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