Thu Oct 11 06:44:29 2012

Asterisk developer's documentation


utils.c File Reference

Utility functions. More...

#include "asterisk.h"
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include "asterisk/lock.h"
#include "asterisk/io.h"
#include "asterisk/logger.h"
#include "asterisk/md5.h"
#include "asterisk/sha1.h"
#include "asterisk/options.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 dependency graph for utils.c:

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 ONE_MILLION   1000000

Functions

ast_string_field __ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, size_t needed, ast_string_field *fields, int num_fields)
void __ast_string_field_index_build (struct ast_string_field_mgr *mgr, ast_string_field *fields, int num_fields, int index, const char *format,...)
void __ast_string_field_index_build_va (struct ast_string_field_mgr *mgr, ast_string_field *fields, int num_fields, int index, const char *format, va_list ap1, va_list ap2)
int __ast_string_field_init (struct ast_string_field_mgr *mgr, size_t size, ast_string_field *fields, int num_fields)
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, size_t size)
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)
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_carefulwrite (int fd, char *s, int len, int timeoutms)
 Try to write string, but wait no more than ms milliseconds before timing out.
int ast_dynamic_str_thread_build_va (struct ast_dynamic_str **buf, size_t max_len, struct ast_threadstorage *ts, int append, const char *fmt, va_list ap)
 Core functionality of ast_dynamic_str_thread_(set|append)_va.
void ast_enable_packet_fragmentation (int sock)
 Disable PMTU discovery on a socket.
int ast_false (const char *s)
int ast_get_time_t (const char *src, time_t *dst, time_t _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, char *const w[])
void ast_md5_hash (char *output, char *input)
 Produce 32 char MD5 hash of value.
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_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)
 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)
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_semicolon (char *s)
 Strip backslash for "escaped" semicolons.
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 doreserved)
 ast_uri_encode: 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 void base64_init (void)
static void * dummy_start (void *data)
static void inet_ntoa_buf_init (void)
static struct timeval tvfix (struct timeval a)

Variables

const char __ast_string_field_empty [] = ""
static char b2a [256]
static char base64 [64]
static ast_mutex_t fetchadd_m = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER )
static struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = inet_ntoa_buf_init , }
static ast_mutex_t randomlock = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER )
 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 65 of file utils.c.

#define AST_API_MODULE

Definition at line 65 of file utils.c.

#define AST_API_MODULE

Definition at line 65 of file utils.c.

#define AST_API_MODULE

Definition at line 65 of file utils.c.

#define AST_API_MODULE

Definition at line 65 of file utils.c.

#define AST_API_MODULE

Definition at line 65 of file utils.c.

#define ONE_MILLION   1000000

Definition at line 1093 of file utils.c.

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


Function Documentation

ast_string_field __ast_string_field_alloc_space ( struct ast_string_field_mgr mgr,
size_t  needed,
ast_string_field fields,
int  num_fields 
)

Definition at line 1235 of file utils.c.

References add_string_pool(), ast_string_field_pool::base, ast_string_field_mgr::pool, ast_string_field_mgr::size, ast_string_field_mgr::space, and ast_string_field_mgr::used.

01237 {
01238    char *result = NULL;
01239 
01240    if (__builtin_expect(needed > mgr->space, 0)) {
01241       size_t new_size = mgr->size * 2;
01242 
01243       while (new_size < needed)
01244          new_size *= 2;
01245 
01246       if (add_string_pool(mgr, new_size))
01247          return NULL;
01248    }
01249 
01250    result = mgr->pool->base + mgr->used;
01251    mgr->used += needed;
01252    mgr->space -= needed;
01253    return result;
01254 }

void __ast_string_field_index_build ( struct ast_string_field_mgr mgr,
ast_string_field fields,
int  num_fields,
int  index,
const char *  format,
  ... 
)

Definition at line 1310 of file utils.c.

References __ast_string_field_index_build_va().

01313 {
01314    va_list ap1, ap2;
01315 
01316    va_start(ap1, format);
01317    va_start(ap2, format);     /* va_copy does not exist on FreeBSD */
01318 
01319    __ast_string_field_index_build_va(mgr, fields, num_fields, index, format, ap1, ap2);
01320 
01321    va_end(ap1);
01322    va_end(ap2);
01323 }

void __ast_string_field_index_build_va ( struct ast_string_field_mgr mgr,
ast_string_field fields,
int  num_fields,
int  index,
const char *  format,
va_list  ap1,
va_list  ap2 
)

Definition at line 1256 of file utils.c.

References add_string_pool(), available(), ast_string_field_pool::base, ast_string_field_mgr::pool, ast_string_field_mgr::size, ast_string_field_mgr::space, and ast_string_field_mgr::used.

Referenced by __ast_string_field_index_build().

01259 {
01260    size_t needed;
01261    size_t available;
01262    char *target;
01263 
01264    /* if the field already has space allocated, try to reuse it;
01265       otherwise, use the empty space at the end of the current
01266       pool
01267    */
01268    if (fields[index][0] != '\0') {
01269       target = (char *) fields[index];
01270       available = strlen(fields[index]) + 1;
01271    } else {
01272       target = mgr->pool->base + mgr->used;
01273       available = mgr->space;
01274    }
01275 
01276    needed = vsnprintf(target, available, format, ap1) + 1;
01277 
01278    va_end(ap1);
01279 
01280    if (needed > available) {
01281       /* if the space needed can be satisfied by using the current
01282          pool (which could only occur if we tried to use the field's
01283          allocated space and failed), then use that space; otherwise
01284          allocate a new pool
01285       */
01286       if (needed <= mgr->space) {
01287          target = mgr->pool->base + mgr->used;
01288       } else {
01289          size_t new_size = mgr->size * 2;
01290 
01291          while (new_size < needed)
01292             new_size *= 2;
01293          
01294          if (add_string_pool(mgr, new_size))
01295             return;
01296          
01297          target = mgr->pool->base + mgr->used;
01298       }
01299 
01300       vsprintf(target, format, ap2);
01301    }
01302 
01303    if (fields[index] != target) {
01304       fields[index] = target;
01305       mgr->used += needed;
01306       mgr->space -= needed;
01307    }
01308 }

int __ast_string_field_init ( struct ast_string_field_mgr mgr,
size_t  size,
ast_string_field fields,
int  num_fields 
)

Definition at line 1221 of file utils.c.

References __ast_string_field_empty, and add_string_pool().

01223 {
01224    int index;
01225 
01226    if (add_string_pool(mgr, size))
01227       return -1;
01228 
01229    for (index = 0; index < num_fields; index++)
01230       fields[index] = __ast_string_field_empty;
01231 
01232    return 0;
01233 }

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

Definition at line 1430 of file utils.c.

References MALLOC_FAILURE_MSG, and vasprintf.

01431 {
01432    int res;
01433    va_list ap;
01434 
01435    va_start(ap, fmt);
01436    if ((res = vasprintf(ret, fmt, ap)) == -1) {
01437       MALLOC_FAILURE_MSG;
01438    }
01439    va_end(ap);
01440 
01441    return res;
01442 }

static int add_string_pool ( struct ast_string_field_mgr mgr,
size_t  size 
) [static]

Definition at line 1205 of file utils.c.

References ast_calloc, ast_string_field_mgr::pool, ast_string_field_pool::prev, ast_string_field_mgr::size, ast_string_field_mgr::space, and ast_string_field_mgr::used.

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

01206 {
01207    struct ast_string_field_pool *pool;
01208 
01209    if (!(pool = ast_calloc(1, sizeof(*pool) + size)))
01210       return -1;
01211    
01212    pool->prev = mgr->pool;
01213    mgr->pool = pool;
01214    mgr->size = size;
01215    mgr->space = size;
01216    mgr->used = 0;
01217 
01218    return 0;
01219 }

int ast_atomic_fetchadd_int_slow ( volatile int *  p,
int  v 
)

Definition at line 1327 of file utils.c.

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

01328 {
01329         int ret;
01330         ast_mutex_lock(&fetchadd_m);
01331         ret = *p;
01332         *p += v;
01333         ast_mutex_unlock(&fetchadd_m);
01334         return ret;
01335 }

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

decode BASE64 encoded text

Definition at line 267 of file utils.c.

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

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

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

Definition at line 345 of file utils.c.

References ast_base64encode_full().

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

00346 {
00347    return ast_base64encode_full(dst, src, srclen, max, 0);
00348 }

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

encode text to BASE64 coding

Definition at line 294 of file utils.c.

Referenced by ast_base64encode().

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

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

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.

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
Returns:
0 on success, non-zero on failure.

Definition at line 1047 of file utils.c.

References ast_build_string_va().

Referenced by __queues_show(), add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), ast_cdr_serialize_variables(), ast_http_setcookie(), config_odbc(), config_pgsql(), function_realtime_read(), generic_http_callback(), html_translate(), httpstatus_callback(), initreqprep(), pbx_builtin_serialize_variables(), print_uptimestr(), show_translation(), show_translation_deprecated(), transmit_notify_with_mwi(), transmit_state_notify(), and xml_translate().

01048 {
01049    va_list ap;
01050    int result;
01051 
01052    va_start(ap, fmt);
01053    result = ast_build_string_va(buffer, space, fmt, ap);
01054    va_end(ap);
01055 
01056    return result;
01057 }

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

Referenced by ast_build_string().

01029 {
01030    int result;
01031 
01032    if (!buffer || !*buffer || !space || !*space)
01033       return -1;
01034 
01035    result = vsnprintf(*buffer, *space, fmt, ap);
01036 
01037    if (result < 0)
01038       return -1;
01039    else if (result > *space)
01040       result = *space;
01041 
01042    *buffer += result;
01043    *space -= result;
01044    return 0;
01045 }

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.

ast_carefulwrite

Note:
If you are calling ast_carefulwrite, it is assumed that you are calling it on a file descriptor that _DOES_ have NONBLOCK set. This way, 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.

Definition at line 922 of file utils.c.

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

Referenced by agi_debug_cli(), ast_cli(), astman_append(), and process_events().

00923 {
00924    struct timeval start = ast_tvnow();
00925    int res = 0;
00926    int elapsed = 0;
00927 
00928    while (len) {
00929       struct pollfd pfd = {
00930          .fd = fd,
00931          .events = POLLOUT,
00932       };
00933 
00934       /* poll() until the fd is writable without blocking */
00935       while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
00936          if (res == 0) {
00937             /* timed out. */
00938             if (option_debug) {
00939                ast_log(LOG_DEBUG, "Timed out trying to write\n");
00940             }
00941             return -1;
00942          } else if (res == -1) {
00943             /* poll() returned an error, check to see if it was fatal */
00944 
00945             if (errno == EINTR || errno == EAGAIN) {
00946                elapsed = ast_tvdiff_ms(ast_tvnow(), start);
00947                if (elapsed > timeoutms) {
00948                   /* We've taken too long to write 
00949                    * This is only an error condition if we haven't finished writing. */
00950                   res = len ? -1 : 0;
00951                   break;
00952                }
00953                /* This was an acceptable error, go back into poll() */
00954                continue;
00955             }
00956 
00957             /* Fatal error, bail. */
00958             ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));
00959 
00960             return -1;
00961          }
00962       }
00963 
00964       res = write(fd, s, len);
00965 
00966       if (res < 0 && errno != EAGAIN && errno != EINTR) {
00967          /* fatal error from write() */
00968          ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
00969          return -1;
00970       }
00971 
00972       if (res < 0) {
00973          /* It was an acceptable error */
00974          res = 0;
00975       }
00976 
00977       /* Update how much data we have left to write */
00978       len -= res;
00979       s += res;
00980       res = 0;
00981 
00982       elapsed = ast_tvdiff_ms(ast_tvnow(), start);
00983       if (elapsed > timeoutms) {
00984          /* We've taken too long to write 
00985           * This is only an error condition if we haven't finished writing. */
00986          res = len ? -1 : 0;
00987          break;
00988       }
00989    }
00990 
00991    return res;
00992 }

int ast_dynamic_str_thread_build_va ( struct ast_dynamic_str **  buf,
size_t  max_len,
struct ast_threadstorage ts,
int  append,
const char *  fmt,
va_list  ap 
)

Core functionality of ast_dynamic_str_thread_(set|append)_va.

The arguments to this function are the same as those described for ast_dynamic_str_thread_set_va except for an addition argument, append. If append is non-zero, this will append to the current string instead of writing over it.

Definition at line 1363 of file utils.c.

References AST_DYNSTR_BUILD_FAILED, AST_DYNSTR_BUILD_RETRY, ast_realloc, ast_threadstorage::key, ast_dynamic_str::len, and offset.

01365 {
01366    int res;
01367    int offset = (append && (*buf)->len) ? strlen((*buf)->str) : 0;
01368 #if defined(DEBUG_THREADLOCALS)
01369    struct ast_dynamic_str *old_buf = *buf;
01370 #endif /* defined(DEBUG_THREADLOCALS) */
01371 
01372    res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap);
01373 
01374    /* Check to see if there was not enough space in the string buffer to prepare
01375     * the string.  Also, if a maximum length is present, make sure the current
01376     * length is less than the maximum before increasing the size. */
01377    if ((res + offset + 1) > (*buf)->len && (max_len ? ((*buf)->len < max_len) : 1)) {
01378       /* Set the new size of the string buffer to be the size needed
01379        * to hold the resulting string (res) plus one byte for the
01380        * terminating '\0'.  If this size is greater than the max, set
01381        * the new length to be the maximum allowed. */
01382       if (max_len)
01383          (*buf)->len = ((res + offset + 1) < max_len) ? (res + offset + 1) : max_len;
01384       else
01385          (*buf)->len = res + offset + 1;
01386 
01387       if (!(*buf = ast_realloc(*buf, (*buf)->len + sizeof(*(*buf)))))
01388          return AST_DYNSTR_BUILD_FAILED;
01389 
01390       if (append)
01391          (*buf)->str[offset] = '\0';
01392 
01393       if (ts) {
01394          pthread_setspecific(ts->key, *buf);
01395 #if defined(DEBUG_THREADLOCALS)
01396          __ast_threadstorage_object_replace(old_buf, *buf, (*buf)->len + sizeof(*(*buf)));
01397 #endif /* defined(DEBUG_THREADLOCALS) */
01398       }
01399 
01400       /* va_end() and va_start() must be done before calling
01401        * vsnprintf() again. */
01402       return AST_DYNSTR_BUILD_RETRY;
01403    }
01404 
01405    return res;
01406 }

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

References ast_log(), and LOG_WARNING.

Referenced by ast_netsock_bindaddr(), and reload_config().

01409 {
01410 #if defined(HAVE_IP_MTU_DISCOVER)
01411    int val = IP_PMTUDISC_DONT;
01412    
01413    if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
01414       ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
01415 #endif /* HAVE_IP_MTU_DISCOVER */
01416 }

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".

Returns 0 if val is a NULL pointer, -1 if "false", and 0 otherwise.

Definition at line 1076 of file utils.c.

References ast_strlen_zero().

Referenced by aji_create_client(), aji_load_config(), ast_readconfig(), ast_rtp_reload(), ast_udptl_reload(), build_peer(), build_user(), handle_common_options(), init_acf_query(), load_config(), load_odbc_config(), reload(), reload_config(), run_agi(), set_config(), set_insecure_flags(), sla_build_trunk(), and strings_to_mask().

01077 {
01078    if (ast_strlen_zero(s))
01079       return 0;
01080 
01081    /* Determine if this is a false value */
01082    if (!strcasecmp(s, "no") ||
01083        !strcasecmp(s, "false") ||
01084        !strcasecmp(s, "n") ||
01085        !strcasecmp(s, "f") ||
01086        !strcasecmp(s, "0") ||
01087        !strcasecmp(s, "off"))
01088       return -1;
01089 
01090    return 0;
01091 }

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

get values from config variables.

Definition at line 1340 of file utils.c.

References ast_strlen_zero(), and t.

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

01341 {
01342    long t;
01343    int scanned;
01344 
01345    if (dst == NULL)
01346       return -1;
01347 
01348    *dst = _default;
01349 
01350    if (ast_strlen_zero(src))
01351       return -1;
01352 
01353    /* only integer at the moment, but one day we could accept more formats */
01354    if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
01355       *dst = t;
01356       if (consumed)
01357          *consumed = scanned;
01358       return 0;
01359    } else
01360       return -1;
01361 }

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

Definition at line 185 of file utils.c.

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

Referenced by __ast_http_load(), __set_address_from_contact(), ast_dnsmgr_lookup(), ast_find_ourip(), ast_get_ip_or_srv(), ast_sip_ouraddrfor(), build_peer(), check_via(), create_addr(), dnsmgr_refresh(), festival_exec(), get_ip_and_port_from_sdp(), gtalk_load_config(), gtalk_update_stun(), iax_template_parse(), launch_netscript(), parse_register_contact(), process_sdp(), process_sdp_c(), process_via(), realtime_peer(), realtime_user(), reload_config(), rpt_exec(), rtcp_do_debug_ip(), rtcp_do_debug_ip_deprecated(), rtp_do_debug_ip(), set_config(), set_destination(), sip_devicestate(), sip_do_debug_ip(), and udptl_do_debug_ip().

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

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

References ast_threadstorage_get(), and inet_ntoa_buf.

Referenced by __attempt_transmit(), __find_callno(), __iax2_show_peers(), __sip_show_channels(), __sip_xmit(), _sip_show_peer(), _sip_show_peers(), accept_thread(), add_sdp(), ast_apply_ha(), ast_netsock_bindaddr(), 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_with_duration(), ast_sip_ouraddrfor(), 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_user_full(), check_via(), copy_via_headers(), create_addr_from_peer(), create_dtmf_frame(), dnsmgr_refresh(), 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(), function_sipchaninfo_read(), function_sippeer(), generic_http_callback(), get_input(), gtalk_create_candidates(), gtalk_update_stun(), handle_call_token(), handle_command_response(), handle_error(), handle_open_receive_channel_ack_message(), handle_request(), handle_request_bye(), handle_request_register(), handle_request_subscribe(), handle_response(), handle_response_refer(), handle_show_http(), handle_showmanconn(), http_server_start(), httpstatus_callback(), iax2_ack_registry(), iax2_prov_app(), iax2_show_callnumber_usage(), iax2_show_channels(), iax2_show_peer(), iax2_show_registry(), iax2_trunk_queue(), iax_server(), iax_showframe(), initreqprep(), load_module(), mgcp_show_endpoints(), mgcpsock_read(), oh323_addrcmp_str(), oh323_call(), oh323_set_rtp_peer(), parse_register_contact(), peercnt_add(), peercnt_modify(), peercnt_remove(), process_message(), process_rfc3389(), process_sdp(), 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(), rtcp_do_debug_ip_deprecated(), rtp_do_debug_ip(), sched_delay_remove(), score_address(), send_packet(), send_request(), send_response(), send_trunk(), session_do(), set_config(), set_destination(), set_peercnt_limit(), setup_incoming_call(), sip_do_debug_ip(), sip_do_debug_peer(), sip_handle_t38_reinvite(), sip_poke_peer(), sip_set_rtp_peer(), sip_set_udptl_peer(), sip_show_channel(), sip_show_settings(), sipsock_read(), skinny_session(), skinny_show_devices(), socket_process(), timing_read(), transmit_notify_with_mwi(), udptl_do_debug_ip(), and update_registry().

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

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

Definition at line 1184 of file utils.c.

Referenced by __ast_cli_generator(), __ast_cli_register(), ast_builtins_init(), console_sendtext(), console_sendtext_deprecated(), find_best(), handle_agidumphtml(), handle_help(), handle_showagi(), help1(), and help_workhorse().

01185 {
01186    int x, ofs = 0;
01187    const char *src;
01188 
01189    /* Join words into a string */
01190    if (!s)
01191       return;
01192    for (x = 0; ofs < len && w[x]; x++) {
01193       if (x > 0)
01194          s[ofs++] = ' ';
01195       for (src = w[x]; *src && ofs < len; src++)
01196          s[ofs++] = *src;
01197    }
01198    if (ofs == len)
01199       ofs--;
01200    s[ofs] = '\0';
01201 }

void ast_md5_hash ( char *  output,
char *  input 
)

Produce 32 char MD5 hash of value.

Definition at line 233 of file utils.c.

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

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

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

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

Referenced by handle_context_add_extension(), handle_context_add_extension_deprecated(), and pbx_load_config().

01159 {
01160    char *dataPut = start;
01161    int inEscape = 0;
01162    int inQuotes = 0;
01163 
01164    for (; *start; start++) {
01165       if (inEscape) {
01166          *dataPut++ = *start;       /* Always goes verbatim */
01167          inEscape = 0;
01168       } else {
01169          if (*start == '\\') {
01170             inEscape = 1;      /* Do not copy \ into the data */
01171          } else if (*start == '\'') {
01172             inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
01173          } else {
01174             /* Replace , with |, unless in quotes */
01175             *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
01176          }
01177       }
01178    }
01179    if (start != dataPut)
01180       *dataPut = 0;
01181    return dataPut;
01182 }

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

References 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.

00868 {
00869 #if !defined(LOW_MEMORY)
00870    struct thr_arg *a;
00871 #endif
00872 
00873    if (!attr) {
00874       attr = alloca(sizeof(*attr));
00875       pthread_attr_init(attr);
00876    }
00877 
00878 #ifdef __linux__
00879    /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
00880       which is kind of useless. Change this here to
00881       PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
00882       priority will propagate down to new threads by default.
00883       This does mean that callers cannot set a different priority using
00884       PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
00885       the priority afterwards with pthread_setschedparam(). */
00886    if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
00887       ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
00888 #endif
00889 
00890    if (!stacksize)
00891       stacksize = AST_STACKSIZE;
00892 
00893    if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
00894       ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
00895 
00896 #if !defined(LOW_MEMORY)
00897    if ((a = ast_malloc(sizeof(*a)))) {
00898       a->start_routine = start_routine;
00899       a->data = data;
00900       start_routine = dummy_start;
00901       if (asprintf(&a->name, "%-20s started at [%5d] %s %s()",
00902               start_fn, line, file, caller) < 0) {
00903          ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
00904          a->name = NULL;
00905       }
00906       data = a;
00907    }
00908 #endif /* !LOW_MEMORY */
00909 
00910    return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
00911 }

long int ast_random ( void   ) 

void ast_sha1_hash ( char *  output,
char *  input 
)

Produce 40 char SHA1 hash of value.

Definition at line 249 of file utils.c.

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

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

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

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

References ast_strip().

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

00995 {
00996    char *e;
00997    char *q;
00998 
00999    s = ast_strip(s);
01000    if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
01001       e = s + strlen(s) - 1;
01002       if (*e == *(end_quotes + (q - beg_quotes))) {
01003          s++;
01004          *e = '\0';
01005       }
01006    }
01007 
01008    return s;
01009 }

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".

Returns 0 if val is a NULL pointer, -1 if "true", and 0 otherwise.

Definition at line 1059 of file utils.c.

References ast_strlen_zero().

Referenced by __ast_http_load(), __login_exec(), _parse(), action_agent_callback_login(), action_agent_logoff(), action_originate(), action_setcdruserfield(), action_updateconfig(), aji_create_client(), aji_load_config(), apply_option(), apply_outgoing(), ast_jb_read_conf(), ast_plc_reload(), ast_readconfig(), ast_udptl_reload(), authenticate(), build_device(), build_gateway(), build_peer(), build_user(), connect_link(), do_directory(), do_reload(), festival_exec(), func_inheritance_write(), get_encrypt_methods(), gtalk_load_config(), handle_common_options(), handle_save_dialplan(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), manager_add_queue_member(), manager_pause_queue_member(), misdn_answer(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), process_dahdi(), queue_set_param(), read_agent_config(), reload(), reload_config(), reload_queues(), set_config(), set_insecure_flags(), sla_load_config(), smdi_load(), start_monitor_action(), strings_to_mask(), and update_common_options().

01060 {
01061    if (ast_strlen_zero(s))
01062       return 0;
01063 
01064    /* Determine if this is a true value */
01065    if (!strcasecmp(s, "yes") ||
01066        !strcasecmp(s, "true") ||
01067        !strcasecmp(s, "y") ||
01068        !strcasecmp(s, "t") ||
01069        !strcasecmp(s, "1") ||
01070        !strcasecmp(s, "on"))
01071       return -1;
01072 
01073    return 0;
01074 }

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

Returns the sum of two timevals a + b.

Definition at line 1113 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_generic_bridge(), ast_poll2(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_senddigit_end_with_duration(), ast_sched_runq(), ast_smoother_read(), ast_translate(), calc_timestamp(), do_cdr(), iax2_process_thread(), jb_get_and_deliver(), monmp3thread(), mp3_exec(), mwi_monitor_handler(), NBScat_exec(), sched_settime(), sched_thread(), schedule_delivery(), sla_process_timers(), and smdi_message_wait().

01114 {
01115    /* consistency checks to guarantee usec in 0..999999 */
01116    a = tvfix(a);
01117    b = tvfix(b);
01118    a.tv_sec += b.tv_sec;
01119    a.tv_usec += b.tv_usec;
01120    if (a.tv_usec >= ONE_MILLION) {
01121       a.tv_sec++;
01122       a.tv_usec -= ONE_MILLION;
01123    }
01124    return a;
01125 }

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

Returns the difference of two timevals a - b.

Definition at line 1127 of file utils.c.

References ONE_MILLION, and tvfix().

Referenced by ast_channel_bridge(), ast_poll2(), ast_rwlock_timedrdlock(), ast_rwlock_timedwrlock(), ast_sched_dump(), ast_translate(), calc_rxstamp(), and calc_timestamp().

01128 {
01129    /* consistency checks to guarantee usec in 0..999999 */
01130    a = tvfix(a);
01131    b = tvfix(b);
01132    a.tv_sec -= b.tv_sec;
01133    a.tv_usec -= b.tv_usec;
01134    if (a.tv_usec < 0) {
01135       a.tv_sec-- ;
01136       a.tv_usec += ONE_MILLION;
01137    }
01138    return a;
01139 }

char* ast_unescape_semicolon ( char *  s  ) 

Strip backslash for "escaped" semicolons.

s The string to be stripped (will be modified).

Returns:
The stripped string.

Definition at line 1011 of file utils.c.

Referenced by sip_notify().

01012 {
01013    char *e;
01014    char *work = s;
01015 
01016    while ((e = strchr(work, ';'))) {
01017       if ((e > work) && (*(e-1) == '\\')) {
01018          memmove(e - 1, e, strlen(e) + 1);
01019          work = e;
01020       } else {
01021          work = e + 1;
01022       }
01023    }
01024 
01025    return s;
01026 }

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

Referenced by check_user_full(), get_also_info(), get_destination(), get_refer_info(), handle_request_invite(), handle_uri(), parse_moved_contact(), register_verify(), sip_new(), and uridecode().

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

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

ast_uri_encode: Turn text string to URI-encoded XX version

Turn text string to URI-encoded XX version 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:
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 386 of file utils.c.

Referenced by build_contact(), initreqprep(), and uriencode().

00387 {
00388    char *reserved = ";/?:@&=+$,# "; /* Reserved chars */
00389 
00390    const char *ptr  = string; /* Start with the string */
00391    char *out = outbuf;
00392 
00393    /* If there's no characters to convert, just go through and copy the string */
00394    while (*ptr && out - outbuf < buflen - 1) {
00395       if ((*ptr < 32) || (doreserved && strchr(reserved, *ptr))) {
00396          if (out - outbuf >= buflen - 3) {
00397             break;
00398          }
00399 
00400          out += sprintf(out, "%%%02x", (unsigned char) *ptr);
00401       } else {
00402          *out = *ptr;   /* copy the character */
00403          out++;
00404       }
00405       ptr++;
00406    }
00407 
00408    if (buflen) {
00409       *out = '\0';
00410    }
00411 
00412    return outbuf;
00413 }

int ast_utils_init ( void   ) 

Definition at line 1418 of file utils.c.

References ast_cli_register_multiple(), and base64_init().

Referenced by main().

01419 {
01420    base64_init();
01421 #ifdef DEBUG_THREADS
01422 #if !defined(LOW_MEMORY)
01423    ast_cli_register_multiple(utils_cli, sizeof(utils_cli) / sizeof(utils_cli[0]));
01424 #endif
01425 #endif
01426    return 0;
01427 }

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

References ast_strdupa.

Referenced by ast_backtrace().

01446 {
01447    const char *envPATH = getenv("PATH");
01448    char *tpath, *path;
01449    struct stat unused;
01450    if (!envPATH) {
01451       return NULL;
01452    }
01453    tpath = ast_strdupa(envPATH);
01454    while ((path = strsep(&tpath, ":"))) {
01455       snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
01456       if (!stat(fullpath, &unused)) {
01457          return fullpath;
01458       }
01459    }
01460    return NULL;
01461 }

int ast_wait_for_input ( int  fd,
int  ms 
)

Definition at line 913 of file utils.c.

References ast_poll.

Referenced by action_waitevent(), http_root(), main(), and moh_class_destructor().

00914 {
00915    struct pollfd pfd[1];
00916    memset(pfd, 0, sizeof(pfd));
00917    pfd[0].fd = fd;
00918    pfd[0].events = POLLIN|POLLPRI;
00919    return ast_poll(pfd, 1, ms);
00920 }

static void base64_init ( void   )  [static]

Definition at line 350 of file utils.c.

Referenced by ast_utils_init().

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

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

Definition at line 821 of file utils.c.

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

Referenced by ast_pthread_create_stack().

00822 {
00823    void *ret;
00824    struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
00825 #ifdef DEBUG_THREADS
00826    struct thr_lock_info *lock_info;
00827    pthread_mutexattr_t mutex_attr;
00828 #endif
00829 
00830    /* note that even though data->name is a pointer to allocated memory,
00831       we are not freeing it here because ast_register_thread is going to
00832       keep a copy of the pointer and then ast_unregister_thread will
00833       free the memory
00834    */
00835    free(data);
00836    ast_register_thread(a.name);
00837    pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());
00838 
00839 #ifdef DEBUG_THREADS
00840    if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
00841       return NULL;
00842 
00843    lock_info->thread_id = pthread_self();
00844    lock_info->thread_name = strdup(a.name);
00845 
00846    pthread_mutexattr_init(&mutex_attr);
00847    pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
00848    pthread_mutex_init(&lock_info->lock, &mutex_attr);
00849    pthread_mutexattr_destroy(&mutex_attr);
00850 
00851    pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
00852    AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
00853    pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
00854 #endif /* DEBUG_THREADS */
00855 
00856    ret = a.start_routine(a.data);
00857 
00858    pthread_cleanup_pop(1);
00859 
00860    return ret;
00861 }

static void inet_ntoa_buf_init ( void   )  [static]

Definition at line 71 of file utils.c.

00088 {

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

Definition at line 1098 of file utils.c.

References ast_log(), LOG_WARNING, and ONE_MILLION.

Referenced by ast_tvadd(), and ast_tvsub().

01099 {
01100    if (a.tv_usec >= ONE_MILLION) {
01101       ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
01102          (long) a.tv_sec, (long int) a.tv_usec);
01103       a.tv_sec += a.tv_usec / ONE_MILLION;
01104       a.tv_usec %= ONE_MILLION;
01105    } else if (a.tv_usec < 0) {
01106       ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
01107          (long) a.tv_sec, (long int) a.tv_usec);
01108       a.tv_usec = 0;
01109    }
01110    return a;
01111 }


Variable Documentation

const char __ast_string_field_empty[] = ""

Definition at line 1203 of file utils.c.

Referenced by __ast_string_field_init().

char b2a[256] [static]

Definition at line 69 of file utils.c.

char base64[64] [static]

Definition at line 68 of file utils.c.

Referenced by aji_act_hook().

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

Definition at line 1325 of file utils.c.

Referenced by ast_atomic_fetchadd_int_slow().

struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = inet_ntoa_buf_init , } [static]

Definition at line 71 of file utils.c.

Referenced by ast_inet_ntoa().

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

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

Definition at line 1146 of file utils.c.

Referenced by ast_random().


Generated on Thu Oct 11 06:44:30 2012 for Asterisk - the Open Source PBX by  doxygen 1.5.6