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