Author: anthm Date: Fri Dec 19 19:35:09 2008 New Revision: 10890 Log: add esl and fs_cli Added: freeswitch/trunk/libs/esl/ freeswitch/trunk/libs/esl/Makefile freeswitch/trunk/libs/esl/fs_cli.c freeswitch/trunk/libs/esl/src/ freeswitch/trunk/libs/esl/src/esl.c freeswitch/trunk/libs/esl/src/esl_event.c freeswitch/trunk/libs/esl/src/esl_threadmutex.c freeswitch/trunk/libs/esl/src/include/ freeswitch/trunk/libs/esl/src/include/esl.h freeswitch/trunk/libs/esl/src/include/esl_event.h freeswitch/trunk/libs/esl/src/include/esl_threadmutex.h freeswitch/trunk/libs/esl/testclient.c Added: freeswitch/trunk/libs/esl/Makefile ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/Makefile Fri Dec 19 19:35:09 2008 @@ -0,0 +1,26 @@ +PWD=$(shell pwd) +INCS=-I$(PWD)/src/include +LIBEDIT_DIR=../../libs/libedit +CFLAGS=$(INCS) -g -ggdb -I$(LIBEDIT_DIR)/src/ +MYLIB=libesl.a + +OBJS=src/esl.o src/esl_event.o src/esl_threadmutex.o + +all: $(MYLIB) fs_cli + +$(MYLIB): $(OBJS) $(HEADERS) + ar rcs $(MYLIB) $(OBJS) + ranlib $(MYLIB) + +%.o: %.c + $(CC) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@ + +test: $(MYLIB) + $(CC) $(CC_CFLAGS) $(CFLAGS) testclient.c -o testclient -L. -lesl + +fs_cli: $(MYLIB) fs_cli.c + $(CC) $(CC_CFLAGS) $(CFLAGS) fs_cli.c -o fs_cli -L. -L$(LIBEDIT_DIR)/src/.libs -lesl -ledit -lncurses -lpthread + +clean: + rm -f *.o src/*.o testclient fs_cli libesl.a *~ src/*~ src/include/*~ + Added: freeswitch/trunk/libs/esl/fs_cli.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/fs_cli.c Fri Dec 19 19:35:09 2008 @@ -0,0 +1,245 @@ +#include <stdio.h> +#include <stdlib.h> +#include <esl.h> +#include <signal.h> +#include <sys/select.h> + +#include <histedit.h> +static char prompt_str[512] = ""; +static char hostname[512] = ""; + +char *prompt(EditLine * e) +{ + if (*prompt_str == '\0') { + gethostname(hostname, sizeof(hostname)); + snprintf(prompt_str, sizeof(prompt_str), "freeswitch@%s> ", hostname); + } + + return prompt_str; + +} + +static EditLine *el; +static History *myhistory; +static HistEvent ev; +static char *hfile = NULL; +static int running = 1; +static int thread_running = 0; +static esl_mutex_t *global_mutex; + +static void handle_SIGINT(int sig) +{ + if (sig); + return; +} + +static const char* COLORS[] = { ESL_SEQ_DEFAULT_COLOR, ESL_SEQ_FRED, ESL_SEQ_FRED, + ESL_SEQ_FRED, ESL_SEQ_FMAGEN, ESL_SEQ_FCYAN, ESL_SEQ_FGREEN, ESL_SEQ_FYELLOW }; + + +static void *msg_thread_run(esl_thread_t *me, void *obj) +{ + + esl_handle_t *handle = (esl_handle_t *) obj; + + thread_running = 1; + + while(thread_running && handle->connected) { + fd_set rfds, efds; + struct timeval tv = { 0, 50 * 1000 }; + int max, activity, i = 0; + + esl_mutex_lock(global_mutex); + FD_ZERO(&rfds); + FD_ZERO(&efds); + FD_SET(handle->sock, &rfds); + FD_SET(handle->sock, &efds); + + max = handle->sock + 1; + + if ((activity = select(max, &rfds, NULL, &efds, &tv)) < 0) { + esl_mutex_unlock(global_mutex); + goto done; + } + + + if (activity && FD_ISSET(handle->sock, &rfds)) { + esl_recv(handle); + if (handle->last_event) { + const char *type = esl_event_get_header(handle->last_event, "content-type"); + if (!strcasecmp(type, "log/data")) { + int level; + if (strstr(handle->last_event->body, "[CONSOLE]")) { + level = 0; + } else if (strstr(handle->last_event->body, "[ALERT]")) { + level = 1; + } else if (strstr(handle->last_event->body, "[CRIT]")) { + level = 2; + } else if (strstr(handle->last_event->body, "[ERROR]")) { + level = 3; + } else if (strstr(handle->last_event->body, "[WARNING]")) { + level = 4; + } else if (strstr(handle->last_event->body, "[NOTICE]")) { + level = 5; + } else if (strstr(handle->last_event->body, "[INFO]")) { + level = 6; + } else if (strstr(handle->last_event->body, "[DEBUG]")) { + level = 7; + } + + printf("%s%s%s", COLORS[level], handle->last_event->body, ESL_SEQ_DEFAULT_COLOR); + } + } + + } + + esl_mutex_unlock(global_mutex); + usleep(1000); + } + + done: + + thread_running = 0; + + return NULL; +} + +static int process_command(esl_handle_t *handle, const char *cmd) +{ + if (!strcasecmp(cmd, "exit")) { + return -1; + } + + if (!strncasecmp(cmd, "loglevel", 8)) { + const char *level = cmd + 8; + + while(*level == ' ') level++; + if (!esl_strlen_zero(level)) { + char cb[128] = ""; + + snprintf(cb, sizeof(cb), "log %s\n\n", level); + esl_mutex_lock(global_mutex); + esl_send_recv(handle, cb); + printf("%s\n", handle->last_reply); + esl_mutex_unlock(global_mutex); + } + + goto end; + } + + + printf("Unknown command [%s]\n", cmd); + + end: + + return 0; + +} + +int main(void) +{ + esl_handle_t handle = {0}; + int count; + const char *line; + char cmd_str[1024] = ""; + char hfile[512] = "/tmp/fs_cli_history"; + char *home = getenv("HOME"); + + if (home) { + snprintf(hfile, sizeof(hfile), "%s/.fs_cli_history", home); + } + + esl_mutex_create(&global_mutex); + + signal(SIGINT, handle_SIGINT); + gethostname(hostname, sizeof(hostname)); + + handle.debug = 0; + + + // um ya add some command line parsing for host port and pass + + if (esl_connect(&handle, "localhost", 8021, "ClueCon")) { + printf("Error Connecting [%s]\n", handle.err); + goto done; + } + + esl_thread_create_detached(msg_thread_run, &handle); + + el = el_init(__FILE__, stdout, stdout, stdout); + el_set(el, EL_PROMPT, &prompt); + el_set(el, EL_EDITOR, "emacs"); + myhistory = history_init(); + + if (myhistory == 0) { + fprintf(stderr, "history could not be initialized\n"); + goto done; + } + + history(myhistory, &ev, H_SETSIZE, 800); + el_set(el, EL_HIST, history, myhistory); + history(myhistory, &ev, H_LOAD, hfile); + + + snprintf(cmd_str, sizeof(cmd_str), "log info\n\n"); + esl_mutex_lock(global_mutex); + esl_send_recv(&handle, cmd_str); + esl_mutex_unlock(global_mutex); + + while (running) { + + line = el_gets(el, &count); + + if (count > 1) { + if (!esl_strlen_zero(line)) { + char *cmd = strdup(line); + char *p; + const LineInfo *lf = el_line(el); + char *foo = (char *) lf->buffer; + if ((p = strrchr(cmd, '\r')) || (p = strrchr(cmd, '\n'))) { + *p = '\0'; + } + assert(cmd != NULL); + history(myhistory, &ev, H_ENTER, line); + + if (!strncasecmp(cmd, "...", 3)) { + goto done; + } else if (*cmd == '/') { + if (process_command(&handle, cmd + 1)) { + running = 0; + } + } else { + snprintf(cmd_str, sizeof(cmd_str), "api %s\n\n", cmd); + esl_mutex_lock(global_mutex); + esl_send_recv(&handle, cmd_str); + printf("%s\n", handle.last_event->body); + esl_mutex_unlock(global_mutex); + } + + el_deletestr(el, strlen(foo) + 1); + memset(foo, 0, strlen(foo)); + free(cmd); + } + } + + usleep(1000); + + } + + + done: + + history(myhistory, &ev, H_SAVE, hfile); + + /* Clean up our memory */ + history_end(myhistory); + el_end(el); + + esl_disconnect(&handle); + + thread_running = 0; + + esl_mutex_destroy(&global_mutex); + + return 0; +} Added: freeswitch/trunk/libs/esl/src/esl.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/esl.c Fri Dec 19 19:35:09 2008 @@ -0,0 +1,333 @@ +/* + * 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> + +#ifndef HAVE_GETHOSTBYNAME_R +extern int gethostbyname_r (const char *__name, + struct hostent *__result_buf, + char *__buf, size_t __buflen, + struct hostent **__result, + int *__h_errnop); +#endif + + + +size_t esl_url_encode(const char *url, char *buf, size_t len) +{ + const char *p; + size_t x = 0; + const char urlunsafe[] = "\r\n \"#%&+:;<=>?@[\\]^`{|}"; + const char hex[] = "0123456789ABCDEF"; + + if (!buf) { + return 0; + } + + if (!url) { + return 0; + } + + len--; + + for (p = url; *p; p++) { + if (x >= len) { + break; + } + if (*p < ' ' || *p > '~' || strchr(urlunsafe, *p)) { + if ((x + 3) >= len) { + break; + } + buf[x++] = '%'; + buf[x++] = hex[*p >> 4]; + buf[x++] = hex[*p & 0x0f]; + } else { + buf[x++] = *p; + } + } + buf[x] = '\0'; + + return x; +} + +char *esl_url_decode(char *s) +{ + char *o; + unsigned int tmp; + + for (o = s; *s; s++, o++) { + if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) { + *o = (char) tmp; + s += 2; + } else { + *o = *s; + } + } + *o = '\0'; + return s; +} + + + +esl_status_t esl_connect(esl_handle_t *handle, const char *host, esl_port_t port, const char *password) +{ + + struct hostent *result; + char sendbuf[256]; + char recvbuf[256]; + int rval; + const char *hval; + + handle->sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + + if (handle->sock == ESL_SOCK_INVALID) { + snprintf(handle->err, sizeof(handle->err), "Socket Error"); + return ESL_FAIL; + } + + memset(&handle->sockaddr, 0, sizeof(handle->sockaddr)); + handle->sockaddr.sin_family = AF_INET; + handle->sockaddr.sin_port = htons(port); + + memset(&handle->hostent, 0, sizeof(handle->hostent)); + +#ifdef HAVE_GETHOSTBYNAME_R_FIVE + rval = gethostbyname_r(host, &handle->hostent, handle->hostbuf, sizeof(handle->hostbuf), &handle->errno); + result = handle->hostent; +#else + rval = gethostbyname_r(host, &handle->hostent, handle->hostbuf, sizeof(handle->hostbuf), &result, &handle->errno); +#endif + + if (rval) { + strerror_r(handle->errno, handle->err, sizeof(handle->err)); + goto fail; + } + + memcpy(&handle->sockaddr.sin_addr, result->h_addr, result->h_length); + + rval = connect(handle->sock, (struct sockaddr *) &handle->sockaddr, sizeof(handle->sockaddr)); + + if (rval) { + strerror_r(handle->errno, handle->err, sizeof(handle->err)); + goto fail; + } + + if (esl_recv(handle)) { + snprintf(handle->err, sizeof(handle->err), "Connection Error"); + goto fail; + } + + hval = esl_event_get_header(handle->last_event, "content-type"); + + if (strcasecmp(hval, "auth/request")) { + snprintf(handle->err, sizeof(handle->err), "Connection Error"); + goto fail; + } + + snprintf(sendbuf, sizeof(sendbuf), "auth %s\n\n", password); + esl_send(handle, sendbuf); + + + if (esl_recv(handle)) { + snprintf(handle->err, sizeof(handle->err), "Connection Error"); + goto fail; + } + + + hval = esl_event_get_header(handle->last_event, "reply-text"); + + if (strcasecmp(hval, "+OK accepted")) { + snprintf(handle->err, sizeof(handle->err), "Connection Error"); + goto fail; + } + + handle->connected = 1; + + return ESL_SUCCESS; + + fail: + + esl_disconnect(handle); + return ESL_FAIL; +} + +esl_status_t esl_disconnect(esl_handle_t *handle) +{ + esl_event_safe_destroy(&handle->last_event); + + if (handle->sock != ESL_SOCK_INVALID) { + close(handle->sock); + handle->sock = ESL_SOCK_INVALID; + return ESL_SUCCESS; + } + + handle->connected = 0; + + return ESL_FAIL; +} + +esl_status_t esl_recv(esl_handle_t *handle) +{ + char *c; + esl_ssize_t rrval; + int crc = 0; + esl_event_t *revent = NULL; + char *beg; + char *hname, *hval; + char *col; + char *cl; + ssize_t len; + + esl_event_safe_destroy(&handle->last_event); + memset(handle->header_buf, 0, sizeof(handle->header_buf)); + + c = handle->header_buf; + beg = c; + + for(;;) { + rrval = recv(handle->sock, c, 1, 0); + + if (rrval < 0) { + strerror_r(handle->errno, handle->err, sizeof(handle->err)); + goto fail; + } else if (rrval > 0) { + if (*c == '\n') { + if (++crc == 2) { + break; + } + + if (!revent) { + esl_event_create(&revent, ESL_EVENT_COMMAND); + } + + hname = beg; + hval = col = NULL; + + if (hname && (col = strchr(hname, ':'))) { + hval = col + 1; + *col = '\0'; + while(*hval == ' ') hval++; + } + + *c = '\0'; + + if (hname && hval) { + if (handle->debug > 1) { + printf("RECV HEADER [%s] = [%s]\n", hname, hval); + } + esl_event_add_header_string(revent, ESL_STACK_BOTTOM, hname, hval); + } + + beg = c+1; + + + } else { + crc = 0; + } + + c++; + } + } + + if (!revent) { + goto fail; + } + + if ((cl = esl_event_get_header(revent, "content-length"))) { + char *body; + esl_ssize_t sofar = 0; + + len = atol(cl); + body = malloc(len+1); + esl_assert(body); + *(body + len) = '\0'; + + do { + esl_ssize_t r; + if ((r = recv(handle->sock, body + sofar, len - sofar, 0)) < 0) { + strerror_r(handle->errno, handle->err, sizeof(handle->err)); + goto fail; + } + sofar += r; + } while (sofar < len); + + revent->body = body; + } + + + + handle->last_event = revent; + + if (handle->last_event) { + const char *reply = esl_event_get_header(handle->last_event, "reply-text"); + if (!esl_strlen_zero(reply)) { + strncpy(handle->last_reply, reply, sizeof(handle->last_reply)); + } + } + + + if (handle->debug) { + char *foo; + esl_event_serialize(handle->last_event, &foo, ESL_FALSE); + printf("RECV MESSAGE\n%s\n", foo); + free(foo); + } + + return ESL_SUCCESS; + + fail: + + esl_disconnect(handle); + return ESL_FAIL; + +} + +esl_status_t esl_send(esl_handle_t *handle, const char *cmd) +{ + if (handle->debug) { + printf("SEND\n%s\n", cmd); + } + + send(handle->sock, cmd, strlen(cmd), 0); +} + + +esl_status_t esl_send_recv(esl_handle_t *handle, const char *cmd) +{ + esl_send(handle, cmd); + esl_recv(handle); +} + + + + Added: freeswitch/trunk/libs/esl/src/esl_event.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/esl_event.c Fri Dec 19 19:35:09 2008 @@ -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: + */ Added: freeswitch/trunk/libs/esl/src/esl_threadmutex.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/esl_threadmutex.c Fri Dec 19 19:35:09 2008 @@ -0,0 +1,237 @@ +/* + * Cross Platform Thread/Mutex abstraction + * Copyright(C) 2007 Michael Jerris + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so. + * + * This work is provided under this license on an "as is" basis, without warranty of any kind, + * either expressed or implied, including, without limitation, warranties that the covered code + * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire + * risk as to the quality and performance of the covered code is with you. Should any covered + * code prove defective in any respect, you (not the initial developer or any other contributor) + * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty + * constitutes an essential part of this license. No use of any covered code is authorized hereunder + * except under this disclaimer. + * + */ + +#ifdef WIN32 +/* required for TryEnterCriticalSection definition. Must be defined before windows.h include */ +#define _WIN32_WINNT 0x0400 +#endif + +#include "esl.h" +#include "esl_threadmutex.h" + +#ifdef WIN32 +#include <process.h> + +#define ESL_THREAD_CALLING_CONVENTION __stdcall + +struct esl_mutex { + CRITICAL_SECTION mutex; +}; + +#else + +#include <pthread.h> + +#define ESL_THREAD_CALLING_CONVENTION + +struct esl_mutex { + pthread_mutex_t mutex; +}; + +#endif + +struct esl_thread { +#ifdef WIN32 + void *handle; +#else + pthread_t handle; +#endif + void *private_data; + esl_thread_function_t function; + size_t stack_size; +#ifndef WIN32 + pthread_attr_t attribute; +#endif +}; + +size_t thread_default_stacksize = 0; + +void esl_thread_override_default_stacksize(size_t size) +{ + thread_default_stacksize = size; +} + +static void * ESL_THREAD_CALLING_CONVENTION thread_launch(void *args) +{ + void *exit_val; + esl_thread_t *thread = (esl_thread_t *)args; + exit_val = thread->function(thread, thread->private_data); +#ifndef WIN32 + pthread_attr_destroy(&thread->attribute); +#endif + free(thread); + + return exit_val; +} + +esl_status_t esl_thread_create_detached(esl_thread_function_t func, void *data) +{ + return esl_thread_create_detached_ex(func, data, thread_default_stacksize); +} + +esl_status_t esl_thread_create_detached_ex(esl_thread_function_t func, void *data, size_t stack_size) +{ + esl_thread_t *thread = NULL; + esl_status_t status = ESL_FAIL; + + if (!func || !(thread = (esl_thread_t *)malloc(sizeof(esl_thread_t)))) { + goto done; + } + + thread->private_data = data; + thread->function = func; + thread->stack_size = stack_size; + +#if defined(WIN32) + thread->handle = (void *)_beginthreadex(NULL, (unsigned)thread->stack_size, (unsigned int (__stdcall *)(void *))thread_launch, thread, 0, NULL); + if (!thread->handle) { + goto fail; + } + CloseHandle(thread->handle); + + status = ESL_SUCCESS; + goto done; +#else + + if (pthread_attr_init(&thread->attribute) != 0) goto fail; + + if (pthread_attr_setdetachstate(&thread->attribute, PTHREAD_CREATE_DETACHED) != 0) goto failpthread; + + if (thread->stack_size && pthread_attr_setstacksize(&thread->attribute, thread->stack_size) != 0) goto failpthread; + + if (pthread_create(&thread->handle, &thread->attribute, thread_launch, thread) != 0) goto failpthread; + + status = ESL_SUCCESS; + goto done; + failpthread: + pthread_attr_destroy(&thread->attribute); +#endif + + fail: + if (thread) { + free(thread); + } + done: + return status; +} + + +esl_status_t esl_mutex_create(esl_mutex_t **mutex) +{ + esl_status_t status = ESL_FAIL; +#ifndef WIN32 + pthread_mutexattr_t attr; +#endif + esl_mutex_t *check = NULL; + + check = (esl_mutex_t *)malloc(sizeof(**mutex)); + if (!check) + goto done; +#ifdef WIN32 + InitializeCriticalSection(&check->mutex); +#else + if (pthread_mutexattr_init(&attr)) + goto done; + + if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) + goto fail; + + if (pthread_mutex_init(&check->mutex, &attr)) + goto fail; + + goto success; + + fail: + pthread_mutexattr_destroy(&attr); + goto done; + + success: +#endif + *mutex = check; + status = ESL_SUCCESS; + + done: + return status; +} + +esl_status_t esl_mutex_destroy(esl_mutex_t **mutex) +{ + esl_mutex_t *mp = *mutex; + *mutex = NULL; + if (!mp) { + return ESL_FAIL; + } +#ifdef WIN32 + DeleteCriticalSection(&mp->mutex); +#else + if (pthread_mutex_destroy(&mp->mutex)) + return ESL_FAIL; +#endif + free(mp); + return ESL_SUCCESS; +} + +esl_status_t esl_mutex_lock(esl_mutex_t *mutex) +{ +#ifdef WIN32 + EnterCriticalSection(&mutex->mutex); +#else + if (pthread_mutex_lock(&mutex->mutex)) + return ESL_FAIL; +#endif + return ESL_SUCCESS; +} + +esl_status_t esl_mutex_trylock(esl_mutex_t *mutex) +{ +#ifdef WIN32 + if (!TryEnterCriticalSection(&mutex->mutex)) + return ESL_FAIL; +#else + if (pthread_mutex_trylock(&mutex->mutex)) + return ESL_FAIL; +#endif + return ESL_SUCCESS; +} + +esl_status_t esl_mutex_unlock(esl_mutex_t *mutex) +{ +#ifdef WIN32 + LeaveCriticalSection(&mutex->mutex); +#else + if (pthread_mutex_unlock(&mutex->mutex)) + return ESL_FAIL; +#endif + 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 expandtab: + */ Added: freeswitch/trunk/libs/esl/src/include/esl.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/include/esl.h Fri Dec 19 19:35:09 2008 @@ -0,0 +1,233 @@ +/* + * 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. + */ + +#ifndef _ESL_H_ +#define _ESL_H_ + +typedef struct esl_event_header esl_event_header_t; +typedef struct esl_event esl_event_t; + + +#define ESL_SEQ_ESC "\033[" +/* Ansi Control character suffixes */ +#define ESL_SEQ_HOME_CHAR 'H' +#define ESL_SEQ_HOME_CHAR_STR "H" +#define ESL_SEQ_CLEARLINE_CHAR '1' +#define ESL_SEQ_CLEARLINE_CHAR_STR "1" +#define ESL_SEQ_CLEARLINEEND_CHAR "K" +#define ESL_SEQ_CLEARSCR_CHAR0 '2' +#define ESL_SEQ_CLEARSCR_CHAR1 'J' +#define ESL_SEQ_CLEARSCR_CHAR "2J" +#define ESL_SEQ_DEFAULT_COLOR ESL_SEQ_ESC ESL_SEQ_END_COLOR /* Reset to Default fg/bg color */ +#define ESL_SEQ_AND_COLOR ";" /* To add multiple color definitions */ +#define ESL_SEQ_END_COLOR "m" /* To end color definitions */ +/* Foreground colors values */ +#define ESL_SEQ_F_BLACK "30" +#define ESL_SEQ_F_RED "31" +#define ESL_SEQ_F_GREEN "32" +#define ESL_SEQ_F_YELLOW "33" +#define ESL_SEQ_F_BLUE "34" +#define ESL_SEQ_F_MAGEN "35" +#define ESL_SEQ_F_CYAN "36" +#define ESL_SEQ_F_WHITE "37" +/* Background colors values */ +#define ESL_SEQ_B_BLACK "40" +#define ESL_SEQ_B_RED "41" +#define ESL_SEQ_B_GREEN "42" +#define ESL_SEQ_B_YELLOW "43" +#define ESL_SEQ_B_BLUE "44" +#define ESL_SEQ_B_MAGEN "45" +#define ESL_SEQ_B_CYAN "46" +#define ESL_SEQ_B_WHITE "47" +/* Preset escape sequences - Change foreground colors only */ +#define ESL_SEQ_FBLACK ESL_SEQ_ESC ESL_SEQ_F_BLACK ESL_SEQ_END_COLOR +#define ESL_SEQ_FRED ESL_SEQ_ESC ESL_SEQ_F_RED ESL_SEQ_END_COLOR +#define ESL_SEQ_FGREEN ESL_SEQ_ESC ESL_SEQ_F_GREEN ESL_SEQ_END_COLOR +#define ESL_SEQ_FYELLOW ESL_SEQ_ESC ESL_SEQ_F_YELLOW ESL_SEQ_END_COLOR +#define ESL_SEQ_FBLUE ESL_SEQ_ESC ESL_SEQ_F_BLUE ESL_SEQ_END_COLOR +#define ESL_SEQ_FMAGEN ESL_SEQ_ESC ESL_SEQ_F_MAGEN ESL_SEQ_END_COLOR +#define ESL_SEQ_FCYAN ESL_SEQ_ESC ESL_SEQ_F_CYAN ESL_SEQ_END_COLOR +#define ESL_SEQ_FWHITE ESL_SEQ_ESC ESL_SEQ_F_WHITE ESL_SEQ_END_COLOR +#define ESL_SEQ_BBLACK ESL_SEQ_ESC ESL_SEQ_B_BLACK ESL_SEQ_END_COLOR +#define ESL_SEQ_BRED ESL_SEQ_ESC ESL_SEQ_B_RED ESL_SEQ_END_COLOR +#define ESL_SEQ_BGREEN ESL_SEQ_ESC ESL_SEQ_B_GREEN ESL_SEQ_END_COLOR +#define ESL_SEQ_BYELLOW ESL_SEQ_ESC ESL_SEQ_B_YELLOW ESL_SEQ_END_COLOR +#define ESL_SEQ_BBLUE ESL_SEQ_ESC ESL_SEQ_B_BLUE ESL_SEQ_END_COLOR +#define ESL_SEQ_BMAGEN ESL_SEQ_ESC ESL_SEQ_B_MAGEN ESL_SEQ_END_COLOR +#define ESL_SEQ_BCYAN ESL_SEQ_ESC ESL_SEQ_B_CYAN ESL_SEQ_END_COLOR +#define ESL_SEQ_BWHITE ESL_SEQ_ESC ESL_SEQ_B_WHITE ESL_SEQ_END_COLOR +/* Preset escape sequences */ +#define ESL_SEQ_HOME ESL_SEQ_ESC ESL_SEQ_HOME_CHAR_STR +#define ESL_SEQ_CLEARLINE ESL_SEQ_ESC ESL_SEQ_CLEARLINE_CHAR_STR +#define ESL_SEQ_CLEARLINEEND ESL_SEQ_ESC ESL_SEQ_CLEARLINEEND_CHAR +#define ESL_SEQ_CLEARSCR ESL_SEQ_ESC ESL_SEQ_CLEARSCR_CHAR ESL_SEQ_HOME + +#if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__) && !defined(__NetBSD__) +#define _XOPEN_SOURCE 600 +#endif + +#ifndef HAVE_STRINGS_H +#define HAVE_STRINGS_H 1 +#endif +#ifndef HAVE_SYS_SOCKET_H +#define HAVE_SYS_SOCKET_H 1 +#endif + +#ifndef __WINDOWS__ +#if defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32) +#define __WINDOWS__ +#endif +#endif + +#ifdef _MSC_VER +#ifndef __inline__ +#define __inline__ __inline +#endif +#if (_MSC_VER >= 1400) /* VC8+ */ +#ifndef _CRT_SECURE_NO_DEPRECATE +#define _CRT_SECURE_NO_DEPRECATE +#endif +#ifndef _CRT_NONSTDC_NO_DEPRECATE +#define _CRT_NONSTDC_NO_DEPRECATE +#endif +#endif +#ifndef strcasecmp +#define strcasecmp(s1, s2) _stricmp(s1, s2) +#endif +#ifndef strncasecmp +#define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n) +#endif +#ifndef snprintf +#define snprintf _snprintf +#endif +#ifndef S_IRUSR +#define S_IRUSR _S_IREAD +#endif +#ifndef S_IWUSR +#define S_IWUSR _S_IWRITE +#endif +#undef HAVE_STRINGS_H +#undef HAVE_SYS_SOCKET_H +#endif + +#include <time.h> +#ifndef WIN32 +#include <sys/time.h> +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#ifdef HAVE_STRINGS_H +#include <strings.h> +#endif +#include <assert.h> + + +#define esl_assert(_x) assert(_x) +#define esl_safe_free(_x) if (_x) free(_x); _x = NULL +#define esl_strlen_zero(s) (!s || *(s) == '\0') +#define esl_strlen_zero_buf(s) (*(s) == '\0') + +#ifdef WIN32 +#include <windows.h> +typedef HANDLE esl_socket_t; +typedef unsigned __int64 uint64_t; +typedef unsigned __int32 uint32_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int8 uint8_t; +typedef __int64 int64_t; +typedef __int32 int32_t; +typedef __int16 int16_t; +typedef __int8 int8_t; +typedef intptr_t esl_ssize_t; +typedef int esl_filehandle_t; +#else +#include <stdint.h> +#include <sys/types.h> +#include <sys/ioctl.h> +#include <stdarg.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#define ESL_SOCK_INVALID -1 +typedef int esl_socket_t; +typedef ssize_t esl_ssize_t; +typedef int esl_filehandle_t; +#endif + +typedef int16_t esl_port_t; + +typedef enum { + ESL_SUCCESS, + ESL_FAIL +} esl_status_t; + + +typedef struct { + struct sockaddr_in sockaddr; + struct hostent hostent; + char hostbuf[256]; + esl_socket_t sock; + char err[256]; + int errno; + char header_buf[4196]; + char last_reply[1024]; + esl_event_t *last_event; + int debug; + int connected; +} esl_handle_t; + +typedef enum { + ESL_TRUE = 1, + ESL_FALSE = 0 +} esl_bool_t; + + +#include "esl_event.h" +#include "esl_threadmutex.h" + +size_t esl_url_encode(const char *url, char *buf, size_t len); +char *esl_url_decode(char *s); + +esl_status_t esl_connect(esl_handle_t *handle, const char *host, esl_port_t port, const char *password); +esl_status_t esl_disconnect(esl_handle_t *handle); +esl_status_t esl_send(esl_handle_t *handle, const char *cmd); +esl_status_t esl_recv(esl_handle_t *handle); +esl_status_t esl_send_recv(esl_handle_t *handle, const char *cmd); + + +#endif + + + Added: freeswitch/trunk/libs/esl/src/include/esl_event.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/include/esl_event.h Fri Dec 19 19:35:09 2008 @@ -0,0 +1,284 @@ +/* + * 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. + */ + +#ifndef ESL_EVENT_H +#define ESL_EVENT_H + +#include <esl.h> + +typedef enum { + ESL_STACK_BOTTOM, + ESL_STACK_TOP +} esl_stack_t; + +typedef enum { + ESL_EVENT_CUSTOM, + ESL_EVENT_CHANNEL_CREATE, + ESL_EVENT_CHANNEL_DESTROY, + ESL_EVENT_CHANNEL_STATE, + ESL_EVENT_CHANNEL_ANSWER, + ESL_EVENT_CHANNEL_HANGUP, + ESL_EVENT_CHANNEL_EXECUTE, + ESL_EVENT_CHANNEL_EXECUTE_COMPLETE, + ESL_EVENT_CHANNEL_BRIDGE, + ESL_EVENT_CHANNEL_UNBRIDGE, + ESL_EVENT_CHANNEL_PROGRESS, + ESL_EVENT_CHANNEL_PROGRESS_MEDIA, + ESL_EVENT_CHANNEL_OUTGOING, + ESL_EVENT_CHANNEL_PARK, + ESL_EVENT_CHANNEL_UNPARK, + ESL_EVENT_CHANNEL_APPLICATION, + ESL_EVENT_CHANNEL_ORIGINATE, + ESL_EVENT_CHANNEL_UUID, + ESL_EVENT_API, + ESL_EVENT_LOG, + ESL_EVENT_INBOUND_CHAN, + ESL_EVENT_OUTBOUND_CHAN, + ESL_EVENT_STARTUP, + ESL_EVENT_SHUTDOWN, + ESL_EVENT_PUBLISH, + ESL_EVENT_UNPUBLISH, + ESL_EVENT_TALK, + ESL_EVENT_NOTALK, + ESL_EVENT_SESSION_CRASH, + ESL_EVENT_MODULE_LOAD, + ESL_EVENT_MODULE_UNLOAD, + ESL_EVENT_DTMF, + ESL_EVENT_MESSAGE, + ESL_EVENT_PRESENCE_IN, + ESL_EVENT_NOTIFY_IN, + ESL_EVENT_PRESENCE_OUT, + ESL_EVENT_PRESENCE_PROBE, + ESL_EVENT_MESSAGE_WAITING, + ESL_EVENT_MESSAGE_QUERY, + ESL_EVENT_ROSTER, + ESL_EVENT_CODEC, + ESL_EVENT_BACKGROUND_JOB, + ESL_EVENT_DETECTED_SPEECH, + ESL_EVENT_DETECTED_TONE, + ESL_EVENT_PRIVATE_COMMAND, + ESL_EVENT_HEARTBEAT, + ESL_EVENT_TRAP, + ESL_EVENT_ADD_SCHEDULE, + ESL_EVENT_DEL_SCHEDULE, + ESL_EVENT_EXE_SCHEDULE, + ESL_EVENT_RE_SCHEDULE, + ESL_EVENT_RELOADXML, + ESL_EVENT_NOTIFY, + ESL_EVENT_SEND_MESSAGE, + ESL_EVENT_RECV_MESSAGE, + ESL_EVENT_REQUEST_PARAMS, + ESL_EVENT_CHANNEL_DATA, + ESL_EVENT_GENERAL, + ESL_EVENT_COMMAND, + ESL_EVENT_SESSION_HEARTBEAT, + ESL_EVENT_ALL +} esl_event_types_t; + +typedef enum { + ESL_PRIORITY_NORMAL, + ESL_PRIORITY_LOW, + ESL_PRIORITY_HIGH +} esl_priority_t; + +/*! \brief An event Header */ + struct esl_event_header { + /*! the header name */ + char *name; + /*! the header value */ + char *value; + /*! hash of the header name */ + unsigned long hash; + struct esl_event_header *next; +}; + + +/*! \brief Representation of an event */ +struct esl_event { + /*! the event id (descriptor) */ + esl_event_types_t event_id; + /*! the priority of the event */ + esl_priority_t priority; + /*! the owner of the event */ + char *owner; + /*! the subclass of the event */ + char *subclass_name; + /*! the event headers */ + esl_event_header_t *headers; + /*! the event headers tail pointer */ + esl_event_header_t *last_header; + /*! the body of the event */ + char *body; + /*! user data from the subclass provider */ + void *bind_user_data; + /*! user data from the event sender */ + void *event_user_data; + /*! unique key */ + unsigned long key; + struct esl_event *next; +}; + + + +#define ESL_EVENT_SUBCLASS_ANY NULL + +/*! + \brief Create an event + \param event a NULL pointer on which to create the event + \param event_id the event id enumeration of the desired event + \param subclass_name the subclass name for custom event (only valid when event_id is ESL_EVENT_CUSTOM) + \return ESL_STATUS_SUCCESS on success +*/ +esl_status_t esl_event_create_subclass(esl_event_t **event, esl_event_types_t event_id, const char *subclass_name); + +/*! + \brief Set the priority of an event + \param event the event to set the priority on + \param priority the event priority + \return ESL_STATUS_SUCCESS +*/ +esl_status_t esl_event_set_priority(esl_event_t *event, esl_priority_t priority); + +/*! + \brief Retrieve a header value from an event + \param event the event to read the header from + \param header_name the name of the header to read + \return the value of the requested header +*/ +char *esl_event_get_header(esl_event_t *event, const char *header_name); + +/*! + \brief Retrieve the body value from an event + \param event the event to read the body from + \return the value of the body or NULL +*/ +char *esl_event_get_body(esl_event_t *event); + +/*! + \brief Add a header to an event + \param event the event to add the header to + \param stack the stack sense (stack it on the top or on the bottom) + \param header_name the name of the header to add + \param fmt the value of the header (varargs see standard sprintf family) + \return ESL_STATUS_SUCCESS if the header was added +*/ +esl_status_t esl_event_add_header(esl_event_t *event, esl_stack_t stack, + const char *header_name, const char *fmt, ...); //PRINTF_FUNCTION(4, 5); + +/*! + \brief Add a string header to an event + \param event the event to add the header to + \param stack the stack sense (stack it on the top or on the bottom) + \param header_name the name of the header to add + \param data the value of the header + \return ESL_STATUS_SUCCESS if the header was added +*/ +esl_status_t esl_event_add_header_string(esl_event_t *event, esl_stack_t stack, const char *header_name, const char *data); + +esl_status_t esl_event_del_header(esl_event_t *event, const char *header_name); + +/*! + \brief Destroy an event + \param event pointer to the pointer to event to destroy +*/ +void esl_event_destroy(esl_event_t **event); +#define esl_event_safe_destroy(_event) if (_event) esl_event_destroy(_event) + +/*! + \brief Duplicate an event + \param event a NULL pointer on which to duplicate the event + \param todup an event to duplicate + \return ESL_STATUS_SUCCESS if the event was duplicated +*/ +esl_status_t esl_event_dup(esl_event_t **event, esl_event_t *todup); + +/*! + \brief Render the name of an event id enumeration + \param event the event id to render the name of + \return the rendered name +*/ +const char *esl_event_name(esl_event_types_t event); + +/*! + \brief return the event id that matches a given event name + \param name the name of the event + \param type the event id to return + \return ESL_STATUS_SUCCESS if there was a match +*/ +esl_status_t esl_name_event(const char *name, esl_event_types_t *type); + +/*! + \brief Render a string representation of an event sutable for printing or network transport + \param event the event to render + \param str a string pointer to point at the allocated data + \param encode url encode the headers + \return ESL_STATUS_SUCCESS if the operation was successful + \note you must free the resulting string when you are finished with it +*/ +esl_status_t esl_event_serialize(esl_event_t *event, char **str, esl_bool_t encode); + +/*! + \brief Add a body to an event + \param event the event to add to body to + \param fmt optional body of the event (varargs see standard sprintf family) + \return ESL_STATUS_SUCCESS if the body was added to the event + \note the body parameter can be shadowed by the esl_event_reserve_subclass_detailed function +*/ +esl_status_t esl_event_add_body(esl_event_t *event, const char *fmt, ...); + +/*! + \brief Create a new event assuming it will not be custom event and therefore hiding the unused parameters + \param event a NULL pointer on which to create the event + \param id the event id enumeration of the desired event + \return ESL_STATUS_SUCCESS on success +*/ +#define esl_event_create(event, id) esl_event_create_subclass(event, id, ESL_EVENT_SUBCLASS_ANY) + +const char *esl_priority_name(esl_priority_t priority); + +///\} + + +#endif + +/* 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: + */ + Added: freeswitch/trunk/libs/esl/src/include/esl_threadmutex.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/src/include/esl_threadmutex.h Fri Dec 19 19:35:09 2008 @@ -0,0 +1,51 @@ +/* + * Cross Platform Thread/Mutex abstraction + * Copyright(C) 2007 Michael Jerris + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so. + * + * This work is provided under this license on an "as is" basis, without warranty of any kind, + * either expressed or implied, including, without limitation, warranties that the covered code + * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire + * risk as to the quality and performance of the covered code is with you. Should any covered + * code prove defective in any respect, you (not the initial developer or any other contributor) + * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty + * constitutes an essential part of this license. No use of any covered code is authorized hereunder + * except under this disclaimer. + * + */ + + +#ifndef _ESL_THREADMUTEX_H +#define _ESL_THREADMUTEX_H + +#include "esl.h" + +typedef struct esl_mutex esl_mutex_t; +typedef struct esl_thread esl_thread_t; +typedef void *(*esl_thread_function_t) (esl_thread_t *, void *); + +esl_status_t esl_thread_create_detached(esl_thread_function_t func, void *data); +esl_status_t esl_thread_create_detached_ex(esl_thread_function_t func, void *data, size_t stack_size); +void esl_thread_override_default_stacksize(size_t size); +esl_status_t esl_mutex_create(esl_mutex_t **mutex); +esl_status_t esl_mutex_destroy(esl_mutex_t **mutex); +esl_status_t esl_mutex_lock(esl_mutex_t *mutex); +esl_status_t esl_mutex_trylock(esl_mutex_t *mutex); +esl_status_t esl_mutex_unlock(esl_mutex_t *mutex); + +#endif + +/* 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 expandtab: + */ + Added: freeswitch/trunk/libs/esl/testclient.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/esl/testclient.c Fri Dec 19 19:35:09 2008 @@ -0,0 +1,19 @@ +#include <stdio.h> +#include <stdlib.h> +#include <esl.h> + + +int main(void) +{ + esl_handle_t handle = {0}; + + handle.debug = 1; + + esl_connect(&handle, "localhost", 8021, "ClueCon"); + + esl_send_recv(&handle, "api status\n\n"); + + esl_disconnect(&handle); + + return 0; +}