Wed Aug 18 22:34:34 2010

Asterisk developer's documentation


utils.c File Reference

Utility functions. More...

#include "asterisk.h"
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "asterisk/network.h"
#include "asterisk/lock.h"
#include "asterisk/io.h"
#include "asterisk/md5.h"
#include "asterisk/sha1.h"
#include "asterisk/cli.h"
#include "asterisk/linkedlists.h"
#include "asterisk/strings.h"
#include "asterisk/time.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/config.h"

Go to the source code of this file.

Data Structures

struct  thr_arg

Defines

#define AST_API_MODULE
#define AST_API_MODULE
#define AST_API_MODULE
#define AST_API_MODULE
#define AST_API_MODULE
#define AST_API_MODULE
#define AST_API_MODULE
#define ONE_MILLION   1000000

Functions

int __ast_str_helper (struct ast_str **buf, ssize_t max_len, int append, const char *fmt, va_list ap)
 Core functionality of ast_str_(set|append)_va.
ast_string_field __ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed)
int __ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func)
void __ast_string_field_ptr_build (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...)
void __ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap1, va_list ap2)
int __ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, size_t needed, const ast_string_field *ptr)
static void __init_inet_ntoa_buf (void)
int _ast_asprintf (char **ret, const char *file, int lineno, const char *func, const char *fmt,...)
static int add_string_pool (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t size, const char *file, int lineno, const char *func)
 add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only.
int ast_atomic_fetchadd_int_slow (volatile int *p, int v)
int ast_base64decode (unsigned char *dst, const char *src, int max)
 Decode data from base64.
int ast_base64encode (char *dst, const unsigned char *src, int srclen, int max)
 Encode data in base64.
int ast_base64encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
 encode text to BASE64 coding
int ast_build_string (char **buffer, size_t *space, const char *fmt,...)
 Build a string in a buffer, designed to be called repeatedly.
int ast_build_string_va (char **buffer, size_t *space, const char *fmt, va_list ap)
 Build a string in a buffer, designed to be called repeatedly.
int ast_careful_fwrite (FILE *f, int fd, const char *src, size_t len, int timeoutms)
 Write data to a file stream with a timeout.
int ast_carefulwrite (int fd, char *s, int len, int timeoutms)
 Try to write string, but wait no more than ms milliseconds before timing out.
void ast_enable_packet_fragmentation (int sock)
 Disable PMTU discovery on a socket.
int ast_false (const char *s)
 Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0".
int ast_get_time_t (const char *src, time_t *dst, time_t _default, int *consumed)
 get values from config variables.
int ast_get_timeval (const char *src, struct timeval *dst, struct timeval _default, int *consumed)
 get values from config variables.
hostent * ast_gethostbyname (const char *host, struct ast_hostent *hp)
 Thread-safe gethostbyname function to use in Asterisk.
const char * ast_inet_ntoa (struct in_addr ia)
 thread-safe replacement for inet_ntoa().
void ast_join (char *s, size_t len, char *const w[])
void ast_md5_hash (char *output, char *input)
 Produces MD5 hash based on input string.
int ast_mkdir (const char *path, int mode)
 Recursively create directory path.
char * ast_process_quotes_and_slashes (char *start, char find, char replace_with)
 Process a string to find and replace characters.
int ast_pthread_create_detached_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn)
int ast_pthread_create_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn)
long int ast_random (void)
void ast_sha1_hash (char *output, char *input)
 Produces SHA1 hash based on input string.
char * ast_strip_quoted (char *s, const char *beg_quotes, const char *end_quotes)
 Strip leading/trailing whitespace and quotes from a string.
int ast_true (const char *s)
 Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1".
timeval ast_tvadd (struct timeval a, struct timeval b)
 Returns the sum of two timevals a + b.
timeval ast_tvsub (struct timeval a, struct timeval b)
 Returns the difference of two timevals a - b.
char * ast_unescape_c (char *src)
 Convert some C escape sequences.
char * ast_unescape_semicolon (char *s)
 Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).
void ast_uri_decode (char *s)
 Decode URI, URN, URL (overwrite string).
char * ast_uri_encode (const char *string, char *outbuf, int buflen, int doreserved)
 Turn text string to URI-encoded XX version.
int ast_utils_init (void)
int ast_wait_for_input (int fd, int ms)
static int ast_wait_for_output (int fd, int timeoutms)
static void base64_init (void)
static void * dummy_start (void *data)
static struct timeval tvfix (struct timeval a)

Variables

const char __ast_string_field_empty [] = ""
static char b2a [256]
static char base64 [64]
static int dev_urandom_fd
static ast_mutex_t fetchadd_m = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP )
static struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , }
static ast_mutex_t randomlock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP )
 glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not.


Detailed Description

Utility functions.

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.

Definition in file utils.c.


Define Documentation

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define AST_API_MODULE

Definition at line 62 of file utils.c.

#define ONE_MILLION   1000000

Definition at line 1345 of file utils.c.

Referenced by ast_tvadd(), ast_tvsub(), and tvfix().


Function Documentation

int __ast_str_helper ( struct ast_str **  buf,
ssize_t  max_len,
int  append,
const char *  fmt,
va_list  ap 
)

Core functionality of ast_str_(set|append)_va.

core handler for dynamic strings. This is not meant to be called directly, but rather through the various wrapper macros ast_str_set(...) ast_str_append(...) ast_str_set_va(...) ast_str_append_va(...)

Definition at line 1765 of file utils.c.

References AST_DYNSTR_BUILD_FAILED, ast_str_make_space(), ast_verbose, and buf.

Referenced by ast_str_set_va().

01767 {
01768    int res, need;
01769    int offset = (append && (*buf)->len) ? (*buf)->used : 0;
01770    va_list aq;
01771 
01772    do {
01773       if (max_len < 0) {
01774          max_len = (*buf)->len;  /* don't exceed the allocated space */
01775       }
01776       /*
01777        * Ask vsnprintf how much space we need. Remember that vsnprintf
01778        * does not count the final '\0' so we must add 1.
01779        */
01780       va_copy(aq, ap);
01781       res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, aq);
01782 
01783       need = res + offset + 1;
01784       /*
01785        * If there is not enough space and we are below the max length,
01786        * reallocate the buffer and return a message telling to retry.
01787        */
01788       if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
01789          if (max_len && max_len < need) { /* truncate as needed */
01790             need = max_len;
01791          } else if (max_len == 0) { /* if unbounded, give more room for next time */
01792             need += 16 + need / 4;
01793          }
01794          if (0) { /* debugging */
01795             ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need);
01796          }
01797          if (ast_str_make_space(buf, need)) {
01798             ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need);
01799             va_end(aq);
01800             return AST_DYNSTR_BUILD_FAILED;
01801          }
01802          (*buf)->str[offset] = '\0';   /* Truncate the partial write. */
01803 
01804          /* Restart va_copy before calling vsnprintf() again. */
01805          va_end(aq);
01806          continue;
01807       }
01808       va_end(aq);
01809       break;
01810    } while (1);
01811    /* update space used, keep in mind the truncation */
01812    (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len - 1 : res + offset;
01813 
01814    return res;
01815 }

ast_string_field __ast_string_field_alloc_space ( struct ast_string_field_mgr mgr,
struct ast_string_field_pool **  pool_head,
size_t  needed 
)

Definition at line 1568 of file utils.c.

References add_string_pool(), ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.

01570 {
01571    char *result = NULL;
01572    size_t space = mgr->size - mgr->used;
01573 
01574    if (__builtin_expect(needed > space, 0)) {
01575       size_t new_size = mgr->size * 2;
01576 
01577       while (new_size < needed)
01578          new_size *= 2;
01579 
01580 #if defined(__AST_DEBUG_MALLOC)
01581       if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
01582          return NULL;
01583 #else
01584       if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__))
01585          return NULL;
01586 #endif
01587    }
01588 
01589    result = (*pool_head)->base + mgr->used;
01590    mgr->used += needed;
01591    mgr->last_alloc = result;
01592    return result;
01593 }

int __ast_string_field_init ( struct ast_string_field_mgr mgr,
struct ast_string_field_pool **  pool_head,
int  needed,
const char *  file,
int  lineno,
const char *  func 
)

Definition at line 1514 of file utils.c.

References add_string_pool(), ast_free, ast_log(), ast_string_field_mgr::last_alloc, LOG_WARNING, ast_string_field_pool::prev, and ast_string_field_mgr::used.

01516 {
01517    const char **p = (const char **) pool_head + 1;
01518    struct ast_string_field_pool *cur = NULL;
01519    struct ast_string_field_pool *preserve = NULL;
01520 
01521    /* clear fields - this is always necessary */
01522    while ((struct ast_string_field_mgr *) p != mgr)
01523       *p++ = __ast_string_field_empty;
01524    mgr->last_alloc = NULL;
01525 #if defined(__AST_DEBUG_MALLOC)
01526    mgr->owner_file = file;
01527    mgr->owner_func = func;
01528    mgr->owner_line = lineno;
01529 #endif
01530    if (needed > 0) {    /* allocate the initial pool */
01531       *pool_head = NULL;
01532       return add_string_pool(mgr, pool_head, needed, file, lineno, func);
01533    }
01534    if (needed < 0) {    /* reset all pools */
01535       if (*pool_head == NULL) {
01536          ast_log(LOG_WARNING, "trying to reset empty pool\n");
01537          return -1;
01538       }
01539       cur = *pool_head;
01540    } else {       /* preserve the last pool */
01541       if (*pool_head == NULL) {
01542          ast_log(LOG_WARNING, "trying to reset empty pool\n");
01543          return -1;
01544       }
01545       mgr->used = 0;
01546       preserve = *pool_head;
01547       cur = preserve->prev;
01548    }
01549 
01550    if (preserve) {
01551       preserve->prev = NULL;
01552    }
01553 
01554    while (cur) {
01555       struct ast_string_field_pool *prev = cur->prev;
01556 
01557       if (cur != preserve) {
01558          ast_free(cur);
01559       }
01560       cur = prev;
01561    }
01562 
01563    *pool_head = preserve;
01564 
01565    return 0;
01566 }

void __ast_string_field_ptr_build ( struct ast_string_field_mgr mgr,
struct ast_string_field_pool **  pool_head,
ast_string_field ptr,
const char *  format,
  ... 
)

Definition at line 1674 of file utils.c.

References __ast_string_field_ptr_build_va().

01677 {
01678    va_list ap1, ap2;
01679 
01680    va_start(ap1, format);
01681    va_start(ap2, format);     /* va_copy does not exist on FreeBSD */
01682 
01683    __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2);
01684 
01685    va_end(ap1);
01686    va_end(ap2);
01687 }

void __ast_string_field_ptr_build_va ( struct ast_string_field_mgr mgr,
struct ast_string_field_pool **  pool_head,
ast_string_field ptr,
const char *  format,
va_list  ap1,
va_list  ap2 
)

Definition at line 1618 of file utils.c.

References add_string_pool(), available(), ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.

Referenced by __ast_string_field_ptr_build().

01621 {
01622    size_t needed;
01623    size_t available;
01624    size_t space = mgr->size - mgr->used;
01625    char *target;
01626 
01627    /* if the field already has space allocated, try to reuse it;
01628       otherwise, use the empty space at the end of the current
01629       pool
01630    */
01631    if ((*ptr)[0] != '\0') {
01632       target = (char *) *ptr;
01633       available = strlen(target) + 1;
01634    } else {
01635       target = (*pool_head)->base + mgr->used;
01636       available = space;
01637    }
01638 
01639    needed = vsnprintf(target, available, format, ap1) + 1;
01640 
01641    va_end(ap1);
01642 
01643    if (needed > available) {
01644       /* if the space needed can be satisfied by using the current
01645          pool (which could only occur if we tried to use the field's
01646          allocated space and failed), then use that space; otherwise
01647          allocate a new pool
01648       */
01649       if (needed > space) {
01650          size_t new_size = mgr->size * 2;
01651 
01652          while (new_size < needed)
01653             new_size *= 2;
01654          
01655 #if defined(__AST_DEBUG_MALLOC)
01656          if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
01657             return;
01658 #else
01659          if (add_string_pool(mgr, pool_head, new_size, NULL, 0, NULL))
01660             return;
01661 #endif
01662       }
01663 
01664       target = (*pool_head)->base + mgr->used;
01665       vsprintf(target, format, ap2);
01666    }
01667 
01668    if (*ptr != target) {
01669       mgr->last_alloc = *ptr = target;
01670       mgr->used += needed;
01671    }
01672 }

int __ast_string_field_ptr_grow ( struct ast_string_field_mgr mgr,
size_t  needed,
const ast_string_field ptr 
)

Definition at line 1595 of file utils.c.

References ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.

01597 {
01598    int grow = needed - (strlen(*ptr) + 1);
01599    size_t space = mgr->size - mgr->used;
01600 
01601    if (grow <= 0) {
01602       return 0;
01603    }
01604 
01605    if (*ptr != mgr->last_alloc) {
01606       return 1;
01607    }
01608 
01609    if (space < grow) {
01610       return 1;
01611    }
01612 
01613    mgr->used += grow;
01614 
01615    return 0;
01616 }

static void __init_inet_ntoa_buf ( void   )  [static]

Definition at line 68 of file utils.c.

00085 {

int _ast_asprintf ( char **  ret,
const char *  file,
int  lineno,
const char *  func,
const char *  fmt,
  ... 
)

Definition at line 1877 of file utils.c.

References MALLOC_FAILURE_MSG, and vasprintf.

01878 {
01879    int res;
01880    va_list ap;
01881 
01882    va_start(ap, fmt);
01883    if ((res = vasprintf(ret, fmt, ap)) == -1) {
01884       MALLOC_FAILURE_MSG;
01885    }
01886    va_end(ap);
01887 
01888    return res;
01889 }

static int add_string_pool ( struct ast_string_field_mgr mgr,
struct ast_string_field_pool **  pool_head,
size_t  size,
const char *  file,
int  lineno,
const char *  func 
) [static]

add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only.

Definition at line 1480 of file utils.c.

References __ast_calloc(), ast_calloc, ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.

Referenced by __ast_string_field_alloc_space(), __ast_string_field_init(), and __ast_string_field_ptr_build_va().

01482 {
01483    struct ast_string_field_pool *pool;
01484 
01485 #if defined(__AST_DEBUG_MALLOC)
01486    if (!(pool = __ast_calloc(1, sizeof(*pool) + size, file, lineno, func))) {
01487       return -1;
01488    }
01489 #else
01490    if (!(pool = ast_calloc(1, sizeof(*pool) + size))) {
01491       return -1;
01492    }
01493 #endif
01494 
01495    pool->prev = *pool_head;
01496    *pool_head = pool;
01497    mgr->size = size;
01498    mgr->used = 0;
01499    mgr->last_alloc = NULL;
01500 
01501    return 0;
01502 }

int ast_atomic_fetchadd_int_slow ( volatile int *  p,
int  v 
)

Definition at line 1692 of file utils.c.

References ast_mutex_lock(), ast_mutex_unlock(), and fetchadd_m.

01693 {
01694    int ret;
01695    ast_mutex_lock(&fetchadd_m);
01696    ret = *p;
01697    *p += v;
01698    ast_mutex_unlock(&fetchadd_m);
01699    return ret;
01700 }

int ast_base64decode ( unsigned char *  dst,
const char *  src,
int  max 
)

Decode data from base64.

Parameters:
dst the destination buffer
src the source buffer
max The maximum number of bytes to write into the destination buffer. Note that this function will not ensure that the destination buffer is NULL terminated. So, in general, this parameter should be sizeof(dst) - 1.

Definition at line 264 of file utils.c.

Referenced by __ast_check_signature(), base64_decode(), and osp_validate_token().

00265 {
00266    int cnt = 0;
00267    unsigned int byte = 0;
00268    unsigned int bits = 0;
00269    int incnt = 0;
00270    while(*src && *src != '=' && (cnt < max)) {
00271       /* Shift in 6 bits of input */
00272       byte <<= 6;
00273       byte |= (b2a[(int)(*src)]) & 0x3f;
00274       bits += 6;
00275       src++;
00276       incnt++;
00277       /* If we have at least 8 bits left over, take that character 
00278          off the top */
00279       if (bits >= 8)  {
00280          bits -= 8;
00281          *dst = (byte >> bits) & 0xff;
00282          dst++;
00283          cnt++;
00284       }
00285    }
00286    /* Dont worry about left over bits, they're extra anyway */
00287    return cnt;
00288 }

int ast_base64encode ( char *  dst,
const unsigned char *  src,
int  srclen,
int  max 
)

Encode data in base64.

Parameters:
dst the destination buffer
src the source data to be encoded
srclen the number of bytes present in the source buffer
max the maximum number of bytes to write into the destination buffer, *including* the terminating NULL character.

Definition at line 342 of file utils.c.

References ast_base64encode_full().

Referenced by __ast_sign(), aji_start_sasl(), base64_encode(), build_secret(), and osp_check_destination().

00343 {
00344    return ast_base64encode_full(dst, src, srclen, max, 0);
00345 }

int ast_base64encode_full ( char *  dst,
const unsigned char *  src,
int  srclen,
int  max,
int  linebreaks 
)

encode text to BASE64 coding

Definition at line 291 of file utils.c.

Referenced by ast_base64encode().

00292 {
00293    int cnt = 0;
00294    int col = 0;
00295    unsigned int byte = 0;
00296    int bits = 0;
00297    int cntin = 0;
00298    /* Reserve space for null byte at end of string */
00299    max--;
00300    while ((cntin < srclen) && (cnt < max)) {
00301       byte <<= 8;
00302       byte |= *(src++);
00303       bits += 8;
00304       cntin++;
00305       if ((bits == 24) && (cnt + 4 <= max)) {
00306          *dst++ = base64[(byte >> 18) & 0x3f];
00307          *dst++ = base64[(byte >> 12) & 0x3f];
00308          *dst++ = base64[(byte >> 6) & 0x3f];
00309          *dst++ = base64[byte & 0x3f];
00310          cnt += 4;
00311          col += 4;
00312          bits = 0;
00313          byte = 0;
00314       }
00315       if (linebreaks && (cnt < max) && (col == 64)) {
00316          *dst++ = '\n';
00317          cnt++;
00318          col = 0;
00319       }
00320    }
00321    if (bits && (cnt + 4 <= max)) {
00322       /* Add one last character for the remaining bits, 
00323          padding the rest with 0 */
00324       byte <<= 24 - bits;
00325       *dst++ = base64[(byte >> 18) & 0x3f];
00326       *dst++ = base64[(byte >> 12) & 0x3f];
00327       if (bits == 16)
00328          *dst++ = base64[(byte >> 6) & 0x3f];
00329       else
00330          *dst++ = '=';
00331       *dst++ = '=';
00332       cnt += 4;
00333    }
00334    if (linebreaks && (cnt < max)) {
00335       *dst++ = '\n';
00336       cnt++;
00337    }
00338    *dst = '\0';
00339    return cnt;
00340 }

int ast_build_string ( char **  buffer,
size_t *  space,
const char *  fmt,
  ... 
)

Build a string in a buffer, designed to be called repeatedly.

Note:
This method is not recommended. New code should use ast_str_*() instead.
This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.

Parameters:
buffer current position in buffer to place string into (will be updated on return)
space remaining space in buffer (will be updated on return)
fmt printf-style format string
Return values:
0 on success
non-zero on failure.

Definition at line 1299 of file utils.c.

References ast_build_string_va().

Referenced by config_odbc(), config_pgsql(), handle_speechrecognize(), lua_func_read(), lua_pbx_exec(), pp_each_extension_exec(), and pp_each_user_exec().

01300 {
01301    va_list ap;
01302    int result;
01303 
01304    va_start(ap, fmt);
01305    result = ast_build_string_va(buffer, space, fmt, ap);
01306    va_end(ap);
01307 
01308    return result;
01309 }

int ast_build_string_va ( char **  buffer,
size_t *  space,
const char *  fmt,
va_list  ap 
)

Build a string in a buffer, designed to be called repeatedly.

This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.

Returns:
0 on success, non-zero on failure.
Parameters:
buffer current position in buffer to place string into (will be updated on return)
space remaining space in buffer (will be updated on return)
fmt printf-style format string
ap varargs list of arguments for format

Definition at line 1280 of file utils.c.

Referenced by ast_build_string().

01281 {
01282    int result;
01283 
01284    if (!buffer || !*buffer || !space || !*space)
01285       return -1;
01286 
01287    result = vsnprintf(*buffer, *space, fmt, ap);
01288 
01289    if (result < 0)
01290       return -1;
01291    else if (result > *space)
01292       result = *space;
01293 
01294    *buffer += result;
01295    *space -= result;
01296    return 0;
01297 }

int ast_careful_fwrite ( FILE *  f,
int  fd,
const char *  s,
size_t  len,
int  timeoutms 
)

Write data to a file stream with a timeout.

Parameters:
f the file stream to write to
fd the file description to poll on to know when the file stream can be written to without blocking.
s the buffer to write from
len the number of bytes to write
timeoutms The maximum amount of time to block in this function trying to write, specified in milliseconds.
Note:
This function assumes that the associated file stream has been set up as non-blocking.
Return values:
0 success
-1 error

Definition at line 1154 of file utils.c.

References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, fwrite, and LOG_ERROR.

Referenced by send_string().

01155 {
01156    struct timeval start = ast_tvnow();
01157    int n = 0;
01158    int elapsed = 0;
01159 
01160    while (len) {
01161       if (ast_wait_for_output(fd, timeoutms - elapsed)) {
01162          /* poll returned a fatal error, so bail out immediately. */
01163          return -1;
01164       }
01165 
01166       /* Clear any errors from a previous write */
01167       clearerr(f);
01168 
01169       n = fwrite(src, 1, len, f);
01170 
01171       if (ferror(f) && errno != EINTR && errno != EAGAIN) {
01172          /* fatal error from fwrite() */
01173          if (!feof(f)) {
01174             /* Don't spam the logs if it was just that the connection is closed. */
01175             ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
01176          }
01177          n = -1;
01178          break;
01179       }
01180 
01181       /* Update for data already written to the socket */
01182       len -= n;
01183       src += n;
01184 
01185       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01186       if (elapsed >= timeoutms) {
01187          /* We've taken too long to write 
01188           * This is only an error condition if we haven't finished writing. */
01189          n = len ? -1 : 0;
01190          break;
01191       }
01192    }
01193 
01194    while (fflush(f)) {
01195       if (errno == EAGAIN || errno == EINTR) {
01196          continue;
01197       }
01198       if (!feof(f)) {
01199          /* Don't spam the logs if it was just that the connection is closed. */
01200          ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
01201       }
01202       n = -1;
01203       break;
01204    }
01205 
01206    return n < 0 ? -1 : 0;
01207 }

int ast_carefulwrite ( int  fd,
char *  s,
int  len,
int  timeoutms 
)

Try to write string, but wait no more than ms milliseconds before timing out.

Try to write string, but wait no more than ms milliseconds before timing out.

Note:
The code assumes that the file descriptor has NONBLOCK set, so there is only one system call made to do a write, unless we actually have a need to wait. This way, we get better performance. If the descriptor is blocking, all assumptions on the guaranteed detail do not apply anymore.

Definition at line 1113 of file utils.c.

References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, and LOG_ERROR.

Referenced by ast_agi_send(), and ast_cli().

01114 {
01115    struct timeval start = ast_tvnow();
01116    int res = 0;
01117    int elapsed = 0;
01118 
01119    while (len) {
01120       if (ast_wait_for_output(fd, timeoutms - elapsed)) {
01121          return -1;
01122       }
01123 
01124       res = write(fd, s, len);
01125 
01126       if (res < 0 && errno != EAGAIN && errno != EINTR) {
01127          /* fatal error from write() */
01128          ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
01129          return -1;
01130       }
01131 
01132       if (res < 0) {
01133          /* It was an acceptable error */
01134          res = 0;
01135       }
01136 
01137       /* Update how much data we have left to write */
01138       len -= res;
01139       s += res;
01140       res = 0;
01141 
01142       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01143       if (elapsed >= timeoutms) {
01144          /* We've taken too long to write 
01145           * This is only an error condition if we haven't finished writing. */
01146          res = len ? -1 : 0;
01147          break;
01148       }
01149    }
01150 
01151    return res;
01152 }

void ast_enable_packet_fragmentation ( int  sock  ) 

Disable PMTU discovery on a socket.

Parameters:
sock The socket to manipulate
Returns:
Nothing
On Linux, UDP sockets default to sending packets with the Dont Fragment (DF) bit set. This is supposedly done to allow the application to do PMTU discovery, but Asterisk does not do this.

Because of this, UDP packets sent by Asterisk that are larger than the MTU of any hop in the path will be lost. This function can be called on a socket to ensure that the DF bit will not be set.

Definition at line 1817 of file utils.c.

References ast_log(), and LOG_WARNING.

Referenced by ast_netsock_bindaddr().

01818 {
01819 #if defined(HAVE_IP_MTU_DISCOVER)
01820    int val = IP_PMTUDISC_DONT;
01821    
01822    if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
01823       ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
01824 #endif /* HAVE_IP_MTU_DISCOVER */
01825 }

int ast_false ( const char *  val  ) 

Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0".

Return values:
0 if val is a NULL pointer.
-1 if "true".
0 otherwise.

Definition at line 1328 of file utils.c.

References ast_strlen_zero().

Referenced by __ast_rtp_reload(), __ast_udptl_reload(), aji_create_client(), aji_load_config(), build_peer(), build_user(), dahdi_set_dnd(), func_channel_write(), handle_common_options(), init_acf_query(), load_config(), load_odbc_config(), run_agi(), set_config(), set_insecure_flags(), and strings_to_mask().

01329 {
01330    if (ast_strlen_zero(s))
01331       return 0;
01332 
01333    /* Determine if this is a false value */
01334    if (!strcasecmp(s, "no") ||
01335        !strcasecmp(s, "false") ||
01336        !strcasecmp(s, "n") ||
01337        !strcasecmp(s, "f") ||
01338        !strcasecmp(s, "0") ||
01339        !strcasecmp(s, "off"))
01340       return -1;
01341 
01342    return 0;
01343 }

int ast_get_time_t ( const char *  src,
time_t *  dst,
time_t  _default,
int *  consumed 
)

get values from config variables.

Definition at line 1732 of file utils.c.

References ast_strlen_zero().

Referenced by build_peer(), cache_lookup_internal(), handle_saydatetime(), load_password(), play_message_datetime(), process_clearcache(), and sayunixtime_exec().

01733 {
01734    long t;
01735    int scanned;
01736 
01737    if (dst == NULL)
01738       return -1;
01739 
01740    *dst = _default;
01741 
01742    if (ast_strlen_zero(src))
01743       return -1;
01744 
01745    /* only integer at the moment, but one day we could accept more formats */
01746    if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
01747       *dst = t;
01748       if (consumed)
01749          *consumed = scanned;
01750       return 0;
01751    } else
01752       return -1;
01753 }

int ast_get_timeval ( const char *  src,
struct timeval *  dst,
struct timeval  _default,
int *  consumed 
)

get values from config variables.

Definition at line 1705 of file utils.c.

References ast_strlen_zero().

Referenced by acf_strftime().

01706 {
01707    long double dtv = 0.0;
01708    int scanned;
01709 
01710    if (dst == NULL)
01711       return -1;
01712 
01713    *dst = _default;
01714 
01715    if (ast_strlen_zero(src))
01716       return -1;
01717 
01718    /* only integer at the moment, but one day we could accept more formats */
01719    if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
01720       dst->tv_sec = dtv;
01721       dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
01722       if (consumed)
01723          *consumed = scanned;
01724       return 0;
01725    } else
01726       return -1;
01727 }

struct hostent* ast_gethostbyname ( const char *  host,
struct ast_hostent hp 
)

Thread-safe gethostbyname function to use in Asterisk.

Definition at line 182 of file utils.c.

References hp, and s.

Referenced by __init_manager(), __set_address_from_contact(), ast_find_ourip(), ast_get_ip_or_srv(), ast_parse_arg(), check_via(), create_addr(), festival_exec(), get_ip_and_port_from_sdp(), gtalk_load_config(), gtalk_update_stun(), handle_cli_udptl_debug_deprecated(), handle_cli_udptl_set_debug(), iax_template_parse(), jingle_load_config(), jingle_update_stun(), launch_netscript(), parse_register_contact(), process_sdp(), process_sdp_c(), realtime_peer(), realtime_user(), reload_config(), rpt_exec(), rtcp_do_debug_ip(), rtp_do_debug_ip(), set_config(), set_destination(), and sip_do_debug_ip().

00183 {
00184    int res;
00185    int herrno;
00186    int dots = 0;
00187    const char *s;
00188    struct hostent *result = NULL;
00189    /* Although it is perfectly legitimate to lookup a pure integer, for
00190       the sake of the sanity of people who like to name their peers as
00191       integers, we break with tradition and refuse to look up a
00192       pure integer */
00193    s = host;
00194    res = 0;
00195    while (s && *s) {
00196       if (*s == '.')
00197          dots++;
00198       else if (!isdigit(*s))
00199          break;
00200       s++;
00201    }
00202    if (!s || !*s) {
00203       /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
00204       if (dots != 3)
00205          return NULL;
00206       memset(hp, 0, sizeof(struct ast_hostent));
00207       hp->hp.h_addrtype = AF_INET;
00208       hp->hp.h_addr_list = (void *) hp->buf;
00209       hp->hp.h_addr = hp->buf + sizeof(void *);
00210       if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
00211          return &hp->hp;
00212       return NULL;
00213       
00214    }
00215 #ifdef HAVE_GETHOSTBYNAME_R_5
00216    result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
00217 
00218    if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
00219       return NULL;
00220 #else
00221    res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
00222 
00223    if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
00224       return NULL;
00225 #endif
00226    return &hp->hp;
00227 }

const char* ast_inet_ntoa ( struct in_addr  ia  ) 

thread-safe replacement for inet_ntoa().

Note:
It is very important to note that even though this is a thread-safe replacement for inet_ntoa(), it is *not* reentrant. In a single thread, the result from a previous call to this function is no longer valid once it is called again. If the result from multiple calls to this function need to be kept or used at once, then the result must be copied to a local buffer before calling this function again.

Definition at line 431 of file utils.c.

References ast_threadstorage_get(), and inet_ntoa_buf.

Referenced by __attempt_transmit(), __find_callno(), __iax2_show_peers(), __sip_xmit(), _sip_show_peer(), _sip_show_peers(), acf_channel_read(), action_login(), add_sdp(), ast_append_ha(), ast_apply_ha(), ast_netsock_bindaddr(), ast_parse_arg(), ast_rtcp_read(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_raw_write(), ast_rtp_read(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_senddigit_continuation(), ast_rtp_senddigit_end(), ast_sip_ouraddrfor(), ast_tcptls_client_create(), ast_tcptls_client_start(), ast_tcptls_server_start(), ast_udptl_bridge(), ast_udptl_read(), ast_udptl_write(), authenticate(), bridge_native_loop(), bridge_p2p_rtp_write(), build_callid_pvt(), build_callid_registry(), build_contact(), build_peer(), build_reply_digest(), build_rpid(), build_via(), calltoken_required(), check_access(), check_peer_ok(), check_via(), copy_via_headers(), create_addr_from_peer(), create_client(), create_dtmf_frame(), dnsmgr_refresh(), dump_addr(), dump_ipaddr(), dundi_rexmit(), dundi_show_peer(), dundi_show_peers(), dundi_show_trans(), dundi_showframe(), dundi_xmit(), external_rtp_create(), find_command(), find_peer(), find_subchannel_and_lock(), find_tpeer(), function_iaxpeer(), function_sipchaninfo_read(), function_sippeer(), get_input(), gtalk_create_candidates(), gtalk_update_stun(), handle_call_token(), handle_cli_iax2_set_debug(), handle_cli_iax2_show_callno_limits(), handle_cli_iax2_show_channels(), handle_cli_iax2_show_peer(), handle_cli_iax2_show_registry(), handle_cli_udptl_debug_deprecated(), handle_cli_udptl_set_debug(), handle_command_response(), handle_error(), handle_incoming(), handle_mgcp_show_endpoints(), handle_open_receive_channel_ack_message(), handle_request(), handle_request_bye(), handle_request_do(), handle_request_register(), handle_request_subscribe(), handle_response(), handle_response_notify(), handle_response_refer(), handle_show_http(), handle_showmanconn(), handle_skinny_show_device(), handle_skinny_show_devices(), handle_skinny_show_settings(), httpstatus_callback(), iax2_ack_registry(), iax2_prov_app(), iax2_trunk_queue(), iax_server(), iax_showframe(), initreqprep(), jingle_create_candidates(), load_module(), manager_iax2_show_peer_list(), mgcpsock_read(), oh323_addrcmp_str(), oh323_call(), oh323_set_rtp_peer(), parse_register_contact(), parsing(), peercnt_add(), peercnt_modify(), peercnt_remove(), phoneprov_callback(), process_request(), process_rfc3389(), process_sdp(), purge_sessions(), raw_hangup(), realtime_peer(), realtime_update_peer(), realtime_user(), reg_source_db(), register_verify(), registry_rerequest(), reload_config(), resend_response(), retrans_pkt(), rpt_exec(), rtcp_do_debug_ip(), rtp_do_debug_ip(), sched_delay_remove(), score_address(), send_packet(), send_raw_client(), send_request(), send_response(), send_trunk(), session_do(), set_config(), set_destination(), set_peercnt_limit(), setup_incoming_call(), show_channels_cb(), show_chanstats_cb(), show_main_page(), sip_do_debug_ip(), sip_do_debug_peer(), sip_poke_peer(), sip_set_rtp_peer(), sip_set_udptl_peer(), sip_show_channel(), sip_show_settings(), sip_show_tcp(), skinny_session(), skinny_set_rtp_peer(), socket_process(), socket_process_meta(), start_rtp(), timing_read(), transmit_notify_with_mwi(), unistim_info(), unistimsock_read(), and update_registry().

00432 {
00433    char *buf;
00434 
00435    if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
00436       return "";
00437 
00438    return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
00439 }

void ast_join ( char *  s,
size_t  len,
char *const   w[] 
)

Definition at line 1451 of file utils.c.

Referenced by __ast_cli_generator(), ast_agi_register(), ast_agi_unregister(), cli_console_sendtext(), console_sendtext(), find_best(), handle_cli_agi_show(), handle_help(), help1(), help_workhorse(), set_full_cmd(), and write_htmldump().

01452 {
01453    int x, ofs = 0;
01454    const char *src;
01455 
01456    /* Join words into a string */
01457    if (!s)
01458       return;
01459    for (x = 0; ofs < len && w[x]; x++) {
01460       if (x > 0)
01461          s[ofs++] = ' ';
01462       for (src = w[x]; *src && ofs < len; src++)
01463          s[ofs++] = *src;
01464    }
01465    if (ofs == len)
01466       ofs--;
01467    s[ofs] = '\0';
01468 }

void ast_md5_hash ( char *  output,
char *  input 
)

Produces MD5 hash based on input string.

Definition at line 230 of file utils.c.

References md5(), MD5Final(), MD5Init(), and MD5Update().

Referenced by build_reply_digest(), check_auth(), and md5().

00231 {
00232    struct MD5Context md5;
00233    unsigned char digest[16];
00234    char *ptr;
00235    int x;
00236 
00237    MD5Init(&md5);
00238    MD5Update(&md5, (unsigned char *)input, strlen(input));
00239    MD5Final(digest, &md5);
00240    ptr = output;
00241    for (x = 0; x < 16; x++)
00242       ptr += sprintf(ptr, "%2.2x", digest[x]);
00243 }

int ast_mkdir ( const char *  path,
int  mode 
)

Recursively create directory path.

Parameters:
path The directory path to create
mode The permissions with which to try to create the directory
Returns:
0 on success or an error code otherwise
Creates a directory path, creating parent directories as needed.

Definition at line 1827 of file utils.c.

References ast_strdupa, errno, and len().

Referenced by ast_monitor_change_fname(), ast_monitor_start(), conf_run(), create_dirpath(), dictate_exec(), init_logger(), load_module(), mixmonitor_exec(), reload_logger(), remove_from_queue(), setup_privacy_args(), sms_nextoutgoing(), sms_writefile(), testclient_exec(), testserver_exec(), and write_history().

01828 {
01829    char *ptr;
01830    int len = strlen(path), count = 0, x, piececount = 0;
01831    char *tmp = ast_strdupa(path);
01832    char **pieces;
01833    char *fullpath = alloca(len + 1);
01834    int res = 0;
01835 
01836    for (ptr = tmp; *ptr; ptr++) {
01837       if (*ptr == '/')
01838          count++;
01839    }
01840 
01841    /* Count the components to the directory path */
01842    pieces = alloca(count * sizeof(*pieces));
01843    for (ptr = tmp; *ptr; ptr++) {
01844       if (*ptr == '/') {
01845          *ptr = '\0';
01846          pieces[piececount++] = ptr + 1;
01847       }
01848    }
01849 
01850    *fullpath = '\0';
01851    for (x = 0; x < piececount; x++) {
01852       /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
01853       strcat(fullpath, "/");
01854       strcat(fullpath, pieces[x]);
01855       res = mkdir(fullpath, mode);
01856       if (res && errno != EEXIST)
01857          return errno;
01858    }
01859    return 0;
01860 }

char* ast_process_quotes_and_slashes ( char *  start,
char  find,
char  replace_with 
)

Process a string to find and replace characters.

Parameters:
start The string to analyze
find The character to find
replace_with The character that will replace the one we are looking for

Definition at line 1425 of file utils.c.

01426 {
01427    char *dataPut = start;
01428    int inEscape = 0;
01429    int inQuotes = 0;
01430 
01431    for (; *start; start++) {
01432       if (inEscape) {
01433          *dataPut++ = *start;       /* Always goes verbatim */
01434          inEscape = 0;
01435       } else {
01436          if (*start == '\\') {
01437             inEscape = 1;      /* Do not copy \ into the data */
01438          } else if (*start == '\'') {
01439             inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
01440          } else {
01441             /* Replace , with |, unless in quotes */
01442             *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
01443          }
01444       }
01445    }
01446    if (start != dataPut)
01447       *dataPut = 0;
01448    return dataPut;
01449 }

int ast_pthread_create_detached_stack ( pthread_t *  thread,
pthread_attr_t *  attr,
void *(*)(void *)  start_routine,
void *  data,
size_t  stacksize,
const char *  file,
const char *  caller,
int  line,
const char *  start_fn 
)

Definition at line 1026 of file utils.c.

References ast_log(), ast_pthread_create_stack(), errno, and LOG_WARNING.

01029 {
01030    unsigned char attr_destroy = 0;
01031    int res;
01032 
01033    if (!attr) {
01034       attr = alloca(sizeof(*attr));
01035       pthread_attr_init(attr);
01036       attr_destroy = 1;
01037    }
01038 
01039    if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
01040       ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
01041 
01042    res = ast_pthread_create_stack(thread, attr, start_routine, data, 
01043                                   stacksize, file, caller, line, start_fn);
01044 
01045    if (attr_destroy)
01046       pthread_attr_destroy(attr);
01047 
01048    return res;
01049 }

int ast_pthread_create_stack ( pthread_t *  thread,
pthread_attr_t *  attr,
void *(*)(void *)  start_routine,
void *  data,
size_t  stacksize,
const char *  file,
const char *  caller,
int  line,
const char *  start_fn 
)

Definition at line 977 of file utils.c.

References asprintf, ast_log(), ast_malloc, AST_STACKSIZE, dummy_start(), errno, LOG_WARNING, and pthread_create.

Referenced by ast_pthread_create_detached_stack().

00980 {
00981 #if !defined(LOW_MEMORY)
00982    struct thr_arg *a;
00983 #endif
00984 
00985    if (!attr) {
00986       attr = alloca(sizeof(*attr));
00987       pthread_attr_init(attr);
00988    }
00989 
00990 #ifdef __linux__
00991    /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
00992       which is kind of useless. Change this here to
00993       PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
00994       priority will propagate down to new threads by default.
00995       This does mean that callers cannot set a different priority using
00996       PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
00997       the priority afterwards with pthread_setschedparam(). */
00998    if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
00999       ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
01000 #endif
01001 
01002    if (!stacksize)
01003       stacksize = AST_STACKSIZE;
01004 
01005    if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
01006       ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
01007 
01008 #if !defined(LOW_MEMORY)
01009    if ((a = ast_malloc(sizeof(*a)))) {
01010       a->start_routine = start_routine;
01011       a->data = data;
01012       start_routine = dummy_start;
01013       if (asprintf(&a->name, "%-20s started at [%5d] %s %s()",
01014               start_fn, line, file, caller) < 0) {
01015          ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
01016          a->name = NULL;
01017       }
01018       data = a;
01019    }
01020 #endif /* !LOW_MEMORY */
01021 
01022    return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
01023 }

long int ast_random ( void   ) 

Definition at line 1401 of file utils.c.

References ast_mutex_lock(), ast_mutex_unlock(), and randomlock.

Referenced by acf_rand_exec(), action_challenge(), add_sdp(), agent_new(), agi_handle_command(), ast_lock_path_lockfile(), ast_moh_files_next(), ast_rtp_change_source(), ast_rtp_new_init(), ast_rtp_new_with_bindaddr(), ast_udptl_new_with_bindaddr(), authenticate_request(), build_gateway(), build_iv(), build_rand_pad(), build_reply_digest(), calc_metric(), calc_rxstamp(), callno_hash(), dahdi_new(), generate_random_string(), get_trans_id(), gtalk_alloc(), gtalk_create_candidates(), gtalk_new(), handle_response_invite(), iax2_key_rotate(), iax2_start_transfer(), jingle_alloc(), jingle_create_candidates(), jingle_new(), load_module(), local_new(), make_email_file(), make_our_tag(), moh_files_alloc(), ogg_vorbis_rewrite(), osp_create_uuid(), page_exec(), park_space_reserve(), process_weights(), reg_source_db(), registry_authrequest(), reqprep(), say_periodic_announcement(), sendmail(), set_nonce_randdata(), sip_alloc(), socket_read(), start_rtp(), stun_req_id(), transmit_invite(), transmit_register(), transmit_response_using_temp(), and try_firmware().

01402 {
01403    long int res;
01404 #ifdef HAVE_DEV_URANDOM
01405    if (dev_urandom_fd >= 0) {
01406       int read_res = read(dev_urandom_fd, &res, sizeof(res));
01407       if (read_res > 0) {
01408          long int rm = RAND_MAX;
01409          res = res < 0 ? ~res : res;
01410          rm++;
01411          return res % rm;
01412       }
01413    }
01414 #endif
01415 #ifdef linux
01416    res = random();
01417 #else
01418    ast_mutex_lock(&randomlock);
01419    res = random();
01420    ast_mutex_unlock(&randomlock);
01421 #endif
01422    return res;
01423 }

void ast_sha1_hash ( char *  output,
char *  input 
)

Produces SHA1 hash based on input string.

Definition at line 246 of file utils.c.

References SHA1Input(), SHA1Reset(), and SHA1Result().

Referenced by aji_act_hook(), handle_call_token(), jabber_make_auth(), and sha1().

00247 {
00248    struct SHA1Context sha;
00249    char *ptr;
00250    int x;
00251    uint8_t Message_Digest[20];
00252 
00253    SHA1Reset(&sha);
00254    
00255    SHA1Input(&sha, (const unsigned char *) input, strlen(input));
00256 
00257    SHA1Result(&sha, Message_Digest);
00258    ptr = output;
00259    for (x = 0; x < 20; x++)
00260       ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
00261 }

char* ast_strip_quoted ( char *  s,
const char *  beg_quotes,
const char *  end_quotes 
)

Strip leading/trailing whitespace and quotes from a string.

Parameters:
s The string to be stripped (will be modified).
beg_quotes The list of possible beginning quote characters.
end_quotes The list of matching ending quote characters.
Returns:
The stripped string.
This functions strips all leading and trailing whitespace characters from the input string, and returns a pointer to the resulting string. The string is modified in place.

It can also remove beginning and ending quote (or quote-like) characters, in matching pairs. If the first character of the string matches any character in beg_quotes, and the last character of the string is the matching character in end_quotes, then they are removed from the string.

Examples:

  ast_strip_quoted(buf, "\"", "\"");
  ast_strip_quoted(buf, "'", "'");
  ast_strip_quoted(buf, "[{(", "]})");

Definition at line 1209 of file utils.c.

References ast_strip().

Referenced by ast_register_file_version(), get_rdnis(), iftime(), load_values_config(), parse_cookies(), and parse_dial_string().

01210 {
01211    char *e;
01212    char *q;
01213 
01214    s = ast_strip(s);
01215    if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
01216       e = s + strlen(s) - 1;
01217       if (*e == *(end_quotes + (q - beg_quotes))) {
01218          s++;
01219          *e = '\0';
01220       }
01221    }
01222 
01223    return s;
01224 }

int ast_true ( const char *  val  ) 

Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1".

Return values:
0 if val is a NULL pointer.
-1 if "true".
0 otherwise.

Definition at line 1311 of file utils.c.

References ast_strlen_zero().

Referenced by __ast_http_load(), __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _parse(), action_agent_logoff(), action_bridge(), action_originate(), action_updateconfig(), aji_create_client(), aji_load_config(), apply_general_options(), apply_option(), apply_outgoing(), ast_jb_read_conf(), build_device(), build_gateway(), build_peer(), build_user(), connect_link(), dahdi_set_dnd(), do_reload(), do_timelimit(), festival_exec(), func_channel_write(), func_inheritance_write(), get_encrypt_methods(), gtalk_load_config(), handle_common_options(), handle_t38_options(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), local_ast_moh_start(), login_exec(), manager_add_queue_member(), manager_pause_queue_member(), message_template_build(), misdn_answer(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), process_echocancel(), queue_set_param(), read_agent_config(), realtime_directory(), reload_config(), reload_queues(), run_startup_commands(), search_directory(), set_active(), set_config(), sla_load_config(), speex_write(), start_monitor_action(), strings_to_mask(), and update_common_options().

01312 {
01313    if (ast_strlen_zero(s))
01314       return 0;
01315 
01316    /* Determine if this is a true value */
01317    if (!strcasecmp(s, "yes") ||
01318        !strcasecmp(s, "true") ||
01319        !strcasecmp(s, "y") ||
01320        !strcasecmp(s, "t") ||
01321        !strcasecmp(s, "1") ||
01322        !strcasecmp(s, "on"))
01323       return -1;
01324 
01325    return 0;
01326 }

struct timeval ast_tvadd ( struct timeval  a,
struct timeval  b 
)

Returns the sum of two timevals a + b.

Definition at line 1365 of file utils.c.

References ONE_MILLION, and tvfix().

Referenced by __get_from_jb(), agent_hangup(), agent_read(), ast_audiohook_trigger_wait(), ast_channel_bridge(), ast_channel_cmpwhentohangup_tv(), ast_channel_setwhentohangup_tv(), ast_generic_bridge(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_senddigit_end(), ast_sched_runq(), ast_smoother_read(), ast_translate(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), dial_exec_full(), do_cdr(), do_timing(), iax2_process_thread(), jb_get_and_deliver(), mb_poll_thread(), monmp3thread(), mp3_exec(), mwi_monitor_handler(), NBScat_exec(), sched_settime(), sched_thread(), schedule_delivery(), sla_process_timers(), smdi_message_wait(), and timeout_write().

01366 {
01367    /* consistency checks to guarantee usec in 0..999999 */
01368    a = tvfix(a);
01369    b = tvfix(b);
01370    a.tv_sec += b.tv_sec;
01371    a.tv_usec += b.tv_usec;
01372    if (a.tv_usec >= ONE_MILLION) {
01373       a.tv_sec++;
01374       a.tv_usec -= ONE_MILLION;
01375    }
01376    return a;
01377 }

struct timeval ast_tvsub ( struct timeval  a,
struct timeval  b 
)

Returns the difference of two timevals a - b.

Definition at line 1379 of file utils.c.

References ONE_MILLION, and tvfix().

Referenced by ast_channel_bridge(), ast_rwlock_timedrdlock(), ast_rwlock_timedwrlock(), ast_sched_dump(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), handle_showcalls(), handle_showuptime(), and pri_dchannel().

01380 {
01381    /* consistency checks to guarantee usec in 0..999999 */
01382    a = tvfix(a);
01383    b = tvfix(b);
01384    a.tv_sec -= b.tv_sec;
01385    a.tv_usec -= b.tv_usec;
01386    if (a.tv_usec < 0) {
01387       a.tv_sec-- ;
01388       a.tv_usec += ONE_MILLION;
01389    }
01390    return a;
01391 }

char* ast_unescape_c ( char *  s  ) 

Convert some C escape sequences.

(\b\f\n\r\t) 
into the equivalent characters. The string to be converted (will be modified).
Returns:
The converted string.

Definition at line 1245 of file utils.c.

01246 {
01247    char c, *ret, *dst;
01248 
01249    if (src == NULL)
01250       return NULL;
01251    for (ret = dst = src; (c = *src++); *dst++ = c ) {
01252       if (c != '\\')
01253          continue;   /* copy char at the end of the loop */
01254       switch ((c = *src++)) {
01255       case '\0':  /* special, trailing '\' */
01256          c = '\\';
01257          break;
01258       case 'b':   /* backspace */
01259          c = '\b';
01260          break;
01261       case 'f':   /* form feed */
01262          c = '\f';
01263          break;
01264       case 'n':
01265          c = '\n';
01266          break;
01267       case 'r':
01268          c = '\r';
01269          break;
01270       case 't':
01271          c = '\t';
01272          break;
01273       }
01274       /* default, use the char literally */
01275    }
01276    *dst = '\0';
01277    return ret;
01278 }

char* ast_unescape_semicolon ( char *  s  ) 

Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).

Returns:
The stripped string.

Definition at line 1226 of file utils.c.

Referenced by transmit_invite(), and transmit_notify_custom().

01227 {
01228    char *e;
01229    char *work = s;
01230 
01231    while ((e = strchr(work, ';'))) {
01232       if ((e > work) && (*(e-1) == '\\')) {
01233          memmove(e - 1, e, strlen(e) + 1);
01234          work = e;
01235       } else {
01236          work = e + 1;
01237       }
01238    }
01239 
01240    return s;
01241 }

void ast_uri_decode ( char *  s  ) 

Decode URI, URN, URL (overwrite string).

Parameters:
s String to be decoded

Definition at line 414 of file utils.c.

Referenced by check_user_full(), config_curl(), get_also_info(), get_destination(), get_refer_info(), handle_request_invite(), http_decode(), realtime_curl(), realtime_multi_curl(), register_verify(), sip_new(), and uridecode().

00415 {
00416    char *o;
00417    unsigned int tmp;
00418 
00419    for (o = s; *s; s++, o++) {
00420       if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
00421          /* have '%', two chars and correct parsing */
00422          *o = tmp;
00423          s += 2;  /* Will be incremented once more when we break out */
00424       } else /* all other cases, just copy */
00425          *o = *s;
00426    }
00427    *o = '\0';
00428 }

char* ast_uri_encode ( const char *  string,
char *  outbuf,
int  buflen,
int  doreserved 
)

Turn text string to URI-encoded XX version.

Note:
At this point, we're converting from ISO-8859-x (8-bit), not UTF8 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.

Definition at line 383 of file utils.c.

References ast_copy_string().

Referenced by config_curl(), destroy_curl(), initreqprep(), launch_asyncagi(), realtime_curl(), realtime_multi_curl(), require_curl(), store_curl(), update_curl(), and uriencode().

00384 {
00385    char *reserved = ";/?:@&=+$,# "; /* Reserved chars */
00386 
00387    const char *ptr  = string; /* Start with the string */
00388    char *out = NULL;
00389    char *buf = NULL;
00390 
00391    ast_copy_string(outbuf, string, buflen);
00392 
00393    /* If there's no characters to convert, just go through and don't do anything */
00394    while (*ptr) {
00395       if ((*ptr < 32) || (doreserved && strchr(reserved, *ptr))) {
00396          /* Oops, we need to start working here */
00397          if (!buf) {
00398             buf = outbuf;
00399             out = buf + (ptr - string) ;  /* Set output ptr */
00400          }
00401          out += sprintf(out, "%%%02x", (unsigned char) *ptr);
00402       } else if (buf) {
00403          *out = *ptr;   /* Continue copying the string */
00404          out++;
00405       } 
00406       ptr++;
00407    }
00408    if (buf)
00409       *out = '\0';
00410    return outbuf;
00411 }

int ast_utils_init ( void   ) 

Definition at line 1862 of file utils.c.

References ARRAY_LEN, ast_cli_register_multiple(), and base64_init().

Referenced by main().

01863 {
01864 #ifdef HAVE_DEV_URANDOM
01865    dev_urandom_fd = open("/dev/urandom", O_RDONLY);
01866 #endif
01867    base64_init();
01868 #ifdef DEBUG_THREADS
01869 #if !defined(LOW_MEMORY)
01870    ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
01871 #endif
01872 #endif
01873    return 0;
01874 }

int ast_wait_for_input ( int  fd,
int  ms 
)

Definition at line 1051 of file utils.c.

References ast_poll.

Referenced by action_waitevent(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), and moh_class_destructor().

01052 {
01053    struct pollfd pfd[1];
01054    memset(pfd, 0, sizeof(pfd));
01055    pfd[0].fd = fd;
01056    pfd[0].events = POLLIN|POLLPRI;
01057    return ast_poll(pfd, 1, ms);
01058 }

static int ast_wait_for_output ( int  fd,
int  timeoutms 
) [static]

Definition at line 1060 of file utils.c.

References ast_debug, ast_log(), ast_poll, ast_tvdiff_ms(), ast_tvnow(), errno, and LOG_ERROR.

Referenced by ast_careful_fwrite(), and ast_carefulwrite().

01061 {
01062    struct pollfd pfd = {
01063       .fd = fd,
01064       .events = POLLOUT,
01065    };
01066    int res;
01067    struct timeval start = ast_tvnow();
01068    int elapsed = 0;
01069 
01070    /* poll() until the fd is writable without blocking */
01071    while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
01072       if (res == 0) {
01073          /* timed out. */
01074 #ifndef STANDALONE
01075          ast_debug(1, "Timed out trying to write\n");
01076 #endif
01077          return -1;
01078       } else if (res == -1) {
01079          /* poll() returned an error, check to see if it was fatal */
01080 
01081          if (errno == EINTR || errno == EAGAIN) {
01082             elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01083             if (elapsed >= timeoutms) {
01084                return -1;
01085             }
01086             /* This was an acceptable error, go back into poll() */
01087             continue;
01088          }
01089 
01090          /* Fatal error, bail. */
01091          ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
01092 
01093          return -1;
01094       }
01095       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01096       if (elapsed >= timeoutms) {
01097          return -1;
01098       }
01099    }
01100 
01101    return 0;
01102 }

static void base64_init ( void   )  [static]

Definition at line 347 of file utils.c.

Referenced by ast_utils_init().

00348 {
00349    int x;
00350    memset(b2a, -1, sizeof(b2a));
00351    /* Initialize base-64 Conversion table */
00352    for (x = 0; x < 26; x++) {
00353       /* A-Z */
00354       base64[x] = 'A' + x;
00355       b2a['A' + x] = x;
00356       /* a-z */
00357       base64[x + 26] = 'a' + x;
00358       b2a['a' + x] = x + 26;
00359       /* 0-9 */
00360       if (x < 10) {
00361          base64[x + 52] = '0' + x;
00362          b2a['0' + x] = x + 52;
00363       }
00364    }
00365    base64[62] = '+';
00366    base64[63] = '/';
00367    b2a[(int)'+'] = 62;
00368    b2a[(int)'/'] = 63;
00369 }

static void* dummy_start ( void *  data  )  [static]

Definition at line 933 of file utils.c.

References ast_free, AST_LIST_INSERT_TAIL, AST_MUTEX_KIND, ast_register_thread(), ast_threadstorage_get(), ast_unregister_thread(), thr_arg::data, lock_info, thr_arg::name, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, thr_arg::start_routine, and strdup.

Referenced by ast_pthread_create_stack().

00934 {
00935    void *ret;
00936    struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
00937 #ifdef DEBUG_THREADS
00938    struct thr_lock_info *lock_info;
00939    pthread_mutexattr_t mutex_attr;
00940 #endif
00941 
00942    /* note that even though data->name is a pointer to allocated memory,
00943       we are not freeing it here because ast_register_thread is going to
00944       keep a copy of the pointer and then ast_unregister_thread will
00945       free the memory
00946    */
00947    ast_free(data);
00948    ast_register_thread(a.name);
00949    pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
00950 
00951 #ifdef DEBUG_THREADS
00952    if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
00953       return NULL;
00954 
00955    lock_info->thread_id = pthread_self();
00956    lock_info->thread_name = strdup(a.name);
00957 
00958    pthread_mutexattr_init(&mutex_attr);
00959    pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
00960    pthread_mutex_init(&lock_info->lock, &mutex_attr);
00961    pthread_mutexattr_destroy(&mutex_attr);
00962 
00963    pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
00964    AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
00965    pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
00966 #endif /* DEBUG_THREADS */
00967 
00968    ret = a.start_routine(a.data);
00969 
00970    pthread_cleanup_pop(1);
00971 
00972    return ret;
00973 }

static struct timeval tvfix ( struct timeval  a  )  [static]

Definition at line 1350 of file utils.c.

References ast_log(), LOG_WARNING, and ONE_MILLION.

Referenced by ast_tvadd(), and ast_tvsub().

01351 {
01352    if (a.tv_usec >= ONE_MILLION) {
01353       ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
01354          (long)a.tv_sec, (long int) a.tv_usec);
01355       a.tv_sec += a.tv_usec / ONE_MILLION;
01356       a.tv_usec %= ONE_MILLION;
01357    } else if (a.tv_usec < 0) {
01358       ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
01359          (long)a.tv_sec, (long int) a.tv_usec);
01360       a.tv_usec = 0;
01361    }
01362    return a;
01363 }


Variable Documentation

const char __ast_string_field_empty[] = ""

the empty string

Definition at line 1474 of file utils.c.

char b2a[256] [static]

Definition at line 66 of file utils.c.

char base64[64] [static]

Definition at line 65 of file utils.c.

Referenced by aji_start_sasl().

int dev_urandom_fd [static]

Definition at line 442 of file utils.c.

ast_mutex_t fetchadd_m = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static]

Definition at line 1690 of file utils.c.

Referenced by ast_atomic_fetchadd_int_slow().

struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , } [static]

Definition at line 68 of file utils.c.

Referenced by ast_inet_ntoa().

ast_mutex_t randomlock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static]

glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not.

Definition at line 1398 of file utils.c.

Referenced by ast_random().


Generated on Wed Aug 18 22:34:34 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7