Utility functions. More...
#include "asterisk.h"
#include <ctype.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <fcntl.h>
#include "asterisk/network.h"
#include "asterisk/ast_version.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_tid (void) |
Get current thread ID. | |
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. | |
void | ast_unescape_quoted (char *quote_str) |
Unescape quotes in a string. | |
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) |
int | ast_wait_for_output (int fd, int ms) |
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) |
static int | wait_for_output (int fd, int timeoutms) |
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 1727 of file utils.c.
Referenced by optimal_alloc_size().
#define ONE_MILLION 1000000 |
Definition at line 1567 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 2026 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.
02029 { 02030 struct ast_string_field_mgr *mgr; 02031 struct ast_string_field_pool *pool; 02032 struct ast_string_field_pool **pool_head; 02033 size_t pool_size_needed = sizeof(*pool) + pool_size; 02034 size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed); 02035 void *allocation; 02036 unsigned int x; 02037 02038 #if defined(__AST_DEBUG_MALLOC) 02039 if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) { 02040 return NULL; 02041 } 02042 #else 02043 if (!(allocation = ast_calloc(num_structs, size_to_alloc))) { 02044 return NULL; 02045 } 02046 #endif 02047 02048 for (x = 0; x < num_structs; x++) { 02049 void *base = allocation + (size_to_alloc * x); 02050 const char **p; 02051 02052 mgr = base + field_mgr_offset; 02053 pool_head = base + field_mgr_pool_offset; 02054 pool = base + struct_size; 02055 02056 p = (const char **) pool_head + 1; 02057 while ((struct ast_string_field_mgr *) p != mgr) { 02058 *p++ = __ast_string_field_empty; 02059 } 02060 02061 mgr->embedded_pool = pool; 02062 *pool_head = pool; 02063 pool->size = size_to_alloc - struct_size - sizeof(*pool); 02064 #if defined(__AST_DEBUG_MALLOC) 02065 mgr->owner_file = file; 02066 mgr->owner_func = func; 02067 mgr->owner_line = lineno; 02068 #endif 02069 } 02070 02071 return allocation; 02072 }
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 1847 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().
01849 { 01850 char *result = NULL; 01851 size_t space = (*pool_head)->size - (*pool_head)->used; 01852 size_t to_alloc; 01853 01854 /* Make room for ast_string_field_allocation and make it a multiple of that. */ 01855 to_alloc = ast_make_room_for(needed, ast_string_field_allocation); 01856 ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0); 01857 01858 if (__builtin_expect(to_alloc > space, 0)) { 01859 size_t new_size = (*pool_head)->size; 01860 01861 while (new_size < to_alloc) { 01862 new_size *= 2; 01863 } 01864 01865 #if defined(__AST_DEBUG_MALLOC) 01866 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func)) 01867 return NULL; 01868 #else 01869 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__)) 01870 return NULL; 01871 #endif 01872 } 01873 01874 /* pool->base is always aligned (gcc aligned attribute). We ensure that 01875 * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation) 01876 * causing result to always be aligned as well; which in turn fixes that 01877 * AST_STRING_FIELD_ALLOCATION(result) is aligned. */ 01878 result = (*pool_head)->base + (*pool_head)->used; 01879 (*pool_head)->used += to_alloc; 01880 (*pool_head)->active += needed; 01881 result += ast_alignof(ast_string_field_allocation); 01882 AST_STRING_FIELD_ALLOCATION(result) = needed; 01883 mgr->last_alloc = result; 01884 01885 return result; 01886 }
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 1780 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.
01782 { 01783 const char **p = (const char **) pool_head + 1; 01784 struct ast_string_field_pool *cur = NULL; 01785 struct ast_string_field_pool *preserve = NULL; 01786 01787 /* clear fields - this is always necessary */ 01788 while ((struct ast_string_field_mgr *) p != mgr) { 01789 *p++ = __ast_string_field_empty; 01790 } 01791 01792 mgr->last_alloc = NULL; 01793 #if defined(__AST_DEBUG_MALLOC) 01794 mgr->owner_file = file; 01795 mgr->owner_func = func; 01796 mgr->owner_line = lineno; 01797 #endif 01798 if (needed > 0) { /* allocate the initial pool */ 01799 *pool_head = NULL; 01800 mgr->embedded_pool = NULL; 01801 return add_string_pool(mgr, pool_head, needed, file, lineno, func); 01802 } 01803 01804 /* if there is an embedded pool, we can't actually release *all* 01805 * pools, we must keep the embedded one. if the caller is about 01806 * to free the structure that contains the stringfield manager 01807 * and embedded pool anyway, it will be freed as part of that 01808 * operation. 01809 */ 01810 if ((needed < 0) && mgr->embedded_pool) { 01811 needed = 0; 01812 } 01813 01814 if (needed < 0) { /* reset all pools */ 01815 cur = *pool_head; 01816 } else if (mgr->embedded_pool) { /* preserve the embedded pool */ 01817 preserve = mgr->embedded_pool; 01818 cur = *pool_head; 01819 } else { /* preserve the last pool */ 01820 if (*pool_head == NULL) { 01821 ast_log(LOG_WARNING, "trying to reset empty pool\n"); 01822 return -1; 01823 } 01824 preserve = *pool_head; 01825 cur = preserve->prev; 01826 } 01827 01828 if (preserve) { 01829 preserve->prev = NULL; 01830 preserve->used = preserve->active = 0; 01831 } 01832 01833 while (cur) { 01834 struct ast_string_field_pool *prev = cur->prev; 01835 01836 if (cur != preserve) { 01837 ast_free(cur); 01838 } 01839 cur = prev; 01840 } 01841 01842 *pool_head = preserve; 01843 01844 return 0; 01845 }
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 2011 of file utils.c.
References __ast_string_field_ptr_build_va().
02014 { 02015 va_list ap1, ap2; 02016 02017 va_start(ap1, format); 02018 va_start(ap2, format); /* va_copy does not exist on FreeBSD */ 02019 02020 __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2); 02021 02022 va_end(ap1); 02023 va_end(ap2); 02024 }
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 1935 of file utils.c.
References __ast_string_field_alloc_space(), __ast_string_field_release_active(), ast_align_for, ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, available(), and ast_string_field_mgr::last_alloc.
Referenced by __ast_string_field_ptr_build().
01938 { 01939 size_t needed; 01940 size_t available; 01941 size_t space = (*pool_head)->size - (*pool_head)->used; 01942 int res; 01943 ssize_t grow; 01944 char *target; 01945 01946 /* if the field already has space allocated, try to reuse it; 01947 otherwise, try to use the empty space at the end of the current 01948 pool 01949 */ 01950 if (*ptr != __ast_string_field_empty) { 01951 target = (char *) *ptr; 01952 available = AST_STRING_FIELD_ALLOCATION(*ptr); 01953 if (*ptr == mgr->last_alloc) { 01954 available += space; 01955 } 01956 } else { 01957 /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation) 01958 * so we don't need to re-align anything here. 01959 */ 01960 target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation); 01961 if (space > ast_alignof(ast_string_field_allocation)) { 01962 available = space - ast_alignof(ast_string_field_allocation); 01963 } else { 01964 available = 0; 01965 } 01966 } 01967 01968 res = vsnprintf(target, available, format, ap1); 01969 if (res < 0) { 01970 /* Are we out of memory? */ 01971 return; 01972 } 01973 if (res == 0) { 01974 __ast_string_field_release_active(*pool_head, *ptr); 01975 *ptr = __ast_string_field_empty; 01976 return; 01977 } 01978 needed = (size_t)res + 1; /* NUL byte */ 01979 01980 if (needed > available) { 01981 /* the allocation could not be satisfied using the field's current allocation 01982 (if it has one), or the space available in the pool (if it does not). allocate 01983 space for it, adding a new string pool if necessary. 01984 */ 01985 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) { 01986 return; 01987 } 01988 vsprintf(target, format, ap2); 01989 __ast_string_field_release_active(*pool_head, *ptr); 01990 *ptr = target; 01991 } else if (*ptr != target) { 01992 /* the allocation was satisfied using available space in the pool, but not 01993 using the space already allocated to the field 01994 */ 01995 __ast_string_field_release_active(*pool_head, *ptr); 01996 mgr->last_alloc = *ptr = target; 01997 ast_assert(needed < (ast_string_field_allocation)-1); 01998 AST_STRING_FIELD_ALLOCATION(target) = (ast_string_field_allocation)needed; 01999 (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation); 02000 (*pool_head)->active += needed; 02001 } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) { 02002 /* the allocation was satisfied by using available space in the pool *and* 02003 the field was the last allocated field from the pool, so it grew 02004 */ 02005 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 02006 (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation); 02007 (*pool_head)->active += grow; 02008 } 02009 }
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 1888 of file utils.c.
References AST_STRING_FIELD_ALLOCATION, and ast_string_field_mgr::last_alloc.
01891 { 01892 ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr); 01893 size_t space = (*pool_head)->size - (*pool_head)->used; 01894 01895 if (*ptr != mgr->last_alloc) { 01896 return 1; 01897 } 01898 01899 if (space < grow) { 01900 return 1; 01901 } 01902 01903 (*pool_head)->used += grow; 01904 (*pool_head)->active += grow; 01905 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 01906 01907 return 0; 01908 }
void __ast_string_field_release_active | ( | struct ast_string_field_pool * | pool_head, | |
const ast_string_field | ptr | |||
) |
Definition at line 1910 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().
01912 { 01913 struct ast_string_field_pool *pool, *prev; 01914 01915 if (ptr == __ast_string_field_empty) { 01916 return; 01917 } 01918 01919 for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) { 01920 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) { 01921 pool->active -= AST_STRING_FIELD_ALLOCATION(ptr); 01922 if (pool->active == 0) { 01923 if (prev) { 01924 prev->prev = pool->prev; 01925 ast_free(pool); 01926 } else { 01927 pool->used = 0; 01928 } 01929 } 01930 break; 01931 } 01932 } 01933 }
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 1744 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().
01746 { 01747 struct ast_string_field_pool *pool; 01748 size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size); 01749 01750 #if defined(__AST_DEBUG_MALLOC) 01751 if (!(pool = __ast_calloc(1, alloc_size, file, lineno, func))) { 01752 return -1; 01753 } 01754 #else 01755 if (!(pool = ast_calloc(1, alloc_size))) { 01756 return -1; 01757 } 01758 #endif 01759 01760 pool->prev = *pool_head; 01761 pool->size = alloc_size - sizeof(*pool); 01762 *pool_head = pool; 01763 mgr->last_alloc = NULL; 01764 01765 return 0; 01766 }
int ast_atomic_fetchadd_int_slow | ( | volatile int * | p, | |
int | v | |||
) |
Definition at line 2078 of file utils.c.
References ast_mutex_lock, ast_mutex_unlock, and fetchadd_m.
02079 { 02080 int ret; 02081 ast_mutex_lock(&fetchadd_m); 02082 ret = *p; 02083 *p += v; 02084 ast_mutex_unlock(&fetchadd_m); 02085 return ret; 02086 }
int ast_base64decode | ( | unsigned char * | dst, | |
const char * | src, | |||
int | max | |||
) |
decode BASE64 encoded text
Decode data from base64.
Definition at line 279 of file utils.c.
Referenced by aes_helper(), ast_check_signature(), base64_helper(), osp_validate_token(), sdp_crypto_process(), and sdp_crypto_setup().
00280 { 00281 int cnt = 0; 00282 unsigned int byte = 0; 00283 unsigned int bits = 0; 00284 int incnt = 0; 00285 while(*src && *src != '=' && (cnt < max)) { 00286 /* Shift in 6 bits of input */ 00287 byte <<= 6; 00288 byte |= (b2a[(int)(*src)]) & 0x3f; 00289 bits += 6; 00290 src++; 00291 incnt++; 00292 /* If we have at least 8 bits left over, take that character 00293 off the top */ 00294 if (bits >= 8) { 00295 bits -= 8; 00296 *dst = (byte >> bits) & 0xff; 00297 dst++; 00298 cnt++; 00299 } 00300 } 00301 /* Don't worry about left over bits, they're extra anyway */ 00302 return cnt; 00303 }
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 357 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().
00358 { 00359 return ast_base64encode_full(dst, src, srclen, max, 0); 00360 }
int ast_base64encode_full | ( | char * | dst, | |
const unsigned char * | src, | |||
int | srclen, | |||
int | max, | |||
int | linebreaks | |||
) |
encode text to BASE64 coding
Definition at line 306 of file utils.c.
Referenced by ast_base64encode().
00307 { 00308 int cnt = 0; 00309 int col = 0; 00310 unsigned int byte = 0; 00311 int bits = 0; 00312 int cntin = 0; 00313 /* Reserve space for null byte at end of string */ 00314 max--; 00315 while ((cntin < srclen) && (cnt < max)) { 00316 byte <<= 8; 00317 byte |= *(src++); 00318 bits += 8; 00319 cntin++; 00320 if ((bits == 24) && (cnt + 4 <= max)) { 00321 *dst++ = base64[(byte >> 18) & 0x3f]; 00322 *dst++ = base64[(byte >> 12) & 0x3f]; 00323 *dst++ = base64[(byte >> 6) & 0x3f]; 00324 *dst++ = base64[byte & 0x3f]; 00325 cnt += 4; 00326 col += 4; 00327 bits = 0; 00328 byte = 0; 00329 } 00330 if (linebreaks && (cnt < max) && (col == 64)) { 00331 *dst++ = '\n'; 00332 cnt++; 00333 col = 0; 00334 } 00335 } 00336 if (bits && (cnt + 4 <= max)) { 00337 /* Add one last character for the remaining bits, 00338 padding the rest with 0 */ 00339 byte <<= 24 - bits; 00340 *dst++ = base64[(byte >> 18) & 0x3f]; 00341 *dst++ = base64[(byte >> 12) & 0x3f]; 00342 if (bits == 16) 00343 *dst++ = base64[(byte >> 6) & 0x3f]; 00344 else 00345 *dst++ = '='; 00346 *dst++ = '='; 00347 cnt += 4; 00348 } 00349 if (linebreaks && (cnt < max)) { 00350 *dst++ = '\n'; 00351 cnt++; 00352 } 00353 *dst = '\0'; 00354 return cnt; 00355 }
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 1521 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().
01522 { 01523 va_list ap; 01524 int result; 01525 01526 va_start(ap, fmt); 01527 result = ast_build_string_va(buffer, space, fmt, ap); 01528 va_end(ap); 01529 01530 return result; 01531 }
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 1502 of file utils.c.
Referenced by ast_build_string().
01503 { 01504 int result; 01505 01506 if (!buffer || !*buffer || !space || !*space) 01507 return -1; 01508 01509 result = vsnprintf(*buffer, *space, fmt, ap); 01510 01511 if (result < 0) 01512 return -1; 01513 else if (result > *space) 01514 result = *space; 01515 01516 *buffer += result; 01517 *space -= result; 01518 return 0; 01519 }
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 1369 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), errno, LOG_ERROR, and wait_for_output().
Referenced by send_string().
01370 { 01371 struct timeval start = ast_tvnow(); 01372 int n = 0; 01373 int elapsed = 0; 01374 01375 while (len) { 01376 if (wait_for_output(fd, timeoutms - elapsed)) { 01377 /* poll returned a fatal error, so bail out immediately. */ 01378 return -1; 01379 } 01380 01381 /* Clear any errors from a previous write */ 01382 clearerr(f); 01383 01384 n = fwrite(src, 1, len, f); 01385 01386 if (ferror(f) && errno != EINTR && errno != EAGAIN) { 01387 /* fatal error from fwrite() */ 01388 if (!feof(f)) { 01389 /* Don't spam the logs if it was just that the connection is closed. */ 01390 ast_log(LOG_ERROR, "fwrite() returned error: %s\n", strerror(errno)); 01391 } 01392 n = -1; 01393 break; 01394 } 01395 01396 /* Update for data already written to the socket */ 01397 len -= n; 01398 src += n; 01399 01400 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01401 if (elapsed >= timeoutms) { 01402 /* We've taken too long to write 01403 * This is only an error condition if we haven't finished writing. */ 01404 n = len ? -1 : 0; 01405 break; 01406 } 01407 } 01408 01409 errno = 0; 01410 while (fflush(f)) { 01411 if (errno == EAGAIN || errno == EINTR) { 01412 /* fflush() does not appear to reset errno if it flushes 01413 * and reaches EOF at the same time. It returns EOF with 01414 * the last seen value of errno, causing a possible loop. 01415 * Also usleep() to reduce CPU eating if it does loop */ 01416 errno = 0; 01417 usleep(1); 01418 continue; 01419 } 01420 if (errno && !feof(f)) { 01421 /* Don't spam the logs if it was just that the connection is closed. */ 01422 ast_log(LOG_ERROR, "fflush() returned error: %s\n", strerror(errno)); 01423 } 01424 n = -1; 01425 break; 01426 } 01427 01428 return n < 0 ? -1 : 0; 01429 }
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 1328 of file utils.c.
References ast_log(), ast_tvdiff_ms(), ast_tvnow(), errno, LOG_ERROR, and wait_for_output().
Referenced by ast_agi_send(), and ast_cli().
01329 { 01330 struct timeval start = ast_tvnow(); 01331 int res = 0; 01332 int elapsed = 0; 01333 01334 while (len) { 01335 if (wait_for_output(fd, timeoutms - elapsed)) { 01336 return -1; 01337 } 01338 01339 res = write(fd, s, len); 01340 01341 if (res < 0 && errno != EAGAIN && errno != EINTR) { 01342 /* fatal error from write() */ 01343 ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno)); 01344 return -1; 01345 } 01346 01347 if (res < 0) { 01348 /* It was an acceptable error */ 01349 res = 0; 01350 } 01351 01352 /* Update how much data we have left to write */ 01353 len -= res; 01354 s += res; 01355 res = 0; 01356 01357 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01358 if (elapsed >= timeoutms) { 01359 /* We've taken too long to write 01360 * This is only an error condition if we haven't finished writing. */ 01361 res = len ? -1 : 0; 01362 break; 01363 } 01364 } 01365 01366 return res; 01367 }
void ast_do_crash | ( | void | ) |
Force a crash if DO_CRASH is defined.
Definition at line 2382 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 2141 of file utils.c.
References ast_log(), and LOG_WARNING.
Referenced by ast_netsock_bindaddr(), and reload_config().
02142 { 02143 #if defined(HAVE_IP_MTU_DISCOVER) 02144 int val = IP_PMTUDISC_DONT; 02145 02146 if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val))) 02147 ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n"); 02148 #endif /* HAVE_IP_MTU_DISCOVER */ 02149 }
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 431 of file utils.c.
Referenced by add_diversion_header(), add_rpid(), ast_callerid_merge(), and initreqprep().
00432 { 00433 const char *ptr = string; 00434 char *out = outbuf; 00435 char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */ 00436 00437 while (*ptr && out - outbuf < buflen - 1) { 00438 if (!(strchr(allow, *ptr)) 00439 && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */ 00440 && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */ 00441 && !((unsigned char) *ptr > 0x7f)) { /* UTF8-nonascii */ 00442 00443 if (out - outbuf >= buflen - 2) { 00444 break; 00445 } 00446 out += sprintf(out, "\\%c", (unsigned char) *ptr); 00447 } else { 00448 *out = *ptr; 00449 out++; 00450 } 00451 ptr++; 00452 } 00453 00454 if (buflen) { 00455 *out = '\0'; 00456 } 00457 00458 return outbuf; 00459 }
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 1550 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().
01551 { 01552 if (ast_strlen_zero(s)) 01553 return 0; 01554 01555 /* Determine if this is a false value */ 01556 if (!strcasecmp(s, "no") || 01557 !strcasecmp(s, "false") || 01558 !strcasecmp(s, "n") || 01559 !strcasecmp(s, "f") || 01560 !strcasecmp(s, "0") || 01561 !strcasecmp(s, "off")) 01562 return -1; 01563 01564 return 0; 01565 }
int ast_get_tid | ( | void | ) |
Get current thread ID.
Definition at line 2346 of file utils.c.
Referenced by __ao2_alloc_debug(), __ao2_ref_debug(), and ast_log().
02347 { 02348 int ret = -1; 02349 #if defined (__linux) && defined(SYS_gettid) 02350 ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */ 02351 #elif defined(__sun) 02352 ret = pthread_self(); 02353 #elif defined(__APPLE__) 02354 ret = mach_thread_self(); 02355 mach_port_deallocate(mach_task_self(), ret); 02356 #elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H) 02357 long lwpid; 02358 thr_self(&lwpid); /* available since sys/thr.h creation 2003 */ 02359 ret = lwpid; 02360 #endif 02361 return ret; 02362 }
int ast_get_time_t | ( | const char * | src, | |
time_t * | dst, | |||
time_t | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 2118 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().
02119 { 02120 long t; 02121 int scanned; 02122 02123 if (dst == NULL) 02124 return -1; 02125 02126 *dst = _default; 02127 02128 if (ast_strlen_zero(src)) 02129 return -1; 02130 02131 /* only integer at the moment, but one day we could accept more formats */ 02132 if (sscanf(src, "%30ld%n", &t, &scanned) == 1) { 02133 *dst = t; 02134 if (consumed) 02135 *consumed = scanned; 02136 return 0; 02137 } else 02138 return -1; 02139 }
int ast_get_timeval | ( | const char * | src, | |
struct timeval * | dst, | |||
struct timeval | _default, | |||
int * | consumed | |||
) |
get values from config variables.
Definition at line 2091 of file utils.c.
References ast_strlen_zero().
Referenced by acf_strftime().
02092 { 02093 long double dtv = 0.0; 02094 int scanned; 02095 02096 if (dst == NULL) 02097 return -1; 02098 02099 *dst = _default; 02100 02101 if (ast_strlen_zero(src)) 02102 return -1; 02103 02104 /* only integer at the moment, but one day we could accept more formats */ 02105 if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) { 02106 dst->tv_sec = dtv; 02107 dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0; 02108 if (consumed) 02109 *consumed = scanned; 02110 return 0; 02111 } else 02112 return -1; 02113 }
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 195 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().
00196 { 00197 int res; 00198 int herrno; 00199 int dots = 0; 00200 const char *s; 00201 struct hostent *result = NULL; 00202 /* Although it is perfectly legitimate to lookup a pure integer, for 00203 the sake of the sanity of people who like to name their peers as 00204 integers, we break with tradition and refuse to look up a 00205 pure integer */ 00206 s = host; 00207 res = 0; 00208 while (s && *s) { 00209 if (*s == '.') 00210 dots++; 00211 else if (!isdigit(*s)) 00212 break; 00213 s++; 00214 } 00215 if (!s || !*s) { 00216 /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */ 00217 if (dots != 3) 00218 return NULL; 00219 memset(hp, 0, sizeof(struct ast_hostent)); 00220 hp->hp.h_addrtype = AF_INET; 00221 hp->hp.h_addr_list = (void *) hp->buf; 00222 hp->hp.h_addr = hp->buf + sizeof(void *); 00223 /* For AF_INET, this will always be 4 */ 00224 hp->hp.h_length = 4; 00225 if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0) 00226 return &hp->hp; 00227 return NULL; 00228 00229 } 00230 #ifdef HAVE_GETHOSTBYNAME_R_5 00231 result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno); 00232 00233 if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00234 return NULL; 00235 #else 00236 res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno); 00237 00238 if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0]) 00239 return NULL; 00240 #endif 00241 return &hp->hp; 00242 }
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 564 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().
00565 { 00566 char *buf; 00567 00568 if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN))) 00569 return ""; 00570 00571 return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN); 00572 }
void ast_join | ( | char * | s, | |
size_t | len, | |||
const char *const | w[] | |||
) |
Definition at line 1690 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().
01691 { 01692 int x, ofs = 0; 01693 const char *src; 01694 01695 /* Join words into a string */ 01696 if (!s) 01697 return; 01698 for (x = 0; ofs < len && w[x]; x++) { 01699 if (x > 0) 01700 s[ofs++] = ' '; 01701 for (src = w[x]; *src && ofs < len; src++) 01702 s[ofs++] = *src; 01703 } 01704 if (ofs == len) 01705 ofs--; 01706 s[ofs] = '\0'; 01707 }
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 245 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().
00246 { 00247 struct MD5Context md5; 00248 unsigned char digest[16]; 00249 char *ptr; 00250 int x; 00251 00252 MD5Init(&md5); 00253 MD5Update(&md5, (const unsigned char *) input, strlen(input)); 00254 MD5Final(digest, &md5); 00255 ptr = output; 00256 for (x = 0; x < 16; x++) 00257 ptr += sprintf(ptr, "%2.2x", (unsigned)digest[x]); 00258 }
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 2151 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().
02152 { 02153 char *ptr; 02154 int len = strlen(path), count = 0, x, piececount = 0; 02155 char *tmp = ast_strdupa(path); 02156 char **pieces; 02157 char *fullpath = ast_alloca(len + 1); 02158 int res = 0; 02159 02160 for (ptr = tmp; *ptr; ptr++) { 02161 if (*ptr == '/') 02162 count++; 02163 } 02164 02165 /* Count the components to the directory path */ 02166 pieces = ast_alloca(count * sizeof(*pieces)); 02167 for (ptr = tmp; *ptr; ptr++) { 02168 if (*ptr == '/') { 02169 *ptr = '\0'; 02170 pieces[piececount++] = ptr + 1; 02171 } 02172 } 02173 02174 *fullpath = '\0'; 02175 for (x = 0; x < piececount; x++) { 02176 /* This looks funky, but the buffer is always ideally-sized, so it's fine. */ 02177 strcat(fullpath, "/"); 02178 strcat(fullpath, pieces[x]); 02179 res = mkdir(fullpath, mode); 02180 if (res && errno != EEXIST) 02181 return errno; 02182 } 02183 return 0; 02184 }
int ast_parse_digest | ( | const char * | digest, | |
struct ast_http_digest * | d, | |||
int | request, | |||
int | pedantic | |||
) |
Parse digest authorization header.
Definition at line 2216 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().
02216 { 02217 char *c; 02218 struct ast_str *str = ast_str_create(16); 02219 02220 /* table of recognised keywords, and places where they should be copied */ 02221 const struct x { 02222 const char *key; 02223 const ast_string_field *field; 02224 } *i, keys[] = { 02225 { "username=", &d->username }, 02226 { "realm=", &d->realm }, 02227 { "nonce=", &d->nonce }, 02228 { "uri=", &d->uri }, 02229 { "domain=", &d->domain }, 02230 { "response=", &d->response }, 02231 { "cnonce=", &d->cnonce }, 02232 { "opaque=", &d->opaque }, 02233 /* Special cases that cannot be directly copied */ 02234 { "algorithm=", NULL }, 02235 { "qop=", NULL }, 02236 { "nc=", NULL }, 02237 { NULL, 0 }, 02238 }; 02239 02240 if (ast_strlen_zero(digest) || !d || !str) { 02241 ast_free(str); 02242 return -1; 02243 } 02244 02245 ast_str_set(&str, 0, "%s", digest); 02246 02247 c = ast_skip_blanks(ast_str_buffer(str)); 02248 02249 if (strncasecmp(c, "Digest ", strlen("Digest "))) { 02250 ast_log(LOG_WARNING, "Missing Digest.\n"); 02251 ast_free(str); 02252 return -1; 02253 } 02254 c += strlen("Digest "); 02255 02256 /* lookup for keys/value pair */ 02257 while (c && *c && *(c = ast_skip_blanks(c))) { 02258 /* find key */ 02259 for (i = keys; i->key != NULL; i++) { 02260 char *src, *separator; 02261 int unescape = 0; 02262 if (strncasecmp(c, i->key, strlen(i->key)) != 0) { 02263 continue; 02264 } 02265 02266 /* Found. Skip keyword, take text in quotes or up to the separator. */ 02267 c += strlen(i->key); 02268 if (*c == '"') { 02269 src = ++c; 02270 separator = "\""; 02271 unescape = 1; 02272 } else { 02273 src = c; 02274 separator = ","; 02275 } 02276 strsep(&c, separator); /* clear separator and move ptr */ 02277 if (unescape) { 02278 ast_unescape_c(src); 02279 } 02280 if (i->field) { 02281 ast_string_field_ptr_set(d, i->field, src); 02282 } else { 02283 /* Special cases that require additional procesing */ 02284 if (!strcasecmp(i->key, "algorithm=")) { 02285 if (strcasecmp(src, "MD5")) { 02286 ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src); 02287 ast_free(str); 02288 return -1; 02289 } 02290 } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) { 02291 d->qop = 1; 02292 } else if (!strcasecmp(i->key, "nc=")) { 02293 unsigned long u; 02294 if (sscanf(src, "%30lx", &u) != 1) { 02295 ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src); 02296 ast_free(str); 02297 return -1; 02298 } 02299 ast_string_field_set(d, nc, src); 02300 } 02301 } 02302 break; 02303 } 02304 if (i->key == NULL) { /* not found, try ',' */ 02305 strsep(&c, ","); 02306 } 02307 } 02308 ast_free(str); 02309 02310 /* Digest checkout */ 02311 if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) { 02312 /* "realm" and "nonce" MUST be always exist */ 02313 return -1; 02314 } 02315 02316 if (!request) { 02317 /* Additional check for Digest response */ 02318 if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) { 02319 return -1; 02320 } 02321 02322 if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) { 02323 return -1; 02324 } 02325 } 02326 02327 return 0; 02328 }
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 1664 of file utils.c.
01665 { 01666 char *dataPut = start; 01667 int inEscape = 0; 01668 int inQuotes = 0; 01669 01670 for (; *start; start++) { 01671 if (inEscape) { 01672 *dataPut++ = *start; /* Always goes verbatim */ 01673 inEscape = 0; 01674 } else { 01675 if (*start == '\\') { 01676 inEscape = 1; /* Do not copy \ into the data */ 01677 } else if (*start == '\'') { 01678 inQuotes = 1 - inQuotes; /* Do not copy ' into the data */ 01679 } else { 01680 /* Replace , with |, unless in quotes */ 01681 *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start); 01682 } 01683 } 01684 } 01685 if (start != dataPut) 01686 *dataPut = 0; 01687 return dataPut; 01688 }
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 1230 of file utils.c.
References ast_alloca, ast_log(), ast_pthread_create_stack(), errno, LOG_WARNING, and thr_arg::start_routine.
01233 { 01234 unsigned char attr_destroy = 0; 01235 int res; 01236 01237 if (!attr) { 01238 attr = ast_alloca(sizeof(*attr)); 01239 pthread_attr_init(attr); 01240 attr_destroy = 1; 01241 } 01242 01243 if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED))) 01244 ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno)); 01245 01246 res = ast_pthread_create_stack(thread, attr, start_routine, data, 01247 stacksize, file, caller, line, start_fn); 01248 01249 if (attr_destroy) 01250 pthread_attr_destroy(attr); 01251 01252 return res; 01253 }
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 1182 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().
01185 { 01186 #if !defined(LOW_MEMORY) 01187 struct thr_arg *a; 01188 #endif 01189 01190 if (!attr) { 01191 attr = ast_alloca(sizeof(*attr)); 01192 pthread_attr_init(attr); 01193 } 01194 01195 #ifdef __linux__ 01196 /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED, 01197 which is kind of useless. Change this here to 01198 PTHREAD_INHERIT_SCHED; that way the -p option to set realtime 01199 priority will propagate down to new threads by default. 01200 This does mean that callers cannot set a different priority using 01201 PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set 01202 the priority afterwards with pthread_setschedparam(). */ 01203 if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED))) 01204 ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno)); 01205 #endif 01206 01207 if (!stacksize) 01208 stacksize = AST_STACKSIZE; 01209 01210 if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE))) 01211 ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno)); 01212 01213 #if !defined(LOW_MEMORY) 01214 if ((a = ast_malloc(sizeof(*a)))) { 01215 a->start_routine = start_routine; 01216 a->data = data; 01217 start_routine = dummy_start; 01218 if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()", 01219 start_fn, line, file, caller) < 0) { 01220 a->name = NULL; 01221 } 01222 data = a; 01223 } 01224 #endif /* !LOW_MEMORY */ 01225 01226 return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */ 01227 }
long int ast_random | ( | void | ) |
Definition at line 1640 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_localtag_registry(), 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().
01641 { 01642 long int res; 01643 #ifdef HAVE_DEV_URANDOM 01644 if (dev_urandom_fd >= 0) { 01645 int read_res = read(dev_urandom_fd, &res, sizeof(res)); 01646 if (read_res > 0) { 01647 long int rm = RAND_MAX; 01648 res = res < 0 ? ~res : res; 01649 rm++; 01650 return res % rm; 01651 } 01652 } 01653 #endif 01654 #ifdef linux 01655 res = random(); 01656 #else 01657 ast_mutex_lock(&randomlock); 01658 res = random(); 01659 ast_mutex_unlock(&randomlock); 01660 #endif 01661 return res; 01662 }
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 1615 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(), tcptls_stream_read(), tcptls_stream_write(), wait_for_answer(), and waitforring_exec().
01616 { 01617 int ms; 01618 01619 if (max_ms < 0) { 01620 ms = max_ms; 01621 } else { 01622 ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start); 01623 if (ms < 0) { 01624 ms = 0; 01625 } 01626 } 01627 01628 return ms; 01629 }
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 261 of file utils.c.
References SHA1Input(), SHA1Reset(), and SHA1Result().
Referenced by aji_act_hook(), handle_call_token(), jabber_make_auth(), and sha1().
00262 { 00263 struct SHA1Context sha; 00264 char *ptr; 00265 int x; 00266 uint8_t Message_Digest[20]; 00267 00268 SHA1Reset(&sha); 00269 00270 SHA1Input(&sha, (const unsigned char *) input, strlen(input)); 00271 00272 SHA1Result(&sha, Message_Digest); 00273 ptr = output; 00274 for (x = 0; x < 20; x++) 00275 ptr += sprintf(ptr, "%2.2x", (unsigned)Message_Digest[x]); 00276 }
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 1431 of file utils.c.
References ast_strip().
Referenced by ast_callerid_parse(), ast_register_file_version(), get_rdnis(), iftime(), load_values_config(), parse_allowed_methods(), parse_cookies(), parse_dial_string(), and sip_parse_register_line().
01432 { 01433 char *e; 01434 char *q; 01435 01436 s = ast_strip(s); 01437 if ((q = strchr(beg_quotes, *s)) && *q != '\0') { 01438 e = s + strlen(s) - 1; 01439 if (*e == *(end_quotes + (q - beg_quotes))) { 01440 s++; 01441 *e = '\0'; 01442 } 01443 } 01444 01445 return s; 01446 }
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 1533 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().
01534 { 01535 if (ast_strlen_zero(s)) 01536 return 0; 01537 01538 /* Determine if this is a true value */ 01539 if (!strcasecmp(s, "yes") || 01540 !strcasecmp(s, "true") || 01541 !strcasecmp(s, "y") || 01542 !strcasecmp(s, "t") || 01543 !strcasecmp(s, "1") || 01544 !strcasecmp(s, "on")) 01545 return -1; 01546 01547 return 0; 01548 }
struct timeval ast_tvadd | ( | struct timeval | a, | |
struct timeval | b | |||
) | [read] |
Returns the sum of two timevals a + b.
Definition at line 1587 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().
01588 { 01589 /* consistency checks to guarantee usec in 0..999999 */ 01590 a = tvfix(a); 01591 b = tvfix(b); 01592 a.tv_sec += b.tv_sec; 01593 a.tv_usec += b.tv_usec; 01594 if (a.tv_usec >= ONE_MILLION) { 01595 a.tv_sec++; 01596 a.tv_usec -= ONE_MILLION; 01597 } 01598 return a; 01599 }
struct timeval ast_tvsub | ( | struct timeval | a, | |
struct timeval | b | |||
) | [read] |
Returns the difference of two timevals a - b.
Definition at line 1601 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().
01602 { 01603 /* consistency checks to guarantee usec in 0..999999 */ 01604 a = tvfix(a); 01605 b = tvfix(b); 01606 a.tv_sec -= b.tv_sec; 01607 a.tv_usec -= b.tv_usec; 01608 if (a.tv_usec < 0) { 01609 a.tv_sec-- ; 01610 a.tv_usec += ONE_MILLION; 01611 } 01612 return a; 01613 }
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 1467 of file utils.c.
Referenced by ast_parse_digest().
01468 { 01469 char c, *ret, *dst; 01470 01471 if (src == NULL) 01472 return NULL; 01473 for (ret = dst = src; (c = *src++); *dst++ = c ) { 01474 if (c != '\\') 01475 continue; /* copy char at the end of the loop */ 01476 switch ((c = *src++)) { 01477 case '\0': /* special, trailing '\' */ 01478 c = '\\'; 01479 break; 01480 case 'b': /* backspace */ 01481 c = '\b'; 01482 break; 01483 case 'f': /* form feed */ 01484 c = '\f'; 01485 break; 01486 case 'n': 01487 c = '\n'; 01488 break; 01489 case 'r': 01490 c = '\r'; 01491 break; 01492 case 't': 01493 c = '\t'; 01494 break; 01495 } 01496 /* default, use the char literally */ 01497 } 01498 *dst = '\0'; 01499 return ret; 01500 }
void ast_unescape_quoted | ( | char * | quote_str | ) |
Unescape quotes in a string.
quote_str | The string with quotes to be unescaped |
Definition at line 461 of file utils.c.
Referenced by ast_callerid_parse().
00462 { 00463 int esc_pos; 00464 int unesc_pos; 00465 int quote_str_len = strlen(quote_str); 00466 00467 for (esc_pos = 0, unesc_pos = 0; 00468 esc_pos < quote_str_len; 00469 esc_pos++, unesc_pos++) { 00470 if (quote_str[esc_pos] == '\\') { 00471 /* at least one more char and current is \\ */ 00472 esc_pos++; 00473 if (esc_pos >= quote_str_len) { 00474 break; 00475 } 00476 } 00477 00478 quote_str[unesc_pos] = quote_str[esc_pos]; 00479 } 00480 quote_str[unesc_pos] = '\0'; 00481 }
char* ast_unescape_semicolon | ( | char * | s | ) |
Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).
Definition at line 1448 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 484 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().
00485 { 00486 char *o; 00487 unsigned int tmp; 00488 00489 for (o = s; *s; s++, o++) { 00490 if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) { 00491 /* have '%', two chars and correct parsing */ 00492 *o = tmp; 00493 s += 2; /* Will be incremented once more when we break out */ 00494 } else /* all other cases, just copy */ 00495 *o = *s; 00496 } 00497 *o = '\0'; 00498 }
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 398 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().
00399 { 00400 const char *ptr = string; /* Start with the string */ 00401 char *out = outbuf; 00402 const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */ 00403 00404 while (*ptr && out - outbuf < buflen - 1) { 00405 if ((const signed char) *ptr < 32 || *ptr == 0x7f || *ptr == '%' || 00406 (do_special_char && 00407 !(*ptr >= '0' && *ptr <= '9') && /* num */ 00408 !(*ptr >= 'A' && *ptr <= 'Z') && /* ALPHA */ 00409 !(*ptr >= 'a' && *ptr <= 'z') && /* alpha */ 00410 !strchr(mark, *ptr))) { /* mark set */ 00411 if (out - outbuf >= buflen - 3) { 00412 break; 00413 } 00414 00415 out += sprintf(out, "%%%02X", (unsigned) *ptr); 00416 } else { 00417 *out = *ptr; /* Continue copying the string */ 00418 out++; 00419 } 00420 ptr++; 00421 } 00422 00423 if (buflen) { 00424 *out = '\0'; 00425 } 00426 00427 return outbuf; 00428 }
int ast_utils_init | ( | void | ) |
Definition at line 2193 of file utils.c.
References ARRAY_LEN, ast_cli_register_multiple(), ast_register_atexit(), and base64_init().
Referenced by main().
02194 { 02195 #ifdef HAVE_DEV_URANDOM 02196 dev_urandom_fd = open("/dev/urandom", O_RDONLY); 02197 #endif 02198 base64_init(); 02199 #ifdef DEBUG_THREADS 02200 #if !defined(LOW_MEMORY) 02201 ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli)); 02202 ast_register_atexit(utils_shutdown); 02203 #endif 02204 #endif 02205 return 0; 02206 }
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 2364 of file utils.c.
References ast_strdupa.
Referenced by ast_bt_get_symbols().
02365 { 02366 const char *envPATH = getenv("PATH"); 02367 char *tpath, *path; 02368 struct stat unused; 02369 if (!envPATH) { 02370 return NULL; 02371 } 02372 tpath = ast_strdupa(envPATH); 02373 while ((path = strsep(&tpath, ":"))) { 02374 snprintf(fullpath, fullpath_size, "%s/%s", path, binary); 02375 if (!stat(fullpath, &unused)) { 02376 return fullpath; 02377 } 02378 } 02379 return NULL; 02380 }
int ast_wait_for_input | ( | int | fd, | |
int | ms | |||
) |
Definition at line 1255 of file utils.c.
References ast_poll.
Referenced by action_waitevent(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), moh_class_destructor(), sip_tcptls_read(), tcptls_stream_read(), and tcptls_stream_write().
01256 { 01257 struct pollfd pfd[1]; 01258 01259 memset(pfd, 0, sizeof(pfd)); 01260 pfd[0].fd = fd; 01261 pfd[0].events = POLLIN | POLLPRI; 01262 return ast_poll(pfd, 1, ms); 01263 }
int ast_wait_for_output | ( | int | fd, | |
int | ms | |||
) |
Definition at line 1265 of file utils.c.
References ast_poll.
Referenced by tcptls_stream_read(), and tcptls_stream_write().
01266 { 01267 struct pollfd pfd[1]; 01268 01269 memset(pfd, 0, sizeof(pfd)); 01270 pfd[0].fd = fd; 01271 pfd[0].events = POLLOUT; 01272 return ast_poll(pfd, 1, ms); 01273 }
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 500 of file utils.c.
References ast_assert, entity, and len().
Referenced by state_notify_build_xml().
00501 { 00502 char *dst = outbuf; 00503 char *end = outbuf + buflen - 1; /* save one for the null terminator */ 00504 00505 /* Handle the case for the empty output buffer */ 00506 if (buflen == 0) { 00507 return -1; 00508 } 00509 00510 /* Escaping rules from http://www.w3.org/TR/REC-xml/#syntax */ 00511 /* This also prevents partial entities at the end of a string */ 00512 while (*string && dst < end) { 00513 const char *entity = NULL; 00514 int len = 0; 00515 00516 switch (*string) { 00517 case '<': 00518 entity = "<"; 00519 len = 4; 00520 break; 00521 case '&': 00522 entity = "&"; 00523 len = 5; 00524 break; 00525 case '>': 00526 /* necessary if ]]> is in the string; easier to escape them all */ 00527 entity = ">"; 00528 len = 4; 00529 break; 00530 case '\'': 00531 /* necessary in single-quoted strings; easier to escape them all */ 00532 entity = "'"; 00533 len = 6; 00534 break; 00535 case '"': 00536 /* necessary in double-quoted strings; easier to escape them all */ 00537 entity = """; 00538 len = 6; 00539 break; 00540 default: 00541 *dst++ = *string++; 00542 break; 00543 } 00544 00545 if (entity) { 00546 ast_assert(len == strlen(entity)); 00547 if (end - dst < len) { 00548 /* no room for the entity; stop */ 00549 break; 00550 } 00551 /* just checked for length; strcpy is fine */ 00552 strcpy(dst, entity); 00553 dst += len; 00554 ++string; 00555 } 00556 } 00557 /* Write null terminator */ 00558 *dst = '\0'; 00559 /* If any chars are left in string, return failure */ 00560 return *string == '\0' ? 0 : -1; 00561 }
static void base64_init | ( | void | ) | [static] |
Definition at line 362 of file utils.c.
Referenced by ast_utils_init().
00363 { 00364 int x; 00365 memset(b2a, -1, sizeof(b2a)); 00366 /* Initialize base-64 Conversion table */ 00367 for (x = 0; x < 26; x++) { 00368 /* A-Z */ 00369 base64[x] = 'A' + x; 00370 b2a['A' + x] = x; 00371 /* a-z */ 00372 base64[x + 26] = 'a' + x; 00373 b2a['a' + x] = x + 26; 00374 /* 0-9 */ 00375 if (x < 10) { 00376 base64[x + 52] = '0' + x; 00377 b2a['0' + x] = x + 52; 00378 } 00379 } 00380 base64[62] = '+'; 00381 base64[63] = '/'; 00382 b2a[(int)'+'] = 62; 00383 b2a[(int)'/'] = 63; 00384 }
static void* dummy_start | ( | void * | data | ) | [static] |
Definition at line 1140 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().
01141 { 01142 void *ret; 01143 struct thr_arg a = *((struct thr_arg *) data); /* make a local copy */ 01144 #ifdef DEBUG_THREADS 01145 struct thr_lock_info *lock_info; 01146 pthread_mutexattr_t mutex_attr; 01147 01148 if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info)))) 01149 return NULL; 01150 01151 lock_info->thread_id = pthread_self(); 01152 lock_info->thread_name = strdup(a.name); 01153 01154 pthread_mutexattr_init(&mutex_attr); 01155 pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND); 01156 pthread_mutex_init(&lock_info->lock, &mutex_attr); 01157 pthread_mutexattr_destroy(&mutex_attr); 01158 01159 pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 01160 AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry); 01161 pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */ 01162 #endif /* DEBUG_THREADS */ 01163 01164 /* note that even though data->name is a pointer to allocated memory, 01165 we are not freeing it here because ast_register_thread is going to 01166 keep a copy of the pointer and then ast_unregister_thread will 01167 free the memory 01168 */ 01169 ast_free(data); 01170 ast_register_thread(a.name); 01171 pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self()); 01172 01173 ret = a.start_routine(a.data); 01174 01175 pthread_cleanup_pop(1); 01176 01177 return ret; 01178 }
static size_t optimal_alloc_size | ( | size_t | size | ) | [static] |
Definition at line 1729 of file utils.c.
References ALLOCATOR_OVERHEAD.
Referenced by __ast_calloc_with_stringfields(), and add_string_pool().
01730 { 01731 unsigned int count; 01732 01733 size += ALLOCATOR_OVERHEAD; 01734 01735 for (count = 1; size; size >>= 1, count++); 01736 01737 return (1 << count) - ALLOCATOR_OVERHEAD; 01738 }
static struct timeval tvfix | ( | struct timeval | a | ) | [static, read] |
Definition at line 1572 of file utils.c.
References ast_log(), LOG_WARNING, and ONE_MILLION.
Referenced by ast_tvadd(), and ast_tvsub().
01573 { 01574 if (a.tv_usec >= ONE_MILLION) { 01575 ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n", 01576 (long)a.tv_sec, (long int) a.tv_usec); 01577 a.tv_sec += a.tv_usec / ONE_MILLION; 01578 a.tv_usec %= ONE_MILLION; 01579 } else if (a.tv_usec < 0) { 01580 ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n", 01581 (long)a.tv_sec, (long int) a.tv_usec); 01582 a.tv_usec = 0; 01583 } 01584 return a; 01585 }
static int wait_for_output | ( | int | fd, | |
int | timeoutms | |||
) | [static] |
Definition at line 1275 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().
01276 { 01277 struct pollfd pfd = { 01278 .fd = fd, 01279 .events = POLLOUT, 01280 }; 01281 int res; 01282 struct timeval start = ast_tvnow(); 01283 int elapsed = 0; 01284 01285 /* poll() until the fd is writable without blocking */ 01286 while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) { 01287 if (res == 0) { 01288 /* timed out. */ 01289 #ifndef STANDALONE 01290 ast_debug(1, "Timed out trying to write\n"); 01291 #endif 01292 return -1; 01293 } else if (res == -1) { 01294 /* poll() returned an error, check to see if it was fatal */ 01295 01296 if (errno == EINTR || errno == EAGAIN) { 01297 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01298 if (elapsed >= timeoutms) { 01299 return -1; 01300 } 01301 /* This was an acceptable error, go back into poll() */ 01302 continue; 01303 } 01304 01305 /* Fatal error, bail. */ 01306 ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno)); 01307 01308 return -1; 01309 } 01310 elapsed = ast_tvdiff_ms(ast_tvnow(), start); 01311 if (elapsed >= timeoutms) { 01312 return -1; 01313 } 01314 } 01315 01316 return 0; 01317 }
struct { ... } __ast_string_field_empty_buffer [static] |
Definition at line 1721 of file utils.c.
Referenced by __ast_calloc_with_stringfields().
char base64[64] [static] |
Definition at line 78 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 2076 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 81 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 1637 of file utils.c.
Referenced by ast_random().
char string[1] |
Definition at line 1722 of file utils.c.
Referenced by private_enum_init().