utils.h File Reference

Utility functions. More...

#include "asterisk/network.h"
#include <time.h>
#include <unistd.h>
#include <string.h>
#include <endian.h>
#include "asterisk/lock.h"
#include "asterisk/logger.h"
#include "asterisk/localtime.h"
#include "asterisk/stringfields.h"
#include "asterisk/strings.h"

Include dependency graph for utils.h:

Go to the source code of this file.

Data Structures
struct	ast_eid
	An Entity ID is essentially a MAC address, brief and unique. More...
struct	ast_flags
	Structure used to handle boolean flags. More...
struct	ast_flags64
	Structure used to handle a large number of boolean flags == used only in app_dial? More...
struct	ast_hostent
struct	ast_http_digest

Macros
#define	ARRAY_IN_BOUNDS(v, a)   IN_BOUNDS((int) (v), 0, ARRAY_LEN(a) - 1)
	Checks to see if value is within the bounds of the given array.
#define	ARRAY_LEN(a)   (size_t) (sizeof(a) / sizeof(0[a]))
#define	ast_align_for(offset, type)   (((offset + __alignof__(type) - 1) / __alignof__(type)) * __alignof__(type))
	Increase offset so it is a multiple of the required alignment of type.
#define	ast_alignof(type)   __alignof__(type)
	Return the number of bytes used in the alignment of type.
#define	ast_assert(a)
#define	ast_assert_return(a, ...)
#define	AST_BACKGROUND_STACKSIZE   ast_background_stacksize()
#define	ast_clear_flag(p, flag)
#define	ast_clear_flag64(p, flag)
#define	ast_clear_flag_nonstd(p, flag)
#define	ast_copy_flags(dest, src, flagz)
#define	ast_copy_flags64(dest, src, flagz)
#define	ast_copy_flags_nonstd(dest, src, flagz)
#define	ast_fd_clear_flags(fd, flags)    __ast_fd_set_flags((fd), (flags), AST_FD_FLAG_CLEAR, __FILE__, __LINE__, __PRETTY_FUNCTION__)
	Clear flags on the given file descriptor.
#define	ast_fd_set_flags(fd, flags)    __ast_fd_set_flags((fd), (flags), AST_FD_FLAG_SET, __FILE__, __LINE__, __PRETTY_FUNCTION__)
	Set flags on the given file descriptor.
#define	AST_FLAGS64_ALL   ULONG_MAX
#define	AST_FLAGS_ALL   UINT_MAX
#define	ast_make_room_for(offset, type)   (((offset + (2 * __alignof__(type) - 1)) / __alignof__(type)) * __alignof__(type))
	Increase offset by the required alignment of type and make sure it is a multiple of said alignment.
#define	ast_pipe_nonblock(filedes)   pipe2((filedes), O_NONBLOCK)
	Create a non-blocking pipe.
#define	ast_pthread_create(a, b, c, d)
#define	ast_pthread_create_background(a, b, c, d)
#define	ast_pthread_create_detached(a, b, c, d)
#define	ast_pthread_create_detached_background(a, b, c, d)
#define	ast_random_double()   (((double)ast_random()) / RAND_MAX)
	Returns a random number between 0.0 and 1.0, inclusive.
#define	ast_set2_flag(p, value, flag)
#define	ast_set2_flag64(p, value, flag)
#define	ast_set2_flag_nonstd(p, value, flag)
#define	ast_set_flag(p, flag)
#define	ast_set_flag64(p, flag)
#define	ast_set_flag_nonstd(p, flag)
#define	ast_set_flags_to(p, flag, value)
#define	ast_set_flags_to64(p, flag, value)
#define	ast_socket_nonblock(domain, type, protocol)   socket((domain), (type) | SOCK_NONBLOCK, (protocol))
	Create a non-blocking socket.
#define	AST_STACKSIZE   (((sizeof(void *) * 8 * 8) - 16) * 1024)
#define	AST_STACKSIZE_LOW   (((sizeof(void *) * 8 * 2) - 16) * 1024)
#define	ast_test_flag(p, flag)
#define	ast_test_flag64(p, flag)
#define	ast_test_flag_nonstd(p, flag)    ((p)->flags & (flag))
#define	AST_URI_ALPHANUM   (1 << 0)
#define	AST_URI_LEGACY_SPACE   (1 << 2)
#define	AST_URI_MARK   (1 << 1)
#define	AST_URI_SIP_USER_UNRESERVED   (1 << 20)
#define	AST_URI_UNRESERVED   (AST_URI_ALPHANUM | AST_URI_MARK)
#define	DO_CRASH_NORETURN
#define	IN_BOUNDS(v, min, max)   ((v) >= (min)) && ((v) <= (max))
	Checks to see if value is within the given bounds.
#define	localtime_r   __dont_use_localtime_r_use_ast_localtime_instead__
#define	MAX(a, b)   ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a < __b) ? __b : __a);})
#define	MIN(a, b)   ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a > __b) ? __b : __a);})
#define	RAII_VAR(vartype, varname, initval, dtor)
	Declare a variable that will call a destructor function when it goes out of scope.
#define	SWAP(a, b)   do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)

Enumerations
enum	ast_fd_flag_operation { AST_FD_FLAG_SET , AST_FD_FLAG_CLEAR }

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)
int	ast_background_stacksize (void)
int	ast_base64_encode_file (FILE *inputfile, FILE *outputfile, const char *endl)
	Performs a base 64 encode algorithm on the contents of a File.
int	ast_base64_encode_file_path (const char *filename, FILE *outputfile, const char *endl)
	Performs a base 64 encode algorithm on the contents of a File.
int	ast_base64decode (unsigned char *dst, const char *src, int max)
	Decode data from base64.
char *	ast_base64decode_string (const char *src)
	Same as ast_base64decode, but does the math for you and returns a decoded string.
int	ast_base64encode (char *dst, const unsigned char *src, int srclen, int max)
	Encode data in base64.
int	ast_base64encode_full (char *dst, const unsigned char *src, int srclen, int max, int linebreaks)
	encode text to BASE64 coding
char *	ast_base64encode_string (const char *src)
	Same as ast_base64encode, but does hte math for you and returns an encoded string.
int	ast_base64url_decode (unsigned char *dst, const char *src, int max)
	Decode data from base64 URL.
char *	ast_base64url_decode_string (const char *src)
	Decode string from base64 URL.
int	ast_base64url_encode (char *dst, const unsigned char *src, int srclen, int max)
	Encode data in base64 URL.
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.
char *	ast_base64url_encode_string (const char *src)
	Encode string in base64 URL.
int	ast_careful_fwrite (FILE *f, int fd, const char *s, size_t len, int timeoutms)
	Write data to a file stream with a timeout.
int	ast_carefulwrite (int fd, char *s, int len, int timeoutms)
	Try to write string, but wait no more than ms milliseconds before timing out.
int	ast_check_command_in_path (const char *cmd)
	Test for the presence of an executable command in $PATH.
int	ast_check_ipv6 (void)
	Test that an OS supports IPv6 Networking.
int	ast_compare_versions (const char *version1, const char *version2)
	Compare 2 major.minor.patch.extra version strings.
char *	ast_crypt (const char *key, const char *salt)
	Asterisk wrapper around crypt(3).
char *	ast_crypt_encrypt (const char *key)
	Asterisk wrapper around crypt(3) for encrypting passwords.
int	ast_crypt_validate (const char *key, const char *expected)
	Asterisk wrapper around crypt(3) for validating passwords.
void DO_CRASH_NORETURN	ast_do_crash (void)
	Force a crash if DO_CRASH is defined.
int	ast_eid_cmp (const struct ast_eid *eid1, const struct ast_eid *eid2)
	Compare two EIDs.
int	ast_eid_is_empty (const struct ast_eid *eid)
	Check if EID is empty.
char *	ast_eid_to_str (char *s, int maxlen, struct ast_eid *eid)
	Convert an EID to a string.
void	ast_enable_packet_fragmentation (int sock)
	Disable PMTU discovery on a socket.
char *	ast_escape_quoted (const char *string, char *outbuf, int buflen)
	Escape characters found in a quoted string.
char *	ast_escape_semicolons (const char *string, char *outbuf, int buflen)
	Escape semicolons found in a string.
int	ast_file_is_readable (const char *filename)
	Test that a file exists and is readable by the effective user.
int	ast_get_tid (void)
	Get current thread ID.
struct hostent *	ast_gethostbyname (const char *host, struct ast_hostent *hp)
	Thread-safe gethostbyname function to use in Asterisk.
void	ast_md5_hash (char *output, const char *input)
	Produces MD5 hash based on input string.
int	ast_mkdir (const char *path, int mode)
	Recursively create directory path.
int	ast_parse_digest (const char *digest, struct ast_http_digest *d, int request, int pedantic)
	Parse digest authorization header.
char *	ast_process_quotes_and_slashes (char *start, char find, char replace_with)
	Process a string to find and replace characters.
int	ast_pthread_create_detached_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn)
int	ast_pthread_create_stack (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize, const char *file, const char *caller, int line, const char *start_fn)
long int	ast_random (void)
void	ast_register_thread (char *name)
void	ast_replace_subargument_delimiter (char *s)
	Replace '^' in a string with ','.
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.
void	ast_set_default_eid (struct ast_eid *eid)
	Fill in an ast_eid with the default eid of this machine.
void	ast_sha1_hash (char *output, const char *input)
	Produces SHA1 hash based on input string.
void	ast_sha1_hash_uint (uint8_t *digest, const char *input)
	Produces SHA1 hash based on input string, stored in uint8_t array.
static force_inline void	ast_slinear_saturated_add (short *input, short *value)
static force_inline void	ast_slinear_saturated_divide (short *input, short *value)
static force_inline void	ast_slinear_saturated_divide_float (short *input, float *value)
static force_inline void	ast_slinear_saturated_multiply (short *input, short *value)
static force_inline void	ast_slinear_saturated_multiply_float (short *input, float *value)
static force_inline void	ast_slinear_saturated_subtract (short *input, short *value)
int	ast_str_to_eid (struct ast_eid *eid, const char *s)
	Convert a string into an EID.
int	ast_thread_is_user_interface (void)
	Indicates whether the current thread is a user interface.
int	ast_thread_user_interface_set (int is_user_interface)
	Set the current thread's user interface status.
void	ast_unescape_quoted (char *quote_str)
	Unescape quotes in a string.
void	ast_unregister_thread (void *id)
void	ast_uri_decode (char *s, struct ast_flags spec)
	Decode URI, URN, URL (overwrite string)
char *	ast_uri_encode (const char *string, char *outbuf, int buflen, struct ast_flags spec)
	Turn text string to URI-encoded XX version.
int	ast_uri_verify_encoded (const char *string)
	Verify if a string is valid as a URI component.
int	ast_utils_init (void)
char *	ast_utils_which (const char *binary, char *fullpath, size_t fullpath_size)
	Resolve a binary to a full pathname.
int	ast_wait_for_input (int fd, int ms)
int	ast_wait_for_output (int fd, int ms)
int	ast_xml_escape (const char *string, char *outbuf, size_t buflen)
	Escape reserved characters for use in XML.

Variables
unsigned int	__unsigned_int_flags_dummy
uint64_t	__unsigned_int_flags_dummy64
	Swap the upper and lower 32 bits of a big-endian 64-bit integer.
struct ast_eid	ast_eid_default
	Global EID.
const struct ast_flags	ast_uri_http
const struct ast_flags	ast_uri_http_legacy
const struct ast_flags	ast_uri_sip_user

Detailed Description

Utility functions.

Definition in file utils.h.

Macro Definition Documentation

ARRAY_IN_BOUNDS

#define ARRAY_IN_BOUNDS	(		v,
			a
	)		IN_BOUNDS((int) (v), 0, ARRAY_LEN(a) - 1)

Checks to see if value is within the bounds of the given array.

Parameters

v	the value to check
a	the array to bound check

Return values

0	if value out of bounds
non-zero	otherwise

Definition at line 727 of file utils.h.

ARRAY_LEN

#define ARRAY_LEN

(

a

)

(size_t) (sizeof(a) / sizeof(0[a]))

Examples

app_skel.c.

Definition at line 706 of file utils.h.

ast_align_for

#define ast_align_for	(		offset,
			type
	)		(((offset + __alignof__(type) - 1) / __alignof__(type)) * __alignof__(type))

Increase offset so it is a multiple of the required alignment of type.

Parameters

offset	The value that should be increased.
type	The data type that offset should be aligned to.

Returns

The smallest multiple of alignof(type) larger than or equal to offset.

See also

ast_make_room_for()

Many systems prefer integers to be stored on aligned on memory locations. This macro will increase an offset so a value of the supplied type can be safely be stored on such a memory location.

Examples: ast_align_for(0x17, int64_t) ==> 0x18 ast_align_for(0x18, int64_t) ==> 0x18 ast_align_for(0x19, int64_t) ==> 0x20

Don't mind the ugliness, the compiler will optimize it.

Definition at line 825 of file utils.h.

ast_alignof

#define ast_alignof

(

type

)

__alignof__(type)

Return the number of bytes used in the alignment of type.

Parameters

type

Returns

The number of bytes required for alignment.

This is really just alignof(), but tucked away in this header so we don't have to look at the nasty underscores in the source.

Definition at line 805 of file utils.h.

ast_assert

#define ast_assert

(

a

)

Definition at line 779 of file utils.h.

ast_assert_return

#define ast_assert_return	(		a,
			...
	)

Value:

({ \
    if (__builtin_expect(!(a), 1)) { \
        return __VA_ARGS__; \
    }\
})

Definition at line 780 of file utils.h.

 { \
    if (__builtin_expect(!(a), 1)) { \
        return __VA_ARGS__; \
    }\
})

AST_BACKGROUND_STACKSIZE

#define AST_BACKGROUND_STACKSIZE   ast_background_stacksize()

Definition at line 611 of file utils.h.

ast_clear_flag

#define ast_clear_flag	(		p,
			flag
	)

Definition at line 78 of file utils.h.

                                       { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags &= ~(flag)); \
                    } while(0)

ast_clear_flag64

#define ast_clear_flag64	(		p,
			flag
	)

Definition at line 154 of file utils.h.

                                           { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags &= ~SWAP64_32(flag)); \
                    } while(0)

ast_clear_flag_nonstd

#define ast_clear_flag_nonstd	(		p,
			flag
	)

Value:

                    do { \
                    ((p)->flags &= ~(flag)); \
                    } while(0)

Definition at line 201 of file utils.h.

                                               { \
                    ((p)->flags &= ~(flag)); \
                    } while(0)

ast_copy_flags

#define ast_copy_flags	(		dest,
			src,
			flagz
	)

Definition at line 85 of file utils.h.

                                           { \
                    typeof ((dest)->flags) __d = (dest)->flags; \
                    typeof ((src)->flags) __s = (src)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__d == &__x); \
                    (void) (&__s == &__x); \
                    (dest)->flags &= ~(flagz); \
                    (dest)->flags |= ((src)->flags & (flagz)); \
                    } while (0)

ast_copy_flags64

#define ast_copy_flags64	(		dest,
			src,
			flagz
	)

Definition at line 161 of file utils.h.

                                               { \
                    typeof ((dest)->flags) __d = (dest)->flags; \
                    typeof ((src)->flags) __s = (src)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__d == &__x); \
                    (void) (&__s == &__x); \
                    (dest)->flags &= ~SWAP64_32(flagz); \
                    (dest)->flags |= ((src)->flags & SWAP64_32(flagz)); \
                    } while (0)

ast_copy_flags_nonstd

#define ast_copy_flags_nonstd	(		dest,
			src,
			flagz
	)

Value:

                    do { \
                    (dest)->flags &= ~(flagz); \
                    (dest)->flags |= ((src)->flags & (flagz)); \
                    } while (0)

Definition at line 205 of file utils.h.

                                                   { \
                    (dest)->flags &= ~(flagz); \
                    (dest)->flags |= ((src)->flags & (flagz)); \
                    } while (0)

ast_fd_clear_flags

#define ast_fd_clear_flags	(		fd,
			flags
	)		__ast_fd_set_flags((fd), (flags), AST_FD_FLAG_CLEAR, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Clear flags on the given file descriptor.

Since

13.19

If getting or setting flags of the given file descriptor fails, logs an error message.

Parameters

fd	File descriptor to clear flags on
flags	The flag(s) to clear

Return values

-1	on error
0	if successful

Definition at line 1095 of file utils.h.

ast_fd_set_flags

#define ast_fd_set_flags	(		fd,
			flags
	)		__ast_fd_set_flags((fd), (flags), AST_FD_FLAG_SET, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Set flags on the given file descriptor.

Since

13.19

If getting or setting flags of the given file descriptor fails, logs an error message.

Parameters

fd	File descriptor to set flags on
flags	The flag(s) to set

Return values

-1	on error
0	if successful

Definition at line 1079 of file utils.h.

AST_FLAGS64_ALL

#define AST_FLAGS64_ALL   ULONG_MAX

Definition at line 189 of file utils.h.

AST_FLAGS_ALL

#define AST_FLAGS_ALL   UINT_MAX

Definition at line 217 of file utils.h.

ast_make_room_for

#define ast_make_room_for	(		offset,
			type
	)		(((offset + (2 * __alignof__(type) - 1)) / __alignof__(type)) * __alignof__(type))

Increase offset by the required alignment of type and make sure it is a multiple of said alignment.

Parameters

offset	The value that should be increased.
type	The data type that room should be reserved for.

Returns

The smallest multiple of alignof(type) larger than or equal to offset plus alignof(type).

See also

ast_align_for()

A use case for this is when prepending length fields of type int to a buffer. If you keep the offset a multiple of the alignment of the integer type, a next block of length+buffer will have the length field automatically aligned.

Examples: ast_make_room_for(0x17, int64_t) ==> 0x20 ast_make_room_for(0x18, int64_t) ==> 0x20 ast_make_room_for(0x19, int64_t) ==> 0x28

Don't mind the ugliness, the compiler will optimize it.

Definition at line 848 of file utils.h.

ast_pipe_nonblock

#define ast_pipe_nonblock

(

filedes

)

pipe2((filedes), O_NONBLOCK)

Create a non-blocking pipe.

Since

13.25

Wrapper around pipe(2) that sets the O_NONBLOCK flag on the resulting file descriptors.

For parameter and return information, see the man page for pipe(2).

Definition at line 1130 of file utils.h.

ast_pthread_create

#define ast_pthread_create	(		a,
			b,
			c,
			d
	)

Value:

    ast_pthread_create_stack(a, b, c, d,            \
        0, __FILE__, __FUNCTION__, __LINE__, #c)

Definition at line 624 of file utils.h.

ast_pthread_create_background

#define ast_pthread_create_background	(		a,
			b,
			c,
			d
	)

Value:

    ast_pthread_create_stack(a, b, c, d,            \
        AST_BACKGROUND_STACKSIZE,           \
        __FILE__, __FUNCTION__, __LINE__, #c)

Definition at line 632 of file utils.h.

ast_pthread_create_detached

#define ast_pthread_create_detached	(		a,
			b,
			c,
			d
	)

Value:

    ast_pthread_create_detached_stack(a, b, c, d,       \
        0, __FILE__, __FUNCTION__, __LINE__, #c)

Definition at line 628 of file utils.h.

ast_pthread_create_detached_background

#define ast_pthread_create_detached_background	(		a,
			b,
			c,
			d
	)

Value:

    ast_pthread_create_detached_stack(a, b, c, d,       \
        AST_BACKGROUND_STACKSIZE,           \
        __FILE__, __FUNCTION__, __LINE__, #c)

Definition at line 637 of file utils.h.

ast_random_double

#define ast_random_double

(

)

(((double)ast_random()) / RAND_MAX)

Returns a random number between 0.0 and 1.0, inclusive.

Since

12

Definition at line 664 of file utils.h.

ast_set2_flag

#define ast_set2_flag	(		p,
			value,
			flag
	)

Definition at line 95 of file utils.h.

                                       { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__p == &__x); \
                    if (value) \
                        (p)->flags |= (flag); \
                    else \
                        (p)->flags &= ~(flag); \
                    } while (0)

ast_set2_flag64

#define ast_set2_flag64	(		p,
			value,
			flag
	)

Definition at line 171 of file utils.h.

                                           { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == &__x); \
                    if (value) \
                        (p)->flags |= SWAP64_32(flag); \
                    else \
                        (p)->flags &= ~SWAP64_32(flag); \
                    } while (0)

ast_set2_flag_nonstd

#define ast_set2_flag_nonstd	(		p,
			value,
			flag
	)

Definition at line 210 of file utils.h.

                                               { \
                    if (value) \
                        (p)->flags |= (flag); \
                    else \
                        (p)->flags &= ~(flag); \
                    } while (0)

ast_set_flag

#define ast_set_flag	(		p,
			flag
	)

Definition at line 71 of file utils.h.

                                       { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags |= (flag)); \
                    } while(0)

ast_set_flag64

#define ast_set_flag64	(		p,
			flag
	)

Definition at line 147 of file utils.h.

                                       { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags |= SWAP64_32(flag)); \
                    } while(0)

ast_set_flag_nonstd

#define ast_set_flag_nonstd	(		p,
			flag
	)

Value:

                    do { \
                    ((p)->flags |= (flag)); \
                    } while(0)

Definition at line 197 of file utils.h.

                                               { \
                    ((p)->flags |= (flag)); \
                    } while(0)

ast_set_flags_to

#define ast_set_flags_to	(		p,
			flag,
			value
	)

Definition at line 105 of file utils.h.

                                           { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__p == &__x); \
                    (p)->flags &= ~(flag); \
                    (p)->flags |= (value); \
                    } while (0)

ast_set_flags_to64

#define ast_set_flags_to64	(		p,
			flag,
			value
	)

Definition at line 181 of file utils.h.

                                               { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == &__x); \
                    (p)->flags &= ~SWAP64_32(flag); \
                    (p)->flags |= SWAP64_32(value); \
                    } while (0)

ast_socket_nonblock

#define ast_socket_nonblock	(		domain,
			type,
			protocol
	)		socket((domain), (type) | SOCK_NONBLOCK, (protocol))

Create a non-blocking socket.

Since

13.25

Wrapper around socket(2) that sets the O_NONBLOCK flag on the resulting socket.

For parameter and return information, see the man page for socket(2).

Definition at line 1113 of file utils.h.

AST_STACKSIZE

#define AST_STACKSIZE   (((sizeof(void *) * 8 * 8) - 16) * 1024)

Definition at line 605 of file utils.h.

AST_STACKSIZE_LOW

#define AST_STACKSIZE_LOW   (((sizeof(void *) * 8 * 2) - 16) * 1024)

Definition at line 606 of file utils.h.

ast_test_flag

#define ast_test_flag	(		p,
			flag
	)

Examples

app_skel.c.

Definition at line 64 of file utils.h.

                                     { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags & (flag)); \
                    })

ast_test_flag64

#define ast_test_flag64	(		p,
			flag
	)

Definition at line 140 of file utils.h.

                                         { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == &__x); \
                    ((p)->flags & SWAP64_32(flag)); \
                    })

ast_test_flag_nonstd

#define ast_test_flag_nonstd	(		p,
			flag
	)		((p)->flags & (flag))

Definition at line 194 of file utils.h.

AST_URI_ALPHANUM

#define AST_URI_ALPHANUM   (1 << 0)

Definition at line 385 of file utils.h.

AST_URI_LEGACY_SPACE

#define AST_URI_LEGACY_SPACE   (1 << 2)

Definition at line 388 of file utils.h.

AST_URI_MARK

#define AST_URI_MARK   (1 << 1)

Definition at line 386 of file utils.h.

AST_URI_SIP_USER_UNRESERVED

#define AST_URI_SIP_USER_UNRESERVED   (1 << 20)

Definition at line 390 of file utils.h.

AST_URI_UNRESERVED

#define AST_URI_UNRESERVED   (AST_URI_ALPHANUM | AST_URI_MARK)

Definition at line 387 of file utils.h.

DO_CRASH_NORETURN

#define DO_CRASH_NORETURN

Definition at line 757 of file utils.h.

IN_BOUNDS

#define IN_BOUNDS	(		v,
			min,
			max
	)		((v) >= (min)) && ((v) <= (max))

Checks to see if value is within the given bounds.

Parameters

v	the value to check
min	minimum lower bound (inclusive)
max	maximum upper bound (inclusive)

Return values

0	if value out of bounds
non-zero	otherwise

Definition at line 717 of file utils.h.

localtime_r

#define localtime_r   __dont_use_localtime_r_use_ast_localtime_instead__

Definition at line 561 of file utils.h.

MAX

#define MAX	(		a,
			b
	)		({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a < __b) ? __b : __a);})

Definition at line 254 of file utils.h.

MIN

#define MIN	(		a,
			b
	)		({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a > __b) ? __b : __a);})

Definition at line 252 of file utils.h.

RAII_VAR

#define RAII_VAR	(		vartype,
			varname,
			initval,
			dtor
	)

Value:

    auto void _dtor_ ## varname (vartype * v);                                 \
    void _dtor_ ## varname (vartype * v) { dtor(*v); }                         \
    vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)

Declare a variable that will call a destructor function when it goes out of scope.

Resource Allocation Is Initialization (RAII) variable declaration.

Since

11.0

Parameters

vartype	The type of the variable
varname	The name of the variable
initval	The initial value of the variable
dtor	The destructor function of type' void func(vartype *)'

void mything_cleanup(struct mything *t)
{
    if (t) {
        ast_free(t->stuff);
    }
}
 
void do_stuff(const char *name)
{
    RAII_VAR(struct mything *, thing, mything_alloc(name), mything_cleanup);
    ...
}

Note

This macro is especially useful for working with ao2 objects. A common idiom would be a function that needed to look up an ao2 object and might have several error conditions after the allocation that would normally need to unref the ao2 object. With RAII_VAR, it is possible to just return and leave the cleanup to the destructor function. For example:

void do_stuff(const char *name)
{
    RAII_VAR(struct mything *, thing, find_mything(name), ao2_cleanup);
    if (!thing) {
        return;
    }
    if (error) {
        return;
    }
    do_stuff_with_thing(thing);
}

Examples

app_skel.c.

Definition at line 981 of file utils.h.

                                         { dtor(*v); }                         \
    vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)

SWAP

#define SWAP	(		a,
			b
	)		do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)

Definition at line 256 of file utils.h.

Enumeration Type Documentation

ast_fd_flag_operation

enum ast_fd_flag_operation

Enumerator
AST_FD_FLAG_SET
AST_FD_FLAG_CLEAR

Definition at line 1061 of file utils.h.

                           {
    AST_FD_FLAG_SET,
    AST_FD_FLAG_CLEAR,
};

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

{
    /*
     * 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();
}

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

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

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

{
    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;
}

References __LOG_ERROR, ast_assert, AST_FD_FLAG_CLEAR, AST_FD_FLAG_SET, ast_log, and errno.

ast_background_stacksize()

int ast_background_stacksize

(

void

)

Definition at line 1650 of file utils.c.

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

References AST_STACKSIZE, and AST_STACKSIZE_LOW.

ast_base64_encode_file()

int ast_base64_encode_file	(	FILE *	inputfile,
		FILE *	outputfile,
		const char *	endl
	)

Performs a base 64 encode algorithm on the contents of a File.

Parameters

inputfile	A FILE handle to the input file to be encoded. Must be readable. This handle is not automatically closed.
outputfile	A FILE handle to the output file to receive the base 64 encoded contents of the input file, identified by filename.
endl	The line ending to use (e.g. either "\n" or "\r\n")

Returns

zero on success, -1 on error.

Definition at line 646 of file utils.c.

{
    static const unsigned char dtable[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
        'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
        '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
    int i, hiteof = 0;
    struct baseio bio;
 
    memset(&bio, 0, sizeof(bio));
    bio.iocp = BASEMAXINLINE;
 
    while (!hiteof){
        unsigned char igroup[3], ogroup[4];
        int c, n;
 
        memset(igroup, 0, sizeof(igroup));
 
        for (n = 0; n < 3; n++) {
            if ((c = inchar(&bio, inputfile)) == EOF) {
                hiteof = 1;
                break;
            }
 
            igroup[n] = (unsigned char) c;
        }
 
        if (n > 0) {
            ogroup[0]= dtable[igroup[0] >> 2];
            ogroup[1]= dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
            ogroup[2]= dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
            ogroup[3]= dtable[igroup[2] & 0x3F];
 
            if (n < 3) {
                ogroup[3] = '=';
 
                if (n < 2) {
                    ogroup[2] = '=';
                }
            }
 
            for (i = 0; i < 4; i++) {
                ochar(&bio, ogroup[i], outputfile, endl);
            }
        }
    }
 
    if (fputs(endl, outputfile) == EOF) {
        return 0;
    }
 
    return 1;
}

References BASEMAXINLINE, c, inchar(), baseio::iocp, and ochar().

Referenced by ast_base64_encode_file_path().

ast_base64_encode_file_path()

int ast_base64_encode_file_path	(	const char *	filename,
		FILE *	outputfile,
		const char *	endl
	)

Performs a base 64 encode algorithm on the contents of a File.

Parameters

filename	The path to the file to be encoded. Must be readable, file is opened in read mode.
outputfile	A FILE handle to the output file to receive the base 64 encoded contents of the input file, identified by filename.
endl	The line ending to use (e.g. either "\n" or "\r\n")

Returns

zero on success, -1 on error.

Definition at line 700 of file utils.c.

{
    FILE *fi;
    int res;
 
    if (!(fi = fopen(filename, "rb"))) {
        ast_log(AST_LOG_WARNING, "Failed to open file: %s: %s\n", filename, strerror(errno));
        return -1;
    }
 
    res = ast_base64_encode_file(fi, outputfile, endl);
 
    fclose(fi);
 
    return res;
}

References ast_base64_encode_file(), ast_log, AST_LOG_WARNING, and errno.

Referenced by add_email_attachment(), and sendmail().

ast_base64decode()

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

Decode data from base64.

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.

Decode data from base64.

Definition at line 296 of file utils.c.

{
    int cnt = 0;
    unsigned int byte = 0;
    unsigned int bits = 0;
    while(*src && *src != '=' && (cnt < max)) {
        /* Shift in 6 bits of input */
        byte <<= 6;
        byte |= (b2a[(int)(*src)]) & 0x3f;
        bits += 6;
        src++;
        /* 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;
}

References b2a, and max.

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(), presence_write(), and res_sdp_crypto_parse_offer().

ast_base64decode_string()

char * ast_base64decode_string

(

const char *

src

)

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

Note

The returned string will need to be freed later and IS NULL terminated

Parameters

src	The source buffer

Return values

NULL	on failure

Returns

Decoded string on success

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

Definition at line 321 of file utils.c.

{
    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;
}

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

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 utils.c.

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

References ast_base64encode_full(), and max.

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

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 utils.c.

{
    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;
}

References base64, and max.

Referenced by ast_base64encode().

ast_base64encode_string()

char * ast_base64encode_string

(

const char *

src

)

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

Note

The returned string will need to be freed later

Parameters

src	The source buffer

Return values

NULL	on failure

Returns

Encoded string on success

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

Definition at line 410 of file utils.c.

{
    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;
}

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

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 utils.c.

{
    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;
}

References b2a_url, and max.

Referenced by ast_base64url_decode_string().

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

Returns

Decoded string on success

Definition at line 448 of file utils.c.

{
    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;
}

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

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 utils.c.

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

References ast_base64url_encode_full(), and max.

Referenced by ast_base64url_encode_string().

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 utils.c.

{
    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;
}

References base64url, and max.

Referenced by ast_base64url_encode().

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

Returns

Encoded string on success

Definition at line 521 of file utils.c.

{
    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;
}

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

ast_careful_fwrite()

int ast_careful_fwrite	(	FILE *	f,
		int	fd,
		const char *	s,
		size_t	len,
		int	timeoutms
	)

Write data to a file stream with a timeout.

Parameters

f	the file stream to write to
fd	the file description to poll on to know when the file stream can be written to without blocking.
s	the buffer to write from
len	the number of bytes to write
timeoutms	The maximum amount of time to block in this function trying to write, specified in milliseconds.

Note

This function assumes that the associated file stream has been set up as non-blocking.

Return values

0	success
-1	error

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.

Note

If you are calling ast_carefulwrite, it is assumed that you are calling it on a file descriptor that DOES have NONBLOCK set. This way, there is only one system call made to do a write, unless we actually have a need to wait. This way, we get better performance.

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

{
    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;
}

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

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

ast_check_command_in_path()

int ast_check_command_in_path

(

const char *

cmd

)

Test for the presence of an executable command in $PATH.

Parameters

cmd	Name of command to locate.

Return values

True	(non-zero) if command is in $PATH.
False	(zero) command not found.

Definition at line 3297 of file utils.c.

{
    char *token, *saveptr, *path = getenv("PATH");
    char filename[PATH_MAX];
    int len;
 
    if (path == NULL) {
        return 0;
    }
 
    path = ast_strdup(path);
    if (path == NULL) {
        return 0;
    }
 
    token = strtok_r(path, ":", &saveptr);
    while (token != NULL) {
        len = snprintf(filename, sizeof(filename), "%s/%s", token, cmd);
        if (len < 0 || len >= sizeof(filename)) {
            ast_log(LOG_WARNING, "Path constructed with '%s' too long; skipping\n", token);
            continue;
        }
 
        if (access(filename, X_OK) == 0) {
            ast_free(path);
            return 1;
        }
 
        token = strtok_r(NULL, ":", &saveptr);
    }
    ast_free(path);
    return 0;
}

References ast_free, ast_log, ast_strdup, len(), LOG_WARNING, NULL, and PATH_MAX.

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

ast_check_ipv6()

int ast_check_ipv6

(

void

)

Test that an OS supports IPv6 Networking.

Since

13.14.0

Return values

True	(non-zero) if the IPv6 supported.
False	(zero) if the OS doesn't support IPv6.

Definition at line 2826 of file utils.c.

{
    int udp6_socket = socket(AF_INET6, SOCK_DGRAM, 0);
 
    if (udp6_socket < 0) {
        return 0;
    }
 
    close(udp6_socket);
    return 1;
}

Referenced by load_module(), and load_module().

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

Return values

negative	if version 1 < version 2.
0	if version 1 = version 2.
positive	if version 1 > version 2.

Definition at line 3158 of file utils.c.

{
    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];
}

Referenced by transport_apply().

ast_crypt()

char * ast_crypt	(	const char *	key,
		const char *	salt
	)

Asterisk wrapper around crypt(3).

The interpretation of the salt (which determines the password hashing algorithm) is system specific. Application code should prefer to use ast_crypt_encrypt() or ast_crypt_validate().

The returned string is heap allocated, and should be freed with ast_free().

Parameters

key	User's password to crypt.
salt	Salt to crypt with.

Returns

Crypted password.

Return values

NULL

on error.

Definition at line 121 of file crypt.c.

{
    struct crypt_data data = {};
    const char *crypted = crypt_r(key, salt, &data);
 
    /* Crypt may return success even if it doesn't recognize the salt. But
     * in those cases it always mangles the salt in some way.
     */
    if (!crypted || !ast_begins_with(crypted, salt)) {
        return NULL;
    }
 
    return ast_strdup(crypted);
}

References ast_begins_with(), ast_strdup, and NULL.

Referenced by ast_crypt_encrypt().

ast_crypt_encrypt()

char * ast_crypt_encrypt

(

const char *

key

)

Asterisk wrapper around crypt(3) for encrypting passwords.

This function will generate a random salt and encrypt the given password.

The returned string is heap allocated, and should be freed with ast_free().

Parameters

key	User's password to crypt.

Returns

Crypted password.

Return values

NULL

on error.

Definition at line 190 of file crypt.c.

{
    char salt[MAX_SALT_LEN] = {};
    while (gen_salt(salt, sizeof(salt)) == 0) {
        char *crypted = ast_crypt(key, salt);
        if (crypted) {
            return crypted;
        }
    }
    return NULL;
}

References ast_crypt(), gen_salt(), MAX_SALT_LEN, and NULL.

Referenced by ari_mkpasswd(), and AST_TEST_DEFINE().

ast_crypt_validate()

int ast_crypt_validate	(	const char *	key,
		const char *	expected
	)

Asterisk wrapper around crypt(3) for validating passwords.

Parameters

key	User's password to validate.
expected	Expected result from crypt.

Return values

True	(non-zero) if key matches expected.
False	(zero) if key doesn't match.

Definition at line 136 of file crypt.c.

{
    struct crypt_data data = {};
    return strcmp(expected, crypt_r(key, expected, &data)) == 0;
}

Referenced by ari_conf_validate_user(), and AST_TEST_DEFINE().

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.

Definition at line 2838 of file utils.c.

{
#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) */
}

Referenced by __ast_assert_failed().

ast_eid_cmp()

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

Compare two EIDs.

Return values

0	if the two are the same
non-zero	otherwise

Since

1.6.1

Definition at line 3128 of file utils.c.

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

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_update(), 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().

ast_eid_is_empty()

int ast_eid_is_empty

(

const struct ast_eid *

eid

)

Check if EID is empty.

Return values

1	if the EID is empty
0	otherwise

Since

13.12.0

Definition at line 3133 of file utils.c.

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

References ast_eid::eid, and empty_eid.

Referenced by load_module(), load_module(), load_module(), and set_config().

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

{
    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;
}

References ast_eid::eid.

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(), session_send_app_event(), session_send_or_queue(), update_key(), xmpp_pubsub_publish_device_state(), and xmpp_pubsub_publish_mwi().

ast_enable_packet_fragmentation()

void ast_enable_packet_fragmentation

(

int

sock

)

Disable PMTU discovery on a socket.

Parameters

sock	The socket to manipulate

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

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

Definition at line 2503 of file utils.c.

{
#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 */
}

References ast_log, and LOG_WARNING.

Referenced by ast_netsock_bindaddr().

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

{
    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;
}

References out, and string.

Referenced by ast_callerid_merge(), ast_sip_modify_id_header(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), channel_read_pjsip(), create_new_id_hdr(), print_escaped_uri(), and refer_send().

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

{
    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;
}

References ast_assert, NULL, out, and string.

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

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.

Return values

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

{
#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
}

References R_OK.

Referenced by add_email_attachment(), as_check_common_config(), ast_media_cache_retrieve(), ast_rtp_dtls_cfg_parse(), retrieve_cert_from_cache(), transport_tls_file_handler(), and vs_check_common_config().

ast_get_tid()

int ast_get_tid

(

void

)

Get current thread ID.

Returns

the ID if platform is supported, else -1

Definition at line 2786 of file utils.c.

{
    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__)
    long lwpid;
    thr_self(&lwpid);
    ret = lwpid;
#elif defined(__NetBSD__)
    ret = _lwp_self();
#elif defined(__OpenBSD__)
    ret = getthrid();
#endif
    return ret;
}

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

ast_gethostbyname()

struct hostent * ast_gethostbyname	(	const char *	host,
		struct ast_hostent *	hp
	)

Thread-safe gethostbyname function to use in Asterisk.

Deprecated:

Replaced by ast_sockaddr_resolve() and ast_sockaddr_resolve_first_af()

Note

To be removed in Asterisk 23.

Thread-safe gethostbyname function to use in Asterisk.

Definition at line 199 of file utils.c.

{
#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;
}

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

ast_md5_hash()

void ast_md5_hash	(	char *	output,
		const char *	input
	)

Produces MD5 hash based on input string.

Produces MD5 hash based on input string.

Definition at line 250 of file utils.c.

{
    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]);
}

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

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

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

Return values

0	on success

Returns

error code otherwise

Creates a directory path, creating parent directories as needed.

Definition at line 2513 of file utils.c.

{
    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;
}

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

Referenced by ast_file_fdtemp(), ast_logger_rotate_channel(), conf_rec_name(), conf_run(), create_destination_directory(), create_dirpath(), create_dirpath(), dictate_exec(), filename_parse(), 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().

ast_parse_digest()

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

Parse digest authorization header.

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.

Returns

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

Note

This function may be used for Digest request and response 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 2672 of file utils.c.

                                                                                               {
    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 processing */
                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;
}

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, d, LOG_WARNING, NULL, request(), str, and strsep().

Referenced by auth_http_callback().

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

{
    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;
}

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

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

{
#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 */
}

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

Referenced by ast_pthread_create_detached_stack().

ast_random()

long int ast_random

(

void

)

Examples

app_skel.c.

Definition at line 2346 of file utils.c.

{
    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;
}

References ast_mutex_lock, ast_mutex_unlock, dev_urandom_fd, and randomlock.

Referenced by acf_rand_exec(), action_challenge(), agi_handle_command(), app_exec(), ast_generate_random_string(), ast_lock_path_lockfile(), ast_rtp_change_source(), ast_rtp_new(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), ast_udptl_new_with_bindaddr(), astobj2_test_1_helper(), auth_http_callback(), authenticate_request(), build_iv(), build_rand_pad(), calc_metric(), calc_rxstamp(), caldav_write_event(), create_channel_name(), create_local_sdp(), dns_srv_sort(), generate_parked_user(), generate_random_string(), generic_http_callback(), get_trans_id(), get_unused_callno(), handle_cli_sched_bench(), iax2_key_rotate(), jingle_add_ice_udp_candidates_to_transport(), jingle_alloc(), jingle_new(), load_module(), make_email_file(), mbl_new(), moh_files_alloc(), moh_files_next(), multicast_rtp_new(), ogg_vorbis_rewrite(), page_exec(), process_weights(), registry_authrequest(), 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(), 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(), try_firmware(), websocket_client_create_key(), and websocket_mask_payload().

ast_register_thread()

void ast_register_thread

(

char *

name

)

Definition at line 422 of file asterisk.c.

{
    struct thread_list_t *new = ast_calloc(1, sizeof(*new));
 
    if (!new)
        return;
 
    ast_assert(multi_thread_safe);
    new->id = pthread_self();
    new->lwp = ast_get_tid();
    new->name = name; /* steal the allocated memory for the thread name */
    AST_RWLIST_WRLOCK(&thread_list);
    AST_RWLIST_INSERT_HEAD(&thread_list, new, list);
    AST_RWLIST_UNLOCK(&thread_list);
}

References ast_assert, ast_calloc, ast_get_tid(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, thread_list_t::list, multi_thread_safe, and name.

Referenced by dummy_start().

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

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

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

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

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

Return values

0	on success

Returns

an error code otherwise

Definition at line 2618 of file utils.c.

{
    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);
}

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

Referenced by AST_TEST_DEFINE(), stasis_app_control_record(), and stasis_app_stored_recording_copy().

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

{
    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;
}

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

Referenced by load_asterisk_conf().

ast_sha1_hash()

void ast_sha1_hash	(	char *	output,
		const char *	input
	)

Produces SHA1 hash based on input string.

Produces SHA1 hash based on input string.

Definition at line 266 of file utils.c.

{
    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]);
}

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

Referenced by ast_tcptls_server_start(), AST_TEST_DEFINE(), ctx_populate(), handle_call_token(), media_cache_item_sync_to_astdb(), sha1(), xmpp_client_authenticate_digest(), and xmpp_component_authenticate().

ast_sha1_hash_uint()

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

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

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

Definition at line 284 of file utils.c.

{
        struct SHA1Context sha;
 
        SHA1Reset(&sha);
 
        SHA1Input(&sha, (const unsigned char *) input, strlen(input));
 
        SHA1Result(&sha, digest);
}

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

Referenced by websocket_combine_key().

ast_slinear_saturated_add()

static force_inline void ast_slinear_saturated_add ( short *  input, short *  value  )

static

Definition at line 484 of file utils.h.

{
    int res;
 
    res = (int) *input + *value;
    if (res > 32767)
        *input = 32767;
    else if (res < -32768)
        *input = -32768;
    else
        *input = (short) res;
}

References value.

Referenced by ast_frame_slinear_sum(), audio_audiohook_write_list(), audiohook_read_frame_both(), binaural_mixing(), softmix_mixing_loop(), and spy_generate().

ast_slinear_saturated_divide()

static force_inline void ast_slinear_saturated_divide ( short *  input, short *  value  )

static

Definition at line 539 of file utils.h.

{
    *input /= *value;
}

References value.

Referenced by ast_frame_adjust_volume(), and audiohook_read_frame_both().

ast_slinear_saturated_divide_float()

static force_inline void ast_slinear_saturated_divide_float ( short *  input, float *  value  )

static

Definition at line 544 of file utils.h.

{
    float res = (float) *input / *value;
    if (res > 32767)
        *input = 32767;
    else if (res < -32768)
        *input = -32768;
    else if (res > 0)
        *input = (short) (res + 0.5);
    else
        *input = (short) (res - 0.5);
 
}

References value.

Referenced by ast_frame_adjust_volume_float().

ast_slinear_saturated_multiply()

static force_inline void ast_slinear_saturated_multiply ( short *  input, short *  value  )

static

Definition at line 510 of file utils.h.

{
    int res;
 
    res = (int) *input * *value;
    if (res > 32767)
        *input = 32767;
    else if (res < -32768)
        *input = -32768;
    else
        *input = (short) res;
}

References value.

Referenced by ast_frame_adjust_volume(), and audiohook_read_frame_both().

ast_slinear_saturated_multiply_float()

static force_inline void ast_slinear_saturated_multiply_float ( short *  input, float *  value  )

static

Definition at line 523 of file utils.h.

{
    float res;
 
    res = (float) *input * *value;
    if (res > 32767)
        *input = 32767;
    else if (res < -32768)
        *input = -32768;
    else if (res > 0)
        *input = (short) (res + 0.5);
    else
        *input = (short) (res - 0.5);
 
}

References value.

Referenced by ast_frame_adjust_volume_float().

ast_slinear_saturated_subtract()

static force_inline void ast_slinear_saturated_subtract ( short *  input, short *  value  )

static

Definition at line 497 of file utils.h.

{
    int res;
 
    res = (int) *input - *value;
    if (res > 32767)
        *input = 32767;
    else if (res < -32768)
        *input = -32768;
    else
        *input = (short) res;
}

References value.

Referenced by softmix_process_write_audio(), and softmix_process_write_binaural_audio().

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

Return values

0	success
non-zero	failure

Since

1.6.1

Definition at line 3111 of file utils.c.

{
    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;
}

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

ast_thread_is_user_interface()

int ast_thread_is_user_interface

(

void

)

Indicates whether the current thread is a user interface.

Return values

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

Definition at line 3282 of file utils.c.

{
    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;
}

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

Referenced by ast_autoservice_start(), and ast_autoservice_stop().

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.

Return values

True	(non-zero) if marking current thread failed.
False	(zero) if successfuly marked current thread.

Definition at line 3267 of file utils.c.

{
    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;
}

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

Referenced by handle_tcptls_connection().

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

{
    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';
}

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

ast_unregister_thread()

void ast_unregister_thread

(

void *

id

)

Definition at line 438 of file asterisk.c.

{
    struct thread_list_t *x;
 
    AST_RWLIST_WRLOCK(&thread_list);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&thread_list, x, list) {
        if ((void *) x->id == id) {
            AST_RWLIST_REMOVE_CURRENT(list);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&thread_list);
    if (x) {
        ast_free(x->name);
        ast_free(x);
    }
}

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, thread_list_t::id, thread_list_t::list, and thread_list_t::name.

Referenced by dummy_start().

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

{
    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';
}

References ast_test_flag, and AST_URI_LEGACY_SPACE.

Referenced by acf_curl_helper(), ast_ari_invoke(), ast_http_parse_post_form(), AST_TEST_DEFINE(), config_curl(), handle_uri(), realtime_curl(), realtime_multi_curl(), and uridecode().

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

{
    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;
}

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

Referenced by 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(), and uriencode().

ast_uri_verify_encoded()

int ast_uri_verify_encoded

(

const char *

string

)

Verify if a string is valid as a URI component.

This function checks if the string either doesn't need encoding or is already properly URI encoded. Valid characters are 'a-zA-Z0-9.+_-' and 'xx' escape sequences.

Parameters

string

String to be checked

Return values

1	if the string is valid
0	if the string is not valid

Definition at line 779 of file utils.c.

{
    const char *ptr = string;
    size_t length;
    char *endl;
 
    if (!string) {
        return 0;
    }
 
    length = strlen(string);
    endl = (char *)string + length;
 
    while (*ptr) {
        if (*ptr == '%') {
            unsigned int tmp;
            /* Make sure there are at least 2 characters left to decode */
            if (ptr + 2 >= endl) {
                return 0;
            }
            /* Try to parse the next two characters as hex */
            if (sscanf(ptr + 1, "%2x", &tmp) != 1) {
                return 0;
            }
            /* All good, move past the '%' and the two hex digits */
            ptr += 3;
        } else if (!isalnum((unsigned char ) *ptr) && !strchr("-_.+", *ptr)) {
            return 0;
        } else {
            ptr++;
        }
    }
 
    return 1; /* all characters are valid */
}

References string.

Referenced by validate_uri_parameters().

ast_utils_init()

int ast_utils_init

(

void

)

Definition at line 2651 of file utils.c.

{
    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;
}

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

Referenced by asterisk_daemon().

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

{
    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;
}

References ast_strdupa, NULL, and strsep().

ast_wait_for_input()

int ast_wait_for_input	(	int	fd,
		int	ms
	)

Definition at line 1732 of file utils.c.

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

References ast_poll.

Referenced by action_waitevent(), ast_audiosocket_receive_frame_with_hangup(), ast_iostream_wait_for_input(), ast_iostream_write(), ast_tcptls_server_root(), dahdi_test_timer(), get_input(), iostream_read(), moh_class_destructor(), session_read(), and unbound_resolver_thread().

ast_wait_for_output()

int ast_wait_for_output	(	int	fd,
		int	ms
	)

Definition at line 1742 of file utils.c.

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

References ast_poll.

Referenced by ast_iostream_write(), iostream_read(), and socket_connect().

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

Return values

0	for success
-1	if buflen is too short.

Definition at line 898 of file utils.c.

{
    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;
}

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

Referenced by ast_http_create_response(), and test_xml().

Variable Documentation

__unsigned_int_flags_dummy

unsigned int __unsigned_int_flags_dummy

extern

Note

   Note:
   It is very important to use only unsigned variables to hold
   bit flags, as otherwise you can fall prey to the compiler's
   sign-extension antics if you try to use the top two bits in
   your variable.

   The flag macros below use a set of compiler tricks to verify
   that the caller is using an "unsigned int" variable to hold
   the flags, and nothing else. If the caller uses any other
   type of variable, a warning message similar to this:

   warning: comparison of distinct pointer types lacks cast
   will be generated.

   The "dummy" variable below is used to make these comparisons.

   Also note that at -O2 or above, this type-safety checking
   does _not_ produce any additional object code at all.

__unsigned_int_flags_dummy64

uint64_t __unsigned_int_flags_dummy64

extern

Swap the upper and lower 32 bits of a big-endian 64-bit integer.

This macro is needed to preserve ABI compatability on big-endian systems after changing from a 32 bit flags to a 64 bit flags. It ensures that a new 64-bit flag field will still work with a function that expects a 32-bit flag field. On a little-endian system, nothing is needed, since the 64-bit flags are already in the correct order.

Note

This macro is different than a standard byte swap, as it doesn't reverse the byte order, it just swaps the upper 4 bytes with the lower 4 bytes.

Parameters

flags

The 64-bit flags to swap

Return values

The	flags with the upper and lower 32 bits swapped if the system is big-endian,

ast_eid_default

struct ast_eid ast_eid_default

extern

Global EID.

This is set in asterisk.conf, or determined automatically by taking the mac address of an Ethernet interface on the system.

Definition at line 94 of file options.c.

Referenced by app_send(), ast_ari_asterisk_get_info(), ast_ari_asterisk_ping(), ast_delete_mwi_state_full(), ast_device_state_clear_cache(), ast_event_append_eid(), ast_str_retrieve_variable(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), asterisk_publication_send_refresh(), asterisk_publisher_devstate_cb(), asterisk_publisher_mwistate_cb(), bridges_scrape_cb(), cache_entry_by_eid(), cache_entry_create(), cache_remove(), cache_test_message_create(), cache_update(), channels_scrape_cb(), clear_node_cache(), cpg_confchg_cb(), cpg_deliver_cb(), endpoints_scrape_cb(), handle_show_settings(), load_asterisk_conf(), load_module(), load_module(), load_module(), mwi_state_create_message(), prometheus_config_post_apply(), publish_cluster_discovery_to_stasis(), publish_to_corosync(), session_send_app_event(), session_send_or_queue(), set_config(), stasis_cache_dump(), stasis_cache_get(), stasis_message_create(), state_find_and_remove_eid(), state_find_or_add_eid(), xmpp_pubsub_devstate_cb(), xmpp_pubsub_handle_event(), xmpp_pubsub_mwi_cb(), xmpp_pubsub_publish_device_state(), and xmpp_pubsub_publish_mwi().

ast_uri_http

const struct ast_flags ast_uri_http

extern

Definition at line 717 of file utils.c.

{AST_URI_UNRESERVED};

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

extern

Definition at line 718 of file utils.c.

{AST_URI_LEGACY_SPACE | AST_URI_UNRESERVED};

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

ast_uri_sip_user

const struct ast_flags ast_uri_sip_user

extern

Definition at line 719 of file utils.c.

{AST_URI_UNRESERVED | AST_URI_SIP_USER_UNRESERVED};

Referenced by AST_TEST_DEFINE().