lib/transaction.c

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