#include "mod_python.h"

APR_DECLARE_OPTIONAL_FN(char *, ssl_var_lookup,

(apr_pool_t *, server_rec *,

conn_rec *, request_rec *,

char *));

APR_DECLARE_OPTIONAL_FN(int, ssl_is_https, (conn_rec *));

static APR_OPTIONAL_FN_TYPE(ssl_var_lookup) *optfn_ssl_var_lookup = NULL;

static APR_OPTIONAL_FN_TYPE(ssl_is_https) *optfn_is_https = NULL;

PyObject * MpRequest_FromRequest(request_rec *req)

{

requestobject *result;

result = PyObject_GC_New(requestobject, &MpRequest_Type);

if (! result)

return PyErr_NoMemory();

result->dict = PyDict_New();

if (!result->dict)

return PyErr_NoMemory();

result->request_rec = req;

result->connection = NULL;

result->server = NULL;

result->headers_in = NULL;

result->headers_out = NULL;

result->err_headers_out = NULL;

result->subprocess_env = NULL;

result->notes = NULL;

result->phase = NULL;

result->config = NULL;

result->options = NULL;

result->extension = NULL;

result->content_type_set = 0;

result->bytes_queued = 0;

result->hlo = NULL;

result->rbuff = NULL;

result->rbuff_pos = 0;

result->rbuff_len = 0;

/* we make sure that the object dictionary is there

PyObject_GC_Track(result);

return (PyObject *) result;

}

static PyObject * req_add_common_vars(requestobject *self)

{

ap_add_common_vars(self->request_rec);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject * req_add_cgi_vars(requestobject *self)

{

request_rec *r = self->request_rec;

apr_table_t *e = r->subprocess_env;

apr_table_setn(e, "GATEWAY_INTERFACE", "CGI/1.1");

apr_table_setn(e, "SERVER_PROTOCOL", r->protocol);

apr_table_setn(e, "REQUEST_METHOD", r->method);

apr_table_setn(e, "QUERY_STRING", r->args ? r->args : "");

apr_table_setn(e, "REQUEST_URI", r->uri);

if (!r->path_info || !*r->path_info) {

apr_table_setn(e, "SCRIPT_NAME", r->uri);

}

else {

int path_info_start = ap_find_path_info(r->uri, r->path_info);

apr_table_setn(e, "SCRIPT_NAME",

apr_pstrndup(r->pool, r->uri, path_info_start));

apr_table_setn(e, "PATH_INFO", r->path_info);

}

ap_add_common_vars(self->request_rec);

Py_INCREF(Py_None);

return Py_None;

}

static int set_wsgi_path_info(requestobject *self)

{

py_config *conf =

(py_config *) ap_get_module_config(self->request_rec->per_dir_config,

&python_module);

const char *path_info = self->request_rec->uri;

const char *base_uri = apr_table_get(conf->options, "mod_python.wsgi.base_uri");

if (!base_uri && conf->d_is_location) {

/* Use Location as the base_uri, automatically adjust trailing slash */

char *bu = apr_pstrdup(self->request_rec->pool, conf->config_dir);

int last = strlen(bu) - 1;

if (*bu && bu[last] == '/')

bu[last] = '\0';

base_uri = bu;

} else if (base_uri && *base_uri) {

/* This base_uri was set by hand, enforce correctness */

if (base_uri[strlen(base_uri)-1] == '/') {

PyErr_SetString(PyExc_ValueError,

apr_psprintf(self->request_rec->pool,

"PythonOption 'mod_python.wsgi.base_uri' ('%s') must not end with '/'",

base_uri));

return 1;

}

}

if (base_uri && *base_uri) {

/* find end of base_uri match in r->uri, this will be our path_info */

while (*path_info && *base_uri && (*path_info == *base_uri)) {

path_info++;

base_uri++;

}

if (*base_uri) {

/* we have not reached end of base_uri, therefore

return 2;

}

}

self->request_rec->path_info = apr_pstrdup(self->request_rec->pool, path_info);

return 0;

}

static PyObject *wsgi_version = NULL;

static PyObject *wsgi_multithread = NULL;

static PyObject *wsgi_multiprocess = NULL;

static PyObject *req_build_wsgi_env(requestobject *self)

{

request_rec *r = self->request_rec;

apr_table_t *e = r->subprocess_env;

PyObject *env, *v;

const char *val;

int i, j;

env = PyDict_New();

if (!env)

return NULL;

int rc = set_wsgi_path_info(self);

if (rc == 1) {

/* bad base_uri, the error is already set */

Py_DECREF(env);

return NULL;

} else if (rc == 2) {

/* base_uri does not match uri, wsgi.py will decline */

Py_DECREF(env);

Py_INCREF(Py_None);

return Py_None;

}

/* this will create the correct SCRIPT_NAME based on our path_info now */

req_add_cgi_vars(self);

/* copy r->subprocess_env */

if (!self->subprocess_env)

self->subprocess_env = MpTable_FromTable(self->request_rec->subprocess_env);

else

((tableobject*)self->subprocess_env)->table = r->subprocess_env;

PyDict_Merge(env, (PyObject*)self->subprocess_env, 0);

/* authorization */

if ((val = apr_table_get(r->headers_in, "authorization"))) {

v = MpBytesOrUnicode_FromString(val);

PyDict_SetItemString(env, "HTTP_AUTHORIZATION", v);

Py_DECREF(v);

}

PyDict_SetItemString(env, "wsgi.input", (PyObject *) self);

PyDict_SetItemString(env, "wsgi.errors", PySys_GetObject("stderr"));

if (!wsgi_version) {

int result;

wsgi_version = Py_BuildValue("(ii)", 1, 0);

ap_mpm_query(AP_MPMQ_IS_THREADED, &result);

wsgi_multithread = PyBool_FromLong(result);

ap_mpm_query(AP_MPMQ_IS_FORKED, &result);

wsgi_multiprocess = PyBool_FromLong(result);

}

/* NOTE: these are global vars which we never decref! */

PyDict_SetItemString(env, "wsgi.version", wsgi_version);

PyDict_SetItemString(env, "wsgi.multithread", wsgi_multithread);

PyDict_SetItemString(env, "wsgi.multiprocess", wsgi_multiprocess);

val = apr_table_get(r->subprocess_env, "HTTPS");

if (!val || !strcasecmp(val, "off")) {

v = MpBytesOrUnicode_FromString("http");

PyDict_SetItemString(env, "wsgi.url_scheme", v);

Py_DECREF(v);

} else {

v = MpBytesOrUnicode_FromString("https");

PyDict_SetItemString(env, "wsgi.url_scheme", v);

Py_DECREF(v);

}

return env;

}

static PyObject *req_wsgi_start_response(requestobject *self, PyObject *args)

{

char *status_line = NULL;

PyObject *headers = NULL;

PyObject *exc_info = NULL;

int status, i;

if (! PyArg_ParseTuple(args, "sO|O:wsgi_start_response", &status_line, &headers, &exc_info))

return NULL;

if (!PyList_Check(headers)) {

PyErr_Format(PyExc_TypeError, "headers argument must be a list, not a '%.200s'",

headers->ob_type->tp_name);

return NULL;

}

/* I don't understand what PEP3333 wants us to do with the

if (exc_info) {

PyObject *exc, *value, *tb;

if (PyArg_UnpackTuple(exc_info, "wsgi_start_response", 3, 3, &exc, &value, &tb)) {

Py_INCREF(exc);

Py_INCREF(value);

Py_INCREF(tb);

PyErr_Restore(exc, value, tb);

}

return NULL;

}

/* add the headers */

for (i=0; i < PyList_Size(headers); i++) {

PyObject *key = NULL, *val = NULL;

char *k, *v;

PyObject *item = PyList_GetItem(headers, i);

if (!PyTuple_CheckExact(item)) {

PyErr_Format(PyExc_TypeError, "each header must be a tuple, not a '%.200s'",

item->ob_type->tp_name);

return NULL;

}

if (! PyArg_ParseTuple(item, "OO", &key, &val))

return NULL;

if (!((PyUnicode_CheckExact(key) || PyBytes_CheckExact(key)))) {

PyErr_Format(PyExc_TypeError, "header names must be strings, not '%.200s'",

key->ob_type->tp_name);

return NULL;

}

if (!((PyUnicode_CheckExact(val) || PyBytes_CheckExact(val)))) {

PyErr_Format(PyExc_TypeError, "header values must be strings, not '%.200s'",

val->ob_type->tp_name);

return NULL;

}

MP_ANYSTR_AS_STR(k, key, 1);

MP_ANYSTR_AS_STR(v, val, 1);

if ((!k) || (!v)) {

Py_DECREF(key); /* MP_ANYSTR_AS_STR */

Py_DECREF(val); /* MP_ANYSTR_AS_STR */

return NULL;

}

apr_table_add(self->request_rec->headers_out, k, v);

Py_DECREF(key); /* MP_ANYSTR_AS_STR */

Py_DECREF(val); /* MP_ANYSTR_AS_STR */

}

status = atoi(status_line);

if (!ap_is_HTTP_VALID_RESPONSE(status)) {

PyErr_SetString(PyExc_ValueError,

apr_psprintf(self->request_rec->pool,

"Invalid status line: %s", status_line));

return NULL;

}

self->request_rec->status_line = apr_pstrdup(self->request_rec->pool, status_line);

return PyObject_GetAttrString((PyObject*)self, "write");

}

static int valid_phase(const char *p)

{

if ((strcmp(p, "PythonHandler") != 0) &&

(strcmp(p, "PythonAuthenHandler") != 0) &&

(strcmp(p, "PythonPostReadRequestHandler") != 0) &&

(strcmp(p, "PythonTransHandler") != 0) &&

(strcmp(p, "PythonHeaderParserHandler") != 0) &&

(strcmp(p, "PythonAccessHandler") != 0) &&

(strcmp(p, "PythonAuthzHandler") != 0) &&

(strcmp(p, "PythonTypeHandler") != 0) &&

(strcmp(p, "PythonFixupHandler") != 0) &&

(strcmp(p, "PythonLogHandler") != 0) &&

(strcmp(p, "PythonInitHandler") != 0))

return 0;

else

return 1;

}

static PyObject *req_add_handler(requestobject *self, PyObject *args)

{

char *phase = NULL;

PyObject *o_phase;

char *handler;

const char *dir = NULL;

const char *currphase;

if (! PyArg_ParseTuple(args, "ss|z", &phase, &handler, &dir))

return NULL;

if (! valid_phase(phase)) {

PyErr_SetString(PyExc_IndexError,

apr_psprintf(self->request_rec->pool,

"Invalid phase: %s", phase));

return NULL;

}

/* Canonicalize path and add trailing slash at

if (dir) {

char *newpath = 0;

apr_status_t rv;

rv = apr_filepath_merge(&newpath, NULL, dir,

APR_FILEPATH_TRUENAME,

self->request_rec->pool);

/* If there is a failure, use the original path

if (rv == APR_SUCCESS || rv == APR_EPATHWILD) {

dir = newpath;

if (dir[strlen(dir) - 1] != '/') {

dir = apr_pstrcat(self->request_rec->pool, dir, "/", NULL);

}

}

else {

/* dir is from Python, so duplicate it */

dir = apr_pstrdup(self->request_rec->pool, dir);

}

}

/* handler is from Python, so duplicate it */

handler = apr_pstrdup(self->request_rec->pool, handler);

/* which phase are we processing? */

o_phase = self->phase;

MP_ANYSTR_AS_STR(currphase, o_phase, 1);

/* are we in same phase as what's being added? */

if (strcmp(currphase, phase) == 0) {

/* then just append to hlist */

hlist_append(self->request_rec->pool, self->hlo->head,

handler, dir, 0, 0, NULL, NOTSILENT);

}

else {

/* this is a phase that we're not in */

py_req_config *req_config;

hl_entry *hle;

/* get request config */

req_config = (py_req_config *)

ap_get_module_config(self->request_rec->request_config,

&python_module);

hle = apr_hash_get(req_config->dynhls, phase, APR_HASH_KEY_STRING);

if (! hle) {

hle = hlist_new(self->request_rec->pool, handler, dir, 0, 0, NULL, NOTSILENT);

apr_hash_set(req_config->dynhls, phase, APR_HASH_KEY_STRING, hle);

}

else {

hlist_append(self->request_rec->pool, hle, handler, dir, 0, 0, NULL, NOTSILENT);

}

}

Py_XDECREF(o_phase);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_add_input_filter(requestobject *self, PyObject *args)

{

char *name;

py_req_config *req_config;

python_filter_ctx *ctx;

if (! PyArg_ParseTuple(args, "s", &name))

return NULL;

req_config = (py_req_config *) ap_get_module_config(

self->request_rec->request_config, &python_module);

if (apr_hash_get(req_config->in_filters, name, APR_HASH_KEY_STRING)) {

ctx = (python_filter_ctx *) apr_pcalloc(self->request_rec->pool,

sizeof(python_filter_ctx));

ctx->name = apr_pstrdup(self->request_rec->pool, name);

ap_add_input_filter(FILTER_NAME, ctx, self->request_rec,

self->request_rec->connection);

} else {

ap_add_input_filter(name, NULL, self->request_rec,

self->request_rec->connection);

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_add_output_filter(requestobject *self, PyObject *args)

{

char *name;

py_req_config *req_config;

python_filter_ctx *ctx;

if (! PyArg_ParseTuple(args, "s", &name))

return NULL;

req_config = (py_req_config *) ap_get_module_config(

self->request_rec->request_config, &python_module);

if (apr_hash_get(req_config->out_filters, name, APR_HASH_KEY_STRING)) {

ctx = (python_filter_ctx *) apr_pcalloc(self->request_rec->pool,

sizeof(python_filter_ctx));

ctx->name = apr_pstrdup(self->request_rec->pool, name);

ap_add_output_filter(FILTER_NAME, ctx, self->request_rec,

self->request_rec->connection);

} else {

ap_add_output_filter(name, NULL, self->request_rec,

self->request_rec->connection);

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_register_input_filter(requestobject *self, PyObject *args)

{

char *name;

char *handler;

char *dir = NULL;

py_req_config *req_config;

py_handler *fh;

if (! PyArg_ParseTuple(args, "ss|s", &name, &handler, &dir))

return NULL;

req_config = (py_req_config *) ap_get_module_config(

self->request_rec->request_config, &python_module);

fh = (py_handler *) apr_pcalloc(self->request_rec->pool,

sizeof(py_handler));

fh->handler = apr_pstrdup(self->request_rec->pool, handler);

/* Canonicalize path and add trailing slash at

if (dir) {

char *newpath = 0;

apr_status_t rv;

rv = apr_filepath_merge(&newpath, NULL, dir,

APR_FILEPATH_TRUENAME,

self->request_rec->pool);

/* If there is a failure, use the original path

if (rv == APR_SUCCESS || rv == APR_EPATHWILD) {

dir = newpath;

if (dir[strlen(dir) - 1] != '/') {

dir = apr_pstrcat(self->request_rec->pool, dir, "/", NULL);

}

fh->directory = dir;

} else {

fh->directory = apr_pstrdup(self->request_rec->pool, dir);

}

}

apr_hash_set(req_config->in_filters,

apr_pstrdup(self->request_rec->pool, name),

APR_HASH_KEY_STRING, fh);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_register_output_filter(requestobject *self, PyObject *args)

{

char *name;

char *handler;

char *dir = NULL;

py_req_config *req_config;

py_handler *fh;

if (! PyArg_ParseTuple(args, "ss|s", &name, &handler, &dir))

return NULL;

req_config = (py_req_config *) ap_get_module_config(

self->request_rec->request_config, &python_module);

fh = (py_handler *) apr_pcalloc(self->request_rec->pool,

sizeof(py_handler));

fh->handler = apr_pstrdup(self->request_rec->pool, handler);

/* Canonicalize path and add trailing slash at

if (dir) {

char *newpath = 0;

apr_status_t rv;

rv = apr_filepath_merge(&newpath, NULL, dir,

APR_FILEPATH_TRUENAME,

self->request_rec->pool);

/* If there is a failure, use the original path

if (rv == APR_SUCCESS || rv == APR_EPATHWILD) {

dir = newpath;

if (dir[strlen(dir) - 1] != '/') {

dir = apr_pstrcat(self->request_rec->pool, dir, "/", NULL);

}

fh->directory = dir;

} else {

fh->directory = apr_pstrdup(self->request_rec->pool, dir);

}

}

apr_hash_set(req_config->out_filters,

apr_pstrdup(self->request_rec->pool, name),

APR_HASH_KEY_STRING, fh);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_allow_methods(requestobject *self, PyObject *args)

{

PyObject *methods;

int reset = 0;

int len, i;

if (! PyArg_ParseTuple(args, "O|i", &methods, &reset))

return NULL;

if (! PySequence_Check(methods)){

PyErr_SetString(PyExc_TypeError,

"First argument must be a sequence");

return NULL;

}

len = PySequence_Length(methods);

if (len) {

PyObject *method;

char *m;

method = PySequence_GetItem(methods, 0);

MP_ANYSTR_AS_STR(m, method, 1);

if (!m) {

Py_DECREF(method); /* MP_ANYSTR_AS_STR */

return NULL;

}

ap_allow_methods(self->request_rec, (reset == REPLACE_ALLOW), m, NULL);

Py_DECREF(method); /* MP_ANYSTR_AS_STR */

for (i = 1; i < len; i++) {

method = PySequence_GetItem(methods, i);

MP_ANYSTR_AS_STR(m, method, 1);

if (!m) {

Py_DECREF(method); /* MP_ANYSTR_AS_STR */

return NULL;

}

ap_allow_methods(self->request_rec, MERGE_ALLOW, m, NULL);

Py_DECREF(method); /* MP_ANYSTR_AS_STR */

}

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject * req_is_https(requestobject *self)

{

int is_https;

if (!optfn_is_https)

optfn_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);

is_https = optfn_is_https && optfn_is_https(self->request_rec->connection);

return PyLong_FromLong(is_https);

}

static PyObject * req_ssl_var_lookup(requestobject *self, PyObject *args)

{

char *var_name;

if (! PyArg_ParseTuple(args, "s", &var_name))

return NULL; /* error */

if (!optfn_ssl_var_lookup)

optfn_ssl_var_lookup = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup);

if (optfn_ssl_var_lookup) {

const char *val;

val = optfn_ssl_var_lookup(self->request_rec->pool,

self->request_rec->server,

self->request_rec->connection,

self->request_rec,

var_name);

if (val)

return MpBytesOrUnicode_FromString(val);

}

/* variable not found, or mod_ssl is not loaded */

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *req_document_root(requestobject *self)

{

return MpBytesOrUnicode_FromString(ap_document_root(self->request_rec));

}

static PyObject * req_get_basic_auth_pw(requestobject *self, PyObject *args)

{

const char *pw;

request_rec *req;

/* http://stackoverflow.com/questions/702629/utf-8-characters-mangled-in-http-basic-auth-username/703341#703341 */

/* Latin1 is Safari, Chrome and Mozilla - otherwise it can be decoded manually */

req = self->request_rec;

if (! ap_get_basic_auth_pw(req, &pw)) {

#if PY_MAJOR_VERSION < 3

return PyBytes_FromString(pw);

return PyUnicode_DecodeLatin1(pw, strlen(pw), NULL);

} else {

Py_INCREF(Py_None);

return Py_None;

}

}

static PyObject *req_auth_name(requestobject *self)

{

const char *auth_name = ap_auth_name(self->request_rec);

if (!auth_name) {

Py_INCREF(Py_None);

return Py_None;

}

return MpBytesOrUnicode_FromString(auth_name);

}

static PyObject *req_auth_type(requestobject *self)

{

const char *auth_type = ap_auth_type(self->request_rec);

if (!auth_type) {

Py_INCREF(Py_None);

return Py_None;

}

return MpBytesOrUnicode_FromString(auth_type);

}

static PyObject *req_construct_url(requestobject *self, PyObject *args)

{

char *uri;

if (! PyArg_ParseTuple(args, "s", &uri))

return NULL;

return MpBytesOrUnicode_FromString(ap_construct_url(self->request_rec->pool,

uri, self->request_rec));

}

static PyObject * req_discard_request_body(requestobject *self)

{

return PyLong_FromLong(ap_discard_request_body(self->request_rec));

}

static PyObject * req_get_addhandler_exts(requestobject *self, PyObject *args)

{

char *exts = get_addhandler_extensions(self->request_rec);

if (exts)

return MpBytesOrUnicode_FromString(exts);

else

return MpBytesOrUnicode_FromString("");

}

static PyObject * req_get_config(requestobject *self)

{

py_config *conf =

(py_config *) ap_get_module_config(self->request_rec->per_dir_config,

&python_module);

if (!self->config)

self->config = MpTable_FromTable(conf->directives);

if (((tableobject*)self->config)->table != conf->directives)

((tableobject*)self->config)->table = conf->directives;

Py_INCREF(self->config);

return self->config;

}

static PyObject * req_get_remote_host(requestobject *self, PyObject *args)

{

int type = REMOTE_NAME;

PyObject *str_is_ip = Py_None;

int _str_is_ip;

const char *host;

if (! PyArg_ParseTuple(args, "|iO", &type, &str_is_ip))

return NULL;

if (str_is_ip != Py_None) {

host = ap_get_remote_host(self->request_rec->connection,

self->request_rec->per_dir_config, type, &_str_is_ip);

}

else {

host = ap_get_remote_host(self->request_rec->connection,

self->request_rec->per_dir_config, type, NULL);

}

if (! host) {

Py_INCREF(Py_None);

return Py_None;

}

else {

if (str_is_ip != Py_None) {

return Py_BuildValue("(s,i)", host, _str_is_ip);

}

else {

return MpBytesOrUnicode_FromString(host);

}

}

}

static PyObject * req_get_options(requestobject *self, PyObject *args)

{

py_config *conf =

(py_config *) ap_get_module_config(self->request_rec->per_dir_config,

&python_module);

if (!self->options)

self->options = MpTable_FromTable(conf->options);

if (((tableobject*)self->options)->table != conf->options)

((tableobject*)self->options)->table = conf->options;

const apr_array_header_t* ah = apr_table_elts(conf->options);

apr_table_entry_t* elts = (apr_table_entry_t *) ah->elts;

int i;

/* Remove the empty values as a way to unset values.