Merged revisions 162413 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, 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, (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, 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 && (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         /* Dont 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  ast_uri_encode: Turn text string to URI-encoded %XX version
372 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
373         as in the SIP protocol spec 
374         If doreserved == 1 we will convert reserved characters also.
375         RFC 2396, section 2.4
376         outbuf needs to have more memory allocated than the instring
377         to have room for the expansion. Every char that is converted
378         is replaced by three ASCII characters.
379
380         Note: The doreserved option is needed for replaces header in
381         SIP transfers.
382 */
383 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved) 
384 {
385         char *reserved = ";/?:@&=+$,# ";        /* Reserved chars */
386
387         const char *ptr  = string;      /* Start with the string */
388         char *out = NULL;
389         char *buf = NULL;
390
391         ast_copy_string(outbuf, string, buflen);
392
393         /* If there's no characters to convert, just go through and don't do anything */
394         while (*ptr) {
395                 if ((*ptr < 32 || (unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
396                         /* Oops, we need to start working here */
397                         if (!buf) {
398                                 buf = outbuf;
399                                 out = buf + (ptr - string) ;    /* Set output ptr */
400                         }
401                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
402                 } else if (buf) {
403                         *out = *ptr;    /* Continue copying the string */
404                         out++;
405                 } 
406                 ptr++;
407         }
408         if (buf)
409                 *out = '\0';
410         return outbuf;
411 }
412
413 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
414 void ast_uri_decode(char *s) 
415 {
416         char *o;
417         unsigned int tmp;
418
419         for (o = s; *s; s++, o++) {
420                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
421                         /* have '%', two chars and correct parsing */
422                         *o = tmp;
423                         s += 2; /* Will be incremented once more when we break out */
424                 } else /* all other cases, just copy */
425                         *o = *s;
426         }
427         *o = '\0';
428 }
429
430 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
431 const char *ast_inet_ntoa(struct in_addr ia)
432 {
433         char *buf;
434
435         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
436                 return "";
437
438         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
439 }
440
441 #ifdef HAVE_DEV_URANDOM
442 static int dev_urandom_fd;
443 #endif
444
445 #ifndef __linux__
446 #undef pthread_create /* For ast_pthread_create function only */
447 #endif /* !__linux__ */
448
449 #if !defined(LOW_MEMORY)
450
451 #ifdef DEBUG_THREADS
452
453 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
454 #define AST_MAX_LOCKS 64
455
456 /* Allow direct use of pthread_mutex_t and friends */
457 #undef pthread_mutex_t
458 #undef pthread_mutex_lock
459 #undef pthread_mutex_unlock
460 #undef pthread_mutex_init
461 #undef pthread_mutex_destroy
462
463 /*! 
464  * \brief Keep track of which locks a thread holds 
465  *
466  * There is an instance of this struct for every active thread
467  */
468 struct thr_lock_info {
469         /*! The thread's ID */
470         pthread_t thread_id;
471         /*! The thread name which includes where the thread was started */
472         const char *thread_name;
473         /*! This is the actual container of info for what locks this thread holds */
474         struct {
475                 const char *file;
476                 int line_num;
477                 const char *func;
478                 const char *lock_name;
479                 void *lock_addr;
480                 int times_locked;
481                 enum ast_lock_type type;
482                 /*! This thread is waiting on this lock */
483                 int pending:2;
484 #ifdef HAVE_BKTR
485                 struct ast_bt *backtrace;
486 #endif
487         } locks[AST_MAX_LOCKS];
488         /*! This is the number of locks currently held by this thread.
489          *  The index (num_locks - 1) has the info on the last one in the
490          *  locks member */
491         unsigned int num_locks;
492         /*! Protects the contents of the locks member 
493          * Intentionally not ast_mutex_t */
494         pthread_mutex_t lock;
495         AST_LIST_ENTRY(thr_lock_info) entry;
496 };
497
498 /*! 
499  * \brief Locked when accessing the lock_infos list 
500  */
501 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
502 /*!
503  * \brief A list of each thread's lock info 
504  */
505 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
506
507 /*!
508  * \brief Destroy a thread's lock info
509  *
510  * This gets called automatically when the thread stops
511  */
512 static void lock_info_destroy(void *data)
513 {
514         struct thr_lock_info *lock_info = data;
515         int i;
516
517         pthread_mutex_lock(&lock_infos_lock.mutex);
518         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
519         pthread_mutex_unlock(&lock_infos_lock.mutex);
520
521
522         for (i = 0; i < lock_info->num_locks; i++) {
523                 ast_log(LOG_ERROR, 
524                         "Thread '%s' still has a lock! - '%s' (%p) from '%s' in %s:%d!\n", 
525                         lock_info->thread_name,
526                         lock_info->locks[i].lock_name,
527                         lock_info->locks[i].lock_addr,
528                         lock_info->locks[i].func,
529                         lock_info->locks[i].file,
530                         lock_info->locks[i].line_num
531                 );
532         }
533
534         pthread_mutex_destroy(&lock_info->lock);
535         if (lock_info->thread_name)
536                 free((void *) lock_info->thread_name);
537         free(lock_info);
538 }
539
540 /*!
541  * \brief The thread storage key for per-thread lock info
542  */
543 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
544 #ifdef HAVE_BKTR
545 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
546         int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
547 #else
548 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
549         int line_num, const char *func, const char *lock_name, void *lock_addr)
550 #endif
551 {
552         struct thr_lock_info *lock_info;
553         int i;
554
555         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
556                 return;
557
558         pthread_mutex_lock(&lock_info->lock);
559
560         for (i = 0; i < lock_info->num_locks; i++) {
561                 if (lock_info->locks[i].lock_addr == lock_addr) {
562                         lock_info->locks[i].times_locked++;
563 #ifdef HAVE_BKTR
564                         lock_info->locks[i].backtrace = bt;
565 #endif
566                         pthread_mutex_unlock(&lock_info->lock);
567                         return;
568                 }
569         }
570
571         if (lock_info->num_locks == AST_MAX_LOCKS) {
572                 /* Can't use ast_log here, because it will cause infinite recursion */
573                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
574                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
575                 pthread_mutex_unlock(&lock_info->lock);
576                 return;
577         }
578
579         if (i && lock_info->locks[i - 1].pending == -1) {
580                 /* The last lock on the list was one that this thread tried to lock but
581                  * failed at doing so.  It has now moved on to something else, so remove
582                  * the old lock from the list. */
583                 i--;
584                 lock_info->num_locks--;
585                 memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
586         }
587
588         lock_info->locks[i].file = filename;
589         lock_info->locks[i].line_num = line_num;
590         lock_info->locks[i].func = func;
591         lock_info->locks[i].lock_name = lock_name;
592         lock_info->locks[i].lock_addr = lock_addr;
593         lock_info->locks[i].times_locked = 1;
594         lock_info->locks[i].type = type;
595         lock_info->locks[i].pending = 1;
596 #ifdef HAVE_BKTR
597         lock_info->locks[i].backtrace = bt;
598 #endif
599         lock_info->num_locks++;
600
601         pthread_mutex_unlock(&lock_info->lock);
602 }
603
604 void ast_mark_lock_acquired(void *lock_addr)
605 {
606         struct thr_lock_info *lock_info;
607
608         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
609                 return;
610
611         pthread_mutex_lock(&lock_info->lock);
612         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
613                 lock_info->locks[lock_info->num_locks - 1].pending = 0;
614         }
615         pthread_mutex_unlock(&lock_info->lock);
616 }
617
618 void ast_mark_lock_failed(void *lock_addr)
619 {
620         struct thr_lock_info *lock_info;
621
622         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
623                 return;
624
625         pthread_mutex_lock(&lock_info->lock);
626         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
627                 lock_info->locks[lock_info->num_locks - 1].pending = -1;
628                 lock_info->locks[lock_info->num_locks - 1].times_locked--;
629         }
630         pthread_mutex_unlock(&lock_info->lock);
631 }
632
633 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)
634 {
635         struct thr_lock_info *lock_info;
636         int i = 0;
637
638         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
639                 return -1;
640
641         pthread_mutex_lock(&lock_info->lock);
642
643         for (i = lock_info->num_locks - 1; i >= 0; i--) {
644                 if (lock_info->locks[i].lock_addr == lock_addr)
645                         break;
646         }
647
648         if (i == -1) {
649                 /* Lock not found :( */
650                 pthread_mutex_unlock(&lock_info->lock);
651                 return -1;
652         }
653
654         ast_copy_string(filename, lock_info->locks[i].file, filename_size);
655         *lineno = lock_info->locks[i].line_num;
656         ast_copy_string(func, lock_info->locks[i].func, func_size);
657         ast_copy_string(mutex_name, lock_info->locks[i].lock_name, mutex_name_size);
658
659         pthread_mutex_unlock(&lock_info->lock);
660
661         return 0;
662 }
663
664 #ifdef HAVE_BKTR
665 void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt)
666 #else
667 void ast_remove_lock_info(void *lock_addr)
668 #endif
669 {
670         struct thr_lock_info *lock_info;
671         int i = 0;
672
673         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
674                 return;
675
676         pthread_mutex_lock(&lock_info->lock);
677
678         for (i = lock_info->num_locks - 1; i >= 0; i--) {
679                 if (lock_info->locks[i].lock_addr == lock_addr)
680                         break;
681         }
682
683         if (i == -1) {
684                 /* Lock not found :( */
685                 pthread_mutex_unlock(&lock_info->lock);
686                 return;
687         }
688
689         if (lock_info->locks[i].times_locked > 1) {
690                 lock_info->locks[i].times_locked--;
691 #ifdef HAVE_BKTR
692                 lock_info->locks[i].backtrace = bt;
693 #endif
694                 pthread_mutex_unlock(&lock_info->lock);
695                 return;
696         }
697
698         if (i < lock_info->num_locks - 1) {
699                 /* Not the last one ... *should* be rare! */
700                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1], 
701                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
702         }
703
704         lock_info->num_locks--;
705
706         pthread_mutex_unlock(&lock_info->lock);
707 }
708
709 static const char *locktype2str(enum ast_lock_type type)
710 {
711         switch (type) {
712         case AST_MUTEX:
713                 return "MUTEX";
714         case AST_RDLOCK:
715                 return "RDLOCK";
716         case AST_WRLOCK:
717                 return "WRLOCK";
718         }
719
720         return "UNKNOWN";
721 }
722
723 #ifdef HAVE_BKTR
724 static void append_backtrace_information(struct ast_str **str, struct ast_bt *bt)
725 {
726         char **symbols;
727
728         if (!bt) {
729                 ast_str_append(str, 0, "\tNo backtrace to print\n");
730                 return;
731         }
732
733         if ((symbols = backtrace_symbols(bt->addresses, bt->num_frames))) {
734                 int frame_iterator;
735                 
736                 for (frame_iterator = 0; frame_iterator < bt->num_frames; ++frame_iterator) {
737                         ast_str_append(str, 0, "\t%s\n", symbols[frame_iterator]);
738                 }
739
740                 free(symbols);
741         } else {
742                 ast_str_append(str, 0, "\tCouldn't retrieve backtrace symbols\n");
743         }
744 }
745 #endif
746
747 static void append_lock_information(struct ast_str **str, struct thr_lock_info *lock_info, int i)
748 {
749         int j;
750         ast_mutex_t *lock;
751         struct ast_lock_track *lt;
752         
753         ast_str_append(str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d)\n", 
754                                    lock_info->locks[i].pending > 0 ? "Waiting for " : 
755                                    lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
756                                    lock_info->locks[i].file, 
757                                    locktype2str(lock_info->locks[i].type),
758                                    lock_info->locks[i].line_num,
759                                    lock_info->locks[i].func, lock_info->locks[i].lock_name,
760                                    lock_info->locks[i].lock_addr, 
761                                    lock_info->locks[i].times_locked);
762 #ifdef HAVE_BKTR
763         append_backtrace_information(str, lock_info->locks[i].backtrace);
764 #endif
765         
766         if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
767                 return;
768         
769         /* We only have further details for mutexes right now */
770         if (lock_info->locks[i].type != AST_MUTEX)
771                 return;
772         
773         lock = lock_info->locks[i].lock_addr;
774         lt = &lock->track;
775         ast_reentrancy_lock(lt);
776         for (j = 0; *str && j < lt->reentrancy; j++) {
777                 ast_str_append(str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
778                                            lt->file[j], lt->lineno[j], lt->func[j]);
779         }
780         ast_reentrancy_unlock(lt);      
781 }
782
783
784 /*! This function can help you find highly temporal locks; locks that happen for a 
785     short time, but at unexpected times, usually at times that create a deadlock,
786         Why is this thing locked right then? Who is locking it? Who am I fighting
787     with for this lock? 
788
789         To answer such questions, just call this routine before you would normally try
790         to aquire a lock. It doesn't do anything if the lock is not acquired. If the
791         lock is taken, it will publish a line or two to the console via ast_log().
792
793         Sometimes, the lock message is pretty uninformative. For instance, you might
794         find that the lock is being aquired deep within the astobj2 code; this tells
795         you little about higher level routines that call the astobj2 routines.
796         But, using gdb, you can set a break at the ast_log below, and for that
797         breakpoint, you can set the commands:
798           where
799           cont
800         which will give a stack trace and continue. -- that aught to do the job!
801
802 */
803 void log_show_lock(void *this_lock_addr)
804 {
805         struct thr_lock_info *lock_info;
806         struct ast_str *str;
807
808         if (!(str = ast_str_create(4096))) {
809                 ast_log(LOG_NOTICE,"Could not create str\n");
810                 return;
811         }
812         
813
814         pthread_mutex_lock(&lock_infos_lock.mutex);
815         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
816                 int i;
817                 pthread_mutex_lock(&lock_info->lock);
818                 for (i = 0; str && i < lock_info->num_locks; i++) {
819                         /* ONLY show info about this particular lock, if
820                            it's acquired... */
821                         if (lock_info->locks[i].lock_addr == this_lock_addr) {
822                                 append_lock_information(&str, lock_info, i);
823                                 ast_log(LOG_NOTICE, "%s", str->str);
824                                 break;
825                         }
826                 }
827                 pthread_mutex_unlock(&lock_info->lock);
828         }
829         pthread_mutex_unlock(&lock_infos_lock.mutex);
830         ast_free(str);
831 }
832
833
834 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
835 {
836         struct thr_lock_info *lock_info;
837         struct ast_str *str;
838
839         if (!(str = ast_str_create(4096)))
840                 return CLI_FAILURE;
841
842         switch (cmd) {
843         case CLI_INIT:
844                 e->command = "core show locks";
845                 e->usage =
846                         "Usage: core show locks\n"
847                         "       This command is for lock debugging.  It prints out which locks\n"
848                         "are owned by each active thread.\n";
849                 return NULL;
850
851         case CLI_GENERATE:
852                 return NULL;
853         }
854
855         ast_str_append(&str, 0, "\n" 
856                        "=======================================================================\n"
857                        "=== Currently Held Locks ==============================================\n"
858                        "=======================================================================\n"
859                        "===\n"
860                        "=== <pending> <lock#> (<file>): <lock type> <line num> <function> <lock name> <lock addr> (times locked)\n"
861                        "===\n");
862
863         if (!str)
864                 return CLI_FAILURE;
865
866         pthread_mutex_lock(&lock_infos_lock.mutex);
867         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
868                 int i;
869                 if (lock_info->num_locks) {
870                         ast_str_append(&str, 0, "=== Thread ID: %d (%s)\n", (int) lock_info->thread_id,
871                                 lock_info->thread_name);
872                         pthread_mutex_lock(&lock_info->lock);
873                         for (i = 0; str && i < lock_info->num_locks; i++) {
874                                 append_lock_information(&str, lock_info, i);
875                         }
876                         pthread_mutex_unlock(&lock_info->lock);
877                         if (!str)
878                                 break;
879                         ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
880                                        "===\n");
881                         if (!str)
882                                 break;
883                 }
884         }
885         pthread_mutex_unlock(&lock_infos_lock.mutex);
886
887         if (!str)
888                 return CLI_FAILURE;
889
890         ast_str_append(&str, 0, "=======================================================================\n"
891                        "\n");
892
893         if (!str)
894                 return CLI_FAILURE;
895
896         ast_cli(a->fd, "%s", str->str);
897
898         ast_free(str);
899
900         return CLI_SUCCESS;
901 }
902
903 static struct ast_cli_entry utils_cli[] = {
904         AST_CLI_DEFINE(handle_show_locks, "Show which locks are held by which thread"),
905 };
906
907 #endif /* DEBUG_THREADS */
908
909 /*
910  * support for 'show threads'. The start routine is wrapped by
911  * dummy_start(), so that ast_register_thread() and
912  * ast_unregister_thread() know the thread identifier.
913  */
914 struct thr_arg {
915         void *(*start_routine)(void *);
916         void *data;
917         char *name;
918 };
919
920 /*
921  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
922  * are odd macros which start and end a block, so they _must_ be
923  * used in pairs (the latter with a '1' argument to call the
924  * handler on exit.
925  * On BSD we don't need this, but we keep it for compatibility.
926  */
927 static void *dummy_start(void *data)
928 {
929         void *ret;
930         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
931 #ifdef DEBUG_THREADS
932         struct thr_lock_info *lock_info;
933         pthread_mutexattr_t mutex_attr;
934 #endif
935
936         /* note that even though data->name is a pointer to allocated memory,
937            we are not freeing it here because ast_register_thread is going to
938            keep a copy of the pointer and then ast_unregister_thread will
939            free the memory
940         */
941         ast_free(data);
942         ast_register_thread(a.name);
943         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
944
945 #ifdef DEBUG_THREADS
946         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
947                 return NULL;
948
949         lock_info->thread_id = pthread_self();
950         lock_info->thread_name = strdup(a.name);
951
952         pthread_mutexattr_init(&mutex_attr);
953         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
954         pthread_mutex_init(&lock_info->lock, &mutex_attr);
955         pthread_mutexattr_destroy(&mutex_attr);
956
957         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
958         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
959         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
960 #endif /* DEBUG_THREADS */
961
962         ret = a.start_routine(a.data);
963
964         pthread_cleanup_pop(1);
965
966         return ret;
967 }
968
969 #endif /* !LOW_MEMORY */
970
971 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
972                              void *data, size_t stacksize, const char *file, const char *caller,
973                              int line, const char *start_fn)
974 {
975 #if !defined(LOW_MEMORY)
976         struct thr_arg *a;
977 #endif
978
979         if (!attr) {
980                 attr = alloca(sizeof(*attr));
981                 pthread_attr_init(attr);
982         }
983
984 #ifdef __linux__
985         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
986            which is kind of useless. Change this here to
987            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
988            priority will propagate down to new threads by default.
989            This does mean that callers cannot set a different priority using
990            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
991            the priority afterwards with pthread_setschedparam(). */
992         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
993                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
994 #endif
995
996         if (!stacksize)
997                 stacksize = AST_STACKSIZE;
998
999         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
1000                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
1001
1002 #if !defined(LOW_MEMORY)
1003         if ((a = ast_malloc(sizeof(*a)))) {
1004                 a->start_routine = start_routine;
1005                 a->data = data;
1006                 start_routine = dummy_start;
1007                 if (asprintf(&a->name, "%-20s started at [%5d] %s %s()",
1008                              start_fn, line, file, caller) < 0) {
1009                         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
1010                         a->name = NULL;
1011                 }
1012                 data = a;
1013         }
1014 #endif /* !LOW_MEMORY */
1015
1016         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
1017 }
1018
1019
1020 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1021                              void *data, size_t stacksize, const char *file, const char *caller,
1022                              int line, const char *start_fn)
1023 {
1024         unsigned char attr_destroy = 0;
1025         int res;
1026
1027         if (!attr) {
1028                 attr = alloca(sizeof(*attr));
1029                 pthread_attr_init(attr);
1030                 attr_destroy = 1;
1031         }
1032
1033         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
1034                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
1035
1036         res = ast_pthread_create_stack(thread, attr, start_routine, data, 
1037                                        stacksize, file, caller, line, start_fn);
1038
1039         if (attr_destroy)
1040                 pthread_attr_destroy(attr);
1041
1042         return res;
1043 }
1044
1045 int ast_wait_for_input(int fd, int ms)
1046 {
1047         struct pollfd pfd[1];
1048         memset(pfd, 0, sizeof(pfd));
1049         pfd[0].fd = fd;
1050         pfd[0].events = POLLIN|POLLPRI;
1051         return poll(pfd, 1, ms);
1052 }
1053
1054 /*!
1055  * Try to write string, but wait no more than ms milliseconds before timing out.
1056  *
1057  * \note The code assumes that the file descriptor has NONBLOCK set,
1058  * so there is only one system call made to do a write, unless we actually
1059  * have a need to wait.  This way, we get better performance.
1060  * If the descriptor is blocking, all assumptions on the guaranteed
1061  * detail do not apply anymore.
1062  * Also note that in the current implementation, the delay is per-write,
1063  * so you still have no guarantees, anyways.
1064  * Fortunately the routine is only used in a few places (cli.c, manager.c,
1065  * res_agi.c) so it is reasonably easy to check how it behaves there.
1066  *
1067  * XXX We either need to fix the code, or fix the documentation.
1068  */
1069 int ast_carefulwrite(int fd, char *s, int len, int timeoutms) 
1070 {
1071         /* Try to write string, but wait no more than ms milliseconds
1072            before timing out */
1073         int res = 0;
1074         struct pollfd fds[1];
1075         while (len) {
1076                 res = write(fd, s, len);
1077                 if ((res < 0) && (errno != EAGAIN)) {
1078                         return -1;
1079                 }
1080                 if (res < 0)
1081                         res = 0;
1082                 len -= res;
1083                 s += res;
1084                 res = 0;
1085                 if (len) {
1086                         fds[0].fd = fd;
1087                         fds[0].events = POLLOUT;
1088                         /* Wait until writable again */
1089                         res = poll(fds, 1, timeoutms);
1090                         if (res < 1)
1091                                 return -1;
1092                 }
1093         }
1094         return res;
1095 }
1096
1097 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1098 {
1099         char *e;
1100         char *q;
1101
1102         s = ast_strip(s);
1103         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1104                 e = s + strlen(s) - 1;
1105                 if (*e == *(end_quotes + (q - beg_quotes))) {
1106                         s++;
1107                         *e = '\0';
1108                 }
1109         }
1110
1111         return s;
1112 }
1113
1114 char *ast_unescape_semicolon(char *s)
1115 {
1116         char *e;
1117         char *work = s;
1118
1119         while ((e = strchr(work, ';'))) {
1120                 if ((e > work) && (*(e-1) == '\\')) {
1121                         memmove(e - 1, e, strlen(e) + 1);
1122                         work = e;
1123                 } else {
1124                         work = e + 1;
1125                 }
1126         }
1127
1128         return s;
1129 }
1130
1131 /* !\brief unescape some C sequences in place, return pointer to the original string.
1132  */
1133 char *ast_unescape_c(char *src)
1134 {
1135         char c, *ret, *dst;
1136
1137         if (src == NULL)
1138                 return NULL;
1139         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1140                 if (c != '\\')
1141                         continue;       /* copy char at the end of the loop */
1142                 switch ((c = *src++)) {
1143                 case '\0':      /* special, trailing '\' */
1144                         c = '\\';
1145                         break;
1146                 case 'b':       /* backspace */
1147                         c = '\b';
1148                         break;
1149                 case 'f':       /* form feed */
1150                         c = '\f';
1151                         break;
1152                 case 'n':
1153                         c = '\n';
1154                         break;
1155                 case 'r':
1156                         c = '\r';
1157                         break;
1158                 case 't':
1159                         c = '\t';
1160                         break;
1161                 }
1162                 /* default, use the char literally */
1163         }
1164         *dst = '\0';
1165         return ret;
1166 }
1167
1168 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1169 {
1170         int result;
1171
1172         if (!buffer || !*buffer || !space || !*space)
1173                 return -1;
1174
1175         result = vsnprintf(*buffer, *space, fmt, ap);
1176
1177         if (result < 0)
1178                 return -1;
1179         else if (result > *space)
1180                 result = *space;
1181
1182         *buffer += result;
1183         *space -= result;
1184         return 0;
1185 }
1186
1187 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1188 {
1189         va_list ap;
1190         int result;
1191
1192         va_start(ap, fmt);
1193         result = ast_build_string_va(buffer, space, fmt, ap);
1194         va_end(ap);
1195
1196         return result;
1197 }
1198
1199 int ast_true(const char *s)
1200 {
1201         if (ast_strlen_zero(s))
1202                 return 0;
1203
1204         /* Determine if this is a true value */
1205         if (!strcasecmp(s, "yes") ||
1206             !strcasecmp(s, "true") ||
1207             !strcasecmp(s, "y") ||
1208             !strcasecmp(s, "t") ||
1209             !strcasecmp(s, "1") ||
1210             !strcasecmp(s, "on"))
1211                 return -1;
1212
1213         return 0;
1214 }
1215
1216 int ast_false(const char *s)
1217 {
1218         if (ast_strlen_zero(s))
1219                 return 0;
1220
1221         /* Determine if this is a false value */
1222         if (!strcasecmp(s, "no") ||
1223             !strcasecmp(s, "false") ||
1224             !strcasecmp(s, "n") ||
1225             !strcasecmp(s, "f") ||
1226             !strcasecmp(s, "0") ||
1227             !strcasecmp(s, "off"))
1228                 return -1;
1229
1230         return 0;
1231 }
1232
1233 #define ONE_MILLION     1000000
1234 /*
1235  * put timeval in a valid range. usec is 0..999999
1236  * negative values are not allowed and truncated.
1237  */
1238 static struct timeval tvfix(struct timeval a)
1239 {
1240         if (a.tv_usec >= ONE_MILLION) {
1241                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1242                         (long)a.tv_sec, (long int) a.tv_usec);
1243                 a.tv_sec += a.tv_usec / ONE_MILLION;
1244                 a.tv_usec %= ONE_MILLION;
1245         } else if (a.tv_usec < 0) {
1246                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1247                         (long)a.tv_sec, (long int) a.tv_usec);
1248                 a.tv_usec = 0;
1249         }
1250         return a;
1251 }
1252
1253 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1254 {
1255         /* consistency checks to guarantee usec in 0..999999 */
1256         a = tvfix(a);
1257         b = tvfix(b);
1258         a.tv_sec += b.tv_sec;
1259         a.tv_usec += b.tv_usec;
1260         if (a.tv_usec >= ONE_MILLION) {
1261                 a.tv_sec++;
1262                 a.tv_usec -= ONE_MILLION;
1263         }
1264         return a;
1265 }
1266
1267 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1268 {
1269         /* consistency checks to guarantee usec in 0..999999 */
1270         a = tvfix(a);
1271         b = tvfix(b);
1272         a.tv_sec -= b.tv_sec;
1273         a.tv_usec -= b.tv_usec;
1274         if (a.tv_usec < 0) {
1275                 a.tv_sec-- ;
1276                 a.tv_usec += ONE_MILLION;
1277         }
1278         return a;
1279 }
1280 #undef ONE_MILLION
1281
1282 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1283  * BSD libc (and others) do not. */
1284
1285 #ifndef linux
1286 AST_MUTEX_DEFINE_STATIC(randomlock);
1287 #endif
1288
1289 long int ast_random(void)
1290 {
1291         long int res;
1292 #ifdef HAVE_DEV_URANDOM
1293         if (dev_urandom_fd >= 0) {
1294                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1295                 if (read_res > 0) {
1296                         long int rm = RAND_MAX;
1297                         res = res < 0 ? ~res : res;
1298                         rm++;
1299                         return res % rm;
1300                 }
1301         }
1302 #endif
1303 #ifdef linux
1304         res = random();
1305 #else
1306         ast_mutex_lock(&randomlock);
1307         res = random();
1308         ast_mutex_unlock(&randomlock);
1309 #endif
1310         return res;
1311 }
1312
1313 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1314 {
1315         char *dataPut = start;
1316         int inEscape = 0;
1317         int inQuotes = 0;
1318
1319         for (; *start; start++) {
1320                 if (inEscape) {
1321                         *dataPut++ = *start;       /* Always goes verbatim */
1322                         inEscape = 0;
1323                 } else {
1324                         if (*start == '\\') {
1325                                 inEscape = 1;      /* Do not copy \ into the data */
1326                         } else if (*start == '\'') {
1327                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1328                         } else {
1329                                 /* Replace , with |, unless in quotes */
1330                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1331                         }
1332                 }
1333         }
1334         if (start != dataPut)
1335                 *dataPut = 0;
1336         return dataPut;
1337 }
1338
1339 void ast_join(char *s, size_t len, char * const w[])
1340 {
1341         int x, ofs = 0;
1342         const char *src;
1343
1344         /* Join words into a string */
1345         if (!s)
1346                 return;
1347         for (x = 0; ofs < len && w[x]; x++) {
1348                 if (x > 0)
1349                         s[ofs++] = ' ';
1350                 for (src = w[x]; *src && ofs < len; src++)
1351                         s[ofs++] = *src;
1352         }
1353         if (ofs == len)
1354                 ofs--;
1355         s[ofs] = '\0';
1356 }
1357
1358 /*
1359  * stringfields support routines.
1360  */
1361
1362 const char __ast_string_field_empty[] = ""; /*!< the empty string */
1363
1364 /*! \brief add a new block to the pool.
1365  * We can only allocate from the topmost pool, so the
1366  * fields in *mgr reflect the size of that only.
1367  */
1368 static int add_string_pool(struct ast_string_field_mgr *mgr,
1369                            struct ast_string_field_pool **pool_head,
1370                            size_t size)
1371 {
1372         struct ast_string_field_pool *pool;
1373
1374         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
1375                 return -1;
1376         
1377         pool->prev = *pool_head;
1378         *pool_head = pool;
1379         mgr->size = size;
1380         mgr->used = 0;
1381         mgr->last_alloc = NULL;
1382
1383         return 0;
1384 }
1385
1386 /*
1387  * This is an internal API, code should not use it directly.
1388  * It initializes all fields as empty, then uses 'size' for 3 functions:
1389  * size > 0 means initialize the pool list with a pool of given size.
1390  *      This must be called right after allocating the object.
1391  * size = 0 means release all pools except the most recent one.
1392  *      This is useful to e.g. reset an object to the initial value.
1393  * size < 0 means release all pools.
1394  *      This must be done before destroying the object.
1395  */
1396 int __ast_string_field_init(struct ast_string_field_mgr *mgr,
1397                             struct ast_string_field_pool **pool_head,
1398                             int size)
1399 {
1400         const char **p = (const char **) pool_head + 1;
1401         struct ast_string_field_pool *cur = *pool_head;
1402
1403         /* clear fields - this is always necessary */
1404         while ((struct ast_string_field_mgr *) p != mgr)
1405                 *p++ = __ast_string_field_empty;
1406         mgr->last_alloc = NULL;
1407         if (size > 0) {                 /* allocate the initial pool */
1408                 *pool_head = NULL;
1409                 return add_string_pool(mgr, pool_head, size);
1410         }
1411         if (size < 0) {                 /* reset all pools */
1412                 *pool_head = NULL;
1413         } else {                        /* preserve the first pool */
1414                 if (cur == NULL) {
1415                         ast_log(LOG_WARNING, "trying to reset empty pool\n");
1416                         return -1;
1417                 }
1418                 cur = cur->prev;
1419                 (*pool_head)->prev = NULL;
1420                 mgr->used = 0;
1421         }
1422
1423         while (cur) {
1424                 struct ast_string_field_pool *prev = cur->prev;
1425
1426                 ast_free(cur);
1427                 cur = prev;
1428         }
1429
1430         return 0;
1431 }
1432
1433 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr,
1434                                                 struct ast_string_field_pool **pool_head, size_t needed)
1435 {
1436         char *result = NULL;
1437         size_t space = mgr->size - mgr->used;
1438
1439         if (__builtin_expect(needed > space, 0)) {
1440                 size_t new_size = mgr->size * 2;
1441
1442                 while (new_size < needed)
1443                         new_size *= 2;
1444
1445                 if (add_string_pool(mgr, pool_head, new_size))
1446                         return NULL;
1447         }
1448
1449         result = (*pool_head)->base + mgr->used;
1450         mgr->used += needed;
1451         mgr->last_alloc = result;
1452         return result;
1453 }
1454
1455 int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr, size_t needed,
1456                                 const ast_string_field *ptr)
1457 {
1458         int grow = needed - (strlen(*ptr) + 1);
1459         size_t space = mgr->size - mgr->used;
1460
1461         if (grow <= 0) {
1462                 return 0;
1463         }
1464
1465         if (*ptr != mgr->last_alloc) {
1466                 return 1;
1467         }
1468
1469         if (space < grow) {
1470                 return 1;
1471         }
1472
1473         mgr->used += grow;
1474
1475         return 0;
1476 }
1477
1478 void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
1479                                      struct ast_string_field_pool **pool_head,
1480                                      const ast_string_field *ptr, const char *format, va_list ap1, va_list ap2)
1481 {
1482         size_t needed;
1483         char *dst = (*pool_head)->base + mgr->used;
1484         const char **p = (const char **) ptr;
1485         size_t space = mgr->size - mgr->used;
1486
1487         /* try to write using available space */
1488         needed = vsnprintf(dst, space, format, ap1) + 1;
1489
1490         va_end(ap1);
1491
1492         if (needed > space) {   /* if it fails, reallocate */
1493                 size_t new_size = mgr->size * 2;
1494
1495                 while (new_size < needed)
1496                         new_size *= 2;
1497
1498                 if (add_string_pool(mgr, pool_head, new_size))
1499                         return;
1500
1501                 dst = (*pool_head)->base + mgr->used;
1502                 vsprintf(dst, format, ap2);
1503         }
1504
1505         mgr->last_alloc = *p = dst;
1506         mgr->used += needed;
1507 }
1508
1509 void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
1510                                   struct ast_string_field_pool **pool_head,
1511                                   const ast_string_field *ptr, const char *format, ...)
1512 {
1513         va_list ap1, ap2;
1514
1515         va_start(ap1, format);
1516         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
1517
1518         __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2);
1519
1520         va_end(ap1);
1521         va_end(ap2);
1522 }
1523 /* end of stringfields support */
1524
1525 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1526
1527 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1528 {
1529         int ret;
1530         ast_mutex_lock(&fetchadd_m);
1531         ret = *p;
1532         *p += v;
1533         ast_mutex_unlock(&fetchadd_m);
1534         return ret;
1535 }
1536
1537 /*! \brief
1538  * get values from config variables.
1539  */
1540 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
1541 {
1542         long double dtv = 0.0;
1543         int scanned;
1544
1545         if (dst == NULL)
1546                 return -1;
1547
1548         *dst = _default;
1549
1550         if (ast_strlen_zero(src))
1551                 return -1;
1552
1553         /* only integer at the moment, but one day we could accept more formats */
1554         if (sscanf(src, "%Lf%n", &dtv, &scanned) > 0) {
1555                 dst->tv_sec = dtv;
1556                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
1557                 if (consumed)
1558                         *consumed = scanned;
1559                 return 0;
1560         } else
1561                 return -1;
1562 }
1563
1564 /*! \brief
1565  * get values from config variables.
1566  */
1567 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1568 {
1569         long t;
1570         int scanned;
1571
1572         if (dst == NULL)
1573                 return -1;
1574
1575         *dst = _default;
1576
1577         if (ast_strlen_zero(src))
1578                 return -1;
1579
1580         /* only integer at the moment, but one day we could accept more formats */
1581         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
1582                 *dst = t;
1583                 if (consumed)
1584                         *consumed = scanned;
1585                 return 0;
1586         } else
1587                 return -1;
1588 }
1589
1590 /*!
1591  * core handler for dynamic strings.
1592  * This is not meant to be called directly, but rather through the
1593  * various wrapper macros
1594  *      ast_str_set(...)
1595  *      ast_str_append(...)
1596  *      ast_str_set_va(...)
1597  *      ast_str_append_va(...)
1598  */
1599
1600 int __ast_str_helper(struct ast_str **buf, size_t max_len,
1601         int append, const char *fmt, va_list ap)
1602 {
1603         int res, need;
1604         int offset = (append && (*buf)->len) ? (*buf)->used : 0;
1605         va_list aq;
1606
1607         do {
1608                 if (max_len < 0) {
1609                         max_len = (*buf)->len;  /* don't exceed the allocated space */
1610                 }
1611                 /*
1612                  * Ask vsnprintf how much space we need. Remember that vsnprintf
1613                  * does not count the final '\0' so we must add 1.
1614                  */
1615                 va_copy(aq, ap);
1616                 res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, aq);
1617
1618                 need = res + offset + 1;
1619                 /*
1620                  * If there is not enough space and we are below the max length,
1621                  * reallocate the buffer and return a message telling to retry.
1622                  */
1623                 if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
1624                         if (max_len && max_len < need) {        /* truncate as needed */
1625                                 need = max_len;
1626                         } else if (max_len == 0) {      /* if unbounded, give more room for next time */
1627                                 need += 16 + need / 4;
1628                         }
1629                         if (0) {        /* debugging */
1630                                 ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need);
1631                         }
1632                         if (ast_str_make_space(buf, need)) {
1633                                 ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need);
1634                                 return AST_DYNSTR_BUILD_FAILED;
1635                         }
1636                         (*buf)->str[offset] = '\0';     /* Truncate the partial write. */
1637
1638                         /* Restart va_copy before calling vsnprintf() again. */
1639                         va_end(aq);
1640                         continue;
1641                 }
1642                 break;
1643         } while (1);
1644         /* update space used, keep in mind the truncation */
1645         (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len : res + offset;
1646
1647         return res;
1648 }
1649
1650 void ast_enable_packet_fragmentation(int sock)
1651 {
1652 #if defined(HAVE_IP_MTU_DISCOVER)
1653         int val = IP_PMTUDISC_DONT;
1654         
1655         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1656                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1657 #endif /* HAVE_IP_MTU_DISCOVER */
1658 }
1659
1660 int ast_mkdir(const char *path, int mode)
1661 {
1662         char *ptr;
1663         int len = strlen(path), count = 0, x, piececount = 0;
1664         char *tmp = ast_strdupa(path);
1665         char **pieces;
1666         char *fullpath = alloca(len + 1);
1667         int res = 0;
1668
1669         for (ptr = tmp; *ptr; ptr++) {
1670                 if (*ptr == '/')
1671                         count++;
1672         }
1673
1674         /* Count the components to the directory path */
1675         pieces = alloca(count * sizeof(*pieces));
1676         for (ptr = tmp; *ptr; ptr++) {
1677                 if (*ptr == '/') {
1678                         *ptr = '\0';
1679                         pieces[piececount++] = ptr + 1;
1680                 }
1681         }
1682
1683         *fullpath = '\0';
1684         for (x = 0; x < piececount; x++) {
1685                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
1686                 strcat(fullpath, "/");
1687                 strcat(fullpath, pieces[x]);
1688                 res = mkdir(fullpath, mode);
1689                 if (res && errno != EEXIST)
1690                         return errno;
1691         }
1692         return 0;
1693 }
1694
1695 int ast_utils_init(void)
1696 {
1697 #ifdef HAVE_DEV_URANDOM
1698         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
1699 #endif
1700         base64_init();
1701 #ifdef DEBUG_THREADS
1702 #if !defined(LOW_MEMORY)
1703         ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
1704 #endif
1705 #endif
1706         return 0;
1707 }
1708
1709 #ifndef __AST_DEBUG_MALLOC
1710 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...)
1711 {
1712         int res;
1713         va_list ap;
1714
1715         va_start(ap, fmt);
1716         if ((res = vasprintf(ret, fmt, ap)) == -1) {
1717                 MALLOC_FAILURE_MSG;
1718         }
1719         va_end(ap);
1720
1721         return res;
1722 }
1723 #endif