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