From a7b74115ceea93de89feecd905f9b5fc61300337 Mon Sep 17 00:00:00 2001 From: sebastid Date: Tue, 25 Jul 2006 12:44:19 +0000 Subject: [PATCH] Big ecore_dbus overhaul SVN revision: 24191 --- legacy/ecore/src/bin/ecore_dbus_test.c | 5 - legacy/ecore/src/lib/ecore/Ecore_Data.h | 2 + legacy/ecore/src/lib/ecore/ecore_list.c | 34 ++ legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h | 13 +- legacy/ecore/src/lib/ecore_dbus/Makefile.am | 1 + legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c | 482 +-------------- .../src/lib/ecore_dbus/ecore_dbus_marshal.c | 279 ++++----- .../src/lib/ecore_dbus/ecore_dbus_message.c | 560 ++++++++++++++++++ .../src/lib/ecore_dbus/ecore_dbus_private.h | 234 ++++++-- .../src/lib/ecore_dbus/ecore_dbus_unmarshal.c | 375 ++++++++---- .../src/lib/ecore_dbus/ecore_dbus_utils.c | 131 ++-- 11 files changed, 1248 insertions(+), 868 deletions(-) create mode 100644 legacy/ecore/src/lib/ecore_dbus/ecore_dbus_message.c diff --git a/legacy/ecore/src/bin/ecore_dbus_test.c b/legacy/ecore/src/bin/ecore_dbus_test.c index 70e81efaf6..b7ba8ad63e 100644 --- a/legacy/ecore/src/bin/ecore_dbus_test.c +++ b/legacy/ecore/src/bin/ecore_dbus_test.c @@ -35,11 +35,6 @@ main(int argc, char **argv) handler[i++] = ecore_event_handler_add(ECORE_DBUS_EVENT_SERVER_DATA, _ecore_dbus_event_server_data, NULL); - /* - ret = ecore_dbus_message_new_method_call(svr, "org.freedesktop.DBus.Hello", - NULL, NULL, NULL, NULL); - */ - ecore_main_loop_begin(); for (i = 0; i < 3; i++) diff --git a/legacy/ecore/src/lib/ecore/Ecore_Data.h b/legacy/ecore/src/lib/ecore/Ecore_Data.h index c6710c89ce..f66a5b501b 100644 --- a/legacy/ecore/src/lib/ecore/Ecore_Data.h +++ b/legacy/ecore/src/lib/ecore/Ecore_Data.h @@ -98,6 +98,8 @@ extern "C" { /* Retrieve the current position in the list */ EAPI void *ecore_list_current(Ecore_List * list); + EAPI void *ecore_list_first(Ecore_List * list); + EAPI void *ecore_list_last(Ecore_List * list); EAPI int ecore_list_index(Ecore_List * list); EAPI int ecore_list_nodes(Ecore_List * list); diff --git a/legacy/ecore/src/lib/ecore/ecore_list.c b/legacy/ecore/src/lib/ecore/ecore_list.c index 96973d2dac..d4e84e9d90 100644 --- a/legacy/ecore/src/lib/ecore/ecore_list.c +++ b/legacy/ecore/src/lib/ecore/ecore_list.c @@ -879,6 +879,40 @@ ecore_list_current(Ecore_List *list) return ret; } +/** + * Retrieve the data pointed to by the first item in @p list. + * @param list The list. + * @return Returns the data at current position, can be @c NULL. + */ +EAPI inline void * +ecore_list_first(Ecore_List *list) +{ + void *ret; + + if (!list->first) + return NULL; + ret = list->first->data; + + return ret; +} + +/** + * Retrieve the data pointed to by the last item in @p list. + * @param list The list. + * @return Returns the data at current position, can be @c NULL. + */ +EAPI inline void * +ecore_list_last(Ecore_List *list) +{ + void *ret; + + if (!list->last) + return NULL; + ret = list->last->data; + + return ret; +} + /* Return the data of the current node without incrementing */ static void * _ecore_list_current(Ecore_List *list) diff --git a/legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h b/legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h index 3aa5fb86a6..b674578398 100644 --- a/legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h +++ b/legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h @@ -81,6 +81,12 @@ extern "C" { Ecore_DBus_Server *server; }; + struct _Ecore_DBus_Event_Server_Data + { + Ecore_DBus_Server *server; + Ecore_DBus_Message *message; + }; + typedef enum _Ecore_DBus_Message_Header_Field { ECORE_DBUS_HEADER_FIELD_INVALID, @@ -109,10 +115,13 @@ extern "C" { /* message */ EAPI int ecore_dbus_server_send(Ecore_DBus_Server *svr, char *command, int length); - EAPI unsigned int ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr, char *service, char *path, char *interface, char *method, char *fmt, ...); + EAPI unsigned int ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr, char *destination, char *path, char *interface, char *method, char *fmt, ...); + EAPI void ecore_dbus_message_del(Ecore_DBus_Message *msg); EAPI void ecore_dbus_message_print(Ecore_DBus_Message *msg); - EAPI void *ecore_dbus_get_header_field(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field *field, Ecore_DBus_Message_Header_Field header); + EAPI void *ecore_dbus_message_header_field_get(Ecore_DBus_Message *msg, Ecore_DBus_Message_Header_Field field); +#if 0 EAPI void *ecore_dbus_get_body_field(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field *field, unsigned int pos); +#endif #ifdef __cplusplus } diff --git a/legacy/ecore/src/lib/ecore_dbus/Makefile.am b/legacy/ecore/src/lib/ecore_dbus/Makefile.am index 820e261d93..771c9b0eee 100644 --- a/legacy/ecore/src/lib/ecore_dbus/Makefile.am +++ b/legacy/ecore/src/lib/ecore_dbus/Makefile.am @@ -21,6 +21,7 @@ Ecore_DBus.h libecore_dbus_la_SOURCES = \ ecore_dbus.c \ +ecore_dbus_message.c \ ecore_dbus_marshal.c \ ecore_dbus_unmarshal.c \ ecore_dbus_utils.c \ diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c index e297fddb10..1dfd4898bf 100644 --- a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c @@ -1,8 +1,6 @@ /* * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2 */ -#include - #include "Ecore.h" #include "ecore_private.h" #include "Ecore_Con.h" @@ -48,11 +46,6 @@ EAPI int ECORE_DBUS_EVENT_SERVER_DATA = 0; /* private function declaration */ -/* message functions */ -static void _ecore_dbus_message_free(void *data, void *ev); -/* header functions */ -static void _ecore_dbus_message_common_header(Ecore_DBus_Message *msg, int type, int flags); -static void *_ecore_dbus_field_get(unsigned char *buf, Ecore_DBus_Message_Field *f); /* helper functions */ static char *_ecore_dbus_getuid(void); static char *_ecore_dbus_hex_encode(char *src_str); @@ -62,11 +55,7 @@ unsigned char *_ecore_dbus_auth_external(void *data); static int _ecore_dbus_event_server_add(void *data, int ev_type, void *ev); static int _ecore_dbus_event_server_del(void *data, int ev_type, void *ev); static int _ecore_dbus_event_server_data(void *data, int ev_type, void *ev); -/* printing functions */ -static Ecore_DBus_Message_Field *_ecore_dbus_message_print_field(Ecore_DBus_Message_Field *f, unsigned char *buf); -static Ecore_DBus_Message_Field *_ecore_dbus_message_print_header_field(Ecore_DBus_Message_Field *f, unsigned char *buf); -/*static void _ecore_dbus_message_print_fields(Ecore_DBus_Message_Field *f);*/ -/*static void _ecore_dbus_message_print_raw(unsigned char *msg, unsigned int msg_len);*/ +static void _ecore_dbus_event_server_data_free(void *data, void *ev); /* local variables */ @@ -182,333 +171,6 @@ ecore_dbus_server_send(Ecore_DBus_Server *svr, char *command, int length) return ret; } -EAPI unsigned int -ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr, char *service, - char *path, char *interface, char *method, - char *fmt, ...) -{ - unsigned int serial; - va_list ap; - unsigned int size = 0; - - Ecore_DBus_Message_Field *f; - - if ((!service) && (!path) && (!interface) && (!method)) return 0; - - /* init message */ - Ecore_DBus_Message *msg = _ecore_dbus_message_new(svr); - - /* common header */ - _ecore_dbus_message_common_header(msg, ECORE_DBUS_MESSAGE_TYPE_METHOD_CALL, 0); - /* custom header */ - if (path) - { - f = _ecore_dbus_message_marshal_custom_header(&msg->header, &msg->hpos, - 1, - ECORE_DBUS_DATA_TYPE_OBJECT_PATH, - path); - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - size++; - } - if (service) - { - f = _ecore_dbus_message_marshal_custom_header(&msg->header, &msg->hpos, - 6, - ECORE_DBUS_DATA_TYPE_STRING, - service); - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - size++; - } - if (interface) - { - f = _ecore_dbus_message_marshal_custom_header(&msg->header, &msg->hpos, - 2, - ECORE_DBUS_DATA_TYPE_STRING, - interface); - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - size++; - } - if (method) - { - f = _ecore_dbus_message_marshal_custom_header(&msg->header, &msg->hpos, - 3, - ECORE_DBUS_DATA_TYPE_STRING, - method); - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - size++; - } - if (fmt) - { - f = _ecore_dbus_message_marshal_custom_header(&msg->header, &msg->hpos, - 8, - ECORE_DBUS_DATA_TYPE_SIGNATURE, - fmt); - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - size++; - } - /* Remove 16 bytes for the intro */ - *(unsigned int *)(msg->header + 12) = msg->hpos - 16; - _ecore_dbus_message_padding(&msg->header, &msg->hpos, 8); - msg->hlength = msg->hpos; - /* message body */ - if (fmt) - { - va_start(ap, fmt); - while (*fmt) - { - switch (*fmt) - { - case ECORE_DBUS_DATA_TYPE_BYTE: - f = _ecore_dbus_message_marshal_byte(&msg->body, &msg->bpos, - va_arg(ap, int)); - msg->body_fields = _ecore_list2_append(msg->body_fields, f); - break; - case ECORE_DBUS_DATA_TYPE_UINT32: - f = _ecore_dbus_message_marshal_uint32(&msg->body, &msg->bpos, - va_arg(ap, unsigned int)); - msg->body_fields = _ecore_list2_append(msg->body_fields, f); - break; - case ECORE_DBUS_DATA_TYPE_STRING: - f = _ecore_dbus_message_marshal_string(&msg->body, &msg->bpos, - (char *)va_arg(ap, char *)); - msg->body_fields = _ecore_list2_append(msg->body_fields, f); - break; - case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - f = _ecore_dbus_message_marshal_object_path(&msg->body, &msg->bpos, - (char *)va_arg(ap, char *)); - msg->body_fields = _ecore_list2_append(msg->body_fields, f); - break; - case ECORE_DBUS_DATA_TYPE_INT32: - case ECORE_DBUS_DATA_TYPE_BOOLEAN: - case ECORE_DBUS_DATA_TYPE_INT64: - case ECORE_DBUS_DATA_TYPE_UINT64: - case ECORE_DBUS_DATA_TYPE_DOUBLE: - case ECORE_DBUS_DATA_TYPE_ARRAY: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: - case ECORE_DBUS_DATA_TYPE_INVALID: -#if 0 - default: -#endif - printf("[ecore_dbus] unknown/unhandled data type %c\n", *fmt); - break; - } - fmt++; - } - va_end(ap); - } - *(unsigned int *)(msg->header + 4) = msg->blength = msg->bpos; - /* show message */ - ecore_dbus_message_print(msg); - /* - _ecore_dbus_message_print_raw(msg->header, msg->hlength); - _ecore_dbus_message_print_raw(msg->body, msg->blength); - */ - /* send message */ - ecore_dbus_server_send(svr, (char *)msg->header, msg->hlength); - if (msg->body) - ecore_dbus_server_send(svr, (char *)msg->body, msg->blength); - - serial = msg->serial; - _ecore_dbus_message_free(NULL, msg); - return serial; -} - -EAPI void -ecore_dbus_message_print(Ecore_DBus_Message *msg) -{ - Ecore_DBus_Message_Field *f; - static const char *msg_type[] = { - "INVALID", "METHOD_CALL", "METHOD_RETURN", "ERROR", "SIGNAL" - }; - - printf("[ecore_dbus] per field message:\n"); - printf("[ecore_dbus] header fields:\n"); - /* header common fields */ - printf("[ecore_dbus] header endianess : %c\n", msg->header[0]); - printf("[ecore_dbus] header type : %s\n", msg_type[msg->header[1]]); - printf("[ecore_dbus] header flags : %c\n", msg->header[2]); - printf("[ecore_dbus] header protocol : %c\n", msg->header[3]); - printf("[ecore_dbus] header hlength : %u\n", msg->hlength); - printf("[ecore_dbus] header blength : %u\n", - *(unsigned int *)(msg->header + 4)); - printf("[ecore_dbus] header serial : %u\n", - *(unsigned int *)(msg->header + 8)); - - /* header custom fields */ - f = msg->header_fields; - while (f) - { - f = _ecore_dbus_message_print_header_field(f, msg->header); - } - /* body fields */ - printf("[ecore_dbus] body fields:\n"); - f = msg->body_fields; - while (f) - { - f = _ecore_dbus_message_print_field(f, msg->body); - } - printf("[ecore_dbus] end per field message\n"); -} - -EAPI void * -ecore_dbus_header_field_get(Ecore_DBus_Message *m, - Ecore_DBus_Message_Field *mf, - Ecore_DBus_Message_Header_Field hft) -{ - Ecore_List2 *l; - - for (l = (Ecore_List2 *)mf; l; l = l->next) - if (((Ecore_DBus_Message_Field *)l)->hfield == hft) - return _ecore_dbus_field_get(m->header, (Ecore_DBus_Message_Field *)l); - return NULL; -} - -EAPI void * -ecore_dbus_body_field_get(Ecore_DBus_Message *m, Ecore_DBus_Message_Field *mf, - unsigned int pos) -{ - Ecore_List2 *l; - unsigned int i = 0; - - for (l = (Ecore_List2 *) mf; l; l = l->next) - { - if (i == pos) - return _ecore_dbus_field_get(m->body, (Ecore_DBus_Message_Field *)l); - i++; - } - return NULL; -} - -/* private functions */ - -/* message functions */ - -Ecore_DBus_Message * -_ecore_dbus_message_new(Ecore_DBus_Server *svr) -{ - Ecore_DBus_Message *msg; - - msg = calloc(1, sizeof(Ecore_DBus_Message)); - if (!msg) return NULL; - - msg->ref_server = svr; - msg->body_fields = NULL; - msg->header_fields = NULL; - msg->hpos = 0; - msg->bpos = 0; - msg->header = NULL; - msg->body = NULL; - msg->hlength = 0; - msg->blength = 0; - return msg; -} - -Ecore_DBus_Message_Field * -_ecore_dbus_message_new_field(Ecore_DBus_Data_Type type, unsigned int offset) -{ - Ecore_DBus_Message_Field *f; - - f = malloc(sizeof(Ecore_DBus_Message_Field)); - if (!f) return NULL; - f->offset = offset; - f->type = type; - f->count = 0; - return f; -} - -static void -_ecore_dbus_message_free(void *data, void *ev) -{ - Ecore_DBus_Message *msg; - Ecore_List2 *l; - Ecore_List2 *next; - - msg = ev; - - l = (Ecore_List2 *)msg->body_fields; - while (l) - { - next = l->next; - free(l); - l = next; - } - l = (Ecore_List2 *)msg->header_fields; - while (l) - { - next = l->next; - free(l); - l = next; - } - free(msg->header); - free(msg->body); - free(msg); -} - -/* header functions */ - -static void -_ecore_dbus_message_common_header(Ecore_DBus_Message *msg, int type, int flags) -{ - /* the body, header length arent filled only alloc */ - _ecore_dbus_message_append_length(&msg->header, msg->hpos, 16); - /* endiannes (1) */ - msg->header[0] = msg->byte_order = 'l'; - /* type (1) */ - msg->header[1] = msg->type = (char)type; - /* flags (1) 0x1 = no reply expected, 0x2 auto activiation */ - msg->header[2] = msg->flags = 0x0; - /* protocol (1) */ - msg->header[3] = msg->protocol = ECORE_DBUS_MAJOR_PROTOCOL_VERSION; - /* autoincrement the client_serial (0 is invalid) */ - msg->ref_server->cnt_msg++; - - *(unsigned int *)(msg->header + 8) = msg->serial = msg->ref_server->cnt_msg; - *(msg->header + 12) = ECORE_DBUS_DATA_TYPE_INT16; - msg->hpos = 16; -} - -static void * -_ecore_dbus_field_get(unsigned char *buf, Ecore_DBus_Message_Field *f) -{ - switch (f->type) - { - case ECORE_DBUS_DATA_TYPE_BYTE: - case ECORE_DBUS_DATA_TYPE_BOOLEAN: - case ECORE_DBUS_DATA_TYPE_INT16: - case ECORE_DBUS_DATA_TYPE_UINT16: - case ECORE_DBUS_DATA_TYPE_INT32: - case ECORE_DBUS_DATA_TYPE_UINT32: - case ECORE_DBUS_DATA_TYPE_INT64: - case ECORE_DBUS_DATA_TYPE_UINT64: - case ECORE_DBUS_DATA_TYPE_DOUBLE: - return buf + f->offset; - break; - case ECORE_DBUS_DATA_TYPE_STRING: - case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - return buf + f->offset + 4; - break; - case ECORE_DBUS_DATA_TYPE_SIGNATURE: - return buf + f->offset + 1; - break; - case ECORE_DBUS_DATA_TYPE_INVALID: - case ECORE_DBUS_DATA_TYPE_ARRAY: - case ECORE_DBUS_DATA_TYPE_VARIANT: - case ECORE_DBUS_DATA_TYPE_STRUCT: - case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: - case ECORE_DBUS_DATA_TYPE_STRUCT_END: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: -#if 0 - default: -#endif - printf("[ecore_dbus] unknown/unhandled data type %c\n", f->type); - break; - - } - return NULL; -} - /* helper functions */ static char * @@ -675,142 +337,30 @@ _ecore_dbus_event_server_data(void *udata, int ev_type, void *ev) printf("[ecore_dbus] received server data, %d bytes\n", e->size); while (e->size) { - msg = _ecore_dbus_message_unmarshal(svr, (unsigned char *)(e->data) + offset); + Ecore_DBus_Event_Server_Data *ev; + + msg = _ecore_dbus_message_unmarshal(svr, (unsigned char *)(e->data) + offset, e->size); if (msg == NULL) break; - offset += msg->hlength + msg->blength; - e->size -= msg->hlength + msg->blength; + offset += msg->length; + e->size -= msg->length; printf("[ecore_dbus] dbus message length %u bytes, still %d\n", - msg->hlength + msg->blength, e->size); + msg->length, e->size); ecore_dbus_message_print(msg); - ecore_event_add(ECORE_DBUS_EVENT_SERVER_DATA, msg, _ecore_dbus_message_free, NULL); + ev = malloc(sizeof(Ecore_DBus_Event_Server_Data)); + ev->server = svr; + ev->message = msg; + ecore_event_add(ECORE_DBUS_EVENT_SERVER_DATA, ev, _ecore_dbus_event_server_data_free, NULL); } } return 0; } -/* printing functions */ - -static Ecore_DBus_Message_Field * -_ecore_dbus_message_print_field(Ecore_DBus_Message_Field *f, unsigned char *buf) -{ - int i; - - switch (f->type) - { - case ECORE_DBUS_DATA_TYPE_BYTE: - printf - ("[ecore_dbus] field BYTE: value offset = %d value = %d\n", - f->offset, (char)*(buf + f->offset)); - break; - case ECORE_DBUS_DATA_TYPE_INT32: - printf - ("[ecore_dbus] field INT32: value offset = %d value = %d\n", - f->offset, (int)*(buf + f->offset)); - break; - case ECORE_DBUS_DATA_TYPE_UINT32: - printf - ("[ecore_dbus] field UINT32: value offset = %d value = %u\n", - f->offset, (unsigned int)*(buf + f->offset)); - break; - case ECORE_DBUS_DATA_TYPE_STRING: - printf - ("[ecore_dbus] field STRING: value offset = %d length = %d value = %s\n", - f->offset, *(buf + f->offset), (buf + f->offset + 4)); - break; - case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - printf - ("[ecore_dbus] field PATH: value offset = %d length = %d value = %s\n", - f->offset, *(buf + f->offset), (buf + f->offset + 4)); - break; - case ECORE_DBUS_DATA_TYPE_SIGNATURE: - printf - ("[ecore_dbus] field SIGNATURE : value offset = %d length = %d value = %s\n", - f->offset, *(buf + f->offset), (buf + f->offset + 1)); - break; - case ECORE_DBUS_DATA_TYPE_ARRAY: - { - printf - ("[ecore_dbus] field ARRAY : value offset = %d length = %u elements = %u\n", - f->offset, *(unsigned int *)(buf + f->offset), f->count); - printf("[ecore_dbus] * ARRAY elements begin *\n"); - f = (Ecore_DBus_Message_Field *)((Ecore_List2 *)f)->next; - for (i = 0; i < f->count; i++) - f = _ecore_dbus_message_print_field(f, buf); - printf("[ecore_dbus] * ARRAY elements end *\n"); - return f; - } - break; - case ECORE_DBUS_DATA_TYPE_INVALID: - case ECORE_DBUS_DATA_TYPE_BOOLEAN: - case ECORE_DBUS_DATA_TYPE_INT16: - case ECORE_DBUS_DATA_TYPE_UINT16: - case ECORE_DBUS_DATA_TYPE_INT64: - case ECORE_DBUS_DATA_TYPE_UINT64: - case ECORE_DBUS_DATA_TYPE_DOUBLE: - case ECORE_DBUS_DATA_TYPE_VARIANT: - case ECORE_DBUS_DATA_TYPE_STRUCT: - case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: - case ECORE_DBUS_DATA_TYPE_STRUCT_END: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: - /* TODO */ - printf("[ecore_dbus] field not implemented: %c\n", f->type); - break; -#if 0 - default: - printf("[ecore_dbus] field !UNKNOWN!: %c\n", f->type); - break; -#endif - } - return (Ecore_DBus_Message_Field *)((Ecore_List2 *)f)->next; -} - -static Ecore_DBus_Message_Field * -_ecore_dbus_message_print_header_field(Ecore_DBus_Message_Field *f, unsigned char *buf) -{ - static const char *header_fields[] = { - "INVALID", "PATH", "INTERFACE", "MEMBER", "ERROR_NAME", - "REPLY_SERIAL", "DESTINATION", "SERIAL", "SIGNATURE" - }; - - printf("[ecore_dbus] header field %s ", header_fields[f->hfield]); - return _ecore_dbus_message_print_field(f, buf); -} - -/* static void -_ecore_dbus_message_print_fields(Ecore_DBus_Message_Field *f) +_ecore_dbus_event_server_data_free(void *data, void *ev) { - int i; - Ecore_List2 *l; + Ecore_DBus_Event_Server_Data *event; - i = 0; - l = (Ecore_List2 *)f; - while (l) - { - printf("%d\n", i); - l = l->next; - i++; - } + event = ev; + _ecore_dbus_message_free(event->message); + free(ev); } - -static void -_ecore_dbus_message_print_raw(unsigned char *msg, unsigned int msg_len) -{ - int i; - - printf("[ecore_dbus] raw message:\n"); - for (i = 0; i < msg_len; i++) - { - if (msg[i] == 0) - printf(","); - else if (msg[i] < 21) - printf("*"); - else - printf("%c", msg[i]); - } - printf("\n"); - printf("[ecore_dbus] end raw message\n"); -} -*/ diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_marshal.c b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_marshal.c index 0a9fa2ba56..94ad0374cd 100644 --- a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_marshal.c +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_marshal.c @@ -7,184 +7,158 @@ #include "Ecore_DBus.h" #include "ecore_dbus_private.h" -static int _ecore_dbus_alignment_get(Ecore_DBus_Data_Type type); - -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_byte(unsigned char **buf, unsigned int *old_length, - unsigned char c) +Ecore_DBus_Message_Field_Byte * +_ecore_dbus_message_marshal_byte(Ecore_DBus_Message *msg, unsigned char c) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Byte *f; - /* increase the length + 1, old_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_BYTE); - *old_length += 1; - /* increase the length + 1, old_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append c at cur_length */ - _ecore_dbus_message_append_byte(*buf + *old_length, c); - /* create field */ - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_BYTE, *old_length); - *old_length += 1; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_BYTE); + f->value = c; + _ecore_dbus_message_append_byte(msg, c); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_uint32(unsigned char **buf, - unsigned int *old_length, - unsigned int i) +Ecore_DBus_Message_Field_UInt32 * +_ecore_dbus_message_marshal_uint32(Ecore_DBus_Message *msg, unsigned int i) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_UInt32 *f; + unsigned char *c; - /* increase the length + 1, old_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_UINT32); - *old_length += 1; - _ecore_dbus_message_padding(buf, old_length, 4); - _ecore_dbus_message_increase_length(buf, *old_length + 4); - _ecore_dbus_message_append_uint32(*buf + *old_length, i); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_UINT32, *old_length); - *old_length += 4; + _ecore_dbus_message_padding(msg, 4); + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_UINT32); + f->value = i; + c = (unsigned char *)&i; + _ecore_dbus_message_append_bytes(msg, c, 4); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_object_path(unsigned char **buf, unsigned int *old_length, - char *str) +Ecore_DBus_Message_Field_String * +_ecore_dbus_message_marshal_string(Ecore_DBus_Message *msg, char *str) { - int str_len; - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_String *f; + unsigned int str_len; - /* increase the length + 1, old_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_OBJECT_PATH); - *old_length += 1; + _ecore_dbus_message_padding(msg, 4); + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_STRING); + f->value = str; str_len = strlen(str); - _ecore_dbus_message_padding(buf, old_length, 4); - _ecore_dbus_message_increase_length(buf, *old_length + 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_OBJECT_PATH, *old_length); - _ecore_dbus_message_append_uint32(*buf + *old_length, str_len); - *old_length += 4; - /* + 1 for \0 */ - _ecore_dbus_message_increase_length(buf, *old_length + str_len + 1); - _ecore_dbus_message_append_nbytes(*buf + *old_length, (unsigned char *)str, str_len + 1); - *old_length += str_len + 1; + _ecore_dbus_message_append_uint32(msg, str_len); + /* + 1 for \0 */ + _ecore_dbus_message_append_bytes(msg, (unsigned char *)str, str_len + 1); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_string(unsigned char **buf, - unsigned int *old_length, char *str) +Ecore_DBus_Message_Field_Object_Path * +_ecore_dbus_message_marshal_object_path(Ecore_DBus_Message *msg, char *str) { - int str_len; - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Object_Path *f; + unsigned int str_len; - /* increase the length + 1, new_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_STRING); - *old_length += 1; + _ecore_dbus_message_padding(msg, 4); + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_OBJECT_PATH); + f->value = str; str_len = strlen(str); - _ecore_dbus_message_padding(buf, old_length, 4); - _ecore_dbus_message_increase_length(buf, *old_length + 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_STRING, *old_length); - _ecore_dbus_message_append_uint32(*buf + *old_length, str_len); - *old_length += 4; + _ecore_dbus_message_append_uint32(msg, str_len); + /* + 1 for \0 */ - _ecore_dbus_message_increase_length(buf, *old_length + str_len + 1); - _ecore_dbus_message_append_nbytes(*buf + *old_length, (unsigned char *)str, str_len + 1); - *old_length += str_len + 1; + _ecore_dbus_message_append_bytes(msg, (unsigned char *)str, str_len + 1); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_array(unsigned char **buf, unsigned int *old_length, - Ecore_DBus_Data_Type contained_type) +Ecore_DBus_Message_Field_Signature * +_ecore_dbus_message_marshal_signature(Ecore_DBus_Message *msg, char *str) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Signature *f; + unsigned int str_len; - /* increase the length with 1 + contained length */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_ARRAY); - *old_length += 1; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_SIGNATURE); + f->value = str; + str_len = strlen(str); + _ecore_dbus_message_append_byte(msg, str_len); + + /* + 1 for \0 */ + _ecore_dbus_message_append_bytes(msg, (unsigned char *)str, str_len + 1); + return f; +} + +Ecore_DBus_Message_Field_Array * +_ecore_dbus_message_marshal_array_begin(Ecore_DBus_Message *msg, + Ecore_DBus_Data_Type contained_type) +{ + Ecore_DBus_Message_Field_Array *arr; + + _ecore_dbus_message_padding(msg, 4); + + arr = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_ARRAY); /* for the array length value */ - _ecore_dbus_message_padding(buf, old_length, 4); - _ecore_dbus_message_increase_length(buf, *old_length + 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_ARRAY, *old_length); - *old_length += 4; + _ecore_dbus_message_append_uint32(msg, 0); + arr->contained_type = contained_type; + ecore_list_prepend(msg->recurse, arr); /* pad for contained type */ - _ecore_dbus_message_padding(buf, old_length, _ecore_dbus_alignment_get(contained_type)); + _ecore_dbus_message_padding(msg, _ecore_dbus_alignment_get(contained_type)); + arr->start = msg->length; - return f; + return arr; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_struct_begin(unsigned char **buf, unsigned int *old_length) +void +_ecore_dbus_message_marshal_array_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Array *arr) { - Ecore_DBus_Message_Field *f; - - /* increase the length with 1 */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN); - *old_length += 1; - - /* padding */ - _ecore_dbus_message_padding(buf, old_length, 8); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_STRUCT, *old_length); - - return f; + ecore_list_remove_first(msg->recurse); + arr->end = msg->length; + *(unsigned int *)ECORE_DBUS_MESSAGE_FIELD(arr)->buffer = arr->end - arr->start; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_struct_end(unsigned char **buf, unsigned int *old_length) +Ecore_DBus_Message_Field_Struct * +_ecore_dbus_message_marshal_struct_begin(Ecore_DBus_Message *msg) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Struct *s; - /* increase the length with 1 */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the data type */ - _ecore_dbus_message_append_byte(*buf + *old_length, ECORE_DBUS_DATA_TYPE_STRUCT_END); - *old_length += 1; + _ecore_dbus_message_padding(msg, 8); + s = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_STRUCT); + ecore_list_prepend(msg->recurse, s); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_STRUCT, *old_length); - - return f; + return s; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_data(unsigned char **buf, unsigned int *old_length, - Ecore_DBus_Data_Type type, void *data) +void +_ecore_dbus_message_marshal_struct_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Struct *s) { - Ecore_DBus_Message_Field *f = NULL; + ecore_list_remove_first(msg->recurse); +} - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append the signature length */ - _ecore_dbus_message_append_byte(*buf + *old_length, 1); - *old_length += 1; +Ecore_DBus_Message_Field_Variant * +_ecore_dbus_message_marshal_variant(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type type, void *data) +{ + Ecore_DBus_Message_Field_Variant *f = NULL; + + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_VARIANT); + ecore_list_prepend(msg->recurse, f); + f->contained_type = type; + + /* signature length */ + _ecore_dbus_message_append_byte(msg, 1); + /* signature */ + _ecore_dbus_message_append_byte(msg, type); switch (type) { case ECORE_DBUS_DATA_TYPE_UINT32: - f = _ecore_dbus_message_marshal_uint32(buf, old_length, - *(unsigned int *)data); + f->value = _ecore_dbus_message_marshal_uint32(msg, *(unsigned int *)data); break; case ECORE_DBUS_DATA_TYPE_STRING: - f = _ecore_dbus_message_marshal_string(buf, old_length, - (char *)data); + f->value = _ecore_dbus_message_marshal_string(msg, (char *)data); break; case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - f = _ecore_dbus_message_marshal_object_path(buf, old_length, - (char *)data); + f->value = _ecore_dbus_message_marshal_object_path(msg, (char *)data); + break; + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + f->value = _ecore_dbus_message_marshal_signature(msg, (char *)data); break; case ECORE_DBUS_DATA_TYPE_INVALID: case ECORE_DBUS_DATA_TYPE_BYTE: @@ -195,7 +169,6 @@ _ecore_dbus_message_marshal_data(unsigned char **buf, unsigned int *old_length, case ECORE_DBUS_DATA_TYPE_INT64: case ECORE_DBUS_DATA_TYPE_UINT64: case ECORE_DBUS_DATA_TYPE_DOUBLE: - case ECORE_DBUS_DATA_TYPE_SIGNATURE: case ECORE_DBUS_DATA_TYPE_ARRAY: case ECORE_DBUS_DATA_TYPE_VARIANT: case ECORE_DBUS_DATA_TYPE_STRUCT: @@ -210,58 +183,6 @@ _ecore_dbus_message_marshal_data(unsigned char **buf, unsigned int *old_length, printf("[ecore_dbus] unknown/unhandled data type %c\n", type); break; } + ecore_list_remove_first(msg->recurse); return f; } - -Ecore_DBus_Message_Field * -_ecore_dbus_message_marshal_custom_header(unsigned char **buf, - unsigned int *old_length, - unsigned int code, - Ecore_DBus_Data_Type type, void *data) -{ - Ecore_DBus_Message_Field *f; - - _ecore_dbus_message_padding(buf, old_length, 8); - /* increase the length + 1, old_length changed */ - _ecore_dbus_message_increase_length(buf, *old_length + 1); - /* append header field name at cur_length */ - _ecore_dbus_message_append_byte(*buf + *old_length, code); - *old_length += 1; - - /* marshal header field data */ - f = _ecore_dbus_message_marshal_data(buf, old_length, type, data); - f->hfield = code; - return f; -} - -static int -_ecore_dbus_alignment_get(Ecore_DBus_Data_Type type) -{ - switch (type) - { - case ECORE_DBUS_DATA_TYPE_BYTE: - case ECORE_DBUS_DATA_TYPE_SIGNATURE: - case ECORE_DBUS_DATA_TYPE_VARIANT: - return 1; - case ECORE_DBUS_DATA_TYPE_INT16: - case ECORE_DBUS_DATA_TYPE_UINT16: - return 2; - case ECORE_DBUS_DATA_TYPE_BOOLEAN: - case ECORE_DBUS_DATA_TYPE_INT32: - case ECORE_DBUS_DATA_TYPE_UINT32: - case ECORE_DBUS_DATA_TYPE_STRING: - case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - case ECORE_DBUS_DATA_TYPE_ARRAY: - return 4; - case ECORE_DBUS_DATA_TYPE_INT64: - case ECORE_DBUS_DATA_TYPE_UINT64: - case ECORE_DBUS_DATA_TYPE_DOUBLE: - return 8; - case ECORE_DBUS_DATA_TYPE_STRUCT: - case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: - return 8; - default: - fprintf(stderr, "Ecore_DBus: Alignment requested for invalid data type!\n"); - return 0; - } -} diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_message.c b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_message.c new file mode 100644 index 0000000000..fada377ceb --- /dev/null +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_message.c @@ -0,0 +1,560 @@ +/* + * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2 + */ +#include + +#include "ecore_private.h" +#include "Ecore_Con.h" +#include "Ecore_DBus.h" +#include "ecore_dbus_private.h" + +static void _ecore_dbus_message_common_header(Ecore_DBus_Message *msg, int type, int flags); +static void _ecore_dbus_message_field_free(void *data); + +/* printing functions */ +static void _ecore_dbus_message_field_print(Ecore_DBus_Message_Field *f); +static void _ecore_dbus_message_header_field_print(Ecore_DBus_Message_Field_Container *arr); +static void _ecore_dbus_message_print_raw(Ecore_DBus_Message *msg); + +EAPI unsigned int +ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr, char *destination, + char *path, char *interface, char *method, + char *fmt, ...) +{ + unsigned int serial, body_start; + Ecore_DBus_Message_Field_Array *arr; + + if ((!destination) && (!path) && (!interface) && (!method)) return 0; + + /* init message */ + Ecore_DBus_Message *msg = _ecore_dbus_message_new(svr); + + /* common header */ + _ecore_dbus_message_common_header(msg, ECORE_DBUS_MESSAGE_TYPE_METHOD_CALL, 0); + + arr = _ecore_dbus_message_marshal_array_begin(msg, ECORE_DBUS_DATA_TYPE_STRUCT); + /* custom header */ + if (path) + { + Ecore_DBus_Message_Field_Struct *s; + + s = _ecore_dbus_message_marshal_struct_begin(msg); + _ecore_dbus_message_marshal_byte(msg, ECORE_DBUS_HEADER_FIELD_PATH); + _ecore_dbus_message_marshal_variant(msg, ECORE_DBUS_DATA_TYPE_OBJECT_PATH, path); + _ecore_dbus_message_marshal_struct_end(msg, s); + } + if (destination) + { + Ecore_DBus_Message_Field_Struct *s; + + s = _ecore_dbus_message_marshal_struct_begin(msg); + _ecore_dbus_message_marshal_byte(msg, ECORE_DBUS_HEADER_FIELD_DESTINATION); + _ecore_dbus_message_marshal_variant(msg, ECORE_DBUS_DATA_TYPE_STRING, destination); + _ecore_dbus_message_marshal_struct_end(msg, s); + } + if (interface) + { + Ecore_DBus_Message_Field_Struct *s; + + s = _ecore_dbus_message_marshal_struct_begin(msg); + _ecore_dbus_message_marshal_byte(msg, ECORE_DBUS_HEADER_FIELD_INTERFACE); + _ecore_dbus_message_marshal_variant(msg, ECORE_DBUS_DATA_TYPE_STRING, interface); + _ecore_dbus_message_marshal_struct_end(msg, s); + } + if (method) + { + Ecore_DBus_Message_Field_Struct *s; + + s = _ecore_dbus_message_marshal_struct_begin(msg); + _ecore_dbus_message_marshal_byte(msg, ECORE_DBUS_HEADER_FIELD_MEMBER); + _ecore_dbus_message_marshal_variant(msg, ECORE_DBUS_DATA_TYPE_STRING, method); + _ecore_dbus_message_marshal_struct_end(msg, s); + } + if (fmt) + { + Ecore_DBus_Message_Field_Struct *s; + + s = _ecore_dbus_message_marshal_struct_begin(msg); + _ecore_dbus_message_marshal_byte(msg, ECORE_DBUS_HEADER_FIELD_SIGNATURE); + _ecore_dbus_message_marshal_variant(msg, ECORE_DBUS_DATA_TYPE_SIGNATURE, method); + _ecore_dbus_message_marshal_struct_end(msg, s); + } + _ecore_dbus_message_marshal_array_end(msg, arr); + msg->header = ecore_list_remove_first(msg->fields); + _ecore_dbus_message_padding(msg, 8); + + /* message body */ + body_start = msg->length; + if (fmt) + { + va_list ap; + va_start(ap, fmt); + while (*fmt) + { + Ecore_DBus_Data_Type type = *fmt; + switch (type) + { + case ECORE_DBUS_DATA_TYPE_BYTE: + _ecore_dbus_message_marshal_byte(msg, va_arg(ap, int)); + break; + case ECORE_DBUS_DATA_TYPE_UINT32: + _ecore_dbus_message_marshal_uint32(msg, va_arg(ap, unsigned int)); + break; + case ECORE_DBUS_DATA_TYPE_STRING: + _ecore_dbus_message_marshal_string(msg, (char *)va_arg(ap, char *)); + break; + case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: + _ecore_dbus_message_marshal_object_path(msg, (char *)va_arg(ap, char *)); + break; + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + _ecore_dbus_message_marshal_signature(msg, (char *)va_arg(ap, char *)); + break; + case ECORE_DBUS_DATA_TYPE_INVALID: + case ECORE_DBUS_DATA_TYPE_BOOLEAN: + case ECORE_DBUS_DATA_TYPE_INT16: + case ECORE_DBUS_DATA_TYPE_UINT16: + case ECORE_DBUS_DATA_TYPE_INT32: + case ECORE_DBUS_DATA_TYPE_INT64: + case ECORE_DBUS_DATA_TYPE_UINT64: + case ECORE_DBUS_DATA_TYPE_DOUBLE: + case ECORE_DBUS_DATA_TYPE_ARRAY: + case ECORE_DBUS_DATA_TYPE_VARIANT: + case ECORE_DBUS_DATA_TYPE_STRUCT: + case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: + case ECORE_DBUS_DATA_TYPE_STRUCT_END: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: +#if 0 + default: +#endif + printf("[ecore_dbus] unknown/unhandled data type %c\n", *fmt); + break; + } + fmt++; + } + va_end(ap); + } + /* set body length */ + *(unsigned int *)(msg->buffer + 4) = msg->length - body_start; + + /* show message */ + ecore_dbus_message_print(msg); + /* send message */ + ecore_dbus_server_send(svr, (char *)msg->buffer, msg->length); + + serial = msg->serial; + _ecore_dbus_message_free(msg); + return serial; +} + +EAPI void +ecore_dbus_message_print(Ecore_DBus_Message *msg) +{ + Ecore_DBus_Message_Field *f; + static const char *msg_type[] = { + "INVALID", "METHOD_CALL", "METHOD_RETURN", "ERROR", "SIGNAL" + }; + _ecore_dbus_message_print_raw(msg); + + printf("[ecore_dbus] per field message:\n"); + /* header common fields */ + printf("[ecore_dbus] header endianess : %c\n", msg->byte_order); + printf("[ecore_dbus] header type : %s\n", msg_type[msg->type]); + printf("[ecore_dbus] header flags : %c\n", msg->flags); + printf("[ecore_dbus] header protocol : %c\n", msg->protocol); + printf("[ecore_dbus] body length : %u\n", + *(unsigned int *)(msg->buffer + 4)); + printf("[ecore_dbus] header serial : %u\n", + *(unsigned int *)(msg->buffer + 8)); + + /* header custom fields */ + printf("[ecore_dbus] header fields:\n"); + _ecore_dbus_message_header_field_print(msg->header); + /* body fields */ + printf("[ecore_dbus] body fields:\n"); + ecore_list_goto_first(msg->fields); + while ((f = ecore_list_next(msg->fields))) + _ecore_dbus_message_field_print(f); +} + +EAPI void * +ecore_dbus_message_header_field_get(Ecore_DBus_Message *m, + Ecore_DBus_Message_Header_Field field) +{ + Ecore_DBus_Message_Field_Container *s; + + ecore_list_goto_first(ECORE_DBUS_MESSAGE_FIELD_CONTAINER(m->header)->values); + while ((s = ecore_list_next(ECORE_DBUS_MESSAGE_FIELD_CONTAINER(m->header)->values))) + { + Ecore_DBus_Message_Field_Byte *b; + b = ecore_list_first(s->values); + if (b->value == field) + { + Ecore_DBus_Message_Field_Variant *v; + + v = ecore_list_last(s->values); + return v->value; + } + } + return NULL; +} + +#if 0 +EAPI void * +ecore_dbus_body_field_get(Ecore_DBus_Message *m, Ecore_DBus_Message_Field *mf, + unsigned int pos) +{ + Ecore_List2 *l; + unsigned int i = 0; + + for (l = (Ecore_List2 *) mf; l; l = l->next) + { + if (i == pos) + return _ecore_dbus_field_get(m->body, (Ecore_DBus_Message_Field *)l); + i++; + } + return NULL; +} +#endif + +/* message functions */ + +Ecore_DBus_Message * +_ecore_dbus_message_new(Ecore_DBus_Server *svr) +{ + Ecore_DBus_Message *msg; + + msg = calloc(1, sizeof(Ecore_DBus_Message)); + if (!msg) return NULL; + + msg->server = svr; + + msg->length = 0; + msg->size = 128; + msg->buffer = calloc(msg->size, sizeof(unsigned char)); + + msg->fields = ecore_list_new(); + ecore_list_set_free_cb(msg->fields, _ecore_dbus_message_field_free); + msg->recurse = ecore_list_new(); + + return msg; +} + +void * +_ecore_dbus_message_field_new(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type type) +{ + Ecore_DBus_Message_Field *f; + + switch (type) + { + case ECORE_DBUS_DATA_TYPE_INVALID: + f = NULL; + break; + case ECORE_DBUS_DATA_TYPE_BYTE: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Byte)); + break; + case ECORE_DBUS_DATA_TYPE_BOOLEAN: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Boolean)); + break; + case ECORE_DBUS_DATA_TYPE_INT16: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Int16)); + break; + case ECORE_DBUS_DATA_TYPE_UINT16: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_UInt16)); + break; + case ECORE_DBUS_DATA_TYPE_INT32: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Int32)); + break; + case ECORE_DBUS_DATA_TYPE_UINT32: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_UInt32)); + break; + case ECORE_DBUS_DATA_TYPE_INT64: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Int64)); + break; + case ECORE_DBUS_DATA_TYPE_UINT64: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_UInt64)); + break; + case ECORE_DBUS_DATA_TYPE_DOUBLE: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Double)); + break; + case ECORE_DBUS_DATA_TYPE_STRING: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_String)); + break; + case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Object_Path)); + break; + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Signature)); + break; + case ECORE_DBUS_DATA_TYPE_ARRAY: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Array)); + ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values = ecore_list_new(); + ecore_list_set_free_cb(ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values, + _ecore_dbus_message_field_free); + break; + case ECORE_DBUS_DATA_TYPE_VARIANT: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Variant)); + ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values = ecore_list_new(); + ecore_list_set_free_cb(ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values, + _ecore_dbus_message_field_free); + break; + case ECORE_DBUS_DATA_TYPE_STRUCT: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Struct)); + ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values = ecore_list_new(); + ecore_list_set_free_cb(ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f)->values, + _ecore_dbus_message_field_free); + break; + case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: + f = NULL; + break; + case ECORE_DBUS_DATA_TYPE_STRUCT_END: + f = NULL; + break; + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: + f = calloc(1, sizeof(Ecore_DBus_Message_Field_Dict_Entry)); + break; + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: + f = NULL; + break; + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: + f = NULL; + break; + } + if (!f) return NULL; + + f->type = type; + if (!ecore_list_is_empty(msg->recurse)) + { + Ecore_DBus_Message_Field_Container *c; + + c = ecore_list_first(msg->recurse); + ecore_list_append(c->values, f); + } + else + { + ecore_list_append(msg->fields, f); + } + + f->offset = msg->length; + f->buffer = msg->buffer + f->offset; + return f; +} + +void +_ecore_dbus_message_free(Ecore_DBus_Message *msg) +{ + _ecore_dbus_message_field_free(msg->header); + ecore_list_destroy(msg->fields); + ecore_list_destroy(msg->recurse); + free(msg->buffer); + free(msg); +} + +/* private functions */ + +/* header functions */ + +static void +_ecore_dbus_message_common_header(Ecore_DBus_Message *msg, int type, int flags) +{ + /* endiannes (1) */ + msg->buffer[0] = msg->byte_order = 'l'; + /* type (1) */ + msg->buffer[1] = msg->type = (char)type; + /* flags (1) 0x1 = no reply expected, 0x2 auto activation */ + msg->buffer[2] = msg->flags = 0x0; + /* protocol (1) */ + msg->buffer[3] = msg->protocol = ECORE_DBUS_MAJOR_PROTOCOL_VERSION; + /* autoincrement the client_serial (0 is invalid) */ + msg->server->cnt_msg++; + + *(unsigned int *)(msg->buffer + 8) = msg->serial = msg->server->cnt_msg; + msg->length = 12; +} + +static void +_ecore_dbus_message_field_free(void *data) +{ + Ecore_DBus_Message_Field *f; + + f = data; + switch (f->type) + { + case ECORE_DBUS_DATA_TYPE_BYTE: + case ECORE_DBUS_DATA_TYPE_BOOLEAN: + case ECORE_DBUS_DATA_TYPE_INT16: + case ECORE_DBUS_DATA_TYPE_UINT16: + case ECORE_DBUS_DATA_TYPE_INT32: + case ECORE_DBUS_DATA_TYPE_UINT32: + case ECORE_DBUS_DATA_TYPE_INT64: + case ECORE_DBUS_DATA_TYPE_UINT64: + case ECORE_DBUS_DATA_TYPE_DOUBLE: + case ECORE_DBUS_DATA_TYPE_STRING: + case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + free(f); + break; + case ECORE_DBUS_DATA_TYPE_ARRAY: + case ECORE_DBUS_DATA_TYPE_VARIANT: + case ECORE_DBUS_DATA_TYPE_STRUCT: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: + { + Ecore_DBus_Message_Field_Container *c; + + c = (Ecore_DBus_Message_Field_Container *)f; + ecore_list_destroy(c->values); + } + free(f); + break; + case ECORE_DBUS_DATA_TYPE_INVALID: + case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: + case ECORE_DBUS_DATA_TYPE_STRUCT_END: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: + break; + } +} + +/* printing functions */ + +static void +_ecore_dbus_message_field_print(Ecore_DBus_Message_Field *f) +{ + switch (f->type) + { + case ECORE_DBUS_DATA_TYPE_BYTE: + printf + ("[ecore_dbus] field BYTE: value offset = %d value = %c %d\n", + f->offset, (char)*(f->buffer), (char)*(f->buffer)); + break; + case ECORE_DBUS_DATA_TYPE_INT32: + printf + ("[ecore_dbus] field INT32: value offset = %d value = %d\n", + f->offset, (int)*(f->buffer)); + break; + case ECORE_DBUS_DATA_TYPE_UINT32: + printf + ("[ecore_dbus] field UINT32: value offset = %d value = %u\n", + f->offset, (unsigned int)*(f->buffer)); + break; + case ECORE_DBUS_DATA_TYPE_STRING: + printf + ("[ecore_dbus] field STRING: value offset = %d length = %d value = %s\n", + f->offset, (unsigned int)*(f->buffer), (f->buffer + 4)); + break; + case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: + printf + ("[ecore_dbus] field PATH: value offset = %d length = %d value = %s\n", + f->offset, (unsigned int)*(f->buffer), (f->buffer + 4)); + break; + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + printf + ("[ecore_dbus] field SIGNATURE: value offset = %d length = %d value = %s\n", + f->offset, (unsigned int)*(f->buffer), (f->buffer + 1)); + break; + case ECORE_DBUS_DATA_TYPE_ARRAY: + { + Ecore_DBus_Message_Field_Container *c; + Ecore_DBus_Message_Field *s; + + c = (Ecore_DBus_Message_Field_Container *)f; + printf + ("[ecore_dbus] field ARRAY: value offset = %d length = %u\n", + f->offset, (unsigned int)*(f->buffer)); + printf("[ecore_dbus] * ARRAY elements begin *\n"); + ecore_list_goto_first(c->values); + while ((s = ecore_list_next(c->values))) + _ecore_dbus_message_field_print(s); + printf("[ecore_dbus] * ARRAY elements end *\n"); + } + break; + case ECORE_DBUS_DATA_TYPE_STRUCT: + { + Ecore_DBus_Message_Field_Container *c; + Ecore_DBus_Message_Field *s; + + c = (Ecore_DBus_Message_Field_Container *)f; + printf + ("[ecore_dbus] field STRUCT: value offset = %d\n", + f->offset); + printf("[ecore_dbus] * STRUCT elements begin *\n"); + ecore_list_goto_first(c->values); + while ((s = ecore_list_next(c->values))) + _ecore_dbus_message_field_print(s); + printf("[ecore_dbus] * STRUCT elements end *\n"); + } + break; + case ECORE_DBUS_DATA_TYPE_VARIANT: + { + Ecore_DBus_Message_Field_Variant *v; + + v = (Ecore_DBus_Message_Field_Variant *)f; + printf + ("[ecore_dbus] field VARIANT: value offset = %d length: %d signature = %c\n", + f->offset, (char)*(f->buffer), (char)*(f->buffer + 1)); + printf("[ecore_dbus] * VARIANT element begin *\n"); + _ecore_dbus_message_field_print(v->value); + printf("[ecore_dbus] * VARIANT element end *\n"); + } + break; + case ECORE_DBUS_DATA_TYPE_INVALID: + case ECORE_DBUS_DATA_TYPE_BOOLEAN: + case ECORE_DBUS_DATA_TYPE_INT16: + case ECORE_DBUS_DATA_TYPE_UINT16: + case ECORE_DBUS_DATA_TYPE_INT64: + case ECORE_DBUS_DATA_TYPE_UINT64: + case ECORE_DBUS_DATA_TYPE_DOUBLE: + case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN: + case ECORE_DBUS_DATA_TYPE_STRUCT_END: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END: + /* TODO */ + printf("[ecore_dbus] field not implemented: %c\n", f->type); + break; +#if 0 + default: + printf("[ecore_dbus] field !UNKNOWN!: %c\n", f->type); + break; +#endif + } +} + +static void +_ecore_dbus_message_header_field_print(Ecore_DBus_Message_Field_Container *arr) +{ + Ecore_DBus_Message_Field_Container *s; + static const char *header_fields[] = { + "INVALID", "PATH", "INTERFACE", "MEMBER", "ERROR_NAME", + "REPLY_SERIAL", "DESTINATION", "SENDER", "SIGNATURE" + }; + + ecore_list_goto_first(arr->values); + while ((s = ecore_list_next(arr->values))) + { + Ecore_DBus_Message_Field_Byte *b; + b = ecore_list_first(s->values); + printf("[ecore_dbus] header field %s ", header_fields[b->value]); + _ecore_dbus_message_field_print(ecore_list_last(s->values)); + } +} + +static void +_ecore_dbus_message_print_raw(Ecore_DBus_Message *msg) +{ + int i; + + printf("[ecore_dbus] raw message:\n"); + for (i = 0; i < msg->length; i++) + { + if ((i % 16) == 0) + printf("\n"); + if ((msg->buffer[i] > 31) && (msg->buffer[i] < 128)) + printf("%c", msg->buffer[i]); + else + printf("*");//, msg->buffer[i]); + } + printf("\n"); + printf("[ecore_dbus] end raw message\n"); +} diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_private.h b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_private.h index 3011bf2c4b..2272d8b731 100644 --- a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_private.h +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_private.h @@ -4,9 +4,31 @@ #ifndef _ECORE_DBUS_PRIVATE_H #define _ECORE_DBUS_PRIVATE_H -typedef struct _Ecore_DBus_Auth Ecore_DBus_Auth; typedef unsigned char *(*Ecore_DBus_Auth_Transaction)(void *); +typedef struct _Ecore_DBus_Auth Ecore_DBus_Auth; + +typedef struct _Ecore_DBus_Message_Field_Container Ecore_DBus_Message_Field_Container; + +#define ECORE_DBUS_MESSAGE_FIELD(x) ((Ecore_DBus_Message_Field *)(x)) +#define ECORE_DBUS_MESSAGE_FIELD_CONTAINER(x) ((Ecore_DBus_Message_Field_Container *)(x)) +typedef struct _Ecore_DBus_Message_Field_Byte Ecore_DBus_Message_Field_Byte; +typedef struct _Ecore_DBus_Message_Field_Boolean Ecore_DBus_Message_Field_Boolean; +typedef struct _Ecore_DBus_Message_Field_Int16 Ecore_DBus_Message_Field_Int16; +typedef struct _Ecore_DBus_Message_Field_UInt16 Ecore_DBus_Message_Field_UInt16; +typedef struct _Ecore_DBus_Message_Field_Int32 Ecore_DBus_Message_Field_Int32; +typedef struct _Ecore_DBus_Message_Field_UInt32 Ecore_DBus_Message_Field_UInt32; +typedef struct _Ecore_DBus_Message_Field_Int64 Ecore_DBus_Message_Field_Int64; +typedef struct _Ecore_DBus_Message_Field_UInt64 Ecore_DBus_Message_Field_UInt64; +typedef struct _Ecore_DBus_Message_Field_Double Ecore_DBus_Message_Field_Double; +typedef struct _Ecore_DBus_Message_Field_String Ecore_DBus_Message_Field_String; +typedef struct _Ecore_DBus_Message_Field_Object_Path Ecore_DBus_Message_Field_Object_Path; +typedef struct _Ecore_DBus_Message_Field_Signature Ecore_DBus_Message_Field_Signature; +typedef struct _Ecore_DBus_Message_Field_Array Ecore_DBus_Message_Field_Array; +typedef struct _Ecore_DBus_Message_Field_Variant Ecore_DBus_Message_Field_Variant; +typedef struct _Ecore_DBus_Message_Field_Struct Ecore_DBus_Message_Field_Struct; +typedef struct _Ecore_DBus_Message_Field_Dict_Entry Ecore_DBus_Message_Field_Dict_Entry; + typedef enum _Ecore_DBus_Auth_Type { ECORE_DBUS_AUTH_TYPE_EXTERNAL, @@ -37,33 +59,138 @@ struct _Ecore_DBus_Server struct _Ecore_DBus_Message { + /* server to send to */ + Ecore_DBus_Server *server; + /* header fields */ - unsigned char byte_order; - unsigned char type; - unsigned char flags; - unsigned char protocol; - unsigned int hlength; - unsigned int blength; - unsigned int serial; + unsigned char byte_order; + unsigned char type; + unsigned char flags; + unsigned char protocol; + unsigned int serial; + unsigned int body_length; + unsigned char *signature; - Ecore_DBus_Server *ref_server; + /* message */ + unsigned int size; + unsigned int length; + unsigned char *buffer; - unsigned char *header; - unsigned int hpos; - Ecore_DBus_Message_Field *header_fields; - unsigned char *body; - unsigned int bpos; - Ecore_DBus_Message_Field *body_fields; - unsigned char *signature; + void *header; + Ecore_List *fields; + Ecore_List *recurse; }; struct _Ecore_DBus_Message_Field { - Ecore_List2 __list_data; Ecore_DBus_Data_Type type; unsigned int offset; - unsigned int count; /* number of elements, usefull for structs, arrays, dicts */ - unsigned int hfield; /* if the field is a header field, we need the type of it */ + unsigned char *buffer; +}; + +struct _Ecore_DBus_Message_Field_Container +{ + Ecore_DBus_Message_Field __field; + Ecore_List *values; +}; + +struct _Ecore_DBus_Message_Field_Byte +{ + Ecore_DBus_Message_Field __field; + unsigned char value; +}; + +struct _Ecore_DBus_Message_Field_Boolean +{ + Ecore_DBus_Message_Field __field; + unsigned int value; +}; + +struct _Ecore_DBus_Message_Field_Int16 +{ + Ecore_DBus_Message_Field __field; + short value; +}; + +struct _Ecore_DBus_Message_Field_UInt16 +{ + Ecore_DBus_Message_Field __field; + unsigned short value; +}; + +struct _Ecore_DBus_Message_Field_Int32 +{ + Ecore_DBus_Message_Field __field; + int value; +}; + +struct _Ecore_DBus_Message_Field_UInt32 +{ + Ecore_DBus_Message_Field __field; + unsigned int value; +}; + +struct _Ecore_DBus_Message_Field_Int64 +{ + Ecore_DBus_Message_Field __field; + long long value; +}; + +struct _Ecore_DBus_Message_Field_UInt64 +{ + Ecore_DBus_Message_Field __field; + unsigned long long value; +}; + +struct _Ecore_DBus_Message_Field_Double +{ + Ecore_DBus_Message_Field __field; + double value; +}; + +struct _Ecore_DBus_Message_Field_String +{ + Ecore_DBus_Message_Field __field; + char *value; +}; + +struct _Ecore_DBus_Message_Field_Object_Path +{ + Ecore_DBus_Message_Field __field; + char *value; +}; + +struct _Ecore_DBus_Message_Field_Signature +{ + Ecore_DBus_Message_Field __field; + char *value; +}; + +struct _Ecore_DBus_Message_Field_Array +{ + Ecore_DBus_Message_Field_Container __field; + Ecore_DBus_Data_Type contained_type; + unsigned int start; + unsigned int end; +}; + +struct _Ecore_DBus_Message_Field_Variant +{ + Ecore_DBus_Message_Field_Container __field; + Ecore_DBus_Data_Type contained_type; + void *value; +}; + +struct _Ecore_DBus_Message_Field_Struct +{ + Ecore_DBus_Message_Field_Container __field; +}; + +struct _Ecore_DBus_Message_Field_Dict_Entry +{ + Ecore_DBus_Message_Field __field; + Ecore_DBus_Message_Field *key; + Ecore_DBus_Message_Field *value; }; struct _Ecore_DBus_Auth @@ -73,76 +200,69 @@ struct _Ecore_DBus_Auth Ecore_DBus_Auth_Transaction transactions[5]; }; +/* ecore_dbus_message.c */ +Ecore_DBus_Message *_ecore_dbus_message_new(Ecore_DBus_Server *svr); +void _ecore_dbus_message_free(Ecore_DBus_Message *msg); +void *_ecore_dbus_message_field_new(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type type); /* ecore_dbus_utils.c */ -void _ecore_dbus_message_append_length(unsigned char **buf, unsigned int old_length, unsigned int size); -void _ecore_dbus_message_increase_length(unsigned char **buf, unsigned int new_length); -void _ecore_dbus_message_padding(unsigned char **buf, unsigned int *old_length, int size); -void _ecore_dbus_message_padding_skip(unsigned int *old_length, int size); -void _ecore_dbus_message_append_nbytes(unsigned char *buf, unsigned char *data, unsigned int data_length); -void _ecore_dbus_message_append_byte(unsigned char *buf, unsigned char c); -void _ecore_dbus_message_append_uint32(unsigned char *buf, unsigned int i); -unsigned char _ecore_dbus_message_read_byte(unsigned char *buf); -unsigned int _ecore_dbus_message_read_uint32(unsigned char *buf); - -/* ecore_dbus.c */ -Ecore_DBus_Message *_ecore_dbus_message_new(Ecore_DBus_Server *svr); -Ecore_DBus_Message_Field *_ecore_dbus_message_new_field(Ecore_DBus_Data_Type type, unsigned int offset); +void _ecore_dbus_message_padding(Ecore_DBus_Message *msg, unsigned int size); +void _ecore_dbus_message_padding_skip(Ecore_DBus_Message *msg, unsigned int size); +void _ecore_dbus_message_append_bytes(Ecore_DBus_Message *msg, unsigned char *c, unsigned int size); +void _ecore_dbus_message_append_byte(Ecore_DBus_Message *msg, unsigned char c); +void _ecore_dbus_message_append_uint32(Ecore_DBus_Message *msg, unsigned int i); +unsigned char _ecore_dbus_message_read_byte(Ecore_DBus_Message *msg); +unsigned int _ecore_dbus_message_read_uint32(Ecore_DBus_Message *msg); +int _ecore_dbus_alignment_get(Ecore_DBus_Data_Type type); /* ecore_dbus_marshal.c */ -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_byte(unsigned char **buf, unsigned int *old_length, unsigned char c); -/* +Ecore_DBus_Message_Field_Byte *_ecore_dbus_message_marshal_byte(Ecore_DBus_Message *msg, unsigned char c); +#if 0 Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_boolean(unsigned char **buf, unsigned int *old_length, uint32_t i); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_int16(unsigned char **buf, unsigned int *old_length, int16_t i); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_uint16(unsigned char **buf, unsigned int *old_length, uint16_t i); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_int32(unsigned char **buf, unsigned int *old_length, int32_t i); -*/ -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_uint32(unsigned char **buf, unsigned int *old_length, uint32_t i); -/* +#endif +Ecore_DBus_Message_Field_UInt32 *_ecore_dbus_message_marshal_uint32(Ecore_DBus_Message *msg, unsigned int i); +#if 0 Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_int64(unsigned char **buf, unsigned int *old_length, int64_t i); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_uint64(unsigned char **buf, unsigned int *old_length, uint64_t i); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_double(unsigned char **buf, unsigned int *old_length, double i); -*/ -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_string(unsigned char **buf, unsigned int *old_length, char *str); -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_object_path(unsigned char **buf, unsigned int *old_length, char *str); -/* -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_signature(unsigned char **buf, unsigned int *old_length, char *str); -*/ -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_array(unsigned char **msg, unsigned int *old_length, Ecore_DBus_Data_Type contained_type); -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_struct_begin(unsigned char **msg, unsigned int *old_length); -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_struct_end(unsigned char **msg, unsigned int *old_length); -/* - * FIXME: These aren't correct ! -Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_variant(unsigned char **msg, unsigned int *old_length); +#endif +Ecore_DBus_Message_Field_String *_ecore_dbus_message_marshal_string(Ecore_DBus_Message *msg, char *str); +Ecore_DBus_Message_Field_Object_Path *_ecore_dbus_message_marshal_object_path(Ecore_DBus_Message *msg, char *str); +Ecore_DBus_Message_Field_Signature *_ecore_dbus_message_marshal_signature(Ecore_DBus_Message *msg, char *str); +Ecore_DBus_Message_Field_Array *_ecore_dbus_message_marshal_array_begin(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type contained_type); +void _ecore_dbus_message_marshal_array_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Array *arr); +Ecore_DBus_Message_Field_Struct *_ecore_dbus_message_marshal_struct_begin(Ecore_DBus_Message *msg); +void _ecore_dbus_message_marshal_struct_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Struct *s); +Ecore_DBus_Message_Field_Variant *_ecore_dbus_message_marshal_variant(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type type, void *data); +#if 0 Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_dict_entry(unsigned char **msg, unsigned int *old_length); -*/ Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_data(unsigned char **buf, unsigned int *old_length, Ecore_DBus_Data_Type type, void *data); Ecore_DBus_Message_Field *_ecore_dbus_message_marshal_custom_header(unsigned char **buf, unsigned int *old_length, unsigned int code, Ecore_DBus_Data_Type type, void *data); +#endif + /* ecore_dbus_unmarshal.c */ /* Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_byte(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_boolean(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_int16(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_uint16(unsigned char *buf, unsigned int *old_length); -*/ Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_int32(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_uint32(unsigned char *buf, unsigned int *old_length); -/* Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_int64(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_uint64(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_double(unsigned char *buf, unsigned int *old_length); -*/ Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_string(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_object_path(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_signature(unsigned char *buf, unsigned int *old_length); -/* - * FIXME: These aren't correct! Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_array(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_variant(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_struct(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_dict_entry(unsigned char *buf, unsigned int *old_length); -*/ Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_data(unsigned char *buf, unsigned int *old_length); Ecore_DBus_Message_Field *_ecore_dbus_message_unmarshal_custom_header(unsigned char *buf, unsigned int *old_length); -Ecore_DBus_Message *_ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message); +*/ +Ecore_DBus_Message *_ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message, int size); /* Errors */ #define DBUS_ERROR_FAILED "org.freedesktop.DBus.Error.Failed" diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_unmarshal.c b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_unmarshal.c index 2b0ddd4f4f..d35f992f38 100644 --- a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_unmarshal.c +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_unmarshal.c @@ -7,105 +7,255 @@ #include "Ecore_DBus.h" #include "ecore_dbus_private.h" -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_int32(unsigned char *buf, - unsigned int *old_length) +static Ecore_DBus_Message_Field_Byte * +_ecore_dbus_message_unmarshal_byte(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Byte *f; + unsigned int old_length; - _ecore_dbus_message_padding_skip(old_length, 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_INT32, *old_length); - *old_length += 4; + old_length = msg->length; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_BYTE); + f->value = _ecore_dbus_message_read_byte(msg); + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for byte: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_uint32(unsigned char *buf, - unsigned int *old_length) +static Ecore_DBus_Message_Field_Int32 * +_ecore_dbus_message_unmarshal_int32(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f; + Ecore_DBus_Message_Field_Int32 *f; + unsigned int old_length; - _ecore_dbus_message_padding_skip(old_length, 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_UINT32, *old_length); - *old_length += 4; + old_length = msg->length; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_INT32); + f->value = _ecore_dbus_message_read_uint32(msg); + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for uint32: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_string(unsigned char *buf, - unsigned int *old_length) +static Ecore_DBus_Message_Field_UInt32 * +_ecore_dbus_message_unmarshal_uint32(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f; - unsigned int str_len; + Ecore_DBus_Message_Field_UInt32 *f; + unsigned int old_length; - _ecore_dbus_message_padding_skip(old_length, 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_STRING, *old_length); - str_len = _ecore_dbus_message_read_uint32(buf + *old_length); - *old_length += 4; - *old_length += str_len + 1; + old_length = msg->length; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_UINT32); + f->value = _ecore_dbus_message_read_uint32(msg); + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for uint32: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_object_path(unsigned char *buf, unsigned int *old_length) +static Ecore_DBus_Message_Field_String * +_ecore_dbus_message_unmarshal_string(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f; - unsigned int str_len; + Ecore_DBus_Message_Field_String *f; + unsigned int str_len, old_length; - _ecore_dbus_message_padding_skip(old_length, 4); - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_OBJECT_PATH, - *old_length); - str_len = _ecore_dbus_message_read_uint32(buf + *old_length); - *old_length += 4; - *old_length += str_len + 1; + old_length = msg->length; + _ecore_dbus_message_padding(msg, 4); + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_STRING); + str_len = _ecore_dbus_message_read_uint32(msg); + f->value = (char *)msg->buffer + msg->length; + msg->length += str_len + 1; + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for string: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_signature(unsigned char *buf, - unsigned int *old_length) +static Ecore_DBus_Message_Field_Object_Path * +_ecore_dbus_message_unmarshal_object_path(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f; - unsigned int str_len; + Ecore_DBus_Message_Field_Object_Path *f; + unsigned int str_len, old_length; - f = _ecore_dbus_message_new_field(ECORE_DBUS_DATA_TYPE_SIGNATURE, *old_length); - str_len = _ecore_dbus_message_read_byte(buf + *old_length); - *old_length += 1; - *old_length += str_len + 1; + old_length = msg->length; + _ecore_dbus_message_padding(msg, 4); + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_OBJECT_PATH); + str_len = _ecore_dbus_message_read_uint32(msg); + f->value = (char *)msg->buffer + msg->length; + msg->length += str_len + 1; + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for object path: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); return f; } -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_data(unsigned char *buf, unsigned int *old_length) +static Ecore_DBus_Message_Field_Signature * +_ecore_dbus_message_unmarshal_signature(Ecore_DBus_Message *msg, int *size) { - Ecore_DBus_Message_Field *f = NULL; - Ecore_DBus_Data_Type type; - - type = _ecore_dbus_message_read_byte(buf + *old_length); - *old_length += 1; + Ecore_DBus_Message_Field_Signature *f; + unsigned int str_len, old_length; + + old_length = msg->length; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_SIGNATURE); + str_len = _ecore_dbus_message_read_byte(msg); + f->value = (char *)msg->buffer + msg->length; + msg->length += str_len + 1; + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for signature: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); + return f; +} + +static Ecore_DBus_Message_Field_Array * +_ecore_dbus_message_unmarshal_array_begin(Ecore_DBus_Message *msg, + Ecore_DBus_Data_Type contained_type, int *size) +{ + Ecore_DBus_Message_Field_Array *arr; + unsigned int old_length; + + old_length = msg->length; + _ecore_dbus_message_padding_skip(msg, 4); + + arr = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_ARRAY); + arr->start = 0; + arr->end = _ecore_dbus_message_read_uint32(msg); + + _ecore_dbus_message_padding_skip(msg, _ecore_dbus_alignment_get(contained_type)); + arr->start = msg->length; + arr->end += msg->length; + + ecore_list_prepend(msg->recurse, arr); + + if (*size < (arr->end - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for array: got %d need %d\n", + *size, (arr->end - old_length)); + return NULL; + } + *size -= (msg->length - old_length); + return arr; +} + +static void +_ecore_dbus_message_unmarshal_array_end(Ecore_DBus_Message *msg, + Ecore_DBus_Message_Field_Array *arr) +{ + ecore_list_remove_first(msg->recurse); +} + +static Ecore_DBus_Message_Field_Struct * +_ecore_dbus_message_unmarshal_struct_begin(Ecore_DBus_Message *msg, + int *size) +{ + Ecore_DBus_Message_Field_Struct *s; + unsigned int old_length; + + old_length = msg->length; + _ecore_dbus_message_padding_skip(msg, 8); + + s = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_STRUCT); + ecore_list_prepend(msg->recurse, s); + + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for struct: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); + return s; +} + +static void +_ecore_dbus_message_unmarshal_struct_end(Ecore_DBus_Message *msg, + Ecore_DBus_Message_Field_Struct *s) +{ + ecore_list_remove_first(msg->recurse); +} + +static Ecore_DBus_Message_Field_Variant * +_ecore_dbus_message_unmarshal_variant(Ecore_DBus_Message *msg, int *size) +{ + Ecore_DBus_Message_Field_Variant *f = NULL; + unsigned int old_length; + unsigned char length; + Ecore_DBus_Data_Type type; + + old_length = msg->length; + f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_VARIANT); + ecore_list_prepend(msg->recurse, f); + f->contained_type = type; + + /* signature length */ + length = _ecore_dbus_message_read_byte(msg); + if (length != 1) + { + /* TODO: Free message field */ + printf("Ecore_DBus: Wrong length for variant signature: %d\n", length); + return NULL; + } + /* signature */ + type = _ecore_dbus_message_read_byte(msg); + if (*size < (msg->length - old_length)) + { + /* TODO: Free message field */ + printf("Ecore_DBus: To few bytes for variant header: got %d need %d\n", + *size, (msg->length - old_length)); + return NULL; + } + *size -= (msg->length - old_length); switch (type) { - case ECORE_DBUS_DATA_TYPE_INT32: - f = _ecore_dbus_message_unmarshal_int32(buf, old_length); - break; case ECORE_DBUS_DATA_TYPE_UINT32: - f = _ecore_dbus_message_unmarshal_uint32(buf, old_length); + f->value = _ecore_dbus_message_unmarshal_uint32(msg, size); break; case ECORE_DBUS_DATA_TYPE_STRING: - f = _ecore_dbus_message_unmarshal_string(buf, old_length); + f->value = _ecore_dbus_message_unmarshal_string(msg, size); break; case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - f = _ecore_dbus_message_unmarshal_object_path(buf, old_length); + f->value = _ecore_dbus_message_unmarshal_object_path(msg, size); break; case ECORE_DBUS_DATA_TYPE_SIGNATURE: - f = _ecore_dbus_message_unmarshal_signature(buf, old_length); + f->value = _ecore_dbus_message_unmarshal_signature(msg, size); break; case ECORE_DBUS_DATA_TYPE_INVALID: case ECORE_DBUS_DATA_TYPE_BYTE: case ECORE_DBUS_DATA_TYPE_BOOLEAN: case ECORE_DBUS_DATA_TYPE_INT16: case ECORE_DBUS_DATA_TYPE_UINT16: + case ECORE_DBUS_DATA_TYPE_INT32: case ECORE_DBUS_DATA_TYPE_INT64: case ECORE_DBUS_DATA_TYPE_UINT64: case ECORE_DBUS_DATA_TYPE_DOUBLE: @@ -123,108 +273,92 @@ _ecore_dbus_message_unmarshal_data(unsigned char *buf, unsigned int *old_length) printf("[ecore_dbus] unknown/unhandled data type %c\n", type); break; } - return f; -} - -Ecore_DBus_Message_Field * -_ecore_dbus_message_unmarshal_custom_header(unsigned char *buf, - unsigned int *old_length) -{ - Ecore_DBus_Message_Field *f; - unsigned int code, length; - - _ecore_dbus_message_padding_skip(old_length, 8); - /* get header field name at cur_length */ - code = _ecore_dbus_message_read_byte(buf + *old_length); - *old_length += 1; - /* Read signature length */ - length = _ecore_dbus_message_read_byte(buf + *old_length); - if (length != 1) - fprintf(stderr, "[ecore_dbus]: Wrong signature length in header\n"); - *old_length += 1; - - /* unmarshal header field data */ - f = _ecore_dbus_message_unmarshal_data(buf, old_length); - if (f) f->hfield = code; + ecore_list_remove_first(msg->recurse); return f; } Ecore_DBus_Message * -_ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message) +_ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message, int size) { - Ecore_DBus_Message_Field *f, *sig; + Ecore_DBus_Message *msg; + Ecore_DBus_Message_Field_Array *arr; + Ecore_DBus_Message_Field_Signature *sig; + unsigned int old_length; /* init */ - Ecore_DBus_Message *msg = _ecore_dbus_message_new(svr); - + if (size < 16) + { + printf("Ecore_DBus: To few bytes for minimal header: %d\n", size); + return NULL; + } printf("[ecore_dbus] unmarshaling\n"); + msg = _ecore_dbus_message_new(svr); /* message header */ - - /* common fields */ msg->byte_order = *(message + 0); msg->type = *(message + 1); msg->flags = *(message + 2); msg->protocol = *(message + 3); - msg->blength = *(unsigned int *)(message + 4); + msg->body_length = *(unsigned int *)(message + 4); msg->serial = *(unsigned int *)(message + 8); - msg->hlength = *(unsigned int *)(message + 12) + 16; - _ecore_dbus_message_padding_skip(&(msg->hlength), 8); if (msg->type == ECORE_DBUS_MESSAGE_TYPE_INVALID) { printf("[ecore_dbus] message type invalid\n"); return NULL; } - msg->hpos += 16; - /* memcpy the header part */ - _ecore_dbus_message_increase_length(&msg->header, msg->hlength); - _ecore_dbus_message_append_nbytes(msg->header, message, msg->hlength); - /* custom fields */ - sig = NULL; - while ((msg->hpos + 8 - (msg->hpos % 8)) < msg->hlength) + /* copy message to buffer */ + _ecore_dbus_message_append_bytes(msg, message, size); + msg->length = 12; + size -= 12; + /* Parse custom header */ + if (!(arr = _ecore_dbus_message_unmarshal_array_begin(msg, ECORE_DBUS_DATA_TYPE_STRUCT, &size))) { - f = _ecore_dbus_message_unmarshal_custom_header(message, &msg->hpos); - if (f) - { - msg->header_fields = _ecore_list2_append(msg->header_fields, f); - if (f->type == ECORE_DBUS_DATA_TYPE_SIGNATURE) - sig = f; - } + printf("Could not parse custom header.\n"); + goto error; } - msg->hpos = msg->hlength; - message += msg->hlength; + while (msg->length < arr->end) + { + Ecore_DBus_Message_Field_Struct *s; + s = _ecore_dbus_message_unmarshal_struct_begin(msg, &size); + _ecore_dbus_message_unmarshal_byte(msg, &size); + _ecore_dbus_message_unmarshal_variant(msg, &size); + _ecore_dbus_message_unmarshal_struct_end(msg, s); + } + _ecore_dbus_message_unmarshal_array_end(msg, arr); + msg->header = ecore_list_remove_first(msg->fields); + sig = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_SIGNATURE); + old_length = msg->length; + _ecore_dbus_message_padding_skip(msg, 8); + + size -= (msg->length - old_length); /* message body */ if (sig) { - unsigned char *s; - Ecore_DBus_Data_Type type; + char *s; - _ecore_dbus_message_increase_length(&msg->body, msg->blength); - _ecore_dbus_message_append_nbytes(msg->body, message, msg->blength); - - s = msg->header + sig->offset + 2; + s = sig->value; while (*s) { - f = NULL; - printf("body: %c\n", *s); + Ecore_DBus_Data_Type type; + type = *s; switch (type) { case ECORE_DBUS_DATA_TYPE_INT32: - f = _ecore_dbus_message_unmarshal_int32(msg->body, &(msg->bpos)); + _ecore_dbus_message_unmarshal_int32(msg, &size); break; case ECORE_DBUS_DATA_TYPE_UINT32: - f = _ecore_dbus_message_unmarshal_uint32(msg->body, &(msg->bpos)); + _ecore_dbus_message_unmarshal_uint32(msg, &size); break; case ECORE_DBUS_DATA_TYPE_STRING: - f = _ecore_dbus_message_unmarshal_string(msg->body, &(msg->bpos)); + _ecore_dbus_message_unmarshal_string(msg, &size); break; case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: - f = _ecore_dbus_message_unmarshal_object_path(msg->body, &(msg->bpos)); + _ecore_dbus_message_unmarshal_object_path(msg, &size); break; case ECORE_DBUS_DATA_TYPE_SIGNATURE: - f = _ecore_dbus_message_unmarshal_signature(msg->body, &(msg->bpos)); + _ecore_dbus_message_unmarshal_signature(msg, &size); break; case ECORE_DBUS_DATA_TYPE_INVALID: case ECORE_DBUS_DATA_TYPE_BYTE: @@ -248,10 +382,11 @@ _ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message) printf("[ecore_dbus] unknown/unhandled data type %c\n", type); break; } - if (f) - msg->body_fields = _ecore_list2_append(msg->body_fields, f); s++; } } return msg; +error: + _ecore_dbus_message_free(msg); + return NULL; } diff --git a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_utils.c b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_utils.c index 6af21e8022..8b7e0fb199 100644 --- a/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_utils.c +++ b/legacy/ecore/src/lib/ecore_dbus/ecore_dbus_utils.c @@ -1,85 +1,138 @@ -/* length functions */ +/* + * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2 + */ #include #include -void -_ecore_dbus_message_append_length(unsigned char **buf, - unsigned int old_length, unsigned int size) +#include "ecore_private.h" +#include "Ecore_Con.h" +#include "Ecore_DBus.h" +#include "ecore_dbus_private.h" + +static void _ecore_dbus_message_length_append(Ecore_DBus_Message *msg, unsigned int size); + +static void +_ecore_dbus_message_length_append(Ecore_DBus_Message *msg, unsigned int size) { - *buf = realloc(*buf, old_length + size); - memset(*buf + old_length, 0, size); + if (msg->length + size >= msg->size) + { + size = (((msg->size + size) / 128) + 1) * 128; + + msg->buffer = realloc(msg->buffer, size); + memset(msg->buffer + msg->size, 0, size - msg->size); + msg->size = size; + } } void -_ecore_dbus_message_increase_length(unsigned char **buf, - unsigned int new_length) -{ - *buf = realloc(*buf, new_length); -} - -/* padding functions */ - -void -_ecore_dbus_message_padding(unsigned char **buf, unsigned int *old_length, int size) +_ecore_dbus_message_padding(Ecore_DBus_Message *msg, unsigned int size) { unsigned int padding; - padding = *old_length % size; + padding = msg->length % size; if (padding != 0) { padding = size - padding; - _ecore_dbus_message_append_length(buf, *old_length, padding); + _ecore_dbus_message_length_append(msg, padding); + msg->length += padding; } - *old_length += padding; } void -_ecore_dbus_message_padding_skip(unsigned int *old_length, int size) +_ecore_dbus_message_padding_skip(Ecore_DBus_Message *msg, unsigned int size) { unsigned int padding; - padding = *old_length % size; + padding = msg->length % size; if (padding != 0) - *old_length += size - padding; - return; + { + padding = size - padding; + /* We append the padding, so that we are sure that the buffer + * is at least length in size + */ + _ecore_dbus_message_length_append(msg, padding); + msg->length += padding; + } } -/* appending/reading functions */ - void -_ecore_dbus_message_append_nbytes(unsigned char *buf, unsigned char *data, - unsigned int data_length) +_ecore_dbus_message_append_bytes(Ecore_DBus_Message *msg, unsigned char *c, unsigned int size) { - memcpy(buf, data, data_length); + _ecore_dbus_message_length_append(msg, size); + memcpy(msg->buffer + msg->length, c, size); + msg->length += size; } void -_ecore_dbus_message_append_byte(unsigned char *buf, unsigned char c) +_ecore_dbus_message_append_byte(Ecore_DBus_Message *msg, unsigned char c) { - *buf = c; + _ecore_dbus_message_length_append(msg, 1); + msg->buffer[msg->length++] = c; } void -_ecore_dbus_message_append_uint32(unsigned char *buf, unsigned int i) +_ecore_dbus_message_append_uint32(Ecore_DBus_Message *msg, unsigned int i) { unsigned char *c; c = (unsigned char *)&i; - *(buf + 0) = *(c + 0); - *(buf + 1) = *(c + 1); - *(buf + 2) = *(c + 2); - *(buf + 3) = *(c + 3); + _ecore_dbus_message_length_append(msg, 4); + msg->buffer[msg->length++] = c[0]; + msg->buffer[msg->length++] = c[1]; + msg->buffer[msg->length++] = c[2]; + msg->buffer[msg->length++] = c[3]; } unsigned char -_ecore_dbus_message_read_byte(unsigned char *buf) +_ecore_dbus_message_read_byte(Ecore_DBus_Message *msg) { - return *(unsigned char *)buf; + unsigned char c; + + _ecore_dbus_message_length_append(msg, 1); + c = *(unsigned char *)(msg->buffer + msg->length); + msg->length++; + return c; } unsigned int -_ecore_dbus_message_read_uint32(unsigned char *buf) +_ecore_dbus_message_read_uint32(Ecore_DBus_Message *msg) { - return *(unsigned int *)buf; + unsigned int i; + + _ecore_dbus_message_length_append(msg, 4); + i = *(unsigned int *)(msg->buffer + msg->length); + msg->length += 4; + return i; } +int +_ecore_dbus_alignment_get(Ecore_DBus_Data_Type type) +{ + switch (type) + { + case ECORE_DBUS_DATA_TYPE_BYTE: + case ECORE_DBUS_DATA_TYPE_SIGNATURE: + case ECORE_DBUS_DATA_TYPE_VARIANT: + return 1; + case ECORE_DBUS_DATA_TYPE_INT16: + case ECORE_DBUS_DATA_TYPE_UINT16: + return 2; + case ECORE_DBUS_DATA_TYPE_BOOLEAN: + case ECORE_DBUS_DATA_TYPE_INT32: + case ECORE_DBUS_DATA_TYPE_UINT32: + case ECORE_DBUS_DATA_TYPE_STRING: + case ECORE_DBUS_DATA_TYPE_OBJECT_PATH: + case ECORE_DBUS_DATA_TYPE_ARRAY: + return 4; + case ECORE_DBUS_DATA_TYPE_INT64: + case ECORE_DBUS_DATA_TYPE_UINT64: + case ECORE_DBUS_DATA_TYPE_DOUBLE: + return 8; + case ECORE_DBUS_DATA_TYPE_STRUCT: + case ECORE_DBUS_DATA_TYPE_DICT_ENTRY: + return 8; + default: + printf("Ecore_DBus: Alignment requested for invalid data type!\n"); + return 0; + } +}