enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

move ecore_dbus to proto and flag it as deprecated 

SVN revision: 30742
This commit is contained in:
rephorm 2007-07-11 05:46:52 +00:00 committed by rephorm
parent 06b389a9e3
commit 2960827592
15 changed files with 2 additions and 3683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
legacy/ecore/Makefile.am
View File

@ -12,7 +12,6 @@ MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess \
debian/changelog \
ecore-con.pc \
ecore-config.pc \
ecore-dbus.pc \
ecore-desktop.pc \
ecore-directfb.pc\
ecore-evas.pc \
@ -31,7 +30,6 @@ EXTRA_DIST = AUTHORS COPYING COPYING-PLAIN ecore.c.in gendoc ecore.supp \
ecore.pc.in \
ecore-con.pc.in \
ecore-config.pc.in \
ecore-dbus.pc.in \
ecore-desktop.pc.in \
ecore-directfb.pc.in\
ecore-evas.pc.in \
@ -49,7 +47,6 @@ EXTRA_DIST = AUTHORS COPYING COPYING-PLAIN ecore.c.in gendoc ecore.supp \
debian/ecore0-bin.install \
debian/libecore0-con.install \
debian/libecore0-config.install \
debian/libecore0-dbus.install \
debian/libecore0-desktop.install \
debian/libecore0-dev.install \
debian/libecore0-evas.install \
@ -70,10 +67,6 @@ if BUILD_ECORE_CONFIG
pconfig = ecore-config.pc
endif
if BUILD_ECORE_DBUS
pdbus = ecore-dbus.pc
endif
if BUILD_ECORE_DIRECTFB
pdfb = ecore-directfb.pc
endif
@ -116,5 +109,5 @@ endif
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = \
ecore.pc $(pcon) $(pconfig) $(pdbus) $(pdfb) $(pevas) \
ecore.pc $(pcon) $(pconfig) $(pdfb) $(pevas) \
$(pfb) $(pfile) $(pdesktop) $(pipc) $(pjob) $(ptxt) $(px)

5
legacy/ecore/configure.in
View File

@ -63,7 +63,6 @@ AC_HEADER_SYS_WAIT
# only the trivial requirements go here.
requirements_ecore_con=""
requirements_ecore_config=""
requirements_ecore_dbus=""
requirements_ecore_desktop=""
requirements_ecore_directfb=""
requirements_ecore_evas="evas"
@ -747,7 +746,6 @@ AC_SUBST(PERL)
AC_SUBST(requirements_ecore_con)
AC_SUBST(requirements_ecore_config)
AC_SUBST(requirements_ecore_dbus)
AC_SUBST(requirements_ecore_desktop)
AC_SUBST(requirements_ecore_directfb)
AC_SUBST(requirements_ecore_evas)
@ -772,7 +770,6 @@ AC_OUTPUT([
Makefile
ecore-con.pc
ecore-config.pc
ecore-dbus.pc
ecore-desktop.pc
ecore-directfb.pc
ecore-evas.pc
@ -796,7 +793,6 @@ src/lib/ecore_ipc/Makefile
src/lib/ecore_txt/Makefile
src/lib/ecore_config/Makefile
src/lib/ecore_file/Makefile
src/lib/ecore_dbus/Makefile
src/lib/ecore_desktop/Makefile
src/lib/ecore_directfb/Makefile
README
@ -828,7 +824,6 @@ echo " Ecore_Evas DFB Support.......: $have_ecore_evas_dfb"
echo " Ecore_Evas Buffer Support....: $have_ecore_evas_buffer"
echo " Ecore_Ipc....................: $have_ecore_ipc (OpenSSL: $use_openssl)"
echo " Ecore_Config.................: $have_ecore_config"
echo " Ecore_DBUS...................: $have_ecore_dbus"
echo " Ecore_Desktop................: $have_ecore_desktop"
#echo " Ecore_File...................: $have_ecore_file (Inotify: $use_inotify) (FAM: $use_fam) (Poll: $use_poll)"
echo " Ecore_File...................: $have_ecore_file (Inotify: $use_inotify) (Poll: $use_poll) (CURL: $use_curl)"

3
legacy/ecore/src/lib/Makefile.am
View File

@ -11,5 +11,4 @@ ecore_ipc \
ecore_evas \
ecore_config \
ecore_file \
ecore_desktop \
ecore_dbus
ecore_desktop

7
legacy/ecore/src/lib/ecore_dbus/.cvsignore
View File

@ -1,7 +0,0 @@
.deps
.libs
Ecore_Con.h
Makefile
Makefile.in
*.lo
libecore_dbus.la

260
legacy/ecore/src/lib/ecore_dbus/Ecore_DBus.h
View File

@ -1,260 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#ifndef _ECORE_DBUS_H
#define _ECORE_DBUS_H
#include "Ecore_Data.h"
#include "Ecore_Con.h"
#ifdef EAPI
#undef EAPI
#endif
#ifdef _MSC_VER
# ifdef BUILDING_DLL
# define EAPI __declspec(dllexport)
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#define ECORE_DBUS_MAJOR_PROTOCOL_VERSION 0x1
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _Ecore_DBus_Server Ecore_DBus_Server;
typedef struct _Ecore_DBus_Event_Server_Add Ecore_DBus_Event_Server_Add;
typedef struct _Ecore_DBus_Event_Server_Del Ecore_DBus_Event_Server_Del;
typedef struct _Ecore_DBus_Event_Server_Data Ecore_DBus_Event_Server_Data;
typedef struct _Ecore_DBus_Event_Server_Data Ecore_DBus_Event_Signal;
typedef struct _Ecore_DBus_Event_Server_Data Ecore_DBus_Event_Method_Call;
typedef struct _Ecore_DBus_Event_Server_Data Ecore_DBus_Method_Return;
typedef struct _Ecore_DBus_Message Ecore_DBus_Message;
typedef struct _Ecore_DBus_Message_Arg Ecore_DBus_Message_Arg;
typedef struct _Ecore_DBus_Message_Field Ecore_DBus_Message_Field;
typedef struct _Ecore_DBus_Address Ecore_DBus_Address;
typedef void (*Ecore_DBus_Method_Call_Cb) (void *data, Ecore_DBus_Event_Method_Call *event);
typedef struct _Ecore_DBus_Object Ecore_DBus_Object;
typedef struct _Ecore_DBus_Object_Method Ecore_DBus_Object_Method;
typedef struct _Ecore_DBus_Object_Registry Ecore_DBus_Object_Registry;
struct _Ecore_DBus_Object
{
Ecore_DBus_Server *server;
char *path; /* dbus path name */
Ecore_List *methods;
};
struct _Ecore_DBus_Object_Method
{
Ecore_DBus_Object *object;
char *interface;
char *name;
Ecore_DBus_Method_Call_Cb func;
void *data;
};
struct _Ecore_DBus_Object_Registry
{
Ecore_Hash *objects;
};
typedef enum _Ecore_DBus_Message_Type
{
ECORE_DBUS_MESSAGE_TYPE_INVALID,
ECORE_DBUS_MESSAGE_TYPE_METHOD_CALL,
ECORE_DBUS_MESSAGE_TYPE_METHOD_RETURN,
ECORE_DBUS_MESSAGE_TYPE_ERROR,
ECORE_DBUS_MESSAGE_TYPE_SIGNAL
} Ecore_DBus_Message_Type;
typedef enum _Ecore_DBus_Message_Flag
{
ECORE_DBUS_MESSAGE_FLAG_NO_REPLY_EXPECTED,
ECORE_DBUS_MESSAGE_FLAG_NO_AUTO_START
} Ecore_DBus_Message_Flag;
typedef enum _Ecore_DBus_Data_Type
{
ECORE_DBUS_DATA_TYPE_INVALID = ((int) '\0'),
ECORE_DBUS_DATA_TYPE_BYTE = ((int) 'y'),
ECORE_DBUS_DATA_TYPE_BOOLEAN = ((int) 'b'), /* 0,1 */
ECORE_DBUS_DATA_TYPE_INT16 = ((int) 'n'),
ECORE_DBUS_DATA_TYPE_UINT16 = ((int) 'q'),
ECORE_DBUS_DATA_TYPE_INT32 = ((int) 'i'),
ECORE_DBUS_DATA_TYPE_UINT32 = ((int) 'u'),
ECORE_DBUS_DATA_TYPE_INT64 = ((int) 'x'),
ECORE_DBUS_DATA_TYPE_UINT64 = ((int) 't'),
ECORE_DBUS_DATA_TYPE_DOUBLE = ((int) 'd'),
ECORE_DBUS_DATA_TYPE_STRING = ((int) 's'),
ECORE_DBUS_DATA_TYPE_OBJECT_PATH = ((int) 'o'),
ECORE_DBUS_DATA_TYPE_SIGNATURE = ((int) 'g'),
ECORE_DBUS_DATA_TYPE_ARRAY = ((int) 'a'),
ECORE_DBUS_DATA_TYPE_VARIANT = ((int) 'v'),
ECORE_DBUS_DATA_TYPE_STRUCT = ((int) 'r'),
ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN = ((int) '('),
ECORE_DBUS_DATA_TYPE_STRUCT_END = ((int) ')'),
ECORE_DBUS_DATA_TYPE_DICT_ENTRY = ((int) 'e'),
ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN = ((int) '{'),
ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END = ((int) '}'),
} Ecore_DBus_Data_Type;
struct _Ecore_DBus_Event_Server_Add
{
Ecore_DBus_Server *server;
};
struct _Ecore_DBus_Event_Server_Del
{
Ecore_DBus_Server *server;
};
struct _Ecore_DBus_Event_Server_Data
{
Ecore_DBus_Server *server;
Ecore_DBus_Message_Type type;
Ecore_DBus_Message *message;
struct {
const char *path;
const char *interface;
const char *member;
const char *error_name;
unsigned int reply_serial;
const char *destination;
const char *sender;
const char *signature;
} header;
Ecore_DBus_Message_Arg *args;
};
struct _Ecore_DBus_Message_Arg
{
Ecore_DBus_Data_Type type;
void *value;
};
typedef enum _Ecore_DBus_Message_Header_Field
{
ECORE_DBUS_HEADER_FIELD_INVALID,
ECORE_DBUS_HEADER_FIELD_PATH,
ECORE_DBUS_HEADER_FIELD_INTERFACE,
ECORE_DBUS_HEADER_FIELD_MEMBER,
ECORE_DBUS_HEADER_FIELD_ERROR_NAME,
ECORE_DBUS_HEADER_FIELD_REPLY_SERIAL,
ECORE_DBUS_HEADER_FIELD_DESTINATION,
ECORE_DBUS_HEADER_FIELD_SENDER,
ECORE_DBUS_HEADER_FIELD_SIGNATURE
} Ecore_DBus_Message_Header_Field;
struct _Ecore_DBus_Address
{
char *transport;
Ecore_List *keys;
Ecore_List *vals;
};
EAPI extern int ECORE_DBUS_EVENT_SERVER_ADD;
EAPI extern int ECORE_DBUS_EVENT_SERVER_DEL;
EAPI extern int ECORE_DBUS_EVENT_METHOD_CALL;
EAPI extern int ECORE_DBUS_EVENT_SIGNAL;
/* callback */
typedef void (*Ecore_DBus_Method_Return_Cb)(void *data, Ecore_DBus_Method_Return *reply);
typedef void (*Ecore_DBus_Error_Cb)(void *data, const char *error);
/* init */
EAPI int ecore_dbus_init(void);
EAPI int ecore_dbus_shutdown(void);
/* connection */
EAPI Ecore_DBus_Server *ecore_dbus_server_system_connect(const void *data);
EAPI Ecore_DBus_Server *ecore_dbus_server_session_connect(const void *data);
EAPI Ecore_DBus_Server *ecore_dbus_server_starter_connect(const void *data);
EAPI Ecore_DBus_Server *ecore_dbus_server_connect(Ecore_Con_Type type, const char *name, int port, const void *data);
EAPI void ecore_dbus_server_del(Ecore_DBus_Server *svr);
/* message */
EAPI int ecore_dbus_server_send(Ecore_DBus_Server *svr, const char *command, int length);
EAPI unsigned int ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr,
const char *path, const char *interface,
const char *method, const char *destination,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
const void *data,
const char *signature, ...);
EAPI unsigned int ecore_dbus_message_new_method_return(Ecore_DBus_Server *svr,
int reply_serial, const char *destination,
const char *signature, ...);
EAPI unsigned int ecore_dbus_message_new_error(Ecore_DBus_Server *svr,
const char *error_name,
int reply_serial, const char *destination,
const char *error_message);
EAPI unsigned int ecore_dbus_message_new_signal(Ecore_DBus_Server *svr,
const char *path,
const char *interface, const char *signal_name,
const char *destination, const void *data,
const char *signature, ...);
EAPI void ecore_dbus_message_del(Ecore_DBus_Message *msg);
EAPI void ecore_dbus_message_print(Ecore_DBus_Message *msg);
EAPI void *ecore_dbus_message_header_field_get(Ecore_DBus_Message *msg, Ecore_DBus_Message_Header_Field field);
EAPI void *ecore_dbus_message_body_field_get(Ecore_DBus_Message *msg, unsigned int pos);
EAPI int ecore_dbus_message_serial_get(Ecore_DBus_Message *m);
/* methods */
EAPI int ecore_dbus_method_hello(Ecore_DBus_Server *svr, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_list_names(Ecore_DBus_Server *svr, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_name_has_owner(Ecore_DBus_Server *svr, char *name, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_start_service_by_name(Ecore_DBus_Server *svr, char *name, unsigned int flags, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_get_name_owner(Ecore_DBus_Server *svr, char *name, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_get_connection_unix_user(Ecore_DBus_Server *svr, char *connection, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_add_match(Ecore_DBus_Server *svr, char *match, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_remove_match(Ecore_DBus_Server *svr, char *match, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_request_name(Ecore_DBus_Server *svr, char *name, int flags, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
EAPI int ecore_dbus_method_release_name(Ecore_DBus_Server *svr, char *name, Ecore_DBus_Method_Return_Cb method_cb, Ecore_DBus_Error_Cb, void *data);
/* addresses */
EAPI Ecore_DBus_Address *ecore_dbus_address_new(void);
EAPI void ecore_dbus_address_free(Ecore_DBus_Address *address);
EAPI Ecore_List *ecore_dbus_address_parse(const char *address);
EAPI char *ecore_dbus_address_string(Ecore_DBus_Address *address);
EAPI const char *ecore_dbus_address_value_get(Ecore_DBus_Address *address, const char *key);
EAPI void ecore_dbus_print_address_list(Ecore_List *addresses);
EAPI Ecore_DBus_Server *ecore_dbus_address_list_connect(Ecore_List *addrs, const void *data);
EAPI Ecore_DBus_Server *ecore_dbus_address_connect(Ecore_DBus_Address *addr, const void *data);
/* object */
EAPI Ecore_DBus_Object *ecore_dbus_object_add(Ecore_DBus_Server *svr, const char *path);
EAPI void ecore_dbus_object_free(Ecore_DBus_Object *obj);
EAPI Ecore_DBus_Object_Method *ecore_dbus_object_method_add(Ecore_DBus_Object *obj, const char *interface, const char *method_name, Ecore_DBus_Method_Call_Cb func, void *data);
EAPI void ecore_dbus_object_method_remove(Ecore_DBus_Object *obj, Ecore_DBus_Object_Method *method);
EAPI void ecore_dbus_object_method_free(Ecore_DBus_Object_Method *method);
#ifdef __cplusplus
}
#endif
#endif

46
legacy/ecore/src/lib/ecore_dbus/Makefile.am
View File

@ -1,46 +0,0 @@
MAINTAINERCLEANFILES = Makefile.in
INCLUDES = \
-I$(top_builddir)/src/lib/ecore \
-I$(top_builddir)/src/lib/ecore_con \
-I$(top_builddir)/src/lib/ecore_dbus \
-I$(top_srcdir)/src/lib/ecore \
-I$(top_srcdir)/src/lib/ecore_con \
-I$(top_srcdir)/src/lib/ecore_dbus \
@SSL_CFLAGS@
libecore_dbus_la_LDFLAGS = -version-info 1:0:0 \
-L$(top_builddir)/src/lib/ecore/.libs \
-L$(top_builddir)/src/lib/ecore_con/.libs
if BUILD_ECORE_DBUS
lib_LTLIBRARIES = libecore_dbus.la
include_HEADERS = \
Ecore_DBus.h
libecore_dbus_la_SOURCES = \
ecore_dbus.c \
ecore_dbus_message.c \
ecore_dbus_marshal.c \
ecore_dbus_unmarshal.c \
ecore_dbus_methods.c \
ecore_dbus_utils.c \
ecore_dbus_address.c \
ecore_dbus_object.c \
ecore_dbus_private.h
libecore_dbus_la_LIBADD = \
$(top_builddir)/src/lib/ecore/libecore.la \
$(top_builddir)/src/lib/ecore_con/libecore_con.la \
@SSL_LIBS@
libecore_dbus_la_DEPENDENCIES = \
$(top_builddir)/src/lib/ecore/libecore.la \
$(top_builddir)/src/lib/ecore_con/libecore_con.la
endif
EXTRA_DIST = \
ecore_dbus.c \
ecore_dbus_private.h

605
legacy/ecore/src/lib/ecore_dbus/ecore_dbus.c
View File

@ -1,605 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "config.h"
#include "Ecore.h"
#include "ecore_private.h"
#include "Ecore_Con.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
/********************************************************************************/
/* About */
/********************************************************************************/
/* Author: Jorge Luis Zapata */
/* Author: Brian Mattern (rephorm) */
/* Author: Sebastian Dransfeld */
/* Version: 0.3.0 */
/********************************************************************************/
/* Todo */
/********************************************************************************/
/* free allocated data */
/* make other authentication mechanisms besides external */
/********************************************************************************/
/* Changelog */
/********************************************************************************/
/* 0.0 usable interface */
/* 0.1 change dbus spec version (0.11): */
/* different header format */
/* new type signature */
/* header length = 8 byte multiple */
/* paddings value must be null */
/* body need not to end in a 8 byte boundary */
/* new data type: variant,signature,dict */
/* ecore_oldlist cant join two lists so is difficult to handle compound */
/* data types (variant,struct,dict,array) in a stack way */
/* 0.2 change again the spec version (0.8) */
/* i realized that the first version was correct, when i read the spec */
/* for ecore_dbus 0.1 i was reading a previous version :( */
/* put again the data type byte in each marshaled data */
/* */
/* 29-03-05 */
/* 0.2.1 some segfault fixes, new tests */
/* 0.3.0 add ability to send signals, receive method class and respond to them */
/* add address parsing and functions to connect to standard busses */
/* change API of ecore_dbus_message_new_method_call() */
/* global variables */
EAPI int ECORE_DBUS_EVENT_SERVER_ADD = 0;
EAPI int ECORE_DBUS_EVENT_SERVER_DEL = 0;
EAPI int ECORE_DBUS_EVENT_SIGNAL = 0;
EAPI int ECORE_DBUS_EVENT_METHOD_CALL = 0;
/* private function declaration */
/* helper functions */
static char *_ecore_dbus_getuid(void);
static char *_ecore_dbus_hex_encode(char *src_str);
/* auth functions */
unsigned char *_ecore_dbus_auth_external(void *data);
/* con functions */
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);
static void _ecore_dbus_event_server_del_free(void *data, void *ev);
static void _ecore_dbus_event_server_data_free(void *data, void *ev);
static Ecore_DBus_Event_Server_Data *_ecore_dbus_event_create(Ecore_DBus_Server *svr, Ecore_DBus_Message *msg);
static void _ecore_dbus_method_hello_cb(void *data, Ecore_DBus_Method_Return *reply);
static void _ecore_dbus_method_error_cb(void *data, const char *error);
/* local variables */
static const Ecore_DBus_Auth auths[] = {
{"EXTERNAL", 1, {_ecore_dbus_auth_external, NULL, NULL, NULL, NULL}},
{"MAGIC_COOKIE", 0, {NULL, NULL, NULL, NULL, NULL}},
{"DBUS_COOKIE_SHA1", 0, {NULL, NULL, NULL, NULL, NULL}},
{"KERBEROS_V4", 0, {NULL, NULL, NULL, NULL, NULL}},
{"SKEY", 0, {NULL, NULL, NULL, NULL, NULL}},
};
static int init_count = 0;
static Ecore_List2 *servers = NULL;
static Ecore_Event_Handler *handler[3];
int words_bigendian = -1;
/* public functions */
EAPI int
ecore_dbus_init(void)
{
int i = 0;
if (++init_count != 1) return init_count;
if (words_bigendian == -1)
{
unsigned long int v;
v = htonl(0x12345678);
if (v == 0x12345678) words_bigendian = 1;
else words_bigendian = 0;
}
ecore_con_init();
ECORE_DBUS_EVENT_SERVER_ADD = ecore_event_type_new();
ECORE_DBUS_EVENT_SERVER_DEL = ecore_event_type_new();
ECORE_DBUS_EVENT_SIGNAL = ecore_event_type_new();
ECORE_DBUS_EVENT_METHOD_CALL = ecore_event_type_new();
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
_ecore_dbus_event_server_add, NULL);
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
_ecore_dbus_event_server_del, NULL);
handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
_ecore_dbus_event_server_data, NULL);
ecore_dbus_objects_init();
return init_count;
}
EAPI int
ecore_dbus_shutdown(void)
{
int i = 0;
if (--init_count != 0) return init_count;
ecore_dbus_objects_shutdown();
/* FIXME: Delete servers */
for (i = 0; i < 3; i++)
ecore_event_handler_del(handler[i]);
ecore_con_shutdown();
return init_count;
}
/**
* Connect to the system bus.
*/
EAPI Ecore_DBus_Server *
ecore_dbus_server_system_connect(const void *data)
{
Ecore_List *addrs;
Ecore_DBus_Server *svr;
char *bus_env;
/* get the system bus address from the environment */
bus_env = getenv("DBUS_SYSTEM_BUS_ADDRESS");
if (bus_env)
{
addrs = ecore_dbus_address_parse(bus_env);
if (addrs)
{
svr = ecore_dbus_address_list_connect(addrs, data);
ecore_list_destroy(addrs);
if (svr) return svr;
}
}
/* if we haven't returned already, try the default location */
return ecore_dbus_server_connect(ECORE_CON_LOCAL_SYSTEM, "/var/run/dbus/system_bus_socket", -1, data);
}
/**
* Connect to the session bus.
*/
EAPI Ecore_DBus_Server *
ecore_dbus_server_session_connect(const void *data)
{
Ecore_List *addrs;
Ecore_DBus_Server *svr;
char *bus_env;
/* get the session bus address from the environment */
bus_env = getenv("DBUS_SESSION_BUS_ADDRESS");
if (bus_env)
{
addrs = ecore_dbus_address_parse(bus_env);
if (addrs)
{
svr = ecore_dbus_address_list_connect(addrs, data);
ecore_list_destroy(addrs);
if (svr) return svr;
}
}
/*
* XXX try getting address from _DBUS_SESSION_BUS_ADDRESS property (STRING) set
* on the root window
*/
return NULL;
}
EAPI Ecore_DBus_Server *
ecore_dbus_server_starter_connect(const void *data)
{
Ecore_List *addrs;
Ecore_DBus_Server *svr;
char *bus_env;
/* get the session bus address from the environment */
bus_env = getenv("DBUS_STARTER_ADDRESS");
if (bus_env)
{
addrs = ecore_dbus_address_parse(bus_env);
if (addrs)
{
svr = ecore_dbus_address_list_connect(addrs, data);
ecore_list_destroy(addrs);
if (svr) return svr;
}
}
return NULL;
}
EAPI Ecore_DBus_Server *
ecore_dbus_server_connect(Ecore_Con_Type con_type, const char *name, int port,
const void *data __UNUSED__)
{
/* XXX data isn't used! */
Ecore_DBus_Server *svr;
svr = calloc(1, sizeof(Ecore_DBus_Server));
if (!svr) return NULL;
svr->server =
ecore_con_server_connect(con_type, name, port, svr);
if (!svr->server)
{
fprintf(stderr, "Ecore_DBus Error: Couldn't connect to server\n");
free(svr);
return NULL;
}
svr->authenticated = 0;
svr->cnt_msg = 0;
svr->auth_type = -1;
svr->auth_type_transaction = 0;
svr->messages = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
ecore_hash_set_free_value(svr->messages, ECORE_FREE_CB(_ecore_dbus_message_free));
svr->objects = ecore_hash_new(ecore_str_hash, ecore_str_compare);
ecore_hash_set_free_key(svr->objects, free);
ecore_hash_set_free_value(svr->objects, ECORE_FREE_CB(ecore_dbus_object_free));
servers = _ecore_list2_append(servers, svr);
return svr;
}
EAPI void
ecore_dbus_server_del(Ecore_DBus_Server *svr)
{
if (svr->server) ecore_con_server_del(svr->server);
servers = _ecore_list2_remove(servers, svr);
if (svr->unique_name) free(svr->unique_name);
ecore_hash_destroy(svr->messages);
ecore_hash_destroy(svr->objects);
free(svr);
}
EAPI int
ecore_dbus_server_send(Ecore_DBus_Server *svr, const char *command, int length)
{
int ret;
ret = ecore_con_server_send(svr->server, command, length);
printf("[ecore_dbus] ecore_dbus_server: %p ecore_con_server: %p sent %d of %d bytes\n",
svr, svr->server, ret, length);
return ret;
}
/* helper functions */
static char *
_ecore_dbus_getuid(void)
{
/* this calculation is from comp.lang.c faq */
#define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1) /* +1 for '-' */
int len;
char *uid;
char *tmp;
tmp = (char *)malloc(MAX_LONG_LEN);
len = snprintf(tmp, MAX_LONG_LEN, "%ld", (long) getuid());
uid = (char *)malloc(len + 1);
uid = memcpy(uid, tmp, len);
uid[len] = '\0';
free(tmp);
return uid;
}
/* encodes a string into a string of hex values */
/* each byte is two hex digits */
static char *
_ecore_dbus_hex_encode(char *src_str)
{
const char hexdigits[16] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'
};
char *enc_str;
char *p;
char *end;
int len;
int i = 0;
len = strlen(src_str);
p = src_str;
end = p + len;
enc_str = malloc(2 * len + 1);
while (p != end)
{
enc_str[i] = hexdigits[(*p >> 4)];
i++;
enc_str[i] = hexdigits[(*p & 0x0f)];
i++;
p++;
}
enc_str[i] = '\0';
return enc_str;
}
/* auth functions */
unsigned char *
_ecore_dbus_auth_external(void *data __UNUSED__)
{
char *uid, *enc_uid, *msg;
uid = _ecore_dbus_getuid();
enc_uid = _ecore_dbus_hex_encode(uid);
free(uid);
msg = malloc(strlen(enc_uid) + 17);
sprintf(msg, "AUTH EXTERNAL %s\r\n", enc_uid);
free(enc_uid);
return (unsigned char *)msg;
}
/* con functions */
static int
_ecore_dbus_event_server_add(void *data __UNUSED__, int ev_type __UNUSED__, void *ev)
{
Ecore_Con_Event_Server_Add *e;
Ecore_DBus_Server *svr;
e = ev;
svr = ecore_con_server_data_get(e->server);
if (!svr) return 1;
if (!_ecore_list2_find(servers, svr)) return 1;
ecore_dbus_server_send(svr, "\0", 1);
ecore_dbus_server_send(svr, "AUTH\r\n", 6);
printf("[ecore_dbus] begining auth process\n");
return 0;
}
static int
_ecore_dbus_event_server_del(void *udata __UNUSED__, int ev_type __UNUSED__, void *ev)
{
Ecore_Con_Event_Server_Del *e;
Ecore_DBus_Server *svr;
Ecore_DBus_Event_Server_Del *e2;
e = ev;
svr = ecore_con_server_data_get(e->server);
if (!svr) return 1;
if (!_ecore_list2_find(servers, svr)) return 1;
e2 = calloc(1, sizeof(Ecore_DBus_Event_Server_Del));
if (e2)
{
svr->server = NULL;
e2->server = svr;
ecore_event_add(ECORE_DBUS_EVENT_SERVER_DEL, e2, _ecore_dbus_event_server_del_free, NULL);
}
return 0;
}
static int
_ecore_dbus_event_server_data(void *udata __UNUSED__, int ev_type __UNUSED__, void *ev)
{
Ecore_Con_Event_Server_Data *e;
Ecore_DBus_Server *svr;
e = ev;
svr = ecore_con_server_data_get(e->server);
if (!svr) return 1;
if (!_ecore_list2_find(servers, svr)) return 1;
if (!svr->authenticated)
{
/* authentication protocol */
const Ecore_DBus_Auth *auth;
Ecore_DBus_Auth_Transaction trans;
if (!strncmp(e->data, "OK", 2))
{
printf("[ecore_dbus] auth type %s successful\n", auths[svr->auth_type].name);
ecore_dbus_server_send(svr, "BEGIN\r\n", 7);
svr->authenticated = 1;
/* Register on the bus */
ecore_dbus_method_hello(svr, _ecore_dbus_method_hello_cb, _ecore_dbus_method_error_cb, svr);
}
else if (!strncmp(e->data, "DATA", 4))
{
printf("[ecore_dbus] requiring data (unavailable)\n");
}
else if (!strncmp(e->data, "ERROR", 5))
{
printf("[ecore_dbus] auth process error\n");
}
else if (!strncmp(e->data, "REJECTED", 8))
{
unsigned char *msg;
if (svr->auth_type >= 0)
printf("[ecore_dbus] auth type %s rejected\n", auths[svr->auth_type].name);
svr->auth_type++;
auth = &auths[svr->auth_type];
trans = auth->transactions[0];
printf("[ecore_dbus] auth type %s started\n", auth->name);
msg = trans(NULL);
ecore_dbus_server_send(svr, (char *)msg, strlen((char *)msg));
free(msg);
}
}
else
{
/* message protocol */
Ecore_DBus_Message *msg;
unsigned int offset = 0;
printf("[ecore_dbus] received server data, %d bytes\n", e->size);
while (e->size)
{
Ecore_DBus_Event_Server_Data *ev2;
msg = _ecore_dbus_message_unmarshal(svr, (unsigned char *)(e->data) + offset, e->size);
if (!msg) break;
offset += msg->length;
e->size -= msg->length;
printf("[ecore_dbus] dbus message length %u bytes, still %d\n",
msg->length, e->size);
//ecore_dbus_message_print(msg);
/* Trap known messages */
ev2 = _ecore_dbus_event_create(svr, msg);
if (!ev2) break;
if (msg->type == ECORE_DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
Ecore_DBus_Message *sent;
sent = ecore_hash_remove(svr->messages, (void *)(ev2->header.reply_serial));
if ((sent) && (sent->cb.method_return))
{
sent->cb.method_return(sent->cb.data, ev2);
}
else
{
printf("[ecore_dbus] Reply without reply serial!\n");
}
if (sent) _ecore_dbus_message_free(sent);
_ecore_dbus_event_server_data_free(NULL, ev2);
}
else if (msg->type == ECORE_DBUS_MESSAGE_TYPE_ERROR)
{
Ecore_DBus_Message *sent;
sent = ecore_hash_remove(svr->messages, (void *)(ev2->header.reply_serial));
if ((sent) && (sent->cb.error))
{
char *error = NULL;
if ((ev2->args) && (ev2->args[0].type == ECORE_DBUS_DATA_TYPE_STRING))
error = ev2->args[0].value;
sent->cb.error(sent->cb.data, error);
}
else
{
printf("[ecore_dbus] Error without reply serial!\n");
}
if (sent) _ecore_dbus_message_free(sent);
_ecore_dbus_event_server_data_free(NULL, ev2);
}
else if (msg->type == ECORE_DBUS_MESSAGE_TYPE_SIGNAL)
{
ecore_event_add(ECORE_DBUS_EVENT_SIGNAL, ev2,
_ecore_dbus_event_server_data_free, NULL);
}
else if (msg->type == ECORE_DBUS_MESSAGE_TYPE_METHOD_CALL)
{
ecore_event_add(ECORE_DBUS_EVENT_METHOD_CALL, ev2,
_ecore_dbus_event_server_data_free, NULL);
}
else
{
printf("Ecore_DBus: Unknown return type %d\n", msg->type);
_ecore_dbus_event_server_data_free(NULL, ev2);
}
}
}
return 0;
}
static void
_ecore_dbus_event_server_del_free(void *data __UNUSED__, void *ev)
{
Ecore_DBus_Event_Server_Del *event;
event = ev;
ecore_dbus_server_del(event->server);
free(ev);
}
static void
_ecore_dbus_event_server_data_free(void *data __UNUSED__, void *ev)
{
Ecore_DBus_Event_Server_Data *event;
event = ev;
_ecore_dbus_message_free(event->message);
if (event->args) free(event->args);
free(ev);
}
static Ecore_DBus_Event_Server_Data *
_ecore_dbus_event_create(Ecore_DBus_Server *svr, Ecore_DBus_Message *msg)
{
Ecore_DBus_Event_Server_Data *ev;
unsigned int *serial;
ev = calloc(1, sizeof(Ecore_DBus_Event_Server_Data));
if (!ev) return NULL;
ev->server = svr;
ev->type = msg->type;
ev->message = msg;
ev->header.path = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_PATH);
ev->header.interface = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_INTERFACE);
ev->header.member = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_MEMBER);
ev->header.error_name = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_ERROR_NAME);
serial = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_REPLY_SERIAL);
if (serial)
ev->header.reply_serial = *serial;
ev->header.destination = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_DESTINATION);
ev->header.sender = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_SENDER);
ev->header.signature = ecore_dbus_message_header_field_get(msg, ECORE_DBUS_HEADER_FIELD_SIGNATURE);
if (!ecore_list_is_empty(msg->fields))
{
Ecore_DBus_Message_Field *f;
int i = 0;
ev->args = malloc(ecore_list_nodes(msg->fields) * sizeof(Ecore_DBus_Message_Arg));
ecore_list_goto_first(msg->fields);
while ((f = ecore_list_next(msg->fields)))
{
ev->args[i].type = f->type;
ev->args[i].value = _ecore_dbus_message_field_value_get(f);
i++;
}
}
return ev;
}
static void
_ecore_dbus_method_hello_cb(void *data, Ecore_DBus_Method_Return *reply)
{
Ecore_DBus_Event_Server_Add *svr_add;
Ecore_DBus_Server *svr;
char *name;
svr = data;
name = reply->args[0].value;
printf("Got unique name: %s\n", name);
if (svr->unique_name)
{
printf("Ecore_DBus: Already said hello %s - %s\n",
svr->unique_name, name);
free(svr->unique_name);
}
svr->unique_name = strdup(name);
svr_add = malloc(sizeof(Ecore_DBus_Event_Server_Add));
svr_add->server = svr;
ecore_event_add(ECORE_DBUS_EVENT_SERVER_ADD, svr_add, NULL, NULL);
}
static void
_ecore_dbus_method_error_cb(void *data, const char *error)
{
Ecore_DBus_Event_Server_Del *ev;
Ecore_DBus_Server *svr;
svr = data;
printf("Ecore_DBus: error %s\n", error);
ev = malloc(sizeof(Ecore_DBus_Event_Server_Del));
if (!ev) return;
ev->server = svr;
ecore_event_add(ECORE_DBUS_EVENT_SERVER_DEL, ev, _ecore_dbus_event_server_del_free, NULL);
}

361
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_address.c
View File

@ -1,361 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "config.h"
#include "ecore_private.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
static void _ecore_dbus_address_list_free_cb(void *data);
static int _ecore_dbus_address_value_char_optional_encode(char c);
static char * _ecore_dbus_address_value_decode(const char *value);
static char * _ecore_dbus_address_value_encode(const char *value);
static void
_ecore_dbus_address_list_free_cb(void *data)
{
if (data) free(data);
}
Ecore_DBus_Address *
ecore_dbus_address_new()
{
Ecore_DBus_Address *a;
a = calloc(1, sizeof(Ecore_DBus_Address));
if (!a) return NULL;
a->keys = ecore_list_new();
ecore_list_set_free_cb(a->keys, _ecore_dbus_address_list_free_cb);
a->vals = ecore_list_new();
ecore_list_set_free_cb(a->vals, _ecore_dbus_address_list_free_cb);
return a;
}
void
ecore_dbus_address_free(Ecore_DBus_Address *address)
{
if (!address) return;
ecore_list_destroy(address->keys);
ecore_list_destroy(address->vals);
if (address->transport) free(address->transport);
free(address);
}
/**
* Parse an address into an array of Ecore_DBus_Address structs
*/
Ecore_List *
ecore_dbus_address_parse(const char *address)
{
Ecore_List *alist = NULL;
Ecore_DBus_Address *a = NULL;
char *addcpy;
char *p;
addcpy = strdup(address);
p = addcpy;
char *start = NULL;
char *transport = p;
char *key = NULL;
char *val = NULL;
int error = 0;
alist = ecore_list_new();
ecore_list_set_free_cb(alist, ECORE_FREE_CB(ecore_dbus_address_free));
while(1)
{
if (!a)
{
start = p;
a = ecore_dbus_address_new();
if (!a) { error = 1; break; }
}
if (!*p || *p == ';' || *p == ',')
{
/* append value */
char sep = *p;
if (!val)
{
if (p != start) error = 1;
break;
}
*p = '\0';
ecore_list_append(a->vals, _ecore_dbus_address_value_decode(val));
val = NULL;
if (sep == ',')
{
key = p + 1;
}
else
{
/* append address to list */
ecore_list_append(alist, a);
a = NULL;
if (!sep) break; /* end of string */
transport = p + 1;
}
}
else if (*p == '=')
{
/* append key */
if (!key) { error = 1; break; }
*p = '\0';
ecore_list_append(a->keys, strdup(key));
key = NULL;
val = p + 1;
}
else if (*p == ':')
{
/* append transport */
if (!transport) { error = 1; break; }
*p = '\0';
a->transport = strdup(transport);
transport = NULL;
key = p + 1;
}
p++;
}
if (error)
{
ecore_list_destroy(alist);
alist = NULL;
}
free(addcpy);
return alist;
}
const char *
ecore_dbus_address_value_get(Ecore_DBus_Address *address, const char *key)
{
int i;
char *s;
if (!key) return NULL;
ecore_list_goto_first(address->keys);
i = 0;
while((s = ecore_list_next(address->keys)))
{
if (!strcmp(key, s))
{
return ecore_list_goto_index(address->vals, i);
}
i++;
}
return NULL;
}
EAPI char *
ecore_dbus_address_string(Ecore_DBus_Address *address)
{
char buf[PATH_MAX];
char *key, *val;
int left = PATH_MAX - 1; /* space left in the buffer, leaving room for a final null */
if (!address) return NULL;
snprintf(buf, PATH_MAX, "%s:", address->transport);
left -= strlen(address->transport) + 1;
ecore_list_goto_first(address->keys);
ecore_list_goto_first(address->vals);
while ((key = ecore_list_next(address->keys)) && (val = ecore_list_next(address->vals)))
{
char *encval;
strncat(buf, key, left);
left -= strlen(key);
strncat(buf, "=", left);
left -= 1;
encval = _ecore_dbus_address_value_encode(val);
strncat(buf, encval, left);
left -= strlen(encval);
free(encval);
}
return strdup(buf);
}
/**
* Connect to the first successful server in a list of addresses.
*/
EAPI Ecore_DBus_Server *
ecore_dbus_address_list_connect(Ecore_List *addrs, const void *data)
{
Ecore_DBus_Address *addr;
ecore_list_goto_first(addrs);
/* try each listed address in turn */
while ((addr = ecore_list_next(addrs)))
{
Ecore_DBus_Server *svr;
svr = ecore_dbus_address_connect(addr, data);
if (svr) return svr;
}
return NULL;
}
/**
* Connect to a server by its Ecore_DBus_Address
*/
EAPI Ecore_DBus_Server *
ecore_dbus_address_connect(Ecore_DBus_Address *addr, const void *data)
{
const char *name;
int type;
int port;
char *addr_string;
addr_string = ecore_dbus_address_string(addr);
printf("[ecore_dbus] connecting to address: %s\n", addr_string);
free(addr_string);
if (!strcmp(addr->transport, "unix"))
{
type = ECORE_CON_LOCAL_SYSTEM;
name = ecore_dbus_address_value_get(addr, "path");
if (!name)
{
name = ecore_dbus_address_value_get(addr, "abstract");
type = ECORE_CON_LOCAL_ABSTRACT;
}
if (!name) return NULL;
port = -1;
}
else if (!strcmp(addr->transport, "tcp"))
{
/* XXX implement (and verify transport name is actually 'tcp') */
return NULL;
}
else
{
return NULL;
}
return ecore_dbus_server_connect(type, name, port, data);
}
void
ecore_dbus_print_address_list(Ecore_List *addresses)
{
Ecore_DBus_Address *a;
ecore_list_goto_first(addresses);
while((a = ecore_list_next(addresses)))
{
char *k, *v;
printf("Transport: %s\n", a->transport);
ecore_list_goto_first(a->keys);
ecore_list_goto_first(a->vals);
k = ecore_list_next(a->keys);
v = ecore_list_next(a->vals);
while (k || v)
{
printf(" %s => %s\n", k, v);
k = ecore_list_next(a->keys);
v = ecore_list_next(a->vals);
}
}
}
static int
_ecore_dbus_address_value_char_optional_encode(char c)
{
/* addl optional chars (other than 0-9A-Za-z) */
static const char OPTIONAL_CHARS[] = {'_', '-', '/', '.', '\\'};
unsigned int i;
if (isascii(c) && (isalpha(c) || isdigit(c))) return 1;
for (i = 0; i < sizeof(OPTIONAL_CHARS); i++)
if (c == OPTIONAL_CHARS[i]) return 1;
return 0;
}
static char *
_ecore_dbus_address_value_encode(const char *value)
{
char *buf;
const char *p;
int i;
static const char hexdigits[16] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'
};
if (!value) return NULL;
buf = malloc(3 * strlen(value) + 1);
p = value;
i = 0;
while (*p)
{
if (_ecore_dbus_address_value_char_optional_encode(*p))
buf[i++] = *p;
else
{
buf[i++] = '%';
buf[i++] = hexdigits[(*p >> 4)];
buf[i++] = hexdigits[(*p & 0xf)];
}
p++;
}
buf[i] = '\0';
return buf;
}
static char *
_ecore_dbus_address_value_decode(const char *value)
{
char *buf;
const char *p;
int i;
buf = malloc(strlen(value) + 1);
*buf = '\0';
p = value;
i = 0;
while (*p)
{
if (*p == '%')
{
char c = 0;
int j;
for (j = 0; j < 2; j++)
{
p++;
c = c << 4;
if ('0' <= *p && *p <= '9')
c |= *p - '0';
else if ('A' <= *p && *p <= 'F')
c |= 10 + *p - 'A';
else if ('a' <= *p && *p <= 'f') /* a-f */
c |= 10 + *p - 'a';
}
buf[i++] = c;
}
else
buf[i++] = *p;
p++;
}
buf[i] = '\0';
return buf;
}

212
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_marshal.c
View File

@ -1,212 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "ecore_private.h"
#include "Ecore_Con.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
Ecore_DBus_Message_Field_Byte *
_ecore_dbus_message_marshal_byte(Ecore_DBus_Message *msg, unsigned char c)
{
Ecore_DBus_Message_Field_Byte *f;
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_UInt32 *
_ecore_dbus_message_marshal_uint32(Ecore_DBus_Message *msg, unsigned int i)
{
Ecore_DBus_Message_Field_UInt32 *f;
unsigned char *c;
_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_String *
_ecore_dbus_message_marshal_string(Ecore_DBus_Message *msg, char *str)
{
Ecore_DBus_Message_Field_String *f;
unsigned int str_len;
_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_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_Object_Path *
_ecore_dbus_message_marshal_object_path(Ecore_DBus_Message *msg, char *str)
{
Ecore_DBus_Message_Field_Object_Path *f;
unsigned int str_len;
_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_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_Signature *
_ecore_dbus_message_marshal_signature(Ecore_DBus_Message *msg, char *str)
{
Ecore_DBus_Message_Field_Signature *f;
unsigned int str_len;
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);
_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);
/* leave room for the array length value, gets filled in on array_end() */
_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(msg, _ecore_dbus_alignment_get(contained_type));
arr->start = msg->length;
return arr;
}
void
_ecore_dbus_message_marshal_array_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Array *arr)
{
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_Array *
_ecore_dbus_message_marshal_array(Ecore_DBus_Message *msg, const char *contained_type, Ecore_List *data)
{
Ecore_DBus_Message_Field_Array *arr;
void *el;
printf("[ecore_dbus] marshal array %c\n", *contained_type);
arr = _ecore_dbus_message_marshal_array_begin(msg, *contained_type);
ecore_list_goto_first(data);
while ((el = ecore_list_next(data)))
_ecore_dbus_message_marshal(msg, contained_type, el);
_ecore_dbus_message_marshal_array_end(msg, arr);
return arr;
}
Ecore_DBus_Message_Field_Struct *
_ecore_dbus_message_marshal_struct_begin(Ecore_DBus_Message *msg)
{
Ecore_DBus_Message_Field_Struct *s;
_ecore_dbus_message_padding(msg, 8);
s = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_STRUCT);
ecore_list_prepend(msg->recurse, s);
return s;
}
void
_ecore_dbus_message_marshal_struct_end(Ecore_DBus_Message *msg, Ecore_DBus_Message_Field_Struct *s __UNUSED__)
{
ecore_list_remove_first(msg->recurse);
}
Ecore_DBus_Message_Field_Variant *
_ecore_dbus_message_marshal_variant(Ecore_DBus_Message *msg, Ecore_DBus_Data_Type type, const 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);
_ecore_dbus_message_append_byte(msg, '\0');
f->value = _ecore_dbus_message_marshal(msg, (char *)&type, data);
ecore_list_remove_first(msg->recurse);
return f;
}
Ecore_DBus_Message_Field *
_ecore_dbus_message_marshal(Ecore_DBus_Message *msg, const char *type, const void *data)
{
switch (*type)
{
case ECORE_DBUS_DATA_TYPE_UINT32:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_uint32(msg, *(unsigned int *)data);
case ECORE_DBUS_DATA_TYPE_STRING:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_string(msg, (char *)data);
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_object_path(msg, (char *)data);
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_signature(msg, (char *)data);
case ECORE_DBUS_DATA_TYPE_BYTE:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_byte(msg, *(char *)data);
case ECORE_DBUS_DATA_TYPE_ARRAY:
return (Ecore_DBus_Message_Field *)_ecore_dbus_message_marshal_array(msg, type + 1, (Ecore_List *)data); // we need to let the caller know how many fields were marshalled (e.g. how far to skip ahead in the type list)
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_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:
case ECORE_DBUS_DATA_TYPE_INVALID:
printf("[ecore_dbus] unhandled data type %c\n", *type);
return NULL;
default:
printf("[ecore_dbus] unknown data type %c\n", *type);
return NULL;
}
}

725
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_message.c
View File

@ -1,725 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include <stdarg.h>
#include "ecore_private.h"
#include "Ecore_Con.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
/* message helpers */
static Ecore_DBus_Message *_ecore_dbus_message_create(Ecore_DBus_Server *svr,
int type, int flags, const char *path, const char *interface,
const char *member, const char *error_name, int reply_serial,
const char *destination, const char *signature, va_list args);
static void _ecore_dbus_message_header(Ecore_DBus_Message *msg, int type,
int flags, const char *path, const char *interface,
const char *member, const char *error_name, int reply_serial,
const char *destination, const char *format);
static void _ecore_dbus_message_body(Ecore_DBus_Message *msg,
const char *signature, va_list args);
static unsigned int _ecore_dbus_message_new_error(Ecore_DBus_Server *svr, const char *error_name,
int reply_serial, const char *destination,
const char *signature, ...);
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);
/*
* Message types and allowed fields (* indicates required field):
*
* METHOD_CALL
* *path
* interface
* member
* destination
* signature
*
* METHOD_RETURN
* member
* *reply_serial
* destination
* signature
*
* ERROR
* *error_name
* *reply_serial
* destination
* signature
*
* SIGNAL
* *path
* *interface
* *member
* destination
* signature
*
*/
EAPI unsigned int
ecore_dbus_message_new_method_return(Ecore_DBus_Server *svr, int reply_serial,
const char *destination, const char *signature, ...)
{
va_list args;
Ecore_DBus_Message *msg;
va_start(args, signature);
msg = _ecore_dbus_message_create(svr, ECORE_DBUS_MESSAGE_TYPE_METHOD_RETURN, 0, NULL, NULL, NULL, NULL, reply_serial, destination, signature, args);
va_end(args);
ecore_dbus_server_send(svr, (char *)msg->buffer, msg->length);
ecore_hash_set(svr->messages, (void *)msg->serial, msg);
return msg->serial;
}
/* errors either have a single param, the error message, or no params. */
EAPI unsigned int
ecore_dbus_message_new_error(Ecore_DBus_Server *svr, const char *error_name,
int reply_serial, const char *destination,
const char *error_message)
{
const char *format = "";
if (error_message) format = "s";
return _ecore_dbus_message_new_error(svr, error_name, reply_serial, destination, format, error_message);
}
static unsigned int
_ecore_dbus_message_new_error(Ecore_DBus_Server *svr, const char *error_name,
int reply_serial, const char *destination,
const char *signature, ...)
{
va_list args;
Ecore_DBus_Message *msg;
va_start(args, signature);
msg = _ecore_dbus_message_create(svr, ECORE_DBUS_MESSAGE_TYPE_ERROR, 0, NULL, NULL, NULL, error_name, reply_serial, destination, signature, args);
va_end(args);
ecore_dbus_server_send(svr, (char *)msg->buffer, msg->length);
ecore_hash_set(svr->messages, (void *)msg->serial, msg);
return msg->serial;
}
EAPI unsigned int
ecore_dbus_message_new_signal(Ecore_DBus_Server *svr, const char *path,
const char *interface, const char *signal_name,
const char *destination, const void *data __UNUSED__,
const char *signature, ...)
{
va_list args;
Ecore_DBus_Message *msg;
va_start(args, signature);
msg = _ecore_dbus_message_create(svr, ECORE_DBUS_MESSAGE_TYPE_SIGNAL, 0, path, interface, signal_name, NULL, 0, destination, signature, args);
va_end(args);
ecore_dbus_server_send(svr, (char *)msg->buffer, msg->length);
ecore_hash_set(svr->messages, (void *)msg->serial, msg);
return msg->serial;
}
EAPI unsigned int
ecore_dbus_message_new_method_call(Ecore_DBus_Server *svr,
const char *path, const char *interface,
const char *method, const char *destination,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
const void *data,
const char *signature, ...)
{
va_list args;
Ecore_DBus_Message *msg;
int flags = 0;
if (!method) return 0;
if (!method_cb && !error_cb) flags |= ECORE_DBUS_MESSAGE_FLAG_NO_REPLY_EXPECTED;
va_start(args, signature);
msg = _ecore_dbus_message_create(svr, ECORE_DBUS_MESSAGE_TYPE_METHOD_CALL, flags, path, interface, method, NULL, 0, destination, signature, args);
va_end(args);
if (method_cb || error_cb)
{
msg->cb.method_return = method_cb;
msg->cb.error = error_cb;
msg->cb.data = (void*)data;
}
/* send message */
ecore_dbus_server_send(svr, (char *)msg->buffer, msg->length);
ecore_hash_set(svr->messages, (void *)msg->serial, msg);
return msg->serial;
}
static Ecore_DBus_Message *
_ecore_dbus_message_create(Ecore_DBus_Server *svr, int type, int flags, const char *path, const char *interface, const char *member, const char *error_name, int reply_serial, const char *destination, const char *signature, va_list args)
{
/* init message */
Ecore_DBus_Message *msg;
msg = _ecore_dbus_message_new(svr);
_ecore_dbus_message_header(msg, type, flags, path, interface, member, error_name, reply_serial, destination, signature);
_ecore_dbus_message_body(msg, signature, args);
/* show message */
//ecore_dbus_message_print(msg);
return msg;
}
static void
_ecore_dbus_message_body(Ecore_DBus_Message *msg, const char *signature, va_list args)
{
unsigned int body_start;
/* message body */
body_start = msg->length;
if (signature)
{
while (*signature)
{
Ecore_DBus_Data_Type type = *signature;
switch (type)
{
case ECORE_DBUS_DATA_TYPE_BYTE:
_ecore_dbus_message_marshal_byte(msg, va_arg(args, int));
break;
case ECORE_DBUS_DATA_TYPE_UINT32:
_ecore_dbus_message_marshal_uint32(msg, va_arg(args, unsigned int));
break;
case ECORE_DBUS_DATA_TYPE_STRING:
_ecore_dbus_message_marshal_string(msg, (char *)va_arg(args, char *));
break;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
_ecore_dbus_message_marshal_object_path(msg, (char *)va_arg(args, char *));
break;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
_ecore_dbus_message_marshal_signature(msg, (char *)va_arg(args, char *));
break;
case ECORE_DBUS_DATA_TYPE_ARRAY:
_ecore_dbus_message_marshal_array(msg, signature + 1, (Ecore_List *)va_arg(args, Ecore_List *));
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_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", *signature);
break;
}
signature += _ecore_dbus_complete_type_length_get(signature);
}
}
/* set body length */
*(unsigned int *)(msg->buffer + 4) = msg->length - body_start;
}
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);
switch (v->contained_type)
{
case ECORE_DBUS_DATA_TYPE_UINT32:
return &ECORE_DBUS_MESSAGE_FIELD_UINT32(v->value)->value;
case ECORE_DBUS_DATA_TYPE_STRING:
return ECORE_DBUS_MESSAGE_FIELD_STRING(v->value)->value;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
return ECORE_DBUS_MESSAGE_FIELD_OBJECT_PATH(v->value)->value;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
return ECORE_DBUS_MESSAGE_FIELD_SIGNATURE(v->value)->value;
default:
return NULL;
}
}
}
return NULL;
}
EAPI void *
ecore_dbus_message_body_field_get(Ecore_DBus_Message *m, unsigned int pos)
{
Ecore_DBus_Message_Field *f;
f = ecore_list_goto_index(m->fields, pos);
if (f)
return _ecore_dbus_message_field_value_get(f);
return NULL;
}
EAPI int
ecore_dbus_message_serial_get(Ecore_DBus_Message *m)
{
return m->serial;
}
/* 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->all = ecore_list_new();
ecore_list_set_free_cb(msg->all, _ecore_dbus_message_field_free);
msg->fields = ecore_list_new();
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 = NULL;
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();
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();
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();
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);
}
ecore_list_append(msg->all, f);
f->offset = msg->length;
f->buffer = msg->buffer + f->offset;
return f;
}
void
_ecore_dbus_message_free(Ecore_DBus_Message *msg)
{
ecore_list_destroy(msg->fields);
ecore_list_destroy(msg->recurse);
ecore_list_destroy(msg->all);
free(msg->buffer);
free(msg);
}
/* private functions */
/* header functions */
static void
_ecore_dbus_message_header(Ecore_DBus_Message *msg, int type, int flags,
const char *path, const char *interface, const char *member,
const char *error_name __UNUSED__, int reply_serial __UNUSED__,
const char *destination, const char *signature)
{
Ecore_DBus_Message_Field_Array *arr;
if (!msg) return;
/* endianness (1) */
if (words_bigendian)
msg->buffer[0] = msg->byte_order = 'B';
else
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 = flags;
/* 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;
/* header fields */
arr = _ecore_dbus_message_marshal_array_begin(msg, ECORE_DBUS_DATA_TYPE_STRUCT);
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 (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 (member)
{
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, member);
_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 (signature)
{
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, signature);
_ecore_dbus_message_marshal_struct_end(msg, s);
}
_ecore_dbus_message_marshal_array_end(msg, arr);
/* move the header fields to the header */
msg->header = ecore_list_remove_last(msg->fields);
/* pad to an 8 bit boundary */
_ecore_dbus_message_padding(msg, 8);
}
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_BOOLEAN:
printf
("[ecore_dbus] field BOOLEAN: value offset = %d value = %u\n",
f->offset, (unsigned int)*(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_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)
{
unsigned int i;
printf("[ecore_dbus] raw message:\n");
for (i = 0; i < msg->length; i++)
{
if ((i % 8) == 0)
printf("\n");
if ((msg->buffer[i] > 31) && (msg->buffer[i] < 128))
printf(" '%c' ", msg->buffer[i]);
else
printf("0x%02x ", msg->buffer[i]);
}
printf("\n");
printf("[ecore_dbus] end raw message\n");
}

164
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_methods.c
View File

@ -1,164 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
/* Standard dbus methods */
#include "ecore_private.h"
#include "Ecore_Con.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
EAPI int
ecore_dbus_method_hello(Ecore_DBus_Server *svr,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
if (svr->unique_name)
{
printf("Ecore_DBus: Already registered on the message bus.\n");
return 0;
}
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"Hello" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
NULL /*fmt*/);
}
EAPI int
ecore_dbus_method_list_names(Ecore_DBus_Server *svr,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"ListNames" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
NULL /*fmt*/);
}
EAPI int
ecore_dbus_method_name_has_owner(Ecore_DBus_Server *svr, char *name,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"NameHasOwner" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, name);
}
EAPI int
ecore_dbus_method_start_service_by_name(Ecore_DBus_Server *svr, char *name, unsigned int flags,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"StartServiceByName" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"su" /*fmt*/, name, flags);
}
EAPI int
ecore_dbus_method_get_name_owner(Ecore_DBus_Server *svr, char *name,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"GetNameOwner" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, name);
}
EAPI int
ecore_dbus_method_get_connection_unix_user(Ecore_DBus_Server *svr, char *connection,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"GetConnectionUnixUser" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, connection);
}
EAPI int
ecore_dbus_method_add_match(Ecore_DBus_Server *svr, char *match,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"AddMatch" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, match);
}
EAPI int
ecore_dbus_method_remove_match(Ecore_DBus_Server *svr, char *match,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"RemoveMatch" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, match);
}
EAPI int
ecore_dbus_method_request_name(Ecore_DBus_Server *svr, char *name, int flags,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"RequestName" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"su" /*fmt*/, name, flags);
}
EAPI int
ecore_dbus_method_release_name(Ecore_DBus_Server *svr, char *name,
Ecore_DBus_Method_Return_Cb method_cb,
Ecore_DBus_Error_Cb error_cb,
void *data)
{
return ecore_dbus_message_new_method_call(svr,
"/org/freedesktop/DBus" /*path*/,
"org.freedesktop.DBus" /*interface*/,
"RequestName" /*method*/,
"org.freedesktop.DBus" /*destination*/,
method_cb, error_cb, data,
"s" /*fmt*/, name);
}

184
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_object.c
View File

@ -1,184 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "Ecore.h"
#include "ecore_private.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
static int init_count = 0;
static Ecore_Event_Handler *handler = NULL;
static int _ecore_dbus_event_method_call_cb(void *udata, int evtype, void *ev);
static void _ecore_dbus_object_free(Ecore_DBus_Object *obj);
static void _ecore_dbus_object_method_free(Ecore_DBus_Object_Method *method);
int
ecore_dbus_objects_init()
{
if (++init_count != 1) return init_count;
handler = ecore_event_handler_add(ECORE_DBUS_EVENT_METHOD_CALL,
_ecore_dbus_event_method_call_cb, NULL);
return init_count;
}
void
ecore_dbus_objects_shutdown()
{
if (!init_count) return;
if (--init_count) return;
ecore_event_handler_del(handler);
}
static int
_ecore_dbus_event_method_call_cb(void *udata __UNUSED__, int evtype __UNUSED__, void *ev)
{
Ecore_DBus_Event_Server_Data *event;
Ecore_DBus_Object *obj;
Ecore_DBus_Object_Method *method;
event = ev;
if (!event->header.path || !event->header.member) return 1;
event = ev;
obj = ecore_hash_get(event->server->objects, event->header.path);
if (!obj)
{
Ecore_List *keys;
char *key;
printf("[ecore_dbus] object %s not found\n", event->header.path);
keys = ecore_hash_keys(event->server->objects);
printf("Keys\n----\n");
while ((key = ecore_list_next(keys)))
printf(" %s => %d\n", key, (int)ecore_hash_get(event->server->objects, key));
ecore_list_destroy(keys);
/* XXX send an 'unknown object' error */
return 0;
}
printf("[ecore_dbus] got object %s\n", event->header.path);
ecore_list_goto_first(obj->methods);
printf("[ecore_dbus] looking for method %s.%s\n", event->header.interface, event->header.member);
while((method = ecore_list_next(obj->methods)))
{
printf("[ecore_dbus] test against %s.%s\n", method->interface, method->name);
if (event->header.interface && event->header.interface[0])
{
if (!strcmp(event->header.interface, method->interface) &&
!strcmp(event->header.member, method->name)) break;
}
else
{
if (!strcmp(event->header.member, method->name)) break;
}
method = NULL;
}
if (method)
{
printf("[ecore_dbus] method found %s\n", event->header.member);
method->func(method->data, event);
return 0;
}
printf("[ecore_dbus] unknown method %s\n", event->header.member);
/* XXX auto-send an 'unknown method' error */
return 0;
}
/* objects */
EAPI Ecore_DBus_Object *
ecore_dbus_object_add(Ecore_DBus_Server *server, const char *path)
{
Ecore_DBus_Object *obj;
char *key;
obj = malloc(sizeof(Ecore_DBus_Object));
if (!obj) return NULL;
obj->server = server;
obj->path = strdup(path);
obj->methods = ecore_list_new();
ecore_list_set_free_cb(obj->methods, ECORE_FREE_CB(_ecore_dbus_object_method_free));
printf("[ecore_dbus] adding obj %d to key %s\n", (int)obj, path);
key = strdup(path);
ecore_hash_set(server->objects, key, obj);
return obj;
}
EAPI void
ecore_dbus_object_free(Ecore_DBus_Object *obj)
{
if (!obj) return;
if (obj->server) ecore_hash_remove(obj->server->objects, obj->path);
_ecore_dbus_object_free(obj);
}
static void
_ecore_dbus_object_free(Ecore_DBus_Object *obj)
{
if (!obj) return;
if (obj->path) free(obj->path);
if (obj->methods) ecore_list_destroy(obj->methods);
free(obj);
}
/* object methods */
EAPI Ecore_DBus_Object_Method *
ecore_dbus_object_method_add(Ecore_DBus_Object *obj, const char *interface, const char *method_name, Ecore_DBus_Method_Call_Cb func, void *data)
{
Ecore_DBus_Object_Method *m;
char buf[PATH_MAX];
if (!obj || !interface || !method_name || !func) return NULL;
m = malloc(sizeof(Ecore_DBus_Object_Method));
m->object = obj;
m->interface = strdup(interface);
m->name = strdup(method_name);
m->func = func;
m->data = data;
ecore_list_append(obj->methods, m);
/* add match to server for this method */
snprintf(buf, sizeof(buf), "type=method_call,path=%s,interface=%s,member=%s", obj->path, interface, method_name);
ecore_dbus_method_add_match(obj->server, buf, NULL, NULL, NULL);
return m;
}
EAPI void
ecore_dbus_object_method_free(Ecore_DBus_Object_Method *method)
{
if (!method) return;
if (method->object && ecore_list_goto(method->object->methods, method))
ecore_list_remove(method->object->methods);
_ecore_dbus_object_method_free(method);
}
static void
_ecore_dbus_object_method_free(Ecore_DBus_Object_Method *method)
{
if (!method) return;
if (method->interface) free(method->interface);
if (method->name) free(method->name);
free(method);
}

358
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_private.h
View File

@ -1,358 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#ifndef _ECORE_DBUS_PRIVATE_H
#define _ECORE_DBUS_PRIVATE_H
#include "Ecore_Con.h"
#include "Ecore_Data.h"
extern int words_bigendian;
#define SWAP64(x) (x) = \
((((unsigned long long)(x) & 0x00000000000000ffULL ) << 56) |\
(((unsigned long long)(x) & 0x000000000000ff00ULL ) << 40) |\
(((unsigned long long)(x) & 0x0000000000ff0000ULL ) << 24) |\
(((unsigned long long)(x) & 0x00000000ff000000ULL ) << 8) |\
(((unsigned long long)(x) & 0x000000ff00000000ULL ) >> 8) |\
(((unsigned long long)(x) & 0x0000ff0000000000ULL ) >> 24) |\
(((unsigned long long)(x) & 0x00ff000000000000ULL ) >> 40) |\
(((unsigned long long)(x) & 0xff00000000000000ULL ) >> 56))
#define SWAP32(x) (x) = \
((((unsigned int)(x) & 0x000000ff ) << 24) |\
(((unsigned int)(x) & 0x0000ff00 ) << 8) |\
(((unsigned int)(x) & 0x00ff0000 ) >> 8) |\
(((unsigned int)(x) & 0xff000000 ) >> 24))
#define SWAP16(x) (x) = \
((((unsigned short)(x) & 0x00ff ) << 8) |\
(((unsigned short)(x) & 0xff00 ) >> 8))
#define CONV16(order, x) { if (words_bigendian && (order) != 'B') SWAP16(x); }
#define CONV32(order, x) { if (words_bigendian && (order) != 'B') SWAP32(x); }
#define CONV64(order, x) { if (words_bigendian && (order) != 'B') SWAP64(x); }
typedef unsigned char *(*Ecore_DBus_Auth_Transaction)(void *);
typedef struct _Ecore_DBus_Auth Ecore_DBus_Auth;
#define ECORE_DBUS_MESSAGE_FIELD(x) ((Ecore_DBus_Message_Field *)(x))
typedef struct _Ecore_DBus_Message_Field_Container Ecore_DBus_Message_Field_Container;
#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;
#define ECORE_DBUS_MESSAGE_FIELD_BYTE(x) ((Ecore_DBus_Message_Field_Byte *)(x))
typedef struct _Ecore_DBus_Message_Field_Boolean Ecore_DBus_Message_Field_Boolean;
#define ECORE_DBUS_MESSAGE_FIELD_BOOLEAN(x) ((Ecore_DBus_Message_Field_Boolean *)(x))
typedef struct _Ecore_DBus_Message_Field_Int16 Ecore_DBus_Message_Field_Int16;
#define ECORE_DBUS_MESSAGE_FIELD_INT16(x) ((Ecore_DBus_Message_Field_Int16 *)(x))
typedef struct _Ecore_DBus_Message_Field_UInt16 Ecore_DBus_Message_Field_UInt16;
#define ECORE_DBUS_MESSAGE_FIELD_UINT16(x) ((Ecore_DBus_Message_Field_UInt16 *)(x))
typedef struct _Ecore_DBus_Message_Field_Int32 Ecore_DBus_Message_Field_Int32;
#define ECORE_DBUS_MESSAGE_FIELD_INT32(x) ((Ecore_DBus_Message_Field_Int32 *)(x))
typedef struct _Ecore_DBus_Message_Field_UInt32 Ecore_DBus_Message_Field_UInt32;
#define ECORE_DBUS_MESSAGE_FIELD_UINT32(x) ((Ecore_DBus_Message_Field_UInt32 *)(x))
typedef struct _Ecore_DBus_Message_Field_Int64 Ecore_DBus_Message_Field_Int64;
#define ECORE_DBUS_MESSAGE_FIELD_INT64(x) ((Ecore_DBus_Message_Field_Int64 *)(x))
typedef struct _Ecore_DBus_Message_Field_UInt64 Ecore_DBus_Message_Field_UInt64;
#define ECORE_DBUS_MESSAGE_FIELD_UINT64(x) ((Ecore_DBus_Message_Field_UInt64 *)(x))
typedef struct _Ecore_DBus_Message_Field_Double Ecore_DBus_Message_Field_Double;
#define ECORE_DBUS_MESSAGE_FIELD_DOUBLE(x) ((Ecore_DBus_Message_Field_Double *)(x))
typedef struct _Ecore_DBus_Message_Field_String Ecore_DBus_Message_Field_String;
#define ECORE_DBUS_MESSAGE_FIELD_STRING(x) ((Ecore_DBus_Message_Field_String *)(x))
typedef struct _Ecore_DBus_Message_Field_Object_Path Ecore_DBus_Message_Field_Object_Path;
#define ECORE_DBUS_MESSAGE_FIELD_OBJECT_PATH(x) ((Ecore_DBus_Message_Field_Object_Path *)(x))
typedef struct _Ecore_DBus_Message_Field_Signature Ecore_DBus_Message_Field_Signature;
#define ECORE_DBUS_MESSAGE_FIELD_SIGNATURE(x) ((Ecore_DBus_Message_Field_Signature *)(x))
typedef struct _Ecore_DBus_Message_Field_Array Ecore_DBus_Message_Field_Array;
#define ECORE_DBUS_MESSAGE_FIELD_ARRAY(x) ((Ecore_DBus_Message_Field_Array *)(x))
typedef struct _Ecore_DBus_Message_Field_Variant Ecore_DBus_Message_Field_Variant;
#define ECORE_DBUS_MESSAGE_FIELD_VARIANT(x) ((Ecore_DBus_Message_Field_Variant *)(x))
typedef struct _Ecore_DBus_Message_Field_Struct Ecore_DBus_Message_Field_Struct;
#define ECORE_DBUS_MESSAGE_FIELD_STRUCT(x) ((Ecore_DBus_Message_Field_Struct *)(x))
typedef struct _Ecore_DBus_Message_Field_Dict_Entry Ecore_DBus_Message_Field_Dict_Entry;
#define ECORE_DBUS_MESSAGE_FIELD_DICT_ENTRY(x) ((Ecore_DBus_Message_Field_Dict_Entry *)(x))
typedef enum _Ecore_DBus_Auth_Type
{
ECORE_DBUS_AUTH_TYPE_EXTERNAL,
ECORE_DBUS_AUTH_MAGIC_COOKIE,
ECORE_DBUS_AUTH_TYPE_ECORE_DBUS_COOKIE_SHA1,
ECORE_DBUS_AUTH_TYPE_KERBEROS_V4,
ECORE_DBUS_AUTH_TYPE_SKEY
} Ecore_DBus_Auth_Type;
struct _Ecore_DBus_Server
{
Ecore_List2 __list_data;
Ecore_Con_Server *server;
int authenticated;
int auth_type;
int auth_type_transaction;
int cnt_msg;
Ecore_Hash *messages;
Ecore_Hash *objects;
char *unique_name;
};
struct _Ecore_DBus_Message
{
/* server to send to */
Ecore_DBus_Server *server;
/* callback */
struct {
Ecore_DBus_Method_Return_Cb method_return;
Ecore_DBus_Error_Cb error;
void *data;
} cb;
/* header fields */
unsigned char byte_order;
unsigned char type;
unsigned char flags;
unsigned char protocol;
unsigned int serial;
unsigned int body_length;
unsigned char *signature;
/* message */
unsigned int size;
unsigned int length;
unsigned char *buffer;
void *header;
Ecore_List *all;
Ecore_List *fields;
Ecore_List *recurse;
};
struct _Ecore_DBus_Message_Field
{
Ecore_DBus_Data_Type type;
unsigned int offset;
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
{
const char *name;
unsigned int num_transactions;
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_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);
void *_ecore_dbus_message_field_value_get(Ecore_DBus_Message_Field *f);
int _ecore_dbus_complete_type_length_get(const char *signature);
/* ecore_dbus_marshal.c */
Ecore_DBus_Message_Field *
_ecore_dbus_message_marshal(Ecore_DBus_Message *msg, const char *type, const void *data);
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);
#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);
#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_Array *_ecore_dbus_message_marshal_array(Ecore_DBus_Message *msg, const char *contained_type, Ecore_List *data);
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, const 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);
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, int size);
/* ecore_dbus_object.c */
int ecore_dbus_object_method_dispatch(Ecore_DBus_Server *server, const char *path, const char *interface, const char *method);
int ecore_dbus_objects_init(void);
void ecore_dbus_objects_shutdown(void);
/* Errors */
#define DBUS_ERROR_FAILED "org.freedesktop.DBus.Error.Failed"
#define DBUS_ERROR_NO_MEMORY "org.freedesktop.DBus.Error.NoMemory"
#define DBUS_ERROR_ACTIVATE_SERVICE_NOT_FOUND "org.freedesktop.DBus.Error.ServiceNotFound"
#define DBUS_ERROR_SERVICE_DOES_NOT_EXIST "org.freedesktop.DBus.Error.ServiceDoesNotExist"
#define DBUS_ERROR_SERVICE_HAS_NO_OWNER "org.freedesktop.DBus.Error.ServiceHasNoOwner"
#define DBUS_ERROR_NO_REPLY "org.freedesktop.DBus.Error.NoReply"
#define DBUS_ERROR_IO_ERROR "org.freedesktop.DBus.Error.IOError"
#define DBUS_ERROR_BAD_ADDRESS "org.freedesktop.DBus.Error.BadAddress"
#define DBUS_ERROR_NOT_SUPPORTED "org.freedesktop.DBus.Error.NotSupported"
#define DBUS_ERROR_LIMITS_EXCEEDED "org.freedesktop.DBus.Error.LimitsExceeded"
#define DBUS_ERROR_ACCESS_DENIED "org.freedesktop.DBus.Error.AccessDenied"
#define DBUS_ERROR_AUTH_FAILED "org.freedesktop.DBus.Error.AuthFailed"
#define DBUS_ERROR_NO_SERVER "org.freedesktop.DBus.Error.NoServer"
#define DBUS_ERROR_TIMEOUT "org.freedesktop.DBus.Error.Timeout"
#define DBUS_ERROR_NO_NETWORK "org.freedesktop.DBus.Error.NoNetwork"
#define DBUS_ERROR_ADDRESS_IN_USE "org.freedesktop.DBus.Error.AddressInUse"
#define DBUS_ERROR_DISCONNECTED "org.freedesktop.DBus.Error.Disconnected"
#define DBUS_ERROR_INVALID_ARGS "org.freedesktop.DBus.Error.InvalidArgs"
#define DBUS_ERROR_FILE_NOT_FOUND "org.freedesktop.DBus.Error.FileNotFound"
#define DBUS_ERROR_UNKNOWN_METHOD "org.freedesktop.DBus.Error.UnknownMethod"
#define DBUS_ERROR_TIMED_OUT "org.freedesktop.DBus.Error.TimedOut"
#define DBUS_ERROR_MATCH_RULE_NOT_FOUND "org.freedesktop.DBus.Error.MatchRuleNotFound"
#define DBUS_ERROR_MATCH_RULE_INVALID "org.freedesktop.DBus.Error.MatchRuleInvalid"
#define DBUS_ERROR_SPAWN_EXEC_FAILED "org.freedesktop.DBus.Error.Spawn.ExecFailed"
#define DBUS_ERROR_SPAWN_FORK_FAILED "org.freedesktop.DBus.Error.Spawn.ForkFailed"
#define DBUS_ERROR_SPAWN_CHILD_EXITED "org.freedesktop.DBus.Error.Spawn.ChildExited"
#define DBUS_ERROR_SPAWN_CHILD_SIGNALED "org.freedesktop.DBus.Error.Spawn.ChildSignaled"
#define DBUS_ERROR_SPAWN_FAILED "org.freedesktop.DBus.Error.Spawn.Failed"
#define DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN "org.freedesktop.DBus.Error.UnixProcessIdUnknown"
#endif

477
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_unmarshal.c
View File

@ -1,477 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "ecore_private.h"
#include "Ecore_Con.h"
#include "Ecore_DBus.h"
#include "ecore_dbus_private.h"
typedef void *(*Ecore_DBus_Unmarshal_Func)(Ecore_DBus_Message *msg, int *size);
static void *
_ecore_dbus_message_unmarshal_byte(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_Byte *f;
unsigned int old_length;
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 < (int)(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;
}
static void *
_ecore_dbus_message_unmarshal_boolean(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_Boolean *f;
unsigned int old_length;
old_length = msg->length;
f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_BOOLEAN);
f->value = _ecore_dbus_message_read_uint32(msg);
if (*size < (int)(msg->length - old_length))
{
/* TODO: Free message field */
printf("Ecore_DBus: To few bytes for boolean: got %d need %d\n",
*size, (msg->length - old_length));
return NULL;
}
*size -= (msg->length - old_length);
return f;
}
static void *
_ecore_dbus_message_unmarshal_int32(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_Int32 *f;
unsigned int old_length;
old_length = msg->length;
_ecore_dbus_message_padding(msg, 4);
f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_INT32);
f->value = _ecore_dbus_message_read_uint32(msg);
if (*size < (int)(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;
}
static void *
_ecore_dbus_message_unmarshal_uint32(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_UInt32 *f;
unsigned int old_length;
old_length = msg->length;
_ecore_dbus_message_padding(msg, 4);
f = _ecore_dbus_message_field_new(msg, ECORE_DBUS_DATA_TYPE_UINT32);
f->value = _ecore_dbus_message_read_uint32(msg);
if (*size < (int)(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;
}
static void *
_ecore_dbus_message_unmarshal_string(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_String *f;
unsigned int str_len, old_length;
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 < (int)(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;
}
static void *
_ecore_dbus_message_unmarshal_object_path(Ecore_DBus_Message *msg, int *size)
{
Ecore_DBus_Message_Field_Object_Path *f;
unsigned int str_len, old_length;
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 < (int)(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;
}
static void *
_ecore_dbus_message_unmarshal_signature(Ecore_DBus_Message *msg, int *size)
{
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 < (int)(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 void *
_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->contained_type = contained_type;
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 < (int)(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 __UNUSED__)
{
ecore_list_remove_first(msg->recurse);
}
static void *
_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 < (int)(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 __UNUSED__)
{
ecore_list_remove_first(msg->recurse);
}
static void *
_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);
/* 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);
f->contained_type = type;
/* Read '\0' from signature */
_ecore_dbus_message_read_byte(msg);
if (*size < (int)(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_UINT32:
f->value = _ecore_dbus_message_unmarshal_uint32(msg, size);
break;
case ECORE_DBUS_DATA_TYPE_STRING:
f->value = _ecore_dbus_message_unmarshal_string(msg, size);
break;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
f->value = _ecore_dbus_message_unmarshal_object_path(msg, size);
break;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
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:
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", type);
break;
}
ecore_list_remove_first(msg->recurse);
return f;
}
static Ecore_DBus_Unmarshal_Func
_ecore_dbus_message_unmarshal_func(Ecore_DBus_Data_Type type)
{
switch (type)
{
case ECORE_DBUS_DATA_TYPE_BYTE:
return _ecore_dbus_message_unmarshal_byte;
case ECORE_DBUS_DATA_TYPE_INT32:
return _ecore_dbus_message_unmarshal_int32;
case ECORE_DBUS_DATA_TYPE_UINT32:
return _ecore_dbus_message_unmarshal_uint32;
case ECORE_DBUS_DATA_TYPE_STRING:
return _ecore_dbus_message_unmarshal_string;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
return _ecore_dbus_message_unmarshal_object_path;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
return _ecore_dbus_message_unmarshal_signature;
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_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", type);
break;
}
return NULL;
}
Ecore_DBus_Message *
_ecore_dbus_message_unmarshal(Ecore_DBus_Server *svr, unsigned char *message, int size)
{
Ecore_DBus_Message *msg;
Ecore_DBus_Message_Field_Array *arr;
char *sig;
unsigned int old_length;
/* init */
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 */
msg->byte_order = *(message + 0);
msg->type = *(message + 1);
msg->flags = *(message + 2);
msg->protocol = *(message + 3);
if (msg->protocol != ECORE_DBUS_MAJOR_PROTOCOL_VERSION)
{
printf("Ecore_DBus: Only supports protocol 0x%x, message has protocol 0x%x.\n",
ECORE_DBUS_MAJOR_PROTOCOL_VERSION, msg->protocol);
goto error;
}
msg->body_length = *(unsigned int *)(message + 4);
msg->serial = *(unsigned int *)(message + 8);
if (msg->type == ECORE_DBUS_MESSAGE_TYPE_INVALID)
{
printf("Ecore_DBus: Invalid message type.\n");
goto error;
}
/* copy message to buffer */
_ecore_dbus_message_append_bytes(msg, message, size);
msg->length = 12;
size -= 12;
/* Parse header fields */
if (!(arr = _ecore_dbus_message_unmarshal_array_begin(msg, ECORE_DBUS_DATA_TYPE_STRUCT, &size)))
{
printf("Could not parse header fields.\n");
goto error;
}
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)
{
while (*sig)
{
Ecore_DBus_Data_Type type;
type = *sig;
switch (type)
{
case ECORE_DBUS_DATA_TYPE_BOOLEAN:
_ecore_dbus_message_unmarshal_boolean(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_INT32:
_ecore_dbus_message_unmarshal_int32(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_UINT32:
_ecore_dbus_message_unmarshal_uint32(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_STRING:
_ecore_dbus_message_unmarshal_string(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
_ecore_dbus_message_unmarshal_object_path(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
_ecore_dbus_message_unmarshal_signature(msg, &size);
break;
case ECORE_DBUS_DATA_TYPE_ARRAY:
{
Ecore_DBus_Message_Field_Array *ar2;
Ecore_DBus_Unmarshal_Func func;
sig++;
type = *sig;
ar2 = _ecore_dbus_message_unmarshal_array_begin(msg, type, &size);
func = _ecore_dbus_message_unmarshal_func(type);
while (msg->length < ar2->end)
(*func)(msg, &size);
_ecore_dbus_message_unmarshal_array_end(msg, ar2);
}
break;
case ECORE_DBUS_DATA_TYPE_INVALID:
case ECORE_DBUS_DATA_TYPE_BYTE:
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:
printf("[ecore_dbus] unhandled data type %c\n", type);
break;
default:
printf("[ecore_dbus] unknown data type %c\n", type);
break;
}
sig++;
}
}
return msg;
error:
_ecore_dbus_message_free(msg);
return NULL;
}

269
legacy/ecore/src/lib/ecore_dbus/ecore_dbus_utils.c
View File

@ -1,269 +0,0 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include <stdlib.h>
#include <string.h>
#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)
{
if (msg->length + size >= msg->size)
{
Ecore_DBus_Message_Field *f;
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;
/* Update buffer references */
ecore_list_goto_first(msg->all);
while ((f = ecore_list_next(msg->all)))
f->buffer = msg->buffer + f->offset;
}
}
void
_ecore_dbus_message_padding(Ecore_DBus_Message *msg, unsigned int size)
{
unsigned int padding;
padding = msg->length % size;
if (padding != 0)
{
padding = size - padding;
_ecore_dbus_message_length_append(msg, padding);
msg->length += padding;
}
}
void
_ecore_dbus_message_padding_skip(Ecore_DBus_Message *msg, unsigned int size)
{
unsigned int padding;
padding = msg->length % size;
if (padding != 0)
{
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;
}
}
void
_ecore_dbus_message_append_bytes(Ecore_DBus_Message *msg, unsigned char *c, unsigned int size)
{
_ecore_dbus_message_length_append(msg, size);
memcpy(msg->buffer + msg->length, c, size);
msg->length += size;
}
void
_ecore_dbus_message_append_byte(Ecore_DBus_Message *msg, unsigned char c)
{
_ecore_dbus_message_length_append(msg, 1);
msg->buffer[msg->length++] = c;
}
void
_ecore_dbus_message_append_uint32(Ecore_DBus_Message *msg, unsigned int i)
{
unsigned char *c;
CONV32(msg->byte_order, i)
c = (unsigned char *)&i;
_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(Ecore_DBus_Message *msg)
{
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(Ecore_DBus_Message *msg)
{
unsigned int i;
_ecore_dbus_message_length_append(msg, 4);
i = *(unsigned int *)(msg->buffer + msg->length);
CONV32(msg->byte_order, i)
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 (%c)", type);
return 0;
}
}
void *
_ecore_dbus_message_field_value_get(Ecore_DBus_Message_Field *f)
{
switch (f->type)
{
case ECORE_DBUS_DATA_TYPE_BYTE:
return &ECORE_DBUS_MESSAGE_FIELD_BYTE(f)->value;
case ECORE_DBUS_DATA_TYPE_BOOLEAN:
return &ECORE_DBUS_MESSAGE_FIELD_BOOLEAN(f)->value;
case ECORE_DBUS_DATA_TYPE_INT16:
return &ECORE_DBUS_MESSAGE_FIELD_INT16(f)->value;
case ECORE_DBUS_DATA_TYPE_UINT16:
return &ECORE_DBUS_MESSAGE_FIELD_UINT16(f)->value;
case ECORE_DBUS_DATA_TYPE_INT32:
return &ECORE_DBUS_MESSAGE_FIELD_INT32(f)->value;
case ECORE_DBUS_DATA_TYPE_UINT32:
return &ECORE_DBUS_MESSAGE_FIELD_UINT32(f)->value;
case ECORE_DBUS_DATA_TYPE_INT64:
return &ECORE_DBUS_MESSAGE_FIELD_INT64(f)->value;
case ECORE_DBUS_DATA_TYPE_UINT64:
return &ECORE_DBUS_MESSAGE_FIELD_UINT64(f)->value;
case ECORE_DBUS_DATA_TYPE_DOUBLE:
return &ECORE_DBUS_MESSAGE_FIELD_DOUBLE(f)->value;
case ECORE_DBUS_DATA_TYPE_STRING:
return ECORE_DBUS_MESSAGE_FIELD_STRING(f)->value;
case ECORE_DBUS_DATA_TYPE_OBJECT_PATH:
return ECORE_DBUS_MESSAGE_FIELD_OBJECT_PATH(f)->value;
case ECORE_DBUS_DATA_TYPE_SIGNATURE:
return ECORE_DBUS_MESSAGE_FIELD_SIGNATURE(f)->value;
case ECORE_DBUS_DATA_TYPE_ARRAY:
{
Ecore_DBus_Message_Field_Container *c;
Ecore_List *list;
void *value;
list = ecore_list_new();
c = ECORE_DBUS_MESSAGE_FIELD_CONTAINER(f);
ecore_list_goto_first(c->values);
while ((value = ecore_list_next(c->values)))
ecore_list_append(list, _ecore_dbus_message_field_value_get(value));
return list;
}
case ECORE_DBUS_DATA_TYPE_INVALID:
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
break;
}
return NULL;
}
/**
* Returns the length of the complete type starting at signature.
* signature should be a pointer within a signature string.
*
* e.g
* uia -> 1 "u"
* aus -> 2 "au"
* (aus)s -> 5 "(aus)"
*/
int
_ecore_dbus_complete_type_length_get(const char *signature)
{
int len = 0;
int depth = 0;
while (*signature)
{
len++;
switch (*signature)
{
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:
case ECORE_DBUS_DATA_TYPE_VARIANT:
/* these types are complete on their own */
if (!depth) return len;
break;
case ECORE_DBUS_DATA_TYPE_ARRAY:
/* this takes one complete type after it. */
break;
case ECORE_DBUS_DATA_TYPE_STRUCT_BEGIN:
case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_BEGIN:
depth++;
break;
case ECORE_DBUS_DATA_TYPE_STRUCT_END:
case ECORE_DBUS_DATA_TYPE_DICT_ENTRY_END:
depth--;
if (!depth) return len;
break;
case ECORE_DBUS_DATA_TYPE_STRUCT:
case ECORE_DBUS_DATA_TYPE_DICT_ENTRY:
case ECORE_DBUS_DATA_TYPE_INVALID:
printf("[ecore_dbus] type '%c' not allowed in signature string", *signature);
break;
default:
printf("[ecore_dbus] unknown type '%c' not allowed in signature string", *signature);
break;
}
signature++;
}
return 0;
}