enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 24 Pull Requests 2 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;
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); */
/* we can disconnect a client like this: */
/* ecore_ipc_client_del(e->client); */

22
src/bin/e_ipc.h
View File

@ -1,7 +1,27 @@
#ifndef 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 void e_ipc_shutdown(void);
#endif

185
src/bin/e_remote_main.c
View File

@ -1,10 +1,19 @@
#include "e.h"
/* local subsystem functions */
static int _e_cb_signal_exit(void *data, int ev_type, void *ev);
static int _e_ipc_init(void);
static int _e_cb_signal_exit(void *data, int ev_type, void *ev);
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 */
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 */
int
@ -13,18 +22,20 @@ main(int argc, char **argv)
int i;
/* handle some command-line parameters */
display_name = (const char *)getenv("DISPLAY");
for (i = 1; i < argc; i++)
{
if ((!strcmp(argv[i], "-instance")) && (i < (argc - 1)))
if ((!strcmp(argv[i], "-display")) && (i < (argc - 1)))
{
i++;
display_name = argv[i];
}
}
/* basic 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");
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 */
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");
exit(-1);
}
/* init ipc */
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");
exit(-1);
}
@ -47,17 +58,18 @@ main(int argc, char **argv)
/* setup e ipc service */
if (!_e_ipc_init())
{
printf("Enlightenment cannot set up the IPC socket.\n"
"It likely is already in use by an exisiting copy of Enlightenment.\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");
printf("ERROR: Enlightenment_remote cannot set up the IPC socket.\n"
"Maybe try the '-display :0' option?\n");
exit(-1);
}
/* start our main loop */
ecore_main_loop_begin();
_e_ipc_shutdown();
ecore_ipc_shutdown();
ecore_shutdown();
/* just return 0 to keep the compiler quiet */
return 0;
}
@ -74,5 +86,154 @@ _e_cb_signal_exit(void *data, int ev_type, void *ev)
static int
_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;
}