void rpmluaSetVar(rpmlua _lua, rpmluav var)
{
INITSTATE(_lua, lua);
lua_State *L = lua->L;
if (var->listmode && lua->pushsize > 0) {
if (var->keyType != RPMLUAV_NUMBER || var->key.num == (double)0) {
var->keyType = RPMLUAV_NUMBER;
var->key.num = (double) luaL_getn(L, -1);
}
var->key.num++;
}
if (!var->listmode || lua->pushsize > 0) {
#if defined(LUA_GLOBALSINDEX)
if (lua->pushsize == 0)
lua_pushvalue(L, LUA_GLOBALSINDEX);
#endif
if (pushvar(L, var->keyType, &var->key) != -1) {
if (pushvar(L, var->valueType, &var->value) != -1)
lua_rawset(L, -3);
else
lua_pop(L, 1);
}
if (lua->pushsize == 0)
lua_pop(L, 1);
}
}
void rpmluaGetVar(rpmlua _lua, rpmluav var)
{
INITSTATE(_lua, lua);
lua_State *L = lua->L;
if (!var->listmode) {
if (lua->pushsize == 0)
lua_pushvalue(L, LUA_GLOBALSINDEX);
if (pushvar(L, var->keyType, &var->key) != -1) {
lua_rawget(L, -2);
popvar(L, &var->valueType, &var->value);
}
if (lua->pushsize == 0)
lua_pop(L, 1);
} else if (lua->pushsize > 0) {
(void) pushvar(L, var->keyType, &var->key);
if (lua_next(L, -2) != 0)
popvar(L, &var->valueType, &var->value);
}
}
unsigned char *gf4tp_tp(unsigned char *dst, struct gfainf *gi,
struct gfalin *gl, unsigned int flags) {
/* Current source, marker, top and bottom pointers */
const unsigned char *src = gl->line, *mrk, *top = gl->line,
*bot = gl->line + gl->size;
/* line command pointer, line command token, primary function token,
* secondary function token
*/
unsigned short lcp, lct, pft, sft;
unsigned short v;
/* double conversion buffer */
unsigned char dcb[8];
/* destination multi purpose conversion bin marker */
unsigned char *bin;
unsigned char c;
unsigned int i, j;
/* double conversion string */
char *dcs;
int num;
unsigned char *linestart=dst;
union {
unsigned long long int ull;
double d;
} u;
/* Variablen-Suffix text (VST) */
/* #,$,%,!,#(,$(,%(,!(,&,|,,,&(,|(,,$ */
static const unsigned char gfavst[][3] = {
{0x23, 0x00, 0x00}, /* "#" */
{0x24, 0x00, 0x00}, /* "$" */
{0x25, 0x00, 0x00}, /* "%" */
{0x21, 0x00, 0x00}, /* "!" */
{0x23, 0x28, 0x00}, /* "#(" */
{0x24, 0x28, 0x00}, /* "$(" */
{0x25, 0x28, 0x00}, /* "%(" */
{0x21, 0x28, 0x00}, /* "!(" */
{0x26, 0x00, 0x00}, /* "&" */
{0x7C, 0x00, 0x00}, /* "|" */
{0x00, 0x00, 0x00}, /* "" */
{0x00, 0x00, 0x00}, /* "" */
{0x26, 0x28, 0x00}, /* "&(" */
{0x7C, 0x28, 0x00}, /* "|(" */
{0x00, 0x00, 0x00}, /* "" */
{0x24, 0x00, 0x00}, /* "$" */
};
/* number character text */
static const unsigned char gfanct[] = {
0x30, 0x31, 0x32, 0x33,
0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x41, 0x42,
0x43, 0x44, 0x45, 0x46
};
assert(sizeof (double) == 8);
assert(sizeof (unsigned long long int) == 8);
pop16b(lcp, src);
lct = lcp / 4;
#ifdef DEBUG
gf4tp_output(" pointer= %hu depth= %hd\n", lcp, gl->depth);
#endif
switch (lcp) {
/* 0+ 4- 8+ 12- 16+ 20- 24+ 28- 32+ 36- 40+ 44- 48+ 52- 56* 60*
* 64* 76..120+ 124..168- 176+ 196+ 200+ 204- 208- 216+ 224* 1796+
*/
case 0: case 8: case 16: case 24: case 32: case 40: case 48:
case 76: case 80: case 84: case 88: case 92: case 96: case 100:
case 104: case 108: case 112: case 116: case 120: case 176: case 196:
case 200: case 216:
gl->depth -= (flags & TP_BACKW) != 0;
if (gl->depth > 0) /* Required because i is unsigned */
for (i = 0; i < gl->depth; i++)
*dst++ = 0x20, *dst++ = 0x20;
gl->depth += (flags & TP_BACKW) == 0;
break;
case 1796:
gl->depth -= (flags & TP_BACKW) != 0;
if (gl->depth > 0)
for (i = 0; i < gl->depth; i++)
*dst++ = 0x20, *dst++ = 0x20;
gl->depth += (flags & TP_BACKW) == 0 && (flags & TP_BUGEM) == 0;
break;
case 4: case 12: case 20: case 28: case 36: case 44: case 52:
case 124: case 128: case 132: case 136: case 140: case 144: case 148:
case 152: case 156: case 160: case 164: case 168: case 204: case 208:
gl->depth -= (flags & TP_BACKW) == 0;
if (gl->depth > 0)
for (i = 0; i < gl->depth; i++)
*dst++ = 0x20, *dst++ = 0x20;
gl->depth += (flags & TP_BACKW) != 0;
break;
case 56: case 60: case 64: case 224: case 252:
if (gl->depth > 0)
for (i = 1; i < gl->depth; i++)
*dst++ = 0x20, *dst++ = 0x20;
break;
default:
if (gl->depth > 0)
for (i = 0; i < gl->depth; i++)
*dst++ = 0x20, *dst++ = 0x20;
}
mrk = gfalct[lct];
while (*mrk != 0x00)
*dst++ = *mrk++;
switch (lcp) { /* TYPE */
case 456: case 460: case 464: case 468: /* REM, ', ==>, DATA */
if (*src != 0x0D)
*dst++ = 0x20;
/* FALLTROUGH */
case 1644: case 1016: /* $, . */
/* (1640(OPTION )) */
while (*src != 0x0D)
*dst++ = *src++;
src++;
src += (src - top) & 0x01;
break;
case 180: /* End of program */
return NULL;
case 192: case 236: /* MONITOR, RESTORE, */
case 420: case 1020: /* RESUME, RANDOMIZE, */
case 1072: case 1108: /* CLOSE, DEFLINE, */
case 1128: case 1136: /* DEFMARK, DEFTEXT, */
case 1140: case 1144: /* DEFFILL, DEFFILL, */
case 1236: case 1276: case 1300: /* QUIT, DIR, FILES, */
case 1364: case 1416: case 1420: /* SYSTEM, SOUND, WAVE, */
case 1592: /* DUMP */
if (*src != 0x46)
*dst++ = 0x20;
break;
case 124: case 128: case 132: /* NEXT x# */
src += 4;
pop16b(v, src);
pushvar(dst, mrk, 0, v, gi, gf4tp_resvar);
break;
case 136: case 140: case 144: /* NEXT x% */
src += 4;
pop16b(v, src);
pushvar(dst, mrk, 2, v, gi, gf4tp_resvar);
break;
case 148: case 152: case 156: /* NEXT x& */
src += 4;
pop16b(v, src);
pushvar(dst, mrk, 8, v, gi, gf4tp_resvar);
break;
case 160: case 164: case 168: /* NEXT x| */
src += 4;
pop16b(v, src);
pushvar(dst, mrk, 9, v, gi, gf4tp_resvar);
break;
case 304: case 76: case 80: case 84: case 256: /* x#= / */
/* FOR x#= / LET x#= */
pop16b(v, src);
pushvar(dst, mrk, 0, v, gi, gf4tp_resvar);
*dst++ = 0x3D; /* '=' */
break;
case 308: case 260: /* x$= / LET x$= */
pop16b(v, src);
pushvar(dst, mrk, 1, v, gi, gf4tp_resvar);
*dst++ = 0x3D;
break;
case 312: case 88: case 92: case 96: case 264: /* x%= / */
/* FOR x%= / LET x%= */
pop16b(v, src);
pushvar(dst, mrk, 2, v, gi, gf4tp_resvar);
*dst++ = 0x3D;
break;
case 316: case 268: /* x!= / LET x!= */
pop16b(v, src);
pushvar(dst, mrk, 3, v, gi, gf4tp_resvar);
*dst++ = 0x3D;
break;
case 320: case 100: case 104: case 108: case 272: /* x&= / */
/* FOR x&= / LET x&= */
pop16b(v, src);
pushvar(dst, mrk, 8, v, gi, gf4tp_resvar);
*dst++ = 0x3D;
break;
case 324: case 112: case 116: case 120: case 276: /* x|= / */
/* FOR x|= / LET x|= */
pop16b(v, src);
pushvar(dst, mrk, 9, v, gi, gf4tp_resvar);
*dst++ = 0x3D;
break;
case 328: case 280: case 656: case 688: case 720: /* x#()= / LET x#()= */
case 752: case 784: case 816: /* INC x#() / DEC x#() */
/* ADD x#() / SUB x#() */
/* MUL x#() / DIV x#() */
pop16b(v, src);
pushvar(dst, mrk, 4, v, gi, gf4tp_resvar);
break;
case 332: case 284: /* x$()= / LET x$()= */
pop16b(v, src);
pushvar(dst, mrk, 5, v, gi, gf4tp_resvar);
break;
case 336: case 288: case 660: case 692: case 724: /* x%()= / LET x%()= */
case 756: case 788: case 820: /* INC x%() / DEC x%() */
/* ADD x%() / SUB x%() */
/* MUL x%() / DIV x%() */
pop16b(v, src);
pushvar(dst, mrk, 6, v, gi, gf4tp_resvar);
break;
case 340: case 292: /* x!()= / LET x!()= */
pop16b(v, src);
pushvar(dst, mrk, 7, v, gi, gf4tp_resvar);
break;
case 344: case 296: case 664: case 696: case 728: /* x&()= / LET x&()= */
case 760: case 792: case 824: /* INC x&() / DEC x&() */
/* ADD x&() / SUB x&() */
/* MUL x&() / DIV x&() */
pop16b(v, src);
pushvar(dst, mrk, 12, v, gi, gf4tp_resvar);
break;
case 348: case 300: case 668: case 700: case 732: /* x|()= / LET x|()= */
case 764: case 796: case 828: /* INC x|() / DEC x|() */
/* ADD x|() / SUB x|() */
/* MUL x|() / DIV x|() */
pop16b(v, src);
pushvar(dst, mrk, 13, v, gi, gf4tp_resvar);
break;
case 24: case 216: /* PROCEDURE / */
/* > PROCEDURE */
pop16b(v, src);
pushvar(dst, mrk, 11, v, gi, gf4tp_resvar);
if (*src != 0x46)
*dst++ = 0x28; /* '(' */
break;
case 240: case 244: case 248: /* / @ / GOSUB */
pop16b(v, src);
pushvar(dst, mrk, 11, v, gi, gf4tp_resvar);
break;
case 1796: /* > FUNCTION */
break;
case 588: case 1212: case 1260: /* PRINT / LPRINT */
/* CLS */
if (*src != 0x46)
*dst++ = 0x20; /* ' ' */
break;
case 640: case 672: /* INC x# / DEC x# */
pop16b(v, src);
pushvar(dst, mrk, 0, v, gi, gf4tp_resvar);
break;
case 644: case 676: /* INC x% / DEC x% */
pop16b(v, src);
pushvar(dst, mrk, 2, v, gi, gf4tp_resvar);
break;
case 648: case 680: /* INC x& / DEC x& */
pop16b(v, src);
pushvar(dst, mrk, 8, v, gi, gf4tp_resvar);
break;
case 652: case 684: /* INC x| / DEC x| */
pop16b(v, src);
pushvar(dst, mrk, 9, v, gi, gf4tp_resvar);
break;
case 704: case 736: case 768: case 800: /* ADD x#, / SUB x#, / */
/* MUL x#, / DIV x#, */
pop16b(v, src);
pushvar(dst, mrk, 0, v, gi, gf4tp_resvar);
*dst++ = 0x2C; /* ',' */
break;
case 708: case 740: case 772: case 804: /* ADD x%, / SUB x%, / */
/* MUL x%, / DIV x%, */
pop16b(v, src);
pushvar(dst, mrk, 2, v, gi, gf4tp_resvar);
*dst++ = 0x2C;
break;
case 712: case 744: case 776: case 808: /* ADD x&, / SUB x&, / */
/* MUL x&, / DIV x&, */
pop16b(v, src);
pushvar(dst, mrk, 8, v, gi, gf4tp_resvar);
*dst++ = 0x2C;
break;
case 716: case 748: case 780: case 812: /* ADD x|, / SUB x|, / */
/* MUL x|, / DIV x|, */
pop16b(v, src);
pushvar(dst, mrk, 9, v, gi, gf4tp_resvar);
*dst++ = 0x2C;
break;
case 4: case 12: case 16: case 20: /* UNTIL (12) / */
case 32: case 48: case 56: case 60: /* EXIT IF (172, 220) / */
case 64: case 172: case 176: case 196: /* DO WHILE (196) / */
case 200: case 204: case 208: case 220: /* DO UNTIL (200) / */
case 224: /* LOOP WHILE (204) / */
/* LOOP (4) / */
/* LOOP UNTIL (208) / */
/* IF (32) / */
/* ELSE IF (64) / */
/* ELSE (56) / */
/* SELECT (48) / */
/* CASE (224) / */
/* WHILE (16) / */
/* WEND (20) / */
/* DEFAULT (60) / */
/* SELECT (176) / */
src += 4;
/*
' CASE 76,80,84,88,92,96,100,104,108,112,116,120
' CASE 124,128,132,136,140,144,148,152,156,160,164,168
' CASE 76,88,100,112,124,136,148,160 ! FOR / NEXT
CASE 124,128,132,136,140,144,148,152,156,160,164,168 ! NEXT
ADD a&,6
*/
}
while (src < bot) {
switch (pft = *src++) {
case 70:
src += (src - top) & 0x01;
if (src == bot)
break;
if (lcp != 1668) {
for (i = *src++; i > 0; i--)
*dst++ = 0x20;
*dst++ = 0x21; /* '!' */
for (mrk = src; mrk < bot && *mrk != 0x0D; mrk++);
if (mrk < bot) {
while (src < mrk)
*dst++ = *src++;
src++; /* 0x0D */
src += (src - top) & 0x01;
} else
/* FIXME Is there padding in this case? Is this case
* legal at all?
*/
src = mrk;
} else {
/* treat INLINE data... */
if(flags&TP_SAVEINLINE) {
/* find out pointer name and save the data into file.... */
unsigned char filename[256];
unsigned char *p=linestart;
unsigned char *d=filename;
while(p<dst && *p==' ') p++;
while(p<dst && *p) {
if(*p==' ') *d++='-';
else if(*p=='%') *d++='.';
else if(*p==',') break;
else if(isprint(*p)) *d++=*p;
else *d++='_';
p++;
}
*d++='i';*d++='n';*d++='l';
*d=0;
bsave(filename,src,(size_t)(bot-src));
gf4tp_output("Saved INLINE data into file --> %s (%d bytes.)\n",filename,bot-src);
} else {
/* Added hex printing of INLINE data / Markus Hoffmann 2013 */
printf("' ## INLINE:");
for (mrk = src; mrk < bot; mrk++) {
if((mrk-src)%16==0) printf("\n' $%04x: ",mrk-src);
printf("%02x ",*mrk);
} printf("\n' %d Bytes.\n",mrk-src);
}
src = bot;
}
break;
case 199:
src++;
/* FALLTROUGH */
case 198:
*dst++ = 0x22; /* '"' */
for (mrk = src + 4; src < mrk && *src == 0x00; src++);
while (src < mrk)
*dst++ = *src++;
*dst++ = 0x22;
break;
case 201:
src++;
/* FALLTROUGH */
case 200:
pop32b(num, src);
pushsig(dst, num);
pushnum(dst, num, 10, bin, i, j, c);
break;
case 203:
src++;
/* FALLTROUGH */
case 202:
*dst++ = 0x26; *dst++ = 0x48; /* "&H" */
pop32b(i, src);
pushnum(dst, i, 16, bin, i, j, c);
break;
case 205:
src++;
/* FALLTROUGH */
case 204:
*dst++ = 0x26; *dst++ = 0x4F; /* "&O" */
pop32b(i, src);
pushnum(dst, i, 8, bin, i, j, c);
break;
case 207:
src++;
/* FALLTROUGH */
case 206:
*dst++ = 0x26; *dst++ = 0x58; /* "&X" */
pop32b(i, src);
pushnum(dst, i, 2, bin, i, j, c);
break;
case 208:
sft = *src++;
mrk = gfasft[sft];
while (*mrk != 0x00)
*dst++ = *mrk++;
break;
case 46: /* !! */
/* case 55: NUMBER: */
case 64: /* !! */
case 68: /* !! */
case 136: case 137: /* !! */
case 144: case 145: case 146: case 147: /* !! */
case 148: case 149: case 150:
case 164: case 165: case 166: /* !! */
case 142: /* !! */
case 169: /* !! */
case 177: case 178: case 179: case 180: case 181: /* !! */
case 197: /* !! */
case 209: case 210: case 211: case 212: case 213: case 214: /* !! */
#ifdef DEBUG
gf4tp_output("201 gf4tp_tp() Error at %hu: "
"%02hhX is an unknown token code to me\n",
src - top, *src);
#endif
src++;
break;
case 215:
src++;
/* FALLTROUGH */
case 216:
/* binary 8byte double -> ASCII Octal */
*dst++ = 0x26; *dst++ = 0x4F; /* "&O" */
/* We cannot abuse dst as dcb here via bin = dst because
* there might be a constant at the 256 byte line length
* limit smaller than eight characters in it's ASCII
* representation, causing a buffer overflow.
*/
dgfabintoieee(dcb, src);
src += 8;
/* I don't know whether it's right that
* IEEE doubles are really sensitive to endianess, but
* according to a comparision between my Atari and
* a iPENTIUM it seems to be. Maybe GFA BASIC is just
* wrong here. Should be tested on an independend
* second big endian machine.
*/
copy64b(u.ull, dcb);
u.ull = (unsigned long long int) u.d;
/* C99 offers an %A format which even obeys hexadecimal
* fractions. However I think GFA BASIC does not allow
* fractional hexadecimal constants.
*/
pushnum(dst, u.ull, 8, bin, i, j, c);
break;
case 217:
src++;
/* FALLTROUGH */
case 218:
/* binary 8byte double -> ASCII binary */
*dst++ = 0x26; *dst++ = 0x58; /* "&X" */
dgfabintoieee(dcb, src);
src += 8;
copy64b(u.ull, dcb);
u.ull = (unsigned long long int) u.d;
pushnum(dst, u.ull, 2, bin, i, j, c);
break;
case 219:
src++;
/* FALLTROUGH */
case 220:
/* binary 8byte double -> ASCII hexa */
*dst++ = 0x26; *dst++ = 0x48; /* "&H" */
dgfabintoieee(dcb, src);
src += 8;
copy64b(u.ull, dcb);
u.ull = (unsigned long long int) u.d;
pushnum(dst, u.ull, 16, bin, i, j, c);
break;
case 221:
src++;
/* FALLTROUGH */
case 223: /* 1234567890.1234567890E+1234567890 */
/* binary 8byte double -> ASCII decimal */
dgfabintoieee(dcb, src);
src += 8;
copy64b(u.ull, dcb);
dcs = dst;
sprintf(dcs, "%G", u.d);
while (*dcs != '\0')
switch (*dcs++) {
case '0': *dst++ = 0x30; break;
case '1': *dst++ = 0x31; break;
case '2': *dst++ = 0x32; break;
case '3': *dst++ = 0x33; break;
case '4': *dst++ = 0x34; break;
case '5': *dst++ = 0x35; break;
case '6': *dst++ = 0x36; break;
case '7': *dst++ = 0x37; break;
case '8': *dst++ = 0x38; break;
case '9': *dst++ = 0x39; break;
case '.': *dst++ = 0x2E; break;
case 'E': *dst++ = 0x45; break;
case '+': *dst++ = 0x2B; break;
case '-': *dst++ = 0x2D; break;
default: *dst++ = 0x3F; break;
}
break;
case 222: /* " */
*dst++ = 0x22; /* '"' */
for (i = *src++; i > 0; i--)
if ((*dst++ = *src++) == 0x22)
*dst++ = 0x22;
*dst++ = 0x22;
break;
case 224: case 225: case 226: case 227: case 228:
case 229: case 230: case 231: case 232: case 233:
case 234: case 235: case 236: case 237: case 238:
case 239:
// varstart=dst; /* save marker for variable name for INLINE*/
i = pft - 224;
v = *src++;
pushvar(dst, mrk, i, v, gi, gf4tp_resvar);
break;
case 240: case 241: case 242: case 243: case 244:
case 245: case 246: case 247: case 248: case 249:
case 250: case 251: case 252: case 253: case 254:
case 255:
i = pft - 240;
pop16b(v, src);
pushvar(dst, mrk, i, v, gi, gf4tp_resvar);
break;
default:
mrk = gfapft[pft];
while (*mrk != 0x00)
*dst++ = *mrk++;
}
}
*dst = '\0';
return dst;
}
static int luci_handle_req(struct httpd_plugin *p, struct http_context *ctx)
{
int ret;
lua_newtable(L); /* new table for the http context */
/* convert http_context data structure to lua table */
#define PUSH(x) pushvar(#x, ctx->x)
PUSH(cookie);
PUSH(request_method);
PUSH(server_addr);
PUSH(server_proto);
PUSH(query_string);
PUSH(remote_addr);
lua_pushinteger(L, ctx->remote_port);
lua_setfield(L, -2, "remote_port");
PUSH(content_type);
PUSH(content_length);
PUSH(http_accept);
#undef PUSH
if (!strncmp(ctx->uri, p->prefix, strlen(p->prefix)))
pushvar("uri", ctx->uri + strlen(p->prefix));
else
pushvar("uri", ctx->uri);
/* make sure the global 'luci' table is prepared */
lua_getglobal(L, "luci-plugin");
if (!lua_istable(L, -1))
return 0;
lua_getfield(L, -1, "init_req");
if (!lua_isfunction(L, -1)) {
/* ignore error */
lua_pop(L, 1);
} else {
lua_pushvalue(L, -3);
luci_pcall(L, "init_req", 1);
}
/* storage space for cgi variables */
lua_newtable(L);
lua_pushvalue(L, -1); /* copy for setfield */
lua_setfield(L, -3, "vars");
lua_pushvalue(L, -3); /* the http context table */
/*
* make luci_parse_header a closure
* argument 1: the luci.vars table
* argument 2: the http context table
*/
lua_pushcclosure(L, luci_parse_header, 2);
ret = luci_pcall(L, "parse_header", 0);
lua_getfield(L, -1, "handle_req");
ret = lua_isfunction(L, -1);
if (!ret)
goto done;
lua_pushvalue(L, -3);
ret = luci_pcall(L, "handle_req", 1);
/* pop the luci and http context tables */
done:
lua_pop(L, 2);
return ret;
}
