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