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