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