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>
2016-12-19 05:58:55 -08:00
# include <sys/stat.h>
2013-03-15 01:12:05 -07:00
2016-12-12 06:16:33 -08:00
# ifdef HAVE_ARPA_INET_H
# include <arpa / inet.h>
# endif
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
2016-11-23 16:35:48 -08:00
/* EFL_NET_SERVER_UNIX_CLASS and EFL_NET_DIALER_UNIX_CLASS should be defined at the same time, we're only checking for EFL_NET_SERVER_UNIX_CLASS in shared blocks */
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 ;
2016-11-23 16:35:48 -08: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 ;
2020-06-20 02:43:56 -07:00
2020-06-08 04:27:42 -07:00
cl - > delete_me = EINA_TRUE ;
2016-11-22 17:20:40 -08:00
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 ;
2016-11-23 13:45:33 -08:00
cl - > max_buf_size = 32 * 1024 ;
2016-11-22 17:20:40 -08:00
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 )
{
2009-10-09 22:28:43 -07:00
if ( + + _ecore_ipc_init_count ! = 1 )
return _ecore_ipc_init_count ;
2016-12-19 05:37:24 -08:00
2017-09-26 00:32:29 -07:00
_ecore_ipc_log_dom = eina_log_domain_register
( " ecore_ipc " , ECORE_IPC_DEFAULT_LOG_COLOR ) ;
if ( _ecore_ipc_log_dom < 0 )
2009-12-21 09:32:19 -08:00
{
2017-09-26 00:32:29 -07:00
EINA_LOG_ERR ( " Impossible to create a log domain for the Ecore IPC module. " ) ;
return - - _ecore_ipc_init_count ;
2009-12-21 09:32:19 -08:00
}
2016-12-19 05:37:24 -08:00
2009-10-09 22:28:43 -07:00
if ( ! ecore_con_init ( ) )
2017-09-26 00:32:29 -07:00
{
eina_log_domain_unregister ( _ecore_ipc_log_dom ) ;
_ecore_ipc_log_dom = - 1 ;
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 ( ) ;
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 )
{
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
2017-03-09 16:11:50 -08:00
ecore_event_type_flush ( ECORE_IPC_EVENT_CLIENT_ADD ,
ECORE_IPC_EVENT_CLIENT_DEL ,
ECORE_IPC_EVENT_SERVER_ADD ,
ECORE_IPC_EVENT_SERVER_DEL ,
ECORE_IPC_EVENT_CLIENT_DATA ,
ECORE_IPC_EVENT_SERVER_DATA ) ;
2005-09-07 02:24:05 -07:00
ecore_con_shutdown ( ) ;
2016-12-19 05:37:24 -08:00
2017-09-26 00:32:29 -07:00
eina_log_domain_unregister ( _ecore_ipc_log_dom ) ;
_ecore_ipc_log_dom = - 1 ;
2016-12-19 05:37:24 -08:00
2009-10-09 22:28:43 -07:00
return _ecore_ipc_init_count ;
2003-09-23 01:09:32 -07:00
}
2016-11-23 13:45:33 -08:00
static void
_ecore_ipc_server_del ( Ecore_Ipc_Server * svr )
{
DBG ( " server %p del " , svr ) ;
if ( svr - > server )
{
efl_del ( svr - > server ) ;
svr - > server = NULL ;
}
}
static void _ecore_ipc_server_client_add ( void * data , const Efl_Event * event ) ;
EFL_CALLBACKS_ARRAY_DEFINE ( _ecore_ipc_server_cbs ,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD , _ecore_ipc_server_client_add } ) ;
/* FIXME: need to add protocol type parameter */
EAPI Ecore_Ipc_Server *
ecore_ipc_server_add ( Ecore_Ipc_Type type , const char * name , int port , const void * data )
{
Ecore_Ipc_Server * svr ;
2018-02-26 21:10:12 -08:00
Eo * loop = efl_main_loop_get ( ) ;
2016-11-23 13:45:33 -08:00
char * address = NULL ;
Eina_Error err ;
# ifdef EFL_NET_SERVER_UNIX_CLASS
2017-07-26 08:11:29 -07:00
Eina_Bool local_system = EINA_FALSE ;
2016-12-02 05:47:43 -08:00
mode_t old_mask = 0 , new_mask = 0 ;
2016-11-23 13:45:33 -08:00
# endif
EINA_SAFETY_ON_NULL_RETURN_VAL ( name , NULL ) ;
svr = calloc ( 1 , sizeof ( Ecore_Ipc_Server ) ) ;
EINA_SAFETY_ON_NULL_RETURN_VAL ( svr , NULL ) ;
if ( 0 ) { }
# ifdef EFL_NET_SERVER_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_server ) ;
new_mask = S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH ;
2018-02-26 21:10:12 -08:00
svr - > server = efl_add ( EFL_NET_SERVER_UNIX_CLASS , efl_main_loop_get ( ) ,
2016-11-25 12:01:29 -08:00
efl_net_server_unix_leading_directories_create_set ( efl_added , EINA_TRUE , S_IRUSR | S_IWUSR | S_IXUSR ) ) ;
2016-11-23 13:45:33 -08:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
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_server ) ;
/* ecore_con didn't create leading directories for LOCAL_SYSTEM */
new_mask = 0 ;
2017-07-26 08:11:29 -07:00
local_system = EINA_TRUE ;
2016-11-23 13:45:33 -08:00
2018-02-26 21:10:12 -08:00
svr - > server = efl_add ( EFL_NET_SERVER_UNIX_CLASS , efl_main_loop_get ( ) ) ;
2016-11-23 13:45:33 -08:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
# endif /* EFL_NET_SERVER_UNIX_CLASS */
2017-03-27 11:54:38 -07:00
# ifdef EFL_NET_SERVER_WINDOWS_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_server ) ;
// TODO: specify SECURITY_ATTRIBUTES to use or some
// Efl_Net_Server_Windows API to limit access
2018-02-26 21:10:12 -08:00
svr - > server = efl_add ( EFL_NET_SERVER_WINDOWS_CLASS , efl_main_loop_get ( ) ) ;
2017-03-27 11:54:38 -07:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
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_server ) ;
// TODO: specify SECURITY_ATTRIBUTES to use or some
// Efl_Net_Server_Windows API to limit access
2018-02-26 21:10:12 -08:00
svr - > server = efl_add ( EFL_NET_SERVER_WINDOWS_CLASS , efl_main_loop_get ( ) ) ;
2017-03-27 11:54:38 -07:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
# endif /* EFL_NET_SERVER_WINDOWS_CLASS */
2016-11-23 13:45:33 -08:00
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_server ;
}
snprintf ( buf , sizeof ( buf ) , " %s:%d " , name , port ) ;
address = strdup ( buf ) ;
EINA_SAFETY_ON_NULL_GOTO ( address , error_server ) ;
if ( ( type & ECORE_IPC_USE_SSL ) = = ECORE_IPC_USE_SSL )
{
svr - > server = efl_add ( EFL_NET_SERVER_SSL_CLASS , loop ) ;
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
else
{
svr - > server = efl_add ( EFL_NET_SERVER_TCP_CLASS , loop ) ;
EINA_SAFETY_ON_NULL_GOTO ( svr - > server , error_server ) ;
}
}
else
{
ERR ( " IPC Type must be one of: local_user, local_system or remote_system " ) ;
goto error_server ;
}
efl_event_callback_array_add ( svr - > server , _ecore_ipc_server_cbs ( ) , svr ) ;
2017-07-26 08:11:29 -07:00
if ( efl_isa ( svr - > server , EFL_NET_SERVER_FD_CLASS ) )
{
efl_net_server_fd_reuse_address_set ( svr - > server , EINA_TRUE ) ;
efl_net_server_fd_reuse_port_set ( svr - > server , EINA_TRUE ) ;
}
if ( efl_isa ( svr - > server , EFL_NET_SERVER_TCP_CLASS ) )
{
/* old ecore_con did not map ipv4 to ipv6... */
2017-09-29 14:12:03 -07:00
efl_net_server_ip_ipv6_only_set ( svr - > server , EINA_TRUE ) ;
2017-07-26 08:11:29 -07:00
}
2016-11-23 13:45:33 -08:00
# ifdef EFL_NET_SERVER_UNIX_CLASS
if ( efl_isa ( svr - > server , EFL_NET_SERVER_UNIX_CLASS ) )
2017-07-26 08:11:29 -07:00
{
old_mask = umask ( new_mask ) ;
efl_net_server_unix_leading_directories_create_set ( svr - > server ,
EINA_TRUE ,
local_system ? 0755 : 0700 ) ;
}
2016-11-23 13:45:33 -08:00
# endif
err = efl_net_server_serve ( svr - > server , address ) ;
# ifdef EFL_NET_SERVER_UNIX_CLASS
if ( efl_isa ( svr - > server , EFL_NET_SERVER_UNIX_CLASS ) )
umask ( old_mask ) ;
# endif
if ( err )
{
WRN ( " Could not serve %s %s: %s " ,
efl_class_name_get ( efl_class_get ( svr - > server ) ) ,
address , eina_error_msg_get ( err ) ) ;
goto error ;
}
DBG ( " will serve %p %s address='%s' " ,
svr - > server ,
efl_class_name_get ( efl_class_get ( svr - > server ) ) ,
address ) ;
svr - > max_buf_size = 32 * 1024 ;
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_server_del ( svr ) ;
free ( svr ) ;
return NULL ; /* server will trigger all cleanup on its own callbacks */
error_server :
free ( address ) ;
free ( svr ) ;
return NULL ;
}
2003-09-23 01:09:32 -07:00
2019-05-22 05:01:58 -07:00
static Efl_Callback_Array_Item * _ecore_ipc_dialer_cbs ( void ) ;
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 )
{
2019-05-22 05:01:58 -07:00
efl_event_callback_array_del ( svr - > dialer . dialer , _ecore_ipc_dialer_cbs ( ) , svr ) ;
if ( ! efl_io_closer_closed_get ( svr - > dialer . dialer ) )
efl_io_closer_close ( svr - > dialer . dialer ) ;
2016-11-23 06:17:14 -08:00
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 } ,
2019-03-08 07:47:32 -08:00
{ EFL_NET_DIALER_EVENT_DIALER_ERROR , _ecore_ipc_dialer_error } ,
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED , _ecore_ipc_dialer_connected } ) ;
2016-11-23 06:17:14 -08:00
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 } ) ;
/* 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 ;
2018-02-26 21:10:12 -08:00
Eo * loop = efl_main_loop_get ( ) ;
2016-11-23 06:17:14 -08:00
char * address = NULL ;
Eina_Error err ;
EINA_SAFETY_ON_NULL_RETURN_VAL ( name , NULL ) ;
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 )
{
2016-12-19 05:58:55 -08:00
struct stat st ;
2016-11-23 06:17:14 -08:00
address = ecore_con_local_path_new ( EINA_FALSE , name , port ) ;
EINA_SAFETY_ON_NULL_GOTO ( address , error_dialer ) ;
2016-12-19 05:58:55 -08:00
if ( ( stat ( address , & st ) ! = 0 )
# ifdef S_ISSOCK
| | ( ! S_ISSOCK ( st . st_mode ) )
# endif
)
{
DBG ( " %s is not a socket " , address ) ;
goto error_dialer ;
}
2018-02-26 21:10:12 -08:00
svr - > dialer . dialer = efl_add ( EFL_NET_DIALER_UNIX_CLASS , efl_main_loop_get ( ) ) ;
2016-11-23 06:17:14 -08:00
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 ) ;
2018-02-26 21:10:12 -08:00
svr - > dialer . dialer = efl_add ( EFL_NET_DIALER_UNIX_CLASS , efl_main_loop_get ( ) ) ;
2016-11-23 06:17:14 -08:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > dialer . dialer , error_dialer ) ;
}
# endif /* EFL_NET_DIALER_UNIX_CLASS */
2017-03-27 11:54:38 -07:00
# ifdef EFL_NET_DIALER_WINDOWS_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 ) ;
2018-02-26 21:10:12 -08:00
svr - > dialer . dialer = efl_add ( EFL_NET_DIALER_WINDOWS_CLASS , efl_main_loop_get ( ) ) ;
2017-03-27 11:54:38 -07:00
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 ) ;
2018-02-26 21:10:12 -08:00
svr - > dialer . dialer = efl_add ( EFL_NET_DIALER_WINDOWS_CLASS , efl_main_loop_get ( ) ) ;
2017-03-27 11:54:38 -07:00
EINA_SAFETY_ON_NULL_GOTO ( svr - > dialer . dialer , error_dialer ) ;
}
# endif /* EFL_NET_DIALER_WINDOWS_CLASS */
2016-11-23 06:17:14 -08:00
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 ;
}
2018-04-17 16:17:29 -07:00
efl_io_closer_close_on_invalidate_set ( svr - > dialer . dialer , EINA_TRUE ) ;
2016-11-23 06:17:14 -08:00
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 ,
2018-04-17 16:17:29 -07:00
efl_io_closer_close_on_invalidate_set ( efl_added , EINA_FALSE ) ,
2016-11-23 06:17:14 -08:00
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 ,
2018-04-17 16:17:29 -07:00
efl_io_closer_close_on_invalidate_set ( efl_added , EINA_FALSE ) ,
2016-11-23 06:17:14 -08:00
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 :
2016-11-23 12:22:21 -08:00
free ( address ) ;
2016-11-23 06:17:14 -08:00
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 13:45:33 -08:00
if ( svr - > server ) _ecore_ipc_server_del ( svr ) ;
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 ) ;
2017-06-09 17:16:07 -07:00
eina_list_free ( svr - > dead_clients ) ;
eina_list_free ( svr - > clients ) ;
2010-09-30 00:35:00 -07:00
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 13:45:33 -08:00
else if ( svr - > server ) return EINA_TRUE ;
2016-11-23 16:35:48 -08:00
return EINA_FALSE ;
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 ; \
2019-02-01 03:04:17 -08:00
v = eina_htonl ( v ) ; \
2010-09-30 00:35:00 -07:00
* ( 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 ; \
2019-02-01 03:04:17 -08:00
v = eina_htons ( v ) ; \
2010-09-30 00:35:00 -07:00
* ( 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 ;
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 ) ;
2019-02-01 03:04:17 -08:00
* head = eina_htonl ( * head ) ;
2004-04-23 00:24:40 -07:00
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 ;
}
2018-04-10 22:34:40 -07:00
if ( ( data ) & & ( size > 0 ) )
2016-11-23 06:17:14 -08:00
{
2018-04-10 22:34:40 -07:00
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 ;
}
2016-11-23 06:17:14 -08:00
}
return s + size ;
}
2016-11-23 13:45:33 -08:00
else if ( svr - > server )
{
ERR ( " Send data to clients, not the server handle " ) ;
return 0 ;
}
2016-11-23 16:35:48 -08:00
return 0 ;
2003-09-23 01:09:32 -07:00
}
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 13:45:33 -08:00
if ( svr - > server )
{
efl_net_server_clients_limit_set ( svr - > server , client_limit , reject_excess_clients ) ;
return ;
}
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 13:45:33 -08:00
else if ( svr - > server )
{
if ( efl_isa ( svr - > server , EFL_NET_SERVER_TCP_CLASS ) | |
efl_isa ( svr - > server , EFL_NET_SERVER_SSL_CLASS ) )
return efl_net_server_address_get ( svr - > server ) ;
/* original IPC just returned IP for remote connections */
return NULL ;
}
2016-11-23 16:35:48 -08:00
return NULL ;
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 )
{
2016-12-19 06:57:09 -08:00
while ( ! efl_io_closer_closed_get ( svr - > dialer . dialer ) & &
! efl_net_dialer_connected_get ( svr - > dialer . dialer ) )
ecore_main_loop_iterate ( ) ;
2018-03-26 02:18:30 -07:00
while ( ( efl_io_queue_usage_get ( svr - > dialer . input ) > 0 ) | |
( efl_io_copier_pending_size_get ( svr - > dialer . send_copier ) > 0 ) )
2016-11-25 10:48:45 -08:00
efl_io_copier_flush ( svr - > dialer . send_copier , EINA_TRUE , EINA_TRUE ) ;
2016-11-23 06:17:14 -08:00
return ;
}
2016-11-23 13:45:33 -08:00
else if ( svr - > server )
{
ERR ( " Flush clients, not the server handle " ) ;
return ;
}
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 ; \
2019-02-01 03:04:17 -08:00
v = eina_htonl ( v ) ; \
2010-09-30 00:35:00 -07:00
* ( 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 ; \
2019-02-01 03:04:17 -08:00
v = eina_htons ( v ) ; \
2010-09-30 00:35:00 -07:00
* ( 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 ;
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
}
2016-11-23 13:45:33 -08:00
if ( cl - > socket . socket )
EINA_SAFETY_ON_TRUE_RETURN_VAL ( efl_io_closer_closed_get ( cl - > socket . socket ) , 0 ) ;
else
{
ERR ( " client %p is not connected " , cl ) ;
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 ;
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 ) ;
2019-02-01 03:04:17 -08:00
* head = eina_htonl ( * head ) ;
2004-04-23 00:24:40 -07:00
cl - > prev . o = msg ;
2016-11-23 13:45:33 -08:00
if ( cl - > socket . input )
{
Eina_Slice slice ;
Eina_Error err ;
slice . mem = dat ;
slice . len = s ;
err = efl_io_writer_write ( cl - > socket . input , & slice , NULL ) ;
if ( err )
{
ERR ( " could not write queue=%p %zd bytes: %s " ,
cl - > socket . 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 , cl - > socket . input ) ;
return 0 ;
}
2018-04-10 22:34:40 -07:00
if ( ( data ) & & ( size > 0 ) )
2016-11-23 13:45:33 -08:00
{
2018-04-10 22:34:40 -07:00
slice . mem = data ;
slice . len = size ;
err = efl_io_writer_write ( cl - > socket . input , & slice , NULL ) ;
if ( err )
{
ERR ( " could not write queue=%p %zd bytes: %s " ,
cl - > socket . 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 , cl - > socket . input ) ;
return 0 ;
}
2016-11-23 13:45:33 -08:00
}
return s + size ;
}
2016-11-23 16:35:48 -08:00
return 0 ;
2003-09-23 01:09:32 -07:00
}
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
}
2016-11-23 13:45:33 -08:00
static Efl_Callback_Array_Item * _ecore_ipc_socket_cbs ( void ) ;
static void
_ecore_ipc_client_socket_del ( Ecore_Ipc_Client * cl )
{
DBG ( " client %p socket del " , cl ) ;
if ( cl - > socket . recv_copier )
{
efl_del ( cl - > socket . recv_copier ) ;
cl - > socket . recv_copier = NULL ;
}
if ( cl - > socket . send_copier )
{
efl_del ( cl - > socket . send_copier ) ;
cl - > socket . send_copier = NULL ;
}
if ( cl - > socket . input )
{
efl_del ( cl - > socket . input ) ;
cl - > socket . input = NULL ;
}
if ( cl - > socket . socket )
{
efl_event_callback_array_del ( cl - > socket . socket , _ecore_ipc_socket_cbs ( ) , cl ) ;
/* do not del() as it's owned by srv->server */
if ( ! efl_io_closer_closed_get ( cl - > socket . socket ) )
efl_io_closer_close ( cl - > socket . socket ) ;
efl_unref ( cl - > socket . socket ) ;
cl - > socket . socket = NULL ;
2017-06-09 17:16:07 -07:00
if ( ! cl - > svr ) return ;
cl - > svr - > clients = eina_list_remove ( cl - > svr - > clients , cl ) ;
cl - > svr - > dead_clients = eina_list_append ( cl - > svr - > dead_clients , cl ) ;
2016-11-23 13:45:33 -08:00
}
}
static void
_ecore_ipc_client_socket_eos ( void * data , const Efl_Event * event EINA_UNUSED )
{
Ecore_Ipc_Client * cl = data ;
DBG ( " client %p socket %p eos " , cl , cl - > socket . socket ) ;
_ecore_ipc_client_socket_del ( cl ) ;
ecore_ipc_post_event_client_del ( cl ) ;
}
EFL_CALLBACKS_ARRAY_DEFINE ( _ecore_ipc_socket_cbs ,
{ EFL_IO_READER_EVENT_EOS , _ecore_ipc_client_socket_eos } ) ;
static Eina_Bool ecore_ipc_client_data_process ( Ecore_Ipc_Client * cl , void * data , int size , Eina_Bool * stolen ) ;
static void
_ecore_ipc_client_socket_copier_data ( void * data , const Efl_Event * event EINA_UNUSED )
{
Ecore_Ipc_Client * cl = data ;
Eina_Binbuf * binbuf ;
uint8_t * mem ;
int size ;
Eina_Bool stolen ;
DBG ( " client %p recv_copier %p data " , cl , cl - > socket . recv_copier ) ;
binbuf = efl_io_copier_binbuf_steal ( cl - > socket . 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_client_data_process ( cl , mem , size , & stolen ) ;
if ( ! stolen ) free ( mem ) ;
}
static void
_ecore_ipc_client_socket_copier_error ( void * data , const Efl_Event * event )
{
Ecore_Ipc_Client * cl = data ;
Eina_Error * perr = event - > info ;
WRN ( " client %p socket %p copier %p error %s " , cl , cl - > socket . socket , event - > object , eina_error_msg_get ( * perr ) ) ;
if ( ! efl_io_closer_closed_get ( cl - > socket . socket ) )
efl_io_closer_close ( cl - > socket . socket ) ;
}
EFL_CALLBACKS_ARRAY_DEFINE ( _ecore_ipc_client_socket_copier_cbs ,
{ EFL_IO_COPIER_EVENT_ERROR , _ecore_ipc_client_socket_copier_error } ) ;
static void
_ecore_ipc_server_client_add ( void * data , const Efl_Event * event )
{
Ecore_Ipc_Server * svr = data ;
Eo * socket = event - > info ;
Ecore_Ipc_Client * cl ;
Eo * loop ;
DBG ( " server %p %p got new client %p (%s) " ,
svr , svr - > server ,
event - > object , efl_net_socket_address_remote_get ( socket ) ) ;
cl = ecore_ipc_client_add ( svr ) ;
EINA_SAFETY_ON_NULL_RETURN ( cl ) ;
cl - > socket . socket = efl_ref ( socket ) ;
efl_event_callback_array_add ( cl - > socket . socket , _ecore_ipc_socket_cbs ( ) , cl ) ;
loop = efl_loop_get ( socket ) ;
cl - > socket . input = efl_add ( EFL_IO_QUEUE_CLASS , loop ) ;
EINA_SAFETY_ON_NULL_GOTO ( cl - > socket . input , error ) ;
cl - > socket . send_copier = efl_add ( EFL_IO_COPIER_CLASS , loop ,
2018-04-17 16:17:29 -07:00
efl_io_closer_close_on_invalidate_set ( efl_added , EINA_FALSE ) ,
2016-11-23 13:45:33 -08:00
efl_io_copier_source_set ( efl_added , cl - > socket . input ) ,
efl_io_copier_destination_set ( efl_added , cl - > socket . socket ) ,
efl_event_callback_array_add ( efl_added , _ecore_ipc_client_socket_copier_cbs ( ) , cl ) ) ;
EINA_SAFETY_ON_NULL_GOTO ( cl - > socket . send_copier , error ) ;
cl - > socket . recv_copier = efl_add ( EFL_IO_COPIER_CLASS , loop ,
2018-04-17 16:17:29 -07:00
efl_io_closer_close_on_invalidate_set ( efl_added , EINA_FALSE ) ,
2016-11-23 13:45:33 -08:00
efl_io_copier_source_set ( efl_added , cl - > socket . socket ) ,
efl_event_callback_array_add ( efl_added , _ecore_ipc_client_socket_copier_cbs ( ) , cl ) ,
efl_event_callback_add ( efl_added , EFL_IO_COPIER_EVENT_DATA , _ecore_ipc_client_socket_copier_data , cl ) ) ;
EINA_SAFETY_ON_NULL_GOTO ( cl - > socket . recv_copier , error ) ;
ecore_ipc_post_event_client_add ( cl ) ;
return ;
error :
_ecore_ipc_client_socket_del ( cl ) ;
free ( cl ) ;
}
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 ;
2016-11-23 13:45:33 -08:00
if ( cl - > socket . socket ) _ecore_ipc_client_socket_del ( cl ) ;
2016-07-11 06:29:04 -07:00
if ( ECORE_MAGIC_CHECK ( svr , ECORE_MAGIC_IPC_SERVER ) )
2017-06-09 17:16:07 -07:00
svr - > dead_clients = eina_list_remove ( svr - > dead_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
}
2016-11-23 13:45:33 -08:00
if ( cl - > socket . socket )
{
if ( efl_isa ( cl - > socket . socket , EFL_NET_SOCKET_TCP_CLASS ) | |
efl_isa ( cl - > socket . socket , EFL_NET_SOCKET_SSL_CLASS ) )
return efl_net_socket_address_remote_get ( cl - > socket . socket ) ;
/* original IPC just returned IP for remote connections,
* for unix socket it returned 0.0 .0 .0
*/
return " 0.0.0.0 " ;
}
2016-11-23 16:35:48 -08:00
return NULL ;
2006-03-19 23:45:58 -08:00
}
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
}
2016-11-23 13:45:33 -08:00
if ( cl - > socket . input )
{
while ( efl_io_queue_usage_get ( cl - > socket . input ) > 0 )
2016-11-25 10:48:45 -08:00
efl_io_copier_flush ( cl - > socket . send_copier , EINA_TRUE , EINA_TRUE ) ;
2016-11-23 13:45:33 -08:00
return ;
}
2007-02-16 10:12:38 -08:00
}
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
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 ) ; \
2019-02-01 03:04:17 -08:00
d = ( int ) eina_ntohl ( v ) ; \
2010-09-30 00:35:00 -07:00
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 ) ; \
2019-02-01 03:04:17 -08:00
d = ( int ) eina_ntohs ( v ) ; \
2010-09-30 00:35:00 -07:00
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 ) ;
2019-02-01 03:04:17 -08:00
head = eina_ntohl ( head ) ;
2010-09-30 00:35:00 -07:00
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 ;
}
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 ) ; \
2019-02-01 03:04:17 -08:00
d = ( int ) eina_ntohl ( v ) ; \
2010-09-30 00:35:00 -07:00
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 ) ; \
2019-02-01 03:04:17 -08:00
d = ( int ) eina_ntohs ( v ) ; \
2010-09-30 00:35:00 -07:00
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 ) ;
2019-02-01 03:04:17 -08:00
head = eina_ntohl ( head ) ;
2010-09-30 00:35:00 -07:00
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 ;
}
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 ) ;
}