Merged revisions 79904 via svnmerge from
[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 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <ctype.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <errno.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <sys/stat.h>
38 #include <sys/types.h>
39 #include <sys/socket.h>
40 #include <netinet/in.h>
41 #include <arpa/inet.h>
42
43 #ifdef HAVE_DEV_URANDOM
44 #include <fcntl.h>
45 #endif
46
47 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
48 #include "asterisk/lock.h"
49 #include "asterisk/io.h"
50 #include "asterisk/logger.h"
51 #include "asterisk/md5.h"
52 #include "asterisk/sha1.h"
53 #include "asterisk/options.h"
54 #include "asterisk/cli.h"
55 #include "asterisk/linkedlists.h"
56
57 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
58 #include "asterisk/strings.h"
59
60 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
61 #include "asterisk/time.h"
62
63 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
64 #include "asterisk/stringfields.h"
65
66 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
67 #include "asterisk/utils.h"
68
69 #define AST_API_MODULE
70 #include "asterisk/threadstorage.h"
71
72 static char base64[64];
73 static char b2a[256];
74
75 AST_THREADSTORAGE(inet_ntoa_buf);
76
77 #if !defined(HAVE_GETHOSTBYNAME_R_5) && !defined(HAVE_GETHOSTBYNAME_R_6)
78
79 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
80 #undef gethostbyname
81
82 AST_MUTEX_DEFINE_STATIC(__mutex);
83
84 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
85 \note This
86 routine is derived from code originally written and placed in the public 
87 domain by Enzo Michelangeli <em@em.no-ip.com> */
88
89 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
90                                 size_t buflen, struct hostent **result, 
91                                 int *h_errnop) 
92 {
93         int hsave;
94         struct hostent *ph;
95         ast_mutex_lock(&__mutex); /* begin critical area */
96         hsave = h_errno;
97
98         ph = gethostbyname(name);
99         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
100         if (ph == NULL) {
101                 *result = NULL;
102         } else {
103                 char **p, **q;
104                 char *pbuf;
105                 int nbytes=0;
106                 int naddr=0, naliases=0;
107                 /* determine if we have enough space in buf */
108
109                 /* count how many addresses */
110                 for (p = ph->h_addr_list; *p != 0; p++) {
111                         nbytes += ph->h_length; /* addresses */
112                         nbytes += sizeof(*p); /* pointers */
113                         naddr++;
114                 }
115                 nbytes += sizeof(*p); /* one more for the terminating NULL */
116
117                 /* count how many aliases, and total length of strings */
118                 for (p = ph->h_aliases; *p != 0; p++) {
119                         nbytes += (strlen(*p)+1); /* aliases */
120                         nbytes += sizeof(*p);  /* pointers */
121                         naliases++;
122                 }
123                 nbytes += sizeof(*p); /* one more for the terminating NULL */
124
125                 /* here nbytes is the number of bytes required in buffer */
126                 /* as a terminator must be there, the minimum value is ph->h_length */
127                 if (nbytes > buflen) {
128                         *result = NULL;
129                         ast_mutex_unlock(&__mutex); /* end critical area */
130                         return ERANGE; /* not enough space in buf!! */
131                 }
132
133                 /* There is enough space. Now we need to do a deep copy! */
134                 /* Allocation in buffer:
135                         from [0] to [(naddr-1) * sizeof(*p)]:
136                         pointers to addresses
137                         at [naddr * sizeof(*p)]:
138                         NULL
139                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
140                         pointers to aliases
141                         at [(naddr+naliases+1) * sizeof(*p)]:
142                         NULL
143                         then naddr addresses (fixed length), and naliases aliases (asciiz).
144                 */
145
146                 *ret = *ph;   /* copy whole structure (not its address!) */
147
148                 /* copy addresses */
149                 q = (char **)buf; /* pointer to pointers area (type: char **) */
150                 ret->h_addr_list = q; /* update pointer to address list */
151                 pbuf = buf + ((naddr + naliases + 2) * sizeof(*p)); /* skip that area */
152                 for (p = ph->h_addr_list; *p != 0; p++) {
153                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
154                         *q++ = pbuf; /* the pointer is the one inside buf... */
155                         pbuf += ph->h_length; /* advance pbuf */
156                 }
157                 *q++ = NULL; /* address list terminator */
158
159                 /* copy aliases */
160                 ret->h_aliases = q; /* update pointer to aliases list */
161                 for (p = ph->h_aliases; *p != 0; p++) {
162                         strcpy(pbuf, *p); /* copy alias strings */
163                         *q++ = pbuf; /* the pointer is the one inside buf... */
164                         pbuf += strlen(*p); /* advance pbuf */
165                         *pbuf++ = 0; /* string terminator */
166                 }
167                 *q++ = NULL; /* terminator */
168
169                 strcpy(pbuf, ph->h_name); /* copy alias strings */
170                 ret->h_name = pbuf;
171                 pbuf += strlen(ph->h_name); /* advance pbuf */
172                 *pbuf++ = 0; /* string terminator */
173
174                 *result = ret;  /* and let *result point to structure */
175
176         }
177         h_errno = hsave;  /* restore h_errno */
178         ast_mutex_unlock(&__mutex); /* end critical area */
179
180         return (*result == NULL); /* return 0 on success, non-zero on error */
181 }
182
183
184 #endif
185
186 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the 
187    standard gethostbyname (which is not thread safe)
188 */
189 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
190 {
191         int res;
192         int herrno;
193         int dots=0;
194         const char *s;
195         struct hostent *result = NULL;
196         /* Although it is perfectly legitimate to lookup a pure integer, for
197            the sake of the sanity of people who like to name their peers as
198            integers, we break with tradition and refuse to look up a
199            pure integer */
200         s = host;
201         res = 0;
202         while (s && *s) {
203                 if (*s == '.')
204                         dots++;
205                 else if (!isdigit(*s))
206                         break;
207                 s++;
208         }
209         if (!s || !*s) {
210                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
211                 if (dots != 3)
212                         return NULL;
213                 memset(hp, 0, sizeof(struct ast_hostent));
214                 hp->hp.h_addrtype = AF_INET;
215                 hp->hp.h_addr_list = (void *) hp->buf;
216                 hp->hp.h_addr = hp->buf + sizeof(void *);
217                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
218                         return &hp->hp;
219                 return NULL;
220                 
221         }
222 #ifdef HAVE_GETHOSTBYNAME_R_5
223         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
224
225         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
226                 return NULL;
227 #else
228         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
229
230         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
231                 return NULL;
232 #endif
233         return &hp->hp;
234 }
235
236
237
238 AST_MUTEX_DEFINE_STATIC(test_lock);
239 AST_MUTEX_DEFINE_STATIC(test_lock2);
240 static pthread_t test_thread; 
241 static int lock_count = 0;
242 static int test_errors = 0;
243
244 /*! \brief This is a regression test for recursive mutexes.
245    test_for_thread_safety() will return 0 if recursive mutex locks are
246    working properly, and non-zero if they are not working properly. */
247 static void *test_thread_body(void *data) 
248
249         ast_mutex_lock(&test_lock);
250         lock_count += 10;
251         if (lock_count != 10) 
252                 test_errors++;
253         ast_mutex_lock(&test_lock);
254         lock_count += 10;
255         if (lock_count != 20) 
256                 test_errors++;
257         ast_mutex_lock(&test_lock2);
258         ast_mutex_unlock(&test_lock);
259         lock_count -= 10;
260         if (lock_count != 10) 
261                 test_errors++;
262         ast_mutex_unlock(&test_lock);
263         lock_count -= 10;
264         ast_mutex_unlock(&test_lock2);
265         if (lock_count != 0) 
266                 test_errors++;
267         return NULL;
268
269
270 int test_for_thread_safety(void)
271
272         ast_mutex_lock(&test_lock2);
273         ast_mutex_lock(&test_lock);
274         lock_count += 1;
275         ast_mutex_lock(&test_lock);
276         lock_count += 1;
277         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
278         usleep(100);
279         if (lock_count != 2) 
280                 test_errors++;
281         ast_mutex_unlock(&test_lock);
282         lock_count -= 1;
283         usleep(100); 
284         if (lock_count != 1) 
285                 test_errors++;
286         ast_mutex_unlock(&test_lock);
287         lock_count -= 1;
288         if (lock_count != 0) 
289                 test_errors++;
290         ast_mutex_unlock(&test_lock2);
291         usleep(100);
292         if (lock_count != 0) 
293                 test_errors++;
294         pthread_join(test_thread, NULL);
295         return(test_errors);          /* return 0 on success. */
296 }
297
298 /*! \brief Produce 32 char MD5 hash of value. */
299 void ast_md5_hash(char *output, char *input)
300 {
301         struct MD5Context md5;
302         unsigned char digest[16];
303         char *ptr;
304         int x;
305
306         MD5Init(&md5);
307         MD5Update(&md5, (unsigned char *)input, strlen(input));
308         MD5Final(digest, &md5);
309         ptr = output;
310         for (x = 0; x < 16; x++)
311                 ptr += sprintf(ptr, "%2.2x", digest[x]);
312 }
313
314 /*! \brief Produce 40 char SHA1 hash of value. */
315 void ast_sha1_hash(char *output, char *input)
316 {
317         struct SHA1Context sha;
318         char *ptr;
319         int x;
320         uint8_t Message_Digest[20];
321
322         SHA1Reset(&sha);
323         
324         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
325
326         SHA1Result(&sha, Message_Digest);
327         ptr = output;
328         for (x = 0; x < 20; x++)
329                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
330 }
331
332 /*! \brief decode BASE64 encoded text */
333 int ast_base64decode(unsigned char *dst, const char *src, int max)
334 {
335         int cnt = 0;
336         unsigned int byte = 0;
337         unsigned int bits = 0;
338         int incnt = 0;
339         while (*src && (cnt < max)) {
340                 /* Shift in 6 bits of input */
341                 byte <<= 6;
342                 byte |= (b2a[(int)(*src)]) & 0x3f;
343                 bits += 6;
344                 src++;
345                 incnt++;
346                 /* If we have at least 8 bits left over, take that character 
347                    off the top */
348                 if (bits >= 8)  {
349                         bits -= 8;
350                         *dst = (byte >> bits) & 0xff;
351                         dst++;
352                         cnt++;
353                 }
354         }
355         /* Dont worry about left over bits, they're extra anyway */
356         return cnt;
357 }
358
359 /*! \brief encode text to BASE64 coding */
360 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
361 {
362         int cnt = 0;
363         int col = 0;
364         unsigned int byte = 0;
365         int bits = 0;
366         int cntin = 0;
367         /* Reserve space for null byte at end of string */
368         max--;
369         while ((cntin < srclen) && (cnt < max)) {
370                 byte <<= 8;
371                 byte |= *(src++);
372                 bits += 8;
373                 cntin++;
374                 if ((bits == 24) && (cnt + 4 <= max)) {
375                         *dst++ = base64[(byte >> 18) & 0x3f];
376                         *dst++ = base64[(byte >> 12) & 0x3f];
377                         *dst++ = base64[(byte >> 6) & 0x3f];
378                         *dst++ = base64[byte & 0x3f];
379                         cnt += 4;
380                         col += 4;
381                         bits = 0;
382                         byte = 0;
383                 }
384                 if (linebreaks && (cnt < max) && (col == 64)) {
385                         *dst++ = '\n';
386                         cnt++;
387                         col = 0;
388                 }
389         }
390         if (bits && (cnt + 4 <= max)) {
391                 /* Add one last character for the remaining bits, 
392                    padding the rest with 0 */
393                 byte <<= 24 - bits;
394                 *dst++ = base64[(byte >> 18) & 0x3f];
395                 *dst++ = base64[(byte >> 12) & 0x3f];
396                 if (bits == 16)
397                         *dst++ = base64[(byte >> 6) & 0x3f];
398                 else
399                         *dst++ = '=';
400                 *dst++ = '=';
401                 cnt += 4;
402         }
403         if (linebreaks && (cnt < max)) {
404                 *dst++ = '\n';
405                 cnt++;
406         }
407         *dst = '\0';
408         return cnt;
409 }
410
411 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
412 {
413         return ast_base64encode_full(dst, src, srclen, max, 0);
414 }
415
416 static void base64_init(void)
417 {
418         int x;
419         memset(b2a, -1, sizeof(b2a));
420         /* Initialize base-64 Conversion table */
421         for (x = 0; x < 26; x++) {
422                 /* A-Z */
423                 base64[x] = 'A' + x;
424                 b2a['A' + x] = x;
425                 /* a-z */
426                 base64[x + 26] = 'a' + x;
427                 b2a['a' + x] = x + 26;
428                 /* 0-9 */
429                 if (x < 10) {
430                         base64[x + 52] = '0' + x;
431                         b2a['0' + x] = x + 52;
432                 }
433         }
434         base64[62] = '+';
435         base64[63] = '/';
436         b2a[(int)'+'] = 62;
437         b2a[(int)'/'] = 63;
438 }
439
440 /*! \brief  ast_uri_encode: Turn text string to URI-encoded %XX version
441 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
442         as in the SIP protocol spec 
443         If doreserved == 1 we will convert reserved characters also.
444         RFC 2396, section 2.4
445         outbuf needs to have more memory allocated than the instring
446         to have room for the expansion. Every char that is converted
447         is replaced by three ASCII characters.
448
449         Note: The doreserved option is needed for replaces header in
450         SIP transfers.
451 */
452 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved) 
453 {
454         char *reserved = ";/?:@&=+$, "; /* Reserved chars */
455
456         const char *ptr  = string;      /* Start with the string */
457         char *out = NULL;
458         char *buf = NULL;
459
460         ast_copy_string(outbuf, string, buflen);
461
462         /* If there's no characters to convert, just go through and don't do anything */
463         while (*ptr) {
464                 if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
465                         /* Oops, we need to start working here */
466                         if (!buf) {
467                                 buf = outbuf;
468                                 out = buf + (ptr - string) ;    /* Set output ptr */
469                         }
470                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
471                 } else if (buf) {
472                         *out = *ptr;    /* Continue copying the string */
473                         out++;
474                 } 
475                 ptr++;
476         }
477         if (buf)
478                 *out = '\0';
479         return outbuf;
480 }
481
482 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
483 void ast_uri_decode(char *s) 
484 {
485         char *o;
486         unsigned int tmp;
487
488         for (o = s; *s; s++, o++) {
489                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
490                         /* have '%', two chars and correct parsing */
491                         *o = tmp;
492                         s += 2; /* Will be incremented once more when we break out */
493                 } else /* all other cases, just copy */
494                         *o = *s;
495         }
496         *o = '\0';
497 }
498
499 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
500 const char *ast_inet_ntoa(struct in_addr ia)
501 {
502         char *buf;
503
504         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
505                 return "";
506
507         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
508 }
509
510 #ifdef HAVE_DEV_URANDOM
511 static int dev_urandom_fd;
512 #endif
513
514 #ifndef __linux__
515 #undef pthread_create /* For ast_pthread_create function only */
516 #endif /* !__linux__ */
517
518 #if !defined(LOW_MEMORY)
519
520 #ifdef DEBUG_THREADS
521
522 /*! \brief A reasonable maximum number of locks a thread would be holding ... */
523 #define AST_MAX_LOCKS 16
524
525 /* Allow direct use of pthread_mutex_t and friends */
526 #undef pthread_mutex_t
527 #undef pthread_mutex_lock
528 #undef pthread_mutex_unlock
529 #undef pthread_mutex_init
530 #undef pthread_mutex_destroy
531
532 /*! 
533  * \brief Keep track of which locks a thread holds 
534  *
535  * There is an instance of this struct for every active thread
536  */
537 struct thr_lock_info {
538         /*! The thread's ID */
539         pthread_t thread_id;
540         /*! The thread name which includes where the thread was started */
541         const char *thread_name;
542         /*! This is the actual container of info for what locks this thread holds */
543         struct {
544                 const char *file;
545                 int line_num;
546                 const char *func;
547                 const char *lock_name;
548                 void *lock_addr;
549                 int times_locked;
550                 /*! This thread is waiting on this lock */
551                 unsigned int pending:1;
552         } locks[AST_MAX_LOCKS];
553         /*! This is the number of locks currently held by this thread.
554          *  The index (num_locks - 1) has the info on the last one in the
555          *  locks member */
556         unsigned int num_locks;
557         /*! Protects the contents of the locks member 
558          * Intentionally not ast_mutex_t */
559         pthread_mutex_t lock;
560         AST_LIST_ENTRY(thr_lock_info) entry;
561 };
562
563 /*! 
564  * \brief Locked when accessing the lock_infos list 
565  */
566 AST_MUTEX_DEFINE_STATIC(lock_infos_lock);
567 /*!
568  * \brief A list of each thread's lock info 
569  */
570 static AST_LIST_HEAD_NOLOCK_STATIC(lock_infos, thr_lock_info);
571
572 /*!
573  * \brief Destroy a thread's lock info
574  *
575  * This gets called automatically when the thread stops
576  */
577 static void lock_info_destroy(void *data)
578 {
579         struct thr_lock_info *lock_info = data;
580
581         pthread_mutex_lock(&lock_infos_lock.mutex);
582         AST_LIST_REMOVE(&lock_infos, lock_info, entry);
583         pthread_mutex_unlock(&lock_infos_lock.mutex);
584
585         pthread_mutex_destroy(&lock_info->lock);
586         free((void *) lock_info->thread_name);
587         free(lock_info);
588 }
589
590 /*!
591  * \brief The thread storage key for per-thread lock info
592  */
593 AST_THREADSTORAGE_CUSTOM(thread_lock_info, NULL, lock_info_destroy);
594
595 void ast_store_lock_info(const char *filename, int line_num, 
596         const char *func, const char *lock_name, void *lock_addr)
597 {
598         struct thr_lock_info *lock_info;
599         int i;
600
601         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
602                 return;
603
604         pthread_mutex_lock(&lock_info->lock);
605
606         for (i = 0; i < lock_info->num_locks; i++) {
607                 if (lock_info->locks[i].lock_addr == lock_addr) {
608                         lock_info->locks[i].times_locked++;
609                         pthread_mutex_unlock(&lock_info->lock);
610                         return;
611                 }
612         }
613
614         if (lock_info->num_locks == AST_MAX_LOCKS) {
615                 /* Can't use ast_log here, because it will cause infinite recursion */
616                 fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
617                         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
618                 pthread_mutex_unlock(&lock_info->lock);
619                 return;
620         }
621         
622         lock_info->locks[i].file = filename;
623         lock_info->locks[i].line_num = line_num;
624         lock_info->locks[i].func = func;
625         lock_info->locks[i].lock_name = lock_name;
626         lock_info->locks[i].lock_addr = lock_addr;
627         lock_info->locks[i].times_locked = 1;
628         lock_info->locks[i].pending = 1;
629         lock_info->num_locks++;
630
631         pthread_mutex_unlock(&lock_info->lock);
632 }
633
634 void ast_mark_lock_acquired(void)
635 {
636         struct thr_lock_info *lock_info;
637
638         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
639                 return;
640
641         pthread_mutex_lock(&lock_info->lock);
642         lock_info->locks[lock_info->num_locks - 1].pending = 0;
643         pthread_mutex_unlock(&lock_info->lock);
644 }
645
646 void ast_remove_lock_info(void *lock_addr)
647 {
648         struct thr_lock_info *lock_info;
649         int i = 0;
650
651         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
652                 return;
653
654         pthread_mutex_lock(&lock_info->lock);
655
656         for (i = lock_info->num_locks - 1; i >= 0; i--) {
657                 if (lock_info->locks[i].lock_addr == lock_addr)
658                         break;
659         }
660
661         if (i == -1) {
662                 /* Lock not found :( */
663                 pthread_mutex_unlock(&lock_info->lock);
664                 return;
665         }
666
667         if (lock_info->locks[i].times_locked > 1) {
668                 lock_info->locks[i].times_locked--;
669                 pthread_mutex_unlock(&lock_info->lock);
670                 return;
671         }
672
673         if (i < lock_info->num_locks - 1) {
674                 /* Not the last one ... *should* be rare! */
675                 memmove(&lock_info->locks[i], &lock_info->locks[i + 1], 
676                         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
677         }
678
679         lock_info->num_locks--;
680
681         pthread_mutex_unlock(&lock_info->lock);
682 }
683
684 static char *handle_show_locks(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
685 {
686         struct thr_lock_info *lock_info;
687
688         switch (cmd) {
689         case CLI_INIT:
690                 e->command = "core show locks";
691                 e->usage =
692                         "Usage: core show locks\n"
693                         "       This command is for lock debugging.  It prints out which locks\n"
694                         "are owned by each active thread.\n";
695                 return NULL;
696
697         case CLI_GENERATE:
698                 return NULL;
699         }
700
701         ast_cli(a->fd, "\n" 
702                        "=======================================================================\n"
703                        "=== Currently Held Locks ==============================================\n"
704                        "=======================================================================\n"
705                        "===\n"
706                        "=== <file> <line num> <function> <lock name> <lock addr> (times locked)\n"
707                        "===\n");
708
709         pthread_mutex_lock(&lock_infos_lock.mutex);
710         AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
711                 int i;
712                 ast_cli(a->fd, "=== Thread ID: %d (%s)\n", (int) lock_info->thread_id,
713                         lock_info->thread_name);
714                 pthread_mutex_lock(&lock_info->lock);
715                 for (i = 0; i < lock_info->num_locks; i++) {
716                         ast_cli(a->fd, "=== ---> %sLock #%d: %s %d %s %s %p (%d)\n", 
717                                 lock_info->locks[i].pending ? "Waiting for " : "", i,
718                                 lock_info->locks[i].file, lock_info->locks[i].line_num,
719                                 lock_info->locks[i].func, lock_info->locks[i].lock_name,
720                                 lock_info->locks[i].lock_addr, 
721                                 lock_info->locks[i].times_locked);
722                 }
723                 pthread_mutex_unlock(&lock_info->lock);
724                 ast_cli(a->fd, "=== -------------------------------------------------------------------\n"
725                                "===\n");
726         }
727         pthread_mutex_unlock(&lock_infos_lock.mutex);
728
729         ast_cli(a->fd, "=======================================================================\n"
730                        "\n");
731
732         return 0;
733 }
734
735 static struct ast_cli_entry utils_cli[] = {
736         NEW_CLI(handle_show_locks, "Show which locks are held by which thread"),
737 };
738
739 #endif /* DEBUG_THREADS */
740
741 /*
742  * support for 'show threads'. The start routine is wrapped by
743  * dummy_start(), so that ast_register_thread() and
744  * ast_unregister_thread() know the thread identifier.
745  */
746 struct thr_arg {
747         void *(*start_routine)(void *);
748         void *data;
749         char *name;
750 };
751
752 /*
753  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
754  * are odd macros which start and end a block, so they _must_ be
755  * used in pairs (the latter with a '1' argument to call the
756  * handler on exit.
757  * On BSD we don't need this, but we keep it for compatibility.
758  */
759 static void *dummy_start(void *data)
760 {
761         void *ret;
762         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
763 #ifdef DEBUG_THREADS
764         struct thr_lock_info *lock_info;
765 #endif
766
767         /* note that even though data->name is a pointer to allocated memory,
768            we are not freeing it here because ast_register_thread is going to
769            keep a copy of the pointer and then ast_unregister_thread will
770            free the memory
771         */
772         ast_free(data);
773         ast_register_thread(a.name);
774         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
775
776 #ifdef DEBUG_THREADS
777         if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
778                 return NULL;
779
780         lock_info->thread_id = pthread_self();
781         lock_info->thread_name = strdup(a.name);
782         pthread_mutex_init(&lock_info->lock, NULL);
783
784         pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
785         AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
786         pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
787 #endif /* DEBUG_THREADS */
788
789         ret = a.start_routine(a.data);
790
791         pthread_cleanup_pop(1);
792
793         return ret;
794 }
795
796 #endif /* !LOW_MEMORY */
797
798 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
799                              void *data, size_t stacksize, const char *file, const char *caller,
800                              int line, const char *start_fn)
801 {
802 #if !defined(LOW_MEMORY)
803         struct thr_arg *a;
804 #endif
805
806         if (!attr) {
807                 attr = alloca(sizeof(*attr));
808                 pthread_attr_init(attr);
809         }
810
811 #ifdef __linux__
812         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
813            which is kind of useless. Change this here to
814            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
815            priority will propagate down to new threads by default.
816            This does mean that callers cannot set a different priority using
817            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
818            the priority afterwards with pthread_setschedparam(). */
819         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
820                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
821 #endif
822
823         if (!stacksize)
824                 stacksize = AST_STACKSIZE;
825
826         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
827                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
828
829 #if !defined(LOW_MEMORY)
830         if ((a = ast_malloc(sizeof(*a)))) {
831                 a->start_routine = start_routine;
832                 a->data = data;
833                 start_routine = dummy_start;
834                 asprintf(&a->name, "%-20s started at [%5d] %s %s()",
835                          start_fn, line, file, caller);
836                 data = a;
837         }
838 #endif /* !LOW_MEMORY */
839
840         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
841 }
842
843
844 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
845                              void *data, size_t stacksize, const char *file, const char *caller,
846                              int line, const char *start_fn)
847 {
848         unsigned char attr_destroy = 0;
849         int res;
850
851         if (!attr) {
852                 attr = alloca(sizeof(*attr));
853                 pthread_attr_init(attr);
854                 attr_destroy = 1;
855         }
856
857         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
858                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
859
860         res = ast_pthread_create_stack(thread, attr, start_routine, data, 
861                                        stacksize, file, caller, line, start_fn);
862
863         if (attr_destroy)
864                 pthread_attr_destroy(attr);
865
866         return res;
867 }
868
869 int ast_wait_for_input(int fd, int ms)
870 {
871         struct pollfd pfd[1];
872         memset(pfd, 0, sizeof(pfd));
873         pfd[0].fd = fd;
874         pfd[0].events = POLLIN|POLLPRI;
875         return poll(pfd, 1, ms);
876 }
877
878 /*!
879  * Try to write string, but wait no more than ms milliseconds before timing out.
880  *
881  * \note The code assumes that the file descriptor has NONBLOCK set,
882  * so there is only one system call made to do a write, unless we actually
883  * have a need to wait.  This way, we get better performance.
884  * If the descriptor is blocking, all assumptions on the guaranteed
885  * detail do not apply anymore.
886  * Also note that in the current implementation, the delay is per-write,
887  * so you still have no guarantees, anyways.
888  * Fortunately the routine is only used in a few places (cli.c, manager.c,
889  * res_agi.c) so it is reasonably easy to check how it behaves there.
890  *
891  * XXX We either need to fix the code, or fix the documentation.
892  */
893 int ast_carefulwrite(int fd, char *s, int len, int timeoutms) 
894 {
895         /* Try to write string, but wait no more than ms milliseconds
896            before timing out */
897         int res = 0;
898         struct pollfd fds[1];
899         while (len) {
900                 res = write(fd, s, len);
901                 if ((res < 0) && (errno != EAGAIN)) {
902                         return -1;
903                 }
904                 if (res < 0)
905                         res = 0;
906                 len -= res;
907                 s += res;
908                 res = 0;
909                 if (len) {
910                         fds[0].fd = fd;
911                         fds[0].events = POLLOUT;
912                         /* Wait until writable again */
913                         res = poll(fds, 1, timeoutms);
914                         if (res < 1)
915                                 return -1;
916                 }
917         }
918         return res;
919 }
920
921 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
922 {
923         char *e;
924         char *q;
925
926         s = ast_strip(s);
927         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
928                 e = s + strlen(s) - 1;
929                 if (*e == *(end_quotes + (q - beg_quotes))) {
930                         s++;
931                         *e = '\0';
932                 }
933         }
934
935         return s;
936 }
937
938 char *ast_unescape_semicolon(char *s)
939 {
940         char *e;
941         char *work = s;
942
943         while ((e = strchr(work, ';'))) {
944                 if ((e > work) && (*(e-1) == '\\')) {
945                         memmove(e - 1, e, strlen(e) + 1);
946                         work = e;
947                 }
948         }
949
950         return s;
951 }
952
953 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
954 {
955         int result;
956
957         if (!buffer || !*buffer || !space || !*space)
958                 return -1;
959
960         result = vsnprintf(*buffer, *space, fmt, ap);
961
962         if (result < 0)
963                 return -1;
964         else if (result > *space)
965                 result = *space;
966
967         *buffer += result;
968         *space -= result;
969         return 0;
970 }
971
972 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
973 {
974         va_list ap;
975         int result;
976
977         va_start(ap, fmt);
978         result = ast_build_string_va(buffer, space, fmt, ap);
979         va_end(ap);
980
981         return result;
982 }
983
984 int ast_true(const char *s)
985 {
986         if (ast_strlen_zero(s))
987                 return 0;
988
989         /* Determine if this is a true value */
990         if (!strcasecmp(s, "yes") ||
991             !strcasecmp(s, "true") ||
992             !strcasecmp(s, "y") ||
993             !strcasecmp(s, "t") ||
994             !strcasecmp(s, "1") ||
995             !strcasecmp(s, "on"))
996                 return -1;
997
998         return 0;
999 }
1000
1001 int ast_false(const char *s)
1002 {
1003         if (ast_strlen_zero(s))
1004                 return 0;
1005
1006         /* Determine if this is a false value */
1007         if (!strcasecmp(s, "no") ||
1008             !strcasecmp(s, "false") ||
1009             !strcasecmp(s, "n") ||
1010             !strcasecmp(s, "f") ||
1011             !strcasecmp(s, "0") ||
1012             !strcasecmp(s, "off"))
1013                 return -1;
1014
1015         return 0;
1016 }
1017
1018 #define ONE_MILLION     1000000
1019 /*
1020  * put timeval in a valid range. usec is 0..999999
1021  * negative values are not allowed and truncated.
1022  */
1023 static struct timeval tvfix(struct timeval a)
1024 {
1025         if (a.tv_usec >= ONE_MILLION) {
1026                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
1027                         a.tv_sec, (long int) a.tv_usec);
1028                 a.tv_sec += a.tv_usec / ONE_MILLION;
1029                 a.tv_usec %= ONE_MILLION;
1030         } else if (a.tv_usec < 0) {
1031                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
1032                         a.tv_sec, (long int) a.tv_usec);
1033                 a.tv_usec = 0;
1034         }
1035         return a;
1036 }
1037
1038 struct timeval ast_tvadd(struct timeval a, struct timeval b)
1039 {
1040         /* consistency checks to guarantee usec in 0..999999 */
1041         a = tvfix(a);
1042         b = tvfix(b);
1043         a.tv_sec += b.tv_sec;
1044         a.tv_usec += b.tv_usec;
1045         if (a.tv_usec >= ONE_MILLION) {
1046                 a.tv_sec++;
1047                 a.tv_usec -= ONE_MILLION;
1048         }
1049         return a;
1050 }
1051
1052 struct timeval ast_tvsub(struct timeval a, struct timeval b)
1053 {
1054         /* consistency checks to guarantee usec in 0..999999 */
1055         a = tvfix(a);
1056         b = tvfix(b);
1057         a.tv_sec -= b.tv_sec;
1058         a.tv_usec -= b.tv_usec;
1059         if (a.tv_usec < 0) {
1060                 a.tv_sec-- ;
1061                 a.tv_usec += ONE_MILLION;
1062         }
1063         return a;
1064 }
1065 #undef ONE_MILLION
1066
1067 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1068  * BSD libc (and others) do not. */
1069
1070 #ifndef linux
1071 AST_MUTEX_DEFINE_STATIC(randomlock);
1072 #endif
1073
1074 long int ast_random(void)
1075 {
1076         long int res;
1077 #ifdef HAVE_DEV_URANDOM
1078         if (dev_urandom_fd >= 0) {
1079                 int read_res = read(dev_urandom_fd, &res, sizeof(res));
1080                 if (read_res > 0)
1081                         return labs(res);
1082         }
1083 #endif
1084 #ifdef linux
1085         res = random();
1086 #else
1087         ast_mutex_lock(&randomlock);
1088         res = random();
1089         ast_mutex_unlock(&randomlock);
1090 #endif
1091         return res;
1092 }
1093
1094 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1095 {
1096         char *dataPut = start;
1097         int inEscape = 0;
1098         int inQuotes = 0;
1099
1100         for (; *start; start++) {
1101                 if (inEscape) {
1102                         *dataPut++ = *start;       /* Always goes verbatim */
1103                         inEscape = 0;
1104                 } else {
1105                         if (*start == '\\') {
1106                                 inEscape = 1;      /* Do not copy \ into the data */
1107                         } else if (*start == '\'') {
1108                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1109                         } else {
1110                                 /* Replace , with |, unless in quotes */
1111                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1112                         }
1113                 }
1114         }
1115         if (start != dataPut)
1116                 *dataPut = 0;
1117         return dataPut;
1118 }
1119
1120 void ast_join(char *s, size_t len, char * const w[])
1121 {
1122         int x, ofs = 0;
1123         const char *src;
1124
1125         /* Join words into a string */
1126         if (!s)
1127                 return;
1128         for (x = 0; ofs < len && w[x]; x++) {
1129                 if (x > 0)
1130                         s[ofs++] = ' ';
1131                 for (src = w[x]; *src && ofs < len; src++)
1132                         s[ofs++] = *src;
1133         }
1134         if (ofs == len)
1135                 ofs--;
1136         s[ofs] = '\0';
1137 }
1138
1139 const char __ast_string_field_empty[] = "";
1140
1141 static int add_string_pool(struct ast_string_field_mgr *mgr, size_t size)
1142 {
1143         struct ast_string_field_pool *pool;
1144
1145         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
1146                 return -1;
1147         
1148         pool->prev = mgr->pool;
1149         mgr->pool = pool;
1150         mgr->size = size;
1151         mgr->space = size;
1152         mgr->used = 0;
1153
1154         return 0;
1155 }
1156
1157 int __ast_string_field_init(struct ast_string_field_mgr *mgr, size_t size,
1158                             ast_string_field *fields, int num_fields)
1159 {
1160         int index;
1161
1162         if (add_string_pool(mgr, size))
1163                 return -1;
1164
1165         for (index = 0; index < num_fields; index++)
1166                 fields[index] = __ast_string_field_empty;
1167
1168         return 0;
1169 }
1170
1171 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, size_t needed,
1172                                                 ast_string_field *fields, int num_fields)
1173 {
1174         char *result = NULL;
1175
1176         if (__builtin_expect(needed > mgr->space, 0)) {
1177                 size_t new_size = mgr->size * 2;
1178
1179                 while (new_size < needed)
1180                         new_size *= 2;
1181
1182                 if (add_string_pool(mgr, new_size))
1183                         return NULL;
1184         }
1185
1186         result = mgr->pool->base + mgr->used;
1187         mgr->used += needed;
1188         mgr->space -= needed;
1189         return result;
1190 }
1191
1192 void __ast_string_field_index_build_va(struct ast_string_field_mgr *mgr,
1193                                     ast_string_field *fields, int num_fields,
1194                                     int index, const char *format, va_list ap1, va_list ap2)
1195 {
1196         size_t needed;
1197
1198         needed = vsnprintf(mgr->pool->base + mgr->used, mgr->space, format, ap1) + 1;
1199
1200         va_end(ap1);
1201
1202         if (needed > mgr->space) {
1203                 size_t new_size = mgr->size * 2;
1204
1205                 while (new_size < needed)
1206                         new_size *= 2;
1207
1208                 if (add_string_pool(mgr, new_size))
1209                         return;
1210
1211                 vsprintf(mgr->pool->base + mgr->used, format, ap2);
1212         }
1213
1214         fields[index] = mgr->pool->base + mgr->used;
1215         mgr->used += needed;
1216         mgr->space -= needed;
1217 }
1218
1219 void __ast_string_field_index_build(struct ast_string_field_mgr *mgr,
1220                                     ast_string_field *fields, int num_fields,
1221                                     int index, const char *format, ...)
1222 {
1223         va_list ap1, ap2;
1224
1225         va_start(ap1, format);
1226         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
1227
1228         __ast_string_field_index_build_va(mgr, fields, num_fields, index, format, ap1, ap2);
1229
1230         va_end(ap1);
1231         va_end(ap2);
1232 }
1233
1234 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1235
1236 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1237 {
1238         int ret;
1239         ast_mutex_lock(&fetchadd_m);
1240         ret = *p;
1241         *p += v;
1242         ast_mutex_unlock(&fetchadd_m);
1243         return ret;
1244 }
1245
1246 /*! \brief
1247  * get values from config variables.
1248  */
1249 int ast_get_timeval(const char *src, struct timeval *dst, struct timeval _default, int *consumed)
1250 {
1251         long double dtv = 0.0;
1252         int scanned;
1253
1254         if (dst == NULL)
1255                 return -1;
1256
1257         *dst = _default;
1258
1259         if (ast_strlen_zero(src))
1260                 return -1;
1261
1262         /* only integer at the moment, but one day we could accept more formats */
1263         if (sscanf(src, "%Lf%n", &dtv, &scanned) > 0) {
1264                 dst->tv_sec = dtv;
1265                 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
1266                 if (consumed)
1267                         *consumed = scanned;
1268                 return 0;
1269         } else
1270                 return -1;
1271 }
1272
1273 /*! \brief
1274  * get values from config variables.
1275  */
1276 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1277 {
1278         long t;
1279         int scanned;
1280
1281         if (dst == NULL)
1282                 return -1;
1283
1284         *dst = _default;
1285
1286         if (ast_strlen_zero(src))
1287                 return -1;
1288
1289         /* only integer at the moment, but one day we could accept more formats */
1290         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
1291                 *dst = t;
1292                 if (consumed)
1293                         *consumed = scanned;
1294                 return 0;
1295         } else
1296                 return -1;
1297 }
1298
1299 /*!
1300  * core handler for dynamic strings.
1301  * This is not meant to be called directly, but rather through the
1302  * various wrapper macros
1303  *      ast_str_set(...)
1304  *      ast_str_append(...)
1305  *      ast_str_set_va(...)
1306  *      ast_str_append_va(...)
1307  */
1308 int __ast_str_helper(struct ast_str **buf, size_t max_len,
1309         int append, const char *fmt, va_list ap)
1310 {
1311         int res, need;
1312         int offset = (append && (*buf)->len) ? (*buf)->used : 0;
1313
1314         if (max_len < 0)
1315                 max_len = (*buf)->len;  /* don't exceed the allocated space */
1316         /*
1317          * Ask vsnprintf how much space we need. Remember that vsnprintf
1318          * does not count the final '\0' so we must add 1.
1319          */
1320         res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap);
1321
1322         need = res + offset + 1;
1323         /*
1324          * If there is not enough space and we are below the max length,
1325          * reallocate the buffer and return a message telling to retry.
1326          */
1327         if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
1328                 if (max_len && max_len < need)  /* truncate as needed */
1329                         need = max_len;
1330                 else if (max_len == 0)  /* if unbounded, give more room for next time */
1331                         need += 16 + need/4;
1332                 if (0)  /* debugging */
1333                         ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need);
1334                 if (ast_str_make_space(buf, need)) {
1335                         ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need);
1336                         return AST_DYNSTR_BUILD_FAILED;
1337                 }
1338                 (*buf)->str[offset] = '\0';     /* Truncate the partial write. */
1339
1340                 /* va_end() and va_start() must be done before calling
1341                  * vsnprintf() again. */
1342                 return AST_DYNSTR_BUILD_RETRY;
1343         }
1344         /* update space used, keep in mind the truncation */
1345         (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len : res + offset;
1346
1347         return res;
1348 }
1349
1350 void ast_enable_packet_fragmentation(int sock)
1351 {
1352 #if defined(HAVE_IP_MTU_DISCOVER)
1353         int val = IP_PMTUDISC_DONT;
1354         
1355         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1356                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1357 #endif /* HAVE_IP_MTU_DISCOVER */
1358 }
1359
1360 int ast_mkdir(const char *path, int mode)
1361 {
1362         char *ptr;
1363         int len = strlen(path), count = 0, x, piececount = 0;
1364         char *tmp = ast_strdupa(path);
1365         char **pieces;
1366         char *fullpath = alloca(len + 1);
1367         int res = 0;
1368
1369         for (ptr = tmp; *ptr; ptr++) {
1370                 if (*ptr == '/')
1371                         count++;
1372         }
1373
1374         /* Count the components to the directory path */
1375         pieces = alloca(count * sizeof(*pieces));
1376         for (ptr = tmp; *ptr; ptr++) {
1377                 if (*ptr == '/') {
1378                         *ptr = '\0';
1379                         pieces[piececount++] = ptr + 1;
1380                 }
1381         }
1382
1383         *fullpath = '\0';
1384         for (x = 0; x < piececount; x++) {
1385                 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
1386                 strcat(fullpath, "/");
1387                 strcat(fullpath, pieces[x]);
1388                 res = mkdir(fullpath, mode);
1389                 if (res && errno != EEXIST)
1390                         return errno;
1391         }
1392         return 0;
1393 }
1394
1395 int ast_utils_init(void)
1396 {
1397 #ifdef HAVE_DEV_URANDOM
1398         dev_urandom_fd = open("/dev/urandom", O_RDONLY);
1399 #endif
1400         base64_init();
1401 #ifdef DEBUG_THREADS
1402         ast_cli_register_multiple(utils_cli, sizeof(utils_cli) / sizeof(utils_cli[0]));
1403 #endif
1404         return 0;
1405 }