/*
Copyright (C) 2004-2008 Joshua J Baker
See the file COPYING for copying permission.
*/
#define CCOD_MAJOR_VERSION 1
#define CCOD_MINOR_VERSION 2
#define CCOD_MICRO_VERSION 9
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <dirent.h>
#include <sys/stat.h>
#include <ctype.h>
#if defined(__STRICT_ANSI__)
#undef __STRICT_ANSI__
#endif
#if defined(WIN32) || defined(_WIN32)
#include <fcntl.h>
#include <io.h>
#include <process.h>
#endif
#if defined(WIN32) || defined(_WIN32)
#include <windows.h>
#define mkdir2(name) mkdir(name)
#define setenv(name,value,overwrite) SetEnvironmentVariable((LPCTSTR)name,(LPCTSTR)value)
#else
#define mkdir2(name) mkdir(name,0755)
#endif
#define mkstr(s) # s
char version[512];
char verstl[100];
unsigned char cgiinc[] = {0};
unsigned char cgiheader[] = {0};
unsigned char cgimain[] = {0};
//#include "cgiinc.bin"
//#include "cgiheader.bin"
//#include "cgimain.bin"
/* Some cksum functions */
static unsigned long cksum(const unsigned char *path);
static unsigned long cksumbin(const unsigned char *bin, size_t n);
static unsigned long cksumpath(const char *path);
//static int process_ssi_file(const char *pathin, const char *pathout);
static int process_ssi_stream(const char *path, FILE *fin, FILE *fout, unsigned long *addcksum);
int systemc(const char *command);
int argc; /* The original arguments */
char **argv; /* passed from the command line */
/* String Allocator. */
char *stralloc = 0;
/* Global variables. */
char *cgi_object = 0; /* String - the cgi object ready for linking. */
char *cgi_dll = 0;
char *cgi_shared = 0;
char *cgi_main = 0;
char *cgi_object_directory = 0;
char *orgsource = 0; /* String - the original source path. */
char *source = 0; /* String - the path of the source file. */
char *sourcebase = 0; /* String - the base name of thesource path. */
char *sourcefull = 0; /* String - the full path of the source file. */
char *orgsourcepath = 0;/* String - the parent path of sourefull. */
char *orgworkpath = 0; /* String - the working directory. */
char *tmp_source = 0; /* String - the temporary source file. */
char *username = 0; /* String - the user name. */
char *homedir = 0; /* String - the home directory of the user. */
char *pardir = 0; /* String - the parent directory path. */
char *directory = 0; /* String - contains the directory of the program. */
char *tempdir = 0; /* String - the temp directory of the user. */
char *options = 0; /* String - options passed to the cc command. */
char *use_cc = 0; /* String - containing the cc command. */
char *std = 0; /* String - c standard to use. */
char *workdir = 0; /* String - the working directory of the program. */
char *progpath = 0; /* String - the path of the compiled program. */
char *progargs = 0; /* String - the args of the executed program. */
char *shellcmd = 0; /* String - the shell command that will execute. */
char *cc_cmd= 0; /* String - the cc command. */
int sessions = 0; /* Boolean - is cgi sessions enabled? */
int cgi = 0; /* Boolean - include cgi functions. */
int gui = 0; /* Boolean - include gui stuff. */
int inline_errors = 0; /* Boolean - does the errors appear through stdout. */
int shell_script = 0; /* Boolean - is this a shell script. */
int script = 0; /* Boolean - is this a script interface. */
int clean = 0; /* Boolean - does the program need cleaning? */
int execute = 1; /* Boolean - is the program going to be executed? */
int argidx = 0; /* Integer - source file argument index. */
int fretval = 0; /* Integer - the final return value. */
int ignmaxerr = 0; /* Integer - ignore the max data error. */
int objc = 0; /* Boolean - objective-c source. */
unsigned long
max_upload_size = 0; /* UInt - Max bytes allowed to be uploaded. */
unsigned long
sourcesum = 0; /* ULong - the cksum of the source file data. */
unsigned long
pathsum = 0; /* ULong - the cksum of the path file data. */
unsigned long
compilesum = 0; /* ULong - the compile cksum of the cc options. */
static void print_error(const char *errstr);
/*
oom();
Prints an Out of Memory error to the stderr and exits unsuccessfully.
*/
#define oom() { oom_(__LINE__); }
static void
oom_(int l)
{
print_error("error: out of memory.\n");
exit(-1);
}
/*
strset(String, Value)
Sets a string's value. Auto handles the memory.
*/
#define strset(str,val) ((str?free(str):0),(((str=(char*)malloc(strlen(val)+1))&&strcpy(str,val))?str:0))
#if defined(_WIN32) || defined(WIN32)
int system2file(const char *command, const char *path, int std_output, int std_error)
{
DWORD retval;
STARTUPINFO si;
PROCESS_INFORMATION pi;
HANDLE File = 0;
SECURITY_ATTRIBUTES sa;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
if (path)
{
File = CreateFile(path,
GENERIC_WRITE,
0,
&sa,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (File == INVALID_HANDLE_VALUE)
{
print_error("error: system2file failed (%s).\n");
exit(-1);
}
}
//printf("Content-Type: text/html\n\n");
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.hStdOutput = std_output?File:GetStdHandle(STD_OUTPUT_HANDLE);
si.hStdError = std_error?File:GetStdHandle(STD_ERROR_HANDLE);
ZeroMemory(&pi, sizeof(pi));
if (!CreateProcess( NULL, // No module name (use command line).
(LPTSTR)command, // Command line.
NULL, // Process handle not inheritable.
NULL, // Thread handle not inheritable.
TRUE, // Set handle inheritance to FALSE.
0, // No creation flags.
NULL, // Use parent's environment block.
NULL, // Use parent's starting directory.
&si, // Pointer to STARTUPINFO structure.
&pi) // Pointer to PROCESS_INFORMATION structure.
)
{
char errstr[] = "error: could not start process ";
char *cpath = 0;
char *p;
DWORD written;
TCHAR szBuf[150];
LPVOID lpMsgBuf;
DWORD dw = GetLastError();
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
wsprintf(szBuf, "failed with error %d: %s\n", dw, lpMsgBuf);
strset(cpath, command);
p = cpath;
if (*p=='\"')
{
p++;
while (*p)
{
if (*p=='\"') *p = 0;
p++;
}
p = cpath+1;
}
else
{
while (*p)
{
if (isspace(*p)) *p = 0;
p++;
}
p = cpath;
}
WriteFile(File, errstr, strlen(errstr), &written, 0);
WriteFile(File, "[", 1, &written, 0);
WriteFile(File, p, strlen(p), &written, 0);
WriteFile(File, "]", 1, &written, 0);
WriteFile(File, "\n", 1, &written, 0);
WriteFile(File, szBuf, strlen(szBuf), &written, 0);
free(cpath);
LocalFree(lpMsgBuf);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
CloseHandle(File);
return -1;
}
WaitForSingleObject(pi.hProcess, INFINITE);
GetExitCodeProcess (pi.hProcess, &retval);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
CloseHandle(File);
return (int)retval;
}
#else
int
system2file(const char *command, const char *path, int std_output, int std_error)
{
char *ncommand;
int retval;
ncommand = (char*)malloc(strlen(command)+strlen(path)+50);
if (!ncommand) oom();
sprintf(ncommand, "%s &> \"%s\"", command, path);
retval = system(ncommand);
free(ncommand);
return retval;
}
#endif
/*
append_cc_options(char *noption)
Appends the cc command options.
*/
static void
append_cc_options(char *noption)
{
stralloc = (char*)realloc(options, strlen(options)+strlen(noption)+10);
if (!stralloc) oom();
options = stralloc;
strcat(options, " ");
strcat(options, noption);
strcat(options, " ");
}
static void
append_cc_options_quotes(char *noption)
{
stralloc = (char*)realloc(options, strlen(options)+strlen(noption)+10);
if (!stralloc) oom();
options = stralloc;
strcat(options, " \"");
strcat(options, noption);
strcat(options, "\" ");
}
/*
directory_exists(const char *path)
Return 1 if the path is a directory or 0 if not.
*/
static int
directory_exists(const char *path)
{
DIR *d;
d = opendir(path);
if (!d) return 0;
closedir(d);
return 1;
}
/*
store_tempdir()
Gets the TEMP/TMP environment variable and stores it.
*/
static void
store_tempdir()
{
char *temp;
char *p;
temp = (char*)getenv("TEMP");
if (!temp) temp = (char*)getenv("TMP");
if (!temp)
{
if (directory_exists("/var/tmp"))
{
strset(tempdir, "/var/tmp");
}
else if (directory_exists("/usr/tmp"))
{
strset(tempdir, "/usr/tmp");
}
else if (directory_exists("/tmp"))
{
strset(tempdir, "/tmp");
}
else
{
strset(tempdir, "");
}
}
else
{
strset(tempdir, temp);
}
p = tempdir;
while (*p)
{
if (*p=='\\') *p = '/';
p++;
}
}
/*
store_homedir()
Gets the HOME environment variable and stores it.
*/
static void
store_homedir()
{
char *home;
FILE *fpasswd;
char *line, *linealloc, *useritm, *p, *homeitm;
char c;
int nl, ig, lineln, maxlineln;
int i;
home = (char*)getenv("HOME");
if (!home) home = (char*)getenv("USERPROFILE");
if (!home)
{
home = (char*)getenv("HOMEPATH");
if (home)
{
char *homedrive = (char*)getenv("HOMEDRIVE");
if (!homedrive)
{
strset(homedir, home);
}
else
{
homedir = (char*)malloc(strlen(home)+strlen(homedrive)+25);
if (!homedir) oom();
sprintf(homedir, "%s%s", homedrive, home);
}
}
else
{
fpasswd = fopen("/etc/passwd", "rb");
if (!fpasswd)
{
strset(homedir, "");
}
else
{
line = (char*)malloc(60);
if (!line)
{
fclose(fpasswd);
strset(homedir, "");
}
else
{
lineln = 0;
maxlineln = 50;
c = getc(fpasswd);
nl = 1;
ig = 0;
while (!feof(fpasswd))
{
if (c=='\r'||c=='\n')
{
nl = 1;
ig = 0;
c = getc(fpasswd);
line[lineln+1] = 0;
p = line;
for (i=0;i<1;i++)
{
useritm = p;
while (*p)
{
if (*p==':')
{
*p = 0;
p++;
break;
}
p++;
}
}
for (i=0;i<5;i++)
{
homeitm = p;
while (*p)
{
if (*p==':')
{
*p = 0;
p++;
break;
}
p++;
}
}
if (!strcmp(useritm, username))
{
strset(homedir, homeitm);
free(line);
fclose(fpasswd);
return;
}
lineln = 0;
continue;
}
if (nl&&c=='#')
{
ig = 1;
nl = 0;
}
if (!ig)
{
if (lineln>=maxlineln)
{
maxlineln+=50;
linealloc = (char*)realloc(line, maxlineln+10);
if (!linealloc)
{
free(line);
fclose(fpasswd);
strset(homedir, "");
return;
}
line = linealloc;
}
line[lineln] = c;
lineln++;
}
c = getc(fpasswd);
}
fclose(fpasswd);
}
}
}
}
else
{
strset(homedir, home);
}
p = homedir;
while (*p)
{
if (*p=='\\') *p = '/';
p++;
}
}
static int
remove_directory(const char *path)
{
FILE *p = 0;
char *rmcmd;
int rv = 666;
if (!directory_exists(path)) return 1;
rmcmd = (char*)malloc(strlen(path)+25);
if (!rmcmd) return 0;
#if defined(WIN32) || defined(_WIN32)
{
SHFILEOPSTRUCT sfo;
char *npath;
char *p;
npath = (char*)malloc(strlen(path)+10);
if (!npath) oom();
memset(npath, 0, strlen(path)+10);
memcpy(npath, path, strlen(path));
p = npath;
while (*p)
{
if (*p=='/') *p = '\\';
p++;
}
memset(&sfo, 0, sizeof(SHFILEOPSTRUCT));
sfo.hwnd = 0;
sfo.wFunc = FO_DELETE;
sfo.pFrom = npath;
sfo.fFlags = FOF_SILENT|FOF_NOCONFIRMATION;
rv = SHFileOperation(&sfo);
free(npath);
}
#else
sprintf(rmcmd, "rm -rf \"%s\" 2>&1", path);
p = popen (rmcmd, "r");
if (p) { rv = pclose(p); }
#endif
//printf("%d %s\n", rv, getenv("PATH"));
free(rmcmd);
return !directory_exists(path);
}
static int
create_directory(const char *path)
{
char *pathm, *p;
if (directory_exists(path)) return 1;
umask(0);
pathm = (char*)malloc(strlen(path)+1);
if (!pathm) return 0;
strcpy(pathm, path);
p = pathm;
while (*p)
{
if (*p=='/'||*p=='\\')
{
char c = *p;
*p = '\0';
mkdir2(pathm);
*p = c;
}
p++;
}
mkdir2(pathm);
free(pathm);
return directory_exists(path);
}
/*
pexec(const char *cmd, int *retval);
Executes a command and returns the output.
*/
static char *
pexec(const char *cmd, int *retval)
{
char buf[512], *almem, *cvar = 0;
size_t cvarlen = 0, read;
FILE *f;
int rv;
if (!(f = popen(cmd, "r"))) goto l__oom;
read = fread(buf, 1, sizeof(buf), f);
while (read)
{
almem = (char*)realloc(cvar, cvarlen+read+1);
if (!almem) goto l__oom;
cvar = almem;
memcpy(cvar+cvarlen, buf, read);
cvar[cvarlen+read] = 0;
cvarlen+=read;
read = fread(buf, 1, sizeof(buf), f);
}
rv = pclose(f);
if (retval) *retval = rv;
if (!cvar)
{
cvar = (char*)malloc(1);
if (!cvar) goto l__oom;
cvar[0] = 0;
}
return cvar;
l__oom:
if (cvar) free(cvar);
if (retval) *retval = -1;
return 0;
}
/*
store_username()
Get the USERNAME environment variable and store it.
*/
static void
store_username()
{
char *usernameenv;
char *p;
int retval;
usernameenv = (char*)getenv("LOGNAME");
if (!usernameenv) usernameenv = (char*)getenv("USER");
if (!usernameenv) usernameenv = (char*)getenv("USERNAME");
if (!usernameenv)
{
if (getenv("SERVER_SOFTWARE")&&strstr((char*)getenv("SERVER_SOFTWARE"), "Microsoft-IIS"))
{
strset(username, "IUSR");
return;
}
}
if (!usernameenv)
{
usernameenv = pexec("whoami", &retval);
if (!usernameenv||!*usernameenv||retval)
{
if (usernameenv) free(usernameenv);
usernameenv = pexec("logname", &retval);
if (!usernameenv||!*usernameenv||retval)
{
if (usernameenv) free(usernameenv);
strset(username, "");
return;
}
}
p = usernameenv;
while (*p)
{
if (isspace(*p))
{
*p = 0;
break;
}
p++;
}
strset(username, usernameenv);
free(usernameenv);
}
else
{
strset(username, usernameenv);
}
}
/*
reset_globals()
Resets all the Globals back to the original value.
*/
static void
reset_globals()
{
/* Reset Integers */
argidx = 0;
max_upload_size = 1024*50; /* 50 KB Max */
/*1024*1024*15;*/ /* 15 MB Max */
/* Reset Booleans */
ignmaxerr = 0;
sessions = 1;
clean = 0;
execute = 1;
script = 1;
inline_errors = 1;
cgi = getenv("SERVER_SOFTWARE")?1:0;
gui = 0;
/* Reset Cksums */
sourcesum = 0;
pathsum = 0;
/* Reset Strings */
strset(use_cc, "gcc");
strset(options, "-I. -w -s");
strset(homedir, "");
strset(tempdir, "");
strset(username, "");
strset(source, "");
strset(sourcefull, "");
strset(workdir, "");
strset(directory, "");
strset(progpath, "");
strset(progargs, "");
strset(shellcmd, "");
strset(pardir, "");
strset(tmp_source, "");
strset(orgsourcepath, "");
strset(orgworkpath, "");
strset(cc_cmd, "");
strset(orgsource, "");
strset(std, "");
strset(cgi_object, "");
sprintf(verstl, "ccod (CCOD) %d.%d.%d (%s %s)", CCOD_MAJOR_VERSION,CCOD_MINOR_VERSION,CCOD_MICRO_VERSION,__DATE__,__TIME__);
//sprintf(verstl, "ccod (CCOD) %d.%d.%d (%s)", CCOD_MAJOR_VERSION,CCOD_MINOR_VERSION,CCOD_MICRO_VERSION,__DATE__);
sprintf(version, "%s\n"
//"Written by Joshua J Baker.\n"
"\n"
"Copyright (C) 2004-2008 Joshua J Baker\n"
"This is free software; see the source for copying conditions. There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
//"\n"
,verstl);
}
/*
read_arguments()
Read all the command line options
*/
static void
read_arguments()
{
int i;
for (i=1;i<argc;i++)
{
if (!strcmp(argv[i], "-v")||!strcmp(argv[i], "--version"))
{
printf("%s", version);
exit(0);
}
else if (!strcmp(argv[i], "-c")||!strcmp(argv[i], "--cc"))
{
i++;
if (i<argc)
{
if (argv[i][0]=='-')
{
print_error("error: missing compiler name\n");
exit(-1);
}
strset(use_cc, argv[i]);
}
else
{
print_error("error: missing compiler name\n");
exit(-1);
}
}
else if (!strcmp(argv[i], "-x")||!strcmp(argv[i], "--clean"))
{
clean = 1;
}
else if (!strcmp(argv[i], "-z")||!strcmp(argv[i], "--clean-only"))
{
clean = 1;
execute = 0;
}
else if (!strcmp(argv[i], "-h")||!strcmp(argv[i], "--help"))
{
printf(
"Usage: ccod [options] -- file [file options]\n"
" ccod file [file options]\n"
"\n"
"Options:\n"
" -v, --version Display version information\n"
" -h, --help Display this information\n"
" -c, --cc Assigns the compiler (cc is used as the default)\n"
" -x, --clean Removes the cached program, recompiles, and runs.\n"
" -z, --clean-only Removes the cached program and does not compile or run.\n"
" -o, --options Compiler specific options.\n"
"\n"
"Examples:\n"
" ccod source.c foo bar # Runs source.c.\n"
" ccod -c g++ -- source.cpp # Runs source.cpp using the g++ compiler.\n"
" ccod -o -O2 -s -- source.c # Runs source.c using the compiler options.\n"
"\n"
"Report bugs to <bakeman@user.sourceforge.net>.\n");
exit(0);
}
else if (!strcmp(argv[i], "--"))
{
i++;
argidx = i;
return;
}
#if 0
else if (!strcmp(argv[i], "-p")||!strcmp(argv[i], "--pack"))
{
FILE *packF;
char *packIn = 0;
char *packOut = 0;
char *packBasename;
char *packPath = 0;
char *targzcmd = 0;
i++;
if (argc==i)
{
print_error("error: missing path of file/directory to pack.\n");
exit(-1);
}
strset(packIn, argv[i]);
i++;
if (argc==i)
{
packBasename = basename(packIn);
packOut = (char*)malloc(strlen(packBasename)+10);
if (!packOut) oom();
sprintf(packOut, "%s.pak", packBasename);
}
else
{
strset(packOut, argv[i]);
}
packF = fopen(packOut, "wb+");
if (!packF)
{
print_error("error: could not create the pack file 1.\n");
exit(-1);
}
if (fprintf(packF,
"#!/bin/sh\n"
"#if 0\n"
"eval 'exec ccod $0 ${1+\"$@\"}'\n"
"exit\n"
"#endif\n"
"#pragma CCOD:package\n"
"//PackSig"
)<0)
{
print_error("error: could not create the pack file 2.\n");
exit(-1);
}
targzcmd = (char*)malloc(strlen(packIn)+(strlen(packOut)*2)+100);
if (!targzcmd) oom();
sprintf(targzcmd, "tar cf - \"%s\" | gzip -9 >> \"%s\"; chmod 755 \"%s\"", packIn, packOut, packOut);
retval = system(targzcmd);
if (retval) exit(-1);
//printf("%s", targzcmd);
//strset(packSource, argv[i]);
//printf("%s\n", packOut);
/*packF = fopen(argv[i], "wb+");
if (!packF)
{
print_error("error: cou
}
*/
exit(0);
}
#endif
else if (!strcmp(argv[i], "--testcgi"))
{
printf("Content-Type: text/html\n\n");
printf("<html>\n<head>\n<title>Test CGI</title>\n</head>\n");
printf("<body>\n<h3>Test CGI</h3>\n<hr>\n<pre>\n");
//i++;
//for (;i<argc;i++)
//{
//printf("%s\n", argv[i]);
//}
//printf("</pre>\n");
/*{
int rv;
printf("<pre>\n[%s]</pre>\n", pexec("c:/mingw/bin/gcc.exe --version", &rv));
//system("c:/mingw/bin/gcc.exe --version");
printf("<br>%d<br>", rv);
} */
//system("gcc --version");
//system("set");
//printf("</body>\n<html>\n");
}
else if (!strcmp(argv[i], "-o")||!strcmp(argv[i], "--options"))
{
i++;
for (;i<argc;i++)
{
if (!strcmp(argv[i], "--"))
{
i++;
argidx = i;
if (i<argc) return;
}
else
{
append_cc_options_quotes(argv[i]);
}
}
}
else if (argv[i][0]=='-')
{
print_error("error: invalid option\n");
exit(-1);
}
else
{
argidx = i;
if (i<argc) return;
}
}
print_error("error: missing source file to execute\n");
exit (-1);
}
/*
store_source()
Read the source from arguments and check the file existance.
*/
static void
store_source()
{
FILE *fsource;
char *p;
strset(source, argv[argidx]);
/* forward-slash path */
p = source;
while (*p)
{
if (*p=='\\') *p = '/';
p++;
}
if (directory_exists(source))
{
print_error("error: source must be a file.\n");
exit(-1);
}
fsource = fopen(source, "r");
if (!fsource)
{
print_error("error: invalid source file or access denied.\n");
exit(-1);
}
fclose(fsource);
strset(orgsource, source);
}
/*
full_path(char *path)
Returns back the full path of the path.
*/
static char *
full_path(const char *path)
{
char *fpath, *fpath2;
char *wd, *p, *p2, *d;
char *cwd;
int nwd;
int iswinabs = 0;
if (!path) path = "";
iswinabs = ( strlen(path) >= 2 && isalpha(path[0]) && path[1] == ':');
cwd = (char*)getcwd((char*)NULL, 0);
if (*path!='/'&&!iswinabs&&cwd)
{
wd = (char*)malloc(strlen(cwd)+25);
if (!wd) return 0;
strcpy(wd, cwd);
nwd = 0;
}
else
{
wd = "";
nwd = 1;
}
fpath = (char*)malloc(strlen(path)+strlen(wd)+25);
if (!fpath)
{
if (!nwd) free(wd);
if (cwd) free(cwd);
return 0;
}
if (*wd&&*path)
{
sprintf(fpath, "%s/%s", wd, path);
}
else if (*wd)
{
sprintf(fpath, "%s", wd);
}
else if (*path)
{
sprintf(fpath, "%s", path);
}
else
{
if (cwd) free(cwd);
return 0;
}
//printf("%s\n", fpath);
fpath2 = (char*)malloc(strlen(path)+strlen(wd)+25);
if (!fpath2)
{
if (!nwd) free(wd);
free(fpath);
if (cwd) free(cwd);
return 0;
}
iswinabs = ( strlen(fpath) >= 2 && isalpha(fpath[0]) && fpath[1] == ':');
if (iswinabs)
{
strcpy(fpath2, "");
}
else
{
strcpy(fpath2, "/");
}
p = fpath;
d = p;
while (*p)
{
if (*p=='/')
{
*p = 0;
if (!strcmp(d, ".")||!strcmp(d, "")){}
else if (!strcmp(d, ".."))
{
p2 = fpath2+strlen(fpath2)-2;
while (p2>=fpath2)
{
if (*p2=='/')
{
p2++;
*p2 = 0;
break;
}
p2--;
}
}
else
{
strcat(fpath2, d);
strcat(fpath2, "/");
}
d = p+1;
}
p++;
}
if (!strcmp(d, ".")||!strcmp(d, "")){}
else if (!strcmp(d, ".."))
{
p2 = fpath2+strlen(fpath2)-2;
while (p2>=fpath2)
{
if (*p2=='/')
{
p2++;
*p2 = 0;
break;
}
p2--;
}
}
else
{
strcat(fpath2, d);
}
p = fpath2;
while (*p)
{
if (*p=='\\') *p = '/';
p++;
}
if (cwd) free(cwd);
return fpath2;
}
/*
store_sourcefull()
Get the full path of the source file.
*/
static void
store_sourcefull()
{
char *sfull;
sfull = full_path(source);
if (!sfull)
{
strset(sourcefull, "");
}
else
{
strset(sourcefull, sfull);
free(sfull);
}
}
/*
get_sourcesum()
Get the cksum of the source data
*/
static void
get_sourcesum()
{
int retval;
char *cmd = 0;
char *retstr;
char *outpath;
FILE *f;
int fsiz;
cmd = malloc(strlen(use_cc) + strlen(sourcefull) + 100);
if (!cmd) oom();
sprintf(cmd, "%s -w -E -nostdinc \"%s\"", use_cc, sourcefull);
outpath = tempnam(0,0);
retval = system2file(cmd, outpath, 1, 1);
f = fopen(outpath, "rb");
if (!f)
{
print_error("error: invalid source file or access denied.\n");
exit(-1);
}
fseek(f, 0, SEEK_END);
fsiz = ftell(f);
rewind(f);
retstr = malloc(fsiz+1);
if (!retstr)
{
fclose(f);
remove(outpath);
oom();
}
fread(retstr, 1, fsiz, f);
retstr[fsiz] = 0;
if (retstr)
{
sourcesum = cksumbin((unsigned char *)retstr, strlen(retstr)) + cksum((unsigned char *)sourcefull);
}
else
{
print_error("error: invalid source file or access denied.\n");
exit(-1);
}
if (retstr) free(retstr);
if (cmd) free(cmd);
fclose(f);
remove(outpath);
}
/*
get_pathsum()
Get the cksum of the source path
*/
static void
get_pathsum()
{
pathsum = cksumpath(sourcefull);
}
static unsigned long crctab[] = {
0x00000000,
0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6,
0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac,
0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f,
0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a,
0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58,
0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033,
0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe,
0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4,
0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5,
0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07,
0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c,
0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1,
0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b,
0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698,
0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d,
0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f,
0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80,
0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a,
0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629,
0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c,
0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e,
0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65,
0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8,
0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2,
0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74,
0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21,
0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a,
0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087,
0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d,
0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce,
0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb,
0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09,
0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf,
0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
static unsigned long
cksum(const unsigned char *path)
{
register unsigned int i, c, s = 0;
size_t n;
FILE *f;
if (directory_exists((char*)path)) return 0;
f = fopen((char *)path, "rb");
if (!f)
{
n = 0;
}
else
{
fseek(f, 0, SEEK_END);
n = ftell(f);
rewind(f);
}
for (i = n; i > 0; --i)
{
c = (unsigned int)getc(f);
s = (s << 8) ^ crctab[(s >> 24) ^ c];
}
/* Extend with the length of the string. */
while (n != 0)
{
c = n & 0377;
n >>= 8;
s = (s << 8) ^ crctab[(s >> 24) ^ c];
}
if (f) fclose(f);
return ~s;
}
static unsigned long
cksumbin(const unsigned char *bin, size_t n)
{
register unsigned int i, c, s = 0;
for (i = n; i > 0; --i)
{
c = (unsigned int)*(bin++);
s = (s << 8) ^ crctab[(s >> 24) ^ c];
}
/* Extend with the length of the string. */
while (n != 0)
{
c = n & 0377;
n >>= 8;
s = (s << 8) ^ crctab[(s >> 24) ^ c];
}
return ~s;
}
unsigned long
cksumpath(const char *path)
{
char *path1, *path2, *p;
struct stat sbuf1,sbuf2;
unsigned long cks;
path1 = full_path(path);
if (!path1) return 0;
path2 = full_path(path);
if (!path2)
{
free(path1);
return 0;
}
if (*(path1+strlen(path1)-1)=='/')
{
*(path1+strlen(path1)-1) = 0;
*(path2+strlen(path2)-1) = 0;
}
p = path2;
while (*p)
{
*p = tolower(*p);
p++;
}
stat(path1, &sbuf1);
stat(path2, &sbuf2);
if (sbuf1.st_ino==sbuf2.st_ino)
{
cks = cksumbin((unsigned char *)path2, strlen(path2));
}
else
{
cks = cksumbin((unsigned char *)path1, strlen(path1));
}
free(path1);
free(path2);
return cks;
}
static void
detect_objc()
{
if (objc)
{
append_cc_options("-L /System/Library/Frameworks/Foundation.framework/Foundation");
append_cc_options("-L /System/Library/Frameworks/AppKit.framework/AppKit");
append_cc_options("-fnested-functions");
}
}
/*
read_pragmas()
This routine will read the pragmas from the source file and do something with
them.
*/
static void
read_pragmas()
{
size_t i, s = 1024;
int lc = 0;
int c = 0;
char *prag, *val, *p, *pline;
char *line;
char *allocator;
FILE *fsource;
fsource = fopen(source, "rb");
if (!fsource)
{
print_error("error: could not open soruce file during pragma parsing.\n");
exit (-1);
}
line = (char*)malloc(s);
if (!line) oom();
l__nextline:
*line = 0;
i=0;
l__appendline:
while (!feof(fsource))
{
lc = c;
c = getc(fsource);
if (c=='\n'&&lc=='\r') continue;
if (c=='\r'||c=='\n'||c==EOF)
{
if (i>=s)
{
s+=1024;
allocator = (char*)realloc(line, s);
if (!allocator) oom();
line = allocator;
}
line[i] = 0;
if (line[i-1]=='\\')
{
i--;
goto l__appendline;
}
pline = line;
while (*pline&&isspace(*pline)) pline++;
if (!strncmp(pline, "//@pragma", 9))
{
prag = pline+9;
goto l__readprag;
}
else if (!strncmp(pline, "#pragma", 7))
{
prag = pline+7;
l__readprag:
while (*prag)
{
if (*prag!=' '&&*prag!='\t') break;
prag++;
}
val = prag;
while (*val)
{
if (*val==' '||*val=='\t')
{
*val=0;
val++;
break;
}
val++;
}
while (*val)
{
if (*val!=' '&&*val!='\t') break;
val++;
}
p = val+strlen(val)-1;
while (p>=val)
{
if (!isspace(*p))
{
*(p+1) = 0;
break;
}
p--;
}
if (!strncmp(prag, "CCOD:", 5))
{
if (!strcmp(prag+5, "compilerOptions")||!strcmp(prag+5, "options"))
{
append_cc_options(val);
}
else if (!strcmp(prag+5, "gui"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
gui = 1;
}
else if (!strcmp(val, "no"))
{
gui = 0;
}
}
else if (!strcmp(prag+5, "cgi")||!strcmp(prag+5, "csp"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
cgi = 1;
}
else if (!strcmp(val, "no"))
{
cgi = 0;
}
}
else if (!strcmp(prag+5, "ignoreUploadError"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
ignmaxerr = 1;
}
else if (!strcmp(val, "no"))
{
ignmaxerr = 0;
}
}
else if (!strcmp(prag+5, "maxUploadSize")||!strcmp(prag+5, "upload"))
{
max_upload_size = atol(val);
}
else if (!strcmp(prag+5, "std"))
{
strset(std, val);
}
else if (!strcmp(prag+5, "useCompiler")||!strcmp(prag+5, "compiler"))
{
strset(use_cc, val);
}
else if (!strcmp(prag+5, "useDirectory")||!strcmp(prag+5, "directory"))
{
strset(workdir, val);
}
else if (!strcmp(prag+5, "scriptInterface")||!strcmp(prag+5, "script"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
script = 1;
}
else if (!strcmp(val, "no"))
{
script = 0;
}
}
else if (!strcmp(prag+5, "inlineErrors"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
inline_errors = 1;
}
else if (!strcmp(val, "no"))
{
inline_errors = 0;
}
}
else if (!strcmp(prag+5, "sessions"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
sessions = 1;
}
else if (!strcmp(val, "no"))
{
sessions = 0;
}
}
else if (!strcmp(prag+5, "recompile"))
{
char *p;
p = val;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(val, "yes"))
{
clean = 1;
}
else if (!strcmp(val, "no"))
{
clean = 0;
}
}
/*else if (!strcmp(prag+5, "package"))
{
printf("I AM A PACKAGE\n");
exit(0);
}*/
else if (!strcmp(prag+5, "importLibrary")||!strcmp(prag+5, "library"))
{
char *tmpstr;
tmpstr = (char*)malloc(strlen(val)+1);
if (!tmpstr) oom();
sprintf(tmpstr, "-l%s", val);
append_cc_options(tmpstr);
free(tmpstr);
}
else if (!strcmp(prag+5, "addSourceFile")||!strcmp(prag+5, "source"))
{
char *tmpstr;
tmpstr = (char*)malloc(strlen(val)+1);
if (!tmpstr) oom();
sourcesum += cksum((unsigned char *)val);
sprintf(tmpstr, "%s", val);
append_cc_options(tmpstr);
free(tmpstr);
}
else if (!strcmp(prag+5, "type"))
{
if (!strcmp(val, "app"))
{
//printf("Application\n");
}
else if (!strcmp(val, "lib"))
{
}
}
}
}
goto l__nextline;
}
else
{
if (i>=s)
{
s+=1024;
allocator = (char*)realloc(line, s);
if (!allocator) oom();
line = allocator;
}
line[i++] = c;
}
}
fclose(fsource);
}
/*
Produce the compilesum
*/
static void
get_compilesum()
{
compilesum =
cksumbin((unsigned char *)use_cc, strlen(use_cc))
+cksumbin((unsigned char *)options, strlen(options))
+cksumbin((unsigned char *)std, strlen(std))
;
}
/*
Build the directory name based on different globals
*/
static void
store_dirname()
{
directory = (char*)malloc(strlen(pardir)+25);
if (!directory) oom();
sprintf(directory, "%s/%lu.%lu", pardir, sourcesum, compilesum);
}
static void
store_pardir()
{
pardir = (char*)malloc(strlen(homedir)+strlen(sourcebase)+strlen(tempdir)+250);
if (!pardir) oom();
sprintf(pardir, "%s/.ccod", homedir);
if (!create_directory(pardir))
{
sprintf(pardir, "%s/%s.ccod", tempdir, username);
if (!create_directory(pardir))
{
print_error("error: could not create ccod cache directory.\n");
exit(-1);
}
else
{
sprintf(pardir, "%s/%s.ccod/apps/%s.%lu", tempdir, username, sourcebase, pathsum);
}
}
else
{
sprintf(pardir, "%s/.ccod/apps/%s.%lu", homedir, sourcebase, pathsum);
}
}
static char *
basename(const char *path)
{
char *ptr;
ptr = (char*)path+strlen((char*)path);
while (ptr>path)
{
if (*ptr=='/'||*ptr=='\\') return ptr+1;
ptr--;
}
return ptr;
}
static void
clean_program()
{
if (clean)
{
remove_directory(directory);
}
if (!execute) exit(0);
}
static void
store_sourcebase()
{
strset(sourcebase, basename(sourcefull));
}
static void
store_progpath()
{
progpath = (char*)malloc(strlen(directory)+strlen(sourcebase)+50);
if (!progpath) oom();
sprintf(progpath, "%s/%s", directory, sourcebase);
}
static void
store_progargs()
{
char *allocator;
int i;
i = argidx+1;
strset(progargs, "");
for (;i<argc;i++)
{
allocator = (char*)realloc(progargs, strlen(progargs)+strlen(argv[i])+10);
if (!allocator) oom();
progargs = allocator;
strcat(progargs, "\"");
strcat(progargs, argv[i]);
strcat(progargs, "\" ");
}
if (*progargs) progargs[strlen(progargs)-1] = 0;
}
static void
store_shellcmd()
{
shellcmd = (char*)malloc(strlen(progpath)+strlen(progargs)+100);
if (!shellcmd) oom();
sprintf(shellcmd, "\"%s\" %s", progpath, progargs);
}
static void
create_progdir()
{
if (!create_directory(directory))
{
print_error("error: could not create the program directory.\n");
exit (-1);
}
}
static int
copy_file(char *pathin, char *pathout)
{
FILE *fin;
FILE *fout;
fin = fopen(pathin, "rb");
if (!fin) return 0;
fout = fopen(pathout, "wb+");
if (!fout)
{
fclose(fin);
return 0;
}
while (1)
{
char c;
if (!fread(&c,1,1,fin)) break;
fwrite(&c,1,1,fout);
}
fclose(fin);
fclose(fout);
return 1;
}
static void
clean_pardir()
{
/* if (!remove_directory(pardir))
{
print_error("error: could not remove old cached version.\n");
exit(-1);
}
*/
/* We dont want to check for errors because otherwise, if a copy of the
program is in use, this compile will fail.
*/
remove_directory(pardir);
if (!create_directory(directory))
{
print_error("error: could not create program directory.\n");
exit(-1);
}
}
static void
copy_source_file()
{
char *tmp_cmd;
tmp_source = (char*)malloc(strlen(directory)+strlen(sourcebase)+25);
if (!tmp_source) oom();
sprintf(tmp_source, "%s/tmp.%s", directory, sourcebase);
tmp_cmd = (char*)malloc(strlen(source)+strlen(tmp_source)+25);
if (!tmp_cmd) oom();
copy_file(source, tmp_source);
strset(source, tmp_source);
free(tmp_cmd);
}
static void
modify_if_shell_script()
{
FILE *fin;
FILE *fout;
char *tmp_source2;
fin = fopen(tmp_source, "rb");
if (!fin)
{
print_error("error: could not open temp source file.\n");
}
if (getc(fin)=='#'&&getc(fin)=='!')
{
shell_script = 1;
tmp_source2 = (char*)malloc(strlen(tmp_source)+25);
if (!tmp_source2) oom();
sprintf(tmp_source2, "%s.script", tmp_source);
fout = fopen(tmp_source2, "wb+");
if (!fout)
{
print_error("error: could not create temp source script.\n");
exit(-1);
}
fwrite("\n",1,1,fout);
while (!feof(fin))
{
char c;
fread(&c, 1, 1, fin);
if (c=='\n')
{
while (!feof(fin))
{
char c;
if (fread(&c, 1, 1, fin)==0) break;
fwrite(&c, 1, 1, fout);
}
break;
}
}
fclose(fin);
fclose(fout);
remove(tmp_source);
fin = fopen(tmp_source2, "rb");
if (!fin)
{
print_error("error: could not open input source for script tag stripping.\n");
exit(-1);
}
fout = fopen(tmp_source, "wb+");
if (!fin)
{
print_error("error: could not open output source for script tag stripping.\n");
exit(-1);
}
while (!feof(fin))
{
char c;
if (fread(&c, 1, 1, fin)==0) break;
fwrite(&c, 1, 1, fout);
}
fclose(fin);
fclose(fout);
remove(tmp_source2);
}
else
{
fclose(fin);
}
}
static void
modify_if_interface_script()
{
char *cmd;
char *hpath;
FILE *fin;
FILE *fout = 0;
FILE *fscript;
FILE *fhead;
int enterstr = 1;
int addlines = 0;
char lcr = 0;
char entertype = 0;
int pss = 0;
int i;
int header_already = 0;
int spacesfront = 1;
char *spacesfront_str = 0, *spacesfront_alloc;
int spacesfront_grow = 512;
int spacesfront_size, spacesfront_len;
#if defined(WIN32) || defined(_WIN32)
const char hguistr[] = "int WINAPI WinMain (HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow){";
const char fguistr[] = ";return 0;}\n";
#else
const char hguistr[] = "int main(int argc, char **argv){";
const char fguistr[] = ";return 0;}\n";
#endif
const char hcgistr[] = "void cspmain(){";
const char fcgistr[] = ";return;}\n";
const char hplainstr[] = "int main(int argc, char **argv){";
const char fplainstr[] = ";return 0;}\n";
if (cgi&&!script)
{
/* Add only the cgiinc.h line to the top of the file. */
char incline[] = "#include <csp.h>\n";
char *ntmp;
FILE *fin, *fout;
ntmp = (char*)malloc(strlen(tmp_source)+25);
if (!ntmp) oom();
sprintf(ntmp, "%s.2", tmp_source);
fin = fopen(tmp_source, "rb");
fout = fopen(ntmp, "wb+");
if (!fin||!fout)
{
print_error("error: could not create no-script cgi temp source.\n");
exit(-1);
}
fwrite(incline, 1, strlen(incline), fout);
while (1)
{
char c;
if (!fread(&c,1,1,fin)) break;
fwrite(&c,1,1,fout);
}
fclose(fin);
fclose(fout);
remove(tmp_source);
copy_file(ntmp, tmp_source);
remove(ntmp);
free(ntmp);
return;
}
if (!script) return;
cmd = (char*)malloc((strlen(tmp_source)*3)+100);
if (!cmd) oom();
hpath = (char*)malloc((strlen(tmp_source)*3)+100);
if (!hpath) oom();
/* Modify script tags */
fin = fopen(tmp_source, "rb");
if (!fin)
{
print_error("error: could not open input source for script tag stripping.\n");
exit(-1);
}
sprintf(cmd, "%s.script", tmp_source);
sprintf(hpath, "%s.head", tmp_source);
fscript = fopen(cmd, "wb+");
fhead = fopen(hpath, "wb+");
if (!fscript||!fhead)
{
print_error("error: could not open output source for script tag stripping.\n");
exit(-1);
}
fout = fscript;
if (cgi)
{
fwrite(hcgistr, 1, strlen(hcgistr), fout);
}
else if (gui)
{
fwrite(hguistr, 1, strlen(hguistr), fout);
}
else
{
fwrite(hplainstr, 1, strlen(hplainstr), fout);
}
if (objc)
{
fprintf(fout, "NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];\n");
}
//if (shell_script) fprintf(fout, "\n");
//if (shell_script) addlines-=1;
//if (cgi) addlines-=1;
spacesfront = 1;
spacesfront_str = (char*)malloc(spacesfront_grow+1);
if (!spacesfront_str) oom();
*spacesfront_str = 0;
spacesfront_size = spacesfront_grow;
spacesfront_len = 0;
while (1)
{
char c = 0;
char bc = 0;
if (fread(&c, 1, 1, fin)==0) break;
if (enterstr)
{
if (c=='<')
{
if (fread(&c, 1, 1, fin)==0)
{
c = '<';
goto l__escapeit;
}
if (c=='?'||c=='#')
{
if (c == '?')
{
if (fread(&c, 1, 1, fin)==0) break;
if (c != '#')
{
fseek(fin, -1, SEEK_CUR); // move back one character
c = '?';
}
}
enterstr = 0;
entertype = c;
if (c=='?')
{
if (!spacesfront)
{
fprintf(fout, "\");\n");
}
}
else
{
if (header_already)
{
print_error("error: header data was already processed.\n");
exit(-1);
}
header_already = 1;
}
if (!pss&&shell_script)
{
//addlines++;
pss = 1;
}
fout = (c=='?')?fscript:fhead;
for (i=0;i<addlines;i++)
{
fprintf(fout, "\n");
}
continue;
}
else
{
bc = '<';
}
}
l__escapeit:
if (isspace(c)&&spacesfront)
{
if (spacesfront_len>=spacesfront_size-2)
{
spacesfront_str = (char*)realloc(spacesfront_str, spacesfront_size+spacesfront_grow+1);
if (!spacesfront_str) oom();
}
spacesfront_str[spacesfront_len++] = '\\';
switch (c)
{
case (' '): spacesfront_str[spacesfront_len++] = ' '; break;
case ('\f'): spacesfront_str[spacesfront_len++] = 'f'; break;
case ('\n'): spacesfront_str[spacesfront_len++] = 'n'; break;
case ('\r'): spacesfront_str[spacesfront_len++] = 'r'; break;
case ('\t'): spacesfront_str[spacesfront_len++] = 't'; break;
case ('\v'): spacesfront_str[spacesfront_len++] = 'v'; break;
}
spacesfront_str[spacesfront_len] = 0;
spacesfront_size += spacesfront_grow;
}
else if (!(isspace(c)&&spacesfront))
{
if (spacesfront)
{
if (cgi)
{
if (*spacesfront_str) fprintf(fout, ";\nResponse.Write(\"%s\");\n", spacesfront_str);
fprintf(fout, ";\nResponse.Write(\"");
}
else
{
if (*spacesfront_str) fprintf(fout, ";\nprintf(\"%s\");\n", spacesfront_str);
fprintf(fout, ";\nprintf(\"");
}
spacesfront = 0;
}
if (bc)
{
fprintf(fout, "%c", bc);
}
switch (c)
{
case ('\b'): fprintf(fout, "\\b"); break;
case ('\f'): fprintf(fout, "\\f"); break;
case ('\n'):
if (!lcr) addlines++;
fprintf(fout, "\\n");
lcr = 0;
break;
case ('\r'):
addlines++;
fprintf(fout, "\\r");
break;
case ('\t'): fprintf(fout, "\\t"); break;
case ('\"'): fprintf(fout, "\\\""); break;
case ('\''): fprintf(fout, "\\'"); break;
case ('\\'): fprintf(fout, "\\\\"); break;
case ('\v'): fprintf(fout, "\\v"); break;
case ('\a'): fprintf(fout, "\\a"); break;
case ('\?'): fprintf(fout, "\\?"); break;
case ('%'): fprintf(fout, "%%%%"); break;
default:
if ( ((c>='0' && c<='~') || c==' ') && c != '%')
{
fwrite(&c, 1, 1, fout);
}
else
{
fprintf(fout, "\" \"\\x%x\" \"", c);
}
}
}
if (c=='\r') lcr = 1;
}
else
{
if (c=='?'||c=='#')
{
char lc = c;
if (fread(&c, 1, 1, fin)==0)
{
fwrite(&c, 1, 1, fout);
break;
}
if (lc == '#' && c == '?')
{
if (fread(&c, 1, 1, fin)==0)
{
fwrite(&c, 1, 1, fout);
break;
}
}
if (c=='>')
{
enterstr = 1;
addlines = 0;
entertype = 0;
fout = fscript;
if (lc=='?')
{
/*
if (cgi)
{
fprintf(fout, ";\nResponse.Write(\"");
}
else
{
fprintf(fout, ";\nprintf(\"");
}
*/
}
spacesfront = 1;
*spacesfront_str = 0;
spacesfront_len = 0;
continue;
}
else
{
fwrite(&lc,1,1,fout);
}
}
fwrite(&c, 1, 1, fout);
}
}
if (!spacesfront)
{
fprintf(fout, "\");\n");
}
if (spacesfront_str) free(spacesfront_str);
if (objc)
{
fprintf(fout, "[pool release];\n");
}
if (cgi)
{
fwrite(fcgistr, 1, strlen(fcgistr), fout);
}
else if (gui)
{
fwrite(fguistr, 1, strlen(fguistr), fout);
}
else
{
fwrite(fplainstr, 1, strlen(fplainstr), fout);
}
fclose(fhead);
fclose(fin);
fclose(fscript);
remove(tmp_source);
fin = fopen(cmd, "rb");
if (!fin)
{
print_error("error: could not open input source for script tag stripping.\n");
exit(-1);
}
//sprintf(cmd, "%s.script", tmp_source);
fout = fopen(tmp_source, "wb+");
if (!fout)
{
print_error("error: could not open output source for script tag stripping.\n");
exit(-1);
}
fprintf(fout, "#define csp\n");
fprintf(fout, "#define ccod\n");
if (cgi)
{
fprintf(fout, "#include <csp.h>\n");
}
else
{
fprintf(fout, "#include <stdio.h>\n");
fprintf(fout, "#include <stdlib.h>\n");
}
if (objc)
{
fprintf(fout, "#import <Foundation/Foundation.h>\n");
fprintf(fout, "#import <AppKit/AppKit.h>\n");
}
fhead = fopen(hpath, "rb");
if (!fhead)
{
print_error("error: could not open input source for script tag stripping.\n");
exit(-1);
}
for (;;)
{
char c;
if (!fread(&c, 1, 1, fhead)) break;
fwrite(&c, 1, 1, fout);
}
fclose(fhead);
for (;;)
{
char c;
if (!fread(&c, 1, 1, fin)) break;
fwrite(&c, 1, 1, fout);
}
fclose(fin);
fclose(fout);
remove(cmd);
remove(hpath);
free(cmd);
free(hpath);
}
static void
modify_if_ssi()
{
FILE *fin;
FILE *fout;
char *fpath;
int res;
char *tmp_source2;
if (!script) return;
tmp_source2 = (char*)malloc(strlen(tmp_source)+25);
if (!tmp_source2) oom();
sprintf(tmp_source2, "%s.script", tmp_source);
fpath = full_path(orgsource);
if (!fpath) oom();
fin = fopen(tmp_source, "rb");
fout = fopen(tmp_source2, "wb+");
res = process_ssi_stream(fpath, fin, fout, NULL);
fclose(fin);
fclose(fout);
free(fpath);
//remove(tmp_source);
copy_file(tmp_source2, tmp_source);
remove(tmp_source2);
free(tmp_source2);
if (!res)
{
print_error("error: could not process ssi commands.\n");
exit(-1);
}
}
void
print_error(const char *errstr)
{
if (getenv("SERVER_SOFTWARE"))
{
char *use_cc_version;
char *compiler_version = 0;
char *p;
int cv_retval;
char *outpath;
outpath = tempnam(0,0);
use_cc_version = (char*)malloc(strlen(use_cc)+100);
if (!use_cc_version) oom();
sprintf(use_cc_version, "%s --version", use_cc, outpath);
cv_retval = system2file(use_cc_version, outpath, 1, 1);
if (cv_retval)
{
strset(compiler_version, "unknown compiler");
}
else
{
FILE *f;
f = fopen(outpath, "rt");
if (!f)
{
strset(compiler_version, "unknown compiler");
}
else
{
size_t siz;
fseek(f, 0, SEEK_END);
siz = ftell(f);
rewind(f);
compiler_version = (char*)malloc(siz+1);
if (!compiler_version) oom();
memset(compiler_version, 0, siz+1);
fread(compiler_version, 1, siz+1, f);
fclose(f);
remove(outpath);
}
}
p = compiler_version;
while(*p)
{
if (*p=='\r'||*p=='\n')
{
*p = 0;
break;
}
p++;
}
fprintf(stdout, "Content-Type: text/html\n\n");
fprintf(stdout, "<html>\r\n");
fprintf(stdout, " <head>\r\n");
fprintf(stdout, " <title>CCOD Compiler Error</title>\r\n");
fprintf(stdout, " </head>\r\n");
fprintf(stdout, " <body bgcolor=\"white\">\n");
fprintf(stdout, " <font face=\"arial,sans-serif\" color=\"black\">\r\n");
fprintf(stdout, " <hr size=\"1\"/>\r\n");
fprintf(stdout, " <font size=\"3\"><b>CCOD Compiler Error</b><br></font></h2>\r\n");
fprintf(stdout, " <font size=\"2\">CCOD encountered the following errors while compiling a source file.</font>\r\n");
fprintf(stdout, " <hr size=\"1\"/>\r\n");
fprintf(stdout, " <table cellpadding=15 cellspacing=0 border=0 "
"bgcolor=silver width=\"100%%\"><td><pre>"
"%s"
"</pre></td></table>",errstr);
fprintf(stdout, " <hr size=1><br>\n");
if (verstl&&*verstl)
{
fprintf(stdout, "\n<i><b><font face=arial,sans-serif>CCOD Software: </font></b></i><br><pre>%s</pre>", verstl);
}
if (getenv("SERVER_SOFTWARE"))
{
fprintf(stdout, "\n<i><b><font face=arial,sans-serif>Server Software: </font></b></i><br><pre>%s</pre>", getenv("SERVER_SOFTWARE"));
}
if (sourcefull&&*sourcefull)
{
fprintf(stdout, "\n<i><b><font face=arial,sans-serif>Source Path: </font></b></i><br><pre>%s</pre>", sourcefull);
if (source&&*source&&strcmp(sourcefull,source))
{
fprintf(stdout, "\n<i><b><font face=arial,sans-serif>Cached Path: </font></b></i><br><pre>%s</pre>", source);
}
}
fprintf(stdout, "\n<i><b><font face=arial,sans-serif>Compiler: </font></b></i><br><pre>%s</pre>", compiler_version);
fprintf(stdout, "\n<hr size=1>\n");
fprintf(stdout, "</body>\n");
fprintf(stdout, "</html>\n");
remove(outpath);
free(compiler_version);
exit(0);
}
else
{
fprintf(stderr, "%s", errstr);
exit(-1);
}
}
static void
exec_compile_command()
{
int retval;
FILE *p;
char c;
char *line = 0, *lalloc;
int ls, lidx;
char *stri;
char *finaloutput = 0;
char *outpath;
char *cgiheaderpath = 0;
char *outdata = 0;
int minuslines = 0;
FILE *stdoutput;
if (cc_cmd) free(cc_cmd);
cc_cmd = (char*)malloc(strlen(orgworkpath)+strlen(orgsourcepath)+strlen(use_cc)+strlen(sourcebase)+strlen(options)+strlen(source)+strlen(progpath)+strlen(cgi_object)+100);
if (!cc_cmd) oom();
outpath = (char*)malloc(strlen(directory)+100);
if (!outpath) oom();
sprintf(outpath, "%s/errors.txt", directory);
chdir(orgsourcepath);
if (cgi)
{
cgiheaderpath = (char*)malloc(strlen(directory)+100);
if (!cgiheaderpath) oom();
sprintf(cgiheaderpath, "%s/cgiinc.h", directory);
p = fopen(cgiheaderpath, "wb+");
if (!p)
{
print_error("error: could not create the cgiinc.h file.\n");
exit(-1);
}
fwrite(cgiheader, 1, sizeof(cgiheader), p);
fclose(p);
}
remove(outpath);
#if defined(WIN32) || defined(_WIN32)
if (cgi)
{
/*
sprintf(cc_cmd, "%s \"%s\" \"%s\" \"%s\" %s -std=%s -o \"%s\"", use_cc, source,
cgi_object, cgi_dll,
options, std, progpath);
*/
char *dllpath;
dllpath = (char*)malloc(strlen(argv[0])+50);
if (!dllpath) oom();
strcpy(dllpath, argv[0]);
dllpath[strlen(dllpath)-strlen(basename(dllpath))] = 0;
strcat(dllpath, "libcsp.dll");
sprintf(cc_cmd, "%s \"%s\" \"%s\" %s %s%s -o \"%s\"", use_cc, source,
dllpath,
options, *std?"-std=":"", *std?std:"", progpath);
/*
sprintf(cc_cmd, "%s \"%s\" -lcsp %s -std=%s -o \"%s\"", use_cc, source,
options, std, progpath);
*/
free(dllpath);
}
else
{
sprintf(cc_cmd, "%s \"%s\" %s %s%s -o \"%s\"", use_cc, source, options, *std?"-std=":"", *std?std:"", progpath);
}
retval = system2file(cc_cmd, outpath, 1, 1);
#else
if (cgi)
{
sprintf(cc_cmd, "%s \"%s\" -lpthread -lcsp %s %s%s -o \"%s\" 2>&1", use_cc, source,
options, *std?"-std=":"", *std?std:"", progpath);
}
else
{
sprintf(cc_cmd, "%s \"%s\" %s %s%s -o \"%s\" 2>&1", use_cc, source, options, *std?"-std=":"", *std?std:"", progpath);
}
outdata = pexec(cc_cmd, &retval);
if (!outdata) oom();
p = fopen(outpath, "wb+");
if (!p)
{
print_error("error: could not create the error file (1).\n");
exit(-1);
}
fprintf(p, "%s", outdata);
fclose(p);
#endif
if (cgi)
{
remove(cgiheaderpath);
free(cgiheaderpath);
}
p = fopen(outpath, "rb");
if (!p)
{
print_error("error: could not open the error file (2).\n");
exit(-1);
}
finaloutput = (char*)malloc(1);
if (!finaloutput) oom();;
*finaloutput = 0;
if (script&&inline_errors)
{
stdoutput = stdout;
}
else
{
stdoutput = stderr;
}
line = (char*)malloc(250+50);
if (!line) oom();
ls = 250;
*line = 0;
lidx = 0;
while (!feof(p))
{
char *lp, *nstr, *np, nstrac[30];
size_t ln;
c = getc(p);
line[lidx] = c;
if (line[lidx]=='\r'||line[lidx]=='\n')
{
lidx++;
line[lidx] = 0;
/* Make sure the line contains the correct line number. */
lp = line;
while (*lp)
{
if (*lp==':')
{
nstr = lp+1;
lp++;
while (*lp)
{
if (*lp==':')
{
*lp = 0;
np = nstr;
while (*np)
{
if (!isdigit(*np))
{
*lp = ':';
goto l__eol;
}
np++;
}
ln = atol(nstr);
if (script) ln-=6;
if (cgi) ln+=1;
if (cgi&&!script) ln-=2;
sprintf(nstrac, "%lu", ln);
*lp = ':';
{
char *nline;
nline = (char*)malloc(strlen(line)+strlen(nstrac)+1);
if (!nline) oom();
*(nstr-1) = 0;
sprintf(nline, "%s:%s:%s", line, nstrac, lp+1);
strcpy(line, nline);
free(nline);
}
//memmove(nstr+strlen(nstrac), lp, strlen(lp));
//sprintf(nstr, "%s", nstrac);
//*lp = ':';
//printf("[%d]\n", ln);
goto l__eol;
}
lp++;
}
}
lp++;
}
l__eol:
finaloutput = (char*)realloc(finaloutput,
strlen(finaloutput)+strlen(orgsource)+
strlen(line)+strlen(source)+50);
if (!finaloutput) oom();
stri = (char*)strstr((char*)line, (char*)source);
if (stri==line)
{
//fprintf(stdoutput, "%s", orgsource);
//fprintf(stdoutput, "%s", line+strlen(source));
sprintf(finaloutput+strlen(finaloutput), "%s", orgsource);
sprintf(finaloutput+strlen(finaloutput), "%s", line+strlen(source));
}
else if (stri>line)
{
line[stri-line] = 0;
//fprintf(stdoutput, "%s", line);
//fprintf(stdoutput, "%s", orgsource);
//fprintf(stdoutput, "%s", line+strlen(source)+(stri-line));
sprintf(finaloutput+strlen(finaloutput), "%s", line);
sprintf(finaloutput+strlen(finaloutput), "%s", orgsource);
sprintf(finaloutput+strlen(finaloutput), "%s", line+strlen(source)+(stri-line));
}
else
{
stri = (char*)strstr((char*)line, basename(source));
if (stri==line)
{
//fprintf(stdoutput, "%s", orgsource);
//fprintf(stdoutput, "%s", line+strlen(source));
sprintf(finaloutput+strlen(finaloutput), "%s", basename(orgsource));
sprintf(finaloutput+strlen(finaloutput), "%s", line+strlen(basename(source)));
}
else if (stri>line)
{
line[stri-line] = 0;
//fprintf(stdoutput, "%s", line);
//fprintf(stdoutput, "%s", orgsource);
//fprintf(stdoutput, "%s", line+strlen(source)+(stri-line));
sprintf(finaloutput+strlen(finaloutput), "%s", line);
sprintf(finaloutput+strlen(finaloutput), "%s", basename(orgsource));
sprintf(finaloutput+strlen(finaloutput), "%s", line+strlen(basename(source))+(stri-line));
}
else
{
//fprintf(stdoutput, "%s", line);
sprintf(finaloutput+strlen(finaloutput), "%s", line);
}
}
lidx = 0;
continue;
}
lidx++;
if (lidx>ls)
{
ls+=250;
lalloc = (char*)malloc(ls+50);
if (!lalloc) oom();
line = lalloc;
}
}
if (line) free(line);
fclose(p);
remove(outpath);
if (stdoutput == stderr)
{
if (retval)
{
fprintf(stderr, "%s", finaloutput);
exit(retval);
}
}
else
{
if (retval)
{
print_error(finaloutput);
exit(0);
}
}
if (finaloutput) free(finaloutput);
chdir(orgworkpath);
}
static void
remove_source_copy()
{
remove(source);
if (cgi)
{
char *cgisource;
cgisource = (char*)malloc(strlen(directory)+50);
if (!cgisource) oom();
sprintf(cgisource, "%s/cgiinc.c", directory);
remove(cgisource);
free(cgisource);
}
}
static void
begin_compile()
{
FILE *f;
if (directory_exists(progpath))
{
print_error("error: progam file is a directory.\n");
exit(-1);
}
f = fopen(progpath, "rb");
if (!f)
{
clean_pardir();
copy_source_file();
modify_if_shell_script();
modify_if_ssi();
modify_if_interface_script();
//modify_if_cgi();
exec_compile_command();
remove_source_copy();
}
else
{
fclose(f);
}
}
static void
store_orgworkpath()
{
char *pwd = (char*)getcwd((char*)NULL,0);
char *p;
if (!pwd||!*pwd)
{
//print_error("error: could not get the working directory.\n");
//exit(-1);
pwd = ".";
}
strset(orgworkpath, pwd);
p = orgworkpath;
while (*p)
{
if (*p=='\\') *p = '/';
p++;
}
free(pwd);
}
static void
change_working_directory()
{
char *cdcmd;
if (getenv("PATH_TRANSLATED"))
{
strset(cdcmd, (char*)getenv("PATH_TRANSLATED"));
cdcmd[strlen(cdcmd)-strlen(basename(cdcmd))] = 0;
chdir(cdcmd);
free(cdcmd);
}
//char *cdcmd;
//if (!strcmp(workdir, ".")||!strcmp(workdir, "")) return;
//cdcmd = (char*)malloc(strlen(workdir)+strlen(shellcmd)+100);
//if (!cdcmd) oom();
//sprintf(cdcmd, "cd \"%s\" && cd \"%s\" && %s", orgsourcepath, workdir, shellcmd);
//strset(shellcmd, cdcmd);
//free(cdcmd);
}
int systemc(const char *command)
{
#if defined(_WIN32) || defined(WIN32)
return system2file(command,0,0,0);
#else
return system(command);
#endif
}
static void
execute_final_program()
{
int retval;
char *fshellcmd;
char maxulsizstr[50];
fshellcmd = (char*)malloc(strlen(shellcmd)+25);
if (!fshellcmd) oom();
chdir(workdir);
setenv("CCOD_SOFTWARE", verstl, 1);
setenv("CCOD_PROGPATH", progpath, 1);
setenv("CCOD_SESSIONS", sessions?"yes":"no", 1);
setenv("CCOD_CSPINUSE", cgi?"yes":"no", 1);
setenv("CCOD_IGMAXULE", ignmaxerr?"yes":"no", 1);
sprintf(maxulsizstr, "%lu", max_upload_size);
setenv("CCOD_MAXULSIZ", maxulsizstr, 1);
sprintf(fshellcmd, "%s", shellcmd);
if (fshellcmd[strlen(fshellcmd)-1] == ' ') fshellcmd[strlen(fshellcmd)-1] = 0;
retval = systemc(fshellcmd);
chdir(orgsourcepath);
fretval = retval;
free(fshellcmd);
}
static void
store_orgsourcepath()
{
strset(orgsourcepath, sourcefull);
orgsourcepath[strlen(orgsourcepath)-strlen(basename(sourcefull))-1] = 0;
}
static int
process_ssi_stream(const char *path, FILE *fin, FILE *fout, unsigned long *addcksum)
{
char ch;
char ssiotag[6];
char *ssiline = 0, *ssilinealloc;
size_t ssilinelen;
size_t ssilinemax;
char *command, *p, *attr, *val;
size_t read;
if (!fin) goto l__err;
//if (!fout) goto l__err;
ssilinemax = 500;
ssiline = (char*)malloc(ssilinemax+25);
if (!ssiline) goto l__err;
*ssiline = 0;
ssilinelen = 0;
for (;;)
{
if (!fread(&ch,1,1,fin)) goto l__eof;
if (ch=='<')
{
memset(ssiotag, 0, sizeof(ssiotag));
read = fread(ssiotag,1,4,fin);
if (read!=4)
{
if (fout) fprintf(fout, "<%s", ssiotag);
goto l__eof;
}
else if (strcmp(ssiotag, "!--#"))
{
if (fout) fprintf(fout, "<%s", ssiotag);
continue;
}
else
{
ssilinelen = 0;
for (;;)
{
if (!fread(&ch,1,1,fin)) goto l__eof;
if (ch=='-')
{
if (!fread(&ch,1,1,fin)) goto l__eof;
if (ch=='-')
{
if (!fread(&ch,1,1,fin)) goto l__eof;
if (ch=='>')
{
break;
}
ssiline[ssilinelen++] = '-';
ssiline[ssilinelen++] = '-';
ssiline[ssilinelen++] = ch;
continue;
}
ssiline[ssilinelen++] = '-';
ssiline[ssilinelen++] = ch;
continue;
}
if (ssilinelen>=ssilinemax)
{
ssilinemax+=500;
ssilinealloc = (char*)realloc(ssiline, ssilinemax+25);
if (!ssilinealloc) goto l__err;
ssiline = ssilinealloc;
}
ssiline[ssilinelen++] = ch;
}
ssiline[ssilinelen] = 0;
/* parse the ssi command */
p = ssiline;
while (*p&&isspace(*p)) p++;
command = p;
while (*p)
{
if (isspace(*p))
{
*p = 0;
p++;
break;
}
*p = tolower(*p);
p++;
}
if (!strcmp(command, "include"))
{
while (*p&&isspace(*p)) p++;
attr = p;
while (*p)
{
if (isspace(*p)||*p=='=')
{
*p = 0;
p++;
break;
}
*p = tolower(*p);
p++;
}
while (*p&&isspace(*p)) p++;
if (*p=='=') p++;
while (*p&&isspace(*p)) p++;
if (*p=='\"'||*p=='\'')
{
char qp = *p;
p++;
val = p;
while (*p)
{
if (*p==qp)
{
*p = 0;
p++;
break;
}
p++;
}
}
else
{
val = p;
while (*p)
{
if (isspace(*p))
{
*p = 0;
p++;
break;
}
p++;
}
}
if (!strcmp(attr, "file"))
{
if (!strstr(val, "../")&&*val!='/'&&!strstr(val, "/..")&&((char*)strstr(val, "..")!=(char*)val))
{
FILE *fin2;
char *dir;
char *fpath;
char *p3;
dir = (char*)malloc(strlen(path)+1);
if (!dir) goto l__err;
strcpy(dir, path);
p3 = dir+strlen(dir);
while (p3>dir)
{
if (*p3=='/')
{
*p3 = 0;
break;
}
p3--;
}
fpath = (char*)malloc(strlen(dir)+strlen(val)+2);
if (!fpath)
{
free(dir);
goto l__err;
}
sprintf(fpath, "%s/%s", dir, val);
free(dir);
dir = full_path(fpath);
if (!dir)
{
free(fpath);
goto l__err;
}
free(fpath);
fpath = dir;
dir = 0;
fin2 = fopen(fpath, "rb");
if (!fin2)
{
free(fpath);
goto l__err;
}
if (!process_ssi_stream(fpath, fin2, fout, addcksum))
{
fclose(fin2);
free(fpath);
goto l__err;
}
fclose(fin2);
if (addcksum) *addcksum += cksum((unsigned char *)fpath);
free(fpath);
}
}
else if (!strcmp(attr, "virtual"))
{
if (getenv("DOCUMENT_ROOT")&&*val=='/'&&!strstr(val, "../")&&!strstr(val, "/..")&&((char*)strstr(val, "..")!=(char*)val))
{
char *fpath;
FILE *fin2;
fpath = (char*)malloc(strlen((char*)getenv("DOCUMENT_ROOT"))+strlen(val)+1);
if (!fpath) goto l__err;
sprintf(fpath, "%s%s", getenv("DOCUMENT_ROOT"), val);
fin2 = fopen(fpath, "rb");
if (!fin2)
{
free(fpath);
goto l__err;
}
if (!process_ssi_stream(fpath, fin2, fout, addcksum))
{
fclose(fin2);
free(fpath);
goto l__err;
}
fclose(fin2);
if (addcksum) *addcksum += cksum((unsigned char *)fpath);
free(fpath);
}
else
{
goto l__err;
}
}
}
else if (!strcmp(command, "echo"))
{
}
else if (!strcmp(command, "printenv"))
{
//printf("<?system(\"set\");?>\n");
}
continue;
}
}
if (fout) { if (!fwrite(&ch,1,1,fout)) goto l__err; }
}
l__eof:
if (ssiline) free(ssiline);
return 1;
l__err:
if (ssiline) free(ssiline);
return 0;
}
#if 0
static int
process_ssi_file(const char *pathin, const char *pathout)
{
FILE *fin;
FILE *fout;
char *fpath;
int res;
fpath = full_path(pathin);
if (!fpath) return 0;
fin = fopen(fpath, "rb");
fout = fopen(pathout, "wb+");
res = process_ssi_stream(fpath, fin, fout, NULL);
fclose(fin);
fclose(fout);
free(fpath);
return res;
}
#endif
static void
add_ssiincludesum()
{
FILE *fin;
fin = fopen(sourcefull, "rb");
if (!fin)
{
print_error("error: error opening source file.\n");
exit(-1);
}
if (!process_ssi_stream(sourcefull, fin, NULL, &sourcesum))
{
print_error("error: ssi instruction error.\n");
exit(-1);
}
fclose(fin);
}
#define TIMESTART() \
{\
clock_t start, finish;\
double duration;\
start = clock();
#define TIMEEND() \
finish = clock();\
duration = (double)(finish - start) / CLOCKS_PER_SEC;\
printf( "%7.6f seconds\n", duration );\
}
void
detect_compiler()
{
char *p, *ext;
p = source+strlen(source)-1;
while (p>source)
{
if (*p=='.') break;
p--;
}
ext = (char*)malloc(strlen(p)+1);
if (!ext) oom();
strcpy(ext, p);
if (!strcmp(ext, ".c"))
{
strset(use_cc, "gcc");
strset(std, "c99");
}
else
{
p = ext;
while (*p)
{
*p = tolower(*p);
p++;
}
if (!strcmp(ext, ".cc")||!strcmp(ext, ".cp")||!strcmp(ext, ".cxx")||
!strcmp(ext, ".cpp")||!strcmp(ext, ".c++")||!strcmp(ext, ".C"))
{
strset(use_cc, "g++");
strset(std, "c++98");
}
else if (!strcmp(ext, ".m"))
{
objc = 1;
strset(std, "c99");
}
}
free(ext);
}
#if defined(WIN32) || defined(_WIN32)
int WINAPI WinMain (HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow)
{
argc = __argc;
argv = __argv;
#else
int
main(int in_argc, char **in_argv)
{
argc = in_argc;
argv = in_argv;
#endif
#if defined(WIN32) || defined(_WIN32)
if (setmode(fileno(stdin), O_BINARY) == -1)
{
print_error("error: could not set binary mode for stdin.\n");
exit(-1);
}
if (setmode(fileno(stdout), O_BINARY) == -1)
{
print_error("error: could not set binary mode for stdout.\n");
exit(-1);
}
if (getenv("PATH"))
{
char envvar[5000];
char *npath;
char *ndir = 0;
npath = (char*)malloc(strlen(getenv("PATH"))+strlen(argv[0])+50);
if (!npath) oom();
strset(ndir, argv[0]);
ndir[strlen(ndir)-strlen(basename(ndir))-1] = 0;
sprintf(npath, "%s;%s", ndir, getenv("PATH"));
SetEnvironmentVariable("PATH", npath);
GetEnvironmentVariable("PATH", envvar, sizeof(envvar));
free(npath);
free(ndir);
}
#endif
/* Reset all the Global Variables. */
reset_globals();
/* Read Command Line Arguments. */
read_arguments();
/* Locate the users temp directory. */
store_tempdir();
/* Get the user name. */
store_username();
/* Locate the users home directory. */
store_homedir();
if (!tempdir||!*tempdir)
{
print_error("error: could not lookup the temp directory.\n");
exit(-1);
}
else if (!username||!*username)
{
print_error("error: could not lookup the user/login name.\n");
exit(-1);
}
else if (!homedir||!*homedir)
{
print_error("error: could not lookup the home directory.\n");
exit(-1);
}
//printf("\n");
//printf("User Name: [%s]\nHome Dir:[%s]\nTemp Dir:[%s]\n", username, homedir, tempdir);
/* Read and Check the source file. */
store_source();
/* Read and Check source full path. */
store_sourcefull();
store_orgworkpath();
store_orgsourcepath();
/* Read the base name of the source. */
store_sourcebase();
/* Calculate the source file sum. */
get_sourcesum();
/* Add ssi includes to cksum. */
add_ssiincludesum();
/* Calculate the source path sum. */
get_pathsum();
if (!source||!*source||!sourcefull||!*sourcefull)
{
print_error("error: source file error.\n");
exit(-1);
}
else if (!sourcesum)
{
print_error("error: could not calculate the source cksum.\n");
exit(-1);
}
else if (!pathsum)
{
print_error("error: could not calculate the path cksum.\n");
exit(-1);
}
//printf("Source File: [%s]\n", source);
//printf("Source Full: [%s]\n", sourcefull);
//printf("Org Source: [%s]\n", orgsourcepath);
//printf("Org Working: [%s]\n", orgworkpath);
//printf("Source Sum: [%u]\n", sourcesum);
//printf("Path Sum: [%u]\n", pathsum);
/* Auto detect compiler */
detect_compiler();
/* Read the Pragmas from the source file. */
read_pragmas();
/* Objective-C Support (Mac OS X) */
detect_objc();
/* Produce a compilesum from the command line cc options. */
get_compilesum();
/* Build the parent directory name. */
store_pardir();
/* Build the directory name. */
store_dirname();
if (!directory||!*directory)
{
print_error("error: could not build the output directory path.\n");
exit(-1);
}
//printf("Compile Sum: [%u]\n", compilesum);
//printf("Parent Directory: [%s]\n", pardir);
//printf("Directory: [%s]\n", directory);
/* Build the program path. */
store_progpath();
if (!progpath||!*progpath)
{
print_error("error: could not build the output program path.\n");
exit(-1);
}
//printf("Program Path: [%s]\n", progpath);
/* Store the arguments that will be passed to the program when executed. */
store_progargs();
/* Build and store the shell command of the executed program. */
store_shellcmd();
//printf("Program Arguments: [%s]\n", progargs);
//printf("Shell Command: [%s]\n", shellcmd);
/* Clean the program if the option was passed. */
clean_program();
/* Create the program directory. */
create_progdir();
/* Compile the CGI */
//compile_cgi();
/* Begin the compile process. */
begin_compile();
/* Make sure the correct working directory is selected. */
change_working_directory();
/* Here it is. This is what we have been waiting for. */
//TIMESTART();
execute_final_program();
//TIMEEND();
return fretval;
}
