lib/fsm.c

   1 /** \ingroup payload
   2  * \file lib/fsm.c
   3  * File state machine to handle a payload from a package.
   4  */
   5
   6 #include "system.h"
   7
   8 #include <rpm/rpmte.h>
   9 #include <rpm/rpmts.h>
  10 #include <rpm/rpmsq.h>
  11 #include <rpm/rpmlog.h>
  12
  13 #include "rpmio/rpmio_internal.h"       /* fdGet/SetCpioPos, fdInit/FiniDigest */
  14 #include "lib/cpio.h"
  15 #include "lib/fsm.h"
  16 #define fsmUNSAFE       fsmStage
  17 #include "lib/rpmfi_internal.h" /* XXX fi->apath, ... */
  18 #include "lib/rpmte_internal.h" /* XXX rpmfs */
  19 #include "lib/misc.h"           /* XXX unameToUid() and gnameToGid() */
  20
  21 #include "debug.h"
  22
  23 #define _FSM_DEBUG      0
  24 int _fsm_debug = _FSM_DEBUG;
  25
  26 int _fsm_threads = 0;
  27
  28 /* XXX Failure to remove is not (yet) cause for failure. */
  29 static int strict_erasures = 0;
  30
  31 /** \ingroup payload
  32  * Keeps track of the set of all hard links to a file in an archive.
  33  */
  34 struct hardLink_s {
  35     hardLink_t next;
  36     const char ** nsuffix;
  37     int * filex;
  38     struct stat sb;
  39     nlink_t nlink;
  40     nlink_t linksLeft;
  41     int linkIndex;
  42     int createdPath;
  43 };
  44
  45 /** \ingroup payload
  46  * Iterator across package file info, forward on install, backward on erase.
  47  */
  48 struct fsmIterator_s {
  49     rpmts ts;                   /*!< transaction set. */
  50     rpmte te;                   /*!< transaction element. */
  51     rpmfi fi;                   /*!< transaction element file info. */
  52     int reverse;                /*!< reversed traversal? */
  53     int isave;                  /*!< last returned iterator index. */
  54     int i;                      /*!< iterator index. */
  55 };
  56
  57 /**
  58  * Retrieve transaction set from file state machine iterator.
  59  * @param fsm           file state machine
  60  * @return              transaction set
  61  */
  62 static rpmts fsmGetTs(const FSM_t fsm) {
  63     const FSMI_t iter = fsm->iter;
  64     return (iter ? iter->ts : NULL);
  65 }
  66
  67 /**
  68  * Retrieve transaction element file info from file state machine iterator.
  69  * @param fsm           file state machine
  70  * @return              transaction element file info
  71  */
  72 static rpmfi fsmGetFi(const FSM_t fsm)
  73 {
  74     const FSMI_t iter = fsm->iter;
  75     return (iter ? iter->fi : NULL);
  76 }
  77
  78 static rpmte fsmGetTe(const FSM_t fsm)
  79 {
  80     const FSMI_t iter = fsm->iter;
  81     return (iter ? iter->te : NULL);
  82 }
  83
  84 #define SUFFIX_RPMORIG  ".rpmorig"
  85 #define SUFFIX_RPMSAVE  ".rpmsave"
  86 #define SUFFIX_RPMNEW   ".rpmnew"
  87
  88 /* Default directory and file permissions if not mapped */
  89 #define _dirPerms 0755
  90 #define _filePerms 0644
  91
  92 /*
  93  * XXX Forward declarations for previously exported functions to avoid moving
  94  * things around needlessly
  95  */
  96 static const char * fileStageString(fileStage a);
  97 static const char * fileActionString(rpmFileAction a);
  98 static int fsmStage(FSM_t fsm, fileStage stage);
  99
 100 /** \ingroup payload
 101  * Build path to file from file info, ornamented with subdir and suffix.
 102  * @param fsm           file state machine data
 103  * @param st            file stat info
 104  * @param subdir        subdir to use (NULL disables)
 105  * @param suffix        suffix to use (NULL disables)
 106  * @retval              path to file (malloced)
 107  */
 108 static char * fsmFsPath(const FSM_t fsm,
 109                 const struct stat * st,
 110                 const char * subdir,
 111                 const char * suffix)
 112 {
 113     char * s = NULL;
 114
 115     if (fsm) {
 116         size_t nb;
 117         char * t;
 118         nb = strlen(fsm->dirName) +
 119             (st && !S_ISDIR(st->st_mode) ? (subdir ? strlen(subdir) : 0) : 0) +
 120             (st && !S_ISDIR(st->st_mode) ? (suffix ? strlen(suffix) : 0) : 0) +
 121             strlen(fsm->baseName) + 1;
 122         s = t = xmalloc(nb);
 123         t = stpcpy(t, fsm->dirName);
 124         if (st && !S_ISDIR(st->st_mode))
 125             if (subdir) t = stpcpy(t, subdir);
 126         t = stpcpy(t, fsm->baseName);
 127         if (st && !S_ISDIR(st->st_mode))
 128             if (suffix) t = stpcpy(t, suffix);
 129     }
 130     return s;
 131 }
 132
 133 /** \ingroup payload
 134  * Destroy file info iterator.
 135  * @param p             file info iterator
 136  * @retval              NULL always
 137  */
 138 static void * mapFreeIterator(void * p)
 139 {
 140     FSMI_t iter = p;
 141     if (iter) {
 142 /* XXX rpmswExit() */
 143         iter->ts = rpmtsFree(iter->ts);
 144         iter->te = NULL; /* XXX rpmte is not refcounted yet */
 145         iter->fi = rpmfiUnlink(iter->fi, RPMDBG_M("mapFreeIterator"));
 146     }
 147     return _free(p);
 148 }
 149
 150 /** \ingroup payload
 151  * Create file info iterator.
 152  * @param ts            transaction set
 153  * @param fi            transaction element file info
 154  * @return              file info iterator
 155  */
 156 static void *
 157 mapInitIterator(rpmts ts, rpmte te, rpmfi fi)
 158 {
 159     FSMI_t iter = NULL;
 160
 161     iter = xcalloc(1, sizeof(*iter));
 162     iter->ts = rpmtsLink(ts, RPMDBG_M("mapIterator"));
 163     iter->te = te; /* XXX rpmte is not refcounted yet */
 164     iter->fi = rpmfiLink(fi, RPMDBG_M("mapIterator"));
 165     iter->reverse = (rpmteType(te) == TR_REMOVED);
 166     iter->i = (iter->reverse ? (rpmfiFC(fi) - 1) : 0);
 167     iter->isave = iter->i;
 168     return iter;
 169 }
 170
 171 /** \ingroup payload
 172  * Return next index into file info.
 173  * @param a             file info iterator
 174  * @return              next index, -1 on termination
 175  */
 176 static int mapNextIterator(void * a)
 177 {
 178     FSMI_t iter = a;
 179     int i = -1;
 180
 181     if (iter) {
 182         const rpmfi fi = iter->fi;
 183         if (iter->reverse) {
 184             if (iter->i >= 0)   i = iter->i--;
 185         } else {
 186             if (iter->i < rpmfiFC(fi))  i = iter->i++;
 187         }
 188         iter->isave = i;
 189     }
 190     return i;
 191 }
 192
 193 /** \ingroup payload
 194  */
 195 static int cpioStrCmp(const void * a, const void * b)
 196 {
 197     const char * afn = *(const char **)a;
 198     const char * bfn = *(const char **)b;
 199
 200     /* XXX Some 4+ year old rpm packages have basename only in payloads. */
 201 #ifdef  VERY_OLD_BUGGY_RPM_PACKAGES
 202     if (strchr(afn, '/') == NULL)
 203         bfn = strrchr(bfn, '/') + 1;
 204 #endif
 205
 206     /* Match rpm-4.0 payloads with ./ prefixes. */
 207     if (afn[0] == '.' && afn[1] == '/') afn += 2;
 208     if (bfn[0] == '.' && bfn[1] == '/') bfn += 2;
 209
 210     /* If either path is absolute, make it relative. */
 211     if (afn[0] == '/')  afn += 1;
 212     if (bfn[0] == '/')  bfn += 1;
 213
 214     return strcmp(afn, bfn);
 215 }
 216
 217 /** \ingroup payload
 218  * Locate archive path in file info.
 219  * @param iter          file info iterator
 220  * @param fsmPath       archive path
 221  * @return              index into file info, -1 if archive path was not found
 222  */
 223 static int mapFind(FSMI_t iter, const char * fsmPath)
 224 {
 225     int ix = -1;
 226
 227     if (iter) {
 228         const rpmfi fi = iter->fi;
 229         int fc = rpmfiFC(fi);
 230         if (fi && fc > 0 && fi->apath && fsmPath && *fsmPath) {
 231             char ** p = NULL;
 232
 233             if (fi->apath != NULL)
 234                 p = bsearch(&fsmPath, fi->apath, fc, sizeof(fsmPath),
 235                         cpioStrCmp);
 236             if (p) {
 237                 iter->i = p - fi->apath;
 238                 ix = mapNextIterator(iter);
 239             }
 240         }
 241     }
 242     return ix;
 243 }
 244
 245 /** \ingroup payload
 246  * Directory name iterator.
 247  */
 248 typedef struct dnli_s {
 249     rpmfi fi;
 250     char * active;
 251     int reverse;
 252     int isave;
 253     int i;
 254 } * DNLI_t;
 255
 256 /** \ingroup payload
 257  * Destroy directory name iterator.
 258  * @param a             directory name iterator
 259  * @retval              NULL always
 260  */
 261 static void * dnlFreeIterator(void * a)
 262 {
 263     if (a) {
 264         DNLI_t dnli = (void *)a;
 265         if (dnli->active) free(dnli->active);
 266     }
 267     return _free(a);
 268 }
 269
 270 /** \ingroup payload
 271  */
 272 static inline int dnlCount(const DNLI_t dnli)
 273 {
 274     return (dnli ? rpmfiDC(dnli->fi) : 0);
 275 }
 276
 277 /** \ingroup payload
 278  */
 279 static inline int dnlIndex(const DNLI_t dnli)
 280 {
 281     return (dnli ? dnli->isave : -1);
 282 }
 283
 284 /** \ingroup payload
 285  * Create directory name iterator.
 286  * @param fsm           file state machine data
 287  * @param reverse       traverse directory names in reverse order?
 288  * @return              directory name iterator
 289  */
 290 static
 291 void * dnlInitIterator(const FSM_t fsm,
 292                 int reverse)
 293
 294 {
 295     rpmfi fi = fsmGetFi(fsm);
 296     rpmfs fs = rpmteGetFileStates(fsmGetTe(fsm));
 297     DNLI_t dnli;
 298     int i, j;
 299     int dc;
 300
 301     if (fi == NULL)
 302         return NULL;
 303     dc = rpmfiDC(fi);
 304     dnli = xcalloc(1, sizeof(*dnli));
 305     dnli->fi = fi;
 306     dnli->reverse = reverse;
 307     dnli->i = (reverse ? dc : 0);
 308
 309     if (dc) {
 310         dnli->active = xcalloc(dc, sizeof(*dnli->active));
 311         int fc = rpmfiFC(fi);
 312
 313         /* Identify parent directories not skipped. */
 314         for (i = 0; i < fc; i++)
 315             if (!XFA_SKIPPING(rpmfsGetAction(fs, i)))
 316                 dnli->active[rpmfiDIIndex(fi, i)] = 1;
 317
 318         /* Exclude parent directories that are explicitly included. */
 319         for (i = 0; i < fc; i++) {
 320             int dil;
 321             size_t dnlen, bnlen;
 322
 323             if (!S_ISDIR(rpmfiFModeIndex(fi, i)))
 324                 continue;
 325
 326             dil = rpmfiDIIndex(fi, i);
 327             dnlen = strlen(rpmfiDNIndex(fi, dil));
 328             bnlen = strlen(rpmfiBNIndex(fi, i));
 329
 330             for (j = 0; j < dc; j++) {
 331                 const char * dnl;
 332                 size_t jlen;
 333
 334                 if (!dnli->active[j] || j == dil)
 335                     continue;
 336                 dnl = rpmfiDNIndex(fi, j);
 337                 jlen = strlen(dnl);
 338                 if (jlen != (dnlen+bnlen+1))
 339                     continue;
 340                 if (!rstreqn(dnl, rpmfiDNIndex(fi, dil), dnlen))
 341                     continue;
 342                 if (!rstreqn(dnl+dnlen, rpmfiBNIndex(fi, i), bnlen))
 343                     continue;
 344                 if (dnl[dnlen+bnlen] != '/' || dnl[dnlen+bnlen+1] != '\0')
 345                     continue;
 346                 /* This directory is included in the package. */
 347                 dnli->active[j] = 0;
 348                 break;
 349             }
 350         }
 351
 352         /* Print only once per package. */
 353         if (!reverse) {
 354             j = 0;
 355             for (i = 0; i < dc; i++) {
 356                 if (!dnli->active[i]) continue;
 357                 if (j == 0) {
 358                     j = 1;
 359                     rpmlog(RPMLOG_DEBUG,
 360         "========== Directories not explicitly included in package:\n");
 361                 }
 362                 rpmlog(RPMLOG_DEBUG, "%10d %s\n", i, rpmfiDNIndex(fi, i));
 363             }
 364             if (j)
 365                 rpmlog(RPMLOG_DEBUG, "==========\n");
 366         }
 367     }
 368     return dnli;
 369 }
 370
 371 /** \ingroup payload
 372  * Return next directory name (from file info).
 373  * @param dnli          directory name iterator
 374  * @return              next directory name
 375  */
 376 static
 377 const char * dnlNextIterator(DNLI_t dnli)
 378 {
 379     const char * dn = NULL;
 380
 381     if (dnli) {
 382         rpmfi fi = dnli->fi;
 383         int dc = rpmfiDC(fi);
 384         int i = -1;
 385
 386         if (dnli->active)
 387         do {
 388             i = (!dnli->reverse ? dnli->i++ : --dnli->i);
 389         } while (i >= 0 && i < dc && !dnli->active[i]);
 390
 391         if (i >= 0 && i < dc)
 392             dn = rpmfiDNIndex(fi, i);
 393         else
 394             i = -1;
 395         dnli->isave = i;
 396     }
 397     return dn;
 398 }
 399
 400 static void * fsmThread(void * arg)
 401 {
 402     FSM_t fsm = arg;
 403     return ((void *) ((long) fsmStage(fsm, fsm->nstage)));
 404 }
 405
 406 int fsmNext(FSM_t fsm, fileStage nstage)
 407 {
 408     fsm->nstage = nstage;
 409     if (_fsm_threads)
 410         return rpmsqJoin( rpmsqThread(fsmThread, fsm) );
 411     return fsmStage(fsm, fsm->nstage);
 412 }
 413
 414 /** \ingroup payload
 415  * Save hard link in chain.
 416  * @param fsm           file state machine data
 417  * @return              Is chain only partially filled?
 418  */
 419 static int saveHardLink(FSM_t fsm)
 420 {
 421     struct stat * st = &fsm->sb;
 422     int rc = 0;
 423     int ix = -1;
 424     int j;
 425
 426     /* Find hard link set. */
 427     for (fsm->li = fsm->links; fsm->li; fsm->li = fsm->li->next) {
 428         if (fsm->li->sb.st_ino == st->st_ino && fsm->li->sb.st_dev == st->st_dev)
 429             break;
 430     }
 431
 432     /* New hard link encountered, add new link to set. */
 433     if (fsm->li == NULL) {
 434         fsm->li = xcalloc(1, sizeof(*fsm->li));
 435         fsm->li->next = NULL;
 436         fsm->li->sb = *st;      /* structure assignment */
 437         fsm->li->nlink = st->st_nlink;
 438         fsm->li->linkIndex = fsm->ix;
 439         fsm->li->createdPath = -1;
 440
 441         fsm->li->filex = xcalloc(st->st_nlink, sizeof(fsm->li->filex[0]));
 442         memset(fsm->li->filex, -1, (st->st_nlink * sizeof(fsm->li->filex[0])));
 443         fsm->li->nsuffix = xcalloc(st->st_nlink, sizeof(*fsm->li->nsuffix));
 444
 445         if (fsm->goal == FSM_PKGBUILD)
 446             fsm->li->linksLeft = st->st_nlink;
 447         if (fsm->goal == FSM_PKGINSTALL)
 448             fsm->li->linksLeft = 0;
 449
 450         fsm->li->next = fsm->links;
 451         fsm->links = fsm->li;
 452     }
 453
 454     if (fsm->goal == FSM_PKGBUILD) --fsm->li->linksLeft;
 455     fsm->li->filex[fsm->li->linksLeft] = fsm->ix;
 456     fsm->li->nsuffix[fsm->li->linksLeft] = fsm->nsuffix;
 457     if (fsm->goal == FSM_PKGINSTALL) fsm->li->linksLeft++;
 458
 459     if (fsm->goal == FSM_PKGBUILD)
 460         return (fsm->li->linksLeft > 0);
 461
 462     if (fsm->goal != FSM_PKGINSTALL)
 463         return 0;
 464
 465     if (!(st->st_size || fsm->li->linksLeft == st->st_nlink))
 466         return 1;
 467
 468     /* Here come the bits, time to choose a non-skipped file name. */
 469     {   rpmfs fs = rpmteGetFileStates(fsmGetTe(fsm));
 470
 471         for (j = fsm->li->linksLeft - 1; j >= 0; j--) {
 472             ix = fsm->li->filex[j];
 473             if (ix < 0 || XFA_SKIPPING(rpmfsGetAction(fs, ix)))
 474                 continue;
 475             break;
 476         }
 477     }
 478
 479     /* Are all links skipped or not encountered yet? */
 480     if (ix < 0 || j < 0)
 481         return 1;       /* XXX W2DO? */
 482
 483     /* Save the non-skipped file name and map index. */
 484     fsm->li->linkIndex = j;
 485     fsm->path = _constfree(fsm->path);
 486     fsm->ix = ix;
 487     rc = fsmNext(fsm, FSM_MAP);
 488     return rc;
 489 }
 490
 491 /** \ingroup payload
 492  * Destroy set of hard links.
 493  * @param li            set of hard links
 494  * @return              NULL always
 495  */
 496 static void * freeHardLink(hardLink_t li)
 497 {
 498     if (li) {
 499         li->nsuffix = _free(li->nsuffix);       /* XXX elements are shared */
 500         li->filex = _free(li->filex);
 501     }
 502     return _free(li);
 503 }
 504
 505 FSM_t newFSM(cpioMapFlags mapflags)
 506 {
 507     FSM_t fsm = xcalloc(1, sizeof(*fsm));
 508     fsm->mapFlags = mapflags;
 509     return fsm;
 510 }
 511
 512 FSM_t freeFSM(FSM_t fsm)
 513 {
 514     if (fsm) {
 515         fsm->path = _constfree(fsm->path);
 516         while ((fsm->li = fsm->links) != NULL) {
 517             fsm->links = fsm->li->next;
 518             fsm->li->next = NULL;
 519             fsm->li = freeHardLink(fsm->li);
 520         }
 521         fsm->dnlx = _free(fsm->dnlx);
 522         fsm->ldn = _free(fsm->ldn);
 523         fsm->iter = mapFreeIterator(fsm->iter);
 524     }
 525     return _free(fsm);
 526 }
 527
 528 int fsmSetup(FSM_t fsm, fileStage goal,
 529                 rpmts ts, rpmte te, rpmfi fi, FD_t cfd,
 530                 rpm_loff_t * archiveSize, char ** failedFile)
 531 {
 532     rpm_loff_t pos = 0;
 533     int rc, ec = 0;
 534
 535     fsm->goal = goal;
 536     if (cfd != NULL) {
 537         fsm->cfd = fdLink(cfd, RPMDBG_M("persist (fsm)"));
 538         pos = fdGetCpioPos(fsm->cfd);
 539         fdSetCpioPos(fsm->cfd, 0);
 540     }
 541     fsm->iter = mapInitIterator(ts, te, fi);
 542     fsm->digestalgo = rpmfiDigestAlgo(fi);
 543
 544     if (fsm->goal == FSM_PKGINSTALL || fsm->goal == FSM_PKGBUILD) {
 545         void * ptr;
 546         fsm->archivePos = 0;
 547         ptr = rpmtsNotify(ts, te,
 548                 RPMCALLBACK_INST_START, fsm->archivePos, fi->archiveSize);
 549     }
 550
 551     fsm->archiveSize = archiveSize;
 552     if (fsm->archiveSize)
 553         *fsm->archiveSize = 0;
 554     fsm->failedFile = failedFile;
 555     if (fsm->failedFile)
 556         *fsm->failedFile = NULL;
 557
 558     memset(fsm->sufbuf, 0, sizeof(fsm->sufbuf));
 559     if (fsm->goal == FSM_PKGINSTALL) {
 560         if (ts && rpmtsGetTid(ts) != (rpm_tid_t)-1)
 561             sprintf(fsm->sufbuf, ";%08x", (unsigned)rpmtsGetTid(ts));
 562     }
 563
 564     ec = fsm->rc = 0;
 565     rc = fsmUNSAFE(fsm, FSM_CREATE);
 566     if (rc && !ec) ec = rc;
 567
 568     rc = fsmUNSAFE(fsm, fsm->goal);
 569     if (rc && !ec) ec = rc;
 570
 571     if (fsm->archiveSize && ec == 0)
 572         *fsm->archiveSize = (fdGetCpioPos(fsm->cfd) - pos);
 573
 574 /* FIX: *fsm->failedFile may be NULL */
 575    return ec;
 576 }
 577
 578 int fsmTeardown(FSM_t fsm)
 579 {
 580     int rc = fsm->rc;
 581
 582     if (!rc)
 583         rc = fsmUNSAFE(fsm, FSM_DESTROY);
 584
 585     fsm->iter = mapFreeIterator(fsm->iter);
 586     if (fsm->cfd != NULL) {
 587         fsm->cfd = fdFree(fsm->cfd, RPMDBG_M("persist (fsm)"));
 588         fsm->cfd = NULL;
 589     }
 590     fsm->failedFile = NULL;
 591     return rc;
 592 }
 593
 594 static int fsmMapFContext(FSM_t fsm)
 595 {
 596     rpmts ts = fsmGetTs(fsm);
 597     struct stat * st;
 598     st = &fsm->sb;
 599
 600     /*
 601      * Find file security context (if not disabled).
 602      */
 603     fsm->fcontext = NULL;
 604     if (ts != NULL && !(rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONTEXTS)) {
 605         security_context_t scon = NULL;
 606
 607         if (matchpathcon(fsm->path, st->st_mode, &scon) == 0 && scon != NULL) {
 608             fsm->fcontext = scon;
 609         }
 610     }
 611     return 0;
 612 }
 613
 614 #if WITH_CAP
 615 static int fsmMapFCaps(FSM_t fsm)
 616 {
 617     rpmfi fi = fsmGetFi(fsm);
 618     const char *captxt = rpmfiFCapsIndex(fi, fsm->ix);
 619     fsm->fcaps = NULL;
 620     if (captxt && *captxt != '\0') {
 621         cap_t fcaps = cap_from_text(captxt);
 622         if (fcaps) {
 623            fsm->fcaps = fcaps;
 624         }
 625     }
 626     return 0;
 627 }
 628 #endif
 629
 630 /**
 631  * Map next file path and action.
 632  * @param fsm           file state machine
 633  */
 634 static int fsmMapPath(FSM_t fsm)
 635 {
 636     rpmfi fi = fsmGetFi(fsm);   /* XXX const except for fstates */
 637     int rc = 0;
 638     int i;
 639
 640     fsm->osuffix = NULL;
 641     fsm->nsuffix = NULL;
 642     fsm->action = FA_UNKNOWN;
 643
 644     i = fsm->ix;
 645     if (fi && i >= 0 && i < rpmfiFC(fi)) {
 646         rpmte te = fsmGetTe(fsm);
 647         rpmfs fs = rpmteGetFileStates(te);
 648         /* XXX these should use rpmfiFFlags() etc */
 649         fsm->action = rpmfsGetAction(fs, i);
 650         fsm->fflags = rpmfiFFlagsIndex(fi, i);
 651
 652         /* src rpms have simple base name in payload. */
 653         fsm->dirName = rpmfiDNIndex(fi, rpmfiDIIndex(fi, i));
 654         fsm->baseName = rpmfiBNIndex(fi, i);
 655
 656         switch (fsm->action) {
 657         case FA_SKIP:
 658             break;
 659         case FA_UNKNOWN:
 660             break;
 661
 662         case FA_COPYOUT:
 663             break;
 664         case FA_COPYIN:
 665         case FA_CREATE:
 666             break;
 667
 668         case FA_SKIPNSTATE:
 669             if (rpmteType(te) == TR_ADDED)
 670                 rpmfsSetState(fs, i, RPMFILE_STATE_NOTINSTALLED);
 671             break;
 672
 673         case FA_SKIPNETSHARED:
 674             if (rpmteType(te) == TR_ADDED)
 675                 rpmfsSetState(fs, i, RPMFILE_STATE_NETSHARED);
 676             break;
 677
 678         case FA_SKIPCOLOR:
 679             if (rpmteType(te) == TR_ADDED)
 680                 rpmfsSetState(fs, i, RPMFILE_STATE_WRONGCOLOR);
 681             break;
 682
 683         case FA_BACKUP:
 684             if (!(fsm->fflags & RPMFILE_GHOST)) /* XXX Don't if %ghost file. */
 685             switch (rpmteType(te)) {
 686             case TR_ADDED:
 687                 fsm->osuffix = SUFFIX_RPMORIG;
 688                 break;
 689             case TR_REMOVED:
 690                 fsm->osuffix = SUFFIX_RPMSAVE;
 691                 break;
 692             }
 693             break;
 694
 695         case FA_ALTNAME:
 696             assert(rpmteType(te) == TR_ADDED);
 697             if (!(fsm->fflags & RPMFILE_GHOST)) /* XXX Don't if %ghost file. */
 698                 fsm->nsuffix = SUFFIX_RPMNEW;
 699             break;
 700
 701         case FA_SAVE:
 702             assert(rpmteType(te) == TR_ADDED);
 703             if (!(fsm->fflags & RPMFILE_GHOST)) /* XXX Don't if %ghost file. */
 704                 fsm->osuffix = SUFFIX_RPMSAVE;
 705             break;
 706         case FA_ERASE:
 707 #if 0   /* XXX is this a genhdlist fix? */
 708             assert(rpmteType(>te) == TR_REMOVED);
 709 #endif
 710             /*
 711              * XXX TODO: %ghost probably shouldn't be removed, but that changes
 712              * legacy rpm behavior.
 713              */
 714             break;
 715         default:
 716             break;
 717         }
 718
 719         if ((fsm->mapFlags & CPIO_MAP_PATH) || fsm->nsuffix) {
 720             const struct stat * st = &fsm->sb;
 721             fsm->path = _constfree(fsm->path);
 722             fsm->path = fsmFsPath(fsm, st, fsm->subdir,
 723                 (fsm->suffix ? fsm->suffix : fsm->nsuffix));
 724         }
 725     }
 726     return rc;
 727 }
 728
 729 /**
 730  * Map file stat(2) info.
 731  * @param fsm           file state machine
 732  */
 733 static int fsmMapAttrs(FSM_t fsm)
 734 {
 735     struct stat * st = &fsm->sb;
 736     rpmfi fi = fsmGetFi(fsm);
 737     int i = fsm->ix;
 738
 739     /* this check is pretty moot,  rpmfi accessors check array bounds etc */
 740     if (fi && i >= 0 && i < rpmfiFC(fi)) {
 741         mode_t finalMode = rpmfiFModeIndex(fi, i);
 742         dev_t finalRdev = rpmfiFRdevIndex(fi, i);
 743         time_t finalMtime = rpmfiFMtimeIndex(fi, i);
 744         const char *user = rpmfiFUserIndex(fi, i);
 745         const char *group = rpmfiFGroupIndex(fi, i);
 746         uid_t uid = 0;
 747         gid_t gid = 0;
 748
 749         if (user && unameToUid(user, &uid)) {
 750             if (fsm->goal == FSM_PKGINSTALL)
 751                 rpmlog(RPMLOG_WARNING,
 752                     _("user %s does not exist - using root\n"), user);
 753             finalMode &= ~S_ISUID;      /* turn off suid bit */
 754         }
 755
 756         if (group && gnameToGid(group, &gid)) {
 757             if (fsm->goal == FSM_PKGINSTALL)
 758                 rpmlog(RPMLOG_WARNING,
 759                     _("group %s does not exist - using root\n"), group);
 760             finalMode &= ~S_ISGID;      /* turn off sgid bit */
 761         }
 762
 763         if (fsm->mapFlags & CPIO_MAP_MODE)
 764             st->st_mode = (st->st_mode & S_IFMT) | (finalMode & ~S_IFMT);
 765         if (fsm->mapFlags & CPIO_MAP_TYPE) {
 766             st->st_mode = (st->st_mode & ~S_IFMT) | (finalMode & S_IFMT);
 767             if ((S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
 768             && st->st_nlink == 0)
 769                 st->st_nlink = 1;
 770             st->st_rdev = finalRdev;
 771             st->st_mtime = finalMtime;
 772         }
 773         if (fsm->mapFlags & CPIO_MAP_UID)
 774             st->st_uid = uid;
 775         if (fsm->mapFlags & CPIO_MAP_GID)
 776             st->st_gid = gid;
 777
 778         {   rpmts ts = fsmGetTs(fsm);
 779
 780             /*
 781              * Set file digest (if not disabled).
 782              */
 783             if (ts != NULL && !(rpmtsFlags(ts) & RPMTRANS_FLAG_NOFILEDIGEST)) {
 784                 fsm->digest = rpmfiFDigestIndex(fi, i, NULL, NULL);
 785             } else {
 786                 fsm->digest = NULL;
 787             }
 788         }
 789     }
 790     return 0;
 791 }
 792
 793 /** \ingroup payload
 794  * Create file from payload stream.
 795  * @param fsm           file state machine data
 796  * @return              0 on success
 797  */
 798 static int expandRegular(FSM_t fsm)
 799 {
 800     const struct stat * st = &fsm->sb;
 801     rpm_loff_t left = st->st_size;
 802     int rc = 0;
 803
 804     rc = fsmNext(fsm, FSM_WOPEN);
 805     if (rc)
 806         goto exit;
 807
 808     if (st->st_size > 0 && fsm->digest != NULL)
 809         fdInitDigest(fsm->wfd, fsm->digestalgo, 0);
 810
 811     while (left) {
 812
 813         fsm->wrlen = (left > fsm->wrsize ? fsm->wrsize : left);
 814         rc = fsmNext(fsm, FSM_DREAD);
 815         if (rc)
 816             goto exit;
 817
 818         rc = fsmNext(fsm, FSM_WRITE);
 819         if (rc)
 820             goto exit;
 821
 822         left -= fsm->wrnb;
 823
 824         /* don't call this with fileSize == fileComplete */
 825         if (!rc && left)
 826             (void) fsmNext(fsm, FSM_NOTIFY);
 827     }
 828
 829     if (st->st_size > 0 && fsm->digest) {
 830         void * digest = NULL;
 831         int asAscii = (fsm->digest == NULL ? 1 : 0);
 832
 833         (void) Fflush(fsm->wfd);
 834         fdFiniDigest(fsm->wfd, fsm->digestalgo, &digest, NULL, asAscii);
 835
 836         if (digest == NULL) {
 837             rc = CPIOERR_DIGEST_MISMATCH;
 838             goto exit;
 839         }
 840
 841         if (fsm->digest != NULL) {
 842             size_t diglen = rpmDigestLength(fsm->digestalgo);
 843             if (memcmp(digest, fsm->digest, diglen))
 844                 rc = CPIOERR_DIGEST_MISMATCH;
 845         } else {
 846             rc = CPIOERR_DIGEST_MISMATCH;
 847         }
 848         digest = _free(digest);
 849     }
 850
 851 exit:
 852     (void) fsmNext(fsm, FSM_WCLOSE);
 853     return rc;
 854 }
 855
 856 /** \ingroup payload
 857  * Write next item to payload stream.
 858  * @param fsm           file state machine data
 859  * @param writeData     should data be written?
 860  * @return              0 on success
 861  */
 862 static int writeFile(FSM_t fsm, int writeData)
 863 {
 864     const char * path = fsm->path;
 865     const char * opath = fsm->opath;
 866     struct stat * st = &fsm->sb;
 867     struct stat * ost = &fsm->osb;
 868     char * symbuf = NULL;
 869     rpm_loff_t left;
 870     int rc;
 871
 872     st->st_size = (writeData ? ost->st_size : 0);
 873
 874     if (S_ISDIR(st->st_mode)) {
 875         st->st_size = 0;
 876     } else if (S_ISLNK(st->st_mode)) {
 877         /*
 878          * While linux puts the size of a symlink in the st_size field,
 879          * I don't think that's a specified standard.
 880          */
 881         /* XXX NUL terminated result in fsm->rdbuf, len in fsm->rdnb. */
 882         rc = fsmUNSAFE(fsm, FSM_READLINK);
 883         if (rc) goto exit;
 884         st->st_size = fsm->rdnb;
 885         rstrcat(&symbuf, fsm->rdbuf);   /* XXX save readlink return. */
 886     }
 887
 888     if (fsm->mapFlags & CPIO_MAP_ABSOLUTE) {
 889         char *p = NULL;
 890         if (fsm->mapFlags & CPIO_MAP_ADDDOT)
 891                 rstrcat(&p, ".");
 892         rstrscat(&p, fsm->dirName, fsm->baseName, NULL);
 893         fsm->path = p;
 894     } else if (fsm->mapFlags & CPIO_MAP_PATH) {
 895         rpmfi fi = fsmGetFi(fsm);
 896         fsm->path = xstrdup((fi->apath ? fi->apath[fsm->ix] + fi->striplen :
 897                                          rpmfiBNIndex(fi, fsm->ix)));
 898     }
 899
 900     rc = fsmNext(fsm, FSM_HWRITE);
 901     _constfree(fsm->path);
 902     fsm->path = path;
 903     if (rc) goto exit;
 904
 905     if (writeData && S_ISREG(st->st_mode)) {
 906 #ifdef HAVE_MMAP
 907         char * rdbuf = NULL;
 908         void * mapped = (void *)-1;
 909         size_t nmapped;
 910 #endif
 911
 912         rc = fsmNext(fsm, FSM_ROPEN);
 913         if (rc) goto exit;
 914
 915         /* XXX unbuffered mmap generates *lots* of fdio debugging */
 916 #ifdef HAVE_MMAP
 917         nmapped = 0;
 918         mapped = mmap(NULL, st->st_size, PROT_READ, MAP_SHARED, Fileno(fsm->rfd), 0);
 919         if (mapped != (void *)-1) {
 920             rdbuf = fsm->rdbuf;
 921             fsm->rdbuf = (char *) mapped;
 922             fsm->rdlen = nmapped = st->st_size;
 923 #if defined(MADV_DONTNEED)
 924             xx = madvise(mapped, nmapped, MADV_DONTNEED);
 925 #endif
 926         }
 927 #endif
 928
 929         left = st->st_size;
 930
 931         while (left) {
 932 #ifdef HAVE_MMAP
 933           if (mapped != (void *)-1) {
 934             fsm->rdnb = nmapped;
 935           } else
 936 #endif
 937           {
 938             fsm->rdlen = (left > fsm->rdsize ? fsm->rdsize : left),
 939             rc = fsmNext(fsm, FSM_READ);
 940             if (rc) goto exit;
 941           }
 942
 943             /* XXX DWRITE uses rdnb for I/O length. */
 944             rc = fsmNext(fsm, FSM_DWRITE);
 945             if (rc) goto exit;
 946
 947             left -= fsm->wrnb;
 948         }
 949
 950 #ifdef HAVE_MMAP
 951         if (mapped != (void *)-1) {
 952             xx = msync(mapped, nmapped, MS_ASYNC);
 953 #if defined(MADV_DONTNEED)
 954             xx = madvise(mapped, nmapped, MADV_DONTNEED);
 955 #endif
 956             xx = munmap(mapped, nmapped);
 957             fsm->rdbuf = rdbuf;
 958         }
 959 #endif
 960
 961     } else if (writeData && S_ISLNK(st->st_mode)) {
 962         /* XXX DWRITE uses rdnb for I/O length. */
 963         strcpy(fsm->rdbuf, symbuf);     /* XXX restore readlink buffer. */
 964         fsm->rdnb = strlen(symbuf);
 965         rc = fsmNext(fsm, FSM_DWRITE);
 966         if (rc) goto exit;
 967     }
 968
 969     rc = fsmNext(fsm, FSM_PAD);
 970     if (rc) goto exit;
 971
 972     rc = 0;
 973
 974 exit:
 975     if (fsm->rfd != NULL)
 976         (void) fsmNext(fsm, FSM_RCLOSE);
 977     fsm->opath = opath;
 978     fsm->path = path;
 979     free(symbuf);
 980     return rc;
 981 }
 982
 983 /** \ingroup payload
 984  * Write set of linked files to payload stream.
 985  * @param fsm           file state machine data
 986  * @return              0 on success
 987  */
 988 static int writeLinkedFile(FSM_t fsm)
 989 {
 990     const char * path = fsm->path;
 991     const char * nsuffix = fsm->nsuffix;
 992     int iterIndex = fsm->ix;
 993     int ec = 0;
 994     int rc;
 995     int i;
 996
 997     fsm->path = NULL;
 998     fsm->nsuffix = NULL;
 999     fsm->ix = -1;
1000
1001     for (i = fsm->li->nlink - 1; i >= 0; i--) {
1002
1003         if (fsm->li->filex[i] < 0) continue;
1004
1005         fsm->ix = fsm->li->filex[i];
1006         rc = fsmNext(fsm, FSM_MAP);
1007
1008         /* Write data after last link. */
1009         rc = writeFile(fsm, (i == 0));
1010         if (fsm->failedFile && rc != 0 && *fsm->failedFile == NULL) {
1011             ec = rc;
1012             *fsm->failedFile = xstrdup(fsm->path);
1013         }
1014
1015         fsm->path = _constfree(fsm->path);
1016         fsm->li->filex[i] = -1;
1017     }
1018
1019     fsm->ix = iterIndex;
1020     fsm->nsuffix = nsuffix;
1021     fsm->path = path;
1022     return ec;
1023 }
1024
1025 /** \ingroup payload
1026  * Create pending hard links to existing file.
1027  * @param fsm           file state machine data
1028  * @return              0 on success
1029  */
1030 static int fsmMakeLinks(FSM_t fsm)
1031 {
1032     const char * path = fsm->path;
1033     const char * opath = fsm->opath;
1034     const char * nsuffix = fsm->nsuffix;
1035     int iterIndex = fsm->ix;
1036     int ec = 0;
1037     int rc;
1038     int i;
1039
1040     fsm->path = NULL;
1041     fsm->opath = NULL;
1042     fsm->nsuffix = NULL;
1043     fsm->ix = -1;
1044
1045     fsm->ix = fsm->li->filex[fsm->li->createdPath];
1046     rc = fsmNext(fsm, FSM_MAP);
1047     fsm->opath = fsm->path;
1048     fsm->path = NULL;
1049     for (i = 0; i < fsm->li->nlink; i++) {
1050         if (fsm->li->filex[i] < 0) continue;
1051         if (fsm->li->createdPath == i) continue;
1052
1053         fsm->ix = fsm->li->filex[i];
1054         fsm->path = _constfree(fsm->path);
1055         rc = fsmNext(fsm, FSM_MAP);
1056         if (XFA_SKIPPING(fsm->action)) continue;
1057
1058         rc = fsmUNSAFE(fsm, FSM_VERIFY);
1059         if (!rc) continue;
1060         if (!(rc == CPIOERR_ENOENT)) break;
1061
1062         /* XXX link(fsm->opath, fsm->path) */
1063         rc = fsmNext(fsm, FSM_LINK);
1064         if (fsm->failedFile && rc != 0 && *fsm->failedFile == NULL) {
1065             ec = rc;
1066             *fsm->failedFile = xstrdup(fsm->path);
1067         }
1068
1069         fsm->li->linksLeft--;
1070     }
1071     fsm->path = _constfree(fsm->path);
1072     fsm->opath = _constfree(fsm->opath);
1073
1074     fsm->ix = iterIndex;
1075     fsm->nsuffix = nsuffix;
1076     fsm->path = path;
1077     fsm->opath = opath;
1078     return ec;
1079 }
1080
1081 /** \ingroup payload
1082  * Commit hard linked file set atomically.
1083  * @param fsm           file state machine data
1084  * @return              0 on success
1085  */
1086 static int fsmCommitLinks(FSM_t fsm)
1087 {
1088     const char * path = fsm->path;
1089     const char * nsuffix = fsm->nsuffix;
1090     int iterIndex = fsm->ix;
1091     struct stat * st = &fsm->sb;
1092     int rc = 0;
1093     nlink_t i;
1094
1095     fsm->path = NULL;
1096     fsm->nsuffix = NULL;
1097     fsm->ix = -1;
1098
1099     for (fsm->li = fsm->links; fsm->li; fsm->li = fsm->li->next) {
1100         if (fsm->li->sb.st_ino == st->st_ino && fsm->li->sb.st_dev == st->st_dev)
1101             break;
1102     }
1103
1104     for (i = 0; i < fsm->li->nlink; i++) {
1105         if (fsm->li->filex[i] < 0) continue;
1106         fsm->ix = fsm->li->filex[i];
1107         rc = fsmNext(fsm, FSM_MAP);
1108         if (!XFA_SKIPPING(fsm->action))
1109             rc = fsmNext(fsm, FSM_COMMIT);
1110         fsm->path = _constfree(fsm->path);
1111         fsm->li->filex[i] = -1;
1112     }
1113
1114     fsm->ix = iterIndex;
1115     fsm->nsuffix = nsuffix;
1116     fsm->path = path;
1117     return rc;
1118 }
1119
1120 /**
1121  * Remove (if created) directories not explicitly included in package.
1122  * @param fsm           file state machine data
1123  * @return              0 on success
1124  */
1125 static int fsmRmdirs(FSM_t fsm)
1126 {
1127     const char * path = fsm->path;
1128     void * dnli = dnlInitIterator(fsm, 1);
1129     char * dn = fsm->rdbuf;
1130     int dc = dnlCount(dnli);
1131     int rc = 0;
1132
1133     fsm->path = NULL;
1134     dn[0] = '\0';
1135     if (fsm->ldn != NULL && fsm->dnlx != NULL)
1136     while ((fsm->path = dnlNextIterator(dnli)) != NULL) {
1137         size_t dnlen = strlen(fsm->path);
1138         char * te;
1139
1140         dc = dnlIndex(dnli);
1141         if (fsm->dnlx[dc] < 1 || fsm->dnlx[dc] >= dnlen)
1142             continue;
1143
1144         /* Copy to avoid const on fsm->path. */
1145         te = stpcpy(dn, fsm->path) - 1;
1146         fsm->path = dn;
1147
1148         /* Remove generated directories. */
1149         do {
1150             if (*te == '/') {
1151                 *te = '\0';
1152                 rc = fsmNext(fsm, FSM_RMDIR);
1153                 *te = '/';
1154             }
1155             if (rc)
1156                 break;
1157             te--;
1158         } while ((te - fsm->path) > fsm->dnlx[dc]);
1159     }
1160     dnli = dnlFreeIterator(dnli);
1161
1162     fsm->path = path;
1163     return rc;
1164 }
1165
1166 /**
1167  * Create (if necessary) directories not explicitly included in package.
1168  * @param fsm           file state machine data
1169  * @return              0 on success
1170  */
1171 static int fsmMkdirs(FSM_t fsm)
1172 {
1173     struct stat * st = &fsm->sb;
1174     struct stat * ost = &fsm->osb;
1175     const char * path = fsm->path;
1176     mode_t st_mode = st->st_mode;
1177     void * dnli = dnlInitIterator(fsm, 0);
1178     char * dn = fsm->rdbuf;
1179     int dc = dnlCount(dnli);
1180     int rc = 0;
1181     int i;
1182     rpmts ts = fsmGetTs(fsm);
1183     security_context_t scon = NULL;
1184
1185     fsm->path = NULL;
1186
1187     dn[0] = '\0';
1188     fsm->dnlx = (dc ? xcalloc(dc, sizeof(*fsm->dnlx)) : NULL);
1189     if (fsm->dnlx != NULL)
1190     while ((fsm->path = dnlNextIterator(dnli)) != NULL) {
1191         size_t dnlen = strlen(fsm->path);
1192         char * te;
1193
1194         dc = dnlIndex(dnli);
1195         if (dc < 0) continue;
1196         fsm->dnlx[dc] = dnlen;
1197         if (dnlen <= 1)
1198             continue;
1199
1200         if (dnlen <= fsm->ldnlen && rstreq(fsm->path, fsm->ldn))
1201             continue;
1202
1203         /* Copy to avoid const on fsm->path. */
1204         (void) stpcpy(dn, fsm->path);
1205         fsm->path = dn;
1206
1207         /* Assume '/' directory exists, "mkdir -p" for others if non-existent */
1208         for (i = 1, te = dn + 1; *te != '\0'; te++, i++) {
1209             if (*te != '/')
1210                 continue;
1211
1212             *te = '\0';
1213
1214             /* Already validated? */
1215             if (i < fsm->ldnlen &&
1216                 (fsm->ldn[i] == '/' || fsm->ldn[i] == '\0') &&
1217                 rstreqn(fsm->path, fsm->ldn, i))
1218             {
1219                 *te = '/';
1220                 /* Move pre-existing path marker forward. */
1221                 fsm->dnlx[dc] = (te - dn);
1222                 continue;
1223             }
1224
1225             /* Validate next component of path. */
1226             rc = fsmUNSAFE(fsm, FSM_LSTAT);
1227             *te = '/';
1228
1229             /* Directory already exists? */
1230             if (rc == 0 && S_ISDIR(ost->st_mode)) {
1231                 /* Move pre-existing path marker forward. */
1232                 fsm->dnlx[dc] = (te - dn);
1233             } else if (rc == CPIOERR_ENOENT) {
1234                 *te = '\0';
1235                 st->st_mode = S_IFDIR | (_dirPerms & 07777);
1236                 rc = fsmNext(fsm, FSM_MKDIR);
1237                 if (!rc) {
1238                     /* XXX FIXME? only new dir will have context set. */
1239                     /* Get file security context from patterns. */
1240                     if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONTEXTS)) {
1241                         if (matchpathcon(fsm->path, st->st_mode, &scon) == 0 &&
1242                             scon != NULL) {
1243                             fsm->fcontext = scon;
1244                             rc = fsmNext(fsm, FSM_LSETFCON);
1245                         }
1246                     }
1247
1248                     if (fsm->fcontext == NULL)
1249                         rpmlog(RPMLOG_DEBUG,
1250                             "%s directory created with perms %04o, no context.\n",
1251                             fsm->path, (unsigned)(st->st_mode & 07777));
1252                     else {
1253                         rpmlog(RPMLOG_DEBUG,
1254                             "%s directory created with perms %04o, context %s.\n",
1255                             fsm->path, (unsigned)(st->st_mode & 07777),
1256                             fsm->fcontext);
1257                         freecon(fsm->fcontext);
1258                     }
1259                     fsm->fcontext = NULL;
1260                 }
1261                 *te = '/';
1262             }
1263             if (rc)
1264                 break;
1265         }
1266         if (rc) break;
1267
1268         /* Save last validated path. */
1269 /* FIX: ldn/path annotations ? */
1270         if (fsm->ldnalloc < (dnlen + 1)) {
1271             fsm->ldnalloc = dnlen + 100;
1272             fsm->ldn = xrealloc(fsm->ldn, fsm->ldnalloc);
1273         }
1274         if (fsm->ldn != NULL) { /* XXX can't happen */
1275             strcpy(fsm->ldn, fsm->path);
1276             fsm->ldnlen = dnlen;
1277         }
1278     }
1279     dnli = dnlFreeIterator(dnli);
1280
1281     fsm->path = path;
1282     st->st_mode = st_mode;              /* XXX restore st->st_mode */
1283 /* FIX: ldn/path annotations ? */
1284     return rc;
1285 }
1286
1287 #ifdef  NOTYET
1288 /**
1289  * Check for file on disk.
1290  * @param fsm           file state machine data
1291  * @return              0 on success
1292  */
1293 static int fsmStat(FSM_t fsm)
1294 {
1295     int rc = 0;
1296
1297     if (fsm->path != NULL) {
1298         int saveernno = errno;
1299         rc = fsmUNSAFE(fsm, (!(fsm->mapFlags & CPIO_FOLLOW_SYMLINKS)
1300                         ? FSM_LSTAT : FSM_STAT));
1301         if (rc == CPIOERR_ENOENT) {
1302             errno = saveerrno;
1303             rc = 0;
1304             fsm->exists = 0;
1305         } else if (rc == 0) {
1306             fsm->exists = 1;
1307         }
1308     } else {
1309         /* Skip %ghost files on build. */
1310         fsm->exists = 0;
1311     }
1312     return rc;
1313 }
1314 #endif
1315
1316 static const char * rpmteTypeString(rpmte te)
1317 {
1318     switch(rpmteType(te)) {
1319     case TR_ADDED:      return " install";
1320     case TR_REMOVED:    return "   erase";
1321     default:            return "???";
1322     }
1323 }
1324
1325 #define IS_DEV_LOG(_x)  \
1326         ((_x) != NULL && strlen(_x) >= (sizeof("/dev/log")-1) && \
1327         rstreqn((_x), "/dev/log", sizeof("/dev/log")-1) && \
1328         ((_x)[sizeof("/dev/log")-1] == '\0' || \
1329          (_x)[sizeof("/dev/log")-1] == ';'))
1330
1331 /**
1332  * File state machine driver.
1333  * @param fsm           file state machine
1334  * @param stage         next stage
1335  * @return              0 on success
1336  */
1337 static int fsmStage(FSM_t fsm, fileStage stage)
1338 {
1339 #ifdef  UNUSED
1340     fileStage prevStage = fsm->stage;
1341     const char * const prev = fileStageString(prevStage);
1342 #endif
1343     static int modulo = 4;
1344     const char * const cur = fileStageString(stage);
1345     struct stat * st = &fsm->sb;
1346     struct stat * ost = &fsm->osb;
1347     int saveerrno = errno;
1348     int rc = fsm->rc;
1349     rpm_loff_t left;
1350
1351 #define _fafilter(_a)   \
1352     (!((_a) == FA_CREATE || (_a) == FA_ERASE || (_a) == FA_COPYIN || (_a) == FA_COPYOUT) \
1353         ? fileActionString(_a) : "")
1354
1355     if (stage & FSM_DEAD) {
1356         /* do nothing */
1357     } else if (stage & FSM_INTERNAL) {
1358         if (_fsm_debug && !(stage & FSM_SYSCALL))
1359             rpmlog(RPMLOG_DEBUG, " %8s %06o%3d (%4d,%4d)%10d %s %s\n",
1360                 cur,
1361                 (unsigned)st->st_mode, (int)st->st_nlink,
1362                 (int)st->st_uid, (int)st->st_gid, (int)st->st_size,
1363                 (fsm->path ? fsm->path : ""),
1364                 _fafilter(fsm->action));
1365     } else {
1366         fsm->stage = stage;
1367         if (_fsm_debug || !(stage & FSM_VERBOSE))
1368             rpmlog(RPMLOG_DEBUG, "%-8s  %06o%3d (%4d,%4d)%10d %s %s\n",
1369                 cur,
1370                 (unsigned)st->st_mode, (int)st->st_nlink,
1371                 (int)st->st_uid, (int)st->st_gid, (int)st->st_size,
1372                 (fsm->path ? fsm->path : ""),
1373                 _fafilter(fsm->action));
1374     }
1375 #undef  _fafilter
1376
1377     switch (stage) {
1378     case FSM_UNKNOWN:
1379         break;
1380     case FSM_PKGINSTALL:
1381         while (1) {
1382             /* Clean fsm, free'ing memory. Read next archive header. */
1383             rc = fsmUNSAFE(fsm, FSM_INIT);
1384
1385             /* Exit on end-of-payload. */
1386             if (rc == CPIOERR_HDR_TRAILER) {
1387                 rc = 0;
1388                 break;
1389             }
1390
1391             /* Exit on error. */
1392             if (rc) {
1393                 fsm->postpone = 1;
1394                 (void) fsmNext(fsm, FSM_UNDO);
1395                 break;
1396             }
1397
1398             /* Extract file from archive. */
1399             rc = fsmNext(fsm, FSM_PROCESS);
1400             if (rc) {
1401                 (void) fsmNext(fsm, FSM_UNDO);
1402                 break;
1403             }
1404
1405             /* Notify on success. */
1406             (void) fsmNext(fsm, FSM_NOTIFY);
1407
1408             rc = fsmNext(fsm, FSM_FINI);
1409             if (rc) {
1410                 break;
1411             }
1412         }
1413         break;
1414     case FSM_PKGERASE:
1415     case FSM_PKGCOMMIT:
1416         while (1) {
1417             /* Clean fsm, free'ing memory. */
1418             rc = fsmUNSAFE(fsm, FSM_INIT);
1419
1420             /* Exit on end-of-payload. */
1421             if (rc == CPIOERR_HDR_TRAILER) {
1422                 rc = 0;
1423                 break;
1424             }
1425
1426             /* Rename/erase next item. */
1427             if (fsmNext(fsm, FSM_FINI))
1428                 break;
1429         }
1430         break;
1431     case FSM_PKGBUILD:
1432         while (1) {
1433
1434             rc = fsmUNSAFE(fsm, FSM_INIT);
1435
1436             /* Exit on end-of-payload. */
1437             if (rc == CPIOERR_HDR_TRAILER) {
1438                 rc = 0;
1439                 break;
1440             }
1441
1442             /* Exit on error. */
1443             if (rc) {
1444                 fsm->postpone = 1;
1445                 (void) fsmNext(fsm, FSM_UNDO);
1446                 break;
1447             }
1448
1449             /* Copy file into archive. */
1450             rc = fsmNext(fsm, FSM_PROCESS);
1451             if (rc) {
1452                 (void) fsmNext(fsm, FSM_UNDO);
1453                 break;
1454             }
1455
1456             /* Notify on success. */
1457             (void) fsmNext(fsm, FSM_NOTIFY);
1458
1459             if (fsmNext(fsm, FSM_FINI))
1460                 break;
1461         }
1462
1463         /* Flush partial sets of hard linked files. */
1464         if (!(fsm->mapFlags & CPIO_ALL_HARDLINKS)) {
1465             nlink_t i, nlink;
1466             int j;
1467             while ((fsm->li = fsm->links) != NULL) {
1468                 fsm->links = fsm->li->next;
1469                 fsm->li->next = NULL;
1470
1471                 /* Re-calculate link count for archive header. */
1472                 for (j = -1, nlink = 0, i = 0; i < fsm->li->nlink; i++) {
1473                     if (fsm->li->filex[i] < 0)
1474                         continue;
1475                     nlink++;
1476                     if (j == -1) j = i;
1477                 }
1478                 /* XXX force the contents out as well. */
1479                 if (j != 0) {
1480                     fsm->li->filex[0] = fsm->li->filex[j];
1481                     fsm->li->filex[j] = -1;
1482                 }
1483                 fsm->li->sb.st_nlink = nlink;
1484
1485                 fsm->sb = fsm->li->sb;  /* structure assignment */
1486                 fsm->osb = fsm->sb;     /* structure assignment */
1487
1488                 if (!rc) rc = writeLinkedFile(fsm);
1489
1490                 fsm->li = freeHardLink(fsm->li);
1491             }
1492         }
1493
1494         if (!rc)
1495             rc = fsmNext(fsm, FSM_TRAILER);
1496
1497         break;
1498     case FSM_CREATE:
1499         {   rpmts ts = fsmGetTs(fsm);
1500 #define _tsmask (RPMTRANS_FLAG_PKGCOMMIT | RPMTRANS_FLAG_COMMIT)
1501             fsm->commit = ((ts && (rpmtsFlags(ts) & _tsmask) &&
1502                         fsm->goal != FSM_PKGCOMMIT) ? 0 : 1);
1503 #undef _tsmask
1504         }
1505         fsm->path = _constfree(fsm->path);
1506         fsm->opath = _constfree(fsm->opath);
1507         fsm->dnlx = _free(fsm->dnlx);
1508
1509         fsm->ldn = _free(fsm->ldn);
1510         fsm->ldnalloc = fsm->ldnlen = 0;
1511
1512         fsm->rdsize = fsm->wrsize = 0;
1513         fsm->rdbuf = fsm->rdb = _free(fsm->rdb);
1514         fsm->wrbuf = fsm->wrb = _free(fsm->wrb);
1515         if (fsm->goal == FSM_PKGINSTALL || fsm->goal == FSM_PKGBUILD) {
1516             fsm->rdsize = 8 * BUFSIZ;
1517             fsm->rdbuf = fsm->rdb = xmalloc(fsm->rdsize);
1518             fsm->wrsize = 8 * BUFSIZ;
1519             fsm->wrbuf = fsm->wrb = xmalloc(fsm->wrsize);
1520         }
1521
1522         fsm->mkdirsdone = 0;
1523         fsm->ix = -1;
1524         fsm->links = NULL;
1525         fsm->li = NULL;
1526         errno = 0;      /* XXX get rid of EBADF */
1527
1528         /* Detect and create directories not explicitly in package. */
1529         if (fsm->goal == FSM_PKGINSTALL) {
1530             rc = fsmNext(fsm, FSM_MKDIRS);
1531             if (!rc) fsm->mkdirsdone = 1;
1532         }
1533
1534         break;
1535     case FSM_INIT:
1536         fsm->path = _constfree(fsm->path);
1537         fsm->postpone = 0;
1538         fsm->diskchecked = fsm->exists = 0;
1539         fsm->subdir = NULL;
1540         fsm->suffix = (fsm->sufbuf[0] != '\0' ? fsm->sufbuf : NULL);
1541         fsm->action = FA_UNKNOWN;
1542         fsm->osuffix = NULL;
1543         fsm->nsuffix = NULL;
1544
1545         if (fsm->goal == FSM_PKGINSTALL) {
1546             /* Read next header from payload, checking for end-of-payload. */
1547             rc = fsmUNSAFE(fsm, FSM_NEXT);
1548         }
1549         if (rc) break;
1550
1551         /* Identify mapping index. */
1552         fsm->ix = ((fsm->goal == FSM_PKGINSTALL)
1553                 ? mapFind(fsm->iter, fsm->path) : mapNextIterator(fsm->iter));
1554
1555         /* Detect end-of-loop and/or mapping error. */
1556         if (fsm->ix < 0) {
1557             if (fsm->goal == FSM_PKGINSTALL) {
1558 #if 0
1559                 rpmlog(RPMLOG_WARNING,
1560                     _("archive file %s was not found in header file list\n"),
1561                         fsm->path);
1562 #endif
1563                 if (fsm->failedFile && *fsm->failedFile == NULL)
1564                     *fsm->failedFile = xstrdup(fsm->path);
1565                 rc = CPIOERR_UNMAPPED_FILE;
1566             } else {
1567                 rc = CPIOERR_HDR_TRAILER;
1568             }
1569             break;
1570         }
1571
1572         /* On non-install, mode must be known so that dirs don't get suffix. */
1573         if (fsm->goal != FSM_PKGINSTALL) {
1574             rpmfi fi = fsmGetFi(fsm);
1575             st->st_mode = rpmfiFModeIndex(fi, fsm->ix);
1576         }
1577
1578         /* Generate file path. */
1579         rc = fsmNext(fsm, FSM_MAP);
1580         if (rc) break;
1581
1582         /* Perform lstat/stat for disk file. */
1583 #ifdef  NOTYET
1584         rc = fsmStat(fsm);
1585 #else
1586         if (fsm->path != NULL &&
1587             !(fsm->goal == FSM_PKGINSTALL && S_ISREG(st->st_mode)))
1588         {
1589             rc = fsmUNSAFE(fsm, (!(fsm->mapFlags & CPIO_FOLLOW_SYMLINKS)
1590                         ? FSM_LSTAT : FSM_STAT));
1591             if (rc == CPIOERR_ENOENT) {
1592                 errno = saveerrno;
1593                 rc = 0;
1594                 fsm->exists = 0;
1595             } else if (rc == 0) {
1596                 fsm->exists = 1;
1597             }
1598         } else {
1599             /* Skip %ghost files on build. */
1600             fsm->exists = 0;
1601         }
1602 #endif
1603         fsm->diskchecked = 1;
1604         if (rc) break;
1605
1606         /* On non-install, the disk file stat is what's remapped. */
1607         if (fsm->goal != FSM_PKGINSTALL)
1608             *st = *ost;                 /* structure assignment */
1609
1610         /* Remap file perms, owner, and group. */
1611         rc = fsmMapAttrs(fsm);
1612         if (rc) break;
1613
1614         fsm->postpone = XFA_SKIPPING(fsm->action);
1615         if (fsm->goal == FSM_PKGINSTALL || fsm->goal == FSM_PKGBUILD) {
1616             /* FIX: saveHardLink can modify fsm */
1617             if (S_ISREG(st->st_mode) && st->st_nlink > 1)
1618                 fsm->postpone = saveHardLink(fsm);
1619         }
1620         break;
1621     case FSM_PRE:
1622         break;
1623     case FSM_MAP:
1624         rc = fsmMapPath(fsm);
1625         break;
1626     case FSM_MKDIRS:
1627         rc = fsmMkdirs(fsm);
1628         break;
1629     case FSM_RMDIRS:
1630         if (fsm->dnlx)
1631             rc = fsmRmdirs(fsm);
1632         break;
1633     case FSM_PROCESS:
1634         if (fsm->postpone) {
1635             if (fsm->goal == FSM_PKGINSTALL)
1636                 rc = fsmNext(fsm, FSM_EAT);
1637             break;
1638         }
1639
1640         if (fsm->goal == FSM_PKGBUILD) {
1641             if (fsm->fflags & RPMFILE_GHOST) /* XXX Don't if %ghost file. */
1642                 break;
1643             if (S_ISREG(st->st_mode) && st->st_nlink > 1) {
1644                 hardLink_t li, prev;
1645
1646 if (!(fsm->mapFlags & CPIO_ALL_HARDLINKS)) break;
1647                 rc = writeLinkedFile(fsm);
1648                 if (rc) break;  /* W2DO? */
1649
1650                 for (li = fsm->links, prev = NULL; li; prev = li, li = li->next)
1651                      if (li == fsm->li)
1652                         break;
1653
1654                 if (prev == NULL)
1655                     fsm->links = fsm->li->next;
1656                 else
1657                     prev->next = fsm->li->next;
1658                 fsm->li->next = NULL;
1659                 fsm->li = freeHardLink(fsm->li);
1660             } else {
1661                 rc = writeFile(fsm, 1);
1662             }
1663             break;
1664         }
1665
1666         if (fsm->goal != FSM_PKGINSTALL)
1667             break;
1668
1669         if (S_ISREG(st->st_mode)) {
1670             const char * path = fsm->path;
1671             if (fsm->osuffix)
1672                 fsm->path = fsmFsPath(fsm, st, NULL, NULL);
1673             rc = fsmUNSAFE(fsm, FSM_VERIFY);
1674
1675             if (rc == 0 && fsm->osuffix) {
1676                 const char * opath = fsm->opath;
1677                 fsm->opath = fsm->path;
1678                 fsm->path = fsmFsPath(fsm, st, NULL, fsm->osuffix);
1679                 rc = fsmNext(fsm, FSM_RENAME);
1680                 if (!rc)
1681                     rpmlog(RPMLOG_WARNING,
1682                         _("%s saved as %s\n"),
1683                                 (fsm->opath ? fsm->opath : ""),
1684                                 (fsm->path ? fsm->path : ""));
1685                 fsm->path = _constfree(fsm->path);
1686                 fsm->opath = opath;
1687             }
1688
1689             fsm->path = path;
1690             if (!(rc == CPIOERR_ENOENT)) return rc;
1691             rc = expandRegular(fsm);
1692         } else if (S_ISDIR(st->st_mode)) {
1693             mode_t st_mode = st->st_mode;
1694             rc = fsmUNSAFE(fsm, FSM_VERIFY);
1695             if (rc == CPIOERR_ENOENT) {
1696                 st->st_mode &= ~07777;          /* XXX abuse st->st_mode */
1697                 st->st_mode |=  00700;
1698                 rc = fsmNext(fsm, FSM_MKDIR);
1699                 st->st_mode = st_mode;          /* XXX restore st->st_mode */
1700             }
1701         } else if (S_ISLNK(st->st_mode)) {
1702             const char * opath = fsm->opath;
1703
1704             if ((st->st_size + 1) > fsm->rdsize) {
1705                 rc = CPIOERR_HDR_SIZE;
1706                 break;
1707             }
1708
1709             fsm->wrlen = st->st_size;
1710             rc = fsmNext(fsm, FSM_DREAD);
1711             if (!rc && fsm->rdnb != fsm->wrlen)
1712                 rc = CPIOERR_READ_FAILED;
1713             if (rc) break;
1714
1715             fsm->wrbuf[st->st_size] = '\0';
1716             /* XXX symlink(fsm->opath, fsm->path) */
1717             fsm->opath = fsm->wrbuf;
1718             rc = fsmUNSAFE(fsm, FSM_VERIFY);
1719             if (rc == CPIOERR_ENOENT)
1720                 rc = fsmNext(fsm, FSM_SYMLINK);
1721             fsm->opath = opath;         /* XXX restore fsm->path */
1722         } else if (S_ISFIFO(st->st_mode)) {
1723             mode_t st_mode = st->st_mode;
1724             /* This mimics cpio S_ISSOCK() behavior but probably isnt' right */
1725             rc = fsmUNSAFE(fsm, FSM_VERIFY);
1726             if (rc == CPIOERR_ENOENT) {
1727                 st->st_mode = 0000;             /* XXX abuse st->st_mode */
1728                 rc = fsmNext(fsm, FSM_MKFIFO);
1729                 st->st_mode = st_mode;  /* XXX restore st->st_mode */
1730             }
1731         } else if (S_ISCHR(st->st_mode) ||
1732                    S_ISBLK(st->st_mode) ||
1733     S_ISSOCK(st->st_mode))
1734         {
1735             rc = fsmUNSAFE(fsm, FSM_VERIFY);
1736             if (rc == CPIOERR_ENOENT)
1737                 rc = fsmNext(fsm, FSM_MKNOD);
1738         } else {
1739             /* XXX Special case /dev/log, which shouldn't be packaged anyways */
1740             if (!IS_DEV_LOG(fsm->path))
1741                 rc = CPIOERR_UNKNOWN_FILETYPE;
1742         }
1743         if (S_ISREG(st->st_mode) && st->st_nlink > 1) {
1744             fsm->li->createdPath = fsm->li->linkIndex;
1745             rc = fsmMakeLinks(fsm);
1746         }
1747         break;
1748     case FSM_POST:
1749         break;
1750     case FSM_MKLINKS:
1751         rc = fsmMakeLinks(fsm);
1752         break;
1753     case FSM_NOTIFY:            /* XXX move from fsm to psm -> tsm */
1754         if (fsm->goal == FSM_PKGINSTALL || fsm->goal == FSM_PKGBUILD) {
1755             rpmts ts = fsmGetTs(fsm);
1756             rpmte te = fsmGetTe(fsm);
1757             rpmfi fi = fsmGetFi(fsm);
1758             void * ptr;
1759             rpm_loff_t archivePos = fdGetCpioPos(fsm->cfd);
1760             if (archivePos > fsm->archivePos) {
1761                 fsm->archivePos = archivePos;
1762                 ptr = rpmtsNotify(ts, te, RPMCALLBACK_INST_PROGRESS,
1763                         fsm->archivePos, fi->archiveSize);
1764             }
1765         }
1766         break;
1767     case FSM_UNDO:
1768         if (fsm->postpone)
1769             break;
1770         if (fsm->goal == FSM_PKGINSTALL) {
1771             /* XXX only erase if temp fn w suffix is in use */
1772             if (fsm->sufbuf[0] != '\0')
1773                 (void) fsmNext(fsm,
1774                     (S_ISDIR(st->st_mode) ? FSM_RMDIR : FSM_UNLINK));
1775
1776 #ifdef  NOTYET  /* XXX remove only dirs just created, not all. */
1777             if (fsm->dnlx)
1778                 (void) fsmNext(fsm, FSM_RMDIRS);
1779 #endif
1780             errno = saveerrno;
1781         }
1782         if (fsm->failedFile && *fsm->failedFile == NULL)
1783             *fsm->failedFile = xstrdup(fsm->path);
1784         break;
1785     case FSM_FINI:
1786         if (!fsm->postpone && fsm->commit) {
1787             if (fsm->goal == FSM_PKGINSTALL)
1788                 rc = ((S_ISREG(st->st_mode) && st->st_nlink > 1)
1789                         ? fsmCommitLinks(fsm) : fsmNext(fsm, FSM_COMMIT));
1790             if (fsm->goal == FSM_PKGCOMMIT)
1791                 rc = fsmNext(fsm, FSM_COMMIT);
1792             if (fsm->goal == FSM_PKGERASE)
1793                 rc = fsmNext(fsm, FSM_COMMIT);
1794         }
1795         fsm->path = _constfree(fsm->path);
1796         fsm->opath = _constfree(fsm->opath);
1797         memset(st, 0, sizeof(*st));
1798         memset(ost, 0, sizeof(*ost));
1799         break;
1800     case FSM_COMMIT:
1801         /* Rename pre-existing modified or unmanaged file. */
1802         if (fsm->osuffix && fsm->diskchecked &&
1803           (fsm->exists || (fsm->goal == FSM_PKGINSTALL && S_ISREG(st->st_mode))))
1804         {
1805             const char * opath = fsm->opath;
1806             const char * path = fsm->path;
1807             fsm->opath = fsmFsPath(fsm, st, NULL, NULL);
1808             fsm->path = fsmFsPath(fsm, st, NULL, fsm->osuffix);
1809             rc = fsmNext(fsm, FSM_RENAME);
1810             if (!rc) {
1811                 rpmlog(RPMLOG_WARNING, _("%s saved as %s\n"),
1812                                 (fsm->opath ? fsm->opath : ""),
1813                                 (fsm->path ? fsm->path : ""));
1814             }
1815             fsm->path = _constfree(fsm->path);
1816             fsm->path = path;
1817             fsm->opath = _constfree(fsm->opath);
1818             fsm->opath = opath;
1819         }
1820
1821         /* Remove erased files. */
1822         if (fsm->goal == FSM_PKGERASE) {
1823             if (fsm->action == FA_ERASE) {
1824                 rpmte te = fsmGetTe(fsm);
1825                 if (S_ISDIR(st->st_mode)) {
1826                     rc = fsmNext(fsm, FSM_RMDIR);
1827                     if (!rc) break;
1828                     switch (rc) {
1829                     case CPIOERR_ENOENT: /* XXX rmdir("/") linux 2.2.x kernel hack */
1830                     case CPIOERR_ENOTEMPTY:
1831         /* XXX make sure that build side permits %missingok on directories. */
1832                         if (fsm->fflags & RPMFILE_MISSINGOK)
1833                             break;
1834
1835                         /* XXX common error message. */
1836                         rpmlog(
1837                             (strict_erasures ? RPMLOG_ERR : RPMLOG_DEBUG),
1838                             _("%s rmdir of %s failed: Directory not empty\n"),
1839                                 rpmteTypeString(te), fsm->path);
1840                         break;
1841                     default:
1842                         rpmlog(
1843                             (strict_erasures ? RPMLOG_ERR : RPMLOG_DEBUG),
1844                                 _("%s rmdir of %s failed: %s\n"),
1845                                 rpmteTypeString(te), fsm->path, strerror(errno));
1846                         break;
1847                     }
1848                 } else {
1849                     rc = fsmNext(fsm, FSM_UNLINK);
1850                     if (!rc) break;
1851                     switch (rc) {
1852                     case CPIOERR_ENOENT:
1853                         if (fsm->fflags & RPMFILE_MISSINGOK)
1854                             break;
1855                     default:
1856                         rpmlog(
1857                             (strict_erasures ? RPMLOG_ERR : RPMLOG_DEBUG),
1858                                 _("%s unlink of %s failed: %s\n"),
1859                                 rpmteTypeString(te), fsm->path, strerror(errno));
1860                         break;
1861                     }
1862                 }
1863             }
1864             /* XXX Failure to remove is not (yet) cause for failure. */
1865             if (!strict_erasures) rc = 0;
1866             break;
1867         }
1868
1869         /* XXX Special case /dev/log, which shouldn't be packaged anyways */
1870         if (!S_ISSOCK(st->st_mode) && !IS_DEV_LOG(fsm->path)) {
1871             /* Rename temporary to final file name. */
1872             if (!S_ISDIR(st->st_mode) &&
1873                 (fsm->subdir || fsm->suffix || fsm->nsuffix))
1874             {
1875                 fsm->opath = fsm->path;
1876                 fsm->path = fsmFsPath(fsm, st, NULL, fsm->nsuffix);
1877                 rc = fsmNext(fsm, FSM_RENAME);
1878                 if (!rc && fsm->nsuffix) {
1879                     char * opath = fsmFsPath(fsm, st, NULL, NULL);
1880                     rpmlog(RPMLOG_WARNING, _("%s created as %s\n"),
1881                                 (opath ? opath : ""),
1882                                 (fsm->path ? fsm->path : ""));
1883                     opath = _free(opath);
1884                 }
1885                 fsm->opath = _constfree(fsm->opath);
1886             }
1887             /*
1888              * Set file security context (if not disabled).
1889              */
1890             if (!rc && !getuid()) {
1891                 rc = fsmMapFContext(fsm);
1892                 if (!rc) {
1893                     rc = fsmNext(fsm, FSM_LSETFCON);
1894                     freecon(fsm->fcontext);
1895                 }
1896                 fsm->fcontext = NULL;
1897             }
1898             if (S_ISLNK(st->st_mode)) {
1899                 if (!rc && !getuid())
1900                     rc = fsmNext(fsm, FSM_LCHOWN);
1901             } else {
1902                 if (!rc && !getuid())
1903                     rc = fsmNext(fsm, FSM_CHOWN);
1904                 if (!rc)
1905                     rc = fsmNext(fsm, FSM_CHMOD);
1906                 if (!rc) {
1907                     time_t mtime = st->st_mtime;
1908                     rpmfi fi = fsmGetFi(fsm);
1909                     st->st_mtime = rpmfiFMtimeIndex(fi, fsm->ix);
1910                     rc = fsmNext(fsm, FSM_UTIME);
1911                     st->st_mtime = mtime;
1912                 }
1913 #if WITH_CAP
1914                 if (!rc && !S_ISDIR(st->st_mode) && !getuid()) {
1915                     rc = fsmMapFCaps(fsm);
1916                     if (!rc && fsm->fcaps) {
1917                         rc = fsmNext(fsm, FSM_SETCAP);
1918                         cap_free(fsm->fcaps);
1919                     }
1920                     fsm->fcaps = NULL;
1921                 }
1922 #endif /* WITH_CAP */
1923             }
1924         }
1925
1926         /* Notify on success. */
1927         if (!rc)                rc = fsmNext(fsm, FSM_NOTIFY);
1928         else if (fsm->failedFile && *fsm->failedFile == NULL) {
1929             /* XXX ick, stripping const */
1930             *fsm->failedFile = (char *) fsm->path;
1931             fsm->path = NULL;
1932         }
1933         break;
1934     case FSM_DESTROY:
1935         fsm->path = _constfree(fsm->path);
1936
1937         /* Check for hard links missing from payload. */
1938         while ((fsm->li = fsm->links) != NULL) {
1939             fsm->links = fsm->li->next;
1940             fsm->li->next = NULL;
1941             if (fsm->goal == FSM_PKGINSTALL &&
1942                         fsm->commit && fsm->li->linksLeft)
1943             {
1944                 for (nlink_t i = 0 ; i < fsm->li->linksLeft; i++) {
1945                     if (fsm->li->filex[i] < 0)
1946                         continue;
1947                     rc = CPIOERR_MISSING_HARDLINK;
1948                     if (fsm->failedFile && *fsm->failedFile == NULL) {
1949                         fsm->ix = fsm->li->filex[i];
1950                         if (!fsmNext(fsm, FSM_MAP)) {
1951                             /*
1952                              * XXX ick, stripping const. Out-of-sync
1953                              * hardlinks handled as sub-state, see
1954                              * changeset 4062:02b0c237b675
1955                              */
1956                             *fsm->failedFile = (char *) fsm->path;
1957                             fsm->path = NULL;
1958                         }
1959                     }
1960                     break;
1961                 }
1962             }
1963             if (fsm->goal == FSM_PKGBUILD &&
1964                 (fsm->mapFlags & CPIO_ALL_HARDLINKS))
1965             {
1966                 rc = CPIOERR_MISSING_HARDLINK;
1967             }
1968             fsm->li = freeHardLink(fsm->li);
1969         }
1970         fsm->ldn = _free(fsm->ldn);
1971         fsm->ldnalloc = fsm->ldnlen = 0;
1972         fsm->rdbuf = fsm->rdb = _free(fsm->rdb);
1973         fsm->wrbuf = fsm->wrb = _free(fsm->wrb);
1974         break;
1975     case FSM_VERIFY:
1976         if (fsm->diskchecked && !fsm->exists) {
1977             rc = CPIOERR_ENOENT;
1978             break;
1979         }
1980         if (S_ISREG(st->st_mode)) {
1981             /*
1982              * XXX HP-UX (and other os'es) don't permit unlink on busy
1983              * XXX files.
1984              */
1985             fsm->opath = fsm->path;
1986             fsm->path = rstrscat(NULL, fsm->path, "-RPMDELETE", NULL);
1987             rc = fsmNext(fsm, FSM_RENAME);
1988             if (!rc)
1989                     (void) fsmNext(fsm, FSM_UNLINK);
1990             else
1991                     rc = CPIOERR_UNLINK_FAILED;
1992             _constfree(fsm->path);
1993             fsm->path = fsm->opath;
1994             fsm->opath = NULL;
1995             return (rc ? rc : CPIOERR_ENOENT);  /* XXX HACK */
1996             break;
1997         } else if (S_ISDIR(st->st_mode)) {
1998             if (S_ISDIR(ost->st_mode))          return 0;
1999             if (S_ISLNK(ost->st_mode)) {
2000                 rc = fsmUNSAFE(fsm, FSM_STAT);
2001                 if (rc == CPIOERR_ENOENT) rc = 0;
2002                 if (rc) break;
2003                 errno = saveerrno;
2004                 if (S_ISDIR(ost->st_mode))      return 0;
2005             }
2006         } else if (S_ISLNK(st->st_mode)) {
2007             if (S_ISLNK(ost->st_mode)) {
2008         /* XXX NUL terminated result in fsm->rdbuf, len in fsm->rdnb. */
2009                 rc = fsmUNSAFE(fsm, FSM_READLINK);
2010                 errno = saveerrno;
2011                 if (rc) break;
2012                 if (rstreq(fsm->opath, fsm->rdbuf))     return 0;
2013             }
2014         } else if (S_ISFIFO(st->st_mode)) {
2015             if (S_ISFIFO(ost->st_mode))         return 0;
2016         } else if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode)) {
2017             if ((S_ISCHR(ost->st_mode) || S_ISBLK(ost->st_mode)) &&
2018                 (ost->st_rdev == st->st_rdev))  return 0;
2019         } else if (S_ISSOCK(st->st_mode)) {
2020             if (S_ISSOCK(ost->st_mode))         return 0;
2021         }
2022             /* XXX shouldn't do this with commit/undo. */
2023         rc = 0;
2024         if (fsm->stage == FSM_PROCESS) rc = fsmNext(fsm, FSM_UNLINK);
2025         if (rc == 0)    rc = CPIOERR_ENOENT;
2026         return (rc ? rc : CPIOERR_ENOENT);      /* XXX HACK */
2027         break;
2028
2029     case FSM_UNLINK:
2030         if (fsm->mapFlags & CPIO_SBIT_CHECK) {
2031             struct stat stb;
2032             if (lstat(fsm->path, &stb) == 0 && S_ISREG(stb.st_mode) && (stb.st_mode & 06000) != 0)
2033                 chmod(fsm->path, stb.st_mode & 0777);
2034         }
2035         rc = unlink(fsm->path);
2036         if (_fsm_debug && (stage & FSM_SYSCALL))
2037             rpmlog(RPMLOG_DEBUG, " %8s (%s) %s\n", cur,
2038                 fsm->path, (rc < 0 ? strerror(errno) : ""));
2039         if (rc < 0)
2040             rc = (errno == ENOENT ? CPIOERR_ENOENT : CPIOERR_UNLINK_FAILED);
2041         break;
2042     case FSM_RENAME:
2043         rc = rename(fsm->opath, fsm->path);
2044 #if defined(ETXTBSY) && defined(__HPUX__)
2045         if (rc && errno == ETXTBSY) {
2046             char *path = NULL;
2047             rstrscat(&path, fsm->path, "-RPMDELETE", NULL);
2048             /*
2049              * XXX HP-UX (and other os'es) don't permit rename to busy
2050              * XXX files.
2051              */
2052             rc = rename(fsm->path, path);
2053             if (!rc) rc = rename(fsm->opath, fsm->path);
2054             free(path);
2055         }
2056 #endif
2057         if (_fsm_debug && (stage & FSM_SYSCALL))
2058             rpmlog(RPMLOG_DEBUG, " %8s (%s, %s) %s\n", cur,
2059                 fsm->opath, fsm->path, (rc < 0 ? strerror(errno) : ""));
2060         if (rc < 0)     rc = CPIOERR_RENAME_FAILED;
2061         break;
2062     case FSM_MKDIR:
2063         rc = mkdir(fsm->path, (st->st_mode & 07777));
2064         if (_fsm_debug && (stage & FSM_SYSCALL))
2065             rpmlog(RPMLOG_DEBUG, " %8s (%s, 0%04o) %s\n", cur,
2066                 fsm->path, (unsigned)(st->st_mode & 07777),
2067                 (rc < 0 ? strerror(errno) : ""));
2068         if (rc < 0)     rc = CPIOERR_MKDIR_FAILED;
2069         break;
2070     case FSM_RMDIR:
2071         rc = rmdir(fsm->path);
2072         if (_fsm_debug && (stage & FSM_SYSCALL))
2073             rpmlog(RPMLOG_DEBUG, " %8s (%s) %s\n", cur,
2074                 fsm->path, (rc < 0 ? strerror(errno) : ""));
2075         if (rc < 0)
2076             switch (errno) {
2077             case ENOENT:        rc = CPIOERR_ENOENT;    break;
2078             case ENOTEMPTY:     rc = CPIOERR_ENOTEMPTY; break;
2079             default:            rc = CPIOERR_RMDIR_FAILED; break;
2080             }
2081         break;
2082     case FSM_LSETFCON:
2083         if (fsm->fcontext == NULL || *fsm->fcontext == '\0'
2084          || rstreq(fsm->fcontext, "<<none>>"))
2085             break;
2086         rc = lsetfilecon(fsm->path, (security_context_t)fsm->fcontext);
2087         if (_fsm_debug && (stage & FSM_SYSCALL))
2088             rpmlog(RPMLOG_DEBUG, " %8s (%s, %s) %s\n", cur,
2089                 fsm->path, fsm->fcontext,
2090                 (rc < 0 ? strerror(errno) : ""));
2091         if (rc < 0) rc = (errno == EOPNOTSUPP ? 0 : CPIOERR_LSETFCON_FAILED);
2092         break;
2093     case FSM_CHOWN:
2094         rc = chown(fsm->path, st->st_uid, st->st_gid);
2095         if (_fsm_debug && (stage & FSM_SYSCALL))
2096             rpmlog(RPMLOG_DEBUG, " %8s (%s, %d, %d) %s\n", cur,
2097                 fsm->path, (int)st->st_uid, (int)st->st_gid,
2098                 (rc < 0 ? strerror(errno) : ""));
2099         if (rc < 0)     rc = CPIOERR_CHOWN_FAILED;
2100         break;
2101     case FSM_LCHOWN:
2102 #if ! CHOWN_FOLLOWS_SYMLINK
2103         rc = lchown(fsm->path, st->st_uid, st->st_gid);
2104         if (_fsm_debug && (stage & FSM_SYSCALL))
2105             rpmlog(RPMLOG_DEBUG, " %8s (%s, %d, %d) %s\n", cur,
2106                 fsm->path, (int)st->st_uid, (int)st->st_gid,
2107                 (rc < 0 ? strerror(errno) : ""));
2108         if (rc < 0)     rc = CPIOERR_CHOWN_FAILED;
2109 #endif
2110         break;
2111     case FSM_CHMOD:
2112         rc = chmod(fsm->path, (st->st_mode & 07777));
2113         if (_fsm_debug && (stage & FSM_SYSCALL))
2114             rpmlog(RPMLOG_DEBUG, " %8s (%s, 0%04o) %s\n", cur,
2115                 fsm->path, (unsigned)(st->st_mode & 07777),
2116                 (rc < 0 ? strerror(errno) : ""));
2117         if (rc < 0)     rc = CPIOERR_CHMOD_FAILED;
2118         break;
2119     case FSM_UTIME:
2120         {   struct utimbuf stamp;
2121             stamp.actime = st->st_mtime;
2122             stamp.modtime = st->st_mtime;
2123             rc = utime(fsm->path, &stamp);
2124             if (_fsm_debug && (stage & FSM_SYSCALL))
2125                 rpmlog(RPMLOG_DEBUG, " %8s (%s, 0x%x) %s\n", cur,
2126                         fsm->path, (unsigned)st->st_mtime,
2127                         (rc < 0 ? strerror(errno) : ""));
2128             if (rc < 0) rc = CPIOERR_UTIME_FAILED;
2129         }
2130         break;
2131 #if WITH_CAP
2132     case FSM_SETCAP:
2133         rc = cap_set_file(fsm->path, fsm->fcaps);
2134         if (rc < 0) {
2135             rc = CPIOERR_SETCAP_FAILED;
2136         }
2137         break;
2138 #endif /* WITH_CAP */
2139     case FSM_SYMLINK:
2140         rc = symlink(fsm->opath, fsm->path);
2141         if (_fsm_debug && (stage & FSM_SYSCALL))
2142             rpmlog(RPMLOG_DEBUG, " %8s (%s, %s) %s\n", cur,
2143                 fsm->opath, fsm->path, (rc < 0 ? strerror(errno) : ""));
2144         if (rc < 0)     rc = CPIOERR_SYMLINK_FAILED;
2145         break;
2146     case FSM_LINK:
2147         rc = link(fsm->opath, fsm->path);
2148         if (_fsm_debug && (stage & FSM_SYSCALL))
2149             rpmlog(RPMLOG_DEBUG, " %8s (%s, %s) %s\n", cur,
2150                 fsm->opath, fsm->path, (rc < 0 ? strerror(errno) : ""));
2151         if (rc < 0)     rc = CPIOERR_LINK_FAILED;
2152         break;
2153     case FSM_MKFIFO:
2154         rc = mkfifo(fsm->path, (st->st_mode & 07777));
2155         if (_fsm_debug && (stage & FSM_SYSCALL))
2156             rpmlog(RPMLOG_DEBUG, " %8s (%s, 0%04o) %s\n", cur,
2157                 fsm->path, (unsigned)(st->st_mode & 07777),
2158                 (rc < 0 ? strerror(errno) : ""));
2159         if (rc < 0)     rc = CPIOERR_MKFIFO_FAILED;
2160         break;
2161     case FSM_MKNOD:
2162         /* FIX: check S_IFIFO or dev != 0 */
2163         rc = mknod(fsm->path, (st->st_mode & ~07777), st->st_rdev);
2164         if (_fsm_debug && (stage & FSM_SYSCALL))
2165             rpmlog(RPMLOG_DEBUG, " %8s (%s, 0%o, 0x%x) %s\n", cur,
2166                 fsm->path, (unsigned)(st->st_mode & ~07777),
2167                 (unsigned)st->st_rdev,
2168                 (rc < 0 ? strerror(errno) : ""));
2169         if (rc < 0)     rc = CPIOERR_MKNOD_FAILED;
2170         break;
2171     case FSM_LSTAT:
2172         rc = lstat(fsm->path, ost);
2173         if (_fsm_debug && (stage & FSM_SYSCALL) && rc && errno != ENOENT)
2174             rpmlog(RPMLOG_DEBUG, " %8s (%s, ost) %s\n", cur,
2175                 fsm->path, (rc < 0 ? strerror(errno) : ""));
2176         if (rc < 0) {
2177             rc = (errno == ENOENT ? CPIOERR_ENOENT : CPIOERR_LSTAT_FAILED);
2178             memset(ost, 0, sizeof(*ost));       /* XXX s390x hackery */
2179         }
2180         break;
2181     case FSM_STAT:
2182         rc = stat(fsm->path, ost);
2183         if (_fsm_debug && (stage & FSM_SYSCALL) && rc && errno != ENOENT)
2184             rpmlog(RPMLOG_DEBUG, " %8s (%s, ost) %s\n", cur,
2185                 fsm->path, (rc < 0 ? strerror(errno) : ""));
2186         if (rc < 0) {
2187             rc = (errno == ENOENT ? CPIOERR_ENOENT : CPIOERR_STAT_FAILED);
2188             memset(ost, 0, sizeof(*ost));       /* XXX s390x hackery */
2189         }
2190         break;
2191     case FSM_READLINK:
2192         /* XXX NUL terminated result in fsm->rdbuf, len in fsm->rdnb. */
2193         rc = readlink(fsm->path, fsm->rdbuf, fsm->rdsize - 1);
2194         if (_fsm_debug && (stage & FSM_SYSCALL))
2195             rpmlog(RPMLOG_DEBUG, " %8s (%s, rdbuf, %d) %s\n", cur,
2196                 fsm->path, (int)(fsm->rdsize -1), (rc < 0 ? strerror(errno) : ""));
2197         if (rc < 0)     rc = CPIOERR_READLINK_FAILED;
2198         else {
2199             fsm->rdnb = rc;
2200             fsm->rdbuf[fsm->rdnb] = '\0';
2201             rc = 0;
2202         }
2203         break;
2204     case FSM_CHROOT:
2205         break;
2206
2207     case FSM_NEXT:
2208         rc = fsmUNSAFE(fsm, FSM_HREAD);
2209         if (rc) break;
2210         if (rstreq(fsm->path, CPIO_TRAILER)) { /* Detect end-of-payload. */
2211             fsm->path = _constfree(fsm->path);
2212             rc = CPIOERR_HDR_TRAILER;
2213         }
2214         if (!rc)
2215             rc = fsmNext(fsm, FSM_POS);
2216         break;
2217     case FSM_EAT:
2218         for (left = st->st_size; left > 0; left -= fsm->rdnb) {
2219             fsm->wrlen = (left > fsm->wrsize ? fsm->wrsize : left);
2220             rc = fsmNext(fsm, FSM_DREAD);
2221             if (rc)
2222                 break;
2223         }
2224         break;
2225     case FSM_POS:
2226         left = (modulo - (fdGetCpioPos(fsm->cfd) % modulo)) % modulo;
2227         if (left) {
2228             fsm->wrlen = left;
2229             (void) fsmNext(fsm, FSM_DREAD);
2230         }
2231         break;
2232     case FSM_PAD:
2233         left = (modulo - (fdGetCpioPos(fsm->cfd) % modulo)) % modulo;
2234         if (left) {
2235             memset(fsm->rdbuf, 0, left);
2236             /* XXX DWRITE uses rdnb for I/O length. */
2237             fsm->rdnb = left;
2238             (void) fsmNext(fsm, FSM_DWRITE);
2239         }
2240         break;
2241     case FSM_TRAILER:
2242         rc = cpioTrailerWrite(fsm);
2243         break;
2244     case FSM_HREAD:
2245         rc = fsmNext(fsm, FSM_POS);
2246         if (!rc)
2247             rc = cpioHeaderRead(fsm, st);       /* Read next payload header. */
2248         break;
2249     case FSM_HWRITE:
2250         rc = cpioHeaderWrite(fsm, st);          /* Write next payload header. */
2251         break;
2252     case FSM_DREAD:
2253         fsm->rdnb = Fread(fsm->wrbuf, sizeof(*fsm->wrbuf), fsm->wrlen, fsm->cfd);
2254         if (_fsm_debug && (stage & FSM_SYSCALL))
2255             rpmlog(RPMLOG_DEBUG, " %8s (%s, %d, cfd)\trdnb %d\n",
2256                 cur, (fsm->wrbuf == fsm->wrb ? "wrbuf" : "mmap"),
2257                 (int)fsm->wrlen, (int)fsm->rdnb);
2258         if (fsm->rdnb != fsm->wrlen || Ferror(fsm->cfd))
2259             rc = CPIOERR_READ_FAILED;
2260         if (fsm->rdnb > 0)
2261             fdSetCpioPos(fsm->cfd, fdGetCpioPos(fsm->cfd) + fsm->rdnb);
2262         break;
2263     case FSM_DWRITE:
2264         fsm->wrnb = Fwrite(fsm->rdbuf, sizeof(*fsm->rdbuf), fsm->rdnb, fsm->cfd);
2265         if (_fsm_debug && (stage & FSM_SYSCALL))
2266             rpmlog(RPMLOG_DEBUG, " %8s (%s, %d, cfd)\twrnb %d\n",
2267                 cur, (fsm->rdbuf == fsm->rdb ? "rdbuf" : "mmap"),
2268                 (int)fsm->rdnb, (int)fsm->wrnb);
2269         if (fsm->rdnb != fsm->wrnb || Ferror(fsm->cfd))
2270             rc = CPIOERR_WRITE_FAILED;
2271         if (fsm->wrnb > 0)
2272             fdSetCpioPos(fsm->cfd, fdGetCpioPos(fsm->cfd) + fsm->wrnb);
2273         break;
2274
2275     case FSM_ROPEN:
2276         fsm->rfd = Fopen(fsm->path, "r.ufdio");
2277         if (fsm->rfd == NULL || Ferror(fsm->rfd)) {
2278             if (fsm->rfd != NULL)       (void) fsmNext(fsm, FSM_RCLOSE);
2279             fsm->rfd = NULL;
2280             rc = CPIOERR_OPEN_FAILED;
2281             break;
2282         }
2283         if (_fsm_debug && (stage & FSM_SYSCALL))
2284             rpmlog(RPMLOG_DEBUG, " %8s (%s, \"r\") rfd %p rdbuf %p\n", cur,
2285                 fsm->path, fsm->rfd, fsm->rdbuf);
2286         break;
2287     case FSM_READ:
2288         fsm->rdnb = Fread(fsm->rdbuf, sizeof(*fsm->rdbuf), fsm->rdlen, fsm->rfd);
2289         if (_fsm_debug && (stage & FSM_SYSCALL))
2290             rpmlog(RPMLOG_DEBUG, " %8s (rdbuf, %d, rfd)\trdnb %d\n",
2291                 cur, (int)fsm->rdlen, (int)fsm->rdnb);
2292         if (fsm->rdnb != fsm->rdlen || Ferror(fsm->rfd))
2293             rc = CPIOERR_READ_FAILED;
2294         break;
2295     case FSM_RCLOSE:
2296         if (fsm->rfd != NULL) {
2297             if (_fsm_debug && (stage & FSM_SYSCALL))
2298                 rpmlog(RPMLOG_DEBUG, " %8s (%p)\n", cur, fsm->rfd);
2299             (void) rpmswAdd(rpmtsOp(fsmGetTs(fsm), RPMTS_OP_DIGEST),
2300                         fdOp(fsm->rfd, FDSTAT_DIGEST));
2301             (void) Fclose(fsm->rfd);
2302             errno = saveerrno;
2303         }
2304         fsm->rfd = NULL;
2305         break;
2306     case FSM_WOPEN:
2307         fsm->wfd = Fopen(fsm->path, "w.ufdio");
2308         if (fsm->wfd == NULL || Ferror(fsm->wfd)) {
2309             if (fsm->wfd != NULL)       (void) fsmNext(fsm, FSM_WCLOSE);
2310             fsm->wfd = NULL;
2311             rc = CPIOERR_OPEN_FAILED;
2312         }
2313         if (_fsm_debug && (stage & FSM_SYSCALL))
2314             rpmlog(RPMLOG_DEBUG, " %8s (%s, \"w\") wfd %p wrbuf %p\n", cur,
2315                 fsm->path, fsm->wfd, fsm->wrbuf);
2316         break;
2317     case FSM_WRITE:
2318         fsm->wrnb = Fwrite(fsm->wrbuf, sizeof(*fsm->wrbuf), fsm->rdnb, fsm->wfd);
2319         if (_fsm_debug && (stage & FSM_SYSCALL))
2320             rpmlog(RPMLOG_DEBUG, " %8s (wrbuf, %d, wfd)\twrnb %d\n",
2321                 cur, (int)fsm->rdnb, (int)fsm->wrnb);
2322         if (fsm->rdnb != fsm->wrnb || Ferror(fsm->wfd))
2323             rc = CPIOERR_WRITE_FAILED;
2324         break;
2325     case FSM_WCLOSE:
2326         if (fsm->wfd != NULL) {
2327             if (_fsm_debug && (stage & FSM_SYSCALL))
2328                 rpmlog(RPMLOG_DEBUG, " %8s (%p)\n", cur, fsm->wfd);
2329             (void) rpmswAdd(rpmtsOp(fsmGetTs(fsm), RPMTS_OP_DIGEST),
2330                         fdOp(fsm->wfd, FDSTAT_DIGEST));
2331             (void) Fclose(fsm->wfd);
2332             errno = saveerrno;
2333         }
2334         fsm->wfd = NULL;
2335         break;
2336
2337     default:
2338         break;
2339     }
2340
2341     if (!(stage & FSM_INTERNAL)) {
2342         fsm->rc = (rc == CPIOERR_HDR_TRAILER ? 0 : rc);
2343     }
2344     return rc;
2345 }
2346
2347 /**
2348  * Return formatted string representation of file disposition.
2349  * @param a             file dispostion
2350  * @return              formatted string
2351  */
2352 static const char * fileActionString(rpmFileAction a)
2353 {
2354     switch (a) {
2355     case FA_UNKNOWN:    return "unknown";
2356     case FA_CREATE:     return "create";
2357     case FA_COPYOUT:    return "copyout";
2358     case FA_COPYIN:     return "copyin";
2359     case FA_BACKUP:     return "backup";
2360     case FA_SAVE:       return "save";
2361     case FA_SKIP:       return "skip";
2362     case FA_ALTNAME:    return "altname";
2363     case FA_ERASE:      return "erase";
2364     case FA_SKIPNSTATE: return "skipnstate";
2365     case FA_SKIPNETSHARED: return "skipnetshared";
2366     case FA_SKIPCOLOR:  return "skipcolor";
2367     default:            return "???";
2368     }
2369 }
2370
2371 /**
2372  * Return formatted string representation of file stages.
2373  * @param a             file stage
2374  * @return              formatted string
2375  */
2376 static const char * fileStageString(fileStage a) {
2377     switch(a) {
2378     case FSM_UNKNOWN:   return "unknown";
2379
2380     case FSM_PKGINSTALL:return "INSTALL";
2381     case FSM_PKGERASE:  return "ERASE";
2382     case FSM_PKGBUILD:  return "BUILD";
2383     case FSM_PKGCOMMIT: return "COMMIT";
2384     case FSM_PKGUNDO:   return "UNDO";
2385
2386     case FSM_CREATE:    return "create";
2387     case FSM_INIT:      return "init";
2388     case FSM_MAP:       return "map";
2389     case FSM_MKDIRS:    return "mkdirs";
2390     case FSM_RMDIRS:    return "rmdirs";
2391     case FSM_PRE:       return "pre";
2392     case FSM_PROCESS:   return "process";
2393     case FSM_POST:      return "post";
2394     case FSM_MKLINKS:   return "mklinks";
2395     case FSM_NOTIFY:    return "notify";
2396     case FSM_UNDO:      return "undo";
2397     case FSM_FINI:      return "fini";
2398     case FSM_COMMIT:    return "commit";
2399     case FSM_DESTROY:   return "destroy";
2400     case FSM_VERIFY:    return "verify";
2401
2402     case FSM_UNLINK:    return "unlink";
2403     case FSM_RENAME:    return "rename";
2404     case FSM_MKDIR:     return "mkdir";
2405     case FSM_RMDIR:     return "rmdir";
2406     case FSM_LSETFCON:  return "lsetfcon";
2407     case FSM_CHOWN:     return "chown";
2408     case FSM_LCHOWN:    return "lchown";
2409     case FSM_CHMOD:     return "chmod";
2410     case FSM_UTIME:     return "utime";
2411     case FSM_SYMLINK:   return "symlink";
2412     case FSM_LINK:      return "link";
2413     case FSM_MKFIFO:    return "mkfifo";
2414     case FSM_MKNOD:     return "mknod";
2415     case FSM_LSTAT:     return "lstat";
2416     case FSM_STAT:      return "stat";
2417     case FSM_READLINK:  return "readlink";
2418     case FSM_CHROOT:    return "chroot";
2419     case FSM_SETCAP:    return "setcap";
2420
2421     case FSM_NEXT:      return "next";
2422     case FSM_EAT:       return "eat";
2423     case FSM_POS:       return "pos";
2424     case FSM_PAD:       return "pad";
2425     case FSM_TRAILER:   return "trailer";
2426     case FSM_HREAD:     return "hread";
2427     case FSM_HWRITE:    return "hwrite";
2428     case FSM_DREAD:     return "Fread";
2429     case FSM_DWRITE:    return "Fwrite";
2430
2431     case FSM_ROPEN:     return "Fopen";
2432     case FSM_READ:      return "Fread";
2433     case FSM_RCLOSE:    return "Fclose";
2434     case FSM_WOPEN:     return "Fopen";
2435     case FSM_WRITE:     return "Fwrite";
2436     case FSM_WCLOSE:    return "Fclose";
2437
2438     default:            return "???";
2439     }
2440 }