Return to xml.c CVS log

Up to [truecrypt] / truecrypt / common

Annotation of truecrypt/common/xml.c, revision 1.1

1.1     ! root        1: /* 
        !             2: Copyright (c) 2004-2005 TrueCrypt Foundation. All rights reserved. 
        !             3: 
        !             4: Covered by TrueCrypt License 2.0 the full text of which is contained in the file
        !             5: License.txt included in TrueCrypt binary and source code distribution archives. 
        !             6: */
        !             7: 
        !             8: #include <windows.h>
        !             9: #include <stdio.h>
        !            10: #include "Xml.h"
        !            11: 
        !            12: 
        !            13: static BOOL BeginsWith (char *string, char *subString)
        !            14: {
        !            15:        while (*string++ == *subString++)
        !            16:        {
        !            17:                if (*subString == 0) return TRUE;
        !            18:                if (*string == 0) return FALSE;
        !            19:        }
        !            20: 
        !            21:        return FALSE;
        !            22: }
        !            23: 
        !            24: 
        !            25: char *XmlNextNode (char *xmlNode)
        !            26: {
        !            27:        char *t = xmlNode + 1;
        !            28:        while ((t = strchr (t, '<')) != NULL)
        !            29:        {
        !            30:                if (t[1] != '/')
        !            31:                        return t;
        !            32: 
        !            33:                t++;
        !            34:        }
        !            35: 
        !            36:        return NULL;
        !            37: }
        !            38: 
        !            39: 
        !            40: char *XmlFindElement (char *xmlNode, char *nodeName)
        !            41: {
        !            42:        char *t = xmlNode;
        !            43:        size_t nameLen = strlen (nodeName);
        !            44: 
        !            45:        do
        !            46:        {
        !            47:                if (BeginsWith (t + 1, nodeName)
        !            48:                        && (t[nameLen + 1] == '>'
        !            49:                        || t[nameLen + 1] == ' ')) return t;
        !            50: 
        !            51:        } while (t = XmlNextNode (t));
        !            52: 
        !            53:        return NULL;
        !            54: }
        !            55: 
        !            56: 
        !            57: char *XmlFindElementByAttributeValue (char *xml, char *nodeName, char *attrName, char *attrValue)
        !            58: {
        !            59:        char attr[2048];
        !            60: 
        !            61:        while (xml = XmlFindElement (xml, nodeName))
        !            62:        {
        !            63:                XmlAttribute (xml, attrName, attr, sizeof (attr));
        !            64:                if (strcmp (attr, attrValue) == 0)
        !            65:                        return xml;
        !            66: 
        !            67:                xml++;
        !            68:        }
        !            69: 
        !            70:        return NULL;
        !            71: }
        !            72: 
        !            73: 
        !            74: char *XmlAttribute (char *xmlNode, char *xmlAttrName, char *xmlAttrValue, int xmlAttrValueSize)
        !            75: {
        !            76:        char *t = xmlNode;
        !            77:        char *e = xmlNode;
        !            78:        int l = 0;
        !            79: 
        !            80:        xmlAttrValue[0] = 0;
        !            81:        if (t[0] != '<') return NULL;
        !            82: 
        !            83:        e = strchr (e, '>');
        !            84:        if (e == NULL) return NULL;
        !            85: 
        !            86:        while ((t = strstr (t, xmlAttrName)) && t < e)
        !            87:        {
        !            88:                char *o = t + strlen (xmlAttrName);
        !            89:                if (t[-1] == ' '
        !            90:                        &&
        !            91:                        (BeginsWith (o, "=\"")
        !            92:                        || BeginsWith (o, "= \"")
        !            93:                        || BeginsWith (o, " =\"")
        !            94:                        || BeginsWith (o, " = \""))
        !            95:                        )
        !            96:                        break;
        !            97: 
        !            98:                t++;
        !            99:        }
        !           100: 
        !           101:        if (t == NULL || t > e) return NULL;
        !           102: 
        !           103:        t = strchr (t, '"') + 1;
        !           104:        e = strchr (t, '"');
        !           105:        l = (int)(e - t);
        !           106:        if (e == NULL || l > xmlAttrValueSize) return NULL;
        !           107: 
        !           108:        memcpy (xmlAttrValue, t, l);
        !           109:        xmlAttrValue[l] = 0;
        !           110: 
        !           111:        return xmlAttrValue;
        !           112: }
        !           113: 
        !           114: 
        !           115: char *XmlNodeText (char *xmlNode, char *xmlText, int xmlTextSize)
        !           116: {
        !           117:        char *t = xmlNode;
        !           118:        char *e = xmlNode + 1;
        !           119:        int l = 0, i = 0, j = 0;
        !           120: 
        !           121:        xmlText[0] = 0;
        !           122: 
        !           123:        if (t[0] != '<')
        !           124:                return NULL;
        !           125: 
        !           126:        t = strchr (t, '>') + 1;
        !           127:        if (t == NULL) return NULL;
        !           128: 
        !           129:        e = strchr (e, '<');
        !           130:        if (e == NULL) return NULL;
        !           131: 
        !           132:        l = (int)(e - t);
        !           133:        if (e == NULL || l > xmlTextSize) return NULL;
        !           134: 
        !           135:        while (i < l)
        !           136:        {
        !           137:                if (BeginsWith (&t[i], "&lt;"))
        !           138:                {
        !           139:                        xmlText[j++] = '<';
        !           140:                        i += 4;
        !           141:                        continue;
        !           142:                }
        !           143:                if (BeginsWith (&t[i], "&gt;"))
        !           144:                {
        !           145:                        xmlText[j++] = '>';
        !           146:                        i += 4;
        !           147:                        continue;
        !           148:                }
        !           149:                if (BeginsWith (&t[i], "&amp;"))
        !           150:                {
        !           151:                        xmlText[j++] = '&';
        !           152:                        i += 5;
        !           153:                        continue;
        !           154:                }
        !           155:                xmlText[j++] = t[i++];
        !           156:        }
        !           157:        xmlText[j] = 0;
        !           158: 
        !           159:        return t;
        !           160: }
        !           161: 
        !           162: 
        !           163: int XmlWriteHeader (FILE *file)
        !           164: {
        !           165:        return fputs ("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<TrueCrypt>", file);
        !           166: }
        !           167: 
        !           168: 
        !           169: int XmlWriteFooter (FILE *file)
        !           170: {
        !           171:        return fputs ("\n</TrueCrypt>", file);
        !           172: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.