registrar_parser.c File Reference

---

Detailed Description

Serving-CSCF - Parser for the IMS User Subscription XML.

This XML is received in the Server-Assignment-Answer

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file registrar_parser.c.

#include <libxml/xmlschemas.h>
#include <libxml/xmlschemastypes.h>
#include <libxml/parser.h>
#include "registrar_parser.h"
#include "mod.h"
#include "../../mem/shm_mem.h"
#include "../../parser/parse_hname2.h"

Go to the source code of this file.

Functions
int	parser_init (char *dtd_filename, char *xsd_filename)
	Initializes the libxml2 parser.
void	parser_destroy ()
	Destroys the parser.
void	space_quotes_trim_dup (str *dest, char *src)
	Duplicate a string into shm and trim leading&trailing spaces and surrounding quotes.
static void	space_trim_dup (str *dest, char *src)
	Duplicate a string into shm and trim leading&trailing spaces.
static char	ifc_tBool2char (xmlChar *x)
	Converts strings to integer values.
static char	ifc_tDefaultHandling2char (xmlChar *x)
	Converts strings to integer values.
static char	ifc_tDirectionOfRequest2char (xmlChar *x)
	Converts strings to integer values.
static char	ifc_tProfilePartIndicator2char (xmlChar *x)
	Converts strings to integer values.
static int	parse_public_identity (xmlDocPtr doc, xmlNodePtr root, ims_public_identity *pi)
	Parse the Public Identity.
static int	parse_sip_header (xmlDocPtr doc, xmlNodePtr node, ims_sip_header *sh)
	Parse SPT for SIP Header.
static int	parse_session_desc (xmlDocPtr doc, xmlNodePtr node, ims_session_desc *sd)
	Parse SPT for Session Description.
static int	parse_spt_extension (xmlDocPtr doc, xmlNodePtr node, ims_spt *spt)
	Parse a Service Point Trigger Extension (RegistrationType).
static int	parse_spt (xmlDocPtr doc, xmlNodePtr node, ims_spt *spt_to, unsigned short *spt_cnt)
	Parse a Service Point Trigger.
static int	parse_trigger_point (xmlDocPtr doc, xmlNodePtr node, ims_trigger_point *tp)
	Parse a Trigger Point.
static int	parse_application_server (xmlDocPtr doc, xmlNodePtr node, ims_application_server *as)
	Parse a Application Server.
static int	parse_filter_criteria (xmlDocPtr doc, xmlNodePtr node, ims_filter_criteria *fc)
	Parse a Filter Criteria.
static int	parse_cn_service_auth (xmlDocPtr doc, xmlNodePtr node, ims_cn_service_auth *cn)
	Parse a Core Network Service Authorization.
static int	parse_service_profile (xmlDocPtr doc, xmlNodePtr root, ims_service_profile *sp)
	Parse a Core Network Service Profile.
static ims_subscription *	parse_ims_subscription (xmlDocPtr doc, xmlNodePtr root)
	Parse a IMS Subscription.
ims_subscription *	parse_user_data (str xml)
	Parses the user data XML and copies data into a new ims_subscription structure.
void	print_user_data (int log_level, ims_subscription *s)
	Print the contents of an ims_subscription structure.
void	free_user_data (ims_subscription *s)
	Deallocates memory used by a subscription.
Variables
char *	scscf_user_data_dtd
char *	scscf_user_data_xsd
int	scscf_support_wildcardPSI
int	ctxtInit = 0
	the XML context
static xmlDtdPtr	dtd = 0
	DTD file.
static xmlValidCtxtPtr	dtdCtxt = 0
	Validating context.
static xmlSchemaPtr	xsd = 0
	XSD file.
static xmlSchemaValidCtxtPtr	xsdCtxt = 0
	Schema Validating context.

---

Function Documentation

int parser_init	(	char *	dtd_filename,
		char *	xsd_filename
	)

Initializes the libxml2 parser.

Parameters:

	dtd_filename	- path to the DTD or NULL if none
	xsd_filename	- path to the XSD or NULL if none

Returns:

1 on success or 0 on error

Definition at line 89 of file registrar_parser.c.

References ctxtInit, dtd, dtdCtxt, M_NAME, NULL, xsd, and xsdCtxt.

{
    if (dtd_filename){
        dtd = xmlParseDTD(NULL,(unsigned char*)dtd_filename);
        if (!dtd){
            LOG(L_ERR,"ERR:"M_NAME":parser_init: unsuccesful DTD parsing from file <%s>\n",
                dtd_filename);
            return 0;
        }
        dtdCtxt = xmlNewValidCtxt();
        dtdCtxt->userData = (void*)stderr;
        dtdCtxt->error = (xmlValidityErrorFunc) fprintf;
        dtdCtxt->warning = (xmlValidityWarningFunc) fprintf;
    }
    if (xsd_filename){
        xmlSchemaParserCtxtPtr ctxt;
        ctxt = xmlSchemaNewParserCtxt(xsd_filename);
        if (!ctxt) {
            LOG(L_ERR,"ERR:"M_NAME":parser_init: unsuccesful XSD parsing from file <%s>\n",
                xsd_filename);
            return 0;
        }
        xmlSchemaSetParserErrors(ctxt,(xmlValidityErrorFunc) fprintf,(xmlValidityWarningFunc) fprintf,stderr);
        xsd = xmlSchemaParse(ctxt);
        xmlSchemaFreeParserCtxt(ctxt);      
        
        xsdCtxt = xmlSchemaNewValidCtxt(xsd);
        xmlSchemaSetValidErrors(xsdCtxt,(xmlValidityErrorFunc) fprintf,(xmlValidityWarningFunc) fprintf,stderr);
    }
    ctxtInit=1;
    return 1;
}

void parser_destroy

(

)

Destroys the parser.

Definition at line 125 of file registrar_parser.c.

References dtdCtxt, and xsdCtxt.

{
    if (dtdCtxt){
        xmlFreeValidCtxt(dtdCtxt);
    }
    if (xsdCtxt){
        xmlSchemaFreeValidCtxt(xsdCtxt);
        xmlSchemaCleanupTypes();
    }
    xmlCleanupParser();
    
}

void space_quotes_trim_dup	(	str *	dest,
		char *	src
	)

Duplicate a string into shm and trim leading&trailing spaces and surrounding quotes.

Parameters:

	dest	- destination
	src	- source

Definition at line 143 of file registrar_parser.c.

References NULL.

Referenced by parse_session_desc(), and parse_sip_header().

                                                 {
    int i = 0;
    //right space trim
    if (src == NULL) return ;
    dest->len = strlen(src);
    i = dest->len - 1;
    while((src[i] == ' '||src[i]=='\t') && i > 0) {
        dest->len--;
        i--;
    }
    //left space trim
    i = 0;
    while((src[i] == ' '||src[i]=='\t') && i<dest->len)
        i++;

    while(i<dest->len &&(src[i]=='\"'&&src[dest->len-1]=='\"')){
        i++;
        if (i<dest->len) dest->len--;
    }

    dest->len -= i;
    if (dest->len<=0) return;
    dest->s = shm_malloc(dest->len);
    memcpy(dest->s, src+i , dest->len);
}

static void space_trim_dup	(	str *	dest,
		char *	src
	)			[inline, static]

Duplicate a string into shm and trim leading&trailing spaces.

Parameters:

	dest	- destination
	src	- source

Definition at line 174 of file registrar_parser.c.

References M_NAME.

{
    int i;
    dest->s=0;
    dest->len=0;
    if (!src) return;
    dest->len = strlen(src);
    i = dest->len-1;
    while((src[i]==' '||src[i]=='\t') && i>0) 
        i--;
    i=0;
    while((src[i]==' '||src[i]=='\t') && i<dest->len)
        i++;
    dest->len -= i;
    dest->s = shm_malloc(dest->len);
    if (!dest->s) {
        LOG(L_ERR,"ERR:"M_NAME":space_trim_dup: Out of memory allocating %d bytes\n",dest->len);
        dest->len=0;
        return;
    }
    memcpy(dest->s,src+i,dest->len);
}

static char ifc_tBool2char

(

xmlChar *

x

)

[inline, static]

Converts strings to integer values.

• False -> 0
• True -> 1

  Parameters:

  x

  - input value

  Returns:

  int value

Definition at line 206 of file registrar_parser.c.

Referenced by parse_public_identity(), parse_spt(), and parse_trigger_point().

{
    int r=0;    
    while(x[r]){
        switch(x[r]){
            case '0': return 0;
            case '1': return 1;
            case 't': case 'T': return 1;
            case 'f': case 'F': return 0;
        }
        r++;
    }
    return 0;
}

static char ifc_tDefaultHandling2char

(

xmlChar *

x

)

[inline, static]

Converts strings to integer values.

• SESSION_CONTINUED -> 0
• SESSION_TERMINATED -> 1

  Parameters:

  x

  - input value

  Returns:

  int value

Definition at line 228 of file registrar_parser.c.

References errno, and NULL.

Referenced by parse_application_server().

{
    char r; 
    r = strtol((char*)x, (char **)NULL, 10);
    if (errno==EINVAL){
        while(x[0]){
            if (x[0]=='c'||x[0]=='C') return 0;//SESSION_CONTINUED
            if (x[0]=='r'||x[0]=='R') return 1;//SESSION_TERMINATED
            x++;
        }
        return 0;
    } 
    else return (char)r; 
}

static char ifc_tDirectionOfRequest2char

(

xmlChar *

x

)

[inline, static]

Converts strings to integer values.

• ORIGINATING_SESSION -> 0
• TERMINATING_REGISTERED -> 1
• TERMINATING_UNREGISTERED -> 2

  Parameters:

  x

  - input value

  Returns:

  int value

Definition at line 251 of file registrar_parser.c.

References errno, and NULL.

Referenced by parse_spt().

{
    int r;  
    r = strtol((char*)x, (char **)NULL, 10);
    if (errno==EINVAL){
        while(x[0]){
            if (x[0]=='o'||x[0]=='O') return 0;//ORIGINATING_SESSION
            if (x[0]=='s'||x[0]=='S') return 1;//TERMINATING_REGISTERED
            if (x[0]=='u'||x[0]=='U') return 2;//TERMINATING_UNREGISTERED
            x++;
        }
        return 0;
    } 
    else return (char)r; 
}

static char ifc_tProfilePartIndicator2char

(

xmlChar *

x

)

[inline, static]

Converts strings to integer values.

• REGISTERED -> 0
• UNREGISTERED -> 1
• error (any) -> -1

  Parameters:

  x

  - input value

  Returns:

  int value

Definition at line 275 of file registrar_parser.c.

References errno, and NULL.

Referenced by parse_filter_criteria().

{
    int r;  
    if (x==0||x[0]==0) return -1;
    r = strtol((char*)x, (char **)NULL, 10);
    if (errno==EINVAL){
        while(x[0]){
            if (x[0]=='r'||x[0]=='R') return 0;//REGISTERED
            if (x[0]=='u'||x[0]=='U') return 1;//UNREGISTERED
            x++;
        }
        return 0;
    } 
    else return (char)r; 
}

static int parse_public_identity	(	xmlDocPtr	doc,
		xmlNodePtr	root,
		ims_public_identity *	pi
	)			[static]

Parse the Public Identity.

Parameters:

	doc	- the XML document
	root	- the current node
	pi	- structure to fill

Returns:

1 on success, 0 on failure , 2 if its a wildcardpsi

Definition at line 299 of file registrar_parser.c.

References ims_public_identity::barring, ifc_tBool2char(), ims_public_identity::public_identity, scscf_support_wildcardPSI, space_trim_dup(), and ims_public_identity::wildcarded_psi.

Referenced by parse_service_profile().

{
    xmlNodePtr child;
    xmlNodePtr grandson;
    xmlChar *x;
    int return_code=1;
    
    for(child=root->children;child;child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]){
                case 'I': case 'i':
                    if (!pi->public_identity.len){
                        x = xmlNodeListGetString(doc,child->xmlChildrenNode,1);
                        space_trim_dup(&(pi->public_identity),(char*)x);
                        xmlFree(x);
                    }                   
                    break;
                case 'B': case 'b':
                    x = xmlNodeListGetString(doc,child->xmlChildrenNode,1);
                    pi->barring = ifc_tBool2char(x);
                    xmlFree(x);
                    break;
                //lets add something 
                case 'E' : case 'e':
                    // that would be Extension
                    // here i need to parse Identity Type 
                    // if its two then  wildcardedpsi
                    // and then extension!!!
                    // I have to check how you parse this shit

                    for(grandson=child->children;grandson;grandson=grandson->next)
                    {
                                                
                        if (grandson->type==XML_ELEMENT_NODE)
                        {
                            switch (grandson->name[0]) {
                                case 'I' : case 'i':
                                    //identity type 0 public identity 1 distinct psi 2 wildcard psi
                                    //x = xmlNodeListGetString(doc,grandson->xmlChildrenNode,1);
                                    // i need to compare x with 2, but i have to trim leading 
                                    // space characters or tabs         
                                    //xmlFree(x);
                                    break;
                                case 'W' : case 'w':
                                    //wildcardpsi
                                    if(!scscf_support_wildcardPSI) {
                                        LOG(L_ERR,"Configured without support for Wildcard PSI and got one from HSS\n");
                                        LOG(L_ERR,"the identity will be stored but never be matched, please include the parameter to support wildcard PSI in the config file\n");
                                    }
                                    
                                    x = xmlNodeListGetString(doc,grandson->xmlChildrenNode,1);
                                    
                                    space_trim_dup(&(pi->wildcarded_psi),(char*)x);
                                    
                                    xmlFree(x);
                                    return_code=2;
                                    break;
                                default :
                                    break;
                            }
                        }
                    }
                                        
                    break;              
            }

    return return_code;
}

static int parse_sip_header	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_sip_header *	sh
	)			[static]

Parse SPT for SIP Header.

Parameters:

	doc	- the XML document
	node	- the current node
	sh	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 375 of file registrar_parser.c.

References _ims_sip_header::content, _ims_sip_header::header, NULL, space_quotes_trim_dup(), space_trim_dup(), and _ims_sip_header::type.

Referenced by parse_spt().

{
    xmlNodePtr child;
    xmlChar *x;
    char c[256];
    int len;
    struct hdr_field hf;
    sh->header.s=NULL;sh->header.len=0;
    sh->content.s=NULL;sh->content.len=0;

    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'H':case 'h':  //Header
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    len = strlen((char*)x);     
                    memcpy(c,x,len);
                    c[len++]=':';
                    c[len]=0;
                    space_trim_dup(&(sh->header),(char*)x);
                    parse_hname2(c,c+(len<4?4:len),&hf);
                    sh->type=(short)hf.type;
                    //LOG(L_CRIT,"[%.*s(%d)]\n",sh->header.len,sh->header.s,sh->type);
                    xmlFree(x);
                    break;
                case 'C':case 'c':  //Content
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    space_quotes_trim_dup(&(sh->content),(char*)x);
                    xmlFree(x);
                    break;
            }
    return 1;
}

static int parse_session_desc	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_session_desc *	sd
	)			[static]

Parse SPT for Session Description.

Parameters:

	doc	- the XML document
	node	- the current node
	sd	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 416 of file registrar_parser.c.

References _ims_session_desc::content, _ims_session_desc::line, NULL, space_quotes_trim_dup(), and space_trim_dup().

Referenced by parse_spt().

{
    xmlNodePtr child;
    xmlChar *x;
    sd->line.s=NULL;sd->line.len=0;
    sd->content.s=NULL;sd->content.len=0;

    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'L':case 'l':  //Line
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    space_trim_dup(&(sd->line),(char*)x);
                    xmlFree(x);
                    break;
                case 'C':case 'c':  //Content
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    space_quotes_trim_dup(&(sd->content),(char*)x);
                    xmlFree(x);
                    break;
            }
    return 1;
}

static int parse_spt_extension	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_spt *	spt
	)			[static]

Parse a Service Point Trigger Extension (RegistrationType).

Parameters:

	doc	- the XML document
	node	- the current node
	spt	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 447 of file registrar_parser.c.

References IFC_DE_REGISTRATION, IFC_INITIAL_REGISTRATION, IFC_RE_REGISTRATION, and _ims_spt::registration_type.

Referenced by parse_spt().

{
    xmlNodePtr child;
    xmlChar *x;

    for(child=node->children ; child ; child=child->next) {
        if (child->type==XML_ELEMENT_NODE && (child->name[0]=='R' || child->name[0]=='r')) {
            x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
            switch(atoi((char*)x)) {
                case 0:
                    spt->registration_type |= IFC_INITIAL_REGISTRATION;
                    break;
                case 1:
                    spt->registration_type |= IFC_RE_REGISTRATION;
                    break;
                case 2:
                    spt->registration_type |= IFC_DE_REGISTRATION;
                    break;
            }                               
            xmlFree(x);
        }
    }
//  LOG(L_CRIT,"INFO:"M_NAME":parse_spt_extension: spt->registration_type=%d\n",spt->registration_type);
    return 1;           
}

static int parse_spt	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_spt *	spt_to,
		unsigned short *	spt_cnt
	)			[static]

Parse a Service Point Trigger.

Parameters:

	doc	- the XML document
	node	- the current node
	spt_to	- structure to fill
	spt_cnt	- structure to fill with the spt count

Returns:

1 on success, 0 on failure

Definition at line 481 of file registrar_parser.c.

References _ims_spt::condition_negated, _ims_spt::group, IFC_METHOD, IFC_REQUEST_URI, IFC_SESSION_CASE, IFC_SESSION_DESC, IFC_SIP_HEADER, ifc_tBool2char(), ifc_tDirectionOfRequest2char(), IFC_UNKNOWN, M_NAME, _ims_spt::method, parse_session_desc(), parse_sip_header(), parse_spt_extension(), _ims_spt::registration_type, _ims_spt::request_uri, _ims_spt::session_case, _ims_spt::session_desc, _ims_spt::sip_header, space_trim_dup(), and _ims_spt::type.

Referenced by parse_trigger_point().

{
    xmlNodePtr child,saved=0;
    xmlChar *x;

    ims_spt *spt,*spt2;
    int group;
    
    spt = spt_to + *spt_cnt;
    
    spt->condition_negated=0;
    spt->group=0;
    spt->type=IFC_UNKNOWN;
    spt->registration_type=0;

    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'C':case 'c': //ConditionNegated
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    spt->condition_negated=ifc_tBool2char(x);
                    xmlFree(x);
                    break;
                case 'G':case 'g': //Group
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    spt->group=atoi((char*)x);
                    xmlFree(x);
                    break;
                case 'R':case 'r': //RequestUri
                    spt->type=IFC_REQUEST_URI;
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    space_trim_dup(&(spt->request_uri),(char*)x);
                    xmlFree(x);
                    break;
                case 'E':case 'e': //Extension
                    parse_spt_extension(doc,child,spt);
                    break;
                case 'M':case 'm': //method
                    spt->type=IFC_METHOD;
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    space_trim_dup(&(spt->method),(char*)x);
                    xmlFree(x);
                    break;
                case 'S':case 's': {//SIPHeader/SessionCase/SessionDescription
                    switch(child->name[7]) {
                        case 'E':case 'e'://SIP_HEADER
                            spt->type=IFC_SIP_HEADER;
                            parse_sip_header(doc,child,&(spt->sip_header));
                            saved = child;
                            break;
                        case 'C':case 'c'://Session Case
                            spt->type=IFC_SESSION_CASE;
                            x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                            spt->session_case=ifc_tDirectionOfRequest2char(x);
                            xmlFree(x);
                            break;
                        case 'D':case 'd'://Session Description
                            spt->type=IFC_SESSION_DESC;
                            parse_session_desc(doc,child,&(spt->session_desc));
                            saved = child;
                            break;
                    }

                }
                    break;
            }
    *spt_cnt=*spt_cnt+1;

    /* adding the other nodes for multiple groups */            
    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'G':case 'g': //Group
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    group=atoi((char*)x);
                    xmlFree(x);
                    if (group != spt->group){
                        spt2 = spt_to + *spt_cnt;
                        spt2->condition_negated = spt->condition_negated;
                        spt2->group = group;
                        spt2->type = spt->type;
                        switch(spt2->type){
                            case IFC_REQUEST_URI:
                                spt2->request_uri.len = spt->request_uri.len;
                                spt2->request_uri.s = shm_malloc(spt2->request_uri.len);
                                if (!spt2->request_uri.s){
                                    LOG(L_ERR,"ERR:"M_NAME":parse_spt: Out of memory allocating %d bytes\n",spt->request_uri.len);
                                    break;
                                }
                                memcpy(spt2->request_uri.s,spt->request_uri.s,spt->request_uri.len);
                                break;
                            case IFC_METHOD:
                                spt2->method.len = spt->method.len;
                                spt2->method.s = shm_malloc(spt2->method.len);
                                if (!spt2->method.s){
                                    LOG(L_ERR,"ERR:"M_NAME":parse_spt: Out of memory allocating %d bytes\n",spt->method.len);
                                    break;
                                }
                                memcpy(spt2->method.s,spt->method.s,spt->method.len);
                                break;
                            case IFC_SIP_HEADER:
                                parse_sip_header(doc,saved,&(spt2->sip_header));
                                break;
                            case IFC_SESSION_CASE:
                                spt2->session_case = spt->session_case;
                                break;
                            case IFC_SESSION_DESC:
                                parse_session_desc(doc,saved,&(spt2->session_desc));
                                break;                              
                        }
                        spt2->registration_type = spt->registration_type;
                        *spt_cnt = *spt_cnt+1;                      
                    }
                    break;
            }
    return 1;           
}

static int parse_trigger_point	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_trigger_point *	tp
	)			[static]

Parse a Trigger Point.

Parameters:

	doc	- the XML document
	node	- the current node
	tp	- structure to fill

Returns:

1 on success, 0 on failure

Todo:

An effective sort for the priority

Definition at line 607 of file registrar_parser.c.

References _ims_trigger_point::condition_type_cnf, _ims_spt::group, IFC_DNF, ifc_tBool2char(), M_NAME, NULL, parse_spt(), _ims_trigger_point::spt, and _ims_trigger_point::spt_cnt.

Referenced by parse_filter_criteria().

{
    xmlNodePtr child,child2;
    xmlChar *x;
    unsigned short spt_cnt=0;
    int i,j;
    ims_spt spttemp;
    tp->condition_type_cnf=IFC_DNF;//0
    tp->spt=NULL;
    tp->spt_cnt=0;

    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'C':case 'c': //ConditionTypeCNF
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    tp->condition_type_cnf=ifc_tBool2char(x);
                    xmlFree(x);
                    break;
                case 'S':case 's': //SPT - Service Point Trigger
                    // COUNT all in another groups
                    for(child2=child->children ; child2 ; child2=child2->next)
                        if (child2->type==XML_ELEMENT_NODE)
                            switch (child2->name[0]) {
                                case 'G':case 'g':
                                    spt_cnt++;
                            }
                    break;
            }
    tp->spt = (ims_spt*) shm_malloc(sizeof(ims_spt)*spt_cnt);
    if (!tp->spt){
        LOG(L_ERR,"ERR:"M_NAME":parse_trigger_point: Out of memory allocating %d bytes\n",sizeof(ims_spt)*spt_cnt);
        return 0;
    }
    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'S':case 's': //SPT - Service Point Trigger
                    parse_spt(doc,child,tp->spt,&(tp->spt_cnt));
                    /*i=0;
                    while(i<tp->spt_cnt&&tp->spt[i].group<spttemp.group)
                        i++;
                    for(j=tp->spt_cnt-1;j>=i;j--)
                        tp->spt[j+1]=tp->spt[j];
                    tp->spt[i]=spttemp;
                    tp->spt_cnt++;*/
            
                    break;
            }
    
    j=1;
    while(j){
        j=0;
        for(i=0;i<tp->spt_cnt-1;i++)
            if (tp->spt[i].group > tp->spt[i+1].group){
                j=1;
                spttemp = tp->spt[i];
                tp->spt[i]=tp->spt[i+1];
                tp->spt[i+1]=spttemp;
            }           
    }
    return 1;
}

static int parse_application_server	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_application_server *	as
	)			[static]

Parse a Application Server.

Parameters:

	doc	- the XML document
	node	- the current node
	as	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 677 of file registrar_parser.c.

References _ims_application_server::default_handling, IFC_NO_DEFAULT_HANDLING, ifc_tDefaultHandling2char(), NULL, _ims_application_server::server_name, _ims_application_server::service_info, and space_trim_dup().

Referenced by parse_filter_criteria().

{
    xmlNodePtr child;
    xmlChar *x;
    as->server_name.s=NULL;as->server_name.len=0;
    as->default_handling=IFC_NO_DEFAULT_HANDLING;
    as->service_info.s=NULL;as->service_info.len=0;

    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'S':case 's':  {//ServerName / ServiceInfo
                    switch (child->name[4]) {
                        case 'E':case 'e':  //ServerName
                            x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                            space_trim_dup(&(as->server_name),(char*)x);
                            xmlFree((char*)x);
                            break;
                        case 'I':case 'i':  //ServiceInfo
                            x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                            space_trim_dup(&(as->service_info),(char*)x);
                            xmlFree(x);
                            break;
                    }
                    break;
                }
                case 'D':case 'd': //DefaultHandling
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    as->default_handling=ifc_tDefaultHandling2char(x);
                    xmlFree(x);
                    break;
            }
    return 1;
}

static int parse_filter_criteria	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_filter_criteria *	fc
	)			[static]

Parse a Filter Criteria.

Parameters:

	doc	- the XML document
	node	- the current node
	fc	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 721 of file registrar_parser.c.

References _ims_filter_criteria::application_server, ifc_tProfilePartIndicator2char(), M_NAME, NULL, parse_application_server(), parse_trigger_point(), _ims_filter_criteria::priority, _ims_filter_criteria::profile_part_indicator, and _ims_filter_criteria::trigger_point.

Referenced by parse_service_profile().

{
    xmlNodePtr child;
    xmlChar *x;
    char k;
    fc->priority=0;
    fc->trigger_point=NULL;
    fc->profile_part_indicator=NULL;
    //fc->apllication_server init mai tarziu
    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[3]) {
                case 'O':case 'o':  //Priority
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    fc->priority=atoi((char*)x);
                    xmlFree(x);
                    break;
                case 'G':case 'g':  //TriggerPoint
                    fc->trigger_point=(ims_trigger_point*) shm_malloc(sizeof(ims_trigger_point));
                    if (!fc->trigger_point){
                        LOG(L_ERR,"ERR:"M_NAME":parse_filter_criteria: Out of memory allocating %d bytes\n",sizeof(ims_trigger_point));
                        break;
                    }
                    if (!parse_trigger_point(doc,child,fc->trigger_point)){
                        shm_free(fc->trigger_point);
                        fc->trigger_point=0;
                        return 0;
                    }
                    break;
                case 'L':case 'l':  //ApplicationServer
                    parse_application_server(doc,child,&(fc->application_server));
                    break;
                case 'F':case 'f':  //ProfilePartIndicator
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    k = ifc_tProfilePartIndicator2char(x);
                    if (k<0) break;
                    fc->profile_part_indicator=(char*)shm_malloc(sizeof(char));
                    if (!fc->profile_part_indicator){
                        LOG(L_ERR,"ERR:"M_NAME":parse_filter_criteria: Out of memory allocating %d bytes\n",sizeof(ims_trigger_point));
                        break;
                    }
                    *fc->profile_part_indicator=k;
                    xmlFree(x);
                    break;
            }
    return 1;
}

static int parse_cn_service_auth	(	xmlDocPtr	doc,
		xmlNodePtr	node,
		ims_cn_service_auth *	cn
	)			[static]

Parse a Core Network Service Authorization.

Parameters:

	doc	- the XML document
	node	- the current node
	cn	- structure to fill

Returns:

1 on success, 0 on failure

Definition at line 777 of file registrar_parser.c.

References _ims_cn_service_auth::subscribed_media_profile_id.

Referenced by parse_service_profile().

{
    xmlNodePtr child;
    xmlChar *x;
    cn->subscribed_media_profile_id=-1;
    for(child=node->children ; child ; child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]) {
                case 'S':case 's':  //BarringIndication
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    cn->subscribed_media_profile_id=atoi((char*)x);
                    xmlFree(x);
                    return 1;
                    break;

            }
    return 0;
}

static int parse_service_profile	(	xmlDocPtr	doc,
		xmlNodePtr	root,
		ims_service_profile *	sp
	)			[static]

Parse a Core Network Service Profile.