lib/transaction.c

   1 /** \ingroup rpmts
   2  * \file lib/transaction.c
   3  */
   4
   5 #include "system.h"
   6 #include <rpmlib.h>
   7
   8 #include <rpmmacro.h>   /* XXX for rpmExpand */
   9
  10 #include "fsm.h"
  11 #include "psm.h"
  12
  13 #include "rpmdb.h"
  14
  15 #include "rpmds.h"
  16
  17 #define _RPMFI_INTERNAL
  18 #include "rpmfi.h"
  19
  20 #define _RPMTE_INTERNAL
  21 #include "rpmte.h"
  22
  23 #define _RPMTS_INTERNAL
  24 #include "rpmts.h"
  25
  26 #include "cpio.h"
  27 #include "fprint.h"
  28 #include "legacy.h"     /* XXX domd5 */
  29 #include "misc.h" /* XXX stripTrailingChar, splitString, currentDirectory */
  30
  31 #include "debug.h"
  32
  33 /*@access FD_t @*/              /* XXX compared with NULL */
  34 /*@access Header @*/            /* XXX compared with NULL */
  35 /*@access rpmps @*/     /* XXX need rpmProblemSetOK() */
  36 /*@access dbiIndexSet @*/
  37 /*@access rpmdb @*/
  38
  39 /*@access rpmpsm @*/
  40
  41 /*@access alKey @*/
  42 /*@access fnpyKey @*/
  43
  44 /*@access rpmfi @*/
  45
  46 /*@access rpmte @*/
  47 /*@access rpmtsi @*/
  48 /*@access rpmts @*/
  49
  50 /**
  51  */
  52 static int archOkay(/*@null@*/ const char * pkgArch)
  53         /*@*/
  54 {
  55     if (pkgArch == NULL) return 0;
  56     return (rpmMachineScore(RPM_MACHTABLE_INSTARCH, pkgArch) ? 1 : 0);
  57 }
  58
  59 /**
  60  */
  61 static int osOkay(/*@null@*/ const char * pkgOs)
  62         /*@*/
  63 {
  64     if (pkgOs == NULL) return 0;
  65     return (rpmMachineScore(RPM_MACHTABLE_INSTOS, pkgOs) ? 1 : 0);
  66 }
  67
  68 /**
  69  */
  70 static int sharedCmp(const void * one, const void * two)
  71         /*@*/
  72 {
  73     sharedFileInfo a = (sharedFileInfo) one;
  74     sharedFileInfo b = (sharedFileInfo) two;
  75
  76     if (a->otherPkg < b->otherPkg)
  77         return -1;
  78     else if (a->otherPkg > b->otherPkg)
  79         return 1;
  80
  81     return 0;
  82 }
  83
  84 /**
  85  */
  86 /*@-boundsread@*/
  87 static fileAction decideFileFate(const rpmts ts,
  88                 const rpmfi ofi, rpmfi nfi)
  89         /*@globals fileSystem, internalState @*/
  90         /*@modifies nfi, fileSystem, internalState @*/
  91 {
  92     const char * fn = rpmfiFN(nfi);
  93     int newFlags = rpmfiFFlags(nfi);
  94     char buffer[1024];
  95     fileTypes dbWhat, newWhat, diskWhat;
  96     struct stat sb;
  97     int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
  98
  99     if (lstat(fn, &sb)) {
 100         /*
 101          * The file doesn't exist on the disk. Create it unless the new
 102          * package has marked it as missingok, or allfiles is requested.
 103          */
 104         if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_ALLFILES)
 105          && (newFlags & RPMFILE_MISSINGOK))
 106         {
 107             rpmMessage(RPMMESS_DEBUG, _("%s skipped due to missingok flag\n"),
 108                         fn);
 109             return FA_SKIP;
 110         } else {
 111             return FA_CREATE;
 112         }
 113     }
 114
 115     diskWhat = whatis((int_16)sb.st_mode);
 116     dbWhat = whatis(rpmfiFMode(ofi));
 117     newWhat = whatis(rpmfiFMode(nfi));
 118
 119     /*
 120      * RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
 121      * them in older packages as well.
 122      */
 123     if (newWhat == XDIR)
 124         return FA_CREATE;
 125
 126     if (diskWhat != newWhat)
 127         return save;
 128     else if (newWhat != dbWhat && diskWhat != dbWhat)
 129         return save;
 130     else if (dbWhat != newWhat)
 131         return FA_CREATE;
 132     else if (dbWhat != LINK && dbWhat != REG)
 133         return FA_CREATE;
 134
 135     /*
 136      * This order matters - we'd prefer to CREATE the file if at all
 137      * possible in case something else (like the timestamp) has changed.
 138      */
 139     if (dbWhat == REG) {
 140         const unsigned char * omd5, * nmd5;
 141         if (domd5(fn, buffer, 0, NULL))
 142             return FA_CREATE;   /* assume file has been removed */
 143         omd5 = rpmfiMD5(ofi);
 144         if (omd5 && !memcmp(omd5, buffer, 16))
 145             return FA_CREATE;   /* unmodified config file, replace. */
 146         nmd5 = rpmfiMD5(nfi);
 147 /*@-nullpass@*/
 148         if (omd5 && nmd5 && !memcmp(omd5, nmd5, 16))
 149             return FA_SKIP;     /* identical file, don't bother. */
 150 /*@=nullpass@*/
 151     } else /* dbWhat == LINK */ {
 152         const char * oFLink, * nFLink;
 153         memset(buffer, 0, sizeof(buffer));
 154         if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
 155             return FA_CREATE;   /* assume file has been removed */
 156         oFLink = rpmfiFLink(ofi);
 157         if (oFLink && !strcmp(oFLink, buffer))
 158             return FA_CREATE;   /* unmodified config file, replace. */
 159         nFLink = rpmfiFLink(nfi);
 160 /*@-nullpass@*/
 161         if (oFLink && nFLink && !strcmp(oFLink, nFLink))
 162             return FA_SKIP;     /* identical file, don't bother. */
 163 /*@=nullpass@*/
 164      }
 165
 166     /*
 167      * The config file on the disk has been modified, but
 168      * the ones in the two packages are different. It would
 169      * be nice if RPM was smart enough to at least try and
 170      * merge the difference ala CVS, but...
 171      */
 172     return save;
 173 }
 174 /*@=boundsread@*/
 175
 176 /**
 177  */
 178 /*@-boundsread@*/
 179 static int filecmp(rpmfi afi, rpmfi bfi)
 180         /*@*/
 181 {
 182     fileTypes awhat = whatis(rpmfiFMode(afi));
 183     fileTypes bwhat = whatis(rpmfiFMode(bfi));
 184
 185     if (awhat != bwhat) return 1;
 186
 187     if (awhat == LINK) {
 188         const char * alink = rpmfiFLink(afi);
 189         const char * blink = rpmfiFLink(bfi);
 190         if (alink == blink) return 0;
 191         if (alink == NULL) return 1;
 192         if (blink == NULL) return -1;
 193         return strcmp(alink, blink);
 194     } else if (awhat == REG) {
 195         const unsigned char * amd5 = rpmfiMD5(afi);
 196         const unsigned char * bmd5 = rpmfiMD5(bfi);
 197         if (amd5 == bmd5) return 0;
 198         if (amd5 == NULL) return 1;
 199         if (bmd5 == NULL) return -1;
 200         return memcmp(amd5, bmd5, 16);
 201     }
 202
 203     return 0;
 204 }
 205 /*@=boundsread@*/
 206
 207 /**
 208  */
 209 /* XXX only ts->{probs,rpmdb} modified */
 210 /*@-bounds@*/
 211 static int handleInstInstalledFiles(const rpmts ts,
 212                 rpmte p, rpmfi fi,
 213                 sharedFileInfo shared,
 214                 int sharedCount, int reportConflicts)
 215         /*@globals rpmGlobalMacroContext, fileSystem, internalState @*/
 216         /*@modifies ts, fi, rpmGlobalMacroContext, fileSystem, internalState @*/
 217 {
 218     const char * altNEVR = NULL;
 219     rpmfi otherFi = NULL;
 220     int numReplaced = 0;
 221     rpmps ps;
 222     int i;
 223
 224     {   rpmdbMatchIterator mi;
 225         Header h;
 226         int scareMem = 0;
 227
 228         mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES,
 229                         &shared->otherPkg, sizeof(shared->otherPkg));
 230         while ((h = rpmdbNextIterator(mi)) != NULL) {
 231             altNEVR = hGetNEVR(h, NULL);
 232             otherFi = rpmfiNew(ts, h, RPMTAG_BASENAMES, scareMem);
 233             break;
 234         }
 235         mi = rpmdbFreeIterator(mi);
 236     }
 237
 238     if (otherFi == NULL)
 239         return 1;
 240
 241     fi->replaced = xcalloc(sharedCount, sizeof(*fi->replaced));
 242
 243     ps = rpmtsProblems(ts);
 244     for (i = 0; i < sharedCount; i++, shared++) {
 245         int otherFileNum, fileNum;
 246         int isCfgFile;
 247
 248         otherFileNum = shared->otherFileNum;
 249         (void) rpmfiSetFX(otherFi, otherFileNum);
 250
 251         fileNum = shared->pkgFileNum;
 252         (void) rpmfiSetFX(fi, fileNum);
 253
 254         isCfgFile = ((rpmfiFFlags(otherFi) | rpmfiFFlags(fi)) & RPMFILE_CONFIG);
 255
 256 #ifdef  DYING
 257         /* XXX another tedious segfault, assume file state normal. */
 258         if (otherStates && otherStates[otherFileNum] != RPMFILE_STATE_NORMAL)
 259             continue;
 260 #endif
 261
 262         if (XFA_SKIPPING(fi->actions[fileNum]))
 263             continue;
 264
 265         if (filecmp(otherFi, fi)) {
 266             if (reportConflicts) {
 267                 rpmpsAppend(ps, RPMPROB_FILE_CONFLICT,
 268                         rpmteNEVR(p), rpmteKey(p),
 269                         rpmfiDN(fi), rpmfiBN(fi),
 270                         altNEVR,
 271                         0);
 272             }
 273             if (!isCfgFile) {
 274                 /*@-assignexpose@*/ /* FIX: p->replaced, not fi */
 275                 if (!shared->isRemoved)
 276                     fi->replaced[numReplaced++] = *shared;
 277                 /*@=assignexpose@*/
 278             }
 279         }
 280
 281         if (isCfgFile) {
 282             fileAction action;
 283             action = decideFileFate(ts, otherFi, fi);
 284             fi->actions[fileNum] = action;
 285         }
 286         fi->replacedSizes[fileNum] = rpmfiFSize(otherFi);
 287     }
 288     ps = rpmpsFree(ps);
 289
 290     altNEVR = _free(altNEVR);
 291     otherFi = rpmfiFree(otherFi);
 292
 293     fi->replaced = xrealloc(fi->replaced,       /* XXX memory leak */
 294                            sizeof(*fi->replaced) * (numReplaced + 1));
 295     fi->replaced[numReplaced].otherPkg = 0;
 296
 297     return 0;
 298 }
 299 /*@=bounds@*/
 300
 301 /**
 302  */
 303 /* XXX only ts->rpmdb modified */
 304 static int handleRmvdInstalledFiles(const rpmts ts, rpmfi fi,
 305                 sharedFileInfo shared, int sharedCount)
 306         /*@globals rpmGlobalMacroContext, fileSystem, internalState @*/
 307         /*@modifies ts, fi, rpmGlobalMacroContext, fileSystem, internalState @*/
 308 {
 309     HGE_t hge = fi->hge;
 310     Header h;
 311     const char * otherStates;
 312     int i, xx;
 313
 314     rpmdbMatchIterator mi;
 315
 316     mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES,
 317                         &shared->otherPkg, sizeof(shared->otherPkg));
 318     h = rpmdbNextIterator(mi);
 319     if (h == NULL) {
 320         mi = rpmdbFreeIterator(mi);
 321         return 1;
 322     }
 323
 324     xx = hge(h, RPMTAG_FILESTATES, NULL, (void **) &otherStates, NULL);
 325
 326 /*@-boundswrite@*/
 327     for (i = 0; i < sharedCount; i++, shared++) {
 328         int otherFileNum, fileNum;
 329         otherFileNum = shared->otherFileNum;
 330         fileNum = shared->pkgFileNum;
 331
 332         if (otherStates[otherFileNum] != RPMFILE_STATE_NORMAL)
 333             continue;
 334
 335         fi->actions[fileNum] = FA_SKIP;
 336     }
 337 /*@=boundswrite@*/
 338
 339     mi = rpmdbFreeIterator(mi);
 340
 341     return 0;
 342 }
 343
 344 #define ISROOT(_d)      (((_d)[0] == '/' && (_d)[1] == '\0') ? "" : (_d))
 345
 346 /*@unchecked@*/
 347 int _fps_debug = 0;
 348
 349 static int fpsCompare (const void * one, const void * two)
 350         /*@*/
 351 {
 352     const struct fingerPrint_s * a = (const struct fingerPrint_s *)one;
 353     const struct fingerPrint_s * b = (const struct fingerPrint_s *)two;
 354     int adnlen = strlen(a->entry->dirName);
 355     int asnlen = (a->subDir ? strlen(a->subDir) : 0);
 356     int abnlen = strlen(a->baseName);
 357     int bdnlen = strlen(b->entry->dirName);
 358     int bsnlen = (b->subDir ? strlen(b->subDir) : 0);
 359     int bbnlen = strlen(b->baseName);
 360     char * afn, * bfn, * t;
 361     int rc = 0;
 362
 363     if (adnlen == 1 && asnlen != 0) adnlen = 0;
 364     if (bdnlen == 1 && bsnlen != 0) bdnlen = 0;
 365
 366 /*@-boundswrite@*/
 367     afn = t = alloca(adnlen+asnlen+abnlen+2);
 368     if (adnlen) t = stpcpy(t, a->entry->dirName);
 369     *t++ = '/';
 370     if (a->subDir && asnlen) t = stpcpy(t, a->subDir);
 371     if (abnlen) t = stpcpy(t, a->baseName);
 372     if (afn[0] == '/' && afn[1] == '/') afn++;
 373
 374     bfn = t = alloca(bdnlen+bsnlen+bbnlen+2);
 375     if (bdnlen) t = stpcpy(t, b->entry->dirName);
 376     *t++ = '/';
 377     if (b->subDir && bsnlen) t = stpcpy(t, b->subDir);
 378     if (bbnlen) t = stpcpy(t, b->baseName);
 379     if (bfn[0] == '/' && bfn[1] == '/') bfn++;
 380 /*@=boundswrite@*/
 381
 382     rc = strcmp(afn, bfn);
 383 /*@-modfilesys@*/
 384 if (_fps_debug)
 385 fprintf(stderr, "\trc(%d) = strcmp(\"%s\", \"%s\")\n", rc, afn, bfn);
 386 /*@=modfilesys@*/
 387
 388 /*@-modfilesys@*/
 389 if (_fps_debug)
 390 fprintf(stderr, "\t%s/%s%s\trc %d\n",
 391 ISROOT(b->entry->dirName),
 392 (b->subDir ? b->subDir : ""),
 393 b->baseName,
 394 rc
 395 );
 396 /*@=modfilesys@*/
 397
 398     return rc;
 399 }
 400
 401 /*@unchecked@*/
 402 static int _linear_fps_search = 0;
 403
 404 static int findFps(const struct fingerPrint_s * fiFps,
 405                 const struct fingerPrint_s * otherFps,
 406                 int otherFc)
 407         /*@*/
 408 {
 409     int otherFileNum;
 410
 411 /*@-modfilesys@*/
 412 if (_fps_debug)
 413 fprintf(stderr, "==> %s/%s%s\n",
 414 ISROOT(fiFps->entry->dirName),
 415 (fiFps->subDir ? fiFps->subDir : ""),
 416 fiFps->baseName);
 417 /*@=modfilesys@*/
 418
 419   if (_linear_fps_search) {
 420
 421 linear:
 422     for (otherFileNum = 0; otherFileNum < otherFc; otherFileNum++, otherFps++) {
 423
 424 /*@-modfilesys@*/
 425 if (_fps_debug)
 426 fprintf(stderr, "\t%4d %s/%s%s\n", otherFileNum,
 427 ISROOT(otherFps->entry->dirName),
 428 (otherFps->subDir ? otherFps->subDir : ""),
 429 otherFps->baseName);
 430 /*@=modfilesys@*/
 431
 432         /* If the addresses are the same, so are the values. */
 433         if (fiFps == otherFps)
 434             break;
 435
 436         /* Otherwise, compare fingerprints by value. */
 437         /*@-nullpass@*/ /* LCL: looks good to me */
 438         if (FP_EQUAL((*fiFps), (*otherFps)))
 439             break;
 440         /*@=nullpass@*/
 441     }
 442
 443 if (otherFileNum == otherFc) {
 444 /*@-modfilesys@*/
 445 if (_fps_debug)
 446 fprintf(stderr, "*** FP_EQUAL NULL %s/%s%s\n",
 447 ISROOT(fiFps->entry->dirName),
 448 (fiFps->subDir ? fiFps->subDir : ""),
 449 fiFps->baseName);
 450 /*@=modfilesys@*/
 451 }
 452
 453     return otherFileNum;
 454
 455   } else {
 456
 457     const struct fingerPrint_s * bingoFps;
 458
 459 /*@-boundswrite@*/
 460     bingoFps = bsearch(fiFps, otherFps, otherFc, sizeof(*otherFps), fpsCompare);
 461 /*@=boundswrite@*/
 462     if (bingoFps == NULL) {
 463 /*@-modfilesys@*/
 464 if (_fps_debug)
 465 fprintf(stderr, "*** bingoFps NULL %s/%s%s\n",
 466 ISROOT(fiFps->entry->dirName),
 467 (fiFps->subDir ? fiFps->subDir : ""),
 468 fiFps->baseName);
 469 /*@=modfilesys@*/
 470         goto linear;
 471     }
 472
 473     /* If the addresses are the same, so are the values. */
 474     /*@-nullpass@*/     /* LCL: looks good to me */
 475     if (!(fiFps == bingoFps || FP_EQUAL((*fiFps), (*bingoFps)))) {
 476 /*@-modfilesys@*/
 477 if (_fps_debug)
 478 fprintf(stderr, "***  BAD %s/%s%s\n",
 479 ISROOT(bingoFps->entry->dirName),
 480 (bingoFps->subDir ? bingoFps->subDir : ""),
 481 bingoFps->baseName);
 482 /*@=modfilesys@*/
 483         goto linear;
 484     }
 485
 486     otherFileNum = (bingoFps != NULL ? (bingoFps - otherFps) : 0);
 487
 488   }
 489
 490     return otherFileNum;
 491 }
 492
 493 /**
 494  * Update disk space needs on each partition for this package's files.
 495  */
 496 /* XXX only ts->{probs,di} modified */
 497 static void handleOverlappedFiles(const rpmts ts,
 498                 const rpmte p, rpmfi fi)
 499         /*@globals fileSystem, internalState @*/
 500         /*@modifies ts, fi, fileSystem, internalState @*/
 501 {
 502     uint_32 fixupSize = 0;
 503     rpmps ps;
 504     const char * fn;
 505     int i, j;
 506
 507     ps = rpmtsProblems(ts);
 508     fi = rpmfiInit(fi, 0);
 509     if (fi != NULL)
 510     while ((i = rpmfiNext(fi)) >= 0) {
 511         struct fingerPrint_s * fiFps;
 512         int otherPkgNum, otherFileNum;
 513         rpmfi otherFi;
 514         int_32 FFlags;
 515         int_16 FMode;
 516         const rpmfi * recs;
 517         int numRecs;
 518
 519         if (XFA_SKIPPING(fi->actions[i]))
 520             continue;
 521
 522         fn = rpmfiFN(fi);
 523         fiFps = fi->fps + i;
 524         FFlags = rpmfiFFlags(fi);
 525         FMode = rpmfiFMode(fi);
 526
 527         fixupSize = 0;
 528
 529         /*
 530          * Retrieve all records that apply to this file. Note that the
 531          * file info records were built in the same order as the packages
 532          * will be installed and removed so the records for an overlapped
 533          * files will be sorted in exactly the same order.
 534          */
 535         (void) htGetEntry(ts->ht, fiFps,
 536                         (const void ***) &recs, &numRecs, NULL);
 537
 538         /*
 539          * If this package is being added, look only at other packages
 540          * being added -- removed packages dance to a different tune.
 541          *
 542          * If both this and the other package are being added, overlapped
 543          * files must be identical (or marked as a conflict). The
 544          * disposition of already installed config files leads to
 545          * a small amount of extra complexity.
 546          *
 547          * If this package is being removed, then there are two cases that
 548          * need to be worried about:
 549          * If the other package is being added, then skip any overlapped files
 550          * so that this package removal doesn't nuke the overlapped files
 551          * that were just installed.
 552          * If both this and the other package are being removed, then each
 553          * file removal from preceding packages needs to be skipped so that
 554          * the file removal occurs only on the last occurence of an overlapped
 555          * file in the transaction set.
 556          *
 557          */
 558
 559         /* Locate this overlapped file in the set of added/removed packages. */
 560         for (j = 0; j < numRecs && recs[j] != fi; j++)
 561             {};
 562
 563         /* Find what the previous disposition of this file was. */
 564         otherFileNum = -1;                      /* keep gcc quiet */
 565         otherFi = NULL;
 566         for (otherPkgNum = j - 1; otherPkgNum >= 0; otherPkgNum--) {
 567             struct fingerPrint_s * otherFps;
 568             int otherFc;
 569
 570             otherFi = recs[otherPkgNum];
 571
 572             /* Added packages need only look at other added packages. */
 573             if (rpmteType(p) == TR_ADDED && rpmteType(otherFi->te) != TR_ADDED)
 574                 /*@innercontinue@*/ continue;
 575
 576             otherFps = otherFi->fps;
 577             otherFc = rpmfiFC(otherFi);
 578
 579             otherFileNum = findFps(fiFps, otherFps, otherFc);
 580             (void) rpmfiSetFX(otherFi, otherFileNum);
 581
 582             /* XXX Happens iff fingerprint for incomplete package install. */
 583             if (otherFi->actions[otherFileNum] != FA_UNKNOWN)
 584                 /*@innerbreak@*/ break;
 585         }
 586
 587 /*@-boundswrite@*/
 588         switch (rpmteType(p)) {
 589         case TR_ADDED:
 590           { struct stat sb;
 591             if (otherPkgNum < 0) {
 592                 /* XXX is this test still necessary? */
 593                 if (fi->actions[i] != FA_UNKNOWN)
 594                     /*@switchbreak@*/ break;
 595                 if ((FFlags & RPMFILE_CONFIG) && !lstat(fn, &sb)) {
 596                     /* Here is a non-overlapped pre-existing config file. */
 597                     fi->actions[i] = (FFlags & RPMFILE_NOREPLACE)
 598                         ? FA_ALTNAME : FA_BACKUP;
 599                 } else {
 600                     fi->actions[i] = FA_CREATE;
 601                 }
 602                 /*@switchbreak@*/ break;
 603             }
 604
 605 assert(otherFi != NULL);
 606             /* Mark added overlapped non-identical files as a conflict. */
 607             if ((rpmtsFilterFlags(ts) & RPMPROB_FILTER_REPLACENEWFILES)
 608              && filecmp(otherFi, fi))
 609             {
 610                 rpmpsAppend(ps, RPMPROB_NEW_FILE_CONFLICT,
 611                         rpmteNEVR(p), rpmteKey(p),
 612                         fn, NULL,
 613                         rpmteNEVR(otherFi->te),
 614                         0);
 615             }
 616
 617             /* Try to get the disk accounting correct even if a conflict. */
 618             fixupSize = rpmfiFSize(otherFi);
 619
 620             if ((FFlags & RPMFILE_CONFIG) && !lstat(fn, &sb)) {
 621                 /* Here is an overlapped  pre-existing config file. */
 622                 fi->actions[i] = (FFlags & RPMFILE_NOREPLACE)
 623                         ? FA_ALTNAME : FA_SKIP;
 624             } else {
 625                 fi->actions[i] = FA_CREATE;
 626             }
 627           } /*@switchbreak@*/ break;
 628
 629         case TR_REMOVED:
 630             if (otherPkgNum >= 0) {
 631 assert(otherFi != NULL);
 632                 /* Here is an overlapped added file we don't want to nuke. */
 633                 if (otherFi->actions[otherFileNum] != FA_ERASE) {
 634                     /* On updates, don't remove files. */
 635                     fi->actions[i] = FA_SKIP;
 636                     /*@switchbreak@*/ break;
 637                 }
 638                 /* Here is an overlapped removed file: skip in previous. */
 639                 otherFi->actions[otherFileNum] = FA_SKIP;
 640             }
 641             if (XFA_SKIPPING(fi->actions[i]))
 642                 /*@switchbreak@*/ break;
 643             if (rpmfiFState(fi) != RPMFILE_STATE_NORMAL)
 644                 /*@switchbreak@*/ break;
 645             if (!(S_ISREG(FMode) && (FFlags & RPMFILE_CONFIG))) {
 646                 fi->actions[i] = FA_ERASE;
 647                 /*@switchbreak@*/ break;
 648             }
 649
 650             /* Here is a pre-existing modified config file that needs saving. */
 651             {   char md5sum[50];
 652                 const unsigned char * MD5 = rpmfiMD5(fi);
 653                 if (!domd5(fn, md5sum, 0, NULL) && memcmp(MD5, md5sum, 16)) {
 654                     fi->actions[i] = FA_BACKUP;
 655                     /*@switchbreak@*/ break;
 656                 }
 657             }
 658             fi->actions[i] = FA_ERASE;
 659             /*@switchbreak@*/ break;
 660         }
 661 /*@=boundswrite@*/
 662
 663         /* Update disk space info for a file. */
 664         rpmtsUpdateDSI(ts, fiFps->entry->dev,
 665                 rpmfiFSize(fi), fi->replacedSizes[i], fixupSize, fi->actions[i]);
 666
 667     }
 668     ps = rpmpsFree(ps);
 669 }
 670
 671 /**
 672  * Ensure that current package is newer than installed package.
 673  * @param ts            transaction set
 674  * @param p             current transaction element
 675  * @param h             installed header
 676  * @return              0 if not newer, 1 if okay
 677  */
 678 static int ensureOlder(rpmts ts,
 679                 const rpmte p, const Header h)
 680         /*@modifies ts @*/
 681 {
 682     int_32 reqFlags = (RPMSENSE_LESS | RPMSENSE_EQUAL);
 683     const char * reqEVR;
 684     rpmds req;
 685     char * t;
 686     int nb;
 687     int rc;
 688
 689     if (p == NULL || h == NULL)
 690         return 1;
 691
 692 /*@-boundswrite@*/
 693     nb = strlen(rpmteNEVR(p)) + (rpmteE(p) != NULL ? strlen(rpmteE(p)) : 0) + 1;
 694     t = alloca(nb);
 695     *t = '\0';
 696     reqEVR = t;
 697     if (rpmteE(p) != NULL)      t = stpcpy( stpcpy(t, rpmteE(p)), ":");
 698     if (rpmteV(p) != NULL)      t = stpcpy(t, rpmteV(p));
 699     *t++ = '-';
 700     if (rpmteR(p) != NULL)      t = stpcpy(t, rpmteR(p));
 701 /*@=boundswrite@*/
 702
 703     req = rpmdsSingle(RPMTAG_REQUIRENAME, rpmteN(p), reqEVR, reqFlags);
 704     rc = rpmdsNVRMatchesDep(h, req, _rpmds_nopromote);
 705     req = rpmdsFree(req);
 706
 707     if (rc == 0) {
 708         rpmps ps = rpmtsProblems(ts);
 709         const char * altNEVR = hGetNEVR(h, NULL);
 710         rpmpsAppend(ps, RPMPROB_OLDPACKAGE,
 711                 rpmteNEVR(p), rpmteKey(p),
 712                 NULL, NULL,
 713                 altNEVR,
 714                 0);
 715         altNEVR = _free(altNEVR);
 716         ps = rpmpsFree(ps);
 717         rc = 1;
 718     } else
 719         rc = 0;
 720
 721     return rc;
 722 }
 723
 724 /**
 725  * Skip any files that do not match install policies.
 726  * @param ts            transaction set
 727  * @param fi            file info set
 728  */
 729 /*@-mustmod@*/ /* FIX: fi->actions is modified. */
 730 /*@-bounds@*/
 731 static void skipFiles(const rpmts ts, rpmfi fi)
 732         /*@globals rpmGlobalMacroContext @*/
 733         /*@modifies fi, rpmGlobalMacroContext @*/
 734 {
 735     int noConfigs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONFIGS);
 736     int noDocs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NODOCS);
 737     char ** netsharedPaths = NULL;
 738     const char ** languages;
 739     const char * dn, * bn;
 740     int dnlen, bnlen, ix;
 741     const char * s;
 742     int * drc;
 743     char * dff;
 744     int dc;
 745     int i, j;
 746
 747     if (!noDocs)
 748         noDocs = rpmExpandNumeric("%{_excludedocs}");
 749
 750     {   const char *tmpPath = rpmExpand("%{_netsharedpath}", NULL);
 751         /*@-branchstate@*/
 752         if (tmpPath && *tmpPath != '%')
 753             netsharedPaths = splitString(tmpPath, strlen(tmpPath), ':');
 754         /*@=branchstate@*/
 755         tmpPath = _free(tmpPath);
 756     }
 757
 758     s = rpmExpand("%{_install_langs}", NULL);
 759     /*@-branchstate@*/
 760     if (!(s && *s != '%'))
 761         s = _free(s);
 762     if (s) {
 763         languages = (const char **) splitString(s, strlen(s), ':');
 764         s = _free(s);
 765     } else
 766         languages = NULL;
 767     /*@=branchstate@*/
 768
 769     /* Compute directory refcount, skip directory if now empty. */
 770     dc = rpmfiDC(fi);
 771     drc = alloca(dc * sizeof(*drc));
 772     memset(drc, 0, dc * sizeof(*drc));
 773     dff = alloca(dc * sizeof(*dff));
 774     memset(dff, 0, dc * sizeof(*dff));
 775
 776     fi = rpmfiInit(fi, 0);
 777     if (fi != NULL)     /* XXX lclint */
 778     while ((i = rpmfiNext(fi)) >= 0)
 779     {
 780         char **nsp;
 781
 782         bn = rpmfiBN(fi);
 783         bnlen = strlen(bn);
 784         ix = rpmfiDX(fi);
 785         dn = rpmfiDN(fi);
 786         dnlen = strlen(dn);
 787         if (dn == NULL)
 788             continue;   /* XXX can't happen */
 789
 790         drc[ix]++;
 791
 792         /* Don't bother with skipped files */
 793         if (XFA_SKIPPING(fi->actions[i])) {
 794             drc[ix]--;
 795             continue;
 796         }
 797
 798         /*
 799          * Skip net shared paths.
 800          * Net shared paths are not relative to the current root (though
 801          * they do need to take package relocations into account).
 802          */
 803         for (nsp = netsharedPaths; nsp && *nsp; nsp++) {
 804             int len;
 805
 806             len = strlen(*nsp);
 807             if (dnlen >= len) {
 808                 if (strncmp(dn, *nsp, len))
 809                     /*@innercontinue@*/ continue;
 810                 /* Only directories or complete file paths can be net shared */
 811                 if (!(dn[len] == '/' || dn[len] == '\0'))
 812                     /*@innercontinue@*/ continue;
 813             } else {
 814                 if (len < (dnlen + bnlen))
 815                     /*@innercontinue@*/ continue;
 816                 if (strncmp(dn, *nsp, dnlen))
 817                     /*@innercontinue@*/ continue;
 818                 if (strncmp(bn, (*nsp) + dnlen, bnlen))
 819                     /*@innercontinue@*/ continue;
 820                 len = dnlen + bnlen;
 821                 /* Only directories or complete file paths can be net shared */
 822                 if (!((*nsp)[len] == '/' || (*nsp)[len] == '\0'))
 823                     /*@innercontinue@*/ continue;
 824             }
 825
 826             /*@innerbreak@*/ break;
 827         }
 828
 829         if (nsp && *nsp) {
 830             drc[ix]--;  dff[ix] = 1;
 831             fi->actions[i] = FA_SKIPNETSHARED;
 832             continue;
 833         }
 834
 835         /*
 836          * Skip i18n language specific files.
 837          */
 838         if (fi->flangs && languages && *fi->flangs[i]) {
 839             const char **lang, *l, *le;
 840             for (lang = languages; *lang != NULL; lang++) {
 841                 if (!strcmp(*lang, "all"))
 842                     /*@innerbreak@*/ break;
 843                 for (l = fi->flangs[i]; *l != '\0'; l = le) {
 844                     for (le = l; *le != '\0' && *le != '|'; le++)
 845                         {};
 846                     if ((le-l) > 0 && !strncmp(*lang, l, (le-l)))
 847                         /*@innerbreak@*/ break;
 848                     if (*le == '|') le++;       /* skip over | */
 849                 }
 850                 if (*l != '\0')
 851                     /*@innerbreak@*/ break;
 852             }
 853             if (*lang == NULL) {
 854                 drc[ix]--;      dff[ix] = 1;
 855                 fi->actions[i] = FA_SKIPNSTATE;
 856                 continue;
 857             }
 858         }
 859
 860         /*
 861          * Skip config files if requested.
 862          */
 863         if (noConfigs && (rpmfiFFlags(fi) & RPMFILE_CONFIG)) {
 864             drc[ix]--;  dff[ix] = 1;
 865             fi->actions[i] = FA_SKIPNSTATE;
 866             continue;
 867         }
 868
 869         /*
 870          * Skip documentation if requested.
 871          */
 872         if (noDocs && (rpmfiFFlags(fi) & RPMFILE_DOC)) {
 873             drc[ix]--;  dff[ix] = 1;
 874             fi->actions[i] = FA_SKIPNSTATE;
 875             continue;
 876         }
 877     }
 878
 879     /* Skip (now empty) directories that had skipped files. */
 880 #ifndef NOTYET
 881     if (fi != NULL)     /* XXX can't happen */
 882     for (j = 0; j < dc; j++)
 883 #else
 884     if ((fi = rpmfiInitD(fi)) != NULL)
 885     while (j = rpmfiNextD(fi) >= 0)
 886 #endif
 887     {
 888
 889         if (drc[j]) continue;   /* dir still has files. */
 890         if (!dff[j]) continue;  /* dir was not emptied here. */
 891
 892         /* Find parent directory and basename. */
 893         dn = fi->dnl[j];        dnlen = strlen(dn) - 1;
 894         bn = dn + dnlen;        bnlen = 0;
 895         while (bn > dn && bn[-1] != '/') {
 896                 bnlen++;
 897                 dnlen--;
 898                 bn--;
 899         }
 900
 901         /* If explicitly included in the package, skip the directory. */
 902         fi = rpmfiInit(fi, 0);
 903         if (fi != NULL)         /* XXX lclint */
 904         while ((i = rpmfiNext(fi)) >= 0) {
 905             const char * fdn, * fbn;
 906             int_16 fFMode;
 907
 908             if (XFA_SKIPPING(fi->actions[i]))
 909                 /*@innercontinue@*/ continue;
 910
 911             fFMode = rpmfiFMode(fi);
 912
 913             if (whatis(fFMode) != XDIR)
 914                 /*@innercontinue@*/ continue;
 915             fdn = rpmfiDN(fi);
 916             if (strlen(fdn) != dnlen)
 917                 /*@innercontinue@*/ continue;
 918             if (strncmp(fdn, dn, dnlen))
 919                 /*@innercontinue@*/ continue;
 920             fbn = rpmfiBN(fi);
 921             if (strlen(fbn) != bnlen)
 922                 /*@innercontinue@*/ continue;
 923             if (strncmp(fbn, bn, bnlen))
 924                 /*@innercontinue@*/ continue;
 925             rpmMessage(RPMMESS_DEBUG, _("excluding directory %s\n"), dn);
 926             fi->actions[i] = FA_SKIPNSTATE;
 927             /*@innerbreak@*/ break;
 928         }
 929     }
 930
 931     if (netsharedPaths) freeSplitString(netsharedPaths);
 932 #ifdef  DYING   /* XXX freeFi will deal with this later. */
 933     fi->flangs = _free(fi->flangs);
 934 #endif
 935     if (languages) freeSplitString((char **)languages);
 936 }
 937 /*@=bounds@*/
 938 /*@=mustmod@*/
 939
 940 /**
 941  * Return transaction element's file info.
 942  * @todo Take a rpmfi refcount here.
 943  * @param tsi           transaction element iterator
 944  * @return              transaction element file info
 945  */
 946 static /*@null@*/
 947 rpmfi rpmtsiFi(const rpmtsi tsi)
 948         /*@*/
 949 {
 950     rpmfi fi = NULL;
 951
 952     if (tsi != NULL && tsi->ocsave != -1) {
 953         /*@-type -abstract@*/ /* FIX: rpmte not opaque */
 954         rpmte te = rpmtsElement(tsi->ts, tsi->ocsave);
 955         /*@-assignexpose@*/
 956         if (te != NULL && (fi = te->fi) != NULL)
 957             fi->te = te;
 958         /*@=assignexpose@*/
 959         /*@=type =abstract@*/
 960     }
 961     /*@-compdef -refcounttrans -usereleased @*/
 962     return fi;
 963     /*@=compdef =refcounttrans =usereleased @*/
 964 }
 965
 966 #define NOTIFY(_ts, _al) /*@i@*/ if ((_ts)->notify) (void) (_ts)->notify _al
 967
 968 int rpmtsRun(rpmts ts, rpmps okProbs, rpmprobFilterFlags ignoreSet)
 969 {
 970     int i, j;
 971     int ourrc = 0;
 972     int totalFileCount = 0;
 973     rpmfi fi;
 974     sharedFileInfo shared, sharedList;
 975     int numShared;
 976     int nexti;
 977     alKey lastFailKey;
 978     fingerPrintCache fpc;
 979     rpmps ps;
 980     rpmpsm psm;
 981     rpmtsi pi;  rpmte p;
 982     rpmtsi qi;  rpmte q;
 983     int numAdded;
 984     int numRemoved;
 985     int xx;
 986
 987     /* FIXME: what if the same package is included in ts twice? */
 988
 989     if (rpmtsFlags(ts) & RPMTRANS_FLAG_NOSCRIPTS)
 990         (void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransScripts | _noTransTriggers));
 991     if (rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERS)
 992         (void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransTriggers));
 993
 994     /* XXX MULTILIB is broken, as packages can and do execute /sbin/ldconfig. */
 995     if (rpmtsFlags(ts) & (RPMTRANS_FLAG_JUSTDB | RPMTRANS_FLAG_MULTILIB))
 996         (void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransScripts | _noTransTriggers));
 997
 998     ts->probs = rpmpsFree(ts->probs);
 999     ts->probs = rpmpsCreate();
1000
1001     /* XXX Make sure the database is open RDWR for package install/erase. */
1002     {   int dbmode = (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)
1003                 ? O_RDONLY : (O_RDWR|O_CREAT);
1004
1005         /* Open database RDWR for installing packages. */
1006         if (rpmtsOpenDB(ts, dbmode))
1007             return -1;  /* XXX W2DO? */
1008     }
1009
1010     ts->ignoreSet = ignoreSet;
1011     {   const char * currDir = currentDirectory();
1012         rpmtsSetCurrDir(ts, currDir);
1013         currDir = _free(currDir);
1014     }
1015
1016     (void) rpmtsSetChrootDone(ts, 0);
1017
1018     {   int_32 tid = (int_32) time(NULL);
1019         (void) rpmtsSetTid(ts, tid);
1020     }
1021
1022     /* Get available space on mounted file systems. */
1023     xx = rpmtsInitDSI(ts);
1024
1025     /* ===============================================
1026      * For packages being installed:
1027      * - verify package arch/os.
1028      * - verify package epoch:version-release is newer.
1029      * - count files.
1030      * For packages being removed:
1031      * - count files.
1032      */
1033
1034 rpmMessage(RPMMESS_DEBUG, _("sanity checking %d elements\n"), rpmtsNElements(ts));
1035     ps = rpmtsProblems(ts);
1036     /* The ordering doesn't matter here */
1037     pi = rpmtsiInit(ts);
1038     while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
1039         rpmdbMatchIterator mi;
1040         int fc;
1041
1042         if ((fi = rpmtsiFi(pi)) == NULL)
1043             continue;   /* XXX can't happen */
1044         fc = rpmfiFC(fi);
1045
1046         if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_IGNOREARCH))
1047             if (!archOkay(rpmteA(p)))
1048                 rpmpsAppend(ps, RPMPROB_BADARCH,
1049                         rpmteNEVR(p), rpmteKey(p),
1050                         rpmteA(p), NULL,
1051                         NULL, 0);
1052
1053         if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_IGNOREOS))
1054             if (!osOkay(rpmteO(p)))
1055                 rpmpsAppend(ps, RPMPROB_BADOS,
1056                         rpmteNEVR(p), rpmteKey(p),
1057                         rpmteO(p), NULL,
1058                         NULL, 0);
1059
1060         if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_OLDPACKAGE)) {
1061             Header h;
1062             mi = rpmtsInitIterator(ts, RPMTAG_NAME, rpmteN(p), 0);
1063             while ((h = rpmdbNextIterator(mi)) != NULL)
1064                 xx = ensureOlder(ts, p, h);
1065             mi = rpmdbFreeIterator(mi);
1066         }
1067
1068         /* XXX multilib should not display "already installed" problems */
1069         if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_REPLACEPKG) && !rpmteMultiLib(p)) {
1070             mi = rpmtsInitIterator(ts, RPMTAG_NAME, rpmteN(p), 0);
1071             xx = rpmdbSetIteratorRE(mi, RPMTAG_EPOCH, RPMMIRE_DEFAULT,
1072                                 rpmteE(p));
1073             xx = rpmdbSetIteratorRE(mi, RPMTAG_VERSION, RPMMIRE_DEFAULT,
1074                                 rpmteV(p));
1075             xx = rpmdbSetIteratorRE(mi, RPMTAG_RELEASE, RPMMIRE_DEFAULT,
1076                                 rpmteR(p));
1077
1078             while (rpmdbNextIterator(mi) != NULL) {
1079                 rpmpsAppend(ps, RPMPROB_PKG_INSTALLED,
1080                         rpmteNEVR(p), rpmteKey(p),
1081                         NULL, NULL,
1082                         NULL, 0);
1083                 /*@innerbreak@*/ break;
1084             }
1085             mi = rpmdbFreeIterator(mi);
1086         }
1087
1088         /* Count no. of files (if any). */
1089         totalFileCount += fc;
1090
1091     }
1092     pi = rpmtsiFree(pi);
1093     ps = rpmpsFree(ps);
1094
1095     /* The ordering doesn't matter here */
1096     pi = rpmtsiInit(ts);
1097     while ((p = rpmtsiNext(pi, TR_REMOVED)) != NULL) {
1098         int fc;
1099
1100         if ((fi = rpmtsiFi(pi)) == NULL)
1101             continue;   /* XXX can't happen */
1102         fc = rpmfiFC(fi);
1103
1104         totalFileCount += fc;
1105     }
1106     pi = rpmtsiFree(pi);
1107
1108     /* ===============================================
1109      * Initialize transaction element file info for package:
1110      */
1111
1112     /*
1113      * FIXME?: we'd be better off assembling one very large file list and
1114      * calling fpLookupList only once. I'm not sure that the speedup is
1115      * worth the trouble though.
1116      */
1117 rpmMessage(RPMMESS_DEBUG, _("computing %d file fingerprints\n"), totalFileCount);
1118     numAdded = numRemoved = 0;
1119     pi = rpmtsiInit(ts);
1120     while ((p = rpmtsiNext(pi, 0)) != NULL) {
1121         int fc;
1122
1123         if ((fi = rpmtsiFi(pi)) == NULL)
1124             continue;   /* XXX can't happen */
1125         fc = rpmfiFC(fi);
1126
1127         /*@-branchstate@*/
1128         switch (rpmteType(p)) {
1129         case TR_ADDED:
1130             numAdded++;
1131             fi->record = 0;
1132             /* Skip netshared paths, not our i18n files, and excluded docs */
1133             if (fc > 0)
1134                 skipFiles(ts, fi);
1135             /*@switchbreak@*/ break;
1136         case TR_REMOVED:
1137             numRemoved++;
1138             fi->record = rpmteDBOffset(p);
1139             /*@switchbreak@*/ break;
1140         }
1141         /*@=branchstate@*/
1142
1143         fi->fps = (fc > 0 ? xmalloc(fc * sizeof(*fi->fps)) : NULL);
1144     }
1145     pi = rpmtsiFree(pi);
1146
1147     if (!rpmtsChrootDone(ts)) {
1148         const char * rootDir = rpmtsRootDir(ts);
1149         xx = chdir("/");
1150         /*@-superuser -noeffect @*/
1151         if (rootDir != NULL)
1152             xx = chroot(rootDir);
1153         /*@=superuser =noeffect @*/
1154         (void) rpmtsSetChrootDone(ts, 1);
1155     }
1156
1157     ts->ht = htCreate(totalFileCount * 2, 0, 0, fpHashFunction, fpEqual);
1158     fpc = fpCacheCreate(totalFileCount);
1159
1160     /* ===============================================
1161      * Add fingerprint for each file not skipped.
1162      */
1163     pi = rpmtsiInit(ts);
1164     while ((p = rpmtsiNext(pi, 0)) != NULL) {
1165         int fc;
1166
1167         (void) rpmdbCheckSignals();
1168
1169         if ((fi = rpmtsiFi(pi)) == NULL)
1170             continue;   /* XXX can't happen */
1171         fc = rpmfiFC(fi);
1172
1173         fpLookupList(fpc, fi->dnl, fi->bnl, fi->dil, fc, fi->fps);
1174         /*@-branchstate@*/
1175         fi = rpmfiInit(fi, 0);
1176         if (fi != NULL)         /* XXX lclint */
1177         while ((i = rpmfiNext(fi)) >= 0) {
1178             if (XFA_SKIPPING(fi->actions[i]))
1179                 /*@innercontinue@*/ continue;
1180             /*@-dependenttrans@*/
1181             htAddEntry(ts->ht, fi->fps + i, (void *) fi);
1182             /*@=dependenttrans@*/
1183         }
1184         /*@=branchstate@*/
1185     }
1186     pi = rpmtsiFree(pi);
1187
1188     NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_START, 6, ts->orderCount,
1189         NULL, ts->notifyData));
1190
1191     /* ===============================================
1192      * Compute file disposition for each package in transaction set.
1193      */
1194 rpmMessage(RPMMESS_DEBUG, _("computing file dispositions\n"));
1195     ps = rpmtsProblems(ts);
1196     pi = rpmtsiInit(ts);
1197     while ((p = rpmtsiNext(pi, 0)) != NULL) {
1198         dbiIndexSet * matches;
1199         int knownBad;
1200         int fc;
1201
1202         (void) rpmdbCheckSignals();
1203
1204         if ((fi = rpmtsiFi(pi)) == NULL)
1205             continue;   /* XXX can't happen */
1206         fc = rpmfiFC(fi);
1207
1208         NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_PROGRESS, rpmtsiOc(pi),
1209                         ts->orderCount, NULL, ts->notifyData));
1210
1211         if (fc == 0) continue;
1212
1213         /* Extract file info for all files in this package from the database. */
1214         matches = xcalloc(fc, sizeof(*matches));
1215         if (rpmdbFindFpList(rpmtsGetRdb(ts), fi->fps, matches, fc)) {
1216             ps = rpmpsFree(ps);
1217             return 1;   /* XXX WTFO? */
1218         }
1219
1220         numShared = 0;
1221         fi = rpmfiInit(fi, 0);
1222         while ((i = rpmfiNext(fi)) >= 0)
1223             numShared += dbiIndexSetCount(matches[i]);
1224
1225         /* Build sorted file info list for this package. */
1226         shared = sharedList = xcalloc((numShared + 1), sizeof(*sharedList));
1227
1228         fi = rpmfiInit(fi, 0);
1229         while ((i = rpmfiNext(fi)) >= 0) {
1230             /*
1231              * Take care not to mark files as replaced in packages that will
1232              * have been removed before we will get here.
1233              */
1234             for (j = 0; j < dbiIndexSetCount(matches[i]); j++) {
1235                 int ro;
1236                 ro = dbiIndexRecordOffset(matches[i], j);
1237                 knownBad = 0;
1238                 qi = rpmtsiInit(ts);
1239                 while ((q = rpmtsiNext(qi, TR_REMOVED)) != NULL) {
1240                     if (ro == knownBad)
1241                         /*@innerbreak@*/ break;
1242                     if (rpmteDBOffset(q) == ro)
1243                         knownBad = ro;
1244                 }
1245                 qi = rpmtsiFree(qi);
1246
1247                 shared->pkgFileNum = i;
1248                 shared->otherPkg = dbiIndexRecordOffset(matches[i], j);
1249                 shared->otherFileNum = dbiIndexRecordFileNumber(matches[i], j);
1250                 shared->isRemoved = (knownBad == ro);
1251                 shared++;
1252             }
1253             matches[i] = dbiFreeIndexSet(matches[i]);
1254         }
1255         numShared = shared - sharedList;
1256         shared->otherPkg = -1;
1257         matches = _free(matches);
1258
1259         /* Sort file info by other package index (otherPkg) */
1260         qsort(sharedList, numShared, sizeof(*shared), sharedCmp);
1261
1262         /* For all files from this package that are in the database ... */
1263         /*@-branchstate@*/
1264         for (i = 0; i < numShared; i = nexti) {
1265             int beingRemoved;
1266
1267             shared = sharedList + i;
1268
1269             /* Find the end of the files in the other package. */
1270             for (nexti = i + 1; nexti < numShared; nexti++) {
1271                 if (sharedList[nexti].otherPkg != shared->otherPkg)
1272                     /*@innerbreak@*/ break;
1273             }
1274
1275             /* Is this file from a package being removed? */
1276             beingRemoved = 0;
1277             if (ts->removedPackages != NULL)
1278             for (j = 0; j < ts->numRemovedPackages; j++) {
1279                 if (ts->removedPackages[j] != shared->otherPkg)
1280                     /*@innercontinue@*/ continue;
1281                 beingRemoved = 1;
1282                 /*@innerbreak@*/ break;
1283             }
1284
1285             /* Determine the fate of each file. */
1286             switch (rpmteType(p)) {
1287             case TR_ADDED:
1288                 xx = handleInstInstalledFiles(ts, p, fi, shared, nexti - i,
1289         !(beingRemoved || (rpmtsFilterFlags(ts) & RPMPROB_FILTER_REPLACEOLDFILES)));
1290                 /*@switchbreak@*/ break;
1291             case TR_REMOVED:
1292                 if (!beingRemoved)
1293                     xx = handleRmvdInstalledFiles(ts, fi, shared, nexti - i);
1294                 /*@switchbreak@*/ break;
1295             }
1296         }
1297         /*@=branchstate@*/
1298
1299         free(sharedList);
1300
1301         /* Update disk space needs on each partition for this package. */
1302         handleOverlappedFiles(ts, p, fi);
1303
1304         /* Check added package has sufficient space on each partition used. */
1305         switch (rpmteType(p)) {
1306         case TR_ADDED:
1307             rpmtsCheckDSIProblems(ts, p);
1308             /*@switchbreak@*/ break;
1309         case TR_REMOVED:
1310             /*@switchbreak@*/ break;
1311         }
1312     }
1313     pi = rpmtsiFree(pi);
1314     ps = rpmpsFree(ps);
1315
1316     if (rpmtsChrootDone(ts)) {
1317         const char * currDir = rpmtsCurrDir(ts);
1318         /*@-superuser -noeffect @*/
1319         xx = chroot(".");
1320         /*@=superuser =noeffect @*/
1321         (void) rpmtsSetChrootDone(ts, 0);
1322         if (currDir != NULL)
1323             xx = chdir(currDir);
1324     }
1325
1326     NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_STOP, 6, ts->orderCount,
1327         NULL, ts->notifyData));
1328
1329     /* ===============================================
1330      * Free unused memory as soon as possible.
1331      */
1332     pi = rpmtsiInit(ts);
1333     while ((p = rpmtsiNext(pi, 0)) != NULL) {
1334         if ((fi = rpmtsiFi(pi)) == NULL)
1335             continue;   /* XXX can't happen */
1336         if (rpmfiFC(fi) == 0)
1337             continue;
1338         fi->fps = _free(fi->fps);
1339     }
1340     pi = rpmtsiFree(pi);
1341
1342     fpc = fpCacheFree(fpc);
1343     ts->ht = htFree(ts->ht);
1344
1345     /* ===============================================
1346      * If unfiltered problems exist, free memory and return.
1347      */
1348     if ((rpmtsFlags(ts) & RPMTRANS_FLAG_BUILD_PROBS)
1349      || (ts->probs->numProblems &&
1350                 (okProbs != NULL || rpmpsTrim(ts->probs, okProbs)))
1351        )
1352     {
1353         return ts->orderCount;
1354     }
1355
1356     /* ===============================================
1357      * Save removed files before erasing.
1358      */
1359     if (rpmtsFlags(ts) & (RPMTRANS_FLAG_DIRSTASH | RPMTRANS_FLAG_REPACKAGE)) {
1360         int progress;
1361         progress = 0;
1362         pi = rpmtsiInit(ts);
1363         while ((p = rpmtsiNext(pi, 0)) != NULL) {
1364
1365             (void) rpmdbCheckSignals();
1366
1367             if ((fi = rpmtsiFi(pi)) == NULL)
1368                 continue;       /* XXX can't happen */
1369             switch (rpmteType(p)) {
1370             case TR_ADDED:
1371                 /*@switchbreak@*/ break;
1372             case TR_REMOVED:
1373                 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_REPACKAGE))
1374                     /*@switchbreak@*/ break;
1375                 if (!progress)
1376                     NOTIFY(ts, (NULL, RPMCALLBACK_REPACKAGE_START,
1377                                 7, numRemoved, NULL, ts->notifyData));
1378
1379                 NOTIFY(ts, (NULL, RPMCALLBACK_REPACKAGE_PROGRESS, progress,
1380                         numRemoved, NULL, ts->notifyData));
1381                 progress++;
1382
1383         /* XXX TR_REMOVED needs CPIO_MAP_{ABSOLUTE,ADDDOT} CPIO_ALL_HARDLINKS */
1384                 fi->mapflags |= CPIO_MAP_ABSOLUTE;
1385                 fi->mapflags |= CPIO_MAP_ADDDOT;
1386                 fi->mapflags |= CPIO_ALL_HARDLINKS;
1387                 psm = rpmpsmNew(ts, p, fi);
1388                 xx = rpmpsmStage(psm, PSM_PKGSAVE);
1389                 psm = rpmpsmFree(psm);
1390                 fi->mapflags &= ~CPIO_MAP_ABSOLUTE;
1391                 fi->mapflags &= ~CPIO_MAP_ADDDOT;
1392                 fi->mapflags &= ~CPIO_ALL_HARDLINKS;
1393
1394                 /*@switchbreak@*/ break;
1395             }
1396         }
1397         pi = rpmtsiFree(pi);
1398         if (progress) {
1399             NOTIFY(ts, (NULL, RPMCALLBACK_REPACKAGE_STOP, 7, numRemoved,
1400                         NULL, ts->notifyData));
1401         }
1402     }
1403
1404     /* ===============================================
1405      * Install and remove packages.
1406      */
1407     lastFailKey = (alKey)-2;    /* erased packages have -1 */
1408     pi = rpmtsiInit(ts);
1409     /*@-branchstate@*/ /* FIX: fi reload needs work */
1410     while ((p = rpmtsiNext(pi, 0)) != NULL) {
1411         alKey pkgKey;
1412         int gotfd;
1413
1414         (void) rpmdbCheckSignals();
1415
1416         gotfd = 0;
1417         if ((fi = rpmtsiFi(pi)) == NULL)
1418             continue;   /* XXX can't happen */
1419
1420         psm = rpmpsmNew(ts, p, fi);
1421         psm->unorderedSuccessor =
1422                 (rpmtsiOc(pi) >= rpmtsUnorderedSuccessors(ts, -1) ? 1 : 0);
1423
1424         switch (rpmteType(p)) {
1425         case TR_ADDED:
1426
1427             pkgKey = rpmteAddedKey(p);
1428
1429             rpmMessage(RPMMESS_DEBUG, "========== +++ %s\n", rpmteNEVR(p));
1430             p->h = NULL;
1431             /*@-type@*/ /* FIX: rpmte not opaque */
1432             {
1433                 /*@-noeffectuncon@*/ /* FIX: notify annotations */
1434                 p->fd = ts->notify(p->h, RPMCALLBACK_INST_OPEN_FILE, 0, 0,
1435                                 rpmteKey(p), ts->notifyData);
1436                 /*@=noeffectuncon@*/
1437                 if (rpmteFd(p) != NULL) {
1438                     rpmVSFlags ovsflags = rpmtsVSFlags(ts);
1439                     rpmVSFlags vsflags = ovsflags | RPMVSF_NEEDPAYLOAD;
1440                     rpmRC rpmrc;
1441
1442                     ovsflags = rpmtsSetVSFlags(ts, vsflags);
1443                     rpmrc = rpmReadPackageFile(ts, rpmteFd(p),
1444                                 rpmteNEVR(p), &p->h);
1445                     vsflags = rpmtsSetVSFlags(ts, ovsflags);
1446
1447                     switch (rpmrc) {
1448                     default:
1449                         /*@-noeffectuncon@*/ /* FIX: notify annotations */
1450                         p->fd = ts->notify(p->h, RPMCALLBACK_INST_CLOSE_FILE,
1451                                         0, 0,
1452                                         rpmteKey(p), ts->notifyData);
1453                         /*@=noeffectuncon@*/
1454                         p->fd = NULL;
1455                         ourrc++;
1456                         /*@innerbreak@*/ break;
1457                     case RPMRC_NOTTRUSTED:
1458                     case RPMRC_NOKEY:
1459                     case RPMRC_OK:
1460                         /*@innerbreak@*/ break;
1461                     }
1462                     if (rpmteFd(p) != NULL) gotfd = 1;
1463                 }
1464             }
1465             /*@=type@*/
1466
1467             if (rpmteFd(p) != NULL) {
1468                 /*
1469                  * XXX Sludge necessary to tranfer existing fstates/actions
1470                  * XXX around a recreated file info set.
1471                  */
1472                 psm->fi = rpmfiFree(psm->fi);
1473                 {
1474                     char * fstates = fi->fstates;
1475                     fileAction * actions = fi->actions;
1476                     rpmte savep;
1477
1478                     fi->fstates = NULL;
1479                     fi->actions = NULL;
1480                     fi = rpmfiFree(fi);
1481
1482                     savep = rpmtsSetRelocateElement(ts, p);
1483                     fi = rpmfiNew(ts, p->h, RPMTAG_BASENAMES, 1);
1484                     (void) rpmtsSetRelocateElement(ts, savep);
1485
1486                     if (fi != NULL) {   /* XXX can't happen */
1487                         fi->te = p;
1488                         fi->fstates = _free(fi->fstates);
1489                         fi->fstates = fstates;
1490                         fi->actions = _free(fi->actions);
1491                         fi->actions = actions;
1492                         p->fi = fi;
1493                     }
1494                 }
1495                 psm->fi = rpmfiLink(p->fi, NULL);
1496
1497                 if (rpmteMultiLib(p))
1498                     (void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | RPMTRANS_FLAG_MULTILIB));
1499                 else
1500                     (void) rpmtsSetFlags(ts, (rpmtsFlags(ts) & ~RPMTRANS_FLAG_MULTILIB));
1501
1502 /*@-nullstate@*/ /* FIX: psm->fi may be NULL */
1503                 if (rpmpsmStage(psm, PSM_PKGINSTALL)) {
1504                     ourrc++;
1505                     lastFailKey = pkgKey;
1506                 }
1507 /*@=nullstate@*/
1508             } else {
1509                 ourrc++;
1510                 lastFailKey = pkgKey;
1511             }
1512
1513             if (gotfd) {
1514                 /*@-noeffectuncon @*/ /* FIX: check rc */
1515                 (void) ts->notify(p->h, RPMCALLBACK_INST_CLOSE_FILE, 0, 0,
1516                         rpmteKey(p), ts->notifyData);
1517                 /*@=noeffectuncon @*/
1518                 /*@-type@*/
1519                 p->fd = NULL;
1520                 /*@=type@*/
1521             }
1522
1523             p->h = headerFree(p->h);
1524
1525             /*@switchbreak@*/ break;
1526         case TR_REMOVED:
1527             rpmMessage(RPMMESS_DEBUG, "========== --- %s\n", rpmteNEVR(p));
1528             /*
1529              * XXX This has always been a hack, now mostly broken.
1530              * If install failed, then we shouldn't erase.
1531              */
1532             if (rpmteDependsOnKey(p) != lastFailKey) {
1533                 if (rpmpsmStage(psm, PSM_PKGERASE))
1534                     ourrc++;
1535             }
1536             /*@switchbreak@*/ break;
1537         }
1538         xx = rpmdbSync(rpmtsGetRdb(ts));
1539
1540 /*@-nullstate@*/ /* FIX: psm->fi may be NULL */
1541         psm = rpmpsmFree(psm);
1542 /*@=nullstate@*/
1543
1544 /*@-type@*/ /* FIX: p is almost opaque */
1545         p->fi = rpmfiFree(p->fi);
1546 /*@=type@*/
1547
1548     }
1549     /*@=branchstate@*/
1550     pi = rpmtsiFree(pi);
1551
1552     /*@-nullstate@*/ /* FIX: ts->flList may be NULL */
1553     if (ourrc)
1554         return -1;
1555     else
1556         return 0;
1557     /*@=nullstate@*/
1558 }