Reorder startup sequence to prevent lockups when process is sent to background
[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 #ifdef HAVE_DEV_URANDOM
39 #include <fcntl.h>
40 #endif
41
42 #include <sys/syscall.h>
43 #if defined(__APPLE__)
44 #include <mach/mach.h>
45 #elif defined(HAVE_SYS_THR_H)
46 #include <sys/thr.h>
47 #endif
48
49 #include "asterisk/network.h"
50
51 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
52 #include "asterisk/lock.h"
53 #include "asterisk/io.h"
54 #include "asterisk/md5.h"
55 #include "asterisk/sha1.h"
56 #include "asterisk/cli.h"
57 #include "asterisk/linkedlists.h"
58
59 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
60 #include "asterisk/strings.h"
61
62 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
63 #include "asterisk/time.h"
64
65 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
66 #include "asterisk/stringfields.h"
67
68 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
69 #include "asterisk/utils.h"
70
71 #define AST_API_MODULE
72 #include "asterisk/threadstorage.h"
73
74 #define AST_API_MODULE
75 #include "asterisk/config.h"
76
77 static char base64[64];
78 static char b2a[256];
79
80 AST_THREADSTORAGE(inet_ntoa_buf);
81
82 #if !defined(HAVE_GETHOSTBYNAME_R_5) && !defined(HAVE_GETHOSTBYNAME_R_6)
83
84 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
85 #undef gethostbyname
86
87 AST_MUTEX_DEFINE_STATIC(__mutex);
88
89 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
90 \note This
91 routine is derived from code originally written and placed in the public
92 domain by Enzo Michelangeli <em@em.no-ip.com> */
93
94 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
95                                 size_t buflen, struct hostent **result,
96                                 int *h_errnop)
97 {
98         int hsave;
99         struct hostent *ph;
100         ast_mutex_lock(&__mutex); /* begin critical area */
101         hsave = h_errno;
102
103         ph = gethostbyname(name);
104         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
105         if (ph == NULL) {
106                 *result = NULL;
107         } else {
108                 char **p, **q;
109                 char *pbuf;
110                 int nbytes = 0;
111                 int naddr = 0, naliases = 0;
112                 /* determine if we have enough space in buf */
113
114                 /* count how many addresses */
115                 for (p = ph->h_addr_list; *p != 0; p++) {
116                         nbytes += ph->h_length; /* addresses */
117                         nbytes += sizeof(*p); /* pointers */
118                         naddr++;
119                 }
120                 nbytes += sizeof(*p); /* one more for the terminating NULL */
121
122                 /* count how many aliases, and total length of strings */
123                 for (p = ph->h_aliases; *p != 0; p++) {
124                         nbytes += (strlen(*p)+1); /* aliases */
125                         nbytes += sizeof(*p);  /* pointers */
126                         naliases++;
127                 }
128                 nbytes += sizeof(*p); /* one more for the terminating NULL */
129
130                 /* here nbytes is the number of bytes required in buffer */
131                 /* as a terminator must be there, the minimum value is ph->h_length */
132                 if (nbytes > buflen) {
133                         *result = NULL;
134                         ast_mutex_unlock(&__mutex); /* end critical area */
135                         return ERANGE; /* not enough space in buf!! */
136                 }
137
138                 /* There is enough space. Now we need to do a deep copy! */
139                 /* Allocation in buffer:
140                         from [0] to [(naddr-1) * sizeof(*p)]:
141                         pointers to addresses
142                         at [naddr * sizeof(*p)]:
143                         NULL
144                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
145                         pointers to aliases
146                         at [(naddr+naliases+1) * sizeof(*p)]:
147                         NULL
148                         then naddr addresses (fixed length), and naliases aliases (asciiz).
149                 */
150
151                 *ret = *ph;   /* copy whole structure (not its address!) */
152
153                 /* copy addresses */
154                 q = (char **)buf; /* pointer to pointers area (type: char **) */
155                 ret->h_addr_list = q; /* update pointer to address list */
156                 pbuf = buf + ((naddr + naliases + 2) * sizeof(*p)); /* skip that area */
157                 for (p = ph->h_addr_list; *p != 0; p++) {
158                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
159                         *q++ = pbuf; /* the pointer is the one inside buf... */
160                         pbuf += ph->h_length; /* advance pbuf */
161                 }
162                 *q++ = NULL; /* address list terminator */
163
164                 /* copy aliases */
165                 ret->h_aliases = q; /* update pointer to aliases list */
166                 for (p = ph->h_aliases; *p != 0; p++) {
167                         strcpy(pbuf, *p); /* copy alias strings */
168                         *q++ = pbuf; /* the pointer is the one inside buf... */
169                         pbuf += strlen(*p); /* advance pbuf */
170                         *pbuf++ = 0; /* string terminator */
171                 }
172                 *q++ = NULL; /* terminator */
173
174                 strcpy(pbuf, ph->h_name); /* copy alias strings */
175                 ret->h_name = pbuf;
176                 pbuf += strlen(ph->h_name); /* advance pbuf */
177                 *pbuf++ = 0; /* string terminator */
178
179                 *result = ret;  /* and let *result point to structure */
180
181         }
182         h_errno = hsave;  /* restore h_errno */
183         ast_mutex_unlock(&__mutex); /* end critical area */
184
185         return (*result == NULL); /* return 0 on success, non-zero on error */
186 }
187
188
189 #endif
190
191 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the
192    standard gethostbyname (which is not thread safe)
193 */
194 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
195 {
196         int res;
197         int herrno;
198         int dots = 0;
199         const char *s;
200         struct hostent *result = NULL;
201         /* Although it is perfectly legitimate to lookup a pure integer, for
202            the sake of the sanity of people who like to name their peers as
203            integers, we break with tradition and refuse to look up a
204            pure integer */
205         s = host;
206         res = 0;
207         while (s && *s) {
208                 if (*s == '.')
209                         dots++;
210                 else if (!isdigit(*s))
211                         break;
212                 s++;
213         }
214         if (!s || !*s) {
215                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
216                 if (dots != 3)
217                         return NULL;
218                 memset(hp, 0, sizeof(struct ast_hostent));
219                 hp->hp.h_addrtype = AF_INET;
220                 hp->hp.h_addr_list = (void *) hp->buf;
221                 hp->hp.h_addr = hp->buf + sizeof(void *);
222                 /* For AF_INET, this will always be 4 */
223                 hp->hp.h_length = 4;
224                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
225                         return &hp->hp;
226                 return NULL;
227
228         }
229 #ifdef HAVE_GETHOSTBYNAME_R_5
230         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
231
232         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
233                 return NULL;
234 #else
235         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
236
237         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
238                 return NULL;
239 #endif
240         return &hp->hp;
241 }
242
243 /*! \brief Produce 32 char MD5 hash of value. */
244 void ast_md5_hash(char *output, const char *input)
245 {
246         struct MD5Context md5;
247         unsigned char digest[16];
248         char *ptr;
249         int x;
250
251         MD5Init(&md5);
252         MD5Update(&md5, (const unsigned char *) input, strlen(input));
253         MD5Final(digest, &md5);
254         ptr = output;
255         for (x = 0; x < 16; x++)
256                 ptr += sprintf(ptr, "%2.2x", digest[x]);
257 }
258
259 /*! \brief Produce 40 char SHA1 hash of value. */
260 void ast_sha1_hash(char *output, const char *input)
261 {
262         struct SHA1Context sha;
263         char *ptr;
264         int x;
265         uint8_t Message_Digest[20];
266
267         SHA1Reset(&sha);
268
269         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
270
271         SHA1Result(&sha, Message_Digest);
272         ptr = output;
273         for (x = 0; x < 20; x++)
274                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
275 }
276
277 /*! \brief Produce a 20 byte SHA1 hash of value. */
278 void ast_sha1_hash_uint(uint8_t *digest, const char *input)
279 {
280         struct SHA1Context sha;
281
282         SHA1Reset(&sha);
283
284         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
285
286         SHA1Result(&sha, digest);
287 }
288
289 /*! \brief decode BASE64 encoded text */
290 int ast_base64decode(unsigned char *dst, const char *src, int max)
291 {
292         int cnt = 0;
293         unsigned int byte = 0;
294         unsigned int bits = 0;
295         int incnt = 0;
296         while(*src && *src != '=' && (cnt < max)) {
297                 /* Shift in 6 bits of input */
298                 byte <<= 6;
299                 byte |= (b2a[(int)(*src)]) & 0x3f;
300                 bits += 6;
301                 src++;
302                 incnt++;
303                 /* If we have at least 8 bits left over, take that character
304                    off the top */
305                 if (bits >= 8)  {
306                         bits -= 8;
307                         *dst = (byte >> bits) & 0xff;
308                         dst++;
309                         cnt++;
310                 }
311         }
312         /* Don't worry about left over bits, they're extra anyway */
313         return cnt;
314 }
315
316 /*! \brief encode text to BASE64 coding */
317 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
318 {
319         int cnt = 0;
320         int col = 0;
321         unsigned int byte = 0;
322         int bits = 0;
323         int cntin = 0;
324         /* Reserve space for null byte at end of string */
325         max--;
326         while ((cntin < srclen) && (cnt < max)) {
327                 byte <<= 8;
328                 byte |= *(src++);
329                 bits += 8;
330                 cntin++;
331                 if ((bits == 24) && (cnt + 4 <= max)) {
332                         *dst++ = base64[(byte >> 18) & 0x3f];
333                         *dst++ = base64[(byte >> 12) & 0x3f];
334                         *dst++ = base64[(byte >> 6) & 0x3f];
335                         *dst++ = base64[byte & 0x3f];
336                         cnt += 4;
337                         col += 4;
338                         bits = 0;
339                         byte = 0;
340                 }
341                 if (linebreaks && (cnt < max) && (col == 64)) {
342                         *dst++ = '\n';
343                         cnt++;
344                         col = 0;
345                 }
346         }
347         if (bits && (cnt + 4 <= max)) {
348                 /* Add one last character for the remaining bits,
349                    padding the rest with 0 */
350                 byte <<= 24 - bits;
351                 *dst++ = base64[(byte >> 18) & 0x3f];
352                 *dst++ = base64[(byte >> 12) & 0x3f];
353                 if (bits == 16)
354                         *dst++ = base64[(byte >> 6) & 0x3f];
355                 else
356                         *dst++ = '=';
357                 *dst++ = '=';
358                 cnt += 4;
359         }
360         if (linebreaks && (cnt < max)) {
361                 *dst++ = '\n';
362                 cnt++;
363         }
364         *dst = '\0';
365         return cnt;
366 }
367
368 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
369 {
370         return ast_base64encode_full(dst, src, srclen, max, 0);
371 }
372
373 static void base64_init(void)
374 {
375         int x;
376         memset(b2a, -1, sizeof(b2a));
377         /* Initialize base-64 Conversion table */
378         for (x = 0; x < 26; x++) {
379                 /* A-Z */
380                 base64[x] = 'A' + x;
381                 b2a['A' + x] = x;
382                 /* a-z */
383                 base64[x + 26] = 'a' + x;
384                 b2a['a' + x] = x + 26;
385                 /* 0-9 */
386                 if (x < 10) {
387                         base64[x + 52] = '0' + x;
388                         b2a['0' + x] = x + 52;
389                 }
390         }
391         base64[62] = '+';
392         base64[63] = '/';
393         b2a[(int)'+'] = 62;
394         b2a[(int)'/'] = 63;
395 }
396
397 const struct ast_flags ast_uri_http = {AST_URI_UNRESERVED};
398 const struct ast_flags ast_uri_http_legacy = {AST_URI_LEGACY_SPACE | AST_URI_UNRESERVED};
399 const struct ast_flags ast_uri_sip_user = {AST_URI_UNRESERVED | AST_URI_SIP_USER_UNRESERVED};
400
401 char *ast_uri_encode(const char *string, char *outbuf, int buflen, struct ast_flags spec)
402 {
403         const char *ptr  = string;      /* Start with the string */
404         char *out = outbuf;
405         const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */
406         const char *user_unreserved = "&=+$,;?/"; /* user-unreserved set, RFC 3261 sec 25 */
407
408         while (*ptr && out - outbuf < buflen - 1) {
409                 if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *ptr == ' ') {
410                         /* for legacy encoding, encode spaces as '+' */
411                         *out = '+';
412                         out++;
413                 } else if (!(ast_test_flag(&spec, AST_URI_MARK)
414                                 && strchr(mark, *ptr))
415                         && !(ast_test_flag(&spec, AST_URI_ALPHANUM)
416                                 && ((*ptr >= '0' && *ptr <= '9')
417                                 || (*ptr >= 'A' && *ptr <= 'Z')
418                                 || (*ptr >= 'a' && *ptr <= 'z')))
419                         && !(ast_test_flag(&spec, AST_URI_SIP_USER_UNRESERVED)
420                                 && strchr(user_unreserved, *ptr))) {
421
422                         if (out - outbuf >= buflen - 3) {
423                                 break;
424                         }
425                         out += sprintf(out, "%%%02X", (unsigned char) *ptr);
426                 } else {
427                         *out = *ptr;    /* Continue copying the string */
428                         out++;
429                 }
430                 ptr++;
431         }
432
433         if (buflen) {
434                 *out = '\0';
435         }
436
437         return outbuf;
438 }
439
440 void ast_uri_decode(char *s, struct ast_flags spec)
441 {
442         char *o;
443         unsigned int tmp;
444
445         for (o = s; *s; s++, o++) {
446                 if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *s == '+') {
447                         /* legacy mode, decode '+' as space */
448                         *o = ' ';
449                 } else if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) {
450                         /* have '%', two chars and correct parsing */
451                         *o = tmp;
452                         s += 2; /* Will be incremented once more when we break out */
453                 } else /* all other cases, just copy */
454                         *o = *s;
455         }
456         *o = '\0';
457 }
458
459 char *ast_escape_quoted(const char *string, char *outbuf, int buflen)
460 {
461         const char *ptr  = string;
462         char *out = outbuf;
463         char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */
464
465         while (*ptr && out - outbuf < buflen - 1) {
466                 if (!(strchr(allow, *ptr))
467                         && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */
468                         && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */
469                         && !((unsigned char) *ptr > 0x7f)) {             /* UTF8-nonascii */
470
471                         if (out - outbuf >= buflen - 2) {
472                                 break;
473                         }
474                         out += sprintf(out, "\\%c", (unsigned char) *ptr);
475                 } else {
476                         *out = *ptr;
477                         out++;
478                 }
479                 ptr++;
480         }
481
482         if (buflen) {
483                 *out = '\0';
484         }
485
486         return outbuf;
487 }
488 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
489 const char *ast_inet_ntoa(struct in_addr ia)
490 {
491         char *buf;
492
493         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
494                 return "";
495
496         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
497 }
498
499 #ifdef HAVE_DEV_URANDOM
500 static int dev_urandom_fd;
501 #endif
502
503 #ifndef __linux__
504 #undef pthread_create /* For ast_pthread_create function only */
505 #endif /* !__linux__ */
506
507 #if !defined(LOW_MEMORY)
508
509 #ifdef DEBUG_THREADS
510
511 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
512 #define AST_MAX_LOCKS 64
513
514 /* Allow direct use of pthread_mutex_t and friends */
515 #undef pthread_mutex_t
516 #undef pthread_mutex_lock
517 #undef pthread_mutex_unlock
518 #undef pthread_mutex_init
519 #undef pthread_mutex_destroy
520
521 /*!
522  * \brief Keep track of which locks a thread holds
523  *
524  * There is an instance of this struct for every active thread
525  */
526 struct thr_lock_info {
527         /*! The thread's ID */
528         pthread_t thread_id;
529         /*! The thread name which includes where the thread was started */
530         const char *thread_name;
531         /*! This is the actual container of info for what locks this thread holds */
532         struct {
533                 const char *file;
534                 int line_num;
535                 const char *func;
536                 const char *lock_name;
537                 void *lock_addr;
538                 int times_locked;
539                 enum ast_lock_type type;
540                 /*! This thread is waiting on this lock */
541                 int pending:2;
542 #ifdef HAVE_BKTR
543                 struct ast_bt *backtrace;
544 #endif
545         } locks[AST_MAX_LOCKS];
546         /*! This is the number of locks currently held by this thread.
547          *  The index (num_locks - 1) has the info on the last one in the
548          *  locks member */
549         unsigned int num_locks;
550         /*! Protects the contents of the locks member
551          * Intentionally not ast_mutex_t */
552         pthread_mutex_t lock;
553         AST_LIST_ENTRY(thr_lock_info) entry;
554 };
555
556 /*!
557  * \brief Locked when accessing the lock_infos list
558  */
559 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
560 /*!
561  * \brief A list of each thread's lock info
562  */
563 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
564
565 /*!
566  * \brief Destroy a thread's lock info
567  *
568  * This gets called automatically when the thread stops
569  */
570 static void lock_info_destroy(void *data)
571 {
572         struct thr_lock_info *lock_info = data;
573         int i;
574
575         pthread_mutex_lock(&lock_infos_lock.mutex);
576         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
577         pthread_mutex_unlock(&lock_infos_lock.mutex);
578
579
580         for (i = 0; i < lock_info->num_locks; i++) {
581                 if (lock_info->locks[i].pending == -1) {
582                         /* This just means that the last lock this thread went for was by
583                          * using trylock, and it failed.  This is fine. */
584                         break;
585                 }
586
587                 ast_log(LOG_ERROR,
588                         "Thread '%s' still has a lock! - '%s' (%p) from '%s' in %s:%d!\n",
589                         lock_info->thread_name,
590                         lock_info->locks[i].lock_name,
591                         lock_info->locks[i].lock_addr,
592                         lock_info->locks[i].func,
593                         lock_info->locks[i].file,
594                         lock_info->locks[i].line_num
595                 );
596         }
597
598         pthread_mutex_destroy(&lock_info->lock);
599         if (lock_info->thread_name)
600                 free((void *) lock_info->thread_name);
601         free(lock_info);
602 }
603
604 /*!
605  * \brief The thread storage key for per-thread lock info
606  */
607 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
608 #ifdef HAVE_BKTR
609 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
610         int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
611 #else
612 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
613         int line_num, const char *func, const char *lock_name, void *lock_addr)
614 #endif
615 {
616         struct thr_lock_info *lock_info;
617         int i;
618
619         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
620                 return;
621
622         pthread_mutex_lock(&lock_info->lock);
623
624         for (i = 0; i < lock_info->num_locks; i++) {
625                 if (lock_info->locks[i].lock_addr == lock_addr) {
626                         lock_info->locks[i].times_locked++;
627 #ifdef HAVE_BKTR
628                         lock_info->locks[i].backtrace = bt;
629 #endif
630                         pthread_mutex_unlock(&lock_info->lock);
631                         return;
632                 }
633         }
634
635         if (lock_info->num_locks == AST_MAX_LOCKS) {
636                 /* Can't use ast_log here, because it will cause infinite recursion */
637                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
638                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
639                 pthread_mutex_unlock(&lock_info->lock);
640                 return;
641         }
642
643         if (i && lock_info->locks[i - 1].pending == -1) {
644                 /* The last lock on the list was one that this thread tried to lock but
645                  * failed at doing so.  It has now moved on to something else, so remove
646                  * the old lock from the list. */
647                 i--;
648                 lock_info->num_locks--;
649                 memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
650         }
651
652         lock_info->locks[i].file = filename;
653         lock_info->locks[i].line_num = line_num;
654         lock_info->locks[i].func = func;
655         lock_info->locks[i].lock_name = lock_name;
656         lock_info->locks[i].lock_addr = lock_addr;
657         lock_info->locks[i].times_locked = 1;
658         lock_info->locks[i].type = type;
659         lock_info->locks[i].pending = 1;
660 #ifdef HAVE_BKTR
661         lock_info->locks[i].backtrace = bt;
662 #endif
663         lock_info->num_locks++;
664
665         pthread_mutex_unlock(&lock_info->lock);
666 }
667
668 void ast_mark_lock_acquired(void *lock_addr)
669 {
670         struct thr_lock_info *lock_info;
671
672         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
673                 return;
674
675         pthread_mutex_lock(&lock_info->lock);
676         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
677                 lock_info->locks[lock_info->num_locks - 1].pending = 0;
678         }
679         pthread_mutex_unlock(&lock_info->lock);
680 }
681
682 void ast_mark_lock_failed(void *lock_addr)
683 {
684         struct thr_lock_info *lock_info;
685
686         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
687                 return;
688
689         pthread_mutex_lock(&lock_info->lock);
690         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
691                 lock_info->locks[lock_info->num_locks - 1].pending = -1;
692                 lock_info->locks[lock_info->num_locks - 1].times_locked--;
693         }
694         pthread_mutex_unlock(&lock_info->lock);
695 }
696
697 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)
698 {
699         struct thr_lock_info *lock_info;
700         int i = 0;
701
702         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
703                 return -1;
704
705         pthread_mutex_lock(&lock_info->lock);
706
707         for (i = lock_info->num_locks - 1; i >= 0; i--) {
708                 if (lock_info->locks[i].lock_addr == lock_addr)
709                         break;
710         }
711
712         if (i == -1) {
713                 /* Lock not found :( */
714                 pthread_mutex_unlock(&lock_info->lock);
715                 return -1;
716         }
717
718         ast_copy_string(filename, lock_info->locks[i].file, filename_size);
719         *lineno = lock_info->locks[i].line_num;
720         ast_copy_string(func, lock_info->locks[i].func, func_size);
721         ast_copy_string(mutex_name, lock_info->locks[i].lock_name, mutex_name_size);
722
723         pthread_mutex_unlock(&lock_info->lock);
724
725         return 0;
726 }
727
728 #ifdef HAVE_BKTR
729 void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt)
730 #else
731 void ast_remove_lock_info(void *lock_addr)
732 #endif
733 {
734         struct thr_lock_info *lock_info;
735         int i = 0;
736
737         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
738                 return;
739
740         pthread_mutex_lock(&lock_info->lock);
741
742         for (i = lock_info->num_locks - 1; i >= 0; i--) {
743                 if (lock_info->locks[i].lock_addr == lock_addr)
744                         break;
745         }
746
747         if (i == -1) {
748                 /* Lock not found :( */
749                 pthread_mutex_unlock(&lock_info->lock);
750                 return;
751         }
752
753         if (lock_info->locks[i].times_locked > 1) {
754                 lock_info->locks[i].times_locked--;
755 #ifdef HAVE_BKTR
756                 lock_info->locks[i].backtrace = bt;
757 #endif
758                 pthread_mutex_unlock(&lock_info->lock);
759                 return;
760         }
761
762         if (i < lock_info->num_locks - 1) {
763                 /* Not the last one ... *should* be rare! */
764                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1],
765                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
766         }
767
768         lock_info->num_locks--;
769
770         pthread_mutex_unlock(&lock_info->lock);
771 }
772
773 static const char *locktype2str(enum ast_lock_type type)
774 {
775         switch (type) {
776         case AST_MUTEX:
777                 return "MUTEX";
778         case AST_RDLOCK:
779                 return "RDLOCK";
780         case AST_WRLOCK:
781                 return "WRLOCK";
782         }
783
784         return "UNKNOWN";
785 }
786
787 #ifdef HAVE_BKTR
788 static void append_backtrace_information(struct ast_str **str, struct ast_bt *bt)
789 {
790         char **symbols;
791         int num_frames;
792
793         if (!bt) {
794                 ast_str_append(str, 0, "\tNo backtrace to print\n");
795                 return;
796         }
797
798         /* store frame count locally to avoid the memory corruption that
799          * sometimes happens on virtualized CentOS 6.x systems */
800         num_frames = bt->num_frames;
801         if ((symbols = ast_bt_get_symbols(bt->addresses, num_frames))) {
802                 int frame_iterator;
803
804                 for (frame_iterator = 0; frame_iterator < num_frames; ++frame_iterator) {
805                         ast_str_append(str, 0, "\t%s\n", symbols[frame_iterator]);
806                 }
807
808                 free(symbols);
809         } else {
810                 ast_str_append(str, 0, "\tCouldn't retrieve backtrace symbols\n");
811         }
812 }
813 #endif
814
815 static void append_lock_information(struct ast_str **str, struct thr_lock_info *lock_info, int i)
816 {
817         int j;
818         ast_mutex_t *lock;
819         struct ast_lock_track *lt;
820
821         ast_str_append(str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d)\n",
822                                    lock_info->locks[i].pending > 0 ? "Waiting for " :
823                                    lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
824                                    lock_info->locks[i].file,
825                                    locktype2str(lock_info->locks[i].type),
826                                    lock_info->locks[i].line_num,
827                                    lock_info->locks[i].func, lock_info->locks[i].lock_name,
828                                    lock_info->locks[i].lock_addr,
829                                    lock_info->locks[i].times_locked);
830 #ifdef HAVE_BKTR
831         append_backtrace_information(str, lock_info->locks[i].backtrace);
832 #endif
833
834         if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
835                 return;
836
837         /* We only have further details for mutexes right now */
838         if (lock_info->locks[i].type != AST_MUTEX)
839                 return;
840
841         lock = lock_info->locks[i].lock_addr;
842         lt = lock->track;
843         ast_reentrancy_lock(lt);
844         for (j = 0; *str && j < lt->reentrancy; j++) {
845                 ast_str_append(str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
846                                            lt->file[j], lt->lineno[j], lt->func[j]);
847         }
848         ast_reentrancy_unlock(lt);
849 }
850
851
852 /*! This function can help you find highly temporal locks; locks that happen for a
853     short time, but at unexpected times, usually at times that create a deadlock,
854         Why is this thing locked right then? Who is locking it? Who am I fighting
855     with for this lock?
856
857         To answer such questions, just call this routine before you would normally try
858         to aquire a lock. It doesn't do anything if the lock is not acquired. If the
859         lock is taken, it will publish a line or two to the console via ast_log().
860
861         Sometimes, the lock message is pretty uninformative. For instance, you might
862         find that the lock is being aquired deep within the astobj2 code; this tells
863         you little about higher level routines that call the astobj2 routines.
864         But, using gdb, you can set a break at the ast_log below, and for that
865         breakpoint, you can set the commands:
866           where
867           cont
868         which will give a stack trace and continue. -- that aught to do the job!
869
870 */
871 void log_show_lock(void *this_lock_addr)
872 {
873         struct thr_lock_info *lock_info;
874         struct ast_str *str;
875
876         if (!(str = ast_str_create(4096))) {
877                 ast_log(LOG_NOTICE,"Could not create str\n");
878                 return;
879         }
880
881
882         pthread_mutex_lock(&lock_infos_lock.mutex);
883         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
884                 int i;
885                 pthread_mutex_lock(&lock_info->lock);
886                 for (i = 0; str && i < lock_info->num_locks; i++) {
887                         /* ONLY show info about this particular lock, if
888                            it's acquired... */
889                         if (lock_info->locks[i].lock_addr == this_lock_addr) {
890                                 append_lock_information(&str, lock_info, i);
891                                 ast_log(LOG_NOTICE, "%s", ast_str_buffer(str));
892                                 break;
893                         }
894                 }
895                 pthread_mutex_unlock(&lock_info->lock);
896         }
897         pthread_mutex_unlock(&lock_infos_lock.mutex);
898         ast_free(str);
899 }
900
901
902 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
903 {
904         struct thr_lock_info *lock_info;
905         struct ast_str *str;
906
907         if (!(str = ast_str_create(4096)))
908                 return CLI_FAILURE;
909
910         switch (cmd) {
911         case CLI_INIT:
912                 e->command = "core show locks";
913                 e->usage =
914                         "Usage: core show locks\n"
915                         "       This command is for lock debugging.  It prints out which locks\n"
916                         "are owned by each active thread.\n";
917                 return NULL;
918
919         case CLI_GENERATE:
920                 return NULL;
921         }
922
923         ast_str_append(&str, 0, "\n"
924                        "=======================================================================\n"
925                        "=== Currently Held Locks ==============================================\n"
926                        "=======================================================================\n"
927                        "===\n"
928                        "=== <pending> <lock#> (<file>): <lock type> <line num> <function> <lock name> <lock addr> (times locked)\n"
929                        "===\n");
930
931         if (!str)
932                 return CLI_FAILURE;
933
934         pthread_mutex_lock(&lock_infos_lock.mutex);
935         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
936                 int i;
937                 if (lock_info->num_locks) {
938                         ast_str_append(&str, 0, "=== Thread ID: 0x%lx (%s)\n", (long) lock_info->thread_id,
939                                 lock_info->thread_name);
940                         pthread_mutex_lock(&lock_info->lock);
941                         for (i = 0; str && i < lock_info->num_locks; i++) {
942                                 append_lock_information(&str, lock_info, i);
943                         }
944                         pthread_mutex_unlock(&lock_info->lock);
945                         if (!str)
946                                 break;
947                         ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
948                                        "===\n");
949                         if (!str)
950                                 break;
951                 }
952         }
953         pthread_mutex_unlock(&lock_infos_lock.mutex);
954
955         if (!str)
956                 return CLI_FAILURE;
957
958         ast_str_append(&str, 0, "=======================================================================\n"
959                        "\n");
960
961         if (!str)
962                 return CLI_FAILURE;
963
964         ast_cli(a->fd, "%s", ast_str_buffer(str));
965
966         ast_free(str);
967
968         return CLI_SUCCESS;
969 }
970
971 static struct ast_cli_entry utils_cli[] = {
972         AST_CLI_DEFINE(handle_show_locks, "Show which locks are held by which thread"),
973 };
974
975 #endif /* DEBUG_THREADS */
976
977 /*
978  * support for 'show threads'. The start routine is wrapped by
979  * dummy_start(), so that ast_register_thread() and
980  * ast_unregister_thread() know the thread identifier.
981  */
982 struct thr_arg {
983         void *(*start_routine)(void *);
984         void *data;
985         char *name;
986 };
987
988 /*
989  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
990  * are odd macros which start and end a block, so they _must_ be
991  * used in pairs (the latter with a '1' argument to call the
992  * handler on exit.
993  * On BSD we don't need this, but we keep it for compatibility.
994  */
995 static void *dummy_start(void *data)
996 {
997         void *ret;
998         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
999 #ifdef DEBUG_THREADS
1000         struct thr_lock_info *lock_info;
1001         pthread_mutexattr_t mutex_attr;
1002
1003         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
1004                 return NULL;
1005
1006         lock_info->thread_id = pthread_self();
1007         lock_info->thread_name = strdup(a.name);
1008
1009         pthread_mutexattr_init(&mutex_attr);
1010         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
1011         pthread_mutex_init(&lock_info->lock, &mutex_attr);
1012         pthread_mutexattr_destroy(&mutex_attr);
1013
1014         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1015         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
1016         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1017 #endif /* DEBUG_THREADS */
1018
1019         /* note that even though data->name is a pointer to allocated memory,
1020            we are not freeing it here because ast_register_thread is going to
1021            keep a copy of the pointer and then ast_unregister_thread will
1022            free the memory
1023         */
1024         ast_free(data);
1025         ast_register_thread(a.name);
1026         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
1027
1028         ret = a.start_routine(a.data);
1029
1030         pthread_cleanup_pop(1);
1031
1032         return ret;
1033 }
1034
1035 #endif /* !LOW_MEMORY */
1036
1037 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1038                              void *data, size_t stacksize, const char *file, const char *caller,
1039                              int line, const char *start_fn)
1040 {
1041 #if !defined(LOW_MEMORY)
1042         struct thr_arg *a;
1043 #endif
1044
1045         if (!attr) {
1046                 attr = ast_alloca(sizeof(*attr));
1047                 pthread_attr_init(attr);
1048         }
1049
1050 #ifdef __linux__
1051         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
1052            which is kind of useless. Change this here to
1053            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
1054            priority will propagate down to new threads by default.
1055            This does mean that callers cannot set a different priority using
1056            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
1057            the priority afterwards with pthread_setschedparam(). */
1058         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
1059                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
1060 #endif
1061
1062         if (!stacksize)
1063                 stacksize = AST_STACKSIZE;
1064
1065         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
1066                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
1067
1068 #if !defined(LOW_MEMORY)
1069         if ((a = ast_malloc(sizeof(*a)))) {
1070                 a->start_routine = start_routine;
1071                 a->data = data;
1072                 start_routine = dummy_start;
1073                 if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()",
1074                              start_fn, line, file, caller) < 0) {
1075                         a->name = NULL;
1076                 }
1077                 data = a;
1078         }
1079 #endif /* !LOW_MEMORY */
1080
1081         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
1082 }
1083
1084
1085 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1086                              void *data, size_t stacksize, const char *file, const char *caller,
1087                              int line, const char *start_fn)
1088 {
1089         unsigned char attr_destroy = 0;
1090         int res;
1091
1092         if (!attr) {
1093                 attr = ast_alloca(sizeof(*attr));
1094                 pthread_attr_init(attr);
1095                 attr_destroy = 1;
1096         }
1097
1098         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
1099                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
1100
1101         res = ast_pthread_create_stack(thread, attr, start_routine, data,
1102                                        stacksize, file, caller, line, start_fn);
1103
1104         if (attr_destroy)
1105                 pthread_attr_destroy(attr);
1106
1107         return res;
1108 }
1109
1110 int ast_wait_for_input(int fd, int ms)
1111 {
1112         struct pollfd pfd[1];
1113         memset(pfd, 0, sizeof(pfd));
1114         pfd[0].fd = fd;
1115         pfd[0].events = POLLIN|POLLPRI;
1116         return ast_poll(pfd, 1, ms);
1117 }
1118
1119 static int ast_wait_for_output(int fd, int timeoutms)
1120 {
1121         struct pollfd pfd = {
1122                 .fd = fd,
1123                 .events = POLLOUT,
1124         };
1125         int res;
1126         struct timeval start = ast_tvnow();
1127         int elapsed = 0;
1128
1129         /* poll() until the fd is writable without blocking */
1130         while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
1131                 if (res == 0) {
1132                         /* timed out. */
1133 #ifndef STANDALONE
1134                         ast_debug(1, "Timed out trying to write\n");
1135 #endif
1136                         return -1;
1137                 } else if (res == -1) {
1138                         /* poll() returned an error, check to see if it was fatal */
1139
1140                         if (errno == EINTR || errno == EAGAIN) {
1141                                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1142                                 if (elapsed >= timeoutms) {
1143                                         return -1;
1144                                 }
1145                                 /* This was an acceptable error, go back into poll() */
1146                                 continue;
1147                         }
1148
1149                         /* Fatal error, bail. */
1150                         ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
1151
1152                         return -1;
1153                 }
1154                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1155                 if (elapsed >= timeoutms) {
1156                         return -1;
1157                 }
1158         }
1159
1160         return 0;
1161 }
1162
1163 /*!
1164  * Try to write string, but wait no more than ms milliseconds before timing out.
1165  *
1166  * \note The code assumes that the file descriptor has NONBLOCK set,
1167  * so there is only one system call made to do a write, unless we actually
1168  * have a need to wait.  This way, we get better performance.
1169  * If the descriptor is blocking, all assumptions on the guaranteed
1170  * detail do not apply anymore.
1171  */
1172 int ast_carefulwrite(int fd, char *s, int len, int timeoutms)
1173 {
1174         struct timeval start = ast_tvnow();
1175         int res = 0;
1176         int elapsed = 0;
1177
1178         while (len) {
1179                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1180                         return -1;
1181                 }
1182
1183                 res = write(fd, s, len);
1184
1185                 if (res < 0 && errno != EAGAIN && errno != EINTR) {
1186                         /* fatal error from write() */
1187                         ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
1188                         return -1;
1189                 }
1190
1191                 if (res < 0) {
1192                         /* It was an acceptable error */
1193                         res = 0;
1194                 }
1195
1196                 /* Update how much data we have left to write */
1197                 len -= res;
1198                 s += res;
1199                 res = 0;
1200
1201                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1202                 if (elapsed >= timeoutms) {
1203                         /* We've taken too long to write
1204                          * This is only an error condition if we haven't finished writing. */
1205                         res = len ? -1 : 0;
1206                         break;
1207                 }
1208         }
1209
1210         return res;
1211 }
1212
1213 int ast_careful_fwrite(FILE *f, int fd, const char *src, size_t len, int timeoutms)
1214 {
1215         struct timeval start = ast_tvnow();
1216         int n = 0;
1217         int elapsed = 0;
1218
1219         while (len) {
1220                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1221                         /* poll returned a fatal error, so bail out immediately. */
1222                         return -1;
1223                 }
1224
1225                 /* Clear any errors from a previous write */
1226                 clearerr(f);
1227
1228                 n = fwrite(src, 1, len, f);
1229
1230                 if (ferror(f) && errno != EINTR && errno != EAGAIN) {
1231                         /* fatal error from fwrite() */
1232                         if (!feof(f)) {
1233                                 /* Don't spam the logs if it was just that the connection is closed. */
1234                                 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
1235                         }
1236                         n = -1;
1237                         break;
1238                 }
1239
1240                 /* Update for data already written to the socket */
1241                 len -= n;
1242                 src += n;
1243
1244                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1245                 if (elapsed >= timeoutms) {
1246                         /* We've taken too long to write
1247                          * This is only an error condition if we haven't finished writing. */
1248                         n = len ? -1 : 0;
1249                         break;
1250                 }
1251         }
1252
1253         while (fflush(f)) {
1254                 if (errno == EAGAIN || errno == EINTR) {
1255                         continue;
1256                 }
1257                 if (!feof(f)) {
1258                         /* Don't spam the logs if it was just that the connection is closed. */
1259                         ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
1260                 }
1261                 n = -1;
1262                 break;
1263         }
1264
1265         return n < 0 ? -1 : 0;
1266 }
1267
1268 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1269 {
1270         char *e;
1271         char *q;
1272
1273         s = ast_strip(s);
1274         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1275                 e = s + strlen(s) - 1;
1276                 if (*e == *(end_quotes + (q - beg_quotes))) {
1277                         s++;
1278                         *e = '\0';
1279                 }
1280         }
1281
1282         return s;
1283 }
1284
1285 char *ast_unescape_semicolon(char *s)
1286 {
1287         char *e;
1288         char *work = s;
1289
1290         while ((e = strchr(work, ';'))) {
1291                 if ((e > work) && (*(e-1) == '\\')) {
1292                         memmove(e - 1, e, strlen(e) + 1);
1293                         work = e;
1294                 } else {
1295                         work = e + 1;
1296                 }
1297         }
1298
1299         return s;
1300 }
1301
1302 /* !\brief unescape some C sequences in place, return pointer to the original string.
1303  */
1304 char *ast_unescape_c(char *src)
1305 {
1306         char c, *ret, *dst;
1307
1308         if (src == NULL)
1309                 return NULL;
1310         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1311                 if (c != '\\')
1312                         continue;       /* copy char at the end of the loop */
1313                 switch ((c = *src++)) {
1314                 case '\0':      /* special, trailing '\' */
1315                         c = '\\';
1316                         break;
1317                 case 'b':       /* backspace */
1318                         c = '\b';
1319                         break;
1320                 case 'f':       /* form feed */
1321                         c = '\f';
1322                         break;
1323                 case 'n':
1324                         c = '\n';
1325                         break;
1326                 case 'r':
1327                         c = '\r';
1328                         break;
1329                 case 't':
1330                         c = '\t';
1331                         break;
1332                 }
1333                 /* default, use the char literally */
1334         }
1335         *dst = '\0';
1336         return ret;
1337 }
1338
1339 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1340 {
1341         int result;
1342
1343         if (!buffer || !*buffer || !space || !*space)
1344                 return -1;
1345
1346         result = vsnprintf(*buffer, *space, fmt, ap);
1347
1348         if (result < 0)
1349                 return -1;
1350         else if (result > *space)
1351                 result = *space;
1352
1353         *buffer += result;
1354         *space -= result;
1355         return 0;
1356 }
1357
1358 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1359 {
1360         va_list ap;
1361         int result;
1362
1363         va_start(ap, fmt);
1364         result = ast_build_string_va(buffer, space, fmt, ap);
1365         va_end(ap);
1366
1367         return result;
1368 }
1369
1370 int ast_regex_string_to_regex_pattern(const char *regex_string, struct ast_str **regex_pattern)
1371 {
1372         int regex_len = strlen(regex_string);
1373         int ret = 3;
1374
1375         /* Chop off the leading / if there is one */
1376         if ((regex_len >= 1) && (regex_string[0] == '/')) {
1377                 ast_str_set(regex_pattern, 0, "%s", regex_string + 1);
1378                 ret -= 2;
1379         }
1380
1381         /* Chop off the ending / if there is one */
1382         if ((regex_len > 1) && (regex_string[regex_len - 1] == '/')) {
1383                 ast_str_truncate(*regex_pattern, -1);
1384                 ret -= 1;
1385         }
1386
1387         return ret;
1388 }
1389
1390 int ast_true(const char *s)
1391 {
1392         if (ast_strlen_zero(s))
1393                 return 0;
1394
1395         /* Determine if this is a true value */
1396         if (!strcasecmp(s, "yes") ||
1397             !strcasecmp(s, "true") ||
1398             !strcasecmp(s, "y") ||
1399             !strcasecmp(s, "t") ||
1400             !strcasecmp(s, "1") ||
1401             !strcasecmp(s, "on"))
1402                 return -1;
1403
1404         return 0;
1405 }
1406
1407 int ast_false(const char *s)
1408 {
1409         if (ast_strlen_zero(s))
1410                 return 0;
1411
1412         /* Determine if this is a false value */
1413         if (!strcasecmp(s, "no") ||
1414             !strcasecmp(s, "false") ||
1415             !strcasecmp(s, "n") ||
1416             !strcasecmp(s, "f") ||
1417             !strcasecmp(s, "0") ||
1418             !strcasecmp(s, "off"))
1419                 return -1;
1420
1421         return 0;
1422 }
1423
1424 #define ONE_MILLION     1000000
1425 /*
1426  * put timeval in a valid range. usec is 0..999999
1427  * negative values are not allowed and truncated.
1428  */
1429 static struct timeval tvfix(struct timeval a)
1430 {
1431         if (a.tv_usec >= ONE_MILLION) {
1432                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1433                         (long)a.tv_sec, (long int) a.tv_usec);
1434                 a.tv_sec += a.tv_usec / ONE_MILLION;
1435                 a.tv_usec %= ONE_MILLION;
1436         } else if (a.tv_usec < 0) {
1437                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1438                         (long)a.tv_sec, (long int) a.tv_usec);
1439                 a.tv_usec = 0;
1440         }
1441         return a;
1442 }
1443
1444 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1445 {
1446         /* consistency checks to guarantee usec in 0..999999 */
1447         a = tvfix(a);
1448         b = tvfix(b);
1449         a.tv_sec += b.tv_sec;
1450         a.tv_usec += b.tv_usec;
1451         if (a.tv_usec >= ONE_MILLION) {
1452                 a.tv_sec++;
1453                 a.tv_usec -= ONE_MILLION;
1454         }
1455         return a;
1456 }
1457
1458 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1459 {
1460         /* consistency checks to guarantee usec in 0..999999 */
1461         a = tvfix(a);
1462         b = tvfix(b);
1463         a.tv_sec -= b.tv_sec;
1464         a.tv_usec -= b.tv_usec;
1465         if (a.tv_usec < 0) {
1466                 a.tv_sec-- ;
1467                 a.tv_usec += ONE_MILLION;
1468         }
1469         return a;
1470 }
1471
1472 int ast_remaining_ms(struct timeval start, int max_ms)
1473 {
1474         int ms;
1475
1476         if (max_ms < 0) {
1477                 ms = max_ms;
1478         } else {
1479                 ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start);
1480                 if (ms < 0) {
1481                         ms = 0;
1482                 }
1483         }
1484
1485         return ms;
1486 }
1487
1488 #undef ONE_MILLION
1489
1490 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1491  * BSD libc (and others) do not. */
1492
1493 #ifndef linux
1494 AST_MUTEX_DEFINE_STATIC(randomlock);
1495 #endif
1496
1497 long int ast_random(void)
1498 {
1499         long int res;
1500 #ifdef HAVE_DEV_URANDOM
1501         if (dev_urandom_fd >= 0) {
1502                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1503                 if (read_res > 0) {
1504                         long int rm = RAND_MAX;
1505                         res = res < 0 ? ~res : res;
1506                         rm++;
1507                         return res % rm;
1508                 }
1509         }
1510 #endif
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 #ifdef HAVE_DEV_URANDOM
2035         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
2036 #endif
2037         base64_init();
2038 #ifdef DEBUG_THREADS
2039 #if !defined(LOW_MEMORY)
2040         ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
2041 #endif
2042 #endif
2043         return 0;
2044 }
2045
2046
2047 /*!
2048  *\brief Parse digest authorization header.
2049  *\return Returns -1 if we have no auth or something wrong with digest.
2050  *\note This function may be used for Digest request and responce header.
2051  * request arg is set to nonzero, if we parse Digest Request.
2052  * pedantic arg can be set to nonzero if we need to do addition Digest check.
2053  */
2054 int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic) {
2055         char *c;
2056         struct ast_str *str = ast_str_create(16);
2057
2058         /* table of recognised keywords, and places where they should be copied */
2059         const struct x {
2060                 const char *key;
2061                 const ast_string_field *field;
2062         } *i, keys[] = {
2063                 { "username=", &d->username },
2064                 { "realm=", &d->realm },
2065                 { "nonce=", &d->nonce },
2066                 { "uri=", &d->uri },
2067                 { "domain=", &d->domain },
2068                 { "response=", &d->response },
2069                 { "cnonce=", &d->cnonce },
2070                 { "opaque=", &d->opaque },
2071                 /* Special cases that cannot be directly copied */
2072                 { "algorithm=", NULL },
2073                 { "qop=", NULL },
2074                 { "nc=", NULL },
2075                 { NULL, 0 },
2076         };
2077
2078         if (ast_strlen_zero(digest) || !d || !str) {
2079                 ast_free(str);
2080                 return -1;
2081         }
2082
2083         ast_str_set(&str, 0, "%s", digest);
2084
2085         c = ast_skip_blanks(ast_str_buffer(str));
2086
2087         if (strncasecmp(c, "Digest ", strlen("Digest "))) {
2088                 ast_log(LOG_WARNING, "Missing Digest.\n");
2089                 ast_free(str);
2090                 return -1;
2091         }
2092         c += strlen("Digest ");
2093
2094         /* lookup for keys/value pair */
2095         while (c && *c && *(c = ast_skip_blanks(c))) {
2096                 /* find key */
2097                 for (i = keys; i->key != NULL; i++) {
2098                         char *src, *separator;
2099                         int unescape = 0;
2100                         if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
2101                                 continue;
2102                         }
2103
2104                         /* Found. Skip keyword, take text in quotes or up to the separator. */
2105                         c += strlen(i->key);
2106                         if (*c == '"') {
2107                                 src = ++c;
2108                                 separator = "\"";
2109                                 unescape = 1;
2110                         } else {
2111                                 src = c;
2112                                 separator = ",";
2113                         }
2114                         strsep(&c, separator); /* clear separator and move ptr */
2115                         if (unescape) {
2116                                 ast_unescape_c(src);
2117                         }
2118                         if (i->field) {
2119                                 ast_string_field_ptr_set(d, i->field, src);
2120                         } else {
2121                                 /* Special cases that require additional procesing */
2122                                 if (!strcasecmp(i->key, "algorithm=")) {
2123                                         if (strcasecmp(src, "MD5")) {
2124                                                 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
2125                                                 ast_free(str);
2126                                                 return -1;
2127                                         }
2128                                 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
2129                                         d->qop = 1;
2130                                 } else if (!strcasecmp(i->key, "nc=")) {
2131                                         unsigned long u;
2132                                         if (sscanf(src, "%30lx", &u) != 1) {
2133                                                 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
2134                                                 ast_free(str);
2135                                                 return -1;
2136                                         }
2137                                         ast_string_field_set(d, nc, src);
2138                                 }
2139                         }
2140                         break;
2141                 }
2142                 if (i->key == NULL) { /* not found, try ',' */
2143                         strsep(&c, ",");
2144                 }
2145         }
2146         ast_free(str);
2147
2148         /* Digest checkout */
2149         if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
2150                 /* "realm" and "nonce" MUST be always exist */
2151                 return -1;
2152         }
2153
2154         if (!request) {
2155                 /* Additional check for Digest response */
2156                 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
2157                         return -1;
2158                 }
2159
2160                 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
2161                         return -1;
2162                 }
2163         }
2164
2165         return 0;
2166 }
2167
2168 #ifndef __AST_DEBUG_MALLOC
2169 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...)
2170 {
2171         int res;
2172         va_list ap;
2173
2174         va_start(ap, fmt);
2175         if ((res = vasprintf(ret, fmt, ap)) == -1) {
2176                 MALLOC_FAILURE_MSG;
2177         }
2178         va_end(ap);
2179
2180         return res;
2181 }
2182 #endif
2183
2184 int ast_get_tid(void)
2185 {
2186         int ret = -1;
2187 #if defined (__linux) && defined(SYS_gettid)
2188         ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */
2189 #elif defined(__sun)
2190         ret = pthread_self();
2191 #elif defined(__APPLE__)
2192         ret = mach_thread_self();
2193         mach_port_deallocate(mach_task_self(), ret);
2194 #elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H)
2195         long lwpid;
2196         thr_self(&lwpid); /* available since sys/thr.h creation 2003 */
2197         ret = lwpid;
2198 #endif
2199         return ret;
2200 }
2201
2202 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size)
2203 {
2204         const char *envPATH = getenv("PATH");
2205         char *tpath, *path;
2206         struct stat unused;
2207         if (!envPATH) {
2208                 return NULL;
2209         }
2210         tpath = ast_strdupa(envPATH);
2211         while ((path = strsep(&tpath, ":"))) {
2212                 snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
2213                 if (!stat(fullpath, &unused)) {
2214                         return fullpath;
2215                 }
2216         }
2217         return NULL;
2218 }
2219
2220 void ast_do_crash(void)
2221 {
2222 #if defined(DO_CRASH)
2223         abort();
2224         /*
2225          * Just in case abort() doesn't work or something else super
2226          * silly, and for Qwell's amusement.
2227          */
2228         *((int *) 0) = 0;
2229 #endif  /* defined(DO_CRASH) */
2230 }
2231
2232 #if defined(AST_DEVMODE)
2233 void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function)
2234 {
2235         /*
2236          * Attempt to put it into the logger, but hope that at least
2237          * someone saw the message on stderr ...
2238          */
2239         ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
2240                 condition_str, condition);
2241         fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
2242                 condition_str, condition, line, function, file);
2243         /*
2244          * Give the logger a chance to get the message out, just in case
2245          * we abort(), or Asterisk crashes due to whatever problem just
2246          * happened after we exit ast_assert().
2247          */
2248         usleep(1);
2249         ast_do_crash();
2250 }
2251 #endif  /* defined(AST_DEVMODE) */