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