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