rpmqv.c

   1 #include "system.h"
   2 const char *__progname;
   3
   4 #define _AUTOHELP
   5
   6 #if defined(IAM_RPM)
   7 #define IAM_RPMBT
   8 #define IAM_RPMDB
   9 #define IAM_RPMEIU
  10 #define IAM_RPMQV
  11 #define IAM_RPMK
  12 #endif
  13
  14 #include <sys/wait.h>
  15 #if HAVE_MCHECK_H
  16 #include <mcheck.h>
  17 #endif
  18
  19 #include <rpm/rpmcli.h>
  20 #include <rpm/rpmlib.h>                 /* RPMSIGTAG, rpmReadPackageFile .. */
  21 #include <rpm/rpmbuild.h>
  22 #include <rpm/rpmlog.h>
  23 #include <rpm/rpmfileutil.h>
  24 #include <rpm/rpmdb.h>
  25 #include <rpm/rpmps.h>
  26 #include <rpm/rpmts.h>
  27
  28 #ifdef  IAM_RPMBT
  29 #include "build.h"
  30 #define GETOPT_REBUILD          1003
  31 #define GETOPT_RECOMPILE        1004
  32 #endif
  33
  34 #if defined(IAM_RPMBT) || defined(IAM_RPMK)
  35 #include "lib/signature.h"
  36 #endif
  37
  38 #include "debug.h"
  39
  40 enum modes {
  41
  42     MODE_QUERY          = (1 <<  0),
  43     MODE_VERIFY         = (1 <<  3),
  44 #define MODES_QV (MODE_QUERY | MODE_VERIFY)
  45
  46     MODE_INSTALL        = (1 <<  1),
  47     MODE_ERASE          = (1 <<  2),
  48 #define MODES_IE (MODE_INSTALL | MODE_ERASE)
  49
  50     MODE_BUILD          = (1 <<  4),
  51     MODE_REBUILD        = (1 <<  5),
  52     MODE_RECOMPILE      = (1 <<  8),
  53     MODE_TARBUILD       = (1 << 11),
  54 #define MODES_BT (MODE_BUILD | MODE_TARBUILD | MODE_REBUILD | MODE_RECOMPILE)
  55
  56     MODE_CHECKSIG       = (1 <<  6),
  57     MODE_RESIGN         = (1 <<  7),
  58 #define MODES_K  (MODE_CHECKSIG | MODE_RESIGN)
  59
  60     MODE_INITDB         = (1 << 10),
  61     MODE_REBUILDDB      = (1 << 12),
  62     MODE_VERIFYDB       = (1 << 13),
  63 #define MODES_DB (MODE_INITDB | MODE_REBUILDDB | MODE_VERIFYDB)
  64
  65
  66     MODE_UNKNOWN        = 0
  67 };
  68
  69 #define MODES_FOR_DBPATH        (MODES_BT | MODES_IE | MODES_QV | MODES_DB)
  70 #define MODES_FOR_NODEPS        (MODES_BT | MODES_IE | MODE_VERIFY)
  71 #define MODES_FOR_TEST          (MODES_BT | MODES_IE)
  72 #define MODES_FOR_ROOT          (MODES_BT | MODES_IE | MODES_QV | MODES_DB | MODES_K)
  73
  74 static int quiet;
  75
  76 /* the structure describing the options we take and the defaults */
  77 static struct poptOption optionsTable[] = {
  78
  79 #ifdef  IAM_RPMQV
  80  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmQVSourcePoptTable, 0,
  81         N_("Query/Verify package selection options:"),
  82         NULL },
  83  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmQueryPoptTable, 0,
  84         N_("Query options (with -q or --query):"),
  85         NULL },
  86  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmVerifyPoptTable, 0,
  87         N_("Verify options (with -V or --verify):"),
  88         NULL },
  89 #endif  /* IAM_RPMQV */
  90
  91 #ifdef  IAM_RPMK
  92  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmSignPoptTable, 0,
  93         N_("Signature options:"),
  94         NULL },
  95 #endif  /* IAM_RPMK */
  96
  97 #ifdef  IAM_RPMDB
  98  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmDatabasePoptTable, 0,
  99         N_("Database options:"),
 100         NULL },
 101 #endif  /* IAM_RPMDB */
 102
 103 #ifdef  IAM_RPMBT
 104  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmBuildPoptTable, 0,
 105         N_("Build options with [ <specfile> | <tarball> | <source package> ]:"),
 106         NULL },
 107 #endif  /* IAM_RPMBT */
 108
 109 #ifdef  IAM_RPMEIU
 110  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmInstallPoptTable, 0,
 111         N_("Install/Upgrade/Erase options:"),
 112         NULL },
 113 #endif  /* IAM_RPMEIU */
 114
 115  { "quiet", '\0', 0, &quiet, 0,                 NULL, NULL},
 116
 117  { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmcliAllPoptTable, 0,
 118         N_("Common options for all rpm modes and executables:"),
 119         NULL },
 120
 121    POPT_AUTOALIAS
 122    POPT_AUTOHELP
 123    POPT_TABLEEND
 124 };
 125
 126 #ifdef __MINT__
 127 /* MiNT cannot dynamically increase the stack.  */
 128 long _stksize = 64 * 1024L;
 129 #endif
 130
 131 RPM_GNUC_NORETURN
 132 static void argerror(const char * desc)
 133 {
 134     fprintf(stderr, _("%s: %s\n"), __progname, desc);
 135     exit(EXIT_FAILURE);
 136 }
 137
 138 static void printVersion(FILE * fp)
 139 {
 140     fprintf(fp, _("RPM version %s\n"), rpmEVR);
 141 }
 142
 143 static void printBanner(FILE * fp)
 144 {
 145     fprintf(fp, _("Copyright (C) 1998-2002 - Red Hat, Inc.\n"));
 146     fprintf(fp, _("This program may be freely redistributed under the terms of the GNU GPL\n"));
 147 }
 148
 149 static void printUsage(poptContext con, FILE * fp, int flags)
 150 {
 151     printVersion(fp);
 152     printBanner(fp);
 153     fprintf(fp, "\n");
 154
 155     if (rpmIsVerbose())
 156         poptPrintHelp(con, fp, flags);
 157     else
 158         poptPrintUsage(con, fp, flags);
 159 }
 160
 161 int main(int argc, char *argv[])
 162 {
 163     rpmts ts = NULL;
 164     enum modes bigMode = MODE_UNKNOWN;
 165
 166 #if defined(IAM_RPMQV)
 167     QVA_t qva = &rpmQVKArgs;
 168 #endif
 169
 170 #ifdef  IAM_RPMBT
 171     BTA_t ba = &rpmBTArgs;
 172 #endif
 173
 174 #ifdef  IAM_RPMEIU
 175    struct rpmInstallArguments_s * ia = &rpmIArgs;
 176 #endif
 177
 178 #if defined(IAM_RPMDB)
 179    struct rpmDatabaseArguments_s * da = &rpmDBArgs;
 180 #endif
 181
 182 #if defined(IAM_RPMK)
 183    QVA_t ka = &rpmQVKArgs;
 184 #endif
 185
 186 #if defined(IAM_RPMBT) || defined(IAM_RPMK)
 187     char * passPhrase = "";
 188 #endif
 189
 190     int arg;
 191
 192     const char *optArg, *poptCtx;
 193     pid_t pipeChild = 0;
 194     poptContext optCon;
 195     int ec = 0;
 196     int status;
 197     int p[2];
 198 #ifdef  IAM_RPMEIU
 199     int i;
 200 #endif
 201
 202 #if HAVE_MCHECK_H && HAVE_MTRACE
 203     mtrace();   /* Trace malloc only if MALLOC_TRACE=mtrace-output-file. */
 204 #endif
 205     setprogname(argv[0]);       /* Retrofit glibc __progname */
 206
 207     /* XXX glibc churn sanity */
 208     if (__progname == NULL) {
 209         if ((__progname = strrchr(argv[0], '/')) != NULL) __progname++;
 210         else __progname = argv[0];
 211     }
 212
 213     /* Set the major mode based on argv[0] */
 214 #ifdef  IAM_RPMBT
 215     if (rstreq(__progname, "rpmbuild")) bigMode = MODE_BUILD;
 216 #endif
 217 #ifdef  IAM_RPMQV
 218     if (rstreq(__progname, "rpmquery")) bigMode = MODE_QUERY;
 219     if (rstreq(__progname, "rpmverify")) bigMode = MODE_VERIFY;
 220 #endif
 221
 222 #if defined(IAM_RPMQV)
 223     /* Jumpstart option from argv[0] if necessary. */
 224     switch (bigMode) {
 225     case MODE_QUERY:    qva->qva_mode = 'q';    break;
 226     case MODE_VERIFY:   qva->qva_mode = 'V';    break;
 227     case MODE_CHECKSIG: qva->qva_mode = 'K';    break;
 228     case MODE_RESIGN:   qva->qva_mode = 'R';    break;
 229     case MODE_INSTALL:
 230     case MODE_ERASE:
 231     case MODE_BUILD:
 232     case MODE_REBUILD:
 233     case MODE_RECOMPILE:
 234     case MODE_TARBUILD:
 235     case MODE_INITDB:
 236     case MODE_REBUILDDB:
 237     case MODE_VERIFYDB:
 238     case MODE_UNKNOWN:
 239     default:
 240         break;
 241     }
 242 #endif
 243
 244 #if defined(ENABLE_NLS)
 245     /* set up the correct locale */
 246     (void) setlocale(LC_ALL, "" );
 247
 248     bindtextdomain(PACKAGE, LOCALEDIR);
 249     textdomain(PACKAGE);
 250 #endif
 251
 252     rpmSetVerbosity(RPMLOG_NOTICE);     /* XXX silly use by showrc */
 253
 254     /* Only build has it's own set of aliases, everything else uses rpm */
 255 #ifdef  IAM_RPMBT
 256     poptCtx = "rpmbuild";
 257 #else
 258     poptCtx = "rpm";
 259 #endif
 260
 261     /* Make a first pass through the arguments, looking for --rcfile */
 262     /* We need to handle that before dealing with the rest of the arguments. */
 263     /* XXX popt argv definition should be fixed instead of casting... */
 264     optCon = poptGetContext(poptCtx, argc, (const char **)argv, optionsTable, 0);
 265     {
 266         char *poptfile = rpmGenPath(rpmConfigDir(), LIBRPMALIAS_FILENAME, NULL);
 267         (void) poptReadConfigFile(optCon, poptfile);
 268         free(poptfile);
 269     }
 270     (void) poptReadDefaultConfig(optCon, 1);
 271     poptSetExecPath(optCon, rpmConfigDir(), 1);
 272
 273     while ((arg = poptGetNextOpt(optCon)) > 0) {
 274         optArg = poptGetOptArg(optCon);
 275
 276         switch (arg) {
 277         default:
 278             fprintf(stderr, _("Internal error in argument processing (%d) :-(\n"), arg);
 279             exit(EXIT_FAILURE);
 280         }
 281     }
 282
 283     if (arg < -1) {
 284         fprintf(stderr, "%s: %s\n",
 285                 poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
 286                 poptStrerror(arg));
 287         exit(EXIT_FAILURE);
 288     }
 289
 290     rpmcliConfigured();
 291
 292 #ifdef  IAM_RPMBT
 293     switch (ba->buildMode) {
 294     case 'b':   bigMode = MODE_BUILD;           break;
 295     case 't':   bigMode = MODE_TARBUILD;        break;
 296     case 'B':   bigMode = MODE_REBUILD;         break;
 297     case 'C':   bigMode = MODE_RECOMPILE;       break;
 298     }
 299
 300     if ((ba->buildAmount & RPMBUILD_RMSOURCE) && bigMode == MODE_UNKNOWN)
 301         bigMode = MODE_BUILD;
 302
 303     if ((ba->buildAmount & RPMBUILD_RMSPEC) && bigMode == MODE_UNKNOWN)
 304         bigMode = MODE_BUILD;
 305
 306     if (ba->buildRootOverride && bigMode != MODE_BUILD &&
 307         bigMode != MODE_REBUILD && bigMode != MODE_TARBUILD) {
 308         argerror("--buildroot may only be used during package builds");
 309     }
 310 #endif  /* IAM_RPMBT */
 311
 312 #ifdef  IAM_RPMDB
 313   if (bigMode == MODE_UNKNOWN || (bigMode & MODES_DB)) {
 314     if (da->init) {
 315         if (bigMode != MODE_UNKNOWN)
 316             argerror(_("only one major mode may be specified"));
 317         else
 318             bigMode = MODE_INITDB;
 319     } else
 320     if (da->rebuild) {
 321         if (bigMode != MODE_UNKNOWN)
 322             argerror(_("only one major mode may be specified"));
 323         else
 324             bigMode = MODE_REBUILDDB;
 325     } else
 326     if (da->verify) {
 327         if (bigMode != MODE_UNKNOWN)
 328             argerror(_("only one major mode may be specified"));
 329         else
 330             bigMode = MODE_VERIFYDB;
 331     }
 332   }
 333 #endif  /* IAM_RPMDB */
 334
 335 #ifdef  IAM_RPMQV
 336   if (bigMode == MODE_UNKNOWN || (bigMode & MODES_QV)) {
 337     switch (qva->qva_mode) {
 338     case 'q':   bigMode = MODE_QUERY;           break;
 339     case 'V':   bigMode = MODE_VERIFY;          break;
 340     }
 341
 342     if (qva->qva_sourceCount) {
 343         if (qva->qva_sourceCount > 2)
 344             argerror(_("one type of query/verify may be performed at a "
 345                         "time"));
 346     }
 347     if (qva->qva_flags && (bigMode & ~MODES_QV))
 348         argerror(_("unexpected query flags"));
 349
 350     if (qva->qva_queryFormat && (bigMode & ~MODES_QV))
 351         argerror(_("unexpected query format"));
 352
 353     if (qva->qva_source != RPMQV_PACKAGE && (bigMode & ~MODES_QV))
 354         argerror(_("unexpected query source"));
 355   }
 356 #endif  /* IAM_RPMQV */
 357
 358 #ifdef  IAM_RPMEIU
 359   if (bigMode == MODE_UNKNOWN || (bigMode & MODES_IE))
 360     {   int iflags = (ia->installInterfaceFlags &
 361                 (INSTALL_UPGRADE|INSTALL_FRESHEN|INSTALL_INSTALL));
 362         int eflags = (ia->installInterfaceFlags & INSTALL_ERASE);
 363
 364         if (iflags & eflags)
 365             argerror(_("only one major mode may be specified"));
 366         else if (iflags)
 367             bigMode = MODE_INSTALL;
 368         else if (eflags)
 369             bigMode = MODE_ERASE;
 370     }
 371 #endif  /* IAM_RPMEIU */
 372
 373 #ifdef  IAM_RPMK
 374   if (bigMode == MODE_UNKNOWN || (bigMode & MODES_K)) {
 375         switch (ka->qva_mode) {
 376         case RPMSIGN_NONE:
 377             ka->sign = 0;
 378             break;
 379         case RPMSIGN_IMPORT_PUBKEY:
 380         case RPMSIGN_CHK_SIGNATURE:
 381             bigMode = MODE_CHECKSIG;
 382             ka->sign = 0;
 383             break;
 384         case RPMSIGN_ADD_SIGNATURE:
 385         case RPMSIGN_NEW_SIGNATURE:
 386         case RPMSIGN_DEL_SIGNATURE:
 387             bigMode = MODE_RESIGN;
 388             ka->sign = (ka->qva_mode != RPMSIGN_DEL_SIGNATURE);
 389             break;
 390         }
 391   }
 392 #endif  /* IAM_RPMK */
 393
 394 #if defined(IAM_RPMEIU)
 395     if (!( bigMode == MODE_INSTALL ) &&
 396 (ia->probFilter & (RPMPROB_FILTER_REPLACEPKG | RPMPROB_FILTER_OLDPACKAGE)))
 397         argerror(_("only installation, upgrading, rmsource and rmspec may be forced"));
 398     if (bigMode != MODE_INSTALL && (ia->probFilter & RPMPROB_FILTER_FORCERELOCATE))
 399         argerror(_("files may only be relocated during package installation"));
 400
 401     if (ia->relocations && ia->prefix)
 402         argerror(_("cannot use --prefix with --relocate or --excludepath"));
 403
 404     if (bigMode != MODE_INSTALL && ia->relocations)
 405         argerror(_("--relocate and --excludepath may only be used when installing new packages"));
 406
 407     if (bigMode != MODE_INSTALL && ia->prefix)
 408         argerror(_("--prefix may only be used when installing new packages"));
 409
 410     if (ia->prefix && ia->prefix[0] != '/')
 411         argerror(_("arguments to --prefix must begin with a /"));
 412
 413     if (bigMode != MODE_INSTALL && (ia->installInterfaceFlags & INSTALL_HASH))
 414         argerror(_("--hash (-h) may only be specified during package "
 415                         "installation"));
 416
 417     if (bigMode != MODE_INSTALL && (ia->installInterfaceFlags & INSTALL_PERCENT))
 418         argerror(_("--percent may only be specified during package "
 419                         "installation"));
 420
 421     if (bigMode != MODE_INSTALL && (ia->probFilter & RPMPROB_FILTER_REPLACEPKG))
 422         argerror(_("--replacepkgs may only be specified during package "
 423                         "installation"));
 424
 425     if (bigMode != MODE_INSTALL && (ia->transFlags & RPMTRANS_FLAG_NODOCS))
 426         argerror(_("--excludedocs may only be specified during package "
 427                    "installation"));
 428
 429     if (bigMode != MODE_INSTALL && ia->incldocs)
 430         argerror(_("--includedocs may only be specified during package "
 431                    "installation"));
 432
 433     if (ia->incldocs && (ia->transFlags & RPMTRANS_FLAG_NODOCS))
 434         argerror(_("only one of --excludedocs and --includedocs may be "
 435                  "specified"));
 436
 437     if (bigMode != MODE_INSTALL && (ia->probFilter & RPMPROB_FILTER_IGNOREARCH))
 438         argerror(_("--ignorearch may only be specified during package "
 439                    "installation"));
 440
 441     if (bigMode != MODE_INSTALL && (ia->probFilter & RPMPROB_FILTER_IGNOREOS))
 442         argerror(_("--ignoreos may only be specified during package "
 443                    "installation"));
 444
 445     if (bigMode != MODE_INSTALL && bigMode != MODE_ERASE &&
 446         (ia->probFilter & (RPMPROB_FILTER_DISKSPACE|RPMPROB_FILTER_DISKNODES)))
 447         argerror(_("--ignoresize may only be specified during package "
 448                    "installation"));
 449
 450     if ((ia->installInterfaceFlags & UNINSTALL_ALLMATCHES) && bigMode != MODE_ERASE)
 451         argerror(_("--allmatches may only be specified during package "
 452                    "erasure"));
 453
 454     if ((ia->transFlags & RPMTRANS_FLAG_ALLFILES) && bigMode != MODE_INSTALL)
 455         argerror(_("--allfiles may only be specified during package "
 456                    "installation"));
 457
 458     if ((ia->transFlags & RPMTRANS_FLAG_JUSTDB) &&
 459         bigMode != MODE_INSTALL && bigMode != MODE_ERASE)
 460         argerror(_("--justdb may only be specified during package "
 461                    "installation and erasure"));
 462
 463     if (bigMode != MODE_INSTALL && bigMode != MODE_ERASE && bigMode != MODE_VERIFY &&
 464         (ia->transFlags & (RPMTRANS_FLAG_NOSCRIPTS | _noTransScripts | _noTransTriggers)))
 465         argerror(_("script disabling options may only be specified during "
 466                    "package installation and erasure"));
 467
 468     if (bigMode != MODE_INSTALL && bigMode != MODE_ERASE && bigMode != MODE_VERIFY &&
 469         (ia->transFlags & (RPMTRANS_FLAG_NOTRIGGERS | _noTransTriggers)))
 470         argerror(_("trigger disabling options may only be specified during "
 471                    "package installation and erasure"));
 472
 473     if (ia->noDeps & (bigMode & ~MODES_FOR_NODEPS))
 474         argerror(_("--nodeps may only be specified during package "
 475                    "building, rebuilding, recompilation, installation,"
 476                    "erasure, and verification"));
 477
 478     if ((ia->transFlags & RPMTRANS_FLAG_TEST) && (bigMode & ~MODES_FOR_TEST))
 479         argerror(_("--test may only be specified during package installation, "
 480                  "erasure, and building"));
 481 #endif  /* IAM_RPMEIU */
 482
 483     if (rpmcliRootDir && rpmcliRootDir[1] && (bigMode & ~MODES_FOR_ROOT))
 484         argerror(_("--root (-r) may only be specified during "
 485                  "installation, erasure, querying, and "
 486                  "database rebuilds"));
 487
 488     if (rpmcliRootDir) {
 489         switch (urlIsURL(rpmcliRootDir)) {
 490         default:
 491             if (bigMode & MODES_FOR_ROOT)
 492                 break;
 493         case URL_IS_UNKNOWN:
 494             if (rpmcliRootDir[0] != '/')
 495                 argerror(_("arguments to --root (-r) must begin with a /"));
 496             break;
 497         }
 498     }
 499
 500     if (quiet)
 501         rpmSetVerbosity(RPMLOG_WARNING);
 502
 503 #if defined(IAM_RPMBT) || defined(IAM_RPMK)
 504     if (0
 505 #if defined(IAM_RPMBT)
 506     || ba->sign
 507 #endif
 508 #if defined(IAM_RPMK)
 509     || ka->sign
 510 #endif
 511     )
 512     {
 513         if (bigMode == MODE_REBUILD || bigMode == MODE_BUILD ||
 514             bigMode == MODE_RESIGN || bigMode == MODE_TARBUILD)
 515         {
 516             const char ** av;
 517             struct stat sb;
 518             int errors = 0;
 519
 520             if ((av = poptGetArgs(optCon)) == NULL) {
 521                 fprintf(stderr, _("no files to sign\n"));
 522                 errors++;
 523             } else
 524             while (*av) {
 525                 if (stat(*av, &sb)) {
 526                     fprintf(stderr, _("cannot access file %s\n"), *av);
 527                     errors++;
 528                 }
 529                 av++;
 530             }
 531
 532             if (errors) {
 533                 ec = errors;
 534                 goto exit;
 535             }
 536
 537             if (poptPeekArg(optCon)) {
 538                 int sigTag = rpmLookupSignatureType(RPMLOOKUPSIG_QUERY);
 539                 switch (sigTag) {
 540                   case 0:
 541                     break;
 542                   case RPMSIGTAG_PGP:
 543                   case RPMSIGTAG_GPG:
 544                   case RPMSIGTAG_DSA:
 545                   case RPMSIGTAG_RSA:
 546                     passPhrase = rpmGetPassPhrase(_("Enter pass phrase: "), sigTag);
 547                     if (passPhrase == NULL) {
 548                         fprintf(stderr, _("Pass phrase check failed\n"));
 549                         ec = EXIT_FAILURE;
 550                         goto exit;
 551                     }
 552                     fprintf(stderr, _("Pass phrase is good.\n"));
 553                     passPhrase = xstrdup(passPhrase);
 554                     break;
 555                   default:
 556                     fprintf(stderr,
 557                             _("Invalid %%_signature spec in macro file.\n"));
 558                     ec = EXIT_FAILURE;
 559                     goto exit;
 560                     break;
 561                 }
 562             }
 563         } else {
 564             argerror(_("--sign may only be used during package building"));
 565         }
 566     } else {
 567         /* Make rpmLookupSignatureType() return 0 ("none") from now on */
 568         (void) rpmLookupSignatureType(RPMLOOKUPSIG_DISABLE);
 569     }
 570 #endif  /* IAM_RPMBT || IAM_RPMK */
 571
 572     if (rpmcliPipeOutput) {
 573         if (pipe(p) < 0) {
 574             fprintf(stderr, _("creating a pipe for --pipe failed: %m\n"));
 575             goto exit;
 576         }
 577
 578         if (!(pipeChild = fork())) {
 579             (void) signal(SIGPIPE, SIG_DFL);
 580             (void) close(p[1]);
 581             (void) dup2(p[0], STDIN_FILENO);
 582             (void) close(p[0]);
 583             (void) execl("/bin/sh", "/bin/sh", "-c", rpmcliPipeOutput, NULL);
 584             fprintf(stderr, _("exec failed\n"));
 585         }
 586
 587         (void) close(p[0]);
 588         (void) dup2(p[1], STDOUT_FILENO);
 589         (void) close(p[1]);
 590     }
 591
 592     ts = rpmtsCreate();
 593     (void) rpmtsSetRootDir(ts, rpmcliRootDir);
 594     switch (bigMode) {
 595 #ifdef  IAM_RPMDB
 596     case MODE_INITDB:
 597         ec = rpmtsInitDB(ts, 0644);
 598         break;
 599
 600     case MODE_REBUILDDB:
 601     {   rpmVSFlags vsflags = rpmExpandNumeric("%{_vsflags_rebuilddb}");
 602         rpmVSFlags ovsflags = rpmtsSetVSFlags(ts, vsflags);
 603         ec = rpmtsRebuildDB(ts);
 604         vsflags = rpmtsSetVSFlags(ts, ovsflags);
 605     }   break;
 606     case MODE_VERIFYDB:
 607         ec = rpmtsVerifyDB(ts);
 608         break;
 609 #endif  /* IAM_RPMDB */
 610
 611 #ifdef  IAM_RPMBT
 612     case MODE_REBUILD:
 613     case MODE_RECOMPILE:
 614     {   const char * pkg;
 615
 616         while (!rpmIsVerbose())
 617             rpmIncreaseVerbosity();
 618
 619         if (!poptPeekArg(optCon))
 620             argerror(_("no packages files given for rebuild"));
 621
 622         ba->buildAmount =
 623             RPMBUILD_PREP | RPMBUILD_BUILD | RPMBUILD_INSTALL | RPMBUILD_CHECK;
 624         if (bigMode == MODE_REBUILD) {
 625             ba->buildAmount |= RPMBUILD_PACKAGEBINARY;
 626             ba->buildAmount |= RPMBUILD_RMSOURCE;
 627             ba->buildAmount |= RPMBUILD_RMSPEC;
 628             ba->buildAmount |= RPMBUILD_CLEAN;
 629             ba->buildAmount |= RPMBUILD_RMBUILD;
 630         }
 631
 632         while ((pkg = poptGetArg(optCon))) {
 633             char * specFile = NULL;
 634
 635             ba->cookie = NULL;
 636             ec = rpmInstallSource(ts, pkg, &specFile, &ba->cookie);
 637             if (ec == 0) {
 638                 ba->rootdir = rpmcliRootDir;
 639                 ba->passPhrase = passPhrase;
 640                 ec = build(ts, specFile, ba, rpmcliRcfile);
 641             }
 642             ba->cookie = _free(ba->cookie);
 643             specFile = _free(specFile);
 644
 645             if (ec)
 646                 break;
 647         }
 648
 649     }   break;
 650
 651     case MODE_BUILD:
 652     case MODE_TARBUILD:
 653     {   const char * pkg;
 654         if (!quiet) while (!rpmIsVerbose())
 655             rpmIncreaseVerbosity();
 656
 657         switch (ba->buildChar) {
 658         case 'a':
 659             ba->buildAmount |= RPMBUILD_PACKAGESOURCE;
 660         case 'b':
 661             ba->buildAmount |= RPMBUILD_PACKAGEBINARY;
 662             ba->buildAmount |= RPMBUILD_CLEAN;
 663             if ((ba->buildChar == 'b') && ba->shortCircuit)
 664                 break;
 665         case 'i':
 666             ba->buildAmount |= RPMBUILD_INSTALL;
 667             ba->buildAmount |= RPMBUILD_CHECK;
 668             if ((ba->buildChar == 'i') && ba->shortCircuit)
 669                 break;
 670         case 'c':
 671             ba->buildAmount |= RPMBUILD_BUILD;
 672             if ((ba->buildChar == 'c') && ba->shortCircuit)
 673                 break;
 674         case 'p':
 675             ba->buildAmount |= RPMBUILD_PREP;
 676             break;
 677
 678         case 'l':
 679             ba->buildAmount |= RPMBUILD_FILECHECK;
 680             break;
 681         case 's':
 682             ba->buildAmount |= RPMBUILD_PACKAGESOURCE;
 683             break;
 684         }
 685
 686         if (!poptPeekArg(optCon)) {
 687             if (bigMode == MODE_BUILD)
 688                 argerror(_("no spec files given for build"));
 689             else
 690                 argerror(_("no tar files given for build"));
 691         }
 692
 693         while ((pkg = poptGetArg(optCon))) {
 694             ba->rootdir = rpmcliRootDir;
 695             ba->passPhrase = passPhrase;
 696             ba->cookie = NULL;
 697             ec = build(ts, pkg, ba, rpmcliRcfile);
 698             if (ec)
 699                 break;
 700             rpmFreeMacros(NULL);
 701             (void) rpmReadConfigFiles(rpmcliRcfile, NULL);
 702         }
 703     }   break;
 704 #endif  /* IAM_RPMBT */
 705
 706 #ifdef  IAM_RPMEIU
 707     case MODE_ERASE:
 708         if (ia->noDeps) ia->installInterfaceFlags |= UNINSTALL_NODEPS;
 709
 710         if (!poptPeekArg(optCon)) {
 711             argerror(_("no packages given for erase"));
 712         } else {
 713             ec += rpmErase(ts, ia, (ARGV_const_t) poptGetArgs(optCon));
 714         }
 715         break;
 716
 717     case MODE_INSTALL:
 718
 719         /* RPMTRANS_FLAG_KEEPOBSOLETE */
 720
 721         if (!ia->incldocs) {
 722             if (ia->transFlags & RPMTRANS_FLAG_NODOCS) {
 723                 ;
 724             } else if (rpmExpandNumeric("%{_excludedocs}"))
 725                 ia->transFlags |= RPMTRANS_FLAG_NODOCS;
 726         }
 727
 728         if (ia->noDeps) ia->installInterfaceFlags |= INSTALL_NODEPS;
 729
 730         /* we've already ensured !(!ia->prefix && !ia->relocations) */
 731         if (ia->prefix) {
 732             ia->relocations = xmalloc(2 * sizeof(*ia->relocations));
 733             ia->relocations[0].oldPath = NULL;   /* special case magic */
 734             ia->relocations[0].newPath = ia->prefix;
 735             ia->relocations[1].oldPath = NULL;
 736             ia->relocations[1].newPath = NULL;
 737         } else if (ia->relocations) {
 738             ia->relocations = xrealloc(ia->relocations,
 739                         sizeof(*ia->relocations) * (ia->numRelocations + 1));
 740             ia->relocations[ia->numRelocations].oldPath = NULL;
 741             ia->relocations[ia->numRelocations].newPath = NULL;
 742         }
 743
 744         if (!poptPeekArg(optCon)) {
 745             argerror(_("no packages given for install"));
 746         } else {
 747             /* FIX: ia->relocations[0].newPath undefined */
 748             ec += rpmInstall(ts, ia, (ARGV_t) poptGetArgs(optCon));
 749         }
 750         break;
 751
 752 #endif  /* IAM_RPMEIU */
 753
 754 #ifdef  IAM_RPMQV
 755     case MODE_QUERY:
 756         if (!poptPeekArg(optCon) && !(qva->qva_source == RPMQV_ALL))
 757             argerror(_("no arguments given for query"));
 758
 759         qva->qva_specQuery = rpmspecQuery;
 760         ec = rpmcliQuery(ts, qva, (ARGV_const_t) poptGetArgs(optCon));
 761         qva->qva_specQuery = NULL;
 762         break;
 763
 764     case MODE_VERIFY:
 765     {   rpmVerifyFlags verifyFlags = VERIFY_ALL;
 766
 767         verifyFlags &= ~qva->qva_flags;
 768         qva->qva_flags = (rpmQueryFlags) verifyFlags;
 769
 770         if (!poptPeekArg(optCon) && !(qva->qva_source == RPMQV_ALL))
 771             argerror(_("no arguments given for verify"));
 772         ec = rpmcliVerify(ts, qva, (ARGV_const_t) poptGetArgs(optCon));
 773     }   break;
 774 #endif  /* IAM_RPMQV */
 775
 776 #ifdef IAM_RPMK
 777     case MODE_CHECKSIG:
 778     {   rpmVerifyFlags verifyFlags =
 779                 (VERIFY_FILEDIGEST|VERIFY_DIGEST|VERIFY_SIGNATURE);
 780
 781         verifyFlags &= ~ka->qva_flags;
 782         ka->qva_flags = (rpmQueryFlags) verifyFlags;
 783     }
 784     case MODE_RESIGN:
 785         if (!poptPeekArg(optCon))
 786             argerror(_("no arguments given"));
 787         ka->passPhrase = passPhrase;
 788         ec = rpmcliSign(ts, ka, (ARGV_const_t) poptGetArgs(optCon));
 789         break;
 790 #endif  /* IAM_RPMK */
 791
 792 #if !defined(IAM_RPMQV)
 793     case MODE_QUERY:
 794     case MODE_VERIFY:
 795 #endif
 796 #if !defined(IAM_RPMK)
 797     case MODE_CHECKSIG:
 798     case MODE_RESIGN:
 799 #endif
 800 #if !defined(IAM_RPMDB)
 801     case MODE_INITDB:
 802     case MODE_REBUILDDB:
 803     case MODE_VERIFYDB:
 804 #endif
 805 #if !defined(IAM_RPMBT)
 806     case MODE_BUILD:
 807     case MODE_REBUILD:
 808     case MODE_RECOMPILE:
 809     case MODE_TARBUILD:
 810 #endif
 811 #if !defined(IAM_RPMEIU)
 812     case MODE_INSTALL:
 813     case MODE_ERASE:
 814 #endif
 815     case MODE_UNKNOWN:
 816         if (poptPeekArg(optCon) != NULL || argc <= 1 || rpmIsVerbose()) {
 817             printUsage(optCon, stderr, 0);
 818             ec = argc;
 819         }
 820         break;
 821     }
 822
 823 exit:
 824
 825     ts = rpmtsFree(ts);
 826
 827     optCon = poptFreeContext(optCon);
 828     rpmFreeMacros(NULL);
 829         rpmFreeMacros(rpmCLIMacroContext);
 830     rpmFreeRpmrc();
 831
 832     if (pipeChild) {
 833         (void) fclose(stdout);
 834         (void) waitpid(pipeChild, &status, 0);
 835     }
 836
 837     /* keeps memory leak checkers quiet */
 838     rpmlogClose();
 839
 840 #ifdef  IAM_RPMQV
 841     qva->qva_queryFormat = _free(qva->qva_queryFormat);
 842 #endif
 843
 844 #ifdef  IAM_RPMBT
 845     freeNames();
 846     ba->buildRootOverride = _free(ba->buildRootOverride);
 847     ba->targets = _free(ba->targets);
 848 #endif
 849
 850 #ifdef  IAM_RPMEIU
 851     if (ia->relocations != NULL)
 852     for (i = 0; i < ia->numRelocations; i++)
 853         ia->relocations[i].oldPath = _free(ia->relocations[i].oldPath);
 854     ia->relocations = _free(ia->relocations);
 855 #endif
 856
 857 #if HAVE_MCHECK_H && HAVE_MTRACE
 858     muntrace();   /* Trace malloc only if MALLOC_TRACE=mtrace-output-file. */
 859 #endif
 860
 861     /* XXX Avoid exit status overflow. Status 255 is special to xargs(1) */
 862     if (ec > 254) ec = 254;
 863
 864     return ec;
 865 }