2009-01-31 10:33:39 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2009-01-31 10:56:17 -08:00
|
|
|
# include <config.h>
|
2009-01-31 10:33:39 -08:00
|
|
|
#endif
|
|
|
|
|
2010-01-04 15:43:16 -08:00
|
|
|
#include <string.h>
|
2013-01-10 12:26:02 -08:00
|
|
|
#include <sys/types.h>
|
2013-03-15 01:12:05 -07:00
|
|
|
|
2011-05-14 11:30:43 -07:00
|
|
|
#include <Ecore.h>
|
|
|
|
#include <ecore_private.h>
|
|
|
|
#include <Ecore_Con.h>
|
|
|
|
|
2010-01-04 15:43:16 -08:00
|
|
|
#include "Ecore_Ipc.h"
|
2011-05-14 11:30:43 -07:00
|
|
|
#include "ecore_ipc_private.h"
|
2010-01-04 15:43:16 -08:00
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
#define DLT_ZERO 0
|
|
|
|
#define DLT_ONE 1
|
|
|
|
#define DLT_SAME 2
|
|
|
|
#define DLT_SHL 3
|
|
|
|
#define DLT_SHR 4
|
|
|
|
#define DLT_ADD8 5
|
|
|
|
#define DLT_DEL8 6
|
|
|
|
#define DLT_ADDU8 7
|
|
|
|
#define DLT_DELU8 8
|
|
|
|
#define DLT_ADD16 9
|
|
|
|
#define DLT_DEL16 10
|
|
|
|
#define DLT_ADDU16 11
|
|
|
|
#define DLT_DELU16 12
|
|
|
|
#define DLT_SET 13
|
|
|
|
#define DLT_R1 14
|
|
|
|
#define DLT_R2 15
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2016-11-22 11:31:13 -08:00
|
|
|
static int _ecore_ipc_log_dom = -1;
|
2009-12-21 09:32:19 -08:00
|
|
|
|
2013-10-02 02:32:18 -07:00
|
|
|
/****** This swap function are around just for backward compatibility do not remove *******/
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI unsigned short
|
2005-04-08 17:07:32 -07:00
|
|
|
_ecore_ipc_swap_16(unsigned short v)
|
|
|
|
{
|
2013-10-02 02:32:18 -07:00
|
|
|
return eina_swap16(v);
|
2005-04-08 17:07:32 -07:00
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI unsigned int
|
2005-04-08 17:07:32 -07:00
|
|
|
_ecore_ipc_swap_32(unsigned int v)
|
|
|
|
{
|
2013-10-02 02:32:18 -07:00
|
|
|
return eina_swap32(v);
|
2005-04-08 17:07:32 -07:00
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI unsigned long long
|
2005-04-08 17:07:32 -07:00
|
|
|
_ecore_ipc_swap_64(unsigned long long v)
|
|
|
|
{
|
2013-10-02 02:32:18 -07:00
|
|
|
return eina_swap64(v);
|
2005-04-08 17:07:32 -07:00
|
|
|
}
|
2013-10-02 02:32:18 -07:00
|
|
|
/***********************/
|
2005-04-08 17:07:32 -07:00
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
static int _ecore_ipc_dlt_int(int out, int prev, int *mode);
|
|
|
|
static int _ecore_ipc_ddlt_int(int in, int prev, int mode);
|
|
|
|
|
|
|
|
static int
|
|
|
|
_ecore_ipc_dlt_int(int out, int prev, int *mode)
|
|
|
|
{
|
|
|
|
int dlt;
|
|
|
|
|
|
|
|
/* 0 byte */
|
|
|
|
if (out == 0)
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ZERO;
|
|
|
|
return 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
2005-03-01 23:06:44 -08:00
|
|
|
if (out == (int)0xffffffff)
|
2004-04-23 00:24:40 -07:00
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ONE;
|
|
|
|
return 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
if (out == prev)
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_SAME;
|
|
|
|
return 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
if (out == prev << 1)
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_SHL;
|
|
|
|
return 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
if (out == prev >> 1)
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_SHR;
|
|
|
|
return 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
/* 1 byte */
|
|
|
|
dlt = out - prev;
|
|
|
|
if (!(dlt & 0xffffff00))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ADD8;
|
|
|
|
return dlt & 0xff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = prev - out;
|
|
|
|
if (!(dlt & 0xffffff00))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_DEL8;
|
|
|
|
return dlt & 0xff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = out - prev;
|
|
|
|
if (!(dlt & 0x00ffffff))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ADDU8;
|
|
|
|
return (dlt >> 24) & 0xff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = prev - out;
|
|
|
|
if (!(dlt & 0x00ffffff))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_DELU8;
|
|
|
|
return (dlt >> 24) & 0xff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
/* 2 byte */
|
|
|
|
dlt = out - prev;
|
|
|
|
if (!(dlt & 0xffff0000))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ADD16;
|
|
|
|
return dlt & 0xffff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = prev - out;
|
|
|
|
if (!(dlt & 0xffff0000))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_DEL16;
|
|
|
|
return dlt & 0xffff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = out - prev;
|
|
|
|
if (!(dlt & 0x0000ffff))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_ADDU16;
|
|
|
|
return (dlt >> 16) & 0xffff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
dlt = prev - out;
|
|
|
|
if (!(dlt & 0x0000ffff))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
*mode = DLT_DELU16;
|
|
|
|
return (dlt >> 16) & 0xffff;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
/* 4 byte */
|
|
|
|
*mode = DLT_SET;
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_ecore_ipc_ddlt_int(int in, int prev, int mode)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2004-04-23 00:24:40 -07:00
|
|
|
switch (mode)
|
|
|
|
{
|
|
|
|
case DLT_ZERO:
|
2010-09-30 00:35:00 -07:00
|
|
|
return 0;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_ONE:
|
2010-09-30 00:35:00 -07:00
|
|
|
return 0xffffffff;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_SAME:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_SHL:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev << 1;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_SHR:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev >> 1;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_ADD8:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev + in;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_DEL8:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev - in;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_ADDU8:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev + (in << 24);
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_DELU8:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev - (in << 24);
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_ADD16:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev + in;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_DEL16:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev - in;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_ADDU16:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev + (in << 16);
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_DELU16:
|
2010-09-30 00:35:00 -07:00
|
|
|
return prev - (in << 16);
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_SET:
|
2010-09-30 00:35:00 -07:00
|
|
|
return in;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_R1:
|
2010-09-30 00:35:00 -07:00
|
|
|
return 0;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
case DLT_R2:
|
2010-09-30 00:35:00 -07:00
|
|
|
return 0;
|
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
default:
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool _ecore_ipc_event_client_add(void *data, int ev_type, void *ev);
|
|
|
|
static Eina_Bool _ecore_ipc_event_client_del(void *data, int ev_type, void *ev);
|
|
|
|
static Eina_Bool _ecore_ipc_event_server_add(void *data, int ev_type, void *ev);
|
|
|
|
static Eina_Bool _ecore_ipc_event_server_del(void *data, int ev_type, void *ev);
|
|
|
|
static Eina_Bool _ecore_ipc_event_client_data(void *data, int ev_type, void *ev);
|
|
|
|
static Eina_Bool _ecore_ipc_event_server_data(void *data, int ev_type, void *ev);
|
2006-03-19 21:53:12 -08:00
|
|
|
static void _ecore_ipc_event_client_add_free(void *data, void *ev);
|
|
|
|
static void _ecore_ipc_event_client_del_free(void *data, void *ev);
|
2003-09-23 01:09:32 -07:00
|
|
|
static void _ecore_ipc_event_client_data_free(void *data, void *ev);
|
2006-03-19 21:53:12 -08:00
|
|
|
static void _ecore_ipc_event_server_add_free(void *data, void *ev);
|
|
|
|
static void _ecore_ipc_event_server_del_free(void *data, void *ev);
|
2003-09-23 01:09:32 -07:00
|
|
|
static void _ecore_ipc_event_server_data_free(void *data, void *ev);
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int ECORE_IPC_EVENT_CLIENT_ADD = 0;
|
|
|
|
EAPI int ECORE_IPC_EVENT_CLIENT_DEL = 0;
|
|
|
|
EAPI int ECORE_IPC_EVENT_SERVER_ADD = 0;
|
|
|
|
EAPI int ECORE_IPC_EVENT_SERVER_DEL = 0;
|
|
|
|
EAPI int ECORE_IPC_EVENT_CLIENT_DATA = 0;
|
|
|
|
EAPI int ECORE_IPC_EVENT_SERVER_DATA = 0;
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2009-10-09 22:28:43 -07:00
|
|
|
static int _ecore_ipc_init_count = 0;
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
static Eina_List *servers = NULL;
|
2005-09-07 02:24:05 -07:00
|
|
|
static Ecore_Event_Handler *handler[6];
|
2004-08-15 22:17:14 -07:00
|
|
|
|
2016-11-22 17:20:40 -08:00
|
|
|
static void
|
|
|
|
ecore_ipc_post_event_server_add(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Server_Add *ev;
|
|
|
|
|
|
|
|
if (svr->delete_me) return;
|
|
|
|
|
|
|
|
ev = calloc(1, sizeof(Ecore_Ipc_Event_Server_Add));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(ev);
|
|
|
|
|
|
|
|
svr->event_count++;
|
|
|
|
ev->server = svr;
|
|
|
|
ecore_event_add(ECORE_IPC_EVENT_SERVER_ADD, ev,
|
|
|
|
_ecore_ipc_event_server_add_free, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ecore_ipc_post_event_server_del(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Server_Del *ev;
|
|
|
|
|
|
|
|
if (svr->delete_me) return;
|
|
|
|
|
|
|
|
ev = calloc(1, sizeof(Ecore_Ipc_Event_Server_Del));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(ev);
|
|
|
|
|
|
|
|
svr->event_count++;
|
|
|
|
ev->server = svr;
|
|
|
|
ecore_event_add(ECORE_IPC_EVENT_SERVER_DEL, ev,
|
|
|
|
_ecore_ipc_event_server_del_free, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ecore_ipc_post_event_client_add(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Add *ev;
|
|
|
|
|
|
|
|
if (cl->delete_me) return;
|
|
|
|
|
|
|
|
ev = calloc(1, sizeof(Ecore_Ipc_Event_Client_Add));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(ev);
|
|
|
|
|
|
|
|
cl->event_count++;
|
|
|
|
ev->client = cl;
|
|
|
|
ecore_event_add(ECORE_IPC_EVENT_CLIENT_ADD, ev,
|
|
|
|
_ecore_ipc_event_client_add_free, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ecore_ipc_post_event_client_del(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Del *ev;
|
|
|
|
|
|
|
|
if (cl->delete_me) return;
|
|
|
|
|
|
|
|
ev = calloc(1, sizeof(Ecore_Ipc_Event_Client_Del));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(ev);
|
|
|
|
|
|
|
|
cl->event_count++;
|
|
|
|
ev->client = cl;
|
|
|
|
ecore_event_add(ECORE_IPC_EVENT_CLIENT_DEL, ev,
|
|
|
|
_ecore_ipc_event_client_del_free, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Ecore_Ipc_Client *
|
|
|
|
ecore_ipc_client_add(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Client *cl;
|
|
|
|
|
|
|
|
cl = calloc(1, sizeof(Ecore_Ipc_Client));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
|
|
|
|
cl->svr = svr;
|
|
|
|
ECORE_MAGIC_SET(cl, ECORE_MAGIC_IPC_CLIENT);
|
|
|
|
svr->clients = eina_list_append(svr->clients, cl);
|
|
|
|
|
|
|
|
return cl;
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_init(void)
|
|
|
|
{
|
2005-09-07 02:24:05 -07:00
|
|
|
int i = 0;
|
|
|
|
|
2009-10-09 22:28:43 -07:00
|
|
|
if (++_ecore_ipc_init_count != 1)
|
|
|
|
return _ecore_ipc_init_count;
|
2010-10-07 15:31:46 -07:00
|
|
|
_ecore_ipc_log_dom = eina_log_domain_register
|
|
|
|
("ecore_ipc", ECORE_IPC_DEFAULT_LOG_COLOR);
|
2009-12-21 09:32:19 -08:00
|
|
|
if(_ecore_ipc_log_dom < 0)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR("Impossible to create a log domain for the Ecore IPC module.");
|
|
|
|
return --_ecore_ipc_init_count;
|
|
|
|
}
|
2009-10-09 22:28:43 -07:00
|
|
|
if (!ecore_con_init())
|
|
|
|
return --_ecore_ipc_init_count;
|
2005-09-07 02:24:05 -07:00
|
|
|
|
|
|
|
ECORE_IPC_EVENT_CLIENT_ADD = ecore_event_type_new();
|
|
|
|
ECORE_IPC_EVENT_CLIENT_DEL = ecore_event_type_new();
|
|
|
|
ECORE_IPC_EVENT_SERVER_ADD = ecore_event_type_new();
|
|
|
|
ECORE_IPC_EVENT_SERVER_DEL = ecore_event_type_new();
|
|
|
|
ECORE_IPC_EVENT_CLIENT_DATA = ecore_event_type_new();
|
|
|
|
ECORE_IPC_EVENT_SERVER_DATA = ecore_event_type_new();
|
|
|
|
|
|
|
|
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_client_add, NULL);
|
2005-09-07 02:24:05 -07:00
|
|
|
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_client_del, NULL);
|
2005-09-07 02:24:05 -07:00
|
|
|
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_server_add, NULL);
|
2005-09-07 02:24:05 -07:00
|
|
|
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_server_del, NULL);
|
2005-09-07 02:24:05 -07:00
|
|
|
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_client_data, NULL);
|
2009-12-07 13:01:26 -08:00
|
|
|
handler[i] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
|
2010-09-30 00:35:00 -07:00
|
|
|
_ecore_ipc_event_server_data, NULL);
|
2009-10-09 22:28:43 -07:00
|
|
|
return _ecore_ipc_init_count;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_shutdown(void)
|
|
|
|
{
|
2005-09-07 02:24:05 -07:00
|
|
|
int i;
|
|
|
|
|
2009-10-09 22:28:43 -07:00
|
|
|
if (--_ecore_ipc_init_count != 0)
|
|
|
|
return _ecore_ipc_init_count;
|
2005-09-07 02:24:05 -07:00
|
|
|
|
2012-02-12 22:49:30 -08:00
|
|
|
Eina_List *l, *l2;
|
|
|
|
Ecore_Ipc_Server *svr;
|
|
|
|
EINA_LIST_FOREACH_SAFE(servers, l, l2, svr)
|
|
|
|
ecore_ipc_server_del(svr);
|
2005-09-07 02:24:05 -07:00
|
|
|
|
|
|
|
for (i = 0; i < 6; i++)
|
|
|
|
ecore_event_handler_del(handler[i]);
|
|
|
|
|
|
|
|
ecore_con_shutdown();
|
2009-12-21 09:32:19 -08:00
|
|
|
eina_log_domain_unregister(_ecore_ipc_log_dom);
|
|
|
|
_ecore_ipc_log_dom = -1;
|
2009-10-09 22:28:43 -07:00
|
|
|
return _ecore_ipc_init_count;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2016-10-04 05:08:17 -07:00
|
|
|
/* FIXME: need to add protocol type parameter */
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI Ecore_Ipc_Server *
|
2005-03-04 11:29:39 -08:00
|
|
|
ecore_ipc_server_add(Ecore_Ipc_Type compl_type, const char *name, int port, const void *data)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr;
|
2004-04-05 23:20:39 -07:00
|
|
|
Ecore_Ipc_Type type;
|
|
|
|
Ecore_Con_Type extra = 0;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-09-02 23:09:34 -07:00
|
|
|
if (!name) return NULL;
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
svr = calloc(1, sizeof(Ecore_Ipc_Server));
|
|
|
|
if (!svr) return NULL;
|
2004-04-05 23:20:39 -07:00
|
|
|
type = compl_type;
|
|
|
|
type &= ~ECORE_IPC_USE_SSL;
|
|
|
|
if (compl_type & ECORE_IPC_USE_SSL) extra = ECORE_CON_USE_SSL;
|
2003-09-23 01:09:32 -07:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case ECORE_IPC_LOCAL_USER:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_add(ECORE_CON_LOCAL_USER | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
case ECORE_IPC_LOCAL_SYSTEM:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_add(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
case ECORE_IPC_REMOTE_SYSTEM:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_add(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
default:
|
2010-09-30 00:35:00 -07:00
|
|
|
free(svr);
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
if (!svr->legacy_server)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
free(svr);
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2006-03-13 00:50:26 -08:00
|
|
|
svr->max_buf_size = 32 * 1024;
|
2003-09-23 01:09:32 -07:00
|
|
|
svr->data = (void *)data;
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
servers = eina_list_append(servers, svr);
|
2003-09-23 01:09:32 -07:00
|
|
|
ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
|
|
|
|
return svr;
|
|
|
|
}
|
|
|
|
|
2016-11-23 06:17:14 -08:00
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_del(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
DBG("dialer %p del", svr);
|
|
|
|
|
|
|
|
if (svr->dialer.recv_copier)
|
|
|
|
{
|
|
|
|
efl_del(svr->dialer.recv_copier);
|
|
|
|
svr->dialer.recv_copier = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (svr->dialer.send_copier)
|
|
|
|
{
|
|
|
|
efl_del(svr->dialer.send_copier);
|
|
|
|
svr->dialer.send_copier = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (svr->dialer.input)
|
|
|
|
{
|
|
|
|
efl_del(svr->dialer.input);
|
|
|
|
svr->dialer.input = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (svr->dialer.dialer)
|
|
|
|
{
|
|
|
|
efl_del(svr->dialer.dialer);
|
|
|
|
svr->dialer.dialer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_eos(void *data, const Efl_Event *event EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr = data;
|
|
|
|
|
|
|
|
DBG("dialer %p %p eos", svr, svr->dialer.dialer);
|
|
|
|
|
|
|
|
_ecore_ipc_dialer_del(svr);
|
|
|
|
|
|
|
|
ecore_ipc_post_event_server_del(svr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_error(void *data, const Efl_Event *event)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr = data;
|
|
|
|
Eina_Error *perr = event->info;
|
|
|
|
|
|
|
|
WRN("dialer %p %p error %s", svr, svr->dialer.dialer, eina_error_msg_get(*perr));
|
|
|
|
|
|
|
|
if (!efl_io_closer_closed_get(svr->dialer.dialer))
|
|
|
|
efl_io_closer_close(svr->dialer.dialer); /* triggers EOS */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_connected(void *data, const Efl_Event *event EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr = data;
|
|
|
|
|
|
|
|
DBG("connected to %s %s",
|
|
|
|
efl_class_name_get(efl_class_get(svr->dialer.dialer)),
|
|
|
|
efl_net_dialer_address_dial_get(svr->dialer.dialer));
|
|
|
|
|
|
|
|
ecore_ipc_post_event_server_add(svr);
|
|
|
|
}
|
|
|
|
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_ecore_ipc_dialer_cbs,
|
|
|
|
{ EFL_IO_READER_EVENT_EOS, _ecore_ipc_dialer_eos },
|
|
|
|
{ EFL_NET_DIALER_EVENT_ERROR, _ecore_ipc_dialer_error },
|
|
|
|
{ EFL_NET_DIALER_EVENT_CONNECTED, _ecore_ipc_dialer_connected });
|
|
|
|
|
|
|
|
static Eina_Bool ecore_ipc_server_data_process(Ecore_Ipc_Server *svr, void *data, int size, Eina_Bool *stolen);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_copier_data(void *data, const Efl_Event *event EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr = data;
|
|
|
|
Eina_Binbuf *binbuf;
|
|
|
|
uint8_t *mem;
|
|
|
|
int size;
|
|
|
|
Eina_Bool stolen;
|
|
|
|
|
|
|
|
DBG("dialer %p recv_copier %p data", svr, svr->dialer.recv_copier);
|
|
|
|
|
|
|
|
binbuf = efl_io_copier_binbuf_steal(svr->dialer.recv_copier);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(binbuf);
|
|
|
|
size = eina_binbuf_length_get(binbuf);
|
|
|
|
mem = eina_binbuf_string_steal(binbuf);
|
|
|
|
eina_binbuf_free(binbuf);
|
|
|
|
|
|
|
|
ecore_ipc_server_data_process(svr, mem, size, &stolen);
|
|
|
|
if (!stolen) free(mem);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_ecore_ipc_dialer_copier_error(void *data, const Efl_Event *event)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr = data;
|
|
|
|
Eina_Error *perr = event->info;
|
|
|
|
|
|
|
|
WRN("dialer %p %p copier %p error %s", svr, svr->dialer.dialer, event->object, eina_error_msg_get(*perr));
|
|
|
|
|
|
|
|
if (!efl_io_closer_closed_get(svr->dialer.dialer))
|
|
|
|
efl_io_closer_close(svr->dialer.dialer);
|
|
|
|
}
|
|
|
|
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_ecore_ipc_dialer_copier_cbs,
|
|
|
|
{ EFL_IO_COPIER_EVENT_ERROR, _ecore_ipc_dialer_copier_error });
|
|
|
|
|
|
|
|
#ifndef EFL_NET_DIALER_UNIX_CLASS
|
|
|
|
static Ecore_Ipc_Server *
|
|
|
|
ecore_ipc_server_connect_legacy(Ecore_Ipc_Type compl_type, char *name, int port, const void *data)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr;
|
2004-04-05 23:20:39 -07:00
|
|
|
Ecore_Ipc_Type type;
|
|
|
|
Ecore_Con_Type extra = 0;
|
2012-06-04 02:03:04 -07:00
|
|
|
int features;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
svr = calloc(1, sizeof(Ecore_Ipc_Server));
|
|
|
|
if (!svr) return NULL;
|
2012-06-04 02:03:04 -07:00
|
|
|
type = compl_type & ECORE_IPC_TYPE;
|
|
|
|
features = compl_type & ECORE_IPC_SSL;
|
|
|
|
if ((features & ECORE_IPC_USE_SSL) == ECORE_IPC_USE_SSL)
|
|
|
|
extra |= ECORE_CON_USE_SSL;
|
|
|
|
if ((features & ECORE_IPC_NO_PROXY) == ECORE_IPC_NO_PROXY)
|
|
|
|
extra |= ECORE_CON_NO_PROXY;
|
2003-09-23 01:09:32 -07:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case ECORE_IPC_LOCAL_USER:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_connect(ECORE_CON_LOCAL_USER | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
case ECORE_IPC_LOCAL_SYSTEM:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_connect(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
case ECORE_IPC_REMOTE_SYSTEM:
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
break;
|
2003-09-23 01:09:32 -07:00
|
|
|
default:
|
2010-09-30 00:35:00 -07:00
|
|
|
free(svr);
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
if (!svr->legacy_server)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
free(svr);
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2006-03-13 00:50:26 -08:00
|
|
|
svr->max_buf_size = -1;
|
2003-09-23 01:09:32 -07:00
|
|
|
svr->data = (void *)data;
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
servers = eina_list_append(servers, svr);
|
2003-09-23 01:09:32 -07:00
|
|
|
ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
|
|
|
|
return svr;
|
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* FIXME: need to add protocol type parameter */
|
|
|
|
EAPI Ecore_Ipc_Server *
|
|
|
|
ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *data)
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr;
|
|
|
|
Eo *loop = ecore_main_loop_get();
|
|
|
|
char *address = NULL;
|
|
|
|
Eina_Error err;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
|
|
|
|
|
|
|
|
#ifndef EFL_NET_DIALER_UNIX_CLASS
|
|
|
|
if (((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_USER) ||
|
|
|
|
((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM))
|
|
|
|
{
|
|
|
|
DBG("no 'local' Efl.Net.Dialer for your system yet, use legacy Ecore_Con");
|
|
|
|
return ecore_ipc_server_connect_legacy(type, name, port, data);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
svr = calloc(1, sizeof(Ecore_Ipc_Server));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(svr, NULL);
|
|
|
|
|
|
|
|
if (0) { }
|
|
|
|
#ifdef EFL_NET_DIALER_UNIX_CLASS
|
|
|
|
if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_USER)
|
|
|
|
{
|
|
|
|
address = ecore_con_local_path_new(EINA_FALSE, name, port);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
|
|
|
|
|
|
|
|
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, ecore_main_loop_get());
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
|
|
|
|
}
|
|
|
|
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
|
|
|
|
{
|
|
|
|
address = ecore_con_local_path_new(EINA_TRUE, name, port);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
|
|
|
|
|
|
|
|
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, ecore_main_loop_get());
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
|
|
|
|
}
|
|
|
|
#endif /* EFL_NET_DIALER_UNIX_CLASS */
|
|
|
|
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_REMOTE_SYSTEM)
|
|
|
|
{
|
|
|
|
char buf[4096];
|
|
|
|
|
|
|
|
if (port <= 0)
|
|
|
|
{
|
|
|
|
ERR("remote system requires port>=0, got %d", port);
|
|
|
|
goto error_dialer;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "%s:%d", name, port);
|
|
|
|
address = strdup(buf);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
|
|
|
|
|
|
|
|
if ((type & ECORE_IPC_USE_SSL) == ECORE_IPC_USE_SSL)
|
|
|
|
{
|
|
|
|
svr->dialer.dialer = efl_add(EFL_NET_DIALER_SSL_CLASS, loop);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
svr->dialer.dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, loop);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((type & ECORE_IPC_NO_PROXY) == ECORE_IPC_NO_PROXY)
|
|
|
|
efl_net_dialer_proxy_set(svr->dialer.dialer, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ERR("IPC Type must be one of: local_user, local_system or remote_system");
|
|
|
|
goto error_dialer;
|
|
|
|
}
|
|
|
|
|
|
|
|
efl_io_closer_close_on_destructor_set(svr->dialer.dialer, EINA_TRUE);
|
|
|
|
efl_event_callback_array_add(svr->dialer.dialer, _ecore_ipc_dialer_cbs(), svr);
|
|
|
|
|
|
|
|
svr->dialer.input = efl_add(EFL_IO_QUEUE_CLASS, loop);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.input, error);
|
|
|
|
|
|
|
|
svr->dialer.send_copier = efl_add(EFL_IO_COPIER_CLASS, loop,
|
|
|
|
efl_io_closer_close_on_destructor_set(efl_added, EINA_FALSE),
|
|
|
|
efl_io_copier_source_set(efl_added, svr->dialer.input),
|
|
|
|
efl_io_copier_destination_set(efl_added, svr->dialer.dialer),
|
|
|
|
efl_event_callback_array_add(efl_added, _ecore_ipc_dialer_copier_cbs(), svr));
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.send_copier, error);
|
|
|
|
|
|
|
|
svr->dialer.recv_copier = efl_add(EFL_IO_COPIER_CLASS, loop,
|
|
|
|
efl_io_closer_close_on_destructor_set(efl_added, EINA_FALSE),
|
|
|
|
efl_io_copier_source_set(efl_added, svr->dialer.dialer),
|
|
|
|
efl_event_callback_array_add(efl_added, _ecore_ipc_dialer_copier_cbs(), svr),
|
|
|
|
efl_event_callback_add(efl_added, EFL_IO_COPIER_EVENT_DATA, _ecore_ipc_dialer_copier_data, svr));
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.recv_copier, error);
|
|
|
|
|
|
|
|
err = efl_net_dialer_dial(svr->dialer.dialer, address);
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
WRN("Could not reach %s %s: %s",
|
|
|
|
efl_class_name_get(efl_class_get(svr->dialer.dialer)),
|
|
|
|
address, eina_error_msg_get(err));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DBG("connecting %p %s address='%s'",
|
|
|
|
svr->dialer.dialer,
|
|
|
|
efl_class_name_get(efl_class_get(svr->dialer.dialer)),
|
|
|
|
address);
|
|
|
|
|
2016-11-23 11:38:18 -08:00
|
|
|
svr->max_buf_size = -1;
|
2016-11-23 06:17:14 -08:00
|
|
|
svr->data = (void *)data;
|
|
|
|
servers = eina_list_append(servers, svr);
|
|
|
|
ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
|
|
|
|
free(address);
|
|
|
|
return svr;
|
|
|
|
|
|
|
|
error:
|
|
|
|
free(address);
|
|
|
|
_ecore_ipc_dialer_del(svr);
|
|
|
|
free(svr);
|
|
|
|
return NULL; /* dialer will trigger all cleanup on its own callbacks */
|
|
|
|
|
|
|
|
error_dialer:
|
|
|
|
free(svr);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void *
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_server_del(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
2012-12-24 01:35:56 -08:00
|
|
|
if (!svr) return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_del");
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
data = svr->data;
|
2006-03-19 21:59:21 -08:00
|
|
|
svr->data = NULL;
|
2006-06-02 01:06:46 -07:00
|
|
|
svr->delete_me = 1;
|
|
|
|
if (svr->event_count == 0)
|
2007-08-26 04:17:21 -07:00
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
Ecore_Ipc_Client *cl;
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
|
2010-09-30 00:35:00 -07:00
|
|
|
EINA_LIST_FREE(svr->clients, cl)
|
2016-07-11 06:29:04 -07:00
|
|
|
{
|
|
|
|
cl->svr = NULL;
|
|
|
|
ecore_ipc_client_del(cl);
|
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
|
|
|
|
if (svr->dialer.dialer) _ecore_ipc_dialer_del(svr);
|
2016-11-23 11:09:18 -08:00
|
|
|
if (svr->legacy_server) ecore_con_server_del(svr->legacy_server);
|
2010-09-30 00:35:00 -07:00
|
|
|
servers = eina_list_remove(servers, svr);
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
|
2010-09-30 00:35:00 -07:00
|
|
|
if (svr->buf) free(svr->buf);
|
|
|
|
ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
|
2016-11-23 06:17:14 -08:00
|
|
|
DBG("server %p freed", svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
free(svr);
|
2006-03-19 21:53:12 -08:00
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
else DBG("server %p has %d events pending, postpone deletion", svr, svr->event_count);
|
2003-09-23 01:09:32 -07:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void *
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_server_data_get(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_data_get");
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
return svr->data;
|
|
|
|
}
|
|
|
|
|
2010-09-20 18:58:54 -07:00
|
|
|
EAPI Eina_Bool
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_server_connected_get(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_connected_get");
|
|
|
|
return EINA_FALSE;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
|
|
|
|
if (svr->dialer.dialer)
|
|
|
|
return efl_net_dialer_connected_get(svr->dialer.dialer);
|
2016-11-23 11:09:18 -08:00
|
|
|
else if (!svr->legacy_server) return EINA_FALSE;
|
2016-11-23 06:17:14 -08:00
|
|
|
|
2016-11-23 11:09:18 -08:00
|
|
|
return ecore_con_server_connected_get(svr->legacy_server);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
* estickies,
* etk,
* PROTO/exalt,
* E-MODULES-EXTRA/diskio,
* E-MODULES-EXTRA/drawer,
* E-MODULES-EXTRA/penguins,
* E-MODULES-EXTRA/slideshow,
* E-MODULES-EXTRA/mail,
* E-MODULES-EXTRA/forecasts,
* E-MODULES-EXTRA/iiirk,
* E-MODULES-EXTRA/places,
* e,
* ewl,
* ecore,
* elitaire,
* entrance,
* e_dbus,
* efreet: Here we go, move from Ecore_List to Eina_List.
NOTE: This patch is huge, I did test it a lot, and I hope nothing is
broken. But if you think something change after this commit, please
contact me ASAP.
SVN revision: 39200
2009-02-25 03:03:47 -08:00
|
|
|
EAPI Eina_List *
|
2006-03-30 00:12:17 -08:00
|
|
|
ecore_ipc_server_clients_get(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_clients_get");
|
|
|
|
return NULL;
|
2006-03-30 00:12:17 -08:00
|
|
|
}
|
2012-08-29 02:08:30 -07:00
|
|
|
return svr->clients;
|
2006-03-30 00:12:17 -08:00
|
|
|
}
|
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
#define SVENC(_member) \
|
|
|
|
d = _ecore_ipc_dlt_int(msg._member, svr->prev.o._member, &md); \
|
|
|
|
if (md >= DLT_SET) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned int v; \
|
|
|
|
unsigned char *dd; \
|
|
|
|
dd = (unsigned char *)&v; \
|
|
|
|
v = d; \
|
|
|
|
v = htonl(v); \
|
|
|
|
*(dat + s + 0) = dd[0]; \
|
|
|
|
*(dat + s + 1) = dd[1]; \
|
|
|
|
*(dat + s + 2) = dd[2]; \
|
|
|
|
*(dat + s + 3) = dd[3]; \
|
|
|
|
s += 4; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD16) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned short v; \
|
|
|
|
unsigned char *dd; \
|
|
|
|
dd = (unsigned char *)&v; \
|
|
|
|
v = d; \
|
|
|
|
v = htons(v); \
|
|
|
|
*(dat + s + 0) = dd[0]; \
|
|
|
|
*(dat + s + 1) = dd[1]; \
|
|
|
|
s += 2; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD8) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
*(dat + s + 0) = (unsigned char)d; \
|
|
|
|
s += 1; \
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
|
2016-10-04 05:08:17 -07:00
|
|
|
/* FIXME: this needs to become an ipc message */
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int
|
2007-10-21 08:16:14 -07:00
|
|
|
ecore_ipc_server_send(Ecore_Ipc_Server *svr, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Msg_Head msg;
|
|
|
|
int ret;
|
2004-04-23 00:24:40 -07:00
|
|
|
int *head, md = 0, d, s;
|
|
|
|
unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_send");
|
|
|
|
return 0;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
if (size < 0) size = 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
msg.major = major;
|
|
|
|
msg.minor = minor;
|
|
|
|
msg.ref = ref;
|
|
|
|
msg.ref_to = ref_to;
|
|
|
|
msg.response = response;
|
|
|
|
msg.size = size;
|
|
|
|
head = (int *)dat;
|
|
|
|
s = 4;
|
|
|
|
SVENC(major);
|
|
|
|
*head = md;
|
|
|
|
SVENC(minor);
|
|
|
|
*head |= md << (4 * 1);
|
|
|
|
SVENC(ref);
|
|
|
|
*head |= md << (4 * 2);
|
|
|
|
SVENC(ref_to);
|
|
|
|
*head |= md << (4 * 3);
|
|
|
|
SVENC(response);
|
|
|
|
*head |= md << (4 * 4);
|
|
|
|
SVENC(size);
|
|
|
|
*head |= md << (4 * 5);
|
|
|
|
*head = htonl(*head);
|
|
|
|
svr->prev.o = msg;
|
2016-11-23 06:17:14 -08:00
|
|
|
|
|
|
|
if (svr->dialer.input)
|
|
|
|
{
|
|
|
|
Eina_Slice slice;
|
|
|
|
Eina_Error err;
|
|
|
|
|
|
|
|
slice.mem = dat;
|
|
|
|
slice.len = s;
|
|
|
|
err = efl_io_writer_write(svr->dialer.input, &slice, NULL);
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
ERR("could not write queue=%p %zd bytes: %s",
|
|
|
|
svr->dialer.input, slice.len, eina_error_msg_get(err));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (slice.len < (size_t)s)
|
|
|
|
{
|
|
|
|
ERR("only wrote %zd of %d bytes to queue %p",
|
|
|
|
slice.len, s, svr->dialer.input);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
slice.mem = data;
|
|
|
|
slice.len = size;
|
|
|
|
err = efl_io_writer_write(svr->dialer.input, &slice, NULL);
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
ERR("could not write queue=%p %zd bytes: %s",
|
|
|
|
svr->dialer.input, slice.len, eina_error_msg_get(err));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (slice.len < (size_t)size)
|
|
|
|
{
|
|
|
|
ERR("only wrote %zd of %d bytes to queue %p",
|
|
|
|
slice.len, size, svr->dialer.input);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s + size;
|
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
else if (!svr->legacy_server) return 0;
|
2016-11-23 06:17:14 -08:00
|
|
|
|
2016-11-23 11:09:18 -08:00
|
|
|
ret = ecore_con_server_send(svr->legacy_server, dat, s);
|
|
|
|
if (size > 0) ret += ecore_con_server_send(svr->legacy_server, data, size);
|
2003-09-23 01:09:32 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void
|
2005-04-28 21:58:55 -07:00
|
|
|
ecore_ipc_server_client_limit_set(Ecore_Ipc_Server *svr, int client_limit, char reject_excess_clients)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_client_limit_set");
|
|
|
|
return;
|
2005-04-28 21:58:55 -07:00
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
ecore_con_server_client_limit_set(svr->legacy_server, client_limit, reject_excess_clients);
|
2005-04-28 21:58:55 -07:00
|
|
|
}
|
|
|
|
|
2006-03-13 00:50:26 -08:00
|
|
|
EAPI void
|
|
|
|
ecore_ipc_server_data_size_max_set(Ecore_Ipc_Server *svr, int size)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_data_size_max_set");
|
|
|
|
return;
|
2006-03-13 00:50:26 -08:00
|
|
|
}
|
|
|
|
svr->max_buf_size = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
ecore_ipc_server_data_size_max_get(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_data_size_max_get");
|
|
|
|
return -1;
|
2006-03-13 00:50:26 -08:00
|
|
|
}
|
|
|
|
return svr->max_buf_size;
|
|
|
|
}
|
|
|
|
|
2010-07-28 17:12:27 -07:00
|
|
|
EAPI const char *
|
2006-03-19 23:45:58 -08:00
|
|
|
ecore_ipc_server_ip_get(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_ip_get");
|
|
|
|
return NULL;
|
2006-03-19 23:45:58 -08:00
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
|
|
|
|
if (svr->dialer.dialer)
|
|
|
|
{
|
|
|
|
if (efl_isa(svr->dialer.dialer, EFL_NET_DIALER_TCP_CLASS) ||
|
|
|
|
efl_isa(svr->dialer.dialer, EFL_NET_DIALER_SSL_CLASS))
|
|
|
|
return efl_net_dialer_address_dial_get(svr->dialer.dialer);
|
|
|
|
/* original IPC just returned IP for remote connections */
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
else if (!svr->legacy_server) return NULL;
|
2016-11-23 06:17:14 -08:00
|
|
|
|
2016-11-23 11:09:18 -08:00
|
|
|
return ecore_con_server_ip_get(svr->legacy_server);
|
2006-03-19 23:45:58 -08:00
|
|
|
}
|
|
|
|
|
2007-02-16 10:12:38 -08:00
|
|
|
EAPI void
|
|
|
|
ecore_ipc_server_flush(Ecore_Ipc_Server *svr)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
|
|
|
|
"ecore_ipc_server_server_flush");
|
|
|
|
return;
|
2007-02-16 10:12:38 -08:00
|
|
|
}
|
2016-11-23 06:17:14 -08:00
|
|
|
if (svr->dialer.input)
|
|
|
|
{
|
|
|
|
while (efl_io_queue_usage_get(svr->dialer.input) > 0)
|
|
|
|
efl_io_copier_flush(svr->dialer.send_copier);
|
|
|
|
return;
|
|
|
|
}
|
2016-11-23 11:09:18 -08:00
|
|
|
else if (!svr->legacy_server) return;
|
2016-11-23 06:17:14 -08:00
|
|
|
|
2016-11-23 11:09:18 -08:00
|
|
|
ecore_con_server_flush(svr->legacy_server);
|
2007-02-16 10:12:38 -08:00
|
|
|
}
|
2006-03-13 00:50:26 -08:00
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
#define CLENC(_member) \
|
|
|
|
d = _ecore_ipc_dlt_int(msg._member, cl->prev.o._member, &md); \
|
|
|
|
if (md >= DLT_SET) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned int v; \
|
|
|
|
unsigned char *dd; \
|
|
|
|
dd = (unsigned char *)&v; \
|
|
|
|
v = d; \
|
|
|
|
v = htonl(v); \
|
|
|
|
*(dat + s + 0) = dd[0]; \
|
|
|
|
*(dat + s + 1) = dd[1]; \
|
|
|
|
*(dat + s + 2) = dd[2]; \
|
|
|
|
*(dat + s + 3) = dd[3]; \
|
|
|
|
s += 4; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD16) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned short v; \
|
|
|
|
unsigned char *dd; \
|
|
|
|
dd = (unsigned char *)&v; \
|
|
|
|
v = d; \
|
|
|
|
v = htons(v); \
|
|
|
|
*(dat + s + 0) = dd[0]; \
|
|
|
|
*(dat + s + 1) = dd[1]; \
|
|
|
|
s += 2; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD8) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
*(dat + s) = (unsigned char)d; \
|
|
|
|
s += 1; \
|
2004-04-23 00:24:40 -07:00
|
|
|
}
|
|
|
|
|
2016-10-04 05:08:17 -07:00
|
|
|
/* FIXME: this needs to become an ipc message */
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int
|
2007-10-21 08:16:14 -07:00
|
|
|
ecore_ipc_client_send(Ecore_Ipc_Client *cl, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Msg_Head msg;
|
|
|
|
int ret;
|
2004-04-23 00:24:40 -07:00
|
|
|
int *head, md = 0, d, s;
|
|
|
|
unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_send");
|
|
|
|
return 0;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2012-06-06 02:49:24 -07:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(!cl->client, 0);
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(!ecore_con_client_connected_get(cl->client), 0);
|
2003-09-23 01:09:32 -07:00
|
|
|
if (size < 0) size = 0;
|
2004-04-23 00:24:40 -07:00
|
|
|
msg.major = major;
|
|
|
|
msg.minor = minor;
|
|
|
|
msg.ref = ref;
|
|
|
|
msg.ref_to = ref_to;
|
|
|
|
msg.response = response;
|
|
|
|
msg.size = size;
|
|
|
|
head = (int *)dat;
|
|
|
|
s = 4;
|
|
|
|
CLENC(major);
|
|
|
|
*head = md;
|
|
|
|
CLENC(minor);
|
|
|
|
*head |= md << (4 * 1);
|
|
|
|
CLENC(ref);
|
|
|
|
*head |= md << (4 * 2);
|
|
|
|
CLENC(ref_to);
|
|
|
|
*head |= md << (4 * 3);
|
|
|
|
CLENC(response);
|
|
|
|
*head |= md << (4 * 4);
|
|
|
|
CLENC(size);
|
|
|
|
*head |= md << (4 * 5);
|
|
|
|
*head = htonl(*head);
|
|
|
|
cl->prev.o = msg;
|
|
|
|
ret = ecore_con_client_send(cl->client, dat, s);
|
|
|
|
if (size > 0) ret += ecore_con_client_send(cl->client, data, size);
|
2003-09-23 01:09:32 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI Ecore_Ipc_Server *
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_client_server_get(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_server_get");
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2012-06-06 02:49:24 -07:00
|
|
|
return cl->svr;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void *
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_client_del(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
Ecore_Ipc_Server *svr;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-12-24 01:35:56 -08:00
|
|
|
if (!cl) return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_del");
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
data = cl->data;
|
2006-03-19 21:59:21 -08:00
|
|
|
cl->data = NULL;
|
2006-06-02 01:06:46 -07:00
|
|
|
cl->delete_me = 1;
|
|
|
|
if (cl->event_count == 0)
|
2006-03-19 21:53:12 -08:00
|
|
|
{
|
2012-06-06 02:49:24 -07:00
|
|
|
svr = cl->svr;
|
|
|
|
if (cl->client) ecore_con_client_del(cl->client);
|
2016-07-11 06:29:04 -07:00
|
|
|
if (ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
|
|
|
|
svr->clients = eina_list_remove(svr->clients, cl);
|
2010-09-30 00:35:00 -07:00
|
|
|
if (cl->buf) free(cl->buf);
|
|
|
|
ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
|
|
|
|
free(cl);
|
2006-03-19 21:53:12 -08:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_client_data_set(Ecore_Ipc_Client *cl, const void *data)
|
2007-08-26 04:17:21 -07:00
|
|
|
{
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_data_set");
|
|
|
|
return;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
cl->data = (void *)data;
|
2007-08-26 04:17:21 -07:00
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI void *
|
2003-09-23 01:09:32 -07:00
|
|
|
ecore_ipc_client_data_get(Ecore_Ipc_Client *cl)
|
2007-08-26 04:17:21 -07:00
|
|
|
{
|
2003-09-23 01:09:32 -07:00
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_data_get");
|
|
|
|
return NULL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
return cl->data;
|
|
|
|
}
|
|
|
|
|
2006-03-13 00:50:26 -08:00
|
|
|
EAPI void
|
|
|
|
ecore_ipc_client_data_size_max_set(Ecore_Ipc_Client *cl, int size)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_data_size_max_set");
|
|
|
|
return;
|
2006-03-13 00:50:26 -08:00
|
|
|
}
|
|
|
|
cl->max_buf_size = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
ecore_ipc_client_data_size_max_get(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_data_size_max_get");
|
|
|
|
return -1;
|
2006-03-13 00:50:26 -08:00
|
|
|
}
|
|
|
|
return cl->max_buf_size;
|
|
|
|
}
|
|
|
|
|
2010-07-28 17:12:27 -07:00
|
|
|
EAPI const char *
|
2006-03-19 23:45:58 -08:00
|
|
|
ecore_ipc_client_ip_get(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_ip_get");
|
|
|
|
return NULL;
|
2006-03-19 23:45:58 -08:00
|
|
|
}
|
|
|
|
return ecore_con_client_ip_get(cl->client);
|
|
|
|
}
|
|
|
|
|
2007-02-16 10:12:38 -08:00
|
|
|
EAPI void
|
|
|
|
ecore_ipc_client_flush(Ecore_Ipc_Client *cl)
|
|
|
|
{
|
|
|
|
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
|
|
|
|
"ecore_ipc_client_flush");
|
|
|
|
return;
|
2007-02-16 10:12:38 -08:00
|
|
|
}
|
|
|
|
ecore_con_client_flush(cl->client);
|
|
|
|
}
|
|
|
|
|
2006-01-06 10:26:37 -08:00
|
|
|
EAPI int
|
2004-10-21 20:41:49 -07:00
|
|
|
ecore_ipc_ssl_available_get(void)
|
|
|
|
{
|
|
|
|
return ecore_con_ssl_available_get();
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_client_add(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Con_Event_Client_Add *e;
|
2012-06-06 02:49:24 -07:00
|
|
|
Ecore_Ipc_Server *svr;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
2012-06-06 02:49:24 -07:00
|
|
|
svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
|
|
|
|
if (!eina_list_data_find(servers, svr)) return ECORE_CALLBACK_RENEW;
|
2003-09-23 01:09:32 -07:00
|
|
|
/* handling code here */
|
|
|
|
{
|
2016-11-22 17:20:40 -08:00
|
|
|
Ecore_Ipc_Client *cl = ecore_ipc_client_add(svr);
|
2010-09-30 00:35:00 -07:00
|
|
|
|
|
|
|
if (!cl) return ECORE_CALLBACK_CANCEL;
|
|
|
|
cl->client = e->client;
|
|
|
|
cl->max_buf_size = 32 * 1024;
|
|
|
|
ecore_con_client_data_set(cl->client, (void *)cl);
|
2016-11-22 17:20:40 -08:00
|
|
|
|
|
|
|
ecore_ipc_post_event_client_add(cl);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_client_del(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Con_Event_Client_Del *e;
|
2012-06-06 02:49:24 -07:00
|
|
|
Ecore_Ipc_Server *svr;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
2012-06-06 02:49:24 -07:00
|
|
|
if (!e->client) return ECORE_CALLBACK_RENEW;
|
|
|
|
svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
|
|
|
|
if (!eina_list_data_find(servers, svr)) return ECORE_CALLBACK_RENEW;
|
2003-09-23 01:09:32 -07:00
|
|
|
/* handling code here */
|
|
|
|
{
|
2010-09-30 00:35:00 -07:00
|
|
|
Ecore_Ipc_Client *cl;
|
|
|
|
|
|
|
|
cl = ecore_con_client_data_get(e->client);
|
2016-11-23 06:14:57 -08:00
|
|
|
if (!eina_list_data_find(svr->clients, cl)) return ECORE_CALLBACK_RENEW;
|
2012-06-06 02:49:24 -07:00
|
|
|
cl->client = NULL;
|
2016-11-22 17:20:40 -08:00
|
|
|
|
|
|
|
ecore_ipc_post_event_client_del(cl);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_server_add(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Con_Event_Server_Add *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
2010-12-12 23:26:21 -08:00
|
|
|
if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
|
2003-09-23 01:09:32 -07:00
|
|
|
/* handling code here */
|
|
|
|
{
|
2010-12-12 23:26:21 -08:00
|
|
|
Ecore_Ipc_Server *svr;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-12-12 23:26:21 -08:00
|
|
|
svr = ecore_con_server_data_get(e->server);
|
2016-11-22 17:20:40 -08:00
|
|
|
|
|
|
|
ecore_ipc_post_event_server_add(svr);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_server_del(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Con_Event_Server_Del *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
2010-12-12 23:26:21 -08:00
|
|
|
if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
|
2003-09-23 01:09:32 -07:00
|
|
|
/* handling code here */
|
|
|
|
{
|
2010-12-12 23:26:21 -08:00
|
|
|
Ecore_Ipc_Server *svr;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-12-12 23:26:21 -08:00
|
|
|
svr = ecore_con_server_data_get(e->server);
|
2016-11-23 11:09:18 -08:00
|
|
|
svr->legacy_server = NULL;
|
2016-11-22 17:20:40 -08:00
|
|
|
|
|
|
|
ecore_ipc_post_event_server_del(svr);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
#define CLSZ(_n) \
|
|
|
|
md = ((head >> (4 * _n)) & 0xf); \
|
|
|
|
if (md >= DLT_SET) s += 4; \
|
|
|
|
else if (md >= DLT_ADD16) s += 2; \
|
|
|
|
else if (md >= DLT_ADD8) s += 1;
|
|
|
|
|
|
|
|
#define CLDEC(_n, _member) \
|
|
|
|
md = ((head >> (4 * _n)) & 0xf); \
|
|
|
|
if (md >= DLT_SET) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned int v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(cl->buf + offset + s + 0); \
|
|
|
|
dv[1] = *(cl->buf + offset + s + 1); \
|
|
|
|
dv[2] = *(cl->buf + offset + s + 2); \
|
|
|
|
dv[3] = *(cl->buf + offset + s + 3); \
|
|
|
|
d = (int)ntohl(v); \
|
|
|
|
s += 4; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD16) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned short v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(cl->buf + offset + s + 0); \
|
|
|
|
dv[1] = *(cl->buf + offset + s + 1); \
|
|
|
|
d = (int)ntohs(v); \
|
|
|
|
s += 2; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD8) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned char v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(cl->buf + offset + s + 0); \
|
|
|
|
d = (int)v; \
|
|
|
|
s += 1; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
msg._member = _ecore_ipc_ddlt_int(d, cl->prev.i._member, md);
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2016-11-22 18:01:14 -08:00
|
|
|
ecore_ipc_client_data_process(Ecore_Ipc_Client *cl, void *data, int size, Eina_Bool *stolen)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2016-11-22 18:01:14 -08:00
|
|
|
/* use e->data and e->size to reduce diff to original code */
|
|
|
|
struct { void *data; int size; } _e = { data, size }, *e = &_e;
|
|
|
|
Ecore_Ipc_Server *svr = ecore_ipc_client_server_get(cl);
|
|
|
|
*stolen = EINA_FALSE;
|
|
|
|
if (1)
|
|
|
|
{ /* keep same identation as original code to help verification */
|
2010-09-30 00:35:00 -07:00
|
|
|
Ecore_Ipc_Msg_Head msg;
|
|
|
|
int offset = 0;
|
|
|
|
unsigned char *buf;
|
|
|
|
|
|
|
|
if (!cl->buf)
|
|
|
|
{
|
|
|
|
cl->buf_size = e->size;
|
|
|
|
cl->buf = e->data;
|
2016-11-22 18:01:14 -08:00
|
|
|
*stolen = EINA_TRUE;
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf = realloc(cl->buf, cl->buf_size + e->size);
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
free(cl->buf);
|
|
|
|
cl->buf = 0;
|
|
|
|
cl->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
cl->buf = buf;
|
|
|
|
memcpy(cl->buf + cl->buf_size, e->data, e->size);
|
|
|
|
cl->buf_size += e->size;
|
|
|
|
}
|
|
|
|
/* examine header */
|
|
|
|
redo:
|
|
|
|
if ((cl->buf_size - offset) >= (int)sizeof(int))
|
|
|
|
{
|
|
|
|
int s, md, d = 0, head;
|
|
|
|
unsigned char *dd;
|
|
|
|
|
|
|
|
dd = (unsigned char *)&head;
|
|
|
|
dd[0] = *(cl->buf + offset + 0);
|
|
|
|
dd[1] = *(cl->buf + offset + 1);
|
|
|
|
dd[2] = *(cl->buf + offset + 2);
|
|
|
|
dd[3] = *(cl->buf + offset + 3);
|
|
|
|
head = ntohl(head);
|
|
|
|
dd = (unsigned char *)&d;
|
|
|
|
s = 4;
|
|
|
|
CLSZ(0);
|
|
|
|
CLSZ(1);
|
|
|
|
CLSZ(2);
|
|
|
|
CLSZ(3);
|
|
|
|
CLSZ(4);
|
|
|
|
CLSZ(5);
|
|
|
|
if ((cl->buf_size - offset) < s)
|
|
|
|
{
|
|
|
|
if (offset > 0) goto scroll;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = 4;
|
|
|
|
CLDEC(0, major);
|
|
|
|
CLDEC(1, minor);
|
|
|
|
CLDEC(2, ref);
|
|
|
|
CLDEC(3, ref_to);
|
|
|
|
CLDEC(4, response);
|
|
|
|
CLDEC(5, size);
|
|
|
|
if (msg.size < 0) msg.size = 0;
|
|
|
|
/* there is enough data in the buffer for a full message */
|
|
|
|
if ((cl->buf_size - offset) >= (s + msg.size))
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Data *e2;
|
|
|
|
int max, max2;
|
|
|
|
|
|
|
|
buf = NULL;
|
|
|
|
max = svr->max_buf_size;
|
|
|
|
max2 = cl->max_buf_size;
|
|
|
|
if ((max >= 0) && (max2 >= 0))
|
|
|
|
{
|
|
|
|
if (max2 < max) max = max2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (max < 0) max = max2;
|
|
|
|
}
|
|
|
|
if ((max < 0) || (msg.size <= max))
|
|
|
|
{
|
2014-12-11 19:05:36 -08:00
|
|
|
Eina_Bool need_free = EINA_FALSE;
|
2010-09-30 00:35:00 -07:00
|
|
|
if (msg.size > 0)
|
|
|
|
{
|
|
|
|
buf = malloc(msg.size);
|
|
|
|
if (!buf) return ECORE_CALLBACK_CANCEL;
|
|
|
|
memcpy(buf, cl->buf + offset + s, msg.size);
|
2014-12-11 19:05:36 -08:00
|
|
|
need_free = EINA_TRUE;
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
if (!cl->delete_me)
|
|
|
|
{
|
|
|
|
e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Data));
|
|
|
|
if (e2)
|
|
|
|
{
|
|
|
|
cl->event_count++;
|
|
|
|
e2->client = cl;
|
|
|
|
e2->major = msg.major;
|
|
|
|
e2->minor = msg.minor;
|
|
|
|
e2->ref = msg.ref;
|
|
|
|
e2->ref_to = msg.ref_to;
|
|
|
|
e2->response = msg.response;
|
|
|
|
e2->size = msg.size;
|
|
|
|
e2->data = buf;
|
|
|
|
ecore_event_add(ECORE_IPC_EVENT_CLIENT_DATA, e2,
|
|
|
|
_ecore_ipc_event_client_data_free,
|
|
|
|
NULL);
|
2014-12-11 19:05:36 -08:00
|
|
|
need_free = EINA_FALSE;
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
}
|
2014-12-11 19:05:36 -08:00
|
|
|
if (need_free) free(buf);
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
cl->prev.i = msg;
|
|
|
|
offset += (s + msg.size);
|
|
|
|
if (cl->buf_size == offset)
|
|
|
|
{
|
|
|
|
free(cl->buf);
|
|
|
|
cl->buf = NULL;
|
|
|
|
cl->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
else goto scroll;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
scroll:
|
|
|
|
buf = malloc(cl->buf_size - offset);
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
free(cl->buf);
|
|
|
|
cl->buf = NULL;
|
|
|
|
cl->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
memcpy(buf, cl->buf + offset, cl->buf_size - offset);
|
|
|
|
free(cl->buf);
|
|
|
|
cl->buf = buf;
|
|
|
|
cl->buf_size -= offset;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2016-11-22 18:01:14 -08:00
|
|
|
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_ecore_ipc_event_client_data(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
|
|
|
{
|
|
|
|
Ecore_Con_Event_Client_Data *e;
|
|
|
|
Ecore_Ipc_Server *svr;
|
|
|
|
|
|
|
|
e = ev;
|
|
|
|
svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
|
|
|
|
if (!eina_list_data_find(servers, svr)) return ECORE_CALLBACK_RENEW;
|
|
|
|
/* handling code here */
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Client *cl;
|
|
|
|
Eina_Bool stolen;
|
|
|
|
|
|
|
|
cl = ecore_con_client_data_get(e->client);
|
|
|
|
|
|
|
|
ecore_ipc_client_data_process(cl, e->data, e->size, &stolen);
|
|
|
|
if (stolen)
|
|
|
|
{
|
|
|
|
e->data = NULL;
|
|
|
|
e->size = 0;
|
|
|
|
}
|
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2004-04-23 00:24:40 -07:00
|
|
|
#define SVSZ(_n) \
|
|
|
|
md = ((head >> (4 * _n)) & 0xf); \
|
|
|
|
if (md >= DLT_SET) s += 4; \
|
|
|
|
else if (md >= DLT_ADD16) s += 2; \
|
|
|
|
else if (md >= DLT_ADD8) s += 1;
|
|
|
|
|
|
|
|
#define SVDEC(_n, _member) \
|
|
|
|
md = ((head >> (4 * _n)) & 0xf); \
|
|
|
|
if (md >= DLT_SET) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned int v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(svr->buf + offset + s + 0); \
|
|
|
|
dv[1] = *(svr->buf + offset + s + 1); \
|
|
|
|
dv[2] = *(svr->buf + offset + s + 2); \
|
|
|
|
dv[3] = *(svr->buf + offset + s + 3); \
|
|
|
|
d = (int)ntohl(v); \
|
|
|
|
s += 4; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD16) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned short v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(svr->buf + offset + s + 0); \
|
|
|
|
dv[1] = *(svr->buf + offset + s + 1); \
|
|
|
|
d = (int)ntohs(v); \
|
|
|
|
s += 2; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
else if (md >= DLT_ADD8) \
|
|
|
|
{ \
|
2010-09-30 00:35:00 -07:00
|
|
|
unsigned char v; \
|
|
|
|
unsigned char *dv; \
|
|
|
|
dv = (unsigned char *)&v; \
|
|
|
|
dv[0] = *(svr->buf + offset + s + 0); \
|
|
|
|
d = (int)v; \
|
|
|
|
s += 1; \
|
2004-04-23 00:24:40 -07:00
|
|
|
} \
|
|
|
|
msg._member = _ecore_ipc_ddlt_int(d, svr->prev.i._member, md);
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2016-11-22 17:55:57 -08:00
|
|
|
ecore_ipc_server_data_process(Ecore_Ipc_Server *svr, void *data, int size, Eina_Bool *stolen)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2016-11-22 17:55:57 -08:00
|
|
|
/* use e->data and e->size to reduce diff to original code */
|
|
|
|
struct { void *data; int size; } _e = { data, size }, *e = &_e;
|
|
|
|
*stolen = EINA_FALSE;
|
|
|
|
if (1)
|
|
|
|
{ /* keep same identation as original code to help verification */
|
2010-09-30 00:35:00 -07:00
|
|
|
Ecore_Ipc_Msg_Head msg;
|
|
|
|
int offset = 0;
|
2013-07-08 08:08:14 -07:00
|
|
|
unsigned char *buf = NULL;
|
2010-09-30 00:35:00 -07:00
|
|
|
|
|
|
|
if (!svr->buf)
|
|
|
|
{
|
|
|
|
svr->buf_size = e->size;
|
|
|
|
svr->buf = e->data;
|
2016-11-22 17:55:57 -08:00
|
|
|
*stolen = EINA_TRUE;
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf = realloc(svr->buf, svr->buf_size + e->size);
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
free(svr->buf);
|
|
|
|
svr->buf = 0;
|
|
|
|
svr->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
svr->buf = buf;
|
|
|
|
memcpy(svr->buf + svr->buf_size, e->data, e->size);
|
|
|
|
svr->buf_size += e->size;
|
|
|
|
}
|
|
|
|
/* examine header */
|
|
|
|
redo:
|
|
|
|
if ((svr->buf_size - offset) >= (int)sizeof(int))
|
|
|
|
{
|
|
|
|
int s, md, d = 0, head;
|
|
|
|
unsigned char *dd;
|
|
|
|
|
|
|
|
dd = (unsigned char *)&head;
|
|
|
|
dd[0] = *(svr->buf + offset + 0);
|
|
|
|
dd[1] = *(svr->buf + offset + 1);
|
|
|
|
dd[2] = *(svr->buf + offset + 2);
|
|
|
|
dd[3] = *(svr->buf + offset + 3);
|
|
|
|
head = ntohl(head);
|
|
|
|
dd = (unsigned char *)&d;
|
|
|
|
s = 4;
|
|
|
|
SVSZ(0);
|
|
|
|
SVSZ(1);
|
|
|
|
SVSZ(2);
|
|
|
|
SVSZ(3);
|
|
|
|
SVSZ(4);
|
|
|
|
SVSZ(5);
|
|
|
|
if ((svr->buf_size - offset) < s)
|
|
|
|
{
|
|
|
|
if (offset > 0) goto scroll;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = 4;
|
|
|
|
SVDEC(0, major);
|
|
|
|
SVDEC(1, minor);
|
|
|
|
SVDEC(2, ref);
|
|
|
|
SVDEC(3, ref_to);
|
|
|
|
SVDEC(4, response);
|
|
|
|
SVDEC(5, size);
|
|
|
|
if (msg.size < 0) msg.size = 0;
|
|
|
|
/* there is enough data in the buffer for a full message */
|
|
|
|
if ((svr->buf_size - offset) >= (s + msg.size))
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Server_Data *e2;
|
|
|
|
int max;
|
|
|
|
|
2013-07-16 02:58:20 -07:00
|
|
|
if (buf != svr->buf) free(buf);
|
2010-09-30 00:35:00 -07:00
|
|
|
buf = NULL;
|
|
|
|
max = svr->max_buf_size;
|
|
|
|
if ((max < 0) || (msg.size <= max))
|
|
|
|
{
|
|
|
|
if (msg.size > 0)
|
|
|
|
{
|
|
|
|
buf = malloc(msg.size);
|
|
|
|
if (!buf) return ECORE_CALLBACK_CANCEL;
|
|
|
|
memcpy(buf, svr->buf + offset + s, msg.size);
|
|
|
|
}
|
|
|
|
if (!svr->delete_me)
|
|
|
|
{
|
|
|
|
e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Data));
|
|
|
|
if (e2)
|
|
|
|
{
|
|
|
|
svr->event_count++;
|
|
|
|
e2->server = svr;
|
|
|
|
e2->major = msg.major;
|
|
|
|
e2->minor = msg.minor;
|
|
|
|
e2->ref = msg.ref;
|
|
|
|
e2->ref_to = msg.ref_to;
|
|
|
|
e2->response = msg.response;
|
|
|
|
e2->size = msg.size;
|
|
|
|
e2->data = buf;
|
2013-07-08 20:18:37 -07:00
|
|
|
if (buf == svr->buf)
|
|
|
|
{
|
|
|
|
svr->buf = NULL;
|
|
|
|
svr->buf_size = 0;
|
|
|
|
}
|
|
|
|
buf = NULL;
|
2010-09-30 00:35:00 -07:00
|
|
|
ecore_event_add(ECORE_IPC_EVENT_SERVER_DATA, e2,
|
|
|
|
_ecore_ipc_event_server_data_free,
|
|
|
|
NULL);
|
|
|
|
}
|
2013-07-16 02:58:20 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
free(buf);
|
|
|
|
buf = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
free(buf);
|
|
|
|
buf = NULL;
|
2010-09-30 00:35:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
svr->prev.i = msg;
|
|
|
|
offset += (s + msg.size);
|
2015-07-27 16:08:11 -07:00
|
|
|
if ((svr->buf_size == offset) && (svr->buf))
|
2010-09-30 00:35:00 -07:00
|
|
|
{
|
2013-07-08 20:18:37 -07:00
|
|
|
if (svr->buf) free(svr->buf);
|
2010-09-30 00:35:00 -07:00
|
|
|
svr->buf = NULL;
|
|
|
|
svr->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
else goto scroll;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
scroll:
|
2013-11-28 00:17:09 -08:00
|
|
|
if (buf != svr->buf) free(buf);
|
2010-09-30 00:35:00 -07:00
|
|
|
buf = malloc(svr->buf_size - offset);
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
free(svr->buf);
|
|
|
|
svr->buf = NULL;
|
|
|
|
svr->buf_size = 0;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
memcpy(buf, svr->buf + offset, svr->buf_size - offset);
|
|
|
|
free(svr->buf);
|
|
|
|
svr->buf = buf;
|
|
|
|
svr->buf_size -= offset;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2016-11-22 17:55:57 -08:00
|
|
|
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_ecore_ipc_event_server_data(void *data EINA_UNUSED, int ev_type EINA_UNUSED, void *ev)
|
|
|
|
{
|
|
|
|
Ecore_Con_Event_Server_Data *e;
|
|
|
|
|
|
|
|
e = ev;
|
|
|
|
if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server)))
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
/* handling code here */
|
|
|
|
{
|
|
|
|
Ecore_Ipc_Server *svr;
|
|
|
|
Eina_Bool stolen;
|
|
|
|
|
|
|
|
svr = ecore_con_server_data_get(e->server);
|
|
|
|
|
|
|
|
ecore_ipc_server_data_process(svr, e->data, e->size, &stolen);
|
|
|
|
if (stolen)
|
|
|
|
{
|
|
|
|
e->data = NULL;
|
|
|
|
e->size = 0;
|
|
|
|
}
|
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2006-03-19 21:53:12 -08:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_client_add_free(void *data EINA_UNUSED, void *ev)
|
2006-03-19 21:53:12 -08:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Add *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2006-03-19 21:53:12 -08:00
|
|
|
e = ev;
|
2006-03-20 00:18:52 -08:00
|
|
|
e->client->event_count--;
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->client->event_count == 0) && (e->client->delete_me))
|
|
|
|
ecore_ipc_client_del(e->client);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_client_del_free(void *data EINA_UNUSED, void *ev)
|
2006-03-19 21:53:12 -08:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Del *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2006-03-19 21:53:12 -08:00
|
|
|
e = ev;
|
2006-03-20 00:18:52 -08:00
|
|
|
e->client->event_count--;
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->client->event_count == 0) && (e->client->delete_me))
|
|
|
|
ecore_ipc_client_del(e->client);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_client_data_free(void *data EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Client_Data *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
2006-03-20 00:18:52 -08:00
|
|
|
e->client->event_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
if (e->data) free(e->data);
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->client->event_count == 0) && (e->client->delete_me))
|
|
|
|
ecore_ipc_client_del(e->client);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_server_add_free(void *data EINA_UNUSED, void *ev)
|
2006-03-19 21:53:12 -08:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Server_Add *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2006-03-19 21:53:12 -08:00
|
|
|
e = ev;
|
2006-03-20 00:18:52 -08:00
|
|
|
e->server->event_count--;
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->server->event_count == 0) && (e->server->delete_me))
|
|
|
|
ecore_ipc_server_del(e->server);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_server_del_free(void *data EINA_UNUSED, void *ev)
|
2006-03-19 21:53:12 -08:00
|
|
|
{
|
2016-11-22 17:20:22 -08:00
|
|
|
Ecore_Ipc_Event_Server_Del *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2006-03-19 21:53:12 -08:00
|
|
|
e = ev;
|
2006-03-20 00:18:52 -08:00
|
|
|
e->server->event_count--;
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->server->event_count == 0) && (e->server->delete_me))
|
|
|
|
ecore_ipc_server_del(e->server);
|
2003-09-23 01:09:32 -07:00
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_ipc_event_server_data_free(void *data EINA_UNUSED, void *ev)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
|
|
|
Ecore_Ipc_Event_Server_Data *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
e = ev;
|
|
|
|
if (e->data) free(e->data);
|
2006-03-20 00:18:52 -08:00
|
|
|
e->server->event_count--;
|
2006-03-19 21:53:12 -08:00
|
|
|
if ((e->server->event_count == 0) && (e->server->delete_me))
|
|
|
|
ecore_ipc_server_del(e->server);
|
2003-09-23 01:09:32 -07:00
|
|
|
free(e);
|
|
|
|
}
|