use new (separate) dependencies file from menuselect
[asterisk/asterisk.git] / 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/types.h>
38 #include <sys/socket.h>
39 #include <netinet/in.h>
40 #include <arpa/inet.h>
41
42 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
43 #include "asterisk/lock.h"
44 #include "asterisk/io.h"
45 #include "asterisk/logger.h"
46 #include "asterisk/md5.h"
47 #include "asterisk/sha1.h"
48 #include "asterisk/options.h"
49
50 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
51 #include "asterisk/strings.h"
52
53 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
54 #include "asterisk/time.h"
55
56 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
57 #include "asterisk/stringfields.h"
58
59 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
60 #include "asterisk/utils.h"
61
62 static char base64[64];
63 static char b2a[256];
64
65 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined(__APPLE__) || defined(__CYGWIN__)
66
67 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
68 #undef gethostbyname
69
70 AST_MUTEX_DEFINE_STATIC(__mutex);
71
72 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
73 \note This
74 routine is derived from code originally written and placed in the public 
75 domain by Enzo Michelangeli <em@em.no-ip.com> */
76
77 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
78                                 size_t buflen, struct hostent **result, 
79                                 int *h_errnop) 
80 {
81         int hsave;
82         struct hostent *ph;
83         ast_mutex_lock(&__mutex); /* begin critical area */
84         hsave = h_errno;
85
86         ph = gethostbyname(name);
87         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
88         if (ph == NULL) {
89                 *result = NULL;
90         } else {
91                 char **p, **q;
92                 char *pbuf;
93                 int nbytes=0;
94                 int naddr=0, naliases=0;
95                 /* determine if we have enough space in buf */
96
97                 /* count how many addresses */
98                 for (p = ph->h_addr_list; *p != 0; p++) {
99                         nbytes += ph->h_length; /* addresses */
100                         nbytes += sizeof(*p); /* pointers */
101                         naddr++;
102                 }
103                 nbytes += sizeof(*p); /* one more for the terminating NULL */
104
105                 /* count how many aliases, and total length of strings */
106                 for (p = ph->h_aliases; *p != 0; p++) {
107                         nbytes += (strlen(*p)+1); /* aliases */
108                         nbytes += sizeof(*p);  /* pointers */
109                         naliases++;
110                 }
111                 nbytes += sizeof(*p); /* one more for the terminating NULL */
112
113                 /* here nbytes is the number of bytes required in buffer */
114                 /* as a terminator must be there, the minimum value is ph->h_length */
115                 if(nbytes > buflen) {
116                         *result = NULL;
117                         ast_mutex_unlock(&__mutex); /* end critical area */
118                         return ERANGE; /* not enough space in buf!! */
119                 }
120
121                 /* There is enough space. Now we need to do a deep copy! */
122                 /* Allocation in buffer:
123                         from [0] to [(naddr-1) * sizeof(*p)]:
124                         pointers to addresses
125                         at [naddr * sizeof(*p)]:
126                         NULL
127                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
128                         pointers to aliases
129                         at [(naddr+naliases+1) * sizeof(*p)]:
130                         NULL
131                         then naddr addresses (fixed length), and naliases aliases (asciiz).
132                 */
133
134                 *ret = *ph;   /* copy whole structure (not its address!) */
135
136                 /* copy addresses */
137                 q = (char **)buf; /* pointer to pointers area (type: char **) */
138                 ret->h_addr_list = q; /* update pointer to address list */
139                 pbuf = buf + ((naddr+naliases+2)*sizeof(*p)); /* skip that area */
140                 for (p = ph->h_addr_list; *p != 0; p++) {
141                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
142                         *q++ = pbuf; /* the pointer is the one inside buf... */
143                         pbuf += ph->h_length; /* advance pbuf */
144                 }
145                 *q++ = NULL; /* address list terminator */
146
147                 /* copy aliases */
148                 ret->h_aliases = q; /* update pointer to aliases list */
149                 for (p = ph->h_aliases; *p != 0; p++) {
150                         strcpy(pbuf, *p); /* copy alias strings */
151                         *q++ = pbuf; /* the pointer is the one inside buf... */
152                         pbuf += strlen(*p); /* advance pbuf */
153                         *pbuf++ = 0; /* string terminator */
154                 }
155                 *q++ = NULL; /* terminator */
156
157                 strcpy(pbuf, ph->h_name); /* copy alias strings */
158                 ret->h_name = pbuf;
159                 pbuf += strlen(ph->h_name); /* advance pbuf */
160                 *pbuf++ = 0; /* string terminator */
161
162                 *result = ret;  /* and let *result point to structure */
163
164         }
165         h_errno = hsave;  /* restore h_errno */
166         ast_mutex_unlock(&__mutex); /* end critical area */
167
168         return (*result == NULL); /* return 0 on success, non-zero on error */
169 }
170
171
172 #endif
173
174 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the 
175    standard gethostbyname (which is not thread safe)
176 */
177 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
178 {
179         int res;
180         int herrno;
181         int dots=0;
182         const char *s;
183         struct hostent *result = NULL;
184         /* Although it is perfectly legitimate to lookup a pure integer, for
185            the sake of the sanity of people who like to name their peers as
186            integers, we break with tradition and refuse to look up a
187            pure integer */
188         s = host;
189         res = 0;
190         while(s && *s) {
191                 if (*s == '.')
192                         dots++;
193                 else if (!isdigit(*s))
194                         break;
195                 s++;
196         }
197         if (!s || !*s) {
198                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
199                 if (dots != 3)
200                         return NULL;
201                 memset(hp, 0, sizeof(struct ast_hostent));
202                 hp->hp.h_addr_list = (void *) hp->buf;
203                 hp->hp.h_addr = hp->buf + sizeof(void *);
204                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
205                         return &hp->hp;
206                 return NULL;
207                 
208         }
209 #ifdef SOLARIS
210         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
211
212         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
213                 return NULL;
214 #else
215         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
216
217         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
218                 return NULL;
219 #endif
220         return &hp->hp;
221 }
222
223
224
225 AST_MUTEX_DEFINE_STATIC(test_lock);
226 AST_MUTEX_DEFINE_STATIC(test_lock2);
227 static pthread_t test_thread; 
228 static int lock_count = 0;
229 static int test_errors = 0;
230
231 /*! \brief This is a regression test for recursive mutexes.
232    test_for_thread_safety() will return 0 if recursive mutex locks are
233    working properly, and non-zero if they are not working properly. */
234 static void *test_thread_body(void *data) 
235
236         ast_mutex_lock(&test_lock);
237         lock_count += 10;
238         if (lock_count != 10) 
239                 test_errors++;
240         ast_mutex_lock(&test_lock);
241         lock_count += 10;
242         if (lock_count != 20) 
243                 test_errors++;
244         ast_mutex_lock(&test_lock2);
245         ast_mutex_unlock(&test_lock);
246         lock_count -= 10;
247         if (lock_count != 10) 
248                 test_errors++;
249         ast_mutex_unlock(&test_lock);
250         lock_count -= 10;
251         ast_mutex_unlock(&test_lock2);
252         if (lock_count != 0) 
253                 test_errors++;
254         return NULL;
255
256
257 int test_for_thread_safety(void)
258
259         ast_mutex_lock(&test_lock2);
260         ast_mutex_lock(&test_lock);
261         lock_count += 1;
262         ast_mutex_lock(&test_lock);
263         lock_count += 1;
264         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
265         usleep(100);
266         if (lock_count != 2) 
267                 test_errors++;
268         ast_mutex_unlock(&test_lock);
269         lock_count -= 1;
270         usleep(100); 
271         if (lock_count != 1) 
272                 test_errors++;
273         ast_mutex_unlock(&test_lock);
274         lock_count -= 1;
275         if (lock_count != 0) 
276                 test_errors++;
277         ast_mutex_unlock(&test_lock2);
278         usleep(100);
279         if (lock_count != 0) 
280                 test_errors++;
281         pthread_join(test_thread, NULL);
282         return(test_errors);          /* return 0 on success. */
283 }
284
285 /*! \brief Produce 32 char MD5 hash of value. */
286 void ast_md5_hash(char *output, char *input)
287 {
288         struct MD5Context md5;
289         unsigned char digest[16];
290         char *ptr;
291         int x;
292
293         MD5Init(&md5);
294         MD5Update(&md5, (unsigned char *)input, strlen(input));
295         MD5Final(digest, &md5);
296         ptr = output;
297         for (x=0; x<16; x++)
298                 ptr += sprintf(ptr, "%2.2x", digest[x]);
299 }
300
301 /*! \brief Produce 40 char SHA1 hash of value. */
302 void ast_sha1_hash(char *output, char *input)
303 {
304         struct SHA1Context sha;
305         char *ptr;
306         int x;
307         uint8_t Message_Digest[20];
308
309         SHA1Reset(&sha);
310         
311         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
312
313         SHA1Result(&sha, Message_Digest);
314         ptr = output;
315         for (x = 0; x < 20; x++)
316                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
317 }
318
319 /*! \brief decode BASE64 encoded text */
320 int ast_base64decode(unsigned char *dst, const char *src, int max)
321 {
322         int cnt = 0;
323         unsigned int byte = 0;
324         unsigned int bits = 0;
325         int incnt = 0;
326         while(*src && (cnt < max)) {
327                 /* Shift in 6 bits of input */
328                 byte <<= 6;
329                 byte |= (b2a[(int)(*src)]) & 0x3f;
330                 bits += 6;
331                 src++;
332                 incnt++;
333                 /* If we have at least 8 bits left over, take that character 
334                    off the top */
335                 if (bits >= 8)  {
336                         bits -= 8;
337                         *dst = (byte >> bits) & 0xff;
338                         dst++;
339                         cnt++;
340                 }
341         }
342         /* Dont worry about left over bits, they're extra anyway */
343         return cnt;
344 }
345
346 /*! \brief encode text to BASE64 coding */
347 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
348 {
349         int cnt = 0;
350         int col = 0;
351         unsigned int byte = 0;
352         int bits = 0;
353         int cntin = 0;
354         /* Reserve space for null byte at end of string */
355         max--;
356         while((cntin < srclen) && (cnt < max)) {
357                 byte <<= 8;
358                 byte |= *(src++);
359                 bits += 8;
360                 cntin++;
361                 if ((bits == 24) && (cnt + 4 < max)) {
362                         *dst++ = base64[(byte >> 18) & 0x3f];
363                         *dst++ = base64[(byte >> 12) & 0x3f];
364                         *dst++ = base64[(byte >> 6) & 0x3f];
365                         *dst++ = base64[byte & 0x3f];
366                         cnt += 4;
367                         col += 4;
368                         bits = 0;
369                         byte = 0;
370                 }
371                 if (linebreaks && (cnt < max) && (col == 64)) {
372                         *dst++ = '\n';
373                         cnt++;
374                         col = 0;
375                 }
376         }
377         if (bits && (cnt + 4 < max)) {
378                 /* Add one last character for the remaining bits, 
379                    padding the rest with 0 */
380                 byte <<= 24 - bits;
381                 *dst++ = base64[(byte >> 18) & 0x3f];
382                 *dst++ = base64[(byte >> 12) & 0x3f];
383                 if (bits == 16)
384                         *dst++ = base64[(byte >> 6) & 0x3f];
385                 else
386                         *dst++ = '=';
387                 *dst++ = '=';
388                 cnt += 4;
389         }
390         if (linebreaks && (cnt < max)) {
391                 *dst++ = '\n';
392                 cnt++;
393         }
394         *dst = '\0';
395         return cnt;
396 }
397
398 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
399 {
400         return ast_base64encode_full(dst, src, srclen, max, 0);
401 }
402
403 static void base64_init(void)
404 {
405         int x;
406         memset(b2a, -1, sizeof(b2a));
407         /* Initialize base-64 Conversion table */
408         for (x=0;x<26;x++) {
409                 /* A-Z */
410                 base64[x] = 'A' + x;
411                 b2a['A' + x] = x;
412                 /* a-z */
413                 base64[x + 26] = 'a' + x;
414                 b2a['a' + x] = x + 26;
415                 /* 0-9 */
416                 if (x < 10) {
417                         base64[x + 52] = '0' + x;
418                         b2a['0' + x] = x + 52;
419                 }
420         }
421         base64[62] = '+';
422         base64[63] = '/';
423         b2a[(int)'+'] = 62;
424         b2a[(int)'/'] = 63;
425 #if 0
426         for (x=0;x<64;x++) {
427                 if (b2a[(int)base64[x]] != x) {
428                         fprintf(stderr, "!!! %d failed\n", x);
429                 } else
430                         fprintf(stderr, "--- %d passed\n", x);
431         }
432 #endif
433 }
434
435 /*! \brief  ast_uri_encode: Turn text string to URI-encoded %XX version
436 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
437         as in the SIP protocol spec 
438         If doreserved == 1 we will convert reserved characters also.
439         RFC 2396, section 2.4
440         outbuf needs to have more memory allocated than the instring
441         to have room for the expansion. Every char that is converted
442         is replaced by three ASCII characters.
443
444         Note: The doreserved option is needed for replaces header in
445         SIP transfers.
446 */
447 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved) 
448 {
449         char *reserved = ";/?:@&=+$, "; /* Reserved chars */
450
451         const char *ptr  = string;      /* Start with the string */
452         char *out = NULL;
453         char *buf = NULL;
454
455         strncpy(outbuf, string, buflen);
456
457         /* If there's no characters to convert, just go through and don't do anything */
458         while (*ptr) {
459                 if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
460                         /* Oops, we need to start working here */
461                         if (!buf) {
462                                 buf = outbuf;
463                                 out = buf + (ptr - string) ;    /* Set output ptr */
464                         }
465                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
466                 } else if (buf) {
467                         *out = *ptr;    /* Continue copying the string */
468                         out++;
469                 } 
470                 ptr++;
471         }
472         if (buf)
473                 *out = '\0';
474         return outbuf;
475 }
476
477 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
478 void ast_uri_decode(char *s) 
479 {
480         char *o;
481         unsigned int tmp;
482
483         for (o = s; *s; s++, o++) {
484                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
485                         /* have '%', two chars and correct parsing */
486                         *o = tmp;
487                         s += 2; /* Will be incremented once more when we break out */
488                 } else /* all other cases, just copy */
489                         *o = *s;
490         }
491         *o = '\0';
492 }
493
494 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
495 const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia)
496 {
497         return inet_ntop(AF_INET, &ia, buf, bufsiz);
498 }
499
500 int ast_utils_init(void)
501 {
502         base64_init();
503         return 0;
504 }
505
506 #ifndef __linux__
507 #undef pthread_create /* For ast_pthread_create function only */
508 #endif /* !__linux__ */
509
510 /*
511  * support for 'show threads'. The start routine is wrapped by
512  * dummy_start(), so that ast_register_thread() and
513  * ast_unregister_thread() know the thread identifier.
514  */
515 struct thr_arg {
516         void *(*start_routine)(void *);
517         void *data;
518         char *name;
519 };
520
521 /*
522  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
523  * are odd macros which start and end a block, so they _must_ be
524  * used in pairs (the latter with a '1' argument to call the
525  * handler on exit.
526  * On BSD we don't need this, but we keep it for compatibility with the MAC.
527  */
528 static void *dummy_start(void *data)
529 {
530         void *ret;
531         struct thr_arg a = *((struct thr_arg *)data);   /* make a local copy */
532
533         free(data);
534         ast_register_thread(a.name);
535         pthread_cleanup_push(ast_unregister_thread, (void *)pthread_self());    /* on unregister */
536         ret = a.start_routine(a.data);
537         pthread_cleanup_pop(1);
538         return ret;
539 }
540
541 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize,
542         const char *file, const char *caller, int line, const char *start_fn)
543 {
544         struct thr_arg *a;
545
546         pthread_attr_t lattr;
547         if (!attr) {
548                 pthread_attr_init(&lattr);
549                 attr = &lattr;
550         }
551 #ifdef __linux__
552         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
553            which is kind of useless. Change this here to
554            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
555            priority will propagate down to new threads by default.
556            This does mean that callers cannot set a different priority using
557            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
558            the priority afterwards with pthread_setschedparam(). */
559         errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED);
560         if (errno)
561                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched returned non-zero: %s\n", strerror(errno));
562 #endif
563
564         if (!stacksize)
565                 stacksize = AST_STACKSIZE;
566         errno = pthread_attr_setstacksize(attr, stacksize);
567         if (errno)
568                 ast_log(LOG_WARNING, "pthread_attr_setstacksize returned non-zero: %s\n", strerror(errno));
569         a = ast_malloc(sizeof(*a));
570         if (!a)
571                 ast_log(LOG_WARNING, "no memory, thread %s will not be listed\n", start_fn);
572         else {  /* remap parameters */
573                 a->start_routine = start_routine;
574                 a->data = data;
575                 start_routine = dummy_start;
576                 asprintf(&a->name, "%-20s started at [%5d] %s %s()",
577                         start_fn, line, file, caller);
578                 data = a;
579         }
580         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
581 }
582
583 int ast_wait_for_input(int fd, int ms)
584 {
585         struct pollfd pfd[1];
586         memset(pfd, 0, sizeof(pfd));
587         pfd[0].fd = fd;
588         pfd[0].events = POLLIN|POLLPRI;
589         return poll(pfd, 1, ms);
590 }
591
592 int ast_carefulwrite(int fd, char *s, int len, int timeoutms) 
593 {
594         /* Try to write string, but wait no more than ms milliseconds
595            before timing out */
596         int res = 0;
597         struct pollfd fds[1];
598         while (len) {
599                 res = write(fd, s, len);
600                 if ((res < 0) && (errno != EAGAIN)) {
601                         return -1;
602                 }
603                 if (res < 0)
604                         res = 0;
605                 len -= res;
606                 s += res;
607                 res = 0;
608                 if (len) {
609                         fds[0].fd = fd;
610                         fds[0].events = POLLOUT;
611                         /* Wait until writable again */
612                         res = poll(fds, 1, timeoutms);
613                         if (res < 1)
614                                 return -1;
615                 }
616         }
617         return res;
618 }
619
620 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
621 {
622         char *e;
623         char *q;
624
625         s = ast_strip(s);
626         if ((q = strchr(beg_quotes, *s))) {
627                 e = s + strlen(s) - 1;
628                 if (*e == *(end_quotes + (q - beg_quotes))) {
629                         s++;
630                         *e = '\0';
631                 }
632         }
633
634         return s;
635 }
636
637 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
638 {
639         int result;
640
641         if (!buffer || !*buffer || !space || !*space)
642                 return -1;
643
644         result = vsnprintf(*buffer, *space, fmt, ap);
645
646         if (result < 0)
647                 return -1;
648         else if (result > *space)
649                 result = *space;
650
651         *buffer += result;
652         *space -= result;
653         return 0;
654 }
655
656 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
657 {
658         va_list ap;
659         int result;
660
661         va_start(ap, fmt);
662         result = ast_build_string_va(buffer, space, fmt, ap);
663         va_end(ap);
664
665         return result;
666 }
667
668 int ast_true(const char *s)
669 {
670         if (ast_strlen_zero(s))
671                 return 0;
672
673         /* Determine if this is a true value */
674         if (!strcasecmp(s, "yes") ||
675             !strcasecmp(s, "true") ||
676             !strcasecmp(s, "y") ||
677             !strcasecmp(s, "t") ||
678             !strcasecmp(s, "1") ||
679             !strcasecmp(s, "on"))
680                 return -1;
681
682         return 0;
683 }
684
685 int ast_false(const char *s)
686 {
687         if (ast_strlen_zero(s))
688                 return 0;
689
690         /* Determine if this is a false value */
691         if (!strcasecmp(s, "no") ||
692             !strcasecmp(s, "false") ||
693             !strcasecmp(s, "n") ||
694             !strcasecmp(s, "f") ||
695             !strcasecmp(s, "0") ||
696             !strcasecmp(s, "off"))
697                 return -1;
698
699         return 0;
700 }
701
702 #define ONE_MILLION     1000000
703 /*
704  * put timeval in a valid range. usec is 0..999999
705  * negative values are not allowed and truncated.
706  */
707 static struct timeval tvfix(struct timeval a)
708 {
709         if (a.tv_usec >= ONE_MILLION) {
710                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
711                         a.tv_sec, (long int) a.tv_usec);
712                 a.tv_sec += a.tv_usec / ONE_MILLION;
713                 a.tv_usec %= ONE_MILLION;
714         } else if (a.tv_usec < 0) {
715                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
716                         a.tv_sec, (long int) a.tv_usec);
717                 a.tv_usec = 0;
718         }
719         return a;
720 }
721
722 struct timeval ast_tvadd(struct timeval a, struct timeval b)
723 {
724         /* consistency checks to guarantee usec in 0..999999 */
725         a = tvfix(a);
726         b = tvfix(b);
727         a.tv_sec += b.tv_sec;
728         a.tv_usec += b.tv_usec;
729         if (a.tv_usec >= ONE_MILLION) {
730                 a.tv_sec++;
731                 a.tv_usec -= ONE_MILLION;
732         }
733         return a;
734 }
735
736 struct timeval ast_tvsub(struct timeval a, struct timeval b)
737 {
738         /* consistency checks to guarantee usec in 0..999999 */
739         a = tvfix(a);
740         b = tvfix(b);
741         a.tv_sec -= b.tv_sec;
742         a.tv_usec -= b.tv_usec;
743         if (a.tv_usec < 0) {
744                 a.tv_sec-- ;
745                 a.tv_usec += ONE_MILLION;
746         }
747         return a;
748 }
749 #undef ONE_MILLION
750
751 #ifndef HAVE_STRCASESTR
752 static char *upper(const char *orig, char *buf, int bufsize)
753 {
754         int i = 0;
755
756         while (i < (bufsize - 1) && orig[i]) {
757                 buf[i] = toupper(orig[i]);
758                 i++;
759         }
760
761         buf[i] = '\0';
762
763         return buf;
764 }
765
766 char *strcasestr(const char *haystack, const char *needle)
767 {
768         char *u1, *u2;
769         int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
770
771         u1 = alloca(u1len);
772         u2 = alloca(u2len);
773         if (u1 && u2) {
774                 char *offset;
775                 if (u2len > u1len) {
776                         /* Needle bigger than haystack */
777                         return NULL;
778                 }
779                 offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
780                 if (offset) {
781                         /* Return the offset into the original string */
782                         return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
783                 } else {
784                         return NULL;
785                 }
786         } else {
787                 ast_log(LOG_ERROR, "Out of memory\n");
788                 return NULL;
789         }
790 }
791 #endif /* !HAVE_STRCASESTR */
792
793 #ifndef HAVE_STRNLEN
794 size_t strnlen(const char *s, size_t n)
795 {
796         size_t len;
797
798         for (len=0; len < n; len++)
799                 if (s[len] == '\0')
800                         break;
801
802         return len;
803 }
804 #endif /* !HAVE_STRNLEN */
805
806 #if !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC)
807 char *strndup(const char *s, size_t n)
808 {
809         size_t len = strnlen(s, n);
810         char *new = ast_malloc(len + 1);
811
812         if (!new)
813                 return NULL;
814
815         new[len] = '\0';
816         return memcpy(new, s, len);
817 }
818 #endif /* !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC) */
819
820 #if !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC)
821 int vasprintf(char **strp, const char *fmt, va_list ap)
822 {
823         int size;
824         va_list ap2;
825         char s;
826
827         *strp = NULL;
828         va_copy(ap2, ap);
829         size = vsnprintf(&s, 1, fmt, ap2);
830         va_end(ap2);
831         *strp = ast_malloc(size + 1);
832         if (!*strp)
833                 return -1;
834         vsnprintf(*strp, size + 1, fmt, ap);
835
836         return size;
837 }
838 #endif /* !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC) */
839
840 /*
841  * Based on Code from bsd-asprintf from OpenSSH
842  * Copyright (c) 2004 Darren Tucker.
843  *
844  * Based originally on asprintf.c from OpenBSD:
845  * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
846  *
847  * Permission to use, copy, modify, and distribute this software for any
848  * purpose with or without fee is hereby granted, provided that the above
849  * copyright notice and this permission notice appear in all copies.
850  *
851  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
852  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
853  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
854  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
855  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
856  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
857  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
858  */
859 #if !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC) 
860 int asprintf(char **str, const char *fmt, ...)
861 {
862         va_list ap;
863         int ret;
864
865         *str = NULL;
866         va_start(ap, fmt);
867         ret = vasprintf(str, fmt, ap);
868         va_end(ap);
869
870         return ret;
871 }
872 #endif /* !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC) */
873
874 #ifndef HAVE_STRTOQ
875 #ifndef LONG_MIN
876 #define LONG_MIN        (-9223372036854775807L-1L)
877                                          /* min value of a "long int" */
878 #endif
879 #ifndef LONG_MAX
880 #define LONG_MAX        9223372036854775807L
881                                          /* max value of a "long int" */
882 #endif
883
884 /*! \brief
885  * Convert a string to a quad integer.
886  *
887  * \note Ignores `locale' stuff.  Assumes that the upper and lower case
888  * alphabets and digits are each contiguous.
889  */
890 uint64_t strtoq(const char *nptr, char **endptr, int base)
891 {
892          const char *s;
893          uint64_t acc;
894          unsigned char c;
895          uint64_t qbase, cutoff;
896          int neg, any, cutlim;
897
898          /*
899           * Skip white space and pick up leading +/- sign if any.
900           * If base is 0, allow 0x for hex and 0 for octal, else
901           * assume decimal; if base is already 16, allow 0x.
902           */
903          s = nptr;
904          do {
905                  c = *s++;
906          } while (isspace(c));
907          if (c == '-') {
908                  neg = 1;
909                  c = *s++;
910          } else {
911                  neg = 0;
912                  if (c == '+')
913                          c = *s++;
914          }
915          if ((base == 0 || base == 16) &&
916              c == '\0' && (*s == 'x' || *s == 'X')) {
917                  c = s[1];
918                  s += 2;
919                  base = 16;
920          }
921          if (base == 0)
922                  base = c == '\0' ? 8 : 10;
923
924          /*
925           * Compute the cutoff value between legal numbers and illegal
926           * numbers.  That is the largest legal value, divided by the
927           * base.  An input number that is greater than this value, if
928           * followed by a legal input character, is too big.  One that
929           * is equal to this value may be valid or not; the limit
930           * between valid and invalid numbers is then based on the last
931           * digit.  For instance, if the range for quads is
932           * [-9223372036854775808..9223372036854775807] and the input base
933           * is 10, cutoff will be set to 922337203685477580 and cutlim to
934           * either 7 (neg==0) or 8 (neg==1), meaning that if we have
935           * accumulated a value > 922337203685477580, or equal but the
936           * next digit is > 7 (or 8), the number is too big, and we will
937           * return a range error.
938           *
939           * Set any if any `digits' consumed; make it negative to indicate
940           * overflow.
941           */
942          qbase = (unsigned)base;
943          cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
944          cutlim = cutoff % qbase;
945          cutoff /= qbase;
946          for (acc = 0, any = 0;; c = *s++) {
947                  if (!isascii(c))
948                          break;
949                  if (isdigit(c))
950                          c -= '\0';
951                  else if (isalpha(c))
952                          c -= isupper(c) ? 'A' - 10 : 'a' - 10;
953                  else
954                          break;
955                  if (c >= base)
956                          break;
957                  if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
958                          any = -1;
959                  else {
960                          any = 1;
961                          acc *= qbase;
962                          acc += c;
963                  }
964          }
965          if (any < 0) {
966                  acc = neg ? LONG_MIN : LONG_MAX;
967          } else if (neg)
968                  acc = -acc;
969          if (endptr != 0)
970                  *((const char **)endptr) = any ? s - 1 : nptr;
971          return acc;
972 }
973 #endif /* !HAVE_STRTOQ */
974
975 #ifndef HAVE_GETLOADAVG
976 #ifdef linux
977 /*! \brief Alternative method of getting load avg on Linux only */
978 int getloadavg(double *list, int nelem)
979 {
980         FILE *LOADAVG;
981         double avg[3] = { 0.0, 0.0, 0.0 };
982         int i, res = -1;
983
984         if ((LOADAVG = fopen("/proc/loadavg", "r"))) {
985                 fscanf(LOADAVG, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]);
986                 res = 0;
987                 fclose(LOADAVG);
988         }
989
990         for (i = 0; (i < nelem) && (i < 3); i++) {
991                 list[i] = avg[i];
992         }
993
994         return res;
995 }
996 #else /* !linux */
997 /*! \brief Return something that won't cancel the call, but still return -1, in case
998  * we correct the implementation to check return value */
999 int getloadavg(double *list, int nelem)
1000 {
1001         int i;
1002
1003         for (i = 0; i < nelem; i++) {
1004                 list[i] = 0.1;
1005         }
1006         return -1;
1007 }
1008 #endif /* linux */
1009 #endif /* !defined(_BSD_SOURCE) */
1010
1011 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1012  * BSD libc (and others) do not. */
1013 #ifndef linux
1014
1015 AST_MUTEX_DEFINE_STATIC(randomlock);
1016
1017 long int ast_random(void)
1018 {
1019         long int res;
1020         ast_mutex_lock(&randomlock);
1021         res = random();
1022         ast_mutex_unlock(&randomlock);
1023         return res;
1024 }
1025 #endif
1026
1027 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1028 {
1029         char *dataPut = start;
1030         int inEscape = 0;
1031         int inQuotes = 0;
1032
1033         for (; *start; start++) {
1034                 if (inEscape) {
1035                         *dataPut++ = *start;       /* Always goes verbatim */
1036                         inEscape = 0;
1037                 } else {
1038                         if (*start == '\\') {
1039                                 inEscape = 1;      /* Do not copy \ into the data */
1040                         } else if (*start == '\'') {
1041                                 inQuotes = 1-inQuotes;   /* Do not copy ' into the data */
1042                         } else {
1043                                 /* Replace , with |, unless in quotes */
1044                                 *dataPut++ = inQuotes ? *start : ((*start==find) ? replace_with : *start);
1045                         }
1046                 }
1047         }
1048         if (start != dataPut)
1049                 *dataPut = 0;
1050         return dataPut;
1051 }
1052
1053 void ast_join(char *s, size_t len, char * const w[])
1054 {
1055         int x, ofs = 0;
1056         const char *src;
1057
1058         /* Join words into a string */
1059         if (!s)
1060                 return;
1061         for (x=0; ofs < len && w[x]; x++) {
1062                 if (x > 0)
1063                         s[ofs++] = ' ';
1064                 for (src = w[x]; *src && ofs < len; src++)
1065                         s[ofs++] = *src;
1066         }
1067         if (ofs == len)
1068                 ofs--;
1069         s[ofs] = '\0';
1070 }
1071
1072 const char __ast_string_field_empty[] = "";
1073
1074 static int add_string_pool(struct ast_string_field_mgr *mgr, size_t size)
1075 {
1076         struct ast_string_field_pool *pool;
1077
1078         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
1079                 return -1;
1080         
1081         pool->prev = mgr->pool;
1082         mgr->pool = pool;
1083         mgr->size = size;
1084         mgr->space = size;
1085         mgr->used = 0;
1086
1087         return 0;
1088 }
1089
1090 int __ast_string_field_init(struct ast_string_field_mgr *mgr, size_t size,
1091                             ast_string_field *fields, int num_fields)
1092 {
1093         int index;
1094
1095         if (add_string_pool(mgr, size))
1096                 return -1;
1097
1098         for (index = 0; index < num_fields; index++)
1099                 fields[index] = __ast_string_field_empty;
1100
1101         return 0;
1102 }
1103
1104 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, size_t needed,
1105                                                 ast_string_field *fields, int num_fields)
1106 {
1107         char *result = NULL;
1108
1109         if (__builtin_expect(needed > mgr->space, 0)) {
1110                 size_t new_size = mgr->size * 2;
1111
1112                 while (new_size < needed)
1113                         new_size *= 2;
1114
1115                 if (add_string_pool(mgr, new_size))
1116                         return NULL;
1117         }
1118
1119         result = mgr->pool->base + mgr->used;
1120         mgr->used += needed;
1121         mgr->space -= needed;
1122         return result;
1123 }
1124
1125 void __ast_string_field_index_build(struct ast_string_field_mgr *mgr,
1126                                     ast_string_field *fields, int num_fields,
1127                                     int index, const char *format, ...)
1128 {
1129         size_t needed;
1130         va_list ap1, ap2;
1131
1132         va_start(ap1, format);
1133         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
1134
1135         needed = vsnprintf(mgr->pool->base + mgr->used, mgr->space, format, ap1) + 1;
1136
1137         va_end(ap1);
1138
1139         if (needed > mgr->space) {
1140                 size_t new_size = mgr->size * 2;
1141
1142                 while (new_size < needed)
1143                         new_size *= 2;
1144
1145                 if (add_string_pool(mgr, new_size))
1146                         return;
1147
1148                 vsprintf(mgr->pool->base + mgr->used, format, ap2);
1149         }
1150
1151         fields[index] = mgr->pool->base + mgr->used;
1152         mgr->used += needed;
1153         mgr->space -= needed;
1154
1155         va_end(ap2);
1156 }
1157
1158 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1159 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1160 {
1161         int ret;
1162         ast_mutex_lock(&fetchadd_m);
1163         ret = *p;
1164         *p += v;
1165         ast_mutex_unlock(&fetchadd_m);
1166         return ret;
1167 }
1168
1169 /*! \brief
1170  * get values from config variables.
1171  */
1172 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1173 {
1174         long t;
1175         int scanned;
1176
1177         if (dst == NULL)
1178                 return -1;
1179
1180         *dst = _default;
1181
1182         if (ast_strlen_zero(src))
1183                 return -1;
1184
1185         /* only integer at the moment, but one day we could accept more formats */
1186         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
1187                 *dst = t;
1188                 if (consumed)
1189                         *consumed = scanned;
1190                 return 0;
1191         } else
1192                 return -1;
1193 }