int load_module(void)
{
char *zErr;
char fn[PATH_MAX];
int res;
/* is the database there? */
snprintf(fn, sizeof(fn), "%s/cdr.db", cw_config_CW_LOG_DIR);
sqlite3_open(fn, &db);
if (!db) {
cw_log(LOG_ERROR, "cdr_sqlite: %s\n", zErr);
free(zErr);
return -1;
}
/* is the table there? */
res = sqlite3_exec(db, "SELECT COUNT(AcctId) FROM cdr;", NULL, NULL, NULL);
if (res) {
res = sqlite3_exec(db, sql_create_table, NULL, NULL, &zErr);
if (res) {
cw_log(LOG_ERROR, "cdr_sqlite: Unable to create table 'cdr': %s\n", zErr);
free(zErr);
goto err;
}
/* TODO: here we should probably create an index */
}
res = cw_cdr_register(name, desc, sqlite_log);
if (res) {
cw_log(LOG_ERROR, "Unable to register SQLite CDR handling\n");
goto err;
}
if (db) sqlite3_close(db);
return 0;
err:
if (db) sqlite3_close(db);
return -1;
}
static int h263_write(struct cw_filestream *fs, struct cw_frame *f)
{
int res;
unsigned int ts;
unsigned short len;
int subclass;
int mark = 0;
if (f->frametype != CW_FRAME_VIDEO)
{
cw_log(LOG_WARNING, "Asked to write non-video frame!\n");
return -1;
}
subclass = f->subclass;
if (subclass & 0x1)
mark=0x8000;
subclass &= ~0x1;
if (subclass != CW_FORMAT_H263)
{
cw_log(LOG_WARNING, "Asked to write non-h263 frame (%d)!\n", f->subclass);
return -1;
}
ts = htonl(f->samples);
if ((res = fwrite(&ts, 1, sizeof(ts), fs->f)) != sizeof(ts))
{
cw_log(LOG_WARNING, "Bad write (%d/4): %s\n", res, strerror(errno));
return -1;
}
len = htons(f->datalen | mark);
if ((res = fwrite(&len, 1, sizeof(len), fs->f)) != sizeof(len))
{
cw_log(LOG_WARNING, "Bad write (%d/2): %s\n", res, strerror(errno));
return -1;
}
if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen)
{
cw_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
return 0;
}
static struct cw_filestream *slinear_rewrite(FILE *f, const char *comment)
{
/* We don't have any header to read or anything really, but
if we did, it would go here. We also might want to check
and be sure it's a valid file. */
struct cw_filestream *tmp;
if ((tmp = malloc(sizeof(struct cw_filestream)))) {
memset(tmp, 0, sizeof(struct cw_filestream));
if (cw_mutex_lock(&slinear_lock)) {
cw_log(LOG_WARNING, "Unable to lock slinear list\n");
free(tmp);
return NULL;
}
tmp->f = f;
glistcnt++;
cw_mutex_unlock(&slinear_lock);
cw_update_use_count();
} else
cw_log(LOG_WARNING, "Out of memory\n");
return tmp;
}
int xprocess_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
struct sockaddr *from)
{
uint8_t *msgptr = rawmsg + cw_get_hdr_msg_offset(rawmsg);
uint32_t type = cw_get_msg_type(msgptr);
cw_log(LOG_ERR, "Hey: %d", type);
if (type == CW_MSG_DISCOVERY_REQUEST)
conn->capwap_state = CW_STATE_DISCOVERY;
return process_message(conn, rawmsg, rawlen, from);
}
/* Standard function for cleaning up a caller after a bridge ends or fails */
icd_status icd_customer__standard_cleanup_caller(icd_caller * that)
{
assert(that != NULL);
if (icd_debug)
cw_log(LOG_DEBUG,
"Caller %d [%s] has a customer role with no pushback needed, exit icd thread finished \n",
icd_caller__get_id(that), icd_caller__get_name(that));
that->thread_state = ICD_THREAD_STATE_FINISHED;
return ICD_SUCCESS;
}
static int pcm_write(struct cw_filestream *fs, struct cw_frame *f)
{
int res;
if (f->frametype != CW_FRAME_VOICE)
{
cw_log(LOG_WARNING, "Asked to write non-voice frame!\n");
return -1;
}
if (f->subclass != CW_FORMAT_ULAW)
{
cw_log(LOG_WARNING, "Asked to write non-ulaw frame (%d)!\n", f->subclass);
return -1;
}
if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen)
{
cw_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
return 0;
}
void wtpman_run_data(void *wtpman_arg)
{
return;
struct wtpman *wtpman = (struct wtpman *) wtpman_arg;
struct conn *conn = wtpman->conn;
uint8_t data[1001];
memset(data, 0, 1000);
cw_log(LOG_ERR, "I am the data thread**********************************************************************\n");
while (1) {
sleep(5);
// conn->write_data(conn, data, 100);
cw_log(LOG_ERR, "O was the data thread***********************************************************\n");
}
}
static void linear_release(struct cw_channel *chan, void *params)
{
struct linear_state *ls = params;
if (ls->origwfmt && cw_set_write_format(chan, ls->origwfmt))
{
cw_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, ls->origwfmt);
}
if (ls->autoclose)
close(ls->fd);
free(params);
}
static int sccp_pbx_answer(struct cw_channel *ast) {
sccp_channel_t * c = CS_CW_CHANNEL_PVT(ast);
if (!c || !c->device || !c->line) {
cw_log(LOG_ERROR, "SCCP: Answered %s but no SCCP channel\n", ast->name);
return -1;
}
sccp_log(1)(VERBOSE_PREFIX_3 "SCCP: Outgoing call has been answered %s on %s@%s-%d\n", ast->name, c->line->name, c->device->id, c->callid);
sccp_indicate_lock(c, SCCP_CHANNELSTATE_CONNECTED);
return 0;
}
int add_command_to_queue (
struct cw_conference *conf, struct cw_conf_member *member ,
int command, int param_number, char *param_text
)
{
struct cw_conf_command_queue *cq, *cq_last;
cq = calloc(1, sizeof( struct cw_conf_command_queue ) ) ;
if ( cq == NULL )
{
cw_log( LOG_ERROR, "unable to malloc cw_conf_command_queue\n" ) ;
return 1 ;
}
cq->next = NULL;
cq->command = command;
cq->issuedby = member;
cq->param_number = param_number;
strncpy(cq->param_text, param_text, sizeof(cq->param_text) );
cw_mutex_lock( &conf->lock ) ;
if ( conf->command_queue == NULL ) {
conf->command_queue = cq;
} else {
cq_last = conf->command_queue;
while ( cq_last->next != NULL )
cq_last = cq_last->next;
cq_last->next = cq;
}
cw_log( CW_CONF_DEBUG, "Conference, name => %s - Added command %d params: '%d/%s'\n",
conf->name, cq->command, cq->param_number, cq->param_text );
cw_mutex_unlock( &conf->lock ) ;
return 1;
}
static int database_queue_thread_start(void) {
pthread_attr_t attr;
cw_cond_init(&db_condition_save, NULL);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (cw_pthread_create(&db_thread, &attr, database_queue_thread_main, NULL) < 0) {
cw_log(LOG_ERROR, "Unable to start database queue thread. Using standard (non cached mode).\n");
return -1;
}
return 0;
}
static int phase_d_handler(t30_state_t *s, void *user_data, int result)
{
struct cw_channel *chan;
t30_stats_t t;
chan = (struct cw_channel *) user_data;
if (result)
{
t30_get_transfer_statistics(s, &t);
cw_log(LOG_DEBUG, "==============================================================================\n");
cw_log(LOG_DEBUG, "Pages transferred: %i\n", t.pages_rx);
cw_log(LOG_DEBUG, "Image size: %i x %i\n", t.width, t.length);
cw_log(LOG_DEBUG, "Image resolution %i x %i\n", t.x_resolution, t.y_resolution);
cw_log(LOG_DEBUG, "Transfer Rate: %i\n", t.bit_rate);
cw_log(LOG_DEBUG, "Bad rows %i\n", t.bad_rows);
cw_log(LOG_DEBUG, "Longest bad row run %i\n", t.longest_bad_row_run);
cw_log(LOG_DEBUG, "Compression type %s\n", t4_encoding_to_str(t.encoding));
cw_log(LOG_DEBUG, "Image size (bytes) %i\n", t.image_size);
cw_log(LOG_DEBUG, "==============================================================================\n");
}
return T30_ERR_OK;
}
static void group_function_write(struct cw_channel *chan, int argc, char **argv, const char *value)
{
char grpcat[256];
if (argc > 0 && argv[0][0]) {
snprintf(grpcat, sizeof(grpcat), "%s@%s", value, argv[0]);
} else {
cw_copy_string(grpcat, value, sizeof(grpcat));
}
if (cw_app_group_set_channel(chan, grpcat))
cw_log(LOG_WARNING, "Setting a group requires an argument (group name)\n");
}
static int PGSQL_exec(struct cw_channel *chan, int argc, char **argv)
{
struct localuser *u;
int result;
if (argc == 0 || !argv[0][0]) {
cw_log(LOG_WARNING, "APP_PGSQL requires an argument (see manual)\n");
return -1;
}
#if EXTRA_LOG
printf("PRSQL_exec: arg=%s\n", argv[0]);
#endif
LOCAL_USER_ADD(u);
result=0;
if (strncasecmp("connect",argv[0],strlen("connect"))==0) {
result=(aPGSQL_connect(chan,argv[0]));
} else if (strncasecmp("query",argv[0],strlen("query"))==0) {
result=(aPGSQL_query(chan,argv[0]));
} else if (strncasecmp("fetch",argv[0],strlen("fetch"))==0) {
result=(aPGSQL_fetch(chan,argv[0]));
} else if (strncasecmp("reset",argv[0],strlen("reset"))==0) {
result=(aPGSQL_reset(chan,argv[0]));
} else if (strncasecmp("clear",argv[0],strlen("clear"))==0) {
result=(aPGSQL_clear(chan,argv[0]));
} else if (strncasecmp("debug",argv[0],strlen("debug"))==0) {
result=(aPGSQL_debug(chan,argv[0]));
} else if (strncasecmp("disconnect",argv[0],strlen("disconnect"))==0) {
result=(aPGSQL_disconnect(chan,argv[0]));
} else {
cw_log(LOG_WARNING, "Unknown APP_PGSQL argument : %s\n", argv[0]);
result=-1;
}
LOCAL_USER_REMOVE(u);
return result;
}
static int register_actions(struct cw_actiondef *actions, int mode)
{
switch (mode) {
case MOD_MODE_CAPWAP:
{
struct mod_ac *cmod = modload_ac("capwap");
if (!cmod) {
cw_log(LOG_ERR,
"Can't initialize mod_fortinet, failed to load base mod mod_capwap");
return 1;
}
cmod->register_actions(actions, MOD_MODE_CAPWAP);
int rc = fortinet_register_actions_ac(actions);
cw_dbg(DBG_INFO, "Initialized mod fortinet with %d actions", rc);
return 0;
}
case MOD_MODE_BINDINGS:
{
struct mod_ac *cmod = modload_ac("capwap80211");
if (!cmod) {
cw_log(LOG_ERR,
"Can't initialize mod_fortinet, failed to load base mod mod_capwap80211");
return 1;
}
cmod->register_actions(actions, MOD_MODE_BINDINGS);
int rc = fortinet_register_actions80211_ac(actions);
cw_dbg(DBG_INFO, "Initialized mod_fortinet 80211 with %d actions", rc);
return 0;
}
}
return 0;
}
// process outgoing frames for the channel, playing either normal conference audio,
// or requested sounds
static int process_outgoing( struct cw_conf_member *member, int samples )
{
int res;
struct cw_frame *cf = NULL;
cw_mutex_lock(&member->lock);
cf=get_outgoing_frame( member->conf, member, samples ) ;
cw_mutex_unlock(&member->lock);
/*
cw_log(LOG_WARNING,
"OURGen: samples %d - conf %s - speak: %d - format: %d\n",
samples, member->chan->name, member->is_speaking , cf->frametype
);
*/
// if there's no frames exit the loop.
if( cf == NULL ) {
cw_log( LOG_ERROR, "Nothing to write to the conference, channel => %s\n", member->channel_name ) ;
return 0;
}
// send the voice frame
res = cw_write( member->chan, cf );
if ( ( res != 0) )
{
// log 'dropped' outgoing frame
cw_log( LOG_ERROR, "unable to write voice frame to channel, channel => %s, samples %d \n", member->channel_name, samples ) ;
}
// clean up frame
cw_fr_free(cf);
return 0;
}
int cw_out_ac_descriptor(struct conn *conn,struct cw_action_out * a,uint8_t *dst)
{
uint8_t *d = dst+4;
struct mbag_item * i;
i = mbag_get(conn->local,CW_ITEM_AC_STATUS);
if (!i) {
cw_log(LOG_ERR,"Can't send AC Descriptor, no AC Status Item found");
return 0;
}
d+=cw_put_ac_status(d ,(struct cw_ac_status*)(i->data));
i = mbag_get(conn->local,CW_ITEM_AC_HARDWARE_VERSION);
if ( i ) {
d += cw_put_version(d,CW_SUBELEM_AC_HARDWARE_VERSION,i->data);
}
else {
cw_log(LOG_ERR, "Can't send hard version in AC descriptor, not set.");
}
i = mbag_get(conn->local,CW_ITEM_AC_SOFTWARE_VERSION);
if ( i ) {
d += cw_put_version(d,CW_SUBELEM_AC_SOFTWARE_VERSION,i->data);
}
else {
cw_log(LOG_ERR, "Can't send software version in AC descriptor, not set.");
}
int len = d-dst-4;
return len + cw_put_elem_hdr(dst,a->elem_id,len);
}
static void gsm_close(struct cw_filestream *s)
{
if (cw_mutex_lock(&gsm_lock))
{
cw_log(LOG_WARNING, "Unable to lock gsm list\n");
return;
}
glistcnt--;
cw_mutex_unlock(&gsm_lock);
cw_update_use_count();
fclose(s->f);
free(s);
}
static int socklist_check_size()
{
if (socklist_len>0 && (socklist_len % SOCKLIST_SIZE)==0){
struct socklistelem *newsocklist;
newsocklist = realloc(socklist, sizeof(struct socklistelem)*(socklist_len+SOCKLIST_SIZE));
if (!newsocklist) {
cw_log(LOG_ERR,"Can't increase socklist size, realoc failed");
return 0;
}
socklist = newsocklist;
}
return 1;
}
/* MYSQL operations */
static int aMYSQL_connect(struct cw_channel *chan, char *data) {
MYSQL *mysql;
char *connid_var;
char *dbhost;
char *dbuser;
char *dbpass;
char *dbname;
strsep(&data," "); // eat the first token, we already know it :P
connid_var=strsep(&data," ");
dbhost=strsep(&data," ");
dbuser=strsep(&data," ");
dbpass=strsep(&data," ");
dbname=strsep(&data,"\n");
if( connid_var && dbhost && dbuser && dbpass && dbname ) {
mysql = mysql_init(NULL);
if (mysql) {
if (mysql_real_connect(mysql,dbhost,dbuser,dbpass,dbname,0,NULL,0)) {
add_identifier_and_set_callweaver_int(chan,connid_var,CW_MYSQL_ID_CONNID,mysql);
return 0;
}
else {
cw_log(LOG_WARNING,"mysql_real_connect(mysql,%s,%s,dbpass,%s,...) failed\n",dbhost,dbuser,dbname);
}
}
else {
cw_log(LOG_WARNING,"myslq_init returned NULL\n");
}
}
else {
cw_log(LOG_WARNING,"MYSQL(connect is missing some arguments\n");
}
return -1;
}
static int aMYSQL_query(struct cw_channel *chan, char *data) {
MYSQL *mysql;
MYSQL_RES *mysqlres;
char *resultid_var;
int connid;
char *querystring;
strsep(&data," "); // eat the first token, we already know it :P
resultid_var = strsep(&data," ");
connid = safe_scan_int(&data," ",-1);
querystring = strsep(&data,"\n");
if (resultid_var && (connid>=0) && querystring) {
if ((mysql=find_identifier(connid,CW_MYSQL_ID_CONNID))!=NULL) {
mysql_query(mysql,querystring);
if ((mysqlres=mysql_use_result(mysql))!=NULL) {
add_identifier_and_set_callweaver_int(chan,resultid_var,CW_MYSQL_ID_RESID,mysqlres);
return 0;
}
else if( mysql_field_count(mysql)==0 ) {
return 0; // See http://dev.mysql.com/doc/mysql/en/mysql_field_count.html
}
else {
cw_log(LOG_WARNING,"aMYSQL_query: mysql_store_result() failed on query %s\n",querystring);
}
}
else {
cw_log(LOG_WARNING,"aMYSQL_query: Invalid connection identifier %d passed in aMYSQL_query\n",connid);
}
}
else {
cw_log(LOG_WARNING,"aMYSQL_query: missing some arguments\n");
}
return -1;
}
int cw_itemdefheap_register(cw_itemdefheap_t t, cw_itemdef_t * defs)
{
int n = 0;
while (defs->id != CW_ITEM_NONE) {
cw_itemdef_t *a = mavl_add(t, defs);
if (a != defs) {
cw_log(LOG_ERR, "Duplicated item: %s", defs->id);
} else
n++;
defs++;
}
return n;
}
static void span_message(int level, const char *msg)
{
int cw_level;
if (level == SPAN_LOG_ERROR)
cw_level = __LOG_ERROR;
else if (level == SPAN_LOG_WARNING)
cw_level = __LOG_WARNING;
else
cw_level = __LOG_DEBUG;
//cw_level = __LOG_WARNING;
cw_log(cw_level, __FILE__, __LINE__, __PRETTY_FUNCTION__, msg);
}
static sqlite3 *sqlite_open_db(char *filename)
{
sqlite3 *db;
char path[1024];
sqlite_pick_path(filename, path, sizeof(path));
if (sqlite3_open(path, &db)) {
cw_log(LOG_WARNING, "SQL ERR [%s]\n", sqlite3_errmsg(db));
sqlite3_close(db);
db=NULL;
}
return db;
}
static void au_close(struct cw_filestream *s)
{
if (cw_mutex_lock(&au_lock))
{
cw_log(LOG_WARNING, "Unable to lock au count\n");
return;
}
localusecnt--;
cw_mutex_unlock(&au_lock);
cw_update_use_count();
fclose(s->f);
free(s);
}
int cw_put_mbag_item(uint8_t * dst, struct mbag_item *item)
{
if (item->type->put){
cw_dbg(DBG_X,"User put method to put ");
return item->type->put(item,dst);
}
if (MBAG_STR == item->type ){
return cw_put_data(dst, item->data, strlen((char *) item->data));
}
if (MBAG_DATA == item->type){
return cw_put_data(dst, item->data+1, *((uint8_t*)item->data));
}
if (MBAG_BYTE == item->type){
return cw_put_byte(dst, item->byte);
}
if (MBAG_WORD == item->type){
return cw_put_word(dst, item->word);
}
if (MBAG_DWORD == item->type){
return cw_put_dword(dst, item->dword);
}
if (MBAG_BSTR == item->type) {
return cw_put_bstr(dst, item->data);
}
if ( MBAG_BSTR16 == item->type)
return cw_put_bstr16(dst,item->data);
if (MBAG_VENDORSTR == item->type)
{
int l=0;
l+=cw_put_dword(dst, bstrv_get_vendor_id(item->data));
l+=cw_put_data(dst+4, bstrv_data(item->data),bstrv_len(item->data));
return l;
}
if (MBAG_MBAG == item->type){
*((void**)dst)=item->data;
return sizeof(void *);
}
cw_log(LOG_ERR,"No method to put items of type %s",item->type->name);
return 0;
}
static char *function_sort(struct cw_channel *chan, int argc, char **argv, char *buf, size_t len)
{
struct sortable_keys *sortable_keys;
char *p;
int count2;
if (argc < 1 || !argv[0][0]) {
cw_log(LOG_ERROR, "Syntax: %s\n", sort_func_syntax);
return NULL;
}
sortable_keys = alloca(argc * sizeof(struct sortable_keys));
memset(sortable_keys, 0, argc * sizeof(struct sortable_keys));
/* Parse each into a struct */
count2 = 0;
for (; argc; argv++, argc--) {
if (!(p= strchr(argv[0], ':')))
continue;
*(p++) = '\0';
sortable_keys[count2].key = argv[0];
sscanf(p, "%f", &sortable_keys[count2].value);
count2++;
}
if (count2 > 0) {
int i, l, first = 1;
/* Sort the structs */
qsort(sortable_keys, count2, sizeof(struct sortable_keys), sort_subroutine);
len--; /* one for the terminating null */
p = buf;
for (i = 0; len && i < count2; i++) {
if (len > 0 && !first) {
*(p++) = ',';
len--;
} else
first = 0;
l = strlen(sortable_keys[i].key);
if (l > len)
l = len;
memcpy(p, sortable_keys[i].key, l);
p += l;
len -= l;
}
}
*p = '\0';
return buf;
}
static char *builtin_function_regex(struct cw_channel *chan, int argc, char **argv, char *buf, size_t len)
{
char errstr[256] = "";
regex_t regexbuf;
int i;
if (argc < 2 || !argv[0][0]) {
cw_log(LOG_ERROR, "Syntax: %s\n", regex_func_syntax);
return NULL;
}
if (!buf) {
cw_log(LOG_ERROR, "%s should only be used in an expression context\n", regex_func_name);
return NULL;
}
if ((i = regcomp(®exbuf, argv[0], REG_EXTENDED | REG_NOSUB))) {
regerror(i, ®exbuf, errstr, sizeof(errstr));
cw_log(LOG_ERROR, "Malformed input %s(%s): %s\n", regex_func_name, argv[0], errstr);
return NULL;
}
if (len > 0) {
buf[0] = '0';
if (len > 1)
buf[1] = '\0';
}
for (i = 1; i < argc; i++) {
if (!regexec(®exbuf, argv[i], 0, NULL, 0)) {
snprintf(buf, len, "%d", i);
break;
}
}
regfree(®exbuf);
return buf;
}
int conference_queue_sound( struct cw_conf_member *member, char *soundfile )
{
struct cw_conf_soundq *newsound;
struct cw_conf_soundq **q;
if( member == NULL ) {
cw_log(LOG_WARNING, "Member is null. Cannot play\n");
return 0;
}
if( soundfile == NULL ) {
cw_log(LOG_WARNING, "Soundfile is null. Cannot play\n");
return 0;
}
if (
( member->force_remove_flag == 1 ) ||
( member->remove_flag == 1 )
)
{
return 0;
}
newsound = calloc(1,sizeof(struct cw_conf_soundq));
cw_copy_string(newsound->name, soundfile, sizeof(newsound->name));
// append sound to the end of the list.
cw_mutex_lock(&member->lock);
for( q = &member->soundq; *q; q = &((*q)->next) ) ;;
*q = newsound;
cw_mutex_unlock(&member->lock);
return 0 ;
}
static void sqlite_check_table_exists(char *dbfile, char *test_sql, char *create_sql)
{
sqlite3 *db;
char *errmsg;
if ((db = sqlite_open_db(dbfile))) {
if (test_sql) {
sqlite3_exec(
db,
test_sql,
NULL,
NULL,
&errmsg
);
if (errmsg) {
cw_log(LOG_WARNING,"SQL ERR [%s]\n[%s]\nAuto Repairing!\n",errmsg,test_sql);
sqlite3_free(errmsg);
errmsg = NULL;
sqlite3_exec(
db,
create_sql,
NULL,
NULL,
&errmsg
);
if (errmsg) {
cw_log(LOG_WARNING,"SQL ERR [%s]\n[%s]\n",errmsg,create_sql);
sqlite3_free(errmsg);
errmsg = NULL;
}
}
sqlite3_close(db);
}
}
}
