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