Add option to hide console connect messages
[asterisk/asterisk.git] / utils / extconf.c
1 /*  
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006, Digium, Inc.
5  *
6  * Steve Murphy <murf@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19
20 /*
21  *
22  * A condensation of the pbx_config stuff, to read into exensions.conf, and provide an interface to the data there,
23  * for operations outside of asterisk. A huge, awful hack.
24  *
25  */
26 #include "asterisk.h"
27
28 #undef DEBUG_THREADS
29
30 #include "asterisk/compat.h"
31 #include "asterisk/paths.h"     /* we use AST_CONFIG_DIR */
32
33 #include <errno.h>
34 #include <time.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <sys/time.h>
38 #include <sys/resource.h>
39 #include <sys/wait.h>
40 #include <stdarg.h>
41 #include <string.h>
42 #include <locale.h>
43 #include <ctype.h>
44 #if !defined(SOLARIS) && !defined(__CYGWIN__)
45 #include <err.h>
46 #endif
47 #include <regex.h>
48 #include <limits.h>
49 #include <pthread.h>
50 #include <netdb.h>
51 #include <sys/param.h>
52
53 static void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__((format(printf, 5, 6)));
54 void ast_verbose(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
55
56 #define ASINCLUDE_GLOB 1
57 #ifdef AST_INCLUDE_GLOB
58
59 #if !defined(GLOB_ABORTED)
60 #define GLOB_ABORTED GLOB_ABEND
61 #endif
62
63 # include <glob.h>
64 #endif
65
66 #define AST_API_MODULE  1 /* gimme the inline defs! */
67 struct ast_channel 
68 {
69         char x; /* basically empty! */
70 };
71
72
73
74 #include "asterisk/inline_api.h"
75 #include "asterisk/endian.h"
76 #include "asterisk/ast_expr.h"
77
78 /* logger.h */
79
80 #define EVENTLOG "event_log"
81 #define QUEUELOG        "queue_log"
82
83 #define DEBUG_M(a) { \
84         a; \
85 }
86
87 #define VERBOSE_PREFIX_1 " "
88 #define VERBOSE_PREFIX_2 "  == "
89 #define VERBOSE_PREFIX_3 "    -- "
90 #define VERBOSE_PREFIX_4 "       > "
91
92 void ast_backtrace(void);
93
94 void ast_queue_log(const char *queuename, const char *callid, const char *agent, const char *event, const char *fmt, ...)
95         __attribute__((format(printf, 5, 6)));
96
97 /* IN CONFLICT: void ast_verbose(const char *fmt, ...)
98    __attribute__((format(printf, 1, 2))); */
99
100 int ast_register_verbose(void (*verboser)(const char *string));
101 int ast_unregister_verbose(void (*verboser)(const char *string));
102
103 void ast_console_puts(const char *string);
104
105 #define _A_ __FILE__, __LINE__, __PRETTY_FUNCTION__
106
107 #ifdef LOG_DEBUG
108 #undef LOG_DEBUG
109 #endif
110 #define __LOG_DEBUG    0
111 #define LOG_DEBUG      __LOG_DEBUG, _A_
112
113 #ifdef LOG_EVENT
114 #undef LOG_EVENT
115 #endif
116 #define __LOG_EVENT    1
117 #define LOG_EVENT      __LOG_EVENT, _A_
118
119 #ifdef LOG_NOTICE
120 #undef LOG_NOTICE
121 #endif
122 #define __LOG_NOTICE   2
123 #define LOG_NOTICE     __LOG_NOTICE, _A_
124
125 #ifdef LOG_WARNING
126 #undef LOG_WARNING
127 #endif
128 #define __LOG_WARNING  3
129 #define LOG_WARNING    __LOG_WARNING, _A_
130
131 #ifdef LOG_ERROR
132 #undef LOG_ERROR
133 #endif
134 #define __LOG_ERROR    4
135 #define LOG_ERROR      __LOG_ERROR, _A_
136
137 #ifdef LOG_VERBOSE
138 #undef LOG_VERBOSE
139 #endif
140 #define __LOG_VERBOSE  5
141 #define LOG_VERBOSE    __LOG_VERBOSE, _A_
142
143 #ifdef LOG_DTMF
144 #undef LOG_DTMF
145 #endif
146 #define __LOG_DTMF  6
147 #define LOG_DTMF    __LOG_DTMF, _A_
148
149 /* lock.h */
150
151 #ifndef HAVE_MTX_PROFILE
152 #define __MTX_PROF(a)   return pthread_mutex_lock((a))
153 #else
154 int mtx_prof = -1;
155
156 #define __MTX_PROF(a)   do {                    \
157         int i;                                  \
158         /* profile only non-blocking events */  \
159         ast_mark(mtx_prof, 1);                  \
160         i = pthread_mutex_trylock((a));         \
161         ast_mark(mtx_prof, 0);                  \
162         if (!i)                                 \
163                 return i;                       \
164         else                                    \
165                 return pthread_mutex_lock((a)); \
166         } while (0)
167 #endif  /* HAVE_MTX_PROFILE */
168
169 #define AST_PTHREADT_NULL (pthread_t) -1
170 #define AST_PTHREADT_STOP (pthread_t) -2
171
172 #if defined(SOLARIS) || defined(BSD)
173 #define AST_MUTEX_INIT_W_CONSTRUCTORS
174 #endif /* SOLARIS || BSD */
175
176 /* Asterisk REQUIRES recursive (not error checking) mutexes
177    and will not run without them. */
178 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) && defined(PTHREAD_MUTEX_RECURSIVE_NP)
179 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
180 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE_NP
181 #else
182 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_MUTEX_INITIALIZER
183 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE
184 #endif /* PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP */
185
186 #ifdef DEBUG_THREADS
187
188 #define __ast_mutex_logger(...)  do { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); } while (0)
189
190 #ifdef THREAD_CRASH
191 #define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
192 #else
193 #define DO_THREAD_CRASH do { } while (0)
194 #endif
195
196 #define AST_MUTEX_INIT_VALUE { PTHREAD_MUTEX_INIT_VALUE, { NULL }, { 0 }, 0, { NULL }, { 0 } }
197
198 #define AST_MAX_REENTRANCY 10
199
200 struct ast_mutex_info {
201         pthread_mutex_t mutex;
202         /*! Track which thread holds this lock */
203         unsigned int track:1;
204         const char *file[AST_MAX_REENTRANCY];
205         int lineno[AST_MAX_REENTRANCY];
206         int reentrancy;
207         const char *func[AST_MAX_REENTRANCY];
208         pthread_t thread[AST_MAX_REENTRANCY];
209 };
210
211 typedef struct ast_mutex_info ast_mutex_t;
212
213 typedef pthread_cond_t ast_cond_t;
214
215 static pthread_mutex_t empty_mutex;
216
217 static void __attribute__((constructor)) init_empty_mutex(void)
218 {
219         memset(&empty_mutex, 0, sizeof(empty_mutex));
220 }
221
222 static inline int __ast_pthread_mutex_init_attr(const char *filename, int lineno, const char *func,
223                                                 const char *mutex_name, ast_mutex_t *t,
224                                                 pthread_mutexattr_t *attr) 
225 {
226 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
227         int canlog = strcmp(filename, "logger.c");
228
229         if ((t->mutex) != ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
230                 if ((t->mutex) != (empty_mutex)) {
231                         __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is already initialized.\n",
232                                            filename, lineno, func, mutex_name);
233                         __ast_mutex_logger("%s line %d (%s): Error: previously initialization of mutex '%s'.\n",
234                                            t->file[0], t->lineno[0], t->func[0], mutex_name);
235                         DO_THREAD_CRASH;
236                         return 0;
237                 }
238         }
239 #endif
240
241         t->file[0] = filename;
242         t->lineno[0] = lineno;
243         t->func[0] = func;
244         t->thread[0]  = 0;
245         t->reentrancy = 0;
246
247         return pthread_mutex_init(&t->mutex, attr);
248 }
249
250 static inline int __ast_pthread_mutex_init(const char *filename, int lineno, const char *func,
251                                            const char *mutex_name, ast_mutex_t *t)
252 {
253         static pthread_mutexattr_t  attr;
254
255         pthread_mutexattr_init(&attr);
256         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
257
258         return __ast_pthread_mutex_init_attr(filename, lineno, func, mutex_name, t, &attr);
259 }
260 #define ast_mutex_init(pmutex) __ast_pthread_mutex_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
261
262 static inline int __ast_pthread_mutex_destroy(const char *filename, int lineno, const char *func,
263                                                 const char *mutex_name, ast_mutex_t *t)
264 {
265         int res;
266         int canlog = strcmp(filename, "logger.c");
267
268 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
269         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
270                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
271                                    filename, lineno, func, mutex_name);
272         }
273 #endif
274
275         res = pthread_mutex_trylock(&t->mutex);
276         switch (res) {
277         case 0:
278                 pthread_mutex_unlock(&t->mutex);
279                 break;
280         case EINVAL:
281                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
282                                   filename, lineno, func, mutex_name);
283                 break;
284         case EBUSY:
285                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
286                                    filename, lineno, func, mutex_name);
287                 __ast_mutex_logger("%s line %d (%s): Error: '%s' was locked here.\n",
288                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
289                 break;
290         }
291
292         if ((res = pthread_mutex_destroy(&t->mutex)))
293                 __ast_mutex_logger("%s line %d (%s): Error destroying mutex: %s\n",
294                                    filename, lineno, func, strerror(res));
295 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
296         else
297                 t->mutex = PTHREAD_MUTEX_INIT_VALUE;
298 #endif
299         t->file[0] = filename;
300         t->lineno[0] = lineno;
301         t->func[0] = func;
302
303         return res;
304 }
305
306 static inline int __ast_pthread_mutex_lock(const char *filename, int lineno, const char *func,
307                                            const char* mutex_name, ast_mutex_t *t)
308 {
309         int res;
310         int canlog = strcmp(filename, "logger.c");
311
312 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
313         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
314                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
315                                  filename, lineno, func, mutex_name);
316                 ast_mutex_init(t);
317         }
318 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
319
320 #ifdef DETECT_DEADLOCKS
321         {
322                 time_t seconds = time(NULL);
323                 time_t current;
324                 do {
325 #ifdef  HAVE_MTX_PROFILE
326                         ast_mark(mtx_prof, 1);
327 #endif
328                         res = pthread_mutex_trylock(&t->mutex);
329 #ifdef  HAVE_MTX_PROFILE
330                         ast_mark(mtx_prof, 0);
331 #endif
332                         if (res == EBUSY) {
333                                 current = time(NULL);
334                                 if ((current - seconds) && (!((current - seconds) % 5))) {
335                                         __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
336                                                            filename, lineno, func, (int)(current - seconds), mutex_name);
337                                         __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
338                                                            t->file[t->reentrancy-1], t->lineno[t->reentrancy-1],
339                                                            t->func[t->reentrancy-1], mutex_name);
340                                 }
341                                 usleep(200);
342                         }
343                 } while (res == EBUSY);
344         }
345 #else
346 #ifdef  HAVE_MTX_PROFILE
347         ast_mark(mtx_prof, 1);
348         res = pthread_mutex_trylock(&t->mutex);
349         ast_mark(mtx_prof, 0);
350         if (res)
351 #endif
352         res = pthread_mutex_lock(&t->mutex);
353 #endif /* DETECT_DEADLOCKS */
354
355         if (!res) {
356                 if (t->reentrancy < AST_MAX_REENTRANCY) {
357                         t->file[t->reentrancy] = filename;
358                         t->lineno[t->reentrancy] = lineno;
359                         t->func[t->reentrancy] = func;
360                         t->thread[t->reentrancy] = pthread_self();
361                         t->reentrancy++;
362                 } else {
363                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
364                                                            filename, lineno, func, mutex_name);
365                 }
366         } else {
367                 __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
368                                    filename, lineno, func, strerror(errno));
369                 DO_THREAD_CRASH;
370         }
371
372         return res;
373 }
374
375 static inline int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func,
376                                               const char* mutex_name, ast_mutex_t *t)
377 {
378         int res;
379         int canlog = strcmp(filename, "logger.c");
380
381 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
382         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
383                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
384                                    filename, lineno, func, mutex_name);
385                 ast_mutex_init(t);
386         }
387 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
388
389         if (!(res = pthread_mutex_trylock(&t->mutex))) {
390                 if (t->reentrancy < AST_MAX_REENTRANCY) {
391                         t->file[t->reentrancy] = filename;
392                         t->lineno[t->reentrancy] = lineno;
393                         t->func[t->reentrancy] = func;
394                         t->thread[t->reentrancy] = pthread_self();
395                         t->reentrancy++;
396                 } else {
397                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
398                                            filename, lineno, func, mutex_name);
399                 }
400         } else {
401                 __ast_mutex_logger("%s line %d (%s): Warning: '%s' was locked here.\n",
402                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
403         }
404
405         return res;
406 }
407
408 static inline int __ast_pthread_mutex_unlock(const char *filename, int lineno, const char *func,
409                                              const char *mutex_name, ast_mutex_t *t)
410 {
411         int res;
412         int canlog = strcmp(filename, "logger.c");
413
414 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
415         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
416                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
417                                    filename, lineno, func, mutex_name);
418         }
419 #endif
420
421         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
422                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
423                                    filename, lineno, func, mutex_name);
424                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
425                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
426                 DO_THREAD_CRASH;
427         }
428
429         if (--t->reentrancy < 0) {
430                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
431                                    filename, lineno, func, mutex_name);
432                 t->reentrancy = 0;
433         }
434
435         if (t->reentrancy < AST_MAX_REENTRANCY) {
436                 t->file[t->reentrancy] = NULL;
437                 t->lineno[t->reentrancy] = 0;
438                 t->func[t->reentrancy] = NULL;
439                 t->thread[t->reentrancy] = 0;
440         }
441
442         if ((res = pthread_mutex_unlock(&t->mutex))) {
443                 __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n", 
444                                    filename, lineno, func, strerror(res));
445                 DO_THREAD_CRASH;
446         }
447
448         return res;
449 }
450
451 static inline int __ast_cond_init(const char *filename, int lineno, const char *func,
452                                   const char *cond_name, ast_cond_t *cond, pthread_condattr_t *cond_attr)
453 {
454         return pthread_cond_init(cond, cond_attr);
455 }
456
457 static inline int __ast_cond_signal(const char *filename, int lineno, const char *func,
458                                     const char *cond_name, ast_cond_t *cond)
459 {
460         return pthread_cond_signal(cond);
461 }
462
463 static inline int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
464                                        const char *cond_name, ast_cond_t *cond)
465 {
466         return pthread_cond_broadcast(cond);
467 }
468
469 static inline int __ast_cond_destroy(const char *filename, int lineno, const char *func,
470                                      const char *cond_name, ast_cond_t *cond)
471 {
472         return pthread_cond_destroy(cond);
473 }
474
475 static inline int __ast_cond_wait(const char *filename, int lineno, const char *func,
476                                   const char *cond_name, const char *mutex_name,
477                                   ast_cond_t *cond, ast_mutex_t *t)
478 {
479         int res;
480         int canlog = strcmp(filename, "logger.c");
481
482 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
483         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
484                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
485                                    filename, lineno, func, mutex_name);
486         }
487 #endif
488
489         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
490                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
491                                    filename, lineno, func, mutex_name);
492                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
493                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
494                 DO_THREAD_CRASH;
495         }
496
497         if (--t->reentrancy < 0) {
498                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
499                                    filename, lineno, func, mutex_name);
500                 t->reentrancy = 0;
501         }
502
503         if (t->reentrancy < AST_MAX_REENTRANCY) {
504                 t->file[t->reentrancy] = NULL;
505                 t->lineno[t->reentrancy] = 0;
506                 t->func[t->reentrancy] = NULL;
507                 t->thread[t->reentrancy] = 0;
508         }
509
510         if ((res = pthread_cond_wait(cond, &t->mutex))) {
511                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
512                                    filename, lineno, func, strerror(res));
513                 DO_THREAD_CRASH;
514         } else {
515                 if (t->reentrancy < AST_MAX_REENTRANCY) {
516                         t->file[t->reentrancy] = filename;
517                         t->lineno[t->reentrancy] = lineno;
518                         t->func[t->reentrancy] = func;
519                         t->thread[t->reentrancy] = pthread_self();
520                         t->reentrancy++;
521                 } else {
522                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
523                                                            filename, lineno, func, mutex_name);
524                 }
525         }
526
527         return res;
528 }
529
530 static inline int __ast_cond_timedwait(const char *filename, int lineno, const char *func,
531                                        const char *cond_name, const char *mutex_name, ast_cond_t *cond,
532                                        ast_mutex_t *t, const struct timespec *abstime)
533 {
534         int res;
535         int canlog = strcmp(filename, "logger.c");
536
537 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
538         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
539                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
540                                    filename, lineno, func, mutex_name);
541         }
542 #endif
543
544         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
545                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
546                                    filename, lineno, func, mutex_name);
547                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
548                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
549                 DO_THREAD_CRASH;
550         }
551
552         if (--t->reentrancy < 0) {
553                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
554                                    filename, lineno, func, mutex_name);
555                 t->reentrancy = 0;
556         }
557
558         if (t->reentrancy < AST_MAX_REENTRANCY) {
559                 t->file[t->reentrancy] = NULL;
560                 t->lineno[t->reentrancy] = 0;
561                 t->func[t->reentrancy] = NULL;
562                 t->thread[t->reentrancy] = 0;
563         }
564
565         if ((res = pthread_cond_timedwait(cond, &t->mutex, abstime)) && (res != ETIMEDOUT)) {
566                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
567                                    filename, lineno, func, strerror(res));
568                 DO_THREAD_CRASH;
569         } else {
570                 if (t->reentrancy < AST_MAX_REENTRANCY) {
571                         t->file[t->reentrancy] = filename;
572                         t->lineno[t->reentrancy] = lineno;
573                         t->func[t->reentrancy] = func;
574                         t->thread[t->reentrancy] = pthread_self();
575                         t->reentrancy++;
576                 } else {
577                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
578                                                            filename, lineno, func, mutex_name);
579                 }
580         }
581
582         return res;
583 }
584
585 #define ast_mutex_destroy(a) __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
586 #define ast_mutex_lock(a) __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
587 #define ast_mutex_unlock(a) __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
588 #define ast_mutex_trylock(a) __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
589 #define ast_cond_init(cond, attr) __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
590 #define ast_cond_destroy(cond) __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
591 #define ast_cond_signal(cond) __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
592 #define ast_cond_broadcast(cond) __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
593 #define ast_cond_wait(cond, mutex) __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
594 #define ast_cond_timedwait(cond, mutex, time) __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
595
596 #else /* !DEBUG_THREADS */
597
598
599 typedef pthread_mutex_t ast_mutex_t;
600
601 #define AST_MUTEX_INIT_VALUE    ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
602
603 static inline int ast_mutex_init(ast_mutex_t *pmutex)
604 {
605         pthread_mutexattr_t attr;
606
607         pthread_mutexattr_init(&attr);
608         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
609
610         return pthread_mutex_init(pmutex, &attr);
611 }
612
613 #define ast_pthread_mutex_init(pmutex,a) pthread_mutex_init(pmutex,a)
614
615 static inline int ast_mutex_unlock(ast_mutex_t *pmutex)
616 {
617         return pthread_mutex_unlock(pmutex);
618 }
619
620 static inline int ast_mutex_destroy(ast_mutex_t *pmutex)
621 {
622         return pthread_mutex_destroy(pmutex);
623 }
624
625 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
626 {
627         __MTX_PROF(pmutex);
628 }
629
630 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
631 {
632         return pthread_mutex_trylock(pmutex);
633 }
634
635 typedef pthread_cond_t ast_cond_t;
636
637 static inline int ast_cond_init(ast_cond_t *cond, pthread_condattr_t *cond_attr)
638 {
639         return pthread_cond_init(cond, cond_attr);
640 }
641
642 static inline int ast_cond_signal(ast_cond_t *cond)
643 {
644         return pthread_cond_signal(cond);
645 }
646
647 static inline int ast_cond_broadcast(ast_cond_t *cond)
648 {
649         return pthread_cond_broadcast(cond);
650 }
651
652 static inline int ast_cond_destroy(ast_cond_t *cond)
653 {
654         return pthread_cond_destroy(cond);
655 }
656
657 static inline int ast_cond_wait(ast_cond_t *cond, ast_mutex_t *t)
658 {
659         return pthread_cond_wait(cond, t);
660 }
661
662 static inline int ast_cond_timedwait(ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
663 {
664         return pthread_cond_timedwait(cond, t, abstime);
665 }
666
667 #endif /* !DEBUG_THREADS */
668
669 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
670 /* If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
671  constructors/destructors to create/destroy mutexes.  */
672 #define __AST_MUTEX_DEFINE(scope, mutex) \
673         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
674 static void  __attribute__((constructor)) init_##mutex(void) \
675 { \
676         ast_mutex_init(&mutex); \
677 } \
678 static void  __attribute__((destructor)) fini_##mutex(void) \
679 { \
680         ast_mutex_destroy(&mutex); \
681 }
682 #else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
683 /* By default, use static initialization of mutexes. */ 
684 #define __AST_MUTEX_DEFINE(scope, mutex) \
685         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
686 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
687
688 #define pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t
689 #define pthread_mutex_lock use_ast_mutex_lock_instead_of_pthread_mutex_lock
690 #define pthread_mutex_unlock use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
691 #define pthread_mutex_trylock use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
692 #define pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init
693 #define pthread_mutex_destroy use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
694 #define pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t
695 #define pthread_cond_init use_ast_cond_init_instead_of_pthread_cond_init
696 #define pthread_cond_destroy use_ast_cond_destroy_instead_of_pthread_cond_destroy
697 #define pthread_cond_signal use_ast_cond_signal_instead_of_pthread_cond_signal
698 #define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
699 #define pthread_cond_wait use_ast_cond_wait_instead_of_pthread_cond_wait
700 #define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
701
702 #define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex)
703
704 #define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
705
706 #define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
707
708 #ifndef __linux__
709 #define pthread_create __use_ast_pthread_create_instead__
710 #endif
711
712 typedef pthread_rwlock_t ast_rwlock_t;
713
714 static inline int ast_rwlock_init(ast_rwlock_t *prwlock)
715 {
716         pthread_rwlockattr_t attr;
717
718         pthread_rwlockattr_init(&attr);
719
720 #ifdef HAVE_PTHREAD_RWLOCK_PREFER_WRITER_NP
721         pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);
722 #endif
723
724         return pthread_rwlock_init(prwlock, &attr);
725 }
726
727 static inline int ast_rwlock_destroy(ast_rwlock_t *prwlock)
728 {
729         return pthread_rwlock_destroy(prwlock);
730 }
731
732 static inline int ast_rwlock_unlock(ast_rwlock_t *prwlock)
733 {
734         return pthread_rwlock_unlock(prwlock);
735 }
736
737 static inline int ast_rwlock_rdlock(ast_rwlock_t *prwlock)
738 {
739         return pthread_rwlock_rdlock(prwlock);
740 }
741
742 static inline int ast_rwlock_tryrdlock(ast_rwlock_t *prwlock)
743 {
744         return pthread_rwlock_tryrdlock(prwlock);
745 }
746
747 static inline int ast_rwlock_wrlock(ast_rwlock_t *prwlock)
748 {
749         return pthread_rwlock_wrlock(prwlock);
750 }
751
752 static inline int ast_rwlock_trywrlock(ast_rwlock_t *prwlock)
753 {
754         return pthread_rwlock_trywrlock(prwlock);
755 }
756
757 /* Statically declared read/write locks */
758
759 #ifndef HAVE_PTHREAD_RWLOCK_INITIALIZER
760 #define __AST_RWLOCK_DEFINE(scope, rwlock) \
761         scope ast_rwlock_t rwlock; \
762 static void  __attribute__((constructor)) init_##rwlock(void) \
763 { \
764         ast_rwlock_init(&rwlock); \
765 } \
766 static void  __attribute__((destructor)) fini_##rwlock(void) \
767 { \
768         ast_rwlock_destroy(&rwlock); \
769 }
770 #else
771 #define AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER
772 #define __AST_RWLOCK_DEFINE(scope, rwlock) \
773         scope ast_rwlock_t rwlock = AST_RWLOCK_INIT_VALUE
774 #endif
775
776 #define AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock)
777
778 /*
779  * Initial support for atomic instructions.
780  * For platforms that have it, use the native cpu instruction to
781  * implement them. For other platforms, resort to a 'slow' version
782  * (defined in utils.c) that protects the atomic instruction with
783  * a single lock.
784  * The slow versions is always available, for testing purposes,
785  * as ast_atomic_fetchadd_int_slow()
786  */
787
788 #if defined(HAVE_OSX_ATOMICS)
789 #include "libkern/OSAtomic.h"
790 #endif
791
792 /*! \brief Atomically add v to *p and return * the previous value of *p.
793  * This can be used to handle reference counts, and the return value
794  * can be used to generate unique identifiers.
795  */
796
797 #if defined(HAVE_GCC_ATOMICS)
798 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
799 {
800         return __sync_fetch_and_add(p, v);
801 })
802 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
803 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
804 {
805         return OSAtomicAdd32(v, (int32_t *) p);
806 })
807 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
808 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
809 {
810         return OSAtomicAdd64(v, (int64_t *) p);
811 #elif defined (__i386__) || defined(__x86_64__)
812 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
813 {
814         __asm __volatile (
815         "       lock   xaddl   %0, %1 ;        "
816         : "+r" (v),                     /* 0 (result) */   
817           "=m" (*p)                     /* 1 */
818         : "m" (*p));                    /* 2 */
819         return (v);
820 })
821 #else
822 static int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
823 {
824         int ret;
825         ret = *p;
826         *p += v;
827         return ret;
828 }
829 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
830 {
831         return ast_atomic_fetchadd_int_slow(p, v);
832 })
833 #endif
834
835 /*! \brief decrement *p by 1 and return true if the variable has reached 0.
836  * Useful e.g. to check if a refcount has reached 0.
837  */
838 #if defined(HAVE_GCC_ATOMICS)
839 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
840 {
841         return __sync_sub_and_fetch(p, 1) == 0;
842 })
843 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
844 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
845 {
846         return OSAtomicAdd32( -1, (int32_t *) p) == 0;
847 })
848 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
849 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
850 {
851         return OSAtomicAdd64( -1, (int64_t *) p) == 0;
852 #else
853 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
854 {
855         int a = ast_atomic_fetchadd_int(p, -1);
856         return a == 1; /* true if the value is 0 now (so it was 1 previously) */
857 })
858 #endif
859
860 #ifndef DEBUG_CHANNEL_LOCKS
861 /*! \brief Lock a channel. If DEBUG_CHANNEL_LOCKS is defined 
862         in the Makefile, print relevant output for debugging */
863 #define ast_channel_lock(x)             ast_mutex_lock(&x->lock)
864 /*! \brief Unlock a channel. If DEBUG_CHANNEL_LOCKS is defined 
865         in the Makefile, print relevant output for debugging */
866 #define ast_channel_unlock(x)           ast_mutex_unlock(&x->lock)
867 /*! \brief Try locking a channel. If DEBUG_CHANNEL_LOCKS is defined 
868         in the Makefile, print relevant output for debugging */
869 #define ast_channel_trylock(x)          ast_mutex_trylock(&x->lock)
870 #else
871
872 /*! \brief Lock AST channel (and print debugging output)
873 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
874 int ast_channel_lock(struct ast_channel *chan);
875
876 /*! \brief Unlock AST channel (and print debugging output)
877 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
878 */
879 int ast_channel_unlock(struct ast_channel *chan);
880
881 /*! \brief Lock AST channel (and print debugging output)
882 \note   You need to enable DEBUG_CHANNEL_LOCKS for this function */
883 int ast_channel_trylock(struct ast_channel *chan);
884 #endif
885
886
887 #include "asterisk/hashtab.h"
888 #include "asterisk/ael_structs.h"
889 #include "asterisk/pval.h"
890
891 /* from utils.h */
892
893 #define ast_free free
894
895 #define MALLOC_FAILURE_MSG \
896         ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
897 #ifndef __AST_DEBUG_MALLOC
898
899 /*!
900  * \brief A wrapper for malloc()
901  *
902  * ast_malloc() is a wrapper for malloc() that will generate an Asterisk log
903  * message in the case that the allocation fails.
904  *
905  * The argument and return value are the same as malloc()
906  */
907 #define ast_malloc(len) \
908         _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
909
910 #define ast_calloc(num, len) \
911         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
912
913 #define ast_calloc_cache(num, len) \
914         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
915
916 #define ast_realloc(p, len) \
917         _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
918
919 #define ast_strdup(str) \
920         _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
921
922 #define ast_strndup(str, len) \
923         _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
924
925 #define ast_asprintf(ret, fmt, ...) \
926         _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
927
928 #define ast_vasprintf(ret, fmt, ap) \
929         _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
930
931 #else
932
933 /* If astmm is in use, let it handle these.  Otherwise, it will report that
934    all allocations are coming from this header file */
935
936 #undef __ast_calloc
937 #undef calloc
938 #undef ast_calloc
939
940 #define ast_malloc(a)           malloc(a)
941 #define ast_calloc(a,b)         calloc(a,b)
942 #define ast_realloc(a,b)        realloc(a,b)
943 #define ast_strdup(a)           strdup(a)
944 #define ast_strndup(a,b)        strndup(a,b)
945 #define ast_asprintf(a,b,...)   asprintf(a,b,__VA_ARGS__)
946 #define ast_vasprintf(a,b,c)    vasprintf(a,b,c)
947
948 void * attribute_malloc __ast_malloc(size_t len, const char *file, int lineno, const char *func)
949 {
950         void *p;
951
952         if (!(p = malloc(len)))
953                 MALLOC_FAILURE_MSG;
954
955         return p;
956 }
957
958 void * attribute_malloc __ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func)
959 {
960         void *p;
961
962         if (!(p = calloc(num, len)))
963                 MALLOC_FAILURE_MSG;
964
965         return p;
966 }
967
968 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func);
969
970 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func)
971 {
972         void *p;
973
974         if (!(p = calloc(num, len)))
975                 MALLOC_FAILURE_MSG;
976
977         return p;
978 }
979
980 void * attribute_malloc __ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func)
981 {
982         void *newp;
983
984         if (!(newp = realloc(p, len)))
985                 MALLOC_FAILURE_MSG;
986
987         return newp;
988 }
989
990 char * attribute_malloc __ast_strdup(const char *str, const char *file, int lineno, const char *func)
991 {
992         char *newstr = NULL;
993
994         if (str) {
995                 if (!(newstr = strdup(str)))
996                         MALLOC_FAILURE_MSG;
997         }
998
999         return newstr;
1000 }
1001
1002 char * attribute_malloc __ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func)
1003 {
1004         char *newstr = NULL;
1005
1006         if (str) {
1007                 if (!(newstr = strndup(str, len)))
1008                         MALLOC_FAILURE_MSG;
1009         }
1010
1011         return newstr;
1012 }
1013
1014 void __ast_free(void *ptr, const char *file, int lineno, const char *func)
1015 {
1016 #undef free
1017         free(ptr);
1018 }
1019
1020 #endif /* AST_DEBUG_MALLOC */
1021
1022
1023 static unsigned int __unsigned_int_flags_dummy;
1024
1025 struct ast_flags {  /* stolen from utils.h */
1026         unsigned int flags;
1027 };
1028 #define ast_test_flag(p,flag)           ({ \
1029                                         typeof ((p)->flags) __p = (p)->flags; \
1030                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
1031                                         (void) (&__p == &__x); \
1032                                         ((p)->flags & (flag)); \
1033                                         })
1034
1035 #define ast_set2_flag(p,value,flag)     do { \
1036                                         typeof ((p)->flags) __p = (p)->flags; \
1037                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
1038                                         (void) (&__p == &__x); \
1039                                         if (value) \
1040                                                 (p)->flags |= (flag); \
1041                                         else \
1042                                                 (p)->flags &= ~(flag); \
1043                                         } while (0)
1044
1045
1046
1047 #ifndef __AST_DEBUG_MALLOC
1048
1049 #define MALLOC_FAILURE_MSG \
1050         ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
1051 /*!
1052  * \brief A wrapper for malloc()
1053  *
1054  * ast_malloc() is a wrapper for malloc() that will generate an Asterisk log
1055  * message in the case that the allocation fails.
1056  *
1057  * The argument and return value are the same as malloc()
1058  */
1059 #define ast_malloc(len) \
1060         _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1061
1062 AST_INLINE_API(
1063 void * attribute_malloc _ast_malloc(size_t len, const char *file, int lineno, const char *func),
1064 {
1065         void *p;
1066
1067         if (!(p = malloc(len)))
1068                 MALLOC_FAILURE_MSG;
1069
1070         return p;
1071 }
1072 )
1073
1074 /*!
1075  * \brief A wrapper for calloc()
1076  *
1077  * ast_calloc() is a wrapper for calloc() that will generate an Asterisk log
1078  * message in the case that the allocation fails.
1079  *
1080  * The arguments and return value are the same as calloc()
1081  */
1082 #define ast_calloc(num, len) \
1083         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1084
1085 AST_INLINE_API(
1086 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func),
1087 {
1088         void *p;
1089
1090         if (!(p = calloc(num, len)))
1091                 MALLOC_FAILURE_MSG;
1092
1093         return p;
1094 }
1095 )
1096
1097 /*!
1098  * \brief A wrapper for calloc() for use in cache pools
1099  *
1100  * ast_calloc_cache() is a wrapper for calloc() that will generate an Asterisk log
1101  * message in the case that the allocation fails. When memory debugging is in use,
1102  * the memory allocated by this function will be marked as 'cache' so it can be
1103  * distinguished from normal memory allocations.
1104  *
1105  * The arguments and return value are the same as calloc()
1106  */
1107 #define ast_calloc_cache(num, len) \
1108         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1109
1110 /*!
1111  * \brief A wrapper for realloc()
1112  *
1113  * ast_realloc() is a wrapper for realloc() that will generate an Asterisk log
1114  * message in the case that the allocation fails.
1115  *
1116  * The arguments and return value are the same as realloc()
1117  */
1118 #define ast_realloc(p, len) \
1119         _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1120
1121 AST_INLINE_API(
1122 void * attribute_malloc _ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func),
1123 {
1124         void *newp;
1125
1126         if (!(newp = realloc(p, len)))
1127                 MALLOC_FAILURE_MSG;
1128
1129         return newp;
1130 }
1131 )
1132
1133 /*!
1134  * \brief A wrapper for strdup()
1135  *
1136  * ast_strdup() is a wrapper for strdup() that will generate an Asterisk log
1137  * message in the case that the allocation fails.
1138  *
1139  * ast_strdup(), unlike strdup(), can safely accept a NULL argument. If a NULL
1140  * argument is provided, ast_strdup will return NULL without generating any
1141  * kind of error log message.
1142  *
1143  * The argument and return value are the same as strdup()
1144  */
1145 #define ast_strdup(str) \
1146         _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1147
1148 AST_INLINE_API(
1149 char * attribute_malloc _ast_strdup(const char *str, const char *file, int lineno, const char *func),
1150 {
1151         char *newstr = NULL;
1152
1153         if (str) {
1154                 if (!(newstr = strdup(str)))
1155                         MALLOC_FAILURE_MSG;
1156         }
1157
1158         return newstr;
1159 }
1160 )
1161
1162 /*!
1163  * \brief A wrapper for strndup()
1164  *
1165  * ast_strndup() is a wrapper for strndup() that will generate an Asterisk log
1166  * message in the case that the allocation fails.
1167  *
1168  * ast_strndup(), unlike strndup(), can safely accept a NULL argument for the
1169  * string to duplicate. If a NULL argument is provided, ast_strdup will return  
1170  * NULL without generating any kind of error log message.
1171  *
1172  * The arguments and return value are the same as strndup()
1173  */
1174 #define ast_strndup(str, len) \
1175         _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1176
1177 AST_INLINE_API(
1178 char * attribute_malloc _ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func),
1179 {
1180         char *newstr = NULL;
1181
1182         if (str) {
1183                 if (!(newstr = strndup(str, len)))
1184                         MALLOC_FAILURE_MSG;
1185         }
1186
1187         return newstr;
1188 }
1189 )
1190
1191 /*!
1192  * \brief A wrapper for asprintf()
1193  *
1194  * ast_asprintf() is a wrapper for asprintf() that will generate an Asterisk log
1195  * message in the case that the allocation fails.
1196  *
1197  * The arguments and return value are the same as asprintf()
1198  */
1199 #define ast_asprintf(ret, fmt, ...) \
1200         _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
1201
1202 AST_INLINE_API(
1203 __attribute__((format(printf, 5, 6)))
1204 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...),
1205 {
1206         int res;
1207         va_list ap;
1208
1209         va_start(ap, fmt);
1210         if ((res = vasprintf(ret, fmt, ap)) == -1)
1211                 MALLOC_FAILURE_MSG;
1212         va_end(ap);
1213
1214         return res;
1215 }
1216 )
1217
1218 /*!
1219  * \brief A wrapper for vasprintf()
1220  *
1221  * ast_vasprintf() is a wrapper for vasprintf() that will generate an Asterisk log
1222  * message in the case that the allocation fails.
1223  *
1224  * The arguments and return value are the same as vasprintf()
1225  */
1226 #define ast_vasprintf(ret, fmt, ap) \
1227         _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
1228
1229 AST_INLINE_API(
1230 __attribute__((format(printf, 5, 0)))
1231 int _ast_vasprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, va_list ap),
1232 {
1233         int res;
1234
1235         if ((res = vasprintf(ret, fmt, ap)) == -1)
1236                 MALLOC_FAILURE_MSG;
1237
1238         return res;
1239 }
1240 )
1241
1242 #else
1243
1244 /* If astmm is in use, let it handle these.  Otherwise, it will report that
1245    all allocations are coming from this header file */
1246
1247 #define ast_malloc(a)           malloc(a)
1248 #define ast_calloc(a,b)         calloc(a,b)
1249 #define ast_realloc(a,b)        realloc(a,b)
1250 #define ast_strdup(a)           strdup(a)
1251 #define ast_strndup(a,b)        strndup(a,b)
1252 #define ast_vasprintf(a,b,c)    vasprintf(a,b,c)
1253
1254 #endif /* AST_DEBUG_MALLOC */
1255
1256 #if !defined(ast_strdupa) && defined(__GNUC__)
1257 /*!
1258   \brief duplicate a string in memory from the stack
1259   \param s The string to duplicate
1260
1261   This macro will duplicate the given string.  It returns a pointer to the stack
1262   allocatted memory for the new string.
1263 */
1264 #define ast_strdupa(s)                                                    \
1265         (__extension__                                                    \
1266         ({                                                                \
1267                 const char *__old = (s);                                  \
1268                 size_t __len = strlen(__old) + 1;                         \
1269                 char *__new = __builtin_alloca(__len);                    \
1270                 memcpy (__new, __old, __len);                             \
1271                 __new;                                                    \
1272         }))
1273 #endif
1274
1275
1276 /* from config.c */
1277
1278 #define MAX_NESTED_COMMENTS 128
1279 #define COMMENT_START ";--"
1280 #define COMMENT_END "--;"
1281 #define COMMENT_META ';'
1282 #define COMMENT_TAG '-'
1283
1284 static char *extconfig_conf = "extconfig.conf";
1285
1286 /*! Growable string buffer */
1287 static char *comment_buffer;   /*!< this will be a comment collector.*/
1288 static int   comment_buffer_size;  /*!< the amount of storage so far alloc'd for the comment_buffer */
1289
1290 static char *lline_buffer;    /*!< A buffer for stuff behind the ; */
1291 static int  lline_buffer_size;
1292
1293 #define CB_INCR 250
1294
1295 struct ast_comment {
1296         struct ast_comment *next;
1297         char cmt[0];
1298 };
1299
1300 static void CB_INIT(void)
1301 {
1302         if (!comment_buffer) {
1303                 comment_buffer = ast_malloc(CB_INCR);
1304                 if (!comment_buffer)
1305                         return;
1306                 comment_buffer[0] = 0;
1307                 comment_buffer_size = CB_INCR;
1308                 lline_buffer = ast_malloc(CB_INCR);
1309                 if (!lline_buffer)
1310                         return;
1311                 lline_buffer[0] = 0;
1312                 lline_buffer_size = CB_INCR;
1313         } else {
1314                 comment_buffer[0] = 0;
1315                 lline_buffer[0] = 0;
1316         }
1317 }
1318
1319 static void  CB_ADD(char *str)
1320 {
1321         int rem = comment_buffer_size - strlen(comment_buffer) - 1;
1322         int siz = strlen(str);
1323         if (rem < siz+1) {
1324                 comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + siz + 1);
1325                 if (!comment_buffer)
1326                         return;
1327                 comment_buffer_size += CB_INCR+siz+1;
1328         }
1329         strcat(comment_buffer,str);
1330 }
1331
1332 static void  CB_ADD_LEN(char *str, int len)
1333 {
1334         int cbl = strlen(comment_buffer) + 1;
1335         int rem = comment_buffer_size - cbl;
1336         if (rem < len+1) {
1337                 comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + len + 1);
1338                 if (!comment_buffer)
1339                         return;
1340                 comment_buffer_size += CB_INCR+len+1;
1341         }
1342         strncat(comment_buffer,str,len); /* safe */
1343         comment_buffer[cbl+len-1] = 0;
1344 }
1345
1346 static void  LLB_ADD(char *str)
1347 {
1348         int rem = lline_buffer_size - strlen(lline_buffer) - 1;
1349         int siz = strlen(str);
1350         if (rem < siz+1) {
1351                 lline_buffer = ast_realloc(lline_buffer, lline_buffer_size + CB_INCR + siz + 1);
1352                 if (!lline_buffer) 
1353                         return;
1354                 lline_buffer_size += CB_INCR + siz + 1;
1355         }
1356         strcat(lline_buffer,str);
1357 }
1358
1359 static void CB_RESET(void )  
1360
1361         comment_buffer[0] = 0; 
1362         lline_buffer[0] = 0;
1363 }
1364                 
1365 /*! \brief Keep track of how many threads are currently trying to wait*() on
1366  *  a child process */
1367 static unsigned int safe_system_level = 0;
1368 static void *safe_system_prev_handler;
1369
1370 /*! \brief NULL handler so we can collect the child exit status */
1371 static void null_sig_handler(int sig)
1372 {
1373
1374 }
1375
1376 void ast_replace_sigchld(void);
1377
1378 void ast_replace_sigchld(void)
1379 {
1380         unsigned int level;
1381
1382         level = safe_system_level++;
1383
1384         /* only replace the handler if it has not already been done */
1385         if (level == 0)
1386                 safe_system_prev_handler = signal(SIGCHLD, null_sig_handler);
1387
1388 }
1389
1390 void ast_unreplace_sigchld(void);
1391
1392 void ast_unreplace_sigchld(void)
1393 {
1394         unsigned int level;
1395
1396         level = --safe_system_level;
1397
1398         /* only restore the handler if we are the last one */
1399         if (level == 0)
1400                 signal(SIGCHLD, safe_system_prev_handler);
1401
1402 }
1403
1404 int ast_safe_system(const char *s);
1405
1406 int ast_safe_system(const char *s)
1407 {
1408         pid_t pid;
1409 #ifdef HAVE_WORKING_FORK
1410         int x;
1411 #endif
1412         int res;
1413         struct rusage rusage;
1414         int status;
1415
1416 #if defined(HAVE_WORKING_FORK) || defined(HAVE_WORKING_VFORK)
1417         ast_replace_sigchld();
1418
1419 #ifdef HAVE_WORKING_FORK
1420         pid = fork();
1421 #else
1422         pid = vfork();
1423 #endif  
1424
1425         if (pid == 0) {
1426 #ifdef HAVE_WORKING_FORK
1427                 /* Close file descriptors and launch system command */
1428                 for (x = STDERR_FILENO + 1; x < 4096; x++)
1429                         close(x);
1430 #endif
1431                 execl("/bin/sh", "/bin/sh", "-c", s, (char *) NULL);
1432                 _exit(1);
1433         } else if (pid > 0) {
1434                 for(;;) {
1435                         res = wait4(pid, &status, 0, &rusage);
1436                         if (res > -1) {
1437                                 res = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
1438                                 break;
1439                         } else if (errno != EINTR) 
1440                                 break;
1441                 }
1442         } else {
1443                 ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
1444                 res = -1;
1445         }
1446
1447         ast_unreplace_sigchld();
1448 #else
1449         res = -1;
1450 #endif
1451
1452         return res;
1453 }
1454
1455 static struct ast_comment *ALLOC_COMMENT(const char *buffer)
1456
1457         struct ast_comment *x = ast_calloc(1,sizeof(struct ast_comment)+strlen(buffer)+1);
1458         strcpy(x->cmt, buffer);
1459         return x;
1460 }
1461
1462 static struct ast_config_map {
1463         struct ast_config_map *next;
1464         char *name;
1465         char *driver;
1466         char *database;
1467         char *table;
1468         char stuff[0];
1469 } *config_maps = NULL;
1470
1471 static struct ast_config_engine *config_engine_list;
1472
1473 #define MAX_INCLUDE_LEVEL 10
1474
1475
1476 struct ast_category {
1477         char name[80];
1478         int ignored;                    /*!< do not let user of the config see this category */
1479         int include_level;      
1480     char *file;                /*!< the file name from whence this declaration was read */
1481     int lineno;
1482         struct ast_comment *precomments;
1483         struct ast_comment *sameline;
1484         struct ast_variable *root;
1485         struct ast_variable *last;
1486         struct ast_category *next;
1487 };
1488
1489 struct ast_config {
1490         struct ast_category *root;
1491         struct ast_category *last;
1492         struct ast_category *current;
1493         struct ast_category *last_browse;               /*!< used to cache the last category supplied via category_browse */
1494         int include_level;
1495         int max_include_level;
1496     struct ast_config_include *includes;  /*!< a list of inclusions, which should describe the entire tree */
1497 };
1498
1499 struct ast_config_include {
1500         char *include_location_file;     /*!< file name in which the include occurs */
1501         int  include_location_lineno;    /*!< lineno where include occurred */
1502         int  exec;                       /*!< set to non-zero if itsa #exec statement */
1503         char *exec_file;                 /*!< if it's an exec, you'll have both the /var/tmp to read, and the original script */
1504         char *included_file;             /*!< file name included */
1505         int inclusion_count;             /*!< if the file is included more than once, a running count thereof -- but, worry not,
1506                                                                            we explode the instances and will include those-- so all entries will be unique */
1507         int output;                      /*!< a flag to indicate if the inclusion has been output */
1508         struct ast_config_include *next; /*!< ptr to next inclusion in the list */
1509 };
1510
1511 typedef struct ast_config *config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, int withcomments, const char *suggested_include_file);
1512 typedef struct ast_variable *realtime_var_get(const char *database, const char *table, va_list ap);
1513 typedef struct ast_config *realtime_multi_get(const char *database, const char *table, va_list ap);
1514 typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap);
1515
1516 /*! \brief Configuration engine structure, used to define realtime drivers */
1517 struct ast_config_engine {
1518         char *name;
1519         config_load_func *load_func;
1520         realtime_var_get *realtime_func;
1521         realtime_multi_get *realtime_multi_func;
1522         realtime_update *update_func;
1523         struct ast_config_engine *next;
1524 };
1525
1526 static struct ast_config_engine *config_engine_list;
1527
1528 /* taken from strings.h */
1529
1530 static force_inline int ast_strlen_zero(const char *s)
1531 {
1532         return (!s || (*s == '\0'));
1533 }
1534
1535 #define S_OR(a, b)      (!ast_strlen_zero(a) ? (a) : (b))
1536
1537 AST_INLINE_API(
1538 void ast_copy_string(char *dst, const char *src, size_t size),
1539 {
1540         while (*src && size) {
1541                 *dst++ = *src++;
1542                 size--;
1543         }
1544         if (__builtin_expect(!size, 0))
1545                 dst--;
1546         *dst = '\0';
1547 }
1548 )
1549
1550 AST_INLINE_API(
1551 char *ast_skip_blanks(const char *str),
1552 {
1553         while (*str && *str < 33)
1554                 str++;
1555         return (char *)str;
1556 }
1557 )
1558
1559 /*!
1560   \brief Trims trailing whitespace characters from a string.
1561   \param ast_trim_blanks function being used
1562   \param str the input string
1563   \return a pointer to the modified string
1564  */
1565 AST_INLINE_API(
1566 char *ast_trim_blanks(char *str),
1567 {
1568         char *work = str;
1569
1570         if (work) {
1571                 work += strlen(work) - 1;
1572                 /* It's tempting to only want to erase after we exit this loop, 
1573                    but since ast_trim_blanks *could* receive a constant string
1574                    (which we presumably wouldn't have to touch), we shouldn't
1575                    actually set anything unless we must, and it's easier just
1576                    to set each position to \0 than to keep track of a variable
1577                    for it */
1578                 while ((work >= str) && *work < 33)
1579                         *(work--) = '\0';
1580         }
1581         return str;
1582 }
1583 )
1584
1585 /*!
1586   \brief Strip leading/trailing whitespace from a string.
1587   \param s The string to be stripped (will be modified).
1588   \return The stripped string.
1589
1590   This functions strips all leading and trailing whitespace
1591   characters from the input string, and returns a pointer to
1592   the resulting string. The string is modified in place.
1593 */
1594 AST_INLINE_API(
1595 char *ast_strip(char *s),
1596 {
1597         s = ast_skip_blanks(s);
1598         if (s)
1599                 ast_trim_blanks(s);
1600         return s;
1601
1602 )
1603
1604
1605 /* from config.h */
1606
1607 struct ast_variable {
1608         char *name;
1609         char *value;
1610         char *file;
1611         int lineno;
1612         int object;             /*!< 0 for variable, 1 for object */
1613         int blanklines;         /*!< Number of blanklines following entry */
1614         struct ast_comment *precomments;
1615         struct ast_comment *sameline;
1616         struct ast_variable *next;
1617         char stuff[0];
1618 };
1619
1620 static const char *ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable);
1621 static struct ast_config *config_text_file_load(const char *database, const char *table, const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_include_file);
1622
1623 struct ast_config *localized_config_load_with_comments(const char *filename);
1624 static char *ast_category_browse(struct ast_config *config, const char *prev);
1625 static struct ast_variable *ast_variable_browse(const struct ast_config *config, const char *category);
1626 static void ast_variables_destroy(struct ast_variable *v);
1627 static void ast_config_destroy(struct ast_config *cfg);
1628 static struct ast_config_include *ast_include_new(struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size);
1629 static struct ast_config_include *ast_include_find(struct ast_config *conf, const char *included_file);
1630 void localized_ast_include_rename(struct ast_config *conf, const char *from_file, const char *to_file);
1631
1632 static struct ast_variable *ast_variable_new(const char *name, const char *value, const char *filename);
1633
1634 static struct ast_variable *ast_variable_new(const char *name, const char *value, const char *filename) 
1635 {
1636         struct ast_variable *variable;
1637         int name_len = strlen(name) + 1;        
1638
1639         if ((variable = ast_calloc(1, name_len + strlen(value) + 1 + strlen(filename) + 1 + sizeof(*variable)))) {
1640                 variable->name = variable->stuff;
1641                 variable->value = variable->stuff + name_len;           
1642                 variable->file = variable->value + strlen(value) + 1;           
1643                 strcpy(variable->name,name);
1644                 strcpy(variable->value,value);
1645                 strcpy(variable->file,filename);
1646         }
1647
1648         return variable;
1649 }
1650
1651 static struct ast_config_include *ast_include_new(struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size)
1652 {
1653         /* a file should be included ONCE. Otherwise, if one of the instances is changed,
1654        then all be changed. -- how do we know to include it? -- Handling modified 
1655        instances is possible, I'd have
1656        to create a new master for each instance. */
1657         struct ast_config_include *inc;
1658     
1659         inc = ast_include_find(conf, included_file);
1660         if (inc)
1661         {
1662                 inc->inclusion_count++;
1663                 snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
1664                 ast_log(LOG_WARNING,"'%s', line %d:  Same File included more than once! This data will be saved in %s if saved back to disk.\n", from_file, from_lineno, real_included_file_name);
1665         } else
1666                 *real_included_file_name = 0;
1667         
1668         inc = ast_calloc(1,sizeof(struct ast_config_include));
1669         inc->include_location_file = ast_strdup(from_file);
1670         inc->include_location_lineno = from_lineno;
1671         if (!ast_strlen_zero(real_included_file_name))
1672                 inc->included_file = ast_strdup(real_included_file_name);
1673         else
1674                 inc->included_file = ast_strdup(included_file);
1675         
1676         inc->exec = is_exec;
1677         if (is_exec)
1678                 inc->exec_file = ast_strdup(exec_file);
1679         
1680         /* attach this new struct to the conf struct */
1681         inc->next = conf->includes;
1682         conf->includes = inc;
1683     
1684         return inc;
1685 }
1686
1687 void localized_ast_include_rename(struct ast_config *conf, const char *from_file, const char *to_file)
1688 {
1689         struct ast_config_include *incl;
1690         struct ast_category *cat;
1691         struct ast_variable *v;
1692     
1693         int from_len = strlen(from_file);
1694         int to_len = strlen(to_file);
1695     
1696         if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */
1697                 return;
1698         
1699         /* the manager code allows you to read in one config file, then
1700        write it back out under a different name. But, the new arrangement
1701            ties output lines to the file name. So, before you try to write
1702        the config file to disk, better riffle thru the data and make sure
1703        the file names are changed.
1704         */
1705         /* file names are on categories, includes (of course), and on variables. So,
1706            traverse all this and swap names */
1707         
1708         for (incl = conf->includes; incl; incl=incl->next) {
1709                 if (strcmp(incl->include_location_file,from_file) == 0) {
1710                         if (from_len >= to_len)
1711                                 strcpy(incl->include_location_file, to_file);
1712                         else {
1713                                 free(incl->include_location_file);
1714                                 incl->include_location_file = strdup(to_file);
1715                         }
1716                 }
1717         }
1718         for (cat = conf->root; cat; cat = cat->next) {
1719                 if (strcmp(cat->file,from_file) == 0) {
1720                         if (from_len >= to_len)
1721                                 strcpy(cat->file, to_file);
1722                         else {
1723                                 free(cat->file);
1724                                 cat->file = strdup(to_file);
1725                         }
1726                 }
1727                 for (v = cat->root; v; v = v->next) {
1728                         if (strcmp(v->file,from_file) == 0) {
1729                                 if (from_len >= to_len)
1730                                         strcpy(v->file, to_file);
1731                                 else {
1732                                         free(v->file);
1733                                         v->file = strdup(to_file);
1734                                 }
1735                         }
1736                 }
1737         }
1738 }
1739
1740 static struct ast_config_include *ast_include_find(struct ast_config *conf, const char *included_file)
1741 {
1742         struct ast_config_include *x;
1743         for (x=conf->includes;x;x=x->next)
1744         {
1745                 if (strcmp(x->included_file,included_file) == 0)
1746                         return x;
1747         }
1748         return 0;
1749 }
1750
1751
1752 static void ast_variable_append(struct ast_category *category, struct ast_variable *variable);
1753
1754 static void ast_variable_append(struct ast_category *category, struct ast_variable *variable)
1755 {
1756         if (!variable)
1757                 return;
1758         if (category->last)
1759                 category->last->next = variable;
1760         else
1761                 category->root = variable;
1762         category->last = variable;
1763         while (category->last->next)
1764                 category->last = category->last->next;
1765 }
1766
1767 static struct ast_category *category_get(const struct ast_config *config, const char *category_name, int ignored);
1768
1769 static struct ast_category *category_get(const struct ast_config *config, const char *category_name, int ignored)
1770 {
1771         struct ast_category *cat;
1772
1773         /* try exact match first, then case-insensitive match */
1774         for (cat = config->root; cat; cat = cat->next) {
1775                 if (cat->name == category_name && (ignored || !cat->ignored))
1776                         return cat;
1777         }
1778
1779         for (cat = config->root; cat; cat = cat->next) {
1780                 if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored))
1781                         return cat;
1782         }
1783
1784         return NULL;
1785 }
1786
1787 static struct ast_category *ast_category_get(const struct ast_config *config, const char *category_name)
1788 {
1789         return category_get(config, category_name, 0);
1790 }
1791
1792 static struct ast_variable *ast_variable_browse(const struct ast_config *config, const char *category)
1793 {
1794         struct ast_category *cat = NULL;
1795
1796         if (category && config->last_browse && (config->last_browse->name == category))
1797                 cat = config->last_browse;
1798         else
1799                 cat = ast_category_get(config, category);
1800
1801         return (cat) ? cat->root : NULL;
1802 }
1803
1804 static const char *ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable)
1805 {
1806         struct ast_variable *v;
1807
1808         if (category) {
1809                 for (v = ast_variable_browse(config, category); v; v = v->next) {
1810                         if (!strcasecmp(variable, v->name))
1811                                 return v->value;
1812                 }
1813         } else {
1814                 struct ast_category *cat;
1815
1816                 for (cat = config->root; cat; cat = cat->next)
1817                         for (v = cat->root; v; v = v->next)
1818                                 if (!strcasecmp(variable, v->name))
1819                                         return v->value;
1820         }
1821
1822         return NULL;
1823 }
1824
1825 static struct ast_variable *variable_clone(const struct ast_variable *old)
1826 {
1827         struct ast_variable *new = ast_variable_new(old->name, old->value, old->file);
1828
1829         if (new) {
1830                 new->lineno = old->lineno;
1831                 new->object = old->object;
1832                 new->blanklines = old->blanklines;
1833                 /* TODO: clone comments? */
1834         }
1835
1836         return new;
1837 }
1838  
1839 static void ast_variables_destroy(struct ast_variable *v)
1840 {
1841         struct ast_variable *vn;
1842
1843         while (v) {
1844                 vn = v;
1845                 v = v->next;
1846                 free(vn);
1847         }
1848 }
1849
1850 static void ast_includes_destroy(struct ast_config_include *incls)
1851 {
1852         struct ast_config_include *incl,*inclnext;
1853     
1854         for (incl=incls; incl; incl = inclnext) {
1855                 inclnext = incl->next;
1856                 if (incl->include_location_file)
1857                         free(incl->include_location_file);
1858                 if (incl->exec_file)
1859                         free(incl->exec_file);
1860                 if (incl->included_file)
1861                         free(incl->included_file);
1862                 free(incl);
1863         }
1864 }
1865
1866 static void ast_config_destroy(struct ast_config *cfg)
1867 {
1868         struct ast_category *cat, *catn;
1869
1870         if (!cfg)
1871                 return;
1872
1873         ast_includes_destroy(cfg->includes);
1874         
1875         cat = cfg->root;
1876         while (cat) {
1877                 ast_variables_destroy(cat->root);
1878                 catn = cat;
1879                 cat = cat->next;
1880                 free(catn);
1881         }
1882         free(cfg);
1883 }
1884
1885 enum ast_option_flags {
1886         /*! Allow \#exec in config files */
1887         AST_OPT_FLAG_EXEC_INCLUDES = (1 << 0),
1888         /*! Do not fork() */
1889         AST_OPT_FLAG_NO_FORK = (1 << 1),
1890         /*! Keep quiet */
1891         AST_OPT_FLAG_QUIET = (1 << 2),
1892         /*! Console mode */
1893         AST_OPT_FLAG_CONSOLE = (1 << 3),
1894         /*! Run in realtime Linux priority */
1895         AST_OPT_FLAG_HIGH_PRIORITY = (1 << 4),
1896         /*! Initialize keys for RSA authentication */
1897         AST_OPT_FLAG_INIT_KEYS = (1 << 5),
1898         /*! Remote console */
1899         AST_OPT_FLAG_REMOTE = (1 << 6),
1900         /*! Execute an asterisk CLI command upon startup */
1901         AST_OPT_FLAG_EXEC = (1 << 7),
1902         /*! Don't use termcap colors */
1903         AST_OPT_FLAG_NO_COLOR = (1 << 8),
1904         /*! Are we fully started yet? */
1905         AST_OPT_FLAG_FULLY_BOOTED = (1 << 9),
1906         /*! Trascode via signed linear */
1907         AST_OPT_FLAG_TRANSCODE_VIA_SLIN = (1 << 10),
1908         /*! Dump core on a seg fault */
1909         AST_OPT_FLAG_DUMP_CORE = (1 << 12),
1910         /*! Cache sound files */
1911         AST_OPT_FLAG_CACHE_RECORD_FILES = (1 << 13),
1912         /*! Display timestamp in CLI verbose output */
1913         AST_OPT_FLAG_TIMESTAMP = (1 << 14),
1914         /*! Override config */
1915         AST_OPT_FLAG_OVERRIDE_CONFIG = (1 << 15),
1916         /*! Reconnect */
1917         AST_OPT_FLAG_RECONNECT = (1 << 16),
1918         /*! Transmit Silence during Record() and DTMF Generation */
1919         AST_OPT_FLAG_TRANSMIT_SILENCE = (1 << 17),
1920         /*! Suppress some warnings */
1921         AST_OPT_FLAG_DONT_WARN = (1 << 18),
1922         /*! End CDRs before the 'h' extension */
1923         AST_OPT_FLAG_END_CDR_BEFORE_H_EXTEN = (1 << 19),
1924         /*! Use DAHDI Timing for generators if available */
1925         AST_OPT_FLAG_INTERNAL_TIMING = (1 << 20),
1926         /*! Always fork, even if verbose or debug settings are non-zero */
1927         AST_OPT_FLAG_ALWAYS_FORK = (1 << 21),
1928         /*! Disable log/verbose output to remote consoles */
1929         AST_OPT_FLAG_MUTE = (1 << 22),
1930         /*! There is a per-file debug setting */
1931         AST_OPT_FLAG_DEBUG_FILE = (1 << 23),
1932         /*! There is a per-file verbose setting */
1933         AST_OPT_FLAG_VERBOSE_FILE = (1 << 24),
1934         /*! Terminal colors should be adjusted for a light-colored background */
1935         AST_OPT_FLAG_LIGHT_BACKGROUND = (1 << 25),
1936         /*! Count Initiated seconds in CDR's */
1937         AST_OPT_FLAG_INITIATED_SECONDS = (1 << 26),
1938         /*! Force black background */
1939         AST_OPT_FLAG_FORCE_BLACK_BACKGROUND = (1 << 27),
1940 };
1941
1942 /* options.h declares ast_options extern; I need it static? */
1943 #define AST_CACHE_DIR_LEN       512
1944 #define AST_FILENAME_MAX        80
1945
1946 /*! These are the options that set by default when Asterisk starts */
1947 #define AST_DEFAULT_OPTIONS AST_OPT_FLAG_TRANSCODE_VIA_SLIN
1948
1949 struct ast_flags ast_options = { AST_DEFAULT_OPTIONS };
1950
1951 #define ast_opt_exec_includes           ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)
1952 #define ast_opt_no_fork                 ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)
1953 #define ast_opt_quiet                   ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)
1954 #define ast_opt_console                 ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)
1955 #define ast_opt_high_priority           ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)
1956 #define ast_opt_init_keys               ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)
1957 #define ast_opt_remote                  ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)
1958 #define ast_opt_exec                    ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)
1959 #define ast_opt_no_color                ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)
1960 #define ast_fully_booted                ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)
1961 #define ast_opt_transcode_via_slin      ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)
1962 #define ast_opt_priority_jumping        ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)
1963 #define ast_opt_dump_core               ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)
1964 #define ast_opt_cache_record_files      ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)
1965 #define ast_opt_timestamp               ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)
1966 #define ast_opt_override_config         ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)
1967 #define ast_opt_reconnect               ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)
1968 #define ast_opt_transmit_silence        ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)
1969 #define ast_opt_dont_warn               ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)
1970 #define ast_opt_end_cdr_before_h_exten  ast_test_flag(&ast_options, AST_OPT_FLAG_END_CDR_BEFORE_H_EXTEN)
1971 #define ast_opt_internal_timing         ast_test_flag(&ast_options, AST_OPT_FLAG_INTERNAL_TIMING)
1972 #define ast_opt_always_fork             ast_test_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)
1973 #define ast_opt_mute                    ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)
1974
1975 extern int option_verbose;
1976 extern int option_debug;                /*!< Debugging */
1977 extern int option_maxcalls;             /*!< Maximum number of simultaneous channels */
1978 extern double option_maxload;
1979 extern char defaultlanguage[];
1980
1981 extern pid_t ast_mainpid;
1982
1983 extern char record_cache_dir[AST_CACHE_DIR_LEN];
1984 extern char debug_filename[AST_FILENAME_MAX];
1985
1986 extern int ast_language_is_prefix;
1987
1988
1989
1990 /* linkedlists.h */
1991
1992 #define AST_LIST_LOCK(head)                                             \
1993         ast_mutex_lock(&(head)->lock) 
1994
1995 /*!
1996   \brief Write locks a list.
1997   \param head This is a pointer to the list head structure
1998
1999   This macro attempts to place an exclusive write lock in the
2000   list head structure pointed to by head.
2001   Returns non-zero on success, 0 on failure
2002 */
2003 #define AST_RWLIST_WRLOCK(head)                                         \
2004         ast_rwlock_wrlock(&(head)->lock)
2005
2006 /*!
2007   \brief Read locks a list.
2008   \param head This is a pointer to the list head structure
2009
2010   This macro attempts to place a read lock in the
2011   list head structure pointed to by head.
2012   Returns non-zero on success, 0 on failure
2013 */
2014 #define AST_RWLIST_RDLOCK(head)                                         \
2015         ast_rwlock_rdlock(&(head)->lock)
2016         
2017 /*!
2018   \brief Locks a list, without blocking if the list is locked.
2019   \param head This is a pointer to the list head structure
2020
2021   This macro attempts to place an exclusive lock in the
2022   list head structure pointed to by head.
2023   Returns non-zero on success, 0 on failure
2024 */
2025 #define AST_LIST_TRYLOCK(head)                                          \
2026         ast_mutex_trylock(&(head)->lock) 
2027
2028 /*!
2029   \brief Write locks a list, without blocking if the list is locked.
2030   \param head This is a pointer to the list head structure
2031
2032   This macro attempts to place an exclusive write lock in the
2033   list head structure pointed to by head.
2034   Returns non-zero on success, 0 on failure
2035 */
2036 #define AST_RWLIST_TRYWRLOCK(head)                                      \
2037         ast_rwlock_trywrlock(&(head)->lock)
2038
2039 /*!
2040   \brief Read locks a list, without blocking if the list is locked.
2041   \param head This is a pointer to the list head structure
2042
2043   This macro attempts to place a read lock in the
2044   list head structure pointed to by head.
2045   Returns non-zero on success, 0 on failure
2046 */
2047 #define AST_RWLIST_TRYRDLOCK(head)                                      \
2048         ast_rwlock_tryrdlock(&(head)->lock)
2049         
2050 /*!
2051   \brief Attempts to unlock a list.
2052   \param head This is a pointer to the list head structure
2053
2054   This macro attempts to remove an exclusive lock from the
2055   list head structure pointed to by head. If the list
2056   was not locked by this thread, this macro has no effect.
2057 */
2058 #define AST_LIST_UNLOCK(head)                                           \
2059         ast_mutex_unlock(&(head)->lock)
2060
2061 /*!
2062   \brief Attempts to unlock a read/write based list.
2063   \param head This is a pointer to the list head structure
2064
2065   This macro attempts to remove a read or write lock from the
2066   list head structure pointed to by head. If the list
2067   was not locked by this thread, this macro has no effect.
2068 */
2069 #define AST_RWLIST_UNLOCK(head)                                         \
2070         ast_rwlock_unlock(&(head)->lock)
2071
2072 /*!
2073   \brief Defines a structure to be used to hold a list of specified type.
2074   \param name This will be the name of the defined structure.
2075   \param type This is the type of each list entry.
2076
2077   This macro creates a structure definition that can be used
2078   to hold a list of the entries of type \a type. It does not actually
2079   declare (allocate) a structure; to do that, either follow this
2080   macro with the desired name of the instance you wish to declare,
2081   or use the specified \a name to declare instances elsewhere.
2082
2083   Example usage:
2084   \code
2085   static AST_LIST_HEAD(entry_list, entry) entries;
2086   \endcode
2087
2088   This would define \c struct \c entry_list, and declare an instance of it named
2089   \a entries, all intended to hold a list of type \c struct \c entry.
2090 */
2091 #define AST_LIST_HEAD(name, type)                                       \
2092 struct name {                                                           \
2093         struct type *first;                                             \
2094         struct type *last;                                              \
2095         ast_mutex_t lock;                                               \
2096 }
2097
2098 /*!
2099   \brief Defines a structure to be used to hold a read/write list of specified type.
2100   \param name This will be the name of the defined structure.
2101   \param type This is the type of each list entry.
2102
2103   This macro creates a structure definition that can be used
2104   to hold a list of the entries of type \a type. It does not actually
2105   declare (allocate) a structure; to do that, either follow this
2106   macro with the desired name of the instance you wish to declare,
2107   or use the specified \a name to declare instances elsewhere.
2108
2109   Example usage:
2110   \code
2111   static AST_RWLIST_HEAD(entry_list, entry) entries;
2112   \endcode
2113
2114   This would define \c struct \c entry_list, and declare an instance of it named
2115   \a entries, all intended to hold a list of type \c struct \c entry.
2116 */
2117 #define AST_RWLIST_HEAD(name, type)                                     \
2118 struct name {                                                           \
2119         struct type *first;                                             \
2120         struct type *last;                                              \
2121         ast_rwlock_t lock;                                              \
2122 }
2123
2124 /*!
2125   \brief Defines a structure to be used to hold a list of specified type (with no lock).
2126   \param name This will be the name of the defined structure.
2127   \param type This is the type of each list entry.
2128
2129   This macro creates a structure definition that can be used
2130   to hold a list of the entries of type \a type. It does not actually
2131   declare (allocate) a structure; to do that, either follow this
2132   macro with the desired name of the instance you wish to declare,
2133   or use the specified \a name to declare instances elsewhere.
2134
2135   Example usage:
2136   \code
2137   static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;
2138   \endcode
2139
2140   This would define \c struct \c entry_list, and declare an instance of it named
2141   \a entries, all intended to hold a list of type \c struct \c entry.
2142 */
2143 #define AST_LIST_HEAD_NOLOCK(name, type)                                \
2144 struct name {                                                           \
2145         struct type *first;                                             \
2146         struct type *last;                                              \
2147 }
2148
2149 /*!
2150   \brief Defines initial values for a declaration of AST_LIST_HEAD
2151 */
2152 #define AST_LIST_HEAD_INIT_VALUE        {               \
2153         .first = NULL,                                  \
2154         .last = NULL,                                   \
2155         .lock = AST_MUTEX_INIT_VALUE,                   \
2156         }
2157
2158 /*!
2159   \brief Defines initial values for a declaration of AST_RWLIST_HEAD
2160 */
2161 #define AST_RWLIST_HEAD_INIT_VALUE      {               \
2162         .first = NULL,                                  \
2163         .last = NULL,                                   \
2164         .lock = AST_RWLOCK_INIT_VALUE,                  \
2165         }
2166
2167 /*!
2168   \brief Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK
2169 */
2170 #define AST_LIST_HEAD_NOLOCK_INIT_VALUE {       \
2171         .first = NULL,                                  \
2172         .last = NULL,                                   \
2173         }
2174
2175 /*!
2176   \brief Defines a structure to be used to hold a list of specified type, statically initialized.
2177   \param name This will be the name of the defined structure.
2178   \param type This is the type of each list entry.
2179
2180   This macro creates a structure definition that can be used
2181   to hold a list of the entries of type \a type, and allocates an instance
2182   of it, initialized to be empty.
2183
2184   Example usage:
2185   \code
2186   static AST_LIST_HEAD_STATIC(entry_list, entry);
2187   \endcode
2188
2189   This would define \c struct \c entry_list, intended to hold a list of
2190   type \c struct \c entry.
2191 */
2192 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
2193 #define AST_LIST_HEAD_STATIC(name, type)                                \
2194 struct name {                                                           \
2195         struct type *first;                                             \
2196         struct type *last;                                              \
2197         ast_mutex_t lock;                                               \
2198 } name;                                                                 \
2199 static void  __attribute__((constructor)) init_##name(void)             \
2200 {                                                                       \
2201         AST_LIST_HEAD_INIT(&name);                                      \
2202 }                                                                       \
2203 static void  __attribute__((destructor)) fini_##name(void)              \
2204 {                                                                       \
2205         AST_LIST_HEAD_DESTROY(&name);                                   \
2206 }                                                                       \
2207 struct __dummy_##name
2208 #else
2209 #define AST_LIST_HEAD_STATIC(name, type)                                \
2210 struct name {                                                           \
2211         struct type *first;                                             \
2212         struct type *last;                                              \
2213         ast_mutex_t lock;                                               \
2214 } name = AST_LIST_HEAD_INIT_VALUE
2215 #endif
2216
2217 /*!
2218   \brief Defines a structure to be used to hold a read/write list of specified type, statically initialized.
2219   \param name This will be the name of the defined structure.
2220   \param type This is the type of each list entry.
2221
2222   This macro creates a structure definition that can be used
2223   to hold a list of the entries of type \a type, and allocates an instance
2224   of it, initialized to be empty.
2225
2226   Example usage:
2227   \code
2228   static AST_RWLIST_HEAD_STATIC(entry_list, entry);
2229   \endcode
2230
2231   This would define \c struct \c entry_list, intended to hold a list of
2232   type \c struct \c entry.
2233 */
2234 #ifndef AST_RWLOCK_INIT_VALUE
2235 #define AST_RWLIST_HEAD_STATIC(name, type)                              \
2236 struct name {                                                           \
2237         struct type *first;                                             \
2238         struct type *last;                                              \
2239         ast_rwlock_t lock;                                              \
2240 } name;                                                                 \
2241 static void  __attribute__((constructor)) init_##name(void)            \
2242 {                                                                       \
2243         AST_RWLIST_HEAD_INIT(&name);                                    \
2244 }                                                                       \
2245 static void  __attribute__((destructor)) fini_##name(void)             \
2246 {                                                                       \
2247         AST_RWLIST_HEAD_DESTROY(&name);                                 \
2248 }                                                                       \
2249 struct __dummy_##name
2250 #else
2251 #define AST_RWLIST_HEAD_STATIC(name, type)                              \
2252 struct name {                                                           \
2253         struct type *first;                                             \
2254         struct type *last;                                              \
2255         ast_rwlock_t lock;                                              \
2256 } name = AST_RWLIST_HEAD_INIT_VALUE
2257 #endif
2258
2259 /*!
2260   \brief Defines a structure to be used to hold a list of specified type, statically initialized.
2261
2262   This is the same as AST_LIST_HEAD_STATIC, except without the lock included.
2263 */
2264 #define AST_LIST_HEAD_NOLOCK_STATIC(name, type)                         \
2265 struct name {                                                           \
2266         struct type *first;                                             \
2267         struct type *last;                                              \
2268 } name = AST_LIST_HEAD_NOLOCK_INIT_VALUE
2269
2270 /*!
2271   \brief Initializes a list head structure with a specified first entry.
2272   \param head This is a pointer to the list head structure
2273   \param entry pointer to the list entry that will become the head of the list
2274
2275   This macro initializes a list head structure by setting the head
2276   entry to the supplied value and recreating the embedded lock.
2277 */
2278 #define AST_LIST_HEAD_SET(head, entry) do {                             \
2279         (head)->first = (entry);                                        \
2280         (head)->last = (entry);                                         \
2281         ast_mutex_init(&(head)->lock);                                  \
2282 } while (0)
2283
2284 /*!
2285   \brief Initializes an rwlist head structure with a specified first entry.
2286   \param head This is a pointer to the list head structure
2287   \param entry pointer to the list entry that will become the head of the list
2288
2289   This macro initializes a list head structure by setting the head
2290   entry to the supplied value and recreating the embedded lock.
2291 */
2292 #define AST_RWLIST_HEAD_SET(head, entry) do {                           \
2293         (head)->first = (entry);                                        \
2294         (head)->last = (entry);                                         \
2295         ast_rwlock_init(&(head)->lock);                                 \
2296 } while (0)
2297
2298 /*!
2299   \brief Initializes a list head structure with a specified first entry.
2300   \param head This is a pointer to the list head structure
2301   \param entry pointer to the list entry that will become the head of the list
2302
2303   This macro initializes a list head structure by setting the head
2304   entry to the supplied value.
2305 */
2306 #define AST_LIST_HEAD_SET_NOLOCK(head, entry) do {                      \
2307         (head)->first = (entry);                                        \
2308         (head)->last = (entry);                                         \
2309 } while (0)
2310
2311 /*!
2312   \brief Declare a forward link structure inside a list entry.
2313   \param type This is the type of each list entry.
2314
2315   This macro declares a structure to be used to link list entries together.
2316   It must be used inside the definition of the structure named in
2317   \a type, as follows:
2318
2319   \code
2320   struct list_entry {
2321         ...
2322         AST_LIST_ENTRY(list_entry) list;
2323   }
2324   \endcode
2325
2326   The field name \a list here is arbitrary, and can be anything you wish.
2327 */
2328 #define AST_LIST_ENTRY(type)                                            \
2329 struct {                                                                \
2330         struct type *next;                                              \
2331 }
2332
2333 #define AST_RWLIST_ENTRY AST_LIST_ENTRY
2334  
2335 /*!
2336   \brief Returns the first entry contained in a list.
2337   \param head This is a pointer to the list head structure
2338  */
2339 #define AST_LIST_FIRST(head)    ((head)->first)
2340
2341 #define AST_RWLIST_FIRST AST_LIST_FIRST
2342
2343 /*!
2344   \brief Returns the last entry contained in a list.
2345   \param head This is a pointer to the list head structure
2346  */
2347 #define AST_LIST_LAST(head)     ((head)->last)
2348
2349 #define AST_RWLIST_LAST AST_LIST_LAST
2350
2351 /*!
2352   \brief Returns the next entry in the list after the given entry.
2353   \param elm This is a pointer to the current entry.
2354   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2355   used to link entries of this list together.
2356 */
2357 #define AST_LIST_NEXT(elm, field)       ((elm)->field.next)
2358
2359 #define AST_RWLIST_NEXT AST_LIST_NEXT
2360
2361 /*!
2362   \brief Checks whether the specified list contains any entries.
2363   \param head This is a pointer to the list head structure
2364
2365   Returns non-zero if the list has entries, zero if not.
2366  */
2367 #define AST_LIST_EMPTY(head)    (AST_LIST_FIRST(head) == NULL)
2368
2369 #define AST_RWLIST_EMPTY AST_LIST_EMPTY
2370
2371 /*!
2372   \brief Loops over (traverses) the entries in a list.
2373   \param head This is a pointer to the list head structure
2374   \param var This is the name of the variable that will hold a pointer to the
2375   current list entry on each iteration. It must be declared before calling
2376   this macro.
2377   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2378   used to link entries of this list together.
2379
2380   This macro is use to loop over (traverse) the entries in a list. It uses a
2381   \a for loop, and supplies the enclosed code with a pointer to each list
2382   entry as it loops. It is typically used as follows:
2383   \code
2384   static AST_LIST_HEAD(entry_list, list_entry) entries;
2385   ...
2386   struct list_entry {
2387         ...
2388         AST_LIST_ENTRY(list_entry) list;
2389   }
2390   ...
2391   struct list_entry *current;
2392   ...
2393   AST_LIST_TRAVERSE(&entries, current, list) {
2394      (do something with current here)
2395   }
2396   \endcode
2397   \warning If you modify the forward-link pointer contained in the \a current entry while
2398   inside the loop, the behavior will be unpredictable. At a minimum, the following
2399   macros will modify the forward-link pointer, and should not be used inside
2400   AST_LIST_TRAVERSE() against the entry pointed to by the \a current pointer without
2401   careful consideration of their consequences:
2402   \li AST_LIST_NEXT() (when used as an lvalue)
2403   \li AST_LIST_INSERT_AFTER()
2404   \li AST_LIST_INSERT_HEAD()
2405   \li AST_LIST_INSERT_TAIL()
2406 */
2407 #define AST_LIST_TRAVERSE(head,var,field)                               \
2408         for((var) = (head)->first; (var); (var) = (var)->field.next)
2409
2410 #define AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE
2411
2412 /*!
2413   \brief Loops safely over (traverses) the entries in a list.
2414   \param head This is a pointer to the list head structure
2415   \param var This is the name of the variable that will hold a pointer to the
2416   current list entry on each iteration. It must be declared before calling
2417   this macro.
2418   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2419   used to link entries of this list together.
2420
2421   This macro is used to safely loop over (traverse) the entries in a list. It
2422   uses a \a for loop, and supplies the enclosed code with a pointer to each list
2423   entry as it loops. It is typically used as follows:
2424
2425   \code
2426   static AST_LIST_HEAD(entry_list, list_entry) entries;
2427   ...
2428   struct list_entry {
2429         ...
2430         AST_LIST_ENTRY(list_entry) list;
2431   }
2432   ...
2433   struct list_entry *current;
2434   ...
2435   AST_LIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) {
2436      (do something with current here)
2437   }
2438   AST_LIST_TRAVERSE_SAFE_END;
2439   \endcode
2440
2441   It differs from AST_LIST_TRAVERSE() in that the code inside the loop can modify
2442   (or even free, after calling AST_LIST_REMOVE_CURRENT()) the entry pointed to by
2443   the \a current pointer without affecting the loop traversal.
2444 */
2445 #define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field) {                                \
2446         typeof((head)->first) __list_next;                                              \
2447         typeof((head)->first) __list_prev = NULL;                                       \
2448         typeof((head)->first) __new_prev = NULL;                                        \
2449         for ((var) = (head)->first, __new_prev = (var),                                 \
2450               __list_next = (var) ? (var)->field.next : NULL;                           \
2451              (var);                                                                     \
2452              __list_prev = __new_prev, (var) = __list_next,                             \
2453              __new_prev = (var),                                                        \
2454              __list_next = (var) ? (var)->field.next : NULL                             \
2455             )
2456
2457 #define AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN
2458
2459 /*!
2460   \brief Removes the \a current entry from a list during a traversal.
2461   \param head This is a pointer to the list head structure
2462   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2463   used to link entries of this list together.
2464
2465   \note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
2466   block; it is used to unlink the current entry from the list without affecting
2467   the list traversal (and without having to re-traverse the list to modify the
2468   previous entry, if any).
2469  */
2470 #define AST_LIST_REMOVE_CURRENT(head, field)                                            \
2471         __new_prev->field.next = NULL;                                                  \
2472         __new_prev = __list_prev;                                                       \
2473         if (__list_prev)                                                                \
2474                 __list_prev->field.next = __list_next;                                  \
2475         else                                                                            \
2476                 (head)->first = __list_next;                                            \
2477         if (!__list_next)                                                               \
2478                 (head)->last = __list_prev;
2479
2480 #define AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT
2481
2482 /*!
2483   \brief Inserts a list entry before the current entry during a traversal.
2484   \param head This is a pointer to the list head structure
2485   \param elm This is a pointer to the entry to be inserted.
2486   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2487   used to link entries of this list together.
2488
2489   \note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
2490   block.
2491  */
2492 #define AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field) do {           \
2493         if (__list_prev) {                                              \
2494                 (elm)->field.next = __list_prev->field.next;            \
2495                 __list_prev->field.next = elm;                          \
2496         } else {                                                        \
2497                 (elm)->field.next = (head)->first;                      \
2498                 (head)->first = (elm);                                  \
2499         }                                                               \
2500         __new_prev = (elm);                                             \
2501 } while (0)
2502
2503 #define AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT
2504
2505 /*!
2506   \brief Closes a safe loop traversal block.
2507  */
2508 #define AST_LIST_TRAVERSE_SAFE_END  }
2509
2510 #define AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END
2511
2512 /*!
2513   \brief Initializes a list head structure.
2514   \param head This is a pointer to the list head structure
2515
2516   This macro initializes a list head structure by setting the head
2517   entry to \a NULL (empty list) and recreating the embedded lock.
2518 */
2519 #define AST_LIST_HEAD_INIT(head) {                                      \
2520         (head)->first = NULL;                                           \
2521         (head)->last = NULL;                                            \
2522         ast_mutex_init(&(head)->lock);                                  \
2523 }
2524
2525 /*!
2526   \brief Initializes an rwlist head structure.
2527   \param head This is a pointer to the list head structure
2528
2529   This macro initializes a list head structure by setting the head
2530   entry to \a NULL (empty list) and recreating the embedded lock.
2531 */
2532 #define AST_RWLIST_HEAD_INIT(head) {                                    \
2533         (head)->first = NULL;                                           \
2534         (head)->last = NULL;                                            \
2535         ast_rwlock_init(&(head)->lock);                                 \
2536 }
2537
2538 /*!
2539   \brief Destroys a list head structure.
2540   \param head This is a pointer to the list head structure
2541
2542   This macro destroys a list head structure by setting the head
2543   entry to \a NULL (empty list) and destroying the embedded lock.
2544   It does not free the structure from memory.
2545 */
2546 #define AST_LIST_HEAD_DESTROY(head) {                                   \
2547         (head)->first = NULL;                                           \
2548         (head)->last = NULL;                                            \
2549         ast_mutex_destroy(&(head)->lock);                               \
2550 }
2551
2552 /*!
2553   \brief Destroys an rwlist head structure.
2554   \param head This is a pointer to the list head structure
2555
2556   This macro destroys a list head structure by setting the head
2557   entry to \a NULL (empty list) and destroying the embedded lock.
2558   It does not free the structure from memory.
2559 */
2560 #define AST_RWLIST_HEAD_DESTROY(head) {                                 \
2561         (head)->first = NULL;                                           \
2562         (head)->last = NULL;                                            \
2563         ast_rwlock_destroy(&(head)->lock);                              \
2564 }
2565
2566 /*!
2567   \brief Initializes a list head structure.
2568   \param head This is a pointer to the list head structure
2569
2570   This macro initializes a list head structure by setting the head
2571   entry to \a NULL (empty list). There is no embedded lock handling
2572   with this macro.
2573 */
2574 #define AST_LIST_HEAD_INIT_NOLOCK(head) {                               \
2575         (head)->first = NULL;                                           \
2576         (head)->last = NULL;                                            \
2577 }
2578
2579 /*!
2580   \brief Inserts a list entry after a given entry.
2581   \param head This is a pointer to the list head structure
2582   \param listelm This is a pointer to the entry after which the new entry should
2583   be inserted.
2584   \param elm This is a pointer to the entry to be inserted.
2585   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2586   used to link entries of this list together.
2587  */
2588 #define AST_LIST_INSERT_AFTER(head, listelm, elm, field) do {           \
2589         (elm)->field.next = (listelm)->field.next;                      \
2590         (listelm)->field.next = (elm);                                  \
2591         if ((head)->last == (listelm))                                  \
2592                 (head)->last = (elm);                                   \
2593 } while (0)
2594
2595 #define AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER
2596
2597 /*!
2598   \brief Inserts a list entry at the head of a list.
2599   \param head This is a pointer to the list head structure
2600   \param elm This is a pointer to the entry to be inserted.
2601   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2602   used to link entries of this list together.
2603  */
2604 #define AST_LIST_INSERT_HEAD(head, elm, field) do {                     \
2605                 (elm)->field.next = (head)->first;                      \
2606                 (head)->first = (elm);                                  \
2607                 if (!(head)->last)                                      \
2608                         (head)->last = (elm);                           \
2609 } while (0)
2610
2611 #define AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD
2612
2613 /*!
2614   \brief Appends a list entry to the tail of a list.
2615   \param head This is a pointer to the list head structure
2616   \param elm This is a pointer to the entry to be appended.
2617   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2618   used to link entries of this list together.
2619
2620   Note: The link field in the appended entry is \b not modified, so if it is
2621   actually the head of a list itself, the entire list will be appended
2622   temporarily (until the next AST_LIST_INSERT_TAIL is performed).
2623  */
2624 #define AST_LIST_INSERT_TAIL(head, elm, field) do {                     \
2625       if (!(head)->first) {                                             \
2626                 (head)->first = (elm);                                  \
2627                 (head)->last = (elm);                                   \
2628       } else {                                                          \
2629                 (head)->last->field.next = (elm);                       \
2630                 (head)->last = (elm);                                   \
2631       }                                                                 \
2632 } while (0)
2633
2634 #define AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL
2635
2636 /*!
2637   \brief Appends a whole list to the tail of a list.
2638   \param head This is a pointer to the list head structure
2639   \param list This is a pointer to the list to be appended.
2640   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2641   used to link entries of this list together.
2642  */
2643 #define AST_LIST_APPEND_LIST(head, list, field) do {                    \
2644       if (!(head)->first) {                                             \
2645                 (head)->first = (list)->first;                          \
2646                 (head)->last = (list)->last;                            \
2647       } else {                                                          \
2648                 (head)->last->field.next = (list)->first;               \
2649                 (head)->last = (list)->last;                            \
2650       }                                                                 \
2651 } while (0)
2652
2653 #define AST_RWLIST_APPEND_LIST AST_LIST_APPEND_LIST
2654
2655 /*!
2656   \brief Removes and returns the head entry from a list.
2657   \param head This is a pointer to the list head structure
2658   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2659   used to link entries of this list together.
2660
2661   Removes the head entry from the list, and returns a pointer to it.
2662   This macro is safe to call on an empty list.
2663  */
2664 #define AST_LIST_REMOVE_HEAD(head, field) ({                            \
2665                 typeof((head)->first) cur = (head)->first;              \
2666                 if (cur) {                                              \
2667                         (head)->first = cur->field.next;                \
2668                         cur->field.next = NULL;                         \
2669                         if ((head)->last == cur)                        \
2670                                 (head)->last = NULL;                    \
2671                 }                                                       \
2672                 cur;                                                    \
2673         })
2674
2675 #define AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD
2676
2677 /*!
2678   \brief Removes a specific entry from a list.
2679   \param head This is a pointer to the list head structure
2680   \param elm This is a pointer to the entry to be removed.
2681   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2682   used to link entries of this list together.
2683   \warning The removed entry is \b not freed nor modified in any way.
2684  */
2685 #define AST_LIST_REMOVE(head, elm, field) do {                          \
2686         if ((head)->first == (elm)) {                                   \
2687                 (head)->first = (elm)->field.next;                      \
2688                 if ((head)->last == (elm))                      \
2689                         (head)->last = NULL;                    \
2690         } else {                                                                \
2691                 typeof(elm) curelm = (head)->first;                     \
2692                 while (curelm && (curelm->field.next != (elm)))                 \
2693                         curelm = curelm->field.next;                    \
2694                 if (curelm) { \
2695                         curelm->field.next = (elm)->field.next;                 \
2696                         if ((head)->last == (elm))                              \
2697                                 (head)->last = curelm;                          \
2698                 } \
2699         }                                                               \
2700         (elm)->field.next = NULL;                                       \
2701 } while (0)
2702
2703 #define AST_RWLIST_REMOVE AST_LIST_REMOVE
2704
2705 /* chanvars.h */
2706
2707 struct ast_var_t {
2708         AST_LIST_ENTRY(ast_var_t) entries;
2709         char *value;
2710         char name[0];
2711 };
2712
2713 AST_LIST_HEAD_NOLOCK(varshead, ast_var_t);
2714
2715 AST_RWLOCK_DEFINE_STATIC(globalslock);
2716 static struct varshead globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
2717
2718
2719 /* IN CONFLICT: struct ast_var_t *ast_var_assign(const char *name, const char *value); */
2720
2721 static struct ast_var_t *ast_var_assign(const char *name, const char *value);
2722
2723 static void ast_var_delete(struct ast_var_t *var);
2724
2725 /*from channel.h */
2726 #define AST_MAX_EXTENSION  80      /*!< Max length of an extension */
2727
2728
2729 /* from pbx.h */
2730 #define PRIORITY_HINT   -1      /*!< Special Priority for a hint */
2731
2732 enum ast_extension_states {
2733         AST_EXTENSION_REMOVED = -2,     /*!< Extension removed */
2734         AST_EXTENSION_DEACTIVATED = -1, /*!< Extension hint removed */
2735         AST_EXTENSION_NOT_INUSE = 0,    /*!< No device INUSE or BUSY  */
2736         AST_EXTENSION_INUSE = 1 << 0,   /*!< One or more devices INUSE */
2737         AST_EXTENSION_BUSY = 1 << 1,    /*!< All devices BUSY */
2738         AST_EXTENSION_UNAVAILABLE = 1 << 2, /*!< All devices UNAVAILABLE/UNREGISTERED */
2739         AST_EXTENSION_RINGING = 1 << 3, /*!< All devices RINGING */
2740         AST_EXTENSION_ONHOLD = 1 << 4,  /*!< All devices ONHOLD */
2741 };
2742
2743 struct ast_custom_function {
2744         const char *name;               /*!< Name */
2745         const char *synopsis;           /*!< Short description for "show functions" */
2746         const char *desc;               /*!< Help text that explains it all */
2747         const char *syntax;             /*!< Syntax description */
2748         int (*read)(struct ast_channel *, const char *, char *, char *, size_t);        /*!< Read function, if read is supported */
2749         int (*write)(struct ast_channel *, const char *, char *, const char *);         /*!< Write function, if write is supported */
2750         AST_RWLIST_ENTRY(ast_custom_function) acflist;
2751 };
2752
2753 typedef int (ast_switch_f)(struct ast_channel *chan, const char *context,
2754         const char *exten, int priority, const char *callerid, const char *data);
2755
2756 struct ast_switch {
2757         AST_LIST_ENTRY(ast_switch) list;
2758         const char *name;                       /*!< Name of the switch */
2759         const char *description;                /*!< Description of the switch */
2760         
2761         ast_switch_f *exists;
2762         ast_switch_f *canmatch;
2763         ast_switch_f *exec;
2764         ast_switch_f *matchmore;
2765 };
2766
2767
2768 static char *config_filename = "extensions.conf";
2769 static char *global_registrar = "conf2ael";
2770 static char userscontext[AST_MAX_EXTENSION] = "default";
2771 static int static_config = 0;
2772 static int write_protect_config = 1;
2773 static int autofallthrough_config = 0;
2774 static int clearglobalvars_config = 0;
2775 /*! Go no deeper than this through includes (not counting loops) */
2776 #define AST_PBX_MAX_STACK       128
2777 static void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
2778
2779
2780 /* stolen from callerid.c */
2781
2782 /*! \brief Clean up phone string
2783  * remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets.
2784  * Basically, remove anything that could be invalid in a pattern.
2785  */
2786 static void ast_shrink_phone_number(char *n)
2787 {
2788         int x, y=0;
2789         int bracketed = 0;
2790
2791         for (x=0; n[x]; x++) {
2792                 switch(n[x]) {
2793                 case '[':
2794                         bracketed++;
2795                         n[y++] = n[x];
2796                         break;
2797                 case ']':
2798                         bracketed--;
2799                         n[y++] = n[x];
2800                         break;
2801                 case '-':
2802                         if (bracketed)
2803                                 n[y++] = n[x];
2804                         break;
2805                 case '.':
2806                         if (!n[x+1])
2807                                 n[y++] = n[x];
2808                         break;
2809                 default:
2810                         if (!strchr("()", n[x]))
2811                                 n[y++] = n[x];
2812                 }
2813         }
2814         n[y] = '\0';
2815 }
2816
2817
2818 /* stolen from chanvars.c */
2819
2820 static const char *ast_var_name(const struct ast_var_t *var)
2821 {
2822         const char *name;
2823
2824         if (var == NULL || (name = var->name) == NULL)
2825                 return NULL;
2826         /* Return the name without the initial underscores */
2827         if (name[0] == '_') {
2828                 name++;
2829                 if (name[0] == '_')
2830                         name++;
2831         }
2832         return name;
2833 }
2834
2835 /* experiment 1: see if it's easier just to use existing config code
2836  *               to read in the extensions.conf file. In this scenario, 
2837                  I have to rip/copy code from other modules, because they
2838                  are staticly declared as-is. A solution would be to move
2839                  the ripped code to another location and make them available
2840                  to other modules and standalones */
2841
2842 /* Our own version of ast_log, since the expr parser uses it. -- stolen from utils/check_expr.c */
2843
2844 static void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
2845 {
2846         va_list vars;
2847         va_start(vars,fmt);
2848         
2849         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
2850                    level, file, line, function);
2851         vprintf(fmt, vars);
2852         fflush(stdout);
2853         va_end(vars);
2854 }
2855
2856 void __attribute__((format(printf, 1, 2))) ast_verbose(const char *fmt, ...)
2857 {
2858         va_list vars;
2859         va_start(vars,fmt);
2860         
2861         printf("VERBOSE: ");
2862         vprintf(fmt, vars);
2863         fflush(stdout);
2864         va_end(vars);
2865 }
2866
2867 /* stolen from main/utils.c */
2868 static char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
2869 {
2870         char *dataPut = start;
2871         int inEscape = 0;
2872         int inQuotes = 0;
2873
2874         for (; *start; start++) {
2875                 if (inEscape) {
2876                         *dataPut++ = *start;       /* Always goes verbatim */
2877                         inEscape = 0;
2878                 } else {
2879                         if (*start == '\\') {
2880                                 inEscape = 1;      /* Do not copy \ into the data */
2881                         } else if (*start == '\'') {
2882                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
2883                         } else {
2884                                 /* Replace , with |, unless in quotes */
2885                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
2886                         }
2887                 }
2888         }
2889         if (start != dataPut)
2890                 *dataPut = 0;
2891         return dataPut;
2892 }
2893
2894 static int ast_true(const char *s)
2895 {
2896         if (ast_strlen_zero(s))
2897                 return 0;
2898
2899         /* Determine if this is a true value */
2900         if (!strcasecmp(s, "yes") ||
2901             !strcasecmp(s, "true") ||
2902             !strcasecmp(s, "y") ||
2903             !strcasecmp(s, "t") ||
2904             !strcasecmp(s, "1") ||
2905             !strcasecmp(s, "on"))
2906                 return -1;
2907
2908         return 0;
2909 }
2910
2911 /* stolen from pbx.c */
2912 #define VAR_BUF_SIZE 4096
2913
2914 #define VAR_NORMAL              1
2915 #define VAR_SOFTTRAN    2
2916 #define VAR_HARDTRAN    3
2917
2918 #define BACKGROUND_SKIP         (1 << 0)
2919 #define BACKGROUND_NOANSWER     (1 << 1)
2920 #define BACKGROUND_MATCHEXTEN   (1 << 2)
2921 #define BACKGROUND_PLAYBACK     (1 << 3)
2922
2923 /*!
2924    \brief ast_exten: An extension
2925         The dialplan is saved as a linked list with each context
2926         having it's own linked list of extensions - one item per
2927         priority.
2928 */
2929 struct ast_exten {
2930         char *exten;                    /*!< Extension name */
2931         int matchcid;                   /*!< Match caller id ? */
2932         const char *cidmatch;           /*!< Caller id to match for this extension */
2933         int priority;                   /*!< Priority */
2934         const char *label;              /*!< Label */
2935         struct ast_context *parent;     /*!< The context this extension belongs to  */
2936         const char *app;                /*!< Application to execute */
2937         struct ast_app *cached_app;     /*!< Cached location of application */
2938         void *data;                     /*!< Data to use (arguments) */
2939         void (*datad)(void *);          /*!< Data destructor */
2940         struct ast_exten *peer;         /*!< Next higher priority with our extension */
2941         const char *registrar;          /*!< Registrar */
2942         struct ast_exten *next;         /*!< Extension with a greater ID */
2943         char stuff[0];
2944 };
2945 /* from pbx.h */
2946 typedef int (*ast_state_cb_type)(char *context, char* id, enum ast_extension_states state, void *data);
2947 struct ast_timing {
2948         int hastime;                            /*!< If time construct exists */
2949         unsigned int monthmask;                 /*!< Mask for month */
2950         unsigned int daymask;                   /*!< Mask for date */
2951         unsigned int dowmask;                   /*!< Mask for day of week (mon-sun) */
2952         unsigned int minmask[24];               /*!< Mask for minute */
2953         char *timezone;                 /*!< NULL, or zoneinfo style timezone */
2954 };
2955 /* end of pbx.h */
2956 /*! \brief ast_include: include= support in extensions.conf */
2957 struct ast_include {
2958         const char *name;
2959         const char *rname;                      /*!< Context to include */
2960         const char *registrar;                  /*!< Registrar */
2961         int hastime;                            /*!< If time construct exists */
2962         struct ast_timing timing;               /*!< time construct */
2963         struct ast_include *next;               /*!< Link them together */
2964         char stuff[0];
2965 };
2966
2967 /*! \brief ast_sw: Switch statement in extensions.conf */
2968 struct ast_sw {
2969         char *name;
2970         const char *registrar;                  /*!< Registrar */
2971         char *data;                             /*!< Data load */
2972         int eval;
2973         AST_LIST_ENTRY(ast_sw) list;
2974         char *tmpdata;
2975         char stuff[0];
2976 };
2977
2978 /*! \brief ast_ignorepat: Ignore patterns in dial plan */
2979 struct ast_ignorepat {
2980         const char *registrar;
2981         struct ast_ignorepat *next;
2982         char pattern[0];
2983 };
2984
2985 /*! \brief ast_context: An extension context */
2986 struct ast_context {
2987         ast_rwlock_t lock;                      /*!< A lock to prevent multiple threads from clobbering the context */
2988         struct ast_exten *root;                 /*!< The root of the list of extensions */
2989         struct ast_context *next;               /*!< Link them together */
2990         struct ast_include *includes;           /*!< Include other contexts */
2991         struct ast_ignorepat *ignorepats;       /*!< Patterns for which to continue playing dialtone */
2992         const char *registrar;                  /*!< Registrar */
2993         AST_LIST_HEAD_NOLOCK(, ast_sw) alts;    /*!< Alternative switches */
2994         ast_mutex_t macrolock;                  /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */
2995         char name[0];                           /*!< Name of the context */
2996 };
2997
2998
2999 /*! \brief ast_app: A registered application */
3000 struct ast_app {
3001         int (*execute)(struct ast_channel *chan, void *data);
3002         const char *synopsis;                   /*!< Synopsis text for 'show applications' */
3003         const char *description;                /*!< Description (help text) for 'show application &lt;name&gt;' */
3004         AST_RWLIST_ENTRY(ast_app) list;         /*!< Next app in list */
3005         void *module;                   /*!< Module this app belongs to */
3006         char name[0];                           /*!< Name of the application */
3007 };
3008
3009
3010 /*! \brief ast_state_cb: An extension state notify register item */
3011 struct ast_state_cb {
3012         int id;
3013         void *data;
3014         ast_state_cb_type callback;
3015         struct ast_state_cb *next;
3016 };
3017
3018 /*! \brief Structure for dial plan hints
3019
3020   \note Hints are pointers from an extension in the dialplan to one or
3021   more devices (tech/name) 
3022         - See \ref AstExtState
3023 */
3024 struct ast_hint {
3025         struct ast_exten *exten;        /*!< Extension */
3026         int laststate;                  /*!< Last known state */
3027         struct ast_state_cb *callbacks; /*!< Callback list for this extension */
3028         AST_RWLIST_ENTRY(ast_hint) list;/*!< Pointer to next hint in list */
3029 };
3030
3031 struct store_hint {
3032         char *context;
3033         char *exten;
3034         struct ast_state_cb *callbacks;
3035         int laststate;
3036         AST_LIST_ENTRY(store_hint) list;
3037         char data[1];
3038 };
3039
3040 AST_LIST_HEAD(store_hints, store_hint);
3041
3042 static const struct cfextension_states {
3043         int extension_state;
3044         const char * const text;
3045 } extension_states[] = {
3046         { AST_EXTENSION_NOT_INUSE,                     "Idle" },
3047         { AST_EXTENSION_INUSE,                         "InUse" },
3048         { AST_EXTENSION_BUSY,                          "Busy" },
3049         { AST_EXTENSION_UNAVAILABLE,                   "Unavailable" },
3050         { AST_EXTENSION_RINGING,                       "Ringing" },
3051         { AST_EXTENSION_INUSE | AST_EXTENSION_RINGING, "InUse&Ringing" },
3052         { AST_EXTENSION_ONHOLD,                        "Hold" },
3053         { AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD,  "InUse&Hold" }
3054 };
3055 #define STATUS_NO_CONTEXT       1
3056 #define STATUS_NO_EXTENSION     2
3057 #define STATUS_NO_PRIORITY      3
3058 #define STATUS_NO_LABEL         4
3059 #define STATUS_SUCCESS          5
3060
3061
3062 #if defined ( __i386__) && (defined(__FreeBSD__) || defined(linux))
3063 #if defined(__FreeBSD__)
3064 #include <machine/cpufunc.h>
3065 #elif defined(linux)
3066 static __inline uint64_t
3067 rdtsc(void)
3068
3069         uint64_t rv;
3070
3071         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
3072         return (rv);
3073 }
3074 #endif
3075 #else   /* supply a dummy function on other platforms */
3076 static __inline uint64_t
3077 rdtsc(void)
3078 {
3079         return 0;
3080 }
3081 #endif
3082
3083
3084 static struct ast_var_t *ast_var_assign(const char *name, const char *value)
3085 {       
3086         struct ast_var_t *var;
3087         int name_len = strlen(name) + 1;
3088         int value_len = strlen(value) + 1;
3089
3090         if (!(var = ast_calloc(sizeof(*var) + name_len + value_len, sizeof(char)))) {
3091                 return NULL;
3092         }
3093
3094         ast_copy_string(var->name, name, name_len);
3095         var->value = var->name + name_len;
3096         ast_copy_string(var->value, value, value_len);
3097         
3098         return var;
3099 }       
3100         
3101 static void ast_var_delete(struct ast_var_t *var)
3102 {
3103         if (var)
3104                 free(var);
3105 }
3106
3107
3108 /* chopped this one off at the knees! */
3109 static int ast_func_write(struct ast_channel *chan, const char *function, const char *value)
3110 {
3111
3112         /* ast_log(LOG_ERROR, "Function %s not registered\n", function); we are not interested in the details here */
3113
3114         return -1;
3115 }
3116
3117 static unsigned int ast_app_separate_args(char *buf, char delim, char **array, int arraylen)
3118 {
3119         int argc;
3120         char *scan;
3121         int paren = 0, quote = 0;
3122
3123         if (!buf || !array || !arraylen)
3124                 return 0;
3125
3126         memset(array, 0, arraylen * sizeof(*array));
3127
3128         scan = buf;
3129
3130         for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
3131                 array[argc] = scan;
3132                 for (; *scan; scan++) {
3133                         if (*scan == '(')
3134                                 paren++;
3135                         else if (*scan == ')') {
3136                                 if (paren)
3137                                         paren--;
3138                         } else if (*scan == '"' && delim != '"') {
3139                                 quote = quote ? 0 : 1;
3140                                 /* Remove quote character from argument */
3141                                 memmove(scan, scan + 1, strlen(scan));
3142                                 scan--;
3143                         } else if (*scan == '\\') {
3144                                 /* Literal character, don't parse */
3145                                 memmove(scan, scan + 1, strlen(scan));
3146                         } else if ((*scan == delim) && !paren && !quote) {
3147                                 *scan++ = '\0';
3148                                 break;
3149                         }
3150                 }
3151         }
3152
3153         if (*scan)
3154                 array[argc++] = scan;
3155
3156         return argc;
3157 }
3158
3159 static void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
3160 {
3161         struct ast_var_t *newvariable;
3162         struct varshead *headp;
3163         const char *nametail = name;
3164
3165         /* XXX may need locking on the channel ? */
3166         if (name[strlen(name)-1] == ')') {
3167                 char *function = ast_strdupa(name);
3168
3169                 ast_func_write(chan, function, value);
3170                 return;
3171         }
3172
3173         headp = &globals;
3174
3175         /* For comparison purposes, we have to strip leading underscores */
3176         if (*nametail == '_') {
3177                 nametail++;
3178                 if (*nametail == '_')
3179                         nametail++;
3180         }
3181
3182         AST_LIST_TRAVERSE (headp, newvariable, entries) {
3183                 if (strcasecmp(ast_var_name(newvariable), nametail) == 0) {
3184                         /* there is already such a variable, delete it */
3185                         AST_LIST_REMOVE(headp, newvariable, entries);
3186                         ast_var_delete(newvariable);
3187                         break;
3188                 }
3189         }
3190
3191         if (value) {
3192                 if ((option_verbose > 1) && (headp == &globals))
3193                         ast_verbose(VERBOSE_PREFIX_2 "Setting global variable '%s' to '%s'\n", name, value);
3194                 newvariable = ast_var_assign(name, value);
3195                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
3196         }
3197
3198 }
3199
3200 static int pbx_builtin_setvar(struct ast_channel *chan, void *data)
3201 {
3202         char *name, *value, *mydata;
3203         int argc;
3204         char *argv[24];         /* this will only support a maximum of 24 variables being set in a single operation */
3205         int global = 0;
3206         int x;
3207
3208         if (ast_strlen_zero(data)) {
3209                 ast_log(LOG_WARNING, "Set requires at least one variable name/value pair.\n");
3210                 return 0;
3211         }
3212
3213         mydata = ast_strdupa(data);
3214         argc = ast_app_separate_args(mydata, '|', argv, sizeof(argv) / sizeof(argv[0]));
3215
3216         /* check for a trailing flags argument */
3217         if ((argc > 1) && !strchr(argv[argc-1], '=')) {
3218                 argc--;
3219                 if (strchr(argv[argc], 'g'))
3220                         global = 1;
3221         }
3222
3223         for (x = 0; x < argc; x++) {
3224                 name = argv[x];
3225                 if ((value = strchr(name, '='))) {
3226                         *value++ = '\0';
3227                         pbx_builtin_setvar_helper((global) ? NULL : chan, name, value);
3228                 } else
3229                         ast_log(LOG_WARNING, "Ignoring entry '%s' with no = (and not last 'options' entry)\n", name);
3230         }
3231
3232         return(0);
3233 }
3234
3235 int localized_pbx_builtin_setvar(struct ast_channel *chan, void *data);
3236
3237 int localized_pbx_builtin_setvar(struct ast_channel *chan, void *data)
3238 {
3239         return pbx_builtin_setvar(chan, data);
3240 }
3241
3242
3243 /*! \brief Helper for get_range.
3244  * return the index of the matching entry, starting from 1.
3245  * If names is not supplied, try numeric values.
3246  */
3247 static int lookup_name(const char *s, char *const names[], int max)
3248 {
3249         int i;
3250
3251         if (names && *s > '9') {
3252                 for (i = 0; names[i]; i++) {
3253                         if (!strcasecmp(s, names[i])) {
3254                                 return i;
3255                         }
3256                 }
3257         }
3258
3259         /* Allow months and weekdays to be specified as numbers, as well */
3260         if (sscanf(s, "%d", &i) == 1 && i >= 1 && i <= max) {
3261                 /* What the array offset would have been: "1" would be at offset 0 */
3262                 return i - 1;
3263         }
3264         return -1; /* error return */
3265 }
3266
3267 /*! \brief helper function to return a range up to max (7, 12, 31 respectively).
3268  * names, if supplied, is an array of names that should be mapped to numbers.
3269  */
3270 static unsigned get_range(char *src, int max, char *const names[], const char *msg)
3271 {
3272         int start, end; /* start and ending position */
3273         unsigned int mask = 0;
3274         char *part;
3275
3276         /* Check for whole range */
3277         if (ast_strlen_zero(src) || !strcmp(src, "*")) {
3278                 return (1 << max) - 1;
3279         }
3280
3281         while ((part = strsep(&src, "&"))) {
3282                 /* Get start and ending position */
3283                 char *endpart = strchr(part, '-');
3284                 if (endpart) {
3285                         *endpart++ = '\0';
3286                 }
3287                 /* Find the start */
3288                 if ((start = lookup_name(part, names, max)) < 0) {
3289                         ast_log(LOG_WARNING, "Invalid %s '%s', skipping element\n", msg, part);
3290                         continue;
3291                 }
3292                 if (endpart) { /* find end of range */
3293                         if ((end = lookup_name(endpart, names, max)) < 0) {
3294                                 ast_log(LOG_WARNING, "Invalid end %s '%s', skipping element\n", msg, endpart);
3295                                 continue;
3296                         }
3297                 } else {
3298                         end = start;
3299                 }
3300                 /* Fill the mask. Remember that ranges are cyclic */
3301                 mask |= (1 << end);   /* initialize with last element */
3302                 while (start != end) {
3303                         if (start >= max) {
3304                                 start = 0;
3305                         }
3306                         mask |= (1 << start);
3307                         start++;
3308                 }
3309         }
3310         return mask;
3311 }
3312
3313 /*! \brief store a bitmask of valid times, one bit each 2 minute */
3314 static void get_timerange(struct ast_timing *i, char *times)
3315 {
3316         char *endpart, *part;
3317         int x;
3318         int st_h, st_m;
3319         int endh, endm;
3320         int minute_start, minute_end;
3321
3322         /* start disabling all times, fill the fields with 0's, as they may contain garbage */
3323         memset(i->minmask, 0, sizeof(i->minmask));
3324
3325         /* 1-minute per bit */
3326         /* Star is all times */