Tue Aug 20 16:35:17 2013

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 ALLOCATOR_OVERHEAD   48
#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

void * __ast_calloc_with_stringfields (unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func)
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, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr)
void __ast_string_field_release_active (struct ast_string_field_pool *pool_head, const ast_string_field ptr)
static void __init_inet_ntoa_buf (void)
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 BASE64 encoded text
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_do_crash (void)
 Force a crash if DO_CRASH is defined.
void ast_enable_packet_fragmentation (int sock)
 Disable PMTU discovery on a socket.
char * ast_escape_quoted (const char *string, char *outbuf, int buflen)
 escapes characters specified for quoted portions of sip messages
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.
struct hostent * ast_gethostbyname (const char *host, struct ast_hostent *hp)
 Re-entrant (thread safe) version of gethostbyname that replaces the standard gethostbyname (which is not thread safe).
const char * ast_inet_ntoa (struct in_addr ia)
 ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa
void ast_join (char *s, size_t len, const char *const w[])
void ast_md5_hash (char *output, const char *input)
 Produce 32 char MD5 hash of value.
int ast_mkdir (const char *path, int mode)
 Recursively create directory path.
int ast_parse_digest (const char *digest, struct ast_http_digest *d, int request, int pedantic)
 Parse digest authorization header.
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)
int ast_remaining_ms (struct timeval start, int max_ms)
 Calculate remaining milliseconds given a starting timestamp and upper bound.
void ast_sha1_hash (char *output, const char *input)
 Produce 40 char SHA1 hash of value.
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".
struct timeval ast_tvadd (struct timeval a, struct timeval b)
 Returns the sum of two timevals a + b.
struct 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)
 ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)
char * ast_uri_encode (const char *string, char *outbuf, int buflen, int do_special_char)
 Turn text string to URI-encoded XX version.
int ast_utils_init (void)
char * ast_utils_which (const char *binary, char *fullpath, size_t fullpath_size)
 Resolve a binary to a full pathname.
int ast_wait_for_input (int fd, int ms)
static int ast_wait_for_output (int fd, int timeoutms)
int ast_xml_escape (const char *string, char *const outbuf, const size_t buflen)
 Escape reserved characters for use in XML.
static void base64_init (void)
static void * dummy_start (void *data)
static size_t optimal_alloc_size (size_t size)
static struct timeval tvfix (struct timeval a)

Variables

ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string
struct {
   ast_string_field_allocation   allocation
   char   string [1]
__ast_string_field_empty_buffer
static char b2a [256]
static char base64 [64]
static int dev_urandom_fd
static ast_mutex_t fetchadd_m = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
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 = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
 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 ALLOCATOR_OVERHEAD   48

Definition at line 1609 of file utils.c.

Referenced by optimal_alloc_size().

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define AST_API_MODULE

Definition at line 67 of file utils.c.

#define ONE_MILLION   1000000

Definition at line 1449 of file utils.c.

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


Function Documentation

void* __ast_calloc_with_stringfields ( unsigned int  num_structs,
size_t  struct_size,
size_t  field_mgr_offset,
size_t  field_mgr_pool_offset,
size_t  pool_size,
const char *  file,
int  lineno,
const char *  func 
)

Definition at line 1888 of file utils.c.

References __ast_calloc(), allocation, ast_calloc, ast_string_field_pool::base, ast_string_field_mgr::embedded_pool, optimal_alloc_size(), ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, ast_string_field_mgr::owner_line, and ast_string_field_pool::size.

01891 {
01892    struct ast_string_field_mgr *mgr;
01893    struct ast_string_field_pool *pool;
01894    struct ast_string_field_pool **pool_head;
01895    size_t pool_size_needed = sizeof(*pool) + pool_size;
01896    size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
01897    void *allocation;
01898    unsigned int x;
01899 
01900 #if defined(__AST_DEBUG_MALLOC)  
01901    if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) {
01902       return NULL;
01903    }
01904 #else
01905    if (!(allocation = ast_calloc(num_structs, size_to_alloc))) {
01906       return NULL;
01907    }
01908 #endif
01909 
01910    for (x = 0; x < num_structs; x++) {
01911       void *base = allocation + (size_to_alloc * x);
01912       const char **p;
01913 
01914       mgr = base + field_mgr_offset;
01915       pool_head = base + field_mgr_pool_offset;
01916       pool = base + struct_size;
01917 
01918       p = (const char **) pool_head + 1;
01919       while ((struct ast_string_field_mgr *) p != mgr) {
01920          *p++ = __ast_string_field_empty;
01921       }
01922 
01923       mgr->embedded_pool = pool;
01924       *pool_head = pool;
01925       pool->size = size_to_alloc - struct_size - sizeof(*pool);
01926 #if defined(__AST_DEBUG_MALLOC)
01927       mgr->owner_file = file;
01928       mgr->owner_func = func;
01929       mgr->owner_line = lineno;
01930 #endif
01931    }
01932 
01933    return allocation;
01934 }

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 1729 of file utils.c.

References add_string_pool(), ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, ast_string_field_mgr::last_alloc, ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, and ast_string_field_mgr::owner_line.

Referenced by __ast_string_field_ptr_build_va().

01731 {
01732    char *result = NULL;
01733    size_t space = (*pool_head)->size - (*pool_head)->used;
01734    size_t to_alloc;
01735 
01736    /* Make room for ast_string_field_allocation and make it a multiple of that. */
01737    to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
01738    ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);
01739 
01740    if (__builtin_expect(to_alloc > space, 0)) {
01741       size_t new_size = (*pool_head)->size;
01742 
01743       while (new_size < to_alloc) {
01744          new_size *= 2;
01745       }
01746 
01747 #if defined(__AST_DEBUG_MALLOC)
01748       if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func))
01749          return NULL;
01750 #else
01751       if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__))
01752          return NULL;
01753 #endif
01754    }
01755 
01756    /* pool->base is always aligned (gcc aligned attribute). We ensure that
01757     * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
01758     * causing result to always be aligned as well; which in turn fixes that
01759     * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
01760    result = (*pool_head)->base + (*pool_head)->used;
01761    (*pool_head)->used += to_alloc;
01762    (*pool_head)->active += needed;
01763    result += ast_alignof(ast_string_field_allocation);
01764    AST_STRING_FIELD_ALLOCATION(result) = needed;
01765    mgr->last_alloc = result;
01766 
01767    return result;
01768 }

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 1662 of file utils.c.

References ast_string_field_pool::active, add_string_pool(), ast_free, ast_log(), ast_string_field_mgr::embedded_pool, ast_string_field_mgr::last_alloc, LOG_WARNING, ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, ast_string_field_mgr::owner_line, ast_string_field_pool::prev, and ast_string_field_pool::used.

01664 {
01665    const char **p = (const char **) pool_head + 1;
01666    struct ast_string_field_pool *cur = NULL;
01667    struct ast_string_field_pool *preserve = NULL;
01668 
01669    /* clear fields - this is always necessary */
01670    while ((struct ast_string_field_mgr *) p != mgr) {
01671       *p++ = __ast_string_field_empty;
01672    }
01673 
01674    mgr->last_alloc = NULL;
01675 #if defined(__AST_DEBUG_MALLOC)
01676    mgr->owner_file = file;
01677    mgr->owner_func = func;
01678    mgr->owner_line = lineno;
01679 #endif
01680    if (needed > 0) {    /* allocate the initial pool */
01681       *pool_head = NULL;
01682       mgr->embedded_pool = NULL;
01683       return add_string_pool(mgr, pool_head, needed, file, lineno, func);
01684    }
01685 
01686    /* if there is an embedded pool, we can't actually release *all*
01687     * pools, we must keep the embedded one. if the caller is about
01688     * to free the structure that contains the stringfield manager
01689     * and embedded pool anyway, it will be freed as part of that
01690     * operation.
01691     */
01692    if ((needed < 0) && mgr->embedded_pool) {
01693       needed = 0;
01694    }
01695 
01696    if (needed < 0) {    /* reset all pools */
01697       cur = *pool_head;
01698    } else if (mgr->embedded_pool) { /* preserve the embedded pool */
01699       preserve = mgr->embedded_pool;
01700       cur = *pool_head;
01701    } else {       /* preserve the last pool */
01702       if (*pool_head == NULL) {
01703          ast_log(LOG_WARNING, "trying to reset empty pool\n");
01704          return -1;
01705       }
01706       preserve = *pool_head;
01707       cur = preserve->prev;
01708    }
01709 
01710    if (preserve) {
01711       preserve->prev = NULL;
01712       preserve->used = preserve->active = 0;
01713    }
01714 
01715    while (cur) {
01716       struct ast_string_field_pool *prev = cur->prev;
01717 
01718       if (cur != preserve) {
01719          ast_free(cur);
01720       }
01721       cur = prev;
01722    }
01723 
01724    *pool_head = preserve;
01725 
01726    return 0;
01727 }

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 1873 of file utils.c.

References __ast_string_field_ptr_build_va().

01876 {
01877    va_list ap1, ap2;
01878 
01879    va_start(ap1, format);
01880    va_start(ap2, format);     /* va_copy does not exist on FreeBSD */
01881 
01882    __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2);
01883 
01884    va_end(ap1);
01885    va_end(ap2);
01886 }

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 1813 of file utils.c.

References __ast_string_field_alloc_space(), __ast_string_field_release_active(), ast_align_for, ast_alignof, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, available(), and ast_string_field_mgr::last_alloc.

Referenced by __ast_string_field_ptr_build().

01816 {
01817    size_t needed;
01818    size_t available;
01819    size_t space = (*pool_head)->size - (*pool_head)->used;
01820    ssize_t grow;
01821    char *target;
01822 
01823    /* if the field already has space allocated, try to reuse it;
01824       otherwise, try to use the empty space at the end of the current
01825       pool
01826    */
01827    if (*ptr != __ast_string_field_empty) {
01828       target = (char *) *ptr;
01829       available = AST_STRING_FIELD_ALLOCATION(*ptr);
01830       if (*ptr == mgr->last_alloc) {
01831          available += space;
01832       }
01833    } else {
01834       /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
01835        * so we don't need to re-align anything here.
01836        */
01837       target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
01838       available = space - ast_alignof(ast_string_field_allocation);
01839    }
01840 
01841    needed = vsnprintf(target, available, format, ap1) + 1;
01842 
01843    if (needed > available) {
01844       /* the allocation could not be satisfied using the field's current allocation
01845          (if it has one), or the space available in the pool (if it does not). allocate
01846          space for it, adding a new string pool if necessary.
01847       */
01848       if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {
01849          return;
01850       }
01851       vsprintf(target, format, ap2);
01852       __ast_string_field_release_active(*pool_head, *ptr);
01853       *ptr = target;
01854    } else if (*ptr != target) {
01855       /* the allocation was satisfied using available space in the pool, but not
01856          using the space already allocated to the field
01857       */
01858       __ast_string_field_release_active(*pool_head, *ptr);
01859       mgr->last_alloc = *ptr = target;
01860       AST_STRING_FIELD_ALLOCATION(target) = needed;
01861       (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
01862       (*pool_head)->active += needed;
01863    } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
01864       /* the allocation was satisfied by using available space in the pool *and*
01865          the field was the last allocated field from the pool, so it grew
01866       */
01867       AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
01868       (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
01869       (*pool_head)->active += grow;
01870    }
01871 }

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

Definition at line 1770 of file utils.c.

References AST_STRING_FIELD_ALLOCATION, and ast_string_field_mgr::last_alloc.

01773 {
01774    ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
01775    size_t space = (*pool_head)->size - (*pool_head)->used;
01776 
01777    if (*ptr != mgr->last_alloc) {
01778       return 1;
01779    }
01780 
01781    if (space < grow) {
01782       return 1;
01783    }
01784 
01785    (*pool_head)->used += grow;
01786    (*pool_head)->active += grow;
01787    AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
01788 
01789    return 0;
01790 }

void __ast_string_field_release_active ( struct ast_string_field_pool pool_head,
const ast_string_field  ptr 
)

Definition at line 1792 of file utils.c.

References ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, and ast_string_field_pool::prev.

Referenced by __ast_string_field_ptr_build_va().

01794 {
01795    struct ast_string_field_pool *pool, *prev;
01796 
01797    if (ptr == __ast_string_field_empty) {
01798       return;
01799    }
01800 
01801    for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
01802       if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
01803          pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
01804          if ((pool->active == 0) && prev) {
01805             prev->prev = pool->prev;
01806             ast_free(pool);
01807          }
01808          break;
01809       }
01810    }
01811 }

static void __init_inet_ntoa_buf ( void   )  [static]

Definition at line 73 of file utils.c.

00090 {

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 1626 of file utils.c.

References __ast_calloc(), ast_calloc, ast_string_field_mgr::last_alloc, optimal_alloc_size(), ast_string_field_pool::prev, and ast_string_field_pool::size.

Referenced by __ast_string_field_alloc_space(), and __ast_string_field_init().

01628 {
01629    struct ast_string_field_pool *pool;
01630    size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);
01631 
01632 #if defined(__AST_DEBUG_MALLOC)
01633    if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) {
01634       return -1;
01635    }
01636 #else
01637    if (!(pool = ast_calloc(1, alloc_size))) {
01638       return -1;
01639    }
01640 #endif
01641 
01642    pool->prev = *pool_head;
01643    pool->size = alloc_size - sizeof(*pool);
01644    *pool_head = pool;
01645    mgr->last_alloc = NULL;
01646 
01647    return 0;
01648 }

int ast_atomic_fetchadd_int_slow ( volatile int *  p,
int  v 
)

Definition at line 1940 of file utils.c.

References ast_mutex_lock, ast_mutex_unlock, and fetchadd_m.

01941 {
01942    int ret;
01943    ast_mutex_lock(&fetchadd_m);
01944    ret = *p;
01945    *p += v;
01946    ast_mutex_unlock(&fetchadd_m);
01947    return ret;
01948 }

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

decode BASE64 encoded text

Decode data from base64.

Definition at line 271 of file utils.c.

Referenced by aes_helper(), ast_check_signature(), base64_helper(), osp_validate_token(), sdp_crypto_process(), and sdp_crypto_setup().

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

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 349 of file utils.c.

References ast_base64encode_full().

Referenced by aes_helper(), aji_start_sasl(), ast_sign(), base64_helper(), build_secret(), osp_check_destination(), and sdp_crypto_setup().

00350 {
00351    return ast_base64encode_full(dst, src, srclen, max, 0);
00352 }

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

encode text to BASE64 coding

Definition at line 298 of file utils.c.

Referenced by ast_base64encode().

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

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 1403 of file utils.c.

References ast_build_string_va().

Referenced by ast_fax_caps_to_str(), config_odbc(), generate_filenames_string(), handle_speechrecognize(), pp_each_extension_helper(), and pp_each_user_helper().

01404 {
01405    va_list ap;
01406    int result;
01407 
01408    va_start(ap, fmt);
01409    result = ast_build_string_va(buffer, space, fmt, ap);
01410    va_end(ap);
01411 
01412    return result;
01413 }

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 1384 of file utils.c.

Referenced by ast_build_string().

01385 {
01386    int result;
01387 
01388    if (!buffer || !*buffer || !space || !*space)
01389       return -1;
01390 
01391    result = vsnprintf(*buffer, *space, fmt, ap);
01392 
01393    if (result < 0)
01394       return -1;
01395    else if (result > *space)
01396       result = *space;
01397 
01398    *buffer += result;
01399    *space -= result;
01400    return 0;
01401 }

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 1258 of file utils.c.

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

Referenced by send_string().

01259 {
01260    struct timeval start = ast_tvnow();
01261    int n = 0;
01262    int elapsed = 0;
01263 
01264    while (len) {
01265       if (ast_wait_for_output(fd, timeoutms - elapsed)) {
01266          /* poll returned a fatal error, so bail out immediately. */
01267          return -1;
01268       }
01269 
01270       /* Clear any errors from a previous write */
01271       clearerr(f);
01272 
01273       n = fwrite(src, 1, len, f);
01274 
01275       if (ferror(f) && errno != EINTR && errno != EAGAIN) {
01276          /* fatal error from fwrite() */
01277          if (!feof(f)) {
01278             /* Don't spam the logs if it was just that the connection is closed. */
01279             ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno));
01280          }
01281          n = -1;
01282          break;
01283       }
01284 
01285       /* Update for data already written to the socket */
01286       len -= n;
01287       src += n;
01288 
01289       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01290       if (elapsed >= timeoutms) {
01291          /* We've taken too long to write 
01292           * This is only an error condition if we haven't finished writing. */
01293          n = len ? -1 : 0;
01294          break;
01295       }
01296    }
01297 
01298    while (fflush(f)) {
01299       if (errno == EAGAIN || errno == EINTR) {
01300          continue;
01301       }
01302       if (!feof(f)) {
01303          /* Don't spam the logs if it was just that the connection is closed. */
01304          ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno));
01305       }
01306       n = -1;
01307       break;
01308    }
01309 
01310    return n < 0 ? -1 : 0;
01311 }

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 1217 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().

01218 {
01219    struct timeval start = ast_tvnow();
01220    int res = 0;
01221    int elapsed = 0;
01222 
01223    while (len) {
01224       if (ast_wait_for_output(fd, timeoutms - elapsed)) {
01225          return -1;
01226       }
01227 
01228       res = write(fd, s, len);
01229 
01230       if (res < 0 && errno != EAGAIN && errno != EINTR) {
01231          /* fatal error from write() */
01232          ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
01233          return -1;
01234       }
01235 
01236       if (res < 0) {
01237          /* It was an acceptable error */
01238          res = 0;
01239       }
01240 
01241       /* Update how much data we have left to write */
01242       len -= res;
01243       s += res;
01244       res = 0;
01245 
01246       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01247       if (elapsed >= timeoutms) {
01248          /* We've taken too long to write 
01249           * This is only an error condition if we haven't finished writing. */
01250          res = len ? -1 : 0;
01251          break;
01252       }
01253    }
01254 
01255    return res;
01256 }

void ast_do_crash ( void   ) 

Force a crash if DO_CRASH is defined.

Note:
If DO_CRASH is not defined then the function returns.
Returns:
Nothing

Definition at line 2218 of file utils.c.

Referenced by my_do_crash().

02219 {
02220 #if defined(DO_CRASH)
02221    abort();
02222    /*
02223     * Just in case abort() doesn't work or something else super
02224     * silly, and for Qwell's amusement.
02225     */
02226    *((int *) 0) = 0;
02227 #endif   /* defined(DO_CRASH) */
02228 }

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 2003 of file utils.c.

References ast_log(), and LOG_WARNING.

Referenced by ast_netsock_bindaddr(), and reload_config().

02004 {
02005 #if defined(HAVE_IP_MTU_DISCOVER)
02006    int val = IP_PMTUDISC_DONT;
02007    
02008    if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
02009       ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
02010 #endif /* HAVE_IP_MTU_DISCOVER */
02011 }

char* ast_escape_quoted ( const char *  string,
char *  outbuf,
int  buflen 
)

escapes characters specified for quoted portions of sip messages

Escape characters found in a quoted string.

Definition at line 423 of file utils.c.

Referenced by initreqprep().

00424 {
00425    const char *ptr  = string;
00426    char *out = outbuf;
00427    char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */
00428 
00429    while (*ptr && out - outbuf < buflen - 1) {
00430       if (!(strchr(allow, *ptr))
00431          && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */
00432          && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */
00433          && !((unsigned char) *ptr > 0x7f)) {             /* UTF8-nonascii */
00434 
00435          if (out - outbuf >= buflen - 2) {
00436             break;
00437          }
00438          out += sprintf(out, "\\%c", (unsigned char) *ptr);
00439       } else {
00440          *out = *ptr;
00441          out++;
00442       }
00443       ptr++;
00444    }
00445 
00446    if (buflen) {
00447       *out = '\0';
00448    }
00449 
00450    return outbuf;
00451 }

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 1432 of file utils.c.

References ast_strlen_zero().

Referenced by __ast_udptl_reload(), acf_faxopt_write(), acf_transaction_write(), actual_load_config(), aji_create_client(), aji_load_config(), aoc_cli_debug_enable(), build_peer(), build_user(), dahdi_set_dnd(), find_realtime(), func_channel_write_real(), handle_common_options(), handle_memory_atexit_list(), handle_memory_atexit_summary(), init_acf_query(), load_config(), load_odbc_config(), manager_mute_mixmonitor(), parse_empty_options(), reload_config(), rtp_reload(), run_agi(), set_config(), set_insecure_flags(), sla_build_trunk(), and strings_to_mask().

01433 {
01434    if (ast_strlen_zero(s))
01435       return 0;
01436 
01437    /* Determine if this is a false value */
01438    if (!strcasecmp(s, "no") ||
01439        !strcasecmp(s, "false") ||
01440        !strcasecmp(s, "n") ||
01441        !strcasecmp(s, "f") ||
01442        !strcasecmp(s, "0") ||
01443        !strcasecmp(s, "off"))
01444       return -1;
01445 
01446    return 0;
01447 }

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

get values from config variables.

Definition at line 1980 of file utils.c.

References ast_strlen_zero().

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

01981 {
01982    long t;
01983    int scanned;
01984 
01985    if (dst == NULL)
01986       return -1;
01987 
01988    *dst = _default;
01989 
01990    if (ast_strlen_zero(src))
01991       return -1;
01992 
01993    /* only integer at the moment, but one day we could accept more formats */
01994    if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
01995       *dst = t;
01996       if (consumed)
01997          *consumed = scanned;
01998       return 0;
01999    } else
02000       return -1;
02001 }

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

get values from config variables.

Definition at line 1953 of file utils.c.

References ast_strlen_zero().

Referenced by acf_strftime().

01954 {
01955    long double dtv = 0.0;
01956    int scanned;
01957 
01958    if (dst == NULL)
01959       return -1;
01960 
01961    *dst = _default;
01962 
01963    if (ast_strlen_zero(src))
01964       return -1;
01965 
01966    /* only integer at the moment, but one day we could accept more formats */
01967    if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
01968       dst->tv_sec = dtv;
01969       dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
01970       if (consumed)
01971          *consumed = scanned;
01972       return 0;
01973    } else
01974       return -1;
01975 }

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

Re-entrant (thread safe) version of gethostbyname that replaces the standard gethostbyname (which is not thread safe).

Thread-safe gethostbyname function to use in Asterisk.

Definition at line 187 of file utils.c.

References ast_hostent::buf, and ast_hostent::hp.

Referenced by __ast_http_load(), app_exec(), ast_parse_arg(), build_peer(), config_load(), config_parse_variables(), create_addr(), festival_exec(), gtalk_load_config(), gtalk_update_stun(), iax_template_parse(), jingle_load_config(), jingle_update_stun(), launch_netscript(), process_sdp(), realtime_peer(), realtime_user(), reload_config(), and set_config().

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

const char* ast_inet_ntoa ( struct in_addr  ia  ) 

ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa

thread-safe replacement for inet_ntoa().

Definition at line 534 of file utils.c.

References ast_threadstorage_get(), and inet_ntoa_buf.

Referenced by __attempt_transmit(), __find_callno(), __iax2_show_peers(), _skinny_show_device(), _skinny_show_devices(), acf_channel_read(), action_login(), add_ipv4_ie(), add_sdp(), ast_apply_ha(), ast_netsock_bindaddr(), ast_parse_arg(), auth_http_callback(), authenticate(), calltoken_required(), check_access(), config_load(), create_client(), data_get_xml_add_child(), data_result_manager_output(), data_result_print_cli_node(), do_message(), 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(), generic_http_callback(), get_input(), gtalk_update_externip(), 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_command_response(), handle_error(), handle_mgcp_show_endpoints(), handle_open_receive_channel_ack_message(), handle_request(), handle_show_http(), handle_showmanconn(), handle_skinny_show_settings(), iax2_ack_registry(), iax2_prov_app(), iax2_trunk_queue(), iax_server(), iax_showframe(), jingle_create_candidates(), load_module(), manager_iax2_show_peer_list(), manager_iax2_show_registry(), mgcpsock_read(), oh323_addrcmp_str(), oh323_call(), oh323_set_rtp_peer(), parsing(), peercnt_add(), peercnt_modify(), peercnt_remove(), peers_data_provider_get(), phoneprov_callback(), process_request(), process_sdp(), purge_sessions(), raw_hangup(), realtime_peer(), realtime_user(), register_verify(), registry_rerequest(), reload_config(), resend_response(), sched_delay_remove(), score_address(), send_packet(), send_raw_client(), send_request(), send_response(), send_trunk(), session_do(), set_config(), set_peercnt_limit(), setup_incoming_call(), show_main_page(), skinny_session(), skinny_set_rtp_peer(), socket_process(), socket_process_meta(), start_rtp(), stun_monitor_request(), timing_read(), unistim_info(), unistimsock_read(), and update_registry().

00535 {
00536    char *buf;
00537 
00538    if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
00539       return "";
00540 
00541    return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
00542 }

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

Definition at line 1572 of file utils.c.

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

01573 {
01574    int x, ofs = 0;
01575    const char *src;
01576 
01577    /* Join words into a string */
01578    if (!s)
01579       return;
01580    for (x = 0; ofs < len && w[x]; x++) {
01581       if (x > 0)
01582          s[ofs++] = ' ';
01583       for (src = w[x]; *src && ofs < len; src++)
01584          s[ofs++] = *src;
01585    }
01586    if (ofs == len)
01587       ofs--;
01588    s[ofs] = '\0';
01589 }

void ast_md5_hash ( char *  output,
const char *  input 
)

Produce 32 char MD5 hash of value.

Produces MD5 hash based on input string.

Definition at line 237 of file utils.c.

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

Referenced by __init_manager(), auth_exec(), auth_http_callback(), build_reply_digest(), check_auth(), and md5().

00238 {
00239    struct MD5Context md5;
00240    unsigned char digest[16];
00241    char *ptr;
00242    int x;
00243 
00244    MD5Init(&md5);
00245    MD5Update(&md5, (const unsigned char *) input, strlen(input));
00246    MD5Final(digest, &md5);
00247    ptr = output;
00248    for (x = 0; x < 16; x++)
00249       ptr += sprintf(ptr, "%2.2x", digest[x]);
00250 }

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 2013 of file utils.c.

References ast_alloca, ast_strdupa, errno, and len().

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

02014 {
02015    char *ptr;
02016    int len = strlen(path), count = 0, x, piececount = 0;
02017    char *tmp = ast_strdupa(path);
02018    char **pieces;
02019    char *fullpath = ast_alloca(len + 1);
02020    int res = 0;
02021 
02022    for (ptr = tmp; *ptr; ptr++) {
02023       if (*ptr == '/')
02024          count++;
02025    }
02026 
02027    /* Count the components to the directory path */
02028    pieces = ast_alloca(count * sizeof(*pieces));
02029    for (ptr = tmp; *ptr; ptr++) {
02030       if (*ptr == '/') {
02031          *ptr = '\0';
02032          pieces[piececount++] = ptr + 1;
02033       }
02034    }
02035 
02036    *fullpath = '\0';
02037    for (x = 0; x < piececount; x++) {
02038       /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
02039       strcat(fullpath, "/");
02040       strcat(fullpath, pieces[x]);
02041       res = mkdir(fullpath, mode);
02042       if (res && errno != EEXIST)
02043          return errno;
02044    }
02045    return 0;
02046 }

int ast_parse_digest ( const char *  digest,
struct ast_http_digest d,
int  request,
int  pedantic 
)

Parse digest authorization header.

Returns:
Returns -1 if we have no auth or something wrong with digest.
Note:
This function may be used for Digest request and responce header. request arg is set to nonzero, if we parse Digest Request. pedantic arg can be set to nonzero if we need to do addition Digest check.

Definition at line 2070 of file utils.c.

References ast_free, ast_log(), ast_skip_blanks(), ast_str_buffer(), ast_str_create(), ast_str_set(), ast_string_field_ptr_set, ast_string_field_set, ast_strlen_zero(), ast_unescape_c(), ast_http_digest::cnonce, ast_http_digest::domain, LOG_WARNING, ast_http_digest::nc, ast_http_digest::nonce, ast_http_digest::opaque, ast_http_digest::qop, ast_http_digest::realm, ast_http_digest::response, ast_http_digest::uri, and ast_http_digest::username.

Referenced by auth_http_callback().

02070                                                                                                {
02071    char *c;
02072    struct ast_str *str = ast_str_create(16);
02073 
02074    /* table of recognised keywords, and places where they should be copied */
02075    const struct x {
02076       const char *key;
02077       const ast_string_field *field;
02078    } *i, keys[] = {
02079       { "username=", &d->username },
02080       { "realm=", &d->realm },
02081       { "nonce=", &d->nonce },
02082       { "uri=", &d->uri },
02083       { "domain=", &d->domain },
02084       { "response=", &d->response },
02085       { "cnonce=", &d->cnonce },
02086       { "opaque=", &d->opaque },
02087       /* Special cases that cannot be directly copied */
02088       { "algorithm=", NULL },
02089       { "qop=", NULL },
02090       { "nc=", NULL },
02091       { NULL, 0 },
02092    };
02093 
02094    if (ast_strlen_zero(digest) || !d || !str) {
02095       ast_free(str);
02096       return -1;
02097    }
02098 
02099    ast_str_set(&str, 0, "%s", digest);
02100 
02101    c = ast_skip_blanks(ast_str_buffer(str));
02102 
02103    if (strncasecmp(c, "Digest ", strlen("Digest "))) {
02104       ast_log(LOG_WARNING, "Missing Digest.\n");
02105       ast_free(str);
02106       return -1;
02107    }
02108    c += strlen("Digest ");
02109 
02110    /* lookup for keys/value pair */
02111    while (c && *c && *(c = ast_skip_blanks(c))) {
02112       /* find key */
02113       for (i = keys; i->key != NULL; i++) {
02114          char *src, *separator;
02115          int unescape = 0;
02116          if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
02117             continue;
02118          }
02119 
02120          /* Found. Skip keyword, take text in quotes or up to the separator. */
02121          c += strlen(i->key);
02122          if (*c == '"') {
02123             src = ++c;
02124             separator = "\"";
02125             unescape = 1;
02126          } else {
02127             src = c;
02128             separator = ",";
02129          }
02130          strsep(&c, separator); /* clear separator and move ptr */
02131          if (unescape) {
02132             ast_unescape_c(src);
02133          }
02134          if (i->field) {
02135             ast_string_field_ptr_set(d, i->field, src);
02136          } else {
02137             /* Special cases that require additional procesing */
02138             if (!strcasecmp(i->key, "algorithm=")) {
02139                if (strcasecmp(src, "MD5")) {
02140                   ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
02141                   ast_free(str);
02142                   return -1;
02143                }
02144             } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
02145                d->qop = 1;
02146             } else if (!strcasecmp(i->key, "nc=")) {
02147                unsigned long u;
02148                if (sscanf(src, "%30lx", &u) != 1) {
02149                   ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
02150                   ast_free(str);
02151                   return -1;
02152                }
02153                ast_string_field_set(d, nc, src);
02154             }
02155          }
02156          break;
02157       }
02158       if (i->key == NULL) { /* not found, try ',' */
02159          strsep(&c, ",");
02160       }
02161    }
02162    ast_free(str);
02163 
02164    /* Digest checkout */
02165    if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
02166       /* "realm" and "nonce" MUST be always exist */
02167       return -1;
02168    }
02169 
02170    if (!request) {
02171       /* Additional check for Digest response */
02172       if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
02173          return -1;
02174       }
02175 
02176       if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
02177          return -1;
02178       }
02179    }
02180 
02181    return 0;
02182 }

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 1546 of file utils.c.

01547 {
01548    char *dataPut = start;
01549    int inEscape = 0;
01550    int inQuotes = 0;
01551 
01552    for (; *start; start++) {
01553       if (inEscape) {
01554          *dataPut++ = *start;       /* Always goes verbatim */
01555          inEscape = 0;
01556       } else {
01557          if (*start == '\\') {
01558             inEscape = 1;      /* Do not copy \ into the data */
01559          } else if (*start == '\'') {
01560             inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
01561          } else {
01562             /* Replace , with |, unless in quotes */
01563             *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
01564          }
01565       }
01566    }
01567    if (start != dataPut)
01568       *dataPut = 0;
01569    return dataPut;
01570 }

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 1130 of file utils.c.

References ast_alloca, ast_log(), ast_pthread_create_stack(), errno, LOG_WARNING, and thr_arg::start_routine.

01133 {
01134    unsigned char attr_destroy = 0;
01135    int res;
01136 
01137    if (!attr) {
01138       attr = ast_alloca(sizeof(*attr));
01139       pthread_attr_init(attr);
01140       attr_destroy = 1;
01141    }
01142 
01143    if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
01144       ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));
01145 
01146    res = ast_pthread_create_stack(thread, attr, start_routine, data, 
01147                                   stacksize, file, caller, line, start_fn);
01148 
01149    if (attr_destroy)
01150       pthread_attr_destroy(attr);
01151 
01152    return res;
01153 }

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 1082 of file utils.c.

References ast_alloca, ast_asprintf, ast_log(), ast_malloc, AST_STACKSIZE, thr_arg::data, dummy_start(), errno, LOG_WARNING, thr_arg::name, pthread_create, and thr_arg::start_routine.

Referenced by ast_pthread_create_detached_stack().

01085 {
01086 #if !defined(LOW_MEMORY)
01087    struct thr_arg *a;
01088 #endif
01089 
01090    if (!attr) {
01091       attr = ast_alloca(sizeof(*attr));
01092       pthread_attr_init(attr);
01093    }
01094 
01095 #ifdef __linux__
01096    /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
01097       which is kind of useless. Change this here to
01098       PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
01099       priority will propagate down to new threads by default.
01100       This does mean that callers cannot set a different priority using
01101       PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
01102       the priority afterwards with pthread_setschedparam(). */
01103    if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
01104       ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
01105 #endif
01106 
01107    if (!stacksize)
01108       stacksize = AST_STACKSIZE;
01109 
01110    if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
01111       ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
01112 
01113 #if !defined(LOW_MEMORY)
01114    if ((a = ast_malloc(sizeof(*a)))) {
01115       a->start_routine = start_routine;
01116       a->data = data;
01117       start_routine = dummy_start;
01118       if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()",
01119               start_fn, line, file, caller) < 0) {
01120          a->name = NULL;
01121       }
01122       data = a;
01123    }
01124 #endif /* !LOW_MEMORY */
01125 
01126    return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
01127 }

long int ast_random ( void   ) 

Definition at line 1522 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(), ast_udptl_new_with_bindaddr(), auth_http_callback(), authenticate_request(), build_gateway(), build_iv(), build_rand_pad(), build_reply_digest(), calc_metric(), calc_rxstamp(), caldav_write_event(), callno_hash(), create_channel_name(), generate_exchange_uuid(), generate_random_string(), generic_http_callback(), get_trans_id(), gtalk_alloc(), gtalk_create_candidates(), gtalk_new(), handle_incoming(), handle_response_invite(), iax2_key_rotate(), iax2_start_transfer(), jingle_alloc(), jingle_create_candidates(), jingle_new(), load_module(), make_email_file(), make_our_tag(), moh_files_alloc(), multicast_rtp_new(), 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(), try_calling(), and try_firmware().

01523 {
01524    long int res;
01525 #ifdef HAVE_DEV_URANDOM
01526    if (dev_urandom_fd >= 0) {
01527       int read_res = read(dev_urandom_fd, &res, sizeof(res));
01528       if (read_res > 0) {
01529          long int rm = RAND_MAX;
01530          res = res < 0 ? ~res : res;
01531          rm++;
01532          return res % rm;
01533       }
01534    }
01535 #endif
01536 #ifdef linux
01537    res = random();
01538 #else
01539    ast_mutex_lock(&randomlock);
01540    res = random();
01541    ast_mutex_unlock(&randomlock);
01542 #endif
01543    return res;
01544 }

int ast_remaining_ms ( struct timeval  start,
int  max_ms 
)

Calculate remaining milliseconds given a starting timestamp and upper bound.

If the upper bound is negative, then this indicates that there is no upper bound on the amount of time to wait. This will result in a negative return.

Parameters:
start When timing started being calculated
max_ms The maximum number of milliseconds to wait from start. May be negative.
Returns:
The number of milliseconds left to wait for. May be negative.

Definition at line 1497 of file utils.c.

References ast_tvdiff_ms(), and ast_tvnow().

Referenced by __analog_ss_thread(), __ast_answer(), __ast_request_and_dial(), agent_ack_sleep(), analog_ss_thread(), ast_recvtext(), ast_safe_sleep_conditional(), ast_waitfordigit_full(), async_wait(), dahdi_bridge(), disable_t38(), find_cache(), generic_fax_exec(), local_bridge_loop(), receivefax_t38_init(), record_exec(), remote_bridge_loop(), sendfax_t38_init(), wait_for_answer(), and waitforring_exec().

01498 {
01499    int ms;
01500 
01501    if (max_ms < 0) {
01502       ms = max_ms;
01503    } else {
01504       ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start);
01505       if (ms < 0) {
01506          ms = 0;
01507       }
01508    }
01509 
01510    return ms;
01511 }

void ast_sha1_hash ( char *  output,
const char *  input 
)

Produce 40 char SHA1 hash of value.

Produces SHA1 hash based on input string.

Definition at line 253 of file utils.c.

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

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

00254 {
00255    struct SHA1Context sha;
00256    char *ptr;
00257    int x;
00258    uint8_t Message_Digest[20];
00259 
00260    SHA1Reset(&sha);
00261    
00262    SHA1Input(&sha, (const unsigned char *) input, strlen(input));
00263 
00264    SHA1Result(&sha, Message_Digest);
00265    ptr = output;
00266    for (x = 0; x < 20; x++)
00267       ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
00268 }

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 1313 of file utils.c.

References ast_strip().

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

01314 {
01315    char *e;
01316    char *q;
01317 
01318    s = ast_strip(s);
01319    if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
01320       e = s + strlen(s) - 1;
01321       if (*e == *(end_quotes + (q - beg_quotes))) {
01322          s++;
01323          *e = '\0';
01324       }
01325    }
01326 
01327    return s;
01328 }

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 1415 of file utils.c.

References ast_strlen_zero().

Referenced by __ast_http_load(), __ast_udptl_reload(), __init_manager(), _parse(), acf_curlopt_write(), acf_faxopt_write(), acf_transaction_write(), action_agent_logoff(), action_bridge(), action_originate(), action_updateconfig(), actual_load_config(), aji_create_client(), aji_load_config(), aoc_cli_debug_enable(), apply_general_options(), apply_option(), apply_outgoing(), ast_bridge_timelimit(), ast_jb_read_conf(), AST_LIST_HEAD_NOLOCK(), ast_plc_reload(), ast_readconfig(), ast_tls_read_conf(), autopause2int(), build_device(), build_gateway(), build_peer(), build_user(), config_parse_variables(), dahdi_set_dnd(), data_search_cmp_bool(), do_reload(), festival_exec(), func_channel_write_real(), func_inheritance_write(), func_mute_write(), get_encrypt_methods(), gtalk_load_config(), handle_common_options(), handle_logger_set_level(), handle_memory_atexit_list(), handle_t38_options(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), local_ast_moh_start(), login_exec(), manager_add_queue_member(), manager_mutestream(), manager_pause_queue_member(), message_template_build(), misdn_answer(), odbc_load_module(), osp_load(), osplookup_exec(), parkinglot_config_read(), parse_config(), parse_empty_options(), pbx_load_config(), pbx_load_users(), process_config(), process_dahdi(), process_echocancel(), queue_set_global_params(), queue_set_param(), read_agent_config(), realtime_directory(), reload_config(), rtp_reload(), run_startup_commands(), search_directory(), set_active(), set_config(), sla_load_config(), smdi_load(), speex_write(), stackpeek_read(), start_monitor_action(), strings_to_mask(), tds_load_module(), update_common_options(), xmldoc_get_syntax_cmd(), xmldoc_get_syntax_fun(), and xmldoc_get_syntax_manager().

01416 {
01417    if (ast_strlen_zero(s))
01418       return 0;
01419 
01420    /* Determine if this is a true value */
01421    if (!strcasecmp(s, "yes") ||
01422        !strcasecmp(s, "true") ||
01423        !strcasecmp(s, "y") ||
01424        !strcasecmp(s, "t") ||
01425        !strcasecmp(s, "1") ||
01426        !strcasecmp(s, "on"))
01427       return -1;
01428 
01429    return 0;
01430 }

struct timeval ast_tvadd ( struct timeval  a,
struct timeval  b 
) [read]
struct timeval ast_tvsub ( struct timeval  a,
struct timeval  b 
) [read]

Returns the difference of two timevals a - b.

Definition at line 1483 of file utils.c.

References ONE_MILLION, and tvfix().

Referenced by ast_channel_bridge(), ast_poll2(), ast_sched_dump(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), debug_check_frame_for_silence(), handle_showcalls(), and handle_showuptime().

01484 {
01485    /* consistency checks to guarantee usec in 0..999999 */
01486    a = tvfix(a);
01487    b = tvfix(b);
01488    a.tv_sec -= b.tv_sec;
01489    a.tv_usec -= b.tv_usec;
01490    if (a.tv_usec < 0) {
01491       a.tv_sec-- ;
01492       a.tv_usec += ONE_MILLION;
01493    }
01494    return a;
01495 }

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 1349 of file utils.c.

Referenced by ast_parse_digest().

01350 {
01351    char c, *ret, *dst;
01352 
01353    if (src == NULL)
01354       return NULL;
01355    for (ret = dst = src; (c = *src++); *dst++ = c ) {
01356       if (c != '\\')
01357          continue;   /* copy char at the end of the loop */
01358       switch ((c = *src++)) {
01359       case '\0':  /* special, trailing '\' */
01360          c = '\\';
01361          break;
01362       case 'b':   /* backspace */
01363          c = '\b';
01364          break;
01365       case 'f':   /* form feed */
01366          c = '\f';
01367          break;
01368       case 'n':
01369          c = '\n';
01370          break;
01371       case 'r':
01372          c = '\r';
01373          break;
01374       case 't':
01375          c = '\t';
01376          break;
01377       }
01378       /* default, use the char literally */
01379    }
01380    *dst = '\0';
01381    return ret;
01382 }

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 1330 of file utils.c.

Referenced by sip_cli_notify().

01331 {
01332    char *e;
01333    char *work = s;
01334 
01335    while ((e = strchr(work, ';'))) {
01336       if ((e > work) && (*(e-1) == '\\')) {
01337          memmove(e - 1, e, strlen(e) + 1);
01338          work = e;
01339       } else {
01340          work = e + 1;
01341       }
01342    }
01343 
01344    return s;
01345 }

void ast_uri_decode ( char *  s  ) 

ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)

Decode URI, URN, URL (overwrite string).

Definition at line 454 of file utils.c.

Referenced by acf_curl_helper(), config_curl(), get_destination(), get_name_and_number(), get_refer_info(), handle_request_invite(), http_decode(), parse_moved_contact(), realtime_curl(), realtime_multi_curl(), sip_new(), sip_uri_cmp(), and uridecode().

00455 {
00456    char *o;
00457    unsigned int tmp;
00458 
00459    for (o = s; *s; s++, o++) {
00460       if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) {
00461          /* have '%', two chars and correct parsing */
00462          *o = tmp;
00463          s += 2;  /* Will be incremented once more when we break out */
00464       } else /* all other cases, just copy */
00465          *o = *s;
00466    }
00467    *o = '\0';
00468 }

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

Turn text string to URI-encoded XX version.

Note:
At this point, this function is encoding agnostic; it does not check whether it is fed legal UTF-8. We escape control characters (-), '', and all characters above 0x7F. If do_special_char == 1 we will convert all characters except alnum and mark. 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.

Definition at line 390 of file utils.c.

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

00391 {
00392    const char *ptr  = string; /* Start with the string */
00393    char *out = outbuf;
00394    const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */
00395 
00396    while (*ptr && out - outbuf < buflen - 1) {
00397       if ((const signed char) *ptr < 32 || *ptr == 0x7f || *ptr == '%' ||
00398             (do_special_char &&
00399             !(*ptr >= '0' && *ptr <= '9') &&      /* num */
00400             !(*ptr >= 'A' && *ptr <= 'Z') &&      /* ALPHA */
00401             !(*ptr >= 'a' && *ptr <= 'z') &&      /* alpha */
00402             !strchr(mark, *ptr))) {               /* mark set */
00403          if (out - outbuf >= buflen - 3) {
00404             break;
00405          }
00406 
00407          out += sprintf(out, "%%%02X", (unsigned char) *ptr);
00408       } else {
00409          *out = *ptr;   /* Continue copying the string */
00410          out++;
00411       }
00412       ptr++;
00413    }
00414 
00415    if (buflen) {
00416       *out = '\0';
00417    }
00418 
00419    return outbuf;
00420 }

int ast_utils_init ( void   ) 

Definition at line 2048 of file utils.c.

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

Referenced by main().

02049 {
02050 #ifdef HAVE_DEV_URANDOM
02051    dev_urandom_fd = open("/dev/urandom", O_RDONLY);
02052 #endif
02053    base64_init();
02054 #ifdef DEBUG_THREADS
02055 #if !defined(LOW_MEMORY)
02056    ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
02057 #endif
02058 #endif
02059    return 0;
02060 }

char* ast_utils_which ( const char *  binary,
char *  fullpath,
size_t  fullpath_size 
)

Resolve a binary to a full pathname.

Parameters:
binary Name of the executable to resolve
fullpath Buffer to hold the complete pathname
fullpath_size Size of fullpath
Return values:
NULL binary was not found or the environment variable PATH is not set
Returns:
fullpath

Definition at line 2200 of file utils.c.

References ast_strdupa.

Referenced by ast_bt_get_symbols().

02201 {
02202    const char *envPATH = getenv("PATH");
02203    char *tpath, *path;
02204    struct stat unused;
02205    if (!envPATH) {
02206       return NULL;
02207    }
02208    tpath = ast_strdupa(envPATH);
02209    while ((path = strsep(&tpath, ":"))) {
02210       snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
02211       if (!stat(fullpath, &unused)) {
02212          return fullpath;
02213       }
02214    }
02215    return NULL;
02216 }

int ast_wait_for_input ( int  fd,
int  ms 
)

Definition at line 1155 of file utils.c.

References ast_poll.

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

01156 {
01157    struct pollfd pfd[1];
01158    memset(pfd, 0, sizeof(pfd));
01159    pfd[0].fd = fd;
01160    pfd[0].events = POLLIN|POLLPRI;
01161    return ast_poll(pfd, 1, ms);
01162 }

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

Definition at line 1164 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().

01165 {
01166    struct pollfd pfd = {
01167       .fd = fd,
01168       .events = POLLOUT,
01169    };
01170    int res;
01171    struct timeval start = ast_tvnow();
01172    int elapsed = 0;
01173 
01174    /* poll() until the fd is writable without blocking */
01175    while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
01176       if (res == 0) {
01177          /* timed out. */
01178 #ifndef STANDALONE
01179          ast_debug(1, "Timed out trying to write\n");
01180 #endif
01181          return -1;
01182       } else if (res == -1) {
01183          /* poll() returned an error, check to see if it was fatal */
01184 
01185          if (errno == EINTR || errno == EAGAIN) {
01186             elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01187             if (elapsed >= timeoutms) {
01188                return -1;
01189             }
01190             /* This was an acceptable error, go back into poll() */
01191             continue;
01192          }
01193 
01194          /* Fatal error, bail. */
01195          ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
01196 
01197          return -1;
01198       }
01199       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
01200       if (elapsed >= timeoutms) {
01201          return -1;
01202       }
01203    }
01204 
01205    return 0;
01206 }

int ast_xml_escape ( const char *  string,
char *  outbuf,
size_t  buflen 
)

Escape reserved characters for use in XML.

ast_xml_escape If outbuf is too short, the output string will be truncated. Regardless, the output will always be null terminated.

Parameters:
string String to be converted
outbuf Resulting encoded string
buflen Size of output buffer
Returns:
0 for success
-1 if buflen is too short.

Definition at line 470 of file utils.c.

References ast_assert, entity, and len().

Referenced by state_notify_build_xml().

00471 {
00472    char *dst = outbuf;
00473    char *end = outbuf + buflen - 1; /* save one for the null terminator */
00474 
00475    /* Handle the case for the empty output buffer */
00476    if (buflen == 0) {
00477       return -1;
00478    }
00479 
00480    /* Escaping rules from http://www.w3.org/TR/REC-xml/#syntax */
00481    /* This also prevents partial entities at the end of a string */
00482    while (*string && dst < end) {
00483       const char *entity = NULL;
00484       int len = 0;
00485 
00486       switch (*string) {
00487       case '<':
00488          entity = "&lt;";
00489          len = 4;
00490          break;
00491       case '&':
00492          entity = "&amp;";
00493          len = 5;
00494          break;
00495       case '>':
00496          /* necessary if ]]> is in the string; easier to escape them all */
00497          entity = "&gt;";
00498          len = 4;
00499          break;
00500       case '\'':
00501          /* necessary in single-quoted strings; easier to escape them all */
00502          entity = "&apos;";
00503          len = 6;
00504          break;
00505       case '"':
00506          /* necessary in double-quoted strings; easier to escape them all */
00507          entity = "&quot;";
00508          len = 6;
00509          break;
00510       default:
00511          *dst++ = *string++;
00512          break;
00513       }
00514 
00515       if (entity) {
00516          ast_assert(len == strlen(entity));
00517          if (end - dst < len) {
00518             /* no room for the entity; stop */
00519             break;
00520          }
00521          /* just checked for length; strcpy is fine */
00522          strcpy(dst, entity);
00523          dst += len;
00524          ++string;
00525       }
00526    }
00527    /* Write null terminator */
00528    *dst = '\0';
00529    /* If any chars are left in string, return failure */
00530    return *string == '\0' ? 0 : -1;
00531 }

static void base64_init ( void   )  [static]

Definition at line 354 of file utils.c.

Referenced by ast_utils_init().

00355 {
00356    int x;
00357    memset(b2a, -1, sizeof(b2a));
00358    /* Initialize base-64 Conversion table */
00359    for (x = 0; x < 26; x++) {
00360       /* A-Z */
00361       base64[x] = 'A' + x;
00362       b2a['A' + x] = x;
00363       /* a-z */
00364       base64[x + 26] = 'a' + x;
00365       b2a['a' + x] = x + 26;
00366       /* 0-9 */
00367       if (x < 10) {
00368          base64[x + 52] = '0' + x;
00369          b2a['0' + x] = x + 52;
00370       }
00371    }
00372    base64[62] = '+';
00373    base64[63] = '/';
00374    b2a[(int)'+'] = 62;
00375    b2a[(int)'/'] = 63;
00376 }

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

Definition at line 1040 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, thr_arg::name, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, thr_arg::start_routine, and strdup.

Referenced by ast_pthread_create_stack().

01041 {
01042    void *ret;
01043    struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
01044 #ifdef DEBUG_THREADS
01045    struct thr_lock_info *lock_info;
01046    pthread_mutexattr_t mutex_attr;
01047 
01048    if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
01049       return NULL;
01050 
01051    lock_info->thread_id = pthread_self();
01052    lock_info->thread_name = strdup(a.name);
01053 
01054    pthread_mutexattr_init(&mutex_attr);
01055    pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
01056    pthread_mutex_init(&lock_info->lock, &mutex_attr);
01057    pthread_mutexattr_destroy(&mutex_attr);
01058 
01059    pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
01060    AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
01061    pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
01062 #endif /* DEBUG_THREADS */
01063 
01064    /* note that even though data->name is a pointer to allocated memory,
01065       we are not freeing it here because ast_register_thread is going to
01066       keep a copy of the pointer and then ast_unregister_thread will
01067       free the memory
01068    */
01069    ast_free(data);
01070    ast_register_thread(a.name);
01071    pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
01072 
01073    ret = a.start_routine(a.data);
01074 
01075    pthread_cleanup_pop(1);
01076 
01077    return ret;
01078 }

static size_t optimal_alloc_size ( size_t  size  )  [static]

Definition at line 1611 of file utils.c.

References ALLOCATOR_OVERHEAD.

Referenced by __ast_calloc_with_stringfields(), and add_string_pool().

01612 {
01613    unsigned int count;
01614 
01615    size += ALLOCATOR_OVERHEAD;
01616 
01617    for (count = 1; size; size >>= 1, count++);
01618 
01619    return (1 << count) - ALLOCATOR_OVERHEAD;
01620 }

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

Definition at line 1454 of file utils.c.

References ast_log(), LOG_WARNING, and ONE_MILLION.

Referenced by ast_tvadd(), and ast_tvsub().

01455 {
01456    if (a.tv_usec >= ONE_MILLION) {
01457       ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
01458          (long)a.tv_sec, (long int) a.tv_usec);
01459       a.tv_sec += a.tv_usec / ONE_MILLION;
01460       a.tv_usec %= ONE_MILLION;
01461    } else if (a.tv_usec < 0) {
01462       ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
01463          (long)a.tv_sec, (long int) a.tv_usec);
01464       a.tv_usec = 0;
01465    }
01466    return a;
01467 }


Variable Documentation

Definition at line 1607 of file utils.c.

struct { ... } __ast_string_field_empty_buffer [static]

Definition at line 1603 of file utils.c.

Referenced by __ast_calloc_with_stringfields().

char b2a[256] [static]

Definition at line 71 of file utils.c.

char base64[64] [static]

Definition at line 70 of file utils.c.

Referenced by aji_start_sasl().

int dev_urandom_fd [static]

Definition at line 545 of file utils.c.

ast_mutex_t fetchadd_m = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static]

Definition at line 1938 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 73 of file utils.c.

Referenced by ast_inet_ntoa().

ast_mutex_t randomlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static]

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

Definition at line 1519 of file utils.c.

Referenced by ast_random().

char string[1]

Definition at line 1604 of file utils.c.

Referenced by private_enum_init().


Generated on 20 Aug 2013 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1