#include "asterisk.h"
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "asterisk/network.h"
#include "asterisk/lock.h"
#include "asterisk/io.h"
#include "asterisk/md5.h"
#include "asterisk/sha1.h"
#include "asterisk/cli.h"
#include "asterisk/linkedlists.h"
#include "asterisk/strings.h"
#include "asterisk/time.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/config.h"
Go to the source code of this file.
Data Structures | |
struct | thr_arg |
Defines | |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | ONE_MILLION 1000000 |
Functions | |
int | __ast_str_helper (struct ast_str **buf, ssize_t max_len, int append, const char *fmt, va_list ap) |
Core functionality of ast_str_(set|append)_va. | |
ast_string_field | __ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed) |
int | __ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func) |
void | __ast_string_field_ptr_build (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...) |
void | __ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap1, va_list ap2) |
int | __ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, size_t needed, const ast_string_field *ptr) |
static void | __init_inet_ntoa_buf (void) |
int | _ast_asprintf (char **ret, const char *file, int lineno, const char *func, const char *fmt,...) |
static int | add_string_pool (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t size, const char *file, int lineno, const char *func) |
add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only. | |
int | ast_atomic_fetchadd_int_slow (volatile int *p, int v) |
int | ast_base64decode (unsigned char *dst, const char *src, int max) |
Decode data from base64. | |
int | ast_base64encode (char *dst, const unsigned char *src, int srclen, int max) |
Encode data in base64. | |
int | ast_base64encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks) |
encode text to BASE64 coding | |
int | ast_build_string (char **buffer, size_t *space, const char *fmt,...) |
Build a string in a buffer, designed to be called repeatedly. | |
int | ast_build_string_va (char **buffer, size_t *space, const char *fmt, va_list ap) |
Build a string in a buffer, designed to be called repeatedly. | |
int | ast_careful_fwrite (FILE *f, int fd, const char *src, size_t len, int timeoutms) |
Write data to a file stream with a timeout. | |
int | ast_carefulwrite (int fd, char *s, int len, int timeoutms) |
Try to write string, but wait no more than ms milliseconds before timing out. | |
void | ast_enable_packet_fragmentation (int sock) |
Disable PMTU discovery on a socket. | |
int | ast_false (const char *s) |
Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0". | |
int | ast_get_time_t (const char *src, time_t *dst, time_t _default, int *consumed) |
get values from config variables. | |
int | ast_get_timeval (const char *src, struct timeval *dst, struct timeval _default, int *consumed) |
get values from config variables. | |
hostent * | ast_gethostbyname (const char *host, struct ast_hostent *hp) |
Thread-safe gethostbyname function to use in Asterisk. | |
const char * | ast_inet_ntoa (struct in_addr ia) |
thread-safe replacement for inet_ntoa(). | |
void | ast_join (char *s, size_t len, char *const w[]) |
void | ast_md5_hash (char *output, char *input) |
Produces MD5 hash based on input string. | |
int | ast_mkdir (const char *path, int mode) |
Recursively create directory path. | |
char * | ast_process_quotes_and_slashes (char *start, char find, char replace_with) |
Process a string to find and replace characters. | |
int | ast_pthread_create_detached_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn) |
int | ast_pthread_create_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn) |
long int | ast_random (void) |
void | ast_sha1_hash (char *output, char *input) |
Produces SHA1 hash based on input string. | |
char * | ast_strip_quoted (char *s, const char *beg_quotes, const char *end_quotes) |
Strip leading/trailing whitespace and quotes from a string. | |
int | ast_true (const char *s) |
Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1". | |
timeval | ast_tvadd (struct timeval a, struct timeval b) |
Returns the sum of two timevals a + b. | |
timeval | ast_tvsub (struct timeval a, struct timeval b) |
Returns the difference of two timevals a - b. | |
char * | ast_unescape_c (char *src) |
Convert some C escape sequences. | |
char * | ast_unescape_semicolon (char *s) |
Strip backslash for "escaped" semicolons, the string to be stripped (will be modified). | |
void | ast_uri_decode (char *s) |
Decode URI, URN, URL (overwrite string). | |
char * | ast_uri_encode (const char *string, char *outbuf, int buflen, int doreserved) |
Turn text string to URI-encoded XX version. | |
int | ast_utils_init (void) |
int | ast_wait_for_input (int fd, int ms) |
static int | ast_wait_for_output (int fd, int timeoutms) |
static void | base64_init (void) |
static void * | dummy_start (void *data) |
static struct timeval | tvfix (struct timeval a) |
Variables | |
const char | __ast_string_field_empty [] = "" |
static char | b2a [256] |
static char | base64 [64] |
static int | dev_urandom_fd |
static ast_mutex_t | fetchadd_m = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) |
static struct ast_threadstorage | inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , } |
static ast_mutex_t | randomlock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) |
glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not. |
Definition in file utils.c.
#define ONE_MILLION 1000000 |
int __ast_str_helper | ( | struct ast_str ** | buf, | |
ssize_t | max_len, | |||
int | append, | |||
const char * | fmt, | |||
va_list | ap | |||
) |
Core functionality of ast_str_(set|append)_va.
core handler for dynamic strings. This is not meant to be called directly, but rather through the various wrapper macros ast_str_set(...) ast_str_append(...) ast_str_set_va(...) ast_str_append_va(...)
Definition at line 1765 of file utils.c.
References AST_DYNSTR_BUILD_FAILED, ast_str_make_space(), ast_verbose, and buf.
Referenced by ast_str_set_va().
01767 { 01768 int res, need; 01769 int offset = (append && (*buf)->len) ? (*buf)->used : 0; 01770 va_list aq; 01771 01772 do { 01773 if (max_len < 0) { 01774 max_len = (*buf)->len; /* don't exceed the allocated space */ 01775 } 01776 /* 01777 * Ask vsnprintf how much space we need. Remember that vsnprintf 01778 * does not count the final '\0' so we must add 1. 01779 */ 01780 va_copy(aq, ap); 01781 res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, aq); 01782 01783 need = res + offset + 1; 01784 /* 01785 * If there is not enough space and we are below the max length, 01786 * reallocate the buffer and return a message telling to retry. 01787 */ 01788 if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) { 01789 if (max_len && max_len < need) { /* truncate as needed */ 01790 need = max_len; 01791 } else if (max_len == 0) { /* if unbounded, give more room for next time */ 01792 need += 16 + need / 4; 01793 } 01794 if (0) { /* debugging */ 01795 ast_verbose("extend from %d to %d\n", (int)(*buf)->len, need); 01796 } 01797 if (ast_str_make_space(buf, need)) { 01798 ast_verbose("failed to extend from %d to %d\n", (int)(*buf)->len, need); 01799 va_end(aq); 01800 return AST_DYNSTR_BUILD_FAILED; 01801 } 01802 (*buf)->str[offset] = '\0'; /* Truncate the partial write. */ 01803 01804 /* Restart va_copy before calling vsnprintf() again. */ 01805 va_end(aq); 01806 continue; 01807 } 01808 va_end(aq); 01809 break; 01810 } while (1); 01811 /* update space used, keep in mind the truncation */ 01812 (*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len - 1 : res + offset; 01813 01814 return res; 01815 }
ast_string_field __ast_string_field_alloc_space | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | needed | |||
) |
Definition at line 1568 of file utils.c.
References add_string_pool(), ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.
01570 { 01571 char *result = NULL; 01572 size_t space = mgr->size - mgr->used; 01573 01574 if (__builtin_expect(needed > space, 0)) { 01575 size_t new_size = mgr->size * 2; 01576 01577 while (new_size < needed) 01578 new_size *= 2; 01579 01580 #if defined(__AST_DEBUG_MALLOC) 01581 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func)) 01582 return NULL; 01583 #else 01584 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__)) 01585 return NULL; 01586 #endif 01587 } 01588 01589 result = (*pool_head)->base + mgr->used; 01590 mgr->used += needed; 01591 mgr->last_alloc = result; 01592 return result; 01593 }
int __ast_string_field_init | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
int | needed, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) |
Definition at line 1514 of file utils.c.
References add_string_pool(), ast_free, ast_log(), ast_string_field_mgr::last_alloc, LOG_WARNING, ast_string_field_pool::prev, and ast_string_field_mgr::used.
01516 { 01517 const char **p = (const char **) pool_head + 1; 01518 struct ast_string_field_pool *cur = NULL; 01519 struct ast_string_field_pool *preserve = NULL; 01520 01521 /* clear fields - this is always necessary */ 01522 while ((struct ast_string_field_mgr *) p != mgr) 01523 *p++ = __ast_string_field_empty; 01524 mgr->last_alloc = NULL; 01525 #if defined(__AST_DEBUG_MALLOC) 01526 mgr->owner_file = file; 01527 mgr->owner_func = func; 01528 mgr->owner_line = lineno; 01529 #endif 01530 if (needed > 0) { /* allocate the initial pool */ 01531 *pool_head = NULL; 01532 return add_string_pool(mgr, pool_head, needed, file, lineno, func); 01533 } 01534 if (needed < 0) { /* reset all pools */ 01535 if (*pool_head == NULL) { 01536 ast_log(LOG_WARNING, "trying to reset empty pool\n"); 01537 return -1; 01538 } 01539 cur = *pool_head; 01540 } else { /* preserve the last pool */ 01541 if (*pool_head == NULL) { 01542 ast_log(LOG_WARNING, "trying to reset empty pool\n"); 01543 return -1; 01544 } 01545 mgr->used = 0; 01546 preserve = *pool_head; 01547 cur = preserve->prev; 01548 } 01549 01550 if (preserve) { 01551 preserve->prev = NULL; 01552 } 01553 01554 while (cur) { 01555 struct ast_string_field_pool *prev = cur->prev; 01556 01557 if (cur != preserve) { 01558 ast_free(cur); 01559 } 01560 cur = prev; 01561 } 01562 01563 *pool_head = preserve; 01564 01565 return 0; 01566 }
void __ast_string_field_ptr_build | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
... | ||||
) |
Definition at line 1674 of file utils.c.
References __ast_string_field_ptr_build_va().
01677 { 01678 va_list ap1, ap2; 01679 01680 va_start(ap1, format); 01681 va_start(ap2, format); /* va_copy does not exist on FreeBSD */ 01682 01683 __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2); 01684 01685 va_end(ap1); 01686 va_end(ap2); 01687 }
void __ast_string_field_ptr_build_va | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
va_list | ap1, | |||
va_list | ap2 | |||
) |
Definition at line 1618 of file utils.c.
References add_string_pool(), available(), ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.
Referenced by __ast_string_field_ptr_build().
01621 { 01622 size_t needed; 01623 size_t available; 01624 size_t space = mgr->size - mgr->used; 01625 char *target; 01626 01627 /* if the field already has space allocated, try to reuse it; 01628 otherwise, use the empty space at the end of the current 01629 pool 01630 */ 01631 if ((*ptr)[0] != '\0') { 01632 target = (char *) *ptr; 01633 available = strlen(target) + 1; 01634 } else { 01635 target = (*pool_head)->base + mgr->used; 01636 available = space; 01637 } 01638 01639 needed = vsnprintf(target, available, format, ap1) + 1; 01640 01641 va_end(ap1); 01642 01643 if (needed > available) { 01644 /* if the space needed can be satisfied by using the current 01645 pool (which could only occur if we tried to use the field's 01646 allocated space and failed), then use that space; otherwise 01647 allocate a new pool 01648 */ 01649 if (needed > space) { 01650 size_t new_size = mgr->size * 2; 01651 01652 while (new_size < needed) 01653 new_size *= 2; 01654 01655 #if defined(__AST_DEBUG_MALLOC) 01656 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func)) 01657 return; 01658 #else 01659 if (add_string_pool(mgr, pool_head, new_size, NULL, 0, NULL)) 01660 return; 01661 #endif 01662 } 01663 01664 target = (*pool_head)->base + mgr->used; 01665 vsprintf(target, format, ap2); 01666 } 01667 01668 if (*ptr != target) { 01669 mgr->last_alloc = *ptr = target; 01670 mgr->used += needed; 01671 } 01672 }
int __ast_string_field_ptr_grow | ( | struct ast_string_field_mgr * | mgr, | |
size_t | needed, | |||
const ast_string_field * | ptr | |||
) |
Definition at line 1595 of file utils.c.
References ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.
01597 { 01598 int grow = needed - (strlen(*ptr) + 1); 01599 size_t space = mgr->size - mgr->used; 01600 01601 if (grow <= 0) { 01602 return 0; 01603 } 01604 01605 if (*ptr != mgr->last_alloc) { 01606 return 1; 01607 } 01608 01609 if (space < grow) { 01610 return 1; 01611 } 01612 01613 mgr->used += grow; 01614 01615 return 0; 01616 }
int _ast_asprintf | ( | char ** | ret, | |
const char * | file, | |||
int | lineno, | |||
const char * | func, | |||
const char * | fmt, | |||
... | ||||
) |
Definition at line 1877 of file utils.c.
References MALLOC_FAILURE_MSG, and vasprintf.
01878 { 01879 int res; 01880 va_list ap; 01881 01882 va_start(ap, fmt); 01883 if ((res = vasprintf(ret, fmt, ap)) == -1) { 01884 MALLOC_FAILURE_MSG; 01885 } 01886 va_end(ap); 01887 01888 return res; 01889 }
static int add_string_pool | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | size, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) | [static] |
add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only.
Definition at line 1480 of file utils.c.
References __ast_calloc(), ast_calloc, ast_string_field_mgr::last_alloc, ast_string_field_mgr::size, and ast_string_field_mgr::used.
Referenced by __ast_string_field_alloc_space(), __ast_string_field_init(), and __ast_string_field_ptr_build_va().
01482 { 01483 struct ast_string_field_pool *pool; 01484 01485 #if defined(__AST_DEBUG_MALLOC) 01486 if (!(pool = __ast_calloc(1, sizeof(*pool) + size, file, lineno, func))) { 01487 return -1; 01488 } 01489 #else 01490 if (!(pool = ast_calloc(1, sizeof(*pool) + size))) { 01491 return -1; 01492 } 01493 #endif 01494 01495 pool->prev = *pool_head; 01496 *pool_head = pool; 01497 mgr->size = size; 01498 mgr->used = 0; 01499 mgr->last_alloc = NULL; 01500 01501 return 0; 01502 }
int ast_atomic_fetchadd_int_slow | ( | volatile int * | p, | |
int | v | |||
) |
Definition at line 1692 of file utils.c.
References ast_mutex_lock(), ast_mutex_unlock(), and fetchadd_m.
01693 { 01694 int ret; 01695 ast_mutex_lock(&fetchadd_m); 01696 ret = *p; 01697 *p += v; 01698 ast_mutex_unlock(&fetchadd_m); 01699 return ret; 01700 }
int ast_base64decode | ( | unsigned char * | dst, | |
const char * | src, | |||
int | max | |||
) |
Decode data from base64.
dst | the destination buffer | |
src | the source buffer | |
max | The maximum number of bytes to write into the destination buffer. Note that this function will not ensure that the destination buffer is NULL terminated. So, in general, this parameter should be sizeof(dst) - 1. |
Definition at line 264 of file utils.c.
Referenced by __ast_check_signature(), base64_decode(), and osp_validate_token().
00265 { 00266 int cnt = 0; 00267 unsigned int byte = 0; 00268 unsigned int bits = 0; 00269 int incnt = 0; 00270 while(*src && *src != '=' && (cnt < max)) { 00271 /* Shift in 6 bits of input */ 00272 byte <<= 6; 00273 byte |= (b2a[(int)(*src)]) & 0x3f; 00274 bits += 6; 00275 src++; 00276 incnt++; 00277 /* If we have at least 8 bits left over, take that character 00278 off the top */ 00279 if (bits >= 8) { 00280 bits -= 8; 00281 *dst = (byte >> bits) & 0xff; 00282 dst++; 00283 cnt++; 00284 } 00285 } 00286 /* Dont worry about left over bits, they're extra anyway */ 00287 return cnt; 00288 }
int ast_base64encode | ( | char * | dst, | |
const unsigned char * | src, | |||
int | srclen, | |||
int | max | |||
) |
Encode data in base64.
dst | the destination buffer | |
src | the source data to be encoded | |
srclen | the number of bytes present in the source buffer | |
max | the maximum number of bytes to write into the destination buffer, *including* the terminating NULL character. |
Definition at line 342 of file utils.c.
References ast_base64encode_full().
Referenced by __ast_sign(), aji_start_sasl(), base64_encode(), build_secret(), and osp_check_destination().
00343 { 00344 return ast_base64encode_full(dst, src, srclen, max, 0); 00345 }
int ast_base64encode_full | ( | char * | dst, | |
const unsigned char * | src, | |||
int | srclen, | |||
int | max, | |||
int | linebreaks | |||
) |
encode text to BASE64 coding
Definition at line 291 of file utils.c.
Referenced by ast_base64encode().
00292 { 00293 int cnt = 0; 00294 int col = 0; 00295 unsigned int byte = 0; 00296 int bits = 0; 00297 int cntin = 0; 00298 /* Reserve space for null byte at end of string */ 00299 max--; 00300 while ((cntin < srclen) && (cnt < max)) { 00301 byte <<= 8; 00302 byte |= *(src++); 00303 bits += 8; 00304 cntin++; 00305 if ((bits == 24) && (cnt + 4 <= max)) { 00306 *dst++ = base64[(byte >> 18) & 0x3f]; 00307 *dst++ = base64[(byte >> 12) & 0x3f]; 00308 *dst++ = base64[(byte >> 6) & 0x3f]; 00309 *dst++ = base64[byte & 0x3f]; 00310 cnt += 4; 00311 col += 4; 00312 bits = 0; 00313 byte = 0; 00314 } 00315 if (linebreaks && (cnt < max) && (col == 64)) { 00316 *dst++ = '\n'; 00317 cnt++; 00318 col = 0; 00319 } 00320 } 00321 if (bits && (cnt + 4 <= max)) { 00322 /* Add one last character for the remaining bits, 00323 padding the rest with 0 */ 00324 byte <<= 24 - bits; 00325 *dst++ = base64[(byte >> 18) & 0x3f]; 00326 *dst++ = base64[(byte >> 12) & 0x3f]; 00327 if (bits == 16) 00328 *dst++ = base64[(byte >> 6) & 0x3f]; 00329 else 00330 *dst++ = '='; 00331 *dst++ = '='; 00332 cnt += 4; 00333 } 00334 if (linebreaks && (cnt < max)) { 00335 *dst++ = '\n'; 00336 cnt++; 00337 } 00338 *dst = '\0'; 00339 return cnt; 00340 }
int ast_build_string | ( | char ** | buffer, | |
size_t * | space, | |||
const char * | fmt, | |||
... | ||||
) |
Build a string in a buffer, designed to be called repeatedly.
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 |
0 | on success | |
non-zero | on failure. |
Definition at line 1299 of file utils.c.
References ast_build_string_va().
Referenced by config_odbc(), config_pgsql(), handle_speechrecognize(), lua_func_read(), lua_pbx_exec(), pp_each_extension_exec(), and pp_each_user_exec().
01300 { 01301 va_list ap; 01302 int result; 01303 01304 va_start(ap, fmt); 01305 result = ast_build_string_va(buffer, space, fmt, ap); 01306 va_end(ap); 01307 01308 return result; 01309 }
int ast_build_string_va | ( | char ** | buffer, | |
size_t * | space, | |||
const char * | fmt, | |||
va_list | ap | |||
) |
Build a string in a buffer, designed to be called repeatedly.
This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.
buffer | current position in buffer to place string into (will be updated on return) | |
space | remaining space in buffer (will be updated on return) | |
fmt | printf-style format string | |
ap | varargs list of arguments for format |
Definition at line 1280 of file utils.c.
Referenced by ast_build_string().
01281 { 01282 int result; 01283 01284 if (!buffer || !*buffer || !space || !*space) 01285 return -1; 01286 01287 result = vsnprintf(*buffer, *space, fmt, ap); 01288 01289 if (result < 0) 01290 return -1; 01291 else if (result > *space) 01292 result = *space; 01293 01294 *buffer += result; 01295 *space -= result; 01296 return 0; 01297 }
int ast_careful_fwrite | ( | FILE * | f, | |
int | fd, | |||
const char * | s, | |||
size_t | len, | |||
int | timeoutms | |||
) |
Write data to a file stream with a timeout.
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. |
0 | success | |
-1 | error |
Definition at line 1154 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, fwrite, and LOG_ERROR.
Referenced by send_string().
01155 { 01156 struct timeval start = ast_tvnow(); 01157 int n = 0; 01158 int elapsed = 0; 01159 01160 while (len) { 01161 if (ast_wait_for_output(fd, timeoutms - elapsed)) { 01162 /* poll returned a fatal error, so bail out immediately. */ 01163 return -1; 01164 } 01165 01166 /* Clear any errors from a previous write */ 01167 clearerr(f); 01168 01169 n = fwrite(src, 1, len, f); 01170 01171 if (ferror(f) && errno != EINTR && errno != EAGAIN) { 01172 /* fatal error from fwrite() */ 01173 if (!feof(f)) { 01174 /* Don't spam the logs if it was just that the connection is closed. */ 01175 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno)); 01176 } 01177 n = -1; 01178 break; 01179 } 01180 01181 /* Update for data already written to the socket */ 01182 len -= n; 01183 src += n; 01184 01185 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01186 if (elapsed >= timeoutms) { 01187 /* We've taken too long to write 01188 * This is only an error condition if we haven't finished writing. */ 01189 n = len ? -1 : 0; 01190 break; 01191 } 01192 } 01193 01194 while (fflush(f)) { 01195 if (errno == EAGAIN || errno == EINTR) { 01196 continue; 01197 } 01198 if (!feof(f)) { 01199 /* Don't spam the logs if it was just that the connection is closed. */ 01200 ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno)); 01201 } 01202 n = -1; 01203 break; 01204 } 01205 01206 return n < 0 ? -1 : 0; 01207 }
int ast_carefulwrite | ( | int | fd, | |
char * | s, | |||
int | len, | |||
int | timeoutms | |||
) |
Try to write string, but wait no more than ms milliseconds before timing out.
Try to write string, but wait no more than ms milliseconds before timing out.
Definition at line 1113 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, and LOG_ERROR.
Referenced by ast_agi_send(), and ast_cli().
01114 { 01115 struct timeval start = ast_tvnow(); 01116 int res = 0; 01117 int elapsed = 0; 01118 01119 while (len) { 01120 if (ast_wait_for_output(fd, timeoutms - elapsed)) { 01121 return -1; 01122 } 01123 01124 res = write(fd, s, len); 01125 01126 if (res < 0 && errno != EAGAIN && errno != EINTR) { 01127 /* fatal error from write() */ 01128 ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno)); 01129 return -1; 01130 } 01131 01132 if (res < 0) { 01133 /* It was an acceptable error */ 01134 res = 0; 01135 } 01136 01137 /* Update how much data we have left to write */ 01138 len -= res; 01139 s += res; 01140 res = 0; 01141 01142 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01143 if (elapsed >= timeoutms) { 01144 /* We've taken too long to write 01145 * This is only an error condition if we haven't finished writing. */ 01146 res = len ? -1 : 0; 01147 break; 01148 } 01149 } 01150 01151 return res; 01152 }
void ast_enable_packet_fragmentation | ( | int | sock | ) |
Disable PMTU discovery on a socket.
sock | The socket to manipulate |
Because of this, UDP packets sent by Asterisk that are larger than the MTU of any hop in the path will be lost. This function can be called on a socket to ensure that the DF bit will not be set.
Definition at line 1817 of file utils.c.
References ast_log(), and LOG_WARNING.
Referenced by ast_netsock_bindaddr().
01818 { 01819 #if defined(HAVE_IP_MTU_DISCOVER) 01820 int val = IP_PMTUDISC_DONT; 01821 01822 if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val))) 01823 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n"); 01824 #endif /* HAVE_IP_MTU_DISCOVER */ 01825 }
int ast_false | ( | const char * | val | ) |
Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0".
0 | if val is a NULL pointer. | |
-1 | if "true". | |
0 | otherwise. |
Definition at line 1328 of file utils.c.
References ast_strlen_zero().
Referenced by __ast_rtp_reload(), __ast_udptl_reload(), aji_create_client(), aji_load_config(), build_peer(), build_user(), dahdi_set_dnd(), func_channel_write(), handle_common_options(), init_acf_query(), load_config(), load_odbc_config(), run_agi(), set_config(), set_insecure_flags(), and strings_to_mask().
01329 { 01330 if (ast_strlen_zero(s)) 01331 return 0; 01332 01333 /* Determine if this is a false value */ 01334 if (!strcasecmp(s, "no") || 01335 !strcasecmp(s, "false") || 01336 !strcasecmp(s, "n") || 01337 !strcasecmp(s, "f") || 01338 !strcasecmp(s, "0") || 01339 !strcasecmp(s, "off")) 01340 return -1; 01341 01342 return 0; 01343 }
int ast_get_time_t | ( | const char * | src, | |
time_t * | dst, | |||
time_t | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 1732 of file utils.c.
References ast_strlen_zero().
Referenced by build_peer(), cache_lookup_internal(), handle_saydatetime(), load_password(), play_message_datetime(), process_clearcache(), and sayunixtime_exec().
01733 { 01734 long t; 01735 int scanned; 01736 01737 if (dst == NULL) 01738 return -1; 01739 01740 *dst = _default; 01741 01742 if (ast_strlen_zero(src)) 01743 return -1; 01744 01745 /* only integer at the moment, but one day we could accept more formats */ 01746 if (sscanf(src, "%30ld%n", &t, &scanned) == 1) { 01747 *dst = t; 01748 if (consumed) 01749 *consumed = scanned; 01750 return 0; 01751 } else 01752 return -1; 01753 }
int ast_get_timeval | ( | const char * | src, | |
struct timeval * | dst, | |||
struct timeval | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 1705 of file utils.c.
References ast_strlen_zero().
Referenced by acf_strftime().
01706 { 01707 long double dtv = 0.0; 01708 int scanned; 01709 01710 if (dst == NULL) 01711 return -1; 01712 01713 *dst = _default; 01714 01715 if (ast_strlen_zero(src)) 01716 return -1; 01717 01718 /* only integer at the moment, but one day we could accept more formats */ 01719 if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) { 01720 dst->tv_sec = dtv; 01721 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0; 01722 if (consumed) 01723 *consumed = scanned; 01724 return 0; 01725 } else 01726 return -1; 01727 }
struct hostent* ast_gethostbyname | ( | const char * | host, | |
struct ast_hostent * | hp | |||
) |
Thread-safe gethostbyname function to use in Asterisk.
Definition at line 182 of file utils.c.
Referenced by __init_manager(), __set_address_from_contact(), ast_find_ourip(), ast_get_ip_or_srv(), ast_parse_arg(), check_via(), create_addr(), festival_exec(), get_ip_and_port_from_sdp(), gtalk_load_config(), gtalk_update_stun(), handle_cli_udptl_debug_deprecated(), handle_cli_udptl_set_debug(), iax_template_parse(), jingle_load_config(), jingle_update_stun(), launch_netscript(), parse_register_contact(), process_sdp(), process_sdp_c(), realtime_peer(), realtime_user(), reload_config(), rpt_exec(), rtcp_do_debug_ip(), rtp_do_debug_ip(), set_config(), set_destination(), and sip_do_debug_ip().
00183 { 00184 int res; 00185 int herrno; 00186 int dots = 0; 00187 const char *s; 00188 struct hostent *result = NULL; 00189 /* Although it is perfectly legitimate to lookup a pure integer, for 00190 the sake of the sanity of people who like to name their peers as 00191 integers, we break with tradition and refuse to look up a 00192 pure integer */ 00193 s = host; 00194 res = 0; 00195 while (s && *s) { 00196 if (*s == '.') 00197 dots++; 00198 else if (!isdigit(*s)) 00199 break; 00200 s++; 00201 } 00202 if (!s || !*s) { 00203 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */ 00204 if (dots != 3) 00205 return NULL; 00206 memset(hp, 0, sizeof(struct ast_hostent)); 00207 hp->hp.h_addrtype = AF_INET; 00208 hp->hp.h_addr_list = (void *) hp->buf; 00209 hp->hp.h_addr = hp->buf + sizeof(void *); 00210 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0) 00211 return &hp->hp; 00212 return NULL; 00213 00214 } 00215 #ifdef HAVE_GETHOSTBYNAME_R_5 00216 result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno); 00217 00218 if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00219 return NULL; 00220 #else 00221 res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno); 00222 00223 if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00224 return NULL; 00225 #endif 00226 return &hp->hp; 00227 }
const char* ast_inet_ntoa | ( | struct in_addr | ia | ) |
thread-safe replacement for inet_ntoa().
Definition at line 431 of file utils.c.
References ast_threadstorage_get(), and inet_ntoa_buf.
Referenced by __attempt_transmit(), __find_callno(), __iax2_show_peers(), __sip_xmit(), _sip_show_peer(), _sip_show_peers(), acf_channel_read(), action_login(), add_sdp(), ast_append_ha(), ast_apply_ha(), ast_netsock_bindaddr(), ast_parse_arg(), ast_rtcp_read(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_raw_write(), ast_rtp_read(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_senddigit_continuation(), ast_rtp_senddigit_end(), ast_sip_ouraddrfor(), ast_tcptls_client_create(), ast_tcptls_client_start(), ast_tcptls_server_start(), ast_udptl_bridge(), ast_udptl_read(), ast_udptl_write(), authenticate(), bridge_native_loop(), bridge_p2p_rtp_write(), build_callid_pvt(), build_callid_registry(), build_contact(), build_peer(), build_reply_digest(), build_rpid(), build_via(), calltoken_required(), check_access(), check_peer_ok(), check_via(), copy_via_headers(), create_addr_from_peer(), create_client(), create_dtmf_frame(), dnsmgr_refresh(), dump_addr(), dump_ipaddr(), dundi_rexmit(), dundi_show_peer(), dundi_show_peers(), dundi_show_trans(), dundi_showframe(), dundi_xmit(), external_rtp_create(), find_command(), find_peer(), find_subchannel_and_lock(), find_tpeer(), function_iaxpeer(), function_sipchaninfo_read(), function_sippeer(), get_input(), gtalk_create_candidates(), gtalk_update_stun(), handle_call_token(), handle_cli_iax2_set_debug(), handle_cli_iax2_show_callno_limits(), handle_cli_iax2_show_channels(), handle_cli_iax2_show_peer(), handle_cli_iax2_show_registry(), handle_cli_udptl_debug_deprecated(), handle_cli_udptl_set_debug(), handle_command_response(), handle_error(), handle_incoming(), handle_mgcp_show_endpoints(), handle_open_receive_channel_ack_message(), handle_request(), handle_request_bye(), handle_request_do(), handle_request_register(), handle_request_subscribe(), handle_response(), handle_response_notify(), handle_response_refer(), handle_show_http(), handle_showmanconn(), handle_skinny_show_device(), handle_skinny_show_devices(), handle_skinny_show_settings(), httpstatus_callback(), iax2_ack_registry(), iax2_prov_app(), iax2_trunk_queue(), iax_server(), iax_showframe(), initreqprep(), jingle_create_candidates(), load_module(), manager_iax2_show_peer_list(), mgcpsock_read(), oh323_addrcmp_str(), oh323_call(), oh323_set_rtp_peer(), parse_register_contact(), parsing(), peercnt_add(), peercnt_modify(), peercnt_remove(), phoneprov_callback(), process_request(), process_rfc3389(), process_sdp(), purge_sessions(), raw_hangup(), realtime_peer(), realtime_update_peer(), realtime_user(), reg_source_db(), register_verify(), registry_rerequest(), reload_config(), resend_response(), retrans_pkt(), rpt_exec(), rtcp_do_debug_ip(), rtp_do_debug_ip(), sched_delay_remove(), score_address(), send_packet(), send_raw_client(), send_request(), send_response(), send_trunk(), session_do(), set_config(), set_destination(), set_peercnt_limit(), setup_incoming_call(), show_channels_cb(), show_chanstats_cb(), show_main_page(), sip_do_debug_ip(), sip_do_debug_peer(), sip_poke_peer(), sip_set_rtp_peer(), sip_set_udptl_peer(), sip_show_channel(), sip_show_settings(), sip_show_tcp(), skinny_session(), skinny_set_rtp_peer(), socket_process(), socket_process_meta(), start_rtp(), timing_read(), transmit_notify_with_mwi(), unistim_info(), unistimsock_read(), and update_registry().
00432 { 00433 char *buf; 00434 00435 if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN))) 00436 return ""; 00437 00438 return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN); 00439 }
void ast_join | ( | char * | s, | |
size_t | len, | |||
char *const | w[] | |||
) |
Definition at line 1451 of file utils.c.
Referenced by __ast_cli_generator(), ast_agi_register(), ast_agi_unregister(), cli_console_sendtext(), console_sendtext(), find_best(), handle_cli_agi_show(), handle_help(), help1(), help_workhorse(), set_full_cmd(), and write_htmldump().
01452 { 01453 int x, ofs = 0; 01454 const char *src; 01455 01456 /* Join words into a string */ 01457 if (!s) 01458 return; 01459 for (x = 0; ofs < len && w[x]; x++) { 01460 if (x > 0) 01461 s[ofs++] = ' '; 01462 for (src = w[x]; *src && ofs < len; src++) 01463 s[ofs++] = *src; 01464 } 01465 if (ofs == len) 01466 ofs--; 01467 s[ofs] = '\0'; 01468 }
void ast_md5_hash | ( | char * | output, | |
char * | input | |||
) |
Produces MD5 hash based on input string.
Definition at line 230 of file utils.c.
References md5(), MD5Final(), MD5Init(), and MD5Update().
Referenced by build_reply_digest(), check_auth(), and md5().
00231 { 00232 struct MD5Context md5; 00233 unsigned char digest[16]; 00234 char *ptr; 00235 int x; 00236 00237 MD5Init(&md5); 00238 MD5Update(&md5, (unsigned char *)input, strlen(input)); 00239 MD5Final(digest, &md5); 00240 ptr = output; 00241 for (x = 0; x < 16; x++) 00242 ptr += sprintf(ptr, "%2.2x", digest[x]); 00243 }
int ast_mkdir | ( | const char * | path, | |
int | mode | |||
) |
Recursively create directory path.
path | The directory path to create | |
mode | The permissions with which to try to create the directory |
Definition at line 1827 of file utils.c.
References ast_strdupa, errno, and len().
Referenced by ast_monitor_change_fname(), ast_monitor_start(), conf_run(), create_dirpath(), dictate_exec(), init_logger(), load_module(), mixmonitor_exec(), reload_logger(), remove_from_queue(), setup_privacy_args(), sms_nextoutgoing(), sms_writefile(), testclient_exec(), testserver_exec(), and write_history().
01828 { 01829 char *ptr; 01830 int len = strlen(path), count = 0, x, piececount = 0; 01831 char *tmp = ast_strdupa(path); 01832 char **pieces; 01833 char *fullpath = alloca(len + 1); 01834 int res = 0; 01835 01836 for (ptr = tmp; *ptr; ptr++) { 01837 if (*ptr == '/') 01838 count++; 01839 } 01840 01841 /* Count the components to the directory path */ 01842 pieces = alloca(count * sizeof(*pieces)); 01843 for (ptr = tmp; *ptr; ptr++) { 01844 if (*ptr == '/') { 01845 *ptr = '\0'; 01846 pieces[piececount++] = ptr + 1; 01847 } 01848 } 01849 01850 *fullpath = '\0'; 01851 for (x = 0; x < piececount; x++) { 01852 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */ 01853 strcat(fullpath, "/"); 01854 strcat(fullpath, pieces[x]); 01855 res = mkdir(fullpath, mode); 01856 if (res && errno != EEXIST) 01857 return errno; 01858 } 01859 return 0; 01860 }
char* ast_process_quotes_and_slashes | ( | char * | start, | |
char | find, | |||
char | replace_with | |||
) |
Process a string to find and replace characters.
start | The string to analyze | |
find | The character to find | |
replace_with | The character that will replace the one we are looking for |
Definition at line 1425 of file utils.c.
01426 { 01427 char *dataPut = start; 01428 int inEscape = 0; 01429 int inQuotes = 0; 01430 01431 for (; *start; start++) { 01432 if (inEscape) { 01433 *dataPut++ = *start; /* Always goes verbatim */ 01434 inEscape = 0; 01435 } else { 01436 if (*start == '\\') { 01437 inEscape = 1; /* Do not copy \ into the data */ 01438 } else if (*start == '\'') { 01439 inQuotes = 1 - inQuotes; /* Do not copy ' into the data */ 01440 } else { 01441 /* Replace , with |, unless in quotes */ 01442 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start); 01443 } 01444 } 01445 } 01446 if (start != dataPut) 01447 *dataPut = 0; 01448 return dataPut; 01449 }
int ast_pthread_create_detached_stack | ( | pthread_t * | thread, | |
pthread_attr_t * | attr, | |||
void *(*)(void *) | start_routine, | |||
void * | data, | |||
size_t | stacksize, | |||
const char * | file, | |||
const char * | caller, | |||
int | line, | |||
const char * | start_fn | |||
) |
Definition at line 1026 of file utils.c.
References ast_log(), ast_pthread_create_stack(), errno, and LOG_WARNING.
01029 { 01030 unsigned char attr_destroy = 0; 01031 int res; 01032 01033 if (!attr) { 01034 attr = alloca(sizeof(*attr)); 01035 pthread_attr_init(attr); 01036 attr_destroy = 1; 01037 } 01038 01039 if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED))) 01040 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno)); 01041 01042 res = ast_pthread_create_stack(thread, attr, start_routine, data, 01043 stacksize, file, caller, line, start_fn); 01044 01045 if (attr_destroy) 01046 pthread_attr_destroy(attr); 01047 01048 return res; 01049 }
int ast_pthread_create_stack | ( | pthread_t * | thread, | |
pthread_attr_t * | attr, | |||
void *(*)(void *) | start_routine, | |||
void * | data, | |||
size_t | stacksize, | |||
const char * | file, | |||
const char * | caller, | |||
int | line, | |||
const char * | start_fn | |||
) |
Definition at line 977 of file utils.c.
References asprintf, ast_log(), ast_malloc, AST_STACKSIZE, dummy_start(), errno, LOG_WARNING, and pthread_create.
Referenced by ast_pthread_create_detached_stack().
00980 { 00981 #if !defined(LOW_MEMORY) 00982 struct thr_arg *a; 00983 #endif 00984 00985 if (!attr) { 00986 attr = alloca(sizeof(*attr)); 00987 pthread_attr_init(attr); 00988 } 00989 00990 #ifdef __linux__ 00991 /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED, 00992 which is kind of useless. Change this here to 00993 PTHREAD_INHERIT_SCHED; that way the -p option to set realtime 00994 priority will propagate down to new threads by default. 00995 This does mean that callers cannot set a different priority using 00996 PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set 00997 the priority afterwards with pthread_setschedparam(). */ 00998 if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED))) 00999 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno)); 01000 #endif 01001 01002 if (!stacksize) 01003 stacksize = AST_STACKSIZE; 01004 01005 if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE))) 01006 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno)); 01007 01008 #if !defined(LOW_MEMORY) 01009 if ((a = ast_malloc(sizeof(*a)))) { 01010 a->start_routine = start_routine; 01011 a->data = data; 01012 start_routine = dummy_start; 01013 if (asprintf(&a->name, "%-20s started at [%5d] %s %s()", 01014 start_fn, line, file, caller) < 0) { 01015 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno)); 01016 a->name = NULL; 01017 } 01018 data = a; 01019 } 01020 #endif /* !LOW_MEMORY */ 01021 01022 return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */ 01023 }
long int ast_random | ( | void | ) |
Definition at line 1401 of file utils.c.
References ast_mutex_lock(), ast_mutex_unlock(), and randomlock.
Referenced by acf_rand_exec(), action_challenge(), add_sdp(), agent_new(), agi_handle_command(), ast_lock_path_lockfile(), ast_moh_files_next(), ast_rtp_change_source(), ast_rtp_new_init(), ast_rtp_new_with_bindaddr(), ast_udptl_new_with_bindaddr(), authenticate_request(), build_gateway(), build_iv(), build_rand_pad(), build_reply_digest(), calc_metric(), calc_rxstamp(), callno_hash(), dahdi_new(), generate_random_string(), get_trans_id(), gtalk_alloc(), gtalk_create_candidates(), gtalk_new(), handle_response_invite(), iax2_key_rotate(), iax2_start_transfer(), jingle_alloc(), jingle_create_candidates(), jingle_new(), load_module(), local_new(), make_email_file(), make_our_tag(), moh_files_alloc(), ogg_vorbis_rewrite(), osp_create_uuid(), page_exec(), park_space_reserve(), process_weights(), reg_source_db(), registry_authrequest(), reqprep(), say_periodic_announcement(), sendmail(), set_nonce_randdata(), sip_alloc(), socket_read(), start_rtp(), stun_req_id(), transmit_invite(), transmit_register(), transmit_response_using_temp(), and try_firmware().
01402 { 01403 long int res; 01404 #ifdef HAVE_DEV_URANDOM 01405 if (dev_urandom_fd >= 0) { 01406 int read_res = read(dev_urandom_fd, &res, sizeof(res)); 01407 if (read_res > 0) { 01408 long int rm = RAND_MAX; 01409 res = res < 0 ? ~res : res; 01410 rm++; 01411 return res % rm; 01412 } 01413 } 01414 #endif 01415 #ifdef linux 01416 res = random(); 01417 #else 01418 ast_mutex_lock(&randomlock); 01419 res = random(); 01420 ast_mutex_unlock(&randomlock); 01421 #endif 01422 return res; 01423 }
void ast_sha1_hash | ( | char * | output, | |
char * | input | |||
) |
Produces SHA1 hash based on input string.
Definition at line 246 of file utils.c.
References SHA1Input(), SHA1Reset(), and SHA1Result().
Referenced by aji_act_hook(), handle_call_token(), jabber_make_auth(), and sha1().
00247 { 00248 struct SHA1Context sha; 00249 char *ptr; 00250 int x; 00251 uint8_t Message_Digest[20]; 00252 00253 SHA1Reset(&sha); 00254 00255 SHA1Input(&sha, (const unsigned char *) input, strlen(input)); 00256 00257 SHA1Result(&sha, Message_Digest); 00258 ptr = output; 00259 for (x = 0; x < 20; x++) 00260 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]); 00261 }
char* ast_strip_quoted | ( | char * | s, | |
const char * | beg_quotes, | |||
const char * | end_quotes | |||
) |
Strip leading/trailing whitespace and quotes from a string.
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. |
It can also remove beginning and ending quote (or quote-like) characters, in matching pairs. If the first character of the string matches any character in beg_quotes, and the last character of the string is the matching character in end_quotes, then they are removed from the string.
Examples:
ast_strip_quoted(buf, "\"", "\""); ast_strip_quoted(buf, "'", "'"); ast_strip_quoted(buf, "[{(", "]})");
Definition at line 1209 of file utils.c.
References ast_strip().
Referenced by ast_register_file_version(), get_rdnis(), iftime(), load_values_config(), parse_cookies(), and parse_dial_string().
01210 { 01211 char *e; 01212 char *q; 01213 01214 s = ast_strip(s); 01215 if ((q = strchr(beg_quotes, *s)) && *q != '\0') { 01216 e = s + strlen(s) - 1; 01217 if (*e == *(end_quotes + (q - beg_quotes))) { 01218 s++; 01219 *e = '\0'; 01220 } 01221 } 01222 01223 return s; 01224 }
int ast_true | ( | const char * | val | ) |
Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1".
0 | if val is a NULL pointer. | |
-1 | if "true". | |
0 | otherwise. |
Definition at line 1311 of file utils.c.
References ast_strlen_zero().
Referenced by __ast_http_load(), __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _parse(), action_agent_logoff(), action_bridge(), action_originate(), action_updateconfig(), aji_create_client(), aji_load_config(), apply_general_options(), apply_option(), apply_outgoing(), ast_jb_read_conf(), build_device(), build_gateway(), build_peer(), build_user(), connect_link(), dahdi_set_dnd(), do_reload(), do_timelimit(), festival_exec(), func_channel_write(), func_inheritance_write(), get_encrypt_methods(), gtalk_load_config(), handle_common_options(), handle_t38_options(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), local_ast_moh_start(), login_exec(), manager_add_queue_member(), manager_pause_queue_member(), message_template_build(), misdn_answer(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), process_echocancel(), queue_set_param(), read_agent_config(), realtime_directory(), reload_config(), reload_queues(), run_startup_commands(), search_directory(), set_active(), set_config(), sla_load_config(), speex_write(), start_monitor_action(), strings_to_mask(), and update_common_options().
01312 { 01313 if (ast_strlen_zero(s)) 01314 return 0; 01315 01316 /* Determine if this is a true value */ 01317 if (!strcasecmp(s, "yes") || 01318 !strcasecmp(s, "true") || 01319 !strcasecmp(s, "y") || 01320 !strcasecmp(s, "t") || 01321 !strcasecmp(s, "1") || 01322 !strcasecmp(s, "on")) 01323 return -1; 01324 01325 return 0; 01326 }
struct timeval ast_tvadd | ( | struct timeval | a, | |
struct timeval | b | |||
) |
Returns the sum of two timevals a + b.
Definition at line 1365 of file utils.c.
References ONE_MILLION, and tvfix().
Referenced by __get_from_jb(), agent_hangup(), agent_read(), ast_audiohook_trigger_wait(), ast_channel_bridge(), ast_channel_cmpwhentohangup_tv(), ast_channel_setwhentohangup_tv(), ast_generic_bridge(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_senddigit_end(), ast_sched_runq(), ast_smoother_read(), ast_translate(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), dial_exec_full(), do_cdr(), do_timing(), iax2_process_thread(), jb_get_and_deliver(), mb_poll_thread(), monmp3thread(), mp3_exec(), mwi_monitor_handler(), NBScat_exec(), sched_settime(), sched_thread(), schedule_delivery(), sla_process_timers(), smdi_message_wait(), and timeout_write().
01366 { 01367 /* consistency checks to guarantee usec in 0..999999 */ 01368 a = tvfix(a); 01369 b = tvfix(b); 01370 a.tv_sec += b.tv_sec; 01371 a.tv_usec += b.tv_usec; 01372 if (a.tv_usec >= ONE_MILLION) { 01373 a.tv_sec++; 01374 a.tv_usec -= ONE_MILLION; 01375 } 01376 return a; 01377 }
struct timeval ast_tvsub | ( | struct timeval | a, | |
struct timeval | b | |||
) |
Returns the difference of two timevals a - b.
Definition at line 1379 of file utils.c.
References ONE_MILLION, and tvfix().
Referenced by ast_channel_bridge(), ast_rwlock_timedrdlock(), ast_rwlock_timedwrlock(), ast_sched_dump(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), handle_showcalls(), handle_showuptime(), and pri_dchannel().
01380 { 01381 /* consistency checks to guarantee usec in 0..999999 */ 01382 a = tvfix(a); 01383 b = tvfix(b); 01384 a.tv_sec -= b.tv_sec; 01385 a.tv_usec -= b.tv_usec; 01386 if (a.tv_usec < 0) { 01387 a.tv_sec-- ; 01388 a.tv_usec += ONE_MILLION; 01389 } 01390 return a; 01391 }
char* ast_unescape_c | ( | char * | s | ) |
Convert some C escape sequences.
(\b\f\n\r\t)
Definition at line 1245 of file utils.c.
01246 { 01247 char c, *ret, *dst; 01248 01249 if (src == NULL) 01250 return NULL; 01251 for (ret = dst = src; (c = *src++); *dst++ = c ) { 01252 if (c != '\\') 01253 continue; /* copy char at the end of the loop */ 01254 switch ((c = *src++)) { 01255 case '\0': /* special, trailing '\' */ 01256 c = '\\'; 01257 break; 01258 case 'b': /* backspace */ 01259 c = '\b'; 01260 break; 01261 case 'f': /* form feed */ 01262 c = '\f'; 01263 break; 01264 case 'n': 01265 c = '\n'; 01266 break; 01267 case 'r': 01268 c = '\r'; 01269 break; 01270 case 't': 01271 c = '\t'; 01272 break; 01273 } 01274 /* default, use the char literally */ 01275 } 01276 *dst = '\0'; 01277 return ret; 01278 }
char* ast_unescape_semicolon | ( | char * | s | ) |
Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).
Definition at line 1226 of file utils.c.
Referenced by transmit_invite(), and transmit_notify_custom().
01227 { 01228 char *e; 01229 char *work = s; 01230 01231 while ((e = strchr(work, ';'))) { 01232 if ((e > work) && (*(e-1) == '\\')) { 01233 memmove(e - 1, e, strlen(e) + 1); 01234 work = e; 01235 } else { 01236 work = e + 1; 01237 } 01238 } 01239 01240 return s; 01241 }
void ast_uri_decode | ( | char * | s | ) |
Decode URI, URN, URL (overwrite string).
s | String to be decoded |
Definition at line 414 of file utils.c.
Referenced by check_user_full(), config_curl(), get_also_info(), get_destination(), get_refer_info(), handle_request_invite(), http_decode(), realtime_curl(), realtime_multi_curl(), register_verify(), sip_new(), and uridecode().
00415 { 00416 char *o; 00417 unsigned int tmp; 00418 00419 for (o = s; *s; s++, o++) { 00420 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) { 00421 /* have '%', two chars and correct parsing */ 00422 *o = tmp; 00423 s += 2; /* Will be incremented once more when we break out */ 00424 } else /* all other cases, just copy */ 00425 *o = *s; 00426 } 00427 *o = '\0'; 00428 }
char* ast_uri_encode | ( | const char * | string, | |
char * | outbuf, | |||
int | buflen, | |||
int | doreserved | |||
) |
Turn text string to URI-encoded XX version.
Definition at line 383 of file utils.c.
References ast_copy_string().
Referenced by config_curl(), destroy_curl(), initreqprep(), launch_asyncagi(), realtime_curl(), realtime_multi_curl(), require_curl(), store_curl(), update_curl(), and uriencode().
00384 { 00385 char *reserved = ";/?:@&=+$,# "; /* Reserved chars */ 00386 00387 const char *ptr = string; /* Start with the string */ 00388 char *out = NULL; 00389 char *buf = NULL; 00390 00391 ast_copy_string(outbuf, string, buflen); 00392 00393 /* If there's no characters to convert, just go through and don't do anything */ 00394 while (*ptr) { 00395 if ((*ptr < 32) || (doreserved && strchr(reserved, *ptr))) { 00396 /* Oops, we need to start working here */ 00397 if (!buf) { 00398 buf = outbuf; 00399 out = buf + (ptr - string) ; /* Set output ptr */ 00400 } 00401 out += sprintf(out, "%%%02x", (unsigned char) *ptr); 00402 } else if (buf) { 00403 *out = *ptr; /* Continue copying the string */ 00404 out++; 00405 } 00406 ptr++; 00407 } 00408 if (buf) 00409 *out = '\0'; 00410 return outbuf; 00411 }
int ast_utils_init | ( | void | ) |
Definition at line 1862 of file utils.c.
References ARRAY_LEN, ast_cli_register_multiple(), and base64_init().
Referenced by main().
01863 { 01864 #ifdef HAVE_DEV_URANDOM 01865 dev_urandom_fd = open("/dev/urandom", O_RDONLY); 01866 #endif 01867 base64_init(); 01868 #ifdef DEBUG_THREADS 01869 #if !defined(LOW_MEMORY) 01870 ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli)); 01871 #endif 01872 #endif 01873 return 0; 01874 }
int ast_wait_for_input | ( | int | fd, | |
int | ms | |||
) |
Definition at line 1051 of file utils.c.
References ast_poll.
Referenced by action_waitevent(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), and moh_class_destructor().
01052 { 01053 struct pollfd pfd[1]; 01054 memset(pfd, 0, sizeof(pfd)); 01055 pfd[0].fd = fd; 01056 pfd[0].events = POLLIN|POLLPRI; 01057 return ast_poll(pfd, 1, ms); 01058 }
static int ast_wait_for_output | ( | int | fd, | |
int | timeoutms | |||
) | [static] |
Definition at line 1060 of file utils.c.
References ast_debug, ast_log(), ast_poll, ast_tvdiff_ms(), ast_tvnow(), errno, and LOG_ERROR.
Referenced by ast_careful_fwrite(), and ast_carefulwrite().
01061 { 01062 struct pollfd pfd = { 01063 .fd = fd, 01064 .events = POLLOUT, 01065 }; 01066 int res; 01067 struct timeval start = ast_tvnow(); 01068 int elapsed = 0; 01069 01070 /* poll() until the fd is writable without blocking */ 01071 while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) { 01072 if (res == 0) { 01073 /* timed out. */ 01074 #ifndef STANDALONE 01075 ast_debug(1, "Timed out trying to write\n"); 01076 #endif 01077 return -1; 01078 } else if (res == -1) { 01079 /* poll() returned an error, check to see if it was fatal */ 01080 01081 if (errno == EINTR || errno == EAGAIN) { 01082 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01083 if (elapsed >= timeoutms) { 01084 return -1; 01085 } 01086 /* This was an acceptable error, go back into poll() */ 01087 continue; 01088 } 01089 01090 /* Fatal error, bail. */ 01091 ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno)); 01092 01093 return -1; 01094 } 01095 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01096 if (elapsed >= timeoutms) { 01097 return -1; 01098 } 01099 } 01100 01101 return 0; 01102 }
static void base64_init | ( | void | ) | [static] |
Definition at line 347 of file utils.c.
Referenced by ast_utils_init().
00348 { 00349 int x; 00350 memset(b2a, -1, sizeof(b2a)); 00351 /* Initialize base-64 Conversion table */ 00352 for (x = 0; x < 26; x++) { 00353 /* A-Z */ 00354 base64[x] = 'A' + x; 00355 b2a['A' + x] = x; 00356 /* a-z */ 00357 base64[x + 26] = 'a' + x; 00358 b2a['a' + x] = x + 26; 00359 /* 0-9 */ 00360 if (x < 10) { 00361 base64[x + 52] = '0' + x; 00362 b2a['0' + x] = x + 52; 00363 } 00364 } 00365 base64[62] = '+'; 00366 base64[63] = '/'; 00367 b2a[(int)'+'] = 62; 00368 b2a[(int)'/'] = 63; 00369 }
static void* dummy_start | ( | void * | data | ) | [static] |
Definition at line 933 of file utils.c.
References ast_free, AST_LIST_INSERT_TAIL, AST_MUTEX_KIND, ast_register_thread(), ast_threadstorage_get(), ast_unregister_thread(), thr_arg::data, lock_info, thr_arg::name, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, thr_arg::start_routine, and strdup.
Referenced by ast_pthread_create_stack().
00934 { 00935 void *ret; 00936 struct thr_arg a = *((struct thr_arg *) data); /* make a local copy */ 00937 #ifdef DEBUG_THREADS 00938 struct thr_lock_info *lock_info; 00939 pthread_mutexattr_t mutex_attr; 00940 #endif 00941 00942 /* note that even though data->name is a pointer to allocated memory, 00943 we are not freeing it here because ast_register_thread is going to 00944 keep a copy of the pointer and then ast_unregister_thread will 00945 free the memory 00946 */ 00947 ast_free(data); 00948 ast_register_thread(a.name); 00949 pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self()); 00950 00951 #ifdef DEBUG_THREADS 00952 if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info)))) 00953 return NULL; 00954 00955 lock_info->thread_id = pthread_self(); 00956 lock_info->thread_name = strdup(a.name); 00957 00958 pthread_mutexattr_init(&mutex_attr); 00959 pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND); 00960 pthread_mutex_init(&lock_info->lock, &mutex_attr); 00961 pthread_mutexattr_destroy(&mutex_attr); 00962 00963 pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 00964 AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry); 00965 pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 00966 #endif /* DEBUG_THREADS */ 00967 00968 ret = a.start_routine(a.data); 00969 00970 pthread_cleanup_pop(1); 00971 00972 return ret; 00973 }
static struct timeval tvfix | ( | struct timeval | a | ) | [static] |
Definition at line 1350 of file utils.c.
References ast_log(), LOG_WARNING, and ONE_MILLION.
Referenced by ast_tvadd(), and ast_tvsub().
01351 { 01352 if (a.tv_usec >= ONE_MILLION) { 01353 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n", 01354 (long)a.tv_sec, (long int) a.tv_usec); 01355 a.tv_sec += a.tv_usec / ONE_MILLION; 01356 a.tv_usec %= ONE_MILLION; 01357 } else if (a.tv_usec < 0) { 01358 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n", 01359 (long)a.tv_sec, (long int) a.tv_usec); 01360 a.tv_usec = 0; 01361 } 01362 return a; 01363 }
const char __ast_string_field_empty[] = "" |
char base64[64] [static] |
int dev_urandom_fd [static] |
ast_mutex_t fetchadd_m = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static] |
struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , } [static] |
ast_mutex_t randomlock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static] |
glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not.
Definition at line 1398 of file utils.c.
Referenced by ast_random().