#include "httpd.h"

#include "http_config.h"

#include "http_protocol.h"

#include "util_script.h"

#include "http_log.h"

#include "Python.h"

#include "structmember.h"

#define VERSION_COMPONENT "mod_python/2.0a"

#define MODULENAME "apache"

#define INITSTRING "apache.init()"

#define INTERP_ATTR "__interpreter__"

static int debug = 1;

static int single_mode = 0;

static PyObject * interpreters = NULL;

static PyObject *obCallBack = NULL;

void noop(void *data) {};

void python_decref(void *object);

PyObject * make_obcallback(const char *module, const char *initstring);

PyObject * tuple_from_array_header(const array_header *ah);

PyObject * get_obcallback(const char *name, server_rec * req);

static PyObject * SetCallBack(PyObject *self, PyObject *args);

static PyObject * log_error(PyObject *self, PyObject *args);

static PyObject * make_table(PyObject *self, PyObject *args);

static struct PyMethodDef _apache_module_methods[] = {

{"SetCallBack", (PyCFunction)SetCallBack, METH_VARARGS},

{"log_error", (PyCFunction)log_error, METH_VARARGS},

{"make_table", (PyCFunction)make_table, METH_VARARGS},

{NULL, NULL} /* sentinel */

};

typedef struct tableobject {

} tableobject;

static PyTypeObject tableobjecttype;

#define is_tableobject(op) ((op)->ob_type == &tableobjecttype)

static PyObject * tablegetitem (tableobject *self, PyObject *key );

static PyObject * table_has_key (tableobject *self, PyObject *args );

static PyObject * table_keys (tableobject *self);

static int tablelength (tableobject *self);

static int tablesetitem (tableobject *self, PyObject *key, PyObject *val);

static int tb_setitem (tableobject *self, const char *key, const char *val);

static tableobject * make_tableobject(table * t);

static PyMethodDef tablemethods[] = {

{ "keys", (PyCFunction)table_keys, 1},

{ "has_key", (PyCFunction)table_has_key, 1},

{ NULL, NULL } /* sentinel */

};

static PyMappingMethods table_mapping = {

(inquiry) tablelength, /*mp_length*/

(binaryfunc) tablegetitem, /*mp_subscript*/

(objobjargproc) tablesetitem, /*mp_ass_subscript*/

};

tableobject * headers_in(request_rec *req);

typedef struct serverobject {

} serverobject;

static PyTypeObject serverobjecttype;

#define is_serverobject(op) ((op)->ob_type == &serverobjecttype)

#define OFF(x) offsetof(server_rec, x)

static struct memberlist server_memberlist[] = {

{"defn_name", T_STRING, OFF(defn_name), RO},

{"defn_line_number", T_INT, OFF(defn_line_number), RO},

{"srm_confname", T_STRING, OFF(srm_confname), RO},

{"access_confname", T_STRING, OFF(access_confname), RO},

{"server_admin", T_STRING, OFF(server_admin), RO},

{"server_hostname", T_STRING, OFF(server_hostname), RO},

{"port", T_SHORT, OFF(port), RO},

{"error_fname", T_STRING, OFF(error_fname), RO},

{"loglevel", T_INT, OFF(loglevel), RO},

{"is_virtual", T_INT, OFF(is_virtual), RO},

/* XXX implement module_config ? */

/* XXX implement lookup_defaults ? */

/* XXX implement server_addr_rec ? */

{"timeout", T_INT, OFF(timeout), RO},

{"keep_alive_timeout", T_INT, OFF(keep_alive_timeout), RO},

{"keep_alive_max", T_INT, OFF(keep_alive_max), RO},

{"keep_alive", T_INT, OFF(keep_alive), RO},

{"send_buffer_size", T_INT, OFF(send_buffer_size), RO},

{"path", T_STRING, OFF(path), RO},

{"pathlen", T_INT, OFF(pathlen), RO},

{"server_uid", T_INT, OFF(server_uid), RO},

{"server_gid", T_INT, OFF(server_gid), RO},

{NULL} /* Sentinel */

};

typedef struct connobject {

} connobject;

static PyTypeObject connobjecttype;

#define is_connobject(op) ((op)->ob_type == &connobjecttype)

#undef OFF

#define OFF(x) offsetof(conn_rec, x)

static struct memberlist conn_memberlist[] = {

/* server in getattr */

/* base_server in getattr */

/* XXX vhost_lookup_data? */

{"child_num", T_INT, OFF(child_num), RO},

/* XXX BUFF? */

/* XXX struct sockaddr_in local_addr? */

/* XXX struct sockaddr_in remote_addr? */

{"remote_ip", T_STRING, OFF(remote_ip), RO},

{"remote_host", T_STRING, OFF(remote_host), RO},

{"remote_logname", T_STRING, OFF(remote_logname), RO},

{"user", T_STRING, OFF(user), RO},

{"ap_auth_type", T_STRING, OFF(ap_auth_type), RO},

/* XXX aborted, keepalive, keptalive, double_reverse, keepalives ? */

{NULL} /* Sentinel */

};

typedef struct requestobject {

} requestobject;

static PyTypeObject requestobjecttype;

#define is_requestobject(op) ((op)->ob_type == &requestobjecttype)

static PyObject * req_send_http_header (requestobject *self, PyObject *args);

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

static PyObject * req_write (requestobject *self, PyObject *args);

static PyObject * req_read (requestobject *self, PyObject *args);

static PyObject * req_get_config (requestobject *self, PyObject *args);

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

static PyObject * req_get_dirs (requestobject *self, PyObject *args);

static PyObject * req_add_common_vars (requestobject *self, PyObject *args);

static PyMethodDef requestobjectmethods[] = {

{"send_http_header", (PyCFunction) req_send_http_header, METH_VARARGS},

{"get_basic_auth_pw", (PyCFunction) req_get_basic_auth_pw, METH_VARARGS},

{"write", (PyCFunction) req_write, METH_VARARGS},

{"read", (PyCFunction) req_read, METH_VARARGS},

{"get_config", (PyCFunction) req_get_config, METH_VARARGS},

{"get_options", (PyCFunction) req_get_options, METH_VARARGS},

{"get_dirs", (PyCFunction) req_get_dirs, METH_VARARGS},

{"add_common_vars", (PyCFunction) req_add_common_vars, METH_VARARGS},

{ NULL, NULL } /* sentinel */

};

#undef OFF

#define OFF(x) offsetof(request_rec, x)

static struct memberlist request_memberlist[] = {

/* connection, server, next, prev, main in getattr */

{"the_request", T_STRING, OFF(the_request), RO},

{"assbackwards", T_INT, OFF(assbackwards), RO},

{"proxyreq", T_INT, OFF(proxyreq), RO},

{"header_only", T_INT, OFF(header_only), RO},

{"protocol", T_STRING, OFF(protocol), RO},

{"proto_num", T_INT, OFF(proto_num), RO},

{"hostname", T_STRING, OFF(hostname), RO},

{"request_time", T_LONG, OFF(request_time), RO},

{"status_line", T_STRING, OFF(status_line), RO},

{"status", T_INT, OFF(status) },

{"method", T_STRING, OFF(method), RO},

{"method_number", T_INT, OFF(method_number), RO},

{"allowed", T_INT, OFF(allowed), RO},

{"sent_bodyct", T_INT, OFF(sent_bodyct), RO},

{"bytes_sent", T_LONG, OFF(bytes_sent), RO},

{"mtime", T_LONG, OFF(mtime), RO},

{"chunked", T_INT, OFF(chunked), RO},

{"byterange", T_INT, OFF(byterange), RO},

{"boundary", T_STRING, OFF(boundary), RO},

{"range", T_STRING, OFF(range), RO},

{"clength", T_LONG, OFF(clength), RO},

{"remaining", T_LONG, OFF(remaining), RO},

{"read_length", T_LONG, OFF(read_length), RO},

{"read_body", T_INT, OFF(read_body), RO},

{"read_chunked", T_INT, OFF(read_chunked), RO},

{"content_type", T_STRING, OFF(content_type) },

{"handler", T_STRING, OFF(handler), RO},

{"content_encoding", T_STRING, OFF(content_encoding), RO},

{"content_language", T_STRING, OFF(content_language), RO},

/* XXX content_languages */

{"no_cache", T_INT, OFF(no_cache), RO},

{"no_local_copy", T_INT, OFF(no_local_copy), RO},

{"unparsed_uri", T_STRING, OFF(unparsed_uri), RO},

{"uri", T_STRING, OFF(uri), RO},

{"filename", T_STRING, OFF(filename), RO},

{"path_info", T_STRING, OFF(path_info), RO},

{"args", T_STRING, OFF(args), RO},

/* XXX finfo */

/* XXX parsed_uri */

/* XXX per_dir_config */

/* XXX request_config */

/* XXX htaccess */

{NULL} /* Sentinel */

};

module MODULE_VAR_EXPORT python_module;

extern module python_module;

typedef struct

{

int authoritative;

char *config_dir;

table *options;

table *directives;

table *dirs;

} py_dir_config;

static tableobject * make_tableobject(table * t)

{

tableobject *result;

result = PyMem_NEW(tableobject, 1);

if (! result)

return (tableobject *) PyErr_NoMemory();

result->table = t;

result->ob_type = &tableobjecttype;

result->pool = NULL;

_Py_NewReference(result);

return result;

}

static PyObject * make_table(PyObject *self, PyObject *args)

{

tableobject *t;

pool *p;

p = ap_make_sub_pool(NULL);

/* two is a wild guess */

t = make_tableobject(ap_make_table(p, 2));

/* remember the pointer to our own pool */

t->pool = p;

return (PyObject *)t;

}

static PyObject * table_getattr(PyObject *self, char *name)

{

return Py_FindMethod(tablemethods, self, name);

}

static PyObject * tablegetitem(tableobject *self, PyObject *key)

{

const char *v;

char *k;

k = PyString_AsString(key);

v = ap_table_get(self->table, k);

if (! v)

{

PyErr_SetObject(PyExc_KeyError, key);

return NULL;

}

return PyString_FromString(v);

}

static PyObject * table_has_key(tableobject *self, PyObject *args)

{

const char *val, *key;

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

return NULL;

val = ap_table_get (self->table, key);

if (val)

return PyInt_FromLong(1);

else

return PyInt_FromLong(0);

}

static int tablelength(tableobject *self)

{

return ap_table_elts(self->table)->nelts;

};

static int tablesetitem(tableobject *self, PyObject *key, PyObject

*val)

{

char *k;

if (key && !PyString_Check(key)) {

PyErr_SetString(PyExc_TypeError,

"table keys must be strings");

return -1;

}

k = PyString_AsString(key);

if ((val == Py_None) || (val == NULL)) {

ap_table_unset(self->table, k);

}

else {

if (val && !PyString_Check(val)) {

PyErr_SetString(PyExc_TypeError,

"table values must be strings");

return -1;

}

ap_table_set(self->table, k, PyString_AsString(val));

}

return 0;

};

static int tb_setitem(tableobject *self, const char *key, const char *val)

{

PyObject *ps1, *ps2;

ps1 = PyString_FromString(key);

ps2 = PyString_FromString(val);

tablesetitem(self, ps1, ps2);

Py_DECREF(ps1);

Py_DECREF(ps2);

return 0;

/* prevent complier warning about function

tb_setitem(self, key, val);

}

static void table_dealloc(tableobject *self)

{

if (self->pool)

ap_destroy_pool(self->pool);

free(self);

}

static PyObject * table_repr(tableobject *self)

{

PyObject *s;

array_header *ah;

table_entry *elts;

int i;

s = PyString_FromString("{");

ah = ap_table_elts (self->table);

elts = (table_entry *) ah->elts;

i = ah->nelts;

if (i == 0)

PyString_ConcatAndDel(&s, PyString_FromString("}"));

while (i--)

if (elts[i].key)

{

PyString_ConcatAndDel(&s, PyString_FromString("'"));

PyString_ConcatAndDel(&s, PyString_FromString(elts[i].key));

PyString_ConcatAndDel(&s, PyString_FromString("': '"));

PyString_ConcatAndDel(&s, PyString_FromString(elts[i].val));

PyString_ConcatAndDel(&s, PyString_FromString("'"));

if (i > 0)

PyString_ConcatAndDel(&s, PyString_FromString(", "));

else

PyString_ConcatAndDel(&s, PyString_FromString("}"));

}

return s;

}

static PyObject * table_keys(tableobject *self)

{

PyObject *v;

array_header *ah;

table_entry *elts;

int i, j;

ah = ap_table_elts(self->table);

elts = (table_entry *) ah->elts;

v = PyList_New(ah->nelts);

for (i = 0, j = 0; i < ah->nelts; i++)

{

if (elts[i].key)

{

PyObject *key = PyString_FromString(elts[i].key);

PyList_SetItem(v, j, key);

j++;

}

}

return v;

}

static void copy_table(table *t1, table *t2)

{

array_header *ah;

table_entry *elts;

int i;

ah = ap_table_elts(t2);

elts = (table_entry *)ah->elts;

i = ah->nelts;

while (i--)

if (elts[i].key)

ap_table_set(t1, elts[i].key, elts[i].val);

}

static void print_table(table * t)

{

array_header *ah;

table_entry *elts;

int i;

ah = ap_table_elts (t);

elts = (table_entry *) ah->elts;

i = ah->nelts;

while (i--)

if (elts[i].key)

printf(" %s: \t%s\n", elts[i].key, elts[i].val);

}

static void *print_array(array_header *ah)

{

int i;

char **elts;

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

for (i = 0; i < ah->nelts; ++i) {

printf("%s ", elts[i]);

}

printf("\n");

return NULL;

/* avoid compiler warning */

print_array(ah);

}

static serverobject * make_serverobject(server_rec *t)

{

serverobject *result;

result = PyMem_NEW(serverobject, 1);

if (! result)

return (serverobject *) PyErr_NoMemory();

result->server = t;

result->ob_type = &serverobjecttype;

result->next = NULL;

_Py_NewReference(result);

return result;

}

static void server_dealloc(serverobject *self)

{

Py_XDECREF(self->next);

free(self);

}

static PyObject * server_getattr(serverobject *self, char *name)

{

if (strcmp(name, "next") == 0)

/* server.next serverobject is created as needed */

if (self->next == NULL) {

if (self->server->next == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

else {

self->next = (PyObject *)make_serverobject(self->server->next);

Py_INCREF(self->next);

return self->next;

}

}

else {

Py_INCREF(self->next);

return self->next;

}

else if (strcmp(name, "error_log") == 0)

return PyInt_FromLong((long)fileno(self->server->error_log));

else if (strcmp(name, "names") == 0) {

return tuple_from_array_header(self->server->names);

}

else if (strcmp(name, "wild_names") == 0) {

return tuple_from_array_header(self->server->wild_names);

}

else

return PyMember_Get((char *)self->server, server_memberlist, name);

}

static connobject * make_connobject(conn_rec *t)

{

connobject *result;

result = PyMem_NEW(connobject, 1);

if (! result)

return (connobject *) PyErr_NoMemory();

result->conn = t;

result->ob_type = &connobjecttype;

result->server = NULL;

result->base_server = NULL;

_Py_NewReference(result);

return result;

}

static void conn_dealloc(connobject *self)

{

Py_XDECREF(self->server);

Py_XDECREF(self->base_server);

free(self);

}

static PyObject * conn_getattr(connobject *self, char *name)

{

if (strcmp(name, "server") == 0) {

/* server serverobject is created as needed */

if (self->server == NULL) {

if (self->conn->server == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

else {

self->server = (PyObject *)make_serverobject(self->conn->server);

Py_INCREF(self->server);

return self->server;

}

}

else {

Py_INCREF(self->server);

return self->server;

}

}

else if (strcmp(name, "base_server") == 0) {

/* base_server serverobject is created as needed */

if (self->base_server == NULL) {

if (self->conn->base_server == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

else {

self->base_server = (PyObject *)make_serverobject(self->conn->base_server);

Py_INCREF(self->base_server);

return self->base_server;

}

}

else {

Py_INCREF(self->base_server);

return self->base_server;

}

}

else

return PyMember_Get((char *)self->conn, conn_memberlist, name);

}

static requestobject * make_requestobject(request_rec *req)

{

requestobject *result;

result = PyMem_NEW(requestobject, 1);

if (! result)

return (requestobject *) PyErr_NoMemory();

result->request_rec = req;

result->ob_type = &requestobjecttype;

result->connection = NULL;

result->server = NULL;

result->next = NULL;

result->prev = NULL;

result->main = NULL;

result->headers_in = make_tableobject(req->headers_in);

result->headers_out = make_tableobject(req->headers_out);

result->err_headers_out = make_tableobject(req->err_headers_out);

result->subprocess_env = make_tableobject(req->subprocess_env);

result->notes = make_tableobject(req->notes);

result->header_sent = 0;

_Py_NewReference(result);

ap_register_cleanup(req->pool, (PyObject *)result, python_decref, noop);

return result;

}

static void request_dealloc(requestobject *self)

{

Py_XDECREF(self->connection);

Py_XDECREF(self->server);

Py_XDECREF(self->next);

Py_XDECREF(self->prev);

Py_XDECREF(self->main);

Py_XDECREF(self->headers_in);

Py_XDECREF(self->headers_out);

Py_XDECREF(self->err_headers_out);

Py_XDECREF(self->subprocess_env);

Py_XDECREF(self->notes);

free(self);

}

static PyObject * request_getattr(requestobject *self, char *name)

{

PyObject *res;

res = Py_FindMethod(requestobjectmethods, (PyObject *)self, name);

if (res != NULL)

return res;

PyErr_Clear();

if (strcmp(name, "connection") == 0) {

if (self->connection == NULL) {

if (self->request_rec->connection == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

else {

self->connection = (PyObject *)make_connobject(self->request_rec->connection);

Py_INCREF(self->connection);

return self->connection;

}

}

else {

Py_INCREF(self->connection);

return self->connection;

}

}

else if (strcmp(name, "server") == 0) {

if (self->server == NULL) {

if (self->request_rec->server == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

else {

self->server = (PyObject *)make_serverobject(self->request_rec->server);

Py_INCREF(self->server);

return self->server;

}

}

else {

Py_INCREF(self->server);

return self->server;

}

}