void resume_ro_session_ontimeout(struct interim_ccr *i_req, int timeout_or_error) { time_t now = get_current_time_micro(); long used_secs; struct ro_session_entry *ro_session_entry = NULL; int call_terminated = 0; if (!i_req) { LM_ERR("This is so wrong: i_req is NULL\n"); return; } ro_session_entry = &(ro_session_table->entries[i_req->ro_session->h_entry]); ro_session_lock(ro_session_table, ro_session_entry); LM_DBG("credit=%d credit_valid_for=%d", i_req->new_credit, i_req->credit_valid_for); used_secs = rint((now - ((timeout_or_error==1 && i_req->ro_session->last_event_timestamp_backup>0)?i_req->ro_session->last_event_timestamp_backup : i_req->ro_session->last_event_timestamp)) / (float) 1000000); /* check to make sure diameter server is giving us sane values */ if (i_req->credit_valid_for !=0 && i_req->new_credit > i_req->credit_valid_for) { LM_WARN("That's weird, Diameter server gave us credit with a lower validity period :D. Setting reserved time to validity period instead \n"); i_req->new_credit = i_req->credit_valid_for; } if (i_req->new_credit > 0) { //now insert the new timer i_req->ro_session->last_event_timestamp = get_current_time_micro(); i_req->ro_session->event_type = answered; i_req->ro_session->valid_for = i_req->credit_valid_for; int ret = 0; if (i_req->is_final_allocation) { LM_DBG("This is a final allocation and call will end in %i seconds\n", i_req->new_credit); i_req->ro_session->event_type = no_more_credit; ret = insert_ro_timer(&i_req->ro_session->ro_tl, i_req->new_credit); } else { int timer_timeout = i_req->new_credit; if (i_req->new_credit > ro_timer_buffer /*TIMEOUTBUFFER*/) { // We haven't finished using our 1st block of units, and we need to set the timer to // (new_credit - ro_timer_buffer[5 secs]) to ensure we get new credit before our previous // reservation is exhausted. This will only be done the first time, because the timer // will always be fired 5 seconds before we run out of time thanks to this operation timer_timeout = i_req->new_credit - ro_timer_buffer; } ret = insert_ro_timer(&i_req->ro_session->ro_tl, timer_timeout); } // update to the new block of units we got i_req->ro_session->reserved_secs = i_req->new_credit; if (ret != 0) { LM_CRIT("unable to insert timer for Ro Session [%.*s]\n", i_req->ro_session->ro_session_id.len, i_req->ro_session->ro_session_id.s); } else { ref_ro_session(i_req->ro_session, 1, 0); } if (ro_db_mode == DB_MODE_REALTIME) { i_req->ro_session->flags |= RO_SESSION_FLAG_CHANGED; if (update_ro_dbinfo_unsafe(i_req->ro_session) != 0) { LM_ERR("Failed to update Ro session in DB... continuing\n"); } } } else { /* just put the timer back in with however many seconds are left (if any!!! in which case we need to kill */ /* also update the event type to no_more_credit to save on processing the next time we get here */ i_req->ro_session->event_type = no_more_credit; if (!timeout_or_error) i_req->ro_session->last_event_timestamp = get_current_time_micro(); int whatsleft = i_req->ro_session->reserved_secs - used_secs; if (whatsleft <= 0) { // TODO we need to handle this situation more precisely. // in case CCR times out, we get a call shutdown but the error message assumes it was due to a lack of credit. // LM_WARN("Immediately killing call due to no more credit *OR* no CCA received (timeout) after reservation request\n"); // // we need to unlock the session or else we might get a deadlock on dlg_terminated() dialog callback. // Do not unref the session because it will be made inside the dlg_terminated() function. // //unref_ro_session_unsafe(i_req->ro_session, 1, ro_session_entry); ro_session_unlock(ro_session_table, ro_session_entry); dlgb.lookup_terminate_dlg(i_req->ro_session->dlg_h_entry, i_req->ro_session->dlg_h_id, NULL); call_terminated = 1; } else { LM_DBG("No more credit for user - letting call run out of money in [%i] seconds", whatsleft); int ret = insert_ro_timer(&i_req->ro_session->ro_tl, whatsleft); if (ret != 0) { LM_CRIT("unable to insert timer for Ro Session [%.*s]\n", i_req->ro_session->ro_session_id.len, i_req->ro_session->ro_session_id.s); } else { ref_ro_session(i_req->ro_session, 1, 0); } } } // // if call was forcefully terminated, the lock was released before dlgb.lookup_terminate_dlg() function call. // if (!call_terminated) { unref_ro_session(i_req->ro_session, 1, 0); //unref from the initial timer that fired this event. ro_session_unlock(ro_session_table, ro_session_entry); } shm_free(i_req); LM_DBG("Exiting async ccr interim nicely"); }
void dlg_answered(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params) { struct sip_msg *reply; struct ro_session* session = 0; struct ro_session_entry* ro_session_entry; time_t now = get_current_time_micro(); time_t time_since_last_event; LM_DBG("dlg_reply callback entered\n"); if (!_params) { return; } session = (struct ro_session*) *_params->param; if (!session) { LM_ERR("Ro Session object is NULL...... aborting\n"); return; } LM_DBG("Call answered on dlg [%p] - search for Ro Session [%p]\n", dlg, session); ro_session_entry = &(ro_session_table->entries[session->h_entry]); ro_session_lock(ro_session_table, ro_session_entry); if (session->active) { LM_CRIT("Why the heck am i receiving a double confirmation of the dialog? Ignoring... "); ro_session_unlock(ro_session_table, ro_session_entry); return; } else if (session->active < 0) { //session has already been terminated - we can't reactivate... LM_WARN("Received an answer after terminating dialog.... ignoring\n"); ro_session_unlock(ro_session_table, ro_session_entry); return; } time_since_last_event = (now - session->last_event_timestamp)/1000000; session->start_time = session->last_event_timestamp = now; session->event_type = answered; session->active = 1; /* check to make sure that the validity of the credit is enough for the bundle */ int ret = 0; LM_DBG("we were granted %d seconds (valud for %d seconds) and it's been %d seconds since we requested\n", (int)session->reserved_secs, (int)session->valid_for, (int)time_since_last_event); if (session->reserved_secs < (session->valid_for - time_since_last_event)) { if (session->reserved_secs > ro_timer_buffer/*TIMEOUTBUFFER*/) { ret = insert_ro_timer(&session->ro_tl, session->reserved_secs - ro_timer_buffer); //subtract 5 seconds so as to get more credit before we run out } else { ret = insert_ro_timer(&session->ro_tl, session->reserved_secs); } } else { if (session->valid_for > ro_timer_buffer) { ret = insert_ro_timer(&session->ro_tl, session->valid_for - ro_timer_buffer); //subtract 5 seconds so as to get more credit before we run out } else { ret = insert_ro_timer(&session->ro_tl, session->valid_for); } } if (ret != 0) { LM_CRIT("unable to insert timer for Ro Session [%.*s]\n", session->ro_session_id.len, session->ro_session_id.s); } else { ref_ro_session_unsafe(session, 1); // lock already acquired } if (ro_db_mode == DB_MODE_REALTIME) { session->flags |= RO_SESSION_FLAG_CHANGED; if (update_ro_dbinfo_unsafe(session) != 0) { LM_ERR("Failed to update ro_session in database... continuing\n"); }; } ro_session_unlock(ro_session_table, ro_session_entry); AAASession* cdp_session = cdpb.AAAGetCCAccSession(session->ro_session_id); if (!cdp_session) { LM_ERR("could not find find CC App CDP session for session [%.*s]\n", session->ro_session_id.len, session->ro_session_id.s); return; } cdpb.AAAStartChargingCCAccSession(cdp_session); cdpb.AAASessionsUnlock(cdp_session->hash); }
void dlg_reply(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params) { struct sip_msg *reply; struct ro_session* session = 0; struct ro_session_entry* ro_session_entry; time_t now = time(0); time_t time_since_last_event; LM_DBG("dlg_reply callback entered\n"); if (!_params) { return; } reply = _params->rpl; if (!reply) { LM_WARN("dlg_reply has no SIP reply associated.\n"); return; } if (reply != FAKED_REPLY && reply->REPLY_STATUS == 200) { LM_DBG("Call answered on dlg [%p] - search for Ro Session and initialise timers.\n", dlg); session = (struct ro_session*)*_params->param; if (!session) { LM_ERR("Ro Session object is NULL...... aborting\n"); return; } ro_session_entry = &(ro_session_table->entries[session->h_entry]); ro_session_lock(ro_session_table, ro_session_entry); if (session->active) { LM_CRIT("Why the heck am i receiving a double confirmation of the dialog? Ignoring... "); ro_session_unlock(ro_session_table, ro_session_entry); return; } time_since_last_event = now - session->last_event_timestamp; session->start_time = session->last_event_timestamp = now; session->event_type = answered; session->active = 1; /* check to make sure that the validity of the credit is enough for the bundle */ int ret = 0; if (session->reserved_secs < (session->valid_for - time_since_last_event)) { if (session->reserved_secs > ro_timer_buffer/*TIMEOUTBUFFER*/) { ret = insert_ro_timer(&session->ro_tl, session->reserved_secs - ro_timer_buffer); //subtract 5 seconds so as to get more credit before we run out } else { ret = insert_ro_timer(&session->ro_tl, session->reserved_secs); } } else { if (session->valid_for > ro_timer_buffer) { ret = insert_ro_timer(&session->ro_tl, session->valid_for - ro_timer_buffer); //subtract 5 seconds so as to get more credit before we run out } else { ret = insert_ro_timer(&session->ro_tl, session->valid_for); } } if (ret != 0) { LM_CRIT("unable to insert timer for Ro Session [%.*s]\n", session->ro_session_id.len, session->ro_session_id.s); } else { ref_ro_session_unsafe(session, 1); // lock already acquired } if (ro_db_mode == DB_MODE_REALTIME) { session->flags |= RO_SESSION_FLAG_CHANGED; if (update_ro_dbinfo_unsafe(session) != 0) { LM_ERR("Failed to update ro_session in database... continuing\n"); }; } ro_session_unlock(ro_session_table, ro_session_entry); AAASession* cdp_session = cdpb.AAAGetCCAccSession(session->ro_session_id); if (!cdp_session) { LM_ERR("could not find find CC App CDP session for session [%.*s]\n", session->ro_session_id.len, session->ro_session_id.s); // ro_session_unlock(ro_session_table, ro_session_entry); return; } // ro_session_unlock(ro_session_table, ro_session_entry); cdpb.AAAStartChargingCCAccSession(cdp_session); cdpb.AAASessionsUnlock(cdp_session->hash); // unref_ro_session(session, 1); DONT need this anymore because we don't do lookup so no addition to ref counter } }
void dlg_terminated(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params) { //int i; int unref = 0; struct ro_session *ro_session = 0; struct ro_session_entry *ro_session_entry; struct sip_msg *request; LM_DBG("dialog [%p] terminated, lets send stop record\n", dlg); if (!_params) { return; } ro_session = (struct ro_session*)*_params->param; if (!ro_session) { LM_ERR("Ro Session object is NULL...... aborting\n"); return; } request = _params->req; if (!request) { LM_WARN("dlg_terminated has no SIP request associated.\n"); } if (dlg && (dlg->callid.s && dlg->callid.len > 0)) { /* find the session for this call, possibly both for orig and term*/ //for (i=0; i<2; i++) { //TODO: try and get the Ro session specifically for terminating dialog or originating one //currently the way we are doing is a hack..... //if ((ro_session = lookup_ro_session(dlg->h_entry, &dlg->callid, 0, 0))) { ro_session_entry = &(ro_session_table->entries[ro_session->h_entry]); //if the Ro session is not active we don't need to do anything. This prevents //double processing for various dialog_terminated callback events. //If however, the call was never answered, then we can continue as normal ro_session_lock(ro_session_table, ro_session_entry); if (!ro_session->active && (ro_session->start_time != 0)) { unref_ro_session(ro_session,1); LM_ERR("Ro Session is not active, but may have been answered [%d]\n", (int)ro_session->start_time); ro_session_unlock(ro_session_table, ro_session_entry); return; } if (ro_session->active) { // if the call was never activated, there's no timer to remove int ret = remove_ro_timer(&ro_session->ro_tl); if (ret < 0) { LM_CRIT("unable to unlink the timer on ro_session %p [%.*s]\n", ro_session, ro_session->ro_session_id.len, ro_session->ro_session_id.s); } else if (ret > 0) { LM_WARN("inconsistent ro timer data on ro_session %p [%.*s]\n", ro_session, ro_session->ro_session_id.len, ro_session->ro_session_id.s); } else { unref++; } } LM_DBG("Sending CCR STOP on Ro_Session [%p]\n", ro_session); send_ccr_stop(ro_session); ro_session->active = -1; //deleted.... terminated .... if (ro_db_mode == DB_MODE_REALTIME) { ro_session->flags |= RO_SESSION_FLAG_DELETED; if (update_ro_dbinfo_unsafe(ro_session) != 0) { LM_ERR("Unable to update Ro session in DB...continuing\n"); } } //ro_session->start_time; unref_ro_session_unsafe(ro_session, 1+unref, ro_session_entry); //lock already acquired //unref_ro_session_unsafe(ro_session, 2+unref, ro_session_entry); //lock already acquired ro_session_unlock(ro_session_table, ro_session_entry); //} //} } }
void dlg_terminated(struct dlg_cell *dlg, int type, unsigned int termcode, char* reason, struct dlg_cb_params *_params) { //int i; int unref = 0; struct ro_session *ro_session = 0; struct ro_session_entry *ro_session_entry; struct sip_msg *request; str s_reason; s_reason.s = reason; s_reason.len = strlen(reason); LM_DBG("dialog [%p] terminated on type [%d], lets send stop record\n", dlg, type); if (!_params) { return; } LM_DBG("Direction is %d\n", _params->direction); if (_params->req) { if (_params->req->first_line.u.request.method_value == METHOD_BYE) { if (_params->direction == DLG_DIR_DOWNSTREAM) { LM_DBG("Dialog ended by Caller\n"); } else { LM_DBG("Dialog ended by Callee\n"); } } else { LM_DBG("Request is %.*s\n", _params->req->first_line.u.request.method.len, _params->req->first_line.u.request.method.s); } struct hdr_field* h = get_hdr_by_name(_params->req, "Reason", 6); if(h!=NULL){ LM_DBG("reason header is [%.*s]\n", h->body.len, h->body.s); s_reason = h->body; } } else if (_params->rpl) { LM_DBG("Reply is [%d - %.*s]", _params->rpl->first_line.u.reply.statuscode, _params->rpl->first_line.u.reply.reason.len, _params->rpl->first_line.u.reply.reason.s); } ro_session = (struct ro_session*)*_params->param; if (!ro_session) { LM_ERR("Ro Session object is NULL...... aborting\n"); return; } request = _params->req; if (!request) { LM_WARN("dlg_terminated has no SIP request associated.\n"); } if (dlg && (dlg->callid.s && dlg->callid.len > 0)) { /* find the session for this call, possibly both for orig and term*/ //for (i=0; i<2; i++) { //TODO: try and get the Ro session specifically for terminating dialog or originating one //currently the way we are doing is a hack..... //if ((ro_session = lookup_ro_session(dlg->h_entry, &dlg->callid, 0, 0))) { ro_session_entry = &(ro_session_table->entries[ro_session->h_entry]); //if the Ro session is not active we don't need to do anything. This prevents //double processing for various dialog_terminated callback events. //If however, the call was never answered, then we can continue as normal ro_session_lock(ro_session_table, ro_session_entry); LM_DBG("processing dlg_terminated in Ro and session [%.*s] has active = %d", ro_session->ro_session_id.len, ro_session->ro_session_id.s, ro_session->active); if ((!ro_session->active && (ro_session->start_time != 0)) || (ro_session->ccr_sent == 1)) { unref_ro_session_unsafe(ro_session,1,ro_session_entry); LM_DBG("CCR already sent or Ro Session is not active, but may have been answered [%d]\n", (int)ro_session->start_time); ro_session_unlock(ro_session_table, ro_session_entry); return; } if (ro_session->active) { // if the call was never activated, there's no timer to remove int ret = remove_ro_timer(&ro_session->ro_tl); if (ret < 0) { LM_CRIT("unable to unlink the timer on ro_session %p [%.*s]\n", ro_session, ro_session->ro_session_id.len, ro_session->ro_session_id.s); } else if (ret > 0) { LM_WARN("inconsistent ro timer data on ro_session %p [%.*s]\n", ro_session, ro_session->ro_session_id.len, ro_session->ro_session_id.s); } else { unref++; } } LM_DBG("Sending CCR STOP on Ro_Session [%p]\n", ro_session); send_ccr_stop_with_param(ro_session, termcode, &s_reason); ro_session->active = -1; //deleted.... terminated .... ro_session->ccr_sent = 1; // counter_add(ims_charging_cnts_h.active_ro_sessions, -1); if (ro_db_mode == DB_MODE_REALTIME) { ro_session->flags |= RO_SESSION_FLAG_DELETED; if (update_ro_dbinfo_unsafe(ro_session) != 0) { LM_ERR("Unable to update Ro session in DB...continuing\n"); } } //ro_session->start_time; unref_ro_session_unsafe(ro_session, 1+unref, ro_session_entry); //lock already acquired //unref_ro_session_unsafe(ro_session, 2+unref, ro_session_entry); //lock already acquired ro_session_unlock(ro_session_table, ro_session_entry); //} //} } }