#include "common.h"
#include "h_script.h"
#include "haserl.h"
#include "h_error.h"
char *g_err_msg[] = {
"",
"Memory Allocation Failure",
"Unable to open file %s",
"%c> before <%c",
"Missing %c>",
"Unknown operation",
"Unable to start subshell",
"Unspecified Error",
};
/*
* abort the program
*/
void
die_with_error (char *msg)
{
fprintf (stderr, "Error: %s\n", msg);
exit (-1);
}
/* print an error message and die. If sp or where are non-null pointers, then
a line is added saying where in the script buffer the error occured. If
there's a request method, then http headers are added.
*/
void
die_with_message (void *sp, char *where, const char *s, ...)
{
#ifndef JUST_LUACSHELL
script_t *script = sp;
#endif
va_list p;
FILE *fo = stderr;
if (global.silent == FALSE)
{
if (getenv ("REQUEST_METHOD"))
{
fo = stdout;
fprintf (fo, "HTTP/1.0 500 Server Error\n"
"Content-Type: text/html\n\n"
"" PACKAGE_NAME
" CGI Error
\n");
}
va_start (p, s);
vfprintf (fo, s, p);
va_end (p);
#ifndef JUST_LUACSHELL
if (where && sp)
{
fprintf (fo, " near line %d of %s\n",
count_lines (script->buf, script->size, where),
script->name);
}
#endif
printf ("\n");
if (getenv ("REQUEST_METHOD"))
fprintf (fo, "\n");
}
exit (-1);
}
haserl-0.9.32/src/haserl_lualib.lua 0000644 0001750 0001750 00000003360 12217130607 016456 0 ustar nangel nangel --[[
/* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
]]--
haserl, FORM, ENV, COOKIE, HASERL, GET, POST = {}, {}, {}, {}, {}, {}, {}
function haserl.setfield (f, v)
-- From programming in Lua 1st Ed.
local t = _G -- start with the table of globals
for w, d in string.gmatch(f, '([%w_%-]+)(.?)') do
if (tonumber(w)) then
w = tonumber(w)
end
if d == '.' then -- not last field?
t[w] = t[w] or {} -- create table if absent
t = t[w] -- get the table
else -- last field
t[w] = v -- do the assignment
end
end
end
function haserl.getfield (f)
local v = _G -- start with the table of globals
for w in string.gmatch(f, '[%w_]+') do
v = v[w]
end
return v
end
function haserl.myputenv(key, value)
-- convert key to dotted form
key = string.gsub(key, '[\\]\\[]', '.' )
key = string.gsub(key, '[\\.]+', '.' )
-- and create a table if necessary
haserl.setfield (key, value)
end
haserl-0.9.32/src/h_bash.c 0000644 0001750 0001750 00000036156 12217130607 014546 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#if HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if HAVE_SIGNAL_H
#include
#endif
#include "common.h"
#include "h_error.h"
#include "h_bash.h"
#include "h_script.h"
#include "haserl.h"
/* Local subshell variables */
static int subshell_pipe[2];
static int subshell_pid;
void
bash_setup (char *shell, list_t * env)
{
int retcode = 0;
int count;
argv_t *argv;
char *av[20];
list_t *next;
if (shell == NULL)
return;
retcode = pipe (&subshell_pipe[PARENT_IN]);
if (retcode == 0)
{
subshell_pid = fork ();
if (subshell_pid == -1)
{
die_with_message (NULL, NULL, g_err_msg[E_SUBSHELL_FAIL]);
}
if (subshell_pid == 0)
{
/* I'm the child, connect stdin to the parent */
dup2 (subshell_pipe[PARENT_IN], STDIN_FILENO);
close (subshell_pipe[PARENT_IN]);
close (subshell_pipe[PARENT_OUT]);
count = argc_argv (shell, &argv, "");
if (count > 19)
{
/* over 20 command line args, silently truncate */
av[19] = "\0";
count = 18;
}
while (count >= 0)
{
av[count] = argv[count].string;
count--;
}
/* populate the environment */
while (env)
{
next = env->next;
putenv (env->buf);
env = next;
}
execv (argv[0].string, av);
free (argv);
/* if we get here, we had a failure */
die_with_message (NULL, NULL, g_err_msg[E_SUBSHELL_FAIL]);
}
else
{
/* I'm parent, move along please */
close (subshell_pipe[PARENT_IN]);
}
}
/* control should get to this point only in the parent.
*/
}
void
bash_destroy (void)
{
int status;
waitpid (subshell_pid, &status, 0);
}
void
bash_exec (buffer_t * buf, char *str)
{
buffer_add (buf, str, strlen (str));
return;
}
/* Run the echo command in a subshell */
void
bash_echo (buffer_t * buf, char *str, size_t len)
{
/* limits.h would tell us the ARG_MAX characters we COULD send to the echo command, but
* we will take the (ancient) POSIX1 standard of 4K, subtract 1K from it and use that
* as the maxmimum. The Linux limit appears to be 128K, so 3K will fit. */
static char echo_start[] = "printf '%s' '";
static char echo_quote[] = "'\\''";
static char echo_end[] = "'\n";
const size_t maxlen = 3096;
size_t pos;
if (len == 0)
return;
pos = 0;
buffer_add (buf, echo_start, strlen (echo_start));
while (pos < len)
{
if (str[pos] == '\'')
buffer_add (buf, echo_quote, strlen (echo_quote));
else
buffer_add (buf, str + pos, 1);
pos++;
if ((pos % maxlen) == 0)
{
buffer_add (buf, echo_end, strlen (echo_end));
buffer_add (buf, echo_start, strlen (echo_start));
}
}
buffer_add (buf, echo_end, strlen (echo_end));
}
/* do an evaluation in a subshell */
void
bash_eval (buffer_t * buf, char *str, size_t len)
{
static char echo_start[] = "echo -n ";
static char echo_end[] = "\n";
if (len == 0)
return;
buffer_add (buf, echo_start, strlen (echo_start));
buffer_add (buf, str, len);
buffer_add (buf, echo_end, strlen (echo_end));
}
#ifdef BASHEXTENSIONS
/* generate an IF statment */
void
bash_if (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for if'\nexit 99\n";
static char if_start[] = "if [[ ";
static char if_end[] = " ]]\nthen\n";
static char ex_start[] = "if ";
static char ex_end[] = "\nthen\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, if_start, strlen (if_start));
buffer_add (buf, str, len);
buffer_add (buf, if_end, strlen (if_end));
}
}
/* generate an ELIF statment */
void
bash_elif (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for elif'\nexit 99\n";
static char elif_start[] = "elif [[ ";
static char elif_end[] = " ]]\nthen\n";
static char ex_start[] = "elif ";
static char ex_end[] = "\nthen\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, elif_start, strlen (elif_start));
buffer_add (buf, str, len);
buffer_add (buf, elif_end, strlen (elif_end));
}
}
/* generate an ELSE statment */
void
bash_else (buffer_t * buf, char *str, size_t len)
{
static char else_start[] = "else";
static char else_start2[] = "else #";
static char else_end[] = "\n";
if (len == 0)
{
buffer_add (buf, else_start, strlen (else_start));
}
else
{
buffer_add (buf, else_start2, strlen (else_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, else_end, strlen (else_end));
}
/* generate a FI statment */
void
bash_endif (buffer_t * buf, char *str, size_t len)
{
static char fi_start[] = "fi";
static char fi_start2[] = "fi #";
static char fi_end[] = "\n";
if (len == 0)
{
buffer_add (buf, fi_start, strlen (fi_start));
}
else
{
buffer_add (buf, fi_start2, strlen (fi_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, fi_end, strlen (fi_end));
}
/* generate a CASE statment */
void
bash_case (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for case'\nexit 99\n";
static char case_start[] = "case ";
static char case_end[] = " in\n";
/*
create a bogus case condition, nul+esc+eof, so nl+;;+nl
can be prepended to each when/otherwise/endcase, which
eliminates the need for ;; or <% ;; %> in the page source
*/
static char case_bogus[] = "\"\\000\\040\\004\") :\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else
{
buffer_add (buf, case_start, strlen (case_start));
buffer_add (buf, str, len);
buffer_add (buf, case_end, strlen (case_end));
buffer_add (buf, case_bogus, strlen (case_bogus));
}
}
/* generate a WHEN statment */
void
bash_when (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for when'\nexit 99\n";
static char when_start[] = "\n;;\n";
static char when_end[] = ")\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else
{
buffer_add (buf, when_start, strlen (when_start));
buffer_add (buf, str, len - 1);
buffer_add (buf, when_end, strlen (when_end));
}
}
/* generate an OTHERWISE statment */
void
bash_otherwise (buffer_t * buf, char *str, size_t len)
{
static char otherwise_start[] = "\n;;\n";
static char otherwise_start1[] = "*)";
static char otherwise_start2[] = "*) #";
static char otherwise_end[] = "\n";
buffer_add (buf, otherwise_start, strlen (otherwise_start));
if (len == 0)
{
buffer_add (buf, otherwise_start1, strlen (otherwise_start1));
}
else
{
buffer_add (buf, otherwise_start2, strlen (otherwise_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, otherwise_end, strlen (otherwise_end));
}
/* generate a ENDCASE statment */
void
bash_endcase (buffer_t * buf, char *str, size_t len)
{
static char endcase_start[] = "\n;;\n";
static char endcase_start1[] = "esac";
static char endcase_start2[] = "esac #";
static char endcase_end[] = "\n";
buffer_add (buf, endcase_start, strlen (endcase_start));
if (len == 0)
{
buffer_add (buf, endcase_start1, strlen (endcase_start1));
}
else
{
buffer_add (buf, endcase_start2, strlen (endcase_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, endcase_end, strlen (endcase_end));
}
/* generate a WHILE statment */
void
bash_while (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for while'\nexit 99\n";
static char while_start[] = "while [[ ";
static char while_end[] = " ]]\ndo\n";
static char ex_start[] = "while ";
static char ex_end[] = "\ndo\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, while_start, strlen (while_start));
buffer_add (buf, str, len);
buffer_add (buf, while_end, strlen (while_end));
}
}
/* generate an ENDWHILE statment */
void
bash_endwhile (buffer_t * buf, char *str, size_t len)
{
static char endwhile_start[] = "done";
static char endwhile_start2[] = "done #";
static char endwhile_end[] = "\n";
if (len == 0)
{
buffer_add (buf, endwhile_start, strlen (endwhile_start));
}
else
{
buffer_add (buf, endwhile_start2, strlen (endwhile_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, endwhile_end, strlen (endwhile_end));
}
/* generate an UNTIL statment */
void
bash_until (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for until'\nexit 99\n";
static char until_start[] = "until [[ ";
static char until_end[] = " ]]\ndo\n";
static char ex_start[] = "until ";
static char ex_end[] = "\ndo\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, until_start, strlen (until_start));
buffer_add (buf, str, len);
buffer_add (buf, until_end, strlen (until_end));
}
}
/* generate an ENDUNTIL statment */
void
bash_enduntil (buffer_t * buf, char *str, size_t len)
{
static char enduntil_start[] = "done";
static char enduntil_start2[] = "done #";
static char enduntil_end[] = "\n";
if (len == 0)
{
buffer_add (buf, enduntil_start, strlen (enduntil_start));
}
else
{
buffer_add (buf, enduntil_start2, strlen (enduntil_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, enduntil_end, strlen (enduntil_end));
}
/* generate a FOR statment */
void
bash_for (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for for'\nexit 99\n";
static char for_start[] = "for ";
static char for_end[] = "\ndo\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else
{
buffer_add (buf, for_start, strlen (for_start));
buffer_add (buf, str, len);
buffer_add (buf, for_end, strlen (for_end));
}
}
/* generate an ENDFOR statment */
void
bash_endfor (buffer_t * buf, char *str, size_t len)
{
static char endfor_start[] = "done";
static char endfor_start2[] = "done #";
static char endfor_end[] = "\n";
if (len == 0)
{
buffer_add (buf, endfor_start, strlen (endfor_start));
}
else
{
buffer_add (buf, endfor_start2, strlen (endfor_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, endfor_end, strlen (endfor_end));
}
/* generate an UNLESS statment */
void
bash_unless (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for unless'\nexit 99\n";
static char unless_start[] = "if [[ ! ( ";
static char unless_end[] = " ) ]]\nthen\n";
static char ex_start[] = "if ! ";
static char ex_end[] = "\nthen\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, unless_start, strlen (unless_start));
buffer_add (buf, str, len);
buffer_add (buf, unless_end, strlen (unless_end));
}
}
/* generate an ELUN statment */
void
bash_elun (buffer_t * buf, char *str, size_t len)
{
static char err_msg[] =
"echo 'error: missing expression for elun'\nexit 99\n";
static char elun_start[] = "elif [[ ! ( ";
static char elun_end[] = " ) ]]\nthen\n";
static char ex_start[] = "elif ! ";
static char ex_end[] = "\nthen\n";
if (len == 0)
{
buffer_add (buf, err_msg, strlen (err_msg));
}
else if (str[0] == '|')
{
str[0] = ' ';
buffer_add (buf, ex_start, strlen (ex_start));
buffer_add (buf, str, len);
buffer_add (buf, ex_end, strlen (ex_end));
}
else
{
buffer_add (buf, elun_start, strlen (elun_start));
buffer_add (buf, str, len);
buffer_add (buf, elun_end, strlen (elun_end));
}
}
/* generate an UNELSE statment */
void
bash_unelse (buffer_t * buf, char *str, size_t len)
{
static char unelse_start[] = "else";
static char unelse_start2[] = "else #";
static char unelse_end[] = "\n";
if (len == 0)
{
buffer_add (buf, unelse_start, strlen (unelse_start));
}
else
{
buffer_add (buf, unelse_start2, strlen (unelse_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, unelse_end, strlen (unelse_end));
}
/* generate a ENDUNLESS statment */
void
bash_endunless (buffer_t * buf, char *str, size_t len)
{
static char endunless_start[] = "fi";
static char endunless_start2[] = "fi #";
static char endunless_end[] = "\n";
if (len == 0)
{
buffer_add (buf, endunless_start, strlen (endunless_start));
}
else
{
buffer_add (buf, endunless_start2, strlen (endunless_start2));
buffer_add (buf, str, len);
}
buffer_add (buf, endunless_end, strlen (endunless_end));
}
#endif
void
bash_doscript (buffer_t * script, char *name)
{
static char postfix[] = "\nexit\n";
/* dump the script to the subshell */
write (subshell_pipe[PARENT_OUT], script->data, script->ptr - script->data);
/* write the postfix */
write (subshell_pipe[PARENT_OUT], postfix, strlen (postfix));
return;
}
haserl-0.9.32/src/h_lua.c 0000644 0001750 0001750 00000007741 12217130607 014410 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#if HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "common.h"
#include "h_error.h"
#include "h_lua.h"
#include "h_script.h"
#include "haserl.h"
extern lua_State *lua_vm;
/* attempts to open a file, tokenize and then process it as a haserl script */
int
h_lua_loadfile (lua_State * L)
{
script_t *scriptchain;
token_t *tokenchain;
buffer_t script_text;
int status;
/* get the filename */
const char *filename = luaL_checkstring (L, 1);
scriptchain = load_script ((char *) filename, NULL);
tokenchain = build_token_list (scriptchain, NULL);
preprocess_token_list (tokenchain);
process_token_list (&script_text, tokenchain);
free_token_list (tokenchain);
free_script_list (scriptchain);
/* script_text has the include file */
status = luaL_loadbuffer (L, (char *) script_text.data,
script_text.ptr - script_text.data, filename);
buffer_destroy (&script_text);
if (status)
{
lua_error (L);
}
return (1); /* we return one value, the buffer, as a function */
}
void
lua_exec (buffer_t * buf, char *str)
{
buffer_add (buf, str, strlen (str));
}
void
lua_doscript (buffer_t * script, char *name)
{
int status;
/* force the string to be null terminated */
buffer_add (script, "\0", 1);
status = luaL_loadbuffer (lua_vm, (char *) script->data,
strlen ((char *) script->data), name) ||
lua_pcall (lua_vm, 0, LUA_MULTRET, 0);
if (status && !lua_isnil (lua_vm, -1))
{
const char *msg = lua_tostring (lua_vm, -1);
if (msg == NULL)
msg = "(error object is not a string)";
die_with_message (NULL, NULL, msg);
}
}
/* Run the echo command in a subshell */
void
lua_echo (buffer_t * buf, char *str, size_t len)
{
static char echo_start[] = " io.write(";
char quote[200] = "]=]"; /* 197 nested comments is a problem */
if (len == 0)
return;
/* figure out if the string uses ]] ]=] ]==] etc in it */
while ((strstr (str, quote)) && (strlen (quote) < 198))
{
memmove (quote + strlen (quote) - 1, quote + strlen (quote) - 2, 3);
}
/* As of 5.1, nested comments are depreciated... sigh */
quote[0] = '[';
quote[strlen (quote) - 1] = quote[0];
while ((strstr (str, quote)) && (strlen (quote) < 198))
{
memmove (quote + strlen (quote) - 1, quote + strlen (quote) - 2, 3);
}
buffer_add (buf, echo_start, strlen (echo_start));
buffer_add (buf, quote, strlen (quote));
buffer_add (buf, str, len);
quote[0] = ']';
quote[strlen (quote) - 1] = quote[0];
buffer_add (buf, quote, strlen (quote));
buffer_add (buf, ")\n", 2);
}
/* do an evaluation */
void
lua_eval (buffer_t * buf, char *str, size_t len)
{
static char start[] = " io.write(tostring(";
static char end[] = "))\n";
if (len == 0)
return;
buffer_add (buf, start, strlen (start));
buffer_add (buf, str, len);
buffer_add (buf, end, strlen (end));
}
haserl-0.9.32/src/config.h.in 0000644 0001750 0001750 00000005014 12217132623 015166 0 ustar nangel nangel /* src/config.h.in. Generated from configure.ac by autoheader. */
/* Include bash extensions */
#undef BASHEXTENSIONS
/* Define to 1 if you have the header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the `memset' function. */
#undef HAVE_MEMSET
/* Define to 1 if you have the `putenv' function. */
#undef HAVE_PUTENV
/* Define to 1 if you have the header file. */
#undef HAVE_SIGNAL_H
/* Define to 1 if you have the header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the `strcasecmp' function. */
#undef HAVE_STRCASECMP
/* Define to 1 if you have the `strdup' function. */
#undef HAVE_STRDUP
/* Define to 1 if you have the header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the `strncasecmp' function. */
#undef HAVE_STRNCASECMP
/* Define to 1 if you have the `strstr' function. */
#undef HAVE_STRSTR
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the header file. */
#undef HAVE_UNISTD_H
/* Include Bash/Linux shell */
#undef INCLUDE_BASHSHELL
/* Include shell for precompiled Haserl/Lua */
#undef INCLUDE_LUACSHELL
/* Include ordinary Lua shell */
#undef INCLUDE_LUASHELL
/* Include just the compiled Lua shell */
#undef JUST_LUACSHELL
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the home page for this package. */
#undef PACKAGE_URL
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* the subshell to start up */
#undef SUBSHELL_CMD
/* Lua enabled */
#undef USE_LUA
/* Version number of package */
#undef VERSION
/* Enable GNU Extensions */
#undef _GNU_SOURCE
/* Define to empty if `const' does not conform to ANSI C. */
#undef const
/* Define to `unsigned int' if does not define. */
#undef size_t
haserl-0.9.32/src/h_lua.h 0000644 0001750 0001750 00000002235 12217130607 014406 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#ifndef H_LUA_H
#define H_LUA_H 1
#include
void lua_exec(buffer_t *buf, char *str);
void lua_echo(buffer_t *buf, char *str, size_t len);
void lua_eval(buffer_t *buf, char *str, size_t len);
void lua_doscript(buffer_t *script, char *name);
int h_lua_loadfile(lua_State *L);
#endif
haserl-0.9.32/src/h_error.h 0000644 0001750 0001750 00000002440 12217130607 014754 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#ifndef H_ERROR_H
#define H_ERROR_H 1
enum error_types { E_NO_ERROR, E_MALLOC_FAIL, E_FILE_OPEN_FAIL,
E_END_BEFORE_BEGIN, E_NO_END_MARKER ,
E_NO_OP, E_SUBSHELL_FAIL, E_WHATEVER };
extern char *g_err_msg[];
/* h_error.c */
void die_with_error(char *msg);
void die_with_syntax(void *script, char *where, int error);
void
die_with_message ( void *sp, char *where, const char *s, ...);
#endif /* !H_ERROR_H */
haserl-0.9.32/src/h_script.h 0000644 0001750 0001750 00000004523 12217130607 015133 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#ifndef H_SCRIPT_H
#define H_SCRIPT_H 1
/* Everything we care to know about a script */
typedef struct {
char *name; /* pointer to name of script */
int size; /* size of script in bytes */
uid_t uid; /* user owner */
gid_t gid; /* group owner */
char *buf; /* pointer to malloc'ed buffer */
size_t curpos; /* current position in buffer */
void *next; /* next script in our chain */
} script_t;
/* tag types */
#ifdef BASHEXTENSIONS
enum tag_t { HTML, RUN, INCLUDE, EVAL, COMMENT, IF, ELIF, ELSE, ENDIF, CASE, WHEN, OTHERWISE, ENDCASE, WHILE, ENDWHILE, UNTIL, ENDUNTIL, FOR, ENDFOR, UNLESS, ELUN, UNELSE, ENDUNLESS, NOOP };
#else
enum tag_t { HTML, RUN, INCLUDE, EVAL, COMMENT, NOOP };
#endif
/* token structure */
typedef struct {
script_t *script; /* the parent script */
enum tag_t tag; /* the token type */
size_t len; /* length of token */
char *buf; /* pointer to start of token */
void *next; /* the next token in the chain */
} token_t;
/* h_script.c */
script_t *load_script(char *filename, script_t *scriptlist);
void free_script_list(script_t *script);
token_t *push_token_on_list(token_t *tokenlist, script_t *scriptbuf, char *start, size_t len);
void free_token_list(token_t *tokenlist);
#ifndef JUST_LUACSHELL
token_t *build_token_list(script_t *scriptbuf, token_t *tokenlist);
void preprocess_token_list(token_t *tokenlist);
token_t *process_token_list(buffer_t *buf, token_t *tokenlist);
#endif
#endif /* !H_SCRIPT_H */
haserl-0.9.32/src/sliding_buffer.c 0000644 0001750 0001750 00000010113 12217130607 016265 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#if HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include "sliding_buffer.h"
/*
* initialize a sliding buffer structure
*/
int
s_buffer_init (sliding_buffer_t * sbuf, int size)
{
sbuf->maxsize = size;
sbuf->buf = malloc (sbuf->maxsize);
/* reduce maxsize by one, so that you can add a NULL to the end of any
returned token and not have a memory overwrite */
sbuf->maxsize -= 1;
sbuf->fh = 0; /* use stdin by default */
sbuf->eof = 0;
sbuf->len = 0;
sbuf->ptr = sbuf->buf;
sbuf->bufsize = 0;
sbuf->maxread = 0;
sbuf->nrread = 0;
return (sbuf->buf != NULL); /* return true if the alloc succeeded */
}
/*
* destroy a sliding buffer structure
*/
void
s_buffer_destroy (sliding_buffer_t * sbuf)
{
free (sbuf->buf);
}
/*
* read the next segment from a sliding buffer. returns !=0 if the
* segment ends at a matchstr token, or if we are at the end of the string
* returns 0 if the segment does not end
*/
int
s_buffer_read (sliding_buffer_t * sbuf, char *matchstr)
{
int len, pos;
int r;
/*
* if eof and ptr ran off the buffer, then we are done
*/
if ((sbuf->eof) && (sbuf->ptr > sbuf->buf))
{
return 0;
}
/*
* if need to fill the buffer, do so
*/
if ((sbuf->bufsize == 0) ||
(sbuf->ptr >= (sbuf->buf + sbuf->bufsize - strlen (matchstr))))
{
len = sbuf->bufsize - (sbuf->ptr - sbuf->buf);
if (len)
{
memmove (sbuf->buf, sbuf->ptr, len);
}
sbuf->ptr = sbuf->buf;
sbuf->bufsize = len;
/* if the filedescriptor is invalid, we are obviously
* at an end of file condition.
*/
if (fcntl (sbuf->fh, F_GETFL) == -1)
{
r = 0;
}
else
{
size_t n = sbuf->maxsize - len;
if (sbuf->maxread && sbuf->maxread < sbuf->nrread + n)
n = sbuf->maxread - sbuf->nrread;
r = read (sbuf->fh, sbuf->buf + len, n);
}
/*
* only report eof when we've done a read of 0.
*/
if (r == 0 || (r < 0 && errno != EINTR))
{
sbuf->eof = -1;
}
else
{
sbuf->bufsize += (r > 0) ? r : 0;
sbuf->nrread += (r > 0) ? r : 0;
}
}
/*
* look for the matchstr
*/
pos = 0;
len = sbuf->bufsize - (int) (sbuf->ptr - sbuf->buf) - strlen (matchstr);
while (memcmp (matchstr, sbuf->ptr + pos, strlen (matchstr)) && (pos < len))
{
pos++;
}
/*
* if we found it
*/
if (pos < len)
{
sbuf->len = pos;
sbuf->segment = sbuf->ptr;
sbuf->ptr = sbuf->segment + pos + strlen (matchstr);
return -1;
}
if (sbuf->eof)
{
len += strlen (matchstr);
}
/*
* ran off the end, didn't find the matchstr
*/
sbuf->segment = sbuf->ptr;
sbuf->len = len;
sbuf->ptr += sbuf->len;
return (sbuf->eof) ? (-1) : (0);
}
#ifdef TEST_FRAMEWORK
main ()
{
int x;
sliding_buffer_t sb;
char foo[200];
s_buffer_init (&sb, 32);
do
{
x = s_buffer_read (&sb, "&");
sprintf (foo, "%03d- %03d - %03d", x, sb.eof, sb.len);
write (1, foo, strlen (foo));
write (1, sb.segment, sb.len);
write (1, "\n", 1);
}
while ((!sb.eof));
s_buffer_destroy (&sb);
}
#endif
haserl-0.9.32/src/haserl.h 0000644 0001750 0001750 00000010505 12217130607 014573 0 ustar nangel nangel /* --------------------------------------------------------------------------
* Copyright 2003-2011 (inclusive) Nathan Angelacos
* (nangel@users.sourceforge.net)
*
* This file is part of haserl.
*
* Haserl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation.
*
* Haserl 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 haserl. If not, see .
*
* ------------------------------------------------------------------------ */
#ifndef _HASERL_H
#define _HASERL_H 1
/* Just a silly construct to contain global variables */
typedef struct
{
unsigned long uploadkb; /* how big an upload do we allow (0 for none)*/
char *shell; /* The shell we use */
char *uploaddir; /* where we upload to */
char *uploadhandler; /* a handler for uploads */
char *var_prefix; /* what name we give to FORM variables */
char *get_prefix; /* what name we give to POST variables */
char *post_prefix; /* what name we give to POST variables */
char *cookie_prefix; /* what name we give to COOKIE variables */
char *nul_prefix; /* what name we give to environment variables*/
char *haserl_prefix; /* what name we give to HASERL variables */
token_t *uploadlist; /* a linked list of pathspecs */
int debug; /* true if in "debug" mode */
int acceptall; /* true if we'll accept POST data on
GETs and vice versa */
int silent; /* true if we never print errors */
} haserl_t;
extern haserl_t global;
char x2c(char *what);
void unescape_url(char *url);
void *xmalloc (size_t size);
void *xrealloc (void *buf, size_t size);
list_t *myputenv(list_t *cur, char *str, char *prefix);
void free_list_chain ( list_t *);
void readenv(list_t *env);
void CookieVars(list_t *env);
void sessionid(list_t *env);
list_t *wcversion(list_t *env);
void haserlflags(list_t *env);
int ReadCGIQueryString(list_t *env);
int ReadCGIPOSTValues(list_t *env);
int LineToStr(char *string, size_t max);
int ReadMimeEncodedInput(list_t *env);
void PrintParseError(char *error, int linenum);
int parseCommandLine(int argc, char *argv[]);
int BecomeUser(uid_t uid, gid_t gid);
void assignGlobalStartupValues(void);
void unlink_uploadlist (void);
int main(int argc, char *argv[]);
extern void (*shell_exec)(buffer_t *buf, char *str);
extern void (*shell_echo)(buffer_t *buf, char *str, size_t len);
extern void (*shell_eval)(buffer_t *buf, char *str, size_t len);
extern void (*shell_setup)( char *, list_t *);
extern void (*shell_doscript)( buffer_t *, char *);
extern void (*shell_destroy) (void);
#ifdef BASHEXTENSIONS
extern void (*shell_if)(buffer_t *buf, char *str, size_t len);
extern void (*shell_elif)(buffer_t *buf, char *str, size_t len);
extern void (*shell_else)(buffer_t *buf, char *str, size_t len);
extern void (*shell_endif)(buffer_t *buf, char *str, size_t len);
extern void (*shell_case)(buffer_t *buf, char *str, size_t len);
extern void (*shell_when)(buffer_t *buf, char *str, size_t len);
extern void (*shell_otherwise)(buffer_t *buf, char *str, size_t len);
extern void (*shell_endcase)(buffer_t *buf, char *str, size_t len);
extern void (*shell_while)(buffer_t *buf, char *str, size_t len);
extern void (*shell_endwhile)(buffer_t *buf, char *str, size_t len);
extern void (*shell_until)(buffer_t *buf, char *str, size_t len);
extern void (*shell_enduntil)(buffer_t *buf, char *str, size_t len);
extern void (*shell_for)(buffer_t *buf, char *str, size_t len);
extern void (*shell_endfor)(buffer_t *buf, char *str, size_t len);
extern void (*shell_unless)(buffer_t *buf, char *str, size_t len);
extern void (*shell_elun)(buffer_t *buf, char *str, size_t len);
extern void (*shell_unelse)(buffer_t *buf, char *str, size_t len);
extern void (*shell_endunless)(buffer_t *buf, char *str, size_t len);
#endif
#endif /* !_HASERL_H */