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