ext/repo_zyppdb.c

   1 /*
   2  * repo_zyppdb.c
   3  *
   4  * Parses legacy /var/lib/zypp/db/products/... files.
   5  * They are old (pre Code11) product descriptions. See bnc#429177
   6  *
   7  *
   8  * Copyright (c) 2008, Novell Inc.
   9  *
  10  * This program is licensed under the BSD license, read LICENSE.BSD
  11  * for further information
  12  */
  13
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16 #include <unistd.h>
  17 #include <limits.h>
  18 #include <fcntl.h>
  19 #include <ctype.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <dirent.h>
  25 #include <expat.h>
  26
  27 #include "pool.h"
  28 #include "repo.h"
  29 #include "util.h"
  30 #define DISABLE_SPLIT
  31 #include "tools_util.h"
  32 #include "repo_content.h"
  33
  34
  35 //#define DUMPOUT 0
  36
  37 enum state {
  38   STATE_START,           // 0
  39   STATE_PRODUCT,         // 1
  40   STATE_NAME,            // 2
  41   STATE_VERSION,         // 3
  42   STATE_ARCH,            // 4
  43   STATE_SUMMARY,         // 5
  44   STATE_VENDOR,          // 6
  45   STATE_INSTALLTIME,     // 7
  46   NUMSTATES              // 0
  47 };
  48
  49 struct stateswitch {
  50   enum state from;
  51   char *ename;
  52   enum state to;
  53   int docontent;
  54 };
  55
  56 /* !! must be sorted by first column !! */
  57 static struct stateswitch stateswitches[] = {
  58   { STATE_START,     "product",       STATE_PRODUCT,       0 },
  59   { STATE_PRODUCT,   "name",          STATE_NAME,          1 },
  60   { STATE_PRODUCT,   "version",       STATE_VERSION,       0 },
  61   { STATE_PRODUCT,   "arch",          STATE_ARCH,          1 },
  62   { STATE_PRODUCT,   "summary",       STATE_SUMMARY,       1 },
  63   { STATE_PRODUCT,   "install-time",  STATE_INSTALLTIME,   1 },
  64   { STATE_PRODUCT,   "vendor",        STATE_VENDOR,        1 },
  65   { NUMSTATES }
  66 };
  67
  68 struct parsedata {
  69   int depth;
  70   enum state state;
  71   int statedepth;
  72   char *content;
  73   int lcontent;
  74   int acontent;
  75   int docontent;
  76   Pool *pool;
  77   Repo *repo;
  78   Repodata *data;
  79
  80   struct stateswitch *swtab[NUMSTATES];
  81   enum state sbtab[NUMSTATES];
  82   struct joindata jd;
  83
  84   const char *tmplang;
  85
  86   Solvable *solvable;
  87   Id handle;
  88 };
  89
  90
  91 /*
  92  * find_attr
  93  * find value for xml attribute
  94  * I: txt, name of attribute
  95  * I: atts, list of key/value attributes
  96  * I: dup, strdup it
  97  * O: pointer to value of matching key, or NULL
  98  *
  99  */
 100
 101 static inline const char *
 102 find_attr(const char *txt, const char **atts, int dup)
 103 {
 104   for (; *atts; atts += 2)
 105     {
 106       if (!strcmp(*atts, txt))
 107         return dup ? solv_strdup(atts[1]) : atts[1];
 108     }
 109   return 0;
 110 }
 111
 112
 113 /*
 114  * XML callback: startElement
 115  */
 116
 117 static void XMLCALL
 118 startElement(void *userData, const char *name, const char **atts)
 119 {
 120   struct parsedata *pd = userData;
 121   Pool *pool = pd->pool;
 122   Solvable *s = pd->solvable;
 123   struct stateswitch *sw;
 124
 125 #if 0
 126   fprintf(stderr, "start: [%d]%s\n", pd->state, name);
 127 #endif
 128   if (pd->depth != pd->statedepth)
 129     {
 130       pd->depth++;
 131       return;
 132     }
 133
 134   pd->depth++;
 135   if (!pd->swtab[pd->state])    /* no statetable -> no substates */
 136     {
 137 #if 0
 138       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
 139 #endif
 140       return;
 141     }
 142   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
 143     if (!strcmp(sw->ename, name))
 144       break;
 145
 146   if (sw->from != pd->state)
 147     {
 148 #if 0
 149       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
 150 #endif
 151       return;
 152     }
 153   pd->state = sw->to;
 154   pd->docontent = sw->docontent;
 155   pd->statedepth = pd->depth;
 156   pd->lcontent = 0;
 157   *pd->content = 0;
 158
 159   switch(pd->state)
 160     {
 161     case STATE_PRODUCT:
 162       {
 163         /* parse 'type' */
 164         const char *type = find_attr("type", atts, 0);
 165         s = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 166         repodata_extend(pd->data, s - pool->solvables);
 167         pd->handle = s - pool->solvables;
 168         if (type)
 169           repodata_set_str(pd->data, pd->handle, PRODUCT_TYPE, type);
 170       }
 171       break;
 172     case STATE_VERSION:
 173       {
 174         const char *ver = find_attr("ver", atts, 0);
 175         const char *rel = find_attr("rel", atts, 0);
 176         /* const char *epoch = find_attr("epoch", atts, 1); ignored */
 177         s->evr = makeevr(pd->pool, join2(&pd->jd, ver, "-", rel));
 178       }
 179       break;
 180       /* <summary lang="xy">... */
 181     case STATE_SUMMARY:
 182       pd->tmplang = find_attr("lang", atts, 1);
 183       break;
 184     default:
 185       break;
 186     }
 187 }
 188
 189
 190 static void XMLCALL
 191 endElement(void *userData, const char *name)
 192 {
 193   struct parsedata *pd = userData;
 194   Solvable *s = pd->solvable;
 195
 196 #if 0
 197   fprintf(stderr, "end: [%d]%s\n", pd->state, name);
 198 #endif
 199   if (pd->depth != pd->statedepth)
 200     {
 201       pd->depth--;
 202 #if 0
 203       fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 204 #endif
 205       return;
 206     }
 207
 208   pd->depth--;
 209   pd->statedepth--;
 210
 211   switch (pd->state)
 212     {
 213     case STATE_PRODUCT:
 214       if (!s->arch)
 215         s->arch = ARCH_NOARCH;
 216       if (!s->evr)
 217         s->evr = ID_EMPTY;
 218       if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 219         s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
 220       pd->solvable = 0;
 221       break;
 222     case STATE_NAME:
 223       s->name = pool_str2id(pd->pool, join2(&pd->jd, "product", ":", pd->content), 1);
 224       break;
 225     case STATE_ARCH:
 226       s->arch = pool_str2id(pd->pool, pd->content, 1);
 227       break;
 228     case STATE_SUMMARY:
 229       repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_SUMMARY, pd->tmplang, 1), pd->content);
 230       pd->tmplang = solv_free((void *)pd->tmplang);
 231       break;
 232     case STATE_VENDOR:
 233       s->vendor = pool_str2id(pd->pool, pd->content, 1);
 234       break;
 235     case STATE_INSTALLTIME:
 236       repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, atol(pd->content));
 237     default:
 238       break;
 239     }
 240
 241   pd->state = pd->sbtab[pd->state];
 242   pd->docontent = 0;
 243
 244 #if 0
 245   fprintf(stderr, "end: [%s] -> %d\n", name, pd->state);
 246 #endif
 247 }
 248
 249
 250 static void XMLCALL
 251 characterData(void *userData, const XML_Char *s, int len)
 252 {
 253   struct parsedata *pd = userData;
 254   int l;
 255   char *c;
 256   if (!pd->docontent)
 257     return;
 258   l = pd->lcontent + len + 1;
 259   if (l > pd->acontent)
 260     {
 261       pd->content = realloc(pd->content, l + 256);
 262       pd->acontent = l + 256;
 263     }
 264   c = pd->content + pd->lcontent;
 265   pd->lcontent += len;
 266   while (len-- > 0)
 267     *c++ = *s++;
 268   *c = 0;
 269 }
 270
 271 #define BUFF_SIZE 8192
 272
 273
 274 /*
 275  * add single product to repo
 276  *
 277  */
 278
 279 static void
 280 add_zyppdb_product(struct parsedata *pd, FILE *fp)
 281 {
 282   char buf[BUFF_SIZE];
 283   int l;
 284
 285   XML_Parser parser = XML_ParserCreate(NULL);
 286   XML_SetUserData(parser, pd);
 287   XML_SetElementHandler(parser, startElement, endElement);
 288   XML_SetCharacterDataHandler(parser, characterData);
 289
 290   for (;;)
 291     {
 292       l = fread(buf, 1, sizeof(buf), fp);
 293       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 294         {
 295           pool_debug(pd->pool, SOLV_ERROR, "repo_zyppdb: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 296           return;
 297         }
 298       if (l == 0)
 299         break;
 300     }
 301   XML_ParserFree(parser);
 302 }
 303
 304
 305 /*
 306  * read all installed products
 307  *
 308  * parse each one as a product
 309  */
 310
 311 void
 312 repo_add_zyppdb_products(Repo *repo, const char *dirpath, int flags)
 313 {
 314   int i;
 315   struct parsedata pd;
 316   struct stateswitch *sw;
 317   struct dirent *entry;
 318   char *fullpath;
 319   DIR *dir;
 320   FILE *fp;
 321   Repodata *data;
 322
 323   data = repo_add_repodata(repo, flags);
 324   memset(&pd, 0, sizeof(pd));
 325   pd.repo = repo;
 326   pd.pool = repo->pool;
 327   pd.data = data;
 328
 329   pd.content = malloc(256);
 330   pd.acontent = 256;
 331
 332   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 333     {
 334       if (!pd.swtab[sw->from])
 335         pd.swtab[sw->from] = sw;
 336       pd.sbtab[sw->to] = sw->from;
 337     }
 338
 339   dir = opendir(dirpath);
 340   if (dir)
 341     {
 342       while ((entry = readdir(dir)))
 343         {
 344           if (strlen(entry->d_name) < 3)
 345             continue;   /* skip '.' and '..' */
 346           fullpath = join2(&pd.jd, dirpath, "/", entry->d_name);
 347           if ((fp = fopen(fullpath, "r")) == 0)
 348             {
 349               perror(fullpath);
 350               continue;
 351             }
 352           add_zyppdb_product(&pd, fp);
 353           fclose(fp);
 354         }
 355     }
 356   closedir(dir);
 357
 358   solv_free((void *)pd.tmplang);
 359   free(pd.content);
 360   join_freemem(&pd.jd);
 361   if (!(flags & REPO_NO_INTERNALIZE))
 362     repodata_internalize(data);
 363 }
 364
 365 /* EOF */