From 3dc668ea5d92f7d3bf85768218fa15d2b1fddc03 Mon Sep 17 00:00:00 2001 From: markster Date: Wed, 11 Sep 2002 17:09:48 +0000 Subject: Version 0.2.0 from FTP git-svn-id: http://svn.digium.com/svn/asterisk/trunk@523 f38db490-d61c-443f-a65b-d21fe96a405b --- apps/Makefile | 14 +- apps/app_festival.c | 480 ++++++++++++++++++++++++++++++++++++++++++ apps/app_sql_postgres.c | 546 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1039 insertions(+), 1 deletion(-) create mode 100755 apps/app_festival.c create mode 100755 apps/app_sql_postgres.c (limited to 'apps') diff --git a/apps/Makefile b/apps/Makefile index 0bc6259b2..ce48c4707 100755 --- a/apps/Makefile +++ b/apps/Makefile @@ -15,7 +15,11 @@ APPS=app_dial.so app_playback.so app_voicemail.so app_directory.so app_intercom.so app_mp3.so \ app_system.so app_echo.so app_record.so app_image.so app_url.so app_disa.so \ app_agi.so app_qcall.so app_adsiprog.so app_getcpeid.so app_milliwatt.so \ - app_zapateller.so + app_zapateller.so app_datetime.so app_setcallerid.so app_festival.so \ + app_queue.so + +#APPS+=app_sql_postgres.so +#APPS+=app_sql_odbc.so APPS+=$(shell if [ -f /usr/include/zap.h ]; then echo "app_zapras.so app_meetme.so" ; fi) @@ -38,6 +42,14 @@ app_todd.o: app_todd.c app_todd.so: app_todd.o $(CC) -shared -Xlinker -x -o $@ $< -L/usr/local/ssl/lib -lssl -lcrypto +app_sql_postgres.o: app_sql_postgres.c + $(CC) -pipe -I/usr/local/pgsql/include -Wall -Wmissing-prototypes -Wmissing-declarations -O6 -g -Iinclude -I../include -D_REENTRANT -D_GNU_SOURCE -march=i686 -DASTERISK_VERSION=\"CVS-07/21/02-14:49:14\" -DDO_CRASH -DDEBUG_THREADS -c -o app_sql_postgres.o app_sql_postgres.c + +app_sql_postgres.so: app_sql_postgres.o + $(CC) -shared -Xlinker -x -o $@ $< -L/usr/local/pgsql/lib -lpq + +app_sql_odbc.so: app_sql_odbc.o + $(CC) -shared -Xlinker -x -o $@ $< -lodbc look: look.c gcc -pipe -O6 -g look.c -o look -lncurses diff --git a/apps/app_festival.c b/apps/app_festival.c new file mode 100755 index 000000000..d45988c99 --- /dev/null +++ b/apps/app_festival.c @@ -0,0 +1,480 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Connect to festival + * + * Copyright (C) 2002, Christos Ricudis + * + * Christos Ricudis + * + * This program is free software, distributed under the terms of + * the GNU General Public License + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define FESTIVAL_CONFIG "festival.conf" + +static char *tdesc = "Simple Festival Interface"; + +static char *app = "Festival"; + +static char *synopsis = "Say text to the user"; + +static char *descrip = +" Festival(): Connect to Festival, send the argument, get back the waveform," +"play it to the user.\n"; + +STANDARD_LOCAL_USER; + +LOCAL_USER_DECL; + +static char *socket_receive_file_to_buff(int fd,int *size) +{ + /* Receive file (probably a waveform file) from socket using */ + /* Festival key stuff technique, but long winded I know, sorry */ + /* but will receive any file without closeing the stream or */ + /* using OOB data */ + static char *file_stuff_key = "ft_StUfF_key"; /* must == Festival's key */ + char *buff; + int bufflen; + int n,k,i; + char c; + + bufflen = 1024; + buff = (char *)malloc(bufflen); + *size=0; + + for (k=0; file_stuff_key[k] != '\0';) + { + n = read(fd,&c,1); + if (n==0) break; /* hit stream eof before end of file */ + if ((*size)+k+1 >= bufflen) + { /* +1 so you can add a NULL if you want */ + bufflen += bufflen/4; + buff = (char *)realloc(buff,bufflen); + } + if (file_stuff_key[k] == c) + k++; + else if ((c == 'X') && (file_stuff_key[k+1] == '\0')) + { /* It looked like the key but wasn't */ + for (i=0; i < k; i++,(*size)++) + buff[*size] = file_stuff_key[i]; + k=0; + /* omit the stuffed 'X' */ + } + else + { + for (i=0; i < k; i++,(*size)++) + buff[*size] = file_stuff_key[i]; + k=0; + buff[*size] = c; + (*size)++; + } + + } + + return buff; +} + +static int send_waveform_to_fd(char *waveform, int length, int fd) { + + int res; + int x; + res = fork(); + if (res < 0) + ast_log(LOG_WARNING, "Fork failed\n"); + if (res) + return res; + for (x=0;x<256;x++) { + if (x != fd) + close(x); + } + write(fd,waveform,length); + write(fd,"a",1); + close(fd); + exit(0); +} + + +static int send_waveform_to_channel(struct ast_channel *chan, char *waveform, int length) { + int res=0; + int fds[2]; + int rfds[1 + AST_MAX_FDS]; + int ms = -1; + int pid = -1; + int us; + int exception; + int owriteformat; + struct timeval tv; + struct timeval last; + struct ast_frame *f; + int x; + struct myframe { + struct ast_frame f; + char offset[AST_FRIENDLY_OFFSET]; + char frdata[160]; + } myf; + last.tv_usec = 0; + last.tv_sec = 0; + + if (pipe(fds)) { + ast_log(LOG_WARNING, "Unable to create pipe\n"); + return -1; + } + + ast_stopstream(chan); + + owriteformat = chan->writeformat; + res = ast_set_write_format(chan, AST_FORMAT_SLINEAR); + if (res < 0) { + ast_log(LOG_WARNING, "Unable to set write format to signed linear\n"); + return -1; + } + + res=send_waveform_to_fd(waveform,length,fds[1]); + if (res >= 0) { + pid = res; + /* Order is important -- there's almost always going to be mp3... we want to prioritize the + user */ + rfds[AST_MAX_FDS] = fds[0]; + for (;;) { + CHECK_BLOCKING(chan); + for (x=0;xfds[x]; + res = ast_waitfor_n_fd(rfds, AST_MAX_FDS+1, &ms, &exception); + chan->blocking = 0; + if (res < 1) { + ast_log(LOG_DEBUG, "Hangup detected\n"); + res = -1; + break; + } + for(x=0;xfds[x]) + break; + + if (x < AST_MAX_FDS) { + if (exception) + chan->exception = 1; + f = ast_read(chan); + if (!f) { + ast_log(LOG_DEBUG, "Null frame == hangup() detected\n"); + res = -1; + break; + } + if (f->frametype == AST_FRAME_DTMF) { + ast_log(LOG_DEBUG, "User pressed a key\n"); + ast_frfree(f); + res = 0; + break; + } + ast_frfree(f); + } else if (res == fds[0]) { + gettimeofday(&tv, NULL); + if (last.tv_sec || last.tv_usec) { + /* We should wait at least a frame length */ + us = sizeof(myf.frdata) / 16 * 1000; + /* Subtract 1,000,000 us for each second late we've passed */ + us -= (tv.tv_sec - last.tv_sec) * 1000000; + /* And one for each us late we've passed */ + us -= (tv.tv_usec - last.tv_usec); + /* Sleep that long if needed */ + if (us > 0) + usleep(us); + } + last = tv; + res = read(fds[0], myf.frdata, sizeof(myf.frdata)); + if (res > 0) { + myf.f.frametype = AST_FRAME_VOICE; + myf.f.subclass = AST_FORMAT_SLINEAR; + myf.f.datalen = res; + myf.f.timelen = res / 16; + myf.f.mallocd = 0; + myf.f.offset = AST_FRIENDLY_OFFSET; + myf.f.src = __PRETTY_FUNCTION__; + myf.f.data = myf.frdata; + if (ast_write(chan, &myf.f) < 0) { + res = -1; + break; + } + if (res < sizeof(myf.frdata)) { // last frame + ast_log(LOG_WARNING, "Last frame\n"); + res=0; + break; + } + } else { + ast_log(LOG_WARNING, "No more waveform\n"); + res = 0; + } + } else { + ast_log(LOG_DEBUG, "HuhHHH?\n"); + res = -1; + break; + } + } + } + close(fds[0]); + close(fds[1]); +// if (pid > -1) +// kill(pid, SIGKILL); + if (!res && owriteformat) + ast_set_write_format(chan, owriteformat); + return res; +} + +#define MAXLEN 180 +#define MAXFESTLEN 2048 + + + + +static int festival_exec(struct ast_channel *chan, void *data) +{ + int usecache; + int res=0; + struct localuser *u; + struct sockaddr_in serv_addr; + struct hostent *serverhost; + int fd; + FILE *fs; + char *host; + char *cachedir; + char *temp; + char *festivalcommand; + int port=1314; + int n; + char ack[4]; + char *waveform; + int filesize; + int wave; + char bigstring[MAXFESTLEN]; + int i; + struct MD5Context md5ctx; + unsigned char MD5Res[16]; + char MD5Hex[32]; + char koko[4]; + char cachefile[MAXFESTLEN]; + int readcache=0; + int writecache=0; + int strln; + int fdesc; + char buffer[16384]; + int seekpos; + + struct ast_config *cfg; + cfg = ast_load(FESTIVAL_CONFIG); + if (!cfg) { + ast_log(LOG_WARNING, "No such configuration file %s\n", FESTIVAL_CONFIG); + return -1; + } + if (!(host = ast_variable_retrieve(cfg, "general", "host"))) { + host = "localhost"; + } + if (!(temp = ast_variable_retrieve(cfg, "general", "port"))) { + port = 1314; + } else { + port = atoi(temp); + } + if (!(temp = ast_variable_retrieve(cfg, "general", "usecache"))) { + usecache=0; + } else { + if (strcasecmp(temp,"yes")==0) { + usecache=1; + } + } + if (!(cachedir = ast_variable_retrieve(cfg, "general", "cachedir"))) { + cachedir = "/tmp/"; + } + if (!(festivalcommand = ast_variable_retrieve(cfg, "general", "festivalcommand"))) { + festivalcommand = "(tts_textasterisk \"%s\" 'file)(quit)\n"; + } + + + + if (!data) { + ast_log(LOG_WARNING, "festival requires an argument (text)\n"); + return -1; + } + LOCAL_USER_ADD(u); + ast_log(LOG_WARNING, "Text passed to festival server : %s\n",(char *)data); + /* Connect to local festival server */ + + fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + if (fd < 0) { + ast_log(LOG_WARNING,"festival_client: can't get socket\n"); + return -1; + } + memset(&serv_addr, 0, sizeof(serv_addr)); + if ((serv_addr.sin_addr.s_addr = inet_addr(host)) == -1) { + /* its a name rather than an ipnum */ + serverhost = gethostbyname(host); + if (serverhost == (struct hostent *)0) { + ast_log(LOG_WARNING,"festival_client: gethostbyname failed\n"); + return -1; + } + memmove(&serv_addr.sin_addr,serverhost->h_addr, serverhost->h_length); + } + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(port); + + if (connect(fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != 0) { + ast_log(LOG_WARNING,"festival_client: connect to server failed\n"); + return -1; + } + + /* Compute MD5 sum of string */ + MD5Init(&md5ctx); + MD5Update(&md5ctx,(unsigned char const *)data,strlen(data)); + MD5Final(MD5Res,&md5ctx); + strcpy(MD5Hex,""); + + /* Convert to HEX and look if there is any matching file in the cache + directory */ + for (i=0;i<16;i++) { + sprintf(koko,"%X",MD5Res[i]); + strcat(MD5Hex,koko); + } + readcache=0; + writecache=0; + if (strlen(cachedir)+strlen(MD5Hex)+1<=MAXFESTLEN && (usecache==1)) { + sprintf(cachefile,"%s/%s",cachedir,MD5Hex); + fdesc=open(cachefile,O_RDWR); + if (fdesc==-1) { + fdesc=open(cachefile,O_CREAT|O_RDWR,0); + if (fdesc!=-1) { + writecache=1; + strln=strlen((char *)data); + ast_log(LOG_WARNING,"line length : %d\n",strln); + write(fdesc,&strln,sizeof(int)); + write(fdesc,data,strln); + seekpos=lseek(fdesc,0,SEEK_CUR); + ast_log(LOG_WARNING,"Seek position : %d\n",seekpos); + } + } else { + read(fdesc,&strln,sizeof(int)); + ast_log(LOG_WARNING,"Cache file exists, strln=%d, strlen=%d\n",strln,strlen((char *)data)); + if (strlen((char *)data)==strln) { + ast_log(LOG_WARNING,"Size OK\n"); + read(fdesc,&bigstring,strln); + if (strcmp(bigstring,data)==0) { + readcache=1; + } else { + ast_log(LOG_WARNING,"Strings do not match\n"); + } + } else { + ast_log(LOG_WARNING,"Size mismatch\n"); + } + } + } + + if (readcache==1) { + close(fd); + fd=fdesc; + ast_log(LOG_WARNING,"Reading from cache...\n"); + } else { + ast_log(LOG_WARNING,"Passing text to festival...\n"); + fs=fdopen(dup(fd),"wb"); + fprintf(fs,festivalcommand,(char *)data); + fflush(fs); + fclose(fs); + } + + /* Write to cache and then pass it down */ + if (writecache==1) { + ast_log(LOG_WARNING,"Writing result to cache...\n"); + while ((strln=read(fd,buffer,16384))!=0) { + write(fdesc,buffer,strln); + } + close(fd); + close(fdesc); + fd=open(cachefile,O_RDWR); + lseek(fd,seekpos,SEEK_SET); + } + + ast_log(LOG_WARNING,"Passing data to channel...\n"); + + /* Read back info from server */ + /* This assumes only one waveform will come back, also LP is unlikely */ + wave = 0; + do { + for (n=0; n < 3; ) + n += read(fd,ack+n,3-n); + ack[3] = '\0'; + if (strcmp(ack,"WV\n") == 0) { /* receive a waveform */ + ast_log(LOG_WARNING,"Festival WV command"); + waveform = socket_receive_file_to_buff(fd,&filesize); + send_waveform_to_channel(chan,waveform,filesize); + free(waveform); + res=0; + break; + } + else if (strcmp(ack,"LP\n") == 0) { /* receive an s-expr */ + ast_log(LOG_WARNING,"Festival LP command"); + waveform = socket_receive_file_to_buff(fd,&filesize); + waveform[filesize]='\0'; + ast_log(LOG_WARNING,"Festival returned LP : %s\n",waveform); + free(waveform); + } else if (strcmp(ack,"ER\n") == 0) { /* server got an error */ + ast_log(LOG_WARNING,"Festival returned ER\n"); + res=-1; + break; + } + } while (strcmp(ack,"OK\n") != 0); + close(fd); + LOCAL_USER_REMOVE(u); + return res; + +} + +int unload_module(void) +{ + STANDARD_HANGUP_LOCALUSERS; + return ast_unregister_application(app); +} + +int load_module(void) +{ + + return ast_register_application(app, festival_exec, synopsis, descrip); +} + +char *description(void) +{ + return tdesc; +} + +int usecount(void) +{ + int res; + STANDARD_USECOUNT(res); + return res; +} + +char *key() +{ + return ASTERISK_GPL_KEY; +} diff --git a/apps/app_sql_postgres.c b/apps/app_sql_postgres.c new file mode 100755 index 000000000..628987ad5 --- /dev/null +++ b/apps/app_sql_postgres.c @@ -0,0 +1,546 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Connect to PostgreSQL + * + * Copyright (C) 2002, Christos Ricudis + * + * Christos Ricudis + * + * This program is free software, distributed under the terms of + * the GNU General Public License + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "libpq-fe.h" + + + + +static char *tdesc = "Simple PostgreSQL Interface"; + +static char *app = "PGSQL"; + +static char *synopsis = "Do several SQLy things"; + +static char *descrip = +" PGSQL(): Do several SQLy things\n"; + +/* + +Syntax of SQL commands : + + Connect #var option-string + + Connects to a database using the option-string and stores the + connection identifier in $var + + + Query var connection-identifier query-string + + Submits query-string to database backend and stores the result + identifier in ${var} + + + Fetch statusvar result-identifier var1 var2 var3 ... varn + + Fetches a row from the query and stores end-of-table status in + ${statusvar} and columns in ${var1}..${varn} + + + Clear result-identifier + + Clears data structures associated with result-identifier + + + Disconnect connection-identifier + + Disconnects from named connection + + +EXAMPLES OF USE : + +( + $2 = Connection Identifier + $3 = Result Identifier + $4 = Fetch Status Identifier (0 = no more rows) + $5, $6 = Data variables +) + +exten => s,2,PGSQL,"Connect connid host=localhost user=asterisk dbname=credit"; +exten => s,3,PGSQL,"Query resultid ${connid} SELECT username,credit FROM credit WHERE callerid=${callerid}"; +exten => s,4,PGSQL,"Fetch fetchid ${resultid} datavar1 datavar2"; +exten => s,5,GotoIf,"${fetchid}=1?s|6:s|8"; +exten => s,6,blablabla ${datavar1} ${datavar2} (does blablabla, datavar1 = username, datavar2 = credit); +exten => s,7,Goto,s|4 +exten => s,8,PGSQL,"Clear ${resultid}"; +exten => s,9,PGSQL,"Disconnect ${connid}"; + +*/ + +STANDARD_LOCAL_USER; + +LOCAL_USER_DECL; + +extern void pbx_builtin_setvar_helper(struct ast_channel *chan, char *name, char *value); + +#define AST_PGSQL_ID_DUMMY 0 +#define AST_PGSQL_ID_CONNID 1 +#define AST_PGSQL_ID_RESID 2 +#define AST_PGSQL_ID_FETCHID 3 + +struct ast_PGSQL_id { + int identifier_type; /* 0=dummy, 1=connid, 2=resultid */ + int identifier; + void *data; + AST_LIST_ENTRY(ast_PGSQL_id) entries; +} *ast_PGSQL_id; + +AST_LIST_HEAD(PGSQLidshead,ast_PGSQL_id) PGSQLidshead; + +static void *find_identifier(int identifier,int identifier_type) { + struct PGSQLidshead *headp; + struct ast_PGSQL_id *i; + void *res=NULL; + int found=0; + + headp=&PGSQLidshead; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING,"Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE(headp,i,entries) { + if ((i->identifier==identifier) && (i->identifier_type==identifier_type)) { + found=1; + res=i->data; + break; + } + } + if (!found) { + ast_log(LOG_WARNING,"Identifier %d, identifier_type %d not found in identifier list\n",identifier,identifier_type); + } + AST_LIST_UNLOCK(headp); + } + + return(res); +} + +static int add_identifier(int identifier_type,void *data) { + struct ast_PGSQL_id *i,*j; + struct PGSQLidshead *headp; + int maxidentifier=0; + + headp=&PGSQLidshead; + i=NULL; + j=NULL; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING,"Unable to lock identifiers list\n"); + return(-1); + } else { + i=malloc(sizeof(struct ast_PGSQL_id)); + AST_LIST_TRAVERSE(headp,j,entries) { + if (j->identifier>maxidentifier) { + maxidentifier=j->identifier; + } + } + + i->identifier=maxidentifier+1; + i->identifier_type=identifier_type; + i->data=data; + AST_LIST_INSERT_HEAD(headp,i,entries); + AST_LIST_UNLOCK(headp); + } + return(i->identifier); +} + +static int del_identifier(int identifier,int identifier_type) { + struct ast_PGSQL_id *i; + struct PGSQLidshead *headp; + int found=0; + + headp=&PGSQLidshead; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING,"Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE(headp,i,entries) { + if ((i->identifier==identifier) && + (i->identifier_type==identifier_type)) { + AST_LIST_REMOVE(headp,i,ast_PGSQL_id,entries); + free(i); + found=1; + break; + } + } + AST_LIST_UNLOCK(headp); + } + + if (found==0) { + ast_log(LOG_WARNING,"Could not find identifier %d, identifier_type %d in list to delete\n",identifier,identifier_type); + return(-1); + } else { + return(0); + } +} + +static int aPGSQL_connect(struct ast_channel *chan, void *data) { + + char *ptrptr; + char *s1,*s4; + char s[100]; + char *optionstring; + char *var; + int l; + int res; + PGconn *karoto; + int id; + + + res=0; + l=strlen(data)+2; + s1=malloc(l); + strncpy(s1,data,l); + strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P + var=strtok_r(NULL," ",&ptrptr); + optionstring=strtok_r(NULL,"\n",&ptrptr); + + karoto = PQconnectdb(optionstring); + if (PQstatus(karoto) == CONNECTION_BAD) { + ast_log(LOG_WARNING,"Connection to database using '%s' failed. postgress reports : %s\n", optionstring, + PQerrorMessage(karoto)); + res=-1; + } else { + ast_log(LOG_WARNING,"adding identifier\n"); + id=add_identifier(AST_PGSQL_ID_CONNID,karoto); + s4=&s[0]; + sprintf(s4,"%d",id); + pbx_builtin_setvar_helper(chan,var,s); + } + + free(s1); + return res; +} + +static int aPGSQL_query(struct ast_channel *chan, void *data) { + + char *ptrptr; + char *s1,*s2,*s3,*s4,*s5; + char s[100]; + char *querystring; + char *var; + int l; + int res,nres; + PGconn *karoto; + PGresult *PGSQLres; + int id,id1; + + + res=0; + l=strlen(data)+2; + s1=malloc(l); + s2=malloc(l); + strcpy(s1,data); + strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P + s3=strtok_r(NULL," ",&ptrptr); + while (1) { // ugly trick to make branches with break; + var=s3; + s4=strtok_r(NULL," ",&ptrptr); + id=atoi(s4); + querystring=strtok_r(NULL,"\n",&ptrptr); + if ((karoto=find_identifier(id,AST_PGSQL_ID_CONNID))==NULL) { + ast_log(LOG_WARNING,"Invalid connection identifier %d passed in aPGSQL_query\n",id); + res=-1; + break; + } + PGSQLres=PQexec(karoto,querystring); + if (PGSQLres==NULL) { + ast_log(LOG_WARNING,"aPGSQL_query: Connection Error (connection identifier = %d, error message : %s)\n",id,PQerrorMessage(karoto)); + res=-1; + break; + } + if (PQresultStatus(PGSQLres) == PGRES_BAD_RESPONSE || + PQresultStatus(PGSQLres) == PGRES_NONFATAL_ERROR || + PQresultStatus(PGSQLres) == PGRES_FATAL_ERROR) { + ast_log(LOG_WARNING,"aPGSQL_query: Query Error (connection identifier : %d, error message : %s)\n",id,PQcmdStatus(PGSQLres)); + res=-1; + break; + } + nres=PQnfields(PGSQLres); + id1=add_identifier(AST_PGSQL_ID_RESID,PGSQLres); + s5=&s[0]; + sprintf(s5,"%d",id1); + pbx_builtin_setvar_helper(chan,var,s); + break; + } + + free(s1); + free(s2); + return(res); +} + + +static int aPGSQL_fetch(struct ast_channel *chan, void *data) { + + char *ptrptr; + char *s1,*s2,*s3,*s4,*s5,*s6,*s7; + char s[100]; + char *var; + int l; + int res; + PGresult *PGSQLres; + int id,id1,i,j,fnd; + int *lalares=NULL; + int nres; + struct ast_var_t *variables; + struct varshead *headp; + + headp=&chan->varshead; + + res=0; + l=strlen(data)+2; + s7=NULL; + s1=malloc(l); + s2=malloc(l); + strcpy(s1,data); + strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P + s3=strtok_r(NULL," ",&ptrptr); + while (1) { // ugly trick to make branches with break; + var=s3; // fetchid + fnd=0; + + AST_LIST_TRAVERSE(headp,variables,entries) { + if (strncasecmp(ast_var_name(variables),s3,strlen(s3))==0) { + s7=ast_var_value(variables); + fnd=1; + break; + } + } + + if (fnd==0) { + s7="0"; + pbx_builtin_setvar_helper(chan,s3,s7); + } + + s4=strtok_r(NULL," ",&ptrptr); + id=atoi(s4); // resultid + if ((PGSQLres=find_identifier(id,AST_PGSQL_ID_RESID))==NULL) { + ast_log(LOG_WARNING,"Invalid result identifier %d passed in aPGSQL_fetch\n",id); + res=-1; + break; + } + id=atoi(s7); //fetchid + if ((lalares=find_identifier(id,AST_PGSQL_ID_FETCHID))==NULL) { + i=0; + } else { + i=*lalares; + free(lalares); + del_identifier(id,AST_PGSQL_ID_FETCHID); + } + nres=PQnfields(PGSQLres); + ast_log(LOG_WARNING,"ast_PGSQL_fetch : nres = %d i = %d ;\n",nres,i); + for (j=0;j