dlg_state.c File Reference

---

Detailed Description

Proxy-CSCF - Dialog State.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Alberto Diez - Support of release_call

Definition in file dlg_state.c.

#include <time.h>
#include "dlg_state.h"
#include "../../mem/shm_mem.h"
#include "../sl/sl_funcs.h"
#include "sip.h"
#include "release_call.h"
#include "ims_pm.h"

Go to the source code of this file.

Defines
#define	strtotime(src, dest)
#define	FParam_INT(val)
#define	FParam_STRING(val)
#define	h_inc   h+=v^(v>>3)
Functions
int	supports_extension (struct sip_msg *m, str *extension)
int	requires_extension (struct sip_msg *m, str *extension)
unsigned int	get_p_dialog_hash (str call_id)
	Computes the hash for a string.
int	p_dialogs_init (int hash_size)
	Initialize the registrar.
void	p_dialogs_destroy ()
	Destroy the registrar.
void	d_lock (unsigned int hash)
	Locks the required part of the hash table.
void	d_unlock (unsigned int hash)
	UnLocks the required part of the hash table.
int	d_act_time ()
	Actualize the current time.
void	p_dialog_count_lock ()
	Locks the dialog counter variable.
void	p_dialog_count_unlock ()
	UnLocks the dialog counter variable.
int	p_dialog_count_increment ()
	Try to increment the dialog count.
void	p_dialog_count_decrement ()
	Decrement the dialog count.
p_dialog *	new_p_dialog (str call_id, str host, int port, int transport)
	Creates a new p_dialog structure.
p_dialog *	add_p_dialog (str call_id, str host, int port, int transport)
	Creates and adds a p_dialog to the hash table.
int	is_p_dialog (str call_id, str host, int port, int transport, enum p_dialog_direction *dir)
	Finds out if a dialog is in the hash table.
int	is_p_dialog_dir (str call_id, enum p_dialog_direction dir)
	Finds out if a dialog is in the hash table.
p_dialog *	get_p_dialog (str call_id, str host, int port, int transport, enum p_dialog_direction *dir)
	Finds and returns a dialog from the hash table.
p_dialog *	get_p_dialog_dir (str call_id, enum p_dialog_direction dir)
	Finds and returns a dialog from the hash table.
p_dialog *	get_p_dialog_dir_nolock (str call_id, enum p_dialog_direction dir)
	Finds and returns a dialog from the hash table.
int	terminate_p_dialog (p_dialog *d)
	Terminates a dialog - called before del_p_dialog to send out terminatination messages.
void	del_p_dialog (p_dialog *d)
	Deletes and destroys the dialog from the hash table.
void	free_p_dialog (p_dialog *d)
	Destroys the dialog.
void	print_p_dialogs (int log_level)
	Prints the dialog hash table.
static enum p_dialog_direction	get_dialog_direction (char *direction)
	Returns the p_dialog_direction from the direction string.
static int	find_dialog_contact (struct sip_msg *msg, enum p_dialog_direction dir, str *host, int *port, int *transport)
	Finds the contact host/port/transport for a dialog.
int	P_is_in_dialog (struct sip_msg *msg, char *str1, char *str2)
	Find out if a message is within a saved dialog.
static enum p_dialog_method	get_dialog_method (str method)
	Return p_dialog_method for a method string.
int	P_422_session_expires (struct sip_msg *msg, char *str1, char *str2)
	Send a 422 Session Interval Too Small.
int	P_check_session_expires (struct sip_msg *msg, char *str1, char *str2)
	Checks if Session-Expires value is over Min_SE local policy.
int	P_save_dialog (struct sip_msg *msg, char *str1, char *str2)
	Saves a dialog.
void	save_dialog_routes (struct sip_msg *msg, char *str1, p_dialog *d)
	Save the Record-routes for a dialog.
int	update_dialog_on_reply (struct sip_msg *msg, p_dialog *d)
	Updates dialog on reply message.
int	P_update_dialog (struct sip_msg *msg, char *str1, char *str2)
	Updates a dialog.
int	P_drop_dialog (struct sip_msg *msg, char *str1, char *str2)
	Drops and deletes a dialog.
int	P_drop_all_dialogs (str host, int port, int transport)
	Drop all dialogs belonging to one contact.
int	P_follows_dialog_routes (struct sip_msg *msg, char *str1, char *str2)
	Checks if the message follows the saved dialog routes.
int	P_enforce_dialog_routes (struct sip_msg *msg, char *str1, char *str2)
	Inserts the Route header containing the dialog routes to be enforced.
int	P_record_route (struct sip_msg *msg, char *str1, char *str2)
	Record routes, with given user as parameter.
void	dialog_timer (unsigned int ticks, void *param)
	The dialog timer looks for expired dialogs and removes them.
Variables
int	p_dialogs_hash_size
	size of the dialog hash table
p_dialog_hash_slot *	p_dialogs = 0
	the hash table
int	pcscf_dialogs_expiration_time
	expiration time for a dialog
int	pcscf_dialogs_enable_release
	if to enable dialog release
time_t	d_time_now
	current time for dialog updates
str	pcscf_record_route_mo
	Record-route for originating case.
str	pcscf_record_route_mo_uri
	URI for Record-route originating.
str	pcscf_record_route_mt
	Record-route for terminating case.
str	pcscf_record_route_mt_uri
	URI for Record-route terminating.
str	pcscf_name_str
	fixed SIP URI of this P-CSCF
tm_binds	tmb
	Structure with pointers to tm funcs.
int	pcscf_min_se
	Minimum session-expires accepted value.
int(*)	sl_reply (struct sip_msg *_msg, char *_str1, char *_str2)
	link to the stateless reply function in sl module
int *	pcscf_dialog_count
	Counter for saved dialogs.
int	pcscf_max_dialog_count
	Maximum number of dialogs.
gen_lock_t *	pcscf_dialog_count_lock
	Lock for the dialog counter.
str	reason_terminate_p_dialog_s = {"Session terminated in the P-CSCF",32}
str	s_OTHER = {"<OTHER>",7}
str	s_INVITE = {"INVITE",6}
str	s_SUBSCRIBE = {"SUBSCRIBE",9}
static fparam_t	fp_422 = FParam_INT(422)
static fparam_t	fp_se_small = FParam_STRING("Session Interval Too Small")
static str	s_refresher = {"refresher=", 10}
static str	str_ext_timer = {"timer", 5}
static str	str_min_se = {"Min-SE:",7}
static str	str_se = {"Session-Expires:",16}
static str	str_require = {"Require:",8}
static str	route_s = {"Route: <",8}
static str	route_1 = {">, <",4}
static str	route_e = {">\r\n",3}
static str	s_record_route_s = {"Record-Route: <",15}
static str	s_record_route_e = {";lr>\r\n",6}

---

Define Documentation

#define strtotime	(	src,
		dest		)

Value:

{\
    int i;\
    (dest)=0;\
    for(i=0;i<(src).len;i++)\
        if ((src).s[i]>='0' && (src).s[i]<='9')\
            (dest) = (dest)*10 + (src).s[i] -'0';\
}

Definition at line 88 of file dlg_state.c.

#define FParam_INT

(

val

)

Value:

{ \
     .v = { \
        .i = val \
     },\
    .type = FPARAM_INT, \
    .orig = "int_value", \
};

Definition at line 98 of file dlg_state.c.

#define FParam_STRING

(

val

)

Value:

{ \
    .v = { \
        .str = STR_STATIC_INIT(val) \
    },\
    .type = FPARAM_STR, \
    .orig = val, \
};

Definition at line 106 of file dlg_state.c.

#define h_inc   h+=v^(v>>3)

---

Function Documentation

int supports_extension	(	struct sip_msg *	m,
		str *	extension
	)

Referenced by P_check_session_expires(), P_save_dialog(), P_update_dialog(), S_check_session_expires(), S_save_dialog(), and S_update_dialog().

int requires_extension	(	struct sip_msg *	m,
		str *	extension
	)

Referenced by update_dialog_on_reply().

unsigned int get_p_dialog_hash

(

str

call_id

)

[inline]

Computes the hash for a string.

Parameters:

call_id

- input string

Returns:

- the hash

Definition at line 120 of file dlg_state.c.

References h_inc, and p_dialogs_hash_size.

Referenced by bin_decode_p_dialog(), get_p_dialog(), get_p_dialog_dir(), get_p_dialog_dir_nolock(), is_p_dialog(), is_p_dialog_dir(), and new_p_dialog().

{
    if (call_id.len==0) return 0;
#define h_inc h+=v^(v>>3)
   char* p;
   register unsigned v;
   register unsigned h;

   h=0;
   for (p=call_id.s; p<=(call_id.s+call_id.len-4); p+=4){
       v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
       h_inc;
   }
   v=0;
   for (;p<(call_id.s+call_id.len); p++) {
       v<<=8;
       v+=*p;
   }
   h_inc;

   h=((h)+(h>>11))+((h>>13)+(h>>23));
   return (h)%p_dialogs_hash_size;
#undef h_inc 
}

int p_dialogs_init

(

int

hash_size

)

Initialize the registrar.

Parameters:

hash_size

- the number of hash table cells

Returns:

1 on success, 0 on error

Definition at line 150 of file dlg_state.c.

References p_dialog_hash_slot::lock, M_NAME, p_dialogs, and p_dialogs_hash_size.

Referenced by mod_init().

{
    int i;
    
    p_dialogs_hash_size = hash_size;
    p_dialogs = shm_malloc(sizeof(p_dialog_hash_slot)*p_dialogs_hash_size);

    if (!p_dialogs) return 0;

    memset(p_dialogs,0,sizeof(p_dialog_hash_slot)*p_dialogs_hash_size);
    
    for(i=0;i<p_dialogs_hash_size;i++){
        p_dialogs[i].lock = lock_alloc();
        if (!p_dialogs[i].lock){
            LOG(L_ERR,"ERR:"M_NAME":d_hash_table_init(): Error creating lock\n");
            return 0;
        }
        p_dialogs[i].lock = lock_init(p_dialogs[i].lock);
    }
            
    return 1;
}

void p_dialogs_destroy

(

)

Destroy the registrar.

Definition at line 176 of file dlg_state.c.

References d_lock(), d_unlock(), free_p_dialog(), p_dialog_hash_slot::head, _p_dialog::next, p_dialogs, and p_dialogs_hash_size.

Referenced by mod_destroy().

{
    int i;
    p_dialog *d,*nd;
    for(i=0;i<p_dialogs_hash_size;i++){
        d_lock(i);
            d = p_dialogs[i].head;
            while(d){
                nd = d->next;
                free_p_dialog(d);
                d = nd;
            }
        d_unlock(i);
        lock_dealloc(p_dialogs[i].lock);
    }
    shm_free(p_dialogs);
}

void d_lock

(

unsigned int

hash

)

[inline]

Locks the required part of the hash table.

Parameters:

hash

- hash of the element to lock (hash slot number)

Definition at line 198 of file dlg_state.c.

Referenced by add_p_dialog(), add_s_dialog(), bin_cache_dump_dialogs_to_table(), bin_cache_load_dialogs_from_table(), dialog_timer(), get_p_dialog(), get_p_dialog_dir(), get_s_dialog(), get_s_dialog_dir(), is_p_dialog(), is_p_dialog_dir(), is_s_dialog(), is_s_dialog_dir(), load_snapshot_dialogs(), make_snapshot_dialogs(), p_dialogs_destroy(), P_drop_all_dialogs(), print_p_dialogs(), print_s_dialogs(), s_dialogs_destroy(), and S_drop_all_dialogs().

{
//  LOG(L_CRIT,"GET %d\n",hash);
    lock_get(p_dialogs[(hash)].lock);
//  LOG(L_CRIT,"GOT %d\n",hash);    
}

void d_unlock

(

unsigned int

hash

)

[inline]

UnLocks the required part of the hash table.

Parameters:

hash

- hash of the element to lock (hash slot number)

Definition at line 209 of file dlg_state.c.

Referenced by bin_cache_dump_dialogs_to_table(), bin_cache_load_dialogs_from_table(), confirmed_response(), dialog_timer(), get_p_dialog(), get_p_dialog_dir(), get_s_dialog(), get_s_dialog_dir(), is_p_dialog(), is_p_dialog_dir(), is_s_dialog(), is_s_dialog_dir(), load_snapshot_dialogs(), make_snapshot_dialogs(), p_dialogs_destroy(), P_drop_all_dialogs(), P_drop_dialog(), P_enforce_dialog_routes(), P_follows_dialog_routes(), P_release_call_onreply(), P_save_dialog(), P_update_dialog(), print_p_dialogs(), print_s_dialogs(), release_call(), s_dialogs_destroy(), S_drop_all_dialogs(), S_drop_dialog(), S_save_dialog(), and S_update_dialog().

{
    lock_release(p_dialogs[(hash)].lock);
//  LOG(L_CRIT,"RELEASED %d\n",hash);   
}

int d_act_time

(

)

[inline]

Actualize the current time.

Returns:

the current time

Definition at line 219 of file dlg_state.c.

References d_time_now.

Referenced by dialog_timer(), P_save_dialog(), P_update_dialog(), print_p_dialogs(), print_s_dialogs(), S_save_dialog(), S_update_dialog(), and update_dialog_on_reply().

{
    d_time_now=time(0);
    return d_time_now;
}

void p_dialog_count_lock

(

)

[inline]

Locks the dialog counter variable.

Definition at line 232 of file dlg_state.c.

References pcscf_dialog_count_lock.

Referenced by p_dialog_count_decrement(), and p_dialog_count_increment().

{
    lock_get(pcscf_dialog_count_lock);
}

void p_dialog_count_unlock

(

)

[inline]

UnLocks the dialog counter variable.

Definition at line 240 of file dlg_state.c.

References pcscf_dialog_count_lock.

Referenced by p_dialog_count_decrement(), and p_dialog_count_increment().

{
        lock_release(pcscf_dialog_count_lock);
}

int p_dialog_count_increment

(

)

[inline]

Try to increment the dialog count.

Returns:

1 on success or 0 if the total number of dialogs is already reached

Definition at line 250 of file dlg_state.c.

References M_NAME, p_dialog_count_lock(), p_dialog_count_unlock(), pcscf_dialog_count, and pcscf_max_dialog_count.

Referenced by new_p_dialog().

{
    if (pcscf_max_dialog_count<0) return 1;
    p_dialog_count_lock();  
    if (*pcscf_dialog_count<pcscf_max_dialog_count){
        (*pcscf_dialog_count)++;
        p_dialog_count_unlock();
        return 1;
    } else {
        p_dialog_count_unlock();
        return 0;
    }
    LOG(L_DBG,"DBG:"M_NAME":p_dialog_count_increment(): P-CSCF Dialog counter value is %d\n", *pcscf_dialog_count);
}

void p_dialog_count_decrement

(

)

[inline]

Decrement the dialog count.

Definition at line 268 of file dlg_state.c.

References M_NAME, p_dialog_count_lock(), p_dialog_count_unlock(), pcscf_dialog_count, and pcscf_max_dialog_count.

Referenced by free_p_dialog(), and new_p_dialog().

{
    if (pcscf_max_dialog_count<0) return ;
    p_dialog_count_lock();
    (*pcscf_dialog_count)--;
    p_dialog_count_unlock();
    LOG(L_DBG,"DBG:"M_NAME":p_dialog_count_decrement(): P-CSCF Dialog counter value is %d\n", *pcscf_dialog_count);    
}

p_dialog* new_p_dialog	(	str	call_id,
		str	host,
		int	port,
		int	transport
	)

Creates a new p_dialog structure.

Does not add the structure to the list.

Parameters:

	call_id	- call-id of the dialog
	host	- host that originates/terminates this dialog
	port	- port that originates/terminates this dialog
	transport	- transport that originates/terminates this dialog

Returns:

the new p_dialog* on success, or NULL on error;

Definition at line 287 of file dlg_state.c.

References _p_dialog::call_id, get_p_dialog_hash(), _p_dialog::hash, _p_dialog::host, M_NAME, p_dialog_count_decrement(), p_dialog_count_increment(), _p_dialog::port, STR_SHM_DUP, and _p_dialog::transport.

Referenced by add_p_dialog().

{
    p_dialog *d;
    
    if (!p_dialog_count_increment()) return 0;
    d = shm_malloc(sizeof(p_dialog));
    if (!d) {
        LOG(L_ERR,"ERR:"M_NAME":new_p_dialog(): Unable to alloc %d bytes\n",
            sizeof(p_dialog));
        goto error;
    }
    memset(d,0,sizeof(p_dialog));
    
    d->hash = get_p_dialog_hash(call_id);       
    STR_SHM_DUP(d->call_id,call_id,"shm");
    STR_SHM_DUP(d->host,host,"shm");    
    d->port = port;
    d->transport = transport;
                
    return d;
error:
out_of_memory:
    if (d){
        if (d->call_id.s) shm_free(d->call_id.s);
        if (d->host.s) shm_free(d->host.s);
        shm_free(d);        
    }
    p_dialog_count_decrement();
    return 0;
}

p_dialog* add_p_dialog	(	str	call_id,
		str	host,
		int	port,
		int	transport
	)

Creates and adds a p_dialog to the hash table.

Note:

Locks the hash slot if ok! Call d_unlock(p_dialog->hash) when you are finished)

make sure that is_p_dialog(call_id) returns 0 or there will be unreachable duplicates!

Parameters:

	call_id	- dialog's call_id
	host	- host that originates/terminates this dialog
	port	- port that originates/terminates this dialog
	transport	- transport that originates/terminates this dialog

Returns:

the new p_dialog* on success, or NULL on error;

Definition at line 328 of file dlg_state.c.

References d_lock(), _p_dialog::hash, p_dialog_hash_slot::head, new_p_dialog(), _p_dialog::next, p_dialogs, _p_dialog::prev, and p_dialog_hash_slot::tail.

Referenced by P_save_dialog().

{
    p_dialog *d;
    
    d = new_p_dialog(call_id,host,port,transport);
    if (!d) return 0;       
    
    d_lock(d->hash);
        d->next = 0;
        d->prev = p_dialogs[d->hash].tail;
        if (d->prev) d->prev->next = d;
        p_dialogs[d->hash].tail = d;
        if (!p_dialogs[d->hash].head) p_dialogs[d->hash].head = d;

        return d;
}

int is_p_dialog	(	str	call_id,
		str	host,
		int	port,
		int	transport,
		enum p_dialog_direction *	dir
	)

Finds out if a dialog is in the hash table.

Parameters:

	call_id	- dialog's call_id
	host	- host that originates/terminates this dialog
	port	- port that originates/terminates this dialog
	transport	- transport that originates/terminates this dialog
	dir	- the direction of the dialog. if NULL, it doesn't matter

Returns:

- 1 if the dialog exists, 0 if not

Note:

transport is ignored.

Definition at line 355 of file dlg_state.c.

References _p_dialog::call_id, d_lock(), d_unlock(), _p_dialog::direction, get_p_dialog_hash(), p_dialog_hash_slot::head, _p_dialog::host, _p_dialog::next, p_dialogs, and _p_dialog::port.

Referenced by P_is_in_dialog(), and P_save_dialog().

{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if ((!dir || d->direction == *dir) &&
                d->port == port &&
/*              d->transport == transport &&*/
/* commented because of strange behaviour */
                d->host.len == host.len &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->host.s,host.s,host.len)==0 &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    d_unlock(hash);
                    return 1;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}

int is_p_dialog_dir	(	str	call_id,
		enum p_dialog_direction	dir
	)

Finds out if a dialog is in the hash table.

Parameters:

	call_id	- dialog's call_id
	dir	- the direction of the dialog

Returns:

- 1 if the dialog exists, 0 if not

Note:

transport is ignored.

Definition at line 387 of file dlg_state.c.

References _p_dialog::call_id, d_lock(), d_unlock(), _p_dialog::direction, get_p_dialog_hash(), p_dialog_hash_slot::head, _p_dialog::next, and p_dialogs.

Referenced by P_release_call_onreply().

{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);
        d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if (d->direction==dir && d->call_id.len == call_id.len &&
                        strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                d_unlock(hash);
                return 1;
            }
            d=d->next;
        }
        d_unlock(hash);
        return 0;
}

p_dialog* get_p_dialog	(	str	call_id,
		str	host,
		int	port,
		int	transport,
		enum p_dialog_direction *	dir
	)

Finds and returns a dialog from the hash table.

Note:

Locks the hash slot if ok! Call d_unlock(p_dialog->hash) when you are finished)

Parameters:

	call_id	- dialog's call_id
	host	- host that originates/terminates this dialog
	port	- port that originates/terminates this dialog
	transport	- transport that originates/terminates this dialog
	dir	- the direction of the dialog. if NULL, it doesn't matter

Note:

transport is ignored.

Definition at line 415 of file dlg_state.c.

References _p_dialog::call_id, d_lock(), d_unlock(), _p_dialog::direction, get_p_dialog_hash(), p_dialog_hash_slot::head, _p_dialog::host, _p_dialog::next, p_dialogs, and _p_dialog::port.

Referenced by P_drop_dialog(), P_enforce_dialog_routes(), P_follows_dialog_routes(), and P_update_dialog().

{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if ((!dir || d->direction == *dir) &&
                d->port == port &&
/*              d->transport == transport &&*/
/* commented because of strange behaviour */
                d->host.len == host.len &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->host.s,host.s,host.len)==0 &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    return d;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}

p_dialog* get_p_dialog_dir	(	str	call_id,
		enum p_dialog_direction	dir
	)

Finds and returns a dialog from the hash table.

Parameters:

	call_id	- call_id of the dialog
	dir	- the direction

Returns:

the p_dialog* or NULL if not found

Definition at line 445 of file dlg_state.c.

References _p_dialog::call_id, d_lock(), d_unlock(), _p_dialog::direction, get_p_dialog_hash(), p_dialog_hash_slot::head, _p_dialog::next, and p_dialogs.

Referenced by confirmed_response(), P_release_call_onreply(), and release_call().

{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if (d->direction == dir &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    return d;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}

p_dialog* get_p_dialog_dir_nolock	(	str	call_id,
		enum p_dialog_direction	dir
	)

Finds and returns a dialog from the hash table.

Note:

the table should be locked already for the call_id in the parameter

Parameters:

	call_id	- call_id of the dialog
	dir	- the direction

Returns:

the p_dialog* or NULL if not found

Definition at line 472 of file dlg_state.c.

References _p_dialog::call_id, _p_dialog::direction, get_p_dialog_hash(), p_dialog_hash_slot::head, _p_dialog::next, and p_dialogs.

Referenced by release_call_confirmed(), and release_call_previous().

{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d = p_dialogs[hash].head;
    while(d){
        if (d->direction == dir &&
            d->call_id.len == call_id.len &&
            strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                return d;
            }
        d = d->next;
    }
    return 0;
}

int terminate_p_dialog

(

p_dialog *

d

)

Terminates a dialog - called before del_p_dialog to send out terminatination messages.

Parameters:

d

- the dialog to terminate

Returns:

- 1 if the requests were sent and the dialog will be deleted, 0 on error (you will have to delete the dialog yourself!)

Definition at line 496 of file dlg_state.c.

References del_p_dialog(), DLG_METHOD_INVITE, DLG_METHOD_SUBSCRIBE, M_NAME, _p_dialog::method, pcscf_dialogs_enable_release, reason_terminate_p_dialog_s, and release_call_p().

Referenced by dialog_timer().

{
    if (!pcscf_dialogs_enable_release) return 0;
    switch (d->method){
        case DLG_METHOD_INVITE:
            if (release_call_p(d,503,reason_terminate_p_dialog_s)==-1){             
                del_p_dialog(d);
            }
            return 1;
            break;
        case DLG_METHOD_SUBSCRIBE:
            LOG(L_ERR,"ERR:"M_NAME":terminate_p_dialog(): Not needed for SUBSCRIBE dialogs - silent drop on expiration.\n");
            return 0;
            break;
        default:
            LOG(L_ERR,"ERR:"M_NAME":terminate_p_dialog(): Not implemented yet for method[%d]!\n",d->method);
            return 0;
    }
}

void del_p_dialog

(

p_dialog *

d

)

Deletes and destroys the dialog from the hash table.

Note:

Must be called with a lock on the dialogs slot

Parameters:

d

- the dialog to delete

Definition at line 521 of file dlg_state.c.

References free_p_dialog(), _p_dialog::hash, p_dialog_hash_slot::head, _p_dialog::next, p_dialogs, _p_dialog::prev, and p_dialog_hash_slot::tail.

Referenced by confirmed_response(), dialog_timer(), P_drop_all_dialogs(), P_drop_dialog(), P_save_dialog(), release_call_confirmed(), release_call_previous(), and terminate_p_dialog().

{
    if (d->prev) d->prev->next = d->next;
    else p_dialogs[d->hash].head = d->next;
    if (d->next) d->next->prev = d->prev;
    else p_dialogs[d->hash].tail = d->prev;
    free_p_dialog(d);
}

void free_p_dialog

(

p_dialog *

d

)

Destroys the dialog.

Parameters:

d

- the dialog to delete

Definition at line 534 of file dlg_state.c.

References _p_dialog::call_id, _p_dialog::dialog_c, _p_dialog::dialog_s, _p_dialog::host, _p_dialog::method_str, p_dialog_count_decrement(), _p_dialog::refresher, _p_dialog::routes, _p_dialog::routes_cnt, and tmb.

Referenced by del_p_dialog(), and p_dialogs_destroy().

{
    int i;
    if (!d) return;
    if (d->call_id.s) shm_free(d->call_id.s);
    if (d->host.s) shm_free(d->host.s); 
    if (d->method_str.s) shm_free(d->method_str.s); 
    if (d->routes){
        for(i=0;i<d->routes_cnt;i++)
            shm_free(d->routes[i].s);
        shm_free(d->routes);
    }
    if (d->dialog_s) tmb.free_dlg(d->dialog_s);
    if (d->dialog_c) tmb.free_dlg(d->dialog_c);
    if (d->refresher.s) shm_free(d->refresher.s);
    shm_free(d);
    p_dialog_count_decrement(); 
}

void print_p_dialogs

(

int

log_level

)

Prints the dialog hash table.

Parameters:

log_level

- the log_level to print with

Definition at line 557 of file dlg_state.c.

References ANSI_BLUE, ANSI_GREEN, ANSI_MAGENTA, ANSI_RED, ANSI_YELLOW, _p_dialog::call_id, d_act_time(), d_lock(), d_time_now, d_unlock(), _p_dialog::direction, _p_dialog::expires, p_dialog_hash_slot::head, _p_dialog::host, M_NAME, _p_dialog::method, _p_dialog::next, p_dialogs, p_dialogs_hash_size, _p_dialog::port, _p_dialog::routes, _p_dialog::state, and _p_dialog::transport.

Referenced by P_drop_dialog(), P_save_dialog(), and P_update_dialog().

{
    p_dialog *d;
    int i,j;
    if (debug<log_level) return; /* to avoid useless calls when nothing will be printed */
    d_act_time();
    LOG(log_level,"INF:"M_NAME":----------  P-CSCF Dialog List begin --------------\n");
    for(i=0;i<p_dialogs_hash_size;i++){
        d_lock(i);
            d = p_dialogs[i].head;
            while(d){
                LOG(log_level,"INF:"M_NAME":[%4d] Dir:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "]\tCall-ID:<"ANSI_BLUE"%.*s"ANSI_GREEN
                    ">\tAOR:"ANSI_RED"%d://%.*s:%d"ANSI_GREEN"\n"
                    ,i,             
                    d->direction,