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