tools/rpmxml.c

Go to the documentation of this file.

#include "system.h"
const char *__progname;

#include <rpmlib.h>
#define _RPMXP_INTERNAL
#include "rpmxp.h"
#include "debug.h"

int _rpmxp_debug = 0;

const char * rpmxpDTD = "\
<?xml version=\"1.0\"?>\n\
<!DOCTYPE rpmHeader [\n\
<!ELEMENT rpmHeader (rpmTag+)>\n\
<!ELEMENT rpmTag        (string+|integer+|base64+)>\n\
<!ATTLIST rpmTag name   CDATA #REQUIRED>\n\
<!ELEMENT string        (#PCDATA)>\n\
<!ELEMENT integer       (#PCDATA)>\n\
<!ELEMENT base64        (#PCDATA)>\n\
]>\n\
";

rpmxp rpmxpFree(rpmxp xp)
{
    if (xp != NULL) {
        if (xp->value) {
            xmlFree(xp->value);
            xp->value = NULL;
        }
        if (xp->name) {
            xmlFree(xp->name);
            xp->name = NULL;
        }
        if (xp->reader != NULL) {
            xmlFreeTextReader(xp->reader);
            xp->reader = NULL;
        }
        free(xp);
        xp = NULL;
    }
    return xp;
}

rpmxp rpmxpNew(const char * fn)
{
    rpmxp xp = calloc(1, sizeof(*xp));

    if (xp == NULL)
        return NULL;
    if (fn) {
        int xx;
        xp->reader = xmlNewTextReaderFilename(fn);
        if (xp->reader == NULL)
            return rpmxpFree(xp);
        xx = xmlTextReaderSetParserProp(xp->reader, XML_PARSER_VALIDATE, 1);
        xx = xmlTextReaderSetParserProp(xp->reader, XML_PARSER_SUBST_ENTITIES, 1);
    }
    xp->name = NULL;
    xp->value = NULL;
    xp->depth = 0;
    xp->nodeType = 0;
    xp->isEmptyElement = 0;
    xp->n = 2;
    return xp;
}

static headerTagTableEntry myTagByName(headerTagTableEntry tbl, const char * name)
{
    int x = (strncmp(name, "RPMTAG_", (sizeof("RPMTAG_")-1))
                ? (sizeof("RPMTAG_")-1) : 0);

    for (; tbl->name != NULL; tbl++) {
        if (!xstrcasecmp(tbl->name+x, name))
            return tbl;
    }
    return NULL;
}

int rpmxpRead(rpmxp xp)
{
    return xmlTextReaderRead(xp->reader);
}

int rpmxpProcess(rpmxp xp)
{
    int rc = 0;

    xp->name = xmlTextReaderName(xp->reader);
    xp->value = xmlTextReaderValue(xp->reader);
    xp->depth = xmlTextReaderDepth(xp->reader);
    xp->nodeType = xmlTextReaderNodeType(xp->reader);
    xp->isEmptyElement = xmlTextReaderIsEmptyElement(xp->reader);

    if (xp->name == NULL)
        xp->name = xmlStrdup(BAD_CAST "--");

if (_rpmxp_debug)
printf("%d %d %s %d\n", xp->depth, xp->nodeType, xp->name, xp->isEmptyElement);
    switch (xp->nodeType) {
    case XML_READER_TYPE_ELEMENT:
        printf("%*s<%s", (xp->n * xp->depth), "", xp->name);
        while (xmlTextReaderMoveToNextAttribute(xp->reader) != 0) {
            xmlChar * attrN = xmlTextReaderName(xp->reader);
            xmlChar * attrV = xmlTextReaderValue(xp->reader);
            printf(" %s", attrN);
            if (attrV) {
                printf("=\"%s\"", attrV);
                if (!strcmp(xp->name, "rpmTag") && !strcmp(attrN, "name")) {
                    /* XXX rpmSTagTable gonna be needed. */
                    xp->tte = myTagByName(rpmTagTable, attrV);
                }
                xmlFree(attrV);
            }
            xmlFree(attrN);
        }
        if (xp->isEmptyElement) {
            printf("/>\n");
            if (xp->h && xp->tte) {
                headerTagTableEntry tte = xp->tte;
                if (!strcmp(xp->name, "string")) {
                    const char * nstr = "";
                    (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &nstr, 1);
                } else
                if (!strcmp(xp->name, "integer")) {
                    int i = 0;
                    (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &i, 1);
                }
            }
        } else {
            printf(">");
            if (xp->depth < 2)
                printf("\n");
        }
        if (!strcmp(xp->name, "rpmHeader")) {
            xp->h = headerNew();
        }
        break;
    case XML_READER_TYPE_END_ELEMENT:
        if (xp->depth < 2)
            printf("%*s", (xp->n * xp->depth), "");
        printf("</%s>\n", xp->name);
        if (!strcmp(xp->name, "rpmHeader")) {
            if (xp->h) {
                FD_t fdo = Fopen("time.xmlhdr", "w.ufdio");
                if (fdo != NULL) {
                    headerWrite(fdo, xp->h, HEADER_MAGIC_YES);
                    Fclose(fdo);
                }
            }
            xp->h = headerFree(xp->h);
        } else
        if (!strcmp(xp->name, "rpmTag")) {
            xp->tte = NULL;
        }
        break;
    case XML_READER_TYPE_TEXT:
        printf("%s", xp->value);
        if (xp->h && xp->tte) {
            headerTagTableEntry tte = xp->tte;
            switch (tte->type) {
            case RPM_NULL_TYPE:
            {
            }   break;
            case RPM_CHAR_TYPE:
            {   char c = xp->value[0];
                (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &c, 1);
            }   break;
            case RPM_INT8_TYPE:
            {   int_8 i = strtol(xp->value, NULL, 0);
                (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &i, 1);
            }   break;
            case RPM_INT16_TYPE:
            {   int_16 i = strtol(xp->value, NULL, 0);
                (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &i, 1);
            }   break;
            case RPM_INT32_TYPE:
            {   int_32 i = strtoll(xp->value, NULL, 0);
                (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &i, 1);
            }   break;
            case RPM_STRING_TYPE:
            {   const char * s = xp->value;
                (void) headerAddEntry(xp->h, tte->val, tte->type, s, 1);
            }   break;
            case RPM_BIN_TYPE:
            {   const char * s = xp->value;
                void * b;
                size_t nb;
                b64decode(s, &b, &nb);
                (void) headerAddEntry(xp->h, tte->val, tte->type, b, nb);
            }   break;
            case RPM_STRING_ARRAY_TYPE:
            {   const char * s = xp->value;
                (void) headerAddOrAppendEntry(xp->h, tte->val, tte->type, &s, 1);
            }   break;
            case RPM_I18NSTRING_TYPE:
            {   const char * s = xp->value;
                (void) headerAddI18NString(xp->h, tte->val, s, "C");
            }   break;
            default:
                break;
            }
        }
        break;
    case XML_READER_TYPE_DOCUMENT_TYPE:
        break;
    case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
        break;

    case XML_READER_TYPE_NONE:
    case XML_READER_TYPE_ATTRIBUTE:
    case XML_READER_TYPE_CDATA:
    case XML_READER_TYPE_ENTITY_REFERENCE:
    case XML_READER_TYPE_ENTITY:
    case XML_READER_TYPE_PROCESSING_INSTRUCTION:
    case XML_READER_TYPE_COMMENT:
    case XML_READER_TYPE_DOCUMENT:
    case XML_READER_TYPE_DOCUMENT_FRAGMENT:
    case XML_READER_TYPE_NOTATION:
    case XML_READER_TYPE_WHITESPACE:
    case XML_READER_TYPE_END_ENTITY:
    case XML_READER_TYPE_XML_DECLARATION:
    default:
        printf("%d %d %s %d\n", xp->depth, xp->nodeType,
                xp->name, xp->isEmptyElement);
        if (xp->value)
            printf(" %s", xp->value);
        if (xp->depth < 2)
            printf("\n");
        rc = -1;
        break;
    }

    if (xp->value != NULL) {
        xmlFree(xp->value);
        xp->value = NULL;
    }
    if (xp->name != NULL) {
        xmlFree(xp->name);
        xp->name = NULL;
    }
    return rc;
}

int rpmxpParseFile(rpmxp xp)
{
    int ret = -1;

    if (xp != NULL)
    while ((ret = rpmxpRead(xp)) == 1)
        rpmxpProcess(xp);
    return ret;
}

int main(int argc, char ** argv)
{
    const char * fn = "time.xml";
    rpmxp xp;
    int ec = 0;

    xp = rpmxpNew(fn);
    rpmxpParseFile(xp);
    xp = rpmxpFree(xp);

    return ec;
}

---