registrar.c

Go to the documentation of this file.

/*
 * $Id: registrar.c 591 2008-10-15 12:46:34Z vingarzan $
 *  
 * Copyright (C) 2004-2006 FhG Fokus
 *
 * This file is part of Open IMS Core - an open source IMS CSCFs & HSS
 * implementation
 *
 * Open IMS Core is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * For a license to use the Open IMS Core software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact Fraunhofer FOKUS by e-mail at the following
 * addresses:
 *     info@open-ims.org
 *
 * Open IMS Core is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * It has to be noted that this Open Source IMS Core System is not 
 * intended to become or act as a product in a commercial context! Its 
 * sole purpose is to provide an IMS core reference implementation for 
 * IMS technology testing and IMS application prototyping for research 
 * purposes, typically performed in IMS test-beds.
 * 
 * Users of the Open Source IMS Core System have to be aware that IMS
 * technology may be subject of patents and licence terms, as being 
 * specified within the various IMS-related IETF, ITU-T, ETSI, and 3GPP
 * standards. Thus all Open IMS Core users have to take notice of this 
 * fact and have to agree to check out carefully before installing, 
 * using and extending the Open Source IMS Core System, if related 
 * patents and licences may become applicable to the intended usage 
 * context.  
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 */
 
#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"


extern struct tm_binds tmb;             
extern struct cdp_binds cdpb;           
extern int r_hash_size;                 
extern r_hash_slot *registrar;      
extern str scscf_name_str;              
extern str scscf_service_route_uri;     
extern str scscf_registration_min_expires;
extern int server_assignment_store_data;
extern int registration_default_expires;
extern int registration_min_expires;    
extern int registration_max_expires;    
extern int registration_disable_early_ims;  
extern time_t time_now;                 
extern int append_branches;             
#ifdef WITH_IMS_PM
        static str zero={0,0};
#endif


void registrar_timer(unsigned int ticks, void* param)
{
    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 )
{
    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 )
{
    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)
{
    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 inline int r_calc_expires(contact_t *c,unsigned int expires_hdr)
{
    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;
}

/*
 * Calculate contact q value as follows:
 * 1) If q parameter exists, use it
 * 2) If the parameter doesn't exist, use the default value
 */
int r_calc_contact_q(param_t* _q, qvalue_t* _r)
{
        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)
{
    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 inline 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)
{
    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->barring){
                        if (!(p=update_r_public(pi->public_identity,&reg_state,s,ccf1,ccf2,ecf1,ecf2))){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                pi->public_identity.len,pi->public_identity.s);
                            goto error;
                        }
                        s_used++;
                        if (!registration_disable_early_ims && sent_by.len) {
                            if (p->early_ims_ip.s) shm_free(p->early_ims_ip.s);
                            STR_SHM_DUP(p->early_ims_ip,sent_by,"IP Early IMS");
                        }
                        if (is_star){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: STAR not accepted in contact for Registration.\n");
                        }else{
                            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(r_calc_contact_q(ci->q, &qvalue) != 0){
                                        LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                                                                        ci->uri.len,ci->uri.s);
                                                                                goto error;
                                    }
                                    expires = r_calc_expires(ci,expires_hdr);
                                    if (!(c=update_r_contact(p,ci->uri,&expires,ua,path,qvalue))){
                                        LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                            ci->uri.len,ci->uri.s);
                                        goto error;
                                    }
                                    if (assignment_type == AVP_IMS_SAR_REGISTRATION)
                                        S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_REGISTERED,0);
                                    else 
                                        S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_REFRESHED,0);
                                    
                                }
                            if (!contacts_added){
                                for(c=p->head;c;c=c->next)
                                    r_add_contact(msg,c->uri,c->expires-time_now,c->qvalue);
                                contacts_added = 1;
                            }
                        }
                        r_unlock(p->hash);
                    }
                }
            break;
        case AVP_IMS_SAR_RE_REGISTRATION:
            reg_state = IMS_USER_REGISTERED;
            public_identity = cscf_get_public_identity(msg);
            if (!public_identity.len) {
                    LOG(L_ERR,"ERR:"M_NAME":update_contacts: message contains no public identity\n");
                    goto error;
            }

            p = get_r_public(public_identity);
            if (!p){
                LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s> - not found in registrar\n",
                    public_identity.len,public_identity.s);
                goto error;
            }

            if (!registration_disable_early_ims && sent_by.len) {
                if (p->early_ims_ip.s) shm_free(p->early_ims_ip.s);
                STR_SHM_DUP(p->early_ims_ip,sent_by,"IP Early IMS");
            }
            if (is_star){
                LOG(L_ERR,"ERR:"M_NAME":update_contacts: STAR not accepted in contact for Re-Registration.\n");
            }else{
                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(r_calc_contact_q(ci->q, &qvalue) != 0){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                   ci->uri.len,ci->uri.s);
                                goto error;
                        }
                        expires = r_calc_expires(ci,expires_hdr);
                        if (!(c=update_r_contact(p,ci->uri,&expires,ua,path,qvalue))){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                ci->uri.len,ci->uri.s);
                            goto error;
                        }
                        if (assignment_type == AVP_IMS_SAR_REGISTRATION)
                            S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_REGISTERED,0);
                        else
                            S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_REFRESHED,0);                        
                    }
                for(c=p->head;c;c=c->next)
                    r_add_contact(msg,c->uri,c->expires-time_now,c->qvalue);
            }            

            /* now update the implicit set */
            if (p->s)
            for(i=0;i<p->s->service_profiles_cnt;i++)
                for(j=0;j<p->s->service_profiles[i].public_identities_cnt;j++){
                    pi = &(p->s->service_profiles[i].public_identities[j]);
                    if (public_identity.len==pi->public_identity.len &&
                        strncasecmp(pi->public_identity.s,public_identity.s,public_identity.len)==0) continue;

                    rpublic = update_r_public_previous_lock(pi->public_identity,p->hash,&reg_state,s,ccf1,ccf2,ecf1,ecf2);
                    if (!rpublic){
                        LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                            pi->public_identity.len,pi->public_identity.s);
                        continue;
                    }

                    if (!registration_disable_early_ims && sent_by.len) {
                        if (rpublic->early_ims_ip.s) shm_free(rpublic->early_ims_ip.s);
                            STR_SHM_DUP(rpublic->early_ims_ip,sent_by,"IP Early IMS");
                    }
                    if (is_star){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: STAR not accepted in contact for Re-Registration.\n");
                    }else{
                        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(r_calc_contact_q(ci->q, &qvalue) != 0){
                                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                                    ci->uri.len,ci->uri.s);
                                            goto error;
                                        }
                                    expires = r_calc_expires(ci,expires_hdr);
                                    if (!(c=update_r_contact(rpublic,ci->uri,&expires,ua,path,qvalue))){
                                        LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s> - implicit identity not found in registrar\n",
                                            ci->uri.len,ci->uri.s);
                                        goto error;
                                    }
                                    if (assignment_type == AVP_IMS_SAR_REGISTRATION)
                                        S_event_reg(rpublic,c,0,IMS_REGISTRAR_CONTACT_REGISTERED,0);
                                    else
                                        S_event_reg(rpublic,c,0,IMS_REGISTRAR_CONTACT_REFRESHED,0);
                                }
                    }
                    if (rpublic->hash!=p->hash) r_unlock(rpublic->hash);                            
            }
            r_unlock(p->hash);
            break;      
            
        case AVP_IMS_SAR_USER_DEREGISTRATION:
            public_identity = cscf_get_public_identity(msg);
            if (!public_identity.len) {
                LOG(L_ERR,"ERR:"M_NAME":update_contacts: message contains no public identity\n");
                goto error;
            }
            p = get_r_public(public_identity);

            if (!p){
                LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s> - not found in registrar\n",
                    public_identity.len,public_identity.s);
                goto error;
            }

            //deregister public identity that is on the message
            if (is_star){
                c = p->head;
                while(c){
                    c->expires = time_now;
                    S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_UNREGISTERED,0);
                    r_add_contact(msg,c->uri,0,c->qvalue);
                    del_r_contact(p,c);
                    c = c->next;
                }
            }else{
                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){
                            c = get_r_contact(p,ci->uri);
                            if (c) {
                                c->expires = time_now;
                                S_event_reg(p,c,0,IMS_REGISTRAR_CONTACT_UNREGISTERED,0);
                                r_add_contact(msg,c->uri,0,c->qvalue);
                                del_r_contact(p,c);
                            }
                        }
                for(c=p->head;c;c=c->next)
                    r_add_contact(msg,c->uri,c->expires-time_now,c->qvalue);                        
            }

            /* now update the implicit set */
            if (p->s)
            for(i=0;i<p->s->service_profiles_cnt;i++)
                for(j=0;j<p->s->service_profiles[i].public_identities_cnt;j++){
                    pi = &(p->s->service_profiles[i].public_identities[j]);
                    if (public_identity.len == pi->public_identity.len && 
                        strncasecmp(pi->public_identity.s,public_identity.s,public_identity.len)==0)    continue;
                        
                    rpublic = update_r_public_previous_lock(pi->public_identity,p->hash,&reg_state,s,ccf1,ccf2,ecf1,ecf2);              
                    if (!rpublic){
                        LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s> - implicit identity not found in registrar\n",
                            pi->public_identity.len,pi->public_identity.s);
                        continue;
                    }
                    s_used++;
                    if (is_star){
                        c = rpublic->head;
                        while(c){
                            c->expires = time_now;
                            S_event_reg(rpublic,c,0,IMS_REGISTRAR_CONTACT_UNREGISTERED,0);                                                                          
                            del_r_contact(rpublic,c);   
                            c = c->next;
                        }
                    }else{
                        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){
                                    c = get_r_contact(rpublic,ci->uri);
                                    if (c) {
                                        c->expires = time_now;
                                        S_event_reg(rpublic,c,0,IMS_REGISTRAR_CONTACT_UNREGISTERED,0);                     
                                        del_r_contact(rpublic,c);
                                    }
                            }
                    }
                    rpublic_hash = rpublic->hash;
                    if (!rpublic->head) 
                        del_r_public(rpublic);
                                                
                    if (p->hash!=rpublic_hash) r_unlock(rpublic_hash);
                }

            hash = p->hash;
            if (!p->head) 
                del_r_public(p);
            r_unlock(hash);         
            break;
                        
        case AVP_IMS_SAR_UNREGISTERED_USER:         
            reg_state = IMS_USER_UNREGISTERED;
            r_act_time();
            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->barring){
                        if (!(p=update_r_public(pi->public_identity,&reg_state,s,ccf1,ccf2,ecf1,ecf2))){
                            LOG(L_ERR,"ERR:"M_NAME":update_contacts: error on <%.*s>\n",
                                pi->public_identity.len,pi->public_identity.s);