7570ca608d265165dcd70f608d11c733645df3fe
[asterisk/asterisk.git] / main / utils.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*! \file
18  *
19  * \brief Utility functions
20  *
21  * \note These are important for portability and security,
22  * so please use them in favour of other routines.
23  * Please consult the CODING GUIDELINES for more information.
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <ctype.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <errno.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <sys/types.h>
38 #include <sys/socket.h>
39 #include <netinet/in.h>
40 #include <arpa/inet.h>
41
42 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in lock.h if required */
43 #include "asterisk/lock.h"
44 #include "asterisk/io.h"
45 #include "asterisk/logger.h"
46 #include "asterisk/md5.h"
47 #include "asterisk/sha1.h"
48 #include "asterisk/options.h"
49
50 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
51 #include "asterisk/strings.h"
52
53 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
54 #include "asterisk/time.h"
55
56 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
57 #include "asterisk/stringfields.h"
58
59 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
60 #include "asterisk/utils.h"
61
62 #define AST_API_MODULE
63 #include "asterisk/threadstorage.h"
64
65 static char base64[64];
66 static char b2a[256];
67
68 AST_THREADSTORAGE(inet_ntoa_buf);
69
70 #if !defined(HAVE_GETHOSTBYNAME_R)
71
72 #define ERANGE 34       /*!< duh? ERANGE value copied from web... */
73 #undef gethostbyname
74
75 AST_MUTEX_DEFINE_STATIC(__mutex);
76
77 /*! \brief Reentrant replacement for gethostbyname for BSD-based systems.
78 \note This
79 routine is derived from code originally written and placed in the public 
80 domain by Enzo Michelangeli <em@em.no-ip.com> */
81
82 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
83                                 size_t buflen, struct hostent **result, 
84                                 int *h_errnop) 
85 {
86         int hsave;
87         struct hostent *ph;
88         ast_mutex_lock(&__mutex); /* begin critical area */
89         hsave = h_errno;
90
91         ph = gethostbyname(name);
92         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
93         if (ph == NULL) {
94                 *result = NULL;
95         } else {
96                 char **p, **q;
97                 char *pbuf;
98                 int nbytes=0;
99                 int naddr=0, naliases=0;
100                 /* determine if we have enough space in buf */
101
102                 /* count how many addresses */
103                 for (p = ph->h_addr_list; *p != 0; p++) {
104                         nbytes += ph->h_length; /* addresses */
105                         nbytes += sizeof(*p); /* pointers */
106                         naddr++;
107                 }
108                 nbytes += sizeof(*p); /* one more for the terminating NULL */
109
110                 /* count how many aliases, and total length of strings */
111                 for (p = ph->h_aliases; *p != 0; p++) {
112                         nbytes += (strlen(*p)+1); /* aliases */
113                         nbytes += sizeof(*p);  /* pointers */
114                         naliases++;
115                 }
116                 nbytes += sizeof(*p); /* one more for the terminating NULL */
117
118                 /* here nbytes is the number of bytes required in buffer */
119                 /* as a terminator must be there, the minimum value is ph->h_length */
120                 if (nbytes > buflen) {
121                         *result = NULL;
122                         ast_mutex_unlock(&__mutex); /* end critical area */
123                         return ERANGE; /* not enough space in buf!! */
124                 }
125
126                 /* There is enough space. Now we need to do a deep copy! */
127                 /* Allocation in buffer:
128                         from [0] to [(naddr-1) * sizeof(*p)]:
129                         pointers to addresses
130                         at [naddr * sizeof(*p)]:
131                         NULL
132                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
133                         pointers to aliases
134                         at [(naddr+naliases+1) * sizeof(*p)]:
135                         NULL
136                         then naddr addresses (fixed length), and naliases aliases (asciiz).
137                 */
138
139                 *ret = *ph;   /* copy whole structure (not its address!) */
140
141                 /* copy addresses */
142                 q = (char **)buf; /* pointer to pointers area (type: char **) */
143                 ret->h_addr_list = q; /* update pointer to address list */
144                 pbuf = buf + ((naddr + naliases + 2) * sizeof(*p)); /* skip that area */
145                 for (p = ph->h_addr_list; *p != 0; p++) {
146                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
147                         *q++ = pbuf; /* the pointer is the one inside buf... */
148                         pbuf += ph->h_length; /* advance pbuf */
149                 }
150                 *q++ = NULL; /* address list terminator */
151
152                 /* copy aliases */
153                 ret->h_aliases = q; /* update pointer to aliases list */
154                 for (p = ph->h_aliases; *p != 0; p++) {
155                         strcpy(pbuf, *p); /* copy alias strings */
156                         *q++ = pbuf; /* the pointer is the one inside buf... */
157                         pbuf += strlen(*p); /* advance pbuf */
158                         *pbuf++ = 0; /* string terminator */
159                 }
160                 *q++ = NULL; /* terminator */
161
162                 strcpy(pbuf, ph->h_name); /* copy alias strings */
163                 ret->h_name = pbuf;
164                 pbuf += strlen(ph->h_name); /* advance pbuf */
165                 *pbuf++ = 0; /* string terminator */
166
167                 *result = ret;  /* and let *result point to structure */
168
169         }
170         h_errno = hsave;  /* restore h_errno */
171         ast_mutex_unlock(&__mutex); /* end critical area */
172
173         return (*result == NULL); /* return 0 on success, non-zero on error */
174 }
175
176
177 #endif
178
179 /*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the 
180    standard gethostbyname (which is not thread safe)
181 */
182 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
183 {
184         int res;
185         int herrno;
186         int dots=0;
187         const char *s;
188         struct hostent *result = NULL;
189         /* Although it is perfectly legitimate to lookup a pure integer, for
190            the sake of the sanity of people who like to name their peers as
191            integers, we break with tradition and refuse to look up a
192            pure integer */
193         s = host;
194         res = 0;
195         while (s && *s) {
196                 if (*s == '.')
197                         dots++;
198                 else if (!isdigit(*s))
199                         break;
200                 s++;
201         }
202         if (!s || !*s) {
203                 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
204                 if (dots != 3)
205                         return NULL;
206                 memset(hp, 0, sizeof(struct ast_hostent));
207                 hp->hp.h_addrtype = AF_INET;
208                 hp->hp.h_addr_list = (void *) hp->buf;
209                 hp->hp.h_addr = hp->buf + sizeof(void *);
210                 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
211                         return &hp->hp;
212                 return NULL;
213                 
214         }
215 #ifdef SOLARIS
216         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
217
218         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
219                 return NULL;
220 #else
221         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
222
223         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
224                 return NULL;
225 #endif
226         return &hp->hp;
227 }
228
229
230
231 AST_MUTEX_DEFINE_STATIC(test_lock);
232 AST_MUTEX_DEFINE_STATIC(test_lock2);
233 static pthread_t test_thread; 
234 static int lock_count = 0;
235 static int test_errors = 0;
236
237 /*! \brief This is a regression test for recursive mutexes.
238    test_for_thread_safety() will return 0 if recursive mutex locks are
239    working properly, and non-zero if they are not working properly. */
240 static void *test_thread_body(void *data) 
241
242         ast_mutex_lock(&test_lock);
243         lock_count += 10;
244         if (lock_count != 10) 
245                 test_errors++;
246         ast_mutex_lock(&test_lock);
247         lock_count += 10;
248         if (lock_count != 20) 
249                 test_errors++;
250         ast_mutex_lock(&test_lock2);
251         ast_mutex_unlock(&test_lock);
252         lock_count -= 10;
253         if (lock_count != 10) 
254                 test_errors++;
255         ast_mutex_unlock(&test_lock);
256         lock_count -= 10;
257         ast_mutex_unlock(&test_lock2);
258         if (lock_count != 0) 
259                 test_errors++;
260         return NULL;
261
262
263 int test_for_thread_safety(void)
264
265         ast_mutex_lock(&test_lock2);
266         ast_mutex_lock(&test_lock);
267         lock_count += 1;
268         ast_mutex_lock(&test_lock);
269         lock_count += 1;
270         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
271         usleep(100);
272         if (lock_count != 2) 
273                 test_errors++;
274         ast_mutex_unlock(&test_lock);
275         lock_count -= 1;
276         usleep(100); 
277         if (lock_count != 1) 
278                 test_errors++;
279         ast_mutex_unlock(&test_lock);
280         lock_count -= 1;
281         if (lock_count != 0) 
282                 test_errors++;
283         ast_mutex_unlock(&test_lock2);
284         usleep(100);
285         if (lock_count != 0) 
286                 test_errors++;
287         pthread_join(test_thread, NULL);
288         return(test_errors);          /* return 0 on success. */
289 }
290
291 /*! \brief Produce 32 char MD5 hash of value. */
292 void ast_md5_hash(char *output, char *input)
293 {
294         struct MD5Context md5;
295         unsigned char digest[16];
296         char *ptr;
297         int x;
298
299         MD5Init(&md5);
300         MD5Update(&md5, (unsigned char *)input, strlen(input));
301         MD5Final(digest, &md5);
302         ptr = output;
303         for (x = 0; x < 16; x++)
304                 ptr += sprintf(ptr, "%2.2x", digest[x]);
305 }
306
307 /*! \brief Produce 40 char SHA1 hash of value. */
308 void ast_sha1_hash(char *output, char *input)
309 {
310         struct SHA1Context sha;
311         char *ptr;
312         int x;
313         uint8_t Message_Digest[20];
314
315         SHA1Reset(&sha);
316         
317         SHA1Input(&sha, (const unsigned char *) input, strlen(input));
318
319         SHA1Result(&sha, Message_Digest);
320         ptr = output;
321         for (x = 0; x < 20; x++)
322                 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
323 }
324
325 /*! \brief decode BASE64 encoded text */
326 int ast_base64decode(unsigned char *dst, const char *src, int max)
327 {
328         int cnt = 0;
329         unsigned int byte = 0;
330         unsigned int bits = 0;
331         int incnt = 0;
332         while (*src && (cnt < max)) {
333                 /* Shift in 6 bits of input */
334                 byte <<= 6;
335                 byte |= (b2a[(int)(*src)]) & 0x3f;
336                 bits += 6;
337                 src++;
338                 incnt++;
339                 /* If we have at least 8 bits left over, take that character 
340                    off the top */
341                 if (bits >= 8)  {
342                         bits -= 8;
343                         *dst = (byte >> bits) & 0xff;
344                         dst++;
345                         cnt++;
346                 }
347         }
348         /* Dont worry about left over bits, they're extra anyway */
349         return cnt;
350 }
351
352 /*! \brief encode text to BASE64 coding */
353 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
354 {
355         int cnt = 0;
356         int col = 0;
357         unsigned int byte = 0;
358         int bits = 0;
359         int cntin = 0;
360         /* Reserve space for null byte at end of string */
361         max--;
362         while ((cntin < srclen) && (cnt < max)) {
363                 byte <<= 8;
364                 byte |= *(src++);
365                 bits += 8;
366                 cntin++;
367                 if ((bits == 24) && (cnt + 4 <= max)) {
368                         *dst++ = base64[(byte >> 18) & 0x3f];
369                         *dst++ = base64[(byte >> 12) & 0x3f];
370                         *dst++ = base64[(byte >> 6) & 0x3f];
371                         *dst++ = base64[byte & 0x3f];
372                         cnt += 4;
373                         col += 4;
374                         bits = 0;
375                         byte = 0;
376                 }
377                 if (linebreaks && (cnt < max) && (col == 64)) {
378                         *dst++ = '\n';
379                         cnt++;
380                         col = 0;
381                 }
382         }
383         if (bits && (cnt + 4 <= max)) {
384                 /* Add one last character for the remaining bits, 
385                    padding the rest with 0 */
386                 byte <<= 24 - bits;
387                 *dst++ = base64[(byte >> 18) & 0x3f];
388                 *dst++ = base64[(byte >> 12) & 0x3f];
389                 if (bits == 16)
390                         *dst++ = base64[(byte >> 6) & 0x3f];
391                 else
392                         *dst++ = '=';
393                 *dst++ = '=';
394                 cnt += 4;
395         }
396         if (linebreaks && (cnt < max)) {
397                 *dst++ = '\n';
398                 cnt++;
399         }
400         *dst = '\0';
401         return cnt;
402 }
403
404 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
405 {
406         return ast_base64encode_full(dst, src, srclen, max, 0);
407 }
408
409 static void base64_init(void)
410 {
411         int x;
412         memset(b2a, -1, sizeof(b2a));
413         /* Initialize base-64 Conversion table */
414         for (x = 0; x < 26; x++) {
415                 /* A-Z */
416                 base64[x] = 'A' + x;
417                 b2a['A' + x] = x;
418                 /* a-z */
419                 base64[x + 26] = 'a' + x;
420                 b2a['a' + x] = x + 26;
421                 /* 0-9 */
422                 if (x < 10) {
423                         base64[x + 52] = '0' + x;
424                         b2a['0' + x] = x + 52;
425                 }
426         }
427         base64[62] = '+';
428         base64[63] = '/';
429         b2a[(int)'+'] = 62;
430         b2a[(int)'/'] = 63;
431 }
432
433 /*! \brief  ast_uri_encode: Turn text string to URI-encoded %XX version
434 \note   At this point, we're converting from ISO-8859-x (8-bit), not UTF8
435         as in the SIP protocol spec 
436         If doreserved == 1 we will convert reserved characters also.
437         RFC 2396, section 2.4
438         outbuf needs to have more memory allocated than the instring
439         to have room for the expansion. Every char that is converted
440         is replaced by three ASCII characters.
441
442         Note: The doreserved option is needed for replaces header in
443         SIP transfers.
444 */
445 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved) 
446 {
447         char *reserved = ";/?:@&=+$, "; /* Reserved chars */
448
449         const char *ptr  = string;      /* Start with the string */
450         char *out = NULL;
451         char *buf = NULL;
452
453         ast_copy_string(outbuf, string, buflen);
454
455         /* If there's no characters to convert, just go through and don't do anything */
456         while (*ptr) {
457                 if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
458                         /* Oops, we need to start working here */
459                         if (!buf) {
460                                 buf = outbuf;
461                                 out = buf + (ptr - string) ;    /* Set output ptr */
462                         }
463                         out += sprintf(out, "%%%02x", (unsigned char) *ptr);
464                 } else if (buf) {
465                         *out = *ptr;    /* Continue copying the string */
466                         out++;
467                 } 
468                 ptr++;
469         }
470         if (buf)
471                 *out = '\0';
472         return outbuf;
473 }
474
475 /*! \brief  ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)  */
476 void ast_uri_decode(char *s) 
477 {
478         char *o;
479         unsigned int tmp;
480
481         for (o = s; *s; s++, o++) {
482                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
483                         /* have '%', two chars and correct parsing */
484                         *o = tmp;
485                         s += 2; /* Will be incremented once more when we break out */
486                 } else /* all other cases, just copy */
487                         *o = *s;
488         }
489         *o = '\0';
490 }
491
492 /*! \brief  ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
493 const char *ast_inet_ntoa(struct in_addr ia)
494 {
495         char *buf;
496
497         if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
498                 return "";
499
500         return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
501 }
502
503 int ast_utils_init(void)
504 {
505         base64_init();
506         return 0;
507 }
508
509 #ifndef __linux__
510 #undef pthread_create /* For ast_pthread_create function only */
511 #endif /* !__linux__ */
512
513 #if !defined(LOW_MEMORY)
514 /*
515  * support for 'show threads'. The start routine is wrapped by
516  * dummy_start(), so that ast_register_thread() and
517  * ast_unregister_thread() know the thread identifier.
518  */
519 struct thr_arg {
520         void *(*start_routine)(void *);
521         void *data;
522         char *name;
523 };
524
525 /*
526  * on OS/X, pthread_cleanup_push() and pthread_cleanup_pop()
527  * are odd macros which start and end a block, so they _must_ be
528  * used in pairs (the latter with a '1' argument to call the
529  * handler on exit.
530  * On BSD we don't need this, but we keep it for compatibility.
531  */
532 static void *dummy_start(void *data)
533 {
534         void *ret;
535         struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
536
537         /* note that even though data->name is a pointer to allocated memory,
538            we are not freeing it here because ast_register_thread is going to
539            keep a copy of the pointer and then ast_unregister_thread will
540            free the memory
541         */
542         ast_free(data);
543         ast_register_thread(a.name);
544         pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
545         ret = a.start_routine(a.data);
546         pthread_cleanup_pop(1);
547
548         return ret;
549 }
550
551 #endif /* !LOW_MEMORY */
552
553 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
554                              void *data, size_t stacksize, const char *file, const char *caller,
555                              int line, const char *start_fn)
556 {
557 #if !defined(LOW_MEMORY)
558         struct thr_arg *a;
559 #endif
560
561         if (!attr) {
562                 attr = alloca(sizeof(*attr));
563                 pthread_attr_init(attr);
564         }
565
566 #ifdef __linux__
567         /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
568            which is kind of useless. Change this here to
569            PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
570            priority will propagate down to new threads by default.
571            This does mean that callers cannot set a different priority using
572            PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
573            the priority afterwards with pthread_setschedparam(). */
574         if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
575                 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
576 #endif
577
578         if (!stacksize)
579                 stacksize = AST_STACKSIZE;
580
581         if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
582                 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
583
584 #if !defined(LOW_MEMORY)
585         if ((a = ast_malloc(sizeof(*a)))) {
586                 a->start_routine = start_routine;
587                 a->data = data;
588                 start_routine = dummy_start;
589                 asprintf(&a->name, "%-20s started at [%5d] %s %s()",
590                          start_fn, line, file, caller);
591                 data = a;
592         }
593 #endif /* !LOW_MEMORY */
594
595         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
596 }
597
598
599 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
600                              void *data, size_t stacksize, const char *file, const char *caller,
601                              int line, const char *start_fn)
602 {
603         unsigned char attr_destroy = 0;
604         int res;
605
606         if (!attr) {
607                 attr = alloca(sizeof(*attr));
608                 pthread_attr_init(attr);
609                 attr_destroy = 1;
610         }
611
612         if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
613                 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
614
615         res = ast_pthread_create_stack(thread, attr, start_routine, data, 
616                                        stacksize, file, caller, line, start_fn);
617
618         if (attr_destroy)
619                 pthread_attr_destroy(attr);
620
621         return res;
622 }
623
624 int ast_wait_for_input(int fd, int ms)
625 {
626         struct pollfd pfd[1];
627         memset(pfd, 0, sizeof(pfd));
628         pfd[0].fd = fd;
629         pfd[0].events = POLLIN|POLLPRI;
630         return poll(pfd, 1, ms);
631 }
632
633 /*!
634  * Try to write string, but wait no more than ms milliseconds before timing out.
635  *
636  * \note The code assumes that the file descriptor has NONBLOCK set,
637  * so there is only one system call made to do a write, unless we actually
638  * have a need to wait.  This way, we get better performance.
639  * If the descriptor is blocking, all assumptions on the guaranteed
640  * detail do not apply anymore.
641  * Also note that in the current implementation, the delay is per-write,
642  * so you still have no guarantees, anyways.
643  * Fortunately the routine is only used in a few places (cli.c, manager.c,
644  * res_agi.c) so it is reasonably easy to check how it behaves there.
645  *
646  * XXX We either need to fix the code, or fix the documentation.
647  */
648 int ast_carefulwrite(int fd, char *s, int len, int timeoutms) 
649 {
650         /* Try to write string, but wait no more than ms milliseconds
651            before timing out */
652         int res = 0;
653         struct pollfd fds[1];
654         while (len) {
655                 res = write(fd, s, len);
656                 if ((res < 0) && (errno != EAGAIN)) {
657                         return -1;
658                 }
659                 if (res < 0)
660                         res = 0;
661                 len -= res;
662                 s += res;
663                 res = 0;
664                 if (len) {
665                         fds[0].fd = fd;
666                         fds[0].events = POLLOUT;
667                         /* Wait until writable again */
668                         res = poll(fds, 1, timeoutms);
669                         if (res < 1)
670                                 return -1;
671                 }
672         }
673         return res;
674 }
675
676 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
677 {
678         char *e;
679         char *q;
680
681         s = ast_strip(s);
682         if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
683                 e = s + strlen(s) - 1;
684                 if (*e == *(end_quotes + (q - beg_quotes))) {
685                         s++;
686                         *e = '\0';
687                 }
688         }
689
690         return s;
691 }
692
693 int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
694 {
695         int result;
696
697         if (!buffer || !*buffer || !space || !*space)
698                 return -1;
699
700         result = vsnprintf(*buffer, *space, fmt, ap);
701
702         if (result < 0)
703                 return -1;
704         else if (result > *space)
705                 result = *space;
706
707         *buffer += result;
708         *space -= result;
709         return 0;
710 }
711
712 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
713 {
714         va_list ap;
715         int result;
716
717         va_start(ap, fmt);
718         result = ast_build_string_va(buffer, space, fmt, ap);
719         va_end(ap);
720
721         return result;
722 }
723
724 int ast_true(const char *s)
725 {
726         if (ast_strlen_zero(s))
727                 return 0;
728
729         /* Determine if this is a true value */
730         if (!strcasecmp(s, "yes") ||
731             !strcasecmp(s, "true") ||
732             !strcasecmp(s, "y") ||
733             !strcasecmp(s, "t") ||
734             !strcasecmp(s, "1") ||
735             !strcasecmp(s, "on"))
736                 return -1;
737
738         return 0;
739 }
740
741 int ast_false(const char *s)
742 {
743         if (ast_strlen_zero(s))
744                 return 0;
745
746         /* Determine if this is a false value */
747         if (!strcasecmp(s, "no") ||
748             !strcasecmp(s, "false") ||
749             !strcasecmp(s, "n") ||
750             !strcasecmp(s, "f") ||
751             !strcasecmp(s, "0") ||
752             !strcasecmp(s, "off"))
753                 return -1;
754
755         return 0;
756 }
757
758 #define ONE_MILLION     1000000
759 /*
760  * put timeval in a valid range. usec is 0..999999
761  * negative values are not allowed and truncated.
762  */
763 static struct timeval tvfix(struct timeval a)
764 {
765         if (a.tv_usec >= ONE_MILLION) {
766                 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
767                         a.tv_sec, (long int) a.tv_usec);
768                 a.tv_sec += a.tv_usec / ONE_MILLION;
769                 a.tv_usec %= ONE_MILLION;
770         } else if (a.tv_usec < 0) {
771                 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
772                         a.tv_sec, (long int) a.tv_usec);
773                 a.tv_usec = 0;
774         }
775         return a;
776 }
777
778 struct timeval ast_tvadd(struct timeval a, struct timeval b)
779 {
780         /* consistency checks to guarantee usec in 0..999999 */
781         a = tvfix(a);
782         b = tvfix(b);
783         a.tv_sec += b.tv_sec;
784         a.tv_usec += b.tv_usec;
785         if (a.tv_usec >= ONE_MILLION) {
786                 a.tv_sec++;
787                 a.tv_usec -= ONE_MILLION;
788         }
789         return a;
790 }
791
792 struct timeval ast_tvsub(struct timeval a, struct timeval b)
793 {
794         /* consistency checks to guarantee usec in 0..999999 */
795         a = tvfix(a);
796         b = tvfix(b);
797         a.tv_sec -= b.tv_sec;
798         a.tv_usec -= b.tv_usec;
799         if (a.tv_usec < 0) {
800                 a.tv_sec-- ;
801                 a.tv_usec += ONE_MILLION;
802         }
803         return a;
804 }
805 #undef ONE_MILLION
806
807 /*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
808  * BSD libc (and others) do not. */
809 #ifndef linux
810
811 AST_MUTEX_DEFINE_STATIC(randomlock);
812
813 long int ast_random(void)
814 {
815         long int res;
816         ast_mutex_lock(&randomlock);
817         res = random();
818         ast_mutex_unlock(&randomlock);
819         return res;
820 }
821 #endif
822
823 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
824 {
825         char *dataPut = start;
826         int inEscape = 0;
827         int inQuotes = 0;
828
829         for (; *start; start++) {
830                 if (inEscape) {
831                         *dataPut++ = *start;       /* Always goes verbatim */
832                         inEscape = 0;
833                 } else {
834                         if (*start == '\\') {
835                                 inEscape = 1;      /* Do not copy \ into the data */
836                         } else if (*start == '\'') {
837                                 inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
838                         } else {
839                                 /* Replace , with |, unless in quotes */
840                                 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
841                         }
842                 }
843         }
844         if (start != dataPut)
845                 *dataPut = 0;
846         return dataPut;
847 }
848
849 void ast_join(char *s, size_t len, char * const w[])
850 {
851         int x, ofs = 0;
852         const char *src;
853
854         /* Join words into a string */
855         if (!s)
856                 return;
857         for (x = 0; ofs < len && w[x]; x++) {
858                 if (x > 0)
859                         s[ofs++] = ' ';
860                 for (src = w[x]; *src && ofs < len; src++)
861                         s[ofs++] = *src;
862         }
863         if (ofs == len)
864                 ofs--;
865         s[ofs] = '\0';
866 }
867
868 const char __ast_string_field_empty[] = "";
869
870 static int add_string_pool(struct ast_string_field_mgr *mgr, size_t size)
871 {
872         struct ast_string_field_pool *pool;
873
874         if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
875                 return -1;
876         
877         pool->prev = mgr->pool;
878         mgr->pool = pool;
879         mgr->size = size;
880         mgr->space = size;
881         mgr->used = 0;
882
883         return 0;
884 }
885
886 int __ast_string_field_init(struct ast_string_field_mgr *mgr, size_t size,
887                             ast_string_field *fields, int num_fields)
888 {
889         int index;
890
891         if (add_string_pool(mgr, size))
892                 return -1;
893
894         for (index = 0; index < num_fields; index++)
895                 fields[index] = __ast_string_field_empty;
896
897         return 0;
898 }
899
900 ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, size_t needed,
901                                                 ast_string_field *fields, int num_fields)
902 {
903         char *result = NULL;
904
905         if (__builtin_expect(needed > mgr->space, 0)) {
906                 size_t new_size = mgr->size * 2;
907
908                 while (new_size < needed)
909                         new_size *= 2;
910
911                 if (add_string_pool(mgr, new_size))
912                         return NULL;
913         }
914
915         result = mgr->pool->base + mgr->used;
916         mgr->used += needed;
917         mgr->space -= needed;
918         return result;
919 }
920
921 void __ast_string_field_index_build_va(struct ast_string_field_mgr *mgr,
922                                     ast_string_field *fields, int num_fields,
923                                     int index, const char *format, va_list ap1, va_list ap2)
924 {
925         size_t needed;
926
927         needed = vsnprintf(mgr->pool->base + mgr->used, mgr->space, format, ap1) + 1;
928
929         va_end(ap1);
930
931         if (needed > mgr->space) {
932                 size_t new_size = mgr->size * 2;
933
934                 while (new_size < needed)
935                         new_size *= 2;
936
937                 if (add_string_pool(mgr, new_size))
938                         return;
939
940                 vsprintf(mgr->pool->base + mgr->used, format, ap2);
941         }
942
943         fields[index] = mgr->pool->base + mgr->used;
944         mgr->used += needed;
945         mgr->space -= needed;
946 }
947
948 void __ast_string_field_index_build(struct ast_string_field_mgr *mgr,
949                                     ast_string_field *fields, int num_fields,
950                                     int index, const char *format, ...)
951 {
952         va_list ap1, ap2;
953
954         va_start(ap1, format);
955         va_start(ap2, format);          /* va_copy does not exist on FreeBSD */
956
957         __ast_string_field_index_build_va(mgr, fields, num_fields, index, format, ap1, ap2);
958
959         va_end(ap1);
960         va_end(ap2);
961 }
962
963 AST_MUTEX_DEFINE_STATIC(fetchadd_m); /* used for all fetc&add ops */
964
965 int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
966 {
967         int ret;
968         ast_mutex_lock(&fetchadd_m);
969         ret = *p;
970         *p += v;
971         ast_mutex_unlock(&fetchadd_m);
972         return ret;
973 }
974
975 /*! \brief
976  * get values from config variables.
977  */
978 int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
979 {
980         long t;
981         int scanned;
982
983         if (dst == NULL)
984                 return -1;
985
986         *dst = _default;
987
988         if (ast_strlen_zero(src))
989                 return -1;
990
991         /* only integer at the moment, but one day we could accept more formats */
992         if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
993                 *dst = t;
994                 if (consumed)
995                         *consumed = scanned;
996                 return 0;
997         } else
998                 return -1;
999 }
1000
1001 /*!
1002  * core handler for dynamic strings.
1003  * This is not meant to be called directly, but rather through the
1004  * various wrapper macros
1005  *      ast_str_set(...)
1006  *      ast_str_append(...)
1007  *      ast_str_set_va(...)
1008  *      ast_str_append_va(...)
1009  */
1010 int __ast_str_helper(struct ast_str **buf, size_t max_len,
1011         int append, const char *fmt, va_list ap)
1012 {
1013         int res, need;
1014         int offset = (append && (*buf)->len) ? (*buf)->used : 0;
1015
1016         if (max_len < 0)
1017                 max_len = (*buf)->len;  /* don't exceed the allocated space */
1018         /*
1019          * Ask vsnprintf how much space we need. Remember that vsnprintf
1020          * does not count the final '\0' so we must add 1.
1021          */
1022         res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap);
1023
1024         need = res + offset + 1;
1025         /*
1026          * If there is not enough space and we are below the max length,
1027          * reallocate the buffer and return a message telling to retry.
1028          */
1029         if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
1030                 if (max_len && max_len < need)  /* truncate as needed */
1031                         need = max_len;
1032                 else if (max_len == 0)  /* if unbounded, give more room for next time */
1033                         need += 16 + need/4;
1034                 if (0)  /* debugging */
1035                         ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need);
1036                 if (ast_str_make_space(buf, need)) {
1037                         ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need);
1038                         return AST_DYNSTR_BUILD_FAILED;
1039                 }
1040                 (*buf)->str[offset] = '\0';     /* Truncate the partial write. */
1041
1042                 /* va_end() and va_start() must be done before calling
1043                  * vsnprintf() again. */
1044                 return AST_DYNSTR_BUILD_RETRY;
1045         }
1046         /* update space used, keep in mind the truncation */
1047         (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len : res + offset;
1048
1049         return res;
1050 }
1051
1052 void ast_enable_packet_fragmentation(int sock)
1053 {
1054 #if defined(HAVE_IP_MTU_DISCOVER)
1055         int val = IP_PMTUDISC_DONT;
1056         
1057         if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
1058                 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
1059 #endif /* HAVE_IP_MTU_DISCOVER */
1060 }