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;
}
static int isNewDep(rpmds *dsp, rpmds bds,
Header h, rpmTagVal indextag, uint32_t index)
{
int isnew = 1;
if (!indextag) {
/* With normal deps, we can just merge and see if anything got added */
isnew = (rpmdsMerge(dsp, bds) > 0);
} else {
struct rpmtd_s idx;
rpmds ads = *dsp;
headerGet(h, indextag, &idx, HEADERGET_MINMEM);
/* rpmdsFind/Merge() probably isn't realiable with triggers... */
rpmdsInit(ads);
while (isnew && rpmdsNext(ads) >= 0) {
if (!rstreq(rpmdsN(ads), rpmdsN(bds))) continue;
if (!rstreq(rpmdsEVR(ads), rpmdsEVR(bds))) continue;
if (rpmdsFlags(ads) != rpmdsFlags(bds)) continue;
if (indextag && rpmtdSetIndex(&idx, rpmdsIx(ads)) >= 0 &&
rpmtdGetNumber(&idx) != index) continue;
isnew = 0;
}
rpmtdFreeData(&idx);
rpmdsMerge(dsp, bds);
}
return isnew;
}
/**
* 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;
}
static char * verifyFlags(rpmtd td, const char *pad)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
val = rpmVerifyString(rpmtdGetNumber(td), pad);
}
return val;
}
static char * numFormat(rpmtd td, const char *format)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
rasprintf(&val, format, rpmtdGetNumber(td));
}
return val;
}
/**
* Format file flags for display.
* @param td tag data container
* @return formatted string
*/
static char * fflagsFormat(rpmtd td)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
val = rpmFFlagsString(rpmtdGetNumber(td), "");
}
return val;
}
uint64_t headerGetNumber(Header h, rpmTag tag)
{
uint64_t res = 0;
struct rpmtd_s td;
if (headerGet(h, tag, &td, HEADERGET_EXT)) {
if (rpmtdCount(&td) == 1) {
res = rpmtdGetNumber(&td);
}
rpmtdFreeData(&td);
}
return res;
}
/**
* Identify type of dependency.
* @param td tag data container
* @return formatted string
*/
static char * deptypeFormat(rpmtd td)
{
char *val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
ARGV_t sdeps = NULL;
uint64_t item = rpmtdGetNumber(td);
if (item & RPMSENSE_SCRIPT_PRE)
argvAdd(&sdeps, "pre");
if (item & RPMSENSE_SCRIPT_POST)
argvAdd(&sdeps, "post");
if (item & RPMSENSE_SCRIPT_PREUN)
argvAdd(&sdeps, "preun");
if (item & RPMSENSE_SCRIPT_POSTUN)
argvAdd(&sdeps, "postun");
if (item & RPMSENSE_SCRIPT_VERIFY)
argvAdd(&sdeps, "verify");
if (item & RPMSENSE_INTERP)
argvAdd(&sdeps, "interp");
if (item & RPMSENSE_RPMLIB)
argvAdd(&sdeps, "rpmlib");
if ((item & RPMSENSE_FIND_REQUIRES) || (item & RPMSENSE_FIND_PROVIDES))
argvAdd(&sdeps, "auto");
if (item & RPMSENSE_PREREQ)
argvAdd(&sdeps, "prereq");
if (item & RPMSENSE_PRETRANS)
argvAdd(&sdeps, "pretrans");
if (item & RPMSENSE_POSTTRANS)
argvAdd(&sdeps, "posttrans");
if (item & RPMSENSE_CONFIG)
argvAdd(&sdeps, "config");
if (item & RPMSENSE_MISSINGOK)
argvAdd(&sdeps, "missingok");
if (sdeps) {
val = argvJoin(sdeps, ",");
} else {
val = xstrdup("manual");
}
argvFree(sdeps);
}
return val;
}
/**
* Format dependency flags for display.
* @param td tag data container
* @return formatted string
*/
static char * depflagsFormat(rpmtd td)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
uint64_t anint = rpmtdGetNumber(td);
val = xcalloc(4, 1);
if (anint & RPMSENSE_LESS)
strcat(val, "<");
if (anint & RPMSENSE_GREATER)
strcat(val, ">");
if (anint & RPMSENSE_EQUAL)
strcat(val, "=");
}
return val;
}
/**
* 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;
}
/*
* 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;
}
/**
* Identify type of trigger.
* @param td tag data container
* @return formatted string
*/
static char * triggertypeFormat(rpmtd td)
{
char * val;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
uint64_t item = rpmtdGetNumber(td);
if (item & RPMSENSE_TRIGGERPREIN)
val = xstrdup("prein");
else if (item & RPMSENSE_TRIGGERIN)
val = xstrdup("in");
else if (item & RPMSENSE_TRIGGERUN)
val = xstrdup("un");
else if (item & RPMSENSE_TRIGGERPOSTUN)
val = xstrdup("postun");
else
val = xstrdup("");
}
return val;
}
/**
* @param td tag data container
* @return formatted string
*/
static char * realDateFormat(rpmtd td, const char * strftimeFormat)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
struct tm * tstruct;
char buf[50];
time_t dateint = rpmtdGetNumber(td);
tstruct = localtime(&dateint);
/* XXX TODO: deal with non-fitting date string correctly */
buf[0] = '\0';
if (tstruct)
(void) strftime(buf, sizeof(buf) - 1, strftimeFormat, tstruct);
val = xstrdup(buf);
}
return val;
}
/**
* @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 char * fstateFormat(rpmtd td)
{
char * val = NULL;
if (rpmtdClass(td) != RPM_NUMERIC_CLASS) {
val = xstrdup(_("(not a number)"));
} else {
const char * str;
rpmfileState fstate = rpmtdGetNumber(td);
switch (fstate) {
case RPMFILE_STATE_NORMAL:
str = _("normal");
break;
case RPMFILE_STATE_REPLACED:
str = _("replaced");
break;
case RPMFILE_STATE_NOTINSTALLED:
str = _("not installed");
break;
case RPMFILE_STATE_NETSHARED:
str = _("net shared");
break;
case RPMFILE_STATE_WRONGCOLOR:
str = _("wrong color");
break;
case RPMFILE_STATE_MISSING:
str = _("missing");
break;
default:
str = _("(unknown)");
break;
}
val = xstrdup(str);
}
return val;
}
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);
}
/**
* Execute triggers.
* @todo Trigger on any provides, not just package NVR.
* @param psm package state machine data
* @param sourceH header of trigger source
* @param trigH header of triggered package
* @param arg2
* @param triggersAlreadyRun
* @return
*/
static rpmRC handleOneTrigger(const rpmpsm psm,
Header sourceH, Header trigH,
int arg2, unsigned char * triggersAlreadyRun)
{
const rpmts ts = psm->ts;
rpmds trigger = rpmdsInit(rpmdsNew(trigH, RPMTAG_TRIGGERNAME, 0));
struct rpmtd_s pfx;
const char * sourceName = headerGetString(sourceH, RPMTAG_NAME);
const char * triggerName = headerGetString(trigH, RPMTAG_NAME);
rpmRC rc = RPMRC_OK;
int i;
if (trigger == NULL)
return rc;
headerGet(trigH, RPMTAG_INSTPREFIXES, &pfx, HEADERGET_ALLOC|HEADERGET_ARGV);
(void) rpmdsSetNoPromote(trigger, 1);
while ((i = rpmdsNext(trigger)) >= 0) {
struct rpmtd_s tindexes;
uint32_t tix;
if (!(rpmdsFlags(trigger) & psm->sense))
continue;
if (!rstreq(rpmdsN(trigger), sourceName))
continue;
/* XXX Trigger on any provided dependency, not just the package NEVR */
if (!rpmdsAnyMatchesDep(sourceH, trigger, 1))
continue;
if (!headerGet(trigH, RPMTAG_TRIGGERINDEX, &tindexes, HEADERGET_MINMEM))
continue;
if (rpmtdSetIndex(&tindexes, i) < 0) {
rpmtdFreeData(&tindexes);
continue;
}
tix = rpmtdGetNumber(&tindexes);
if (triggersAlreadyRun == NULL || triggersAlreadyRun[tix] == 0) {
int arg1 = rpmdbCountPackages(rpmtsGetRdb(ts), triggerName);
if (arg1 < 0) {
/* XXX W2DO? fails as "execution of script failed" */
rc = RPMRC_FAIL;
} else {
rpmScript script = rpmScriptFromTriggerTag(trigH,
triggertag(psm->sense), tix);
arg1 += psm->countCorrection;
rc = runScript(psm, pfx.data, script, arg1, arg2);
if (triggersAlreadyRun != NULL)
triggersAlreadyRun[tix] = 1;
rpmScriptFree(script);
}
}
rpmtdFreeData(&tindexes);
/*
* Each target/source header pair can only result in a single
* script being run.
*/
break;
}
rpmtdFreeData(&pfx);
rpmdsFree(trigger);
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;
}
void rpmRelocateFileList(rpmRelocation *relocations, int numRelocations,
rpmfs fs, Header h)
{
char ** baseNames;
char ** dirNames;
uint32_t * dirIndexes;
rpm_count_t fileCount, dirCount;
int nrelocated = 0;
int fileAlloced = 0;
char * fn = NULL;
int haveRelocatedBase = 0;
size_t maxlen = 0;
int i, j;
struct rpmtd_s bnames, dnames, dindexes, fmodes;
if (!addPrefixes(h, relocations, numRelocations))
return;
if (rpmIsDebug()) {
rpmlog(RPMLOG_DEBUG, "========== relocations\n");
for (i = 0; i < numRelocations; i++) {
if (relocations[i].oldPath == NULL) continue; /* XXX can't happen */
if (relocations[i].newPath == NULL)
rpmlog(RPMLOG_DEBUG, "%5d exclude %s\n",
i, relocations[i].oldPath);
else
rpmlog(RPMLOG_DEBUG, "%5d relocate %s -> %s\n",
i, relocations[i].oldPath, relocations[i].newPath);
}
}
for (i = 0; i < numRelocations; i++) {
if (relocations[i].newPath == NULL) continue;
size_t len = strlen(relocations[i].newPath);
if (len > maxlen) maxlen = len;
}
headerGet(h, RPMTAG_BASENAMES, &bnames, HEADERGET_MINMEM);
headerGet(h, RPMTAG_DIRINDEXES, &dindexes, HEADERGET_ALLOC);
headerGet(h, RPMTAG_DIRNAMES, &dnames, HEADERGET_MINMEM);
headerGet(h, RPMTAG_FILEMODES, &fmodes, HEADERGET_MINMEM);
/* TODO XXX ugh.. use rpmtd iterators & friends instead */
baseNames = bnames.data;
dirIndexes = dindexes.data;
fileCount = rpmtdCount(&bnames);
dirCount = rpmtdCount(&dnames);
/* XXX TODO: use rpmtdDup() instead */
dirNames = dnames.data = duparray(dnames.data, dirCount);
dnames.flags |= RPMTD_PTR_ALLOCED;
/*
* For all relocations, we go through sorted file/relocation lists
* backwards so that /usr/local relocations take precedence over /usr
* ones.
*/
/* Relocate individual paths. */
for (i = fileCount - 1; i >= 0; i--) {
rpmFileTypes ft;
int fnlen;
size_t len = maxlen +
strlen(dirNames[dirIndexes[i]]) + strlen(baseNames[i]) + 1;
if (len >= fileAlloced) {
fileAlloced = len * 2;
fn = xrealloc(fn, fileAlloced);
}
assert(fn != NULL); /* XXX can't happen */
*fn = '\0';
fnlen = stpcpy( stpcpy(fn, dirNames[dirIndexes[i]]), baseNames[i]) - fn;
/*
* See if this file path needs relocating.
*/
/*
* XXX FIXME: Would a bsearch of the (already sorted)
* relocation list be a good idea?
*/
for (j = numRelocations - 1; j >= 0; j--) {
if (relocations[j].oldPath == NULL) /* XXX can't happen */
continue;
len = !rstreq(relocations[j].oldPath, "/")
? strlen(relocations[j].oldPath)
: 0;
if (fnlen < len)
continue;
/*
* Only subdirectories or complete file paths may be relocated. We
* don't check for '\0' as our directory names all end in '/'.
*/
if (!(fn[len] == '/' || fnlen == len))
continue;
if (!rstreqn(relocations[j].oldPath, fn, len))
continue;
break;
}
if (j < 0) continue;
rpmtdSetIndex(&fmodes, i);
ft = rpmfiWhatis(rpmtdGetNumber(&fmodes));
/* On install, a relocate to NULL means skip the path. */
if (relocations[j].newPath == NULL) {
if (ft == XDIR) {
/* Start with the parent, looking for directory to exclude. */
for (j = dirIndexes[i]; j < dirCount; j++) {
len = strlen(dirNames[j]) - 1;
while (len > 0 && dirNames[j][len-1] == '/') len--;
if (fnlen != len)
continue;
if (!rstreqn(fn, dirNames[j], fnlen))
continue;
break;
}
}
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
rpmlog(RPMLOG_DEBUG, "excluding %s %s\n",
ftstring(ft), fn);
continue;
}
/* Relocation on full paths only, please. */
if (fnlen != len) continue;
rpmlog(RPMLOG_DEBUG, "relocating %s to %s\n",
fn, relocations[j].newPath);
nrelocated++;
strcpy(fn, relocations[j].newPath);
{ char * te = strrchr(fn, '/');
if (te) {
if (te > fn) te++; /* root is special */
fnlen = te - fn;
} else
te = fn + strlen(fn);
if (!rstreq(baseNames[i], te)) { /* basename changed too? */
if (!haveRelocatedBase) {
/* XXX TODO: use rpmtdDup() instead */
bnames.data = baseNames = duparray(baseNames, fileCount);
bnames.flags |= RPMTD_PTR_ALLOCED;
haveRelocatedBase = 1;
}
free(baseNames[i]);
baseNames[i] = xstrdup(te);
}
*te = '\0'; /* terminate new directory name */
}
/* Does this directory already exist in the directory list? */
for (j = 0; j < dirCount; j++) {
if (fnlen != strlen(dirNames[j]))
continue;
if (!rstreqn(fn, dirNames[j], fnlen))
continue;
break;
}
if (j < dirCount) {
dirIndexes[i] = j;
continue;
}
/* Creating new paths is a pita */
dirNames = dnames.data = xrealloc(dnames.data,
sizeof(*dirNames) * (dirCount + 1));
dirNames[dirCount] = xstrdup(fn);
dirIndexes[i] = dirCount;
dirCount++;
dnames.count++;
}
/* Finish off by relocating directories. */
for (i = dirCount - 1; i >= 0; i--) {
for (j = numRelocations - 1; j >= 0; j--) {
if (relocations[j].oldPath == NULL) /* XXX can't happen */
continue;
size_t len = !rstreq(relocations[j].oldPath, "/")
? strlen(relocations[j].oldPath)
: 0;
if (len && !rstreqn(relocations[j].oldPath, dirNames[i], len))
continue;
/*
* Only subdirectories or complete file paths may be relocated. We
* don't check for '\0' as our directory names all end in '/'.
*/
if (dirNames[i][len] != '/')
continue;
if (relocations[j].newPath) { /* Relocate the path */
char *t = NULL;
rstrscat(&t, relocations[j].newPath, (dirNames[i] + len), NULL);
/* Unfortunately rpmCleanPath strips the trailing slash.. */
(void) rpmCleanPath(t);
rstrcat(&t, "/");
rpmlog(RPMLOG_DEBUG,
"relocating directory %s to %s\n", dirNames[i], t);
free(dirNames[i]);
dirNames[i] = t;
nrelocated++;
}
}
}
/* Save original filenames in header and replace (relocated) filenames. */
if (nrelocated) {
saveOrig(h);
headerMod(h, &bnames);
headerMod(h, &dnames);
headerMod(h, &dindexes);
}
rpmtdFreeData(&bnames);
rpmtdFreeData(&dnames);
rpmtdFreeData(&dindexes);
rpmtdFreeData(&fmodes);
free(fn);
}
/* ---------------------------------------------------------------------
*/
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;
}