ext/repo_appdata.c

   1 /*
   2  * repo_appdatadb.c
   3  *
   4  * Parses AppSteam Data files.
   5  * See http://people.freedesktop.org/~hughsient/appdata/
   6  *
   7  *
   8  * Copyright (c) 2013, 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 #include <errno.h>
  27
  28 #include "pool.h"
  29 #include "repo.h"
  30 #include "util.h"
  31 #include "repo_appdata.h"
  32
  33
  34 enum state {
  35   STATE_START,
  36   STATE_APPLICATION,
  37   STATE_ID,
  38   STATE_PKGNAME,
  39   STATE_LICENCE,
  40   STATE_NAME,
  41   STATE_SUMMARY,
  42   STATE_DESCRIPTION,
  43   STATE_P,
  44   STATE_UL,
  45   STATE_UL_LI,
  46   STATE_OL,
  47   STATE_OL_LI,
  48   STATE_URL,
  49   STATE_GROUP,
  50   STATE_KEYWORDS,
  51   STATE_KEYWORD,
  52   STATE_EXTENDS,
  53   NUMSTATES
  54 };
  55
  56 struct stateswitch {
  57   enum state from;
  58   char *ename;
  59   enum state to;
  60   int docontent;
  61 };
  62
  63 /* !! must be sorted by first column !! */
  64 static struct stateswitch stateswitches[] = {
  65   { STATE_START,       "applications",  STATE_START,         0 },
  66   { STATE_START,       "components",    STATE_START,         0 },
  67   { STATE_START,       "application",   STATE_APPLICATION,   0 },
  68   { STATE_START,       "component",     STATE_APPLICATION,   0 },
  69   { STATE_APPLICATION, "id",            STATE_ID,            1 },
  70   { STATE_APPLICATION, "pkgname",       STATE_PKGNAME,       1 },
  71   { STATE_APPLICATION, "product_license", STATE_LICENCE,     1 },
  72   { STATE_APPLICATION, "name",          STATE_NAME,          1 },
  73   { STATE_APPLICATION, "summary",       STATE_SUMMARY,       1 },
  74   { STATE_APPLICATION, "description",   STATE_DESCRIPTION,   0 },
  75   { STATE_APPLICATION, "url",           STATE_URL,           1 },
  76   { STATE_APPLICATION, "project_group", STATE_GROUP,         1 },
  77   { STATE_APPLICATION, "keywords",      STATE_KEYWORDS,      0 },
  78   { STATE_APPLICATION, "extends",       STATE_EXTENDS,       1 },
  79   { STATE_DESCRIPTION, "p",             STATE_P,             1 },
  80   { STATE_DESCRIPTION, "ul",            STATE_UL,            0 },
  81   { STATE_DESCRIPTION, "ol",            STATE_OL,            0 },
  82   { STATE_UL,          "li",            STATE_UL_LI,         1 },
  83   { STATE_OL,          "li",            STATE_OL_LI,         1 },
  84   { STATE_KEYWORDS,    "keyword",       STATE_KEYWORD,       1 },
  85   { NUMSTATES }
  86 };
  87
  88 struct parsedata {
  89   int depth;
  90   enum state state;
  91   int statedepth;
  92   char *content;
  93   int lcontent;
  94   int acontent;
  95   int docontent;
  96   Pool *pool;
  97   Repo *repo;
  98   Repodata *data;
  99
 100   struct stateswitch *swtab[NUMSTATES];
 101   enum state sbtab[NUMSTATES];
 102
 103   Solvable *solvable;
 104   Id handle;
 105
 106   char *description;
 107   int licnt;
 108   int skip_depth;
 109   int flags;
 110   char *desktop_file;
 111   int havesummary;
 112   const char *filename;
 113   Queue *owners;
 114 };
 115
 116
 117 static inline const char *
 118 find_attr(const char *txt, const char **atts)
 119 {
 120   for (; *atts; atts += 2)
 121     if (!strcmp(*atts, txt))
 122       return atts[1];
 123   return 0;
 124 }
 125
 126
 127 static void XMLCALL
 128 startElement(void *userData, const char *name, const char **atts)
 129 {
 130   struct parsedata *pd = userData;
 131   Pool *pool = pd->pool;
 132   Solvable *s = pd->solvable;
 133   struct stateswitch *sw;
 134   const char *type;
 135
 136 #if 0
 137   fprintf(stderr, "start: [%d]%s\n", pd->state, name);
 138 #endif
 139   if (pd->depth != pd->statedepth)
 140     {
 141       pd->depth++;
 142       return;
 143     }
 144
 145   pd->depth++;
 146   if (!pd->swtab[pd->state])    /* no statetable -> no substates */
 147     {
 148 #if 0
 149       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
 150 #endif
 151       return;
 152     }
 153   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
 154     if (!strcmp(sw->ename, name))
 155       break;
 156
 157   if (sw->from != pd->state)
 158     {
 159 #if 0
 160       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
 161 #endif
 162       return;
 163     }
 164   pd->state = sw->to;
 165   pd->docontent = sw->docontent;
 166   pd->statedepth = pd->depth;
 167   pd->lcontent = 0;
 168   *pd->content = 0;
 169
 170   if (!pd->skip_depth && find_attr("xml:lang", atts))
 171     pd->skip_depth = pd->depth;
 172   if (pd->skip_depth)
 173     {
 174       pd->docontent = 0;
 175       return;
 176     }
 177
 178   switch(pd->state)
 179     {
 180     case STATE_APPLICATION:
 181       type = find_attr("type", atts);
 182       if (!type || !*type)
 183         type = "desktop";
 184       if (strcmp(type, "desktop") != 0)
 185         {
 186           /* ignore for now */
 187           pd->solvable = 0;
 188           break;
 189         }
 190       s = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 191       pd->handle = s - pool->solvables;
 192       pd->havesummary = 0;
 193       repodata_set_poolstr(pd->data, pd->handle, SOLVABLE_CATEGORY, type);
 194       break;
 195     case STATE_DESCRIPTION:
 196       pd->description = solv_free(pd->description);
 197       break;
 198     case STATE_OL:
 199     case STATE_UL:
 200       pd->licnt = 0;
 201       break;
 202     default:
 203       break;
 204     }
 205 }
 206
 207 /* replace whitespace with one space/newline */
 208 /* also strip starting/ending whitespace */
 209 static void
 210 wsstrip(struct parsedata *pd)
 211 {
 212   int i, j;
 213   int ws = 0;
 214   for (i = j = 0; pd->content[i]; i++)
 215     {
 216       if (pd->content[i] == ' ' || pd->content[i] == '\t' || pd->content[i] == '\n')
 217         {
 218           ws |= pd->content[i] == '\n' ? 2 : 1;
 219           continue;
 220         }
 221       if (ws && j)
 222         pd->content[j++] = (ws & 2) ? '\n' : ' ';
 223       ws = 0;
 224       pd->content[j++] = pd->content[i];
 225     }
 226   pd->content[j] = 0;
 227   pd->lcontent = j;
 228 }
 229
 230 /* indent all lines */
 231 static void
 232 indent(struct parsedata *pd, int il)
 233 {
 234   int i, l;
 235   for (l = 0; pd->content[l]; )
 236     {
 237       if (pd->content[l] == '\n')
 238         {
 239           l++;
 240           continue;
 241         }
 242       if (pd->lcontent + il + 1 > pd->acontent)
 243         {
 244           pd->acontent = pd->lcontent + il + 256;
 245           pd->content = realloc(pd->content, pd->acontent);
 246         }
 247       memmove(pd->content + l + il, pd->content + l, pd->lcontent - l + 1);
 248       for (i = 0; i < il; i++)
 249         pd->content[l + i] = ' ';
 250       pd->lcontent += il;
 251       while (pd->content[l] && pd->content[l] != '\n')
 252         l++;
 253     }
 254 }
 255
 256 static void
 257 add_missing_tags_from_desktop_file(struct parsedata *pd, Solvable *s, const char *desktop_file)
 258 {
 259   Pool *pool = pd->pool;
 260   FILE *fp;
 261   const char *filepath;
 262   char buf[1024];
 263   char *p, *p2, *p3;
 264   int inde = 0;
 265
 266   filepath = pool_tmpjoin(pool, "/usr/share/applications/", desktop_file, 0);
 267   if (pd->flags & REPO_USE_ROOTDIR)
 268     filepath = pool_prepend_rootdir_tmp(pool, filepath);
 269   if (!(fp = fopen(filepath, "r")))
 270     return;
 271   while (fgets(buf, sizeof(buf), fp) > 0)
 272     {
 273       int c, l = strlen(buf);
 274       if (!l)
 275         continue;
 276       if (buf[l - 1] != '\n')
 277         {
 278           /* ignore overlong lines */
 279           while ((c = getc(fp)) != EOF)
 280             if (c == '\n')
 281               break;
 282           if (c == EOF)
 283             break;
 284           continue;
 285         }
 286       buf[--l] = 0;
 287       while (l && (buf[l - 1] == ' ' || buf[l - 1] == '\t'))
 288         buf[--l] = 0;
 289       p = buf;
 290       while (*p == ' ' || *p == '\t')
 291         p++;
 292       if (!*p || *p == '#')
 293         continue;
 294       if (*p == '[')
 295         inde = 0;
 296       if (!strcmp(p, "[Desktop Entry]"))
 297         {
 298           inde = 1;
 299           continue;
 300         }
 301       if (!inde)
 302         continue;
 303       p2 = strchr(p, '=');
 304       if (!p2 || p2 == p)
 305         continue;
 306       *p2 = 0;
 307       for (p3 = p2 - 1; *p3 == ' ' || *p3 == '\t'; p3--)
 308         *p3 = 0;
 309       p2++;
 310       while (*p2 == ' ' || *p2 == '\t')
 311         p2++;
 312       if (!*p2)
 313         continue;
 314       if (!s->name && !strcmp(p, "Name"))
 315         s->name = pool_str2id(pool, pool_tmpjoin(pool, "application:", p2, 0), 1);
 316       else if (!pd->havesummary && !strcmp(p, "Comment"))
 317         {
 318           pd->havesummary = 1;
 319           repodata_set_str(pd->data, pd->handle, SOLVABLE_SUMMARY, p2);
 320         }
 321       else
 322         continue;
 323       if (s->name && pd->havesummary)
 324         break;  /* our work is done */
 325     }
 326   fclose(fp);
 327 }
 328
 329 static char *
 330 guess_filename_from_id(Pool *pool, const char *id)
 331 {
 332   int l = strlen(id);
 333   char *r = pool_tmpjoin(pool, id, ".metainfo.xml", 0);
 334   if (l > 8 && !strcmp(".desktop", id + l - 8))
 335     strcpy(r + l - 8, ".appdata.xml");
 336   else if (l > 4 && !strcmp(".ttf", id + l - 4))
 337     strcpy(r + l - 4, ".metainfo.xml");
 338   else if (l > 4 && !strcmp(".otf", id + l - 4))
 339     strcpy(r + l - 4, ".metainfo.xml");
 340   else if (l > 4 && !strcmp(".xml", id + l - 4))
 341     strcpy(r + l - 4, ".metainfo.xml");
 342   else if (l > 3 && !strcmp(".db", id + l - 3))
 343     strcpy(r + l - 3, ".metainfo.xml");
 344   else
 345     return 0;
 346   return r;
 347 }
 348
 349 static void XMLCALL
 350 endElement(void *userData, const char *name)
 351 {
 352   struct parsedata *pd = userData;
 353   Pool *pool = pd->pool;
 354   Solvable *s = pd->solvable;
 355   Id id;
 356
 357 #if 0
 358   fprintf(stderr, "end: [%d]%s\n", pd->state, name);
 359 #endif
 360   if (pd->depth != pd->statedepth)
 361     {
 362       pd->depth--;
 363 #if 0
 364       fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 365 #endif
 366       return;
 367     }
 368
 369   pd->depth--;
 370   pd->statedepth--;
 371
 372   if (pd->skip_depth && pd->depth + 1 >= pd->skip_depth)
 373     {
 374       if (pd->depth + 1 == pd->skip_depth)
 375         pd->skip_depth = 0;
 376       pd->state = pd->sbtab[pd->state];
 377       pd->docontent = 0;
 378       return;
 379     }
 380   pd->skip_depth = 0;
 381
 382   if (!s)
 383     {
 384       pd->state = pd->sbtab[pd->state];
 385       pd->docontent = 0;
 386       return;
 387     }
 388
 389   switch (pd->state)
 390     {
 391     case STATE_APPLICATION:
 392       if (!s->arch)
 393         s->arch = ARCH_NOARCH;
 394       if (!s->evr)
 395         s->evr = ID_EMPTY;
 396       if ((!s->name || !pd->havesummary) && (pd->flags & APPDATA_CHECK_DESKTOP_FILE) != 0 && pd->desktop_file)
 397         add_missing_tags_from_desktop_file(pd, s, pd->desktop_file);
 398       if (!s->name && pd->desktop_file)
 399         {
 400           char *name = pool_tmpjoin(pool, "application:", pd->desktop_file, 0);
 401           int l = strlen(name);
 402           if (l > 8 && !strcmp(".desktop", name + l - 8))
 403             l -= 8;
 404           s->name = pool_strn2id(pool, name, l, 1);
 405         }
 406       if (!s->requires && pd->owners)
 407         {
 408           int i;
 409           Id id;
 410           for (i = 0; i < pd->owners->count; i++)
 411             {
 412               Solvable *os = pd->pool->solvables + pd->owners->elements[i];
 413               s->requires = repo_addid_dep(pd->repo, s->requires, os->name, 0);
 414               id = pool_str2id(pd->pool, pool_tmpjoin(pd->pool, "application-appdata(", pool_id2str(pd->pool, os->name), ")"), 1);
 415               s->provides = repo_addid_dep(pd->repo, s->provides, id, 0);
 416             }
 417         }
 418       if (!s->requires && (pd->desktop_file || pd->filename))
 419         {
 420           /* add appdata() link requires/provides */
 421           const char *filename = pd->filename;
 422           if (!filename)
 423             filename = guess_filename_from_id(pool, pd->desktop_file);
 424           if (filename)
 425             {
 426               filename = pool_tmpjoin(pool, "application-appdata(", filename, ")");
 427               s->requires = repo_addid_dep(pd->repo, s->requires, pool_str2id(pd->pool, filename + 12, 1), 0);
 428               s->provides = repo_addid_dep(pd->repo, s->provides, pool_str2id(pd->pool, filename, 1), 0);
 429             }
 430         }
 431       if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 432         s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
 433       pd->solvable = 0;
 434       pd->desktop_file = solv_free(pd->desktop_file);
 435       break;
 436     case STATE_ID:
 437       pd->desktop_file = solv_strdup(pd->content);
 438       break;
 439     case STATE_NAME:
 440       s->name = pool_str2id(pd->pool, pool_tmpjoin(pool, "application:", pd->content, 0), 1);
 441       break;
 442     case STATE_LICENCE:
 443       repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_LICENSE, pd->content);
 444       break;
 445     case STATE_SUMMARY:
 446       pd->havesummary = 1;
 447       repodata_set_str(pd->data, pd->handle, SOLVABLE_SUMMARY, pd->content);
 448       break;
 449     case STATE_URL:
 450       repodata_set_str(pd->data, pd->handle, SOLVABLE_URL, pd->content);
 451       break;
 452     case STATE_GROUP:
 453       repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_GROUP, pd->content);
 454       break;
 455     case STATE_EXTENDS:
 456       repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_EXTENDS, pd->content);
 457       break;
 458     case STATE_DESCRIPTION:
 459       if (pd->description)
 460         {
 461           /* strip trailing newlines */
 462           int l = strlen(pd->description);
 463           while (l && pd->description[l - 1] == '\n')
 464             pd->description[--l] = 0;
 465           repodata_set_str(pd->data, pd->handle, SOLVABLE_DESCRIPTION, pd->description);
 466         }
 467       break;
 468     case STATE_P:
 469       wsstrip(pd);
 470       pd->description = solv_dupappend(pd->description, pd->content, "\n\n");
 471       break;
 472     case STATE_UL_LI:
 473       wsstrip(pd);
 474       indent(pd, 4);
 475       pd->content[2] = '-';
 476       pd->description = solv_dupappend(pd->description, pd->content, "\n");
 477       break;
 478     case STATE_OL_LI:
 479       wsstrip(pd);
 480       indent(pd, 4);
 481       if (++pd->licnt >= 10)
 482         pd->content[0] = '0' + (pd->licnt / 10) % 10;
 483       pd->content[1] = '0' + pd->licnt  % 10;
 484       pd->content[2] = '.';
 485       pd->description = solv_dupappend(pd->description, pd->content, "\n");
 486       break;
 487     case STATE_UL:
 488     case STATE_OL:
 489       pd->description = solv_dupappend(pd->description, "\n", 0);
 490       break;
 491     case STATE_PKGNAME:
 492       id = pool_str2id(pd->pool, pd->content, 1);
 493       s->requires = repo_addid_dep(pd->repo, s->requires, id, 0);
 494       id = pool_str2id(pd->pool, pool_tmpjoin(pd->pool, "application-appdata(", pd->content, ")"), 1);
 495       s->provides = repo_addid_dep(pd->repo, s->provides, id, 0);
 496       break;
 497     case STATE_KEYWORD:
 498       repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_KEYWORDS, pd->content);
 499       break;
 500     default:
 501       break;
 502     }
 503
 504   pd->state = pd->sbtab[pd->state];
 505   pd->docontent = 0;
 506
 507 #if 0
 508   fprintf(stderr, "end: [%s] -> %d\n", name, pd->state);
 509 #endif
 510 }
 511
 512
 513 static void XMLCALL
 514 characterData(void *userData, const XML_Char *s, int len)
 515 {
 516   struct parsedata *pd = userData;
 517   int l;
 518   char *c;
 519   if (!pd->docontent)
 520     return;
 521   l = pd->lcontent + len + 1;
 522   if (l > pd->acontent)
 523     {
 524       pd->acontent = l + 256;
 525       pd->content = realloc(pd->content, pd->acontent);
 526     }
 527   c = pd->content + pd->lcontent;
 528   pd->lcontent += len;
 529   while (len-- > 0)
 530     *c++ = *s++;
 531   *c = 0;
 532 }
 533
 534 #define BUFF_SIZE 8192
 535
 536 static int
 537 repo_add_appdata_fn(Repo *repo, FILE *fp, int flags, const char *filename, Queue *owners)
 538 {
 539   Pool *pool = repo->pool;
 540   struct parsedata pd;
 541   struct stateswitch *sw;
 542   Repodata *data;
 543   char buf[BUFF_SIZE];
 544   int i, l;
 545   int ret = 0;
 546
 547   data = repo_add_repodata(repo, flags);
 548   memset(&pd, 0, sizeof(pd));
 549   pd.repo = repo;
 550   pd.pool = repo->pool;
 551   pd.data = data;
 552   pd.flags = flags;
 553   pd.filename = filename;
 554   pd.owners = owners;
 555
 556   pd.content = malloc(256);
 557   pd.acontent = 256;
 558
 559   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 560     {
 561       if (!pd.swtab[sw->from])
 562         pd.swtab[sw->from] = sw;
 563       pd.sbtab[sw->to] = sw->from;
 564     }
 565
 566   XML_Parser parser = XML_ParserCreate(NULL);
 567   XML_SetUserData(parser, &pd);
 568   XML_SetElementHandler(parser, startElement, endElement);
 569   XML_SetCharacterDataHandler(parser, characterData);
 570
 571   for (;;)
 572     {
 573       l = fread(buf, 1, sizeof(buf), fp);
 574       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 575         {
 576           pool_error(pool, -1, "repo_appdata: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 577           if (pd.solvable)
 578             {
 579               repo_free_solvable(repo, pd.solvable - pd.pool->solvables, 1);
 580               pd.solvable = 0;
 581             }
 582           ret = -1;
 583           break;
 584         }
 585       if (l == 0)
 586         break;
 587     }
 588   XML_ParserFree(parser);
 589
 590   if (!(flags & REPO_NO_INTERNALIZE))
 591     repodata_internalize(data);
 592
 593   solv_free(pd.content);
 594   solv_free(pd.desktop_file);
 595   solv_free(pd.description);
 596   return ret;
 597 }
 598
 599 int
 600 repo_add_appdata(Repo *repo, FILE *fp, int flags)
 601 {
 602   return repo_add_appdata_fn(repo, fp, flags, 0, 0);
 603 }
 604
 605 static void
 606 search_uninternalized_filelist(Repo *repo, const char *dir, Queue *res)
 607 {
 608   Pool *pool = repo->pool;
 609   Id rdid, p;
 610   Id iter, did, idid;
 611
 612   for (rdid = 1; rdid < repo->nrepodata; rdid++)
 613     {
 614       Repodata *data = repo_id2repodata(repo, rdid);
 615       if (!data)
 616         continue;
 617       if (data->state == REPODATA_STUB)
 618         continue;
 619       if (!repodata_has_keyname(data, SOLVABLE_FILELIST))
 620         continue;
 621       did = repodata_str2dir(data, dir, 0);
 622       if (!did)
 623         continue;
 624       for (p = data->start; p < data->end; p++)
 625         {
 626           if (p >= pool->nsolvables)
 627             continue;
 628           if (pool->solvables[p].repo != repo)
 629             continue;
 630           iter = 0;
 631           for (;;)
 632             {
 633               const char *str;
 634               int l;
 635               Id id;
 636               idid = did;
 637               str = repodata_lookup_dirstrarray_uninternalized(data, p, SOLVABLE_FILELIST, &idid, &iter);
 638               if (!iter)
 639                 break;
 640               l = strlen(str);
 641               if (l > 12 && strncmp(str + l - 12, ".appdata.xml", 12))
 642                 id = pool_str2id(pool, str, 1);
 643               else if (l > 13 && strncmp(str + l - 13, ".metainfo.xml", 13))
 644                 id = pool_str2id(pool, str, 1);
 645               else
 646                 continue;
 647               queue_push2(res, p, id);
 648             }
 649         }
 650     }
 651 }
 652
 653 /* add all files ending in .appdata.xml */
 654 int
 655 repo_add_appdata_dir(Repo *repo, const char *appdatadir, int flags)
 656 {
 657   DIR *dir;
 658   char *dirpath;
 659   Repodata *data;
 660   Queue flq;
 661   Queue oq;
 662
 663   queue_init(&flq);
 664   queue_init(&oq);
 665   if (flags & APPDATA_SEARCH_UNINTERNALIZED_FILELIST)
 666     search_uninternalized_filelist(repo, appdatadir, &flq);
 667   data = repo_add_repodata(repo, flags);
 668   if (flags & REPO_USE_ROOTDIR)
 669     dirpath = pool_prepend_rootdir(repo->pool, appdatadir);
 670   else
 671     dirpath = solv_strdup(appdatadir);
 672   if ((dir = opendir(dirpath)) != 0)
 673     {
 674       struct dirent *entry;
 675       while ((entry = readdir(dir)))
 676         {
 677           const char *n;
 678           FILE *fp;
 679           int len = strlen(entry->d_name);
 680           if (entry->d_name[0] == '.')
 681             continue;
 682           if (!(len > 12 && !strcmp(entry->d_name + len - 12, ".appdata.xml")) &&
 683               !(len > 13 && !strcmp(entry->d_name + len - 13, ".metainfo.xml")))
 684             continue;
 685           n = pool_tmpjoin(repo->pool, dirpath, "/", entry->d_name);
 686           fp = fopen(n, "r");
 687           if (!fp)
 688             {
 689               pool_error(repo->pool, 0, "%s: %s", n, strerror(errno));
 690               continue;
 691             }
 692           if (flags & APPDATA_SEARCH_UNINTERNALIZED_FILELIST)
 693             {
 694               Id id = pool_str2id(repo->pool, entry->d_name, 0);
 695               queue_empty(&oq);
 696               if (id)
 697                 {
 698                   int i;
 699                   for (i = 0; i < flq.count; i += 2)
 700                     if (flq.elements[i + 1] == id)
 701                       queue_push(&oq, flq.elements[i]);
 702                 }
 703             }
 704           repo_add_appdata_fn(repo, fp, flags | REPO_NO_INTERNALIZE | REPO_REUSE_REPODATA | APPDATA_CHECK_DESKTOP_FILE, entry->d_name, oq.count ? &oq : 0);
 705           fclose(fp);
 706         }
 707       closedir(dir);
 708     }
 709   solv_free(dirpath);
 710   if (!(flags & REPO_NO_INTERNALIZE))
 711     repodata_internalize(data);
 712   queue_free(&oq);
 713   queue_free(&flq);
 714   return 0;
 715 }