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