Check result of ast_var_assign() calls for memory allocation failure.
[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
99 /* logger.h */
100
101 #define EVENTLOG "event_log"
102 #define QUEUELOG        "queue_log"
103
104 #define DEBUG_M(a) { \
105         a; \
106 }
107
108 #define VERBOSE_PREFIX_1 " "
109 #define VERBOSE_PREFIX_2 "  == "
110 #define VERBOSE_PREFIX_3 "    -- "
111 #define VERBOSE_PREFIX_4 "       > "
112
113 void ast_log_backtrace(void);
114
115 void ast_queue_log(const char *queuename, const char *callid, const char *agent, const char *event, const char *fmt, ...)
116         __attribute__((format(printf, 5, 6)));
117
118 /* IN CONFLICT: void ast_verbose(const char *fmt, ...)
119    __attribute__((format(printf, 1, 2))); */
120
121 int ast_register_verbose(void (*verboser)(const char *string));
122 int ast_unregister_verbose(void (*verboser)(const char *string));
123
124 void ast_console_puts(const char *string);
125
126 #define _A_ __FILE__, __LINE__, __PRETTY_FUNCTION__
127
128 #ifdef LOG_DEBUG
129 #undef LOG_DEBUG
130 #endif
131 #define __LOG_DEBUG    0
132 #define LOG_DEBUG      __LOG_DEBUG, _A_
133
134 #ifdef LOG_EVENT
135 #undef LOG_EVENT
136 #endif
137 #define __LOG_EVENT    1
138 #define LOG_EVENT      __LOG_EVENT, _A_
139
140 #ifdef LOG_NOTICE
141 #undef LOG_NOTICE
142 #endif
143 #define __LOG_NOTICE   2
144 #define LOG_NOTICE     __LOG_NOTICE, _A_
145
146 #ifdef LOG_WARNING
147 #undef LOG_WARNING
148 #endif
149 #define __LOG_WARNING  3
150 #define LOG_WARNING    __LOG_WARNING, _A_
151
152 #ifdef LOG_ERROR
153 #undef LOG_ERROR
154 #endif
155 #define __LOG_ERROR    4
156 #define LOG_ERROR      __LOG_ERROR, _A_
157
158 #ifdef LOG_VERBOSE
159 #undef LOG_VERBOSE
160 #endif
161 #define __LOG_VERBOSE  5
162 #define LOG_VERBOSE    __LOG_VERBOSE, _A_
163
164 #ifdef LOG_DTMF
165 #undef LOG_DTMF
166 #endif
167 #define __LOG_DTMF  6
168 #define LOG_DTMF    __LOG_DTMF, _A_
169
170 /* lock.h */
171 #define _ASTERISK_LOCK_H /* A small indication that this is horribly wrong. */
172
173 #ifndef HAVE_MTX_PROFILE
174 #define __MTX_PROF(a)   return pthread_mutex_lock((a))
175 #else
176 int mtx_prof = -1;
177
178 #define __MTX_PROF(a)   do {                    \
179         int i;                                  \
180         /* profile only non-blocking events */  \
181         ast_mark(mtx_prof, 1);                  \
182         i = pthread_mutex_trylock((a));         \
183         ast_mark(mtx_prof, 0);                  \
184         if (!i)                                 \
185                 return i;                       \
186         else                                    \
187                 return pthread_mutex_lock((a)); \
188         } while (0)
189 #endif  /* HAVE_MTX_PROFILE */
190
191 #define AST_PTHREADT_NULL (pthread_t) -1
192 #define AST_PTHREADT_STOP (pthread_t) -2
193
194 #if defined(SOLARIS) || defined(BSD)
195 #define AST_MUTEX_INIT_W_CONSTRUCTORS
196 #endif /* SOLARIS || BSD */
197
198 /* Asterisk REQUIRES recursive (not error checking) mutexes
199    and will not run without them. */
200 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) && defined(PTHREAD_MUTEX_RECURSIVE_NP)
201 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
202 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE_NP
203 #else
204 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_MUTEX_INITIALIZER
205 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE
206 #endif /* PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP */
207
208 #ifdef DEBUG_THREADS
209
210 #define __ast_mutex_logger(...)  do { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); } while (0)
211
212 #ifdef THREAD_CRASH
213 #define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
214 #else
215 #define DO_THREAD_CRASH do { } while (0)
216 #endif
217
218 #define AST_MUTEX_INIT_VALUE { PTHREAD_MUTEX_INIT_VALUE, { NULL }, { 0 }, 0, { NULL }, { 0 } }
219
220 #define AST_MAX_REENTRANCY 10
221
222 struct ast_mutex_info {
223         pthread_mutex_t mutex;
224         /*! Track which thread holds this lock */
225         unsigned int track:1;
226         const char *file[AST_MAX_REENTRANCY];
227         int lineno[AST_MAX_REENTRANCY];
228         int reentrancy;
229         const char *func[AST_MAX_REENTRANCY];
230         pthread_t thread[AST_MAX_REENTRANCY];
231 };
232
233 typedef struct ast_mutex_info ast_mutex_t;
234
235 typedef pthread_cond_t ast_cond_t;
236
237 static pthread_mutex_t empty_mutex;
238
239 static void __attribute__((constructor)) init_empty_mutex(void)
240 {
241         memset(&empty_mutex, 0, sizeof(empty_mutex));
242 }
243
244 static inline int __ast_pthread_mutex_init_attr(const char *filename, int lineno, const char *func,
245                                                 const char *mutex_name, ast_mutex_t *t,
246                                                 pthread_mutexattr_t *attr) 
247 {
248 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
249         int canlog = strcmp(filename, "logger.c");
250
251         if ((t->mutex) != ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
252                 if ((t->mutex) != (empty_mutex)) {
253                         __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is already initialized.\n",
254                                            filename, lineno, func, mutex_name);
255                         __ast_mutex_logger("%s line %d (%s): Error: previously initialization of mutex '%s'.\n",
256                                            t->file[0], t->lineno[0], t->func[0], mutex_name);
257                         DO_THREAD_CRASH;
258                         return 0;
259                 }
260         }
261 #endif
262
263         t->file[0] = filename;
264         t->lineno[0] = lineno;
265         t->func[0] = func;
266         t->thread[0]  = 0;
267         t->reentrancy = 0;
268
269         return pthread_mutex_init(&t->mutex, attr);
270 }
271
272 static inline int __ast_pthread_mutex_init(const char *filename, int lineno, const char *func,
273                                            const char *mutex_name, ast_mutex_t *t)
274 {
275         static pthread_mutexattr_t  attr;
276
277         pthread_mutexattr_init(&attr);
278         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
279
280         return __ast_pthread_mutex_init_attr(filename, lineno, func, mutex_name, t, &attr);
281 }
282 #define ast_mutex_init(pmutex) __ast_pthread_mutex_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
283
284 static inline int __ast_pthread_mutex_destroy(const char *filename, int lineno, const char *func,
285                                                 const char *mutex_name, ast_mutex_t *t)
286 {
287         int res;
288         int canlog = strcmp(filename, "logger.c");
289
290 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
291         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
292                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
293                                    filename, lineno, func, mutex_name);
294         }
295 #endif
296
297         res = pthread_mutex_trylock(&t->mutex);
298         switch (res) {
299         case 0:
300                 pthread_mutex_unlock(&t->mutex);
301                 break;
302         case EINVAL:
303                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
304                                   filename, lineno, func, mutex_name);
305                 break;
306         case EBUSY:
307                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
308                                    filename, lineno, func, mutex_name);
309                 __ast_mutex_logger("%s line %d (%s): Error: '%s' was locked here.\n",
310                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
311                 break;
312         }
313
314         if ((res = pthread_mutex_destroy(&t->mutex)))
315                 __ast_mutex_logger("%s line %d (%s): Error destroying mutex: %s\n",
316                                    filename, lineno, func, strerror(res));
317 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
318         else
319                 t->mutex = PTHREAD_MUTEX_INIT_VALUE;
320 #endif
321         t->file[0] = filename;
322         t->lineno[0] = lineno;
323         t->func[0] = func;
324
325         return res;
326 }
327
328 static inline int __ast_pthread_mutex_lock(const char *filename, int lineno, const char *func,
329                                            const char* mutex_name, ast_mutex_t *t)
330 {
331         int res;
332         int canlog = strcmp(filename, "logger.c");
333
334 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
335         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
336                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
337                                  filename, lineno, func, mutex_name);
338                 ast_mutex_init(t);
339         }
340 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
341
342 #ifdef DETECT_DEADLOCKS
343         {
344                 time_t seconds = time(NULL);
345                 time_t current;
346                 do {
347 #ifdef  HAVE_MTX_PROFILE
348                         ast_mark(mtx_prof, 1);
349 #endif
350                         res = pthread_mutex_trylock(&t->mutex);
351 #ifdef  HAVE_MTX_PROFILE
352                         ast_mark(mtx_prof, 0);
353 #endif
354                         if (res == EBUSY) {
355                                 current = time(NULL);
356                                 if ((current - seconds) && (!((current - seconds) % 5))) {
357                                         __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
358                                                            filename, lineno, func, (int)(current - seconds), mutex_name);
359                                         __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
360                                                            t->file[t->reentrancy-1], t->lineno[t->reentrancy-1],
361                                                            t->func[t->reentrancy-1], mutex_name);
362                                 }
363                                 usleep(200);
364                         }
365                 } while (res == EBUSY);
366         }
367 #else
368 #ifdef  HAVE_MTX_PROFILE
369         ast_mark(mtx_prof, 1);
370         res = pthread_mutex_trylock(&t->mutex);
371         ast_mark(mtx_prof, 0);
372         if (res)
373 #endif
374         res = pthread_mutex_lock(&t->mutex);
375 #endif /* DETECT_DEADLOCKS */
376
377         if (!res) {
378                 if (t->reentrancy < AST_MAX_REENTRANCY) {
379                         t->file[t->reentrancy] = filename;
380                         t->lineno[t->reentrancy] = lineno;
381                         t->func[t->reentrancy] = func;
382                         t->thread[t->reentrancy] = pthread_self();
383                         t->reentrancy++;
384                 } else {
385                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
386                                                            filename, lineno, func, mutex_name);
387                 }
388         } else {
389                 __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
390                                    filename, lineno, func, strerror(errno));
391                 DO_THREAD_CRASH;
392         }
393
394         return res;
395 }
396
397 static inline int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func,
398                                               const char* mutex_name, ast_mutex_t *t)
399 {
400         int res;
401         int canlog = strcmp(filename, "logger.c");
402
403 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
404         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
405                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
406                                    filename, lineno, func, mutex_name);
407                 ast_mutex_init(t);
408         }
409 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
410
411         if (!(res = pthread_mutex_trylock(&t->mutex))) {
412                 if (t->reentrancy < AST_MAX_REENTRANCY) {
413                         t->file[t->reentrancy] = filename;
414                         t->lineno[t->reentrancy] = lineno;
415                         t->func[t->reentrancy] = func;
416                         t->thread[t->reentrancy] = pthread_self();
417                         t->reentrancy++;
418                 } else {
419                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
420                                            filename, lineno, func, mutex_name);
421                 }
422         } else {
423                 __ast_mutex_logger("%s line %d (%s): Warning: '%s' was locked here.\n",
424                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
425         }
426
427         return res;
428 }
429
430 static inline int __ast_pthread_mutex_unlock(const char *filename, int lineno, const char *func,
431                                              const char *mutex_name, ast_mutex_t *t)
432 {
433         int res;
434         int canlog = strcmp(filename, "logger.c");
435
436 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
437         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
438                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
439                                    filename, lineno, func, mutex_name);
440         }
441 #endif
442
443         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
444                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
445                                    filename, lineno, func, mutex_name);
446                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
447                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
448                 DO_THREAD_CRASH;
449         }
450
451         if (--t->reentrancy < 0) {
452                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
453                                    filename, lineno, func, mutex_name);
454                 t->reentrancy = 0;
455         }
456
457         if (t->reentrancy < AST_MAX_REENTRANCY) {
458                 t->file[t->reentrancy] = NULL;
459                 t->lineno[t->reentrancy] = 0;
460                 t->func[t->reentrancy] = NULL;
461                 t->thread[t->reentrancy] = 0;
462         }
463
464         if ((res = pthread_mutex_unlock(&t->mutex))) {
465                 __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n", 
466                                    filename, lineno, func, strerror(res));
467                 DO_THREAD_CRASH;
468         }
469
470         return res;
471 }
472
473 static inline int __ast_cond_init(const char *filename, int lineno, const char *func,
474                                   const char *cond_name, ast_cond_t *cond, pthread_condattr_t *cond_attr)
475 {
476         return pthread_cond_init(cond, cond_attr);
477 }
478
479 static inline int __ast_cond_signal(const char *filename, int lineno, const char *func,
480                                     const char *cond_name, ast_cond_t *cond)
481 {
482         return pthread_cond_signal(cond);
483 }
484
485 static inline int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
486                                        const char *cond_name, ast_cond_t *cond)
487 {
488         return pthread_cond_broadcast(cond);
489 }
490
491 static inline int __ast_cond_destroy(const char *filename, int lineno, const char *func,
492                                      const char *cond_name, ast_cond_t *cond)
493 {
494         return pthread_cond_destroy(cond);
495 }
496
497 static inline int __ast_cond_wait(const char *filename, int lineno, const char *func,
498                                   const char *cond_name, const char *mutex_name,
499                                   ast_cond_t *cond, ast_mutex_t *t)
500 {
501         int res;
502         int canlog = strcmp(filename, "logger.c");
503
504 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
505         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
506                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
507                                    filename, lineno, func, mutex_name);
508         }
509 #endif
510
511         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
512                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
513                                    filename, lineno, func, mutex_name);
514                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
515                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
516                 DO_THREAD_CRASH;
517         }
518
519         if (--t->reentrancy < 0) {
520                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
521                                    filename, lineno, func, mutex_name);
522                 t->reentrancy = 0;
523         }
524
525         if (t->reentrancy < AST_MAX_REENTRANCY) {
526                 t->file[t->reentrancy] = NULL;
527                 t->lineno[t->reentrancy] = 0;
528                 t->func[t->reentrancy] = NULL;
529                 t->thread[t->reentrancy] = 0;
530         }
531
532         if ((res = pthread_cond_wait(cond, &t->mutex))) {
533                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
534                                    filename, lineno, func, strerror(res));
535                 DO_THREAD_CRASH;
536         } else {
537                 if (t->reentrancy < AST_MAX_REENTRANCY) {
538                         t->file[t->reentrancy] = filename;
539                         t->lineno[t->reentrancy] = lineno;
540                         t->func[t->reentrancy] = func;
541                         t->thread[t->reentrancy] = pthread_self();
542                         t->reentrancy++;
543                 } else {
544                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
545                                                            filename, lineno, func, mutex_name);
546                 }
547         }
548
549         return res;
550 }
551
552 static inline int __ast_cond_timedwait(const char *filename, int lineno, const char *func,
553                                        const char *cond_name, const char *mutex_name, ast_cond_t *cond,
554                                        ast_mutex_t *t, const struct timespec *abstime)
555 {
556         int res;
557         int canlog = strcmp(filename, "logger.c");
558
559 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
560         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
561                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
562                                    filename, lineno, func, mutex_name);
563         }
564 #endif
565
566         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
567                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
568                                    filename, lineno, func, mutex_name);
569                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
570                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
571                 DO_THREAD_CRASH;
572         }
573
574         if (--t->reentrancy < 0) {
575                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
576                                    filename, lineno, func, mutex_name);
577                 t->reentrancy = 0;
578         }
579
580         if (t->reentrancy < AST_MAX_REENTRANCY) {
581                 t->file[t->reentrancy] = NULL;
582                 t->lineno[t->reentrancy] = 0;
583                 t->func[t->reentrancy] = NULL;
584                 t->thread[t->reentrancy] = 0;
585         }
586
587         if ((res = pthread_cond_timedwait(cond, &t->mutex, abstime)) && (res != ETIMEDOUT)) {
588                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
589                                    filename, lineno, func, strerror(res));
590                 DO_THREAD_CRASH;
591         } else {
592                 if (t->reentrancy < AST_MAX_REENTRANCY) {
593                         t->file[t->reentrancy] = filename;
594                         t->lineno[t->reentrancy] = lineno;
595                         t->func[t->reentrancy] = func;
596                         t->thread[t->reentrancy] = pthread_self();
597                         t->reentrancy++;
598                 } else {
599                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
600                                                            filename, lineno, func, mutex_name);
601                 }
602         }
603
604         return res;
605 }
606
607 #define ast_mutex_destroy(a) __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
608 #define ast_mutex_lock(a) __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
609 #define ast_mutex_unlock(a) __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
610 #define ast_mutex_trylock(a) __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
611 #define ast_cond_init(cond, attr) __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
612 #define ast_cond_destroy(cond) __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
613 #define ast_cond_signal(cond) __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
614 #define ast_cond_broadcast(cond) __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
615 #define ast_cond_wait(cond, mutex) __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
616 #define ast_cond_timedwait(cond, mutex, time) __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
617
618 #else /* !DEBUG_THREADS */
619
620
621 typedef pthread_mutex_t ast_mutex_t;
622
623 #define AST_MUTEX_INIT_VALUE    ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
624
625 static inline int ast_mutex_init(ast_mutex_t *pmutex)
626 {
627         pthread_mutexattr_t attr;
628
629         pthread_mutexattr_init(&attr);
630         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
631
632         return pthread_mutex_init(pmutex, &attr);
633 }
634
635 #define ast_pthread_mutex_init(pmutex,a) pthread_mutex_init(pmutex,a)
636
637 static inline int ast_mutex_unlock(ast_mutex_t *pmutex)
638 {
639         return pthread_mutex_unlock(pmutex);
640 }
641
642 static inline int ast_mutex_destroy(ast_mutex_t *pmutex)
643 {
644         return pthread_mutex_destroy(pmutex);
645 }
646
647 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
648 {
649         __MTX_PROF(pmutex);
650 }
651
652 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
653 {
654         return pthread_mutex_trylock(pmutex);
655 }
656
657 typedef pthread_cond_t ast_cond_t;
658
659 static inline int ast_cond_init(ast_cond_t *cond, pthread_condattr_t *cond_attr)
660 {
661         return pthread_cond_init(cond, cond_attr);
662 }
663
664 static inline int ast_cond_signal(ast_cond_t *cond)
665 {
666         return pthread_cond_signal(cond);
667 }
668
669 static inline int ast_cond_broadcast(ast_cond_t *cond)
670 {
671         return pthread_cond_broadcast(cond);
672 }
673
674 static inline int ast_cond_destroy(ast_cond_t *cond)
675 {
676         return pthread_cond_destroy(cond);
677 }
678
679 static inline int ast_cond_wait(ast_cond_t *cond, ast_mutex_t *t)
680 {
681         return pthread_cond_wait(cond, t);
682 }
683
684 static inline int ast_cond_timedwait(ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
685 {
686         return pthread_cond_timedwait(cond, t, abstime);
687 }
688
689 #endif /* !DEBUG_THREADS */
690
691 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
692 /* If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
693  constructors/destructors to create/destroy mutexes.  */
694 #define __AST_MUTEX_DEFINE(scope, mutex) \
695         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
696 static void  __attribute__((constructor)) init_##mutex(void) \
697 { \
698         ast_mutex_init(&mutex); \
699 } \
700 static void  __attribute__((destructor)) fini_##mutex(void) \
701 { \
702         ast_mutex_destroy(&mutex); \
703 }
704 #else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
705 /* By default, use static initialization of mutexes. */ 
706 #define __AST_MUTEX_DEFINE(scope, mutex) \
707         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
708 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
709
710 #define pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t
711 #define pthread_mutex_lock use_ast_mutex_lock_instead_of_pthread_mutex_lock
712 #define pthread_mutex_unlock use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
713 #define pthread_mutex_trylock use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
714 #define pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init
715 #define pthread_mutex_destroy use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
716 #define pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t
717 #define pthread_cond_init use_ast_cond_init_instead_of_pthread_cond_init
718 #define pthread_cond_destroy use_ast_cond_destroy_instead_of_pthread_cond_destroy
719 #define pthread_cond_signal use_ast_cond_signal_instead_of_pthread_cond_signal
720 #define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
721 #define pthread_cond_wait use_ast_cond_wait_instead_of_pthread_cond_wait
722 #define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
723
724 #define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex)
725
726 #define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
727
728 #define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
729
730 #ifndef __linux__
731 #define pthread_create __use_ast_pthread_create_instead__
732 #endif
733
734 typedef pthread_rwlock_t ast_rwlock_t;
735
736 static inline int ast_rwlock_init(ast_rwlock_t *prwlock)
737 {
738         pthread_rwlockattr_t attr;
739
740         pthread_rwlockattr_init(&attr);
741
742 #ifdef HAVE_PTHREAD_RWLOCK_PREFER_WRITER_NP
743         pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);
744 #endif
745
746         return pthread_rwlock_init(prwlock, &attr);
747 }
748
749 static inline int ast_rwlock_destroy(ast_rwlock_t *prwlock)
750 {
751         return pthread_rwlock_destroy(prwlock);
752 }
753
754 static inline int ast_rwlock_unlock(ast_rwlock_t *prwlock)
755 {
756         return pthread_rwlock_unlock(prwlock);
757 }
758
759 static inline int ast_rwlock_rdlock(ast_rwlock_t *prwlock)
760 {
761         return pthread_rwlock_rdlock(prwlock);
762 }
763
764 static inline int ast_rwlock_tryrdlock(ast_rwlock_t *prwlock)
765 {
766         return pthread_rwlock_tryrdlock(prwlock);
767 }
768
769 static inline int ast_rwlock_wrlock(ast_rwlock_t *prwlock)
770 {
771         return pthread_rwlock_wrlock(prwlock);
772 }
773
774 static inline int ast_rwlock_trywrlock(ast_rwlock_t *prwlock)
775 {
776         return pthread_rwlock_trywrlock(prwlock);
777 }
778
779 /* Statically declared read/write locks */
780
781 #ifndef HAVE_PTHREAD_RWLOCK_INITIALIZER
782 #define __AST_RWLOCK_DEFINE(scope, rwlock) \
783         scope ast_rwlock_t rwlock; \
784 static void  __attribute__((constructor)) init_##rwlock(void) \
785 { \
786         ast_rwlock_init(&rwlock); \
787 } \
788 static void  __attribute__((destructor)) fini_##rwlock(void) \
789 { \
790         ast_rwlock_destroy(&rwlock); \
791 }
792 #else
793 #define AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER
794 #define __AST_RWLOCK_DEFINE(scope, rwlock) \
795         scope ast_rwlock_t rwlock = AST_RWLOCK_INIT_VALUE
796 #endif
797
798 #define AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock)
799
800 /*
801  * Initial support for atomic instructions.
802  * For platforms that have it, use the native cpu instruction to
803  * implement them. For other platforms, resort to a 'slow' version
804  * (defined in utils.c) that protects the atomic instruction with
805  * a single lock.
806  * The slow versions is always available, for testing purposes,
807  * as ast_atomic_fetchadd_int_slow()
808  */
809
810 #if defined(HAVE_OSX_ATOMICS)
811 #include "libkern/OSAtomic.h"
812 #endif
813
814 /*! \brief Atomically add v to *p and return * the previous value of *p.
815  * This can be used to handle reference counts, and the return value
816  * can be used to generate unique identifiers.
817  */
818
819 #if defined(HAVE_GCC_ATOMICS)
820 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
821 {
822         return __sync_fetch_and_add(p, v);
823 })
824 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
825 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
826 {
827         return OSAtomicAdd32(v, (int32_t *) p);
828 })
829 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
830 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
831 {
832         return OSAtomicAdd64(v, (int64_t *) p);
833 #elif defined (__i386__) || defined(__x86_64__)
834 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
835 {
836         __asm __volatile (
837         "       lock   xaddl   %0, %1 ;        "
838         : "+r" (v),                     /* 0 (result) */   
839           "=m" (*p)                     /* 1 */
840         : "m" (*p));                    /* 2 */
841         return (v);
842 })
843 #else
844 static int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
845 {
846         int ret;
847         ret = *p;
848         *p += v;
849         return ret;
850 }
851 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
852 {
853         return ast_atomic_fetchadd_int_slow(p, v);
854 })
855 #endif
856
857 /*! \brief decrement *p by 1 and return true if the variable has reached 0.
858  * Useful e.g. to check if a refcount has reached 0.
859  */
860 #if defined(HAVE_GCC_ATOMICS)
861 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
862 {
863         return __sync_sub_and_fetch(p, 1) == 0;
864 })
865 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
866 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
867 {
868         return OSAtomicAdd32( -1, (int32_t *) p) == 0;
869 })
870 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
871 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
872 {
873         return OSAtomicAdd64( -1, (int64_t *) p) == 0;
874 #else
875 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
876 {
877         int a = ast_atomic_fetchadd_int(p, -1);
878         return a == 1; /* true if the value is 0 now (so it was 1 previously) */
879 })
880 #endif
881
882 #ifndef DEBUG_CHANNEL_LOCKS
883 /*! \brief Lock a channel. If DEBUG_CHANNEL_LOCKS is defined 
884         in the Makefile, print relevant output for debugging */
885 #define ast_channel_lock(x)             ast_mutex_lock(&x->lock)
886 /*! \brief Unlock a channel. If DEBUG_CHANNEL_LOCKS is defined 
887         in the Makefile, print relevant output for debugging */
888 #define ast_channel_unlock(x)           ast_mutex_unlock(&x->lock)
889 /*! \brief Try locking a channel. If DEBUG_CHANNEL_LOCKS is defined 
890         in the Makefile, print relevant output for debugging */
891 #define ast_channel_trylock(x)          ast_mutex_trylock(&x->lock)
892 #else
893
894 /*! \brief Lock AST channel (and print debugging output)
895 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
896 int ast_channel_lock(struct ast_channel *chan);
897
898 /*! \brief Unlock AST channel (and print debugging output)
899 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
900 */
901 int ast_channel_unlock(struct ast_channel *chan);
902
903 /*! \brief Lock AST channel (and print debugging output)
904 \note   You need to enable DEBUG_CHANNEL_LOCKS for this function */
905 int ast_channel_trylock(struct ast_channel *chan);
906 #endif
907
908
909 #include "asterisk/hashtab.h"
910 #include "asterisk/ael_structs.h"
911 #include "asterisk/pval.h"
912
913 /* from utils.h */
914
915 #define ast_free free
916 #define ast_free_ptr free
917
918 #define MALLOC_FAILURE_MSG \
919         ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
920
921 /*!
922  * \brief A wrapper for malloc()
923  *
924  * ast_malloc() is a wrapper for malloc() that will generate an Asterisk log
925  * message in the case that the allocation fails.
926  *
927  * The argument and return value are the same as malloc()
928  */
929 #define ast_malloc(len) \
930         _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
931
932 #define ast_calloc(num, len) \
933         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
934
935 #define ast_calloc_cache(num, len) \
936         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
937
938 #define ast_realloc(p, len) \
939         _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
940
941 #define ast_strdup(str) \
942         _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
943
944 #define ast_strndup(str, len) \
945         _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
946
947 #define ast_asprintf(ret, fmt, ...) \
948         _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
949
950 #define ast_vasprintf(ret, fmt, ap) \
951         _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
952
953
954 static unsigned int __unsigned_int_flags_dummy;
955
956 struct ast_flags {  /* stolen from utils.h */
957         unsigned int flags;
958 };
959 #define ast_test_flag(p,flag)           ({ \
960                                         typeof ((p)->flags) __p = (p)->flags; \
961                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
962                                         (void) (&__p == &__x); \
963                                         ((p)->flags & (flag)); \
964                                         })
965
966 #define ast_set2_flag(p,value,flag)     do { \
967                                         typeof ((p)->flags) __p = (p)->flags; \
968                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
969                                         (void) (&__p == &__x); \
970                                         if (value) \
971                                                 (p)->flags |= (flag); \
972                                         else \
973                                                 (p)->flags &= ~(flag); \
974                                         } while (0)
975
976
977
978 #define MALLOC_FAILURE_MSG \
979         ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
980 /*!
981  * \brief A wrapper for malloc()
982  *
983  * ast_malloc() is a wrapper for malloc() that will generate an Asterisk log
984  * message in the case that the allocation fails.
985  *
986  * The argument and return value are the same as malloc()
987  */
988 #define ast_malloc(len) \
989         _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
990
991 AST_INLINE_API(
992 void * attribute_malloc _ast_malloc(size_t len, const char *file, int lineno, const char *func),
993 {
994         void *p;
995
996         if (!(p = malloc(len)))
997                 MALLOC_FAILURE_MSG;
998
999         return p;
1000 }
1001 )
1002
1003 /*!
1004  * \brief A wrapper for calloc()
1005  *
1006  * ast_calloc() is a wrapper for calloc() that will generate an Asterisk log
1007  * message in the case that the allocation fails.
1008  *
1009  * The arguments and return value are the same as calloc()
1010  */
1011 #define ast_calloc(num, len) \
1012         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1013
1014 AST_INLINE_API(
1015 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func),
1016 {
1017         void *p;
1018
1019         if (!(p = calloc(num, len)))
1020                 MALLOC_FAILURE_MSG;
1021
1022         return p;
1023 }
1024 )
1025
1026 /*!
1027  * \brief A wrapper for calloc() for use in cache pools
1028  *
1029  * ast_calloc_cache() is a wrapper for calloc() that will generate an Asterisk log
1030  * message in the case that the allocation fails. When memory debugging is in use,
1031  * the memory allocated by this function will be marked as 'cache' so it can be
1032  * distinguished from normal memory allocations.
1033  *
1034  * The arguments and return value are the same as calloc()
1035  */
1036 #define ast_calloc_cache(num, len) \
1037         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1038
1039 /*!
1040  * \brief A wrapper for realloc()
1041  *
1042  * ast_realloc() is a wrapper for realloc() that will generate an Asterisk log
1043  * message in the case that the allocation fails.
1044  *
1045  * The arguments and return value are the same as realloc()
1046  */
1047 #define ast_realloc(p, len) \
1048         _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1049
1050 AST_INLINE_API(
1051 void * attribute_malloc _ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func),
1052 {
1053         void *newp;
1054
1055         if (!(newp = realloc(p, len)))
1056                 MALLOC_FAILURE_MSG;
1057
1058         return newp;
1059 }
1060 )
1061
1062 /*!
1063  * \brief A wrapper for strdup()
1064  *
1065  * ast_strdup() is a wrapper for strdup() that will generate an Asterisk log
1066  * message in the case that the allocation fails.
1067  *
1068  * ast_strdup(), unlike strdup(), can safely accept a NULL argument. If a NULL
1069  * argument is provided, ast_strdup will return NULL without generating any
1070  * kind of error log message.
1071  *
1072  * The argument and return value are the same as strdup()
1073  */
1074 #define ast_strdup(str) \
1075         _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1076
1077 AST_INLINE_API(
1078 char * attribute_malloc _ast_strdup(const char *str, const char *file, int lineno, const char *func),
1079 {
1080         char *newstr = NULL;
1081
1082         if (str) {
1083                 if (!(newstr = strdup(str)))
1084                         MALLOC_FAILURE_MSG;
1085         }
1086
1087         return newstr;
1088 }
1089 )
1090
1091 /*!
1092  * \brief A wrapper for strndup()
1093  *
1094  * ast_strndup() is a wrapper for strndup() that will generate an Asterisk log
1095  * message in the case that the allocation fails.
1096  *
1097  * ast_strndup(), unlike strndup(), can safely accept a NULL argument for the
1098  * string to duplicate. If a NULL argument is provided, ast_strdup will return  
1099  * NULL without generating any kind of error log message.
1100  *
1101  * The arguments and return value are the same as strndup()
1102  */
1103 #define ast_strndup(str, len) \
1104         _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
1105
1106 AST_INLINE_API(
1107 char * attribute_malloc _ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func),
1108 {
1109         char *newstr = NULL;
1110
1111         if (str) {
1112                 if (!(newstr = strndup(str, len)))
1113                         MALLOC_FAILURE_MSG;
1114         }
1115
1116         return newstr;
1117 }
1118 )
1119
1120 /*!
1121  * \brief A wrapper for asprintf()
1122  *
1123  * ast_asprintf() is a wrapper for asprintf() that will generate an Asterisk log
1124  * message in the case that the allocation fails.
1125  *
1126  * The arguments and return value are the same as asprintf()
1127  */
1128 #define ast_asprintf(ret, fmt, ...) \
1129         _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
1130
1131 AST_INLINE_API(
1132 __attribute__((format(printf, 5, 6)))
1133 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...),
1134 {
1135         int res;
1136         va_list ap;
1137
1138         va_start(ap, fmt);
1139         if ((res = vasprintf(ret, fmt, ap)) == -1)
1140                 MALLOC_FAILURE_MSG;
1141         va_end(ap);
1142
1143         return res;
1144 }
1145 )
1146
1147 /*!
1148  * \brief A wrapper for vasprintf()
1149  *
1150  * ast_vasprintf() is a wrapper for vasprintf() that will generate an Asterisk log
1151  * message in the case that the allocation fails.
1152  *
1153  * The arguments and return value are the same as vasprintf()
1154  */
1155 #define ast_vasprintf(ret, fmt, ap) \
1156         _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
1157
1158 AST_INLINE_API(
1159 __attribute__((format(printf, 5, 0)))
1160 int _ast_vasprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, va_list ap),
1161 {
1162         int res;
1163
1164         if ((res = vasprintf(ret, fmt, ap)) == -1)
1165                 MALLOC_FAILURE_MSG;
1166
1167         return res;
1168 }
1169 )
1170
1171 #if !defined(ast_strdupa) && defined(__GNUC__)
1172 /*!
1173   \brief duplicate a string in memory from the stack
1174   \param s The string to duplicate
1175
1176   This macro will duplicate the given string.  It returns a pointer to the stack
1177   allocatted memory for the new string.
1178 */
1179 #define ast_strdupa(s)                                                    \
1180         (__extension__                                                    \
1181         ({                                                                \
1182                 const char *__old = (s);                                  \
1183                 size_t __len = strlen(__old) + 1;                         \
1184                 char *__new = __builtin_alloca(__len);                    \
1185                 memcpy (__new, __old, __len);                             \
1186                 __new;                                                    \
1187         }))
1188 #endif
1189
1190
1191 /* from config.c */
1192
1193 #define MAX_NESTED_COMMENTS 128
1194 #define COMMENT_START ";--"
1195 #define COMMENT_END "--;"
1196 #define COMMENT_META ';'
1197 #define COMMENT_TAG '-'
1198
1199 static char *extconfig_conf = "extconfig.conf";
1200
1201 /*! Growable string buffer */
1202 static char *comment_buffer;   /*!< this will be a comment collector.*/
1203 static int   comment_buffer_size;  /*!< the amount of storage so far alloc'd for the comment_buffer */
1204
1205 static char *lline_buffer;    /*!< A buffer for stuff behind the ; */
1206 static int  lline_buffer_size;
1207
1208 #define CB_INCR 250
1209
1210 struct ast_comment {
1211         struct ast_comment *next;
1212         char cmt[0];
1213 };
1214
1215 static void CB_INIT(void)
1216 {
1217         if (!comment_buffer) {
1218                 comment_buffer = ast_malloc(CB_INCR);
1219                 if (!comment_buffer)
1220                         return;
1221                 comment_buffer[0] = 0;
1222                 comment_buffer_size = CB_INCR;
1223                 lline_buffer = ast_malloc(CB_INCR);
1224                 if (!lline_buffer)
1225                         return;
1226                 lline_buffer[0] = 0;
1227                 lline_buffer_size = CB_INCR;
1228         } else {
1229                 comment_buffer[0] = 0;
1230                 lline_buffer[0] = 0;
1231         }
1232 }
1233
1234 static void  CB_ADD(char *str)
1235 {
1236         int rem = comment_buffer_size - strlen(comment_buffer) - 1;
1237         int siz = strlen(str);
1238         if (rem < siz+1) {
1239                 comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + siz + 1);
1240                 if (!comment_buffer)
1241                         return;
1242                 comment_buffer_size += CB_INCR+siz+1;
1243         }
1244         strcat(comment_buffer,str);
1245 }
1246
1247 static void  CB_ADD_LEN(char *str, int len)
1248 {
1249         int cbl = strlen(comment_buffer) + 1;
1250         int rem = comment_buffer_size - cbl;
1251         if (rem < len+1) {
1252                 comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + len + 1);
1253                 if (!comment_buffer)
1254                         return;
1255                 comment_buffer_size += CB_INCR+len+1;
1256         }
1257         strncat(comment_buffer,str,len); /* safe */
1258         comment_buffer[cbl+len-1] = 0;
1259 }
1260
1261 static void  LLB_ADD(char *str)
1262 {
1263         int rem = lline_buffer_size - strlen(lline_buffer) - 1;
1264         int siz = strlen(str);
1265         if (rem < siz+1) {
1266                 lline_buffer = ast_realloc(lline_buffer, lline_buffer_size + CB_INCR + siz + 1);
1267                 if (!lline_buffer) 
1268                         return;
1269                 lline_buffer_size += CB_INCR + siz + 1;
1270         }
1271         strcat(lline_buffer,str);
1272 }
1273
1274 static void CB_RESET(void )  
1275
1276         comment_buffer[0] = 0; 
1277         lline_buffer[0] = 0;
1278 }
1279                 
1280 /*! \brief Keep track of how many threads are currently trying to wait*() on
1281  *  a child process */
1282 static unsigned int safe_system_level = 0;
1283 static struct sigaction safe_system_prev_handler;
1284
1285 /*! \brief NULL handler so we can collect the child exit status */
1286 static void _null_sig_handler(int sig)
1287 {
1288
1289 }
1290
1291 static struct sigaction null_sig_handler = {
1292         .sa_handler = _null_sig_handler,
1293         .sa_flags = SA_RESTART,
1294 };
1295
1296 void ast_replace_sigchld(void);
1297
1298 void ast_replace_sigchld(void)
1299 {
1300         unsigned int level;
1301
1302         level = safe_system_level++;
1303
1304         /* only replace the handler if it has not already been done */
1305         if (level == 0) {
1306                 sigaction(SIGCHLD, &null_sig_handler, &safe_system_prev_handler);
1307         }
1308 }
1309
1310 void ast_unreplace_sigchld(void);
1311
1312 void ast_unreplace_sigchld(void)
1313 {
1314         unsigned int level;
1315
1316         level = --safe_system_level;
1317
1318         /* only restore the handler if we are the last one */
1319         if (level == 0) {
1320                 sigaction(SIGCHLD, &safe_system_prev_handler, NULL);
1321         }
1322 }
1323
1324 int ast_safe_system(const char *s);
1325
1326 int ast_safe_system(const char *s)
1327 {
1328         pid_t pid;
1329 #ifdef HAVE_WORKING_FORK
1330         int x;
1331 #endif
1332         int res;
1333         struct rusage rusage;
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 = wait4(pid, &status, 0, &rusage);
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 /*! Go no deeper than this through includes (not counting loops) */
2696 #define AST_PBX_MAX_STACK       128
2697 static void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
2698
2699
2700 /* stolen from callerid.c */
2701
2702 /*! \brief Clean up phone string
2703  * remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets.
2704  * Basically, remove anything that could be invalid in a pattern.
2705  */
2706 static void ast_shrink_phone_number(char *n)
2707 {
2708         int x, y=0;
2709         int bracketed = 0;
2710
2711         for (x=0; n[x]; x++) {
2712                 switch(n[x]) {
2713                 case '[':
2714                         bracketed++;
2715                         n[y++] = n[x];
2716                         break;
2717                 case ']':
2718                         bracketed--;
2719                         n[y++] = n[x];
2720                         break;
2721                 case '-':
2722                         if (bracketed)
2723                                 n[y++] = n[x];
2724                         break;
2725                 case '.':
2726                         if (!n[x+1])
2727                                 n[y++] = n[x];
2728                         break;
2729                 default:
2730                         if (!strchr("()", n[x]))
2731                                 n[y++] = n[x];
2732                 }
2733         }
2734         n[y] = '\0';
2735 }
2736
2737
2738 /* stolen from chanvars.c */
2739
2740 static const char *ast_var_name(const struct ast_var_t *var)
2741 {
2742         const char *name;
2743
2744         if (var == NULL || (name = var->name) == NULL)
2745                 return NULL;
2746         /* Return the name without the initial underscores */
2747         if (name[0] == '_') {
2748                 name++;
2749                 if (name[0] == '_')
2750                         name++;
2751         }
2752         return name;
2753 }
2754
2755 /* experiment 1: see if it's easier just to use existing config code
2756  *               to read in the extensions.conf file. In this scenario, 
2757                  I have to rip/copy code from other modules, because they
2758                  are staticly declared as-is. A solution would be to move
2759                  the ripped code to another location and make them available
2760                  to other modules and standalones */
2761
2762 /* Our own version of ast_log, since the expr parser uses it. -- stolen from utils/check_expr.c */
2763
2764 static void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
2765 {
2766         va_list vars;
2767         va_start(vars,fmt);
2768         
2769         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
2770                    level, file, line, function);
2771         vprintf(fmt, vars);
2772         fflush(stdout);
2773         va_end(vars);
2774 }
2775
2776 void __attribute__((format(printf, 1, 2))) ast_verbose(const char *fmt, ...)
2777 {
2778         va_list vars;
2779         va_start(vars,fmt);
2780         
2781         printf("VERBOSE: ");
2782         vprintf(fmt, vars);
2783         fflush(stdout);
2784         va_end(vars);
2785 }
2786
2787 /* stolen from main/utils.c */
2788 static char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
2789 {
2790         char *dataPut = start;
2791         int inEscape = 0;
2792         int inQuotes = 0;
2793
2794         for (; *start; start++) {
2795                 if (inEscape) {
2796                         *dataPut++ = *start;       /* Always goes verbatim */
2797                         inEscape = 0;
2798                 } else {
2799                         if (*start == '\\') {
2800                                 inEscape = 1;      /* Do not copy \ into the data */
2801                         } else if (*start == '\'') {
2802                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
2803                         } else {
2804                                 /* Replace , with |, unless in quotes */
2805                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
2806                         }
2807                 }
2808         }
2809         if (start != dataPut)
2810                 *dataPut = 0;
2811         return dataPut;
2812 }
2813
2814 static int ast_true(const char *s)
2815 {
2816         if (ast_strlen_zero(s))
2817                 return 0;
2818
2819         /* Determine if this is a true value */
2820         if (!strcasecmp(s, "yes") ||
2821             !strcasecmp(s, "true") ||
2822             !strcasecmp(s, "y") ||
2823             !strcasecmp(s, "t") ||
2824             !strcasecmp(s, "1") ||
2825             !strcasecmp(s, "on"))
2826                 return -1;
2827
2828         return 0;
2829 }
2830
2831 #define ONE_MILLION     1000000
2832 /*
2833  * put timeval in a valid range. usec is 0..999999
2834  * negative values are not allowed and truncated.
2835  */
2836 static struct timeval tvfix(struct timeval a)
2837 {
2838         if (a.tv_usec >= ONE_MILLION) {
2839                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
2840                         (long)a.tv_sec, (long int) a.tv_usec);
2841                 a.tv_sec += a.tv_usec / ONE_MILLION;
2842                 a.tv_usec %= ONE_MILLION;
2843         } else if (a.tv_usec < 0) {
2844                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
2845                         (long)a.tv_sec, (long int) a.tv_usec);
2846                 a.tv_usec = 0;
2847         }
2848         return a;
2849 }
2850
2851 struct timeval ast_tvadd(struct timeval a, struct timeval b);
2852 struct timeval ast_tvadd(struct timeval a, struct timeval b)
2853 {
2854         /* consistency checks to guarantee usec in 0..999999 */
2855         a = tvfix(a);
2856         b = tvfix(b);
2857         a.tv_sec += b.tv_sec;
2858         a.tv_usec += b.tv_usec;
2859         if (a.tv_usec >= ONE_MILLION) {
2860                 a.tv_sec++;
2861                 a.tv_usec -= ONE_MILLION;
2862         }
2863         return a;
2864 }
2865
2866 struct timeval ast_tvsub(struct timeval a, struct timeval b);
2867 struct timeval ast_tvsub(struct timeval a, struct timeval b)
2868 {
2869         /* consistency checks to guarantee usec in 0..999999 */
2870         a = tvfix(a);
2871         b = tvfix(b);
2872         a.tv_sec -= b.tv_sec;
2873         a.tv_usec -= b.tv_usec;
2874         if (a.tv_usec < 0) {
2875                 a.tv_sec-- ;
2876                 a.tv_usec += ONE_MILLION;
2877         }
2878         return a;
2879 }
2880 #undef ONE_MILLION
2881
2882 void ast_mark_lock_failed(void *lock_addr);
2883 void ast_mark_lock_failed(void *lock_addr)
2884 {
2885         /* Pretend to do something. */
2886 }
2887
2888 /* stolen from pbx.c */
2889 #define VAR_BUF_SIZE 4096
2890
2891 #define VAR_NORMAL              1
2892 #define VAR_SOFTTRAN    2
2893 #define VAR_HARDTRAN    3
2894
2895 #define BACKGROUND_SKIP         (1 << 0)
2896 #define BACKGROUND_NOANSWER     (1 << 1)
2897 #define BACKGROUND_MATCHEXTEN   (1 << 2)
2898 #define BACKGROUND_PLAYBACK     (1 << 3)
2899
2900 /*!
2901    \brief ast_exten: An extension
2902         The dialplan is saved as a linked list with each context
2903         having it's own linked list of extensions - one item per
2904         priority.
2905 */
2906 struct ast_exten {
2907         char *exten;                    /*!< Extension name */
2908         int matchcid;                   /*!< Match caller id ? */
2909         const char *cidmatch;           /*!< Caller id to match for this extension */
2910         int priority;                   /*!< Priority */
2911         const char *label;              /*!< Label */
2912         struct ast_context *parent;     /*!< The context this extension belongs to  */
2913         const char *app;                /*!< Application to execute */
2914         struct ast_app *cached_app;     /*!< Cached location of application */
2915         void *data;                     /*!< Data to use (arguments) */
2916         void (*datad)(void *);          /*!< Data destructor */
2917         struct ast_exten *peer;         /*!< Next higher priority with our extension */
2918         const char *registrar;          /*!< Registrar */
2919         struct ast_exten *next;         /*!< Extension with a greater ID */
2920         char stuff[0];
2921 };
2922 /* from pbx.h */
2923 typedef int (*ast_state_cb_type)(char *context, char* id, enum ast_extension_states state, void *data);
2924 struct ast_timing {
2925         int hastime;                            /*!< If time construct exists */
2926         unsigned int monthmask;                 /*!< Mask for month */
2927         unsigned int daymask;                   /*!< Mask for date */
2928         unsigned int dowmask;                   /*!< Mask for day of week (mon-sun) */
2929         unsigned int minmask[48];               /*!< Mask for minute */
2930         char *timezone;                 /*!< NULL, or zoneinfo style timezone */
2931 };
2932 /* end of pbx.h */
2933 /*! \brief ast_include: include= support in extensions.conf */
2934 struct ast_include {
2935         const char *name;
2936         const char *rname;                      /*!< Context to include */
2937         const char *registrar;                  /*!< Registrar */
2938         int hastime;                            /*!< If time construct exists */
2939         struct ast_timing timing;               /*!< time construct */
2940         struct ast_include *next;               /*!< Link them together */
2941         char stuff[0];
2942 };
2943
2944 /*! \brief ast_sw: Switch statement in extensions.conf */
2945 struct ast_sw {
2946         char *name;
2947         const char *registrar;                  /*!< Registrar */
2948         char *data;                             /*!< Data load */
2949         int eval;
2950         AST_LIST_ENTRY(ast_sw) list;
2951         char *tmpdata;
2952         char stuff[0];
2953 };
2954
2955 /*! \brief ast_ignorepat: Ignore patterns in dial plan */
2956 struct ast_ignorepat {
2957         const char *registrar;
2958         struct ast_ignorepat *next;
2959         char pattern[0];
2960 };
2961
2962 /*! \brief ast_context: An extension context */
2963 struct ast_context {
2964         ast_rwlock_t lock;                      /*!< A lock to prevent multiple threads from clobbering the context */
2965         struct ast_exten *root;                 /*!< The root of the list of extensions */
2966         struct ast_context *next;               /*!< Link them together */
2967         struct ast_include *includes;           /*!< Include other contexts */
2968         struct ast_ignorepat *ignorepats;       /*!< Patterns for which to continue playing dialtone */
2969         const char *registrar;                  /*!< Registrar */
2970         AST_LIST_HEAD_NOLOCK(, ast_sw) alts;    /*!< Alternative switches */
2971         ast_mutex_t macrolock;                  /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */
2972         char name[0];                           /*!< Name of the context */
2973 };
2974
2975
2976 /*! \brief ast_app: A registered application */
2977 struct ast_app {
2978         int (*execute)(struct ast_channel *chan, void *data);
2979         const char *synopsis;                   /*!< Synopsis text for 'show applications' */
2980         const char *description;                /*!< Description (help text) for 'show application &lt;name&gt;' */
2981         AST_RWLIST_ENTRY(ast_app) list;         /*!< Next app in list */
2982         void *module;                   /*!< Module this app belongs to */
2983         char name[0];                           /*!< Name of the application */
2984 };
2985
2986
2987 /*! \brief ast_state_cb: An extension state notify register item */
2988 struct ast_state_cb {
2989         int id;
2990         void *data;
2991         ast_state_cb_type callback;
2992         struct ast_state_cb *next;
2993 };
2994
2995 /*! \brief Structure for dial plan hints
2996
2997   \note Hints are pointers from an extension in the dialplan to one or
2998   more devices (tech/name) 
2999         - See \ref AstExtState
3000 */
3001 struct ast_hint {
3002         struct ast_exten *exten;        /*!< Extension */
3003         int laststate;                  /*!< Last known state */
3004         struct ast_state_cb *callbacks; /*!< Callback list for this extension */
3005         AST_RWLIST_ENTRY(ast_hint) list;/*!< Pointer to next hint in list */
3006 };
3007
3008 struct store_hint {
3009         char *context;
3010         char *exten;
3011         struct ast_state_cb *callbacks;
3012         int laststate;
3013         AST_LIST_ENTRY(store_hint) list;
3014         char data[1];
3015 };
3016
3017 AST_LIST_HEAD(store_hints, store_hint);
3018
3019 static const struct cfextension_states {
3020         int extension_state;
3021         const char * const text;
3022 } extension_states[] = {
3023         { AST_EXTENSION_NOT_INUSE,                     "Idle" },
3024         { AST_EXTENSION_INUSE,                         "InUse" },
3025         { AST_EXTENSION_BUSY,                          "Busy" },
3026         { AST_EXTENSION_UNAVAILABLE,                   "Unavailable" },
3027         { AST_EXTENSION_RINGING,                       "Ringing" },
3028         { AST_EXTENSION_INUSE | AST_EXTENSION_RINGING, "InUse&Ringing" },
3029         { AST_EXTENSION_ONHOLD,                        "Hold" },
3030         { AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD,  "InUse&Hold" }
3031 };
3032 #define STATUS_NO_CONTEXT       1
3033 #define STATUS_NO_EXTENSION     2
3034 #define STATUS_NO_PRIORITY      3
3035 #define STATUS_NO_LABEL         4
3036 #define STATUS_SUCCESS          5
3037
3038
3039 #if defined ( __i386__) && (defined(__FreeBSD__) || defined(linux))
3040 #if defined(__FreeBSD__)
3041 #include <machine/cpufunc.h>
3042 #elif defined(linux)
3043 static __inline uint64_t
3044 rdtsc(void)
3045
3046         uint64_t rv;
3047
3048         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
3049         return (rv);
3050 }
3051 #endif
3052 #else   /* supply a dummy function on other platforms */
3053 static __inline uint64_t
3054 rdtsc(void)
3055 {
3056         return 0;
3057 }
3058 #endif
3059
3060
3061 static struct ast_var_t *ast_var_assign(const char *name, const char *value)
3062 {       
3063         struct ast_var_t *var;
3064         int name_len = strlen(name) + 1;
3065         int value_len = strlen(value) + 1;
3066
3067         if (!(var = ast_calloc(sizeof(*var) + name_len + value_len, sizeof(char)))) {
3068                 return NULL;
3069         }
3070
3071         ast_copy_string(var->name, name, name_len);
3072         var->value = var->name + name_len;
3073         ast_copy_string(var->value, value, value_len);
3074         
3075         return var;
3076 }       
3077         
3078 static void ast_var_delete(struct ast_var_t *var)
3079 {
3080         free(var);
3081 }
3082
3083
3084 /* chopped this one off at the knees! */
3085 static int ast_func_write(struct ast_channel *chan, const char *function, const char *value)
3086 {
3087
3088         /* ast_log(LOG_ERROR, "Function %s not registered\n", function); we are not interested in the details here */
3089
3090         return -1;
3091 }
3092
3093 static unsigned int ast_app_separate_args(char *buf, char delim, char **array, int arraylen)
3094 {
3095         int argc;
3096         char *scan;
3097         int paren = 0, quote = 0;
3098
3099         if (!buf || !array || !arraylen)
3100                 return 0;
3101
3102         memset(array, 0, arraylen * sizeof(*array));
3103
3104         scan = buf;
3105
3106         for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
3107                 array[argc] = scan;
3108                 for (; *scan; scan++) {
3109                         if (*scan == '(')
3110                                 paren++;
3111                         else if (*scan == ')') {
3112                                 if (paren)
3113                                         paren--;
3114                         } else if (*scan == '"' && delim != '"') {
3115                                 quote = quote ? 0 : 1;
3116                                 /* Remove quote character from argument */
3117                                 memmove(scan, scan + 1, strlen(scan));
3118                                 scan--;
3119                         } else if (*scan == '\\') {
3120                                 /* Literal character, don't parse */
3121                                 memmove(scan, scan + 1, strlen(scan));
3122                         } else if ((*scan == delim) && !paren && !quote) {
3123                                 *scan++ = '\0';
3124                                 break;
3125                         }
3126                 }
3127         }
3128
3129         if (*scan)
3130                 array[argc++] = scan;
3131
3132         return argc;
3133 }
3134
3135 static void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
3136 {
3137         struct ast_var_t *newvariable;
3138         struct varshead *headp;
3139         const char *nametail = name;
3140
3141         /* XXX may need locking on the channel ? */
3142         if (name[strlen(name)-1] == ')') {
3143                 char *function = ast_strdupa(name);
3144
3145                 ast_func_write(chan, function, value);
3146                 return;
3147         }
3148
3149         headp = &globals;
3150
3151         /* For comparison purposes, we have to strip leading underscores */
3152         if (*nametail == '_') {
3153                 nametail++;
3154                 if (*nametail == '_')
3155                         nametail++;
3156         }
3157
3158         AST_LIST_TRAVERSE (headp, newvariable, entries) {
3159                 if (strcasecmp(ast_var_name(newvariable), nametail) == 0) {
3160                         /* there is already such a variable, delete it */
3161                         AST_LIST_REMOVE(headp, newvariable, entries);
3162                         ast_var_delete(newvariable);
3163                         break;
3164                 }
3165         }
3166
3167         if (value && (newvariable = ast_var_assign(name, value))) {
3168                 if ((option_verbose > 1) && (headp == &globals))
3169                         ast_verbose(VERBOSE_PREFIX_2 "Setting global variable '%s' to '%s'\n", name, value);
3170                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
3171         }
3172
3173 }
3174
3175 static int pbx_builtin_setvar(struct ast_channel *chan, const void *data)
3176 {
3177         char *name, *value, *mydata;
3178         int argc;
3179         char *argv[24];         /* this will only support a maximum of 24 variables being set in a single operation */
3180         int global = 0;
3181         int x;
3182
3183         if (ast_strlen_zero(data)) {
3184                 ast_log(LOG_WARNING, "Set requires at least one variable name/value pair.\n");
3185                 return 0;
3186         }
3187
3188         mydata = ast_strdupa(data);
3189         argc = ast_app_separate_args(mydata, '|', argv, sizeof(argv) / sizeof(argv[0]));
3190
3191         /* check for a trailing flags argument */
3192         if ((argc > 1) && !strchr(argv[argc-1], '=')) {
3193                 argc--;
3194                 if (strchr(argv[argc], 'g'))
3195                         global = 1;
3196         }
3197
3198         for (x = 0; x < argc; x++) {
3199                 name = argv[x];
3200                 if ((value = strchr(name, '='))) {
3201                         *value++ = '\0';
3202                         pbx_builtin_setvar_helper((global) ? NULL : chan, name, value);
3203                 } else
3204                         ast_log(LOG_WARNING, "Ignoring entry '%s' with no = (and not last 'options' entry)\n", name);
3205         }
3206
3207         return(0);
3208 }
3209
3210 int localized_pbx_builtin_setvar(struct ast_channel *chan, const void *data);
3211
3212 int localized_pbx_builtin_setvar(struct ast_channel *chan, const void *data)
3213 {
3214         return pbx_builtin_setvar(chan, data);
3215 }
3216
3217
3218 /*! \brief Helper for get_range.
3219  * return the index of the matching entry, starting from 1.
3220  * If names is not supplied, try numeric values.
3221  */
3222 static int lookup_name(const char *s, char *const names[], int max)
3223 {
3224         int i;
3225
3226         if (names && *s > '9') {
3227                 for (i = 0; names[i]; i++) {
3228                         if (!strcasecmp(s, names[i])) {
3229                                 return i;
3230                         }
3231                 }
3232         }
3233
3234         /* Allow months and weekdays to be specified as numbers, as well */
3235         if (sscanf(s, "%2d", &i) == 1 && i >= 1 && i <= max) {
3236                 /* What the array offset would have been: "1" would be at offset 0 */
3237                 return i - 1;
3238         }
3239         return -1; /* error return */
3240 }
3241
3242 /*! \brief helper function to return a range up to max (7, 12, 31 respectively).
3243  * names, if supplied, is an array of names that should be mapped to numbers.
3244  */
3245 static unsigned get_range(char *src, int max, char *const names[], const char *msg)
3246 {
3247         int start, end; /* start and ending position */
3248         unsigned int mask = 0;
3249         char *part;
3250
3251         /* Check for whole range */
3252         if (ast_strlen_zero(src) || !strcmp(src, "*")) {
3253                 return (1 << max) - 1;
3254         }
3255
3256         while ((part = strsep(&src, "&"))) {
3257                 /* Get start and ending position */
3258                 char *endpart = strchr(part, '-');
3259                 if (endpart) {
3260                         *endpart++ = '\0';
3261                 }
3262                 /* Find the start */
3263                 if ((start = lookup_name(part, names, max)) < 0) {
3264                         ast_log(LOG_WARNING, "Invalid %s '%s', skipping element\n", msg, part);
3265                         continue;
3266                 }
3267                 if (endpart) { /* find end of range */
3268                         if ((end = lookup_name(endpart, names, max)) < 0) {
3269                                 ast_log(LOG_WARNING, "Invalid end %s '%s', skipping element\n", msg, endpart);
3270                                 continue;
3271                         }
3272                 } else {
3273                         end = start;
3274                 }
3275                 /* Fill the mask. Remember that ranges are cyclic */
3276                 mask |= (1 << end);   /* initialize with last element */
3277                 while (start != end) {
3278                         if (start >= max) {
3279                                 start = 0;
3280                         }
3281                         mask |= (1 << start);
3282                         start++;
3283                 }
3284         }
3285         return mask;
3286 }
3287
3288 /*! \brief store a bitmask of valid times, one bit each 2 minute */
3289 static void get_timerange(struct ast_timing *i, char *times)
3290 {
3291         char *endpart, *part;
3292         int x;
3293         int st_h, st_m;
3294         int endh, endm;
3295         int minute_start, minute_end;
3296
3297         /* start disabling all times, fill the fields with 0's, as they may contain garbage */
3298         memset(i->minmask, 0, sizeof(i->minmask));
3299
3300         /* 1-minute per bit */
3301         /* Star is all times */
3302         if (ast_strlen_zero(times) || !strcmp(times, "*")) {
3303                 /* 48, because each hour takes 2 integers; 30 bits each */
3304                 for (x = 0; x < 48; x++) {
3305                         i->minmask[x] = 0x3fffffff; /* 30 bits */
3306                 }
3307                 return;
3308         }
3309         /* Otherwise expect a range */
3310         while ((part = strsep(&times, "&"))) {
3311                 if (!(endpart = strchr(part, '-'))) {
3312                         if (sscanf(part, "%2d:%2d", &st_h, &st_m) != 2 || st_h < 0 || st_h > 23 || st_m < 0 || st_m > 59) {
3313                                 ast_log(LOG_WARNING, "%s isn't a valid time.\n", part);
3314                                 continue;
3315                         }
3316                         i->minmask[st_h * 2 + (st_m >= 30 ? 1 : 0)] |= (1 << (st_m % 30));