src/lib/ecore_config/ecore_config_ipc_ecore.c

   1 #ifdef HAVE_CONFIG_H
   2 # include <config.h>
   3 #endif
   4
   5 /* by Azundris, with thanks to Corey Donohoe <atmos@atmos.org> */
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <errno.h>
  10 #include <limits.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <unistd.h>
  14 #include <ctype.h>
  15
  16 #include <Ecore.h>
  17 #include "ecore_private.h"
  18 #include <Ecore_Ipc.h>
  19
  20 #include "ecore_config_ipc.h"
  21 #include "ecore_config_util.h"
  22 #include "ecore_config_private.h"
  23
  24 #include "Ecore_Config.h"
  25
  26
  27 /*****************************************************************************/
  28
  29 static int
  30 _ecore_config_ipc_ecore_string_get(char **m, char **r)
  31 {
  32    char               *q;
  33    int                 l = 0;
  34
  35    if (!m || !*m)
  36       return ECORE_CONFIG_ERR_NODATA;
  37    if (!r)
  38       return ECORE_CONFIG_ERR_FAIL;
  39    q = *m;
  40    if (*q != 's')
  41       return ECORE_CONFIG_ERR_TYPEMISMATCH;
  42    q++;
  43    l = (*(q++)) << 8;
  44    l += *(q++);
  45    *r = q;
  46    q += l;
  47    *m = q;
  48    WRN("IPC/eCore: got string-%d \"%s\"", l, *r);
  49    return ECORE_CONFIG_ERR_SUCC;
  50 }
  51
  52 static char               *
  53 _ecore_config_ipc_global_prop_list(Ecore_Config_Server * srv __UNUSED__, long serial __UNUSED__)
  54 {
  55    Ecore_Config_DB_File  *db;
  56    char                 **keys;
  57    int                    key_count, x;
  58    estring               *s;
  59    int                    f;
  60    char                   buf[PATH_MAX], *p;
  61    // char              *data;                  UNUSED
  62    Ecore_Config_Type      type;
  63
  64    db = NULL;
  65    s = estring_new(8192);
  66    f = 0;
  67    if ((p = getenv("HOME")))
  68      {
  69         snprintf(buf, sizeof(buf), "%s/.e/config.eet", p);
  70         if (!(db = _ecore_config_db_open_read(buf)))
  71           {
  72              strcpy(buf, PACKAGE_DATA_DIR"/system.eet");
  73              if (!(db = _ecore_config_db_open_read(buf)))
  74                return NULL;
  75           }
  76      }
  77    if (!db) return NULL;
  78    key_count = 0;
  79    keys = _ecore_config_db_keys_get(db, &key_count);
  80    if (keys)
  81      {
  82         for (x = 0; x < key_count; x++)
  83           {
  84              type = _ecore_config_db_key_type_get(db, keys[x]);
  85              switch (type)
  86                {
  87                   case ECORE_CONFIG_INT:
  88                     estring_appendf(s, "%s%s: integer", f ? "\n" : "", keys[x]);
  89                     break;
  90                   case ECORE_CONFIG_BLN:
  91                     estring_appendf(s, "%s%s: boolean", f ? "\n" : "", keys[x]);
  92                     break;
  93                   case ECORE_CONFIG_FLT:
  94                     estring_appendf(s, "%s%s: float", f ? "\n" : "", keys[x]);
  95                     break;
  96                   case ECORE_CONFIG_STR:
  97                     estring_appendf(s, "%s%s: string", f ? "\n" : "", keys[x]);
  98                     break;
  99                   case ECORE_CONFIG_RGB:
 100                     estring_appendf(s, "%s%s: colour", f ? "\n" : "", keys[x]);
 101                     break;
 102                   case ECORE_CONFIG_THM:
 103                     estring_appendf(s, "%s%s: theme", f ? "\n" : "", keys[x]);
 104                     break;
 105                   case ECORE_CONFIG_SCT:
 106                     estring_appendf(s, "%s%s: structure", f ? "\n" : "", keys[x]);
 107                     break;
 108                   default:
 109                     estring_appendf(s, "%s%s: unknown", f ? "\n" : "", keys[x]);
 110                     continue;
 111                }
 112              f = 1;
 113           }
 114      }
 115    _ecore_config_db_close(db);
 116    if (keys)
 117      {
 118         for (x = 0; x < key_count; x++)
 119           {
 120              free(keys[x]);
 121           }
 122         free(keys);
 123      }
 124
 125    return estring_disown(s);
 126 }
 127
 128 /*****************************************************************************/
 129
 130 static int
 131 _ecore_config_ipc_ecore_send(Ecore_Ipc_Event_Client_Data * e, int code,
 132                              char *reply)
 133 {
 134    static int          our_ref = 0;
 135    int                 len = reply ? strlen(reply) + 1 : 0;
 136
 137    our_ref++;
 138    WRN("IPC/eCore: replying [0,0] %d IRT %d => %d {\"%s\":%d}", our_ref,
 139      e->ref, code, reply ? reply : "", len);
 140    return ecore_ipc_client_send(e->client, 0, 0, our_ref, e->ref, code, reply,
 141                                 len);
 142 }
 143
 144 /*****************************************************************************/
 145
 146 static int
 147 _ecore_config_ipc_ecore_handle_request(Ecore_Ipc_Server * server,
 148                                        Ecore_Ipc_Event_Client_Data * e)
 149 {
 150    Ecore_Config_Server *srv;
 151    long                serial;
 152    int                 ret;
 153    char               *r, *k, *v, *m;
 154
 155    srv = _ecore_config_server_convert(server);
 156    serial = e->minor;
 157    r = NULL;
 158    m = (char *)e->data;
 159    INF("IPC/eCore: client sent: [%d,%d] #%d (%d) @ %p", e->major, e->minor,
 160      e->ref, e->size, server);
 161
 162    switch (e->major)
 163      {
 164      case IPC_PROP_LIST:
 165         if (srv == __ecore_config_server_global)
 166            r = _ecore_config_ipc_global_prop_list(srv, serial);
 167         else
 168            r = _ecore_config_ipc_prop_list(srv, serial);
 169         break;
 170      case IPC_PROP_DESC:
 171         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 172            r = _ecore_config_ipc_prop_desc(srv, serial, k);
 173         break;
 174      case IPC_PROP_GET:
 175         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 176            r = _ecore_config_ipc_prop_get(srv, serial, k);
 177         break;
 178      case IPC_PROP_SET:
 179         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 180           {
 181              if (_ecore_config_ipc_ecore_string_get(&m, &v) ==
 182                  ECORE_CONFIG_ERR_SUCC)
 183                 return _ecore_config_ipc_ecore_send(e,
 184                                                     _ecore_config_ipc_prop_set
 185                                                     (srv, serial, k, v), NULL);
 186           }
 187         break;
 188
 189      case IPC_BUNDLE_LIST:
 190         r = _ecore_config_ipc_bundle_list(srv);
 191         break;
 192      case IPC_BUNDLE_NEW:
 193         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 194            return _ecore_config_ipc_ecore_send(e,
 195                                                k ?
 196                                                _ecore_config_ipc_bundle_new(srv,
 197                                                                             k) :
 198                                                ECORE_CONFIG_ERR_FAIL, NULL);
 199         break;
 200      case IPC_BUNDLE_LABEL_SET:
 201         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 202            return _ecore_config_ipc_ecore_send(e,
 203                                                k ?
 204                                                _ecore_config_ipc_bundle_label_set
 205                                                (srv, serial,
 206                                                 k) : ECORE_CONFIG_ERR_FAIL,
 207                                                NULL);
 208         break;
 209      case IPC_BUNDLE_LABEL_FIND:
 210         if (_ecore_config_ipc_ecore_string_get(&m, &k) == ECORE_CONFIG_ERR_SUCC)
 211            return _ecore_config_ipc_ecore_send(e,
 212                                                _ecore_config_ipc_bundle_label_find
 213                                                (srv, k), NULL);
 214         break;
 215      case IPC_BUNDLE_LABEL_GET:
 216         r = _ecore_config_ipc_bundle_label_get(srv, serial);
 217         break;
 218      }
 219
 220    ret =
 221       _ecore_config_ipc_ecore_send(e,
 222                                    r ? ECORE_CONFIG_ERR_SUCC :
 223                                    ECORE_CONFIG_ERR_FAIL, r);
 224    if (r)
 225      {
 226         free(r);
 227         return ret;
 228      }
 229    return ECORE_CONFIG_ERR_NOTFOUND;
 230 }
 231
 232 /*****************************************************************************/
 233
 234 static Eina_Bool
 235 _ecore_config_ipc_client_add(void *data, int type __UNUSED__, void *event)
 236 {
 237    Ecore_Ipc_Server  **server;
 238    Ecore_Ipc_Event_Client_Data *e;
 239
 240    server = (Ecore_Ipc_Server **) data;
 241    e = (Ecore_Ipc_Event_Client_Data *) event;
 242
 243    if (*server != ecore_ipc_client_server_get(e->client))
 244       return EINA_TRUE;
 245
 246    INF("IPC/eCore: Client connected. @ %p", server);
 247    return EINA_TRUE;
 248 }
 249
 250 static Eina_Bool
 251 _ecore_config_ipc_client_del(void *data, int type __UNUSED__, void *event)
 252 {
 253    Ecore_Ipc_Server  **server;
 254    Ecore_Ipc_Event_Client_Data *e;
 255
 256    server = (Ecore_Ipc_Server **) data;
 257    e = (Ecore_Ipc_Event_Client_Data *) event;
 258
 259    if (*server != ecore_ipc_client_server_get(e->client))
 260       return EINA_TRUE;
 261
 262    INF("IPC/eCore: Client disconnected. @ %p", server);
 263    return EINA_TRUE;
 264 }
 265
 266 static Eina_Bool
 267 _ecore_config_ipc_client_sent(void *data, int type __UNUSED__, void *event)
 268 {
 269    Ecore_Ipc_Server  **server;
 270    Ecore_Ipc_Event_Client_Data *e;
 271
 272    server = (Ecore_Ipc_Server **) data;
 273    e = (Ecore_Ipc_Event_Client_Data *) event;
 274
 275    if (*server != ecore_ipc_client_server_get(e->client))
 276       return EINA_TRUE;
 277
 278    _ecore_config_ipc_ecore_handle_request(*server, e);
 279    return EINA_TRUE;
 280 }
 281
 282 /*****************************************************************************/
 283
 284 int
 285 _ecore_config_ipc_ecore_init(const char *pipe_name, void **data)
 286 {
 287    Ecore_Ipc_Server  **server;
 288    struct stat         st;
 289    char               *p;
 290    int                 port;
 291    char                socket[PATH_MAX];
 292
 293    server = (Ecore_Ipc_Server **) data;
 294    port = 0;
 295    if (!server)
 296       return ECORE_CONFIG_ERR_FAIL;
 297
 298 /*  if(*server)
 299       return ECORE_CONFIG_ERR_IGNORED; */
 300
 301    ecore_init();
 302    if (ecore_ipc_init() < 1)
 303       return ECORE_CONFIG_ERR_FAIL;
 304
 305    if ((p = getenv("HOME")))
 306      {                          /* debug-only ### FIXME */
 307         int                 stale;
 308
 309         stale = 1;
 310         while (stale)
 311           {
 312              snprintf(socket, PATH_MAX, "%s/.ecore/%s/%d", p, pipe_name, port);
 313
 314              if (!stat(socket, &st))
 315                {
 316                   INF("IPC/eCore: pipe \"%s\" already exists!?", socket);
 317 /*      if(unlink(buf))
 318         E(0,"IPC/eCore: could not remove pipe \"%s\": %d\n",buf,errno); }}*/
 319                   port++;
 320                }
 321              else
 322                {
 323                   stale = 0;
 324                }
 325           }
 326      }
 327    *server = ecore_ipc_server_add(ECORE_IPC_LOCAL_USER, pipe_name, port, NULL);
 328    ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD,
 329                            _ecore_config_ipc_client_add, server);
 330    ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL,
 331                            _ecore_config_ipc_client_del, server);
 332    ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA,
 333                            _ecore_config_ipc_client_sent, server);
 334
 335    if (*server)
 336      {
 337         INF("IPC/eCore: Server is listening on %s.", pipe_name);
 338      }
 339
 340    return ECORE_CONFIG_ERR_SUCC;
 341 }
 342
 343 int
 344 _ecore_config_ipc_ecore_exit(void **data)
 345 {
 346    int                 ret;
 347    Ecore_Ipc_Server  **server;
 348
 349    ret = ECORE_CONFIG_ERR_SUCC;
 350    server = (Ecore_Ipc_Server **) data;
 351
 352    if (!server)
 353       return ECORE_CONFIG_ERR_FAIL;
 354
 355    if (*server)
 356      {
 357         ecore_ipc_server_del(*server);
 358         *server = NULL;
 359      }
 360
 361    ecore_ipc_shutdown();
 362    ecore_shutdown();
 363
 364    return ret;
 365 }
 366
 367 /*****************************************************************************/
 368
 369 int
 370 _ecore_config_ipc_ecore_poll(void **data)
 371 {
 372    Ecore_Ipc_Server  **server;
 373
 374    server = (Ecore_Ipc_Server **) data;
 375
 376    if (!server)
 377       return ECORE_CONFIG_ERR_FAIL;
 378
 379    ecore_main_loop_iterate();
 380
 381    return ECORE_CONFIG_ERR_SUCC;
 382 }
 383
 384 /*****************************************************************************/