2 * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
11 #ifdef HAVE_NETINET_IN_H
12 # include <sys/types.h>
13 # include <netinet/in.h>
16 #ifdef HAVE_WINSOCK2_H
17 # include <winsock2.h>
21 #include "ecore_private.h"
22 #include "Ecore_Con.h"
23 #include "ecore_ipc_private.h"
24 #include "Ecore_Ipc.h"
43 int _ecore_ipc_log_dom = -1;
45 /* byte swappers - for dealing with big vs little endian machines */
47 _ecore_ipc_swap_16(unsigned short v)
51 s = (unsigned char *)(&v);
52 t = s[0]; s[0] = s[1]; s[1] = t;
57 _ecore_ipc_swap_32(unsigned int v)
61 s = (unsigned char *)(&v);
62 t = s[0]; s[0] = s[3]; s[3] = t;
63 t = s[1]; s[1] = s[2]; s[2] = t;
67 EAPI unsigned long long
68 _ecore_ipc_swap_64(unsigned long long v)
72 s = (unsigned char *)(&v);
73 t = s[0]; s[0] = s[7]; s[7] = t;
74 t = s[1]; s[1] = s[6]; s[6] = t;
75 t = s[2]; s[2] = s[5]; s[5] = t;
76 t = s[3]; s[3] = s[4]; s[4] = t;
80 static int _ecore_ipc_dlt_int(int out, int prev, int *mode);
81 static int _ecore_ipc_ddlt_int(int in, int prev, int mode);
84 _ecore_ipc_dlt_int(int out, int prev, int *mode)
94 if (out == (int)0xffffffff)
104 if (out == prev << 1)
109 if (out == prev >> 1)
116 if (!(dlt & 0xffffff00))
122 if (!(dlt & 0xffffff00))
128 if (!(dlt & 0x00ffffff))
131 return (dlt >> 24) & 0xff;
134 if (!(dlt & 0x00ffffff))
137 return (dlt >> 24) & 0xff;
141 if (!(dlt & 0xffff0000))
147 if (!(dlt & 0xffff0000))
153 if (!(dlt & 0x0000ffff))
156 return (dlt >> 16) & 0xffff;
159 if (!(dlt & 0x0000ffff))
162 return (dlt >> 16) & 0xffff;
170 _ecore_ipc_ddlt_int(int in, int prev, int mode)
196 return prev + (in << 24);
199 return prev - (in << 24);
208 return prev + (in << 16);
211 return prev - (in << 16);
228 static Eina_Bool _ecore_ipc_event_client_add(void *data, int ev_type, void *ev);
229 static Eina_Bool _ecore_ipc_event_client_del(void *data, int ev_type, void *ev);
230 static Eina_Bool _ecore_ipc_event_server_add(void *data, int ev_type, void *ev);
231 static Eina_Bool _ecore_ipc_event_server_del(void *data, int ev_type, void *ev);
232 static Eina_Bool _ecore_ipc_event_client_data(void *data, int ev_type, void *ev);
233 static Eina_Bool _ecore_ipc_event_server_data(void *data, int ev_type, void *ev);
234 static void _ecore_ipc_event_client_add_free(void *data, void *ev);
235 static void _ecore_ipc_event_client_del_free(void *data, void *ev);
236 static void _ecore_ipc_event_client_data_free(void *data, void *ev);
237 static void _ecore_ipc_event_server_add_free(void *data, void *ev);
238 static void _ecore_ipc_event_server_del_free(void *data, void *ev);
239 static void _ecore_ipc_event_server_data_free(void *data, void *ev);
241 EAPI int ECORE_IPC_EVENT_CLIENT_ADD = 0;
242 EAPI int ECORE_IPC_EVENT_CLIENT_DEL = 0;
243 EAPI int ECORE_IPC_EVENT_SERVER_ADD = 0;
244 EAPI int ECORE_IPC_EVENT_SERVER_DEL = 0;
245 EAPI int ECORE_IPC_EVENT_CLIENT_DATA = 0;
246 EAPI int ECORE_IPC_EVENT_SERVER_DATA = 0;
248 static int _ecore_ipc_init_count = 0;
249 static Eina_List *servers = NULL;
250 static Ecore_Event_Handler *handler[6];
253 * @defgroup Ecore_IPC_Library_Group IPC Library Functions
255 * Functions that set up and shut down the Ecore IPC Library.
259 * Initialises the Ecore IPC library.
260 * @return Number of times the library has been initialised without
262 * @ingroup Ecore_IPC_Library_Group
269 if (++_ecore_ipc_init_count != 1)
270 return _ecore_ipc_init_count;
271 _ecore_ipc_log_dom = eina_log_domain_register("EcoreIpc", ECORE_IPC_DEFAULT_LOG_COLOR);
272 if(_ecore_ipc_log_dom < 0)
274 EINA_LOG_ERR("Impossible to create a log domain for the Ecore IPC module.");
275 return --_ecore_ipc_init_count;
277 if (!ecore_con_init())
278 return --_ecore_ipc_init_count;
280 ECORE_IPC_EVENT_CLIENT_ADD = ecore_event_type_new();
281 ECORE_IPC_EVENT_CLIENT_DEL = ecore_event_type_new();
282 ECORE_IPC_EVENT_SERVER_ADD = ecore_event_type_new();
283 ECORE_IPC_EVENT_SERVER_DEL = ecore_event_type_new();
284 ECORE_IPC_EVENT_CLIENT_DATA = ecore_event_type_new();
285 ECORE_IPC_EVENT_SERVER_DATA = ecore_event_type_new();
287 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,
288 _ecore_ipc_event_client_add, NULL);
289 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,
290 _ecore_ipc_event_client_del, NULL);
291 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
292 _ecore_ipc_event_server_add, NULL);
293 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
294 _ecore_ipc_event_server_del, NULL);
295 handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA,
296 _ecore_ipc_event_client_data, NULL);
297 handler[i] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
298 _ecore_ipc_event_server_data, NULL);
299 return _ecore_ipc_init_count;
303 * Shuts down the Ecore IPC library.
304 * @return Number of times the library has been initialised without being
306 * @ingroup Ecore_IPC_Library_Group
309 ecore_ipc_shutdown(void)
313 if (--_ecore_ipc_init_count != 0)
314 return _ecore_ipc_init_count;
316 while (servers) ecore_ipc_server_del(eina_list_data_get(servers));
318 for (i = 0; i < 6; i++)
319 ecore_event_handler_del(handler[i]);
321 ecore_con_shutdown();
322 eina_log_domain_unregister(_ecore_ipc_log_dom);
323 _ecore_ipc_log_dom = -1;
324 return _ecore_ipc_init_count;
328 * @defgroup Ecore_IPC_Server_Group IPC Server Functions
330 * Functions the deal with IPC server objects.
334 * Creates an IPC server that listens for connections.
336 * For more details about the @p compl_type, @p name and @p port
337 * parameters, see the @ref ecore_con_server_add documentation.
339 * @param compl_type The connection type.
340 * @param name Name to associate with the socket used for connection.
341 * @param port Number to identify with socket used for connection.
342 * @param data Data to associate with the IPC server.
343 * @return New IPC server. If there is an error, @c NULL is returned.
344 * @ingroup Ecore_IPC_Server_Group
345 * @todo Need to add protocol type parameter to this function.
347 EAPI Ecore_Ipc_Server *
348 ecore_ipc_server_add(Ecore_Ipc_Type compl_type, const char *name, int port, const void *data)
350 Ecore_Ipc_Server *svr;
352 Ecore_Con_Type extra = 0;
354 svr = calloc(1, sizeof(Ecore_Ipc_Server));
355 if (!svr) return NULL;
357 type &= ~ECORE_IPC_USE_SSL;
358 if (compl_type & ECORE_IPC_USE_SSL) extra = ECORE_CON_USE_SSL;
361 case ECORE_IPC_LOCAL_USER:
362 svr->server = ecore_con_server_add(ECORE_CON_LOCAL_USER | extra, name, port, svr);
364 case ECORE_IPC_LOCAL_SYSTEM:
365 svr->server = ecore_con_server_add(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
367 case ECORE_IPC_REMOTE_SYSTEM:
368 svr->server = ecore_con_server_add(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
379 svr->max_buf_size = 32 * 1024;
380 svr->data = (void *)data;
381 servers = eina_list_append(servers, svr);
382 ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
387 * Creates an IPC server object to represent the IPC server listening
390 * For more details about the @p compl_type, @p name and @p port
391 * parameters, see the @ref ecore_con_server_connect documentation.
393 * @param compl_type The IPC connection type.
394 * @param name Name used to determine which socket to use for the
396 * @param port Number used to identify the socket to use for the
398 * @param data Data to associate with the server.
399 * @return A new IPC server. @c NULL is returned on error.
400 * @ingroup Ecore_IPC_Server_Group
401 * @todo Need to add protocol type parameter.
403 EAPI Ecore_Ipc_Server *
404 ecore_ipc_server_connect(Ecore_Ipc_Type compl_type, char *name, int port, const void *data)
406 Ecore_Ipc_Server *svr;
408 Ecore_Con_Type extra = 0;
410 svr = calloc(1, sizeof(Ecore_Ipc_Server));
411 if (!svr) return NULL;
413 type &= ~ECORE_IPC_USE_SSL;
414 if (compl_type & ECORE_IPC_USE_SSL) extra = ECORE_CON_USE_SSL;
417 case ECORE_IPC_LOCAL_USER:
418 svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_USER | extra, name, port, svr);
420 case ECORE_IPC_LOCAL_SYSTEM:
421 svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
423 case ECORE_IPC_REMOTE_SYSTEM:
424 svr->server = ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
435 svr->max_buf_size = -1;
436 svr->data = (void *)data;
437 servers = eina_list_append(servers, svr);
438 ECORE_MAGIC_SET(svr, ECORE_MAGIC_IPC_SERVER);
443 * Closes the connection and frees the given IPC server.
444 * @param svr The given IPC server.
445 * @return The data associated with the server when it was created.
446 * @ingroup Ecore_IPC_Server_Group
449 ecore_ipc_server_del(Ecore_Ipc_Server *svr)
453 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
455 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
456 "ecore_ipc_server_del");
459 if (svr->delete_me) return NULL;
464 if (svr->event_count == 0)
466 Ecore_Ipc_Client *cl;
468 EINA_LIST_FREE(svr->clients, cl)
469 ecore_ipc_client_del(cl);
470 ecore_con_server_del(svr->server);
471 servers = eina_list_remove(servers, svr);
473 if (svr->buf) free(svr->buf);
474 ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
481 * Retrieves the data associated with the given IPC server.
482 * @param svr The given IPC server.
483 * @return The associated data.
484 * @ingroup Ecore_IPC_Server_Group
487 ecore_ipc_server_data_get(Ecore_Ipc_Server *svr)
489 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
491 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
492 "ecore_ipc_server_data_get");
499 * Retrieves whether the given IPC server is currently connected.
500 * @param svr The given IPC server.
501 * @return @c 1 if the server is connected. @c 0 otherwise.
502 * @ingroup Ecore_IPC_Server_Group
505 ecore_ipc_server_connected_get(Ecore_Ipc_Server *svr)
507 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
509 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
510 "ecore_ipc_server_connected_get");
513 return ecore_con_server_connected_get(svr->server);
517 * Retrieves the list of clients for this server.
518 * @param svr The given IPC server.
519 * @return An Eina_List with the clients.
520 * @ingroup Ecore_IPC_Server_Group
523 ecore_ipc_server_clients_get(Ecore_Ipc_Server *svr)
525 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
527 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
528 "ecore_ipc_server_clients_get");
531 return svr->client_list;
534 #define SVENC(_member) \
535 d = _ecore_ipc_dlt_int(msg._member, svr->prev.o._member, &md); \
540 dd = (unsigned char *)&v; \
543 *(dat + s + 0) = dd[0]; \
544 *(dat + s + 1) = dd[1]; \
545 *(dat + s + 2) = dd[2]; \
546 *(dat + s + 3) = dd[3]; \
549 else if (md >= DLT_ADD16) \
553 dd = (unsigned char *)&v; \
556 *(dat + s + 0) = dd[0]; \
557 *(dat + s + 1) = dd[1]; \
560 else if (md >= DLT_ADD8) \
562 *(dat + s + 0) = (unsigned char)d; \
567 * Sends a message to the given IPC server.
569 * The content of the parameters, excluding the @p svr paramter, is up to
572 * @param svr The given IPC server.
573 * @param major Major opcode of the message.
574 * @param minor Minor opcode of the message.
575 * @param ref Message reference number.
576 * @param ref_to Reference number of the message this message refers to.
577 * @param response Requires response.
578 * @param data The data to send as part of the message.
579 * @param size Length of the data, in bytes, to send.
580 * @return Number of bytes sent. @c 0 is returned if there is an error.
581 * @ingroup Ecore_IPC_Server_Group
582 * @todo This function needs to become an IPC message.
583 * @todo Fix up the documentation: Make sure what ref_to and response are.
586 ecore_ipc_server_send(Ecore_Ipc_Server *svr, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
588 Ecore_Ipc_Msg_Head msg;
590 int *head, md = 0, d, s;
591 unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
593 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
595 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
596 "ecore_ipc_server_send");
599 if (size < 0) size = 0;
604 msg.response = response;
611 *head |= md << (4 * 1);
613 *head |= md << (4 * 2);
615 *head |= md << (4 * 3);
617 *head |= md << (4 * 4);
619 *head |= md << (4 * 5);
620 *head = htonl(*head);
622 ret = ecore_con_server_send(svr->server, dat, s);
623 if (size > 0) ret += ecore_con_server_send(svr->server, data, size);
628 * Sets a limit on the number of clients that can be handled concurrently
629 * by the given server, and a policy on what to do if excess clients try to
631 * Beware that if you set this once ecore is already running, you may
632 * already have pending CLIENT_ADD events in your event queue. Those
633 * clients have already connected and will not be affected by this call.
634 * Only clients subsequently trying to connect will be affected.
635 * @param svr The given server.
636 * @param client_limit The maximum number of clients to handle
637 * concurrently. -1 means unlimited (default). 0
638 * effectively disables the server.
639 * @param reject_excess_clients Set to 1 to automatically disconnect
640 * excess clients as soon as they connect if you are
641 * already handling client_limit clients. Set to 0
642 * (default) to just hold off on the "accept()"
643 * system call until the number of active clients
644 * drops. This causes the kernel to queue up to 4096
645 * connections (or your kernel's limit, whichever is
647 * @ingroup Ecore_Ipc_Server_Group
650 ecore_ipc_server_client_limit_set(Ecore_Ipc_Server *svr, int client_limit, char reject_excess_clients)
652 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
654 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
655 "ecore_ipc_server_client_limit_set");
658 ecore_con_server_client_limit_set(svr->server, client_limit, reject_excess_clients);
662 * Sets the max data payload size for an Ipc message in bytes
664 * @param svr The given server.
665 * @param size The maximum data payload size in bytes.
666 * @ingroup Ecore_Ipc_Server_Group
669 ecore_ipc_server_data_size_max_set(Ecore_Ipc_Server *svr, int size)
671 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
673 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
674 "ecore_ipc_server_data_size_max_set");
677 svr->max_buf_size = size;
681 * Gets the max data payload size for an Ipc message in bytes
683 * @param svr The given server.
684 * @return The maximum data payload in bytes.
685 * @ingroup Ecore_Ipc_Server_Group
688 ecore_ipc_server_data_size_max_get(Ecore_Ipc_Server *svr)
690 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
692 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
693 "ecore_ipc_server_data_size_max_get");
696 return svr->max_buf_size;
700 * Gets the IP address of a server that has been connected to.
702 * @param svr The given server.
703 * @return A pointer to an internal string that contains the IP address of
704 * the connected server in the form "XXX.YYY.ZZZ.AAA" IP notation.
705 * This string should not be modified or trusted to stay valid after
706 * deletion for the @p svr object. If no IP is known NULL is returned.
707 * @ingroup Ecore_Ipc_Server_Group
710 ecore_ipc_server_ip_get(Ecore_Ipc_Server *svr)
712 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
714 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
715 "ecore_ipc_server_ip_get");
718 return ecore_con_server_ip_get(svr->server);
722 * Flushes all pending data to the given server. Will return when done.
724 * @param svr The given server.
725 * @ingroup Ecore_Ipc_Server_Group
728 ecore_ipc_server_flush(Ecore_Ipc_Server *svr)
730 if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
732 ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
733 "ecore_ipc_server_server_flush");
736 ecore_con_server_flush(svr->server);
739 #define CLENC(_member) \
740 d = _ecore_ipc_dlt_int(msg._member, cl->prev.o._member, &md); \
745 dd = (unsigned char *)&v; \
748 *(dat + s + 0) = dd[0]; \
749 *(dat + s + 1) = dd[1]; \
750 *(dat + s + 2) = dd[2]; \
751 *(dat + s + 3) = dd[3]; \
754 else if (md >= DLT_ADD16) \
758 dd = (unsigned char *)&v; \
761 *(dat + s + 0) = dd[0]; \
762 *(dat + s + 1) = dd[1]; \
765 else if (md >= DLT_ADD8) \
767 *(dat + s) = (unsigned char)d; \
772 * @defgroup Ecore_IPC_Client_Group IPC Client Functions
774 * Functions that deal with IPC client objects.
778 * Sends a message to the given IPC client.
779 * @param cl The given IPC client.
780 * @param major Major opcode of the message.
781 * @param minor Minor opcode of the message.
782 * @param ref Reference number of the message.
783 * @param ref_to Reference number of the message this message refers to.
784 * @param response Requires response.
785 * @param data The data to send as part of the message.
786 * @param size Length of the data, in bytes, to send.
787 * @return The number of bytes sent. @c 0 will be returned if there is
789 * @ingroup Ecore_IPC_Client_Group
790 * @todo This function needs to become an IPC message.
791 * @todo Make sure ref_to and response parameters are described correctly.
794 ecore_ipc_client_send(Ecore_Ipc_Client *cl, int major, int minor, int ref, int ref_to, int response, const void *data, int size)
796 Ecore_Ipc_Msg_Head msg;
798 int *head, md = 0, d, s;
799 unsigned char dat[sizeof(Ecore_Ipc_Msg_Head)];
801 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
803 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
804 "ecore_ipc_client_send");
807 if (size < 0) size = 0;
812 msg.response = response;
819 *head |= md << (4 * 1);
821 *head |= md << (4 * 2);
823 *head |= md << (4 * 3);
825 *head |= md << (4 * 4);
827 *head |= md << (4 * 5);
828 *head = htonl(*head);
830 ret = ecore_con_client_send(cl->client, dat, s);
831 if (size > 0) ret += ecore_con_client_send(cl->client, data, size);
836 * Retrieves the IPC server that the given IPC client is connected to.
837 * @param cl The given IPC client.
838 * @return The IPC server the IPC client is connected to.
839 * @ingroup Ecore_IPC_Client_Group
841 EAPI Ecore_Ipc_Server *
842 ecore_ipc_client_server_get(Ecore_Ipc_Client *cl)
844 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
846 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
847 "ecore_ipc_client_server_get");
850 return (ecore_con_server_data_get(ecore_con_client_server_get(cl->client)));
854 * Closes the connection and frees memory allocated to the given IPC
856 * @param cl The given client.
857 * @return Data associated with the client.
858 * @ingroup Ecore_IPC_Client_Group
861 ecore_ipc_client_del(Ecore_Ipc_Client *cl)
864 Ecore_Ipc_Server *svr;
866 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
868 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
869 "ecore_ipc_client_del");
875 if (cl->event_count == 0)
877 svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
878 ecore_con_client_del(cl->client);
879 svr->clients = eina_list_remove(svr->clients, cl);
880 if (cl->buf) free(cl->buf);
881 ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
888 * Sets the IPC data associated with the given IPC client to @p data.
889 * @param cl The given IPC client.
890 * @param data The data to associate with the IPC client.
891 * @ingroup Ecore_IPC_Client_Group
894 ecore_ipc_client_data_set(Ecore_Ipc_Client *cl, const void *data)
896 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
898 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
899 "ecore_ipc_client_data_set");
902 cl->data = (void *)data;
906 * Retrieves the data that has been associated with the given IPC client.
907 * @param cl The given client.
908 * @return The data associated with the IPC client.
909 * @ingroup Ecore_IPC_Client_Group
912 ecore_ipc_client_data_get(Ecore_Ipc_Client *cl)
914 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
916 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
917 "ecore_ipc_client_data_get");
924 * Sets the max data payload size for an Ipc message in bytes
926 * @param client The given client.
927 * @param size The maximum data payload size in bytes.
928 * @ingroup Ecore_Ipc_Client_Group
931 ecore_ipc_client_data_size_max_set(Ecore_Ipc_Client *cl, int size)
933 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
935 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
936 "ecore_ipc_client_data_size_max_set");
939 cl->max_buf_size = size;
943 * Sets the max data payload size for an Ipc message in bytes
945 * @param cl The given client.
946 * @param size The maximum data payload size in bytes.
947 * @ingroup Ecore_Ipc_Client_Group
950 ecore_ipc_client_data_size_max_get(Ecore_Ipc_Client *cl)
952 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
954 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
955 "ecore_ipc_client_data_size_max_get");
958 return cl->max_buf_size;
962 * Gets the IP address of a client that has been connected to.
964 * @param cl The given client.
965 * @return A pointer to an internal string that contains the IP address of
966 * the connected server in the form "XXX.YYY.ZZZ.AAA" IP notation.
967 * This string should not be modified or trusted to stay valid after
968 * deletion for the @p cl object. If no IP is known NULL is returned.
969 * @ingroup Ecore_Ipc_Client_Group
972 ecore_ipc_client_ip_get(Ecore_Ipc_Client *cl)
974 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
976 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
977 "ecore_ipc_client_ip_get");
980 return ecore_con_client_ip_get(cl->client);
984 * Flushes all pending data to the given client. Will return when done.
986 * @param cl The given client.
987 * @ingroup Ecore_Ipc_Client_Group
990 ecore_ipc_client_flush(Ecore_Ipc_Client *cl)
992 if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
994 ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
995 "ecore_ipc_client_flush");
998 ecore_con_client_flush(cl->client);
1002 * Returns if SSL support is available
1003 * @return 1 if SSL is available, 0 if it is not.
1004 * @ingroup Ecore_Con_Client_Group
1007 ecore_ipc_ssl_available_get(void)
1009 return ecore_con_ssl_available_get();
1014 _ecore_ipc_event_client_add(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1016 Ecore_Con_Event_Client_Add *e;
1019 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
1020 /* handling code here */
1022 Ecore_Ipc_Client *cl;
1023 Ecore_Ipc_Server *svr;
1025 cl = calloc(1, sizeof(Ecore_Ipc_Client));
1026 if (!cl) return ECORE_CALLBACK_CANCEL;
1027 svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
1028 ECORE_MAGIC_SET(cl, ECORE_MAGIC_IPC_CLIENT);
1029 cl->client = e->client;
1030 cl->max_buf_size = 32 * 1024;
1031 ecore_con_client_data_set(cl->client, (void *)cl);
1032 svr->clients = eina_list_append(svr->clients, cl);
1033 svr->client_list = eina_list_append(svr->client_list, cl);
1036 Ecore_Ipc_Event_Client_Add *e2;
1038 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Add));
1043 ecore_event_add(ECORE_IPC_EVENT_CLIENT_ADD, e2,
1044 _ecore_ipc_event_client_add_free, NULL);
1048 return ECORE_CALLBACK_CANCEL;
1052 _ecore_ipc_event_client_del(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1054 Ecore_Con_Event_Client_Del *e;
1057 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
1058 /* handling code here */
1060 Ecore_Ipc_Client *cl;
1062 cl = ecore_con_client_data_get(e->client);
1064 Ecore_Ipc_Event_Client_Del *e2;
1065 Ecore_Ipc_Server *svr;
1067 svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
1068 svr->client_list = eina_list_remove(svr->client_list, cl);
1071 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Del));
1076 ecore_event_add(ECORE_IPC_EVENT_CLIENT_DEL, e2,
1077 _ecore_ipc_event_client_del_free, NULL);
1082 return ECORE_CALLBACK_CANCEL;
1086 _ecore_ipc_event_server_add(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1088 Ecore_Con_Event_Server_Add *e;
1091 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
1092 /* handling code here */
1094 Ecore_Ipc_Server *svr;
1096 svr = ecore_con_server_data_get(e->server);
1097 if (!svr->delete_me)
1099 Ecore_Ipc_Event_Server_Add *e2;
1101 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Add));
1106 ecore_event_add(ECORE_IPC_EVENT_SERVER_ADD, e2,
1107 _ecore_ipc_event_server_add_free, NULL);
1111 return ECORE_CALLBACK_CANCEL;
1115 _ecore_ipc_event_server_del(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1117 Ecore_Con_Event_Server_Del *e;
1120 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
1121 /* handling code here */
1123 Ecore_Ipc_Server *svr;
1125 svr = ecore_con_server_data_get(e->server);
1126 if (!svr->delete_me)
1128 Ecore_Ipc_Event_Server_Del *e2;
1130 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Del));
1135 ecore_event_add(ECORE_IPC_EVENT_SERVER_DEL, e2,
1136 _ecore_ipc_event_server_del_free, NULL);
1140 return ECORE_CALLBACK_CANCEL;
1144 md = ((head >> (4 * _n)) & 0xf); \
1145 if (md >= DLT_SET) s += 4; \
1146 else if (md >= DLT_ADD16) s += 2; \
1147 else if (md >= DLT_ADD8) s += 1;
1149 #define CLDEC(_n, _member) \
1150 md = ((head >> (4 * _n)) & 0xf); \
1151 if (md >= DLT_SET) \
1154 unsigned char *dv; \
1155 dv = (unsigned char *)&v; \
1156 dv[0] = *(cl->buf + offset + s + 0); \
1157 dv[1] = *(cl->buf + offset + s + 1); \
1158 dv[2] = *(cl->buf + offset + s + 2); \
1159 dv[3] = *(cl->buf + offset + s + 3); \
1160 d = (int)ntohl(v); \
1163 else if (md >= DLT_ADD16) \
1166 unsigned char *dv; \
1167 dv = (unsigned char *)&v; \
1168 dv[0] = *(cl->buf + offset + s + 0); \
1169 dv[1] = *(cl->buf + offset + s + 1); \
1170 d = (int)ntohs(v); \
1173 else if (md >= DLT_ADD8) \
1176 unsigned char *dv; \
1177 dv = (unsigned char *)&v; \
1178 dv[0] = *(cl->buf + offset + s + 0); \
1182 msg._member = _ecore_ipc_ddlt_int(d, cl->prev.i._member, md);
1185 _ecore_ipc_event_client_data(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1187 Ecore_Con_Event_Client_Data *e;
1190 if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
1191 /* handling code here */
1193 Ecore_Ipc_Client *cl;
1194 Ecore_Ipc_Msg_Head msg;
1198 cl = ecore_con_client_data_get(e->client);
1202 cl->buf_size = e->size;
1204 e->data = NULL; /* take it out of the old event */
1208 buf = realloc(cl->buf, cl->buf_size + e->size);
1214 return ECORE_CALLBACK_CANCEL;
1217 memcpy(cl->buf + cl->buf_size, e->data, e->size);
1218 cl->buf_size += e->size;
1220 /* examine header */
1222 if ((cl->buf_size - offset) >= (int)sizeof(int))
1224 int s, md, d = 0, head;
1227 dd = (unsigned char *)&head;
1228 dd[0] = *(cl->buf + offset + 0);
1229 dd[1] = *(cl->buf + offset + 1);
1230 dd[2] = *(cl->buf + offset + 2);
1231 dd[3] = *(cl->buf + offset + 3);
1233 dd = (unsigned char *)&d;
1241 if ((cl->buf_size - offset) < s)
1243 if (offset > 0) goto scroll;
1244 return ECORE_CALLBACK_CANCEL;
1254 if (msg.size < 0) msg.size = 0;
1255 /* there is enough data in the buffer for a full message */
1256 if ((cl->buf_size - offset) >= (s + msg.size))
1258 Ecore_Ipc_Event_Client_Data *e2;
1259 Ecore_Ipc_Server *svr;
1263 svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
1264 max = svr->max_buf_size;
1265 max2 = cl->max_buf_size;
1266 if ((max >= 0) && (max2 >= 0))
1268 if (max2 < max) max = max2;
1272 if (max < 0) max = max2;
1274 if ((max < 0) || (msg.size <= max))
1278 buf = malloc(msg.size);
1279 if (!buf) return ECORE_CALLBACK_CANCEL;
1280 memcpy(buf, cl->buf + offset + s, msg.size);
1284 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Data));
1289 e2->major = msg.major;
1290 e2->minor = msg.minor;
1292 e2->ref_to = msg.ref_to;
1293 e2->response = msg.response;
1294 e2->size = msg.size;
1296 ecore_event_add(ECORE_IPC_EVENT_CLIENT_DATA, e2,
1297 _ecore_ipc_event_client_data_free,
1303 offset += (s + msg.size);
1304 if (cl->buf_size == offset)
1309 return ECORE_CALLBACK_CANCEL;
1318 buf = malloc(cl->buf_size - offset);
1324 return ECORE_CALLBACK_CANCEL;
1326 memcpy(buf, cl->buf + offset, cl->buf_size - offset);
1329 cl->buf_size -= offset;
1332 return ECORE_CALLBACK_CANCEL;
1336 md = ((head >> (4 * _n)) & 0xf); \
1337 if (md >= DLT_SET) s += 4; \
1338 else if (md >= DLT_ADD16) s += 2; \
1339 else if (md >= DLT_ADD8) s += 1;
1341 #define SVDEC(_n, _member) \
1342 md = ((head >> (4 * _n)) & 0xf); \
1343 if (md >= DLT_SET) \
1346 unsigned char *dv; \
1347 dv = (unsigned char *)&v; \
1348 dv[0] = *(svr->buf + offset + s + 0); \
1349 dv[1] = *(svr->buf + offset + s + 1); \
1350 dv[2] = *(svr->buf + offset + s + 2); \
1351 dv[3] = *(svr->buf + offset + s + 3); \
1352 d = (int)ntohl(v); \
1355 else if (md >= DLT_ADD16) \
1358 unsigned char *dv; \
1359 dv = (unsigned char *)&v; \
1360 dv[0] = *(svr->buf + offset + s + 0); \
1361 dv[1] = *(svr->buf + offset + s + 1); \
1362 d = (int)ntohs(v); \
1365 else if (md >= DLT_ADD8) \
1368 unsigned char *dv; \
1369 dv = (unsigned char *)&v; \
1370 dv[0] = *(svr->buf + offset + s + 0); \
1374 msg._member = _ecore_ipc_ddlt_int(d, svr->prev.i._member, md);
1377 _ecore_ipc_event_server_data(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
1379 Ecore_Con_Event_Server_Data *e;
1382 if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
1383 /* handling code here */
1385 Ecore_Ipc_Server *svr;
1386 Ecore_Ipc_Msg_Head msg;
1390 svr = ecore_con_server_data_get(e->server);
1394 svr->buf_size = e->size;
1396 e->data = NULL; /* take it out of the old event */
1400 buf = realloc(svr->buf, svr->buf_size + e->size);
1406 return ECORE_CALLBACK_CANCEL;
1409 memcpy(svr->buf + svr->buf_size, e->data, e->size);
1410 svr->buf_size += e->size;
1412 /* examine header */
1414 if ((svr->buf_size - offset) >= (int)sizeof(int))
1416 int s, md, d = 0, head;
1419 dd = (unsigned char *)&head;
1420 dd[0] = *(svr->buf + offset + 0);
1421 dd[1] = *(svr->buf + offset + 1);
1422 dd[2] = *(svr->buf + offset + 2);
1423 dd[3] = *(svr->buf + offset + 3);
1425 dd = (unsigned char *)&d;
1433 if ((svr->buf_size - offset) < s)
1435 if (offset > 0) goto scroll;
1436 return ECORE_CALLBACK_CANCEL;
1446 if (msg.size < 0) msg.size = 0;
1447 /* there is enough data in the buffer for a full message */
1448 if ((svr->buf_size - offset) >= (s + msg.size))
1450 Ecore_Ipc_Event_Server_Data *e2;
1454 max = svr->max_buf_size;
1455 if ((max < 0) || (msg.size <= max))
1459 buf = malloc(msg.size);
1460 if (!buf) return ECORE_CALLBACK_CANCEL;
1461 memcpy(buf, svr->buf + offset + s, msg.size);
1463 if (!svr->delete_me)
1465 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Data));
1470 e2->major = msg.major;
1471 e2->minor = msg.minor;
1473 e2->ref_to = msg.ref_to;
1474 e2->response = msg.response;
1475 e2->size = msg.size;
1477 ecore_event_add(ECORE_IPC_EVENT_SERVER_DATA, e2,
1478 _ecore_ipc_event_server_data_free,
1484 offset += (s + msg.size);
1485 if (svr->buf_size == offset)
1490 return ECORE_CALLBACK_CANCEL;
1499 buf = malloc(svr->buf_size - offset);
1505 return ECORE_CALLBACK_CANCEL;
1507 memcpy(buf, svr->buf + offset, svr->buf_size - offset);
1510 svr->buf_size -= offset;
1513 return ECORE_CALLBACK_CANCEL;
1517 _ecore_ipc_event_client_add_free(void *data __UNUSED__, void *ev)
1519 Ecore_Ipc_Event_Client_Add *e;
1522 e->client->event_count--;
1523 if ((e->client->event_count == 0) && (e->client->delete_me))
1524 ecore_ipc_client_del(e->client);
1529 _ecore_ipc_event_client_del_free(void *data __UNUSED__, void *ev)
1531 Ecore_Ipc_Event_Client_Del *e;
1534 e->client->event_count--;
1535 if ((e->client->event_count == 0) && (e->client->delete_me))
1536 ecore_ipc_client_del(e->client);
1541 _ecore_ipc_event_client_data_free(void *data __UNUSED__, void *ev)
1543 Ecore_Ipc_Event_Client_Data *e;
1546 e->client->event_count--;
1547 if (e->data) free(e->data);
1548 if ((e->client->event_count == 0) && (e->client->delete_me))
1549 ecore_ipc_client_del(e->client);
1554 _ecore_ipc_event_server_add_free(void *data __UNUSED__, void *ev)
1556 Ecore_Ipc_Event_Server_Add *e;
1559 e->server->event_count--;
1560 if ((e->server->event_count == 0) && (e->server->delete_me))
1561 ecore_ipc_server_del(e->server);
1566 _ecore_ipc_event_server_del_free(void *data __UNUSED__, void *ev)
1568 Ecore_Ipc_Event_Server_Add *e;
1571 e->server->event_count--;
1572 if ((e->server->event_count == 0) && (e->server->delete_me))
1573 ecore_ipc_server_del(e->server);
1578 _ecore_ipc_event_server_data_free(void *data __UNUSED__, void *ev)
1580 Ecore_Ipc_Event_Server_Data *e;
1583 if (e->data) free(e->data);
1584 e->server->event_count--;
1585 if ((e->server->event_count == 0) && (e->server->delete_me))
1586 ecore_ipc_server_del(e->server);