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