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