Utility functions. More...
#include "asterisk.h"
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "asterisk/network.h"
#include "asterisk/lock.h"
#include "asterisk/io.h"
#include "asterisk/md5.h"
#include "asterisk/sha1.h"
#include "asterisk/cli.h"
#include "asterisk/linkedlists.h"
#include "asterisk/strings.h"
#include "asterisk/time.h"
#include "asterisk/stringfields.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/config.h"
Go to the source code of this file.
Data Structures | |
struct | thr_arg |
Defines | |
#define | ALLOCATOR_OVERHEAD 48 |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | AST_API_MODULE |
#define | ONE_MILLION 1000000 |
Functions | |
void * | __ast_calloc_with_stringfields (unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func) |
ast_string_field | __ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed) |
int | __ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func) |
void | __ast_string_field_ptr_build (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...) |
void | __ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap1, va_list ap2) |
int | __ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr) |
void | __ast_string_field_release_active (struct ast_string_field_pool *pool_head, const ast_string_field ptr) |
static void | __init_inet_ntoa_buf (void) |
static int | add_string_pool (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t size, const char *file, int lineno, const char *func) |
add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only. | |
int | ast_atomic_fetchadd_int_slow (volatile int *p, int v) |
int | ast_base64decode (unsigned char *dst, const char *src, int max) |
decode BASE64 encoded text | |
int | ast_base64encode (char *dst, const unsigned char *src, int srclen, int max) |
Encode data in base64. | |
int | ast_base64encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks) |
encode text to BASE64 coding | |
int | ast_build_string (char **buffer, size_t *space, const char *fmt,...) |
Build a string in a buffer, designed to be called repeatedly. | |
int | ast_build_string_va (char **buffer, size_t *space, const char *fmt, va_list ap) |
Build a string in a buffer, designed to be called repeatedly. | |
int | ast_careful_fwrite (FILE *f, int fd, const char *src, size_t len, int timeoutms) |
Write data to a file stream with a timeout. | |
int | ast_carefulwrite (int fd, char *s, int len, int timeoutms) |
Try to write string, but wait no more than ms milliseconds before timing out. | |
void | ast_do_crash (void) |
Force a crash if DO_CRASH is defined. | |
void | ast_enable_packet_fragmentation (int sock) |
Disable PMTU discovery on a socket. | |
char * | ast_escape_quoted (const char *string, char *outbuf, int buflen) |
escapes characters specified for quoted portions of sip messages | |
int | ast_false (const char *s) |
Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0". | |
int | ast_get_time_t (const char *src, time_t *dst, time_t _default, int *consumed) |
get values from config variables. | |
int | ast_get_timeval (const char *src, struct timeval *dst, struct timeval _default, int *consumed) |
get values from config variables. | |
struct hostent * | ast_gethostbyname (const char *host, struct ast_hostent *hp) |
Re-entrant (thread safe) version of gethostbyname that replaces the standard gethostbyname (which is not thread safe). | |
const char * | ast_inet_ntoa (struct in_addr ia) |
ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa | |
void | ast_join (char *s, size_t len, const char *const w[]) |
void | ast_md5_hash (char *output, const char *input) |
Produce 32 char MD5 hash of value. | |
int | ast_mkdir (const char *path, int mode) |
Recursively create directory path. | |
int | ast_parse_digest (const char *digest, struct ast_http_digest *d, int request, int pedantic) |
Parse digest authorization header. | |
char * | ast_process_quotes_and_slashes (char *start, char find, char replace_with) |
Process a string to find and replace characters. | |
int | ast_pthread_create_detached_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn) |
int | ast_pthread_create_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn) |
long int | ast_random (void) |
int | ast_remaining_ms (struct timeval start, int max_ms) |
Calculate remaining milliseconds given a starting timestamp and upper bound. | |
void | ast_sha1_hash (char *output, const char *input) |
Produce 40 char SHA1 hash of value. | |
char * | ast_strip_quoted (char *s, const char *beg_quotes, const char *end_quotes) |
Strip leading/trailing whitespace and quotes from a string. | |
int | ast_true (const char *s) |
Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1". | |
struct timeval | ast_tvadd (struct timeval a, struct timeval b) |
Returns the sum of two timevals a + b. | |
struct timeval | ast_tvsub (struct timeval a, struct timeval b) |
Returns the difference of two timevals a - b. | |
char * | ast_unescape_c (char *src) |
Convert some C escape sequences. | |
char * | ast_unescape_semicolon (char *s) |
Strip backslash for "escaped" semicolons, the string to be stripped (will be modified). | |
void | ast_uri_decode (char *s) |
ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string) | |
char * | ast_uri_encode (const char *string, char *outbuf, int buflen, int do_special_char) |
Turn text string to URI-encoded XX version. | |
int | ast_utils_init (void) |
char * | ast_utils_which (const char *binary, char *fullpath, size_t fullpath_size) |
Resolve a binary to a full pathname. | |
int | ast_wait_for_input (int fd, int ms) |
static int | ast_wait_for_output (int fd, int timeoutms) |
int | ast_xml_escape (const char *string, char *const outbuf, const size_t buflen) |
Escape reserved characters for use in XML. | |
static void | base64_init (void) |
static void * | dummy_start (void *data) |
static size_t | optimal_alloc_size (size_t size) |
static struct timeval | tvfix (struct timeval a) |
Variables | |
ast_string_field | __ast_string_field_empty = __ast_string_field_empty_buffer.string |
struct { | |
ast_string_field_allocation allocation | |
char string [1] | |
} | __ast_string_field_empty_buffer |
static char | b2a [256] |
static char | base64 [64] |
static int | dev_urandom_fd |
static ast_mutex_t | fetchadd_m = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } |
static struct ast_threadstorage | inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , } |
static ast_mutex_t | randomlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } |
glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not. |
Utility functions.
Definition in file utils.c.
#define ALLOCATOR_OVERHEAD 48 |
Definition at line 1609 of file utils.c.
Referenced by optimal_alloc_size().
#define ONE_MILLION 1000000 |
Definition at line 1449 of file utils.c.
Referenced by ast_tvadd(), ast_tvsub(), and tvfix().
void* __ast_calloc_with_stringfields | ( | unsigned int | num_structs, | |
size_t | struct_size, | |||
size_t | field_mgr_offset, | |||
size_t | field_mgr_pool_offset, | |||
size_t | pool_size, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) |
Definition at line 1888 of file utils.c.
References __ast_calloc(), allocation, ast_calloc, ast_string_field_pool::base, ast_string_field_mgr::embedded_pool, optimal_alloc_size(), ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, ast_string_field_mgr::owner_line, and ast_string_field_pool::size.
01891 { 01892 struct ast_string_field_mgr *mgr; 01893 struct ast_string_field_pool *pool; 01894 struct ast_string_field_pool **pool_head; 01895 size_t pool_size_needed = sizeof(*pool) + pool_size; 01896 size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed); 01897 void *allocation; 01898 unsigned int x; 01899 01900 #if defined(__AST_DEBUG_MALLOC) 01901 if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) { 01902 return NULL; 01903 } 01904 #else 01905 if (!(allocation = ast_calloc(num_structs, size_to_alloc))) { 01906 return NULL; 01907 } 01908 #endif 01909 01910 for (x = 0; x < num_structs; x++) { 01911 void *base = allocation + (size_to_alloc * x); 01912 const char **p; 01913 01914 mgr = base + field_mgr_offset; 01915 pool_head = base + field_mgr_pool_offset; 01916 pool = base + struct_size; 01917 01918 p = (const char **) pool_head + 1; 01919 while ((struct ast_string_field_mgr *) p != mgr) { 01920 *p++ = __ast_string_field_empty; 01921 } 01922 01923 mgr->embedded_pool = pool; 01924 *pool_head = pool; 01925 pool->size = size_to_alloc - struct_size - sizeof(*pool); 01926 #if defined(__AST_DEBUG_MALLOC) 01927 mgr->owner_file = file; 01928 mgr->owner_func = func; 01929 mgr->owner_line = lineno; 01930 #endif 01931 } 01932 01933 return allocation; 01934 }
ast_string_field __ast_string_field_alloc_space | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | needed | |||
) |
Definition at line 1729 of file utils.c.
References add_string_pool(), ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, ast_string_field_mgr::last_alloc, ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, and ast_string_field_mgr::owner_line.
Referenced by __ast_string_field_ptr_build_va().
01731 { 01732 char *result = NULL; 01733 size_t space = (*pool_head)->size - (*pool_head)->used; 01734 size_t to_alloc; 01735 01736 /* Make room for ast_string_field_allocation and make it a multiple of that. */ 01737 to_alloc = ast_make_room_for(needed, ast_string_field_allocation); 01738 ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0); 01739 01740 if (__builtin_expect(to_alloc > space, 0)) { 01741 size_t new_size = (*pool_head)->size; 01742 01743 while (new_size < to_alloc) { 01744 new_size *= 2; 01745 } 01746 01747 #if defined(__AST_DEBUG_MALLOC) 01748 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func)) 01749 return NULL; 01750 #else 01751 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__)) 01752 return NULL; 01753 #endif 01754 } 01755 01756 /* pool->base is always aligned (gcc aligned attribute). We ensure that 01757 * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation) 01758 * causing result to always be aligned as well; which in turn fixes that 01759 * AST_STRING_FIELD_ALLOCATION(result) is aligned. */ 01760 result = (*pool_head)->base + (*pool_head)->used; 01761 (*pool_head)->used += to_alloc; 01762 (*pool_head)->active += needed; 01763 result += ast_alignof(ast_string_field_allocation); 01764 AST_STRING_FIELD_ALLOCATION(result) = needed; 01765 mgr->last_alloc = result; 01766 01767 return result; 01768 }
int __ast_string_field_init | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
int | needed, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) |
Definition at line 1662 of file utils.c.
References ast_string_field_pool::active, add_string_pool(), ast_free, ast_log(), ast_string_field_mgr::embedded_pool, ast_string_field_mgr::last_alloc, LOG_WARNING, ast_string_field_mgr::owner_file, ast_string_field_mgr::owner_func, ast_string_field_mgr::owner_line, ast_string_field_pool::prev, and ast_string_field_pool::used.
01664 { 01665 const char **p = (const char **) pool_head + 1; 01666 struct ast_string_field_pool *cur = NULL; 01667 struct ast_string_field_pool *preserve = NULL; 01668 01669 /* clear fields - this is always necessary */ 01670 while ((struct ast_string_field_mgr *) p != mgr) { 01671 *p++ = __ast_string_field_empty; 01672 } 01673 01674 mgr->last_alloc = NULL; 01675 #if defined(__AST_DEBUG_MALLOC) 01676 mgr->owner_file = file; 01677 mgr->owner_func = func; 01678 mgr->owner_line = lineno; 01679 #endif 01680 if (needed > 0) { /* allocate the initial pool */ 01681 *pool_head = NULL; 01682 mgr->embedded_pool = NULL; 01683 return add_string_pool(mgr, pool_head, needed, file, lineno, func); 01684 } 01685 01686 /* if there is an embedded pool, we can't actually release *all* 01687 * pools, we must keep the embedded one. if the caller is about 01688 * to free the structure that contains the stringfield manager 01689 * and embedded pool anyway, it will be freed as part of that 01690 * operation. 01691 */ 01692 if ((needed < 0) && mgr->embedded_pool) { 01693 needed = 0; 01694 } 01695 01696 if (needed < 0) { /* reset all pools */ 01697 cur = *pool_head; 01698 } else if (mgr->embedded_pool) { /* preserve the embedded pool */ 01699 preserve = mgr->embedded_pool; 01700 cur = *pool_head; 01701 } else { /* preserve the last pool */ 01702 if (*pool_head == NULL) { 01703 ast_log(LOG_WARNING, "trying to reset empty pool\n"); 01704 return -1; 01705 } 01706 preserve = *pool_head; 01707 cur = preserve->prev; 01708 } 01709 01710 if (preserve) { 01711 preserve->prev = NULL; 01712 preserve->used = preserve->active = 0; 01713 } 01714 01715 while (cur) { 01716 struct ast_string_field_pool *prev = cur->prev; 01717 01718 if (cur != preserve) { 01719 ast_free(cur); 01720 } 01721 cur = prev; 01722 } 01723 01724 *pool_head = preserve; 01725 01726 return 0; 01727 }
void __ast_string_field_ptr_build | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
... | ||||
) |
Definition at line 1873 of file utils.c.
References __ast_string_field_ptr_build_va().
01876 { 01877 va_list ap1, ap2; 01878 01879 va_start(ap1, format); 01880 va_start(ap2, format); /* va_copy does not exist on FreeBSD */ 01881 01882 __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2); 01883 01884 va_end(ap1); 01885 va_end(ap2); 01886 }
void __ast_string_field_ptr_build_va | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
va_list | ap1, | |||
va_list | ap2 | |||
) |
Definition at line 1813 of file utils.c.
References __ast_string_field_alloc_space(), __ast_string_field_release_active(), ast_align_for, ast_alignof, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, available(), and ast_string_field_mgr::last_alloc.
Referenced by __ast_string_field_ptr_build().
01816 { 01817 size_t needed; 01818 size_t available; 01819 size_t space = (*pool_head)->size - (*pool_head)->used; 01820 ssize_t grow; 01821 char *target; 01822 01823 /* if the field already has space allocated, try to reuse it; 01824 otherwise, try to use the empty space at the end of the current 01825 pool 01826 */ 01827 if (*ptr != __ast_string_field_empty) { 01828 target = (char *) *ptr; 01829 available = AST_STRING_FIELD_ALLOCATION(*ptr); 01830 if (*ptr == mgr->last_alloc) { 01831 available += space; 01832 } 01833 } else { 01834 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation) 01835 * so we don't need to re-align anything here. 01836 */ 01837 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation); 01838 available = space - ast_alignof(ast_string_field_allocation); 01839 } 01840 01841 needed = vsnprintf(target, available, format, ap1) + 1; 01842 01843 if (needed > available) { 01844 /* the allocation could not be satisfied using the field's current allocation 01845 (if it has one), or the space available in the pool (if it does not). allocate 01846 space for it, adding a new string pool if necessary. 01847 */ 01848 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) { 01849 return; 01850 } 01851 vsprintf(target, format, ap2); 01852 __ast_string_field_release_active(*pool_head, *ptr); 01853 *ptr = target; 01854 } else if (*ptr != target) { 01855 /* the allocation was satisfied using available space in the pool, but not 01856 using the space already allocated to the field 01857 */ 01858 __ast_string_field_release_active(*pool_head, *ptr); 01859 mgr->last_alloc = *ptr = target; 01860 AST_STRING_FIELD_ALLOCATION(target) = needed; 01861 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation); 01862 (*pool_head)->active += needed; 01863 } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) { 01864 /* the allocation was satisfied by using available space in the pool *and* 01865 the field was the last allocated field from the pool, so it grew 01866 */ 01867 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 01868 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation); 01869 (*pool_head)->active += grow; 01870 } 01871 }
int __ast_string_field_ptr_grow | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | needed, | |||
const ast_string_field * | ptr | |||
) |
Definition at line 1770 of file utils.c.
References AST_STRING_FIELD_ALLOCATION, and ast_string_field_mgr::last_alloc.
01773 { 01774 ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr); 01775 size_t space = (*pool_head)->size - (*pool_head)->used; 01776 01777 if (*ptr != mgr->last_alloc) { 01778 return 1; 01779 } 01780 01781 if (space < grow) { 01782 return 1; 01783 } 01784 01785 (*pool_head)->used += grow; 01786 (*pool_head)->active += grow; 01787 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 01788 01789 return 0; 01790 }
void __ast_string_field_release_active | ( | struct ast_string_field_pool * | pool_head, | |
const ast_string_field | ptr | |||
) |
Definition at line 1792 of file utils.c.
References ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, and ast_string_field_pool::prev.
Referenced by __ast_string_field_ptr_build_va().
01794 { 01795 struct ast_string_field_pool *pool, *prev; 01796 01797 if (ptr == __ast_string_field_empty) { 01798 return; 01799 } 01800 01801 for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) { 01802 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) { 01803 pool->active -= AST_STRING_FIELD_ALLOCATION(ptr); 01804 if ((pool->active == 0) && prev) { 01805 prev->prev = pool->prev; 01806 ast_free(pool); 01807 } 01808 break; 01809 } 01810 } 01811 }
static int add_string_pool | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | size, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) | [static] |
add a new block to the pool. We can only allocate from the topmost pool, so the fields in *mgr reflect the size of that only.
Definition at line 1626 of file utils.c.
References __ast_calloc(), ast_calloc, ast_string_field_mgr::last_alloc, optimal_alloc_size(), ast_string_field_pool::prev, and ast_string_field_pool::size.
Referenced by __ast_string_field_alloc_space(), and __ast_string_field_init().
01628 { 01629 struct ast_string_field_pool *pool; 01630 size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size); 01631 01632 #if defined(__AST_DEBUG_MALLOC) 01633 if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) { 01634 return -1; 01635 } 01636 #else 01637 if (!(pool = ast_calloc(1, alloc_size))) { 01638 return -1; 01639 } 01640 #endif 01641 01642 pool->prev = *pool_head; 01643 pool->size = alloc_size - sizeof(*pool); 01644 *pool_head = pool; 01645 mgr->last_alloc = NULL; 01646 01647 return 0; 01648 }
int ast_atomic_fetchadd_int_slow | ( | volatile int * | p, | |
int | v | |||
) |
Definition at line 1940 of file utils.c.
References ast_mutex_lock, ast_mutex_unlock, and fetchadd_m.
01941 { 01942 int ret; 01943 ast_mutex_lock(&fetchadd_m); 01944 ret = *p; 01945 *p += v; 01946 ast_mutex_unlock(&fetchadd_m); 01947 return ret; 01948 }
int ast_base64decode | ( | unsigned char * | dst, | |
const char * | src, | |||
int | max | |||
) |
decode BASE64 encoded text
Decode data from base64.
Definition at line 271 of file utils.c.
Referenced by aes_helper(), ast_check_signature(), base64_helper(), osp_validate_token(), sdp_crypto_process(), and sdp_crypto_setup().
00272 { 00273 int cnt = 0; 00274 unsigned int byte = 0; 00275 unsigned int bits = 0; 00276 int incnt = 0; 00277 while(*src && *src != '=' && (cnt < max)) { 00278 /* Shift in 6 bits of input */ 00279 byte <<= 6; 00280 byte |= (b2a[(int)(*src)]) & 0x3f; 00281 bits += 6; 00282 src++; 00283 incnt++; 00284 /* If we have at least 8 bits left over, take that character 00285 off the top */ 00286 if (bits >= 8) { 00287 bits -= 8; 00288 *dst = (byte >> bits) & 0xff; 00289 dst++; 00290 cnt++; 00291 } 00292 } 00293 /* Don't worry about left over bits, they're extra anyway */ 00294 return cnt; 00295 }
int ast_base64encode | ( | char * | dst, | |
const unsigned char * | src, | |||
int | srclen, | |||
int | max | |||
) |
Encode data in base64.
dst | the destination buffer | |
src | the source data to be encoded | |
srclen | the number of bytes present in the source buffer | |
max | the maximum number of bytes to write into the destination buffer, *including* the terminating NULL character. |
Definition at line 349 of file utils.c.
References ast_base64encode_full().
Referenced by aes_helper(), aji_start_sasl(), ast_sign(), base64_helper(), build_secret(), osp_check_destination(), and sdp_crypto_setup().
00350 { 00351 return ast_base64encode_full(dst, src, srclen, max, 0); 00352 }
int ast_base64encode_full | ( | char * | dst, | |
const unsigned char * | src, | |||
int | srclen, | |||
int | max, | |||
int | linebreaks | |||
) |
encode text to BASE64 coding
Definition at line 298 of file utils.c.
Referenced by ast_base64encode().
00299 { 00300 int cnt = 0; 00301 int col = 0; 00302 unsigned int byte = 0; 00303 int bits = 0; 00304 int cntin = 0; 00305 /* Reserve space for null byte at end of string */ 00306 max--; 00307 while ((cntin < srclen) && (cnt < max)) { 00308 byte <<= 8; 00309 byte |= *(src++); 00310 bits += 8; 00311 cntin++; 00312 if ((bits == 24) && (cnt + 4 <= max)) { 00313 *dst++ = base64[(byte >> 18) & 0x3f]; 00314 *dst++ = base64[(byte >> 12) & 0x3f]; 00315 *dst++ = base64[(byte >> 6) & 0x3f]; 00316 *dst++ = base64[byte & 0x3f]; 00317 cnt += 4; 00318 col += 4; 00319 bits = 0; 00320 byte = 0; 00321 } 00322 if (linebreaks && (cnt < max) && (col == 64)) { 00323 *dst++ = '\n'; 00324 cnt++; 00325 col = 0; 00326 } 00327 } 00328 if (bits && (cnt + 4 <= max)) { 00329 /* Add one last character for the remaining bits, 00330 padding the rest with 0 */ 00331 byte <<= 24 - bits; 00332 *dst++ = base64[(byte >> 18) & 0x3f]; 00333 *dst++ = base64[(byte >> 12) & 0x3f]; 00334 if (bits == 16) 00335 *dst++ = base64[(byte >> 6) & 0x3f]; 00336 else 00337 *dst++ = '='; 00338 *dst++ = '='; 00339 cnt += 4; 00340 } 00341 if (linebreaks && (cnt < max)) { 00342 *dst++ = '\n'; 00343 cnt++; 00344 } 00345 *dst = '\0'; 00346 return cnt; 00347 }
int ast_build_string | ( | char ** | buffer, | |
size_t * | space, | |||
const char * | fmt, | |||
... | ||||
) |
Build a string in a buffer, designed to be called repeatedly.
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 |
0 | on success | |
non-zero | on failure. |
Definition at line 1403 of file utils.c.
References ast_build_string_va().
Referenced by ast_fax_caps_to_str(), config_odbc(), generate_filenames_string(), handle_speechrecognize(), pp_each_extension_helper(), and pp_each_user_helper().
01404 { 01405 va_list ap; 01406 int result; 01407 01408 va_start(ap, fmt); 01409 result = ast_build_string_va(buffer, space, fmt, ap); 01410 va_end(ap); 01411 01412 return result; 01413 }
int ast_build_string_va | ( | char ** | buffer, | |
size_t * | space, | |||
const char * | fmt, | |||
va_list | ap | |||
) |
Build a string in a buffer, designed to be called repeatedly.
This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.
buffer | current position in buffer to place string into (will be updated on return) | |
space | remaining space in buffer (will be updated on return) | |
fmt | printf-style format string | |
ap | varargs list of arguments for format |
Definition at line 1384 of file utils.c.
Referenced by ast_build_string().
01385 { 01386 int result; 01387 01388 if (!buffer || !*buffer || !space || !*space) 01389 return -1; 01390 01391 result = vsnprintf(*buffer, *space, fmt, ap); 01392 01393 if (result < 0) 01394 return -1; 01395 else if (result > *space) 01396 result = *space; 01397 01398 *buffer += result; 01399 *space -= result; 01400 return 0; 01401 }
int ast_careful_fwrite | ( | FILE * | f, | |
int | fd, | |||
const char * | s, | |||
size_t | len, | |||
int | timeoutms | |||
) |
Write data to a file stream with a timeout.
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 1258 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, and LOG_ERROR.
Referenced by send_string().
01259 { 01260 struct timeval start = ast_tvnow(); 01261 int n = 0; 01262 int elapsed = 0; 01263 01264 while (len) { 01265 if (ast_wait_for_output(fd, timeoutms - elapsed)) { 01266 /* poll returned a fatal error, so bail out immediately. */ 01267 return -1; 01268 } 01269 01270 /* Clear any errors from a previous write */ 01271 clearerr(f); 01272 01273 n = fwrite(src, 1, len, f); 01274 01275 if (ferror(f) && errno != EINTR && errno != EAGAIN) { 01276 /* fatal error from fwrite() */ 01277 if (!feof(f)) { 01278 /* Don't spam the logs if it was just that the connection is closed. */ 01279 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno)); 01280 } 01281 n = -1; 01282 break; 01283 } 01284 01285 /* Update for data already written to the socket */ 01286 len -= n; 01287 src += n; 01288 01289 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01290 if (elapsed >= timeoutms) { 01291 /* We've taken too long to write 01292 * This is only an error condition if we haven't finished writing. */ 01293 n = len ? -1 : 0; 01294 break; 01295 } 01296 } 01297 01298 while (fflush(f)) { 01299 if (errno == EAGAIN || errno == EINTR) { 01300 continue; 01301 } 01302 if (!feof(f)) { 01303 /* Don't spam the logs if it was just that the connection is closed. */ 01304 ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno)); 01305 } 01306 n = -1; 01307 break; 01308 } 01309 01310 return n < 0 ? -1 : 0; 01311 }
int ast_carefulwrite | ( | int | fd, | |
char * | s, | |||
int | len, | |||
int | timeoutms | |||
) |
Try to write string, but wait no more than ms milliseconds before timing out.
Try to write string, but wait no more than ms milliseconds before timing out.
Definition at line 1217 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), ast_wait_for_output(), errno, and LOG_ERROR.
Referenced by ast_agi_send(), and ast_cli().
01218 { 01219 struct timeval start = ast_tvnow(); 01220 int res = 0; 01221 int elapsed = 0; 01222 01223 while (len) { 01224 if (ast_wait_for_output(fd, timeoutms - elapsed)) { 01225 return -1; 01226 } 01227 01228 res = write(fd, s, len); 01229 01230 if (res < 0 && errno != EAGAIN && errno != EINTR) { 01231 /* fatal error from write() */ 01232 ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno)); 01233 return -1; 01234 } 01235 01236 if (res < 0) { 01237 /* It was an acceptable error */ 01238 res = 0; 01239 } 01240 01241 /* Update how much data we have left to write */ 01242 len -= res; 01243 s += res; 01244 res = 0; 01245 01246 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01247 if (elapsed >= timeoutms) { 01248 /* We've taken too long to write 01249 * This is only an error condition if we haven't finished writing. */ 01250 res = len ? -1 : 0; 01251 break; 01252 } 01253 } 01254 01255 return res; 01256 }
void ast_do_crash | ( | void | ) |
Force a crash if DO_CRASH is defined.
Definition at line 2218 of file utils.c.
Referenced by my_do_crash().
void ast_enable_packet_fragmentation | ( | int | sock | ) |
Disable PMTU discovery on a socket.
sock | The socket to manipulate |
On Linux, UDP sockets default to sending packets with the Dont Fragment (DF) bit set. This is supposedly done to allow the application to do PMTU discovery, but Asterisk does not do this.
Because of this, UDP packets sent by Asterisk that are larger than the MTU of any hop in the path will be lost. This function can be called on a socket to ensure that the DF bit will not be set.
Definition at line 2003 of file utils.c.
References ast_log(), and LOG_WARNING.
Referenced by ast_netsock_bindaddr(), and reload_config().
02004 { 02005 #if defined(HAVE_IP_MTU_DISCOVER) 02006 int val = IP_PMTUDISC_DONT; 02007 02008 if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val))) 02009 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n"); 02010 #endif /* HAVE_IP_MTU_DISCOVER */ 02011 }
char* ast_escape_quoted | ( | const char * | string, | |
char * | outbuf, | |||
int | buflen | |||
) |
escapes characters specified for quoted portions of sip messages
Escape characters found in a quoted string.
Definition at line 423 of file utils.c.
Referenced by initreqprep().
00424 { 00425 const char *ptr = string; 00426 char *out = outbuf; 00427 char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */ 00428 00429 while (*ptr && out - outbuf < buflen - 1) { 00430 if (!(strchr(allow, *ptr)) 00431 && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */ 00432 && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */ 00433 && !((unsigned char) *ptr > 0x7f)) { /* UTF8-nonascii */ 00434 00435 if (out - outbuf >= buflen - 2) { 00436 break; 00437 } 00438 out += sprintf(out, "\\%c", (unsigned char) *ptr); 00439 } else { 00440 *out = *ptr; 00441 out++; 00442 } 00443 ptr++; 00444 } 00445 00446 if (buflen) { 00447 *out = '\0'; 00448 } 00449 00450 return outbuf; 00451 }
int ast_false | ( | const char * | val | ) |
Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0".
0 | if val is a NULL pointer. | |
-1 | if "true". | |
0 | otherwise. |
Definition at line 1432 of file utils.c.
References ast_strlen_zero().
Referenced by __ast_udptl_reload(), acf_faxopt_write(), acf_transaction_write(), actual_load_config(), aji_create_client(), aji_load_config(), aoc_cli_debug_enable(), build_peer(), build_user(), dahdi_set_dnd(), find_realtime(), func_channel_write_real(), handle_common_options(), handle_memory_atexit_list(), handle_memory_atexit_summary(), init_acf_query(), load_config(), load_odbc_config(), manager_mute_mixmonitor(), parse_empty_options(), reload_config(), rtp_reload(), run_agi(), set_config(), set_insecure_flags(), sla_build_trunk(), and strings_to_mask().
01433 { 01434 if (ast_strlen_zero(s)) 01435 return 0; 01436 01437 /* Determine if this is a false value */ 01438 if (!strcasecmp(s, "no") || 01439 !strcasecmp(s, "false") || 01440 !strcasecmp(s, "n") || 01441 !strcasecmp(s, "f") || 01442 !strcasecmp(s, "0") || 01443 !strcasecmp(s, "off")) 01444 return -1; 01445 01446 return 0; 01447 }
int ast_get_time_t | ( | const char * | src, | |
time_t * | dst, | |||
time_t | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 1980 of file utils.c.
References ast_strlen_zero().
Referenced by build_peer(), cache_lookup_internal(), handle_saydatetime(), load_password(), play_message_datetime(), process_clearcache(), realtime_peer(), and sayunixtime_exec().
01981 { 01982 long t; 01983 int scanned; 01984 01985 if (dst == NULL) 01986 return -1; 01987 01988 *dst = _default; 01989 01990 if (ast_strlen_zero(src)) 01991 return -1; 01992 01993 /* only integer at the moment, but one day we could accept more formats */ 01994 if (sscanf(src, "%30ld%n", &t, &scanned) == 1) { 01995 *dst = t; 01996 if (consumed) 01997 *consumed = scanned; 01998 return 0; 01999 } else 02000 return -1; 02001 }
int ast_get_timeval | ( | const char * | src, | |
struct timeval * | dst, | |||
struct timeval | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 1953 of file utils.c.
References ast_strlen_zero().
Referenced by acf_strftime().
01954 { 01955 long double dtv = 0.0; 01956 int scanned; 01957 01958 if (dst == NULL) 01959 return -1; 01960 01961 *dst = _default; 01962 01963 if (ast_strlen_zero(src)) 01964 return -1; 01965 01966 /* only integer at the moment, but one day we could accept more formats */ 01967 if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) { 01968 dst->tv_sec = dtv; 01969 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0; 01970 if (consumed) 01971 *consumed = scanned; 01972 return 0; 01973 } else 01974 return -1; 01975 }
struct hostent* ast_gethostbyname | ( | const char * | host, | |
struct ast_hostent * | hp | |||
) | [read] |
Re-entrant (thread safe) version of gethostbyname that replaces the standard gethostbyname (which is not thread safe).
Thread-safe gethostbyname function to use in Asterisk.
Definition at line 187 of file utils.c.
References ast_hostent::buf, and ast_hostent::hp.
Referenced by __ast_http_load(), app_exec(), ast_parse_arg(), build_peer(), config_load(), config_parse_variables(), create_addr(), festival_exec(), gtalk_load_config(), gtalk_update_stun(), iax_template_parse(), jingle_load_config(), jingle_update_stun(), launch_netscript(), process_sdp(), realtime_peer(), realtime_user(), reload_config(), and set_config().
00188 { 00189 int res; 00190 int herrno; 00191 int dots = 0; 00192 const char *s; 00193 struct hostent *result = NULL; 00194 /* Although it is perfectly legitimate to lookup a pure integer, for 00195 the sake of the sanity of people who like to name their peers as 00196 integers, we break with tradition and refuse to look up a 00197 pure integer */ 00198 s = host; 00199 res = 0; 00200 while (s && *s) { 00201 if (*s == '.') 00202 dots++; 00203 else if (!isdigit(*s)) 00204 break; 00205 s++; 00206 } 00207 if (!s || !*s) { 00208 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */ 00209 if (dots != 3) 00210 return NULL; 00211 memset(hp, 0, sizeof(struct ast_hostent)); 00212 hp->hp.h_addrtype = AF_INET; 00213 hp->hp.h_addr_list = (void *) hp->buf; 00214 hp->hp.h_addr = hp->buf + sizeof(void *); 00215 /* For AF_INET, this will always be 4 */ 00216 hp->hp.h_length = 4; 00217 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0) 00218 return &hp->hp; 00219 return NULL; 00220 00221 } 00222 #ifdef HAVE_GETHOSTBYNAME_R_5 00223 result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno); 00224 00225 if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00226 return NULL; 00227 #else 00228 res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno); 00229 00230 if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00231 return NULL; 00232 #endif 00233 return &hp->hp; 00234 }
const char* ast_inet_ntoa | ( | struct in_addr | ia | ) |
ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa
thread-safe replacement for inet_ntoa().
Definition at line 534 of file utils.c.
References ast_threadstorage_get(), and inet_ntoa_buf.
Referenced by __attempt_transmit(), __find_callno(), __iax2_show_peers(), _skinny_show_device(), _skinny_show_devices(), acf_channel_read(), action_login(), add_ipv4_ie(), add_sdp(), ast_apply_ha(), ast_netsock_bindaddr(), ast_parse_arg(), auth_http_callback(), authenticate(), calltoken_required(), check_access(), config_load(), create_client(), data_get_xml_add_child(), data_result_manager_output(), data_result_print_cli_node(), do_message(), dump_addr(), dump_ipaddr(), dundi_rexmit(), dundi_show_peer(), dundi_show_peers(), dundi_show_trans(), dundi_showframe(), dundi_xmit(), external_rtp_create(), find_command(), find_peer(), find_subchannel_and_lock(), find_tpeer(), function_iaxpeer(), generic_http_callback(), get_input(), gtalk_update_externip(), gtalk_update_stun(), handle_call_token(), handle_cli_iax2_set_debug(), handle_cli_iax2_show_callno_limits(), handle_cli_iax2_show_channels(), handle_cli_iax2_show_peer(), handle_cli_iax2_show_registry(), handle_command_response(), handle_error(), handle_mgcp_show_endpoints(), handle_open_receive_channel_ack_message(), handle_request(), handle_show_http(), handle_showmanconn(), handle_skinny_show_settings(), iax2_ack_registry(), iax2_prov_app(), iax2_trunk_queue(), iax_server(), iax_showframe(), jingle_create_candidates(), load_module(), manager_iax2_show_peer_list(), manager_iax2_show_registry(), mgcpsock_read(), oh323_addrcmp_str(), oh323_call(), oh323_set_rtp_peer(), parsing(), peercnt_add(), peercnt_modify(), peercnt_remove(), peers_data_provider_get(), phoneprov_callback(), process_request(), process_sdp(), purge_sessions(), raw_hangup(), realtime_peer(), realtime_user(), register_verify(), registry_rerequest(), reload_config(), resend_response(), sched_delay_remove(), score_address(), send_packet(), send_raw_client(), send_request(), send_response(), send_trunk(), session_do(), set_config(), set_peercnt_limit(), setup_incoming_call(), show_main_page(), skinny_session(), skinny_set_rtp_peer(), socket_process(), socket_process_meta(), start_rtp(), stun_monitor_request(), timing_read(), unistim_info(), unistimsock_read(), and update_registry().
00535 { 00536 char *buf; 00537 00538 if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN))) 00539 return ""; 00540 00541 return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN); 00542 }
void ast_join | ( | char * | s, | |
size_t | len, | |||
const char *const | w[] | |||
) |
Definition at line 1572 of file utils.c.
Referenced by __ast_cli_generator(), ast_agi_register(), ast_agi_unregister(), ast_cli_command_full(), cli_console_sendtext(), console_sendtext(), find_best(), handle_cli_agi_show(), handle_cli_check_permissions(), handle_help(), help1(), help_workhorse(), set_full_cmd(), and write_htmldump().
01573 { 01574 int x, ofs = 0; 01575 const char *src; 01576 01577 /* Join words into a string */ 01578 if (!s) 01579 return; 01580 for (x = 0; ofs < len && w[x]; x++) { 01581 if (x > 0) 01582 s[ofs++] = ' '; 01583 for (src = w[x]; *src && ofs < len; src++) 01584 s[ofs++] = *src; 01585 } 01586 if (ofs == len) 01587 ofs--; 01588 s[ofs] = '\0'; 01589 }
void ast_md5_hash | ( | char * | output, | |
const char * | input | |||
) |
Produce 32 char MD5 hash of value.
Produces MD5 hash based on input string.
Definition at line 237 of file utils.c.
References MD5Final(), MD5Init(), and MD5Update().
Referenced by __init_manager(), auth_exec(), auth_http_callback(), build_reply_digest(), check_auth(), and md5().
00238 { 00239 struct MD5Context md5; 00240 unsigned char digest[16]; 00241 char *ptr; 00242 int x; 00243 00244 MD5Init(&md5); 00245 MD5Update(&md5, (const unsigned char *) input, strlen(input)); 00246 MD5Final(digest, &md5); 00247 ptr = output; 00248 for (x = 0; x < 16; x++) 00249 ptr += sprintf(ptr, "%2.2x", digest[x]); 00250 }
int ast_mkdir | ( | const char * | path, | |
int | mode | |||
) |
Recursively create directory path.
path | The directory path to create | |
mode | The permissions with which to try to create the directory |
Creates a directory path, creating parent directories as needed.
Definition at line 2013 of file utils.c.
References ast_alloca, ast_strdupa, errno, and len().
Referenced by ast_monitor_change_fname(), ast_monitor_start(), conf_run(), create_dirpath(), dictate_exec(), filename_parse(), init_logger(), load_module(), mixmonitor_exec(), record_exec(), reload_logger(), remove_from_queue(), setup_privacy_args(), sms_nextoutgoing(), sms_writefile(), testclient_exec(), testserver_exec(), and write_history().
02014 { 02015 char *ptr; 02016 int len = strlen(path), count = 0, x, piececount = 0; 02017 char *tmp = ast_strdupa(path); 02018 char **pieces; 02019 char *fullpath = ast_alloca(len + 1); 02020 int res = 0; 02021 02022 for (ptr = tmp; *ptr; ptr++) { 02023 if (*ptr == '/') 02024 count++; 02025 } 02026 02027 /* Count the components to the directory path */ 02028 pieces = ast_alloca(count * sizeof(*pieces)); 02029 for (ptr = tmp; *ptr; ptr++) { 02030 if (*ptr == '/') { 02031 *ptr = '\0'; 02032 pieces[piececount++] = ptr + 1; 02033 } 02034 } 02035 02036 *fullpath = '\0'; 02037 for (x = 0; x < piececount; x++) { 02038 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */ 02039 strcat(fullpath, "/"); 02040 strcat(fullpath, pieces[x]); 02041 res = mkdir(fullpath, mode); 02042 if (res && errno != EEXIST) 02043 return errno; 02044 } 02045 return 0; 02046 }
int ast_parse_digest | ( | const char * | digest, | |
struct ast_http_digest * | d, | |||
int | request, | |||
int | pedantic | |||
) |
Parse digest authorization header.
Definition at line 2070 of file utils.c.
References ast_free, ast_log(), ast_skip_blanks(), ast_str_buffer(), ast_str_create(), ast_str_set(), ast_string_field_ptr_set, ast_string_field_set, ast_strlen_zero(), ast_unescape_c(), ast_http_digest::cnonce, ast_http_digest::domain, LOG_WARNING, ast_http_digest::nc, ast_http_digest::nonce, ast_http_digest::opaque, ast_http_digest::qop, ast_http_digest::realm, ast_http_digest::response, ast_http_digest::uri, and ast_http_digest::username.
Referenced by auth_http_callback().
02070 { 02071 char *c; 02072 struct ast_str *str = ast_str_create(16); 02073 02074 /* table of recognised keywords, and places where they should be copied */ 02075 const struct x { 02076 const char *key; 02077 const ast_string_field *field; 02078 } *i, keys[] = { 02079 { "username=", &d->username }, 02080 { "realm=", &d->realm }, 02081 { "nonce=", &d->nonce }, 02082 { "uri=", &d->uri }, 02083 { "domain=", &d->domain }, 02084 { "response=", &d->response }, 02085 { "cnonce=", &d->cnonce }, 02086 { "opaque=", &d->opaque }, 02087 /* Special cases that cannot be directly copied */ 02088 { "algorithm=", NULL }, 02089 { "qop=", NULL }, 02090 { "nc=", NULL }, 02091 { NULL, 0 }, 02092 }; 02093 02094 if (ast_strlen_zero(digest) || !d || !str) { 02095 ast_free(str); 02096 return -1; 02097 } 02098 02099 ast_str_set(&str, 0, "%s", digest); 02100 02101 c = ast_skip_blanks(ast_str_buffer(str)); 02102 02103 if (strncasecmp(c, "Digest ", strlen("Digest "))) { 02104 ast_log(LOG_WARNING, "Missing Digest.\n"); 02105 ast_free(str); 02106 return -1; 02107 } 02108 c += strlen("Digest "); 02109 02110 /* lookup for keys/value pair */ 02111 while (c && *c && *(c = ast_skip_blanks(c))) { 02112 /* find key */ 02113 for (i = keys; i->key != NULL; i++) { 02114 char *src, *separator; 02115 int unescape = 0; 02116 if (strncasecmp(c, i->key, strlen(i->key)) != 0) { 02117 continue; 02118 } 02119 02120 /* Found. Skip keyword, take text in quotes or up to the separator. */ 02121 c += strlen(i->key); 02122 if (*c == '"') { 02123 src = ++c; 02124 separator = "\""; 02125 unescape = 1; 02126 } else { 02127 src = c; 02128 separator = ","; 02129 } 02130 strsep(&c, separator); /* clear separator and move ptr */ 02131 if (unescape) { 02132 ast_unescape_c(src); 02133 } 02134 if (i->field) { 02135 ast_string_field_ptr_set(d, i->field, src); 02136 } else { 02137 /* Special cases that require additional procesing */ 02138 if (!strcasecmp(i->key, "algorithm=")) { 02139 if (strcasecmp(src, "MD5")) { 02140 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src); 02141 ast_free(str); 02142 return -1; 02143 } 02144 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) { 02145 d->qop = 1; 02146 } else if (!strcasecmp(i->key, "nc=")) { 02147 unsigned long u; 02148 if (sscanf(src, "%30lx", &u) != 1) { 02149 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src); 02150 ast_free(str); 02151 return -1; 02152 } 02153 ast_string_field_set(d, nc, src); 02154 } 02155 } 02156 break; 02157 } 02158 if (i->key == NULL) { /* not found, try ',' */ 02159 strsep(&c, ","); 02160 } 02161 } 02162 ast_free(str); 02163 02164 /* Digest checkout */ 02165 if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) { 02166 /* "realm" and "nonce" MUST be always exist */ 02167 return -1; 02168 } 02169 02170 if (!request) { 02171 /* Additional check for Digest response */ 02172 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) { 02173 return -1; 02174 } 02175 02176 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) { 02177 return -1; 02178 } 02179 } 02180 02181 return 0; 02182 }
char* ast_process_quotes_and_slashes | ( | char * | start, | |
char | find, | |||
char | replace_with | |||
) |
Process a string to find and replace characters.
start | The string to analyze | |
find | The character to find | |
replace_with | The character that will replace the one we are looking for |
Definition at line 1546 of file utils.c.
01547 { 01548 char *dataPut = start; 01549 int inEscape = 0; 01550 int inQuotes = 0; 01551 01552 for (; *start; start++) { 01553 if (inEscape) { 01554 *dataPut++ = *start; /* Always goes verbatim */ 01555 inEscape = 0; 01556 } else { 01557 if (*start == '\\') { 01558 inEscape = 1; /* Do not copy \ into the data */ 01559 } else if (*start == '\'') { 01560 inQuotes = 1 - inQuotes; /* Do not copy ' into the data */ 01561 } else { 01562 /* Replace , with |, unless in quotes */ 01563 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start); 01564 } 01565 } 01566 } 01567 if (start != dataPut) 01568 *dataPut = 0; 01569 return dataPut; 01570 }
int ast_pthread_create_detached_stack | ( | pthread_t * | thread, | |
pthread_attr_t * | attr, | |||
void *(*)(void *) | start_routine, | |||
void * | data, | |||
size_t | stacksize, | |||
const char * | file, | |||
const char * | caller, | |||
int | line, | |||
const char * | start_fn | |||
) |
Definition at line 1130 of file utils.c.
References ast_alloca, ast_log(), ast_pthread_create_stack(), errno, LOG_WARNING, and thr_arg::start_routine.
01133 { 01134 unsigned char attr_destroy = 0; 01135 int res; 01136 01137 if (!attr) { 01138 attr = ast_alloca(sizeof(*attr)); 01139 pthread_attr_init(attr); 01140 attr_destroy = 1; 01141 } 01142 01143 if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED))) 01144 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno)); 01145 01146 res = ast_pthread_create_stack(thread, attr, start_routine, data, 01147 stacksize, file, caller, line, start_fn); 01148 01149 if (attr_destroy) 01150 pthread_attr_destroy(attr); 01151 01152 return res; 01153 }
int ast_pthread_create_stack | ( | pthread_t * | thread, | |
pthread_attr_t * | attr, | |||
void *(*)(void *) | start_routine, | |||
void * | data, | |||
size_t | stacksize, | |||
const char * | file, | |||
const char * | caller, | |||
int | line, | |||
const char * | start_fn | |||
) |
Definition at line 1082 of file utils.c.
References ast_alloca, ast_asprintf, ast_log(), ast_malloc, AST_STACKSIZE, thr_arg::data, dummy_start(), errno, LOG_WARNING, thr_arg::name, pthread_create, and thr_arg::start_routine.
Referenced by ast_pthread_create_detached_stack().
01085 { 01086 #if !defined(LOW_MEMORY) 01087 struct thr_arg *a; 01088 #endif 01089 01090 if (!attr) { 01091 attr = ast_alloca(sizeof(*attr)); 01092 pthread_attr_init(attr); 01093 } 01094 01095 #ifdef __linux__ 01096 /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED, 01097 which is kind of useless. Change this here to 01098 PTHREAD_INHERIT_SCHED; that way the -p option to set realtime 01099 priority will propagate down to new threads by default. 01100 This does mean that callers cannot set a different priority using 01101 PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set 01102 the priority afterwards with pthread_setschedparam(). */ 01103 if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED))) 01104 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno)); 01105 #endif 01106 01107 if (!stacksize) 01108 stacksize = AST_STACKSIZE; 01109 01110 if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE))) 01111 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno)); 01112 01113 #if !defined(LOW_MEMORY) 01114 if ((a = ast_malloc(sizeof(*a)))) { 01115 a->start_routine = start_routine; 01116 a->data = data; 01117 start_routine = dummy_start; 01118 if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()", 01119 start_fn, line, file, caller) < 0) { 01120 a->name = NULL; 01121 } 01122 data = a; 01123 } 01124 #endif /* !LOW_MEMORY */ 01125 01126 return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */ 01127 }
long int ast_random | ( | void | ) |
Definition at line 1522 of file utils.c.
References ast_mutex_lock, ast_mutex_unlock, and randomlock.
Referenced by acf_rand_exec(), action_challenge(), add_sdp(), agent_new(), agi_handle_command(), ast_lock_path_lockfile(), ast_moh_files_next(), ast_rtp_change_source(), ast_rtp_new(), ast_udptl_new_with_bindaddr(), auth_http_callback(), authenticate_request(), build_gateway(), build_iv(), build_rand_pad(), build_reply_digest(), calc_metric(), calc_rxstamp(), caldav_write_event(), callno_hash(), create_channel_name(), generate_exchange_uuid(), generate_random_string(), generic_http_callback(), get_trans_id(), gtalk_alloc(), gtalk_create_candidates(), gtalk_new(), handle_incoming(), handle_response_invite(), iax2_key_rotate(), iax2_start_transfer(), jingle_alloc(), jingle_create_candidates(), jingle_new(), load_module(), make_email_file(), make_our_tag(), moh_files_alloc(), multicast_rtp_new(), ogg_vorbis_rewrite(), osp_create_uuid(), page_exec(), park_space_reserve(), process_weights(), reg_source_db(), registry_authrequest(), reqprep(), say_periodic_announcement(), sendmail(), set_nonce_randdata(), sip_alloc(), socket_read(), start_rtp(), stun_req_id(), transmit_invite(), transmit_register(), transmit_response_using_temp(), try_calling(), and try_firmware().
01523 { 01524 long int res; 01525 #ifdef HAVE_DEV_URANDOM 01526 if (dev_urandom_fd >= 0) { 01527 int read_res = read(dev_urandom_fd, &res, sizeof(res)); 01528 if (read_res > 0) { 01529 long int rm = RAND_MAX; 01530 res = res < 0 ? ~res : res; 01531 rm++; 01532 return res % rm; 01533 } 01534 } 01535 #endif 01536 #ifdef linux 01537 res = random(); 01538 #else 01539 ast_mutex_lock(&randomlock); 01540 res = random(); 01541 ast_mutex_unlock(&randomlock); 01542 #endif 01543 return res; 01544 }
int ast_remaining_ms | ( | struct timeval | start, | |
int | max_ms | |||
) |
Calculate remaining milliseconds given a starting timestamp and upper bound.
If the upper bound is negative, then this indicates that there is no upper bound on the amount of time to wait. This will result in a negative return.
start | When timing started being calculated | |
max_ms | The maximum number of milliseconds to wait from start. May be negative. |
Definition at line 1497 of file utils.c.
References ast_tvdiff_ms(), and ast_tvnow().
Referenced by __analog_ss_thread(), __ast_answer(), __ast_request_and_dial(), agent_ack_sleep(), analog_ss_thread(), ast_recvtext(), ast_safe_sleep_conditional(), ast_waitfordigit_full(), async_wait(), dahdi_bridge(), disable_t38(), find_cache(), generic_fax_exec(), local_bridge_loop(), receivefax_t38_init(), record_exec(), remote_bridge_loop(), sendfax_t38_init(), wait_for_answer(), and waitforring_exec().
01498 { 01499 int ms; 01500 01501 if (max_ms < 0) { 01502 ms = max_ms; 01503 } else { 01504 ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start); 01505 if (ms < 0) { 01506 ms = 0; 01507 } 01508 } 01509 01510 return ms; 01511 }
void ast_sha1_hash | ( | char * | output, | |
const char * | input | |||
) |
Produce 40 char SHA1 hash of value.
Produces SHA1 hash based on input string.
Definition at line 253 of file utils.c.
References SHA1Input(), SHA1Reset(), and SHA1Result().
Referenced by aji_act_hook(), handle_call_token(), jabber_make_auth(), and sha1().
00254 { 00255 struct SHA1Context sha; 00256 char *ptr; 00257 int x; 00258 uint8_t Message_Digest[20]; 00259 00260 SHA1Reset(&sha); 00261 00262 SHA1Input(&sha, (const unsigned char *) input, strlen(input)); 00263 00264 SHA1Result(&sha, Message_Digest); 00265 ptr = output; 00266 for (x = 0; x < 20; x++) 00267 ptr += sprintf(ptr, "%2.2x", Message_Digest[x]); 00268 }
char* ast_strip_quoted | ( | char * | s, | |
const char * | beg_quotes, | |||
const char * | end_quotes | |||
) |
Strip leading/trailing whitespace and quotes from a string.
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. |
This functions strips all leading and trailing whitespace characters from the input string, and returns a pointer to the resulting string. The string is modified in place.
It can also remove beginning and ending quote (or quote-like) characters, in matching pairs. If the first character of the string matches any character in beg_quotes, and the last character of the string is the matching character in end_quotes, then they are removed from the string.
Examples:
ast_strip_quoted(buf, "\"", "\""); ast_strip_quoted(buf, "'", "'"); ast_strip_quoted(buf, "[{(", "]})");
Definition at line 1313 of file utils.c.
References ast_strip().
Referenced by ast_register_file_version(), get_rdnis(), iftime(), load_values_config(), parse_allowed_methods(), parse_cookies(), parse_dial_string(), and sip_parse_register_line().
01314 { 01315 char *e; 01316 char *q; 01317 01318 s = ast_strip(s); 01319 if ((q = strchr(beg_quotes, *s)) && *q != '\0') { 01320 e = s + strlen(s) - 1; 01321 if (*e == *(end_quotes + (q - beg_quotes))) { 01322 s++; 01323 *e = '\0'; 01324 } 01325 } 01326 01327 return s; 01328 }
int ast_true | ( | const char * | val | ) |
Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1".
0 | if val is a NULL pointer. | |
-1 | if "true". | |
0 | otherwise. |
Definition at line 1415 of file utils.c.
References ast_strlen_zero().
Referenced by __ast_http_load(), __ast_udptl_reload(), __init_manager(), _parse(), acf_curlopt_write(), acf_faxopt_write(), acf_transaction_write(), action_agent_logoff(), action_bridge(), action_originate(), action_updateconfig(), actual_load_config(), aji_create_client(), aji_load_config(), aoc_cli_debug_enable(), apply_general_options(), apply_option(), apply_outgoing(), ast_bridge_timelimit(), ast_jb_read_conf(), AST_LIST_HEAD_NOLOCK(), ast_plc_reload(), ast_readconfig(), ast_tls_read_conf(), autopause2int(), build_device(), build_gateway(), build_peer(), build_user(), config_parse_variables(), dahdi_set_dnd(), data_search_cmp_bool(), do_reload(), festival_exec(), func_channel_write_real(), func_inheritance_write(), func_mute_write(), get_encrypt_methods(), gtalk_load_config(), handle_common_options(), handle_logger_set_level(), handle_memory_atexit_list(), handle_t38_options(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), local_ast_moh_start(), login_exec(), manager_add_queue_member(), manager_mutestream(), manager_pause_queue_member(), message_template_build(), misdn_answer(), odbc_load_module(), osp_load(), osplookup_exec(), parkinglot_config_read(), parse_config(), parse_empty_options(), pbx_load_config(), pbx_load_users(), process_config(), process_dahdi(), process_echocancel(), queue_set_global_params(), queue_set_param(), read_agent_config(), realtime_directory(), reload_config(), rtp_reload(), run_startup_commands(), search_directory(), set_active(), set_config(), sla_load_config(), smdi_load(), speex_write(), stackpeek_read(), start_monitor_action(), strings_to_mask(), tds_load_module(), update_common_options(), xmldoc_get_syntax_cmd(), xmldoc_get_syntax_fun(), and xmldoc_get_syntax_manager().
01416 { 01417 if (ast_strlen_zero(s)) 01418 return 0; 01419 01420 /* Determine if this is a true value */ 01421 if (!strcasecmp(s, "yes") || 01422 !strcasecmp(s, "true") || 01423 !strcasecmp(s, "y") || 01424 !strcasecmp(s, "t") || 01425 !strcasecmp(s, "1") || 01426 !strcasecmp(s, "on")) 01427 return -1; 01428 01429 return 0; 01430 }
struct timeval ast_tvadd | ( | struct timeval | a, | |
struct timeval | b | |||
) | [read] |
Returns the sum of two timevals a + b.
Definition at line 1469 of file utils.c.
References ONE_MILLION, and tvfix().
Referenced by __get_from_jb(), acf_jabberreceive_read(), agent_hangup(), ast_audiohook_trigger_wait(), ast_channel_bridge(), ast_channel_cmpwhentohangup_tv(), ast_channel_setwhentohangup_tv(), ast_generic_bridge(), ast_poll2(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_end_with_duration(), ast_rtp_sendcng(), 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_run(), sched_settime(), schedule_delivery(), sla_process_timers(), smdi_message_wait(), and timeout_write().
01470 { 01471 /* consistency checks to guarantee usec in 0..999999 */ 01472 a = tvfix(a); 01473 b = tvfix(b); 01474 a.tv_sec += b.tv_sec; 01475 a.tv_usec += b.tv_usec; 01476 if (a.tv_usec >= ONE_MILLION) { 01477 a.tv_sec++; 01478 a.tv_usec -= ONE_MILLION; 01479 } 01480 return a; 01481 }
struct timeval ast_tvsub | ( | struct timeval | a, | |
struct timeval | b | |||
) | [read] |
Returns the difference of two timevals a - b.
Definition at line 1483 of file utils.c.
References ONE_MILLION, and tvfix().
Referenced by ast_channel_bridge(), ast_poll2(), ast_sched_dump(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), debug_check_frame_for_silence(), handle_showcalls(), and handle_showuptime().
01484 { 01485 /* consistency checks to guarantee usec in 0..999999 */ 01486 a = tvfix(a); 01487 b = tvfix(b); 01488 a.tv_sec -= b.tv_sec; 01489 a.tv_usec -= b.tv_usec; 01490 if (a.tv_usec < 0) { 01491 a.tv_sec-- ; 01492 a.tv_usec += ONE_MILLION; 01493 } 01494 return a; 01495 }
char* ast_unescape_c | ( | char * | s | ) |
Convert some C escape sequences.
(\b\f\n\r\t)
into the equivalent characters. The string to be converted (will be modified).
Definition at line 1349 of file utils.c.
Referenced by ast_parse_digest().
01350 { 01351 char c, *ret, *dst; 01352 01353 if (src == NULL) 01354 return NULL; 01355 for (ret = dst = src; (c = *src++); *dst++ = c ) { 01356 if (c != '\\') 01357 continue; /* copy char at the end of the loop */ 01358 switch ((c = *src++)) { 01359 case '\0': /* special, trailing '\' */ 01360 c = '\\'; 01361 break; 01362 case 'b': /* backspace */ 01363 c = '\b'; 01364 break; 01365 case 'f': /* form feed */ 01366 c = '\f'; 01367 break; 01368 case 'n': 01369 c = '\n'; 01370 break; 01371 case 'r': 01372 c = '\r'; 01373 break; 01374 case 't': 01375 c = '\t'; 01376 break; 01377 } 01378 /* default, use the char literally */ 01379 } 01380 *dst = '\0'; 01381 return ret; 01382 }
char* ast_unescape_semicolon | ( | char * | s | ) |
Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).
Definition at line 1330 of file utils.c.
Referenced by sip_cli_notify().
void ast_uri_decode | ( | char * | s | ) |
ast_uri_decode: Decode SIP URI, URN, URL (overwrite the string)
Decode URI, URN, URL (overwrite string).
Definition at line 454 of file utils.c.
Referenced by acf_curl_helper(), config_curl(), get_destination(), get_name_and_number(), get_refer_info(), handle_request_invite(), http_decode(), parse_moved_contact(), realtime_curl(), realtime_multi_curl(), sip_new(), sip_uri_cmp(), and uridecode().
00455 { 00456 char *o; 00457 unsigned int tmp; 00458 00459 for (o = s; *s; s++, o++) { 00460 if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) { 00461 /* have '%', two chars and correct parsing */ 00462 *o = tmp; 00463 s += 2; /* Will be incremented once more when we break out */ 00464 } else /* all other cases, just copy */ 00465 *o = *s; 00466 } 00467 *o = '\0'; 00468 }
char* ast_uri_encode | ( | const char * | string, | |
char * | outbuf, | |||
int | buflen, | |||
int | do_special_char | |||
) |
Turn text string to URI-encoded XX version.
Definition at line 390 of file utils.c.
Referenced by add_rpid(), build_contact(), config_curl(), destroy_curl(), initreqprep(), launch_asyncagi(), realtime_curl(), realtime_multi_curl(), require_curl(), store_curl(), update2_curl(), update_curl(), and uriencode().
00391 { 00392 const char *ptr = string; /* Start with the string */ 00393 char *out = outbuf; 00394 const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */ 00395 00396 while (*ptr && out - outbuf < buflen - 1) { 00397 if ((const signed char) *ptr < 32 || *ptr == 0x7f || *ptr == '%' || 00398 (do_special_char && 00399 !(*ptr >= '0' && *ptr <= '9') && /* num */ 00400 !(*ptr >= 'A' && *ptr <= 'Z') && /* ALPHA */ 00401 !(*ptr >= 'a' && *ptr <= 'z') && /* alpha */ 00402 !strchr(mark, *ptr))) { /* mark set */ 00403 if (out - outbuf >= buflen - 3) { 00404 break; 00405 } 00406 00407 out += sprintf(out, "%%%02X", (unsigned char) *ptr); 00408 } else { 00409 *out = *ptr; /* Continue copying the string */ 00410 out++; 00411 } 00412 ptr++; 00413 } 00414 00415 if (buflen) { 00416 *out = '\0'; 00417 } 00418 00419 return outbuf; 00420 }
int ast_utils_init | ( | void | ) |
Definition at line 2048 of file utils.c.
References ARRAY_LEN, ast_cli_register_multiple(), and base64_init().
Referenced by main().
02049 { 02050 #ifdef HAVE_DEV_URANDOM 02051 dev_urandom_fd = open("/dev/urandom", O_RDONLY); 02052 #endif 02053 base64_init(); 02054 #ifdef DEBUG_THREADS 02055 #if !defined(LOW_MEMORY) 02056 ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli)); 02057 #endif 02058 #endif 02059 return 0; 02060 }
char* ast_utils_which | ( | const char * | binary, | |
char * | fullpath, | |||
size_t | fullpath_size | |||
) |
Resolve a binary to a full pathname.
binary | Name of the executable to resolve | |
fullpath | Buffer to hold the complete pathname | |
fullpath_size | Size of fullpath |
NULL | binary was not found or the environment variable PATH is not set |
Definition at line 2200 of file utils.c.
References ast_strdupa.
Referenced by ast_bt_get_symbols().
02201 { 02202 const char *envPATH = getenv("PATH"); 02203 char *tpath, *path; 02204 struct stat unused; 02205 if (!envPATH) { 02206 return NULL; 02207 } 02208 tpath = ast_strdupa(envPATH); 02209 while ((path = strsep(&tpath, ":"))) { 02210 snprintf(fullpath, fullpath_size, "%s/%s", path, binary); 02211 if (!stat(fullpath, &unused)) { 02212 return fullpath; 02213 } 02214 } 02215 return NULL; 02216 }
int ast_wait_for_input | ( | int | fd, | |
int | ms | |||
) |
Definition at line 1155 of file utils.c.
References ast_poll.
Referenced by action_waitevent(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), moh_class_destructor(), sip_tcp_read(), and sip_tls_read().
01156 { 01157 struct pollfd pfd[1]; 01158 memset(pfd, 0, sizeof(pfd)); 01159 pfd[0].fd = fd; 01160 pfd[0].events = POLLIN|POLLPRI; 01161 return ast_poll(pfd, 1, ms); 01162 }
static int ast_wait_for_output | ( | int | fd, | |
int | timeoutms | |||
) | [static] |
Definition at line 1164 of file utils.c.
References ast_debug, ast_log(), ast_poll, ast_tvdiff_ms(), ast_tvnow(), errno, and LOG_ERROR.
Referenced by ast_careful_fwrite(), and ast_carefulwrite().
01165 { 01166 struct pollfd pfd = { 01167 .fd = fd, 01168 .events = POLLOUT, 01169 }; 01170 int res; 01171 struct timeval start = ast_tvnow(); 01172 int elapsed = 0; 01173 01174 /* poll() until the fd is writable without blocking */ 01175 while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) { 01176 if (res == 0) { 01177 /* timed out. */ 01178 #ifndef STANDALONE 01179 ast_debug(1, "Timed out trying to write\n"); 01180 #endif 01181 return -1; 01182 } else if (res == -1) { 01183 /* poll() returned an error, check to see if it was fatal */ 01184 01185 if (errno == EINTR || errno == EAGAIN) { 01186 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01187 if (elapsed >= timeoutms) { 01188 return -1; 01189 } 01190 /* This was an acceptable error, go back into poll() */ 01191 continue; 01192 } 01193 01194 /* Fatal error, bail. */ 01195 ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno)); 01196 01197 return -1; 01198 } 01199 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01200 if (elapsed >= timeoutms) { 01201 return -1; 01202 } 01203 } 01204 01205 return 0; 01206 }
int ast_xml_escape | ( | const char * | string, | |
char * | outbuf, | |||
size_t | buflen | |||
) |
Escape reserved characters for use in XML.
ast_xml_escape If outbuf is too short, the output string will be truncated. Regardless, the output will always be null terminated.
string | String to be converted | |
outbuf | Resulting encoded string | |
buflen | Size of output buffer |
Definition at line 470 of file utils.c.
References ast_assert, entity, and len().
Referenced by state_notify_build_xml().
00471 { 00472 char *dst = outbuf; 00473 char *end = outbuf + buflen - 1; /* save one for the null terminator */ 00474 00475 /* Handle the case for the empty output buffer */ 00476 if (buflen == 0) { 00477 return -1; 00478 } 00479 00480 /* Escaping rules from http://www.w3.org/TR/REC-xml/#syntax */ 00481 /* This also prevents partial entities at the end of a string */ 00482 while (*string && dst < end) { 00483 const char *entity = NULL; 00484 int len = 0; 00485 00486 switch (*string) { 00487 case '<': 00488 entity = "<"; 00489 len = 4; 00490 break; 00491 case '&': 00492 entity = "&"; 00493 len = 5; 00494 break; 00495 case '>': 00496 /* necessary if ]]> is in the string; easier to escape them all */ 00497 entity = ">"; 00498 len = 4; 00499 break; 00500 case '\'': 00501 /* necessary in single-quoted strings; easier to escape them all */ 00502 entity = "'"; 00503 len = 6; 00504 break; 00505 case '"': 00506 /* necessary in double-quoted strings; easier to escape them all */ 00507 entity = """; 00508 len = 6; 00509 break; 00510 default: 00511 *dst++ = *string++; 00512 break; 00513 } 00514 00515 if (entity) { 00516 ast_assert(len == strlen(entity)); 00517 if (end - dst < len) { 00518 /* no room for the entity; stop */ 00519 break; 00520 } 00521 /* just checked for length; strcpy is fine */ 00522 strcpy(dst, entity); 00523 dst += len; 00524 ++string; 00525 } 00526 } 00527 /* Write null terminator */ 00528 *dst = '\0'; 00529 /* If any chars are left in string, return failure */ 00530 return *string == '\0' ? 0 : -1; 00531 }
static void base64_init | ( | void | ) | [static] |
Definition at line 354 of file utils.c.
Referenced by ast_utils_init().
00355 { 00356 int x; 00357 memset(b2a, -1, sizeof(b2a)); 00358 /* Initialize base-64 Conversion table */ 00359 for (x = 0; x < 26; x++) { 00360 /* A-Z */ 00361 base64[x] = 'A' + x; 00362 b2a['A' + x] = x; 00363 /* a-z */ 00364 base64[x + 26] = 'a' + x; 00365 b2a['a' + x] = x + 26; 00366 /* 0-9 */ 00367 if (x < 10) { 00368 base64[x + 52] = '0' + x; 00369 b2a['0' + x] = x + 52; 00370 } 00371 } 00372 base64[62] = '+'; 00373 base64[63] = '/'; 00374 b2a[(int)'+'] = 62; 00375 b2a[(int)'/'] = 63; 00376 }
static void* dummy_start | ( | void * | data | ) | [static] |
Definition at line 1040 of file utils.c.
References ast_free, AST_LIST_INSERT_TAIL, AST_MUTEX_KIND, ast_register_thread(), ast_threadstorage_get(), ast_unregister_thread(), thr_arg::data, thr_arg::name, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, thr_arg::start_routine, and strdup.
Referenced by ast_pthread_create_stack().
01041 { 01042 void *ret; 01043 struct thr_arg a = *((struct thr_arg *) data); /* make a local copy */ 01044 #ifdef DEBUG_THREADS 01045 struct thr_lock_info *lock_info; 01046 pthread_mutexattr_t mutex_attr; 01047 01048 if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info)))) 01049 return NULL; 01050 01051 lock_info->thread_id = pthread_self(); 01052 lock_info->thread_name = strdup(a.name); 01053 01054 pthread_mutexattr_init(&mutex_attr); 01055 pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND); 01056 pthread_mutex_init(&lock_info->lock, &mutex_attr); 01057 pthread_mutexattr_destroy(&mutex_attr); 01058 01059 pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 01060 AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry); 01061 pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 01062 #endif /* DEBUG_THREADS */ 01063 01064 /* note that even though data->name is a pointer to allocated memory, 01065 we are not freeing it here because ast_register_thread is going to 01066 keep a copy of the pointer and then ast_unregister_thread will 01067 free the memory 01068 */ 01069 ast_free(data); 01070 ast_register_thread(a.name); 01071 pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self()); 01072 01073 ret = a.start_routine(a.data); 01074 01075 pthread_cleanup_pop(1); 01076 01077 return ret; 01078 }
static size_t optimal_alloc_size | ( | size_t | size | ) | [static] |
Definition at line 1611 of file utils.c.
References ALLOCATOR_OVERHEAD.
Referenced by __ast_calloc_with_stringfields(), and add_string_pool().
01612 { 01613 unsigned int count; 01614 01615 size += ALLOCATOR_OVERHEAD; 01616 01617 for (count = 1; size; size >>= 1, count++); 01618 01619 return (1 << count) - ALLOCATOR_OVERHEAD; 01620 }
static struct timeval tvfix | ( | struct timeval | a | ) | [static, read] |
Definition at line 1454 of file utils.c.
References ast_log(), LOG_WARNING, and ONE_MILLION.
Referenced by ast_tvadd(), and ast_tvsub().
01455 { 01456 if (a.tv_usec >= ONE_MILLION) { 01457 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n", 01458 (long)a.tv_sec, (long int) a.tv_usec); 01459 a.tv_sec += a.tv_usec / ONE_MILLION; 01460 a.tv_usec %= ONE_MILLION; 01461 } else if (a.tv_usec < 0) { 01462 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n", 01463 (long)a.tv_sec, (long int) a.tv_usec); 01464 a.tv_usec = 0; 01465 } 01466 return a; 01467 }
struct { ... } __ast_string_field_empty_buffer [static] |
Definition at line 1603 of file utils.c.
Referenced by __ast_calloc_with_stringfields().
char base64[64] [static] |
Definition at line 70 of file utils.c.
Referenced by aji_start_sasl().
int dev_urandom_fd [static] |
ast_mutex_t fetchadd_m = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static] |
Definition at line 1938 of file utils.c.
Referenced by ast_atomic_fetchadd_int_slow().
struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , } [static] |
Definition at line 73 of file utils.c.
Referenced by ast_inet_ntoa().
ast_mutex_t randomlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static] |
glibc puts a lock inside random(3), so that the results are thread-safe. BSD libc (and others) do not.
Definition at line 1519 of file utils.c.
Referenced by ast_random().
char string[1] |
Definition at line 1604 of file utils.c.
Referenced by private_enum_init().