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, AST_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