void w_long(long x, WFILE *p)
{
w_byte((char)( x & 0xff), p);
w_byte((char)((x>> 8) & 0xff), p);
w_byte((char)((x>>16) & 0xff), p);
w_byte((char)((x>>24) & 0xff), p);
}
void write_string(const char* s, WFILE* p)
{
int len = (int)strlen(s);
w_byte(TYPE_STRING, p);
w_long((long)len, p);
w_string(s, len, p);
//log_message(s,p->r);
}
void w_string(const char *s, int n, WFILE *p)
{
//log_message("In w_string", p->r);
while (--n >= 0) {
w_byte(*s, p);
s++;
}
}
void write_integer(int number, WFILE* wf)
{
long x;
x = (long)number;
#if SIZEOF_LONG > 4
long y = x>>31;
if (y && y != -1) {
w_byte(TYPE_INT64, wf);
w_long64(x, wf);
}
else
#endif
{
w_byte(TYPE_INT, wf);
w_long(x, wf);
}
}
static void
w_long(long x, WFILE *p)
{
w_byte((int)( x & 0xff), p);
w_byte((int)((x>> 8) & 0xff), p);
w_byte((int)((x>>16) & 0xff), p);
w_byte((int)((x>>24) & 0xff), p);
}
static void
w_string(char *s, int n, WFILE *p)
{
if (p->fp != NULL) {
fwrite(s, 1, n, p->fp);
}
else {
while (--n >= 0) {
w_byte(*s, p);
s++;
}
}
}
static void
w_object(PyObject *v, WFILE *p)
{
int i, n;
p->depth++;
if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
p->error = 2;
}
else if (v == NULL) {
w_byte(TYPE_NULL, p);
}
else if (v == Py_None) {
w_byte(TYPE_NONE, p);
}
else if (v == PyExc_StopIteration) {
w_byte(TYPE_STOPITER, p);
}
else if (v == Py_Ellipsis) {
w_byte(TYPE_ELLIPSIS, p);
}
else if (v == Py_False) {
w_byte(TYPE_FALSE, p);
}
else if (v == Py_True) {
w_byte(TYPE_TRUE, p);
}
else if (PyInt_Check(v)) {
long x = PyInt_AS_LONG((PyIntObject *)v);
#if SIZEOF_LONG > 4
long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
if (y && y != -1) {
w_byte(TYPE_INT64, p);
w_long64(x, p);
}
else
#endif
{
w_byte(TYPE_INT, p);
w_long(x, p);
}
}
else if (PyLong_Check(v)) {
static void
w_short(int x, WFILE *p)
{
w_byte((char)( x & 0xff), p);
w_byte((char)((x>> 8) & 0xff), p);
}
/* ====================================================================
* Here's the real content handler.
* ==================================================================== */
static int content_handler(request_rec *r)
{
long length;
wkcfg *cfg;
WFILE* env_dict = NULL;
int i;
char msgbuf[MAX_STRING_LEN];
int conn_attempt = 0;
WFILE* whole_dict = NULL;
WFILE* int_dict = NULL;
const char *value;
const char *key;
array_header *hdr_arr;
table_entry *elts;
cfg = ap_get_module_config(r->per_dir_config, &webkit_module);
if (cfg == NULL) {
log_debug("No cfg", r);
cfg = (wkcfg*)wk_create_dir_config(r->pool, "/");
}
env_dict = setup_WFILE(r);
whole_dict = setup_WFILE(r);
int_dict = setup_WFILE(r);
if (env_dict == NULL || whole_dict == NULL) {
log_error("Couldn't allocate Python data structures", r->server);
return HTTP_INTERNAL_SERVER_ERROR;
}
ap_add_common_vars(r);
ap_add_cgi_vars(r); /* not included in the common_vars above */
/* Build the environment dictionary */
hdr_arr = ap_table_elts(r->subprocess_env);
elts = (table_entry *)hdr_arr->elts;
/* start dictionary */
w_byte(TYPE_DICT, env_dict);
for (i = 0; i < hdr_arr->nelts; ++i) {
if (!elts[i].key)
continue;
key = elts[i].key;
value = ap_table_get(r->subprocess_env, elts[i].key);
write_string(key, env_dict);
if (value != NULL)
write_string(value, env_dict);
else
w_byte(TYPE_NONE, env_dict);
}
hdr_arr = cfg->passheaders;
if (hdr_arr) {
char **headers = (char **)hdr_arr->elts;
for (i = 0; i < hdr_arr->nelts; i++) {
key = headers[i];
value = ap_table_get(r->headers_in, key);
if (value && *value) {
write_string(key, env_dict);
write_string(value, env_dict);
}
}
}
#ifdef SECURITY_HOLE_PASS_AUTHORIZATION
/* Ordinarily Apache only makes the username available to CGI scripts,
keeping the password secret. It can be configured to make the complete
credential details available, but only by completely rebuilding the
server with SECURITY_HOLE_PASS_AUTHORIZATION set (enabling this feature
is considered a security risk). By setting the same constant, you can
have mod_webkit pass the authorization information to WebKit instead.
(suggested by Maximillian Dornseif 2003-10-27) */
key = "Authorization";
value = ap_table_get(r->headers_in, key);
if (value && *value) {
write_string("X-HTTP_AUTHORIZATION", env_dict);
write_string(value, env_dict);
}
#endif
w_byte(TYPE_NULL, env_dict);
/* end dictionary */
log_debug("Built env dictionary", r);
/* We can start building the full dictionary now */
w_byte(TYPE_DICT, whole_dict);
write_string("format", whole_dict); /* key */
write_string("CGI", whole_dict); /* value */
write_string("time", whole_dict); /* key */
w_byte(TYPE_INT, whole_dict); /* value */
/* patch from Ken Lalonde to make the time entry useful */
w_long((long)r->request_time, whole_dict); /* value */
write_string("environ", whole_dict); /* key */
/* copy env_dict into whole_dict */
insert_data(whole_dict, env_dict);
/* that should be it */
/* end dictionary */
w_byte(TYPE_NULL, whole_dict);
length = whole_dict->ptr - whole_dict->str;
write_integer((int)length, int_dict);
/* now we try to send it */
for (conn_attempt = 1; conn_attempt <= cfg->retryattempts; conn_attempt++) {
int result = transact_with_app_server(r, cfg, whole_dict, int_dict, length);
if (result == 0) {
return OK;
} else if (result == 2) {
log_error("error transacting with app server -- giving up.", r->server);
return HTTP_INTERNAL_SERVER_ERROR;
}
sprintf(msgbuf,
"Couldn't connect to AppServer, attempt %i of %i",
conn_attempt, cfg->retryattempts);
log_error(msgbuf, r->server);
sleep(cfg->retrydelay);
}
log_error("error transacting with app server -- giving up.", r->server);
return HTTP_INTERNAL_SERVER_ERROR;
}
static void
w_short(int x, WFILE *p)
{
w_byte( x & 0xff, p);
w_byte((x>> 8) & 0xff, p);
}