Fix res/res_http_websocket.c build failure in 32bit due to incorrect print format...
[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         /*! Use DAHDI Timing for generators if available */
1845         AST_OPT_FLAG_INTERNAL_TIMING = (1 << 20),
1846         /*! Always fork, even if verbose or debug settings are non-zero */
1847         AST_OPT_FLAG_ALWAYS_FORK = (1 << 21),
1848         /*! Disable log/verbose output to remote consoles */
1849         AST_OPT_FLAG_MUTE = (1 << 22),
1850         /*! There is a per-file debug setting */
1851         AST_OPT_FLAG_DEBUG_FILE = (1 << 23),
1852         /*! There is a per-file verbose setting */
1853         AST_OPT_FLAG_VERBOSE_FILE = (1 << 24),
1854         /*! Terminal colors should be adjusted for a light-colored background */
1855         AST_OPT_FLAG_LIGHT_BACKGROUND = (1 << 25),
1856         /*! Count Initiated seconds in CDR's */
1857         AST_OPT_FLAG_INITIATED_SECONDS = (1 << 26),
1858         /*! Force black background */
1859         AST_OPT_FLAG_FORCE_BLACK_BACKGROUND = (1 << 27),
1860 };
1861
1862 /* options.h declares ast_options extern; I need it static? */
1863 #define AST_CACHE_DIR_LEN       512
1864 #define AST_FILENAME_MAX        80
1865
1866 /*! These are the options that set by default when Asterisk starts */
1867 #define AST_DEFAULT_OPTIONS AST_OPT_FLAG_TRANSCODE_VIA_SLIN
1868
1869 struct ast_flags ast_options = { AST_DEFAULT_OPTIONS };
1870
1871 #define ast_opt_exec_includes           ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)
1872 #define ast_opt_no_fork                 ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)
1873 #define ast_opt_quiet                   ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)
1874 #define ast_opt_console                 ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)
1875 #define ast_opt_high_priority           ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)
1876 #define ast_opt_init_keys               ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)
1877 #define ast_opt_remote                  ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)
1878 #define ast_opt_exec                    ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)
1879 #define ast_opt_no_color                ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)
1880 #define ast_fully_booted                ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)
1881 #define ast_opt_transcode_via_slin      ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)
1882 #define ast_opt_priority_jumping        ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)
1883 #define ast_opt_dump_core               ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)
1884 #define ast_opt_cache_record_files      ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)
1885 #define ast_opt_timestamp               ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)
1886 #define ast_opt_override_config         ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)
1887 #define ast_opt_reconnect               ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)
1888 #define ast_opt_transmit_silence        ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)
1889 #define ast_opt_dont_warn               ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)
1890 #define ast_opt_end_cdr_before_h_exten  ast_test_flag(&ast_options, AST_OPT_FLAG_END_CDR_BEFORE_H_EXTEN)
1891 #define ast_opt_internal_timing         ast_test_flag(&ast_options, AST_OPT_FLAG_INTERNAL_TIMING)
1892 #define ast_opt_always_fork             ast_test_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)
1893 #define ast_opt_mute                    ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)
1894
1895 extern int option_verbose;
1896 extern int option_debug;                /*!< Debugging */
1897 extern int ast_option_maxcalls;         /*!< Maximum number of simultaneous channels */
1898 extern double ast_option_maxload;
1899 extern char ast_defaultlanguage[];
1900
1901 extern pid_t ast_mainpid;
1902
1903 extern char record_cache_dir[AST_CACHE_DIR_LEN];
1904 extern char debug_filename[AST_FILENAME_MAX];
1905
1906 extern int ast_language_is_prefix;
1907
1908
1909
1910 /* linkedlists.h */
1911
1912 #define AST_LIST_LOCK(head)                                             \
1913         ast_mutex_lock(&(head)->lock) 
1914
1915 /*!
1916   \brief Write locks a list.
1917   \param head This is a pointer to the list head structure
1918
1919   This macro attempts to place an exclusive write lock in the
1920   list head structure pointed to by head.
1921   Returns non-zero on success, 0 on failure
1922 */
1923 #define AST_RWLIST_WRLOCK(head)                                         \
1924         ast_rwlock_wrlock(&(head)->lock)
1925
1926 /*!
1927   \brief Read locks a list.
1928   \param head This is a pointer to the list head structure
1929
1930   This macro attempts to place a read lock in the
1931   list head structure pointed to by head.
1932   Returns non-zero on success, 0 on failure
1933 */
1934 #define AST_RWLIST_RDLOCK(head)                                         \
1935         ast_rwlock_rdlock(&(head)->lock)
1936         
1937 /*!
1938   \brief Locks a list, without blocking if the list is locked.
1939   \param head This is a pointer to the list head structure
1940
1941   This macro attempts to place an exclusive lock in the
1942   list head structure pointed to by head.
1943   Returns non-zero on success, 0 on failure
1944 */
1945 #define AST_LIST_TRYLOCK(head)                                          \
1946         ast_mutex_trylock(&(head)->lock) 
1947
1948 /*!
1949   \brief Write locks a list, without blocking if the list is locked.
1950   \param head This is a pointer to the list head structure
1951
1952   This macro attempts to place an exclusive write lock in the
1953   list head structure pointed to by head.
1954   Returns non-zero on success, 0 on failure
1955 */
1956 #define AST_RWLIST_TRYWRLOCK(head)                                      \
1957         ast_rwlock_trywrlock(&(head)->lock)
1958
1959 /*!
1960   \brief Read locks a list, without blocking if the list is locked.
1961   \param head This is a pointer to the list head structure
1962
1963   This macro attempts to place a read lock in the
1964   list head structure pointed to by head.
1965   Returns non-zero on success, 0 on failure
1966 */
1967 #define AST_RWLIST_TRYRDLOCK(head)                                      \
1968         ast_rwlock_tryrdlock(&(head)->lock)
1969         
1970 /*!
1971   \brief Attempts to unlock a list.
1972   \param head This is a pointer to the list head structure
1973
1974   This macro attempts to remove an exclusive lock from the
1975   list head structure pointed to by head. If the list
1976   was not locked by this thread, this macro has no effect.
1977 */
1978 #define AST_LIST_UNLOCK(head)                                           \
1979         ast_mutex_unlock(&(head)->lock)
1980
1981 /*!
1982   \brief Attempts to unlock a read/write based list.
1983   \param head This is a pointer to the list head structure
1984
1985   This macro attempts to remove a read or write lock from the
1986   list head structure pointed to by head. If the list
1987   was not locked by this thread, this macro has no effect.
1988 */
1989 #define AST_RWLIST_UNLOCK(head)                                         \
1990         ast_rwlock_unlock(&(head)->lock)
1991
1992 /*!
1993   \brief Defines a structure to be used to hold a list of specified type.
1994   \param name This will be the name of the defined structure.
1995   \param type This is the type of each list entry.
1996
1997   This macro creates a structure definition that can be used
1998   to hold a list of the entries of type \a type. It does not actually
1999   declare (allocate) a structure; to do that, either follow this
2000   macro with the desired name of the instance you wish to declare,
2001   or use the specified \a name to declare instances elsewhere.
2002
2003   Example usage:
2004   \code
2005   static AST_LIST_HEAD(entry_list, entry) entries;
2006   \endcode
2007
2008   This would define \c struct \c entry_list, and declare an instance of it named
2009   \a entries, all intended to hold a list of type \c struct \c entry.
2010 */
2011 #define AST_LIST_HEAD(name, type)                                       \
2012 struct name {                                                           \
2013         struct type *first;                                             \
2014         struct type *last;                                              \
2015         ast_mutex_t lock;                                               \
2016 }
2017
2018 /*!
2019   \brief Defines a structure to be used to hold a read/write list of specified type.
2020   \param name This will be the name of the defined structure.
2021   \param type This is the type of each list entry.
2022
2023   This macro creates a structure definition that can be used
2024   to hold a list of the entries of type \a type. It does not actually
2025   declare (allocate) a structure; to do that, either follow this
2026   macro with the desired name of the instance you wish to declare,
2027   or use the specified \a name to declare instances elsewhere.
2028
2029   Example usage:
2030   \code
2031   static AST_RWLIST_HEAD(entry_list, entry) entries;
2032   \endcode
2033
2034   This would define \c struct \c entry_list, and declare an instance of it named
2035   \a entries, all intended to hold a list of type \c struct \c entry.
2036 */
2037 #define AST_RWLIST_HEAD(name, type)                                     \
2038 struct name {                                                           \
2039         struct type *first;                                             \
2040         struct type *last;                                              \
2041         ast_rwlock_t lock;                                              \
2042 }
2043
2044 /*!
2045   \brief Defines a structure to be used to hold a list of specified type (with no lock).
2046   \param name This will be the name of the defined structure.
2047   \param type This is the type of each list entry.
2048
2049   This macro creates a structure definition that can be used
2050   to hold a list of the entries of type \a type. It does not actually
2051   declare (allocate) a structure; to do that, either follow this
2052   macro with the desired name of the instance you wish to declare,
2053   or use the specified \a name to declare instances elsewhere.
2054
2055   Example usage:
2056   \code
2057   static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;
2058   \endcode
2059
2060   This would define \c struct \c entry_list, and declare an instance of it named
2061   \a entries, all intended to hold a list of type \c struct \c entry.
2062 */
2063 #define AST_LIST_HEAD_NOLOCK(name, type)                                \
2064 struct name {                                                           \
2065         struct type *first;                                             \
2066         struct type *last;                                              \
2067 }
2068
2069 /*!
2070   \brief Defines initial values for a declaration of AST_LIST_HEAD
2071 */
2072 #define AST_LIST_HEAD_INIT_VALUE        {               \
2073         .first = NULL,                                  \
2074         .last = NULL,                                   \
2075         .lock = AST_MUTEX_INIT_VALUE,                   \
2076         }
2077
2078 /*!
2079   \brief Defines initial values for a declaration of AST_RWLIST_HEAD
2080 */
2081 #define AST_RWLIST_HEAD_INIT_VALUE      {               \
2082         .first = NULL,                                  \
2083         .last = NULL,                                   \
2084         .lock = AST_RWLOCK_INIT_VALUE,                  \
2085         }
2086
2087 /*!
2088   \brief Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK
2089 */
2090 #define AST_LIST_HEAD_NOLOCK_INIT_VALUE {       \
2091         .first = NULL,                                  \
2092         .last = NULL,                                   \
2093         }
2094
2095 /*!
2096   \brief Defines a structure to be used to hold a list of specified type, statically initialized.
2097   \param name This will be the name of the defined structure.
2098   \param type This is the type of each list entry.
2099
2100   This macro creates a structure definition that can be used
2101   to hold a list of the entries of type \a type, and allocates an instance
2102   of it, initialized to be empty.
2103
2104   Example usage:
2105   \code
2106   static AST_LIST_HEAD_STATIC(entry_list, entry);
2107   \endcode
2108
2109   This would define \c struct \c entry_list, intended to hold a list of
2110   type \c struct \c entry.
2111 */
2112 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
2113 #define AST_LIST_HEAD_STATIC(name, type)                                \
2114 struct name {                                                           \
2115         struct type *first;                                             \
2116         struct type *last;                                              \
2117         ast_mutex_t lock;                                               \
2118 } name;                                                                 \
2119 static void  __attribute__((constructor)) init_##name(void)             \
2120 {                                                                       \
2121         AST_LIST_HEAD_INIT(&name);                                      \
2122 }                                                                       \
2123 static void  __attribute__((destructor)) fini_##name(void)              \
2124 {                                                                       \
2125         AST_LIST_HEAD_DESTROY(&name);                                   \
2126 }                                                                       \
2127 struct __dummy_##name
2128 #else
2129 #define AST_LIST_HEAD_STATIC(name, type)                                \
2130 struct name {                                                           \
2131         struct type *first;                                             \
2132         struct type *last;                                              \
2133         ast_mutex_t lock;                                               \
2134 } name = AST_LIST_HEAD_INIT_VALUE
2135 #endif
2136
2137 /*!
2138   \brief Defines a structure to be used to hold a read/write list of specified type, statically initialized.
2139   \param name This will be the name of the defined structure.
2140   \param type This is the type of each list entry.
2141
2142   This macro creates a structure definition that can be used
2143   to hold a list of the entries of type \a type, and allocates an instance
2144   of it, initialized to be empty.
2145
2146   Example usage:
2147   \code
2148   static AST_RWLIST_HEAD_STATIC(entry_list, entry);
2149   \endcode
2150
2151   This would define \c struct \c entry_list, intended to hold a list of
2152   type \c struct \c entry.
2153 */
2154 #ifndef AST_RWLOCK_INIT_VALUE
2155 #define AST_RWLIST_HEAD_STATIC(name, type)                              \
2156 struct name {                                                           \
2157         struct type *first;                                             \
2158         struct type *last;                                              \
2159         ast_rwlock_t lock;                                              \
2160 } name;                                                                 \
2161 static void  __attribute__((constructor)) init_##name(void)            \
2162 {                                                                       \
2163         AST_RWLIST_HEAD_INIT(&name);                                    \
2164 }                                                                       \
2165 static void  __attribute__((destructor)) fini_##name(void)             \
2166 {                                                                       \
2167         AST_RWLIST_HEAD_DESTROY(&name);                                 \
2168 }                                                                       \
2169 struct __dummy_##name
2170 #else
2171 #define AST_RWLIST_HEAD_STATIC(name, type)                              \
2172 struct name {                                                           \
2173         struct type *first;                                             \
2174         struct type *last;                                              \
2175         ast_rwlock_t lock;                                              \
2176 } name = AST_RWLIST_HEAD_INIT_VALUE
2177 #endif
2178
2179 /*!
2180   \brief Defines a structure to be used to hold a list of specified type, statically initialized.
2181
2182   This is the same as AST_LIST_HEAD_STATIC, except without the lock included.
2183 */
2184 #define AST_LIST_HEAD_NOLOCK_STATIC(name, type)                         \
2185 struct name {                                                           \
2186         struct type *first;                                             \
2187         struct type *last;                                              \
2188 } name = AST_LIST_HEAD_NOLOCK_INIT_VALUE
2189
2190 /*!
2191   \brief Initializes a list head structure with a specified first entry.
2192   \param head This is a pointer to the list head structure
2193   \param entry pointer to the list entry that will become the head of the list
2194
2195   This macro initializes a list head structure by setting the head
2196   entry to the supplied value and recreating the embedded lock.
2197 */
2198 #define AST_LIST_HEAD_SET(head, entry) do {                             \
2199         (head)->first = (entry);                                        \
2200         (head)->last = (entry);                                         \
2201         ast_mutex_init(&(head)->lock);                                  \
2202 } while (0)
2203
2204 /*!
2205   \brief Initializes an rwlist head structure with a specified first entry.
2206   \param head This is a pointer to the list head structure
2207   \param entry pointer to the list entry that will become the head of the list
2208
2209   This macro initializes a list head structure by setting the head
2210   entry to the supplied value and recreating the embedded lock.
2211 */
2212 #define AST_RWLIST_HEAD_SET(head, entry) do {                           \
2213         (head)->first = (entry);                                        \
2214         (head)->last = (entry);                                         \
2215         ast_rwlock_init(&(head)->lock);                                 \
2216 } while (0)
2217
2218 /*!
2219   \brief Initializes a list head structure with a specified first entry.
2220   \param head This is a pointer to the list head structure
2221   \param entry pointer to the list entry that will become the head of the list
2222
2223   This macro initializes a list head structure by setting the head
2224   entry to the supplied value.
2225 */
2226 #define AST_LIST_HEAD_SET_NOLOCK(head, entry) do {                      \
2227         (head)->first = (entry);                                        \
2228         (head)->last = (entry);                                         \
2229 } while (0)
2230
2231 /*!
2232   \brief Declare a forward link structure inside a list entry.
2233   \param type This is the type of each list entry.
2234
2235   This macro declares a structure to be used to link list entries together.
2236   It must be used inside the definition of the structure named in
2237   \a type, as follows:
2238
2239   \code
2240   struct list_entry {
2241         ...
2242         AST_LIST_ENTRY(list_entry) list;
2243   }
2244   \endcode
2245
2246   The field name \a list here is arbitrary, and can be anything you wish.
2247 */
2248 #define AST_LIST_ENTRY(type)                                            \
2249 struct {                                                                \
2250         struct type *next;                                              \
2251 }
2252
2253 #define AST_RWLIST_ENTRY AST_LIST_ENTRY
2254  
2255 /*!
2256   \brief Returns the first entry contained in a list.
2257   \param head This is a pointer to the list head structure
2258  */
2259 #define AST_LIST_FIRST(head)    ((head)->first)
2260
2261 #define AST_RWLIST_FIRST AST_LIST_FIRST
2262
2263 /*!
2264   \brief Returns the last entry contained in a list.
2265   \param head This is a pointer to the list head structure
2266  */
2267 #define AST_LIST_LAST(head)     ((head)->last)
2268
2269 #define AST_RWLIST_LAST AST_LIST_LAST
2270
2271 /*!
2272   \brief Returns the next entry in the list after the given entry.
2273   \param elm This is a pointer to the current entry.
2274   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2275   used to link entries of this list together.
2276 */
2277 #define AST_LIST_NEXT(elm, field)       ((elm)->field.next)
2278
2279 #define AST_RWLIST_NEXT AST_LIST_NEXT
2280
2281 /*!
2282   \brief Checks whether the specified list contains any entries.
2283   \param head This is a pointer to the list head structure
2284
2285   Returns non-zero if the list has entries, zero if not.
2286  */
2287 #define AST_LIST_EMPTY(head)    (AST_LIST_FIRST(head) == NULL)
2288
2289 #define AST_RWLIST_EMPTY AST_LIST_EMPTY
2290
2291 /*!
2292   \brief Loops over (traverses) the entries in a list.
2293   \param head This is a pointer to the list head structure
2294   \param var This is the name of the variable that will hold a pointer to the
2295   current list entry on each iteration. It must be declared before calling
2296   this macro.
2297   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2298   used to link entries of this list together.
2299
2300   This macro is use to loop over (traverse) the entries in a list. It uses a
2301   \a for loop, and supplies the enclosed code with a pointer to each list
2302   entry as it loops. It is typically used as follows:
2303   \code
2304   static AST_LIST_HEAD(entry_list, list_entry) entries;
2305   ...
2306   struct list_entry {
2307         ...
2308         AST_LIST_ENTRY(list_entry) list;
2309   }
2310   ...
2311   struct list_entry *current;
2312   ...
2313   AST_LIST_TRAVERSE(&entries, current, list) {
2314      (do something with current here)
2315   }
2316   \endcode
2317   \warning If you modify the forward-link pointer contained in the \a current entry while
2318   inside the loop, the behavior will be unpredictable. At a minimum, the following
2319   macros will modify the forward-link pointer, and should not be used inside
2320   AST_LIST_TRAVERSE() against the entry pointed to by the \a current pointer without
2321   careful consideration of their consequences:
2322   \li AST_LIST_NEXT() (when used as an lvalue)
2323   \li AST_LIST_INSERT_AFTER()
2324   \li AST_LIST_INSERT_HEAD()
2325   \li AST_LIST_INSERT_TAIL()
2326 */
2327 #define AST_LIST_TRAVERSE(head,var,field)                               \
2328         for((var) = (head)->first; (var); (var) = (var)->field.next)
2329
2330 #define AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE
2331
2332 /*!
2333   \brief Loops safely over (traverses) the entries in a list.
2334   \param head This is a pointer to the list head structure
2335   \param var This is the name of the variable that will hold a pointer to the
2336   current list entry on each iteration. It must be declared before calling
2337   this macro.
2338   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2339   used to link entries of this list together.
2340
2341   This macro is used to safely loop over (traverse) the entries in a list. It
2342   uses a \a for loop, and supplies the enclosed code with a pointer to each list
2343   entry as it loops. It is typically used as follows:
2344
2345   \code
2346   static AST_LIST_HEAD(entry_list, list_entry) entries;
2347   ...
2348   struct list_entry {
2349         ...
2350         AST_LIST_ENTRY(list_entry) list;
2351   }
2352   ...
2353   struct list_entry *current;
2354   ...
2355   AST_LIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) {
2356      (do something with current here)
2357   }
2358   AST_LIST_TRAVERSE_SAFE_END;
2359   \endcode
2360
2361   It differs from AST_LIST_TRAVERSE() in that the code inside the loop can modify
2362   (or even free, after calling AST_LIST_REMOVE_CURRENT()) the entry pointed to by
2363   the \a current pointer without affecting the loop traversal.
2364 */
2365 #define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field) {                                \
2366         typeof((head)->first) __list_next;                                              \
2367         typeof((head)->first) __list_prev = NULL;                                       \
2368         typeof((head)->first) __new_prev = NULL;                                        \
2369         for ((var) = (head)->first, __new_prev = (var),                                 \
2370               __list_next = (var) ? (var)->field.next : NULL;                           \
2371              (var);                                                                     \
2372              __list_prev = __new_prev, (var) = __list_next,                             \
2373              __new_prev = (var),                                                        \
2374              __list_next = (var) ? (var)->field.next : NULL                             \
2375             )
2376
2377 #define AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN
2378
2379 /*!
2380   \brief Removes the \a current entry from a list during a traversal.
2381   \param head This is a pointer to the list head structure
2382   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2383   used to link entries of this list together.
2384
2385   \note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
2386   block; it is used to unlink the current entry from the list without affecting
2387   the list traversal (and without having to re-traverse the list to modify the
2388   previous entry, if any).
2389  */
2390 #define AST_LIST_REMOVE_CURRENT(head, field)                                            \
2391         __new_prev->field.next = NULL;                                                  \
2392         __new_prev = __list_prev;                                                       \
2393         if (__list_prev)                                                                \
2394                 __list_prev->field.next = __list_next;                                  \
2395         else                                                                            \
2396                 (head)->first = __list_next;                                            \
2397         if (!__list_next)                                                               \
2398                 (head)->last = __list_prev;
2399
2400 #define AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT
2401
2402 /*!
2403   \brief Inserts a list entry before the current entry during a traversal.
2404   \param head This is a pointer to the list head structure
2405   \param elm This is a pointer to the entry to be inserted.
2406   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2407   used to link entries of this list together.
2408
2409   \note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
2410   block.
2411  */
2412 #define AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field) do {           \
2413         if (__list_prev) {                                              \
2414                 (elm)->field.next = __list_prev->field.next;            \
2415                 __list_prev->field.next = elm;                          \
2416         } else {                                                        \
2417                 (elm)->field.next = (head)->first;                      \
2418                 (head)->first = (elm);                                  \
2419         }                                                               \
2420         __new_prev = (elm);                                             \
2421 } while (0)
2422
2423 #define AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT
2424
2425 /*!
2426   \brief Closes a safe loop traversal block.
2427  */
2428 #define AST_LIST_TRAVERSE_SAFE_END  }
2429
2430 #define AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END
2431
2432 /*!
2433   \brief Initializes a list head structure.
2434   \param head This is a pointer to the list head structure
2435
2436   This macro initializes a list head structure by setting the head
2437   entry to \a NULL (empty list) and recreating the embedded lock.
2438 */
2439 #define AST_LIST_HEAD_INIT(head) {                                      \
2440         (head)->first = NULL;                                           \
2441         (head)->last = NULL;                                            \
2442         ast_mutex_init(&(head)->lock);                                  \
2443 }
2444
2445 /*!
2446   \brief Initializes an rwlist head structure.
2447   \param head This is a pointer to the list head structure
2448
2449   This macro initializes a list head structure by setting the head
2450   entry to \a NULL (empty list) and recreating the embedded lock.
2451 */
2452 #define AST_RWLIST_HEAD_INIT(head) {                                    \
2453         (head)->first = NULL;                                           \
2454         (head)->last = NULL;                                            \
2455         ast_rwlock_init(&(head)->lock);                                 \
2456 }
2457
2458 /*!
2459   \brief Destroys a list head structure.
2460   \param head This is a pointer to the list head structure
2461
2462   This macro destroys a list head structure by setting the head
2463   entry to \a NULL (empty list) and destroying the embedded lock.
2464   It does not free the structure from memory.
2465 */
2466 #define AST_LIST_HEAD_DESTROY(head) {                                   \
2467         (head)->first = NULL;                                           \
2468         (head)->last = NULL;                                            \
2469         ast_mutex_destroy(&(head)->lock);                               \
2470 }
2471
2472 /*!
2473   \brief Destroys an rwlist head structure.
2474   \param head This is a pointer to the list head structure
2475
2476   This macro destroys a list head structure by setting the head
2477   entry to \a NULL (empty list) and destroying the embedded lock.
2478   It does not free the structure from memory.
2479 */
2480 #define AST_RWLIST_HEAD_DESTROY(head) {                                 \
2481         (head)->first = NULL;                                           \
2482         (head)->last = NULL;                                            \
2483         ast_rwlock_destroy(&(head)->lock);                              \
2484 }
2485
2486 /*!
2487   \brief Initializes a list head structure.
2488   \param head This is a pointer to the list head structure
2489
2490   This macro initializes a list head structure by setting the head
2491   entry to \a NULL (empty list). There is no embedded lock handling
2492   with this macro.
2493 */
2494 #define AST_LIST_HEAD_INIT_NOLOCK(head) {                               \
2495         (head)->first = NULL;                                           \
2496         (head)->last = NULL;                                            \
2497 }
2498
2499 /*!
2500   \brief Inserts a list entry after a given entry.
2501   \param head This is a pointer to the list head structure
2502   \param listelm This is a pointer to the entry after which the new entry should
2503   be inserted.
2504   \param elm This is a pointer to the entry to be inserted.
2505   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2506   used to link entries of this list together.
2507  */
2508 #define AST_LIST_INSERT_AFTER(head, listelm, elm, field) do {           \
2509         (elm)->field.next = (listelm)->field.next;                      \
2510         (listelm)->field.next = (elm);                                  \
2511         if ((head)->last == (listelm))                                  \
2512                 (head)->last = (elm);                                   \
2513 } while (0)
2514
2515 #define AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER
2516
2517 /*!
2518   \brief Inserts a list entry at the head of a list.
2519   \param head This is a pointer to the list head structure
2520   \param elm This is a pointer to the entry to be inserted.
2521   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2522   used to link entries of this list together.
2523  */
2524 #define AST_LIST_INSERT_HEAD(head, elm, field) do {                     \
2525                 (elm)->field.next = (head)->first;                      \
2526                 (head)->first = (elm);                                  \
2527                 if (!(head)->last)                                      \
2528                         (head)->last = (elm);                           \
2529 } while (0)
2530
2531 #define AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD
2532
2533 /*!
2534   \brief Appends a list entry to the tail of a list.
2535   \param head This is a pointer to the list head structure
2536   \param elm This is a pointer to the entry to be appended.
2537   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2538   used to link entries of this list together.
2539
2540   Note: The link field in the appended entry is \b not modified, so if it is
2541   actually the head of a list itself, the entire list will be appended
2542   temporarily (until the next AST_LIST_INSERT_TAIL is performed).
2543  */
2544 #define AST_LIST_INSERT_TAIL(head, elm, field) do {                     \
2545       if (!(head)->first) {                                             \
2546                 (head)->first = (elm);                                  \
2547                 (head)->last = (elm);                                   \
2548       } else {                                                          \
2549                 (head)->last->field.next = (elm);                       \
2550                 (head)->last = (elm);                                   \
2551       }                                                                 \
2552 } while (0)
2553
2554 #define AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL
2555
2556 /*!
2557   \brief Appends a whole list to the tail of a list.
2558   \param head This is a pointer to the list head structure
2559   \param list This is a pointer to the list to be appended.
2560   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2561   used to link entries of this list together.
2562  */
2563 #define AST_LIST_APPEND_LIST(head, list, field) do {                    \
2564       if (!(head)->first) {                                             \
2565                 (head)->first = (list)->first;                          \
2566                 (head)->last = (list)->last;                            \
2567       } else {                                                          \
2568                 (head)->last->field.next = (list)->first;               \
2569                 (head)->last = (list)->last;                            \
2570       }                                                                 \
2571 } while (0)
2572
2573 #define AST_RWLIST_APPEND_LIST AST_LIST_APPEND_LIST
2574
2575 /*!
2576   \brief Removes and returns the head entry from a list.
2577   \param head This is a pointer to the list head structure
2578   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2579   used to link entries of this list together.
2580
2581   Removes the head entry from the list, and returns a pointer to it.
2582   This macro is safe to call on an empty list.
2583  */
2584 #define AST_LIST_REMOVE_HEAD(head, field) ({                            \
2585                 typeof((head)->first) cur = (head)->first;              \
2586                 if (cur) {                                              \
2587                         (head)->first = cur->field.next;                \
2588                         cur->field.next = NULL;                         \
2589                         if ((head)->last == cur)                        \
2590                                 (head)->last = NULL;                    \
2591                 }                                                       \
2592                 cur;                                                    \
2593         })
2594
2595 #define AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD
2596
2597 /*!
2598   \brief Removes a specific entry from a list.
2599   \param head This is a pointer to the list head structure
2600   \param elm This is a pointer to the entry to be removed.
2601   \param field This is the name of the field (declared using AST_LIST_ENTRY())
2602   used to link entries of this list together.
2603   \warning The removed entry is \b not freed nor modified in any way.
2604  */
2605 #define AST_LIST_REMOVE(head, elm, field) do {                          \
2606         if ((head)->first == (elm)) {                                   \
2607                 (head)->first = (elm)->field.next;                      \
2608                 if ((head)->last == (elm))                      \
2609                         (head)->last = NULL;                    \
2610         } else {                                                                \
2611                 typeof(elm) curelm = (head)->first;                     \
2612                 while (curelm && (curelm->field.next != (elm)))                 \
2613                         curelm = curelm->field.next;                    \
2614                 if (curelm) { \
2615                         curelm->field.next = (elm)->field.next;                 \
2616                         if ((head)->last == (elm))                              \
2617                                 (head)->last = curelm;                          \
2618                 } \
2619         }                                                               \
2620         (elm)->field.next = NULL;                                       \
2621 } while (0)
2622
2623 #define AST_RWLIST_REMOVE AST_LIST_REMOVE
2624
2625 /* chanvars.h */
2626
2627 struct ast_var_t {
2628         AST_LIST_ENTRY(ast_var_t) entries;
2629         char *value;
2630         char name[0];
2631 };
2632
2633 AST_LIST_HEAD_NOLOCK(varshead, ast_var_t);
2634
2635 AST_RWLOCK_DEFINE_STATIC(globalslock);
2636 static struct varshead globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
2637
2638
2639 /* IN CONFLICT: struct ast_var_t *ast_var_assign(const char *name, const char *value); */
2640
2641 static struct ast_var_t *ast_var_assign(const char *name, const char *value);
2642
2643 static void ast_var_delete(struct ast_var_t *var);
2644
2645 /*from channel.h */
2646 #define AST_MAX_EXTENSION  80      /*!< Max length of an extension */
2647
2648
2649 /* from pbx.h */
2650 #define PRIORITY_HINT   -1      /*!< Special Priority for a hint */
2651
2652 enum ast_extension_states {
2653         AST_EXTENSION_REMOVED = -2,     /*!< Extension removed */
2654         AST_EXTENSION_DEACTIVATED = -1, /*!< Extension hint removed */
2655         AST_EXTENSION_NOT_INUSE = 0,    /*!< No device INUSE or BUSY  */
2656         AST_EXTENSION_INUSE = 1 << 0,   /*!< One or more devices INUSE */
2657         AST_EXTENSION_BUSY = 1 << 1,    /*!< All devices BUSY */
2658         AST_EXTENSION_UNAVAILABLE = 1 << 2, /*!< All devices UNAVAILABLE/UNREGISTERED */
2659         AST_EXTENSION_RINGING = 1 << 3, /*!< All devices RINGING */
2660         AST_EXTENSION_ONHOLD = 1 << 4,  /*!< All devices ONHOLD */
2661 };
2662
2663 struct ast_custom_function {
2664         const char *name;               /*!< Name */
2665         const char *synopsis;           /*!< Short description for "show functions" */
2666         const char *desc;               /*!< Help text that explains it all */
2667         const char *syntax;             /*!< Syntax description */
2668         int (*read)(struct ast_channel *, const char *, char *, char *, size_t);        /*!< Read function, if read is supported */
2669         int (*write)(struct ast_channel *, const char *, char *, const char *);         /*!< Write function, if write is supported */
2670         AST_RWLIST_ENTRY(ast_custom_function) acflist;
2671 };
2672
2673 typedef int (ast_switch_f)(struct ast_channel *chan, const char *context,
2674         const char *exten, int priority, const char *callerid, const char *data);
2675
2676 struct ast_switch {
2677         AST_LIST_ENTRY(ast_switch) list;
2678         const char *name;                       /*!< Name of the switch */
2679         const char *description;                /*!< Description of the switch */
2680         
2681         ast_switch_f *exists;
2682         ast_switch_f *canmatch;
2683         ast_switch_f *exec;
2684         ast_switch_f *matchmore;
2685 };
2686
2687
2688 static char *config_filename = "extensions.conf";
2689 static char *global_registrar = "conf2ael";
2690 static char userscontext[AST_MAX_EXTENSION] = "default";
2691 static int static_config = 0;
2692 static int write_protect_config = 1;
2693 static int autofallthrough_config = 0;
2694 static int clearglobalvars_config = 0;
2695 static void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
2696
2697
2698 /* stolen from callerid.c */
2699
2700 /*! \brief Clean up phone string
2701  * remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets.
2702  * Basically, remove anything that could be invalid in a pattern.
2703  */
2704 static void ast_shrink_phone_number(char *n)
2705 {
2706         int x, y=0;
2707         int bracketed = 0;
2708
2709         for (x=0; n[x]; x++) {
2710                 switch(n[x]) {
2711                 case '[':
2712                         bracketed++;
2713                         n[y++] = n[x];
2714                         break;
2715                 case ']':
2716                         bracketed--;
2717                         n[y++] = n[x];
2718                         break;
2719                 case '-':
2720                         if (bracketed)
2721                                 n[y++] = n[x];
2722                         break;
2723                 case '.':
2724                         if (!n[x+1])
2725                                 n[y++] = n[x];
2726                         break;
2727                 default:
2728                         if (!strchr("()", n[x]))
2729                                 n[y++] = n[x];
2730                 }
2731         }
2732         n[y] = '\0';
2733 }
2734
2735
2736 /* stolen from chanvars.c */
2737
2738 static const char *ast_var_name(const struct ast_var_t *var)
2739 {
2740         const char *name;
2741
2742         if (var == NULL || (name = var->name) == NULL)
2743                 return NULL;
2744         /* Return the name without the initial underscores */
2745         if (name[0] == '_') {
2746                 name++;
2747                 if (name[0] == '_')
2748                         name++;
2749         }
2750         return name;
2751 }
2752
2753 /* experiment 1: see if it's easier just to use existing config code
2754  *               to read in the extensions.conf file. In this scenario, 
2755                  I have to rip/copy code from other modules, because they
2756                  are staticly declared as-is. A solution would be to move
2757                  the ripped code to another location and make them available
2758                  to other modules and standalones */
2759
2760 /* Our own version of ast_log, since the expr parser uses it. -- stolen from utils/check_expr.c */
2761
2762 static void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
2763 {
2764         va_list vars;
2765         va_start(vars,fmt);
2766         
2767         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
2768                    level, file, line, function);
2769         vprintf(fmt, vars);
2770         fflush(stdout);
2771         va_end(vars);
2772 }
2773
2774 void __attribute__((format(printf, 1, 2))) ast_verbose(const char *fmt, ...)
2775 {
2776         va_list vars;
2777         va_start(vars,fmt);
2778         
2779         printf("VERBOSE: ");
2780         vprintf(fmt, vars);
2781         fflush(stdout);
2782         va_end(vars);
2783 }
2784
2785 /* stolen from main/utils.c */
2786 static char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
2787 {
2788         char *dataPut = start;
2789         int inEscape = 0;
2790         int inQuotes = 0;
2791
2792         for (; *start; start++) {
2793                 if (inEscape) {
2794                         *dataPut++ = *start;       /* Always goes verbatim */
2795                         inEscape = 0;
2796                 } else {
2797                         if (*start == '\\') {
2798                                 inEscape = 1;      /* Do not copy \ into the data */
2799                         } else if (*start == '\'') {
2800                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
2801                         } else {
2802                                 /* Replace , with |, unless in quotes */
2803                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
2804                         }
2805                 }
2806         }
2807         if (start != dataPut)
2808                 *dataPut = 0;
2809         return dataPut;
2810 }
2811
2812 static int ast_true(const char *s)
2813 {
2814         if (ast_strlen_zero(s))
2815                 return 0;
2816
2817         /* Determine if this is a true value */
2818         if (!strcasecmp(s, "yes") ||
2819             !strcasecmp(s, "true") ||
2820             !strcasecmp(s, "y") ||
2821             !strcasecmp(s, "t") ||
2822             !strcasecmp(s, "1") ||
2823             !strcasecmp(s, "on"))
2824                 return -1;
2825
2826         return 0;
2827 }
2828
2829 #define ONE_MILLION     1000000
2830 /*
2831  * put timeval in a valid range. usec is 0..999999
2832  * negative values are not allowed and truncated.
2833  */
2834 static struct timeval tvfix(struct timeval a)
2835 {
2836         if (a.tv_usec >= ONE_MILLION) {
2837                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
2838                         (long)a.tv_sec, (long int) a.tv_usec);
2839                 a.tv_sec += a.tv_usec / ONE_MILLION;
2840                 a.tv_usec %= ONE_MILLION;
2841         } else if (a.tv_usec < 0) {
2842                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
2843                         (long)a.tv_sec, (long int) a.tv_usec);
2844                 a.tv_usec = 0;
2845         }
2846         return a;
2847 }
2848
2849 struct timeval ast_tvadd(struct timeval a, struct timeval b);
2850 struct timeval ast_tvadd(struct timeval a, struct timeval b)
2851 {
2852         /* consistency checks to guarantee usec in 0..999999 */
2853         a = tvfix(a);
2854         b = tvfix(b);
2855         a.tv_sec += b.tv_sec;
2856         a.tv_usec += b.tv_usec;
2857         if (a.tv_usec >= ONE_MILLION) {
2858                 a.tv_sec++;
2859                 a.tv_usec -= ONE_MILLION;
2860         }
2861         return a;
2862 }
2863
2864 struct timeval ast_tvsub(struct timeval a, struct timeval b);
2865 struct timeval ast_tvsub(struct timeval a, struct timeval b)
2866 {
2867         /* consistency checks to guarantee usec in 0..999999 */
2868         a = tvfix(a);
2869         b = tvfix(b);
2870         a.tv_sec -= b.tv_sec;
2871         a.tv_usec -= b.tv_usec;
2872         if (a.tv_usec < 0) {
2873                 a.tv_sec-- ;
2874                 a.tv_usec += ONE_MILLION;
2875         }
2876         return a;
2877 }
2878 #undef ONE_MILLION
2879
2880 void ast_mark_lock_failed(void *lock_addr);
2881 void ast_mark_lock_failed(void *lock_addr)
2882 {
2883         /* Pretend to do something. */
2884 }
2885
2886 /* stolen from pbx.c */
2887 #define VAR_BUF_SIZE 4096
2888
2889 #define VAR_NORMAL              1
2890 #define VAR_SOFTTRAN    2
2891 #define VAR_HARDTRAN    3
2892
2893 #define BACKGROUND_SKIP         (1 << 0)
2894 #define BACKGROUND_NOANSWER     (1 << 1)
2895 #define BACKGROUND_MATCHEXTEN   (1 << 2)
2896 #define BACKGROUND_PLAYBACK     (1 << 3)
2897
2898 /*!
2899    \brief ast_exten: An extension
2900         The dialplan is saved as a linked list with each context
2901         having it's own linked list of extensions - one item per
2902         priority.
2903 */
2904 struct ast_exten {
2905         char *exten;                    /*!< Extension name */
2906         int matchcid;                   /*!< Match caller id ? */
2907         const char *cidmatch;           /*!< Caller id to match for this extension */
2908         int priority;                   /*!< Priority */
2909         const char *label;              /*!< Label */
2910         struct ast_context *parent;     /*!< The context this extension belongs to  */
2911         const char *app;                /*!< Application to execute */
2912         struct ast_app *cached_app;     /*!< Cached location of application */
2913         void *data;                     /*!< Data to use (arguments) */
2914         void (*datad)(void *);          /*!< Data destructor */
2915         struct ast_exten *peer;         /*!< Next higher priority with our extension */
2916         const char *registrar;          /*!< Registrar */
2917         struct ast_exten *next;         /*!< Extension with a greater ID */
2918         char stuff[0];
2919 };
2920 /* from pbx.h */
2921 typedef int (*ast_state_cb_type)(char *context, char* id, enum ast_extension_states state, void *data);
2922 struct ast_timing {
2923         int hastime;                            /*!< If time construct exists */
2924         unsigned int monthmask;                 /*!< Mask for month */
2925         unsigned int daymask;                   /*!< Mask for date */
2926         unsigned int dowmask;                   /*!< Mask for day of week (mon-sun) */
2927         unsigned int minmask[48];               /*!< Mask for minute */
2928         char *timezone;                 /*!< NULL, or zoneinfo style timezone */
2929 };
2930 /* end of pbx.h */
2931 /*! \brief ast_include: include= support in extensions.conf */
2932 struct ast_include {
2933         const char *name;
2934         const char *rname;                      /*!< Context to include */
2935         const char *registrar;                  /*!< Registrar */
2936         int hastime;                            /*!< If time construct exists */
2937         struct ast_timing timing;               /*!< time construct */
2938         struct ast_include *next;               /*!< Link them together */
2939         char stuff[0];
2940 };
2941
2942 /*! \brief ast_sw: Switch statement in extensions.conf */
2943 struct ast_sw {
2944         char *name;
2945         const char *registrar;                  /*!< Registrar */
2946         char *data;                             /*!< Data load */
2947         int eval;
2948         AST_LIST_ENTRY(ast_sw) list;
2949         char *tmpdata;
2950         char stuff[0];
2951 };
2952
2953 /*! \brief ast_ignorepat: Ignore patterns in dial plan */
2954 struct ast_ignorepat {
2955         const char *registrar;
2956         struct ast_ignorepat *next;
2957         char pattern[0];
2958 };
2959
2960 /*! \brief ast_context: An extension context */
2961 struct ast_context {
2962         ast_rwlock_t lock;                      /*!< A lock to prevent multiple threads from clobbering the context */
2963         struct ast_exten *root;                 /*!< The root of the list of extensions */
2964         struct ast_context *next;               /*!< Link them together */
2965         struct ast_include *includes;           /*!< Include other contexts */
2966         struct ast_ignorepat *ignorepats;       /*!< Patterns for which to continue playing dialtone */
2967         const char *registrar;                  /*!< Registrar */
2968         AST_LIST_HEAD_NOLOCK(, ast_sw) alts;    /*!< Alternative switches */
2969         ast_mutex_t macrolock;                  /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */
2970         char name[0];                           /*!< Name of the context */
2971 };
2972
2973
2974 /*! \brief ast_app: A registered application */
2975 struct ast_app {
2976         int (*execute)(struct ast_channel *chan, void *data);
2977         const char *synopsis;                   /*!< Synopsis text for 'show applications' */
2978         const char *description;                /*!< Description (help text) for 'show application &lt;name&gt;' */
2979         AST_RWLIST_ENTRY(ast_app) list;         /*!< Next app in list */
2980         void *module;                   /*!< Module this app belongs to */
2981         char name[0];                           /*!< Name of the application */
2982 };
2983
2984
2985 /*! \brief ast_state_cb: An extension state notify register item */
2986 struct ast_state_cb {
2987         int id;
2988         void *data;
2989         ast_state_cb_type callback;
2990         struct ast_state_cb *next;
2991 };
2992
2993 /*! \brief Structure for dial plan hints
2994
2995   \note Hints are pointers from an extension in the dialplan to one or
2996   more devices (tech/name) 
2997         - See \ref AstExtState
2998 */
2999 struct ast_hint {
3000         struct ast_exten *exten;        /*!< Extension */
3001         int laststate;                  /*!< Last known state */
3002         struct ast_state_cb *callbacks; /*!< Callback list for this extension */
3003         AST_RWLIST_ENTRY(ast_hint) list;/*!< Pointer to next hint in list */
3004 };
3005
3006 struct store_hint {
3007         char *context;
3008         char *exten;
3009         struct ast_state_cb *callbacks;
3010         int laststate;
3011         AST_LIST_ENTRY(store_hint) list;
3012         char data[1];
3013 };
3014
3015 AST_LIST_HEAD(store_hints, store_hint);
3016
3017 static const struct cfextension_states {
3018         int extension_state;
3019         const char * const text;
3020 } extension_states[] = {
3021         { AST_EXTENSION_NOT_INUSE,                     "Idle" },
3022         { AST_EXTENSION_INUSE,                         "InUse" },
3023         { AST_EXTENSION_BUSY,                          "Busy" },
3024         { AST_EXTENSION_UNAVAILABLE,                   "Unavailable" },
3025         { AST_EXTENSION_RINGING,                       "Ringing" },
3026         { AST_EXTENSION_INUSE | AST_EXTENSION_RINGING, "InUse&Ringing" },
3027         { AST_EXTENSION_ONHOLD,                        "Hold" },
3028         { AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD,  "InUse&Hold" }
3029 };
3030 #define STATUS_NO_CONTEXT       1
3031 #define STATUS_NO_EXTENSION     2
3032 #define STATUS_NO_PRIORITY      3
3033 #define STATUS_NO_LABEL         4
3034 #define STATUS_SUCCESS          5
3035
3036
3037 #if defined ( __i386__) && (defined(__FreeBSD__) || defined(linux))
3038 #if defined(__FreeBSD__)
3039 #include <machine/cpufunc.h>
3040 #elif defined(linux)
3041 static __inline uint64_t
3042 rdtsc(void)
3043
3044         uint64_t rv;
3045
3046         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
3047         return (rv);
3048 }
3049 #endif
3050 #else   /* supply a dummy function on other platforms */
3051 static __inline uint64_t
3052 rdtsc(void)
3053 {
3054         return 0;
3055 }
3056 #endif
3057
3058
3059 static struct ast_var_t *ast_var_assign(const char *name, const char *value)
3060 {       
3061         struct ast_var_t *var;
3062         int name_len = strlen(name) + 1;
3063         int value_len = strlen(value) + 1;
3064
3065         if (!(var = ast_calloc(sizeof(*var) + name_len + value_len, sizeof(char)))) {
3066                 return NULL;
3067         }
3068
3069         ast_copy_string(var->name, name, name_len);
3070         var->value = var->name + name_len;
3071         ast_copy_string(var->value, value, value_len);
3072         
3073         return var;
3074 }       
3075         
3076 static void ast_var_delete(struct ast_var_t *var)
3077 {
3078         free(var);
3079 }
3080
3081
3082 /* chopped this one off at the knees! */
3083 static int ast_func_write(struct ast_channel *chan, const char *function, const char *value)
3084 {
3085
3086         /* ast_log(LOG_ERROR, "Function %s not registered\n", function); we are not interested in the details here */
3087
3088         return -1;
3089 }
3090
3091 static unsigned int ast_app_separate_args(char *buf, char delim, char **array, int arraylen)
3092 {
3093         int argc;
3094         char *scan;
3095         int paren = 0, quote = 0;
3096
3097         if (!buf || !array || !arraylen)
3098                 return 0;
3099
3100         memset(array, 0, arraylen * sizeof(*array));
3101
3102         scan = buf;
3103
3104         for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
3105                 array[argc] = scan;
3106                 for (; *scan; scan++) {
3107                         if (*scan == '(')
3108                                 paren++;
3109                         else if (*scan == ')') {
3110                                 if (paren)
3111                                         paren--;
3112                         } else if (*scan == '"' && delim != '"') {
3113                                 quote = quote ? 0 : 1;
3114                                 /* Remove quote character from argument */
3115                                 memmove(scan, scan + 1, strlen(scan));
3116                                 scan--;
3117                         } else if (*scan == '\\') {
3118                                 /* Literal character, don't parse */
3119                                 memmove(scan, scan + 1, strlen(scan));
3120                         } else if ((*scan == delim) && !paren && !quote) {
3121                                 *scan++ = '\0';
3122                                 break;
3123                         }
3124                 }
3125         }
3126
3127         if (*scan)
3128                 array[argc++] = scan;
3129
3130         return argc;
3131 }
3132
3133 static void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
3134 {
3135         struct ast_var_t *newvariable;
3136         struct varshead *headp;
3137         const char *nametail = name;
3138
3139         /* XXX may need locking on the channel ? */
3140         if (name[strlen(name)-1] == ')') {
3141                 char *function = ast_strdupa(name);
3142
3143                 ast_func_write(chan, function, value);
3144                 return;
3145         }
3146
3147         headp = &globals;
3148
3149         /* For comparison purposes, we have to strip leading underscores */
3150         if (*nametail == '_') {
3151                 nametail++;
3152                 if (*nametail == '_')
3153                         nametail++;
3154         }
3155
3156         AST_LIST_TRAVERSE (headp, newvariable, entries) {
3157                 if (strcasecmp(ast_var_name(newvariable), nametail) == 0) {
3158                         /* there is already such a variable, delete it */
3159                         AST_LIST_REMOVE(headp, newvariable, entries);
3160                         ast_var_delete(newvariable);
3161                         break;
3162                 }
3163         }
3164
3165         if (value && (newvariable = ast_var_assign(name, value))) {
3166                 if ((option_verbose > 1) && (headp == &globals))
3167                         ast_verbose(VERBOSE_PREFIX_2 "Setting global variable '%s' to '%s'\n", name, value);
3168                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
3169         }
3170
3171 }
3172
3173 static int pbx_builtin_setvar(struct ast_channel *chan, const void *data)
3174 {
3175         char *name, *value, *mydata;
3176         int argc;
3177         char *argv[24];         /* this will only support a maximum of 24 variables being set in a single operation */
3178         int global = 0;
3179         int x;
3180
3181         if (ast_strlen_zero(data)) {
3182                 ast_log(LOG_WARNING, "Set requires at least one variable name/value pair.\n");
3183                 return 0;
3184         }
3185
3186         mydata = ast_strdupa(data);
3187         argc = ast_app_separate_args(mydata, '|', argv, sizeof(argv) / sizeof(argv[0]));
3188
3189         /* check for a trailing flags argument */
3190         if ((argc > 1) && !strchr(argv[argc-1], '=')) {
3191                 argc--;
3192                 if (strchr(argv[argc], 'g'))
3193                         global = 1;
3194         }
3195
3196         for (x = 0; x < argc; x++) {
3197                 name = argv[x];
3198                 if ((value = strchr(name, '='))) {
3199                         *value++ = '\0';
3200                         pbx_builtin_setvar_helper((global) ? NULL : chan, name, value);
3201                 } else
3202                         ast_log(LOG_WARNING, "Ignoring entry '%s' with no = (and not last 'options' entry)\n", name);
3203         }
3204
3205         return(0);
3206 }
3207
3208 int localized_pbx_builtin_setvar(struct ast_channel *chan, const void *data);
3209
3210 int localized_pbx_builtin_setvar(struct ast_channel *chan, const void *data)
3211 {
3212         return pbx_builtin_setvar(chan, data);
3213 }
3214
3215
3216 /*! \brief Helper for get_range.
3217  * return the index of the matching entry, starting from 1.
3218  * If names is not supplied, try numeric values.
3219  */
3220 static int lookup_name(const char *s, char *const names[], int max)
3221 {
3222         int i;
3223
3224         if (names && *s > '9') {
3225                 for (i = 0; names[i]; i++) {
3226                         if (!strcasecmp(s, names[i])) {
3227                                 return i;
3228                         }
3229                 }
3230         }
3231
3232         /* Allow months and weekdays to be specified as numbers, as well */
3233         if (sscanf(s, "%2d", &i) == 1 && i >= 1 && i <= max) {
3234                 /* What the array offset would have been: "1" would be at offset 0 */
3235                 return i - 1;
3236         }
3237         return -1; /* error return */
3238 }
3239
3240 /*! \brief helper function to return a range up to max (7, 12, 31 respectively).
3241  * names, if supplied, is an array of names that should be mapped to numbers.
3242  */
3243 static unsigned get_range(char *src, int max, char *const names[], const char *msg)
3244 {
3245         int start, end; /* start and ending position */
3246         unsigned int mask = 0;
3247         char *part;
3248
3249         /* Check for whole range */
3250         if (ast_strlen_zero(src) || !strcmp(src, "*")) {
3251                 return (1 << max) - 1;
3252         }
3253
3254         while ((part = strsep(&src, "&"))) {
3255                 /* Get start and ending position */
3256                 char *endpart = strchr(part, '-');
3257                 if (endpart) {
3258                         *endpart++ = '\0';
3259                 }
3260                 /* Find the start */
3261                 if ((start = lookup_name(part, names, max)) < 0) {
3262                         ast_log(LOG_WARNING, "Invalid %s '%s', skipping element\n", msg, part);
3263                         continue;
3264                 }
3265                 if (endpart) { /* find end of range */
3266                         if ((end = lookup_name(endpart, names, max)) < 0) {
3267                                 ast_log(LOG_WARNING, "Invalid end %s '%s', skipping element\n", msg, endpart);
3268                                 continue;
3269                         }
3270                 } else {
3271                         end = start;
3272                 }
3273                 /* Fill the mask. Remember that ranges are cyclic */
3274                 mask |= (1 << end);   /* initialize with last element */
3275                 while (start != end) {
3276                         if (start >= max) {
3277                                 start = 0;
3278                         }
3279                         mask |= (1 << start);
3280                         start++;
3281                 }
3282         }
3283         return mask;
3284 }
3285
3286 /*! \brief store a bitmask of valid times, one bit each 2 minute */
3287 static void get_timerange(struct ast_timing *i, char *times)
3288 {
3289         char *endpart, *part;
3290         int x;
3291         int st_h, st_m;
3292         int endh, endm;
3293         int minute_start, minute_end;
3294
3295         /* start disabling all times, fill the fields with 0's, as they may contain garbage */
3296         memset(i->minmask, 0, sizeof(i->minmask));
3297
3298         /* 1-minute per bit */
3299         /* Star is all times */
3300         if (ast_strlen_zero(times) || !strcmp(times, "*")) {
3301                 /* 48, because each hour takes 2 integers; 30 bits each */
3302                 for (x = 0; x < 48; x++) {
3303                         i->minmask[x] = 0x3fffffff; /* 30 bits */
3304                 }
3305                 return;
3306         }
3307         /* Otherwise expect a range */
3308         while ((part = strsep(&times, "&"))) {
3309                 if (!(endpart = strchr(part, '-'))) {
3310                         if (sscanf(part, "%2d:%2d", &st_h, &st_m) != 2 || st_h < 0 || st_h > 23 || st_m < 0 || st_m > 59) {
3311                                 ast_log(LOG_WARNING, "%s isn't a valid time.\n", part);
3312                                 continue;
3313                         }
3314                         i->minmask[st_h * 2 + (st_m >= 30 ? 1 : 0)] |= (1 << (st_m % 30));
3315                         continue;
3316                 }