res_pjsip: Refactor endpt_send_request to include transaction timeout
authorGeorge Joseph <george.joseph@fairview5.com>
Sat, 11 Apr 2015 21:39:29 +0000 (15:39 -0600)
committerMatt Jordan <mjordan@digium.com>
Thu, 16 Apr 2015 11:44:56 +0000 (06:44 -0500)
This is the first follow-on to https://reviewboard.asterisk.org/r/4572/ and the
discussion at
http://lists.digium.com/pipermail/asterisk-dev/2015-March/073921.html

Since we currently have no control over pjproject transaction timeout, this
patch pulls the pjsip_endpt_send_request function out of pjproject and into
res_pjsip/endpt_send_transaction in order to implement that capability.

Now when the transaction is initiated, we also schedule our own pj_timer with
our own desired timeout.

If the transaction completes before either timeout, pjproject cancels its timer,
and calls our tsx callback where we cancel our timer and run the app callback.

If the pjproject timer times out first, pjproject calls our tsx callback where
we cancel our timer and run the app callback.

If our timer times out first, we terminate the transaction which causes
pjproject to cancel its timer and call our tsx callback where we run the app
callback.

Regardless of the scenario, pjproject is calling the tsx callback inside the
group_lock and there are checks in the callback to make sure it doesn't run
twice.

As part of this patch ast_sip_send_out_of_dialog_request was created to replace
its similarly named private function.  It takes a new timeout argument in
milliseconds (<= 0 to disable the timeout).

ASTERISK-24863 #close
Reported-by: George Joseph <george.joseph@fairview5.com>
Tested-by: George Joseph <george.joseph@fairview5.com>

Change-Id: I0778dc730d9689c5147a444a04aee3c1026bf747

include/asterisk/res_pjsip.h
res/res_pjsip.c

index 2358a72..0610c95 100644 (file)
@@ -1260,6 +1260,30 @@ int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg,
        void (*callback)(void *token, pjsip_event *e));
 
 /*!
+ * \brief General purpose method for sending an Out-Of-Dialog SIP request
+ *
+ * This is a companion function for \ref ast_sip_create_request. The request
+ * created there can be passed to this function, though any request may be
+ * passed in.
+ *
+ * This will automatically set up handling outbound authentication challenges if
+ * they arrive.
+ *
+ * \param tdata The request to send
+ * \param endpoint Optional. If specified, the out-of-dialog request is sent to the endpoint.
+ * \param timeout.  If non-zero, after the timeout the transaction will be terminated
+ * and the callback will be called with the PJSIP_EVENT_TIMER type.
+ * \param token Data to be passed to the callback upon receipt of out-of-dialog response.
+ * \param callback Callback to be called upon receipt of out-of-dialog response.
+ *
+ * \retval 0 Success
+ * \retval -1 Failure (out-of-dialog callback will not be called.)
+ */
+int ast_sip_send_out_of_dialog_request(pjsip_tx_data *tdata,
+       struct ast_sip_endpoint *endpoint, int timeout, void *token,
+       void (*callback)(void *token, pjsip_event *e));
+
+/*!
  * \brief General purpose method for creating a SIP response
  *
  * Its typical use would be to create responses for out of dialog
index fcd8516..108c5b3 100644 (file)
@@ -21,6 +21,8 @@
 #include <pjsip.h>
 /* Needed for SUBSCRIBE, NOTIFY, and PUBLISH method definitions */
 #include <pjsip_simple.h>
+#include <pjsip/sip_transaction.h>
+#include <pj/timer.h>
 #include <pjlib.h>
 
 #include "asterisk/res_pjsip.h"
@@ -2815,6 +2817,128 @@ static pj_bool_t does_method_match(const pj_str_t *message_method, const char *s
 
 /*! Maximum number of challenges before assuming that we are in a loop */
 #define MAX_RX_CHALLENGES      10
+#define TIMER_INACTIVE         0
+#define TIMEOUT_TIMER2         5
+
+struct tsx_data {
+       void *token;
+       void (*cb)(void*, pjsip_event*);
+       pjsip_transaction *tsx;
+       pj_timer_entry *timeout_timer;
+};
+
+static void send_tsx_on_tsx_state(pjsip_transaction *tsx, pjsip_event *event);
+
+pjsip_module send_tsx_module = {
+    .name = { "send_tsx_module", 23 },
+    .id = -1,
+    .priority = PJSIP_MOD_PRIORITY_APPLICATION,
+    .on_tsx_state = &send_tsx_on_tsx_state,
+};
+
+/*! \brief This is the pjsip_tsx_send_msg callback */
+static void send_tsx_on_tsx_state(pjsip_transaction *tsx, pjsip_event *event)
+{
+       struct tsx_data *tsx_data;
+
+       if (event->type != PJSIP_EVENT_TSX_STATE) {
+               return;
+       }
+
+       tsx_data = (struct tsx_data*) tsx->mod_data[send_tsx_module.id];
+       if (tsx_data == NULL) {
+               return;
+       }
+
+       if (tsx->status_code < 200) {
+               return;
+       }
+
+       if (event->body.tsx_state.type == PJSIP_EVENT_TIMER) {
+               ast_debug(1, "PJSIP tsx timer expired\n");
+       }
+
+       if (tsx_data->timeout_timer && tsx_data->timeout_timer->id != TIMER_INACTIVE) {
+               pj_mutex_lock(tsx->mutex_b);
+               pj_timer_heap_cancel_if_active(pjsip_endpt_get_timer_heap(tsx->endpt),
+                       tsx_data->timeout_timer, TIMER_INACTIVE);
+               pj_mutex_unlock(tsx->mutex_b);
+       }
+
+       /* Call the callback, if any, and prevent the callback from being called again
+        * by clearing the transaction's module_data.
+        */
+       tsx->mod_data[send_tsx_module.id] = NULL;
+
+       if (tsx_data->cb) {
+               (*tsx_data->cb)(tsx_data->token, event);
+       }
+}
+
+static void tsx_timer_callback(pj_timer_heap_t *theap, pj_timer_entry *entry)
+{
+       struct tsx_data *tsx_data = entry->user_data;
+
+       entry->id = TIMER_INACTIVE;
+       ast_debug(1, "Internal tsx timer expired\n");
+       pjsip_tsx_terminate(tsx_data->tsx, PJSIP_SC_TSX_TIMEOUT);
+}
+
+static pj_status_t endpt_send_transaction(pjsip_endpoint *endpt,
+       pjsip_tx_data *tdata, int timeout, void *token,
+       pjsip_endpt_send_callback cb)
+{
+       pjsip_transaction *tsx;
+       struct tsx_data *tsx_data;
+       pj_status_t status;
+       pjsip_event event;
+
+       ast_assert(endpt && tdata);
+
+       status = pjsip_tsx_create_uac(&send_tsx_module, tdata, &tsx);
+       if (status != PJ_SUCCESS) {
+               pjsip_tx_data_dec_ref(tdata);
+               ast_log(LOG_ERROR, "Unable to create pjsip uac\n");
+               return status;
+       }
+
+       tsx_data = PJ_POOL_ALLOC_T(tsx->pool, struct tsx_data);
+       tsx_data->token = token;
+       tsx_data->cb = cb;
+       tsx_data->tsx = tsx;
+       if (timeout > 0) {
+               tsx_data->timeout_timer = PJ_POOL_ALLOC_T(tsx->pool, pj_timer_entry);
+       } else {
+               tsx_data->timeout_timer = NULL;
+       }
+       tsx->mod_data[send_tsx_module.id] = tsx_data;
+
+       PJSIP_EVENT_INIT_TX_MSG(event, tdata);
+       pjsip_tx_data_set_transport(tdata, &tsx->tp_sel);
+
+       if (timeout > 0) {
+               pj_time_val timeout_timer_val = { timeout / 1000, timeout % 1000 };
+
+               pj_timer_entry_init(tsx_data->timeout_timer, TIMEOUT_TIMER2,
+                       tsx_data, &tsx_timer_callback);
+               pj_mutex_lock(tsx->mutex_b);
+               pj_timer_heap_cancel_if_active(pjsip_endpt_get_timer_heap(tsx->endpt),
+                       tsx_data->timeout_timer, TIMER_INACTIVE);
+               pj_timer_heap_schedule(pjsip_endpt_get_timer_heap(tsx->endpt),
+                       tsx_data->timeout_timer, &timeout_timer_val);
+               tsx_data->timeout_timer->id = TIMEOUT_TIMER2;
+               pj_mutex_unlock(tsx->mutex_b);
+       }
+
+       status = (*tsx->state_handler)(tsx, &event);
+       pjsip_tx_data_dec_ref(tdata);
+       if (status != PJ_SUCCESS) {
+               ast_log(LOG_ERROR, "Unable to send message\n");
+               return status;
+       }
+
+       return status;
+}
 
 /*! \brief Structure to hold information about an outbound request */
 struct send_request_data {
@@ -2874,7 +2998,7 @@ static void endpt_send_request_wrapper(void *token, pjsip_event *e)
 }
 
 static pj_status_t endpt_send_request(struct ast_sip_endpoint *endpoint,
-       pjsip_tx_data *tdata, pj_int32_t timeout, void *token, pjsip_endpt_send_callback cb)
+       pjsip_tx_data *tdata, int timeout, void *token, pjsip_endpt_send_callback cb)
 {
        struct send_request_wrapper *req_wrapper;
        pj_status_t ret_val;
@@ -2890,7 +3014,7 @@ static pj_status_t endpt_send_request(struct ast_sip_endpoint *endpoint,
        req_wrapper->callback = cb;
 
        ao2_ref(req_wrapper, +1);
-       ret_val = pjsip_endpt_send_request(ast_sip_get_pjsip_endpoint(), tdata, timeout,
+       ret_val = endpt_send_transaction(ast_sip_get_pjsip_endpoint(), tdata, timeout,
                req_wrapper, endpt_send_request_wrapper);
        if (ret_val != PJ_SUCCESS) {
                char errmsg[PJ_ERR_MSG_SIZE];
@@ -2930,6 +3054,10 @@ static void send_request_cb(void *token, pjsip_event *e)
        int res;
 
        switch(e->body.tsx_state.type) {
+       case PJSIP_EVENT_USER:
+               /* Map USER (transaction cancelled by timeout) to TIMER */
+               e->body.tsx_state.type = PJSIP_EVENT_TIMER;
+               break;
        case PJSIP_EVENT_TRANSPORT_ERROR:
        case PJSIP_EVENT_TIMER:
                break;
@@ -2980,8 +3108,9 @@ static void send_request_cb(void *token, pjsip_event *e)
        ao2_ref(req_data, -1);
 }
 
-static int send_out_of_dialog_request(pjsip_tx_data *tdata, struct ast_sip_endpoint *endpoint,
-       void *token, void (*callback)(void *token, pjsip_event *e))
+int ast_sip_send_out_of_dialog_request(pjsip_tx_data *tdata,
+       struct ast_sip_endpoint *endpoint, int timeout, void *token,
+       void (*callback)(void *token, pjsip_event *e))
 {
        struct ast_sip_supplement *supplement;
        struct send_request_data *req_data;
@@ -3007,7 +3136,7 @@ static int send_out_of_dialog_request(pjsip_tx_data *tdata, struct ast_sip_endpo
        ast_sip_mod_data_set(tdata->pool, tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT, NULL);
        ao2_cleanup(contact);
 
-       if (endpt_send_request(endpoint, tdata, -1, req_data, send_request_cb)
+       if (endpt_send_request(endpoint, tdata, timeout, req_data, send_request_cb)
                != PJ_SUCCESS) {
                ao2_cleanup(req_data);
                return -1;
@@ -3025,7 +3154,7 @@ int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg,
        if (dlg) {
                return send_in_dialog_request(tdata, dlg);
        } else {
-               return send_out_of_dialog_request(tdata, endpoint, token, callback);
+               return ast_sip_send_out_of_dialog_request(tdata, endpoint, -1, token, callback);
        }
 }
 
@@ -3543,8 +3672,25 @@ static int load_module(void)
                return AST_MODULE_LOAD_DECLINE;
        }
 
+       if (internal_sip_register_service(&send_tsx_module)) {
+               ast_log(LOG_ERROR, "Failed to initialize send request module. Aborting load\n");
+               internal_sip_unregister_service(&supplement_module);
+               ast_sip_destroy_distributor();
+               ast_res_pjsip_destroy_configuration();
+               ast_sip_destroy_global_headers();
+               stop_monitor_thread();
+               ast_sip_destroy_system();
+               pj_pool_release(memory_pool);
+               memory_pool = NULL;
+               pjsip_endpt_destroy(ast_pjsip_endpoint);
+               ast_pjsip_endpoint = NULL;
+               pj_caching_pool_destroy(&caching_pool);
+               return AST_MODULE_LOAD_DECLINE;
+       }
+
        if (internal_sip_initialize_outbound_authentication()) {
                ast_log(LOG_ERROR, "Failed to initialize outbound authentication. Aborting load\n");
+               internal_sip_unregister_service(&send_tsx_module);
                internal_sip_unregister_service(&supplement_module);
                ast_sip_destroy_distributor();
                ast_res_pjsip_destroy_configuration();
@@ -3588,6 +3734,7 @@ static int unload_pjsip(void *data)
        ast_res_pjsip_destroy_configuration();
        ast_sip_destroy_system();
        ast_sip_destroy_global_headers();
+       internal_sip_unregister_service(&send_tsx_module);
        internal_sip_unregister_service(&supplement_module);
        if (monitor_thread) {
                stop_monitor_thread();