main/utils.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * See http://www.asterisk.org for more information about
   7  * the Asterisk project. Please do not directly contact
   8  * any of the maintainers of this project for assistance;
   9  * the project provides a web site, mailing lists and IRC
  10  * channels for your use.
  11  *
  12  * This program is free software, distributed under the terms of
  13  * the GNU General Public License Version 2. See the LICENSE file
  14  * at the top of the source tree.
  15  */
  16
  17 /*! \file
  18  *
  19  * \brief Utility functions
  20  *
  21  * \note These are important for portability and security,
  22  * so please use them in favour of other routines.
  23  * Please consult the CODING GUIDELINES for more information.
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <ctype.h>
  31 #include <sys/stat.h>
  32
  33 #ifdef HAVE_DEV_URANDOM
  34 #include <fcntl.h>
  35 #endif
  36
  37 #include "asterisk/network.h"
  38
  39 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
  40 #include "asterisk/lock.h"
  41 #include "asterisk/io.h"
  42 #include "asterisk/md5.h"
  43 #include "asterisk/sha1.h"
  44 #include "asterisk/cli.h"
  45 #include "asterisk/linkedlists.h"
  46
  47 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
  48 #include "asterisk/strings.h"
  49
  50 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
  51 #include "asterisk/time.h"
  52
  53 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
  54 #include "asterisk/stringfields.h"
  55
  56 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
  57 #include "asterisk/utils.h"
  58
  59 #define AST_API_MODULE
  60 #include "asterisk/threadstorage.h"
  61
  62 static char base64[64];
  63 static char b2a[256];
  64
  65 AST_THREADSTORAGE(inet_ntoa_buf);
  66
  67 #if !defined(HAVE_GETHOSTBYNAME_R_5) && !defined(HAVE_GETHOSTBYNAME_R_6)
  68
  69 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
  70 #undef gethostbyname
  71
  72 AST_MUTEX_DEFINE_STATIC(__mutex);
  73
  74 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
  75 \note This
  76 routine is derived from code originally written and placed in the public
  77 domain by Enzo Michelangeli <em@em.no-ip.com> */
  78
  79 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
  80                                 size_t buflen, struct hostent **result,
  81                                 int *h_errnop)
  82 {
  83         int hsave;
  84         struct hostent *ph;
  85         ast_mutex_lock(&__mutex); /* begin critical area */
  86         hsave = h_errno;
  87
  88         ph = gethostbyname(name);
  89         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
  90         if (ph == NULL) {
  91                 *result = NULL;
  92         } else {
  93                 char **p, **q;
  94                 char *pbuf;
  95                 int nbytes = 0;
  96                 int naddr = 0, naliases = 0;
  97                 /* determine if we have enough space in buf */
  98
  99                 /* count how many addresses */
 100                 for (p = ph->h_addr_list; *p != 0; p++) {
 101                         nbytes += ph->h_length; /* addresses */
 102                         nbytes += sizeof(*p); /* pointers */
 103                         naddr++;
 104                 }
 105                 nbytes += sizeof(*p); /* one more for the terminating NULL */
 106
 107                 /* count how many aliases, and total length of strings */
 108                 for (p = ph->h_aliases; *p != 0; p++) {
 109                         nbytes += (strlen(*p)+1); /* aliases */
 110                         nbytes += sizeof(*p);  /* pointers */
 111                         naliases++;
 112                 }
 113                 nbytes += sizeof(*p); /* one more for the terminating NULL */
 114
 115                 /* here nbytes is the number of bytes required in buffer */
 116                 /* as a terminator must be there, the minimum value is ph->h_length */
 117                 if (nbytes > buflen) {
 118                         *result = NULL;
 119                         ast_mutex_unlock(&__mutex); /* end critical area */
 120                         return ERANGE; /* not enough space in buf!! */
 121                 }
 122
 123                 /* There is enough space. Now we need to do a deep copy! */
 124                 /* Allocation in buffer:
 125                         from [0] to [(naddr-1) * sizeof(*p)]:
 126                         pointers to addresses
 127                         at [naddr * sizeof(*p)]:
 128                         NULL
 129                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
 130                         pointers to aliases
 131                         at [(naddr+naliases+1) * sizeof(*p)]:
 132                         NULL
 133                         then naddr addresses (fixed length), and naliases aliases (asciiz).
 134                 */
 135
 136                 *ret = *ph;   /* copy whole structure (not its address!) */
 137
 138                 /* copy addresses */
 139                 q = (char **)buf; /* pointer to pointers area (type: char **) */
 140                 ret->h_addr_list = q; /* update pointer to address list */
 141                 pbuf = buf + ((naddr + naliases + 2) * sizeof(*p)); /* skip that area */
 142                 for (p = ph->h_addr_list; *p != 0; p++) {
 143                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
 144                         *q++ = pbuf; /* the pointer is the one inside buf... */
 145                         pbuf += ph->h_length; /* advance pbuf */
 146                 }
 147                 *q++ = NULL; /* address list terminator */
 148
 149                 /* copy aliases */
 150                 ret->h_aliases = q; /* update pointer to aliases list */
 151                 for (p = ph->h_aliases; *p != 0; p++) {
 152                         strcpy(pbuf, *p); /* copy alias strings */
 153                         *q++ = pbuf; /* the pointer is the one inside buf... */
 154                         pbuf += strlen(*p); /* advance pbuf */
 155                         *pbuf++ = 0; /* string terminator */
 156                 }
 157                 *q++ = NULL; /* terminator */
 158
 159                 strcpy(pbuf, ph->h_name); /* copy alias strings */
 160                 ret->h_name = pbuf;
 161                 pbuf += strlen(ph->h_name); /* advance pbuf */
 162                 *pbuf++ = 0; /* string terminator */
 163
 164                 *result = ret;  /* and let *result point to structure */
 165
 166         }
 167         h_errno = hsave;  /* restore h_errno */
 168         ast_mutex_unlock(&__mutex); /* end critical area */
 169
 170         return (*result == NULL); /* return 0 on success, non-zero on error */
 171 }
 172
 173
 174 #endif
 175
 176 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the
 177    standard gethostbyname (which is not thread safe)
 178 */
 179 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
 180 {
 181         int res;
 182         int herrno;
 183         int dots = 0;
 184         const char *s;
 185         struct hostent *result = NULL;
 186         /* Although it is perfectly legitimate to lookup a pure integer, for
 187            the sake of the sanity of people who like to name their peers as
 188            integers, we break with tradition and refuse to look up a
 189            pure integer */
 190         s = host;
 191         res = 0;
 192         while (s && *s) {
 193                 if (*s == '.')
 194                         dots++;
 195                 else if (!isdigit(*s))
 196                         break;
 197                 s++;
 198         }
 199         if (!s || !*s) {
 200                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
 201                 if (dots != 3)
 202                         return NULL;
 203                 memset(hp, 0, sizeof(struct ast_hostent));
 204                 hp->hp.h_addrtype = AF_INET;
 205                 hp->hp.h_addr_list = (void *) hp->buf;
 206                 hp->hp.h_addr = hp->buf + sizeof(void *);
 207                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
 208                         return &hp->hp;
 209                 return NULL;
 210
 211         }
 212 #ifdef HAVE_GETHOSTBYNAME_R_5
 213         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
 214
 215         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
 216                 return NULL;
 217 #else
 218         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
 219
 220         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
 221                 return NULL;
 222 #endif
 223         return &hp->hp;
 224 }
 225
 226
 227
 228 AST_MUTEX_DEFINE_STATIC(test_lock);
 229 AST_MUTEX_DEFINE_STATIC(test_lock2);
 230 static pthread_t test_thread;
 231 static int lock_count = 0;
 232 static int test_errors = 0;
 233
 234 /*! \brief This is a regression test for recursive mutexes.
 235    test_for_thread_safety() will return 0 if recursive mutex locks are
 236    working properly, and non-zero if they are not working properly. */
 237 static void *test_thread_body(void *data)
 238 {
 239         ast_mutex_lock(&test_lock);
 240         lock_count += 10;
 241         if (lock_count != 10)
 242                 test_errors++;
 243         ast_mutex_lock(&test_lock);
 244         lock_count += 10;
 245         if (lock_count != 20)
 246                 test_errors++;
 247         ast_mutex_lock(&test_lock2);
 248         ast_mutex_unlock(&test_lock);
 249         lock_count -= 10;
 250         if (lock_count != 10)
 251                 test_errors++;
 252         ast_mutex_unlock(&test_lock);
 253         lock_count -= 10;
 254         ast_mutex_unlock(&test_lock2);
 255         if (lock_count != 0)
 256                 test_errors++;
 257         return NULL;
 258 }
 259
 260 int test_for_thread_safety(void)
 261 {
 262         ast_mutex_lock(&test_lock2);
 263         ast_mutex_lock(&test_lock);
 264         lock_count += 1;
 265         ast_mutex_lock(&test_lock);
 266         lock_count += 1;
 267         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL);
 268         usleep(100);
 269         if (lock_count != 2)
 270                 test_errors++;
 271         ast_mutex_unlock(&test_lock);
 272         lock_count -= 1;
 273         usleep(100);
 274         if (lock_count != 1)
 275                 test_errors++;
 276         ast_mutex_unlock(&test_lock);
 277         lock_count -= 1;
 278         if (lock_count != 0)
 279                 test_errors++;
 280         ast_mutex_unlock(&test_lock2);
 281         usleep(100);
 282         if (lock_count != 0)
 283                 test_errors++;
 284         pthread_join(test_thread, NULL);
 285         return(test_errors);          /* return 0 on success. */
 286 }
 287
 288 /*! \brief Produce 32 char MD5 hash of value. */
 289 void ast_md5_hash(char *output, char *input)
 290 {
 291         struct MD5Context md5;
 292         unsigned char digest[16];
 293         char *ptr;
 294         int x;
 295
 296         MD5Init(&md5);
 297         MD5Update(&md5, (unsigned char *)input, strlen(input));
 298         MD5Final(digest, &md5);
 299         ptr = output;
 300         for (x = 0; x < 16; x++)
 301                 ptr += sprintf(ptr, "%2.2x", digest[x]);
 302 }
 303
 304 /*! \brief Produce 40 char SHA1 hash of value. */
 305 void ast_sha1_hash(char *output, char *input)
 306 {
 307         struct SHA1Context sha;
 308         char *ptr;
 309         int x;
 310         uint8_t Message_Digest[20];
 311
 312         SHA1Reset(&sha);
 313
 314         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
 315
 316         SHA1Result(&sha, Message_Digest);
 317         ptr = output;
 318         for (x = 0; x < 20; x++)
 319                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
 320 }
 321
 322 /*! \brief decode BASE64 encoded text */
 323 int ast_base64decode(unsigned char *dst, const char *src, int max)
 324 {
 325         int cnt = 0;
 326         unsigned int byte = 0;
 327         unsigned int bits = 0;
 328         int incnt = 0;
 329         while (*src && (cnt < max)) {
 330                 /* Shift in 6 bits of input */
 331                 byte <<= 6;
 332                 byte |= (b2a[(int)(*src)]) & 0x3f;
 333                 bits += 6;
 334                 src++;
 335                 incnt++;
 336                 /* If we have at least 8 bits left over, take that character
 337                    off the top */
 338                 if (bits >= 8)  {
 339                         bits -= 8;
 340                         *dst = (byte >> bits) & 0xff;
 341                         dst++;
 342                         cnt++;
 343                 }
 344         }
 345         /* Dont worry about left over bits, they're extra anyway */
 346         return cnt;
 347 }
 348
 349 /*! \brief encode text to BASE64 coding */
 350 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
 351 {
 352         int cnt = 0;
 353         int col = 0;
 354         unsigned int byte = 0;
 355         int bits = 0;
 356         int cntin = 0;
 357         /* Reserve space for null byte at end of string */
 358         max--;
 359         while ((cntin < srclen) && (cnt < max)) {
 360                 byte <<= 8;
 361                 byte |= *(src++);
 362                 bits += 8;
 363                 cntin++;
 364                 if ((bits == 24) && (cnt + 4 <= max)) {
 365                         *dst++ = base64[(byte >> 18) & 0x3f];
 366                         *dst++ = base64[(byte >> 12) & 0x3f];
 367                         *dst++ = base64[(byte >> 6) & 0x3f];
 368                         *dst++ = base64[byte & 0x3f];
 369                         cnt += 4;
 370                         col += 4;
 371                         bits = 0;
 372                         byte = 0;
 373                 }
 374                 if (linebreaks && (cnt < max) && (col == 64)) {
 375                         *dst++ = '\n';
 376                         cnt++;
 377                         col = 0;
 378                 }
 379         }
 380         if (bits && (cnt + 4 <= max)) {
 381                 /* Add one last character for the remaining bits,
 382                    padding the rest with 0 */
 383                 byte <<= 24 - bits;
 384                 *dst++ = base64[(byte >> 18) & 0x3f];
 385                 *dst++ = base64[(byte >> 12) & 0x3f];
 386                 if (bits == 16)
 387                         *dst++ = base64[(byte >> 6) & 0x3f];
 388                 else
 389                         *dst++ = '=';
 390                 *dst++ = '=';
 391                 cnt += 4;
 392         }
 393         if (linebreaks && (cnt < max)) {
 394                 *dst++ = '\n';
 395                 cnt++;
 396         }
 397         *dst = '\0';
 398         return cnt;
 399 }
 400
 401 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
 402 {
 403         return ast_base64encode_full(dst, src, srclen, max, 0);
 404 }
 405
 406 static void base64_init(void)
 407 {
 408         int x;
 409         memset(b2a, -1, sizeof(b2a));
 410         /* Initialize base-64 Conversion table */
 411         for (x = 0; x < 26; x++) {
 412                 /* A-Z */
 413                 base64[x] = 'A' + x;
 414                 b2a['A' + x] = x;
 415                 /* a-z */
 416                 base64[x + 26] = 'a' + x;
 417                 b2a['a' + x] = x + 26;
 418                 /* 0-9 */
 419                 if (x < 10) {
 420                         base64[x + 52] = '0' + x;
 421                         b2a['0' + x] = x + 52;
 422                 }
 423         }
 424         base64[62] = '+';
 425         base64[63] = '/';
 426         b2a[(int)'+'] = 62;
 427         b2a[(int)'/'] = 63;
 428 }
 429
 430 /*! \brief  ast_uri_encode: Turn text string to URI-encoded %XX version
 431 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
 432         as in the SIP protocol spec
 433         If doreserved == 1 we will convert reserved characters also.
 434         RFC 2396, section 2.4
 435         outbuf needs to have more memory allocated than the instring
 436         to have room for the expansion. Every char that is converted
 437         is replaced by three ASCII characters.
 438
 439         Note: The doreserved option is needed for replaces header in
 440         SIP transfers.
 441 */
 442 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved)
 443 {
 444         char *reserved = ";/?:@&=+$, "; /* Reserved chars */
 445
 446         const char *ptr  = string;      /* Start with the string */
 447         char *out = NULL;
 448         char *buf = NULL;
 449
 450         ast_copy_string(outbuf, string, buflen);
 451
 452         /* If there's no characters to convert, just go through and don't do anything */
 453         while (*ptr) {
 454                 if ((*ptr < 32 || (unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
 455                         /* Oops, we need to start working here */
 456                         if (!buf) {
 457                                 buf = outbuf;
 458                                 out = buf + (ptr - string) ;    /* Set output ptr */
 459                         }
 460                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
 461                 } else if (buf) {
 462                         *out = *ptr;    /* Continue copying the string */
 463                         out++;
 464                 }
 465                 ptr++;
 466         }
 467         if (buf)
 468                 *out = '\0';
 469         return outbuf;
 470 }
 471
 472 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
 473 void ast_uri_decode(char *s)
 474 {
 475         char *o;
 476         unsigned int tmp;
 477
 478         for (o = s; *s; s++, o++) {
 479                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
 480                         /* have '%', two chars and correct parsing */
 481                         *o = tmp;
 482                         s += 2; /* Will be incremented once more when we break out */
 483                 } else /* all other cases, just copy */
 484                         *o = *s;
 485         }
 486         *o = '\0';
 487 }
 488
 489 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
 490 const char *ast_inet_ntoa(struct in_addr ia)
 491 {
 492         char *buf;
 493
 494         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
 495                 return "";
 496
 497         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
 498 }
 499
 500 #ifdef HAVE_DEV_URANDOM
 501 static int dev_urandom_fd;
 502 #endif
 503
 504 #ifndef __linux__
 505 #undef pthread_create /* For ast_pthread_create function only */
 506 #endif /* !__linux__ */
 507
 508 #if !defined(LOW_MEMORY)
 509
 510 #ifdef DEBUG_THREADS
 511
 512 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
 513 #define AST_MAX_LOCKS 64
 514
 515 /* Allow direct use of pthread_mutex_t and friends */
 516 #undef pthread_mutex_t
 517 #undef pthread_mutex_lock
 518 #undef pthread_mutex_unlock
 519 #undef pthread_mutex_init
 520 #undef pthread_mutex_destroy
 521
 522 /*!
 523  * \brief Keep track of which locks a thread holds
 524  *
 525  * There is an instance of this struct for every active thread
 526  */
 527 struct thr_lock_info {
 528         /*! The thread's ID */
 529         pthread_t thread_id;
 530         /*! The thread name which includes where the thread was started */
 531         const char *thread_name;
 532         /*! This is the actual container of info for what locks this thread holds */
 533         struct {
 534                 const char *file;
 535                 int line_num;
 536                 const char *func;
 537                 const char *lock_name;
 538                 void *lock_addr;
 539                 int times_locked;
 540                 enum ast_lock_type type;
 541                 /*! This thread is waiting on this lock */
 542                 int pending:2;
 543         } locks[AST_MAX_LOCKS];
 544         /*! This is the number of locks currently held by this thread.
 545          *  The index (num_locks - 1) has the info on the last one in the
 546          *  locks member */
 547         unsigned int num_locks;
 548         /*! Protects the contents of the locks member
 549          * Intentionally not ast_mutex_t */
 550         pthread_mutex_t lock;
 551         AST_LIST_ENTRY(thr_lock_info) entry;
 552 };
 553
 554 /*!
 555  * \brief Locked when accessing the lock_infos list
 556  */
 557 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
 558 /*!
 559  * \brief A list of each thread's lock info
 560  */
 561 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
 562
 563 /*!
 564  * \brief Destroy a thread's lock info
 565  *
 566  * This gets called automatically when the thread stops
 567  */
 568 static void lock_info_destroy(void *data)
 569 {
 570         struct thr_lock_info *lock_info = data;
 571
 572         pthread_mutex_lock(&lock_infos_lock.mutex);
 573         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
 574         pthread_mutex_unlock(&lock_infos_lock.mutex);
 575
 576         pthread_mutex_destroy(&lock_info->lock);
 577         if (lock_info->thread_name)
 578                 free((void *) lock_info->thread_name);
 579         free(lock_info);
 580 }
 581
 582 /*!
 583  * \brief The thread storage key for per-thread lock info
 584  */
 585 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
 586
 587 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
 588         int line_num, const char *func, const char *lock_name, void *lock_addr)
 589 {
 590         struct thr_lock_info *lock_info;
 591         int i;
 592
 593         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
 594                 return;
 595
 596         pthread_mutex_lock(&lock_info->lock);
 597
 598         for (i = 0; i < lock_info->num_locks; i++) {
 599                 if (lock_info->locks[i].lock_addr == lock_addr) {
 600                         lock_info->locks[i].times_locked++;
 601                         pthread_mutex_unlock(&lock_info->lock);
 602                         return;
 603                 }
 604         }
 605
 606         if (lock_info->num_locks == AST_MAX_LOCKS) {
 607                 /* Can't use ast_log here, because it will cause infinite recursion */
 608                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
 609                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
 610                 pthread_mutex_unlock(&lock_info->lock);
 611                 return;
 612         }
 613
 614         if (i && lock_info->locks[i].pending == -1) {
 615                 /* The last lock on the list was one that this thread tried to lock but
 616                  * failed at doing so.  It has now moved on to something else, so remove
 617                  * the old lock from the list. */
 618                 i--;
 619                 lock_info->num_locks--;
 620                 memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
 621         }
 622
 623         lock_info->locks[i].file = filename;
 624         lock_info->locks[i].line_num = line_num;
 625         lock_info->locks[i].func = func;
 626         lock_info->locks[i].lock_name = lock_name;
 627         lock_info->locks[i].lock_addr = lock_addr;
 628         lock_info->locks[i].times_locked = 1;
 629         lock_info->locks[i].type = type;
 630         lock_info->locks[i].pending = 1;
 631         lock_info->num_locks++;
 632
 633         pthread_mutex_unlock(&lock_info->lock);
 634 }
 635
 636 void ast_mark_lock_acquired(void *lock_addr)
 637 {
 638         struct thr_lock_info *lock_info;
 639
 640         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
 641                 return;
 642
 643         pthread_mutex_lock(&lock_info->lock);
 644         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
 645                 lock_info->locks[lock_info->num_locks - 1].pending = 0;
 646         }
 647         pthread_mutex_unlock(&lock_info->lock);
 648 }
 649
 650 void ast_mark_lock_failed(void *lock_addr)
 651 {
 652         struct thr_lock_info *lock_info;
 653
 654         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
 655                 return;
 656
 657         pthread_mutex_lock(&lock_info->lock);
 658         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
 659                 lock_info->locks[lock_info->num_locks - 1].pending = -1;
 660                 lock_info->locks[lock_info->num_locks - 1].times_locked--;
 661         }
 662         pthread_mutex_unlock(&lock_info->lock);
 663 }
 664
 665 void ast_remove_lock_info(void *lock_addr)
 666 {
 667         struct thr_lock_info *lock_info;
 668         int i = 0;
 669
 670         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
 671                 return;
 672
 673         pthread_mutex_lock(&lock_info->lock);
 674
 675         for (i = lock_info->num_locks - 1; i >= 0; i--) {
 676                 if (lock_info->locks[i].lock_addr == lock_addr)
 677                         break;
 678         }
 679
 680         if (i == -1) {
 681                 /* Lock not found :( */
 682                 pthread_mutex_unlock(&lock_info->lock);
 683                 return;
 684         }
 685
 686         if (lock_info->locks[i].times_locked > 1) {
 687                 lock_info->locks[i].times_locked--;
 688                 pthread_mutex_unlock(&lock_info->lock);
 689                 return;
 690         }
 691
 692         if (i < lock_info->num_locks - 1) {
 693                 /* Not the last one ... *should* be rare! */
 694                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1],
 695                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
 696         }
 697
 698         lock_info->num_locks--;
 699
 700         pthread_mutex_unlock(&lock_info->lock);
 701 }
 702
 703 static const char *locktype2str(enum ast_lock_type type)
 704 {
 705         switch (type) {
 706         case AST_MUTEX:
 707                 return "MUTEX";
 708         case AST_RDLOCK:
 709                 return "RDLOCK";
 710         case AST_WRLOCK:
 711                 return "WRLOCK";
 712         }
 713
 714         return "UNKNOWN";
 715 }
 716
 717 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 718 {
 719         struct thr_lock_info *lock_info;
 720         struct ast_str *str;
 721
 722         if (!(str = ast_str_create(4096)))
 723                 return CLI_FAILURE;
 724
 725         switch (cmd) {
 726         case CLI_INIT:
 727                 e->command = "core show locks";
 728                 e->usage =
 729                         "Usage: core show locks\n"
 730                         "       This command is for lock debugging.  It prints out which locks\n"
 731                         "are owned by each active thread.\n";
 732                 return NULL;
 733
 734         case CLI_GENERATE:
 735                 return NULL;
 736         }
 737
 738         ast_str_append(&str, 0, "\n"
 739                        "=======================================================================\n"
 740                        "=== Currently Held Locks ==============================================\n"
 741                        "=======================================================================\n"
 742                        "===\n"
 743                        "=== <file> <line num> <function> <lock name> <lock addr> (times locked)\n"
 744                        "===\n");
 745
 746         if (!str)
 747                 return CLI_FAILURE;
 748
 749         pthread_mutex_lock(&lock_infos_lock.mutex);
 750         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
 751                 int i;
 752                 ast_str_append(&str, 0, "=== Thread ID: %d (%s)\n", (int) lock_info->thread_id,
 753                         lock_info->thread_name);
 754                 pthread_mutex_lock(&lock_info->lock);
 755                 for (i = 0; str && i < lock_info->num_locks; i++) {
 756                         int j;
 757                         ast_mutex_t *lock;
 758
 759                         ast_str_append(&str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d)\n",
 760                                 lock_info->locks[i].pending > 0 ? "Waiting for " :
 761                                         lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
 762                                 lock_info->locks[i].file,
 763                                 locktype2str(lock_info->locks[i].type),
 764                                 lock_info->locks[i].line_num,
 765                                 lock_info->locks[i].func, lock_info->locks[i].lock_name,
 766                                 lock_info->locks[i].lock_addr,
 767                                 lock_info->locks[i].times_locked);
 768
 769                         if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
 770                                 continue;
 771
 772                         /* We only have further details for mutexes right now */
 773                         if (lock_info->locks[i].type != AST_MUTEX)
 774                                 continue;
 775
 776                         lock = lock_info->locks[i].lock_addr;
 777
 778                         ast_reentrancy_lock(lock);
 779                         for (j = 0; str && j < lock->reentrancy; j++) {
 780                                 ast_str_append(&str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
 781                                         lock->file[j], lock->lineno[j], lock->func[j]);
 782                         }
 783                         ast_reentrancy_unlock(lock);
 784                 }
 785                 pthread_mutex_unlock(&lock_info->lock);
 786                 if (!str)
 787                         break;
 788                 ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
 789                                "===\n");
 790                 if (!str)
 791                         break;
 792         }
 793         pthread_mutex_unlock(&lock_infos_lock.mutex);
 794
 795         if (!str)
 796                 return CLI_FAILURE;
 797
 798         ast_str_append(&str, 0, "=======================================================================\n"
 799                        "\n");
 800
 801         if (!str)
 802                 return CLI_FAILURE;
 803
 804         ast_cli(a->fd, "%s", str->str);
 805
 806         ast_free(str);
 807
 808         return CLI_SUCCESS;
 809 }
 810
 811 static struct ast_cli_entry utils_cli[] = {
 812         AST_CLI_DEFINE(handle_show_locks, "Show which locks are held by which thread"),
 813 };
 814
 815 #endif /* DEBUG_THREADS */
 816
 817 /*
 818  * support for 'show threads'. The start routine is wrapped by
 819  * dummy_start(), so that ast_register_thread() and
 820  * ast_unregister_thread() know the thread identifier.
 821  */
 822 struct thr_arg {
 823         void *(*start_routine)(void *);
 824         void *data;
 825         char *name;
 826 };
 827
 828 /*
 829  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
 830  * are odd macros which start and end a block, so they _must_ be
 831  * used in pairs (the latter with a '1' argument to call the
 832  * handler on exit.
 833  * On BSD we don't need this, but we keep it for compatibility.
 834  */
 835 static void *dummy_start(void *data)
 836 {
 837         void *ret;
 838         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
 839 #ifdef DEBUG_THREADS
 840         struct thr_lock_info *lock_info;
 841         pthread_mutexattr_t mutex_attr;
 842 #endif
 843
 844         /* note that even though data->name is a pointer to allocated memory,
 845            we are not freeing it here because ast_register_thread is going to
 846            keep a copy of the pointer and then ast_unregister_thread will
 847            free the memory
 848         */
 849         ast_free(data);
 850         ast_register_thread(a.name);
 851         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
 852
 853 #ifdef DEBUG_THREADS
 854         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
 855                 return NULL;
 856
 857         lock_info->thread_id = pthread_self();
 858         lock_info->thread_name = strdup(a.name);
 859
 860         pthread_mutexattr_init(&mutex_attr);
 861         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
 862         pthread_mutex_init(&lock_info->lock, &mutex_attr);
 863         pthread_mutexattr_destroy(&mutex_attr);
 864
 865         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
 866         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
 867         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
 868 #endif /* DEBUG_THREADS */
 869
 870         ret = a.start_routine(a.data);
 871
 872         pthread_cleanup_pop(1);
 873
 874         return ret;
 875 }
 876
 877 #endif /* !LOW_MEMORY */
 878
 879 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
 880                              void *data, size_t stacksize, const char *file, const char *caller,
 881                              int line, const char *start_fn)
 882 {
 883 #if !defined(LOW_MEMORY)
 884         struct thr_arg *a;
 885 #endif
 886
 887         if (!attr) {
 888                 attr = alloca(sizeof(*attr));
 889                 pthread_attr_init(attr);
 890         }
 891
 892 #ifdef __linux__
 893         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
 894            which is kind of useless. Change this here to
 895            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
 896            priority will propagate down to new threads by default.
 897            This does mean that callers cannot set a different priority using
 898            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
 899            the priority afterwards with pthread_setschedparam(). */
 900         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
 901                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
 902 #endif
 903
 904         if (!stacksize)
 905                 stacksize = AST_STACKSIZE;
 906
 907         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
 908                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
 909
 910 #if !defined(LOW_MEMORY)
 911         if ((a = ast_malloc(sizeof(*a)))) {
 912                 a->start_routine = start_routine;
 913                 a->data = data;
 914                 start_routine = dummy_start;
 915                 asprintf(&a->name, "%-20s started at [%5d] %s %s()",
 916                          start_fn, line, file, caller);
 917                 data = a;
 918         }
 919 #endif /* !LOW_MEMORY */
 920
 921         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
 922 }
 923
 924
 925 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
 926                              void *data, size_t stacksize, const char *file, const char *caller,
 927                              int line, const char *start_fn)
 928 {
 929         unsigned char attr_destroy = 0;
 930         int res;
 931
 932         if (!attr) {
 933                 attr = alloca(sizeof(*attr));
 934                 pthread_attr_init(attr);
 935                 attr_destroy = 1;
 936         }
 937
 938         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
 939                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
 940
 941         res = ast_pthread_create_stack(thread, attr, start_routine, data,
 942                                        stacksize, file, caller, line, start_fn);
 943
 944         if (attr_destroy)
 945                 pthread_attr_destroy(attr);
 946
 947         return res;
 948 }
 949
 950 int ast_wait_for_input(int fd, int ms)
 951 {
 952         struct pollfd pfd[1];
 953         memset(pfd, 0, sizeof(pfd));
 954         pfd[0].fd = fd;
 955         pfd[0].events = POLLIN|POLLPRI;
 956         return poll(pfd, 1, ms);
 957 }
 958
 959 /*!
 960  * Try to write string, but wait no more than ms milliseconds before timing out.
 961  *
 962  * \note The code assumes that the file descriptor has NONBLOCK set,
 963  * so there is only one system call made to do a write, unless we actually
 964  * have a need to wait.  This way, we get better performance.
 965  * If the descriptor is blocking, all assumptions on the guaranteed
 966  * detail do not apply anymore.
 967  * Also note that in the current implementation, the delay is per-write,
 968  * so you still have no guarantees, anyways.
 969  * Fortunately the routine is only used in a few places (cli.c, manager.c,
 970  * res_agi.c) so it is reasonably easy to check how it behaves there.
 971  *
 972  * XXX We either need to fix the code, or fix the documentation.
 973  */
 974 int ast_carefulwrite(int fd, char *s, int len, int timeoutms)
 975 {
 976         /* Try to write string, but wait no more than ms milliseconds
 977            before timing out */
 978         int res = 0;
 979         struct pollfd fds[1];
 980         while (len) {
 981                 res = write(fd, s, len);
 982                 if ((res < 0) && (errno != EAGAIN)) {
 983                         return -1;
 984                 }
 985                 if (res < 0)
 986                         res = 0;
 987                 len -= res;
 988                 s += res;
 989                 res = 0;
 990                 if (len) {
 991                         fds[0].fd = fd;
 992                         fds[0].events = POLLOUT;
 993                         /* Wait until writable again */
 994                         res = poll(fds, 1, timeoutms);
 995                         if (res < 1)
 996                                 return -1;
 997                 }
 998         }
 999         return res;
1000 }
1001
1002 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1003 {
1004         char *e;
1005         char *q;
1006
1007         s = ast_strip(s);
1008         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1009                 e = s + strlen(s) - 1;
1010                 if (*e == *(end_quotes + (q - beg_quotes))) {
1011                         s++;
1012                         *e = '\0';
1013                 }
1014         }
1015
1016         return s;
1017 }
1018
1019 char *ast_unescape_semicolon(char *s)
1020 {
1021         char *e;
1022         char *work = s;
1023
1024         while ((e = strchr(work, ';'))) {
1025                 if ((e > work) && (*(e-1) == '\\')) {
1026                         memmove(e - 1, e, strlen(e) + 1);
1027                         work = e;
1028                 } else {
1029                         work = e + 1;
1030                 }
1031         }
1032
1033         return s;
1034 }
1035
1036 /* !\brief unescape some C sequences in place, return pointer to the original string.
1037  */
1038 char *ast_unescape_c(char *src)
1039 {
1040         char c, *ret, *dst;
1041
1042         if (src == NULL)
1043                 return NULL;
1044         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1045                 if (c != '\\')
1046                         continue;       /* copy char at the end of the loop */
1047                 switch ((c = *src++)) {
1048                 case '\0':      /* special, trailing '\' */
1049                         c = '\\';
1050                         break;
1051                 case 'b':       /* backspace */
1052                         c = '\b';
1053                         break;
1054                 case 'f':       /* form feed */
1055                         c = '\f';
1056                         break;
1057                 case 'n':
1058                         c = '\n';
1059                         break;
1060                 case 'r':
1061                         c = '\r';
1062                         break;
1063                 case 't':
1064                         c = '\t';
1065                         break;
1066                 }
1067                 /* default, use the char literally */
1068         }
1069         *dst = '\0';
1070         return ret;
1071 }
1072
1073 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1074 {
1075         int result;
1076
1077         if (!buffer || !*buffer || !space || !*space)
1078                 return -1;
1079
1080         result = vsnprintf(*buffer, *space, fmt, ap);
1081
1082         if (result < 0)
1083                 return -1;
1084         else if (result > *space)
1085                 result = *space;
1086
1087         *buffer += result;
1088         *space -= result;
1089         return 0;
1090 }
1091
1092 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1093 {
1094         va_list ap;
1095         int result;
1096
1097         va_start(ap, fmt);
1098         result = ast_build_string_va(buffer, space, fmt, ap);
1099         va_end(ap);
1100
1101         return result;
1102 }
1103
1104 int ast_true(const char *s)
1105 {
1106         if (ast_strlen_zero(s))
1107                 return 0;
1108
1109         /* Determine if this is a true value */
1110         if (!strcasecmp(s, "yes") ||
1111             !strcasecmp(s, "true") ||
1112             !strcasecmp(s, "y") ||
1113             !strcasecmp(s, "t") ||
1114             !strcasecmp(s, "1") ||
1115             !strcasecmp(s, "on"))
1116                 return -1;
1117
1118         return 0;
1119 }
1120
1121 int ast_false(const char *s)
1122 {
1123         if (ast_strlen_zero(s))
1124                 return 0;
1125
1126         /* Determine if this is a false value */
1127         if (!strcasecmp(s, "no") ||
1128             !strcasecmp(s, "false") ||
1129             !strcasecmp(s, "n") ||
1130             !strcasecmp(s, "f") ||
1131             !strcasecmp(s, "0") ||
1132             !strcasecmp(s, "off"))
1133                 return -1;
1134
1135         return 0;
1136 }
1137
1138 #define ONE_MILLION     1000000
1139 /*
1140  * put timeval in a valid range. usec is 0..999999
1141  * negative values are not allowed and truncated.
1142  */
1143 static struct timeval tvfix(struct timeval a)
1144 {
1145         if (a.tv_usec >= ONE_MILLION) {
1146                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1147                         a.tv_sec, (long int) a.tv_usec);
1148                 a.tv_sec += a.tv_usec / ONE_MILLION;
1149                 a.tv_usec %= ONE_MILLION;
1150         } else if (a.tv_usec < 0) {
1151                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1152                         a.tv_sec, (long int) a.tv_usec);
1153                 a.tv_usec = 0;
1154         }
1155         return a;
1156 }
1157
1158 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1159 {
1160         /* consistency checks to guarantee usec in 0..999999 */
1161         a = tvfix(a);
1162         b = tvfix(b);
1163         a.tv_sec += b.tv_sec;
1164         a.tv_usec += b.tv_usec;
1165         if (a.tv_usec >= ONE_MILLION) {
1166                 a.tv_sec++;
1167                 a.tv_usec -= ONE_MILLION;
1168         }
1169         return a;
1170 }
1171
1172 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1173 {
1174         /* consistency checks to guarantee usec in 0..999999 */
1175         a = tvfix(a);
1176         b = tvfix(b);
1177         a.tv_sec -= b.tv_sec;
1178         a.tv_usec -= b.tv_usec;
1179         if (a.tv_usec < 0) {
1180                 a.tv_sec-- ;
1181                 a.tv_usec += ONE_MILLION;
1182         }
1183         return a;
1184 }
1185 #undef ONE_MILLION
1186
1187 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1188  * BSD libc (and others) do not. */
1189
1190 #ifndef linux
1191 AST_MUTEX_DEFINE_STATIC(randomlock);
1192 #endif
1193
1194 long int ast_random(void)
1195 {
1196         long int res;
1197 #ifdef HAVE_DEV_URANDOM
1198         if (dev_urandom_fd >= 0) {
1199                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1200                 if (read_res > 0) {
1201                         long int rm = RAND_MAX;
1202                         res = res < 0 ? ~res : res;
1203                         rm++;
1204                         return res % rm;
1205                 }
1206         }
1207 #endif
1208 #ifdef linux
1209         res = random();
1210 #else
1211         ast_mutex_lock(&randomlock);
1212         res = random();
1213         ast_mutex_unlock(&randomlock);
1214 #endif
1215         return res;
1216 }
1217
1218 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1219 {
1220         char *dataPut = start;
1221         int inEscape = 0;
1222         int inQuotes = 0;
1223
1224         for (; *start; start++) {
1225                 if (inEscape) {
1226                         *dataPut++ = *start;       /* Always goes verbatim */
1227                         inEscape = 0;
1228                 } else {
1229                         if (*start == '\\') {
1230                                 inEscape = 1;      /* Do not copy \ into the data */
1231                         } else if (*start == '\'') {
1232                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1233                         } else {
1234                                 /* Replace , with |, unless in quotes */
1235                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1236                         }
1237                 }
1238         }
1239         if (start != dataPut)
1240                 *dataPut = 0;
1241         return dataPut;
1242 }
1243
1244 void ast_join(char *s, size_t len, char * const w[])
1245 {
1246         int x, ofs = 0;
1247         const char *src;
1248
1249         /* Join words into a string */
1250         if (!s)
1251                 return;
1252         for (x = 0; ofs < len && w[x]; x++) {
1253                 if (x > 0)
1254                         s[ofs++] = ' ';
1255                 for (src = w[x]; *src && ofs < len; src++)
1256                         s[ofs++] = *src;
1257         }
1258         if (ofs == len)
1259                 ofs--;
1260         s[ofs] = '\0';
1261 }
1262
1263 /*
1264  * stringfields support routines.
1265  */
1266
1267 const char __ast_string_field_empty[] = ""; /*!< the empty string */
1268
1269 /*! \brief add a new block to the pool.
1270  * We can only allocate from the topmost pool, so the
1271  * fields in *mgr reflect the size of that only.
1272  */
1273 static int add_string_pool(struct ast_string_field_mgr *mgr,
1274         struct ast_string_field_pool **pool_head, size_t size)
1275 {
1276         struct ast_string_field_pool *pool;
1277
1278         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
1279                 return -1;
1280
1281         pool->prev = *pool_head;
1282         *pool_head = pool;
1283         mgr->size = size;
1284         mgr->used = 0;
1285
1286         return 0;
1287 }
1288
1289 /*
1290  * This is an internal API, code should not use it directly.
1291  * It initializes all fields as empty, then uses 'size' for 3 functions:
1292  * size > 0 means initialize the pool list with a pool of given size.
1293  *      This must be called right after allocating the object.
1294  * size = 0 means release all pools except the most recent one.
1295  *      This is useful to e.g. reset an object to the initial value.
1296  * size < 0 means release all pools.
1297  *      This must be done before destroying the object.
1298  */
1299 int __ast_string_field_init(struct ast_string_field_mgr *mgr,
1300         struct ast_string_field_pool **pool_head, int size)
1301 {
1302         const char **p = (const char **)pool_head + 1;
1303         struct ast_string_field_pool *cur = *pool_head;
1304
1305         /* clear fields - this is always necessary */
1306         while ((struct ast_string_field_mgr *)p != mgr)
1307                 *p++ = __ast_string_field_empty;
1308         if (size > 0) {                 /* allocate the initial pool */
1309                 *pool_head = NULL;
1310                 return add_string_pool(mgr, pool_head, size);
1311         }
1312         if (size < 0) {                 /* reset all pools */
1313                 *pool_head = NULL;
1314         } else {                        /* preserve the first pool */
1315                 if (cur == NULL) {
1316                         ast_log(LOG_WARNING, "trying to reset empty pool\n");
1317                         return -1;
1318                 }
1319                 cur = cur->prev;
1320                 (*pool_head)->prev = NULL;
1321                 mgr->used = 0;
1322         }
1323         while (cur) {
1324                 struct ast_string_field_pool *prev = cur->prev;
1325                 ast_free(cur);
1326                 cur = prev;
1327         }
1328         return 0;
1329 }
1330
1331 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr,
1332         struct ast_string_field_pool **pool_head, size_t needed)
1333 {
1334         char *result = NULL;
1335         size_t space = mgr->size - mgr->used;
1336
1337         if (__builtin_expect(needed > space, 0)) {
1338                 size_t new_size = mgr->size * 2;
1339
1340                 while (new_size < needed)
1341                         new_size *= 2;
1342
1343                 if (add_string_pool(mgr, pool_head, new_size))
1344                         return NULL;
1345         }
1346
1347         result = (*pool_head)->base + mgr->used;
1348         mgr->used += needed;
1349         return result;
1350 }
1351
1352 void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
1353         struct ast_string_field_pool **pool_head,
1354         const ast_string_field *ptr, const char *format, va_list ap1, va_list ap2)
1355 {
1356         size_t needed;
1357         char *dst = (*pool_head)->base + mgr->used;
1358         const char **p = (const char **)ptr;
1359         size_t space = mgr->size - mgr->used;
1360
1361         /* try to write using available space */
1362         needed = vsnprintf(dst, space, format, ap1) + 1;
1363
1364         va_end(ap1);
1365
1366         if (needed > space) {   /* if it fails, reallocate */
1367                 size_t new_size = mgr->size * 2;
1368
1369                 while (new_size < needed)
1370                         new_size *= 2;
1371
1372                 if (add_string_pool(mgr, pool_head, new_size))
1373                         return;
1374
1375                 dst = (*pool_head)->base + mgr->used;
1376                 vsprintf(dst, format, ap2);
1377         }
1378
1379         *p = dst;
1380         mgr->used += needed;
1381 }
1382
1383 void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
1384         struct ast_string_field_pool **pool_head,
1385         const ast_string_field *ptr, const char *format, ...)
1386 {
1387         va_list ap1, ap2;
1388
1389         va_start(ap1, format);
1390         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
1391
1392         __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2);
1393
1394         va_end(ap1);
1395         va_end(ap2);
1396 }
1397 /* end of stringfields support */
1398
1399 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1400
1401 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1402 {
1403         int ret;
1404         ast_mutex_lock(&fetchadd_m);
1405         ret = *p;
1406         *p += v;
1407         ast_mutex_unlock(&fetchadd_m);
1408         return ret;
1409 }
1410
1411 /*! \brief
1412  * get values from config variables.
1413  */
1414 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
1415 {
1416         long double dtv = 0.0;
1417         int scanned;
1418
1419         if (dst == NULL)
1420                 return -1;
1421
1422         *dst = _default;
1423
1424         if (ast_strlen_zero(src))
1425                 return -1;
1426
1427         /* only integer at the moment, but one day we could accept more formats */
1428         if (sscanf(src, "%Lf%n", &dtv, &scanned) > 0) {
1429                 dst->tv_sec = dtv;
1430                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
1431                 if (consumed)
1432                         *consumed = scanned;
1433                 return 0;
1434         } else
1435                 return -1;
1436 }
1437
1438 /*! \brief
1439  * get values from config variables.
1440  */
1441 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1442 {
1443         long t;
1444         int scanned;
1445
1446         if (dst == NULL)
1447                 return -1;
1448
1449         *dst = _default;
1450
1451         if (ast_strlen_zero(src))
1452                 return -1;
1453
1454         /* only integer at the moment, but one day we could accept more formats */
1455         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
1456                 *dst = t;
1457                 if (consumed)
1458                         *consumed = scanned;
1459                 return 0;
1460         } else
1461                 return -1;
1462 }
1463
1464 /*!
1465  * core handler for dynamic strings.
1466  * This is not meant to be called directly, but rather through the
1467  * various wrapper macros
1468  *      ast_str_set(...)
1469  *      ast_str_append(...)
1470  *      ast_str_set_va(...)
1471  *      ast_str_append_va(...)
1472  */
1473 int __ast_str_helper(struct ast_str **buf, size_t max_len,
1474         int append, const char *fmt, va_list ap)
1475 {
1476         int res, need;
1477         int offset = (append && (*buf)->len) ? (*buf)->used : 0;
1478
1479         if (max_len < 0)
1480                 max_len = (*buf)->len;  /* don't exceed the allocated space */
1481         /*
1482          * Ask vsnprintf how much space we need. Remember that vsnprintf
1483          * does not count the final '\0' so we must add 1.
1484          */
1485         res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap);
1486
1487         need = res + offset + 1;
1488         /*
1489          * If there is not enough space and we are below the max length,
1490          * reallocate the buffer and return a message telling to retry.
1491          */
1492         if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
1493                 if (max_len && max_len < need)  /* truncate as needed */
1494                         need = max_len;
1495                 else if (max_len == 0)  /* if unbounded, give more room for next time */
1496                         need += 16 + need/4;
1497                 if (0)  /* debugging */
1498                         ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need);
1499                 if (ast_str_make_space(buf, need)) {
1500                         ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need);
1501                         return AST_DYNSTR_BUILD_FAILED;
1502                 }
1503                 (*buf)->str[offset] = '\0';     /* Truncate the partial write. */
1504
1505                 /* va_end() and va_start() must be done before calling
1506                  * vsnprintf() again. */
1507                 return AST_DYNSTR_BUILD_RETRY;
1508         }
1509         /* update space used, keep in mind the truncation */
1510         (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len : res + offset;
1511
1512         return res;
1513 }
1514
1515 void ast_enable_packet_fragmentation(int sock)
1516 {
1517 #if defined(HAVE_IP_MTU_DISCOVER)
1518         int val = IP_PMTUDISC_DONT;
1519
1520         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1521                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1522 #endif /* HAVE_IP_MTU_DISCOVER */
1523 }
1524
1525 int ast_mkdir(const char *path, int mode)
1526 {
1527         char *ptr;
1528         int len = strlen(path), count = 0, x, piececount = 0;
1529         char *tmp = ast_strdupa(path);
1530         char **pieces;
1531         char *fullpath = alloca(len + 1);
1532         int res = 0;
1533
1534         for (ptr = tmp; *ptr; ptr++) {
1535                 if (*ptr == '/')
1536                         count++;
1537         }
1538
1539         /* Count the components to the directory path */
1540         pieces = alloca(count * sizeof(*pieces));
1541         for (ptr = tmp; *ptr; ptr++) {
1542                 if (*ptr == '/') {
1543                         *ptr = '\0';
1544                         pieces[piececount++] = ptr + 1;
1545                 }
1546         }
1547
1548         *fullpath = '\0';
1549         for (x = 0; x < piececount; x++) {
1550                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
1551                 strcat(fullpath, "/");
1552                 strcat(fullpath, pieces[x]);
1553                 res = mkdir(fullpath, mode);
1554                 if (res && errno != EEXIST)
1555                         return errno;
1556         }
1557         return 0;
1558 }
1559
1560 int ast_utils_init(void)
1561 {
1562 #ifdef HAVE_DEV_URANDOM
1563         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
1564 #endif
1565         base64_init();
1566 #ifdef DEBUG_THREADS
1567         ast_cli_register_multiple(utils_cli, sizeof(utils_cli) / sizeof(utils_cli[0]));
1568 #endif
1569         return 0;
1570 }