tools/dumpsolv.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 <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12
  13 static int with_attr;
  14 static int dump_json;
  15
  16 #include "pool.h"
  17 #include "repo_solv.h"
  18
  19
  20 static int
  21 dump_attr(Repo *repo, Repodata *data, Repokey *key, KeyValue *kv)
  22 {
  23   const char *keyname;
  24   KeyValue *kvp;
  25   int indent = 0;
  26
  27   keyname = pool_id2str(repo->pool, key->name);
  28   for (kvp = kv; (kvp = kvp->parent) != 0; indent += 2)
  29     printf("  ");
  30   switch(key->type)
  31     {
  32     case REPOKEY_TYPE_ID:
  33       if (data && data->localpool)
  34         kv->str = stringpool_id2str(&data->spool, kv->id);
  35       else
  36         kv->str = pool_dep2str(repo->pool, kv->id);
  37       printf("%s: %s\n", keyname, kv->str);
  38       break;
  39     case REPOKEY_TYPE_CONSTANTID:
  40       printf("%s: %s\n", keyname, pool_dep2str(repo->pool, kv->id));
  41       break;
  42     case REPOKEY_TYPE_IDARRAY:
  43       if (!kv->entry)
  44         printf("%s:\n%*s", keyname, indent, "");
  45       if (data && data->localpool)
  46         printf("  %s\n", stringpool_id2str(&data->spool, kv->id));
  47       else
  48         printf("  %s\n", pool_dep2str(repo->pool, kv->id));
  49       break;
  50     case REPOKEY_TYPE_STR:
  51       printf("%s: %s\n", keyname, kv->str);
  52       break;
  53     case REPOKEY_TYPE_MD5:
  54     case REPOKEY_TYPE_SHA1:
  55     case REPOKEY_TYPE_SHA256:
  56       printf("%s: %s (%s)\n", keyname, repodata_chk2str(data, key->type, (unsigned char *)kv->str), pool_id2str(repo->pool, key->type));
  57       break;
  58     case REPOKEY_TYPE_VOID:
  59       printf("%s: (void)\n", keyname);
  60       break;
  61     case REPOKEY_TYPE_U32:
  62     case REPOKEY_TYPE_CONSTANT:
  63       printf("%s: %u\n", keyname, kv->num);
  64       break;
  65     case REPOKEY_TYPE_NUM:
  66       printf("%s: %llu\n", keyname, SOLV_KV_NUM64(kv));
  67       break;
  68     case REPOKEY_TYPE_BINARY:
  69       if (kv->num)
  70         printf("%s: %02x..%02x len %u\n", keyname, (unsigned char)kv->str[0], (unsigned char)kv->str[kv->num - 1], kv->num);
  71       else
  72         printf("%s: len 0\n", keyname);
  73       break;
  74     case REPOKEY_TYPE_DIRNUMNUMARRAY:
  75       if (!kv->entry)
  76         printf("%s:\n%*s", keyname, indent, "");
  77       printf("  %s %u %u\n", repodata_dir2str(data, kv->id, 0), kv->num, kv->num2);
  78       break;
  79     case REPOKEY_TYPE_DIRSTRARRAY:
  80       if (!kv->entry)
  81         printf("%s:\n%*s", keyname, indent, "");
  82       printf("  %s\n", repodata_dir2str(data, kv->id, kv->str));
  83       break;
  84     case REPOKEY_TYPE_FIXARRAY:
  85     case REPOKEY_TYPE_FLEXARRAY:
  86       if (!kv->entry)
  87         printf("%s:\n", keyname);
  88       else
  89         printf("\n");
  90       break;
  91     default:
  92       printf("%s: ?\n", keyname);
  93       break;
  94     }
  95   return 0;
  96 }
  97
  98 static const char *
  99 jsonstring(Pool *pool, const char *s)
 100 {
 101   int needed = 0;
 102   const unsigned char *s1;
 103   char *r, *rp;
 104
 105   for (s1 = (const unsigned char *)s; *s1; s1++)
 106     {
 107       if (*s1 < 32)
 108         needed += *s1 == '\n' ? 2 : 6;
 109       else if (*s1 == '\\' || *s1 == '\"')
 110         needed += 2;
 111       else
 112         needed++;
 113     }
 114   r = rp = pool_alloctmpspace(pool, needed + 3);
 115   *rp++ = '\"';
 116   for (s1 = (const unsigned char *)s; *s1; s1++)
 117     {
 118       if (*s1 < 32)
 119         {
 120           int x;
 121           if (*s1 == '\n')
 122             {
 123               *rp++ = '\\';
 124               *rp++ = 'n';
 125               continue;
 126             }
 127           *rp++ = '\\';
 128           *rp++ = 'u';
 129           *rp++ = '0';
 130           *rp++ = '0';
 131           x = *s1 / 16;
 132           *rp++ = (x < 10 ? '0' : 'a' - 10) + x;
 133           x = *s1 & 15;
 134           *rp++ = (x < 10 ? '0' : 'a' - 10) + x;
 135         }
 136       else if (*s1 == '\\' || *s1 == '\"')
 137         {
 138           *rp++ = '\\';
 139           *rp++ = *s1;
 140         }
 141       else
 142         *rp++ = *s1;
 143     }
 144   *rp++ = '\"';
 145   *rp = 0;
 146   return r;
 147 }
 148
 149 struct cbdata {
 150   unsigned char *first;
 151   int nfirst;
 152   int baseindent;
 153 };
 154
 155 static int
 156 dump_attr_json(Repo *repo, Repodata *data, Repokey *key, KeyValue *kv, struct cbdata *cbdata)
 157 {
 158   Pool *pool = repo->pool;
 159   const char *keyname;
 160   KeyValue *kvp;
 161   int indent = cbdata->baseindent;
 162   int isarray = 0;
 163   const char *str;
 164   int depth = 0;
 165
 166   keyname = pool_id2str(repo->pool, key->name);
 167   for (kvp = kv; (kvp = kvp->parent) != 0; indent += 4)
 168     depth++;
 169   if (cbdata->nfirst < depth + 1)
 170     {
 171       cbdata->first = solv_realloc(cbdata->first, depth + 16);
 172       memset(cbdata->first + cbdata->nfirst, 0, depth + 16 - cbdata->nfirst);
 173       cbdata->nfirst = depth + 16;
 174     }
 175   switch(key->type)
 176     {
 177     case REPOKEY_TYPE_IDARRAY:
 178     case REPOKEY_TYPE_DIRNUMNUMARRAY:
 179     case REPOKEY_TYPE_DIRSTRARRAY:
 180       isarray = 1;
 181       break;
 182     case REPOKEY_TYPE_FIXARRAY:
 183     case REPOKEY_TYPE_FLEXARRAY:
 184       isarray = 2;
 185       break;
 186     default:
 187       break;
 188     }
 189   if (!isarray || !kv->entry)
 190     {
 191       if (cbdata->first[depth])
 192         printf(",\n");
 193       printf("%*s%s: ", indent, "", jsonstring(pool, keyname));
 194       cbdata->first[depth] = 1;
 195     }
 196   if (isarray == 1 && !kv->entry)
 197     printf("[\n%*s", indent + 2, "");
 198   else if (isarray == 1 && kv->entry)
 199     printf("%*s", indent + 2, "");
 200   switch(key->type)
 201     {
 202     case REPOKEY_TYPE_ID:
 203       if (data && data->localpool)
 204         str = stringpool_id2str(&data->spool, kv->id);
 205       else
 206         str = pool_dep2str(repo->pool, kv->id);
 207       printf("%s", jsonstring(pool, str));
 208       break;
 209     case REPOKEY_TYPE_CONSTANTID:
 210       str = pool_dep2str(repo->pool, kv->id);
 211       printf("%s", jsonstring(pool, str));
 212       break;
 213     case REPOKEY_TYPE_IDARRAY:
 214       if (data && data->localpool)
 215         str = stringpool_id2str(&data->spool, kv->id);
 216       else
 217         str = pool_dep2str(repo->pool, kv->id);
 218       printf("%s", jsonstring(pool, str));
 219       break;
 220     case REPOKEY_TYPE_STR:
 221       str = kv->str;
 222       printf("%s", jsonstring(pool, str));
 223       break;
 224     case REPOKEY_TYPE_MD5:
 225     case REPOKEY_TYPE_SHA1:
 226     case REPOKEY_TYPE_SHA256:
 227       printf("{\n");
 228       printf("%*s  \"value\": %s,\n", indent, "", jsonstring(pool, repodata_chk2str(data, key->type, (unsigned char *)kv->str)));
 229       printf("%*s  \"type\": %s\n", indent, "", jsonstring(pool, pool_id2str(repo->pool, key->type)));
 230       printf("%*s}", indent, "");
 231       break;
 232     case REPOKEY_TYPE_VOID:
 233       printf("null");
 234       break;
 235     case REPOKEY_TYPE_U32:
 236     case REPOKEY_TYPE_CONSTANT:
 237       printf("%u", kv->num);
 238       break;
 239     case REPOKEY_TYPE_NUM:
 240       printf("%llu", SOLV_KV_NUM64(kv));
 241       break;
 242     case REPOKEY_TYPE_BINARY:
 243       printf("\"<binary>\"");
 244       break;
 245     case REPOKEY_TYPE_DIRNUMNUMARRAY:
 246       printf("{\n");
 247       printf("%*s    \"dir\": %s,\n", indent, "", jsonstring(pool, repodata_dir2str(data, kv->id, 0)));
 248       printf("%*s    \"num1\": %u,\n", indent, "", kv->num);
 249       printf("%*s    \"num2\": %u\n", indent, "", kv->num2);
 250       printf("%*s  }", indent, "");
 251       break;
 252     case REPOKEY_TYPE_DIRSTRARRAY:
 253       printf("%s", jsonstring(pool, repodata_dir2str(data, kv->id, kv->str)));
 254       break;
 255     case REPOKEY_TYPE_FIXARRAY:
 256     case REPOKEY_TYPE_FLEXARRAY:
 257       cbdata->first[depth + 1] = 0;
 258       if (!kv->entry)
 259         printf("[\n");
 260       else
 261         {
 262           if (kv->eof != 2)
 263             printf("\n%*s  },\n", indent, "");
 264           else
 265             printf("\n%*s  }\n", indent, "");
 266         }
 267       if (kv->eof != 2)
 268         printf("%*s  {\n", indent, "");
 269       else
 270         printf("%*s]", indent, "");
 271       break;
 272     default:
 273       printf("\"?\"");
 274       break;
 275     }
 276   if (isarray == 1)
 277     {
 278       if (!kv->eof)
 279         printf(",\n");
 280       else
 281         printf("\n%*s]", indent, "");
 282     }
 283   return 0;
 284 }
 285
 286 static int
 287 dump_repodata_cb(void *vcbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
 288 {
 289   if (key->name == REPOSITORY_SOLVABLES)
 290     return SEARCH_NEXT_SOLVABLE;
 291   if (!dump_json)
 292     return dump_attr(data->repo, data, key, kv);
 293   else
 294     return dump_attr_json(data->repo, data, key, kv, vcbdata);
 295 }
 296
 297 static void
 298 dump_repodata(Repo *repo, struct cbdata *cbdata)
 299 {
 300   unsigned int i;
 301   Repodata *data;
 302   if (repo->nrepodata == 0)
 303     return;
 304   if (!dump_json)
 305     printf("repo contains %d repodata sections:\n", repo->nrepodata - 1);
 306   cbdata->baseindent = 6;
 307   FOR_REPODATAS(repo, i, data)
 308     {
 309       unsigned int j;
 310       if (!dump_json)
 311         {
 312           printf("\nrepodata %d has %d keys, %d schemata\n", i, data->nkeys - 1, data->nschemata - 1);
 313           for (j = 1; j < data->nkeys; j++)
 314             printf("  %s (type %s size %d storage %d)\n", pool_id2str(repo->pool, data->keys[j].name), pool_id2str(repo->pool, data->keys[j].type), data->keys[j].size, data->keys[j].storage);
 315           if (data->localpool)
 316             printf("  localpool has %d strings, size is %d\n", data->spool.nstrings, data->spool.sstrings);
 317           if (data->dirpool.ndirs)
 318             printf("  localpool has %d directories\n", data->dirpool.ndirs);
 319           printf("\n");
 320         }
 321       repodata_search(data, SOLVID_META, 0, SEARCH_ARRAYSENTINEL|SEARCH_SUB, dump_repodata_cb, cbdata);
 322     }
 323   if (!dump_json)
 324     printf("\n");
 325 }
 326
 327 /*
 328  * dump all attributes for Id <p>
 329  */
 330
 331 void
 332 dump_solvable(Repo *repo, Id p, struct cbdata *cbdata)
 333 {
 334   Dataiterator di;
 335   dataiterator_init(&di, repo->pool, repo, p, 0, 0, SEARCH_ARRAYSENTINEL|SEARCH_SUB);
 336   if (cbdata->first)
 337     cbdata->first[0] = 0;
 338   cbdata->baseindent = 10;
 339   while (dataiterator_step(&di))
 340     {
 341       if (!dump_json)
 342         dump_attr(repo, di.data, di.key, &di.kv);
 343       else
 344         dump_attr_json(repo, di.data, di.key, &di.kv, cbdata);
 345     }
 346 }
 347
 348 static int
 349 loadcallback(Pool *pool, Repodata *data, void *vdata)
 350 {
 351   FILE *fp = 0;
 352   int r;
 353   const char *location;
 354
 355   location = repodata_lookup_str(data, SOLVID_META, REPOSITORY_LOCATION);
 356   if (!location || !with_attr)
 357     return 0;
 358   fprintf(stderr, "[Loading SOLV file %s]\n", location);
 359   fp = fopen (location, "r");
 360   if (!fp)
 361     {
 362       perror(location);
 363       return 0;
 364     }
 365   r = repo_add_solv(data->repo, fp, REPO_USE_LOADING|REPO_LOCALPOOL);
 366   fclose(fp);
 367   return !r ? 1 : 0;
 368 }
 369
 370
 371 static void
 372 usage(int status)
 373 {
 374   fprintf( stderr, "\nUsage:\n"
 375            "dumpsolv [-a] [-j] [<solvfile>]\n"
 376            "  -a  read attributes.\n"
 377            "  -j  dump json format.\n"
 378            );
 379   exit(status);
 380 }
 381
 382 int main(int argc, char **argv)
 383 {
 384   Repo *repo;
 385   Pool *pool;
 386   int c, i, j, n;
 387   Solvable *s;
 388   int openrepo = 0;
 389   struct cbdata cbdata;
 390
 391   memset(&cbdata, 0, sizeof(cbdata));
 392   pool = pool_create();
 393   pool_setloadcallback(pool, loadcallback, 0);
 394
 395   while ((c = getopt(argc, argv, "haj")) >= 0)
 396     {
 397       switch(c)
 398         {
 399         case 'h':
 400           usage(0);
 401           break;
 402         case 'a':
 403           with_attr = 1;
 404           break;
 405         case 'j':
 406           dump_json = 1;
 407           break;
 408         default:
 409           usage(1);
 410           break;
 411         }
 412     }
 413   if (!dump_json)
 414     pool_setdebuglevel(pool, 1);
 415   if (dump_json)
 416     pool->debugmask |= SOLV_DEBUG_TO_STDERR;
 417   for (; optind < argc; optind++)
 418     {
 419       if (freopen(argv[optind], "r", stdin) == 0)
 420         {
 421           perror(argv[optind]);
 422           exit(1);
 423         }
 424       repo = repo_create(pool, argv[optind]);
 425       if (repo_add_solv(repo, stdin, 0))
 426         {
 427           fprintf(stderr, "could not read repository: %s\n", pool_errstr(pool));
 428           exit(1);
 429         }
 430     }
 431   if (!pool->urepos)
 432     {
 433       repo = repo_create(pool, argc != 1 ? argv[1] : "<stdin>");
 434       if (repo_add_solv(repo, stdin, 0))
 435         {
 436           fprintf(stderr, "could not read repository: %s\n", pool_errstr(pool));
 437           exit(1);
 438         }
 439     }
 440   if (!dump_json)
 441     printf("pool contains %d strings, %d rels, string size is %d\n", pool->ss.nstrings, pool->nrels, pool->ss.sstrings);
 442
 443   if (dump_json)
 444     {
 445       printf("{\n");
 446       printf("  \"repositories\": [\n");
 447     }
 448   n = 0;
 449   FOR_REPOS(j, repo)
 450     {
 451       int open = 0;
 452       if (dump_json)
 453         {
 454           if (openrepo)
 455             printf("\n    },");
 456           printf("    {\n");
 457           openrepo = 1;
 458           if (cbdata.first)
 459             cbdata.first[0] = 0;
 460         }
 461       dump_repodata(repo, &cbdata);
 462       if (!dump_json)
 463         {
 464           printf("repo %d contains %d solvables\n", j, repo->nsolvables);
 465           printf("repo start: %d end: %d\n", repo->start, repo->end);
 466         }
 467       else
 468         {
 469           if (cbdata.first[0])
 470             printf(",\n");
 471           printf("      \"solvables\": [\n");
 472         }
 473       FOR_REPO_SOLVABLES(repo, i, s)
 474         {
 475           n++;
 476           if (!dump_json)
 477             {
 478               printf("\n");
 479               printf("solvable %d (%d):\n", n, i);
 480             }
 481           else
 482             {
 483               if (open)
 484                 printf("\n        },\n");
 485               printf("        {\n");
 486               open = 1;
 487             }
 488           dump_solvable(repo, i, &cbdata);
 489         }
 490       if (dump_json)
 491         {
 492           if (open)
 493             printf("\n        }\n");
 494           printf("      ]\n");
 495         }
 496     }
 497   if (dump_json)
 498     {
 499       if (openrepo)
 500         printf("    }\n");
 501       printf("  ]\n");
 502       printf("}\n");
 503     }
 504   pool_free(pool);
 505   solv_free(cbdata.first);
 506   exit(0);
 507 }