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