bin_scscf.c File Reference

---

Detailed Description

Binary codec operations for the S-CSCF.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file bin_scscf.c.

#include "bin_scscf.h"

Go to the source code of this file.

Functions
static int	str_shm_dup (str *dest, str *src)
static int	bin_encode_public_identity (bin_data *x, ims_public_identity *pi)
	Encode and append a Public Indentity.
static int	bin_decode_public_identity (bin_data *x, ims_public_identity *pi)
	Decode a binary string from a binary data structure.
static int	bin_encode_spt (bin_data *x, ims_spt *spt)
	Encode and append a SPT.
static int	bin_decode_spt (bin_data *x, ims_spt *spt)
	Decode an SPT.
static int	bin_encode_filter_criteria (bin_data *x, ims_filter_criteria *fc)
	Encode and Append a Filter Criteria.
static int	bin_decode_filter_criteria (bin_data *x, ims_filter_criteria *fc)
	Decode a Filter Criteria.
static int	bin_encode_service_profile (bin_data *x, ims_service_profile *sp)
	Encode and append a Service Profile.
static int	bin_decode_service_profile (bin_data *x, ims_service_profile *sp)
	Decode a service profile.
int	bin_encode_ims_subscription (bin_data *x, ims_subscription *s)
	Encode the entire user profile and append it to the binary data.
ims_subscription *	bin_decode_ims_subscription (bin_data *x)
	Decode a binary string from a binary data structure.
int	bin_encode_r_contact (bin_data *x, r_contact *c)
	Encode a r_contact into a binary form.
r_contact *	bin_decode_r_contact (bin_data *x)
	Decode a r_contact from a binary data structure.
int	bin_encode_r_subscriber (bin_data *x, r_subscriber *s)
	Encode a r_subscriber into a binary form.
r_subscriber *	bin_decode_r_subscriber (bin_data *x)
	Decode a subscriber from a binary data structure.
int	bin_encode_r_public (bin_data *x, r_public *p)
	Encode a r_public into a binary form.
r_public *	bin_decode_r_public (bin_data *x)
	Decode a r_public from a binary data structure.
int	bin_encode_auth_vector (bin_data *x, auth_vector *v)
	Encode an authentication vector into a binary form.
auth_vector *	bin_decode_auth_vector (bin_data *x)
	Decode an authentication vector from a binary data structure.
int	bin_encode_auth_userdata (bin_data *x, auth_userdata *u)
	Encode an authentication userdata into a binary form.
auth_userdata *	bin_decode_auth_userdata (bin_data *x)
	Decode an authentication userdata from a binary data structure.
int	bin_encode_s_dialog (bin_data *x, s_dialog *d)
	Encode a dialog into a binary form.
s_dialog *	bin_decode_s_dialog (bin_data *x)
	Decode a dialog userdata from a binary data structure.
Variables
tm_binds	tmb
	Structure with pointers to tm funcs.
int	r_hash_size
	Size of S-CSCF registrar hash table.

---

Function Documentation

static int str_shm_dup	(	str *	dest,
		str *	src
	)			[inline, static]

Definition at line 62 of file bin_scscf.c.

References M_NAME.

{
    dest->s = shm_malloc(src->len);
    if (!dest->s){
        LOG(L_ERR,"ERR:"M_NAME":str_shm_dup: Error allocating %d bytes\n",src->len);
        dest->len=0;
        return 0;
    }
    dest->len = src->len;
    memcpy(dest->s,src->s,src->len);
    return 1;
}

static int bin_encode_public_identity	(	bin_data *	x,
		ims_public_identity *	pi
	)			[static]

Encode and append a Public Indentity.

Parameters:

	x	- binary data to append to
	pi	- the public identity to encode

Returns:

1 on succcess or 0 on error

Definition at line 81 of file bin_scscf.c.

References ims_public_identity::barring, bin_encode_char(), bin_encode_str(), M_NAME, and ims_public_identity::public_identity.

Referenced by bin_encode_service_profile().

{
    if (!bin_encode_char(x,pi->barring)) goto error;
    if (!bin_encode_str(x,&(pi->public_identity))) goto error;  
    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_public_identity: Error while encoding.\n");
    return 0;       
}

static int bin_decode_public_identity	(	bin_data *	x,
		ims_public_identity *	pi
	)			[static]

Decode a binary string from a binary data structure.

Parameters:

	x	- binary data to decode from
	pi	- the public identity to decode into

Returns:

1 on succcess or 0 on error

Definition at line 97 of file bin_scscf.c.

References ims_public_identity::barring, bin_decode_char(), bin_decode_str(), M_NAME, _bin_data::max, ims_public_identity::public_identity, and str_shm_dup().

Referenced by bin_decode_service_profile().

{
    str s;
    if (!bin_decode_char(x, &(pi->barring))) goto error;
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(pi->public_identity),&s)) goto error;
    
    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_public_identity: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (pi) {
        if (pi->public_identity.s) shm_free(pi->public_identity.s);
    }
    return 0;
}

static int bin_encode_spt	(	bin_data *	x,
		ims_spt *	spt
	)			[static]

Encode and append a SPT.

Parameters:

	x	- binary data to append to
	spt	- the service point trigger to encode

Returns:

1 on succcess or 0 on error

Definition at line 123 of file bin_scscf.c.

References bin_encode_char(), bin_encode_int(), bin_encode_short(), bin_encode_str(), bin_encode_uchar(), _ims_spt::condition_negated, _ims_session_desc::content, _ims_sip_header::content, _ims_spt::group, _ims_sip_header::header, _ims_session_desc::line, M_NAME, _ims_spt::method, _ims_spt::registration_type, _ims_spt::request_uri, _ims_spt::session_case, _ims_spt::session_desc, _ims_spt::sip_header, _ims_sip_header::type, and _ims_spt::type.

Referenced by bin_encode_filter_criteria().

{
    unsigned char c = spt->condition_negated<<7 | spt->registration_type<<4 | spt->type;
    // cond negated, reg type, spt type
    if (!bin_encode_uchar(x,c)) goto error;

    //group
    if (!bin_encode_int(x,spt->group)) goto error;

    //spt
    switch(spt->type){
        case 1:
            if (!bin_encode_str(x,&(spt->request_uri))) goto error; 
            break;
        case 2:
            if (!bin_encode_str(x,&(spt->method))) goto error; 
            break;
        case 3:
            if (!bin_encode_short(x,spt->sip_header.type)) goto error;
            if (!bin_encode_str(x,&(spt->sip_header.header))) goto error; 
            if (!bin_encode_str(x,&(spt->sip_header.content))) goto error; 
            break;
        case 4:
            if (!bin_encode_char(x,spt->session_case)) goto error;
            break;
        case 5:
            if (!bin_encode_str(x,&(spt->session_desc.line))) goto error; 
            if (!bin_encode_str(x,&(spt->session_desc.content))) goto error; 
            break;
    }
    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_spt: Error while encoding.\n");
    return 0;       
}

static int bin_decode_spt	(	bin_data *	x,
		ims_spt *	spt
	)			[static]

Decode an SPT.

Parameters:

	x	- binary data to decode from
	spt	- the service point trigger to decode into

Returns:

1 on succcess or 0 on error

Definition at line 166 of file bin_scscf.c.

References bin_decode_char(), bin_decode_int(), bin_decode_short(), bin_decode_str(), bin_decode_uchar(), _ims_spt::condition_negated, _ims_session_desc::content, _ims_sip_header::content, _ims_spt::group, _ims_sip_header::header, _ims_session_desc::line, M_NAME, _bin_data::max, _ims_spt::method, _ims_spt::registration_type, _ims_spt::request_uri, _ims_spt::session_case, _ims_spt::session_desc, _ims_spt::sip_header, str_shm_dup(), _ims_sip_header::type, and _ims_spt::type.

Referenced by bin_decode_filter_criteria().

{
    unsigned char k;
    str s;
    
    if (!bin_decode_uchar(x,&k)) goto error;
    
    spt->type = k & 0x0F;
    spt->condition_negated = ((k & 0x80)!=0);
    spt->registration_type = ((k & 0x70)>>4);
    
    if (!bin_decode_int(x,&(spt->group))) goto error;

    switch (spt->type){
        case 1:
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->request_uri),&s)) goto error;
            break;
        case 2:
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->method),&s)) goto error;
            break;
        case 3:
            if (!bin_decode_short(x,&(spt->sip_header.type))) goto error;
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->sip_header.header),&s)) goto error;
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->sip_header.content),&s)) goto error;
            break;
        case 4:
            if (!bin_decode_char(x,&(spt->session_case))) goto error;
            break;
        case 5:
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->session_desc.line),&s)) goto error;
            if (!bin_decode_str(x,&s)||!str_shm_dup(&(spt->session_desc.content),&s)) goto error;
            break;

    }
    return 1;
    
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_spt: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (spt){
        switch (spt->type){
            case 1:
                if (spt->request_uri.s) shm_free(spt->request_uri.s);
                break;
            case 2:
                if (spt->method.s) shm_free(spt->method.s);
                break;
            case 3:
                if (spt->sip_header.header.s) shm_free(spt->sip_header.header.s);
                if (spt->sip_header.header.s) shm_free(spt->sip_header.content.s);
                break;
            case 4:
                break;
            case 5:
                if (spt->sip_header.header.s) shm_free(spt->session_desc.line.s);
                if (spt->sip_header.header.s) shm_free(spt->session_desc.content.s);
                break;
        }
    }
    return 0;
}   

static int bin_encode_filter_criteria	(	bin_data *	x,
		ims_filter_criteria *	fc
	)			[static]

Encode and Append a Filter Criteria.

Parameters:

	x	- binary data to append to
	spt	- the service point trigger to encode

Returns:

1 on succcess or 0 on error

Definition at line 235 of file bin_scscf.c.

References _ims_filter_criteria::application_server, bin_encode_char(), bin_encode_int(), bin_encode_spt(), bin_encode_str(), bin_encode_ushort(), _ims_trigger_point::condition_type_cnf, _ims_application_server::default_handling, if, M_NAME, _ims_filter_criteria::priority, _ims_filter_criteria::profile_part_indicator, _ims_application_server::server_name, _ims_application_server::service_info, _ims_trigger_point::spt, _ims_trigger_point::spt_cnt, and _ims_filter_criteria::trigger_point.

Referenced by bin_encode_service_profile().

{
    int i;
    char ppindicator;

    //priority
    if (!bin_encode_int(x,fc->priority)) goto error;
    
    //profile part indicator
    if (fc->profile_part_indicator) ppindicator = (*fc->profile_part_indicator)+1;
    else ppindicator = 0;
    if (!bin_encode_char(x,ppindicator)) goto error;
            
    // trigger point 
    if (fc->trigger_point) {
        if (!bin_encode_char(x,fc->trigger_point->condition_type_cnf)) goto error;
        
        if (!bin_encode_ushort(x,fc->trigger_point->spt_cnt)) goto error;
        
        for(i=0;i<fc->trigger_point->spt_cnt;i++)
            if (!bin_encode_spt(x,fc->trigger_point->spt+i)) goto error;
    } else {
        if (!bin_encode_char(x,100)) goto error;
    }
    
    //app server
    if (!bin_encode_str(x,&(fc->application_server.server_name))) goto error;
    if (!bin_encode_char(x,fc->application_server.default_handling)) goto error;
    if (!bin_encode_str(x,&(fc->application_server.service_info))) goto error;
    
    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_filter_criteria: Error while encoding.\n");
    return 0;       
}

static int bin_decode_filter_criteria	(	bin_data *	x,
		ims_filter_criteria *	fc
	)			[static]

Decode a Filter Criteria.

Parameters:

	x	- binary data to decode from
	fc	- filter criteria to decode into

Returns:

1 on succcess or 0 on error

Definition at line 278 of file bin_scscf.c.

References _ims_filter_criteria::application_server, bin_decode_char(), bin_decode_int(), bin_decode_spt(), bin_decode_str(), bin_decode_ushort(), _ims_trigger_point::condition_type_cnf, _ims_application_server::default_handling, if, M_NAME, _bin_data::max, NULL, _ims_filter_criteria::priority, _ims_filter_criteria::profile_part_indicator, _ims_application_server::server_name, _ims_application_server::service_info, _ims_trigger_point::spt, _ims_trigger_point::spt_cnt, str_shm_dup(), and _ims_filter_criteria::trigger_point.

{
    int i,len;
    str s;
    char ppindicator,cnf;
    
    //priority
    if (!bin_decode_int(x,&(fc->priority))) goto error;
    
    // profile part indicator
    if (!bin_decode_char(x,&ppindicator)) goto error;
    if (!ppindicator){
        fc->profile_part_indicator = 0;
    }
    else {
        fc->profile_part_indicator = (char*)shm_malloc(sizeof(char));
        if (!fc->profile_part_indicator) {
            LOG(L_ERR,"ERR:"M_NAME":bin_decode_filter_criteria: Error allocating %d bytes.\n",sizeof(int));
            goto error;
        }
        *(fc->profile_part_indicator) = ppindicator-1;
    }
    
    //cnf 
    if (!bin_decode_char(x,&cnf)) goto error;

    if (cnf==100)
        fc->trigger_point=NULL;
    else {
        ims_trigger_point *tp=0;
        //trigger point
        len = sizeof(ims_trigger_point);
        tp = (ims_trigger_point*)shm_malloc(len);
        fc->trigger_point = tp;
        if (!tp) {
            LOG(L_ERR,"ERR:"M_NAME":bin_decode_filter_criteria: Error allocating %d bytes.\n",len);
            goto error;
        }
        memset(tp,0,len);
        tp->condition_type_cnf=cnf;
        
        if (!bin_decode_ushort(x,&tp->spt_cnt)) goto error;
        len = sizeof(ims_spt)*tp->spt_cnt;
        tp->spt = (ims_spt*)shm_malloc(len);
        if (!tp->spt) {
            LOG(L_ERR,"ERR:"M_NAME":bin_decode_filter_criteria: Error allocating %d bytes.\n",len);
            goto error;
        }
        memset(tp->spt,0,len);
        for(i=0;i<tp->spt_cnt;i++)
            if (!bin_decode_spt(x,tp->spt+i)) goto error;
    }
    //app server uri
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(fc->application_server.server_name),&s)) goto error;
    // app server default handling
    if (!bin_decode_char(x,&(fc->application_server.default_handling)))goto error;
    // app server service info
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(fc->application_server.service_info),&s)) goto error;

    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_filter_criteria: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (fc){
        if (fc->trigger_point){
            if (fc->trigger_point){
                if (fc->trigger_point->spt) shm_free(fc->trigger_point->spt);
            }
            shm_free(fc->trigger_point);
        }
        if (fc->application_server.server_name.s) shm_free(fc->application_server.server_name.s);
        if (fc->application_server.service_info.s) shm_free(fc->application_server.service_info.s);
    }
    return 0;       
}

static int bin_encode_service_profile	(	bin_data *	x,
		ims_service_profile *	sp
	)			[static]

Encode and append a Service Profile.

Parameters:

	x	- binary data to append to
	sp	- the service profile to encode

Returns:

1 on succcess or 0 on error

Definition at line 364 of file bin_scscf.c.

References bin_encode_filter_criteria(), bin_encode_int(), bin_encode_public_identity(), bin_encode_ushort(), ims_service_profile::cn_service_auth, ims_service_profile::filter_criteria, ims_service_profile::filter_criteria_cnt, if, M_NAME, ims_service_profile::public_identities, ims_service_profile::public_identities_cnt, ims_service_profile::shared_ifc_set, ims_service_profile::shared_ifc_set_cnt, and _ims_cn_service_auth::subscribed_media_profile_id.

Referenced by bin_encode_ims_subscription().

{
    int i;
        
    //public identity
    if (!bin_encode_ushort(x,sp->public_identities_cnt)) return 0;
    for(i=0;i<sp->public_identities_cnt;i++)
        if (!bin_encode_public_identity(x,sp->public_identities+i)) goto error;
    
    //filter criteria
    if (!bin_encode_ushort(x,sp->filter_criteria_cnt)) return 0;
    for(i=0;i<sp->filter_criteria_cnt;i++)
        if (!bin_encode_filter_criteria(x,sp->filter_criteria+i)) goto error;
        
    //cn service_auth
    if (sp->cn_service_auth)
        i = sp->cn_service_auth->subscribed_media_profile_id;
    else i = 0xFFFFFFFF;
    if (!bin_encode_int(x,i)) goto error;

    //shared_ifc
    if (!bin_encode_ushort(x,sp->shared_ifc_set_cnt)) return 0;
    for(i=0;i<sp->shared_ifc_set_cnt;i++)
        if (!bin_encode_int(x,sp->shared_ifc_set[i])) goto error;

    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_service_profile: Error while encoding.\n");
    return 0;       
}

static int bin_decode_service_profile	(	bin_data *	x,
		ims_service_profile *	sp
	)			[static]

Decode a service profile.

Parameters:

	x	- binary data to decode from
	sp	- service profile to decode into

Returns:

1 on succcess or 0 on error

Definition at line 402 of file bin_scscf.c.

References bin_decode_public_identity(), bin_decode_ushort(), ims_service_profile::filter_criteria, ims_service_profile::filter_criteria_cnt, if, M_NAME, ims_service_profile::public_identities, and ims_service_profile::public_identities_cnt.

Referenced by bin_decode_ims_subscription().

{
    int i,len;

    //public identities
    if (!bin_decode_ushort(x,&(sp->public_identities_cnt))) goto error;
    len = sizeof(ims_public_identity)*sp->public_identities_cnt;
    sp->public_identities = (ims_public_identity*)shm_malloc(len);
    if (!sp->public_identities) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_service_profile: Error allocating %d bytes.\n",len);
        goto error;
    }
    memset(sp->public_identities,0,len);
    for(i=0;i<sp->public_identities_cnt;i++)
        if (!bin_decode_public_identity(x,sp->public_identities+i)) goto error;
    
    // filter criteria
    if (!bin_decode_ushort(x,&(sp->filter_criteria_cnt))) goto error;   
    len = sizeof(ims_filter_criteria)*sp->filter_criteria_cnt;
    sp->filter_criteria = (ims_filter_criteria*)shm_malloc(len);
    if (!sp->filter_criteria) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_service_profile: Error allocating %d bytes.\n",len);
        goto error;
    }
    memset(sp->filter_criteria,0,len);
    for(i=0;i<sp->filter_criteria_cnt;i++)
        if (!bin_decode_filter_criteria(x,sp->filter_criteria+i)) goto error;

    // cn service auth
    if (!bin_decode_int(x,&i)) goto error;
    if (i==0xFFFFFFFF)
        sp->cn_service_auth = 0;
    else {
        len = sizeof(ims_cn_service_auth);
        sp->cn_service_auth = (ims_cn_service_auth*)shm_malloc(len);
        if (!sp->cn_service_auth) {
            LOG(L_ERR,"ERR:"M_NAME":bin_decode_service_profile: Error allocating %d bytes.\n",len);
            goto error;
        }
        sp->cn_service_auth->subscribed_media_profile_id=i;
    }
    
    //shared ifc
    if (!bin_decode_ushort(x,&(sp->shared_ifc_set_cnt))) goto error;    
    len = sizeof(int)*sp->shared_ifc_set_cnt;
    sp->shared_ifc_set = (int*)shm_malloc(len);
    if (!sp->shared_ifc_set) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_service_profile: Error allocating %d bytes.\n",len);
        goto error;
    }
    memset(sp->shared_ifc_set,0,len);
    for(i=0;i<sp->shared_ifc_set_cnt;i++)
        if (!bin_decode_int(x,sp->shared_ifc_set+i)) goto error;

    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_service_profile: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (sp) {
        if (sp->public_identities) shm_free(sp->public_identities);
        if (sp->filter_criteria) shm_free(sp->filter_criteria);
        if (sp->cn_service_auth) shm_free(sp->cn_service_auth);
        if (sp->shared_ifc_set) shm_free(sp->shared_ifc_set);
    }
    return 0;
}

int bin_encode_ims_subscription	(	bin_data *	x,
		ims_subscription *	s
	)

Encode the entire user profile and append it to the binary data.

Parameters:

	x	- binary data to append to
	s	- the ims subscription to encode

Returns:

1 on succcess or 0 on error

Definition at line 486 of file bin_scscf.c.

References bin_encode_service_profile(), bin_encode_str(), bin_encode_ushort(), M_NAME, ims_subscription::private_identity, ims_subscription::service_profiles, and ims_subscription::service_profiles_cnt.

Referenced by bin_encode_r_public().

{
    int i;
    if (!bin_encode_str(x,&(s->private_identity))) goto error;
    if (!bin_encode_ushort(x,s->service_profiles_cnt)) goto error;

    for(i=0;i<s->service_profiles_cnt;i++)
        if (!bin_encode_service_profile(x,s->service_profiles+i)) goto error;
    
    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_ims_subscription: Error while encoding.\n");
    return 0;   
}

ims_subscription* bin_decode_ims_subscription

(

bin_data *

x

)

Decode a binary string from a binary data structure.

Parameters:

x

- binary data to decode from

Returns:

the ims_subscription* where the data has been decoded

Definition at line 507 of file bin_scscf.c.

References bin_decode_service_profile(), bin_decode_str(), bin_decode_ushort(), ims_subscription::lock, M_NAME, _bin_data::max, ims_subscription::private_identity, ims_subscription::ref_count, ims_subscription::service_profiles, ims_subscription::service_profiles_cnt, and str_shm_dup().

Referenced by bin_decode_r_public().

{
    ims_subscription *imss=0;
    int i,len;
    str s;
    
    imss = (ims_subscription*) shm_malloc(sizeof(ims_subscription));
    if (!imss) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_ims_subscription: Error allocating %d bytes.\n",sizeof(ims_subscription));
        goto error;
    }
    memset(imss,0,sizeof(ims_subscription));
    
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(imss->private_identity),&s)) goto error;
    if (!bin_decode_ushort(x,   &(imss->service_profiles_cnt))) goto error;
    
    len = sizeof(ims_service_profile)*imss->service_profiles_cnt;
    imss->service_profiles = (ims_service_profile*)shm_malloc(len);
    if (!imss->service_profiles) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_ims_subscription: Error allocating %d bytes.\n",len);
        goto error;
    }
    memset(imss->service_profiles,0,len);

    for(i=0;i<imss->service_profiles_cnt;i++)
        if (!bin_decode_service_profile(x,imss->service_profiles+i)) goto error;

    imss->lock = lock_alloc();
    imss->lock = lock_init(imss->lock);
    imss->ref_count = 1;

    return imss;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_ims_subscription: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (imss) {
        if (imss->private_identity.s) shm_free(imss->private_identity.s);
        if (imss->service_profiles) shm_free(imss->service_profiles);
        shm_free(imss);
    }
    return 0;
}

int bin_encode_r_contact	(	bin_data *	x,
		r_contact *	c
	)

Encode a r_contact into a binary form.

Parameters:

	x	- binary data to append to
	c	- the r_contact to encode

Returns:

1 on succcess or 0 on error

Definition at line 559 of file bin_scscf.c.

References bin_encode_char(), bin_encode_pinhole(), bin_encode_r_public(), bin_encode_r_security(), bin_encode_str(), bin_encode_time_t(), bin_encode_ushort(), _r_contact::expires, _r_contact::head, _r_contact::host, if, M_NAME, _r_public::next, _r_contact::path, _r_contact::pinhole, _r_contact::port, _r_contact::reg_state, _r_contact::security, _r_contact::security_temp, _r_contact::service_route, _r_contact::service_route_cnt, _r_contact::transport, _r_contact::ua, and _r_contact::uri.

{
    if (!bin_encode_str(x,&(c->uri))) goto error;
    if (!bin_encode_time_t(x,c->expires)) goto error;
    if (!bin_encode_str(x,&(c->ua))) goto error;
    if (!bin_encode_str(x,&(c->path))) goto error;

    return 1;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_encode_r_contact: Error while encoding.\n");
    return 0;       
}

r_contact* bin_decode_r_contact

(

bin_data *

x

)

Decode a r_contact from a binary data structure.

Parameters:

x

- binary data to decode from

Returns:

the r_contact* where the data has been decoded

Definition at line 577 of file bin_scscf.c.

References bin_decode_char(), bin_decode_pinhole(), bin_decode_r_public(), bin_decode_r_security(), bin_decode_str(), bin_decode_time_t(), bin_decode_ushort(), _r_contact::expires, free_r_public(), free_r_security(), get_contact_hash(), _r_contact::hash, _r_contact::head, _r_contact::host, if, M_NAME, _bin_data::max, _r_public::next, _r_contact::path, _r_contact::pinhole, _r_contact::port, _r_public::prev, r_hash_size, _r_contact::reg_state, _r_contact::security, _r_contact::security_temp, _r_contact::service_route, _r_contact::service_route_cnt, str_shm_dup(), _r_contact::tail, _r_contact::transport, _r_contact::ua, and _r_contact::uri.

{
    r_contact *c=0;
    int len;
    str s;
    
    len = sizeof(r_contact);
    c = (r_contact*) shm_malloc(len);
    if (!c) {
        LOG(L_ERR,"ERR:"M_NAME":bin_decode_r_contact: Error allocating %d bytes.\n",len);
        goto error;
    }
    memset(c,0,len);
    
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(c->uri),&s)) goto error;
    if (!bin_decode_time_t(x,&c->expires)) goto error;
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(c->ua),&s)) goto error;
    if (!bin_decode_str(x,&s)||!str_shm_dup(&(c->path),&s)) goto error;
    
    return c;
error:
    LOG(L_ERR,"ERR:"M_NAME":bin_decode_r_contact: Error while decoding (at %d (%04x)).\n",x->max,x->max);
    if (c) {
        if (c->uri.s) shm_free(c->uri.s);
        if (c->ua.s) shm_free(c->ua.s);
        if (c->path.s) shm_free(c->path.s);
        
        shm_free(c);
    }
    return 0;
}

int bin_encode_r_subscriber	(	bin_data *	x,
		r_subscriber *	s
	)

Encode a r_subscriber into a binary form.

Parameters:<