jf_simon
/
enlightenment_my
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

some ACTUAL ipc!!!! wow! you can load, unload, enable, disable and list 

modules now via enlightenment_remote (or any app that speaks the protocol
over ipc - INCLUDING apps that want to go insert modules into e when ther
execute)


SVN revision: 12276
This commit is contained in:
Carsten Haitzler 2004-11-26 12:20:38 +00:00
parent 94c79d788a
commit e0cdc11f48
3 changed files with 299 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
src/bin/e_ipc.c
View File

@ -68,7 +68,111 @@ _e_ipc_cb_client_data(void *data, int type, void *event)
e = event; e = event;
if (ecore_ipc_client_server_get(e->client) != _e_ipc_server) return 1; if (ecore_ipc_client_server_get(e->client) != _e_ipc_server) return 1;
printf("E-IPC: client sent: [%i] [%i] (%i) \"%s\"\n", e->major, e->minor, e->size, e->data); switch (e->minor)
{
case E_IPC_OP_MODULE_LOAD:
if (e->data)
{
char *name;
name = malloc(e->size + 1);
name[e->size] = 0;
memcpy(name, e->data, e->size);
if (!e_module_find(name))
{
e_module_new(name);
}
free(name);
}
break;
case E_IPC_OP_MODULE_UNLOAD:
if (e->data)
{
char *name;
E_Module *m;
name = malloc(e->size + 1);
name[e->size] = 0;
memcpy(name, e->data, e->size);
if ((m = e_module_find(name)))
{
if (e_module_enabled_get(m))
e_module_disable(m);
e_object_del(E_OBJECT(m));
}
free(name);
}
break;
case E_IPC_OP_MODULE_ENABLE:
{
char *name;
E_Module *m;
name = malloc(e->size + 1);
name[e->size] = 0;
memcpy(name, e->data, e->size);
if ((m = e_module_find(name)))
{
if (!e_module_enabled_get(m))
e_module_enable(m);
}
free(name);
}
break;
case E_IPC_OP_MODULE_DISABLE:
{
char *name;
E_Module *m;
name = malloc(e->size + 1);
name[e->size] = 0;
memcpy(name, e->data, e->size);
if ((m = e_module_find(name)))
{
if (e_module_enabled_get(m))
e_module_disable(m);
}
free(name);
}
break;
case E_IPC_OP_MODULE_LIST:
{
Evas_List *modules, *l;
int bytes;
E_Module *m;
char *data, *p;
bytes = 0;
modules = e_module_list();
for (l = modules; l; l = l->next)
{
m = l->data;
bytes += strlen(m->name) + 1 + 1;
}
data = malloc(bytes);
p = data;
for (l = modules; l; l = l->next)
{
m = l->data;
strcpy(p, m->name);
p += strlen(m->name);
*p = 0;
p++;
*p = e_module_enabled_get(m);
p++;
}
ecore_ipc_client_send(e->client,
E_IPC_DOMAIN_REPLY,
E_IPC_OP_MODULE_LIST_REPLY,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
data, bytes);
free(data);
}
break;
default:
break;
}
printf("E-IPC: client sent: [%i] [%i] (%i) \"%p\"\n", e->major, e->minor, e->size, e->data);
/* ecore_ipc_client_send(e->client, 1, 2, 7, 77, 0, "ABC", 4); */ /* ecore_ipc_client_send(e->client, 1, 2, 7, 77, 0, "ABC", 4); */
/* we can disconnect a client like this: */ /* we can disconnect a client like this: */
/* ecore_ipc_client_del(e->client); */ /* ecore_ipc_client_del(e->client); */

22
src/bin/e_ipc.h
View File

@ -1,7 +1,27 @@
#ifndef E_IPC_H #ifndef E_IPC_H
#define E_IPC_H #define E_IPC_H
typedef enum _E_Ipc_Domain {
E_IPC_DOMAIN_NONE,
E_IPC_DOMAIN_SETUP,
E_IPC_DOMAIN_REQUEST,
E_IPC_DOMAIN_REPLY,
E_IPC_DOMAIN_EVENT,
E_IPC_DOMAIN_LAST
} E_Ipc_Domain;
typedef enum _E_Ipc_Op {
E_IPC_OP_NONE,
E_IPC_OP_MODULE_LOAD,
E_IPC_OP_MODULE_UNLOAD,
E_IPC_OP_MODULE_ENABLE,
E_IPC_OP_MODULE_DISABLE,
E_IPC_OP_MODULE_LIST,
E_IPC_OP_MODULE_LIST_REPLY,
E_IPC_OP_LAST
} E_Ipc_Op;
EAPI int e_ipc_init(void); EAPI int e_ipc_init(void);
EAPI void e_ipc_shutdown(void); EAPI void e_ipc_shutdown(void);
#endif #endif

185
src/bin/e_remote_main.c
View File

@ -1,10 +1,19 @@
#include "e.h" #include "e.h"
/* local subsystem functions */ /* local subsystem functions */
static int _e_cb_signal_exit(void *data, int ev_type, void *ev); static int _e_cb_signal_exit(void *data, int ev_type, void *ev);
static int _e_ipc_init(void); static int _e_ipc_init(void);
static void _e_ipc_shutdown(void);
static int _e_ipc_cb_server_add(void *data, int type, void *event);
static int _e_ipc_cb_server_del(void *data, int type, void *event);
static int _e_ipc_cb_server_data(void *data, int type, void *event);
/* local subsystem globals */ /* local subsystem globals */
static Ecore_Ipc_Server *_e_ipc_server = NULL;
static const char *display_name = NULL;
static int reply_count = 0;
static int reply_expect = 0;
/* externally accessible functions */ /* externally accessible functions */
int int
@ -13,18 +22,20 @@ main(int argc, char **argv)
int i; int i;
/* handle some command-line parameters */ /* handle some command-line parameters */
display_name = (const char *)getenv("DISPLAY");
for (i = 1; i < argc; i++) for (i = 1; i < argc; i++)
{ {
if ((!strcmp(argv[i], "-instance")) && (i < (argc - 1))) if ((!strcmp(argv[i], "-display")) && (i < (argc - 1)))
{ {
i++; i++;
display_name = argv[i];
} }
} }
/* basic ecore init */ /* basic ecore init */
if (!ecore_init()) if (!ecore_init())
{ {
printf("Enlightenment cannot Initialize Ecore!\n" printf("ERROR: Enlightenment_remote cannot Initialize Ecore!\n"
"Perhaps you are out of memory?\n"); "Perhaps you are out of memory?\n");
exit(-1); exit(-1);
} }
@ -32,14 +43,14 @@ main(int argc, char **argv)
/* setup a handler for when e is asked to exit via a system signal */ /* setup a handler for when e is asked to exit via a system signal */
if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _e_cb_signal_exit, NULL)) if (!ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _e_cb_signal_exit, NULL))
{ {
printf("Enlightenment cannot set up an exit signal handler.\n" printf("ERROR: Enlightenment_remote cannot set up an exit signal handler.\n"
"Perhaps you are out of memory?\n"); "Perhaps you are out of memory?\n");
exit(-1); exit(-1);
} }
/* init ipc */ /* init ipc */
if (!ecore_ipc_init()) if (!ecore_ipc_init())
{ {
printf("Enlightenment cannot initialize the ipc system.\n" printf("ERROR: Enlightenment_remote cannot initialize the ipc system.\n"
"Perhaps you are out of memory?\n"); "Perhaps you are out of memory?\n");
exit(-1); exit(-1);
} }
@ -47,17 +58,18 @@ main(int argc, char **argv)
/* setup e ipc service */ /* setup e ipc service */
if (!_e_ipc_init()) if (!_e_ipc_init())
{ {
printf("Enlightenment cannot set up the IPC socket.\n" printf("ERROR: Enlightenment_remote cannot set up the IPC socket.\n"
"It likely is already in use by an exisiting copy of Enlightenment.\n" "Maybe try the '-display :0' option?\n");
"Double check to see if Enlightenment is not already on this display,\n"
"but if that fails try deleting all files in ~/.ecore/enlightenment-*\n"
"and try running again.\n");
exit(-1); exit(-1);
} }
/* start our main loop */ /* start our main loop */
ecore_main_loop_begin(); ecore_main_loop_begin();
_e_ipc_shutdown();
ecore_ipc_shutdown();
ecore_shutdown();
/* just return 0 to keep the compiler quiet */ /* just return 0 to keep the compiler quiet */
return 0; return 0;
} }
@ -74,5 +86,154 @@ _e_cb_signal_exit(void *data, int ev_type, void *ev)
static int static int
_e_ipc_init(void) _e_ipc_init(void)
{ {
return 0; char buf[1024];
char *disp;
disp = (char *)display_name;
if (!disp) disp = ":0";
snprintf(buf, sizeof(buf), "enlightenment-(%s)", disp);
_e_ipc_server = ecore_ipc_server_connect(ECORE_IPC_LOCAL_USER, buf, 0, NULL);
/* FIXME: we shoudl also try the generic ":0" if the display is ":0.0" */
/* similar... */
if (!_e_ipc_server) return 0;
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_ADD, _e_ipc_cb_server_add, NULL);
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DEL, _e_ipc_cb_server_del, NULL);
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DATA, _e_ipc_cb_server_data, NULL);
return 1;
}
static void
_e_ipc_shutdown(void)
{
if (_e_ipc_server)
{
ecore_ipc_server_del(_e_ipc_server);
_e_ipc_server = NULL;
}
}
static int
_e_ipc_cb_server_add(void *data, int type, void *event)
{
Ecore_Ipc_Event_Server_Add *e;
int argc;
char **argv;
int i;
e = event;
ecore_app_args_get(&argc, &argv);
for (i = 1; i < argc; i++)
{
char *v;
if ((!strcmp(argv[i], "-load-module")) && (i < (argc - 1)))
{
i++;
v = argv[i];
ecore_ipc_server_send(_e_ipc_server,
E_IPC_DOMAIN_REQUEST,
E_IPC_OP_MODULE_LOAD,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
v, strlen(v));
}
else if ((!strcmp(argv[i], "-unload-module")) && (i < (argc - 1)))
{
i++;
v = argv[i];
ecore_ipc_server_send(_e_ipc_server,
E_IPC_DOMAIN_REQUEST,
E_IPC_OP_MODULE_UNLOAD,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
v, strlen(v));
}
else if ((!strcmp(argv[i], "-enable-module")) && (i < (argc - 1)))
{
i++;
v = argv[i];
ecore_ipc_server_send(_e_ipc_server,
E_IPC_DOMAIN_REQUEST,
E_IPC_OP_MODULE_ENABLE,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
v, strlen(v));
}
else if ((!strcmp(argv[i], "-disable-module")) && (i < (argc - 1)))
{
i++;
v = argv[i];
ecore_ipc_server_send(_e_ipc_server,
E_IPC_DOMAIN_REQUEST,
E_IPC_OP_MODULE_DISABLE,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
v, strlen(v));
}
else if ((!strcmp(argv[i], "-list-modules")))
{
reply_expect++;
ecore_ipc_server_send(_e_ipc_server,
E_IPC_DOMAIN_REQUEST,
E_IPC_OP_MODULE_LIST,
0/*ref*/, 0/*ref_to*/, 0/*response*/,
NULL, 0);
}
}
if (reply_count >= reply_expect) ecore_main_loop_quit();
return 1;
}
static int
_e_ipc_cb_server_del(void *data, int type, void *event)
{
Ecore_Ipc_Event_Server_Del *e;
e = event;
return 1;
}
static int
_e_ipc_cb_server_data(void *data, int type, void *event)
{
Ecore_Ipc_Event_Server_Data *e;
e = event;
printf("REPLY: BEGIN\n");
switch (e->minor)
{
case E_IPC_OP_MODULE_LIST_REPLY:
if (e->data)
{
char *p;
p = e->data;
while (p < (e->data + e->size))
{
char *name;
char enabled;
name = p;
p += strlen(name);
if (p < (e->data + e->size))
{
p++;
if (p < (e->data + e->size))
{
enabled = *p;
p++;
printf("REPLY: MODULE NAME=\"%s\" ENABLED=%i\n",
name, (int)enabled);
}
}
}
}
else
printf("REPLY: MODULE NONE\n");
break;
default:
break;
}
printf("REPLY: END\n");
reply_count++;
if (reply_count >= reply_expect) ecore_main_loop_quit();
return 1;
} }