remove a couple more unnecessary "out of memory" error messages
[asterisk/asterisk.git] / res / res_config_pgsql.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Copyright (C) 1999-2005, Digium, Inc.
5  * 
6  * Manuel Guesdon <mguesdon@oxymium.net> - Postgresql RealTime Driver Author/Adaptor
7  * Mark Spencer <markster@digium.com>  - Asterisk Author
8  * Matthew Boehm <mboehm@cytelcom.com> - MySQL RealTime Driver Author
9  *
10  * res_config_pgsql.c <Postgresql plugin for RealTime configuration engine>
11  *
12  * v1.0   - (07-11-05) - Initial version based on res_config_mysql v2.0
13  */
14
15 /*! \file
16  *
17  * \brief Postgresql plugin for Asterisk RealTime Architecture
18  *
19  * \author Mark Spencer <markster@digium.com>
20  * \author Manuel Guesdon <mguesdon@oxymium.net> - Postgresql RealTime Driver Author/Adaptor
21  *
22  * \arg http://www.postgresql.org
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27 #include <libpq-fe.h>                   /* PostgreSQL */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include "asterisk/file.h"
34 #include "asterisk/logger.h"
35 #include "asterisk/channel.h"
36 #include "asterisk/pbx.h"
37 #include "asterisk/config.h"
38 #include "asterisk/module.h"
39 #include "asterisk/lock.h"
40 #include "asterisk/options.h"
41 #include "asterisk/utils.h"
42 #include "asterisk/cli.h"
43
44 static char *res_config_pgsql_desc = "Postgresql RealTime Configuration Driver";
45
46 AST_MUTEX_DEFINE_STATIC(pgsql_lock);
47
48 #define RES_CONFIG_PGSQL_CONF "res_pgsql.conf"
49
50 PGconn *pgsqlConn = NULL;
51
52 #define MAX_DB_OPTION_SIZE 64
53
54 static char dbhost[MAX_DB_OPTION_SIZE] = "";
55 static char dbuser[MAX_DB_OPTION_SIZE] = "";
56 static char dbpass[MAX_DB_OPTION_SIZE] = "";
57 static char dbname[MAX_DB_OPTION_SIZE] = "";
58 static char dbsock[MAX_DB_OPTION_SIZE] = "";
59 static int dbport = 5432;
60 static time_t connect_time = 0;
61
62 static int parse_config(void);
63 static int pgsql_reconnect(const char *database);
64 static int realtime_pgsql_status(int fd, int argc, char **argv);
65
66 LOCAL_USER_DECL;
67
68 static char cli_realtime_pgsql_status_usage[] =
69         "Usage: realtime pgsql status\n"
70         "       Shows connection information for the Postgresql RealTime driver\n";
71
72 static struct ast_cli_entry cli_realtime_pgsql_status = {
73          { "realtime", "pgsql", "status", NULL }, realtime_pgsql_status,
74          "Shows connection information for the Postgresql RealTime driver",
75          cli_realtime_pgsql_status_usage, NULL
76  };
77
78 static struct ast_variable *realtime_pgsql(const char *database, const char *table, va_list ap)
79 {
80         PGresult *result = NULL;
81         int num_rows = 0;
82         char sql[256];
83         char *stringp;
84         char *chunk;
85         char *op;
86         const char *newparam, *newval;
87         struct ast_variable *var = NULL, *prev = NULL;
88
89         if (!table) {
90                 ast_log(LOG_WARNING, "Postgresql RealTime: No table specified.\n");
91                 return NULL;
92         }
93
94         /* Get the first parameter and first value in our list of passed paramater/value pairs */
95         newparam = va_arg(ap, const char *);
96         newval = va_arg(ap, const char *);
97         if (!newparam || !newval) {
98                 ast_log(LOG_WARNING,
99                                 "Postgresql RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
100                 if (pgsqlConn) {
101                         PQfinish(pgsqlConn);
102                         pgsqlConn = NULL;
103                 };
104                 return NULL;
105         }
106
107         /* Create the first part of the query using the first parameter/value pairs we just extracted
108            If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
109         op = strchr(newparam, ' ') ? "" : " =";
110
111         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op,
112                          newval);
113         while ((newparam = va_arg(ap, const char *))) {
114                 newval = va_arg(ap, const char *);
115                 if (!strchr(newparam, ' '))
116                         op = " =";
117                 else
118                         op = "";
119                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s '%s'", newparam,
120                                  op, newval);
121         }
122         va_end(ap);
123
124         /* We now have our complete statement; Lets connect to the server and execute it. */
125         ast_mutex_lock(&pgsql_lock);
126         if (!pgsql_reconnect(database)) {
127                 ast_mutex_unlock(&pgsql_lock);
128                 return NULL;
129         }
130
131         if (!(result = PQexec(pgsqlConn, sql))) {
132                 ast_log(LOG_WARNING,
133                                 "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
134                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
135                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n",
136                                 PQerrorMessage(pgsqlConn));
137                 ast_mutex_unlock(&pgsql_lock);
138                 return NULL;
139         } else {
140                 ExecStatusType result_status = PQresultStatus(result);
141                 if (result_status != PGRES_COMMAND_OK
142                         && result_status != PGRES_TUPLES_OK
143                         && result_status != PGRES_NONFATAL_ERROR) {
144                         ast_log(LOG_WARNING,
145                                         "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
146                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
147                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n",
148                                         PQresultErrorMessage(result), PQresStatus(result_status));
149                         ast_mutex_unlock(&pgsql_lock);
150                         return NULL;
151                 }
152         }
153
154         ast_log(LOG_DEBUG, "1Postgresql RealTime: Result=%p Query: %s\n", result, sql);
155
156         if ((num_rows = PQntuples(result)) > 0) {
157                 int i = 0;
158                 int rowIndex = 0;
159                 int numFields = PQnfields(result);
160                 char **fieldnames = NULL;
161
162                 ast_log(LOG_DEBUG, "Postgresql RealTime: Found %d rows.\n", num_rows);
163
164                 if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) {
165                         ast_mutex_unlock(&pgsql_lock);
166                         PQclear(result);
167                         return NULL;
168                 }
169                 for (i = 0; i < numFields; i++)
170                         fieldnames[i] = PQfname(result, i);
171                 for (rowIndex = 0; rowIndex < num_rows; rowIndex++) {
172                         for (i = 0; i < numFields; i++) {
173                                 stringp = PQgetvalue(result, rowIndex, i);
174                                 while (stringp) {
175                                         chunk = strsep(&stringp, ";");
176                                         if (chunk && !ast_strlen_zero(ast_strip(chunk))) {
177                                                 if (prev) {
178                                                         prev->next = ast_variable_new(fieldnames[i], chunk);
179                                                         if (prev->next) {
180                                                                 prev = prev->next;
181                                                         }
182                                                 } else {
183                                                         prev = var = ast_variable_new(fieldnames[i], chunk);
184                                                 }
185                                         }
186                                 }
187                         }
188                 }
189                 free(fieldnames);
190         } else {
191                 ast_log(LOG_WARNING,
192                                 "Postgresql RealTime: Could not find any rows in table %s.\n", table);
193         }
194
195         ast_mutex_unlock(&pgsql_lock);
196         PQclear(result);
197
198         return var;
199 }
200
201 static struct ast_config *realtime_multi_pgsql(const char *database, const char *table, va_list ap)
202 {
203         PGresult *result = NULL;
204         int num_rows = 0;
205         char sql[256];
206         const char *initfield = NULL;
207         char *stringp;
208         char *chunk;
209         char *op;
210         const char *newparam, *newval;
211         struct ast_realloca ra;
212         struct ast_variable *var = NULL;
213         struct ast_config *cfg = NULL;
214         struct ast_category *cat = NULL;
215
216         if (!table) {
217                 ast_log(LOG_WARNING, "Postgresql RealTime: No table specified.\n");
218                 return NULL;
219         }
220
221         memset(&ra, 0, sizeof(ra));
222
223         if (!(cfg = ast_config_new()))
224                 return NULL;
225
226         /* Get the first parameter and first value in our list of passed paramater/value pairs */
227         newparam = va_arg(ap, const char *);
228         newval = va_arg(ap, const char *);
229         if (!newparam || !newval) {
230                 ast_log(LOG_WARNING,
231                                 "Postgresql RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
232                 if (pgsqlConn) {
233                         PQfinish(pgsqlConn);
234                         pgsqlConn = NULL;
235                 };
236                 return NULL;
237         }
238
239         initfield = ast_strdupa(newparam);
240         if (initfield && (op = strchr(initfield, ' '))) {
241                 *op = '\0';
242         }
243
244         /* Create the first part of the query using the first parameter/value pairs we just extracted
245            If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
246
247         if (!strchr(newparam, ' '))
248                 op = " =";
249         else
250                 op = "";
251
252         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op,
253                          newval);
254         while ((newparam = va_arg(ap, const char *))) {
255                 newval = va_arg(ap, const char *);
256                 if (!strchr(newparam, ' '))
257                         op = " =";
258                 else
259                         op = "";
260                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s '%s'", newparam,
261                                  op, newval);
262         }
263
264         if (initfield) {
265                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " ORDER BY %s", initfield);
266         }
267
268         va_end(ap);
269
270         /* We now have our complete statement; Lets connect to the server and execute it. */
271         ast_mutex_lock(&pgsql_lock);
272         if (!pgsql_reconnect(database)) {
273                 ast_mutex_unlock(&pgsql_lock);
274                 return NULL;
275         }
276
277         if (!(result = PQexec(pgsqlConn, sql))) {
278                 ast_log(LOG_WARNING,
279                                 "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
280                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
281                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n",
282                                 PQerrorMessage(pgsqlConn));
283                 ast_mutex_unlock(&pgsql_lock);
284                 return NULL;
285         } else {
286                 ExecStatusType result_status = PQresultStatus(result);
287                 if (result_status != PGRES_COMMAND_OK
288                         && result_status != PGRES_TUPLES_OK
289                         && result_status != PGRES_NONFATAL_ERROR) {
290                         ast_log(LOG_WARNING,
291                                         "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
292                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
293                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n",
294                                         PQresultErrorMessage(result), PQresStatus(result_status));
295                         ast_mutex_unlock(&pgsql_lock);
296                         return NULL;
297                 }
298         }
299
300         ast_log(LOG_DEBUG, "2Postgresql RealTime: Result=%p Query: %s\n", result, sql);
301
302         if ((num_rows = PQntuples(result)) > 0) {
303                 int numFields = PQnfields(result);
304                 int i = 0;
305                 int rowIndex = 0;
306                 char **fieldnames = NULL;
307
308                 ast_log(LOG_DEBUG, "Postgresql RealTime: Found %d rows.\n", num_rows);
309
310                 if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) {
311                         ast_mutex_unlock(&pgsql_lock);
312                         PQclear(result);
313                         return NULL;
314                 }
315                 for (i = 0; i < numFields; i++)
316                         fieldnames[i] = PQfname(result, i);
317
318                 for (rowIndex = 0; rowIndex < num_rows; rowIndex++) {
319                         var = NULL;
320                         if (!(cat = ast_category_new("")))
321                                 continue;
322                         for (i = 0; i < numFields; i++) {
323                                 stringp = PQgetvalue(result, rowIndex, i);
324                                 while (stringp) {
325                                         chunk = strsep(&stringp, ";");
326                                         if (chunk && !ast_strlen_zero(ast_strip(chunk))) {
327                                                 if (initfield && !strcmp(initfield, fieldnames[i])) {
328                                                         ast_category_rename(cat, chunk);
329                                                 }
330                                                 var = ast_variable_new(fieldnames[i], chunk);
331                                                 ast_variable_append(cat, var);
332                                         }
333                                 }
334                         }
335                         ast_category_append(cfg, cat);
336                 }
337                 free(fieldnames);
338         } else {
339                 ast_log(LOG_WARNING,
340                                 "Postgresql RealTime: Could not find any rows in table %s.\n", table);
341         }
342
343         ast_mutex_unlock(&pgsql_lock);
344         PQclear(result);
345
346         return cfg;
347 }
348
349 static int update_pgsql(const char *database, const char *table, const char *keyfield,
350                                                 const char *lookup, va_list ap)
351 {
352         PGresult *result = NULL;
353         int numrows = 0;
354         char sql[256];
355         const char *newparam, *newval;
356
357         if (!table) {
358                 ast_log(LOG_WARNING, "Postgresql RealTime: No table specified.\n");
359                 return -1;
360         }
361
362         /* Get the first parameter and first value in our list of passed paramater/value pairs */
363         newparam = va_arg(ap, const char *);
364         newval = va_arg(ap, const char *);
365         if (!newparam || !newval) {
366                 ast_log(LOG_WARNING,
367                                 "Postgresql RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
368                 if (pgsqlConn) {
369                         PQfinish(pgsqlConn);
370                         pgsqlConn = NULL;
371                 };
372                 return -1;
373         }
374
375         /* Create the first part of the query using the first parameter/value pairs we just extracted
376            If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
377
378         snprintf(sql, sizeof(sql), "UPDATE %s SET %s = '%s'", table, newparam, newval);
379         while ((newparam = va_arg(ap, const char *))) {
380                 newval = va_arg(ap, const char *);
381                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), ", %s = '%s'", newparam,
382                                  newval);
383         }
384         va_end(ap);
385         snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " WHERE %s = '%s'", keyfield,
386                          lookup);
387
388         ast_log(LOG_DEBUG, "Postgresql RealTime: Update SQL: %s\n", sql);
389
390         /* We now have our complete statement; Lets connect to the server and execute it. */
391         ast_mutex_lock(&pgsql_lock);
392         if (!pgsql_reconnect(database)) {
393                 ast_mutex_unlock(&pgsql_lock);
394                 return -1;
395         }
396
397         if (!(result = PQexec(pgsqlConn, sql))) {
398                 ast_log(LOG_WARNING,
399                                 "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
400                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
401                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n",
402                                 PQerrorMessage(pgsqlConn));
403                 ast_mutex_unlock(&pgsql_lock);
404                 return -1;
405         } else {
406                 ExecStatusType result_status = PQresultStatus(result);
407                 if (result_status != PGRES_COMMAND_OK
408                         && result_status != PGRES_TUPLES_OK
409                         && result_status != PGRES_NONFATAL_ERROR) {
410                         ast_log(LOG_WARNING,
411                                         "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
412                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
413                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n",
414                                         PQresultErrorMessage(result), PQresStatus(result_status));
415                         ast_mutex_unlock(&pgsql_lock);
416                         return -1;
417                 }
418         }
419
420         numrows = atoi(PQcmdTuples(result));
421         ast_mutex_unlock(&pgsql_lock);
422
423         ast_log(LOG_DEBUG, "Postgresql RealTime: Updated %d rows on table: %s\n", numrows,
424                         table);
425
426         /* From http://dev.pgsql.com/doc/pgsql/en/pgsql-affected-rows.html
427          * An integer greater than zero indicates the number of rows affected
428          * Zero indicates that no records were updated
429          * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
430          */
431
432         if (numrows >= 0)
433                 return (int) numrows;
434
435         return -1;
436 }
437
438 static struct ast_config *config_pgsql(const char *database, const char *table,
439                                            const char *file, struct ast_config *cfg)
440 {
441         PGresult *result = NULL;
442         long num_rows;
443         struct ast_variable *new_v;
444         struct ast_category *cur_cat = NULL;
445         char sql[250] = "";
446         char last[80] = "";
447         int last_cat_metric = 0;
448
449         last[0] = '\0';
450
451         if (!file || !strcmp(file, RES_CONFIG_PGSQL_CONF)) {
452                 ast_log(LOG_WARNING, "Postgresql RealTime: Cannot configure myself.\n");
453                 return NULL;
454         }
455
456         snprintf(sql, sizeof(sql),
457                          "SELECT category, var_name, var_val, cat_metric FROM %s WHERE filename='%s' and commented=0 ORDER BY filename, cat_metric desc, var_metric asc, category, var_name, var_val, id",
458                          table, file);
459
460         ast_log(LOG_DEBUG, "Postgresql RealTime: Static SQL: %s\n", sql);
461
462         /* We now have our complete statement; Lets connect to the server and execute it. */
463         ast_mutex_lock(&pgsql_lock);
464         if (!pgsql_reconnect(database)) {
465                 ast_mutex_unlock(&pgsql_lock);
466                 return NULL;
467         }
468
469         if (!(result = PQexec(pgsqlConn, sql))) {
470                 ast_log(LOG_WARNING,
471                                 "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
472                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
473                 ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n",
474                                 PQerrorMessage(pgsqlConn));
475                 ast_mutex_unlock(&pgsql_lock);
476                 return NULL;
477         } else {
478                 ExecStatusType result_status = PQresultStatus(result);
479                 if (result_status != PGRES_COMMAND_OK
480                         && result_status != PGRES_TUPLES_OK
481                         && result_status != PGRES_NONFATAL_ERROR) {
482                         ast_log(LOG_WARNING,
483                                         "Postgresql RealTime: Failed to query database. Check debug for more info.\n");
484                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql);
485                         ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n",
486                                         PQresultErrorMessage(result), PQresStatus(result_status));
487                         ast_mutex_unlock(&pgsql_lock);
488                         return NULL;
489                 }
490         }
491
492         if ((num_rows = PQntuples(result)) > 0) {
493                 int numFields = PQnfields(result);
494                 int i = 0;
495                 int rowIndex = 0;
496                 char **fieldnames = NULL;
497
498                 ast_log(LOG_DEBUG, "Postgresql RealTime: Found %ld rows.\n", num_rows);
499
500                 if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) {
501                         ast_mutex_unlock(&pgsql_lock);
502                         PQclear(result);
503                         return NULL;
504                 }
505                 for (i = 0; i < numFields; i++)
506                         fieldnames[i] = PQfname(result, i);
507
508                 for (rowIndex = 0; rowIndex < num_rows; rowIndex++) {
509                         char *field_category = PQgetvalue(result, rowIndex, 0);
510                         char *field_var_name = PQgetvalue(result, rowIndex, 1);
511                         char *field_var_val = PQgetvalue(result, rowIndex, 2);
512                         char *field_cat_metric = PQgetvalue(result, rowIndex, 3);
513                         if (!strcmp(field_var_name, "#include")) {
514                                 if (!ast_config_internal_load(field_var_val, cfg)) {
515                                         PQclear(result);
516                                         ast_mutex_unlock(&pgsql_lock);
517                                         return NULL;
518                                 }
519                                 continue;
520                         }
521
522                         if (strcmp(last, field_category) || last_cat_metric != atoi(field_cat_metric)) {
523                                 cur_cat = ast_category_new(field_category);
524                                 if (!cur_cat)
525                                         break;
526                                 strcpy(last, field_category);
527                                 last_cat_metric = atoi(field_cat_metric);
528                                 ast_category_append(cfg, cur_cat);
529                         }
530                         new_v = ast_variable_new(field_var_name, field_var_val);
531                         ast_variable_append(cur_cat, new_v);
532                 }
533         } else {
534                 ast_log(LOG_WARNING,
535                                 "Postgresql RealTime: Could not find config '%s' in database.\n", file);
536         }
537
538         PQclear(result);
539         ast_mutex_unlock(&pgsql_lock);
540
541         return cfg;
542 }
543
544 static struct ast_config_engine pgsql_engine = {
545         .name = "pgsql",
546         .load_func = config_pgsql,
547         .realtime_func = realtime_pgsql,
548         .realtime_multi_func = realtime_multi_pgsql,
549         .update_func = update_pgsql
550 };
551
552 int load_module(void)
553 {
554         parse_config();
555
556         ast_mutex_lock(&pgsql_lock);
557
558         if (!pgsql_reconnect(NULL)) {
559                 ast_log(LOG_WARNING,
560                                 "Postgresql RealTime: Couldn't establish connection. Check debug.\n");
561                 ast_log(LOG_DEBUG, "Postgresql RealTime: Cannot Connect: %s\n",
562                                 PQerrorMessage(pgsqlConn));
563         }
564
565         ast_config_engine_register(&pgsql_engine);
566         if (option_verbose) {
567                 ast_verbose("Postgresql RealTime driver loaded.\n");
568         }
569         ast_cli_register(&cli_realtime_pgsql_status);
570
571         ast_mutex_unlock(&pgsql_lock);
572
573         return 0;
574 }
575
576 int unload_module(void)
577 {
578         /* Aquire control before doing anything to the module itself. */
579         ast_mutex_lock(&pgsql_lock);
580
581         if (pgsqlConn) {
582                 PQfinish(pgsqlConn);
583                 pgsqlConn = NULL;
584         };
585         ast_cli_unregister(&cli_realtime_pgsql_status);
586         ast_config_engine_deregister(&pgsql_engine);
587         if (option_verbose) {
588                 ast_verbose("Postgresql RealTime unloaded.\n");
589         }
590
591         STANDARD_HANGUP_LOCALUSERS;
592
593         /* Unlock so something else can destroy the lock. */
594         ast_mutex_unlock(&pgsql_lock);
595
596         return 0;
597 }
598
599 int reload(void)
600 {
601         /* Aquire control before doing anything to the module itself. */
602         ast_mutex_lock(&pgsql_lock);
603
604         if (pgsqlConn) {
605                 PQfinish(pgsqlConn);
606                 pgsqlConn = NULL;
607         };
608         parse_config();
609
610         if (!pgsql_reconnect(NULL)) {
611                 ast_log(LOG_WARNING,
612                                 "Postgresql RealTime: Couldn't establish connection. Check debug.\n");
613                 ast_log(LOG_DEBUG, "Postgresql RealTime: Cannot Connect: %s\n",
614                                 PQerrorMessage(pgsqlConn));
615         }
616
617         ast_verbose(VERBOSE_PREFIX_2 "Postgresql RealTime reloaded.\n");
618
619         /* Done reloading. Release lock so others can now use driver. */
620         ast_mutex_unlock(&pgsql_lock);
621
622         return 0;
623 }
624
625 int parse_config(void)
626 {
627         struct ast_config *config;
628         char *s;
629
630         config = ast_config_load(RES_CONFIG_PGSQL_CONF);
631
632         if (config) {
633                 if (!(s = ast_variable_retrieve(config, "general", "dbuser"))) {
634                         ast_log(LOG_WARNING,
635                                         "Postgresql RealTime: No database user found, using 'asterisk' as default.\n");
636                         strcpy(dbuser, "asterisk");
637                 } else {
638                         ast_copy_string(dbuser, s, sizeof(dbuser));
639                 }
640
641                 if (!(s = ast_variable_retrieve(config, "general", "dbpass"))) {
642                         ast_log(LOG_WARNING,
643                                         "Postgresql RealTime: No database password found, using 'asterisk' as default.\n");
644                         strcpy(dbpass, "asterisk");
645                 } else {
646                         ast_copy_string(dbpass, s, sizeof(dbpass));
647                 }
648
649                 if (!(s = ast_variable_retrieve(config, "general", "dbhost"))) {
650                         ast_log(LOG_WARNING,
651                                         "Postgresql RealTime: No database host found, using localhost via socket.\n");
652                         dbhost[0] = '\0';
653                 } else {
654                         ast_copy_string(dbhost, s, sizeof(dbhost));
655                 }
656
657                 if (!(s = ast_variable_retrieve(config, "general", "dbname"))) {
658                         ast_log(LOG_WARNING,
659                                         "Postgresql RealTime: No database name found, using 'asterisk' as default.\n");
660                         strcpy(dbname, "asterisk");
661                 } else {
662                         ast_copy_string(dbname, s, sizeof(dbname));
663                 }
664
665                 if (!(s = ast_variable_retrieve(config, "general", "dbport"))) {
666                         ast_log(LOG_WARNING,
667                                         "Postgresql RealTime: No database port found, using 5432 as default.\n");
668                         dbport = 5432;
669                 } else {
670                         dbport = atoi(s);
671                 }
672
673                 if (dbhost && !(s = ast_variable_retrieve(config, "general", "dbsock"))) {
674                         ast_log(LOG_WARNING,
675                                         "Postgresql RealTime: No database socket found, using '/tmp/pgsql.sock' as default.\n");
676                         strcpy(dbsock, "/tmp/pgsql.sock");
677                 } else {
678                         ast_copy_string(dbsock, s, sizeof(dbsock));
679                 }
680         }
681         ast_config_destroy(config);
682
683         if (dbhost) {
684                 ast_log(LOG_DEBUG, "Postgresql RealTime Host: %s\n", dbhost);
685                 ast_log(LOG_DEBUG, "Postgresql RealTime Port: %i\n", dbport);
686         } else {
687                 ast_log(LOG_DEBUG, "Postgresql RealTime Socket: %s\n", dbsock);
688         }
689         ast_log(LOG_DEBUG, "Postgresql RealTime User: %s\n", dbuser);
690         ast_log(LOG_DEBUG, "Postgresql RealTime Password: %s\n", dbpass);
691         ast_log(LOG_DEBUG, "Postgresql RealTime DBName: %s\n", dbname);
692
693         return 1;
694 }
695
696 const char *description(void)
697 {
698         return res_config_pgsql_desc;
699 }
700
701 int usecount(void)
702 {
703         /* Try and get a lock. If unsuccessful, than that means another thread is using the pgsql object. */
704         if (ast_mutex_trylock(&pgsql_lock)) {
705                 ast_log(LOG_DEBUG, "Postgresql RealTime: Module usage count is 1.\n");
706                 return 1;
707         }
708         ast_mutex_unlock(&pgsql_lock);
709         return 0;
710 }
711
712 const char *key()
713 {
714         return ASTERISK_GPL_KEY;
715 }
716
717 static int pgsql_reconnect(const char *database)
718 {
719         char my_database[50];
720
721         ast_copy_string(my_database, S_OR(database, dbname), sizeof(my_database));
722
723         /* mutex lock should have been locked before calling this function. */
724
725         if (pgsqlConn && PQstatus(pgsqlConn) != CONNECTION_OK) {
726                 PQfinish(pgsqlConn);
727                 pgsqlConn = NULL;
728         }
729
730         if ((!pgsqlConn) && (dbhost || dbsock) && dbuser && dbpass && my_database) {
731                 char *connInfo = NULL;
732                 unsigned int size = 100 + strlen(dbhost)
733                         + strlen(dbuser)
734                         + strlen(dbpass)
735                         + strlen(my_database);
736                 
737                 if (!(connInfo = ast_malloc(size)))
738                         return 0;
739                 
740                 sprintf(connInfo, "host=%s port=%d dbname=%s user=%s password=%s",
741                                         dbhost, dbport, my_database, dbuser, dbpass);
742                 ast_log(LOG_DEBUG, "%u connInfo=%s\n", size, connInfo);
743                 pgsqlConn = PQconnectdb(connInfo);
744                 ast_log(LOG_DEBUG, "%u connInfo=%s\n", size, connInfo);
745                 free(connInfo);
746                 connInfo = NULL;
747                 ast_log(LOG_DEBUG, "pgsqlConn=%p\n", pgsqlConn);
748                 if (pgsqlConn) {
749                         ast_log(LOG_DEBUG, "Postgresql RealTime: Successfully connected to database.\n");
750                         connect_time = time(NULL);
751                         return 1;
752                 } else {
753                         ast_log(LOG_ERROR,
754                                         "Postgresql RealTime: Failed to connect database server %s on %s. Check debug for more info.\n",
755                                         dbname, dbhost);
756                         ast_log(LOG_DEBUG, "Postgresql RealTime: Cannot Connect: %s\n",
757                                         PQresultErrorMessage(NULL));
758                         return 0;
759                 }
760         } else {
761                 ast_log(LOG_DEBUG, "Postgresql RealTime: Everything is fine.\n");
762                 return 1;
763         }
764 }
765
766 static int realtime_pgsql_status(int fd, int argc, char **argv)
767 {
768         char status[256], status2[100] = "";
769         int ctime = time(NULL) - connect_time;
770
771         if (pgsqlConn && PQstatus(pgsqlConn) == CONNECTION_OK) {
772                 if (dbhost) {
773                         snprintf(status, 255, "Connected to %s@%s, port %d", dbname, dbhost, dbport);
774                 } else if (dbsock) {
775                         snprintf(status, 255, "Connected to %s on socket file %s", dbname, dbsock);
776                 } else {
777                         snprintf(status, 255, "Connected to %s@%s", dbname, dbhost);
778                 }
779
780                 if (dbuser && *dbuser) {
781                         snprintf(status2, 99, " with username %s", dbuser);
782                 }
783
784                 if (ctime > 31536000) {
785                         ast_cli(fd, "%s%s for %d years, %d days, %d hours, %d minutes, %d seconds.\n",
786                                         status, status2, ctime / 31536000, (ctime % 31536000) / 86400,
787                                         (ctime % 86400) / 3600, (ctime % 3600) / 60, ctime % 60);
788                 } else if (ctime > 86400) {
789                         ast_cli(fd, "%s%s for %d days, %d hours, %d minutes, %d seconds.\n", status,
790                                         status2, ctime / 86400, (ctime % 86400) / 3600, (ctime % 3600) / 60,
791                                         ctime % 60);
792                 } else if (ctime > 3600) {
793                         ast_cli(fd, "%s%s for %d hours, %d minutes, %d seconds.\n", status, status2,
794                                         ctime / 3600, (ctime % 3600) / 60, ctime % 60);
795                 } else if (ctime > 60) {
796                         ast_cli(fd, "%s%s for %d minutes, %d seconds.\n", status, status2, ctime / 60,
797                                         ctime % 60);
798                 } else {
799                         ast_cli(fd, "%s%s for %d seconds.\n", status, status2, ctime);
800                 }
801
802                 return RESULT_SUCCESS;
803         } else {
804                 return RESULT_FAILURE;
805         }
806 }