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