rpmScript rpmScriptFromTriggerTag(Header h, rpmTagVal triggerTag, uint32_t ix)
{
rpmScript script = NULL;
struct rpmtd_s tscripts, tprogs, tflags;
headerGetFlags hgflags = HEADERGET_MINMEM;
headerGet(h, RPMTAG_TRIGGERSCRIPTS, &tscripts, hgflags);
headerGet(h, RPMTAG_TRIGGERSCRIPTPROG, &tprogs, hgflags);
headerGet(h, RPMTAG_TRIGGERSCRIPTFLAGS, &tflags, hgflags);
if (rpmtdSetIndex(&tscripts, ix) >= 0 && rpmtdSetIndex(&tprogs, ix) >= 0) {
rpmscriptFlags sflags = 0;
const char *prog = rpmtdGetString(&tprogs);
if (rpmtdSetIndex(&tflags, ix) >= 0)
sflags = rpmtdGetNumber(&tflags);
script = rpmScriptNew(h, triggerTag, rpmtdGetString(&tscripts), sflags);
/* hack up a hge-style NULL-terminated array */
script->args = xmalloc(2 * sizeof(*script->args) + strlen(prog) + 1);
script->args[0] = (char *)(script->args + 2);
script->args[1] = NULL;
strcpy(script->args[0], prog);
}
rpmtdFreeData(&tscripts);
rpmtdFreeData(&tprogs);
rpmtdFreeData(&tflags);
return script;
}
rpmtd rpmtdDup(rpmtd td)
{
rpmtd newtd = NULL;
char **data = NULL;
int i;
assert(td != NULL);
/* TODO: permit other types too */
if (td->type != RPM_STRING_ARRAY_TYPE && td->type != RPM_I18NSTRING_TYPE) {
return NULL;
}
/* deep-copy container and data, drop immutable flag */
newtd = rpmtdNew();
memcpy(newtd, td, sizeof(*td));
newtd->flags &= ~(RPMTD_IMMUTABLE);
newtd->flags |= (RPMTD_ALLOCED | RPMTD_PTR_ALLOCED);
newtd->data = data = xmalloc(td->count * sizeof(*data));
while ((i = rpmtdNext(td)) >= 0) {
data[i] = xstrdup(rpmtdGetString(td));
}
return newtd;
}
/*
* Convert single tag data item to python object of suitable type
*/
PyObject * rpmtd_ItemAsPyobj(rpmtd td)
{
PyObject *res = NULL;
char *str = NULL;
switch (rpmtdType(td)) {
case RPM_STRING_TYPE:
case RPM_I18NSTRING_TYPE:
case RPM_STRING_ARRAY_TYPE:
res = PyString_FromString(rpmtdGetString(td));
break;
case RPM_INT64_TYPE:
res = PyLong_FromLongLong(*rpmtdGetUint64(td));
break;
case RPM_INT32_TYPE:
res = PyInt_FromLong(*rpmtdGetUint32(td));
break;
case RPM_INT16_TYPE:
res = PyInt_FromLong(*rpmtdGetUint16(td));
break;
case RPM_BIN_TYPE:
str = rpmtdFormat(td, RPMTD_FORMAT_STRING, NULL);
res = PyString_FromString(str);
free(str);
break;
default:
PyErr_SetString(PyExc_KeyError, "unhandled data type");
break;
}
return res;
}
/**
* Return shell escape formatted data.
* @param td tag data container
* @return formatted string
*/
static char * shescapeFormat(rpmtd td)
{
char * result = NULL, * dst, * src;
if (rpmtdClass(td) == RPM_NUMERIC_CLASS) {
rasprintf(&result, "%" PRIu64, rpmtdGetNumber(td));
} else {
char *buf = xstrdup(rpmtdGetString(td));;
result = dst = xmalloc(strlen(buf) * 4 + 3);
*dst++ = '\'';
for (src = buf; *src != '\0'; src++) {
if (*src == '\'') {
*dst++ = '\'';
*dst++ = '\\';
*dst++ = '\'';
*dst++ = '\'';
} else {
*dst++ = *src;
}
}
*dst++ = '\'';
*dst = '\0';
free(buf);
}
return result;
}
/*
* Add extra provides to package.
*/
static void addPackageProvides(Header h)
{
const char *name = NULL, *arch = NULL;
char *evr, *isaprov;
rpmsenseFlags pflags = RPMSENSE_EQUAL;
int noarch = 0;
struct rpmtd_s archtd;
/* <name> = <evr> provide */
evr = headerGetEVR(h, &name);
headerPutString(h, RPMTAG_PROVIDENAME, name);
headerPutString(h, RPMTAG_PROVIDEVERSION, evr);
headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &pflags, 1);
/*
* <name>(<isa>) = <evr> provide
* FIXME: noarch needs special casing for now as BuildArch: noarch doesn't
* cause reading in the noarch macros :-/
*/
isaprov = rpmExpand(name, "%{?_isa}", NULL);
headerGet(h, RPMTAG_ARCH, &archtd, HEADERGET_MINMEM);
arch = rpmtdGetString(&archtd);
noarch = (strcmp(arch, "noarch") == 0);
if (!noarch && strcmp(name, isaprov)) {
headerPutString(h, RPMTAG_PROVIDENAME, isaprov);
headerPutString(h, RPMTAG_PROVIDEVERSION, evr);
headerPutUint32(h, RPMTAG_PROVIDEFLAGS, &pflags, 1);
}
free(isaprov);
free(evr);
}
const char *rpmtdNextString(rpmtd td)
{
assert(td != NULL);
const char *res = NULL;
if (rpmtdNext(td) >= 0) {
res = rpmtdGetString(td);
}
return res;
}
const char * headerGetString(Header h, rpmTag tag)
{
const char *res = NULL;
struct rpmtd_s td;
if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {
if (rpmtdCount(&td) == 1) {
res = rpmtdGetString(&td);
}
rpmtdFreeData(&td);
}
return res;
}
/**
* Wrap a pubkey in ascii armor for display.
* @todo Permit selectable display formats (i.e. binary).
* @param td tag data container
* @return formatted string
*/
static char * armorFormat(rpmtd td)
{
const char * enc;
const unsigned char * s;
unsigned char * bs = NULL;
char *val;
size_t ns;
int atype;
switch (rpmtdType(td)) {
case RPM_BIN_TYPE:
s = td->data;
/* XXX HACK ALERT: element field abused as no. bytes of binary data. */
ns = td->count;
atype = PGPARMOR_SIGNATURE; /* XXX check pkt for signature */
break;
case RPM_STRING_TYPE:
case RPM_STRING_ARRAY_TYPE:
enc = rpmtdGetString(td);
if (rpmBase64Decode(enc, (void **)&bs, &ns))
return xstrdup(_("(not base64)"));
s = bs;
atype = PGPARMOR_PUBKEY; /* XXX check pkt for pubkey */
break;
case RPM_NULL_TYPE:
case RPM_CHAR_TYPE:
case RPM_INT8_TYPE:
case RPM_INT16_TYPE:
case RPM_INT32_TYPE:
case RPM_INT64_TYPE:
case RPM_I18NSTRING_TYPE:
default:
return xstrdup(_("(invalid type)"));
break;
}
/* XXX this doesn't use padding directly, assumes enough slop in retval. */
val = pgpArmorWrap(atype, s, ns);
if (atype == PGPARMOR_PUBKEY) {
free(bs);
}
return val;
}
/*
* Convert single tag data item to python object of suitable type
*/
PyObject * rpmtd_ItemAsPyobj(rpmtd td, rpmTagClass tclass)
{
PyObject *res = NULL;
switch (tclass) {
case RPM_STRING_CLASS:
res = PyBytes_FromString(rpmtdGetString(td));
break;
case RPM_NUMERIC_CLASS:
res = PyLong_FromLongLong(rpmtdGetNumber(td));
break;
case RPM_BINARY_CLASS:
res = PyBytes_FromStringAndSize(td->data, td->count);
break;
default:
PyErr_SetString(PyExc_KeyError, "unknown data type");
break;
}
return res;
}
/**
* barebones string representation with no extra formatting
* @param td tag data container
* @return formatted string
*/
static char * stringFormat(rpmtd td)
{
char *val = NULL;
switch (rpmtdClass(td)) {
case RPM_NUMERIC_CLASS:
rasprintf(&val, "%" PRIu64, rpmtdGetNumber(td));
break;
case RPM_STRING_CLASS:
val = xstrdup(rpmtdGetString(td));
break;
case RPM_BINARY_CLASS:
val = pgpHexStr(td->data, td->count);
break;
default:
val = xstrdup("(unknown type)");
break;
}
return val;
}
static int addFileToTag(rpmSpec spec, const char * file, Header h, rpmTag tag)
{
StringBuf sb = newStringBuf();
const char *s;
struct rpmtd_s td;
headerGet(h, tag, &td, HEADERGET_MINMEM);
if ((s = rpmtdGetString(&td))) {
appendLineStringBuf(sb, s);
rpmtdFreeData(&td);
(void) headerDel(h, tag);
}
if ((sb = addFileToTagAux(spec, file, sb)) == NULL)
return 1;
headerPutString(h, tag, getStringBuf(sb));
sb = freeStringBuf(sb);
return 0;
}
/**
* @brief Return a string representation of the RPM tag type.
*
* @param header A librpm header.
* @param tag A librpm rpmTag_t name.
* @param td A librpm rpmtd.
*
* Given a librpm iterator header and a requested tag name:
* 1. Determine the type of the tag (the class of value).
* 2. Request a const pointer or cast of numerate to that class.
* 3. Lexical-cast the value for SQL.
*
* @return The string representation of the tag type.
*/
static std::string getRpmAttribute(const Header& header,
rpmTag tag,
const rpmtd& td) {
std::string result;
if (headerGet(header, tag, td, HEADERGET_DEFAULT) == 0) {
// Intentional check for a 0 = failure.
TLOG << "Could not get RPM header flag.";
return result;
}
if (rpmTagGetClass(tag) == RPM_NUMERIC_CLASS) {
long long int attr = rpmtdGetNumber(td);
result = BIGINT(attr);
} else if (rpmTagGetClass(tag) == RPM_STRING_CLASS) {
const char* attr = rpmtdGetString(td);
if (attr != nullptr) {
result = TEXT(attr);
}
}
return result;
}
static int haveLangTag(Header h, rpmTagVal tag, const char *lang)
{
int rc = 0; /* assume tag not present */
int langNum = -1;
if (lang && *lang) {
/* See if the language is in header i18n table */
struct rpmtd_s langtd;
const char *s = NULL;
headerGet(h, RPMTAG_HEADERI18NTABLE, &langtd, HEADERGET_MINMEM);
while ((s = rpmtdNextString(&langtd)) != NULL) {
if (rstreq(s, lang)) {
langNum = rpmtdGetIndex(&langtd);
break;
}
}
rpmtdFreeData(&langtd);
} else {
/* C locale */
langNum = 0;
}
/* If locale is present, check the actual tag content */
if (langNum >= 0) {
struct rpmtd_s td;
headerGet(h, tag, &td, HEADERGET_MINMEM|HEADERGET_RAW);
if (rpmtdSetIndex(&td, langNum) == langNum) {
const char *s = rpmtdGetString(&td);
/* non-empty string means a dupe */
if (s && *s)
rc = 1;
}
rpmtdFreeData(&td);
};
return rc;
}
/**
* Retrieve trigger info.
* @param mode type of trigger (see tMode_e)
* @param h header
* @retval td tag data container
* @param hgflags header get flags
* @return 1 on success
*/
static int triggercondsTagFor(tMode mode, Header h, rpmtd td,
headerGetFlags hgflags)
{
uint32_t * indices;
int i, j;
char ** conds;
struct rpmtd_s nametd, indextd, flagtd, versiontd, scripttd;
int hgeflags = HEADERGET_MINMEM;
rpmTagVal triggername, triggerindex, triggerflags;
rpmTagVal triggerversion, triggerscripts;
switch (mode) {
case NORMALTRIGGER:
triggername = RPMTAG_TRIGGERNAME;
triggerindex = RPMTAG_TRIGGERINDEX;
triggerflags = RPMTAG_TRIGGERFLAGS;
triggerversion = RPMTAG_TRIGGERVERSION;
triggerscripts = RPMTAG_TRIGGERSCRIPTS;
break;
case FILETRIGGER:
triggername = RPMTAG_FILETRIGGERNAME;
triggerindex = RPMTAG_FILETRIGGERINDEX;
triggerflags = RPMTAG_FILETRIGGERFLAGS;
triggerversion = RPMTAG_FILETRIGGERVERSION;
triggerscripts = RPMTAG_FILETRIGGERSCRIPTS;
break;
case TRANSFILETRIGGER:
triggername = RPMTAG_TRANSFILETRIGGERNAME;
triggerindex = RPMTAG_TRANSFILETRIGGERINDEX;
triggerflags = RPMTAG_TRANSFILETRIGGERFLAGS;
triggerversion = RPMTAG_TRANSFILETRIGGERVERSION;
triggerscripts = RPMTAG_TRANSFILETRIGGERSCRIPTS;
break;
default:
return 0;
}
if (!headerGet(h, triggername, &nametd, hgeflags)) {
return 0;
}
headerGet(h, triggerindex, &indextd, hgeflags);
headerGet(h, triggerflags, &flagtd, hgeflags);
headerGet(h, triggerversion, &versiontd, hgeflags);
headerGet(h, triggerscripts, &scripttd, hgeflags);
td->type = RPM_STRING_ARRAY_TYPE;
td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;
td->data = conds = xmalloc(sizeof(*conds) * rpmtdCount(&scripttd));
td->count = rpmtdCount(&scripttd);
indices = indextd.data;
while ((i = rpmtdNext(&scripttd)) >= 0) {
rpm_flag_t *flag;
char *flagStr, *item;
ARGV_t items = NULL;
rpmtdInit(&nametd); rpmtdInit(&flagtd); rpmtdInit(&versiontd);
while ((j = rpmtdNext(&nametd)) >= 0) {
/* flag and version arrays match name array size always */
rpmtdNext(&flagtd); rpmtdNext(&versiontd);
if (indices[j] != i)
continue;
flag = rpmtdGetUint32(&flagtd);
if (flag && *flag & RPMSENSE_SENSEMASK) {
flagStr = rpmtdFormat(&flagtd, RPMTD_FORMAT_DEPFLAGS, NULL);
rasprintf(&item, "%s %s %s", rpmtdGetString(&nametd),
flagStr,
rpmtdGetString(&versiontd));
free(flagStr);
} else {
item = xstrdup(rpmtdGetString(&nametd));
}
argvAdd(&items, item);
free(item);
}
conds[i] = argvJoin(items, ", ");
argvFree(items);
}
rpmtdFreeData(&nametd);
rpmtdFreeData(&versiontd);
rpmtdFreeData(&flagtd);
rpmtdFreeData(&indextd);
rpmtdFreeData(&scripttd);
return 1;
}
int main(int argc, char *argv[])
{
FD_t fdi, fdo;
Header h;
char * rpmio_flags;
rpmRC rc;
FD_t gzdi;
setprogname(argv[0]); /* Retrofit glibc __progname */
if (argc == 1)
fdi = fdDup(STDIN_FILENO);
else
fdi = Fopen(argv[1], "r.ufdio");
if (Ferror(fdi)) {
fprintf(stderr, "%s: %s: %s\n", argv[0],
(argc == 1 ? "<stdin>" : argv[1]), Fstrerror(fdi));
exit(EXIT_FAILURE);
}
fdo = fdDup(STDOUT_FILENO);
rpmReadConfigFiles(NULL, NULL);
{ rpmts ts = rpmtsCreate();
rpmVSFlags vsflags = 0;
/* XXX retain the ageless behavior of rpm2cpio */
vsflags |= _RPMVSF_NODIGESTS;
vsflags |= _RPMVSF_NOSIGNATURES;
vsflags |= RPMVSF_NOHDRCHK;
(void) rpmtsSetVSFlags(ts, vsflags);
/* LCL: segfault */
rc = rpmReadPackageFile(ts, fdi, "rpm2cpio", &h);
ts = rpmtsFree(ts);
}
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 type of payload compression. */
{ const char * payload_compressor = NULL;
struct rpmtd_s pc;
headerGet(h, RPMTAG_PAYLOADCOMPRESSOR, &pc, HEADERGET_DEFAULT);
payload_compressor = rpmtdGetString(&pc);
if (!payload_compressor)
payload_compressor = "gzip";
if (!strcmp(payload_compressor, "gzip"))
rpmio_flags = "r.gzdio";
if (!strcmp(payload_compressor, "bzip2"))
rpmio_flags = "r.bzdio";
if (!strcmp(payload_compressor, "lzma"))
rpmio_flags = "r.lzdio";
rpmtdFreeData(&pc);
}
gzdi = Fdopen(fdi, rpmio_flags); /* XXX gzdi == fdi */
if (gzdi == NULL) {
fprintf(stderr, _("cannot re-open payload: %s\n"), Fstrerror(gzdi));
exit(EXIT_FAILURE);
}
rc = ufdCopy(gzdi, fdo);
rc = (rc <= 0) ? EXIT_FAILURE : EXIT_SUCCESS;
Fclose(fdo);
Fclose(gzdi); /* XXX gzdi == fdi */
return rc;
}
/* ---------------------------------------------------------------------
*/
int
netsnmp_swinst_arch_load( netsnmp_container *container, u_int flags)
{
rpmts ts;
rpmdbMatchIterator mi;
Header h;
#if HAVE_HEADERGET
const char *g;
rpmtd td_name, td_version, td_release, td_group, td_time;
#else
char *n, *v, *r, *g;
int32_t *t;
#endif
time_t install_time;
size_t date_len;
int i = 1;
netsnmp_swinst_entry *entry;
#if HAVE_HEADERGET
td_name = rpmtdNew();
td_version = rpmtdNew();
td_release = rpmtdNew();
td_group = rpmtdNew();
td_time = rpmtdNew();
#endif
ts = rpmtsCreate();
rpmtsSetVSFlags( ts, (_RPMVSF_NOSIGNATURES|_RPMVSF_NODIGESTS));
mi = rpmtsInitIterator( ts, RPMDBI_PACKAGES, NULL, 0);
if (mi == NULL)
NETSNMP_LOGONCE((LOG_ERR, "rpmdbOpen() failed\n"));
while (NULL != (h = rpmdbNextIterator( mi )))
{
const u_char *dt;
entry = netsnmp_swinst_entry_create( i++ );
if (NULL == entry)
continue; /* error already logged by function */
CONTAINER_INSERT(container, entry);
h = headerLink( h );
#if HAVE_HEADERGET
headerGet(h, RPMTAG_NAME, td_name, HEADERGET_EXT);
headerGet(h, RPMTAG_VERSION, td_version, HEADERGET_EXT);
headerGet(h, RPMTAG_RELEASE, td_release, HEADERGET_EXT);
headerGet(h, RPMTAG_GROUP, td_group, HEADERGET_EXT);
headerGet(h, RPMTAG_INSTALLTIME, td_time, HEADERGET_EXT);
entry->swName_len = snprintf( entry->swName, sizeof(entry->swName),
"%s-%s-%s", rpmtdGetString(td_name),
rpmtdGetString(td_version),
rpmtdGetString(td_release));
install_time = rpmtdGetNumber(td_time);
g = rpmtdGetString(td_group);
#else
headerGetEntry( h, RPMTAG_NAME, NULL, (void**)&n, NULL);
headerGetEntry( h, RPMTAG_VERSION, NULL, (void**)&v, NULL);
headerGetEntry( h, RPMTAG_RELEASE, NULL, (void**)&r, NULL);
headerGetEntry( h, RPMTAG_GROUP, NULL, (void**)&g, NULL);
headerGetEntry( h, RPMTAG_INSTALLTIME, NULL, (void**)&t, NULL);
entry->swName_len = snprintf( entry->swName, sizeof(entry->swName),
"%s-%s-%s", n, v, r);
install_time = *t;
#endif
entry->swType = (g && NULL != strstr( g, "System Environment"))
? 2 /* operatingSystem */
: 4; /* application */
if (entry->swName_len > sizeof(entry->swName))
entry->swName_len = sizeof(entry->swName);
dt = date_n_time( &install_time, &date_len );
if (date_len != 8 && date_len != 11) {
snmp_log(LOG_ERR, "Bogus length from date_n_time for %s", entry->swName);
entry->swDate_len = 0;
}
else {
entry->swDate_len = date_len;
memcpy(entry->swDate, dt, entry->swDate_len);
}
#if HAVE_HEADERGET
rpmtdFreeData(td_name);
rpmtdFreeData(td_version);
rpmtdFreeData(td_release);
rpmtdFreeData(td_group);
rpmtdFreeData(td_time);
#endif
headerFree( h );
}
rpmdbFreeIterator( mi );
rpmtsFree( ts );
#if HAVE_HEADERGET
rpmtdFree(td_name);
rpmtdFree(td_version);
rpmtdFree(td_release);
rpmtdFree(td_group);
rpmtdFree(td_time);
#endif
DEBUGMSGTL(("swinst:load:arch", "loaded %d entries\n",
(int)CONTAINER_SIZE(container)));
return 0;
}
static rpmRC rpmsinfoInit(rpmtd td, const char *origin,
struct rpmsinfo_s *sinfo, char **msg)
{
rpmRC rc = RPMRC_FAIL;
const void *data = NULL;
const struct vfytag_s *tinfo;
const struct vfyinfo_s *vinfo;
rpm_count_t dlen = 0;
int ix;
if ((ix = sinfoLookup(td->tag)) == -1) {
/* anything unknown just falls through for now */
rc = RPMRC_OK;
goto exit;
}
vinfo = &rpmvfyitems[ix];
tinfo = &rpmvfytags[ix];
assert(tinfo->tag == vinfo->tag);
*sinfo = rpmvfyitems[ix].vi; /* struct assignment */
if (tinfo->tagtype && tinfo->tagtype != td->type) {
rasprintf(msg, _("%s tag %u: invalid type %u"),
origin, td->tag, td->type);
goto exit;
}
if (tinfo->tagcount && tinfo->tagcount != td->count) {
rasprintf(msg, _("%s: tag %u: invalid count %u"),
origin, td->tag, td->count);
goto exit;
}
switch (td->type) {
case RPM_STRING_TYPE:
case RPM_STRING_ARRAY_TYPE:
data = rpmtdGetString(td);
if (data)
dlen = strlen(data);
break;
case RPM_BIN_TYPE:
data = td->data;
dlen = td->count;
break;
}
/* MD5 has data length of 16, everything else is (much) larger */
if (sinfo->hashalgo && (data == NULL || dlen < 16)) {
rasprintf(msg, _("%s tag %u: invalid data %p (%u)"),
origin, td->tag, data, dlen);
goto exit;
}
if (td->type == RPM_STRING_TYPE && td->size == 0)
td->size = dlen + 1;
if (tinfo->tagsize && (td->flags & RPMTD_IMMUTABLE) &&
tinfo->tagsize != td->size) {
rasprintf(msg, _("%s tag %u: invalid size %u"),
origin, td->tag, td->size);
goto exit;
}
if (sinfo->type == RPMSIG_SIGNATURE_TYPE) {
if (pgpPrtParams(data, dlen, PGPTAG_SIGNATURE, &sinfo->sig)) {
rasprintf(msg, _("%s tag %u: invalid OpenPGP signature"),
origin, td->tag);
goto exit;
}
sinfo->hashalgo = pgpDigParamsAlgo(sinfo->sig, PGPVAL_HASHALGO);
sinfo->keyid = pgpGrab(sinfo->sig->signid+4, 4);
} else if (sinfo->type == RPMSIG_DIGEST_TYPE) {
if (td->type == RPM_BIN_TYPE) {
sinfo->dig = pgpHexStr(data, dlen);
} else {
if (!validHex(data, dlen)) {
rasprintf(msg, _("%s: tag %u: invalid hex"), origin, td->tag);
goto exit;
}
sinfo->dig = xstrdup(data);
}
}
if (sinfo->hashalgo)
sinfo->id = (td->tag << 16) | rpmtdGetIndex(td);
rc = RPMRC_OK;
exit:
return rc;
}
/*
* Create a spec file object from a spec file
* @param [String] filename Spec file path
* @return [Spec]
*/
static VALUE
spec_s_open(VALUE klass, VALUE filename)
{
#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
Spec rspec;
#else
rpmts ts = NULL;
#endif
if (TYPE(filename) != T_STRING) {
rb_raise(rb_eTypeError, "illegal argument type");
}
#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
switch (parseSpec(&rspec, RSTRING_PTR(filename), "/", NULL, 0, "", NULL, 1, 1)) {
case 0:
if (rspec != NULL) {
break;
}
default:
rb_raise(rb_eRuntimeError, "specfile `%s' parsing failed", RSTRING_PTR(filename));
}
return Data_Wrap_Struct(klass, NULL, spec_free, rspec);
#else
ts = rpmtsCreate();
#if RPM_VERSION_CODE < RPM_VERSION(4,4,8)
switch (parseSpec(ts, RSTRING_PTR(filename), "/", NULL, 0, "", NULL, 1, 1)) {
#elif RPM_VERSION_CODE < RPM_VERSION(4,5,90)
switch (parseSpec(ts, RSTRING_PTR(filename), "/", 0, "", NULL, 1, 1, 0)) {
#elif RPM_VERSION_CODE < RPM_VERSION(5,0,0)
switch (parseSpec(ts, RSTRING_PTR(filename), "/", NULL, 0, "", NULL, 1, 1)) {
#else
switch (parseSpec(ts, RSTRING_PTR(filename), "/", 0, "", NULL, 1, 1, 0)) {
#endif
case 0:
if (ts != NULL) {
break;
}
default:
rb_raise(rb_eRuntimeError, "specfile `%s' parsing failed", RSTRING_PTR(filename));
}
return Data_Wrap_Struct(klass, NULL, ts_free, ts);
#endif
}
/*
*
* Alias for Spec#open
*/
VALUE
rpm_spec_open(const char* filename)
{
return spec_s_open(rpm_cSpec, rb_str_new2(filename));
}
/*
* @return [String] Return Build root defined in the spec file
*/
VALUE
rpm_spec_get_buildroot(VALUE spec)
{
#if RPM_VERSION_CODE < RPM_VERSION(4,5,90)
if (RPM_SPEC(spec)->buildRootURL) {
return rb_str_new2(RPM_SPEC(spec)->buildRootURL);
}
#elif RPM_VERSION_CODE < RPM_VERSION(4,5,90)
if (RPM_SPEC(spec)->rootURL) {
return rb_str_new2(RPM_SPEC(spec)->rootURL);
}
#elif RPM_VERSION_CODE < RPM_VERSION(5,0,0)
if (RPM_SPEC(spec)->buildRoot) {
return rb_str_new2(RPM_SPEC(spec)->buildRoot);
}
#else
const char *buildRootURL = rpmGenPath(RPM_SPEC(spec)->rootURL, "%{?buildroot}", NULL);
VALUE result = rb_str_new2(buildRootURL);
buildRootURL = _free(buildRootURL);
return result;
#endif
return Qnil;
}
/*
* @return [String] Return Build subdirectory defined in the spec file
*/
VALUE
rpm_spec_get_buildsubdir(VALUE spec)
{
if (RPM_SPEC(spec)->buildSubdir) {
return rb_str_new2(RPM_SPEC(spec)->buildSubdir);
}
return Qnil;
}
/*
* @return [Array<String>] Return Build architectures defined in the spec file
*/
VALUE
rpm_spec_get_buildarchs(VALUE spec)
{
VALUE ba = rb_ivar_get(spec, id_ba);
if (NIL_P(ba)) {
register int i;
ba = rb_ary_new();
for (i = 0; i < RPM_SPEC(spec)->BACount; i++) {
rb_ary_push(ba, rb_str_new2(RPM_SPEC(spec)->BANames[i]));
}
rb_ivar_set(spec, id_ba, ba);
}
return ba;
}
/*
* @return [Array<RPM::Require>] Return Build requires defined in the spec file
*/
VALUE
rpm_spec_get_buildrequires(VALUE spec)
{
VALUE br = rb_ivar_get(spec, id_br);
#if RPM_VERSION_CODE < RPM_VERSION(4,6,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0)
if (NIL_P(br)) {
const char** names;
const char** vers;
int_32* flags;
int_32 count;
rpmTagType nt, vt, type;
register int i;
br = rb_ary_new();
if (!headerGetEntryMinMemory(RPM_SPEC(spec)->buildRestrictions,
RPMTAG_REQUIRENAME, (hTYP_t)&nt,
(hPTR_t*)&names, (hCNT_t)&count)) {
goto leave;
}
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREVERSION,
&vt, (void*)&vers);
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREFLAGS,
&type, (void*)&flags);
for (i = 0; i < count; i++) {
rb_ary_push(br, rpm_require_new(names[i], rpm_version_new(vers[i]),
flags[i], spec));
}
release_entry(nt, names);
release_entry(vt, vers);
rb_ivar_set(spec, id_br, br);
}
leave:
return br;
#else
rpmtd nametd = rpmtdNew();
rpmtd versiontd = rpmtdNew();
rpmtd flagtd = rpmtdNew();
if (NIL_P(br)) {
br = rb_ary_new();
if (!headerGet(RPM_SPEC(spec)->buildRestrictions,
RPMTAG_REQUIRENAME, nametd, HEADERGET_MINMEM)) {
goto leave;
}
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREVERSION,
versiontd);
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREFLAGS,
flagtd);
rpmtdInit(nametd);
while ( rpmtdNext(nametd) != -1 ) {
rb_ary_push(br, rpm_require_new(rpmtdGetString(nametd), rpm_version_new(rpmtdNextString(versiontd)), *rpmtdNextUint32(flagtd), spec));
}
rb_ivar_set(spec, id_br, br);
}
leave:
rpmtdFree(nametd);
rpmtdFree(versiontd);
rpmtdFree(flagtd);
return br;
#endif
}
/*
* @return [Array<RPM::Conflict>] Return Build conflicts defined in the spec file
*/
VALUE
rpm_spec_get_buildconflicts(VALUE spec)
{
VALUE bc = rb_ivar_get(spec, id_bc);
#if RPM_VERSION_CODE < RPM_VERSION(4,6,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0)
if (NIL_P(bc)) {
const char** names;
const char** vers;
int_32* flags;
int_32 count;
rpmTagType nt, vt, type;
register int i;
bc = rb_ary_new();
if (!headerGetEntryMinMemory(RPM_SPEC(spec)->buildRestrictions,
RPMTAG_CONFLICTNAME, (hTYP_t)&nt,
(hPTR_t*)&names, (hCNT_t)&count)) {
goto leave;
}
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTVERSION,
&vt, (void*)&vers);
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTFLAGS,
&type, (void*)&flags);
for (i = 0; i < count; i++) {
rb_ary_push(bc, rpm_conflict_new(names[i], rpm_version_new(vers[i]),
flags[i], spec));
}
release_entry(nt, names);
release_entry(vt, vers);
rb_ivar_set(spec, id_bc, bc);
}
leave:
return bc;
#else
rpmtd nametd = rpmtdNew();
rpmtd versiontd = rpmtdNew();
rpmtd flagtd = rpmtdNew();
if (NIL_P(bc)) {
bc = rb_ary_new();
if (!headerGet(RPM_SPEC(spec)->buildRestrictions,
RPMTAG_CONFLICTNAME, nametd, HEADERGET_MINMEM)) {
goto leave;
}
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTVERSION,
versiontd);
get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTFLAGS,
flagtd);
rpmtdInit(nametd);
while ( rpmtdNext(nametd) != -1) {
rb_ary_push(bc, rpm_conflict_new(rpmtdGetString(nametd), rpm_version_new(rpmtdNextString(versiontd)), *rpmtdNextUint32(flagtd), spec));
}
rb_ivar_set(spec, id_bc, bc);
}
leave:
rpmtdFree(nametd);
rpmtdFree(versiontd);
rpmtdFree(flagtd);
return bc;
#endif
}
/** @todo Generalize --freshen policies. */
int rpmInstall(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_t fileArgv)
{
struct rpmEIU * eiu = xcalloc(1, sizeof(*eiu));
rpmps ps;
rpmprobFilterFlags probFilter;
rpmRelocation * relocations;
char * fileURL = NULL;
int stopInstall = 0;
rpmVSFlags vsflags, ovsflags, tvsflags;
int rc;
int xx;
int i;
if (fileArgv == NULL) goto exit;
rpmcliPackagesTotal = 0;
(void) rpmtsSetFlags(ts, ia->transFlags);
probFilter = ia->probFilter;
relocations = ia->relocations;
if (ia->installInterfaceFlags & INSTALL_UPGRADE)
vsflags = rpmExpandNumeric("%{?_vsflags_erase}");
else
vsflags = rpmExpandNumeric("%{?_vsflags_install}");
if (ia->qva_flags & VERIFY_DIGEST)
vsflags |= _RPMVSF_NODIGESTS;
if (ia->qva_flags & VERIFY_SIGNATURE)
vsflags |= _RPMVSF_NOSIGNATURES;
if (ia->qva_flags & VERIFY_HDRCHK)
vsflags |= RPMVSF_NOHDRCHK;
ovsflags = rpmtsSetVSFlags(ts, (vsflags | RPMVSF_NEEDPAYLOAD));
{ int notifyFlags;
notifyFlags = ia->installInterfaceFlags | (rpmIsVerbose() ? INSTALL_LABEL : 0 );
xx = rpmtsSetNotifyCallback(ts,
rpmShowProgress, (void *) ((long)notifyFlags));
}
if ((eiu->relocations = relocations) != NULL) {
while (eiu->relocations->oldPath)
eiu->relocations++;
if (eiu->relocations->newPath == NULL)
eiu->relocations = NULL;
}
/* Build fully globbed list of arguments in argv[argc]. */
for (eiu->fnp = fileArgv; *eiu->fnp != NULL; eiu->fnp++) {
ARGV_t av = NULL;
int ac = 0;
char * fn;
fn = rpmEscapeSpaces(*eiu->fnp);
rc = rpmGlob(fn, &ac, &av);
fn = _free(fn);
if (rc || ac == 0) {
rpmlog(RPMLOG_ERR, _("File not found by glob: %s\n"), *eiu->fnp);
eiu->numFailed++;
continue;
}
argvAppend(&(eiu->argv), av);
argvFree(av);
eiu->argc += ac;
}
restart:
/* Allocate sufficient storage for next set of args. */
if (eiu->pkgx >= eiu->numPkgs) {
eiu->numPkgs = eiu->pkgx + eiu->argc;
eiu->pkgURL = xrealloc(eiu->pkgURL,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgURL));
memset(eiu->pkgURL + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgURL)));
eiu->pkgState = xrealloc(eiu->pkgState,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgState));
memset(eiu->pkgState + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgState)));
}
/* Retrieve next set of args, cache on local storage. */
for (i = 0; i < eiu->argc; i++) {
fileURL = _free(fileURL);
fileURL = eiu->argv[i];
eiu->argv[i] = NULL;
switch (urlIsURL(fileURL)) {
case URL_IS_HTTPS:
case URL_IS_HTTP:
case URL_IS_FTP:
{ char *tfn;
FD_t tfd;
if (rpmIsVerbose())
fprintf(stdout, _("Retrieving %s\n"), fileURL);
tfd = rpmMkTempFile(rpmtsRootDir(ts), &tfn);
if (tfd && tfn) {
Fclose(tfd);
rc = urlGetFile(fileURL, tfn);
} else {
rc = -1;
}
if (rc != 0) {
rpmlog(RPMLOG_ERR,
_("skipping %s - transfer failed\n"), fileURL);
eiu->numFailed++;
eiu->pkgURL[eiu->pkgx] = NULL;
tfn = _free(tfn);
break;
}
eiu->pkgState[eiu->pkgx] = 1;
eiu->pkgURL[eiu->pkgx] = tfn;
eiu->pkgx++;
} break;
case URL_IS_PATH:
case URL_IS_DASH: /* WRONG WRONG WRONG */
case URL_IS_HKP: /* WRONG WRONG WRONG */
default:
eiu->pkgURL[eiu->pkgx] = fileURL;
fileURL = NULL;
eiu->pkgx++;
break;
}
}
fileURL = _free(fileURL);
if (eiu->numFailed) goto exit;
/* Continue processing file arguments, building transaction set. */
for (eiu->fnp = eiu->pkgURL+eiu->prevx;
*eiu->fnp != NULL;
eiu->fnp++, eiu->prevx++)
{
const char * fileName;
rpmlog(RPMLOG_DEBUG, "============== %s\n", *eiu->fnp);
(void) urlPath(*eiu->fnp, &fileName);
/* Try to read the header from a package file. */
eiu->fd = Fopen(*eiu->fnp, "r.ufdio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), *eiu->fnp,
Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
eiu->numFailed++; *eiu->fnp = NULL;
continue;
}
/* Read the header, verifying signatures (if present). */
tvsflags = rpmtsSetVSFlags(ts, vsflags);
eiu->rpmrc = rpmReadPackageFile(ts, eiu->fd, *eiu->fnp, &eiu->h);
tvsflags = rpmtsSetVSFlags(ts, tvsflags);
xx = Fclose(eiu->fd);
eiu->fd = NULL;
switch (eiu->rpmrc) {
case RPMRC_FAIL:
rpmlog(RPMLOG_ERR, _("%s cannot be installed\n"), *eiu->fnp);
eiu->numFailed++; *eiu->fnp = NULL;
continue;
break;
case RPMRC_NOTFOUND:
goto maybe_manifest;
break;
case RPMRC_NOTTRUSTED:
case RPMRC_NOKEY:
case RPMRC_OK:
default:
break;
}
eiu->isSource = headerIsSource(eiu->h);
if (eiu->isSource) {
rpmlog(RPMLOG_DEBUG, "\tadded source package [%d]\n",
eiu->numSRPMS);
eiu->sourceURL = xrealloc(eiu->sourceURL,
(eiu->numSRPMS + 2) * sizeof(*eiu->sourceURL));
eiu->sourceURL[eiu->numSRPMS] = *eiu->fnp;
*eiu->fnp = NULL;
eiu->numSRPMS++;
eiu->sourceURL[eiu->numSRPMS] = NULL;
continue;
}
if (eiu->relocations) {
struct rpmtd_s prefixes;
headerGet(eiu->h, RPMTAG_PREFIXES, &prefixes, HEADERGET_DEFAULT);
if (rpmtdCount(&prefixes) == 1) {
eiu->relocations->oldPath = xstrdup(rpmtdGetString(&prefixes));
rpmtdFreeData(&prefixes);
} else {
const char * name;
xx = headerNVR(eiu->h, &name, NULL, NULL);
rpmlog(RPMLOG_ERR,
_("package %s is not relocatable\n"), name);
eiu->numFailed++;
goto exit;
}
}
/* On --freshen, verify package is installed and newer */
if (ia->installInterfaceFlags & INSTALL_FRESHEN) {
rpmdbMatchIterator mi;
const char * name;
Header oldH;
int count;
xx = headerNVR(eiu->h, &name, NULL, NULL);
mi = rpmtsInitIterator(ts, RPMTAG_NAME, name, 0);
count = rpmdbGetIteratorCount(mi);
while ((oldH = rpmdbNextIterator(mi)) != NULL) {
if (rpmVersionCompare(oldH, eiu->h) < 0)
continue;
/* same or newer package already installed */
count = 0;
break;
}
mi = rpmdbFreeIterator(mi);
if (count == 0) {
eiu->h = headerFree(eiu->h);
continue;
}
/* Package is newer than those currently installed. */
}
rc = rpmtsAddInstallElement(ts, eiu->h, (fnpyKey)fileName,
(ia->installInterfaceFlags & INSTALL_UPGRADE) != 0,
relocations);
/* XXX reference held by transaction set */
eiu->h = headerFree(eiu->h);
if (eiu->relocations)
eiu->relocations->oldPath = _free(eiu->relocations->oldPath);
switch(rc) {
case 0:
rpmlog(RPMLOG_DEBUG, "\tadded binary package [%d]\n",
eiu->numRPMS);
break;
case 1:
rpmlog(RPMLOG_ERR,
_("error reading from file %s\n"), *eiu->fnp);
eiu->numFailed++;
goto exit;
break;
case 2:
rpmlog(RPMLOG_ERR,
_("file %s requires a newer version of RPM\n"),
*eiu->fnp);
eiu->numFailed++;
goto exit;
break;
default:
eiu->numFailed++;
goto exit;
break;
}
eiu->numRPMS++;
continue;
maybe_manifest:
/* Try to read a package manifest. */
eiu->fd = Fopen(*eiu->fnp, "r.fpio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), *eiu->fnp,
Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
eiu->numFailed++; *eiu->fnp = NULL;
break;
}
/* Read list of packages from manifest. */
/* FIX: *eiu->argv can be NULL */
rc = rpmReadPackageManifest(eiu->fd, &eiu->argc, &eiu->argv);
if (rc != RPMRC_OK)
rpmlog(RPMLOG_ERR, _("%s: not an rpm package (or package manifest): %s\n"),
*eiu->fnp, Fstrerror(eiu->fd));
xx = Fclose(eiu->fd);
eiu->fd = NULL;
/* If successful, restart the query loop. */
if (rc == RPMRC_OK) {
eiu->prevx++;
goto restart;
}
eiu->numFailed++; *eiu->fnp = NULL;
break;
}
rpmlog(RPMLOG_DEBUG, "found %d source and %d binary packages\n",
eiu->numSRPMS, eiu->numRPMS);
if (eiu->numFailed) goto exit;
if (eiu->numRPMS && !(ia->installInterfaceFlags & INSTALL_NODEPS)) {
if (rpmtsCheck(ts)) {
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
ps = rpmtsProblems(ts);
if (!stopInstall && rpmpsNumProblems(ps) > 0) {
rpmlog(RPMLOG_ERR, _("Failed dependencies:\n"));
rpmpsPrint(NULL, ps);
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
ps = rpmpsFree(ps);
}
if (eiu->numRPMS && !(ia->installInterfaceFlags & INSTALL_NOORDER)) {
if (rpmtsOrder(ts)) {
eiu->numFailed = eiu->numPkgs;
stopInstall = 1;
}
}
if (eiu->numRPMS && !stopInstall) {
rpmcliPackagesTotal += eiu->numSRPMS;
rpmlog(RPMLOG_DEBUG, "installing binary packages\n");
/* Drop added/available package indices and dependency sets. */
rpmtsClean(ts);
rc = rpmtsRun(ts, NULL, probFilter);
ps = rpmtsProblems(ts);
if (rc < 0) {
eiu->numFailed += eiu->numRPMS;
} else if (rc > 0) {
eiu->numFailed += rc;
if (rpmpsNumProblems(ps) > 0)
rpmpsPrint(stderr, ps);
}
ps = rpmpsFree(ps);
}
if (eiu->numSRPMS && !stopInstall) {
if (eiu->sourceURL != NULL)
for (i = 0; i < eiu->numSRPMS; i++) {
rpmdbCheckSignals();
if (eiu->sourceURL[i] == NULL) continue;
eiu->fd = Fopen(eiu->sourceURL[i], "r.ufdio");
if (eiu->fd == NULL || Ferror(eiu->fd)) {
rpmlog(RPMLOG_ERR, _("cannot open file %s: %s\n"),
eiu->sourceURL[i], Fstrerror(eiu->fd));
if (eiu->fd != NULL) {
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
continue;
}
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)) {
eiu->rpmrc = rpmInstallSourcePackage(ts, eiu->fd, NULL, NULL);
if (eiu->rpmrc != RPMRC_OK) eiu->numFailed++;
}
xx = Fclose(eiu->fd);
eiu->fd = NULL;
}
}
exit:
if (eiu->pkgURL != NULL)
for (i = 0; i < eiu->numPkgs; i++) {
if (eiu->pkgURL[i] == NULL) continue;
if (eiu->pkgState[i] == 1)
(void) unlink(eiu->pkgURL[i]);
eiu->pkgURL[i] = _free(eiu->pkgURL[i]);
}
eiu->pkgState = _free(eiu->pkgState);
eiu->pkgURL = _free(eiu->pkgURL);
eiu->argv = _free(eiu->argv);
rc = eiu->numFailed;
free(eiu);
rpmtsEmpty(ts);
return rc;
}
/** @todo Generalize --freshen policies. */
int rpmInstall(rpmts ts, struct rpmInstallArguments_s * ia, ARGV_t fileArgv)
{
struct rpmEIU * eiu = xcalloc(1, sizeof(*eiu));
rpmRelocation * relocations;
char * fileURL = NULL;
rpmVSFlags vsflags, ovsflags;
int rc;
int i;
vsflags = setvsFlags(ia);
ovsflags = rpmtsSetVSFlags(ts, (vsflags | RPMVSF_NEEDPAYLOAD));
if (fileArgv == NULL) goto exit;
(void) rpmtsSetFlags(ts, ia->transFlags);
relocations = ia->relocations;
setNotifyFlag(ia, ts);
if ((eiu->relocations = relocations) != NULL) {
while (eiu->relocations->oldPath)
eiu->relocations++;
if (eiu->relocations->newPath == NULL)
eiu->relocations = NULL;
}
/* Build fully globbed list of arguments in argv[argc]. */
for (eiu->fnp = fileArgv; *eiu->fnp != NULL; eiu->fnp++) {
ARGV_t av = NULL;
int ac = 0;
if (giFlags & RPMGI_NOGLOB) {
rc = rpmNoGlob(*eiu->fnp, &ac, &av);
} else {
char * fn = rpmEscapeSpaces(*eiu->fnp);
rc = rpmGlob(fn, &ac, &av);
fn = _free(fn);
}
if (rc || ac == 0) {
if (giFlags & RPMGI_NOGLOB) {
rpmlog(RPMLOG_ERR, _("File not found: %s\n"), *eiu->fnp);
} else {
rpmlog(RPMLOG_ERR, _("File not found by glob: %s\n"), *eiu->fnp);
}
eiu->numFailed++;
continue;
}
argvAppend(&(eiu->argv), av);
argvFree(av);
eiu->argc += ac;
}
restart:
/* Allocate sufficient storage for next set of args. */
if (eiu->pkgx >= eiu->numPkgs) {
eiu->numPkgs = eiu->pkgx + eiu->argc;
eiu->pkgURL = xrealloc(eiu->pkgURL,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgURL));
memset(eiu->pkgURL + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgURL)));
eiu->pkgState = xrealloc(eiu->pkgState,
(eiu->numPkgs + 1) * sizeof(*eiu->pkgState));
memset(eiu->pkgState + eiu->pkgx, 0,
((eiu->argc + 1) * sizeof(*eiu->pkgState)));
}
/* Retrieve next set of args, cache on local storage. */
for (i = 0; i < eiu->argc; i++) {
fileURL = _free(fileURL);
fileURL = eiu->argv[i];
eiu->argv[i] = NULL;
switch (urlIsURL(fileURL)) {
case URL_IS_HTTPS:
case URL_IS_HTTP:
case URL_IS_FTP:
{ char *tfn = NULL;
FD_t tfd;
if (rpmIsVerbose())
fprintf(stdout, _("Retrieving %s\n"), fileURL);
tfd = rpmMkTempFile(rpmtsRootDir(ts), &tfn);
if (tfd && tfn) {
Fclose(tfd);
rc = urlGetFile(fileURL, tfn);
} else {
rc = -1;
}
if (rc != 0) {
rpmlog(RPMLOG_ERR,
_("skipping %s - transfer failed\n"), fileURL);
eiu->numFailed++;
eiu->pkgURL[eiu->pkgx] = NULL;
tfn = _free(tfn);
break;
}
eiu->pkgState[eiu->pkgx] = 1;
eiu->pkgURL[eiu->pkgx] = tfn;
eiu->pkgx++;
} break;
case URL_IS_PATH:
case URL_IS_DASH: /* WRONG WRONG WRONG */
case URL_IS_HKP: /* WRONG WRONG WRONG */
default:
eiu->pkgURL[eiu->pkgx] = fileURL;
fileURL = NULL;
eiu->pkgx++;
break;
}
}
fileURL = _free(fileURL);
if (eiu->numFailed) goto exit;
/* Continue processing file arguments, building transaction set. */
for (eiu->fnp = eiu->pkgURL+eiu->prevx;
*eiu->fnp != NULL;
eiu->fnp++, eiu->prevx++)
{
Header h = NULL;
const char * fileName;
rpmlog(RPMLOG_DEBUG, "============== %s\n", *eiu->fnp);
(void) urlPath(*eiu->fnp, &fileName);
if (tryReadHeader(ts, eiu, &h) == RPMRC_FAIL)
continue;
if (eiu->rpmrc == RPMRC_NOTFOUND) {
rc = tryReadManifest(eiu);
if (rc == RPMRC_OK) {
eiu->prevx++;
goto restart;
}
}
if (headerIsSource(h)) {
if (ia->installInterfaceFlags & INSTALL_FRESHEN) {
headerFree(h);
continue;
}
rpmlog(RPMLOG_DEBUG, "\tadded source package [%d]\n",
eiu->numSRPMS);
eiu->sourceURL = xrealloc(eiu->sourceURL,
(eiu->numSRPMS + 2) * sizeof(*eiu->sourceURL));
eiu->sourceURL[eiu->numSRPMS] = *eiu->fnp;
*eiu->fnp = NULL;
eiu->numSRPMS++;
eiu->sourceURL[eiu->numSRPMS] = NULL;
continue;
}
if (eiu->relocations) {
struct rpmtd_s prefixes;
headerGet(h, RPMTAG_PREFIXES, &prefixes, HEADERGET_DEFAULT);
if (rpmtdCount(&prefixes) == 1) {
eiu->relocations->oldPath = xstrdup(rpmtdGetString(&prefixes));
rpmtdFreeData(&prefixes);
} else {
rpmlog(RPMLOG_ERR, _("package %s is not relocatable\n"),
headerGetString(h, RPMTAG_NAME));
eiu->numFailed++;
goto exit;
}
}
if (ia->installInterfaceFlags & INSTALL_FRESHEN)
if (checkFreshenStatus(ts, h) != 1) {
headerFree(h);
continue;
}
if (ia->installInterfaceFlags & INSTALL_REINSTALL)
rc = rpmtsAddReinstallElement(ts, h, (fnpyKey)fileName);
else
rc = rpmtsAddInstallElement(ts, h, (fnpyKey)fileName,
(ia->installInterfaceFlags & INSTALL_UPGRADE) != 0,
relocations);
headerFree(h);
if (eiu->relocations)
eiu->relocations->oldPath = _free(eiu->relocations->oldPath);
switch (rc) {
case 0:
rpmlog(RPMLOG_DEBUG, "\tadded binary package [%d]\n",
eiu->numRPMS);
break;
case 1:
rpmlog(RPMLOG_ERR,
_("error reading from file %s\n"), *eiu->fnp);
eiu->numFailed++;
goto exit;
break;
default:
eiu->numFailed++;
goto exit;
break;
}
eiu->numRPMS++;
}
rpmlog(RPMLOG_DEBUG, "found %d source and %d binary packages\n",
eiu->numSRPMS, eiu->numRPMS);
if (eiu->numFailed) goto exit;
if (eiu->numRPMS) {
int rc = rpmcliTransaction(ts, ia, eiu->numPkgs);
if (rc < 0)
eiu->numFailed += eiu->numRPMS;
else if (rc > 0)
eiu->numFailed += rc;
}
if (eiu->numSRPMS && (eiu->sourceURL != NULL)) {
rpmcliProgressState = 0;
rpmcliProgressTotal = 0;
rpmcliProgressCurrent = 0;
for (i = 0; i < eiu->numSRPMS; i++) {
rpmsqPoll();
if (eiu->sourceURL[i] != NULL) {
rc = RPMRC_OK;
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST))
rc = rpmInstallSource(ts, eiu->sourceURL[i], NULL, NULL);
if (rc != 0)
eiu->numFailed++;
}
}
}
exit:
if (eiu->pkgURL != NULL) {
for (i = 0; i < eiu->numPkgs; i++) {
if (eiu->pkgURL[i] == NULL) continue;
if (eiu->pkgState[i] == 1)
(void) unlink(eiu->pkgURL[i]);
eiu->pkgURL[i] = _free(eiu->pkgURL[i]);
}
}
eiu->pkgState = _free(eiu->pkgState);
eiu->pkgURL = _free(eiu->pkgURL);
eiu->argv = _free(eiu->argv);
rc = eiu->numFailed;
free(eiu);
rpmtsEmpty(ts);
rpmtsSetVSFlags(ts, ovsflags);
return rc;
}
cr_Package *
cr_package_from_header(Header hdr,
int changelog_limit,
cr_HeaderReadingFlags hdrrflags,
G_GNUC_UNUSED GError **err)
{
cr_Package *pkg;
assert(hdr);
assert(!err || *err == NULL);
// Create new package structure
pkg = cr_package_new();
pkg->loadingflags |= CR_PACKAGE_FROM_HEADER;
pkg->loadingflags |= CR_PACKAGE_LOADED_PRI;
pkg->loadingflags |= CR_PACKAGE_LOADED_FIL;
pkg->loadingflags |= CR_PACKAGE_LOADED_OTH;
// Create rpm tag data container
rpmtd td = rpmtdNew();
headerGetFlags flags = HEADERGET_MINMEM | HEADERGET_EXT;
// Fill package structure
pkg->name = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_NAME));
gint64 is_src = headerGetNumber(hdr, RPMTAG_SOURCEPACKAGE);
if (is_src) {
pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, "src");
} else {
pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_ARCH));
}
pkg->version = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VERSION));
#define MAX_STR_INT_LEN 24
char tmp_epoch[MAX_STR_INT_LEN];
if (snprintf(tmp_epoch, MAX_STR_INT_LEN, "%llu", (long long unsigned int) headerGetNumber(hdr, RPMTAG_EPOCH)) <= 0) {
tmp_epoch[0] = '\0';
}
pkg->epoch = g_string_chunk_insert_len(pkg->chunk, tmp_epoch, MAX_STR_INT_LEN);
pkg->release = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_RELEASE));
pkg->summary = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SUMMARY));
pkg->description = cr_safe_string_chunk_insert_null(pkg->chunk, headerGetString(hdr, RPMTAG_DESCRIPTION));
pkg->url = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_URL));
if (headerGet(hdr, RPMTAG_BUILDTIME, td, flags)) {
pkg->time_build = rpmtdGetNumber(td);
}
pkg->rpm_license = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_LICENSE));
pkg->rpm_vendor = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VENDOR));
pkg->rpm_group = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_GROUP));
pkg->rpm_buildhost = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_BUILDHOST));
pkg->rpm_sourcerpm = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SOURCERPM));
pkg->rpm_packager = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_PACKAGER));
if (headerGet(hdr, RPMTAG_SIZE, td, flags)) {
pkg->size_installed = rpmtdGetNumber(td);
}
if (headerGet(hdr, RPMTAG_ARCHIVESIZE, td, flags)) {
pkg->size_archive = rpmtdGetNumber(td);
}
rpmtdFreeData(td);
rpmtdFree(td);
//
// Fill files
//
rpmtd full_filenames = rpmtdNew(); // Only for filenames_hashtable
rpmtd indexes = rpmtdNew();
rpmtd filenames = rpmtdNew();
rpmtd fileflags = rpmtdNew();
rpmtd filemodes = rpmtdNew();
GHashTable *filenames_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
rpmtd dirnames = rpmtdNew();
// Create list of pointer to directory names
int dir_count;
char **dir_list = NULL;
if (headerGet(hdr, RPMTAG_DIRNAMES, dirnames, flags) && (dir_count = rpmtdCount(dirnames))) {
int x = 0;
dir_list = malloc(sizeof(char *) * dir_count);
while (rpmtdNext(dirnames) != -1) {
dir_list[x] = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(dirnames));
x++;
}
assert(x == dir_count);
}
if (headerGet(hdr, RPMTAG_FILENAMES, full_filenames, flags) &&
headerGet(hdr, RPMTAG_DIRINDEXES, indexes, flags) &&
headerGet(hdr, RPMTAG_BASENAMES, filenames, flags) &&
headerGet(hdr, RPMTAG_FILEFLAGS, fileflags, flags) &&
headerGet(hdr, RPMTAG_FILEMODES, filemodes, flags))
{
rpmtdInit(full_filenames);
rpmtdInit(indexes);
rpmtdInit(filenames);
rpmtdInit(fileflags);
rpmtdInit(filemodes);
while ((rpmtdNext(full_filenames) != -1) &&
(rpmtdNext(indexes) != -1) &&
(rpmtdNext(filenames) != -1) &&
(rpmtdNext(fileflags) != -1) &&
(rpmtdNext(filemodes) != -1))
{
cr_PackageFile *packagefile = cr_package_file_new();
packagefile->name = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(filenames));
packagefile->path = (dir_list) ? dir_list[(int) rpmtdGetNumber(indexes)] : "";
if (S_ISDIR(rpmtdGetNumber(filemodes))) {
// Directory
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "dir");
} else if (rpmtdGetNumber(fileflags) & RPMFILE_GHOST) {
// Ghost
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "ghost");
} else {
// Regular file
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "");
}
g_hash_table_replace(filenames_hashtable,
(gpointer) rpmtdGetString(full_filenames),
(gpointer) rpmtdGetString(full_filenames));
pkg->files = g_slist_prepend(pkg->files, packagefile);
}
pkg->files = g_slist_reverse (pkg->files);
rpmtdFreeData(dirnames);
rpmtdFreeData(indexes);
rpmtdFreeData(filenames);
rpmtdFreeData(fileflags);
rpmtdFreeData(filemodes);
}
rpmtdFree(dirnames);
rpmtdFree(indexes);
rpmtdFree(filemodes);
if (dir_list) {
free((void *) dir_list);
}
//
// PCOR (provides, conflicts, obsoletes, requires)
//
rpmtd fileversions = rpmtdNew();
// Struct used as value in ap_hashtable
struct ap_value_struct {
const char *flags;
const char *version;
int pre;
};
// Hastable with filenames from provided
GHashTable *provided_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
// Hashtable with already processed files from requires
GHashTable *ap_hashtable = g_hash_table_new_full(g_str_hash,
g_str_equal,
NULL,
free);
for (int deptype=0; dep_items[deptype].type != DEP_SENTINEL; deptype++) {
if (headerGet(hdr, dep_items[deptype].nametag, filenames, flags) &&
headerGet(hdr, dep_items[deptype].flagstag, fileflags, flags) &&
headerGet(hdr, dep_items[deptype].versiontag, fileversions, flags))
{
// Because we have to select only libc.so with highest version
// e.g. libc.so.6(GLIBC_2.4)
cr_Dependency *libc_require_highest = NULL;
rpmtdInit(filenames);
rpmtdInit(fileflags);
rpmtdInit(fileversions);
while ((rpmtdNext(filenames) != -1) &&
(rpmtdNext(fileflags) != -1) &&
(rpmtdNext(fileversions) != -1))
{
int pre = 0;
const char *filename = rpmtdGetString(filenames);
guint64 num_flags = rpmtdGetNumber(fileflags);
const char *flags = cr_flag_to_str(num_flags);
const char *full_version = rpmtdGetString(fileversions);
// Requires specific stuff
if (deptype == DEP_REQUIRES) {
// Skip requires which start with "rpmlib("
if (!strncmp("rpmlib(", filename, 7)) {
continue;
}
// Skip package primary files
if (g_hash_table_lookup_extended(filenames_hashtable, filename, NULL, NULL)) {
if (cr_is_primary(filename)) {
continue;
}
}
// Skip files which are provided
if (g_hash_table_lookup_extended(provided_hashtable, filename, NULL, NULL)) {
continue;
}
// Calculate pre value
if (num_flags & (RPMSENSE_PREREQ |
RPMSENSE_SCRIPT_PRE |
RPMSENSE_SCRIPT_POST))
{
pre = 1;
}
// Skip duplicate files
gpointer value;
if (g_hash_table_lookup_extended(ap_hashtable, filename, NULL, &value)) {
struct ap_value_struct *ap_value = value;
if (!g_strcmp0(ap_value->flags, flags) &&
!strcmp(ap_value->version, full_version) &&
(ap_value->pre == pre))
{
continue;
}
}
}
// Parse dep string
cr_EVR *evr = cr_str_to_evr(full_version, pkg->chunk);
if ((full_version && *full_version) && !evr->epoch) {
// NULL in epoch mean that the epoch was bad (non-numerical)
_cleanup_free_ gchar *pkg_nevra = cr_package_nevra(pkg);
g_warning("Bad epoch in version string \"%s\" for dependency \"%s\" in package \"%s\"",
full_version, filename, pkg_nevra);
g_warning("Skipping this dependency");
g_free(evr);
continue;
}
// Create dynamic dependency object
cr_Dependency *dependency = cr_dependency_new();
dependency->name = cr_safe_string_chunk_insert(pkg->chunk, filename);
dependency->flags = cr_safe_string_chunk_insert(pkg->chunk, flags);
dependency->epoch = evr->epoch;
dependency->version = evr->version;
dependency->release = evr->release;
g_free(evr);
switch (deptype) {
case DEP_PROVIDES:
g_hash_table_replace(provided_hashtable, dependency->name, dependency->name);
pkg->provides = g_slist_prepend(pkg->provides, dependency);
break;
case DEP_CONFLICTS:
pkg->conflicts = g_slist_prepend(pkg->conflicts, dependency);
break;
case DEP_OBSOLETES:
pkg->obsoletes = g_slist_prepend(pkg->obsoletes, dependency);
break;
case DEP_REQUIRES:
dependency->pre = pre;
// XXX: libc.so filtering ////////////////////////////
if (g_str_has_prefix(dependency->name, "libc.so.6")) {
if (!libc_require_highest)
libc_require_highest = dependency;
else {
if (cr_compare_dependency(libc_require_highest->name,
dependency->name) == 2)
{
g_free(libc_require_highest);
libc_require_highest = dependency;
} else
g_free(dependency);
}
break;
}
// XXX: libc.so filtering - END ///////////////////////
pkg->requires = g_slist_prepend(pkg->requires, dependency);
// Add file into ap_hashtable
struct ap_value_struct *value = malloc(sizeof(struct ap_value_struct));
value->flags = flags;
value->version = full_version;
value->pre = dependency->pre;
g_hash_table_replace(ap_hashtable, dependency->name, value);
break; //case REQUIRES end
case DEP_SUGGESTS:
pkg->suggests = g_slist_prepend(pkg->suggests, dependency);
break;
case DEP_ENHANCES:
pkg->enhances = g_slist_prepend(pkg->enhances, dependency);
break;
case DEP_RECOMMENDS:
pkg->recommends = g_slist_prepend(pkg->recommends, dependency);
break;
case DEP_SUPPLEMENTS:
pkg->supplements = g_slist_prepend(pkg->supplements, dependency);
break;
#ifdef ENABLE_LEGACY_WEAKDEPS
case DEP_OLDSUGGESTS:
if ( num_flags & RPMSENSE_STRONG ) {
pkg->recommends = g_slist_prepend(pkg->recommends, dependency);
} else {
pkg->suggests = g_slist_prepend(pkg->suggests, dependency);
}
break;
case DEP_OLDENHANCES:
if ( num_flags & RPMSENSE_STRONG ) {
pkg->supplements = g_slist_prepend(pkg->supplements, dependency);
} else {
pkg->enhances = g_slist_prepend(pkg->enhances, dependency);
}
break;
#endif
} // Switch end
} // While end
// XXX: libc.so filtering ////////////////////////////////
if (deptype == DEP_REQUIRES && libc_require_highest)
pkg->requires = g_slist_prepend(pkg->requires, libc_require_highest);
// XXX: libc.so filtering - END ////////////////////////////////
}
rpmtdFreeData(filenames);
rpmtdFreeData(fileflags);
rpmtdFreeData(fileversions);
}
pkg->provides = g_slist_reverse (pkg->provides);
pkg->conflicts = g_slist_reverse (pkg->conflicts);
pkg->obsoletes = g_slist_reverse (pkg->obsoletes);
pkg->requires = g_slist_reverse (pkg->requires);
pkg->suggests = g_slist_reverse (pkg->suggests);
pkg->enhances = g_slist_reverse (pkg->enhances);
pkg->recommends = g_slist_reverse (pkg->recommends);
pkg->supplements = g_slist_reverse (pkg->supplements);
g_hash_table_remove_all(filenames_hashtable);
g_hash_table_remove_all(provided_hashtable);
g_hash_table_remove_all(ap_hashtable);
g_hash_table_unref(filenames_hashtable);
g_hash_table_unref(provided_hashtable);
g_hash_table_unref(ap_hashtable);
rpmtdFree(filenames);
rpmtdFree(fileflags);
rpmtdFree(fileversions);
rpmtdFreeData(full_filenames);
rpmtdFree(full_filenames);
//
// Changelogs
//
rpmtd changelogtimes = rpmtdNew();
rpmtd changelognames = rpmtdNew();
rpmtd changelogtexts = rpmtdNew();
if (headerGet(hdr, RPMTAG_CHANGELOGTIME, changelogtimes, flags) &&
headerGet(hdr, RPMTAG_CHANGELOGNAME, changelognames, flags) &&
headerGet(hdr, RPMTAG_CHANGELOGTEXT, changelogtexts, flags))
{
gint64 last_time = G_GINT64_CONSTANT(0);
rpmtdInit(changelogtimes);
rpmtdInit(changelognames);
rpmtdInit(changelogtexts);
while ((rpmtdNext(changelogtimes) != -1) &&
(rpmtdNext(changelognames) != -1) &&
(rpmtdNext(changelogtexts) != -1) &&
(changelog_limit > 0 || changelog_limit == -1))
{
gint64 time = rpmtdGetNumber(changelogtimes);
cr_ChangelogEntry *changelog = cr_changelog_entry_new();
changelog->author = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(changelognames));
changelog->date = time;
changelog->changelog = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(changelogtexts));
// Remove space from end of author name
if (changelog->author) {
size_t len, x;
len = strlen(changelog->author);
for (x=(len-1); x > 0; x--) {
if (changelog->author[x] == ' ') {
changelog->author[x] = '\0';
} else {
break;
}
}
}
pkg->changelogs = g_slist_prepend(pkg->changelogs, changelog);
if (changelog_limit != -1)
changelog_limit--;
// If a previous entry has the same time, increment time of the previous
// entry by one. Ugly but works!
if (last_time == time) {
int tmp_time = time;
GSList *previous = pkg->changelogs;
while ((previous = g_slist_next(previous)) != NULL &&
((cr_ChangelogEntry *) (previous->data))->date == tmp_time) {
((cr_ChangelogEntry *) (previous->data))->date++;
tmp_time++;
}
} else {
last_time = time;
}
}
//pkg->changelogs = g_slist_reverse (pkg->changelogs);
}
rpmtdFreeData(changelogtimes);
rpmtdFreeData(changelognames);
rpmtdFreeData(changelogtexts);
rpmtdFree(changelogtimes);
rpmtdFree(changelognames);
rpmtdFree(changelogtexts);
//
// Keys and hdrid (data used for caching when the --cachedir is specified)
//
if (hdrrflags & CR_HDRR_LOADHDRID)
pkg->hdrid = cr_safe_string_chunk_insert(pkg->chunk,
headerGetString(hdr, RPMTAG_HDRID));
if (hdrrflags & CR_HDRR_LOADSIGNATURES) {
rpmtd gpgtd = rpmtdNew();
rpmtd pgptd = rpmtdNew();
if (headerGet(hdr, RPMTAG_SIGGPG, gpgtd, hdrrflags)
&& gpgtd->count > 0)
{
pkg->siggpg = cr_binary_data_new();
pkg->siggpg->size = gpgtd->count;
pkg->siggpg->data = g_string_chunk_insert_len(pkg->chunk,
gpgtd->data,
gpgtd->count);
}
if (headerGet(hdr, RPMTAG_SIGPGP, pgptd, hdrrflags)
&& pgptd->count > 0)
{
pkg->sigpgp = cr_binary_data_new();
pkg->sigpgp->size = pgptd->count;
pkg->sigpgp->data = g_string_chunk_insert_len(pkg->chunk,
pgptd->data,
pgptd->count);
}
rpmtdFree(gpgtd);
rpmtdFree(pgptd);
}
return pkg;
}
/* 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);
}
static void compressFilelist(Header h)
{
struct rpmtd_s fileNames;
char ** dirNames;
const char ** baseNames;
uint32_t * dirIndexes;
rpm_count_t count;
int i;
int dirIndex = -1;
/*
* This assumes the file list is already sorted, and begins with a
* single '/'. That assumption isn't critical, but it makes things go
* a bit faster.
*/
if (headerIsEntry(h, RPMTAG_DIRNAMES)) {
headerDel(h, RPMTAG_OLDFILENAMES);
return; /* Already converted. */
}
if (!headerGet(h, RPMTAG_OLDFILENAMES, &fileNames, HEADERGET_MINMEM))
return;
count = rpmtdCount(&fileNames);
if (count < 1)
return;
dirNames = xmalloc(sizeof(*dirNames) * count); /* worst case */
baseNames = xmalloc(sizeof(*dirNames) * count);
dirIndexes = xmalloc(sizeof(*dirIndexes) * count);
/* HACK. Source RPM, so just do things differently */
{ const char *fn = rpmtdGetString(&fileNames);
if (fn && *fn != '/') {
dirIndex = 0;
dirNames[dirIndex] = xstrdup("");
while ((i = rpmtdNext(&fileNames)) >= 0) {
dirIndexes[i] = dirIndex;
baseNames[i] = rpmtdGetString(&fileNames);
}
goto exit;
}
}
/*
* XXX EVIL HACK, FIXME:
* This modifies (and then restores) a const string from rpmtd
* through basename retrieved from strrchr() which silently
* casts away const on return.
*/
while ((i = rpmtdNext(&fileNames)) >= 0) {
char ** needle;
char savechar;
char * baseName;
size_t len;
char *filename = (char *) rpmtdGetString(&fileNames); /* HACK HACK */
if (filename == NULL) /* XXX can't happen */
continue;
baseName = strrchr(filename, '/') + 1;
len = baseName - filename;
needle = dirNames;
savechar = *baseName;
*baseName = '\0';
if (dirIndex < 0 ||
(needle = bsearch(&filename, dirNames, dirIndex + 1, sizeof(dirNames[0]), dncmp)) == NULL) {
char *s = xmalloc(len + 1);
rstrlcpy(s, filename, len + 1);
dirIndexes[i] = ++dirIndex;
dirNames[dirIndex] = s;
} else
dirIndexes[i] = needle - dirNames;
*baseName = savechar;
baseNames[i] = baseName;
}
exit:
if (count > 0) {
headerPutUint32(h, RPMTAG_DIRINDEXES, dirIndexes, count);
headerPutStringArray(h, RPMTAG_BASENAMES, baseNames, count);
headerPutStringArray(h, RPMTAG_DIRNAMES,
(const char **) dirNames, dirIndex + 1);
}
rpmtdFreeData(&fileNames);
for (i = 0; i <= dirIndex; i++) {
free(dirNames[i]);
}
free(dirNames);
free(baseNames);
free(dirIndexes);
headerDel(h, RPMTAG_OLDFILENAMES);
}
/* 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, fingerPrintCache fpc)
{
rpmps ps;
rpmte p;
rpmfi fi;
rpmfs fs;
rpmfi otherFi=NULL;
int j;
int xx;
unsigned int fileNum;
const char * oldDir;
rpmdbMatchIterator mi;
Header h, newheader;
int beingRemoved;
rpmlog(RPMLOG_DEBUG, "computing file dispositions\n");
mi = rpmFindBaseNamesInDB(ts);
/* For all installed headers with matching basename's ... */
if (mi == NULL)
return;
if (rpmdbGetIteratorCount(mi) == 0) {
mi = rpmdbFreeIterator(mi);
return;
}
ps = rpmtsProblems(ts);
/* 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 fp;
unsigned int installedPkg;
/* Is this package being removed? */
installedPkg = rpmdbGetIteratorOffset(mi);
beingRemoved = 0;
if (ts->removedPackages != NULL)
for (j = 0; j < ts->numRemovedPackages; j++) {
if (ts->removedPackages[j] != installedPkg)
continue;
beingRemoved = 1;
break;
}
h = headerLink(h);
headerGet(h, RPMTAG_BASENAMES, &bnames, hgflags);
headerGet(h, RPMTAG_DIRNAMES, &dnames, hgflags);
headerGet(h, RPMTAG_DIRINDEXES, &dindexes, hgflags);
headerGet(h, RPMTAG_FILESTATES, &ostates, hgflags);
oldDir = NULL;
/* loop over all interesting files in that package */
do {
int gotRecs;
struct rpmffi_s * recs;
int numRecs;
const char * dirName;
const char * baseName;
fileNum = rpmdbGetIteratorFileNum(mi);
rpmtdSetIndex(&bnames, fileNum);
rpmtdSetIndex(&dindexes, fileNum);
rpmtdSetIndex(&dnames, *rpmtdGetUint32(&dindexes));
rpmtdSetIndex(&ostates, fileNum);
dirName = rpmtdGetString(&dnames);
baseName = rpmtdGetString(&bnames);
/* lookup finger print for this file */
if ( dirName == oldDir) {
/* directory is the same as last round */
fp.baseName = baseName;
} else {
fp = fpLookup(fpc, dirName, baseName, 1);
oldDir = dirName;
}
/* search for files in the transaction with same finger print */
gotRecs = rpmFpHashGetEntry(ts->ht, &fp, &recs, &numRecs, NULL);
for (j=0; (j<numRecs)&&gotRecs; j++) {
p = recs[j].p;
fi = rpmteFI(p);
fs = rpmteGetFileStates(p);
/* Determine the fate of each file. */
switch (rpmteType(p)) {
case TR_ADDED:
if (!otherFi) {
otherFi = rpmfiNew(ts, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER);
}
rpmfiSetFX(fi, recs[j].fileno);
rpmfiSetFX(otherFi, fileNum);
xx = handleInstInstalledFile(ts, p, fi, h, otherFi, beingRemoved);
break;
case TR_REMOVED:
if (!beingRemoved) {
rpmfiSetFX(fi, recs[j].fileno);
if (*rpmtdGetChar(&ostates) == RPMFILE_STATE_NORMAL)
rpmfsSetAction(fs, recs[j].fileno, FA_SKIP);
}
break;
}
}
newheader = rpmdbNextIterator(mi);
} while (newheader==h);
otherFi = rpmfiFree(otherFi);
rpmtdFreeData(&ostates);
rpmtdFreeData(&bnames);
rpmtdFreeData(&dnames);
rpmtdFreeData(&dindexes);
headerFree(h);
h = newheader;
}
mi = rpmdbFreeIterator(mi);
}
void
rpmhdrs_diff_prnt_block (gboolean changelogs, struct RpmHeadersDiff *diff)
{
int num = 0;
g_assert (diff->hs_mod_old->len == diff->hs_mod_new->len);
if (diff->hs_mod_old->len)
{
gboolean done = FALSE;
for (num = 0; num < diff->hs_mod_new->len; ++num)
{
Header ho = diff->hs_mod_old->pdata[num];
Header hn = diff->hs_mod_new->pdata[num];
struct rpmtd_s ochanges_date_s;
_cleanup_rpmtddata_ rpmtd ochanges_date = NULL;
struct rpmtd_s ochanges_name_s;
_cleanup_rpmtddata_ rpmtd ochanges_name = NULL;
struct rpmtd_s ochanges_text_s;
_cleanup_rpmtddata_ rpmtd ochanges_text = NULL;
struct rpmtd_s nchanges_date_s;
_cleanup_rpmtddata_ rpmtd nchanges_date = NULL;
struct rpmtd_s nchanges_name_s;
_cleanup_rpmtddata_ rpmtd nchanges_name = NULL;
struct rpmtd_s nchanges_text_s;
_cleanup_rpmtddata_ rpmtd nchanges_text = NULL;
int ocnum = 0;
int ncnum = 0;
uint64_t ochange_date = 0;
const char *ochange_name = NULL;
const char *ochange_text = NULL;
uint64_t nchange_date = 0;
const char *nchange_name = NULL;
const char *nchange_text = NULL;
g_assert (!header_name_cmp (ho, hn));
if (rpmVersionCompare (ho, hn) > 0)
continue;
if (!done)
{
done = TRUE;
g_print ("Upgraded:\n");
}
printf (" ");
pkg_print (hn);
if (!changelogs)
continue;
/* Load the old %changelog entries */
ochanges_date = &ochanges_date_s;
headerGet (ho, RPMTAG_CHANGELOGTIME, ochanges_date, HEADERGET_MINMEM);
ochanges_name = &ochanges_name_s;
headerGet (ho, RPMTAG_CHANGELOGNAME, ochanges_name, HEADERGET_MINMEM);
ochanges_text = &ochanges_text_s;
headerGet (ho, RPMTAG_CHANGELOGTEXT, ochanges_text, HEADERGET_MINMEM);
ocnum = rpmtdCount (ochanges_date);
if (!ocnum)
continue;
/* Load the new %changelog entries */
nchanges_date = &nchanges_date_s;
headerGet (hn, RPMTAG_CHANGELOGTIME, nchanges_date, HEADERGET_MINMEM);
nchanges_name = &nchanges_name_s;
headerGet (hn, RPMTAG_CHANGELOGNAME, nchanges_name, HEADERGET_MINMEM);
nchanges_text = &nchanges_text_s;
headerGet (hn, RPMTAG_CHANGELOGTEXT, nchanges_text, HEADERGET_MINMEM);
ncnum = rpmtdCount (nchanges_date);
if (!ncnum)
continue;
/* Load the latest old %changelog entry. */
ochange_date = rpmtdGetNumber (ochanges_date);
ochange_name = rpmtdGetString (ochanges_name);
ochange_text = rpmtdGetString (ochanges_text);
while (ncnum > 0)
{
GDateTime *dt = NULL;
g_autofree char *date_time_str = NULL;
/* Load next new %changelog entry, starting at the newest. */
rpmtdNext (nchanges_date);
rpmtdNext (nchanges_name);
rpmtdNext (nchanges_text);
nchange_date = rpmtdGetNumber (nchanges_date);
nchange_name = rpmtdGetString (nchanges_name);
nchange_text = rpmtdGetString (nchanges_text);
/* If we are now older than, or match, the latest old %changelog
* then we are done. */
if (ochange_date > nchange_date)
break;
if ((ochange_date == nchange_date) &&
g_str_equal (ochange_name, nchange_name) &&
g_str_equal (ochange_text, nchange_text))
break;
/* Otherwise, print. */
dt = g_date_time_new_from_unix_utc (nchange_date);
date_time_str = g_date_time_format (dt, "%a %b %d %Y");
g_date_time_unref (dt);
printf ("* %s %s\n%s\n\n", date_time_str, nchange_name,
nchange_text);
--ncnum;
}
}
done = FALSE;
for (num = 0; num < diff->hs_mod_new->len; ++num)
{
Header ho = diff->hs_mod_old->pdata[num];
Header hn = diff->hs_mod_new->pdata[num];
g_assert (!header_name_cmp (ho, hn));
if (rpmVersionCompare (ho, hn) < 0)
continue;
if (!done)
{
done = TRUE;
g_print ("Downgraded:\n");
}
printf (" ");
pkg_print (hn);
}
}
if (diff->hs_del->len)
{
g_print ("Removed:\n");
for (num = 0; num < diff->hs_del->len; ++num)
{
Header hd = diff->hs_del->pdata[num];
printf (" ");
pkg_print (hd);
}
}
if (diff->hs_add->len)
{
g_print ("Added:\n");
for (num = 0; num < diff->hs_add->len; ++num)
{
Header ha = diff->hs_add->pdata[num];
printf (" ");
pkg_print (ha);
}
}
rpmhdrs_diff_free (diff);
}
