cdb9b1a440a6e4be52812bf92ed661eb00c6bd4e
[asterisk/asterisk.git] / 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 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include <ctype.h>
35 #include <sys/stat.h>
36 #include <sys/stat.h>
37
38 #include <fcntl.h>
39
40 #include <sys/syscall.h>
41 #if defined(__APPLE__)
42 #include <mach/mach.h>
43 #elif defined(HAVE_SYS_THR_H)
44 #include <sys/thr.h>
45 #endif
46
47 #include "asterisk/network.h"
48
49 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
50 #include "asterisk/lock.h"
51 #include "asterisk/io.h"
52 #include "asterisk/md5.h"
53 #include "asterisk/sha1.h"
54 #include "asterisk/cli.h"
55 #include "asterisk/linkedlists.h"
56
57 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
58 #include "asterisk/strings.h"
59
60 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
61 #include "asterisk/time.h"
62
63 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
64 #include "asterisk/stringfields.h"
65
66 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
67 #include "asterisk/utils.h"
68
69 #define AST_API_MODULE
70 #include "asterisk/threadstorage.h"
71
72 #define AST_API_MODULE
73 #include "asterisk/config.h"
74
75 static char base64[64];
76 static char b2a[256];
77
78 AST_THREADSTORAGE(inet_ntoa_buf);
79
80 #if !defined(HAVE_GETHOSTBYNAME_R_5) && !defined(HAVE_GETHOSTBYNAME_R_6)
81
82 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
83 #undef gethostbyname
84
85 AST_MUTEX_DEFINE_STATIC(__mutex);
86
87 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
88 \note This
89 routine is derived from code originally written and placed in the public
90 domain by Enzo Michelangeli <em@em.no-ip.com> */
91
92 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
93                                 size_t buflen, struct hostent **result,
94                                 int *h_errnop)
95 {
96         int hsave;
97         struct hostent *ph;
98         ast_mutex_lock(&__mutex); /* begin critical area */
99         hsave = h_errno;
100
101         ph = gethostbyname(name);
102         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
103         if (ph == NULL) {
104                 *result = NULL;
105         } else {
106                 char **p, **q;
107                 char *pbuf;
108                 int nbytes = 0;
109                 int naddr = 0, naliases = 0;
110                 /* determine if we have enough space in buf */
111
112                 /* count how many addresses */
113                 for (p = ph->h_addr_list; *p != 0; p++) {
114                         nbytes += ph->h_length; /* addresses */
115                         nbytes += sizeof(*p); /* pointers */
116                         naddr++;
117                 }
118                 nbytes += sizeof(*p); /* one more for the terminating NULL */
119
120                 /* count how many aliases, and total length of strings */
121                 for (p = ph->h_aliases; *p != 0; p++) {
122                         nbytes += (strlen(*p)+1); /* aliases */
123                         nbytes += sizeof(*p);  /* pointers */
124                         naliases++;
125                 }
126                 nbytes += sizeof(*p); /* one more for the terminating NULL */
127
128                 /* here nbytes is the number of bytes required in buffer */
129                 /* as a terminator must be there, the minimum value is ph->h_length */
130                 if (nbytes > buflen) {
131                         *result = NULL;
132                         ast_mutex_unlock(&__mutex); /* end critical area */
133                         return ERANGE; /* not enough space in buf!! */
134                 }
135
136                 /* There is enough space. Now we need to do a deep copy! */
137                 /* Allocation in buffer:
138                         from [0] to [(naddr-1) * sizeof(*p)]:
139                         pointers to addresses
140                         at [naddr * sizeof(*p)]:
141                         NULL
142                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
143                         pointers to aliases
144                         at [(naddr+naliases+1) * sizeof(*p)]:
145                         NULL
146                         then naddr addresses (fixed length), and naliases aliases (asciiz).
147                 */
148
149                 *ret = *ph;   /* copy whole structure (not its address!) */
150
151                 /* copy addresses */
152                 q = (char **)buf; /* pointer to pointers area (type: char **) */
153                 ret->h_addr_list = q; /* update pointer to address list */
154                 pbuf = buf + ((naddr + naliases + 2) * sizeof(*p)); /* skip that area */
155                 for (p = ph->h_addr_list; *p != 0; p++) {
156                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
157                         *q++ = pbuf; /* the pointer is the one inside buf... */
158                         pbuf += ph->h_length; /* advance pbuf */
159                 }
160                 *q++ = NULL; /* address list terminator */
161
162                 /* copy aliases */
163                 ret->h_aliases = q; /* update pointer to aliases list */
164                 for (p = ph->h_aliases; *p != 0; p++) {
165                         strcpy(pbuf, *p); /* copy alias strings */
166                         *q++ = pbuf; /* the pointer is the one inside buf... */
167                         pbuf += strlen(*p); /* advance pbuf */
168                         *pbuf++ = 0; /* string terminator */
169                 }
170                 *q++ = NULL; /* terminator */
171
172                 strcpy(pbuf, ph->h_name); /* copy alias strings */
173                 ret->h_name = pbuf;
174                 pbuf += strlen(ph->h_name); /* advance pbuf */
175                 *pbuf++ = 0; /* string terminator */
176
177                 *result = ret;  /* and let *result point to structure */
178
179         }
180         h_errno = hsave;  /* restore h_errno */
181         ast_mutex_unlock(&__mutex); /* end critical area */
182
183         return (*result == NULL); /* return 0 on success, non-zero on error */
184 }
185
186
187 #endif
188
189 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the
190    standard gethostbyname (which is not thread safe)
191 */
192 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
193 {
194         int res;
195         int herrno;
196         int dots = 0;
197         const char *s;
198         struct hostent *result = NULL;
199         /* Although it is perfectly legitimate to lookup a pure integer, for
200            the sake of the sanity of people who like to name their peers as
201            integers, we break with tradition and refuse to look up a
202            pure integer */
203         s = host;
204         res = 0;
205         while (s && *s) {
206                 if (*s == '.')
207                         dots++;
208                 else if (!isdigit(*s))
209                         break;
210                 s++;
211         }
212         if (!s || !*s) {
213                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
214                 if (dots != 3)
215                         return NULL;
216                 memset(hp, 0, sizeof(struct ast_hostent));
217                 hp->hp.h_addrtype = AF_INET;
218                 hp->hp.h_addr_list = (void *) hp->buf;
219                 hp->hp.h_addr = hp->buf + sizeof(void *);
220                 /* For AF_INET, this will always be 4 */
221                 hp->hp.h_length = 4;
222                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
223                         return &hp->hp;
224                 return NULL;
225
226         }
227 #ifdef HAVE_GETHOSTBYNAME_R_5
228         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
229
230         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
231                 return NULL;
232 #else
233         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
234
235         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
236                 return NULL;
237 #endif
238         return &hp->hp;
239 }
240
241 /*! \brief Produce 32 char MD5 hash of value. */
242 void ast_md5_hash(char *output, const char *input)
243 {
244         struct MD5Context md5;
245         unsigned char digest[16];
246         char *ptr;
247         int x;
248
249         MD5Init(&md5);
250         MD5Update(&md5, (const unsigned char *) input, strlen(input));
251         MD5Final(digest, &md5);
252         ptr = output;
253         for (x = 0; x < 16; x++)
254                 ptr += sprintf(ptr, "%2.2x", digest[x]);
255 }
256
257 /*! \brief Produce 40 char SHA1 hash of value. */
258 void ast_sha1_hash(char *output, const char *input)
259 {
260         struct SHA1Context sha;
261         char *ptr;
262         int x;
263         uint8_t Message_Digest[20];
264
265         SHA1Reset(&sha);
266
267         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
268
269         SHA1Result(&sha, Message_Digest);
270         ptr = output;
271         for (x = 0; x < 20; x++)
272                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
273 }
274
275 /*! \brief Produce a 20 byte SHA1 hash of value. */
276 void ast_sha1_hash_uint(uint8_t *digest, const char *input)
277 {
278         struct SHA1Context sha;
279
280         SHA1Reset(&sha);
281
282         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
283
284         SHA1Result(&sha, digest);
285 }
286
287 /*! \brief decode BASE64 encoded text */
288 int ast_base64decode(unsigned char *dst, const char *src, int max)
289 {
290         int cnt = 0;
291         unsigned int byte = 0;
292         unsigned int bits = 0;
293         int incnt = 0;
294         while(*src && *src != '=' && (cnt < max)) {
295                 /* Shift in 6 bits of input */
296                 byte <<= 6;
297                 byte |= (b2a[(int)(*src)]) & 0x3f;
298                 bits += 6;
299                 src++;
300                 incnt++;
301                 /* If we have at least 8 bits left over, take that character
302                    off the top */
303                 if (bits >= 8)  {
304                         bits -= 8;
305                         *dst = (byte >> bits) & 0xff;
306                         dst++;
307                         cnt++;
308                 }
309         }
310         /* Don't worry about left over bits, they're extra anyway */
311         return cnt;
312 }
313
314 /*! \brief encode text to BASE64 coding */
315 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
316 {
317         int cnt = 0;
318         int col = 0;
319         unsigned int byte = 0;
320         int bits = 0;
321         int cntin = 0;
322         /* Reserve space for null byte at end of string */
323         max--;
324         while ((cntin < srclen) && (cnt < max)) {
325                 byte <<= 8;
326                 byte |= *(src++);
327                 bits += 8;
328                 cntin++;
329                 if ((bits == 24) && (cnt + 4 <= max)) {
330                         *dst++ = base64[(byte >> 18) & 0x3f];
331                         *dst++ = base64[(byte >> 12) & 0x3f];
332                         *dst++ = base64[(byte >> 6) & 0x3f];
333                         *dst++ = base64[byte & 0x3f];
334                         cnt += 4;
335                         col += 4;
336                         bits = 0;
337                         byte = 0;
338                 }
339                 if (linebreaks && (cnt < max) && (col == 64)) {
340                         *dst++ = '\n';
341                         cnt++;
342                         col = 0;
343                 }
344         }
345         if (bits && (cnt + 4 <= max)) {
346                 /* Add one last character for the remaining bits,
347                    padding the rest with 0 */
348                 byte <<= 24 - bits;
349                 *dst++ = base64[(byte >> 18) & 0x3f];
350                 *dst++ = base64[(byte >> 12) & 0x3f];
351                 if (bits == 16)
352                         *dst++ = base64[(byte >> 6) & 0x3f];
353                 else
354                         *dst++ = '=';
355                 *dst++ = '=';
356                 cnt += 4;
357         }
358         if (linebreaks && (cnt < max)) {
359                 *dst++ = '\n';
360                 cnt++;
361         }
362         *dst = '\0';
363         return cnt;
364 }
365
366 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
367 {
368         return ast_base64encode_full(dst, src, srclen, max, 0);
369 }
370
371 static void base64_init(void)
372 {
373         int x;
374         memset(b2a, -1, sizeof(b2a));
375         /* Initialize base-64 Conversion table */
376         for (x = 0; x < 26; x++) {
377                 /* A-Z */
378                 base64[x] = 'A' + x;
379                 b2a['A' + x] = x;
380                 /* a-z */
381                 base64[x + 26] = 'a' + x;
382                 b2a['a' + x] = x + 26;
383                 /* 0-9 */
384                 if (x < 10) {
385                         base64[x + 52] = '0' + x;
386                         b2a['0' + x] = x + 52;
387                 }
388         }
389         base64[62] = '+';
390         base64[63] = '/';
391         b2a[(int)'+'] = 62;
392         b2a[(int)'/'] = 63;
393 }
394
395 const struct ast_flags ast_uri_http = {AST_URI_UNRESERVED};
396 const struct ast_flags ast_uri_http_legacy = {AST_URI_LEGACY_SPACE | AST_URI_UNRESERVED};
397 const struct ast_flags ast_uri_sip_user = {AST_URI_UNRESERVED | AST_URI_SIP_USER_UNRESERVED};
398
399 char *ast_uri_encode(const char *string, char *outbuf, int buflen, struct ast_flags spec)
400 {
401         const char *ptr  = string;      /* Start with the string */
402         char *out = outbuf;
403         const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */
404         const char *user_unreserved = "&=+$,;?/"; /* user-unreserved set, RFC 3261 sec 25 */
405
406         while (*ptr && out - outbuf < buflen - 1) {
407                 if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *ptr == ' ') {
408                         /* for legacy encoding, encode spaces as '+' */
409                         *out = '+';
410                         out++;
411                 } else if (!(ast_test_flag(&spec, AST_URI_MARK)
412                                 && strchr(mark, *ptr))
413                         && !(ast_test_flag(&spec, AST_URI_ALPHANUM)
414                                 && ((*ptr >= '0' && *ptr <= '9')
415                                 || (*ptr >= 'A' && *ptr <= 'Z')
416                                 || (*ptr >= 'a' && *ptr <= 'z')))
417                         && !(ast_test_flag(&spec, AST_URI_SIP_USER_UNRESERVED)
418                                 && strchr(user_unreserved, *ptr))) {
419
420                         if (out - outbuf >= buflen - 3) {
421                                 break;
422                         }
423                         out += sprintf(out, "%%%02X", (unsigned char) *ptr);
424                 } else {
425                         *out = *ptr;    /* Continue copying the string */
426                         out++;
427                 }
428                 ptr++;
429         }
430
431         if (buflen) {
432                 *out = '\0';
433         }
434
435         return outbuf;
436 }
437
438 void ast_uri_decode(char *s, struct ast_flags spec)
439 {
440         char *o;
441         unsigned int tmp;
442
443         for (o = s; *s; s++, o++) {
444                 if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *s == '+') {
445                         /* legacy mode, decode '+' as space */
446                         *o = ' ';
447                 } else if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) {
448                         /* have '%', two chars and correct parsing */
449                         *o = tmp;
450                         s += 2; /* Will be incremented once more when we break out */
451                 } else /* all other cases, just copy */
452                         *o = *s;
453         }
454         *o = '\0';
455 }
456
457 char *ast_escape_quoted(const char *string, char *outbuf, int buflen)
458 {
459         const char *ptr  = string;
460         char *out = outbuf;
461         char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */
462
463         while (*ptr && out - outbuf < buflen - 1) {
464                 if (!(strchr(allow, *ptr))
465                         && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */
466                         && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */
467                         && !((unsigned char) *ptr > 0x7f)) {             /* UTF8-nonascii */
468
469                         if (out - outbuf >= buflen - 2) {
470                                 break;
471                         }
472                         out += sprintf(out, "\\%c", (unsigned char) *ptr);
473                 } else {
474                         *out = *ptr;
475                         out++;
476                 }
477                 ptr++;
478         }
479
480         if (buflen) {
481                 *out = '\0';
482         }
483
484         return outbuf;
485 }
486 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
487 const char *ast_inet_ntoa(struct in_addr ia)
488 {
489         char *buf;
490
491         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
492                 return "";
493
494         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
495 }
496
497 static int dev_urandom_fd;
498
499 #ifndef __linux__
500 #undef pthread_create /* For ast_pthread_create function only */
501 #endif /* !__linux__ */
502
503 #if !defined(LOW_MEMORY)
504
505 #ifdef DEBUG_THREADS
506
507 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
508 #define AST_MAX_LOCKS 64
509
510 /* Allow direct use of pthread_mutex_t and friends */
511 #undef pthread_mutex_t
512 #undef pthread_mutex_lock
513 #undef pthread_mutex_unlock
514 #undef pthread_mutex_init
515 #undef pthread_mutex_destroy
516
517 /*!
518  * \brief Keep track of which locks a thread holds
519  *
520  * There is an instance of this struct for every active thread
521  */
522 struct thr_lock_info {
523         /*! The thread's ID */
524         pthread_t thread_id;
525         /*! The thread name which includes where the thread was started */
526         const char *thread_name;
527         /*! This is the actual container of info for what locks this thread holds */
528         struct {
529                 const char *file;
530                 int line_num;
531                 const char *func;
532                 const char *lock_name;
533                 void *lock_addr;
534                 int times_locked;
535                 enum ast_lock_type type;
536                 /*! This thread is waiting on this lock */
537                 int pending:2;
538 #ifdef HAVE_BKTR
539                 struct ast_bt *backtrace;
540 #endif
541         } locks[AST_MAX_LOCKS];
542         /*! This is the number of locks currently held by this thread.
543          *  The index (num_locks - 1) has the info on the last one in the
544          *  locks member */
545         unsigned int num_locks;
546         /*! Protects the contents of the locks member
547          * Intentionally not ast_mutex_t */
548         pthread_mutex_t lock;
549         AST_LIST_ENTRY(thr_lock_info) entry;
550 };
551
552 /*!
553  * \brief Locked when accessing the lock_infos list
554  */
555 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
556 /*!
557  * \brief A list of each thread's lock info
558  */
559 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
560
561 /*!
562  * \brief Destroy a thread's lock info
563  *
564  * This gets called automatically when the thread stops
565  */
566 static void lock_info_destroy(void *data)
567 {
568         struct thr_lock_info *lock_info = data;
569         int i;
570
571         pthread_mutex_lock(&lock_infos_lock.mutex);
572         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
573         pthread_mutex_unlock(&lock_infos_lock.mutex);
574
575
576         for (i = 0; i < lock_info->num_locks; i++) {
577                 if (lock_info->locks[i].pending == -1) {
578                         /* This just means that the last lock this thread went for was by
579                          * using trylock, and it failed.  This is fine. */
580                         break;
581                 }
582
583                 ast_log(LOG_ERROR,
584                         "Thread '%s' still has a lock! - '%s' (%p) from '%s' in %s:%d!\n",
585                         lock_info->thread_name,
586                         lock_info->locks[i].lock_name,
587                         lock_info->locks[i].lock_addr,
588                         lock_info->locks[i].func,
589                         lock_info->locks[i].file,
590                         lock_info->locks[i].line_num
591                 );
592         }
593
594         pthread_mutex_destroy(&lock_info->lock);
595         if (lock_info->thread_name)
596                 free((void *) lock_info->thread_name);
597         free(lock_info);
598 }
599
600 /*!
601  * \brief The thread storage key for per-thread lock info
602  */
603 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
604 #ifdef HAVE_BKTR
605 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
606         int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
607 #else
608 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
609         int line_num, const char *func, const char *lock_name, void *lock_addr)
610 #endif
611 {
612         struct thr_lock_info *lock_info;
613         int i;
614
615         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
616                 return;
617
618         pthread_mutex_lock(&lock_info->lock);
619
620         for (i = 0; i < lock_info->num_locks; i++) {
621                 if (lock_info->locks[i].lock_addr == lock_addr) {
622                         lock_info->locks[i].times_locked++;
623 #ifdef HAVE_BKTR
624                         lock_info->locks[i].backtrace = bt;
625 #endif
626                         pthread_mutex_unlock(&lock_info->lock);
627                         return;
628                 }
629         }
630
631         if (lock_info->num_locks == AST_MAX_LOCKS) {
632                 /* Can't use ast_log here, because it will cause infinite recursion */
633                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
634                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
635                 pthread_mutex_unlock(&lock_info->lock);
636                 return;
637         }
638
639         if (i && lock_info->locks[i - 1].pending == -1) {
640                 /* The last lock on the list was one that this thread tried to lock but
641                  * failed at doing so.  It has now moved on to something else, so remove
642                  * the old lock from the list. */
643                 i--;
644                 lock_info->num_locks--;
645                 memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
646         }
647
648         lock_info->locks[i].file = filename;
649         lock_info->locks[i].line_num = line_num;
650         lock_info->locks[i].func = func;
651         lock_info->locks[i].lock_name = lock_name;
652         lock_info->locks[i].lock_addr = lock_addr;
653         lock_info->locks[i].times_locked = 1;
654         lock_info->locks[i].type = type;
655         lock_info->locks[i].pending = 1;
656 #ifdef HAVE_BKTR
657         lock_info->locks[i].backtrace = bt;
658 #endif
659         lock_info->num_locks++;
660
661         pthread_mutex_unlock(&lock_info->lock);
662 }
663
664 void ast_mark_lock_acquired(void *lock_addr)
665 {
666         struct thr_lock_info *lock_info;
667
668         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
669                 return;
670
671         pthread_mutex_lock(&lock_info->lock);
672         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
673                 lock_info->locks[lock_info->num_locks - 1].pending = 0;
674         }
675         pthread_mutex_unlock(&lock_info->lock);
676 }
677
678 void ast_mark_lock_failed(void *lock_addr)
679 {
680         struct thr_lock_info *lock_info;
681
682         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
683                 return;
684
685         pthread_mutex_lock(&lock_info->lock);
686         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
687                 lock_info->locks[lock_info->num_locks - 1].pending = -1;
688                 lock_info->locks[lock_info->num_locks - 1].times_locked--;
689         }
690         pthread_mutex_unlock(&lock_info->lock);
691 }
692
693 int ast_find_lock_info(void *lock_addr, char *filename, size_t filename_size, int *lineno, char *func, size_t func_size, char *mutex_name, size_t mutex_name_size)
694 {
695         struct thr_lock_info *lock_info;
696         int i = 0;
697
698         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
699                 return -1;
700
701         pthread_mutex_lock(&lock_info->lock);
702
703         for (i = lock_info->num_locks - 1; i >= 0; i--) {
704                 if (lock_info->locks[i].lock_addr == lock_addr)
705                         break;
706         }
707
708         if (i == -1) {
709                 /* Lock not found :( */
710                 pthread_mutex_unlock(&lock_info->lock);
711                 return -1;
712         }
713
714         ast_copy_string(filename, lock_info->locks[i].file, filename_size);
715         *lineno = lock_info->locks[i].line_num;
716         ast_copy_string(func, lock_info->locks[i].func, func_size);
717         ast_copy_string(mutex_name, lock_info->locks[i].lock_name, mutex_name_size);
718
719         pthread_mutex_unlock(&lock_info->lock);
720
721         return 0;
722 }
723
724 #ifdef HAVE_BKTR
725 void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt)
726 #else
727 void ast_remove_lock_info(void *lock_addr)
728 #endif
729 {
730         struct thr_lock_info *lock_info;
731         int i = 0;
732
733         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
734                 return;
735
736         pthread_mutex_lock(&lock_info->lock);
737
738         for (i = lock_info->num_locks - 1; i >= 0; i--) {
739                 if (lock_info->locks[i].lock_addr == lock_addr)
740                         break;
741         }
742
743         if (i == -1) {
744                 /* Lock not found :( */
745                 pthread_mutex_unlock(&lock_info->lock);
746                 return;
747         }
748
749         if (lock_info->locks[i].times_locked > 1) {
750                 lock_info->locks[i].times_locked--;
751 #ifdef HAVE_BKTR
752                 lock_info->locks[i].backtrace = bt;
753 #endif
754                 pthread_mutex_unlock(&lock_info->lock);
755                 return;
756         }
757
758         if (i < lock_info->num_locks - 1) {
759                 /* Not the last one ... *should* be rare! */
760                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1],
761                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
762         }
763
764         lock_info->num_locks--;
765
766         pthread_mutex_unlock(&lock_info->lock);
767 }
768
769 static const char *locktype2str(enum ast_lock_type type)
770 {
771         switch (type) {
772         case AST_MUTEX:
773                 return "MUTEX";
774         case AST_RDLOCK:
775                 return "RDLOCK";
776         case AST_WRLOCK:
777                 return "WRLOCK";
778         }
779
780         return "UNKNOWN";
781 }
782
783 #ifdef HAVE_BKTR
784 static void append_backtrace_information(struct ast_str **str, struct ast_bt *bt)
785 {
786         char **symbols;
787         int num_frames;
788
789         if (!bt) {
790                 ast_str_append(str, 0, "\tNo backtrace to print\n");
791                 return;
792         }
793
794         /* store frame count locally to avoid the memory corruption that
795          * sometimes happens on virtualized CentOS 6.x systems */
796         num_frames = bt->num_frames;
797         if ((symbols = ast_bt_get_symbols(bt->addresses, num_frames))) {
798                 int frame_iterator;
799
800                 for (frame_iterator = 0; frame_iterator < num_frames; ++frame_iterator) {
801                         ast_str_append(str, 0, "\t%s\n", symbols[frame_iterator]);
802                 }
803
804                 free(symbols);
805         } else {
806                 ast_str_append(str, 0, "\tCouldn't retrieve backtrace symbols\n");
807         }
808 }
809 #endif
810
811 static void append_lock_information(struct ast_str **str, struct thr_lock_info *lock_info, int i)
812 {
813         int j;
814         ast_mutex_t *lock;
815         struct ast_lock_track *lt;
816
817         ast_str_append(str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d)\n",
818                                    lock_info->locks[i].pending > 0 ? "Waiting for " :
819                                    lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
820                                    lock_info->locks[i].file,
821                                    locktype2str(lock_info->locks[i].type),
822                                    lock_info->locks[i].line_num,
823                                    lock_info->locks[i].func, lock_info->locks[i].lock_name,
824                                    lock_info->locks[i].lock_addr,
825                                    lock_info->locks[i].times_locked);
826 #ifdef HAVE_BKTR
827         append_backtrace_information(str, lock_info->locks[i].backtrace);
828 #endif
829
830         if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
831                 return;
832
833         /* We only have further details for mutexes right now */
834         if (lock_info->locks[i].type != AST_MUTEX)
835                 return;
836
837         lock = lock_info->locks[i].lock_addr;
838         lt = lock->track;
839         ast_reentrancy_lock(lt);
840         for (j = 0; *str && j < lt->reentrancy; j++) {
841                 ast_str_append(str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
842                                            lt->file[j], lt->lineno[j], lt->func[j]);
843         }
844         ast_reentrancy_unlock(lt);
845 }
846
847
848 /*! This function can help you find highly temporal locks; locks that happen for a
849     short time, but at unexpected times, usually at times that create a deadlock,
850         Why is this thing locked right then? Who is locking it? Who am I fighting
851     with for this lock?
852
853         To answer such questions, just call this routine before you would normally try
854         to aquire a lock. It doesn't do anything if the lock is not acquired. If the
855         lock is taken, it will publish a line or two to the console via ast_log().
856
857         Sometimes, the lock message is pretty uninformative. For instance, you might
858         find that the lock is being aquired deep within the astobj2 code; this tells
859         you little about higher level routines that call the astobj2 routines.
860         But, using gdb, you can set a break at the ast_log below, and for that
861         breakpoint, you can set the commands:
862           where
863           cont
864         which will give a stack trace and continue. -- that aught to do the job!
865
866 */
867 void log_show_lock(void *this_lock_addr)
868 {
869         struct thr_lock_info *lock_info;
870         struct ast_str *str;
871
872         if (!(str = ast_str_create(4096))) {
873                 ast_log(LOG_NOTICE,"Could not create str\n");
874                 return;
875         }
876
877
878         pthread_mutex_lock(&lock_infos_lock.mutex);
879         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
880                 int i;
881                 pthread_mutex_lock(&lock_info->lock);
882                 for (i = 0; str && i < lock_info->num_locks; i++) {
883                         /* ONLY show info about this particular lock, if
884                            it's acquired... */
885                         if (lock_info->locks[i].lock_addr == this_lock_addr) {
886                                 append_lock_information(&str, lock_info, i);
887                                 ast_log(LOG_NOTICE, "%s", ast_str_buffer(str));
888                                 break;
889                         }
890                 }
891                 pthread_mutex_unlock(&lock_info->lock);
892         }
893         pthread_mutex_unlock(&lock_infos_lock.mutex);
894         ast_free(str);
895 }
896
897
898 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
899 {
900         struct thr_lock_info *lock_info;
901         struct ast_str *str;
902
903         if (!(str = ast_str_create(4096)))
904                 return CLI_FAILURE;
905
906         switch (cmd) {
907         case CLI_INIT:
908                 e->command = "core show locks";
909                 e->usage =
910                         "Usage: core show locks\n"
911                         "       This command is for lock debugging.  It prints out which locks\n"
912                         "are owned by each active thread.\n";
913                 return NULL;
914
915         case CLI_GENERATE:
916                 return NULL;
917         }
918
919         ast_str_append(&str, 0, "\n"
920                        "=======================================================================\n"
921                        "=== Currently Held Locks ==============================================\n"
922                        "=======================================================================\n"
923                        "===\n"
924                        "=== <pending> <lock#> (<file>): <lock type> <line num> <function> <lock name> <lock addr> (times locked)\n"
925                        "===\n");
926
927         if (!str)
928                 return CLI_FAILURE;
929
930         pthread_mutex_lock(&lock_infos_lock.mutex);
931         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
932                 int i;
933                 if (lock_info->num_locks) {
934                         ast_str_append(&str, 0, "=== Thread ID: 0x%lx (%s)\n", (long) lock_info->thread_id,
935                                 lock_info->thread_name);
936                         pthread_mutex_lock(&lock_info->lock);
937                         for (i = 0; str && i < lock_info->num_locks; i++) {
938                                 append_lock_information(&str, lock_info, i);
939                         }
940                         pthread_mutex_unlock(&lock_info->lock);
941                         if (!str)
942                                 break;
943                         ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
944                                        "===\n");
945                         if (!str)
946                                 break;
947                 }
948         }
949         pthread_mutex_unlock(&lock_infos_lock.mutex);
950
951         if (!str)
952                 return CLI_FAILURE;
953
954         ast_str_append(&str, 0, "=======================================================================\n"
955                        "\n");
956
957         if (!str)
958                 return CLI_FAILURE;
959
960         ast_cli(a->fd, "%s", ast_str_buffer(str));
961
962         ast_free(str);
963
964         return CLI_SUCCESS;
965 }
966
967 static struct ast_cli_entry utils_cli[] = {
968         AST_CLI_DEFINE(handle_show_locks, "Show which locks are held by which thread"),
969 };
970
971 #endif /* DEBUG_THREADS */
972
973 /*
974  * support for 'show threads'. The start routine is wrapped by
975  * dummy_start(), so that ast_register_thread() and
976  * ast_unregister_thread() know the thread identifier.
977  */
978 struct thr_arg {
979         void *(*start_routine)(void *);
980         void *data;
981         char *name;
982 };
983
984 /*
985  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
986  * are odd macros which start and end a block, so they _must_ be
987  * used in pairs (the latter with a '1' argument to call the
988  * handler on exit.
989  * On BSD we don't need this, but we keep it for compatibility.
990  */
991 static void *dummy_start(void *data)
992 {
993         void *ret;
994         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
995 #ifdef DEBUG_THREADS
996         struct thr_lock_info *lock_info;
997         pthread_mutexattr_t mutex_attr;
998
999         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
1000                 return NULL;
1001
1002         lock_info->thread_id = pthread_self();
1003         lock_info->thread_name = strdup(a.name);
1004
1005         pthread_mutexattr_init(&mutex_attr);
1006         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
1007         pthread_mutex_init(&lock_info->lock, &mutex_attr);
1008         pthread_mutexattr_destroy(&mutex_attr);
1009
1010         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1011         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
1012         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1013 #endif /* DEBUG_THREADS */
1014
1015         /* note that even though data->name is a pointer to allocated memory,
1016            we are not freeing it here because ast_register_thread is going to
1017            keep a copy of the pointer and then ast_unregister_thread will
1018            free the memory
1019         */
1020         ast_free(data);
1021         ast_register_thread(a.name);
1022         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
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 = ast_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                 if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()",
1070                              start_fn, line, file, caller) < 0) {
1071                         a->name = NULL;
1072                 }
1073                 data = a;
1074         }
1075 #endif /* !LOW_MEMORY */
1076
1077         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
1078 }
1079
1080
1081 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1082                              void *data, size_t stacksize, const char *file, const char *caller,
1083                              int line, const char *start_fn)
1084 {
1085         unsigned char attr_destroy = 0;
1086         int res;
1087
1088         if (!attr) {
1089                 attr = ast_alloca(sizeof(*attr));
1090                 pthread_attr_init(attr);
1091                 attr_destroy = 1;
1092         }
1093
1094         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
1095                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
1096
1097         res = ast_pthread_create_stack(thread, attr, start_routine, data,
1098                                        stacksize, file, caller, line, start_fn);
1099
1100         if (attr_destroy)
1101                 pthread_attr_destroy(attr);
1102
1103         return res;
1104 }
1105
1106 int ast_wait_for_input(int fd, int ms)
1107 {
1108         struct pollfd pfd[1];
1109         memset(pfd, 0, sizeof(pfd));
1110         pfd[0].fd = fd;
1111         pfd[0].events = POLLIN|POLLPRI;
1112         return ast_poll(pfd, 1, ms);
1113 }
1114
1115 static int ast_wait_for_output(int fd, int timeoutms)
1116 {
1117         struct pollfd pfd = {
1118                 .fd = fd,
1119                 .events = POLLOUT,
1120         };
1121         int res;
1122         struct timeval start = ast_tvnow();
1123         int elapsed = 0;
1124
1125         /* poll() until the fd is writable without blocking */
1126         while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
1127                 if (res == 0) {
1128                         /* timed out. */
1129 #ifndef STANDALONE
1130                         ast_debug(1, "Timed out trying to write\n");
1131 #endif
1132                         return -1;
1133                 } else if (res == -1) {
1134                         /* poll() returned an error, check to see if it was fatal */
1135
1136                         if (errno == EINTR || errno == EAGAIN) {
1137                                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1138                                 if (elapsed >= timeoutms) {
1139                                         return -1;
1140                                 }
1141                                 /* This was an acceptable error, go back into poll() */
1142                                 continue;
1143                         }
1144
1145                         /* Fatal error, bail. */
1146                         ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
1147
1148                         return -1;
1149                 }
1150                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1151                 if (elapsed >= timeoutms) {
1152                         return -1;
1153                 }
1154         }
1155
1156         return 0;
1157 }
1158
1159 /*!
1160  * Try to write string, but wait no more than ms milliseconds before timing out.
1161  *
1162  * \note The code assumes that the file descriptor has NONBLOCK set,
1163  * so there is only one system call made to do a write, unless we actually
1164  * have a need to wait.  This way, we get better performance.
1165  * If the descriptor is blocking, all assumptions on the guaranteed
1166  * detail do not apply anymore.
1167  */
1168 int ast_carefulwrite(int fd, char *s, int len, int timeoutms)
1169 {
1170         struct timeval start = ast_tvnow();
1171         int res = 0;
1172         int elapsed = 0;
1173
1174         while (len) {
1175                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1176                         return -1;
1177                 }
1178
1179                 res = write(fd, s, len);
1180
1181                 if (res < 0 && errno != EAGAIN && errno != EINTR) {
1182                         /* fatal error from write() */
1183                         ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
1184                         return -1;
1185                 }
1186
1187                 if (res < 0) {
1188                         /* It was an acceptable error */
1189                         res = 0;
1190                 }
1191
1192                 /* Update how much data we have left to write */
1193                 len -= res;
1194                 s += res;
1195                 res = 0;
1196
1197                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1198                 if (elapsed >= timeoutms) {
1199                         /* We've taken too long to write
1200                          * This is only an error condition if we haven't finished writing. */
1201                         res = len ? -1 : 0;
1202                         break;
1203                 }
1204         }
1205
1206         return res;
1207 }
1208
1209 int ast_careful_fwrite(FILE *f, int fd, const char *src, size_t len, int timeoutms)
1210 {
1211         struct timeval start = ast_tvnow();
1212         int n = 0;
1213         int elapsed = 0;
1214
1215         while (len) {
1216                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1217                         /* poll returned a fatal error, so bail out immediately. */
1218                         return -1;
1219                 }
1220
1221                 /* Clear any errors from a previous write */
1222                 clearerr(f);
1223
1224                 n = fwrite(src, 1, len, f);
1225
1226                 if (ferror(f) && errno != EINTR && errno != EAGAIN) {
1227                         /* fatal error from fwrite() */
1228                         if (!feof(f)) {
1229                                 /* Don't spam the logs if it was just that the connection is closed. */
1230                                 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
1231                         }
1232                         n = -1;
1233                         break;
1234                 }
1235
1236                 /* Update for data already written to the socket */
1237                 len -= n;
1238                 src += n;
1239
1240                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1241                 if (elapsed >= timeoutms) {
1242                         /* We've taken too long to write
1243                          * This is only an error condition if we haven't finished writing. */
1244                         n = len ? -1 : 0;
1245                         break;
1246                 }
1247         }
1248
1249         while (fflush(f)) {
1250                 if (errno == EAGAIN || errno == EINTR) {
1251                         continue;
1252                 }
1253                 if (!feof(f)) {
1254                         /* Don't spam the logs if it was just that the connection is closed. */
1255                         ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
1256                 }
1257                 n = -1;
1258                 break;
1259         }
1260
1261         return n < 0 ? -1 : 0;
1262 }
1263
1264 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1265 {
1266         char *e;
1267         char *q;
1268
1269         s = ast_strip(s);
1270         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1271                 e = s + strlen(s) - 1;
1272                 if (*e == *(end_quotes + (q - beg_quotes))) {
1273                         s++;
1274                         *e = '\0';
1275                 }
1276         }
1277
1278         return s;
1279 }
1280
1281 char *ast_unescape_semicolon(char *s)
1282 {
1283         char *e;
1284         char *work = s;
1285
1286         while ((e = strchr(work, ';'))) {
1287                 if ((e > work) && (*(e-1) == '\\')) {
1288                         memmove(e - 1, e, strlen(e) + 1);
1289                         work = e;
1290                 } else {
1291                         work = e + 1;
1292                 }
1293         }
1294
1295         return s;
1296 }
1297
1298 /* !\brief unescape some C sequences in place, return pointer to the original string.
1299  */
1300 char *ast_unescape_c(char *src)
1301 {
1302         char c, *ret, *dst;
1303
1304         if (src == NULL)
1305                 return NULL;
1306         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1307                 if (c != '\\')
1308                         continue;       /* copy char at the end of the loop */
1309                 switch ((c = *src++)) {
1310                 case '\0':      /* special, trailing '\' */
1311                         c = '\\';
1312                         break;
1313                 case 'b':       /* backspace */
1314                         c = '\b';
1315                         break;
1316                 case 'f':       /* form feed */
1317                         c = '\f';
1318                         break;
1319                 case 'n':
1320                         c = '\n';
1321                         break;
1322                 case 'r':
1323                         c = '\r';
1324                         break;
1325                 case 't':
1326                         c = '\t';
1327                         break;
1328                 }
1329                 /* default, use the char literally */
1330         }
1331         *dst = '\0';
1332         return ret;
1333 }
1334
1335 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1336 {
1337         int result;
1338
1339         if (!buffer || !*buffer || !space || !*space)
1340                 return -1;
1341
1342         result = vsnprintf(*buffer, *space, fmt, ap);
1343
1344         if (result < 0)
1345                 return -1;
1346         else if (result > *space)
1347                 result = *space;
1348
1349         *buffer += result;
1350         *space -= result;
1351         return 0;
1352 }
1353
1354 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1355 {
1356         va_list ap;
1357         int result;
1358
1359         va_start(ap, fmt);
1360         result = ast_build_string_va(buffer, space, fmt, ap);
1361         va_end(ap);
1362
1363         return result;
1364 }
1365
1366 int ast_regex_string_to_regex_pattern(const char *regex_string, struct ast_str **regex_pattern)
1367 {
1368         int regex_len = strlen(regex_string);
1369         int ret = 3;
1370
1371         /* Chop off the leading / if there is one */
1372         if ((regex_len >= 1) && (regex_string[0] == '/')) {
1373                 ast_str_set(regex_pattern, 0, "%s", regex_string + 1);
1374                 ret -= 2;
1375         }
1376
1377         /* Chop off the ending / if there is one */
1378         if ((regex_len > 1) && (regex_string[regex_len - 1] == '/')) {
1379                 ast_str_truncate(*regex_pattern, -1);
1380                 ret -= 1;
1381         }
1382
1383         return ret;
1384 }
1385
1386 int ast_true(const char *s)
1387 {
1388         if (ast_strlen_zero(s))
1389                 return 0;
1390
1391         /* Determine if this is a true value */
1392         if (!strcasecmp(s, "yes") ||
1393             !strcasecmp(s, "true") ||
1394             !strcasecmp(s, "y") ||
1395             !strcasecmp(s, "t") ||
1396             !strcasecmp(s, "1") ||
1397             !strcasecmp(s, "on"))
1398                 return -1;
1399
1400         return 0;
1401 }
1402
1403 int ast_false(const char *s)
1404 {
1405         if (ast_strlen_zero(s))
1406                 return 0;
1407
1408         /* Determine if this is a false value */
1409         if (!strcasecmp(s, "no") ||
1410             !strcasecmp(s, "false") ||
1411             !strcasecmp(s, "n") ||
1412             !strcasecmp(s, "f") ||
1413             !strcasecmp(s, "0") ||
1414             !strcasecmp(s, "off"))
1415                 return -1;
1416
1417         return 0;
1418 }
1419
1420 #define ONE_MILLION     1000000
1421 /*
1422  * put timeval in a valid range. usec is 0..999999
1423  * negative values are not allowed and truncated.
1424  */
1425 static struct timeval tvfix(struct timeval a)
1426 {
1427         if (a.tv_usec >= ONE_MILLION) {
1428                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1429                         (long)a.tv_sec, (long int) a.tv_usec);
1430                 a.tv_sec += a.tv_usec / ONE_MILLION;
1431                 a.tv_usec %= ONE_MILLION;
1432         } else if (a.tv_usec < 0) {
1433                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1434                         (long)a.tv_sec, (long int) a.tv_usec);
1435                 a.tv_usec = 0;
1436         }
1437         return a;
1438 }
1439
1440 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1441 {
1442         /* consistency checks to guarantee usec in 0..999999 */
1443         a = tvfix(a);
1444         b = tvfix(b);
1445         a.tv_sec += b.tv_sec;
1446         a.tv_usec += b.tv_usec;
1447         if (a.tv_usec >= ONE_MILLION) {
1448                 a.tv_sec++;
1449                 a.tv_usec -= ONE_MILLION;
1450         }
1451         return a;
1452 }
1453
1454 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1455 {
1456         /* consistency checks to guarantee usec in 0..999999 */
1457         a = tvfix(a);
1458         b = tvfix(b);
1459         a.tv_sec -= b.tv_sec;
1460         a.tv_usec -= b.tv_usec;
1461         if (a.tv_usec < 0) {
1462                 a.tv_sec-- ;
1463                 a.tv_usec += ONE_MILLION;
1464         }
1465         return a;
1466 }
1467
1468 int ast_remaining_ms(struct timeval start, int max_ms)
1469 {
1470         int ms;
1471
1472         if (max_ms < 0) {
1473                 ms = max_ms;
1474         } else {
1475                 ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start);
1476                 if (ms < 0) {
1477                         ms = 0;
1478                 }
1479         }
1480
1481         return ms;
1482 }
1483
1484 #undef ONE_MILLION
1485
1486 #ifndef linux
1487 AST_MUTEX_DEFINE_STATIC(randomlock);
1488 #endif
1489
1490 long int ast_random(void)
1491 {
1492         long int res;
1493
1494         if (dev_urandom_fd >= 0) {
1495                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1496                 if (read_res > 0) {
1497                         long int rm = RAND_MAX;
1498                         res = res < 0 ? ~res : res;
1499                         rm++;
1500                         return res % rm;
1501                 }
1502         }
1503
1504         /* XXX - Thread safety really depends on the libc, not the OS.
1505          *
1506          * But... popular Linux libc's (uClibc, glibc, eglibc), all have a
1507          * somewhat thread safe random(3) (results are random, but not
1508          * reproducible). The libc's for other systems (BSD, et al.), not so
1509          * much.
1510          */
1511 #ifdef linux
1512         res = random();
1513 #else
1514         ast_mutex_lock(&randomlock);
1515         res = random();
1516         ast_mutex_unlock(&randomlock);
1517 #endif
1518         return res;
1519 }
1520
1521 void ast_replace_subargument_delimiter(char *s)
1522 {
1523         for (; *s; s++) {
1524                 if (*s == '^') {
1525                         *s = ',';
1526                 }
1527         }
1528 }
1529
1530 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1531 {
1532         char *dataPut = start;
1533         int inEscape = 0;
1534         int inQuotes = 0;
1535
1536         for (; *start; start++) {
1537                 if (inEscape) {
1538                         *dataPut++ = *start;       /* Always goes verbatim */
1539                         inEscape = 0;
1540                 } else {
1541                         if (*start == '\\') {
1542                                 inEscape = 1;      /* Do not copy \ into the data */
1543                         } else if (*start == '\'') {
1544                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1545                         } else {
1546                                 /* Replace , with |, unless in quotes */
1547                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1548                         }
1549                 }
1550         }
1551         if (start != dataPut)
1552                 *dataPut = 0;
1553         return dataPut;
1554 }
1555
1556 void ast_join(char *s, size_t len, const char * const w[])
1557 {
1558         int x, ofs = 0;
1559         const char *src;
1560
1561         /* Join words into a string */
1562         if (!s)
1563                 return;
1564         for (x = 0; ofs < len && w[x]; x++) {
1565                 if (x > 0)
1566                         s[ofs++] = ' ';
1567                 for (src = w[x]; *src && ofs < len; src++)
1568                         s[ofs++] = *src;
1569         }
1570         if (ofs == len)
1571                 ofs--;
1572         s[ofs] = '\0';
1573 }
1574
1575 /*
1576  * stringfields support routines.
1577  */
1578
1579 /* this is a little complex... string fields are stored with their
1580    allocated size in the bytes preceding the string; even the
1581    constant 'empty' string has to be this way, so the code that
1582    checks to see if there is enough room for a new string doesn't
1583    have to have any special case checks
1584 */
1585
1586 static const struct {
1587         ast_string_field_allocation allocation;
1588         char string[1];
1589 } __ast_string_field_empty_buffer;
1590
1591 ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string;
1592
1593 #define ALLOCATOR_OVERHEAD 48
1594
1595 static size_t optimal_alloc_size(size_t size)
1596 {
1597         unsigned int count;
1598
1599         size += ALLOCATOR_OVERHEAD;
1600
1601         for (count = 1; size; size >>= 1, count++);
1602
1603         return (1 << count) - ALLOCATOR_OVERHEAD;
1604 }
1605
1606 /*! \brief add a new block to the pool.
1607  * We can only allocate from the topmost pool, so the
1608  * fields in *mgr reflect the size of that only.
1609  */
1610 static int add_string_pool(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1611                            size_t size, const char *file, int lineno, const char *func)
1612 {
1613         struct ast_string_field_pool *pool;
1614         size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);
1615
1616 #if defined(__AST_DEBUG_MALLOC)
1617         if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) {
1618                 return -1;
1619         }
1620 #else
1621         if (!(pool = ast_calloc(1, alloc_size))) {
1622                 return -1;
1623         }
1624 #endif
1625
1626         pool->prev = *pool_head;
1627         pool->size = alloc_size - sizeof(*pool);
1628         *pool_head = pool;
1629         mgr->last_alloc = NULL;
1630
1631         return 0;
1632 }
1633
1634 /*
1635  * This is an internal API, code should not use it directly.
1636  * It initializes all fields as empty, then uses 'size' for 3 functions:
1637  * size > 0 means initialize the pool list with a pool of given size.
1638  *      This must be called right after allocating the object.
1639  * size = 0 means release all pools except the most recent one.
1640  *      If the first pool was allocated via embedding in another
1641  *      object, that pool will be preserved instead.
1642  *      This is useful to e.g. reset an object to the initial value.
1643  * size < 0 means release all pools.
1644  *      This must be done before destroying the object.
1645  */
1646 int __ast_string_field_init(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1647                             int needed, const char *file, int lineno, const char *func)
1648 {
1649         const char **p = (const char **) pool_head + 1;
1650         struct ast_string_field_pool *cur = NULL;
1651         struct ast_string_field_pool *preserve = NULL;
1652
1653         /* clear fields - this is always necessary */
1654         while ((struct ast_string_field_mgr *) p != mgr) {
1655                 *p++ = __ast_string_field_empty;
1656         }
1657
1658         mgr->last_alloc = NULL;
1659 #if defined(__AST_DEBUG_MALLOC)
1660         mgr->owner_file = file;
1661         mgr->owner_func = func;
1662         mgr->owner_line = lineno;
1663 #endif
1664         if (needed > 0) {               /* allocate the initial pool */
1665                 *pool_head = NULL;
1666                 mgr->embedded_pool = NULL;
1667                 return add_string_pool(mgr, pool_head, needed, file, lineno, func);
1668         }
1669
1670         /* if there is an embedded pool, we can't actually release *all*
1671          * pools, we must keep the embedded one. if the caller is about
1672          * to free the structure that contains the stringfield manager
1673          * and embedded pool anyway, it will be freed as part of that
1674          * operation.
1675          */
1676         if ((needed < 0) && mgr->embedded_pool) {
1677                 needed = 0;
1678         }
1679
1680         if (needed < 0) {               /* reset all pools */
1681                 cur = *pool_head;
1682         } else if (mgr->embedded_pool) { /* preserve the embedded pool */
1683                 preserve = mgr->embedded_pool;
1684                 cur = *pool_head;
1685         } else {                        /* preserve the last pool */
1686                 if (*pool_head == NULL) {
1687                         ast_log(LOG_WARNING, "trying to reset empty pool\n");
1688                         return -1;
1689                 }
1690                 preserve = *pool_head;
1691                 cur = preserve->prev;
1692         }
1693
1694         if (preserve) {
1695                 preserve->prev = NULL;
1696                 preserve->used = preserve->active = 0;
1697         }
1698
1699         while (cur) {
1700                 struct ast_string_field_pool *prev = cur->prev;
1701
1702                 if (cur != preserve) {
1703                         ast_free(cur);
1704                 }
1705                 cur = prev;
1706         }
1707
1708         *pool_head = preserve;
1709
1710         return 0;
1711 }
1712
1713 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr,
1714                                                 struct ast_string_field_pool **pool_head, size_t needed)
1715 {
1716         char *result = NULL;
1717         size_t space = (*pool_head)->size - (*pool_head)->used;
1718         size_t to_alloc;
1719
1720         /* Make room for ast_string_field_allocation and make it a multiple of that. */
1721         to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
1722         ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);
1723
1724         if (__builtin_expect(to_alloc > space, 0)) {
1725                 size_t new_size = (*pool_head)->size;
1726
1727                 while (new_size < to_alloc) {
1728                         new_size *= 2;
1729                 }
1730
1731 #if defined(__AST_DEBUG_MALLOC)
1732                 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
1733                         return NULL;
1734 #else
1735                 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__))
1736                         return NULL;
1737 #endif
1738         }
1739
1740         /* pool->base is always aligned (gcc aligned attribute). We ensure that
1741          * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
1742          * causing result to always be aligned as well; which in turn fixes that
1743          * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
1744         result = (*pool_head)->base + (*pool_head)->used;
1745         (*pool_head)->used += to_alloc;
1746         (*pool_head)->active += needed;
1747         result += ast_alignof(ast_string_field_allocation);
1748         AST_STRING_FIELD_ALLOCATION(result) = needed;
1749         mgr->last_alloc = result;
1750
1751         return result;
1752 }
1753
1754 int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr,
1755                                 struct ast_string_field_pool **pool_head, size_t needed,
1756                                 const ast_string_field *ptr)
1757 {
1758         ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
1759         size_t space = (*pool_head)->size - (*pool_head)->used;
1760
1761         if (*ptr != mgr->last_alloc) {
1762                 return 1;
1763         }
1764
1765         if (space < grow) {
1766                 return 1;
1767         }
1768
1769         (*pool_head)->used += grow;
1770         (*pool_head)->active += grow;
1771         AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
1772
1773         return 0;
1774 }
1775
1776 void __ast_string_field_release_active(struct ast_string_field_pool *pool_head,
1777                                        const ast_string_field ptr)
1778 {
1779         struct ast_string_field_pool *pool, *prev;
1780
1781         if (ptr == __ast_string_field_empty) {
1782                 return;
1783         }
1784
1785         for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
1786                 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
1787                         pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
1788                         if ((pool->active == 0) && prev) {
1789                                 prev->prev = pool->prev;
1790                                 ast_free(pool);
1791                         }
1792                         break;
1793                 }
1794         }
1795 }
1796
1797 void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
1798                                      struct ast_string_field_pool **pool_head,
1799                                      ast_string_field *ptr, const char *format, va_list ap)
1800 {
1801         size_t needed;
1802         size_t available;
1803         size_t space = (*pool_head)->size - (*pool_head)->used;
1804         ssize_t grow;
1805         char *target;
1806         va_list ap2;
1807
1808         /* if the field already has space allocated, try to reuse it;
1809            otherwise, try to use the empty space at the end of the current
1810            pool
1811         */
1812         if (*ptr != __ast_string_field_empty) {
1813                 target = (char *) *ptr;
1814                 available = AST_STRING_FIELD_ALLOCATION(*ptr);
1815                 if (*ptr == mgr->last_alloc) {
1816                         available += space;
1817                 }
1818         } else {
1819                 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
1820                  * so we don't need to re-align anything here.
1821                  */
1822                 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
1823                 available = space - ast_alignof(ast_string_field_allocation);
1824         }
1825
1826         va_copy(ap2, ap);
1827         needed = vsnprintf(target, available, format, ap2) + 1;
1828         va_end(ap2);
1829
1830         if (needed > available) {
1831                 /* the allocation could not be satisfied using the field's current allocation
1832                    (if it has one), or the space available in the pool (if it does not). allocate
1833                    space for it, adding a new string pool if necessary.
1834                 */
1835                 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {
1836                         return;
1837                 }
1838                 vsprintf(target, format, ap);
1839                 va_end(ap); /* XXX va_end without va_start? */
1840                 __ast_string_field_release_active(*pool_head, *ptr);
1841                 *ptr = target;
1842         } else if (*ptr != target) {
1843                 /* the allocation was satisfied using available space in the pool, but not
1844                    using the space already allocated to the field
1845                 */
1846                 __ast_string_field_release_active(*pool_head, *ptr);
1847                 mgr->last_alloc = *ptr = target;
1848                 AST_STRING_FIELD_ALLOCATION(target) = needed;
1849                 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
1850                 (*pool_head)->active += needed;
1851         } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
1852                 /* the allocation was satisfied by using available space in the pool *and*
1853                    the field was the last allocated field from the pool, so it grew
1854                 */
1855                 AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
1856                 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
1857                 (*pool_head)->active += grow;
1858         }
1859 }
1860
1861 void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
1862                                   struct ast_string_field_pool **pool_head,
1863                                   ast_string_field *ptr, const char *format, ...)
1864 {
1865         va_list ap;
1866
1867         va_start(ap, format);
1868         __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap);
1869         va_end(ap);
1870 }
1871
1872 void *__ast_calloc_with_stringfields(unsigned int num_structs, size_t struct_size, size_t field_mgr_offset,
1873                                      size_t field_mgr_pool_offset, size_t pool_size, const char *file,
1874                                      int lineno, const char *func)
1875 {
1876         struct ast_string_field_mgr *mgr;
1877         struct ast_string_field_pool *pool;
1878         struct ast_string_field_pool **pool_head;
1879         size_t pool_size_needed = sizeof(*pool) + pool_size;
1880         size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
1881         void *allocation;
1882         unsigned int x;
1883
1884 #if defined(__AST_DEBUG_MALLOC)
1885         if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) {
1886                 return NULL;
1887         }
1888 #else
1889         if (!(allocation = ast_calloc(num_structs, size_to_alloc))) {
1890                 return NULL;
1891         }
1892 #endif
1893
1894         for (x = 0; x < num_structs; x++) {
1895                 void *base = allocation + (size_to_alloc * x);
1896                 const char **p;
1897
1898                 mgr = base + field_mgr_offset;
1899                 pool_head = base + field_mgr_pool_offset;
1900                 pool = base + struct_size;
1901
1902                 p = (const char **) pool_head + 1;
1903                 while ((struct ast_string_field_mgr *) p != mgr) {
1904                         *p++ = __ast_string_field_empty;
1905                 }
1906
1907                 mgr->embedded_pool = pool;
1908                 *pool_head = pool;
1909                 pool->size = size_to_alloc - struct_size - sizeof(*pool);
1910 #if defined(__AST_DEBUG_MALLOC)
1911                 mgr->owner_file = file;
1912                 mgr->owner_func = func;
1913                 mgr->owner_line = lineno;
1914 #endif
1915         }
1916
1917         return allocation;
1918 }
1919
1920 /* end of stringfields support */
1921
1922 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1923
1924 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1925 {
1926         int ret;
1927         ast_mutex_lock(&fetchadd_m);
1928         ret = *p;
1929         *p += v;
1930         ast_mutex_unlock(&fetchadd_m);
1931         return ret;
1932 }
1933
1934 /*! \brief
1935  * get values from config variables.
1936  */
1937 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
1938 {
1939         long double dtv = 0.0;
1940         int scanned;
1941
1942         if (dst == NULL)
1943                 return -1;
1944
1945         *dst = _default;
1946
1947         if (ast_strlen_zero(src))
1948                 return -1;
1949
1950         /* only integer at the moment, but one day we could accept more formats */
1951         if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
1952                 dst->tv_sec = dtv;
1953                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
1954                 if (consumed)
1955                         *consumed = scanned;
1956                 return 0;
1957         } else
1958                 return -1;
1959 }
1960
1961 /*! \brief
1962  * get values from config variables.
1963  */
1964 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1965 {
1966         long t;
1967         int scanned;
1968
1969         if (dst == NULL)
1970                 return -1;
1971
1972         *dst = _default;
1973
1974         if (ast_strlen_zero(src))
1975                 return -1;
1976
1977         /* only integer at the moment, but one day we could accept more formats */
1978         if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
1979                 *dst = t;
1980                 if (consumed)
1981                         *consumed = scanned;
1982                 return 0;
1983         } else
1984                 return -1;
1985 }
1986
1987 void ast_enable_packet_fragmentation(int sock)
1988 {
1989 #if defined(HAVE_IP_MTU_DISCOVER)
1990         int val = IP_PMTUDISC_DONT;
1991
1992         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1993                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1994 #endif /* HAVE_IP_MTU_DISCOVER */
1995 }
1996
1997 int ast_mkdir(const char *path, int mode)
1998 {
1999         char *ptr;
2000         int len = strlen(path), count = 0, x, piececount = 0;
2001         char *tmp = ast_strdupa(path);
2002         char **pieces;
2003         char *fullpath = ast_alloca(len + 1);
2004         int res = 0;
2005
2006         for (ptr = tmp; *ptr; ptr++) {
2007                 if (*ptr == '/')
2008                         count++;
2009         }
2010
2011         /* Count the components to the directory path */
2012         pieces = ast_alloca(count * sizeof(*pieces));
2013         for (ptr = tmp; *ptr; ptr++) {
2014                 if (*ptr == '/') {
2015                         *ptr = '\0';
2016                         pieces[piececount++] = ptr + 1;
2017                 }
2018         }
2019
2020         *fullpath = '\0';
2021         for (x = 0; x < piececount; x++) {
2022                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
2023                 strcat(fullpath, "/");
2024                 strcat(fullpath, pieces[x]);
2025                 res = mkdir(fullpath, mode);
2026                 if (res && errno != EEXIST)
2027                         return errno;
2028         }
2029         return 0;
2030 }
2031
2032 int ast_utils_init(void)
2033 {
2034         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
2035         base64_init();
2036 #ifdef DEBUG_THREADS
2037 #if !defined(LOW_MEMORY)
2038         ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
2039 #endif
2040 #endif
2041         return 0;
2042 }
2043
2044
2045 /*!
2046  *\brief Parse digest authorization header.
2047  *\return Returns -1 if we have no auth or something wrong with digest.
2048  *\note This function may be used for Digest request and responce header.
2049  * request arg is set to nonzero, if we parse Digest Request.
2050  * pedantic arg can be set to nonzero if we need to do addition Digest check.
2051  */
2052 int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic) {
2053         char *c;
2054         struct ast_str *str = ast_str_create(16);
2055
2056         /* table of recognised keywords, and places where they should be copied */
2057         const struct x {
2058                 const char *key;
2059                 const ast_string_field *field;
2060         } *i, keys[] = {
2061                 { "username=", &d->username },
2062                 { "realm=", &d->realm },
2063                 { "nonce=", &d->nonce },
2064                 { "uri=", &d->uri },
2065                 { "domain=", &d->domain },
2066                 { "response=", &d->response },
2067                 { "cnonce=", &d->cnonce },
2068                 { "opaque=", &d->opaque },
2069                 /* Special cases that cannot be directly copied */
2070                 { "algorithm=", NULL },
2071                 { "qop=", NULL },
2072                 { "nc=", NULL },
2073                 { NULL, 0 },
2074         };
2075
2076         if (ast_strlen_zero(digest) || !d || !str) {
2077                 ast_free(str);
2078                 return -1;
2079         }
2080
2081         ast_str_set(&str, 0, "%s", digest);
2082
2083         c = ast_skip_blanks(ast_str_buffer(str));
2084
2085         if (strncasecmp(c, "Digest ", strlen("Digest "))) {
2086                 ast_log(LOG_WARNING, "Missing Digest.\n");
2087                 ast_free(str);
2088                 return -1;
2089         }
2090         c += strlen("Digest ");
2091
2092         /* lookup for keys/value pair */
2093         while (c && *c && *(c = ast_skip_blanks(c))) {
2094                 /* find key */
2095                 for (i = keys; i->key != NULL; i++) {
2096                         char *src, *separator;
2097                         int unescape = 0;
2098                         if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
2099                                 continue;
2100                         }
2101
2102                         /* Found. Skip keyword, take text in quotes or up to the separator. */
2103                         c += strlen(i->key);
2104                         if (*c == '"') {
2105                                 src = ++c;
2106                                 separator = "\"";
2107                                 unescape = 1;
2108                         } else {
2109                                 src = c;
2110                                 separator = ",";
2111                         }
2112                         strsep(&c, separator); /* clear separator and move ptr */
2113                         if (unescape) {
2114                                 ast_unescape_c(src);
2115                         }
2116                         if (i->field) {
2117                                 ast_string_field_ptr_set(d, i->field, src);
2118                         } else {
2119                                 /* Special cases that require additional procesing */
2120                                 if (!strcasecmp(i->key, "algorithm=")) {
2121                                         if (strcasecmp(src, "MD5")) {
2122                                                 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
2123                                                 ast_free(str);
2124                                                 return -1;
2125                                         }
2126                                 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
2127                                         d->qop = 1;
2128                                 } else if (!strcasecmp(i->key, "nc=")) {
2129                                         unsigned long u;
2130                                         if (sscanf(src, "%30lx", &u) != 1) {
2131                                                 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
2132                                                 ast_free(str);
2133                                                 return -1;
2134                                         }
2135                                         ast_string_field_set(d, nc, src);
2136                                 }
2137                         }
2138                         break;
2139                 }
2140                 if (i->key == NULL) { /* not found, try ',' */
2141                         strsep(&c, ",");
2142                 }
2143         }
2144         ast_free(str);
2145
2146         /* Digest checkout */
2147         if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
2148                 /* "realm" and "nonce" MUST be always exist */
2149                 return -1;
2150         }
2151
2152         if (!request) {
2153                 /* Additional check for Digest response */
2154                 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
2155                         return -1;
2156                 }
2157
2158                 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
2159                         return -1;
2160                 }
2161         }
2162
2163         return 0;
2164 }
2165
2166 #ifndef __AST_DEBUG_MALLOC
2167 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...)
2168 {
2169         int res;
2170         va_list ap;
2171
2172         va_start(ap, fmt);
2173         if ((res = vasprintf(ret, fmt, ap)) == -1) {
2174                 MALLOC_FAILURE_MSG;
2175         }
2176         va_end(ap);
2177
2178         return res;
2179 }
2180 #endif
2181
2182 int ast_get_tid(void)
2183 {
2184         int ret = -1;
2185 #if defined (__linux) && defined(SYS_gettid)
2186         ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */
2187 #elif defined(__sun)
2188         ret = pthread_self();
2189 #elif defined(__APPLE__)
2190         ret = mach_thread_self();
2191         mach_port_deallocate(mach_task_self(), ret);
2192 #elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H)
2193         long lwpid;
2194         thr_self(&lwpid); /* available since sys/thr.h creation 2003 */
2195         ret = lwpid;
2196 #endif
2197         return ret;
2198 }
2199
2200 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size)
2201 {
2202         const char *envPATH = getenv("PATH");
2203         char *tpath, *path;
2204         struct stat unused;
2205         if (!envPATH) {
2206                 return NULL;
2207         }
2208         tpath = ast_strdupa(envPATH);
2209         while ((path = strsep(&tpath, ":"))) {
2210                 snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
2211                 if (!stat(fullpath, &unused)) {
2212                         return fullpath;
2213                 }
2214         }
2215         return NULL;
2216 }
2217
2218 void ast_do_crash(void)
2219 {
2220 #if defined(DO_CRASH)
2221         abort();
2222         /*
2223          * Just in case abort() doesn't work or something else super
2224          * silly, and for Qwell's amusement.
2225          */
2226         *((int *) 0) = 0;
2227 #endif  /* defined(DO_CRASH) */
2228 }
2229
2230 #if defined(AST_DEVMODE)
2231 void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function)
2232 {
2233         /*
2234          * Attempt to put it into the logger, but hope that at least
2235          * someone saw the message on stderr ...
2236          */
2237         ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
2238                 condition_str, condition);
2239         fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
2240                 condition_str, condition, line, function, file);
2241         /*
2242          * Give the logger a chance to get the message out, just in case
2243          * we abort(), or Asterisk crashes due to whatever problem just
2244          * happened after we exit ast_assert().
2245          */
2246         usleep(1);
2247         ast_do_crash();
2248 }
2249 #endif  /* defined(AST_DEVMODE) */