release_call.c File Reference

#include "release_call.h"

Go to the source code of this file.

Functions
void	alter_dialog_route_set (dlg_t *d, enum p_dialog_direction dir)
	Alters the saved dlg_t routes for the dialog by removing the first routes before myself.
int	send_request (str, str, dlg_t *, transaction_cb, enum p_dialog_direction)
void	confirmed_response (struct cell *t, int type, struct tmcb_params *ps)
	Callback function for BYE requests! Identify the s_dialog, then see if one BYE has already been recieved if yes drop it , if no, wait for the second.
int	release_call_confirmed (p_dialog *d, int reason_code, str reason_text)
	This functions sends BYE for a confirmed dialog.
int	release_call_previous (p_dialog *d, enum release_call_situation situation, int reason_code, str reason_text)
	Function that releases a call in early or early200 situation early200 is when the callee has already sent out 200 but that hasn't arrived yet to the caller.
int	release_call_early (p_dialog *d, int reason_code, str reason_text)
int	release_call_early200 (p_dialog *d, int reason_code, str reason_text)
int	release_call_p (p_dialog *d, int reason_code, str reason_text)
	Releases a dialog either confirmed or early the dialog is given with a lock on the hash!
int	release_call (str callid, int reason_code, str reason_text)
	Given a call-id, locate if its terminating,orginating or both release the dialog involved and drop the dialog.
int	P_release_call_onreply (struct sip_msg *msg, char *str1, char *str2)
	Releases a call from the on reply route block called with any reply to an INVITE useful in cases of rejecting a call when you are processing the SDP or handling QoS things - the sip message being processed - the first parameter "orig" or "term" - [optional] the Reason header that you want to go to the messages.
Variables
tm_binds	tmb
	Structure with pointers to tm funcs.
dlg_func_t	dialogb
	Structure with pointers to dialog funcs.
str	pcscf_record_route_mo_uri
	URI for Record-route originating.
str	pcscf_record_route_mt_uri
	URI for Record-route terminating.
static str	reason_hdr_s = {"Reason: SIP ;cause=",19}
static str	reason_hdr_1 = {" ;text=\"",8}
static str	reason_hdr_e = {"\"\r\n",3}
static str	_488_text_s = {"Not Acceptable Here",19}
static str	method_CANCEL_s = {"CANCEL",6}
static str	method_ACK_s = {"ACK",3}
static str	method_BYE_s = {"BYE",3}
static str	content_length_s = {"Content-Length: 0\r\n",19}

---

Function Documentation

void alter_dialog_route_set	(	dlg_t *	d,
		enum p_dialog_direction	dir
	)

Alters the saved dlg_t routes for the dialog by removing the first routes before myself.

This is requiered because half of the RRset is useless.

Parameters:

	d	- the dialog to modify the Record-Routes
	dir	- the direction

Definition at line 511 of file release_call.c.

References DLG_MOBILE_ORIGINATING, DLG_MOBILE_TERMINATING, NULL, pcscf_record_route_mo_uri, and pcscf_record_route_mt_uri.

Referenced by release_call_confirmed(), release_call_previous(), release_call_s(), and release_subscription().

{
    rr_t *r,*r_new; 
    str p; /*this is going to point to the scscf uri*/
        
    
    
    switch (dir) {
        case DLG_MOBILE_ORIGINATING:
            p = pcscf_record_route_mo_uri;
            break;
        case DLG_MOBILE_TERMINATING:
            p = pcscf_record_route_mt_uri;
            break;
        default:
            return;
    }
    //LOG(L_CRIT,"Looking for <%.*s> in\n",p.len,p.s);
    //for(r=d->route_set;r!=NULL;r=r->next) 
    //  LOG(L_CRIT,"<%.*s>\n",r->nameaddr.uri.len,r->nameaddr.uri.s);
        
    for(r=d->route_set;r!=NULL;r=r->next) {
        if (r->nameaddr.uri.len>=p.len && 
            strncasecmp(r->nameaddr.uri.s,p.s,r->nameaddr.uri.len)==0)
            {
                r_new=r->next;
                r->next=NULL;
                shm_free_rr(&d->route_set);
                d->route_set = r_new;
                return; 
            }
                    
    }   
}       

int send_request	(	str	,
		str	,
		dlg_t *	,
		transaction_cb	,
		enum	p_dialog_direction
	)

Definition at line 477 of file release_call.c.

References dialogb, M_NAME, and NULL.

Referenced by release_call_confirmed(), release_call_previous(), release_call_s(), and release_subscription().

{
    if((d!=NULL) && (method.s!=NULL))
    {
        enum p_dialog_direction *cbp=NULL;
        
        if (method.len !=3 || memcmp(method.s,"ACK",3)!=0)
        {
            /*In case of ACK i don't want to even send the direction
             * moreover as the memory is freed in the callback function
             * and the ACK is never replied it would be a bug if i did*/
            cbp = shm_malloc(sizeof(enum p_dialog_direction));
            if (!cbp){
                LOG(L_ERR,"ERR:"M_NAME":send_request(): error allocating %d bytes\n",sizeof(enum p_dialog_direction));
                return 0;
            }
            *cbp=dir;
        }   
        dialogb.request_inside(&method,&reqbuf,NULL, d,cb,cbp);
        return 1;
    }
    
    return 0;
}

void confirmed_response	(	struct cell *	,
		int	,
		struct tmcb_params *
	)

Callback function for BYE requests! Identify the s_dialog, then see if one BYE has already been recieved if yes drop it , if no, wait for the second.

Definition at line 175 of file release_call.c.

References d_unlock(), del_p_dialog(), del_s_dialog(), DLG_STATE_TERMINATED_ONE_SIDE, get_p_dialog_dir(), get_s_dialog_dir(), _s_dialog::hash, _p_dialog::hash, M_NAME, _s_dialog::state, and _p_dialog::state.

Referenced by release_call_confirmed(), release_call_previous(), release_call_s(), and release_subscription().

{       
    p_dialog *d;
    unsigned int hash;
    str call_id;
    
    enum p_dialog_direction dir;
    
    
    if (!ps->param) return;
    dir = *((enum p_dialog_direction *) *(ps->param));
    shm_free(*ps->param);
    *ps->param = 0;     
        
    //call_id = cscf_get_call_id(ps->rpl,0);
    call_id = t->callid;
    call_id.s+=9;
    call_id.len-=11;
    
    LOG(L_INFO,"DBG:"M_NAME":confirmed_response(): Received a BYE for a call release for <%.*s> DIR[%d].\n",
        call_id.len,call_id.s,dir);
    
    d = get_p_dialog_dir(call_id,dir);
    if (!d) {
        LOG(L_ERR,"ERR:"M_NAME":confirmed_response(): Received a BYE for a call release but there is no dialog for <%.*s> DIR[%d].\n",
            call_id.len,call_id.s,dir);
        return;
    }
    
    if (ps->code>=200){
        if (d->state==DLG_STATE_TERMINATED_ONE_SIDE){
            hash=d->hash;
            del_p_dialog(d);
            d_unlock(hash);          
        } else {
            hash=d->hash;
            d->state=DLG_STATE_TERMINATED_ONE_SIDE;
            d_unlock(hash);
        }       
    } 
}

int release_call_confirmed	(	p_dialog *	d,
		int	reason_code,
		str	reason_text
	)

This functions sends BYE for a confirmed dialog.

Parameters:

	d	- the p_dialog to end
	reason	- the Reason: header to include in the messages

Returns:

0 on error 1 on success

Definition at line 95 of file release_call.c.

References alter_dialog_route_set(), _p_dialog::call_id, confirmed_response(), content_length_s, del_p_dialog(), _p_dialog::dialog_c, _p_dialog::dialog_s, _p_dialog::direction, DLG_MOBILE_ORIGINATING, DLG_MOBILE_TERMINATING, get_p_dialog_dir_nolock(), _p_dialog::is_releasing, M_NAME, MAX_TIMES_TO_TRY_TO_RELEASE, method_BYE_s, reason_hdr_1, reason_hdr_e, reason_hdr_s, send_request(), and STR_APPEND.

Referenced by release_call_p().

{
    enum p_dialog_direction odir;
    p_dialog *o;
    str r;
    str hdrs={0,0}; 
    char buf[256];
    
    LOG(L_INFO,"DBG:"M_NAME":release_call_confirmed(): Releasing call <%.*s> DIR[%d].\n",
        d->call_id.len,d->call_id.s,d->direction);
    
    r.len = snprintf(buf,256,"%.*s%d%.*s%.*s%.*s",
        reason_hdr_s.len,reason_hdr_s.s,
        reason_code,
        reason_hdr_1.len,reason_hdr_1.s,
        reason_text.len,reason_text.s,
        reason_hdr_e.len,reason_hdr_e.s);
    r.s = buf;

    hdrs.len = r.len+content_length_s.len;  
    hdrs.s = pkg_malloc(hdrs.len);
    if (!hdrs.s){
        LOG(L_INFO,"DBG:"M_NAME":release_call_confirmed(): Error allocating %d bytes.\n",hdrs.len);
        hdrs.len=0;
        goto error;
    }
    hdrs.len=0; 
    STR_APPEND(hdrs,r);
    STR_APPEND(hdrs,content_length_s);  
        
    /* get the dialog in the other direction to see if something going on there and mark as in releasing */
    switch (d->direction){
        case DLG_MOBILE_ORIGINATING:
            odir = DLG_MOBILE_TERMINATING;
            break;
        case DLG_MOBILE_TERMINATING:
            odir = DLG_MOBILE_ORIGINATING;
            break;
        default:
            odir = d->direction;
    }   
    
    o = get_p_dialog_dir_nolock(d->call_id,odir);
    if (o && !o->is_releasing) o->is_releasing = 1;
        
    d->is_releasing++;
        
    if (d->is_releasing>MAX_TIMES_TO_TRY_TO_RELEASE){
        LOG(L_ERR,"ERR:"M_NAME":release_call_confirmed(): had to delete silently dialog %.*s in direction %i\n",d->call_id.len,d->call_id.s,d->direction);
        del_p_dialog(d);
        goto error;
    }
    if (d->is_releasing==1) {   
        /*Before generating a request, we have to generate
         * the route_set in the dlg , because the route set
         * in the dialog is for the UAC everything which was in the 
         * Record-Routes (including local address)*/
        alter_dialog_route_set(d->dialog_c,d->direction);       
        
        /*first generate the bye for called user*/
        /*then generate the bye for the calling user*/
        send_request(method_BYE_s,hdrs,d->dialog_c,confirmed_response,d->direction);
        send_request(method_BYE_s,hdrs,d->dialog_s,confirmed_response,d->direction);
        
        /*the dialog is droped by the callback-function when receives the two replies */
    }    

    if (hdrs.s) pkg_free(hdrs.s);
    return 1;
error:
    if (hdrs.s) pkg_free(hdrs.s);
    return 0;   
}

int release_call_previous	(	p_dialog *	d,
		enum release_call_situation	situation,
		int	reason_code,
		str	reason_text
	)

Function that releases a call in early or early200 situation early200 is when the callee has already sent out 200 but that hasn't arrived yet to the caller.

Parameters:

d

- p_dialog of the call - flag to distinguish between two situations

Returns:

0 on error 1 on success

Note:

This function shouldn't be called directly! use release_call_early or release_call_early200 instead

This function is full of tricks to fake states and to decieve the transaction module so that it lets us end a call in weird state

any move in the order of functions to clarify the structure can lead to a crash in P-CSCF so watch out!

Definition at line 237 of file release_call.c.

References alter_dialog_route_set(), _p_dialog::call_id, confirmed_response(), content_length_s, del_p_dialog(), _p_dialog::dialog_c, _p_dialog::direction, DLG_MOBILE_ORIGINATING, DLG_MOBILE_TERMINATING, DLG_STATE_TERMINATED_ONE_SIDE, get_p_dialog_dir_nolock(), _p_dialog::is_releasing, M_NAME, MAX_TIMES_TO_TRY_TO_RELEASE, method_ACK_s, method_BYE_s, method_CANCEL_s, reason_hdr_1, reason_hdr_e, reason_hdr_s, RELEASE_CALL_WEIRD, send_request(), _p_dialog::state, STR_APPEND, and tmb.

Referenced by P_release_call_onreply(), release_call_early(), and release_call_early200().

{
    struct cell* t;
    p_dialog *o;
    enum p_dialog_direction odir;
    int i;
    str r;
    str hdrs={0,0}; 
    char buf[256];
    
    LOG(L_INFO,"DBG:"M_NAME":release_call_previous(): Releasing call <%.*s> DIR[%d].\n",
        d->call_id.len,d->call_id.s,d->direction);
    
    r.len = snprintf(buf,256,"%.*s%d%.*s%.*s%.*s",
        reason_hdr_s.len,reason_hdr_s.s,
        reason_code,
        reason_hdr_1.len,reason_hdr_1.s,
        reason_text.len,reason_text.s,
        reason_hdr_e.len,reason_hdr_e.s);
    r.s = buf;

    hdrs.len = r.len+content_length_s.len;  
    hdrs.s = pkg_malloc(hdrs.len);
    if (!hdrs.s){
        LOG(L_INFO,"DBG:"M_NAME":release_call_previous(): Error allocating %d bytes.\n",hdrs.len);
        hdrs.len=0;
        goto error;
    }
    hdrs.len=0;
    STR_APPEND(hdrs,r);
    STR_APPEND(hdrs,content_length_s);  
                                                    
    /* get the dialog in the other direction to see if something going on there and mark as in releasing */
    switch (d->direction){
        case DLG_MOBILE_ORIGINATING:
            odir = DLG_MOBILE_TERMINATING;
            break;
        case DLG_MOBILE_TERMINATING:
            odir = DLG_MOBILE_ORIGINATING;
            break;
        default:
            odir = d->direction;
    }   
    
    o = get_p_dialog_dir_nolock(d->call_id,odir);
    if (o && !o->is_releasing) o->is_releasing = 1;
        
    d->is_releasing++;
        
    if (d->is_releasing>MAX_TIMES_TO_TRY_TO_RELEASE){
        LOG(L_ERR,"ERR:"M_NAME":release_call_previous(): had to delete silently dialog %.*s in direction %i\n",d->call_id.len,d->call_id.s,d->direction);
        del_p_dialog(d);
        goto error;
    }
    
    alter_dialog_route_set(d->dialog_c,d->direction);
    
    d->state=DLG_STATE_TERMINATED_ONE_SIDE;
    /*this is just a trick to use the same callback function*/  
    
    /*trick or treat!*/
    d->dialog_c->state=DLG_CONFIRMED;
    
    if (situation == RELEASE_CALL_WEIRD){
        send_request(method_ACK_s,hdrs,d->dialog_c,0,0);
        send_request(method_BYE_s,hdrs,d->dialog_c,confirmed_response,d->direction);
        //d->dialog_c->state=DLG_EARLY;
    } else {/*(situation == RELEASE_CALL_EARLY)*/       
        send_request(method_CANCEL_s,hdrs,d->dialog_c,confirmed_response,d->direction);
        //d->dialog_c->state=DLG_EARLY;
    }

    /*i need the cell of the invite!!*/
    /*this is very experimental
     * and very tricky too*/
    t=tmb.t_gett();
    
    if (t && t!=(void*) -1  && t->uas.request) {
        /*first trick: i really want to get this reply sent even though we are onreply*/
        *tmb.route_mode=MODE_ONFAILURE;
        
        /*second trick .. i haven't recieve any response from the uac
         * if i don't do this i get a cancel sent to the S-CSCF .. its not a big deal*/
         /*if i cared about sip forking then probably i would not do that and let the 
          * CANCEL go to the S-CSCF (reread specifications needed)*/
        for (i=0; i< t->nr_of_outgoings; i++)
            t->uac[i].last_received=99;
        /*t->uas.status=100;*/ /*no one cares about this*/
        /*now its safe to do this*/
        
        tmb.t_reply(t->uas.request,reason_code,reason_text.s);
        *tmb.route_mode=MODE_ONREPLY;
        tmb.t_release(t->uas.request);

        /*needed because if not i get last message retransmited... 
         * probably there is a more logical way to do this.. but since i really
         * want this transaction to end .. whats the point?*/
    }
    
    return 1;
error:
    if (hdrs.s) pkg_free(hdrs.s);
    return 0;   
}

int release_call_early	(	p_dialog *	d,
		int	reason_code,
		str	reason_text
	)

Definition at line 343 of file release_call.c.

References RELEASE_CALL_EARLY, and release_call_previous().

Referenced by release_call_p().

{
    /*CANCEL will be badly routed because the response hasn't being processed
     * it will be sent to I-CSCF who will relay to S-CSCF and from there to term@P-CSCF*/
    return release_call_previous(d,RELEASE_CALL_EARLY,reason_code,reason_text);
}

int release_call_early200	(	p_dialog *	d,
		int	reason_code,
		str	reason_text
	)

Definition at line 350 of file release_call.c.

References release_call_previous(), and RELEASE_CALL_WEIRD.

{
    return release_call_previous(d,RELEASE_CALL_WEIRD,reason_code,reason_text);
}

int release_call_p	(	p_dialog *	d,
		int	reason_code,
		str	reason_text
	)

Releases a dialog either confirmed or early the dialog is given with a lock on the hash!

Parameters:

	d	- p_dialog to release
	reason	- Reason header to include in messages

Returns:

0 on error , 1 on success, -1 if dialog should be deleted from outside

Definition at line 370 of file release_call.c.

References DLG_STATE_CONFIRMED, release_call_confirmed(), release_call_early(), and _p_dialog::state.

Referenced by release_call(), and terminate_p_dialog().

{       
    if (d->state>=DLG_STATE_CONFIRMED)
            return(release_call_confirmed(d,reason_code,reason_text));
     else  
            return(release_call_early(d,reason_code,reason_text)); 
}

int release_call	(	str	callid,
		int	reason_code,
		str	reason_text
	)

Given a call-id, locate if its terminating,orginating or both release the dialog involved and drop the dialog.

Parameters:

	callid	- the Call-ID to release
	reason	- the Reason header to include in messages

Returns:

0 on error, 1 on success

Definition at line 386 of file release_call.c.

{
    p_dialog *d=0;
    unsigned int hash;
    int res = 0;
    
    d = get_p_dialog_dir(callid,DLG_MOBILE_ORIGINATING);
    if (d) {                
        hash = d->hash;
        if (release_call_p(d,reason_code,reason_text)>0) res = 1;       
        goto done;      
    }
    d = get_p_dialog_dir(callid,DLG_MOBILE_TERMINATING);
    if (d) {                
        hash = d->hash;
        if (release_call_p(d,reason_code,reason_text)>0) res = 1;       
        goto done;
    } 
    
    /*Neither ORGINATING nor TERMINATING is UNKNOWN!*/
    /*or doesn't exist*/
    /*drop it silently?*/
    /*treat it as ORIGINATING or TERMINATING?*/             
done:       
    if (d) d_unlock(hash);
    return 0;   
}

int P_release_call_onreply	(	struct sip_msg *	msg,
		char *	str1,
		char *	str2
	)

Releases a call from the on reply route block called with any reply to an INVITE useful in cases of rejecting a call when you are processing the SDP or handling QoS things - the sip message being processed - the first parameter "orig" or "term" - [optional] the Reason header that you want to go to the messages.

Returns:

- TRUE on success or FALSE on misscall and BREAK on error

Definition at line 426 of file release_call.c.

References _488_text_s, cscf_get_call_id(), CSCF_RETURN_BREAK, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, d_unlock(), DLG_MOBILE_ORIGINATING, DLG_MOBILE_TERMINATING, get_p_dialog_dir(), _p_dialog::hash, is_p_dialog_dir(), M_NAME, NULL, RELEASE_CALL_EARLY, release_call_previous(), and RELEASE_CALL_WEIRD.

{
    enum p_dialog_direction dir;
    p_dialog *d=NULL;
    str callid;
    struct hdr_field *h1;
    str reason={NULL,0};
    
    if (str2) {
        reason.s=str2;
        reason.len=strlen(str2);
    } else
        reason = _488_text_s;
        
    
    dir= (str1[0]=='o' || str1[0]=='O' || str1[0]=='0')? DLG_MOBILE_ORIGINATING : DLG_MOBILE_TERMINATING;
    
    if (msg->first_line.type== SIP_REQUEST)
    {
        LOG(L_ERR,"ERR: P_release_call_on_reply called with a request\n");
        return CSCF_RETURN_FALSE;
    }
    
    callid=cscf_get_call_id(msg,&h1);
    if (is_p_dialog_dir(callid,dir)) {
        d=get_p_dialog_dir(callid,dir);
        if (msg->first_line.u.reply.statuscode > 199)
        {
            release_call_previous(d,RELEASE_CALL_WEIRD,488,reason);
            d_unlock(d->hash);
            return CSCF_RETURN_TRUE;
        } else {
            release_call_previous(d,RELEASE_CALL_EARLY,488,reason);
            d_unlock(d->hash);
            return CSCF_RETURN_TRUE;
        }
    } else {
        LOG(L_ERR,"ERR:"M_NAME "P_release_call_onreply :  unable to find dialog\n");
        return CSCF_RETURN_BREAK;
    }
    
}

---

Variable Documentation

struct tm_binds tmb

Structure with pointers to tm funcs.

Definition at line 257 of file mod.c.

dlg_func_t dialogb

Structure with pointers to dialog funcs.

Definition at line 466 of file mod.c.

str pcscf_record_route_mo_uri

URI for Record-route originating.

Definition at line 171 of file mod.c.

str pcscf_record_route_mt_uri

URI for Record-route terminating.

Definition at line 173 of file mod.c.

str reason_hdr_s = {"Reason: SIP ;cause=",19} [static]

Definition at line 70 of file release_call.c.

Referenced by release_call_confirmed(), and release_call_previous().

str reason_hdr_1 = {" ;text=\"",8} [static]

Definition at line 71 of file release_call.c.

Referenced by release_call_confirmed(), and release_call_previous().

str reason_hdr_e = {"\"\r\n",3} [static]

Definition at line 72 of file release_call.c.

Referenced by release_call_confirmed(), and release_call_previous().

str _488_text_s = {"Not Acceptable Here",19} [static]

Definition at line 76 of file release_call.c.

Referenced by P_release_call_onreply().

str method_CANCEL_s = {"CANCEL",6} [static]

Definition at line 78 of file release_call.c.

Referenced by release_call_previous().

str method_ACK_s = {"ACK",3} [static]

Definition at line 79 of file release_call.c.

Referenced by release_call_previous().

str method_BYE_s = {"BYE",3} [static]

Definition at line 80 of file release_call.c.

Referenced by release_call_confirmed(), and release_call_previous().

str content_length_s = {"Content-Length: 0\r\n",19} [static]

Definition at line 88 of file release_call.c.

Referenced by release_call_confirmed(), release_call_previous(), release_call_s(), and release_subscription().

---