src/lib/elm_module.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /* what are moodules in elementary for? for modularising behavior and features
   5  * so they can be plugged in and out where you dont want the core source to
   6  * always behave like that or do it that way. plug it at runtime!
   7  *
   8  * they have module names (in config) and "slots" to plug that module into
   9  * to server a purpose. eg you plug plugin "xx" into the "entry-copy-paste"
  10  * slot so it would provide replacement copy & paste ui functionality and
  11  * specific symbols
  12  *
  13  * config is something like:
  14  *
  15  * export ELM_MODULES="xx>slot1:yy>slot2"
  16  *
  17  * where a module named xx is plugged into slot1 & yy is plugged into slot2
  18  *
  19  * real examples:
  20  *
  21  * export ELM_MODULES="my_module>entry/api"
  22  *
  23  * this loads the module called "my_module" into the slot "entry/api" which
  24  * is an api slot for entry modules to modify behavior and hook to
  25  * creation/deletion of the entry as well as replace the longpress behavior.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "elementary_config.h"
  30 #endif
  31
  32 #include <dlfcn.h>      /* dlopen,dlclose,etc */
  33
  34 static Eina_Hash *modules = NULL;
  35 static Eina_Hash *modules_as = NULL;
  36
  37 void
  38 _elm_module_init(void)
  39 {
  40    modules = eina_hash_string_small_new(NULL);
  41    modules_as = eina_hash_string_small_new(NULL);
  42 }
  43
  44 void
  45 _elm_module_shutdown(void)
  46 {
  47    // FIXME: unload all modules
  48    if (modules) eina_hash_free(modules);
  49    modules = NULL;
  50    if (modules_as) eina_hash_free(modules_as);
  51    modules_as = NULL;
  52 }
  53
  54 void
  55 _elm_module_parse(const char *s)
  56 {
  57    const char *p, *pe;
  58
  59    p = s;
  60    pe = p;
  61    for (;;)
  62      {
  63         if ((*pe == ':') || (!*pe))
  64           { // p -> pe == 'name:'
  65              if (pe > p)
  66                {
  67                   char *n = malloc(pe - p + 1);
  68                   if (n)
  69                     {
  70                        char *nn;
  71
  72                        strncpy(n, p, pe - p);
  73                        n[pe - p] = 0;
  74                        nn = strchr(n, '>');
  75                        if (nn)
  76                          {
  77                             *nn = 0;
  78                             nn++;
  79                             _elm_module_add(n, nn);
  80                          }
  81                        free(n);
  82                     }
  83                }
  84              if (!*pe) break;
  85              p = pe + 1;
  86              pe = p;
  87           }
  88         else
  89           pe++;
  90      }
  91 }
  92
  93 Elm_Module *
  94 _elm_module_find_as(const char *as)
  95 {
  96    Elm_Module *m;
  97
  98    m = eina_hash_find(modules_as, as);
  99    return m;
 100 }
 101
 102 Elm_Module *
 103 _elm_module_add(const char *name, const char *as)
 104 {
 105    Elm_Module *m;
 106    char buf[PATH_MAX];
 107
 108    m = eina_hash_find(modules, name);
 109    if (m)
 110      {
 111         m->references++;
 112         return m;
 113      }
 114    m = calloc(1, sizeof(Elm_Module));
 115    if (!m) return NULL;
 116    m->version = 1;
 117    if (name[0] != '/')
 118      {
 119         const char *home = getenv("HOME");
 120
 121         if (home)
 122           {
 123              snprintf(buf, sizeof(buf), "%s/.elementary/modules/%s/%s/module" EFL_SHARED_EXTENSION, home, name, MODULE_ARCH);
 124              m->handle = dlopen(buf, RTLD_NOW | RTLD_GLOBAL);
 125              if (m->handle)
 126                {
 127                   m->init_func = dlsym(m->handle, "elm_modapi_init");
 128                   if (m->init_func)
 129                     {
 130                        m->shutdown_func = dlsym(m->handle, "elm_modapi_shutdown");
 131                        m->so_path = eina_stringshare_add(buf);
 132                        m->name = eina_stringshare_add(name);
 133                        snprintf(buf, sizeof(buf), "%s/.elementary/modules/%s/%s", home, name, MODULE_ARCH);
 134                        m->bin_dir = eina_stringshare_add(buf);
 135                        snprintf(buf, sizeof(buf), "%s/.elementary/modules/%s", home, name);
 136                        m->data_dir = eina_stringshare_add(buf);
 137                     }
 138                   else
 139                     {
 140                        dlclose(m->handle);
 141                        free(m);
 142                        return NULL;
 143                     }
 144                }
 145           }
 146         if (!m->handle)
 147           {
 148              snprintf(buf, sizeof(buf), "%s/elementary/modules/%s/%s/module" EFL_SHARED_EXTENSION, _elm_lib_dir, name, MODULE_ARCH);
 149              m->handle = dlopen(buf, RTLD_NOW | RTLD_GLOBAL);
 150              if (m->handle)
 151                {
 152                   m->init_func = dlsym(m->handle, "elm_modapi_init");
 153                   if (m->init_func)
 154                     {
 155                        m->shutdown_func = dlsym(m->handle, "elm_modapi_shutdown");
 156                        m->so_path = eina_stringshare_add(buf);
 157                        m->name = eina_stringshare_add(name);
 158                        snprintf(buf, sizeof(buf), "%s/elementary/modules/%s/%s", _elm_lib_dir, name, MODULE_ARCH);
 159                        m->bin_dir = eina_stringshare_add(buf);
 160                        snprintf(buf, sizeof(buf), "%s/elementary/modules/%s", _elm_lib_dir, name);
 161                        m->data_dir = eina_stringshare_add(buf);
 162                     }
 163                   else
 164                     {
 165                        dlclose(m->handle);
 166                        free(m);
 167                        return NULL;
 168                     }
 169                }
 170           }
 171      }
 172    if (!m->handle)
 173      {
 174         free(m);
 175         return NULL;
 176      }
 177    if (!m->init_func(m))
 178      {
 179         dlclose(m->handle);
 180         eina_stringshare_del(m->name);
 181         eina_stringshare_del(m->so_path);
 182         eina_stringshare_del(m->data_dir);
 183         eina_stringshare_del(m->bin_dir);
 184         free(m);
 185         return NULL;
 186      }
 187    m->references = 1;
 188    eina_hash_direct_add(modules, m->name, m);
 189    m->as = eina_stringshare_add(as);
 190    eina_hash_direct_add(modules_as, m->as, m);
 191    return m;
 192 }
 193
 194 void
 195 _elm_module_del(Elm_Module *m)
 196 {
 197    m->references--;
 198    if (m->references > 0) return;
 199    if (m->shutdown_func) m->shutdown_func(m);
 200    eina_hash_del(modules, m->name, m);
 201    eina_hash_del(modules_as, m->as, m);
 202    if (m->api) free(m->api);
 203    eina_stringshare_del(m->name);
 204    eina_stringshare_del(m->as);
 205    eina_stringshare_del(m->so_path);
 206    eina_stringshare_del(m->data_dir);
 207    eina_stringshare_del(m->bin_dir);
 208    dlclose(m->handle);
 209    free(m);
 210 }
 211
 212 const void *
 213 _elm_module_symbol_get(Elm_Module *m, const char *name)
 214 {
 215    return dlsym(m->handle, name);
 216 }