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