static char * prDbiOpenFlags(int dbflags, int print_dbenv_flags)
{
ARGV_t flags = NULL;
const struct poptOption *opt;
char *buf;
for (opt = rdbOptions; opt->longName != NULL; opt++) {
if (opt->argInfo != POPT_BIT_SET)
continue;
if (print_dbenv_flags) {
if (!(opt->arg == &staticcfg.db_eflags))
continue;
} else {
if (!(opt->arg == &staticdbicfg.dbi_oflags))
continue;
}
if ((dbflags & opt->val) != opt->val)
continue;
argvAdd(&flags, opt->longName);
dbflags &= ~opt->val;
}
if (dbflags) {
char *df = NULL;
rasprintf(&df, "0x%x", (unsigned)dbflags);
argvAdd(&flags, df);
free(df);
}
buf = argvJoin(flags, ":");
argvFree(flags);
return buf ? buf : xstrdup("(none)");
}
int main(int argc, char **argv)
{
poptContext optCon = rpmioInit(argc, argv, optionsTable);
const char ** av = NULL;
int ac;
int r = -1;
_rpmaug_debug = -1;
if (_rpmaugLoadargv != NULL)
_rpmaugLoadpath = argvJoin(_rpmaugLoadargv, PATH_SEP_CHAR);
_rpmaugI = rpmaugNew(_rpmaugRoot, _rpmaugLoadpath, _rpmaugFlags);
if (_rpmaugI == NULL) {
fprintf(stderr, "Failed to initialize Augeas\n");
goto exit;
}
#if defined(WITH_READLINE)
readline_init();
#endif
av = poptGetArgs(optCon);
ac = argvCount(av);
if (ac > 0) { // Accept one command from the command line
const char * cmd = argvJoin(av, ' ');
const char *buf;
buf = NULL;
r = rpmaugRun(NULL, cmd, &buf);
cmd = _free(cmd);
if (buf && *buf)
fprintf(stdout, "%s", buf);
} else {
r = main_loop();
}
exit:
if (_rpmaugLoadargv)
_rpmaugLoadpath = _free(_rpmaugLoadpath);
_rpmaugLoadargv = argvFree(_rpmaugLoadargv);
_rpmaugI = rpmaugFree(_rpmaugI);
optCon = rpmioFini(optCon);
return (r == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
static int filedepTag(Header h, rpmTag tagN, rpmtd td, headerGetFlags hgflags)
{
rpmfi fi = rpmfiNew(NULL, h, RPMTAG_BASENAMES, RPMFI_NOHEADER);
rpmds ds = NULL;
char **fdeps = NULL;
int numfiles;
char deptype = 'R';
int fileix;
int rc = 0;
numfiles = rpmfiFC(fi);
if (numfiles <= 0) {
goto exit;
}
if (tagN == RPMTAG_PROVIDENAME)
deptype = 'P';
else if (tagN == RPMTAG_REQUIRENAME)
deptype = 'R';
ds = rpmdsNew(h, tagN, 0);
fdeps = xmalloc(numfiles * sizeof(*fdeps));
while ((fileix = rpmfiNext(fi)) >= 0) {
ARGV_t deps = NULL;
const uint32_t * ddict = NULL;
int ndx = rpmfiFDepends(fi, &ddict);
if (ddict != NULL) {
while (ndx-- > 0) {
const char * DNEVR;
unsigned dix = *ddict++;
char mydt = ((dix >> 24) & 0xff);
if (mydt != deptype)
continue;
dix &= 0x00ffffff;
(void) rpmdsSetIx(ds, dix-1);
if (rpmdsNext(ds) < 0)
continue;
DNEVR = rpmdsDNEVR(ds);
if (DNEVR != NULL) {
argvAdd(&deps, DNEVR + 2);
}
}
}
fdeps[fileix] = deps ? argvJoin(deps, " ") : xstrdup("");
argvFree(deps);
}
td->data = fdeps;
td->count = numfiles;
td->flags = RPMTD_ALLOCED | RPMTD_PTR_ALLOCED;
td->type = RPM_STRING_ARRAY_TYPE;
rc = 1;
exit:
rpmfiFree(fi);
rpmdsFree(ds);
return rc;
}
/**
* 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;
}
/**
* 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;
}
/**
* Parse arguments (to next new line) for parameterized macro.
* @todo Use popt rather than getopt to parse args.
* @param mb macro expansion state
* @param me macro entry slot
* @param se arguments to parse
* @param lastc stop parsing at lastc
* @return address to continue parsing
*/
static const char *
grabArgs(MacroBuf mb, const rpmMacroEntry me, const char * se,
const char * lastc)
{
const char *opts, *o;
char *args = NULL;
ARGV_t argv = NULL;
int argc = 0;
int c;
/* Copy macro name as argv[0] */
argvAdd(&argv, me->name);
addMacro(mb->mc, "0", NULL, me->name, mb->depth);
/*
* Make a copy of se up to lastc string that we can pass to argvSplit().
* Append the results to main argv.
*/
{ ARGV_t av = NULL;
char *s = xcalloc((lastc-se)+1, sizeof(*s));
memcpy(s, se, (lastc-se));
argvSplit(&av, s, " \t");
argvAppend(&argv, av);
argvFree(av);
free(s);
}
/*
* The macro %* analoguous to the shell's $* means "Pass all non-macro
* parameters." Consequently, there needs to be a macro that means "Pass all
* (including macro parameters) options". This is useful for verifying
* parameters during expansion and yet transparently passing all parameters
* through for higher level processing (e.g. %description and/or %setup).
* This is the (potential) justification for %{**} ...
*/
args = argvJoin(argv + 1, " ");
addMacro(mb->mc, "**", NULL, args, mb->depth);
free(args);
/*
* POSIX states optind must be 1 before any call but glibc uses 0
* to (re)initialize getopt structures, eww.
*/
#ifdef __GLIBC__
optind = 0;
#else
optind = 1;
#endif
opts = me->opts;
argc = argvCount(argv);
/* Define option macros. */
while((c = getopt(argc, argv, opts)) != -1)
{
char *name = NULL, *body = NULL;
if (c == '?' || (o = strchr(opts, c)) == NULL) {
rpmlog(RPMLOG_ERR, _("Unknown option %c in %s(%s)\n"),
(char)c, me->name, opts);
goto exit;
}
rasprintf(&name, "-%c", c);
if (optarg) {
rasprintf(&body, "-%c %s", c, optarg);
} else {
rasprintf(&body, "-%c", c);
}
addMacro(mb->mc, name, NULL, body, mb->depth);
free(name);
free(body);
if (optarg) {
rasprintf(&name, "-%c*", c);
addMacro(mb->mc, name, NULL, optarg, mb->depth);
free(name);
}
}
/* Add argument count (remaining non-option items) as macro. */
{ char *ac = NULL;
rasprintf(&ac, "%d", (argc - optind));
addMacro(mb->mc, "#", NULL, ac, mb->depth);
free(ac);
}
/* Add macro for each argument */
if (argc - optind) {
for (c = optind; c < argc; c++) {
char *name = NULL;
rasprintf(&name, "%d", (c - optind + 1));
addMacro(mb->mc, name, NULL, argv[c], mb->depth);
free(name);
}
}
/* Add concatenated unexpanded arguments as yet another macro. */
args = argvJoin(argv + optind, " ");
addMacro(mb->mc, "*", NULL, args ? args : "", mb->depth);
free(args);
exit:
argvFree(argv);
return *lastc ? lastc + 1 : lastc;
}