Mon Mar 19 11:30:47 2012

Asterisk developer's documentation


event.c File Reference

Internal generic event system. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/event.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dlinkedlists.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/unaligned.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/astobj2.h"
#include "asterisk/cli.h"

Go to the source code of this file.

Data Structures

struct  ast_ev_check_list
 Subscription event check list. More...
struct  ast_event
 An event. More...
struct  ast_event_ie
 An event information element. More...
struct  ast_event_ie_str_payload
 The payload for a string information element. More...
struct  ast_event_ie_val
struct  ast_event_ref
 A holder for an event. More...
struct  ast_event_sub
 Event subscription. More...
struct  ast_event_sub_list
 Event subscriptions The event subscribers are indexed by which event they are subscribed to. More...
struct  ie_map
 IE payload types and names. More...

Defines

#define MAX_CACHE_ARGS   8
#define NUM_CACHE_BUCKETS   563

Functions

static struct ast_event_refalloc_event_ref (void)
int ast_event_append_eid (struct ast_event **event)
 Append the global EID IE.
int ast_event_append_ie_bitflags (struct ast_event **event, enum ast_event_ie_type ie_type, uint32_t flags)
 Append an information element that has a bitflags payload.
int ast_event_append_ie_raw (struct ast_event **event, enum ast_event_ie_type ie_type, const void *data, size_t data_len)
 Append an information element that has a raw payload.
int ast_event_append_ie_str (struct ast_event **event, enum ast_event_ie_type ie_type, const char *str)
 Append an information element that has a string payload.
int ast_event_append_ie_uint (struct ast_event **event, enum ast_event_ie_type ie_type, uint32_t data)
 Append an information element that has an integer payload.
enum ast_event_subscriber_res ast_event_check_subscriber (enum ast_event_type type,...)
 Check if subscribers exist.
static int ast_event_cmp (void *obj, void *arg, int flags)
void ast_event_destroy (struct ast_event *event)
 Destroy an event.
void ast_event_dump_cache (const struct ast_event_sub *event_sub)
 Dump the event cache for the subscriber.
static struct ast_eventast_event_dup (const struct ast_event *event)
ast_eventast_event_get_cached (enum ast_event_type type,...)
 Retrieve an event from the cache.
uint32_t ast_event_get_ie_bitflags (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the value of an information element that has a bitflags payload.
enum ast_event_ie_pltype ast_event_get_ie_pltype (enum ast_event_ie_type ie_type)
 Get the payload type for a given information element type.
const void * ast_event_get_ie_raw (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the value of an information element that has a raw payload.
uint16_t ast_event_get_ie_raw_payload_len (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the length of the raw payload for a particular IE.
const char * ast_event_get_ie_str (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the value of an information element that has a string payload.
uint32_t ast_event_get_ie_str_hash (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the hash for the string payload of an IE.
const char * ast_event_get_ie_type_name (enum ast_event_ie_type ie_type)
 Get the string representation of an information element type.
uint32_t ast_event_get_ie_uint (const struct ast_event *event, enum ast_event_ie_type ie_type)
 Get the value of an information element that has an integer payload.
size_t ast_event_get_size (const struct ast_event *event)
 Get the size of an event.
enum ast_event_type ast_event_get_type (const struct ast_event *event)
 Get the type for an event.
const char * ast_event_get_type_name (const struct ast_event *event)
 Get the string representation of the type of the given event.
static int ast_event_hash (const void *obj, const int flags)
static int ast_event_hash_devstate (const void *obj, const int flags)
static int ast_event_hash_devstate_change (const void *obj, const int flags)
static int ast_event_hash_mwi (const void *obj, const int flags)
static void ast_event_ie_val_destroy (struct ast_event_ie_val *ie_val)
int ast_event_init (void)
uint32_t ast_event_iterator_get_ie_bitflags (struct ast_event_iterator *iterator)
 Get the value of the current IE in the iterator as a bitflags payload.
void * ast_event_iterator_get_ie_raw (struct ast_event_iterator *iterator)
 Get the value of the current IE in the iterator instance that has a raw payload.
uint16_t ast_event_iterator_get_ie_raw_payload_len (struct ast_event_iterator *iterator)
 Get the length of the raw payload for the current IE for an iterator.
const char * ast_event_iterator_get_ie_str (struct ast_event_iterator *iterator)
 Get the value of the current IE in the iterator as a string payload.
enum ast_event_ie_type ast_event_iterator_get_ie_type (struct ast_event_iterator *iterator)
 Get the type of the current IE in the iterator instance.
uint32_t ast_event_iterator_get_ie_uint (struct ast_event_iterator *iterator)
 Get the value of the current IE in the iterator as an integer payload.
int ast_event_iterator_init (struct ast_event_iterator *iterator, const struct ast_event *event)
 Initialize an event iterator instance.
int ast_event_iterator_next (struct ast_event_iterator *iterator)
 Move iterator instance to next IE.
size_t ast_event_minimum_length (void)
 Get the minimum length of an ast_event.
ast_eventast_event_new (enum ast_event_type type,...)
 Create a new event.
int ast_event_queue (struct ast_event *event)
 Queue an event.
int ast_event_queue_and_cache (struct ast_event *event)
 Queue and cache an event.
static void ast_event_ref_destroy (void *obj)
void ast_event_report_subs (const struct ast_event_sub *event_sub)
 Report current subscriptions to a subscription subscriber.
int ast_event_str_to_event_type (const char *str, enum ast_event_type *event_type)
 Convert a string into an event type.
int ast_event_str_to_ie_type (const char *str, enum ast_event_ie_type *ie_type)
 Convert a string to an IE type.
int ast_event_sub_activate (struct ast_event_sub *sub)
 Activate a dynamically built subscription.
int ast_event_sub_append_ie_bitflags (struct ast_event_sub *sub, enum ast_event_ie_type ie_type, uint32_t flags)
 Append a bitflags parameter to a subscription.
int ast_event_sub_append_ie_exists (struct ast_event_sub *sub, enum ast_event_ie_type ie_type)
 Append an 'exists' parameter to a subscription.
int ast_event_sub_append_ie_raw (struct ast_event_sub *sub, enum ast_event_ie_type ie_type, void *data, size_t raw_datalen)
 Append a raw parameter to a subscription.
int ast_event_sub_append_ie_str (struct ast_event_sub *sub, enum ast_event_ie_type ie_type, const char *str)
 Append a string parameter to a subscription.
int ast_event_sub_append_ie_uint (struct ast_event_sub *sub, enum ast_event_ie_type ie_type, uint32_t unsigned_int)
 Append a uint parameter to a subscription.
void ast_event_sub_destroy (struct ast_event_sub *sub)
 Destroy an allocated subscription.
ast_event_subast_event_subscribe (enum ast_event_type type, ast_event_cb_t cb, const char *description, void *userdata,...)
 Subscribe to events.
ast_event_subast_event_subscribe_new (enum ast_event_type type, ast_event_cb_t cb, void *userdata)
 Allocate a subscription, but do not activate it.
const char * ast_event_subscriber_get_description (struct ast_event_sub *sub)
 Get description for a subscription.
ast_event_subast_event_unsubscribe (struct ast_event_sub *sub)
 Un-subscribe from events.
static int dump_cache_cb (void *obj, void *arg, int flags)
static void dump_raw_ie (struct ast_event_iterator *i, struct ast_cli_args *a)
static char * event_dump_cache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int event_dump_cli (void *obj, void *arg, int flags)
static void event_update_cache (struct ao2_container *cache, struct ast_event *event)
static struct ast_eventgen_sub_event (struct ast_event_sub *sub)
static int handle_event (void *data)
static int match_ie_val (const struct ast_event *event, const struct ast_event_ie_val *ie_val, const struct ast_event *event2)
static int match_sub_ie_val_to_event (const struct ast_event_ie_val *sub_ie_val, const struct ast_ev_check_list *check_ie_vals)

Variables

struct {
   enum ast_event_ie_type   cache_args [MAX_CACHE_ARGS]
 Information Elements used for caching.
   ao2_container *   container
 Container of cached events.
   ao2_hash_fn *   hash_fn
 Event type specific hash function.
ast_event_cache [AST_EVENT_TOTAL]
 Event types that are kept in the cache.
static struct ast_event_sub_list ast_event_subs [AST_EVENT_TOTAL]
 Event subscriptions The event subscribers are indexed by which event they are subscribed to.
static const char *const cached_event_types [] = { "MWI", "DeviceState", "DeviceStateChange", NULL }
 Names of cached event types, for CLI tab completion.
static struct ast_cli_entry event_cli []
static struct ast_taskprocessorevent_dispatcher
static const char *const event_names [AST_EVENT_TOTAL]
 Event Names.
static struct ie_map ie_maps [AST_EVENT_IE_TOTAL]
 IE payload types and names.
static uint32_t sub_uniqueid


Detailed Description

Internal generic event system.

Author:
Russell Bryant <russell@digium.com>

Definition in file event.c.


Define Documentation

#define MAX_CACHE_ARGS   8

Definition at line 147 of file event.c.

#define NUM_CACHE_BUCKETS   563

Definition at line 144 of file event.c.

Referenced by ast_event_init().


Function Documentation

static struct ast_event_ref* alloc_event_ref ( void   )  [static]

Definition at line 1378 of file event.c.

References ao2_alloc, and ast_event_ref_destroy().

Referenced by ast_event_queue(), and event_update_cache().

01379 {
01380    return ao2_alloc(sizeof(struct ast_event_ref), ast_event_ref_destroy);
01381 }

int ast_event_append_eid ( struct ast_event **  event  ) 

Append the global EID IE.

Parameters:
event the event to append IE to
Note:
For ast_event_new() that includes IEs, this is done automatically for you.
Return values:
0 success
-1 failure

Definition at line 1267 of file event.c.

References ast_eid_default, ast_event_append_ie_raw(), and AST_EVENT_IE_EID.

Referenced by ast_event_new().

01268 {
01269    return ast_event_append_ie_raw(event, AST_EVENT_IE_EID,
01270          &ast_eid_default, sizeof(ast_eid_default));
01271 }

int ast_event_append_ie_bitflags ( struct ast_event **  event,
enum ast_event_ie_type  ie_type,
uint32_t  bitflags 
)

Append an information element that has a bitflags payload.

Parameters:
event the event that the IE will be appended to
ie_type the type of IE to append
bitflags the flags that are the payload of the IE
Return values:
0 success
-1 failure
Since:
1.8
The pointer to the event will get updated with the new location for the event that now contains the appended information element. If the re-allocation of the memory for this event fails, it will be set to NULL.

Definition at line 1131 of file event.c.

References ast_event_append_ie_raw().

Referenced by ast_event_get_cached(), ast_event_new(), and gen_sub_event().

01133 {
01134    flags = htonl(flags);
01135    return ast_event_append_ie_raw(event, ie_type, &flags, sizeof(flags));
01136 }

int ast_event_append_ie_raw ( struct ast_event **  event,
enum ast_event_ie_type  ie_type,
const void *  data,
size_t  data_len 
)

Append an information element that has a raw payload.

Parameters:
event the event that the IE will be appended to
ie_type the type of IE to append
data A pointer to the raw data for the payload of the IE
data_len The amount of data to copy into the payload
Return values:
0 success
-1 failure
The pointer to the event will get updated with the new location for the event that now contains the appended information element. If the re-allocation of the memory for this event fails, it will be set to NULL.

Definition at line 1138 of file event.c.

References ast_realloc, ast_event_ie::ie_payload, and ast_event_ie::ie_payload_len.

Referenced by ast_event_append_eid(), ast_event_append_ie_bitflags(), ast_event_append_ie_str(), ast_event_append_ie_uint(), ast_event_get_cached(), ast_event_new(), and gen_sub_event().

01140 {
01141    struct ast_event_ie *ie;
01142    unsigned int extra_len;
01143    uint16_t event_len;
01144 
01145    event_len = ntohs((*event)->event_len);
01146    extra_len = sizeof(*ie) + data_len;
01147 
01148    if (!(*event = ast_realloc(*event, event_len + extra_len))) {
01149       return -1;
01150    }
01151 
01152    ie = (struct ast_event_ie *) ( ((char *) *event) + event_len );
01153    ie->ie_type = htons(ie_type);
01154    ie->ie_payload_len = htons(data_len);
01155    memcpy(ie->ie_payload, data, data_len);
01156 
01157    (*event)->event_len = htons(event_len + extra_len);
01158 
01159    return 0;
01160 }

int ast_event_append_ie_str ( struct ast_event **  event,
enum ast_event_ie_type  ie_type,
const char *  str 
)

Append an information element that has a string payload.

Parameters:
event the event that the IE will be appended to
ie_type the type of IE to append
str The string for the payload of the IE
Return values:
0 success
-1 failure
The pointer to the event will get updated with the new location for the event that now contains the appended information element. If the re-allocation of the memory for this event fails, it will be set to NULL.

Definition at line 1109 of file event.c.

References ast_event_append_ie_raw(), ast_str_hash(), ast_event_ie_str_payload::hash, and ast_event_ie_str_payload::str.

Referenced by add_ie(), add_ipv4_ie(), add_timeval_ie(), ast_event_get_cached(), ast_event_new(), and gen_sub_event().

01111 {
01112    struct ast_event_ie_str_payload *str_payload;
01113    size_t payload_len;
01114 
01115    payload_len = sizeof(*str_payload) + strlen(str);
01116    str_payload = alloca(payload_len);
01117 
01118    strcpy(str_payload->str, str);
01119    str_payload->hash = ast_str_hash(str);
01120 
01121    return ast_event_append_ie_raw(event, ie_type, str_payload, payload_len);
01122 }

int ast_event_append_ie_uint ( struct ast_event **  event,
enum ast_event_ie_type  ie_type,
uint32_t  data 
)

Append an information element that has an integer payload.

Parameters:
event the event that the IE will be appended to
ie_type the type of IE to append
data The integer for the payload of the IE
Return values:
0 success
-1 failure
The pointer to the event will get updated with the new location for the event that now contains the appended information element. If the re-allocation of the memory for this event fails, it will be set to NULL.

Definition at line 1124 of file event.c.

References ast_event_append_ie_raw().

Referenced by add_ie(), ast_event_get_cached(), ast_event_new(), and gen_sub_event().

01126 {
01127    data = htonl(data);
01128    return ast_event_append_ie_raw(event, ie_type, &data, sizeof(data));
01129 }

enum ast_event_subscriber_res ast_event_check_subscriber ( enum ast_event_type  event_type,
  ... 
)

Check if subscribers exist.

Parameters:
event_type This is the type of event that the caller would like to check for subscribers to.
The rest of the arguments to this function specify additional parameters for checking for subscriptions to subsets of an event type. The arguments must in sets of:
    <enum ast_event_ie_type>, [enum ast_event_ie_pltype, [payload] ]
and must end with AST_EVENT_IE_END.

If the ie_type specified is *not* AST_EVENT_IE_END, then it must be followed by a valid IE payload type. If the payload type specified is AST_EVENT_IE_PLTYPE_EXISTS, then the 3rd argument should not be provided. Otherwise, a payload must also be specified.

Returns:
This returns one of the values defined in the ast_event_subscriber_res enum which will indicate if subscribers exist that match the given criteria.
Example usage:

This example will check if there are any subscribers to MWI events for the mailbox defined in the "mailbox" variable.

Definition at line 435 of file event.c.

References ARRAY_LEN, AST_EVENT_ALL, AST_EVENT_IE_END, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, AST_EVENT_SUB_EXISTS, AST_EVENT_SUB_NONE, ast_event_subs, AST_LIST_HEAD_NOLOCK_INIT_VALUE, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), AST_RWDLLIST_RDLOCK, AST_RWDLLIST_TRAVERSE, AST_RWDLLIST_UNLOCK, AST_RWLIST_FIRST, ast_event_ie_val::ie_type, ast_event_sub::ie_vals, ast_ev_check_list::ie_vals, LOG_ERROR, LOG_WARNING, and match_sub_ie_val_to_event().

Referenced by ast_event_queue(), ast_event_sub_activate(), and ast_event_unsubscribe().

00436 {
00437    va_list ap;
00438    enum ast_event_ie_type ie_type;
00439    enum ast_event_subscriber_res res = AST_EVENT_SUB_NONE;
00440    struct ast_event_ie_val *ie_val;
00441    struct ast_event_sub *sub;
00442    struct ast_ev_check_list check_ie_vals = {
00443       .ie_vals = AST_LIST_HEAD_NOLOCK_INIT_VALUE
00444    };
00445    const enum ast_event_type event_types[] = { type, AST_EVENT_ALL };
00446    int i;
00447    int want_specific_event;/* TRUE if looking for subscribers wanting specific parameters. */
00448 
00449    if (type >= AST_EVENT_TOTAL) {
00450       ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
00451       return res;
00452    }
00453 
00454    want_specific_event = 0;
00455    va_start(ap, type);
00456    for (ie_type = va_arg(ap, enum ast_event_ie_type);
00457       ie_type != AST_EVENT_IE_END;
00458       ie_type = va_arg(ap, enum ast_event_ie_type))
00459    {
00460       struct ast_event_ie_val *ie_value = alloca(sizeof(*ie_value));
00461       int insert = 0;
00462 
00463       memset(ie_value, 0, sizeof(*ie_value));
00464       ie_value->ie_type = ie_type;
00465       ie_value->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
00466       switch (ie_value->ie_pltype) {
00467       case AST_EVENT_IE_PLTYPE_UINT:
00468          ie_value->payload.uint = va_arg(ap, uint32_t);
00469          insert = 1;
00470          break;
00471       case AST_EVENT_IE_PLTYPE_BITFLAGS:
00472          ie_value->payload.uint = va_arg(ap, uint32_t);
00473          insert = 1;
00474          break;
00475       case AST_EVENT_IE_PLTYPE_STR:
00476          ie_value->payload.str = va_arg(ap, const char *);
00477          insert = 1;
00478          break;
00479       case AST_EVENT_IE_PLTYPE_RAW:
00480       {
00481          void *data = va_arg(ap, void *);
00482          size_t datalen = va_arg(ap, size_t);
00483 
00484          ie_value->payload.raw = alloca(datalen);
00485          memcpy(ie_value->payload.raw, data, datalen);
00486          ie_value->raw_datalen = datalen;
00487          insert = 1;
00488          break;
00489       }
00490       case AST_EVENT_IE_PLTYPE_UNKNOWN:
00491       case AST_EVENT_IE_PLTYPE_EXISTS:
00492          /* Unsupported payload type. */
00493          break;
00494       }
00495 
00496       if (insert) {
00497          want_specific_event = 1;
00498          AST_LIST_INSERT_TAIL(&check_ie_vals.ie_vals, ie_value, entry);
00499       } else {
00500          ast_log(LOG_WARNING, "Unsupported PLTYPE(%d)\n", ie_value->ie_pltype);
00501       }
00502    }
00503    va_end(ap);
00504 
00505    for (i = 0; i < ARRAY_LEN(event_types); i++) {
00506       AST_RWDLLIST_RDLOCK(&ast_event_subs[event_types[i]]);
00507       if (want_specific_event) {
00508          AST_RWDLLIST_TRAVERSE(&ast_event_subs[event_types[i]], sub, entry) {
00509             AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
00510                if (!match_sub_ie_val_to_event(ie_val, &check_ie_vals)) {
00511                   /* The current subscription ie did not match an event ie. */
00512                   break;
00513                }
00514             }
00515             if (!ie_val) {
00516                /* Everything matched.  A subscriber is looking for this event. */
00517                break;
00518             }
00519          }
00520       } else {
00521          /* Just looking to see if there are ANY subscribers to the event type. */
00522          sub = AST_RWLIST_FIRST(&ast_event_subs[event_types[i]]);
00523       }
00524       AST_RWDLLIST_UNLOCK(&ast_event_subs[event_types[i]]);
00525       if (sub) {
00526          break;
00527       }
00528    }
00529 
00530    return sub ? AST_EVENT_SUB_EXISTS : AST_EVENT_SUB_NONE;
00531 }

static int ast_event_cmp ( void *  obj,
void *  arg,
int  flags 
) [static]

Definition at line 1587 of file event.c.

References ARRAY_LEN, ast_event_cache, ast_event_get_ie_pltype(), ast_event_get_type(), cache_args, CMP_MATCH, ast_event_ref::event, and match_ie_val().

Referenced by ast_event_init(), and event_update_cache().

01588 {
01589    struct ast_event_ref *event_ref, *event_ref2;
01590    struct ast_event *event, *event2;
01591    int res = CMP_MATCH;
01592    int i;
01593    enum ast_event_ie_type *cache_args;
01594 
01595    event_ref = obj;
01596    event = event_ref->event;
01597 
01598    event_ref2 = arg;
01599    event2 = event_ref2->event;
01600 
01601    cache_args = ast_event_cache[ast_event_get_type(event)].cache_args;
01602 
01603    for (i = 0; i < ARRAY_LEN(ast_event_cache[0].cache_args) && cache_args[i]; i++) {
01604       struct ast_event_ie_val ie_val = {
01605          .ie_pltype = ast_event_get_ie_pltype(cache_args[i]),
01606          .ie_type = cache_args[i],
01607       };
01608 
01609       if (!match_ie_val(event, &ie_val, event2)) {
01610          res = 0;
01611          break;
01612       }
01613    }
01614 
01615    return res;
01616 }

void ast_event_destroy ( struct ast_event event  ) 

Destroy an event.

Parameters:
event the event to destroy
Returns:
Nothing
Note:
Events that have been queued should *not* be destroyed by the code that created the event. It will be automatically destroyed after being dispatched to the appropriate subscribers.

Definition at line 1273 of file event.c.

References ast_free.

Referenced by ast_cel_report_event(), ast_event_get_cached(), ast_event_queue(), ast_event_queue_and_cache(), ast_event_ref_destroy(), ast_event_report_subs(), ast_event_sub_activate(), ast_event_unsubscribe(), devstate_cached(), event_update_cache(), get_cached_mwi(), handle_security_event(), has_voicemail(), process_collection(), sig_pri_mwi_cache_update(), stun_monitor_request(), unistim_send_mwi_to_peer(), and update_registry().

01274 {
01275    ast_free(event);
01276 }

void ast_event_dump_cache ( const struct ast_event_sub event_sub  ) 

Dump the event cache for the subscriber.

Since:
1.6.1

Definition at line 630 of file event.c.

References ao2_callback, ast_event_cache, dump_cache_cb(), event_sub, OBJ_NODATA, and ast_event_sub::type.

Referenced by add_publish_event(), aji_init_event_distribution(), and handle_devstate_change().

00631 {
00632    ao2_callback(ast_event_cache[event_sub->type].container, OBJ_NODATA,
00633          dump_cache_cb, (void *) event_sub);
00634 }

static struct ast_event* ast_event_dup ( const struct ast_event event  )  [static]

Definition at line 1285 of file event.c.

References ast_calloc, ast_event_get_size(), and ast_event::event_len.

Referenced by ast_event_get_cached(), and event_update_cache().

01286 {
01287    struct ast_event *dup_event;
01288    uint16_t event_len;
01289 
01290    event_len = ast_event_get_size(event);
01291 
01292    if (!(dup_event = ast_calloc(1, event_len))) {
01293       return NULL;
01294    }
01295 
01296    memcpy(dup_event, event, event_len);
01297 
01298    return dup_event;
01299 }

struct ast_event* ast_event_get_cached ( enum  ast_event_type,
  ... 
)

Retrieve an event from the cache.

Parameters:
ast_event_type The type of event to retrieve from the cache
The rest of the arguments to this function specify information elements to match for retrieving events from the cache. They are specified in the form: and must end with AST_EVENT_IE_END.

If the ie_type specified is *not* AST_EVENT_IE_END, then it must be followed by a valid IE payload type. If the payload type specified is AST_EVENT_IE_PLTYPE_EXISTS, then the 3rd argument should not be provided. Otherwise, a payload must also be specified.

Returns:
A reference to an event retrieved from the cache. If no event was found that matches the specified criteria, then NULL will be returned.
Note:
If more than one event in the cache matches the specified criteria, only one will be returned, and it is undefined which one it will be.

The caller of this function *must* call ast_event_destroy() on the returned event after it is done using it.

Example Usage:

This example will check for an MWI event in the cache that matches the specified mailbox. This would be the way to find out the last known state of a mailbox without having to poll the mailbox directly.

Definition at line 1301 of file event.c.

References ao2_find, ao2_ref, ast_event_append_ie_bitflags(), ast_event_append_ie_raw(), ast_event_append_ie_str(), ast_event_append_ie_uint(), ast_event_cache, ast_event_destroy(), ast_event_dup(), AST_EVENT_IE_END, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_event_new(), ast_log(), container, ast_event_ref::event, LOG_ERROR, LOG_WARNING, and OBJ_POINTER.

Referenced by devstate_cached(), get_cached_mwi(), has_voicemail(), process_collection(), sig_pri_mwi_cache_update(), unistim_send_mwi_to_peer(), and update_registry().

01302 {
01303    va_list ap;
01304    enum ast_event_ie_type ie_type;
01305    struct ast_event *dup_event = NULL;
01306    struct ast_event_ref *cached_event_ref;
01307    struct ast_event *cache_arg_event;
01308    struct ast_event_ref tmp_event_ref = {
01309       .event = NULL,
01310    };
01311    struct ao2_container *container = NULL;
01312 
01313    if (type >= AST_EVENT_TOTAL) {
01314       ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
01315       return NULL;
01316    }
01317 
01318    if (!(container = ast_event_cache[type].container)) {
01319       ast_log(LOG_ERROR, "%u is not a cached event type\n", type);
01320       return NULL;
01321    }
01322 
01323    if (!(cache_arg_event = ast_event_new(type, AST_EVENT_IE_END))) {
01324       return NULL;
01325    }
01326 
01327    va_start(ap, type);
01328    for (ie_type = va_arg(ap, enum ast_event_ie_type);
01329       ie_type != AST_EVENT_IE_END;
01330       ie_type = va_arg(ap, enum ast_event_ie_type))
01331    {
01332       enum ast_event_ie_pltype ie_pltype;
01333 
01334       ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
01335 
01336       switch (ie_pltype) {
01337       case AST_EVENT_IE_PLTYPE_UINT:
01338          ast_event_append_ie_uint(&cache_arg_event, ie_type, va_arg(ap, uint32_t));
01339          break;
01340       case AST_EVENT_IE_PLTYPE_BITFLAGS:
01341          ast_event_append_ie_bitflags(&cache_arg_event, ie_type, va_arg(ap, uint32_t));
01342          break;
01343       case AST_EVENT_IE_PLTYPE_STR:
01344          ast_event_append_ie_str(&cache_arg_event, ie_type, va_arg(ap, const char *));
01345          break;
01346       case AST_EVENT_IE_PLTYPE_RAW:
01347       {
01348          void *data = va_arg(ap, void *);
01349          size_t datalen = va_arg(ap, size_t);
01350          ast_event_append_ie_raw(&cache_arg_event, ie_type, data, datalen);
01351          break;
01352       }
01353       case AST_EVENT_IE_PLTYPE_EXISTS:
01354          ast_log(LOG_WARNING, "PLTYPE_EXISTS not supported by this function\n");
01355          break;
01356       case AST_EVENT_IE_PLTYPE_UNKNOWN:
01357          break;
01358       }
01359    }
01360    va_end(ap);
01361 
01362    tmp_event_ref.event = cache_arg_event;
01363 
01364    cached_event_ref = ao2_find(container, &tmp_event_ref, OBJ_POINTER);
01365 
01366    ast_event_destroy(cache_arg_event);
01367    cache_arg_event = NULL;
01368 
01369    if (cached_event_ref) {
01370       dup_event = ast_event_dup(cached_event_ref->event);
01371       ao2_ref(cached_event_ref, -1);
01372       cached_event_ref = NULL;
01373    }
01374 
01375    return dup_event;
01376 }

uint32_t ast_event_get_ie_bitflags ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the value of an information element that has a bitflags payload.

Parameters:
event The event to get the IE from
ie_type the type of information element to retrieve
Returns:
This returns the payload of the information element with the given type. However, an IE with a payload of 0, and the case where no IE is found yield the same return value.

Definition at line 1054 of file event.c.

References ast_event_get_ie_raw(), and get_unaligned_uint32().

Referenced by append_ie(), and match_ie_val().

01055 {
01056    const uint32_t *ie_val;
01057 
01058    ie_val = ast_event_get_ie_raw(event, ie_type);
01059 
01060    return ie_val ? ntohl(get_unaligned_uint32(ie_val)) : 0;
01061 }

enum ast_event_ie_pltype ast_event_get_ie_pltype ( enum ast_event_ie_type  ie_type  ) 

Get the payload type for a given information element type.

Parameters:
ie_type the information element type to get the payload type of
Returns:
the payload type for the provided IE type
Since:
1.6.1

Definition at line 309 of file event.c.

References ARRAY_LEN, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_log(), ie_maps, ie_map::ie_pltype, and LOG_ERROR.

Referenced by append_ie(), ast_event_cmp(), and event_dump_cli().

00310 {
00311    if (ie_type <= 0 || ie_type >= ARRAY_LEN(ie_maps)) {
00312       ast_log(LOG_ERROR, "Invalid IE type - '%d'\n", ie_type);
00313       return AST_EVENT_IE_PLTYPE_UNKNOWN;
00314    }
00315 
00316    return ie_maps[ie_type].ie_pltype;
00317 }

const void* ast_event_get_ie_raw ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the value of an information element that has a raw payload.

Parameters:
event The event to get the IE from
ie_type the type of information element to retrieve
Returns:
This returns the payload of the information element with the given type. If the information element isn't found, NULL will be returned.

Definition at line 1081 of file event.c.

References ast_event_iterator_get_ie_raw(), ast_event_iterator_get_ie_type(), ast_event_iterator_init(), ast_event_iterator_next(), and ast_event_iterator::event.

Referenced by aji_devstate_cb(), aji_mwi_cb(), ast_event_cb(), ast_event_get_ie_bitflags(), ast_event_get_ie_str(), ast_event_get_ie_str_hash(), ast_event_get_ie_uint(), ast_event_new(), devstate_cache_cb(), devstate_change_collector_cb(), evt_event_deliver_cb(), ie_is_present(), and match_ie_val().

01082 {
01083    struct ast_event_iterator iterator;
01084    int res;
01085 
01086    for (res = ast_event_iterator_init(&iterator, event); !res; res = ast_event_iterator_next(&iterator)) {
01087       if (ast_event_iterator_get_ie_type(&iterator) == ie_type) {
01088          return ast_event_iterator_get_ie_raw(&iterator);
01089       }
01090    }
01091 
01092    return NULL;
01093 }

uint16_t ast_event_get_ie_raw_payload_len ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the length of the raw payload for a particular IE.

Parameters:
event The event to get the IE payload length from
ie_type the type of information element to get the length of
Returns:
If an IE of type ie_type is found, its payload length is returned. Otherwise, 0 is returned.

Definition at line 1095 of file event.c.

References ast_event_iterator_get_ie_raw_payload_len(), ast_event_iterator_get_ie_type(), ast_event_iterator_init(), ast_event_iterator_next(), and ast_event_iterator::event.

Referenced by match_ie_val().

01096 {
01097    struct ast_event_iterator iterator;
01098    int res;
01099 
01100    for (res = ast_event_iterator_init(&iterator, event); !res; res = ast_event_iterator_next(&iterator)) {
01101       if (ast_event_iterator_get_ie_type(&iterator) == ie_type) {
01102          return ast_event_iterator_get_ie_raw_payload_len(&iterator);
01103       }
01104    }
01105 
01106    return 0;
01107 }

const char* ast_event_get_ie_str ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the value of an information element that has a string payload.

Parameters:
event The event to get the IE from
ie_type the type of information element to retrieve
Returns:
This returns the payload of the information element with the given type. If the information element isn't found, NULL will be returned.

Definition at line 1072 of file event.c.

References ast_event_get_ie_raw(), and ast_event_ie_str_payload::str.

Referenced by aji_devstate_cb(), aji_mwi_cb(), append_ie(), ast_cel_fill_record(), ast_event_hash_devstate(), ast_event_hash_devstate_change(), ast_event_hash_mwi(), device_state_cb(), devstate_change_collector_cb(), generic_monitor_devstate_cb(), match_ie_val(), mwi_sub_event_cb(), print_cel_sub(), and sig_pri_mwi_event_cb().

01073 {
01074    const struct ast_event_ie_str_payload *str_payload;
01075 
01076    str_payload = ast_event_get_ie_raw(event, ie_type);
01077 
01078    return str_payload ? str_payload->str : NULL;
01079 }

uint32_t ast_event_get_ie_str_hash ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the hash for the string payload of an IE.

Parameters:
event The event to get the IE from
ie_type the type of information element to retrieve the hash for
Returns:
This function returns the hash value as calculated by ast_str_hash() for the string payload. This is stored in the event to avoid unnecessary string comparisons.

Definition at line 1063 of file event.c.

References ast_event_get_ie_raw(), and ast_event_ie_str_payload::hash.

Referenced by match_ie_val().

01064 {
01065    const struct ast_event_ie_str_payload *str_payload;
01066 
01067    str_payload = ast_event_get_ie_raw(event, ie_type);
01068 
01069    return str_payload ? str_payload->hash : 0;
01070 }

const char* ast_event_get_ie_type_name ( enum ast_event_ie_type  ie_type  ) 

Get the string representation of an information element type.

Parameters:
ie_type the information element type to get the string representation of
Returns:
the string representation of the information element type
Since:
1.6.1

Definition at line 299 of file event.c.

References ARRAY_LEN, ast_log(), ie_maps, LOG_ERROR, and ie_map::name.

Referenced by append_ie(), dump_raw_ie(), event_dump_cache(), event_dump_cli(), and security_event_cb().

00300 {
00301    if (ie_type <= 0 || ie_type >= ARRAY_LEN(ie_maps)) {
00302       ast_log(LOG_ERROR, "Invalid IE type - '%d'\n", ie_type);
00303       return "";
00304    }
00305 
00306    return ie_maps[ie_type].name;
00307 }

uint32_t ast_event_get_ie_uint ( const struct ast_event event,
enum ast_event_ie_type  ie_type 
)

Get the value of an information element that has an integer payload.

Parameters:
event The event to get the IE from
ie_type the type of information element to retrieve
Returns:
This returns the payload of the information element with the given type. However, an IE with a payload of 0, and the case where no IE is found yield the same return value.

Definition at line 1045 of file event.c.

References ast_event_get_ie_raw(), and get_unaligned_uint32().

Referenced by aji_devstate_cb(), aji_mwi_cb(), append_ie(), ast_cel_fill_record(), device_state_cb(), devstate_cache_cb(), devstate_cached(), devstate_change_collector_cb(), generic_agent_devstate_cb(), generic_monitor_devstate_cb(), get_cached_mwi(), has_voicemail(), match_ie_val(), mwi_event_cb(), mwi_sub_event_cb(), mwi_unsub_event_cb(), process_collection(), security_event_cb(), sig_pri_mwi_cache_update(), sig_pri_mwi_event_cb(), unistim_send_mwi_to_peer(), and update_registry().

01046 {
01047    const uint32_t *ie_val;
01048 
01049    ie_val = ast_event_get_ie_raw(event, ie_type);
01050 
01051    return ie_val ? ntohl(get_unaligned_uint32(ie_val)) : 0;
01052 }

size_t ast_event_get_size ( const struct ast_event event  ) 

Get the size of an event.

Parameters:
event the event to get the size of
Returns:
the number of bytes contained in the event
Since:
1.6.1

Definition at line 335 of file event.c.

References ast_event::event_len.

Referenced by ast_event_cb(), ast_event_dup(), and ast_event_iterator_init().

00336 {
00337    size_t res;
00338 
00339    res = ntohs(event->event_len);
00340 
00341    return res;
00342 }

enum ast_event_type ast_event_get_type ( const struct ast_event event  ) 

Get the type for an event.

Parameters:
event the event to get the type for
Returns:
the event type as represented by one of the values in the ast_event_type enum

Definition at line 1040 of file event.c.

Referenced by ast_event_cb(), ast_event_cmp(), ast_event_get_type_name(), ast_event_hash(), ast_event_queue_and_cache(), mwi_sub_event_cb(), and mwi_unsub_event_cb().

01041 {
01042    return ntohs(event->type);
01043 }

const char* ast_event_get_type_name ( const struct ast_event event  ) 

Get the string representation of the type of the given event.

Returns:
the string representation of the event type of the provided event
Since:
1.6.1

Definition at line 269 of file event.c.

References ARRAY_LEN, ast_event_get_type(), ast_log(), event_names, LOG_ERROR, and ast_event_sub::type.

Referenced by event_dump_cli().

00270 {
00271    enum ast_event_type type;
00272 
00273    type = ast_event_get_type(event);
00274 
00275    if (type < 0 || type >= ARRAY_LEN(event_names)) {
00276       ast_log(LOG_ERROR, "Invalid event type - '%d'\n", type);
00277       return "";
00278    }
00279 
00280    return event_names[type];
00281 }

static int ast_event_hash ( const void *  obj,
const int  flags 
) [static]

Definition at line 1553 of file event.c.

References ast_event_cache, ast_event_get_type(), ast_event_ref::event, and hash_fn.

Referenced by ast_event_init().

01554 {
01555    const struct ast_event_ref *event_ref;
01556    const struct ast_event *event;
01557    ao2_hash_fn *hash_fn;
01558 
01559    event_ref = obj;
01560    event = event_ref->event;
01561 
01562    if (!(hash_fn = ast_event_cache[ast_event_get_type(event)].hash_fn)) {
01563       return 0;
01564    }
01565 
01566    return hash_fn(event, flags);
01567 }

static int ast_event_hash_devstate ( const void *  obj,
const int  flags 
) [static]

Definition at line 1530 of file event.c.

References ast_event_get_ie_str(), AST_EVENT_IE_DEVICE, and ast_str_hash().

01531 {
01532    const struct ast_event *event = obj;
01533 
01534    return ast_str_hash(ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE));
01535 }

static int ast_event_hash_devstate_change ( const void *  obj,
const int  flags 
) [static]

Definition at line 1546 of file event.c.

References ast_event_get_ie_str(), AST_EVENT_IE_DEVICE, and ast_str_hash().

01547 {
01548    const struct ast_event *event = obj;
01549 
01550    return ast_str_hash(ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE));
01551 }

static int ast_event_hash_mwi ( const void *  obj,
const int  flags 
) [static]

Definition at line 1512 of file event.c.

References ast_event_get_ie_str(), AST_EVENT_IE_CONTEXT, AST_EVENT_IE_MAILBOX, ast_str_hash(), ast_str_hash_add(), context, and mailbox.

01513 {
01514    const struct ast_event *event = obj;
01515    const char *mailbox = ast_event_get_ie_str(event, AST_EVENT_IE_MAILBOX);
01516    const char *context = ast_event_get_ie_str(event, AST_EVENT_IE_CONTEXT);
01517 
01518    return ast_str_hash_add(context, ast_str_hash(mailbox));
01519 }

static void ast_event_ie_val_destroy ( struct ast_event_ie_val ie_val  )  [static]

Definition at line 344 of file event.c.

References AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_free, ast_event_ie_val::ie_pltype, ast_event_ie_val::payload, ast_event_ie_val::raw, and ast_event_ie_val::str.

Referenced by ast_event_sub_destroy().

00345 {
00346    switch (ie_val->ie_pltype) {
00347    case AST_EVENT_IE_PLTYPE_STR:
00348       ast_free((char *) ie_val->payload.str);
00349       break;
00350    case AST_EVENT_IE_PLTYPE_RAW:
00351       ast_free(ie_val->payload.raw);
00352       break;
00353    case AST_EVENT_IE_PLTYPE_UINT:
00354    case AST_EVENT_IE_PLTYPE_BITFLAGS:
00355    case AST_EVENT_IE_PLTYPE_EXISTS:
00356    case AST_EVENT_IE_PLTYPE_UNKNOWN:
00357       break;
00358    }
00359 
00360    ast_free(ie_val);
00361 }

int ast_event_init ( void   ) 

Provided by event.c

Definition at line 1744 of file event.c.

References ao2_container_alloc, ARRAY_LEN, ast_cli_register_multiple(), ast_event_cache, ast_event_cmp(), ast_event_hash(), ast_event_subs, AST_RWDLLIST_HEAD_INIT, ast_taskprocessor_get(), container, event_cli, event_dispatcher, hash_fn, and NUM_CACHE_BUCKETS.

Referenced by main().

01745 {
01746    int i;
01747 
01748    for (i = 0; i < AST_EVENT_TOTAL; i++) {
01749       AST_RWDLLIST_HEAD_INIT(&ast_event_subs[i]);
01750    }
01751 
01752    for (i = 0; i < AST_EVENT_TOTAL; i++) {
01753       if (!ast_event_cache[i].hash_fn) {
01754          /* This event type is not cached. */
01755          continue;
01756       }
01757 
01758       if (!(ast_event_cache[i].container = ao2_container_alloc(NUM_CACHE_BUCKETS,
01759             ast_event_hash, ast_event_cmp))) {
01760          return -1;
01761       }
01762    }
01763 
01764    if (!(event_dispatcher = ast_taskprocessor_get("core_event_dispatcher", 0))) {
01765       return -1;
01766    }
01767 
01768    ast_cli_register_multiple(event_cli, ARRAY_LEN(event_cli));
01769 
01770    return 0;
01771 }

uint32_t ast_event_iterator_get_ie_bitflags ( struct ast_event_iterator iterator  ) 

Get the value of the current IE in the iterator as a bitflags payload.

Parameters:
iterator The iterator instance
Returns:
This returns the payload of the information element as bitflags.

Definition at line 1016 of file event.c.

References get_unaligned_uint32(), ast_event_iterator::ie, and ast_event_ie::ie_payload.

Referenced by event_dump_cli().

01017 {
01018    return ntohl(get_unaligned_uint32(iterator->ie->ie_payload));
01019 }

void* ast_event_iterator_get_ie_raw ( struct ast_event_iterator iterator  ) 

Get the value of the current IE in the iterator instance that has a raw payload.

Parameters:
iterator The iterator instance
Returns:
This returns the payload of the information element as type raw.

Definition at line 1030 of file event.c.

References ast_event_iterator::ie, and ast_event_ie::ie_payload.

Referenced by ast_event_get_ie_raw(), and dump_raw_ie().

01031 {
01032    return iterator->ie->ie_payload;
01033 }

uint16_t ast_event_iterator_get_ie_raw_payload_len ( struct ast_event_iterator iterator  ) 

Get the length of the raw payload for the current IE for an iterator.

Parameters:
iterator The IE iterator
Returns:
The payload length of the current IE

Definition at line 1035 of file event.c.

References ast_event_iterator::ie, and ast_event_ie::ie_payload_len.

Referenced by ast_event_get_ie_raw_payload_len().

01036 {
01037    return ntohs(iterator->ie->ie_payload_len);
01038 }

const char* ast_event_iterator_get_ie_str ( struct ast_event_iterator iterator  ) 

Get the value of the current IE in the iterator as a string payload.

Parameters:
iterator The iterator instance
Returns:
This returns the payload of the information element as a string.

Definition at line 1021 of file event.c.

References ast_event_iterator::ie, ast_event_ie::ie_payload, and ast_event_ie_str_payload::str.

Referenced by event_dump_cli().

01022 {
01023    const struct ast_event_ie_str_payload *str_payload;
01024 
01025    str_payload = (struct ast_event_ie_str_payload *) iterator->ie->ie_payload;
01026 
01027    return str_payload ? str_payload->str : NULL;
01028 }

enum ast_event_ie_type ast_event_iterator_get_ie_type ( struct ast_event_iterator iterator  ) 

Get the type of the current IE in the iterator instance.

Parameters:
iterator The iterator instance
Returns:
the ie type as represented by one of the value sin the ast_event_ie_type enum

Definition at line 1006 of file event.c.

References ast_event_iterator::ie.

Referenced by ast_event_get_ie_raw(), ast_event_get_ie_raw_payload_len(), dump_raw_ie(), and event_dump_cli().

01007 {
01008    return ntohs(iterator->ie->ie_type);
01009 }

uint32_t ast_event_iterator_get_ie_uint ( struct ast_event_iterator iterator  ) 

Get the value of the current IE in the iterator as an integer payload.

Parameters:
iterator The iterator instance
Returns:
This returns the payload of the information element as a uint.

Definition at line 1011 of file event.c.

References get_unaligned_uint32(), ast_event_iterator::ie, and ast_event_ie::ie_payload.

Referenced by event_dump_cli().

01012 {
01013    return ntohl(get_unaligned_uint32(iterator->ie->ie_payload));
01014 }

int ast_event_iterator_init ( struct ast_event_iterator iterator,
const struct ast_event event 
)

Initialize an event iterator instance.

Parameters:
iterator The iterator instance to initialize
event The event that will be iterated through
Return values:
0 Success, there are IEs available to iterate
-1 Failure, there are no IEs in the event to iterate

Definition at line 984 of file event.c.

References ast_event_get_size(), ast_event_iterator::event, ast_event_iterator::event_len, and ast_event_iterator::ie.

Referenced by ast_event_get_ie_raw(), ast_event_get_ie_raw_payload_len(), and event_dump_cli().

00985 {
00986    int res = 0;
00987 
00988    iterator->event_len = ast_event_get_size(event);
00989    iterator->event = event;
00990    if (iterator->event_len >= sizeof(*event) + sizeof(struct ast_event_ie)) {
00991       iterator->ie = (struct ast_event_ie *) ( ((char *) event) + sizeof(*event) );
00992    } else {
00993       iterator->ie = NULL;
00994       res = -1;
00995    }
00996 
00997    return res;
00998 }

int ast_event_iterator_next ( struct ast_event_iterator iterator  ) 

Move iterator instance to next IE.

Parameters:
iterator The iterator instance
Return values:
0 on success
-1 if end is reached

Definition at line 1000 of file event.c.

References ast_event_iterator::event, ast_event_iterator::event_len, ast_event_iterator::ie, and ast_event_ie::ie_payload_len.

Referenced by ast_event_get_ie_raw(), ast_event_get_ie_raw_payload_len(), and event_dump_cli().

01001 {
01002    iterator->ie = (struct ast_event_ie *) ( ((char *) iterator->ie) + sizeof(*iterator->ie) + ntohs(iterator->ie->ie_payload_len));
01003    return ((iterator->event_len <= (((char *) iterator->ie) - ((char *) iterator->event))) ? -1 : 0);
01004 }

size_t ast_event_minimum_length ( void   ) 

Get the minimum length of an ast_event.

Returns:
minimum amount of memory that will be consumed by any ast_event.

Definition at line 1773 of file event.c.

Referenced by evt_event_deliver_cb().

01774 {
01775    return sizeof(struct ast_event);
01776 }

struct ast_event* ast_event_new ( enum ast_event_type  event_type,
  ... 
)

Create a new event.

Parameters:
event_type The type of event to create
The rest of the arguments to this function specify information elements to add to the event. They are specified in the form: and must end with AST_EVENT_IE_END.

If the ie_type specified is *not* AST_EVENT_IE_END, then it must be followed by a valid IE payload type. The payload type, EXISTS, should not be used here because it makes no sense to do so. So, a payload must also be specified after the IE payload type.

Note:
The EID IE will be appended automatically when this function is used with at least one IE specified.
Returns:
This returns the event that has been created. If there is an error creating the event, NULL will be returned.
Example usage:

This creates a MWI event with 3 information elements, a mailbox which is a string, and the number of new and old messages, specified as integers.

Definition at line 1162 of file event.c.

References ast_calloc, ast_event_append_eid(), ast_event_append_ie_bitflags(), ast_event_append_ie_raw(), ast_event_append_ie_str(), ast_event_append_ie_uint(), ast_event_get_ie_raw(), AST_EVENT_IE_EID, AST_EVENT_IE_END, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, AST_LIST_HEAD_NOLOCK_STATIC, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_event_ie_val::ie_pltype, ast_event_ie_val::ie_type, ast_event_sub::ie_vals, LOG_WARNING, ast_event_ie_val::payload, ast_event_ie_val::raw, ast_event_ie_val::raw_datalen, ast_event_ie_val::str, and ast_event_ie_val::uint.

Referenced by aji_handle_pubsub_event(), alloc_event(), ast_cel_report_event(), ast_event_get_cached(), ast_event_unsubscribe(), devstate_event(), gen_sub_event(), handle_request_notify(), notify_message(), process_collection(), queue_mwi_event(), and stun_monitor_request().

01163 {
01164    va_list ap;
01165    struct ast_event *event;
01166    enum ast_event_ie_type ie_type;
01167    struct ast_event_ie_val *ie_val;
01168    int has_ie = 0;
01169    AST_LIST_HEAD_NOLOCK_STATIC(ie_vals, ast_event_ie_val);
01170 
01171    /* Invalid type */
01172    if (type >= AST_EVENT_TOTAL) {
01173       ast_log(LOG_WARNING, "Someone tried to create an event of invalid "
01174          "type '%d'!\n", type);
01175       return NULL;
01176    }
01177 
01178    va_start(ap, type);
01179    for (ie_type = va_arg(ap, enum ast_event_ie_type);
01180       ie_type != AST_EVENT_IE_END;
01181       ie_type = va_arg(ap, enum ast_event_ie_type))
01182    {
01183       struct ast_event_ie_val *ie_value = alloca(sizeof(*ie_value));
01184       int insert = 0;
01185 
01186       memset(ie_value, 0, sizeof(*ie_value));
01187       ie_value->ie_type = ie_type;
01188       ie_value->ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
01189       switch (ie_value->ie_pltype) {
01190       case AST_EVENT_IE_PLTYPE_UINT:
01191          ie_value->payload.uint = va_arg(ap, uint32_t);
01192          insert = 1;
01193          break;
01194       case AST_EVENT_IE_PLTYPE_BITFLAGS:
01195          ie_value->payload.uint = va_arg(ap, uint32_t);
01196          insert = 1;
01197          break;
01198       case AST_EVENT_IE_PLTYPE_STR:
01199          ie_value->payload.str = va_arg(ap, const char *);
01200          insert = 1;
01201          break;
01202       case AST_EVENT_IE_PLTYPE_RAW:
01203       {
01204          void *data = va_arg(ap, void *);
01205          size_t datalen = va_arg(ap, size_t);
01206          ie_value->payload.raw = alloca(datalen);
01207          memcpy(ie_value->payload.raw, data, datalen);
01208          ie_value->raw_datalen = datalen;
01209          insert = 1;
01210          break;
01211       }
01212       case AST_EVENT_IE_PLTYPE_UNKNOWN:
01213       case AST_EVENT_IE_PLTYPE_EXISTS:
01214          break;
01215       }
01216 
01217       if (insert) {
01218          AST_LIST_INSERT_TAIL(&ie_vals, ie_value, entry);
01219          has_ie = 1;
01220       } else {
01221          ast_log(LOG_WARNING, "Unsupported PLTYPE(%d)\n", ie_value->ie_pltype);
01222       }
01223    }
01224    va_end(ap);
01225 
01226    if (!(event = ast_calloc(1, sizeof(*event)))) {
01227       return NULL;
01228    }
01229 
01230    event->type = htons(type);
01231    event->event_len = htons(sizeof(*event));
01232 
01233    AST_LIST_TRAVERSE(&ie_vals, ie_val, entry) {
01234       switch (ie_val->ie_pltype) {
01235       case AST_EVENT_IE_PLTYPE_STR:
01236          ast_event_append_ie_str(&event, ie_val->ie_type, ie_val->payload.str);
01237          break;
01238       case AST_EVENT_IE_PLTYPE_UINT:
01239          ast_event_append_ie_uint(&event, ie_val->ie_type, ie_val->payload.uint);
01240          break;
01241       case AST_EVENT_IE_PLTYPE_BITFLAGS:
01242          ast_event_append_ie_bitflags(&event, ie_val->ie_type, ie_val->payload.uint);
01243          break;
01244       case AST_EVENT_IE_PLTYPE_RAW:
01245          ast_event_append_ie_raw(&event, ie_val->ie_type,
01246                ie_val->payload.raw, ie_val->raw_datalen);
01247          break;
01248       case AST_EVENT_IE_PLTYPE_EXISTS:
01249       case AST_EVENT_IE_PLTYPE_UNKNOWN:
01250          break;
01251       }
01252 
01253       if (!event) {
01254          break;
01255       }
01256    }
01257 
01258    if (has_ie && !ast_event_get_ie_raw(event, AST_EVENT_IE_EID)) {
01259       /* If the event is originating on this server, add the server's
01260        * entity ID to the event. */
01261       ast_event_append_eid(&event);
01262    }
01263 
01264    return event;
01265 }

int ast_event_queue ( struct ast_event event  ) 

Queue an event.

Parameters:
event the event to be queued
Return values:
zero success
non-zero failure. Note that the caller of this function is responsible for destroying the event in the case of a failure.
This function queues an event to be dispatched to all of the appropriate subscribers. This function will not block while the event is being dispatched because the event is queued up for a dispatching thread to handle.

Definition at line 1476 of file event.c.

References alloc_event_ref(), ao2_ref, ast_event_check_subscriber(), ast_event_destroy(), AST_EVENT_IE_END, AST_EVENT_SUB_NONE, ast_log(), ast_taskprocessor_push(), ast_event_ref::event, event_dispatcher, handle_event(), and LOG_WARNING.

Referenced by ast_cel_report_event(), ast_event_queue_and_cache(), ast_event_sub_activate(), ast_event_unsubscribe(), handle_security_event(), and stun_monitor_request().

01477 {
01478    struct ast_event_ref *event_ref;
01479    uint16_t host_event_type;
01480    int res;
01481 
01482    host_event_type = ntohs(event->type);
01483 
01484    /* Invalid type */
01485    if (host_event_type >= AST_EVENT_TOTAL) {
01486       ast_log(LOG_WARNING, "Someone tried to queue an event of invalid "
01487          "type '%d'!\n", host_event_type);
01488       return -1;
01489    }
01490 
01491    /* If nobody has subscribed to this event type, throw it away now */
01492    if (ast_event_check_subscriber(host_event_type, AST_EVENT_IE_END)
01493          == AST_EVENT_SUB_NONE) {
01494       ast_event_destroy(event);
01495       return 0;
01496    }
01497 
01498    if (!(event_ref = alloc_event_ref())) {
01499       return -1;
01500    }
01501 
01502    event_ref->event = event;
01503 
01504    res = ast_taskprocessor_push(event_dispatcher, handle_event, event_ref);
01505    if (res) {
01506       event_ref->event = NULL;
01507       ao2_ref(event_ref, -1);
01508    }
01509    return res;
01510 }

int ast_event_queue_and_cache ( struct ast_event event  ) 

Queue and cache an event.

Parameters:
event the event to be queued and cached
The purpose of caching events is so that the core can retain the last known information for events that represent some sort of state. That way, when code needs to find out the current state, it can query the cache.

The event API already knows which events can be cached and how to cache them.

Return values:
0 success
non-zero failure.

Definition at line 1424 of file event.c.

References ast_event_cache, ast_event_destroy(), ast_event_get_type(), ast_event_queue(), ast_log(), container, event_update_cache(), and LOG_WARNING.

Referenced by aji_handle_pubsub_event(), devstate_event(), handle_request_notify(), notify_message(), process_collection(), queue_event(), and queue_mwi_event().

01425 {
01426    struct ao2_container *container;
01427 
01428    container = ast_event_cache[ast_event_get_type(event)].container;
01429    if (!container) {
01430       ast_log(LOG_WARNING, "cache requested for non-cached event type\n");
01431    } else {
01432       event_update_cache(container, event);
01433    }
01434 
01435    if (ast_event_queue(event)) {
01436       ast_event_destroy(event);
01437    }
01438    return 0;
01439 }

static void ast_event_ref_destroy ( void *  obj  )  [static]

Definition at line 1278 of file event.c.

References ast_event_destroy(), and ast_event_ref::event.

Referenced by alloc_event_ref().

01279 {
01280    struct ast_event_ref *event_ref = obj;
01281 
01282    ast_event_destroy(event_ref->event);
01283 }

void ast_event_report_subs ( const struct ast_event_sub sub  ) 

Report current subscriptions to a subscription subscriber.

Returns:
nothing
This reports all of the current subscribers to a subscriber of subscribers to a specific event type. (Try saying that a few times fast).

The idea here is that it is sometimes very useful for a module to know when someone subscribes to events. However, when they first subscribe, this provides that module the ability to request the event core report to them all of the subscriptions to that event type that already exist.

Definition at line 677 of file event.c.

References ast_event_destroy(), AST_EVENT_IE_EVENTTYPE, AST_EVENT_SUB, ast_event_subs, AST_LIST_TRAVERSE, AST_RWDLLIST_RDLOCK, AST_RWDLLIST_TRAVERSE, AST_RWDLLIST_UNLOCK, ast_event_sub::cb, event_sub, gen_sub_event(), ast_event_ie_val::ie_type, ast_event_sub::ie_vals, ast_event_ie_val::payload, ast_event_sub::type, ast_event_ie_val::uint, and ast_event_sub::userdata.

Referenced by handle_cli_status(), and start_poll_thread().

00678 {
00679    struct ast_event *event;
00680    struct ast_event_sub *sub;
00681    enum ast_event_type event_type = -1;
00682    struct ast_event_ie_val *ie_val;
00683 
00684    if (event_sub->type != AST_EVENT_SUB)
00685       return;
00686 
00687    AST_LIST_TRAVERSE(&event_sub->ie_vals, ie_val, entry) {
00688       if (ie_val->ie_type == AST_EVENT_IE_EVENTTYPE) {
00689          event_type = ie_val->payload.uint;
00690          break;
00691       }
00692    }
00693 
00694    if (event_type == -1)
00695       return;
00696 
00697    AST_RWDLLIST_RDLOCK(&ast_event_subs[event_type]);
00698    AST_RWDLLIST_TRAVERSE(&ast_event_subs[event_type], sub, entry) {
00699       if (event_sub == sub) {
00700          continue;
00701       }
00702 
00703       event = gen_sub_event(sub);
00704       if (!event) {
00705          continue;
00706       }
00707 
00708       event_sub->cb(event, event_sub->userdata);
00709 
00710       ast_event_destroy(event);
00711    }
00712    AST_RWDLLIST_UNLOCK(&ast_event_subs[event_type]);
00713 }

int ast_event_str_to_event_type ( const char *  str,
enum ast_event_type event_type 
)

Convert a string into an event type.

Parameters:
str the string to convert
event_type an output parameter for the event type
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 283 of file event.c.

References ARRAY_LEN, ast_strlen_zero(), and event_names.

Referenced by event_dump_cache().

00284 {
00285    int i;
00286 
00287    for (i = 0; i < ARRAY_LEN(event_names); i++) {
00288       if (ast_strlen_zero(event_names[i]) || strcasecmp(event_names[i], str)) {
00289          continue;
00290       }
00291 
00292       *event_type = i;
00293       return 0;
00294    }
00295 
00296    return -1;
00297 }

int ast_event_str_to_ie_type ( const char *  str,
enum ast_event_ie_type ie_type 
)

Convert a string to an IE type.

Parameters:
str the string to convert
ie_type an output parameter for the IE type
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 319 of file event.c.

References ARRAY_LEN, ie_maps, and name.

00320 {
00321    int i;
00322 
00323    for (i = 0; i < ARRAY_LEN(ie_maps); i++) {
00324       if (strcasecmp(ie_maps[i].name, str)) {
00325          continue;
00326       }
00327 
00328       *ie_type = i;
00329       return 0;
00330    }
00331 
00332    return -1;
00333 }

int ast_event_sub_activate ( struct ast_event_sub sub  ) 

Activate a dynamically built subscription.

Parameters:
sub the subscription to activate that was allocated using ast_event_subscribe_new()
Once a dynamically built subscription has had all of the parameters added to it, it should be activated using this function.

Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 859 of file event.c.

References ast_event_check_subscriber(), ast_event_destroy(), AST_EVENT_IE_END, AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, ast_event_queue(), AST_EVENT_SUB, AST_EVENT_SUB_NONE, ast_event_subs, AST_RWDLLIST_INSERT_TAIL, AST_RWDLLIST_UNLOCK, AST_RWDLLIST_WRLOCK, gen_sub_event(), and ast_event_sub::type.

Referenced by ast_event_subscribe().

00860 {
00861    if (ast_event_check_subscriber(AST_EVENT_SUB,
00862       AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
00863       AST_EVENT_IE_END) != AST_EVENT_SUB_NONE) {
00864       struct ast_event *event;
00865 
00866       event = gen_sub_event(sub);
00867       if (event && ast_event_queue(event)) {
00868          ast_event_destroy(event);
00869       }
00870    }
00871 
00872    AST_RWDLLIST_WRLOCK(&ast_event_subs[sub->type]);
00873    AST_RWDLLIST_INSERT_TAIL(&ast_event_subs[sub->type], sub, entry);
00874    AST_RWDLLIST_UNLOCK(&ast_event_subs[sub->type]);
00875 
00876    return 0;
00877 }

int ast_event_sub_append_ie_bitflags ( struct ast_event_sub sub,
enum ast_event_ie_type  ie_type,
uint32_t  flags 
)

Append a bitflags parameter to a subscription.

Parameters:
sub the dynamic subscription allocated with ast_event_subscribe_new()
ie_type the information element type for the parameter
flags the flags that must be present in the event to match this subscription
Return values:
0 success
non-zero failure
Since:
1.8

Definition at line 759 of file event.c.

References ast_calloc, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_TOTAL, AST_LIST_INSERT_TAIL, and ast_event_sub::ie_vals.

Referenced by ast_event_subscribe().

00761 {
00762    struct ast_event_ie_val *ie_val;
00763 
00764    if (ie_type <= 0 || ie_type >= AST_EVENT_IE_TOTAL) {
00765       return -1;
00766    }
00767 
00768    if (!(ie_val = ast_calloc(1, sizeof(*ie_val)))) {
00769       return -1;
00770    }
00771 
00772    ie_val->ie_type = ie_type;
00773    ie_val->payload.uint = flags;
00774    ie_val->ie_pltype = AST_EVENT_IE_PLTYPE_BITFLAGS;
00775 
00776    AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
00777 
00778    return 0;
00779 }

int ast_event_sub_append_ie_exists ( struct ast_event_sub sub,
enum ast_event_ie_type  ie_type 
)

Append an 'exists' parameter to a subscription.

Parameters:
sub the dynamic subscription allocated with ast_event_subscribe_new()
ie_type the information element type that must be present in the event for it to match this subscription.
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 781 of file event.c.

References ast_calloc, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_TOTAL, AST_LIST_INSERT_TAIL, and ast_event_sub::ie_vals.

Referenced by ast_event_subscribe().

00783 {
00784    struct ast_event_ie_val *ie_val;
00785 
00786    if (ie_type <= 0 || ie_type >= AST_EVENT_IE_TOTAL) {
00787       return -1;
00788    }
00789 
00790    if (!(ie_val = ast_calloc(1, sizeof(*ie_val)))) {
00791       return -1;
00792    }
00793 
00794    ie_val->ie_type = ie_type;
00795    ie_val->ie_pltype = AST_EVENT_IE_PLTYPE_EXISTS;
00796 
00797    AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
00798 
00799    return 0;
00800 }

int ast_event_sub_append_ie_raw ( struct ast_event_sub sub,
enum ast_event_ie_type  ie_type,
void *  data,
size_t  raw_datalen 
)

Append a raw parameter to a subscription.

Parameters:
sub the dynamic subscription allocated with ast_event_subscribe_new()
ie_type the information element type for the parameter
data the data that must be present in the event to match this subscription
raw_datalen length of data
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 830 of file event.c.

References ast_calloc, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_TOTAL, ast_free, AST_LIST_INSERT_TAIL, ast_malloc, and ast_event_sub::ie_vals.

Referenced by ast_event_subscribe().

00832 {
00833    struct ast_event_ie_val *ie_val;
00834 
00835    if (ie_type <= 0 || ie_type >= AST_EVENT_IE_TOTAL) {
00836       return -1;
00837    }
00838 
00839    if (!(ie_val = ast_calloc(1, sizeof(*ie_val)))) {
00840       return -1;
00841    }
00842 
00843    ie_val->ie_type = ie_type;
00844    ie_val->ie_pltype = AST_EVENT_IE_PLTYPE_RAW;
00845    ie_val->raw_datalen = raw_datalen;
00846 
00847    if (!(ie_val->payload.raw = ast_malloc(raw_datalen))) {
00848       ast_free(ie_val);
00849       return -1;
00850    }
00851 
00852    memcpy(ie_val->payload.raw, data, raw_datalen);
00853 
00854    AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
00855 
00856    return 0;
00857 }

int ast_event_sub_append_ie_str ( struct ast_event_sub sub,
enum ast_event_ie_type  ie_type,
const char *  str 
)

Append a string parameter to a subscription.

Parameters:
sub the dynamic subscription allocated with ast_event_subscribe_new()
ie_type the information element type for the parameter
str the string that must be present in the event to match this subscription
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 802 of file event.c.

References ast_calloc, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_TOTAL, ast_free, AST_LIST_INSERT_TAIL, ast_str_hash(), ast_strdup, and ast_event_sub::ie_vals.

Referenced by ast_event_subscribe(), and handle_devstate_change().

00804 {
00805    struct ast_event_ie_val *ie_val;
00806 
00807    if (ie_type <= 0 || ie_type >= AST_EVENT_IE_TOTAL) {
00808       return -1;
00809    }
00810 
00811    if (!(ie_val = ast_calloc(1, sizeof(*ie_val)))) {
00812       return -1;
00813    }
00814 
00815    ie_val->ie_type = ie_type;
00816    ie_val->ie_pltype = AST_EVENT_IE_PLTYPE_STR;
00817 
00818    if (!(ie_val->payload.str = ast_strdup(str))) {
00819       ast_free(ie_val);
00820       return -1;
00821    }
00822 
00823    ie_val->payload.hash = ast_str_hash(str);
00824 
00825    AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
00826 
00827    return 0;
00828 }

int ast_event_sub_append_ie_uint ( struct ast_event_sub sub,
enum ast_event_ie_type  ie_type,
uint32_t  uint 
)

Append a uint parameter to a subscription.

Parameters:
sub the dynamic subscription allocated with ast_event_subscribe_new()
ie_type the information element type for the parameter
uint the value that must be present in the event to match this subscription
Return values:
0 success
non-zero failure
Since:
1.6.1

Definition at line 737 of file event.c.

References ast_calloc, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_TOTAL, AST_LIST_INSERT_TAIL, and ast_event_sub::ie_vals.

Referenced by ast_event_subscribe(), and handle_cli_status().

00739 {
00740    struct ast_event_ie_val *ie_val;
00741 
00742    if (ie_type <= 0 || ie_type >= AST_EVENT_IE_TOTAL) {
00743       return -1;
00744    }
00745 
00746    if (!(ie_val = ast_calloc(1, sizeof(*ie_val)))) {
00747       return -1;
00748    }
00749 
00750    ie_val->ie_type = ie_type;
00751    ie_val->payload.uint = unsigned_int;
00752    ie_val->ie_pltype = AST_EVENT_IE_PLTYPE_UINT;
00753 
00754    AST_LIST_INSERT_TAIL(&sub->ie_vals, ie_val, entry);
00755 
00756    return 0;
00757 }

void ast_event_sub_destroy ( struct ast_event_sub sub  ) 

Destroy an allocated subscription.

Parameters:
sub the subscription to destroy
This function should be used when a subscription is allocated with ast_event_subscribe_new(), but for some reason, you want to destroy it instead of activating it. This could be because of an error when reading in the configuration for the dynamically built subscription.
Since:
1.6.1

Definition at line 941 of file event.c.

References ast_event_ie_val_destroy(), ast_free, AST_LIST_REMOVE_HEAD, and ast_event_sub::ie_vals.

Referenced by ast_event_unsubscribe(), handle_cli_status(), and handle_devstate_change().

00942 {
00943    struct ast_event_ie_val *ie_val;
00944 
00945    while ((ie_val = AST_LIST_REMOVE_HEAD(&sub->ie_vals, entry))) {
00946       ast_event_ie_val_destroy(ie_val);
00947    }
00948 
00949    ast_free(sub);
00950 }

struct ast_event_sub* ast_event_subscribe ( enum ast_event_type  event_type,
ast_event_cb_t  cb,
const char *  description,
void *  userdata,
  ... 
)

Subscribe to events.

Parameters:
event_type The type of events to subscribe to
cb The function to be called with events
description Description of the subscription.
userdata data to be passed to the event callback
The rest of the arguments to this function specify additional parameters for the subscription to filter which events are passed to this subscriber. The arguments must be in sets of: and must end with AST_EVENT_IE_END.

If the ie_type specified is *not* AST_EVENT_IE_END, then it must be followed by a valid IE payload type. If the payload type specified is AST_EVENT_IE_PLTYPE_EXISTS, then the 3rd argument should not be provided. Otherwise, a payload must also be specified.

Returns:
This returns a reference to the subscription for use with un-subscribing later. If there is a failure in creating the subscription, NULL will be returned.
Example usage:

This creates a subscription to AST_EVENT_MWI events that contain an information element, AST_EVENT_IE_MAILBOX, with the same string value contained in peer->mailbox. Also, the event callback will be passed a pointer to the peer.

Note:
A NULL description will cause this function to crash, so watch out!

Definition at line 879 of file event.c.

References ast_copy_string(), AST_EVENT_IE_END, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_event_sub_activate(), ast_event_sub_append_ie_bitflags(), ast_event_sub_append_ie_exists(), ast_event_sub_append_ie_raw(), ast_event_sub_append_ie_str(), ast_event_sub_append_ie_uint(), ast_event_subscribe_new(), ast_event_sub::description, and str.

Referenced by add_peer_mwi_subs(), add_publish_event(), aji_init_event_distribution(), ast_enable_distributed_devstate(), build_peer(), cc_generic_agent_start_monitoring(), config_line(), create_new_generic_list(), load_module(), load_pbx(), network_change_event_subscribe(), sig_pri_start_pri(), and start_poll_thread().

00881 {
00882    va_list ap;
00883    enum ast_event_ie_type ie_type;
00884    struct ast_event_sub *sub;
00885 
00886    if (!(sub = ast_event_subscribe_new(type, cb, userdata))) {
00887       return NULL;
00888    }
00889 
00890    ast_copy_string(sub->description, description, sizeof(sub->description));
00891 
00892    va_start(ap, userdata);
00893    for (ie_type = va_arg(ap, enum ast_event_ie_type);
00894       ie_type != AST_EVENT_IE_END;
00895       ie_type = va_arg(ap, enum ast_event_ie_type))
00896    {
00897       enum ast_event_ie_pltype ie_pltype;
00898 
00899       ie_pltype = va_arg(ap, enum ast_event_ie_pltype);
00900 
00901       switch (ie_pltype) {
00902       case AST_EVENT_IE_PLTYPE_UNKNOWN:
00903          break;
00904       case AST_EVENT_IE_PLTYPE_UINT:
00905       {
00906          uint32_t unsigned_int = va_arg(ap, uint32_t);
00907          ast_event_sub_append_ie_uint(sub, ie_type, unsigned_int);
00908          break;
00909       }
00910       case AST_EVENT_IE_PLTYPE_BITFLAGS:
00911       {
00912          uint32_t unsigned_int = va_arg(ap, uint32_t);
00913          ast_event_sub_append_ie_bitflags(sub, ie_type, unsigned_int);
00914          break;
00915       }
00916       case AST_EVENT_IE_PLTYPE_STR:
00917       {
00918          const char *str = va_arg(ap, const char *);
00919          ast_event_sub_append_ie_str(sub, ie_type, str);
00920          break;
00921       }
00922       case AST_EVENT_IE_PLTYPE_RAW:
00923       {
00924          void *data = va_arg(ap, void *);
00925          size_t data_len = va_arg(ap, size_t);
00926          ast_event_sub_append_ie_raw(sub, ie_type, data, data_len);
00927          break;
00928       }
00929       case AST_EVENT_IE_PLTYPE_EXISTS:
00930          ast_event_sub_append_ie_exists(sub, ie_type);
00931          break;
00932       }
00933    }
00934    va_end(ap);
00935 
00936    ast_event_sub_activate(sub);
00937 
00938    return sub;
00939 }

struct ast_event_sub* ast_event_subscribe_new ( enum ast_event_type  type,
ast_event_cb_t  cb,
void *  userdata 
)

Allocate a subscription, but do not activate it.

Parameters:
type the event type to subscribe to
cb the function to call when an event matches this subscription
userdata data to pass to the provided callback
This function should be used when you want to dynamically build a subscription.

Returns:
the allocated subscription, or NULL on failure
Since:
1.6.1

Definition at line 715 of file event.c.

References ast_atomic_fetchadd_int(), ast_calloc, ast_log(), and LOG_ERROR.

Referenced by ast_event_subscribe(), handle_cli_status(), and handle_devstate_change().

00717 {
00718    struct ast_event_sub *sub;
00719 
00720    if (type < 0 || type >= AST_EVENT_TOTAL) {
00721       ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
00722       return NULL;
00723    }
00724 
00725    if (!(sub = ast_calloc(1, sizeof(*sub)))) {
00726       return NULL;
00727    }
00728 
00729    sub->type = type;
00730    sub->cb = cb;
00731    sub->userdata = userdata;
00732    sub->uniqueid = ast_atomic_fetchadd_int((int *) &sub_uniqueid, 1);
00733 
00734    return sub;
00735 }

const char* ast_event_subscriber_get_description ( struct ast_event_sub sub  ) 

Get description for a subscription.

Parameters:
sub subscription
Returns:
string description of the subscription

Definition at line 952 of file event.c.

References ast_event_sub::description.

00953 {
00954    return sub ? sub->description : NULL;
00955 }

struct ast_event_sub* ast_event_unsubscribe ( struct ast_event_sub event_sub  ) 

Un-subscribe from events.

Parameters:
event_sub This is the reference to the subscription returned by ast_event_subscribe.
This function will remove a subscription and free the associated data structures.

Returns:
NULL for convenience.
Version:
1.6.1 return changed to NULL

Definition at line 957 of file event.c.

References AST_DLLIST_REMOVE, ast_event_check_subscriber(), ast_event_destroy(), AST_EVENT_IE_DESCRIPTION, AST_EVENT_IE_END, AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_UNIQUEID, ast_event_new(), ast_event_queue(), ast_event_sub_destroy(), AST_EVENT_SUB_NONE, ast_event_subs, AST_EVENT_UNSUB, AST_RWDLLIST_UNLOCK, AST_RWDLLIST_WRLOCK, ast_event_sub::description, ast_event_sub::type, and ast_event_sub::uniqueid.

Referenced by add_peer_mwi_subs(), cc_generic_agent_destructor(), destroy_dahdi_pvt(), destroy_mailbox(), generic_agent_devstate_unsubscribe(), generic_monitor_instance_list_destructor(), network_change_event_unsubscribe(), peer_destructor(), publish_event_destroy(), sig_pri_start_pri(), sig_pri_stop_pri(), stop_poll_thread(), and unload_module().

00958 {
00959    struct ast_event *event;
00960 
00961    AST_RWDLLIST_WRLOCK(&ast_event_subs[sub->type]);
00962    AST_DLLIST_REMOVE(&ast_event_subs[sub->type], sub, entry);
00963    AST_RWDLLIST_UNLOCK(&ast_event_subs[sub->type]);
00964 
00965    if (ast_event_check_subscriber(AST_EVENT_UNSUB,
00966       AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_PLTYPE_UINT, sub->type,
00967       AST_EVENT_IE_END) != AST_EVENT_SUB_NONE) {
00968 
00969       event = ast_event_new(AST_EVENT_UNSUB,
00970          AST_EVENT_IE_UNIQUEID,    AST_EVENT_IE_PLTYPE_UINT, sub->uniqueid,
00971          AST_EVENT_IE_EVENTTYPE,   AST_EVENT_IE_PLTYPE_UINT, sub->type,
00972          AST_EVENT_IE_DESCRIPTION, AST_EVENT_IE_PLTYPE_STR, sub->description,
00973          AST_EVENT_IE_END);
00974       if (event && ast_event_queue(event)) {
00975          ast_event_destroy(event);
00976       }
00977    }
00978 
00979    ast_event_sub_destroy(sub);
00980 
00981    return NULL;
00982 }

static int dump_cache_cb ( void *  obj,
void *  arg,
int  flags 
) [static]

Definition at line 608 of file event.c.

References AST_LIST_TRAVERSE, ast_event_sub::cb, ast_event_ref::event, event_sub, ast_event_sub::ie_vals, match_ie_val(), and ast_event_sub::userdata.

Referenced by ast_event_dump_cache().

00609 {
00610    const struct ast_event_ref *event_ref = obj;
00611    const struct ast_event *event = event_ref->event;
00612    const struct ast_event_sub *event_sub = arg;
00613    struct ast_event_ie_val *ie_val = NULL;
00614 
00615    AST_LIST_TRAVERSE(&event_sub->ie_vals, ie_val, entry) {
00616       if (!match_ie_val(event, ie_val, NULL)) {
00617          break;
00618       }
00619    }
00620 
00621    if (!ie_val) {
00622       /* All parameters were matched on this cache entry, so dump it */
00623       event_sub->cb(event, event_sub->userdata);
00624    }
00625 
00626    return 0;
00627 }

static void dump_raw_ie ( struct ast_event_iterator i,
struct ast_cli_args a 
) [static]

Definition at line 1618 of file event.c.

References ast_cli(), ast_eid_to_str(), ast_event_get_ie_type_name(), AST_EVENT_IE_EID, ast_event_iterator_get_ie_raw(), ast_event_iterator_get_ie_type(), and ast_cli_args::fd.

Referenced by event_dump_cli().

01619 {
01620    char eid_buf[32];
01621    enum ast_event_ie_type ie_type;
01622    const char *ie_type_name;
01623 
01624    ie_type = ast_event_iterator_get_ie_type(i);
01625    ie_type_name = ast_event_get_ie_type_name(ie_type);
01626 
01627    switch (ie_type) {
01628    case AST_EVENT_IE_EID:
01629       ast_eid_to_str(eid_buf, sizeof(eid_buf), ast_event_iterator_get_ie_raw(i));
01630       ast_cli(a->fd, "%.30s: %s\n", ie_type_name, eid_buf);
01631       break;
01632    default:
01633       ast_cli(a->fd, "%s\n", ie_type_name);
01634       break;
01635    }
01636 }

static char* event_dump_cache ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 1689 of file event.c.

References ao2_callback, ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ARRAY_LEN, ast_cli(), ast_cli_complete(), ast_event_cache, ast_event_get_ie_type_name(), ast_event_str_to_event_type(), cache_args, cached_event_types, CLI_GENERATE, CLI_HANDLER, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, container, event_dump_cli(), ast_cli_args::fd, ast_cli_args::n, OBJ_NODATA, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

01690 {
01691    enum ast_event_type event_type;
01692    enum ast_event_ie_type *cache_args;
01693    int i;
01694 
01695    switch (cmd) {
01696    case CLI_INIT:
01697       e->command = "event dump cache";
01698       e->usage =
01699          "Usage: event dump cache <event type>\n"
01700          "       Dump all of the cached events for the given event type.\n"
01701          "       This is primarily intended for debugging.\n";
01702       return NULL;
01703    case CLI_GENERATE:
01704       if (a->pos == 3) {
01705          return ast_cli_complete(a->word, cached_event_types, a->n);
01706       }
01707       return NULL;
01708    case CLI_HANDLER:
01709       break;
01710    }
01711 
01712    if (a->argc != e->args + 1) {
01713       return CLI_SHOWUSAGE;
01714    }
01715 
01716    if (ast_event_str_to_event_type(a->argv[e->args], &event_type)) {
01717       ast_cli(a->fd, "Invalid cached event type: '%s'\n", a->argv[e->args]);
01718       return CLI_SHOWUSAGE;
01719    }
01720 
01721    if (!ast_event_cache[event_type].container) {
01722       ast_cli(a->fd, "Event type '%s' has no cache.\n", a->argv[e->args]);
01723       return CLI_SUCCESS;
01724    }
01725 
01726    ast_cli(a->fd, "Event Type: %s\n", a->argv[e->args]);
01727    ast_cli(a->fd, "Cache Unique Keys:\n");
01728    cache_args = ast_event_cache[event_type].cache_args;
01729    for (i = 0; i < ARRAY_LEN(ast_event_cache[0].cache_args) && cache_args[i]; i++) {
01730       ast_cli(a->fd, "--> %s\n", ast_event_get_ie_type_name(cache_args[i]));
01731    }
01732 
01733    ast_cli(a->fd, "\n--- Begin Cache Dump ---\n\n");
01734    ao2_callback(ast_event_cache[event_type].container, OBJ_NODATA, event_dump_cli, a);
01735    ast_cli(a->fd, "--- End Cache Dump ---\n\n");
01736 
01737    return CLI_SUCCESS;
01738 }

static int event_dump_cli ( void *  obj,
void *  arg,
int  flags 
) [static]

Definition at line 1638 of file event.c.

References ast_cli(), ast_event_get_ie_pltype(), ast_event_get_ie_type_name(), ast_event_get_type_name(), AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_event_iterator_get_ie_bitflags(), ast_event_iterator_get_ie_str(), ast_event_iterator_get_ie_type(), ast_event_iterator_get_ie_uint(), ast_event_iterator_init(), ast_event_iterator_next(), dump_raw_ie(), ast_event_iterator::event, ast_event_ref::event, and ast_cli_args::fd.

Referenced by event_dump_cache().

01639 {
01640    const struct ast_event_ref *event_ref = obj;
01641    const struct ast_event *event = event_ref->event;
01642    struct ast_cli_args *a = arg;
01643    struct ast_event_iterator i;
01644 
01645    if (ast_event_iterator_init(&i, event)) {
01646       ast_cli(a->fd, "Failed to initialize event iterator.  :-(\n");
01647       return 0;
01648    }
01649 
01650    ast_cli(a->fd, "Event: %s\n", ast_event_get_type_name(event));
01651 
01652    do {
01653       enum ast_event_ie_type ie_type;
01654       enum ast_event_ie_pltype ie_pltype;
01655       const char *ie_type_name;
01656 
01657       ie_type = ast_event_iterator_get_ie_type(&i);
01658       ie_type_name = ast_event_get_ie_type_name(ie_type);
01659       ie_pltype = ast_event_get_ie_pltype(ie_type);
01660 
01661       switch (ie_pltype) {
01662       case AST_EVENT_IE_PLTYPE_UNKNOWN:
01663       case AST_EVENT_IE_PLTYPE_EXISTS:
01664          ast_cli(a->fd, "%s\n", ie_type_name);
01665          break;
01666       case AST_EVENT_IE_PLTYPE_STR:
01667          ast_cli(a->fd, "%.30s: %s\n", ie_type_name,
01668                ast_event_iterator_get_ie_str(&i));
01669          break;
01670       case AST_EVENT_IE_PLTYPE_UINT:
01671          ast_cli(a->fd, "%.30s: %u\n", ie_type_name,
01672                ast_event_iterator_get_ie_uint(&i));
01673          break;
01674       case AST_EVENT_IE_PLTYPE_BITFLAGS:
01675          ast_cli(a->fd, "%.30s: %u\n", ie_type_name,
01676                ast_event_iterator_get_ie_bitflags(&i));
01677          break;
01678       case AST_EVENT_IE_PLTYPE_RAW:
01679          dump_raw_ie(&i, a);
01680          break;
01681       }
01682    } while (!ast_event_iterator_next(&i));
01683 
01684    ast_cli(a->fd, "\n");
01685 
01686    return 0;
01687 }

static void event_update_cache ( struct ao2_container cache,
struct ast_event event 
) [static]

Definition at line 1393 of file event.c.

References alloc_event_ref(), ao2_callback, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_event_cmp(), ast_event_destroy(), ast_event_dup(), cache, ast_event_ref::event, OBJ_MULTIPLE, OBJ_NODATA, OBJ_POINTER, and OBJ_UNLINK.

Referenced by ast_event_queue_and_cache().

01394 {
01395    struct ast_event_ref tmp_event_ref = {
01396       .event = event,
01397    };
01398    struct ast_event *dup_event;
01399    struct ast_event_ref *event_ref;
01400 
01401    /* Hold the cache container lock while it is updated. */
01402    ao2_lock(cache);
01403 
01404    /* Remove matches from the cache. */
01405    ao2_callback(cache, OBJ_POINTER | OBJ_UNLINK | OBJ_MULTIPLE | OBJ_NODATA,
01406       ast_event_cmp, &tmp_event_ref);
01407 
01408    /* Save a copy of the event in the cache. */
01409    dup_event = ast_event_dup(event);
01410    if (dup_event) {
01411       event_ref = alloc_event_ref();
01412       if (event_ref) {
01413          event_ref->event = dup_event;
01414          ao2_link(cache, event_ref);
01415          ao2_ref(event_ref, -1);
01416       } else {
01417          ast_event_destroy(dup_event);
01418       }
01419    }
01420 
01421    ao2_unlock(cache);
01422 }

static struct ast_event* gen_sub_event ( struct ast_event_sub sub  )  [static]

Definition at line 636 of file event.c.

References ast_event_append_ie_bitflags(), ast_event_append_ie_raw(), ast_event_append_ie_str(), ast_event_append_ie_uint(), AST_EVENT_IE_DESCRIPTION, AST_EVENT_IE_END, AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_EXISTS, AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, AST_EVENT_IE_UNIQUEID, ast_event_new(), AST_EVENT_SUB, AST_LIST_TRAVERSE, ast_event_sub::description, ast_event_ie_val::ie_pltype, ast_event_ie_val::ie_type, ast_event_sub::ie_vals, ast_event_ie_val::payload, ast_event_ie_val::raw, ast_event_ie_val::raw_datalen, ast_event_ie_val::str, ast_event_sub::type, ast_event_ie_val::uint, and ast_event_sub::uniqueid.

Referenced by ast_event_report_subs(), and ast_event_sub_activate().

00637 {
00638    struct ast_event_ie_val *ie_val;
00639    struct ast_event *event;
00640 
00641    event = ast_event_new(AST_EVENT_SUB,
00642       AST_EVENT_IE_UNIQUEID,    AST_EVENT_IE_PLTYPE_UINT, sub->uniqueid,
00643       AST_EVENT_IE_EVENTTYPE,   AST_EVENT_IE_PLTYPE_UINT, sub->type,
00644       AST_EVENT_IE_DESCRIPTION, AST_EVENT_IE_PLTYPE_STR, sub->description,
00645       AST_EVENT_IE_END);
00646    if (!event)
00647       return NULL;
00648 
00649    AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
00650       switch (ie_val->ie_pltype) {
00651       case AST_EVENT_IE_PLTYPE_UNKNOWN:
00652          break;
00653       case AST_EVENT_IE_PLTYPE_EXISTS:
00654          ast_event_append_ie_uint(&event, AST_EVENT_IE_EXISTS, ie_val->ie_type);
00655          break;
00656       case AST_EVENT_IE_PLTYPE_UINT:
00657          ast_event_append_ie_uint(&event, ie_val->ie_type, ie_val->payload.uint);
00658          break;
00659       case AST_EVENT_IE_PLTYPE_BITFLAGS:
00660          ast_event_append_ie_bitflags(&event, ie_val->ie_type, ie_val->payload.uint);
00661          break;
00662       case AST_EVENT_IE_PLTYPE_STR:
00663          ast_event_append_ie_str(&event, ie_val->ie_type, ie_val->payload.str);
00664          break;
00665       case AST_EVENT_IE_PLTYPE_RAW:
00666          ast_event_append_ie_raw(&event, ie_val->ie_type, ie_val->payload.raw, ie_val->raw_datalen);
00667          break;
00668       }
00669       if (!event)
00670          break;
00671    }
00672 
00673    return event;
00674 }

static int handle_event ( void *  data  )  [static]

Definition at line 1441 of file event.c.

References ao2_ref, ARRAY_LEN, AST_EVENT_ALL, ast_event_subs, AST_LIST_TRAVERSE, AST_RWDLLIST_RDLOCK, AST_RWDLLIST_TRAVERSE, AST_RWDLLIST_UNLOCK, ast_event_sub::cb, ast_event_ref::event, ast_event_sub::ie_vals, match_ie_val(), and ast_event_sub::userdata.

01442 {
01443    struct ast_event_ref *event_ref = data;
01444    struct ast_event_sub *sub;
01445    const enum ast_event_type event_types[] = {
01446       ntohs(event_ref->event->type),
01447       AST_EVENT_ALL
01448    };
01449    int i;
01450 
01451    for (i = 0; i < ARRAY_LEN(event_types); i++) {
01452       AST_RWDLLIST_RDLOCK(&ast_event_subs[event_types[i]]);
01453       AST_RWDLLIST_TRAVERSE(&ast_event_subs[event_types[i]], sub, entry) {
01454          struct ast_event_ie_val *ie_val;
01455 
01456          AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
01457             if (!match_ie_val(event_ref->event, ie_val, NULL)) {
01458                /* The current subscription ie did not match an event ie. */
01459                break;
01460             }
01461          }
01462          if (ie_val) {
01463             /* The event did not match this subscription. */
01464             continue;
01465          }
01466          sub->cb(event_ref->event, sub->userdata);
01467       }
01468       AST_RWDLLIST_UNLOCK(&ast_event_subs[event_types[i]]);
01469    }
01470 
01471    ao2_ref(event_ref, -1);
01472 
01473    return 0;
01474 }

static int match_ie_val ( const struct ast_event event,
const struct ast_event_ie_val ie_val,
const struct ast_event event2 
) [static]

Definition at line 546 of file event.c.

References ast_event_get_ie_bitflags(), ast_event_get_ie_raw(), ast_event_get_ie_raw_payload_len(), ast_event_get_ie_str(), ast_event_get_ie_str_hash(), ast_event_get_ie_uint(), AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, ast_event_ie_val::hash, ast_event_ie_val::ie_pltype, ast_event_ie_val::ie_type, ast_event_ie_val::payload, ast_event_ie_val::raw, ast_event_ie_val::raw_datalen, ast_event_ie_val::str, str, and ast_event_ie_val::uint.

Referenced by ast_event_cmp(), dump_cache_cb(), and handle_event().

00548 {
00549    switch (ie_val->ie_pltype) {
00550    case AST_EVENT_IE_PLTYPE_UINT:
00551    {
00552       uint32_t val = event2 ? ast_event_get_ie_uint(event2, ie_val->ie_type) : ie_val->payload.uint;
00553 
00554       return (val == ast_event_get_ie_uint(event, ie_val->ie_type)) ? 1 : 0;
00555    }
00556 
00557    case AST_EVENT_IE_PLTYPE_BITFLAGS:
00558    {
00559       uint32_t flags = event2 ? ast_event_get_ie_uint(event2, ie_val->ie_type) : ie_val->payload.uint;
00560 
00561       /*
00562        * If the subscriber has requested *any* of the bitflags that this event provides,
00563        * then it's a match.
00564        */
00565       return (flags & ast_event_get_ie_bitflags(event, ie_val->ie_type)) ? 1 : 0;
00566    }
00567 
00568    case AST_EVENT_IE_PLTYPE_STR:
00569    {
00570       const char *str;
00571       uint32_t hash;
00572 
00573       hash = event2 ? ast_event_get_ie_str_hash(event2, ie_val->ie_type) : ie_val->payload.hash;
00574       if (hash != ast_event_get_ie_str_hash(event, ie_val->ie_type)) {
00575          return 0;
00576       }
00577 
00578       str = event2 ? ast_event_get_ie_str(event2, ie_val->ie_type) : ie_val->payload.str;
00579       if (str && !strcmp(str, ast_event_get_ie_str(event, ie_val->ie_type))) {
00580          return 1;
00581       }
00582 
00583       return 0;
00584    }
00585 
00586    case AST_EVENT_IE_PLTYPE_RAW:
00587    {
00588       const void *buf = event2 ? ast_event_get_ie_raw(event2, ie_val->ie_type) : ie_val->payload.raw;
00589       uint16_t ie_payload_len = event2 ? ast_event_get_ie_raw_payload_len(event2, ie_val->ie_type) : ie_val->raw_datalen;
00590 
00591       return (buf
00592          && ie_payload_len == ast_event_get_ie_raw_payload_len(event, ie_val->ie_type)
00593          && !memcmp(buf, ast_event_get_ie_raw(event, ie_val->ie_type), ie_payload_len)) ? 1 : 0;
00594    }
00595 
00596    case AST_EVENT_IE_PLTYPE_EXISTS:
00597    {
00598       return ast_event_get_ie_raw(event, ie_val->ie_type) ? 1 : 0;
00599    }
00600 
00601    case AST_EVENT_IE_PLTYPE_UNKNOWN:
00602       return 0;
00603    }
00604 
00605    return 0;
00606 }

static int match_sub_ie_val_to_event ( const struct ast_event_ie_val sub_ie_val,
const struct ast_ev_check_list check_ie_vals 
) [static]

Definition at line 378 of file event.c.

References AST_EVENT_IE_PLTYPE_BITFLAGS, AST_EVENT_IE_PLTYPE_EXISTS, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_PLTYPE_UNKNOWN, AST_LIST_TRAVERSE, ast_event_ie_val::ie_pltype, ast_event_ie_val::ie_type, ast_event_ie_val::payload, ast_event_ie_val::raw, ast_event_ie_val::raw_datalen, ast_event_ie_val::str, and ast_event_ie_val::uint.

Referenced by ast_event_check_subscriber().

00379 {
00380    const struct ast_event_ie_val *event_ie_val;
00381    int res = 0;
00382 
00383    AST_LIST_TRAVERSE(&check_ie_vals->ie_vals, event_ie_val, entry) {
00384       if (sub_ie_val->ie_type == event_ie_val->ie_type) {
00385          break;
00386       }
00387    }
00388    if (!event_ie_val) {
00389       /* We did not find the event ie the subscriber cares about. */
00390       return 0;
00391    }
00392 
00393    if (sub_ie_val->ie_pltype != event_ie_val->ie_pltype) {
00394       if (sub_ie_val->ie_pltype == AST_EVENT_IE_PLTYPE_EXISTS) {
00395          /* The subscription only cares that this ie exists. */
00396          return 1;
00397       }
00398       /* Payload types do not match. */
00399       return 0;
00400    }
00401 
00402    switch (sub_ie_val->ie_pltype) {
00403    case AST_EVENT_IE_PLTYPE_UINT:
00404       res = (sub_ie_val->payload.uint == event_ie_val->payload.uint);
00405       break;
00406    case AST_EVENT_IE_PLTYPE_BITFLAGS:
00407       /*
00408        * If the subscriber has requested *any* of the bitflags we are providing,
00409        * then it's a match.
00410        */
00411       res = (sub_ie_val->payload.uint & event_ie_val->payload.uint);
00412       break;
00413    case AST_EVENT_IE_PLTYPE_STR:
00414       res = !strcmp(sub_ie_val->payload.str, event_ie_val->payload.str);
00415       break;
00416    case AST_EVENT_IE_PLTYPE_RAW:
00417       res = (sub_ie_val->raw_datalen == event_ie_val->raw_datalen
00418          && !memcmp(sub_ie_val->payload.raw, event_ie_val->payload.raw,
00419             sub_ie_val->raw_datalen));
00420       break;
00421    case AST_EVENT_IE_PLTYPE_EXISTS:
00422       /* Should never get here since check_ie_vals cannot have this type. */
00423       break;
00424    case AST_EVENT_IE_PLTYPE_UNKNOWN:
00425       /*
00426        * Should never be in a subscription event ie val list and
00427        * check_ie_vals cannot have this type either.
00428        */
00429       break;
00430    }
00431 
00432    return res;
00433 }


Variable Documentation

struct { ... } ast_event_cache[AST_EVENT_TOTAL] [static]

Event types that are kept in the cache.

Referenced by ast_event_cmp(), ast_event_dump_cache(), ast_event_get_cached(), ast_event_hash(), ast_event_init(), ast_event_queue_and_cache(), and event_dump_cache().

struct ast_event_sub_list ast_event_subs[AST_EVENT_TOTAL] [static]

Event subscriptions The event subscribers are indexed by which event they are subscribed to.

Referenced by ast_event_check_subscriber(), ast_event_init(), ast_event_report_subs(), ast_event_sub_activate(), ast_event_unsubscribe(), and handle_event().

enum ast_event_ie_type cache_args[MAX_CACHE_ARGS]

Information Elements used for caching.

This array is the set of information elements that will be unique among all events in the cache for this event type. When a new event gets cached, a previous event with the same values for these information elements will be replaced.

Definition at line 170 of file event.c.

Referenced by ast_event_cmp(), and event_dump_cache().

const char* const cached_event_types[] = { "MWI", "DeviceState", "DeviceStateChange", NULL } [static]

Names of cached event types, for CLI tab completion.

Note:
These names must match what is in the event_names array.

Definition at line 191 of file event.c.

Referenced by event_dump_cache().

struct ao2_container* container

Container of cached events.

This gets allocated in ast_event_init() when Asterisk starts for the event types declared as using the cache.

Definition at line 159 of file event.c.

struct ast_cli_entry event_cli[] [static]

Initial value:

 {
   { .handler =  event_dump_cache , .summary =  "Dump the internal event cache (for debugging)" ,__VA_ARGS__ },
}

Definition at line 1740 of file event.c.

Referenced by ast_event_init().

struct ast_taskprocessor* event_dispatcher [static]

Definition at line 43 of file event.c.

Referenced by ast_event_init(), and ast_event_queue().

const char* const event_names[AST_EVENT_TOTAL] [static]

Event Names.

Definition at line 196 of file event.c.

Referenced by ast_event_get_type_name(), and ast_event_str_to_event_type().

ao2_hash_fn* hash_fn

Event type specific hash function.

Definition at line 161 of file event.c.

Referenced by ast_event_hash(), and ast_event_init().

struct ie_map ie_maps[AST_EVENT_IE_TOTAL] [static]

IE payload types and names.

Referenced by ast_event_get_ie_pltype(), ast_event_get_ie_type_name(), and ast_event_str_to_ie_type().

uint32_t sub_uniqueid [static]

Definition at line 130 of file event.c.


Generated on Mon Mar 19 11:30:47 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7