58515e007e96d60130e3d4dacc63a6c573aa918e
[asterisk/asterisk.git] / main / event.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007, Digium, Inc.
5  *
6  * Russell Bryant <russell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Internal generic event system
22  *
23  * \author Russell Bryant <russell@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <stdlib.h>
31 #include <stdio.h>
32
33 #include "asterisk/event.h"
34 #include "asterisk/linkedlists.h"
35 #include "asterisk/lock.h"
36 #include "asterisk/utils.h"
37
38 /* Only use one thread for now to ensure ordered delivery */
39 #define NUM_EVENT_THREADS 1
40
41 struct ast_event_ie {
42         enum ast_event_ie_type ie_type:16;
43         /*! Total length of the IE payload */
44         uint16_t ie_payload_len;
45         unsigned char ie_payload[0];
46 } __attribute__ ((packed));
47
48 /*!
49  * \brief An event
50  *
51  * \note The format of this structure is important, and can not change, since
52  *       they are sent directly over the network (via IAX2).
53  *
54  */
55 struct ast_event {
56         /*! Event type */
57         enum ast_event_type type:16;
58         /*! Total length of the event */
59         uint16_t event_len:16;
60         /*! The data payload of the event, made up of information elements */
61         unsigned char payload[0];
62 } __attribute__ ((packed));
63
64 struct ast_event_ref {
65         struct ast_event *event;
66         AST_LIST_ENTRY(ast_event_ref) entry;
67 };
68
69 /*! \brief data shared between event dispatching threads */
70 static struct {
71         ast_cond_t cond;
72         ast_mutex_t lock;
73         AST_LIST_HEAD_NOLOCK(, ast_event_ref) event_q;
74 } event_thread = {
75         .lock = AST_MUTEX_INIT_VALUE,
76 };
77
78 struct ast_event_ie_val {
79         AST_LIST_ENTRY(ast_event_ie_val) entry;
80         enum ast_event_ie_type ie_type;
81         enum ast_event_ie_pltype ie_pltype;
82         union {
83                 uint32_t uint;
84                 const char *str;
85         } payload;
86 };
87
88 /*! \brief Event subscription */
89 struct ast_event_sub {
90         enum ast_event_type type;
91         ast_event_cb_t cb;
92         void *userdata;
93         uint32_t uniqueid;
94         AST_LIST_HEAD_NOLOCK(, ast_event_ie_val) ie_vals;
95         AST_RWLIST_ENTRY(ast_event_sub) entry;
96 };
97
98 static uint32_t sub_uniqueid;
99
100 /*! \brief Event subscriptions
101  * The event subscribers are indexed by which event they are subscribed to */
102 static AST_RWLIST_HEAD(ast_event_sub_list, ast_event_sub) ast_event_subs[AST_EVENT_TOTAL];
103
104 /*! \brief Cached events
105  * The event cache is indexed on the event type.  The purpose of this is 
106  * for events that express some sort of state.  So, when someone first
107  * needs to know this state, it can get the last known state from the cache. */
108 static AST_RWLIST_HEAD(ast_event_ref_list, ast_event_ref) ast_event_cache[AST_EVENT_TOTAL];
109
110 static void ast_event_ie_val_destroy(struct ast_event_ie_val *ie_val)
111 {
112         if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR)
113                 ast_free((void *) ie_val->payload.str);
114
115         ast_free(ie_val);
116 }
117
118 enum ast_event_subscriber_res ast_event_check_subscriber(enum ast_event_type type, ...)
119 {
120         va_list ap;
121         enum ast_event_ie_type ie_type;
122         enum ast_event_subscriber_res res = AST_EVENT_SUB_NONE;
123         struct ast_event_ie_val *ie_val, *sub_ie_val;
124         struct ast_event_sub *sub;
125         AST_LIST_HEAD_NOLOCK_STATIC(ie_vals, ast_event_ie_val);
126
127         if (type >= AST_EVENT_TOTAL) {
128                 ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
129                 return res;
130         }
131
132         va_start(ap, type);
133         for (ie_type = va_arg(ap, enum ast_event_type);
134                 ie_type != AST_EVENT_IE_END;
135                 ie_type = va_arg(ap, enum ast_event_type))
136         {
137                 struct ast_event_ie_val *ie_val = alloca(sizeof(*ie_val));
138                 memset(ie_val, 0, sizeof(*ie_val));
139                 ie_val->ie_type = ie_type;
140                 ie_val->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
141                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT)
142                         ie_val->payload.uint = va_arg(ap, uint32_t);
143                 else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR)
144                         ie_val->payload.str = ast_strdupa(va_arg(ap, const char *));
145                 AST_LIST_INSERT_TAIL(&ie_vals, ie_val, entry);
146         }
147         va_end(ap);
148
149         AST_RWLIST_RDLOCK(&ast_event_subs[type]);
150         AST_RWLIST_TRAVERSE(&ast_event_subs[type], sub, entry) {
151                 AST_LIST_TRAVERSE(&ie_vals, ie_val, entry) {
152                         AST_LIST_TRAVERSE(&sub->ie_vals, sub_ie_val, entry) {
153                                 if (sub_ie_val->ie_type == ie_val->ie_type)
154                                         break;
155                         }
156                         if (!sub_ie_val) {
157                                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS)
158                                         break;
159                                 continue;
160                         }
161                         /* The subscriber doesn't actually care what the value is */
162                         if (sub_ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS)
163                                 continue;
164                         if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT &&
165                                 ie_val->payload.uint != sub_ie_val->payload.uint)
166                                 break;
167                         if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR &&
168                                 strcmp(ie_val->payload.str, sub_ie_val->payload.str))
169                                 break;
170                 }
171                 if (!ie_val)
172                         break;
173         }
174         AST_RWLIST_UNLOCK(&ast_event_subs[type]);
175
176         if (sub) /* All parameters were matched */
177                 return AST_EVENT_SUB_EXISTS;
178
179         AST_RWLIST_RDLOCK(&ast_event_subs[AST_EVENT_ALL]);
180         if (!AST_LIST_EMPTY(&ast_event_subs[AST_EVENT_ALL]))
181                 res = AST_EVENT_SUB_EXISTS;
182         AST_RWLIST_UNLOCK(&ast_event_subs[AST_EVENT_ALL]);
183
184         return res;
185 }
186
187 /*! \brief Send AST_EVENT_SUB events to this subscriber of ... subscriber events */
188 void ast_event_report_subs(const struct ast_event_sub *event_sub)
189 {
190         struct ast_event *event;
191         struct ast_event_sub *sub;
192         enum ast_event_type event_type = -1;
193         struct ast_event_ie_val *ie_val;
194
195         if (event_sub->type != AST_EVENT_SUB)
196                 return;
197
198         AST_LIST_TRAVERSE(&event_sub->ie_vals, ie_val, entry) {
199                 if (ie_val->ie_type == AST_EVENT_IE_EVENTTYPE) {
200                         event_type = ie_val->payload.uint;
201                         break;
202                 }
203         }
204
205         if (event_type == -1)
206                 return;
207
208         AST_RWLIST_RDLOCK(&ast_event_subs[event_type]);
209         AST_RWLIST_TRAVERSE(&ast_event_subs[event_type], sub, entry) {
210                 if (event_sub == sub)
211                         continue;
212
213                 event = ast_event_new(AST_EVENT_SUB,
214                         AST_EVENT_IE_UNIQUEID,  AST_EVENT_IE_PLTYPE_UINT, sub->uniqueid,
215                         AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
216                         AST_EVENT_IE_END);
217
218                 AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
219                         switch (ie_val->ie_pltype) {
220                         case AST_EVENT_IE_PLTYPE_EXISTS:
221                                 ast_event_append_ie_uint(&event, AST_EVENT_IE_EXISTS, ie_val->ie_type);
222                                 break;
223                         case AST_EVENT_IE_PLTYPE_UINT:
224                                 ast_event_append_ie_uint(&event, ie_val->ie_type, ie_val->payload.uint);
225                                 break;
226                         case AST_EVENT_IE_PLTYPE_STR:
227                                 ast_event_append_ie_str(&event, ie_val->ie_type, ie_val->payload.str);
228                                 break;
229                         }
230                         if (!event)
231                                 break;
232                 }
233
234                 if (!event)
235                         continue;
236
237                 event_sub->cb(event, event_sub->userdata);
238
239                 ast_event_destroy(event);
240         }
241         AST_RWLIST_UNLOCK(&ast_event_subs[event_type]);
242 }
243
244 struct ast_event_sub *ast_event_subscribe(enum ast_event_type type, ast_event_cb_t cb, 
245         void *userdata, ...)
246 {
247         va_list ap;
248         enum ast_event_ie_type ie_type;
249         struct ast_event_sub *sub;
250         struct ast_event *event;
251
252         if (type >= AST_EVENT_TOTAL) {
253                 ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
254                 return NULL;
255         }
256
257         if (!(sub = ast_calloc(1, sizeof(*sub))))
258                 return NULL;
259
260         va_start(ap, userdata);
261         for (ie_type = va_arg(ap, enum ast_event_type);
262                 ie_type != AST_EVENT_IE_END;
263                 ie_type = va_arg(ap, enum ast_event_type))
264         {
265                 struct ast_event_ie_val *ie_val;
266                 if (!(ie_val = ast_calloc(1, sizeof(*ie_val))))
267                         continue;
268                 ie_val->ie_type = ie_type;
269                 ie_val->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
270                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT)
271                         ie_val->payload.uint = va_arg(ap, uint32_t);
272                 else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR) {
273                         if (!(ie_val->payload.str = ast_strdup(va_arg(ap, const char *)))) {
274                                 ast_free(ie_val);
275                                 continue;
276                         }
277                 }
278                 AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
279         }
280         va_end(ap);
281
282         sub->type = type;
283         sub->cb = cb;
284         sub->userdata = userdata;
285         sub->uniqueid = ast_atomic_fetchadd_int((int *) &sub_uniqueid, 1);
286
287         if (ast_event_check_subscriber(AST_EVENT_SUB,
288                 AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, type,
289                 AST_EVENT_IE_END) != AST_EVENT_SUB_NONE) {
290                 struct ast_event_ie_val *ie_val;
291
292                 event = ast_event_new(AST_EVENT_SUB,
293                         AST_EVENT_IE_UNIQUEID,  AST_EVENT_IE_PLTYPE_UINT, sub->uniqueid,
294                         AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
295                         AST_EVENT_IE_END);
296
297                 AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
298                         switch (ie_val->ie_pltype) {
299                         case AST_EVENT_IE_PLTYPE_EXISTS:
300                                 ast_event_append_ie_uint(&event, AST_EVENT_IE_EXISTS, ie_val->ie_type);
301                                 break;
302                         case AST_EVENT_IE_PLTYPE_UINT:
303                                 ast_event_append_ie_uint(&event, ie_val->ie_type, ie_val->payload.uint);
304                                 break;
305                         case AST_EVENT_IE_PLTYPE_STR:
306                                 ast_event_append_ie_str(&event, ie_val->ie_type, ie_val->payload.str);
307                                 break;
308                         }
309                         if (!event)
310                                 break;
311                 }
312
313                 if (event)
314                         ast_event_queue(event);
315         }
316
317         AST_RWLIST_WRLOCK(&ast_event_subs[type]);
318         AST_RWLIST_INSERT_TAIL(&ast_event_subs[type], sub, entry);
319         AST_RWLIST_UNLOCK(&ast_event_subs[type]);
320
321         return sub;
322 }
323
324 static void ast_event_sub_destroy(struct ast_event_sub *sub)
325 {
326         struct ast_event_ie_val *ie_val;
327
328         while ((ie_val = AST_LIST_REMOVE_HEAD(&sub->ie_vals, entry)))
329                 ast_event_ie_val_destroy(ie_val);
330
331         ast_free(sub);
332 }
333
334 void ast_event_unsubscribe(struct ast_event_sub *sub)
335 {
336         struct ast_event *event;
337
338         AST_RWLIST_WRLOCK(&ast_event_subs[sub->type]);
339         AST_LIST_REMOVE(&ast_event_subs[sub->type], sub, entry);
340         AST_RWLIST_UNLOCK(&ast_event_subs[sub->type]);
341
342         if (ast_event_check_subscriber(AST_EVENT_UNSUB,
343                 AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
344                 AST_EVENT_IE_END) != AST_EVENT_SUB_NONE) {
345                 
346                 event = ast_event_new(AST_EVENT_UNSUB,
347                         AST_EVENT_IE_UNIQUEID,  AST_EVENT_IE_PLTYPE_UINT, sub->uniqueid,
348                         AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
349                         AST_EVENT_IE_END);
350
351                 if (event)
352                         ast_event_queue(event);
353         }
354
355         ast_event_sub_destroy(sub);
356 }
357
358 enum ast_event_type ast_event_get_type(const struct ast_event *event)
359 {
360         return ntohs(event->type);
361 }
362
363 uint32_t ast_event_get_ie_uint(const struct ast_event *event, enum ast_event_ie_type ie_type)
364 {
365         const uint32_t *ie_val;
366
367         ie_val = ast_event_get_ie_raw(event, ie_type);
368
369         return ie_val ? ntohl(*ie_val) : 0;
370 }
371
372 const char *ast_event_get_ie_str(const struct ast_event *event, enum ast_event_ie_type ie_type)
373 {
374         return ast_event_get_ie_raw(event, ie_type);
375 }
376
377 const void *ast_event_get_ie_raw(const struct ast_event *event, enum ast_event_ie_type ie_type)
378 {
379         struct ast_event_ie *ie;
380         uint16_t event_len;
381
382         ie_type = ntohs(ie_type);
383         event_len = ntohs(event->event_len);
384
385         ie = ((void *) event) + sizeof(*event);
386
387         while ((((void *) ie) - ((void *) event)) < event_len) {
388                 if (ie->ie_type == ie_type)
389                         return ie->ie_payload;
390                 ie = ((void *) ie) + sizeof(*ie) + ntohs(ie->ie_payload_len);
391         }
392
393         return NULL;
394 }
395
396 int ast_event_append_ie_str(struct ast_event **event, enum ast_event_ie_type ie_type,
397         const char *str)
398 {
399         return ast_event_append_ie_raw(event, ie_type, str, strlen(str) + 1);
400 }
401
402 int ast_event_append_ie_uint(struct ast_event **event, enum ast_event_ie_type ie_type,
403         uint32_t data)
404 {
405         data = htonl(data);
406         return ast_event_append_ie_raw(event, ie_type, &data, sizeof(data));
407 }
408
409 int ast_event_append_ie_raw(struct ast_event **event, enum ast_event_ie_type ie_type,
410         const void *data, size_t data_len)
411 {
412         struct ast_event_ie *ie;
413         unsigned int extra_len;
414         uint16_t event_len;
415
416         event_len = ntohs((*event)->event_len);
417         extra_len = sizeof(*ie) + data_len;
418
419         if (!(*event = ast_realloc(*event, event_len + extra_len)))
420                 return -1;
421
422         ie = ((void *) *event) + event_len;
423         ie->ie_type = htons(ie_type);
424         ie->ie_payload_len = htons(data_len);
425         memcpy(ie->ie_payload, data, data_len);
426
427         (*event)->event_len = htons(event_len + extra_len);
428
429         return 0;
430 }
431
432 struct ast_event *ast_event_new(enum ast_event_type type, ...)
433 {
434         va_list ap;
435         struct ast_event *event;
436         enum ast_event_type ie_type;
437         struct ast_event_ie_val *ie_val;
438         AST_LIST_HEAD_NOLOCK_STATIC(ie_vals, ast_event_ie_val);
439
440         /* Invalid type */
441         if (type >= AST_EVENT_TOTAL) {
442                 ast_log(LOG_WARNING, "Someone tried to create an event of invalid "
443                         "type '%d'!\n", type);
444                 return NULL;
445         }
446
447         va_start(ap, type);
448         for (ie_type = va_arg(ap, enum ast_event_type);
449                 ie_type != AST_EVENT_IE_END;
450                 ie_type = va_arg(ap, enum ast_event_type))
451         {
452                 struct ast_event_ie_val *ie_val = alloca(sizeof(*ie_val));
453                 memset(ie_val, 0, sizeof(*ie_val));
454                 ie_val->ie_type = ie_type;
455                 ie_val->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
456                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT)
457                         ie_val->payload.uint = va_arg(ap, uint32_t);
458                 else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR)
459                         ie_val->payload.str = ast_strdupa(va_arg(ap, const char *));
460                 AST_LIST_INSERT_TAIL(&ie_vals, ie_val, entry);
461         }
462         va_end(ap);
463
464         if (!(event = ast_calloc(1, sizeof(*event))))
465                 return NULL;
466
467         event->type = htons(type);
468         event->event_len = htons(sizeof(*event));
469
470         AST_LIST_TRAVERSE(&ie_vals, ie_val, entry) {
471                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR)
472                         ast_event_append_ie_str(&event, ie_val->ie_type, ie_val->payload.str);
473                 else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT)
474                         ast_event_append_ie_uint(&event, ie_val->ie_type, ie_val->payload.uint);
475
476                 if (!event)
477                         break;
478         }
479
480         return event;
481 }
482
483 void ast_event_destroy(struct ast_event *event)
484 {
485         ast_free(event);
486 }
487
488 static void ast_event_ref_destroy(struct ast_event_ref *event_ref)
489 {
490         ast_event_destroy(event_ref->event);
491         ast_free(event_ref);
492 }
493
494 static struct ast_event *ast_event_dup(const struct ast_event *event)
495 {
496         struct ast_event *dup_event;
497         uint16_t event_len;
498
499         event_len = ntohs(event->event_len);
500
501         if (!(dup_event = ast_calloc(1, event_len)))
502                 return NULL;
503         
504         memcpy(dup_event, event, event_len);
505
506         return dup_event;
507 }
508
509 struct ast_event *ast_event_get_cached(enum ast_event_type type, ...)
510 {
511         va_list ap;
512         enum ast_event_ie_type ie_type;
513         struct ast_event *dup_event = NULL;
514         struct ast_event_ref *event_ref;
515         struct cache_arg {
516                 AST_LIST_ENTRY(cache_arg) entry;
517                 enum ast_event_ie_type ie_type;
518                 enum ast_event_ie_pltype ie_pltype;
519                 union {
520                         uint32_t uint;
521                         const char *str;
522                 } payload;
523         } *cache_arg;
524         AST_LIST_HEAD_NOLOCK_STATIC(cache_args, cache_arg);
525
526         if (type >= AST_EVENT_TOTAL) {
527                 ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
528                 return NULL;
529         }
530
531         va_start(ap, type);
532         for (ie_type = va_arg(ap, enum ast_event_type);
533                 ie_type != AST_EVENT_IE_END;
534                 ie_type = va_arg(ap, enum ast_event_type))
535         {
536                 cache_arg = alloca(sizeof(*cache_arg));
537                 memset(cache_arg, 0, sizeof(*cache_arg));
538                 cache_arg->ie_type = ie_type;
539                 cache_arg->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
540                 if (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_UINT)
541                         cache_arg->payload.uint = va_arg(ap, uint32_t);
542                 else if (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_STR)
543                         cache_arg->payload.str = ast_strdupa(va_arg(ap, const char *));
544                 AST_LIST_INSERT_TAIL(&cache_args, cache_arg, entry);
545         }
546         va_end(ap);
547
548         if (AST_LIST_EMPTY(&cache_args)) {
549                 ast_log(LOG_ERROR, "Events can not be retrieved from the cache without "
550                         "specifying at least one IE type!\n");
551                 return NULL;
552         }
553
554         AST_RWLIST_RDLOCK(&ast_event_cache[type]);
555         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&ast_event_cache[type], event_ref, entry) {
556                 AST_LIST_TRAVERSE(&cache_args, cache_arg, entry) {
557                         if ( ! ( (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_UINT &&
558                            (cache_arg->payload.uint ==
559                             ast_event_get_ie_uint(event_ref->event, cache_arg->ie_type))) ||
560
561                            (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_STR &&
562                            (!strcmp(cache_arg->payload.str,
563                              ast_event_get_ie_str(event_ref->event, cache_arg->ie_type)))) ||
564
565                            (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS &&
566                             ast_event_get_ie_raw(event_ref->event, cache_arg->ie_type)) ) ) 
567                         {
568                                 break;  
569                         }
570                 }
571                 if (!cache_arg) {
572                         /* All parameters were matched on this cache entry, so return it */
573                         dup_event = ast_event_dup(event_ref->event);
574                         break;
575                 }
576         }
577         AST_RWLIST_TRAVERSE_SAFE_END
578         AST_RWLIST_UNLOCK(&ast_event_cache[type]);
579
580         return dup_event;
581 }
582
583 /*! \brief Duplicate an event and add it to the cache
584  * \note This assumes this index in to the cache is locked */
585 static int ast_event_dup_and_cache(const struct ast_event *event)
586 {
587         struct ast_event *dup_event;
588         struct ast_event_ref *event_ref;
589
590         if (!(dup_event = ast_event_dup(event)))
591                 return -1;
592         if (!(event_ref = ast_calloc(1, sizeof(*event_ref))))
593                 return -1;
594         
595         event_ref->event = dup_event;
596
597         AST_LIST_INSERT_TAIL(&ast_event_cache[ntohs(event->type)], event_ref, entry);
598
599         return 0;
600 }
601
602 int ast_event_queue_and_cache(struct ast_event *event, ...)
603 {
604         va_list ap;
605         enum ast_event_type ie_type;
606         uint16_t host_event_type;
607         struct ast_event_ref *event_ref;
608         int res;
609         struct cache_arg {
610                 AST_LIST_ENTRY(cache_arg) entry;
611                 enum ast_event_ie_type ie_type;
612                 enum ast_event_ie_pltype ie_pltype;
613         } *cache_arg;
614         AST_LIST_HEAD_NOLOCK_STATIC(cache_args, cache_arg);
615
616         host_event_type = ntohs(event->type);
617
618         /* Invalid type */
619         if (host_event_type >= AST_EVENT_TOTAL) {
620                 ast_log(LOG_WARNING, "Someone tried to queue an event of invalid "
621                         "type '%d'!\n", host_event_type);
622                 return -1;
623         }
624
625         va_start(ap, event);
626         for (ie_type = va_arg(ap, enum ast_event_type);
627                 ie_type != AST_EVENT_IE_END;
628                 ie_type = va_arg(ap, enum ast_event_type))
629         {
630                 cache_arg = alloca(sizeof(*cache_arg));
631                 memset(cache_arg, 0, sizeof(*cache_arg));
632                 cache_arg->ie_type = ie_type;
633                 cache_arg->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
634                 AST_LIST_INSERT_TAIL(&cache_args, cache_arg, entry);
635         }
636         va_end(ap);
637
638         if (AST_LIST_EMPTY(&cache_args)) {
639                 ast_log(LOG_ERROR, "Events can not be cached without specifying at "
640                         "least one IE type!\n");
641                 return ast_event_queue(event);
642         }
643  
644         AST_RWLIST_WRLOCK(&ast_event_cache[host_event_type]);
645         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&ast_event_cache[host_event_type], event_ref, entry) {
646                 AST_LIST_TRAVERSE(&cache_args, cache_arg, entry) {
647                         if ( ! ( (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_UINT &&
648                            (ast_event_get_ie_uint(event, cache_arg->ie_type) ==
649                             ast_event_get_ie_uint(event_ref->event, cache_arg->ie_type))) ||
650
651                            (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_STR &&
652                            (!strcmp(ast_event_get_ie_str(event, cache_arg->ie_type),
653                              ast_event_get_ie_str(event_ref->event, cache_arg->ie_type)))) ||
654
655                            (cache_arg->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS &&
656                             ast_event_get_ie_raw(event_ref->event, cache_arg->ie_type)) ) )
657                         {
658                                 break;  
659                         }
660                 }
661                 if (!cache_arg) {
662                         /* All parameters were matched on this cache entry, so remove it */
663                         AST_LIST_REMOVE_CURRENT(&ast_event_cache[host_event_type], entry);
664                         ast_event_ref_destroy(event_ref);
665                 }
666         }
667         AST_RWLIST_TRAVERSE_SAFE_END
668         res = ast_event_dup_and_cache(event);
669         AST_RWLIST_UNLOCK(&ast_event_cache[host_event_type]);
670
671         return (ast_event_queue(event) || res) ? -1 : 0;
672 }
673
674 int ast_event_queue(struct ast_event *event)
675 {
676         struct ast_event_ref *event_ref;
677         uint16_t host_event_type;
678
679         host_event_type = ntohs(event->type);
680
681         /* Invalid type */
682         if (host_event_type >= AST_EVENT_TOTAL) {
683                 ast_log(LOG_WARNING, "Someone tried to queue an event of invalid "
684                         "type '%d'!\n", host_event_type);
685                 return -1;
686         }
687
688         /* If nobody has subscribed to this event type, throw it away now */
689         if (ast_event_check_subscriber(host_event_type, AST_EVENT_IE_END) 
690                 == AST_EVENT_SUB_NONE) {
691                 ast_event_destroy(event);
692                 return 0;
693         }
694
695         if (!(event_ref = ast_calloc(1, sizeof(*event_ref))))
696                 return -1;
697
698         event_ref->event = event;
699
700         ast_mutex_lock(&event_thread.lock);
701         AST_LIST_INSERT_TAIL(&event_thread.event_q, event_ref, entry);
702         ast_cond_signal(&event_thread.cond);
703         ast_mutex_unlock(&event_thread.lock);
704
705         return 0;
706 }
707
708 static void *ast_event_dispatcher(void *unused)
709 {
710         for (;;) {
711                 struct ast_event_ref *event_ref;
712                 struct ast_event_sub *sub;
713                 uint16_t host_event_type;
714
715                 ast_mutex_lock(&event_thread.lock);
716                 while (!(event_ref = AST_LIST_REMOVE_HEAD(&event_thread.event_q, entry)))
717                         ast_cond_wait(&event_thread.cond, &event_thread.lock);
718                 ast_mutex_unlock(&event_thread.lock);
719
720                 host_event_type = ntohs(event_ref->event->type);
721
722                 /* Subscribers to this specific event first */
723                 AST_RWLIST_RDLOCK(&ast_event_subs[host_event_type]);
724                 AST_RWLIST_TRAVERSE(&ast_event_subs[host_event_type], sub, entry) {
725                         struct ast_event_ie_val *ie_val;
726                         AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
727                                 if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS &&
728                                         ast_event_get_ie_raw(event_ref->event, ie_val->ie_type)) {
729                                         continue;
730                                 } else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_UINT &&
731                                         ast_event_get_ie_uint(event_ref->event, ie_val->ie_type) 
732                                         == ie_val->payload.uint) {
733                                         continue;
734                                 } else if (ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_STR &&
735                                         !strcmp(ast_event_get_ie_str(event_ref->event, ie_val->ie_type),
736                                                 ie_val->payload.str)) {
737                                         continue;
738                                 }
739                                 break;
740                         }
741                         if (ie_val)
742                                 continue;
743                         sub->cb(event_ref->event, sub->userdata);
744                 }
745                 AST_RWLIST_UNLOCK(&ast_event_subs[host_event_type]);
746
747                 /* Now to subscribers to all event types */
748                 AST_RWLIST_RDLOCK(&ast_event_subs[AST_EVENT_ALL]);
749                 AST_RWLIST_TRAVERSE(&ast_event_subs[AST_EVENT_ALL], sub, entry)
750                         sub->cb(event_ref->event, sub->userdata);
751                 AST_RWLIST_UNLOCK(&ast_event_subs[AST_EVENT_ALL]);
752
753                 ast_event_ref_destroy(event_ref);
754         }
755
756         return NULL;
757 }
758
759 void ast_event_init(void)
760 {
761         int i;
762
763         for (i = 0; i < AST_EVENT_TOTAL; i++)
764                 AST_RWLIST_HEAD_INIT(&ast_event_subs[i]);
765
766         for (i = 0; i < AST_EVENT_TOTAL; i++)
767                 AST_RWLIST_HEAD_INIT(&ast_event_cache[i]);
768
769         ast_cond_init(&event_thread.cond, NULL);
770
771         for (i = 0; i < NUM_EVENT_THREADS; i++) {
772                 pthread_t dont_care;
773                 ast_pthread_create_background(&dont_care, NULL, ast_event_dispatcher, NULL);
774         }
775 }