websrvr.c

/* websrvr.c */

/* Synchronet Web Server */

/* $Id$ */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
 * Copyright 2000 Rob Swindell - http://www.synchro.net/copyright.html		*
 *																			*
 * This program is free software; you can redistribute it and/or			*
 * modify it under the terms of the GNU General Public License				*
 * as published by the Free Software Foundation; either version 2			*
 * of the License, or (at your option) any later version.					*
 * See the GNU General Public License for more details: gpl.txt or			*
 * http://www.fsf.org/copyleft/gpl.html										*
 *																			*
 * Anonymous FTP access to the most recent released source is available at	*
 * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net	*
 *																			*
 * Anonymous CVS access to the development source and modification history	*
 * is available at cvs.synchro.net:/cvsroot/sbbs, example:					*
 * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login			*
 *     (just hit return, no password is necessary)							*
 * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src		*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * You are encouraged to submit any modifications (preferably in Unix diff	*
 * format) via e-mail to mods@synchro.net									*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

#if defined(__unix__)
	#include <sys/wait.h>		/* waitpid() */
#endif

#include "sbbs.h"
#include "sockwrap.h"		/* sendfilesocket() */
#include "threadwrap.h"		/* _beginthread() */
#include "websrvr.h"

static const char*	server_name="Synchronet Web Server";
static const char*	newline="\r\n";
static const char*	http_scheme="http://";
static const size_t	http_scheme_len=7;

extern const uchar* nular;

#define TIMEOUT_THREAD_WAIT		60		/* Seconds */
#define MAX_MIME_TYPES			128
#define MAX_REQUEST_LINE		1024
#define CGI_ENVIRON_BLOCK_SIZE	10
#define CGI_HEADS_BLOCK_SIZE	5		/* lines */
#define MAX_ENCODINGS			32		/* Becomes bit-flags in a DWORD */

static scfg_t	scfg;
static BOOL		scfg_reloaded=TRUE;
static uint 	http_threads_running=0;
static ulong	active_clients=0;
static ulong	sockets=0;
static BOOL		recycle_server=FALSE;
static uint		thread_count=0;
static SOCKET	server_socket=INVALID_SOCKET;
static ulong	mime_count=0;
static int		enc_count=0;
static char		revision[16];
static char		root_dir[MAX_PATH+1];
static char		error_dir[MAX_PATH+1];
static web_startup_t* startup=NULL;

typedef struct  {
	BOOL	method;
	char	virtual_path[MAX_PATH+1];
	char	physical_path[MAX_PATH+1];
	BOOL	parsed_headers;
	BOOL    expect_go_ahead;
	time_t	if_modified_since;
	BOOL	keep_alive;
	char	ars[256];
	char    auth[128];				/* UserID:Password */
	char	host[128];				/* The requested host. (virtual hosts) */
	int		send_location;
	char**	cgi_env;
	uint	cgi_env_size;
	uint	cgi_env_max_size;
	char**	cgi_heads;
	uint	cgi_heads_size;
	uint	cgi_heads_max_size;
	char	cgi_infile[128];
	char	cgi_location[MAX_REQUEST_LINE];
	char	cgi_status[MAX_REQUEST_LINE];
	DWORD	accept_encodings;
	int		encoded_as;
	BOOL	was_cgi;
	const char*	mime_type;
} http_request_t;

typedef struct  {
	SOCKET			socket;
	SOCKADDR_IN		addr;
	http_request_t	req;
	char			host_ip[64];
	char			host_name[128];	/* Resolved remote host */
	int				http_ver;       /* HTTP version.  0 = HTTP/0.9, 1=HTTP/1.0, 2=HTTP/1.1 */
	BOOL			finished;		/* Do not accept any more imput from client */
	char			useragent[MAX_REQUEST_LINE];
} http_session_t;

typedef struct {
	char	ext[16];
	char	type[128];
} mime_types_t;

typedef struct {
	char	name[64];
	char	encode[128];
	char	decode[128];
	char	file[128];
} encode_types_t;

static mime_types_t		mime_types[MAX_MIME_TYPES];
static encode_types_t	encode_types[MAX_ENCODINGS];

enum { 
	 HTTP_0_9
	,HTTP_1_0
	,HTTP_1_1
};
static char* http_vers[] = {
	 ""
	,"HTTP/1.0"
	,"HTTP/1.1"
	,NULL	/* terminator */
};

enum { 
	 HTTP_HEAD
	,HTTP_GET
};

static char* methods[] = {
	 "HEAD"
	,"GET"
	,"POST"
	,NULL	/* terminator */
};

enum { 
	 HEAD_ALLOW
	,HEAD_AUTH
	,HEAD_ENCODE
	,HEAD_LENGTH
	,HEAD_TYPE
	,HEAD_DATE
	,HEAD_EXPIRES
	,HEAD_FROM
	,HEAD_IFMODIFIED
	,HEAD_LASTMODIFIED
	,HEAD_LOCATION
	,HEAD_PRAGMA
	,HEAD_REFERER
	,HEAD_SERVER
	,HEAD_USERAGENT
	,HEAD_WWWAUTH
	,HEAD_CONNECTION
	,HEAD_HOST
	,HEAD_STATUS
	,HEAD_ACCEPT_ENCODING
};

static struct {
	int		id;
	char*	text;
} headers[] = {
	{ HEAD_ALLOW,			"Allow"					},
	{ HEAD_AUTH,			"Authorization"			},
	{ HEAD_ENCODE,			"Content-Encoding"		},
	{ HEAD_LENGTH,			"Content-Length"		},
	{ HEAD_TYPE,			"Content-Type"			},
	{ HEAD_DATE,			"Date"					},
	{ HEAD_EXPIRES,			"Expires"				},
	{ HEAD_FROM,			"From"					},
	{ HEAD_IFMODIFIED,		"If-Modified-Since"		},
	{ HEAD_LASTMODIFIED,	"Last-Modified"			},
	{ HEAD_LOCATION,		"Location"				},
	{ HEAD_PRAGMA,			"Pragma"				},
	{ HEAD_REFERER,			"Referer"				},
	{ HEAD_SERVER,			"Server"				},
	{ HEAD_USERAGENT,		"User-Agent"			},
	{ HEAD_WWWAUTH,			"WWW-Authenticate"		},
	{ HEAD_CONNECTION,		"Connection"			},
	{ HEAD_HOST,			"Host"					},
	{ HEAD_STATUS,			"Status"				},
	{ HEAD_ACCEPT_ENCODING,	"Accept-Encoding"		},
	{ -1,				NULL /* terminator */	},
};

enum  {
	NO_LOCATION
	,MOVED_TEMP
	,MOVED_PERM
};

static char	*days[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
static char	*months[]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

static const char * base64alphabet = 
 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

static DWORD monthdays[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};

static void respond(http_session_t * session);

static time_t time_gm( struct tm* ti )  {
	time_t t;

	t=(ti->tm_year-70)*365;
	t+=(ti->tm_year-69)/4;
	t+=monthdays[ti->tm_mon];
	if(ti->tm_mon >= 2 && ti->tm_year+1900%400 ? (ti->tm_year+1900%100 ? (ti->tm_year+1900%4 ? 0:1):0):1)
		++t;
	t += ti->tm_mday - 1;
	t = t * 24 + ti->tm_hour;
	t = t * 60 + ti->tm_min;
	t = t * 60 + ti->tm_sec;

	return t;
}

static int lprintf(char *fmt, ...)
{
	va_list argptr;
	char sbuf[1024];

    if(startup==NULL || startup->lputs==NULL)
        return(0);

	va_start(argptr,fmt);
    vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
	sbuf[sizeof(sbuf)-1]=0;
    va_end(argptr);
    return(startup->lputs(sbuf));
}

#ifdef _WINSOCKAPI_

static WSADATA WSAData;
static BOOL WSAInitialized=FALSE;

static BOOL winsock_startup(void)
{
	int		status;             /* Status Code */

    if((status = WSAStartup(MAKEWORD(1,1), &WSAData))==0) {
		lprintf("%s %s",WSAData.szDescription, WSAData.szSystemStatus);
		WSAInitialized=TRUE;
		return (TRUE);
	}

    lprintf("!WinSock startup ERROR %d", status);
	return (FALSE);
}

#else /* No WINSOCK */

#define winsock_startup()	(TRUE)

#endif

static void status(char* str)
{
	if(startup!=NULL && startup->status!=NULL)
	    startup->status(str);
}

static void update_clients(void)
{
	if(startup!=NULL && startup->clients!=NULL)
		startup->clients(active_clients);
}

static void client_on(SOCKET sock, client_t* client, BOOL update)
{
	if(startup!=NULL && startup->client_on!=NULL)
		startup->client_on(TRUE,sock,client,update);
}

static void client_off(SOCKET sock)
{
	if(startup!=NULL && startup->client_on!=NULL)
		startup->client_on(FALSE,sock,NULL,FALSE);
}

static void thread_up(BOOL setuid)
{
	thread_count++;
	if(startup!=NULL && startup->thread_up!=NULL)
		startup->thread_up(TRUE, setuid);
}

static void thread_down(void)
{
	if(thread_count>0)
		thread_count--;
	if(startup!=NULL && startup->thread_up!=NULL)
		startup->thread_up(FALSE, FALSE);
}

static void grow_enviro(http_session_t *session)  {
	char **new_cgi_env;

	new_cgi_env=session->req.cgi_env;
	new_cgi_env=realloc(session->req.cgi_env,
		sizeof(void*)*(CGI_ENVIRON_BLOCK_SIZE+session->req.cgi_env_max_size));
	if(new_cgi_env != NULL)  {
		session->req.cgi_env=new_cgi_env;
		memset(session->req.cgi_env+sizeof(void*)*session->req.cgi_env_max_size,0,
			sizeof(void*)*(CGI_ENVIRON_BLOCK_SIZE));
		session->req.cgi_env_max_size+=CGI_ENVIRON_BLOCK_SIZE;
	} else  {
		lprintf("%04d Cannot enlarge environment",session->socket);
	}
	return;
}

static void add_env(http_session_t *session, const char *name,const char *value)  {
	char	newname[128];
	char	*p;
	
	if(name==NULL || value==NULL)  {
		lprintf("%04d Attempt to set NULL env variable", session->socket);
		return;
	}
	SAFECOPY(newname,name);

	for(p=newname;*p;p++)  {
		*p=toupper(*p);
		if(*p=='-')
			*p='_';
	}
	if(session->req.cgi_env_size==session->req.cgi_env_max_size-1)
		grow_enviro(session);
		
	if(session->req.cgi_env_size<session->req.cgi_env_max_size)  {
		session->req.cgi_env[session->req.cgi_env_size]=
			malloc(sizeof(char)*(strlen(newname)+strlen(value)+2));
		if(session->req.cgi_env[session->req.cgi_env_size] != NULL)  {
			sprintf(session->req.cgi_env[session->req.cgi_env_size++],"%s=%s",
				newname,value);
			session->req.cgi_env[session->req.cgi_env_size]=NULL;
		}
	}
}

static void init_enviro(http_session_t *session)  {
	char	str[128];

	session->req.cgi_env=malloc(sizeof(void*)*CGI_ENVIRON_BLOCK_SIZE);
	if(session->req.cgi_env != NULL)  {
		memset(session->req.cgi_env,0,sizeof(void*)*CGI_ENVIRON_BLOCK_SIZE);
		session->req.cgi_env_max_size=CGI_ENVIRON_BLOCK_SIZE;
	} else  {
		lprintf("%04d Cannot create environment",session->socket);
		session->req.cgi_env_max_size=0;
	}
	/* Need a better way of doing this! */
	add_env(session,"SERVER_SOFTWARE",VERSION_NOTICE);
	sprintf(str,"%d",startup->port);
	add_env(session,"SERVER_PORT",str);
	add_env(session,"GATEWAY_INTERFACE","CGI/1.1");
	if(!strcmp(session->host_name,"<no name>"))
		add_env(session,"REMOTE_HOST",session->host_name);
	add_env(session,"REMOTE_ADDR",session->host_ip);
}

static void grow_heads(http_session_t *session)  {
	char **new_cgi_heads;

	new_cgi_heads=session->req.cgi_heads;
	new_cgi_heads=realloc(session->req.cgi_heads,
		sizeof(void*)*(CGI_HEADS_BLOCK_SIZE+session->req.cgi_heads_max_size));
	if(new_cgi_heads != NULL)  {
		session->req.cgi_heads=new_cgi_heads;
		memset(session->req.cgi_heads+sizeof(void*)*session->req.cgi_heads_max_size,0,
			sizeof(void*)*(CGI_HEADS_BLOCK_SIZE));
		session->req.cgi_heads_max_size+=CGI_HEADS_BLOCK_SIZE;
	} else  {
		lprintf("%04d Cannot enlarge headroom",session->socket);
	}
	return;
}

static void add_head(http_session_t *session, const char *value)  {
	if(value==NULL)  {
		lprintf("%04d Attempt to set NULL header", session->socket);
		return;
	}

	if(session->req.cgi_heads_size==session->req.cgi_heads_max_size-1)
		grow_heads(session);
		
	if(session->req.cgi_heads_size<session->req.cgi_heads_max_size)  {
		session->req.cgi_heads[session->req.cgi_heads_size]=
			malloc(sizeof(char)*(strlen(value)));
		if(session->req.cgi_heads[session->req.cgi_heads_size] != NULL)  {
			sprintf(session->req.cgi_heads[session->req.cgi_heads_size++],"%s",value);
			session->req.cgi_heads[session->req.cgi_heads_size]=NULL;
			lprintf("%04d Added header: %s",session->socket,value);
		}
	}
}

static void init_heads(http_session_t *session)  {
	session->req.cgi_heads=malloc(sizeof(void*)*CGI_HEADS_BLOCK_SIZE);
	if(session->req.cgi_heads != NULL)  {
		memset(session->req.cgi_heads,0,sizeof(void*)*CGI_HEADS_BLOCK_SIZE);
		session->req.cgi_heads_max_size=CGI_HEADS_BLOCK_SIZE;
	} else  {
		lprintf("%04d Cannot create headers",session->socket);
		session->req.cgi_heads_max_size=0;
	}
	return;
}

static BOOL is_cgi(http_session_t *session)  {

#ifdef __unix__
	/* NOTE: (From the FreeBSD man page) 
	   "Access() is a potential security hole and should never be used." */
	if(!access(session->req.physical_path,X_OK))
		return(TRUE);
#endif
	return(FALSE);	
}

static int sockprintf(SOCKET sock, char *fmt, ...)
{
	int		len;
	int		result;
	va_list argptr;
	char	sbuf[1024];
	fd_set	socket_set;
	struct timeval tv;

    va_start(argptr,fmt);
    len=vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
	sbuf[sizeof(sbuf)-1]=0;
	if(startup->options&WEB_OPT_DEBUG_TX)
		lprintf("%04d TX: %s", sock, sbuf);
	strcat(sbuf,newline);
	len+=2;
    va_end(argptr);

	if(sock==INVALID_SOCKET) {
		lprintf("!INVALID SOCKET in call to sockprintf");
		return(0);
	}

	/* Check socket for writability (using select) */
	tv.tv_sec=60;
	tv.tv_usec=0;

	FD_ZERO(&socket_set);
	FD_SET(sock,&socket_set);

	if((result=select(sock+1,NULL,&socket_set,NULL,&tv))<1) {
		lprintf("%04d !ERROR %d (%d) selecting socket for send"
			,sock, result, ERROR_VALUE, sock);
		return(0);
	}

	while((result=sendsocket(sock,sbuf,len))!=len) {
		if(result==SOCKET_ERROR) {
			if(ERROR_VALUE==EWOULDBLOCK) {
				mswait(1);
				continue;
			}
			if(ERROR_VALUE==ECONNRESET) 
				lprintf("%04d Connection reset by peer on send",sock);
			else if(ERROR_VALUE==ECONNABORTED) 
				lprintf("%04d Connection aborted by peer on send",sock);
			else
				lprintf("%04d !ERROR %d sending on socket",sock,ERROR_VALUE);
			return(0);
		}
		lprintf("%04d !ERROR: short send on socket: %d instead of %d",sock,result,len);
	}
	return(len);
}

static int getmonth(char *mon)
{
	int	i;
	for(i=0;i<12;i++)
		if(!stricmp(mon,months[i]))
			return(i);

	return 0;
}

static time_t decode_date(char *date)
{
	struct	tm	ti;
	char	*token;
	time_t	t;

	ti.tm_sec=0;		/* seconds (0 - 60) */
	ti.tm_min=0;		/* minutes (0 - 59) */
	ti.tm_hour=0;		/* hours (0 - 23) */
	ti.tm_mday=1;		/* day of month (1 - 31) */
	ti.tm_mon=0;		/* month of year (0 - 11) */
	ti.tm_year=0;		/* year - 1900 */
	ti.tm_isdst=0;		/* is summer time in effect? */

#if 0	/* non-standard */
	ti.tm_zone="UTC";	/* abbreviation of timezone name */
	ti.tm_gmtoff=0;		/* offset from UTC in seconds */
#endif

/**	lprintf("Parsing date: %s",date); **/
	token=strtok(date,",");
	/* This probobly only needs to be 9, but the extra one is for luck. */
	if(strlen(date)>15) {
		/* asctime() */
		//lprintf("asctime() Date: %s",token);
		/* Toss away week day */
		token=strtok(date," ");
		token=strtok(NULL," ");
		if(token==NULL)
			return(0);
		//lprintf("Month: %s",token);
		ti.tm_mon=getmonth(token);
		token=strtok(NULL," ");
		if(token==NULL)
			return(0);
		//lprintf("MDay: %s",token);
		ti.tm_mday=atoi(token);
		token=strtok(NULL,":");
		if(token==NULL)
			return(0);
		//lprintf("Hour: %s",token);
		ti.tm_hour=atoi(token);
		token=strtok(NULL,":");
		if(token==NULL)
			return(0);
		//lprintf("Minute: %s",token);
		ti.tm_min=atoi(token);
		token=strtok(NULL," ");
		if(token==NULL)
			return(0);
		//lprintf("Second: %s",token);
		ti.tm_sec=atoi(token);
		token=strtok(NULL,"");
		if(token==NULL)
			return(0);
		//lprintf("Year: %s",token);
		ti.tm_year=atoi(token)-1900;
	}
	else  {
		/* RFC 1123 or RFC 850 */
		//lprintf("RFC Date");
		token=strtok(NULL," -");
		if(token==NULL)
			return(0);
		//lprintf("MDay: %s",token);
		ti.tm_mday=atoi(token);
		token=strtok(NULL," -");
		if(token==NULL)
			return(0);
		//lprintf("Month: %s",token);
		ti.tm_mon=getmonth(token);
		token=strtok(NULL," ");
		if(token==NULL)
			return(0);
		//lprintf("Year: %s",token);
		ti.tm_year=atoi(token);
		token=strtok(NULL,":");
		if(token==NULL)
			return(0);
		//lprintf("Hour: %s",token);
		ti.tm_hour=atoi(token);
		token=strtok(NULL,":");
		if(token==NULL)
			return(0);
		//lprintf("Min: %s",token);
		ti.tm_min=atoi(token);
		token=strtok(NULL," ");
		if(token==NULL)
			return(0);
		//lprintf("Sec: %s",token);
		ti.tm_sec=atoi(token);
		if(ti.tm_year>1900)
			ti.tm_year -= 1900;
	}

	t=time_gm(&ti);
/**	lprintf("Parsed date as: %d",t); **/
	return(t);
}

static SOCKET open_socket(int type)
{
	char	error[256];
	SOCKET	sock;

	sock=socket(AF_INET, type, IPPROTO_IP);
	if(sock!=INVALID_SOCKET && startup!=NULL && startup->socket_open!=NULL) 
		startup->socket_open(TRUE);
	if(sock!=INVALID_SOCKET) {
		if(set_socket_options(&scfg, sock,error))
			lprintf("%04d !ERROR %s",sock,error);

		sockets++;
	}
	return(sock);
}


static int close_socket(SOCKET sock)
{
	int		result;

	if(sock==INVALID_SOCKET)
		return(-1);

	shutdown(sock,SHUT_RDWR);	/* required on Unix */
	result=closesocket(sock);
	if(startup!=NULL && startup->socket_open!=NULL) {
		startup->socket_open(FALSE);
	}
	sockets--;
	if(result!=0) {
		if(ERROR_VALUE!=ENOTSOCK)
			lprintf("%04d !ERROR %d closing socket",sock, ERROR_VALUE);
	}

	return(result);
}

static void close_request(http_session_t * session)
{
	uint i;
	
	
	if(session->req.cgi_heads_size)  {
		for(i=0;i<session->req.cgi_heads_size;i++)
			FREE_AND_NULL(session->req.cgi_heads[i]);
		FREE_AND_NULL(session->req.cgi_heads);
		session->req.cgi_heads_size=0;
	}
	
	if(session->req.cgi_env_size)  {
		for(i=0;i<session->req.cgi_env_size;i++)
			FREE_AND_NULL(session->req.cgi_env[i]);
		FREE_AND_NULL(session->req.cgi_env);
		session->req.cgi_env_size=0;
	}

	if(!session->req.keep_alive) {
		close_socket(session->socket);
		session->socket=INVALID_SOCKET;
		session->finished=TRUE;
	}
}

static int get_header_type(char *header)
{
	int i;
	for(i=0; headers[i].text!=NULL; i++) {
		if(!stricmp(header,headers[i].text)) {
			return(headers[i].id);
		}
	}
	return(-1);
}

static char *get_header(int id) 
{
	int i;

	for(i=0;headers[i].text!=NULL;i++) {
		if(headers[i].id==id) {
			return(headers[i].text);
		}
	}
	return(NULL);
}

static const char* unknown_mime_type="application/octet-stream";

static const char* get_mime_type(char *ext)
{
	uint i;

	lprintf("Getting mime-type for %s",ext);
	if(ext==NULL)
		return(unknown_mime_type);

	for(i=0;i<mime_count;i++)
		if(!stricmp(ext+1,mime_types[i].ext))
			return(mime_types[i].type);

	return(unknown_mime_type);
}

static BOOL send_headers(http_session_t *session, const char *status)
{
	int		ret,i;
	BOOL	send_file=TRUE;
	time_t	ti;
	char	status_line[MAX_REQUEST_LINE];
	struct stat	stats;
	struct tm	*t;

	SAFECOPY(status_line,status);
	ret=stat(session->req.physical_path,&stats);
	if(!ret && (stats.st_mtime < session->req.if_modified_since)) {
		SAFECOPY(status_line,"304 Not Modified");
		ret=-1;
		send_file=FALSE;
		lprintf("%04d Not modified",session->socket);
	}
	if(session->req.send_location==MOVED_PERM)  {
		SAFECOPY(status_line,"301 Moved Permanently");
		ret=-1;
		send_file=FALSE;
		lprintf("%04d Moved Permanently",session->socket);
	}
	if(session->req.send_location==MOVED_TEMP)  {
		SAFECOPY(status_line,"302 Moved Temporarily");
		ret=-1;
		send_file=FALSE;
		lprintf("%04d Moved Temporarily",session->socket);
	}
	/* Status-Line */
	sockprintf(session->socket,"%s %s",http_vers[session->http_ver],status_line);

	/* General Headers */
	ti=time(NULL);
	t=gmtime(&ti);
	sockprintf(session->socket,"%s: %s, %02d %s %04d %02d:%02d:%02d GMT",get_header(HEAD_DATE),days[t->tm_wday],t->tm_mday,months[t->tm_mon],t->tm_year+1900,t->tm_hour,t->tm_min,t->tm_sec);
	if(session->req.keep_alive)
		sockprintf(session->socket,"%s: %s",get_header(HEAD_CONNECTION),"Keep-Alive");
	else
		sockprintf(session->socket,"%s: %s",get_header(HEAD_CONNECTION),"Close");

	/* Response Headers */
	sockprintf(session->socket,"%s: %s",get_header(HEAD_SERVER),VERSION_NOTICE);
	

	/* Entity Headers */
	if(session->req.was_cgi)
		sockprintf(session->socket,"%s: %s",get_header(HEAD_ALLOW),"GET, HEAD, POST");
	else
		sockprintf(session->socket,"%s: %s",get_header(HEAD_ALLOW),"GET, HEAD");

	if(session->req.send_location) {
		if(!strnicmp(session->req.physical_path,http_scheme,http_scheme_len))  {
			lprintf("%04d Sending location as %s",session->socket,session->req.virtual_path);
			sockprintf(session->socket,"%s: %s",get_header(HEAD_LOCATION),(session->req.virtual_path));
		} else  {
			sockprintf(session->socket,"%s: %s",get_header(HEAD_LOCATION),(session->req.virtual_path));
			lprintf("%04d Sending location as %s",session->socket,session->req.virtual_path);
		}
	}
	if(!ret) {
		if(session->req.encoded_as>=0)
			sockprintf(session->socket,"%s: %s"
				,get_header(HEAD_ENCODE),encode_types[session->req.encoded_as].name);
		sockprintf(session->socket,"%s: %d",get_header(HEAD_LENGTH),stats.st_size);
		lprintf("%04d Sending stats for: %s",session->socket,session->req.physical_path);

		if(!session->req.was_cgi)
			sockprintf(session->socket,"%s: %s",get_header(HEAD_TYPE)
				,session->req.mime_type);

		t=gmtime(&stats.st_mtime);
		sockprintf(session->socket,"%s: %s, %02d %s %04d %02d:%02d:%02d GMT"
			,get_header(HEAD_LASTMODIFIED)
			,days[t->tm_wday],t->tm_mday,months[t->tm_mon]
			,t->tm_year+1900,t->tm_hour,t->tm_min,t->tm_sec);
	} else 
		sockprintf(session->socket,"%s: 0",get_header(HEAD_LENGTH));

	if(session->req.was_cgi)  {
		/* CGI-generated headers */
		for(i=0;session->req.cgi_heads[i]!=NULL;i++)  {
			sockprintf(session->socket,"%s",session->req.cgi_heads[i]);
			lprintf("%04d Sending header: %s",session->socket,session->req.cgi_heads[i]);
		}
	}

	/* This could probobly be combined with the CGI-generated headers - ToDo */
	for(i=0;i<session->req.cgi_heads_size;i++)
		FREE_AND_NULL(session->req.cgi_heads[i]);
	FREE_AND_NULL(session->req.cgi_heads);
	session->req.cgi_heads_size=0;

	sendsocket(session->socket,newline,2);
	return(send_file);
}

static void sock_sendfile(SOCKET socket,char *path)
{
	int		file;

	lprintf("%04d Sending %s",socket,path);
	if((file=open(path,O_RDONLY|O_BINARY))==-1)
		lprintf("%04d !ERROR %d opening %s",socket,errno,path);
	else {
		if(sendfilesocket(socket, file, 0, 0) < 1)
			lprintf("%04d !ERROR %d sending %s"
				, socket, errno, path);
		close(file);
		/* sendfilesocket() does not close() */
	}
}

static int	get_best_encoding(http_session_t *session)  {
	/* Essentially, get the lowest set bit from accept_encodings */
	int	i=0;
	
	if(session->req.accept_encodings)  {
		for(i=0;i<enc_count;)  {
			if(session->req.accept_encodings&(1<<i))
				break;
			i++;
		}
		if(i==enc_count)
			return(-1);
		lprintf("%04d Best encoding is %s (%d)",session->socket,encode_types[i].name,i);
		return(i);
	}
	return(-1);
}

static BOOL apply_encoding(http_session_t *session)  {
	int				encoding=0;
	char			path[MAX_PATH+1];
	char			command[MAX_PATH+1];
	struct stat		orig_s;
	struct stat		enc_s;


	encoding=get_best_encoding(session);

	/* Hack for Mozilla 4.* browsers apparently broken Content-Encoding */
	if(!strncmp(session->useragent,"Mozilla/4",9))
		encoding=-1;
		
	lprintf("%04d Applying encoding %s to %s",session->socket,encode_types[encoding].name,session->req.physical_path);
	session->req.mime_type=get_mime_type(strrchr(session->req.physical_path,'.'));
	
	if(encoding!=-1)  {
		sprintf(path,encode_types[encoding].file,session->req.physical_path);
		lprintf("%04d Encoded file is: %s",session->socket,path);
		/* Check if has already been encoded */
		if(fexist(path))  {
			stat(session->req.physical_path,&orig_s);
			stat(path,&enc_s);
			if(orig_s.st_mtime>enc_s.st_mtime)  {
				/* Do encoding */
				sprintf(command,encode_types[encoding].encode,session->req.physical_path,session->req.physical_path);
				lprintf("%04d Encoding command: %s",session->socket,command);
				system(command);
			}
		}
		else  {
			/* Do encoding */
			sprintf(command,encode_types[encoding].encode,session->req.physical_path,session->req.physical_path);
			lprintf("%04d Encoding command: %s",session->socket,command);
			system(command);
		}
		if(fexist(path))  {
			SAFECOPY(session->req.physical_path,path);
			session->req.encoded_as=encoding;
			return(TRUE);
		}
		lprintf("%04d Encoding FAILED! %s",session->socket,encode_types[encoding].name);
		session->req.encoded_as=-1;
		return(FALSE);
	}
	session->req.encoded_as=encoding;
	return(TRUE);
}

static void send_error(http_session_t * session, char *message)
{
	char	error_code[4];

	lprintf("%04d !ERROR %s",session->socket,message);
	session->req.send_location=NO_LOCATION;
	SAFECOPY(error_code,message);
	sprintf(session->req.physical_path,"%s/%s.html",error_dir,error_code);
	if(session->http_ver > HTTP_0_9)  {
		apply_encoding(session);
		send_headers(session,message);
	}
	if(fexist(session->req.physical_path))
		sock_sendfile(session->socket,session->req.physical_path);
	else
		lprintf("%04d Error message file %s doesn't exist.",session->socket,session->req.physical_path);
	close_request(session);
}

static BOOL check_ars(http_session_t * session)
{
	char	*username;
	char	*password;
	uchar	*ar;
	user_t	user;
	BOOL	authorized;

	if(session->req.auth[0]==0) {
		lprintf("%04d !No authentication information",session->socket);
		return(FALSE);
	}

	username=strtok(session->req.auth,":");
	password=strtok(NULL,":");
	/* Require a password */
	if(password==NULL)
		password="";
	user.number=matchuser(&scfg, username, FALSE);
	if(user.number==0) {
		if(scfg.sys_misc&SM_ECHO_PW)
			lprintf("%04d !UNKNOWN USER: %s, Password: %s"
				,session->socket,username,password);
		else
			lprintf("%04d !UNKNOWN USER: %s"
				,session->socket,username);
		return(FALSE);
	}
	lprintf("%04d User number: %d",session->socket,user.number);
	getuserdat(&scfg, &user);
	if(user.pass[0] && stricmp(user.pass,password)) {
		/* Should go to the hack log? */
		if(scfg.sys_misc&SM_ECHO_PW)
			lprintf("%04d !PASSWORD FAILURE for user %s: '%s' expected '%s'"
				,session->socket,username,password,user.pass);
		else
			lprintf("%04d !PASSWORD FAILURE for user %s"
				,session->socket,username);
		return(FALSE);
	}
	ar = arstr(NULL,session->req.ars,&scfg);
	authorized=chk_ar(&scfg,ar,&user);
	if(ar!=NULL && ar!=nular)
		free(ar);

	if(authorized)  {
		add_env(session,"AUTH_TYPE","Basic");
		/* Should use name if set to do so somewhere ToDo */
		add_env(session,"REMOTE_USER",user.alias);
		return(TRUE);
	}

	/* Should go to the hack log? */
	lprintf("%04d !AUTHORIZATION FAILURE for user %s, ARS: %s"
		,session->socket,username,session->req.ars);

	return(FALSE);
}

static void b64_decode(uchar *p)
{
	uchar	*read;
	uchar	*write;
	int		bits=0;
	int		working=0;
	char *	i;

	write=p;
	read=write;
	lprintf("B64 Decoding: %s",p);
	for(;*read;read++) {
		working<<=6;
		i=strchr(base64alphabet,(char)*read);
		if(i==NULL) {
			break;
		}
		if(*i=='=') i=(char*)base64alphabet; /* pad char */
		working |= (i-base64alphabet);
		bits+=6;
		if(bits>8) {
			*(write++)=(uchar)((working&(0xFF<<(bits-8)))>>(bits-8));
			bits-=8;
		}
	}
	*write=0;
	lprintf("B64 Decoded: %s",p);
	return;
}

static BOOL read_mime_types(char* fname)