Make more C89 and POSIX compliant
[platform/upstream/libsolv.git] / ext / repo_rpmmd.c
1 /*
2  * Copyright (c) 2007, Novell Inc.
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7
8 #include <sys/types.h>
9 #include <limits.h>
10 #include <fcntl.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <expat.h>
15
16 #include "pool.h"
17 #include "repo.h"
18 #define DISABLE_SPLIT
19 #include "tools_util.h"
20 #include "repo_rpmmd.h"
21 #include "chksum.h"
22
23
24 enum state {
25   STATE_START,
26
27   STATE_SOLVABLE,
28
29   STATE_NAME,
30   STATE_ARCH,
31   STATE_VERSION,
32
33   // package rpm-md
34   STATE_LOCATION,
35   STATE_CHECKSUM,
36   STATE_RPM_GROUP,
37   STATE_RPM_LICENSE,
38
39   /* resobject attributes */
40   STATE_SUMMARY,
41   STATE_DESCRIPTION,
42   STATE_DISTRIBUTION,
43   STATE_PACKAGER,
44   STATE_URL,
45   STATE_INSNOTIFY,
46   STATE_DELNOTIFY,
47   STATE_VENDOR,
48   STATE_SIZE,
49   STATE_TIME,
50   STATE_DOWNLOADSIZE,
51   STATE_INSTALLTIME,
52   STATE_INSTALLONLY,
53
54   /* Novell/SUSE extended attributes */
55   STATE_EULA,
56   STATE_KEYWORD,
57   STATE_DISKUSAGE,
58   STATE_DIRS,
59   STATE_DIR,
60
61   /* patch */
62   STATE_ID,
63   STATE_TIMESTAMP,
64   STATE_AFFECTSPKG,
65   STATE_REBOOTNEEDED,
66
67   // pattern attributes
68   STATE_CATEGORY, /* pattern and patches */
69   STATE_ORDER,
70   STATE_INCLUDES,
71   STATE_INCLUDESENTRY,
72   STATE_EXTENDS,
73   STATE_EXTENDSENTRY,
74   STATE_SCRIPT,
75   STATE_ICON,
76   STATE_USERVISIBLE,
77   STATE_DEFAULT,
78   STATE_INSTALL_TIME,
79
80   /* product */
81   STATE_SHORTNAME,
82   STATE_DISTNAME, // obsolete
83   STATE_DISTEDITION, // obsolete
84   STATE_SOURCE,
85   STATE_TYPE,
86   STATE_RELNOTESURL,
87   STATE_UPDATEURL,
88   STATE_OPTIONALURL,
89   STATE_FLAG,
90
91   /* rpm-md dependencies inside the
92      format tag */
93   STATE_PROVIDES,
94   STATE_REQUIRES,
95   STATE_OBSOLETES,
96   STATE_CONFLICTS,
97   STATE_RECOMMENDS,
98   STATE_SUPPLEMENTS,
99   STATE_SUGGESTS,
100   STATE_ENHANCES,
101   STATE_FRESHENS,
102   STATE_SOURCERPM,
103   STATE_HEADERRANGE,
104
105   STATE_PROVIDESENTRY,
106   STATE_REQUIRESENTRY,
107   STATE_OBSOLETESENTRY,
108   STATE_CONFLICTSENTRY,
109   STATE_RECOMMENDSENTRY,
110   STATE_SUPPLEMENTSENTRY,
111   STATE_SUGGESTSENTRY,
112   STATE_ENHANCESENTRY,
113   STATE_FRESHENSENTRY,
114
115   STATE_FILE,
116
117   // general
118   NUMSTATES
119 };
120
121 struct stateswitch {
122   enum state from;
123   char *ename;
124   enum state to;
125   int docontent;
126 };
127
128 static struct stateswitch stateswitches[] = {
129   /** fake tag used to enclose 2 different xml files in one **/
130   { STATE_START,       "rpmmd",           STATE_START,    0 },
131
132   /** tags for different package data, we just ignore the tag **/
133   { STATE_START,       "metadata",        STATE_START,    0 },
134   { STATE_START,       "otherdata",       STATE_START,    0 },
135   { STATE_START,       "filelists",       STATE_START,    0 },
136   { STATE_START,       "diskusagedata",   STATE_START,    0 },
137   { STATE_START,       "susedata",        STATE_START,    0 },
138
139   { STATE_START,       "product",         STATE_SOLVABLE, 0 },
140   { STATE_START,       "pattern",         STATE_SOLVABLE, 0 },
141   { STATE_START,       "patch",           STATE_SOLVABLE, 0 },
142   { STATE_START,       "package",         STATE_SOLVABLE, 0 },
143
144   { STATE_SOLVABLE,    "name",            STATE_NAME, 1 },
145   { STATE_SOLVABLE,    "arch",            STATE_ARCH, 1 },
146   { STATE_SOLVABLE,    "version",         STATE_VERSION, 0 },
147
148   // package attributes rpm-md
149   { STATE_SOLVABLE,    "location",        STATE_LOCATION, 0 },
150   { STATE_SOLVABLE,    "checksum",        STATE_CHECKSUM, 1 },
151
152   /* resobject attributes */
153
154   { STATE_SOLVABLE,    "summary",         STATE_SUMMARY,      1 },
155   { STATE_SOLVABLE,    "description",     STATE_DESCRIPTION,  1 },
156   { STATE_SOLVABLE,    "distribution",    STATE_DISTRIBUTION, 1 },
157   { STATE_SOLVABLE,    "url",             STATE_URL,          1 },
158   { STATE_SOLVABLE,    "packager",        STATE_PACKAGER,     1 },
159   //{ STATE_SOLVABLE,    "???",         STATE_INSNOTIFY, 1 },
160   //{ STATE_SOLVABLE,    "??",     STATE_DELNOTIFY, 1 },
161   { STATE_SOLVABLE,    "vendor",          STATE_VENDOR,       1 },
162   { STATE_SOLVABLE,    "size",            STATE_SIZE,         0 },
163   { STATE_SOLVABLE,    "archive-size",    STATE_DOWNLOADSIZE, 1 },
164   { STATE_SOLVABLE,    "install-time",    STATE_INSTALLTIME,  1 },
165   { STATE_SOLVABLE,    "install-only",    STATE_INSTALLONLY,  1 },
166   { STATE_SOLVABLE,    "time",            STATE_TIME,         0 },
167
168   /* extended Novell/SUSE attributes (susedata.xml) */
169   { STATE_SOLVABLE,    "eula",            STATE_EULA,         1 },
170   { STATE_SOLVABLE,    "keyword",         STATE_KEYWORD,      1 },
171   { STATE_SOLVABLE,    "diskusage",       STATE_DISKUSAGE,    0 },
172
173   // pattern attribute
174   { STATE_SOLVABLE,    "script",          STATE_SCRIPT,        1 },
175   { STATE_SOLVABLE,    "icon",            STATE_ICON,          1 },
176   { STATE_SOLVABLE,    "uservisible",     STATE_USERVISIBLE,   1 },
177   { STATE_SOLVABLE,    "category",        STATE_CATEGORY,      1 },
178   { STATE_SOLVABLE,    "order",           STATE_ORDER,         1 },
179   { STATE_SOLVABLE,    "includes",        STATE_INCLUDES,      0 },
180   { STATE_SOLVABLE,    "extends",         STATE_EXTENDS,       0 },
181   { STATE_SOLVABLE,    "default",         STATE_DEFAULT,       1 },
182   { STATE_SOLVABLE,    "install-time",    STATE_INSTALL_TIME,  1 },
183
184   /* product attributes */
185   /* note the product type is an attribute */
186   { STATE_SOLVABLE,    "release-notes-url", STATE_RELNOTESURL, 1 },
187   { STATE_SOLVABLE,    "update-url",        STATE_UPDATEURL,   1 },
188   { STATE_SOLVABLE,    "optional-url",      STATE_OPTIONALURL, 1 },
189   { STATE_SOLVABLE,    "flag",              STATE_FLAG,        1 },
190
191   { STATE_SOLVABLE,      "rpm:vendor",      STATE_VENDOR,      1 },
192   { STATE_SOLVABLE,      "rpm:group",       STATE_RPM_GROUP,   1 },
193   { STATE_SOLVABLE,      "rpm:license",     STATE_RPM_LICENSE, 1 },
194
195   /* rpm-md dependencies */
196   { STATE_SOLVABLE,      "rpm:provides",    STATE_PROVIDES,     0 },
197   { STATE_SOLVABLE,      "rpm:requires",    STATE_REQUIRES,     0 },
198   { STATE_SOLVABLE,      "rpm:obsoletes",   STATE_OBSOLETES,    0 },
199   { STATE_SOLVABLE,      "rpm:conflicts",   STATE_CONFLICTS,    0 },
200   { STATE_SOLVABLE,      "rpm:recommends",  STATE_RECOMMENDS ,  0 },
201   { STATE_SOLVABLE,      "rpm:supplements", STATE_SUPPLEMENTS,  0 },
202   { STATE_SOLVABLE,      "rpm:suggests",    STATE_SUGGESTS,     0 },
203   { STATE_SOLVABLE,      "rpm:enhances",    STATE_ENHANCES,     0 },
204   { STATE_SOLVABLE,      "rpm:freshens",    STATE_FRESHENS,     0 },
205   { STATE_SOLVABLE,      "rpm:sourcerpm",   STATE_SOURCERPM,    1 },
206   { STATE_SOLVABLE,      "rpm:header-range", STATE_HEADERRANGE, 0 },
207   { STATE_SOLVABLE,      "file",            STATE_FILE, 1 },
208
209    /* extended Novell/SUSE diskusage attributes (susedata.xml) */
210   { STATE_DISKUSAGE,   "dirs",            STATE_DIRS,         0 },
211   { STATE_DIRS,        "dir",             STATE_DIR,          0 },
212
213   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
214   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
215   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
216   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
217   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
218   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
219   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
220   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
221   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
222
223   { STATE_INCLUDES,    "item",            STATE_INCLUDESENTRY, 0 },
224   { STATE_EXTENDS,     "item",            STATE_EXTENDSENTRY,  0 },
225
226   { NUMSTATES}
227 };
228
229 /* maxmum initial size of
230    the checksum cache */
231 #define MAX_CSCACHE 32768
232 #define CSREALLOC_STEP 1024
233
234 struct parsedata {
235   struct parsedata_common common;
236   char *kind;
237   int depth;
238   enum state state;
239   int statedepth;
240   char *content;
241   int lcontent;
242   int acontent;
243   int docontent;
244   Solvable *solvable;
245   Offset freshens;
246   struct stateswitch *swtab[NUMSTATES];
247   enum state sbtab[NUMSTATES];
248   /* temporal to store attribute tag language */
249   const char *tmplang;
250   const char *capkind;
251   // used to store tmp attributes
252   // while the tag ends
253   const char *tmpattr;
254   Repodata *data;
255   Id handle;
256   XML_Parser *parser;
257   Id (*dirs)[3]; // dirid, size, nfiles
258   int ndirs;
259   Id langcache[ID_NUM_INTERNAL];
260   /** system language */
261   const char *language;
262
263   Id lastdir;
264   char *lastdirstr;
265   int lastdirstrl;
266
267   /** Hash to maps checksums to solv */
268   Stringpool cspool;
269   /** Cache of known checksums to solvable id */
270   Id *cscache;
271   /* the current longest index in the table */
272   int ncscache;
273 };
274
275 static Id
276 langtag(struct parsedata *pd, Id tag, const char *language)
277 {
278   if (!language)        /* fall back to default if not specified */
279     language = pd->language;
280   if (language && (!language[0] || !strcmp(language, "en")))
281     language = 0;
282   if (!language || tag >= ID_NUM_INTERNAL)
283     return pool_id2langid(pd->common.repo->pool, tag, language, 1);
284   return pool_id2langid(pd->common.repo->pool, tag, language, 1);
285   if (!pd->langcache[tag])
286     pd->langcache[tag] = pool_id2langid(pd->common.repo->pool, tag, language, 1);
287   return pd->langcache[tag];
288 }
289
290 static int
291 id3_cmp (const void *v1, const void *v2, void *dp)
292 {
293   Id *i1 = (Id*)v1;
294   Id *i2 = (Id*)v2;
295   return i1[0] - i2[0];
296 }
297
298 static void
299 commit_diskusage (struct parsedata *pd, unsigned handle)
300 {
301   unsigned i;
302   Dirpool *dp = &pd->data->dirpool;
303   /* Now sort in dirid order.  This ensures that parents come before
304      their children.  */
305   if (pd->ndirs > 1)
306     solv_sort(pd->dirs, pd->ndirs, sizeof (pd->dirs[0]), id3_cmp, 0);
307   /* Substract leaf numbers from all parents to make the numbers
308      non-cumulative.  This must be done post-order (i.e. all leafs
309      adjusted before parents).  We ensure this by starting at the end of
310      the array moving to the start, hence seeing leafs before parents.  */
311   for (i = pd->ndirs; i--;)
312     {
313       unsigned p = dirpool_parent(dp, pd->dirs[i][0]);
314       unsigned j = i;
315       for (; p; p = dirpool_parent(dp, p))
316         {
317           for (; j--;)
318             if (pd->dirs[j][0] == p)
319               break;
320           if (j < pd->ndirs)
321             {
322               if (pd->dirs[j][1] < pd->dirs[i][1])
323                 pd->dirs[j][1] = 0;
324               else
325                 pd->dirs[j][1] -= pd->dirs[i][1];
326               if (pd->dirs[j][2] < pd->dirs[i][2])
327                 pd->dirs[j][2] = 0;
328               else
329                 pd->dirs[j][2] -= pd->dirs[i][2];
330             }
331           else
332             /* Haven't found this parent in the list, look further if
333                we maybe find the parents parent.  */
334             j = i;
335         }
336     }
337 #if 0
338   char sbuf[1024];
339   char *buf = sbuf;
340   unsigned slen = sizeof (sbuf);
341   for (i = 0; i < pd->ndirs; i++)
342     {
343       dir2str (attr, pd->dirs[i][0], &buf, &slen);
344       fprintf (stderr, "have dir %d %d %d %s\n", pd->dirs[i][0], pd->dirs[i][1], pd->dirs[i][2], buf);
345     }
346   if (buf != sbuf)
347     free (buf);
348 #endif
349   for (i = 0; i < pd->ndirs; i++)
350     if (pd->dirs[i][1] || pd->dirs[i][2])
351       {
352         repodata_add_dirnumnum(pd->data, handle, SOLVABLE_DISKUSAGE, pd->dirs[i][0], pd->dirs[i][1], pd->dirs[i][2]);
353       }
354   pd->ndirs = 0;
355 }
356
357
358 /*
359  * makeevr_atts
360  * parse 'epoch', 'ver' and 'rel', return evr Id
361  *
362  */
363
364 static Id
365 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
366 {
367   const char *e, *v, *r, *v2;
368   char *c;
369   int l;
370
371   e = v = r = 0;
372   for (; *atts; atts += 2)
373     {
374       if (!strcmp(*atts, "epoch"))
375         e = atts[1];
376       else if (!strcmp(*atts, "ver"))
377         v = atts[1];
378       else if (!strcmp(*atts, "rel"))
379         r = atts[1];
380     }
381   if (e && !strcmp(e, "0"))
382     e = 0;
383   if (v && !e)
384     {
385       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
386         ;
387       if (v2 > v && *v2 == ':')
388         e = "0";
389     }
390   l = 1;
391   if (e)
392     l += strlen(e) + 1;
393   if (v)
394     l += strlen(v);
395   if (r)
396     l += strlen(r) + 1;
397   if (l > pd->acontent)
398     {
399       pd->content = solv_realloc(pd->content, l + 256);
400       pd->acontent = l + 256;
401     }
402   c = pd->content;
403   if (e)
404     {
405       strcpy(c, e);
406       c += strlen(c);
407       *c++ = ':';
408     }
409   if (v)
410     {
411       strcpy(c, v);
412       c += strlen(c);
413     }
414   if (r)
415     {
416       *c++ = '-';
417       strcpy(c, r);
418       c += strlen(c);
419     }
420   *c = 0;
421   if (!*pd->content)
422     return 0;
423 #if 0
424   fprintf(stderr, "evr: %s\n", pd->content);
425 #endif
426   return pool_str2id(pool, pd->content, 1);
427 }
428
429
430 /*
431  * find_attr
432  * find value for xml attribute
433  * I: txt, name of attribute
434  * I: atts, list of key/value attributes
435  * O: pointer to value of matching key, or NULL
436  *
437  */
438
439 static inline const char *
440 find_attr(const char *txt, const char **atts)
441 {
442   for (; *atts; atts += 2)
443     {
444       if (!strcmp(*atts, txt))
445         return atts[1];
446     }
447   return 0;
448 }
449
450
451 /*
452  * dependency relations
453  */
454
455 static char *flagtab[] = {
456   "GT",
457   "EQ",
458   "GE",
459   "LT",
460   "NE",
461   "LE"
462 };
463
464
465 /*
466  * adddep
467  * parse attributes to reldep Id
468  *
469  */
470
471 static unsigned int
472 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
473 {
474   Id id, name, marker;
475   const char *n, *f, *k;
476   const char **a;
477
478   n = f = k = 0;
479   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
480   for (a = atts; *a; a += 2)
481     {
482       if (!strcmp(*a, "name"))
483         n = a[1];
484       else if (!strcmp(*a, "flags"))
485         f = a[1];
486       else if (!strcmp(*a, "kind"))
487         k = a[1];
488       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
489         marker = SOLVABLE_PREREQMARKER;
490     }
491   if (!n)
492     return olddeps;
493   if (k && !strcmp(k, "package"))
494     k = 0;
495   if (k)
496     {
497       int l = strlen(k) + 1 + strlen(n) + 1;
498       if (l > pd->acontent)
499         {
500           pd->content = solv_realloc(pd->content, l + 256);
501           pd->acontent = l + 256;
502         }
503       sprintf(pd->content, "%s:%s", k, n);
504       name = pool_str2id(pool, pd->content, 1);
505     }
506   else
507     name = pool_str2id(pool, (char *)n, 1);
508   if (f)
509     {
510       Id evr = makeevr_atts(pool, pd, atts);
511       int flags;
512       for (flags = 0; flags < 6; flags++)
513         if (!strcmp(f, flagtab[flags]))
514           break;
515       flags = flags < 6 ? flags + 1 : 0;
516       id = pool_rel2id(pool, name, evr, flags, 1);
517     }
518   else
519     id = name;
520 #if 0
521   fprintf(stderr, "new dep %s%s%s\n", pool_id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
522 #endif
523   return repo_addid_dep(pd->common.repo, olddeps, id, marker);
524 }
525
526
527 /*
528  * set_description_author
529  *
530  */
531 static void
532 set_description_author(Repodata *data, Id handle, char *str, struct parsedata *pd)
533 {
534   char *aut, *p;
535
536   if (!str || !*str)
537     return;
538   for (aut = str; (aut = strchr(aut, '\n')) != 0; aut++)
539     if (!strncmp(aut, "\nAuthors:\n--------\n", 19))
540       break;
541   if (aut)
542     {
543       /* oh my, found SUSE special author section */
544       int l = aut - str;
545       str[l] = 0;
546       while (l > 0 && str[l - 1] == '\n')
547         str[--l] = 0;
548       if (l)
549         repodata_set_str(data, handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), str);
550       p = aut + 19;
551       aut = str;        /* copy over */
552       while (*p == ' ' || *p == '\n')
553         p++;
554       while (*p)
555         {
556           if (*p == '\n')
557             {
558               *aut++ = *p++;
559               while (*p == ' ')
560                 p++;
561               continue;
562             }
563           *aut++ = *p++;
564         }
565       while (aut != str && aut[-1] == '\n')
566         aut--;
567       *aut = 0;
568       if (*str)
569         repodata_set_str(data, handle, SOLVABLE_AUTHORS, str);
570     }
571   else if (*str)
572     repodata_set_str(data, handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), str);
573 }
574
575
576 /*
577  * set_sourcerpm
578  *
579  */
580
581 static void
582 set_sourcerpm(Repodata *data, Solvable *s, Id handle, char *sourcerpm)
583 {
584   const char *p, *sevr, *sarch, *name, *evr;
585   Pool *pool;
586
587   p = strrchr(sourcerpm, '.');
588   if (!p || strcmp(p, ".rpm") != 0)
589     return;
590   p--;
591   while (p > sourcerpm && *p != '.')
592     p--;
593   if (*p != '.' || p == sourcerpm)
594     return;
595   sarch = p-- + 1;
596   while (p > sourcerpm && *p != '-')
597     p--;
598   if (*p != '-' || p == sourcerpm)
599     return;
600   p--;
601   while (p > sourcerpm && *p != '-')
602     p--;
603   if (*p != '-' || p == sourcerpm)
604     return;
605   sevr = p + 1;
606   pool = s->repo->pool;
607   if (!strcmp(sarch, "src.rpm"))
608     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_SRC);
609   else if (!strcmp(sarch, "nosrc.rpm"))
610     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
611   else
612     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, pool_strn2id(pool, sarch, strlen(sarch) - 4, 1));
613   evr = pool_id2str(pool, s->evr);
614   if (evr && !strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
615     repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
616   else
617     repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, pool_strn2id(pool, sevr, sarch - sevr - 1, 1));
618   name = pool_id2str(pool, s->name);
619   if (name && !strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm - 1] == 0)
620     repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
621   else
622     repodata_set_id(data, handle, SOLVABLE_SOURCENAME, pool_strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
623 }
624
625 /*-----------------------------------------------*/
626 /* XML callbacks */
627
628 /*
629  * startElement
630  * XML callback
631  *
632  */
633
634 static void XMLCALL
635 startElement(void *userData, const char *name, const char **atts)
636 {
637   //fprintf(stderr,"+tag: %s\n", name);
638   struct parsedata *pd = userData;
639   Pool *pool = pd->common.pool;
640   Solvable *s = pd->solvable;
641   struct stateswitch *sw;
642   const char *str;
643   Id handle = pd->handle;
644   const char *pkgid;
645
646   // fprintf(stderr, "into %s, from %d, depth %d, statedepth %d\n", name, pd->state, pd->depth, pd->statedepth);
647
648   if (pd->depth != pd->statedepth)
649     {
650       pd->depth++;
651       return;
652     }
653
654   if (pd->state == STATE_START && !strcmp(name, "patterns"))
655     return;
656   if (pd->state == STATE_START && !strcmp(name, "products"))
657     return;
658   //if (pd->state == STATE_START && !strcmp(name, "metadata"))
659   //  return;
660   if (pd->state == STATE_SOLVABLE && !strcmp(name, "format"))
661     return;
662
663   pd->depth++;
664   if (!pd->swtab[pd->state])
665     return;
666   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
667     if (!strcmp(sw->ename, name))
668       break;
669   if (sw->from != pd->state)
670     {
671 #if 0
672       fprintf(stderr, "into unknown: %s\n", name);
673 #endif
674       return;
675     }
676   pd->state = sw->to;
677   pd->docontent = sw->docontent;
678   pd->statedepth = pd->depth;
679   pd->lcontent = 0;
680   *pd->content = 0;
681   switch(pd->state)
682     {
683     case STATE_SOLVABLE:
684       pd->kind = 0;
685       if (name[2] == 't' && name[3] == 't')
686         pd->kind = "pattern";
687       else if (name[1] == 'r')
688         pd->kind = "product";
689       else if (name[2] == 't' && name[3] == 'c')
690         pd->kind = "patch";
691
692       /* to support extension metadata files like others.xml which
693          have the following structure:
694
695          <otherdata xmlns="http://linux.duke.edu/metadata/other"
696                     packages="101">
697            <package pkgid="b78f8664cd90efe42e09a345e272997ef1b53c18"
698                     name="zaptel-kmp-default"
699                     arch="i586"><version epoch="0"
700                     ver="1.2.10_2.6.22_rc4_git6_2" rel="70"/>
701               ...
702
703          we need to check if the pkgid is there and if it matches
704          an already seen package, that means we don't need to create
705          a new solvable but just append the attributes to the existing
706          one.
707       */
708       if ((pkgid = find_attr("pkgid", atts)) != NULL)
709         {
710           // look at the checksum cache
711           Id index = stringpool_str2id(&pd->cspool, pkgid, 0);
712           if (!index || index >= pd->ncscache || !pd->cscache[index])
713             {
714               fprintf(stderr, "error, the repository specifies extra information about package with checksum '%s', which does not exist in the repository.\n", pkgid);
715               exit(1);
716             }
717           pd->solvable = pool_id2solvable(pool, pd->cscache[index]);
718         }
719        else
720         {
721           /* this is a new package */
722           pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->common.repo));
723           pd->freshens = 0;
724         }
725       pd->handle = pd->solvable - pool->solvables;
726 #if 0
727       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
728 #endif
729
730       break;
731     case STATE_VERSION:
732       s->evr = makeevr_atts(pool, pd, atts);
733       break;
734     case STATE_PROVIDES:
735       s->provides = 0;
736       break;
737     case STATE_PROVIDESENTRY:
738       s->provides = adddep(pool, pd, s->provides, atts, 0);
739       break;
740     case STATE_REQUIRES:
741       s->requires = 0;
742       break;
743     case STATE_REQUIRESENTRY:
744       s->requires = adddep(pool, pd, s->requires, atts, 1);
745       break;
746     case STATE_OBSOLETES:
747       s->obsoletes = 0;
748       break;
749     case STATE_OBSOLETESENTRY:
750       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
751       break;
752     case STATE_CONFLICTS:
753       s->conflicts = 0;
754       break;
755     case STATE_CONFLICTSENTRY:
756       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
757       break;
758     case STATE_RECOMMENDS:
759       s->recommends = 0;
760       break;
761     case STATE_RECOMMENDSENTRY:
762       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
763       break;
764     case STATE_SUPPLEMENTS:
765       s->supplements= 0;
766       break;
767     case STATE_SUPPLEMENTSENTRY:
768       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
769       break;
770     case STATE_SUGGESTS:
771       s->suggests = 0;
772       break;
773     case STATE_SUGGESTSENTRY:
774       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
775       break;
776     case STATE_ENHANCES:
777       s->enhances = 0;
778       break;
779     case STATE_ENHANCESENTRY:
780       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
781       break;
782     case STATE_FRESHENS:
783       pd->freshens = 0;
784       break;
785     case STATE_FRESHENSENTRY:
786       pd->freshens = adddep(pool, pd, pd->freshens, atts, 0);
787       break;
788     case STATE_EULA:
789     case STATE_SUMMARY:
790     case STATE_CATEGORY:
791     case STATE_DESCRIPTION:
792       pd->tmplang = find_attr("lang", atts);
793       break;
794     case STATE_USERVISIBLE:
795       repodata_set_void(pd->data, handle, SOLVABLE_ISVISIBLE );
796       break;
797     case STATE_INCLUDESENTRY:
798       {
799         const char *tmp = find_attr("pattern", atts);
800         if (tmp)
801           repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_INCLUDES, join2("pattern", ":", tmp));
802       }
803       break;
804     case STATE_EXTENDSENTRY:
805       {
806         const char *tmp = find_attr("pattern", atts);
807         if (tmp)
808           repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_EXTENDS, join2("pattern", ":", tmp));
809       }
810       break;
811     case STATE_LOCATION:
812       str = find_attr("href", atts);
813       if (str)
814         repodata_set_location(pd->data, handle, 0, 0, str);
815       break;
816     case STATE_CHECKSUM:
817       pd->tmpattr = find_attr("type", atts);
818       break;
819     case STATE_TIME:
820       {
821         unsigned int t;
822         str = find_attr("build", atts);
823         if (str && (t = atoi(str)) != 0)
824           repodata_set_num(pd->data, handle, SOLVABLE_BUILDTIME, t);
825         break;
826       }
827     case STATE_SIZE:
828       {
829         unsigned int k;
830         str = find_attr("installed", atts);
831         if (str && (k = atoi(str)) != 0)
832           repodata_set_num(pd->data, handle, SOLVABLE_INSTALLSIZE, (k + 1023) / 1024);
833         /* XXX the "package" attribute gives the size of the rpm file,
834            i.e. the download size.  Except on packman, there it seems to be
835            something else entirely, it has a value near to the other two
836            values, as if the rpm is uncompressed.  */
837         str = find_attr("package", atts);
838         if (str && (k = atoi(str)) != 0)
839           repodata_set_num(pd->data, handle, SOLVABLE_DOWNLOADSIZE, (k + 1023) / 1024);
840         break;
841       }
842     case STATE_HEADERRANGE:
843       {
844         unsigned int end;
845         str = find_attr("end", atts);
846         if (str && (end = atoi(str)) != 0)
847           repodata_set_num(pd->data, handle, SOLVABLE_HEADEREND, end);
848       }
849       /*
850         <diskusage>
851           <dirs>
852             <dir name="/" size="56" count="11"/>
853             <dir name="usr/" size="56" count="11"/>
854             <dir name="usr/bin/" size="38" count="10"/>
855             <dir name="usr/share/" size="18" count="1"/>
856             <dir name="usr/share/doc/" size="18" count="1"/>
857           </dirs>
858         </diskusage>
859       */
860     case STATE_DISKUSAGE:
861       {
862         /* Really, do nothing, wat for <dir> tag */
863         break;
864       }
865     case STATE_DIR:
866       {
867         long filesz = 0, filenum = 0;
868         unsigned dirid;
869         if ((str = find_attr("name", atts)) != 0)
870           dirid = repodata_str2dir(pd->data, str, 1);
871         else
872           {
873             fprintf( stderr, "<dir .../> tag without 'name' attribute, atts = %p, *atts = %p\n",
874                     (void *)atts, *atts);
875             break;
876           }
877         if ((str = find_attr("size", atts)) != 0)
878           filesz = strtol(str, 0, 0);
879         if ((str = find_attr("count", atts)) != 0)
880           filenum = strtol(str, 0, 0);
881         pd->dirs = solv_extend(pd->dirs, pd->ndirs, 1, sizeof(pd->dirs[0]), 31);
882         pd->dirs[pd->ndirs][0] = dirid;
883         pd->dirs[pd->ndirs][1] = filesz;
884         pd->dirs[pd->ndirs][2] = filenum;
885         pd->ndirs++;
886         break;
887       }
888     default:
889       break;
890     }
891 }
892
893
894 /*
895  * endElement
896  * XML callback
897  *
898  */
899
900 static void XMLCALL
901 endElement(void *userData, const char *name)
902 {
903   //fprintf(stderr,"-tag: %s\n", name);
904   struct parsedata *pd = userData;
905   Pool *pool = pd->common.pool;
906   Solvable *s = pd->solvable;
907   Repo *repo = pd->common.repo;
908   Id handle = pd->handle;
909   Id id;
910   char *p;
911
912   if (pd->depth != pd->statedepth)
913     {
914       pd->depth--;
915       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
916       return;
917     }
918
919   /* ignore patterns & metadata */
920   if (pd->state == STATE_START && !strcmp(name, "patterns"))
921     return;
922   if (pd->state == STATE_START && !strcmp(name, "products"))
923     return;
924   //if (pd->state == STATE_START && !strcmp(name, "metadata"))
925   //  return;
926   if (pd->state == STATE_SOLVABLE && !strcmp(name, "format"))
927     return;
928
929   pd->depth--;
930   pd->statedepth--;
931   switch (pd->state)
932     {
933     case STATE_SOLVABLE:
934       if (pd->kind && !s->name) /* add namespace in case of NULL name */
935         s->name = pool_str2id(pool, join2(pd->kind, ":", ""), 1);
936       if (!s->arch)
937         s->arch = ARCH_NOARCH;
938       if (!s->evr)
939         s->evr = ID_EMPTY;      /* some patterns have this */
940       if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
941         s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
942       s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, pd->freshens);
943       s->conflicts = repo_fix_conflicts(repo, s->conflicts);
944       pd->freshens = 0;
945       pd->kind = 0;
946       break;
947     case STATE_NAME:
948       if (pd->kind)
949         s->name = pool_str2id(pool, join2(pd->kind, ":", pd->content), 1);
950       else
951         s->name = pool_str2id(pool, pd->content, 1);
952       break;
953     case STATE_ARCH:
954       s->arch = pool_str2id(pool, pd->content, 1);
955       break;
956     case STATE_VENDOR:
957       s->vendor = pool_str2id(pool, pd->content, 1);
958       break;
959     case STATE_RPM_GROUP:
960       repodata_set_poolstr(pd->data, handle, SOLVABLE_GROUP, pd->content);
961       break;
962     case STATE_RPM_LICENSE:
963       repodata_set_poolstr(pd->data, handle, SOLVABLE_LICENSE, pd->content);
964       break;
965     case STATE_CHECKSUM:
966       {
967         Id type, index;
968         type = solv_chksum_str2type(pd->tmpattr);
969         if (!type)
970           {
971             fprintf(stderr, "Unknown checksum type: %d: %s\n", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), pd->tmpattr);
972             exit(1);
973           }
974         if (strlen(pd->content) != 2 * solv_chksum_len(type))
975           {
976             fprintf(stderr, "Invalid checksum length: %d: for %s\n", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), pd->tmpattr);
977             exit(1);
978           }
979         repodata_set_checksum(pd->data, handle, SOLVABLE_CHECKSUM, type, pd->content);
980         /* we save the checksum to solvable id relationship for extended
981            metadata */
982         index = stringpool_str2id(&pd->cspool, pd->content, 1 /* create it */);
983         if (index >= pd->ncscache)
984           {
985             pd->cscache = solv_zextend(pd->cscache, pd->ncscache, index + 1 - pd->ncscache, sizeof(Id), 255);
986             pd->ncscache = index + 1;
987           }
988         /* add the checksum to the cache */
989         pd->cscache[index] = s - pool->solvables;
990         break;
991       }
992     case STATE_FILE:
993 #if 0
994       id = pool_str2id(pool, pd->content, 1);
995       s->provides = repo_addid_dep(repo, s->provides, id, SOLVABLE_FILEMARKER);
996 #endif
997       if ((p = strrchr(pd->content, '/')) != 0)
998         {
999           *p++ = 0;
1000           if (pd->lastdir && !strcmp(pd->lastdirstr, pd->content))
1001             {
1002               id = pd->lastdir;
1003             }
1004           else
1005             {
1006               int l;
1007               id = repodata_str2dir(pd->data, pd->content, 1);
1008               l = strlen(pd->content) + 1;
1009               if (l > pd->lastdirstrl)
1010                 {
1011                   pd->lastdirstrl = l + 128;
1012                   pd->lastdirstr = solv_realloc(pd->lastdirstr, pd->lastdirstrl);
1013                 }
1014               strcpy(pd->lastdirstr, pd->content);
1015               pd->lastdir = id;
1016             }
1017         }
1018       else
1019         {
1020           p = pd->content;
1021           id = 0;
1022         }
1023       if (!id)
1024         id = repodata_str2dir(pd->data, "/", 1);
1025       repodata_add_dirstr(pd->data, handle, SOLVABLE_FILELIST, id, p);
1026       break;
1027     case STATE_SUMMARY:
1028       repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), pd->content);
1029       break;
1030     case STATE_DESCRIPTION:
1031       set_description_author(pd->data, handle, pd->content, pd);
1032       break;
1033     case STATE_CATEGORY:
1034       repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_CATEGORY, pd->tmplang), pd->content);
1035       break;
1036     case STATE_DISTRIBUTION:
1037         repodata_set_poolstr(pd->data, handle, SOLVABLE_DISTRIBUTION, pd->content);
1038         break;
1039     case STATE_URL:
1040       if (pd->content[0])
1041         repodata_set_str(pd->data, handle, SOLVABLE_URL, pd->content);
1042       break;
1043     case STATE_PACKAGER:
1044       if (pd->content[0])
1045         repodata_set_poolstr(pd->data, handle, SOLVABLE_PACKAGER, pd->content);
1046       break;
1047     case STATE_SOURCERPM:
1048       set_sourcerpm(pd->data, s, handle, pd->content);
1049       break;
1050     case STATE_RELNOTESURL:
1051       if (pd->content[0])
1052         {
1053           repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
1054           repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "releasenotes", 1));
1055         }
1056       break;
1057     case STATE_UPDATEURL:
1058       if (pd->content[0])
1059         {
1060           repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
1061           repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "update", 1));
1062         }
1063       break;
1064     case STATE_OPTIONALURL:
1065       if (pd->content[0])
1066         {
1067           repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
1068           repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "optional", 1));
1069         }
1070       break;
1071     case STATE_FLAG:
1072       if (pd->content[0])
1073           repodata_set_poolstr(pd->data, handle, PRODUCT_FLAGS, pd->content);
1074       break;
1075     case STATE_EULA:
1076       if (pd->content[0])
1077         repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_EULA, pd->tmplang), pd->content);
1078       break;
1079     case STATE_KEYWORD:
1080       if (pd->content[0])
1081         repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_KEYWORDS, pd->content);
1082       break;
1083     case STATE_DISKUSAGE:
1084       if (pd->ndirs)
1085         commit_diskusage(pd, pd->handle);
1086       break;
1087     case STATE_ORDER:
1088       if (pd->content[0])
1089         repodata_set_str(pd->data, pd->handle, SOLVABLE_ORDER, pd->content);
1090     default:
1091       break;
1092     }
1093   pd->state = pd->sbtab[pd->state];
1094   pd->docontent = 0;
1095   // fprintf(stderr, "back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
1096 }
1097
1098
1099 /*
1100  * characterData
1101  * XML callback
1102  *
1103  */
1104
1105 static void XMLCALL
1106 characterData(void *userData, const XML_Char *s, int len)
1107 {
1108   struct parsedata *pd = userData;
1109   int l;
1110   char *c;
1111
1112   if (!pd->docontent)
1113     return;
1114   l = pd->lcontent + len + 1;
1115   if (l > pd->acontent)
1116     {
1117       pd->content = solv_realloc(pd->content, l + 256);
1118       pd->acontent = l + 256;
1119     }
1120   c = pd->content + pd->lcontent;
1121   pd->lcontent += len;
1122   while (len-- > 0)
1123     *c++ = *s++;
1124   *c = 0;
1125 }
1126
1127
1128 /*-----------------------------------------------*/
1129 /* 'main' */
1130
1131 #define BUFF_SIZE 8192
1132
1133 /*
1134  * repo_add_rpmmd
1135  * parse rpm-md metadata (primary, others)
1136  *
1137  */
1138
1139 int
1140 repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
1141 {
1142   Pool *pool = repo->pool;
1143   struct parsedata pd;
1144   char buf[BUFF_SIZE];
1145   int i, l;
1146   struct stateswitch *sw;
1147   Repodata *data;
1148   unsigned int now;
1149   XML_Parser parser;
1150
1151   now = solv_timems(0);
1152   data = repo_add_repodata(repo, flags);
1153
1154   memset(&pd, 0, sizeof(pd));
1155   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
1156     {
1157       if (!pd.swtab[sw->from])
1158         pd.swtab[sw->from] = sw;
1159       pd.sbtab[sw->to] = sw->from;
1160     }
1161   pd.common.pool = pool;
1162   pd.common.repo = repo;
1163
1164   pd.data = data;
1165
1166   pd.content = solv_malloc(256);
1167   pd.acontent = 256;
1168   pd.lcontent = 0;
1169   pd.common.tmp = 0;
1170   pd.common.tmpl = 0;
1171   pd.kind = 0;
1172   pd.language = language;
1173
1174   /* initialize the string pool where we will store
1175      the package checksums we know about, to get an Id
1176      we can use in a cache */
1177   stringpool_init_empty(&pd.cspool);
1178   if ((flags & REPO_EXTEND_SOLVABLES) != 0)
1179     {
1180       /* setup join data */
1181       Dataiterator di;
1182       dataiterator_init(&di, pool, repo, 0, SOLVABLE_CHECKSUM, 0, 0);
1183       while (dataiterator_step(&di))
1184         {
1185           const char *str;
1186           int index;
1187
1188           if (!solv_chksum_len(di.key->type))
1189             continue;
1190           str = repodata_chk2str(di.data, di.key->type, (const unsigned char *)di.kv.str);
1191           index = stringpool_str2id(&pd.cspool, str, 1);
1192           if (index >= pd.ncscache)
1193             {
1194               pd.cscache = solv_zextend(pd.cscache, pd.ncscache, index + 1 - pd.ncscache, sizeof(Id), 255);
1195               pd.ncscache = index + 1;
1196             }
1197           pd.cscache[index] = di.solvid;
1198         }
1199       dataiterator_free(&di);
1200     }
1201
1202   parser = XML_ParserCreate(NULL);
1203   XML_SetUserData(parser, &pd);
1204   pd.parser = &parser;
1205   XML_SetElementHandler(parser, startElement, endElement);
1206   XML_SetCharacterDataHandler(parser, characterData);
1207   for (;;)
1208     {
1209       l = fread(buf, 1, sizeof(buf), fp);
1210       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
1211         {
1212           pool_debug(pool, SOLV_FATAL, "repo_rpmmd: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
1213           exit(1);
1214         }
1215       if (l == 0)
1216         break;
1217     }
1218   XML_ParserFree(parser);
1219   solv_free(pd.content);
1220   solv_free(pd.lastdirstr);
1221   join_freemem();
1222   stringpool_free(&pd.cspool);
1223   solv_free(pd.cscache);
1224
1225   if (!(flags & REPO_NO_INTERNALIZE))
1226     repodata_internalize(data);
1227   POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", solv_timems(now));
1228   POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
1229   POOL_DEBUG(SOLV_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
1230   return 0;
1231 }