registrar_notify.c File Reference

---

Detailed Description

Serving-CSCF - "reg" Event Operations.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_notify.c.

#include "registrar_notify.h"
#include "registrar_storage.h"
#include "mod.h"
#include "../../mem/mem.h"
#include "../../mem/shm_mem.h"
#include "../../parser/parse_uri.h"
#include "../../locking.h"
#include "../tm/tm_load.h"
#include "sip.h"
#include "ims_pm.h"

Go to the source code of this file.

Defines
#define	MAX_REGINFO_SIZE   16384
	Maximum reginfo XML size.
Functions
int	r_notify_init ()
	Initializes the reg notifications list.
void	r_notify_destroy ()
	Destroys the reg notifications list.
int	S_can_subscribe (struct sip_msg *msg, char *str1, char *str2)
	Check if this message quallifies for a subscription.
int	S_subscribe (struct sip_msg *msg, char *str1, char *str2)
	Save this subscription.
int	S_SUBSCRIBE_reply (struct sip_msg *msg, int code, char *text, int *expires, str *contact)
	Replies to a SUBSCRIBE and also adds the need headers.
static void	r_create_notifications (void *pv, void *cv, void *ps, str content, long expires)
	Creates notifications with the given content for all of the subscribers.
static long	r_update_subscription_status (r_public *p)
	Look if there are no more public ids or contacts registered and expires the subscription.
str	r_get_reginfo_full (void *pv, int event_type, long *subsExpires)
	Creates the full reginfo XML.
str	r_get_reginfo_partial (void *pv, void *pc, int event_type, long *subsExpires)
	Creates the partial reginfo XML.
int	S_event_reg (void *pv, void *c, void *ps, int event_type, int send_now)
	Generate notifications and put them in the notification queue to be sent.
void	uac_request_cb (struct cell *t, int type, struct tmcb_params *ps)
	Callback for the UAC response to NOTIFY.
void	send_notification (r_notification *n)
	Creates a NOTIFY message and sends it.
void	notification_timer (unsigned int ticks, void *param)
	The Notification timer looks for unsent notifications and sends them.
r_notification *	new_r_notification (str req_uri, str uri, str subscription_state, str event, str content_type, str content, dlg_t *dialog, int version)
	Creates a notification based on the given parameters.
void	add_r_notification (r_notification *n)
	Adds a notification to the list of notifications at the end (FIFO).
void	free_r_notification (r_notification *n)
	Frees up space taken by a notification.
Variables
tm_binds	tmb
	Structure with pointers to tm funcs.
str	scscf_name_str
	fixed name of the S-CSCF
int	subscription_default_expires
	the default value for expires if none found
int	subscription_min_expires
	minimum subscription expiration time
int	subscription_max_expires
	maximum subscription expiration time
time_t	time_now
	Current time of the S-CSCF registrar.
int	r_hash_size
	Size of S-CSCF registrar hash table.
r_hash_slot *	registrar
	The S-CSCF registrar.
r_notification_list *	notification_list = 0
	list of notifications for reg to be sent
static str	lookup_sip = {"sip:",4}
str	expires_hdr1 = {"Expires: ",9}
str	expires_hdr2 = {"\r\n",2}
str	contact_hdr1 = {"Contact: <",10}
str	contact_hdr2 = {">\r\n",3}
static str	ruri_lr = {";lr",3}
static str	subs_terminated = {"terminated",10}
static str	subs_active = {"active;expires=",15}
static str	xml_start = {"<?xml version=\"1.0\"?>\n",22}
static str	r_full = {"full",4}
static str	r_partial = {"partial",7}
static str	r_reginfo_s = {"<reginfo xmlns=\"urn:ietf:params:xml:ns:reginfo\" version=\"%s\" state=\"%.*s\">\n",74}
static str	r_reginfo_e = {"</reginfo>\n",11}
static str	r_active = {"active",6}
static str	r_terminated = {"terminated",10}
static str	registration_s = {"\t<registration aor=\"%.*s\" id=\"%p\" state=\"%.*s\">\n",48}
static str	registration_e = {"\t</registration>\n",17}
static str	r_registered = {"registered",10}
static str	r_created = {"created",7}
static str	r_refreshed = {"refreshed",9}
static str	r_shortened = {"shortened",9}
static str	r_expired = {"expired",7}
static str	r_deactivated = {"deactivated",11}
static str	r_probation = {"probation",9}
static str	r_unregistered = {"unregistered",12}
static str	r_rejected = {"rejected",8}
static str	contact_s = {"\t\t<contact id=\"%p\" state=\"%.*s\" event=\"%.*s\" expires=\"%d\">\n",59}
static str	contact_s_q = {"\t\t<contact id=\"%p\" state=\"%.*s\" event=\"%.*s\" expires=\"%d\" q=\"%.3f\">\n",69}
static str	contact_e = {"\t\t</contact>\n",13}
static str	uri_s = {"\t\t\t<uri>",8}
static str	uri_e = {"</uri>\n",7}
static str	method = {"NOTIFY",6}
static str	event_hdr = {"Event: reg\r\n",12}
static str	maxfwds_hdr = {"Max-Forwards: 70\r\n",18}
static str	subss_hdr1 = {"Subscription-State: ",20}
static str	subss_hdr2 = {"\r\n",2}
static str	ctype_hdr1 = {"Content-Type: ",14}
static str	ctype_hdr2 = {"\r\n",2}

---

Define Documentation

#define MAX_REGINFO_SIZE   16384

Maximum reginfo XML size.

Definition at line 532 of file registrar_notify.c.

Referenced by new_r_notification(), r_get_reginfo_full(), and r_get_reginfo_partial().

---

Function Documentation

int r_notify_init

(

)

Initializes the reg notifications list.

Definition at line 85 of file registrar_notify.c.

References r_notification_list::lock, and notification_list.

Referenced by mod_init().

{
    notification_list = shm_malloc(sizeof(r_notification_list));
    if (!notification_list) return 0;
    memset(notification_list,0,sizeof(r_notification_list));
    notification_list->lock = lock_alloc();
    if (!notification_list->lock) return 0;
    notification_list->lock = lock_init(notification_list->lock);
    return 1;
}

void r_notify_destroy

(

)

Destroys the reg notifications list.

Definition at line 99 of file registrar_notify.c.

References free_r_notification(), r_notification_list::head, r_notification_list::lock, and notification_list.

Referenced by mod_destroy().

{
    r_notification *n,*nn;
    lock_get(notification_list->lock);
    n = notification_list->head;
    while(n){
        nn = n->next;
        free_r_notification(n);
        n = nn;
    }
    lock_destroy(notification_list->lock);
    lock_dealloc(notification_list->lock);  
    shm_free(notification_list);
}

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

Check if this message quallifies for a subscription.

Only 3 entities can subscribe:

• the user agent to its own state
• the P-CSCF specified in a Path header for that user
• AS (not implemented yet

  Todo:

  Allow also the AS listed in iFC and not belonging to a 3rd party

  Parameters:

  	msg	- the SIP SUBSCRIBE message
  	str1	- not used
  	str2	- not used

  Returns:

  CSCF_RETURN_TRUE if allowed, CSCF_RETURN_FALSE if not, CSCF_RETURN_ERROR on error

Definition at line 128 of file registrar_notify.c.

References _r_public::aor, ims_public_identity::barring, cscf_get_asserted_identity(), cscf_get_event(), CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, get_r_public(), if, lookup_sip, M_NAME, ims_service_profile::public_identities, ims_service_profile::public_identities_cnt, ims_public_identity::public_identity, _r_public::s, ims_subscription::service_profiles, and ims_subscription::service_profiles_cnt.

{
    int ret=CSCF_RETURN_FALSE;
    struct sip_uri puri;
    str uri={0,0};
    str event;
    str asserted_id;
    r_public *p=0;
    r_contact *c=0;
    ims_public_identity *pi=0;
    int i,j;

    LOG(L_DBG,"DBG:"M_NAME":S_can_subscribe: Checking if allowed to SUBSCRIBE\n");

    /* First check the parameters */
    if (msg->first_line.type!=SIP_REQUEST)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: This message is not a request\n");
        goto error;
    }       
    if (msg->first_line.u.request.method.len != 9 ||
        memcmp(msg->first_line.u.request.method.s,"SUBSCRIBE",9)!=0)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: This message is not a SUBSCRIBE\n");
        goto error;
    }

    /* 1. Get the event     */
    event = cscf_get_event(msg);
    if (event.len!=3||strncasecmp(event.s,"reg",3)!=0){
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: Accepting only <Event: reg>. Found: <%.*s>\n",
            event.len,event.s);
        ret = CSCF_RETURN_FALSE;    
        goto done;
    } 
    
    /* 2. Get the target of the SUBSCRIBE from RequestURI */
    if (msg->new_uri.s) uri = msg->new_uri;
    else uri = msg->first_line.u.request.uri;
    
    if (parse_uri(uri.s, uri.len, &puri) < 0) {
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: Error parsing uri <%.*s>\n",
            uri.len,uri.s);
        goto error;
    }
    uri.len = lookup_sip.len+puri.user.len+1+puri.host.len;
    uri.s = pkg_malloc(uri.len);
    if (!uri.s){
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: Error allocating %d bytes\n",uri.len);
        goto error;
    }
    uri.len=0;
    memcpy(uri.s,lookup_sip.s,lookup_sip.len);
    uri.len+=lookup_sip.len;
    memcpy(uri.s+uri.len,puri.user.s,puri.user.len);
    uri.len+=puri.user.len;
    uri.s[uri.len++]='@';
    memcpy(uri.s+uri.len,puri.host.s,puri.host.len);
    uri.len+=puri.host.len;

    /* 3. Check if the asserted identity is in the same group with the ReqURI */
    asserted_id = cscf_get_asserted_identity(msg);
    if (!asserted_id.len){
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: P-Asserted-Identity empty.\n");
        ret =  CSCF_RETURN_FALSE;
        goto done;      
    }
    LOG(L_DBG,"DBG:"M_NAME":S_can_subscribe: P-Asserted-Identity <%.*s>.\n",
        asserted_id.len,asserted_id.s);
    
    p = get_r_public(uri);
    
    if (!p){
        LOG(L_ERR,"ERR:"M_NAME":S_can_subscribe: Identity not found <%.*s>\n",
            uri.len,uri.s);
        ret =  CSCF_RETURN_FALSE;
        goto done;
    }
    if (p->aor.len == asserted_id.len &&
        strncasecmp(p->aor.s,asserted_id.s,asserted_id.len)==0)
    {
        LOG(L_DBG,"DBG:"M_NAME":S_can_subscribe: Identity found as AOR <%.*s>\n",
            uri.len,uri.s);
        ret = CSCF_RETURN_TRUE;
        goto done;
    }
    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 (!pi->barring &&
                    pi->public_identity.len == asserted_id.len &&
                    strncasecmp(pi->public_identity.s,asserted_id.s,asserted_id.len)==0)
                {
                    LOG(L_DBG,"DBG:"M_NAME":S_can_subscribe: Identity found in SP[%d][%d]\n",
                        i,j);
                    ret = CSCF_RETURN_TRUE;
                    goto done;
                }   
            }
    }
    
    /* 4. Check if it present in any of the Path headers */
    c=p->head;

    while(c){
        if (c->path.len){
            for(i=0;i<c->path.len-asserted_id.len;i++)
                if (strncasecmp(c->path.s+i,asserted_id.s,asserted_id.len)==0){
                    LOG(L_DBG,"DBG:"M_NAME":S_can_subscribe: Identity found in Path <%.*s>\n",
                        c->path.len,c->path.s);
                    ret = CSCF_RETURN_TRUE;
                    goto done;
                }
        }
        c = c->next;
    }
    
    
done:
    if (p) r_unlock(p->hash);
    if (uri.s) pkg_free(uri.s);
    return ret;
error:
    if (p) r_unlock(p->hash);
    if (uri.s) pkg_free(uri.s);
    ret=CSCF_RETURN_ERROR;
    return ret; 
}

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

Save this subscription.

Parameters:

	msg	- the SIP SUBSCRIBE message
	str1	- not used
	str2	- not used

Returns:

CSCF_RETURN_TRUE if allowed, CSCF_RETURN_FALSE if not, CSCF_RETURN_ERROR on error

Definition at line 267 of file registrar_notify.c.

References add_r_public(), cscf_get_contact(), cscf_get_event(), cscf_get_expires_hdr(), CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, del_r_subscriber(), _r_subscriber::dialog, _r_subscriber::expires, get_r_public(), get_r_subscriber(), _r_public::hash, IMS_EVENT_NONE, IMS_EVENT_REG, IMS_REGISTRAR_SUBSCRIBE, IMS_REGISTRAR_UNSUBSCRIBE, lookup_sip, M_NAME, MSG_REG_SUBSCRIBE_OK, MSG_REG_UNSUBSCRIBE_OK, r_act_time(), r_unlock(), S_event_reg(), S_SUBSCRIBE_reply(), subscription_default_expires, subscription_max_expires, subscription_min_expires, time_now, tmb, and update_r_subscriber().

{
    int ret=CSCF_RETURN_FALSE;
    struct sip_uri puri;
    str uri={0,0};
    str event;
    int event_i=IMS_EVENT_NONE;
    int expires=0,expires_time=0;
    str subscriber;
    r_public *p=0;
    r_subscriber *s=0,*new_s=0;
    dlg_t *dialog=0;

    LOG(L_DBG,"DBG:"M_NAME":S_subscribe: Saving SUBSCRIBE\n");

    /* First check the parameters */
    if (msg->first_line.type!=SIP_REQUEST)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: This message is not a request\n");
        goto error;
    }       
    if (msg->first_line.u.request.method.len != 9 ||
        memcmp(msg->first_line.u.request.method.s,"SUBSCRIBE",9)!=0)
    {
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: This message is not a SUBSCRIBE\n");
        goto error;
    }

    /* 1. Get the event     */
    event = cscf_get_event(msg);
    if (event.len!=3||strncasecmp(event.s,"reg",3)!=0){
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Accepting only <Event: reg>. Found: <%.*s>\n",
            event.len,event.s);
        ret = CSCF_RETURN_FALSE;    
        goto done;
    } 
    if (event.len==0 && strncasecmp(event.s,"reg",3)==0)
        event_i = IMS_EVENT_REG;
    
    /* 2. Get the target of the SUBSCRIBE from RequestURI */
    if (msg->new_uri.s) uri = msg->new_uri;
    else uri = msg->first_line.u.request.uri;
    
    if (parse_uri(uri.s, uri.len, &puri) < 0) {
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Error parsing uri <%.*s>\n",
            uri.len,uri.s);
        goto error;
    }
    uri.len = lookup_sip.len+puri.user.len+1+puri.host.len;
    uri.s = pkg_malloc(uri.len);
    if (!uri.s){
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Error allocating %d bytes\n",uri.len);
        goto error;
    }
    uri.len=0;
    memcpy(uri.s,lookup_sip.s,lookup_sip.len);
    uri.len+=lookup_sip.len;
    memcpy(uri.s+uri.len,puri.user.s,puri.user.len);
    uri.len+=puri.user.len;
    uri.s[uri.len++]='@';
    memcpy(uri.s+uri.len,puri.host.s,puri.host.len);
    uri.len+=puri.host.len;

    /* 3. Get the Subscriber's Identity */
    subscriber = cscf_get_contact(msg);
    if (!subscriber.len){
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Contact empty.\n");
        ret =  CSCF_RETURN_FALSE;
        goto done;      
    }
    LOG(L_DBG,"DBG:"M_NAME":S_subscribe: Contact <%.*s>.\n",
        subscriber.len,subscriber.s);
    
    p = get_r_public(uri);

    /* Registration is possible even if the user is not registered... so just create one */
    if (!p){
        p = add_r_public(uri,0,0);
    }
    if (!p){        
        LOG(L_ERR,"ERR:"M_NAME":S_subscribe: Identity not found and error on creation <%.*s>\n",
            uri.len,uri.s);
        ret =  CSCF_RETURN_FALSE;
        goto done;
    }
        
    expires = cscf_get_expires_hdr(msg);
    if (expires == -1) expires = subscription_default_expires;
    if (expires > 0) {
        if (expires < subscription_min_expires) expires = subscription_min_expires;
        if (expires > subscription_max_expires) expires = subscription_max_expires;
        r_act_time();
        expires_time = expires + time_now;
        
        /* get the old subscriber - if any */
        s = get_r_subscriber(p,subscriber,event_i); 
        if (!s){
            /* create a new dialog */
            if (tmb.new_dlg_uas(msg, 200, &dialog) < 0) {       
                LOG(L_ERR,"ERR:"M_NAME":S_subscribe:  Error while creating dialog state\n");
                ret = CSCF_RETURN_FALSE;
                goto error;
            }
        }else
            dialog = s->dialog;
        
        /* update the subscriber */
        if ((new_s=update_r_subscriber(p,subscriber,event_i,&expires_time,dialog))!=0){     
            //if (!s)   /* Only on first subscription, not on refreshes, send a notify */
                S_event_reg(p,0,new_s,IMS_REGISTRAR_SUBSCRIBE,0);
            ret = CSCF_RETURN_TRUE;
        }
        else
            ret = CSCF_RETURN_FALSE;    
    }else{
        /* Unsubscribe */
        /* get the old subscriber - if any */
        r_act_time();
        s = get_r_subscriber(p,subscriber,event_i); 
        if (s) {
            s->expires = time_now;
            S_event_reg(p,0,s,IMS_REGISTRAR_UNSUBSCRIBE,1);
            del_r_subscriber(p,s);
        }
        ret = CSCF_RETURN_TRUE;
    }
done:   
    r_unlock(p->hash);
    if (expires ==0 )S_SUBSCRIBE_reply(msg,200,MSG_REG_UNSUBSCRIBE_OK,&expires,&uri);
    else S_SUBSCRIBE_reply(msg,200,MSG_REG_SUBSCRIBE_OK,&expires,&uri);
    if (uri.s) pkg_free(uri.s);
    return ret;
error:
    if (p) r_unlock(p->hash);
    if (uri.s) pkg_free(uri.s);
    ret=CSCF_RETURN_FALSE;
    return ret; 
}

int S_SUBSCRIBE_reply	(	struct sip_msg *	msg,
		int	code,
		char *	text,
		int *	expires,
		str *	contact
	)

Replies to a SUBSCRIBE and also adds the need headers.

Path for example.

Parameters:

	msg	- the SIP SUBSCRIBE message
	code	- response code to send
	text	- response phrase to send
	expires	- expiration interval in seconds
	contact	- contact to add to reply

Returns:

the tmn.r_reply returned value value

Definition at line 422 of file registrar_notify.c.

References cscf_add_header_rpl(), M_NAME, STR_APPEND, and tmb.

Referenced by S_subscribe().

{
    str hdr={0,0};
    tmb.t_newtran(msg);
    
    if (expires){
        hdr.len = expires_hdr1.len+12+expires_hdr1.len;
        hdr.s = pkg_malloc(hdr.len);
        if (!hdr.s){
            LOG(L_ERR,"ERR:"M_NAME":S_SUBSCRIBE_reply: Error allocating %d bytes.\n",
                hdr.len);           
        }else{
            hdr.len=0;
            STR_APPEND(hdr,expires_hdr1);
            sprintf(hdr.s+hdr.len,"%d",*expires);
            hdr.len += strlen(hdr.s+hdr.len);
            STR_APPEND(hdr,expires_hdr2);
            cscf_add_header_rpl(msg,&hdr);      
            pkg_free(hdr.s);
        }
    }

    if (contact){
        hdr.len = contact_hdr1.len+contact->len+contact_hdr2.len;
        hdr.s = pkg_malloc(hdr.len);
        if (!hdr.s){
            LOG(L_ERR,"ERR:"M_NAME":S_SUBSCRIBE_reply: Error allocating %d bytes.\n",
                hdr.len);           
        }else{
            hdr.len=0;
            STR_APPEND(hdr,contact_hdr1);
            STR_APPEND(hdr,*contact);
            STR_APPEND(hdr,contact_hdr2);
            cscf_add_header_rpl(msg,&hdr);      
            pkg_free(hdr.s);
        }
    }
    
    return tmb.t_reply(msg,code,text);
}

static void r_create_notifications	(	void *	pv,
		void *	cv,
		void *	ps,
		str	content,
		long	expires
	)			[static]

Creates notifications with the given content for all of the subscribers.

Parameters:

	pv	- r_public* to which it refers
	cv	- the r_contact* to which it refers or NULL if for all
	ps	- the r_subscriber* to which it refers or NULL if for all
	content	- the body content
	expires	- the remaining subcription expiration time in seconds

Definition at line 477 of file registrar_notify.c.

References add_r_notification(), _r_public::aor, _r_subscriber::dialog, _r_subscriber::expires, M_NAME, new_r_notification(), _r_subscriber::next, _r_public::shead, STR_PKG_DUP, _r_subscriber::subscriber, time_now, and _r_subscriber::version.

Referenced by S_event_reg().

{
    r_notification *n;
    r_public *p=(r_public*)pv;
//  r_contact *c;
    r_subscriber *for_s=(r_subscriber*)ps;
    r_subscriber *s;    
    str uri={0,0},req_uri={0,0},subscription_state={"active;expires=10000000000",26},
        event={0,0},content_type={"application/reginfo+xml",23};
        
    uri = p->aor;
    if (!for_s) s = p->shead;
    else s = for_s;
    
    while(s){
        req_uri.len = s->subscriber.len+ruri_lr.len;
        req_uri.s = pkg_malloc(req_uri.len);
        if (!req_uri.s) {
            LOG(L_ERR,"ERR:"M_NAME":r_create_notifications: Error allocating %d bytes.\n",req_uri.len);
            return;         
        }
        memcpy(req_uri.s,s->subscriber.s,s->subscriber.len);
        memcpy(req_uri.s+s->subscriber.len,ruri_lr.s,ruri_lr.len);
        //route = s->path;
        if (s->expires>time_now) {
            subscription_state.s = pkg_malloc(32);
            subscription_state.len=0;
            if (subscription_state.s){
                sprintf(subscription_state.s,"%.*s%ld",subs_active.len,subs_active.s,expires);
                subscription_state.len=strlen(subscription_state.s);
            }                   
        }else {                 
            STR_PKG_DUP(subscription_state,subs_terminated,"pkg subs state");
        }
        n = new_r_notification(req_uri,uri,subscription_state,event,
            content_type,content,s->dialog,s->version++);                       
        if (req_uri.s) pkg_free(req_uri.s);
        if (subscription_state.s) pkg_free(subscription_state.s);   
        if (n) {
            #ifdef WITH_IMS_PM
                n->is_scscf_dereg=(expires==0);
            #endif 
            add_r_notification(n);
        }       
        
        if (!for_s) s = s->next;                
        else s = 0;
    }
    return;
out_of_memory:
    if (req_uri.s) pkg_free(req_uri.s);
    return; 
}

static long r_update_subscription_status

(

r_public *

p

)

[inline, static]

Look if there are no more public ids or contacts registered and expires the subscription.

Note:

must be called with lock on the domain

Parameters:

p

- the r_public to update.

Returns:

the expiration is seconds

Definition at line 542 of file registrar_notify.c.

References _r_subscriber::expires, _r_contact::expires, _r_public::head, _r_subscriber::next, r_act_time(), r_valid_contact(), _r_public::shead, and time_now.

Referenced by r_get_reginfo_full(), and r_get_reginfo_partial().

{
    r_subscriber *s;
    r_contact *c;
    long expires=0;
    int cnt=0;
    
    r_act_time();
    
    c = p->head;
    while(c){
        if (r_valid_contact(c)){
            if (c->expires-time_now+30>expires)
                expires = c->expires-time_now+30;
            cnt++;
        }
        c = c->next;
    }       
    if (!cnt){
        s = p->shead;
        while(s){
            s->expires = time_now-1;
            s = s->next;
        }   
    }
    return expires;
}

str r_get_reginfo_full	(	void *	pv,
		int	event_type,
		long *	subsExpires
	)

Creates the full reginfo XML.

Parameters:

	pv	- the r_public to create for
	event_type	- event type
	subsExpires	- subscription expiration

Returns:

the str with the XML content

Definition at line 605 of file registrar_notify.c.

References ims_public_identity::barring, _r_contact::expires, get_aor_hash(), get_r_public(), get_r_public_nolock(), _r_public::hash, _r_contact::head, MAX_REGINFO_SIZE, _r_contact::next, ims_service_profile::public_identities, ims_service_profile::public_identities_cnt, ims_public_identity::public_identity, _r_contact::qvalue, r_hash_size, r_unlock(), r_update_subscription_status(), REGISTERED, _r_public::s, ims_subscription::service_profiles, ims_subscription::service_profiles_cnt, STR_APPEND, time_now, and _r_contact::uri.

Referenced by S_event_reg().

{       
    str x={0,0};
    str buf,pad;    
    char bufc[MAX_REGINFO_SIZE],padc[MAX_REGINFO_SIZE];

    r_public *p=(r_public*)pv,*p2;
    r_contact *c;
    ims_public_identity *pi;
    int i,j;
    unsigned int hash;
    
    buf.s = bufc;
    buf.len=0;
    pad.s = padc;
    pad.len=0;
    
    *subsExpires = r_update_subscription_status(p);
    
    STR_APPEND(buf,xml_start);
    sprintf(pad.s,r_reginfo_s.s,"%d",r_full.len,r_full.s);
    pad.len = strlen(pad.s);
    STR_APPEND(buf,pad);
    
    
    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 (!pi->barring){
                    hash = get_aor_hash(pi->public_identity,r_hash_size);
                    if (hash == p->hash) /* because we already have the lock on p->hash */
                        p2 = get_r_public_nolock(pi->public_identity);
                    else 
                        p2 = get_r_public(pi->public_identity);
                    if (p2){
                        if (p2->reg_state==REGISTERED)
                            sprintf(pad.s,registration_s.s,p2->aor.len,p2->aor.s,p2,r_active.len,r_active.s);
                        else 
                            sprintf(pad.s,registration_s.s,p2->aor.len,p2->aor.s,p2,r_terminated.len,r_terminated.s);
                        pad.len = strlen(pad.s);
                        STR_APPEND(buf,pad);
                        c = p2->head;
                        while(c){
                            if(c->qvalue != -1) {
                                float q = (float)c->qvalue/1000;
                                sprintf(pad.s,contact_s_q.s,c,r_active.len,r_active.s,r_registered.len,r_registered.s,c->expires-time_now, q);
                            }
                            else
                                sprintf(pad.s,contact_s.s,c,r_active.len,r_active.s,r_registered.len,r_registered.s,c->expires-time_now);
                            pad.len = strlen(pad.s);
                            STR_APPEND(buf,pad);                            
                            STR_APPEND(buf,uri_s);
                            STR_APPEND(buf,c->uri);
                            STR_APPEND(buf,uri_e);
                            STR_APPEND(buf,contact_e);
                            c = c->next;
                        }
                        STR_APPEND(buf,registration_e);
                        if (p2->hash != p->hash) r_unlock(p2->hash);
                    }
                }
            }               
    }

    STR_APPEND(buf,r_reginfo_e);

    
    x.s = pkg_malloc(buf.len+1);
    if (x.s){
        x.len = buf.len;
        memcpy(x.s,buf.s,buf.len);
        x.s[x.len]=0;
    }
    return x;
}

str r_get_reginfo_partial	(	void *	pv,
		void *	pc,
		int	event_type,
		long *	subsExpires
	)

Creates the partial reginfo XML.

Parameters:

	pv	- the r_public to create for
	pc	- the r_contatct to create for
	event_type	- event type
	subsExpires	- subscription expiration

Returns:

the str with the XML content

Definition at line 691 of file registrar_notify.c.

References _r_public::aor, contact_e, contact_s, contact_s_q, _r_contact::expires, _r_public::head, IMS_REGISTRAR_CONTACT_CREATED, IMS_REGISTRAR_CONTACT_DEACTIVATED, IMS_REGISTRAR_CONTACT_EXPIRED, IMS_REGISTRAR_CONTACT_PROBATION, IMS_REGISTRAR_CONTACT_REFRESHED, IMS_REGISTRAR_CONTACT_REGISTERED, IMS_REGISTRAR_CONTACT_REJECTED, IMS_REGISTRAR_CONTACT_SHORTENED, IMS_REGISTRAR_CONTACT_UNREGISTERED, MAX_REGINFO_SIZE, _r_contact::qvalue, r_active, r_created, r_deactivated, r_expired, r_partial, r_probation, r_refreshed, r_reginfo_e, r_reginfo_s, r_registered, r_rejected, r_shortened, r_terminated, r_unregistered, r_update_subscription_status(), registration_e, registration_s, STR_APPEND, _r_public::tail, time_now, _r_contact::uri, uri_e, uri_s, and xml_start.

Referenced by S_event_reg().

{       
    str x={0,0};
    str buf,pad;    
    char bufc[MAX_REGINFO_SIZE],padc[MAX_REGINFO_SIZE];
    int expires=-1;

    r_public *p=(r_public*)pv;
    r_contact *c=(r_contact*)pc;
    str state,event;
    
    buf.s = bufc;
    buf.len=0;
    pad.s = padc;
    pad.len=0;

    *subsExpires = r_update_subscription_status(p);
    
    STR_APPEND(buf,xml_start);
    sprintf(pad.s,r_reginfo_s.s,"%d",r_partial.len,r_partial.s);
    pad.len = strlen(pad.s);
    STR_APPEND(buf,pad);
    
    
    if (p){
        expires = c->expires-time_now;
        if (p->head == c && p->tail == c && 
            (event_type==IMS_REGISTRAR_CONTACT_EXPIRED ||
             event_type==IMS_REGISTRAR_CONTACT_DEACTIVATED||
             event_type==IMS_REGISTRAR_CONTACT_UNREGISTERED||
             event_type==IMS_REGISTRAR_CONTACT_REJECTED)
           )
            sprintf(pad.s,registration_s.s,p->aor.len,p->aor.s,p,r_terminated.len,r_terminated.s);
        else 
            sprintf(pad.s,registration_s.s,p->aor.len,p->aor.s,p,r_active.len,r_active.s);
        pad.len = strlen(pad.s);
        STR_APPEND(buf,pad);
        if (c){
            switch(event_type){
                case IMS_REGISTRAR_CONTACT_REGISTERED:
                    state = r_active;
                    event = r_registered;
                    break;
                case IMS_REGISTRAR_CONTACT_CREATED:
                    state = r_active;
                    event = r_created;
                    break;
                case IMS_REGISTRAR_CONTACT_REFRESHED:
                    state = r_active;
                    event = r_refreshed;
                    break;
                case IMS_REGISTRAR_CONTACT_SHORTENED:
                    state =