00001
00006 #include "system.h"
00007
00008 #include <rpmio_internal.h>
00009 #include <rpmlib.h>
00010 #include <rpmmacro.h>
00011 #include <rpmurl.h>
00012 #include <rpmlua.h>
00013
00014 #include "cpio.h"
00015 #include "fsm.h"
00016 #include "psm.h"
00017
00018 #include "rpmds.h"
00019
00020 #define _RPMFI_INTERNAL
00021 #include "rpmfi.h"
00022
00023 #define _RPMTE_INTERNAL
00024 #include "rpmte.h"
00025
00026 #define _RPMTS_INTERNAL
00027 #include "rpmts.h"
00028
00029 #include "rpmlead.h"
00030 #include "signature.h"
00031 #include "legacy.h"
00032 #include "misc.h"
00033 #include "rpmdb.h"
00034 #include "debug.h"
00035
00036 #define _PSM_DEBUG 0
00037
00038 int _psm_debug = _PSM_DEBUG;
00039
00040 int _psm_threads = 0;
00041
00042
00043
00044
00045
00046
00047 extern unsigned int myinstall_instance;
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061 int rpmVersionCompare(Header first, Header second)
00062 {
00063 const char * one, * two;
00064 int_32 * epochOne, * epochTwo;
00065 static int_32 zero = 0;
00066 int rc;
00067
00068 if (!headerGetEntry(first, RPMTAG_EPOCH, NULL, (void **) &epochOne, NULL))
00069 epochOne = &zero;
00070 if (!headerGetEntry(second, RPMTAG_EPOCH, NULL, (void **) &epochTwo, NULL))
00071 epochTwo = &zero;
00072
00073
00074 if (*epochOne < *epochTwo)
00075 return -1;
00076 else if (*epochOne > *epochTwo)
00077 return 1;
00078
00079
00080 rc = headerGetEntry(first, RPMTAG_VERSION, NULL, (void **) &one, NULL);
00081 rc = headerGetEntry(second, RPMTAG_VERSION, NULL, (void **) &two, NULL);
00082
00083 rc = rpmvercmp(one, two);
00084 if (rc)
00085 return rc;
00086
00087 rc = headerGetEntry(first, RPMTAG_RELEASE, NULL, (void **) &one, NULL);
00088 rc = headerGetEntry(second, RPMTAG_RELEASE, NULL, (void **) &two, NULL);
00089
00090 return rpmvercmp(one, two);
00091 }
00092
00097
00098 static struct tagMacro {
00099 const char * macroname;
00100 rpmTag tag;
00101 } tagMacros[] = {
00102 { "name", RPMTAG_NAME },
00103 { "version", RPMTAG_VERSION },
00104 { "release", RPMTAG_RELEASE },
00105 { "epoch", RPMTAG_EPOCH },
00106 { NULL, 0 }
00107 };
00108
00115 static int rpmInstallLoadMacros(rpmfi fi, Header h)
00116
00117
00118 {
00119 HGE_t hge = (HGE_t) fi->hge;
00120 struct tagMacro * tagm;
00121 union {
00122 void * ptr;
00123 const char ** argv;
00124 const char * str;
00125 int_32 * i32p;
00126 } body;
00127 char numbuf[32];
00128 rpmTagType type;
00129
00130 for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {
00131 if (!hge(h, tagm->tag, &type, (void **) &body, NULL))
00132 continue;
00133 switch (type) {
00134 case RPM_INT32_TYPE:
00135
00136 sprintf(numbuf, "%d", *body.i32p);
00137
00138 addMacro(NULL, tagm->macroname, NULL, numbuf, -1);
00139 break;
00140 case RPM_STRING_TYPE:
00141 addMacro(NULL, tagm->macroname, NULL, body.str, -1);
00142 break;
00143 case RPM_NULL_TYPE:
00144 case RPM_CHAR_TYPE:
00145 case RPM_INT8_TYPE:
00146 case RPM_INT16_TYPE:
00147 case RPM_BIN_TYPE:
00148 case RPM_STRING_ARRAY_TYPE:
00149 case RPM_I18NSTRING_TYPE:
00150 default:
00151 break;
00152 }
00153 }
00154 return 0;
00155 }
00156
00162
00163 static rpmRC markReplacedFiles(const rpmpsm psm)
00164
00165
00166 {
00167 const rpmts ts = psm->ts;
00168 rpmfi fi = psm->fi;
00169 HGE_t hge = (HGE_t)fi->hge;
00170 sharedFileInfo replaced = fi->replaced;
00171 sharedFileInfo sfi;
00172 rpmdbMatchIterator mi;
00173 Header h;
00174 unsigned int * offsets;
00175 unsigned int prev;
00176 int num, xx;
00177
00178 if (!(rpmfiFC(fi) > 0 && fi->replaced))
00179 return RPMRC_OK;
00180
00181 num = prev = 0;
00182 for (sfi = replaced; sfi->otherPkg; sfi++) {
00183 if (prev && prev == sfi->otherPkg)
00184 continue;
00185 prev = sfi->otherPkg;
00186 num++;
00187 }
00188 if (num == 0)
00189 return RPMRC_OK;
00190
00191 offsets = alloca(num * sizeof(*offsets));
00192 offsets[0] = 0;
00193 num = prev = 0;
00194 for (sfi = replaced; sfi->otherPkg; sfi++) {
00195 if (prev && prev == sfi->otherPkg)
00196 continue;
00197 prev = sfi->otherPkg;
00198 offsets[num++] = sfi->otherPkg;
00199 }
00200
00201 mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, NULL, 0);
00202 xx = rpmdbAppendIterator(mi, offsets, num);
00203 xx = rpmdbSetIteratorRewrite(mi, 1);
00204
00205 sfi = replaced;
00206 while ((h = rpmdbNextIterator(mi)) != NULL) {
00207 char * secStates;
00208 int modified;
00209 int count;
00210
00211 modified = 0;
00212
00213 if (!hge(h, RPMTAG_FILESTATES, NULL, (void **)&secStates, &count))
00214 continue;
00215
00216 prev = rpmdbGetIteratorOffset(mi);
00217 num = 0;
00218 while (sfi->otherPkg && sfi->otherPkg == prev) {
00219 assert(sfi->otherFileNum < count);
00220 if (secStates[sfi->otherFileNum] != RPMFILE_STATE_REPLACED) {
00221 secStates[sfi->otherFileNum] = RPMFILE_STATE_REPLACED;
00222 if (modified == 0) {
00223
00224 modified = 1;
00225 xx = rpmdbSetIteratorModified(mi, modified);
00226 }
00227 num++;
00228 }
00229 sfi++;
00230 }
00231 }
00232 mi = rpmdbFreeIterator(mi);
00233
00234 return RPMRC_OK;
00235 }
00236
00237
00238 rpmRC rpmInstallSourcePackage(rpmts ts, FD_t fd,
00239 const char ** specFilePtr, const char ** cookie)
00240 {
00241 int scareMem = 1;
00242 rpmfi fi = NULL;
00243 const char * _sourcedir = NULL;
00244 const char * _specdir = NULL;
00245 const char * specFile = NULL;
00246 HGE_t hge;
00247 HFD_t hfd;
00248 Header h = NULL;
00249 struct rpmpsm_s psmbuf;
00250 rpmpsm psm = &psmbuf;
00251 int isSource;
00252 rpmRC rpmrc;
00253 int i;
00254
00255 memset(psm, 0, sizeof(*psm));
00256 psm->ts = rpmtsLink(ts, "InstallSourcePackage");
00257
00258 rpmrc = rpmReadPackageFile(ts, fd, "InstallSourcePackage", &h);
00259 switch (rpmrc) {
00260 case RPMRC_NOTTRUSTED:
00261 case RPMRC_NOKEY:
00262 case RPMRC_OK:
00263 break;
00264 default:
00265 goto exit;
00266 break;
00267 }
00268 if (h == NULL)
00269 goto exit;
00270
00271 rpmrc = RPMRC_OK;
00272
00273 isSource = headerIsEntry(h, RPMTAG_SOURCEPACKAGE);
00274
00275 if (!isSource) {
00276 rpmError(RPMERR_NOTSRPM, _("source package expected, binary found\n"));
00277 rpmrc = RPMRC_FAIL;
00278 goto exit;
00279 }
00280
00281 if (rpmtsAddInstallElement(ts, h, NULL, 0, NULL)) {
00282 rpmrc = RPMRC_FAIL;
00283 goto exit;
00284 }
00285
00286 fi = rpmfiNew(ts, h, RPMTAG_BASENAMES, scareMem);
00287 h = headerFree(h);
00288
00289 if (fi == NULL) {
00290 rpmrc = RPMRC_FAIL;
00291 goto exit;
00292 }
00293
00294
00295 fi->te = rpmtsElement(ts, 0);
00296
00297 if (fi->te == NULL) {
00298 rpmrc = RPMRC_FAIL;
00299 goto exit;
00300 }
00301
00302
00303 fi->te->h = headerLink(fi->h);
00304
00305 fi->te->fd = fdLink(fd, "installSourcePackage");
00306 hge = fi->hge;
00307 hfd = fi->hfd;
00308
00309 (void) rpmInstallLoadMacros(fi, fi->h);
00310
00311 psm->fi = rpmfiLink(fi, NULL);
00312
00313 psm->te = fi->te;
00314
00315
00316 if (cookie) {
00317 *cookie = NULL;
00318 if (hge(fi->h, RPMTAG_COOKIE, NULL, (void **) cookie, NULL))
00319 *cookie = xstrdup(*cookie);
00320 }
00321
00322
00323 fi->fmd5s = hfd(fi->fmd5s, -1);
00324
00325
00326 fi->fmapflags = _free(fi->fmapflags);
00327 fi->mapflags = CPIO_MAP_PATH | CPIO_MAP_MODE | CPIO_MAP_UID | CPIO_MAP_GID;
00328
00329 fi->uid = getuid();
00330 fi->gid = getgid();
00331 fi->astriplen = 0;
00332 fi->striplen = 0;
00333
00334 for (i = 0; i < fi->fc; i++)
00335 fi->actions[i] = FA_CREATE;
00336
00337 i = fi->fc;
00338
00339 if (fi->h != NULL) {
00340 rpmfiBuildFNames(fi->h, RPMTAG_BASENAMES, &fi->apath, NULL);
00341
00342 if (headerIsEntry(fi->h, RPMTAG_COOKIE))
00343 for (i = 0; i < fi->fc; i++)
00344 if (fi->fflags[i] & RPMFILE_SPECFILE) break;
00345 }
00346
00347 if (i == fi->fc) {
00348
00349 for (i = 0; i < fi->fc; i++) {
00350 const char * t = fi->apath[i];
00351 t += strlen(fi->apath[i]) - 5;
00352 if (!strcmp(t, ".spec")) break;
00353 }
00354 }
00355
00356 _sourcedir = rpmGenPath(rpmtsRootDir(ts), "%{_sourcedir}", "");
00357 rpmrc = rpmMkdirPath(_sourcedir, "sourcedir");
00358 if (rpmrc) {
00359 rpmrc = RPMRC_FAIL;
00360 goto exit;
00361 }
00362
00363 _specdir = rpmGenPath(rpmtsRootDir(ts), "%{_specdir}", "");
00364 rpmrc = rpmMkdirPath(_specdir, "specdir");
00365 if (rpmrc) {
00366 rpmrc = RPMRC_FAIL;
00367 goto exit;
00368 }
00369
00370
00371 if (i < fi->fc) {
00372 int speclen = strlen(_specdir) + 2;
00373 int sourcelen = strlen(_sourcedir) + 2;
00374 char * t;
00375
00376 fi->dnl = hfd(fi->dnl, -1);
00377
00378 fi->dc = 2;
00379 fi->dnl = xmalloc(fi->dc * sizeof(*fi->dnl)
00380 + fi->fc * sizeof(*fi->dil)
00381 + speclen + sourcelen);
00382
00383 fi->dil = (int *)(fi->dnl + fi->dc);
00384
00385 memset(fi->dil, 0, fi->fc * sizeof(*fi->dil));
00386 fi->dil[i] = 1;
00387
00388 fi->dnl[0] = t = (char *)(fi->dil + fi->fc);
00389 fi->dnl[1] = t = stpcpy( stpcpy(t, _sourcedir), "/") + 1;
00390
00391 (void) stpcpy( stpcpy(t, _specdir), "/");
00392
00393 t = xmalloc(speclen + strlen(fi->bnl[i]) + 1);
00394 (void) stpcpy( stpcpy( stpcpy(t, _specdir), "/"), fi->bnl[i]);
00395 specFile = t;
00396 } else {
00397 rpmError(RPMERR_NOSPEC, _("source package contains no .spec file\n"));
00398 rpmrc = RPMRC_FAIL;
00399 goto exit;
00400 }
00401
00402 psm->goal = PSM_PKGINSTALL;
00403
00404
00405 rpmrc = rpmpsmStage(psm, PSM_PROCESS);
00406
00407 (void) rpmpsmStage(psm, PSM_FINI);
00408
00409
00410 if (rpmrc) rpmrc = RPMRC_FAIL;
00411
00412 exit:
00413 if (specFilePtr && specFile && rpmrc == RPMRC_OK)
00414 *specFilePtr = specFile;
00415 else
00416 specFile = _free(specFile);
00417
00418 _specdir = _free(_specdir);
00419 _sourcedir = _free(_sourcedir);
00420
00421 psm->fi = rpmfiFree(psm->fi);
00422 psm->te = NULL;
00423
00424 if (h != NULL) h = headerFree(h);
00425
00426
00427 if (fi != NULL) {
00428 fi->te->h = headerFree(fi->te->h);
00429 if (fi->te->fd != NULL)
00430 (void) Fclose(fi->te->fd);
00431 fi->te->fd = NULL;
00432 fi->te = NULL;
00433 fi = rpmfiFree(fi);
00434 }
00435
00436
00437
00438 rpmtsClean(ts);
00439
00440 psm->ts = rpmtsFree(psm->ts);
00441
00442 return rpmrc;
00443 }
00444
00445
00446 static char * SCRIPT_PATH = "PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin";
00447
00453 static const char * const tag2sln(int tag)
00454
00455 {
00456 switch (tag) {
00457 case RPMTAG_PRETRANS: return "%pretrans";
00458 case RPMTAG_TRIGGERPREIN: return "%triggerprein";
00459 case RPMTAG_PREIN: return "%pre";
00460 case RPMTAG_POSTIN: return "%post";
00461 case RPMTAG_TRIGGERIN: return "%triggerin";
00462 case RPMTAG_TRIGGERUN: return "%triggerun";
00463 case RPMTAG_PREUN: return "%preun";
00464 case RPMTAG_POSTUN: return "%postun";
00465 case RPMTAG_POSTTRANS: return "%posttrans";
00466 case RPMTAG_TRIGGERPOSTUN: return "%triggerpostun";
00467 case RPMTAG_VERIFYSCRIPT: return "%verify";
00468 }
00469 return "%unknownscript";
00470 }
00471
00477 static pid_t psmWait(rpmpsm psm)
00478
00479
00480 {
00481 const rpmts ts = psm->ts;
00482 rpmtime_t msecs;
00483
00484 (void) rpmsqWait(&psm->sq);
00485 msecs = psm->sq.op.usecs/1000;
00486 (void) rpmswAdd(rpmtsOp(ts, RPMTS_OP_SCRIPTLETS), &psm->sq.op);
00487
00488 rpmMessage(RPMMESS_DEBUG,
00489 _("%s: waitpid(%d) rc %d status %x secs %u.%03u\n"),
00490 psm->stepName, (unsigned)psm->sq.child,
00491 (unsigned)psm->sq.reaped, psm->sq.status,
00492 (unsigned)msecs/1000, (unsigned)msecs%1000);
00493
00494 return psm->sq.reaped;
00495 }
00496
00497 #ifdef WITH_LUA
00498
00501 static rpmRC runLuaScript(rpmpsm psm, Header h, const char *sln,
00502 int progArgc, const char **progArgv,
00503 const char *script, int arg1, int arg2)
00504
00505
00506 {
00507 const rpmts ts = psm->ts;
00508 int rootFd = -1;
00509 const char *n, *v, *r;
00510 rpmRC rc = RPMRC_OK;
00511 int i;
00512 int xx;
00513 rpmlua lua = NULL;
00514 rpmluav var;
00515
00516 xx = headerNVR(h, &n, &v, &r);
00517
00518 if (!rpmtsChrootDone(ts)) {
00519 const char *rootDir = rpmtsRootDir(ts);
00520 xx = chdir("/");
00521
00522 rootFd = open(".", O_RDONLY, 0);
00523
00524 if (rootFd >= 0) {
00525
00526 if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/')
00527 xx = chroot(rootDir);
00528
00529 xx = rpmtsSetChrootDone(ts, 1);
00530 }
00531 }
00532
00533
00534 rpmluaPushTable(lua, "arg");
00535 var = rpmluavNew();
00536 rpmluavSetListMode(var, 1);
00537
00538 if (progArgv) {
00539 for (i = 0; i < progArgc && progArgv[i]; i++) {
00540 rpmluavSetValue(var, RPMLUAV_STRING, progArgv[i]);
00541 rpmluaSetVar(lua, var);
00542 }
00543 }
00544 if (arg1 >= 0) {
00545 rpmluavSetValueNum(var, arg1);
00546 rpmluaSetVar(lua, var);
00547 }
00548 if (arg2 >= 0) {
00549 rpmluavSetValueNum(var, arg2);
00550 rpmluaSetVar(lua, var);
00551 }
00552
00553
00554 var = rpmluavFree(var);
00555
00556 rpmluaPop(lua);
00557
00558 {
00559 char buf[BUFSIZ];
00560 xx = snprintf(buf, BUFSIZ, "%s(%s-%s-%s)", sln, n, v, r);
00561 if (rpmluaRunScript(lua, script, buf) == -1)
00562 rc = RPMRC_FAIL;
00563 }
00564
00565 rpmluaDelVar(lua, "arg");
00566
00567 if (rootFd >= 0) {
00568 const char *rootDir = rpmtsRootDir(ts);
00569 xx = fchdir(rootFd);
00570 xx = close(rootFd);
00571
00572 if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/')
00573 xx = chroot(".");
00574
00575 xx = rpmtsSetChrootDone(ts, 0);
00576 }
00577
00578 return rc;
00579 }
00580 #endif
00581
00584
00585 static int ldconfig_done = 0;
00586
00587
00588 static const char * ldconfig_path = "/sbin/ldconfig";
00589
00608 static rpmRC runScript(rpmpsm psm, Header h, const char * sln,
00609 int progArgc, const char ** progArgv,
00610 const char * script, int arg1, int arg2)
00611
00612
00613
00614
00615 {
00616 const rpmts ts = psm->ts;
00617 rpmfi fi = psm->fi;
00618 HGE_t hge = fi->hge;
00619 HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
00620 const char ** argv = NULL;
00621 int argc = 0;
00622 const char ** prefixes = NULL;
00623 int numPrefixes;
00624 rpmTagType ipt;
00625 const char * oldPrefix;
00626 int maxPrefixLength;
00627 int len;
00628 char * prefixBuf = NULL;
00629 const char * fn = NULL;
00630 int xx;
00631 int i;
00632 int freePrefixes = 0;
00633 FD_t scriptFd;
00634 FD_t out;
00635 rpmRC rc = RPMRC_OK;
00636 const char *n, *v, *r, *a;
00637
00638 if (progArgv == NULL && script == NULL)
00639 return rc;
00640
00641
00642 xx = headerNVR(h, &n, &v, &r);
00643 xx = hge(h, RPMTAG_ARCH, NULL, (void **) &a, NULL);
00644
00645 if (progArgv && strcmp(progArgv[0], "<lua>") == 0) {
00646 #ifdef WITH_LUA
00647 rpmMessage(RPMMESS_DEBUG,
00648 _("%s: %s(%s-%s-%s.%s) running <lua> scriptlet.\n"),
00649 psm->stepName, tag2sln(psm->scriptTag), n, v, r, a);
00650 return runLuaScript(psm, h, sln, progArgc, progArgv,
00651 script, arg1, arg2);
00652 #else
00653 return RPMRC_FAIL;
00654 #endif
00655 }
00656
00657 psm->sq.reaper = 1;
00658
00659
00660
00661
00662 if (ldconfig_path && progArgv != NULL && psm->unorderedSuccessor) {
00663 if (ldconfig_done && !strcmp(progArgv[0], ldconfig_path)) {
00664 rpmMessage(RPMMESS_DEBUG,
00665 _("%s: %s(%s-%s-%s.%s) skipping redundant \"%s\".\n"),
00666 psm->stepName, tag2sln(psm->scriptTag), n, v, r, a,
00667 progArgv[0]);
00668 return rc;
00669 }
00670 }
00671
00672 rpmMessage(RPMMESS_DEBUG,
00673 _("%s: %s(%s-%s-%s.%s) %ssynchronous scriptlet start\n"),
00674 psm->stepName, tag2sln(psm->scriptTag), n, v, r, a,
00675 (psm->unorderedSuccessor ? "a" : ""));
00676
00677 if (!progArgv) {
00678 argv = alloca(5 * sizeof(*argv));
00679 argv[0] = "/bin/sh";
00680 argc = 1;
00681 ldconfig_done = 0;
00682 } else {
00683 argv = alloca((progArgc + 4) * sizeof(*argv));
00684 memcpy(argv, progArgv, progArgc * sizeof(*argv));
00685 argc = progArgc;
00686 ldconfig_done = (ldconfig_path && !strcmp(argv[0], ldconfig_path)
00687 ? 1 : 0);
00688 }
00689
00690 #if __ia64__
00691
00692 if ((a != NULL && a[0] == 'i' && a[1] != '\0' && a[2] == '8' && a[3] == '6')
00693 && strcmp(argv[0], "/sbin/ldconfig"))
00694 {
00695 const char * fmt = rpmGetPath("%{?_autorelocate_path}", NULL);
00696 const char * errstr;
00697 char * newPath;
00698 char * t;
00699
00700 newPath = headerSprintf(h, fmt, rpmTagTable, rpmHeaderFormats, &errstr);
00701 fmt = _free(fmt);
00702
00703
00704 if (newPath != NULL && *newPath != '\0'
00705 && strlen(newPath) >= (sizeof("/emul/i386")-1)
00706 && newPath[0] == '/' && newPath[1] == 'e' && newPath[2] == 'm'
00707 && newPath[3] == 'u' && newPath[4] == 'l' && newPath[5] == '/'
00708 && newPath[6] == 'i' && newPath[8] == '8' && newPath[9] == '6')
00709 {
00710 newPath[7] = 'a';
00711 newPath[8] = '3';
00712 newPath[9] = '2';
00713 }
00714
00715 t = alloca(strlen(newPath) + strlen(argv[0]) + 1);
00716 *t = '\0';
00717 (void) stpcpy( stpcpy(t, newPath), argv[0]);
00718 newPath = _free(newPath);
00719 argv[0] = t;
00720 }
00721 #endif
00722
00723 if (hge(h, RPMTAG_INSTPREFIXES, &ipt, (void **) &prefixes, &numPrefixes)) {
00724 freePrefixes = 1;
00725 } else if (hge(h, RPMTAG_INSTALLPREFIX, NULL, (void **) &oldPrefix, NULL)) {
00726 prefixes = &oldPrefix;
00727 numPrefixes = 1;
00728 } else {
00729 numPrefixes = 0;
00730 }
00731
00732 maxPrefixLength = 0;
00733 if (prefixes != NULL)
00734 for (i = 0; i < numPrefixes; i++) {
00735 len = strlen(prefixes[i]);
00736 if (len > maxPrefixLength) maxPrefixLength = len;
00737 }
00738 prefixBuf = alloca(maxPrefixLength + 50);
00739
00740 if (script) {
00741 const char * rootDir = rpmtsRootDir(ts);
00742 FD_t fd;
00743
00744
00745 if (makeTempFile((!rpmtsChrootDone(ts) ? rootDir : "/"), &fn, &fd)) {
00746 if (prefixes != NULL && freePrefixes) free(prefixes);
00747 return RPMRC_FAIL;
00748 }
00749
00750
00751 if (rpmIsDebug() &&
00752 (!strcmp(argv[0], "/bin/sh") || !strcmp(argv[0], "/bin/bash")))
00753 {
00754 static const char set_x[] = "set -x\n";
00755 xx = Fwrite(set_x, sizeof(set_x[0]), sizeof(set_x)-1, fd);
00756 }
00757
00758 if (ldconfig_path && strstr(script, ldconfig_path) != NULL)
00759 ldconfig_done = 1;
00760
00761 xx = Fwrite(script, sizeof(script[0]), strlen(script), fd);
00762 xx = Fclose(fd);
00763
00764 { const char * sn = fn;
00765 if (!rpmtsChrootDone(ts) && rootDir != NULL &&
00766 !(rootDir[0] == '/' && rootDir[1] == '\0'))
00767 {
00768 sn += strlen(rootDir)-1;
00769 }
00770 argv[argc++] = sn;
00771 }
00772
00773 if (arg1 >= 0) {
00774 char *av = alloca(20);
00775 sprintf(av, "%d", arg1);
00776 argv[argc++] = av;
00777 }
00778 if (arg2 >= 0) {
00779 char *av = alloca(20);
00780 sprintf(av, "%d", arg2);
00781 argv[argc++] = av;
00782 }
00783 }
00784
00785 argv[argc] = NULL;
00786
00787 scriptFd = rpmtsScriptFd(ts);
00788 if (scriptFd != NULL) {
00789 if (rpmIsVerbose()) {
00790 out = fdDup(Fileno(scriptFd));
00791 } else {
00792 out = Fopen("/dev/null", "w.fdio");
00793 if (Ferror(out)) {
00794 out = fdDup(Fileno(scriptFd));
00795 }
00796 }
00797 } else {
00798 out = fdDup(STDOUT_FILENO);
00799 }
00800 if (out == NULL) return RPMRC_FAIL;
00801
00802
00803 xx = rpmsqFork(&psm->sq);
00804 if (psm->sq.child == 0) {
00805 const char * rootDir;
00806 int pipes[2];
00807 int flag;
00808 int fdno;
00809 int open_max;
00810
00811 pipes[0] = pipes[1] = 0;
00812
00813 xx = pipe(pipes);
00814 xx = close(pipes[1]);
00815 xx = dup2(pipes[0], STDIN_FILENO);
00816 xx = close(pipes[0]);
00817
00818
00819 open_max = sysconf(_SC_OPEN_MAX);
00820 if (open_max == -1) {
00821 open_max = 1024;
00822 }
00823 for (fdno = 3; fdno < open_max; fdno++) {
00824 flag = fcntl(fdno, F_GETFD);
00825 if (flag == -1 || (flag & FD_CLOEXEC))
00826 continue;
00827 xx = fcntl(fdno, F_SETFD, FD_CLOEXEC);
00828
00829 }
00830
00831 if (scriptFd != NULL) {
00832 int sfdno = Fileno(scriptFd);
00833 int ofdno = Fileno(out);
00834 if (sfdno != STDERR_FILENO)
00835 xx = dup2(sfdno, STDERR_FILENO);
00836 if (ofdno != STDOUT_FILENO)
00837 xx = dup2(ofdno, STDOUT_FILENO);
00838
00839 if (ofdno > STDERR_FILENO && ofdno != sfdno)
00840 xx = Fclose (out);
00841 if (sfdno > STDERR_FILENO && ofdno != sfdno)
00842 xx = Fclose (scriptFd);
00843 }
00844
00845 { const char *ipath = rpmExpand("PATH=%{_install_script_path}", NULL);
00846 const char *path = SCRIPT_PATH;
00847
00848 if (ipath && ipath[5] != '%')
00849 path = ipath;
00850
00851 xx = doputenv(path);
00852
00853 ipath = _free(ipath);
00854
00855 }
00856
00857 if (prefixes != NULL)
00858 for (i = 0; i < numPrefixes; i++) {
00859 sprintf(prefixBuf, "RPM_INSTALL_PREFIX%d=%s", i, prefixes[i]);
00860 xx = doputenv(prefixBuf);
00861
00862
00863 if (i == 0) {
00864 sprintf(prefixBuf, "RPM_INSTALL_PREFIX=%s", prefixes[i]);
00865 xx = doputenv(prefixBuf);
00866 }
00867 }
00868
00869 rootDir = ts->rootDir;
00870 if (rootDir != NULL)
00871 switch(urlIsURL(rootDir)) {
00872 case URL_IS_PATH:
00873 rootDir += sizeof("file://") - 1;
00874 rootDir = strchr(rootDir, '/');
00875
00876 case URL_IS_UNKNOWN:
00877 if (!rpmtsChrootDone(ts) &&
00878 !(rootDir[0] == '/' && rootDir[1] == '\0'))
00879 {
00880
00881 xx = chroot(rootDir);
00882
00883 }
00884 xx = chdir("/");
00885 rpmMessage(RPMMESS_DEBUG, _("%s: %s(%s-%s-%s.%s)\texecv(%s) pid %d\n"),
00886 psm->stepName, sln, n, v, r, a,
00887 argv[0], (unsigned)getpid());
00888
00889
00890 unsetenv("MALLOC_CHECK_");
00891
00892
00893 if (rpmtsSELinuxEnabled(ts) == 1) {
00894
00895 xx = rpm_execcon(0, argv[0], argv, environ);
00896
00897 if (xx != 0)
00898 break;
00899 }
00900
00901
00902 xx = execv(argv[0], (char *const *)argv);
00903
00904 break;
00905 case URL_IS_HTTPS:
00906 case URL_IS_HTTP:
00907 case URL_IS_FTP:
00908 case URL_IS_DASH:
00909 case URL_IS_HKP:
00910 default:
00911 break;
00912 }
00913
00914 _exit(-1);
00915
00916 }
00917
00918
00919 if (psm->sq.child == (pid_t)-1) {
00920 rpmError(RPMERR_FORK, _("Couldn't fork %s: %s\n"), sln, strerror(errno));
00921 rc = RPMRC_FAIL;
00922 goto exit;
00923 }
00924
00925 (void) psmWait(psm);
00926
00927
00928 if (!(psm->sq.reaped >= 0 && !strcmp(argv[0], "/usr/sbin/glibc_post_upgrade") && WEXITSTATUS(psm->sq.status) == 110)) {
00929 if (psm->sq.reaped < 0) {
00930 rpmError(RPMERR_SCRIPT,
00931 _("%s(%s-%s-%s.%s) scriptlet failed, waitpid(%d) rc %d: %s\n"),
00932 sln, n, v, r, a, psm->sq.child, psm->sq.reaped, strerror(errno));
00933 rc = RPMRC_FAIL;
00934 } else
00935 if (!WIFEXITED(psm->sq.status) || WEXITSTATUS(psm->sq.status)) {
00936 if (WIFSIGNALED(psm->sq.status)) {
00937 rpmError(RPMERR_SCRIPT,
00938 _("%s(%s-%s-%s.%s) scriptlet failed, signal %d\n"),
00939 sln, n, v, r, a, WTERMSIG(psm->sq.status));
00940 } else {
00941 rpmError(RPMERR_SCRIPT,
00942 _("%s(%s-%s-%s.%s) scriptlet failed, exit status %d\n"),
00943 sln, n, v, r, a, WEXITSTATUS(psm->sq.status));
00944 }
00945 rc = RPMRC_FAIL;
00946 }
00947 }
00948
00949 exit:
00950 if (freePrefixes) prefixes = hfd(prefixes, ipt);
00951
00952 xx = Fclose(out);
00953
00954
00955 if (script) {
00956 if (!rpmIsDebug())
00957 xx = unlink(fn);
00958 fn = _free(fn);
00959 }
00960
00961
00962 return rc;
00963 }
00964
00970 static rpmRC runInstScript(rpmpsm psm)
00971
00972
00973 {
00974 rpmfi fi = psm->fi;
00975 HGE_t hge = fi->hge;
00976 HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
00977 void ** progArgv;
00978 int progArgc;
00979 const char ** argv;
00980 rpmTagType ptt, stt;
00981 const char * script;
00982 rpmRC rc = RPMRC_OK;
00983 int xx;
00984
00985
00986
00987
00988
00989 xx = hge(fi->h, psm->scriptTag, &stt, (void **) &script, NULL);
00990 xx = hge(fi->h, psm->progTag, &ptt, (void **) &progArgv, &progArgc);
00991 if (progArgv == NULL && script == NULL)
00992 goto exit;
00993
00994
00995 if (progArgv && ptt == RPM_STRING_TYPE) {
00996 argv = alloca(sizeof(*argv));
00997 *argv = (const char *) progArgv;
00998 } else {
00999 argv = (const char **) progArgv;
01000 }
01001
01002
01003 if (fi->h != NULL)
01004 rc = runScript(psm, fi->h, tag2sln(psm->scriptTag), progArgc, argv,
01005 script, psm->scriptArg, -1);
01006
01007 exit:
01008 progArgv = hfd(progArgv, ptt);
01009 script = hfd(script, stt);
01010 return rc;
01011 }
01012
01023 static rpmRC handleOneTrigger(const rpmpsm psm,
01024 Header sourceH, Header triggeredH,
01025 int arg2, unsigned char * triggersAlreadyRun)
01026
01027
01028
01029 {
01030 int scareMem = 1;
01031 const rpmts ts = psm->ts;
01032 rpmfi fi = psm->fi;
01033 HGE_t hge = fi->hge;
01034 HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
01035 rpmds trigger = NULL;
01036 const char ** triggerScripts;
01037 const char ** triggerProgs;
01038 int_32 * triggerIndices;
01039 const char * sourceName;
01040 const char * triggerName;
01041 rpmRC rc = RPMRC_OK;
01042 int xx;
01043 int i;
01044
01045 xx = headerNVR(sourceH, &sourceName, NULL, NULL);
01046 xx = headerNVR(triggeredH, &triggerName, NULL, NULL);
01047
01048 trigger = rpmdsInit(rpmdsNew(triggeredH, RPMTAG_TRIGGERNAME, scareMem));
01049 if (trigger == NULL)
01050 return rc;
01051
01052 (void) rpmdsSetNoPromote(trigger, 1);
01053
01054 while ((i = rpmdsNext(trigger)) >= 0) {
01055 rpmTagType tit, tst, tpt;
01056 const char * Name;
01057 int_32 Flags = rpmdsFlags(trigger);
01058
01059 if ((Name = rpmdsN(trigger)) == NULL)
01060 continue;
01061
01062 if (strcmp(Name, sourceName))
01063 continue;
01064 if (!(Flags & psm->sense))
01065 continue;
01066
01067
01068
01069
01070 if (!rpmdsAnyMatchesDep(sourceH, trigger, 1))
01071 continue;
01072
01073 if (!( hge(triggeredH, RPMTAG_TRIGGERINDEX, &tit,
01074 (void **) &triggerIndices, NULL) &&
01075 hge(triggeredH, RPMTAG_TRIGGERSCRIPTS, &tst,
01076 (void **) &triggerScripts, NULL) &&
01077 hge(triggeredH, RPMTAG_TRIGGERSCRIPTPROG, &tpt,
01078 (void **) &triggerProgs, NULL))
01079 )
01080 continue;
01081
01082 { int arg1;
01083 int index;
01084
01085 arg1 = rpmdbCountPackages(rpmtsGetRdb(ts), triggerName);
01086 if (arg1 < 0) {
01087
01088 rc = RPMRC_FAIL;
01089 } else {
01090 arg1 += psm->countCorrection;
01091 index = triggerIndices[i];
01092 if (triggersAlreadyRun == NULL ||
01093 triggersAlreadyRun[index] == 0)
01094 {
01095 rc = runScript(psm, triggeredH, "%trigger", 1,
01096 triggerProgs + index, triggerScripts[index],
01097 arg1, arg2);
01098 if (triggersAlreadyRun != NULL)
01099 triggersAlreadyRun[index] = 1;
01100 }
01101 }
01102 }
01103
01104 triggerIndices = hfd(triggerIndices, tit);
01105 triggerScripts = hfd(triggerScripts, tst);
01106 triggerProgs = hfd(triggerProgs, tpt);
01107
01108
01109
01110
01111
01112 break;
01113 }
01114
01115 trigger = rpmdsFree(trigger);
01116
01117 return rc;
01118 }
01119
01125 static rpmRC runTriggers(rpmpsm psm)
01126
01127
01128
01129
01130 {
01131 const rpmts ts = psm->ts;
01132 rpmfi fi = psm->fi;
01133 int numPackage = -1;
01134 rpmRC rc = RPMRC_OK;
01135 const char * N = NULL;
01136
01137 if (psm->te)
01138 N = rpmteN(psm->te);
01139
01140 if (N)
01141 numPackage = rpmdbCountPackages(rpmtsGetRdb(ts), N)
01142 + psm->countCorrection;
01143 if (numPackage < 0)
01144 return RPMRC_NOTFOUND;
01145
01146 if (fi != NULL && fi->h != NULL)
01147 { Header triggeredH;
01148 rpmdbMatchIterator mi;
01149 int countCorrection = psm->countCorrection;
01150
01151 psm->countCorrection = 0;
01152 mi = rpmtsInitIterator(ts, RPMTAG_TRIGGERNAME, N, 0);
01153 while((triggeredH = rpmdbNextIterator(mi)) != NULL)
01154 rc |= handleOneTrigger(psm, fi->h, triggeredH, numPackage, NULL);
01155 mi = rpmdbFreeIterator(mi);
01156 psm->countCorrection = countCorrection;
01157 }
01158
01159 return rc;
01160 }
01161
01167 static rpmRC runImmedTriggers(rpmpsm psm)
01168
01169
01170
01171
01172 {
01173 const rpmts ts = psm->ts;
01174 rpmfi fi = psm->fi;
01175 HGE_t hge = fi->hge;
01176 HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
01177 const char ** triggerNames;
01178 int numTriggers;
01179 int_32 * triggerIndices;
01180 rpmTagType tnt, tit;
01181 int numTriggerIndices;
01182 unsigned char * triggersRun;
01183 rpmRC rc = RPMRC_OK;
01184
01185 if (fi->h == NULL) return rc;
01186
01187 if (!( hge(fi->h, RPMTAG_TRIGGERNAME, &tnt,
01188 (void **) &triggerNames, &numTriggers) &&
01189 hge(fi->h, RPMTAG_TRIGGERINDEX, &tit,
01190 (void **) &triggerIndices, &numTriggerIndices))
01191 )
01192 return rc;
01193
01194 triggersRun = alloca(sizeof(*triggersRun) * numTriggerIndices);
01195 memset(triggersRun, 0, sizeof(*triggersRun) * numTriggerIndices);
01196
01197 { Header sourceH = NULL;
01198 int i;
01199
01200 for (i = 0; i < numTriggers; i++) {
01201 rpmdbMatchIterator mi;
01202
01203 if (triggersRun[triggerIndices[i]] != 0) continue;
01204
01205 mi = rpmtsInitIterator(ts, RPMTAG_NAME, triggerNames[i], 0);
01206
01207 while((sourceH = rpmdbNextIterator(mi)) != NULL) {
01208 rc |= handleOneTrigger(psm, sourceH, fi->h,
01209 rpmdbGetIteratorCount(mi),
01210 triggersRun);
01211 }
01212
01213 mi = rpmdbFreeIterator(mi);
01214 }
01215 }
01216 triggerIndices = hfd(triggerIndices, tit);
01217 triggerNames = hfd(triggerNames, tnt);
01218 return rc;
01219 }
01220
01221 static const char *const pkgStageString(pkgStage a)
01222
01223 {
01224 switch(a) {
01225 case PSM_UNKNOWN: return "unknown";
01226
01227 case PSM_PKGINSTALL: return " install";
01228 case PSM_PKGERASE: return " erase";
01229 case PSM_PKGCOMMIT: return " commit";
01230 case PSM_PKGSAVE: return "repackage";
01231
01232 case PSM_INIT: return "init";
01233 case PSM_PRE: return "pre";
01234 case PSM_PROCESS: return "process";
01235 case PSM_POST: return "post";
01236 case PSM_UNDO: return "undo";
01237 case PSM_FINI: return "fini";
01238
01239 case PSM_CREATE: return "create";
01240 case PSM_NOTIFY: return "notify";
01241 case PSM_DESTROY: return "destroy";
01242 case PSM_COMMIT: return "commit";
01243
01244 case PSM_CHROOT_IN: return "chrootin";
01245 case PSM_CHROOT_OUT: return "chrootout";
01246 case PSM_SCRIPT: return "script";
01247 case PSM_TRIGGERS: return "triggers";
01248 case PSM_IMMED_TRIGGERS: return "immedtriggers";
01249
01250 case PSM_RPMIO_FLAGS: return "rpmioflags";
01251
01252 case PSM_RPMDB_LOAD: return "rpmdbload";
01253 case PSM_RPMDB_ADD: return "rpmdbadd";
01254 case PSM_RPMDB_REMOVE: return "rpmdbremove";
01255
01256 default: return "???";
01257 }
01258
01259 }
01260
01261 rpmpsm XrpmpsmUnlink(rpmpsm psm, const char * msg, const char * fn, unsigned ln)
01262 {
01263 if (psm == NULL) return NULL;
01264
01265 if (_psm_debug && msg != NULL)
01266 fprintf(stderr, "--> psm %p -- %d %s at %s:%u\n", psm, psm->nrefs, msg, fn, ln);
01267
01268 psm->nrefs--;
01269 return NULL;
01270 }
01271
01272 rpmpsm XrpmpsmLink(rpmpsm psm, const char * msg, const char * fn, unsigned ln)
01273 {
01274 if (psm == NULL) return NULL;
01275 psm->nrefs++;
01276
01277
01278 if (_psm_debug && msg != NULL)
01279 fprintf(stderr, "--> psm %p ++ %d %s at %s:%u\n", psm, psm->nrefs, msg, fn, ln);
01280
01281
01282 return psm;
01283 }
01284
01285 rpmpsm rpmpsmFree(rpmpsm psm)
01286 {
01287 const char * msg = "rpmpsmFree";
01288 if (psm == NULL)
01289 return NULL;
01290
01291 if (psm->nrefs > 1)
01292 return rpmpsmUnlink(psm, msg);
01293
01294
01295 psm->fi = rpmfiFree(psm->fi);
01296 #ifdef NOTYET
01297 psm->te = rpmteFree(psm->te);
01298 #else
01299 psm->te = NULL;
01300 #endif
01301
01302 psm->ts = rpmtsFree(psm->ts);
01303
01304
01305 (void) rpmpsmUnlink(psm, msg);
01306
01307
01308
01309 memset(psm, 0, sizeof(*psm));
01310
01311 psm = _free(psm);
01312
01313
01314 return NULL;
01315
01316 }
01317
01318 rpmpsm rpmpsmNew(rpmts ts, rpmte te, rpmfi fi)
01319 {
01320 const char * msg = "rpmpsmNew";
01321 rpmpsm psm = xcalloc(1, sizeof(*psm));
01322
01323 if (ts) psm->ts = rpmtsLink(ts, msg);
01324 #ifdef NOTYET
01325 if (te) psm->te = rpmteLink(te, msg);
01326 #else
01327
01328 if (te) psm->te = te;
01329
01330 #endif
01331 if (fi) psm->fi = rpmfiLink(fi, msg);
01332
01333 return rpmpsmLink(psm, msg);
01334 }
01335
01336 static void * rpmpsmThread(void * arg)
01337
01338
01339 {
01340 rpmpsm psm = arg;
01341
01342 return ((void *) rpmpsmStage(psm, psm->nstage));
01343
01344 }
01345
01346 static int rpmpsmNext(rpmpsm psm, pkgStage nstage)
01347
01348
01349 {
01350 psm->nstage = nstage;
01351 if (_psm_threads)
01352 return rpmsqJoin( rpmsqThread(rpmpsmThread, psm) );
01353 return rpmpsmStage(psm, psm->nstage);
01354 }
01355
01360
01361 rpmRC rpmpsmStage(rpmpsm psm, pkgStage stage)
01362 {
01363 const rpmts ts = psm->ts;
01364 uint_32 tscolor = rpmtsColor(ts);
01365 rpmfi fi = psm->fi;
01366 HGE_t hge = fi->hge;
01367 HFD_t hfd = (fi->hfd ? fi->hfd : headerFreeData);
01368 rpmRC rc = psm->rc;
01369 int saveerrno;
01370 int xx;
01371
01372
01373 switch (stage) {
01374 case PSM_UNKNOWN:
01375 break;
01376 case PSM_INIT:
01377 rpmMessage(RPMMESS_DEBUG, _("%s: %s has %d files, test = %d\n"),
01378 psm->stepName, rpmteNEVR(psm->te),
01379 rpmfiFC(fi), (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST));
01380
01381
01382
01383
01384
01385
01386 psm->npkgs_installed = rpmdbCountPackages(rpmtsGetRdb(ts), rpmteN(psm->te));
01387 if (psm->npkgs_installed < 0) {
01388 rc = RPMRC_FAIL;
01389 break;
01390 }
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401 if (rpmtsGetScore(ts) != NULL &&
01402 rpmtsGetType(ts) == RPMTRANS_TYPE_AUTOROLLBACK &&
01403 (psm->goal & ~(PSM_PKGSAVE|PSM_PKGERASE))) {
01404
01405
01406
01407 rpmtsScore score = rpmtsGetScore(ts);
01408 if (score != NULL) {
01409
01410
01411
01412 rpmtsScoreEntry se;
01413 se = rpmtsScoreGetEntry(score, rpmteN(psm->te));
01414
01415
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427 if (se && se->installed &&
01428 !se->erased &&
01429 (se->te_types & (TR_ADDED|TR_REMOVED)))
01430 psm->npkgs_installed--;
01431 }
01432 }
01433
01434 if (psm->goal == PSM_PKGINSTALL) {
01435 int fc = rpmfiFC(fi);
01436
01437 psm->scriptArg = psm->npkgs_installed + 1;
01438
01439 assert(psm->mi == NULL);
01440 psm->mi = rpmtsInitIterator(ts, RPMTAG_NAME, rpmteN(psm->te), 0);
01441 xx = rpmdbSetIteratorRE(psm->mi, RPMTAG_EPOCH, RPMMIRE_STRCMP,
01442 rpmteE(psm->te));
01443 xx = rpmdbSetIteratorRE(psm->mi, RPMTAG_VERSION, RPMMIRE_STRCMP,
01444 rpmteV(psm->te));
01445 xx = rpmdbSetIteratorRE(psm->mi, RPMTAG_RELEASE, RPMMIRE_STRCMP,
01446 rpmteR(psm->te));
01447 if (tscolor) {
01448 xx = rpmdbSetIteratorRE(psm->mi, RPMTAG_ARCH, RPMMIRE_STRCMP,
01449 rpmteA(psm->te));
01450 xx = rpmdbSetIteratorRE(psm->mi, RPMTAG_OS, RPMMIRE_STRCMP,
01451 rpmteO(psm->te));
01452 }
01453
01454 while ((psm->oh = rpmdbNextIterator(psm->mi)) != NULL) {
01455 fi->record = rpmdbGetIteratorOffset(psm->mi);
01456 psm->oh = NULL;
01457 break;
01458 }
01459 psm->mi = rpmdbFreeIterator(psm->mi);
01460 rc = RPMRC_OK;
01461
01462
01463 if (fi->fstates == NULL && fc > 0) {
01464 fi->fstates = xmalloc(sizeof(*fi->fstates) * fc);
01465 memset(fi->fstates, RPMFILE_STATE_NORMAL, fc);
01466 }
01467
01468 if (rpmtsFlags(ts) & RPMTRANS_FLAG_JUSTDB) break;
01469 if (fc <= 0) break;
01470
01471
01472
01473
01474
01475
01476 { const char * p;
01477 xx = hge(fi->h, RPMTAG_DEFAULTPREFIX, NULL, (void **) &p, NULL);
01478 fi->striplen = (xx ? strlen(p) + 1 : 1);
01479 }
01480 fi->mapflags =
01481 CPIO_MAP_PATH | CPIO_MAP_MODE | CPIO_MAP_UID | CPIO_MAP_GID | (fi->mapflags & CPIO_SBIT_CHECK);
01482
01483 if (headerIsEntry(fi->h, RPMTAG_ORIGBASENAMES))
01484 rpmfiBuildFNames(fi->h, RPMTAG_ORIGBASENAMES, &fi->apath, NULL);
01485 else
01486 rpmfiBuildFNames(fi->h, RPMTAG_BASENAMES, &fi->apath, NULL);
01487
01488 if (fi->fuser == NULL)
01489 xx = hge(fi->h, RPMTAG_FILEUSERNAME, NULL,
01490 (void **) &fi->fuser, NULL);
01491 if (fi->fgroup == NULL)
01492 xx = hge(fi->h, RPMTAG_FILEGROUPNAME, NULL,
01493 (void **) &fi->fgroup, NULL);
01494 rc = RPMRC_OK;
01495 }
01496 if (psm->goal == PSM_PKGERASE || psm->goal == PSM_PKGSAVE) {
01497 psm->scriptArg = psm->npkgs_installed - 1;
01498
01499
01500 rc = rpmpsmNext(psm, PSM_RPMDB_LOAD);
01501 if (rc == RPMRC_OK)
01502 if (psm->te)
01503 psm->te->h = headerLink(fi->h);
01504 }
01505 if (psm->goal == PSM_PKGSAVE) {
01506
01507 { const char * bfmt = rpmGetPath("%{_repackage_name_fmt}", NULL);
01508 const char * pkgbn =
01509 headerSprintf(fi->h, bfmt, rpmTagTable, rpmHeaderFormats, NULL);
01510
01511 bfmt = _free(bfmt);
01512 psm->pkgURL = rpmGenPath("%{?_repackage_root}",
01513 "%{?_repackage_dir}",
01514 pkgbn);
01515 pkgbn = _free(pkgbn);
01516 (void) urlPath(psm->pkgURL, &psm->pkgfn);
01517 psm->fd = Fopen(psm->pkgfn, "w.ufdio");
01518 if (psm->fd == NULL || Ferror(psm->fd)) {
01519 rc = RPMRC_FAIL;
01520 break;
01521 }
01522 }
01523 }
01524 break;
01525 case PSM_PRE:
01526 if (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST) break;
01527
01528
01529 #ifdef NOTYET
01530 { static int oneshot = 0;
01531 dbiIndex dbi;
01532 if (!oneshot) {
01533 dbi = dbiOpen(rpmtsGetRdb(ts), RPMTAG_TRIGGERNAME, 0);
01534 oneshot++;
01535 }
01536 }
01537 #endif
01538
01539
01540 rc = rpmpsmNext(psm, PSM_CHROOT_IN);
01541
01542 if (psm->goal == PSM_PKGINSTALL) {
01543 psm->scriptTag = RPMTAG_PREIN;
01544 psm->progTag = RPMTAG_PREINPROG;
01545 psm->sense = RPMSENSE_TRIGGERPREIN;
01546 psm->countCorrection = 0;
01547
01548 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERPREIN)) {
01549
01550
01551 rc = rpmpsmNext(psm, PSM_TRIGGERS);
01552 if (rc) break;
01553
01554
01555 rc = rpmpsmNext(psm, PSM_IMMED_TRIGGERS);
01556 if (rc) break;
01557 }
01558
01559 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOPRE)) {
01560 rc = rpmpsmNext(psm, PSM_SCRIPT);
01561 if (rc != RPMRC_OK) {
01562 rpmError(RPMERR_SCRIPT,
01563 _("%s: %s scriptlet failed (%d), skipping %s\n"),
01564 psm->stepName, tag2sln(psm->scriptTag), rc,
01565 rpmteNEVR(psm->te));
01566 break;
01567 }
01568 }
01569 }
01570
01571 if (psm->goal == PSM_PKGERASE) {
01572 psm->scriptTag = RPMTAG_PREUN;
01573 psm->progTag = RPMTAG_PREUNPROG;
01574 psm->sense = RPMSENSE_TRIGGERUN;
01575 psm->countCorrection = -1;
01576
01577 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERUN)) {
01578
01579 rc = rpmpsmNext(psm, PSM_IMMED_TRIGGERS);
01580 if (rc) break;
01581
01582
01583 rc = rpmpsmNext(psm, PSM_TRIGGERS);
01584 if (rc) break;
01585 }
01586
01587 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOPREUN))
01588 rc = rpmpsmNext(psm, PSM_SCRIPT);
01589 }
01590 if (psm->goal == PSM_PKGSAVE) {
01591 int noArchiveSize = 0;
01592
01593
01594 { void * uh = NULL;
01595 int_32 uht, uhc;
01596
01597 if (headerGetEntry(fi->h, RPMTAG_HEADERIMMUTABLE, &uht, &uh, &uhc)) {
01598 psm->oh = headerCopyLoad(uh);
01599 uh = hfd(uh, uht);
01600 } else
01601 if (headerGetEntry(fi->h, RPMTAG_HEADERIMAGE, &uht, &uh, &uhc))
01602 {
01603 HeaderIterator hi;
01604 int_32 tag, type, count;
01605 hPTR_t ptr;
01606 Header oh;
01607
01608
01609 oh = headerCopyLoad(uh);
01610
01611
01612 psm->oh = headerNew();
01613
01614
01615 for (hi = headerInitIterator(oh);
01616 headerNextIterator(hi, &tag, &type, &ptr, &count);
01617 ptr = headerFreeData((void *)ptr, type))
01618 {
01619 if (tag == RPMTAG_ARCHIVESIZE)
01620 noArchiveSize = 1;
01621 if (ptr) (void) headerAddEntry(psm->oh, tag, type, ptr, count);
01622 }
01623 hi = headerFreeIterator(hi);
01624
01625
01626 oh = headerFree(oh);
01627 uh = hfd(uh, uht);
01628 } else
01629 break;
01630 }
01631
01632
01633
01634 rc = rpmpsmNext(psm, PSM_RPMIO_FLAGS);
01635
01636
01637
01638 { int archnum = -1;
01639 int osnum = -1;
01640 struct rpmlead lead;
01641
01642 #ifndef DYING
01643 rpmGetArchInfo(NULL, &archnum);
01644 rpmGetOsInfo(NULL, &osnum);
01645 #endif
01646
01647 memset(&lead, 0, sizeof(lead));
01648
01649 lead.major = 3;
01650 lead.minor = 0;
01651 lead.type = RPMLEAD_BINARY;
01652 lead.archnum = archnum;
01653 lead.osnum = osnum;
01654 lead.signature_type = RPMSIGTYPE_HEADERSIG;
01655
01656 strncpy(lead.name, rpmteNEVR(psm->te), sizeof(lead.name));
01657
01658 rc = writeLead(psm->fd, &lead);
01659 if (rc != RPMRC_OK) {
01660 rpmError(RPMERR_NOSPACE, _("Unable to write package: %s\n"),
01661 Fstrerror(psm->fd));
01662 break;
01663 }
01664 }
01665
01666
01667
01668 { Header sigh = headerRegenSigHeader(fi->h, noArchiveSize);
01669
01670 sigh = headerReload(sigh, RPMTAG_HEADERSIGNATURES);
01671 if (sigh == NULL) {
01672 rpmError(RPMERR_NOSPACE, _("Unable to reload signature header\n"));
01673 rc = RPMRC_FAIL;
01674 break;
01675 }
01676 rc = rpmWriteSignature(psm->fd, sigh);
01677 sigh = rpmFreeSignature(sigh);
01678 if (rc) break;
01679 }
01680
01681
01682 if (psm->oh != NULL)
01683 { int_32 tid = rpmtsGetTid(ts);
01684 xx = headerAddEntry(psm->oh, RPMTAG_REMOVETID,
01685 RPM_INT32_TYPE, &tid, 1);
01686 }
01687
01688
01689 rc = headerWrite(psm->fd, psm->oh, HEADER_MAGIC_YES);
01690 if (rc) break;
01691 }
01692 break;
01693 case PSM_PROCESS:
01694 if (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST) break;
01695
01696 if (psm->goal == PSM_PKGINSTALL) {
01697
01698 if (rpmtsFlags(ts) & RPMTRANS_FLAG_JUSTDB) break;
01699
01700
01701 if (rpmfiFC(fi) <= 0) {
01702 void * ptr;
01703 ptr = rpmtsNotify(ts, fi->te, RPMCALLBACK_INST_START, 0, 100);
01704 ptr = rpmtsNotify(ts, fi->te, RPMCALLBACK_INST_PROGRESS, 100, 100);
01705 break;
01706 }
01707
01708
01709 rc = rpmpsmNext(psm, PSM_RPMIO_FLAGS);
01710
01711 if (rpmteFd(fi->te) == NULL) {
01712 rc = RPMRC_FAIL;
01713 break;
01714 }
01715
01716
01717 psm->cfd = Fdopen(fdDup(Fileno(rpmteFd(fi->te))), psm->rpmio_flags);
01718
01719 if (psm->cfd == NULL) {
01720 rc = RPMRC_FAIL;
01721 break;
01722 }
01723
01724 rc = fsmSetup(fi->fsm, FSM_PKGINSTALL, ts, fi,
01725 psm->cfd, NULL, &psm->failedFile);
01726 (void) rpmswAdd(rpmtsOp(ts, RPMTS_OP_UNCOMPRESS),
01727 fdstat_op(psm->cfd, FDSTAT_READ));
01728 (void) rpmswAdd(rpmtsOp(ts, RPMTS_OP_DIGEST),
01729 fdstat_op(psm->cfd, FDSTAT_DIGEST));
01730 xx = fsmTeardown(fi->fsm);
01731
01732 saveerrno = errno;
01733 xx = Fclose(psm->cfd);
01734 psm->cfd = NULL;
01735
01736 errno = saveerrno;
01737
01738
01739 if (!rc)
01740 rc = rpmpsmNext(psm, PSM_COMMIT);
01741
01742
01743 psm->what = RPMCALLBACK_INST_PROGRESS;
01744 psm->amount = (fi->archiveSize ? fi->archiveSize : 100);
01745 psm->total = psm->amount;
01746 xx = rpmpsmNext(psm, PSM_NOTIFY);
01747
01748 if (rc) {
01749 rpmError(RPMERR_CPIO,
01750 _("unpacking of archive failed%s%s: %s\n"),
01751 (psm->failedFile != NULL ? _(" on file ") : ""),
01752 (psm->failedFile != NULL ? psm->failedFile : ""),
01753 cpioStrerror(rc));
01754 rc = RPMRC_FAIL;
01755
01756
01757 psm->what = RPMCALLBACK_UNPACK_ERROR;
01758 psm->amount = 0;
01759 psm->total = 0;
01760 xx = rpmpsmNext(psm, PSM_NOTIFY);
01761
01762 break;
01763 }
01764 }
01765 if (psm->goal == PSM_PKGERASE) {
01766 int fc = rpmfiFC(fi);
01767
01768 if (rpmtsFlags(ts) & RPMTRANS_FLAG_JUSTDB) break;
01769 if (rpmtsFlags(ts) & RPMTRANS_FLAG_APPLYONLY) break;
01770
01771
01772 if (rpmfiFC(fi) <= 0) {
01773 void * ptr;
01774 ptr = rpmtsNotify(ts, fi->te, RPMCALLBACK_UNINST_START, 0, 100);
01775 ptr = rpmtsNotify(ts, fi->te, RPMCALLBACK_UNINST_STOP, 0, 100);
01776 break;
01777 }
01778
01779 psm->what = RPMCALLBACK_UNINST_START;
01780 psm->amount = fc;
01781 psm->total = fc;
01782 xx = rpmpsmNext(psm, PSM_NOTIFY);
01783
01784 rc = fsmSetup(fi->fsm, FSM_PKGERASE, ts, fi,
01785 NULL, NULL, &psm->failedFile);
01786 xx = fsmTeardown(fi->fsm);
01787
01788 psm->what = RPMCALLBACK_UNINST_STOP;
01789 psm->amount = 0;
01790 psm->total = fc;
01791 xx = rpmpsmNext(psm, PSM_NOTIFY);
01792
01793 }
01794 if (psm->goal == PSM_PKGSAVE) {
01795 fileAction * actions = fi->actions;
01796 fileAction action = fi->action;
01797
01798 fi->action = FA_COPYOUT;
01799 fi->actions = NULL;
01800
01801 if (psm->fd == NULL) {
01802 rc = RPMRC_FAIL;
01803 break;
01804 }
01805
01806 xx = Fflush(psm->fd);
01807 psm->cfd = Fdopen(fdDup(Fileno(psm->fd)), psm->rpmio_flags);
01808
01809 if (psm->cfd == NULL) {
01810 rc = RPMRC_FAIL;
01811 break;
01812 }
01813
01814 rc = fsmSetup(fi->fsm, FSM_PKGBUILD, ts, fi, psm->cfd,
01815 NULL, &psm->failedFile);
01816 (void) rpmswAdd(rpmtsOp(ts, RPMTS_OP_COMPRESS),
01817 fdstat_op(psm->cfd, FDSTAT_WRITE));
01818 (void) rpmswAdd(rpmtsOp(ts, RPMTS_OP_DIGEST),
01819 fdstat_op(psm->cfd, FDSTAT_DIGEST));
01820 xx = fsmTeardown(fi->fsm);
01821
01822 saveerrno = errno;
01823 xx = Fclose(psm->cfd);
01824 psm->cfd = NULL;
01825
01826 errno = saveerrno;
01827
01828
01829
01830 psm->what = RPMCALLBACK_INST_PROGRESS;
01831 psm->amount = (fi->archiveSize ? fi->archiveSize : 100);
01832 psm->total = psm->amount;
01833 xx = rpmpsmNext(psm, PSM_NOTIFY);
01834
01835 fi->action = action;
01836 fi->actions = actions;
01837 }
01838 break;
01839 case PSM_POST:
01840 if (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST) break;
01841
01842 if (psm->goal == PSM_PKGINSTALL) {
01843 int_32 installTime = (int_32) time(NULL);
01844 int fc = rpmfiFC(fi);
01845
01846 if (fi->h == NULL) break;
01847 if (fi->fstates != NULL && fc > 0)
01848 xx = headerAddEntry(fi->h, RPMTAG_FILESTATES, RPM_CHAR_TYPE,
01849 fi->fstates, fc);
01850
01851 xx = headerAddEntry(fi->h, RPMTAG_INSTALLTIME, RPM_INT32_TYPE,
01852 &installTime, 1);
01853
01854 xx = headerAddEntry(fi->h, RPMTAG_INSTALLCOLOR, RPM_INT32_TYPE,
01855 &tscolor, 1);
01856
01857
01858
01859
01860
01861 if (fi->record && !(rpmtsFlags(ts) & RPMTRANS_FLAG_APPLYONLY)) {
01862 rc = rpmpsmNext(psm, PSM_RPMDB_REMOVE);
01863 if (rc) break;
01864 }
01865
01866 rc = rpmpsmNext(psm, PSM_RPMDB_ADD);
01867 if (rc) break;
01868
01869 psm->scriptTag = RPMTAG_POSTIN;
01870 psm->progTag = RPMTAG_POSTINPROG;
01871 psm->sense = RPMSENSE_TRIGGERIN;
01872 psm->countCorrection = 0;
01873
01874 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOPOST)) {
01875 rc = rpmpsmNext(psm, PSM_SCRIPT);
01876 if (rc) break;
01877 }
01878 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERIN)) {
01879
01880 rc = rpmpsmNext(psm, PSM_TRIGGERS);
01881 if (rc) break;
01882
01883
01884 rc = rpmpsmNext(psm, PSM_IMMED_TRIGGERS);
01885 if (rc) break;
01886 }
01887
01888 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_APPLYONLY))
01889 rc = markReplacedFiles(psm);
01890
01891 }
01892 if (psm->goal == PSM_PKGERASE) {
01893
01894 psm->scriptTag = RPMTAG_POSTUN;
01895 psm->progTag = RPMTAG_POSTUNPROG;
01896 psm->sense = RPMSENSE_TRIGGERPOSTUN;
01897 psm->countCorrection = -1;
01898
01899 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOPOSTUN)) {
01900 rc = rpmpsmNext(psm, PSM_SCRIPT);
01901 if (rc) break;
01902 }
01903
01904 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERPOSTUN)) {
01905
01906 rc = rpmpsmNext(psm, PSM_TRIGGERS);
01907 if (rc) break;
01908 }
01909
01910 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_APPLYONLY))
01911 rc = rpmpsmNext(psm, PSM_RPMDB_REMOVE);
01912 }
01913 if (psm->goal == PSM_PKGSAVE) {
01914 }
01915
01916
01917 xx = rpmpsmNext(psm, PSM_CHROOT_OUT);
01918 break;
01919 case PSM_UNDO:
01920 break;
01921 case PSM_FINI:
01922
01923 xx = rpmpsmNext(psm, PSM_CHROOT_OUT);
01924
01925 if (psm->fd != NULL) {
01926 saveerrno = errno;
01927 xx = Fclose(psm->fd);
01928 psm->fd = NULL;
01929
01930 errno = saveerrno;
01931
01932 }
01933
01934 if (psm->goal == PSM_PKGSAVE) {
01935 if (!rc && ts && ts->notify == NULL) {
01936 rpmMessage(RPMMESS_VERBOSE, _("Wrote: %s\n"),
01937 (psm->pkgURL ? psm->pkgURL : "???"));
01938 }
01939 }
01940
01941 if (rc) {
01942 if (psm->failedFile)
01943 rpmError(RPMERR_CPIO,
01944 _("%s failed on file %s: %s\n"),
01945 psm->stepName, psm->failedFile, cpioStrerror(rc));
01946 else
01947 rpmError(RPMERR_CPIO, _("%s failed: %s\n"),
01948 psm->stepName, cpioStrerror(rc));
01949
01950
01951 psm->what = RPMCALLBACK_CPIO_ERROR;
01952 psm->amount = 0;
01953 psm->total = 0;
01954
01955 xx = rpmpsmNext(psm, PSM_NOTIFY);
01956
01957 }
01958
01959
01960 if (psm->goal == PSM_PKGERASE || psm->goal == PSM_PKGSAVE) {
01961 if (psm->te != NULL)
01962 if (psm->te->h != NULL)
01963 psm->te->h = headerFree(psm->te->h);
01964 if (fi->h != NULL)
01965 fi->h = headerFree(fi->h);
01966 }
01967
01968 psm->oh = headerFree(psm->oh);
01969 psm->pkgURL = _free(psm->pkgURL);
01970 psm->rpmio_flags = _free(psm->rpmio_flags);
01971 psm->failedFile = _free(psm->failedFile);
01972
01973 fi->fgroup = hfd(fi->fgroup, -1);
01974 fi->fuser = hfd(fi->fuser, -1);
01975 fi->apath = _free(fi->apath);
01976 fi->fstates = _free(fi->fstates);
01977 break;
01978
01979 case PSM_PKGINSTALL:
01980 case PSM_PKGERASE:
01981 case PSM_PKGSAVE:
01982 psm->goal = stage;
01983 psm->rc = RPMRC_OK;
01984 psm->stepName = pkgStageString(stage);
01985
01986 rc = rpmpsmNext(psm, PSM_INIT);
01987 if (!rc) rc = rpmpsmNext(psm, PSM_PRE);
01988 if (!rc) rc = rpmpsmNext(psm, PSM_PROCESS);
01989 if (!rc) rc = rpmpsmNext(psm, PSM_POST);
01990 xx = rpmpsmNext(psm, PSM_FINI);
01991 break;
01992 case PSM_PKGCOMMIT:
01993 break;
01994
01995 case PSM_CREATE:
01996 break;
01997 case PSM_NOTIFY:
01998 { void * ptr;
01999
02000 ptr = rpmtsNotify(ts, psm->te, psm->what, psm->amount, psm->total);
02001
02002 } break;
02003 case PSM_DESTROY:
02004 break;
02005 case PSM_COMMIT:
02006 if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_PKGCOMMIT)) break;
02007 if (rpmtsFlags(ts) & RPMTRANS_FLAG_APPLYONLY) break;
02008
02009 rc = fsmSetup(fi->fsm, FSM_PKGCOMMIT, ts, fi,
02010 NULL, NULL, &psm->failedFile);
02011 xx = fsmTeardown(fi->fsm);
02012 break;
02013
02014 case PSM_CHROOT_IN:
02015 { const char * rootDir = rpmtsRootDir(ts);
02016
02017 if (rootDir != NULL && !(rootDir[0] == '/' && rootDir[1] == '\0')
02018 && !rpmtsChrootDone(ts) && !psm->chrootDone)
02019 {
02020 static int _pw_loaded = 0;
02021 static int _gr_loaded = 0;
02022
02023 if (!_pw_loaded) {
02024 (void)getpwnam("root");
02025 endpwent();
02026 _pw_loaded++;
02027 }
02028 if (!_gr_loaded) {
02029 (void)getgrnam("root");
02030 endgrent();
02031 _gr_loaded++;
02032 }
02033
02034 xx = chdir("/");
02035
02036 if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/')
02037 rc = chroot(rootDir);
02038
02039 psm->chrootDone = 1;
02040 (void) rpmtsSetChrootDone(ts, 1);
02041 }
02042 } break;
02043 case PSM_CHROOT_OUT:
02044
02045 if (psm->chrootDone) {
02046 const char * rootDir = rpmtsRootDir(ts);
02047 const char * currDir = rpmtsCurrDir(ts);
02048
02049 if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/')
02050 rc = chroot(".");
02051
02052 psm->chrootDone = 0;
02053 (void) rpmtsSetChrootDone(ts, 0);
02054 if (currDir != NULL)
02055 xx = chdir(currDir);
02056 }
02057 break;
02058 case PSM_SCRIPT:
02059 rc = runInstScript(psm);
02060 break;
02061 case PSM_TRIGGERS:
02062
02063 rc = runTriggers(psm);
02064 break;
02065 case PSM_IMMED_TRIGGERS:
02066
02067 rc = runImmedTriggers(psm);
02068 break;
02069
02070 case PSM_RPMIO_FLAGS:
02071 { const char * payload_compressor = NULL;
02072 char * t;
02073
02074
02075 if (!hge(fi->h, RPMTAG_PAYLOADCOMPRESSOR, NULL,
02076 (void **) &payload_compressor, NULL))
02077 payload_compressor = "gzip";
02078
02079 psm->rpmio_flags = t = xmalloc(sizeof("w9.gzdio"));
02080 *t = '\0';
02081 t = stpcpy(t, ((psm->goal == PSM_PKGSAVE) ? "w9" : "r"));
02082 if (!strcmp(payload_compressor, "gzip"))
02083 t = stpcpy(t, ".gzdio");
02084 if (!strcmp(payload_compressor, "bzip2"))
02085 t = stpcpy(t, ".bzdio");
02086 rc = RPMRC_OK;
02087 } break;
02088
02089 case PSM_RPMDB_LOAD:
02090 assert(psm->mi == NULL);
02091 psm->mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES,
02092 &fi->record, sizeof(fi->record));
02093
02094 fi->h = rpmdbNextIterator(psm->mi);
02095 if (fi->h != NULL)
02096 fi->h = headerLink(fi->h);
02097
02098 psm->mi = rpmdbFreeIterator(psm->mi);
02099 rc = (fi->h != NULL ? RPMRC_OK : RPMRC_FAIL);
02100 break;
02101 case PSM_RPMDB_ADD:
02102 if (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST) break;
02103 if (fi->h == NULL) break;
02104 (void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_DBADD), 0);
02105 if (!(rpmtsVSFlags(ts) & RPMVSF_NOHDRCHK))
02106 rc = rpmdbAdd(rpmtsGetRdb(ts), rpmtsGetTid(ts), fi->h,
02107 ts, headerCheck);
02108 else
02109 rc = rpmdbAdd(rpmtsGetRdb(ts), rpmtsGetTid(ts), fi->h,
02110 NULL, NULL);
02111
02112
02113
02114
02115 rpmteSetDBInstance(psm->te, myinstall_instance);
02116
02117
02118
02119
02120
02121 if (rpmtsGetScore(ts) != NULL &&
02122 rpmtsGetType(ts) != RPMTRANS_TYPE_ROLLBACK &&
02123 rpmtsGetType(ts) != RPMTRANS_TYPE_AUTOROLLBACK)
02124 {
02125
02126
02127
02128 rpmtsScore score = rpmtsGetScore(ts);
02129 if (score != NULL) {
02130 rpmtsScoreEntry se;
02131
02132
02133
02134 rpmMessage(RPMMESS_DEBUG,
02135 _("Attempting to mark %s as installed in score board(%u).\n"),
02136 rpmteN(psm->te), (unsigned) score);
02137 se = rpmtsScoreGetEntry(score, rpmteN(psm->te));
02138 if (se != NULL) se->installed = 1;
02139 }
02140 }
02141 (void) rpmswExit(rpmtsOp(ts, RPMTS_OP_DBADD), 0);
02142 break;
02143 case PSM_RPMDB_REMOVE:
02144 if (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST) break;
02145 (void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_DBREMOVE), 0);
02146 rc = rpmdbRemove(rpmtsGetRdb(ts), rpmtsGetTid(ts), fi->record,
02147 NULL, NULL);
02148
02149
02150
02151
02152
02153 if (rpmtsGetScore(ts) != NULL &&
02154 rpmtsGetType(ts) != RPMTRANS_TYPE_ROLLBACK &&
02155 rpmtsGetType(ts) != RPMTRANS_TYPE_AUTOROLLBACK)
02156 {
02157
02158
02159
02160 rpmtsScore score = rpmtsGetScore(ts);
02161
02162 if (score != NULL) {
02163 rpmtsScoreEntry se;
02164
02165
02166
02167 rpmMessage(RPMMESS_DEBUG,
02168 _("Attempting to mark %s as erased in score board(0x%x).\n"),
02169 rpmteN(psm->te), (unsigned) score);
02170 se = rpmtsScoreGetEntry(score, rpmteN(psm->te));
02171 if (se != NULL) se->erased = 1;
02172 }
02173 }
02174
02175 (void) rpmswExit(rpmtsOp(ts, RPMTS_OP_DBREMOVE), 0);
02176 break;
02177
02178 default:
02179 break;
02180 }
02181
02182
02183
02184 return rc;
02185
02186 }
02187