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