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