registrar.c File Reference

---

Detailed Description

Serving-CSCF - Registrar-Related Operations.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar.c.

#include <time.h>
#include "../../parser/contact/contact.h"
#include "../../parser/contact/parse_contact.h"
#include "../../ut.h"
#include "../tm/tm_load.h"
#include "../cdp/cdp_load.h"
#include "../../dset.h"
#include "registrar.h"
#include "registration.h"
#include "mod.h"
#include "registrar_parser.h"
#include "registrar_storage.h"
#include "sip.h"
#include "cx.h"
#include "cx_avp.h"
#include "sip_messages.h"
#include "dlg_state.h"

Go to the source code of this file.

Functions
void	registrar_timer (unsigned int ticks, void *param)
	The Registrar timer looks for expires contacts and removes them.
int	S_assign_server (struct sip_msg *msg, char *str1, char *str2)
	Does the Server Assignment procedures, assigning this S-CSCF to the user.
int	S_assign_server_unreg (struct sip_msg *msg, char *str1, char *str2)
	Does the Server Assignment procedures, assigning this S-CSCF to the user without previous registration.
int	SAR (struct sip_msg *msg, str realm, str public_identity, str private_identity, int assignment_type, int data_available)
	Sends a SAR.
static int	r_calc_expires (contact_t *c, unsigned int expires_hdr)
	Calculates the expiration time for one contact.
int	r_calc_contact_q (param_t *_q, qvalue_t *_r)
static int	r_add_contact (struct sip_msg *msg, str uri, int expires, qvalue_t qvalue)
	Adds a Contact header to the reply, containing the approved expires.
static int	update_contacts (struct sip_msg *msg, int assignment_type, unsigned char is_star, ims_subscription **s, str *ua, str *path, str *ccf1, str *ccf2, str *ecf1, str *ecf2)
	Updates the contacts in the registrar with the new values received, for the addresses received in the SAA.
int	insert_p_associated_uri (struct sip_msg *msg, ims_subscription *s)
	Adds to the response the P-Associated-URI header.
int	save_location (struct sip_msg *msg, int assignment_type, str *xml, str *ccf1, str *ccf2, str *ecf1, str *ecf2)
	Save the contacts.
int	S_update_contacts (struct sip_msg *msg, char *str1, char *str2)
	Save the contacts.
static int	r_add_route_path (struct sip_msg *msg, r_contact *c)
	Adds a Route header containing the saved Path.
static int	r_add_p_called_party_id (struct sip_msg *msg)
	Adds the P-Called-Party-ID header containing the Request-URI before that will be resolved to the contact address.
int	S_lookup (struct sip_msg *msg, char *str1, char *str2)
	Lookup for the Request-URI in registrar and rewrite request URI with the contact address.
int	r_is_registered_id (str public_identity)
	Finds if the user is registered at this S-CSCF.
int	r_is_not_registered_id (str public_identity)
	Finds if the user is not registered at this S-CSCF.
int	r_is_unregistered_id (str public_identity)
	Finds if the user is unregistered at this S-CSCF.
int	S_term_registered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the terminating user (in the RequestURI) is registered at this S-CSCF.
int	S_term_not_registered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the terminating user (in the RequestURI) is not registered at this S-CSCF.
int	S_term_unregistered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the terminating user (in the RequestURI) is unregistered at this S-CSCF.
int	S_orig_registered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the originating user (in P-Asserted-Identity) is registered at this S-CSCF.
int	S_add_p_asserted_identity (struct sip_msg *msg, char *str1, char *str2)
	Adds suplimentary P-Asserted-Identity.
int	S_orig_not_registered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the originating user (in P-Asserted-Identity) is not registered at this S-CSCF.
int	S_orig_unregistered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the originating user (in P-Asserted-Identity) is unregistered at this S-CSCF.
int	S_is_not_registered (struct sip_msg *msg, char *str1, char *str2)
	Finds if the user in To header is not registered at this S-CSCF.
int	S_mobile_originating (struct sip_msg *msg, char *str1, char *str2)
	Finds if the message contains as first route the specific service route for originating case (indicated in the Service-Route at registration), or if the topmost route contains the "orig" parameter.
int	S_is_barred (str public_identity)
	Finds if the user exists and it is barred.
int	S_originating_barred (struct sip_msg *msg, char *str1, char *str2)
	Finds if the originating user is barred.
int	S_terminating_barred (struct sip_msg *msg, char *str1, char *str2)
	Finds if the terminating user is barred.
Variables
tm_binds	tmb
	Structure with pointers to tm funcs.
cdp_binds	cdpb
	Structure with pointers to cdp funcs.
int	r_hash_size
	Size of S-CSCF registrar hash table.
r_hash_slot *	registrar
	The S-CSCF registrar.
str	scscf_name_str
	fixed name of the S-CSCF
str	scscf_service_route_uri
	just the service route uri
str	scscf_registration_min_expires
	fixed minimum registration expiration time
int	server_assignment_store_data
	whether to ask to keep the data in SAR
int	registration_default_expires
	the default value for expires if none found
int	registration_min_expires
	minimum registration expiration time
int	registration_max_expires
	maximum registration expiration time
int	registration_disable_early_ims
	if to disable the Early-IMS checks
time_t	time_now
	Current time of the S-CSCF registrar.
int	append_branches
	if to append branches
str	hdr_p_associated_uri1 = {"P-Associated-URI: <",19}
str	hdr_p_associated_uri2 = {">, <",4}
str	hdr_p_associated_uri3 = {">\r\n",3}
str	route_hdr1 = {"Route: ",7}
str	route_hdr2 = {"\r\n",2}
str	p_called_party_id_hdr1 = {"P-Called-Party-ID: <",20}
str	p_called_party_id_hdr2 = {">\r\n",3}
static str	p_asserted_identity_s = {"P-Asserted-Identity: <",22}
static str	p_asserted_identity_e = {">\r\n",3}
static str	p_asserted_identity_param = {";user=phone",11}
static str	p_asserted_identity_tel = {"tel:",4}
static str	route_header = {"Route",5}

---

Function Documentation

void registrar_timer	(	unsigned int	ticks,
		void *	param
	)

The Registrar timer looks for expires contacts and removes them.

Parameters:

	ticks	- the current time
	param	- pointer to the domain_list

Definition at line 109 of file registrar.c.

References _r_public::aor, AVP_IMS_SAR_TIMEOUT_DEREGISTRATION, AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME, cscf_get_realm_from_uri(), del_r_contact(), del_r_public(), del_r_subscriber(), DEREGISTERED, _r_contact::expires, get_r_public_previous_lock(), _r_public::hash, _r_contact::head, _r_public::head, r_hash_slot::head, if, IMS_REGISTRAR_CONTACT_EXPIRED, M_NAME, _r_subscriber::next, _r_contact::next, _r_public::next, NOT_REGISTERED, P_security_drop(), _r_contact::pinhole, ims_subscription::private_identity, ims_service_profile::public_identities, ims_service_profile::public_identities_cnt, ims_public_identity::public_identity, r_act_time(), r_hash_size, r_lock(), r_unlock(), r_valid_contact(), r_valid_subscriber(), REG_PENDING, _r_contact::reg_state, _r_public::reg_state, REGISTERED, registrar, _r_public::s, S_event_reg(), SAR(), SEC_IPSEC, SEC_TLS, _r_contact::security, _r_contact::security_temp, server_assignment_store_data, ims_subscription::service_profiles, ims_subscription::service_profiles_cnt, _r_public::shead, _r_subscriber::subscriber, time_now, _r_security::type, UNREGISTERED, and _r_contact::uri.

{
    r_public *p,*pn,*rpublic;
    r_contact *c,*c2=0,*cn,*cn2=0;
    r_subscriber *s,*sn,*s2=0,*sn2=0;
    int i,j,n,assignment_type,sar_res;
    ims_public_identity *pi=0;
    r_hash_slot *r;
    int rpublic_hash;
    
    #ifdef WITH_IMS_PM
        int impu_cnt=0,contact_cnt=0,subs_cnt=0;
    #endif


    r = param;
    
    LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Called at %d\n",ticks);

    r_act_time();

    for(i=0;i<r_hash_size;i++){
        r_lock(i);
            p = r[i].head;
            while(p){
                pn = p->next;
                c = p->head;
                                    
                while(c){
                    cn = c->next;
                    if (!r_valid_contact(c)){
                        LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Contact <%.*s> expired and removed.\n",
                            c->uri.len,c->uri.s);                           
                        S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_EXPIRED,1);/* send now because we might drop the dialog soon */ 
                        del_r_contact(p,c);
                    }
                    #ifdef WITH_IMS_PM
                        else contact_cnt++;
                    #endif
                    c = cn;
                }
                s = p->shead;
                while(s){
                    sn = s->next;
                    if (!r_valid_subscriber(s)){
                        LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Subscriber <%.*s> expired and removed.\n",
                            s->subscriber.len,s->subscriber.s);
                        del_r_subscriber(p,s);
                    }
                    #ifdef WITH_IMS_PM
                        else subs_cnt++;
                    #endif
                    s = sn;
                }
                
                if (!p->head){/* no more contacts, then deregister it */
                    switch (p->reg_state){
                        case REGISTERED:
                            if (server_assignment_store_data) 
                                assignment_type = AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME;
                            else assignment_type = AVP_IMS_SAR_TIMEOUT_DEREGISTRATION;
                            sar_res = SAR(0,cscf_get_realm_from_uri(p->aor),p->aor,p->s->private_identity,assignment_type,0);
                            
                            if (sar_res==1){
                                /* SAR successful, de-register everything in this implicit set */
                                if (!p->s){
                                    LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Problem r_public does not contain IMS Subscription <%.*s> \n",
                                        p->aor.len,p->aor.s);
                                    break;
                                }
                                for(j=0;j<p->s->service_profiles_cnt;j++)
                                    for(n=0;n<p->s->service_profiles[j].public_identities_cnt;n++){
                                        pi = &(p->s->service_profiles[j].public_identities[n]);
                                        if (pi->public_identity.len == p->aor.len &&
                                            strncasecmp(pi->public_identity.s,p->aor.s,p->aor.len)==0) continue;
                                        rpublic = get_r_public_previous_lock(pi->public_identity,p->hash);
                                        
                                        if(!rpublic){
                                            LOG(L_INFO,"INFO:"M_NAME":registrar_timer: The implicit set public identity <%.*s> was not found in the registrar",
                                                pi->public_identity.len,pi->public_identity.s);
                                            continue;
                                        }
                                        rpublic_hash = rpublic->hash;
                                        
                                        c2 = rpublic->head;
                                        while(c2){
                                            cn2 = c2->next;
                                            if (!r_valid_contact(c2)){
                                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Contact <%.*s> expired and removed (because of implicit set).\n",c2->uri.len,c2->uri.s);
                                                S_event_reg(rpublic,c2,0,IMS_REGISTRAR_CONTACT_EXPIRED,1);/* send now because we might drop the dialog soon */  
                                                del_r_contact(rpublic,c2);
                                            }
                                            c2 = cn2;
                                        }
                                        
                                        s2 = rpublic->shead;
                                        while(s2){
                                            sn2 = s2->next;
                                            if (!r_valid_subscriber(s2)){
                                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: Subscriber <%.*s> expired and removed (because of implicit set).\n",s2->subscriber.len,s2->subscriber.s);
                                                del_r_subscriber(rpublic,s2);
                                            }                                         
                                            s2 = sn2;
                                        }
                                
                                        if (!rpublic->head){/* no more contacts, then deregister it */
                                            if (!rpublic->shead)  {/* delete it if there are no more subscribers for it */     
                                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> removed (because of implicit set).\n",
                                                    rpublic->aor.len,rpublic->aor.s);
                                                del_r_public(rpublic);
                                            }else{/* else mark it unregistered - to avoid more SAR */
                                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> kept unregistered - has subscribers (because of implicit set).\n",
                                                    rpublic->aor.len,rpublic->aor.s);                                                
                                                rpublic->reg_state = NOT_REGISTERED;                                       
                                            }
                                        }
                                        /* because the lock was taken with a previous lock */
                                        if (rpublic_hash!=i) r_unlock(rpublic_hash);
                                    }

                              LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> deregistered.\n",
                                    p->aor.len,p->aor.s);
                              if (!p->shead)    {/* delete it if there are no more subscribers for it */                        
                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> removed.\n",
                                    p->aor.len,p->aor.s);
                                del_r_public(p);
                              }else{/* else mark it unregistered - to avoid more SAR */
                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> kept unregistered - has subscribers.\n",
                                p->aor.len,p->aor.s);                               
                                p->reg_state = NOT_REGISTERED;                              
                              }
                            }else{
                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> deregistration SAR failed.Keeping into registrar, but with no contacts\n",
                                    p->aor.len,p->aor.s);
                                #ifdef WITH_IMS_PM
                                    impu_cnt++;
                                #endif
                            }                                       
                            break;
                            
                        case UNREGISTERED:
                            /* Don't drop it, just keep it for unregistered triggering*/
                             #ifdef WITH_IMS_PM
                                impu_cnt++;
                            #endif
                            break;
                            
                        case NOT_REGISTERED:                                
                            /* to avoid sending SAR when we still have subscribers, but no contact */
                            if (!p->shead)  {/* delete it if there are no more subscribers for it */                        
                                LOG(L_DBG,"DBG:"M_NAME":registrar_timer: User <%.*s> removed - no more subscribers.\n",
                                    p->aor.len,p->aor.s);
                                del_r_public(p);                            
                            }
                            break;
                    }
                }
                #ifdef WITH_IMS_PM
                    else impu_cnt++;
                #endif
                p = pn;
            }
        r_unlock(i);        
    }
    print_r(L_INFO);
    #ifdef WITH_IMS_PM
        IMS_PM_LOG01(RD_NbrIMPU,impu_cnt);
        IMS_PM_LOG01(RD_NbrContact,contact_cnt);
        IMS_PM_LOG01(RD_NbrSubs,subs_cnt);
    #endif
}

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

Does the Server Assignment procedures, assigning this S-CSCF to the user.

Covered cases: AVP_IMS_SAR_NO_ASSIGNMENT = 0 AVP_IMS_SAR_REGISTRATION = 1, YES,HERE AVP_IMS_SAR_RE_REGISTRATION = 2, AVP_IMS_SAR_UNREGISTERED_USER = 3, in S_assign_server_unreg AVP_IMS_SAR_TIMEOUT_DEREGISTRATION = 4, AVP_IMS_SAR_USER_DEREGISTRATION = 5, YES,HERE AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME = 6, AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME = 7, YES,HERE AVP_IMS_SAR_ADMINISTRATIVE_DEREGISTRATION = 8, AVP_IMS_SAR_AUTHENTICATION_FAILURE = 9, AVP_IMS_SAR_AUTHENTICATION_TIMEOUT = 10, AVP_IMS_SAR_DEREGISTRATION_TOO_MUCH_DATA

Parameters:

	msg	- the SIP REGISTER message (that is authorized)
	str1	- the realm to look for in Authorization
	str2	- not used

Returns:

true if ok, false if not, break on error

Definition at line 302 of file registrar.c.

References AVP_IMS_SAR_NO_ASSIGNMENT, AVP_IMS_SAR_RE_REGISTRATION, AVP_IMS_SAR_REGISTRATION, AVP_IMS_SAR_USER_DATA_ALREADY_AVAILABLE, AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE, AVP_IMS_SAR_USER_DEREGISTRATION, AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME, ci, cscf_get_max_expires(), cscf_get_private_identity(), cscf_get_public_identity(), cscf_parse_contacts(), CSCF_RETURN_BREAK, CSCF_RETURN_ERROR, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, drop_auth_userdata(), get_r_contact(), get_r_public(), _r_public::hash, _r_public::head, M_NAME, _r_contact::next, r_is_registered_id(), r_unlock(), SAR(), save_location(), and server_assignment_store_data.

{
    int ret=CSCF_RETURN_FALSE;
    str private_identity,public_identity,realm;
    int assignment_type = AVP_IMS_SAR_NO_ASSIGNMENT;
    int data_available = AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE;
    int expires;
    r_public *p;
    int require_user_data=0;
    contact_body_t* b=0;
    struct hdr_field *h=0;
    contact_t *ci=0;
    r_contact *c=0;
    int n_contacts=0,contacts_reg=0;

    LOG(L_DBG,"DBG:"M_NAME":S_assign_server: Assigning server...\n");
    
    /* First check the parameters */
    if (msg->first_line.type!=SIP_REQUEST)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_assign_server: This message is not a request\n");
        goto error;
    }       

    realm.s = str1; realm.len = strlen(str1);
    if (!realm.len) {
        LOG(L_ERR,"ERR:"M_NAME":S_assign_server: No realm found\n");
        return CSCF_RETURN_BREAK;
    }
        
    private_identity = cscf_get_private_identity(msg,realm);
    
    public_identity = cscf_get_public_identity(msg);
    if (!public_identity.len) {
        LOG(L_ERR,"ERR:"M_NAME":S_assign_server: public identity missing\n");       
        return ret;
    }
        
    expires = cscf_get_max_expires(msg);
    
    if (expires>0) {
        if (r_is_registered_id(public_identity)) 
            assignment_type = AVP_IMS_SAR_RE_REGISTRATION;
        else{
            assignment_type = AVP_IMS_SAR_REGISTRATION;
            require_user_data=1;
        }
    }
    else {
        if (server_assignment_store_data) 
            assignment_type = AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME;
        else assignment_type = AVP_IMS_SAR_USER_DEREGISTRATION;

        b = cscf_parse_contacts(msg);
        
        if (!b||(!b->contacts && !b->star)) {
            LOG(L_ERR,"ERR:"M_NAME":S_assign_server: No contacts found - this was just bindings fetch, no SAR done\n");
            ret = CSCF_RETURN_TRUE;
            goto done;
        }
        
        if (!b->star){
            // If not all contacts would be de-registered now, then we actually skip the SAR
            p = get_r_public(public_identity);
            if(!p)  goto error;
            
            for(h=msg->contact;h;h=h->next){
                if (h->type==HDR_CONTACT_T && h->parsed){
                    for(ci=((contact_body_t*)h->parsed)->contacts;ci;ci=ci->next){
                        if (get_r_contact(p,ci->uri))
                            n_contacts++;
                    }
                }
            }
            
            for(c=p->head;c;c=c->next)
                contacts_reg++;
            r_unlock(p->hash);
            
            if (n_contacts < contacts_reg){
                // There are still contacts left for this public id
                drop_auth_userdata(private_identity,public_identity);
                ret = save_location(msg,assignment_type,0,0,0,0,0); 
                goto done;
            }           
        }
    }
    
    //TODO
    //if (userdataavailable) data_available = AVP_IMS_SAR_USER_DATA_ALREADY_AVAILABLE;
    //else

    if(require_user_data)
        data_available = AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE;
    else
        data_available = AVP_IMS_SAR_USER_DATA_ALREADY_AVAILABLE;
    
    ret = SAR(msg,realm,public_identity,private_identity,assignment_type,data_available);

done:           
    return ret; 
error:
    ret = CSCF_RETURN_ERROR;        
    return ret;
}

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

Does the Server Assignment procedures, assigning this S-CSCF to the user without previous registration.

Covered cases: AVP_IMS_SAR_NO_ASSIGNMENT = 0 AVP_IMS_SAR_REGISTRATION = 1, YES, NOT HERE AVP_IMS_SAR_RE_REGISTRATION = 2, AVP_IMS_SAR_UNREGISTERED_USER = 3, YES, HERE AVP_IMS_SAR_TIMEOUT_DEREGISTRATION = 4, AVP_IMS_SAR_USER_DEREGISTRATION = 5, YES, NOT HERE AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME = 6, AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME = 7, YES, NOT HERE AVP_IMS_SAR_ADMINISTRATIVE_DEREGISTRATION = 8, AVP_IMS_SAR_AUTHENTICATION_FAILURE = 9, AVP_IMS_SAR_AUTHENTICATION_TIMEOUT = 10, AVP_IMS_SAR_DEREGISTRATION_TOO_MUCH_DATA

Parameters:

	msg	- the SIP REGISTER message (that is authorized)
	str1	- the realm to look for in Authorization
	str2	- direction - "orig" or "term"

Returns:

true if ok, false if not, break on error

Definition at line 429 of file registrar.c.

References AVP_IMS_SAR_NO_ASSIGNMENT, AVP_IMS_SAR_UNREGISTERED_USER, AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE, cscf_get_asserted_identity(), cscf_get_public_identity_from_requri(), CSCF_RETURN_BREAK, CSCF_RETURN_ERROR, CSCF_RETURN_FALSE, DLG_MOBILE_ORIGINATING, DLG_MOBILE_TERMINATING, get_dialog_direction(), M_NAME, and SAR().

{
    int ret=CSCF_RETURN_FALSE;
    str private_identity={0,0},public_identity={0,0},realm={0,0};
    int assignment_type = AVP_IMS_SAR_NO_ASSIGNMENT;
    int data_available = AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE;

    /* First check the parameters */
    if (msg->first_line.type!=SIP_REQUEST)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_assign_server_unreg: This message is not a request\n");
        goto error;
    }       

    realm.s = str1; realm.len = strlen(str1);
    if (!realm.len) {
        LOG(L_ERR,"ERR:"M_NAME":S_assign_server_unreg: No realm found\n");
        return CSCF_RETURN_BREAK;
    }

    enum s_dialog_direction dir = get_dialog_direction(str2);
    
    switch (dir){
        case DLG_MOBILE_ORIGINATING:
            public_identity = cscf_get_asserted_identity(msg);
            if (!public_identity.len) {
                LOG(L_DBG,"DBG:"M_NAME":S_assign_server_unreg(orig): public identity missing\n");       
                return ret;
            }
            break;
        case DLG_MOBILE_TERMINATING:
            public_identity = cscf_get_public_identity_from_requri(msg);
            if (!public_identity.len) {
                LOG(L_DBG,"DBG:"M_NAME":S_assign_server_unreg(term): public identity missing\n");       
                return ret;
            }
            break;
        default:
            LOG(L_ERR,"ERR:"M_NAME":S_assign_server_unreg: bad dialog direction parameter\n");
            goto error;
    }
    
    assignment_type = AVP_IMS_SAR_UNREGISTERED_USER;
    
    //TODO
    //if (userdataavailable) data_available = AVP_IMS_SAR_USER_DATA_ALREADY_AVAILABLE;
    //else
    data_available = AVP_IMS_SAR_USER_DATA_NOT_AVAILABLE;
    
    ret = SAR(0,realm,public_identity,private_identity,assignment_type,data_available);
    
    return ret; 
error:
    ret = CSCF_RETURN_ERROR;        
    return ret;
}

int SAR	(	struct sip_msg *	msg,
		str	realm,
		str	public_identity,
		str	private_identity,
		int	assignment_type,
		int	data_available
	)

Sends a SAR.

Can respond with a SIP reply if msg!=0

Parameters:

	msg	- the SIP message
	realm	- the realm
	public_identity	- public identity
	private_identity	- private identity
	assignment_type	- assignment type
	data_available	- if the data is already available

Returns:

CSCF_RETURN_TRUE if ok, CSCF_RETURN_FALSE on error or CSCF_RETURN_BREAK on response sent out

Definition at line 498 of file registrar.c.

References AAA_SUCCESS, AAA_UNABLE_TO_COMPLY, cdp_binds::AAAFreeMessage, AVP_IMS_SAR_ADMINISTRATIVE_DEREGISTRATION, AVP_IMS_SAR_TIMEOUT_DEREGISTRATION, AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME, AVP_IMS_SAR_UNREGISTERED_USER, AVP_IMS_SAR_USER_DEREGISTRATION, AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME, cdpb, cscf_get_realm_from_uri(), CSCF_RETURN_BREAK, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, Cx_get_charging_info(), Cx_get_experimental_result_code(), Cx_get_result_code(), Cx_get_user_data(), Cx_SAR(), drop_auth_userdata(), MSG_403_AUTH_SCHEME_UNSOPPORTED, MSG_403_IDENTITIES_DONT_MATCH, MSG_403_UNABLE_TO_COMPLY, MSG_403_UNKOWN_EXPERIMENTAL_RC, MSG_403_UNKOWN_RC, MSG_403_USER_UNKNOWN, MSG_480_DIAMETER_MISSING_AVP, MSG_480_DIAMETER_TIMEOUT_SAR, RC_IMS_DIAMETER_ERROR_AUTH_SCHEME_NOT_SUPPORTED, RC_IMS_DIAMETER_ERROR_IDENTITIES_DONT_MATCH, RC_IMS_DIAMETER_ERROR_USER_UNKNOWN, S_REGISTER_reply(), save_location(), and scscf_name_str.

Referenced by registrar_timer(), S_assign_server(), and S_assign_server_unreg().

{
    AAAMessage *saa;
    int rc=-1,experimental_rc=-1;
    str xml={0,0},ccf1={0,0},ccf2={0,0},ecf1={0,0},ecf2={0,0};
        
    if (realm.len==0){
        realm = cscf_get_realm_from_uri(private_identity);
    }       
    saa = Cx_SAR(msg,public_identity,private_identity,scscf_name_str,realm,
        assignment_type,data_available);
    
    if (!saa){
        //TODO - add the warning code 99 in the reply   
        if (msg) S_REGISTER_reply(msg,480,MSG_480_DIAMETER_TIMEOUT_SAR);        
        goto error;
    }
    
    if (!Cx_get_result_code(saa,&rc)&&
        !Cx_get_experimental_result_code(saa,&experimental_rc))
    {
        if (msg) S_REGISTER_reply(msg,480,MSG_480_DIAMETER_MISSING_AVP);
        goto done;
    }
    
    switch(rc){
        case -1:
            switch(experimental_rc){
                case RC_IMS_DIAMETER_ERROR_USER_UNKNOWN:
                    if (msg) S_REGISTER_reply(msg,403,MSG_403_USER_UNKNOWN);        
                    break;
                case RC_IMS_DIAMETER_ERROR_IDENTITIES_DONT_MATCH:
                    if (msg) S_REGISTER_reply(msg,403,MSG_403_IDENTITIES_DONT_MATCH);       
                    break;
                case RC_IMS_DIAMETER_ERROR_AUTH_SCHEME_NOT_SUPPORTED:
                    if (msg) S_REGISTER_reply(msg,403,MSG_403_AUTH_SCHEME_UNSOPPORTED);     
                    break;
                
                default:
                    if (msg) S_REGISTER_reply(msg,403,MSG_403_UNKOWN_EXPERIMENTAL_RC);      
            }
            break;
        
        case AAA_UNABLE_TO_COMPLY:
            if (msg) S_REGISTER_reply(msg,403,MSG_403_UNABLE_TO_COMPLY);        
            break;
                
        case AAA_SUCCESS:
            goto success;           
            break;
                        
        default:
            if (msg) S_REGISTER_reply(msg,403,MSG_403_UNKOWN_RC);       
    }
    
goto done;      
    
success:
    xml = Cx_get_user_data(saa);
    
    if (assignment_type==AVP_IMS_SAR_TIMEOUT_DEREGISTRATION ||
        assignment_type==AVP_IMS_SAR_USER_DEREGISTRATION ||
        assignment_type==AVP_IMS_SAR_TIMEOUT_DEREGISTRATION_STORE_SERVER_NAME ||
        assignment_type==AVP_IMS_SAR_USER_DEREGISTRATION_STORE_SERVER_NAME ||
        assignment_type==AVP_IMS_SAR_ADMINISTRATIVE_DEREGISTRATION
       )
    {
        drop_auth_userdata(private_identity,public_identity);
    }
    
    Cx_get_charging_info(saa,&ccf1,&ccf2,&ecf1,&ecf2);
    if (msg||assignment_type==AVP_IMS_SAR_UNREGISTERED_USER){
        int ret = save_location(msg,assignment_type,&xml,&ccf1,&ccf2,&ecf1,&ecf2);
        if (saa) cdpb.AAAFreeMessage(&saa);
        return ret;
    }else{
        /* it was called internally and there is no SIP message to respond to */        
    }
    if (saa) cdpb.AAAFreeMessage(&saa);
    return CSCF_RETURN_TRUE;
done:   
    if (saa) cdpb.AAAFreeMessage(&saa);
    return CSCF_RETURN_FALSE;
error:  
    if (saa) cdpb.AAAFreeMessage(&saa);
    return CSCF_RETURN_BREAK;
}

static int r_calc_expires	(	contact_t *	c,
		unsigned int	expires_hdr
	)			[inline, static]

Calculates the expiration time for one contact.

Tries to use the Expiration header, if not present then use the expires parameter of the contact, if param not present it defaults to the default value. Also checks

Parameters:

	c	- the contact to calcualte for
	expires_hdr	- value of expires hdr if present, if not -1

Returns:

the time of expiration

Definition at line 599 of file registrar.c.

References registration_default_expires, registration_max_expires, registration_min_expires, and time_now.

{
    unsigned int r;
    if (expires_hdr>=0) r = expires_hdr;
    else r = registration_default_expires;
    if (c && c->expires)
        str2int(&(c->expires->body), (unsigned int*)&r); 
    if (r>0 && r<registration_min_expires) r = registration_min_expires;
    if (r>registration_max_expires) r = registration_max_expires;
    return time_now+r;
}

int r_calc_contact_q	(	param_t *	_q,
		qvalue_t *	_r
	)

Definition at line 616 of file registrar.c.

Referenced by update_contacts().

{
        if (!_q || (_q->body.len == 0)) {
                *_r = -1;
        } else {
                if (str2q(_r, _q->body.s, _q->body.len) < 0) {
                        LOG(L_ERR, "r_calc_contact_q(): Invalid q parameter\n");
                        return -1;
                }
        }
        return 0;
}

static int r_add_contact	(	struct sip_msg *	msg,
		str	uri,
		int	expires,
		qvalue_t	qvalue
	)			[static]

Adds a Contact header to the reply, containing the approved expires.

Parameters:

	msg	- the SIP message to add contact header to its reply
	uri	- the contact uri
	expires	- the expiration time
	qvalue	- q-value

Returns:

1 if ok, 0 if not

Definition at line 637 of file registrar.c.

References cscf_add_header_rpl().

{
    str hdr;
    int r;
    hdr.s = pkg_malloc(10+uri.len+10+12+3+1);
    if (!hdr.s) return 0;
    if(qvalue != -1) {
        float q = (float)qvalue/1000;
        sprintf(hdr.s,"Contact: <%.*s>;expires=%d;q=%.3f\r\n",uri.len,uri.s,expires,q);
    }       
    else
        sprintf(hdr.s,"Contact: <%.*s>;expires=%d\r\n",uri.len,uri.s,expires);
    hdr.len = strlen(hdr.s);
    r = cscf_add_header_rpl(msg,&hdr);
    pkg_free(hdr.s);
    return r;
}

static int update_contacts	(	struct sip_msg *	msg,
		int	assignment_type,
		unsigned char	is_star,
		ims_subscription **	s,
		str *	ua,
		str *	path,
		str *	ccf1,
		str *	ccf2,
		str *	ecf1,
		str *	ecf2
	)			[inline, static]

Updates the contacts in the registrar with the new values received, for the addresses received in the SAA.

Parameters:

	msg	- the SIP REGISTER message, if available
	assignment_type	- the value sent in SAR
	ct	- SIP contact list from message
	is_star	- if the contact header was of type STAR
	s	- the ims_subscription received in the SAA
	ua	- the user agent string
	path	- the path to save

Returns:

CSCF_RETURN_TRUE if ok, CSCF_RETURN_FALSE on error or CSCF_RETURN_BREAK on response sent out

Definition at line 669 of file registrar.c.

References AVP_IMS_SAR_REGISTRATION, ims_public_identity::barring, ci, cscf_get_expires_hdr(), cscf_get_last_via_received(), cscf_get_last_via_sent_by(), _r_public::early_ims_ip, if, IMS_REGISTRAR_CONTACT_REFRESHED, IMS_REGISTRAR_CONTACT_REGISTERED, IMS_USER_REGISTERED, M_NAME, ims_public_identity::public_identity, r_act_time(), r_calc_contact_q(), r_calc_expires(), registration_disable_early_ims, S_event_reg(), STR_SHM_DUP, update_r_contact(), and update_r_public().

{
    int i,j,s_used=0;
    r_public *p,*rpublic;
    r_contact *c=0;
    ims_public_identity *pi=0;
    struct hdr_field *h;
    contact_t *ci;
    int reg_state,expires_hdr=-1,expires,hash,rpublic_hash;
    str public_identity,sent_by={0,0};
    int contacts_added=0;
    qvalue_t qvalue;
    
//  if (!*s) return 1;
    if (msg) {
        /* check for Early-IMS case */
        if (!registration_disable_early_ims && !msg->authorization){
            str received={0,0};     
            sent_by = cscf_get_last_via_sent_by(msg);
            if (sent_by.len){
                received = cscf_get_last_via_received(msg);
                if (received.len) sent_by=received;             
            }
        }
        expires_hdr = cscf_get_expires_hdr(msg);
    }
    
    r_act_time();
    LOG(L_DBG,"DBG:"M_NAME":update_contacts: Assign Type %d\n",assignment_type);
    switch (assignment_type){
        case AVP_IMS_SAR_REGISTRATION:
            reg_state = IMS_USER_REGISTERED;
            if (!*s) break;
            for(i=0;i<(*s)->service_profiles_cnt;i++)
                for(j=0;j<(*s)->service_profiles[i].public_identities_cnt;j++){
                    pi = &((*s)->service_profiles[i].public_identities[j]);
                    if (!pi->