registrar_notify.h File Reference

---

Detailed Description

Serving-CSCF - "reg" Event Operations.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_notify.h.

#include "../../sr_module.h"
#include "../../locking.h"
#include "../tm/tm_load.h"
#include "ims_pm.h"

Go to the source code of this file.

Data Structures
struct	_r_notification
	reg event notification structure More...
struct	r_notification_list
	Notification List Structure. More...
Defines
#define	MSG_REG_SUBSCRIBE_OK   "Subscription to REG saved"
#define	MSG_REG_UNSUBSCRIBE_OK   "Subscription to REG dropped"
Typedefs
typedef _r_notification	r_notification
	reg event notification structure
Enumerations
enum	{   IMS_REGISTRAR_NONE, IMS_REGISTRAR_SUBSCRIBE, IMS_REGISTRAR_UNSUBSCRIBE, IMS_REGISTRAR_SUBSCRIBE_EXPIRED,   IMS_REGISTRAR_CONTACT_REGISTERED, IMS_REGISTRAR_CONTACT_CREATED, IMS_REGISTRAR_CONTACT_REFRESHED, IMS_REGISTRAR_CONTACT_SHORTENED,   IMS_REGISTRAR_CONTACT_EXPIRED, IMS_REGISTRAR_CONTACT_DEACTIVATED, IMS_REGISTRAR_CONTACT_PROBATION, IMS_REGISTRAR_CONTACT_UNREGISTERED,   IMS_REGISTRAR_CONTACT_REJECTED }
	Event types for "reg" to generated notifications after. More...
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.
int	S_event_reg (void *p, void *c, void *s, int event_type, int send_now)
	Generate notifications and put them in the notification queue to be sent.
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
enum { ... }	IMS_Registrar_events
	Event types for "reg" to generated notifications after.

---

Define Documentation

#define MSG_REG_SUBSCRIBE_OK   "Subscription to REG saved"

Definition at line 64 of file registrar_notify.h.

Referenced by S_subscribe().

#define MSG_REG_UNSUBSCRIBE_OK   "Subscription to REG dropped"

Definition at line 65 of file registrar_notify.h.

Referenced by S_subscribe().

---

Typedef Documentation

typedef struct _r_notification r_notification

reg event notification structure

---

Enumeration Type Documentation

anonymous enum

Event types for "reg" to generated notifications after.

Enumerator:

IMS_REGISTRAR_NONE	no event - donothing
IMS_REGISTRAR_SUBSCRIBE	Initial SUBSCRIBE - just send all data - this should not be treated though.
IMS_REGISTRAR_UNSUBSCRIBE	Final UnSUBSCRIBE - just send a NOTIFY which will probably fail.
IMS_REGISTRAR_SUBSCRIBE_EXPIRED	The subscribe has expired.
IMS_REGISTRAR_CONTACT_REGISTERED	Registered with REGISTER.
IMS_REGISTRAR_CONTACT_CREATED	Registered administratively.
IMS_REGISTRAR_CONTACT_REFRESHED	The expiration was refreshed.
IMS_REGISTRAR_CONTACT_SHORTENED	The expiration was administratively shortened.
IMS_REGISTRAR_CONTACT_EXPIRED	A contact has expired and will be removed.
IMS_REGISTRAR_CONTACT_DEACTIVATED	Administratively removed, user should retry.
IMS_REGISTRAR_CONTACT_PROBATION	Administratively removed, user should retry later.
IMS_REGISTRAR_CONTACT_UNREGISTERED	User unregistered with Expires 0.
IMS_REGISTRAR_CONTACT_REJECTED	Administratively removed, user should not retry.

Definition at line 69 of file registrar_notify.h.

     {
    IMS_REGISTRAR_NONE,                 
    IMS_REGISTRAR_SUBSCRIBE,            
    IMS_REGISTRAR_UNSUBSCRIBE,          
    IMS_REGISTRAR_SUBSCRIBE_EXPIRED,    
    IMS_REGISTRAR_CONTACT_REGISTERED,   
    IMS_REGISTRAR_CONTACT_CREATED,      
    IMS_REGISTRAR_CONTACT_REFRESHED,    
    IMS_REGISTRAR_CONTACT_SHORTENED,    
    IMS_REGISTRAR_CONTACT_EXPIRED,      
    IMS_REGISTRAR_CONTACT_DEACTIVATED,  
    IMS_REGISTRAR_CONTACT_PROBATION,    
    IMS_REGISTRAR_CONTACT_UNREGISTERED, 
    IMS_REGISTRAR_CONTACT_REJECTED      
}IMS_Registrar_events;

---

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);
}

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.

Note:

Must be called with a lock on the r_public pv

Parameters:

	pv	- r_public to generate for
	c	- r_contact to generate for or NULL if for all
	ps	- r_subscriber to generated for or NULL if for all
	event_type	- event type
	send_now	- whether to send immediately or delay

Returns:

1 on success, 0 on failure

Definition at line 810 of file registrar_notify.c.

References 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, IMS_REGISTRAR_NONE, IMS_REGISTRAR_SUBSCRIBE, IMS_REGISTRAR_UNSUBSCRIBE, M_NAME, notification_timer(), r_act_time(), r_create_notifications(), r_get_reginfo_full(), and r_get_reginfo_partial().

Referenced by registrar_timer(), S_subscribe(), and update_contacts().

{
    r_public *p=(r_public*)pv;
    r_subscriber *s=(r_subscriber*)ps;
    str content={0,0};
    long subsExpires=-1;

    r_act_time();
    switch (event_type){
        case IMS_REGISTRAR_NONE:
            if (send_now) notification_timer(0,0);
            return 0;
            break;
        case IMS_REGISTRAR_SUBSCRIBE:
            content = r_get_reginfo_full(p,event_type,&subsExpires);
            r_create_notifications(p,0,s,content,subsExpires);          
            if (content.s) pkg_free(content.s);
            if (send_now) notification_timer(0,0);
            return 1;
            break;
        case IMS_REGISTRAR_UNSUBSCRIBE:
            subsExpires=0;
            r_create_notifications(p,0,s,content,subsExpires);          
            if (content.s) pkg_free(content.s);
            if (send_now) notification_timer(0,0);
            return 1;
            break;
            
        case IMS_REGISTRAR_CONTACT_REGISTERED:
        case IMS_REGISTRAR_CONTACT_CREATED: 
        case IMS_REGISTRAR_CONTACT_REFRESHED:
        case IMS_REGISTRAR_CONTACT_SHORTENED:
        case IMS_REGISTRAR_CONTACT_EXPIRED:
        case IMS_REGISTRAR_CONTACT_DEACTIVATED:
        case IMS_REGISTRAR_CONTACT_PROBATION:
        case IMS_REGISTRAR_CONTACT_UNREGISTERED:
        case IMS_REGISTRAR_CONTACT_REJECTED:
            content = r_get_reginfo_partial(p,c,event_type,&subsExpires);   
            r_create_notifications(p,c,s,content,subsExpires);
            if (content.s) pkg_free(content.s);
            if (send_now) notification_timer(0,0);
            return 1;
            break;
                
        default:
            LOG(L_ERR,"ERR:"M_NAME":S_event_reg: Unknown event %d\n",event_type);
            if (send_now) notification_timer(0,0);
            return 0;   
    }       
}

void send_notification

(

r_notification *

n

)

Creates a NOTIFY message and sends it.

Parameters:

n

- the r_notification to create the NOTIFY after

Definition at line 891 of file registrar_notify.c.

References contact_hdr1, contact_hdr2, IMS_PM_LOG11, M_NAME, STR_APPEND, tmb, and uac_request_cb().

Referenced by notification_timer().

{
    str h={0,0};
    int k=0;

    LOG(L_DBG,"DBG:"M_NAME":send_notification: NOTIFY about <%.*s>\n",n->uri.len,n->uri.s);
    
    //tmb.print_dlg(stdout,n->dialog);
    
    h.len = 0;
    h.len += contact_hdr1.len + n->uri.len + contact_hdr2.len ;
    if (n->subscription_state.len) h.len += subss_hdr1.len + subss_hdr2.len + n->subscription_state.len;
    h.len+=event_hdr.len;
    h.len+=maxfwds_hdr.len;
    if (n->content_type.len) h.len += ctype_hdr1.len + ctype_hdr2.len + n->content_type.len;
    h.s = pkg_malloc(h.len);
    if (!h.s){
        LOG(L_ERR,"ERR:"M_NAME":send_notification: Error allocating %d bytes\n",h.len);
        h.len = 0;
    }

    h.len = 0;
    STR_APPEND(h,contact_hdr1);
    STR_APPEND(h,n->uri);
    STR_APPEND(h,contact_hdr2);

    STR_APPEND(h,event_hdr);
    STR_APPEND(h,maxfwds_hdr);
    if (n->subscription_state.len) {
        STR_APPEND(h,subss_hdr1);
        STR_APPEND(h,n->subscription_state);
        STR_APPEND(h,subss_hdr2);
    }
    if (n->content_type.len) {
        STR_APPEND(h,ctype_hdr1);
        STR_APPEND(h,n->content_type);
        STR_APPEND(h,ctype_hdr2);
    }
    
    //LOG(L_CRIT,"DLG:%p\n",n->dialog);
    #ifdef WITH_IMS_PM
        k = n->is_scscf_dereg;
    #endif 
    if (n->content.len) 
        tmb.t_request_within(&method, &h, &(n->content), n->dialog, uac_request_cb, (void*)k);      
    else 
        tmb.t_request_within(&method, &h, 0, n->dialog, uac_request_cb, (void*)k);      
    if (h.s) pkg_free(h.s);
    
    #ifdef WITH_IMS_PM
        if (n->is_scscf_dereg) IMS_PM_LOG11(UR_AttDeRegCscf,n->dialog->id.call_id,n->dialog->loc_seq.value);
    #endif 
}

void notification_timer	(	unsigned int	ticks,
		void *	param
	)

The Notification timer looks for unsent notifications and sends them.

• because not all events should wait until the notifications for them are sent

  Parameters:

  	ticks	- the current time
  	param	- pointer to the domain_list

Definition at line 954 of file registrar_notify.c.

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

Referenced by mod_init(), and S_event_reg().

{
    r_notification *n;
    lock_get(notification_list->lock);
    while(notification_list->head){
        n = notification_list->head;
        notification_list->head = n->next;
        if (n->next) n->next->prev=0;
        else notification_list->tail=n->next;
        lock_release(notification_list->lock);          
        
        send_notification(n);
        free_r_notification(n);
        lock_get(notification_list->lock);
    }   
    lock_release(notification_list->lock);              
}

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.

Parameters:

	req_uri	- the Request-URI for the NOTIFY
	uri	- uri to send to
	subscription_state	- the Subscription-State header value
	event	- the event
	content_type	- content type
	content	- content
	dialog	- dialog to send on

Returns:

the r_notification or NULL on error

Definition at line 985 of file registrar_notify.c.

References free_r_notification(), M_NAME, MAX_REGINFO_SIZE, and STR_SHM_DUP.

Referenced by r_create_notifications().

{
    r_notification *n=0;
    str buf;    
    char bufc[MAX_REGINFO_SIZE];
    
    n = shm_malloc(sizeof(r_notification));
    if (!n){
        LOG(L_ERR,"ERR:"M_NAME":new_r_notification: Error allocating %d bytes\n",
            sizeof(r_notification));
        goto error;
    }
    memset(n,0,sizeof(r_notification));
    
    STR_SHM_DUP(n->req_uri,req_uri,"new_r_notification");
    
    STR_SHM_DUP(n->uri,uri,"new_r_notification");
    
    STR_SHM_DUP(n->subscription_state,subscription_state,"new_r_notification");
    
    STR_SHM_DUP(n->event,event,"new_r_notification");
    
    STR_SHM_DUP(n->content_type,content_type,"new_r_notification");
    
    sprintf(bufc,content.s,version);
    buf.s = bufc;
    buf.len = strlen(bufc);
    STR_SHM_DUP(n->content,buf,"new_r_notification");
    
    n->dialog = dialog;
    
    return n;
error:
out_of_memory:
    free_r_notification(n);
    return 0;
}

void add_r_notification

(

r_notification *

n

)

Adds a notification to the list of notifications at the end (FIFO).

Parameters:

n

- the notification to be added

Definition at line 1028 of file registrar_notify.c.

References r_notification_list::head, r_notification_list::lock, notification_list, and r_notification_list::tail.

Referenced by r_create_notifications().

{
    if (!n) return;
    lock_get(notification_list->lock);
    n->next = 0;
    n->prev = notification_list->tail;
    if (notification_list->tail) notification_list->tail->next = n;
    notification_list->tail = n;
    if (!notification_list->head) notification_list->head = n;      
    lock_release(notification_list->lock);
}

void free_r_notification

(

r_notification *

n

)

Frees up space taken by a notification.

Parameters:

n

- the notification to be freed

Definition at line 1044 of file registrar_notify.c.

Referenced by new_r_notification(), notification_timer(), and r_notify_destroy().

{
    if (n){
        if (n->req_uri.s) shm_free(n->req_uri.s);
        if (n->uri.s) shm_free(n->uri.s);
        if (n->subscription_state.s) shm_free(n->subscription_state.s);
        if (n->event.s) shm_free(n->event.s);
        if (n->content_type.s) shm_free(n->content_type.s);
        if (n->content.s) shm_free(n->content.s);
        shm_free(n);
    }
}

---

Variable Documentation

enum { ... } IMS_Registrar_events

Event types for "reg" to generated notifications after.

---