/** \ingroup header
* \file lib/formats.c
*/
#include "system.h"
#include <inttypes.h>
#include <rpm/rpmtypes.h>
#include <rpm/rpmtd.h>
#include <rpm/rpmds.h>
#include <rpm/rpmfi.h>
#include <rpm/rpmstring.h>
#include <rpm/rpmmacro.h>
#include <rpm/rpmbase64.h>
#include "rpmio/digest.h"
#include "lib/manifest.h"
#include "lib/misc.h"
#include "lib/signature.h"
#include "debug.h"
#define RPM_ANY_CLASS 255
typedef char * (*headerTagFormatFunction) (rpmtd td, char **emsg);
/** \ingroup header
* Define header tag output formats.
*/
struct headerFmt_s {
rpmtdFormats fmt; /*!< Value of extension */
const char *name; /*!< Name of extension. */
rpmTagClass class; /*!< Class of source data (RPM_ANY_CLASS for any) */
headerTagFormatFunction func; /*!< Pointer to formatter function. */
};
static const char *classEr(rpmTagClass class)
{
switch (class) {
case RPM_BINARY_CLASS: return _("(not a blob)");
case RPM_NUMERIC_CLASS: return _("(not a number)");
case RPM_STRING_CLASS: return _("(not a string)");
default: break;
}
return _("(invalid type)");
}
/* barebones string representation with no extra formatting */
static char * stringFormat(rpmtd td, char **emsg)
{
char *val = NULL;
switch (rpmtdClass(td)) {
case RPM_NUMERIC_CLASS:
rasprintf(&val, "%" PRIu64, rpmtdGetNumber(td));
break;
case RPM_STRING_CLASS: {
const char *str = rpmtdGetString(td);
if (str)
val = xstrdup(str);
break;
}
case RPM_BINARY_CLASS:
val = pgpHexStr(td->data, td->count);
break;
default:
*emsg = xstrdup("(unknown type)");
break;
}
return val;
}
/* arbitrary number format as per format arg */
static char * numFormat(rpmtd td, const char *format)
{
char * val = NULL;
rasprintf(&val, format, rpmtdGetNumber(td));
return val;
}
/* octal number formatting */
static char * octalFormat(rpmtd td, char **emsg)
{
return numFormat(td, "%o");
}
/* hexadecimal format */
static char * hexFormat(rpmtd td, char **emsg)
{
return numFormat(td, "%x");
}
/* arbitrary date formatting as per strftimeFormat arg */
static char * realDateFormat(rpmtd td, const char * strftimeFormat, char **emsg)
{
char * val = NULL;
struct tm * tstruct;
char buf[1024];
time_t dateint = rpmtdGetNumber(td);
tstruct = localtime(&dateint);
buf[0] = '\0';
if (tstruct)
if (strftime(buf, sizeof(buf) - 1, strftimeFormat, tstruct) == 0)
*emsg = xstrdup("date output too long");
val = xstrdup(buf);
return val;
}
/* date formatting */
static char * dateFormat(rpmtd td, char **emsg)
{
return realDateFormat(td, _("%c"), emsg);
}
/* day formatting */
static char * dayFormat(rpmtd td, char **emsg)
{
return realDateFormat(td, _("%a %b %d %Y"), emsg);
}
/* shell escape formatting */
static char * shescapeFormat(rpmtd td, char **emsg)
{
char * result = NULL, * dst, * src;
if (rpmtdClass(td) == RPM_NUMERIC_CLASS) {
rasprintf(&result, "%" PRIu64, rpmtdGetNumber(td));
} else if (rpmtdClass(td) == RPM_STRING_CLASS) {
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);
} else {
*emsg = xstrdup(_("(invalid type)"));
}
return result;
}
/* trigger type formatting (from rpmsense flags) */
static char * triggertypeFormat(rpmtd td, char **emsg)
{
char * val;
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;
}
/* dependency type formatting (from rpmsense flags) */
static char * deptypeFormat(rpmtd td, char **emsg)
{
char *val = NULL;
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;
}
/* file permissions formatting */
static char * permsFormat(rpmtd td, char **emsg)
{
return rpmPermsString(rpmtdGetNumber(td));
}
/* file flags formatting */
static char * fflagsFormat(rpmtd td, char **emsg)
{
return rpmFFlagsString(rpmtdGetNumber(td), "");
}
/* pubkey ascii armor formatting */
static char * armorFormat(rpmtd td, char **emsg)
{
const char * enc;
const unsigned char * s;
unsigned char * bs = NULL;
char *val = NULL;
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)) {
*emsg = xstrdup(_("(not base64)"));
goto exit;
}
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:
*emsg = xstrdup(_("(invalid type)"));
goto exit;
break;
}
/* XXX this doesn't use padding directly, assumes enough slop in retval. */
val = pgpArmorWrap(atype, s, ns);
if (atype == PGPARMOR_PUBKEY) {
free(bs);
}
exit:
return val;
}
/* base64 encoding formatting */
static char * base64Format(rpmtd td, char **emsg)
{
char * val = rpmBase64Encode(td->data, td->count, -1);
if (val == NULL)
val = xstrdup("");
return val;
}
/* xml formatting */
static char * xmlFormat(rpmtd td, char **emsg)
{
const char *xtag = NULL;
char *val = NULL;
char *s = NULL;
headerTagFormatFunction fmt = stringFormat;
switch (rpmtdClass(td)) {
case RPM_STRING_CLASS:
xtag = "string";
break;
case RPM_BINARY_CLASS:
fmt = base64Format;
xtag = "base64";
break;
case RPM_NUMERIC_CLASS:
xtag = "integer";
break;
case RPM_NULL_TYPE:
default:
*emsg = xstrdup(_("(invalid xml type)"));
goto exit;
break;
}
s = fmt(td, emsg);
if (s == NULL)
goto exit;
if (s[0] == '\0') {
val = rstrscat(NULL, "\t<", xtag, "/>", NULL);
} else {
char *new_s = NULL;
size_t i, s_size = strlen(s);
for (i=0; i<s_size; i++) {
switch (s[i]) {
case '<': rstrcat(&new_s, "<"); break;
case '>': rstrcat(&new_s, ">"); break;
case '&': rstrcat(&new_s, "&"); break;
default: {
char c[2] = " ";
*c = s[i];
rstrcat(&new_s, c);
break;
}
}
}
val = rstrscat(NULL, "\t<", xtag, ">", new_s, "</", xtag, ">", NULL);
free(new_s);
}
free(s);
exit:
return val;
}
/* signature fingerprint and time formatting */
static char * pgpsigFormat(rpmtd td, char **emsg)
{
char * val = NULL;
pgpDigParams sigp = NULL;
if (pgpPrtParams(td->data, td->count, PGPTAG_SIGNATURE, &sigp)) {
*emsg = xstrdup(_("(not an OpenPGP signature)"));
} else {
char dbuf[BUFSIZ];
char *keyid = pgpHexStr(sigp->signid, sizeof(sigp->signid));
unsigned int dateint = sigp->time;
time_t date = dateint;
struct tm * tms = localtime(&date);
unsigned int key_algo = pgpDigParamsAlgo(sigp, PGPVAL_PUBKEYALGO);
unsigned int hash_algo = pgpDigParamsAlgo(sigp, PGPVAL_HASHALGO);
if (!(tms && strftime(dbuf, sizeof(dbuf), "%c", tms) > 0)) {
rasprintf(emsg, _("Invalid date %u"), dateint);
} else {
rasprintf(&val, "%s/%s, %s, Key ID %s",
pgpValString(PGPVAL_PUBKEYALGO, key_algo),
pgpValString(PGPVAL_HASHALGO, hash_algo),
dbuf, keyid);
}
free(keyid);
pgpDigParamsFree(sigp);
}
return val;
}
/* dependency flags formatting */
static char * depflagsFormat(rpmtd td, char **emsg)
{
char * val = NULL;
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;
}
/* tag container array size */
static char * arraysizeFormat(rpmtd td, char **emsg)
{
char *val = NULL;
rasprintf(&val, "%u", rpmtdCount(td));
return val;
}
/* file state formatting */
static char * fstateFormat(rpmtd td, char **emsg)
{
char * val = NULL;
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;
}
/* file verification flags formatting with optional padding */
static char * verifyFlags(rpmtd td, const char *pad)
{
return rpmVerifyString(rpmtdGetNumber(td), pad);
}
static char * vflagsFormat(rpmtd td, char **emsg)
{
return verifyFlags(td, "");
}
static char * fstatusFormat(rpmtd td, char **emsg)
{
return verifyFlags(td, ".");
}
/* macro expansion formatting */
static char * expandFormat(rpmtd td, char **emsg)
{
return rpmExpand(rpmtdGetString(td), NULL);
}
static char * humanFormat(rpmtd td, char **emsg, int kilo)
{
const char* units[] = {"", "K", "M", "G", "T", "P", "E", "Z", "Y"};
int i = 0;
float number = rpmtdGetNumber(td);
int decimals = 0;
char * val = NULL;
while (number >= kilo) {
number /= kilo;
i++;
}
if ((number > 0.05) && (number < 9.95))
decimals = 1;
rasprintf(&val, "%.*f%s", decimals, number, units[i]);
return val;
}
static char * humansiFormat(rpmtd td, char **emsg)
{
return humanFormat(td, emsg, 1000);
}
static char * humaniecFormat(rpmtd td, char **emsg)
{
return humanFormat(td, emsg, 1024);
}
static const struct headerFmt_s rpmHeaderFormats[] = {
{ RPMTD_FORMAT_STRING, "string",
RPM_ANY_CLASS, stringFormat },
{ RPMTD_FORMAT_ARMOR, "armor",
RPM_ANY_CLASS, armorFormat },
{ RPMTD_FORMAT_BASE64, "base64",
RPM_BINARY_CLASS, base64Format },
{ RPMTD_FORMAT_PGPSIG, "pgpsig",
RPM_BINARY_CLASS, pgpsigFormat },
{ RPMTD_FORMAT_DEPFLAGS, "depflags",
RPM_NUMERIC_CLASS, depflagsFormat },
{ RPMTD_FORMAT_DEPTYPE, "deptype",
RPM_NUMERIC_CLASS, deptypeFormat },
{ RPMTD_FORMAT_FFLAGS, "fflags",
RPM_NUMERIC_CLASS, fflagsFormat },
{ RPMTD_FORMAT_PERMS, "perms",
RPM_NUMERIC_CLASS, permsFormat },
{ RPMTD_FORMAT_PERMS, "permissions",
RPM_NUMERIC_CLASS, permsFormat },
{ RPMTD_FORMAT_TRIGGERTYPE, "triggertype",
RPM_NUMERIC_CLASS, triggertypeFormat },
{ RPMTD_FORMAT_XML, "xml",
RPM_ANY_CLASS, xmlFormat },
{ RPMTD_FORMAT_OCTAL, "octal",
RPM_NUMERIC_CLASS, octalFormat },
{ RPMTD_FORMAT_HEX, "hex",
RPM_NUMERIC_CLASS, hexFormat },
{ RPMTD_FORMAT_DATE, "date",
RPM_NUMERIC_CLASS, dateFormat },
{ RPMTD_FORMAT_DAY, "day",
RPM_NUMERIC_CLASS, dayFormat },
{ RPMTD_FORMAT_SHESCAPE, "shescape",
RPM_ANY_CLASS, shescapeFormat },
{ RPMTD_FORMAT_ARRAYSIZE, "arraysize",
RPM_ANY_CLASS, arraysizeFormat },
{ RPMTD_FORMAT_FSTATE, "fstate",
RPM_NUMERIC_CLASS, fstateFormat },
{ RPMTD_FORMAT_VFLAGS, "vflags",
RPM_NUMERIC_CLASS, vflagsFormat },
{ RPMTD_FORMAT_EXPAND, "expand",
RPM_STRING_CLASS, expandFormat },
{ RPMTD_FORMAT_FSTATUS, "fstatus",
RPM_NUMERIC_CLASS, fstatusFormat },
{ RPMTD_FORMAT_HUMANSI, "humansi",
RPM_NUMERIC_CLASS, humansiFormat },
{ RPMTD_FORMAT_HUMANIEC, "humaniec",
RPM_NUMERIC_CLASS, humaniecFormat },
{ -1, NULL, 0, NULL }
};
headerFmt rpmHeaderFormatByName(const char *fmt)
{
const struct headerFmt_s * ext;
for (ext = rpmHeaderFormats; ext->name != NULL; ext++) {
if (rstreq(ext->name, fmt))
return ext;
}
return NULL;
}
headerFmt rpmHeaderFormatByValue(rpmtdFormats fmt)
{
const struct headerFmt_s * ext;
for (ext = rpmHeaderFormats; ext->name != NULL; ext++) {
if (fmt == ext->fmt)
return ext;
}
return NULL;
}
char *rpmHeaderFormatCall(headerFmt fmt, rpmtd td)
{
char *ret = NULL;
char *err = NULL;
if (fmt->class != RPM_ANY_CLASS && rpmtdClass(td) != fmt->class)
err = xstrdup(classEr(fmt->class));
else
ret = fmt->func(td, &err);
if (err) {
free(ret);
ret = err;
}
return ret;
}