From e8b81c92e78dc781a9569d7d51bd4f98d89237f8 Mon Sep 17 00:00:00 2001 From: nbd Date: Fri, 5 Oct 2007 00:27:49 +0000 Subject: Upgrade busybox to 1.7.2 - clean up insmod crap - add some lineno/programname fixes for awx - clean up awk getopt stuff - remove unnecessary patches git-svn-id: svn://svn.openwrt.org/openwrt/trunk@9130 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- package/busybox/patches/510-awx.patch | 1624 +++++++++++++++++++++++++++++++++ 1 file changed, 1624 insertions(+) create mode 100644 package/busybox/patches/510-awx.patch (limited to 'package/busybox/patches/510-awx.patch') diff --git a/package/busybox/patches/510-awx.patch b/package/busybox/patches/510-awx.patch new file mode 100644 index 000000000..571b32397 --- /dev/null +++ b/package/busybox/patches/510-awx.patch @@ -0,0 +1,1624 @@ +Index: busybox-1.7.2/editors/awk.c +=================================================================== +--- busybox-1.7.2.orig/editors/awk.c 2007-10-05 01:39:50.073293533 +0200 ++++ busybox-1.7.2/editors/awk.c 2007-10-05 02:16:42.539374788 +0200 +@@ -33,6 +33,11 @@ + /* these flags are static, don't change them when value is changed */ + #define VF_DONTTOUCH (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY) + ++#ifdef CONFIG_AWX ++#define fputs(s, stream) fputs_hook(s, stream) ++static inline int fputs_hook (__const char *__restrict __s, FILE *__restrict __stream); ++#endif ++ + /* Variable */ + typedef struct var_s { + unsigned type; /* flags */ +@@ -54,9 +59,14 @@ + } chain; + + /* Function */ ++typedef var *(*awk_cfunc)(var *res, var *args, int nargs); + typedef struct func_s { + unsigned nargs; +- struct chain_s body; ++ enum { AWKFUNC, CFUNC } type; ++ union { ++ awk_cfunc cfunc; ++ struct chain_s body; ++ } x; + } func; + + /* I/O stream */ +@@ -1400,7 +1410,8 @@ + next_token(TC_FUNCTION); + g_pos++; + f = newfunc(t_string); +- f->body.first = NULL; ++ f->type = AWKFUNC; ++ f->x.body.first = NULL; + f->nargs = 0; + while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) { + v = findvar(ahash, t_string); +@@ -1409,7 +1420,7 @@ + if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM) + break; + } +- seq = &(f->body); ++ seq = &(f->x.body); + chain_group(); + clear_array(ahash); + +@@ -2372,7 +2383,8 @@ + break; + + case XC( OC_FUNC ): +- if (!op->r.f->body.first) ++ if ((op->r.f->type == AWKFUNC) && ++ !op->r.f->x.body.first) + syntax_error(EMSG_UNDEF_FUNC); + + X.v = R.v = nvalloc(op->r.f->nargs+1); +@@ -2389,7 +2401,10 @@ + fnargs = X.v; + + L.s = g_progname; +- res = evaluate(op->r.f->body.first, res); ++ if (op->r.f->type == AWKFUNC) ++ res = evaluate(op->r.f->x.body.first, res); ++ else if (op->r.f->type == CFUNC) ++ res = op->r.f->x.cfunc(res, fnargs, op->r.f->nargs); + g_progname = L.s; + + nvfree(fnargs); +@@ -2753,6 +2768,13 @@ + } + + int awk_main(int argc, char **argv); ++int awx_main(int argc, char **argv); ++ ++#ifdef CONFIG_AWX ++static int is_awx = 0; ++#include "awx.c" ++#endif ++ + int awk_main(int argc, char **argv) + { + unsigned opt; +@@ -2817,6 +2839,11 @@ + *s1 = '='; + } + } ++ ++#ifdef CONFIG_AWX ++ do_awx(argc, argv); ++#endif ++ + opt_complementary = "v::f::"; + opt = getopt32(argv, "F:v:f:W:", &opt_F, &opt_v, &opt_f, &opt_W); + argv += optind; +Index: busybox-1.7.2/editors/awx.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ busybox-1.7.2/editors/awx.c 2007-10-05 02:10:16.393369582 +0200 +@@ -0,0 +1,636 @@ ++/* ++ * awk web extension ++ * ++ * Copyright (C) 2007 by Felix Fietkau ++ * ++ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. ++ */ ++ ++#include ++#include ++#include "awx_parser.h" ++ ++#define LINE_BUF 2048 ++#define HASH_MAX 1536 ++#define TR_START "@TR<<" ++#define TR_END ">>" ++#define MAX_TR 32 ++ ++#undef fputs ++ ++static xhash *lstr = NULL; ++static xhash *formvar = NULL; ++static int lang_inuse = 0; ++ ++/* look up a translation symbol from the hash */ ++static inline const char *translate_lookup(char *str) ++{ ++ char *name, *def, *p; ++ hash_item *hi; ++ var *v; ++ ++ def = name = str; ++ if (((p = strchr(str, '|')) != NULL) ++ || ((p = strchr(str, '#')) != NULL)) { ++ def = p + 1; ++ *p = 0; ++ } ++ ++ hi = hash_search(lstr, name); ++ if (!hi) ++ return def; ++ ++ v = &hi->data.v; ++ ++ return getvar_s(v); ++} ++ ++/* look for translation markers in the line and return the translated string */ ++static char *translate_line(char *line) ++{ ++ const char *tok[MAX_TR * 3]; ++ char *l, *p, *p2 = NULL, *res; ++ int len = 0, _pos = 0, i, tr_abort = 0; ++ static char *backlog = NULL; ++ ++ if (backlog && line) { ++ backlog = xrealloc(backlog, strlen(backlog) + strlen(line) + 1); ++ sprintf(backlog + strlen(backlog), line); ++ l = backlog; ++ } else { ++ l = line; ++ } ++ ++ while (l != NULL) { ++ if ((p = strstr(l, TR_START)) == NULL) { ++ len += strlen((tok[_pos++] = l)); ++ break; ++ } ++ ++ p2 = strstr(p, TR_END); ++ if (p2 == NULL) { ++ p2 = xstrdup(l); ++ tr_abort = 1; ++ break; ++ } ++ ++ *p = 0; ++ len += strlen((tok[_pos++] = l)); ++ *p2 = 0; ++ len += strlen((tok[_pos++] = translate_lookup(p + strlen(TR_START)))); ++ ++ l = p2; ++ l += strlen(TR_END); ++ } ++ len++; ++ ++ p = xmalloc(len + 1); ++ *p = 0; ++ res = p; ++ for (i = 0; i < _pos; i++) { ++ strcat(p, tok[i]); ++ p += strlen(tok[i]); ++ } ++ if (backlog) { ++ free(backlog); ++ backlog = NULL; ++ } ++ if (tr_abort && p2) ++ backlog = p2; ++ ++ return res; ++} ++ ++/* hook for intercepting awk's use of puts. used for running all printed strings ++ * through the translation system */ ++static inline int fputs_hook (__const char *__restrict __s, FILE *__restrict __stream) ++{ ++ if (lang_inuse && (__stream == stdout)) { ++ int ret; ++ char *str; ++ ++ str = translate_line((char *) __s); ++ ret = fputs(str, __stream); ++ free(str); ++ ++ return ret; ++ } ++ ++ return fputs(__s, __stream); ++} ++ ++static var *init_lang(var *res, var *args, int nargs) ++{ ++ if (!lstr) ++ lstr = hash_init(); ++ ++ lang_inuse = 1; ++ return res; ++} ++ ++ ++/* load and parse language file */ ++static void load_lang_file(char *file) ++{ ++ FILE *f; ++ char *b, *name, *value; ++ char buf1[LINE_BUF]; ++ ++ if ((f = fopen(file, "r")) == NULL) ++ return; ++ ++ while (!feof(f) && (fgets(buf1, LINE_BUF - 1, f) != NULL)) { ++ b = buf1; ++ if (*b == '#') ++ continue; /* skip comments */ ++ ++ while (isspace(*b)) ++ b++; /* skip leading spaces */ ++ if (!*b) ++ continue; ++ ++ name = b; ++ if ((b = strstr(name, "=>")) == NULL) ++ continue; /* separator not found */ ++ ++ value = b + 2; ++ if (!*value) ++ continue; ++ ++ *b = 0; ++ for (b--; isspace(*b); b--) ++ *b = 0; /* remove trailing spaces */ ++ ++ while (isspace(*value)) ++ value++; /* skip leading spaces */ ++ ++ for (b = value + strlen(value) - 1; isspace(*b); b--) ++ *b = 0; /* remove trailing spaces */ ++ ++ if (!*value) ++ continue; ++ ++ setvar_s(findvar(lstr,name), value); ++ } ++ ++ fclose(f); ++} ++ ++static var *load_lang(var *res, var *args, int nargs) ++{ ++ const char *langfmt = "/usr/lib/webif/lang/%s.txt"; ++ char lbuf[LINE_BUF]; ++ const char *lang; ++ ++ if (!lang_inuse) ++ init_lang(res, args, nargs); ++ ++ lang = getvar_s(args); ++ if (!lang || !strcmp(lang, "")) ++ return res; ++ ++ sprintf(lbuf, langfmt, lang); ++ load_lang_file(lbuf); ++ ++ return res; ++} ++ ++/* read the contents of an entire file */ ++static char *get_file(const char *fname) ++{ ++ FILE *F; ++ char *s = NULL; ++ int i, j, flen; ++ ++ F = fopen(fname, "r"); ++ if (!F) { ++ return NULL; ++ } ++ ++ if (fseek(F, 0, SEEK_END) == 0) { ++ flen = ftell(F); ++ s = (char *)xmalloc(flen+4); ++ fseek(F, 0, SEEK_SET); ++ i = 1 + fread(s+1, 1, flen, F); ++ } else { ++ for (i=j=1; j>0; i+=j) { ++ s = (char *)xrealloc(s, i+4096); ++ j = fread(s+i, 1, 4094, F); ++ } ++ } ++ ++ s[i] = '\0'; ++ fclose(F); ++ return s; ++} ++ ++ ++/* parse_include(): ++ * ++ * taken from parse_program from awk.c ++ * END{} is not parsed here, and BEGIN{} is executed immediately ++ */ ++static void parse_include(char *p) ++{ ++ uint32_t tclass; ++ chain *initseq = NULL; ++ chain tmp; ++ func *f; ++ var *v, *tv; ++ ++ tv = nvalloc(1); ++ memset(&tmp, 0, sizeof(tmp)); ++ g_pos = p; ++ t_lineno = 1; ++ while ((tclass = next_token(TC_EOF | TC_OPSEQ | ++ TC_OPTERM | TC_BEGIN | TC_FUNCDECL)) != TC_EOF) { ++ if (tclass & TC_OPTERM) ++ continue; ++ ++ seq = &tmp; ++ if (tclass & TC_BEGIN) { ++ initseq = xzalloc(sizeof(chain)); ++ seq = initseq; ++ chain_group(); ++ } else if (tclass & TC_FUNCDECL) { ++ next_token(TC_FUNCTION); ++ g_pos++; ++ f = newfunc(t_string); ++ f->type = AWKFUNC; ++ f->x.body.first = NULL; ++ f->nargs = 0; ++ while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) { ++ v = findvar(ahash, t_string); ++ v->x.aidx = (f->nargs)++; ++ ++ if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM) ++ break; ++ } ++ seq = &(f->x.body); ++ chain_group(); ++ clear_array(ahash); ++ } ++ } ++ if (initseq && initseq->first) ++ tv = evaluate(initseq->first, tv); ++ nvfree(tv); ++} ++ ++ ++/* include an awk file and run its BEGIN{} section */ ++static xhash *includes = NULL; ++static void include_file(const char *filename) ++{ ++ char *s; ++ var *v; ++ int oldlnr = g_lineno; ++ const char *oldprg = g_progname; ++ ++ if (!includes) ++ includes = hash_init(); ++ ++ /* find out if the file has been included already */ ++ v = findvar(includes, filename); ++ if (istrue(v)) ++ return; ++ setvar_s(v, "1"); ++ ++ /* read include file */ ++ s = get_file(filename); ++ if (!s) { ++ fprintf(stderr, "Could not open file.\n"); ++ return; ++ } ++ g_lineno = 1; ++ g_progname = xstrdup(filename); ++ parse_include(s+1); ++ free(s); ++ g_lineno = oldlnr; ++ g_progname = oldprg; ++} ++ ++static var *include(var *res, var *args, int nargs) ++{ ++ const char *s; ++ ++ s = getvar_s(args); ++ if (s && (strlen(s) > 0)) ++ include_file(s); ++ ++ return res; ++} ++ ++/* parse an awk expression */ ++static var *parse_awk(char *str, var *tv) ++{ ++ chain body; ++ node *n; ++ ++ memset(&body, 0, sizeof(body)); ++ g_pos = str; ++ seq = &body; ++ ++ /* end of expression, assume that there's going to be a free byte ++ * at the end of the string that can be used for the ')' */ ++ strcat(str + strlen(str), "}"); ++ n = parse_expr(TC_GRPTERM); ++ if (!n) ++ return NULL; ++ ++ return evaluate(n, tv); ++} ++ ++static inline void print_translate(char *s) ++{ ++ char *str = s; ++ if (lang_inuse) ++ str = translate_line(s); ++ fputs(str, stdout); ++ fflush(stdout); ++ if (lang_inuse) ++ free(str); ++} ++ ++static void render_element(struct template_cb *tcb, struct template_element *e) ++{ ++ var *v; ++ char *s, *s2; ++ int i; ++ ++ if (!e || !e->var) ++ return; ++ g_lineno = e->line; ++ switch (e->t) { ++ case T_TEXT: ++ s = malloc(strlen(e->var) + 2); ++ strcpy(s, e->var); ++ print_translate(s); ++ free(s); ++ break; ++ case T_CODE: ++ s = malloc(strlen(e->var) + 2); ++ strcpy(s, e->var); ++ v = nvalloc(1); ++ s2 = strdup(getvar_s(parse_awk(s, v))); ++ nvfree(v); ++ print_translate(s2); ++ free(s); ++ free(s2); ++ break; ++ case T_IF: ++ s = malloc(strlen(e->var) + 2); ++ strcpy(s, e->var); ++ v = nvalloc(1); ++ i = istrue(parse_awk(s, v)); ++ nvfree(v); ++ free(s); ++ ++ if (i) ++ execute_template(tcb, e->sub); ++ else if (e->sub2) ++ execute_template(tcb, e->sub2); ++ break; ++ case T_FOR: { ++ v = newvar(e->var); ++ hashwalk_init(v, iamarray(findvar(vhash, e->in))); ++ while (hashwalk_next(v)) { ++ execute_template(tcb, e->sub); ++ } ++ clrvar(v); ++ } ++ break; ++ default: ++ break; ++ } ++} ++ ++/* awk method render(), which opens a template file and processes all awk ssi calls */ ++static void render_file(const char *filename) ++{ ++ struct template_cb tcb; ++ struct template_element *e; ++ FILE *f; ++ const char *oldprg = g_progname; ++ int oldlnr = g_lineno; ++ ++ if (!filename) ++ return; ++ ++ f = fopen(filename, "r"); ++ if (!f) ++ return; ++ ++ g_progname = xstrdup(filename); ++ g_lineno = 1; ++ memset(&tcb, 0, sizeof(tcb)); ++ tcb.handle_element = render_element; ++ e = parse_template(&tcb, f); ++ execute_template(&tcb, e); ++ free_template(&tcb, e); ++ fclose(f); ++ g_progname = oldprg; ++ g_lineno = oldlnr; ++} ++ ++static var *render(var *res, var *args, int nargs) ++{ ++ const char *s; ++ ++ s = getvar_s(args); ++ if (!s) ++ return res; ++ ++ render_file(s); ++ ++ return res; ++} ++ ++/* Call render, but only if this function hasn't been called already */ ++static int layout_rendered = 0; ++static var *render_layout(var *res, var *args, int nargs) ++{ ++ if (layout_rendered) ++ return res; ++ layout_rendered = 1; ++ return render(res, args, nargs); ++} ++ ++/* registers a global c function for the awk interpreter */ ++static void register_cfunc(const char *name, awk_cfunc cfunc, int nargs) ++{ ++ func *f; ++ ++ f = newfunc(name); ++ f->type = CFUNC; ++ f->x.cfunc = cfunc; ++ f->nargs = nargs; ++} ++ ++static void putvar(vartype type, char *name, char *value) ++{ ++ if (type != FORM_VAR) ++ return; ++ ++ setvar_u(findvar(formvar, name), value); ++} ++ ++static const char *cgi_getvar(const char *name) ++{ ++ if (!formvar) { ++ formvar = hash_init(); ++ cgi_init(putvar); ++ } ++ ++ if (!formvar || !name) ++ return NULL; ++ ++ return getvar_s(findvar(formvar, name)); ++} ++ ++/* function call for accessing cgi form variables */ ++static var *getvar(var *res, var *args, int nargs) ++{ ++ const char *s, *svar; ++ ++ s = getvar_s(args); ++ if (!s) ++ return res; ++ ++ svar = cgi_getvar(s); ++ if (!svar) ++ return res; ++ ++ setvar_u(res, svar); ++ ++ return res; ++} ++ ++/* call an awk function without arguments by string reference */ ++static var *call(var *res, var *args, int nargs) ++{ ++ const char *s = getvar_s(args); ++ func *f; ++ ++ if (!s) ++ goto done; ++ ++ f = newfunc(s); ++ if (f && f->type == AWKFUNC && f->x.body.first) ++ return evaluate(f->x.body.first, res); ++ ++done: ++ return res; ++} ++ ++ ++static int run_awxscript(char *name) ++{ ++ var tv, *layout, *action; ++ char *tmp, *s = NULL; ++ ++ zero_out_var(&tv); ++ g_progname = name; ++ ++ /* read the main controller source */ ++ s = get_file(g_progname); ++ if (!s) { ++ fprintf(stderr, "Could not open file\n"); ++ return 1; ++ } ++ parse_program(s+1); ++ free(s); ++ ++ ++ /* set some defaults for ACTION and LAYOUT, which will have special meaning */ ++ layout = newvar("LAYOUT"); ++ setvar_s(layout, "views/layout.ahtml"); ++ ++ /* run the BEGIN {} block */ ++ evaluate(beginseq.first, &tv); ++ ++ action = newvar("ACTION"); ++ if (!(strlen(getvar_s(action)) > 0)) { ++ tmp = (char *) cgi_getvar("action"); ++ if (!tmp || (strlen(tmp) <= 0)) ++ tmp = strdup("default"); ++ ++ setvar_p(action, tmp); ++ } ++ ++ /* call the action (precedence: begin block override > cgi parameter > "default") */ ++ tmp = xmalloc(strlen(getvar_s(action)) + 7); ++ sprintf(tmp, "handle_%s", getvar_s(action)); ++ setvar_s(action, tmp); ++ call(&tv, action, 1); ++ free(tmp); ++ ++ /* render the selected layout, will do nothing if render_layout has been called from awk */ ++ render_layout(&tv, layout, 1); ++ ++ return 0; ++} ++ ++ ++/* main awx processing function. called from awk_main() */ ++static int do_awx(int argc, char **argv) ++{ ++ int ret = -1; ++ var tv; ++ int i, c; ++ char **args = argv; ++ ++ zero_out_var(&tv); ++ ++ /* register awk C callbacks */ ++ register_cfunc("getvar", getvar, 1); ++ register_cfunc("render", render, 1); ++ register_cfunc("render_layout", render_layout, 1); ++ register_cfunc("call", call, 1); ++ register_cfunc("include", include, 1); ++ register_cfunc("init_lang", init_lang, 1); ++ register_cfunc("load_lang", load_lang, 1); ++ ++ if (!is_awx) ++ return 0; ++ ++ /* fill in ARGV array */ ++ setvar_i(intvar[ARGC], argc + 1); ++ setari_u(intvar[ARGV], 0, "awx"); ++ i = 0; ++ while (*args) ++ setari_u(intvar[ARGV], ++i, *args++); ++ ++ while((c = getopt(argc, argv, "i:f:")) != EOF) { ++ switch(c) { ++ case 'i': ++ g_progname = optarg; ++ include_file(optarg); ++ break; ++ case 'f': ++ ret = 0; ++ g_progname = optarg; ++ render_file(optarg); ++ goto done; ++ } ++ } ++ argc -= optind; ++ argv += optind; ++ ++ if (argc < 1) { ++ fprintf(stderr, "Invalid argument.\n"); ++ goto done; ++ } ++ ++ ret = run_awxscript(*argv); ++ ++done: ++ exit(ret); ++} ++ ++/* entry point for awx applet */ ++int awx_main(int argc, char **argv) ++{ ++ is_awx = 1; ++ return awk_main(argc, argv); ++} ++ +Index: busybox-1.7.2/editors/awx_parser.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ busybox-1.7.2/editors/awx_parser.h 2007-10-05 01:43:59.487506840 +0200 +@@ -0,0 +1,38 @@ ++#ifndef __TEMPLATE_PARSER_H ++#define __TEMPLATE_PARSER_H ++ ++enum type { ++ T_TEXT, ++ T_FOR, ++ T_IF, ++ T_CODE ++}; ++ ++struct template_element; ++struct template_cb; ++ ++struct template_cb { ++ void *(*prepare_code)(struct template_element *); ++ void (*handle_element)(struct template_cb *, struct template_element *); ++ void (*free_code)(struct template_element *); ++}; ++ ++struct template_element { ++ enum type t; ++ char *var; ++ char *in; ++ int line; ++ void *priv; ++ struct template_element *parent; ++ struct template_element *sub; ++ struct template_element *sub2; ++ struct template_element *prev; ++ struct template_element *next; ++}; ++ ++ ++struct template_element *parse_template(struct template_cb *cb, FILE *in); ++void execute_template(struct template_cb *cb, struct template_element *e); ++void free_template(struct template_cb *cb, struct template_element *e); ++ ++#endif +Index: busybox-1.7.2/editors/awx_parser.l +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ busybox-1.7.2/editors/awx_parser.l 2007-10-05 01:43:59.547510259 +0200 +@@ -0,0 +1,302 @@ ++%{ ++#include ++#include ++#include ++#include "busybox.h" ++#include "awx_parser.h" ++ ++enum { ++ S_INIT, ++ S_TEXT, ++ S_CODE, ++ S_IF_START, ++ S_FOR_START, ++ S_FOR_IN, ++ S_END, ++ S_ELSE, ++ S_EOF ++}; ++int state; ++ ++#undef DEBUG ++#ifdef DEBUG ++char *statestr[] = { ++ [S_INIT] = "S_INIT", ++ [S_TEXT] = "S_TEXT", ++ [S_CODE] = "S_CODE", ++ [S_IF_START] = "S_IF_START", ++ [S_FOR_START] = "S_FOR_START", ++ [S_FOR_IN] = "S_FOR_IN", ++ [S_EOF] = "S_EOF" ++}; ++ ++char *typestr[] = { ++ [T_TEXT] = "T_TEXT", ++ [T_FOR] = "T_FOR", ++ [T_IF] = "T_IF", ++ [T_CODE] = "T_CODE" ++}; ++#endif ++ ++static struct template_cb *parse_cb; ++static struct template_element *cur, *head; ++static char *textbuf; ++static unsigned int buflen; ++static unsigned int buf_offset; ++static int _lnr = 0; ++ ++static void buf_realloc(void) ++{ ++ buflen *= 2; ++ textbuf = xrealloc(textbuf, buflen); ++} ++ ++static void parse_error(char *str) ++{ ++ fprintf(stderr, "Parse error%s%s\n", (str ? ": " : "!"), (str ?: "")); ++ exit(255); ++} ++ ++ ++static struct template_element *new_template_element(struct template_element *parent) ++{ ++ struct template_element *ptr; ++ ++ ptr = xzalloc(sizeof(struct template_element)); ++ ptr->parent = parent; ++ return ptr; ++} ++ ++static inline void next_template_element(void) ++{ ++ cur->next = new_template_element(cur->parent); ++ cur->next->prev = cur; ++ cur = cur->next; ++} ++ ++static void addtext(char *text) ++{ ++ while(buf_offset + strlen(text) + 1 > buflen) ++ buf_realloc(); ++ ++ buf_offset += sprintf(&textbuf[buf_offset], "%s", text); ++} ++ ++static void set_state(int newstate) ++{ ++ char *ptr; ++ ++#ifdef DEBUG ++ static int _rec = 0; ++ fprintf(stderr, "DEBUG(%d): %s => %s: %s\n", _rec, statestr[state], statestr[newstate], textbuf); ++#endif ++ ptr = xstrdup(textbuf); ++ if (state == S_FOR_IN) ++ cur->in = ptr; ++ else ++ cur->var = ptr; ++ ++ if (parse_cb && (cur->t == T_CODE) && parse_cb->prepare_code) ++ parse_cb->prepare_code(cur); ++ ++ buf_offset = 0; ++ *textbuf = 0; ++ ++ switch(newstate) { ++#if 0 ++ case S_EOF: ++ if (cur->parent) ++ parse_error(); ++ break; ++#endif ++ case S_FOR_START: ++ if (ptr || !cur->prev) ++ next_template_element(); ++ cur->t = T_FOR; ++ break; ++ case S_IF_START: ++ if (ptr || !cur->prev) ++ next_template_element(); ++ cur->t = T_IF; ++ break; ++ case S_ELSE: ++ cur = cur->parent; ++ if (!cur) ++ parse_error("'@else' without parent element"); ++ cur->sub2 = new_template_element(cur); ++ cur = cur->sub2; ++ newstate = S_TEXT; ++ break; ++ case S_END: ++#ifdef DEBUG ++ _rec--; ++#endif ++ cur = cur->parent; ++ if (!cur) ++ parse_error("'@end' without parent element"); ++ ++ next_template_element(); ++ cur->t = T_TEXT; ++ newstate = S_TEXT; ++ break; ++ case S_TEXT: ++ switch (cur->t) { ++ case T_CODE: ++ next_template_element(); ++ break; ++ case T_IF: ++ case T_FOR: ++#ifdef DEBUG ++ _rec++; ++#endif ++ cur->sub = new_template_element(cur); ++ cur = cur->sub; ++ break; ++ default: ++ break; ++ } ++ cur->t = T_TEXT; ++ break; ++ case S_CODE: ++ if (ptr || !cur->prev) ++ next_template_element(); ++ cur->t = T_CODE; ++ break; ++ default: ++ break; ++ } ++ cur->line = _lnr; ++ state = newstate; ++} ++ ++%} ++ ++%% ++"<%"[ \n\t]*"@if"[ \n\t]+ { ++ if (state == S_TEXT) ++ set_state(S_IF_START); ++ else ++ REJECT; ++} ++ ++"<%"[ \n\t]*"@for"[ \n\t]+ { ++ if (state == S_TEXT) ++ set_state(S_FOR_START); ++ else ++ REJECT; ++} ++ ++[ \n\t]+"in"[ \n\t]+ { ++ if (state == S_FOR_START) ++ set_state(S_FOR_IN); ++ else ++ REJECT; ++} ++ ++"<%"[ \n\t]*"@end"[ \n\t]*%> { ++ if (state != S_TEXT) ++ REJECT; ++ set_state(S_END); ++} ++ ++"<%"[ \n\t]*"@else"[ \n\t]*%> { ++ if (state != S_TEXT) ++ REJECT; ++ set_state(S_ELSE); ++} ++ ++"<%" { ++ if (state != S_TEXT) ++ parse_error("'<%' cannot be nested"); ++ set_state(S_CODE); ++} ++ ++[ \n\t]"%>" { ++ if (state == S_TEXT) ++ REJECT; ++ set_state(S_TEXT); ++} ++ ++\n { ++ _lnr++; ++ if (state == S_TEXT) ++ addtext(yytext); ++} ++. { ++ addtext(yytext); ++} ++ ++ ++%% ++ ++ ++void execute_template(struct template_cb *cb, struct template_element *e) ++{ ++ static int rec = 0; ++ ++ while (e) { ++#ifdef DEBUG ++ fprintf(stderr, "DEBUG: execute(%d)\t%s\n", rec, typestr[e->t]); ++#endif ++ rec++; ++ if (cb->handle_element) ++ cb->handle_element(cb, e); ++ rec--; ++ e = e->next; ++ } ++} ++ ++int yywrap() ++{ ++ set_state(S_EOF); ++ return 1; ++} ++ ++struct template_element *parse_template(struct template_cb *cb, FILE *in) ++{ ++ _lnr = 1; ++ buf_offset = 0; ++ state = S_TEXT; ++ parse_cb = cb; ++ ++ buflen = 4096; ++ textbuf = xzalloc(buflen); ++ ++ head = xzalloc(sizeof(struct template_element)); ++ head->t = T_TEXT; ++ cur = head; ++ ++ yyin = in; ++ yylex(); ++ ++ return head; ++} ++ ++void free_template(struct template_cb *cb, struct template_element *e) ++{ ++ struct template_element *next; ++ return; ++ if (!e) ++ return; ++ ++ switch (e->t) { ++ case T_CODE: ++ if (cb->free_code) ++ cb->free_code(e); ++ break; ++ case T_FOR: ++ case T_IF: ++ free_template(cb, e->sub); ++ break; ++ default: ++ break; ++ } ++ if (e->var) ++ free(e->var); ++ if (e->in) ++ free(e->in); ++ ++ next = e->next; ++ free(e); ++ return free_template(cb, next); ++} +Index: busybox-1.7.2/editors/Config.in +=================================================================== +--- busybox-1.7.2.orig/editors/Config.in 2007-10-05 01:39:50.097294897 +0200 ++++ busybox-1.7.2/editors/Config.in 2007-10-05 01:43:59.583512308 +0200 +@@ -12,6 +12,13 @@ + Awk is used as a pattern scanning and processing language. This is + the BusyBox implementation of that programming language. + ++config AWX ++ bool "Enable awx (awk web extension)" ++ default n ++ depends on AWK ++ help ++ awx - awk web extension ++ + config FEATURE_AWK_MATH + bool "Enable math functions (requires libm)" + default y +Index: busybox-1.7.2/editors/Kbuild +=================================================================== +--- busybox-1.7.2.orig/editors/Kbuild 2007-10-05 01:39:50.105295361 +0200 ++++ busybox-1.7.2/editors/Kbuild 2007-10-05 01:43:59.627514818 +0200 +@@ -12,3 +12,12 @@ + lib-$(CONFIG_PATCH) += patch.o + lib-$(CONFIG_SED) += sed.o + lib-$(CONFIG_VI) += vi.o ++lib-$(CONFIG_AWX) += awx_parser.o ++ ++editors/awx_parser.c: editors/awx_parser.l editors/awx_parser.h ++ @flex $< ++ @mv lex.yy.c $@ ++ ++editors/awx_parser.o: editors/awx_parser.c FORCE ++ $(call cmd,force_checksrc) ++ $(call if_changed_rule,cc_o_c) +Index: busybox-1.7.2/include/applets.h +=================================================================== +--- busybox-1.7.2.orig/include/applets.h 2007-10-05 01:43:59.203490652 +0200 ++++ busybox-1.7.2/include/applets.h 2007-10-05 01:43:59.647515958 +0200 +@@ -76,6 +76,7 @@ + USE_ARPING(APPLET(arping, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) + USE_ASH(APPLET_NOUSAGE(ash, ash, _BB_DIR_BIN, _BB_SUID_NEVER)) + USE_AWK(APPLET_NOEXEC(awk, awk, _BB_DIR_USR_BIN, _BB_SUID_NEVER, awk)) ++USE_AWX(APPLET_NOUSAGE(awx, awx, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) + USE_BASENAME(APPLET_NOFORK(basename, basename, _BB_DIR_USR_BIN, _BB_SUID_NEVER, basename)) + USE_BBCONFIG(APPLET(bbconfig, _BB_DIR_BIN, _BB_SUID_NEVER)) + //USE_BBSH(APPLET(bbsh, _BB_DIR_BIN, _BB_SUID_NEVER)) +Index: busybox-1.7.2/include/cgi.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ busybox-1.7.2/include/cgi.h 2007-10-05 01:43:59.667517098 +0200 +@@ -0,0 +1,8 @@ ++#ifndef CGI_H ++#define CGI_H ++ ++typedef enum { FORM_VAR, COOKIE_VAR } vartype; ++typedef void (*var_handler) (vartype, char *, char *); ++int cgi_init(var_handler); ++ ++#endif +Index: busybox-1.7.2/libbb/cgi.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ busybox-1.7.2/libbb/cgi.c 2007-10-05 01:43:59.707519378 +0200 +@@ -0,0 +1,457 @@ ++/* -------------------------------------------------------------------------- ++ * functions for processing cgi form data ++ * Copyright (C) 2007 by Felix Fietkau ++ * ++ * parts taken from the core of haserl.cgi - a poor-man's php for embedded/lightweight environments ++ * $Id: haserl.c,v 1.13 2004/11/10 17:59:35 nangel Exp $ ++ * Copyright (c) 2003,2004 Nathan Angelacos (nangel@users.sourceforge.net) ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ * ----- ++ * The x2c() and unescape_url() routines were taken from ++ * http://www.jmarshall.com/easy/cgi/getcgi.c.txt ++ * ++ * The comments in that text file state: ++ * ++ *** Written in 1996 by James Marshall, james@jmarshall.com, except ++ *** that the x2c() and unescape_url() routines were lifted directly ++ *** from NCSA's sample program util.c, packaged with their HTTPD. ++ *** For the latest, see http://www.jmarshall.com/easy/cgi/ ++ * ----- ++ * ++ ------------------------------------------------------------------------- */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#ifndef MAX_UPLOAD_KB ++#define MAX_UPLOAD_KB 2048 ++#endif ++#define TEMPDIR "/tmp" ++ ++static int global_upload_size = 0; ++static int ReadMimeEncodedInput(char *qs); ++static var_handler do_putvar = NULL; ++ ++/* ++ * Convert 2 char hex string into char it represents ++ * (from http://www.jmarshall.com/easy/cgi) ++ */ ++static char x2c (char *what) { ++ char digit; ++ ++ digit=(what[0] >= 'A' ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0')); ++ digit *=16; ++ digit+=(what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0')); ++ ++ return digit; ++} ++ ++/* ++ * unsescape %xx to the characters they represent ++ */ ++ ++static void unescape_url (char *url) { ++ int i,j; ++ ++ for (i=0, j=0; url[j]; ++i, ++j) { ++ if ((url[i] = url[j]) == '%') { ++ url[i] = x2c(&url[j+1]); ++ j+=2; ++ } ++ } ++ url[i]='\0'; ++} ++ ++static inline void put_var(vartype type, char *var) ++{ ++ char *val; ++ ++ if (!do_putvar) ++ return; ++ ++ val = strchr(var, '='); ++ if (!val) ++ return; ++ ++ *val = 0; ++ val++; ++ do_putvar(type, var, val); ++ ++ return; ++} ++ ++ ++/* CookieVars () ++ * if HTTP_COOKIE is passed as an environment variable, ++ * attempt to parse its values into environment variables ++ */ ++static void CookieVars (void) ++{ ++ char *qs; ++ char *token; ++ ++ if (getenv("HTTP_COOKIE") != NULL) ++ qs=strdup(getenv("HTTP_COOKIE")); ++ else ++ return; ++ ++ /** split on; to extract name value pairs */ ++ token=strtok(qs, ";"); ++ while (token) { ++ // skip leading spaces ++ while ( token[0] == ' ' ) ++ token++; ++ ++ put_var(COOKIE_VAR, token); ++ ++ token = strtok(NULL, ";"); ++ } ++ free (qs); ++} ++ ++/* ++ * Read cgi variables from query string, and put in environment ++ */ ++static int ReadCGIQueryString (void) ++{ ++ char *qs; ++ char *token; ++ int i; ++ ++ if (getenv("QUERY_STRING") != NULL) ++ qs=strdup(getenv("QUERY_STRING")); ++ else ++ return 0; ++ ++ /* change plusses into spaces */ ++ for (i=0; qs[i]; i++ ) { if (qs[i] == '+' ) { qs[i] = ' ';} }; ++ ++ /** split on & and ; to extract name value pairs */ ++ ++ token=strtok(qs, "&;"); ++ while (token) { ++ unescape_url(token); ++ put_var(FORM_VAR, token); ++ token=strtok(NULL, "&;"); ++ } ++ free(qs); ++ ++ return 0; ++} ++ ++ ++/* ++ * Read cgi variables from stdin (for POST queries) ++ * (oh... and if its mime-encoded file upload, we save the ++ * file to /tmp; and return the name of the tmp file ++ * the cgi script is responsible for disposing of the tmp file ++ */ ++ ++static int ReadCGIPOSTValues (void) { ++ char *qs; ++ int content_length; ++ int i; ++ char *token; ++ ++ ++ if (getenv("CONTENT_LENGTH") == NULL) ++ return(-1); ++ else ++ content_length = atoi(getenv("CONTENT_LENGTH")); ++ ++ /* protect ourselves from 20GB file uploads */ ++ if (content_length > MAX_UPLOAD_KB * 1024 ) { ++ /* But we need to finish reading the content */ ++ while ( fread( &i, sizeof(int), 1, stdin) == 1 ); ++ return -1; ++ } ++ ++ if (!(qs=malloc(content_length+1))) ++ return -1; ++ ++ /* set the buffer to null, so that a browser messing with less ++ data than content_length won't buffer underrun us */ ++ memset(qs, 0 ,content_length+1); ++ ++ if ((!fread(qs,content_length,1,stdin) && ++ (content_length > 0) ++ && !feof(stdin))) { ++ ++ free(qs); ++ return -1; ++ } ++ ++ if (getenv("CONTENT_TYPE") && (strncasecmp(getenv("CONTENT_TYPE"), "multipart/form-data", 19) == 0)) { ++ /* This is a mime request, we need to go to the mime handler */ ++ i=ReadMimeEncodedInput(qs); ++ free(qs); ++ ++ return i; ++ } ++ ++ /* change plusses into spaces */ ++ for (i=0; qs[i]; i++ ) { if (qs[i] == '+' ) { qs[i] = ' ';} }; ++ ++ /** split on & and ; to extract name value pairs */ ++ token=strtok(qs, "&;"); ++ while (token) { ++ unescape_url(token); ++ put_var(FORM_VAR, token); ++ token=strtok(NULL, "&;"); ++ } ++ ++ free(qs); ++ ++ return 0; ++} ++ ++/* ++ * LineToStr - Scans char and replaces the first "\n" with a "\0"; ++ * If it finds a "\r", it does that to; (fix DOS brokennes) returns ++ * the length of the string; ++ */ ++static int LineToStr (char *string, size_t max) { ++ size_t offset=0; ++ ++ while ((offset < max) && (string[offset] != '\n') && (string[offset] != '\r')) ++ offset++; ++ ++ if (string[offset] == '\r') { ++ string[offset]='\0'; ++ offset++; ++ } ++ if (string[offset] == '\n') { ++ string[offset]='\0'; ++ offset++; ++ } ++ ++ return offset; ++} ++ ++ ++/* ++ * ReadMimeEncodedInput - handles things that are mime encoded ++ * takes a pointer to the input; returns 0 on success ++ */ ++ ++static int ReadMimeEncodedInput(char *qs) ++{ ++ char *boundary; ++ char *ct; ++ int i; ++ int datastart; ++ size_t cl; ++ size_t offset; ++ char *envname; ++ char *filename; ++ char *ptr; ++ int line; ++ char tmpname[] = TEMPDIR "/XXXXXX"; ++ int fd; ++ /* we should only get here if the content type was set. Segfaults happen ++ if Content_Type is null */ ++ ++ if (getenv("CONTENT_LENGTH") == NULL) ++ /* No content length?! */ ++ return(-1); ++ ++ cl=atoi(getenv("CONTENT_LENGTH")); ++ ++ /* we do this 'cause we can't mess with the real env. variable - it would ++ * overwrite the environment - I tried. ++ */ ++ i=strlen(getenv("CONTENT_TYPE"))+1; ++ ct=malloc(i); ++ if (ct) ++ memcpy(ct, getenv("CONTENT_TYPE"), i); ++ else ++ return(-1); ++ ++ i=(int) NULL; ++ if (ct != NULL) { ++ while (i < strlen(ct) && (strncmp("boundary=", &ct[i], 9) != 0)) ++ i++; ++ } ++ if (i == strlen(ct)) { ++ /* no boundary informaiton found */ ++ free(ct); ++ return -1; ++ } ++ boundary=&ct[i+7]; ++ /* add two leading -- to the boundary */ ++ boundary[0]='-'; ++ boundary[1]='-'; ++ ++ /* begin the big loop. Look for: ++ --boundary ++ Content-Disposition: form-data; name="......." ++ .... ++ ++ content ++ --boundary ++ Content-Disposition: form-data; name="....." filename="....." ++ ... ++ ++ --boundary-- ++ eof ++ */ ++ ++ offset=0; ++ while (offset < cl) { ++ /* first look for boundary */ ++ while ((offset < cl) && (memcmp(&qs[offset], boundary, strlen(boundary)))) ++ offset++; ++ ++ /* if we got here and we ran off the end, its an error */ ++ if (offset >= cl) { ++ free(ct); ++ return -1; ++ } ++ ++ /* if the two characters following the boundary are --, */ ++ /* then we are at the end, exit */ ++ if (memcmp(&qs[offset+strlen(boundary)], "--", 2) == 0) { ++ offset+=2; ++ break; ++ } ++ /* find where the offset should be */ ++ line=LineToStr(&qs[offset], cl-offset); ++ offset+=line; ++ ++ /* Now we're going to look for content-disposition */ ++ line=LineToStr(&qs[offset], cl-offset); ++ if (strncasecmp(&qs[offset], "Content-Disposition", 19) != 0) { ++ /* hmm... content disposition was not where we expected it */ ++ free(ct); ++ return -1; ++ } ++ /* Found it, so let's go find "name=" */ ++ if (!(envname=strstr(&qs[offset], "name="))) { ++ /* now name= is missing?! */ ++ free(ct); ++ return(-1); ++ } else ++ envname+=6; ++ ++ /* is there a filename tag? */ ++ if ((filename=strstr(&qs[offset], "filename="))!= NULL) ++ filename+=10; ++ else ++ filename=NULL; ++ ++ /* make envname and filename ASCIIZ */ ++ for (i=0; (envname[i] != '"') && (envname[i] != '\0'); i++); ++ ++ envname[i] = '\0'; ++ if (filename) { ++ for (i=0; (filename[i] != '"') && (filename[i] != '\0'); i++); ++ filename[i] = '\0'; ++ } ++ offset+=line; ++ ++ /* Ok, by some miracle, we have the name; let's skip till we */ ++ /* come to a blank line */ ++ line=LineToStr(&qs[offset], cl-offset); ++ while (strlen(&qs[offset]) > 1) { ++ offset+=line; ++ line=LineToStr(&qs[offset], cl-offset); ++ } ++ offset+=line; ++ datastart=offset; ++ /* And we go back to looking for a boundary */ ++ while ((offset < cl) && (memcmp(&qs[offset], boundary, strlen(boundary)))) ++ offset++; ++ ++ /* strip [cr] lf */ ++ if ((qs[offset-1] == '\n') && (qs[offset-2] == '\r')) ++ offset-=2; ++ else ++ offset-=1; ++ ++ qs[offset]=0; ++ ++ /* ok, at this point, we know where the name is, and we know */ ++ /* where the content is... we have to do one of two things */ ++ /* based on whether its a file or not */ ++ if (filename==NULL) { /* its not a file, so its easy */ ++ /* just jam the content after the name */ ++ memcpy(&envname[strlen(envname)+1], &qs[datastart], offset-datastart+1); ++ envname[strlen(envname)]='='; ++ put_var(FORM_VAR, envname); ++ } else { /* handle the fileupload case */ ++ if (offset-datastart) { /* only if they uploaded */ ++ if ( global_upload_size == 0 ) { ++ return -1; ++ } ++ /* stuff in the filename */ ++ ptr= calloc ( sizeof (char), strlen(envname)+strlen(filename)+2+5 ); ++ sprintf (ptr, "%s_name=%s", envname, filename); ++ put_var(FORM_VAR, ptr); ++ free(ptr); ++ ++ fd=mkstemp(tmpname); ++ ++ if (fd == -1) ++ return(-1); ++ ++ write(fd, &qs[datastart], offset-datastart); ++ close(fd); ++ ptr= calloc (sizeof(char), strlen(envname)+strlen(tmpname)+2); ++ sprintf (ptr, "%s=%s", envname, tmpname); ++ put_var(FORM_VAR, ptr); ++ free(ptr); ++ } ++ } ++ } ++ free(ct); ++ return 0; ++} ++ ++ ++/*------------------------------------------------------------------------- ++ * ++ * Main ++ * ++ *------------------------------------------------------------------------*/ ++ ++int cgi_init(var_handler putvar_handler) ++{ ++ int retval = 0; ++ ++ do_putvar = putvar_handler; ++ ++ /* Read the current environment into our chain */ ++ CookieVars(); ++ if (getenv("REQUEST_METHOD")) { ++ if (strcasecmp(getenv("REQUEST_METHOD"), "GET") == 0) ++ retval = ReadCGIQueryString(); ++ ++ if (strcasecmp(getenv("REQUEST_METHOD"), "POST") == 0) ++ retval = ReadCGIPOSTValues(); ++ } ++ ++ return retval; ++} +Index: busybox-1.7.2/libbb/Kbuild +=================================================================== +--- busybox-1.7.2.orig/libbb/Kbuild 2007-10-05 01:43:59.387501141 +0200 ++++ busybox-1.7.2/libbb/Kbuild 2007-10-05 01:43:59.751521884 +0200 +@@ -99,6 +99,7 @@ + lib-y += xreadlink.o + + # conditionally compiled objects: ++lib-$(CONFIG_AWX) += cgi.o + lib-$(CONFIG_FEATURE_MOUNT_LOOP) += loop.o + lib-$(CONFIG_LOSETUP) += loop.o + lib-$(CONFIG_FEATURE_MTAB_SUPPORT) += mtab.o -- cgit v1.2.3