#include "script-runner.h"

/**

* skip_program_name

*

* Given command line p skips over the program name and

* returns pointer to the first argument in p

*/

const TCHAR* skip_program_name(const TCHAR* p)

{

int dq = 0;

while (*p > _T(' ') || (*p && dq)) {

if (*p == _T('"'))

dq = !dq;

++p;

}

while (*p && *p <= _T(' '))

++p;

return p;

}

/**

* skip_dirname

*

* Given path p skips over dirname and

* returns pointer to filename in p

*/

const TCHAR* skip_dirname(const TCHAR* p)

{

const TCHAR* p1 = _tcsrchr(p, _T('\\'));

const TCHAR* p2 = _tcsrchr(p, _T('/'));

const TCHAR* pend = p1 > p2 ? p1 : p2;

if (!pend)

return p; /* no dirname */

while (*pend && *pend == _T('\\') || *pend == _T('/'))

++pend;

return pend; /* pend points to the filename */

}

/**

* get_file_ext

* Given path p skips over filename and

* returns pointer to file extension

*/

const TCHAR* get_file_ext(const TCHAR* p)

{

const TCHAR* pext;

p = skip_dirname(p);

pext = _tcsrchr(p, _T('.'));

if (!pext)

return p + _tcslen(p); /* no extension*/

return pext;

}

/**

* get_module_filename

*

* returns filename of module hInstance

* returned string must be freed using free()

*/

TCHAR* get_module_filename(HINSTANCE hInstance)

{

TCHAR buffer[MAX_PATH+1];

buffer[0] = _T('\0');

GetModuleFileName(hInstance, buffer, MAX_PATH);

buffer[MAX_PATH] = _T('\0');

return _tcsdup(buffer);

}

/**

* dirname

*

* returns dirname of path p

* returned string must be freed using free()

*/

TCHAR* dirname(const TCHAR* p)

{

TCHAR* r;

const TCHAR* p1 = _tcsrchr(p, _T('\\'));

const TCHAR* p2 = _tcsrchr(p, _T('/'));

const TCHAR* pend = p1 > p2 ? p1 : p2;

if (!pend)

return _tcsdup(_T(""));

r = malloc((pend - p + 1) * sizeof(TCHAR));

memcpy(r, p, (pend - p) * sizeof(TCHAR));

r[pend - p] = '\0';

return r;

}

/**

* join

*

* returns join of paths p1 and p2

* returned string must be freed using free()

*/

TCHAR* join(const TCHAR* p1, const TCHAR* p2)

{

TCHAR* r;

int p1len, p2len;

const TCHAR* p1end = p1 + _tcslen(p1);

const TCHAR* p2end = p2 + _tcslen(p2);

if (p1 == p1end)

return _tcsdup(p2);

if (p2 == p2end)

return _tcsdup(p1);

while (p1 != p1end && (p1end[-1] == _T('\\') || p1end[-1] == _T('/')))

--p1end;

while (p2 != p2end && (p2[0] == _T('\\') || p2[0] == _T('/')))

++p2;

p1len = p1end - p1;

p2len = p2end - p2;

r = malloc((p1len + 1 + p2len + 1) * sizeof(TCHAR));

memcpy(r, p1, p1len * sizeof(TCHAR));

r[p1len] = _T('\\');

memcpy(r + p1len + 1, p2, p2len * sizeof(TCHAR));

r[p1len + 1 + p2len] = _T('\0');

return r;

}

/**

* HasConsole

* Taken from Tcl sources

*/

static BOOL HasConsole()

{

HANDLE handle;

handle = CreateFile(_T("CONOUT$"), GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

if (handle != INVALID_HANDLE_VALUE) {

CloseHandle(handle);

return TRUE;

} else {

return FALSE;

}

}

/**

* run

* Based on Tcl sources

*

* runs command specified in command

* returns 0 on success, non-zero on failure

* on success orc will be filled with exit-code of the process

*/

static int run(TCHAR* command, int* orc)

{

HANDLE hProcess;

STARTUPINFO si;

PROCESS_INFORMATION pi;

DWORD status;

hProcess = GetCurrentProcess();

memset(&si, 0, sizeof(si));

si.cb = sizeof(si);

si.dwFlags = STARTF_USESTDHANDLES;

si.hStdInput = INVALID_HANDLE_VALUE;

si.hStdOutput = INVALID_HANDLE_VALUE;

si.hStdError = INVALID_HANDLE_VALUE;

DuplicateHandle(hProcess, GetStdHandle(STD_INPUT_HANDLE), hProcess, &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);

DuplicateHandle(hProcess, GetStdHandle(STD_OUTPUT_HANDLE), hProcess, &si.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);

DuplicateHandle(hProcess, GetStdHandle(STD_ERROR_HANDLE), hProcess, &si.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS);

if (!CreateProcess(NULL, command, NULL, NULL, TRUE, HasConsole() ? 0 : DETACHED_PROCESS, NULL, NULL, &si, &pi))

return -1;

WaitForInputIdle(pi.hProcess, 5000);

CloseHandle(pi.hThread);

if (si.hStdInput != INVALID_HANDLE_VALUE) CloseHandle(si.hStdInput);

if (si.hStdOutput != INVALID_HANDLE_VALUE) CloseHandle(si.hStdOutput);

if (si.hStdError != INVALID_HANDLE_VALUE) CloseHandle(si.hStdError);

WaitForSingleObject(pi.hProcess, INFINITE);

if (!GetExitCodeProcess(pi.hProcess, &status)) {

CloseHandle(pi.hProcess);

return -1;

}

CloseHandle(pi.hProcess);

if (orc)

*orc = (int)status;

return 0;

}

/**

* try_script

*

* given script name and arguments args

* tries to run it using available runners

* returns 0 on success, non-zero on failure

* on success orc will be filled with exit-code of the process

*/

static int try_script(const TCHAR* name, const TCHAR* args, int* orc)

{

int rc = -1;

DWORD attr;

const TCHAR* p;

int needquotes = 0;

TCHAR* quotedname = NULL;

size_t maxlen = 0;

TCHAR* cmdline;

const TCHAR** runner;

attr = GetFileAttributes(name);

if (attr == INVALID_FILE_ATTRIBUTES ||

attr & FILE_ATTRIBUTE_DIRECTORY)

return -1; /* we can't execute non-existent file or directory */

for (p = name; *p; ++p) {

if (*p <= _T(' ') || *p == '&') {

needquotes = 1;

break;

}

}

if (needquotes) {

/* since name is a filename quoting is generally simple */

quotedname = malloc((1 + _tcslen(name) + 2) * sizeof(TCHAR));

_stprintf(quotedname, _T("\"%s\""), name);

}

/* find maximum length of runner names */

for (runner = config.runners; *runner; ++runner) {

size_t len = _tcslen(*runner);

if (maxlen < len)

maxlen = len;

}

cmdline = malloc((maxlen +

1 + _tcslen(quotedname ? quotedname : name) +

1 + _tcslen(args) + 1) * sizeof(TCHAR));

/* try executing every runner in order */

for (runner = config.runners; *runner; ++runner) {

_stprintf(cmdline, _T("%s %s %s"), *runner, quotedname ? quotedname : name, args);

if (!run(cmdline, orc)) {

rc = 0;

break;

}

}

if (cmdline)

free(cmdline);

if (quotedname)

free(quotedname);

return rc;

}

static BOOL WINAPI CtrlHandler(DWORD dwCtrlType)

{

switch(dwCtrlType)

{

/* We want to give children a chance at handling these

* without their parent sudenly disappearing (default

* handler would kill us even if child handles them),

* so when Ctrl+C or Ctrl+Break is pressed we return

* TRUE to ignore them until our child exits.

*

* If we don't do this then our parent (typically

* cmd.exe) and our child would start fighting for

* control over input/output leading to very amusing

* results. :)

*/

case CTRL_C_EVENT:

case CTRL_BREAK_EVENT:

return TRUE;

default:

return FALSE;

}

}

int main(int argc, char** argv)

{

int rc = 127;

HINSTANCE hInstance = GetModuleHandle(NULL);

const TCHAR* args = skip_program_name(GetCommandLine());

TCHAR* modulename = get_module_filename(hInstance);

TCHAR* moduleext = (TCHAR*)get_file_ext(modulename);

size_t maxlen = 0;

const TCHAR** ext;

TCHAR* name;

TCHAR* nameext;

int found = 0;

for (ext = config.extensions; *ext; ++ext) {

size_t len = _tcslen(*ext);

if (maxlen < len)

maxlen = len;

}

name = malloc(((moduleext - modulename) + maxlen + 1) * sizeof(TCHAR));

_tcsncpy(name, modulename, moduleext - modulename);

nameext = name + (moduleext - modulename);

SetConsoleCtrlHandler(&CtrlHandler, TRUE); /* let children handle Ctrl+C */

for (ext = config.extensions; *ext; ++ext) {

_tcscpy(nameext, *ext);

if (!try_script(name, args, &rc)) {

found = 1;

break;

}

}

SetConsoleCtrlHandler(&CtrlHandler, FALSE); /* restore default behavior */

if (!found)

_ftprintf(stderr, _T("Error: stub could not find or execute the script file\n"));

free(name);

free(modulename);

return rc;

}