Merged revisions 37419 via svnmerge from
[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 }
426
427 /*! \brief  ast_uri_encode: Turn text string to URI-encoded %XX version
428 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
429         as in the SIP protocol spec 
430         If doreserved == 1 we will convert reserved characters also.
431         RFC 2396, section 2.4
432         outbuf needs to have more memory allocated than the instring
433         to have room for the expansion. Every char that is converted
434         is replaced by three ASCII characters.
435
436         Note: The doreserved option is needed for replaces header in
437         SIP transfers.
438 */
439 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved) 
440 {
441         char *reserved = ";/?:@&=+$, "; /* Reserved chars */
442
443         const char *ptr  = string;      /* Start with the string */
444         char *out = NULL;
445         char *buf = NULL;
446
447         strncpy(outbuf, string, buflen);
448
449         /* If there's no characters to convert, just go through and don't do anything */
450         while (*ptr) {
451                 if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
452                         /* Oops, we need to start working here */
453                         if (!buf) {
454                                 buf = outbuf;
455                                 out = buf + (ptr - string) ;    /* Set output ptr */
456                         }
457                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
458                 } else if (buf) {
459                         *out = *ptr;    /* Continue copying the string */
460                         out++;
461                 } 
462                 ptr++;
463         }
464         if (buf)
465                 *out = '\0';
466         return outbuf;
467 }
468
469 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
470 void ast_uri_decode(char *s) 
471 {
472         char *o;
473         unsigned int tmp;
474
475         for (o = s; *s; s++, o++) {
476                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
477                         /* have '%', two chars and correct parsing */
478                         *o = tmp;
479                         s += 2; /* Will be incremented once more when we break out */
480                 } else /* all other cases, just copy */
481                         *o = *s;
482         }
483         *o = '\0';
484 }
485
486 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
487 const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia)
488 {
489         return inet_ntop(AF_INET, &ia, buf, bufsiz);
490 }
491
492 int ast_utils_init(void)
493 {
494         base64_init();
495         return 0;
496 }
497
498 #ifndef __linux__
499 #undef pthread_create /* For ast_pthread_create function only */
500 #endif /* !__linux__ */
501
502 /*
503  * support for 'show threads'. The start routine is wrapped by
504  * dummy_start(), so that ast_register_thread() and
505  * ast_unregister_thread() know the thread identifier.
506  */
507 struct thr_arg {
508         void *(*start_routine)(void *);
509         void *data;
510         char *name;
511 };
512
513 /*
514  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
515  * are odd macros which start and end a block, so they _must_ be
516  * used in pairs (the latter with a '1' argument to call the
517  * handler on exit.
518  * On BSD we don't need this, but we keep it for compatibility with the MAC.
519  */
520 static void *dummy_start(void *data)
521 {
522         void *ret;
523         struct thr_arg a = *((struct thr_arg *)data);   /* make a local copy */
524
525         free(data);
526         ast_register_thread(a.name);
527         pthread_cleanup_push(ast_unregister_thread, (void *)pthread_self());    /* on unregister */
528         ret = a.start_routine(a.data);
529         pthread_cleanup_pop(1);
530         return ret;
531 }
532
533 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize,
534         const char *file, const char *caller, int line, const char *start_fn)
535 {
536         struct thr_arg *a;
537
538         pthread_attr_t lattr;
539         if (!attr) {
540                 pthread_attr_init(&lattr);
541                 attr = &lattr;
542         }
543 #ifdef __linux__
544         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
545            which is kind of useless. Change this here to
546            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
547            priority will propagate down to new threads by default.
548            This does mean that callers cannot set a different priority using
549            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
550            the priority afterwards with pthread_setschedparam(). */
551         errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED);
552         if (errno)
553                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched returned non-zero: %s\n", strerror(errno));
554 #endif
555
556         if (!stacksize)
557                 stacksize = AST_STACKSIZE;
558         errno = pthread_attr_setstacksize(attr, stacksize);
559         if (errno)
560                 ast_log(LOG_WARNING, "pthread_attr_setstacksize returned non-zero: %s\n", strerror(errno));
561         a = ast_malloc(sizeof(*a));
562         if (!a)
563                 ast_log(LOG_WARNING, "no memory, thread %s will not be listed\n", start_fn);
564         else {  /* remap parameters */
565                 a->start_routine = start_routine;
566                 a->data = data;
567                 start_routine = dummy_start;
568                 asprintf(&a->name, "%-20s started at [%5d] %s %s()",
569                         start_fn, line, file, caller);
570                 data = a;
571         }
572         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
573 }
574
575 int ast_wait_for_input(int fd, int ms)
576 {
577         struct pollfd pfd[1];
578         memset(pfd, 0, sizeof(pfd));
579         pfd[0].fd = fd;
580         pfd[0].events = POLLIN|POLLPRI;
581         return poll(pfd, 1, ms);
582 }
583
584 int ast_carefulwrite(int fd, char *s, int len, int timeoutms) 
585 {
586         /* Try to write string, but wait no more than ms milliseconds
587            before timing out */
588         int res = 0;
589         struct pollfd fds[1];
590         while (len) {
591                 res = write(fd, s, len);
592                 if ((res < 0) && (errno != EAGAIN)) {
593                         return -1;
594                 }
595                 if (res < 0)
596                         res = 0;
597                 len -= res;
598                 s += res;
599                 res = 0;
600                 if (len) {
601                         fds[0].fd = fd;
602                         fds[0].events = POLLOUT;
603                         /* Wait until writable again */
604                         res = poll(fds, 1, timeoutms);
605                         if (res < 1)
606                                 return -1;
607                 }
608         }
609         return res;
610 }
611
612 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
613 {
614         char *e;
615         char *q;
616
617         s = ast_strip(s);
618         if ((q = strchr(beg_quotes, *s))) {
619                 e = s + strlen(s) - 1;
620                 if (*e == *(end_quotes + (q - beg_quotes))) {
621                         s++;
622                         *e = '\0';
623                 }
624         }
625
626         return s;
627 }
628
629 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
630 {
631         int result;
632
633         if (!buffer || !*buffer || !space || !*space)
634                 return -1;
635
636         result = vsnprintf(*buffer, *space, fmt, ap);
637
638         if (result < 0)
639                 return -1;
640         else if (result > *space)
641                 result = *space;
642
643         *buffer += result;
644         *space -= result;
645         return 0;
646 }
647
648 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
649 {
650         va_list ap;
651         int result;
652
653         va_start(ap, fmt);
654         result = ast_build_string_va(buffer, space, fmt, ap);
655         va_end(ap);
656
657         return result;
658 }
659
660 int ast_true(const char *s)
661 {
662         if (ast_strlen_zero(s))
663                 return 0;
664
665         /* Determine if this is a true value */
666         if (!strcasecmp(s, "yes") ||
667             !strcasecmp(s, "true") ||
668             !strcasecmp(s, "y") ||
669             !strcasecmp(s, "t") ||
670             !strcasecmp(s, "1") ||
671             !strcasecmp(s, "on"))
672                 return -1;
673
674         return 0;
675 }
676
677 int ast_false(const char *s)
678 {
679         if (ast_strlen_zero(s))
680                 return 0;
681
682         /* Determine if this is a false value */
683         if (!strcasecmp(s, "no") ||
684             !strcasecmp(s, "false") ||
685             !strcasecmp(s, "n") ||
686             !strcasecmp(s, "f") ||
687             !strcasecmp(s, "0") ||
688             !strcasecmp(s, "off"))
689                 return -1;
690
691         return 0;
692 }
693
694 #define ONE_MILLION     1000000
695 /*
696  * put timeval in a valid range. usec is 0..999999
697  * negative values are not allowed and truncated.
698  */
699 static struct timeval tvfix(struct timeval a)
700 {
701         if (a.tv_usec >= ONE_MILLION) {
702                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
703                         a.tv_sec, (long int) a.tv_usec);
704                 a.tv_sec += a.tv_usec / ONE_MILLION;
705                 a.tv_usec %= ONE_MILLION;
706         } else if (a.tv_usec < 0) {
707                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
708                         a.tv_sec, (long int) a.tv_usec);
709                 a.tv_usec = 0;
710         }
711         return a;
712 }
713
714 struct timeval ast_tvadd(struct timeval a, struct timeval b)
715 {
716         /* consistency checks to guarantee usec in 0..999999 */
717         a = tvfix(a);
718         b = tvfix(b);
719         a.tv_sec += b.tv_sec;
720         a.tv_usec += b.tv_usec;
721         if (a.tv_usec >= ONE_MILLION) {
722                 a.tv_sec++;
723                 a.tv_usec -= ONE_MILLION;
724         }
725         return a;
726 }
727
728 struct timeval ast_tvsub(struct timeval a, struct timeval b)
729 {
730         /* consistency checks to guarantee usec in 0..999999 */
731         a = tvfix(a);
732         b = tvfix(b);
733         a.tv_sec -= b.tv_sec;
734         a.tv_usec -= b.tv_usec;
735         if (a.tv_usec < 0) {
736                 a.tv_sec-- ;
737                 a.tv_usec += ONE_MILLION;
738         }
739         return a;
740 }
741 #undef ONE_MILLION
742
743 #ifndef HAVE_STRCASESTR
744 static char *upper(const char *orig, char *buf, int bufsize)
745 {
746         int i = 0;
747
748         while (i < (bufsize - 1) && orig[i]) {
749                 buf[i] = toupper(orig[i]);
750                 i++;
751         }
752
753         buf[i] = '\0';
754
755         return buf;
756 }
757
758 char *strcasestr(const char *haystack, const char *needle)
759 {
760         char *u1, *u2;
761         int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
762
763         u1 = alloca(u1len);
764         u2 = alloca(u2len);
765         if (u1 && u2) {
766                 char *offset;
767                 if (u2len > u1len) {
768                         /* Needle bigger than haystack */
769                         return NULL;
770                 }
771                 offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
772                 if (offset) {
773                         /* Return the offset into the original string */
774                         return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
775                 } else {
776                         return NULL;
777                 }
778         } else {
779                 ast_log(LOG_ERROR, "Out of memory\n");
780                 return NULL;
781         }
782 }
783 #endif /* !HAVE_STRCASESTR */
784
785 #ifndef HAVE_STRNLEN
786 size_t strnlen(const char *s, size_t n)
787 {
788         size_t len;
789
790         for (len = 0; len < n; len++)
791                 if (s[len] == '\0')
792                         break;
793
794         return len;
795 }
796 #endif /* !HAVE_STRNLEN */
797
798 #if !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC)
799 char *strndup(const char *s, size_t n)
800 {
801         size_t len = strnlen(s, n);
802         char *new = ast_malloc(len + 1);
803
804         if (!new)
805                 return NULL;
806
807         new[len] = '\0';
808         return memcpy(new, s, len);
809 }
810 #endif /* !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC) */
811
812 #if !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC)
813 int vasprintf(char **strp, const char *fmt, va_list ap)
814 {
815         int size;
816         va_list ap2;
817         char s;
818
819         *strp = NULL;
820         va_copy(ap2, ap);
821         size = vsnprintf(&s, 1, fmt, ap2);
822         va_end(ap2);
823         *strp = ast_malloc(size + 1);
824         if (!*strp)
825                 return -1;
826         vsnprintf(*strp, size + 1, fmt, ap);
827
828         return size;
829 }
830 #endif /* !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC) */
831
832 /*
833  * Based on Code from bsd-asprintf from OpenSSH
834  * Copyright (c) 2004 Darren Tucker.
835  *
836  * Based originally on asprintf.c from OpenBSD:
837  * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
838  *
839  * Permission to use, copy, modify, and distribute this software for any
840  * purpose with or without fee is hereby granted, provided that the above
841  * copyright notice and this permission notice appear in all copies.
842  *
843  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
844  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
845  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
846  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
847  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
848  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
849  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
850  */
851 #if !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC) 
852 int asprintf(char **str, const char *fmt, ...)
853 {
854         va_list ap;
855         int ret;
856
857         *str = NULL;
858         va_start(ap, fmt);
859         ret = vasprintf(str, fmt, ap);
860         va_end(ap);
861
862         return ret;
863 }
864 #endif /* !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC) */
865
866 #ifndef HAVE_STRTOQ
867 #ifndef LONG_MIN
868 #define LONG_MIN        (-9223372036854775807L-1L)
869                                          /* min value of a "long int" */
870 #endif
871 #ifndef LONG_MAX
872 #define LONG_MAX        9223372036854775807L
873                                          /* max value of a "long int" */
874 #endif
875
876 /*! \brief
877  * Convert a string to a quad integer.
878  *
879  * \note Ignores `locale' stuff.  Assumes that the upper and lower case
880  * alphabets and digits are each contiguous.
881  */
882 uint64_t strtoq(const char *nptr, char **endptr, int base)
883 {
884          const char *s;
885          uint64_t acc;
886          unsigned char c;
887          uint64_t qbase, cutoff;
888          int neg, any, cutlim;
889
890          /*
891           * Skip white space and pick up leading +/- sign if any.
892           * If base is 0, allow 0x for hex and 0 for octal, else
893           * assume decimal; if base is already 16, allow 0x.
894           */
895          s = nptr;
896          do {
897                  c = *s++;
898          } while (isspace(c));
899          if (c == '-') {
900                  neg = 1;
901                  c = *s++;
902          } else {
903                  neg = 0;
904                  if (c == '+')
905                          c = *s++;
906          }
907          if ((base == 0 || base == 16) &&
908              c == '\0' && (*s == 'x' || *s == 'X')) {
909                  c = s[1];
910                  s += 2;
911                  base = 16;
912          }
913          if (base == 0)
914                  base = c == '\0' ? 8 : 10;
915
916          /*
917           * Compute the cutoff value between legal numbers and illegal
918           * numbers.  That is the largest legal value, divided by the
919           * base.  An input number that is greater than this value, if
920           * followed by a legal input character, is too big.  One that
921           * is equal to this value may be valid or not; the limit
922           * between valid and invalid numbers is then based on the last
923           * digit.  For instance, if the range for quads is
924           * [-9223372036854775808..9223372036854775807] and the input base
925           * is 10, cutoff will be set to 922337203685477580 and cutlim to
926           * either 7 (neg==0) or 8 (neg==1), meaning that if we have
927           * accumulated a value > 922337203685477580, or equal but the
928           * next digit is > 7 (or 8), the number is too big, and we will
929           * return a range error.
930           *
931           * Set any if any `digits' consumed; make it negative to indicate
932           * overflow.
933           */
934          qbase = (unsigned)base;
935          cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
936          cutlim = cutoff % qbase;
937          cutoff /= qbase;
938          for (acc = 0, any = 0;; c = *s++) {
939                  if (!isascii(c))
940                          break;
941                  if (isdigit(c))
942                          c -= '\0';
943                  else if (isalpha(c))
944                          c -= isupper(c) ? 'A' - 10 : 'a' - 10;
945                  else
946                          break;
947                  if (c >= base)
948                          break;
949                  if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
950                          any = -1;
951                  else {
952                          any = 1;
953                          acc *= qbase;
954                          acc += c;
955                  }
956          }
957          if (any < 0) {
958                  acc = neg ? LONG_MIN : LONG_MAX;
959          } else if (neg)
960                  acc = -acc;
961          if (endptr != 0)
962                  *((const char **)endptr) = any ? s - 1 : nptr;
963          return acc;
964 }
965 #endif /* !HAVE_STRTOQ */
966
967 #ifndef HAVE_GETLOADAVG
968 #ifdef linux
969 /*! \brief Alternative method of getting load avg on Linux only */
970 int getloadavg(double *list, int nelem)
971 {
972         FILE *LOADAVG;
973         double avg[3] = { 0.0, 0.0, 0.0 };
974         int i, res = -1;
975
976         if ((LOADAVG = fopen("/proc/loadavg", "r"))) {
977                 fscanf(LOADAVG, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]);
978                 res = 0;
979                 fclose(LOADAVG);
980         }
981
982         for (i = 0; (i < nelem) && (i < 3); i++) {
983                 list[i] = avg[i];
984         }
985
986         return res;
987 }
988 #else /* !linux */
989 /*! \brief Return something that won't cancel the call, but still return -1, in case
990  * we correct the implementation to check return value */
991 int getloadavg(double *list, int nelem)
992 {
993         int i;
994
995         for (i = 0; i < nelem; i++) {
996                 list[i] = 0.1;
997         }
998         return -1;
999 }
1000 #endif /* linux */
1001 #endif /* !defined(_BSD_SOURCE) */
1002
1003 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
1004  * BSD libc (and others) do not. */
1005 #ifndef linux
1006
1007 AST_MUTEX_DEFINE_STATIC(randomlock);
1008
1009 long int ast_random(void)
1010 {
1011         long int res;
1012         ast_mutex_lock(&randomlock);
1013         res = random();
1014         ast_mutex_unlock(&randomlock);
1015         return res;
1016 }
1017 #endif
1018
1019 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
1020 {
1021         char *dataPut = start;
1022         int inEscape = 0;
1023         int inQuotes = 0;
1024
1025         for (; *start; start++) {
1026                 if (inEscape) {
1027                         *dataPut++ = *start;       /* Always goes verbatim */
1028                         inEscape = 0;
1029                 } else {
1030                         if (*start == '\\') {
1031                                 inEscape = 1;      /* Do not copy \ into the data */
1032                         } else if (*start == '\'') {
1033                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
1034                         } else {
1035                                 /* Replace , with |, unless in quotes */
1036                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
1037                         }
1038                 }
1039         }
1040         if (start != dataPut)
1041                 *dataPut = 0;
1042         return dataPut;
1043 }
1044
1045 void ast_join(char *s, size_t len, char * const w[])
1046 {
1047         int x, ofs = 0;
1048         const char *src;
1049
1050         /* Join words into a string */
1051         if (!s)
1052                 return;
1053         for (x = 0; ofs < len && w[x]; x++) {
1054                 if (x > 0)
1055                         s[ofs++] = ' ';
1056                 for (src = w[x]; *src && ofs < len; src++)
1057                         s[ofs++] = *src;
1058         }
1059         if (ofs == len)
1060                 ofs--;
1061         s[ofs] = '\0';
1062 }
1063
1064 const char __ast_string_field_empty[] = "";
1065
1066 static int add_string_pool(struct ast_string_field_mgr *mgr, size_t size)
1067 {
1068         struct ast_string_field_pool *pool;
1069
1070         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
1071                 return -1;
1072         
1073         pool->prev = mgr->pool;
1074         mgr->pool = pool;
1075         mgr->size = size;
1076         mgr->space = size;
1077         mgr->used = 0;
1078
1079         return 0;
1080 }
1081
1082 int __ast_string_field_init(struct ast_string_field_mgr *mgr, size_t size,
1083                             ast_string_field *fields, int num_fields)
1084 {
1085         int index;
1086
1087         if (add_string_pool(mgr, size))
1088                 return -1;
1089
1090         for (index = 0; index < num_fields; index++)
1091                 fields[index] = __ast_string_field_empty;
1092
1093         return 0;
1094 }
1095
1096 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, size_t needed,
1097                                                 ast_string_field *fields, int num_fields)
1098 {
1099         char *result = NULL;
1100
1101         if (__builtin_expect(needed > mgr->space, 0)) {
1102                 size_t new_size = mgr->size * 2;
1103
1104                 while (new_size < needed)
1105                         new_size *= 2;
1106
1107                 if (add_string_pool(mgr, new_size))
1108                         return NULL;
1109         }
1110
1111         result = mgr->pool->base + mgr->used;
1112         mgr->used += needed;
1113         mgr->space -= needed;
1114         return result;
1115 }
1116
1117 void __ast_string_field_index_build(struct ast_string_field_mgr *mgr,
1118                                     ast_string_field *fields, int num_fields,
1119                                     int index, const char *format, ...)
1120 {
1121         size_t needed;
1122         va_list ap1, ap2;
1123
1124         va_start(ap1, format);
1125         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
1126
1127         needed = vsnprintf(mgr->pool->base + mgr->used, mgr->space, format, ap1) + 1;
1128
1129         va_end(ap1);
1130
1131         if (needed > mgr->space) {
1132                 size_t new_size = mgr->size * 2;
1133
1134                 while (new_size < needed)
1135                         new_size *= 2;
1136
1137                 if (add_string_pool(mgr, new_size))
1138                         return;
1139
1140                 vsprintf(mgr->pool->base + mgr->used, format, ap2);
1141         }
1142
1143         fields[index] = mgr->pool->base + mgr->used;
1144         mgr->used += needed;
1145         mgr->space -= needed;
1146
1147         va_end(ap2);
1148 }
1149
1150 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
1151
1152 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
1153 {
1154         int ret;
1155         ast_mutex_lock(&fetchadd_m);
1156         ret = *p;
1157         *p += v;
1158         ast_mutex_unlock(&fetchadd_m);
1159         return ret;
1160 }
1161
1162 /*! \brief
1163  * get values from config variables.
1164  */
1165 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
1166 {
1167         long t;
1168         int scanned;
1169
1170         if (dst == NULL)
1171                 return -1;
1172
1173         *dst = _default;
1174
1175         if (ast_strlen_zero(src))
1176                 return -1;
1177
1178         /* only integer at the moment, but one day we could accept more formats */
1179         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
1180                 *dst = t;
1181                 if (consumed)
1182                         *consumed = scanned;
1183                 return 0;
1184         } else
1185                 return -1;
1186 }
1187