/**
* Save this subscription.
* @param msg - the SIP SUBSCRIBE message
* @param str1 - not used
* @param str2 - not used
* @returns #CSCF_RETURN_TRUE if allowed, #CSCF_RETURN_FALSE if not, #CSCF_RETURN_ERROR on error
*/
int S_subscribe(struct sip_msg *msg,char *str1,char *str2)
{
int ret=CSCF_RETURN_FALSE;
struct sip_uri puri;
str uri={0,0};
str event;
int event_i=IMS_EVENT_NONE;
int expires=0,expires_time=0;
str subscriber;
r_public *p=0;
r_subscriber *s=0,*new_s=0;
dlg_t *dialog=0;
LOG(L_DBG,"DBG:"M_NAME":S_subscribe: Saving SUBSCRIBE\n");
/* First check the parameters */
if (msg->first_line.type!=SIP_REQUEST)
{
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: This message is not a request\n");
goto error;
}
if (msg->first_line.u.request.method.len != 9 ||
memcmp(msg->first_line.u.request.method.s,"SUBSCRIBE",9)!=0)
{
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: This message is not a SUBSCRIBE\n");
goto error;
}
/* 1. Get the event */
event = cscf_get_event(msg);
if (event.len!=3||strncasecmp(event.s,"reg",3)!=0){
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Accepting only <Event: reg>. Found: <%.*s>\n",
event.len,event.s);
ret = CSCF_RETURN_FALSE;
goto done;
}
if (event.len==0 && strncasecmp(event.s,"reg",3)==0)
event_i = IMS_EVENT_REG;
/* 2. Get the target of the SUBSCRIBE from RequestURI */
if (msg->new_uri.s) uri = msg->new_uri;
else uri = msg->first_line.u.request.uri;
if (parse_uri(uri.s, uri.len, &puri) < 0) {
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Error parsing uri <%.*s>\n",
uri.len,uri.s);
goto error;
}
uri.len = lookup_sip.len+puri.user.len+1+puri.host.len;
uri.s = pkg_malloc(uri.len);
if (!uri.s){
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Error allocating %d bytes\n",uri.len);
goto error;
}
uri.len=0;
memcpy(uri.s,lookup_sip.s,lookup_sip.len);
uri.len+=lookup_sip.len;
memcpy(uri.s+uri.len,puri.user.s,puri.user.len);
uri.len+=puri.user.len;
uri.s[uri.len++]='@';
memcpy(uri.s+uri.len,puri.host.s,puri.host.len);
uri.len+=puri.host.len;
/* 3. Get the Subscriber's Identity */
subscriber = cscf_get_contact(msg);
if (!subscriber.len){
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Contact empty.\n");
ret = CSCF_RETURN_FALSE;
goto done;
}
LOG(L_DBG,"DBG:"M_NAME":S_subscribe: Contact <%.*s>.\n",
subscriber.len,subscriber.s);
p = get_r_public(uri);
/* Registration is possible even if the user is not registered... so just create one */
if (!p){
p = add_r_public(uri,0,0);
}
if (!p){
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Identity not found and error on creation <%.*s>\n",
uri.len,uri.s);
ret = CSCF_RETURN_FALSE;
goto done;
}
expires = cscf_get_expires_hdr(msg,0);
if (expires == -1) expires = subscription_default_expires;
if (expires > 0) {
if (expires < subscription_min_expires) expires = subscription_min_expires;
if (expires > subscription_max_expires) expires = subscription_max_expires;
r_act_time();
expires_time = expires + time_now;
/* get the old subscriber - if any */
s = get_r_subscriber(p,subscriber,event_i);
if (!s){
/* create a new dialog */
if (tmb.new_dlg_uas(msg, 200, &dialog) < 0) {
LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Error while creating dialog state\n");
ret = CSCF_RETURN_FALSE;
goto error;
}
}else
dialog = s->dialog;
/* update the subscriber */
if ((new_s=update_r_subscriber(p,subscriber,event_i,&expires_time,dialog))!=0){
//if (!s) /* Only on first subscription, not on refreshes, send a notify */
S_event_reg(p,0,new_s,IMS_REGISTRAR_SUBSCRIBE,0);
ret = CSCF_RETURN_TRUE;
}
else
ret = CSCF_RETURN_FALSE;
}else{
/* Unsubscribe */
/* get the old subscriber - if any */
r_act_time();
s = get_r_subscriber(p,subscriber,event_i);
if (s) {
s->expires = time_now;
S_event_reg(p,0,s,IMS_REGISTRAR_UNSUBSCRIBE,1);
del_r_subscriber(p,s);
}
ret = CSCF_RETURN_TRUE;
}
done:
r_unlock(p->hash);
if (expires ==0 )S_SUBSCRIBE_reply(msg,200,MSG_REG_UNSUBSCRIBE_OK,&expires,&uri);
else S_SUBSCRIBE_reply(msg,200,MSG_REG_SUBSCRIBE_OK,&expires,&uri);
if (uri.s) pkg_free(uri.s);
return ret;
error:
if (p) r_unlock(p->hash);
if (uri.s) pkg_free(uri.s);
ret=CSCF_RETURN_FALSE;
return ret;
}
static int w_ro_ccr(struct sip_msg *msg, char* c_route_name, char* c_direction, char* c_charge_type, char* c_unit_type, int reservation_units, char* c_trunk_id) {
/* PSEUDOCODE/NOTES
* 1. What mode are we in - terminating or originating
* 2. check request type - IEC - Immediate Event Charging
* ECUR - Event Charging with Unit Reservation
* SCUR - Session Charging with Unit Reservation
* 3. probably only do SCUR in this module for now - can see event based charging in another component instead (AS for SMS for example, etc)
* 4. Check a dialog exists for call, if not we fail
* 5. make sure we dont already have an Ro Session for this dialog
* 6. create new Ro Session
* 7. register for DLG callback passing new Ro session as parameter - (if dlg torn down we know which Ro session it is associated with)
*
*
*/
int ret = RO_RETURN_TRUE;
int dir = 0;
str identity = {0, 0},
contact = {0, 0};
struct hdr_field *h=0;
cfg_action_t* cfg_action;
tm_cell_t *t;
unsigned int tindex = 0,
tlabel = 0;
struct impu_data *impu_data;
char *p;
struct dlg_cell* dlg;
unsigned int len;
struct ro_session *ro_session = 0;
int free_contact = 0;
str s_route_name, s_direction, s_charge_type, s_unit_type, s_trunk_id;
if (get_str_fparam(&s_route_name, msg, (fparam_t*) c_route_name) < 0) {
LM_ERR("failed to get s_route_name\n");
return RO_RETURN_ERROR;
}
if (get_str_fparam(&s_direction, msg, (fparam_t*) c_direction) < 0) {
LM_ERR("failed to get s_direction\n");
return RO_RETURN_ERROR;
}
if (get_str_fparam(&s_charge_type, msg, (fparam_t*) c_charge_type) < 0) {
LM_ERR("failed to get s_charge_type\n");
return RO_RETURN_ERROR;
}
if (get_str_fparam(&s_unit_type, msg, (fparam_t*) c_unit_type) < 0) {
LM_ERR("failed to get s_unit_type\n");
return RO_RETURN_ERROR;
}
if (get_str_fparam(&s_trunk_id, msg, (fparam_t*) c_trunk_id) < 0) {
LM_ERR("failed to get s_trunk_id\n");
return RO_RETURN_ERROR;
}
LM_DBG("Ro CCR initiated: direction:%.*s, charge_type:%.*s, unit_type:%.*s, reservation_units:%i, route_name:%.*s, trunk_id:%.*s\n",
s_direction.len, s_direction.s,
s_charge_type.len, s_charge_type.s,
s_unit_type.len, s_unit_type.s,
reservation_units,
s_route_name.len, s_route_name.s,
s_trunk_id.len, s_trunk_id.s);
if (msg->first_line.type != SIP_REQUEST) {
LM_ERR("Ro_CCR() called from SIP reply.");
return RO_RETURN_ERROR;;
}
//make sure we can get the dialog! if not, we can't continue
dlg = dlgb.get_dlg(msg);
if (!dlg) {
LM_ERR("Unable to find dialog and cannot do Ro charging without it\n");
return RO_RETURN_ERROR;
}
dir = get_direction_as_int(&s_direction);
if (dir == RO_ORIG_DIRECTION) {
//get caller IMPU from asserted identity
if ((identity = cscf_get_asserted_identity(msg, 0)).len == 0) {
LM_DBG("No P-Asserted-Identity hdr found. Using From hdr for asserted_identity");
identity = dlg->from_uri;
}
//get caller contact from contact header - if not present then skip this
if ((contact = cscf_get_contact(msg)).len == 0) {
LM_WARN("Can not get contact from message - will not get callbacks if this IMPU is removed to terminate call");
goto send_ccr;
}
} else if (dir == RO_TERM_DIRECTION){
//get callee IMPU from called part id - if not present then skip this
if ((identity = cscf_get_public_identity_from_called_party_id(msg, &h)).len == 0) {
LM_WARN("No P-Called-Identity hdr found - will not get callbacks if this IMPU is removed to terminate call");
goto send_ccr;
}
//get callee contact from request URI
contact = cscf_get_contact_from_requri(msg);
free_contact = 1;
} else {
LM_CRIT("don't know what to do in unknown mode - should we even get here\n");
ret = RO_RETURN_ERROR;
goto done;
}
LM_DBG("IMPU data to pass to usrloc: contact <%.*s> identity <%.*s>\n", contact.len, contact.s, identity.len, identity.s);
//create impu_data_parcel
len = identity.len + contact.len + sizeof (struct impu_data);
impu_data = (struct impu_data*) shm_malloc(len);
if (!impu_data) {
LM_ERR("Unable to allocate memory for impu_data, trying to send CCR\n");
ret = RO_RETURN_ERROR;
goto done;
}
memset(impu_data, 0, len);
p = (char*) (impu_data + 1);
impu_data->identity.s = p;
impu_data->identity.len = identity.len;
memcpy(p, identity.s, identity.len);
p += identity.len;
impu_data->contact.s = p;
impu_data->contact.len = contact.len;
memcpy(p, contact.s, contact.len);
p += contact.len;
if (p != (((char*) impu_data) + len)) {
LM_ERR("buffer overflow creating impu data, trying to send CCR\n");
shm_free(impu_data);
ret = RO_RETURN_ERROR;
goto done;
}
//reg for callbacks on confirmed and terminated
if (dlgb.register_dlgcb(dlg, /* DLGCB_RESPONSE_FWDED */ DLGCB_CONFIRMED, add_dlg_data_to_contact, (void*)impu_data ,NULL ) != 0) {
LM_CRIT("cannot register callback for dialog confirmation\n");
ret = RO_RETURN_ERROR;
goto done;
}
if (dlgb.register_dlgcb(dlg, DLGCB_TERMINATED | DLGCB_FAILED | DLGCB_EXPIRED /*| DLGCB_DESTROY */, remove_dlg_data_from_contact, (void*)impu_data, NULL ) != 0) {
LM_CRIT("cannot register callback for dialog termination\n");
ret = RO_RETURN_ERROR;
goto done;
}
send_ccr:
//check if we need to send_ccr -
//we get the ro_session based on dlg->h_id and dlg->h_entry and direction 0 (so get any ro_session)
//if it already exists then we go to done
if (single_ro_session_per_dialog && (ro_session = lookup_ro_session(dlg->h_entry, &dlg->callid, 0, 0))) {
LM_DBG("single_ro_session_per_dialog = 1 and ro_session already exists for this dialog -so we don't need to send another one\n");
unref_ro_session(ro_session,1);//for the lookup ro session ref
goto done;
}
LM_DBG("Looking for route block [%.*s]\n", s_route_name.len, s_route_name.s);
int ri = route_get(&main_rt, s_route_name.s);
if (ri < 0) {
LM_ERR("unable to find route block [%.*s]\n", s_route_name.len, s_route_name.s);
ret = RO_RETURN_ERROR;
goto done;
}
cfg_action = main_rt.rlist[ri];
if (!cfg_action) {
LM_ERR("empty action lists in route block [%.*s]\n", s_route_name.len, s_route_name.s);
ret = RO_RETURN_ERROR;
goto done;
}
//before we send lets suspend the transaction
t = tmb.t_gett();
if (t == NULL || t == T_UNDEFINED) {
if (tmb.t_newtran(msg) < 0) {
LM_ERR("cannot create the transaction for CCR async\n");
ret = RO_RETURN_ERROR;
goto done;
}
t = tmb.t_gett();
if (t == NULL || t == T_UNDEFINED) {
LM_ERR("cannot lookup the transaction\n");
ret = RO_RETURN_ERROR;
goto done;
}
}
LM_DBG("Suspending SIP TM transaction\n");
if (tmb.t_suspend(msg, &tindex, &tlabel) < 0) {
LM_ERR("failed to suspend the TM processing\n");
ret = RO_RETURN_ERROR;
goto done;
}
ret = Ro_Send_CCR(msg, dlg, dir, &s_charge_type, &s_unit_type, reservation_units, &s_trunk_id, cfg_action, tindex, tlabel);
if(ret < 0){
LM_ERR("Failed to send CCR\n");
tmb.t_cancel_suspend(tindex, tlabel);
}
done:
if(free_contact) shm_free(contact.s);// shm_malloc in cscf_get_public_identity_from_requri
return ret;
}