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