Hi,
Pada hari Sabtu, tanggal 15/10/2005 pukul 19:16 +0100, Alvaro Lopez
Ortega menulis:
> I have been reading this code, but it does not make much sense for
> me. It seems like you want to have an extra pointer in
> set_env_pair(), but what is its purpose?
I need to pass fcgi handler to set_env_pair, or at least fcgi->id to
build the environment buffer. Each env must be prefixed with FCGI_PARAMS
header. (However in fcgi spec we can see only one FCGI_PARAMS for -all-
environment variables, but it doesnt work)
> With FastCGI many connections can share a single connection to the
> FastCGI. It multiplexes all that information in a single stream,
> that is why there is IDs in the packages. The purpose of the
I see, now I have moved them again back to the manager side, now it
multiplex the buffer to be sent and demultiplex the data from fcgi
server. I use CHEROKEE_MUTEX_LOCK there to mark it as critical sections
(there are two of them, one is for sending, and one is for processing
the data).
fcgi_manager_step returns immediately if there is a response from fcgi
server which has not being picked up by handler. then handler would
reset the buffer after pick the data and return it to the main thread.
I have played it with ab (from apache stock) and had this result with
500 requests:
Server Software: Cherokee/0.4.27b2
Server Hostname: 127.0.0.1
Server Port: 8000
Document Path: /test.fcgi
Document Length: 4211 bytes
Concurrency Level: 1
Time taken for tests: 0.515189 seconds
Complete requests: 500
Failed requests: 0
Write errors: 0
Total transferred: 2172500 bytes
HTML transferred: 2105500 bytes
Requests per second: 970.52 [#/sec] (mean)
Time per request: 1.030 [ms] (mean)
Time per request: 1.030 [ms] (mean, across all concurrent
requests)
Transfer rate: 4116.94 [Kbytes/sec] received
However when I increased the concurrency level to more than 4, after
processing some requests, it stucked in
ret = cherokee_socket_read (fcgim->socket, &fcgim->read_buffer,
DEFAULT_READ_SIZE, &size);
(fcgi_manager.c:327)
any hints?
> > Questions:
> > 0. what should be returned by handler_step if:
> > a. data is ready (ret_ok? or ret_eof?)
>
> ret_eagain
> > b. there is an error (ret_error?)
>
> If it is a terminal error for the connection:
>
> cnt->error_code = ...;
> return ret_error;
>
> > c. data is incomplete, to be retried (ret_eagain?)
>
> If you got some data to be send, just put it on the buffer and
> return ret_ok
how to escape the step? what value should be returned?
> > 1. how to print to log?
>
> Do you want to log the connections? If so, do not do it; It should
> not do it from a handler.
>
> If what you want to write information about that FastCGI server
> state or something like that, you can use:
>
> cherokee_logger_write_string (CONN_VSRV(HANDLER_CONN(handler))->logger,
> "%s", whatever);
>
is this similar to apache writing to error_log?
thanks!
Index: fcgi_manager.c
===================================================================
--- fcgi_manager.c (revision 51)
+++ fcgi_manager.c (working copy)
@@ -48,6 +48,7 @@
n->port = DEFAULT_PORT;
cherokee_buffer_init (&n->hostname);
cherokee_buffer_init (&n->read_buffer);
+ n->request_id = 0;
cherokee_buffer_ensure_size (&n->read_buffer, DEFAULT_READ_SIZE);
@@ -208,7 +209,7 @@
fcgim->conn_poll[slot] = conn;
printf ("registered id=%d\n", slot);
- *id = slot;
+ *id = slot + 1;
return ret_ok;
}
@@ -247,52 +248,84 @@
static ret_t
process_read_buffer (cherokee_fcgi_manager_t *fcgim)
{
- cuint_t offset;
+ ret_t ret = ret_eagain;
+ cuint_t len;
FCGI_Header *header;
-
- offset = 0;
- while (fcgim->read_buffer.len - offset >= sizeof(FCGI_EndRequestRecord))
- {
- cuint_t id;
- cuint_t len;
- header = (FCGI_Header *)((&fcgim->read_buffer.buf) + offset);
- id = (header->requestIdB0 | (header->requestIdB1 << 8));
- len = (header->contentLengthB0 | (header->contentLengthB1 << 8)) + header->paddingLength;
+ /* There are still some data in read_buffer */
+ if (fcgim->remaining_size > 0) {
+ if (fcgim->remaining_size > fcgim->read_buffer.len) {
+ len = fcgim->remaining_size - fcgim->read_buffer.len;
+ fcgim->remaining_size -= len;
+ }
+ cherokee_buffer_add (&fcgim->request_buffer, fcgim->read_buffer.buf, len);
+ fcgim->last_offset += len;
+ ret = ret_ok;
+ } else {
+ cuint_t id;
+ void *start = fcgim->read_buffer.buf + fcgim->last_offset;
+ fcgim->remaining_size = 0;
+
+ header = (FCGI_Header *) start;
+ fcgim->request_id = (header->requestIdB0 | (header->requestIdB1 << 8));
+ fcgim->request_type = header->type;
+ len = (header->contentLengthB0 | (header->contentLengthB1 << 8));
+
+ if (len > (fcgim->read_buffer.size - FCGI_HEADER_LEN)) {
+ fcgim->remaining_size = len - fcgim->read_buffer.len - FCGI_HEADER_LEN;
+ len = fcgim->read_buffer.size - FCGI_HEADER_LEN;
+ }
+ fcgim->last_offset += len + FCGI_HEADER_LEN + header->paddingLength;
+
+ ret = ret_ok;
switch (header->type) {
case FCGI_STDERR:
- printf ("strerr\n");
+ cherokee_buffer_add (&fcgim->request_buffer, (start + FCGI_HEADER_LEN), len);
break;
case FCGI_STDOUT:
- printf ("stdout\n");
+ if (len > 0)
+ cherokee_buffer_add (&fcgim->request_buffer, (start + FCGI_HEADER_LEN), len);
+ else
+ ret = ret_eof;
break;
case FCGI_END_REQUEST:
- printf ("end request\n");
- break;
+ ret = ret_ok;
+ break;
default:
PRINT_ERROR ("ERROR: Unknown FCGI header type: %d\n", header->type);
+ ret = ret_error;
}
-
- offset += sizeof(FCGI_EndRequestRecord);
}
- return ret_ok;
+ if (fcgim->last_offset >= fcgim->read_buffer.len) {
+ cherokee_buffer_mrproper (&fcgim->read_buffer);
+ fcgim->last_offset = 0;
+ }
+
+ return ret;
}
-
ret_t
cherokee_fcgi_manager_step (cherokee_fcgi_manager_t *fcgim)
{
ret_t ret;
size_t size;
+ /* Data is ready please pick it up */
+ if (fcgim->request_id != 0) {
+ printf ("data is ready for %d\n", fcgim->request_id);
+ return ret_ok;
+ }
+
/* Read from the FastCGI application
*/
if (fcgim->read_buffer.len < sizeof(FCGI_Header))
{
+ printf ("start %d\n", fcgim->read_buffer.len);
+ fcgim->last_offset = 0;
ret = cherokee_socket_read (fcgim->socket, &fcgim->read_buffer, DEFAULT_READ_SIZE, &size);
- printf ("cherokee_fcgi_manager_step: _read %d\n", ret);
+ printf ("read %d\n", size);
if (ret != ret_ok) return ret;
}
@@ -301,8 +334,7 @@
if (fcgim->read_buffer.len >= sizeof(FCGI_Header))
{
ret = process_read_buffer (fcgim);
- printf ("cherokee_fcgi_manager_step: process %d\n", ret);
- return ret_ok;
+ return ret;
}
/* Read
@@ -310,7 +342,6 @@
return ret_eagain;
}
-
ret_t
cherokee_fcgi_manager_add_conn (cherokee_fcgi_manager_t *fcgim, cherokee_connection_t *conn)
{
Index: fcgi_manager.h
===================================================================
--- fcgi_manager.h (revision 51)
+++ fcgi_manager.h (working copy)
@@ -39,6 +39,13 @@
cherokee_buffer_t read_buffer;
+ int request_type;
+ cuint_t request_id;
+ cherokee_buffer_t request_buffer;
+
+ cuint_t last_offset;
+ cuint_t remaining_size;
+
/* Connections
*/
cherokee_connection_t **conn_poll;
Index: buffer.c
===================================================================
--- buffer.c (revision 51)
+++ buffer.c (working copy)
@@ -547,6 +547,7 @@
cherokee_buffer_print_debug (cherokee_buffer_t *buf, int len)
{
int i, length;
+ char text[17];
if ((len == -1) || (buf->len <= len)) {
length = buf->len;
@@ -554,20 +555,24 @@
length = len;
}
-
+ text [16] = 0;
for (i=0; i < length; i++) {
if (i%16 == 0) {
printf ("%08x ", i);
}
printf ("%02x", buf->buf[i] & 0xFF);
+ if (buf->buf[i] > ' ' && buf->buf[i] < 128)
+ text [i%16] = (char) buf->buf[i];
+ else
+ text [i%16] = '.';
if ((i+1)%2 == 0) {
printf (" ");
}
if ((i+1)%16 == 0) {
- printf ("\n");
+ printf ("%s\n", text);
}
fflush(stdout);
Index: Makefile.am
===================================================================
--- Makefile.am (revision 51)
+++ Makefile.am (working copy)
@@ -179,7 +179,7 @@
handler_fastcgi = \
$(common_cgi) \
-fastcgi.h \
+cgi.c cgi.h fastcgi.h \
handler_fastcgi.c \
handler_fastcgi.h \
fcgi_manager.h \
Index: handler_fastcgi.c
===================================================================
--- handler_fastcgi.c (revision 51)
+++ handler_fastcgi.c (working copy)
@@ -43,19 +43,17 @@
static pthread_mutex_t __global_fastcgi_managers_lock;
#endif
-
-
static void
fcgi_build_header (FCGI_Header *hdr, cuchar_t type, cushort_t request_id, cuint_t content_length, cuchar_t padding)
{
hdr->version = FCGI_VERSION_1;
hdr->type = type;
- hdr->requestIdB0 = (cuchar_t) request_id;
- hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
- hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
- hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
+ hdr->requestIdB0 = (cuchar_t) request_id;
+ hdr->requestIdB1 = (cuchar_t) (request_id >> 8) & 0xff;
+ hdr->contentLengthB0 = (cuchar_t) (content_length % 256);
+ hdr->contentLengthB1 = (cuchar_t) (content_length / 256);
hdr->paddingLength = padding;
- hdr->reserved = 0;
+ hdr->reserved = 0;
}
static void
@@ -97,10 +95,6 @@
n->host_ref = NULL;
n->interpreter_ref = NULL;
- cherokee_buffer_init (&n->write_buffer);
- cherokee_buffer_init (&n->incoming_buffer);
- cherokee_buffer_init (&n->environment);
-
if (properties) {
cherokee_typed_table_get_str (properties, "server", &n->host_ref);
cherokee_typed_table_get_str (properties, "interpreter", &n->interpreter_ref);
@@ -125,34 +119,36 @@
return ret_ok;
}
-
-
-
static void
-add_env_pair (cherokee_buffer_t *buf,
+add_env_pair (cherokee_buffer_t *buf, void *user_data,
char *key, int key_len,
char *val, int val_len)
{
+ cherokee_handler_fastcgi_t *fcgi = (cherokee_handler_fastcgi_t *) user_data;
+ FCGI_BeginRequestRecord request;
int len;
-
+
len = key_len + val_len;
- len += key_len > 127 ? 4 : 1;
- len += val_len > 127 ? 4 : 1;
+ len += key_len > 127 ? 4 : 1;
+ len += val_len > 127 ? 4 : 1;
cherokee_buffer_ensure_size (buf, buf->len + key_len + val_len);
+ fcgi_build_header (&request.header, FCGI_PARAMS, fcgi->id, len, 0);
+ cherokee_buffer_add (buf, (void *)&request.header, sizeof(FCGI_Header));
+
if (key_len <= 127) {
buf->buf[buf->len++] = key_len;
- } else {
+ } else {
buf->buf[buf->len++] = ((key_len >> 24) & 0xff) | 0x80;
buf->buf[buf->len++] = (key_len >> 16) & 0xff;
buf->buf[buf->len++] = (key_len >> 8) & 0xff;
buf->buf[buf->len++] = (key_len >> 0) & 0xff;
- }
+ }
if (val_len <= 127) {
buf->buf[buf->len++] = val_len;
- } else {
+ } else {
buf->buf[buf->len++] = ((val_len >> 24) & 0xff) | 0x80;
buf->buf[buf->len++] = (val_len >> 16) & 0xff;
buf->buf[buf->len++] = (val_len >> 8) & 0xff;
@@ -163,35 +159,33 @@
cherokee_buffer_add (buf, val, val_len);
}
-
static ret_t
build_initial_packages (cherokee_handler_fastcgi_t *fcgi)
{
ret_t ret;
- cherokee_buffer_t tmp = CHEROKEE_BUF_INIT;
+ cherokee_buffer_t tmp = CHEROKEE_BUF_INIT, write_tmp;
cherokee_connection_t *conn;
FCGI_BeginRequestRecord request;
conn = HANDLER_CONN(fcgi);
-
/* FCGI_BEGIN_REQUEST
*/
fcgi_build_header (&request.header, FCGI_BEGIN_REQUEST, fcgi->id, sizeof(request.body), 0);
- fcgi_build_request_body (&request.body);
+ fcgi_build_request_body (&request);
cherokee_buffer_add (&fcgi->write_buffer, (void *)&request, sizeof(FCGI_BeginRequestRecord));
-
+
/* Add enviroment variables
- */
- ret = cherokee_cgi_build_basic_env (conn, (cherokee_cgi_set_env_pair_t) add_env_pair, &tmp, &fcgi->write_buffer);
+ */
+ cherokee_buffer_init (&tmp);
+ cherokee_buffer_init (&write_tmp);
+ ret = cherokee_cgi_build_basic_env (conn, (cherokee_cgi_set_env_pair_t) add_env_pair, &tmp, &write_tmp, fcgi);
if (unlikely (ret != ret_ok)) return ret;
-
+
+ cherokee_buffer_add_buffer (&fcgi->write_buffer, &write_tmp);
cherokee_buffer_mrproper (&tmp);
+ cherokee_buffer_mrproper (&write_tmp);
- fcgi_build_header (&request.header, FCGI_PARAMS, fcgi->id, tmp.size, 0);
- cherokee_buffer_add (&fcgi->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
- cherokee_buffer_add_buffer (&fcgi->write_buffer, &tmp);
-
/* There aren't more parameters
*/
fcgi_build_header (&request.header, FCGI_PARAMS, fcgi->id, 0, 0);
@@ -218,6 +212,12 @@
return ret_error;
}
+ cherokee_buffer_init (&fcgi->write_buffer);
+ cherokee_buffer_init (&fcgi->incoming_buffer);
+ cherokee_buffer_init (&fcgi->data);
+ cherokee_buffer_init (&fcgi->environment);
+ fcgi->ended = 0;
+
/* Look for the FCGI managers table
*/
CHEROKEE_MUTEX_LOCK (&__global_fastcgi_managers_lock);
@@ -244,11 +244,15 @@
/* Launch a new FastCGI server and connect to it
*/
- ret = cherokee_fcgi_manager_spawn_srv (n, fcgi->interpreter_ref);
- if (unlikely (ret != ret_ok)) return ret;
+
+ ret = cherokee_fcgi_manager_connect_to_srv (n, fcgi->host_ref);
+ if (unlikely (ret != ret_ok)) {
+ ret = cherokee_fcgi_manager_spawn_srv (n, fcgi->interpreter_ref);
+ if (unlikely (ret != ret_ok)) return ret;
- ret = cherokee_fcgi_manager_connect_to_srv (n, fcgi->host_ref);
- if (unlikely (ret != ret_ok)) return ret_error;
+ ret = cherokee_fcgi_manager_connect_to_srv (n, fcgi->host_ref);
+ if (unlikely (ret != ret_ok)) return ret_error;
+ }
}
CHEROKEE_MUTEX_UNLOCK (&__global_fastcgi_managers_lock);
@@ -267,34 +271,32 @@
return ret_ok;
}
-
+static
ret_t
-cherokee_handler_fastcgi_step (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
+read_fcgi (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
{
- ret_t ret;
- size_t done;
+ ret_t ret;
+ size_t size;
+ cherokee_fcgi_manager_t *fcgim;
- return_if_fail (fcgi->manager_ref != NULL, ret_error);
-
-
- printf ("cherokee_handler_fastcgi_step: begin\n");
-
+ fcgim = fcgi->manager_ref;
+
/* It has something to send
*/
if (! cherokee_buffer_is_empty (&fcgi->write_buffer)) {
- ret = cherokee_fcgi_manager_send (fcgi->manager_ref, &fcgi->write_buffer, &done);
+ CHEROKEE_MUTEX_LOCK (&__global_fastcgi_managers_lock);
+ ret = cherokee_fcgi_manager_send (fcgi->manager_ref, &fcgi->write_buffer, &size);
+ CHEROKEE_MUTEX_UNLOCK (&__global_fastcgi_managers_lock);
printf ("cherokee_handler_fastcgi_step: !empty, send: %d\n", ret);
switch (ret) {
case ret_ok:
- if (cherokee_buffer_is_empty (&fcgi->write_buffer))
- return ret_eagain;
+ break;
- return ret_ok;
-
case ret_eagain:
return ret_eagain;
case ret_eof:
+ break;
case ret_error:
return ret_error;
default:
@@ -302,21 +304,122 @@
}
}
+
+ CHEROKEE_MUTEX_LOCK (&__global_fastcgi_managers_lock);
+ printf ("%d\n", fcgi->id);
+ ret = cherokee_fcgi_manager_step (fcgim);
+ CHEROKEE_MUTEX_UNLOCK (&__global_fastcgi_managers_lock);
+
+ if (ret == ret_ok) {
+ if (fcgim->request_id == fcgi->id) {
+ /* pick the data */
+ printf ("X %d %d %d %d\n", fcgim->request_type, fcgim->request_id, ret, fcgim->read_buffer.len);
+ switch (fcgim->request_type) {
+ case FCGI_STDOUT:
+ cherokee_buffer_add_buffer (buffer, &fcgim->request_buffer);
+
+ ret = ret_eagain;
+ case FCGI_STDERR:
+ ret = ret_eagain;
+ break;
+ case FCGI_END_REQUEST:
+ fcgi->ended = 1;
+ cherokee_buffer_mrproper (&fcgim->request_buffer);
+ ret = ret_ok;
+ break;
+ }
+ fcgim->request_id = 0;
+ return ret;
+ }
+ }
+
+ /* Read
+ */
+ return ret_eagain;
+}
+
+ret_t
+cherokee_handler_fastcgi_step (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
+{
+ ret_t ret = ret_ok;
+
+ if (!cherokee_buffer_is_empty (&fcgi->data))
+ {
+ cherokee_buffer_add_buffer (buffer, &fcgi->data);
+ cherokee_buffer_mrproper (&fcgi->data);
+ return ret_ok;
+ }
+
/* Lets read from the FastCGI server
- * As side effect it could update more connections in this call
*/
- ret = cherokee_fcgi_manager_step (fcgi->manager_ref);
- printf ("cherokee_handler_fastcgi_step: manager_step: %d\n", ret);
+ printf ("S\n");
+ if (fcgi->ended == 0)
+ ret = read_fcgi (fcgi, buffer);
+ else
+ ret = ret_ok;
- // To continue..
-
- return ret_ok;
+ return ret;
}
ret_t
-cherokee_handler_fastcgi_add_headers (cherokee_handler_fastcgi_t *hdl, cherokee_buffer_t *buffer)
+cherokee_handler_fastcgi_add_headers (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
{
+ ret_t ret;
+
+ int len;
+ char *content;
+ int end_len;
+
+ /* Sanity check
+ */
+ return_if_fail (buffer != NULL, ret_error);
+
+ /* Read information from the FCGI
+ */
+ printf ("H %d\n", fcgi->id);
+ ret = read_fcgi (fcgi, &fcgi->data);
+
+ switch (ret) {
+ case ret_ok:
+ case ret_eof:
+ break;
+
+ case ret_error:
+ case ret_eagain:
+ return ret;
+
+ default:
+ RET_UNKNOWN(ret);
+ return ret_error;
+ }
+
+ /* Look the end of headers
+ */
+ content = strstr (fcgi->data.buf, CRLF CRLF);
+ if (content != NULL) {
+ end_len = 4;
+ } else {
+ content = strstr (fcgi->data.buf, "\n\n");
+ end_len = 2;
+ }
+
+ if (content == NULL) {
+ return (ret == ret_eof) ? ret_eof : ret_eagain;
+ }
+
+ /* Copy the header
+ */
+ len = content - fcgi->data.buf;
+
+ cherokee_buffer_ensure_size (buffer, len+6);
+ cherokee_buffer_add (buffer, fcgi->data.buf, len);
+ cherokee_buffer_add (buffer, CRLF CRLF, 4);
+
+ /* Drop out the headers, we already have a copy
+ */
+ cherokee_buffer_move_to_begin (&fcgi->data, len + end_len);
+
return ret_ok;
}
@@ -325,7 +428,7 @@
*/
void
-fastcgi_init (cherokee_module_loader_t *loader)
+cherokee_module_fastcgi_init (cherokee_module_loader_t *loader)
{
PRINT_ERROR_S ("WARNING: The FastCGI is under development, it isn't ready to be used!\n");
Index: handler_fastcgi.h
===================================================================
--- handler_fastcgi.h (revision 51)
+++ handler_fastcgi.h (working copy)
@@ -72,6 +72,8 @@
cherokee_buffer_t environment;
cherokee_buffer_t write_buffer;
cherokee_buffer_t incoming_buffer;
+ cherokee_buffer_t data;
+ cuint_t ended;
} cherokee_handler_fastcgi_t;
Index: handler_cgi.c
===================================================================
--- handler_cgi.c (revision 51)
+++ handler_cgi.c (working copy)
@@ -271,7 +271,7 @@
*/
ret = cherokee_cgi_build_basic_env (conn,
(cherokee_cgi_set_env_pair_t) cherokee_handler_cgi_add_env_pair,
- &tmp, cgi);
+ &tmp, cgi, NULL);
if (unlikely (ret != ret_ok)) return ret;
/* Set SCRIPT_NAME
Index: cgi.c
===================================================================
--- cgi.c (revision 51)
+++ cgi.c (working copy)
@@ -37,7 +37,8 @@
cherokee_cgi_build_basic_env (cherokee_connection_t *conn,
cherokee_cgi_set_env_pair_t set_env_pair,
cherokee_buffer_t *tmp,
- void *param)
+ void *param,
+ void *user_data)
{
int r;
ret_t ret;
@@ -53,17 +54,17 @@
/* Set the basic variables
*/
- set_env_pair (param, "SERVER_SIGNATURE", 16, "<address>Cherokee web server</address>", 38);
- set_env_pair (param, "SERVER_SOFTWARE", 15, "Cherokee " PACKAGE_VERSION, 9 + sizeof(PACKAGE_VERSION));
- set_env_pair (param, "GATEWAY_INTERFACE", 17, "CGI/1.1", 7);
- set_env_pair (param, "PATH", 4, "/bin:/usr/bin:/sbin:/usr/sbin", 29);
+ set_env_pair (param, user_data, "SERVER_SIGNATURE", 16, "<address>Cherokee web server</address>", 38);
+ set_env_pair (param, user_data, "SERVER_SOFTWARE", 15, "Cherokee " PACKAGE_VERSION, 9 + sizeof(PACKAGE_VERSION));
+ set_env_pair (param, user_data, "GATEWAY_INTERFACE", 17, "CGI/1.1", 7);
+ set_env_pair (param, user_data, "PATH", 4, "/bin:/usr/bin:/sbin:/usr/sbin", 29);
/* Servers MUST supply this value to scripts. The QUERY_STRING
* value is case-sensitive. If the Script-URI does not include a
* query component, the QUERY_STRING metavariable MUST be defined
* as an empty string ("").
*/
- set_env_pair (param, "DOCUMENT_ROOT", 13, conn->local_directory->buf, conn->local_directory->len);
+ set_env_pair (param, user_data, "DOCUMENT_ROOT", 13, conn->local_directory->buf, conn->local_directory->len);
/* The IP address of the client sending the request to the
* server. This is not necessarily that of the user agent (such
@@ -71,7 +72,7 @@
*/
memset (remote_ip, 0, sizeof(remote_ip));
cherokee_socket_ntop (conn->socket, remote_ip, sizeof(remote_ip)-1);
- set_env_pair (param, "REMOTE_ADDR", 11, remote_ip, strlen(remote_ip));
+ set_env_pair (param, user_data, "REMOTE_ADDR", 11, remote_ip, strlen(remote_ip));
/* HTTP_HOST and SERVER_NAME. The difference between them is that
* HTTP_HOST can include the �:PORT� text, and SERVER_NAME only
@@ -79,12 +80,12 @@
*/
cherokee_header_copy_known (conn->header, header_host, tmp);
if (! cherokee_buffer_is_empty(tmp)) {
- set_env_pair (param, "HTTP_HOST", 9, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "HTTP_HOST", 9, tmp->buf, tmp->len);
p = strchr (tmp->buf, ':');
if (p != NULL) *p = '\0';
- set_env_pair (param, "SERVER_NAME", 11, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "SERVER_NAME", 11, tmp->buf, tmp->len);
}
/* Cookies :-)
@@ -92,7 +93,7 @@
cherokee_buffer_clean (tmp);
ret = cherokee_header_copy_unknown (conn->header, "Cookie", 6, tmp);
if (ret == ret_ok) {
- set_env_pair (param, "HTTP_COOKIE", 11, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "HTTP_COOKIE", 11, tmp->buf, tmp->len);
}
/* User Agent
@@ -100,7 +101,7 @@
cherokee_buffer_clean (tmp);
ret = cherokee_header_copy_known (conn->header, header_user_agent, tmp);
if (ret == ret_ok) {
- set_env_pair (param, "HTTP_USER_AGENT", 15, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "HTTP_USER_AGENT", 15, tmp->buf, tmp->len);
}
/* Content-type and Content-lenght (if available)
@@ -108,41 +109,41 @@
cherokee_buffer_clean (tmp);
ret = cherokee_header_copy_unknown (conn->header, "Content-Type", 12, tmp);
if (ret == ret_ok)
- set_env_pair (param, "CONTENT_TYPE", 12, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "CONTENT_TYPE", 12, tmp->buf, tmp->len);
cherokee_buffer_clean (tmp);
ret = cherokee_header_copy_known (conn->header, header_content_length, tmp);
if (ret == ret_ok)
- set_env_pair (param, "CONTENT_LENGTH", 14, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "CONTENT_LENGTH", 14, tmp->buf, tmp->len);
/* If there is a query_string, set the environment variable
*/
if (conn->query_string->len > 0)
- set_env_pair (param, "QUERY_STRING", 12, conn->query_string->buf, conn->query_string->len);
+ set_env_pair (param, user_data, "QUERY_STRING", 12, conn->query_string->buf, conn->query_string->len);
else
- set_env_pair (param, "QUERY_STRING", 12, "", 0);
+ set_env_pair (param, user_data, "QUERY_STRING", 12, "", 0);
/* Set the server port
*/
r = snprintf (temp, temp_size, "%d", CONN_SRV(conn)->port);
- set_env_pair (param, "SERVER_PORT", 11, temp, r);
+ set_env_pair (param, user_data, "SERVER_PORT", 11, temp, r);
/* Set the HTTP version
*/
ret = cherokee_http_version_to_string (conn->header->version, &p_const, &p_len);
if (ret >= ret_ok)
- set_env_pair (param, "SERVER_PROTOCOL", 15, (char *)p_const, p_len);
+ set_env_pair (param, user_data, "SERVER_PROTOCOL", 15, (char *)p_const, p_len);
/* Set the method
*/
ret = cherokee_http_method_to_string (conn->header->method, &p_const, &p_len);
if (ret >= ret_ok)
- set_env_pair (param, "REQUEST_METHOD", 14, (char *)p_const, p_len);
+ set_env_pair (param, user_data, "REQUEST_METHOD", 14, (char *)p_const, p_len);
/* Remote user
*/
if (conn->validator && !cherokee_buffer_is_empty (&conn->validator->user)) {
- set_env_pair (param, "REMOTE_USER", 11, conn->validator->user.buf, conn->validator->user.len);
+ set_env_pair (param, user_data, "REMOTE_USER", 11, conn->validator->user.buf, conn->validator->user.len);
}
/* Set the host name
@@ -151,7 +152,7 @@
p = strchr (conn->host->buf, ':');
if (p != NULL) *p = '\0';
- set_env_pair (param, "SERVER_NAME", 11, conn->host->buf, conn->host->len);
+ set_env_pair (param, user_data, "SERVER_NAME", 11, conn->host->buf, conn->host->len);
if (p != NULL) *p = ':';
}
@@ -159,14 +160,14 @@
/* Set PATH_INFO
*/
if (! cherokee_buffer_is_empty(conn->pathinfo)) {
- set_env_pair (param, "PATH_INFO", 9, conn->pathinfo->buf, conn->pathinfo->len);
+ set_env_pair (param, user_data, "PATH_INFO", 9, conn->pathinfo->buf, conn->pathinfo->len);
}
/* Set REQUEST_URI
*/
cherokee_buffer_clean (tmp);
cherokee_header_copy_request_w_args (conn->header, tmp);
- set_env_pair (param, "REQUEST_URI", 11, tmp->buf, tmp->len);
+ set_env_pair (param, user_data, "REQUEST_URI", 11, tmp->buf, tmp->len);
return ret_ok;
}
Index: cgi.h
===================================================================
--- cgi.h (revision 51)
+++ cgi.h (working copy)
@@ -29,11 +29,12 @@
#include "connection.h"
-typedef void (* cherokee_cgi_set_env_pair_t) (void *param, char *key, int key_len, char *val, int val_len);
+typedef void (* cherokee_cgi_set_env_pair_t) (void *param, void *user_data, char *key, int key_len, char *val, int val_len);
ret_t cherokee_cgi_build_basic_env (cherokee_connection_t *conn,
cherokee_cgi_set_env_pair_t set_env_pair,
cherokee_buffer_t *tmp,
- void *param);
+ void *param,
+ void *user_data);
#endif /* CHEROKEE_CGI_H */
_______________________________________________
Cherokee mailing list
[email protected]
http://www.alobbs.com/cgi-bin/mailman/listinfo/cherokee
