void async_aar_callback(int is_timeout, void *param, AAAMessage *aaa, long elapsed_msecs) {
struct cell *t = 0;
unsigned int cdp_result;
int result = CSCF_RETURN_ERROR;
LM_DBG("Received AAR callback\n");
saved_transaction_t* data = (saved_transaction_t*) param;
LM_DBG("received AAA answer");
if (tmb.t_lookup_ident(&t, data->tindex, data->tlabel) < 0) {
LM_ERR("t_continue: transaction not found\n");
goto error;
} else {
LM_DBG("t_continue: transaction found\n");
}
//we have T, lets restore our state (esp. for AVPs)
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &t->uri_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &t->uri_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &t->user_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &t->user_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &t->domain_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &t->domain_avps_to);
if (is_timeout != 0) {
LM_ERR("Error timeout when sending AAR message via CDP\n");
counter_inc(ims_qos_cnts_h.media_aar_timeouts);
goto error;
}
if (!aaa) {
LM_ERR("Error sending message via CDP\n");
goto error;
}
counter_inc(ims_qos_cnts_h.media_aars);
counter_add(ims_qos_cnts_h.media_aar_response_time, elapsed_msecs);
counter_inc(ims_qos_cnts_h.media_aar_replies_received);
/* Process the response to AAR, retrieving result code and associated Rx session ID */
if (rx_process_aaa(aaa, &cdp_result) < 0) {
LM_ERR("Failed to process AAA from PCRF\n"); //puri.host.len, puri.host.s);
goto error;
}
if (cdp_result >= 2000 && cdp_result < 3000) {
LM_DBG("Success, received code: [%i] from PCRF for AAR request\n", cdp_result);
counter_inc(ims_qos_cnts_h.successful_media_aars);
LM_DBG("Auth session ID [%.*s]", aaa->sessionId->data.len, aaa->sessionId->data.s);
if(!data->aar_update) {
LM_DBG("This is an AAA response to an initial AAR");
counter_inc(ims_qos_cnts_h.active_media_rx_sessions);
str * passed_rx_session_id = shm_malloc(sizeof (struct _str));
passed_rx_session_id->s = 0;
passed_rx_session_id->len = 0;
STR_SHM_DUP(*passed_rx_session_id, aaa->sessionId->data, "cb_passed_rx_session_id");
LM_DBG("passed rx session id [%.*s]", passed_rx_session_id->len, passed_rx_session_id->s);
dlgb.register_dlgcb_nodlg(&data->callid, &data->ftag, &data->ttag, DLGCB_TERMINATED | DLGCB_DESTROY | DLGCB_EXPIRED | DLGCB_RESPONSE_WITHIN | DLGCB_CONFIRMED | DLGCB_FAILED, callback_dialog, (void*) (passed_rx_session_id), free_dialog_data);
}
result = CSCF_RETURN_TRUE;
} else {
LM_DBG("Received negative reply from PCRF for AAR Request\n");
counter_inc(ims_qos_cnts_h.failed_media_aars);
//we don't free rx_authdata_p here - it is free-ed when the CDP session expires
goto error; // if its not a success then that means i want to reject this call!
}
//set success response code AVP
create_return_code(result);
goto done;
out_of_memory:
error :
//set failure response code
create_return_code(result);
done:
if (t) tmb.unref_cell(t);
//free memory
if (aaa)
cdpb.AAAFreeMessage(&aaa);
tmb.t_continue(data->tindex, data->tlabel, data->act);
free_saved_transaction_global_data(data);
}
/* Wrapper to send AAR from config file - only used for registration */
static int w_rx_aar_register(struct sip_msg *msg, char* route, char* str1, char* bar) {
int ret = CSCF_RETURN_ERROR;
struct pcontact_info ci;
struct cell *t;
contact_t* c;
struct hdr_field* h;
pcontact_t* pcontact;
contact_body_t* cb = 0;
AAASession* auth;
rx_authsessiondata_t* rx_regsession_data_p;
cfg_action_t* cfg_action = 0;
str route_name;
char* p;
int aar_sent = 0;
saved_transaction_local_t* local_data = 0; //data to be shared across all async calls
saved_transaction_t* saved_t_data = 0; //data specific to each contact's AAR async call
if (fixup_get_svalue(msg, (gparam_t*) route, &route_name) != 0) {
LM_ERR("no async route block for assign_server_unreg\n");
return -1;
}
LM_DBG("Looking for route block [%.*s]\n", route_name.len, route_name.s);
int ri = route_get(&main_rt, route_name.s);
if (ri < 0) {
LM_ERR("unable to find route block [%.*s]\n", route_name.len, route_name.s);
return -1;
}
cfg_action = main_rt.rlist[ri];
if (cfg_action == NULL) {
LM_ERR("empty action lists in route block [%.*s]\n", route_name.len, route_name.s);
return -1;
}
udomain_t* domain_t = (udomain_t*) str1;
int is_rereg = 0; //is this a reg/re-reg
LM_DBG("Rx AAR Register called\n");
//create the default return code AVP
create_return_code(ret);
memset(&ci, 0, sizeof (struct pcontact_info));
/** If this is a response then let's check the status before we try and do an AAR.
* We will only do AAR for register on success response and of course if message is register
*/
if (msg->first_line.type == SIP_REPLY) {
//check this is a response to a register
/* Get the SIP request from this transaction */
t = tmb.t_gett();
if (!t) {
LM_ERR("Cannot get transaction for AAR based on SIP Request\n");
goto error;
}
if ((strncmp(t->method.s, "REGISTER", 8) != 0)) {
LM_ERR("Method is not a response to a REGISTER\n");
goto error;
}
if (msg->first_line.u.reply.statuscode < 200
|| msg->first_line.u.reply.statuscode >= 300) {
LM_DBG("Message is not a 2xx OK response to a REGISTER\n");
goto error;
}
tmb.t_release(msg);
} else { //SIP Request
/* in case of request make sure it is a REGISTER */
if (msg->first_line.u.request.method_value != METHOD_REGISTER) {
LM_DBG("This is not a register request\n");
goto error;
}
if ((cscf_get_max_expires(msg, 0) == 0)) {
//if ((cscf_get_expires(msg) == 0)) {
LM_DBG("This is a de registration\n");
LM_DBG("We ignore it as these are dealt with by usrloc callbacks \n");
create_return_code(CSCF_RETURN_TRUE);
return CSCF_RETURN_TRUE;
}
}
//before we continue, make sure we have a transaction to work with (viz. cdp async)
t = tmb.t_gett();
if (t == NULL || t == T_UNDEFINED) {
if (tmb.t_newtran(msg) < 0) {
LM_ERR("cannot create the transaction for UAR async\n");
return CSCF_RETURN_ERROR;
}
t = tmb.t_gett();
if (t == NULL || t == T_UNDEFINED) {
LM_ERR("cannot lookup the transaction\n");
return CSCF_RETURN_ERROR;
}
}
saved_t_data = (saved_transaction_t*) shm_malloc(sizeof (saved_transaction_t));
if (!saved_t_data) {
LM_ERR("Unable to allocate memory for transaction data, trying to send AAR\n");
return CSCF_RETURN_ERROR;
}
memset(saved_t_data, 0, sizeof (saved_transaction_t));
saved_t_data->act = cfg_action;
saved_t_data->domain = domain_t;
saved_t_data->lock = lock_alloc();
if (saved_t_data->lock == NULL) {
LM_ERR("unable to allocate init lock for saved_t_transaction reply counter\n");
return CSCF_RETURN_ERROR;
}
if (lock_init(saved_t_data->lock) == NULL) {
LM_ERR("unable to init lock for saved_t_transaction reply counter\n");
return CSCF_RETURN_ERROR;
}
LM_DBG("Suspending SIP TM transaction\n");
if (tmb.t_suspend(msg, &saved_t_data->tindex, &saved_t_data->tlabel) < 0) {
LM_ERR("failed to suspend the TM processing\n");
free_saved_transaction_global_data(saved_t_data);
return CSCF_RETURN_ERROR;
}
LM_DBG("Successfully suspended transaction\n");
//now get the contacts in the REGISTER and do AAR for each one.
cb = cscf_parse_contacts(msg);
if (!cb || (!cb->contacts && !cb->star)) {
LM_DBG("No contact headers in Register message\n");
goto error;
}
lock_get(saved_t_data->lock); //we lock here to make sure we send all requests before processing replies asynchronously
for (h = msg->contact; h; h = h->next) {
if (h->type == HDR_CONTACT_T && h->parsed) {
for (c = ((contact_body_t*) h->parsed)->contacts; c; c = c->next) {
ul.lock_udomain(domain_t, &c->uri);
if (ul.get_pcontact(domain_t, &c->uri, &pcontact) != 0) {
LM_DBG("This contact does not exist in PCSCF usrloc - error in cfg file\n");
ul.unlock_udomain(domain_t, &c->uri);
lock_release(saved_t_data->lock);
goto error;
} else if (pcontact->reg_state == PCONTACT_REG_PENDING
|| pcontact->reg_state == PCONTACT_REGISTERED) { //NEW reg request
LM_DBG("Contact [%.*s] exists and is in state PCONTACT_REG_PENDING or PCONTACT_REGISTERED\n"
, pcontact->aor.len, pcontact->aor.s);
//get IP address from contact
struct sip_uri puri;
if (parse_uri(c->uri.s, c->uri.len, &puri) < 0) {
LM_ERR("failed to parse Contact\n");
ul.unlock_udomain(domain_t, &c->uri);
lock_release(saved_t_data->lock);
goto error;
}
LM_DBG("Parsed URI of from host is [%.*s]\n", puri.host.len, puri.host.s);
uint16_t ip_version = AF_INET; //TODO IPv6!!!?
//check for existing Rx session
if (pcontact->rx_session_id.len > 0
&& pcontact->rx_session_id.s
&& (auth = cdpb.AAAGetAuthSession(pcontact->rx_session_id))) {
LM_DBG("Rx session already exists for this user\n");
if (memcmp(pcontact->rx_session_id.s, auth->id.s, auth->id.len) != 0) {
LM_ERR("Rx session mismatch when URI is [%.*s].......Aborting\n", puri.host.len, puri.host.s);
if (auth) cdpb.AAASessionsUnlock(auth->hash);
lock_release(saved_t_data->lock);
goto error;
}
//re-registration - update auth lifetime
auth->u.auth.lifetime = time(NULL) + rx_auth_expiry;
is_rereg = 1;
} else {
LM_DBG("Creating new Rx session for contact <%.*s>\n", pcontact->aor.len, pcontact->aor.s);
int ret = create_new_regsessiondata(domain_t->name, &pcontact->aor, &rx_regsession_data_p);
if (!ret) {
LM_ERR("Unable to create regsession data parcel when URI is [%.*s]...Aborting\n", puri.host.len, puri.host.s);
ul.unlock_udomain(domain_t, &c->uri);
if (rx_regsession_data_p) {
shm_free(rx_regsession_data_p);
rx_regsession_data_p = 0;
}
lock_release(saved_t_data->lock);
goto error;
}
auth = cdpb.AAACreateClientAuthSession(1, callback_for_cdp_session, rx_regsession_data_p); //returns with a lock
if (!auth) {
LM_ERR("Rx: unable to create new Rx Reg Session when URI is [%.*s]\n", puri.host.len, puri.host.s);
if (rx_regsession_data_p) {
shm_free(rx_regsession_data_p);
rx_regsession_data_p = 0;
}
ul.unlock_udomain(domain_t, &c->uri);
if (auth) cdpb.AAASessionsUnlock(auth->hash);
if (rx_regsession_data_p) {
shm_free(rx_regsession_data_p);
rx_regsession_data_p = 0;
}
lock_release(saved_t_data->lock);
goto error;
}
}
//we are ready to send the AAR async. lets save the local data data
int local_data_len = sizeof (saved_transaction_local_t) + c->uri.len + auth->id.len;
local_data = shm_malloc(local_data_len);
if (!local_data) {
LM_ERR("unable to alloc memory for local data, trying to send AAR Register\n");
lock_release(saved_t_data->lock);
goto error;
}
memset(local_data, 0, local_data_len);
local_data->is_rereg = is_rereg;
local_data->global_data = saved_t_data;
p = (char*) (local_data + 1);
local_data->contact.s = p;
local_data->contact.len = c->uri.len;
memcpy(p, c->uri.s, c->uri.len);
p += c->uri.len;
local_data->auth_session_id.s = p;
local_data->auth_session_id.len = auth->id.len;
memcpy(p, auth->id.s, auth->id.len);
p += auth->id.len;
if (p != (((char*) local_data) + local_data_len)) {
LM_CRIT("buffer overflow\n");
free_saved_transaction_data(local_data);
goto error;
}
LM_DBG("Calling send aar register");
//TODOD remove - no longer user AOR parm
//ret = rx_send_aar_register(msg, auth, &puri.host, &ip_version, &c->uri, local_data); //returns a locked rx auth object
ret = rx_send_aar_register(msg, auth, &puri.host, &ip_version, local_data); //returns a locked rx auth object
ul.unlock_udomain(domain_t, &c->uri);
if (!ret) {
LM_ERR("Failed to send AAR\n");
lock_release(saved_t_data->lock);
free_saved_transaction_data(local_data); //free the local data becuase the CDP async request was not successful (we must free here)
goto error;
} else {
aar_sent = 1;
//before we send - bump up the reply counter
saved_t_data->answers_not_received++; //we dont need to lock as we already hold the lock above
}
} else {
//contact exists - this is a re-registration, for now we just ignore this
LM_DBG("This contact exists and is not in state REGISTER PENDING - we assume re (or de) registration and ignore\n");
ul.unlock_udomain(domain_t, &c->uri);
//now we loop for any other contacts.
}
}
} else {
if (h->type == HDR_CONTACT_T) { //means we couldnt parse the contact - this is an error
LM_ERR("Failed to parse contact header\n");
lock_release(saved_t_data->lock);
goto error;
}
}
}
//all requests sent at this point - we can unlock the reply lock
lock_release(saved_t_data->lock);
/*if we get here, we have either:
* 1. Successfully sent AAR's for ALL contacts, or
* 2. haven't needed to send ANY AAR's for ANY contacts
*/
if (aar_sent) {
LM_DBG("Successful async send of AAR\n");
return CSCF_RETURN_BREAK; //on success we break - because rest of cfg file will be executed by async process
} else {
create_return_code(CSCF_RETURN_TRUE);
tmb.t_cancel_suspend(saved_t_data->tindex, saved_t_data->tlabel);
if (saved_t_data) {
free_saved_transaction_global_data(saved_t_data); //no aar sent so we must free the global data
}
//return CSCF_RETURN_ERROR;
return CSCF_RETURN_TRUE;
}
error:
LM_ERR("Error trying to send AAR\n");
if (!aar_sent) {
tmb.t_cancel_suspend(saved_t_data->tindex, saved_t_data->tlabel);
if (saved_t_data) {
free_saved_transaction_global_data(saved_t_data); //only free global data if no AARs were sent. if one was sent we have to rely on the callback (CDP) to free
//otherwise the callback will segfault
}
}
return CSCF_RETURN_ERROR;
//return CSCF_RETURN_FALSE;
}
void async_aar_reg_callback(int is_timeout, void *param, AAAMessage *aaa, long elapsed_msecs) {
struct cell *t = 0;
pcontact_t* pcontact;
unsigned int cdp_result;
struct pcontact_info ci;
udomain_t* domain_t;
int finalReply = 0;
AAASession *auth = 0;
rx_authsessiondata_t* p_session_data = 0;
int result = CSCF_RETURN_ERROR;
pcontact_info_t contact_info;
LM_DBG("Received AAR callback\n");
saved_transaction_local_t* local_data = (saved_transaction_local_t*) param;
saved_transaction_t* data = local_data->global_data;
domain_t = data->domain;
int is_rereg = local_data->is_rereg;
//before we do anything else, lets decrement the reference counter on replies
lock_get(data->lock);
data->answers_not_received--;
if (data->answers_not_received <= 0) {
finalReply = 1;
}
if (data->ignore_replies) { //there was obv. a subsequent error AFTER we had sent one/more AAR's - so we can ignore these replies and just free memory
free_saved_transaction_data(local_data);
if (finalReply) {
free_saved_transaction_global_data(data);
}
return;
}
lock_release(data->lock);
LM_DBG("received answer and we are waiting for [%d] answers so far failures flag is [%d]\n", data->answers_not_received, data->failed);
if (tmb.t_lookup_ident(&t, data->tindex, data->tlabel) < 0) {
LM_ERR("t_continue: transaction not found\n");
goto error;
}
//we have T, lets restore our state (esp. for AVPs)
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &t->uri_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &t->uri_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &t->user_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &t->user_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &t->domain_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &t->domain_avps_to);
if (is_timeout != 0) {
LM_ERR("Error timeout when sending AAR message via CDP\n");
counter_inc(ims_qos_cnts_h.registration_aar_timeouts);
goto error;
}
if (!aaa) {
LM_ERR("Error sending message via CDP\n");
goto error;
}
counter_inc(ims_qos_cnts_h.registration_aars);
counter_add(ims_qos_cnts_h.registration_aar_response_time, elapsed_msecs);
counter_inc(ims_qos_cnts_h.registration_aar_replies_received);
/* Process the response to AAR, retrieving result code and associated Rx session ID */
if (rx_process_aaa(aaa, &cdp_result) < 0) {
LM_ERR("Failed to process AAA from PCRF\n"); //puri.host.len, puri.host.s);
goto error;
}
if (cdp_result >= 2000 && cdp_result < 3000) {
counter_inc(ims_qos_cnts_h.successful_registration_aars);
if (is_rereg) {
LM_DBG("this is a re-registration, therefore we don't need to do anything except know that the the subscription was successful\n");
result = CSCF_RETURN_TRUE;
create_return_code(result);
goto done;
}
//need to set Rx auth data to say this session has been successfully opened
//This is used elsewhere to prevent acting on termination events when the session has not been opened
//getting auth session
auth = cdpb.AAAGetAuthSession(aaa->sessionId->data);
if (!auth) {
LM_DBG("Could not get Auth Session for session id: [%.*s]\n", aaa->sessionId->data.len, aaa->sessionId->data.s);
goto error;
}
//getting session data
p_session_data = (rx_authsessiondata_t*) auth->u.auth.generic_data;
if (!p_session_data) {
LM_DBG("Could not get session data on Auth Session for session id: [%.*s]\n", aaa->sessionId->data.len, aaa->sessionId->data.s);
if (auth) cdpb.AAASessionsUnlock(auth->hash);
goto error;
}
p_session_data->session_has_been_opened = 1;
counter_inc(ims_qos_cnts_h.active_registration_rx_sessions);
if (auth) cdpb.AAASessionsUnlock(auth->hash);
LM_DBG("Success, received code: [%i] from PCRF for AAR request (contact: [%.*s]), (auth session id: %.*s)\n",
cdp_result, local_data->contact.len, local_data->contact.s,
local_data->auth_session_id.len, local_data->auth_session_id.s);
LM_DBG("Registering for Usrloc callbacks on DELETE\n");
ul.lock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto);
contact_info.received_host = local_data->recv_host;
contact_info.received_port = local_data->recv_port;
contact_info.received_proto = local_data->recv_proto;
contact_info.searchflag = (1 << SEARCH_RECEIVED);
contact_info.aor = local_data->contact;
contact_info.via_host = local_data->via_host;
contact_info.via_port = local_data->via_port;
contact_info.via_prot = local_data->via_proto;
if (ul.get_pcontact(domain_t, &contact_info, &pcontact) != 0) {
LM_ERR("Shouldn't get here, can't find contact....\n");
ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto);
goto error;
}
//at this point we have the contact
/*set the contact state to say we have succesfully done ARR for register and that we dont need to do it again
* for the duration of the registration.
* */
if (ul.update_rx_regsession(domain_t, &local_data->auth_session_id, pcontact) != 0) {
LM_ERR("unable to update pcontact......\n");
ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto);
goto error;
}
memset(&ci, 0, sizeof (struct pcontact_info));
ci.reg_state = PCONTACT_REG_PENDING_AAR;
ci.num_service_routes = 0;
ci.num_public_ids = 0;
LM_DBG("impu: [%.*s] updating status to PCONTACT_REG_PENDING\n", pcontact->aor.len, pcontact->aor.s);
ul.update_pcontact(domain_t, &ci, pcontact);
//register for callbacks on contact
ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE,
callback_pcscf_contact_cb, NULL);
ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto);
result = CSCF_RETURN_TRUE;
} else {
LM_DBG("Received negative reply from PCRF for AAR Request\n");
counter_inc(ims_qos_cnts_h.failed_registration_aars);
result = CSCF_RETURN_FALSE;
goto error;
}
//set success response code AVP
create_return_code(result);
goto done;
error:
//set failure response code
create_return_code(result);
done:
if (t) tmb.unref_cell(t);
//free memory
if (aaa)
cdpb.AAAFreeMessage(&aaa);
if (finalReply) {
tmb.t_continue(data->tindex, data->tlabel, data->act);
free_saved_transaction_global_data(data);
}
free_saved_transaction_data(local_data);
}
/* Wrapper to send AAR from config file - this only allows for AAR for calls - not register, which uses r_rx_aar_register
* return: 1 - success, <=0 failure. 2 - message not a AAR generating message (ie proceed without PCC if you wish)
*/
static int w_rx_aar(struct sip_msg *msg, char *route, char* str1, char* bar) {
int ret = CSCF_RETURN_ERROR;
struct cell *t;
AAASession* auth_session;
rx_authsessiondata_t* rx_authdata_p = 0;
str *rx_session_id;
str callid = {0, 0};
str ftag = {0, 0};
str ttag = {0, 0};
str route_name;
cfg_action_t* cfg_action = 0;
saved_transaction_t* saved_t_data = 0; //data specific to each contact's AAR async call
char* direction = str1;
if (fixup_get_svalue(msg, (gparam_t*) route, &route_name) != 0) {
LM_ERR("no async route block for assign_server_unreg\n");
return -1;
}
LM_DBG("Looking for route block [%.*s]\n", route_name.len, route_name.s);
int ri = route_get(&main_rt, route_name.s);
if (ri < 0) {
LM_ERR("unable to find route block [%.*s]\n", route_name.len, route_name.s);
return -1;
}
cfg_action = main_rt.rlist[ri];
if (cfg_action == NULL) {
LM_ERR("empty action lists in route block [%.*s]\n", route_name.len, route_name.s);
return -1;
}
LM_DBG("Rx AAR called\n");
//create the default return code AVP
create_return_code(ret);
//We don't ever do AAR on request for calling scenario...
if (msg->first_line.type != SIP_REPLY) {
LM_DBG("Can't do AAR for call session in request\n");
return CSCF_RETURN_ERROR;
}
//is it appropriate to send AAR at this stage?
t = tmb.t_gett();
if (t == NULL || t == T_UNDEFINED) {
LM_WARN("Cannot get transaction for AAR based on SIP Request\n");
//goto aarna;
return CSCF_RETURN_ERROR;
}
//we dont apply QoS if its not a reply to an INVITE! or UPDATE or PRACK!
if ((t->method.len == 5 && memcmp(t->method.s, "PRACK", 5) == 0)
|| (t->method.len == 6 && (memcmp(t->method.s, "INVITE", 6) == 0
|| memcmp(t->method.s, "UPDATE", 6) == 0))) {
if (cscf_get_content_length(msg) == 0
|| cscf_get_content_length(t->uas.request) == 0) {
LM_DBG("No SDP offer answer -> therefore we can not do Rx AAR");
//goto aarna; //AAR na if we dont have offer/answer pair
return CSCF_RETURN_ERROR;
}
} else {
LM_DBG("Message is not response to INVITE, PRACK or UPDATE -> therefore we do not Rx AAR");
return CSCF_RETURN_ERROR;
}
/* get callid, from and to tags to be able to identify dialog */
callid = cscf_get_call_id(msg, 0);
if (callid.len <= 0 || !callid.s) {
LM_ERR("unable to get callid\n");
return CSCF_RETURN_ERROR;
}
if (!cscf_get_from_tag(msg, &ftag)) {
LM_ERR("Unable to get ftag\n");
return CSCF_RETURN_ERROR;
}
if (!cscf_get_to_tag(msg, &ttag)) {
LM_ERR("Unable to get ttag\n");
return CSCF_RETURN_ERROR;
}
//check to see that this is not a result of a retransmission in reply route only
if (msg->cseq == NULL
&& ((parse_headers(msg, HDR_CSEQ_F, 0) == -1) || (msg->cseq == NULL))) {
LM_ERR("No Cseq header found - aborting\n");
return CSCF_RETURN_ERROR;
}
saved_t_data = (saved_transaction_t*) shm_malloc(sizeof (saved_transaction_t));
if (!saved_t_data) {
LM_ERR("Unable to allocate memory for transaction data, trying to send AAR\n");
return CSCF_RETURN_ERROR;
}
memset(saved_t_data, 0, sizeof (saved_transaction_t));
saved_t_data->act = cfg_action;
//OTHER parms need after async response set here
//store call id
saved_t_data->callid.s = (char*) shm_malloc(callid.len + 1);
if (!saved_t_data->callid.s) {
LM_ERR("no more memory trying to save transaction state : callid\n");
shm_free(saved_t_data);
return CSCF_RETURN_ERROR;
}
memset(saved_t_data->callid.s, 0, callid.len + 1);
memcpy(saved_t_data->callid.s, callid.s, callid.len);
saved_t_data->callid.len = callid.len;
//store ttag
saved_t_data->ttag.s = (char*) shm_malloc(ttag.len + 1);
if (!saved_t_data->ttag.s) {
LM_ERR("no more memory trying to save transaction state : ttag\n");
shm_free(saved_t_data);
return CSCF_RETURN_ERROR;
}
memset(saved_t_data->ttag.s, 0, ttag.len + 1);
memcpy(saved_t_data->ttag.s, ttag.s, ttag.len);
saved_t_data->ttag.len = ttag.len;
//store ftag
saved_t_data->ftag.s = (char*) shm_malloc(ftag.len + 1);
if (!saved_t_data->ftag.s) {
LM_ERR("no more memory trying to save transaction state : ftag\n");
shm_free(saved_t_data);
return CSCF_RETURN_ERROR;
}
memset(saved_t_data->ftag.s, 0, ftag.len + 1);
memcpy(saved_t_data->ftag.s, ftag.s, ftag.len);
saved_t_data->ftag.len = ftag.len;
//store branch
int branch;
if (tmb.t_check( msg , &branch )==-1){
LOG(L_ERR, "ERROR: t_suspend: failed find UAC branch\n");
return CSCF_RETURN_ERROR;
}
//Check that we dont already have an auth session for this specific dialog
//if not we create a new one and attach it to the dialog (via session ID).
enum dialog_direction dlg_direction = get_dialog_direction(direction);
if (dlg_direction == DLG_MOBILE_ORIGINATING) {
rx_session_id = dlgb.get_dlg_var(&callid, &ftag, &ttag,
&orig_session_key);
} else {
rx_session_id = dlgb.get_dlg_var(&callid, &ftag, &ttag,
&term_session_key);
}
if (!rx_session_id || rx_session_id->len <= 0 || !rx_session_id->s) {
LM_DBG("New AAR session for this dialog in mode %s\n", direction);
//create new diameter auth session
int ret = create_new_callsessiondata(&callid, &ftag, &ttag, &rx_authdata_p);
if (!ret) {
LM_DBG("Unable to create new media session data parcel\n");
goto error;
}
auth_session = cdpb.AAACreateClientAuthSession(1, callback_for_cdp_session, rx_authdata_p); //returns with a lock
if (!auth_session) {
LM_ERR("Rx: unable to create new Rx Media Session\n");
if (auth_session) cdpb.AAASessionsUnlock(auth_session->hash);
if (rx_authdata_p) {
shm_free(rx_authdata_p);
rx_authdata_p = 0;
}
goto error;
}
//attach new cdp auth session to dlg for this direction
if (dlg_direction == DLG_MOBILE_ORIGINATING) {
dlgb.set_dlg_var(&callid, &ftag, &ttag,
&orig_session_key, &auth_session->id);
} else {
dlgb.set_dlg_var(&callid, &ftag, &ttag,
&term_session_key, &auth_session->id);
}
LM_DBG("Attached CDP auth session [%.*s] for Rx to dialog in %s mode\n", auth_session->id.len, auth_session->id.s, direction);
} else {
LM_DBG("Update AAR session for this dialog in mode %s\n", direction);
if (saved_t_data)
free_saved_transaction_global_data(saved_t_data); //only free global data if no AARs were sent. if one was sent we have to rely on the callback (CDP) to free
create_return_code(CSCF_RETURN_TRUE);
return CSCF_RETURN_TRUE;
}
LM_DBG("Suspending SIP TM transaction\n");
if (tmb.t_suspend(msg, &saved_t_data->tindex, &saved_t_data->tlabel) < 0) {
LM_ERR("failed to suspend the TM processing\n");
free_saved_transaction_global_data(saved_t_data);
return CSCF_RETURN_ERROR;
}
LM_DBG("Sending Rx AAR");
ret = rx_send_aar(t->uas.request, msg, auth_session, direction, saved_t_data);
if (!ret) {
LM_ERR("Failed to send AAR\n");
tmb.t_cancel_suspend(saved_t_data->tindex, saved_t_data->tlabel);
goto error;
} else {
LM_DBG("Successful async send of AAR\n");
return CSCF_RETURN_BREAK; //on success we break - because rest of cfg file will be executed by async process
}
error:
LM_ERR("Error trying to send AAR (calling)\n");
if (saved_t_data)
free_saved_transaction_global_data(saved_t_data); //only free global data if no AARs were sent. if one was sent we have to rely on the callback (CDP) to free
//otherwise the callback will segfault
return CSCF_RETURN_ERROR;
}
