registrar_storage.h File Reference

---

Detailed Description

Proxy-CSCF - Registrar Storage.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_storage.h.

#include "../../sr_module.h"
#include "../../locking.h"

Go to the source code of this file.

Data Structures
struct	_r_nat_dest
	NAT address. More...
struct	_r_public
	Registrar Public Identity Structure. More...
struct	_r_ipsec
	IPSec SA Information. More...
struct	_r_tls
	TLS SA Information. More...
struct	_r_security
struct	_r_contact
	Registrar Contact Structure. More...
struct	r_hash_slot
	Registrar Slot Structure. More...
Typedefs
typedef _r_nat_dest	r_nat_dest
	NAT address.
typedef _r_public	r_public
	Registrar Public Identity Structure.
typedef _r_ipsec	r_ipsec
	IPSec SA Information.
typedef _r_tls	r_tls
	TLS SA Information.
typedef enum _r_sec_type	r_security_type
typedef _r_security	r_security
typedef _r_contact	r_contact
	Registrar Contact Structure.
Enumerations
enum	Reg_States {   NOT_REGISTERED = 0, REGISTERED = 1, REG_PENDING = -1, DEREGISTERED = -2,   NOT_REGISTERED = 0, REGISTERED = 1, UNREGISTERED = -1 }
	User Registration States. More...
enum	_r_sec_type { SEC_NONE = 0, SEC_IPSEC = 1, SEC_TLS = 2 }
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.
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.
unsigned int	get_contact_hash (str aor, int port, int transport, int hash_size)
	Computes the hash for a contact.
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 *	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 *	get_r_contact (str host, int port, int transport)
	Searches for a r_contact contact and returns it.
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.
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.
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	print_r (int log_level)
	Debug print the contents of the entire registrar.

---

Typedef Documentation

typedef struct _r_nat_dest r_nat_dest

NAT address.

typedef struct _r_public r_public

Registrar Public Identity Structure.

typedef struct _r_ipsec r_ipsec

IPSec SA Information.

typedef struct _r_tls r_tls

TLS SA Information.

typedef enum _r_sec_type r_security_type

typedef struct _r_security r_security

typedef struct _r_contact r_contact

Registrar Contact Structure.

---

Enumeration Type Documentation

enum Reg_States

User Registration States.

Enumerator:

NOT_REGISTERED	User not-registered.
REGISTERED	User registered.
REG_PENDING	Registration pending.
DEREGISTERED	DeRegistered-IPSec on - used to relay last messages to freshly de-registered user.
NOT_REGISTERED	User not-registered, no profile stored.
REGISTERED	User registered.
UNREGISTERED	User not-registered, profile stored.

Definition at line 77 of file registrar_storage.h.

                {
    NOT_REGISTERED=0,           
    REGISTERED=1,               
    REG_PENDING=-1,             
    DEREGISTERED=-2             
} ;

enum _r_sec_type

Enumerator:

SEC_NONE
SEC_IPSEC
SEC_TLS

Definition at line 107 of file registrar_storage.h.

                         {
    SEC_NONE    =0,
    SEC_IPSEC   =1,
    SEC_TLS     =2,
} r_security_type;

---

Function Documentation

void r_act_time

(

)

[inline]

Update the time.

Definition at line 79 of file registrar_storage.c.

{
    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.

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

int r_storage_init

(

int

hash_size

)

Initialize the registrar.

Parameters:

hash_size

- number of hash slots to create

Returns:

1 on success, 0 on error

Definition at line 149 of file registrar_storage.c.

{
    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.

{
    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

- the index of the slot

Definition at line 196 of file registrar_storage.c.

{
//  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

- the index of the slot

Definition at line 206 of file registrar_storage.c.

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

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 
}

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.

References _r_public::aor, _r_public::is_default, and M_NAME.

{
    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.

References _r_public::aor, _r_contact::head, and _r_public::next.

{
    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.

References _r_contact::head, new_r_public(), _r_public::next, _r_public::prev, and _r_contact::tail.

{
    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.

References add_r_public(), get_r_public(), and _r_public::is_default.

{
    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.

References free_r_public(), _r_contact::head, _r_public::next, _r_public::prev, and _r_contact::tail.

{
    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.

Parameters:

p

- the r_public to be deallocated

Definition at line 346 of file registrar_storage.c.

{
    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* 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.

References _r_contact::expires, free_r_contact(), get_contact_hash(), _r_contact::hash, _r_contact::host, M_NAME, _r_contact::port, r_hash_size, _r_contact::reg_state, _r_contact::service_route, _r_contact::service_route_cnt, STR_SHM_DUP, _r_contact::transport, and _r_contact::uri.

{
    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* 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.

References get_contact_hash(), r_hash_slot::head, _r_contact::host, _r_contact::next, _r_contact::port, r_hash_size, r_lock(), r_unlock(), and registrar.

{
    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* 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.

References _r_contact::hash, r_hash_slot::head, new_r_contact(), _r_contact::next, _r_contact::pinhole, _r_contact::prev, r_lock(), registrar, and r_hash_slot::tail.

{
    r_contact *c;