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