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