Revert Jim's earlier "fix" :)
[asterisk/asterisk.git] / utils.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Utility functions
5  *
6  * Copyright (C) 2004, Digium
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 <sys/types.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
23 #include <arpa/inet.h>
24 #include <asterisk/lock.h>
25 #include <asterisk/utils.h>
26 #include <asterisk/logger.h>
27
28 static char base64[64];
29 static char b2a[256];
30
31 char *ast_strip(char *buf)
32 {
33         char *start;
34         /* Strip off trailing whitespace, returns, etc */
35         while (!ast_strlen_zero(buf) && (buf[strlen(buf)-1]<33))
36                 buf[strlen(buf)-1] = '\0';
37         start = buf;
38         /* Strip off leading whitespace, returns, etc */
39         while (*start && (*start < 33))
40                 *start++ = '\0';
41         return start;
42 }
43
44 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined(__APPLE__)
45
46 /* duh? ERANGE value copied from web... */
47 #define ERANGE 34
48 #undef gethostbyname
49
50 AST_MUTEX_DEFINE_STATIC(__mutex);
51
52 /* Recursive replacement for gethostbyname for BSD-based systems */
53 static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
54                                 size_t buflen, struct hostent **result, 
55                                 int *h_errnop) 
56 {
57         int hsave;
58         struct hostent *ph;
59         ast_mutex_lock(&__mutex); /* begin critical area */
60         hsave = h_errno;
61
62         ph = gethostbyname(name);
63         *h_errnop = h_errno; /* copy h_errno to *h_herrnop */
64         if (ph == NULL) {
65                 *result = NULL;
66         } else {
67                 char **p, **q;
68                 char *pbuf;
69                 int nbytes=0;
70                 int naddr=0, naliases=0;
71                 /* determine if we have enough space in buf */
72
73                 /* count how many addresses */
74                 for (p = ph->h_addr_list; *p != 0; p++) {
75                         nbytes += ph->h_length; /* addresses */
76                         nbytes += sizeof(*p); /* pointers */
77                         naddr++;
78                 }
79                 nbytes += sizeof(*p); /* one more for the terminating NULL */
80
81                 /* count how many aliases, and total length of strings */
82                 for (p = ph->h_aliases; *p != 0; p++) {
83                         nbytes += (strlen(*p)+1); /* aliases */
84                         nbytes += sizeof(*p);  /* pointers */
85                         naliases++;
86                 }
87                 nbytes += sizeof(*p); /* one more for the terminating NULL */
88
89                 /* here nbytes is the number of bytes required in buffer */
90                 /* as a terminator must be there, the minimum value is ph->h_length */
91                 if(nbytes > buflen) {
92                         *result = NULL;
93                         ast_mutex_unlock(&__mutex); /* end critical area */
94                         return ERANGE; /* not enough space in buf!! */
95                 }
96
97                 /* There is enough space. Now we need to do a deep copy! */
98                 /* Allocation in buffer:
99                         from [0] to [(naddr-1) * sizeof(*p)]:
100                         pointers to addresses
101                         at [naddr * sizeof(*p)]:
102                         NULL
103                         from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
104                         pointers to aliases
105                         at [(naddr+naliases+1) * sizeof(*p)]:
106                         NULL
107                         then naddr addresses (fixed length), and naliases aliases (asciiz).
108                 */
109
110                 *ret = *ph;   /* copy whole structure (not its address!) */
111
112                 /* copy addresses */
113                 q = (char **)buf; /* pointer to pointers area (type: char **) */
114                 ret->h_addr_list = q; /* update pointer to address list */
115                 pbuf = buf + ((naddr+naliases+2)*sizeof(*p)); /* skip that area */
116                 for (p = ph->h_addr_list; *p != 0; p++) {
117                         memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
118                         *q++ = pbuf; /* the pointer is the one inside buf... */
119                         pbuf += ph->h_length; /* advance pbuf */
120                 }
121                 *q++ = NULL; /* address list terminator */
122
123                 /* copy aliases */
124                 ret->h_aliases = q; /* update pointer to aliases list */
125                 for (p = ph->h_aliases; *p != 0; p++) {
126                         strcpy(pbuf, *p); /* copy alias strings */
127                         *q++ = pbuf; /* the pointer is the one inside buf... */
128                         pbuf += strlen(*p); /* advance pbuf */
129                         *pbuf++ = 0; /* string terminator */
130                 }
131                 *q++ = NULL; /* terminator */
132
133                 strcpy(pbuf, ph->h_name); /* copy alias strings */
134                 ret->h_name = pbuf;
135                 pbuf += strlen(ph->h_name); /* advance pbuf */
136                 *pbuf++ = 0; /* string terminator */
137
138                 *result = ret;  /* and let *result point to structure */
139
140         }
141         h_errno = hsave;  /* restore h_errno */
142         ast_mutex_unlock(&__mutex); /* end critical area */
143
144         return (*result == NULL); /* return 0 on success, non-zero on error */
145 }
146
147
148 #endif
149
150 /* Recursive thread safe version of gethostbyname that replaces the 
151    standard gethostbyname (which is not recursive)
152 */
153 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
154 {
155         int res;
156         int herrno;
157         const char *s;
158         struct hostent *result = NULL;
159         /* Although it is perfectly legitimate to lookup a pure integer, for
160            the sake of the sanity of people who like to name their peers as
161            integers, we break with tradition and refuse to look up a
162            pure integer */
163         s = host;
164         while(s && *s) {
165                 if (!isdigit(*s))
166                         break;
167                 s++;
168         }
169         if (!s || !*s)
170                 return NULL;
171 #ifdef SOLARIS
172         result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
173
174         if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
175                 return NULL;
176 #else
177         res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
178
179         if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
180                 return NULL;
181 #endif
182         return &hp->hp;
183 }
184
185
186 /* This is a regression test for recursive mutexes.
187    test_for_thread_safety() will return 0 if recursive mutex locks are
188    working properly, and non-zero if they are not working properly. */
189
190 AST_MUTEX_DEFINE_STATIC(test_lock);
191 AST_MUTEX_DEFINE_STATIC(test_lock2);
192 static pthread_t test_thread; 
193 static int lock_count = 0;
194 static int test_errors = 0;
195
196 static void *test_thread_body(void *data) 
197
198         ast_mutex_lock(&test_lock);
199         lock_count += 10;
200         if (lock_count != 10) 
201                 test_errors++;
202         ast_mutex_lock(&test_lock);
203         lock_count += 10;
204         if (lock_count != 20) 
205                 test_errors++;
206         ast_mutex_lock(&test_lock2);
207         ast_mutex_unlock(&test_lock);
208         lock_count -= 10;
209         if (lock_count != 10) 
210                 test_errors++;
211         ast_mutex_unlock(&test_lock);
212         lock_count -= 10;
213         ast_mutex_unlock(&test_lock2);
214         if (lock_count != 0) 
215                 test_errors++;
216         return NULL;
217
218
219 int test_for_thread_safety(void)
220
221         ast_mutex_lock(&test_lock2);
222         ast_mutex_lock(&test_lock);
223         lock_count += 1;
224         ast_mutex_lock(&test_lock);
225         lock_count += 1;
226         ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
227         usleep(100);
228         if (lock_count != 2) 
229                 test_errors++;
230         ast_mutex_unlock(&test_lock);
231         lock_count -= 1;
232         usleep(100); 
233         if (lock_count != 1) 
234                 test_errors++;
235         ast_mutex_unlock(&test_lock);
236         lock_count -= 1;
237         if (lock_count != 0) 
238                 test_errors++;
239         ast_mutex_unlock(&test_lock2);
240         usleep(100);
241         if (lock_count != 0) 
242                 test_errors++;
243         pthread_join(test_thread, NULL);
244         return(test_errors);          /* return 0 on success. */
245 }
246
247 int ast_base64decode(unsigned char *dst, char *src, int max)
248 {
249         int cnt = 0;
250         unsigned int byte = 0;
251         unsigned int bits = 0;
252         int incnt = 0;
253 #if 0
254         unsigned char *odst = dst;
255 #endif
256         while(*src && (cnt < max)) {
257                 /* Shift in 6 bits of input */
258                 byte <<= 6;
259                 byte |= (b2a[(int)(*src)]) & 0x3f;
260                 bits += 6;
261 #if 0
262                 printf("Add: %c %s\n", *src, binary(b2a[(int)(*src)] & 0x3f, 6));
263 #endif
264                 src++;
265                 incnt++;
266                 /* If we have at least 8 bits left over, take that character 
267                    off the top */
268                 if (bits >= 8)  {
269                         bits -= 8;
270                         *dst = (byte >> bits) & 0xff;
271 #if 0
272                         printf("Remove: %02x %s\n", *dst, binary(*dst, 8));
273 #endif
274                         dst++;
275                         cnt++;
276                 }
277         }
278 #if 0
279         dump(odst, cnt);
280 #endif
281         /* Dont worry about left over bits, they're extra anyway */
282         return cnt;
283 }
284
285 int ast_base64encode(char *dst, unsigned char *src, int srclen, int max)
286 {
287         int cnt = 0;
288         unsigned int byte = 0;
289         int bits = 0;
290         int index;
291         int cntin = 0;
292 #if 0
293         char *odst = dst;
294         dump(src, srclen);
295 #endif
296         /* Reserve one bit for end */
297         max--;
298         while((cntin < srclen) && (cnt < max)) {
299                 byte <<= 8;
300 #if 0
301                 printf("Add: %02x %s\n", *src, binary(*src, 8));
302 #endif
303                 byte |= *(src++);
304                 bits += 8;
305                 cntin++;
306                 while((bits >= 6) && (cnt < max)) {
307                         bits -= 6;
308                         /* We want only the top */
309                         index = (byte >> bits) & 0x3f;
310                         *dst = base64[index];
311 #if 0
312                         printf("Remove: %c %s\n", *dst, binary(index, 6));
313 #endif
314                         dst++;
315                         cnt++;
316                 }
317         }
318         if (bits && (cnt < max)) {
319                 /* Add one last character for the remaining bits, 
320                    padding the rest with 0 */
321                 byte <<= (6 - bits);
322                 index = (byte) & 0x3f;
323                 *(dst++) = base64[index];
324                 cnt++;
325         }
326         *dst = '\0';
327         return cnt;
328 }
329
330 static void base64_init(void)
331 {
332         int x;
333         memset(b2a, -1, sizeof(b2a));
334         /* Initialize base-64 Conversion table */
335         for (x=0;x<26;x++) {
336                 /* A-Z */
337                 base64[x] = 'A' + x;
338                 b2a['A' + x] = x;
339                 /* a-z */
340                 base64[x + 26] = 'a' + x;
341                 b2a['a' + x] = x + 26;
342                 /* 0-9 */
343                 if (x < 10) {
344                         base64[x + 52] = '0' + x;
345                         b2a['0' + x] = x + 52;
346                 }
347         }
348         base64[62] = '+';
349         base64[63] = '/';
350         b2a[(int)'+'] = 62;
351         b2a[(int)'/'] = 63;
352 #if 0
353         for (x=0;x<64;x++) {
354                 if (b2a[(int)base64[x]] != x) {
355                         fprintf(stderr, "!!! %d failed\n", x);
356                 } else
357                         fprintf(stderr, "--- %d passed\n", x);
358         }
359 #endif
360 }
361
362 /* Recursive thread safe replacement of inet_ntoa */
363 const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia)
364 {
365         return inet_ntop(AF_INET, &ia, buf, bufsiz);
366 }
367
368 int ast_utils_init(void)
369 {
370         base64_init();
371         return 0;
372 }
373
374
375 #ifndef __linux__
376 #undef pthread_create /* For ast_pthread_create function only */
377 int ast_pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data)
378 {
379         pthread_attr_t lattr;
380         if (!attr) {
381                 pthread_attr_init(&lattr);
382                 attr = &lattr;
383         }
384         errno = pthread_attr_setstacksize(attr, PTHREAD_ATTR_STACKSIZE);
385         if (errno)
386                 ast_log(LOG_WARNING, "pthread_attr_setstacksize returned non-zero: %s\n", strerror(errno));
387         return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
388 }
389 #endif /* ! LINUX */
390
391 /* Case-insensitive substring matching */
392 #ifndef LINUX
393 static char *upper(const char *orig, char *buf, int bufsize)
394 {
395         int i;
396         memset(buf, 0, bufsize);
397         for (i=0; i<bufsize - 1; i++) {
398                 buf[i] = toupper(orig[i]);
399                 if (orig[i] == '\0') {
400                         break;
401                 }
402         }
403         return buf;
404 }
405
406 char *ast_strcasestr(const char *haystack, const char *needle)
407 {
408         char *u1, *u2;
409         int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
410
411         u1 = alloca(u1len);
412         u2 = alloca(u2len);
413         if (u1 && u2) {
414                 char *offset;
415                 if (u2len > u1len) {
416                         /* Needle bigger than haystack */
417                         return NULL;
418                 }
419                 offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
420                 if (offset) {
421                         /* Return the offset into the original string */
422                         return ((char *)((unsigned int)haystack + (unsigned int)(offset - u1)));
423                 } else {
424                         return NULL;
425                 }
426         } else {
427                 ast_log(LOG_ERROR, "Out of memory\n");
428                 return NULL;
429         }
430 }
431 #endif
432
433
434 /*--- ast_print_group: Print call group and pickup group ---*/
435 char *ast_print_group(char *buf, int buflen, unsigned int group) 
436 {
437         unsigned int i;
438         int first=1;
439         char num[3];
440
441         buf[0] = '\0';
442         
443         if (!group)     /* Return empty string if no group */
444                 return(buf);
445
446         for (i=0; i<=31; i++) { /* Max group is 31 */
447                 if (group & (1 << i)) {
448                         if (!first) {
449                                 strncat(buf, ", ", buflen);
450                         } else {
451                                 first=0;
452                         }
453                         snprintf(num, sizeof(num), "%u", i);
454                         strncat(buf, num, buflen);
455                 }
456         }
457         return(buf);
458 }