/*
* Get files from next package from match iterator. If files are
* available in memory then don't read them from rpmdb.
*/
static rpmfiles rpmtsNextFiles(rpmts ts, rpmdbMatchIterator mi)
{
Header h;
rpmte *te;
rpmfiles files = NULL;
rpmstrPool pool = ts->members->pool;
int ix;
unsigned int offset;
ix = rpmdbGetIteratorIndex(mi);
if (ix < rpmdbGetIteratorCount(mi)) {
offset = rpmdbGetIteratorOffsetFor(mi, ix);
if (packageHashGetEntry(ts->members->removedPackages, offset,
&te, NULL, NULL)) {
/* Files are available in memory */
files = rpmteFiles(te[0]);
}
if (packageHashGetEntry(ts->members->installedPackages, offset,
&te, NULL, NULL)) {
/* Files are available in memory */
files = rpmteFiles(te[0]);
}
}
if (files) {
rpmdbSetIteratorIndex(mi, ix + 1);
} else {
/* Files are not available in memory. Read them from rpmdb */
h = rpmdbNextIterator(mi);
if (h) {
files = rpmfilesNew(pool, h, RPMTAG_BASENAMES,
RPMFI_FLAGS_ONLY_FILENAMES);
}
}
return files;
}
static int process_package(rpmts ts, char * filename)
{
FD_t fdi;
FD_t gzdi;
Header h;
int rc = 0;
char * rpmio_flags = NULL;
struct archive *a;
struct archive_entry *entry;
if (!strcmp(filename, "-")) {
fdi = fdDup(STDIN_FILENO);
} else {
fdi = Fopen(filename, "r.ufdio");
}
if (Ferror(fdi)) {
fprintf(stderr, "rpm2archive: %s: %s\n",
filename, Fstrerror(fdi));
exit(EXIT_FAILURE);
}
rc = rpmReadPackageFile(ts, fdi, "rpm2cpio", &h);
switch (rc) {
case RPMRC_OK:
case RPMRC_NOKEY:
case RPMRC_NOTTRUSTED:
break;
case RPMRC_NOTFOUND:
fprintf(stderr, _("argument is not an RPM package\n"));
exit(EXIT_FAILURE);
break;
case RPMRC_FAIL:
default:
fprintf(stderr, _("error reading header from package\n"));
exit(EXIT_FAILURE);
break;
}
/* Retrieve payload size and compression type. */
{ const char *compr = headerGetString(h, RPMTAG_PAYLOADCOMPRESSOR);
rpmio_flags = rstrscat(NULL, "r.", compr ? compr : "gzip", NULL);
}
gzdi = Fdopen(fdi, rpmio_flags); /* XXX gzdi == fdi */
free(rpmio_flags);
if (gzdi == NULL) {
fprintf(stderr, _("cannot re-open payload: %s\n"), Fstrerror(gzdi));
exit(EXIT_FAILURE);
}
rpmfiles files = rpmfilesNew(NULL, h, 0, RPMFI_KEEPHEADER);
rpmfi fi = rpmfiNewArchiveReader(gzdi, files, RPMFI_ITER_READ_ARCHIVE_CONTENT_FIRST);
/* create archive */
a = archive_write_new();
archive_write_add_filter_gzip(a);
archive_write_set_format_pax_restricted(a);
if (!strcmp(filename, "-")) {
if (isatty(STDOUT_FILENO)) {
fprintf(stderr, "Error: refusing to output archive data to a terminal.\n");
exit(EXIT_FAILURE);
}
archive_write_open_fd(a, STDOUT_FILENO);
} else {
char * outname = rstrscat(NULL, filename, ".tgz", NULL);
archive_write_open_filename(a, outname);
_free(outname);
// XXX error handling
}
entry = archive_entry_new();
char * buf = xmalloc(BUFSIZE);
char * hardlink = NULL;
rc = 0;
while (rc >= 0) {
rc = rpmfiNext(fi);
if (rc == RPMERR_ITER_END) {
break;
}
rpm_mode_t mode = rpmfiFMode(fi);
int nlink = rpmfiFNlink(fi);
fill_archive_entry(a, entry, fi);
if (nlink > 1) {
if (rpmfiArchiveHasContent(fi)) {
_free(hardlink);
hardlink = rstrscat(NULL, ".", rpmfiFN(fi), NULL);
} else {
archive_entry_set_hardlink(entry, hardlink);
}
}
archive_write_header(a, entry);
if (S_ISREG(mode) && (nlink == 1 || rpmfiArchiveHasContent(fi))) {
write_file_content(a, buf, fi);
}
}
/* End of iteration is not an error */
if (rc == RPMERR_ITER_END) {
rc = 0;
}
_free(hardlink);
Fclose(gzdi); /* XXX gzdi == fdi */
archive_entry_free(entry);
archive_write_close(a);
archive_write_free(a);
buf = _free(buf);
rpmfilesFree(files);
rpmfiFree(fi);
headerFree(h);
return rc;
}
/* Check files in the transactions against the rpmdb
* Lookup all files with the same basename in the rpmdb
* and then check for matching finger prints
* @param ts transaction set
* @param fpc global finger print cache
*/
static
void checkInstalledFiles(rpmts ts, uint64_t fileCount, fingerPrintCache fpc)
{
tsMembers tsmem = rpmtsMembers(ts);
rpmte p;
rpmfiles fi;
rpmfs fs;
int j;
unsigned int fileNum;
rpmdbMatchIterator mi;
Header h, newheader;
rpmlog(RPMLOG_DEBUG, "computing file dispositions\n");
mi = rpmFindBaseNamesInDB(ts, fileCount);
/* For all installed headers with matching basename's ... */
if (mi == NULL)
return;
if (rpmdbGetIteratorCount(mi) == 0) {
mi = rpmdbFreeIterator(mi);
return;
}
/* Loop over all packages from the rpmdb */
h = newheader = rpmdbNextIterator(mi);
while (h != NULL) {
headerGetFlags hgflags = HEADERGET_MINMEM;
struct rpmtd_s bnames, dnames, dindexes, ostates;
fingerPrint *fpp = NULL;
unsigned int installedPkg;
int beingRemoved = 0;
rpmfiles otherFi = NULL;
rpmte *removedPkg = NULL;
/* Is this package being removed? */
installedPkg = rpmdbGetIteratorOffset(mi);
if (packageHashGetEntry(tsmem->removedPackages, installedPkg,
&removedPkg, NULL, NULL)) {
beingRemoved = 1;
otherFi = rpmteFiles(removedPkg[0]);
}
h = headerLink(h);
/* For packages being removed we can use its rpmfi to avoid all this */
if (!beingRemoved) {
headerGet(h, RPMTAG_BASENAMES, &bnames, hgflags);
headerGet(h, RPMTAG_DIRNAMES, &dnames, hgflags);
headerGet(h, RPMTAG_DIRINDEXES, &dindexes, hgflags);
headerGet(h, RPMTAG_FILESTATES, &ostates, hgflags);
}
/* loop over all interesting files in that package */
do {
int fpIx;
struct rpmffi_s * recs;
int numRecs;
const char * dirName;
const char * baseName;
/* lookup finger print for this file */
fileNum = rpmdbGetIteratorFileNum(mi);
if (!beingRemoved) {
rpmtdSetIndex(&bnames, fileNum);
rpmtdSetIndex(&dindexes, fileNum);
rpmtdSetIndex(&dnames, *rpmtdGetUint32(&dindexes));
rpmtdSetIndex(&ostates, fileNum);
dirName = rpmtdGetString(&dnames);
baseName = rpmtdGetString(&bnames);
fpLookup(fpc, dirName, baseName, &fpp);
fpIx = 0;
} else {
fpp = rpmfilesFps(otherFi);
fpIx = fileNum;
}
/* search for files in the transaction with same finger print */
fpCacheGetByFp(fpc, fpp, fpIx, &recs, &numRecs);
for (j = 0; j < numRecs; j++) {
p = recs[j].p;
fi = rpmteFiles(p);
fs = rpmteGetFileStates(p);
/* Determine the fate of each file. */
switch (rpmteType(p)) {
case TR_ADDED:
if (!otherFi) {
/* XXX What to do if this fails? */
otherFi = rpmfilesNew(NULL, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER);
}
handleInstInstalledFile(ts, p, fi, recs[j].fileno,
h, otherFi, fileNum, beingRemoved);
break;
case TR_REMOVED:
if (!beingRemoved) {
if (*rpmtdGetChar(&ostates) == RPMFILE_STATE_NORMAL)
rpmfsSetAction(fs, recs[j].fileno, FA_SKIP);
}
break;
}
rpmfilesFree(fi);
}
newheader = rpmdbNextIterator(mi);
} while (newheader==h);
otherFi = rpmfilesFree(otherFi);
if (!beingRemoved) {
rpmtdFreeData(&ostates);
rpmtdFreeData(&bnames);
rpmtdFreeData(&dnames);
rpmtdFreeData(&dindexes);
free(fpp);
}
headerFree(h);
h = newheader;
}
rpmdbFreeIterator(mi);
}
