src/main/event.c

   1 /* Event handling functions */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include "elinks.h"
   8
   9 #include "main/event.h"
  10 #include "util/error.h"
  11 #include "util/hash.h"
  12 #include "util/memory.h"
  13 #include "util/snprintf.h"
  14 #include "util/string.h"
  15
  16
  17 /* First, we should set some terminology:
  18  *
  19  * o event -> Message being [triggerred] by some ELinks part and [catched]
  20  *   by various random other ones.
  21  *
  22  * o event hook -> Device being deployed by various ELinks parts,
  23  *   associated with certain [event It [catches] that event by having a
  24  *   handler executed when the [event] is triggerred.
  25  *
  26  * o event chain -> Line of [event hook]s associated with a given [event
  27  *   The [hook]s are ordered by [priority Each hook returns whenever should
  28  *   the chain continue or that no other events in the chain should be
  29  *   triggered (TODO).
  30  */
  31
  32 struct event_handler {
  33         /* The function to be called with the event data. */
  34         event_hook_T callback;
  35
  36         /* The @priority of this handler. */
  37         int priority;
  38
  39         /* Handler specific data. */
  40         void *data;
  41 };
  42
  43 struct event {
  44         /* The event name has to be unique. */
  45         unsigned char *name;
  46
  47         /* There are @count event @handlers all ordered by priority. */
  48         struct event_handler *handlers;
  49         unsigned int count;
  50
  51         /* The unique event id and position in events. */
  52         int id;
  53 };
  54
  55 static struct event *events = NULL;
  56 static unsigned int eventssize = 0;
  57 static struct hash *event_hash = NULL;
  58
  59 /* TODO: This should be tuned to the number of events.  When we will have a lot
  60  * of them, this should be some big enough number to reduce unnecessary
  61  * slavery of CPU on the startup. Then after all main modules will be
  62  * initialized and their events will be registered, we could call something
  63  * like adjust_events_list() which will tune it to the exactly needed number.
  64  * This should be also called after each new plugin loaded. */
  65 #define EVENT_GRANULARITY 0x07
  66
  67 #define realloc_events(ptr, size) \
  68         mem_align_alloc(ptr, (size), (size) + 1, EVENT_GRANULARITY)
  69
  70 static inline int
  71 invalid_event_id(register int id)
  72 {
  73         return (id < 0 || id >= eventssize || id == EVENT_NONE);
  74 }
  75
  76 int
  77 register_event(unsigned char *name)
  78 {
  79         int id = get_event_id(name);
  80         struct event *event;
  81         int namelen;
  82
  83         if (id != EVENT_NONE) return id;
  84
  85         event = events;
  86         if (!realloc_events(&events, eventssize)) return EVENT_NONE;
  87
  88         /* If @events got relocated update the hash. */
  89         if (event != events) {
  90                 for (id = 0; id < eventssize; id++) {
  91                         struct hash_item *item;
  92                         int len = strlen(events[id].name);
  93
  94                         item = get_hash_item(event_hash, events[id].name, len);
  95
  96                         if (item) item->value = &events[id];
  97                 }
  98         }
  99
 100         event = &events[eventssize];
 101
 102         namelen = strlen(name);
 103         event->name = memacpy(name, namelen);
 104         if (!event->name) return EVENT_NONE;
 105
 106         if (!add_hash_item(event_hash, event->name, namelen, event)) {
 107                 mem_free(event->name);
 108                 event->name = NULL;
 109                 return EVENT_NONE;
 110         }
 111
 112         event->handlers = NULL;
 113         event->count = 0;
 114         event->id = eventssize++;
 115
 116         return event->id;
 117 }
 118
 119 int
 120 get_event_id(unsigned char *name)
 121 {
 122         struct hash_item *item;
 123         int namelen;
 124
 125         assertm(name && name[0], "Empty or missing event name");
 126         if_assert_failed return EVENT_NONE;
 127
 128         if (!event_hash) return EVENT_NONE;
 129
 130         namelen = strlen(name);
 131         item = get_hash_item(event_hash, name, namelen);
 132         if (item) {
 133                 struct event *event = item->value;
 134
 135                 assertm(event, "Hash item with no value");
 136                 if_assert_failed return EVENT_NONE;
 137
 138                 return event->id;
 139         }
 140
 141         return EVENT_NONE;
 142 }
 143
 144 unsigned char *
 145 get_event_name(int id)
 146 {
 147         if (invalid_event_id(id)) return NULL;
 148
 149         return events[id].name;
 150 }
 151
 152 static void
 153 trigger_event_va(int id, va_list ap_init)
 154 {
 155         int i;
 156         struct event_handler *ev_handler;
 157
 158         if (invalid_event_id(id)) return;
 159
 160         ev_handler = events[id].handlers;
 161         for (i = 0; i < events[id].count; i++, ev_handler++) {
 162                 enum evhook_status ret;
 163                 va_list ap;
 164
 165                 VA_COPY(ap, ap_init);
 166                 ret = ev_handler->callback(ap, ev_handler->data);
 167                 va_end(ap);
 168
 169                 if (ret == EVENT_HOOK_STATUS_LAST) return;
 170         }
 171 }
 172
 173 void
 174 trigger_event(int id, ...)
 175 {
 176         va_list ap;
 177
 178         va_start(ap, id);
 179         trigger_event_va(id, ap);
 180 }
 181
 182 void
 183 trigger_event_name(unsigned char *name, ...)
 184 {
 185         va_list ap;
 186         int id = get_event_id(name);
 187
 188         va_start(ap, name);
 189         trigger_event_va(id, ap);
 190 }
 191
 192 static inline void
 193 move_event_handler(struct event *event, int to, int from)
 194 {
 195         int d = int_max(to, from);
 196
 197         memmove(&event->handlers[to], &event->handlers[from],
 198                 (event->count - d) * sizeof(*event->handlers));
 199 }
 200
 201 int
 202 register_event_hook(int id, event_hook_T callback, int priority, void *data)
 203 {
 204         struct event *event;
 205         int i;
 206
 207         assert(callback);
 208         if_assert_failed return EVENT_NONE;
 209
 210         if (invalid_event_id(id)) return EVENT_NONE;
 211
 212         event = &events[id];
 213
 214         for (i = 0; i < event->count; i++)
 215                 if (event->handlers[i].callback == callback) break;
 216
 217         if (i == event->count) {
 218                 struct event_handler *eh;
 219
 220                 eh = mem_realloc(event->handlers,
 221                                  (event->count + 1) * sizeof(*event->handlers));
 222
 223                 if (!eh) return EVENT_NONE;
 224
 225                 event->handlers = eh;
 226                 event->count++;
 227         } else {
 228                 move_event_handler(event, i, i + 1);
 229         }
 230
 231         for (i = 0; i < event->count - 1; i++)
 232                 if (event->handlers[i].priority < priority) break;
 233
 234         move_event_handler(event, i + 1, i);
 235
 236         event->handlers[i].callback = callback;
 237         event->handlers[i].priority = priority;
 238         event->handlers[i].data = data;
 239
 240         return id;
 241 }
 242
 243 void
 244 unregister_event_hook(int id, event_hook_T callback)
 245 {
 246         struct event *event;
 247
 248         assert(callback);
 249         if_assert_failed return;
 250
 251         if (invalid_event_id(id)) return;
 252
 253         event = &events[id];
 254         if (event->handlers) {
 255                 int i;
 256
 257                 for (i = 0; i < event->count; i++) {
 258                         if (event->handlers[i].callback != callback)
 259                                 continue;
 260
 261                         move_event_handler(event, i, i + 1);
 262                         event->count--;
 263                         if (!event->count) {
 264                                 mem_free(event->handlers);
 265                                 event->handlers = NULL;
 266                         } else {
 267                                 struct event_handler *eh;
 268
 269                                 eh = mem_realloc(event->handlers,
 270                                                  event->count * sizeof(*event->handlers));
 271                                 if (eh) event->handlers = eh;
 272                         }
 273
 274                         break;
 275                 }
 276         }
 277 }
 278
 279 void
 280 register_event_hooks(struct event_hook_info *hooks)
 281 {
 282         int i;
 283
 284         for (i = 0; hooks[i].name; i++) {
 285                 int id = register_event(hooks[i].name);
 286
 287                 if (id == EVENT_NONE) continue;
 288
 289                 register_event_hook(id, hooks[i].callback, hooks[i].priority,
 290                                     hooks[i].data);
 291         }
 292 }
 293
 294 void
 295 unregister_event_hooks(struct event_hook_info *hooks)
 296 {
 297         int i;
 298
 299         for (i = 0; hooks[i].name; i++) {
 300                 int id = get_event_id(hooks[i].name);
 301
 302                 if (id == EVENT_NONE) continue;
 303
 304                 unregister_event_hook(id, hooks[i].callback);
 305         }
 306 }
 307
 308 void
 309 init_event(void)
 310 {
 311         event_hash = init_hash8();
 312 }
 313
 314 void
 315 done_event(void)
 316 {
 317         int i;
 318
 319         for (i = 0; i < eventssize; i++) {
 320                 mem_free_if(events[i].handlers);
 321                 mem_free(events[i].name);
 322         }
 323
 324         mem_free_set(&events, NULL);
 325
 326         if (event_hash) free_hash(&event_hash);
 327         eventssize = 0;
 328 }