Multiple revisions 369001-369002
[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
792         if (!bt) {
793                 ast_str_append(str, 0, "\tNo backtrace to print\n");
794                 return;
795         }
796
797         if ((symbols = ast_bt_get_symbols(bt->addresses, bt->num_frames))) {
798                 int frame_iterator;
799
800                 for (frame_iterator = 0; frame_iterator < bt->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 #endif
999
1000         /* note that even though data->name is a pointer to allocated memory,
1001            we are not freeing it here because ast_register_thread is going to
1002            keep a copy of the pointer and then ast_unregister_thread will
1003            free the memory
1004         */
1005         ast_free(data);
1006         ast_register_thread(a.name);
1007         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
1008
1009 #ifdef DEBUG_THREADS
1010         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
1011                 return NULL;
1012
1013         lock_info->thread_id = pthread_self();
1014         lock_info->thread_name = strdup(a.name);
1015
1016         pthread_mutexattr_init(&mutex_attr);
1017         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
1018         pthread_mutex_init(&lock_info->lock, &mutex_attr);
1019         pthread_mutexattr_destroy(&mutex_attr);
1020
1021         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1022         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
1023         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1024 #endif /* DEBUG_THREADS */
1025
1026         ret = a.start_routine(a.data);
1027
1028         pthread_cleanup_pop(1);
1029
1030         return ret;
1031 }
1032
1033 #endif /* !LOW_MEMORY */
1034
1035 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1036                              void *data, size_t stacksize, const char *file, const char *caller,
1037                              int line, const char *start_fn)
1038 {
1039 #if !defined(LOW_MEMORY)
1040         struct thr_arg *a;
1041 #endif
1042
1043         if (!attr) {
1044                 attr = alloca(sizeof(*attr));
1045                 pthread_attr_init(attr);
1046         }
1047
1048 #ifdef __linux__
1049         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
1050            which is kind of useless. Change this here to
1051            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
1052            priority will propagate down to new threads by default.
1053            This does mean that callers cannot set a different priority using
1054            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
1055            the priority afterwards with pthread_setschedparam(). */
1056         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
1057                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
1058 #endif
1059
1060         if (!stacksize)
1061                 stacksize = AST_STACKSIZE;
1062
1063         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
1064                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
1065
1066 #if !defined(LOW_MEMORY)
1067         if ((a = ast_malloc(sizeof(*a)))) {
1068                 a->start_routine = start_routine;
1069                 a->data = data;
1070                 start_routine = dummy_start;
1071                 if (asprintf(&a->name, "%-20s started at [%5d] %s %s()",
1072                              start_fn, line, file, caller) < 0) {
1073                         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
1074                         a->name = NULL;
1075                 }
1076                 data = a;
1077         }
1078 #endif /* !LOW_MEMORY */
1079
1080         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
1081 }
1082
1083
1084 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1085                              void *data, size_t stacksize, const char *file, const char *caller,
1086                              int line, const char *start_fn)
1087 {
1088         unsigned char attr_destroy = 0;
1089         int res;
1090
1091         if (!attr) {
1092                 attr = alloca(sizeof(*attr));
1093                 pthread_attr_init(attr);
1094                 attr_destroy = 1;
1095         }
1096
1097         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
1098                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
1099
1100         res = ast_pthread_create_stack(thread, attr, start_routine, data,
1101                                        stacksize, file, caller, line, start_fn);
1102
1103         if (attr_destroy)
1104                 pthread_attr_destroy(attr);
1105
1106         return res;
1107 }
1108
1109 int ast_wait_for_input(int fd, int ms)
1110 {
1111         struct pollfd pfd[1];
1112         memset(pfd, 0, sizeof(pfd));
1113         pfd[0].fd = fd;
1114         pfd[0].events = POLLIN|POLLPRI;
1115         return ast_poll(pfd, 1, ms);
1116 }
1117
1118 static int ast_wait_for_output(int fd, int timeoutms)
1119 {
1120         struct pollfd pfd = {
1121                 .fd = fd,
1122                 .events = POLLOUT,
1123         };
1124         int res;
1125         struct timeval start = ast_tvnow();
1126         int elapsed = 0;
1127
1128         /* poll() until the fd is writable without blocking */
1129         while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
1130                 if (res == 0) {
1131                         /* timed out. */
1132 #ifndef STANDALONE
1133                         ast_debug(1, "Timed out trying to write\n");
1134 #endif
1135                         return -1;
1136                 } else if (res == -1) {
1137                         /* poll() returned an error, check to see if it was fatal */
1138
1139                         if (errno == EINTR || errno == EAGAIN) {
1140                                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1141                                 if (elapsed >= timeoutms) {
1142                                         return -1;
1143                                 }
1144                                 /* This was an acceptable error, go back into poll() */
1145                                 continue;
1146                         }
1147
1148                         /* Fatal error, bail. */
1149                         ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
1150
1151                         return -1;
1152                 }
1153                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1154                 if (elapsed >= timeoutms) {
1155                         return -1;
1156                 }
1157         }
1158
1159         return 0;
1160 }
1161
1162 /*!
1163  * Try to write string, but wait no more than ms milliseconds before timing out.
1164  *
1165  * \note The code assumes that the file descriptor has NONBLOCK set,
1166  * so there is only one system call made to do a write, unless we actually
1167  * have a need to wait.  This way, we get better performance.
1168  * If the descriptor is blocking, all assumptions on the guaranteed
1169  * detail do not apply anymore.
1170  */
1171 int ast_carefulwrite(int fd, char *s, int len, int timeoutms)
1172 {
1173         struct timeval start = ast_tvnow();
1174         int res = 0;
1175         int elapsed = 0;
1176
1177         while (len) {
1178                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1179                         return -1;
1180                 }
1181
1182                 res = write(fd, s, len);
1183
1184                 if (res < 0 && errno != EAGAIN && errno != EINTR) {
1185                         /* fatal error from write() */
1186                         ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
1187                         return -1;
1188                 }
1189
1190                 if (res < 0) {
1191                         /* It was an acceptable error */
1192                         res = 0;
1193                 }
1194
1195                 /* Update how much data we have left to write */
1196                 len -= res;
1197                 s += res;
1198                 res = 0;
1199
1200                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1201                 if (elapsed >= timeoutms) {
1202                         /* We've taken too long to write
1203                          * This is only an error condition if we haven't finished writing. */
1204                         res = len ? -1 : 0;
1205                         break;
1206                 }
1207         }
1208
1209         return res;
1210 }
1211
1212 int ast_careful_fwrite(FILE *f, int fd, const char *src, size_t len, int timeoutms)
1213 {
1214         struct timeval start = ast_tvnow();
1215         int n = 0;
1216         int elapsed = 0;
1217
1218         while (len) {
1219                 if (ast_wait_for_output(fd, timeoutms - elapsed)) {
1220                         /* poll returned a fatal error, so bail out immediately. */
1221                         return -1;
1222                 }
1223
1224                 /* Clear any errors from a previous write */
1225                 clearerr(f);
1226
1227                 n = fwrite(src, 1, len, f);
1228
1229                 if (ferror(f) && errno != EINTR && errno != EAGAIN) {
1230                         /* fatal error from fwrite() */
1231                         if (!feof(f)) {
1232                                 /* Don't spam the logs if it was just that the connection is closed. */
1233                                 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
1234                         }
1235                         n = -1;
1236                         break;
1237                 }
1238
1239                 /* Update for data already written to the socket */
1240                 len -= n;
1241                 src += n;
1242
1243                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1244                 if (elapsed >= timeoutms) {
1245                         /* We've taken too long to write
1246                          * This is only an error condition if we haven't finished writing. */
1247                         n = len ? -1 : 0;
1248                         break;
1249                 }
1250         }
1251
1252         while (fflush(f)) {
1253                 if (errno == EAGAIN || errno == EINTR) {
1254                         continue;
1255                 }
1256                 if (!feof(f)) {
1257                         /* Don't spam the logs if it was just that the connection is closed. */
1258                         ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
1259                 }
1260                 n = -1;
1261                 break;
1262         }
1263
1264         return n < 0 ? -1 : 0;
1265 }
1266
1267 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1268 {
1269         char *e;
1270         char *q;
1271
1272         s = ast_strip(s);
1273         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1274                 e = s + strlen(s) - 1;
1275                 if (*e == *(end_quotes + (q - beg_quotes))) {
1276                         s++;
1277                         *e = '\0';
1278                 }
1279         }
1280
1281         return s;
1282 }
1283
1284 char *ast_unescape_semicolon(char *s)
1285 {
1286         char *e;
1287         char *work = s;
1288
1289         while ((e = strchr(work, ';'))) {
1290                 if ((e > work) && (*(e-1) == '\\')) {
1291                         memmove(e - 1, e, strlen(e) + 1);
1292                         work = e;
1293                 } else {
1294                         work = e + 1;
1295                 }
1296         }
1297
1298         return s;
1299 }
1300
1301 /* !\brief unescape some C sequences in place, return pointer to the original string.
1302  */
1303 char *ast_unescape_c(char *src)
1304 {
1305         char c, *ret, *dst;
1306
1307         if (src == NULL)
1308                 return NULL;
1309         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1310                 if (c != '\\')
1311                         continue;       /* copy char at the end of the loop */
1312                 switch ((c = *src++)) {
1313                 case '\0':      /* special, trailing '\' */
1314                         c = '\\';
1315                         break;
1316                 case 'b':       /* backspace */
1317                         c = '\b';
1318                         break;
1319                 case 'f':       /* form feed */
1320                         c = '\f';
1321                         break;
1322                 case 'n':
1323                         c = '\n';
1324                         break;
1325                 case 'r':
1326                         c = '\r';
1327                         break;
1328                 case 't':
1329                         c = '\t';
1330                         break;
1331                 }
1332                 /* default, use the char literally */
1333         }
1334         *dst = '\0';
1335         return ret;
1336 }
1337
1338 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1339 {
1340         int result;
1341
1342         if (!buffer || !*buffer || !space || !*space)
1343                 return -1;
1344
1345         result = vsnprintf(*buffer, *space, fmt, ap);
1346
1347         if (result < 0)
1348                 return -1;
1349         else if (result > *space)
1350                 result = *space;
1351
1352         *buffer += result;
1353         *space -= result;
1354         return 0;
1355 }
1356
1357 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1358 {
1359         va_list ap;
1360         int result;
1361
1362         va_start(ap, fmt);
1363         result = ast_build_string_va(buffer, space, fmt, ap);
1364         va_end(ap);
1365
1366         return result;
1367 }
1368
1369 int ast_regex_string_to_regex_pattern(const char *regex_string, struct ast_str **regex_pattern)
1370 {
1371         int regex_len = strlen(regex_string);
1372         int ret = 3;
1373
1374         /* Chop off the leading / if there is one */
1375         if ((regex_len >= 1) && (regex_string[0] == '/')) {
1376                 ast_str_set(regex_pattern, 0, "%s", regex_string + 1);
1377                 ret -= 2;
1378         }
1379
1380         /* Chop off the ending / if there is one */
1381         if ((regex_len > 1) && (regex_string[regex_len - 1] == '/')) {
1382                 ast_str_truncate(*regex_pattern, -1);
1383                 ret -= 1;
1384         }
1385
1386         return ret;
1387 }
1388
1389 int ast_true(const char *s)
1390 {
1391         if (ast_strlen_zero(s))
1392                 return 0;
1393
1394         /* Determine if this is a true value */
1395         if (!strcasecmp(s, "yes") ||
1396             !strcasecmp(s, "true") ||
1397             !strcasecmp(s, "y") ||
1398             !strcasecmp(s, "t") ||
1399             !strcasecmp(s, "1") ||
1400             !strcasecmp(s, "on"))
1401                 return -1;
1402
1403         return 0;
1404 }
1405
1406 int ast_false(const char *s)
1407 {
1408         if (ast_strlen_zero(s))
1409                 return 0;
1410
1411         /* Determine if this is a false value */
1412         if (!strcasecmp(s, "no") ||
1413             !strcasecmp(s, "false") ||
1414             !strcasecmp(s, "n") ||
1415             !strcasecmp(s, "f") ||
1416             !strcasecmp(s, "0") ||
1417             !strcasecmp(s, "off"))
1418                 return -1;
1419
1420         return 0;
1421 }
1422
1423 #define ONE_MILLION     1000000
1424 /*
1425  * put timeval in a valid range. usec is 0..999999
1426  * negative values are not allowed and truncated.
1427  */
1428 static struct timeval tvfix(struct timeval a)
1429 {
1430         if (a.tv_usec >= ONE_MILLION) {
1431                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1432                         (long)a.tv_sec, (long int) a.tv_usec);
1433                 a.tv_sec += a.tv_usec / ONE_MILLION;
1434                 a.tv_usec %= ONE_MILLION;
1435         } else if (a.tv_usec < 0) {
1436                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1437                         (long)a.tv_sec, (long int) a.tv_usec);
1438                 a.tv_usec = 0;
1439         }
1440         return a;
1441 }
1442
1443 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1444 {
1445         /* consistency checks to guarantee usec in 0..999999 */
1446         a = tvfix(a);
1447         b = tvfix(b);
1448         a.tv_sec += b.tv_sec;
1449         a.tv_usec += b.tv_usec;
1450         if (a.tv_usec >= ONE_MILLION) {
1451                 a.tv_sec++;
1452                 a.tv_usec -= ONE_MILLION;
1453         }
1454         return a;
1455 }
1456
1457 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1458 {
1459         /* consistency checks to guarantee usec in 0..999999 */
1460         a = tvfix(a);
1461         b = tvfix(b);
1462         a.tv_sec -= b.tv_sec;
1463         a.tv_usec -= b.tv_usec;
1464         if (a.tv_usec < 0) {
1465                 a.tv_sec-- ;
1466                 a.tv_usec += ONE_MILLION;
1467         }
1468         return a;
1469 }
1470 #undef ONE_MILLION
1471
1472 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1473  * BSD libc (and others) do not. */
1474
1475 #ifndef linux
1476 AST_MUTEX_DEFINE_STATIC(randomlock);
1477 #endif
1478
1479 long int ast_random(void)
1480 {
1481         long int res;
1482 #ifdef HAVE_DEV_URANDOM
1483         if (dev_urandom_fd >= 0) {
1484                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1485                 if (read_res > 0) {
1486                         long int rm = RAND_MAX;
1487                         res = res < 0 ? ~res : res;
1488                         rm++;
1489                         return res % rm;
1490                 }
1491         }
1492 #endif
1493 #ifdef linux
1494         res = random();
1495 #else
1496         ast_mutex_lock(&randomlock);
1497         res = random();
1498         ast_mutex_unlock(&randomlock);
1499 #endif
1500         return res;
1501 }
1502
1503 void ast_replace_subargument_delimiter(char *s)
1504 {
1505         for (; *s; s++) {
1506                 if (*s == '^') {
1507                         *s = ',';
1508                 }
1509         }
1510 }
1511
1512 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1513 {
1514         char *dataPut = start;
1515         int inEscape = 0;
1516         int inQuotes = 0;
1517
1518         for (; *start; start++) {
1519                 if (inEscape) {
1520                         *dataPut++ = *start;       /* Always goes verbatim */
1521                         inEscape = 0;
1522                 } else {
1523                         if (*start == '\\') {
1524                                 inEscape = 1;      /* Do not copy \ into the data */
1525                         } else if (*start == '\'') {
1526                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1527                         } else {
1528                                 /* Replace , with |, unless in quotes */
1529                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1530                         }
1531                 }
1532         }
1533         if (start != dataPut)
1534                 *dataPut = 0;
1535         return dataPut;
1536 }
1537
1538 void ast_join(char *s, size_t len, const char * const w[])
1539 {
1540         int x, ofs = 0;
1541         const char *src;
1542
1543         /* Join words into a string */
1544         if (!s)
1545                 return;
1546         for (x = 0; ofs < len && w[x]; x++) {
1547                 if (x > 0)
1548                         s[ofs++] = ' ';
1549                 for (src = w[x]; *src && ofs < len; src++)
1550                         s[ofs++] = *src;
1551         }
1552         if (ofs == len)
1553                 ofs--;
1554         s[ofs] = '\0';
1555 }
1556
1557 /*
1558  * stringfields support routines.
1559  */
1560
1561 /* this is a little complex... string fields are stored with their
1562    allocated size in the bytes preceding the string; even the
1563    constant 'empty' string has to be this way, so the code that
1564    checks to see if there is enough room for a new string doesn't
1565    have to have any special case checks
1566 */
1567
1568 static const struct {
1569         ast_string_field_allocation allocation;
1570         char string[1];
1571 } __ast_string_field_empty_buffer;
1572
1573 ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string;
1574
1575 #define ALLOCATOR_OVERHEAD 48
1576
1577 static size_t optimal_alloc_size(size_t size)
1578 {
1579         unsigned int count;
1580
1581         size += ALLOCATOR_OVERHEAD;
1582
1583         for (count = 1; size; size >>= 1, count++);
1584
1585         return (1 << count) - ALLOCATOR_OVERHEAD;
1586 }
1587
1588 /*! \brief add a new block to the pool.
1589  * We can only allocate from the topmost pool, so the
1590  * fields in *mgr reflect the size of that only.
1591  */
1592 static int add_string_pool(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1593                            size_t size, const char *file, int lineno, const char *func)
1594 {
1595         struct ast_string_field_pool *pool;
1596         size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);
1597
1598 #if defined(__AST_DEBUG_MALLOC)
1599         if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) {
1600                 return -1;
1601         }
1602 #else
1603         if (!(pool = ast_calloc(1, alloc_size))) {
1604                 return -1;
1605         }
1606 #endif
1607
1608         pool->prev = *pool_head;
1609         pool->size = alloc_size - sizeof(*pool);
1610         *pool_head = pool;
1611         mgr->last_alloc = NULL;
1612
1613         return 0;
1614 }
1615
1616 /*
1617  * This is an internal API, code should not use it directly.
1618  * It initializes all fields as empty, then uses 'size' for 3 functions:
1619  * size > 0 means initialize the pool list with a pool of given size.
1620  *      This must be called right after allocating the object.
1621  * size = 0 means release all pools except the most recent one.
1622  *      If the first pool was allocated via embedding in another
1623  *      object, that pool will be preserved instead.
1624  *      This is useful to e.g. reset an object to the initial value.
1625  * size < 0 means release all pools.
1626  *      This must be done before destroying the object.
1627  */
1628 int __ast_string_field_init(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1629                             int needed, const char *file, int lineno, const char *func)
1630 {
1631         const char **p = (const char **) pool_head + 1;
1632         struct ast_string_field_pool *cur = NULL;
1633         struct ast_string_field_pool *preserve = NULL;
1634
1635         /* clear fields - this is always necessary */
1636         while ((struct ast_string_field_mgr *) p != mgr) {
1637                 *p++ = __ast_string_field_empty;
1638         }
1639
1640         mgr->last_alloc = NULL;
1641 #if defined(__AST_DEBUG_MALLOC)
1642         mgr->owner_file = file;
1643         mgr->owner_func = func;
1644         mgr->owner_line = lineno;
1645 #endif
1646         if (needed > 0) {               /* allocate the initial pool */
1647                 *pool_head = NULL;
1648                 mgr->embedded_pool = NULL;
1649                 return add_string_pool(mgr, pool_head, needed, file, lineno, func);
1650         }
1651
1652         /* if there is an embedded pool, we can't actually release *all*
1653          * pools, we must keep the embedded one. if the caller is about
1654          * to free the structure that contains the stringfield manager
1655          * and embedded pool anyway, it will be freed as part of that
1656          * operation.
1657          */
1658         if ((needed < 0) && mgr->embedded_pool) {
1659                 needed = 0;
1660         }
1661
1662         if (needed < 0) {               /* reset all pools */
1663                 cur = *pool_head;
1664         } else if (mgr->embedded_pool) { /* preserve the embedded pool */
1665                 preserve = mgr->embedded_pool;
1666                 cur = *pool_head;
1667         } else {                        /* preserve the last pool */
1668                 if (*pool_head == NULL) {
1669                         ast_log(LOG_WARNING, "trying to reset empty pool\n");
1670                         return -1;
1671                 }
1672                 preserve = *pool_head;
1673                 cur = preserve->prev;
1674         }
1675
1676         if (preserve) {
1677                 preserve->prev = NULL;
1678                 preserve->used = preserve->active = 0;
1679         }
1680
1681         while (cur) {
1682                 struct ast_string_field_pool *prev = cur->prev;
1683
1684                 if (cur != preserve) {
1685                         ast_free(cur);
1686                 }
1687                 cur = prev;
1688         }
1689
1690         *pool_head = preserve;
1691
1692         return 0;
1693 }
1694
1695 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr,
1696                                                 struct ast_string_field_pool **pool_head, size_t needed)
1697 {
1698         char *result = NULL;
1699         size_t space = (*pool_head)->size - (*pool_head)->used;
1700         size_t to_alloc;
1701
1702         /* Make room for ast_string_field_allocation and make it a multiple of that. */
1703         to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
1704         ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);
1705
1706         if (__builtin_expect(to_alloc > space, 0)) {
1707                 size_t new_size = (*pool_head)->size;
1708
1709                 while (new_size < to_alloc) {
1710                         new_size *= 2;
1711                 }
1712
1713 #if defined(__AST_DEBUG_MALLOC)
1714                 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
1715                         return NULL;
1716 #else
1717                 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__))
1718                         return NULL;
1719 #endif
1720         }
1721
1722         /* pool->base is always aligned (gcc aligned attribute). We ensure that
1723          * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
1724          * causing result to always be aligned as well; which in turn fixes that
1725          * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
1726         result = (*pool_head)->base + (*pool_head)->used;
1727         (*pool_head)->used += to_alloc;
1728         (*pool_head)->active += needed;
1729         result += ast_alignof(ast_string_field_allocation);
1730         AST_STRING_FIELD_ALLOCATION(result) = needed;
1731         mgr->last_alloc = result;
1732
1733         return result;
1734 }
1735
1736 int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr,
1737                                 struct ast_string_field_pool **pool_head, size_t needed,
1738                                 const ast_string_field *ptr)
1739 {
1740         ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
1741         size_t space = (*pool_head)->size - (*pool_head)->used;
1742
1743         if (*ptr != mgr->last_alloc) {
1744                 return 1;
1745         }
1746
1747         if (space < grow) {
1748                 return 1;
1749         }
1750
1751         (*pool_head)->used += grow;
1752         (*pool_head)->active += grow;
1753         AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
1754
1755         return 0;
1756 }
1757
1758 void __ast_string_field_release_active(struct ast_string_field_pool *pool_head,
1759                                        const ast_string_field ptr)
1760 {
1761         struct ast_string_field_pool *pool, *prev;
1762
1763         if (ptr == __ast_string_field_empty) {
1764                 return;
1765         }
1766
1767         for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
1768                 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
1769                         pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
1770                         if ((pool->active == 0) && prev) {
1771                                 prev->prev = pool->prev;
1772                                 ast_free(pool);
1773                         }
1774                         break;
1775                 }
1776         }
1777 }
1778
1779 void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
1780                                      struct ast_string_field_pool **pool_head,
1781                                      ast_string_field *ptr, const char *format, va_list ap)
1782 {
1783         size_t needed;
1784         size_t available;
1785         size_t space = (*pool_head)->size - (*pool_head)->used;
1786         ssize_t grow;
1787         char *target;
1788         va_list ap2;
1789
1790         /* if the field already has space allocated, try to reuse it;
1791            otherwise, try to use the empty space at the end of the current
1792            pool
1793         */
1794         if (*ptr != __ast_string_field_empty) {
1795                 target = (char *) *ptr;
1796                 available = AST_STRING_FIELD_ALLOCATION(*ptr);
1797                 if (*ptr == mgr->last_alloc) {
1798                         available += space;
1799                 }
1800         } else {
1801                 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
1802                  * so we don't need to re-align anything here.
1803                  */
1804                 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
1805                 available = space - ast_alignof(ast_string_field_allocation);
1806         }
1807
1808         va_copy(ap2, ap);
1809         needed = vsnprintf(target, available, format, ap2) + 1;
1810         va_end(ap2);
1811
1812         if (needed > available) {
1813                 /* the allocation could not be satisfied using the field's current allocation
1814                    (if it has one), or the space available in the pool (if it does not). allocate
1815                    space for it, adding a new string pool if necessary.
1816                 */
1817                 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {
1818                         return;
1819                 }
1820                 vsprintf(target, format, ap);
1821                 va_end(ap); /* XXX va_end without va_start? */
1822                 __ast_string_field_release_active(*pool_head, *ptr);
1823                 *ptr = target;
1824         } else if (*ptr != target) {
1825                 /* the allocation was satisfied using available space in the pool, but not
1826                    using the space already allocated to the field
1827                 */
1828                 __ast_string_field_release_active(*pool_head, *ptr);
1829                 mgr->last_alloc = *ptr = target;
1830                 AST_STRING_FIELD_ALLOCATION(target) = needed;
1831                 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
1832                 (*pool_head)->active += needed;
1833         } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
1834                 /* the allocation was satisfied by using available space in the pool *and*
1835                    the field was the last allocated field from the pool, so it grew
1836                 */
1837                 AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
1838                 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
1839                 (*pool_head)->active += grow;
1840         }
1841 }
1842
1843 void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
1844                                   struct ast_string_field_pool **pool_head,
1845                                   ast_string_field *ptr, const char *format, ...)
1846 {
1847         va_list ap;
1848
1849         va_start(ap, format);
1850         __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap);
1851         va_end(ap);
1852 }
1853
1854 void *__ast_calloc_with_stringfields(unsigned int num_structs, size_t struct_size, size_t field_mgr_offset,
1855                                      size_t field_mgr_pool_offset, size_t pool_size, const char *file,
1856                                      int lineno, const char *func)
1857 {
1858         struct ast_string_field_mgr *mgr;
1859         struct ast_string_field_pool *pool;
1860         struct ast_string_field_pool **pool_head;
1861         size_t pool_size_needed = sizeof(*pool) + pool_size;
1862         size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
1863         void *allocation;
1864         unsigned int x;
1865
1866 #if defined(__AST_DEBUG_MALLOC)
1867         if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) {
1868                 return NULL;
1869         }
1870 #else
1871         if (!(allocation = ast_calloc(num_structs, size_to_alloc))) {
1872                 return NULL;
1873         }
1874 #endif
1875
1876         for (x = 0; x < num_structs; x++) {
1877                 void *base = allocation + (size_to_alloc * x);
1878                 const char **p;
1879
1880                 mgr = base + field_mgr_offset;
1881                 pool_head = base + field_mgr_pool_offset;
1882                 pool = base + struct_size;
1883
1884                 p = (const char **) pool_head + 1;
1885                 while ((struct ast_string_field_mgr *) p != mgr) {
1886                         *p++ = __ast_string_field_empty;
1887                 }
1888
1889                 mgr->embedded_pool = pool;
1890                 *pool_head = pool;
1891                 pool->size = size_to_alloc - struct_size - sizeof(*pool);
1892 #if defined(__AST_DEBUG_MALLOC)
1893                 mgr->owner_file = file;
1894                 mgr->owner_func = func;
1895                 mgr->owner_line = lineno;
1896 #endif
1897         }
1898
1899         return allocation;
1900 }
1901
1902 /* end of stringfields support */
1903
1904 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1905
1906 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1907 {
1908         int ret;
1909         ast_mutex_lock(&fetchadd_m);
1910         ret = *p;
1911         *p += v;
1912         ast_mutex_unlock(&fetchadd_m);
1913         return ret;
1914 }
1915
1916 /*! \brief
1917  * get values from config variables.
1918  */
1919 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
1920 {
1921         long double dtv = 0.0;
1922         int scanned;
1923
1924         if (dst == NULL)
1925                 return -1;
1926
1927         *dst = _default;
1928
1929         if (ast_strlen_zero(src))
1930                 return -1;
1931
1932         /* only integer at the moment, but one day we could accept more formats */
1933         if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
1934                 dst->tv_sec = dtv;
1935                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
1936                 if (consumed)
1937                         *consumed = scanned;
1938                 return 0;
1939         } else
1940                 return -1;
1941 }
1942
1943 /*! \brief
1944  * get values from config variables.
1945  */
1946 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1947 {
1948         long t;
1949         int scanned;
1950
1951         if (dst == NULL)
1952                 return -1;
1953
1954         *dst = _default;
1955
1956         if (ast_strlen_zero(src))
1957                 return -1;
1958
1959         /* only integer at the moment, but one day we could accept more formats */
1960         if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
1961                 *dst = t;
1962                 if (consumed)
1963                         *consumed = scanned;
1964                 return 0;
1965         } else
1966                 return -1;
1967 }
1968
1969 void ast_enable_packet_fragmentation(int sock)
1970 {
1971 #if defined(HAVE_IP_MTU_DISCOVER)
1972         int val = IP_PMTUDISC_DONT;
1973
1974         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1975                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1976 #endif /* HAVE_IP_MTU_DISCOVER */
1977 }
1978
1979 int ast_mkdir(const char *path, int mode)
1980 {
1981         char *ptr;
1982         int len = strlen(path), count = 0, x, piececount = 0;
1983         char *tmp = ast_strdupa(path);
1984         char **pieces;
1985         char *fullpath = alloca(len + 1);
1986         int res = 0;
1987
1988         for (ptr = tmp; *ptr; ptr++) {
1989                 if (*ptr == '/')
1990                         count++;
1991         }
1992
1993         /* Count the components to the directory path */
1994         pieces = alloca(count * sizeof(*pieces));
1995         for (ptr = tmp; *ptr; ptr++) {
1996                 if (*ptr == '/') {
1997                         *ptr = '\0';
1998                         pieces[piececount++] = ptr + 1;
1999                 }
2000         }
2001
2002         *fullpath = '\0';
2003         for (x = 0; x < piececount; x++) {
2004                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
2005                 strcat(fullpath, "/");
2006                 strcat(fullpath, pieces[x]);
2007                 res = mkdir(fullpath, mode);
2008                 if (res && errno != EEXIST)
2009                         return errno;
2010         }
2011         return 0;
2012 }
2013
2014 int ast_utils_init(void)
2015 {
2016 #ifdef HAVE_DEV_URANDOM
2017         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
2018 #endif
2019         base64_init();
2020 #ifdef DEBUG_THREADS
2021 #if !defined(LOW_MEMORY)
2022         ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
2023 #endif
2024 #endif
2025         return 0;
2026 }
2027
2028
2029 /*!
2030  *\brief Parse digest authorization header.
2031  *\return Returns -1 if we have no auth or something wrong with digest.
2032  *\note This function may be used for Digest request and responce header.
2033  * request arg is set to nonzero, if we parse Digest Request.
2034  * pedantic arg can be set to nonzero if we need to do addition Digest check.
2035  */
2036 int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic) {
2037         char *c;
2038         struct ast_str *str = ast_str_create(16);
2039
2040         /* table of recognised keywords, and places where they should be copied */
2041         const struct x {
2042                 const char *key;
2043                 const ast_string_field *field;
2044         } *i, keys[] = {
2045                 { "username=", &d->username },
2046                 { "realm=", &d->realm },
2047                 { "nonce=", &d->nonce },
2048                 { "uri=", &d->uri },
2049                 { "domain=", &d->domain },
2050                 { "response=", &d->response },
2051                 { "cnonce=", &d->cnonce },
2052                 { "opaque=", &d->opaque },
2053                 /* Special cases that cannot be directly copied */
2054                 { "algorithm=", NULL },
2055                 { "qop=", NULL },
2056                 { "nc=", NULL },
2057                 { NULL, 0 },
2058         };
2059
2060         if (ast_strlen_zero(digest) || !d || !str) {
2061                 ast_free(str);
2062                 return -1;
2063         }
2064
2065         ast_str_set(&str, 0, "%s", digest);
2066
2067         c = ast_skip_blanks(ast_str_buffer(str));
2068
2069         if (strncasecmp(c, "Digest ", strlen("Digest "))) {
2070                 ast_log(LOG_WARNING, "Missing Digest.\n");
2071                 ast_free(str);
2072                 return -1;
2073         }
2074         c += strlen("Digest ");
2075
2076         /* lookup for keys/value pair */
2077         while (c && *c && *(c = ast_skip_blanks(c))) {
2078                 /* find key */
2079                 for (i = keys; i->key != NULL; i++) {
2080                         char *src, *separator;
2081                         int unescape = 0;
2082                         if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
2083                                 continue;
2084                         }
2085
2086                         /* Found. Skip keyword, take text in quotes or up to the separator. */
2087                         c += strlen(i->key);
2088                         if (*c == '"') {
2089                                 src = ++c;
2090                                 separator = "\"";
2091                                 unescape = 1;
2092                         } else {
2093                                 src = c;
2094                                 separator = ",";
2095                         }
2096                         strsep(&c, separator); /* clear separator and move ptr */
2097                         if (unescape) {
2098                                 ast_unescape_c(src);
2099                         }
2100                         if (i->field) {
2101                                 ast_string_field_ptr_set(d, i->field, src);
2102                         } else {
2103                                 /* Special cases that require additional procesing */
2104                                 if (!strcasecmp(i->key, "algorithm=")) {
2105                                         if (strcasecmp(src, "MD5")) {
2106                                                 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
2107                                                 ast_free(str);
2108                                                 return -1;
2109                                         }
2110                                 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
2111                                         d->qop = 1;
2112                                 } else if (!strcasecmp(i->key, "nc=")) {
2113                                         unsigned long u;
2114                                         if (sscanf(src, "%30lx", &u) != 1) {
2115                                                 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
2116                                                 ast_free(str);
2117                                                 return -1;
2118                                         }
2119                                         ast_string_field_set(d, nc, src);
2120                                 }
2121                         }
2122                         break;
2123                 }
2124                 if (i->key == NULL) { /* not found, try ',' */
2125                         strsep(&c, ",");
2126                 }
2127         }
2128         ast_free(str);
2129
2130         /* Digest checkout */
2131         if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
2132                 /* "realm" and "nonce" MUST be always exist */
2133                 return -1;
2134         }
2135
2136         if (!request) {
2137                 /* Additional check for Digest response */
2138                 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
2139                         return -1;
2140                 }
2141
2142                 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
2143                         return -1;
2144                 }
2145         }
2146
2147         return 0;
2148 }
2149
2150 #ifndef __AST_DEBUG_MALLOC
2151 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...)
2152 {
2153         int res;
2154         va_list ap;
2155
2156         va_start(ap, fmt);
2157         if ((res = vasprintf(ret, fmt, ap)) == -1) {
2158                 MALLOC_FAILURE_MSG;
2159         }
2160         va_end(ap);
2161
2162         return res;
2163 }
2164 #endif
2165
2166 int ast_get_tid(void)
2167 {
2168         int ret = -1;
2169 #if defined (__linux) && defined(SYS_gettid)
2170         ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */
2171 #elif defined(__sun)
2172         ret = pthread_self();
2173 #elif defined(__APPLE__)
2174         ret = mach_thread_self();
2175         mach_port_deallocate(mach_task_self(), ret);
2176 #elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H)
2177         long lwpid;
2178         thr_self(&lwpid); /* available since sys/thr.h creation 2003 */
2179         ret = lwpid;
2180 #endif
2181         return ret;
2182 }
2183
2184 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size)
2185 {
2186         const char *envPATH = getenv("PATH");
2187         char *tpath, *path;
2188         struct stat unused;
2189         if (!envPATH) {
2190                 return NULL;
2191         }
2192         tpath = ast_strdupa(envPATH);
2193         while ((path = strsep(&tpath, ":"))) {
2194                 snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
2195                 if (!stat(fullpath, &unused)) {
2196                         return fullpath;
2197                 }
2198         }
2199         return NULL;
2200 }
2201