int
rpmDefineMacro(rpmMacroContext mc, const char * macro, int level)
{
MacroBuf mb = xcalloc(1, sizeof(*mb));
/* XXX just enough to get by */
mb->mc = (mc ? mc : rpmGlobalMacroContext);
(void) doDefine(mb, macro, level, 0);
_free(mb);
return 0;
}
/**
* The main macro recursion loop.
* @todo Dynamically reallocate target buffer.
* @param mb macro expansion state
* @return 0 on success, 1 on failure
*/
static int
expandMacro(MacroBuf mb)
{
rpmMacroEntry *mep;
rpmMacroEntry me;
const char *s = mb->s, *se;
const char *f, *fe;
const char *g, *ge;
size_t fn, gn;
char *t = mb->t; /* save expansion pointer for printExpand */
int c;
int rc = 0;
int negate;
const char * lastc;
int chkexist;
if (++mb->depth > max_macro_depth) {
rpmlog(RPMLOG_ERR,
_("Recursion depth(%d) greater than max(%d)\n"),
mb->depth, max_macro_depth);
mb->depth--;
mb->expand_trace = 1;
return 1;
}
while (rc == 0 && mb->nb > 0 && (c = *s) != '\0') {
s++;
/* Copy text until next macro */
switch(c) {
case '%':
if (*s) { /* Ensure not end-of-string. */
if (*s != '%')
break;
s++; /* skip first % in %% */
}
default:
SAVECHAR(mb, c);
continue;
break;
}
/* Expand next macro */
f = fe = NULL;
g = ge = NULL;
if (mb->depth > 1) /* XXX full expansion for outermost level */
t = mb->t; /* save expansion pointer for printExpand */
negate = 0;
lastc = NULL;
chkexist = 0;
switch ((c = *s)) {
default: /* %name substitution */
while (strchr("!?", *s) != NULL) {
switch(*s++) {
case '!':
negate = ((negate + 1) % 2);
break;
case '?':
chkexist++;
break;
}
}
f = se = s;
if (*se == '-')
se++;
while((c = *se) && (risalnum(c) || c == '_'))
se++;
/* Recognize non-alnum macros too */
switch (*se) {
case '*':
se++;
if (*se == '*') se++;
break;
case '#':
se++;
break;
default:
break;
}
fe = se;
/* For "%name " macros ... */
if ((c = *fe) && isblank(c))
if ((lastc = strchr(fe,'\n')) == NULL)
lastc = strchr(fe, '\0');
break;
case '(': /* %(...) shell escape */
if ((se = matchchar(s, c, ')')) == NULL) {
rpmlog(RPMLOG_ERR,
_("Unterminated %c: %s\n"), (char)c, s);
rc = 1;
continue;
}
if (mb->macro_trace)
printMacro(mb, s, se+1);
s++; /* skip ( */
rc = doShellEscape(mb, s, (se - s));
se++; /* skip ) */
s = se;
continue;
break;
case '{': /* %{...}/%{...:...} substitution */
if ((se = matchchar(s, c, '}')) == NULL) {
rpmlog(RPMLOG_ERR,
_("Unterminated %c: %s\n"), (char)c, s);
rc = 1;
continue;
}
f = s+1;/* skip { */
se++; /* skip } */
while (strchr("!?", *f) != NULL) {
switch(*f++) {
case '!':
negate = ((negate + 1) % 2);
break;
case '?':
chkexist++;
break;
}
}
for (fe = f; (c = *fe) && !strchr(" :}", c);)
fe++;
switch (c) {
case ':':
g = fe + 1;
ge = se - 1;
break;
case ' ':
lastc = se-1;
break;
default:
break;
}
break;
}
/* XXX Everything below expects fe > f */
fn = (fe - f);
gn = (ge - g);
if ((fe - f) <= 0) {
/* XXX Process % in unknown context */
c = '%'; /* XXX only need to save % */
SAVECHAR(mb, c);
#if 0
rpmlog(RPMLOG_ERR,
_("A %% is followed by an unparseable macro\n"));
#endif
s = se;
continue;
}
if (mb->macro_trace)
printMacro(mb, s, se);
/* Expand builtin macros */
if (STREQ("global", f, fn)) {
s = doDefine(mb, se, RMIL_GLOBAL, 1);
continue;
}
if (STREQ("define", f, fn)) {
s = doDefine(mb, se, mb->depth, 0);
continue;
}
if (STREQ("undefine", f, fn)) {
s = doUndefine(mb->mc, se);
continue;
}
if (STREQ("echo", f, fn) ||
STREQ("warn", f, fn) ||
STREQ("error", f, fn)) {
int waserror = 0;
if (STREQ("error", f, fn))
waserror = 1;
if (g != NULL && g < ge)
doOutput(mb, waserror, g, gn);
else
doOutput(mb, waserror, f, fn);
s = se;
continue;
}
if (STREQ("trace", f, fn)) {
/* XXX TODO restore expand_trace/macro_trace to 0 on return */
mb->expand_trace = mb->macro_trace = (negate ? 0 : mb->depth);
if (mb->depth == 1) {
print_macro_trace = mb->macro_trace;
print_expand_trace = mb->expand_trace;
}
s = se;
continue;
}
if (STREQ("dump", f, fn)) {
rpmDumpMacroTable(mb->mc, NULL);
while (iseol(*se))
se++;
s = se;
continue;
}
#ifdef WITH_LUA
if (STREQ("lua", f, fn)) {
rpmlua lua = NULL; /* Global state. */
const char *ls = s+sizeof("{lua:")-1;
const char *lse = se-sizeof("}")+1;
char *scriptbuf = (char *)xmalloc((lse-ls)+1);
const char *printbuf;
memcpy(scriptbuf, ls, lse-ls);
scriptbuf[lse-ls] = '\0';
rpmluaSetPrintBuffer(lua, 1);
if (rpmluaRunScript(lua, scriptbuf, NULL) == -1)
rc = 1;
printbuf = rpmluaGetPrintBuffer(lua);
if (printbuf) {
size_t len = strlen(printbuf);
if (len > mb->nb)
len = mb->nb;
memcpy(mb->t, printbuf, len);
mb->t += len;
mb->nb -= len;
}
rpmluaSetPrintBuffer(lua, 0);
free(scriptbuf);
s = se;
continue;
}
#endif
/* XXX necessary but clunky */
if (STREQ("basename", f, fn) ||
STREQ("suffix", f, fn) ||
STREQ("expand", f, fn) ||
STREQ("verbose", f, fn) ||
STREQ("uncompress", f, fn) ||
STREQ("url2path", f, fn) ||
STREQ("u2p", f, fn) ||
STREQ("getenv", f, fn) ||
STREQ("S", f, fn) ||
STREQ("P", f, fn) ||
STREQ("F", f, fn)) {
/* FIX: verbose may be set */
doFoo(mb, negate, f, fn, g, gn);
s = se;
continue;
}
/* Expand defined macros */
mep = findEntry(mb->mc, f, fn);
me = (mep ? *mep : NULL);
/* XXX Special processing for flags */
if (*f == '-') {
if (me)
me->used++; /* Mark macro as used */
if ((me == NULL && !negate) || /* Without -f, skip %{-f...} */
(me != NULL && negate)) { /* With -f, skip %{!-f...} */
s = se;
continue;
}
if (g && g < ge) { /* Expand X in %{-f:X} */
rc = expandT(mb, g, gn);
} else
if (me && me->body && *me->body) {/* Expand %{-f}/%{-f*} */
rc = expandT(mb, me->body, strlen(me->body));
}
s = se;
continue;
}
/* XXX Special processing for macro existence */
if (chkexist) {
if ((me == NULL && !negate) || /* Without -f, skip %{?f...} */
(me != NULL && negate)) { /* With -f, skip %{!?f...} */
s = se;
continue;
}
if (g && g < ge) { /* Expand X in %{?f:X} */
rc = expandT(mb, g, gn);
} else
if (me && me->body && *me->body) { /* Expand %{?f}/%{?f*} */
rc = expandT(mb, me->body, strlen(me->body));
}
s = se;
continue;
}
if (me == NULL) { /* leave unknown %... as is */
#ifndef HACK
#if DEAD
/* XXX hack to skip over empty arg list */
if (fn == 1 && *f == '*') {
s = se;
continue;
}
#endif
/* XXX hack to permit non-overloaded %foo to be passed */
c = '%'; /* XXX only need to save % */
SAVECHAR(mb, c);
#else
rpmlog(RPMLOG_ERR,
_("Macro %%%.*s not found, skipping\n"), fn, f);
s = se;
#endif
continue;
}
/* Setup args for "%name " macros with opts */
if (me && me->opts != NULL) {
if (lastc != NULL) {
se = grabArgs(mb, me, fe, lastc);
} else {
addMacro(mb->mc, "**", NULL, "", mb->depth);
addMacro(mb->mc, "*", NULL, "", mb->depth);
addMacro(mb->mc, "#", NULL, "0", mb->depth);
addMacro(mb->mc, "0", NULL, me->name, mb->depth);
}
}
/* Recursively expand body of macro */
if (me->body && *me->body) {
mb->s = me->body;
rc = expandMacro(mb);
if (rc == 0)
me->used++; /* Mark macro as used */
}
/* Free args for "%name " macros with opts */
if (me->opts != NULL)
freeArgs(mb);
s = se;
}
*mb->t = '\0';
mb->s = s;
mb->depth--;
if (rc != 0 || mb->expand_trace)
printExpansion(mb, t, mb->t);
return rc;
}
result_t SandBox::addScript(const char *srcname, const char *script,
v8::Local<v8::Value> &retVal)
{
std::string fname(srcname);
Context context(this, srcname);
result_t hr;
v8::Local<v8::Object> mod;
v8::Local<v8::Object> exports;
// cache string
v8::Local<v8::String> strRequire = v8::String::NewFromUtf8(isolate, "require");
v8::Local<v8::String> strExports = v8::String::NewFromUtf8(isolate, "exports");
v8::Local<v8::String> strModule = v8::String::NewFromUtf8(isolate, "module");
v8::Local<v8::String> strDefine = v8::String::NewFromUtf8(isolate, "define");
// attach define function first.
v8::Local<v8::Function> def =
v8::FunctionTemplate::New(isolate, _define)->GetFunction();
def->ToObject()->Set(v8::String::NewFromUtf8(isolate, "amd"), v8::Object::New(isolate),
v8::ReadOnly);
context.glob->Set(strDefine, def, v8::ReadOnly);
exports = v8::Object::New(isolate);
// module and exports object
mod = v8::Object::New(isolate);
// init module
mod->Set(strExports, exports);
mod->Set(strRequire, context.glob->Get(strRequire), v8::ReadOnly);
// add to modules
std::string id(fname, 0, fname.length() - 3);
InstallModule(id, exports);
// attach to global
context.glob->Set(strModule, mod, v8::ReadOnly);
context.glob->Set(strExports, exports, v8::ReadOnly);
std::string sname;
if (!m_name.empty())
{
sname = m_name + srcname;
srcname = sname.c_str();
}
hr = context.run(script, srcname);
if (hr < 0)
{
// delete from modules
m_mods.erase(id);
return hr;
}
// remove commonjs function
context.glob->ForceDelete(strDefine);
context.glob->ForceDelete(strModule);
context.glob->ForceDelete(strExports);
// process defined modules
hr = doDefine(mod);
if (hr < 0)
{
// delete from modules
m_mods.erase(id);
return hr;
}
// attach again
context.glob->Set(strModule, mod, v8::ReadOnly);
context.glob->Set(strExports, exports, v8::ReadOnly);
// use module.exports as result value
v8::Local<v8::Value> v = mod->Get(strExports);
if (!exports->Equals(v))
InstallModule(id, v);
retVal = v;
return 0;
}
