embedaddon/lighttpd/src/mod_ssi.c - diff

Return to mod_ssi.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

Diff for /embedaddon/lighttpd/src/mod_ssi.c between versions 1.1 and 1.1.1.3

version 1.1, 2013/10/14 10:32:48	version 1.1.1.3, 2016/11/02 10:35:00
Line 1	Line 1
	#include "first.h"

#include "base.h"	#include "base.h"
#include "log.h"	#include "log.h"
#include "buffer.h"	#include "buffer.h"
#include "stat_cache.h"

#include "plugin.h"	#include "plugin.h"
#include "stream.h"	#include "stream.h"
Line 20	Line 21
#include <stdlib.h>	#include <stdlib.h>
#include <stdio.h>	#include <stdio.h>
#include <string.h>	#include <string.h>
	#include <strings.h>
#include <errno.h>	#include <errno.h>
	#include <fcntl.h>
#include <time.h>	#include <time.h>
#include <unistd.h>	#include <unistd.h>

Line 37	Line 40
#endif	#endif

#include "etag.h"	#include "etag.h"
#include "version.h"

/* The newest modified time of included files for include statement */	/* The newest modified time of included files for include statement */
static volatile time_t include_file_last_mtime = 0;	static volatile time_t include_file_last_mtime = 0;
Line 69 FREE_FUNC(mod_ssi_free) {	Line 71 FREE_FUNC(mod_ssi_free) {
for (i = 0; i < srv->config_context->used; i++) {	for (i = 0; i < srv->config_context->used; i++) {
plugin_config *s = p->config_storage[i];	plugin_config *s = p->config_storage[i];

	if (NULL == s) continue;

array_free(s->ssi_extension);	array_free(s->ssi_extension);
buffer_free(s->content_type);	buffer_free(s->content_type);

Line 79 FREE_FUNC(mod_ssi_free) {	Line 83 FREE_FUNC(mod_ssi_free) {

array_free(p->ssi_vars);	array_free(p->ssi_vars);
array_free(p->ssi_cgi_env);	array_free(p->ssi_cgi_env);
#ifdef HAVE_PCRE_H
pcre_free(p->ssi_regex);
#endif
buffer_free(p->timefmt);	buffer_free(p->timefmt);
buffer_free(p->stat_fn);	buffer_free(p->stat_fn);

Line 95 FREE_FUNC(mod_ssi_free) {	Line 96 FREE_FUNC(mod_ssi_free) {
SETDEFAULTS_FUNC(mod_ssi_set_defaults) {	SETDEFAULTS_FUNC(mod_ssi_set_defaults) {
plugin_data *p = p_d;	plugin_data *p = p_d;
size_t i = 0;	size_t i = 0;
#ifdef HAVE_PCRE_H
const char *errptr;
int erroff;
#endif

config_values_t cv[] = {	config_values_t cv[] = {
{ "ssi.extension", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 0 */	{ "ssi.extension", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
{ "ssi.content-type", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 1 */	{ "ssi.content-type", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
	{ "ssi.conditional-requests", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
	{ "ssi.exec", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 3 */
{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }	{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
};	};

if (!p) return HANDLER_ERROR;	if (!p) return HANDLER_ERROR;

p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));	p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *));

for (i = 0; i < srv->config_context->used; i++) {	for (i = 0; i < srv->config_context->used; i++) {
	data_config const* config = (data_config const*)srv->config_context->data[i];
plugin_config *s;	plugin_config *s;

s = calloc(1, sizeof(plugin_config));	s = calloc(1, sizeof(plugin_config));
s->ssi_extension = array_init();	s->ssi_extension = array_init();
s->content_type = buffer_init();	s->content_type = buffer_init();
	s->conditional_requests = 0;
	s->ssi_exec = 1;

cv[0].destination = s->ssi_extension;	cv[0].destination = s->ssi_extension;
cv[1].destination = s->content_type;	cv[1].destination = s->content_type;
	cv[2].destination = &(s->conditional_requests);
	cv[3].destination = &(s->ssi_exec);

p->config_storage[i] = s;	p->config_storage[i] = s;

if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {	if (0 != config_insert_values_global(srv, config->value, cv, i == 0 ? T_CONFIG_SCOPE_SERVER : T_CONFIG_SCOPE_CONNECTION)) {
return HANDLER_ERROR;	return HANDLER_ERROR;
}	}
}	}

#ifdef HAVE_PCRE_H
/* allow 2 params */
if (NULL == (p->ssi_regex = pcre_compile("<!--#([a-z]+)\\s+(?:([a-z]+)=\"(.?)(?<!\\\\)\"\\s)?(?:([a-z]+)=\"(.?)(?<!\\\\)\"\\s)?-->", 0, &errptr, &erroff, NULL))) {
log_error_write(srv, __FILE__, __LINE__, "sds",
"ssi: pcre ",
erroff, errptr);
return HANDLER_ERROR;
}
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"mod_ssi: pcre support is missing, please recompile with pcre support or remove mod_ssi from the list of modules");
return HANDLER_ERROR;
#endif

return HANDLER_GO_ON;	return HANDLER_GO_ON;
}	}


static int ssi_env_add(array env, const char key, const char *val) {	static int ssi_env_add(array env, const char key, const char *val) {
data_string *ds;	data_string *ds;

Line 172 static int ssi_env_add_request_headers(server *srv, co	Line 163 static int ssi_env_add_request_headers(server *srv, co

ds = (data_string *)con->request.headers->data[i];	ds = (data_string *)con->request.headers->data[i];

if (ds->value->used && ds->key->used) {	if (!buffer_is_empty(ds->value) && !buffer_is_empty(ds->key)) {
size_t j;
buffer_reset(srv->tmp_buf);

/* don't forward the Authorization: Header */	/* don't forward the Authorization: Header */
if (0 == strcasecmp(ds->key->ptr, "AUTHORIZATION")) {	if (buffer_is_equal_caseless_string(ds->key, CONST_STR_LEN("Authorization"))) {
continue;	continue;
}	}

if (0 != strcasecmp(ds->key->ptr, "CONTENT-TYPE")) {	/* Do not emit HTTP_PROXY in environment.
buffer_copy_string_len(srv->tmp_buf, CONST_STR_LEN("HTTP_"));	* Some executables use HTTP_PROXY to configure
srv->tmp_buf->used--;	* outgoing proxy. See also https://httpoxy.org/ */
	if (buffer_is_equal_caseless_string(ds->key, CONST_STR_LEN("Proxy"))) {
	continue;
}	}

buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);	buffer_copy_string_encoded_cgi_varnames(srv->tmp_buf, CONST_BUF_LEN(ds->key), 1);
for (j = 0; j < ds->key->used - 1; j++) {
char c = '_';
if (light_isalpha(ds->key->ptr[j])) {
/* upper-case */
c = ds->key->ptr[j] & ~32;
} else if (light_isdigit(ds->key->ptr[j])) {
/* copy */
c = ds->key->ptr[j];
}
srv->tmp_buf->ptr[srv->tmp_buf->used++] = c;
}
srv->tmp_buf->ptr[srv->tmp_buf->used] = '\0';

ssi_env_add(p->ssi_cgi_env, srv->tmp_buf->ptr, ds->value->ptr);	ssi_env_add(p->ssi_cgi_env, srv->tmp_buf->ptr, ds->value->ptr);
}	}
Line 209 static int ssi_env_add_request_headers(server *srv, co	Line 187 static int ssi_env_add_request_headers(server *srv, co

ds = (data_string *)con->environment->data[i];	ds = (data_string *)con->environment->data[i];

if (ds->value->used && ds->key->used) {	if (!buffer_is_empty(ds->value) && !buffer_is_empty(ds->key)) {
size_t j;	buffer_copy_string_encoded_cgi_varnames(srv->tmp_buf, CONST_BUF_LEN(ds->key), 0);

buffer_reset(srv->tmp_buf);
buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);

for (j = 0; j < ds->key->used - 1; j++) {
char c = '_';
if (light_isalpha(ds->key->ptr[j])) {
/* upper-case */
c = ds->key->ptr[j] & ~32;
} else if (light_isdigit(ds->key->ptr[j])) {
/* copy */
c = ds->key->ptr[j];
}
srv->tmp_buf->ptr[srv->tmp_buf->used++] = c;
}
srv->tmp_buf->ptr[srv->tmp_buf->used] = '\0';

ssi_env_add(p->ssi_cgi_env, srv->tmp_buf->ptr, ds->value->ptr);	ssi_env_add(p->ssi_cgi_env, srv->tmp_buf->ptr, ds->value->ptr);
}	}
}	}
Line 236 static int ssi_env_add_request_headers(server *srv, co	Line 198 static int ssi_env_add_request_headers(server *srv, co
}	}

static int build_ssi_cgi_vars(server srv, connection con, plugin_data *p) {	static int build_ssi_cgi_vars(server srv, connection con, plugin_data *p) {
char buf[32];	char buf[LI_ITOSTRING_LENGTH];

server_socket *srv_sock = con->srv_socket;	server_socket *srv_sock = con->srv_socket;

Line 249 static int build_ssi_cgi_vars(server *srv, connection	Line 211 static int build_ssi_cgi_vars(server *srv, connection

array_reset(p->ssi_cgi_env);	array_reset(p->ssi_cgi_env);

ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_SOFTWARE"), PACKAGE_DESC);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_SOFTWARE"), con->conf.server_tag->ptr);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_NAME"),	ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_NAME"),
#ifdef HAVE_IPV6	#ifdef HAVE_IPV6
inet_ntop(srv_sock->addr.plain.sa_family,	inet_ntop(srv_sock->addr.plain.sa_family,
Line 263 static int build_ssi_cgi_vars(server *srv, connection	Line 225 static int build_ssi_cgi_vars(server *srv, connection
);	);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("GATEWAY_INTERFACE"), "CGI/1.1");	ssi_env_add(p->ssi_cgi_env, CONST_STRING("GATEWAY_INTERFACE"), "CGI/1.1");

LI_ltostr(buf,	li_utostrn(buf, sizeof(buf),
#ifdef HAVE_IPV6	#ifdef HAVE_IPV6
ntohs(srv_sock->addr.plain.sa_family ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)	ntohs(srv_sock->addr.plain.sa_family ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)
#else	#else
Line 279 static int build_ssi_cgi_vars(server *srv, connection	Line 241 static int build_ssi_cgi_vars(server *srv, connection
if (con->request.content_length > 0) {	if (con->request.content_length > 0) {
/* CGI-SPEC 6.1.2 and FastCGI spec 6.3 */	/* CGI-SPEC 6.1.2 and FastCGI spec 6.3 */

/* request.content_length < SSIZE_MAX, see request.c */	li_itostrn(buf, sizeof(buf), con->request.content_length);
LI_ltostr(buf, con->request.content_length);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("CONTENT_LENGTH"), buf);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("CONTENT_LENGTH"), buf);
}	}

Line 301 static int build_ssi_cgi_vars(server *srv, connection	Line 262 static int build_ssi_cgi_vars(server *srv, connection
* parameter.	* parameter.
*/	*/

if (con->request.pathinfo->used) {	if (!buffer_string_is_empty(con->request.pathinfo)) {
ssi_env_add(p->ssi_cgi_env, CONST_STRING("PATH_INFO"), con->request.pathinfo->ptr);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("PATH_INFO"), con->request.pathinfo->ptr);
}	}

ssi_env_add(p->ssi_cgi_env, CONST_STRING("SCRIPT_FILENAME"), con->physical.path->ptr);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("SCRIPT_FILENAME"), con->physical.path->ptr);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("DOCUMENT_ROOT"), con->physical.doc_root->ptr);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("DOCUMENT_ROOT"), con->physical.basedir->ptr);

ssi_env_add(p->ssi_cgi_env, CONST_STRING("REQUEST_URI"), con->request.uri->ptr);	ssi_env_add(p->ssi_cgi_env, CONST_STRING("REQUEST_URI"), con->request.uri->ptr);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("QUERY_STRING"), con->uri.query->used ? con->uri.query->ptr : "");
	if (!buffer_string_is_empty(con->uri.scheme)) {
	ssi_env_add(p->ssi_cgi_env, CONST_STRING("REQUEST_SCHEME"), con->uri.scheme->ptr);
	}

	ssi_env_add(p->ssi_cgi_env, CONST_STRING("QUERY_STRING"), buffer_is_empty(con->uri.query) ? "" : con->uri.query->ptr);
ssi_env_add(p->ssi_cgi_env, CONST_STRING("REQUEST_METHOD"), get_http_method_name(con->request.http_method));	ssi_env_add(p->ssi_cgi_env, CONST_STRING("REQUEST_METHOD"), get_http_method_name(con->request.http_method));
ssi_env_add(p->ssi_cgi_env, CONST_STRING("REDIRECT_STATUS"), "200");
ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_PROTOCOL"), get_http_version_name(con->request.http_version));	ssi_env_add(p->ssi_cgi_env, CONST_STRING("SERVER_PROTOCOL"), get_http_version_name(con->request.http_version));
	/* set REDIRECT_STATUS for php compiled with --force-redirect
	* (if REDIRECT_STATUS has not already been set by error handler) */
	if (0 == con->error_handler_saved_status) {
	ssi_env_add(p->ssi_cgi_env, CONST_STRING("REDIRECT_STATUS"), "200");
	}

ssi_env_add_request_headers(srv, con, p);	ssi_env_add_request_headers(srv, con, p);

return 0;	return 0;
}	}

static int process_ssi_stmt(server srv, connection con, plugin_data *p,	static int process_ssi_stmt(server srv, connection con, plugin_data p, const char l, size_t n, struct stat st) {
const char **l, size_t n) {
	/**
	* <!--#element attribute=value attribute=value ... -->
	*
	* config DONE
	* errmsg -- missing
	* sizefmt DONE
	* timefmt DONE
	* echo DONE
	* var DONE
	* encoding -- missing
	* exec DONE
	* cgi -- never
	* cmd DONE
	* fsize DONE
	* file DONE
	* virtual DONE
	* flastmod DONE
	* file DONE
	* virtual DONE
	* include DONE
	* file DONE
	* virtual DONE
	* printenv DONE
	* set DONE
	* var DONE
	* value DONE
	*
	* if DONE
	* elif DONE
	* else DONE
	* endif DONE
	*
	*
	* expressions
	* AND, OR DONE
	* comp DONE
	* ${...} -- missing
	* $... DONE
	* '...' DONE
	* ( ... ) DONE
	*
	*
	*
	* all DONE
	* DATE_GMT
	* The current date in Greenwich Mean Time.
	* DATE_LOCAL
	* The current date in the local time zone.
	* DOCUMENT_NAME
	* The filename (excluding directories) of the document requested by the user.
	* DOCUMENT_URI
	* The (%-decoded) URL path of the document requested by the user. Note that in the case of nested include files, this is not then URL for the current document.
	* LAST_MODIFIED
	* The last modification date of the document requested by the user.
	* USER_NAME
	* Contains the owner of the file which included it.
	*
	*/

size_t i, ssicmd = 0;	size_t i, ssicmd = 0;
char buf[255];	char buf[255];
buffer *b = NULL;	buffer *b = NULL;
Line 360 static int process_ssi_stmt(server srv, connection c	Line 389 static int process_ssi_stmt(server srv, connection c
int var = 0;	int var = 0;
/* int enc = 0; */	/* int enc = 0; */
const char *var_val = NULL;	const char *var_val = NULL;
stat_cache_entry *sce = NULL;

struct {	struct {
const char *var;	const char *var;
enum { SSI_ECHO_UNSET, SSI_ECHO_DATE_GMT, SSI_ECHO_DATE_LOCAL, SSI_ECHO_DOCUMENT_NAME, SSI_ECHO_DOCUMENT_URI,	enum {
SSI_ECHO_LAST_MODIFIED, SSI_ECHO_USER_NAME } type;	SSI_ECHO_UNSET,
	SSI_ECHO_DATE_GMT,
	SSI_ECHO_DATE_LOCAL,
	SSI_ECHO_DOCUMENT_NAME,
	SSI_ECHO_DOCUMENT_URI,
	SSI_ECHO_LAST_MODIFIED,
	SSI_ECHO_USER_NAME,
	SSI_ECHO_SCRIPT_URI,
	SSI_ECHO_SCRIPT_URL,
	} type;
} echovars[] = {	} echovars[] = {
{ "DATE_GMT", SSI_ECHO_DATE_GMT },	{ "DATE_GMT", SSI_ECHO_DATE_GMT },
{ "DATE_LOCAL", SSI_ECHO_DATE_LOCAL },	{ "DATE_LOCAL", SSI_ECHO_DATE_LOCAL },
Line 373 static int process_ssi_stmt(server srv, connection c	Line 410 static int process_ssi_stmt(server srv, connection c
{ "DOCUMENT_URI", SSI_ECHO_DOCUMENT_URI },	{ "DOCUMENT_URI", SSI_ECHO_DOCUMENT_URI },
{ "LAST_MODIFIED", SSI_ECHO_LAST_MODIFIED },	{ "LAST_MODIFIED", SSI_ECHO_LAST_MODIFIED },
{ "USER_NAME", SSI_ECHO_USER_NAME },	{ "USER_NAME", SSI_ECHO_USER_NAME },
	{ "SCRIPT_URI", SSI_ECHO_SCRIPT_URI },
	{ "SCRIPT_URL", SSI_ECHO_SCRIPT_URL },

{ NULL, SSI_ECHO_UNSET }	{ NULL, SSI_ECHO_UNSET }
};	};
Line 415 static int process_ssi_stmt(server srv, connection c	Line 454 static int process_ssi_stmt(server srv, connection c
*/	*/
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 429 static int process_ssi_stmt(server srv, connection c	Line 468 static int process_ssi_stmt(server srv, connection c
break;	break;
}	}

stat_cache_get_entry(srv, con, con->physical.path, &sce);

switch(var) {	switch(var) {
case SSI_ECHO_USER_NAME: {	case SSI_ECHO_USER_NAME: {
struct passwd *pw;	struct passwd *pw;

b = chunkqueue_get_append_buffer(con->write_queue);	b = buffer_init();
#ifdef HAVE_PWD_H	#ifdef HAVE_PWD_H
if (NULL == (pw = getpwuid(sce->st.st_uid))) {	if (NULL == (pw = getpwuid(st->st_uid))) {
buffer_copy_long(b, sce->st.st_uid);	buffer_copy_int(b, st->st_uid);
} else {	} else {
buffer_copy_string(b, pw->pw_name);	buffer_copy_string(b, pw->pw_name);
}	}
#else	#else
buffer_copy_long(b, sce->st.st_uid);	buffer_copy_int(b, st->st_uid);
#endif	#endif
	chunkqueue_append_buffer(con->write_queue, b);
	buffer_free(b);
break;	break;
}	}
case SSI_ECHO_LAST_MODIFIED: {	case SSI_ECHO_LAST_MODIFIED: {
time_t t = sce->st.st_mtime;	time_t t = st->st_mtime;

b = chunkqueue_get_append_buffer(con->write_queue);
if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {	if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {
buffer_copy_string_len(b, CONST_STR_LEN("(none)"));	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("(none)"));
} else {	} else {
buffer_copy_string(b, buf);	chunkqueue_append_mem(con->write_queue, buf, strlen(buf));
}	}
break;	break;
}	}
case SSI_ECHO_DATE_LOCAL: {	case SSI_ECHO_DATE_LOCAL: {
time_t t = time(NULL);	time_t t = time(NULL);

b = chunkqueue_get_append_buffer(con->write_queue);
if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {	if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {
buffer_copy_string_len(b, CONST_STR_LEN("(none)"));	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("(none)"));
} else {	} else {
buffer_copy_string(b, buf);	chunkqueue_append_mem(con->write_queue, buf, strlen(buf));
}	}
break;	break;
}	}
case SSI_ECHO_DATE_GMT: {	case SSI_ECHO_DATE_GMT: {
time_t t = time(NULL);	time_t t = time(NULL);

b = chunkqueue_get_append_buffer(con->write_queue);
if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, gmtime(&t))) {	if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, gmtime(&t))) {
buffer_copy_string_len(b, CONST_STR_LEN("(none)"));	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("(none)"));
} else {	} else {
buffer_copy_string(b, buf);	chunkqueue_append_mem(con->write_queue, buf, strlen(buf));
}	}
break;	break;
}	}
case SSI_ECHO_DOCUMENT_NAME: {	case SSI_ECHO_DOCUMENT_NAME: {
char *sl;	char *sl;

b = chunkqueue_get_append_buffer(con->write_queue);
if (NULL == (sl = strrchr(con->physical.path->ptr, '/'))) {	if (NULL == (sl = strrchr(con->physical.path->ptr, '/'))) {
buffer_copy_string_buffer(b, con->physical.path);	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->physical.path));
} else {	} else {
buffer_copy_string(b, sl + 1);	chunkqueue_append_mem(con->write_queue, sl + 1, strlen(sl + 1));
}	}
break;	break;
}	}
case SSI_ECHO_DOCUMENT_URI: {	case SSI_ECHO_DOCUMENT_URI: {
b = chunkqueue_get_append_buffer(con->write_queue);	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->uri.path));
buffer_copy_string_buffer(b, con->uri.path);
break;	break;
}	}
	case SSI_ECHO_SCRIPT_URI: {
	if (!buffer_string_is_empty(con->uri.scheme) && !buffer_string_is_empty(con->uri.authority)) {
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->uri.scheme));
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("://"));
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->uri.authority));
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->request.uri));
	if (!buffer_string_is_empty(con->uri.query)) {
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("?"));
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->uri.query));
	}
	}
	break;
	}
	case SSI_ECHO_SCRIPT_URL: {
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->request.uri));
	if (!buffer_string_is_empty(con->uri.query)) {
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("?"));
	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(con->uri.query));
	}
	break;
	}
default: {	default: {
data_string *ds;	data_string *ds;
/* check if it is a cgi-var */	/* check if it is a cgi-var or a ssi-var */

b = chunkqueue_get_append_buffer(con->write_queue);	if (NULL != (ds = (data_string *)array_get_element(p->ssi_cgi_env, var_val)) \|\|
	NULL != (ds = (data_string *)array_get_element(p->ssi_vars, var_val))) {
if (NULL != (ds = (data_string *)array_get_element(p->ssi_cgi_env, var_val))) {	chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(ds->value));
buffer_copy_string_buffer(b, ds->value);
} else {	} else {
buffer_copy_string_len(b, CONST_STR_LEN("(none)"));	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("(none)"));
}	}

break;	break;
Line 517 static int process_ssi_stmt(server srv, connection c	Line 571 static int process_ssi_stmt(server srv, connection c
case SSI_FLASTMOD:	case SSI_FLASTMOD:
case SSI_FSIZE: {	case SSI_FSIZE: {
const char * file_path = NULL, *virt_path = NULL;	const char * file_path = NULL, *virt_path = NULL;
struct stat st;	struct stat stb;
char *sl;	char *sl;

for (i = 2; i < n; i += 2) {	for (i = 2; i < n; i += 2) {
Line 527 static int process_ssi_stmt(server srv, connection c	Line 581 static int process_ssi_stmt(server srv, connection c
virt_path = l[i+1];	virt_path = l[i+1];
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 563 static int process_ssi_stmt(server srv, connection c	Line 617 static int process_ssi_stmt(server srv, connection c
buffer_append_string_buffer(p->stat_fn, srv->tmp_buf);	buffer_append_string_buffer(p->stat_fn, srv->tmp_buf);
} else {	} else {
/* virtual */	/* virtual */
	size_t remain;

if (virt_path[0] == '/') {	if (virt_path[0] == '/') {
buffer_copy_string(p->stat_fn, virt_path);	buffer_copy_string(p->stat_fn, virt_path);
Line 579 static int process_ssi_stmt(server srv, connection c	Line 634 static int process_ssi_stmt(server srv, connection c

/* we have an uri */	/* we have an uri */

buffer_copy_string_buffer(p->stat_fn, con->physical.doc_root);	/* Destination physical path (similar to code in mod_webdav.c)
buffer_append_string_buffer(p->stat_fn, srv->tmp_buf);	* src con->physical.path might have been remapped with mod_alias, mod_userdir.
	* (but neither modifies con->physical.rel_path)
	* Find matching prefix to support relative paths to current physical path.
	* Aliasing of paths underneath current con->physical.basedir might not work.
	* Likewise, mod_rewrite URL rewriting might thwart this comparison.
	* Use mod_redirect instead of mod_alias to remap paths under this basedir.
	* Use mod_redirect instead of mod_rewrite on any parts of path to basedir.
	* (Related, use mod_auth to protect this basedir, but avoid attempting to
	* use mod_auth on paths underneath this basedir, as target path is not
	* validated with mod_auth)
	*/

	/* find matching URI prefix
	* check if remaining con->physical.rel_path matches suffix
	* of con->physical.basedir so that we can use it to
	* remap Destination physical path */
	{
	const char sep, sep2;
	sep = con->uri.path->ptr;
	sep2 = srv->tmp_buf->ptr;
	for (i = 0; sep[i] && sep[i] == sep2[i]; ++i) ;
	while (i != 0 && sep[--i] != '/') ; /* find matching directory path */
	}
	if (con->conf.force_lowercase_filenames) {
	buffer_to_lower(srv->tmp_buf);
	}
	remain = buffer_string_length(con->uri.path) - i;
	if (!con->conf.force_lowercase_filenames
	? buffer_is_equal_right_len(con->physical.path, con->physical.rel_path, remain)
	:(buffer_string_length(con->physical.path) >= remain
	&& 0 == strncasecmp(con->physical.path->ptr+buffer_string_length(con->physical.path)-remain, con->physical.rel_path->ptr+i, remain))) {
	buffer_copy_string_len(p->stat_fn, con->physical.path->ptr, buffer_string_length(con->physical.path)-remain);
	buffer_append_string_len(p->stat_fn, srv->tmp_buf->ptr+i, buffer_string_length(srv->tmp_buf)-i);
	} else {
	/* unable to perform physical path remap here;
	* assume doc_root/rel_path and no remapping */
	buffer_copy_buffer(p->stat_fn, con->physical.doc_root);
	buffer_append_string_buffer(p->stat_fn, srv->tmp_buf);
	}
}	}

if (0 == stat(p->stat_fn->ptr, &st)) {	if (0 == stat(p->stat_fn->ptr, &stb)) {
time_t t = st.st_mtime;	time_t t = stb.st_mtime;

switch (ssicmd) {	switch (ssicmd) {
case SSI_FSIZE:	case SSI_FSIZE:
b = chunkqueue_get_append_buffer(con->write_queue);	b = buffer_init();
if (p->sizefmt) {	if (p->sizefmt) {
int j = 0;	int j = 0;
const char *abr[] = { " B", " kB", " MB", " GB", " TB", NULL };	const char *abr[] = { " B", " kB", " MB", " GB", " TB", NULL };

off_t s = st.st_size;	off_t s = stb.st_size;

for (j = 0; s > 1024 && abr[j+1]; s /= 1024, j++);	for (j = 0; s > 1024 && abr[j+1]; s /= 1024, j++);

buffer_copy_off_t(b, s);	buffer_copy_int(b, s);
buffer_append_string(b, abr[j]);	buffer_append_string(b, abr[j]);
} else {	} else {
buffer_copy_off_t(b, st.st_size);	buffer_copy_int(b, stb.st_size);
}	}
	chunkqueue_append_buffer(con->write_queue, b);
	buffer_free(b);
break;	break;
case SSI_FLASTMOD:	case SSI_FLASTMOD:
b = chunkqueue_get_append_buffer(con->write_queue);
if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {	if (0 == strftime(buf, sizeof(buf), p->timefmt->ptr, localtime(&t))) {
buffer_copy_string_len(b, CONST_STR_LEN("(none)"));	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("(none)"));
} else {	} else {
buffer_copy_string(b, buf);	chunkqueue_append_mem(con->write_queue, buf, strlen(buf));
}	}
break;	break;
case SSI_INCLUDE:	case SSI_INCLUDE:
chunkqueue_append_file(con->write_queue, p->stat_fn, 0, st.st_size);	chunkqueue_append_file(con->write_queue, p->stat_fn, 0, stb.st_size);

/* Keep the newest mtime of included files */	/* Keep the newest mtime of included files */
if (st.st_mtime > include_file_last_mtime)	if (stb.st_mtime > include_file_last_mtime)
include_file_last_mtime = st.st_mtime;	include_file_last_mtime = stb.st_mtime;

break;	break;
}	}
Line 636 static int process_ssi_stmt(server srv, connection c	Line 730 static int process_ssi_stmt(server srv, connection c
val = l[i+1];	val = l[i+1];
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 653 static int process_ssi_stmt(server srv, connection c	Line 747 static int process_ssi_stmt(server srv, connection c
buffer_copy_string(ds->value, val);	buffer_copy_string(ds->value, val);

array_insert_unique(p->ssi_vars, (data_unset *)ds);	array_insert_unique(p->ssi_vars, (data_unset *)ds);
	} else if (key \|\| val) {
	log_error_write(srv, __FILE__, __LINE__, "sSSss",
	"ssi: var and value have to be set in <!--#set", l[1], "=", l[2], "-->");
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "s",
"ssi: var and value have to be set in",	"ssi: var and value have to be set in <!--#set var=... value=... -->");
l[0], l[1]);
}	}
break;	break;
}	}
Line 669 static int process_ssi_stmt(server srv, connection c	Line 765 static int process_ssi_stmt(server srv, connection c
} else if (0 == strcmp(l[i], "sizefmt")) {	} else if (0 == strcmp(l[i], "sizefmt")) {
if (0 == strcmp(l[i+1], "abbrev")) {	if (0 == strcmp(l[i+1], "abbrev")) {
p->sizefmt = 1;	p->sizefmt = 1;
} else if (0 == strcmp(l[i+1], "abbrev")) {	} else if (0 == strcmp(l[i+1], "bytes")) {
p->sizefmt = 0;	p->sizefmt = 0;
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sssss",	log_error_write(srv, __FILE__, __LINE__, "sssss",
"ssi: unknow value for attribute '",	"ssi: unknown value for attribute '",
l[i],	l[i],
"' for ",	"' for ",
l[1], l[i+1]);	l[1], l[i+1]);
}	}
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 688 static int process_ssi_stmt(server srv, connection c	Line 784 static int process_ssi_stmt(server srv, connection c
case SSI_PRINTENV:	case SSI_PRINTENV:
if (p->if_is_false) break;	if (p->if_is_false) break;

b = chunkqueue_get_append_buffer(con->write_queue);	b = buffer_init();
for (i = 0; i < p->ssi_vars->used; i++) {	for (i = 0; i < p->ssi_vars->used; i++) {
data_string ds = (data_string )p->ssi_vars->data[p->ssi_vars->sorted[i]];	data_string ds = (data_string )p->ssi_vars->data[p->ssi_vars->sorted[i]];

Line 705 static int process_ssi_stmt(server srv, connection c	Line 801 static int process_ssi_stmt(server srv, connection c
buffer_append_string_encoded(b, CONST_BUF_LEN(ds->value), ENCODING_MINIMAL_XML);	buffer_append_string_encoded(b, CONST_BUF_LEN(ds->value), ENCODING_MINIMAL_XML);
buffer_append_string_len(b, CONST_STR_LEN("\n"));	buffer_append_string_len(b, CONST_STR_LEN("\n"));
}	}
	chunkqueue_append_buffer(con->write_queue, b);
	buffer_free(b);

break;	break;
case SSI_EXEC: {	case SSI_EXEC: {
Line 712 static int process_ssi_stmt(server srv, connection c	Line 810 static int process_ssi_stmt(server srv, connection c
pid_t pid;	pid_t pid;
int from_exec_fds[2];	int from_exec_fds[2];

	if (!p->conf.ssi_exec) { /* <!--#exec ... --> disabled by config */
	break;
	}

for (i = 2; i < n; i += 2) {	for (i = 2; i < n; i += 2) {
if (0 == strcmp(l[i], "cmd")) {	if (0 == strcmp(l[i], "cmd")) {
cmd = l[i+1];	cmd = l[i+1];
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 787 static int process_ssi_stmt(server srv, connection c	Line 889 static int process_ssi_stmt(server srv, connection c
int toread;	int toread;
/* read everything from client and paste it into the output */	/* read everything from client and paste it into the output */
was_interrupted = 0;	was_interrupted = 0;

while(1) {	while(1) {
if (ioctl(from_exec_fds[0], FIONREAD, &toread)) {	if (ioctl(from_exec_fds[0], FIONREAD, &toread)) {
log_error_write(srv, __FILE__, __LINE__, "s",	log_error_write(srv, __FILE__, __LINE__, "s",
"unexpected end-of-file (perhaps the ssi-exec process died)");	"unexpected end-of-file (perhaps the ssi-exec process died)");
return -1;	return -1;
}	}

if (toread > 0) {	if (toread > 0) {
b = chunkqueue_get_append_buffer(con->write_queue);	char *mem;
	size_t mem_len;
buffer_prepare_copy(b, toread + 1);
	chunkqueue_get_memory(con->write_queue, &mem, &mem_len, 0, toread);
if ((r = read(from_exec_fds[0], b->ptr, b->size - 1)) < 0) {	r = read(from_exec_fds[0], mem, mem_len);
/* read failed */	chunkqueue_use_memory(con->write_queue, r > 0 ? r : 0);
break;
} else {	if (r < 0) break; /* read failed */
b->used = r;
b->ptr[b->used++] = '\0';
}
} else {	} else {
break;	break;
}	}
Line 837 static int process_ssi_stmt(server srv, connection c	Line 936 static int process_ssi_stmt(server srv, connection c
expr = l[i+1];	expr = l[i+1];
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 891 static int process_ssi_stmt(server srv, connection c	Line 990 static int process_ssi_stmt(server srv, connection c
expr = l[i+1];	expr = l[i+1];
} else {	} else {
log_error_write(srv, __FILE__, __LINE__, "sss",	log_error_write(srv, __FILE__, __LINE__, "sss",
"ssi: unknow attribute for ",	"ssi: unknown attribute for ",
l[1], l[i]);	l[1], l[i]);
}	}
}	}
Line 940 static int process_ssi_stmt(server srv, connection c	Line 1039 static int process_ssi_stmt(server srv, connection c
break;	break;
default:	default:
log_error_write(srv, __FILE__, __LINE__, "ss",	log_error_write(srv, __FILE__, __LINE__, "ss",
"ssi: unknow ssi-command:",	"ssi: unknown ssi-command:",
l[1]);	l[1]);
break;	break;
}	}
Line 949 static int process_ssi_stmt(server srv, connection c	Line 1048 static int process_ssi_stmt(server srv, connection c

}	}

static int mod_ssi_handle_request(server srv, connection con, plugin_data *p) {	static int mod_ssi_parse_ssi_stmt_value(const char * const s, const int len) {
stream s;	int n;
#ifdef HAVE_PCRE_H	const int c = (s[0] == '"' ? '"' : s[0] == '\'' ? '\'' : 0);
int i, n;	if (0 != c) {
	for (n = 1; n < len; ++n) {
	if (s[n] == c) return n+1;
	if (s[n] == '\\') {
	if (n+1 == len) return 0; /* invalid */
	++n;
	}
	}
	return 0; /* invalid */
	} else {
	for (n = 0; n < len; ++n) {
	if (isspace(s[n])) return n;
	if (s[n] == '\\') {
	if (n+1 == len) return 0; /* invalid */
	++n;
	}
	}
	return n;
	}
	}

#define N 10	static int mod_ssi_parse_ssi_stmt_offlen(int o[10], const char * const s, const int len) {
int ovec[N * 3];
	/**
	* <!--#element attribute=value attribute=value ... -->
	*/

	/* s must begin "<!--#" and must end with "-->" */
	int n = 5;
	o[0] = n;
	for (; light_isalpha(s[n]); ++n) ; /(n = 5 to begin after "<!--#")/
	o[1] = n - o[0];
	if (0 == o[1]) return -1; /* empty token */

	if (n+3 == len) return 2; /* token only; no params */
	if (!isspace(s[n])) return -1;
	do { ++n; } while (isspace(s[n])); /* string ends "-->", so n < len */
	if (n+3 == len) return 2; /* token only; no params */

	o[2] = n;
	for (; light_isalpha(s[n]); ++n) ;
	o[3] = n - o[2];
	if (0 == o[3] \|\| s[n++] != '=') return -1;

	o[4] = n;
	o[5] = mod_ssi_parse_ssi_stmt_value(s+n, len-n-3);
	if (0 == o[5]) return -1; /* empty or invalid token */
	n += o[5];

	if (n+3 == len) return 6; /* token and one param */
	if (!isspace(s[n])) return -1;
	do { ++n; } while (isspace(s[n])); /* string ends "-->", so n < len */
	if (n+3 == len) return 6; /* token and one param */

	o[6] = n;
	for (; light_isalpha(s[n]); ++n) ;
	o[7] = n - o[6];
	if (0 == o[7] \|\| s[n++] != '=') return -1;

	o[8] = n;
	o[9] = mod_ssi_parse_ssi_stmt_value(s+n, len-n-3);
	if (0 == o[9]) return -1; /* empty or invalid token */
	n += o[9];

	if (n+3 == len) return 10; /* token and two params */
	if (!isspace(s[n])) return -1;
	do { ++n; } while (isspace(s[n])); /* string ends "-->", so n < len */
	if (n+3 == len) return 10; /* token and two params */
	return -1;
	}

	static void mod_ssi_parse_ssi_stmt(server srv, connection con, plugin_data p, char s, int len, struct stat *st) {

	/**
	* <!--#element attribute=value attribute=value ... -->
	*/

	int o[10];
	int m;
	const int n = mod_ssi_parse_ssi_stmt_offlen(o, s, len);
	char *l[6] = { s, NULL, NULL, NULL, NULL, NULL };
	if (-1 == n) {
	/* XXX: perhaps emit error comment instead of invalid <!--#...--> code to client */
	chunkqueue_append_mem(con->write_queue, s, len); /* append stmt as-is */
	return;
	}

	#if 0
	/* dup s and then modify s */
	/(l[0] is no longer used; was previously used in only one place for error reporting)/
	l[0] = malloc((size_t)(len+1));
	memcpy(l[0], s, (size_t)len);
	(l[0])[len] = '\0';
	#endif

	/* modify s in-place to split string into arg tokens */
	for (m = 0; m < n; m += 2) {
	char *ptr = s+o[m];
	switch (*ptr) {
	case '"':
	case '\'': (++ptr)[o[m+1]-2] = '\0'; break;
	default: ptr[o[m+1]] = '\0'; break;
	}
	l[1+(m>>1)] = ptr;
	if (m == 4 \|\| m == 8) {
	/* XXX: removing '\\' escapes from param value would be
	* the right thing to do, but would potentially change
	* current behavior, e.g. <!--#exec cmd=... --> */
	}
	}

	process_ssi_stmt(srv, con, p, (const char **)l, 1+(n>>1), st);

	#if 0
	free(l[0]);
	#endif
	}

	static int mod_ssi_stmt_len(const char *s, const int len) {
	/* s must begin "<!--#" */
	int n, sq = 0, dq = 0, bs = 0;
	for (n = 5; n < len; ++n) { /(n = 5 to begin after "<!--#")/
	switch (s[n]) {
	default:
	break;
	case '-':
	if (!sq && !dq && n+2 < len && s[n+1] == '-' && s[n+2] == '>') return n+3; /* found end of stmt */
	break;
	case '"':
	if (!sq && (!dq \|\| !bs)) dq = !dq;
	break;
	case '\'':
	if (!dq && (!sq \|\| !bs)) sq = !sq;
	break;
	case '\\':
	if (sq \|\| dq) bs = !bs;
	break;
	}
	}
	return 0; /* incomplete directive "<!--#...-->" */
	}

	static void mod_ssi_read_fd(server srv, connection con, plugin_data p, int fd, struct stat st) {
	ssize_t rd;
	size_t offset, pretag;
	char buf[8192];

	offset = 0;
	pretag = 0;
	while (0 < (rd = read(fd, buf+offset, sizeof(buf)-offset))) {
	char *s;
	size_t prelen = 0, len;
	offset += (size_t)rd;
	for (; (s = memchr(buf+prelen, '<', offset-prelen)); ++prelen) {
	prelen = s - buf;
	if (prelen + 5 <= offset) { /("<!--#" is 5 chars)/
	if (0 != memcmp(s+1, CONST_STR_LEN("!--#"))) continue; /* loop to loop for next '<' */

	if (prelen - pretag && !p->if_is_false) {
	chunkqueue_append_mem(con->write_queue, buf+pretag, prelen-pretag);
	}

	len = mod_ssi_stmt_len(buf+prelen, offset-prelen);
	if (len) { /* num of chars to be consumed */
	mod_ssi_parse_ssi_stmt(srv, con, p, buf+prelen, len, st);
	prelen += (len - 1); /* offset to '>' at end of SSI directive; incremented at top of loop */
	pretag = prelen + 1;
	if (pretag == offset) {
	offset = pretag = 0;
	break;
	}
	} else if (0 == prelen && offset == sizeof(buf)) { /(full buf)/
	/* SSI statement is way too long
	* NOTE: skipping this buf will expose the rest of this SSI statement */
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("<!-- [an error occurred: directive too long] "));
	/* check if buf ends with "-" or "--" which might be part of "-->"
	* (buf contains at least 5 chars for "<!--#") */
	if (buf[offset-2] == '-' && buf[offset-1] == '-') {
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("--"));
	} else if (buf[offset-1] == '-') {
	chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("-"));
	}
	offset = pretag = 0;
	break;
	} else { /* incomplete directive "<!--#...-->" */
	memmove(buf, buf+prelen, (offset -= prelen));
	pretag = 0;
	break;
	}
	} else if (prelen + 1 == offset \|\| 0 == memcmp(s+1, "!--", offset - prelen - 1)) {
	if (prelen - pretag && !p->if_is_false) {
	chunkqueue_append_mem(con->write_queue, buf+pretag, prelen-pretag);
	}
	memcpy(buf, buf+prelen, (offset -= prelen));
	pretag = 0;
	break;
	}
	/* loop to look for next '<' */
	}
	if (offset == sizeof(buf)) {
	if (!p->if_is_false) {
	chunkqueue_append_mem(con->write_queue, buf+pretag, offset-pretag);
	}
	offset = pretag = 0;
	}
	}

	if (0 != rd) {
	log_error_write(srv, __FILE__, __LINE__, "SsB", "read(): ", strerror(errno), con->physical.path);
	}

	if (offset - pretag) {
	/* copy remaining data in buf */
	if (!p->if_is_false) {
	chunkqueue_append_mem(con->write_queue, buf+pretag, offset-pretag);
	}
	}
	}


	/* don't want to block when open()ing a fifo */
	#if defined(O_NONBLOCK)
	# define FIFO_NONBLOCK O_NONBLOCK
	#else
	# define FIFO_NONBLOCK 0
#endif	#endif

	static int mod_ssi_handle_request(server srv, connection con, plugin_data *p) {
	int fd;
	struct stat st;

/* get a stream to the file */	/* get a stream to the file */

array_reset(p->ssi_vars);	array_reset(p->ssi_vars);
Line 970 static int mod_ssi_handle_request(server *srv, connect	Line 1294 static int mod_ssi_handle_request(server *srv, connect
/* Reset the modified time of included files */	/* Reset the modified time of included files */
include_file_last_mtime = 0;	include_file_last_mtime = 0;

if (-1 == stream_open(&s, con->physical.path)) {	if (-1 == (fd = open(con->physical.path->ptr, O_RDONLY \| FIFO_NONBLOCK))) {
log_error_write(srv, __FILE__, __LINE__, "sb",	log_error_write(srv, __FILE__, __LINE__, "sb",
"stream-open: ", con->physical.path);	"open: ", con->physical.path);
return -1;	return -1;
}	}

	if (0 != fstat(fd, &st)) {
/**	log_error_write(srv, __FILE__, __LINE__, "SB", "fstat failed: ", con->physical.path);
* <!--#element attribute=value attribute=value ... -->	close(fd);
*	return -1;
* config DONE
* errmsg -- missing
* sizefmt DONE
* timefmt DONE
* echo DONE
* var DONE
* encoding -- missing
* exec DONE
* cgi -- never
* cmd DONE
* fsize DONE
* file DONE
* virtual DONE
* flastmod DONE
* file DONE
* virtual DONE
* include DONE
* file DONE
* virtual DONE
* printenv DONE
* set DONE
* var DONE
* value DONE
*
* if DONE
* elif DONE
* else DONE
* endif DONE
*
*
* expressions
* AND, OR DONE
* comp DONE
* ${...} -- missing
* $... DONE
* '...' DONE
* ( ... ) DONE
*
*
*
* all DONE
* DATE_GMT
* The current date in Greenwich Mean Time.
* DATE_LOCAL
* The current date in the local time zone.
* DOCUMENT_NAME
* The filename (excluding directories) of the document requested by the user.
* DOCUMENT_URI
* The (%-decoded) URL path of the document requested by the user. Note that in the case of nested include files, this is not then URL for the current document.
* LAST_MODIFIED
* The last modification date of the document requested by the user.
* USER_NAME
* Contains the owner of the file which included it.
*
*/
#ifdef HAVE_PCRE_H
for (i = 0; (n = pcre_exec(p->ssi_regex, NULL, s.start, s.size, i, 0, ovec, N * 3)) > 0; i = ovec[1]) {
const char **l;
/* take everything from last offset to current match pos */

if (!p->if_is_false) chunkqueue_append_file(con->write_queue, con->physical.path, i, ovec[0] - i);

pcre_get_substring_list(s.start, ovec, n, &l);
process_ssi_stmt(srv, con, p, l, n);
pcre_free_substring_list(l);
}	}

switch(n) {	mod_ssi_read_fd(srv, con, p, fd, &st);
case PCRE_ERROR_NOMATCH:
/* copy everything/the rest */
chunkqueue_append_file(con->write_queue, con->physical.path, i, s.size - i);

break;	close(fd);
default:
log_error_write(srv, __FILE__, __LINE__, "sd",
"execution error while matching: ", n);
break;
}
#endif


stream_close(&s);

con->file_started = 1;	con->file_started = 1;
con->file_finished = 1;	con->file_finished = 1;
con->mode = p->id;	con->mode = p->id;

if (p->conf.content_type->used <= 1) {	if (buffer_string_is_empty(p->conf.content_type)) {
response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));	response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));
} else {	} else {
response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(p->conf.content_type));	response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(p->conf.content_type));
}	}

{	if (p->conf.conditional_requests) {
/* Generate "ETag" & "Last-Modified" headers */	/* Generate "ETag" & "Last-Modified" headers */

stat_cache_entry *sce = NULL;
time_t lm_time = 0;
buffer *mtime = NULL;	buffer *mtime = NULL;

stat_cache_get_entry(srv, con, con->physical.path, &sce);	/* use most recently modified include file for ETag and Last-Modified */
	if (st.st_mtime < include_file_last_mtime)
	st.st_mtime = include_file_last_mtime;

etag_mutate(con->physical.etag, sce->etag);	etag_create(con->physical.etag, &st, con->etag_flags);
response_header_overwrite(srv, con, CONST_STR_LEN("ETag"), CONST_BUF_LEN(con->physical.etag));	response_header_overwrite(srv, con, CONST_STR_LEN("ETag"), CONST_BUF_LEN(con->physical.etag));

if (sce->st.st_mtime > include_file_last_mtime)	mtime = strftime_cache_get(srv, st.st_mtime);
lm_time = sce->st.st_mtime;
else
lm_time = include_file_last_mtime;

mtime = strftime_cache_get(srv, lm_time);
response_header_overwrite(srv, con, CONST_STR_LEN("Last-Modified"), CONST_BUF_LEN(mtime));	response_header_overwrite(srv, con, CONST_STR_LEN("Last-Modified"), CONST_BUF_LEN(mtime));

	if (HANDLER_FINISHED == http_response_handle_cachable(srv, con, mtime)) {
	/* ok, the client already has our content,
	* no need to send it again */

	chunkqueue_reset(con->write_queue);
	}
}	}

/* Reset the modified time of included files */	/* Reset the modified time of included files */
Line 1111 static int mod_ssi_patch_connection(server *srv, conne	Line 1358 static int mod_ssi_patch_connection(server *srv, conne

PATCH(ssi_extension);	PATCH(ssi_extension);
PATCH(content_type);	PATCH(content_type);
	PATCH(conditional_requests);
	PATCH(ssi_exec);

/* skip the first, the global context */	/* skip the first, the global context */
for (i = 1; i < srv->config_context->used; i++) {	for (i = 1; i < srv->config_context->used; i++) {
Line 1128 static int mod_ssi_patch_connection(server *srv, conne	Line 1377 static int mod_ssi_patch_connection(server *srv, conne
PATCH(ssi_extension);	PATCH(ssi_extension);
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.content-type"))) {	} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.content-type"))) {
PATCH(content_type);	PATCH(content_type);
	} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.conditional-requests"))) {
	PATCH(conditional_requests);
	} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.exec"))) {
	PATCH(ssi_exec);
}	}
}	}
}	}
Line 1142 URIHANDLER_FUNC(mod_ssi_physical_path) {	Line 1395 URIHANDLER_FUNC(mod_ssi_physical_path) {

if (con->mode != DIRECT) return HANDLER_GO_ON;	if (con->mode != DIRECT) return HANDLER_GO_ON;

if (con->physical.path->used == 0) return HANDLER_GO_ON;	if (buffer_is_empty(con->physical.path)) return HANDLER_GO_ON;

mod_ssi_patch_connection(srv, con, p);	mod_ssi_patch_connection(srv, con, p);

for (k = 0; k < p->conf.ssi_extension->used; k++) {	for (k = 0; k < p->conf.ssi_extension->used; k++) {
data_string ds = (data_string )p->conf.ssi_extension->data[k];	data_string ds = (data_string )p->conf.ssi_extension->data[k];

if (ds->value->used == 0) continue;	if (buffer_is_empty(ds->value)) continue;

if (buffer_is_equal_right_len(con->physical.path, ds->value, ds->value->used - 1)) {	if (buffer_is_equal_right_len(con->physical.path, ds->value, buffer_string_length(ds->value))) {
/* handle ssi-request */	/* handle ssi-request */

if (mod_ssi_handle_request(srv, con, p)) {	if (mod_ssi_handle_request(srv, con, p)) {

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.3