tools/repo_products.c

   1 /*
   2  * repo_products.c
   3  *
   4  * Parses all files below 'proddir'
   5  * See http://en.opensuse.org/Product_Management/Code11
   6  *
   7  *
   8  * Copyright (c) 2007, 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 <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <assert.h>
  23 #include <dirent.h>
  24 #include <expat.h>
  25
  26 #include "pool.h"
  27 #include "repo.h"
  28 #include "util.h"
  29 #define DISABLE_SPLIT
  30 #include "tools_util.h"
  31 #include "repo_content.h"
  32
  33
  34 static ino_t baseproduct = 0;
  35
  36 //#define DUMPOUT 0
  37
  38 enum state {
  39   STATE_START,
  40   STATE_PRODUCT,
  41   STATE_GENERAL,
  42   STATE_VENDOR,
  43   STATE_NAME,
  44   STATE_VERSION,
  45   STATE_RELEASE,
  46   STATE_SUMMARY,
  47   STATE_DESCRIPTION,
  48   STATE_DISTRIBUTION,
  49   STATE_FLAVOR,
  50   STATE_URLS,
  51   STATE_URL,
  52   STATE_RUNTIMECONFIG,
  53   STATE_LINGUAS,
  54   STATE_LANG,
  55   NUMSTATES
  56 };
  57
  58 struct stateswitch {
  59   enum state from;
  60   char *ename;
  61   enum state to;
  62   int docontent;
  63 };
  64
  65 /* !! must be sorted by first column !! */
  66 static struct stateswitch stateswitches[] = {
  67   { STATE_START,     "product",       STATE_PRODUCT,       0 },
  68   { STATE_PRODUCT,   "general",       STATE_GENERAL,       0 },
  69   { STATE_GENERAL,   "vendor",        STATE_VENDOR,        1 },
  70   { STATE_GENERAL,   "name",          STATE_NAME,          1 },
  71   { STATE_GENERAL,   "version",       STATE_VERSION,       1 },
  72   { STATE_GENERAL,   "release",       STATE_RELEASE,       1 },
  73   { STATE_GENERAL,   "summary",       STATE_SUMMARY,       1 },
  74   { STATE_GENERAL,   "description",   STATE_DESCRIPTION,   1 },
  75   { STATE_GENERAL,   "distribution",  STATE_DISTRIBUTION,  0 },
  76   { STATE_GENERAL,   "urls",          STATE_URLS,          0 },
  77   { STATE_GENERAL,   "runtimeconfig", STATE_RUNTIMECONFIG, 0 },
  78   { STATE_GENERAL,   "linguas",       STATE_LINGUAS,       0 },
  79   { STATE_URLS,      "url",           STATE_URL,           0 },
  80   { STATE_LINGUAS,   "lang",          STATE_LANG,          0 },
  81   { NUMSTATES }
  82 };
  83
  84 struct parsedata {
  85   int depth;
  86   enum state state;
  87   int statedepth;
  88   char *content;
  89   int lcontent;
  90   int acontent;
  91   int docontent;
  92   Pool *pool;
  93   Repo *repo;
  94   Repodata *data;
  95   int datanum;
  96
  97   struct stateswitch *swtab[NUMSTATES];
  98   enum state sbtab[NUMSTATES];
  99
 100   const char *attribute; /* only print this attribute */
 101
 102   const char *tmplang;
 103   const char *tmpvers;
 104   const char *tmprel;
 105
 106   Solvable *s;
 107   Id handle;
 108
 109   Id langcache[ID_NUM_INTERNAL];
 110 };
 111
 112
 113 /*
 114  * find_attr
 115  * find value for xml attribute
 116  * I: txt, name of attribute
 117  * I: atts, list of key/value attributes
 118  * I: dup, strdup it
 119  * O: pointer to value of matching key, or NULL
 120  *
 121  */
 122
 123 static inline const char *
 124 find_attr(const char *txt, const char **atts, int dup)
 125 {
 126   for (; *atts; atts += 2)
 127     {
 128       if (!strcmp(*atts, txt))
 129         return dup ? strdup(atts[1]) : atts[1];
 130     }
 131   return 0;
 132 }
 133
 134
 135 /*
 136  * create localized tag
 137  */
 138
 139 static Id
 140 langtag(struct parsedata *pd, Id tag, const char *language)
 141 {
 142     if (language && !language[0])
 143         language = 0;
 144     if (!language || tag >= ID_NUM_INTERNAL)
 145         return pool_id2langid(pd->repo->pool, tag, language, 1);
 146     if (!pd->langcache[tag])
 147         pd->langcache[tag] = pool_id2langid(pd->repo->pool, tag, language, 1);
 148     return pd->langcache[tag];
 149 }
 150
 151
 152 /*
 153  * XML callback: startElement
 154  */
 155
 156 static void XMLCALL
 157 startElement(void *userData, const char *name, const char **atts)
 158 {
 159   struct parsedata *pd = userData;
 160   Pool *pool = pd->pool;
 161   struct stateswitch *sw;
 162
 163 #if 0
 164       fprintf(stderr, "start: [%d]%s\n", pd->state, name);
 165 #endif
 166   if (pd->depth != pd->statedepth)
 167     {
 168       pd->depth++;
 169       return;
 170     }
 171
 172   pd->depth++;
 173   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
 174     if (!strcmp(sw->ename, name))
 175       break;
 176
 177   if (sw->from != pd->state)
 178     {
 179 #if 1
 180       fprintf(stderr, "into unknown: [%d]%s (from: %d)\n", sw->to, name, sw->from);
 181       exit( 1 );
 182 #endif
 183       return;
 184     }
 185   pd->state = sw->to;
 186   pd->docontent = sw->docontent;
 187   pd->statedepth = pd->depth;
 188   pd->lcontent = 0;
 189   *pd->content = 0;
 190
 191   switch(pd->state)
 192     {
 193       case STATE_START:
 194           break;
 195     case STATE_PRODUCT:
 196       if (!pd->s)
 197         {
 198
 199           pd->s = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 200           repodata_extend(pd->data, pd->s - pool->solvables);
 201           pd->handle = repodata_get_handle(pd->data, pd->s - pool->solvables - pd->repo->start);
 202         }
 203      break;
 204
 205       /* <summary lang="xy">... */
 206     case STATE_SUMMARY:
 207       pd->tmplang = find_attr("lang", atts, 1);
 208       break;
 209     case STATE_DESCRIPTION:
 210       pd->tmplang = find_attr("lang", atts, 1);
 211       break;
 212     case STATE_DISTRIBUTION:
 213         {
 214           const char *str;
 215           if ((str = find_attr("flavor", atts, 0)))
 216             repo_set_str(pd->repo, pd->s - pool->solvables, PRODUCT_FLAVOR, str);
 217           if ((str = find_attr("target", atts, 0)))
 218             {
 219               if (pd->attribute && !strcmp(pd->attribute, "distribution.target"))
 220                   printf("%s\n", str);
 221               else
 222                   repo_set_str(pd->repo, pd->s - pool->solvables, SOLVABLE_DISTRIBUTION, str);
 223             }
 224         }
 225       break;
 226     case STATE_URLS:
 227     case STATE_URL:
 228     case STATE_RUNTIMECONFIG:
 229       default:
 230       break;
 231     }
 232   return;
 233 }
 234
 235
 236 static void XMLCALL
 237 endElement(void *userData, const char *name)
 238 {
 239   struct parsedata *pd = userData;
 240
 241 #if 0
 242       fprintf(stderr, "end: %s\n", name);
 243 #endif
 244   if (pd->depth != pd->statedepth)
 245     {
 246       pd->depth--;
 247 #if 1
 248       fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 249 #endif
 250       return;
 251     }
 252
 253   pd->depth--;
 254   pd->statedepth--;
 255
 256   switch (pd->state)
 257     {
 258     case STATE_VENDOR:
 259       pd->s->vendor = str2id(pd->pool, pd->content, 1);
 260       break;
 261     case STATE_NAME:
 262       pd->s->name = str2id(pd->pool, join2("product", ":", pd->content), 1);
 263       break;
 264     case STATE_VERSION:
 265       pd->tmpvers = strdup(pd->content);
 266       break;
 267     case STATE_RELEASE:
 268       pd->tmprel = strdup(pd->content);
 269       break;
 270     case STATE_SUMMARY:
 271       repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), pd->content);
 272       if (pd->tmplang)
 273       {
 274         free( (char *)pd->tmplang );
 275         pd->tmplang = 0;
 276       }
 277       break;
 278     case STATE_DESCRIPTION:
 279       repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), pd->content );
 280       if (pd->tmplang)
 281       {
 282         free( (char *)pd->tmplang );
 283         pd->tmplang = 0;
 284       }
 285       break;
 286     case STATE_DISTRIBUTION:
 287       break;
 288     case STATE_URL:
 289       break;
 290     case STATE_RUNTIMECONFIG:
 291       break;
 292     default:
 293       break;
 294     }
 295
 296   pd->state = pd->sbtab[pd->state];
 297   pd->docontent = 0;
 298
 299   return;
 300 }
 301
 302
 303 static void XMLCALL
 304 characterData(void *userData, const XML_Char *s, int len)
 305 {
 306   struct parsedata *pd = userData;
 307   int l;
 308   char *c;
 309   if (!pd->docontent) {
 310 #if 0
 311     char *dup = strndup( s, len );
 312   fprintf(stderr, "Content: [%d]'%s'\n", pd->state, dup );
 313   free( dup );
 314 #endif
 315     return;
 316   }
 317   l = pd->lcontent + len + 1;
 318   if (l > pd->acontent)
 319     {
 320       pd->content = realloc(pd->content, l + 256);
 321       pd->acontent = l + 256;
 322     }
 323   c = pd->content + pd->lcontent;
 324   pd->lcontent += len;
 325   while (len-- > 0)
 326     *c++ = *s++;
 327   *c = 0;
 328 }
 329
 330 #define BUFF_SIZE 8192
 331
 332
 333 /*
 334  * add single product to repo
 335  *
 336  */
 337
 338 static void
 339 repo_add_product(struct parsedata *pd, Repodata *data, FILE *fp, int code11)
 340 {
 341   Pool *pool = pd->pool;
 342   char buf[BUFF_SIZE];
 343   int i, l;
 344   struct stateswitch *sw;
 345
 346   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 347     {
 348       if (!pd->swtab[sw->from])
 349         pd->swtab[sw->from] = sw;
 350       pd->sbtab[sw->to] = sw->from;
 351     }
 352   XML_Parser parser = XML_ParserCreate(NULL);
 353   XML_SetUserData(parser, pd);
 354   XML_SetElementHandler(parser, startElement, endElement);
 355   XML_SetCharacterDataHandler(parser, characterData);
 356
 357   for (;;)
 358     {
 359       l = fread(buf, 1, sizeof(buf), fp);
 360       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 361         {
 362           fprintf(stderr, "repo_diskusagexml: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 363           exit(1);
 364         }
 365       if (l == 0)
 366         break;
 367     }
 368   XML_ParserFree(parser);
 369
 370   if (pd->s)
 371     {
 372       Solvable *s = pd->s;
 373       struct stat st;
 374       if (!fstat(fileno(fp), &st))
 375         {
 376           repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, st.st_ctime);
 377           /* this is where <productsdir>/baseproduct points to */
 378           if (st.st_ino == baseproduct)
 379             repodata_set_str(pd->data, pd->handle, PRODUCT_TYPE, "base");
 380         }
 381       else
 382         {
 383           perror("Can't stat()");
 384         }
 385
 386       if (pd->tmprel)
 387         {
 388           if (pd->tmpvers)
 389             {
 390               s->evr = makeevr(pool, join2(pd->tmpvers, "-", pd->tmprel));
 391               free((char *)pd->tmpvers);
 392               pd->tmpvers = 0;
 393             }
 394           else
 395             {
 396               fprintf(stderr, "Seen <release> but no <version>\n");
 397             }
 398           free((char *)pd->tmprel);
 399           pd->tmprel = 0;
 400         }
 401       else if (pd->tmpvers)
 402         {
 403           s->evr = makeevr(pool, pd->tmpvers); /* just version, no release */
 404           free((char *)pd->tmpvers);
 405           pd->tmpvers = 0;
 406         }
 407       if (!s->arch)
 408         s->arch = ARCH_NOARCH;
 409       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 410         {
 411           s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 412         }
 413     } /* if pd->s */
 414   return;
 415 }
 416
 417
 418 /*
 419  * parse dir looking for files ending in suffix
 420  */
 421
 422 static void
 423 parse_dir(DIR *dir, const char *path, struct parsedata *pd, Repodata *repodata, int code11)
 424 {
 425   struct dirent *entry;
 426   char *suffix = code11 ? ".xml" : "-release";
 427   int slen = code11 ? 4 : 8;  /* strlen(".xml") : strlen("-release") */
 428   struct stat st;
 429
 430   /* check for <productsdir>/baseproduct on code11 and remember its target inode */
 431   if (code11
 432       && stat(join2(path, "/", "baseproduct"), &st) == 0) /* follow symlink */
 433     {
 434       baseproduct = st.st_ino;
 435     }
 436
 437   while ((entry = readdir(dir)))
 438     {
 439       int len;
 440       len = strlen(entry->d_name);
 441
 442       /* skip /etc/lsb-release, thats not a product per-se */
 443       if (!code11
 444           && strcmp(entry->d_name, "lsb-release") == 0)
 445         {
 446           continue;
 447         }
 448
 449       if (len > slen
 450           && strcmp(entry->d_name+len-slen, suffix) == 0)
 451         {
 452           char *fullpath = join2(path, "/", entry->d_name);
 453           FILE *fp = fopen(fullpath, "r");
 454           if (!fp)
 455             {
 456               perror(fullpath);
 457               break;
 458             }
 459           repo_add_product(pd, repodata, fp, code11);
 460           fclose(fp);
 461         }
 462     }
 463 }
 464
 465
 466 /*
 467  * read all installed products
 468  *
 469  * try proddir (reading all .xml files from this directory) first
 470  * if not available, assume non-code11 layout and parse /etc/xyz-release
 471  *
 472  * parse each one as a product
 473  */
 474
 475 void
 476 repo_add_products(Repo *repo, Repodata *repodata, const char *proddir, const char *root, const char *attribute)
 477 {
 478   const char *fullpath = proddir;
 479   int code11 = 1;
 480   DIR *dir = opendir(fullpath);
 481   struct parsedata pd;
 482
 483   memset(&pd, 0, sizeof(pd));
 484   pd.repo = repo;
 485   pd.pool = repo->pool;
 486   pd.data = repo_add_repodata(pd.repo, 0);
 487
 488   pd.content = malloc(256);
 489   pd.acontent = 256;
 490
 491   pd.attribute = attribute;
 492
 493   if (!dir)
 494     {
 495       fullpath = root ? join2(root, "", "/etc") : "/etc";
 496       dir = opendir(fullpath);
 497       code11 = 0;
 498     }
 499   if (!dir)
 500     {
 501       perror(fullpath);
 502     }
 503   else
 504     {
 505       parse_dir(dir, fullpath, &pd, repodata, code11);
 506     }
 507
 508   if (pd.data)
 509     repodata_internalize(pd.data);
 510
 511   free(pd.content);
 512   join_freemem();
 513   closedir(dir);
 514 }
 515
 516 /* EOF */