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 = 0;
  14
  15 #include "pool.h"
  16 #include "repo_solv.h"
  17
  18 static int dump_repoattrs_cb(void *vcbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv);
  19
  20 static void
  21 dump_repodata(Repo *repo)
  22 {
  23   unsigned i;
  24   Repodata *data;
  25   if (repo->nrepodata == 0)
  26     return;
  27   printf("repo contains %d repodata sections:\n", repo->nrepodata);
  28   FOR_REPODATAS(repo, i, data)
  29     {
  30       unsigned int j;
  31       printf("\nrepodata %d has %d keys, %d schemata\n", i + 1, data->nkeys - 1, data->nschemata - 1);
  32       for (j = 1; j < data->nkeys; j++)
  33         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);
  34       if (data->localpool)
  35         printf("  localpool has %d strings, size is %d\n", data->spool.nstrings, data->spool.sstrings);
  36       if (data->dirpool.ndirs)
  37         printf("  localpool has %d directories\n", data->dirpool.ndirs);
  38       printf("\n");
  39       repodata_search(data, SOLVID_META, 0, SEARCH_ARRAYSENTINEL|SEARCH_SUB, dump_repoattrs_cb, 0);
  40     }
  41   printf("\n");
  42 }
  43
  44 #if 0
  45 static void
  46 printids(Repo *repo, char *kind, Offset ido)
  47 {
  48   Pool *pool = repo->pool;
  49   Id id, *ids;
  50   if (!ido)
  51     return;
  52   printf("%s:\n", kind);
  53   ids = repo->idarraydata + ido;
  54   while((id = *ids++) != 0)
  55     printf("  %s\n", pool_dep2str(pool, id));
  56 }
  57 #endif
  58
  59 int
  60 dump_attr(Repo *repo, Repodata *data, Repokey *key, KeyValue *kv)
  61 {
  62   const char *keyname;
  63   KeyValue *kvp;
  64   int indent = 0;
  65
  66   keyname = pool_id2str(repo->pool, key->name);
  67   for (kvp = kv; (kvp = kvp->parent) != 0; indent += 2)
  68     printf("  ");
  69   switch(key->type)
  70     {
  71     case REPOKEY_TYPE_ID:
  72       if (data && data->localpool)
  73         kv->str = stringpool_id2str(&data->spool, kv->id);
  74       else
  75         kv->str = pool_dep2str(repo->pool, kv->id);
  76       printf("%s: %s\n", keyname, kv->str);
  77       break;
  78     case REPOKEY_TYPE_CONSTANTID:
  79       printf("%s: %s\n", keyname, pool_dep2str(repo->pool, kv->id));
  80       break;
  81     case REPOKEY_TYPE_IDARRAY:
  82       if (!kv->entry)
  83         printf("%s:\n%*s", keyname, indent, "");
  84       if (data && data->localpool)
  85         printf("  %s\n", stringpool_id2str(&data->spool, kv->id));
  86       else
  87         printf("  %s\n", pool_dep2str(repo->pool, kv->id));
  88       break;
  89     case REPOKEY_TYPE_STR:
  90       printf("%s: %s\n", keyname, kv->str);
  91       break;
  92     case REPOKEY_TYPE_MD5:
  93     case REPOKEY_TYPE_SHA1:
  94     case REPOKEY_TYPE_SHA256:
  95       printf("%s: %s (%s)\n", keyname, repodata_chk2str(data, key->type, (unsigned char *)kv->str), pool_id2str(repo->pool, key->type));
  96       break;
  97     case REPOKEY_TYPE_VOID:
  98       printf("%s: (void)\n", keyname);
  99       break;
 100     case REPOKEY_TYPE_U32:
 101     case REPOKEY_TYPE_CONSTANT:
 102       printf("%s: %u\n", keyname, kv->num);
 103       break;
 104     case REPOKEY_TYPE_NUM:
 105       printf("%s: %llu\n", keyname, SOLV_KV_NUM64(kv));
 106       break;
 107     case REPOKEY_TYPE_BINARY:
 108       if (kv->num)
 109         printf("%s: %02x..%02x len %u\n", keyname, (unsigned char)kv->str[0], (unsigned char)kv->str[kv->num - 1], kv->num);
 110       else
 111         printf("%s: len 0\n", keyname);
 112       break;
 113     case REPOKEY_TYPE_DIRNUMNUMARRAY:
 114       if (!kv->entry)
 115         printf("%s:\n%*s", keyname, indent, "");
 116       printf("  %s %u %u\n", repodata_dir2str(data, kv->id, 0), kv->num, kv->num2);
 117       break;
 118     case REPOKEY_TYPE_DIRSTRARRAY:
 119       if (!kv->entry)
 120         printf("%s:\n%*s", keyname, indent, "");
 121       printf("  %s\n", repodata_dir2str(data, kv->id, kv->str));
 122       break;
 123     case REPOKEY_TYPE_FIXARRAY:
 124     case REPOKEY_TYPE_FLEXARRAY:
 125       if (!kv->entry)
 126         printf("%s:\n", keyname);
 127       else
 128         printf("\n");
 129       break;
 130     default:
 131       printf("%s: ?\n", keyname);
 132       break;
 133     }
 134   return 0;
 135 }
 136
 137 #if 1
 138 static int
 139 dump_repoattrs_cb(void *vcbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
 140 {
 141   if (key->name == REPOSITORY_SOLVABLES)
 142     return SEARCH_NEXT_SOLVABLE;
 143   return dump_attr(data->repo, data, key, kv);
 144 }
 145 #endif
 146
 147 /*
 148  * dump all attributes for Id <p>
 149  */
 150
 151 void
 152 dump_repoattrs(Repo *repo, Id p)
 153 {
 154 #if 0
 155   repo_search(repo, p, 0, 0, SEARCH_ARRAYSENTINEL|SEARCH_SUB, dump_repoattrs_cb, 0);
 156 #else
 157   Dataiterator di;
 158   dataiterator_init(&di, repo->pool, repo, p, 0, 0, SEARCH_ARRAYSENTINEL|SEARCH_SUB);
 159   while (dataiterator_step(&di))
 160     dump_attr(repo, di.data, di.key, &di.kv);
 161 #endif
 162 }
 163
 164 #if 0
 165 void
 166 dump_some_attrs(Repo *repo, Solvable *s)
 167 {
 168   const char *summary = 0;
 169   unsigned int medianr = -1, downloadsize = -1;
 170   unsigned int time = -1;
 171   summary = repo_lookup_str(s, SOLVABLE_SUMMARY);
 172   medianr = repo_lookup_num(s, SOLVABLE_MEDIANR);
 173   downloadsize = repo_lookup_num (s, SOLVABLE_DOWNLOADSIZE);
 174   time = repo_lookup_num(s, SOLVABLE_BUILDTIME);
 175   printf ("  XXX %d %d %u %s\n", medianr, downloadsize, time, summary);
 176 }
 177 #endif
 178
 179
 180 static int
 181 loadcallback (Pool *pool, Repodata *data, void *vdata)
 182 {
 183   FILE *fp = 0;
 184   int r;
 185   const char *location;
 186
 187 printf("LOADCALLBACK\n");
 188   location = repodata_lookup_str(data, SOLVID_META, REPOSITORY_LOCATION);
 189 printf("loc %s\n", location);
 190   if (!location || !with_attr)
 191     return 0;
 192   fprintf (stderr, "Loading SOLV file %s\n", location);
 193   fp = fopen (location, "r");
 194   if (!fp)
 195     {
 196       perror(location);
 197       return 0;
 198     }
 199   r = repo_add_solv(data->repo, fp, REPO_USE_LOADING|REPO_LOCALPOOL);
 200   fclose(fp);
 201   return !r ? 1 : 0;
 202 }
 203
 204
 205 static void
 206 usage(int status)
 207 {
 208   fprintf( stderr, "\nUsage:\n"
 209            "dumpsolv [-a] [<solvfile>]\n"
 210            "  -a  read attributes.\n"
 211            );
 212   exit(status);
 213 }
 214
 215 #if 0
 216 static void
 217 tryme (Repo *repo, Id p, Id keyname, const char *match, int flags)
 218 {
 219   Dataiterator di;
 220   dataiterator_init(&di, repo, p, keyname, match, flags);
 221   while (dataiterator_step(&di))
 222     {
 223       switch (di.key->type)
 224         {
 225           case REPOKEY_TYPE_ID:
 226           case REPOKEY_TYPE_IDARRAY:
 227               if (di.data && di.data->localpool)
 228                 di.kv.str = stringpool_id2str(&di.data->spool, di.kv.id);
 229               else
 230                 di.kv.str = pool_id2str(repo->pool, di.kv.id);
 231               break;
 232           case REPOKEY_TYPE_STR:
 233           case REPOKEY_TYPE_DIRSTRARRAY:
 234               break;
 235           default:
 236               di.kv.str = 0;
 237         }
 238       fprintf (stdout, "found: %d:%s %d %s %d %d %d\n",
 239                di.solvid,
 240                pool_id2str(repo->pool, di.key->name),
 241                di.kv.id,
 242                di.kv.str, di.kv.num, di.kv.num2, di.kv.eof);
 243     }
 244 }
 245 #endif
 246
 247 int main(int argc, char **argv)
 248 {
 249   Repo *repo;
 250   Pool *pool;
 251   int c, i, j, n;
 252   Solvable *s;
 253
 254   pool = pool_create();
 255   pool_setdebuglevel(pool, 1);
 256   pool_setloadcallback(pool, loadcallback, 0);
 257
 258   while ((c = getopt(argc, argv, "ha")) >= 0)
 259     {
 260       switch(c)
 261         {
 262         case 'h':
 263           usage(0);
 264           break;
 265         case 'a':
 266           with_attr = 1;
 267           break;
 268         default:
 269           usage(1);
 270           break;
 271         }
 272     }
 273   for (; optind < argc; optind++)
 274     {
 275       if (freopen(argv[optind], "r", stdin) == 0)
 276         {
 277           perror(argv[optind]);
 278           exit(1);
 279         }
 280       repo = repo_create(pool, argv[optind]);
 281       if (repo_add_solv(repo, stdin, 0))
 282         printf("could not read repository: %s\n", pool_errstr(pool));
 283     }
 284   if (!pool->urepos)
 285     {
 286       repo = repo_create(pool, argc != 1 ? argv[1] : "<stdin>");
 287       if (repo_add_solv(repo, stdin, 0))
 288         printf("could not read repository: %s\n", pool_errstr(pool));
 289     }
 290   printf("pool contains %d strings, %d rels, string size is %d\n", pool->ss.nstrings, pool->nrels, pool->ss.sstrings);
 291
 292 #if 0
 293 {
 294   Dataiterator di;
 295   dataiterator_init(&di, repo, -1, 0, "oo", DI_SEARCHSUB|SEARCH_SUBSTRING);
 296   while (dataiterator_step(&di))
 297     dump_attr(di.repo, di.data, di.key, &di.kv);
 298   exit(0);
 299 }
 300 #endif
 301
 302   n = 0;
 303   FOR_REPOS(j, repo)
 304     {
 305       dump_repodata(repo);
 306
 307       printf("repo %d contains %d solvables\n", j, repo->nsolvables);
 308       printf("repo start: %d end: %d\n", repo->start, repo->end);
 309       FOR_REPO_SOLVABLES(repo, i, s)
 310         {
 311           n++;
 312           printf("\n");
 313           printf("solvable %d (%d):\n", n, i);
 314 #if 0
 315           if (s->name || s->evr || s->arch)
 316             printf("name: %s %s %s\n", pool_id2str(pool, s->name), pool_id2str(pool, s->evr), pool_id2str(pool, s->arch));
 317           if (s->vendor)
 318             printf("vendor: %s\n", pool_id2str(pool, s->vendor));
 319           printids(repo, "provides", s->provides);
 320           printids(repo, "obsoletes", s->obsoletes);
 321           printids(repo, "conflicts", s->conflicts);
 322           printids(repo, "requires", s->requires);
 323           printids(repo, "recommends", s->recommends);
 324           printids(repo, "suggests", s->suggests);
 325           printids(repo, "supplements", s->supplements);
 326           printids(repo, "enhances", s->enhances);
 327           if (repo->rpmdbid)
 328             printf("rpmdbid: %u\n", repo->rpmdbid[i - repo->start]);
 329 #endif
 330           dump_repoattrs(repo, i);
 331 #if 0
 332           dump_some_attrs(repo, s);
 333 #endif
 334         }
 335 #if 0
 336       tryme(repo, 0, SOLVABLE_MEDIANR, 0, 0);
 337       printf("\n");
 338       tryme(repo, 0, 0, 0, 0);
 339       printf("\n");
 340       tryme(repo, 0, 0, "*y*e*", SEARCH_GLOB);
 341 #endif
 342     }
 343 #if 0
 344   printf ("\nSearchresults:\n");
 345   Dataiterator di;
 346   dataiterator_init(&di, pool, 0, 0, 0, "3", SEARCH_SUB | SEARCH_SUBSTRING | SEARCH_FILES);
 347   /* int count = 0; */
 348   while (dataiterator_step(&di))
 349     {
 350       printf("%d:", di.solvid);
 351       dump_attr(repo, di.data, di.key, &di.kv);
 352       /*if (di.solvid == 4 && count++ == 0)
 353         dataiterator_jump_to_solvable(&di, pool->solvables + 3);*/
 354       /* dataiterator_skip_attribute(&di); */
 355       /* dataiterator_skip_solvable(&di); */
 356       /* dataiterator_skip_repo(&di); */
 357     }
 358 #endif
 359   pool_free(pool);
 360   exit(0);
 361 }