00001
00005 #include "system.h"
00006
00007 #include <rpmio.h>
00008 #include <rpmcb.h>
00009 #include <rpmmacro.h>
00010 #include <rpmlib.h>
00011 #include <rpmte.h>
00012 #include <pkgio.h>
00013
00014 #define _RPMGI_INTERNAL
00015 #define _RPMTS_INTERNAL
00016 #include <rpmgi.h>
00017
00018 #include <rpmdb.h>
00019 #include "manifest.h"
00020
00021 #include "debug.h"
00022
00023
00024
00025
00026
00027
00028
00031
00032 int _rpmgi_debug = 0;
00033
00036
00037 rpmgiFlags giFlags = RPMGI_NONE;
00038
00041
00042 static int indent = 2;
00043
00046
00047 static const char * ftsInfoStrings[] = {
00048 "UNKNOWN",
00049 "D",
00050 "DC",
00051 "DEFAULT",
00052 "DNR",
00053 "DOT",
00054 "DP",
00055 "ERR",
00056 "F",
00057 "INIT",
00058 "NS",
00059 "NSOK",
00060 "SL",
00061 "SLNONE",
00062 "W",
00063 };
00064
00067
00068 static const char * ftsInfoStr(int fts_info)
00069
00070 {
00071
00072 if (!(fts_info >= 1 && fts_info <= 14))
00073 fts_info = 0;
00074
00075 return ftsInfoStrings[ fts_info ];
00076
00077 }
00078
00086
00087 static FD_t rpmgiOpen(const char * path, const char * fmode)
00088
00089
00090 {
00091 const char * fn = rpmExpand(path, NULL);
00092 FD_t fd;
00093
00094
00095 errno = 0;
00096 fd = Fopen(fn, fmode);
00097
00098 if (fd == NULL || Ferror(fd)) {
00099 rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), fn, Fstrerror(fd));
00100 if (fd != NULL) (void) Fclose(fd);
00101 fd = NULL;
00102 }
00103 fn = _free(fn);
00104
00105 return fd;
00106 }
00107
00114 static rpmRC rpmgiLoadManifest(rpmgi gi, const char * path)
00115
00116
00117 {
00118 FD_t fd = rpmgiOpen(path, "r%{?_rpmgio}");
00119 rpmRC rpmrc = RPMRC_FAIL;
00120
00121 if (fd != NULL) {
00122 rpmrc = rpmReadPackageManifest(fd, &gi->argc, &gi->argv);
00123 (void) Fclose(fd);
00124 }
00125 return rpmrc;
00126 }
00127
00134
00135 static Header rpmgiReadHeader(rpmgi gi, const char * path)
00136
00137
00138 {
00139 FD_t fd = rpmgiOpen(path, "r%{?_rpmgio}");
00140 Header h = NULL;
00141
00142 if (fd != NULL) {
00143
00144 rpmRC rpmrc = rpmReadPackageFile(gi->ts, fd, path, &h);
00145
00146 (void) Fclose(fd);
00147
00148 switch (rpmrc) {
00149 case RPMRC_NOTFOUND:
00150
00151 case RPMRC_FAIL:
00152 default:
00153 h = headerFree(h);
00154 break;
00155 case RPMRC_NOTTRUSTED:
00156 case RPMRC_NOKEY:
00157 case RPMRC_OK:
00158 break;
00159 }
00160 }
00161
00162 return h;
00163 }
00164
00170 static rpmRC rpmgiLoadNextKey(rpmgi gi)
00171
00172 {
00173 rpmRC rpmrc = RPMRC_NOTFOUND;
00174 if (gi->argv != NULL && gi->argv[gi->i] != NULL) {
00175 gi->keyp = gi->argv[gi->i];
00176 gi->keylen = 0;
00177 rpmrc = RPMRC_OK;
00178 } else {
00179 gi->i = -1;
00180 gi->keyp = NULL;
00181 gi->keylen = 0;
00182 }
00183 return rpmrc;
00184 }
00185
00194 static rpmRC rpmgiLoadReadHeader(rpmgi gi)
00195
00196
00197 {
00198 rpmRC rpmrc = RPMRC_NOTFOUND;
00199 Header h = NULL;
00200
00201 if (gi->argv != NULL && gi->argv[gi->i] != NULL)
00202 do {
00203 const char * fn;
00204
00205 fn = gi->argv[gi->i];
00206 if (!(gi->flags & RPMGI_NOHEADER)) {
00207 h = rpmgiReadHeader(gi, fn);
00208 if (h != NULL)
00209 rpmrc = RPMRC_OK;
00210 } else
00211 rpmrc = RPMRC_OK;
00212
00213 if (rpmrc == RPMRC_OK || gi->flags & RPMGI_NOMANIFEST)
00214 break;
00215 if (errno == ENOENT)
00216 break;
00217
00218
00219 gi->argv[gi->i] = NULL;
00220 rpmrc = rpmgiLoadManifest(gi, fn);
00221 if (rpmrc != RPMRC_OK) {
00222 gi->argv[gi->i] = fn;
00223 break;
00224 }
00225 fn = _free(fn);
00226 rpmrc = RPMRC_NOTFOUND;
00227 } while (1);
00228
00229 if (rpmrc == RPMRC_OK && h != NULL)
00230 gi->h = headerLink(h);
00231 h = headerFree(h);
00232
00233 return rpmrc;
00234 }
00235
00241
00242 static rpmRC rpmgiWalkPathFilter(rpmgi gi)
00243
00244 {
00245 FTSENT * fts = gi->fts;
00246 rpmRC rpmrc = RPMRC_NOTFOUND;
00247 const char * s;
00248
00249 if (_rpmgi_debug < 0)
00250 rpmlog(RPMLOG_DEBUG, "FTS_%s\t%*s %s%s\n", ftsInfoStr(fts->fts_info),
00251 indent * (fts->fts_level < 0 ? 0 : fts->fts_level), "",
00252 fts->fts_name,
00253 ((fts->fts_info == FTS_D || fts->fts_info == FTS_DP) ? "/" : ""));
00254
00255 switch (fts->fts_info) {
00256 case FTS_D:
00257 break;
00258 case FTS_DP:
00259 break;
00260 case FTS_F:
00261
00262 s = fts->fts_name + fts->fts_namelen + 1 - sizeof(".rpm");
00263 if (strcmp(s, ".rpm"))
00264 break;
00265 rpmrc = RPMRC_OK;
00266 break;
00267 case FTS_NS:
00268 case FTS_DNR:
00269 case FTS_ERR:
00270 break;
00271 case FTS_DC:
00272 case FTS_DEFAULT:
00273 case FTS_DOT:
00274 case FTS_INIT:
00275 case FTS_NSOK:
00276 case FTS_SL:
00277 case FTS_SLNONE:
00278 case FTS_W:
00279 default:
00280 break;
00281 }
00282 return rpmrc;
00283 }
00284
00290
00291 static rpmRC rpmgiWalkReadHeader(rpmgi gi)
00292
00293
00294 {
00295 rpmRC rpmrc = RPMRC_NOTFOUND;
00296
00297 if (gi->ftsp != NULL)
00298 while ((gi->fts = Fts_read(gi->ftsp)) != NULL) {
00299 if (gi->walkPathFilter)
00300 rpmrc = (*gi->walkPathFilter) (gi);
00301 else
00302 rpmrc = rpmgiWalkPathFilter(gi);
00303 if (rpmrc == RPMRC_OK)
00304 break;
00305 }
00306
00307 if (rpmrc == RPMRC_OK) {
00308 Header h = NULL;
00309 if (!(gi->flags & RPMGI_NOHEADER)) {
00310
00311 if (gi->fts != NULL)
00312 h = rpmgiReadHeader(gi, gi->fts->fts_path);
00313 }
00314 if (h != NULL) {
00315 gi->h = headerLink(h);
00316 h = headerFree(h);
00317
00318 if (gi->stash != NULL)
00319 (void) (*gi->stash) (gi, gi->h);
00320
00321 }
00322 }
00323
00324 return rpmrc;
00325 }
00326
00327 const char * rpmgiEscapeSpaces(const char * s)
00328 {
00329 const char * se;
00330 const char * t;
00331 char * te;
00332 size_t nb = 0;
00333
00334 for (se = s; *se; se++) {
00335 if (isspace(*se))
00336 nb++;
00337 nb++;
00338 }
00339 nb++;
00340
00341 t = te = xmalloc(nb);
00342 for (se = s; *se; se++) {
00343 if (isspace(*se))
00344 *te++ = '\\';
00345 *te++ = *se;
00346 }
00347 *te = '\0';
00348 return t;
00349 }
00350
00357 static rpmRC rpmgiGlobArgv(rpmgi gi, ARGV_t argv)
00358
00359
00360 {
00361 const char * arg;
00362 rpmRC rpmrc = RPMRC_OK;
00363 int ac = 0;
00364 int xx;
00365
00366
00367 if ((gi->flags & RPMGI_NOGLOB)
00368 || !(gi->tag == RPMDBI_HDLIST || gi->tag == RPMDBI_ARGLIST || gi->tag == RPMDBI_FTSWALK))
00369 {
00370 if (argv != NULL) {
00371 while (argv[ac] != NULL)
00372 ac++;
00373
00374 xx = argvAppend(&gi->argv, argv);
00375
00376 }
00377 gi->argc = ac;
00378 return rpmrc;
00379 }
00380
00381 if (argv != NULL)
00382 while ((arg = *argv++) != NULL) {
00383 const char * t = rpmgiEscapeSpaces(arg);
00384 ARGV_t av = NULL;
00385
00386 xx = rpmGlob(t, &ac, &av);
00387 xx = argvAppend(&gi->argv, av);
00388 gi->argc += ac;
00389 av = argvFree(av);
00390 t = _free(t);
00391 ac = 0;
00392 }
00393 return rpmrc;
00394 }
00395
00401 static rpmRC rpmgiInitFilter(rpmgi gi)
00402
00403
00404 {
00405 rpmRC rpmrc = RPMRC_OK;
00406 ARGV_t av;
00407 int res = 0;
00408
00409 gi->mi = rpmtsInitIterator(gi->ts, gi->tag, gi->keyp, gi->keylen);
00410
00411 if (_rpmgi_debug < 0)
00412 fprintf(stderr, "*** gi %p key %p[%d]\tmi %p\n", gi, gi->keyp, (int)gi->keylen, gi->mi);
00413
00414 if (gi->argv != NULL)
00415 for (av = (const char **) gi->argv; *av != NULL; av++) {
00416 if (gi->tag == RPMDBI_PACKAGES) {
00417 int tag = RPMTAG_NAME;
00418 const char * pat;
00419 char * a, * ae;
00420
00421 pat = a = xstrdup(*av);
00422 tag = RPMTAG_NAME;
00423
00424
00425 if ((ae = strchr(a, '=')) != NULL) {
00426 *ae++ = '\0';
00427 if (*a != '\0') {
00428 tag = tagValue(a);
00429 if (tag < 0) {
00430 rpmlog(RPMLOG_NOTICE, _("unknown tag: \"%s\"\n"), a);
00431 res = 1;
00432 }
00433 }
00434 pat = ae;
00435 }
00436 if (!res) {
00437 if (_rpmgi_debug < 0)
00438 fprintf(stderr, "\tav %p[%d]: \"%s\" -> %s ~= \"%s\"\n", gi->argv, (int)(av - gi->argv), *av, tagName(tag), pat);
00439 res = rpmdbSetIteratorRE(gi->mi, tag, RPMMIRE_DEFAULT, pat);
00440 }
00441 a = _free(a);
00442 }
00443
00444 if (res == 0)
00445 continue;
00446
00447 gi->mi = rpmdbFreeIterator(gi->mi);
00448 rpmrc = RPMRC_FAIL;
00449 break;
00450 }
00451
00452 return rpmrc;
00453 }
00454
00455 rpmgi XrpmgiUnlink(rpmgi gi, const char * msg, const char * fn, unsigned ln)
00456 {
00457 if (gi == NULL) return NULL;
00458
00459 if (_rpmgi_debug && msg != NULL)
00460 fprintf(stderr, "--> gi %p -- %d %s(%s) at %s:%u\n", gi, gi->nrefs, msg, tagName(gi->tag), fn, ln);
00461
00462 gi->nrefs--;
00463 return NULL;
00464 }
00465
00466 rpmgi XrpmgiLink(rpmgi gi, const char * msg, const char * fn, unsigned ln)
00467 {
00468 if (gi == NULL) return NULL;
00469 gi->nrefs++;
00470
00471 if (_rpmgi_debug && msg != NULL)
00472 fprintf(stderr, "--> gi %p ++ %d %s(%s) at %s:%u\n", gi, gi->nrefs, msg, tagName(gi->tag), fn, ln);
00473
00474 return gi;
00475 }
00476
00477 rpmgi rpmgiFree(rpmgi gi)
00478 {
00479 if (gi == NULL)
00480 return NULL;
00481
00482 if (gi->nrefs > 1)
00483 return rpmgiUnlink(gi, "rpmgiFree");
00484
00485 (void) rpmgiUnlink(gi, "rpmgiFree");
00486
00487
00488
00489 gi->hdrPath = _free(gi->hdrPath);
00490 gi->h = headerFree(gi->h);
00491
00492 gi->argv = argvFree(gi->argv);
00493
00494 if (gi->ftsp != NULL) {
00495 int xx;
00496 xx = Fts_close(gi->ftsp);
00497 gi->ftsp = NULL;
00498 gi->fts = NULL;
00499 }
00500 if (gi->fd != NULL) {
00501 (void) Fclose(gi->fd);
00502 gi->fd = NULL;
00503 }
00504 gi->tsi = rpmtsiFree(gi->tsi);
00505 gi->mi = rpmdbFreeIterator(gi->mi);
00506 gi->ts = rpmtsFree(gi->ts);
00507
00508 memset(gi, 0, sizeof(*gi));
00509
00510 gi = _free(gi);
00511
00512
00513 return NULL;
00514 }
00515
00516 rpmgi rpmgiNew(rpmts ts, int tag, const void * keyp, size_t keylen)
00517 {
00518 rpmgi gi = xcalloc(1, sizeof(*gi));
00519
00520 if (gi == NULL)
00521 return NULL;
00522
00523 gi->ts = rpmtsLink(ts, "rpmgiNew");
00524 gi->tsOrder = rpmtsOrder;
00525 gi->tag = tag;
00526
00527 gi->keyp = keyp;
00528
00529 gi->keylen = keylen;
00530
00531 gi->flags = 0;
00532 gi->active = 0;
00533 gi->i = -1;
00534 gi->hdrPath = NULL;
00535 gi->h = NULL;
00536
00537 gi->tsi = NULL;
00538 gi->mi = NULL;
00539 gi->fd = NULL;
00540 gi->argv = xcalloc(1, sizeof(*gi->argv));
00541 gi->argc = 0;
00542 gi->ftsOpts = 0;
00543 gi->ftsp = NULL;
00544 gi->fts = NULL;
00545 gi->walkPathFilter = NULL;
00546
00547 gi = rpmgiLink(gi, "rpmgiNew");
00548
00549 return gi;
00550 }
00551
00552
00553 static const char * _query_hdlist_path = "/usr/share/comps/%{_arch}/hdlist";
00554
00555 rpmRC rpmgiNext( rpmgi gi)
00556 {
00557 char hnum[32];
00558 rpmRC rpmrc = RPMRC_NOTFOUND;
00559 int xx;
00560
00561 if (gi == NULL)
00562 return rpmrc;
00563
00564 if (_rpmgi_debug)
00565 fprintf(stderr, "*** rpmgiNext(%p) tag %s\n", gi, tagName(gi->tag));
00566
00567
00568 gi->h = headerFree(gi->h);
00569 gi->hdrPath = _free(gi->hdrPath);
00570 hnum[0] = '\0';
00571
00572 if (++gi->i >= 0)
00573 switch (gi->tag) {
00574 default:
00575 if (!gi->active) {
00576 nextkey:
00577 rpmrc = rpmgiLoadNextKey(gi);
00578 if (rpmrc != RPMRC_OK)
00579 goto enditer;
00580 rpmrc = rpmgiInitFilter(gi);
00581 if (rpmrc != RPMRC_OK || gi->mi == NULL) {
00582 gi->mi = rpmdbFreeIterator(gi->mi);
00583 gi->i++;
00584 goto nextkey;
00585 }
00586 rpmrc = RPMRC_NOTFOUND;
00587 gi->active = 1;
00588 }
00589 if (gi->mi != NULL) {
00590 Header h = rpmdbNextIterator(gi->mi);
00591 if (h != NULL) {
00592 if (!(gi->flags & RPMGI_NOHEADER))
00593 gi->h = headerLink(h);
00594 sprintf(hnum, "%u", rpmdbGetIteratorOffset(gi->mi));
00595 gi->hdrPath = rpmExpand("rpmdb h# ", hnum, NULL);
00596 rpmrc = RPMRC_OK;
00597
00598 }
00599 }
00600 if (rpmrc != RPMRC_OK) {
00601 gi->mi = rpmdbFreeIterator(gi->mi);
00602 goto nextkey;
00603 }
00604 break;
00605 case RPMDBI_PACKAGES:
00606 if (!gi->active) {
00607 rpmrc = rpmgiInitFilter(gi);
00608 if (rpmrc != RPMRC_OK) {
00609 gi->mi = rpmdbFreeIterator(gi->mi);
00610 goto enditer;
00611 }
00612 rpmrc = RPMRC_NOTFOUND;
00613 gi->active = 1;
00614 }
00615 if (gi->mi != NULL) {
00616 Header h = rpmdbNextIterator(gi->mi);
00617 if (h != NULL) {
00618 if (!(gi->flags & RPMGI_NOHEADER))
00619 gi->h = headerLink(h);
00620 sprintf(hnum, "%u", rpmdbGetIteratorOffset(gi->mi));
00621 gi->hdrPath = rpmExpand("rpmdb h# ", hnum, NULL);
00622 rpmrc = RPMRC_OK;
00623
00624 }
00625 }
00626 if (rpmrc != RPMRC_OK) {
00627 gi->mi = rpmdbFreeIterator(gi->mi);
00628 goto enditer;
00629 }
00630 break;
00631 case RPMDBI_REMOVED:
00632 case RPMDBI_ADDED:
00633 { rpmte p;
00634 int teType = 0;
00635 const char * teTypeString = NULL;
00636
00637 if (!gi->active) {
00638 gi->tsi = rpmtsiInit(gi->ts);
00639 gi->active = 1;
00640 }
00641 if ((p = rpmtsiNext(gi->tsi, teType)) != NULL) {
00642 Header h = rpmteHeader(p);
00643 if (h != NULL)
00644 if (!(gi->flags & RPMGI_NOHEADER)) {
00645 gi->h = headerLink(h);
00646 switch(rpmteType(p)) {
00647 case TR_ADDED: teTypeString = "+++"; break;
00648 case TR_REMOVED: teTypeString = "---"; break;
00649 }
00650 sprintf(hnum, "%u", (unsigned)gi->i);
00651 gi->hdrPath = rpmExpand("%s h# ", teTypeString, hnum, NULL);
00652 rpmrc = RPMRC_OK;
00653 h = headerFree(h);
00654 }
00655 }
00656 if (rpmrc != RPMRC_OK) {
00657 gi->tsi = rpmtsiFree(gi->tsi);
00658 goto enditer;
00659 }
00660 } break;
00661 case RPMDBI_HDLIST:
00662 if (!gi->active) {
00663 const char * path = rpmExpand("%{?_query_hdlist_path}", NULL);
00664 if (path == NULL || *path == '\0') {
00665 path = _free(path);
00666 path = rpmExpand(_query_hdlist_path, NULL);
00667 }
00668 gi->fd = rpmgiOpen(path, "rm%{?_rpmgio}");
00669 gi->active = 1;
00670 path = _free(path);
00671 }
00672 if (gi->fd != NULL) {
00673 Header h = NULL;
00674 const char item[] = "Header";
00675 const char * msg = NULL;
00676
00677 rpmrc = rpmpkgRead(item, gi->fd, &h, &msg);
00678
00679 if (rpmrc != RPMRC_OK) {
00680 rpmlog(RPMLOG_ERR, "%s: %s: %s\n", "rpmpkgRead", item, msg);
00681 h = NULL;
00682 }
00683 msg = _free(msg);
00684 if (h != NULL) {
00685 if (!(gi->flags & RPMGI_NOHEADER))
00686 gi->h = headerLink(h);
00687 sprintf(hnum, "%u", (unsigned)gi->i);
00688 gi->hdrPath = rpmExpand("hdlist h# ", hnum, NULL);
00689 rpmrc = RPMRC_OK;
00690 h = headerFree(h);
00691 }
00692 }
00693 if (rpmrc != RPMRC_OK) {
00694 if (gi->fd != NULL) (void) Fclose(gi->fd);
00695 gi->fd = NULL;
00696 goto enditer;
00697 }
00698 break;
00699 case RPMDBI_ARGLIST:
00700
00701 if (_rpmgi_debug < 0)
00702 fprintf(stderr, "*** gi %p\t%p[%d]: %s\n", gi, gi->argv, gi->i, gi->argv[gi->i]);
00703
00704 rpmrc = rpmgiLoadReadHeader(gi);
00705
00706 if (rpmrc != RPMRC_OK)
00707 goto enditer;
00708
00709 gi->hdrPath = xstrdup(gi->argv[gi->i]);
00710 break;
00711 case RPMDBI_FTSWALK:
00712 if (gi->argv == NULL || gi->argv[0] == NULL)
00713 goto enditer;
00714
00715 if (!gi->active) {
00716 gi->ftsp = Fts_open((char *const *)gi->argv, gi->ftsOpts, NULL);
00717
00718 gi->active = 1;
00719 }
00720
00721
00722 rpmrc = rpmgiWalkReadHeader(gi);
00723
00724 if (rpmrc != RPMRC_OK) {
00725 xx = Fts_close(gi->ftsp);
00726 gi->ftsp = NULL;
00727 goto enditer;
00728 }
00729
00730 if (gi->fts != NULL)
00731 gi->hdrPath = xstrdup(gi->fts->fts_path);
00732 break;
00733 }
00734
00735 if ((gi->flags & RPMGI_TSADD) && gi->h != NULL) {
00736
00737 if (gi->flags & RPMGI_ERASING) {
00738 static int hdrx = 0;
00739 int dboffset = headerGetInstance(gi->h);
00740 if (dboffset <= 0)
00741 dboffset = --hdrx;
00742 xx = rpmtsAddEraseElement(gi->ts, gi->h, dboffset);
00743 } else
00744 xx = rpmtsAddInstallElement(gi->ts, gi->h, (fnpyKey)gi->hdrPath, 2, NULL);
00745 }
00746
00747 return rpmrc;
00748
00749 enditer:
00750 if (gi->flags & RPMGI_TSORDER) {
00751 rpmts ts = gi->ts;
00752 rpmps ps;
00753 int i;
00754
00755
00756 if (!(gi->flags & RPMGI_ERASING)) {
00757 (void) rpmtsSetGoal(ts, TSM_INSTALL);
00758 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), -RPMDBI_DEPENDS);
00759 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), -RPMTAG_BASENAMES);
00760 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), -RPMTAG_PROVIDENAME);
00761 } else {
00762 (void) rpmtsSetGoal(ts, TSM_ERASE);
00763 }
00764
00765 xx = rpmtsCheck(ts);
00766
00767
00768 if (!(gi->flags & RPMGI_ERASING)) {
00769 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), +RPMTAG_PROVIDENAME);
00770 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), +RPMTAG_BASENAMES);
00771 xx = rpmdbBlockDBI(rpmtsGetRdb(ts), +RPMDBI_DEPENDS);
00772 }
00773
00774
00775 ps = rpmtsProblems(ts);
00776 if (rpmpsNumProblems(ps) > 0) {
00777
00778 rpmlog(RPMLOG_INFO, _("Failed dependencies:\n"));
00779 if (rpmIsVerbose())
00780 rpmpsPrint(NULL, ps);
00781
00782 if (ts->suggests != NULL && ts->nsuggests > 0) {
00783 rpmlog(RPMLOG_INFO, _(" Suggested resolutions:\n"));
00784 for (i = 0; i < ts->nsuggests; i++) {
00785 const char * str = ts->suggests[i];
00786
00787 if (str == NULL)
00788 break;
00789
00790 rpmlog(RPMLOG_INFO, "\t%s\n", str);
00791
00792 ts->suggests[i] = NULL;
00793 str = _free(str);
00794 }
00795 ts->suggests = _free(ts->suggests);
00796 }
00797
00798 }
00799 ps = rpmpsFree(ps);
00800 ts->probs = rpmpsFree(ts->probs);
00801
00802
00803 if (rpmIsVerbose())
00804 (void) rpmtsSetDFlags(ts, (rpmtsDFlags(ts) | RPMDEPS_FLAG_DEPLOOPS));
00805
00806 xx = (*gi->tsOrder) (ts);
00807
00808
00809 gi->tag = (!(gi->flags & RPMGI_ERASING) ? RPMDBI_ADDED : RPMDBI_REMOVED);
00810 gi->flags &= ~(RPMGI_TSADD|RPMGI_TSORDER);
00811
00812 }
00813
00814 gi->h = headerFree(gi->h);
00815 gi->hdrPath = _free(gi->hdrPath);
00816 gi->i = -1;
00817 gi->active = 0;
00818 return rpmrc;
00819 }
00820
00821 rpmgiFlags rpmgiGetFlags(rpmgi gi)
00822 {
00823 return (gi != NULL ? gi->flags : RPMGI_NONE);
00824 }
00825
00826 const char * rpmgiHdrPath(rpmgi gi)
00827 {
00828 return (gi != NULL ? gi->hdrPath : NULL);
00829 }
00830
00831 Header rpmgiHeader(rpmgi gi)
00832 {
00833
00834 return (gi != NULL ? gi->h : NULL);
00835
00836 }
00837
00838 rpmts rpmgiTs(rpmgi gi)
00839 {
00840
00841 return (gi != NULL ? gi->ts : NULL);
00842
00843 }
00844
00845 rpmRC rpmgiSetArgs(rpmgi gi, ARGV_t argv, int ftsOpts, rpmgiFlags flags)
00846 {
00847 if (gi == NULL) return RPMRC_FAIL;
00848 gi->ftsOpts = ftsOpts;
00849 gi->flags = flags;
00850 return rpmgiGlobArgv(gi, argv);
00851 }
00852
00853