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