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