CallerID: Fix parsing of malformed callerid
[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
487 void ast_unescape_quoted(char *quote_str)
488 {
489         int esc_pos;
490         int unesc_pos;
491         int quote_str_len = strlen(quote_str);
492
493         for (esc_pos = 0, unesc_pos = 0;
494                 esc_pos < quote_str_len;
495                 esc_pos++, unesc_pos++) {
496                 if (quote_str[esc_pos] == '\\') {
497                         /* at least one more char and current is \\ */
498                         esc_pos++;
499                         if (esc_pos >= quote_str_len) {
500                                 break;
501                         }
502                 }
503
504                 quote_str[unesc_pos] = quote_str[esc_pos];
505         }
506         quote_str[unesc_pos] = '\0';
507 }
508
509 int ast_xml_escape(const char *string, char * const outbuf, const size_t buflen)
510 {
511         char *dst = outbuf;
512         char *end = outbuf + buflen - 1; /* save one for the null terminator */
513
514         /* Handle the case for the empty output buffer */
515         if (buflen == 0) {
516                 return -1;
517         }
518
519         /* Escaping rules from http://www.w3.org/TR/REC-xml/#syntax */
520         /* This also prevents partial entities at the end of a string */
521         while (*string && dst < end) {
522                 const char *entity = NULL;
523                 int len = 0;
524
525                 switch (*string) {
526                 case '<':
527                         entity = "&lt;";
528                         len = 4;
529                         break;
530                 case '&':
531                         entity = "&amp;";
532                         len = 5;
533                         break;
534                 case '>':
535                         /* necessary if ]]> is in the string; easier to escape them all */
536                         entity = "&gt;";
537                         len = 4;
538                         break;
539                 case '\'':
540                         /* necessary in single-quoted strings; easier to escape them all */
541                         entity = "&apos;";
542                         len = 6;
543                         break;
544                 case '"':
545                         /* necessary in double-quoted strings; easier to escape them all */
546                         entity = "&quot;";
547                         len = 6;
548                         break;
549                 default:
550                         *dst++ = *string++;
551                         break;
552                 }
553
554                 if (entity) {
555                         ast_assert(len == strlen(entity));
556                         if (end - dst < len) {
557                                 /* no room for the entity; stop */
558                                 break;
559                         }
560                         /* just checked for length; strcpy is fine */
561                         strcpy(dst, entity);
562                         dst += len;
563                         ++string;
564                 }
565         }
566         /* Write null terminator */
567         *dst = '\0';
568         /* If any chars are left in string, return failure */
569         return *string == '\0' ? 0 : -1;
570 }
571
572 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
573 const char *ast_inet_ntoa(struct in_addr ia)
574 {
575         char *buf;
576
577         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
578                 return "";
579
580         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
581 }
582
583 static int dev_urandom_fd;
584
585 #ifndef __linux__
586 #undef pthread_create /* For ast_pthread_create function only */
587 #endif /* !__linux__ */
588
589 #if !defined(LOW_MEMORY)
590
591 #ifdef DEBUG_THREADS
592
593 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
594 #define AST_MAX_LOCKS 64
595
596 /* Allow direct use of pthread_mutex_t and friends */
597 #undef pthread_mutex_t
598 #undef pthread_mutex_lock
599 #undef pthread_mutex_unlock
600 #undef pthread_mutex_init
601 #undef pthread_mutex_destroy
602
603 /*!
604  * \brief Keep track of which locks a thread holds
605  *
606  * There is an instance of this struct for every active thread
607  */
608 struct thr_lock_info {
609         /*! The thread's ID */
610         pthread_t thread_id;
611         /*! The thread name which includes where the thread was started */
612         const char *thread_name;
613         /*! This is the actual container of info for what locks this thread holds */
614         struct {
615                 const char *file;
616                 const char *func;
617                 const char *lock_name;
618                 void *lock_addr;
619                 int times_locked;
620                 int line_num;
621                 enum ast_lock_type type;
622                 /*! This thread is waiting on this lock */
623                 int pending:2;
624                 /*! A condition has suspended this lock */
625                 int suspended:1;
626 #ifdef HAVE_BKTR
627                 struct ast_bt *backtrace;
628 #endif
629         } locks[AST_MAX_LOCKS];
630         /*! This is the number of locks currently held by this thread.
631          *  The index (num_locks - 1) has the info on the last one in the
632          *  locks member */
633         unsigned int num_locks;
634         /*! The LWP id (which GDB prints) */
635         int lwp;
636         /*! Protects the contents of the locks member
637          * Intentionally not ast_mutex_t */
638         pthread_mutex_t lock;
639         AST_LIST_ENTRY(thr_lock_info) entry;
640 };
641
642 /*!
643  * \brief Locked when accessing the lock_infos list
644  */
645 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
646 /*!
647  * \brief A list of each thread's lock info
648  */
649 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
650
651 /*!
652  * \brief Destroy a thread's lock info
653  *
654  * This gets called automatically when the thread stops
655  */
656 static void lock_info_destroy(void *data)
657 {
658         struct thr_lock_info *lock_info = data;
659         int i;
660
661         pthread_mutex_lock(&lock_infos_lock.mutex);
662         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
663         pthread_mutex_unlock(&lock_infos_lock.mutex);
664
665
666         for (i = 0; i < lock_info->num_locks; i++) {
667                 if (lock_info->locks[i].pending == -1) {
668                         /* This just means that the last lock this thread went for was by
669                          * using trylock, and it failed.  This is fine. */
670                         break;
671                 }
672
673                 ast_log(LOG_ERROR,
674                         "Thread '%s' still has a lock! - '%s' (%p) from '%s' in %s:%d!\n",
675                         lock_info->thread_name,
676                         lock_info->locks[i].lock_name,
677                         lock_info->locks[i].lock_addr,
678                         lock_info->locks[i].func,
679                         lock_info->locks[i].file,
680                         lock_info->locks[i].line_num
681                 );
682         }
683
684         pthread_mutex_destroy(&lock_info->lock);
685         if (lock_info->thread_name) {
686                 ast_free((void *) lock_info->thread_name);
687         }
688         ast_free(lock_info);
689 }
690
691 /*!
692  * \brief The thread storage key for per-thread lock info
693  */
694 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
695 #ifdef HAVE_BKTR
696 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
697         int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
698 #else
699 void ast_store_lock_info(enum ast_lock_type type, const char *filename,
700         int line_num, const char *func, const char *lock_name, void *lock_addr)
701 #endif
702 {
703         struct thr_lock_info *lock_info;
704         int i;
705
706         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
707                 return;
708
709         pthread_mutex_lock(&lock_info->lock);
710
711         for (i = 0; i < lock_info->num_locks; i++) {
712                 if (lock_info->locks[i].lock_addr == lock_addr) {
713                         lock_info->locks[i].times_locked++;
714 #ifdef HAVE_BKTR
715                         lock_info->locks[i].backtrace = bt;
716 #endif
717                         pthread_mutex_unlock(&lock_info->lock);
718                         return;
719                 }
720         }
721
722         if (lock_info->num_locks == AST_MAX_LOCKS) {
723                 /* Can't use ast_log here, because it will cause infinite recursion */
724                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
725                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
726                 pthread_mutex_unlock(&lock_info->lock);
727                 return;
728         }
729
730         if (i && lock_info->locks[i - 1].pending == -1) {
731                 /* The last lock on the list was one that this thread tried to lock but
732                  * failed at doing so.  It has now moved on to something else, so remove
733                  * the old lock from the list. */
734                 i--;
735                 lock_info->num_locks--;
736                 memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
737         }
738
739         lock_info->locks[i].file = filename;
740         lock_info->locks[i].line_num = line_num;
741         lock_info->locks[i].func = func;
742         lock_info->locks[i].lock_name = lock_name;
743         lock_info->locks[i].lock_addr = lock_addr;
744         lock_info->locks[i].times_locked = 1;
745         lock_info->locks[i].type = type;
746         lock_info->locks[i].pending = 1;
747 #ifdef HAVE_BKTR
748         lock_info->locks[i].backtrace = bt;
749 #endif
750         lock_info->num_locks++;
751
752         pthread_mutex_unlock(&lock_info->lock);
753 }
754
755 void ast_mark_lock_acquired(void *lock_addr)
756 {
757         struct thr_lock_info *lock_info;
758
759         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
760                 return;
761
762         pthread_mutex_lock(&lock_info->lock);
763         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
764                 lock_info->locks[lock_info->num_locks - 1].pending = 0;
765         }
766         pthread_mutex_unlock(&lock_info->lock);
767 }
768
769 void ast_mark_lock_failed(void *lock_addr)
770 {
771         struct thr_lock_info *lock_info;
772
773         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
774                 return;
775
776         pthread_mutex_lock(&lock_info->lock);
777         if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
778                 lock_info->locks[lock_info->num_locks - 1].pending = -1;
779                 lock_info->locks[lock_info->num_locks - 1].times_locked--;
780         }
781         pthread_mutex_unlock(&lock_info->lock);
782 }
783
784 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)
785 {
786         struct thr_lock_info *lock_info;
787         int i = 0;
788
789         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
790                 return -1;
791
792         pthread_mutex_lock(&lock_info->lock);
793
794         for (i = lock_info->num_locks - 1; i >= 0; i--) {
795                 if (lock_info->locks[i].lock_addr == lock_addr)
796                         break;
797         }
798
799         if (i == -1) {
800                 /* Lock not found :( */
801                 pthread_mutex_unlock(&lock_info->lock);
802                 return -1;
803         }
804
805         ast_copy_string(filename, lock_info->locks[i].file, filename_size);
806         *lineno = lock_info->locks[i].line_num;
807         ast_copy_string(func, lock_info->locks[i].func, func_size);
808         ast_copy_string(mutex_name, lock_info->locks[i].lock_name, mutex_name_size);
809
810         pthread_mutex_unlock(&lock_info->lock);
811
812         return 0;
813 }
814
815 void ast_suspend_lock_info(void *lock_addr)
816 {
817         struct thr_lock_info *lock_info;
818         int i = 0;
819
820         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info)))) {
821                 return;
822         }
823
824         pthread_mutex_lock(&lock_info->lock);
825
826         for (i = lock_info->num_locks - 1; i >= 0; i--) {
827                 if (lock_info->locks[i].lock_addr == lock_addr)
828                         break;
829         }
830
831         if (i == -1) {
832                 /* Lock not found :( */
833                 pthread_mutex_unlock(&lock_info->lock);
834                 return;
835         }
836
837         lock_info->locks[i].suspended = 1;
838
839         pthread_mutex_unlock(&lock_info->lock);
840 }
841
842 void ast_restore_lock_info(void *lock_addr)
843 {
844         struct thr_lock_info *lock_info;
845         int i = 0;
846
847         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
848                 return;
849
850         pthread_mutex_lock(&lock_info->lock);
851
852         for (i = lock_info->num_locks - 1; i >= 0; i--) {
853                 if (lock_info->locks[i].lock_addr == lock_addr)
854                         break;
855         }
856
857         if (i == -1) {
858                 /* Lock not found :( */
859                 pthread_mutex_unlock(&lock_info->lock);
860                 return;
861         }
862
863         lock_info->locks[i].suspended = 0;
864
865         pthread_mutex_unlock(&lock_info->lock);
866 }
867
868
869 #ifdef HAVE_BKTR
870 void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt)
871 #else
872 void ast_remove_lock_info(void *lock_addr)
873 #endif
874 {
875         struct thr_lock_info *lock_info;
876         int i = 0;
877
878         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
879                 return;
880
881         pthread_mutex_lock(&lock_info->lock);
882
883         for (i = lock_info->num_locks - 1; i >= 0; i--) {
884                 if (lock_info->locks[i].lock_addr == lock_addr)
885                         break;
886         }
887
888         if (i == -1) {
889                 /* Lock not found :( */
890                 pthread_mutex_unlock(&lock_info->lock);
891                 return;
892         }
893
894         if (lock_info->locks[i].times_locked > 1) {
895                 lock_info->locks[i].times_locked--;
896 #ifdef HAVE_BKTR
897                 lock_info->locks[i].backtrace = bt;
898 #endif
899                 pthread_mutex_unlock(&lock_info->lock);
900                 return;
901         }
902
903         if (i < lock_info->num_locks - 1) {
904                 /* Not the last one ... *should* be rare! */
905                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1],
906                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
907         }
908
909         lock_info->num_locks--;
910
911         pthread_mutex_unlock(&lock_info->lock);
912 }
913
914 static const char *locktype2str(enum ast_lock_type type)
915 {
916         switch (type) {
917         case AST_MUTEX:
918                 return "MUTEX";
919         case AST_RDLOCK:
920                 return "RDLOCK";
921         case AST_WRLOCK:
922                 return "WRLOCK";
923         }
924
925         return "UNKNOWN";
926 }
927
928 #ifdef HAVE_BKTR
929 static void append_backtrace_information(struct ast_str **str, struct ast_bt *bt)
930 {
931         char **symbols;
932         int num_frames;
933
934         if (!bt) {
935                 ast_str_append(str, 0, "\tNo backtrace to print\n");
936                 return;
937         }
938
939         /* store frame count locally to avoid the memory corruption that
940          * sometimes happens on virtualized CentOS 6.x systems */
941         num_frames = bt->num_frames;
942         if ((symbols = ast_bt_get_symbols(bt->addresses, num_frames))) {
943                 int frame_iterator;
944
945                 for (frame_iterator = 0; frame_iterator < num_frames; ++frame_iterator) {
946                         ast_str_append(str, 0, "\t%s\n", symbols[frame_iterator]);
947                 }
948
949                 ast_std_free(symbols);
950         } else {
951                 ast_str_append(str, 0, "\tCouldn't retrieve backtrace symbols\n");
952         }
953 }
954 #endif
955
956 static void append_lock_information(struct ast_str **str, struct thr_lock_info *lock_info, int i)
957 {
958         int j;
959         ast_mutex_t *lock;
960         struct ast_lock_track *lt;
961
962         ast_str_append(str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d%s)\n",
963                                    lock_info->locks[i].pending > 0 ? "Waiting for " :
964                                    lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
965                                    lock_info->locks[i].file,
966                                    locktype2str(lock_info->locks[i].type),
967                                    lock_info->locks[i].line_num,
968                                    lock_info->locks[i].func, lock_info->locks[i].lock_name,
969                                    lock_info->locks[i].lock_addr,
970                                    lock_info->locks[i].times_locked,
971                                    lock_info->locks[i].suspended ? " - suspended" : "");
972 #ifdef HAVE_BKTR
973         append_backtrace_information(str, lock_info->locks[i].backtrace);
974 #endif
975
976         if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
977                 return;
978
979         /* We only have further details for mutexes right now */
980         if (lock_info->locks[i].type != AST_MUTEX)
981                 return;
982
983         lock = lock_info->locks[i].lock_addr;
984         lt = lock->track;
985         ast_reentrancy_lock(lt);
986         for (j = 0; *str && j < lt->reentrancy; j++) {
987                 ast_str_append(str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
988                                            lt->file[j], lt->lineno[j], lt->func[j]);
989         }
990         ast_reentrancy_unlock(lt);
991 }
992
993
994 /*! This function can help you find highly temporal locks; locks that happen for a
995     short time, but at unexpected times, usually at times that create a deadlock,
996         Why is this thing locked right then? Who is locking it? Who am I fighting
997     with for this lock?
998
999         To answer such questions, just call this routine before you would normally try
1000         to aquire a lock. It doesn't do anything if the lock is not acquired. If the
1001         lock is taken, it will publish a line or two to the console via ast_log().
1002
1003         Sometimes, the lock message is pretty uninformative. For instance, you might
1004         find that the lock is being aquired deep within the astobj2 code; this tells
1005         you little about higher level routines that call the astobj2 routines.
1006         But, using gdb, you can set a break at the ast_log below, and for that
1007         breakpoint, you can set the commands:
1008           where
1009           cont
1010         which will give a stack trace and continue. -- that aught to do the job!
1011
1012 */
1013 void ast_log_show_lock(void *this_lock_addr)
1014 {
1015         struct thr_lock_info *lock_info;
1016         struct ast_str *str;
1017
1018         if (!(str = ast_str_create(4096))) {
1019                 ast_log(LOG_NOTICE,"Could not create str\n");
1020                 return;
1021         }
1022
1023
1024         pthread_mutex_lock(&lock_infos_lock.mutex);
1025         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
1026                 int i;
1027                 pthread_mutex_lock(&lock_info->lock);
1028                 for (i = 0; str && i < lock_info->num_locks; i++) {
1029                         /* ONLY show info about this particular lock, if
1030                            it's acquired... */
1031                         if (lock_info->locks[i].lock_addr == this_lock_addr) {
1032                                 append_lock_information(&str, lock_info, i);
1033                                 ast_log(LOG_NOTICE, "%s", ast_str_buffer(str));
1034                                 break;
1035                         }
1036                 }
1037                 pthread_mutex_unlock(&lock_info->lock);
1038         }
1039         pthread_mutex_unlock(&lock_infos_lock.mutex);
1040         ast_free(str);
1041 }
1042
1043
1044 struct ast_str *ast_dump_locks(void)
1045 {
1046         struct thr_lock_info *lock_info;
1047         struct ast_str *str;
1048
1049         if (!(str = ast_str_create(4096))) {
1050                 return NULL;
1051         }
1052
1053         ast_str_append(&str, 0, "\n"
1054                        "=======================================================================\n"
1055                        "=== %s\n"
1056                        "=== Currently Held Locks\n"
1057                        "=======================================================================\n"
1058                        "===\n"
1059                        "=== <pending> <lock#> (<file>): <lock type> <line num> <function> <lock name> <lock addr> (times locked)\n"
1060                        "===\n", ast_get_version());
1061
1062         if (!str) {
1063                 return NULL;
1064         }
1065
1066         pthread_mutex_lock(&lock_infos_lock.mutex);
1067         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
1068                 int i;
1069                 int header_printed = 0;
1070                 pthread_mutex_lock(&lock_info->lock);
1071                 for (i = 0; str && i < lock_info->num_locks; i++) {
1072                         /* Don't show suspended locks */
1073                         if (lock_info->locks[i].suspended) {
1074                                 continue;
1075                         }
1076
1077                         if (!header_printed) {
1078                                 if (lock_info->lwp != -1) {
1079                                         ast_str_append(&str, 0, "=== Thread ID: 0x%lx LWP:%d (%s)\n",
1080                                                 (long unsigned) lock_info->thread_id, lock_info->lwp, lock_info->thread_name);
1081                                 } else {
1082                                         ast_str_append(&str, 0, "=== Thread ID: 0x%lx (%s)\n",
1083                                                 (long unsigned) lock_info->thread_id, lock_info->thread_name);
1084                                 }
1085                                 header_printed = 1;
1086                         }
1087
1088                         append_lock_information(&str, lock_info, i);
1089                 }
1090                 pthread_mutex_unlock(&lock_info->lock);
1091                 if (!str) {
1092                         break;
1093                 }
1094                 if (header_printed) {
1095                         ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
1096                                 "===\n");
1097                 }
1098                 if (!str) {
1099                         break;
1100                 }
1101         }
1102         pthread_mutex_unlock(&lock_infos_lock.mutex);
1103
1104         if (!str) {
1105                 return NULL;
1106         }
1107
1108         ast_str_append(&str, 0, "=======================================================================\n"
1109                        "\n");
1110
1111         return str;
1112 }
1113
1114 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1115 {
1116         struct ast_str *str;
1117
1118         switch (cmd) {
1119         case CLI_INIT:
1120                 e->command = "core show locks";
1121                 e->usage =
1122                         "Usage: core show locks\n"
1123                         "       This command is for lock debugging.  It prints out which locks\n"
1124                         "are owned by each active thread.\n";
1125                 return NULL;
1126
1127         case CLI_GENERATE:
1128                 return NULL;
1129         }
1130
1131         str = ast_dump_locks();
1132         if (!str) {
1133                 return CLI_FAILURE;
1134         }
1135
1136         ast_cli(a->fd, "%s", ast_str_buffer(str));
1137
1138         ast_free(str);
1139
1140         return CLI_SUCCESS;
1141 }
1142
1143 static struct ast_cli_entry utils_cli[] = {
1144         AST_CLI_DEFINE(handle_show_locks, "Show which locks are held by which thread"),
1145 };
1146
1147 #endif /* DEBUG_THREADS */
1148
1149 /*
1150  * support for 'show threads'. The start routine is wrapped by
1151  * dummy_start(), so that ast_register_thread() and
1152  * ast_unregister_thread() know the thread identifier.
1153  */
1154 struct thr_arg {
1155         void *(*start_routine)(void *);
1156         void *data;
1157         char *name;
1158 };
1159
1160 /*
1161  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
1162  * are odd macros which start and end a block, so they _must_ be
1163  * used in pairs (the latter with a '1' argument to call the
1164  * handler on exit.
1165  * On BSD we don't need this, but we keep it for compatibility.
1166  */
1167 static void *dummy_start(void *data)
1168 {
1169         void *ret;
1170         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
1171 #ifdef DEBUG_THREADS
1172         struct thr_lock_info *lock_info;
1173         pthread_mutexattr_t mutex_attr;
1174
1175         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
1176                 return NULL;
1177
1178         lock_info->thread_id = pthread_self();
1179         lock_info->lwp = ast_get_tid();
1180         lock_info->thread_name = strdup(a.name);
1181
1182         pthread_mutexattr_init(&mutex_attr);
1183         pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
1184         pthread_mutex_init(&lock_info->lock, &mutex_attr);
1185         pthread_mutexattr_destroy(&mutex_attr);
1186
1187         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1188         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
1189         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
1190 #endif /* DEBUG_THREADS */
1191
1192         /* note that even though data->name is a pointer to allocated memory,
1193            we are not freeing it here because ast_register_thread is going to
1194            keep a copy of the pointer and then ast_unregister_thread will
1195            free the memory
1196         */
1197         ast_free(data);
1198         ast_register_thread(a.name);
1199         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
1200
1201         ret = a.start_routine(a.data);
1202
1203         pthread_cleanup_pop(1);
1204
1205         return ret;
1206 }
1207
1208 #endif /* !LOW_MEMORY */
1209
1210 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1211                              void *data, size_t stacksize, const char *file, const char *caller,
1212                              int line, const char *start_fn)
1213 {
1214 #if !defined(LOW_MEMORY)
1215         struct thr_arg *a;
1216 #endif
1217
1218         if (!attr) {
1219                 attr = ast_alloca(sizeof(*attr));
1220                 pthread_attr_init(attr);
1221         }
1222
1223 #ifdef __linux__
1224         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
1225            which is kind of useless. Change this here to
1226            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
1227            priority will propagate down to new threads by default.
1228            This does mean that callers cannot set a different priority using
1229            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
1230            the priority afterwards with pthread_setschedparam(). */
1231         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
1232                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
1233 #endif
1234
1235         if (!stacksize)
1236                 stacksize = AST_STACKSIZE;
1237
1238         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
1239                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
1240
1241 #if !defined(LOW_MEMORY)
1242         if ((a = ast_malloc(sizeof(*a)))) {
1243                 a->start_routine = start_routine;
1244                 a->data = data;
1245                 start_routine = dummy_start;
1246                 if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()",
1247                              start_fn, line, file, caller) < 0) {
1248                         a->name = NULL;
1249                 }
1250                 data = a;
1251         }
1252 #endif /* !LOW_MEMORY */
1253
1254         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
1255 }
1256
1257
1258 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
1259                              void *data, size_t stacksize, const char *file, const char *caller,
1260                              int line, const char *start_fn)
1261 {
1262         unsigned char attr_destroy = 0;
1263         int res;
1264
1265         if (!attr) {
1266                 attr = ast_alloca(sizeof(*attr));
1267                 pthread_attr_init(attr);
1268                 attr_destroy = 1;
1269         }
1270
1271         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
1272                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
1273
1274         res = ast_pthread_create_stack(thread, attr, start_routine, data,
1275                                        stacksize, file, caller, line, start_fn);
1276
1277         if (attr_destroy)
1278                 pthread_attr_destroy(attr);
1279
1280         return res;
1281 }
1282
1283 int ast_wait_for_input(int fd, int ms)
1284 {
1285         struct pollfd pfd[1];
1286
1287         memset(pfd, 0, sizeof(pfd));
1288         pfd[0].fd = fd;
1289         pfd[0].events = POLLIN | POLLPRI;
1290         return ast_poll(pfd, 1, ms);
1291 }
1292
1293 int ast_wait_for_output(int fd, int ms)
1294 {
1295         struct pollfd pfd[1];
1296
1297         memset(pfd, 0, sizeof(pfd));
1298         pfd[0].fd = fd;
1299         pfd[0].events = POLLOUT;
1300         return ast_poll(pfd, 1, ms);
1301 }
1302
1303 static int wait_for_output(int fd, int timeoutms)
1304 {
1305         struct pollfd pfd = {
1306                 .fd = fd,
1307                 .events = POLLOUT,
1308         };
1309         int res;
1310         struct timeval start = ast_tvnow();
1311         int elapsed = 0;
1312
1313         /* poll() until the fd is writable without blocking */
1314         while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
1315                 if (res == 0) {
1316                         /* timed out. */
1317 #ifndef STANDALONE
1318                         ast_debug(1, "Timed out trying to write\n");
1319 #endif
1320                         return -1;
1321                 } else if (res == -1) {
1322                         /* poll() returned an error, check to see if it was fatal */
1323
1324                         if (errno == EINTR || errno == EAGAIN) {
1325                                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1326                                 if (elapsed >= timeoutms) {
1327                                         return -1;
1328                                 }
1329                                 /* This was an acceptable error, go back into poll() */
1330                                 continue;
1331                         }
1332
1333                         /* Fatal error, bail. */
1334                         ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
1335
1336                         return -1;
1337                 }
1338                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1339                 if (elapsed >= timeoutms) {
1340                         return -1;
1341                 }
1342         }
1343
1344         return 0;
1345 }
1346
1347 /*!
1348  * Try to write string, but wait no more than ms milliseconds before timing out.
1349  *
1350  * \note The code assumes that the file descriptor has NONBLOCK set,
1351  * so there is only one system call made to do a write, unless we actually
1352  * have a need to wait.  This way, we get better performance.
1353  * If the descriptor is blocking, all assumptions on the guaranteed
1354  * detail do not apply anymore.
1355  */
1356 int ast_carefulwrite(int fd, char *s, int len, int timeoutms)
1357 {
1358         struct timeval start = ast_tvnow();
1359         int res = 0;
1360         int elapsed = 0;
1361
1362         while (len) {
1363                 if (wait_for_output(fd, timeoutms - elapsed)) {
1364                         return -1;
1365                 }
1366
1367                 res = write(fd, s, len);
1368
1369                 if (res < 0 && errno != EAGAIN && errno != EINTR) {
1370                         /* fatal error from write() */
1371                         ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
1372                         return -1;
1373                 }
1374
1375                 if (res < 0) {
1376                         /* It was an acceptable error */
1377                         res = 0;
1378                 }
1379
1380                 /* Update how much data we have left to write */
1381                 len -= res;
1382                 s += res;
1383                 res = 0;
1384
1385                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1386                 if (elapsed >= timeoutms) {
1387                         /* We've taken too long to write
1388                          * This is only an error condition if we haven't finished writing. */
1389                         res = len ? -1 : 0;
1390                         break;
1391                 }
1392         }
1393
1394         return res;
1395 }
1396
1397 int ast_careful_fwrite(FILE *f, int fd, const char *src, size_t len, int timeoutms)
1398 {
1399         struct timeval start = ast_tvnow();
1400         int n = 0;
1401         int elapsed = 0;
1402
1403         while (len) {
1404                 if (wait_for_output(fd, timeoutms - elapsed)) {
1405                         /* poll returned a fatal error, so bail out immediately. */
1406                         return -1;
1407                 }
1408
1409                 /* Clear any errors from a previous write */
1410                 clearerr(f);
1411
1412                 n = fwrite(src, 1, len, f);
1413
1414                 if (ferror(f) && errno != EINTR && errno != EAGAIN) {
1415                         /* fatal error from fwrite() */
1416                         if (!feof(f)) {
1417                                 /* Don't spam the logs if it was just that the connection is closed. */
1418                                 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
1419                         }
1420                         n = -1;
1421                         break;
1422                 }
1423
1424                 /* Update for data already written to the socket */
1425                 len -= n;
1426                 src += n;
1427
1428                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
1429                 if (elapsed >= timeoutms) {
1430                         /* We've taken too long to write
1431                          * This is only an error condition if we haven't finished writing. */
1432                         n = len ? -1 : 0;
1433                         break;
1434                 }
1435         }
1436
1437         errno = 0;
1438         while (fflush(f)) {
1439                 if (errno == EAGAIN || errno == EINTR) {
1440                         /* fflush() does not appear to reset errno if it flushes
1441                          * and reaches EOF at the same time. It returns EOF with
1442                          * the last seen value of errno, causing a possible loop.
1443                          * Also usleep() to reduce CPU eating if it does loop */
1444                         errno = 0;
1445                         usleep(1);
1446                         continue;
1447                 }
1448                 if (errno && !feof(f)) {
1449                         /* Don't spam the logs if it was just that the connection is closed. */
1450                         ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
1451                 }
1452                 n = -1;
1453                 break;
1454         }
1455
1456         return n < 0 ? -1 : 0;
1457 }
1458
1459 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
1460 {
1461         char *e;
1462         char *q;
1463
1464         s = ast_strip(s);
1465         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
1466                 e = s + strlen(s) - 1;
1467                 if (*e == *(end_quotes + (q - beg_quotes))) {
1468                         s++;
1469                         *e = '\0';
1470                 }
1471         }
1472
1473         return s;
1474 }
1475
1476 char *ast_unescape_semicolon(char *s)
1477 {
1478         char *e;
1479         char *work = s;
1480
1481         while ((e = strchr(work, ';'))) {
1482                 if ((e > work) && (*(e-1) == '\\')) {
1483                         memmove(e - 1, e, strlen(e) + 1);
1484                         work = e;
1485                 } else {
1486                         work = e + 1;
1487                 }
1488         }
1489
1490         return s;
1491 }
1492
1493 /* !\brief unescape some C sequences in place, return pointer to the original string.
1494  */
1495 char *ast_unescape_c(char *src)
1496 {
1497         char c, *ret, *dst;
1498
1499         if (src == NULL)
1500                 return NULL;
1501         for (ret = dst = src; (c = *src++); *dst++ = c ) {
1502                 if (c != '\\')
1503                         continue;       /* copy char at the end of the loop */
1504                 switch ((c = *src++)) {
1505                 case '\0':      /* special, trailing '\' */
1506                         c = '\\';
1507                         break;
1508                 case 'b':       /* backspace */
1509                         c = '\b';
1510                         break;
1511                 case 'f':       /* form feed */
1512                         c = '\f';
1513                         break;
1514                 case 'n':
1515                         c = '\n';
1516                         break;
1517                 case 'r':
1518                         c = '\r';
1519                         break;
1520                 case 't':
1521                         c = '\t';
1522                         break;
1523                 }
1524                 /* default, use the char literally */
1525         }
1526         *dst = '\0';
1527         return ret;
1528 }
1529
1530 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
1531 {
1532         int result;
1533
1534         if (!buffer || !*buffer || !space || !*space)
1535                 return -1;
1536
1537         result = vsnprintf(*buffer, *space, fmt, ap);
1538
1539         if (result < 0)
1540                 return -1;
1541         else if (result > *space)
1542                 result = *space;
1543
1544         *buffer += result;
1545         *space -= result;
1546         return 0;
1547 }
1548
1549 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
1550 {
1551         va_list ap;
1552         int result;
1553
1554         va_start(ap, fmt);
1555         result = ast_build_string_va(buffer, space, fmt, ap);
1556         va_end(ap);
1557
1558         return result;
1559 }
1560
1561 int ast_regex_string_to_regex_pattern(const char *regex_string, struct ast_str **regex_pattern)
1562 {
1563         int regex_len = strlen(regex_string);
1564         int ret = 3;
1565
1566         /* Chop off the leading / if there is one */
1567         if ((regex_len >= 1) && (regex_string[0] == '/')) {
1568                 ast_str_set(regex_pattern, 0, "%s", regex_string + 1);
1569                 ret -= 2;
1570         }
1571
1572         /* Chop off the ending / if there is one */
1573         if ((regex_len > 1) && (regex_string[regex_len - 1] == '/')) {
1574                 ast_str_truncate(*regex_pattern, -1);
1575                 ret -= 1;
1576         }
1577
1578         return ret;
1579 }
1580
1581 int ast_true(const char *s)
1582 {
1583         if (ast_strlen_zero(s))
1584                 return 0;
1585
1586         /* Determine if this is a true value */
1587         if (!strcasecmp(s, "yes") ||
1588             !strcasecmp(s, "true") ||
1589             !strcasecmp(s, "y") ||
1590             !strcasecmp(s, "t") ||
1591             !strcasecmp(s, "1") ||
1592             !strcasecmp(s, "on"))
1593                 return -1;
1594
1595         return 0;
1596 }
1597
1598 int ast_false(const char *s)
1599 {
1600         if (ast_strlen_zero(s))
1601                 return 0;
1602
1603         /* Determine if this is a false value */
1604         if (!strcasecmp(s, "no") ||
1605             !strcasecmp(s, "false") ||
1606             !strcasecmp(s, "n") ||
1607             !strcasecmp(s, "f") ||
1608             !strcasecmp(s, "0") ||
1609             !strcasecmp(s, "off"))
1610                 return -1;
1611
1612         return 0;
1613 }
1614
1615 #define ONE_MILLION     1000000
1616 /*
1617  * put timeval in a valid range. usec is 0..999999
1618  * negative values are not allowed and truncated.
1619  */
1620 static struct timeval tvfix(struct timeval a)
1621 {
1622         if (a.tv_usec >= ONE_MILLION) {
1623                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1624                         (long)a.tv_sec, (long int) a.tv_usec);
1625                 a.tv_sec += a.tv_usec / ONE_MILLION;
1626                 a.tv_usec %= ONE_MILLION;
1627         } else if (a.tv_usec < 0) {
1628                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1629                         (long)a.tv_sec, (long int) a.tv_usec);
1630                 a.tv_usec = 0;
1631         }
1632         return a;
1633 }
1634
1635 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1636 {
1637         /* consistency checks to guarantee usec in 0..999999 */
1638         a = tvfix(a);
1639         b = tvfix(b);
1640         a.tv_sec += b.tv_sec;
1641         a.tv_usec += b.tv_usec;
1642         if (a.tv_usec >= ONE_MILLION) {
1643                 a.tv_sec++;
1644                 a.tv_usec -= ONE_MILLION;
1645         }
1646         return a;
1647 }
1648
1649 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1650 {
1651         /* consistency checks to guarantee usec in 0..999999 */
1652         a = tvfix(a);
1653         b = tvfix(b);
1654         a.tv_sec -= b.tv_sec;
1655         a.tv_usec -= b.tv_usec;
1656         if (a.tv_usec < 0) {
1657                 a.tv_sec-- ;
1658                 a.tv_usec += ONE_MILLION;
1659         }
1660         return a;
1661 }
1662
1663 int ast_remaining_ms(struct timeval start, int max_ms)
1664 {
1665         int ms;
1666
1667         if (max_ms < 0) {
1668                 ms = max_ms;
1669         } else {
1670                 ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start);
1671                 if (ms < 0) {
1672                         ms = 0;
1673                 }
1674         }
1675
1676         return ms;
1677 }
1678
1679 void ast_format_duration_hh_mm_ss(int duration, char *buf, size_t length)
1680 {
1681         int durh, durm, durs;
1682         durh = duration / 3600;
1683         durm = (duration % 3600) / 60;
1684         durs = duration % 60;
1685         snprintf(buf, length, "%02d:%02d:%02d", durh, durm, durs);
1686 }
1687
1688 #undef ONE_MILLION
1689
1690 #ifndef linux
1691 AST_MUTEX_DEFINE_STATIC(randomlock);
1692 #endif
1693
1694 long int ast_random(void)
1695 {
1696         long int res;
1697
1698         if (dev_urandom_fd >= 0) {
1699                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1700                 if (read_res > 0) {
1701                         long int rm = RAND_MAX;
1702                         res = res < 0 ? ~res : res;
1703                         rm++;
1704                         return res % rm;
1705                 }
1706         }
1707
1708         /* XXX - Thread safety really depends on the libc, not the OS.
1709          *
1710          * But... popular Linux libc's (uClibc, glibc, eglibc), all have a
1711          * somewhat thread safe random(3) (results are random, but not
1712          * reproducible). The libc's for other systems (BSD, et al.), not so
1713          * much.
1714          */
1715 #ifdef linux
1716         res = random();
1717 #else
1718         ast_mutex_lock(&randomlock);
1719         res = random();
1720         ast_mutex_unlock(&randomlock);
1721 #endif
1722         return res;
1723 }
1724
1725 void ast_replace_subargument_delimiter(char *s)
1726 {
1727         for (; *s; s++) {
1728                 if (*s == '^') {
1729                         *s = ',';
1730                 }
1731         }
1732 }
1733
1734 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1735 {
1736         char *dataPut = start;
1737         int inEscape = 0;
1738         int inQuotes = 0;
1739
1740         for (; *start; start++) {
1741                 if (inEscape) {
1742                         *dataPut++ = *start;       /* Always goes verbatim */
1743                         inEscape = 0;
1744                 } else {
1745                         if (*start == '\\') {
1746                                 inEscape = 1;      /* Do not copy \ into the data */
1747                         } else if (*start == '\'') {
1748                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1749                         } else {
1750                                 /* Replace , with |, unless in quotes */
1751                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1752                         }
1753                 }
1754         }
1755         if (start != dataPut)
1756                 *dataPut = 0;
1757         return dataPut;
1758 }
1759
1760 void ast_join_delim(char *s, size_t len, const char * const w[], unsigned int size, char delim)
1761 {
1762         int x, ofs = 0;
1763         const char *src;
1764
1765         /* Join words into a string */
1766         if (!s)
1767                 return;
1768         for (x = 0; ofs < len && w[x] && x < size; x++) {
1769                 if (x > 0)
1770                         s[ofs++] = delim;
1771                 for (src = w[x]; *src && ofs < len; src++)
1772                         s[ofs++] = *src;
1773         }
1774         if (ofs == len)
1775                 ofs--;
1776         s[ofs] = '\0';
1777 }
1778
1779 char *ast_to_camel_case_delim(const char *s, const char *delim)
1780 {
1781         char *res = ast_strdup(s);
1782         char *front, *back, *buf = res;
1783         int size;
1784
1785         front = strtok_r(buf, delim, &back);
1786
1787         while (front) {
1788                 size = strlen(front);
1789                 *front = toupper(*front);
1790                 ast_copy_string(buf, front, size + 1);
1791                 buf += size;
1792                 front = strtok_r(NULL, delim, &back);
1793         }
1794
1795         return res;
1796 }
1797
1798 /*
1799  * stringfields support routines.
1800  */
1801
1802 /* this is a little complex... string fields are stored with their
1803    allocated size in the bytes preceding the string; even the
1804    constant 'empty' string has to be this way, so the code that
1805    checks to see if there is enough room for a new string doesn't
1806    have to have any special case checks
1807 */
1808
1809 static const struct {
1810         ast_string_field_allocation allocation;
1811         char string[1];
1812 } __ast_string_field_empty_buffer;
1813
1814 ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string;
1815
1816 #define ALLOCATOR_OVERHEAD 48
1817
1818 static size_t optimal_alloc_size(size_t size)
1819 {
1820         unsigned int count;
1821
1822         size += ALLOCATOR_OVERHEAD;
1823
1824         for (count = 1; size; size >>= 1, count++);
1825
1826         return (1 << count) - ALLOCATOR_OVERHEAD;
1827 }
1828
1829 /*! \brief add a new block to the pool.
1830  * We can only allocate from the topmost pool, so the
1831  * fields in *mgr reflect the size of that only.
1832  */
1833 static int add_string_pool(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1834                            size_t size, const char *file, int lineno, const char *func)
1835 {
1836         struct ast_string_field_pool *pool;
1837         size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);
1838
1839 #if defined(__AST_DEBUG_MALLOC)
1840         if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) {
1841                 return -1;
1842         }
1843 #else
1844         if (!(pool = ast_calloc(1, alloc_size))) {
1845                 return -1;
1846         }
1847 #endif
1848
1849         pool->prev = *pool_head;
1850         pool->size = alloc_size - sizeof(*pool);
1851         *pool_head = pool;
1852         mgr->last_alloc = NULL;
1853
1854         return 0;
1855 }
1856
1857 /*
1858  * This is an internal API, code should not use it directly.
1859  * It initializes all fields as empty, then uses 'size' for 3 functions:
1860  * size > 0 means initialize the pool list with a pool of given size.
1861  *      This must be called right after allocating the object.
1862  * size = 0 means release all pools except the most recent one.
1863  *      If the first pool was allocated via embedding in another
1864  *      object, that pool will be preserved instead.
1865  *      This is useful to e.g. reset an object to the initial value.
1866  * size < 0 means release all pools.
1867  *      This must be done before destroying the object.
1868  */
1869 int __ast_string_field_init(struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head,
1870                             int needed, const char *file, int lineno, const char *func)
1871 {
1872         const char **p = (const char **) pool_head + 1;
1873         struct ast_string_field_pool *cur = NULL;
1874         struct ast_string_field_pool *preserve = NULL;
1875
1876         /* clear fields - this is always necessary */
1877         while ((struct ast_string_field_mgr *) p != mgr) {
1878                 *p++ = __ast_string_field_empty;
1879         }
1880
1881         mgr->last_alloc = NULL;
1882 #if defined(__AST_DEBUG_MALLOC)
1883         mgr->owner_file = file;
1884         mgr->owner_func = func;
1885         mgr->owner_line = lineno;
1886 #endif
1887         if (needed > 0) {               /* allocate the initial pool */
1888                 *pool_head = NULL;
1889                 mgr->embedded_pool = NULL;
1890                 return add_string_pool(mgr, pool_head, needed, file, lineno, func);
1891         }
1892
1893         /* if there is an embedded pool, we can't actually release *all*
1894          * pools, we must keep the embedded one. if the caller is about
1895          * to free the structure that contains the stringfield manager
1896          * and embedded pool anyway, it will be freed as part of that
1897          * operation.
1898          */
1899         if ((needed < 0) && mgr->embedded_pool) {
1900                 needed = 0;
1901         }
1902
1903         if (needed < 0) {               /* reset all pools */
1904                 cur = *pool_head;
1905         } else if (mgr->embedded_pool) { /* preserve the embedded pool */
1906                 preserve = mgr->embedded_pool;
1907                 cur = *pool_head;
1908         } else {                        /* preserve the last pool */
1909                 if (*pool_head == NULL) {
1910                         ast_log(LOG_WARNING, "trying to reset empty pool\n");
1911                         return -1;
1912                 }
1913                 preserve = *pool_head;
1914                 cur = preserve->prev;
1915         }
1916
1917         if (preserve) {
1918                 preserve->prev = NULL;
1919                 preserve->used = preserve->active = 0;
1920         }
1921
1922         while (cur) {
1923                 struct ast_string_field_pool *prev = cur->prev;
1924
1925                 if (cur != preserve) {
1926                         ast_free(cur);
1927                 }
1928                 cur = prev;
1929         }
1930
1931         *pool_head = preserve;
1932
1933         return 0;
1934 }
1935
1936 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr,
1937                                                 struct ast_string_field_pool **pool_head, size_t needed)
1938 {
1939         char *result = NULL;
1940         size_t space = (*pool_head)->size - (*pool_head)->used;
1941         size_t to_alloc;
1942
1943         /* Make room for ast_string_field_allocation and make it a multiple of that. */
1944         to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
1945         ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);
1946
1947         if (__builtin_expect(to_alloc > space, 0)) {
1948                 size_t new_size = (*pool_head)->size;
1949
1950                 while (new_size < to_alloc) {
1951                         new_size *= 2;
1952                 }
1953
1954 #if defined(__AST_DEBUG_MALLOC)
1955                 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
1956                         return NULL;
1957 #else
1958                 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__))
1959                         return NULL;
1960 #endif
1961         }
1962
1963         /* pool->base is always aligned (gcc aligned attribute). We ensure that
1964          * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
1965          * causing result to always be aligned as well; which in turn fixes that
1966          * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
1967         result = (*pool_head)->base + (*pool_head)->used;
1968         (*pool_head)->used += to_alloc;
1969         (*pool_head)->active += needed;
1970         result += ast_alignof(ast_string_field_allocation);
1971         AST_STRING_FIELD_ALLOCATION(result) = needed;
1972         mgr->last_alloc = result;
1973
1974         return result;
1975 }
1976
1977 int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr,
1978                                 struct ast_string_field_pool **pool_head, size_t needed,
1979                                 const ast_string_field *ptr)
1980 {
1981         ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
1982         size_t space = (*pool_head)->size - (*pool_head)->used;
1983
1984         if (*ptr != mgr->last_alloc) {
1985                 return 1;
1986         }
1987
1988         if (space < grow) {
1989                 return 1;
1990         }
1991
1992         (*pool_head)->used += grow;
1993         (*pool_head)->active += grow;
1994         AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
1995
1996         return 0;
1997 }
1998
1999 void __ast_string_field_release_active(struct ast_string_field_pool *pool_head,
2000                                        const ast_string_field ptr)
2001 {
2002         struct ast_string_field_pool *pool, *prev;
2003
2004         if (ptr == __ast_string_field_empty) {
2005                 return;
2006         }
2007
2008         for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
2009                 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
2010                         pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
2011                         if ((pool->active == 0) && prev) {
2012                                 prev->prev = pool->prev;
2013                                 ast_free(pool);
2014                         }
2015                         break;
2016                 }
2017         }
2018 }
2019
2020 void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
2021                                      struct ast_string_field_pool **pool_head,
2022                                      ast_string_field *ptr, const char *format, va_list ap)
2023 {
2024         size_t needed;
2025         size_t available;
2026         size_t space = (*pool_head)->size - (*pool_head)->used;
2027         int res;
2028         ssize_t grow;
2029         char *target;
2030         va_list ap2;
2031
2032         /* if the field already has space allocated, try to reuse it;
2033            otherwise, try to use the empty space at the end of the current
2034            pool
2035         */
2036         if (*ptr != __ast_string_field_empty) {
2037                 target = (char *) *ptr;
2038                 available = AST_STRING_FIELD_ALLOCATION(*ptr);
2039                 if (*ptr == mgr->last_alloc) {
2040                         available += space;
2041                 }
2042         } else {
2043                 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
2044                  * so we don't need to re-align anything here.
2045                  */
2046                 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
2047                 if (space > ast_alignof(ast_string_field_allocation)) {
2048                         available = space - ast_alignof(ast_string_field_allocation);
2049                 } else {
2050                         available = 0;
2051                 }
2052         }
2053
2054         va_copy(ap2, ap);
2055         res = vsnprintf(target, available, format, ap2);
2056         va_end(ap2);
2057
2058         if (res < 0) {
2059                 /* Are we out of memory? */
2060                 return;
2061         }
2062         needed = (size_t)res + 1; /* NUL byte */
2063
2064         if (needed > available) {
2065                 /* the allocation could not be satisfied using the field's current allocation
2066                    (if it has one), or the space available in the pool (if it does not). allocate
2067                    space for it, adding a new string pool if necessary.
2068                 */
2069                 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {
2070                         return;
2071                 }
2072                 vsprintf(target, format, ap);
2073                 va_end(ap); /* XXX va_end without va_start? */
2074                 __ast_string_field_release_active(*pool_head, *ptr);
2075                 *ptr = target;
2076         } else if (*ptr != target) {
2077                 /* the allocation was satisfied using available space in the pool, but not
2078                    using the space already allocated to the field
2079                 */
2080                 __ast_string_field_release_active(*pool_head, *ptr);
2081                 mgr->last_alloc = *ptr = target;
2082                 ast_assert(needed < (ast_string_field_allocation)-1);
2083                 AST_STRING_FIELD_ALLOCATION(target) = (ast_string_field_allocation)needed;
2084                 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
2085                 (*pool_head)->active += needed;
2086         } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
2087                 /* the allocation was satisfied by using available space in the pool *and*
2088                    the field was the last allocated field from the pool, so it grew
2089                 */
2090                 AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
2091                 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
2092                 (*pool_head)->active += grow;
2093         }
2094 }
2095
2096 void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
2097                                   struct ast_string_field_pool **pool_head,
2098                                   ast_string_field *ptr, const char *format, ...)
2099 {
2100         va_list ap;
2101
2102         va_start(ap, format);
2103         __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap);
2104         va_end(ap);
2105 }
2106
2107 void *__ast_calloc_with_stringfields(unsigned int num_structs, size_t struct_size, size_t field_mgr_offset,
2108                                      size_t field_mgr_pool_offset, size_t pool_size, const char *file,
2109                                      int lineno, const char *func)
2110 {
2111         struct ast_string_field_mgr *mgr;
2112         struct ast_string_field_pool *pool;
2113         struct ast_string_field_pool **pool_head;
2114         size_t pool_size_needed = sizeof(*pool) + pool_size;
2115         size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
2116         void *allocation;
2117         unsigned int x;
2118
2119 #if defined(__AST_DEBUG_MALLOC)
2120         if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) {
2121                 return NULL;
2122         }
2123 #else
2124         if (!(allocation = ast_calloc(num_structs, size_to_alloc))) {
2125                 return NULL;
2126         }
2127 #endif
2128
2129         for (x = 0; x < num_structs; x++) {
2130                 void *base = allocation + (size_to_alloc * x);
2131                 const char **p;
2132
2133                 mgr = base + field_mgr_offset;
2134                 pool_head = base + field_mgr_pool_offset;
2135                 pool = base + struct_size;
2136
2137                 p = (const char **) pool_head + 1;
2138                 while ((struct ast_string_field_mgr *) p != mgr) {
2139                         *p++ = __ast_string_field_empty;
2140                 }
2141
2142                 mgr->embedded_pool = pool;
2143                 *pool_head = pool;
2144                 pool->size = size_to_alloc - struct_size - sizeof(*pool);
2145 #if defined(__AST_DEBUG_MALLOC)
2146                 mgr->owner_file = file;
2147                 mgr->owner_func = func;
2148                 mgr->owner_line = lineno;
2149 #endif
2150         }
2151
2152         return allocation;
2153 }
2154
2155 /* end of stringfields support */
2156
2157 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
2158
2159 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
2160 {
2161         int ret;
2162         ast_mutex_lock(&fetchadd_m);
2163         ret = *p;
2164         *p += v;
2165         ast_mutex_unlock(&fetchadd_m);
2166         return ret;
2167 }
2168
2169 /*! \brief
2170  * get values from config variables.
2171  */
2172 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
2173 {
2174         long double dtv = 0.0;
2175         int scanned;
2176
2177         if (dst == NULL)
2178                 return -1;
2179
2180         *dst = _default;
2181
2182         if (ast_strlen_zero(src))
2183                 return -1;
2184
2185         /* only integer at the moment, but one day we could accept more formats */
2186         if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
2187                 dst->tv_sec = dtv;
2188                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
2189                 if (consumed)
2190                         *consumed = scanned;
2191                 return 0;
2192         } else
2193                 return -1;
2194 }
2195
2196 /*! \brief
2197  * get values from config variables.
2198  */
2199 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
2200 {
2201         long t;
2202         int scanned;
2203
2204         if (dst == NULL)
2205                 return -1;
2206
2207         *dst = _default;
2208
2209         if (ast_strlen_zero(src))
2210                 return -1;
2211
2212         /* only integer at the moment, but one day we could accept more formats */
2213         if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
2214                 *dst = t;
2215                 if (consumed)
2216                         *consumed = scanned;
2217                 return 0;
2218         } else
2219                 return -1;
2220 }
2221
2222 void ast_enable_packet_fragmentation(int sock)
2223 {
2224 #if defined(HAVE_IP_MTU_DISCOVER)
2225         int val = IP_PMTUDISC_DONT;
2226
2227         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
2228                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
2229 #endif /* HAVE_IP_MTU_DISCOVER */
2230 }
2231
2232 int ast_mkdir(const char *path, int mode)
2233 {
2234         char *ptr;
2235         int len = strlen(path), count = 0, x, piececount = 0;
2236         char *tmp = ast_strdupa(path);
2237         char **pieces;
2238         char *fullpath = ast_alloca(len + 1);
2239         int res = 0;
2240
2241         for (ptr = tmp; *ptr; ptr++) {
2242                 if (*ptr == '/')
2243                         count++;
2244         }
2245
2246         /* Count the components to the directory path */
2247         pieces = ast_alloca(count * sizeof(*pieces));
2248         for (ptr = tmp; *ptr; ptr++) {
2249                 if (*ptr == '/') {
2250                         *ptr = '\0';
2251                         pieces[piececount++] = ptr + 1;
2252                 }
2253         }
2254
2255         *fullpath = '\0';
2256         for (x = 0; x < piececount; x++) {
2257                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
2258                 strcat(fullpath, "/");
2259                 strcat(fullpath, pieces[x]);
2260                 res = mkdir(fullpath, mode);
2261                 if (res && errno != EEXIST)
2262                         return errno;
2263         }
2264         return 0;
2265 }
2266
2267 static int safe_mkdir(const char *base_path, char *path, int mode)
2268 {
2269         RAII_VAR(char *, absolute_path, NULL, ast_std_free);
2270
2271         absolute_path = realpath(path, NULL);
2272
2273         if (absolute_path) {
2274                 /* Path exists, but is it in the right place? */
2275                 if (!ast_begins_with(absolute_path, base_path)) {
2276                         return EPERM;
2277                 }
2278
2279                 /* It is in the right place! */
2280                 return 0;
2281         } else {
2282                 /* Path doesn't exist. */
2283
2284                 /* The slash terminating the subpath we're checking */
2285                 char *path_term = strchr(path, '/');
2286                 /* True indicates the parent path is within base_path */
2287                 int parent_is_safe = 0;
2288                 int res;
2289
2290                 while (path_term) {
2291                         RAII_VAR(char *, absolute_subpath, NULL, ast_std_free);
2292
2293                         /* Truncate the path one past the slash */
2294                         char c = *(path_term + 1);
2295                         *(path_term + 1) = '\0';
2296                         absolute_subpath = realpath(path, NULL);
2297
2298                         if (absolute_subpath) {
2299                                 /* Subpath exists, but is it safe? */
2300                                 parent_is_safe = ast_begins_with(
2301                                         absolute_subpath, base_path);
2302                         } else if (parent_is_safe) {
2303                                 /* Subpath does not exist, but parent is safe
2304                                  * Create it */
2305                                 res = mkdir(path, mode);
2306                                 if (res != 0) {
2307                                         ast_assert(errno != EEXIST);
2308                                         return errno;
2309                                 }
2310                         } else {
2311                                 /* Subpath did not exist, parent was not safe
2312                                  * Fail! */
2313                                 errno = EPERM;
2314                                 return errno;
2315                         }
2316                         /* Restore the path */
2317                         *(path_term + 1) = c;
2318                         /* Move on to the next slash */
2319                         path_term = strchr(path_term + 1, '/');
2320                 }
2321
2322                 /* Now to build the final path, but only if it's safe */
2323                 if (!parent_is_safe) {
2324                         errno = EPERM;
2325                         return errno;
2326                 }
2327
2328                 res = mkdir(path, mode);
2329                 if (res != 0 && errno != EEXIST) {
2330                         return errno;
2331                 }
2332
2333                 return 0;
2334         }
2335 }
2336
2337 int ast_safe_mkdir(const char *base_path, const char *path, int mode)
2338 {
2339         RAII_VAR(char *, absolute_base_path, NULL, ast_std_free);
2340         RAII_VAR(char *, p, NULL, ast_free);
2341
2342         if (base_path == NULL || path == NULL) {
2343                 errno = EFAULT;
2344                 return errno;
2345         }
2346
2347         p = ast_strdup(path);
2348         if (p == NULL) {
2349                 errno = ENOMEM;
2350                 return errno;
2351         }
2352
2353         absolute_base_path = realpath(base_path, NULL);
2354         if (absolute_base_path == NULL) {
2355                 return errno;
2356         }
2357
2358         return safe_mkdir(absolute_base_path, p, mode);
2359 }
2360
2361 static void utils_shutdown(void)
2362 {
2363         close(dev_urandom_fd);
2364         dev_urandom_fd = -1;
2365 #if defined(DEBUG_THREADS) && !defined(LOW_MEMORY)
2366         ast_cli_unregister_multiple(utils_cli, ARRAY_LEN(utils_cli));
2367 #endif
2368 }
2369
2370 int ast_utils_init(void)
2371 {
2372         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
2373         base64_init();
2374 #ifdef DEBUG_THREADS
2375 #if !defined(LOW_MEMORY)
2376         ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
2377 #endif
2378 #endif
2379         ast_register_atexit(utils_shutdown);
2380         return 0;
2381 }
2382
2383
2384 /*!
2385  *\brief Parse digest authorization header.
2386  *\return Returns -1 if we have no auth or something wrong with digest.
2387  *\note This function may be used for Digest request and responce header.
2388  * request arg is set to nonzero, if we parse Digest Request.
2389  * pedantic arg can be set to nonzero if we need to do addition Digest check.
2390  */
2391 int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic) {
2392         char *c;
2393         struct ast_str *str = ast_str_create(16);
2394
2395         /* table of recognised keywords, and places where they should be copied */
2396         const struct x {
2397                 const char *key;
2398                 const ast_string_field *field;
2399         } *i, keys[] = {
2400                 { "username=", &d->username },
2401                 { "realm=", &d->realm },
2402                 { "nonce=", &d->nonce },
2403                 { "uri=", &d->uri },
2404                 { "domain=", &d->domain },
2405                 { "response=", &d->response },
2406                 { "cnonce=", &d->cnonce },
2407                 { "opaque=", &d->opaque },
2408                 /* Special cases that cannot be directly copied */
2409                 { "algorithm=", NULL },
2410                 { "qop=", NULL },
2411                 { "nc=", NULL },
2412                 { NULL, 0 },
2413         };
2414
2415         if (ast_strlen_zero(digest) || !d || !str) {
2416                 ast_free(str);
2417                 return -1;
2418         }
2419
2420         ast_str_set(&str, 0, "%s", digest);
2421
2422         c = ast_skip_blanks(ast_str_buffer(str));
2423
2424         if (strncasecmp(c, "Digest ", strlen("Digest "))) {
2425                 ast_log(LOG_WARNING, "Missing Digest.\n");
2426                 ast_free(str);
2427                 return -1;
2428         }
2429         c += strlen("Digest ");
2430
2431         /* lookup for keys/value pair */
2432         while (c && *c && *(c = ast_skip_blanks(c))) {
2433                 /* find key */
2434                 for (i = keys; i->key != NULL; i++) {
2435                         char *src, *separator;
2436                         int unescape = 0;
2437                         if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
2438                                 continue;
2439                         }
2440
2441                         /* Found. Skip keyword, take text in quotes or up to the separator. */
2442                         c += strlen(i->key);
2443                         if (*c == '"') {
2444                                 src = ++c;
2445                                 separator = "\"";
2446                                 unescape = 1;
2447                         } else {
2448                                 src = c;
2449                                 separator = ",";
2450                         }
2451                         strsep(&c, separator); /* clear separator and move ptr */
2452                         if (unescape) {
2453                                 ast_unescape_c(src);
2454                         }
2455                         if (i->field) {
2456                                 ast_string_field_ptr_set(d, i->field, src);
2457                         } else {
2458                                 /* Special cases that require additional procesing */
2459                                 if (!strcasecmp(i->key, "algorithm=")) {
2460                                         if (strcasecmp(src, "MD5")) {
2461                                                 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
2462                                                 ast_free(str);
2463                                                 return -1;
2464                                         }
2465                                 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
2466                                         d->qop = 1;
2467                                 } else if (!strcasecmp(i->key, "nc=")) {
2468                                         unsigned long u;
2469                                         if (sscanf(src, "%30lx", &u) != 1) {
2470                                                 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
2471                                                 ast_free(str);
2472                                                 return -1;
2473                                         }
2474                                         ast_string_field_set(d, nc, src);
2475                                 }
2476                         }
2477                         break;
2478                 }
2479                 if (i->key == NULL) { /* not found, try ',' */
2480                         strsep(&c, ",");
2481                 }
2482         }
2483         ast_free(str);
2484
2485         /* Digest checkout */
2486         if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
2487                 /* "realm" and "nonce" MUST be always exist */
2488                 return -1;
2489         }
2490
2491         if (!request) {
2492                 /* Additional check for Digest response */
2493                 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
2494                         return -1;
2495                 }
2496
2497                 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
2498                         return -1;
2499                 }
2500         }
2501
2502         return 0;
2503 }
2504
2505 #ifndef __AST_DEBUG_MALLOC
2506 int _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...)
2507 {
2508         int res;
2509         va_list ap;
2510
2511         va_start(ap, fmt);
2512         if ((res = vasprintf(ret, fmt, ap)) == -1) {
2513                 MALLOC_FAILURE_MSG;
2514         }
2515         va_end(ap);
2516
2517         return res;
2518 }
2519 #endif
2520
2521 int ast_get_tid(void)
2522 {
2523         int ret = -1;
2524 #if defined (__linux) && defined(SYS_gettid)
2525         ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */
2526 #elif defined(__sun)
2527         ret = pthread_self();
2528 #elif defined(__APPLE__)
2529         ret = mach_thread_self();
2530         mach_port_deallocate(mach_task_self(), ret);
2531 #elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H)
2532         long lwpid;
2533         thr_self(&lwpid); /* available since sys/thr.h creation 2003 */
2534         ret = lwpid;
2535 #endif
2536         return ret;
2537 }
2538
2539 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size)
2540 {
2541         const char *envPATH = getenv("PATH");
2542         char *tpath, *path;
2543         struct stat unused;
2544         if (!envPATH) {
2545                 return NULL;
2546         }
2547         tpath = ast_strdupa(envPATH);
2548         while ((path = strsep(&tpath, ":"))) {
2549                 snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
2550                 if (!stat(fullpath, &unused)) {
2551                         return fullpath;
2552                 }
2553         }
2554         return NULL;
2555 }
2556
2557 void ast_do_crash(void)
2558 {
2559 #if defined(DO_CRASH)
2560         abort();
2561         /*
2562          * Just in case abort() doesn't work or something else super
2563          * silly, and for Qwell's amusement.
2564          */
2565         *((int *) 0) = 0;
2566 #endif  /* defined(DO_CRASH) */
2567 }
2568
2569 #if defined(AST_DEVMODE)
2570 void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function)
2571 {
2572         /*
2573          * Attempt to put it into the logger, but hope that at least
2574          * someone saw the message on stderr ...
2575          */
2576         ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
2577                 condition_str, condition);
2578         fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
2579                 condition_str, condition, line, function, file);
2580
2581         /* Generate a backtrace for the assert */
2582         ast_log_backtrace();
2583
2584         /*
2585          * Give the logger a chance to get the message out, just in case
2586          * we abort(), or Asterisk crashes due to whatever problem just
2587          * happened after we exit ast_assert().
2588          */
2589         usleep(1);
2590         ast_do_crash();
2591 }
2592 #endif  /* defined(AST_DEVMODE) */
2593
2594 char *ast_eid_to_str(char *s, int maxlen, struct ast_eid *eid)
2595 {
2596         int x;
2597         char *os = s;
2598         if (maxlen < 18) {
2599                 if (s && (maxlen > 0)) {
2600                         *s = '\0';
2601                 }
2602         } else {
2603                 for (x = 0; x < 5; x++) {
2604                         sprintf(s, "%02x:", (unsigned)eid->eid[x]);
2605                         s += 3;
2606                 }
2607                 sprintf(s, "%02x", (unsigned)eid->eid[5]);
2608         }
2609         return os;
2610 }
2611
2612 void ast_set_default_eid(struct ast_eid *eid)
2613 {
2614 #if defined(SIOCGIFHWADDR) && defined(HAVE_STRUCT_IFREQ_IFR_IFRU_IFRU_HWADDR)
2615         int s, x = 0;
2616         char eid_str[20];
2617         struct ifreq ifr;
2618         static const unsigned int MAXIF = 10;
2619
2620         s = socket(AF_INET, SOCK_STREAM, 0);
2621         if (s < 0) {
2622                 return;
2623         }
2624         for (x = 0; x < MAXIF; x++) {
2625                 static const char *prefixes[] = { "eth", "em" };
2626                 unsigned int i;
2627
2628                 for (i = 0; i < ARRAY_LEN(prefixes); i++) {
2629                         memset(&ifr, 0, sizeof(ifr));
2630                         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s%d", prefixes[i], x);
2631                         if (!ioctl(s, SIOCGIFHWADDR, &ifr)) {
2632                                 break;
2633                         }
2634                 }
2635
2636                 if (i == ARRAY_LEN(prefixes)) {
2637                         /* Try pciX#[1..N] */
2638                         for (i = 0; i < MAXIF; i++) {
2639                                 memset(&ifr, 0, sizeof(ifr));
2640                                 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "pci%d#%u", x, i);
2641                                 if (!ioctl(s, SIOCGIFHWADDR, &ifr)) {
2642                                         break;
2643                                 }
2644                         }
2645                         if (i == MAXIF) {
2646                                 continue;
2647                         }
2648                 }
2649
2650                 memcpy(eid, ((unsigned char *)&ifr.ifr_hwaddr) + 2, sizeof(*eid));
2651                 ast_debug(1, "Seeding global EID '%s' from '%s' using 'siocgifhwaddr'\n", ast_eid_to_str(eid_str, sizeof(eid_str), eid), ifr.ifr_name);
2652                 close(s);
2653                 return;
2654         }
2655         close(s);
2656 #else
2657 #if defined(ifa_broadaddr) && !defined(SOLARIS)
2658         char eid_str[20];
2659         struct ifaddrs *ifap;
2660
2661         if (getifaddrs(&ifap) == 0) {
2662                 struct ifaddrs *p;
2663                 for (p = ifap; p; p = p->ifa_next) {
2664                         if ((p->ifa_addr->sa_family == AF_LINK) && !(p->ifa_flags & IFF_LOOPBACK) && (p->ifa_flags & IFF_RUNNING)) {
2665                                 struct sockaddr_dl* sdp = (struct sockaddr_dl*) p->ifa_addr;
2666                                 memcpy(&(eid->eid), sdp->sdl_data + sdp->sdl_nlen, 6);
2667                                 ast_debug(1, "Seeding global EID '%s' from '%s' using 'getifaddrs'\n", ast_eid_to_str(eid_str, sizeof(eid_str), eid), p->ifa_name);
2668                                 freeifaddrs(ifap);
2669                                 return;
2670                         }
2671                 }
2672                 freeifaddrs(ifap);
2673         }
2674 #endif
2675 #endif
2676         ast_debug(1, "No ethernet interface found for seeding global EID. You will have to set it manually.\n");
2677 }
2678
2679 int ast_str_to_eid(struct ast_eid *eid, const char *s)
2680 {
2681         unsigned int eid_int[6];
2682         int x;
2683
2684         if (sscanf(s, "%2x:%2x:%2x:%2x:%2x:%2x", &eid_int[0], &eid_int[1], &eid_int[2],
2685                  &eid_int[3], &eid_int[4], &eid_int[5]) != 6) {
2686                         return -1;
2687         }
2688
2689         for (x = 0; x < 6; x++) {
2690                 eid->eid[x] = eid_int[x];
2691         }
2692
2693         return 0;
2694 }
2695
2696 int ast_eid_cmp(const struct ast_eid *eid1, const struct ast_eid *eid2)
2697 {
2698         return memcmp(eid1, eid2, sizeof(*eid1));
2699 }