xml store capabilities are parsed now.
[platform/upstream/libsolv.git] / tools / 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 #include "tools_util.h"
19 #include "repo_rpmmd.h"
20
21
22 enum state {
23   STATE_START,
24   STATE_METADATA,
25   STATE_SOLVABLE,
26   STATE_PRODUCT,
27   STATE_PATTERN,
28   STATE_PATCH,
29   STATE_NAME,
30   STATE_ARCH,
31   STATE_VERSION,
32
33   STATE_SUMMARY,
34   STATE_DESCRIPTION,
35
36   STATE_FORMAT,
37   STATE_VENDOR,
38   STATE_PROVIDES,
39   STATE_REQUIRES,
40   STATE_OBSOLETES,
41   STATE_CONFLICTS,
42   STATE_RECOMMENDS,
43   STATE_SUPPLEMENTS,
44   STATE_SUGGESTS,
45   STATE_ENHANCES,
46   STATE_FRESHENS,
47
48   STATE_CAPS_FORMAT,
49   STATE_CAPS_VENDOR,
50   STATE_CAPS_PROVIDES,
51   STATE_CAPS_REQUIRES,
52   STATE_CAPS_OBSOLETES,
53   STATE_CAPS_CONFLICTS,
54   STATE_CAPS_RECOMMENDS,
55   STATE_CAPS_SUPPLEMENTS,
56   STATE_CAPS_SUGGESTS,
57   STATE_CAPS_ENHANCES,
58   STATE_CAPS_FRESHENS,
59
60   STATE_PROVIDESENTRY,
61   STATE_REQUIRESENTRY,
62   STATE_OBSOLETESENTRY,
63   STATE_CONFLICTSENTRY,
64   STATE_RECOMMENDSENTRY,
65   STATE_SUPPLEMENTSENTRY,
66   STATE_SUGGESTSENTRY,
67   STATE_ENHANCESENTRY,
68   STATE_FRESHENSENTRY,
69
70   STATE_CAP_FRESHENS,
71   STATE_CAP_PROVIDES,
72   STATE_CAP_REQUIRES,
73   STATE_CAP_OBSOLETES,
74   STATE_CAP_CONFLICTS,
75   STATE_CAP_SUGGESTS,
76   STATE_CAP_RECOMMENDS,
77   STATE_CAP_SUPPLEMENTS,
78   STATE_CAP_ENHANCES,
79
80   STATE_FILE,
81   // xml store pattern attributes
82   STATE_SCRIPT,
83   STATE_ICON,
84   STATE_USERVISIBLE,
85   STATE_CATEGORY,
86   STATE_DEFAULT,
87   STATE_INSTALL_TIME,
88
89   NUMSTATES
90 };
91
92
93 struct stateswitch {
94   enum state from;
95   char *ename;
96   enum state to;
97   int docontent;
98 };
99
100 static struct stateswitch stateswitches[] = {
101
102   { STATE_START,       "product",         STATE_SOLVABLE, 0 },
103   { STATE_START,       "pattern",         STATE_SOLVABLE, 0 },
104   { STATE_START,       "patch",           STATE_SOLVABLE, 0 },
105
106   { STATE_START,       "metadata",        STATE_METADATA, 0 },
107   { STATE_METADATA,    "package",         STATE_SOLVABLE, 0 },
108   
109   { STATE_SOLVABLE,    "name",            STATE_NAME, 1 },
110   { STATE_SOLVABLE,    "arch",            STATE_ARCH, 1 },
111   { STATE_SOLVABLE,    "version",         STATE_VERSION, 0 },
112   { STATE_SOLVABLE,    "vendor",          STATE_VENDOR, 1 },
113
114   { STATE_SOLVABLE,    "summary",         STATE_SUMMARY, 1 },
115   { STATE_SOLVABLE,    "description",     STATE_DESCRIPTION, 1 },
116   
117   // xml store pattern attributes
118   { STATE_SOLVABLE,    "script",          STATE_SCRIPT, 1 },
119   { STATE_SOLVABLE,    "icon",            STATE_ICON, 1 },
120   { STATE_SOLVABLE,    "uservisible",     STATE_USERVISIBLE, 1 },
121   { STATE_SOLVABLE,    "category",        STATE_CATEGORY, 1 },
122   { STATE_SOLVABLE,    "default",         STATE_DEFAULT, 1 },
123   { STATE_SOLVABLE,    "install-time",    STATE_INSTALL_TIME, 1 },
124
125   { STATE_SOLVABLE,    "format",          STATE_FORMAT, 0 },
126
127   /* those are used in libzypp xml store */
128   { STATE_SOLVABLE,    "obsoletes",       STATE_CAPS_OBSOLETES , 0 },
129   { STATE_SOLVABLE,    "conflicts",       STATE_CAPS_CONFLICTS , 0 },
130   { STATE_SOLVABLE,    "recommends",      STATE_CAPS_RECOMMENDS , 0 },
131   { STATE_SOLVABLE,    "supplements",     STATE_CAPS_SUPPLEMENTS, 0 },
132   { STATE_SOLVABLE,    "suggests",        STATE_CAPS_SUGGESTS, 0 },
133   { STATE_SOLVABLE,    "enhances",        STATE_CAPS_ENHANCES, 0 },
134   { STATE_SOLVABLE,    "freshens",        STATE_CAPS_FRESHENS, 0 },
135   { STATE_SOLVABLE,    "provides",        STATE_CAPS_PROVIDES, 0 },
136   { STATE_SOLVABLE,    "requires",        STATE_CAPS_REQUIRES, 0 },
137
138   { STATE_CAPS_PROVIDES,    "capability",      STATE_CAP_PROVIDES, 1 },
139   { STATE_CAPS_REQUIRES,    "capability",      STATE_CAP_REQUIRES, 1 },
140   { STATE_CAPS_OBSOLETES,   "capability",      STATE_CAP_OBSOLETES, 1 },
141   { STATE_CAPS_CONFLICTS,   "capability",      STATE_CAP_CONFLICTS, 1 },
142   { STATE_CAPS_RECOMMENDS,  "capability",      STATE_CAP_RECOMMENDS, 1 },
143   { STATE_CAPS_SUPPLEMENTS, "capability",      STATE_CAP_SUPPLEMENTS, 1 },
144   { STATE_CAPS_SUGGESTS,    "capability",      STATE_CAP_SUGGESTS, 1 },
145   { STATE_CAPS_ENHANCES,    "capability",      STATE_CAP_ENHANCES, 1 },
146   { STATE_CAPS_FRESHENS,    "capability",      STATE_CAP_FRESHENS, 1 },
147   
148   { STATE_FORMAT,      "rpm:vendor",      STATE_VENDOR, 1 },
149
150   /* rpm-md dependencies */ 
151   { STATE_FORMAT,      "rpm:provides",    STATE_PROVIDES, 0 },
152   { STATE_FORMAT,      "rpm:requires",    STATE_REQUIRES, 0 },
153   { STATE_FORMAT,      "rpm:obsoletes",   STATE_OBSOLETES , 0 },
154   { STATE_FORMAT,      "rpm:conflicts",   STATE_CONFLICTS , 0 },
155   { STATE_FORMAT,      "rpm:recommends",  STATE_RECOMMENDS , 0 },
156   { STATE_FORMAT,      "rpm:supplements", STATE_SUPPLEMENTS, 0 },
157   { STATE_FORMAT,      "rpm:suggests",    STATE_SUGGESTS, 0 },
158   { STATE_FORMAT,      "rpm:enhances",    STATE_ENHANCES, 0 },
159   { STATE_FORMAT,      "rpm:freshens",    STATE_FRESHENS, 0 },
160   { STATE_FORMAT,      "file",            STATE_FILE, 1 },
161   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
162   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
163   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
164   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
165   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
166   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
167   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
168   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
169   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
170   { NUMSTATES}
171 };
172
173 struct parsedata {
174   struct parsedata_common common;
175   char *kind;
176   int depth;
177   enum state state;
178   int statedepth;
179   char *content;
180   int lcontent;
181   int acontent;
182   int docontent;
183   int numpacks;
184   Solvable *solvable;
185   struct stateswitch *swtab[NUMSTATES];
186   enum state sbtab[NUMSTATES];
187   const char *lang;
188   const char *capkind;
189 };
190
191 static char *flagtabnum[] = {
192   ">",
193   "=",
194   ">=",
195   "<",
196   "!=",
197   "<=",
198 };
199
200 /**
201  * adds plain dependencies, that is strings like "foo > 2.0"
202  * which are used in libzypp xml store, not in rpm-md.
203  */
204 static unsigned int
205 adddepplain(Pool *pool, struct parsedata_common *pd, unsigned int olddeps, char *line, Id marker, const char *kind)
206 {
207   int i, flags;
208   Id id, evrid;
209   char *sp[4];
210
211   i = split(line, sp, 4);
212   if (i != 1 && i != 3)
213     {
214       fprintf(stderr, "Bad dependency line: %s\n", line);
215       exit(1);
216     }
217   if (kind)
218     id = str2id(pool, join(pd, kind, ":", sp[0]), 1);
219   else
220     id = str2id(pool, sp[0], 1);
221   if (i == 3)
222     {
223       evrid = makeevr(pool, sp[2]);
224       for (flags = 0; flags < 6; flags++)
225         if (!strcmp(sp[1], flagtabnum[flags]))
226           break;
227       if (flags == 6)
228         {
229           if ( !strcmp(sp[1], "=="))
230            {
231             flags = 1;
232            }
233           else
234            {
235             fprintf(stderr, "Unknown relation '%s'\n", sp[1]);
236             exit(1);
237            }
238         }
239       id = rel2id(pool, id, evrid, flags + 1, 1);
240     }
241   return repo_addid_dep(pd->repo, olddeps, id, marker);
242 }
243
244 static Id
245 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
246 {
247   const char *e, *v, *r, *v2;
248   char *c;
249   int l;
250
251   e = v = r = 0;
252   for (; *atts; atts += 2)
253     {
254       if (!strcmp(*atts, "epoch"))
255         e = atts[1];
256       else if (!strcmp(*atts, "ver"))
257         v = atts[1];
258       else if (!strcmp(*atts, "rel"))
259         r = atts[1];
260     }
261   if (e && !strcmp(e, "0"))
262     e = 0;
263   if (v && !e)
264     {
265       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
266         ;
267       if (v2 > v && *v2 == ':')
268         e = "0";
269     }
270   l = 1;
271   if (e)
272     l += strlen(e) + 1;
273   if (v)
274     l += strlen(v);
275   if (r)
276     l += strlen(r) + 1;
277   if (l > pd->acontent)
278     {
279       pd->content = sat_realloc(pd->content, l + 256);
280       pd->acontent = l + 256;
281     }
282   c = pd->content;
283   if (e)
284     {
285       strcpy(c, e);
286       c += strlen(c);
287       *c++ = ':';
288     }
289   if (v)
290     {
291       strcpy(c, v);
292       c += strlen(c);
293     }
294   if (r)
295     {
296       *c++ = '-';
297       strcpy(c, r);
298       c += strlen(c);
299     }
300   *c = 0;
301   if (!*pd->content)
302     return 0;
303 #if 0
304   fprintf(stderr, "evr: %s\n", pd->content);
305 #endif
306   return str2id(pool, pd->content, 1);
307 }
308
309 static const char *
310 find_attr(const char *txt, const char **atts)
311 {
312   char *k;
313   k = 0;
314   for (; *atts; atts += 2)
315     {
316       if (!strcmp(*atts, txt))
317         return atts[1];
318     }
319   return k;
320 }
321
322 static char *flagtab[] = {
323   "GT",
324   "EQ",
325   "GE",
326   "LT",
327   "NE",
328   "LE"
329 };
330
331 static unsigned int
332 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
333 {
334   Id id, name, marker;
335   const char *n, *f, *k;
336   const char **a;
337
338   n = f = k = 0;
339   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
340   for (a = atts; *a; a += 2)
341     {
342       if (!strcmp(*a, "name"))
343         n = a[1];
344       else if (!strcmp(*a, "flags"))
345         f = a[1];
346       else if (!strcmp(*a, "kind"))
347         k = a[1];
348       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
349         marker = SOLVABLE_PREREQMARKER;
350     }
351   if (!n)
352     return olddeps;
353   if (k && !strcmp(k, "package"))
354     k = 0;
355   if (k)
356     {
357       int l = strlen(k) + 1 + strlen(n) + 1;
358       if (l > pd->acontent)
359         {
360           pd->content = sat_realloc(pd->content, l + 256);
361           pd->acontent = l + 256;
362         }
363       sprintf(pd->content, "%s:%s", k, n); 
364       name = str2id(pool, pd->content, 1); 
365     }
366   else
367     name = str2id(pool, (char *)n, 1);
368   if (f)
369     {
370       Id evr = makeevr_atts(pool, pd, atts);
371       int flags;
372       for (flags = 0; flags < 6; flags++)
373         if (!strcmp(f, flagtab[flags]))
374           break;
375       flags = flags < 6 ? flags + 1 : 0;
376       id = rel2id(pool, name, evr, flags, 1);
377     }
378   else
379     id = name;
380 #if 0
381   fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
382 #endif
383   return repo_addid_dep(pd->common.repo, olddeps, id, marker);
384 }
385
386
387 static void XMLCALL
388 startElement(void *userData, const char *name, const char **atts)
389 {
390   //fprintf(stderr,"+tag: %s\n", name);
391   struct parsedata *pd = userData;
392   Pool *pool = pd->common.pool;
393   Solvable *s = pd->solvable;
394   struct stateswitch *sw;
395
396   if (pd->depth != pd->statedepth)
397     {
398       pd->depth++;
399       return;
400     }
401   pd->depth++;
402   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
403     if (!strcmp(sw->ename, name))
404       break;
405   if (sw->from != pd->state)
406     {
407 #if 0
408       fprintf(stderr, "into unknown: %s\n", name);
409 #endif
410       return;
411     }
412   pd->state = sw->to;
413   pd->docontent = sw->docontent;
414   pd->statedepth = pd->depth;
415   pd->lcontent = 0;
416   *pd->content = 0;
417   switch(pd->state)
418     {
419     case STATE_METADATA:
420       for (; *atts; atts += 2)
421         {
422           if (!strcmp(*atts, "packages"))
423             {
424               pd->numpacks = atoi(atts[1]);
425               if (pd->numpacks < 0)
426                 pd->numpacks = 0;
427 #if 0
428               fprintf(stderr, "numpacks: %d\n", pd->numpacks);
429 #endif
430               pd->solvable = pool_id2solvable(pool, repo_add_solvable_block(pd->common.repo, pd->numpacks));
431             }
432         }
433       break;
434     case STATE_SOLVABLE:
435       pd->kind = 0;
436       if ( name[2] == 't' && name[3] == 't' )
437         pd->kind = "pattern";
438       else if ( name[1] == 'r' )
439         pd->kind = "product";
440       else if ( name[2] == 't' && name[3] == 'c' )
441         pd->kind = "patch";
442       
443       if (pd->numpacks == 0)
444         pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->common.repo));
445 #if 0
446       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
447 #endif
448       break;
449     case STATE_VERSION:
450       s->evr = makeevr_atts(pool, pd, atts);
451       break;
452     case STATE_CAPS_PROVIDES:
453     case STATE_PROVIDES:
454       s->provides = 0;
455       break;
456     case STATE_PROVIDESENTRY:
457       s->provides = adddep(pool, pd, s->provides, atts, 0);
458       break;
459     case STATE_CAPS_REQUIRES:
460     case STATE_REQUIRES:
461       s->requires = 0;
462       break;
463     case STATE_REQUIRESENTRY:
464       s->requires = adddep(pool, pd, s->requires, atts, 1);
465       break;
466     case STATE_CAPS_OBSOLETES:
467     case STATE_OBSOLETES:
468       s->obsoletes = 0;
469       break;
470     case STATE_OBSOLETESENTRY:
471       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
472       break;
473     case STATE_CAPS_CONFLICTS:
474     case STATE_CONFLICTS:
475       s->conflicts = 0;
476       break;
477     case STATE_CONFLICTSENTRY:
478       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
479       break;
480     case STATE_CAPS_RECOMMENDS:
481     case STATE_RECOMMENDS:
482       s->recommends = 0;
483       break;
484     case STATE_RECOMMENDSENTRY:
485       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
486       break;
487     case STATE_CAPS_SUPPLEMENTS:
488     case STATE_SUPPLEMENTS:
489       s->supplements= 0;
490       break;
491     case STATE_SUPPLEMENTSENTRY:
492       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
493       break;
494     case STATE_CAPS_SUGGESTS:
495     case STATE_SUGGESTS:
496       s->suggests = 0;
497       break;
498     case STATE_SUGGESTSENTRY:
499       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
500       break;
501     case STATE_CAPS_ENHANCES:
502     case STATE_ENHANCES:
503       s->enhances = 0;
504       break;
505     case STATE_ENHANCESENTRY:
506       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
507       break;
508     case STATE_CAPS_FRESHENS:
509     case STATE_FRESHENS:
510       s->freshens = 0;
511       break;
512     case STATE_FRESHENSENTRY:
513       s->freshens = adddep(pool, pd, s->freshens, atts, 0);
514       break;
515     case STATE_CAP_PROVIDES:
516     case STATE_CAP_REQUIRES:
517     case STATE_CAP_OBSOLETES:
518     case STATE_CAP_CONFLICTS:
519     case STATE_CAP_RECOMMENDS:
520     case STATE_CAP_SUPPLEMENTS:
521     case STATE_CAP_SUGGESTS:
522     case STATE_CAP_ENHANCES:
523     case STATE_CAP_FRESHENS:
524       pd->capkind = find_attr("kind", atts);
525       //fprintf(stderr,"capkind es: %s\n", pd->capkind);
526       break;
527     case STATE_SUMMARY:
528     case STATE_DESCRIPTION:
529       pd->lang = find_attr("lang", atts);
530       break;
531     default:
532       break;
533     }
534 }
535
536 static void XMLCALL
537 endElement(void *userData, const char *name)
538 {
539   //fprintf(stderr,"-tag: %s\n", name);
540   struct parsedata *pd = userData;
541   Pool *pool = pd->common.pool;
542   Solvable *s = pd->solvable;
543   Repo *repo = pd->common.repo;
544   Id id;
545
546   if (pd->depth != pd->statedepth)
547     {
548       pd->depth--;
549       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
550       return;
551     }
552   pd->depth--;
553   pd->statedepth--;
554   switch (pd->state)
555     {
556     case STATE_PATTERN:
557     case STATE_PRODUCT:
558     case STATE_SOLVABLE:
559       if (!s->arch)
560         s->arch = ARCH_NOARCH;
561       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
562         s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
563       s->supplements = repo_fix_legacy(repo, s->provides, s->supplements);
564       if (pd->numpacks > 0)
565         {
566           pd->numpacks--;
567           pd->solvable++;
568         }
569       pd->kind = 0;
570       break;
571     case STATE_NAME:
572       if ( pd->kind )
573           s->name = str2id(pool, join(&pd->common, pd->kind, ":", pd->content), 1);
574       else
575           s->name = str2id(pool, pd->content, 1);
576       break;
577     case STATE_ARCH:
578       s->arch = str2id(pool, pd->content, 1);
579       break;
580     case STATE_VENDOR:
581       s->vendor = str2id(pool, pd->content, 1);
582       break;
583     case STATE_FILE:
584       id = str2id(pool, pd->content, 1);
585       s->provides = repo_addid(repo, s->provides, id);
586       break;
587     // xml store capabilities
588     case STATE_CAP_PROVIDES:
589       s->provides = adddepplain(pool, &pd->common, s->provides, pd->content, 0, pd->capkind);
590       break;
591     case STATE_CAP_REQUIRES:
592       s->requires = adddepplain(pool, &pd->common, s->requires, pd->content, 0, pd->capkind);
593       break;
594     case STATE_CAP_OBSOLETES:
595       s->obsoletes = adddepplain(pool, &pd->common, s->obsoletes, pd->content, 0, pd->capkind);
596       break;
597     case STATE_CAP_CONFLICTS:
598       s->conflicts = adddepplain(pool, &pd->common, s->conflicts, pd->content, 0, pd->capkind);
599       break;
600     case STATE_CAP_RECOMMENDS:
601       s->recommends = adddepplain(pool, &pd->common, s->recommends, pd->content, 0, pd->capkind);
602       break;
603     case STATE_CAP_SUPPLEMENTS:
604       s->supplements = adddepplain(pool, &pd->common, s->supplements, pd->content, 0, pd->capkind);
605       break;
606     case STATE_CAP_SUGGESTS:
607       s->suggests = adddepplain(pool, &pd->common, s->suggests, pd->content, 0, pd->capkind);
608       break;
609     case STATE_CAP_ENHANCES:
610       s->enhances = adddepplain(pool, &pd->common, s->enhances, pd->content, 0, pd->capkind);
611       break;
612     case STATE_CAP_FRESHENS:
613       s->freshens = adddepplain(pool, &pd->common, s->freshens, pd->content, 0, pd->capkind);
614       break;
615     case STATE_SUMMARY:
616       pd->lang = 0;
617       break;
618     case STATE_DESCRIPTION:
619       pd->lang = 0;
620       break;
621     default:
622       break;
623     }
624   pd->state = pd->sbtab[pd->state];
625   pd->docontent = 0;
626   //fprintf(stderr, "back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
627 }
628
629 static void XMLCALL
630 characterData(void *userData, const XML_Char *s, int len)
631 {
632   struct parsedata *pd = userData;
633   int l;
634   char *c;
635
636   if (!pd->docontent)
637     return;
638   l = pd->lcontent + len + 1;
639   if (l > pd->acontent)
640     {
641       pd->content = sat_realloc(pd->content, l + 256);
642       pd->acontent = l + 256;
643     }
644   c = pd->content + pd->lcontent;
645   pd->lcontent += len;
646   while (len-- > 0)
647     *c++ = *s++;
648   *c = 0;
649 }
650
651
652 #define BUFF_SIZE 8192
653
654 void
655 repo_add_rpmmd(Repo *repo, FILE *fp)
656 {
657   Pool *pool = repo->pool;
658   struct parsedata pd;
659   char buf[BUFF_SIZE];
660   int i, l;
661   struct stateswitch *sw;
662
663   memset(&pd, 0, sizeof(pd));
664   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
665     {
666       if (!pd.swtab[sw->from])
667         pd.swtab[sw->from] = sw;
668       pd.sbtab[sw->to] = sw->from;
669     }
670   pd.common.pool = pool;
671   pd.common.repo = repo;
672   pd.content = sat_malloc(256);
673   pd.acontent = 256;
674   pd.lcontent = 0;
675   pd.common.tmp = 0;
676   pd.common.tmpl = 0;
677   pd.kind = 0;
678   XML_Parser parser = XML_ParserCreate(NULL);
679   XML_SetUserData(parser, &pd);
680   XML_SetElementHandler(parser, startElement, endElement);
681   XML_SetCharacterDataHandler(parser, characterData);
682   for (;;)
683     {
684       l = fread(buf, 1, sizeof(buf), fp);
685       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
686         {
687           fprintf(stderr, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser));
688           exit(1);
689         }
690       if (l == 0)
691         break;
692     }
693   XML_ParserFree(parser);
694   if (pd.numpacks)
695     repo_free_solvable_block(repo, pd.solvable - pool->solvables, pd.numpacks, 1);
696   sat_free(pd.content);
697 }