/*

* Copyright (C) 2000, 2001, 2013 Gregory Trubetskoy

* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Apache Software Foundation

*

* Licensed under the Apache License, Version 2.0 (the "License"); you

* may not use this file except in compliance with the License. You

* may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

* implied. See the License for the specific language governing

* permissions and limitations under the License.

*

* Originally developed by Gregory Trubetskoy.

*

*

* mod_python.c

*

*

* See accompanying documentation and source code comments

* for details.

*

*/

#include "mod_python.h"

static PyThreadState* global_tstate;

/* Server object for main server as supplied to python_init(). */

static server_rec *main_server = NULL;

/* List of available Python obCallBacks/Interpreters */

static apr_hash_t *interpreters = NULL;

static apr_pool_t *interp_pool = NULL;

static void release_interpreter(interpreterdata *idata);

apr_pool_t *child_init_pool = NULL;

/* Optional functions imported from mod_include when loaded: */

static APR_OPTIONAL_FN_TYPE(ap_register_include_handler) *optfn_register_include_handler;

static APR_OPTIONAL_FN_TYPE(ap_ssi_get_tag_and_value) *optfn_ssi_get_tag_and_value;

static APR_OPTIONAL_FN_TYPE(ap_ssi_parse_string) *optfn_ssi_parse_string;

/*

* Python3 uses wchar_t * for strings; Python2 uses char *.

* So for printing we need a different format string.

*/

#if PY_MAJOR_VERSION < 3

# define PRIs "%s"

#else

# define PRIs "%ls"

#endif

/**

** make_obcallback

**

* This function instantiates an obCallBack object.

* NOTE: The obCallBack object is instantiated by Python

* code. This C module calls into Python code which returns

* the reference to obCallBack.

*/

static PyObject * make_obcallback(const char *name)

{

PyObject *m = NULL;

PyObject *obCallBack = NULL;

/* This makes _apache appear imported, and subsequent

* >>> import _apache

* will not give an error.

*/

_apache_module_init();

/* Now execute the equivalent of

* >>> import <module>

* >>> <initstring>

* in the __main__ module to start up Python.

*/

m = PyImport_ImportModule("mod_python.apache");

if (!m) {

PyObject *path;

char *c_path;

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"make_obcallback: could not import mod_python.apache.\n");

PyErr_Print();

fflush(stderr);

path = PyObject_Repr(PySys_GetObject("path"));

MP_ANYSTR_AS_STR(c_path, path, 0);

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"make_obcallback: Python path being used \"%s\".",

c_path);

Py_DECREF(path);

return NULL;

} else {

/* Make sure that C and Python code have the same version */

const char *mp_dynamic_version = "<unknown>";

PyObject *mp = PyImport_ImportModule("mod_python");

if (mp) {

PyObject *d = PyModule_GetDict(mp);

PyObject *o = PyDict_GetItemString(d, "mp_version");

PyObject *f = PyDict_GetItemString(d, "__file__");

MP_ANYSTR_AS_STR(mp_dynamic_version, o, 1);

if (!mp_dynamic_version) {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"make_obcallback: fatal: mp_dynamic_version is NULL.");

Py_DECREF(o);

Py_DECREF(mp);

return NULL;

}

if (strcmp(mp_version_string, mp_dynamic_version) != 0) {

char *c_f;

ap_log_error(APLOG_MARK, APLOG_WARNING, 0, main_server,

"WARNING: mod_python version mismatch, expected '%s', found '%s'.",

mp_version_string, mp_dynamic_version);

MP_ANYSTR_AS_STR(c_f, f, 1);

ap_log_error(APLOG_MARK, APLOG_WARNING, 0, main_server,

"WARNING: mod_python modules location '%s'.", c_f);

Py_DECREF(f); /* MP_ANYSTR_AS_STR */

}

Py_DECREF(o); /* MP_ANYSTR_AS_STR */

Py_XDECREF(mp);

/* call init to get obCallBack */

if (! (obCallBack = PyObject_CallMethod(

m, "init", "sO", name, MpServer_FromServer(main_server)))) {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"make_obcallback: could not call init().");

PyErr_Print();

fflush(stderr);

}

} else {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"make_obcallback: could not import mod_python");

}

}

Py_XDECREF(m);

return obCallBack;

}

/**

** save_interpreter

**

* Save the interpreter. The argument is a PyThreadState

* belonging to (i.e. tstate->interp) the interpreter we are

* saving. Creates a new interpreterdata and returns a pointer to

* it.

*/

static interpreterdata *save_interpreter(const char *name, PyThreadState *tstate)

{

interpreterdata *idata = NULL;

idata = (interpreterdata *)malloc(sizeof(interpreterdata));

if (!idata)

return NULL;

idata->tstates = apr_array_make(interp_pool, 128, sizeof(interpreterdata *));

idata->interp = tstate->interp;

idata->obcallback = NULL;

apr_hash_set(interpreters, name, APR_HASH_KEY_STRING, idata);

return idata;

}

/*

* python_interpreter_name

*

* Get name of current interpreter. Must be called while lock is held.

* This is effectively a shortcut for accessing "apache.interpreter".

*/

PyObject *python_interpreter_name()

{

PyObject *m = NULL;

PyObject *d = NULL;

PyObject *o = NULL;

m = PyImport_ImportModule("mod_python.apache");

if (m) {

d = PyModule_GetDict(m);

o = PyDict_GetItemString(d, "interpreter");

if (o) {

Py_INCREF(o);

Py_DECREF(m);

return o;

}

}

return 0;

}

/**

** get_interpreter

**

* Get interpreter given its name.

*

* A thread state never outlives a handler; when a phase of a handler

* is done, there is no use for this thread state. But there is no

* need to malloc() a new thread state at every request, so when a

* handler is done, in release_interpreter() we push the tstate into

* an array of available tstates for this interpreter. When we need

* another tstate, we pop from this array, and only if that returns

* nothing do we create a new tstate.

*

*/

static interpreterdata *get_interpreter(const char *name)

{

PyThreadState *tstate;

interpreterdata *idata = NULL;

if (! name)

name = MAIN_INTERPRETER;

/* Py_NewInterpreter requires the GIL held, this is one way to have it so */

PyEval_RestoreThread(global_tstate);

idata = apr_hash_get(interpreters, name, APR_HASH_KEY_STRING);

if (!idata) {

tstate = Py_NewInterpreter();

if (!tstate) {

/* couldn't create an interpreter, this is bad */

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"get_interpreter: Py_NewInterpreter() returned NULL. No more memory?");

return NULL;

}

idata = save_interpreter(name, tstate);

if (!idata) {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"get_interpreter: save_interpreter() returned NULL. No more memory?");

return NULL;

}

}

else {

#ifdef WITH_THREAD

/* use an available tstate, or create a new one */

PyThreadState ** tstate_pp;

tstate_pp = (PyThreadState **)apr_array_pop(idata->tstates);

if (!tstate_pp)

tstate = PyThreadState_New(idata->interp);

else

tstate = *tstate_pp;

#else

/* always use the first (and only) tstate */

tstate = idata->interp->tstate_head;

#endif

PyThreadState_Swap(tstate);

}

/* At this point GIL is held and tstate is set, we're ready to run */

if (!idata->obcallback) {

idata->obcallback = make_obcallback(name);

if (!idata->obcallback) {

release_interpreter(idata);

ap_log_error(APLOG_MARK, APLOG_ERR, 0, main_server,

"get_interpreter: no interpreter callback found.");

return NULL;

}

}

return idata;

}

/**

** release_interpreter

**

* Release interpreter.

*/

static void release_interpreter(interpreterdata *idata)

{

PyThreadState *tstate = PyThreadState_Get();

#ifdef WITH_THREAD

#if PY_MAJOR_VERSION <= 3 && PY_MINOR_VERSION < 9

PyThreadState_Clear(tstate);

#endif

if (idata)

APR_ARRAY_PUSH(idata->tstates, PyThreadState *) = tstate;

else

PyThreadState_Delete(tstate);

PyEval_ReleaseThread(tstate);

#else

if (!idata) PyThreadState_Delete(tstate);

#endif

}

/**

** pytho_cleanup

**

* This function gets called for clean ups registered

* with register_cleanup(). Clean ups registered via

* PythonCleanupHandler run in python_cleanup_handler()

* below.

*/

apr_status_t python_cleanup(void *data)

{

interpreterdata *idata;

cleanup_info *ci = (cleanup_info *)data;

/* get/create interpreter */

idata = get_interpreter(ci->interpreter);

if (!idata) {

Py_DECREF(ci->handler);

Py_XDECREF(ci->data);

free((void *)ci->interpreter);

free(ci);

return APR_SUCCESS; /* this is ignored anyway */

}

/*

* Call the cleanup function.

*/

if (! PyObject_CallFunction(ci->handler, "O", ci->data)) {

PyObject *ptype;

PyObject *pvalue;

PyObject *ptb;

PyObject *handler;

PyObject *stype;

PyObject *svalue;

char *c_handler, *c_svalue, *c_stype;

PyErr_Fetch(&ptype, &pvalue, &ptb);

handler = PyObject_Str(ci->handler);

stype = PyObject_Str(ptype);

svalue = PyObject_Str(pvalue);

Py_XDECREF(ptype);

Py_XDECREF(pvalue);

Py_XDECREF(ptb);

MP_ANYSTR_AS_STR(c_handler, handler, 0);

if (!c_handler) c_handler = "<ERROR>";

MP_ANYSTR_AS_STR(c_svalue, svalue, 0);

if (!c_svalue) c_svalue = "<ERROR>";

MP_ANYSTR_AS_STR(c_stype, stype, 0);

if (!c_stype) c_stype = "<ERROR>";

if (ci->request_rec) {

ap_log_rerror(APLOG_MARK, APLOG_ERR, 0,

ci->request_rec,

"python_cleanup: Error calling cleanup object %s",

c_handler);

ap_log_rerror(APLOG_MARK, APLOG_ERR, 0,

ci->request_rec,

" %s: %s", c_stype, c_svalue);

}

else {

ap_log_error(APLOG_MARK, APLOG_ERR, 0,

ci->server_rec,

"python_cleanup: Error calling cleanup object %s",

c_handler);

ap_log_error(APLOG_MARK, APLOG_ERR, 0,

ci->server_rec,

" %s: %s", c_stype, c_svalue);

}

Py_DECREF(handler);

Py_DECREF(stype);

Py_DECREF(svalue);

}

Py_DECREF(ci->handler);

Py_DECREF(ci->data);

free((void *)ci->interpreter);

free(ci);

release_interpreter(idata);

return APR_SUCCESS;

}

static apr_status_t init_mutexes(server_rec *s, apr_pool_t *p, py_global_config *glb)

{

int max_threads = 0;

int max_procs = 0;

int is_threaded = 0;

int is_forked = 0;

int max_clients;

int locks;

int n;

const char *val;

const char *mutex_dir;

py_config *conf;

conf = (py_config *) ap_get_module_config(s->module_config,

&python_module);

/* figure out maximum possible concurrent connections */

/* MAX_DAEMON_USED seems to account for MaxClients, as opposed to

MAX_DAEMONS, which is ServerLimit

*/

ap_mpm_query(AP_MPMQ_IS_THREADED, &is_threaded);

if (is_threaded != AP_MPMQ_NOT_SUPPORTED) {

ap_mpm_query(AP_MPMQ_MAX_THREADS, &max_threads);

}

ap_mpm_query(AP_MPMQ_IS_FORKED, &is_forked);

if (is_forked != AP_MPMQ_NOT_SUPPORTED) {

/* XXX This looks strange, and it is. prefork.c seems to use

MAX_DAEMON_USED the same way that worker.c uses

MAX_DAEMONS (prefork is wrong IMO) */

ap_mpm_query(AP_MPMQ_MAX_DAEMON_USED, &max_procs);

if (max_procs == -1) {

ap_mpm_query(AP_MPMQ_MAX_DAEMONS, &max_procs);

}

}

max_clients = (((max_threads <= 0) ? 1 : max_threads) *

((max_procs <= 0) ? 1 : max_procs));

/* On some systems the locking mechanism chosen uses valuable

system resources, notably on RH 8 it will use sysv ipc for

which Linux by default provides only 128 semaphores

system-wide, and on many other systems flock is used, which

results in a relatively large number of open files.

The maximum number of locks can be specified at

compile time using "./configure --with-max-locks value" or

at run time with "PythonOption mod_python.mutex_locks value".

If the PythonOption directive is used, it must be in a

server config context, otherwise it will be ignored.

The optimal number of necessary locks is not clear, perhaps a

small number is more than sufficient - if someone took the

time to run some research on this, that'd be most welcome!

*/

val = apr_table_get(conf->options, "mod_python.mutex_locks");

if (val) {

locks = atoi(val);

} else {

locks = MAX_LOCKS;

}

locks = (max_clients > locks) ? locks : max_clients;

ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, s,

"mod_python: Creating %d session mutexes based "

"on %d max processes and %d max threads.",

locks, max_procs, max_threads);

glb->g_locks = (apr_global_mutex_t **)

apr_palloc(p, locks * sizeof(apr_global_mutex_t *));

glb->nlocks = locks;

glb->parent_pid = getpid();

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)

/* On some sytems a directory for the mutex lock files is required.

This mutex directory can be specifed at compile time using

"./configure --with-mutex-dir value" or at run time with

"PythonOption mod_python.mutex_directory value".

If the PythonOption directive is used, it must be in a

server config context, otherwise it will be ignored.

XXX Should we check if mutex_dir exists and has the correct

permissions?

*/

mutex_dir = apr_table_get(conf->options, "mod_python.mutex_directory");

if (!mutex_dir)

mutex_dir = MUTEX_DIR;

ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, s,

"mod_python: using mutex_directory %s ",

mutex_dir);

#endif

for (n=0; n<locks; n++) {

apr_status_t rc;

apr_global_mutex_t **mutex = glb->g_locks;

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)

char fname[255];

/* XXX What happens if len(mutex_dir) > 255 - len(mpmtx%d%d)? */

snprintf(fname, 255, "%s/mpmtx%d%d", mutex_dir, glb->parent_pid, n);

#else

char *fname = NULL;

#endif

rc = apr_global_mutex_create(&mutex[n], fname, APR_LOCK_DEFAULT,

p);

if (rc != APR_SUCCESS) {

ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,

"mod_python: Failed to create global mutex %d of %d (%s).",

n, locks, (!fname) ? "<null>" : fname);

if (n > 1) {

/* we were able to create at least two, so lets just print a

warning/hint and proceed

*/

ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,

"mod_python: We can probably continue, but with diminished ability "

"to process session locks.");

ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,

"mod_python: Hint: On Linux, the problem may be the number of "

"available semaphores, check 'sysctl kernel.sem'");

/* now free two locks so that if there is another

module or two that wants a lock, it will be ok */

apr_global_mutex_destroy(mutex[n-1]);

glb->nlocks = n-1;

if (n > 2) {

apr_global_mutex_destroy(mutex[n-2]);

glb->nlocks = n-2;

}

break;

}

else {

return rc;

}

}

else {

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)

#if AP_MODULE_MAGIC_AT_LEAST(20081201,0)

ap_unixd_set_global_mutex_perms(mutex[n]);

#else

if (!geteuid()) {

chown(fname, unixd_config.user_id, -1);

unixd_set_global_mutex_perms(mutex[n]);

}

#endif

#endif

}

}

return APR_SUCCESS;

}

static apr_status_t reinit_mutexes(server_rec *s, apr_pool_t *p, py_global_config *glb)

{

int n;

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)

/* Determine the directory to use for mutex lock files.

See init_mutexes function for more details.

*/

const char *mutex_dir;

py_config *conf;

conf = (py_config *) ap_get_module_config(s->module_config,

&python_module);

mutex_dir = apr_table_get(conf->options, "mod_python.mutex_directory");

if (!mutex_dir)

mutex_dir = MUTEX_DIR;

#endif

for (n=0; n< glb->nlocks; n++) {

apr_status_t rc;

apr_global_mutex_t **mutex = glb->g_locks;

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)

char fname[255];

snprintf(fname, 255, "%s/mpmtx%d%d", mutex_dir, glb->parent_pid, n);

#else

char *fname = NULL;

#endif

rc = apr_global_mutex_child_init(&mutex[n], fname, p);

if (rc != APR_SUCCESS) {

ap_log_error(APLOG_MARK, APLOG_STARTUP, rc, s,

"mod_python: Failed to reinit global mutex %s.",

(!fname) ? "<null>" : fname);

return rc;

}

}

return APR_SUCCESS;

}

/**

** python_create_global_config

**

* This creates the part of config that survives

* server restarts

*

*/

static py_global_config *python_create_global_config(server_rec *s)

{

apr_pool_t *pool = s->process->pool;

py_global_config *glb;

/* do we already have it in s->process->pool? */

apr_pool_userdata_get((void **)&glb, MP_CONFIG_KEY, pool);

if (glb) {

return glb;

}

/* otherwise, create it */

glb = (py_global_config *)apr_palloc(pool, sizeof(*glb));

apr_pool_userdata_set(glb, MP_CONFIG_KEY,

apr_pool_cleanup_null,

pool);

return glb;

}

/*

* mp_acquire_interpreter()

*

* Exported function for acquiring named interpreter.

*/

PyInterpreterState *mp_acquire_interpreter(const char *name)

{

interpreterdata *idata;

idata = get_interpreter(name);

return idata->interp;

}

/*

* mp_release_interpreter()

*

* Exported function for releasing acquired interpreter.

*

*/

void mp_release_interpreter(void)

{

release_interpreter(NULL);

}

/*

* mp_get_request_object(request_rec *req)

*

* Exported function for obtaining wrapper for request object.

*

*/

PyObject *mp_get_request_object(request_rec *req)

{

requestobject *request_obj;

request_obj = python_get_request_object(req, 0);

return (PyObject *)request_obj;

}

/*

* mp_get_server_object(server_rec *srv)

*

* Exported function for obtaining wrapper for server object.

*

*/

PyObject *mp_get_server_object(server_rec *srv)

{

return (PyObject *)MpServer_FromServer(srv);

}

/*

* mp_get_connection_object(conn_rec *conn)

*

* Exported function for obtaining wrapper for connection object.

*

*/

PyObject *mp_get_connection_object(conn_rec *conn)

{

return (PyObject *)MpConn_FromConn(conn);

}

/**

** python_init()

**

* Called by Apache at mod_python initialization time.

*/

static int python_init(apr_pool_t *p, apr_pool_t *ptemp,

apr_pool_t *plog, server_rec *s)

{

char buff[255];

void *data;

py_global_config *glb;

const char *userdata_key = "python_init";

apr_status_t rc;

const char *py_dynamic_version = 0;

/* The "initialized" flag is a fudge for Mac OS X. It

* addresses two issues. The first is that when an Apache

* "restart" is performed, Apache will unload the mod_python

* shared object, but not the Python framework. This means

* that when "python_init()" is called after the restart,

* the mod_python initialization will not run if only the

* initialized state of Python is checked, because Python

* is already initialized. The second problem is that for

* some older revisions of Mac OS X, even on the initial

* startup of Apache, the "Py_IsInitialized()" function

* would return true and mod_python wouldn't initialize

* itself correctly and would crash.

*/

static int initialized = 0;

#ifdef WIN32

/* No need to run python_init() in Win32 parent processes as

* the lack of fork on Win32 means we get no benefit as far as

* inheriting a preinitialized Python interpreter. Further,

* upon a restart on Win32 platform the python_init() function

* will be called again in the parent process but without some

* resources allocated by the previous call having being

* released properly, resulting in memory and Win32 resource

* leaks.

*/

if (!getenv("AP_PARENT_PID"))

return OK;

#endif /* WIN32 */

apr_pool_userdata_get(&data, userdata_key, s->process->pool);

if (!data) {

apr_pool_userdata_set((const void *)1, userdata_key,

apr_pool_cleanup_null, s->process->pool);

return OK;

}

/* mod_python version */

ap_add_version_component(p, mp_version_component);

py_dynamic_version = strtok((char *)Py_GetVersion(), " ");

/* Python version */

sprintf(buff, "Python/%.200s", py_dynamic_version);

ap_add_version_component(p, buff);

/* cache main server */

main_server = s;

/* global config */

glb = python_create_global_config(s);

if ((rc = init_mutexes(s, p, glb)) != APR_SUCCESS) {

return rc;

}

/* initialize global Python interpreter if necessary */

if (initialized == 0 || !Py_IsInitialized())

{

initialized = 1;

/* disable user site directories */

Py_NoUserSiteDirectory = 1;

/* Initialze the main interpreter. */

#if PY_MAJOR_VERSION == 2 && \

(PY_MINOR_VERSION < 7 || (PY_MINOR_VERSION == 7 && PY_MICRO_VERSION < 14))

/*

* We do not want site.py to

* be imported because as of Python 2.7.9 it would cause a

* circular dependency related to _locale which breaks

* graceful restart so we set Py_NoSiteFlag to 1 just for this

* one time. (https://github.com/grisha/mod_python/issues/46)

*/

Py_NoSiteFlag = 1;

#endif

Py_Initialize();

#if PY_MAJOR_VERSION == 2 && \

(PY_MINOR_VERSION < 7 || (PY_MINOR_VERSION == 7 && PY_MICRO_VERSION < 14))

Py_NoSiteFlag = 0;

#endif

/* see https://docs.python.org/3/c-api/init.html#c.PyEval_InitThreads */

#if defined (WITH_THREAD) && PY_VERSION_HEX < 0x03070000

/* create and acquire the interpreter lock */

PyEval_InitThreads();

#endif

/* create the obCallBack dictionary */

interpreters = apr_hash_make(p);

interp_pool = p;

if (! interpreters) {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,

"python_init: apr_hash_make() failed! No more memory?");

exit(1);

}

/* save the global_tstate */

global_tstate = PyEval_SaveThread();

}

APR_REGISTER_OPTIONAL_FN(mp_acquire_interpreter);

APR_REGISTER_OPTIONAL_FN(mp_release_interpreter);

APR_REGISTER_OPTIONAL_FN(mp_get_request_object);

APR_REGISTER_OPTIONAL_FN(mp_get_server_object);

APR_REGISTER_OPTIONAL_FN(mp_get_connection_object);

return OK;

}

/**

** python_create_config

**

* Called by create_dir_config and create_srv_config

*/

static py_config *python_create_config(apr_pool_t *p)

{

py_config *conf =

(py_config *) apr_pcalloc(p, sizeof(py_config));

conf->authoritative = 1;

conf->d_is_location = 0;

conf->options = apr_table_make(p, 4);

conf->directives = apr_table_make(p, 4);

conf->hlists = apr_hash_make(p);

conf->in_filters = apr_hash_make(p);

conf->out_filters = apr_hash_make(p);

return conf;

}

/**

** python_create_dir_config

**

* Allocate memory and initialize the strucure that will

* hold configuration parametes.

*

* This function is called on every hit it seems.

*/

static void *python_create_dir_config(apr_pool_t *p, char *dir)

{

py_config *conf = python_create_config(p);

conf->config_dir = dir;

return conf;

}

/**

** python_create_srv_config

**

* Allocate memory and initialize the strucure that will

* hold configuration parametes.

*/

static void *python_create_srv_config(apr_pool_t *p, server_rec *srv)

{

py_config *conf = python_create_config(p);

return conf;

}

/**

** modpython_table_overlap

**

* Replaces the apr_table_overlap() function using a specific pool

* for the resulting table.

*/

static apr_table_t *modpython_table_overlap(apr_pool_t *p,

apr_table_t *current_table,

apr_table_t *new_table)

{

apr_table_t *merge = apr_table_overlay(p, current_table, new_table);

apr_table_compress(merge, APR_OVERLAP_TABLES_SET);

return merge;

}

/**

** python_merge_dir_config

**

*/

static void *python_merge_config(apr_pool_t *p, void *current_conf,

void *new_conf)

{

py_config *merged_conf =

(py_config *) apr_pcalloc(p, sizeof(py_config));

py_config *cc = (py_config *) current_conf;

py_config *nc = (py_config *) new_conf;

apr_hash_index_t *hi;

char *key;

apr_ssize_t klen;

hl_entry *hle;

py_handler *fh;

/* we basically allow the local configuration to override global,

* by first copying current values and then new values on top

*/

/** create **/

merged_conf->hlists = apr_hash_make(p);

merged_conf->in_filters = apr_hash_make(p);

merged_conf->out_filters = apr_hash_make(p);

/** merge directives and options **/

merged_conf->directives = modpython_table_overlap(p, cc->directives,

nc->directives);

merged_conf->options = modpython_table_overlap(p, cc->options,

nc->options);

/** copy current **/

merged_conf->authoritative = cc->authoritative;

merged_conf->config_dir = apr_pstrdup(p, cc->config_dir);

merged_conf->d_is_location = cc->d_is_location;

for (hi = apr_hash_first(p, cc->hlists); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void **)&key, &klen, (void **)&hle);

apr_hash_set(merged_conf->hlists, key, klen, (void *)hle);

}

for (hi = apr_hash_first(p, cc->in_filters); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void **)&key, &klen, (void **)&fh);

apr_hash_set(merged_conf->in_filters, key, klen, (void *)fh);

}

for (hi = apr_hash_first(p, cc->out_filters); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void **)&key, &klen, (void **)&fh);

apr_hash_set(merged_conf->out_filters, key, klen, (void *)fh);

}

/** copy new **/

if (nc->authoritative != merged_conf->authoritative)

merged_conf->authoritative = nc->authoritative;

if (nc->config_dir) {

merged_conf->config_dir = apr_pstrdup(p, nc->config_dir);

merged_conf->d_is_location = nc->d_is_location;

}

for (hi = apr_hash_first(p, nc->hlists); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void**)&key, &klen, (void **)&hle);

apr_hash_set(merged_conf->hlists, key, klen, (void *)hle);

}

for (hi = apr_hash_first(p, nc->in_filters); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void**)&key, &klen, (void **)&fh);

apr_hash_set(merged_conf->in_filters, key, klen, (void *)fh);

}

for (hi = apr_hash_first(p, nc->out_filters); hi; hi=apr_hash_next(hi)) {

apr_hash_this(hi, (const void**)&key, &klen, (void **)&fh);

apr_hash_set(merged_conf->out_filters, key, klen, (void *)fh);

}

return (void *) merged_conf;

}

/**

** python_directive

**

* Called by non-handler directives

*

*/

static const char *python_directive(cmd_parms *cmd, void * mconfig,

char *key, const char *val)

{

py_config *conf;

conf = (py_config *) mconfig;

apr_table_set(conf->directives, key, val);

return NULL;

}

/* returns a parent if it matches the given directive */

static const ap_directive_t * find_parent(const ap_directive_t *dirp,

const char *what)