main/utils.c File Reference

Utility functions. More...

#include "asterisk.h"
#include <ctype.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.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/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/time.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/config.h"
#include "asterisk/alertpipe.h"

Include dependency graph for main/utils.c:

Go to the source code of this file.

Data Structures
struct	lock_infos
	A list of each thread's lock info. More...
struct	thr_arg
struct	thr_lock_info
	Keep track of which locks a thread holds. More...

Macros
#define	AST_API_MODULE   /* ensure that inlinable API functions will be built in lock.h if required */
#define	AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */
#define	AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */
#define	AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */
#define	AST_API_MODULE
#define	AST_API_MODULE
#define	AST_API_MODULE
#define	AST_MAX_LOCKS   64
	A reasonable maximum number of locks a thread would be holding ... More...
#define	ONE_MILLION   1000000

Functions
void DO_CRASH_NORETURN	__ast_assert_failed (int condition, const char *condition_str, const char *file, int line, const char *function)
int	__ast_fd_set_flags (int fd, int flags, enum ast_fd_flag_operation op, const char *file, int lineno, const char *function)
static void	__init_inet_ntoa_buf (void)
static void	__init_thread_lock_info (void)
	The thread storage key for per-thread lock info. More...
static void	__init_thread_user_interface_tl (void)
	A thread local indicating whether the current thread is a user interface. More...
static void	append_backtrace_information (struct ast_str **str, struct ast_bt *bt)
static void	append_lock_information (struct ast_str **str, struct thr_lock_info *lock_info, int i)
int	ast_background_stacksize (void)
int	ast_base64decode (unsigned char *dst, const char *src, int max)
	decode BASE64 encoded text More...
char *	ast_base64decode_string (const char *src)
	Decode BASE64 encoded text and return the string. More...
int	ast_base64encode (char *dst, const unsigned char *src, int srclen, int max)
	Encode data in base64. More...
int	ast_base64encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
	encode text to BASE64 coding More...
char *	ast_base64encode_string (const char *src)
	Encode to BASE64 and return encoded string. More...
int	ast_base64url_decode (unsigned char *dst, const char *src, int max)
	Decode data from base64 URL. More...
char *	ast_base64url_decode_string (const char *src)
	Decode string from base64 URL. More...
int	ast_base64url_encode (char *dst, const unsigned char *src, int srclen, int max)
	Encode data in base64 URL. More...
int	ast_base64url_encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
	Same as ast_base64encode_full but for base64 URL. More...
char *	ast_base64url_encode_string (const char *src)
	Encode string in base64 URL. More...
int	ast_build_string (char **buffer, size_t *space, const char *fmt,...)
	Build a string in a buffer, designed to be called repeatedly. More...
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. More...
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. More...
int	ast_check_ipv6 (void)
	Test that an OS supports IPv6 Networking. More...
int	ast_compare_versions (const char *version1, const char *version2)
	Compare 2 major.minor.patch.extra version strings. More...
void DO_CRASH_NORETURN	ast_do_crash (void)
	Force a crash if DO_CRASH is defined. More...
struct ast_str *	ast_dump_locks (void)
	Generate a lock dump equivalent to "core show locks". More...
int	ast_eid_cmp (const struct ast_eid *eid1, const struct ast_eid *eid2)
	Compare two EIDs. More...
int	ast_eid_is_empty (const struct ast_eid *eid)
	Check if EID is empty. More...
char *	ast_eid_to_str (char *s, int maxlen, struct ast_eid *eid)
	Convert an EID to a string. More...
void	ast_enable_packet_fragmentation (int sock)
	Disable PMTU discovery on a socket. More...
char *	ast_escape (char *dest, const char *s, size_t size, const char *to_escape)
	Escape the 'to_escape' characters in the given string. More...
char *	ast_escape_alloc (const char *s, const char *to_escape)
	Escape the 'to_escape' characters in the given string. More...
char *	ast_escape_c (char *dest, const char *s, size_t size)
	Escape standard 'C' sequences in the given string. More...
char *	ast_escape_c_alloc (const char *s)
	Escape standard 'C' sequences in the given string. More...
char *	ast_escape_quoted (const char *string, char *outbuf, int buflen)
	Escape characters found in a quoted string. More...
char *	ast_escape_semicolons (const char *string, char *outbuf, int buflen)
	Escape semicolons found in a string. More...
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". More...
int	ast_file_is_readable (const char *filename)
	Test that a file exists and is readable by the effective user. More...
int	ast_find_lock_info (void *lock_addr, char *filename, size_t filename_size, int *lineno, char *func, size_t func_size, char *mutex_name, size_t mutex_name_size)
	retrieve lock info for the specified mutex More...
void	ast_format_duration_hh_mm_ss (int duration, char *buf, size_t length)
	Formats a duration into HH:MM:SS. More...
int	ast_get_tid (void)
	Get current thread ID. More...
int	ast_get_time_t (const char *src, time_t *dst, time_t _default, int *consumed)
	get values from config variables. More...
int	ast_get_timeval (const char *src, struct timeval *dst, struct timeval _default, int *consumed)
	get values from config variables. More...
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) More...
const char *	ast_inet_ntoa (struct in_addr ia)
	ast_inet_ntoa: Recursive thread safe replacement of inet_ntoa More...
void	ast_join_delim (char *s, size_t len, const char *const w[], unsigned int size, char delim)
void	ast_log_show_lock (void *this_lock_addr)
	log info for the current lock with ast_log(). More...
void	ast_mark_lock_acquired (void *lock_addr)
	Mark the last lock as acquired. More...
void	ast_mark_lock_failed (void *lock_addr)
	Mark the last lock as failed (trylock) More...
void	ast_md5_hash (char *output, const char *input)
	Produce 32 char MD5 hash of value. More...
int	ast_mkdir (const char *path, int mode)
	Recursively create directory path. More...
int	ast_parse_digest (const char *digest, struct ast_http_digest *d, int request, int pedantic)
	Parse digest authorization header. More...
char *	ast_process_quotes_and_slashes (char *start, char find, char replace_with)
	Process a string to find and replace characters. More...
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_regex_string_to_regex_pattern (const char *regex_string, struct ast_str **regex_pattern)
	Given a string regex_string in the form of "/regex/", convert it into the form of "regex". More...
int	ast_remaining_ms (struct timeval start, int max_ms)
	Calculate remaining milliseconds given a starting timestamp and upper bound. More...
void	ast_remove_lock_info (void *lock_addr, struct ast_bt *bt)
	remove lock info for the current thread More...
void	ast_replace_subargument_delimiter (char *s)
	Replace '^' in a string with ','. More...
void	ast_restore_lock_info (void *lock_addr)
int	ast_safe_mkdir (const char *base_path, const char *path, int mode)
	Recursively create directory path, but only if it resolves within the given base_path. More...
void	ast_set_default_eid (struct ast_eid *eid)
	Fill in an ast_eid with the default eid of this machine. More...
void	ast_sha1_hash (char *output, const char *input)
	Produce 40 char SHA1 hash of value. More...
void	ast_sha1_hash_uint (uint8_t *digest, const char *input)
	Produce a 20 byte SHA1 hash of value. More...
void	ast_store_lock_info (enum ast_lock_type type, const char *filename, int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
	Store lock info for the current thread. More...
int	ast_str_to_eid (struct ast_eid *eid, const char *s)
	Convert a string into an EID. More...
char *	ast_strip_quoted (char *s, const char *beg_quotes, const char *end_quotes)
	Strip leading/trailing whitespace and quotes from a string. More...
char *	ast_strsep (char **iss, const char sep, uint32_t flags)
	Act like strsep but ignore separators inside quotes. More...
void	ast_suspend_lock_info (void *lock_addr)
int	ast_thread_is_user_interface (void)
	Indicates whether the current thread is a user interface. More...
int	ast_thread_user_interface_set (int is_user_interface)
	Set the current thread's user interface status. More...
char *	ast_to_camel_case_delim (const char *s, const char *delim)
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". More...
struct timeval	ast_tvadd (struct timeval a, struct timeval b)
	Returns the sum of two timevals a + b. More...
struct timeval	ast_tvsub (struct timeval a, struct timeval b)
	Returns the difference of two timevals a - b. More...
char *	ast_unescape_c (char *src)
	Convert some C escape sequences. More...
void	ast_unescape_quoted (char *quote_str)
	Unescape quotes in a string. More...
char *	ast_unescape_semicolon (char *s)
	Strip backslash for "escaped" semicolons, the string to be stripped (will be modified). More...
void	ast_uri_decode (char *s, struct ast_flags spec)
	Decode URI, URN, URL (overwrite string) More...
char *	ast_uri_encode (const char *string, char *outbuf, int buflen, struct ast_flags spec)
	Turn text string to URI-encoded XX version. More...
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. More...
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. More...
static void	base64_init (void)
static void *	dummy_start (void *data)
static char *	escape_alloc (const char *s, size_t *size)
static char *	handle_show_locks (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	lock_info_destroy (void *data)
	Destroy a thread's lock info. More...
static const char *	locktype2str (enum ast_lock_type type)
static int	safe_mkdir (const char *base_path, char *path, int mode)
static struct timeval	tvfix (struct timeval a)
static void	utils_shutdown (void)
static int	wait_for_output (int fd, int timeoutms)

Variables
const struct ast_flags	ast_uri_http = {AST_URI_UNRESERVED}
const struct ast_flags	ast_uri_http_legacy = {AST_URI_LEGACY_SPACE | AST_URI_UNRESERVED}
const struct ast_flags	ast_uri_sip_user = {AST_URI_UNRESERVED | AST_URI_SIP_USER_UNRESERVED}
static char	b2a [256]
static char	b2a_url [256]
static char	base64 [64]
static char	base64url [64]
static int	dev_urandom_fd = -1
char	escape_sequences []
static char	escape_sequences_map []
static struct ast_threadstorage	inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , }
static struct lock_infos	lock_infos = { .first = NULL, .last = NULL, }
static ast_mutex_t	lock_infos_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Locked when accessing the lock_infos list. More...
static ast_mutex_t	randomlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static struct ast_threadstorage	thread_lock_info = { .once = PTHREAD_ONCE_INIT , .key_init = __init_thread_lock_info , .custom_init = NULL , }
static struct ast_threadstorage	thread_user_interface_tl = { .once = PTHREAD_ONCE_INIT , .key_init = __init_thread_user_interface_tl , .custom_init = NULL , }
static struct ast_cli_entry	utils_cli []

Detailed Description

Utility functions.

Note

These are important for portability and security, so please use them in favour of other routines. Please consult the CODING GUIDELINES for more information.

Definition in file main/utils.c.

Macro Definition Documentation

AST_API_MODULE [1/7]

#define AST_API_MODULE   /* ensure that inlinable API functions will be built in lock.h if required */

Definition at line 70 of file main/utils.c.

AST_API_MODULE [2/7]

#define AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */

Definition at line 70 of file main/utils.c.

AST_API_MODULE [3/7]

#define AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */

Definition at line 70 of file main/utils.c.

AST_API_MODULE [4/7]

#define AST_API_MODULE   /* ensure that inlinable API functions will be built in this module if required */

Definition at line 70 of file main/utils.c.

AST_API_MODULE [5/7]

#define AST_API_MODULE

Definition at line 70 of file main/utils.c.

AST_API_MODULE [6/7]

#define AST_API_MODULE

Definition at line 70 of file main/utils.c.

AST_API_MODULE [7/7]

#define AST_API_MODULE

Definition at line 70 of file main/utils.c.

AST_MAX_LOCKS

#define AST_MAX_LOCKS   64

A reasonable maximum number of locks a thread would be holding ...

Definition at line 802 of file main/utils.c.

Referenced by ast_store_lock_info().

ONE_MILLION

#define ONE_MILLION   1000000

Definition at line 1985 of file main/utils.c.

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

Function Documentation

__ast_assert_failed()

void DO_CRASH_NORETURN __ast_assert_failed	(	int	condition,
		const char *	condition_str,
		const char *	file,
		int	line,
		const char *	function
	)

Definition at line 2564 of file main/utils.c.

References __LOG_ERROR, ast_do_crash(), ast_log, and ast_log_backtrace().

Referenced by __ao2_container_clone(), __ao2_iterator_next(), __ao2_link(), __ao2_ref(), _ast_assert(), internal_ao2_traverse(), and log_bad_ao2().

{
   /*
    * Attempt to put it into the logger, but hope that at least
    * someone saw the message on stderr ...
    */
   fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
      condition_str, condition, line, function, file);
   ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
      condition_str, condition);

   /* Generate a backtrace for the assert */
   ast_log_backtrace();

   /*
    * Give the logger a chance to get the message out, just in case
    * we abort(), or Asterisk crashes due to whatever problem just
    * happened after we exit ast_assert().
    */
   usleep(1);
   ast_do_crash();
}

__ast_fd_set_flags()

int __ast_fd_set_flags	(	int	fd,
		int	flags,
		enum ast_fd_flag_operation	op,
		const char *	file,
		int	lineno,
		const char *	function
	)

Definition at line 2898 of file main/utils.c.

References __LOG_ERROR, ast_assert, AST_FD_FLAG_CLEAR, AST_FD_FLAG_SET, ast_fd_set_flags, ast_log, ast_pipe_nonblock, ast_socket_nonblock, errno, and thr_lock_info::type.

{
   int f;

   f = fcntl(fd, F_GETFL);
   if (f == -1) {
      ast_log(__LOG_ERROR, file, lineno, function,
         "Failed to get fcntl() flags for file descriptor: %s\n", strerror(errno));
      return -1;
   }

   switch (op) {
   case AST_FD_FLAG_SET:
      if ((f & flags) == flags) {
         /* There is nothing to set */
         return 0;
      }
      f |= flags;
      break;
   case AST_FD_FLAG_CLEAR:
      if (!(f & flags)) {
         /* There is nothing to clear */
         return 0;
      }
      f &= ~flags;
      break;
   default:
      ast_assert(0);
      break;
   }

   f = fcntl(fd, F_SETFL, f);
   if (f == -1) {
      ast_log(__LOG_ERROR, file, lineno, function,
         "Failed to set fcntl() flags for file descriptor: %s\n", strerror(errno));
      return -1;
   }

   return 0;
}

__init_inet_ntoa_buf()

static void __init_inet_ntoa_buf ( void  )

static

Definition at line 83 of file main/utils.c.

{

__init_thread_lock_info()

static void __init_thread_lock_info ( void  )

static

The thread storage key for per-thread lock info.

Definition at line 902 of file main/utils.c.

{

__init_thread_user_interface_tl()

static void __init_thread_user_interface_tl ( void  )

static

A thread local indicating whether the current thread is a user interface.

Definition at line 2979 of file main/utils.c.

{

append_backtrace_information()

static void append_backtrace_information ( struct ast_str **  str, struct ast_bt *  bt  )

static

Definition at line 1147 of file main/utils.c.

References ast_bt::addresses, ast_bt_free_symbols, ast_bt_get_symbols, ast_str_append(), AST_VECTOR_GET, AST_VECTOR_SIZE, and ast_bt::num_frames.

Referenced by append_lock_information().

{
   struct ast_vector_string *symbols;
   int num_frames;

   if (!bt) {
      ast_str_append(str, 0, "\tNo backtrace to print\n");
      return;
   }

   /* store frame count locally to avoid the memory corruption that
    * sometimes happens on virtualized CentOS 6.x systems */
   num_frames = bt->num_frames;
   if ((symbols = ast_bt_get_symbols(bt->addresses, num_frames))) {
      int frame_iterator;

      for (frame_iterator = 1; frame_iterator < AST_VECTOR_SIZE(symbols); ++frame_iterator) {
         ast_str_append(str, 0, "\t%s\n", AST_VECTOR_GET(symbols, frame_iterator));
      }

      ast_bt_free_symbols(symbols);
   } else {
      ast_str_append(str, 0, "\tCouldn't retrieve backtrace symbols\n");
   }
}

append_lock_information()

static void append_lock_information ( struct ast_str **  str, struct thr_lock_info *  lock_info, int  i  )

static

Definition at line 1174 of file main/utils.c.

References append_backtrace_information(), AST_MUTEX, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_str_append(), thr_lock_info::backtrace, ast_lock_track::file, thr_lock_info::file, ast_lock_track::func, thr_lock_info::func, thr_lock_info::line_num, ast_lock_track::lineno, thr_lock_info::lock, thr_lock_info::lock_addr, thr_lock_info::lock_name, thr_lock_info::locks, locktype2str(), thr_lock_info::pending, ast_lock_track::reentrancy, thr_lock_info::suspended, thr_lock_info::times_locked, ast_mutex_info::track, and thr_lock_info::type.

Referenced by ast_dump_locks(), and ast_log_show_lock().

{
   int j;
   ast_mutex_t *lock;
   struct ast_lock_track *lt;

   ast_str_append(str, 0, "=== ---> %sLock #%d (%s): %s %d %s %s %p (%d%s)\n",
               lock_info->locks[i].pending > 0 ? "Waiting for " :
               lock_info->locks[i].pending < 0 ? "Tried and failed to get " : "", i,
               lock_info->locks[i].file,
               locktype2str(lock_info->locks[i].type),
               lock_info->locks[i].line_num,
               lock_info->locks[i].func, lock_info->locks[i].lock_name,
               lock_info->locks[i].lock_addr,
               lock_info->locks[i].times_locked,
               lock_info->locks[i].suspended ? " - suspended" : "");
#ifdef HAVE_BKTR
   append_backtrace_information(str, lock_info->locks[i].backtrace);
#endif

   if (!lock_info->locks[i].pending || lock_info->locks[i].pending == -1)
      return;

   /* We only have further details for mutexes right now */
   if (lock_info->locks[i].type != AST_MUTEX)
      return;

   lock = lock_info->locks[i].lock_addr;
   lt = lock->track;
   ast_reentrancy_lock(lt);
   for (j = 0; *str && j < lt->reentrancy; j++) {
      ast_str_append(str, 0, "=== --- ---> Locked Here: %s line %d (%s)\n",
                  lt->file[j], lt->lineno[j], lt->func[j]);
   }
   ast_reentrancy_unlock(lt);
}

ast_background_stacksize()

int ast_background_stacksize

(

void

)

Definition at line 1437 of file main/utils.c.

References AST_STACKSIZE, and AST_STACKSIZE_LOW.

{
#if !defined(LOW_MEMORY)
   return AST_STACKSIZE;
#else
   return AST_STACKSIZE_LOW;
#endif
}

ast_base64decode()

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

decode BASE64 encoded text

Decode data from base64.

Definition at line 294 of file main/utils.c.

References b2a.

Referenced by action_messagesend(), aes_helper(), ast_base64decode_string(), ast_check_signature(), ast_http_get_auth(), AST_TEST_DEFINE(), base64_helper(), crypto_init_keys(), custom_presence_callback(), osp_validate_token(), presence_write(), and res_sdp_crypto_parse_offer().

{
   int cnt = 0;
   unsigned int byte = 0;
   unsigned int bits = 0;
   int incnt = 0;
   while(*src && *src != '=' && (cnt < max)) {
      /* Shift in 6 bits of input */
      byte <<= 6;
      byte |= (b2a[(int)(*src)]) & 0x3f;
      bits += 6;
      src++;
      incnt++;
      /* If we have at least 8 bits left over, take that character
         off the top */
      if (bits >= 8)  {
         bits -= 8;
         *dst = (byte >> bits) & 0xff;
         dst++;
         cnt++;
      }
   }
   /* Don't worry about left over bits, they're extra anyway */
   return cnt;
}

ast_base64decode_string()

char* ast_base64decode_string

(

const char *

src

)

Decode BASE64 encoded text and return the string.

Same as ast_base64decode, but does the math for you and returns a decoded string.

Definition at line 321 of file main/utils.c.

References ast_base64decode(), ast_malloc, ast_strlen_zero, and NULL.

{
   size_t encoded_len;
   size_t decoded_len;
   int padding = 0;
   unsigned char *decoded_string;

   if (ast_strlen_zero(src)) {
      return NULL;
   }

   encoded_len = strlen(src);
   if (encoded_len > 2 && src[encoded_len - 1] == '=') {
      padding++;
      if (src[encoded_len - 2] == '=') {
         padding++;
      }
   }

   decoded_len = (encoded_len / 4 * 3) - padding;
   decoded_string = ast_malloc(decoded_len + 1);
   if (!decoded_string) {
      return NULL;
   }

   ast_base64decode(decoded_string, src, decoded_len);
   decoded_string[decoded_len] = '\0';

   return (char *)decoded_string;
}

ast_base64encode()

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

Encode data in base64.

Parameters

dst	the destination buffer
src	the source data to be encoded
srclen	the number of bytes present in the source buffer
max	the maximum number of bytes to write into the destination buffer, including the terminating NULL character.

Definition at line 404 of file main/utils.c.

References ast_base64encode_full().

Referenced by aes_helper(), ast_base64encode_string(), ast_sign(), AST_TEST_DEFINE(), base64_helper(), build_secret(), crypto_init_keys(), osp_check_destination(), presence_read(), websocket_client_create_key(), websocket_combine_key(), and xmpp_client_authenticate_sasl().

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

ast_base64encode_full()

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

encode text to BASE64 coding

Definition at line 353 of file main/utils.c.

References base64, and max.

Referenced by ast_base64encode().

{
   int cnt = 0;
   int col = 0;
   unsigned int byte = 0;
   int bits = 0;
   int cntin = 0;
   /* Reserve space for null byte at end of string */
   max--;
   while ((cntin < srclen) && (cnt < max)) {
      byte <<= 8;
      byte |= *(src++);
      bits += 8;
      cntin++;
      if ((bits == 24) && (cnt + 4 <= max)) {
         *dst++ = base64[(byte >> 18) & 0x3f];
         *dst++ = base64[(byte >> 12) & 0x3f];
         *dst++ = base64[(byte >> 6) & 0x3f];
         *dst++ = base64[byte & 0x3f];
         cnt += 4;
         col += 4;
         bits = 0;
         byte = 0;
      }
      if (linebreaks && (cnt < max) && (col == 64)) {
         *dst++ = '\n';
         cnt++;
         col = 0;
      }
   }
   if (bits && (cnt + 4 <= max)) {
      /* Add one last character for the remaining bits,
         padding the rest with 0 */
      byte <<= 24 - bits;
      *dst++ = base64[(byte >> 18) & 0x3f];
      *dst++ = base64[(byte >> 12) & 0x3f];
      if (bits == 16)
         *dst++ = base64[(byte >> 6) & 0x3f];
      else
         *dst++ = '=';
      *dst++ = '=';
      cnt += 4;
   }
   if (linebreaks && (cnt < max)) {
      *dst++ = '\n';
      cnt++;
   }
   *dst = '\0';
   return cnt;
}

ast_base64encode_string()

char* ast_base64encode_string

(

const char *

src

)

Encode to BASE64 and return encoded string.

Same as ast_base64encode, but does hte math for you and returns an encoded string.

Definition at line 410 of file main/utils.c.

References ast_base64encode(), ast_calloc, ast_strlen_zero, and NULL.

{
   size_t encoded_len;
   char *encoded_string;

   if (ast_strlen_zero(src)) {
      return NULL;
   }

   encoded_len = ((strlen(src) * 4 / 3 + 3) & ~3) + 1;
   encoded_string = ast_calloc(1, encoded_len);

   ast_base64encode(encoded_string, (const unsigned char *)src, strlen(src), encoded_len);

   return encoded_string;
}

ast_base64url_decode()

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

Decode data from base64 URL.

Parameters

dst	The destination buffer
src	The source buffer
max	The maximum number of bytes to write into the destination buffer. Note that this function will not ensure that the destination buffer is NULL terminated. So, in general, this parameter should be sizeof(dst) - 1

Definition at line 427 of file main/utils.c.

References b2a_url.

Referenced by ast_base64url_decode_string(), and stir_shaken_verify_signature().

{
   int cnt = 0;
   unsigned int byte = 0;
   unsigned int bits = 0;

   while (*src && (cnt < max)) {
      byte <<= 6;
      byte |= (b2a_url[(int)(*src)]) & 0x3f;
      bits += 6;
      src++;
      if (bits >= 8) {
         bits -= 8;
         *dst = (byte >> bits) & 0xff;
         dst++;
         cnt++;
      }
   }
   return cnt;
}

ast_base64url_decode_string()

char* ast_base64url_decode_string

(

const char *

src

)

Decode string from base64 URL.

Note

The returned string will need to be freed later

Parameters

src	The source buffer

Return values

NULL	on failure
Decoded	string on success

Definition at line 448 of file main/utils.c.

References ast_base64url_decode(), ast_malloc, ast_strlen_zero, and NULL.

Referenced by stir_shaken_incoming_request().

{
   size_t decoded_len;
   unsigned char *decoded_string;

   if (ast_strlen_zero(src)) {
      return NULL;
   }

   decoded_len = strlen(src) * 3 / 4;
   decoded_string = ast_malloc(decoded_len + 1);
   if (!decoded_string) {
      return NULL;
   }

   ast_base64url_decode(decoded_string, src, decoded_len);
   decoded_string[decoded_len] = '\0';

   return (char *)decoded_string;
}

ast_base64url_encode()

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

Encode data in base64 URL.

Parameters

dst	The destination buffer
src	The source data to be encoded
srclen	The number of bytes present in the source buffer
max	The maximum number of bytes to write into the destination buffer, including the terminating NULL character

Definition at line 516 of file main/utils.c.

References ast_base64url_encode_full().

Referenced by ast_base64url_encode_string(), and stir_shaken_sign().

{
   return ast_base64url_encode_full(dst, src, srclen, max, 0);
}

ast_base64url_encode_full()

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

Same as ast_base64encode_full but for base64 URL.

Parameters

dst	The destination buffer
src	The source buffer
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.
linebreaks	Set to 1 if there should be linebreaks inserted in the result

Definition at line 469 of file main/utils.c.

References base64url, and max.

Referenced by ast_base64url_encode().

{
   int cnt = 0;
   int col = 0;
   unsigned int byte = 0;
   int bits = 0;
   int cntin = 0;

   max--;
   while ((cntin < srclen) && (cnt < max)) {
      byte <<= 8;
      byte |= *(src++);
      bits += 8;
      cntin++;
      if ((bits == 24) && (cnt + 4 <= max)) {
         *dst++ = base64url[(byte >> 18) & 0x3f];
         *dst++ = base64url[(byte >> 12) & 0x3f];
         *dst++ = base64url[(byte >> 6) & 0x3f];
         *dst++ = base64url[(byte) & 0x3f];
         cnt += 4;
         col += 4;
         bits = 0;
         byte = 0;
      }
      if (linebreaks && (cnt < max) && (col == 64)) {
         *dst++ = '\n';
         cnt++;
         col = 0;
      }
   }
   if (bits && (cnt + 4 <= max)) {
      byte <<= 24 - bits;
      *dst++ = base64url[(byte >> 18) & 0x3f];
      *dst++ = base64url[(byte >> 12) & 0x3f];
      if (bits == 16) {
         *dst++ = base64url[(byte >> 6) & 0x3f];
      }
      cnt += 4;
   }
   if (linebreaks && (cnt < max)) {
      *dst++ = '\n';
      cnt++;
   }
   *dst = '\0';
   return cnt;
}

ast_base64url_encode_string()

char* ast_base64url_encode_string

(

const char *

src

)

Encode string in base64 URL.

Note

The returned string will need to be freed later

Parameters

src	The source data to be encoded

Return values

NULL	on failure
Encoded	string on success

Definition at line 521 of file main/utils.c.

References ast_base64url_encode(), ast_malloc, ast_strlen_zero, and NULL.

Referenced by add_identity_header().

{
   size_t encoded_len;
   char *encoded_string;

   if (ast_strlen_zero(src)) {
      return NULL;
   }

   encoded_len = ((strlen(src) * 4 / 3 + 3) & ~3) + 1;
   encoded_string = ast_malloc(encoded_len);

   ast_base64url_encode(encoded_string, (const unsigned char *)src, strlen(src), encoded_len);

   return encoded_string;
}

ast_build_string()

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

Build a string in a buffer, designed to be called repeatedly.

Note

This method is not recommended. New code should use ast_str_*() instead.

This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.

Parameters

buffer	current position in buffer to place string into (will be updated on return)
space	remaining space in buffer (will be updated on return)
fmt	printf-style format string

Return values

0	on success
non-zero	on failure.

Definition at line 1919 of file main/utils.c.

References ast_build_string_va(), and result.

Referenced by ast_fax_caps_to_str(), generate_filenames_string(), handle_speechrecognize(), pp_each_extension_helper(), and vm_allocate_dh().

{
   va_list ap;
   int result;

   va_start(ap, fmt);
   result = ast_build_string_va(buffer, space, fmt, ap);
   va_end(ap);

   return result;
}

ast_build_string_va()

int ast_build_string_va	(	char **	buffer,
		size_t *	space,
		const char *	fmt,
		va_list	ap
	)

Build a string in a buffer, designed to be called repeatedly.

This is a wrapper for snprintf, that properly handles the buffer pointer and buffer space available.

Returns

0 on success, non-zero on failure.

Parameters

buffer	current position in buffer to place string into (will be updated on return)
space	remaining space in buffer (will be updated on return)
fmt	printf-style format string
ap	varargs list of arguments for format

Definition at line 1900 of file main/utils.c.

References result.

Referenced by ast_build_string().

{
   int result;

   if (!buffer || !*buffer || !space || !*space)
      return -1;

   result = vsnprintf(*buffer, *space, fmt, ap);

   if (result < 0)
      return -1;
   else if (result > *space)
      result = *space;

   *buffer += result;
   *space -= result;
   return 0;
}

ast_carefulwrite()

int ast_carefulwrite	(	int	fd,
		char *	s,
		int	len,
		int	timeoutms
	)

Try to write string, but wait no more than ms milliseconds before timing out.

Try to write string, but wait no more than ms milliseconds before timing out.

Note

The code assumes that the file descriptor has NONBLOCK set, so there is only one system call made to do a write, unless we actually have a need to wait. This way, we get better performance. If the descriptor is blocking, all assumptions on the guaranteed detail do not apply anymore.

Definition at line 1592 of file main/utils.c.

References ast_debug, ast_log, ast_tvdiff_ms(), ast_tvnow(), errno, LOG_ERROR, and wait_for_output().

Referenced by ast_agi_send(), AST_VECTOR(), and cleanup_module().

{
   struct timeval start = ast_tvnow();
   int res = 0;
   int elapsed = 0;

   while (len) {
      if (wait_for_output(fd, timeoutms - elapsed)) {
         return -1;
      }

      res = write(fd, s, len);

      if (res < 0 && errno != EAGAIN && errno != EINTR) {
         /* fatal error from write() */
         if (errno == EPIPE) {
#ifndef STANDALONE
            ast_debug(1, "write() failed due to reading end being closed: %s\n", strerror(errno));
#endif
         } else {
            ast_log(LOG_ERROR, "write() returned error: %s\n", strerror(errno));
         }
         return -1;
      }

      if (res < 0) {
         /* It was an acceptable error */
         res = 0;
      }

      /* Update how much data we have left to write */
      len -= res;
      s += res;
      res = 0;

      elapsed = ast_tvdiff_ms(ast_tvnow(), start);
      if (elapsed >= timeoutms) {
         /* We've taken too long to write
          * This is only an error condition if we haven't finished writing. */
         res = len ? -1 : 0;
         break;
      }
   }

   return res;
}

ast_check_ipv6()

int ast_check_ipv6

(

void

)

Test that an OS supports IPv6 Networking.

Since

13.14.0

Returns

True (non-zero) if the IPv6 supported.

False (zero) if the OS doesn't support IPv6.

Definition at line 2540 of file main/utils.c.

Referenced by load_module().

{
   int udp6_socket = socket(AF_INET6, SOCK_DGRAM, 0);

   if (udp6_socket < 0) {
      return 0;
   }

   close(udp6_socket);
   return 1;
}

ast_compare_versions()

int ast_compare_versions	(	const char *	version1,
		const char *	version2
	)

Compare 2 major.minor.patch.extra version strings.

Since

13.7.0

Parameters

version1.
version2.

Returns

<0 if version 1 < version 2.

=0 if version 1 = version 2.

>0 if version 1 > version 2.

Definition at line 2872 of file main/utils.c.

Referenced by transport_apply().

{
   unsigned int major[2] = { 0 };
   unsigned int minor[2] = { 0 };
   unsigned int patch[2] = { 0 };
   unsigned int extra[2] = { 0 };
   int res;

   sscanf(version1, "%u.%u.%u.%u", &major[0], &minor[0], &patch[0], &extra[0]);
   sscanf(version2, "%u.%u.%u.%u", &major[1], &minor[1], &patch[1], &extra[1]);

   res = major[0] - major[1];
   if (res) {
      return res;
   }
   res = minor[0] - minor[1];
   if (res) {
      return res;
   }
   res = patch[0] - patch[1];
   if (res) {
      return res;
   }
   return extra[0] - extra[1];
}

ast_do_crash()

void DO_CRASH_NORETURN ast_do_crash

(

void

)

Force a crash if DO_CRASH is defined.

Note

If DO_CRASH is not defined then the function returns.

Returns

Nothing

Definition at line 2552 of file main/utils.c.

Referenced by __ast_assert_failed(), _ast_assert(), ast_optional_api_use(), optional_api_create(), optional_api_user_create(), and sip_route_process_header().

{
#if defined(DO_CRASH)
   abort();
   /*
    * Just in case abort() doesn't work or something else super
    * silly, and for Qwell's amusement.
    */
   *((int *) 0) = 0;
#endif   /* defined(DO_CRASH) */
}

ast_dump_locks()

struct ast_str* ast_dump_locks

(

void

)

Generate a lock dump equivalent to "core show locks".

The lock dump generated is generally too large to be output by a single ast_verbose/log/debug/etc. call. Only ast_cli() handles it properly without changing BUFSIZ in logger.c.

Note: This must be ast_free()d when you're done with it.

Return values

An	ast_str containing the lock dump
NULL	on error

Since

12

Definition at line 1264 of file main/utils.c.

References append_lock_information(), ast_get_version(), AST_LIST_TRAVERSE, ast_str_append(), ast_str_create, thr_lock_info::lock, lock_info, lock_infos_lock, thr_lock_info::locks, thr_lock_info::lwp, ast_mutex_info::mutex, NULL, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, str, thr_lock_info::suspended, thr_lock_info::thread_id, and thr_lock_info::thread_name.

Referenced by handle_show_locks().

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   struct ast_str *str;

   if (!(str = ast_str_create(4096))) {
      return NULL;
   }

   ast_str_append(&str, 0, "\n"
                  "=======================================================================\n"
                  "=== %s\n"
                  "=== Currently Held Locks\n"
                  "=======================================================================\n"
                  "===\n"
                  "=== <pending> <lock#> (<file>): <lock type> <line num> <function> <lock name> <lock addr> (times locked)\n"
                  "===\n", ast_get_version());

   if (!str) {
      return NULL;
   }

   pthread_mutex_lock(&lock_infos_lock.mutex);
   AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
      int i;
      int header_printed = 0;
      pthread_mutex_lock(&lock_info->lock);
      for (i = 0; str && i < lock_info->num_locks; i++) {
         /* Don't show suspended locks */
         if (lock_info->locks[i].suspended) {
            continue;
         }

         if (!header_printed) {
            if (lock_info->lwp != -1) {
               ast_str_append(&str, 0, "=== Thread ID: 0x%lx LWP:%d (%s)\n",
                  (long unsigned) lock_info->thread_id, lock_info->lwp, lock_info->thread_name);
            } else {
               ast_str_append(&str, 0, "=== Thread ID: 0x%lx (%s)\n",
                  (long unsigned) lock_info->thread_id, lock_info->thread_name);
            }
            header_printed = 1;
         }

         append_lock_information(&str, lock_info, i);
      }
      pthread_mutex_unlock(&lock_info->lock);
      if (!str) {
         break;
      }
      if (header_printed) {
         ast_str_append(&str, 0, "=== -------------------------------------------------------------------\n"
            "===\n");
      }
      if (!str) {
         break;
      }
   }
   pthread_mutex_unlock(&lock_infos_lock.mutex);

   if (!str) {
      return NULL;
   }

   ast_str_append(&str, 0, "=======================================================================\n"
                  "\n");

   return str;
#else /* if defined(LOW_MEMORY) */
   return NULL;
#endif
}

ast_eid_cmp()

int ast_eid_cmp	(	const struct ast_eid *	eid1,
		const struct ast_eid *	eid2
	)

Compare two EIDs.

Returns

0 if the two are the same, non-zero otherwise

Since

1.6.1

Definition at line 2842 of file main/utils.c.

Referenced by AST_TEST_DEFINE(), asterisk_publisher_devstate_cb(), asterisk_publisher_mwistate_cb(), build_peer(), build_transactions(), cache_entry_by_eid(), cache_entry_create(), cache_remove(), cache_udpate(), clear_node_cache(), cpg_deliver_cb(), destroy_trans(), dundi_answer_entity(), dundi_answer_query(), dundi_ie_append_eid_appropriately(), dundi_lookup_internal(), dundi_prop_precache(), dundi_query_thread(), find_peer(), handle_command_response(), optimize_transactions(), publish_cluster_discovery_to_stasis(), publish_to_corosync(), register_request(), state_find_and_remove_eid(), state_find_or_add_eid(), xmpp_pubsub_devstate_cb(), xmpp_pubsub_handle_event(), and xmpp_pubsub_mwi_cb().

{
   return memcmp(eid1, eid2, sizeof(*eid1));
}

ast_eid_is_empty()

int ast_eid_is_empty

(

const struct ast_eid *

eid

)

Check if EID is empty.

Returns

1 if the EID is empty, zero otherwise

Since

13.12.0

Definition at line 2847 of file main/utils.c.

Referenced by load_module(), and set_config().

{
   struct ast_eid empty_eid;

   memset(&empty_eid, 0, sizeof(empty_eid));
   return memcmp(eid, &empty_eid, sizeof(empty_eid)) ? 0 : 1;
}

ast_eid_to_str()

char* ast_eid_to_str	(	char *	s,
		int	maxlen,
		struct ast_eid *	eid
	)

Convert an EID to a string.

Since

1.6.1

Definition at line 2587 of file main/utils.c.

References ast_debug, ast_free, ast_log, ast_malloc, ast_set_default_eid(), buf, ast_eid::eid, LOG_WARNING, and NULL.

Referenced by app_send(), append_transaction(), ast_ari_asterisk_get_info(), ast_ari_asterisk_ping(), ast_set_default_eid(), ast_str_retrieve_variable(), AST_TEST_DEFINE(), asterisk_publication_send_refresh(), asterisk_publisher_devstate_cb(), asterisk_publisher_mwistate_cb(), bridges_scrape_cb(), build_peer(), build_transactions(), cache_lookup(), cache_lookup_internal(), channels_scrape_cb(), check_key(), complete_peer_helper(), cpg_deliver_cb(), destroy_trans(), do_autokill(), do_register(), do_register_expire(), dump_answer(), dump_eid(), dundi_answer_entity(), dundi_lookup_internal(), dundi_lookup_local(), dundi_lookup_thread(), dundi_precache_thread(), dundi_prop_precache(), dundi_query_thread(), dundi_send(), dundi_show_cache(), dundi_show_entityid(), dundi_show_hints(), dundi_show_peer(), dundi_show_peers(), dundi_show_requests(), endpoints_scrape_cb(), handle_command_response(), handle_show_settings(), populate_addr(), prometheus_config_post_apply(), publish_cluster_discovery_to_stasis_full(), publish_device_state_to_stasis(), publish_mwi_to_stasis(), publish_to_corosync(), register_request(), registry_message_cb(), update_key(), xmpp_pubsub_publish_device_state(), and xmpp_pubsub_publish_mwi().

{
   int x;
   char *os = s;
   if (maxlen < 18) {
      if (s && (maxlen > 0)) {
         *s = '\0';
      }
   } else {
      for (x = 0; x < 5; x++) {
         sprintf(s, "%02hhx:", eid->eid[x]);
         s += 3;
      }
      sprintf(s, "%02hhx", eid->eid[5]);
   }
   return os;
}

ast_enable_packet_fragmentation()

void ast_enable_packet_fragmentation

(

int

sock

)

Disable PMTU discovery on a socket.

Parameters

sock	The socket to manipulate

Returns

Nothing

On Linux, UDP sockets default to sending packets with the Dont Fragment (DF) bit set. This is supposedly done to allow the application to do PMTU discovery, but Asterisk does not do this.

Because of this, UDP packets sent by Asterisk that are larger than the MTU of any hop in the path will be lost. This function can be called on a socket to ensure that the DF bit will not be set.

Definition at line 2221 of file main/utils.c.

References ast_log, and LOG_WARNING.

Referenced by ast_netsock_bindaddr(), and reload_config().

{
#if defined(HAVE_IP_MTU_DISCOVER)
   int val = IP_PMTUDISC_DONT;

   if (setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val)))
      ast_log(LOG_WARNING, "Unable to disable PMTU discovery. Large UDP packets may fail to be delivered when sent from this socket.\n");
#endif /* HAVE_IP_MTU_DISCOVER */
}

ast_escape()

char* ast_escape	(	char *	dest,
		const char *	s,
		size_t	size,
		const char *	to_escape
	)

Escape the 'to_escape' characters in the given string.

Note

The given output buffer will contain a truncated escaped version of the source string if the given buffer is not large enough.

Parameters

dest	the escaped string
s	the source string to escape
size	The size of the destination buffer
to_escape	an array of characters to escape

Returns

Pointer to the destination.

Definition at line 1786 of file main/utils.c.

References ast_copy_string(), ast_strlen_zero, c, and escape_sequences.

Referenced by ast_escape_alloc().

{
   char *p;
   char *c;

   if (!dest || !size) {
      return dest;
   }
   if (ast_strlen_zero(s)) {
      *dest = '\0';
      return dest;
   }

   if (ast_strlen_zero(to_escape)) {
      ast_copy_string(dest, s, size);
      return dest;
   }

   for (p = dest; *s && --size; ++s, ++p) {
      /* If in the list of characters to escape then escape it */
      if (strchr(to_escape, *s)) {
         if (!--size) {
            /* Not enough room left for the escape sequence. */
            break;
         }

         /*
          * See if the character to escape is part of the standard escape
          * sequences. If so we'll have to use its mapped counterpart
          * otherwise just use the current character.
          */
         c = strchr(escape_sequences, *s);
         *p++ = '\\';
         *p = c ? escape_sequences_map[c - escape_sequences] : *s;
      } else {
         *p = *s;
      }
   }
   *p = '\0';

   return dest;
}

ast_escape_alloc()

char* ast_escape_alloc	(	const char *	s,
		const char *	to_escape
	)

Escape the 'to_escape' characters in the given string.

Note

Caller is responsible for freeing the returned string

Parameters

s	the source string to escape
to_escape	an array of characters to escape

Returns

Pointer to the escaped string or NULL.

Definition at line 1884 of file main/utils.c.

References ast_escape(), and escape_alloc().

{
   size_t size = 0;
   char *dest = escape_alloc(s, &size);

   return ast_escape(dest, s, size, to_escape);
}

ast_escape_c()

char* ast_escape_c	(	char *	dest,
		const char *	s,
		size_t	size
	)

Escape standard 'C' sequences in the given string.

Note

The given output buffer will contain a truncated escaped version of the source string if the given buffer is not large enough.

Parameters

dest	the escaped string
s	the source string to escape
size	The size of the destination buffer

Returns

Pointer to the escaped string.

Definition at line 1829 of file main/utils.c.

References ast_strlen_zero, c, and escape_sequences.

Referenced by ast_escape_c_alloc().

{
   /*
    * Note - This is an optimized version of ast_escape. When looking only
    * for escape_sequences a couple of checks used in the generic case can
    * be left out thus making it slightly more efficient.
    */
   char *p;
   char *c;

   if (!dest || !size) {
      return dest;
   }
   if (ast_strlen_zero(s)) {
      *dest = '\0';
      return dest;
   }

   for (p = dest; *s && --size; ++s, ++p) {
      /*
       * See if the character to escape is part of the standard escape
       * sequences. If so use its mapped counterpart.
       */
      c = strchr(escape_sequences, *s);
      if (c) {
         if (!--size) {
            /* Not enough room left for the escape sequence. */
            break;
         }

         *p++ = '\\';
         *p = escape_sequences_map[c - escape_sequences];
      } else {
         *p = *s;
      }
   }
   *p = '\0';

   return dest;
}

ast_escape_c_alloc()

char* ast_escape_c_alloc

(

const char *

s

)

Escape standard 'C' sequences in the given string.

Note

Caller is responsible for freeing the returned string

Parameters

s	the source string to escape

Returns

Pointer to the escaped string or NULL.

Definition at line 1892 of file main/utils.c.

References ast_escape_c(), and escape_alloc().

Referenced by ast_manager_build_channel_state_string_prefix(), channel_new_callerid(), presence_state_to_ami(), and varset_to_ami().

{
   size_t size = 0;
   char *dest = escape_alloc(s, &size);

   return ast_escape_c(dest, s, size);
}

ast_escape_quoted()

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

Escape characters found in a quoted string.

Note

This function escapes quoted characters based on the 'qdtext' set of allowed characters from RFC 3261 section 25.1.

Parameters

string	string to be escaped
outbuf	resulting escaped string
buflen	size of output buffer

Returns

a pointer to the escaped string

Definition at line 635 of file main/utils.c.

References out, and string.

Referenced by add_diversion(), add_rpid(), ast_callerid_merge(), ast_sip_modify_id_header(), AST_TEST_DEFINE(), channel_read_pjsip(), create_new_id_hdr(), initreqprep(), print_escaped_uri(), and receive_message().

{
   const char *ptr  = string;
   char *out = outbuf;
   char *allow = "\t\v !"; /* allow LWS (minus \r and \n) and "!" */

   while (*ptr && out - outbuf < buflen - 1) {
      if (!(strchr(allow, *ptr))
         && !(*ptr >= '#' && *ptr <= '[') /* %x23 - %x5b */
         && !(*ptr >= ']' && *ptr <= '~') /* %x5d - %x7e */
         && !((unsigned char) *ptr > 0x7f)) {             /* UTF8-nonascii */

         if (out - outbuf >= buflen - 2) {
            break;
         }
         out += sprintf(out, "\\%c", (unsigned char) *ptr);
      } else {
         *out = *ptr;
         out++;
      }
      ptr++;
   }

   if (buflen) {
      *out = '\0';
   }

   return outbuf;
}

ast_escape_semicolons()

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

Escape semicolons found in a string.

Parameters

string	string to be escaped
outbuf	resulting escaped string
buflen	size of output buffer

Returns

a pointer to the escaped string

Definition at line 665 of file main/utils.c.

References ast_assert, NULL, out, and string.

Referenced by ast_config_text_file_save2(), handle_cli_dialplan_save(), and test_semi().

{
   const char *ptr = string;
   char *out = outbuf;

   if (string == NULL || outbuf == NULL) {
      ast_assert(string != NULL && outbuf != NULL);
      return NULL;
   }

   while (*ptr && out - outbuf < buflen - 1) {
      if (*ptr == ';') {
         if (out - outbuf >= buflen - 2) {
            break;
         }
         strcpy(out, "\\;");
         out += 2;
      } else {
         *out = *ptr;
         out++;
      }
      ptr++;
   }

   if (buflen) {
      *out = '\0';
   }

   return outbuf;
}

ast_false()

int ast_false

(

const char *

val

)

Make sure something is false. Determine if a string containing a boolean value is "false". This function checks to see whether a string passed to it is an indication of an "false" value. It checks to see if the string is "no", "false", "n", "f", "off" or "0".

Return values

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

Definition at line 1968 of file main/utils.c.

References ast_strlen_zero.

Referenced by acf_faxopt_write(), acf_transaction_write(), actual_load_config(), announce_user_count_all_handler(), aoc_cli_debug_enable(), bool_handler_fn(), boolflag_handler_fn(), build_peer(), build_user(), check_debug(), dahdi_set_dnd(), find_realtime(), function_ooh323_write(), handle_common_options(), handle_queue_set_member_ringinuse(), hook_write(), init_acf_query(), load_config(), manager_mute_mixmonitor(), manager_queue_member_ringinuse(), parking_feature_flag_cfg(), parse_empty_options(), parse_playtone(), prack_handler(), process_config(), process_dahdi(), process_echocancel(), read_pjproject_startup_options(), reload(), reload_config(), reload_single_member(), rt_handle_member_record(), rtp_reload(), run_agi(), set_config(), set_insecure_flags(), sip_parse_nat_option(), sla_build_trunk(), strings_to_mask(), and timers_handler().

{
   if (ast_strlen_zero(s))
      return 0;

   /* Determine if this is a false value */
   if (!strcasecmp(s, "no") ||
       !strcasecmp(s, "false") ||
       !strcasecmp(s, "n") ||
       !strcasecmp(s, "f") ||
       !strcasecmp(s, "0") ||
       !strcasecmp(s, "off"))
      return -1;

   return 0;
}

ast_file_is_readable()

int ast_file_is_readable

(

const char *

filename

)

Test that a file exists and is readable by the effective user.

Since

13.7.0

Parameters

filename

File to test.

Returns

True (non-zero) if the file exists and is readable.

False (zero) if the file either doesn't exists or is not readable.

Definition at line 2855 of file main/utils.c.

Referenced by add_email_attachment(), ast_media_cache_retrieve(), ast_rtp_dtls_cfg_parse(), on_load_ca_file(), on_load_ca_path(), and transport_tls_file_handler().

{
#if defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS)
#if defined(HAVE_EUIDACCESS) && !defined(HAVE_EACCESS)
#define eaccess euidaccess
#endif
   return eaccess(filename, R_OK) == 0;
#else
   int fd = open(filename, O_RDONLY |  O_NONBLOCK);
   if (fd < 0) {
      return 0;
   }
   close(fd);
   return 1;
#endif
}

ast_find_lock_info()

int ast_find_lock_info	(	void *	lock_addr,
		char *	filename,
		size_t	filename_size,
		int *	lineno,
		char *	func,
		size_t	func_size,
		char *	mutex_name,
		size_t	mutex_name_size
	)

retrieve lock info for the specified mutex

this gets called during deadlock avoidance, so that the information may be preserved as to what location originally acquired the lock.

Definition at line 995 of file main/utils.c.

References ast_copy_string(), ast_threadstorage_get(), thr_lock_info::file, thr_lock_info::func, thr_lock_info::line_num, thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::lock_name, thr_lock_info::locks, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, and thread_lock_info.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   int i = 0;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return -1;

   pthread_mutex_lock(&lock_info->lock);

   for (i = lock_info->num_locks - 1; i >= 0; i--) {
      if (lock_info->locks[i].lock_addr == lock_addr)
         break;
   }

   if (i == -1) {
      /* Lock not found :( */
      pthread_mutex_unlock(&lock_info->lock);
      return -1;
   }

   ast_copy_string(filename, lock_info->locks[i].file, filename_size);
   *lineno = lock_info->locks[i].line_num;
   ast_copy_string(func, lock_info->locks[i].func, func_size);
   ast_copy_string(mutex_name, lock_info->locks[i].lock_name, mutex_name_size);

   pthread_mutex_unlock(&lock_info->lock);

   return 0;
#else /* if defined(LOW_MEMORY) */
   return -1;
#endif
}

ast_format_duration_hh_mm_ss()

void ast_format_duration_hh_mm_ss	(	int	duration,
		char *	buf,
		size_t	length
	)

Formats a duration into HH:MM:SS.

Since

12

Parameters

duration	The time (in seconds) to format
buf	A buffer to hold the formatted string'
length	The size of the buffer

Definition at line 2049 of file main/utils.c.

Referenced by cli_channel_print_body(), cli_channelstats_print_body(), handle_bridge_show_all(), handle_bridge_show_specific(), show_chanstats_cb(), and stasis_show_topic().

{
   int durh, durm, durs;
   durh = duration / 3600;
   durm = (duration % 3600) / 60;
   durs = duration % 60;
   snprintf(buf, length, "%02d:%02d:%02d", durh, durm, durs);
}

ast_get_tid()

int ast_get_tid

(

void

)

Get current thread ID.

Returns

the ID if platform is supported, else -1

Definition at line 2504 of file main/utils.c.

Referenced by __ao2_ref(), ast_hangup(), ast_register_thread(), dummy_start(), format_log_message_ap(), and internal_ao2_alloc().

{
   int ret = -1;
#if defined (__linux) && defined(SYS_gettid)
   ret = syscall(SYS_gettid); /* available since Linux 1.4.11 */
#elif defined(__sun)
   ret = pthread_self();
#elif defined(__APPLE__)
   ret = mach_thread_self();
   mach_port_deallocate(mach_task_self(), ret);
#elif defined(__FreeBSD__) && defined(HAVE_SYS_THR_H)
   long lwpid;
   thr_self(&lwpid); /* available since sys/thr.h creation 2003 */
   ret = lwpid;
#endif
   return ret;
}

ast_get_time_t()

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

get values from config variables.

Definition at line 2198 of file main/utils.c.

References ast_strlen_zero, and NULL.

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

{
   long t;
   int scanned;

   if (dst == NULL)
      return -1;

   *dst = _default;

   if (ast_strlen_zero(src))
      return -1;

   /* only integer at the moment, but one day we could accept more formats */
   if (sscanf(src, "%30ld%n", &t, &scanned) == 1) {
      *dst = t;
      if (consumed)
         *consumed = scanned;
      return 0;
   } else
      return -1;
}

ast_get_timeval()

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

get values from config variables.

Definition at line 2171 of file main/utils.c.

References ast_strlen_zero, and NULL.

Referenced by acf_strftime(), expiration_str2struct(), persistence_expires_str2struct(), and timeval_str2struct().

{
   long double dtv = 0.0;
   int scanned;

   if (dst == NULL)
      return -1;

   *dst = _default;

   if (ast_strlen_zero(src))
      return -1;

   /* only integer at the moment, but one day we could accept more formats */
   if (sscanf(src, "%30Lf%n", &dtv, &scanned) > 0) {
      dst->tv_sec = dtv;
      dst->tv_usec = (dtv - dst->tv_sec) * 1000000.0;
      if (consumed)
         *consumed = scanned;
      return 0;
   } else
      return -1;
}

ast_gethostbyname()

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)

Thread-safe gethostbyname function to use in Asterisk.

Definition at line 197 of file main/utils.c.

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

Referenced by ast_parse_arg(), config_load(), config_parse_variables(), festival_exec(), iax_template_parse(), process_sdp(), and reload_config().

{
#ifndef HAVE_GETHOSTBYNAME_R_5
   int res;
#endif
   int herrno;
   int dots = 0;
   const char *s;
   struct hostent *result = NULL;
   /* Although it is perfectly legitimate to lookup a pure integer, for
      the sake of the sanity of people who like to name their peers as
      integers, we break with tradition and refuse to look up a
      pure integer */
   s = host;
   while (s && *s) {
      if (*s == '.')
         dots++;
      else if (!isdigit(*s))
         break;
      s++;
   }
   if (!s || !*s) {
      /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
      if (dots != 3)
         return NULL;
      memset(hp, 0, sizeof(struct ast_hostent));
      hp->hp.h_addrtype = AF_INET;
      hp->hp.h_addr_list = (void *) hp->buf;
      hp->hp.h_addr = hp->buf + sizeof(void *);
      /* For AF_INET, this will always be 4 */
      hp->hp.h_length = 4;
      if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
         return &hp->hp;
      return NULL;

   }
#ifdef HAVE_GETHOSTBYNAME_R_5
   result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);

   if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
      return NULL;
#else
   res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);

   if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
      return NULL;
#endif
   return &hp->hp;
}

ast_inet_ntoa()

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 782 of file main/utils.c.

References ast_threadstorage_get(), buf, and inet_ntoa_buf.

Referenced by _skinny_show_device(), _skinny_show_devices(), _stun_show_status(), add_sdp(), ast_dns_get_nameservers(), ast_parse_arg(), config_load(), create_client(), find_command(), find_subchannel_and_lock(), get_defaults(), get_to_address(), handle_error(), handle_mgcp_show_endpoints(), handle_open_receive_channel_ack_message(), handle_request(), handle_skinny_show_settings(), iax_server(), mgcpsock_read(), parsing(), process_request(), process_sdp(), reload_config(), resend_response(), rtp_add_candidates_to_ice(), rtp_reload(), score_address(), send_raw_client(), send_request(), send_response(), send_start_rtp(), send_trunk(), show_main_page(), skinny_session(), skinny_session_cleanup(), skinny_set_rtp_peer(), start_rtp(), stun_monitor_request(), transmit_serverres(), transmit_startmediatransmission(), unistim_show_devices(), unistim_show_info(), and unistimsock_read().

{
   char *buf;

   if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
      return "";

   return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
}

ast_join_delim()

void ast_join_delim	(	char *	s,
		size_t	len,
		const char *const	w[],
		unsigned int	size,
		char	delim
	)

Definition at line 2130 of file main/utils.c.

References len().

Referenced by ast_sip_auths_to_str().

{
   int x, ofs = 0;
   const char *src;

   /* Join words into a string */
   if (!s)
      return;
   for (x = 0; ofs < len && x < size && w[x] ; x++) {
      if (x > 0)
         s[ofs++] = delim;
      for (src = w[x]; *src && ofs < len; src++)
         s[ofs++] = *src;
   }
   if (ofs == len)
      ofs--;
   s[ofs] = '\0';
}

ast_log_show_lock()

void ast_log_show_lock

(

void *

this_lock_addr

)

log info for the current lock with ast_log().

This function can help you find highly temporal locks; locks that happen for a short time, but at unexpected times, usually at times that create a deadlock, Why is this thing locked right then? Who is locking it? Who am I fighting with for this lock?

To answer such questions, just call this routine before you would normally try to aquire a lock. It doesn't do anything if the lock is not acquired. If the lock is taken, it will publish a line or two to the console via ast_log().

Sometimes, the lock message is pretty uninformative. For instance, you might find that the lock is being aquired deep within the astobj2 code; this tells you little about higher level routines that call the astobj2 routines. But, using gdb, you can set a break at the ast_log below, and for that breakpoint, you can set the commands: where cont which will give a stack trace and continue. – that aught to do the job!

Definition at line 1231 of file main/utils.c.

References append_lock_information(), ast_free, AST_LIST_TRAVERSE, ast_log, ast_str_buffer(), ast_str_create, thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, lock_infos_lock, thr_lock_info::locks, LOG_NOTICE, ast_mutex_info::mutex, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, and str.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   struct ast_str *str;

   if (!(str = ast_str_create(4096))) {
      ast_log(LOG_NOTICE,"Could not create str\n");
      return;
   }


   pthread_mutex_lock(&lock_infos_lock.mutex);
   AST_LIST_TRAVERSE(&lock_infos, lock_info, entry) {
      int i;
      pthread_mutex_lock(&lock_info->lock);
      for (i = 0; str && i < lock_info->num_locks; i++) {
         /* ONLY show info about this particular lock, if
            it's acquired... */
         if (lock_info->locks[i].lock_addr == this_lock_addr) {
            append_lock_information(&str, lock_info, i);
            ast_log(LOG_NOTICE, "%s", ast_str_buffer(str));
            break;
         }
      }
      pthread_mutex_unlock(&lock_info->lock);
   }
   pthread_mutex_unlock(&lock_infos_lock.mutex);
   ast_free(str);
#endif /* ! LOW_MEMORY */
}

ast_mark_lock_acquired()

void ast_mark_lock_acquired

(

void *

lock_addr

)

Mark the last lock as acquired.

Definition at line 962 of file main/utils.c.

References ast_threadstorage_get(), thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::locks, thr_lock_info::num_locks, thr_lock_info::pending, pthread_mutex_lock, pthread_mutex_unlock, and thread_lock_info.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return;

   pthread_mutex_lock(&lock_info->lock);
   if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
      lock_info->locks[lock_info->num_locks - 1].pending = 0;
   }
   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_mark_lock_failed()

void ast_mark_lock_failed

(

void *

lock_addr

)

Mark the last lock as failed (trylock)

Definition at line 978 of file main/utils.c.

References ast_threadstorage_get(), thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::locks, thr_lock_info::num_locks, thr_lock_info::pending, pthread_mutex_lock, pthread_mutex_unlock, thread_lock_info, and thr_lock_info::times_locked.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return;

   pthread_mutex_lock(&lock_info->lock);
   if (lock_info->locks[lock_info->num_locks - 1].lock_addr == lock_addr) {
      lock_info->locks[lock_info->num_locks - 1].pending = -1;
      lock_info->locks[lock_info->num_locks - 1].times_locked--;
   }
   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_md5_hash()

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 248 of file main/utils.c.

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

Referenced by __init_manager(), ast_sip_location_create_contact(), AST_TEST_DEFINE(), auth_exec(), auth_http_callback(), build_nonce(), build_reply_digest(), check_auth(), md5(), and permanent_uri_handler().

{
   struct MD5Context md5;
   unsigned char digest[16];
   char *ptr;
   int x;

   MD5Init(&md5);
   MD5Update(&md5, (const unsigned char *) input, strlen(input));
   MD5Final(digest, &md5);
   ptr = output;
   for (x = 0; x < 16; x++)
      ptr += sprintf(ptr, "%02hhx", digest[x]);
}

ast_mkdir()

int ast_mkdir	(	const char *	path,
		int	mode
	)

Recursively create directory path.

Parameters

path	The directory path to create
mode	The permissions with which to try to create the directory

Returns

0 on success or an error code otherwise

Creates a directory path, creating parent directories as needed.

Definition at line 2231 of file main/utils.c.

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

Referenced by ast_logger_rotate_channel(), ast_monitor_change_fname(), ast_monitor_start(), conf_rec_name(), conf_run(), create_destination_directory(), create_dirpath(), create_temp_file(), dictate_exec(), filename_parse(), init_logger(), load_module(), reload_logger(), remove_from_queue(), setup_privacy_args(), sms_nextoutgoing(), sms_writefile(), test_vm_api_create_voicemail_folder(), testclient_exec(), testserver_exec(), and write_history().

{
   char *ptr;
   int len = strlen(path), count = 0, x, piececount = 0;
   char *tmp = ast_strdupa(path);
   char **pieces;
   char *fullpath = ast_alloca(len + 1);
   int res = 0;

   for (ptr = tmp; *ptr; ptr++) {
      if (*ptr == '/')
         count++;
   }

   /* Count the components to the directory path */
   pieces = ast_alloca(count * sizeof(*pieces));
   for (ptr = tmp; *ptr; ptr++) {
      if (*ptr == '/') {
         *ptr = '\0';
         pieces[piececount++] = ptr + 1;
      }
   }

   *fullpath = '\0';
   for (x = 0; x < piececount; x++) {
      /* This looks funky, but the buffer is always ideally-sized, so it's fine. */
      strcat(fullpath, "/");
      strcat(fullpath, pieces[x]);
      res = mkdir(fullpath, mode);
      if (res && errno != EEXIST)
         return errno;
   }
   return 0;
}

ast_parse_digest()

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

Parse digest authorization header.

Returns

Returns -1 if we have no auth or something wrong with digest.

Note

This function may be used for Digest request and responce header. request arg is set to nonzero, if we parse Digest Request. pedantic arg can be set to nonzero if we need to do addition Digest check.

Definition at line 2390 of file main/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(), c, ast_http_digest::cnonce, ast_http_digest::domain, LOG_WARNING, ast_http_digest::nc, ast_http_digest::nonce, NULL, ast_http_digest::opaque, ast_http_digest::qop, ast_http_digest::realm, ast_http_digest::response, str, strsep(), ast_http_digest::uri, and ast_http_digest::username.

Referenced by auth_http_callback().

                                                                                               {
   char *c;
   struct ast_str *str = ast_str_create(16);

   /* table of recognised keywords, and places where they should be copied */
   const struct x {
      const char *key;
      const ast_string_field *field;
   } *i, keys[] = {
      { "username=", &d->username },
      { "realm=", &d->realm },
      { "nonce=", &d->nonce },
      { "uri=", &d->uri },
      { "domain=", &d->domain },
      { "response=", &d->response },
      { "cnonce=", &d->cnonce },
      { "opaque=", &d->opaque },
      /* Special cases that cannot be directly copied */
      { "algorithm=", NULL },
      { "qop=", NULL },
      { "nc=", NULL },
      { NULL, 0 },
   };

   if (ast_strlen_zero(digest) || !d || !str) {
      ast_free(str);
      return -1;
   }

   ast_str_set(&str, 0, "%s", digest);

   c = ast_skip_blanks(ast_str_buffer(str));

   if (strncasecmp(c, "Digest ", strlen("Digest "))) {
      ast_log(LOG_WARNING, "Missing Digest.\n");
      ast_free(str);
      return -1;
   }
   c += strlen("Digest ");

   /* lookup for keys/value pair */
   while (c && *c && *(c = ast_skip_blanks(c))) {
      /* find key */
      for (i = keys; i->key != NULL; i++) {
         char *src, *separator;
         int unescape = 0;
         if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
            continue;
         }

         /* Found. Skip keyword, take text in quotes or up to the separator. */
         c += strlen(i->key);
         if (*c == '"') {
            src = ++c;
            separator = "\"";
            unescape = 1;
         } else {
            src = c;
            separator = ",";
         }
         strsep(&c, separator); /* clear separator and move ptr */
         if (unescape) {
            ast_unescape_c(src);
         }
         if (i->field) {
            ast_string_field_ptr_set(d, i->field, src);
         } else {
            /* Special cases that require additional procesing */
            if (!strcasecmp(i->key, "algorithm=")) {
               if (strcasecmp(src, "MD5")) {
                  ast_log(LOG_WARNING, "Digest algorithm: \"%s\" not supported.\n", src);
                  ast_free(str);
                  return -1;
               }
            } else if (!strcasecmp(i->key, "qop=") && !strcasecmp(src, "auth")) {
               d->qop = 1;
            } else if (!strcasecmp(i->key, "nc=")) {
               unsigned long u;
               if (sscanf(src, "%30lx", &u) != 1) {
                  ast_log(LOG_WARNING, "Incorrect Digest nc value: \"%s\".\n", src);
                  ast_free(str);
                  return -1;
               }
               ast_string_field_set(d, nc, src);
            }
         }
         break;
      }
      if (i->key == NULL) { /* not found, try ',' */
         strsep(&c, ",");
      }
   }
   ast_free(str);

   /* Digest checkout */
   if (ast_strlen_zero(d->realm) || ast_strlen_zero(d->nonce)) {
      /* "realm" and "nonce" MUST be always exist */
      return -1;
   }

   if (!request) {
      /* Additional check for Digest response */
      if (ast_strlen_zero(d->username) || ast_strlen_zero(d->uri) || ast_strlen_zero(d->response)) {
         return -1;
      }

      if (pedantic && d->qop && (ast_strlen_zero(d->cnonce) || ast_strlen_zero(d->nc))) {
         return -1;
      }
   }

   return 0;
}

ast_process_quotes_and_slashes()

char* ast_process_quotes_and_slashes	(	char *	start,
		char	find,
		char	replace_with
	)

Process a string to find and replace characters.

Parameters

start	The string to analyze
find	The character to find
replace_with	The character that will replace the one we are looking for

Definition at line 2104 of file main/utils.c.

{
   char *dataPut = start;
   int inEscape = 0;
   int inQuotes = 0;

   for (; *start; start++) {
      if (inEscape) {
         *dataPut++ = *start;       /* Always goes verbatim */
         inEscape = 0;
      } else {
         if (*start == '\\') {
            inEscape = 1;      /* Do not copy \ into the data */
         } else if (*start == '\'') {
            inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
         } else {
            /* Replace , with |, unless in quotes */
            *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
         }
      }
   }
   if (start != dataPut)
      *dataPut = 0;
   return dataPut;
}

ast_pthread_create_detached_stack()

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 1494 of file main/utils.c.

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

{
   unsigned char attr_destroy = 0;
   int res;

   if (!attr) {
      attr = ast_alloca(sizeof(*attr));
      pthread_attr_init(attr);
      attr_destroy = 1;
   }

   if ((errno = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)))
      ast_log(LOG_WARNING, "pthread_attr_setdetachstate: %s\n", strerror(errno));

   res = ast_pthread_create_stack(thread, attr, start_routine, data,
                                  stacksize, file, caller, line, start_fn);

   if (attr_destroy)
      pthread_attr_destroy(attr);

   return res;
}

ast_pthread_create_stack()

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 1446 of file main/utils.c.

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

Referenced by ast_pthread_create_detached_stack().

{
#if !defined(LOW_MEMORY)
   struct thr_arg *a;
#endif

   if (!attr) {
      attr = ast_alloca(sizeof(*attr));
      pthread_attr_init(attr);
   }

#if defined(__linux__) || defined(__FreeBSD__)
   /* On Linux and FreeBSD , pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
      which is kind of useless. Change this here to
      PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
      priority will propagate down to new threads by default.
      This does mean that callers cannot set a different priority using
      PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
      the priority afterwards with pthread_setschedparam(). */
   if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
      ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
#endif

   if (!stacksize)
      stacksize = AST_STACKSIZE;

   if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
      ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));

#if !defined(LOW_MEMORY)
   if ((a = ast_malloc(sizeof(*a)))) {
      a->start_routine = start_routine;
      a->data = data;
      start_routine = dummy_start;
      if (ast_asprintf(&a->name, "%-20s started at [%5d] %s %s()",
              start_fn, line, file, caller) < 0) {
         a->name = NULL;
      }
      data = a;
   }
#endif /* !LOW_MEMORY */

   return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
}

ast_random()

long int ast_random

(

void

)

Definition at line 2064 of file main/utils.c.

References ast_mutex_lock, ast_mutex_unlock, and randomlock.

Referenced by __sip_alloc(), acf_rand_exec(), action_challenge(), add_sdp(), agi_handle_command(), app_exec(), ast_generate_random_string(), ast_lock_path_lockfile(), ast_moh_files_next(), ast_rtp_change_source(), ast_rtp_new(), AST_TEST_DEFINE(), ast_udptl_new_with_bindaddr(), astobj2_test_1_helper(), auth_http_callback(), authenticate_request(), build_gateway(), build_iv(), build_localtag_registry(), build_nonce(), build_rand_pad(), build_reply_digest(), calc_metric(), calc_rxstamp(), caldav_write_event(), closefrom(), create_channel_name(), create_local_sdp(), dns_srv_sort(), drop_packets_data_update(), fill_with_garbage(), generate_parked_user(), generate_random_string(), generic_http_callback(), get_trans_id(), get_unused_callno(), handle_cli_sched_bench(), handle_incoming(), handle_response_invite(), iax2_key_rotate(), jingle_add_ice_udp_candidates_to_transport(), jingle_alloc(), jingle_new(), load_module(), make_email_file(), make_our_tag(), mbl_new(), moh_files_alloc(), multicast_rtp_new(), ogg_vorbis_rewrite(), osp_create_uuid(), page_exec(), process_weights(), reg_source_db(), registry_authrequest(), reqprep(), reschedule_reinvite(), rtp_allocate_transport(), say_periodic_announcement(), sendmail(), sip_outbound_registration_perform(), socket_read(), sorcery_memory_cache_thrash_retrieve(), sorcery_memory_cache_thrash_update(), start_rtp(), stun_req_id(), test_ao2_find_w_no_flags(), test_ao2_find_w_OBJ_KEY(), test_ao2_find_w_OBJ_PARTIAL_KEY(), test_ao2_find_w_OBJ_POINTER(), test_files_get_one(), transmit_invite(), transmit_register(), transmit_response_using_temp(), try_calling(), try_firmware(), websocket_client_create_key(), and websocket_mask_payload().

{
   long int res;

   if (dev_urandom_fd >= 0) {
      int read_res = read(dev_urandom_fd, &res, sizeof(res));
      if (read_res > 0) {
         long int rm = RAND_MAX;
         res = res < 0 ? ~res : res;
         rm++;
         return res % rm;
      }
   }

   /* XXX - Thread safety really depends on the libc, not the OS.
    *
    * But... popular Linux libc's (uClibc, glibc, eglibc), all have a
    * somewhat thread safe random(3) (results are random, but not
    * reproducible). The libc's for other systems (BSD, et al.), not so
    * much.
    */
#ifdef linux
   res = random();
#else
   ast_mutex_lock(&randomlock);
   res = random();
   ast_mutex_unlock(&randomlock);
#endif
   return res;
}

ast_regex_string_to_regex_pattern()

int ast_regex_string_to_regex_pattern	(	const char *	regex_string,
		struct ast_str **	regex_pattern
	)

Given a string regex_string in the form of "/regex/", convert it into the form of "regex".

This function will trim one leading / and one trailing / from a given input string ast_str regex_pattern must be preallocated before calling this function

Returns

0 on success, non-zero on failure.

1 if we only stripped a leading /

2 if we only stripped a trailing /

3 if we did not strip any / characters

Parameters

regex_string	the string containing /regex/
regex_pattern	the destination ast_str which will contain "regex" after execution

Definition at line 1931 of file main/utils.c.

References ast_str_set(), and ast_str_truncate().

Referenced by action_hangup(), mwi_mailbox_delete(), and mwi_mailbox_get().

{
   int regex_len = strlen(regex_string);
   int ret = 3;

   /* Chop off the leading / if there is one */
   if ((regex_len >= 1) && (regex_string[0] == '/')) {
      ast_str_set(regex_pattern, 0, "%s", regex_string + 1);
      ret -= 2;
   }

   /* Chop off the ending / if there is one */
   if ((regex_len > 1) && (regex_string[regex_len - 1] == '/')) {
      ast_str_truncate(*regex_pattern, -1);
      ret -= 1;
   }

   return ret;
}

ast_remaining_ms()

int ast_remaining_ms	(	struct timeval	start,
		int	max_ms
	)

Calculate remaining milliseconds given a starting timestamp and upper bound.

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

Parameters

start	When timing started being calculated
max_ms	The maximum number of milliseconds to wait from start. May be negative.

Returns

The number of milliseconds left to wait for. May be negative.

Definition at line 2033 of file main/utils.c.

References ast_tvdiff_ms(), and ast_tvnow().

Referenced by __analog_ss_thread(), __ast_answer(), __ast_request_and_dial(), analog_ss_thread(), ast_iostream_write(), ast_recvtext(), ast_stun_request(), ast_waitfordigit_full(), disable_t38(), find_cache(), generic_fax_exec(), iostream_read(), parking_set_duration(), read_mf_digits(), read_sf_digits(), receivefax_t38_init(), record_exec(), safe_sleep_conditional(), sendfax_t38_init(), wait_exec(), wait_for_answer(), wait_for_cache_update(), and waitforring_exec().

{
   int ms;

   if (max_ms < 0) {
      ms = max_ms;
   } else {
      ms = max_ms - ast_tvdiff_ms(ast_tvnow(), start);
      if (ms < 0) {
         ms = 0;
      }
   }

   return ms;
}

ast_remove_lock_info()

void ast_remove_lock_info	(	void *	lock_addr,
		struct ast_bt *	bt
	)

remove lock info for the current thread

this gets called by ast_mutex_unlock so that information on the lock can be removed from the current thread's lock info struct.

Definition at line 1088 of file main/utils.c.

References ast_threadstorage_get(), thr_lock_info::backtrace, thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::locks, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, thread_lock_info, and thr_lock_info::times_locked.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   int i = 0;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return;

   pthread_mutex_lock(&lock_info->lock);

   for (i = lock_info->num_locks - 1; i >= 0; i--) {
      if (lock_info->locks[i].lock_addr == lock_addr)
         break;
   }

   if (i == -1) {
      /* Lock not found :( */
      pthread_mutex_unlock(&lock_info->lock);
      return;
   }

   if (lock_info->locks[i].times_locked > 1) {
      lock_info->locks[i].times_locked--;
#ifdef HAVE_BKTR
      lock_info->locks[i].backtrace = bt;
#endif
      pthread_mutex_unlock(&lock_info->lock);
      return;
   }

   if (i < lock_info->num_locks - 1) {
      /* Not the last one ... *should* be rare! */
      memmove(&lock_info->locks[i], &lock_info->locks[i + 1],
         (lock_info->num_locks - (i + 1)) * sizeof(lock_info->locks[0]));
   }

   lock_info->num_locks--;

   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_replace_subargument_delimiter()

void ast_replace_subargument_delimiter

(

char *

s

)

Replace '^' in a string with ','.

Parameters

s	String within which to replace characters

Definition at line 2095 of file main/utils.c.

Referenced by app_exec(), ast_bridge_set_after_go_on(), dial_exec_full(), originate_exec(), page_exec(), and queue_exec().

{
   for (; *s; s++) {
      if (*s == '^') {
         *s = ',';
      }
   }
}

ast_restore_lock_info()

void ast_restore_lock_info

(

void *

lock_addr

)

Definition at line 1059 of file main/utils.c.

References ast_threadstorage_get(), thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::locks, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, thr_lock_info::suspended, and thread_lock_info.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   int i = 0;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return;

   pthread_mutex_lock(&lock_info->lock);

   for (i = lock_info->num_locks - 1; i >= 0; i--) {
      if (lock_info->locks[i].lock_addr == lock_addr)
         break;
   }

   if (i == -1) {
      /* Lock not found :( */
      pthread_mutex_unlock(&lock_info->lock);
      return;
   }

   lock_info->locks[i].suspended = 0;

   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_safe_mkdir()

int ast_safe_mkdir	(	const char *	base_path,
		const char *	path,
		int	mode
	)

Recursively create directory path, but only if it resolves within the given base_path.

If base_path does not exist, it will not be created and this function returns EPERM.

Parameters

path	The directory path to create
mode	The permissions with which to try to create the directory

Returns

0 on success or an error code otherwise

Definition at line 2336 of file main/utils.c.

References ast_free, ast_std_free(), ast_strdup, errno, NULL, RAII_VAR, and safe_mkdir().

Referenced by AST_TEST_DEFINE(), and stasis_app_control_record().

{
   RAII_VAR(char *, absolute_base_path, NULL, ast_std_free);
   RAII_VAR(char *, p, NULL, ast_free);

   if (base_path == NULL || path == NULL) {
      errno = EFAULT;
      return errno;
   }

   p = ast_strdup(path);
   if (p == NULL) {
      errno = ENOMEM;
      return errno;
   }

   absolute_base_path = realpath(base_path, NULL);
   if (absolute_base_path == NULL) {
      return errno;
   }

   return safe_mkdir(absolute_base_path, p, mode);
}

ast_set_default_eid()

void ast_set_default_eid

(

struct ast_eid *

eid

)

Fill in an ast_eid with the default eid of this machine.

Since

1.6.1

Definition at line 2749 of file main/utils.c.

References ast_debug, ast_eid_to_str(), ast_free, ast_log, ast_malloc, buf, if(), LOG_WARNING, and NULL.

Referenced by ast_eid_to_str(), and load_asterisk_conf().

{
   int s;
   int i;
   struct ifreq *ifr;
   struct ifreq *ifrp;
   struct ifconf ifc;
   char *buf = NULL;
   char eid_str[20];
   int bufsz, num_interfaces;
   unsigned char empty_mac[6] = {0, 0, 0, 0, 0, 0};
   unsigned char full_mac[6]  = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

   s = socket(AF_INET, SOCK_STREAM, 0);
   if (s < 0) {
      ast_log(LOG_WARNING, "Unable to open socket for seeding global EID. "
         "You will have to set it manually.\n");
      return;
   }

   ifc.ifc_len = 0;
   ifc.ifc_buf = NULL;
   if (ioctl(s, SIOCGIFCONF, &ifc) || ifc.ifc_len <= 0) {
      ast_log(LOG_WARNING, "No ethernet interface found for seeding global EID. "
         "You will have to set it manually.\n");
      close(s);
      return;
   }
   bufsz = ifc.ifc_len;

   if (!(buf = ast_malloc(bufsz))) {
      ast_log(LOG_WARNING, "Unable to allocate memory for seeding global EID. "
         "You will have to set it manually.\n");
      close(s);
      return;
   }

   ifc.ifc_buf = buf;
   if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
      ast_log(LOG_WARNING, "Unable to retrieve ethernet interfaces for seeding global EID. "
         "You will have to set it manually.\n");
      ast_free(buf);
      close(s);
      return;
   }

   ifrp = ifc.ifc_req;
   num_interfaces = ifc.ifc_len / sizeof(*ifr);

   for (i = 0; i < num_interfaces; i++) {
      ifr = &ifrp[i];
      if (!ioctl(s, SIOCGIFHWADDR, ifr)) {
         unsigned char *hwaddr = (unsigned char *) ifr->ifr_hwaddr.sa_data;

         if (!(memcmp(hwaddr, &empty_mac, 6) && memcmp(hwaddr, &full_mac, 6))) {
            continue;
         }

         memcpy(eid, hwaddr, sizeof(*eid));
         ast_debug(1, "Seeding global EID '%s' from '%s' using 'siocgifhwaddr'\n",
            ast_eid_to_str(eid_str, sizeof(eid_str), eid), ifr->ifr_name);
         ast_free(buf);
         close(s);
         return;
      }
   }

   ast_log(LOG_WARNING, "No ethernet interface found for seeding global EID. "
      "You will have to set it manually.\n");
   ast_free(buf);
   close(s);

   return;
}

ast_sha1_hash()

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 264 of file main/utils.c.

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

Referenced by add_public_key_to_astdb(), ast_tcptls_server_start(), AST_TEST_DEFINE(), get_path_to_public_key(), handle_call_token(), media_cache_item_sync_to_astdb(), public_key_is_expired(), remove_public_key_from_astdb(), set_public_key_expiration(), sha1(), test_stir_shaken_add_fake_astdb_entry(), xmpp_client_authenticate_digest(), and xmpp_component_authenticate().

{
   struct SHA1Context sha;
   char *ptr;
   int x;
   uint8_t Message_Digest[20];

   SHA1Reset(&sha);

   SHA1Input(&sha, (const unsigned char *) input, strlen(input));

   SHA1Result(&sha, Message_Digest);
   ptr = output;
   for (x = 0; x < 20; x++)
      ptr += sprintf(ptr, "%02hhx", Message_Digest[x]);
}

ast_sha1_hash_uint()

void ast_sha1_hash_uint	(	uint8_t *	digest,
		const char *	input
	)

Produce a 20 byte SHA1 hash of value.

Produces SHA1 hash based on input string, stored in uint8_t array.

Definition at line 282 of file main/utils.c.

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

Referenced by websocket_combine_key().

{
        struct SHA1Context sha;

        SHA1Reset(&sha);

        SHA1Input(&sha, (const unsigned char *) input, strlen(input));

        SHA1Result(&sha, digest);
}

ast_store_lock_info()

void ast_store_lock_info	(	enum ast_lock_type	type,
		const char *	filename,
		int	line_num,
		const char *	func,
		const char *	lock_name,
		void *	lock_addr,
		struct ast_bt *	bt
	)

Store lock info for the current thread.

This function gets called in ast_mutex_lock() and ast_mutex_trylock() so that information about this lock can be stored in this thread's lock info struct. The lock is marked as pending as the thread is waiting on the lock. ast_mark_lock_acquired() will mark it as held by this thread.

Definition at line 905 of file main/utils.c.

References AST_MAX_LOCKS, ast_threadstorage_get(), thr_lock_info::backtrace, thr_lock_info::file, thr_lock_info::func, thr_lock_info::line_num, thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::lock_name, thr_lock_info::locks, thr_lock_info::num_locks, thr_lock_info::pending, pthread_mutex_lock, pthread_mutex_unlock, thread_lock_info, thr_lock_info::times_locked, and thr_lock_info::type.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   int i;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return;

   pthread_mutex_lock(&lock_info->lock);

   for (i = 0; i < lock_info->num_locks; i++) {
      if (lock_info->locks[i].lock_addr == lock_addr) {
         lock_info->locks[i].times_locked++;
#ifdef HAVE_BKTR
         lock_info->locks[i].backtrace = bt;
#endif
         pthread_mutex_unlock(&lock_info->lock);
         return;
      }
   }

   if (lock_info->num_locks == AST_MAX_LOCKS) {
      /* Can't use ast_log here, because it will cause infinite recursion */
      fprintf(stderr, "XXX ERROR XXX A thread holds more locks than '%d'."
         "  Increase AST_MAX_LOCKS!\n", AST_MAX_LOCKS);
      pthread_mutex_unlock(&lock_info->lock);
      return;
   }

   if (i && lock_info->locks[i - 1].pending == -1) {
      /* The last lock on the list was one that this thread tried to lock but
       * failed at doing so.  It has now moved on to something else, so remove
       * the old lock from the list. */
      i--;
      lock_info->num_locks--;
      memset(&lock_info->locks[i], 0, sizeof(lock_info->locks[0]));
   }

   lock_info->locks[i].file = filename;
   lock_info->locks[i].line_num = line_num;
   lock_info->locks[i].func = func;
   lock_info->locks[i].lock_name = lock_name;
   lock_info->locks[i].lock_addr = lock_addr;
   lock_info->locks[i].times_locked = 1;
   lock_info->locks[i].type = type;
   lock_info->locks[i].pending = 1;
#ifdef HAVE_BKTR
   lock_info->locks[i].backtrace = bt;
#endif
   lock_info->num_locks++;

   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_str_to_eid()

int ast_str_to_eid	(	struct ast_eid *	eid,
		const char *	s
	)

Convert a string into an EID.

This function expects an EID in the format: 00:11:22:33:44:55

Returns

0 success, non-zero failure

Since

1.6.1

Definition at line 2825 of file main/utils.c.

References ast_eid::eid.

Referenced by asterisk_publication_devicestate_state_change(), asterisk_publication_mwi_state_change(), build_peer(), dundi_do_query(), load_asterisk_conf(), set_config(), and xmpp_pubsub_handle_event().

{
   unsigned int eid_int[6];
   int x;

   if (sscanf(s, "%2x:%2x:%2x:%2x:%2x:%2x", &eid_int[0], &eid_int[1], &eid_int[2],
       &eid_int[3], &eid_int[4], &eid_int[5]) != 6) {
         return -1;
   }

   for (x = 0; x < 6; x++) {
      eid->eid[x] = eid_int[x];
   }

   return 0;
}

ast_strip_quoted()

char* ast_strip_quoted	(	char *	s,
		const char *	beg_quotes,
		const char *	end_quotes
	)

Strip leading/trailing whitespace and quotes from a string.

Parameters

s	The string to be stripped (will be modified).
beg_quotes	The list of possible beginning quote characters.
end_quotes	The list of matching ending quote characters.

Returns

The stripped string.

This functions strips all leading and trailing whitespace characters from the input string, and returns a pointer to the resulting string. The string is modified in place.

It can also remove beginning and ending quote (or quote-like) characters, in matching pairs. If the first character of the string matches any character in beg_quotes, and the last character of the string is the matching character in end_quotes, then they are removed from the string.

Examples:

ast_strip_quoted(buf, "\"", "\"");
ast_strip_quoted(buf, "'", "'");
ast_strip_quoted(buf, "[{(", "]})");

Definition at line 1639 of file main/utils.c.

References ast_strip().

Referenced by applicationmap_handler(), ast_callerid_parse(), ast_sip_validate_uri_length(), ast_strsep(), dialog_info_generate_body_content(), get_rdnis(), hfp_parse_clip(), iftime(), load_values_config(), parse_allowed_methods(), parse_cookies(), parse_dial_string(), pidf_allocate_body(), set_redirecting_reason(), sip_parse_register_line(), and xpidf_allocate_body().

{
   char *e;
   char *q;

   s = ast_strip(s);
   if ((q = strchr(beg_quotes, *s)) && *q != '\0') {
      e = s + strlen(s) - 1;
      if (*e == *(end_quotes + (q - beg_quotes))) {
         s++;
         *e = '\0';
      }
   }

   return s;
}

ast_strsep()

char* ast_strsep	(	char **	s,
		const char	sep,
		uint32_t	flags
	)

Act like strsep but ignore separators inside quotes.

Parameters

s	Pointer to address of the string to be processed. Will be modified and can't be constant.
sep	A single character delimiter.
flags	Controls post-processing of the result. AST_STRSEP_TRIM trims all leading and trailing whitespace from the result. AST_STRSEP_STRIP does a trim then strips the outermost quotes. You may want to trim again after the strip. Just OR both the TRIM and STRIP flags. AST_STRSEP_UNESCAPE unescapes '\' sequences. AST_STRSEP_ALL does all of the above processing.

Returns

The next token or NULL if done or if there are more than 8 levels of nested quotes.

This function acts like strsep with three exceptions... The separator is a single character instead of a string. Separators inside quotes are treated literally instead of like separators. You can elect to have leading and trailing whitespace and quotes stripped from the result and have '\' sequences unescaped.

Like strsep, ast_strsep maintains no internal state and you can call it recursively using different separators on the same storage.

Also like strsep, for consistent results, consecutive separators are not collapsed so you may get an empty string as a valid result.

Examples:

char *mystr = ast_strdupa("abc=def,ghi='zzz=yyy,456',jkl");
char *token, *token2, *token3;

while((token = ast_strsep(&mystr, ',', AST_SEP_STRIP))) {
  // 1st token will be aaa=def
  // 2nd token will be ghi='zzz=yyy,456'
  while((token2 = ast_strsep(&token, '=', AST_SEP_STRIP))) {
     // 1st token2 will be ghi
     // 2nd token2 will be zzz=yyy,456
     while((token3 = ast_strsep(&token2, ',', AST_SEP_STRIP))) {
        // 1st token3 will be zzz=yyy
        // 2nd token3 will be 456
        // and so on
     }
  }
  // 3rd token will be jkl
}

Definition at line 1656 of file main/utils.c.

References ast_strip(), ast_strip_quoted(), ast_strlen_zero, AST_STRSEP_STRIP, AST_STRSEP_TRIM, AST_STRSEP_UNESCAPE, ast_unescape_quoted(), and NULL.

Referenced by AST_TEST_DEFINE(), does_category_match(), handle_updates(), originate_exec(), test_xml_entry(), and wizard_apply_handler().

{
   char *st = *iss;
   char *is;
   int inquote = 0;
   int found = 0;
   char stack[8];

   if (ast_strlen_zero(st)) {
      return NULL;
   }

   memset(stack, 0, sizeof(stack));

   for(is = st; *is; is++) {
      if (*is == '\\') {
         if (*++is != '\0') {
            is++;
         } else {
            break;
         }
      }

      if (*is == '\'' || *is == '"') {
         if (*is == stack[inquote]) {
            stack[inquote--] = '\0';
         } else {
            if (++inquote >= sizeof(stack)) {
               return NULL;
            }
            stack[inquote] = *is;
         }
      }

      if (*is == sep && !inquote) {
         *is = '\0';
         found = 1;
         *iss = is + 1;
         break;
      }
   }
   if (!found) {
      *iss = NULL;
   }

   if (flags & AST_STRSEP_STRIP) {
      st = ast_strip_quoted(st, "'\"", "'\"");
   }

   if (flags & AST_STRSEP_TRIM) {
      st = ast_strip(st);
   }

   if (flags & AST_STRSEP_UNESCAPE) {
      ast_unescape_quoted(st);
   }

   return st;
}

ast_suspend_lock_info()

void ast_suspend_lock_info

(

void *

lock_addr

)

Definition at line 1030 of file main/utils.c.

References ast_threadstorage_get(), thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, thr_lock_info::locks, thr_lock_info::num_locks, pthread_mutex_lock, pthread_mutex_unlock, thr_lock_info::suspended, and thread_lock_info.

{
#if !defined(LOW_MEMORY)
   struct thr_lock_info *lock_info;
   int i = 0;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info)))) {
      return;
   }

   pthread_mutex_lock(&lock_info->lock);

   for (i = lock_info->num_locks - 1; i >= 0; i--) {
      if (lock_info->locks[i].lock_addr == lock_addr)
         break;
   }

   if (i == -1) {
      /* Lock not found :( */
      pthread_mutex_unlock(&lock_info->lock);
      return;
   }

   lock_info->locks[i].suspended = 1;

   pthread_mutex_unlock(&lock_info->lock);
#endif /* ! LOW_MEMORY */
}

ast_thread_is_user_interface()

int ast_thread_is_user_interface

(

void

)

Indicates whether the current thread is a user interface.

Returns

True (non-zero) if thread is a user interface.

False (zero) if thread is not a user interface.

Definition at line 2996 of file main/utils.c.

References ast_log, ast_threadstorage_get(), LOG_ERROR, NULL, and thread_user_interface_tl.

Referenced by ast_autoservice_start(), and ast_autoservice_stop().

{
   int *thread_user_interface;

   thread_user_interface = ast_threadstorage_get(
      &thread_user_interface_tl, sizeof(*thread_user_interface));
   if (thread_user_interface == NULL) {
      ast_log(LOG_ERROR, "Error checking thread's user interface status\n");
      /* On error, assume that we are not a user interface thread */
      return 0;
   }

   return *thread_user_interface;
}

ast_thread_user_interface_set()

int ast_thread_user_interface_set

(

int

is_user_interface

)

Set the current thread's user interface status.

Parameters

is_user_interface

Non-zero to mark the thread as a user interface.

Returns

0 if successfuly marked current thread.

Non-zero if marking current thread failed.

Definition at line 2981 of file main/utils.c.

References ast_log, ast_threadstorage_get(), LOG_ERROR, NULL, and thread_user_interface_tl.

Referenced by handle_tcptls_connection().

{
   int *thread_user_interface;

   thread_user_interface = ast_threadstorage_get(
      &thread_user_interface_tl, sizeof(*thread_user_interface));
   if (thread_user_interface == NULL) {
      ast_log(LOG_ERROR, "Error setting user interface status for current thread\n");
      return -1;
   }

   *thread_user_interface = !!is_user_interface;
   return 0;
}

ast_to_camel_case_delim()

char* ast_to_camel_case_delim	(	const char *	s,
		const char *	delim
	)

Definition at line 2149 of file main/utils.c.

References ast_copy_string(), ast_strdup, and NULL.

{
   char *res = ast_strdup(s);
   char *front, *back, *buf = res;
   int size;

   front = strtok_r(buf, delim, &back);

   while (front) {
      size = strlen(front);
      *front = toupper(*front);
      ast_copy_string(buf, front, size + 1);
      buf += size;
      front = strtok_r(NULL, delim, &back);
   }

   return res;
}

ast_true()

int ast_true

(

const char *

val

)

Make sure something is true. Determine if a string containing a boolean value is "true". This function checks to see whether a string passed to it is an indication of an "true" value. It checks to see if the string is "yes", "true", "y", "t", "on" or "1".

Return values

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

Definition at line 1951 of file main/utils.c.

References ast_strlen_zero.

Referenced by __ast_http_load(), __init_manager(), _parse(), acf_curlopt_write(), acf_faxopt_write(), acf_transaction_write(), action_agent_logoff(), action_originate(), action_status(), action_updateconfig(), actual_load_config(), agent_login_channel_config(), announce_user_count_all_handler(), aoc_cli_debug_enable(), apply_general_options(), apply_option(), ast_ari_bridges_add_channel_cb(), ast_ari_bridges_record_cb(), ast_ari_channels_record_cb(), ast_ari_events_event_websocket_ws_attempted_cb(), ast_ari_events_event_websocket_ws_established_cb(), ast_bridge_timelimit(), ast_jb_read_conf(), ast_rtp_dtls_cfg_parse(), AST_TEST_DEFINE(), ast_tls_read_conf(), autopause2int(), bool_handler_fn(), boolflag_handler_fn(), build_calendar(), build_device(), build_gateway(), build_peer(), build_user(), cdr_prop_write_callback(), check_debug(), client_bitfield_handler(), config_parse_variables(), custom_bitfield_handler(), customopt_handler(), dahdi_cc_callback(), dahdi_set_dnd(), destroy_all_channels(), do_reload(), encoding_format_handler(), festival_exec(), func_channel_write_real(), func_mute_write(), function_ooh323_write(), get_encrypt_methods(), global_bitfield_handler(), handle_clear_alarms(), handle_common_options(), handle_logger_set_level(), handle_queue_set_member_ringinuse(), handle_t38_options(), hook_write(), init_logger_chain(), internal_feature_write(), is_variable_true(), load_asterisk_conf(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), loader_config_init(), manager_add_queue_member(), manager_dialplan_extension_add(), manager_mute_mixmonitor(), manager_mutestream(), manager_pause_queue_member(), manager_play_dtmf(), manager_queue_member_ringinuse(), mbl_load_adapter(), mbl_load_device(), message_template_build(), misdn_answer(), moh_parse_options(), my_load_module(), new_realtime_sqlite3_db(), odbc_load_module(), osp_load(), osplookup_exec(), parse_config(), parse_empty_options(), parse_line(), parse_playtone(), pbx_builtin_saycharacters(), pbx_builtin_saycharacters_case(), pbx_builtin_saydigits(), pbx_builtin_saymoney(), pbx_builtin_saynumber(), pbx_builtin_sayphonetic(), pbx_load_config(), pbx_load_users(), pjsip_acf_moh_passthrough_write(), pjsip_set_logger_verbose(), prack_handler(), process_dahdi(), process_echocancel(), process_my_load_module(), profile_set_param(), queue_rules_set_global_params(), queue_set_global_params(), queue_set_param(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_module(), reload_single_member(), rt_handle_member_record(), rtp_reload(), run_agi(), run_startup_commands(), sayunixtime_exec(), search_directory(), search_directory_sub(), set_active(), set_config(), sla_load_config(), smdi_load(), sorcery_config_open(), sorcery_memory_cache_ami_stale_object(), sorcery_memory_cache_open(), speex_write(), stackpeek_read(), start_monitor_action(), strings_to_mask(), tds_load_module(), timers_handler(), transport_tls_bool_handler(), xfer_set(), xmldoc_get_syntax_cmd(), xmldoc_get_syntax_config_object(), xmldoc_get_syntax_fun(), and xmldoc_get_syntax_manager().

{
   if (ast_strlen_zero(s))
      return 0;

   /* Determine if this is a true value */
   if (!strcasecmp(s, "yes") ||
       !strcasecmp(s, "true") ||
       !strcasecmp(s, "y") ||
       !strcasecmp(s, "t") ||
       !strcasecmp(s, "1") ||
       !strcasecmp(s, "on"))
      return -1;

   return 0;
}

ast_tvadd()

struct timeval ast_tvadd	(	struct timeval	a,
		struct timeval	b
	)

Returns the sum of two timevals a + b.

Definition at line 2005 of file main/utils.c.

References a, b, ONE_MILLION, and tvfix().

{
   /* consistency checks to guarantee usec in 0..999999 */
   a = tvfix(a);
   b = tvfix(b);
   a.tv_sec += b.tv_sec;
   a.tv_usec += b.tv_usec;
   if (a.tv_usec >= ONE_MILLION) {
      a.tv_sec++;
      a.tv_usec -= ONE_MILLION;
   }
   return a;
}

ast_tvsub()

struct timeval ast_tvsub	(	struct timeval	a,
		struct timeval	b
	)

Returns the difference of two timevals a - b.

Definition at line 2019 of file main/utils.c.

References a, b, ONE_MILLION, and tvfix().

{
   /* consistency checks to guarantee usec in 0..999999 */
   a = tvfix(a);
   b = tvfix(b);
   a.tv_sec -= b.tv_sec;
   a.tv_usec -= b.tv_usec;
   if (a.tv_usec < 0) {
      a.tv_sec-- ;
      a.tv_usec += ONE_MILLION;
   }
   return a;
}

ast_unescape_c()

char* ast_unescape_c

(

char *

s

)

Convert some C escape sequences.

(\b\f\n\r\t) 

into the equivalent characters. The string to be converted (will be modified).

Returns

The converted string.

Definition at line 1735 of file main/utils.c.

References c, and NULL.

Referenced by ast_parse_digest().

{
   char c, *ret, *dst;

   if (src == NULL)
      return NULL;
   for (ret = dst = src; (c = *src++); *dst++ = c ) {
      if (c != '\\')
         continue;   /* copy char at the end of the loop */
      switch ((c = *src++)) {
      case '\0':  /* special, trailing '\' */
         c = '\\';
         break;
      case 'b':   /* backspace */
         c = '\b';
         break;
      case 'f':   /* form feed */
         c = '\f';
         break;
      case 'n':
         c = '\n';
         break;
      case 'r':
         c = '\r';
         break;
      case 't':
         c = '\t';
         break;
      }
      /* default, use the char literally */
   }
   *dst = '\0';
   return ret;
}

ast_unescape_quoted()

void ast_unescape_quoted

(

char *

quote_str

)

Unescape quotes in a string.

Parameters

quote_str

The string with quotes to be unescaped

Note

This function mutates the passed-in string.

Definition at line 696 of file main/utils.c.

Referenced by ast_callerid_parse(), ast_strsep(), and AST_TEST_DEFINE().

{
   int esc_pos;
   int unesc_pos;
   int quote_str_len = strlen(quote_str);

   for (esc_pos = 0, unesc_pos = 0;
      esc_pos < quote_str_len;
      esc_pos++, unesc_pos++) {
      if (quote_str[esc_pos] == '\\') {
         /* at least one more char and current is \\ */
         esc_pos++;
         if (esc_pos >= quote_str_len) {
            break;
         }
      }

      quote_str[unesc_pos] = quote_str[esc_pos];
   }
   quote_str[unesc_pos] = '\0';
}

ast_unescape_semicolon()

char* ast_unescape_semicolon

(

char *

s

)

Strip backslash for "escaped" semicolons, the string to be stripped (will be modified).

Returns

The stripped string.

Definition at line 1716 of file main/utils.c.

Referenced by sip_cli_notify().

{
   char *e;
   char *work = s;

   while ((e = strchr(work, ';'))) {
      if ((e > work) && (*(e-1) == '\\')) {
         memmove(e - 1, e, strlen(e) + 1);
         work = e;
      } else {
         work = e + 1;
      }
   }

   return s;
}

ast_uri_decode()

void ast_uri_decode	(	char *	s,
		struct ast_flags	spec
	)

Decode URI, URN, URL (overwrite string)

Note

The ast_uri_http_legacy decode spec flag will cause this function to decode '+' as ' '.

Parameters

s	string to be decoded
spec	flags describing how the decoding should be performed

Definition at line 616 of file main/utils.c.

References ast_test_flag, AST_URI_LEGACY_SPACE, and tmp().

Referenced by acf_curl_helper(), ast_ari_invoke(), ast_http_get_post_vars(), AST_TEST_DEFINE(), config_curl(), get_destination(), get_name_and_number(), get_refer_info(), handle_request_invite(), handle_uri(), parse_moved_contact(), realtime_curl(), realtime_multi_curl(), sip_new(), sip_uri_cmp(), and uridecode().

{
   char *o;
   unsigned int tmp;

   for (o = s; *s; s++, o++) {
      if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *s == '+') {
         /* legacy mode, decode '+' as space */
         *o = ' ';
      } else if (*s == '%' && s[1] != '\0' && s[2] != '\0' && sscanf(s + 1, "%2x", &tmp) == 1) {
         /* have '%', two chars and correct parsing */
         *o = tmp;
         s += 2;  /* Will be incremented once more when we break out */
      } else /* all other cases, just copy */
         *o = *s;
   }
   *o = '\0';
}

ast_uri_encode()

char* ast_uri_encode	(	const char *	string,
		char *	outbuf,
		int	buflen,
		struct ast_flags	spec
	)

Turn text string to URI-encoded XX version.

This function encodes characters according to the rules presented in RFC 2396 and/or RFC 3261 section 19.1.2 and section 25.1.

Outbuf needs to have more memory allocated than the instring to have room for the expansion. Every byte that is converted is replaced by three ASCII characters.

Parameters

string	string to be converted
outbuf	resulting encoded string
buflen	size of output buffer
spec	flags describing how the encoding should be performed

Returns

a pointer to the uri encoded string

Definition at line 577 of file main/utils.c.

References ast_test_flag, AST_URI_ALPHANUM, AST_URI_LEGACY_SPACE, AST_URI_MARK, AST_URI_SIP_USER_UNRESERVED, out, and string.

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

{
   const char *ptr  = string; /* Start with the string */
   char *out = outbuf;
   const char *mark = "-_.!~*'()"; /* no encode set, RFC 2396 section 2.3, RFC 3261 sec 25 */
   const char *user_unreserved = "&=+$,;?/"; /* user-unreserved set, RFC 3261 sec 25 */

   while (*ptr && out - outbuf < buflen - 1) {
      if (ast_test_flag(&spec, AST_URI_LEGACY_SPACE) && *ptr == ' ') {
         /* for legacy encoding, encode spaces as '+' */
         *out = '+';
         out++;
      } else if (!(ast_test_flag(&spec, AST_URI_MARK)
            && strchr(mark, *ptr))
         && !(ast_test_flag(&spec, AST_URI_ALPHANUM)
            && ((*ptr >= '0' && *ptr <= '9')
            || (*ptr >= 'A' && *ptr <= 'Z')
            || (*ptr >= 'a' && *ptr <= 'z')))
         && !(ast_test_flag(&spec, AST_URI_SIP_USER_UNRESERVED)
            && strchr(user_unreserved, *ptr))) {

         if (out - outbuf >= buflen - 3) {
            break;
         }
         out += sprintf(out, "%%%02hhX", (unsigned char) *ptr);
      } else {
         *out = *ptr;   /* Continue copying the string */
         out++;
      }
      ptr++;
   }

   if (buflen) {
      *out = '\0';
   }

   return outbuf;
}

ast_utils_init()

int ast_utils_init

(

void

)

Definition at line 2369 of file main/utils.c.

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

Referenced by asterisk_daemon().

{
   dev_urandom_fd = open("/dev/urandom", O_RDONLY);
   base64_init();
#ifdef DEBUG_THREADS
#if !defined(LOW_MEMORY)
   ast_cli_register_multiple(utils_cli, ARRAY_LEN(utils_cli));
#endif
#endif
   ast_register_cleanup(utils_shutdown);
   return 0;
}

ast_utils_which()

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

Resolve a binary to a full pathname.

Parameters

binary	Name of the executable to resolve
fullpath	Buffer to hold the complete pathname
fullpath_size	Size of fullpath

Return values

NULL	binary was not found or the environment variable PATH is not set

Returns

fullpath

Definition at line 2522 of file main/utils.c.

References ast_strdupa, NULL, and strsep().

{
   const char *envPATH = getenv("PATH");
   char *tpath, *path;
   struct stat unused;
   if (!envPATH) {
      return NULL;
   }
   tpath = ast_strdupa(envPATH);
   while ((path = strsep(&tpath, ":"))) {
      snprintf(fullpath, fullpath_size, "%s/%s", path, binary);
      if (!stat(fullpath, &unused)) {
         return fullpath;
      }
   }
   return NULL;
}

ast_wait_for_input()

int ast_wait_for_input	(	int	fd,
		int	ms
	)

Definition at line 1519 of file main/utils.c.

References ast_poll.

Referenced by action_waitevent(), ast_ari_websocket_session_read(), ast_iostream_wait_for_input(), ast_iostream_write(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), iostream_read(), moh_class_destructor(), sip_tcptls_read(), sip_websocket_callback(), and unbound_resolver_thread().

{
   struct pollfd pfd[1];

   memset(pfd, 0, sizeof(pfd));
   pfd[0].fd = fd;
   pfd[0].events = POLLIN | POLLPRI;
   return ast_poll(pfd, 1, ms);
}

ast_wait_for_output()

int ast_wait_for_output	(	int	fd,
		int	ms
	)

Definition at line 1529 of file main/utils.c.

References ast_poll.

Referenced by ast_iostream_write(), and iostream_read().

{
   struct pollfd pfd[1];

   memset(pfd, 0, sizeof(pfd));
   pfd[0].fd = fd;
   pfd[0].events = POLLOUT;
   return ast_poll(pfd, 1, ms);
}

ast_xml_escape()

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

Escape reserved characters for use in XML.

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

Parameters

string	String to be converted
outbuf	Resulting encoded string
buflen	Size of output buffer

Returns

0 for success

-1 if buflen is too short.

Definition at line 718 of file main/utils.c.

References ast_assert, end, entity, len(), NULL, and string.

Referenced by ast_http_create_response(), state_notify_build_xml(), and test_xml().

{
   char *dst = outbuf;
   char *end = outbuf + buflen - 1; /* save one for the null terminator */

   /* Handle the case for the empty output buffer */
   if (buflen == 0) {
      return -1;
   }

   /* Escaping rules from http://www.w3.org/TR/REC-xml/#syntax */
   /* This also prevents partial entities at the end of a string */
   while (*string && dst < end) {
      const char *entity = NULL;
      int len = 0;

      switch (*string) {
      case '<':
         entity = "&lt;";
         len = 4;
         break;
      case '&':
         entity = "&amp;";
         len = 5;
         break;
      case '>':
         /* necessary if ]]> is in the string; easier to escape them all */
         entity = "&gt;";
         len = 4;
         break;
      case '\'':
         /* necessary in single-quoted strings; easier to escape them all */
         entity = "&apos;";
         len = 6;
         break;
      case '"':
         /* necessary in double-quoted strings; easier to escape them all */
         entity = "&quot;";
         len = 6;
         break;
      default:
         *dst++ = *string++;
         break;
      }

      if (entity) {
         ast_assert(len == strlen(entity));
         if (end - dst < len) {
            /* no room for the entity; stop */
            break;
         }
         /* just checked for length; strcpy is fine */
         strcpy(dst, entity);
         dst += len;
         ++string;
      }
   }
   /* Write null terminator */
   *dst = '\0';
   /* If any chars are left in string, return failure */
   return *string == '\0' ? 0 : -1;
}

base64_init()

static void base64_init ( void  )

static

Definition at line 538 of file main/utils.c.

References b2a, b2a_url, base64, and base64url.

Referenced by ast_utils_init().

{
   int x;
   memset(b2a, -1, sizeof(b2a));
   memset(b2a_url, -1, sizeof(b2a_url));
   /* Initialize base-64 Conversion table */
   for (x = 0; x < 26; x++) {
      /* A-Z */
      base64[x] = 'A' + x;
      base64url[x] = 'A' + x;
      b2a['A' + x] = x;
      b2a_url['A' + x] = x;
      /* a-z */
      base64[x + 26] = 'a' + x;
      base64url[x + 26] = 'a' + x;
      b2a['a' + x] = x + 26;
      b2a_url['a' + x] = x + 26;
      /* 0-9 */
      if (x < 10) {
         base64[x + 52] = '0' + x;
         base64url[x + 52] = '0' + x;
         b2a['0' + x] = x + 52;
         b2a_url['0' + x] = x + 52;
      }
   }
   base64[62] = '+';
   base64[63] = '/';
   base64url[62] = '-';
   base64url[63] = '_';
   b2a[(int)'+'] = 62;
   b2a[(int)'/'] = 63;
   b2a_url[(int)'-'] = 62;
   b2a_url[(int)'_'] = 63;
}

dummy_start()

static void* dummy_start ( void *  data )

static

Definition at line 1394 of file main/utils.c.

References ast_free, ast_get_tid(), AST_LIST_INSERT_TAIL, AST_MUTEX_KIND, ast_register_thread(), ast_strdup, ast_threadstorage_get(), ast_unregister_thread(), thr_arg::data, thr_lock_info::lock, lock_info, lock_infos_lock, thr_lock_info::lwp, ast_mutex_info::mutex, thr_arg::name, NULL, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, thr_arg::start_routine, thr_lock_info::thread_id, thread_lock_info, and thr_lock_info::thread_name.

Referenced by ast_pthread_create_stack().

{
   void *ret;
   struct thr_arg a = *((struct thr_arg *) data);  /* make a local copy */
#ifdef DEBUG_THREADS
   struct thr_lock_info *lock_info;
   pthread_mutexattr_t mutex_attr;

   if (!(lock_info = ast_threadstorage_get(&thread_lock_info, sizeof(*lock_info))))
      return NULL;

   lock_info->thread_id = pthread_self();
   lock_info->lwp = ast_get_tid();
   lock_info->thread_name = ast_strdup(a.name);

   pthread_mutexattr_init(&mutex_attr);
   pthread_mutexattr_settype(&mutex_attr, AST_MUTEX_KIND);
   pthread_mutex_init(&lock_info->lock, &mutex_attr);
   pthread_mutexattr_destroy(&mutex_attr);

   pthread_mutex_lock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
   AST_LIST_INSERT_TAIL(&lock_infos, lock_info, entry);
   pthread_mutex_unlock(&lock_infos_lock.mutex); /* Intentionally not the wrapper */
#endif /* DEBUG_THREADS */

   /* note that even though data->name is a pointer to allocated memory,
      we are not freeing it here because ast_register_thread is going to
      keep a copy of the pointer and then ast_unregister_thread will
      free the memory
   */
   ast_free(data);
   ast_register_thread(a.name);
   pthread_cleanup_push(ast_unregister_thread, (void *) pthread_self());

   ret = a.start_routine(a.data);

   pthread_cleanup_pop(1);

   return ret;
}

escape_alloc()

static char* escape_alloc ( const char *  s, size_t *  size  )

static

Definition at line 1870 of file main/utils.c.

References ast_malloc, and NULL.

Referenced by ast_escape_alloc(), and ast_escape_c_alloc().

{
   if (!s) {
      return NULL;
   }

   /*
    * The result string needs to be twice the size of the given
    * string just in case every character in it needs to be escaped.
    */
   *size = strlen(s) * 2 + 1;
   return ast_malloc(*size);
}

handle_show_locks()

static char* handle_show_locks ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1339 of file main/utils.c.

References ast_cli(), ast_cli_allow_at_shutdown(), ast_dump_locks(), ast_free, ast_str_buffer(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, str, and ast_cli_entry::usage.

{
   struct ast_str *str;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show locks";
      e->usage =
         "Usage: core show locks\n"
         "       This command is for lock debugging.  It prints out which locks\n"
         "are owned by each active thread.\n";
      ast_cli_allow_at_shutdown(e);
      return NULL;

   case CLI_GENERATE:
      return NULL;
   }

   str = ast_dump_locks();
   if (!str) {
      return CLI_FAILURE;
   }

   ast_cli(a->fd, "%s", ast_str_buffer(str));

   ast_free(str);

   return CLI_SUCCESS;
}

lock_info_destroy()

static void lock_info_destroy ( void *  data )

static

Destroy a thread's lock info.

This gets called automatically when the thread stops

Definition at line 864 of file main/utils.c.

References ast_free, AST_LIST_REMOVE, ast_log, thr_lock_info::file, thr_lock_info::func, thr_lock_info::line_num, thr_lock_info::lock, thr_lock_info::lock_addr, lock_info, lock_infos_lock, thr_lock_info::lock_name, thr_lock_info::locks, LOG_ERROR, ast_mutex_info::mutex, thr_lock_info::num_locks, thr_lock_info::pending, pthread_mutex_destroy, pthread_mutex_lock, pthread_mutex_unlock, and thr_lock_info::thread_name.

{
   struct thr_lock_info *lock_info = data;
   int i;

   pthread_mutex_lock(&lock_infos_lock.mutex);
   AST_LIST_REMOVE(&lock_infos, lock_info, entry);
   pthread_mutex_unlock(&lock_infos_lock.mutex);


   for (i = 0; i < lock_info->num_locks; i++) {
      if (lock_info->locks[i].pending == -1) {
         /* This just means that the last lock this thread went for was by
          * using trylock, and it failed.  This is fine. */
         break;
      }

      ast_log(LOG_ERROR,
         "Thread '%s' still has a lock! - '%s' (%p) from '%s' in %s:%d!\n",
         lock_info->thread_name,
         lock_info->locks[i].lock_name,
         lock_info->locks[i].lock_addr,
         lock_info->locks[i].func,
         lock_info->locks[i].file,
         lock_info->locks[i].line_num
      );
   }

   pthread_mutex_destroy(&lock_info->lock);
   if (lock_info->thread_name) {
      ast_free((void *) lock_info->thread_name);
   }
   ast_free(lock_info);
}

locktype2str()

static const char* locktype2str ( enum ast_lock_type  type )

static

Definition at line 1132 of file main/utils.c.

References AST_MUTEX, AST_RDLOCK, and AST_WRLOCK.

Referenced by append_lock_information().

{
   switch (type) {
   case AST_MUTEX:
      return "MUTEX";
   case AST_RDLOCK:
      return "RDLOCK";
   case AST_WRLOCK:
      return "WRLOCK";
   }

   return "UNKNOWN";
}

safe_mkdir()

static int safe_mkdir ( const char *  base_path, char *  path, int  mode  )

static

Definition at line 2266 of file main/utils.c.

References ast_assert, ast_begins_with(), ast_std_free(), c, errno, NULL, and RAII_VAR.

Referenced by ast_safe_mkdir().

{
   RAII_VAR(char *, absolute_path, NULL, ast_std_free);

   absolute_path = realpath(path, NULL);

   if (absolute_path) {
      /* Path exists, but is it in the right place? */
      if (!ast_begins_with(absolute_path, base_path)) {
         return EPERM;
      }

      /* It is in the right place! */
      return 0;
   } else {
      /* Path doesn't exist. */

      /* The slash terminating the subpath we're checking */
      char *path_term = strchr(path, '/');
      /* True indicates the parent path is within base_path */
      int parent_is_safe = 0;
      int res;

      while (path_term) {
         RAII_VAR(char *, absolute_subpath, NULL, ast_std_free);

         /* Truncate the path one past the slash */
         char c = *(path_term + 1);
         *(path_term + 1) = '\0';
         absolute_subpath = realpath(path, NULL);

         if (absolute_subpath) {
            /* Subpath exists, but is it safe? */
            parent_is_safe = ast_begins_with(
               absolute_subpath, base_path);
         } else if (parent_is_safe) {
            /* Subpath does not exist, but parent is safe
             * Create it */
            res = mkdir(path, mode);
            if (res != 0) {
               ast_assert(errno != EEXIST);
               return errno;
            }
         } else {
            /* Subpath did not exist, parent was not safe
             * Fail! */
            errno = EPERM;
            return errno;
         }
         /* Restore the path */
         *(path_term + 1) = c;
         /* Move on to the next slash */
         path_term = strchr(path_term + 1, '/');
      }

      /* Now to build the final path, but only if it's safe */
      if (!parent_is_safe) {
         errno = EPERM;
         return errno;
      }

      res = mkdir(path, mode);
      if (res != 0 && errno != EEXIST) {
         return errno;
      }

      return 0;
   }
}

tvfix()

static struct timeval tvfix ( struct timeval  a )

static

Definition at line 1990 of file main/utils.c.

References a, ast_log, LOG_WARNING, and ONE_MILLION.

Referenced by ast_tvadd(), and ast_tvsub().

{
   if (a.tv_usec >= ONE_MILLION) {
      ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
         (long)a.tv_sec, (long int) a.tv_usec);
      a.tv_sec += a.tv_usec / ONE_MILLION;
      a.tv_usec %= ONE_MILLION;
   } else if (a.tv_usec < 0) {
      ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
         (long)a.tv_sec, (long int) a.tv_usec);
      a.tv_usec = 0;
   }
   return a;
}

utils_shutdown()

static void utils_shutdown ( void  )

static

Definition at line 2360 of file main/utils.c.

References ARRAY_LEN, and ast_cli_unregister_multiple().

Referenced by ast_utils_init().

{
   close(dev_urandom_fd);
   dev_urandom_fd = -1;
#if defined(DEBUG_THREADS) && !defined(LOW_MEMORY)
   ast_cli_unregister_multiple(utils_cli, ARRAY_LEN(utils_cli));
#endif
}

wait_for_output()

static int wait_for_output ( int  fd, int  timeoutms  )

static

Definition at line 1539 of file main/utils.c.

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

Referenced by ast_carefulwrite().

{
   struct pollfd pfd = {
      .fd = fd,
      .events = POLLOUT,
   };
   int res;
   struct timeval start = ast_tvnow();
   int elapsed = 0;

   /* poll() until the fd is writable without blocking */
   while ((res = ast_poll(&pfd, 1, timeoutms - elapsed)) <= 0) {
      if (res == 0) {
         /* timed out. */
#ifndef STANDALONE
         ast_debug(1, "Timed out trying to write\n");
#endif
         return -1;
      } else if (res == -1) {
         /* poll() returned an error, check to see if it was fatal */

         if (errno == EINTR || errno == EAGAIN) {
            elapsed = ast_tvdiff_ms(ast_tvnow(), start);
            if (elapsed >= timeoutms) {
               return -1;
            }
            /* This was an acceptable error, go back into poll() */
            continue;
         }

         /* Fatal error, bail. */
         ast_log(LOG_ERROR, "poll returned error: %s\n", strerror(errno));

         return -1;
      }
      elapsed = ast_tvdiff_ms(ast_tvnow(), start);
      if (elapsed >= timeoutms) {
         return -1;
      }
   }

   return 0;
}

Variable Documentation

ast_uri_http

const struct ast_flags ast_uri_http = {AST_URI_UNRESERVED}

Definition at line 573 of file main/utils.c.

Referenced by acf_curl_helper(), ast_ari_bridges_record(), ast_ari_channels_record(), AST_TEST_DEFINE(), config_curl(), destroy_curl(), launch_asyncagi(), realtime_curl(), realtime_multi_curl(), require_curl(), store_curl(), update2_curl(), update_curl(), uridecode(), and uriencode().

ast_uri_http_legacy

const struct ast_flags ast_uri_http_legacy = {AST_URI_LEGACY_SPACE | AST_URI_UNRESERVED}

Definition at line 574 of file main/utils.c.

Referenced by acf_curl_helper(), ast_ari_invoke(), ast_http_get_post_vars(), AST_TEST_DEFINE(), and handle_uri().

ast_uri_sip_user

const struct ast_flags ast_uri_sip_user = {AST_URI_UNRESERVED | AST_URI_SIP_USER_UNRESERVED}

Definition at line 575 of file main/utils.c.

Referenced by add_diversion(), add_rpid(), AST_TEST_DEFINE(), build_contact(), get_destination(), get_name_and_number(), get_refer_info(), handle_request_invite(), initreqprep(), parse_moved_contact(), sip_new(), and sip_uri_cmp().

b2a

char b2a[256]

static

Definition at line 80 of file main/utils.c.

Referenced by ast_base64decode(), and base64_init().

b2a_url

char b2a_url[256]

static

Definition at line 81 of file main/utils.c.

Referenced by ast_base64url_decode(), and base64_init().

base64

char base64[64]

static

Definition at line 78 of file main/utils.c.

Referenced by ast_base64encode_full(), ast_http_get_auth(), ast_websocket_uri_cb(), base64_init(), websocket_client_handshake_get_response(), and xmpp_client_authenticate_sasl().

base64url

char base64url[64]

static

Definition at line 79 of file main/utils.c.

Referenced by ast_base64url_encode_full(), and base64_init().

dev_urandom_fd

int dev_urandom_fd = -1

static

Definition at line 792 of file main/utils.c.

Referenced by ast_uuid_init().

escape_sequences

char escape_sequences[]

Initial value:

= {
   '\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\', '\'', '\"', '\?', '\0'
}

Definition at line 1774 of file main/utils.c.

Referenced by ast_escape(), and ast_escape_c().

escape_sequences_map

char escape_sequences_map[]

static

Initial value:

= {
   'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '"', '?', '\0'
}

Definition at line 1782 of file main/utils.c.

inet_ntoa_buf

struct ast_threadstorage inet_ntoa_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_inet_ntoa_buf , .custom_init = NULL , }

static

Definition at line 83 of file main/utils.c.

Referenced by ast_inet_ntoa().

lock_infos

struct lock_infos lock_infos = { .first = NULL, .last = NULL, }

static

lock_infos_lock

ast_mutex_t lock_infos_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Locked when accessing the lock_infos list.

Definition at line 853 of file main/utils.c.

Referenced by ast_dump_locks(), ast_log_show_lock(), dummy_start(), and lock_info_destroy().

randomlock

ast_mutex_t randomlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 2061 of file main/utils.c.

Referenced by ast_random().

thread_lock_info

struct ast_threadstorage thread_lock_info = { .once = PTHREAD_ONCE_INIT , .key_init = __init_thread_lock_info , .custom_init = NULL , }

static

Definition at line 902 of file main/utils.c.

Referenced by ast_find_lock_info(), ast_mark_lock_acquired(), ast_mark_lock_failed(), ast_remove_lock_info(), ast_restore_lock_info(), ast_store_lock_info(), ast_suspend_lock_info(), and dummy_start().

thread_user_interface_tl

struct ast_threadstorage thread_user_interface_tl = { .once = PTHREAD_ONCE_INIT , .key_init = __init_thread_user_interface_tl , .custom_init = NULL , }

static

Definition at line 2979 of file main/utils.c.

Referenced by ast_thread_is_user_interface(), and ast_thread_user_interface_set().

utils_cli

struct ast_cli_entry utils_cli[]

static

Initial value:

= {
   { .handler =  handle_show_locks , .summary =  "Show which locks are held by which thread" ,},
}

Definition at line 1369 of file main/utils.c.