Hi,
Now manager has many improvements: writes directly to handler's buffer,
better buffer parser function, and handles unix socket (hardcoded
to /tmp/sock for testing now, see below). The handler also now builds
the fcgi_param buffer with cgi function and fill the id afterwards.
When I tried to implement the round robin, I found that Server directive
cant accept / character. Instead of using Server, can I add, say, Socket
for UNIX socket?
Handler fastcgi {
Server 127.0.0.1:9090
Socket /tmp/unix.sock
Server other.host:port
}
UNIX socket stuff also modify socket.[c|h] files, please check if I made
some mess there.
btw, I sometimes still getting SIGPIPE under high number of concurrency
level, what could possibly cause this:
Program received signal SIGPIPE, Broken pipe.
0xffffe410 in __kernel_vsyscall ()
(gdb) bt
#0 0xffffe410 in __kernel_vsyscall ()
#1 0xb7f87a18 in send () from /lib/tls/i686/cmov/libpthread.so.0
#2 0xb7f6c40b in cherokee_write (socket=0x8141178,
buf=0x8147398 "<title>FastCGI echo</title><h1>FastCGI
echo</h1>\nRequest number 346, Process ID: 3217<p>\nNo data from
standard input.<p>\nRequest environment:<br>\n<pre>\nFCGI_ROLE=RESPONDER
\nSERVER_SIGNATURE=<address>C"...,
buf_len=2120, written=0xb7c6e330) at socket.c:679
#3 0xb7f6c88a in cherokee_socket_write (socket=0x8141178,
buf=0xb7f7a284,
written=0xb7f7a284) at socket.c:886
#4 0xb7f43d5f in cherokee_connection_send (cnt=0x8141068) at
connection.c:764
#5 0xb7f4a07b in process_active_connections (thd=0x807f860) at
thread.c:965
#6 0xb7f4a3ba in cherokee_thread_step_MULTI_THREAD (thd=0x807f860,
dont_block=false) at thread.c:1499
#7 0xb7f4a813 in thread_routine (data=0x807f860) at thread.c:113
#8 0xb7f82361 in start_thread ()
from /lib/tls/i686/cmov/libpthread.so.0
#9 0xb7ed1bde in clone () from /lib/tls/i686/cmov/libc.so.6
thanks!
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,35 +193,32 @@
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);
@@ -218,6 +245,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->first_data_sent = 0;
+
/* Look for the FCGI managers table
*/
CHEROKEE_MUTEX_LOCK (&__global_fastcgi_managers_lock);
@@ -244,11 +278,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 +305,37 @@
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)
{
- ret_t ret;
- size_t done;
+ ret_t ret = ret_eagain;
+ size_t size;
+ cherokee_fcgi_manager_t *fcgim;
+ cherokee_connection_t *conn;
+ conn = HANDLER_CONN(fcgi);
- 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);
- 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->first_data_sent == 0)
+ fcgi->first_data_sent = 1;
+ }
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 +343,121 @@
}
}
+ if (fcgi->first_data_sent == 0)
+ 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))
+ {
+ printf ("flush %d\n", fcgi->id);
+ 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) {
+ printf ("remainnig %d\n", fcgi->id);
+ 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 +466,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,7 +56,13 @@
// struct sockaddr_un local;
} cherokee_fcgi_sockaddr_t;
+typedef enum {
+ fcgi_data_unavailable,
+ fcgi_data_available,
+ fcgi_data_completed,
+} cherokee_fcgi_status_t;
+
typedef struct {
cherokee_handler_t handler;
@@ -72,6 +78,9 @@
cherokee_buffer_t environment;
cherokee_buffer_t write_buffer;
cherokee_buffer_t incoming_buffer;
+ cherokee_buffer_t data;
+ cuint_t status;
+ cuint_t first_data_sent;
} cherokee_handler_fastcgi_t;
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
