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