lib/transaction.c

   1 /** \ingroup rpmtrans
   2  * \file lib/transaction.c
   3  */
   4
   5 #include "system.h"
   6
   7 #include "psm.h"
   8 #include <rpmmacro.h>   /* XXX for rpmExpand */
   9
  10 #include "fprint.h"
  11 #include "legacy.h"     /* XXX mdfile */
  12 #include "misc.h" /* XXX stripTrailingChar, splitString, currentDirectory */
  13 #include "rpmdb.h"
  14
  15 /*@-redecl -exportheadervar@*/
  16 /*@unchecked@*/
  17 extern const char * chroot_prefix;
  18 /*@=redecl =exportheadervar@*/
  19
  20 /* XXX FIXME: merge with existing (broken?) tests in system.h */
  21 /* portability fiddles */
  22 #if STATFS_IN_SYS_STATVFS
  23 /*@-incondefs@*/
  24 # include <sys/statvfs.h>
  25 #if defined(__LCLINT__)
  26 /*@-declundef -exportheader -protoparammatch @*/ /* LCL: missing annotation */
  27 extern int statvfs (const char * file, /*@out@*/ struct statvfs * buf)
  28         /*@globals fileSystem @*/
  29         /*@modifies *buf, fileSystem @*/;
  30 /*@=declundef =exportheader =protoparammatch @*/
  31 /*@=incondefs@*/
  32 #endif
  33 #else
  34 # if STATFS_IN_SYS_VFS
  35 #  include <sys/vfs.h>
  36 # else
  37 #  if STATFS_IN_SYS_MOUNT
  38 #   include <sys/mount.h>
  39 #  else
  40 #   if STATFS_IN_SYS_STATFS
  41 #    include <sys/statfs.h>
  42 #   endif
  43 #  endif
  44 # endif
  45 #endif
  46
  47 #include "debug.h"
  48
  49 /*@access FD_t@*/               /* XXX compared with NULL */
  50 /*@access Header@*/             /* XXX compared with NULL */
  51 /*@access dbiIndexSet@*/
  52 /*@access rpmdb@*/
  53 /*@access rpmTransactionSet@*/
  54 /*@access TFI_t@*/
  55 /*@access PSM_t@*/
  56 /*@access rpmProblemSet@*/
  57 /*@access rpmProblem@*/
  58
  59 /**
  60  */
  61 struct diskspaceInfo {
  62     dev_t dev;                  /*!< file system device number. */
  63     signed long bneeded;        /*!< no. of blocks needed. */
  64     signed long ineeded;        /*!< no. of inodes needed. */
  65     int bsize;                  /*!< file system block size. */
  66     signed long bavail;         /*!< no. of blocks available. */
  67     signed long iavail;         /*!< no. of inodes available. */
  68 };
  69
  70 /**
  71  * Adjust for root only reserved space. On linux e2fs, this is 5%.
  72  */
  73 #define adj_fs_blocks(_nb)      (((_nb) * 21) / 20)
  74
  75 /* argon thought a shift optimization here was a waste of time...  he's
  76    probably right :-( */
  77 #define BLOCK_ROUND(size, block) (((size) + (block) - 1) / (block))
  78
  79 #define XSTRCMP(a, b) ((!(a) && !(b)) || ((a) && (b) && !strcmp((a), (b))))
  80
  81 /**
  82  */
  83 static /*@null@*/ void * freeFl(rpmTransactionSet ts,
  84                 /*@only@*/ /*@null@*/ TFI_t flList)
  85         /*@*/
  86 {
  87     if (flList) {
  88         TFI_t fi;
  89         int oc;
  90
  91         /*@-usereleased@*/
  92         for (oc = 0, fi = flList; oc < ts->orderCount; oc++, fi++)
  93             freeFi(fi);
  94         flList = _free(flList);
  95         /*@=usereleased@*/
  96     }
  97     return NULL;
  98 }
  99
 100 void rpmtransSetScriptFd(rpmTransactionSet ts, FD_t fd)
 101 {
 102     /*@-type@*/ /* FIX: cast? */
 103     ts->scriptFd = (fd ? fdLink(fd, "rpmtransSetScriptFd") : NULL);
 104     /*@=type@*/
 105 }
 106
 107 int rpmtransGetKeys(const rpmTransactionSet ts, const void *** ep, int * nep)
 108 {
 109     int rc = 0;
 110
 111     if (nep) *nep = ts->orderCount;
 112     if (ep) {
 113         const void ** e;
 114         int oc;
 115
 116         *ep = e = xmalloc(ts->orderCount * sizeof(*e));
 117         for (oc = 0; oc < ts->orderCount; oc++, e++) {
 118             switch (ts->order[oc].type) {
 119             case TR_ADDED:
 120                 if (ts->addedPackages.list) {
 121                     struct availablePackage * alp;
 122                     alp = ts->addedPackages.list + ts->order[oc].u.addedIndex;
 123                     *e = alp->key;
 124                     /*@switchbreak@*/ break;
 125                 }
 126                 /*@fallthrough@*/
 127             default:
 128             case TR_REMOVED:
 129                 /*@-mods@*/     /* FIX: double indirection. */
 130                 *e = NULL;
 131                 /*@=mods@*/
 132                 /*@switchbreak@*/ break;
 133             }
 134         }
 135     }
 136     return rc;
 137 }
 138
 139 /**
 140  */
 141 static int archOkay(Header h)
 142         /*@*/
 143 {
 144     void * pkgArch;
 145     int type, count;
 146
 147     /* make sure we're trying to install this on the proper architecture */
 148     (void) headerGetEntry(h, RPMTAG_ARCH, &type, (void **) &pkgArch, &count);
 149 #ifndef DYING
 150     if (type == RPM_INT8_TYPE) {
 151         int_8 * pkgArchNum;
 152         int archNum;
 153
 154         /* old arch handling */
 155         rpmGetArchInfo(NULL, &archNum);
 156         pkgArchNum = pkgArch;
 157         if (archNum != *pkgArchNum) {
 158             return 0;
 159         }
 160     } else
 161 #endif
 162     {
 163         /* new arch handling */
 164         if (!rpmMachineScore(RPM_MACHTABLE_INSTARCH, pkgArch)) {
 165             return 0;
 166         }
 167     }
 168
 169     return 1;
 170 }
 171
 172 /**
 173  */
 174 static int osOkay(Header h)
 175         /*@*/
 176 {
 177     void * pkgOs;
 178     int type, count;
 179
 180     /* make sure we're trying to install this on the proper os */
 181     (void) headerGetEntry(h, RPMTAG_OS, &type, (void **) &pkgOs, &count);
 182 #ifndef DYING
 183     if (type == RPM_INT8_TYPE) {
 184         /* v1 packages and v2 packages both used improper OS numbers, so just
 185            deal with it hope things work */
 186         return 1;
 187     } else
 188 #endif
 189     {
 190         /* new os handling */
 191         if (!rpmMachineScore(RPM_MACHTABLE_INSTOS, pkgOs)) {
 192             return 0;
 193         }
 194     }
 195
 196     return 1;
 197 }
 198
 199 void rpmProblemSetFree(rpmProblemSet probs)
 200 {
 201     int i;
 202
 203     for (i = 0; i < probs->numProblems; i++) {
 204         rpmProblem p = probs->probs + i;
 205         p->h = headerFree(p->h);
 206         p->pkgNEVR = _free(p->pkgNEVR);
 207         p->altNEVR = _free(p->altNEVR);
 208         p->str1 = _free(p->str1);
 209     }
 210     free(probs);
 211 }
 212
 213 /**
 214  * Filter a problem set.
 215  * As the problem sets are generated in an order solely dependent
 216  * on the ordering of the packages in the transaction, and that
 217  * ordering can't be changed, the problem sets must be parallel to
 218  * one another. Additionally, the filter set must be a subset of the
 219  * target set, given the operations available on transaction set.
 220  * This is good, as it lets us perform this trim in linear time, rather
 221  * then logarithmic or quadratic.
 222  *
 223  * @param filter        filter
 224  * @param target        problem set
 225  * @return              0 no problems, 1 if problems remain
 226  */
 227 static int psTrim(rpmProblemSet filter, rpmProblemSet target)
 228         /*@modifies target @*/
 229 {
 230     rpmProblem f = filter->probs;
 231     rpmProblem t = target->probs;
 232     int gotProblems = 0;
 233
 234     /*@-branchstate@*/
 235     while ((f - filter->probs) < filter->numProblems) {
 236         if (!f->ignoreProblem) {
 237             f++;
 238             continue;
 239         }
 240         while ((t - target->probs) < target->numProblems) {
 241             /*@-nullpass@*/     /* LCL: looks good to me */
 242             if (f->h == t->h && f->type == t->type && t->key == f->key &&
 243                      XSTRCMP(f->str1, t->str1))
 244                 /*@innerbreak@*/ break;
 245             /*@=nullpass@*/
 246             t++;
 247             gotProblems = 1;
 248         }
 249
 250         if ((t - target->probs) == target->numProblems) {
 251             /* this can't happen ;-) let's be sane if it doesn though */
 252             break;
 253         }
 254
 255         t->ignoreProblem = f->ignoreProblem;
 256         t++, f++;
 257     }
 258     /*@=branchstate@*/
 259
 260     if ((t - target->probs) < target->numProblems)
 261         gotProblems = 1;
 262
 263     return gotProblems;
 264 }
 265
 266 /**
 267  */
 268 static int sharedCmp(const void * one, const void * two)
 269         /*@*/
 270 {
 271     const struct sharedFileInfo * a = one;
 272     const struct sharedFileInfo * b = two;
 273
 274     if (a->otherPkg < b->otherPkg)
 275         return -1;
 276     else if (a->otherPkg > b->otherPkg)
 277         return 1;
 278
 279     return 0;
 280 }
 281
 282 /**
 283  */
 284 static fileAction decideFileFate(const char * dirName,
 285                         const char * baseName, short dbMode,
 286                         const char * dbMd5, const char * dbLink, short newMode,
 287                         const char * newMd5, const char * newLink, int newFlags,
 288                         rpmtransFlags transFlags)
 289         /*@globals fileSystem @*/
 290         /*@modifies fileSystem @*/
 291 {
 292     char buffer[1024];
 293     const char * dbAttr, * newAttr;
 294     fileTypes dbWhat, newWhat, diskWhat;
 295     struct stat sb;
 296     int i, rc;
 297     int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
 298     char * filespec = alloca(strlen(dirName) + strlen(baseName) + 1);
 299
 300     (void) stpcpy( stpcpy(filespec, dirName), baseName);
 301
 302     if (lstat(filespec, &sb)) {
 303         /*
 304          * The file doesn't exist on the disk. Create it unless the new
 305          * package has marked it as missingok, or allfiles is requested.
 306          */
 307         if (!(transFlags & RPMTRANS_FLAG_ALLFILES) &&
 308            (newFlags & RPMFILE_MISSINGOK)) {
 309             rpmMessage(RPMMESS_DEBUG, _("%s skipped due to missingok flag\n"),
 310                         filespec);
 311             return FA_SKIP;
 312         } else {
 313             return FA_CREATE;
 314         }
 315     }
 316
 317     diskWhat = whatis(sb.st_mode);
 318     dbWhat = whatis(dbMode);
 319     newWhat = whatis(newMode);
 320
 321     /* RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
 322        them in older packages as well */
 323     if (newWhat == XDIR) {
 324         return FA_CREATE;
 325     }
 326
 327     if (diskWhat != newWhat) {
 328         return save;
 329     } else if (newWhat != dbWhat && diskWhat != dbWhat) {
 330         return save;
 331     } else if (dbWhat != newWhat) {
 332         return FA_CREATE;
 333     } else if (dbWhat != LINK && dbWhat != REG) {
 334         return FA_CREATE;
 335     }
 336
 337     if (dbWhat == REG) {
 338         rc = mdfile(filespec, buffer);
 339
 340         if (rc) {
 341             /* assume the file has been removed, don't freak */
 342             return FA_CREATE;
 343         }
 344         dbAttr = dbMd5;
 345         newAttr = newMd5;
 346     } else /* dbWhat == LINK */ {
 347         memset(buffer, 0, sizeof(buffer));
 348         i = readlink(filespec, buffer, sizeof(buffer) - 1);
 349         if (i == -1) {
 350             /* assume the file has been removed, don't freak */
 351             return FA_CREATE;
 352         }
 353         dbAttr = dbLink;
 354         newAttr = newLink;
 355      }
 356
 357     /* this order matters - we'd prefer to CREATE the file if at all
 358        possible in case something else (like the timestamp) has changed */
 359
 360     if (!strcmp(dbAttr, buffer)) {
 361         /* this config file has never been modified, so just replace it */
 362         return FA_CREATE;
 363     }
 364
 365     if (!strcmp(dbAttr, newAttr)) {
 366         /* this file is the same in all versions of this package */
 367         return FA_SKIP;
 368     }
 369
 370     /*
 371      * The config file on the disk has been modified, but
 372      * the ones in the two packages are different. It would
 373      * be nice if RPM was smart enough to at least try and
 374      * merge the difference ala CVS, but...
 375      */
 376     return save;
 377 }
 378
 379 /**
 380  */
 381 static int filecmp(short mode1, const char * md51, const char * link1,
 382                    short mode2, const char * md52, const char * link2)
 383         /*@*/
 384 {
 385     fileTypes what1 = whatis(mode1);
 386     fileTypes what2 = whatis(mode2);
 387
 388     if (what1 != what2) return 1;
 389
 390     if (what1 == LINK)
 391         return strcmp(link1, link2);
 392     else if (what1 == REG)
 393         return strcmp(md51, md52);
 394
 395     return 0;
 396 }
 397
 398 /**
 399  */
 400 /* XXX only ts->{probs,rpmdb} modified */
 401 static int handleInstInstalledFiles(const rpmTransactionSet ts, TFI_t fi,
 402                 struct sharedFileInfo * shared,
 403                 int sharedCount, int reportConflicts)
 404         /*@globals fileSystem @*/
 405         /*@modifies ts, fi, fileSystem @*/
 406 {
 407     HGE_t hge = fi->hge;
 408     HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
 409     rpmdb db = ts->rpmdb;
 410     rpmProblemSet probs = ts->probs;
 411     rpmtransFlags transFlags = ts->transFlags;
 412     rpmTagType oltype, omtype;
 413     Header h;
 414     int i;
 415     const char ** otherMd5s;
 416     const char ** otherLinks;
 417     const char * otherStates;
 418     uint_32 * otherFlags;
 419     uint_32 * otherSizes;
 420     uint_16 * otherModes;
 421     int numReplaced = 0;
 422     int xx;
 423
 424     rpmdbMatchIterator mi;
 425
 426     mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, &shared->otherPkg, sizeof(shared->otherPkg));
 427     h = rpmdbNextIterator(mi);
 428     if (h == NULL) {
 429         mi = rpmdbFreeIterator(mi);
 430         return 1;
 431     }
 432
 433     xx = hge(h, RPMTAG_FILEMD5S, &omtype, (void **) &otherMd5s, NULL);
 434     xx = hge(h, RPMTAG_FILELINKTOS, &oltype, (void **) &otherLinks, NULL);
 435     xx = hge(h, RPMTAG_FILESTATES, NULL, (void **) &otherStates, NULL);
 436     xx = hge(h, RPMTAG_FILEMODES, NULL, (void **) &otherModes, NULL);
 437     xx = hge(h, RPMTAG_FILEFLAGS, NULL, (void **) &otherFlags, NULL);
 438     xx = hge(h, RPMTAG_FILESIZES, NULL, (void **) &otherSizes, NULL);
 439
 440     fi->replaced = xmalloc(sharedCount * sizeof(*fi->replaced));
 441
 442     for (i = 0; i < sharedCount; i++, shared++) {
 443         int otherFileNum, fileNum;
 444         otherFileNum = shared->otherFileNum;
 445         fileNum = shared->pkgFileNum;
 446
 447         /* XXX another tedious segfault, assume file state normal. */
 448         if (otherStates && otherStates[otherFileNum] != RPMFILE_STATE_NORMAL)
 449             continue;
 450
 451         if (XFA_SKIPPING(fi->actions[fileNum]))
 452             continue;
 453
 454         if (filecmp(otherModes[otherFileNum],
 455                         otherMd5s[otherFileNum],
 456                         otherLinks[otherFileNum],
 457                         fi->fmodes[fileNum],
 458                         fi->fmd5s[fileNum],
 459                         fi->flinks[fileNum])) {
 460             if (reportConflicts)
 461                 psAppend(probs, RPMPROB_FILE_CONFLICT, fi->ap,
 462                         fi->dnl[fi->dil[fileNum]], fi->bnl[fileNum], h, 0);
 463             if (!(otherFlags[otherFileNum] | fi->fflags[fileNum])
 464                         & RPMFILE_CONFIG) {
 465                 /*@-assignexpose@*/
 466                 if (!shared->isRemoved)
 467                     fi->replaced[numReplaced++] = *shared;
 468                 /*@=assignexpose@*/
 469             }
 470         }
 471
 472         if ((otherFlags[otherFileNum] | fi->fflags[fileNum]) & RPMFILE_CONFIG) {
 473             fi->actions[fileNum] = decideFileFate(
 474                         fi->dnl[fi->dil[fileNum]],
 475                         fi->bnl[fileNum],
 476                         otherModes[otherFileNum],
 477                         otherMd5s[otherFileNum],
 478                         otherLinks[otherFileNum],
 479                         fi->fmodes[fileNum],
 480                         fi->fmd5s[fileNum],
 481                         fi->flinks[fileNum],
 482                         fi->fflags[fileNum],
 483                         transFlags);
 484         }
 485
 486         fi->replacedSizes[fileNum] = otherSizes[otherFileNum];
 487     }
 488
 489     otherMd5s = hfd(otherMd5s, omtype);
 490     otherLinks = hfd(otherLinks, oltype);
 491     mi = rpmdbFreeIterator(mi);
 492
 493     fi->replaced = xrealloc(fi->replaced,       /* XXX memory leak */
 494                            sizeof(*fi->replaced) * (numReplaced + 1));
 495     fi->replaced[numReplaced].otherPkg = 0;
 496
 497     return 0;
 498 }
 499
 500 /**
 501  */
 502 /* XXX only ts->rpmdb modified */
 503 static int handleRmvdInstalledFiles(const rpmTransactionSet ts, TFI_t fi,
 504                 struct sharedFileInfo * shared, int sharedCount)
 505         /*@globals fileSystem @*/
 506         /*@modifies ts, fi, fileSystem @*/
 507 {
 508     HGE_t hge = fi->hge;
 509     rpmdb db = ts->rpmdb;
 510     Header h;
 511     const char * otherStates;
 512     int i, xx;
 513
 514     rpmdbMatchIterator mi;
 515
 516     mi = rpmdbInitIterator(db, RPMDBI_PACKAGES,
 517                         &shared->otherPkg, sizeof(shared->otherPkg));
 518     h = rpmdbNextIterator(mi);
 519     if (h == NULL) {
 520         mi = rpmdbFreeIterator(mi);
 521         return 1;
 522     }
 523
 524     xx = hge(h, RPMTAG_FILESTATES, NULL, (void **) &otherStates, NULL);
 525
 526     for (i = 0; i < sharedCount; i++, shared++) {
 527         int otherFileNum, fileNum;
 528         otherFileNum = shared->otherFileNum;
 529         fileNum = shared->pkgFileNum;
 530
 531         if (otherStates[otherFileNum] != RPMFILE_STATE_NORMAL)
 532             continue;
 533
 534         fi->actions[fileNum] = FA_SKIP;
 535     }
 536
 537     mi = rpmdbFreeIterator(mi);
 538
 539     return 0;
 540 }
 541
 542 /**
 543  * Update disk space needs on each partition for this package.
 544  */
 545 /* XXX only ts->{probs,di} modified */
 546 static void handleOverlappedFiles(const rpmTransactionSet ts, TFI_t fi)
 547         /*@globals fileSystem @*/
 548         /*@modifies ts, fi, fileSystem @*/
 549 {
 550     struct diskspaceInfo * dsl = ts->di;
 551     rpmProblemSet probs = (ts->ignoreSet & RPMPROB_FILTER_REPLACENEWFILES)
 552         ? NULL : ts->probs;
 553     hashTable ht = ts->ht;
 554     struct diskspaceInfo * ds = NULL;
 555     uint_32 fixupSize = 0;
 556     char * filespec = NULL;
 557     int fileSpecAlloced = 0;
 558     int i, j;
 559
 560     for (i = 0; i < fi->fc; i++) {
 561         int otherPkgNum, otherFileNum;
 562         const TFI_t * recs;
 563         int numRecs;
 564
 565         if (XFA_SKIPPING(fi->actions[i]))
 566             continue;
 567
 568         j = strlen(fi->dnl[fi->dil[i]]) + strlen(fi->bnl[i]) + 1;
 569         /*@-branchstate@*/
 570         if (j > fileSpecAlloced) {
 571             fileSpecAlloced = j * 2;
 572             filespec = xrealloc(filespec, fileSpecAlloced);
 573         }
 574         /*@=branchstate@*/
 575
 576         (void) stpcpy( stpcpy( filespec, fi->dnl[fi->dil[i]]), fi->bnl[i]);
 577
 578         if (dsl) {
 579             ds = dsl;
 580             while (ds->bsize && ds->dev != fi->fps[i].entry->dev) ds++;
 581             if (!ds->bsize) ds = NULL;
 582             fixupSize = 0;
 583         }
 584
 585         /*
 586          * Retrieve all records that apply to this file. Note that the
 587          * file info records were built in the same order as the packages
 588          * will be installed and removed so the records for an overlapped
 589          * files will be sorted in exactly the same order.
 590          */
 591         (void) htGetEntry(ht, &fi->fps[i], (const void ***) &recs, &numRecs, NULL);
 592
 593         /*
 594          * If this package is being added, look only at other packages
 595          * being added -- removed packages dance to a different tune.
 596          * If both this and the other package are being added, overlapped
 597          * files must be identical (or marked as a conflict). The
 598          * disposition of already installed config files leads to
 599          * a small amount of extra complexity.
 600          *
 601          * If this package is being removed, then there are two cases that
 602          * need to be worried about:
 603          * If the other package is being added, then skip any overlapped files
 604          * so that this package removal doesn't nuke the overlapped files
 605          * that were just installed.
 606          * If both this and the other package are being removed, then each
 607          * file removal from preceding packages needs to be skipped so that
 608          * the file removal occurs only on the last occurence of an overlapped
 609          * file in the transaction set.
 610          *
 611          */
 612
 613         /* Locate this overlapped file in the set of added/removed packages. */
 614         for (j = 0; j < numRecs && recs[j] != fi; j++)
 615             {};
 616
 617         /* Find what the previous disposition of this file was. */
 618         otherFileNum = -1;                      /* keep gcc quiet */
 619         for (otherPkgNum = j - 1; otherPkgNum >= 0; otherPkgNum--) {
 620             /* Added packages need only look at other added packages. */
 621             if (fi->type == TR_ADDED && recs[otherPkgNum]->type != TR_ADDED)
 622                 /*@innercontinue@*/ continue;
 623
 624             /* TESTME: there are more efficient searches in the world... */
 625             for (otherFileNum = 0; otherFileNum < recs[otherPkgNum]->fc;
 626                  otherFileNum++) {
 627
 628                 /* If the addresses are the same, so are the values. */
 629                 if ((fi->fps + i) == (recs[otherPkgNum]->fps + otherFileNum))
 630                     /*@innerbreak@*/ break;
 631
 632                 /* Otherwise, compare fingerprints by value. */
 633                 /*@-nullpass@*/ /* LCL: looks good to me */
 634                 if (FP_EQUAL(fi->fps[i], recs[otherPkgNum]->fps[otherFileNum]))
 635                     /*@innerbreak@*/ break;
 636                 /*@=nullpass@*/
 637
 638             }
 639             /* XXX is this test still necessary? */
 640             if (recs[otherPkgNum]->actions[otherFileNum] != FA_UNKNOWN)
 641                 /*@innerbreak@*/ break;
 642         }
 643
 644         switch (fi->type) {
 645         case TR_ADDED:
 646           { struct stat sb;
 647             if (otherPkgNum < 0) {
 648                 /* XXX is this test still necessary? */
 649                 if (fi->actions[i] != FA_UNKNOWN)
 650                     /*@switchbreak@*/ break;
 651                 if ((fi->fflags[i] & RPMFILE_CONFIG) &&
 652                         !lstat(filespec, &sb)) {
 653                     /* Here is a non-overlapped pre-existing config file. */
 654                     fi->actions[i] = (fi->fflags[i] & RPMFILE_NOREPLACE)
 655                         ? FA_ALTNAME : FA_BACKUP;
 656                 } else {
 657                     fi->actions[i] = FA_CREATE;
 658                 }
 659                 /*@switchbreak@*/ break;
 660             }
 661
 662             /* Mark added overlapped non-identical files as a conflict. */
 663             if (probs && filecmp(recs[otherPkgNum]->fmodes[otherFileNum],
 664                         recs[otherPkgNum]->fmd5s[otherFileNum],
 665                         recs[otherPkgNum]->flinks[otherFileNum],
 666                         fi->fmodes[i],
 667                         fi->fmd5s[i],
 668                         fi->flinks[i])) {
 669                 psAppend(probs, RPMPROB_NEW_FILE_CONFLICT, fi->ap,
 670                                 filespec, NULL, recs[otherPkgNum]->ap->h, 0);
 671             }
 672
 673             /* Try to get the disk accounting correct even if a conflict. */
 674             fixupSize = recs[otherPkgNum]->fsizes[otherFileNum];
 675
 676             if ((fi->fflags[i] & RPMFILE_CONFIG) && !lstat(filespec, &sb)) {
 677                 /* Here is an overlapped  pre-existing config file. */
 678                 fi->actions[i] = (fi->fflags[i] & RPMFILE_NOREPLACE)
 679                         ? FA_ALTNAME : FA_SKIP;
 680             } else {
 681                 fi->actions[i] = FA_CREATE;
 682             }
 683           } /*@switchbreak@*/ break;
 684         case TR_REMOVED:
 685             if (otherPkgNum >= 0) {
 686                 /* Here is an overlapped added file we don't want to nuke. */
 687                 if (recs[otherPkgNum]->actions[otherFileNum] != FA_ERASE) {
 688                     /* On updates, don't remove files. */
 689                     fi->actions[i] = FA_SKIP;
 690                     /*@switchbreak@*/ break;
 691                 }
 692                 /* Here is an overlapped removed file: skip in previous. */
 693                 recs[otherPkgNum]->actions[otherFileNum] = FA_SKIP;
 694             }
 695             if (XFA_SKIPPING(fi->actions[i]))
 696                 /*@switchbreak@*/ break;
 697             if (fi->fstates && fi->fstates[i] != RPMFILE_STATE_NORMAL)
 698                 /*@switchbreak@*/ break;
 699             if (!(S_ISREG(fi->fmodes[i]) && (fi->fflags[i] & RPMFILE_CONFIG))) {
 700                 fi->actions[i] = FA_ERASE;
 701                 /*@switchbreak@*/ break;
 702             }
 703
 704             /* Here is a pre-existing modified config file that needs saving. */
 705             {   char mdsum[50];
 706                 if (!mdfile(filespec, mdsum) && strcmp(fi->fmd5s[i], mdsum)) {
 707                     fi->actions[i] = FA_BACKUP;
 708                     /*@switchbreak@*/ break;
 709                 }
 710             }
 711             fi->actions[i] = FA_ERASE;
 712             /*@switchbreak@*/ break;
 713         }
 714
 715         if (ds) {
 716             uint_32 s = BLOCK_ROUND(fi->fsizes[i], ds->bsize);
 717
 718             switch (fi->actions[i]) {
 719               case FA_BACKUP:
 720               case FA_SAVE:
 721               case FA_ALTNAME:
 722                 ds->ineeded++;
 723                 ds->bneeded += s;
 724                 /*@switchbreak@*/ break;
 725
 726             /*
 727              * FIXME: If two packages share a file (same md5sum), and
 728              * that file is being replaced on disk, will ds->bneeded get
 729              * decremented twice? Quite probably!
 730              */
 731               case FA_CREATE:
 732                 ds->bneeded += s;
 733                 ds->bneeded -= BLOCK_ROUND(fi->replacedSizes[i], ds->bsize);
 734                 /*@switchbreak@*/ break;
 735
 736               case FA_ERASE:
 737                 ds->ineeded--;
 738                 ds->bneeded -= s;
 739                 /*@switchbreak@*/ break;
 740
 741               default:
 742                 /*@switchbreak@*/ break;
 743             }
 744
 745             ds->bneeded -= BLOCK_ROUND(fixupSize, ds->bsize);
 746         }
 747     }
 748     if (filespec) free(filespec);
 749 }
 750
 751 /**
 752  */
 753 static int ensureOlder(struct availablePackage * alp, Header old,
 754                 rpmProblemSet probs)
 755         /*@modifies alp, probs @*/
 756 {
 757     int result, rc = 0;
 758
 759     if (old == NULL) return 1;
 760
 761     result = rpmVersionCompare(old, alp->h);
 762     if (result <= 0)
 763         rc = 0;
 764     else if (result > 0) {
 765         rc = 1;
 766         psAppend(probs, RPMPROB_OLDPACKAGE, alp, NULL, NULL, old, 0);
 767     }
 768
 769     return rc;
 770 }
 771
 772 /**
 773  */
 774 static void skipFiles(const rpmTransactionSet ts, TFI_t fi)
 775         /*@globals rpmGlobalMacroContext @*/
 776         /*@modifies fi, rpmGlobalMacroContext @*/
 777 {
 778     int noDocs = (ts->transFlags & RPMTRANS_FLAG_NODOCS);
 779     char ** netsharedPaths = NULL;
 780     const char ** languages;
 781     const char * dn, * bn;
 782     int dnlen, bnlen, ix;
 783     const char * s;
 784     int * drc;
 785     char * dff;
 786     int i, j;
 787
 788     if (!noDocs)
 789         noDocs = rpmExpandNumeric("%{_excludedocs}");
 790
 791     {   const char *tmpPath = rpmExpand("%{_netsharedpath}", NULL);
 792         /*@-branchstate@*/
 793         if (tmpPath && *tmpPath != '%')
 794             netsharedPaths = splitString(tmpPath, strlen(tmpPath), ':');
 795         /*@=branchstate@*/
 796         tmpPath = _free(tmpPath);
 797     }
 798
 799     s = rpmExpand("%{_install_langs}", NULL);
 800     /*@-branchstate@*/
 801     if (!(s && *s != '%'))
 802         s = _free(s);
 803     if (s) {
 804         languages = (const char **) splitString(s, strlen(s), ':');
 805         s = _free(s);
 806     } else
 807         languages = NULL;
 808     /*@=branchstate@*/
 809
 810     /* Compute directory refcount, skip directory if now empty. */
 811     drc = alloca(fi->dc * sizeof(*drc));
 812     memset(drc, 0, fi->dc * sizeof(*drc));
 813     dff = alloca(fi->dc * sizeof(*dff));
 814     memset(dff, 0, fi->dc * sizeof(*dff));
 815
 816     for (i = 0; i < fi->fc; i++) {
 817         char **nsp;
 818
 819         bn = fi->bnl[i];
 820         bnlen = strlen(bn);
 821         ix = fi->dil[i];
 822         dn = fi->dnl[ix];
 823         dnlen = strlen(dn);
 824
 825         drc[ix]++;
 826
 827         /* Don't bother with skipped files */
 828         if (XFA_SKIPPING(fi->actions[i])) {
 829             drc[ix]--;
 830             continue;
 831         }
 832
 833         /*
 834          * Skip net shared paths.
 835          * Net shared paths are not relative to the current root (though
 836          * they do need to take package relocations into account).
 837          */
 838         for (nsp = netsharedPaths; nsp && *nsp; nsp++) {
 839             int len;
 840
 841             len = strlen(*nsp);
 842             if (dnlen >= len) {
 843                 if (strncmp(dn, *nsp, len))
 844                     /*@innercontinue@*/ continue;
 845                 /* Only directories or complete file paths can be net shared */
 846                 if (!(dn[len] == '/' || dn[len] == '\0'))
 847                     /*@innercontinue@*/ continue;
 848             } else {
 849                 if (len < (dnlen + bnlen))
 850                     /*@innercontinue@*/ continue;
 851                 if (strncmp(dn, *nsp, dnlen))
 852                     /*@innercontinue@*/ continue;
 853                 if (strncmp(bn, (*nsp) + dnlen, bnlen))
 854                     /*@innercontinue@*/ continue;
 855                 len = dnlen + bnlen;
 856                 /* Only directories or complete file paths can be net shared */
 857                 if (!((*nsp)[len] == '/' || (*nsp)[len] == '\0'))
 858                     /*@innercontinue@*/ continue;
 859             }
 860
 861             /*@innerbreak@*/ break;
 862         }
 863
 864         if (nsp && *nsp) {
 865             drc[ix]--;  dff[ix] = 1;
 866             fi->actions[i] = FA_SKIPNETSHARED;
 867             continue;
 868         }
 869
 870         /*
 871          * Skip i18n language specific files.
 872          */
 873         if (fi->flangs && languages && *fi->flangs[i]) {
 874             const char **lang, *l, *le;
 875             for (lang = languages; *lang != NULL; lang++) {
 876                 if (!strcmp(*lang, "all"))
 877                     /*@innerbreak@*/ break;
 878                 for (l = fi->flangs[i]; *l != '\0'; l = le) {
 879                     for (le = l; *le != '\0' && *le != '|'; le++)
 880                         {};
 881                     if ((le-l) > 0 && !strncmp(*lang, l, (le-l)))
 882                         /*@innerbreak@*/ break;
 883                     if (*le == '|') le++;       /* skip over | */
 884                 }
 885                 if (*l != '\0')
 886                     /*@innerbreak@*/ break;
 887             }
 888             if (*lang == NULL) {
 889                 drc[ix]--;      dff[ix] = 1;
 890                 fi->actions[i] = FA_SKIPNSTATE;
 891                 continue;
 892             }
 893         }
 894
 895         /*
 896          * Skip documentation if requested.
 897          */
 898         if (noDocs && (fi->fflags[i] & RPMFILE_DOC)) {
 899             drc[ix]--;  dff[ix] = 1;
 900             fi->actions[i] = FA_SKIPNSTATE;
 901             continue;
 902         }
 903     }
 904
 905     /* Skip (now empty) directories that had skipped files. */
 906     for (j = 0; j < fi->dc; j++) {
 907
 908         if (drc[j]) continue;   /* dir still has files. */
 909         if (!dff[j]) continue;  /* dir was not emptied here. */
 910
 911         /* Find parent directory and basename. */
 912         dn = fi->dnl[j];        dnlen = strlen(dn) - 1;
 913         bn = dn + dnlen;        bnlen = 0;
 914         while (bn > dn && bn[-1] != '/') {
 915                 bnlen++;
 916                 dnlen--;
 917                 bn--;
 918         }
 919
 920         /* If explicitly included in the package, skip the directory. */
 921         for (i = 0; i < fi->fc; i++) {
 922             const char * dir;
 923
 924             if (XFA_SKIPPING(fi->actions[i]))
 925                 /*@innercontinue@*/ continue;
 926             if (whatis(fi->fmodes[i]) != XDIR)
 927                 /*@innercontinue@*/ continue;
 928             dir = fi->dnl[fi->dil[i]];
 929             if (strlen(dir) != dnlen)
 930                 /*@innercontinue@*/ continue;
 931             if (strncmp(dir, dn, dnlen))
 932                 /*@innercontinue@*/ continue;
 933             if (strlen(fi->bnl[i]) != bnlen)
 934                 /*@innercontinue@*/ continue;
 935             if (strncmp(fi->bnl[i], bn, bnlen))
 936                 /*@innercontinue@*/ continue;
 937             rpmMessage(RPMMESS_DEBUG, _("excluding directory %s\n"), dn);
 938             fi->actions[i] = FA_SKIPNSTATE;
 939             /*@innerbreak@*/ break;
 940         }
 941     }
 942
 943     if (netsharedPaths) freeSplitString(netsharedPaths);
 944 #ifdef  DYING   /* XXX freeFi will deal with this later. */
 945     fi->flangs = _free(fi->flangs);
 946 #endif
 947     if (languages) freeSplitString((char **)languages);
 948 }
 949
 950 /**
 951  * Iterator across transaction elements, forward on install, backward on erase.
 952  */
 953 struct tsIterator_s {
 954 /*@kept@*/ rpmTransactionSet ts;        /*!< transaction set. */
 955     int reverse;                        /*!< reversed traversal? */
 956     int ocsave;                         /*!< last returned iterator index. */
 957     int oc;                             /*!< iterator index. */
 958 };
 959
 960 /**
 961  * Return transaction element order count.
 962  * @param a             transaction element iterator
 963  * @return              element order count
 964  */
 965 static int tsGetOc(void * a)
 966         /*@*/
 967 {
 968     struct tsIterator_s * iter = a;
 969     int oc = iter->ocsave;
 970     return oc;
 971 }
 972
 973 /**
 974  * Return transaction element available package pointer.
 975  * @param a             transaction element iterator
 976  * @return              available package pointer
 977  */
 978 static /*@dependent@*/ struct availablePackage * tsGetAlp(void * a)
 979         /*@*/
 980 {
 981     struct tsIterator_s * iter = a;
 982     struct availablePackage * alp = NULL;
 983     int oc = iter->ocsave;
 984
 985     /*@-branchstate@*/
 986     if (oc != -1) {
 987         rpmTransactionSet ts = iter->ts;
 988         TFI_t fi = ts->flList + oc;
 989         if (ts->addedPackages.list && fi->type == TR_ADDED)
 990             alp = ts->addedPackages.list + ts->order[oc].u.addedIndex;
 991     }
 992     /*@=branchstate@*/
 993     return alp;
 994 }
 995
 996 /**
 997  * Destroy transaction element iterator.
 998  * @param a             transaction element iterator
 999  * @return              NULL always
1000  */
1001 static /*@null@*/ void * tsFreeIterator(/*@only@*//*@null@*/ const void * a)
1002         /*@modifies a @*/
1003 {
1004     return _free(a);
1005 }
1006
1007 /**
1008  * Create transaction element iterator.
1009  * @param a             transaction set
1010  * @return              transaction element iterator
1011  */
1012 static void * tsInitIterator(/*@kept@*/ const void * a)
1013         /*@*/
1014 {
1015     rpmTransactionSet ts = (void *)a;
1016     struct tsIterator_s * iter = NULL;
1017
1018     iter = xcalloc(1, sizeof(*iter));
1019     iter->ts = ts;
1020     iter->reverse = ((ts->transFlags & RPMTRANS_FLAG_REVERSE) ? 1 : 0);
1021     iter->oc = (iter->reverse ? (ts->orderCount - 1) : 0);
1022     iter->ocsave = iter->oc;
1023     return iter;
1024 }
1025
1026 /**
1027  * Return next transaction element's file info.
1028  * @param a             file info iterator
1029  * @return              next index, -1 on termination
1030  */
1031 static /*@dependent@*/ TFI_t tsNextIterator(void * a)
1032         /*@*/
1033 {
1034     struct tsIterator_s * iter = a;
1035     rpmTransactionSet ts = iter->ts;
1036     TFI_t fi = NULL;
1037     int oc = -1;
1038
1039     if (iter->reverse) {
1040         if (iter->oc >= 0)              oc = iter->oc--;
1041     } else {
1042         if (iter->oc < ts->orderCount)  oc = iter->oc++;
1043     }
1044     iter->ocsave = oc;
1045     if (oc != -1)
1046         fi = ts->flList + oc;
1047     return fi;
1048 }
1049
1050 #define NOTIFY(_ts, _al)        if ((_ts)->notify) (void) (_ts)->notify _al
1051
1052 int rpmRunTransactions( rpmTransactionSet ts,
1053                         rpmCallbackFunction notify, rpmCallbackData notifyData,
1054                         rpmProblemSet okProbs, rpmProblemSet * newProbs,
1055                         rpmtransFlags transFlags, rpmprobFilterFlags ignoreSet)
1056 {
1057     int i, j;
1058     int ourrc = 0;
1059     struct availablePackage * alp;
1060     int totalFileCount = 0;
1061     TFI_t fi;
1062     struct diskspaceInfo * dip;
1063     struct sharedFileInfo * shared, * sharedList;
1064     int numShared;
1065     int nexti;
1066     int lastFailed;
1067     int oc;
1068     fingerPrintCache fpc;
1069     struct psm_s psmbuf;
1070     PSM_t psm = &psmbuf;
1071     void * tsi;
1072     int xx;
1073
1074     /* FIXME: what if the same package is included in ts twice? */
1075
1076     ts->transFlags = transFlags;
1077     if (ts->transFlags & RPMTRANS_FLAG_NOSCRIPTS)
1078         ts->transFlags |= (_noTransScripts | _noTransTriggers);
1079     if (ts->transFlags & RPMTRANS_FLAG_NOTRIGGERS)
1080         ts->transFlags |= _noTransTriggers;
1081
1082     /* XXX MULTILIB is broken, as packages can and do execute /sbin/ldconfig. */
1083     if (ts->transFlags & (RPMTRANS_FLAG_JUSTDB | RPMTRANS_FLAG_MULTILIB))
1084         ts->transFlags |= (_noTransScripts | _noTransTriggers);
1085
1086     ts->notify = notify;
1087     ts->notifyData = notifyData;
1088     /*@-assignexpose@*/
1089     ts->probs = *newProbs = psCreate();
1090     /*@=assignexpose@*/
1091     ts->ignoreSet = ignoreSet;
1092     ts->currDir = _free(ts->currDir);
1093     ts->currDir = currentDirectory();
1094     ts->chrootDone = 0;
1095     if (ts->rpmdb) ts->rpmdb->db_chrootDone = 0;
1096     ts->id = (int_32) time(NULL);
1097
1098     memset(psm, 0, sizeof(*psm));
1099     /*@-assignexpose@*/
1100     psm->ts = ts;
1101     /*@=assignexpose@*/
1102
1103     /* Get available space on mounted file systems. */
1104     if (!(ts->ignoreSet & RPMPROB_FILTER_DISKSPACE) &&
1105                 !rpmGetFilesystemList(&ts->filesystems, &ts->filesystemCount)) {
1106         struct stat sb;
1107
1108         ts->di = _free(ts->di);
1109         dip = ts->di = xcalloc((ts->filesystemCount + 1), sizeof(*ts->di));
1110
1111         for (i = 0; (i < ts->filesystemCount) && dip; i++) {
1112 #if STATFS_IN_SYS_STATVFS
1113             struct statvfs sfb;
1114             memset(&sfb, 0, sizeof(sfb));
1115             if (statvfs(ts->filesystems[i], &sfb))
1116 #else
1117             struct statfs sfb;
1118 #  if STAT_STATFS4
1119 /* This platform has the 4-argument version of the statfs call.  The last two
1120  * should be the size of struct statfs and 0, respectively.  The 0 is the
1121  * filesystem type, and is always 0 when statfs is called on a mounted
1122  * filesystem, as we're doing.
1123  */
1124             memset(&sfb, 0, sizeof(sfb));
1125             if (statfs(ts->filesystems[i], &sfb, sizeof(sfb), 0))
1126 #  else
1127             memset(&sfb, 0, sizeof(sfb));
1128             if (statfs(ts->filesystems[i], &sfb))
1129 #  endif
1130 #endif
1131             {
1132                 dip = NULL;
1133             } else {
1134                 ts->di[i].bsize = sfb.f_bsize;
1135                 ts->di[i].bneeded = 0;
1136                 ts->di[i].ineeded = 0;
1137 #ifdef STATFS_HAS_F_BAVAIL
1138                 ts->di[i].bavail = sfb.f_bavail;
1139 #else
1140 /* FIXME: the statfs struct doesn't have a member to tell how many blocks are
1141  * available for non-superusers.  f_blocks - f_bfree is probably too big, but
1142  * it's about all we can do.
1143  */
1144                 ts->di[i].bavail = sfb.f_blocks - sfb.f_bfree;
1145 #endif
1146                 /* XXX Avoid FAT and other file systems that have not inodes. */
1147                 ts->di[i].iavail = !(sfb.f_ffree == 0 && sfb.f_files == 0)
1148                                 ? sfb.f_ffree : -1;
1149
1150                 xx = stat(ts->filesystems[i], &sb);
1151                 ts->di[i].dev = sb.st_dev;
1152             }
1153         }
1154
1155         if (dip) ts->di[i].bsize = 0;
1156     }
1157
1158     /* ===============================================
1159      * For packages being installed:
1160      * - verify package arch/os.
1161      * - verify package epoch:version-release is newer.
1162      * - count files.
1163      * For packages being removed:
1164      * - count files.
1165      */
1166     /* The ordering doesn't matter here */
1167     if (ts->addedPackages.list != NULL)
1168     for (alp = ts->addedPackages.list;
1169         (alp - ts->addedPackages.list) < ts->addedPackages.size;
1170         alp++)
1171     {
1172         if (!archOkay(alp->h) && !(ts->ignoreSet & RPMPROB_FILTER_IGNOREARCH))
1173             psAppend(ts->probs, RPMPROB_BADARCH, alp, NULL, NULL, NULL, 0);
1174
1175         if (!osOkay(alp->h) && !(ts->ignoreSet & RPMPROB_FILTER_IGNOREOS))
1176             psAppend(ts->probs, RPMPROB_BADOS, alp, NULL, NULL, NULL, 0);
1177
1178         if (!(ts->ignoreSet & RPMPROB_FILTER_OLDPACKAGE)) {
1179             rpmdbMatchIterator mi;
1180             Header oldH;
1181             mi = rpmdbInitIterator(ts->rpmdb, RPMTAG_NAME, alp->name, 0);
1182             while ((oldH = rpmdbNextIterator(mi)) != NULL)
1183                 xx = ensureOlder(alp, oldH, ts->probs);
1184             mi = rpmdbFreeIterator(mi);
1185         }
1186
1187         /* XXX multilib should not display "already installed" problems */
1188         if (!(ts->ignoreSet & RPMPROB_FILTER_REPLACEPKG) && !alp->multiLib) {
1189             rpmdbMatchIterator mi;
1190             mi = rpmdbInitIterator(ts->rpmdb, RPMTAG_NAME, alp->name, 0);
1191             xx = rpmdbSetIteratorRE(mi, RPMTAG_VERSION,
1192                         RPMMIRE_DEFAULT, alp->version);
1193             xx = rpmdbSetIteratorRE(mi, RPMTAG_RELEASE,
1194                         RPMMIRE_DEFAULT, alp->release);
1195
1196             while (rpmdbNextIterator(mi) != NULL) {
1197                 psAppend(ts->probs, RPMPROB_PKG_INSTALLED, alp,
1198                         NULL, NULL, NULL, 0);
1199                 /*@innerbreak@*/ break;
1200             }
1201             mi = rpmdbFreeIterator(mi);
1202         }
1203
1204         totalFileCount += alp->filesCount;
1205
1206     }
1207
1208     /* FIXME: it seems a bit silly to read in all of these headers twice */
1209     /* The ordering doesn't matter here */
1210     if (ts->numRemovedPackages > 0) {
1211         rpmdbMatchIterator mi;
1212         Header h;
1213         int fileCount;
1214
1215         mi = rpmdbInitIterator(ts->rpmdb, RPMDBI_PACKAGES, NULL, 0);
1216         xx = rpmdbAppendIterator(mi, ts->removedPackages, ts->numRemovedPackages);
1217         while ((h = rpmdbNextIterator(mi)) != NULL) {
1218             if (headerGetEntry(h, RPMTAG_BASENAMES, NULL, NULL, &fileCount))
1219                 totalFileCount += fileCount;
1220         }
1221         mi = rpmdbFreeIterator(mi);
1222     }
1223
1224     /* ===============================================
1225      * Initialize file list:
1226      */
1227     ts->flEntries = ts->addedPackages.size + ts->numRemovedPackages;
1228     ts->flList = xcalloc(ts->flEntries, sizeof(*ts->flList));
1229
1230     /*
1231      * FIXME?: we'd be better off assembling one very large file list and
1232      * calling fpLookupList only once. I'm not sure that the speedup is
1233      * worth the trouble though.
1234      */
1235     tsi = tsInitIterator(ts);
1236     while ((fi = tsNextIterator(tsi)) != NULL) {
1237         oc = tsGetOc(tsi);
1238         fi->magic = TFIMAGIC;
1239
1240         /* XXX watchout: fi->type must be set for tsGetAlp() to "work" */
1241         fi->type = ts->order[oc].type;
1242         /*@-branchstate@*/
1243         switch (fi->type) {
1244         case TR_ADDED:
1245             /* XXX watchout: fi->type must be set for tsGetAlp() to "work" */
1246             fi->ap = tsGetAlp(tsi);
1247             fi->record = 0;
1248             loadFi(ts, fi, fi->ap->h, 1);
1249 /* XXX free fi->ap->h here if/when possible */
1250             if (fi->fc == 0)
1251                 continue;
1252
1253             /* Skip netshared paths, not our i18n files, and excluded docs */
1254             skipFiles(ts, fi);
1255             /*@switchbreak@*/ break;
1256         case TR_REMOVED:
1257             fi->ap = NULL;
1258             fi->record = ts->order[oc].u.removed.dboffset;
1259             /* Retrieve erased package header from the database. */
1260             {   rpmdbMatchIterator mi;
1261
1262                 mi = rpmdbInitIterator(ts->rpmdb, RPMDBI_PACKAGES,
1263                                 &fi->record, sizeof(fi->record));
1264                 if ((fi->h = rpmdbNextIterator(mi)) != NULL)
1265                     fi->h = headerLink(fi->h);
1266                 mi = rpmdbFreeIterator(mi);
1267             }
1268             if (fi->h == NULL) {
1269                 /* ACK! */
1270                 continue;
1271             }
1272             /* XXX header arg unused. */
1273             loadFi(ts, fi, fi->h, 0);
1274             /*@switchbreak@*/ break;
1275         }
1276         /*@=branchstate@*/
1277
1278         if (fi->fc)
1279             fi->fps = xmalloc(fi->fc * sizeof(*fi->fps));
1280     }
1281     tsi = tsFreeIterator(tsi);
1282
1283     if (!ts->chrootDone) {
1284         xx = chdir("/");
1285         /*@-superuser -noeffect @*/
1286         xx = chroot(ts->rootDir);
1287         /*@=superuser =noeffect @*/
1288         ts->chrootDone = 1;
1289         if (ts->rpmdb) ts->rpmdb->db_chrootDone = 1;
1290         /*@-onlytrans@*/
1291         /*@-mods@*/
1292         chroot_prefix = ts->rootDir;
1293         /*@=mods@*/
1294         /*@=onlytrans@*/
1295     }
1296
1297     ts->ht = htCreate(totalFileCount * 2, 0, 0, fpHashFunction, fpEqual);
1298     fpc = fpCacheCreate(totalFileCount);
1299
1300     /* ===============================================
1301      * Add fingerprint for each file not skipped.
1302      */
1303     tsi = tsInitIterator(ts);
1304     while ((fi = tsNextIterator(tsi)) != NULL) {
1305         fpLookupList(fpc, fi->dnl, fi->bnl, fi->dil, fi->fc, fi->fps);
1306         for (i = 0; i < fi->fc; i++) {
1307             if (XFA_SKIPPING(fi->actions[i]))
1308                 /*@innercontinue@*/ continue;
1309             /*@-dependenttrans@*/
1310             htAddEntry(ts->ht, fi->fps + i, fi);
1311             /*@=dependenttrans@*/
1312         }
1313     }
1314     tsi = tsFreeIterator(tsi);
1315
1316     /*@-noeffectuncon @*/ /* FIX: check rc */
1317     NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_START, 6, ts->flEntries,
1318         NULL, ts->notifyData));
1319     /*@=noeffectuncon@*/
1320
1321     /* ===============================================
1322      * Compute file disposition for each package in transaction set.
1323      */
1324     tsi = tsInitIterator(ts);
1325     while ((fi = tsNextIterator(tsi)) != NULL) {
1326         dbiIndexSet * matches;
1327         int knownBad;
1328
1329         /*@-noeffectuncon @*/ /* FIX: check rc */
1330         NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_PROGRESS, (fi - ts->flList),
1331                         ts->flEntries, NULL, ts->notifyData));
1332         /*@=noeffectuncon@*/
1333
1334         if (fi->fc == 0) continue;
1335
1336         /* Extract file info for all files in this package from the database. */
1337         matches = xcalloc(fi->fc, sizeof(*matches));
1338         if (rpmdbFindFpList(ts->rpmdb, fi->fps, matches, fi->fc))
1339             return 1;   /* XXX WTFO? */
1340
1341         numShared = 0;
1342         for (i = 0; i < fi->fc; i++)
1343             numShared += dbiIndexSetCount(matches[i]);
1344
1345         /* Build sorted file info list for this package. */
1346         shared = sharedList = xcalloc((numShared + 1), sizeof(*sharedList));
1347         for (i = 0; i < fi->fc; i++) {
1348             /*
1349              * Take care not to mark files as replaced in packages that will
1350              * have been removed before we will get here.
1351              */
1352             for (j = 0; j < dbiIndexSetCount(matches[i]); j++) {
1353                 int k, ro;
1354                 ro = dbiIndexRecordOffset(matches[i], j);
1355                 knownBad = 0;
1356                 for (k = 0; ro != knownBad && k < ts->orderCount; k++) {
1357                     switch (ts->order[k].type) {
1358                     case TR_REMOVED:
1359                         if (ts->order[k].u.removed.dboffset == ro)
1360                             knownBad = ro;
1361                         /*@switchbreak@*/ break;
1362                     case TR_ADDED:
1363                         /*@switchbreak@*/ break;
1364                     }
1365                 }
1366
1367                 shared->pkgFileNum = i;
1368                 shared->otherPkg = dbiIndexRecordOffset(matches[i], j);
1369                 shared->otherFileNum = dbiIndexRecordFileNumber(matches[i], j);
1370                 shared->isRemoved = (knownBad == ro);
1371                 shared++;
1372             }
1373             matches[i] = dbiFreeIndexSet(matches[i]);
1374         }
1375         numShared = shared - sharedList;
1376         shared->otherPkg = -1;
1377         matches = _free(matches);
1378
1379         /* Sort file info by other package index (otherPkg) */
1380         qsort(sharedList, numShared, sizeof(*shared), sharedCmp);
1381
1382         /* For all files from this package that are in the database ... */
1383         for (i = 0; i < numShared; i = nexti) {
1384             int beingRemoved;
1385
1386             shared = sharedList + i;
1387
1388             /* Find the end of the files in the other package. */
1389             for (nexti = i + 1; nexti < numShared; nexti++) {
1390                 if (sharedList[nexti].otherPkg != shared->otherPkg)
1391                     /*@innerbreak@*/ break;
1392             }
1393
1394             /* Is this file from a package being removed? */
1395             beingRemoved = 0;
1396             for (j = 0; j < ts->numRemovedPackages; j++) {
1397                 if (ts->removedPackages[j] != shared->otherPkg)
1398                     /*@innercontinue@*/ continue;
1399                 beingRemoved = 1;
1400                 /*@innerbreak@*/ break;
1401             }
1402
1403             /* Determine the fate of each file. */
1404             switch (fi->type) {
1405             case TR_ADDED:
1406                 xx = handleInstInstalledFiles(ts, fi, shared, nexti - i,
1407         !(beingRemoved || (ts->ignoreSet & RPMPROB_FILTER_REPLACEOLDFILES)));
1408                 /*@switchbreak@*/ break;
1409             case TR_REMOVED:
1410                 if (!beingRemoved)
1411                     xx = handleRmvdInstalledFiles(ts, fi, shared, nexti - i);
1412                 /*@switchbreak@*/ break;
1413             }
1414         }
1415
1416         free(sharedList);
1417
1418         /* Update disk space needs on each partition for this package. */
1419         handleOverlappedFiles(ts, fi);
1420
1421         /* Check added package has sufficient space on each partition used. */
1422         switch (fi->type) {
1423         case TR_ADDED:
1424             if (!(ts->di && fi->fc))
1425                 /*@switchbreak@*/ break;
1426             for (i = 0; i < ts->filesystemCount; i++) {
1427
1428                 dip = ts->di + i;
1429
1430                 /* XXX Avoid FAT and other file systems that have not inodes. */
1431                 if (dip->iavail <= 0)
1432                     /*@innercontinue@*/ continue;
1433
1434                 if (adj_fs_blocks(dip->bneeded) > dip->bavail)
1435                     psAppend(ts->probs, RPMPROB_DISKSPACE, fi->ap,
1436                                 ts->filesystems[i], NULL, NULL,
1437                    (adj_fs_blocks(dip->bneeded) - dip->bavail) * dip->bsize);
1438
1439                 if (adj_fs_blocks(dip->ineeded) > dip->iavail)
1440                     psAppend(ts->probs, RPMPROB_DISKNODES, fi->ap,
1441                                 ts->filesystems[i], NULL, NULL,
1442                     (adj_fs_blocks(dip->ineeded) - dip->iavail));
1443             }
1444             /*@switchbreak@*/ break;
1445         case TR_REMOVED:
1446             /*@switchbreak@*/ break;
1447         }
1448     }
1449     tsi = tsFreeIterator(tsi);
1450
1451     if (ts->chrootDone) {
1452         /*@-superuser -noeffect @*/
1453         xx = chroot(".");
1454         /*@=superuser =noeffect @*/
1455         ts->chrootDone = 0;
1456         if (ts->rpmdb) ts->rpmdb->db_chrootDone = 0;
1457         /*@-mods@*/
1458         chroot_prefix = NULL;
1459         /*@=mods@*/
1460         xx = chdir(ts->currDir);
1461     }
1462
1463     /*@-noeffectuncon @*/ /* FIX: check rc */
1464     NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_STOP, 6, ts->flEntries,
1465         NULL, ts->notifyData));
1466     /*@=noeffectuncon @*/
1467
1468     /* ===============================================
1469      * Free unused memory as soon as possible.
1470      */
1471
1472     tsi = tsInitIterator(ts);
1473     while ((fi = tsNextIterator(tsi)) != NULL) {
1474         psm->fi = fi;
1475         if (fi->fc == 0)
1476             continue;
1477         fi->fps = _free(fi->fps);
1478     }
1479     tsi = tsFreeIterator(tsi);
1480
1481     fpCacheFree(fpc);
1482     htFree(ts->ht);
1483     ts->ht = NULL;
1484
1485     /* ===============================================
1486      * If unfiltered problems exist, free memory and return.
1487      */
1488     if ((ts->transFlags & RPMTRANS_FLAG_BUILD_PROBS) ||
1489            (ts->probs->numProblems && (!okProbs || psTrim(okProbs, ts->probs))))
1490     {
1491         *newProbs = ts->probs;
1492
1493         ts->flList = freeFl(ts, ts->flList);
1494         ts->flEntries = 0;
1495         /*@-nullstate@*/
1496         return ts->orderCount;
1497         /*@=nullstate@*/
1498     }
1499
1500     /* ===============================================
1501      * Save removed files before erasing.
1502      */
1503     if (ts->transFlags & (RPMTRANS_FLAG_DIRSTASH | RPMTRANS_FLAG_REPACKAGE)) {
1504         tsi = tsInitIterator(ts);
1505         while ((fi = tsNextIterator(tsi)) != NULL) {
1506             psm->fi = fi;
1507             switch (fi->type) {
1508             case TR_ADDED:
1509                 /*@switchbreak@*/ break;
1510             case TR_REMOVED:
1511                 if (ts->transFlags & RPMTRANS_FLAG_REPACKAGE)
1512                     xx = psmStage(psm, PSM_PKGSAVE);
1513                 /*@switchbreak@*/ break;
1514             }
1515         }
1516         tsi = tsFreeIterator(tsi);
1517     }
1518
1519     /* ===============================================
1520      * Install and remove packages.
1521      */
1522
1523     lastFailed = -2;    /* erased packages have -1 */
1524     tsi = tsInitIterator(ts);
1525     while ((fi = tsNextIterator(tsi)) != NULL) {
1526         Header h;
1527         int gotfd;
1528
1529         gotfd = 0;
1530         psm->fi = fi;
1531         switch (fi->type) {
1532         case TR_ADDED:
1533             alp = tsGetAlp(tsi);
1534 assert(alp == fi->ap);
1535             i = alp - ts->addedPackages.list;
1536
1537             rpmMessage(RPMMESS_DEBUG, "========== +++ %s-%s-%s\n",
1538                         fi->name, fi->version, fi->release);
1539             h = (fi->h ? headerLink(fi->h) : NULL);
1540             /*@-branchstate@*/
1541             if (alp->fd == NULL) {
1542                 alp->fd = ts->notify(fi->h, RPMCALLBACK_INST_OPEN_FILE, 0, 0,
1543                             alp->key, ts->notifyData);
1544                 if (alp->fd) {
1545                     rpmRC rpmrc;
1546
1547                     h = headerFree(h);
1548
1549 #ifdef  DYING
1550                     /*@-mustmod@*/      /* LCL: segfault */
1551                     rpmrc = rpmReadPackageHeader(alp->fd, &h, NULL, NULL, NULL);
1552                     /*@=mustmod@*/
1553 #else
1554                     /* XXX Leave fd positioned at payload. */
1555                     ts->need_payload = 1;
1556                     /*@-mustmod@*/      /* LCL: segfault */
1557                     xx = rpmReadPackageFile(ts, alp->fd, "rpmRunTransactions", &h);
1558                     /*@=mustmod@*/
1559                     ts->need_payload = 0;
1560                     rpmrc = (xx ? RPMRC_FAIL : RPMRC_OK);      /* XXX HACK */
1561 #endif
1562                     if (!(rpmrc == RPMRC_OK || rpmrc == RPMRC_BADSIZE)) {
1563                         /*@-noeffectuncon @*/ /* FIX: check rc */
1564                         (void)ts->notify(fi->h, RPMCALLBACK_INST_CLOSE_FILE,
1565                                         0, 0, alp->key, ts->notifyData);
1566                         /*@=noeffectuncon @*/
1567                         alp->fd = NULL;
1568                         ourrc++;
1569                     } else if (fi->h != NULL) {
1570                         Header foo = relocateFileList(ts, fi, alp, h, NULL);
1571                         h = headerFree(h);
1572                         h = headerLink(foo);
1573                         foo = headerFree(foo);
1574                     }
1575                     if (alp->fd) gotfd = 1;
1576                 }
1577             }
1578             /*@=branchstate@*/
1579
1580             if (alp->fd) {
1581                 Header hsave = NULL;
1582
1583                 if (fi->h) {
1584                     hsave = headerLink(fi->h);
1585                     fi->h = headerFree(fi->h);
1586                     fi->h = headerLink(h);
1587                 } else {
1588 char * fstates = fi->fstates;
1589 fileAction * actions = fi->actions;
1590 fi->fstates = NULL;
1591 fi->actions = NULL;
1592                     freeFi(fi);
1593 oc = tsGetOc(tsi);
1594 fi->magic = TFIMAGIC;
1595 fi->type = ts->order[oc].type;
1596 fi->ap = tsGetAlp(tsi);
1597 fi->record = 0;
1598                     loadFi(ts, fi, h, 1);
1599 fi->fstates = _free(fi->fstates);
1600 fi->fstates = fstates;
1601 fi->actions = _free(fi->actions);
1602 fi->actions = actions;
1603                 }
1604                 if (alp->multiLib)
1605                     ts->transFlags |= RPMTRANS_FLAG_MULTILIB;
1606
1607 assert(alp == fi->ap);
1608                 if (psmStage(psm, PSM_PKGINSTALL)) {
1609                     ourrc++;
1610                     lastFailed = i;
1611                 }
1612                 fi->h = headerFree(fi->h);
1613                 if (hsave) {
1614                     fi->h = headerLink(hsave);
1615                     hsave = headerFree(hsave);
1616                 }
1617             } else {
1618                 ourrc++;
1619                 lastFailed = i;
1620             }
1621
1622             h = headerFree(h);
1623
1624             if (gotfd) {
1625                 /*@-noeffectuncon @*/ /* FIX: check rc */
1626                 (void)ts->notify(fi->h, RPMCALLBACK_INST_CLOSE_FILE, 0, 0,
1627                         alp->key, ts->notifyData);
1628                 /*@=noeffectuncon @*/
1629                 alp->fd = NULL;
1630             }
1631             freeFi(fi);
1632             /*@switchbreak@*/ break;
1633         case TR_REMOVED:
1634             rpmMessage(RPMMESS_DEBUG, "========== --- %s-%s-%s\n",
1635                         fi->name, fi->version, fi->release);
1636             oc = tsGetOc(tsi);
1637             /* If install failed, then we shouldn't erase. */
1638             if (ts->order[oc].u.removed.dependsOnIndex != lastFailed) {
1639                 if (psmStage(psm, PSM_PKGERASE))
1640                     ourrc++;
1641             }
1642             freeFi(fi);
1643             /*@switchbreak@*/ break;
1644         }
1645         xx = rpmdbSync(ts->rpmdb);
1646     }
1647     tsi = tsFreeIterator(tsi);
1648
1649     ts->flList = freeFl(ts, ts->flList);
1650     ts->flEntries = 0;
1651
1652     /*@-nullstate@*/
1653     if (ourrc)
1654         return -1;
1655     else
1656         return 0;
1657     /*@=nullstate@*/
1658 }