registrar_parser.c

Go to the documentation of this file.

/*
 * $Id: registrar_parser.c 546 2008-04-01 11:45:59Z vingarzan $
 *  
 * Copyright (C) 2004-2006 FhG Fokus
 *
 * This file is part of Open IMS Core - an open source IMS CSCFs & HSS
 * implementation
 *
 * Open IMS Core is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * For a license to use the Open IMS Core software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact Fraunhofer FOKUS by e-mail at the following
 * addresses:
 *     info@open-ims.org
 *
 * Open IMS Core is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * It has to be noted that this Open Source IMS Core System is not 
 * intended to become or act as a product in a commercial context! Its 
 * sole purpose is to provide an IMS core reference implementation for 
 * IMS technology testing and IMS application prototyping for research 
 * purposes, typically performed in IMS test-beds.
 * 
 * Users of the Open Source IMS Core System have to be aware that IMS
 * technology may be subject of patents and licence terms, as being 
 * specified within the various IMS-related IETF, ITU-T, ETSI, and 3GPP
 * standards. Thus all Open IMS Core users have to take notice of this 
 * fact and have to agree to check out carefully before installing, 
 * using and extending the Open Source IMS Core System, if related 
 * patents and licences may become applicable to the intended usage 
 * context.  
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 */
 
#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"



extern char *scscf_user_data_dtd; /* Path to "CxDataType.dtd"                               */
extern char *scscf_user_data_xsd; /* Path to "CxDataType_Rel6.xsd" or "CxDataType_Rel7.xsd" */

extern int scscf_support_wildcardPSI;

int ctxtInit=0;                         
static xmlDtdPtr    dtd=0;              
static xmlValidCtxtPtr  dtdCtxt=0;      
static xmlSchemaPtr xsd=0;              
static xmlSchemaValidCtxtPtr xsdCtxt=0; 
int parser_init(char *dtd_filename,char *xsd_filename)
{
    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()
{
    if (dtdCtxt){
        xmlFreeValidCtxt(dtdCtxt);
    }
    if (xsdCtxt){
        xmlSchemaFreeValidCtxt(xsdCtxt);
        xmlSchemaCleanupTypes();
    }
    xmlCleanupParser();
    
}

void space_quotes_trim_dup(str *dest,char * src) {
    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 inline void space_trim_dup(str *dest, char *src)
{
    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 inline char ifc_tBool2char(xmlChar *x)
{
    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 inline char ifc_tDefaultHandling2char(xmlChar *x)
{
    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 inline char ifc_tDirectionOfRequest2char(xmlChar *x)
{
    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 inline char ifc_tProfilePartIndicator2char(xmlChar *x)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    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)
{
    xmlNodePtr child;
    xmlChar *x;
    unsigned short pi_cnt=0,ifc_cnt=0,sh_cnt=0;
    int i,j;
    ims_filter_criteria fctemp;
    int returncode=0;
    
    for(child=root->children;child;child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]){
                case 'P': case 'p':
                    pi_cnt++;
                    break;  
                case 'i':case 'I':  //InitialFilterCriteria
                    ifc_cnt++;
                    break;
                case 'c':case 'C':  //CoreNetworkServiceAuthorization
                    sp->cn_service_auth = (ims_cn_service_auth*) shm_malloc(
                                                    sizeof(ims_cn_service_auth));
                    break;
                case 's':case 'S':  //SharedIFCSet
                    sh_cnt++;
                    break;
                                    
            }   

    sp->public_identities = shm_malloc(pi_cnt*sizeof(ims_public_identity));
    if (!sp->public_identities) {
        LOG(L_ERR,"ERR:"M_NAME":parse_service_profile: Out of memory allocating %d bytes\n",pi_cnt*sizeof(ims_public_identity));
        return 0;
    }
    memset(sp->public_identities,0,pi_cnt*sizeof(ims_public_identity));

    sp->filter_criteria = (ims_filter_criteria*) shm_malloc(sizeof(ims_filter_criteria)*ifc_cnt);
    if (!sp->filter_criteria) {
        LOG(L_ERR,"ERR:"M_NAME":parse_service_profile: Out of memory allocating %d bytes\n",ifc_cnt*sizeof(ims_filter_criteria));
        return 0;
    }
    memset(sp->filter_criteria,0,ifc_cnt*sizeof(ims_filter_criteria));

    sp->shared_ifc_set = (int*) shm_malloc(sizeof(int)*sh_cnt);
    if (!sp->shared_ifc_set) {
        LOG(L_ERR,"ERR:"M_NAME":parse_service_profile: Out of memory allocating %d bytes\n",sh_cnt*sizeof(int));
        return 0;
    }
    memset(sp->shared_ifc_set,0,sh_cnt*sizeof(int));
    
    for(child=root->children;child;child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]){
                case 'P': case 'p':
                    returncode=parse_public_identity(doc,child,&(sp->public_identities[sp->public_identities_cnt]));
                    if (returncode)
                        sp->public_identities_cnt++;
                    break;      
                case 'I':case 'i':  //InitialFilterCriteria
                    if (!parse_filter_criteria(doc,child,&(fctemp))) 
                        break;
                    i=0;
                    while(i<sp->filter_criteria_cnt&&sp->filter_criteria[i].priority<fctemp.priority)
                        i++;
                    for(j=sp->filter_criteria_cnt-1;j>=i;j--)
                        sp->filter_criteria[j+1]=sp->filter_criteria[j];
                    sp->filter_criteria[i]=fctemp;
                    sp->filter_criteria_cnt++;
                    break;
                case 'C':case 'c':  //CoreNetworkServiceAuthorization
                    if (!parse_cn_service_auth(doc,child,sp->cn_service_auth)){
                        shm_free(sp->cn_service_auth);
                        sp->cn_service_auth=0;
                    }
                    break;
                case 'S':case 's':  //SharedIFCSet
                    x = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    sp->shared_ifc_set[sp->shared_ifc_set_cnt++]=atoi((char*)x);
                    xmlFree(x);
                    break;                              
            }
    if (returncode==2)
        return 2; // i need to know if there is a wildcardpsi hiding in the public_identity
    return 1;
}

static ims_subscription* parse_ims_subscription(xmlDocPtr doc, xmlNodePtr root)
{
    xmlNodePtr child;
    xmlChar *x;
    ims_subscription *s;
    unsigned short sp_cnt=0;
    int rc;
    
    if (!root) return 0;
    while(root->type!=XML_ELEMENT_NODE || strcasecmp((char*)root->name,"IMSSubscription")!=0){
        root = root->next;
    }
    if (!root) {
        LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  No IMSSubscription node found\n");
        return 0;
    }
    s = (ims_subscription*) shm_malloc(sizeof(ims_subscription));
    if (!s) {
        LOG(L_ERR,"ERR:"M_NAME":parse_ims_subscription: Out of memory allocating %d bytes\n",sizeof(ims_subscription));
        return 0;
    }
    memset(s,0,sizeof(ims_subscription));
    for(child=root->children;child;child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            switch (child->name[0]){
                case 'P':case 'p':  /* Private Identity */
                    if (!s->private_identity.len){
                        x = xmlNodeListGetString(doc,child->xmlChildrenNode,1);
                        space_trim_dup(&(s->private_identity),(char*)x);
                        xmlFree(x);
                    }
                    break;
                case 'S':case 's':  /* Service Profile */
                    sp_cnt++;
                    break;                  
            }
    s->service_profiles = (ims_service_profile*) shm_malloc(sp_cnt * sizeof(ims_service_profile));
    if (!s->service_profiles) {
        LOG(L_ERR,"ERR:"M_NAME":parse_ims_subscription: Out of memory allocating %d bytes\n",sp_cnt*sizeof(ims_service_profile));
        return s;   
    }
    memset(s->service_profiles,0,sp_cnt * sizeof(ims_service_profile));
    for(child=root->children;child;child=child->next)
        if (child->type==XML_ELEMENT_NODE)
            if (child->name[0]=='S' || child->name[0]=='s')
            {
                rc=parse_service_profile(doc,child,&(s->service_profiles[s->service_profiles_cnt]));
                if (rc==2)
                    s->wpsi=1;
                if (rc)
                    s->service_profiles_cnt++;
            }               
    s->lock = lock_alloc();
    s->lock = lock_init(s->lock);
    return s;
}


ims_subscription *parse_user_data(str xml)
{
    xmlDocPtr doc=0;
    xmlNodePtr root=0;
    char c;
    ims_subscription *s;
    if (!ctxtInit) parser_init(scscf_user_data_dtd,scscf_user_data_xsd);    
    doc=0;
    c = xml.s[xml.len];
    xml.s[xml.len]=0;
    doc = xmlParseDoc((unsigned char *)xml.s);
    if (!doc){
        LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  This is not a valid XML <%.*s>\n",
            xml.len,xml.s);
        goto error;
    }
    if (dtdCtxt){
        if (xmlValidateDtd(dtdCtxt,doc,dtd)!=1){
            LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  Verification of XML against DTD failed <%.*s>\n",
                xml.len,xml.s);
            goto error;
        }
    }
    if (xsdCtxt){
        if (xmlSchemaValidateDoc(xsdCtxt,doc)!=0){
            LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  Verification of XML against XSD failed <%.*s>\n",
                xml.len,xml.s);
            goto error;
        }
    }
    root = xmlDocGetRootElement(doc);
    if (!root){
        LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  Empty XML <%.*s>\n",
            xml.len,xml.s);
        goto error;
    }
    s = parse_ims_subscription(doc,root);
    if (!s){
        LOG(L_ERR,"ERR:"M_NAME":parse_user_data:  Error while loading into  ims subscription structure\n");
        goto error;     
    }
    xmlFreeDoc(doc);
//  print_user_data(L_CRIT,s);
    return s;
error:  
    if (doc) xmlFreeDoc(doc);
    xml.s[xml.len]=c;
    return 0;   
}

void print_user_data(int log_level,ims_subscription *s)
{
    int i,j,k;
    if (debug<log_level) return; /* to avoid useless calls when nothing will be printed */
    LOG(log_level,"INF:"M_NAME":IMSSubscription:\n");
    if (!s) return;
    lock_get(s->lock);
    LOG(log_level,"INF:"M_NAME":\tPrivate Identity: <%.*s>\n",s->private_identity.len,s->private_identity.s);
    for(i=0;i<s->service_profiles_cnt;i++){
        LOG(log_level,"INF:"M_NAME":\tService Profile:\n");
        for(j=0;j<s->service_profiles[i].public_identities_cnt;j++){    
            LOG(log_level,"INF:"M_NAME":\t\tPublic Identity: Barring [%d] <%.*s> \n",
                s->service_profiles[i].public_identities[j].barring,
                s->service_profiles[i].public_identities[j].public_identity.len,
                s->service_profiles[i].public_identities[j].public_identity.s);         
        }
        for(j=0;j<s->service_profiles[i].filter_criteria_cnt;j++){  
            LOG(log_level,"INF:"M_NAME":\t\tFilter Criteria: Priority [%d]ProfilePartInd [%d]\n",
                s->service_profiles[i].filter_criteria[j].priority,
                s->service_profiles[i].filter_criteria[j].profile_part_indicator?
                 *(s->service_profiles[i].filter_criteria[j].profile_part_indicator):-1 );              
            if (s->service_profiles[i].filter_criteria[j].trigger_point){
                LOG(log_level,"INF:"M_NAME":\t\t\tTrigger Point: CNF [%c] %s\n",
                    s->service_profiles[i].filter_criteria[j].trigger_point->condition_type_cnf?'X':' ',
                    s->service_profiles[i].filter_criteria[j].trigger_point->condition_type_cnf?"(_|_)&(_|_)":"(_&_)|(_&_)"
                    );