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