utils/extconf.c

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