Version 0.2.0 from FTP

git-svn-id: http://svn.digium.com/svn/asterisk/trunk@523 f38db490-d61c-443f-a65b-d21fe96a405b

3 files changed, 1039 insertions, 1 deletions

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 <ricudis@paiko.gr>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include <asterisk/file.h>
+#include <asterisk/logger.h>
+#include <asterisk/channel.h>
+#include <asterisk/pbx.h>
+#include <asterisk/module.h>
+#include <asterisk/md5.h>
+#include <asterisk/config.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <pthread.h>
+
+
+#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;x<AST_MAX_FDS;x++) 
+				rfds[x] = chan->fds[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;x<AST_MAX_FDS;x++) 
+				if (res == chan->fds[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 <ricudis@paiko.gr>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include <asterisk/file.h>
+#include <asterisk/logger.h>
+#include <asterisk/channel.h>
+#include <asterisk/pbx.h>
+#include <asterisk/module.h>
+#include <asterisk/linkedlists.h>
+#include <asterisk/chanvars.h>
+#include <asterisk/lock.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <pthread.h>
+#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<nres;j++) {
+			s5=strtok_r(NULL," ",&ptrptr);
+			if (s5==NULL) {
+				ast_log(LOG_WARNING,"ast_PGSQL_fetch : More tuples (%d) than variables (%d)\n",nres,j);
+				break;
+			}
+			
+			s6=PQgetvalue(PGSQLres,i,j);
+			if (s6==NULL) { 
+				ast_log(LOG_WARNING,"PWgetvalue(res,%d,%d) returned NULL in ast_PGSQL_fetch\n",i,j);
+				break;
+			}
+			ast_log(LOG_WARNING,"===setting variable '%s' to '%s'\n",s5,s6);
+			pbx_builtin_setvar_helper(chan,s5,s6);
+		}
+		i++;
+		if (i<PQntuples(PGSQLres)) {
+			lalares=malloc(sizeof(int));
+			*lalares=i;
+			id1=add_identifier(AST_PGSQL_ID_FETCHID,lalares);
+		} else {
+			id1=0;
+		}
+		s5=&s[0];
+		sprintf(s5,"%d",id1);
+		ast_log(LOG_WARNING,"Setting var '%s' to value '%s'\n",s3,s);
+		pbx_builtin_setvar_helper(chan,s3,s);
+	 	break;
+	}
+	
+	free(s1);
+	free(s2);
+	return(res);
+}
+
+static int aPGSQL_reset(struct ast_channel *chan, void *data) {
+	
+	char *ptrptr;
+	char *s1,*s3;
+	int l;
+	PGconn *karoto;
+	int id;
+	 
+	
+	l=strlen(data)+2;
+	s1=malloc(l);
+	strcpy(s1,data);
+	strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P 
+	s3=strtok_r(NULL," ",&ptrptr);
+	id=atoi(s3);
+	if ((karoto=find_identifier(id,AST_PGSQL_ID_CONNID))==NULL) {
+		ast_log(LOG_WARNING,"Invalid connection identifier %d passed in aPGSQL_reset\n",id);
+	} else {
+		PQreset(karoto);
+	} 
+	free(s1);
+	return(0);
+	
+}
+
+static int aPGSQL_clear(struct ast_channel *chan, void *data) {
+	
+	char *ptrptr;
+	char *s1,*s3;
+	int l;
+	PGresult *karoto;
+	int id;
+	 
+	
+	l=strlen(data)+2;
+	s1=malloc(l);
+	strcpy(s1,data);
+	strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P 
+	s3=strtok_r(NULL," ",&ptrptr);
+	id=atoi(s3);
+	if ((karoto=find_identifier(id,AST_PGSQL_ID_RESID))==NULL) {
+		ast_log(LOG_WARNING,"Invalid result identifier %d passed in aPGSQL_clear\n",id);
+	} else {
+		PQclear(karoto);
+		del_identifier(id,AST_PGSQL_ID_RESID);
+	}
+	free(s1);
+	return(0);
+	
+}
+
+	   
+	   
+	
+static int aPGSQL_disconnect(struct ast_channel *chan, void *data) {
+	
+	char *ptrptr;
+	char *s1,*s3;
+	int l;
+	PGconn *karoto;
+	int id;
+	 
+	
+	l=strlen(data)+2;
+	s1=malloc(l);
+	strcpy(s1,data);
+	strtok_r(s1," ",&ptrptr); // eat the first token, we already know it :P 
+	s3=strtok_r(NULL," ",&ptrptr);
+	id=atoi(s3);
+	if ((karoto=find_identifier(id,AST_PGSQL_ID_CONNID))==NULL) {
+		ast_log(LOG_WARNING,"Invalid connection identifier %d passed in aPGSQL_disconnect\n",id);
+	} else {
+		PQfinish(karoto);
+		del_identifier(id,AST_PGSQL_ID_CONNID);
+	} 
+	free(s1);
+	return(0);
+	
+}
+
+static int aPGSQL_debug(struct ast_channel *chan, void *data) {
+	ast_log(LOG_WARNING,"Debug : %s\n",(char *)data);
+	return(0);
+}
+		
+	
+
+static int PGSQL_exec(struct ast_channel *chan, void *data)
+{
+	struct localuser *u;
+	int result;
+
+	if (!data) {
+		ast_log(LOG_WARNING, "APP_PGSQL requires an argument (see manual)\n");
+		return -1;
+	}
+	LOCAL_USER_ADD(u);
+	result=0;
+	
+	if (strncasecmp("connect",data,strlen("connect"))==0) {
+		result=(aPGSQL_connect(chan,data));
+	} else 	if (strncasecmp("query",data,strlen("query"))==0) {
+		result=(aPGSQL_query(chan,data));
+	} else 	if (strncasecmp("fetch",data,strlen("fetch"))==0) {
+		result=(aPGSQL_fetch(chan,data));
+	} else 	if (strncasecmp("reset",data,strlen("reset"))==0) {
+		result=(aPGSQL_reset(chan,data));
+	} else 	if (strncasecmp("clear",data,strlen("clear"))==0) {
+		result=(aPGSQL_clear(chan,data));
+	} else  if (strncasecmp("debug",data,strlen("debug"))==0) {
+		result=(aPGSQL_debug(chan,data));
+	} else 	if (strncasecmp("disconnect",data,strlen("disconnect"))==0) {
+		result=(aPGSQL_disconnect(chan,data));
+	} else {
+		ast_log(LOG_WARNING, "Unknown APP_PGSQL argument : %s\n",(char *)data);
+		result=-1;	
+	}
+		
+	LOCAL_USER_REMOVE(u);                                                                                
+	return result;
+
+}
+
+int unload_module(void)
+{
+	STANDARD_HANGUP_LOCALUSERS;
+	return ast_unregister_application(app);
+}
+
+int load_module(void)
+{
+	struct PGSQLidshead *headp;
+	
+        headp=&PGSQLidshead;
+        
+	AST_LIST_HEAD_INIT(headp);
+	return ast_register_application(app, PGSQL_exec, synopsis, descrip);
+}
+
+char *description(void)
+{
+	return tdesc;
+}
+
+int usecount(void)
+{
+	int res;
+	STANDARD_USECOUNT(res);
+	return res;
+}
+
+char *key()
+{
+	return ASTERISK_GPL_KEY;
+}