/* Backwards compatibility */
int argvSplit(ARGV_t * argvp, const char * str, const char * seps)
{
if (argvp) {
*argvp = argvSplitString(str, seps, ARGV_SKIPEMPTY);
}
return 0;
}
int parsePrep(rpmSpec spec)
{
int nextPart, res, rc;
StringBuf sb;
char **lines;
ARGV_t saveLines = NULL;
if (spec->prep != NULL) {
rpmlog(RPMLOG_ERR, _("line %d: second %%prep\n"), spec->lineNum);
return PART_ERROR;
}
spec->prep = newStringBuf();
/* There are no options to %prep */
if ((rc = readLine(spec, STRIP_NOTHING)) > 0) {
return PART_NONE;
} else if (rc < 0) {
return PART_ERROR;
}
sb = newStringBuf();
while (! (nextPart = isPart(spec->line))) {
/* Need to expand the macros inline. That way we */
/* can give good line number information on error. */
appendStringBuf(sb, spec->line);
if ((rc = readLine(spec, STRIP_NOTHING)) > 0) {
nextPart = PART_NONE;
break;
} else if (rc < 0) {
goto exit;
}
}
saveLines = argvSplitString(getStringBuf(sb), "\n", ARGV_NONE);
for (lines = saveLines; *lines; lines++) {
res = 0;
if (rstreqn(*lines, "%setup", sizeof("%setup")-1)) {
res = doSetupMacro(spec, *lines);
} else if (rstreqn(*lines, "%patch", sizeof("%patch")-1)) {
res = doPatchMacro(spec, *lines);
} else {
appendLineStringBuf(spec->prep, *lines);
}
if (res && !spec->force) {
/* fixup from RPMRC_FAIL do*Macro() codes for now */
nextPart = PART_ERROR;
goto exit;
}
}
res = nextPart;
exit:
argvFree(saveLines);
sb = freeStringBuf(sb);
return nextPart;
}
static rpmfcAttr rpmfcAttrNew(const char *name)
{
rpmfcAttr attr = xcalloc(1, sizeof(*attr));
struct matchRule *rules[] = { &attr->incl, &attr->excl, NULL };
attr->name = xstrdup(name);
for (struct matchRule **rule = rules; rule && *rule; rule++) {
const char *prefix = (*rule == &attr->incl) ? NULL : "exclude";
char *flags = rpmfcAttrMacro(name, prefix, "flags");
(*rule)->path = rpmfcAttrReg(name, prefix, "path");
(*rule)->magic = rpmfcAttrReg(name, prefix, "magic");
(*rule)->flags = argvSplitString(flags, ",", ARGV_SKIPEMPTY);
argvSort((*rule)->flags, NULL);
free(flags);
}
return attr;
}
static ModuleRec newModule(const char *path, const char *name,
const char *types, uint32_t flags)
{
ModuleRec mod;
uint8_t *raw = NULL;
ssize_t rawlen = 0;
const char *buildDir = "%{_builddir}/%{?buildsubdir}/";
if (!path) {
rpmlog(RPMLOG_ERR, _("%%semodule requires a file path\n"));
return NULL;
}
mod = xcalloc(1, sizeof(*mod));
mod->path = rpmGenPath(buildDir, NULL, path);
if ((rpmioSlurp(mod->path, &raw, &rawlen)) != 0 || raw == NULL) {
rpmlog(RPMLOG_ERR, _("Failed to read policy file: %s\n"),
mod->path);
goto err;
}
mod->data = b64encode(raw, rawlen, -1);
if (!mod->data) {
rpmlog(RPMLOG_ERR, _("Failed to encode policy file: %s\n"),
mod->path);
goto err;
}
if (name) {
mod->name = xstrdup(name);
} else {
/* assume base name (minus extension) if name is not given */
char *tmp = xstrdup(mod->path);
char *bname = basename(tmp);
char *end = strchr(bname, '.');
if (end)
*end = '\0';
if (strlen(bname) > 0) {
mod->name = xstrdup(bname);
} else {
rpmlog(RPMLOG_ERR, _("Failed to determine a policy name: %s\n"),
mod->path);
_free(tmp);
goto err;
}
_free(tmp);
}
if (types) {
mod->types = argvSplitString(types, ",", ARGV_SKIPEMPTY);
argvSort(mod->types, NULL);
if (argvSearch(mod->types, RPMPOL_TYPE_DEFAULT, NULL) && argvCount(mod->types) > 1) {
rpmlog(RPMLOG_WARNING, _("'%s' type given with other types in %%semodule %s. Compacting types to '%s'.\n"),
RPMPOL_TYPE_DEFAULT, mod->path, RPMPOL_TYPE_DEFAULT);
mod->types = argvFree(mod->types);
argvAdd(&mod->types, RPMPOL_TYPE_DEFAULT);
}
} else {
argvAdd(&mod->types, RPMPOL_TYPE_DEFAULT);
}
mod->flags = flags;
return mod;
err:
freeModule(mod);
return NULL;
}