registrar_subscribe.c File Reference

---

Detailed Description

Proxy-CSCF - Registrar Refreshment Through SUBSCRIBE to reg event at the S-CSCF.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_subscribe.c.

#include "registrar_subscribe.h"
#include <libxml/xmlschemas.h>
#include <libxml/parser.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 "../dialog/dlg_mod.h"
#include "sip.h"
#include "ims_pm.h"

Go to the source code of this file.

Defines
#define	h_inc   h+=v^(v>>3)
Functions
unsigned int	get_subscription_hash (str uri)
	Computes the hash for a contact.
void	subs_lock (unsigned int hash)
	Lock a subscription hash slot.
void	subs_unlock (unsigned int hash)
	UnLock a subscriptions hash slot.
int	r_subscription_init ()
	Initialize the subscription list.
void	r_subscription_destroy ()
	Destroys the subscription list.
int	P_subscribe (struct sip_msg *rpl, char *str1, char *str2)
	Subscribe to the reg event to the S-CSCF.
int	r_subscribe (str uri, int duration)
	Creates a subcription and starts the timer resubscription for the given contact.
int	r_send_subscribe (r_subscription *s, int duration)
	Send a subscription.
void	r_subscribe_response (struct cell *t, int type, struct tmcb_params *ps)
	Response callback for subscribe.
void	subscription_timer (unsigned int ticks, void *param)
	The Subscription timer looks for almost expired subscriptions and subscribes again.
r_subscription *	new_r_subscription (str req_uri, int duration)
	Creates a subscription based on the given parameters.
void	add_r_subscription (r_subscription *s)
	Adds a subscription to the list of subscriptions at the end (FIFO).
int	update_r_subscription (r_subscription *s, int expires)
	Updates the expiration time of a subscription.
r_subscription *	get_r_subscription (str aor)
	Returns a subscription if it exists.
int	is_r_subscription (str aor)
	Finds out if a subscription exists.
void	del_r_subscription (r_subscription *s)
	Deletes a subscription from the list of subscriptions.
void	del_r_subscription_nolock (r_subscription *s)
	Deletes a subscription from the list of subscriptions.
void	free_r_subscription (r_subscription *s)
	Frees up space taken by a subscription.
void	print_subs (int log_level)
int	parser_init (char *dtd_filename)
	Initializes the libxml parser.
void	parser_destroy ()
	Destroys the parser.
static void	space_trim_dup (str *dest, char *src)
	Trims spaces and duplicate content into pkg.
r_notification *	r_notification_parse (str xml)
	Parses a notification and creates the r_notification object.
int	r_notification_process (r_notification *n, int expires)
	Processes a notification and updates the registrar info.
void	r_notification_print (r_notification *n)
	Prints the content of a notification.
void	r_notification_free (r_notification *n)
	Frees up the space taken by a notification.
Variables
tm_binds	tmb
	Structure with pointers to tm funcs.
dlg_func_t	dialogb
	Structure with pointers to dialog funcs.
str	pcscf_name_str
	fixed SIP URI of this P-CSCF
str	pcscf_path_str
	fixed Path URI
time_t	time_now
	current time
r_hash_slot *	registrar
	the actual registrar
int	r_hash_size
	number of hash slots in the registrar
int	pcscf_subscribe_retries
	times to retry subscribe to reg on failure
r_subscription_hash_slot *	subscriptions = 0
	The P-CSCF subscriptions.
int	subscriptions_hash_size
	the size of the hash table for subscriptions
static str	method = {"SUBSCRIBE",9}
static str	event_hdr = {"Event: reg\r\n",12}
static str	accept_hdr = {"Accept: application/reginfo+xml\r\n",33}
static str	content_len_hdr = {"Content-Length: 0\r\n",19}
static str	max_fwds_hdr = {"Max-Forwards: 10\r\n",18}
static str	expires_s = {"Expires: ",9}
static str	expires_e = {"\r\n",2}
static str	contact_s = {"Contact: <",10}
static str	contact_e = {">\r\n",3}
static str	p_asserted_identity_s = {"P-Asserted-Identity: <",22}
static str	p_asserted_identity_e = {">\r\n",3}
char *	pcscf_reginfo_dtd
	DTD to check the reginfo/xml in the NOTIFY to reg.
static xmlDtdPtr	dtd = 0
	DTD file.
static xmlValidCtxt	cvp
	XML Validating context.

---

Define Documentation

#define h_inc   h+=v^(v>>3)

---

Function Documentation

unsigned int get_subscription_hash

(

str

uri

)

[inline]

Computes the hash for a contact.

Parameters:

	aor	- the string of the contact
	port	- the port of the contact
	transport	- transport for the contact - ignored for now
	hash_size	- size of the hash, to % with

Returns:

the hash for the contact

Definition at line 98 of file registrar_subscribe.c.

References h_inc, and subscriptions_hash_size.

Referenced by add_r_subscription(), bin_decode_r_subscription(), get_r_subscription(), and is_r_subscription().

{
#define h_inc h+=v^(v>>3)
   char* p;
   register unsigned v;
   register unsigned h;
   h=0;
   for (p=uri.s; p<=(uri.s+uri.len-4); p+=4){
       v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
       h_inc;
   }
   v=0;
   for (;p<(uri.s+uri.len); p++) {
       v<<=8;
       v+=*p;
   }
   h_inc;
   h=((h)+(h>>11))+((h>>13)+(h>>23));
   return (h)%subscriptions_hash_size;
#undef h_inc 
}

void subs_lock

(

unsigned int

hash

)

[inline]

Lock a subscription hash slot.

Parameters:

hash

- index to lock

Definition at line 124 of file registrar_subscribe.c.

References subscriptions.

Referenced by add_r_subscription(), bin_cache_dump_subs_to_table(), bin_cache_load_subscriptions_from_table(), del_r_subscription(), get_r_subscription(), is_r_subscription(), load_snapshot_subscriptions(), make_snapshot_subscriptions(), print_subs(), r_subscription_destroy(), and subscription_timer().

{
//  LOG(L_CRIT,"GET %d\n",hash);
    lock_get(subscriptions[hash].lock);
//  LOG(L_CRIT,"GOT %d\n",hash);
}

void subs_unlock

(

unsigned int

hash

)

[inline]

UnLock a subscriptions hash slot.

Parameters:

hash

- index to unlock

Definition at line 134 of file registrar_subscribe.c.

References subscriptions.

Referenced by add_r_subscription(), bin_cache_dump_subs_to_table(), bin_cache_load_subscriptions_from_table(), del_r_subscription(), get_r_subscription(), is_r_subscription(), load_snapshot_subscriptions(), make_snapshot_subscriptions(), print_subs(), r_notification_process(), r_subscribe(), r_subscribe_response(), subscription_timer(), and update_r_subscription().

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

int r_subscription_init

(

)

Initialize the subscription list.

Returns:

1 if ok, 0 on error

Definition at line 143 of file registrar_subscribe.c.

References r_subscription_hash_slot::lock, subscriptions, and subscriptions_hash_size.

Referenced by mod_init().

{
    int i;
    subscriptions = shm_malloc(sizeof(r_subscription_hash_slot)*subscriptions_hash_size);
    if (!subscriptions) return 0;
    memset(subscriptions,0,sizeof(r_subscription_hash_slot)*subscriptions_hash_size);
    for(i=0;i<subscriptions_hash_size;i++){
        subscriptions[i].lock = lock_alloc();
        if (!subscriptions[i].lock) return 0;
        subscriptions[i].lock = lock_init(subscriptions[i].lock);
    }
    return 1;
}

void r_subscription_destroy

(

)

Destroys the subscription list.

Definition at line 160 of file registrar_subscribe.c.

References free_r_subscription(), r_subscription_hash_slot::head, _r_subscription::next, subs_lock(), subscriptions, and subscriptions_hash_size.

Referenced by mod_destroy().

{
    int i;
    r_subscription *s,*ns;
    for(i=0;i<subscriptions_hash_size;i++){
        subs_lock(i);
        s = subscriptions[i].head;
        while(s){
            ns = s->next;
            //TODO send out unSUBSCRIBE
            free_r_subscription(s);
            s = ns;
        }
        lock_destroy(subscriptions[i].lock);
        lock_dealloc(subscriptions[i].lock);
    }   
    shm_free(subscriptions);
}

int P_subscribe	(	struct sip_msg *	rpl,
		char *	str1,
		char *	str2
	)

Subscribe to the reg event to the S-CSCF.

Parameters:

	rpl	- 200 OK response to REGISTER containing contacts and Service-Route header
	str1	- not used
	str2	- not used

Returns:

CSCF_RETURN_TRUE if subscribed, CSCF_RETURN_FALSE if not or CSCF_RETURN_ERROR on error

Definition at line 187 of file registrar_subscribe.c.

References cscf_get_expires_hdr(), cscf_get_first_p_associated_uri(), cscf_parse_contacts(), CSCF_RETURN_ERROR, CSCF_RETURN_FALSE, CSCF_RETURN_TRUE, M_NAME, and r_subscribe().

{
    int expires_hdr=0,r,max_expires;
    str public_id={0,0};
    contact_t* c=0;
    contact_body_t* b=0;    
    
    cscf_get_first_p_associated_uri(rpl,&public_id);
    
    expires_hdr = cscf_get_expires_hdr(rpl);
    
    if (parse_headers(rpl, HDR_EOH_F, 0) <0) {
        LOG(L_ERR,"ERR:"M_NAME":P_subscribe: error parsing headers\n");
        return CSCF_RETURN_ERROR;
    }   
    
    b = cscf_parse_contacts(rpl);
    
    if (!b||!b->contacts) {
        LOG(L_DBG,"DBG:"M_NAME":P_subscribe: No contacts found\n");
        return CSCF_RETURN_FALSE;
    }
    
    if (b) c = b->contacts;
    
    max_expires = expires_hdr;
    while(c){
        r = expires_hdr;
        if (str2int(&(c->expires->body), (unsigned int*)&r) < 0) {
            r = 0;
        }
        if (r>max_expires) max_expires = r;
        c = c->next;
    }
    if (max_expires<=0){
        LOG(L_INFO,"DBG:"M_NAME":P_subscribe: skipped because de-register\n");      
        return CSCF_RETURN_FALSE;       
    }
    
    if (public_id.s){
//      if (max_expires==0)
//          r_subscribe(public_id,0);
//      else
        r_subscribe(public_id,max_expires+30);
        return CSCF_RETURN_TRUE;
    }else{
        return CSCF_RETURN_FALSE;
    }
}

int r_subscribe	(	str	uri,
		int	duration
	)

Creates a subcription and starts the timer resubscription for the given contact.

Parameters:

	uri	- the contact to subscribe to (actually to its default public id)
	duration	- SUBCRIBE expires

Returns:

1 on success, 0 on failure

Definition at line 243 of file registrar_subscribe.c.

References add_r_subscription(), _r_subscription::attempts_left, _r_subscription::duration, get_r_subscription(), _r_subscription::hash, M_NAME, new_r_subscription(), pcscf_subscribe_retries, and subs_unlock().

Referenced by P_subscribe().

{
    r_subscription *s;
    /* first we try to update. if not found, add it */
    s = get_r_subscription(uri);    
    if (s){
        s->duration = duration;
        s->attempts_left=pcscf_subscribe_retries;
        subs_unlock(s->hash);
    }else{          
        s = new_r_subscription(uri,duration);
        if (!s){
            LOG(L_ERR,"ERR:"M_NAME":r_subscribe: Error creating new subscription\n");
            return 0;
        }
        add_r_subscription(s);
        s->attempts_left=pcscf_subscribe_retries;
    }
        
    return 1;
}

int r_send_subscribe	(	r_subscription *	s,
		int	duration
	)

Send a subscription.

Parameters:

	s	- the subsription to send for
	duration	- expires time

Returns:

true if OK, false if not, error on failure

Todo:

store the dialog and reSubscribe on the same dialog

Definition at line 284 of file registrar_subscribe.c.

References accept_hdr, contact_e, contact_s, content_len_hdr, _r_subscription::dialog, dialogb, event_hdr, expires_e, expires_s, M_NAME, max_fwds_hdr, method, p_asserted_identity_e, p_asserted_identity_s, pcscf_name_str, pcscf_path_str, r_subscribe_response(), _r_subscription::req_uri, STR_APPEND, and tmb.

Referenced by subscription_timer().

{
    str h={0,0};

    LOG(L_DBG,"DBG:"M_NAME":r_send_subscribe: SUBSCRIBE to <%.*s>\n",
        s->req_uri.len,s->req_uri.s);
    
    h.len = event_hdr.len+accept_hdr.len+content_len_hdr.len+max_fwds_hdr.len;
    h.len += expires_s.len + 12 + expires_e.len;

    h.len += contact_s.len + pcscf_name_str.len + contact_e.len;
    if (pcscf_path_str.len) h.len += p_asserted_identity_s.len + 
        p_asserted_identity_e.len + pcscf_path_str.len;

    h.s = pkg_malloc(h.len);
    if (!h.s){
        LOG(L_ERR,"ERR:"M_NAME":r_send_subscribe: Error allocating %d bytes\n",h.len);
        h.len = 0;
        return 0;
    }

    h.len = 0;
    STR_APPEND(h,event_hdr);
    STR_APPEND(h,accept_hdr);
    STR_APPEND(h,content_len_hdr);
    STR_APPEND(h,max_fwds_hdr);

    STR_APPEND(h,expires_s);
    sprintf(h.s+h.len,"%d",duration);
    h.len += strlen(h.s+h.len);
    STR_APPEND(h,expires_e);

    STR_APPEND(h,contact_s);
    STR_APPEND(h,pcscf_name_str);
    STR_APPEND(h,contact_e);
    
    if (pcscf_path_str.len) {
        STR_APPEND(h,p_asserted_identity_s);
        STR_APPEND(h,pcscf_path_str);
        STR_APPEND(h,p_asserted_identity_e);
    }
    
    if (!s->dialog){
        /* this is the first request in the dialog */
        if (tmb.new_dlg_uac(0,0,1,&pcscf_name_str,&s->req_uri,&s->dialog)<0){
            LOG(L_ERR,"ERR:"M_NAME":r_send_subscribe: Error creating a dialog for SUBSCRIBE\n");
            goto error;
        }
        if (dialogb.request_outside(&method, &h, 0, s->dialog, r_subscribe_response,  0) < 0){
            LOG(L_ERR,"ERR:"M_NAME":r_send_subscribe: Error sending initial request in a SUBSCRIBE dialog\n");
            goto error;
        }       
    }else{
        /* this is a subsequent subscribe */
        if (dialogb.request_inside(&method, &h, 0, s->dialog, r_subscribe_response,  0) < 0){
            LOG(L_ERR,"ERR:"M_NAME":r_send_subscribe: Error sending subsequent request in a SUBSCRIBE dialog\n");
            goto error;
        }               
    }

    if (h.s) pkg_free(h.s);
    return 1;

error:
    if (h.s) pkg_free(h.s);
    return 0;
}

void r_subscribe_response	(	struct cell *	t,
		int	type,
		struct tmcb_params *	ps
	)

Response callback for subscribe.

Definition at line 355 of file registrar_subscribe.c.

References cscf_get_expires_hdr(), cscf_get_to_uri(), _r_subscription::dialog, get_r_subscription(), _r_subscription::hash, M_NAME, subs_unlock(), tmb, and update_r_subscription().

Referenced by r_send_subscribe().

{
    str req_uri;
    int expires;
    r_subscription *s=0;
    LOG(L_DBG,"DBG:"M_NAME":r_subscribe_response: code %d\n",ps->code);
    if (!ps->rpl || ps->rpl==(void*) -1) {
        LOG(L_ERR,"INF:"M_NAME":r_subscribe_response: No reply\n");
        return; 
    }
    if (!cscf_get_to_uri(ps->rpl,&req_uri)){
        LOG(L_ERR,"INF:"M_NAME":r_subscribe_response: Error extracting the original Req-URI from To header\n");
        return;
    }       
    s = get_r_subscription(req_uri);
    if (!s){
        LOG(L_ERR,"INF:"M_NAME":r_subscribe_response: received a SUBSCRIBE response but no subscription for <%.*s>\n",
            req_uri.len,req_uri.s);
        return;
    }
    if (ps->code>=200 && ps->code<300){
        expires = cscf_get_expires_hdr(ps->rpl);
        update_r_subscription(s,expires);
        tmb.dlg_response_uac(s->dialog, ps->rpl, IS_TARGET_REFRESH);
    }else
        if (ps->code==404){
            update_r_subscription(s,0);         
            //tmb.dlg_response_uac(s->dialog, ps->rpl, IS_TARGET_REFRESH);
        }else{
            LOG(L_INFO,"INF:"M_NAME":r_subscribe_response: SUBSCRIRE response code %d ignored\n",ps->code);             
        }   
    if (s) subs_unlock(s->hash);        
}

void subscription_timer	(	unsigned int	ticks,
		void *	param
	)

The Subscription timer looks for almost expired subscriptions and subscribes again.

Parameters:

	ticks	- the current time
	param	- the generic parameter

Definition at line 399 of file registrar_subscribe.c.

References _r_subscription::attempts_left, del_r_subscription_nolock(), _r_subscription::duration, _r_subscription::expires, r_subscription_hash_slot::head, IMS_PM_LOG01, M_NAME, _r_subscription::next, pcscf_subscribe_retries, print_subs(), r_act_time(), r_send_subscribe(), subs_lock(), subs_unlock(), subscriptions, subscriptions_hash_size, and time_now.

Referenced by mod_init().

{
    r_subscription *s,*ns;
    int i;
    #ifdef WITH_IMS_PM
        int subs_cnt=0;
    #endif
    for(i=0;i<subscriptions_hash_size;i++){
        subs_lock(i);
        s = subscriptions[i].head;
        r_act_time();
        while(s){
            ns = s->next;           
            if (s->attempts_left > 0 ){
                /* attempt to send a subscribe */
                if (!r_send_subscribe(s,s->duration)){
                    LOG(L_ERR,"ERR:"M_NAME":subscription_timer: Error on SUBSCRIBE (%d times)... droping\n",
                        pcscf_subscribe_retries);
                    del_r_subscription_nolock(s);
                }else{
                    s->attempts_left--;
                    #ifdef WITH_IMS_PM
                        subs_cnt++;
                    #endif
                }
            }else if (s->attempts_left==0) {
                /* we failed to many times, drop the subscription */
                LOG(L_ERR,"ERR:"M_NAME":subscription_timer: Error on SUBSCRIBE for %d times... aborting\n",pcscf_subscribe_retries);
                del_r_subscription_nolock(s);                                       
            }else{
                /* we are subscribed already */
                /* if expired, drop it */
                if (s->expires<time_now) 
                    del_r_subscription_nolock(s);
                #ifdef WITH_IMS_PM
                    else subs_cnt++;
                #endif
                    
                /* if not expired, check for renewal */
//      Commented as the S-CSCF should adjust the subscription time accordingly             
//              if ((s->duration<1200 && s->expires-time_now<s->duration/2)||
//                  (s->duration>=1200 && s->expires-time_now<600))
//              {
//                  /* if we need a resubscribe, we mark it as such and try to subscribe again */                   
//                  s->attempts_left = pcscf_subscribe_retries;
//                  ns = s;
//              }
            }
            s = ns;
        }   
        subs_unlock(i);
    }
    print_subs(L_INFO);
    #ifdef WITH_IMS_PM
        IMS_PM_LOG01(RD_NbrSubs,subs_cnt);
    #endif  
}

r_subscription* new_r_subscription	(	str	req_uri,
		int	duration
	)

Creates a subscription based on the given parameters.

Parameters:

	req_uri	- the AOR of the user to subcribe to
	from	- the From header
	duration	- expires time in seconds
	asserted_identity	- P-Asserted-Identity-Header to use

Returns:

the r_notification or NULL on error

Definition at line 469 of file registrar_subscribe.c.

References _r_subscription::duration, _r_subscription::expires, M_NAME, _r_subscription::req_uri, and STR_SHM_DUP.

Referenced by r_subscribe().

{
    r_subscription *s=0;
    
    s = shm_malloc(sizeof(r_subscription));
    if (!s){
        LOG(L_ERR,"ERR:"M_NAME":new_r_subscription: Error allocating %d bytes\n",
            sizeof(r_subscription));
        goto error;
    }
    memset(s,0,sizeof(r_subscription));
    
    STR_SHM_DUP(s->req_uri,req_uri,"new_r_subscription");
    if (!s->req_uri.s) goto error;
        
    s->duration = duration;
    s->expires = 0;
    
    return s;
error:
out_of_memory:
    if (s->req_uri.s) shm_free(s->req_uri.s);
    if (s) shm_free(s); 
    return 0;
}

void add_r_subscription

(

r_subscription *

s

)

Adds a subscription to the list of subscriptions at the end (FIFO).

Parameters:

s

- the subscription to be added

Definition at line 499 of file registrar_subscribe.c.

References get_subscription_hash(), _r_subscription::hash, r_subscription_hash_slot::head, _r_subscription::next, _r_subscription::prev, _r_subscription::req_uri, subs_lock(), subs_unlock(), subscriptions, and r_subscription_hash_slot::tail.

Referenced by r_subscribe().

{
    if (!s) return;
    s->hash = get_subscription_hash(s->req_uri);
    subs_lock(s->hash);
        s->next = 0;
        s->prev = subscriptions[s->hash].tail;
        if (subscriptions[s->hash].tail) subscriptions[s->hash].tail->next = s;         
        subscriptions[s->hash].tail = s;
        if (!subscriptions[s->hash].head) subscriptions[s->hash].head = s;      
    subs_unlock(s->hash);
}

int update_r_subscription	(	r_subscription *	s,
		int	expires
	)

Updates the expiration time of a subscription.

Todo:

Maybe we should use a hash here to index it as this is called for every notification

Parameters:

	aor	- aor to look for
	expires	- new expiration time

Returns:

1 if found, 0 if not

Definition at line 519 of file registrar_subscribe.c.

References _r_subscription::attempts_left, del_r_subscription_nolock(), _r_subscription::expires, _r_subscription::hash, M_NAME, _r_subscription::req_uri, subs_unlock(), and time_now.

Referenced by r_notification_process(), and r_subscribe_response().

{
    LOG(L_DBG,"DBG:"M_NAME":update_r_subscription: refreshing subscription for <%.*s> [%d]\n",
        s->req_uri.len,s->req_uri.s,expires);
    s->attempts_left = -1;
    if (expires == 0) del_r_subscription_nolock(s);
    else s->expires = expires+time_now;;
    subs_unlock(s->hash);   
    return 1;
}

r_subscription* get_r_subscription

(

str

aor

)

Returns a subscription if it exists.

Note:

- this returns with a lock on the subscriptions[s->hash] if found. Don't forget to unlock when done!!!

Parameters:

aor

- AOR to look for

Returns:

1 if found, 0 if not

Definition at line 536 of file registrar_subscribe.c.

References get_subscription_hash(), r_subscription_hash_slot::head, _r_subscription::next, _r_subscription::req_uri, subs_lock(), subs_unlock(), and subscriptions.

Referenced by r_notification_process(), r_subscribe(), and r_subscribe_response().

{
    r_subscription *s;
    unsigned int hash = get_subscription_hash(aor);
    subs_lock(hash);
        s = subscriptions[hash].head;
        while(s){
            if (s->req_uri.len == aor.len &&
                strncasecmp(s->req_uri.s,aor.s,aor.len)==0)
            {
                return s;
            }
            s = s->next;
        }
    subs_unlock(hash);  
    return 0;
}

int is_r_subscription

(

str

aor

)

Finds out if a subscription exists.

Parameters:

aor

- AOR to look for

Returns:

1 if found, 0 if not

Definition at line 559 of file registrar_subscribe.c.

References get_subscription_hash(), r_subscription_hash_slot::head, _r_subscription::next, _r_subscription::req_uri, subs_lock(), subs_unlock(), and subscriptions.

{
    r_subscription *s;
    unsigned int hash = get_subscription_hash(aor);
    subs_lock(hash);
        s = subscriptions[hash].head;
        while(s){
            if (s->req_uri.len == aor.len &&
                strncasecmp(s->req_uri.s,aor.s,aor.len)==0)
            {
                subs_unlock(hash);  
                return 1;
            }
            s = s->next;
        }
    subs_unlock(hash);  
    return 0;
}

void del_r_subscription

(

r_subscription *

s

)

Deletes a subscription from the list of subscriptions.

Parameters:

s

- the subscription to be deleted

Definition at line 582 of file registrar_subscribe.c.

References free_r_subscription(), _r_subscription::hash, r_subscription_hash_slot::head, _r_subscription::next, _r_subscription::prev, subs_lock(), subs_unlock(), subscriptions, and r_subscription_hash_slot::tail.

{
    if (!s) return;
    subs_lock(s->hash);
        if (subscriptions[s->hash].head == s) subscriptions[s->hash].head = s->next;
        else s->prev->next = s->next;
        if (subscriptions[s->hash].tail == s) subscriptions[s->hash].tail = s->prev;
        else s->next->prev = s->prev;
    subs_unlock(s->hash);
    free_r_subscription(s);
}

void del_r_subscription_nolock

(

r_subscription *

s

)

Deletes a subscription from the list of subscriptions.

Note:

Must have the lock to do this

Parameters:

s

- the subscription to be deleted

Definition at line 599 of file registrar_subscribe.c.

References free_r_subscription(), _r_subscription::hash, r_subscription_hash_slot::head, _r_subscription::next, _r_subscription::prev, subscriptions, and r_subscription_hash_slot::tail.

Referenced by subscription_timer(), and update_r_subscription().

{
    if (!s) return;
    if (subscriptions[s->hash].head == s) subscriptions[s->hash].head = s->next;
    else s->prev->next = s->next;
    if (subscriptions[s->hash].tail == s) subscriptions[s->hash].tail = s->prev;
    else s->next->prev = s->prev;
    free_r_subscription(s);
}

void free_r_subscription

(

r_subscription *

s

)

Frees up space taken by a subscription.

Parameters:

s

- the subscription to free

Definition at line 613 of file registrar_subscribe.c.

References _r_subscription::dialog, _r_subscription::req_uri, and tmb.

Referenced by del_r_subscription(), del_r_subscription_nolock(), and r_subscription_destroy().

{
    if (s){
        if (s->req_uri.s) shm_free(s->req_uri.s);
        if (s->dialog) tmb.free_dlg(s->dialog);
        shm_free(s);
    }
}

void print_subs

(

int

log_level

)

Definition at line 622 of file registrar_subscribe.c.

References ANSI_BLUE, ANSI_CYAN, ANSI_GREEN, ANSI_MAGENTA, _r_subscription::attempts_left, _r_subscription::duration, _r_subscription::expires, _r_subscription::hash, r_subscription_hash_slot::head, M_NAME, _r_subscription::next, r_act_time(), _r_subscription::req_uri, subs_lock(), subs_unlock(), subscriptions, subscriptions_hash_size, and time_now.

Referenced by subscription_timer().

00623 {
00624     r_subscription *s;
00625     int i;
00626     if (debug<log_level) return; /* to avoid useless calls when nothing will be printed */  
00627     LOG(log_level,ANSI_GREEN"INF:"M_NAME":----------  Subscription list begin ---------\n");
00628     for(i=0;i<subscriptions_hash_size;i++){
00629         subs_lock(i);
00630         s = subscriptions[i].head;
00631         r_act_time();
00632         while(s){
00633             LOG(log_level,ANSI_GREEN"INF:"M_NAME":[%4u]\tP: <"ANSI_BLUE"%.*s"ANSI_GREEN"> D:["ANSI_CYAN"%5d"ANSI_GREEN"] E:["ANSI_MAGENTA"%5d"ANSI_GREEN"] Att:[%2d]\n",
00634                 s->hash,s->req_uri.len,s->req_uri.s,s->duration,(int)(s->expires-time_now),s->attempts_left);
00635             s = s->next;            
</