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. More...
static int	clear_history_entries (void *obj)
	Remove all entries from vector_history. More...
static void	clear_history_entry_cb (struct pjsip_history_entry *entry)
	Vector callback that releases the reference for the entry in a history vector. More...
static void	display_entry_list (struct ast_cli_args *a, struct vector_history_t *vec)
	Print a list of the entries to the CLI. More...
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. More...
static void *	entry_get_addr (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's destination address. More...
static void *	entry_get_number (struct pjsip_history_entry *entry)
	Callback to retrieve the entry index number. More...
static void *	entry_get_sip_msg_call_id (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's SIP Call-ID header. More...
static void *	entry_get_sip_msg_request_method (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's SIP request method type. More...
static void *	entry_get_timestamp (struct pjsip_history_entry *entry)
	Callback to retrieve the entry's timestamp. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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'. More...
static int	evaluate_not (struct operator*op, enum aco_option_type type, void *operand)
	Operator callback for determining logical NOT. More...
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. More...
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. More...
static struct expression_token *	expression_token_alloc (enum expression_token_type token_type, void *value)
	Allocate an expression token. More...
static struct expression_token *	expression_token_free (struct expression_token *token)
	Free an expression token and all others it references. More...
static struct vector_history_t *	filter_history (struct ast_cli_args *a)
	Create a filtered history based on a user provided expression. More...
static struct allowed_field *	get_allowed_field (struct expression_token *token)
	Determine if the expression token matches a field in allowed_fields. More...
static pj_bool_t	history_on_rx_msg (pjsip_rx_data *rdata)
	PJSIP callback when a SIP message is received. More...
static pj_status_t	history_on_tx_msg (pjsip_tx_data *tdata)
	PJSIP callback when a SIP message is transmitted. More...
static int	load_module (void)
static struct pjsip_history_entry *	pjsip_history_entry_alloc (pjsip_msg *msg)
	Create a pjsip_history_entry AO2 object. More...
static void	pjsip_history_entry_dtor (void *obj)
	AO2 destructor for pjsip_history_entry. More...
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. More...
static void	sprint_list_entry (struct pjsip_history_entry *entry, char *line, int len)
	Format single line history entry. More...
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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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. More...
static struct operator	allowed_operators []
	Our allowed operations. More...
static const struct ast_module_info *	ast_module_info = &__mod_info
static pj_caching_pool	cachingpool
	Pool factory used by pjlib to allocate memory. More...
static struct ast_cli_entry	cli_pjsip []
static int	enabled
	Whether or not we are storing history. More...
static ast_mutex_t	history_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Mutex that protects vector_history. More...
static struct operator	left_paren
	Operator token for a left parenthesis. More...
static int	log_level = -1
	Log level for history output. More...
static pjsip_module	logging_module
static int	packet_number
	Packet count. More...
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, and LOG_WARNING.

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

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

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

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

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, enabled, history_lock, log_level, NULL, pjsip_history_entry_alloc(), sprint_list_entry(), 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, enabled, history_lock, log_level, NULL, pjsip_history_entry_alloc(), sprint_list_entry(), 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, packet_number, and pjsip_history_entry_dtor().

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.

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

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

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.

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

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 = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

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.

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.

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