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