lib/transaction.c

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