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