c60b7271e7b288bf537519784dee78a32d7030db
[platform/upstream/libsolv.git] / 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) 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 #include "repo_zyppdb.h"
34
35
36 //#define DUMPOUT 0
37
38 enum state {
39   STATE_START,           // 0
40   STATE_PRODUCT,         // 1
41   STATE_VENDOR,          // 2
42   STATE_NAME,            // 3
43   STATE_VERSION,         // 4
44   STATE_RELEASE,         // 5
45   STATE_ARCH,            // 6
46   STATE_SUMMARY,         // 7
47   STATE_DESCRIPTION,     // 8
48   STATE_UPDATEREPOKEY,   // 9 should go away
49   STATE_CPEID,         // 9
50   STATE_URLS,            // 10
51   STATE_URL,             // 11
52   STATE_RUNTIMECONFIG,   // 12
53   STATE_LINGUAS,         // 13
54   STATE_LANG,            // 14
55   STATE_REGISTER,        // 15
56   STATE_TARGET,          // 16
57   STATE_REGRELEASE,      // 18
58   STATE_PRODUCTLINE,     // 19
59   NUMSTATES              // 0
60 };
61
62 struct stateswitch {
63   enum state from;
64   char *ename;
65   enum state to;
66   int docontent;
67 };
68
69 /* !! must be sorted by first column !! */
70 static struct stateswitch stateswitches[] = {
71   { STATE_START,     "product",       STATE_PRODUCT,       0 },
72   { STATE_PRODUCT,   "vendor",        STATE_VENDOR,        1 },
73   { STATE_PRODUCT,   "name",          STATE_NAME,          1 },
74   { STATE_PRODUCT,   "version",       STATE_VERSION,       1 },
75   { STATE_PRODUCT,   "release",       STATE_RELEASE,       1 },
76   { STATE_PRODUCT,   "arch",          STATE_ARCH,          1 },
77   { STATE_PRODUCT,   "productline",   STATE_PRODUCTLINE,   1 },
78   { STATE_PRODUCT,   "summary",       STATE_SUMMARY,       1 },
79   { STATE_PRODUCT,   "description",   STATE_DESCRIPTION,   1 },
80   { STATE_PRODUCT,   "register",      STATE_REGISTER,      0 },
81   { STATE_PRODUCT,   "urls",          STATE_URLS,          0 },
82   { STATE_PRODUCT,   "runtimeconfig", STATE_RUNTIMECONFIG, 0 },
83   { STATE_PRODUCT,   "linguas",       STATE_LINGUAS,       0 },
84   { STATE_PRODUCT,   "updaterepokey", STATE_UPDATEREPOKEY, 1 },
85   { STATE_PRODUCT,   "cpename",       STATE_CPEID,         1 },
86   { STATE_URLS,      "url",           STATE_URL,           1 },
87   { STATE_LINGUAS,   "lang",          STATE_LANG,          0 },
88   { STATE_REGISTER,  "target",        STATE_TARGET,        1 },
89   { STATE_REGISTER,  "release",       STATE_REGRELEASE,    1 },
90   { NUMSTATES }
91 };
92
93 struct parsedata {
94   int depth;
95   enum state state;
96   int statedepth;
97   char *content;
98   int lcontent;
99   int acontent;
100   int docontent;
101   Pool *pool;
102   Repo *repo;
103   Repodata *data;
104
105   struct stateswitch *swtab[NUMSTATES];
106   enum state sbtab[NUMSTATES];
107   const char *attribute; /* only print this attribute, if currentproduct == baseproduct */
108
109   const char *tmplang;
110
111   const char *tmpvers;
112   const char *tmprel;
113   const char *tmpurltype;
114
115   unsigned int ctime;
116
117   Solvable *solvable;
118   Id handle;
119
120   ino_t baseproduct;
121   ino_t currentproduct;
122   int productscheme;
123
124   Id langcache[ID_NUM_INTERNAL];
125 };
126
127
128 /*
129  * find_attr
130  * find value for xml attribute
131  * I: txt, name of attribute
132  * I: atts, list of key/value attributes
133  * I: dup, strdup it
134  * O: pointer to value of matching key, or NULL
135  *
136  */
137
138 static inline const char *
139 find_attr(const char *txt, const char **atts, int dup)
140 {
141   for (; *atts; atts += 2)
142     {
143       if (!strcmp(*atts, txt))
144         return dup ? strdup(atts[1]) : atts[1];
145     }
146   return 0;
147 }
148
149
150 /*
151  * create localized tag
152  */
153
154 static Id
155 langtag(struct parsedata *pd, Id tag, const char *language)
156 {
157   if (language && !language[0])
158     language = 0;
159   if (!language || tag >= ID_NUM_INTERNAL)
160     return pool_id2langid(pd->repo->pool, tag, language, 1);
161   if (!pd->langcache[tag])
162     pd->langcache[tag] = pool_id2langid(pd->repo->pool, tag, language, 1);
163   return pd->langcache[tag];
164 }
165
166
167 /*
168  * XML callback: startElement
169  */
170
171 static void XMLCALL
172 startElement(void *userData, const char *name, const char **atts)
173 {
174   struct parsedata *pd = userData;
175   Pool *pool = pd->pool;
176   Solvable *s = pd->solvable;
177   struct stateswitch *sw;
178
179 #if 0
180       fprintf(stderr, "start: [%d]%s\n", pd->state, name);
181 #endif
182   if (pd->depth != pd->statedepth)
183     {
184       pd->depth++;
185       return;
186     }
187
188   pd->depth++;
189   if (!pd->swtab[pd->state])    /* no statetable -> no substates */
190     {
191 #if 0
192       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
193 #endif
194       return;
195     }
196   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
197     if (!strcmp(sw->ename, name))
198       break;
199
200   if (sw->from != pd->state)
201     {
202 #if 0
203       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
204 #endif
205       return;
206     }
207   pd->state = sw->to;
208   pd->docontent = sw->docontent;
209   pd->statedepth = pd->depth;
210   pd->lcontent = 0;
211   *pd->content = 0;
212
213   switch(pd->state)
214     {
215     case STATE_PRODUCT:
216       /* parse 'schemeversion' and store in global variable */
217       {
218         const char * scheme = find_attr("schemeversion", atts, 0);
219         pd->productscheme = (scheme && *scheme) ? atoi(scheme) : -1;
220       }
221       if (!s)
222         {
223           s = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
224           repodata_extend(pd->data, s - pool->solvables);
225           pd->handle = repodata_get_handle(pd->data, (s - pool->solvables) - pd->repo->start);
226         }
227       break;
228
229       /* <summary lang="xy">... */
230     case STATE_SUMMARY:
231       pd->tmplang = find_attr("lang", atts, 1);
232       break;
233     case STATE_DESCRIPTION:
234       pd->tmplang = find_attr("lang", atts, 1);
235       break;
236     case STATE_URL:
237       pd->tmpurltype = find_attr("name", atts, 1);
238       break;
239     default:
240       break;
241     }
242 }
243
244
245 static void XMLCALL
246 endElement(void *userData, const char *name)
247 {
248   struct parsedata *pd = userData;
249   Solvable *s = pd->solvable;
250
251 #if 0
252       fprintf(stderr, "end: [%d]%s\n", pd->state, name);
253 #endif
254   if (pd->depth != pd->statedepth)
255     {
256       pd->depth--;
257 #if 0
258       fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
259 #endif
260       return;
261     }
262
263   pd->depth--;
264   pd->statedepth--;
265
266   switch (pd->state)
267     {
268     case STATE_PRODUCT:
269       /* product done, finish solvable */
270       if (pd->ctime)
271         repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, pd->ctime);
272
273       /* this is where <productsdir>/baseproduct points to */
274       if (pd->currentproduct == pd->baseproduct)
275         repodata_set_str(pd->data, pd->handle, PRODUCT_TYPE, "base");
276
277       if (pd->tmprel)
278         {
279           if (pd->tmpvers)
280             s->evr = makeevr(pd->pool, join2(pd->tmpvers, "-", pd->tmprel));
281           else
282             {
283               fprintf(stderr, "Seen <release> but no <version>\n");
284             }
285         }
286       else if (pd->tmpvers)
287         s->evr = makeevr(pd->pool, pd->tmpvers); /* just version, no release */
288       pd->tmpvers = sat_free((void *)pd->tmpvers);
289       pd->tmprel = sat_free((void *)pd->tmprel);
290       if (!s->arch)
291         s->arch = ARCH_NOARCH;
292       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
293         s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
294       pd->solvable = 0;
295       break;
296     case STATE_VENDOR:
297       s->vendor = str2id(pd->pool, pd->content, 1);
298       break;
299     case STATE_NAME:
300       s->name = str2id(pd->pool, join2("product", ":", pd->content), 1);
301       break;
302     case STATE_VERSION:
303       pd->tmpvers = strdup(pd->content);
304       break;
305     case STATE_RELEASE:
306       pd->tmprel = strdup(pd->content);
307       break;
308     case STATE_ARCH:
309       s->arch = str2id(pd->pool, pd->content, 1);
310       break;
311     case STATE_PRODUCTLINE:
312       repodata_set_str(pd->data, pd->handle, PRODUCT_PRODUCTLINE, pd->content);
313     break;
314     case STATE_UPDATEREPOKEY:
315       repodata_set_str(pd->data, pd->handle, langtag(pd, PRODUCT_UPDATEREPOKEY, pd->tmplang), pd->content);
316       break;
317     case STATE_SUMMARY:
318       repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), pd->content);
319       pd->tmplang = sat_free((void *)pd->tmplang);
320       break;
321     case STATE_DESCRIPTION:
322       repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), pd->content );
323       pd->tmplang = sat_free((void *)pd->tmplang);
324       break;
325     case STATE_URL:
326       if (pd->tmpurltype)
327         {
328           repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
329           repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, str2id(pd->pool, pd->tmpurltype, 1));
330         }
331       pd->tmpurltype = sat_free((void *)pd->tmpurltype);
332       break;
333     case STATE_TARGET:
334       repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_TARGET, pd->content);
335       if (pd->currentproduct == pd->baseproduct
336           && pd->attribute
337           && !strcmp(pd->attribute, "register.target"))
338         {
339           printf("%s\n", pd->content);
340         }
341     break;
342     case STATE_REGRELEASE:
343       repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_RELEASE, pd->content);
344       if (pd->currentproduct == pd->baseproduct
345           && pd->attribute
346           && !strcmp(pd->attribute, "register.release"))
347         {
348           printf("%s\n", pd->content);
349         }
350     break;
351     case STATE_CPEID:
352       if (pd->content)
353         repodata_set_str(pd->data, pd->handle, SOLVABLE_CPE_ID, pd->content);
354     default:
355       break;
356     }
357
358   pd->state = pd->sbtab[pd->state];
359   pd->docontent = 0;
360
361 #if 0
362       fprintf(stderr, "end: [%s] -> %d\n", name, pd->state);
363 #endif
364 }
365
366
367 static void XMLCALL
368 characterData(void *userData, const XML_Char *s, int len)
369 {
370   struct parsedata *pd = userData;
371   int l;
372   char *c;
373   if (!pd->docontent) {
374 #if 0
375     char *dup = strndup( s, len );
376   fprintf(stderr, "Content: [%d]'%s'\n", pd->state, dup );
377   free( dup );
378 #endif
379     return;
380   }
381   l = pd->lcontent + len + 1;
382   if (l > pd->acontent)
383     {
384       pd->content = realloc(pd->content, l + 256);
385       pd->acontent = l + 256;
386     }
387   c = pd->content + pd->lcontent;
388   pd->lcontent += len;
389   while (len-- > 0)
390     *c++ = *s++;
391   *c = 0;
392 }
393
394 #define BUFF_SIZE 8192
395
396
397 /*
398  * add single product to repo
399  *
400  */
401
402 static void
403 repo_add_product(struct parsedata *pd, Repodata *data, FILE *fp, int code11)
404 {
405   char buf[BUFF_SIZE];
406   int l;
407   struct stat st;
408
409   if (!fstat(fileno(fp), &st))
410     {
411       pd->currentproduct = st.st_ino;
412       pd->ctime = (unsigned int)st.st_ctime;
413     }
414   else
415     {
416       pd->currentproduct = pd->baseproduct + 1; /* make it != baseproduct if stat fails */
417       perror("fstat");
418       pd->ctime = 0;
419     }
420
421   if (code11)
422     {
423       XML_Parser parser = XML_ParserCreate(NULL);
424       XML_SetUserData(parser, pd);
425       XML_SetElementHandler(parser, startElement, endElement);
426       XML_SetCharacterDataHandler(parser, characterData);
427
428       for (;;)
429         {
430           l = fread(buf, 1, sizeof(buf), fp);
431           if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
432             {
433               fprintf(stderr, "repo_products: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
434               exit(1);
435             }
436           if (l == 0)
437             break;
438         }
439       XML_ParserFree(parser);
440     }
441   else
442     {
443       Id name = 0;
444       Id arch = 0;
445       Id version = 0;
446       int lnum = 0; /* line number */
447       char *ptr, *ptr1;
448       /* parse /etc/<xyz>-release file */
449       while (fgets(buf, sizeof(buf), fp))
450         {
451           /* remove trailing \n */
452           int l = strlen(buf);
453           if (*(buf + l - 1) == '\n')
454             {
455               --l;
456               *(buf + l) = 0;
457             }
458           ++lnum;
459
460           if (lnum == 1)
461             {
462               /* 1st line, <name> [(<arch>)] */
463               ptr = strchr(buf, '(');
464               if (ptr)
465                 {
466                   ptr1 = ptr - 1;
467                   *ptr++ = 0;
468                 }
469               else
470                 ptr1 = buf + l - 1;
471
472               /* track back until non-blank, non-digit */
473               while (ptr1 > buf
474                      && (*ptr1 == ' ' || isdigit(*ptr1) || *ptr1 == '.'))
475                 --ptr1;
476               *(++ptr1) = 0;
477               name = str2id(pd->pool, join2("product", ":", buf), 1);
478
479               if (ptr)
480                 {
481                   /* have arch */
482                   char *ptr1 = strchr(ptr, ')');
483                   if (ptr1)
484                     {
485                       *ptr1 = 0;
486                       /* downcase arch */
487                       ptr1 = ptr;
488                       while (*ptr1)
489                         {
490                           if (isupper(*ptr1)) *ptr1 = tolower(*ptr1);
491                           ++ptr1;
492                         }
493                       arch = str2id(pd->pool, ptr, 1);
494                     }
495                 }
496             }
497           else if (strncmp(buf, "VERSION", 7) == 0)
498             {
499               ptr = strchr(buf+7, '=');
500               if (ptr)
501                 {
502                   while (*++ptr == ' ');
503                   version = makeevr(pd->pool, ptr);
504                 }
505             }
506         }
507       if (name)
508         {
509           Solvable *s = pd->solvable = pool_id2solvable(pd->pool, repo_add_solvable(pd->repo));
510           s->name = name;
511           if (version)
512             s->evr = version;
513           if (arch)
514             s->arch = arch;
515           if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
516             s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
517         }
518     }
519   return;
520 }
521
522
523
524 /*
525  * parse dir looking for files ending in suffix
526  */
527
528 static void
529 parse_dir(DIR *dir, const char *path, struct parsedata *pd, Repodata *repodata, int code11)
530 {
531   struct dirent *entry;
532   char *suffix = code11 ? ".prod" : "-release";
533   int slen = code11 ? 5 : 8;  /* strlen(".prod") : strlen("-release") */
534   struct stat st;
535
536   /* check for <productsdir>/baseproduct on code11 and remember its target inode */
537   if (code11
538       && stat(join2(path, "/", "baseproduct"), &st) == 0) /* follow symlink */
539     {
540       pd->baseproduct = st.st_ino;
541     }
542   else
543     pd->baseproduct = 0;
544
545   while ((entry = readdir(dir)))
546     {
547       int len;
548       len = strlen(entry->d_name);
549
550       /* skip /etc/lsb-release, thats not a product per-se */
551       if (!code11
552           && strcmp(entry->d_name, "lsb-release") == 0)
553         {
554           continue;
555         }
556
557       if (len > slen
558           && strcmp(entry->d_name + len - slen, suffix) == 0)
559         {
560           char *fullpath = join2(path, "/", entry->d_name);
561           FILE *fp = fopen(fullpath, "r");
562           if (!fp)
563             {
564               perror(fullpath);
565               break;
566             }
567           repo_add_product(pd, repodata, fp, code11);
568           fclose(fp);
569         }
570     }
571 }
572
573
574 /*
575  * read all installed products
576  *
577  * try proddir (reading all .xml files from this directory) first
578  * if not available, assume non-code11 layout and parse /etc/xyz-release
579  *
580  * parse each one as a product
581  */
582
583 void
584 repo_add_products(Repo *repo, Repodata *repodata, const char *proddir, const char *root, const char *attribute)
585 {
586   const char *fullpath = proddir;
587   DIR *dir;
588   int i;
589   struct parsedata pd;
590   struct stateswitch *sw;
591
592   memset(&pd, 0, sizeof(pd));
593   pd.repo = repo;
594   pd.pool = repo->pool;
595   pd.data = repodata;
596
597   pd.content = malloc(256);
598   pd.acontent = 256;
599
600   pd.attribute = attribute;
601
602   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
603     {
604       if (!pd.swtab[sw->from])
605         pd.swtab[sw->from] = sw;
606       pd.sbtab[sw->to] = sw->from;
607     }
608
609   dir = opendir(fullpath);
610   if (dir)
611     {
612       parse_dir(dir, fullpath, &pd, repodata, 1); /* assume 'code11' products */
613       closedir(dir);
614     }
615   else
616     {
617       fullpath = root ? join2(root, "", "/var/lib/zypp/db/products") : "/var/lib/zypp/db/products";
618       dir = opendir(fullpath);
619       if (dir)
620         {
621           repo_add_zyppdb_products(repo, repodata, fullpath, dir); /* assume 'code10' zypp-style products */
622           closedir(dir);
623         }
624       else
625         {
626           fullpath = root ? join2(root, "", "/etc") : "/etc";
627           dir = opendir(fullpath);
628           if (dir)
629             {
630               parse_dir(dir, fullpath, &pd, repodata, 0); /* fall back to /etc/<xyz>-release parsing */
631               closedir(dir);
632             }
633           else
634             {
635               perror(fullpath);
636             }
637         }
638     }
639
640   sat_free((void *)pd.tmplang);
641   free(pd.content);
642   join_freemem();
643
644 }
645
646 /* EOF */