phase two of string portability stuff:
[asterisk/asterisk.git] / utils.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Utility functions
5  *
6  * Copyright (C)  2004 - 2005, Digium, Inc.
7  *
8  * This program is free software, distributed under the terms of
9  * the GNU General Public License
10  */
11
12 #include <ctype.h>
13 #include <string.h>
14 #include <unistd.h>
15 #include <stdlib.h>
16 #include <errno.h>
17 #include <stdarg.h>
18 #include <stdio.h>
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
23 #include <stdarg.h>
24
25 #include "asterisk.h"
26
27 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
28
29 #include "asterisk/lock.h"
30 #include "asterisk/io.h"
31 #include "asterisk/logger.h"
32 #include "asterisk/md5.h"
33
34 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
35 #include "asterisk/strings.h"
36
37 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
38 #include "asterisk/time.h"
39
40 #define AST_API_MODULE          /* ensure that inlinable API functions will be built in this module if required */
41 #include "asterisk/utils.h"
42
43 static char base64[64];
44 static char b2a[256];
45
46 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined(__APPLE__)
47
48 /* duh? ERANGE value copied from web... */
49 #define ERANGE 34
50 #undef gethostbyname
51
52 AST_MUTEX_DEFINE_STATIC(__mutex);
53
54 /* Recursive replacement for gethostbyname for BSD-based systems.  This
55 routine is derived from code originally written and placed in the public 
56 domain by Enzo Michelangeli <em@em.no-ip.com> */
57
58 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
59                                 size_t buflen, struct hostent **result, 
60                                 int *h_errnop) 
61 {
62         int hsave;
63         struct hostent *ph;
64         ast_mutex_lock(&__mutex); /* begin critical area */
65         hsave = h_errno;
66
67         ph = gethostbyname(name);
68         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
69         if (ph == NULL) {
70                 *result = NULL;
71         } else {
72                 char **p, **q;
73                 char *pbuf;
74                 int nbytes=0;
75                 int naddr=0, naliases=0;
76                 /* determine if we have enough space in buf */
77
78                 /* count how many addresses */
79                 for (p = ph->h_addr_list; *p != 0; p++) {
80                         nbytes += ph->h_length; /* addresses */
81                         nbytes += sizeof(*p); /* pointers */
82                         naddr++;
83                 }
84                 nbytes += sizeof(*p); /* one more for the terminating NULL */
85
86                 /* count how many aliases, and total length of strings */
87                 for (p = ph->h_aliases; *p != 0; p++) {
88                         nbytes += (strlen(*p)+1); /* aliases */
89                         nbytes += sizeof(*p);  /* pointers */
90                         naliases++;
91                 }
92                 nbytes += sizeof(*p); /* one more for the terminating NULL */
93
94                 /* here nbytes is the number of bytes required in buffer */
95                 /* as a terminator must be there, the minimum value is ph->h_length */
96                 if(nbytes > buflen) {
97                         *result = NULL;
98                         ast_mutex_unlock(&__mutex); /* end critical area */
99                         return ERANGE; /* not enough space in buf!! */
100                 }
101
102                 /* There is enough space. Now we need to do a deep copy! */
103                 /* Allocation in buffer:
104                         from [0] to [(naddr-1) * sizeof(*p)]:
105                         pointers to addresses
106                         at [naddr * sizeof(*p)]:
107                         NULL
108                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
109                         pointers to aliases
110                         at [(naddr+naliases+1) * sizeof(*p)]:
111                         NULL
112                         then naddr addresses (fixed length), and naliases aliases (asciiz).
113                 */
114
115                 *ret = *ph;   /* copy whole structure (not its address!) */
116
117                 /* copy addresses */
118                 q = (char **)buf; /* pointer to pointers area (type: char **) */
119                 ret->h_addr_list = q; /* update pointer to address list */
120                 pbuf = buf + ((naddr+naliases+2)*sizeof(*p)); /* skip that area */
121                 for (p = ph->h_addr_list; *p != 0; p++) {
122                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
123                         *q++ = pbuf; /* the pointer is the one inside buf... */
124                         pbuf += ph->h_length; /* advance pbuf */
125                 }
126                 *q++ = NULL; /* address list terminator */
127
128                 /* copy aliases */
129                 ret->h_aliases = q; /* update pointer to aliases list */
130                 for (p = ph->h_aliases; *p != 0; p++) {
131                         strcpy(pbuf, *p); /* copy alias strings */
132                         *q++ = pbuf; /* the pointer is the one inside buf... */
133                         pbuf += strlen(*p); /* advance pbuf */
134                         *pbuf++ = 0; /* string terminator */
135                 }
136                 *q++ = NULL; /* terminator */
137
138                 strcpy(pbuf, ph->h_name); /* copy alias strings */
139                 ret->h_name = pbuf;
140                 pbuf += strlen(ph->h_name); /* advance pbuf */
141                 *pbuf++ = 0; /* string terminator */
142
143                 *result = ret;  /* and let *result point to structure */
144
145         }
146         h_errno = hsave;  /* restore h_errno */
147         ast_mutex_unlock(&__mutex); /* end critical area */
148
149         return (*result == NULL); /* return 0 on success, non-zero on error */
150 }
151
152
153 #endif
154
155 /* Re-entrant (thread safe) version of gethostbyname that replaces the 
156    standard gethostbyname (which is not thread safe)
157 */
158 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
159 {
160         int res;
161         int herrno;
162         const char *s;
163         struct hostent *result = NULL;
164         /* Although it is perfectly legitimate to lookup a pure integer, for
165            the sake of the sanity of people who like to name their peers as
166            integers, we break with tradition and refuse to look up a
167            pure integer */
168         s = host;
169         res = 0;
170         while(s && *s) {
171                 if (!isdigit(*s))
172                         break;
173                 s++;
174         }
175         if (!s || !*s)
176                 return NULL;
177 #ifdef SOLARIS
178         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
179
180         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
181                 return NULL;
182 #else
183         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
184
185         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
186                 return NULL;
187 #endif
188         return &hp->hp;
189 }
190
191
192 /* This is a regression test for recursive mutexes.
193    test_for_thread_safety() will return 0 if recursive mutex locks are
194    working properly, and non-zero if they are not working properly. */
195
196 AST_MUTEX_DEFINE_STATIC(test_lock);
197 AST_MUTEX_DEFINE_STATIC(test_lock2);
198 static pthread_t test_thread; 
199 static int lock_count = 0;
200 static int test_errors = 0;
201
202 static void *test_thread_body(void *data) 
203
204         ast_mutex_lock(&test_lock);
205         lock_count += 10;
206         if (lock_count != 10) 
207                 test_errors++;
208         ast_mutex_lock(&test_lock);
209         lock_count += 10;
210         if (lock_count != 20) 
211                 test_errors++;
212         ast_mutex_lock(&test_lock2);
213         ast_mutex_unlock(&test_lock);
214         lock_count -= 10;
215         if (lock_count != 10) 
216                 test_errors++;
217         ast_mutex_unlock(&test_lock);
218         lock_count -= 10;
219         ast_mutex_unlock(&test_lock2);
220         if (lock_count != 0) 
221                 test_errors++;
222         return NULL;
223
224
225 int test_for_thread_safety(void)
226
227         ast_mutex_lock(&test_lock2);
228         ast_mutex_lock(&test_lock);
229         lock_count += 1;
230         ast_mutex_lock(&test_lock);
231         lock_count += 1;
232         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
233         usleep(100);
234         if (lock_count != 2) 
235                 test_errors++;
236         ast_mutex_unlock(&test_lock);
237         lock_count -= 1;
238         usleep(100); 
239         if (lock_count != 1) 
240                 test_errors++;
241         ast_mutex_unlock(&test_lock);
242         lock_count -= 1;
243         if (lock_count != 0) 
244                 test_errors++;
245         ast_mutex_unlock(&test_lock2);
246         usleep(100);
247         if (lock_count != 0) 
248                 test_errors++;
249         pthread_join(test_thread, NULL);
250         return(test_errors);          /* return 0 on success. */
251 }
252
253 /*--- ast_md5_hash: Produce 16 char MD5 hash of value. ---*/
254 void ast_md5_hash(char *output, char *input)
255 {
256         struct MD5Context md5;
257         unsigned char digest[16];
258         char *ptr;
259         int x;
260
261         MD5Init(&md5);
262         MD5Update(&md5, input, strlen(input));
263         MD5Final(digest, &md5);
264         ptr = output;
265         for (x=0; x<16; x++)
266                 ptr += sprintf(ptr, "%2.2x", digest[x]);
267 }
268
269 int ast_base64decode(unsigned char *dst, char *src, int max)
270 {
271         int cnt = 0;
272         unsigned int byte = 0;
273         unsigned int bits = 0;
274         int incnt = 0;
275 #if 0
276         unsigned char *odst = dst;
277 #endif
278         while(*src && (cnt < max)) {
279                 /* Shift in 6 bits of input */
280                 byte <<= 6;
281                 byte |= (b2a[(int)(*src)]) & 0x3f;
282                 bits += 6;
283 #if 0
284                 printf("Add: %c %s\n", *src, binary(b2a[(int)(*src)] & 0x3f, 6));
285 #endif
286                 src++;
287                 incnt++;
288                 /* If we have at least 8 bits left over, take that character 
289                    off the top */
290                 if (bits >= 8)  {
291                         bits -= 8;
292                         *dst = (byte >> bits) & 0xff;
293 #if 0
294                         printf("Remove: %02x %s\n", *dst, binary(*dst, 8));
295 #endif
296                         dst++;
297                         cnt++;
298                 }
299         }
300 #if 0
301         dump(odst, cnt);
302 #endif
303         /* Dont worry about left over bits, they're extra anyway */
304         return cnt;
305 }
306
307 int ast_base64encode(char *dst, unsigned char *src, int srclen, int max)
308 {
309         int cnt = 0;
310         unsigned int byte = 0;
311         int bits = 0;
312         int index;
313         int cntin = 0;
314 #if 0
315         char *odst = dst;
316         dump(src, srclen);
317 #endif
318         /* Reserve one bit for end */
319         max--;
320         while((cntin < srclen) && (cnt < max)) {
321                 byte <<= 8;
322 #if 0
323                 printf("Add: %02x %s\n", *src, binary(*src, 8));
324 #endif
325                 byte |= *(src++);
326                 bits += 8;
327                 cntin++;
328                 while((bits >= 6) && (cnt < max)) {
329                         bits -= 6;
330                         /* We want only the top */
331                         index = (byte >> bits) & 0x3f;
332                         *dst = base64[index];
333 #if 0
334                         printf("Remove: %c %s\n", *dst, binary(index, 6));
335 #endif
336                         dst++;
337                         cnt++;
338                 }
339         }
340         if (bits && (cnt < max)) {
341                 /* Add one last character for the remaining bits, 
342                    padding the rest with 0 */
343                 byte <<= (6 - bits);
344                 index = (byte) & 0x3f;
345                 *(dst++) = base64[index];
346                 cnt++;
347         }
348         *dst = '\0';
349         return cnt;
350 }
351
352 static void base64_init(void)
353 {
354         int x;
355         memset(b2a, -1, sizeof(b2a));
356         /* Initialize base-64 Conversion table */
357         for (x=0;x<26;x++) {
358                 /* A-Z */
359                 base64[x] = 'A' + x;
360                 b2a['A' + x] = x;
361                 /* a-z */
362                 base64[x + 26] = 'a' + x;
363                 b2a['a' + x] = x + 26;
364                 /* 0-9 */
365                 if (x < 10) {
366                         base64[x + 52] = '0' + x;
367                         b2a['0' + x] = x + 52;
368                 }
369         }
370         base64[62] = '+';
371         base64[63] = '/';
372         b2a[(int)'+'] = 62;
373         b2a[(int)'/'] = 63;
374 #if 0
375         for (x=0;x<64;x++) {
376                 if (b2a[(int)base64[x]] != x) {
377                         fprintf(stderr, "!!! %d failed\n", x);
378                 } else
379                         fprintf(stderr, "--- %d passed\n", x);
380         }
381 #endif
382 }
383
384 /* Recursive thread safe replacement of inet_ntoa */
385 const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia)
386 {
387         return inet_ntop(AF_INET, &ia, buf, bufsiz);
388 }
389
390 int ast_utils_init(void)
391 {
392         base64_init();
393         return 0;
394 }
395
396 #ifndef __linux__
397 #undef pthread_create /* For ast_pthread_create function only */
398 #endif /* ! LINUX */
399 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize)
400 {
401         pthread_attr_t lattr;
402         if (!attr) {
403                 pthread_attr_init(&lattr);
404                 attr = &lattr;
405         }
406         if (!stacksize)
407                 stacksize = AST_STACKSIZE;
408         errno = pthread_attr_setstacksize(attr, stacksize);
409         if (errno)
410                 ast_log(LOG_WARNING, "pthread_attr_setstacksize returned non-zero: %s\n", strerror(errno));
411         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
412 }
413
414 int ast_wait_for_input(int fd, int ms)
415 {
416         struct pollfd pfd[1];
417         memset(pfd, 0, sizeof(pfd));
418         pfd[0].fd = fd;
419         pfd[0].events = POLLIN|POLLPRI;
420         return poll(pfd, 1, ms);
421 }
422
423 char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
424 {
425         char *e;
426         char *q;
427
428         s = ast_strip(s);
429         if ((q = strchr(beg_quotes, *s))) {
430                 e = s + strlen(s) - 1;
431                 if (*e == *(end_quotes + (q - beg_quotes))) {
432                         s++;
433                         *e = '\0';
434                 }
435         }
436
437         return s;
438 }
439
440 int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
441 {
442         va_list ap;
443         int result;
444
445         if (!buffer || !*buffer || !space || !*space)
446                 return -1;
447
448         va_start(ap, fmt);
449         result = vsnprintf(*buffer, *space, fmt, ap);
450         va_end(ap);
451
452         if (result < 0)
453                 return -1;
454         else if (result > *space)
455                 result = *space;
456
457         *buffer += result;
458         *space -= result;
459         return 0;
460 }
461
462 int ast_true(const char *s)
463 {
464         if (!s || ast_strlen_zero(s))
465                 return 0;
466
467         /* Determine if this is a true value */
468         if (!strcasecmp(s, "yes") ||
469             !strcasecmp(s, "true") ||
470             !strcasecmp(s, "y") ||
471             !strcasecmp(s, "t") ||
472             !strcasecmp(s, "1") ||
473             !strcasecmp(s, "on"))
474                 return -1;
475
476         return 0;
477 }
478
479 int ast_false(const char *s)
480 {
481         if (!s || ast_strlen_zero(s))
482                 return 0;
483
484         /* Determine if this is a false value */
485         if (!strcasecmp(s, "no") ||
486             !strcasecmp(s, "false") ||
487             !strcasecmp(s, "n") ||
488             !strcasecmp(s, "f") ||
489             !strcasecmp(s, "0") ||
490             !strcasecmp(s, "off"))
491                 return -1;
492
493         return 0;
494 }
495
496 #ifndef HAVE_STRCASESTR
497 static char *upper(const char *orig, char *buf, int bufsize)
498 {
499         int i = 0;
500
501         while (i < (bufsize - 1) && orig[i]) {
502                 buf[i] = toupper(orig[i]);
503                 i++;
504         }
505
506         buf[i] = '\0';
507
508         return buf;
509 }
510
511 char *strcasestr(const char *haystack, const char *needle)
512 {
513         char *u1, *u2;
514         int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
515
516         u1 = alloca(u1len);
517         u2 = alloca(u2len);
518         if (u1 && u2) {
519                 char *offset;
520                 if (u2len > u1len) {
521                         /* Needle bigger than haystack */
522                         return NULL;
523                 }
524                 offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
525                 if (offset) {
526                         /* Return the offset into the original string */
527                         return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
528                 } else {
529                         return NULL;
530                 }
531         } else {
532                 ast_log(LOG_ERROR, "Out of memory\n");
533                 return NULL;
534         }
535 }
536 #endif
537
538 #ifndef HAVE_STRNLEN
539 size_t strnlen(const char *s, size_t n)
540 {
541         size_t len;
542
543         for (len=0; len < n; len++)
544                 if (s[len] == '\0')
545                         break;
546
547         return len;
548 }
549 #endif
550
551 #ifndef HAVE_STRNDUP
552 char *strndup(const char *s, size_t n)
553 {
554         size_t len = strnlen(s, n);
555         char *new = malloc(len + 1);
556
557         if (!new)
558                 return NULL;
559
560         new[len] = '\0';
561         return memcpy(new, s, len);
562 }
563 #endif
564
565 #ifndef HAVE_VASPRINTF
566 int vasprintf(char **strp, const char *fmt, va_list ap)
567 {
568         int size;
569         va_list ap2;
570
571         *strp = NULL;
572         va_copy(ap2, ap);
573         size = vsnprintf(*strp, 0, fmt, ap2);
574         va_end(ap2);
575         *strp = malloc(size + 1);
576         if (!*strp)
577                 return -1;
578         va_start(fmt, ap);
579         vsnprintf(*strp, size + 1, fmt, ap);
580         va_end(ap);
581
582         return size;
583 }
584 #endif