res_pjsip_messaging.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/message.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/test.h"
#include "asterisk/uri.h"

Include dependency graph for res_pjsip_messaging.c:

Go to the source code of this file.

Data Structures
struct	msg_data

Macros
#define	MAX_BODY_SIZE   1024
#define	MAX_HDR_SIZE   512
#define	MAX_USER_SIZE   128

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static enum pjsip_status_code	check_content_type (const pjsip_rx_data *rdata)
static enum pjsip_status_code	check_content_type_in_dialog (const pjsip_rx_data *rdata)
static int	headers_to_vars (const pjsip_rx_data *rdata, struct ast_msg *msg)
static int	incoming_in_dialog_request (struct ast_sip_session *session, struct pjsip_rx_data *rdata)
static int	is_msg_var_blocked (const char *name)
static int	load_module (void)
static pj_bool_t	module_on_rx_request (pjsip_rx_data *rdata)
static struct msg_data *	msg_data_create (const struct ast_msg *msg, const char *destination, const char *from)
static void	msg_data_destroy (void *obj)
static int	msg_send (void *data)
static int	print_body (pjsip_rx_data *rdata, char *buf, int len)
static enum pjsip_status_code	rx_data_to_ast_msg (pjsip_rx_data *rdata, struct ast_msg *msg)
static pj_status_t	send_response (pjsip_rx_data *rdata, enum pjsip_status_code code, pjsip_dialog *dlg, pjsip_transaction *tsx)
static int	sip_msg_send (const struct ast_msg *msg, const char *destination, const char *from)
static char *	sip_to_pjsip (char *buf, int size, int capacity)
static int	unload_module (void)
static void	update_content_type (pjsip_tx_data *tdata, struct ast_msg *msg, struct ast_sip_body *body)
static int	update_to_display_name (pjsip_tx_data *tdata, char *to)
static enum pjsip_status_code	vars_to_headers (const struct ast_msg *msg, pjsip_tx_data *tdata)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Messaging Support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip,res_pjsip_session", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_taskprocessor *	message_serializer
static pjsip_module	messaging_module
static struct ast_sip_session_supplement	messaging_supplement
static const struct ast_msg_tech	msg_tech
const pjsip_method	pjsip_message_method = {PJSIP_OTHER_METHOD, {"MESSAGE", 7} }

Macro Definition Documentation

MAX_BODY_SIZE

#define MAX_BODY_SIZE   1024

Definition at line 137 of file res_pjsip_messaging.c.

MAX_HDR_SIZE

#define MAX_HDR_SIZE   512

Definition at line 136 of file res_pjsip_messaging.c.

MAX_USER_SIZE

#define MAX_USER_SIZE   128

Definition at line 138 of file res_pjsip_messaging.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1021 of file res_pjsip_messaging.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1021 of file res_pjsip_messaging.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1021 of file res_pjsip_messaging.c.

check_content_type()

static enum pjsip_status_code check_content_type ( const pjsip_rx_data *  rdata )

static

Definition at line 151 of file res_pjsip_messaging.c.

{
    int res;
    if (rdata->msg_info.msg->body && rdata->msg_info.msg->body->len) {
        res = ast_sip_is_content_type(
            &rdata->msg_info.msg->body->content_type, "text", "plain");
    } else {
        res = rdata->msg_info.ctype &&
            ast_sip_is_content_type(
                &rdata->msg_info.ctype->media, "text", "plain");
    }
 
    return res ? PJSIP_SC_OK : PJSIP_SC_UNSUPPORTED_MEDIA_TYPE;
}

References ast_sip_is_content_type().

Referenced by module_on_rx_request().

check_content_type_in_dialog()

static enum pjsip_status_code check_content_type_in_dialog ( const pjsip_rx_data *  rdata )

static

Definition at line 175 of file res_pjsip_messaging.c.

{
    int res = PJSIP_SC_UNSUPPORTED_MEDIA_TYPE;
    static const pj_str_t text = { "text", 4};
    static const pj_str_t application = { "application", 11};
 
    if (!(rdata->msg_info.msg->body && rdata->msg_info.msg->body->len > 0)) {
        return res;
    }
 
    /* We'll accept any text/ or application/ content type */
    if (pj_stricmp(&rdata->msg_info.msg->body->content_type.type, &text) == 0
            || pj_stricmp(&rdata->msg_info.msg->body->content_type.type, &application) == 0) {
        res = PJSIP_SC_OK;
    } else if (rdata->msg_info.ctype
        && (pj_stricmp(&rdata->msg_info.ctype->media.type, &text) == 0
        || pj_stricmp(&rdata->msg_info.ctype->media.type, &application) == 0)) {
        res = PJSIP_SC_OK;
    }
 
    return res;
}

References text.

Referenced by incoming_in_dialog_request().

headers_to_vars()

static int headers_to_vars ( const pjsip_rx_data *  rdata, struct ast_msg *  msg  )

static

Definition at line 310 of file res_pjsip_messaging.c.

{
    char *c;
    char name[MAX_HDR_SIZE];
    char buf[MAX_HDR_SIZE];
    int res = 0;
    pjsip_hdr *h = rdata->msg_info.msg->hdr.next;
    pjsip_hdr *end= &rdata->msg_info.msg->hdr;
 
    while (h != end) {
        if ((res = pjsip_hdr_print_on(h, buf, sizeof(buf)-1)) > 0) {
            buf[res] = '\0';
            if ((c = strchr(buf, ':'))) {
                ast_copy_string(buf, ast_skip_blanks(c + 1), sizeof(buf));
            }
 
            ast_copy_pj_str(name, &h->name, sizeof(name));
            if ((res = ast_msg_set_var(msg, name, buf)) != 0) {
                break;
            }
        }
        h = h->next;
    }
    return 0;
}

References ast_copy_pj_str(), ast_copy_string(), ast_msg_set_var(), ast_skip_blanks(), buf, c, end, MAX_HDR_SIZE, name, and test_val::next.

Referenced by rx_data_to_ast_msg().

incoming_in_dialog_request()

static int incoming_in_dialog_request ( struct ast_sip_session *  session, struct pjsip_rx_data *  rdata  )

static

Definition at line 867 of file res_pjsip_messaging.c.

{
    enum pjsip_status_code code;
    int rc;
    pjsip_dialog *dlg = session->inv_session->dlg;
    pjsip_transaction *tsx = pjsip_rdata_get_tsx(rdata);
    struct ast_msg_data *msg;
    struct ast_party_caller *caller;
    pjsip_name_addr *name_addr;
    size_t from_len;
    size_t to_len;
    struct ast_msg_data_attribute attrs[4];
    int pos = 0;
    int body_pos;
 
    if (!session->channel) {
        send_response(rdata, PJSIP_SC_NOT_FOUND, dlg, tsx);
        return 0;
    }
 
    code = check_content_type_in_dialog(rdata);
    if (code != PJSIP_SC_OK) {
        send_response(rdata, code, dlg, tsx);
        return 0;
    }
 
    caller = ast_channel_caller(session->channel);
 
    name_addr = (pjsip_name_addr *) rdata->msg_info.from->uri;
    from_len = pj_strlen(&name_addr->display);
    if (from_len) {
        attrs[pos].type = AST_MSG_DATA_ATTR_FROM;
        from_len++;
        attrs[pos].value = ast_alloca(from_len);
        ast_copy_pj_str(attrs[pos].value, &name_addr->display, from_len);
        pos++;
    } else if (caller->id.name.valid && !ast_strlen_zero(caller->id.name.str)) {
        attrs[pos].type = AST_MSG_DATA_ATTR_FROM;
        attrs[pos].value = caller->id.name.str;
        pos++;
    }
 
    name_addr = (pjsip_name_addr *) rdata->msg_info.to->uri;
    to_len = pj_strlen(&name_addr->display);
    if (to_len) {
        attrs[pos].type = AST_MSG_DATA_ATTR_TO;
        to_len++;
        attrs[pos].value = ast_alloca(to_len);
        ast_copy_pj_str(attrs[pos].value, &name_addr->display, to_len);
        pos++;
    }
 
    attrs[pos].type = AST_MSG_DATA_ATTR_CONTENT_TYPE;
    attrs[pos].value = ast_alloca(rdata->msg_info.msg->body->content_type.type.slen
        + rdata->msg_info.msg->body->content_type.subtype.slen + 2);
    sprintf(attrs[pos].value, "%.*s/%.*s",
        (int)rdata->msg_info.msg->body->content_type.type.slen,
        rdata->msg_info.msg->body->content_type.type.ptr,
        (int)rdata->msg_info.msg->body->content_type.subtype.slen,
        rdata->msg_info.msg->body->content_type.subtype.ptr);
    pos++;
 
    body_pos = pos;
    attrs[pos].type = AST_MSG_DATA_ATTR_BODY;
    attrs[pos].value = ast_malloc(rdata->msg_info.msg->body->len + 1);
    if (!attrs[pos].value) {
        send_response(rdata, PJSIP_SC_INTERNAL_SERVER_ERROR, dlg, tsx);
        return 0;
    }
    ast_copy_string(attrs[pos].value, rdata->msg_info.msg->body->data, rdata->msg_info.msg->body->len + 1);
    pos++;
 
    msg = ast_msg_data_alloc(AST_MSG_DATA_SOURCE_TYPE_IN_DIALOG, attrs, pos);
    if (!msg) {
        ast_free(attrs[body_pos].value);
        send_response(rdata, PJSIP_SC_INTERNAL_SERVER_ERROR, dlg, tsx);
        return 0;
    }
 
    ast_debug(1, "Received in-dialog MESSAGE from '%s:%s': %s %s\n",
        ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_FROM),
        ast_channel_name(session->channel),
        ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_TO),
        ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_BODY));
 
    rc = ast_msg_data_queue_frame(session->channel, msg);
    ast_free(attrs[body_pos].value);
    ast_free(msg);
    if (rc != 0) {
        send_response(rdata, PJSIP_SC_INTERNAL_SERVER_ERROR, dlg, tsx);
    } else {
        send_response(rdata, PJSIP_SC_ACCEPTED, dlg, tsx);
    }
 
    return 0;
}

References ast_alloca, ast_channel_caller(), ast_channel_name(), ast_copy_pj_str(), ast_copy_string(), ast_debug, ast_free, ast_malloc, ast_msg_data_alloc(), AST_MSG_DATA_ATTR_BODY, AST_MSG_DATA_ATTR_CONTENT_TYPE, AST_MSG_DATA_ATTR_FROM, AST_MSG_DATA_ATTR_TO, ast_msg_data_get_attribute(), ast_msg_data_queue_frame(), AST_MSG_DATA_SOURCE_TYPE_IN_DIALOG, ast_strlen_zero(), check_content_type_in_dialog(), ast_party_caller::id, ast_party_id::name, send_response(), session, ast_party_name::str, ast_msg_data_attribute::type, ast_party_name::valid, ast_msg_data_attribute::value, and value.

is_msg_var_blocked()

static int is_msg_var_blocked ( const char *  name )

static

Definition at line 240 of file res_pjsip_messaging.c.

{
    int i;
 
    /* Don't block the Max-Forwards header because the user can override it */
    static const char *hdr[] = {
        "To",
        "From",
        "Via",
        "Route",
        "Contact",
        "Call-ID",
        "CSeq",
        "Allow",
        "Content-Length",
        "Content-Type",
        "Request-URI",
    };
 
    for (i = 0; i < ARRAY_LEN(hdr); ++i) {
        if (!strcasecmp(name, hdr[i])) {
            /* Block addition of this header. */
            return 1;
        }
    }
    return 0;
}

References ARRAY_LEN, and name.

Referenced by vars_to_headers().

load_module()

static int load_module ( void  )

static

Definition at line 976 of file res_pjsip_messaging.c.

{
    if (ast_sip_register_service(&messaging_module) != PJ_SUCCESS) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(),
                       NULL, PJSIP_H_ALLOW, NULL, 1,
                       &pjsip_message_method.name) != PJ_SUCCESS) {
 
        ast_sip_unregister_service(&messaging_module);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_msg_tech_register(&msg_tech)) {
        ast_sip_unregister_service(&messaging_module);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    message_serializer = ast_sip_create_serializer("pjsip/messaging");
    if (!message_serializer) {
        ast_sip_unregister_service(&messaging_module);
        ast_msg_tech_unregister(&msg_tech);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sip_session_register_supplement(&messaging_supplement);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_msg_tech_register(), ast_msg_tech_unregister(), ast_sip_create_serializer(), ast_sip_get_pjsip_endpoint(), ast_sip_register_service(), ast_sip_session_register_supplement, ast_sip_unregister_service(), message_serializer, messaging_module, messaging_supplement, msg_tech, NULL, and pjsip_message_method.

module_on_rx_request()

static pj_bool_t module_on_rx_request ( pjsip_rx_data *  rdata )

static

Definition at line 817 of file res_pjsip_messaging.c.

{
    enum pjsip_status_code code;
    struct ast_msg *msg;
 
    /* if not a MESSAGE, don't handle */
    if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_message_method)) {
        return PJ_FALSE;
    }
 
    code = check_content_type(rdata);
    if (code != PJSIP_SC_OK) {
        send_response(rdata, code, NULL, NULL);
        return PJ_TRUE;
    }
 
    msg = ast_msg_alloc();
    if (!msg) {
        send_response(rdata, PJSIP_SC_INTERNAL_SERVER_ERROR, NULL, NULL);
        return PJ_TRUE;
    }
 
    code = rx_data_to_ast_msg(rdata, msg);
    if (code != PJSIP_SC_OK) {
        send_response(rdata, code, NULL, NULL);
        ast_msg_destroy(msg);
        return PJ_TRUE;
    }
 
    if (!ast_msg_has_destination(msg)) {
        ast_debug(1, "MESSAGE request received, but no handler wanted it\n");
        send_response(rdata, PJSIP_SC_NOT_FOUND, NULL, NULL);
        ast_msg_destroy(msg);
        return PJ_TRUE;
    }
 
    /* Send it to the messaging core.
     *
     * If we are unable to send a response, the most likely reason is that we
     * are handling a retransmission of an incoming MESSAGE and were unable to
     * create a transaction due to a duplicate key. If we are unable to send
     * a response, we should not queue the message to the dialplan
     */
    if (!send_response(rdata, PJSIP_SC_ACCEPTED, NULL, NULL)) {
        ast_msg_queue(msg);
    }
 
    return PJ_TRUE;
}

References ast_debug, ast_msg_alloc(), ast_msg_destroy(), ast_msg_has_destination(), ast_msg_queue(), check_content_type(), NULL, pjsip_message_method, rx_data_to_ast_msg(), and send_response().

msg_data_create()

static struct msg_data * msg_data_create ( const struct ast_msg *  msg, const char *  destination, const char *  from  )

static

Definition at line 559 of file res_pjsip_messaging.c.

{
    struct msg_data *mdata = ao2_alloc(sizeof(*mdata), msg_data_destroy);
 
    if (!mdata) {
        return NULL;
    }
 
    /* typecast to suppress const warning */
    mdata->msg = ast_msg_ref((struct ast_msg *) msg);
 
    /* To starts with 'pjsip:' which needs to be removed. */
    if (!(destination = strchr(destination, ':'))) {
        ao2_ref(mdata, -1);
        return NULL;
    }
    ++destination;/* Now skip the ':' */
 
    mdata->destination = ast_strdup(destination);
    mdata->from = ast_strdup(from);
 
    return mdata;
}

References ao2_alloc, ao2_ref, ast_msg_ref(), ast_strdup, msg_data::destination, msg_data::from, msg_data::msg, msg_data_destroy(), and NULL.

Referenced by sip_msg_send().

msg_data_destroy()

static void msg_data_destroy ( void *  obj )

static

Definition at line 549 of file res_pjsip_messaging.c.

{
    struct msg_data *mdata = obj;
 
    ast_free(mdata->from);
    ast_free(mdata->destination);
 
    ast_msg_destroy(mdata->msg);
}

References ast_free, ast_msg_destroy(), msg_data::destination, msg_data::from, and msg_data::msg.

Referenced by msg_data_create().

msg_send()

static int msg_send ( void *  data )

static

Definition at line 631 of file res_pjsip_messaging.c.

{
    struct msg_data *mdata = data; /* The caller holds a reference */
 
    struct ast_sip_body body = {
        .type = "text",
        .subtype = "plain",
        .body_text = ast_msg_get_body(mdata->msg)
    };
 
    pjsip_tx_data *tdata;
    RAII_VAR(char *, uri, NULL, ast_free);
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
 
    ast_debug(3, "mdata From: %s msg From: %s mdata Destination: %s msg To: %s\n",
        mdata->from, ast_msg_get_from(mdata->msg), mdata->destination, ast_msg_get_to(mdata->msg));
 
    endpoint = ast_sip_get_endpoint(mdata->destination, 1, &uri);
    if (!endpoint) {
        ast_log(LOG_ERROR,
            "PJSIP MESSAGE - Could not find endpoint '%s' and no default outbound endpoint configured\n",
            mdata->destination);
 
        ast_test_suite_event_notify("MSG_ENDPOINT_URI_FAIL",
            "MdataFrom: %s\r\n"
            "MsgFrom: %s\r\n"
            "MdataDestination: %s\r\n"
            "MsgTo: %s\r\n",
            mdata->from,
            ast_msg_get_from(mdata->msg),
            mdata->destination,
            ast_msg_get_to(mdata->msg));
 
        return -1;
    }
 
    ast_debug(3, "Request URI: %s\n", uri);
 
    if (ast_sip_create_request("MESSAGE", NULL, endpoint, uri, NULL, &tdata)) {
        ast_log(LOG_WARNING, "PJSIP MESSAGE - Could not create request\n");
        return -1;
    }
 
    /* If there was a To in the actual message, */
    if (!ast_strlen_zero(ast_msg_get_to(mdata->msg))) {
        char *msg_to = ast_strdupa(ast_msg_get_to(mdata->msg));
 
        /*
         * It's possible that the message To was copied from
         * an incoming MESSAGE in which case it'll have the
         * pjsip: tech prepended to it.  We need to remove it.
         */
        if (ast_begins_with(msg_to, "pjsip:")) {
            msg_to += 6;
        }
        ast_sip_update_to_uri(tdata, msg_to);
    } else {
        /*
         * If there was no To in the message, it's still possible
         * that there is a display name in the mdata To.  If so,
         * we'll copy the URI display name to the tdata To.
         */
        update_to_display_name(tdata, uri);
    }
 
    if (!ast_strlen_zero(mdata->from)) {
        ast_sip_update_from(tdata, mdata->from);
    } else if (!ast_strlen_zero(ast_msg_get_from(mdata->msg))) {
        ast_sip_update_from(tdata, (char *)ast_msg_get_from(mdata->msg));
    }
 
#ifdef TEST_FRAMEWORK
    {
        pjsip_name_addr *tdata_name_addr;
        pjsip_sip_uri *tdata_sip_uri;
        char touri[128];
        char fromuri[128];
 
        tdata_name_addr = (pjsip_name_addr *) PJSIP_MSG_TO_HDR(tdata->msg)->uri;
        tdata_sip_uri = pjsip_uri_get_uri(tdata_name_addr->uri);
        pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, tdata_sip_uri, touri, sizeof(touri));
        tdata_name_addr = (pjsip_name_addr *) PJSIP_MSG_FROM_HDR(tdata->msg)->uri;
        tdata_sip_uri = pjsip_uri_get_uri(tdata_name_addr->uri);
        pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, tdata_sip_uri, fromuri, sizeof(fromuri));
 
        ast_test_suite_event_notify("MSG_FROMTO_URI",
            "MdataFrom: %s\r\n"
            "MsgFrom: %s\r\n"
            "MdataDestination: %s\r\n"
            "MsgTo: %s\r\n"
            "Endpoint: %s\r\n"
            "RequestURI: %s\r\n"
            "ToURI: %s\r\n"
            "FromURI: %s\r\n",
            mdata->from,
            ast_msg_get_from(mdata->msg),
            mdata->destination,
            ast_msg_get_to(mdata->msg),
            ast_sorcery_object_get_id(endpoint),
            uri,
            touri,
            fromuri
            );
    }
#endif
 
    update_content_type(tdata, mdata->msg, &body);
 
    if (ast_sip_add_body(tdata, &body)) {
        pjsip_tx_data_dec_ref(tdata);
        ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not add body to request\n");
        return -1;
    }
 
    /*
     * This copies any headers set with MESSAGE_DATA() to the
     * tdata.
     */
    vars_to_headers(mdata->msg, tdata);
 
    ast_debug(1, "Sending message to '%s' (via endpoint %s) from '%s'\n",
        uri, ast_sorcery_object_get_id(endpoint), mdata->from);
 
    if (ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL)) {
        ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not send request\n");
        return -1;
    }
 
    return 0;
}

References ao2_cleanup, ast_begins_with(), ast_debug, ast_free, ast_log, ast_msg_get_body(), ast_msg_get_from(), ast_msg_get_to(), ast_sip_add_body(), ast_sip_create_request(), ast_sip_get_endpoint(), ast_sip_send_request(), ast_sip_update_from(), ast_sip_update_to_uri(), ast_sorcery_object_get_id(), ast_strdupa, ast_strlen_zero(), ast_test_suite_event_notify, msg_data::destination, msg_data::from, LOG_ERROR, LOG_WARNING, msg_data::msg, NULL, RAII_VAR, ast_sip_body::type, update_content_type(), update_to_display_name(), and vars_to_headers().

Referenced by sip_msg_send().

print_body()

static int print_body ( pjsip_rx_data *  rdata, char *  buf, int  len  )

static

Definition at line 347 of file res_pjsip_messaging.c.

{
    int res;
 
    if (!rdata->msg_info.msg->body || !rdata->msg_info.msg->body->len) {
        return 0;
    }
 
    if ((res = rdata->msg_info.msg->body->print_body(
             rdata->msg_info.msg->body, buf, len)) < 0) {
        return res;
    }
 
    /* remove any trailing carriage return/line feeds */
    while (res > 0 && ((buf[--res] == '\r') || (buf[res] == '\n')));
 
    buf[++res] = '\0';
 
    return res;
}

References buf, and len().

Referenced by rx_data_to_ast_msg().

rx_data_to_ast_msg()

static enum pjsip_status_code rx_data_to_ast_msg ( pjsip_rx_data *  rdata, struct ast_msg *  msg  )

static

Definition at line 418 of file res_pjsip_messaging.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpt, NULL, ao2_cleanup);
    pjsip_uri *ruri = rdata->msg_info.msg->line.req.uri;
    pjsip_name_addr *name_addr;
    pjsip_sip_uri *suri;
    char *display_name;
    char buf[MAX_BODY_SIZE];
    const char *field;
    const char *context;
    char exten[AST_MAX_EXTENSION];
    int res = 0;
    int size;
 
    if (!ast_sip_is_allowed_uri(ruri)) {
        return PJSIP_SC_UNSUPPORTED_URI_SCHEME;
    }
 
    ast_copy_pj_str(exten, ast_sip_pjsip_uri_get_username(ruri), AST_MAX_EXTENSION);
 
    /*
     * We may want to match in the dialplan without any user
     * options getting in the way.
     */
    AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(exten);
 
    endpt = ast_pjsip_rdata_get_endpoint(rdata);
    ast_assert(endpt != NULL);
 
    context = S_OR(endpt->message_context, endpt->context);
    res |= ast_msg_set_context(msg, "%s", context);
    res |= ast_msg_set_exten(msg, "%s", exten);
 
    /* to header */
    name_addr = (pjsip_name_addr *)rdata->msg_info.to->uri;
    size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf) - 1);
    if (size <= 0) {
        return PJSIP_SC_INTERNAL_SERVER_ERROR;
    }
    buf[size] = '\0';
    res |= ast_msg_set_to(msg, "%s", sip_to_pjsip(buf, ++size, sizeof(buf) - 1));
 
    /*
     * We need to sanitize the from header's display name
     * by replacing any control characters, including NULLs,
     * with spaces.  Since the display name is a pj_str_t, we
     * can't modify it in place, so we need to copy it to a
     * temporary buffer first. The good news is that we can't
     * accidentally run over the end of the buffer, even if
     * there's a NULL in the middle, because the display name
     * is a pj_str_t and we know its length.
     */
    name_addr = (pjsip_name_addr *)rdata->msg_info.from->uri;
    suri = pjsip_uri_get_uri((pjsip_uri *)name_addr);
    if (name_addr->display.slen > 0) {
        int i = 0;
        char *temp_name = ast_alloca(name_addr->display.slen + 1);
        for (i = 0; i < name_addr->display.slen; i++) {
            if (name_addr->display.ptr[i] < 32) {
                temp_name[i] = ' ';
            } else {
                temp_name[i] = name_addr->display.ptr[i];
            }
        }
        temp_name[name_addr->display.slen] = '\0';
        /*
         * We need space for each double quote, the display name,
         * the trailing space and the NULL terminator.
         */
        display_name = ast_alloca(name_addr->display.slen + 5);
        size = sprintf(display_name, "\"%s\" ", temp_name); /* Safe */
    } else {
        display_name = "";
    }
 
    /*
     * In the end, the string should look like...
     * "display name" <scheme:user@host>
     * If there's no display name, it and its double quotes
     * will be suppressed.
     * Note that the port is not included.
     */
    res |= ast_msg_set_from(msg, "%s<" PJSTR_PRINTF_SPEC ":" PJSTR_PRINTF_SPEC "@" PJSTR_PRINTF_SPEC ">",
            display_name,
            PJSTR_PRINTF_VAR(*pjsip_uri_get_scheme(suri)),
            PJSTR_PRINTF_VAR(*ast_sip_pjsip_uri_get_username((pjsip_uri *)name_addr)),
            PJSTR_PRINTF_VAR(*ast_sip_pjsip_uri_get_hostname((pjsip_uri *)name_addr)));
 
    field = pj_sockaddr_print(&rdata->pkt_info.src_addr, buf, sizeof(buf) - 1, 3);
    res |= ast_msg_set_var(msg, "PJSIP_RECVADDR", field);
 
    switch (rdata->tp_info.transport->key.type) {
    case PJSIP_TRANSPORT_UDP:
    case PJSIP_TRANSPORT_UDP6:
        field = "udp";
        break;
    case PJSIP_TRANSPORT_TCP:
    case PJSIP_TRANSPORT_TCP6:
        field = "tcp";
        break;
    case PJSIP_TRANSPORT_TLS:
    case PJSIP_TRANSPORT_TLS6:
        field = "tls";
        break;
    default:
        field = rdata->tp_info.transport->type_name;
    }
    ast_msg_set_var(msg, "PJSIP_TRANSPORT", field);
 
    if (print_body(rdata, buf, sizeof(buf) - 1) > 0) {
        res |= ast_msg_set_body(msg, "%s", buf);
    }
 
    /* endpoint name */
    res |= ast_msg_set_tech(msg, "%s", "PJSIP");
    res |= ast_msg_set_endpoint(msg, "%s", ast_sorcery_object_get_id(endpt));
    if (endpt->id.self.name.valid) {
        res |= ast_msg_set_var(msg, "PJSIP_ENDPOINT", endpt->id.self.name.str);
    }
 
    res |= headers_to_vars(rdata, msg);
 
    return !res ? PJSIP_SC_OK : PJSIP_SC_INTERNAL_SERVER_ERROR;
}

References ao2_cleanup, ast_alloca, ast_assert, ast_copy_pj_str(), AST_MAX_EXTENSION, ast_msg_set_body(), ast_msg_set_context(), ast_msg_set_endpoint(), ast_msg_set_exten(), ast_msg_set_from(), ast_msg_set_tech(), ast_msg_set_to(), ast_msg_set_var(), ast_pjsip_rdata_get_endpoint(), ast_sip_is_allowed_uri(), ast_sip_pjsip_uri_get_hostname(), ast_sip_pjsip_uri_get_username(), AST_SIP_USER_OPTIONS_TRUNCATE_CHECK, ast_sorcery_object_get_id(), buf, headers_to_vars(), MAX_BODY_SIZE, NULL, PJSTR_PRINTF_SPEC, PJSTR_PRINTF_VAR, print_body(), RAII_VAR, and S_OR.

Referenced by module_on_rx_request().

send_response()

static pj_status_t send_response ( pjsip_rx_data *  rdata, enum pjsip_status_code  code, pjsip_dialog *  dlg, pjsip_transaction *  tsx  )

static

Definition at line 788 of file res_pjsip_messaging.c.

{
    pjsip_tx_data *tdata;
    pj_status_t status;
 
    status = ast_sip_create_response(rdata, code, NULL, &tdata);
    if (status != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
        return status;
    }
 
    if (dlg && tsx) {
        status = pjsip_dlg_send_response(dlg, tsx, tdata);
    } else {
        struct ast_sip_endpoint *endpoint;
 
        endpoint = ast_pjsip_rdata_get_endpoint(rdata);
        status = ast_sip_send_stateful_response(rdata, tdata, endpoint);
        ao2_cleanup(endpoint);
    }
 
    if (status != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
    }
 
    return status;
}

References ao2_cleanup, ast_log, ast_pjsip_rdata_get_endpoint(), ast_sip_create_response(), ast_sip_send_stateful_response(), LOG_ERROR, NULL, and status.

Referenced by incoming_in_dialog_request(), and module_on_rx_request().

sip_msg_send()

static int sip_msg_send ( const struct ast_msg *  msg, const char *  destination, const char *  from  )

static

Definition at line 762 of file res_pjsip_messaging.c.

{
    struct msg_data *mdata;
    int res;
 
    if (ast_strlen_zero(destination)) {
        ast_log(LOG_ERROR, "SIP MESSAGE - a 'To' URI  must be specified\n");
        return -1;
    }
 
    mdata = msg_data_create(msg, destination, from);
    if (!mdata) {
        return -1;
    }
 
    res = ast_sip_push_task_wait_serializer(message_serializer, msg_send, mdata);
    ao2_ref(mdata, -1);
 
    return res;
}

References ao2_ref, ast_log, ast_sip_push_task_wait_serializer(), ast_strlen_zero(), msg_data::destination, msg_data::from, LOG_ERROR, message_serializer, msg_data::msg, msg_data_create(), and msg_send().

sip_to_pjsip()

static char * sip_to_pjsip ( char *  buf, int  size, int  capacity  )

static

Definition at line 377 of file res_pjsip_messaging.c.

{
    int count;
    const char *scheme;
    char *res = buf;
 
    /* remove any wrapping brackets */
    if (*buf == '<') {
        ++buf;
        --size;
    }
 
    scheme = strncmp(buf, "sip", 3) ? "pjsip:" : "pj";
    count = strlen(scheme);
    if (count + size >= capacity) {
        ast_log(LOG_WARNING, "Unable to handle MESSAGE- incoming uri "
            "too large for given buffer\n");
        return NULL;
    }
 
    memmove(res + count, buf, size);
    memcpy(res, scheme, count);
 
    buf += size - 1;
    if (*buf == '>') {
        *buf = '\0';
    }
 
    return res;
}

References ast_log, buf, LOG_WARNING, and NULL.

unload_module()

static int unload_module ( void  )

static

Definition at line 1006 of file res_pjsip_messaging.c.

{
    ast_sip_session_unregister_supplement(&messaging_supplement);
    ast_msg_tech_unregister(&msg_tech);
    ast_sip_unregister_service(&messaging_module);
    ast_taskprocessor_unreference(message_serializer);
    return 0;
}

References ast_msg_tech_unregister(), ast_sip_session_unregister_supplement(), ast_sip_unregister_service(), ast_taskprocessor_unreference(), message_serializer, messaging_module, messaging_supplement, and msg_tech.

update_content_type()

static void update_content_type ( pjsip_tx_data *  tdata, struct ast_msg *  msg, struct ast_sip_body *  body  )

static

Definition at line 583 of file res_pjsip_messaging.c.

{
    static const pj_str_t CONTENT_TYPE = { "Content-Type", sizeof("Content-Type") - 1 };
 
    const char *content_type = ast_msg_get_var(msg, pj_strbuf(&CONTENT_TYPE));
    if (content_type) {
        pj_str_t type, subtype;
        pjsip_ctype_hdr *parsed;
 
        /* Let pjsip do the parsing for us */
        parsed = pjsip_parse_hdr(tdata->pool, &CONTENT_TYPE,
            ast_strdupa(content_type), strlen(content_type),
            NULL);
 
        if (!parsed) {
            ast_log(LOG_WARNING, "Failed to parse '%s' as a content type. Using text/plain\n",
                content_type);
            return;
        }
 
        /* We need to turn type and subtype into zero-terminated strings */
        pj_strdup_with_null(tdata->pool, &type, &parsed->media.type);
        pj_strdup_with_null(tdata->pool, &subtype, &parsed->media.subtype);
 
        body->type = pj_strbuf(&type);
        body->subtype = pj_strbuf(&subtype);
    }
}

References ast_log, ast_msg_get_var(), ast_strdupa, LOG_WARNING, msg_data::msg, NULL, ast_sip_body::subtype, type, and ast_sip_body::type.

Referenced by msg_send().

update_to_display_name()

static int update_to_display_name ( pjsip_tx_data *  tdata, char *  to  )

static

Definition at line 207 of file res_pjsip_messaging.c.

{
    pjsip_name_addr *parsed_name_addr;
 
    parsed_name_addr = (pjsip_name_addr *) pjsip_parse_uri(tdata->pool, to, strlen(to),
        PJSIP_PARSE_URI_AS_NAMEADDR);
 
    if (parsed_name_addr) {
        if (pj_strlen(&parsed_name_addr->display)) {
            pjsip_name_addr *name_addr =
                (pjsip_name_addr *) PJSIP_MSG_TO_HDR(tdata->msg)->uri;
 
            pj_strdup(tdata->pool, &name_addr->display, &parsed_name_addr->display);
 
        }
        return 0;
    }
 
    return -1;
}

Referenced by msg_send().

vars_to_headers()

static enum pjsip_status_code vars_to_headers ( const struct ast_msg *  msg, pjsip_tx_data *  tdata  )

static

Definition at line 275 of file res_pjsip_messaging.c.

{
    const char *name;
    const char *value;
    int max_forwards;
    struct ast_msg_var_iterator *iter;
 
    for (iter = ast_msg_var_iterator_init(msg);
        ast_msg_var_iterator_next(msg, iter, &name, &value);
        ast_msg_var_unref_current(iter)) {
        if (!strcasecmp(name, "Max-Forwards")) {
            /* Decrement Max-Forwards for SIP loop prevention. */
            if (sscanf(value, "%30d", &max_forwards) != 1 || --max_forwards == 0) {
                ast_msg_var_iterator_destroy(iter);
                ast_log(LOG_NOTICE, "MESSAGE(Max-Forwards) reached zero.  MESSAGE not sent.\n");
                return -1;
            }
            sprintf((char *) value, "%d", max_forwards);
            ast_sip_add_header(tdata, name, value);
        } else if (!is_msg_var_blocked(name)) {
            ast_sip_add_header(tdata, name, value);
        }
    }
    ast_msg_var_iterator_destroy(iter);
 
    return PJSIP_SC_OK;
}

References ast_log, ast_msg_var_iterator_destroy(), ast_msg_var_iterator_init(), ast_msg_var_iterator_next(), ast_msg_var_unref_current(), ast_sip_add_header(), is_msg_var_blocked(), ast_msg_var_iterator::iter, LOG_NOTICE, name, and value.

Referenced by msg_send().

Variable Documentation

__mod_info

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

static

Definition at line 1021 of file res_pjsip_messaging.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1021 of file res_pjsip_messaging.c.

message_serializer

struct ast_taskprocessor* message_serializer

static

Definition at line 140 of file res_pjsip_messaging.c.

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

messaging_module

pjsip_module messaging_module

static

Definition at line 969 of file res_pjsip_messaging.c.

                                       {
    .name = {"Messaging Module", 16},
    .id = -1,
    .priority = PJSIP_MOD_PRIORITY_APPLICATION,
    .on_rx_request = module_on_rx_request,
};

Referenced by load_module(), and unload_module().

messaging_supplement

struct ast_sip_session_supplement messaging_supplement

static

Initial value:

= {
    .method = "MESSAGE",
    .incoming_request = incoming_in_dialog_request
}

Definition at line 964 of file res_pjsip_messaging.c.

                                                                {
    .method = "MESSAGE",
    .incoming_request = incoming_in_dialog_request
};

Referenced by load_module(), and unload_module().

msg_tech

const struct ast_msg_tech msg_tech

static

Initial value:

= {
    .name = "pjsip",
    .msg_send = sip_msg_send,
}

Definition at line 783 of file res_pjsip_messaging.c.

                                            {
    .name = "pjsip",
    .msg_send = sip_msg_send,
};

Referenced by action_messagesend(), ast_msg_send(), load_module(), msg_send_exec(), and unload_module().

pjsip_message_method

const pjsip_method pjsip_message_method = {PJSIP_OTHER_METHOD, {"MESSAGE", 7} }

Definition at line 134 of file res_pjsip_messaging.c.

{PJSIP_OTHER_METHOD, {"MESSAGE", 7} };

Referenced by load_module(), and module_on_rx_request().