res_pjsip_history.c File Reference

PJSIP History. More...

#include "asterisk.h"
#include <pjsip.h>
#include <regex.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/module.h"
#include "asterisk/logger.h"
#include "asterisk/cli.h"
#include "asterisk/netsock2.h"
#include "asterisk/vector.h"
#include "asterisk/lock.h"
#include "asterisk/res_pjproject.h"

Include dependency graph for res_pjsip_history.c:

Go to the source code of this file.

Data Structures
struct	allowed_field
	A field that we understand and can perform operations on. More...
struct	expression_token
	A token in the expression or an evaluated part of the expression. More...
struct	operator
	An operator that we understand in an expression. More...
struct	pjsip_history_entry
	An item in the history. More...
struct	vector_history_t
	The one and only history that we've captured. More...

Macros
#define	APPEND_TO_OUTPUT(output, token)
#define	HISTORY_INITIAL_SIZE   256

Enumerations
enum	expression_token_type { TOKEN_TYPE_FIELD , TOKEN_TYPE_OPERATOR , TOKEN_TYPE_RESULT }
	The type of token that has been parsed out of an expression. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct expression_token *	build_expression_queue (struct ast_cli_args *a)
	Build a reverse polish notation expression queue.
static int	clear_history_entries (void *obj)
	Remove all entries from vector_history.
static void	clear_history_entry_cb (struct pjsip_history_entry *entry)
	Vector callback that releases the reference for the entry in a history vector.
static void	display_entry_list (struct ast_cli_args *a, struct vector_history_t *vec)
	Print a list of the entries to the CLI.
static void	display_single_entry (struct ast_cli_args *a, struct pjsip_history_entry *entry)
	Print a detailed view of a single entry in the history to the CLI.
static void *	entry_get_addr (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's destination address.
static void *	entry_get_number (struct pjsip_history_entry *entry)
	Callback to retrieve the entry index number.
static void *	entry_get_sip_msg_call_id (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's SIP Call-ID header.
static void *	entry_get_sip_msg_request_method (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's SIP request method type.
static void *	entry_get_timestamp (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's timestamp.
static int	evaluate_and (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining logical AND.
static int	evaluate_equal (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining equality.
static int	evaluate_greater_than (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining if one operand is greater than another.
static int	evaluate_greater_than_or_equal (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining if one operand is greater than or equal to another.
static int	evaluate_history_entry (struct pjsip_history_entry *entry, struct expression_token *queue)
	Evaluate a single entry in this history using a RPN expression.
static int	evaluate_less_than (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining if one operand is less than another.
static int	evaluate_less_than_or_equal (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining if one operand is less than or equal to another.
static int	evaluate_like (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for regex 'like'.
static int	evaluate_not (struct operator*op, enum aco_option_type type, void *operand)
	Operator callback for determining logical NOT.
static int	evaluate_not_equal (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining inequality.
static int	evaluate_or (struct operator*op, enum aco_option_type type, void *op_left, struct expression_token *op_right)
	Operator callback for determining logical OR.
static struct expression_token *	expression_token_alloc (enum expression_token_type token_type, void *value)
	Allocate an expression token.
static struct expression_token *	expression_token_free (struct expression_token *token)
	Free an expression token and all others it references.
static struct vector_history_t *	filter_history (struct ast_cli_args *a)
	Create a filtered history based on a user provided expression.
static struct allowed_field *	get_allowed_field (struct expression_token *token)
	Determine if the expression token matches a field in allowed_fields.
static pj_bool_t	history_on_rx_msg (pjsip_rx_data *rdata)
	PJSIP callback when a SIP message is received.
static pj_status_t	history_on_tx_msg (pjsip_tx_data *tdata)
	PJSIP callback when a SIP message is transmitted.
static int	load_module (void)
static struct pjsip_history_entry *	pjsip_history_entry_alloc (pjsip_msg *msg)
	Create a pjsip_history_entry AO2 object.
static void	pjsip_history_entry_dtor (void *obj)
	AO2 destructor for pjsip_history_entry.
static char *	pjsip_set_history (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	pjsip_show_history (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	safe_vector_cleanup (void *obj)
	Cleanup routine for a history vector, serviced on a registered PJSIP thread.
static void	sprint_list_entry (struct pjsip_history_entry *entry, char *line, int len)
	Format single line history entry.
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP History" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", }
static struct allowed_field	allowed_fields []
	The fields we allow.
static struct operator	allowed_operators []
	Our allowed operations.
static const struct ast_module_info *	ast_module_info = &__mod_info
static pj_caching_pool	cachingpool
	Pool factory used by pjlib to allocate memory.
static struct ast_cli_entry	cli_pjsip []
static int	enabled
	Whether or not we are storing history.
static ast_mutex_t	history_lock = AST_MUTEX_INIT_VALUE
	Mutex that protects vector_history.
static struct operator	left_paren
	Operator token for a left parenthesis.
static int	log_level = -1
	Log level for history output.
static pjsip_module	logging_module
static int	packet_number
	Packet count.
static struct vector_history_t	vector_history

Detailed Description

PJSIP History.

Author

Matt Jordan mjord.nosp@m.an@d.nosp@m.igium.nosp@m..com

Definition in file res_pjsip_history.c.

Macro Definition Documentation

APPEND_TO_OUTPUT

#define APPEND_TO_OUTPUT	(		output,
			token
	)

HISTORY_INITIAL_SIZE

#define HISTORY_INITIAL_SIZE   256

Definition at line 47 of file res_pjsip_history.c.

Enumeration Type Documentation

expression_token_type

enum expression_token_type

The type of token that has been parsed out of an expression.

Enumerator
TOKEN_TYPE_FIELD	The expression_token contains a field
TOKEN_TYPE_OPERATOR	The expression_token contains an operator
TOKEN_TYPE_RESULT	The expression_token contains a previous result

Definition at line 135 of file res_pjsip_history.c.

                           {
    /*! The \c expression_token contains a field */
    TOKEN_TYPE_FIELD,
    /*! The \c expression_token contains an operator */
    TOKEN_TYPE_OPERATOR,
    /*! The \c expression_token contains a previous result */
    TOKEN_TYPE_RESULT
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1410 of file res_pjsip_history.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1410 of file res_pjsip_history.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1410 of file res_pjsip_history.c.

build_expression_queue()

static struct expression_token * build_expression_queue ( struct ast_cli_args *  a )

static

Build a reverse polish notation expression queue.

This function is an implementation of the Shunting-Yard Algorithm. It takes a user provided infix-notation expression and converts it into a reverse polish notation expression, which is a queue of tokens that can be easily parsed.

Parameters

a	The CLI arguments provided by the User, containing the infix expression

Return values

NULL	error
expression_token	A 'queue' of expression tokens in RPN

Definition at line 804 of file res_pjsip_history.c.

{
    AST_VECTOR(, struct operator *) operators; /* A stack of saved operators */
    struct expression_token *output = NULL;    /* The output queue */
    struct expression_token *head = NULL;      /* Pointer to the head of /c output */
    int i;
 
#define APPEND_TO_OUTPUT(output, token) do { \
    if ((output)) { \
        (output)->next = (token); \
        (output) = (token); \
    } else { \
        (output) = (token); \
        head = (output); \
    } \
} while (0)
 
    if (AST_VECTOR_INIT(&operators, 8)) {
        return NULL;
    }
 
    for (i = 4; i < a->argc; i++) {
        struct expression_token *out_token;
        char *token = ast_strdupa(a->argv[i]);
        int j;
 
        /* Strip off and append any left parentheses */
        if (token[0] == '(') {
            AST_VECTOR_APPEND(&operators, &left_paren);
            if (!token[1]) {
                continue;
            }
            token = &token[1];
        }
 
        /* Handle the case where the token is an operator */
        for (j = 0; j < ARRAY_LEN(allowed_operators); j++) {
            int k;
 
            if (strcasecmp(token, allowed_operators[j].symbol)) {
                continue;
            }
 
            for (k = AST_VECTOR_SIZE(&operators) - 1; k >= 0; k--) {
                struct operator *top = AST_VECTOR_GET(&operators, k);
 
                /* Remove and push queued up operators, if they are of
                 * less precedence than this operator
                 */
                if ((allowed_operators[j].right_to_left && allowed_operators[j].precedence >= top->precedence)
                    || (!allowed_operators[j].right_to_left && allowed_operators[j].precedence > top->precedence)) {
 
                    if (!(out_token = expression_token_alloc(TOKEN_TYPE_OPERATOR, top))) {
                        goto error;
                    }
                    APPEND_TO_OUTPUT(output, out_token);
                    AST_VECTOR_REMOVE(&operators, k, 1);
                }
            }
 
            AST_VECTOR_APPEND(&operators, &allowed_operators[j]);
            token = NULL;
            break;
        }
 
        /* Token was an operator; continue to next token */
        if (!token) {
            continue;
        }
 
        /* Handle a right parentheses either by itself or as part of the token.
         * If part of the token, push the token onto the output queue first
         */
        if (token[0] == ')' || token[strlen(token) - 1] == ')') {
 
            if (token[strlen(token) - 1] == ')') {
                token[strlen(token) - 1] = '\0';
 
                if (!(out_token = expression_token_alloc(TOKEN_TYPE_FIELD, token))) {
                    goto error;
                }
                APPEND_TO_OUTPUT(output, out_token);
                token = NULL;
            }
 
            for (j = AST_VECTOR_SIZE(&operators) - 1; j >= 0; j--) {
                struct operator *top = AST_VECTOR_GET(&operators, j);
 
                AST_VECTOR_REMOVE(&operators, j, 1);
                if (top == &left_paren) {
                    break;
                }
 
                if (!(out_token = expression_token_alloc(TOKEN_TYPE_OPERATOR, top))) {
                    goto error;
                }
                APPEND_TO_OUTPUT(output, out_token);
            }
        }
 
        /* Just a plain token, push to the output queue */
        if (token) {
            if (!(out_token = expression_token_alloc(TOKEN_TYPE_FIELD, token))) {
                goto error;
            }
            APPEND_TO_OUTPUT(output, out_token);
        }
    }
 
    /* Remove any non-applied operators that remain, applying them
     * to the output queue
     */
    for (i = AST_VECTOR_SIZE(&operators) - 1; i >= 0; i--) {
        struct operator *top = AST_VECTOR_GET(&operators, i);
        struct expression_token *out_token;
 
        AST_VECTOR_REMOVE(&operators, i, 1);
        if (top == &left_paren) {
            ast_log(LOG_WARNING, "Unbalanced '(' parentheses in expression!\n");
            continue;
        }
 
        if (!(out_token = expression_token_alloc(TOKEN_TYPE_OPERATOR, top))) {
            goto error;
        }
        APPEND_TO_OUTPUT(output, out_token);
    }
 
    AST_VECTOR_FREE(&operators);
    return head;
 
error:
    AST_VECTOR_FREE(&operators);
    expression_token_free(output);
    return NULL;
}

References a, allowed_operators, APPEND_TO_OUTPUT, ARRAY_LEN, ast_log, ast_strdupa, AST_VECTOR, AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, error(), expression_token_alloc(), expression_token_free(), left_paren, LOG_WARNING, NULL, operator::precedence, operator::right_to_left, TOKEN_TYPE_FIELD, and TOKEN_TYPE_OPERATOR.

Referenced by filter_history().

clear_history_entries()

static int clear_history_entries ( void *  obj )

static

Remove all entries from vector_history.

This must be called from a registered PJSIP thread

Definition at line 781 of file res_pjsip_history.c.

{
    ast_mutex_lock(&history_lock);
    AST_VECTOR_RESET(&vector_history, clear_history_entry_cb);
    packet_number = 0;
    ast_mutex_unlock(&history_lock);
 
    return 0;
}

References ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_RESET, clear_history_entry_cb(), history_lock, packet_number, and vector_history.

Referenced by pjsip_set_history(), and unload_module().

clear_history_entry_cb()

static void clear_history_entry_cb ( struct pjsip_history_entry *  entry )

static

Vector callback that releases the reference for the entry in a history vector.

Definition at line 771 of file res_pjsip_history.c.

{
    ao2_ref(entry, -1);
}

References ao2_ref.

Referenced by clear_history_entries(), filter_history(), and safe_vector_cleanup().

display_entry_list()

static void display_entry_list ( struct ast_cli_args *  a, struct vector_history_t *  vec  )

static

Print a list of the entries to the CLI.

Definition at line 1186 of file res_pjsip_history.c.

{
    int i;
 
    ast_cli(a->fd, "%-5.5s %-10.10s %-30.30s %-35.35s\n",
        "No.",
        "Timestamp",
        "(Dir) Address",
        "SIP Message");
    ast_cli(a->fd, "===== ========== ============================== ===================================\n");
 
    for (i = 0; i < AST_VECTOR_SIZE(vec); i++) {
        struct pjsip_history_entry *entry;
        char line[256];
 
        entry = AST_VECTOR_GET(vec, i);
        sprint_list_entry(entry, line, sizeof(line));
 
        ast_cli(a->fd, "%s\n", line);
    }
}

References a, ast_cli(), AST_VECTOR_GET, AST_VECTOR_SIZE, and sprint_list_entry().

Referenced by pjsip_show_history().

display_single_entry()

static void display_single_entry ( struct ast_cli_args *  a, struct pjsip_history_entry *  entry  )

static

Print a detailed view of a single entry in the history to the CLI.

Definition at line 1152 of file res_pjsip_history.c.

{
    char addr[64], secs[AST_TIME_T_LEN];
    char *buf;
 
    buf = ast_calloc(1, PJSIP_MAX_PKT_LEN * sizeof(char));
    if (!buf) {
        return;
    }
 
    if (pjsip_msg_print(entry->msg, buf, PJSIP_MAX_PKT_LEN) == -1) {
        ast_log(LOG_WARNING, "Unable to print SIP message %d: packet too large!\n", entry->number);
        ast_free(buf);
        return;
    }
 
    if (entry->transmitted) {
        pj_sockaddr_print(&entry->dst, addr, sizeof(addr), 3);
    } else {
        pj_sockaddr_print(&entry->src, addr, sizeof(addr), 3);
    }
 
    ast_time_t_to_string(entry->timestamp.tv_sec, secs, sizeof(secs));
    ast_cli(a->fd, "<--- History Entry %d %s %s at %-10.10s --->\n",
        entry->number,
        entry->transmitted ? "Sent to" : "Received from",
        addr,
        secs);
    ast_cli(a->fd, "%s\n", buf);
 
    ast_free(buf);
}

References a, ast_calloc, ast_cli(), ast_free, ast_log, AST_TIME_T_LEN, ast_time_t_to_string(), buf, pjsip_history_entry::dst, LOG_WARNING, pjsip_history_entry::msg, pjsip_history_entry::number, pjsip_history_entry::src, pjsip_history_entry::timestamp, and pjsip_history_entry::transmitted.

Referenced by pjsip_show_history().

entry_get_addr()

static void * entry_get_addr ( struct pjsip_history_entry *  entry )

static

Callback to retrieve the entry's destination address.

Definition at line 483 of file res_pjsip_history.c.

{
    if (entry->transmitted) {
        return &entry->dst;
    } else {
        return &entry->src;
    }
}

References pjsip_history_entry::dst, pjsip_history_entry::src, and pjsip_history_entry::transmitted.

entry_get_number()

static void * entry_get_number ( struct pjsip_history_entry *  entry )

static

Callback to retrieve the entry index number.

Definition at line 471 of file res_pjsip_history.c.

{
    return &entry->number;
}

References pjsip_history_entry::number.

entry_get_sip_msg_call_id()

static void * entry_get_sip_msg_call_id ( struct pjsip_history_entry *  entry )

static

Callback to retrieve the entry's SIP Call-ID header.

Definition at line 503 of file res_pjsip_history.c.

{
    pjsip_cid_hdr *cid_hdr;
 
    cid_hdr = PJSIP_MSG_CID_HDR(entry->msg);
 
    return &cid_hdr->id;
}

References pjsip_history_entry::msg.

entry_get_sip_msg_request_method()

static void * entry_get_sip_msg_request_method ( struct pjsip_history_entry *  entry )

static

Callback to retrieve the entry's SIP request method type.

Definition at line 493 of file res_pjsip_history.c.

{
    if (entry->msg->type != PJSIP_REQUEST_MSG) {
        return NULL;
    }
 
    return &entry->msg->line.req.method.name;
}

References pjsip_history_entry::msg, and NULL.

entry_get_timestamp()

static void * entry_get_timestamp ( struct pjsip_history_entry *  entry )

static

Callback to retrieve the entry's timestamp.

Definition at line 477 of file res_pjsip_history.c.

{
    return &entry->timestamp;
}

References pjsip_history_entry::timestamp.

evaluate_and()

static int evaluate_and ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining logical AND.

Definition at line 374 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
        return (*(int *)op_left && op_right->result);
    default:
        ast_log(LOG_WARNING, "Cannot evaluate: invalid operand type for operator '%s'\n", op->symbol);
    }
 
    return -1;
}

References ast_log, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_INT_T, OPT_UINT_T, expression_token::result, and type.

evaluate_equal()

static int evaluate_equal ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining equality.

Definition at line 167 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
    {
        int right;
 
        if (sscanf(op_right->field, "%30d", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not an integer\n", op_right->field);
            return -1;
        }
        return (*(int *)op_left) == right;
    }
    case OPT_DOUBLE_T:
    {
        double right;
 
        if (sscanf(op_right->field, "%lf", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a double\n", op_right->field);
            return -1;
        }
        return (*(double *)op_left) == right;
    }
    case OPT_CHAR_ARRAY_T:
    case OPT_STRINGFIELD_T:
        /* In our case, we operate on pj_str_t */
        return pj_strcmp2(op_left, op_right->field) == 0;
    case OPT_NOOP_T:
    /* Used for timeval */
    {
        struct timeval right = { 0, };
 
        if ((right.tv_sec = ast_string_to_time_t(op_right->field)) == -1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a timestamp\n", op_right->field);
            return -1;
        }
 
        return ast_tvcmp(*(struct timeval *)op_left, right) == 0;
    }
    case OPT_SOCKADDR_T:
    /* In our case, we operate only on pj_sockaddr_t */
    {
        pj_sockaddr right;
        pj_str_t str_right;
 
        pj_cstr(&str_right, op_right->field);
        if (pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &str_right, &right) != PJ_SUCCESS) {
            ast_log(LOG_WARNING, "Unable to convert field '%s': not an IPv4 or IPv6 address\n", op_right->field);
            return -1;
        }
 
        return pj_sockaddr_cmp(op_left, &right) == 0;
    }
    default:
        ast_log(LOG_WARNING, "Cannot evaluate field '%s': invalid type for operator '%s'\n",
            op_right->field, op->symbol);
    }
 
    return -1;
}

References ast_log, ast_string_to_time_t(), ast_tvcmp(), expression_token::field, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_CHAR_ARRAY_T, OPT_DOUBLE_T, OPT_INT_T, OPT_NOOP_T, OPT_SOCKADDR_T, OPT_STRINGFIELD_T, OPT_UINT_T, and type.

Referenced by evaluate_not_equal().

evaluate_greater_than()

static int evaluate_greater_than ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining if one operand is greater than another.

Definition at line 291 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
    {
        int right;
 
        if (sscanf(op_right->field, "%30d", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not an integer\n", op_right->field);
            return -1;
        }
        return (*(int *)op_left) > right;
    }
    case OPT_DOUBLE_T:
    {
        double right;
 
        if (sscanf(op_right->field, "%lf", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a double\n", op_right->field);
            return -1;
        }
        return (*(double *)op_left) > right;
    }
    case OPT_NOOP_T:
    /* Used for timeval */
    {
        struct timeval right = { 0, };
 
        if ((right.tv_sec = ast_string_to_time_t(op_right->field)) == -1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a timestamp\n", op_right->field);
            return -1;
        }
 
        return ast_tvcmp(*(struct timeval *)op_left, right) == 1;
    }
    default:
        ast_log(LOG_WARNING, "Cannot evaluate field '%s': invalid type for operator '%s'\n",
            op_right->field, op->symbol);
    }
 
    return -1;
}

References ast_log, ast_string_to_time_t(), ast_tvcmp(), expression_token::field, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_DOUBLE_T, OPT_INT_T, OPT_NOOP_T, OPT_UINT_T, and type.

Referenced by evaluate_less_than_or_equal().

evaluate_greater_than_or_equal()

static int evaluate_greater_than_or_equal ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining if one operand is greater than or equal to another.

Definition at line 348 of file res_pjsip_history.c.

{
    return !evaluate_less_than(op, type, op_left, op_right);
}

References evaluate_less_than(), and type.

evaluate_history_entry()

static int evaluate_history_entry ( struct pjsip_history_entry *  entry, struct expression_token *  queue  )

static

Evaluate a single entry in this history using a RPN expression.

Parameters

entry	The entry in the history to evaluate
queue	The RPN expression

Return values

0	The expression evaluated FALSE on entry
1	The expression evaluated TRUE on entry
-1	The expression errored

Definition at line 951 of file res_pjsip_history.c.

{
    AST_VECTOR(, struct expression_token *) stack; /* Our stack of results and operands */
    struct expression_token *it_queue;
    struct expression_token *final;
    int result;
    int i;
 
    if (AST_VECTOR_INIT(&stack, 16)) {
        return -1;
    }
 
    for (it_queue = queue; it_queue; it_queue = it_queue->next) {
        struct expression_token *op_one;
        struct expression_token *op_two = NULL;
        struct expression_token *result;
        int res = 0;
 
        /* If this is not an operator, push it to the stack */
        if (!it_queue->op) {
            if (AST_VECTOR_APPEND(&stack, it_queue)) {
                goto error;
            }
            continue;
        }
 
        if (AST_VECTOR_SIZE(&stack) < it_queue->op->operands) {
            ast_log(LOG_WARNING, "Unable to evaluate expression operator '%s': not enough operands\n",
                it_queue->op->symbol);
            goto error;
        }
 
        if (it_queue->op->operands == 1) {
            /* Unary operators currently consist only of 'not', which can only act
             * upon an evaluated condition result.
             */
            ast_assert(it_queue->op->evaluate_unary != NULL);
 
            op_one = AST_VECTOR_REMOVE(&stack, AST_VECTOR_SIZE(&stack) - 1, 1);
            if (op_one->token_type != TOKEN_TYPE_RESULT) {
                ast_log(LOG_WARNING, "Unable to evaluate '%s': operand is not the result of an operation\n",
                    it_queue->op->symbol);
                goto error;
            }
 
            res = it_queue->op->evaluate_unary(it_queue->op, OPT_INT_T, &op_one->result) == 0 ? 0 : 1;
        } else if (it_queue->op->operands == 2) {
            struct allowed_field *field;
            enum aco_option_type type;
            void *value;
 
            ast_assert(it_queue->op->evaluate != NULL);
 
            op_one = AST_VECTOR_REMOVE(&stack, AST_VECTOR_SIZE(&stack) - 1, 1);
            op_two = AST_VECTOR_REMOVE(&stack, AST_VECTOR_SIZE(&stack) - 1, 1);
 
            /* If operand two is a field, then it must be a field we recognize. */
            if (op_two->token_type == TOKEN_TYPE_FIELD) {
                field = get_allowed_field(op_two);
                if (!field) {
                    ast_log(LOG_WARNING, "Unknown or unrecognized field: %s\n", op_two->field);
                    goto error;
                }
 
                type = field->return_type;
                value = field->get_field(entry);
            } else if (op_two->token_type == TOKEN_TYPE_RESULT) {
                type = OPT_INT_T;
                value = &op_two->result;
            } else {
                ast_log(LOG_WARNING, "Attempting to evaluate an operator: %s\n", op_two->op->symbol);
                goto error;
            }
 
            if (value) {
                res = it_queue->op->evaluate(it_queue->op, type, value, op_one) == 0 ? 0 : 1;
            } else {
                res = 0;
            }
        } else {
            ast_log(LOG_WARNING, "Operator '%s' has an invalid number of operands\n", it_queue->op->symbol);
            ast_assert(0);
            goto error;
        }
 
        /* Results are temporary; clean used ones up */
        if (op_one && op_one->token_type == TOKEN_TYPE_RESULT) {
            ast_free(op_one);
        }
        if (op_two && op_two->token_type == TOKEN_TYPE_RESULT) {
            ast_free(op_two);
        }
 
        /* Push the result onto the stack */
        result = expression_token_alloc(TOKEN_TYPE_RESULT, &res);
        if (!result) {
            goto error;
        }
        if (AST_VECTOR_APPEND(&stack, result)) {
            expression_token_free(result);
 
            goto error;
        }
    }
 
    /*
     * When the evaluation is complete, we must have:
     *  - A single result remaining on the stack
     *  - An actual result
     */
    if (AST_VECTOR_SIZE(&stack) != 1) {
        ast_log(LOG_WARNING, "Expression was unbalanced: %zu results remained after evaluation\n",
            AST_VECTOR_SIZE(&stack));
        goto error;
    }
 
    final = AST_VECTOR_GET(&stack, 0);
    if (final->token_type != TOKEN_TYPE_RESULT) {
        ast_log(LOG_WARNING, "Expression did not create a usable result\n");
        goto error;
    }
    result = final->result;
    ast_free(final);
    AST_VECTOR_FREE(&stack);
 
    return result;
 
error:
    /* Clean out any remaining result expression tokens */
    for (i = 0; i < AST_VECTOR_SIZE(&stack); i++) {
        struct expression_token *failed_token = AST_VECTOR_GET(&stack, i);
 
        if (failed_token->token_type == TOKEN_TYPE_RESULT) {
            ast_free(failed_token);
        }
    }
    AST_VECTOR_FREE(&stack);
    return -1;
}

References ast_assert, ast_free, ast_log, AST_VECTOR, AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, error(), operator::evaluate, operator::evaluate_unary, expression_token_alloc(), expression_token_free(), expression_token::field, get_allowed_field(), allowed_field::get_field, LOG_WARNING, expression_token::next, NULL, expression_token::op, operator::operands, OPT_INT_T, result, expression_token::result, allowed_field::return_type, operator::symbol, expression_token::token_type, TOKEN_TYPE_FIELD, TOKEN_TYPE_RESULT, type, and value.

Referenced by filter_history().

evaluate_less_than()

static int evaluate_less_than ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining if one operand is less than another.

Definition at line 242 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
    {
        int right;
 
        if (sscanf(op_right->field, "%30d", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not an integer\n", op_right->field);
            return -1;
        }
        return (*(int *)op_left) < right;
    }
    case OPT_DOUBLE_T:
    {
        double right;
 
        if (sscanf(op_right->field, "%lf", &right) != 1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a double\n", op_right->field);
            return -1;
        }
        return (*(double *)op_left) < right;
    }
    case OPT_NOOP_T:
    /* Used for timeval */
    {
        struct timeval right = { 0, };
 
        if ((right.tv_sec = ast_string_to_time_t(op_right->field)) == -1) {
            ast_log(LOG_WARNING, "Unable to extract field '%s': not a timestamp\n", op_right->field);
            return -1;
        }
 
        return ast_tvcmp(*(struct timeval *)op_left, right) == -1;
    }
    default:
        ast_log(LOG_WARNING, "Cannot evaluate field '%s': invalid type for operator '%s'\n",
            op_right->field, op->symbol);
    }
 
    return -1;
}

References ast_log, ast_string_to_time_t(), ast_tvcmp(), expression_token::field, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_DOUBLE_T, OPT_INT_T, OPT_NOOP_T, OPT_UINT_T, and type.

Referenced by evaluate_greater_than_or_equal().

evaluate_less_than_or_equal()

static int evaluate_less_than_or_equal ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining if one operand is less than or equal to another.

Definition at line 340 of file res_pjsip_history.c.

{
    return !evaluate_greater_than(op, type, op_left, op_right);
}

References evaluate_greater_than(), and type.

evaluate_like()

static int evaluate_like ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for regex 'like'.

Definition at line 410 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_CHAR_ARRAY_T:
    case OPT_STRINGFIELD_T:
    /* In our case, we operate on pj_str_t */
    {
        int result;
        regex_t regexbuf;
        char buf[pj_strlen(op_left) + 1];
 
        ast_copy_pj_str(buf, op_left, pj_strlen(op_left));
        if (regcomp(&regexbuf, op_right->field, REG_EXTENDED | REG_NOSUB)) {
            ast_log(LOG_WARNING, "Failed to compile '%s' into a regular expression\n", op_right->field);
            return -1;
        }
 
        result = (regexec(&regexbuf, buf, 0, NULL, 0) == 0);
        regfree(&regexbuf);
 
        return result;
    }
    default:
        ast_log(LOG_WARNING, "Cannot evaluate: invalid operand type for operator '%s'\n", op->symbol);
    }
 
    return -1;
}

References ast_copy_pj_str(), ast_log, buf, expression_token::field, LOG_WARNING, NULL, OPT_CHAR_ARRAY_T, OPT_STRINGFIELD_T, result, and type.

evaluate_not()

static int evaluate_not ( struct operator*  op, enum aco_option_type  type, void *  operand  )

static

Operator callback for determining logical NOT.

Definition at line 356 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
        return !(*(int *)operand);
    default:
        ast_log(LOG_WARNING, "Cannot evaluate: invalid operand type for operator '%s'\n", op->symbol);
    }
 
    return -1;
}

References ast_log, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_INT_T, OPT_UINT_T, and type.

evaluate_not_equal()

static int evaluate_not_equal ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining inequality.

Definition at line 234 of file res_pjsip_history.c.

{
    return !evaluate_equal(op, type, op_left, op_right);
}

References evaluate_equal(), and type.

evaluate_or()

static int evaluate_or ( struct operator*  op, enum aco_option_type  type, void *  op_left, struct expression_token *  op_right  )

static

Operator callback for determining logical OR.

Definition at line 392 of file res_pjsip_history.c.

{
    switch (type) {
    case OPT_BOOL_T:
    case OPT_BOOLFLAG_T:
    case OPT_INT_T:
    case OPT_UINT_T:
        return (*(int *)op_left || op_right->result);
    default:
        ast_log(LOG_WARNING, "Cannot evaluate: invalid operand type for operator '%s'\n", op->symbol);
    }
 
    return -1;
}

References ast_log, LOG_WARNING, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_INT_T, OPT_UINT_T, expression_token::result, and type.

expression_token_alloc()

static struct expression_token * expression_token_alloc ( enum expression_token_type  token_type, void *  value  )

static

Allocate an expression token.

Parameters

token_type	The type of token in the expression
value	The value/operator/result to pack into the token

Return values

NULL	on failure
expression_token	on success

Definition at line 547 of file res_pjsip_history.c.

{
    struct expression_token *token;
 
    switch (token_type) {
    case TOKEN_TYPE_RESULT:
    case TOKEN_TYPE_OPERATOR:
        token = ast_calloc(1, sizeof(*token));
        break;
    case TOKEN_TYPE_FIELD:
        token = ast_calloc(1, sizeof(*token) + strlen((const char *)value) + 1);
        break;
    default:
        ast_assert(0);
        return NULL;
    }
 
    if (!token) {
        return NULL;
    }
    token->token_type = token_type;
 
    switch (token_type) {
    case TOKEN_TYPE_RESULT:
        token->result = *(int *)value;
        break;
    case TOKEN_TYPE_OPERATOR:
        token->op = value;
        break;
    case TOKEN_TYPE_FIELD:
        strcpy(token->field, value); /* safe */
        break;
    default:
        ast_assert(0);
    }
 
    return token;
}

References ast_assert, ast_calloc, expression_token::field, NULL, expression_token::op, expression_token::result, expression_token::token_type, TOKEN_TYPE_FIELD, TOKEN_TYPE_OPERATOR, TOKEN_TYPE_RESULT, and value.

Referenced by build_expression_queue(), and evaluate_history_entry().

expression_token_free()

static struct expression_token * expression_token_free ( struct expression_token *  token )

static

Free an expression token and all others it references.

Definition at line 523 of file res_pjsip_history.c.

{
    struct expression_token *it_token;
 
    it_token = token;
    while (it_token) {
        struct expression_token *prev = it_token;
 
        it_token = it_token->next;
        ast_free(prev);
    }
 
    return NULL;
}

References ast_free, expression_token::next, and NULL.

Referenced by build_expression_queue(), evaluate_history_entry(), and filter_history().

filter_history()

static struct vector_history_t * filter_history ( struct ast_cli_args *  a )

static

Create a filtered history based on a user provided expression.

Parameters

a	The CLI arguments containing the expression

Return values

NULL	on error
A	vector containing the filtered history on success

Definition at line 1099 of file res_pjsip_history.c.

{
    struct vector_history_t *output;
    struct expression_token *queue;
    int i;
 
    output = ast_malloc(sizeof(*output));
    if (!output) {
        return NULL;
    }
 
    if (AST_VECTOR_INIT(output, HISTORY_INITIAL_SIZE / 2)) {
        ast_free(output);
        return NULL;
    }
 
    queue = build_expression_queue(a);
    if (!queue) {
        AST_VECTOR_PTR_FREE(output);
        return NULL;
    }
 
    ast_mutex_lock(&history_lock);
    for (i = 0; i < AST_VECTOR_SIZE(&vector_history); i++) {
        struct pjsip_history_entry *entry = AST_VECTOR_GET(&vector_history, i);
        int res;
 
        res = evaluate_history_entry(entry, queue);
        if (res == -1) {
            /* Error in expression evaluation; bail */
            ast_mutex_unlock(&history_lock);
            AST_VECTOR_RESET(output, clear_history_entry_cb);
            AST_VECTOR_FREE(output);
            ast_free(output);
            expression_token_free(queue);
            return NULL;
        } else if (!res) {
            continue;
        } else {
            ao2_bump(entry);
            if (AST_VECTOR_APPEND(output, entry)) {
                ao2_cleanup(entry);
            }
        }
    }
    ast_mutex_unlock(&history_lock);
 
    expression_token_free(queue);
 
    return output;
}

References a, ao2_bump, ao2_cleanup, ast_free, ast_malloc, ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_PTR_FREE, AST_VECTOR_RESET, AST_VECTOR_SIZE, build_expression_queue(), clear_history_entry_cb(), evaluate_history_entry(), expression_token_free(), HISTORY_INITIAL_SIZE, history_lock, NULL, and vector_history.

Referenced by pjsip_show_history().

get_allowed_field()

static struct allowed_field * get_allowed_field ( struct expression_token *  token )

static

Determine if the expression token matches a field in allowed_fields.

Definition at line 587 of file res_pjsip_history.c.

{
    int i;
 
    ast_assert(token->token_type == TOKEN_TYPE_FIELD);
 
    for (i = 0; i < ARRAY_LEN(allowed_fields); i++) {
        if (strcasecmp(allowed_fields[i].symbol, token->field)) {
            continue;
        }
 
        return &allowed_fields[i];
    }
 
    return NULL;
}

References allowed_fields, ARRAY_LEN, ast_assert, expression_token::field, NULL, allowed_field::symbol, expression_token::token_type, and TOKEN_TYPE_FIELD.

Referenced by evaluate_history_entry().

history_on_rx_msg()

static pj_bool_t history_on_rx_msg ( pjsip_rx_data *  rdata )

static

PJSIP callback when a SIP message is received.

Definition at line 728 of file res_pjsip_history.c.

{
    struct pjsip_history_entry *entry;
 
    if (!enabled) {
        return PJ_FALSE;
    }
 
    if (!rdata->msg_info.msg) {
        return PJ_FALSE;
    }
 
    entry = pjsip_history_entry_alloc(rdata->msg_info.msg);
    if (!entry) {
        return PJ_FALSE;
    }
 
    if (rdata->tp_info.transport->addr_len) {
        pj_sockaddr_cp(&entry->dst, &rdata->tp_info.transport->local_addr);
    }
 
    if (rdata->pkt_info.src_addr_len) {
        pj_sockaddr_cp(&entry->src, &rdata->pkt_info.src_addr);
    }
 
    ast_mutex_lock(&history_lock);
    if (AST_VECTOR_APPEND(&vector_history, entry)) {
        ao2_ref(entry, -1);
        entry = NULL;
    }
    ast_mutex_unlock(&history_lock);
 
    if (log_level != -1 && entry) {
        char line[256];
 
        sprint_list_entry(entry, line, sizeof(line));
        ast_log_dynamic_level(log_level, "%s\n", line);
    }
 
    return PJ_FALSE;
}

References ao2_ref, ast_log_dynamic_level, ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_APPEND, pjsip_history_entry::dst, enabled, history_lock, log_level, NULL, pjsip_history_entry_alloc(), sprint_list_entry(), pjsip_history_entry::src, and vector_history.

history_on_tx_msg()

static pj_status_t history_on_tx_msg ( pjsip_tx_data *  tdata )

static

PJSIP callback when a SIP message is transmitted.

Definition at line 694 of file res_pjsip_history.c.

{
    struct pjsip_history_entry *entry;
 
    if (!enabled) {
        return PJ_SUCCESS;
    }
 
    entry = pjsip_history_entry_alloc(tdata->msg);
    if (!entry) {
        return PJ_SUCCESS;
    }
    entry->transmitted = 1;
    pj_sockaddr_cp(&entry->src, &tdata->tp_info.transport->local_addr);
    pj_sockaddr_cp(&entry->dst, &tdata->tp_info.dst_addr);
 
    ast_mutex_lock(&history_lock);
    if (AST_VECTOR_APPEND(&vector_history, entry)) {
        ao2_ref(entry, -1);
        entry = NULL;
    }
    ast_mutex_unlock(&history_lock);
 
    if (log_level != -1 && entry) {
        char line[256];
 
        sprint_list_entry(entry, line, sizeof(line));
        ast_log_dynamic_level(log_level, "%s\n", line);
    }
 
    return PJ_SUCCESS;
}

References ao2_ref, ast_log_dynamic_level, ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_APPEND, pjsip_history_entry::dst, enabled, history_lock, log_level, NULL, pjsip_history_entry_alloc(), sprint_list_entry(), pjsip_history_entry::src, pjsip_history_entry::transmitted, and vector_history.

load_module()

static int load_module ( void  )

static

Definition at line 1370 of file res_pjsip_history.c.

{
    log_level = ast_logger_register_level("PJSIP_HISTORY");
    if (log_level < 0) {
        ast_log(LOG_WARNING, "Unable to register history log level\n");
    }
 
    ast_pjproject_caching_pool_init(&cachingpool, &pj_pool_factory_default_policy, 0);
 
    AST_VECTOR_INIT(&vector_history, HISTORY_INITIAL_SIZE);
 
    ast_sip_register_service(&logging_module);
    ast_cli_register_multiple(cli_pjsip, ARRAY_LEN(cli_pjsip));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ARRAY_LEN, ast_cli_register_multiple, ast_log, ast_logger_register_level(), AST_MODULE_LOAD_SUCCESS, ast_pjproject_caching_pool_init(), ast_sip_register_service(), AST_VECTOR_INIT, cachingpool, cli_pjsip, HISTORY_INITIAL_SIZE, log_level, LOG_WARNING, logging_module, and vector_history.

pjsip_history_entry_alloc()

static struct pjsip_history_entry * pjsip_history_entry_alloc ( pjsip_msg *  msg )

static

Create a pjsip_history_entry AO2 object.

Parameters

msg	The PJSIP message that this history entry wraps

Return values

An	AO2 pjsip_history_entry object on success
NULL	on failure

Definition at line 628 of file res_pjsip_history.c.

{
    struct pjsip_history_entry *entry;
 
    entry = ao2_alloc_options(sizeof(*entry), pjsip_history_entry_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!entry) {
        return NULL;
    }
    entry->number = ast_atomic_fetchadd_int(&packet_number, 1);
    entry->timestamp = ast_tvnow();
    entry->timestamp.tv_usec = 0;
 
    entry->pool = pj_pool_create(&cachingpool.factory, NULL, PJSIP_POOL_RDATA_LEN,
                                 PJSIP_POOL_RDATA_INC, NULL);
    if (!entry->pool) {
        ao2_ref(entry, -1);
        return NULL;
    }
 
    entry->msg = pjsip_msg_clone(entry->pool, msg);
    if (!entry->msg) {
        ao2_ref(entry, -1);
        return NULL;
    }
 
    return entry;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_atomic_fetchadd_int(), ast_tvnow(), cachingpool, pjsip_history_entry::msg, NULL, pjsip_history_entry::number, packet_number, pjsip_history_entry_dtor(), pjsip_history_entry::pool, and pjsip_history_entry::timestamp.

Referenced by history_on_rx_msg(), and history_on_tx_msg().

pjsip_history_entry_dtor()

static void pjsip_history_entry_dtor ( void *  obj )

static

AO2 destructor for pjsip_history_entry.

Definition at line 605 of file res_pjsip_history.c.

{
    struct pjsip_history_entry *entry = obj;
 
    if (entry->pool) {
        /* This mimics the behavior of pj_pool_safe_release
         * which was introduced in pjproject 2.6.
         */
        pj_pool_t *temp_pool = entry->pool;
 
        entry->pool = NULL;
        pj_pool_release(temp_pool);
    }
}

References NULL, and pjsip_history_entry::pool.

Referenced by pjsip_history_entry_alloc().

pjsip_set_history()

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

static

Definition at line 1314 of file res_pjsip_history.c.

{
    const char *what;
 
    if (cmd == CLI_INIT) {
        e->command = "pjsip set history {on|off|clear}";
        e->usage =
            "Usage: pjsip set history {on|off|clear}\n"
            "       Enables/disables/clears the PJSIP history.\n\n"
            "       Enabling the history will start recording transmitted/received\n"
            "       packets. Disabling the history will stop recording, but keep\n"
            "       the already received packets. Clearing the history will wipe\n"
            "       the received packets from memory.\n\n"
            "       As the PJSIP history is maintained in memory, and includes\n"
            "       all received/transmitted requests and responses, it should\n"
            "       only be enabled for debugging purposes, and cleared when done.\n";
        return NULL;
    } else if (cmd == CLI_GENERATE) {
        return NULL;
    }
 
    what = a->argv[e->args - 1];    /* Guaranteed to exist */
 
    if (a->argc == e->args) {
        if (!strcasecmp(what, "on")) {
            enabled = 1;
            ast_cli(a->fd, "PJSIP History enabled\n");
            return CLI_SUCCESS;
        } else if (!strcasecmp(what, "off")) {
            enabled = 0;
            ast_cli(a->fd, "PJSIP History disabled\n");
            return CLI_SUCCESS;
        } else if (!strcasecmp(what, "clear")) {
            ast_sip_push_task(NULL, clear_history_entries, NULL);
            ast_cli(a->fd, "PJSIP History cleared\n");
            return CLI_SUCCESS;
        }
    }
 
    return CLI_SHOWUSAGE;
}

References a, ast_cli_entry::args, ast_cli(), ast_sip_push_task(), clear_history_entries(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, enabled, NULL, and ast_cli_entry::usage.

pjsip_show_history()

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

static

Definition at line 1220 of file res_pjsip_history.c.

{
    struct vector_history_t *vec = &vector_history;
    struct pjsip_history_entry *entry = NULL;
 
    if (cmd == CLI_INIT) {
        e->command = "pjsip show history";
        e->usage =
            "Usage: pjsip show history [entry <num>|where [...]]\n"
            "       Displays the currently collected history or an\n"
            "       entry within the history.\n\n"
            "       * Running the command with no options will display\n"
            "         the entire history.\n"
            "       * Providing 'entry <num>' will display the full\n"
            "         detail of a particular entry in this history.\n"
            "       * Providing 'where ...' will allow for filtering\n"
            "         the history. The history can be filtered using\n"
            "         any of the following fields:\n"
            "         - number: The history entry number\n"
            "         - timestamp: The time associated with the history entry\n"
            "         - addr: The source/destination address of the SIP message\n"
            "         - sip.msg.request.method: The request method type\n"
            "         - sip.msg.call-id: The Call-ID header of the SIP message\n"
            "\n"
            "         When filtering, standard Boolean operators can be used,\n"
            "         as well as 'like' for regexs.\n"
            "\n"
            "         Example:\n"
            "         'pjsip show history where number > 5 and (addr = \"192.168.0.3:5060\" or addr = \"192.168.0.5:5060\")'\n";
        return NULL;
    } else if (cmd == CLI_GENERATE) {
        return NULL;
    }
 
    if (a->argc > 3) {
        if (!strcasecmp(a->argv[3], "entry") && a->argc == 5) {
            int num;
 
            if (sscanf(a->argv[4], "%30d", &num) != 1) {
                ast_cli(a->fd, "'%s' is not a valid entry number\n", a->argv[4]);
                return CLI_FAILURE;
            }
 
            /* Get the entry at the provided position */
            ast_mutex_lock(&history_lock);
            if (num >= AST_VECTOR_SIZE(&vector_history) || num < 0) {
                ast_cli(a->fd, "Entry '%d' does not exist\n", num);
                ast_mutex_unlock(&history_lock);
                return CLI_FAILURE;
            }
            entry = ao2_bump(AST_VECTOR_GET(&vector_history, num));
            ast_mutex_unlock(&history_lock);
        } else if (!strcasecmp(a->argv[3], "where")) {
            vec = filter_history(a);
            if (!vec) {
                return CLI_FAILURE;
            }
        } else {
            return CLI_SHOWUSAGE;
        }
    }
 
    if (AST_VECTOR_SIZE(vec) == 1) {
        if (vec == &vector_history) {
            ast_mutex_lock(&history_lock);
        }
        entry = ao2_bump(AST_VECTOR_GET(vec, 0));
        if (vec == &vector_history) {
            ast_mutex_unlock(&history_lock);
        }
    }
 
    if (entry) {
        display_single_entry(a, entry);
    } else {
        if (vec == &vector_history) {
            ast_mutex_lock(&history_lock);
        }
 
        display_entry_list(a, vec);
 
        if (vec == &vector_history) {
            ast_mutex_unlock(&history_lock);
        }
    }
 
    if (vec != &vector_history) {
        ast_sip_push_task(NULL, safe_vector_cleanup, vec);
    }
    ao2_cleanup(entry);
 
    return CLI_SUCCESS;
}

References a, ao2_bump, ao2_cleanup, ast_cli(), ast_mutex_lock, ast_mutex_unlock, ast_sip_push_task(), AST_VECTOR_GET, AST_VECTOR_SIZE, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, display_entry_list(), display_single_entry(), filter_history(), history_lock, NULL, safe_vector_cleanup(), ast_cli_entry::usage, and vector_history.

safe_vector_cleanup()

static int safe_vector_cleanup ( void *  obj )

static

Cleanup routine for a history vector, serviced on a registered PJSIP thread.

Definition at line 1209 of file res_pjsip_history.c.

{
    struct vector_history_t *vec = obj;
 
    AST_VECTOR_RESET(vec, clear_history_entry_cb);
    AST_VECTOR_FREE(vec);
    ast_free(vec);
 
    return 0;
}

References ast_free, AST_VECTOR_FREE, AST_VECTOR_RESET, and clear_history_entry_cb().

Referenced by pjsip_show_history().

sprint_list_entry()

static void sprint_list_entry ( struct pjsip_history_entry *  entry, char *  line, int  len  )

static

Format single line history entry.

Definition at line 657 of file res_pjsip_history.c.

{
    char addr[64], secs[AST_TIME_T_LEN];
 
    if (entry->transmitted) {
        pj_sockaddr_print(&entry->dst, addr, sizeof(addr), 3);
    } else {
        pj_sockaddr_print(&entry->src, addr, sizeof(addr), 3);
    }
 
    ast_time_t_to_string(entry->timestamp.tv_sec, secs, sizeof(secs));
 
    if (entry->msg->type == PJSIP_REQUEST_MSG) {
        char uri[128];
 
        pjsip_uri_print(PJSIP_URI_IN_REQ_URI, entry->msg->line.req.uri, uri, sizeof(uri));
        snprintf(line, len, "%-5.5d %-10.10s %-5.5s %-24.24s %.*s %s SIP/2.0",
            entry->number,
            secs,
            entry->transmitted ? "* ==>" : "* <==",
            addr,
            (int)pj_strlen(&entry->msg->line.req.method.name),
            pj_strbuf(&entry->msg->line.req.method.name),
            uri);
    } else {
        snprintf(line, len, "%-5.5d %-10.10s %-5.5s %-24.24s SIP/2.0 %u %.*s",
            entry->number,
            secs,
            entry->transmitted ? "* ==>" : "* <==",
            addr,
            entry->msg->line.status.code,
            (int)pj_strlen(&entry->msg->line.status.reason),
            pj_strbuf(&entry->msg->line.status.reason));
    }
}

References AST_TIME_T_LEN, ast_time_t_to_string(), pjsip_history_entry::dst, len(), pjsip_history_entry::msg, pjsip_history_entry::number, pjsip_history_entry::src, pjsip_history_entry::timestamp, and pjsip_history_entry::transmitted.

Referenced by display_entry_list(), history_on_rx_msg(), and history_on_tx_msg().

unload_module()

static int unload_module ( void  )

static

Definition at line 1387 of file res_pjsip_history.c.

{
    ast_cli_unregister_multiple(cli_pjsip, ARRAY_LEN(cli_pjsip));
    ast_sip_unregister_service(&logging_module);
 
    ast_sip_push_task_wait_servant(NULL, clear_history_entries, NULL);
    AST_VECTOR_FREE(&vector_history);
 
    ast_pjproject_caching_pool_destroy(&cachingpool);
 
    if (log_level != -1) {
        ast_logger_unregister_level("PJSIP_HISTORY");
    }
 
    return 0;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_logger_unregister_level(), ast_pjproject_caching_pool_destroy(), ast_sip_push_task_wait_servant(), ast_sip_unregister_service(), AST_VECTOR_FREE, cachingpool, clear_history_entries(), cli_pjsip, log_level, logging_module, NULL, and vector_history.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP History" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", }

static

Definition at line 1410 of file res_pjsip_history.c.

allowed_fields

struct allowed_field allowed_fields[]

static

The fields we allow.

Definition at line 513 of file res_pjsip_history.c.

                                               {
    { .symbol = "number", .return_type = OPT_INT_T, .get_field = entry_get_number, },
    /* We co-op the NOOP type here for timeval */
    { .symbol = "timestamp", .return_type = OPT_NOOP_T, .get_field = entry_get_timestamp, },
    { .symbol = "addr", .return_type = OPT_SOCKADDR_T, .get_field = entry_get_addr, },
    { .symbol = "sip.msg.request.method", .return_type = OPT_CHAR_ARRAY_T, .get_field = entry_get_sip_msg_request_method, },
    { .symbol = "sip.msg.call-id", .return_type = OPT_CHAR_ARRAY_T, .get_field = entry_get_sip_msg_call_id, },
};

Referenced by get_allowed_field().

allowed_operators

struct operator allowed_operators[]

static

Our allowed operations.

Definition at line 453 of file res_pjsip_history.c.

                                             {
    { .symbol = "=", .precedence = 7, .operands = 2, .evaluate = evaluate_equal, },
    { .symbol = "==", .precedence = 7, .operands = 2, .evaluate = evaluate_equal, },
    { .symbol = "!=", .precedence = 7, .operands = 2, .evaluate = evaluate_not_equal, },
    { .symbol = "<", .precedence = 6, .operands = 2, .evaluate = evaluate_less_than, },
    { .symbol = ">", .precedence = 6, .operands = 2, .evaluate = evaluate_greater_than, },
    { .symbol = "<=", .precedence = 6, .operands = 2, .evaluate = evaluate_less_than_or_equal, },
    { .symbol = ">=", .precedence = 6, .operands = 2, .evaluate = evaluate_greater_than_or_equal, },
    { .symbol = "!", .precedence = 2, .operands = 1, .right_to_left = 1, .evaluate_unary = evaluate_not, },
    { .symbol = "&&", .precedence = 11, .operands = 2, .evaluate = evaluate_and, },
    { .symbol = "||", .precedence = 12, .operands = 2, .evaluate = evaluate_or, },
    { .symbol = "like", .precedence = 7, .operands = 2, .evaluate = evaluate_like, },
    { .symbol = "and", .precedence = 11, .operands = 2, .evaluate = evaluate_and, },
    { .symbol = "or", .precedence = 11, .operands = 2, .evaluate = evaluate_or, },
    { .symbol = "not", .precedence = 2, .operands = 1, .right_to_left = 1, .evaluate_unary = evaluate_not, },
};

Referenced by build_expression_queue().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1410 of file res_pjsip_history.c.

cachingpool

pj_caching_pool cachingpool

static

Pool factory used by pjlib to allocate memory.

Definition at line 50 of file res_pjsip_history.c.

Referenced by load_module(), load_module(), pjsip_history_entry_alloc(), and unload_module().

cli_pjsip

struct ast_cli_entry cli_pjsip[]

static

Initial value:

= {
    { .handler =  pjsip_set_history , .summary =  "Enable/Disable PJSIP History" ,},
    { .handler =  pjsip_show_history , .summary =  "Display PJSIP History" ,},
}

Definition at line 1365 of file res_pjsip_history.c.

                                          {
    AST_CLI_DEFINE(pjsip_set_history, "Enable/Disable PJSIP History"),
    AST_CLI_DEFINE(pjsip_show_history, "Display PJSIP History"),
};

Referenced by load_module(), and unload_module().

enabled

int enabled

static

Whether or not we are storing history.

Definition at line 53 of file res_pjsip_history.c.

Referenced by history_on_rx_msg(), history_on_tx_msg(), and pjsip_set_history().

history_lock

ast_mutex_t history_lock = AST_MUTEX_INIT_VALUE

static

Mutex that protects vector_history.

Definition at line 77 of file res_pjsip_history.c.

Referenced by clear_history_entries(), filter_history(), history_on_rx_msg(), history_on_tx_msg(), and pjsip_show_history().

left_paren

struct operator left_paren

static

Initial value:

= {
    .symbol = "(",
    .precedence = 15
}

Operator token for a left parenthesis.

While this is used by the shunting-yard algorithm implementation, it should never appear in the resulting RPN queue of expression tokens

Definition at line 445 of file res_pjsip_history.c.

                                    {
    .symbol = "(",
    .precedence = 15
};

Referenced by build_expression_queue().

log_level

int log_level = -1

static

Log level for history output.

Definition at line 159 of file res_pjsip_history.c.

Referenced by history_on_rx_msg(), history_on_tx_msg(), load_module(), unload_module(), and verify_log_result().

logging_module

pjsip_module logging_module

static

Definition at line 1356 of file res_pjsip_history.c.

                                     {
    .name = { "History Module", 14 },
    .priority = 0,
    .on_rx_request = history_on_rx_msg,
    .on_rx_response = history_on_rx_msg,
    .on_tx_request = history_on_tx_msg,
    .on_tx_response = history_on_tx_msg,
};

Referenced by load_module(), and unload_module().

packet_number

int packet_number

static

Packet count.

Definition at line 56 of file res_pjsip_history.c.

Referenced by clear_history_entries(), and pjsip_history_entry_alloc().

vector_history

struct vector_history_t vector_history

static

Referenced by clear_history_entries(), filter_history(), history_on_rx_msg(), history_on_tx_msg(), load_module(), pjsip_show_history(), and unload_module().