registrar_storage.c File Reference

---

Detailed Description

Proxy-CSCF - Registrar Storage.

This is reversed registrar in the sense that contacts are pointing to public identities and not he other way around. This is required as the P-CSCF retrieves the identities based on the contacts. This being the operation most employed, it doesn't make sense to keep the registrar in the normal order.

The Registrar is kept as a hash table. If you have a large number of users, increase its size for better search times.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_storage.c.

#include <time.h>
#include "mod.h"
#include "registrar_storage.h"
#include "nat_helper.h"
#include "security.h"
#include "dlg_state.h"

Go to the source code of this file.

Defines
#define	h_inc   h+=v^(v>>3)
Functions
void	r_act_time ()
	Update the time.
int	r_valid_contact (r_contact *c)
	Returns if a contact is valid.
int	r_reg_contact (r_contact *c)
	Returns if a contact is valid and registered.
unsigned int	get_contact_hash (str aor, int port, int transport, int hash_size)
	Computes the hash for a contact.
int	r_storage_init (int hash_size)
	Initialize the registrar.
void	r_storage_destroy ()
	Destroy the registrar.
void	r_lock (unsigned int hash)
	Lock a registrar hash slot.
void	r_unlock (unsigned int hash)
	UnLock a registrar hash slot.
r_public *	new_r_public (str aor, int is_default)
	Creates a registrar public record.
r_public *	get_r_public (r_contact *c, str aor)
	Searches for a r_public record and returns it.
r_public *	add_r_public (r_contact *c, str aor, int is_default)
	Creates and Adds a new r_public record.
r_public *	update_r_public (r_contact *c, str aor, int *is_default)
	Updates the r_public with the new is_default.
void	del_r_public (r_contact *c, r_public *p)
	Drops and deallocates a r_public.
void	free_r_public (r_public *p)
	Frees memory taken by a r_public aor structure.
r_ipsec *	new_r_ipsec (int spi_uc, int spi_us, int spi_pc, int spi_ps, int port_uc, int port_us, str ealg_setkey, str r_ealg, str ck_esp, str alg_setkey, str r_alg, str ik_esp)
	Creates a registrar ipsec container.
void	free_r_ipsec (r_ipsec *ipsec)
	Frees memory taken by a r_ipsec structure.
r_tls *	new_r_tls (int port_tls, unsigned long session_hash)
	Creates a registrar tls container.
void	free_r_tls (r_tls *tls)
	Frees memory taken by a r_tls structure.
r_security *	new_r_security (str sec_header, r_security_type type, float q)
void	free_r_security (r_security *s)
r_contact *	get_r_contact (str host, int port, int transport)
	Searches for a r_contact contact and returns it.
r_contact *	new_r_contact (str host, int port, int transport, str uri, enum Reg_States reg_state, int expires, str *service_route, int service_route_cnt)
	Creates a registrar contact This does not insert it in the registrar.
r_contact *	add_r_contact (str host, int port, int transport, str uri, enum Reg_States reg_state, int expires, str *service_route, int service_route_cnt, r_nat_dest *pinhole)
	Creates and Adds a new r_contact.
r_contact *	update_r_contact (str host, int port, int transport, str *uri, enum Reg_States *reg_state, int *expires, str **service_route, int *service_route_cnt, r_nat_dest **pinhole)
	Updates the r_contact with the new states If not found, it will be inserted.
r_contact *	update_r_contact_sec (str host, int port, int transport, str *uri, enum Reg_States *reg_state, int *expires, r_security *s)
	Updates the r_contact with the new security values.
r_nat_dest *	get_r_nat_pinhole (str host, int port, int transport)
	Gets the contact structure with the uri the same as the one given.
void	del_r_contact (r_contact *c)
	Drops and deallocates a r_contact.
void	free_r_contact (r_contact *c)
	Frees memory taken by a r_contact structure.
void	print_r (int log_level)
	Debug print the contents of the entire registrar.
Variables
time_t	time_now
	Current time of the S-CSCF registrar.
r_hash_slot *	registrar = 0
	The S-CSCF registrar.
int	r_hash_size = 128
	Size of S-CSCF registrar hash table.

---

Define Documentation

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

---

Function Documentation

void r_act_time

(

)

[inline]

Update the time.

Definition at line 79 of file registrar_storage.c.

Referenced by get_r_public_expires(), P_security_200(), P_verify_security(), print_r(), print_subs(), r_assert_identity(), r_is_registered(), r_is_registered_id(), r_is_unregistered_id(), r_notification_process(), r_private_expire(), r_public_expire(), r_update_subscription_status(), registrar_timer(), S_event_reg(), S_lookup(), S_subscribe(), save_contact_security(), subscription_timer(), and update_contacts().

{
    time_now=time(0);
}

int r_valid_contact

(

r_contact *

c

)

[inline]

Returns if a contact is valid.

Caller should do actualization of time_now

Parameters:

c

- the contact to check

Returns:

1 if valid, else 0

Definition at line 90 of file registrar_storage.c.

Referenced by P_security_200(), P_verify_security(), r_is_registered_id(), r_is_unregistered_id(), r_update_subscription_status(), registrar_timer(), and S_lookup().

{
//  LOG(L_ERR,"%.*s -> %ld\n",c->uri.len,c->uri.s,c->expires-time_now);
    return (c->reg_state!=NOT_REGISTERED && c->reg_state!=DEREGISTERED)&&(c->expires>time_now);
}

int r_reg_contact

(

r_contact *

c

)

[inline]

Returns if a contact is valid and registered.

Caller should do actualization of time_now

Parameters:

c

- the contact to check

Returns:

1 if valid, else 0

Definition at line 102 of file registrar_storage.c.

References _r_contact::expires, _r_contact::reg_state, REGISTERED, and time_now.

Referenced by r_assert_identity(), and r_is_registered().

{
//  LOG(L_ERR,"%.*s -> %ld\n",c->uri.len,c->uri.s,c->expires-time_now);
    return (c->reg_state==REGISTERED)&&(c->expires>time_now);
}

unsigned int get_contact_hash	(	str	aor,
		int	port,
		int	transport,
		int	hash_size
	)			[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 116 of file registrar_storage.c.

References h_inc.

Referenced by bin_decode_r_contact(), get_r_contact(), and new_r_contact().

{
#define h_inc h+=v^(v>>3)
   char* p;
   register unsigned v;
   register unsigned h;

   h=0;
   for (p=aor.s; p<=(aor.s+aor.len-4); p+=4){
       v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
       h_inc;
   }
   v=0;
   for (;p<(aor.s+aor.len); p++) {
       v<<=8;
       v+=*p;
   }
   h_inc;
   v = port;
   h_inc;
//   v = transport;
//   h_inc;/* because xten does not care about transport */

   h=((h)+(h>>11))+((h>>13)+(h>>23));
   return (h)%hash_size;
#undef h_inc 
}

int r_storage_init

(

int

hash_size

)

Initialize the registrar.

Parameters:

hash_size

- number of hash slots to create

Returns:

1 if 0, 0 if not

Definition at line 149 of file registrar_storage.c.

Referenced by mod_init().

{
    int i;
    r_hash_size = hash_size;
    
    registrar = shm_malloc(sizeof(r_hash_slot)*r_hash_size);
    memset(registrar,0,sizeof(r_hash_slot)*r_hash_size);
    
    for(i=0;i<r_hash_size;i++){
        registrar[i].lock = lock_alloc();
        if (!registrar[i].lock){
            LOG(L_ERR,"ERR:"M_NAME":r_storage_init(): Error creating lock\n");
            return 0;
        }
        registrar[i].lock = lock_init(registrar[i].lock);
    }
            
    if (!registrar) return 0;
    
    return 1;
}

void r_storage_destroy

(

)

Destroy the registrar.

Definition at line 174 of file registrar_storage.c.

Referenced by mod_destroy().

{
    int i;
    r_contact *c,*nc;
    for(i=0;i<r_hash_size;i++){
        r_lock(i);
            c = registrar[i].head;
            while(c){
                nc = c->next;
                free_r_contact(c);
                c = nc;
            }
        r_unlock(i);
        lock_dealloc(registrar[i].lock);
    }
    shm_free(registrar);    
}

void r_lock

(

unsigned int

hash

)

[inline]

Lock a registrar hash slot.

Parameters:

hash

- index to lock

Definition at line 196 of file registrar_storage.c.

Referenced by add_r_contact(), add_r_public(), add_r_public_previous_lock(), bin_cache_dump_registrar_to_table(), bin_cache_load_registrar_from_table(), get_matching_wildcard_psi(), get_r_contact(), get_r_public(), get_r_public_previous_lock(), get_r_public_wpsi(), load_snapshot_registrar(), make_snapshot_registrar(), print_r(), r_private_expire(), r_storage_destroy(), and registrar_timer().

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

void r_unlock

(

unsigned int

hash

)

[inline]

UnLock a registrar hash slot.

Parameters:

hash

- index to unlock

Definition at line 206 of file registrar_storage.c.

Referenced by bin_cache_dump_registrar_to_table(), bin_cache_load_registrar_from_table(), Cx_PPA(), get_matching_wildcard_psi(), get_r_contact(), get_r_public(), get_r_public_expires(), get_r_public_previous_lock(), get_r_public_wpsi(), load_snapshot_registrar(), make_snapshot_registrar(), P_enforce_service_routes(), P_follows_service_routes(), P_NAT_relay(), P_security_200(), P_security_401(), P_security_relay(), P_verify_security(), print_r(), r_assert_identity(), r_get_reginfo_full(), r_is_integrity_protected(), r_is_not_registered_id(), r_is_registered(), r_is_registered_id(), r_is_unregistered_id(), r_notification_process(), r_public_expire(), r_storage_destroy(), registrar_timer(), S_add_p_asserted_identity(), S_add_p_charging_function_addresses(), S_assign_server(), S_is_authorized(), S_is_barred(), S_lookup(), S_subscribe(), update_contacts(), update_r_contact_sec(), and update_r_public().

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

r_public* new_r_public	(	str	aor,
		int	is_default
	)

Creates a registrar public record.

This does not insert it in the registrar

Parameters:

	aor	- the public identity as address of record
	is_default	- if this is the default public id

Returns:

- the r_public created, NULL on error

Definition at line 219 of file registrar_storage.c.

Referenced by add_r_public(), and add_r_public_previous_lock().

{
    r_public *p;
    
    p = shm_malloc(sizeof(r_public));
    if (!p){
        LOG(L_ERR,"ERR:"M_NAME":new_r_public(): Unable to alloc %d bytes\n",
            sizeof(r_public));
        goto error;
    }   
    memset(p,0,sizeof(r_public));
        
    p->aor.s = shm_malloc(aor.len);
    if (!p->aor.s){
        LOG(L_ERR,"ERR:"M_NAME":new_r_public(): Unable to alloc %d bytes\n",
            aor.len);
        goto error;
    }
    p->aor.len = aor.len;
    memcpy(p->aor.s,aor.s,aor.len);
    
    p->is_default = is_default;
    
        
    return p;
error:
    if (p){
        if (p->aor.s) shm_free(p->aor.s);   
        shm_free(p);
    }
    return 0;   
}

r_public* get_r_public	(	r_contact *	c,
		str	aor
	)

Searches for a r_public record and returns it.

Note:

Must be called with a lock on the domain to avoid races

Parameters:

	c	- the r_contact to look into
	aor	- the address of record to look for

Returns:

- the r_public found, 0 if not found

Definition at line 259 of file registrar_storage.c.

Referenced by get_r_public_expires(), r_get_reginfo_full(), r_is_not_registered_id(), r_is_registered_id(), r_is_unregistered_id(), r_public_expire(), S_add_p_asserted_identity(), S_add_p_charging_function_addresses(), S_assign_server(), S_can_subscribe(), S_is_authorized(), S_is_barred(), S_lookup(), S_subscribe(), and update_r_public().

{
    r_public *p=0;
    if (!c) return 0;
    p = c->head;
    while(p){
        if (p->aor.len == aor.len &&
            strncasecmp(p->aor.s,aor.s,aor.len)==0) return p;
        p = p->next;
    }
    return 0;
}

r_public* add_r_public	(	r_contact *	c,
		str	aor,
		int	is_default
	)

Creates and Adds a new r_public record.

Note:

Must be called with a lock on the domain to avoid races

When calling be sure that get_r_public(d,aor) returns 0, to avoid unreachable duplicates

Parameters:

	c	- the r_contact to add to
	aor	- the address of record
	is_default	- if this is the default contact

Returns:

the newly added r_public, 0 on error

Definition at line 283 of file registrar_storage.c.

Referenced by S_subscribe(), and update_r_public().

{
    r_public *p;
    if (!c) return 0;
    p = new_r_public(aor,is_default);
    if (!p) return 0;
    p->next=0;
    p->prev=c->tail;
    if (c->tail) c->tail->next = p;
    c->tail = p;
    if (!c->head) c->head=p;
    
    return p;
}

r_public* update_r_public	(	r_contact *	c,
		str	aor,
		int *	is_default
	)

Updates the r_public with the new is_default.

If not found, it will be inserted

Note:

Must be called with a lock on the domain to avoid races

Parameters:

	c	- the r_contact to add to
	aor	- the address of record
	is_default	- if this is the default contact

Returns:

the newly added r_public, 0 on error

Definition at line 307 of file registrar_storage.c.

Referenced by Cx_PPA(), and update_contacts().

{
    r_public *p;

    if (!c) return 0;
    p = get_r_public(c,aor);
    if (!p){
        if (is_default)
            return add_r_public(c,aor,*is_default);
        else return 0;
    }else{
        if (is_default) p->is_default = *is_default;
        return p;
    }
}

void del_r_public	(	r_contact *	c,
		r_public *	p
	)

Drops and deallocates a r_public.

Note:

Must be called with a lock on the domain to avoid races

When calling be sure that get_r_public(d,aor) returns p, to avoid a bogus removal

Parameters:

	c	- the r_contact that this r_public is attached currently to
	p	- the r_public to remove

Definition at line 332 of file registrar_storage.c.

Referenced by registrar_timer(), and update_r_contact().

{
    if (c->head == p) c->head = p->next;
    else p->prev->next = p->next;
    if (c->tail == p) c->tail = p->prev;
    else p->next->prev = p->prev;
    free_r_public(p);
}

void free_r_public

(

r_public *

p

)

Frees memory taken by a r_public aor structure.

Note:

Must be called with a lock on the domain to avoid races

Parameters:

p

- the r_public to be deallocated

Definition at line 346 of file registrar_storage.c.

Referenced by bin_decode_r_contact(), del_r_public(), free_r_contact(), r_storage_destroy(), and update_r_public().

{
    if (!p) return;
    if (p->aor.s) shm_free(p->aor.s);
    shm_free(p);
}

r_ipsec* new_r_ipsec	(	int	spi_uc,
		int	spi_us,
		int	spi_pc,
		int	spi_ps,
		int	port_uc,
		int	port_us,
		str	ealg_setkey,
		str	r_ealg,
		str	ck_esp,
		str	alg_setkey,
		str	r_alg,
		str	ik_esp
	)

Creates a registrar ipsec container.

This does not insert it in the registrar the strings are duplicated in shm

Parameters:

	spi_uc	- SPI for UserEndpoint Client
	spi_us	- SPI for UserEndpoint Server
	spi_pc	- SPI for P-CSCF Client
	spi_ps	- SPI for UserEndpoint Server
	port_uc	- port for UserEndpoint Client
	port_us	- port for UserEndpoint Server
	ealg_setkey	- Cypher Algorithm
	r_ealg	- received Cypher Algorithm
	ck_esp	- Cypher Key
	r_alg	- received Integrity Algorithm
	ik_esp	- Integrity Key

Returns:

the new r_ipsec* container or NULL on error

Definition at line 370 of file registrar_storage.c.

References _r_ipsec::alg, _r_ipsec::ck, _r_ipsec::ealg, free_r_ipsec(), _r_ipsec::ik, M_NAME, _r_ipsec::port_uc, _r_ipsec::port_us, _r_ipsec::r_alg, _r_ipsec::r_ealg, _r_ipsec::spi_pc, _r_ipsec::spi_ps, _r_ipsec::spi_uc, _r_ipsec::spi_us, and STR_SHM_DUP.

Referenced by save_contact_security().

{
    r_ipsec *ipsec;
    
    ipsec = shm_malloc(sizeof(r_ipsec));
    if (!ipsec) {
        LOG(L_ERR,"ERR:"M_NAME":new_r_ipsec(): Unable to alloc %d bytes\n",
            sizeof(r_ipsec));
        return 0;
    }
    memset(ipsec,0,sizeof(r_ipsec));
    
    ipsec->spi_uc = spi_uc;
    ipsec->spi_us = spi_us;
    ipsec->spi_pc = spi_pc;
    ipsec->spi_ps = spi_ps;
    ipsec->port_uc = port_uc;
    ipsec->port_us = port_us;
    
    
    STR_SHM_DUP(ipsec->ealg,ealg_setkey,"new_r_ipsec");
    STR_SHM_DUP(ipsec->r_ealg,r_ealg,"new_r_ipsec");
    STR_SHM_DUP(ipsec->alg,alg_setkey,"new_r_ipsec");
    STR_SHM_DUP(ipsec->r_alg,r_alg,"new_r_ipsec");
    STR_SHM_DUP(ipsec->ck,ck_esp,"new_r_ipsec");
    STR_SHM_DUP(ipsec->ik,ik_esp,"new_r_ipsec");
            
    return ipsec;
out_of_memory:
    if (ipsec) free_r_ipsec(ipsec);
    return 0;   
}

void free_r_ipsec

(

r_ipsec *

ipsec

)

Frees memory taken by a r_ipsec structure.

Note:

Must be called with a lock on the domain to avoid races

Parameters:

ipsec

- the r_public to be deallocated

Definition at line 409 of file registrar_storage.c.

References _r_ipsec::alg, _r_ipsec::ck, _r_ipsec::ealg, _r_ipsec::ik, _r_ipsec::r_alg, and _r_ipsec::r_ealg.

Referenced by bin_decode_r_security(), free_r_security(), and new_r_ipsec().

{
    if (!ipsec) return;
    if (ipsec->ealg.s) shm_free(ipsec->ealg.s);
    if (ipsec->r_ealg.s) shm_free(ipsec->r_ealg.s);
    if (ipsec->alg.s) shm_free(ipsec->alg.s);
    if (ipsec->r_alg.s) shm_free(ipsec->r_alg.s);
    if (ipsec->ck.s) shm_free(ipsec->ck.s); 
    if (ipsec->ik.s) shm_free(ipsec->ik.s); 
    shm_free(ipsec);
}

r_tls* new_r_tls	(	int	port_tls,
		unsigned long	session_hash
	)

Creates a registrar tls container.

This does not insert it in the registrar the strings are duplicated in shm

Parameters:

	port_tls	- port for UserEndpoint Client
	session_hash	- TLS Session hash

Returns:

the new r_tls* container or NULL on error

Definition at line 429 of file registrar_storage.c.

References M_NAME, _r_tls::port_tls, and _r_tls::session_hash.

Referenced by P_security_200().

{
    r_tls *tls;
    
    tls = shm_malloc(sizeof(r_tls));
    if (!tls) {
        LOG(L_ERR,"ERR:"M_NAME":new_r_tls(): Unable to alloc %d bytes\n",
            sizeof(r_tls));
        return 0;
    }
    memset(tls,0,sizeof(r_tls));
    
    tls->port_tls = port_tls;
    tls->session_hash = session_hash;       
    return tls;
}

void free_r_tls

(

r_tls *

tls

)

Frees memory taken by a r_tls structure.

Note:

Must be called with a lock on the domain to avoid races

Parameters:

tls

- the r_public to be deallocated

Definition at line 451 of file registrar_storage.c.

Referenced by bin_decode_r_security(), and free_r_security().

{
    if (!tls) return;
    shm_free(tls);
}

r_security* new_r_security	(	str	sec_header,
		r_security_type	type,
		float	q
	)

Definition at line 457 of file registrar_storage.c.

References M_NAME, _r_security::q, _r_security::sec_header, STR_SHM_DUP, and _r_security::type.

Referenced by save_contact_security().

{
    r_security *s=0;

    s = shm_malloc(sizeof(r_security));
    if (!s){
        LOG(L_ERR,"ERR:"M_NAME":save_contact_security: Error allocating %d bytes.\n",sizeof(r_security));
        goto error ;
    }
    memset(s,0,sizeof(r_security));
    
    s->type = type;
    s->q = q;
    STR_SHM_DUP(s->sec_header,sec_header,"save_contact_security");
    if (!s->sec_header.s) goto error;   
    return s;
error:
out_of_memory:
    if (s) shm_free(s);
    return 0;
}

void free_r_security

(

r_security *

s

)

Definition at line 480 of file registrar_storage.c.

References _r_security::data, free_r_ipsec(), free_r_tls(), _r_security::ipsec, _r_security::sec_header, SEC_IPSEC, SEC_NONE, SEC_TLS, _r_security::tls, and _r_security::type.

Referenced by bin_decode_r_contact(), free_r_contact(), P_security_200(), save_contact_security(), and update_r_contact_sec().

{
    if (!s) return;
    switch (s->type){
        case SEC_NONE:
            break;
        case SEC_TLS:
            if (s->data.tls) free_r_tls(s->data.tls);
            break;
        case SEC_IPSEC:
            if (s->data.ipsec) free_r_ipsec(s->data.ipsec);
            break;      
    }
    if (s->sec_header.s) shm_free(s->sec_header.s);
    shm_free(s);
}

r_contact* get_r_contact	(	str	host,
		int	port,
		int	transport
	)

Searches for a r_contact contact and returns it.

Note:

Will lock the hash_slot if found! So release it when you are done!

Parameters:

	host	- the IP in string format
	port	- the port number
	transport	- the transport type

Returns:

- the r_contact found, 0 if not found

Definition at line 505 of file registrar_storage.c.

Referenced by get_r_nat_pinhole(), P_enforce_service_routes(), P_follows_service_routes(), P_NAT_relay(), P_security_200(), P_security_relay(), P_verify_security(), r_assert_identity(), r_is_integrity_protected(), r_is_registered(), S_assign_server(), update_r_contact(), and update_r_contact_sec().

{
    r_contact *c=0;
    unsigned int hash;
    if (!registrar) return 0;
    hash = get_contact_hash(host,port,transport,r_hash_size);
    r_lock(hash);
    c = registrar[hash].head;
    while(c){
        if (c->port == port &&
//          c->transport == transport && /* because xten doesn't care about protocols */ 
            c->host.len == host.len &&
            strncasecmp(c->host.s,host.s,host.len)==0) return c;
        c = c->next;
    }
    r_unlock(hash);
    return 0;
}

r_contact* new_r_contact	(	str	host,
		int	port,
		int	transport,
		str	uri,
		enum Reg_States	reg_state,
		int	expires,
		str *	service_route,
		int	service_route_cnt
	)

Creates a registrar contact This does not insert it in the registrar.

Parameters:

	host	- the host part of the contact, in string
	port	- the port number of the contact
	transport	- the transport of the contact
	uri	- URI of the contact
	reg_state	- Registration state
	expires	- expires in
	service_route	- array of service routes
	service_route_cnt	- the size of the array above

Returns:

the new r_contact* or NULL on error

Definition at line 537 of file registrar_storage.c.

Referenced by add_r_contact().

{
    r_contact *c;
    int i;
    
    c = shm_malloc(sizeof(r_contact));
    if (!c) {
        LOG(L_ERR,"ERR:"M_NAME":new_r_contact(): Unable to alloc %d bytes\n",
            sizeof(r_contact));
        goto error;
    }
    memset(c,0,sizeof(r_contact));
    
    STR_SHM_DUP(c->host,host,"new_r_contact");
    c->port = port;
    c->transport = transport;
    c->hash = get_contact_hash(host,port,transport,r_hash_size);
    STR_SHM_DUP(c->uri,uri,"new_r_contact");        
    c->reg_state = reg_state;
    c->expires = expires;   
        
    if (service_route_cnt && service_route){
        c->service_route = shm_malloc(service_route_cnt*sizeof(str));
        if (!c->service_route){
            LOG(L_ERR,"ERR:"M_NAME":new_r_contact(): Unable to alloc %d bytes\n",
                service_route_cnt*sizeof(str));
            goto error;
        }
        for(i=0;i<service_route_cnt;i++)
            STR_SHM_DUP(c->service_route[i],service_route[i],"new_r_contact");
        c->service_route_cnt = service_route_cnt;
    }
        
    return c;
error:
out_of_memory:
    if (c){
        free_r_contact(c);          
    }
    return 0;
}

r_contact* add_r_contact	(	str	host,
		int	port,
		int	transport,
		str	uri,
		enum Reg_States	reg_state,
		int	expires,
		str *	service_route,
		int	service_route_cnt,
		r_nat_dest *	pinhole
	)

Creates and Adds a new r_contact.

Note:

Aquires the lock on the hash_slot on success, so release it when you are done.

When calling be sure that get_r_contact(...) returns 0, to avoid unreachable duplicates

Parameters:

	host	- the host part of the contact, in string
	port	- the port number of the contact
	transport	- the transport of the contact
	uri	- URI of the contact
	reg_state	- Registration state
	expires	- expires in
	service_route	- array of service routes
	service_route_cnt	- the size of the array above
	pinhole	- NAT pin hole

Returns:

the newly added r_contact, 0 on error

Definition at line 595 of file registrar_storage.c.

Referenced by update_r_contact(), and update_r_contact_sec().

{
    r_contact *c;

    if (!registrar) return 0;
    c = new_r_contact(host,port,transport,uri,reg_state, expires, service_route, service_route_cnt);
    if (!c) return 0;
    c->next=0;
    r_lock(c->hash);
        c->prev=registrar[c->hash].tail;
        if (c->prev) c->prev->next = c;
        registrar[c->hash].tail = c;
        if (!registrar[c->hash].head) registrar[c->hash].head=c;
        c->pinhole = pinhole;
    return c;
}

r_contact* update_r_contact	(	str	host,
		int	port,
		int	transport,
		str *	uri,
		enum Reg_States *	reg_state,
		int *	expires,
		str **	service_route,
		int *	service_route_cnt,
		r_nat_dest **	pinhole
	)

Updates the r_contact with the new states If not found, it will be inserted.

Note:

Aquires the lock on the hash_slot on success, so release it when you are done.

Parameters:

	host	- the host part of the contact, in string
	port	- the port number of the contact
	transport	- the transport of the contact
	uri	- URI of the contact
	reg_state	- Registration state
	expires	- expires in
	service_route	- array of service routes
	service_route_cnt	- the size of the array above
	pinhole	- NAT pin hole

Returns:

the updated added r_contact, 0 on error

Definition at line 628 of file registrar_storage.c.

Referenced by