Hi,
This patch incorporate a HTTP POST support for fcgi. I use
cherokee_post_walk_read but changed the API a bit to:
ret_t
cherokee_post_walk_read (cherokee_post_t *post, cherokee_buffer_t *buf,
cuint_t *size)
I changed the 3rd argument from "cuint_t len" to "cuint_t *size". The
size will contains the available post data we read from either memory or
file. I use DEFAULT_READ_SIZE to replace the len argument. is it ok?
Also what is the correct return value of the cherokee_post_walk_read and
cherokee_post_walk_fd?
ret_ok: if no more post data to be read (all post data has been read)
ret_eagain: there are still more data to be consumed, please read again.
is that correct?
Index: fcgi_manager.c
===================================================================
--- fcgi_manager.c (revision 73)
+++ fcgi_manager.c (working copy)
@@ -22,7 +22,10 @@
* USA
*/
+#include "connection.h"
+#include "connection-protected.h"
#include "common-internal.h"
+#include "handler_fastcgi.h"
#include "fcgi_manager.h"
#include "fastcgi.h"
@@ -32,6 +35,7 @@
#define DEFAULT_PORT 8002
#define CONN_POLL_INCREMENT 16
+static pthread_mutex_t __global_fastcgi_manager_lock;
ret_t
cherokee_fcgi_manager_new (cherokee_fcgi_manager_t **fcgim)
@@ -48,6 +52,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);
@@ -62,6 +67,8 @@
/* Return
*/
*fcgim = n;
+
+ CHEROKEE_MUTEX_INIT(&__global_fastcgi_manager_lock, NULL);
return ret_ok;
}
@@ -92,13 +99,21 @@
{
ret_t ret;
- ret = cherokee_socket_set_client (fcgim->socket, AF_INET);
- if (ret != ret_ok) return ret;
+ if (*fcgim->hostname.buf == '/') {
+ ret = cherokee_socket_set_client (fcgim->socket, AF_UNIX);
+ if (ret != ret_ok) return ret;
+ ret = cherokee_socket_gethostbyname (fcgim->socket, &fcgim->hostname);
+ if (ret != ret_ok) return ret;
+ } else {
+ ret = cherokee_socket_set_client (fcgim->socket, AF_INET);
+ if (ret != ret_ok) return ret;
- ret = cherokee_socket_gethostbyname (fcgim->socket, &fcgim->hostname);
- if (ret != ret_ok) return ret;
+ ret = cherokee_socket_gethostbyname (fcgim->socket, &fcgim->hostname);
+ if (ret != ret_ok) return ret;
+ SOCKET_SIN_PORT(fcgim->socket) = htons(fcgim->port);
+ }
- SOCKET_SIN_PORT(fcgim->socket) = htons(fcgim->port);
+
return cherokee_socket_connect (fcgim->socket);
}
@@ -110,17 +125,21 @@
char *port;
ret_t ret;
- /* Parse host name
- */
- port = strchr(host, ':');
- if (port == NULL) {
- cherokee_buffer_add (&fcgim->hostname, host, strlen(host));
- } else {
- *port = '\0';
- fcgim->port = atoi(port+1);
- cherokee_buffer_add (&fcgim->hostname, host, port - host);
- *port = ':';
- }
+ if (*host == '/') {
+ cherokee_buffer_add (&fcgim->hostname, host, strlen(host));
+ } else {
+ /* Parse host name
+ */
+ port = strchr(host, ':');
+ if (port == NULL) {
+ cherokee_buffer_add (&fcgim->hostname, host, strlen(host));
+ } else {
+ *port = '\0';
+ fcgim->port = atoi(port+1);
+ cherokee_buffer_add (&fcgim->hostname, host, port - host);
+ *port = ':';
+ }
+ }
/* Connect to the server
*/
@@ -208,7 +227,7 @@
fcgim->conn_poll[slot] = conn;
printf ("registered id=%d\n", slot);
- *id = slot;
+ *id = slot + 1;
return ret_ok;
}
@@ -236,81 +255,205 @@
{
ret_t ret;
+ CHEROKEE_MUTEX_LOCK (&__global_fastcgi_manager_lock);
ret = cherokee_socket_write (fcgim->socket, info, sent);
+ CHEROKEE_MUTEX_UNLOCK (&__global_fastcgi_manager_lock);
if (ret != ret_ok) return ret;
cherokee_buffer_move_to_begin (info, *sent);
return ret_ok;
}
+static void
+set_status (cherokee_fcgi_manager_t *fcgim, cherokee_fcgi_status_t status)
+{
+ cherokee_handler_fastcgi_t *fcgi;
+ cherokee_connection_t *conn;
+
+ conn = fcgim->conn_poll [fcgim->request_id - 1];
+ if (conn != NULL) {
+ fcgi = (cherokee_handler_fastcgi_t *) conn->handler;
+ if (fcgi != NULL) {
+ fcgi->status = status;
+ }
+ }
+}
+static void
+process_buffer (cherokee_fcgi_manager_t *fcgim, void *data, cuint_t data_len)
+{
+ cherokee_connection_t *conn;
+ cherokee_handler_fastcgi_t *fcgi;
+
+ conn = fcgim->conn_poll [fcgim->request_id - 1];
+ if (conn == NULL)
+ {
+ return;
+ }
+
+ fcgi = (cherokee_handler_fastcgi_t *) conn->handler;
+ switch (fcgim->request_type)
+ {
+ case FCGI_STDERR:
+ case FCGI_STDOUT:
+ cherokee_buffer_add (&fcgi->incoming_buffer, data, data_len);
+ set_status (fcgim, fcgi_data_available);
+ }
+}
+
static ret_t
process_read_buffer (cherokee_fcgi_manager_t *fcgim)
{
- cuint_t offset;
- FCGI_Header *header;
-
- offset = 0;
- while (fcgim->read_buffer.len - offset >= sizeof(FCGI_EndRequestRecord))
- {
- cuint_t id;
- cuint_t len;
+ ret_t ret = ret_eagain;
+ cuint_t len, bytes_to_move, offset = 0;
+ FCGI_Header *header;
+ FCGI_EndRequestBody *end_request;
+ void *start = fcgim->read_buffer.buf;
- header = (FCGI_Header *)((&fcgim->read_buffer.buf) + offset);
- id = (header->requestIdB0 | (header->requestIdB1 << 8));
- len = (header->contentLengthB0 | (header->contentLengthB1 << 8)) + header->paddingLength;
+ while (fcgim->read_buffer.len > 0)
+ {
+ if (fcgim->remaining_size == 0 || fcgim->padding == 0) {
+ if (fcgim->read_buffer.len < sizeof(FCGI_Header))
+ return ret_eagain;
- switch (header->type) {
- case FCGI_STDERR:
- printf ("strerr\n");
- break;
- case FCGI_STDOUT:
- printf ("stdout\n");
- break;
- case FCGI_END_REQUEST:
- printf ("end request\n");
- break;
- default:
- PRINT_ERROR ("ERROR: Unknown FCGI header type: %d\n", header->type);
- }
+ header = (FCGI_Header *) start;
- offset += sizeof(FCGI_EndRequestRecord);
- }
+ if (!(header->type == FCGI_STDERR ||
+ header->type == FCGI_STDOUT ||
+ header->type == FCGI_END_REQUEST))
+ {
+ printf ("rb:%d x:%d rs:%d\n", fcgim->read_buffer.len, fcgim->padding, fcgim->remaining_size);
+ cherokee_buffer_print_debug (&fcgim->read_buffer, -1);
+ return ret_error;
+ }
- return ret_ok;
+ fcgim->request_id = (header->requestIdB0 | (header->requestIdB1 << 8));
+ fcgim->request_type = header->type;
+ len = (header->contentLengthB0 | (header->contentLengthB1 << 8));
+ fcgim->padding = header->paddingLength;
+ fcgim->return_value = 0;
+ fcgim->status = 0;
+
+ offset = FCGI_HEADER_LEN;
+ if (len > (fcgim->read_buffer.len - FCGI_HEADER_LEN))
+ {
+ fcgim->remaining_size = len - fcgim->read_buffer.len - FCGI_HEADER_LEN + 16;
+ len = fcgim->read_buffer.len - FCGI_HEADER_LEN;
+ bytes_to_move = len;
+ } else {
+ fcgim->remaining_size = 0;
+ bytes_to_move = len;
+ if ((fcgim->padding + len) > (fcgim->read_buffer.len - FCGI_HEADER_LEN)) {
+ fcgim->padding = (fcgim->padding + len) - fcgim->read_buffer.len - FCGI_HEADER_LEN;
+ bytes_to_move += fcgim->padding;
+ } else {
+ bytes_to_move += fcgim->padding;
+ fcgim->padding = 0;
+ }
+ }
+ bytes_to_move += FCGI_HEADER_LEN;
+ } else {
+ if (fcgim->remaining_size > fcgim->read_buffer.len) {
+ fcgim->remaining_size = fcgim->remaining_size - fcgim->read_buffer.len;
+ len = fcgim->read_buffer.len;
+ bytes_to_move = len;
+ } else {
+ len = fcgim->remaining_size;
+ bytes_to_move = len;
+ if (fcgim->padding > 0) {
+ if ((fcgim->remaining_size + fcgim->padding) > fcgim->read_buffer.len) {
+ fcgim->padding = fcgim->remaining_size + fcgim->padding - fcgim->read_buffer.len;
+ } else {
+ bytes_to_move += fcgim->padding;
+ fcgim->padding = 0;
+ }
+ }
+ fcgim->remaining_size = 0;
+ }
+ }
+
+ if (fcgim->remaining_size == 0)
+ ret = ret_ok;
+ else
+ ret = ret_eagain;
+
+ switch (fcgim->request_type) {
+ case FCGI_STDERR:
+ case FCGI_STDOUT:
+ if (len > 0)
+ process_buffer (fcgim, (start + offset), len);
+ break;
+ case FCGI_END_REQUEST:
+ end_request = (FCGI_EndRequestBody *) (start + offset);
+ fcgim->status = end_request->protocolStatus;
+ fcgim->return_value = end_request->appStatusB0 |
+ (end_request->appStatusB0 << 8) |
+ (end_request->appStatusB0 << 16) |
+ (end_request->appStatusB0 << 24);
+ set_status (fcgim, fcgi_data_completed);
+ break;
+ default:
+ PRINT_ERROR ("ERROR: Unknown FCGI header type: %d\n", header->type);
+ ret = ret_error;
+ }
+
+ cherokee_buffer_move_to_begin (&fcgim->read_buffer, bytes_to_move);
+ }
+ if (fcgim->read_buffer.len == 0)
+ cherokee_buffer_mrproper (&fcgim->read_buffer);
+
+ return ret;
}
-
ret_t
-cherokee_fcgi_manager_step (cherokee_fcgi_manager_t *fcgim)
+fcgi_manager_step (cherokee_fcgi_manager_t *fcgim, cuint_t id)
{
ret_t ret;
size_t size;
+ cherokee_connection_t *conn;
+ cherokee_handler_fastcgi_t *fcgi;
+
+ conn = fcgim->conn_poll [id - 1];
+ fcgi = (cherokee_handler_fastcgi_t *) conn->handler;
+ if ((fcgi->status == fcgi_data_available) || (fcgi->status == fcgi_data_completed))
+ return ret_ok;
+
/* Read from the FastCGI application
*/
if (fcgim->read_buffer.len < sizeof(FCGI_Header))
{
+ printf (" [readin %d" , id);
ret = cherokee_socket_read (fcgim->socket, &fcgim->read_buffer, DEFAULT_READ_SIZE, &size);
- printf ("cherokee_fcgi_manager_step: _read %d\n", ret);
- if (ret != ret_ok) return ret;
+ printf (" readout %d] ", id);
+ if (ret != ret_ok) {
+ return ret;
+ }
}
/* Process the information
*/
- 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;
- }
+ while (1)
+ {
+ ret = process_read_buffer (fcgim);
+ if ((ret == ret_ok) || (ret == ret_error))
+ break;
+ }
- /* Read
- */
- return ret_eagain;
+ return ret;
}
+ret_t
+cherokee_fcgi_manager_step (cherokee_fcgi_manager_t *fcgim, cuint_t id)
+{
+ ret_t ret;
+ CHEROKEE_MUTEX_LOCK (&__global_fastcgi_manager_lock);
+ ret = fcgi_manager_step (fcgim, id);
+ CHEROKEE_MUTEX_UNLOCK (&__global_fastcgi_manager_lock);
+ return ret;
+}
+
ret_t
cherokee_fcgi_manager_add_conn (cherokee_fcgi_manager_t *fcgim, cherokee_connection_t *conn)
{
Index: fcgi_manager.h
===================================================================
--- fcgi_manager.h (revision 73)
+++ fcgi_manager.h (working copy)
@@ -39,6 +39,15 @@
cherokee_buffer_t read_buffer;
+ int request_type;
+ cuint_t request_id;
+ cherokee_buffer_t request_buffer;
+ int return_value;
+ int status;
+
+ cuint_t padding;
+ cuint_t remaining_size;
+
/* Connections
*/
cherokee_connection_t **conn_poll;
@@ -56,7 +65,7 @@
ret_t cherokee_fcgi_manager_register_conn (cherokee_fcgi_manager_t *fcgim, cherokee_connection_t *conn, cuint_t *id);
ret_t cherokee_fcgi_manager_unregister_conn (cherokee_fcgi_manager_t *fcgim, cherokee_connection_t *conn);
-ret_t cherokee_fcgi_manager_step (cherokee_fcgi_manager_t *fcgim);
+ret_t cherokee_fcgi_manager_step (cherokee_fcgi_manager_t *fcgim, cuint_t);
ret_t cherokee_fcgi_manager_send (cherokee_fcgi_manager_t *fcgim, cherokee_buffer_t *info, size_t *sent);
ret_t cherokee_fcgi_manager_add_conn (cherokee_fcgi_manager_t *fcgim, cherokee_connection_t *conn);
Index: macros.h
===================================================================
--- macros.h (revision 73)
+++ macros.h (working copy)
@@ -215,17 +215,23 @@
#endif /* BYTE_ORDER */
+# include <sys/types.h>
+# include <unistd.h>
/* Format string for off_t
*/
+#if 0
#if SIZEOF_OFF_T == SIZEOF_UNSIGNED_LONG_LONG
# define FMT_OFFSET "%llu"
# define CST_OFFSET unsigned long long
-#elif SIZEOF_OFF_T == SIZEOF_UNISGNED_LONG
+#elif SIZEOF_OFF_T == SIZEOF_UNSIGNED_LONG
# define FMT_OFFSET "%lu"
# define CST_OFFSET unsigned long
#else
# error Unknown size of off_t
#endif
+#endif
+# define FMT_OFFSET "%lu"
+# define CST_OFFSET unsigned long
#ifdef O_NOATIME
Index: buffer.c
===================================================================
--- buffer.c (revision 73)
+++ buffer.c (working copy)
@@ -562,6 +562,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;
@@ -569,20 +570,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 73)
+++ 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 73)
+++ 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,15 +95,13 @@
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);
}
+
+ n->host_ref = strdup ("/tmp/sock");
/* Return
*/
*hdl = HANDLER(n);
@@ -118,6 +114,7 @@
{
cherokee_fcgi_manager_unregister_conn (hdl->manager_ref, HANDLER_CONN(hdl));
+ cherokee_buffer_mrproper (&hdl->data);
cherokee_buffer_mrproper (&hdl->write_buffer);
cherokee_buffer_mrproper (&hdl->incoming_buffer);
cherokee_buffer_mrproper (&hdl->environment);
@@ -125,34 +122,67 @@
return ret_ok;
}
+static void
+fixup_params (cherokee_buffer_t *buf, cuint_t id)
+{
+ char *byte, *end;
+ int length;
+ int crafted_id [2];
+ if (buf->len == 0)
+ return;
+ end = buf->buf + buf->len;
+ crafted_id [0] = (cuchar_t) id;
+ crafted_id [1] = (cuchar_t) (id >> 8) & 0xff;
+ byte = (char*) buf->buf;
+ while (byte <= end)
+ {
+ byte += 2;
+ if (*byte == (char) 0xFF)
+ *byte = crafted_id [1];
+ byte ++;
+ if (*byte == (char) 0xFF)
+ *byte = crafted_id [0];
+ byte ++;
+ length = (*byte << 8);
+ byte ++;
+ length |= *byte;
+ byte ++;
+ length += *byte;
+ byte += (length + 2);
+ }
+}
static void
add_env_pair (cherokee_buffer_t *buf,
char *key, int key_len,
char *val, int val_len)
{
+ 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);
+ cherokee_buffer_ensure_size (buf, buf->len + key_len + val_len + sizeof(FCGI_Header));
+ fcgi_build_header (&request.header, FCGI_PARAMS, 0xFFFF, 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,45 +193,37 @@
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_BUF_INIT;
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);
+ */
+ ret = cherokee_cgi_build_basic_env (conn, (cherokee_cgi_set_env_pair_t) add_env_pair, &tmp, &write_tmp);
if (unlikely (ret != ret_ok)) return ret;
+ fixup_params (&write_tmp, fcgi->id);
+ 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);
cherokee_buffer_add (&fcgi->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
- /* Stdin
- */
- fcgi_build_header (&request.header, FCGI_STDIN, fcgi->id, 0, 0);
- cherokee_buffer_add (&fcgi->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
-
return ret_ok;
}
@@ -218,6 +240,13 @@
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->status = fcgi_data_unavailable;
+ fcgi->sending_phase = fcgi_sending_first_data;
+
/* Look for the FCGI managers table
*/
CHEROKEE_MUTEX_LOCK (&__global_fastcgi_managers_lock);
@@ -244,11 +273,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 +300,82 @@
return ret_ok;
}
+static
+void
+complete_request (cherokee_handler_fastcgi_t *fcgi)
+{
+ FCGI_BeginRequestRecord request;
+ fcgi_build_header (&request.header, FCGI_STDIN, fcgi->id, 0, 0);
+ cherokee_buffer_add (&fcgi->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
+}
+
+static
ret_t
-cherokee_handler_fastcgi_step (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
+read_fcgi (cherokee_handler_fastcgi_t *fcgi)
{
- ret_t ret;
- size_t done;
+ ret_t ret = ret_eagain;
+ size_t size;
+ cherokee_fcgi_manager_t *fcgim;
+ cherokee_connection_t *conn;
+ cherokee_buffer_t post_buffer = CHEROKEE_BUF_INIT;
+ FCGI_BeginRequestRecord request;
- return_if_fail (fcgi->manager_ref != NULL, ret_error);
+ conn = HANDLER_CONN(fcgi);
+ fcgim = fcgi->manager_ref;
+
+ if (fcgi->sending_phase == fcgi_sending_first_data_completed)
+ {
+ if (! cherokee_post_is_empty (&conn->post)) {
+ cherokee_post_walk_reset (&conn->post);
+ fcgi->sending_phase = fcgi_sending_post_data;
+ } else {
+ fcgi->sending_phase = fcgi_sending_data_completed;
+ }
+ }
- printf ("cherokee_handler_fastcgi_step: begin\n");
-
+ if (fcgi->sending_phase == fcgi_sending_post_data)
+ {
+
+ ret = cherokee_post_walk_read (&conn->post, &post_buffer, &size);
+ if (size > 0)
+ {
+ fcgi_build_header (&request.header, FCGI_STDIN, fcgi->id, size, 0);
+ cherokee_buffer_add (&fcgi->write_buffer, (void *)&request.header, sizeof(FCGI_Header));
+ cherokee_buffer_add_buffer (&fcgi->write_buffer, &post_buffer);
+ cherokee_buffer_print_debug (&fcgi->write_buffer, -1);
+ cherokee_buffer_mrproper (&post_buffer);
+ }
+
+ if (ret == ret_ok)
+ {
+ fcgi->sending_phase = fcgi_sending_data_completed;
+ }
+ }
+
+ if (fcgi->sending_phase == fcgi_sending_data_completed)
+ complete_request (fcgi);
+
/* 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);
- printf ("cherokee_handler_fastcgi_step: !empty, send: %d\n", ret);
+ ret = cherokee_fcgi_manager_send (fcgi->manager_ref, &fcgi->write_buffer, &size);
+
+ if (cherokee_buffer_is_empty (&fcgi->write_buffer)) {
+ cherokee_buffer_mrproper (&fcgi->write_buffer);
+ if (fcgi->sending_phase == fcgi_sending_first_data)
+ fcgi->sending_phase = fcgi_sending_first_data_completed;
+ }
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 +383,119 @@
}
}
+ if (fcgi->sending_phase < fcgi_sending_data_completed)
+ return ret_eagain;
+
+ ret = ret_eagain;
+ cherokee_fcgi_manager_step (fcgim, fcgi->id);
+
+ if (fcgi->status == fcgi_data_available || fcgi->status == fcgi_data_completed)
+ ret = ret_ok;
+
+ return ret;
+}
+
+ret_t
+cherokee_handler_fastcgi_step (cherokee_handler_fastcgi_t *fcgi, cherokee_buffer_t *buffer)
+{
+ ret_t ret = ret_ok;
+
+ return_if_fail (buffer != NULL, ret_error);
+
+ if (!cherokee_buffer_is_empty (&fcgi->incoming_buffer))
+ {
+ cherokee_buffer_add_buffer (buffer, &fcgi->incoming_buffer);
+ cherokee_buffer_mrproper (&fcgi->incoming_buffer);
+ if (fcgi->status != fcgi_data_completed)
+ {
+ fcgi->status = fcgi_data_unavailable;
+ return ret_eagain;
+ } else
+ 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);
+ if (fcgi->status != fcgi_data_completed) {
+ ret = read_fcgi (fcgi);
+ if (ret == ret_ok) {
+ cherokee_buffer_add_buffer (buffer, &fcgi->incoming_buffer);
+ cherokee_buffer_mrproper (&fcgi->incoming_buffer);
+ fcgi->status = fcgi_data_unavailable;
+ }
- // To continue..
+ } else {
+ ret = ret_ok;
+ }
- 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
+ */
+ ret = read_fcgi (fcgi);
+
+ switch (ret) {
+ case ret_ok:
+ break;
+
+ case ret_error:
+ case ret_eagain:
+ return ret;
+
+ default:
+ RET_UNKNOWN(ret);
+ return ret_error;
+ }
+
+ if (fcgi->incoming_buffer.buf == NULL)
+ {
+ if (ret == ret_eof)
+ return ret_eof;
+ else
+ return ret_ok;
+ }
+
+ /* Look the end of headers
+ */
+ content = strstr (fcgi->incoming_buffer.buf, CRLF CRLF);
+ if (content != NULL) {
+ end_len = 4;
+ } else {
+ content = strstr (fcgi->incoming_buffer.buf, "\n\n");
+ end_len = 2;
+ }
+
+ if (content == NULL) {
+ return (ret == ret_eof) ? ret_eof : ret_eagain;
+ }
+
+ /* Copy the header
+ */
+ len = content - fcgi->incoming_buffer.buf;
+
+ cherokee_buffer_ensure_size (buffer, len+6);
+ cherokee_buffer_add (buffer, fcgi->incoming_buffer.buf, len);
+ cherokee_buffer_add (buffer, CRLF CRLF, 4);
+
+ /* Drop out the headers, we already have a copy
+ */
+ cherokee_buffer_move_to_begin (&fcgi->incoming_buffer, len + end_len);
+
return ret_ok;
}
@@ -325,7 +504,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 73)
+++ handler_fastcgi.h (working copy)
@@ -56,22 +56,38 @@
// struct sockaddr_un local;
} cherokee_fcgi_sockaddr_t;
+typedef enum {
+ fcgi_data_unavailable,
+ fcgi_data_available,
+ fcgi_data_completed,
+} cherokee_fcgi_status_t;
+typedef enum {
+ fcgi_sending_first_data,
+ fcgi_sending_first_data_completed,
+ fcgi_sending_post_data,
+ fcgi_sending_data_completed
+} cherokee_fcgi_sending_phase_t;
+
+
typedef struct {
cherokee_handler_t handler;
/* FastCGI manager
*/
- cherokee_fcgi_manager_t *manager_ref;
- char *host_ref;
- char *interpreter_ref;
- cuint_t id;
+ cherokee_fcgi_manager_t *manager_ref;
+ char *host_ref;
+ char *interpreter_ref;
+ cuint_t id;
/* FastCGI protocol stuff
*/
- cherokee_buffer_t environment;
- cherokee_buffer_t write_buffer;
- cherokee_buffer_t incoming_buffer;
+ cherokee_buffer_t environment;
+ cherokee_buffer_t write_buffer;
+ cherokee_buffer_t incoming_buffer;
+ cherokee_buffer_t data;
+ cuint_t status;
+ cherokee_fcgi_sending_phase_t sending_phase;
} cherokee_handler_fastcgi_t;
Index: post.c
===================================================================
--- post.c (revision 73)
+++ post.c (working copy)
@@ -243,28 +243,46 @@
ret_t
-cherokee_post_walk_read (cherokee_post_t *post, cherokee_buffer_t *buf, cuint_t len)
+cherokee_post_walk_read (cherokee_post_t *post, cherokee_buffer_t *buf, cuint_t *size)
{
size_t ur;
+ cuint_t real_length;
switch (post->type) {
case post_in_memory:
- cherokee_buffer_add (buf, post->info.buf + post->walk_offset, len);
- post->walk_offset += len;
- return ret_ok;
+ real_length = DEFAULT_READ_SIZE;
+ if (post->walk_offset + real_length > post->info.len)
+ real_length = post->info.len - post->walk_offset;
+ if (real_length == 0)
+ return ret_ok;
+
+ cherokee_buffer_add (buf, post->info.buf + post->walk_offset, real_length);
+ post->walk_offset += real_length;
+ *size = real_length;
+
+ if (post->walk_offset > post->info.len)
+ return ret_ok;
+
+ return ret_eagain;
+
case post_in_tmp_file:
- cherokee_buffer_ensure_size (buf, buf->len + len + 1);
+ real_length = DEFAULT_READ_SIZE;
+ cherokee_buffer_ensure_size (buf, buf->len + real_length);
- ur = fread (buf->buf + buf->len, 1, len, post->tmp_file_p);
+ ur = fread (buf->buf + buf->len, 1, real_length, post->tmp_file_p);
if (ur <= 0) {
- return (feof(post->tmp_file_p)) ? ret_eof : ret_error;
+ return (feof(post->tmp_file_p)) ? ret_ok : ret_error;
}
buf->len += ur;
- buf->buf[buf->len] = '\0';
- return ret_ok;
+ *size = ur;
+ if (ur < real_length)
+ return ret_ok;
+
+ return ret_eagain;
+
default:
SHOULDNT_HAPPEN;
return ret_error;
Index: post.h
===================================================================
--- post.h (revision 73)
+++ post.h (working copy)
@@ -63,7 +63,7 @@
ret_t cherokee_post_commit_buf (cherokee_post_t *post, size_t len);
ret_t cherokee_post_walk_reset (cherokee_post_t *post);
-ret_t cherokee_post_walk_read (cherokee_post_t *post, cherokee_buffer_t *buf, cuint_t len);
+ret_t cherokee_post_walk_read (cherokee_post_t *post, cherokee_buffer_t *buf, cuint_t *size);
ret_t cherokee_post_walk_to_fd (cherokee_post_t *post, int fd);
#endif /* CHEROKEE_POST_H */
Index: socket.c
===================================================================
--- socket.c (revision 73)
+++ socket.c (working copy)
@@ -1044,7 +1044,13 @@
ret_t
cherokee_socket_gethostbyname (cherokee_socket_t *socket, cherokee_buffer_t *hostname)
{
- return cherokee_gethostbyname (hostname->buf, &SOCKET_SIN_ADDR(socket));
+ if (SOCKET_AF(socket) == AF_UNIX) {
+ SOCKET_ADDR_UNIX(socket).sun_family = AF_UNIX;
+ memset ((char*) SOCKET_SUN_PATH (socket), 0, sizeof (SOCKET_ADDR_UNIX(socket)));
+ strncpy (SOCKET_SUN_PATH (socket), hostname->buf, hostname->len);
+ return ret_ok;
+ } else
+ return cherokee_gethostbyname (hostname->buf, &SOCKET_SIN_ADDR(socket));
}
@@ -1054,7 +1060,10 @@
{
int r;
- r = connect (SOCKET_FD(socket), (struct sockaddr *) &SOCKET_ADDR(socket), sizeof(cherokee_sockaddr_t));
+ if (SOCKET_AF(socket) == AF_UNIX)
+ r = connect (SOCKET_FD(socket), (struct sockaddr *) &SOCKET_ADDR_UNIX(socket), sizeof(SOCKET_ADDR_UNIX(socket)));
+ else
+ r = connect (SOCKET_FD(socket), (struct sockaddr *) &SOCKET_ADDR(socket), sizeof(cherokee_sockaddr_t));
if (r < 0) {
int err = SOCK_ERRNO();
Index: socket.h
===================================================================
--- socket.h (revision 73)
+++ socket.h (working copy)
@@ -43,6 +43,7 @@
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
+# include <sys/un.h>
#endif
#ifdef HAVE_ARPA_INET_H
@@ -100,6 +101,7 @@
typedef union {
struct sockaddr sa;
struct sockaddr_in sa_in;
+ struct sockaddr_un sa_un;
#ifdef HAVE_SOCKADDR_IN6
struct sockaddr_in6 sa_in6;
#endif
@@ -140,12 +142,14 @@
#define SOCKET_FD(s) (SOCKET(s)->socket)
#define SOCKET_AF(s) (SOCKET(s)->client_addr.sa.sa_family)
#define SOCKET_ADDR(s) (SOCKET(s)->client_addr)
+#define SOCKET_ADDR_UNIX(s) (SOCKET(s)->client_addr.sa_un)
#define SOCKET_ADDR_IPv4(s) ((struct sockaddr_in *)&SOCKET(s)->client_addr)
#define SOCKET_ADDR_IPv6(s) ((struct sockaddr_in6 *)&SOCKET(s)->client_addr)
#define SOCKET_STATUS(s) (SOCKET(s)->status)
#define SOCKET_SIN_PORT(s) (SOCKET(s)->client_addr.sa_in.sin_port)
#define SOCKET_SIN_ADDR(s) (SOCKET(s)->client_addr.sa_in.sin_addr)
+#define SOCKET_SUN_PATH(s) (SOCKET(s)->client_addr.sa_un.sun_path)
#define SOCKET_ADDRESS_IPv4(s) (SOCKET_ADDR_IPv4(s)->sin_addr.s_addr)
#define SOCKET_ADDRESS_IPv6(s) (SOCKET_ADDR_IPv6(s)->sin6_addr.s6_addr)
_______________________________________________
Cherokee mailing list
[email protected]
http://www.alobbs.com/cgi-bin/mailman/listinfo/cherokee
