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