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