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