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