static rpmRC checkDep(rpmSpec spec, char *N, char *EVR, char **emsg)
{
/*
* Tokens must begin with alphanumeric, _, or /, but we don't know
* the spec's encoding so we only check what we can: plain ascii.
*/
if (isascii(N[0]) && !(risalnum(N[0]) || N[0] == '_' || N[0] == '/')) {
rasprintf(emsg, _("Dependency tokens must begin with alpha-numeric, '_' or '/'"));
return RPMRC_FAIL;
}
if (EVR) {
if (N[0] == '/') {
rasprintf(emsg, _("Versioned file name not permitted"));
return RPMRC_FAIL;
}
if (rpmCharCheck(spec, EVR, ".-_+:%{}~"))
return RPMRC_FAIL;
if (checkSep(EVR, '-', emsg) != RPMRC_OK || checkSep(EVR, ':', emsg) != RPMRC_OK)
return RPMRC_FAIL;
}
return RPMRC_OK;
}
rpmRC parseRCPOT(rpmSpec spec, Package pkg, const char *field, rpmTagVal tagN,
int index, rpmsenseFlags tagflags)
{
const char *r, *re, *v, *ve;
const char *emsg = NULL;
char * N = NULL, * EVR = NULL;
rpmTagVal nametag = RPMTAG_NOT_FOUND;
rpmsenseFlags Flags;
Header h = pkg->header; /* everything except buildrequires go here */
rpmRC rc = RPMRC_FAIL; /* assume failure */
switch (tagN) {
default:
case RPMTAG_REQUIREFLAGS:
nametag = RPMTAG_REQUIRENAME;
tagflags |= RPMSENSE_ANY;
break;
case RPMTAG_PROVIDEFLAGS:
nametag = RPMTAG_PROVIDENAME;
break;
case RPMTAG_OBSOLETEFLAGS:
nametag = RPMTAG_OBSOLETENAME;
break;
case RPMTAG_CONFLICTFLAGS:
nametag = RPMTAG_CONFLICTNAME;
break;
case RPMTAG_ORDERFLAGS:
nametag = RPMTAG_ORDERNAME;
break;
case RPMTAG_PREREQ:
/* XXX map legacy PreReq into Requires(pre,preun) */
nametag = RPMTAG_REQUIRENAME;
tagflags |= (RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_PREUN);
break;
case RPMTAG_TRIGGERPREIN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPREIN;
break;
case RPMTAG_TRIGGERIN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERIN;
break;
case RPMTAG_TRIGGERPOSTUN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPOSTUN;
break;
case RPMTAG_TRIGGERUN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERUN;
break;
case RPMTAG_BUILDPREREQ:
case RPMTAG_BUILDREQUIRES:
nametag = RPMTAG_REQUIRENAME;
tagflags |= RPMSENSE_ANY;
h = spec->buildRestrictions;
break;
case RPMTAG_BUILDCONFLICTS:
nametag = RPMTAG_CONFLICTNAME;
h = spec->buildRestrictions;
break;
}
for (r = field; *r != '\0'; r = re) {
SKIPWHITE(r);
if (*r == '\0')
break;
Flags = (tagflags & ~RPMSENSE_SENSEMASK);
/*
* Tokens must begin with alphanumeric, _, or /, but we don't know
* the spec's encoding so we only check what we can: plain ascii.
*/
if (isascii(r[0]) && !(risalnum(r[0]) || r[0] == '_' || r[0] == '/')) {
emsg = _("Dependency tokens must begin with alpha-numeric, '_' or '/'");
goto exit;
}
re = r;
SKIPNONWHITE(re);
N = xmalloc((re-r) + 1);
rstrlcpy(N, r, (re-r) + 1);
/* Parse EVR */
v = re;
SKIPWHITE(v);
ve = v;
SKIPNONWHITE(ve);
re = v; /* ==> next token (if no EVR found) starts here */
/* Check for possible logical operator */
if (ve > v) {
const struct ReqComp *rc;
for (rc = ReqComparisons; rc->token != NULL; rc++) {
if ((ve-v) != strlen(rc->token) || !rstreqn(v, rc->token, (ve-v)))
continue;
if (r[0] == '/') {
emsg = _("Versioned file name not permitted");
goto exit;
}
Flags |= rc->sense;
/* now parse EVR */
v = ve;
SKIPWHITE(v);
ve = v;
SKIPNONWHITE(ve);
break;
}
}
if (Flags & RPMSENSE_SENSEMASK) {
if (*v == '\0' || ve == v) {
emsg = _("Version required");
goto exit;
}
EVR = xmalloc((ve-v) + 1);
rstrlcpy(EVR, v, (ve-v) + 1);
if (rpmCharCheck(spec, EVR, ve-v, ".-_+:%{}")) goto exit;
re = ve; /* ==> next token after EVR string starts here */
} else
EVR = NULL;
if (addReqProv(h, nametag, N, EVR, Flags, index)) {
emsg = _("invalid dependency");
goto exit;
}
N = _free(N);
EVR = _free(EVR);
}
rc = RPMRC_OK;
exit:
if (emsg) {
/* Automatic dependencies don't relate to spec lines */
if (tagflags & (RPMSENSE_FIND_REQUIRES|RPMSENSE_FIND_PROVIDES)) {
rpmlog(RPMLOG_ERR, "%s: %s\n", emsg, r);
} else {
rpmlog(RPMLOG_ERR, _("line %d: %s: %s\n"),
spec->lineNum, emsg, spec->line);
}
}
free(N);
free(EVR);
return rc;
}
static rpmRC handlePreambleTag(rpmSpec spec, Package pkg, rpmTagVal tag,
const char *macro, const char *lang)
{
char * field = spec->line;
char * end;
int multiToken = 0;
rpmsenseFlags tagflags = RPMSENSE_ANY;
rpmRC rc = RPMRC_FAIL;
if (field == NULL) /* XXX can't happen */
goto exit;
/* Find the start of the "field" and strip trailing space */
while ((*field) && (*field != ':'))
field++;
if (*field != ':') {
rpmlog(RPMLOG_ERR, _("line %d: Malformed tag: %s\n"),
spec->lineNum, spec->line);
goto exit;
}
field++;
SKIPSPACE(field);
if (!*field) {
/* Empty field */
rpmlog(RPMLOG_ERR, _("line %d: Empty tag: %s\n"),
spec->lineNum, spec->line);
goto exit;
}
end = findLastChar(field);
*(end+1) = '\0';
/* See if this is multi-token */
end = field;
SKIPNONSPACE(end);
if (*end != '\0')
multiToken = 1;
switch (tag) {
case RPMTAG_NAME:
SINGLE_TOKEN_ONLY;
if (rpmCharCheck(spec, field, WHITELIST_NAME))
goto exit;
headerPutString(pkg->header, tag, field);
/* Main pkg name is unknown at the start, populate as soon as we can */
if (pkg == spec->packages)
pkg->name = rpmstrPoolId(spec->pool, field, 1);
break;
case RPMTAG_VERSION:
case RPMTAG_RELEASE:
SINGLE_TOKEN_ONLY;
if (rpmCharCheck(spec, field, "._+%{}~"))
goto exit;
headerPutString(pkg->header, tag, field);
break;
case RPMTAG_URL:
case RPMTAG_DISTTAG:
case RPMTAG_BUGURL:
/* XXX TODO: validate format somehow */
case RPMTAG_VCS:
SINGLE_TOKEN_ONLY;
headerPutString(pkg->header, tag, field);
break;
case RPMTAG_GROUP:
case RPMTAG_SUMMARY:
case RPMTAG_DISTRIBUTION:
case RPMTAG_VENDOR:
case RPMTAG_LICENSE:
case RPMTAG_PACKAGER:
if (addLangTag(spec, pkg->header, tag, field, lang))
goto exit;
break;
case RPMTAG_BUILDROOT:
/* just silently ignore BuildRoot */
macro = NULL;
break;
case RPMTAG_PREFIXES: {
struct rpmtd_s td;
const char *str;
if (addOrAppendListEntry(pkg->header, tag, field))
goto exit;
headerGet(pkg->header, tag, &td, HEADERGET_MINMEM);
while ((str = rpmtdNextString(&td))) {
size_t len = strlen(str);
if (len > 1 && str[len-1] == '/') {
rpmlog(RPMLOG_ERR,
_("line %d: Prefixes must not end with \"/\": %s\n"),
spec->lineNum, spec->line);
rpmtdFreeData(&td);
goto exit;
}
}
rpmtdFreeData(&td);
break;
}
case RPMTAG_DOCDIR:
SINGLE_TOKEN_ONLY;
if (field[0] != '/') {
rpmlog(RPMLOG_ERR, _("line %d: Docdir must begin with '/': %s\n"),
spec->lineNum, spec->line);
goto exit;
}
macro = NULL;
rpmPopMacro(NULL, "_docdir");
rpmPushMacro(NULL, "_docdir", NULL, field, RMIL_SPEC);
break;
case RPMTAG_EPOCH: {
SINGLE_TOKEN_ONLY;
uint32_t epoch;
if (parseUnsignedNum(field, &epoch)) {
rpmlog(RPMLOG_ERR,
_("line %d: Epoch field must be an unsigned number: %s\n"),
spec->lineNum, spec->line);
goto exit;
}
headerPutUint32(pkg->header, tag, &epoch, 1);
break;
}
case RPMTAG_AUTOREQPROV:
pkg->autoReq = parseYesNo(field);
pkg->autoProv = pkg->autoReq;
break;
case RPMTAG_AUTOREQ:
pkg->autoReq = parseYesNo(field);
break;
case RPMTAG_AUTOPROV:
pkg->autoProv = parseYesNo(field);
break;
case RPMTAG_SOURCE:
case RPMTAG_PATCH:
macro = NULL;
if (addSource(spec, pkg, field, tag))
goto exit;
break;
case RPMTAG_ICON:
SINGLE_TOKEN_ONLY;
if (addSource(spec, pkg, field, tag) || readIcon(pkg->header, field))
goto exit;
break;
case RPMTAG_NOSOURCE:
case RPMTAG_NOPATCH:
spec->noSource = 1;
if (parseNoSource(spec, field, tag))
goto exit;
break;
case RPMTAG_ORDERFLAGS:
case RPMTAG_REQUIREFLAGS:
if (parseBits(lang, installScriptBits, &tagflags)) {
rpmlog(RPMLOG_ERR, _("line %d: Bad %s: qualifiers: %s\n"),
spec->lineNum, rpmTagGetName(tag), spec->line);
goto exit;
}
/* fallthrough */
case RPMTAG_PREREQ:
case RPMTAG_RECOMMENDFLAGS:
case RPMTAG_SUGGESTFLAGS:
case RPMTAG_SUPPLEMENTFLAGS:
case RPMTAG_ENHANCEFLAGS:
case RPMTAG_CONFLICTFLAGS:
case RPMTAG_OBSOLETEFLAGS:
case RPMTAG_PROVIDEFLAGS:
if (parseRCPOT(spec, pkg, field, tag, 0, tagflags))
goto exit;
break;
case RPMTAG_BUILDPREREQ:
case RPMTAG_BUILDREQUIRES:
case RPMTAG_BUILDCONFLICTS:
if (parseRCPOT(spec, spec->sourcePackage, field, tag, 0, tagflags))
goto exit;
break;
case RPMTAG_EXCLUDEARCH:
case RPMTAG_EXCLUSIVEARCH:
case RPMTAG_EXCLUDEOS:
case RPMTAG_EXCLUSIVEOS:
if (addOrAppendListEntry(spec->buildRestrictions, tag, field))
goto exit;
break;
case RPMTAG_BUILDARCHS: {
int BACount;
const char **BANames = NULL;
if (poptParseArgvString(field, &BACount, &BANames)) {
rpmlog(RPMLOG_ERR,
_("line %d: Bad BuildArchitecture format: %s\n"),
spec->lineNum, spec->line);
goto exit;
}
if (spec->packages == pkg) {
if (spec->BANames) {
rpmlog(RPMLOG_ERR,
_("line %d: Duplicate BuildArch entry: %s\n"),
spec->lineNum, spec->line);
BANames = _free(BANames);
goto exit;
}
spec->BACount = BACount;
spec->BANames = BANames;
} else {
if (BACount != 1 || !rstreq(BANames[0], "noarch")) {
rpmlog(RPMLOG_ERR,
_("line %d: Only noarch subpackages are supported: %s\n"),
spec->lineNum, spec->line);
BANames = _free(BANames);
goto exit;
}
headerPutString(pkg->header, RPMTAG_ARCH, "noarch");
}
if (!BACount)
spec->BANames = _free(spec->BANames);
break;
}
case RPMTAG_REMOVEPATHPOSTFIXES:
argvSplit(&pkg->removePostfixes, field, ":");
break;
default:
rpmlog(RPMLOG_ERR, _("Internal error: Bogus tag %d\n"), tag);
goto exit;
}
if (macro) {
rpmPushMacro(spec->macros, macro, NULL, field, RMIL_SPEC);
/* Add a separate uppercase macro for tags from the main package */
if (pkg == spec->packages) {
char *m = xstrdup(macro);
for (char *p = m; *p; ++p)
*p = rtoupper(*p);
rpmPushMacro(spec->macros, m, NULL, field, RMIL_SPEC);
free(m);
}
}
rc = RPMRC_OK;
exit:
return rc;
}
int parsePreamble(rpmSpec spec, int initialPackage)
{
int nextPart = PART_ERROR;
int res = PART_ERROR; /* assume failure */
int rc;
char *name, *linep;
int flag = 0;
Package pkg;
char *NVR = NULL;
char lang[BUFSIZ];
if (! initialPackage) {
/* There is one option to %package: <pkg> or -n <pkg> */
if (parseSimplePart(spec->line, &name, &flag)) {
rpmlog(RPMLOG_ERR, _("Bad package specification: %s\n"),
spec->line);
goto exit;
}
if (rpmCharCheck(spec, name, WHITELIST_NAME))
goto exit;
if (!lookupPackage(spec, name, flag, NULL)) {
free(name);
goto exit;
}
/* Construct the package */
if (flag == PART_SUBNAME) {
rasprintf(&NVR, "%s-%s",
headerGetString(spec->packages->header, RPMTAG_NAME), name);
} else
NVR = xstrdup(name);
free(name);
pkg = newPackage(NVR, spec->pool, &spec->packages);
headerPutString(pkg->header, RPMTAG_NAME, NVR);
} else {
NVR = xstrdup("(main package)");
pkg = newPackage(NULL, spec->pool, &spec->packages);
spec->sourcePackage = newPackage(NULL, spec->pool, NULL);
}
if ((rc = readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) {
nextPart = PART_NONE;
} else if (rc < 0) {
goto exit;
} else {
while (! (nextPart = isPart(spec->line))) {
const char * macro;
rpmTagVal tag;
/* Skip blank lines */
linep = spec->line;
SKIPSPACE(linep);
if (*linep != '\0') {
if (findPreambleTag(spec, &tag, ¯o, lang)) {
if (spec->lineNum == 1 &&
(unsigned char)(spec->line[0]) == 0xed &&
(unsigned char)(spec->line[1]) == 0xab &&
(unsigned char)(spec->line[2]) == 0xee &&
(unsigned char)(spec->line[3]) == 0xdb) {
rpmlog(RPMLOG_ERR, _("Binary rpm package found. Expected spec file!\n"));
goto exit;
}
rpmlog(RPMLOG_ERR, _("line %d: Unknown tag: %s\n"),
spec->lineNum, spec->line);
goto exit;
}
if (handlePreambleTag(spec, pkg, tag, macro, lang)) {
goto exit;
}
if (spec->BANames && !spec->recursing) {
res = PART_BUILDARCHITECTURES;
goto exit;
}
}
if ((rc =
readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) {
nextPart = PART_NONE;
break;
}
if (rc) {
goto exit;
}
}
}
/*
* Expand buildroot one more time to get %{version} and the like
* from the main package, validate sanity. The spec->buildRoot could
* still contain unexpanded macros but it cannot be empty or '/', and it
* can't be messed with by anything spec does beyond this point.
*/
if (initialPackage) {
char *buildRoot = rpmGetPath(spec->buildRoot, NULL);
if (*buildRoot == '\0') {
rpmlog(RPMLOG_ERR, _("%%{buildroot} couldn't be empty\n"));
goto exit;
}
if (rstreq(buildRoot, "/")) {
rpmlog(RPMLOG_ERR, _("%%{buildroot} can not be \"/\"\n"));
goto exit;
}
free(spec->buildRoot);
spec->buildRoot = buildRoot;
rpmPushMacro(spec->macros, "buildroot", NULL, spec->buildRoot, RMIL_SPEC);
}
/* XXX Skip valid arch check if not building binary package */
if (!(spec->flags & RPMSPEC_ANYARCH) && checkForValidArchitectures(spec)) {
goto exit;
}
/* It is the main package */
if (pkg == spec->packages) {
fillOutMainPackage(pkg->header);
/* Define group tag to something when group is undefined in main package*/
if (!headerIsEntry(pkg->header, RPMTAG_GROUP)) {
headerPutString(pkg->header, RPMTAG_GROUP, "Unspecified");
}
}
if (checkForDuplicates(pkg->header, NVR)) {
goto exit;
}
if (pkg != spec->packages) {
headerCopyTags(spec->packages->header, pkg->header,
(rpmTagVal *)copyTagsDuringParse);
}
if (checkForRequired(pkg->header, NVR)) {
goto exit;
}
/* if we get down here nextPart has been set to non-error */
res = nextPart;
exit:
free(NVR);
return res;
}
