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