mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-08-13 17:38:59 +00:00
add esl and fs_cli
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@10890 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale
553
libs/esl/src/esl_event.c
Normal file
553
libs/esl/src/esl_event.c
Normal file
@@ -0,0 +1,553 @@
|
||||
/*
|
||||
* Copyright (c) 2007, Anthony Minessale II
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* * Neither the name of the original author; nor the names of any contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
|
||||
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <esl.h>
|
||||
#include <esl_event.h>
|
||||
|
||||
static char *my_dup(const char *s)
|
||||
{
|
||||
size_t len = strlen(s) + 1;
|
||||
void *new = malloc(len);
|
||||
esl_assert(new);
|
||||
|
||||
return (char *) memcpy(new, s, len);
|
||||
}
|
||||
|
||||
#ifndef ALLOC
|
||||
#define ALLOC(size) malloc(size)
|
||||
#endif
|
||||
#ifndef DUP
|
||||
#define DUP(str) my_dup(str)
|
||||
#endif
|
||||
#ifndef FREE
|
||||
#define FREE(ptr) esl_safe_free(ptr)
|
||||
#endif
|
||||
|
||||
/* make sure this is synced with the esl_event_types_t enum in esl_types.h
|
||||
also never put any new ones before EVENT_ALL
|
||||
*/
|
||||
static char *EVENT_NAMES[] = {
|
||||
"CUSTOM",
|
||||
"CHANNEL_CREATE",
|
||||
"CHANNEL_DESTROY",
|
||||
"CHANNEL_STATE",
|
||||
"CHANNEL_ANSWER",
|
||||
"CHANNEL_HANGUP",
|
||||
"CHANNEL_EXECUTE",
|
||||
"CHANNEL_EXECUTE_COMPLETE",
|
||||
"CHANNEL_BRIDGE",
|
||||
"CHANNEL_UNBRIDGE",
|
||||
"CHANNEL_PROGRESS",
|
||||
"CHANNEL_PROGRESS_MEDIA",
|
||||
"CHANNEL_OUTGOING",
|
||||
"CHANNEL_PARK",
|
||||
"CHANNEL_UNPARK",
|
||||
"CHANNEL_APPLICATION",
|
||||
"CHANNEL_ORIGINATE",
|
||||
"CHANNEL_UUID",
|
||||
"API",
|
||||
"LOG",
|
||||
"INBOUND_CHAN",
|
||||
"OUTBOUND_CHAN",
|
||||
"STARTUP",
|
||||
"SHUTDOWN",
|
||||
"PUBLISH",
|
||||
"UNPUBLISH",
|
||||
"TALK",
|
||||
"NOTALK",
|
||||
"SESSION_CRASH",
|
||||
"MODULE_LOAD",
|
||||
"MODULE_UNLOAD",
|
||||
"DTMF",
|
||||
"MESSAGE",
|
||||
"PRESENCE_IN",
|
||||
"NOTIFY_IN",
|
||||
"PRESENCE_OUT",
|
||||
"PRESENCE_PROBE",
|
||||
"MESSAGE_WAITING",
|
||||
"MESSAGE_QUERY",
|
||||
"ROSTER",
|
||||
"CODEC",
|
||||
"BACKGROUND_JOB",
|
||||
"DETECTED_SPEECH",
|
||||
"DETECTED_TONE",
|
||||
"PRIVATE_COMMAND",
|
||||
"HEARTBEAT",
|
||||
"TRAP",
|
||||
"ADD_SCHEDULE",
|
||||
"DEL_SCHEDULE",
|
||||
"EXE_SCHEDULE",
|
||||
"RE_SCHEDULE",
|
||||
"RELOADXML",
|
||||
"NOTIFY",
|
||||
"SEND_MESSAGE",
|
||||
"RECV_MESSAGE",
|
||||
"REQUEST_PARAMS",
|
||||
"CHANNEL_DATA",
|
||||
"GENERAL",
|
||||
"COMMAND",
|
||||
"SESSION_HEARTBEAT",
|
||||
"ALL"
|
||||
};
|
||||
|
||||
const char *esl_event_name(esl_event_types_t event)
|
||||
{
|
||||
return EVENT_NAMES[event];
|
||||
}
|
||||
|
||||
esl_status_t esl_name_event(const char *name, esl_event_types_t *type)
|
||||
{
|
||||
esl_event_types_t x;
|
||||
|
||||
for (x = 0; x <= ESL_EVENT_ALL; x++) {
|
||||
if ((strlen(name) > 13 && !strcasecmp(name + 13, EVENT_NAMES[x])) || !strcasecmp(name, EVENT_NAMES[x])) {
|
||||
*type = x;
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
|
||||
esl_status_t esl_event_create_subclass(esl_event_t **event, esl_event_types_t event_id, const char *subclass_name)
|
||||
{
|
||||
*event = NULL;
|
||||
|
||||
if (event_id != ESL_EVENT_CUSTOM && subclass_name) {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
*event = ALLOC(sizeof(esl_event_t));
|
||||
esl_assert(*event);
|
||||
|
||||
|
||||
memset(*event, 0, sizeof(esl_event_t));
|
||||
|
||||
(*event)->event_id = event_id;
|
||||
|
||||
if (subclass_name) {
|
||||
(*event)->subclass_name = DUP(subclass_name);
|
||||
esl_event_add_header_string(*event, ESL_STACK_BOTTOM, "Event-Subclass", subclass_name);
|
||||
}
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
const char *esl_priority_name(esl_priority_t priority)
|
||||
{
|
||||
switch (priority) { /*lol */
|
||||
case ESL_PRIORITY_NORMAL:
|
||||
return "NORMAL";
|
||||
case ESL_PRIORITY_LOW:
|
||||
return "LOW";
|
||||
case ESL_PRIORITY_HIGH:
|
||||
return "HIGH";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
}
|
||||
|
||||
esl_status_t esl_event_set_priority(esl_event_t *event, esl_priority_t priority)
|
||||
{
|
||||
event->priority = priority;
|
||||
esl_event_add_header_string(event, ESL_STACK_TOP, "priority", esl_priority_name(priority));
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
#define ESL_HASH_KEY_STRING -1
|
||||
|
||||
static unsigned int esl_ci_hashfunc_default(const char *char_key, esl_ssize_t *klen)
|
||||
|
||||
{
|
||||
unsigned int hash = 0;
|
||||
const unsigned char *key = (const unsigned char *)char_key;
|
||||
const unsigned char *p;
|
||||
esl_ssize_t i;
|
||||
|
||||
if (*klen == ESL_HASH_KEY_STRING) {
|
||||
for (p = key; *p; p++) {
|
||||
hash = hash * 33 + tolower(*p);
|
||||
}
|
||||
*klen = p - key;
|
||||
}
|
||||
else {
|
||||
for (p = key, i = *klen; i; i--, p++) {
|
||||
hash = hash * 33 + tolower(*p);
|
||||
}
|
||||
}
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
|
||||
char *esl_event_get_header(esl_event_t *event, const char *header_name)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
esl_ssize_t hlen = -1;
|
||||
unsigned long hash = 0;
|
||||
|
||||
esl_assert(event);
|
||||
|
||||
if (!header_name) return NULL;
|
||||
|
||||
hash = esl_ci_hashfunc_default(header_name, &hlen);
|
||||
|
||||
for (hp = event->headers; hp; hp = hp->next) {
|
||||
if ((!hp->hash || hash == hp->hash) && !strcasecmp(hp->name, header_name) ) {
|
||||
return hp->value;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *esl_event_get_body(esl_event_t *event)
|
||||
{
|
||||
return (event ? event->body : NULL);
|
||||
}
|
||||
|
||||
esl_status_t esl_event_del_header(esl_event_t *event, const char *header_name)
|
||||
{
|
||||
esl_event_header_t *hp, *lp = NULL, *tp;
|
||||
esl_status_t status = ESL_FAIL;
|
||||
int x = 0;
|
||||
esl_ssize_t hlen = -1;
|
||||
unsigned long hash = 0;
|
||||
|
||||
tp = event->headers;
|
||||
while (tp) {
|
||||
hp = tp;
|
||||
tp = tp->next;
|
||||
|
||||
x++;
|
||||
esl_assert(x < 1000);
|
||||
hash = esl_ci_hashfunc_default(header_name, &hlen);
|
||||
|
||||
if ((!hp->hash || hash == hp->hash) && !strcasecmp(header_name, hp->name)) {
|
||||
if (lp) {
|
||||
lp->next = hp->next;
|
||||
} else {
|
||||
event->headers = hp->next;
|
||||
}
|
||||
if (hp == event->last_header || !hp->next) {
|
||||
event->last_header = lp;
|
||||
}
|
||||
FREE(hp->name);
|
||||
FREE(hp->value);
|
||||
memset(hp, 0, sizeof(*hp));
|
||||
FREE(hp);
|
||||
|
||||
status = ESL_SUCCESS;
|
||||
} else {
|
||||
lp = hp;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
esl_status_t esl_event_base_add_header(esl_event_t *event, esl_stack_t stack, const char *header_name, char *data)
|
||||
{
|
||||
esl_event_header_t *header;
|
||||
esl_ssize_t hlen = -1;
|
||||
|
||||
header = ALLOC(sizeof(*header));
|
||||
esl_assert(header);
|
||||
|
||||
memset(header, 0, sizeof(*header));
|
||||
|
||||
header->name = DUP(header_name);
|
||||
header->value = data;
|
||||
header->hash = esl_ci_hashfunc_default(header->name, &hlen);
|
||||
|
||||
if (stack == ESL_STACK_TOP) {
|
||||
header->next = event->headers;
|
||||
event->headers = header;
|
||||
if (!event->last_header) {
|
||||
event->last_header = header;
|
||||
}
|
||||
} else {
|
||||
if (event->last_header) {
|
||||
event->last_header->next = header;
|
||||
} else {
|
||||
event->headers = header;
|
||||
header->next = NULL;
|
||||
}
|
||||
event->last_header = header;
|
||||
}
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
esl_status_t esl_event_add_header(esl_event_t *event, esl_stack_t stack, const char *header_name, const char *fmt, ...)
|
||||
{
|
||||
int ret = 0;
|
||||
char *data;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
ret = vasprintf(&data, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (ret == -1) {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
return esl_event_base_add_header(event, stack, header_name, data);
|
||||
}
|
||||
|
||||
esl_status_t esl_event_add_header_string(esl_event_t *event, esl_stack_t stack, const char *header_name, const char *data)
|
||||
{
|
||||
if (data) {
|
||||
return esl_event_base_add_header(event, stack, header_name, DUP(data));
|
||||
}
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
esl_status_t esl_event_add_body(esl_event_t *event, const char *fmt, ...)
|
||||
{
|
||||
int ret = 0;
|
||||
char *data;
|
||||
|
||||
va_list ap;
|
||||
if (fmt) {
|
||||
va_start(ap, fmt);
|
||||
ret = vasprintf(&data, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (ret == -1) {
|
||||
return ESL_FAIL;
|
||||
} else {
|
||||
esl_safe_free(event->body);
|
||||
event->body = data;
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
} else {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
}
|
||||
|
||||
void esl_event_destroy(esl_event_t **event)
|
||||
{
|
||||
esl_event_t *ep = *event;
|
||||
esl_event_header_t *hp, *this;
|
||||
|
||||
if (ep) {
|
||||
for (hp = ep->headers; hp;) {
|
||||
this = hp;
|
||||
hp = hp->next;
|
||||
FREE(this->name);
|
||||
FREE(this->value);
|
||||
memset(this, 0, sizeof(*this));
|
||||
FREE(this);
|
||||
}
|
||||
FREE(ep->body);
|
||||
FREE(ep->subclass_name);
|
||||
memset(ep, 0, sizeof(*ep));
|
||||
FREE(ep);
|
||||
}
|
||||
*event = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
esl_status_t esl_event_dup(esl_event_t **event, esl_event_t *todup)
|
||||
{
|
||||
esl_event_header_t *header, *hp, *hp2, *last = NULL;
|
||||
|
||||
if (esl_event_create_subclass(event, todup->event_id, todup->subclass_name) != ESL_SUCCESS) {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
if (todup->subclass_name) {
|
||||
(*event)->subclass_name = DUP(todup->subclass_name);
|
||||
}
|
||||
(*event)->event_user_data = todup->event_user_data;
|
||||
(*event)->bind_user_data = todup->bind_user_data;
|
||||
|
||||
hp2 = (*event)->headers;
|
||||
|
||||
for (hp = todup->headers; hp; hp = hp->next) {
|
||||
header = ALLOC(sizeof(*header));
|
||||
esl_assert(header);
|
||||
|
||||
memset(header, 0, sizeof(*header));
|
||||
|
||||
header->name = DUP(hp->name);
|
||||
header->value = DUP(hp->value);
|
||||
|
||||
if (last) {
|
||||
last->next = header;
|
||||
} else {
|
||||
(*event)->headers = header;
|
||||
}
|
||||
|
||||
(*event)->last_header = last = header;
|
||||
}
|
||||
|
||||
if (todup->body) {
|
||||
(*event)->body = DUP(todup->body);
|
||||
}
|
||||
|
||||
(*event)->key = todup->key;
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
esl_status_t esl_event_serialize(esl_event_t *event, char **str, esl_bool_t encode)
|
||||
{
|
||||
size_t len = 0;
|
||||
esl_event_header_t *hp;
|
||||
size_t llen = 0, dlen = 0, blocksize = 512, encode_len = 1536, new_len = 0;
|
||||
char *buf;
|
||||
char *encode_buf = NULL; /* used for url encoding of variables to make sure unsafe things stay out of the serialized copy */
|
||||
|
||||
*str = NULL;
|
||||
|
||||
dlen = blocksize * 2;
|
||||
|
||||
if (!(buf = malloc(dlen))) {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
/* go ahead and give ourselves some space to work with, should save a few reallocs */
|
||||
if (!(encode_buf = malloc(encode_len))) {
|
||||
esl_safe_free(buf);
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
/* esl_log_printf(ESL_CHANNEL_LOG, ESL_LOG_INFO, "hit serialized!.\n"); */
|
||||
for (hp = event->headers; hp; hp = hp->next) {
|
||||
/*
|
||||
* grab enough memory to store 3x the string (url encode takes one char and turns it into %XX)
|
||||
* so we could end up with a string that is 3 times the originals length, unlikely but rather
|
||||
* be safe than destroy the string, also add one for the null. And try to be smart about using
|
||||
* the memory, allocate and only reallocate if we need more. This avoids an alloc, free CPU
|
||||
* destroying loop.
|
||||
*/
|
||||
new_len = (strlen(hp->value) * 3) + 1;
|
||||
|
||||
if (encode_len < new_len) {
|
||||
char *tmp;
|
||||
/* esl_log_printf(ESL_CHANNEL_LOG, ESL_LOG_INFO, "Allocing %d was %d.\n", ((strlen(hp->value) * 3) + 1), encode_len); */
|
||||
/* we can use realloc for initial alloc as well, if encode_buf is zero it treats it as a malloc */
|
||||
|
||||
/* keep track of the size of our allocation */
|
||||
encode_len = new_len;
|
||||
|
||||
if (!(tmp = realloc(encode_buf, encode_len))) {
|
||||
/* oh boy, ram's gone, give back what little we grabbed and bail */
|
||||
esl_safe_free(buf);
|
||||
esl_safe_free(encode_buf);
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
encode_buf = tmp;
|
||||
}
|
||||
|
||||
/* handle any bad things in the string like newlines : etc that screw up the serialized format */
|
||||
if (encode) {
|
||||
esl_url_encode(hp->value, encode_buf, encode_len);
|
||||
} else {
|
||||
snprintf(encode_buf, encode_len, "[%s]", hp->value);
|
||||
}
|
||||
|
||||
llen = strlen(hp->name) + strlen(encode_buf) + 8;
|
||||
|
||||
if ((len + llen) > dlen) {
|
||||
char *m;
|
||||
dlen += (blocksize + (len + llen));
|
||||
if ((m = realloc(buf, dlen))) {
|
||||
buf = m;
|
||||
} else {
|
||||
/* we seem to be out of memory trying to resize the serialize string, give back what we already have and give up */
|
||||
esl_safe_free(buf);
|
||||
esl_safe_free(encode_buf);
|
||||
return ESL_FAIL;
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(buf + len, dlen - len, "%s: %s\n", hp->name, *encode_buf == '\0' ? "_undef_" : encode_buf);
|
||||
len = strlen(buf);
|
||||
}
|
||||
|
||||
/* we are done with the memory we used for encoding, give it back */
|
||||
esl_safe_free(encode_buf);
|
||||
|
||||
if (event->body) {
|
||||
int blen = (int) strlen(event->body);
|
||||
llen = blen;
|
||||
|
||||
if (blen) {
|
||||
llen += 25;
|
||||
} else {
|
||||
llen += 5;
|
||||
}
|
||||
|
||||
if ((len + llen) > dlen) {
|
||||
char *m;
|
||||
dlen += (blocksize + (len + llen));
|
||||
if ((m = realloc(buf, dlen))) {
|
||||
buf = m;
|
||||
} else {
|
||||
esl_safe_free(buf);
|
||||
return ESL_FAIL;
|
||||
}
|
||||
}
|
||||
|
||||
if (blen) {
|
||||
snprintf(buf + len, dlen - len, "\n%s", event->body);
|
||||
} else {
|
||||
snprintf(buf + len, dlen - len, "\n");
|
||||
}
|
||||
} else {
|
||||
snprintf(buf + len, dlen - len, "\n");
|
||||
}
|
||||
|
||||
*str = buf;
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/* For Emacs:
|
||||
* Local Variables:
|
||||
* mode:c
|
||||
* indent-tabs-mode:t
|
||||
* tab-width:4
|
||||
* c-basic-offset:4
|
||||
* End:
|
||||
* For VIM:
|
||||
* vim:set softtabstop=4 shiftwidth=4 tabstop=4:
|
||||
*/
|
||||
Reference in New Issue
Block a user