libermanifest/src/ermanifest.c File Reference

#include <stdio.h>
#include <unistd.h>
#include <libxml/xmlschemas.h>
#include "ermanifest.h"

Go to the source code of this file.

Classes
struct	pairs_t
struct	a_step_t
Defines
#define	LIBXML_SCHEMAS_ENABLED
#define	DEFAULT_ENCODING   "utf-8"
#define	INT_MAX_BUF   15
#define	BOOL_MAX_BUF   6
#define	_DEBUG   0
#define	TRACE(x...)   do {} while(0)
#define	BUF_LEN   1024
Enumerations
enum	with_type_t { with_none_t, with_index_t, with_attr_t, with_child_t }
Functions
xmlChar *	ConvertInput (const char *in, const char *encoding)
xmlXPathObjectPtr	LocateTo (const char *express, const erManifest *pCtx)
xmlNodePtr	ermXmlGetChildNode (xmlNodePtr parent, const char *childName)
xmlNodeSetPtr	ermXmlGetChildNodeSet (xmlNodePtr parent, const char *childName)
xmlNodePtr	ermXmlGetChildNodeWithAttr (xmlNodePtr parent, const char *nodeName, const char *attrName, const char *attrValue)
xmlNodePtr	ermXmlGetChildNodeWithoutAttr (xmlNodePtr parent, const char *nodeName, const char *attrName)
int	ermXmlExist (const erManifest *pCtx, const char *express)
int	ermXmlOpenFile (const char *szFileName, erManifest *pCtx)
int	ermXmlOpenManifest (const char *szContainerName, erManifest *pCtx)
int	ermXmlValidateManifest (erManifest *pCtx)
int	ermXmlCreateHandleOnly (erManifest *pCtx)
int	ermXmlCreateFile (const char *szFileName, erManifest *pCtx)
int	ermXmlCreateManifest (const char *szContainerName, erManifest *pCtx)
int	ermXmlParseBuffer (const char *xmlString, const char *szFileName, erManifest *pCtx)
const char *	ermXmlGetFileName (const erManifest *pCtx)
int	ermXmlGetNodeNr (const erManifest *pCtx, const char *express, int *number)
int	ermXmlGetString (const erManifest *pCtx, const char *express, char *pRet, const int length)
const char *	ermXmlGetStringBuffer (const erManifest *pCtx, const char *express, int *length)
void	ermXmlFreeStringBuffer (const char *ptr)
int	ermXmlGetInt (const erManifest *pCtx, const char *express, int *pRet)
int	ermXmlGetBoolean (const erManifest *pCtx, const char *express, int *pRet)
int	ermXmlGetAttributeString (const erManifest *pCtx, const char *express, const char *attrName, char *pRet, const int length)
const char *	ermXmlGetAttributeStringBuffer (const erManifest *pCtx, const char *express, const char *attrName, int *length)
int	ermXmlGetAttributeInt (const erManifest *pCtx, const char *express, const char *attrName, int *pRet)
int	ermXmlSetString (erManifest *pCtx, const char *express, const char *pData)
int	ermXmlSetInt (erManifest *pCtx, const char *express, const int data)
int	ermXmlSetBoolean (erManifest *pCtx, const char *express, const int data)
int	ermXmlSetAttributeString (const erManifest *pCtx, const char *express, const char *attrName, const char *pSrc, const int length)
int	ermXmlSetAttributeInt (erManifest *pCtx, const char *express, const char *attrName, const int data)
int	ermXmlNewString (const erManifest *pCtx, const char *parentExpress, const char *name, const char *content)
int	ermXmlNewInt (erManifest *pCtx, const char *parentExpress, const char *name, const int content)
int	ermXmlNewBoolean (erManifest *pCtx, const char *parentExpress, const char *name, const int content)
int	ermXmlRemoveNode (erManifest *pCtx, const char *express)
int	ermXmlSave (erManifest *pCtx)
int	ermXmlSaveAs (erManifest *pCtx, const char *szFileName)
int	ermXmlSaveAndClose (erManifest *pCtx)
int	ermXmlClose (erManifest *pCtx)
static a_step_t *	newAStep (void)
static void	freeAStep (a_step_t *theStep)
static void	calcDelimiterPositions (char *curSlashPos, char *nextSlashPos, char **beginBracketPos, char **atPos, char **equalPos, char **endBracketPos)
static void	getNameAndValue (char *beginPos, char *equalPos, char *endPos, char **name, char **value)
static void	getIndex (const char *begin, const char *end, int *index)
static int	lexicalizeAStep (char *express, char *curSlashPos, a_step_t *data)
static int	checkAStep (const erManifest *pCtx, char *express, char *curSlashPos)
int	ermXmlCheckXpath (erManifest *pCtx, char *express)

---

Define Documentation

#define _DEBUG   0

Definition at line 37 of file ermanifest.c.

#define BOOL_MAX_BUF   6

Definition at line 35 of file ermanifest.c.

#define BUF_LEN   1024

Definition at line 1227 of file ermanifest.c.

#define DEFAULT_ENCODING   "utf-8"

Definition at line 33 of file ermanifest.c.

#define INT_MAX_BUF   15

Definition at line 34 of file ermanifest.c.

#define LIBXML_SCHEMAS_ENABLED

Copyright (C) 2005-2008 iRex Technologies B.V. All rights reserved.

Definition at line 27 of file ermanifest.c.

#define TRACE

(

x...

)

do {} while(0)

Definition at line 42 of file ermanifest.c.

---

Enumeration Type Documentation

enum with_type_t

Enumerator:

with_none_t
with_index_t
with_attr_t
with_child_t

Definition at line 991 of file ermanifest.c.

{
    with_none_t,
    with_index_t,
    with_attr_t,
    with_child_t
} with_type_t;

---

Function Documentation

static void calcDelimiterPositions	(	char *	curSlashPos,
		char *	nextSlashPos,
		char **	beginBracketPos,
		char **	atPos,
		char **	equalPos,
		char **	endBracketPos
	)			[static]

Definition at line 1064 of file ermanifest.c.

{
    char *cp = NULL;

    cp = curSlashPos + 1;
    while (cp < nextSlashPos)
    {
        switch (*cp)
        {
            case '[':
                *beginBracketPos = cp;
                break;
            case ']':
                *endBracketPos = cp;
                break;
            case '@':
                *atPos = cp;
                break;
            case '=':
                *equalPos = cp;
                break;
            default:
                break;
        }
        cp++;
    }
}

static int checkAStep	(	const erManifest *	pCtx,
		char *	express,
		char *	curSlashPos
	)			[static]

Definition at line 1228 of file ermanifest.c.

{
    a_step_t *data = NULL;
    char xpath[BUF_LEN + 1];
    int nChars, nLen, nRet;

    data = newAStep();
    nChars = lexicalizeAStep(express, curSlashPos, data);
    if (RET_ERR == nChars)
    {
        freeAStep(data);
        data = NULL;
        return RET_ERR;
    }

    switch (data->type)
    {
        case with_attr_t:
            // has attribute
            snprintf(xpath, BUF_LEN, "%s/%s[@%s=\"%s\"]",
                     data->xpath, data->name, data->u.pairs.name, data->u.pairs.value);
            if (RET_ERR == ermXmlExist(pCtx, xpath))
            {
                if (strlen(data->xpath))
                {
                    nRet = ermXmlNewString(pCtx, data->xpath, data->name, "");
                }
                else
                {
                    // it's root element
                    nRet = ermXmlNewString(pCtx, "/", data->name, "");
                }
                
                if (RET_ERR == nRet)
                {
                    freeAStep(data);
                    data = NULL;
                    return RET_ERR;
                }

                snprintf(xpath, BUF_LEN, "%s/%s[last()]", data->xpath, data->name);
                nRet =
                    ermXmlSetAttributeString(pCtx, xpath, data->u.pairs.name,
                                             data->u.pairs.value, strlen(data->u.pairs.value));
                if (RET_ERR == nRet)
                {
                    freeAStep(data);
                    data = NULL;
                    return RET_ERR;
                }
            }
            break;
        case with_child_t:
            // has sub-element
            nLen = snprintf(xpath, BUF_LEN, "%s/%s[%s=\"%s\"]",
                            data->xpath, data->name, data->u.pairs.name, data->u.pairs.value);
            if (RET_ERR == ermXmlExist(pCtx, xpath))
            {
                if (strlen(data->xpath))
                {
                    nRet = ermXmlNewString(pCtx, data->xpath, data->name, "");
                }
                else
                {
                    // it's root element
                    nRet = ermXmlNewString(pCtx, "/", data->name, "");
                }
                
                if (RET_ERR == nRet)
                {
                    freeAStep(data);
                    data = NULL;
                    return RET_ERR;
                }

                nLen = snprintf(xpath, BUF_LEN, "%s/%s[last()]", data->xpath, data->name);
                nRet = ermXmlNewString(pCtx, xpath, data->u.pairs.name, data->u.pairs.value);
                if (RET_ERR == nRet)
                {
                    freeAStep(data);
                    data = NULL;
                    return RET_ERR;
                }
            }
            break;
        case with_index_t:
            // has index
            nLen = snprintf(xpath, BUF_LEN, "%s/%s[%d]", data->xpath, data->name, data->u.index);
            if (RET_ERR == ermXmlExist(pCtx, xpath))
            {
                int nNodes = 0;

                nLen = snprintf(xpath, BUF_LEN, "%s/%s", data->xpath, data->name);
                nRet = ermXmlGetNodeNr(pCtx, xpath, &nNodes);
                while (nNodes < data->u.index)
                {
                    if (strlen(data->xpath))
                    {
                        nRet = ermXmlNewString(pCtx, data->xpath, data->name, "");
                    }
                    else
                    {
                        // it's root element
                        nRet = ermXmlNewString(pCtx, "/", data->name, "");
                    }
                    
                    if (RET_ERR == nRet)
                    {
                        freeAStep(data);
                        data = NULL;
                        return RET_ERR;
                    }
                    nNodes++;
                }
            }
            break;
        case with_none_t:
        default:
            // has nothing
            nLen = snprintf(xpath, BUF_LEN, "%s/%s", data->xpath, data->name);
            if (RET_ERR == ermXmlExist(pCtx, xpath))
            {
                if (strlen(data->xpath))
                {
                    nRet = ermXmlNewString(pCtx, data->xpath, data->name, "");
                }
                else
                {
                    // it's root element
                    nRet = ermXmlNewString(pCtx, "/", data->name, "");
                }

                if (RET_ERR == nRet)
                {
                    freeAStep(data);
                    data = NULL;
                    return RET_ERR;
                }
            }
            break;
    }

    freeAStep(data);
    data = NULL;

    return nChars;
}

Here is the call graph for this function:

xmlChar* ConvertInput	(	const char *	in,
		const char *	encoding
	)

ConvertInput: : string in a given encoding : the encoding used

Converts into UTF-8 for processing with libxml2 APIs From http://www.xmlsoft.org/examples/testWriter.c

Returns the converted UTF-8 string, or NULL in case of error.

Definition at line 56 of file ermanifest.c.

{
    xmlChar *out;
    int ret;
    int size;
    int out_size;
    int temp;
    xmlCharEncodingHandlerPtr handler;

    if (in == 0)
        return 0;

    handler = xmlFindCharEncodingHandler(encoding);

    if (!handler)
    {
        TRACE("ConvertInput: no encoding handler found for '%s'\n", encoding ? encoding : "");
        return 0;
    }

    size = (int)strlen(in) + 1;
    out_size = size * 2 - 1;
    out = (unsigned char *)xmlMalloc((size_t) out_size);

    if (out != 0)
    {
        temp = size - 1;
        ret = handler->input(out, &out_size, (const xmlChar *)in, &temp);
        if ((ret < 0) || (temp - size + 1))
        {
            if (ret < 0)
            {
                TRACE("ConvertInput: conversion wasn't successful.\n");
            }
            else
            {
                TRACE("ConvertInput: conversion wasn't successful. converted: %i octets.\n", temp);
            }

            xmlFree(out);
            out = 0;
        }
        else
        {
            out = (unsigned char *)xmlRealloc(out, out_size + 1);
            out[out_size] = 0;  /*null terminating out */
        }
    }
    else
    {
        TRACE("ConvertInput: no mem\n");
    }

    return out;
}

int ermXmlCheckXpath	(	erManifest *	pCtx,
		char *	express
	)

check the xpath indicated by 'express' exists or not. if not exists, create it and its ancestors automatically, also create attributes automatically as well.

notes: only partly supports xpath

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express

Returns:

RET_OK means succeeds, otherwise returns RET_ERR

Definition at line 1391 of file ermanifest.c.

{
    int i, nChars;

    if ((NULL == pCtx) || (NULL == express))
    {
        return RET_ERR;
    }

    if (RET_OK == ermXmlExist(pCtx, express))
    {
        return RET_OK;
    }

    i = 0;
    while (express[i])
    {
        nChars = checkAStep(pCtx, express, express + i);
        if (RET_ERR == nChars)
        {
            return RET_ERR;
        }
        i += nChars;
    }

    return RET_OK;
}

Here is the call graph for this function:

int ermXmlClose

(

erManifest *

pCtx

)

Close the manifest file WITHOUT saving

Parameters:

pCtx

erManifest struct pointer initialized by ermXmlOpen

Returns:

RET_OK means close operation succeeds, otherwise returns RET_ERR

Definition at line 964 of file ermanifest.c.

{
    if (pCtx->pDoc)
    {
        xmlFreeDoc(pCtx->pDoc);
        pCtx->pDoc = NULL;
    }
    if (pCtx->pPathCtx)
    {
        xmlXPathFreeContext(pCtx->pPathCtx);
        pCtx->pPathCtx = NULL;
    }
    if (pCtx->szFileName)
    {
        free(pCtx->szFileName);
        pCtx->szFileName = NULL;
    }
    return RET_OK;
}

int ermXmlCreateFile	(	const char *	szFileName,
		erManifest *	pCtx
	)

Create a default XML file for reading/writing It will overwrite existing one.

Parameters:

	szFileName	File location
	pCtx	erManifest struct pointer

Returns:

RET_OK means open operation succeeds, otherwise returns RET_ERR

Definition at line 468 of file ermanifest.c.

{
    if (NULL == szFileName)
    {
        TRACE("szFileName pointer is empty!\n");
        return RET_ERR;
    }

    if (0 >= strlen(szFileName))
    {
        TRACE("length of szFileName is zero!\n");
        return RET_ERR;
    }

    int iRet = ermXmlCreateHandleOnly(pCtx);
    if (RET_OK == iRet)
    {
        iRet = ermXmlSaveAs(pCtx, szFileName);
    }
    if (RET_OK != iRet)
    {
        ermXmlClose(pCtx);
    }
    return iRet;
}

Here is the call graph for this function:

int ermXmlCreateHandleOnly

(

erManifest *

pCtx

)

create a new xml handle only, do not save anything till it is saved explicitly, for reading/writing.

Parameters:

pCtx

erManifest struct pointer

Returns:

RET_OK means open operation succeeds, otherwise returns RET_ERR

Definition at line 447 of file ermanifest.c.

{
    pCtx->pDoc = NULL;
    pCtx->pPathCtx = NULL;
    pCtx->szFileName = NULL;

    pCtx->pDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
    if (NULL == pCtx->pDoc)
        return RET_ERR;

    pCtx->pPathCtx = xmlXPathNewContext(pCtx->pDoc);
    if (NULL == pCtx->pPathCtx)
    {
        xmlFreeDoc(pCtx->pDoc);
        return RET_ERR;
    }

    return RET_OK;
}

int ermXmlCreateManifest	(	const char *	szContainerName,
		erManifest *	pCtx
	)

Create a default XML manifest file for reading/writing It will overwrite existing one.

Parameters:

	szContainerName	Container location
	pCtx	erManifest struct pointer

Returns:

RET_OK means open operation succeeds, otherwise returns RET_ERR

Definition at line 495 of file ermanifest.c.

{
    if (NULL == szContainerName)
    {
        TRACE("szContainerName pointer is empty!\n");
        return RET_ERR;
    }

    int n = strlen(szContainerName);
    if (0 >= n)
    {
        TRACE("length of szFileContainer is zero!\n");
        return RET_ERR;
    }

    char *szFileName = alloca(n + 1 + strlen(MANIFEST_FILENAME) + 1);
    if (NULL == szFileName)
    {
        TRACE("alloca failed!\n");
        return RET_ERR;
    }
    sprintf(szFileName, "%s/" MANIFEST_FILENAME, szContainerName);

    return ermXmlCreateFile(szFileName, pCtx);
}

Here is the call graph for this function:

int ermXmlExist	(	const erManifest *	pCtx,
		const char *	express
	)

Check an element is existing or not

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express

Returns:

RET_OK means exist otherwise returns RET_ERR

Definition at line 276 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;         // nothing

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeNr > 0 && nodes->nodeTab[0])
    {
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

void ermXmlFreeStringBuffer

(

const char *

ptr

)

Free the memory buffer allocated by ermXmlGetStringBuffer

Parameters:

ptr

the pointer returned by ermXmlGetStringBuffer

Definition at line 645 of file ermanifest.c.

{
    if (NULL == ptr)
    {
        TRACE("Attempt to free null pointer!\n");
        return;
    }
    xmlFree((xmlChar *) ptr);
}

int ermXmlGetAttributeInt	(	const erManifest *	pCtx,
		const char *	express,
		const char *	attrName,
		int *	pRet
	)

Read a int attribute from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	attrName	attribute name
	pRet	int buffer pointer used to store result

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 736 of file ermanifest.c.

{
    char tmp[INT_MAX_BUF] = { 0 };
    if (RET_OK != ermXmlGetAttributeString(pCtx, express, attrName, tmp, INT_MAX_BUF))
        return RET_ERR;
    if (1 == sscanf(tmp, "%d", pRet))
        return RET_OK;
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlGetAttributeString	(	const erManifest *	pCtx,
		const char *	express,
		const char *	attrName,
		char *	pRet,
		const int	length
	)

Read a attribute string from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	attrName	attribute name
	pRet	char buffer pointer used to store result
	length	char buffer length

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 689 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    /* read from path object */
    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeNr && nodes->nodeTab[0])
    {
        xmlChar *pSrc = xmlGetProp(nodes->nodeTab[0], attrName);
        strncpy(pRet, pSrc, length - 1);
        pRet[length - 1] = '\0';
        xmlXPathFreeObject(xpathObj);
        /* we should release the memory */
        /* http://www.xmlsoft.org/html/libxml-tree.html#xmlGetProp */
        xmlFree(pSrc);
        return RET_OK;
    }

    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

const char* ermXmlGetAttributeStringBuffer	(	const erManifest *	pCtx,
		const char *	express,
		const char *	attrName,
		int *	length
	)

Get attribute string buffer directly from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	attrName	attribute name
	length	of attribute string

Returns:

buffer pointer

Definition at line 715 of file ermanifest.c.

{
    *length = 0;
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return NULL;

    /* read from path object */
    xmlNodeSetPtr nodes = xpathObj->nodesetval;
    if (nodes && nodes->nodeNr && nodes->nodeTab[0])
    {
        xmlChar *pSrc = xmlGetProp(nodes->nodeTab[0], attrName);
        xmlXPathFreeObject(xpathObj);
        *length = xmlStrlen(pSrc);
        return pSrc;
    }

    xmlXPathFreeObject(xpathObj);
    return NULL;
}

Here is the call graph for this function:

int ermXmlGetBoolean	(	const erManifest *	pCtx,
		const char *	express,
		int *	pRet
	)

Read a boiolean from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	pRet	int buffer pointer used to store result (0=false, 1=true)

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 668 of file ermanifest.c.

{
    /* for int */
    char tmp[BOOL_MAX_BUF] = { 0 };

    if (RET_ERR == ermXmlGetString(pCtx, express, tmp, BOOL_MAX_BUF))
        return RET_ERR;

    if (0 == strcmp(tmp, "false"))
    {
        *pRet = 0;
        return RET_OK;
    }
    if (0 == strcmp(tmp, "true"))
    {
        *pRet = 1;
        return RET_OK;
    }
    return RET_ERR;
}

Here is the call graph for this function:

xmlNodePtr ermXmlGetChildNode	(	xmlNodePtr	parent,
		const char *	childName
	)

Find first child node with specified name

Parameters:

	parent	- ptr to the parent node
	childName	- name of the child node to find

Returns:

pointer to the child node, or NULL if not found

Definition at line 140 of file ermanifest.c.

{
    xmlNodePtr cur = NULL;

    //TRACE("entry: parent [%p] [%s]", parent, parent ? parent->name : NULL);
    //TRACE("entry: node [%s]", childName);

    if (parent && childName && childName[0] != '\0')
    {
        cur = parent->children;
        while (cur != NULL)
        {
            if ( xmlStrcmp(cur->name, (const xmlChar*)childName) == 0 )
            {
                //TRACE("Found child node %s", childName);
                break;          // exit while
            }
            cur = cur->next;
        }
    }
    return cur;
}

xmlNodeSetPtr ermXmlGetChildNodeSet	(	xmlNodePtr	parent,
		const char *	childName
	)

Find all child node with specified name

Parameters:

	parent	- ptr to the parent node
	childName	- name of the child node to find

Returns:

pointer to set of child nodes, must be released using xmlXPathFreeNodeSet()

Definition at line 163 of file ermanifest.c.

{
    int  i;

    xmlNodeSetPtr nodeSet = NULL;  // return value
    xmlNodePtr    cur     = NULL;

    //TRACE("entry: parent [%p] [%s]", parent, parent ? parent->name : NULL);
    //TRACE("entry: node [%s]", childName);

    // allocate space for nodeset
    nodeSet = xmlMalloc( sizeof(xmlNodeSet) );
    if (nodeSet == NULL) { return NULL; }
    nodeSet->nodeNr  = 0;
    nodeSet->nodeMax = 10;
    nodeSet->nodeTab = xmlMalloc(10 * sizeof(xmlNode));
    if (nodeSet->nodeTab == NULL) { return NULL; }
    
    if (parent && childName && childName[0] != '\0')
    {
        cur = parent->children;
        while (cur != NULL)
        {
            if ( xmlStrcmp(cur->name, (const xmlChar*)childName) == 0 )
            {
                //TRACE("Found child node %s", childName);

                // extend space for nodeset
                if (nodeSet->nodeNr >= nodeSet->nodeMax)
                {
                    i = 2 * nodeSet->nodeMax;
                    nodeSet->nodeMax = i;
                    nodeSet->nodeTab = xmlRealloc(nodeSet->nodeTab, i * sizeof(xmlNode));
                    if (nodeSet->nodeTab == NULL) { return NULL; }
                }

                // add node to nodeset
                nodeSet->nodeTab[ nodeSet->nodeNr ] = cur;
                nodeSet->nodeNr++;
            }
            cur = cur->next;
        }
    }
    return nodeSet;
}

xmlNodePtr ermXmlGetChildNodeWithAttr	(	xmlNodePtr	parent,
		const char *	nodeName,
		const char *	attrName,
		const char *	attrValue
	)

Find child node on name and attribute

Parameters:

	parent	- ptr to the parent node
	nodeName	- name of the child node to find
	attrName	- name of the attribute that must be present on the child node
	attrValue	- required value of the attribute, or NULL if don't care

Returns:

pointer to the child node, or NULL if not found

Definition at line 209 of file ermanifest.c.

{
    xmlNodePtr cur = NULL;
    xmlNodePtr ret = NULL;
    xmlChar *attr;

    //TRACE("entry: parent [%p] [%s]", parent, parent ? parent->name : NULL);
    //TRACE("entry: node [%s] attr [%s] value [%s]", nodeName, attrName, attrValue);

    if (parent && nodeName && nodeName[0] != '\0')
    {
        cur = parent->children;
        while (cur != NULL && ret == NULL)
        {
            if (xmlStrcmp(cur->name, (const xmlChar *)nodeName) == 0)
            {
                attr = xmlGetProp(cur, attrName);
                if (attr)
                {
                    if (attrValue == NULL       // attribute value not specified
                        || xmlStrcmp(attr, (const xmlChar *)attrValue) == 0)    // attribute value specified and matches
                    {
                        //TRACE("Found child node %s", nodeName);
                        ret = cur;
                    }
                    xmlFree(attr);
                }
            }
            cur = cur->next;
        }
    }
    return ret;
}

xmlNodePtr ermXmlGetChildNodeWithoutAttr	(	xmlNodePtr	parent,
		const char *	nodeName,
		const char *	attrName
	)

Find child node on name but without the specified attribute

Parameters:

	parent	- ptr to the parent node
	nodeName	- name of the child node to find
	attrName	- name of the attribute that must NOT be present on the child node

Returns:

pointer to the child node, or NULL if not found

Definition at line 243 of file ermanifest.c.

{
    xmlNodePtr cur = NULL;
    xmlNodePtr ret = NULL;
    xmlChar*   attr;

    //TRACE("entry: parent [%p] [%s]", parent, parent ? parent->name : NULL);
    //TRACE("entry: node [%s] attr [%s]", nodeName, attrName);

    if (parent && nodeName && nodeName[0] != '\0')
    {
        cur = parent->children;
        while (cur != NULL  &&  ret == NULL)
        {
            if ( xmlStrcmp(cur->name, (const xmlChar*)nodeName) == 0 )
            {
                attr = xmlGetProp(cur, attrName);
                if (attr == NULL)
                {
                    //TRACE("Found child node %s", nodeName);
                    ret = cur;
                }
                else
                {
                    xmlFree(attr);
                }
            }
            cur = cur->next;
        }
    }
    return ret;
}

const char* ermXmlGetFileName

(

const erManifest *

pCtx

)

Report XML filename

Parameters:

pCtx

erManifest struct pointer

Returns:

filename or NULL pointer

Definition at line 566 of file ermanifest.c.

{
    return pCtx->szFileName;
}

int ermXmlGetInt	(	const erManifest *	pCtx,
		const char *	express,
		int *	pRet
	)

Read a int from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	pRet	int buffer pointer used to store result

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 655 of file ermanifest.c.

{
    /* for int */
    char tmp[INT_MAX_BUF] = { 0 };

    if (RET_ERR == ermXmlGetString(pCtx, express, tmp, INT_MAX_BUF))
        return RET_ERR;

    if (1 == sscanf(tmp, "%d", pRet))
        return RET_OK;
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlGetNodeNr	(	const erManifest *	pCtx,
		const char *	express,
		int *	number
	)

Definition at line 571 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    /* read from path object */
    xmlNodeSetPtr nodes = xpathObj->nodesetval;
    if (nodes)
    {
        *number = nodes->nodeNr;
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlGetString	(	const erManifest *	pCtx,
		const char *	express,
		char *	pRet,
		const int	length
	)

Read a string from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	pRet	char buffer pointer used to store result
	length	char buffer length

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 589 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    /* read from path object */
    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeNr > 0 && nodes->nodeTab[0] && nodes->nodeTab[0]->children)
    {
        //xmlChar * content = xmlNodeGetContent(&nodes->nodeTab[0]->children[0]);
        xmlChar *content = xmlNodeGetContent(nodes->nodeTab[0]->children);

        strncpy(pRet, content, length - 1);
        pRet[length - 1] = '\0';
        xmlXPathFreeObject(xpathObj);
        /*we should release the memory, otherwise memory leak */
        xmlFree(content);
        return RET_OK;
    }
    else if (nodes && nodes->nodeNr > 0 && nodes->nodeTab[0])
    {
        pRet[0] = '\0';
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }

    TRACE("No nodes found!");
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

const char* ermXmlGetStringBuffer	(	const erManifest *	pCtx,
		const char *	express,
		int *	length
	)

Read a string from a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	length	of buffer

Returns:

content start address

Definition at line 622 of file ermanifest.c.

{
    *length = 0;
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return NULL;

    /* read from path object */
    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeNr > 0 && nodes->nodeTab[0] && nodes->nodeTab[0]->children)
    {
        xmlChar *content = xmlNodeGetContent(&nodes->nodeTab[0]->children[0]);
        *length = xmlStrlen(content);
        xmlXPathFreeObject(xpathObj);
        return (const char *)content;
    }

    TRACE("No nodes found!\n");
    xmlXPathFreeObject(xpathObj);
    return NULL;
}

Here is the call graph for this function:

int ermXmlNewBoolean	(	erManifest *	pCtx,
		const char *	parentExpress,
		const char *	name,
		const int	content
	)

Create a new boolean element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	parentExpress	XPath express
	name	the new element name
	content	the new element value (0=false, 1=true)

Returns:

RET_OK means new operation succeeds, otherwise returns RET_ERR

Definition at line 881 of file ermanifest.c.

{
    if (0 != content && 1 != content)
        return RET_ERR;

    const char *tmp = content ? "true" : "false";
    return ermXmlNewString(pCtx, parentExpress, name, tmp);
}

Here is the call graph for this function:

int ermXmlNewInt	(	erManifest *	pCtx,
		const char *	parentExpress,
		const char *	name,
		const int	content
	)

Create a new int element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	parentExpress	XPath express
	name	the new element name
	content	the new element value

Returns:

RET_OK means new operation succeeds, otherwise returns RET_ERR

Definition at line 874 of file ermanifest.c.

{
    char tmp[INT_MAX_BUF] = { 0 };
    snprintf(tmp, INT_MAX_BUF, "%d", content);
    return ermXmlNewString(pCtx, parentExpress, name, tmp);
}

Here is the call graph for this function:

int ermXmlNewString	(	const erManifest *	pCtx,
		const char *	parentExpress,
		const char *	name,
		const char *	content
	)

Create a new string element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	parentExpress	XPath express
	name	the new element name
	content	the new element value

Returns:

RET_OK means new operation succeeds, otherwise returns RET_ERR

Definition at line 850 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(parentExpress, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    /* MvdW: we need to encode special chars in the input */
    xmlChar *xmlString = xmlEncodeSpecialChars(pCtx->pDoc, (xmlChar *) content);

    if (nodes && nodes->nodeTab[0])
    {
        /*xmlNodePtr node = */ xmlNewChild(nodes->nodeTab[0],
                                           NULL, BAD_CAST name, // MvdW: this should ALSO be encoded!
                                           xmlString);
        xmlFree(xmlString);
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlOpenFile	(	const char *	szFileName,
		erManifest *	pCtx
	)

Open a XML file for reading/writing

Parameters:

	szFileName	File location
	pCtx	erManifest struct pointer

Returns:

RET_OK means open operation succeeds, otherwise returns RET_ERR

Definition at line 295 of file ermanifest.c.

{
    pCtx->pDoc = NULL;
    pCtx->pPathCtx = NULL;
    pCtx->szFileName = NULL;

    if (NULL == szFileName)
    {
        TRACE("szFileName pointer is empty!\n");
        return RET_ERR;
    }

    if (0 >= strlen(szFileName))
    {
        TRACE("length of szFileName is zero!\n");
        return RET_ERR;
    }

    pCtx->pDoc = xmlParseFile(szFileName);
    if (NULL == pCtx->pDoc)
        return RET_ERR;

    pCtx->pPathCtx = xmlXPathNewContext(pCtx->pDoc);
    if (NULL == pCtx->pPathCtx)
    {
        xmlFreeDoc(pCtx->pDoc);
        pCtx->pDoc = NULL;
        return RET_ERR;
    }

    pCtx->szFileName = strdup(szFileName);
    return RET_OK;
}

int ermXmlOpenManifest	(	const char *	szContainerName,
		erManifest *	pCtx
	)

Open a XML manifest file for reading/writing

Parameters:

	szContainerName	Container location
	pCtx	erManifest struct pointer

Returns:

RET_OK means open operation succeeds, otherwise returns RET_ERR

Definition at line 330 of file ermanifest.c.

{
    int ret;
    char *xpath;
    char buf[100];
    
    if (NULL == szContainerName)
    {
        TRACE("szContainerName pointer is empty!\n");
        return RET_ERR;
    }

    int n = strlen(szContainerName);
    if (0 >= n)
    {
        TRACE("length of szFileContainer is zero!\n");
        return RET_ERR;
    }

    char *szFileName = alloca(n + 1 + strlen(MANIFEST_FILENAME) + 1);
    if (NULL == szFileName)
    {
        TRACE("alloca failedi!\n");
        return RET_ERR;
    }
    sprintf(szFileName, "%s/" MANIFEST_FILENAME, szContainerName);

    ret = ermXmlOpenFile(szFileName, pCtx);
    if (ret == RET_OK)
    {
        // fix issues in case of old version manifest file:

        //   remove dc-metadata/Date if empty
        xpath = "/package/metadata/dc-metadata/Date";
        if (   ermXmlGetString(pCtx, xpath, buf, sizeof(buf)) == RET_OK
            && buf[0] == '\0' )
        {
            ermXmlRemoveNode(pCtx, xpath);
        }

        //   remove dc-metadata/Identified if empty
        xpath = "/package/metadata/dc-metadata/Identifier";
        if (   ermXmlGetString(pCtx, xpath, buf, sizeof(buf)) == RET_OK
            && buf[0] == '\0' )
        {
            ermXmlRemoveNode(pCtx, xpath);
        }

        //   remove dc-metadata/Type if empty
        xpath = "/package/metadata/dc-metadata/Type";
        if (   ermXmlGetString(pCtx, xpath, buf, sizeof(buf)) == RET_OK
            && buf[0] == '\0' )
        {
            ermXmlRemoveNode(pCtx, xpath);
        }

        //   remove dc-metadata/Format
        xpath = "/package/metadata/dc-metadata/Format";
        ermXmlRemoveNode(pCtx, xpath);

        //   remove dc-metadata/Language
        xpath = "/package/metadata/dc-metadata/Language";
        ermXmlRemoveNode(pCtx, xpath);
    }

    return ret;
}

Here is the call graph for this function:

int ermXmlParseBuffer	(	const char *	xmlString,
		const char *	szFileName,
		erManifest *	pCtx
	)

Definition at line 521 of file ermanifest.c.

{
    pCtx->pDoc = NULL;
    pCtx->pPathCtx = NULL;
    pCtx->szFileName = NULL;

    if (NULL == xmlString)
    {
        TRACE("xmlString pointer is empty!\n");
        return RET_ERR;
    }

    if (NULL == szFileName)
    {
        TRACE("szFileName pointer is empty!\n");
        return RET_ERR;
    }

    if (0 >= strlen(szFileName))
    {
        TRACE("length of szFileName is zero!\n");
        return RET_ERR;
    }

    pCtx->pDoc = xmlParseMemory(xmlString, strlen(xmlString));
    if (NULL == pCtx->pDoc)
    {
        TRACE("xmlParseMemory failed!\n");
        return RET_ERR;
    }

    pCtx->pPathCtx = xmlXPathNewContext(pCtx->pDoc);
    if (NULL == pCtx->pPathCtx)
    {
        TRACE("xmlXPathNewContext failed!\n");
        xmlFreeDoc(pCtx->pDoc);
        pCtx->pDoc = NULL;
        return RET_ERR;
    }

    pCtx->szFileName = strdup(szFileName);
    return RET_OK;
}

int ermXmlRemoveNode	(	erManifest *	pCtx,
		const char *	express
	)

Remove an element and its children elements

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	name	the new element name
	content	the new element value

Returns:

RET_OK means new operation succeeds, otherwise returns RET_ERR

Definition at line 891 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeTab[0])
    {
        xmlUnlinkNode(nodes->nodeTab[0]);
        xmlFreeNode(nodes->nodeTab[0]);
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlSave

(

erManifest *

pCtx

)

Save current memory XML Doc into file

Parameters:

pCtx

erManifest struct pointer initialized by ermXmlOpen

Returns:

RET_OK means save operation succeeds, otherwise returns RET_ERR

Definition at line 912 of file ermanifest.c.

{
    if (NULL == pCtx->szFileName)
    {
        TRACE("pCtx->szFileName pointer is empty!\n");
        return RET_ERR;
    }
    if (0 >= strlen(pCtx->szFileName))
    {
        TRACE("length of pCtx->szFileName is zero!\n");
        return RET_ERR;
    }

    int n = xmlSaveFileEnc(pCtx->szFileName, pCtx->pDoc, DEFAULT_ENCODING);
    sync();
    return (n >= 0) ? RET_OK : RET_ERR;
}

int ermXmlSaveAndClose

(

erManifest *

pCtx

)

Save current memory XML Doc into file and close the manifest

Parameters:

pCtx

erManifest struct pointer initialized by ermXmlOpen

Returns:

RET_OK means save operation succeeds, otherwise returns RET_ERR

Definition at line 956 of file ermanifest.c.

{
    int iRet = ermXmlSave(pCtx);
    ermXmlClose(pCtx);
    return iRet;
}

Here is the call graph for this function:

int ermXmlSaveAs	(	erManifest *	pCtx,
		const char *	szFileName
	)

Save current memory XML Doc into a specified file

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	szFileName	the file to be stored

Returns:

RET_OK means save operation succeeds, otherwise returns RET_ERR

Definition at line 931 of file ermanifest.c.

{
    if (NULL == szFileName)
    {
        TRACE("szFileName pointer is empty!\n");
        return RET_ERR;
    }

    if (0 >= strlen(szFileName))
    {
        TRACE("length of szFileName is zero!\n");
        return RET_ERR;
    }

    if (pCtx->szFileName)
    {
        free(pCtx->szFileName);
    }
    pCtx->szFileName = strdup(szFileName);

    int iRet = ermXmlSave(pCtx);
    return iRet;
}

Here is the call graph for this function:

int ermXmlSetAttributeInt	(	erManifest *	pCtx,
		const char *	express,
		const char *	attrName,
		const int	data
	)

Write or Create an attribute integer to a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	attrName	attribute name
	data	source integer data

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 842 of file ermanifest.c.

{
    char tmp[INT_MAX_BUF] = { 0 };
    snprintf(tmp, INT_MAX_BUF, "%d", data);
    return ermXmlSetAttributeString(pCtx, express, attrName, tmp, INT_MAX_BUF);
}

Here is the call graph for this function:

int ermXmlSetAttributeString	(	const erManifest *	pCtx,
		const char *	express,
		const char *	attrName,
		const char *	pSrc,
		const int	length
	)

Write or Create an attribute string to a manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	attrName	attribute name
	pSrc	char buffer pointer contains source content
	length	char buffer length

Returns:

RET_OK means get operation succeeds, otherwise returns RET_ERR

Definition at line 822 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeNr && nodes->nodeTab[0])
    {
        xmlSetProp(nodes->nodeTab[0], attrName, BAD_CAST pSrc);
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlSetBoolean	(	erManifest *	pCtx,
		const char *	express,
		const int	data
	)

Update the existing element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	data	the new boolean value (0=false, 1=true)
	length	string length

Returns:

RET_OK means set operation succeeds, otherwise returns RET_ERR

Definition at line 796 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;
    if (0 != data && 1 != data)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeTab[0])
    {
        const char *tmp = data ? "true" : "false";
        xmlNodeSetContent(nodes->nodeTab[0], tmp);

        if (nodes->nodeTab[0]->type != XML_NAMESPACE_DECL)
            nodes->nodeTab[0] = NULL;
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlSetInt	(	erManifest *	pCtx,
		const char *	express,
		const int	data
	)

Update the existing element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	data	the new integer value
	length	string length

Returns:

RET_OK means set operation succeeds, otherwise returns RET_ERR

Definition at line 773 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    if (nodes && nodes->nodeTab[0])
    {
        char tmp[INT_MAX_BUF] = { 0 };
        snprintf(tmp, INT_MAX_BUF, "%d", data);
        xmlNodeSetContent(nodes->nodeTab[0], tmp);

        if (nodes->nodeTab[0]->type != XML_NAMESPACE_DECL)
            nodes->nodeTab[0] = NULL;
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlSetString	(	erManifest *	pCtx,
		const char *	express,
		const char *	pData
	)

Update the existing element in the manifest file according to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express
	pData	the new string value (null-terminated)

Returns:

RET_OK means set operation succeeds, otherwise returns RET_ERR

Definition at line 747 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj = LocateTo(express, pCtx);
    if (NULL == xpathObj)
        return RET_ERR;

    xmlNodeSetPtr nodes = xpathObj->nodesetval;

    /* MvdW: we need to encode special chars in the input */
    xmlChar *xmlString = xmlEncodeSpecialChars(pCtx->pDoc, (xmlChar *) pData);

    if (nodes && nodes->nodeTab[0])
    {
        xmlNodeSetContent(nodes->nodeTab[0], xmlString);
        xmlFree(xmlString);

        /* See http://www.xmlsoft.org/examples/xpath2.c for detail */
        if (nodes->nodeTab[0]->type != XML_NAMESPACE_DECL)
            nodes->nodeTab[0] = NULL;
        xmlXPathFreeObject(xpathObj);
        return RET_OK;
    }
    xmlXPathFreeObject(xpathObj);
    return RET_ERR;
}

Here is the call graph for this function:

int ermXmlValidateManifest

(

erManifest *

pCtx

)

Validate manifest file against XML schema definition May modify XML to account for default values in XML schema definition

Parameters:

pCtx

erManifest struct pointer

Returns:

RET_OK when manifest validated ok, otherwise RET_ERR

Definition at line 399 of file ermanifest.c.

{
    int  retVal = RET_ERR;

    xmlSchemaParserCtxtPtr  parserCtxtPtr = NULL;
    xmlSchemaValidCtxtPtr   validCtxPtr   = NULL;  
    xmlSchemaPtr            schema        = NULL;

    int result;

    if (NULL == pCtx->pDoc)
    {
        TRACE("pCtx->pDoc pointer is empty!\n");        
        return retVal;
    }

    // get XML schema
    parserCtxtPtr = xmlSchemaNewParserCtxt(MANIFEST_SCHEMA_FILE);
    if (parserCtxtPtr)
    {
        schema = xmlSchemaParse(parserCtxtPtr);
        if (schema)
        {
            validCtxPtr = xmlSchemaNewValidCtxt(schema);
            if (validCtxPtr)
            {
                if (xmlSchemaIsValid(validCtxPtr))
                {
                    // validate XML document
                    result = xmlSchemaValidateDoc(validCtxPtr, pCtx->pDoc);
                    TRACE("ValidateDoc returns [%d] (0 == OK)\n", result);        
                    if (result == 0)
                    {
                        retVal = RET_OK;
                    }
                }
                xmlSchemaFreeValidCtxt(validCtxPtr);
            }
            xmlSchemaFree(schema);
        }
    }
    xmlSchemaFreeParserCtxt(parserCtxtPtr);

    return retVal;
}

static void freeAStep

(

a_step_t *

theStep

)

[static]

Definition at line 1022 of file ermanifest.c.

{
    if (theStep)
    {
        if (theStep->xpath)
        {
            free(theStep->xpath);
            theStep->xpath = NULL;
        }

        if (theStep->name)
        {
            free(theStep->name);
            theStep->name = NULL;
        }

        if ((theStep->type == with_attr_t) || (theStep->type == with_child_t))
        {
            if (theStep->u.pairs.name)
            {
                free(theStep->u.pairs.name);
                theStep->u.pairs.name = NULL;
            }

            if (theStep->u.pairs.value)
            {
                free(theStep->u.pairs.value);
                theStep->u.pairs.value = NULL;
            }
        }

        free(theStep);
    }
}

static void getIndex	(	const char *	begin,
		const char *	end,
		int *	index
	)			[static]

Definition at line 1134 of file ermanifest.c.

{
    char *pBuffer = NULL;
    int nLen;

    *index = 0;

    nLen = end - begin + 1;
    pBuffer = malloc(nLen + 1);
    if (pBuffer)
    {
        strncpy(pBuffer, begin, nLen);
        pBuffer[nLen] = '\0';
        *index = atoi(pBuffer);
        free(pBuffer);
        pBuffer = NULL;
    }
}

static void getNameAndValue	(	char *	beginPos,
		char *	equalPos,
		char *	endPos,
		char **	name,
		char **	value
	)			[static]

Definition at line 1102 of file ermanifest.c.

{
    char *szName = NULL, *szValue = NULL;
    int nNameLen, nValueLen;

    nNameLen = equalPos - beginPos;
    nValueLen = endPos - equalPos - 2;

    szName = (char *)malloc(nNameLen + 1);
    szValue = (char *)malloc(nValueLen + 1);

    if (szName)
    {
        strncpy(szName, beginPos, nNameLen);
        szName[nNameLen] = '\0';
    }

    if (szValue)
    {
        strncpy(szValue, equalPos + 2, nValueLen);
        szValue[nValueLen] = '\0';
    }

    *name = szName;
    *value = szValue;
}

static int lexicalizeAStep	(	char *	express,
		char *	curSlashPos,
		a_step_t *	data
	)			[static]

Definition at line 1153 of file ermanifest.c.

{
    char *nextSlashPos = NULL;
    char *beginBracketPos = NULL, *endBracketPos = NULL;
    char *atPos = NULL, *equalPos = NULL;
    int nLen = 0;

    nextSlashPos = strchr(curSlashPos + 1, '/');
    // reach the end
    if (NULL == nextSlashPos)
    {
        nextSlashPos = (express + strlen(express));
    }

    // get the positions of delimiters in one step
    calcDelimiterPositions(curSlashPos, nextSlashPos, &beginBracketPos, &atPos, &equalPos, &endBracketPos);

    // data->xpath
    nLen = curSlashPos - express;
    data->xpath = malloc(nLen + 1);
    if (NULL == data->xpath)
    {
        return RET_ERR;
    }
    snprintf(data->xpath, nLen + 1, "%s", express);
    
    if (beginBracketPos && endBracketPos)
    {
        // data->name
        nLen = beginBracketPos - (curSlashPos + 1);
        data->name = malloc(nLen + 1);
        if (NULL == data->name)
        {
            return RET_ERR;
        }
        snprintf(data->name, nLen + 1, "%s", curSlashPos + 1);

        if (atPos)
        {
            // has attribute
            data->type = with_attr_t;
            getNameAndValue(atPos + 1, equalPos, endBracketPos - 1, &data->u.pairs.name, &data->u.pairs.value);
        }
        else if (equalPos)
        {
            // has sub-element
            data->type = with_child_t;
            getNameAndValue(beginBracketPos + 1, equalPos, endBracketPos - 1,
                            &data->u.pairs.name, &data->u.pairs.value);
        }
        else
        {
            // has index
            data->type = with_index_t;
            getIndex(beginBracketPos + 1, endBracketPos - 1, &data->u.index);
        }
    }
    else
    {
        // has nothing
        data->type = with_none_t;
        nLen = nextSlashPos - (curSlashPos + 1);

        data->name = malloc(nLen + 1);
        if (NULL == data->name)
        {
            return RET_ERR;
        }
        snprintf(data->name, nLen + 1, "%s", curSlashPos + 1);
    }

    return (nextSlashPos - curSlashPos);
}

Here is the call graph for this function:

xmlXPathObjectPtr LocateTo	(	const char *	express,
		const erManifest *	pCtx
	)

Read a nodelist from a manifest file accorting to XPath express

Parameters:

	pCtx	erManifest struct pointer initialized by ermXmlOpen
	express	XPath express

Returns:

pointer to the xpath object, or NULL when not found

Definition at line 120 of file ermanifest.c.

{
    xmlXPathObjectPtr xpathObj;

    xpathObj = xmlXPathEvalExpression(BAD_CAST express, pCtx->pPathCtx);
    if (xpathObj == NULL)
    {
        TRACE("LocateTo failed! Express %s\n", express);
        return NULL;
    }
    if (xpathObj->nodesetval == NULL || xpathObj->nodesetval->nodeNr <= 0)
    {
        TRACE("LocateTo failed! no or empty xmlNodeSet");
        xmlXPathFreeObject(xpathObj);
        return NULL;
    }

    return xpathObj;
}

static a_step_t* newAStep

(

void

)

[static]

Definition at line 1012 of file ermanifest.c.

{
    a_step_t *theStep = (a_step_t *) malloc(sizeof(a_step_t));
    if (theStep)
    {
        memset(theStep, 0, sizeof(a_step_t));
    }
    return theStep;
}