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