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