dlg_state.h File Reference

---

Detailed Description

Proxy-CSCF - Dialog State.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file dlg_state.h.

#include "../../sr_module.h"
#include "mod.h"
#include "../../locking.h"
#include "../tm/dlg.h"
#include "../tm/tm_load.h"

Go to the source code of this file.

Data Structures
struct	_p_dialog
struct	p_dialog_hash_slot
Defines
#define	DLG_METHOD_MAX   DLG_METHOD_SUBSCRIBE
	The last dialog type.
Typedefs
typedef _p_dialog	p_dialog
Enumerations
enum	p_dialog_method { DLG_METHOD_OTHER = 0, DLG_METHOD_INVITE = 1, DLG_METHOD_SUBSCRIBE = 2 }
enum	p_dialog_state {   DLG_STATE_UNKNOWN = 0, DLG_STATE_INITIAL = 1, DLG_STATE_EARLY = 2, DLG_STATE_CONFIRMED = 3,   DLG_STATE_TERMINATED_ONE_SIDE = 4, DLG_STATE_TERMINATED = 5 }
enum	p_dialog_direction { DLG_MOBILE_ORIGINATING = 0, DLG_MOBILE_TERMINATING = 1, DLG_MOBILE_UNKNOWN = 2 }
Functions
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.
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.
int	P_is_in_dialog (struct sip_msg *msg, char *str1, char *str2)
	Find out if a message is within a saved dialog.
int	P_save_dialog (struct sip_msg *msg, char *str1, char *str2)
	Saves a dialog.
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.
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_422_session_expires (struct sip_msg *msg, char *str1, char *str2)
	Send a 422 Session Interval Too Small.
void	dialog_timer (unsigned int ticks, void *param)
	The dialog timer looks for expired dialogs and removes them.

---

Define Documentation

#define DLG_METHOD_MAX   DLG_METHOD_SUBSCRIBE

The last dialog type.

Definition at line 72 of file dlg_state.h.

Referenced by dialog_timer().

---

Typedef Documentation

typedef struct _p_dialog p_dialog

---

Enumeration Type Documentation

enum p_dialog_method

Enumerator:

DLG_METHOD_OTHER
DLG_METHOD_INVITE
DLG_METHOD_SUBSCRIBE

Definition at line 65 of file dlg_state.h.

                     {
    DLG_METHOD_OTHER=0,
    DLG_METHOD_INVITE=1,
    DLG_METHOD_SUBSCRIBE=2  
};

enum p_dialog_state

Enumerator:

DLG_STATE_UNKNOWN
DLG_STATE_INITIAL
DLG_STATE_EARLY
DLG_STATE_CONFIRMED
DLG_STATE_TERMINATED_ONE_SIDE
DLG_STATE_TERMINATED

Definition at line 74 of file dlg_state.h.

                    {
    DLG_STATE_UNKNOWN=0,
    DLG_STATE_INITIAL=1,
    DLG_STATE_EARLY=2,
    DLG_STATE_CONFIRMED=3,
    DLG_STATE_TERMINATED_ONE_SIDE=4,
    DLG_STATE_TERMINATED=5  
};

enum p_dialog_direction

Enumerator:

DLG_MOBILE_ORIGINATING
DLG_MOBILE_TERMINATING
DLG_MOBILE_UNKNOWN

Definition at line 83 of file dlg_state.h.

                        {
    DLG_MOBILE_ORIGINATING=0,
    DLG_MOBILE_TERMINATING=1,
    DLG_MOBILE_UNKNOWN=2
};

---

Function Documentation

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

- index of the slot to lock

Definition at line 198 of file dlg_state.c.

{
//  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

- index of the slot to unlock

Definition at line 209 of file dlg_state.c.

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

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,
                    d->call_id.len,d->call_id.s,
                    d->transport,d->host.len,d->host.s,d->port);
                LOG(log_level,"INF:"M_NAME":\t\tMethod:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "] State:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "] Exp:["ANSI_MAGENTA"%4d"ANSI_GREEN"]\n",
                    d->method,d->state,
                    (int)(d->expires - d_time_now));    
                for(j=0;j<d->routes_cnt;j++)
                    LOG(log_level,"INF:"M_NAME":\t\t RR: <"ANSI_YELLOW"%.*s"ANSI_GREEN">\n",            
                        d->routes[j].len,d->routes[j].s);                   
                d = d->next;
            }       
        d_unlock(i);
    }
    LOG(log_level,"INF:"M_NAME":----------  P-CSCF Dialog List end   --------------\n");    
}

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

Find out if a message is within a saved dialog.

Parameters:

	msg	- the SIP message
	str1	- the direction of the dialog ("orig"/"term")
	str2	- not used

Returns:

CSCF_RETURN_TRUE if in, CSCF_RETURN_FALSE else or CSCF_RETURN_BREAK on error

Definition at line 652 of file dlg_state.c.

References cscf_get_call_id(), CSCF_RETURN_BREAK, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, find_dialog_contact(), get_dialog_direction(), is_p_dialog(), and M_NAME.

{
    str call_id;
    str host;
    int port,transport;
    enum p_dialog_direction dir;

    dir = get_dialog_direction(str1);
    
    if (!find_dialog_contact(msg,dir,&host,&port,&transport)){
        LOG(L_ERR,"ERR:"M_NAME":P_is_in_dialog(%s): Error retrieving %s contact\n",str1,str1);
        return CSCF_RETURN_BREAK;
    }       

    //print_p_dialog(L_ERR);
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len)
        return CSCF_RETURN_FALSE;
            
    if (is_p_dialog(call_id,host,port,transport,0)) {
        return CSCF_RETURN_TRUE;
    }
    else 
        return CSCF_RETURN_FALSE;
}

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

Saves a dialog.

Parameters:

	msg	- the initial request
	str1	- direction - "orig" or "term"
	str2	- not used

Returns:

CSCF_RETURN_TRUE if ok, CSCF_RETURN_FALSE if not or CSCF_RETURN_BREAK on error

Definition at line 825 of file dlg_state.c.

References add_p_dialog(), cscf_get_call_id(), cscf_get_cseq(), cscf_get_from_tag(), cscf_get_from_uri(), cscf_get_session_expires(), cscf_get_session_expires_body(), cscf_get_to_uri(), CSCF_RETURN_BREAK, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, d_act_time(), d_unlock(), del_p_dialog(), _p_dialog::dialog_c, _p_dialog::dialog_s, _p_dialog::direction, DLG_STATE_INITIAL, _p_dialog::expires, find_dialog_contact(), _p_dialog::first_cseq, get_dialog_direction(), get_dialog_method(), _p_dialog::hash, is_p_dialog(), _p_dialog::last_cseq, _p_dialog::lr_session_expires, M_NAME, _p_dialog::method, _p_dialog::method_str, print_p_dialogs(), _p_dialog::refresher, _p_dialog::state, STR_SHM_DUP, supports_extension(), tmb, and _p_dialog::uac_supp_timer.

{
    str call_id;
    p_dialog *d;
    str host;
    time_t t_time;
    str ses_exp = {0,0};
    str refresher = {0,0};
    int port,transport;
    char buf1[256],buf2[256];
    str tag,ruri,uri,x;
    struct hdr_field *h;
    unsigned int hash;
    enum p_dialog_direction dir;
    
    dir = get_dialog_direction(str1);
    
    if (!find_dialog_contact(msg,dir,&host,&port,&transport)){
        LOG(L_ERR,"ERR:"M_NAME":P_is_in_dialog(): Error retrieving %s contact\n",str1);
        return CSCF_RETURN_BREAK;
    }       
        
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len)
        return CSCF_RETURN_FALSE;

    LOG(L_DBG,"DBG:"M_NAME":P_save_dialog(%s): Call-ID <%.*s>\n",str1,call_id.len,call_id.s);

    if (is_p_dialog(call_id,host,port,transport,&dir)){
        LOG(L_ERR,"ERR:"M_NAME":P_save_dialog: dialog already exists!\n");  
        return CSCF_RETURN_TRUE;
    }
    
    d = add_p_dialog(call_id,host,port,transport);
    if (!d) return CSCF_RETURN_FALSE;

    d->method = get_dialog_method(msg->first_line.u.request.method);
    STR_SHM_DUP(d->method_str,msg->first_line.u.request.method,"shm");
    d->first_cseq = cscf_get_cseq(msg,0);
    d->last_cseq = d->first_cseq;
    d->state = DLG_STATE_INITIAL;

    d->uac_supp_timer = supports_extension(msg, &str_ext_timer);

    ses_exp = cscf_get_session_expires_body(msg, &h);
    t_time = cscf_get_session_expires(ses_exp, &refresher);
    if (!t_time){
        d->expires = d_act_time() + 60;
        d->lr_session_expires = 0;
    }else {
        d->expires = d_act_time() + t_time;
        d->lr_session_expires = t_time;
        if (refresher.len)
            STR_SHM_DUP(d->refresher, refresher, "DIALOG_REFRESHER");
    }
    
    d->direction=dir;
                
    cscf_get_from_tag(msg,&tag);
    cscf_get_from_uri(msg,&x);
    uri.len = snprintf(buf1,256,"<%.*s>",x.len,x.s);
    uri.s = buf1;   
    cscf_get_to_uri(msg,&x);
    ruri.len = snprintf(buf2,256,"<%.*s>",x.len,x.s);
    ruri.s = buf2;
        
    tmb.new_dlg_uac(&call_id,
                    &tag,
                    d->first_cseq,
                    &uri,
                    &ruri,
                    &d->dialog_c);
                    
    tmb.new_dlg_uas(msg,99,&d->dialog_s);