2004-05-09 08:22:15 +00:00
|
|
|
/*
|
2005-09-14 20:46:50 +00:00
|
|
|
* Asterisk -- An open source telephony toolkit.
|
2004-05-09 08:22:15 +00:00
|
|
|
*
|
2006-01-04 21:54:09 +00:00
|
|
|
* Copyright (C) 1999 - 2006, Digium, Inc.
|
2004-05-09 08:22:15 +00:00
|
|
|
*
|
2005-09-14 20:46:50 +00:00
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
2004-05-09 08:22:15 +00:00
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
2005-09-14 20:46:50 +00:00
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
2005-10-24 20:12:06 +00:00
|
|
|
/*! \file
|
2005-09-14 20:46:50 +00:00
|
|
|
*
|
2005-10-24 20:12:06 +00:00
|
|
|
* \brief Utility functions
|
2005-09-14 20:46:50 +00:00
|
|
|
*
|
2005-10-24 20:12:06 +00:00
|
|
|
* \note These are important for portability and security,
|
|
|
|
* so please use them in favour of other routines.
|
|
|
|
* Please consult the CODING GUIDELINES for more information.
|
2004-05-09 08:22:15 +00:00
|
|
|
*/
|
|
|
|
|
2004-05-11 18:41:09 +00:00
|
|
|
#include <ctype.h>
|
2004-05-31 16:51:28 +00:00
|
|
|
#include <string.h>
|
2004-06-22 17:42:14 +00:00
|
|
|
#include <unistd.h>
|
2004-09-06 15:29:41 +00:00
|
|
|
#include <stdlib.h>
|
2004-08-08 17:15:02 +00:00
|
|
|
#include <errno.h>
|
2005-05-15 22:33:02 +00:00
|
|
|
#include <stdarg.h>
|
2005-01-08 18:54:30 +00:00
|
|
|
#include <stdio.h>
|
2004-06-29 12:56:46 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
2004-06-29 17:54:25 +00:00
|
|
|
#include <netinet/in.h>
|
2004-06-29 12:56:46 +00:00
|
|
|
#include <arpa/inet.h>
|
2005-04-22 13:11:34 +00:00
|
|
|
|
2005-06-06 20:27:51 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
2005-06-06 22:12:19 +00:00
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
2005-06-06 20:27:51 +00:00
|
|
|
|
2005-04-21 06:02:45 +00:00
|
|
|
#include "asterisk/lock.h"
|
|
|
|
#include "asterisk/io.h"
|
|
|
|
#include "asterisk/logger.h"
|
|
|
|
#include "asterisk/md5.h"
|
2006-02-03 22:37:29 +00:00
|
|
|
#include "asterisk/sha1.h"
|
2005-07-19 14:08:19 +00:00
|
|
|
#include "asterisk/options.h"
|
2005-11-01 21:53:30 +00:00
|
|
|
#include "asterisk/compat.h"
|
2004-05-09 08:22:15 +00:00
|
|
|
|
2005-06-24 22:45:15 +00:00
|
|
|
#define AST_API_MODULE /* ensure that inlinable API functions will be built in this module if required */
|
|
|
|
#include "asterisk/strings.h"
|
|
|
|
|
|
|
|
#define AST_API_MODULE /* ensure that inlinable API functions will be built in this module if required */
|
|
|
|
#include "asterisk/time.h"
|
|
|
|
|
2006-01-04 21:54:09 +00:00
|
|
|
#define AST_API_MODULE /* ensure that inlinable API functions will be built in this module if required */
|
|
|
|
#include "asterisk/stringfields.h"
|
|
|
|
|
2005-06-23 23:07:55 +00:00
|
|
|
#define AST_API_MODULE /* ensure that inlinable API functions will be built in this module if required */
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
|
2004-06-25 04:07:52 +00:00
|
|
|
static char base64[64];
|
|
|
|
static char b2a[256];
|
|
|
|
|
2005-11-01 21:53:30 +00:00
|
|
|
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined(__APPLE__) || defined(__CYGWIN__)
|
2004-05-09 08:22:15 +00:00
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
#define ERANGE 34 /*!< duh? ERANGE value copied from web... */
|
2004-05-09 08:22:15 +00:00
|
|
|
#undef gethostbyname
|
|
|
|
|
2004-06-09 01:45:08 +00:00
|
|
|
AST_MUTEX_DEFINE_STATIC(__mutex);
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief Recursive replacement for gethostbyname for BSD-based systems.
|
|
|
|
\note This
|
2005-05-09 13:50:38 +00:00
|
|
|
routine is derived from code originally written and placed in the public
|
|
|
|
domain by Enzo Michelangeli <em@em.no-ip.com> */
|
|
|
|
|
2004-06-22 17:42:14 +00:00
|
|
|
static int gethostbyname_r (const char *name, struct hostent *ret, char *buf,
|
2004-06-22 20:11:15 +00:00
|
|
|
size_t buflen, struct hostent **result,
|
|
|
|
int *h_errnop)
|
2004-05-09 08:22:15 +00:00
|
|
|
{
|
|
|
|
int hsave;
|
|
|
|
struct hostent *ph;
|
|
|
|
ast_mutex_lock(&__mutex); /* begin critical area */
|
|
|
|
hsave = h_errno;
|
|
|
|
|
|
|
|
ph = gethostbyname(name);
|
|
|
|
*h_errnop = h_errno; /* copy h_errno to *h_herrnop */
|
|
|
|
if (ph == NULL) {
|
|
|
|
*result = NULL;
|
|
|
|
} else {
|
|
|
|
char **p, **q;
|
|
|
|
char *pbuf;
|
|
|
|
int nbytes=0;
|
|
|
|
int naddr=0, naliases=0;
|
|
|
|
/* determine if we have enough space in buf */
|
|
|
|
|
|
|
|
/* count how many addresses */
|
|
|
|
for (p = ph->h_addr_list; *p != 0; p++) {
|
|
|
|
nbytes += ph->h_length; /* addresses */
|
|
|
|
nbytes += sizeof(*p); /* pointers */
|
|
|
|
naddr++;
|
|
|
|
}
|
|
|
|
nbytes += sizeof(*p); /* one more for the terminating NULL */
|
|
|
|
|
|
|
|
/* count how many aliases, and total length of strings */
|
|
|
|
for (p = ph->h_aliases; *p != 0; p++) {
|
|
|
|
nbytes += (strlen(*p)+1); /* aliases */
|
|
|
|
nbytes += sizeof(*p); /* pointers */
|
|
|
|
naliases++;
|
|
|
|
}
|
|
|
|
nbytes += sizeof(*p); /* one more for the terminating NULL */
|
|
|
|
|
|
|
|
/* here nbytes is the number of bytes required in buffer */
|
|
|
|
/* as a terminator must be there, the minimum value is ph->h_length */
|
|
|
|
if(nbytes > buflen) {
|
|
|
|
*result = NULL;
|
|
|
|
ast_mutex_unlock(&__mutex); /* end critical area */
|
|
|
|
return ERANGE; /* not enough space in buf!! */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* There is enough space. Now we need to do a deep copy! */
|
|
|
|
/* Allocation in buffer:
|
|
|
|
from [0] to [(naddr-1) * sizeof(*p)]:
|
|
|
|
pointers to addresses
|
|
|
|
at [naddr * sizeof(*p)]:
|
|
|
|
NULL
|
|
|
|
from [(naddr+1) * sizeof(*p)] to [(naddr+naliases) * sizeof(*p)] :
|
|
|
|
pointers to aliases
|
|
|
|
at [(naddr+naliases+1) * sizeof(*p)]:
|
|
|
|
NULL
|
|
|
|
then naddr addresses (fixed length), and naliases aliases (asciiz).
|
|
|
|
*/
|
|
|
|
|
|
|
|
*ret = *ph; /* copy whole structure (not its address!) */
|
|
|
|
|
|
|
|
/* copy addresses */
|
|
|
|
q = (char **)buf; /* pointer to pointers area (type: char **) */
|
|
|
|
ret->h_addr_list = q; /* update pointer to address list */
|
|
|
|
pbuf = buf + ((naddr+naliases+2)*sizeof(*p)); /* skip that area */
|
|
|
|
for (p = ph->h_addr_list; *p != 0; p++) {
|
|
|
|
memcpy(pbuf, *p, ph->h_length); /* copy address bytes */
|
|
|
|
*q++ = pbuf; /* the pointer is the one inside buf... */
|
|
|
|
pbuf += ph->h_length; /* advance pbuf */
|
|
|
|
}
|
|
|
|
*q++ = NULL; /* address list terminator */
|
|
|
|
|
|
|
|
/* copy aliases */
|
|
|
|
ret->h_aliases = q; /* update pointer to aliases list */
|
|
|
|
for (p = ph->h_aliases; *p != 0; p++) {
|
|
|
|
strcpy(pbuf, *p); /* copy alias strings */
|
|
|
|
*q++ = pbuf; /* the pointer is the one inside buf... */
|
|
|
|
pbuf += strlen(*p); /* advance pbuf */
|
|
|
|
*pbuf++ = 0; /* string terminator */
|
|
|
|
}
|
|
|
|
*q++ = NULL; /* terminator */
|
|
|
|
|
|
|
|
strcpy(pbuf, ph->h_name); /* copy alias strings */
|
|
|
|
ret->h_name = pbuf;
|
|
|
|
pbuf += strlen(ph->h_name); /* advance pbuf */
|
|
|
|
*pbuf++ = 0; /* string terminator */
|
|
|
|
|
|
|
|
*result = ret; /* and let *result point to structure */
|
|
|
|
|
|
|
|
}
|
|
|
|
h_errno = hsave; /* restore h_errno */
|
|
|
|
ast_mutex_unlock(&__mutex); /* end critical area */
|
|
|
|
|
2004-05-15 05:02:42 +00:00
|
|
|
return (*result == NULL); /* return 0 on success, non-zero on error */
|
2004-05-09 08:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2005-10-26 13:03:17 +00:00
|
|
|
/*! \brief Re-entrant (thread safe) version of gethostbyname that replaces the
|
2005-04-06 21:12:32 +00:00
|
|
|
standard gethostbyname (which is not thread safe)
|
2004-06-29 17:54:25 +00:00
|
|
|
*/
|
2004-05-09 08:22:15 +00:00
|
|
|
struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
int herrno;
|
2005-10-21 04:09:23 +00:00
|
|
|
int dots=0;
|
2004-05-11 18:41:09 +00:00
|
|
|
const char *s;
|
2004-05-09 08:22:15 +00:00
|
|
|
struct hostent *result = NULL;
|
2004-05-11 18:41:09 +00:00
|
|
|
/* Although it is perfectly legitimate to lookup a pure integer, for
|
|
|
|
the sake of the sanity of people who like to name their peers as
|
|
|
|
integers, we break with tradition and refuse to look up a
|
|
|
|
pure integer */
|
|
|
|
s = host;
|
2005-03-17 23:12:15 +00:00
|
|
|
res = 0;
|
2004-05-11 18:41:09 +00:00
|
|
|
while(s && *s) {
|
2005-10-21 04:09:23 +00:00
|
|
|
if (*s == '.')
|
|
|
|
dots++;
|
|
|
|
else if (!isdigit(*s))
|
2004-05-11 18:41:09 +00:00
|
|
|
break;
|
|
|
|
s++;
|
|
|
|
}
|
2005-10-21 04:09:23 +00:00
|
|
|
if (!s || !*s) {
|
|
|
|
/* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
|
|
|
|
if (dots != 3)
|
|
|
|
return NULL;
|
2005-10-21 14:09:03 +00:00
|
|
|
memset(hp, 0, sizeof(struct ast_hostent));
|
2005-10-31 15:21:12 +00:00
|
|
|
hp->hp.h_addr_list = (void *) hp->buf;
|
2005-10-21 14:09:03 +00:00
|
|
|
hp->hp.h_addr = hp->buf + sizeof(void *);
|
2005-10-21 04:09:23 +00:00
|
|
|
if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
|
|
|
|
return &hp->hp;
|
2004-05-11 18:41:09 +00:00
|
|
|
return NULL;
|
2005-10-21 04:09:23 +00:00
|
|
|
|
|
|
|
}
|
2004-12-14 23:36:30 +00:00
|
|
|
#ifdef SOLARIS
|
|
|
|
result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
|
|
|
|
|
|
|
|
if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
|
|
|
|
return NULL;
|
|
|
|
#else
|
2004-05-09 08:22:15 +00:00
|
|
|
res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
|
|
|
|
|
2004-05-13 21:54:30 +00:00
|
|
|
if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
|
2004-05-09 08:22:15 +00:00
|
|
|
return NULL;
|
2004-12-14 23:36:30 +00:00
|
|
|
#endif
|
2004-05-09 08:22:15 +00:00
|
|
|
return &hp->hp;
|
|
|
|
}
|
2004-06-22 17:42:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AST_MUTEX_DEFINE_STATIC(test_lock);
|
|
|
|
AST_MUTEX_DEFINE_STATIC(test_lock2);
|
|
|
|
static pthread_t test_thread;
|
|
|
|
static int lock_count = 0;
|
|
|
|
static int test_errors = 0;
|
|
|
|
|
2005-10-26 13:03:17 +00:00
|
|
|
/*! \brief This is a regression test for recursive mutexes.
|
|
|
|
test_for_thread_safety() will return 0 if recursive mutex locks are
|
|
|
|
working properly, and non-zero if they are not working properly. */
|
2004-06-22 17:42:14 +00:00
|
|
|
static void *test_thread_body(void *data)
|
|
|
|
{
|
2004-06-22 19:53:36 +00:00
|
|
|
ast_mutex_lock(&test_lock);
|
|
|
|
lock_count += 10;
|
|
|
|
if (lock_count != 10)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_lock(&test_lock);
|
|
|
|
lock_count += 10;
|
|
|
|
if (lock_count != 20)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_lock(&test_lock2);
|
|
|
|
ast_mutex_unlock(&test_lock);
|
|
|
|
lock_count -= 10;
|
|
|
|
if (lock_count != 10)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_unlock(&test_lock);
|
|
|
|
lock_count -= 10;
|
|
|
|
ast_mutex_unlock(&test_lock2);
|
|
|
|
if (lock_count != 0)
|
|
|
|
test_errors++;
|
|
|
|
return NULL;
|
2004-06-22 17:42:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int test_for_thread_safety(void)
|
|
|
|
{
|
2004-06-22 19:53:36 +00:00
|
|
|
ast_mutex_lock(&test_lock2);
|
|
|
|
ast_mutex_lock(&test_lock);
|
|
|
|
lock_count += 1;
|
|
|
|
ast_mutex_lock(&test_lock);
|
|
|
|
lock_count += 1;
|
2004-08-08 17:15:02 +00:00
|
|
|
ast_pthread_create(&test_thread, NULL, test_thread_body, NULL);
|
2004-06-22 19:53:36 +00:00
|
|
|
usleep(100);
|
|
|
|
if (lock_count != 2)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_unlock(&test_lock);
|
|
|
|
lock_count -= 1;
|
|
|
|
usleep(100);
|
|
|
|
if (lock_count != 1)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_unlock(&test_lock);
|
|
|
|
lock_count -= 1;
|
|
|
|
if (lock_count != 0)
|
|
|
|
test_errors++;
|
|
|
|
ast_mutex_unlock(&test_lock2);
|
|
|
|
usleep(100);
|
|
|
|
if (lock_count != 0)
|
|
|
|
test_errors++;
|
|
|
|
pthread_join(test_thread, NULL);
|
|
|
|
return(test_errors); /* return 0 on success. */
|
2004-06-22 17:42:14 +00:00
|
|
|
}
|
2004-06-25 04:07:52 +00:00
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief Produce 32 char MD5 hash of value. */
|
2005-02-18 05:29:31 +00:00
|
|
|
void ast_md5_hash(char *output, char *input)
|
|
|
|
{
|
2005-05-04 04:05:34 +00:00
|
|
|
struct MD5Context md5;
|
|
|
|
unsigned char digest[16];
|
|
|
|
char *ptr;
|
|
|
|
int x;
|
|
|
|
|
|
|
|
MD5Init(&md5);
|
2005-08-07 06:47:20 +00:00
|
|
|
MD5Update(&md5, (unsigned char *)input, strlen(input));
|
2005-05-04 04:05:34 +00:00
|
|
|
MD5Final(digest, &md5);
|
|
|
|
ptr = output;
|
|
|
|
for (x=0; x<16; x++)
|
|
|
|
ptr += sprintf(ptr, "%2.2x", digest[x]);
|
2005-02-18 05:29:31 +00:00
|
|
|
}
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief Produce 40 char SHA1 hash of value. */
|
2006-02-03 22:37:29 +00:00
|
|
|
void ast_sha1_hash(char *output, char *input)
|
|
|
|
{
|
|
|
|
struct SHA1Context sha;
|
|
|
|
char *ptr;
|
|
|
|
int x;
|
|
|
|
uint8_t Message_Digest[20];
|
|
|
|
|
|
|
|
SHA1Reset(&sha);
|
|
|
|
|
|
|
|
SHA1Input(&sha, (const unsigned char *) input, strlen(input));
|
|
|
|
|
|
|
|
SHA1Result(&sha, Message_Digest);
|
|
|
|
ptr = output;
|
|
|
|
for (x = 0; x < 20; x++)
|
|
|
|
ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
|
|
|
|
}
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief decode BASE64 encoded text */
|
2005-10-16 03:10:33 +00:00
|
|
|
int ast_base64decode(unsigned char *dst, const char *src, int max)
|
2004-06-25 04:07:52 +00:00
|
|
|
{
|
|
|
|
int cnt = 0;
|
|
|
|
unsigned int byte = 0;
|
|
|
|
unsigned int bits = 0;
|
|
|
|
int incnt = 0;
|
|
|
|
#if 0
|
|
|
|
unsigned char *odst = dst;
|
|
|
|
#endif
|
|
|
|
while(*src && (cnt < max)) {
|
|
|
|
/* Shift in 6 bits of input */
|
|
|
|
byte <<= 6;
|
|
|
|
byte |= (b2a[(int)(*src)]) & 0x3f;
|
|
|
|
bits += 6;
|
|
|
|
#if 0
|
|
|
|
printf("Add: %c %s\n", *src, binary(b2a[(int)(*src)] & 0x3f, 6));
|
|
|
|
#endif
|
|
|
|
src++;
|
|
|
|
incnt++;
|
|
|
|
/* If we have at least 8 bits left over, take that character
|
|
|
|
off the top */
|
|
|
|
if (bits >= 8) {
|
|
|
|
bits -= 8;
|
|
|
|
*dst = (byte >> bits) & 0xff;
|
|
|
|
#if 0
|
|
|
|
printf("Remove: %02x %s\n", *dst, binary(*dst, 8));
|
|
|
|
#endif
|
|
|
|
dst++;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if 0
|
|
|
|
dump(odst, cnt);
|
|
|
|
#endif
|
|
|
|
/* Dont worry about left over bits, they're extra anyway */
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief encode text to BASE64 coding */
|
2005-10-16 03:10:33 +00:00
|
|
|
int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
|
2004-06-25 04:07:52 +00:00
|
|
|
{
|
|
|
|
int cnt = 0;
|
|
|
|
unsigned int byte = 0;
|
|
|
|
int bits = 0;
|
|
|
|
int index;
|
|
|
|
int cntin = 0;
|
|
|
|
#if 0
|
|
|
|
char *odst = dst;
|
|
|
|
dump(src, srclen);
|
|
|
|
#endif
|
|
|
|
/* Reserve one bit for end */
|
|
|
|
max--;
|
|
|
|
while((cntin < srclen) && (cnt < max)) {
|
|
|
|
byte <<= 8;
|
|
|
|
#if 0
|
|
|
|
printf("Add: %02x %s\n", *src, binary(*src, 8));
|
|
|
|
#endif
|
|
|
|
byte |= *(src++);
|
|
|
|
bits += 8;
|
|
|
|
cntin++;
|
|
|
|
while((bits >= 6) && (cnt < max)) {
|
|
|
|
bits -= 6;
|
|
|
|
/* We want only the top */
|
|
|
|
index = (byte >> bits) & 0x3f;
|
|
|
|
*dst = base64[index];
|
|
|
|
#if 0
|
|
|
|
printf("Remove: %c %s\n", *dst, binary(index, 6));
|
|
|
|
#endif
|
|
|
|
dst++;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bits && (cnt < max)) {
|
|
|
|
/* Add one last character for the remaining bits,
|
|
|
|
padding the rest with 0 */
|
|
|
|
byte <<= (6 - bits);
|
|
|
|
index = (byte) & 0x3f;
|
|
|
|
*(dst++) = base64[index];
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
*dst = '\0';
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void base64_init(void)
|
|
|
|
{
|
|
|
|
int x;
|
|
|
|
memset(b2a, -1, sizeof(b2a));
|
|
|
|
/* Initialize base-64 Conversion table */
|
|
|
|
for (x=0;x<26;x++) {
|
|
|
|
/* A-Z */
|
|
|
|
base64[x] = 'A' + x;
|
|
|
|
b2a['A' + x] = x;
|
|
|
|
/* a-z */
|
|
|
|
base64[x + 26] = 'a' + x;
|
|
|
|
b2a['a' + x] = x + 26;
|
|
|
|
/* 0-9 */
|
|
|
|
if (x < 10) {
|
|
|
|
base64[x + 52] = '0' + x;
|
|
|
|
b2a['0' + x] = x + 52;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
base64[62] = '+';
|
|
|
|
base64[63] = '/';
|
|
|
|
b2a[(int)'+'] = 62;
|
|
|
|
b2a[(int)'/'] = 63;
|
|
|
|
#if 0
|
|
|
|
for (x=0;x<64;x++) {
|
|
|
|
if (b2a[(int)base64[x]] != x) {
|
|
|
|
fprintf(stderr, "!!! %d failed\n", x);
|
|
|
|
} else
|
|
|
|
fprintf(stderr, "--- %d passed\n", x);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief ast_uri_encode: Turn text string to URI-encoded %XX version
|
|
|
|
\note At this point, we're converting from ISO-8859-x (8-bit), not UTF8
|
2005-08-29 22:39:39 +00:00
|
|
|
as in the SIP protocol spec
|
|
|
|
If doreserved == 1 we will convert reserved characters also.
|
|
|
|
RFC 2396, section 2.4
|
|
|
|
outbuf needs to have more memory allocated than the instring
|
|
|
|
to have room for the expansion. Every char that is converted
|
|
|
|
is replaced by three ASCII characters.
|
|
|
|
|
|
|
|
Note: The doreserved option is needed for replaces header in
|
|
|
|
SIP transfers.
|
|
|
|
*/
|
2006-01-04 21:54:09 +00:00
|
|
|
char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved)
|
2005-08-29 22:39:39 +00:00
|
|
|
{
|
|
|
|
char *reserved = ";/?:@&=+$, "; /* Reserved chars */
|
|
|
|
|
2006-01-04 21:54:09 +00:00
|
|
|
const char *ptr = string; /* Start with the string */
|
2005-08-29 22:39:39 +00:00
|
|
|
char *out = NULL;
|
|
|
|
char *buf = NULL;
|
|
|
|
|
|
|
|
strncpy(outbuf, string, buflen);
|
|
|
|
|
|
|
|
/* If there's no characters to convert, just go through and don't do anything */
|
|
|
|
while (*ptr) {
|
|
|
|
if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
|
|
|
|
/* Oops, we need to start working here */
|
|
|
|
if (!buf) {
|
|
|
|
buf = outbuf;
|
|
|
|
out = buf + (ptr - string) ; /* Set output ptr */
|
|
|
|
}
|
|
|
|
out += sprintf(out, "%%%02x", (unsigned char) *ptr);
|
|
|
|
} else if (buf) {
|
|
|
|
*out = *ptr; /* Continue copying the string */
|
|
|
|
out++;
|
|
|
|
}
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
if (buf)
|
|
|
|
*out = '\0';
|
|
|
|
return outbuf;
|
|
|
|
}
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string) */
|
2005-08-29 22:39:39 +00:00
|
|
|
void ast_uri_decode(char *s)
|
|
|
|
{
|
|
|
|
char *o;
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
for (o = s; *s; s++, o++) {
|
|
|
|
if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
|
|
|
|
/* have '%', two chars and correct parsing */
|
|
|
|
*o = tmp;
|
|
|
|
s += 2; /* Will be incremented once more when we break out */
|
|
|
|
} else /* all other cases, just copy */
|
|
|
|
*o = *s;
|
|
|
|
}
|
|
|
|
*o = '\0';
|
|
|
|
}
|
|
|
|
|
2005-10-26 13:03:17 +00:00
|
|
|
/*! \brief ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa */
|
2004-06-29 12:56:46 +00:00
|
|
|
const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia)
|
|
|
|
{
|
|
|
|
return inet_ntop(AF_INET, &ia, buf, bufsiz);
|
|
|
|
}
|
2004-06-25 04:07:52 +00:00
|
|
|
|
|
|
|
int ast_utils_init(void)
|
|
|
|
{
|
|
|
|
base64_init();
|
|
|
|
return 0;
|
|
|
|
}
|
2004-08-08 17:15:02 +00:00
|
|
|
|
2005-03-08 20:47:30 +00:00
|
|
|
#ifndef __linux__
|
|
|
|
#undef pthread_create /* For ast_pthread_create function only */
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !__linux__ */
|
2005-08-29 22:39:39 +00:00
|
|
|
|
2005-03-04 00:01:41 +00:00
|
|
|
int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize)
|
2004-08-08 17:15:02 +00:00
|
|
|
{
|
|
|
|
pthread_attr_t lattr;
|
|
|
|
if (!attr) {
|
|
|
|
pthread_attr_init(&lattr);
|
|
|
|
attr = &lattr;
|
|
|
|
}
|
2005-09-29 04:08:18 +00:00
|
|
|
#ifdef __linux__
|
|
|
|
/* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
|
|
|
|
which is kind of useless. Change this here to
|
|
|
|
PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
|
|
|
|
priority will propagate down to new threads by default.
|
|
|
|
This does mean that callers cannot set a different priority using
|
|
|
|
PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
|
|
|
|
the priority afterwards with pthread_setschedparam(). */
|
|
|
|
errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED);
|
|
|
|
if (errno)
|
|
|
|
ast_log(LOG_WARNING, "pthread_attr_setinheritsched returned non-zero: %s\n", strerror(errno));
|
|
|
|
#endif
|
|
|
|
|
2005-03-04 00:01:41 +00:00
|
|
|
if (!stacksize)
|
|
|
|
stacksize = AST_STACKSIZE;
|
|
|
|
errno = pthread_attr_setstacksize(attr, stacksize);
|
2004-08-08 17:15:02 +00:00
|
|
|
if (errno)
|
|
|
|
ast_log(LOG_WARNING, "pthread_attr_setstacksize returned non-zero: %s\n", strerror(errno));
|
|
|
|
return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
|
|
|
|
}
|
2004-08-27 04:21:09 +00:00
|
|
|
|
2005-03-05 03:20:55 +00:00
|
|
|
int ast_wait_for_input(int fd, int ms)
|
|
|
|
{
|
|
|
|
struct pollfd pfd[1];
|
|
|
|
memset(pfd, 0, sizeof(pfd));
|
|
|
|
pfd[0].fd = fd;
|
|
|
|
pfd[0].events = POLLIN|POLLPRI;
|
|
|
|
return poll(pfd, 1, ms);
|
|
|
|
}
|
|
|
|
|
2005-06-24 22:45:15 +00:00
|
|
|
char *ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
|
|
|
|
{
|
|
|
|
char *e;
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
s = ast_strip(s);
|
|
|
|
if ((q = strchr(beg_quotes, *s))) {
|
|
|
|
e = s + strlen(s) - 1;
|
|
|
|
if (*e == *(end_quotes + (q - beg_quotes))) {
|
|
|
|
s++;
|
|
|
|
*e = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2005-10-01 15:41:27 +00:00
|
|
|
int ast_build_string_va(char **buffer, size_t *space, const char *fmt, va_list ap)
|
2005-05-15 22:33:02 +00:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (!buffer || !*buffer || !space || !*space)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
result = vsnprintf(*buffer, *space, fmt, ap);
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
return -1;
|
|
|
|
else if (result > *space)
|
|
|
|
result = *space;
|
|
|
|
|
|
|
|
*buffer += result;
|
|
|
|
*space -= result;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-01 15:41:27 +00:00
|
|
|
int ast_build_string(char **buffer, size_t *space, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
result = ast_build_string_va(buffer, space, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2005-06-24 22:45:15 +00:00
|
|
|
int ast_true(const char *s)
|
|
|
|
{
|
2005-10-26 18:54:24 +00:00
|
|
|
if (ast_strlen_zero(s))
|
2005-06-24 22:45:15 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Determine if this is a true value */
|
|
|
|
if (!strcasecmp(s, "yes") ||
|
|
|
|
!strcasecmp(s, "true") ||
|
|
|
|
!strcasecmp(s, "y") ||
|
|
|
|
!strcasecmp(s, "t") ||
|
|
|
|
!strcasecmp(s, "1") ||
|
|
|
|
!strcasecmp(s, "on"))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ast_false(const char *s)
|
|
|
|
{
|
2005-10-26 18:54:24 +00:00
|
|
|
if (ast_strlen_zero(s))
|
2005-06-24 22:45:15 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Determine if this is a false value */
|
|
|
|
if (!strcasecmp(s, "no") ||
|
|
|
|
!strcasecmp(s, "false") ||
|
|
|
|
!strcasecmp(s, "n") ||
|
|
|
|
!strcasecmp(s, "f") ||
|
|
|
|
!strcasecmp(s, "0") ||
|
|
|
|
!strcasecmp(s, "off"))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-15 23:00:47 +00:00
|
|
|
#define ONE_MILLION 1000000
|
|
|
|
/*
|
|
|
|
* put timeval in a valid range. usec is 0..999999
|
|
|
|
* negative values are not allowed and truncated.
|
|
|
|
*/
|
|
|
|
static struct timeval tvfix(struct timeval a)
|
|
|
|
{
|
|
|
|
if (a.tv_usec >= ONE_MILLION) {
|
2005-08-23 17:55:59 +00:00
|
|
|
ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
|
2005-09-02 11:39:24 +00:00
|
|
|
a.tv_sec, (long int) a.tv_usec);
|
2005-12-13 16:07:19 +00:00
|
|
|
a.tv_sec += a.tv_usec / ONE_MILLION;
|
2005-07-15 23:00:47 +00:00
|
|
|
a.tv_usec %= ONE_MILLION;
|
|
|
|
} else if (a.tv_usec < 0) {
|
2005-07-19 15:32:03 +00:00
|
|
|
ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
|
2005-12-13 16:07:19 +00:00
|
|
|
a.tv_sec, (long int) a.tv_usec);
|
2005-07-15 23:00:47 +00:00
|
|
|
a.tv_usec = 0;
|
|
|
|
}
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct timeval ast_tvadd(struct timeval a, struct timeval b)
|
|
|
|
{
|
|
|
|
/* consistency checks to guarantee usec in 0..999999 */
|
|
|
|
a = tvfix(a);
|
|
|
|
b = tvfix(b);
|
|
|
|
a.tv_sec += b.tv_sec;
|
|
|
|
a.tv_usec += b.tv_usec;
|
|
|
|
if (a.tv_usec >= ONE_MILLION) {
|
|
|
|
a.tv_sec++;
|
|
|
|
a.tv_usec -= ONE_MILLION;
|
|
|
|
}
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct timeval ast_tvsub(struct timeval a, struct timeval b)
|
|
|
|
{
|
|
|
|
/* consistency checks to guarantee usec in 0..999999 */
|
|
|
|
a = tvfix(a);
|
|
|
|
b = tvfix(b);
|
|
|
|
a.tv_sec -= b.tv_sec;
|
|
|
|
a.tv_usec -= b.tv_usec;
|
|
|
|
if (a.tv_usec < 0) {
|
|
|
|
a.tv_sec-- ;
|
|
|
|
a.tv_usec += ONE_MILLION;
|
|
|
|
}
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
#undef ONE_MILLION
|
|
|
|
|
2005-07-15 22:06:15 +00:00
|
|
|
#ifndef HAVE_STRCASESTR
|
2004-08-27 04:21:09 +00:00
|
|
|
static char *upper(const char *orig, char *buf, int bufsize)
|
|
|
|
{
|
2005-07-15 22:06:15 +00:00
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (i < (bufsize - 1) && orig[i]) {
|
2004-08-27 04:21:09 +00:00
|
|
|
buf[i] = toupper(orig[i]);
|
2005-07-15 22:06:15 +00:00
|
|
|
i++;
|
2004-08-27 04:21:09 +00:00
|
|
|
}
|
2005-07-15 22:06:15 +00:00
|
|
|
|
|
|
|
buf[i] = '\0';
|
|
|
|
|
2004-08-27 04:21:09 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2005-07-15 22:06:15 +00:00
|
|
|
char *strcasestr(const char *haystack, const char *needle)
|
2004-08-27 04:21:09 +00:00
|
|
|
{
|
|
|
|
char *u1, *u2;
|
2004-09-25 22:42:17 +00:00
|
|
|
int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
|
2004-08-27 04:21:09 +00:00
|
|
|
|
|
|
|
u1 = alloca(u1len);
|
|
|
|
u2 = alloca(u2len);
|
|
|
|
if (u1 && u2) {
|
|
|
|
char *offset;
|
|
|
|
if (u2len > u1len) {
|
|
|
|
/* Needle bigger than haystack */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
|
|
|
|
if (offset) {
|
|
|
|
/* Return the offset into the original string */
|
2005-05-27 21:10:06 +00:00
|
|
|
return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
|
2004-08-27 04:21:09 +00:00
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR, "Out of memory\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !HAVE_STRCASESTR */
|
2005-07-15 00:39:01 +00:00
|
|
|
|
2005-07-15 22:06:15 +00:00
|
|
|
#ifndef HAVE_STRNLEN
|
|
|
|
size_t strnlen(const char *s, size_t n)
|
2005-07-15 00:39:01 +00:00
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
for (len=0; len < n; len++)
|
|
|
|
if (s[len] == '\0')
|
|
|
|
break;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !HAVE_STRNLEN */
|
2005-07-15 00:39:01 +00:00
|
|
|
|
2005-09-14 02:30:33 +00:00
|
|
|
#if !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC)
|
2005-07-15 22:06:15 +00:00
|
|
|
char *strndup(const char *s, size_t n)
|
2005-07-15 00:39:01 +00:00
|
|
|
{
|
2005-07-15 22:06:15 +00:00
|
|
|
size_t len = strnlen(s, n);
|
2005-07-15 00:39:01 +00:00
|
|
|
char *new = malloc(len + 1);
|
|
|
|
|
|
|
|
if (!new)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
new[len] = '\0';
|
|
|
|
return memcpy(new, s, len);
|
|
|
|
}
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC) */
|
2005-07-15 00:39:01 +00:00
|
|
|
|
2005-09-14 02:30:33 +00:00
|
|
|
#if !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC)
|
2005-07-15 22:06:15 +00:00
|
|
|
int vasprintf(char **strp, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
int size;
|
|
|
|
va_list ap2;
|
2005-08-03 02:07:25 +00:00
|
|
|
char s;
|
2005-07-15 22:06:15 +00:00
|
|
|
|
|
|
|
*strp = NULL;
|
|
|
|
va_copy(ap2, ap);
|
2005-08-03 02:07:25 +00:00
|
|
|
size = vsnprintf(&s, 1, fmt, ap2);
|
2005-07-15 22:06:15 +00:00
|
|
|
va_end(ap2);
|
|
|
|
*strp = malloc(size + 1);
|
|
|
|
if (!*strp)
|
|
|
|
return -1;
|
|
|
|
vsnprintf(*strp, size + 1, fmt, ap);
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC) */
|
2005-07-20 00:13:15 +00:00
|
|
|
|
|
|
|
#ifndef HAVE_STRTOQ
|
2005-11-01 21:53:30 +00:00
|
|
|
#ifndef LONG_MIN
|
2005-07-20 00:13:15 +00:00
|
|
|
#define LONG_MIN (-9223372036854775807L-1L)
|
2005-08-29 22:39:39 +00:00
|
|
|
/* min value of a "long int" */
|
2005-11-01 21:53:30 +00:00
|
|
|
#endif
|
|
|
|
#ifndef LONG_MAX
|
2005-07-20 00:13:15 +00:00
|
|
|
#define LONG_MAX 9223372036854775807L
|
2005-08-29 22:39:39 +00:00
|
|
|
/* max value of a "long int" */
|
2005-11-01 21:53:30 +00:00
|
|
|
#endif
|
2005-07-20 00:13:15 +00:00
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief
|
2005-07-20 00:13:15 +00:00
|
|
|
* Convert a string to a quad integer.
|
|
|
|
*
|
2006-03-07 17:55:33 +00:00
|
|
|
* \note Ignores `locale' stuff. Assumes that the upper and lower case
|
2005-07-20 00:13:15 +00:00
|
|
|
* alphabets and digits are each contiguous.
|
|
|
|
*/
|
|
|
|
uint64_t strtoq(const char *nptr, char **endptr, int base)
|
|
|
|
{
|
2005-08-29 22:39:39 +00:00
|
|
|
const char *s;
|
|
|
|
uint64_t acc;
|
|
|
|
unsigned char c;
|
|
|
|
uint64_t qbase, cutoff;
|
|
|
|
int neg, any, cutlim;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip white space and pick up leading +/- sign if any.
|
|
|
|
* If base is 0, allow 0x for hex and 0 for octal, else
|
|
|
|
* assume decimal; if base is already 16, allow 0x.
|
|
|
|
*/
|
|
|
|
s = nptr;
|
|
|
|
do {
|
|
|
|
c = *s++;
|
|
|
|
} while (isspace(c));
|
|
|
|
if (c == '-') {
|
|
|
|
neg = 1;
|
|
|
|
c = *s++;
|
|
|
|
} else {
|
|
|
|
neg = 0;
|
|
|
|
if (c == '+')
|
|
|
|
c = *s++;
|
|
|
|
}
|
|
|
|
if ((base == 0 || base == 16) &&
|
|
|
|
c == '\0' && (*s == 'x' || *s == 'X')) {
|
|
|
|
c = s[1];
|
|
|
|
s += 2;
|
|
|
|
base = 16;
|
|
|
|
}
|
|
|
|
if (base == 0)
|
|
|
|
base = c == '\0' ? 8 : 10;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute the cutoff value between legal numbers and illegal
|
|
|
|
* numbers. That is the largest legal value, divided by the
|
|
|
|
* base. An input number that is greater than this value, if
|
|
|
|
* followed by a legal input character, is too big. One that
|
|
|
|
* is equal to this value may be valid or not; the limit
|
|
|
|
* between valid and invalid numbers is then based on the last
|
|
|
|
* digit. For instance, if the range for quads is
|
|
|
|
* [-9223372036854775808..9223372036854775807] and the input base
|
|
|
|
* is 10, cutoff will be set to 922337203685477580 and cutlim to
|
|
|
|
* either 7 (neg==0) or 8 (neg==1), meaning that if we have
|
|
|
|
* accumulated a value > 922337203685477580, or equal but the
|
|
|
|
* next digit is > 7 (or 8), the number is too big, and we will
|
|
|
|
* return a range error.
|
|
|
|
*
|
|
|
|
* Set any if any `digits' consumed; make it negative to indicate
|
|
|
|
* overflow.
|
|
|
|
*/
|
|
|
|
qbase = (unsigned)base;
|
|
|
|
cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
|
|
|
|
cutlim = cutoff % qbase;
|
|
|
|
cutoff /= qbase;
|
|
|
|
for (acc = 0, any = 0;; c = *s++) {
|
|
|
|
if (!isascii(c))
|
|
|
|
break;
|
|
|
|
if (isdigit(c))
|
|
|
|
c -= '\0';
|
|
|
|
else if (isalpha(c))
|
|
|
|
c -= isupper(c) ? 'A' - 10 : 'a' - 10;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
if (c >= base)
|
|
|
|
break;
|
|
|
|
if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
|
|
|
|
any = -1;
|
|
|
|
else {
|
|
|
|
any = 1;
|
|
|
|
acc *= qbase;
|
|
|
|
acc += c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (any < 0) {
|
|
|
|
acc = neg ? LONG_MIN : LONG_MAX;
|
|
|
|
} else if (neg)
|
|
|
|
acc = -acc;
|
|
|
|
if (endptr != 0)
|
|
|
|
*((const char **)endptr) = any ? s - 1 : nptr;
|
|
|
|
return acc;
|
2005-07-20 00:13:15 +00:00
|
|
|
}
|
2005-10-31 21:25:21 +00:00
|
|
|
#endif /* !HAVE_STRTOQ */
|
|
|
|
|
2005-11-08 04:13:19 +00:00
|
|
|
#ifndef HAVE_GETLOADAVG
|
2005-10-31 21:25:21 +00:00
|
|
|
#ifdef linux
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief Alternative method of getting load avg on Linux only */
|
2005-10-31 21:25:21 +00:00
|
|
|
int getloadavg(double *list, int nelem)
|
|
|
|
{
|
|
|
|
FILE *LOADAVG;
|
|
|
|
double avg[3] = { 0.0, 0.0, 0.0 };
|
|
|
|
int i, res = -1;
|
|
|
|
|
|
|
|
if ((LOADAVG = fopen("/proc/loadavg", "r"))) {
|
|
|
|
fscanf(LOADAVG, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]);
|
|
|
|
res = 0;
|
|
|
|
fclose(LOADAVG);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; (i < nelem) && (i < 3); i++) {
|
|
|
|
list[i] = avg[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
#else /* !linux */
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief Return something that won't cancel the call, but still return -1, in case
|
2005-10-31 21:25:21 +00:00
|
|
|
* we correct the implementation to check return value */
|
|
|
|
int getloadavg(double *list, int nelem)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < nelem; i++) {
|
|
|
|
list[i] = 0.1;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif /* linux */
|
2005-11-01 20:26:29 +00:00
|
|
|
#endif /* !defined(_BSD_SOURCE) */
|
2005-09-23 02:57:14 +00:00
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief glibc puts a lock inside random(3), so that the results are thread-safe.
|
2006-01-10 00:55:45 +00:00
|
|
|
* BSD libc (and others) do not. */
|
|
|
|
#ifndef linux
|
2006-01-10 08:33:52 +00:00
|
|
|
|
|
|
|
AST_MUTEX_DEFINE_STATIC(randomlock);
|
|
|
|
|
2006-01-10 00:55:45 +00:00
|
|
|
long int ast_random(void)
|
|
|
|
{
|
|
|
|
long int res;
|
|
|
|
ast_mutex_lock(&randomlock);
|
|
|
|
res = random();
|
|
|
|
ast_mutex_unlock(&randomlock);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-23 02:57:14 +00:00
|
|
|
char *ast_process_quotes_and_slashes(char *start, char find, char replace_with)
|
|
|
|
{
|
|
|
|
char *dataPut = start;
|
|
|
|
int inEscape = 0;
|
|
|
|
int inQuotes = 0;
|
|
|
|
|
|
|
|
for (; *start; start++) {
|
|
|
|
if (inEscape) {
|
|
|
|
*dataPut++ = *start; /* Always goes verbatim */
|
|
|
|
inEscape = 0;
|
|
|
|
} else {
|
|
|
|
if (*start == '\\') {
|
|
|
|
inEscape = 1; /* Do not copy \ into the data */
|
|
|
|
} else if (*start == '\'') {
|
|
|
|
inQuotes = 1-inQuotes; /* Do not copy ' into the data */
|
|
|
|
} else {
|
|
|
|
/* Replace , with |, unless in quotes */
|
|
|
|
*dataPut++ = inQuotes ? *start : ((*start==find) ? replace_with : *start);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (start != dataPut)
|
|
|
|
*dataPut = 0;
|
|
|
|
return dataPut;
|
|
|
|
}
|
2005-12-20 20:20:04 +00:00
|
|
|
|
|
|
|
void ast_join(char *s, size_t len, char * const w[])
|
|
|
|
{
|
|
|
|
int x, ofs = 0;
|
|
|
|
const char *src;
|
|
|
|
|
|
|
|
/* Join words into a string */
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
for (x=0; ofs < len && w[x]; x++) {
|
|
|
|
if (x > 0)
|
|
|
|
s[ofs++] = ' ';
|
|
|
|
for (src = w[x]; *src && ofs < len; src++)
|
|
|
|
s[ofs++] = *src;
|
|
|
|
}
|
|
|
|
if (ofs == len)
|
|
|
|
ofs--;
|
|
|
|
s[ofs] = '\0';
|
|
|
|
}
|
2006-01-04 21:54:09 +00:00
|
|
|
|
2006-02-11 20:54:21 +00:00
|
|
|
const char __ast_string_field_empty[] = "";
|
2006-01-04 21:54:09 +00:00
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
static int add_string_pool(struct ast_string_field_mgr *mgr, size_t size)
|
|
|
|
{
|
|
|
|
struct ast_string_field_pool *pool;
|
|
|
|
|
|
|
|
if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
pool->prev = mgr->pool;
|
|
|
|
mgr->pool = pool;
|
|
|
|
mgr->size = size;
|
|
|
|
mgr->space = size;
|
|
|
|
mgr->used = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __ast_string_field_init(struct ast_string_field_mgr *mgr, size_t size,
|
2006-01-04 21:54:09 +00:00
|
|
|
ast_string_field *fields, int num_fields)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
if (add_string_pool(mgr, size))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (index = 0; index < num_fields; index++)
|
|
|
|
fields[index] = __ast_string_field_empty;
|
|
|
|
|
|
|
|
return 0;
|
2006-01-04 21:54:09 +00:00
|
|
|
}
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr, size_t needed,
|
2006-01-06 19:19:17 +00:00
|
|
|
ast_string_field *fields, int num_fields)
|
2006-01-04 21:54:09 +00:00
|
|
|
{
|
|
|
|
char *result = NULL;
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
if (__builtin_expect(needed > mgr->space, 0)) {
|
|
|
|
size_t new_size = mgr->size * 2;
|
2006-01-04 21:54:09 +00:00
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
while (new_size < needed)
|
2006-01-04 21:54:09 +00:00
|
|
|
new_size *= 2;
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
if (add_string_pool(mgr, new_size))
|
2006-01-04 21:54:09 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
result = mgr->pool->base + mgr->used;
|
|
|
|
mgr->used += needed;
|
|
|
|
mgr->space -= needed;
|
2006-01-04 21:54:09 +00:00
|
|
|
return result;
|
|
|
|
}
|
2006-01-06 19:19:17 +00:00
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
void __ast_string_field_index_build(struct ast_string_field_mgr *mgr,
|
2006-01-06 19:19:17 +00:00
|
|
|
ast_string_field *fields, int num_fields,
|
|
|
|
int index, const char *format, ...)
|
|
|
|
{
|
|
|
|
size_t needed;
|
|
|
|
va_list ap1, ap2;
|
|
|
|
|
|
|
|
va_start(ap1, format);
|
2006-03-06 10:49:15 +00:00
|
|
|
va_start(ap2, format); /* va_copy does not exist on FreeBSD */
|
2006-01-06 19:19:17 +00:00
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
needed = vsnprintf(mgr->pool->base + mgr->used, mgr->space, format, ap1) + 1;
|
2006-01-06 19:19:17 +00:00
|
|
|
|
|
|
|
va_end(ap1);
|
|
|
|
|
2006-01-26 04:00:05 +00:00
|
|
|
if (needed > mgr->space) {
|
|
|
|
size_t new_size = mgr->size * 2;
|
|
|
|
|
|
|
|
while (new_size < needed)
|
|
|
|
new_size *= 2;
|
|
|
|
|
|
|
|
if (add_string_pool(mgr, new_size))
|
|
|
|
return;
|
|
|
|
|
|
|
|
vsprintf(mgr->pool->base + mgr->used, format, ap2);
|
|
|
|
}
|
|
|
|
|
|
|
|
fields[index] = mgr->pool->base + mgr->used;
|
|
|
|
mgr->used += needed;
|
|
|
|
mgr->space -= needed;
|
2006-01-06 19:19:17 +00:00
|
|
|
|
|
|
|
va_end(ap2);
|
|
|
|
}
|
2006-02-15 00:24:24 +00:00
|
|
|
|
|
|
|
|
2006-03-07 17:55:33 +00:00
|
|
|
/*! \brief
|
2006-02-15 00:24:24 +00:00
|
|
|
* get values from config variables.
|
|
|
|
*/
|
2006-02-23 17:13:57 +00:00
|
|
|
int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
|
2006-02-15 00:24:24 +00:00
|
|
|
{
|
|
|
|
long t;
|
2006-02-23 17:13:57 +00:00
|
|
|
int scanned;
|
2006-02-15 00:24:24 +00:00
|
|
|
|
|
|
|
if (dst == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
*dst = _default;
|
|
|
|
|
|
|
|
if (ast_strlen_zero(src))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* only integer at the moment, but one day we could accept more formats */
|
2006-02-23 17:13:57 +00:00
|
|
|
if (sscanf(src, "%ld%n", &t, &scanned) == 1) {
|
2006-02-15 00:24:24 +00:00
|
|
|
*dst = t;
|
2006-02-23 17:13:57 +00:00
|
|
|
if (consumed)
|
|
|
|
*consumed = scanned;
|
2006-02-15 00:24:24 +00:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -1;
|
|
|
|
}
|