2 * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
11 #ifdef HAVE_NETINET_IN_H
12 # include <netinet/in.h>
15 #ifdef HAVE_WINSOCK2_H
16 # include <winsock2.h>
20 #include "ecore_private.h"
21 #include "Ecore_Con.h"
22 #include "ecore_ipc_private.h"
23 #include "Ecore_Ipc.h"
42 int _ecore_ipc_log_dom = -1;
44 /* byte swappers - for dealing with big vs little endian machines */
46 _ecore_ipc_swap_16(unsigned short v)
50 s = (unsigned char *)(&v);
51 t = s[0]; s[0] = s[1]; s[1] = t;
56 _ecore_ipc_swap_32(unsigned int v)
60 s = (unsigned char *)(&v);
61 t = s[0]; s[0] = s[3]; s[3] = t;
62 t = s[1]; s[1] = s[2]; s[2] = t;
66 EAPI unsigned long long
67 _ecore_ipc_swap_64(unsigned long long v)
71 s = (unsigned char *)(&v);
72 t = s[0]; s[0] = s[7]; s[7] = t;
73 t = s[1]; s[1] = s[6]; s[6] = t;
74 t = s[2]; s[2] = s[5]; s[5] = t;
75 t = s[3]; s[3] = s[4]; s[4] = t;
79 static int _ecore_ipc_dlt_int(int out, int prev, int *mode);
80 static int _ecore_ipc_ddlt_int(int in, int prev, int mode);
83 _ecore_ipc_dlt_int(int out, int prev, int *mode)
93 if (out == (int)0xffffffff)
103 if (out == prev << 1)
108 if (out == prev >> 1)
115 if (!(dlt & 0xffffff00))
121 if (!(dlt & 0xffffff00))
127 if (!(dlt & 0x00ffffff))
130 return (dlt >> 24) & 0xff;
133 if (!(dlt & 0x00ffffff))
136 return (dlt >> 24) & 0xff;
140 if (!(dlt & 0xffff0000))
146 if (!(dlt & 0xffff0000))
152 if (!(dlt & 0x0000ffff))
155 return (dlt >> 16) & 0xffff;
158 if (!(dlt & 0x0000ffff))
161 return (dlt >> 16) & 0xffff;
169 _ecore_ipc_ddlt_int(int in, int prev, int mode)
195 return prev + (in << 24);
198 return prev - (in << 24);
207 return prev + (in << 16);
210 return prev - (in << 16);
227 static int _ecore_ipc_event_client_add(void *data, int ev_type, void *ev);
228 static int _ecore_ipc_event_client_del(void *data, int ev_type, void *ev);
229 static int _ecore_ipc_event_server_add(void *data, int ev_type, void *ev);
230 static int _ecore_ipc_event_server_del(void *data, int ev_type, void *ev);
231 static int _ecore_ipc_event_client_data(void *data, int ev_type, void *ev);
232 static int _ecore_ipc_event_server_data(void *data, int ev_type, void *ev);
233 static void _ecore_ipc_event_client_add_free(void *data, void *ev);
234 static void _ecore_ipc_event_client_del_free(void *data, void *ev);
235 static void _ecore_ipc_event_client_data_free(void *data, void *ev);
236 static void _ecore_ipc_event_server_add_free(void *data, void *ev);
237 static void _ecore_ipc_event_server_del_free(void *data, void *ev);
238 static void _ecore_ipc_event_server_data_free(void *data, void *ev);
240 EAPI int ECORE_IPC_EVENT_CLIENT_ADD = 0;
241 EAPI int ECORE_IPC_EVENT_CLIENT_DEL = 0;
242 EAPI int ECORE_IPC_EVENT_SERVER_ADD = 0;
243 EAPI int ECORE_IPC_EVENT_SERVER_DEL = 0;
244 EAPI int ECORE_IPC_EVENT_CLIENT_DATA = 0;
245 EAPI int ECORE_IPC_EVENT_SERVER_DATA = 0;
247 static int _ecore_ipc_init_count = 0;
248 static Eina_List *servers = NULL;
249 static Ecore_Event_Handler *handler[6];
252 * @defgroup Ecore_IPC_Library_Group IPC Library Functions
254 * Functions that set up and shut down the Ecore IPC Library.
258 * Initialises the Ecore IPC library.
259 * @return Number of times the library has been initialised without
261 * @ingroup Ecore_IPC_Library_Group
268 if (++_ecore_ipc_init_count != 1)
269 return _ecore_ipc_init_count;
270 _ecore_ipc_log_dom = eina_log_domain_register("EcoreIpc", ECORE_DEFAULT_LOG_COLOR);
271 if(_ecore_ipc_log_dom < 0)
273 EINA_LOG_ERR("Impossible to create a log domain for the Ecore IPC module.");
274 return --_ecore_ipc_init_count;
276 if (!ecore_con_init())
277 return --_ecore_ipc_init_count;
279 ECORE_IPC_EVENT_CLIENT_ADD = ecore_event_type_new();
280 ECORE_IPC_EVENT_CLIENT_DEL = ecore_event_type_new();
281 ECORE_IPC_EVENT_SERVER_ADD = ecore_event_type_new();
282 ECORE_IPC_EVENT_SERVER_DEL = ecore_event_type_new();
283 ECORE_IPC_EVENT_CLIENT_DATA = ecore_event_type_new();
284 ECORE_IPC_EVENT_SERVER_DATA = ecore_event_type_new();
286 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,
287 _ecore_ipc_event_client_add, NULL);
288 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,
289 _ecore_ipc_event_client_del, NULL);
290 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
291 _ecore_ipc_event_server_add, NULL);
292 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
293 _ecore_ipc_event_server_del, NULL);
294 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA,
295 _ecore_ipc_event_client_data, NULL);
296 handler[i] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
297 _ecore_ipc_event_server_data, NULL);
298 return _ecore_ipc_init_count;
302 * Shuts down the Ecore IPC library.
303 * @return Number of times the library has been initialised without being
305 * @ingroup Ecore_IPC_Library_Group
308 ecore_ipc_shutdown(void)
312 if (--_ecore_ipc_init_count != 0)
313 return _ecore_ipc_init_count;
315 while (servers) ecore_ipc_server_del(eina_list_data_get(servers));
317 for (i = 0; i < 6; i++)
318 ecore_event_handler_del(handler[i]);
320 ecore_con_shutdown();
321 eina_log_domain_unregister(_ecore_ipc_log_dom);
322 _ecore_ipc_log_dom = -1;
323 return _ecore_ipc_init_count;
327 * @defgroup Ecore_IPC_Server_Group IPC Server Functions
329 * Functions the deal with IPC server objects.
333 * Creates an IPC server that listens for connections.
335 * For more details about the @p compl_type, @p name and @p port
336 * parameters, see the @ref ecore_con_server_add documentation.
338 * @param compl_type The connection type.
339 * @param name Name to associate with the socket used for connection.
340 * @param port Number to identify with socket used for connection.
341 * @param data Data to associate with the IPC server.
342 * @return New IPC server. If there is an error, @c NULL is returned.
343 * @ingroup Ecore_IPC_Server_Group
344 * @todo Need to add protocol type parameter to this function.
346 EAPI Ecore_Ipc_Server *
347 ecore_ipc_server_add(Ecore_Ipc_Type compl_type, const char *name, int port, const void *data)
349 Ecore_Ipc_Server *svr;
351 Ecore_Con_Type extra = 0;
353 svr = calloc(1, sizeof(Ecore_Ipc_Server));
354 if (!svr) return NULL;
356 type &= ~ECORE_IPC_USE_SSL;
357 if (compl_type & ECORE_IPC_USE_SSL) extra = ECORE_CON_USE_SSL;
360 case ECORE_IPC_LOCAL_USER:
361 svr->server = ecore_con_server_add(ECORE_CON_LOCAL_USER | extra, name, port, svr);
363 case ECORE_IPC_LOCAL_SYSTEM:
364 svr->server = ecore_con_server_add(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
366 case ECORE_IPC_REMOTE_SYSTEM:
367 svr->server = ecore_con_server_add(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
378 svr->max_buf_size = 32 * 1024;
379 svr->data = (void *)data;
380 servers = eina_list_append(servers, svr);
381 ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
386 * Creates an IPC server object to represent the IPC server listening
389 * For more details about the @p compl_type, @p name and @p port
390 * parameters, see the @ref ecore_con_server_connect documentation.
392 * @param compl_type The IPC connection type.
393 * @param name Name used to determine which socket to use for the
395 * @param port Number used to identify the socket to use for the
397 * @param data Data to associate with the server.
398 * @return A new IPC server. @c NULL is returned on error.
399 * @ingroup Ecore_IPC_Server_Group
400 * @todo Need to add protocol type parameter.
402 EAPI Ecore_Ipc_Server *
403 ecore_ipc_server_connect(Ecore_Ipc_Type compl_type, char *name, int port, const void *data)
405 Ecore_Ipc_Server *svr;
407 Ecore_Con_Type extra = 0;
409 svr = calloc(1, sizeof(Ecore_Ipc_Server));
410 if (!svr) return NULL;
412 type &= ~ECORE_IPC_USE_SSL;
413 if (compl_type & ECORE_IPC_USE_SSL) extra = ECORE_CON_USE_SSL;
416 case ECORE_IPC_LOCAL_USER:
417 svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_USER | extra, name, port, svr);
419 case ECORE_IPC_LOCAL_SYSTEM:
420 svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
422 case ECORE_IPC_REMOTE_SYSTEM:
423 svr->server = ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
434 svr->max_buf_size = -1;
435 svr->data = (void *)data;
436 servers = eina_list_append(servers, svr);
437 ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
442 * Closes the connection and frees the given IPC server.
443 * @param svr The given IPC server.
444 * @return The data associated with the server when it was created.
445 * @ingroup Ecore_IPC_Server_Group
448 ecore_ipc_server_del(Ecore_Ipc_Server *svr)
452 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
454 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
455 "ecore_ipc_server_del");
458 if (svr->delete_me) return NULL;
463 if (svr->event_count == 0)
465 Ecore_Ipc_Client *cl;
467 EINA_LIST_FREE(svr->clients, cl)
468 ecore_ipc_client_del(cl);
469 ecore_con_server_del(svr->server);
470 servers = eina_list_remove(servers, svr);
472 if (svr->buf) free(svr->buf);
473 ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
480 * Retrieves the data associated with the given IPC server.
481 * @param svr The given IPC server.
482 * @return The associated data.
483 * @ingroup Ecore_IPC_Server_Group
486 ecore_ipc_server_data_get(Ecore_Ipc_Server *svr)
488 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
490 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
491 "ecore_ipc_server_data_get");
498 * Retrieves whether the given IPC server is currently connected.
499 * @param svr The given IPC server.
500 * @return @c 1 if the server is connected. @c 0 otherwise.
501 * @ingroup Ecore_IPC_Server_Group
504 ecore_ipc_server_connected_get(Ecore_Ipc_Server *svr)
506 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
508 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
509 "ecore_ipc_server_connected_get");
512 return ecore_con_server_connected_get(svr->server);
516 * Retrieves the list of clients for this server.
517 * @param svr The given IPC server.
518 * @return An Eina_List with the clients.
519 * @ingroup Ecore_IPC_Server_Group
522 ecore_ipc_server_clients_get(Ecore_Ipc_Server *svr)
524 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
526 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
527 "ecore_ipc_server_clients_get");
530 return svr->client_list;
533 #define SVENC(_member) \
534 d = _ecore_ipc_dlt_int(msg._member, svr->prev.o._member, &md); \
539 dd = (unsigned char *)&v; \
542 *(dat + s + 0) = dd[0]; \
543 *(dat + s + 1) = dd[1]; \
544 *(dat + s + 2) = dd[2]; \
545 *(dat + s + 3) = dd[3]; \
548 else if (md >= DLT_ADD16) \
552 dd = (unsigned char *)&v; \
555 *(dat + s + 0) = dd[0]; \
556 *(dat + s + 1) = dd[1]; \
559 else if (md >= DLT_ADD8) \
561 *(dat + s + 0) = (unsigned char)d; \
566 * Sends a message to the given IPC server.
568 * The content of the parameters, excluding the @p svr paramter, is up to
571 * @param svr The given IPC server.
572 * @param major Major opcode of the message.
573 * @param minor Minor opcode of the message.
574 * @param ref Message reference number.
575 * @param ref_to Reference number of the message this message refers to.
576 * @param response Requires response.
577 * @param data The data to send as part of the message.
578 * @param size Length of the data, in bytes, to send.
579 * @return Number of bytes sent. @c 0 is returned if there is an error.
580 * @ingroup Ecore_IPC_Server_Group
581 * @todo This function needs to become an IPC message.
582 * @todo Fix up the documentation: Make sure what ref_to and response are.
585 ecore_ipc_server_send(Ecore_Ipc_Server *svr, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
587 Ecore_Ipc_Msg_Head msg;
589 int *head, md = 0, d, s;
590 unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
592 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
594 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
595 "ecore_ipc_server_send");
598 if (size < 0) size = 0;
603 msg.response = response;
610 *head |= md << (4 * 1);
612 *head |= md << (4 * 2);
614 *head |= md << (4 * 3);
616 *head |= md << (4 * 4);
618 *head |= md << (4 * 5);
619 *head = htonl(*head);
621 ret = ecore_con_server_send(svr->server, dat, s);
622 if (size > 0) ret += ecore_con_server_send(svr->server, data, size);
627 * Sets a limit on the number of clients that can be handled concurrently
628 * by the given server, and a policy on what to do if excess clients try to
630 * Beware that if you set this once ecore is already running, you may
631 * already have pending CLIENT_ADD events in your event queue. Those
632 * clients have already connected and will not be affected by this call.
633 * Only clients subsequently trying to connect will be affected.
634 * @param svr The given server.
635 * @param client_limit The maximum number of clients to handle
636 * concurrently. -1 means unlimited (default). 0
637 * effectively disables the server.
638 * @param reject_excess_clients Set to 1 to automatically disconnect
639 * excess clients as soon as they connect if you are
640 * already handling client_limit clients. Set to 0
641 * (default) to just hold off on the "accept()"
642 * system call until the number of active clients
643 * drops. This causes the kernel to queue up to 4096
644 * connections (or your kernel's limit, whichever is
646 * @ingroup Ecore_Ipc_Server_Group
649 ecore_ipc_server_client_limit_set(Ecore_Ipc_Server *svr, int client_limit, char reject_excess_clients)
651 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
653 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
654 "ecore_ipc_server_client_limit_set");
657 ecore_con_server_client_limit_set(svr->server, client_limit, reject_excess_clients);
661 * Sets the max data payload size for an Ipc message in bytes
663 * @param svr The given server.
664 * @param size The maximum data payload size in bytes.
665 * @ingroup Ecore_Ipc_Server_Group
668 ecore_ipc_server_data_size_max_set(Ecore_Ipc_Server *svr, int size)
670 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
672 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
673 "ecore_ipc_server_data_size_max_set");
676 svr->max_buf_size = size;
680 * Gets the max data payload size for an Ipc message in bytes
682 * @param svr The given server.
683 * @return The maximum data payload in bytes.
684 * @ingroup Ecore_Ipc_Server_Group
687 ecore_ipc_server_data_size_max_get(Ecore_Ipc_Server *svr)
689 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
691 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
692 "ecore_ipc_server_data_size_max_get");
695 return svr->max_buf_size;
699 * Gets the IP address of a server that has been connected to.
701 * @param svr The given server.
702 * @return A pointer to an internal string that contains the IP address of
703 * the connected server in the form "XXX.YYY.ZZZ.AAA" IP notation.
704 * This string should not be modified or trusted to stay valid after
705 * deletion for the @p svr object. If no IP is known NULL is returned.
706 * @ingroup Ecore_Ipc_Server_Group
709 ecore_ipc_server_ip_get(Ecore_Ipc_Server *svr)
711 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
713 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
714 "ecore_ipc_server_ip_get");
717 return ecore_con_server_ip_get(svr->server);
721 * Flushes all pending data to the given server. Will return when done.
723 * @param svr The given server.
724 * @ingroup Ecore_Ipc_Server_Group
727 ecore_ipc_server_flush(Ecore_Ipc_Server *svr)
729 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
731 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
732 "ecore_ipc_server_server_flush");
735 ecore_con_server_flush(svr->server);
738 #define CLENC(_member) \
739 d = _ecore_ipc_dlt_int(msg._member, cl->prev.o._member, &md); \
744 dd = (unsigned char *)&v; \
747 *(dat + s + 0) = dd[0]; \
748 *(dat + s + 1) = dd[1]; \
749 *(dat + s + 2) = dd[2]; \
750 *(dat + s + 3) = dd[3]; \
753 else if (md >= DLT_ADD16) \
757 dd = (unsigned char *)&v; \
760 *(dat + s + 0) = dd[0]; \
761 *(dat + s + 1) = dd[1]; \
764 else if (md >= DLT_ADD8) \
766 *(dat + s) = (unsigned char)d; \
771 * @defgroup Ecore_IPC_Client_Group IPC Client Functions
773 * Functions that deal with IPC client objects.
777 * Sends a message to the given IPC client.
778 * @param cl The given IPC client.
779 * @param major Major opcode of the message.
780 * @param minor Minor opcode of the message.
781 * @param ref Reference number of the message.
782 * @param ref_to Reference number of the message this message refers to.
783 * @param response Requires response.
784 * @param data The data to send as part of the message.
785 * @param size Length of the data, in bytes, to send.
786 * @return The number of bytes sent. @c 0 will be returned if there is
788 * @ingroup Ecore_IPC_Client_Group
789 * @todo This function needs to become an IPC message.
790 * @todo Make sure ref_to and response parameters are described correctly.
793 ecore_ipc_client_send(Ecore_Ipc_Client *cl, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
795 Ecore_Ipc_Msg_Head msg;
797 int *head, md = 0, d, s;
798 unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
800 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
802 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
803 "ecore_ipc_client_send");
806 if (size < 0) size = 0;
811 msg.response = response;
818 *head |= md << (4 * 1);
820 *head |= md << (4 * 2);
822 *head |= md << (4 * 3);
824 *head |= md << (4 * 4);
826 *head |= md << (4 * 5);
827 *head = htonl(*head);
829 ret = ecore_con_client_send(cl->client, dat, s);
830 if (size > 0) ret += ecore_con_client_send(cl->client, data, size);
835 * Retrieves the IPC server that the given IPC client is connected to.
836 * @param cl The given IPC client.
837 * @return The IPC server the IPC client is connected to.
838 * @ingroup Ecore_IPC_Client_Group
840 EAPI Ecore_Ipc_Server *
841 ecore_ipc_client_server_get(Ecore_Ipc_Client *cl)
843 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
845 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
846 "ecore_ipc_client_server_get");
849 return (ecore_con_server_data_get(ecore_con_client_server_get(cl->client)));
853 * Closes the connection and frees memory allocated to the given IPC
855 * @param cl The given client.
856 * @return Data associated with the client.
857 * @ingroup Ecore_IPC_Client_Group
860 ecore_ipc_client_del(Ecore_Ipc_Client *cl)
863 Ecore_Ipc_Server *svr;
865 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
867 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
868 "ecore_ipc_client_del");
874 if (cl->event_count == 0)
876 svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
877 ecore_con_client_del(cl->client);
878 svr->clients = eina_list_remove(svr->clients, cl);
879 if (cl->buf) free(cl->buf);
880 ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
887 * Sets the IPC data associated with the given IPC client to @p data.
888 * @param cl The given IPC client.
889 * @param data The data to associate with the IPC client.
890 * @ingroup Ecore_IPC_Client_Group
893 ecore_ipc_client_data_set(Ecore_Ipc_Client *cl, const void *data)
895 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
897 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
898 "ecore_ipc_client_data_set");
901 cl->data = (void *)data;
905 * Retrieves the data that has been associated with the given IPC client.
906 * @param cl The given client.
907 * @return The data associated with the IPC client.
908 * @ingroup Ecore_IPC_Client_Group
911 ecore_ipc_client_data_get(Ecore_Ipc_Client *cl)
913 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
915 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
916 "ecore_ipc_client_data_get");
923 * Sets the max data payload size for an Ipc message in bytes
925 * @param client The given client.
926 * @param size The maximum data payload size in bytes.
927 * @ingroup Ecore_Ipc_Client_Group
930 ecore_ipc_client_data_size_max_set(Ecore_Ipc_Client *cl, int size)
932 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
934 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
935 "ecore_ipc_client_data_size_max_set");
938 cl->max_buf_size = size;
942 * Sets the max data payload size for an Ipc message in bytes
944 * @param cl The given client.
945 * @param size The maximum data payload size in bytes.
946 * @ingroup Ecore_Ipc_Client_Group
949 ecore_ipc_client_data_size_max_get(Ecore_Ipc_Client *cl)
951 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
953 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
954 "ecore_ipc_client_data_size_max_get");
957 return cl->max_buf_size;
961 * Gets the IP address of a client that has been connected to.
963 * @param cl The given client.
964 * @return A pointer to an internal string that contains the IP address of
965 * the connected server in the form "XXX.YYY.ZZZ.AAA" IP notation.
966 * This string should not be modified or trusted to stay valid after
967 * deletion for the @p cl object. If no IP is known NULL is returned.
968 * @ingroup Ecore_Ipc_Client_Group
971 ecore_ipc_client_ip_get(Ecore_Ipc_Client *cl)
973 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
975 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
976 "ecore_ipc_client_ip_get");
979 return ecore_con_client_ip_get(cl->client);
983 * Flushes all pending data to the given client. Will return when done.
985 * @param cl The given client.
986 * @ingroup Ecore_Ipc_Client_Group
989 ecore_ipc_client_flush(Ecore_Ipc_Client *cl)
991 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
993 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
994 "ecore_ipc_client_flush");
997 ecore_con_client_flush(cl->client);
1001 * Returns if SSL support is available
1002 * @return 1 if SSL is available, 0 if it is not.
1003 * @ingroup Ecore_Con_Client_Group
1006 ecore_ipc_ssl_available_get(void)
1008 return ecore_con_ssl_available_get();
1013 _ecore_ipc_event_client_add(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1015 Ecore_Con_Event_Client_Add *e;
1018 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return 1;
1019 /* handling code here */
1021 Ecore_Ipc_Client *cl;
1022 Ecore_Ipc_Server *svr;
1024 cl = calloc(1, sizeof(Ecore_Ipc_Client));
1026 svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
1027 ECORE_MAGIC_SET(cl, ECORE_MAGIC_IPC_CLIENT);
1028 cl->client = e->client;
1029 cl->max_buf_size = 32 * 1024;
1030 ecore_con_client_data_set(cl->client, (void *)cl);
1031 svr->clients = eina_list_append(svr->clients, cl);
1032 svr->client_list = eina_list_append(svr->client_list, cl);
1035 Ecore_Ipc_Event_Client_Add *e2;
1037 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Add));
1042 ecore_event_add(ECORE_IPC_EVENT_CLIENT_ADD, e2,
1043 _ecore_ipc_event_client_add_free, NULL);
1051 _ecore_ipc_event_client_del(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1053 Ecore_Con_Event_Client_Del *e;
1056 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return 1;
1057 /* handling code here */
1059 Ecore_Ipc_Client *cl;
1061 cl = ecore_con_client_data_get(e->client);
1063 Ecore_Ipc_Event_Client_Del *e2;
1064 Ecore_Ipc_Server *svr;
1066 svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
1067 svr->client_list = eina_list_remove(svr->client_list, cl);
1070 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Del));
1075 ecore_event_add(ECORE_IPC_EVENT_CLIENT_DEL, e2,
1076 _ecore_ipc_event_client_del_free, NULL);
1085 _ecore_ipc_event_server_add(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1087 Ecore_Con_Event_Server_Add *e;
1090 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return 1;
1091 /* handling code here */
1093 Ecore_Ipc_Server *svr;
1095 svr = ecore_con_server_data_get(e->server);
1096 if (!svr->delete_me)
1098 Ecore_Ipc_Event_Server_Add *e2;
1100 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Add));
1105 ecore_event_add(ECORE_IPC_EVENT_SERVER_ADD, e2,
1106 _ecore_ipc_event_server_add_free, NULL);
1114 _ecore_ipc_event_server_del(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1116 Ecore_Con_Event_Server_Del *e;
1119 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return 1;
1120 /* handling code here */
1122 Ecore_Ipc_Server *svr;
1124 svr = ecore_con_server_data_get(e->server);
1125 if (!svr->delete_me)
1127 Ecore_Ipc_Event_Server_Del *e2;
1129 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Del));
1134 ecore_event_add(ECORE_IPC_EVENT_SERVER_DEL, e2,
1135 _ecore_ipc_event_server_del_free, NULL);
1143 md = ((head >> (4 * _n)) & 0xf); \
1144 if (md >= DLT_SET) s += 4; \
1145 else if (md >= DLT_ADD16) s += 2; \
1146 else if (md >= DLT_ADD8) s += 1;
1148 #define CLDEC(_n, _member) \
1149 md = ((head >> (4 * _n)) & 0xf); \
1150 if (md >= DLT_SET) \
1153 unsigned char *dv; \
1154 dv = (unsigned char *)&v; \
1155 dv[0] = *(cl->buf + offset + s + 0); \
1156 dv[1] = *(cl->buf + offset + s + 1); \
1157 dv[2] = *(cl->buf + offset + s + 2); \
1158 dv[3] = *(cl->buf + offset + s + 3); \
1159 d = (int)ntohl(v); \
1162 else if (md >= DLT_ADD16) \
1165 unsigned char *dv; \
1166 dv = (unsigned char *)&v; \
1167 dv[0] = *(cl->buf + offset + s + 0); \
1168 dv[1] = *(cl->buf + offset + s + 1); \
1169 d = (int)ntohs(v); \
1172 else if (md >= DLT_ADD8) \
1175 unsigned char *dv; \
1176 dv = (unsigned char *)&v; \
1177 dv[0] = *(cl->buf + offset + s + 0); \
1181 msg._member = _ecore_ipc_ddlt_int(d, cl->prev.i._member, md);
1184 _ecore_ipc_event_client_data(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1186 Ecore_Con_Event_Client_Data *e;
1189 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return 1;
1190 /* handling code here */
1192 Ecore_Ipc_Client *cl;
1193 Ecore_Ipc_Msg_Head msg;
1197 cl = ecore_con_client_data_get(e->client);
1201 cl->buf_size = e->size;
1203 e->data = NULL; /* take it out of the old event */
1207 buf = realloc(cl->buf, cl->buf_size + e->size);
1216 memcpy(cl->buf + cl->buf_size, e->data, e->size);
1217 cl->buf_size += e->size;
1219 /* examine header */
1221 if ((cl->buf_size - offset) >= (int)sizeof(int))
1223 int s, md, d = 0, head;
1226 dd = (unsigned char *)&head;
1227 dd[0] = *(cl->buf + offset + 0);
1228 dd[1] = *(cl->buf + offset + 1);
1229 dd[2] = *(cl->buf + offset + 2);
1230 dd[3] = *(cl->buf + offset + 3);
1232 dd = (unsigned char *)&d;
1240 if ((cl->buf_size - offset) < s)
1242 if (offset > 0) goto scroll;
1253 if (msg.size < 0) msg.size = 0;
1254 /* there is enough data in the buffer for a full message */
1255 if ((cl->buf_size - offset) >= (s + msg.size))
1257 Ecore_Ipc_Event_Client_Data *e2;
1258 Ecore_Ipc_Server *svr;
1262 svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
1263 max = svr->max_buf_size;
1264 max2 = cl->max_buf_size;
1265 if ((max >= 0) && (max2 >= 0))
1267 if (max2 < max) max = max2;
1271 if (max < 0) max = max2;
1273 if ((max < 0) || (msg.size <= max))
1277 buf = malloc(msg.size);
1279 memcpy(buf, cl->buf + offset + s, msg.size);
1283 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Data));
1288 e2->major = msg.major;
1289 e2->minor = msg.minor;
1291 e2->ref_to = msg.ref_to;
1292 e2->response = msg.response;
1293 e2->size = msg.size;
1295 ecore_event_add(ECORE_IPC_EVENT_CLIENT_DATA, e2,
1296 _ecore_ipc_event_client_data_free,
1302 offset += (s + msg.size);
1303 if (cl->buf_size == offset)
1317 buf = malloc(cl->buf_size - offset);
1325 memcpy(buf, cl->buf + offset, cl->buf_size - offset);
1328 cl->buf_size -= offset;
1335 md = ((head >> (4 * _n)) & 0xf); \
1336 if (md >= DLT_SET) s += 4; \
1337 else if (md >= DLT_ADD16) s += 2; \
1338 else if (md >= DLT_ADD8) s += 1;
1340 #define SVDEC(_n, _member) \
1341 md = ((head >> (4 * _n)) & 0xf); \
1342 if (md >= DLT_SET) \
1345 unsigned char *dv; \
1346 dv = (unsigned char *)&v; \
1347 dv[0] = *(svr->buf + offset + s + 0); \
1348 dv[1] = *(svr->buf + offset + s + 1); \
1349 dv[2] = *(svr->buf + offset + s + 2); \
1350 dv[3] = *(svr->buf + offset + s + 3); \
1351 d = (int)ntohl(v); \
1354 else if (md >= DLT_ADD16) \
1357 unsigned char *dv; \
1358 dv = (unsigned char *)&v; \
1359 dv[0] = *(svr->buf + offset + s + 0); \
1360 dv[1] = *(svr->buf + offset + s + 1); \
1361 d = (int)ntohs(v); \
1364 else if (md >= DLT_ADD8) \
1367 unsigned char *dv; \
1368 dv = (unsigned char *)&v; \
1369 dv[0] = *(svr->buf + offset + s + 0); \
1373 msg._member = _ecore_ipc_ddlt_int(d, svr->prev.i._member, md);
1376 _ecore_ipc_event_server_data(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1378 Ecore_Con_Event_Server_Data *e;
1381 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return 1;
1382 /* handling code here */
1384 Ecore_Ipc_Server *svr;
1385 Ecore_Ipc_Msg_Head msg;
1389 svr = ecore_con_server_data_get(e->server);
1393 svr->buf_size = e->size;
1395 e->data = NULL; /* take it out of the old event */
1399 buf = realloc(svr->buf, svr->buf_size + e->size);
1408 memcpy(svr->buf + svr->buf_size, e->data, e->size);
1409 svr->buf_size += e->size;
1411 /* examine header */
1413 if ((svr->buf_size - offset) >= (int)sizeof(int))
1415 int s, md, d = 0, head;
1418 dd = (unsigned char *)&head;
1419 dd[0] = *(svr->buf + offset + 0);
1420 dd[1] = *(svr->buf + offset + 1);
1421 dd[2] = *(svr->buf + offset + 2);
1422 dd[3] = *(svr->buf + offset + 3);
1424 dd = (unsigned char *)&d;
1432 if ((svr->buf_size - offset) < s)
1434 if (offset > 0) goto scroll;
1445 if (msg.size < 0) msg.size = 0;
1446 /* there is enough data in the buffer for a full message */
1447 if ((svr->buf_size - offset) >= (s + msg.size))
1449 Ecore_Ipc_Event_Server_Data *e2;
1453 max = svr->max_buf_size;
1454 if ((max < 0) || (msg.size <= max))
1458 buf = malloc(msg.size);
1460 memcpy(buf, svr->buf + offset + s, msg.size);
1462 if (!svr->delete_me)
1464 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Data));
1469 e2->major = msg.major;
1470 e2->minor = msg.minor;
1472 e2->ref_to = msg.ref_to;
1473 e2->response = msg.response;
1474 e2->size = msg.size;
1476 ecore_event_add(ECORE_IPC_EVENT_SERVER_DATA, e2,
1477 _ecore_ipc_event_server_data_free,
1483 offset += (s + msg.size);
1484 if (svr->buf_size == offset)
1498 buf = malloc(svr->buf_size - offset);
1506 memcpy(buf, svr->buf + offset, svr->buf_size - offset);
1509 svr->buf_size -= offset;
1516 _ecore_ipc_event_client_add_free(void *data __UNUSED__, void *ev)
1518 Ecore_Ipc_Event_Client_Add *e;
1521 e->client->event_count--;
1522 if ((e->client->event_count == 0) && (e->client->delete_me))
1523 ecore_ipc_client_del(e->client);
1528 _ecore_ipc_event_client_del_free(void *data __UNUSED__, void *ev)
1530 Ecore_Ipc_Event_Client_Del *e;
1533 e->client->event_count--;
1534 if ((e->client->event_count == 0) && (e->client->delete_me))
1535 ecore_ipc_client_del(e->client);
1540 _ecore_ipc_event_client_data_free(void *data __UNUSED__, void *ev)
1542 Ecore_Ipc_Event_Client_Data *e;
1545 e->client->event_count--;
1546 if (e->data) free(e->data);
1547 if ((e->client->event_count == 0) && (e->client->delete_me))
1548 ecore_ipc_client_del(e->client);
1553 _ecore_ipc_event_server_add_free(void *data __UNUSED__, void *ev)
1555 Ecore_Ipc_Event_Server_Add *e;
1558 e->server->event_count--;
1559 if ((e->server->event_count == 0) && (e->server->delete_me))
1560 ecore_ipc_server_del(e->server);
1565 _ecore_ipc_event_server_del_free(void *data __UNUSED__, void *ev)
1567 Ecore_Ipc_Event_Server_Add *e;
1570 e->server->event_count--;
1571 if ((e->server->event_count == 0) && (e->server->delete_me))
1572 ecore_ipc_server_del(e->server);
1577 _ecore_ipc_event_server_data_free(void *data __UNUSED__, void *ev)
1579 Ecore_Ipc_Event_Server_Data *e;
1582 if (e->data) free(e->data);
1583 e->server->event_count--;
1584 if ((e->server->event_count == 0) && (e->server->delete_me))
1585 ecore_ipc_server_del(e->server);