lib/base/nxml.cpp

   1 #include <lib/base/nconfig.h>
   2 #include <string.h>
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include <config.h>
   6 #endif
   7
   8 #ifdef HAVE_TIME_H
   9 #include <time.h>
  10 #endif
  11
  12 #ifdef HAVE_LIBXML2
  13 #include <libxml/tree.h>
  14 #include <libxml/parser.h>
  15 #include <libxml/parserInternals.h>
  16 #else
  17 #define xmlChar char
  18 #endif /* HAVE_LIBXML2 */
  19
  20 #define DE(x)           ((struct nc_de_s *) (data+(x)))
  21 #define IDE(x, y)       (DE(((unsigned *) (data+(x)->offset))[(y)]))
  22 #define XML_DE          ((const xmlChar *) "dirEntry")
  23 #define XML_NS          ((const xmlChar *) "http://hq.alert.sk/projects/nconfig")
  24 #define XML_ROOT        ((const xmlChar *) "NConfigExport")
  25
  26 static char *encodeXml(const char *what)
  27 {
  28         unsigned p = 0, size = 6*strlen(what)+1;
  29         char *ret = (char *)malloc(size);
  30         for (; *what; what++) {
  31                 switch (*what) {
  32                 case '"':
  33                         ret[p++] = '&';
  34                         ret[p++] = 'q';
  35                         ret[p++] = 'u';
  36                         ret[p++] = 'o';
  37                         ret[p++] = 't';
  38                         ret[p++] = ';';
  39                         continue;
  40                 case '>':
  41                         ret[p++] = '&';
  42                         ret[p++] = 'q';
  43                         ret[p++] = 't';
  44                         ret[p++] = ';';
  45                         continue;
  46                 case '<':
  47                         ret[p++] = '&';
  48                         ret[p++] = 'l';
  49                         ret[p++] = 't';
  50                         ret[p++] = ';';
  51                         continue;
  52                 case '&':
  53                         ret[p++] = '&';
  54                         ret[p++] = 'a';
  55                         ret[p++] = 'm';
  56                         ret[p++] = 'p';
  57                         ret[p++] = ';';
  58                         continue;
  59                 }
  60                 if (*what >= 0x20 || *what == '\n' || *what == '\r' || *what == '\t')
  61                         ret[p++] = *what;
  62                 else
  63                         p += sprintf(ret+p, "&#%d;", *what);
  64         }
  65         ret[p] = '\0';
  66         return ret;
  67 }
  68
  69 void NConfig::store(nc_de_s *de, FILE *f)
  70 {
  71         struct nc_de_s *cc;
  72         for (unsigned i=0; i<de->pages; i++)
  73                 if ((cc = IDE(de, i))->type) {
  74                         char *encname = encodeXml(data+cc->name);
  75                         fprintf(f, "<nc:%s name=\"%s\" type=\"%d\" value=\"", XML_DE, encname, cc->type);
  76                         free(encname);
  77                         switch (cc->type) {
  78                         case NC_DIR:
  79                                 fprintf(f, "%u\">\n", cc->pages);
  80                                 store(cc, f);
  81                                 fprintf(f, "</nc:%s>\n", XML_DE);
  82                                 break;
  83                         case NC_STRING:
  84                                 fprintf(f, "%s\"/>\n", encname = encodeXml(data+cc->offset));
  85                                 free(encname);
  86                                 break;
  87                         case NC_INT:
  88                                 fprintf(f, "%lld\"/>\n", *((signed long long *) (data+cc->offset)));
  89                                 break;
  90                         case NC_UINT:
  91                                 fprintf(f, "%llu\"/>\n", *((unsigned long long *) (data+cc->offset)));
  92                                 break;
  93                         case NC_DOUBLE:
  94                                 fprintf(f, "%La\"/>\n", *((long double *) (data+cc->offset)));
  95                                 break;
  96                         case NC_RAW:
  97                                 {
  98                                         const char *raw = data+cc->offset;
  99                                         for (unsigned j=0; j<cc->pages; j++)
 100                                                 fprintf(f, "%d%d%d", raw[j] / 100, (raw[j] % 100) / 10, raw[j] % 10);
 101                                         fprintf(f, "\"/>\n");
 102                                 }
 103                         }
 104                 }
 105 }
 106
 107 int NConfig::toXML(const char *filename)
 108 {
 109         if (fd < 0)
 110                 return NC_ERR_NFILE;
 111
 112         FILE *f = fopen(filename, "w");
 113         if (!f)
 114                 return NC_ERR_PERM;
 115
 116         fprintf(f, "%s", "<?xml version=\"1.0\"?>\n");
 117         fprintf(f, "<nc:%s xmlns:nc=\"%s\" libVersion=\"%s\"", XML_ROOT, XML_NS, VERSION);
 118 #ifdef HAVE_TIME_H
 119     time_t t = time(NULL);
 120     char *tim = ctime(&t);
 121     tim[strlen(tim)-1] = 0;
 122         fprintf(f, " time=\"%s\"", tim);
 123 #endif /* HAVE_TIME_H */
 124         fprintf(f, ">\n");
 125         lockFile(NC_L_RO);
 126
 127         store(rdir, f);
 128
 129         unLockFile();
 130         fprintf(f, "</nc:%s>\n", XML_ROOT);
 131         fclose(f);
 132         return NC_ERR_OK;
 133 }
 134
 135 #ifdef HAVE_LIBXML2
 136 static xmlSAXHandler sh;
 137 enum stateEnum {noRoot = 0, inRoot, inDir, inEnt, unknown};
 138
 139 struct ncParseState {
 140         stateEnum state, pState;
 141         xmlChar *ns;
 142         unsigned depth;
 143         unsigned unDepth;
 144         unsigned force;
 145         NConfig *which;
 146 };
 147
 148 static int ncXmlSAXParseFile(xmlSAXHandlerPtr sax, void *user_data, const char *filename)
 149 {
 150         int ret = 0;
 151         xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename);
 152         if (!ctxt)
 153                 return -1;
 154         ctxt->sax = sax;
 155         ctxt->userData = user_data;
 156         xmlParseDocument(ctxt);
 157         ret = ctxt->wellFormed ? 0 : -1;
 158         if (sax)
 159                 ctxt->sax = NULL;
 160         xmlFreeParserCtxt(ctxt);
 161         return ret;
 162 }
 163
 164 static xmlEntityPtr ncXmlGetEntity(void *user_data, const CHAR *name)
 165 {
 166         return xmlGetPredefinedEntity(name);
 167 }
 168
 169 static void ncXmlStartElement(void *user_data, const CHAR *name, const CHAR **attrs)
 170 {
 171         struct ncParseState *p = (struct ncParseState *)user_data;
 172 #ifdef NC_DEBUG_XML
 173         fprintf(stderr, "New element %s state=%d %s\n", name, p->state, p->ns);
 174 #endif
 175         if (p->state == unknown) {
 176                 p->unDepth++;
 177                 return;
 178         }
 179         if (p->state == noRoot) {
 180                 while (*attrs) {
 181                         if (!xmlStrncmp(*attrs, (const xmlChar *) "xmlns:", 6)) {
 182                                 if (!xmlStrcmp(attrs[1], XML_NS)) {
 183                                         p->ns = xmlStrdup((*attrs)+6);
 184                                         break;
 185                                 }
 186                         }
 187                         attrs += 2;
 188                 }
 189                 char *b = (char *) malloc(xmlStrlen(p->ns)+xmlStrlen(XML_ROOT)+2);
 190                 sprintf(b, "%s:%s", p->ns, XML_ROOT);
 191                 if (xmlStrcmp(name, (xmlChar *)b)) {
 192 #ifdef NC_DEBUG_XML
 193                         fprintf(stderr, "NewElement, entering unknown %s\n", name);
 194 #endif
 195                         p->pState = p->state;
 196                         p->state = unknown;
 197                 } else
 198                         p->state = inRoot;
 199                 free(b);
 200                 return;
 201         }
 202         if (p->state == inRoot || p->state == inDir) {
 203                 const xmlChar *value = NULL, *n = NULL;
 204                 int type = 0;
 205                 while (*attrs) {
 206                         if (!xmlStrcmp(*attrs, (const xmlChar *)"value"))
 207                                 value = attrs[1];
 208                         if (!xmlStrcmp(*attrs, (const xmlChar *)"name"))
 209                                 n = attrs[1];
 210                         if (!xmlStrcmp(*attrs, (const xmlChar *)"type"))
 211                                 type = atoi(attrs[1]);
 212                         attrs += 2;
 213                 }
 214 #ifdef NC_DEBUG_XML
 215                 fprintf(stderr, "%s %s %s %d %d\n", name, n, value, type, p->state);
 216 #endif
 217                 char *b = (char *) malloc(xmlStrlen(p->ns)+xmlStrlen(XML_DE)+2);
 218                 sprintf(b, "%s:%s", p->ns, XML_DE);
 219                 if (xmlStrcmp(name, (xmlChar *)b) || !type || !value || !n) {
 220 #ifdef NC_DEBUG_XML
 221                         fprintf(stderr, "NewElement, entering unknown on mismatch\n");
 222 #endif
 223                         p->pState = p->state;
 224                         p->state = unknown;
 225                         free(b);
 226                         return;
 227                 }
 228                 free(b);
 229                 if (p->force)
 230                         p->which->delKey((const char *)n);
 231
 232                 switch (type) {
 233                 case NC_DIR:
 234                         if (p->which->createDir((const char *)n, strtoul((const char *)value, NULL, 0)) != NC_ERR_OK) {
 235                                 p->pState = p->state;
 236                                 p->state = unknown;
 237 #ifdef NC_DEBUG_XML
 238                                 fprintf(stderr, "NewElement, entering unknown on failed mkdir\n");
 239 #endif
 240                                 return;
 241                         }
 242                         p->which->chDir((const char *)n);
 243                         break;
 244                 case NC_STRING:
 245                         p->which->setKey((const char *)n, (const char *)value);
 246                         break;
 247                 case NC_INT:
 248                         p->which->setKey((const char *)n, strtoll((const char *)value, NULL, 0));
 249                         break;
 250                 case NC_UINT:
 251                         p->which->setKey((const char *)n, strtoull((const char *)value, NULL, 0));
 252                         break;
 253                 case NC_DOUBLE:
 254                         {
 255                                 long double c;
 256                                 sscanf((const char *)value, "%La", &c);
 257                                 p->which->setKey((const char *)n, c);
 258                         }
 259                         break;
 260                 case NC_RAW:
 261                         {
 262                                 unsigned size = xmlStrlen(value) / 3;
 263                                 char *dec = NULL;
 264                                 if (size) {
 265                                         dec = (char *)malloc(size);
 266                                         for (unsigned i=0, k=0; i<size; i++, k += 3)
 267                                                 dec[i] = value[k] * 100 + value[k+1] * 10 + value[k+2];
 268                                 }
 269                                 p->which->setKey((const char *)n, dec, size);
 270                                 free(dec);
 271                         }
 272                 }
 273                 if (type == NC_DIR) {
 274                         p->state = inDir;
 275                         p->depth++;
 276                 } else {
 277                         p->pState = p->state;
 278                         p->state = inEnt;
 279                 }
 280                 return;
 281         }
 282 }
 283
 284 static void ncXmlEndElement(void *user_data, const CHAR *name)
 285 {
 286         struct ncParseState *p = (struct ncParseState *)user_data;
 287 #ifdef NC_DEBUG_XML
 288         fprintf(stderr, "EndElement %s %s %d\n", name, p->ns, p->state);
 289 #endif
 290         if (p->state == inEnt) {
 291                 p->state = p->pState;
 292                 return;
 293         }
 294         if (p->state == unknown) {
 295                 if (p->unDepth)
 296                         p->unDepth--;
 297                 else
 298                         p->state = p->pState;
 299                 return;
 300         }
 301         if (p->state == inRoot) {
 302                 p->state = noRoot;
 303                 free(p->ns);
 304                 p->ns = NULL;
 305                 return;
 306         }
 307         if (p->state == inDir) {
 308                 p->depth--;
 309                 if (!p->depth)
 310                         p->state = inRoot;
 311                 p->which->chDir("..");
 312         }
 313 }
 314 #endif /* HAVE_LIBXML2 */
 315
 316 int NConfig::fromXML(const char *filename, int force)
 317 {
 318         if (fd < 0)
 319                 return NC_ERR_NFILE;
 320         if (omode != NC_O_RW)
 321                 return NC_ERR_PERM;
 322 #ifndef HAVE_LIBXML2
 323         return NC_ERR_NOSUPPORT;
 324 #else
 325         struct ncParseState state = { noRoot, noRoot, NULL, 0, 0, force, this };
 326         sh.getEntity = ncXmlGetEntity;
 327         sh.startElement = ncXmlStartElement;
 328         sh.endElement = ncXmlEndElement;
 329
 330         lockFile(NC_L_RW);
 331         cdir = rdir;
 332         int ret = ncXmlSAXParseFile(&sh, &state, filename);
 333         cdir = rdir;
 334         unLockFile();
 335
 336         return ret < 0 ? NC_ERR_NVAL : NC_ERR_OK;
 337 #endif /* HAVE_LIBXML2 */
 338 }
 339