#include "php.h"

#include "fastcgi.h"

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <errno.h>

#ifdef _WIN32

#include <windows.h>

typedef unsigned int in_addr_t;

struct sockaddr_un {

short sun_family;

char sun_path[MAXPATHLEN];

};

static HANDLE fcgi_accept_mutex = INVALID_HANDLE_VALUE;

static int is_impersonate = 0;

#define FCGI_LOCK(fd) \

if (fcgi_accept_mutex != INVALID_HANDLE_VALUE) { \

DWORD ret; \

while ((ret = WaitForSingleObject(fcgi_accept_mutex, 1000)) == WAIT_TIMEOUT) { \

if (in_shutdown) return -1; \

} \

if (ret == WAIT_FAILED) { \

fprintf(stderr, "WaitForSingleObject() failed\n"); \

return -1; \

} \

}

#define FCGI_UNLOCK(fd) \

if (fcgi_accept_mutex != INVALID_HANDLE_VALUE) { \

ReleaseMutex(fcgi_accept_mutex); \

}

# include <sys/types.h>

# include <sys/stat.h>

# include <unistd.h>

# include <fcntl.h>

# include <sys/socket.h>

# include <sys/un.h>

# include <netinet/in.h>

# include <netinet/tcp.h>

# include <arpa/inet.h>

# include <netdb.h>

# include <signal.h>

# define closesocket(s) close(s)

# if defined(HAVE_SYS_POLL_H) && defined(HAVE_POLL)

# include <sys/poll.h>

# if defined(HAVE_SYS_SELECT_H)

# include <sys/select.h>

#ifndef INADDR_NONE

#define INADDR_NONE ((unsigned long) -1)

# ifndef HAVE_SOCKLEN_T

typedef unsigned int socklen_t;

# ifdef USE_LOCKING

# define FCGI_LOCK(fd) \

do { \

struct flock lock; \

lock.l_type = F_WRLCK; \

lock.l_start = 0; \

lock.l_whence = SEEK_SET; \

lock.l_len = 0; \

if (fcntl(fd, F_SETLKW, &lock) != -1) { \

break; \

} else if (errno != EINTR || in_shutdown) { \

return -1; \

} \

} while (1)

# define FCGI_UNLOCK(fd) \

do { \

int orig_errno = errno; \

while (1) { \

struct flock lock; \

lock.l_type = F_UNLCK; \

lock.l_start = 0; \

lock.l_whence = SEEK_SET; \

lock.l_len = 0; \

if (fcntl(fd, F_SETLK, &lock) != -1) { \

break; \

} else if (errno != EINTR) { \

return -1; \

} \

} \

errno = orig_errno; \

} while (0)

# define FCGI_LOCK(fd)

# define FCGI_UNLOCK(fd)

typedef union _sa_t {

struct sockaddr sa;

struct sockaddr_un sa_unix;

struct sockaddr_in sa_inet;

} sa_t;

static HashTable fcgi_mgmt_vars;

static int is_initialized = 0;

static int is_fastcgi = 0;

static int in_shutdown = 0;

static in_addr_t *allowed_clients = NULL;

#define FCGI_HASH_TABLE_SIZE 128

#define FCGI_HASH_TABLE_MASK (FCGI_HASH_TABLE_SIZE - 1)

#define FCGI_HASH_SEG_SIZE 4096

typedef struct _fcgi_hash_bucket {

} fcgi_hash_bucket;

typedef struct _fcgi_hash_buckets {

} fcgi_hash_buckets;

typedef struct _fcgi_data_seg {

} fcgi_data_seg;

typedef struct _fcgi_hash {

} fcgi_hash;

static void fcgi_hash_init(fcgi_hash *h)

{

memset(h->hash_table, 0, sizeof(h->hash_table));

h->list = NULL;

h->buckets = (fcgi_hash_buckets*)malloc(sizeof(fcgi_hash_buckets));

h->buckets->idx = 0;

h->buckets->next = NULL;

h->data = (fcgi_data_seg*)malloc(sizeof(fcgi_data_seg) - 1 + FCGI_HASH_SEG_SIZE);

h->data->pos = h->data->data;

h->data->end = h->data->pos + FCGI_HASH_SEG_SIZE;

h->data->next = NULL;

}

static void fcgi_hash_destroy(fcgi_hash *h)

{

fcgi_hash_buckets *b;

fcgi_data_seg *p;

b = h->buckets;

while (b) {

fcgi_hash_buckets *q = b;

b = b->next;

free(q);

}

p = h->data;

while (p) {

fcgi_data_seg *q = p;

p = p->next;

free(q);

}

}

static void fcgi_hash_clean(fcgi_hash *h)

{

memset(h->hash_table, 0, sizeof(h->hash_table));

h->list = NULL;

/* delete all bucket blocks except the first one */

while (h->buckets->next) {

fcgi_hash_buckets *q = h->buckets;

h->buckets = h->buckets->next;

free(q);

}

h->buckets->idx = 0;

/* delete all data segments except the first one */

while (h->data->next) {

fcgi_data_seg *q = h->data;

h->data = h->data->next;

free(q);

}

h->data->pos = h->data->data;

}

static inline char* fcgi_hash_strndup(fcgi_hash *h, char *str, unsigned int str_len)

{

char *ret;

if (UNEXPECTED(h->data->pos + str_len + 1 >= h->data->end)) {

unsigned int seg_size = (str_len + 1 > FCGI_HASH_SEG_SIZE) ? str_len + 1 : FCGI_HASH_SEG_SIZE;

fcgi_data_seg *p = (fcgi_data_seg*)malloc(sizeof(fcgi_data_seg) - 1 + seg_size);

p->pos = p->data;

p->end = p->pos + seg_size;

p->next = h->data;

h->data = p;

}

ret = h->data->pos;

memcpy(ret, str, str_len);

ret[str_len] = 0;

h->data->pos += str_len + 1;

return ret;

}

static char* fcgi_hash_set(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, char *val, unsigned int val_len)

{

unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK;

fcgi_hash_bucket *p = h->hash_table[idx];

while (UNEXPECTED(p != NULL)) {

if (UNEXPECTED(p->hash_value == hash_value) &&

p->var_len == var_len &&

memcmp(p->var, var, var_len) == 0) {

p->val_len = val_len;

p->val = fcgi_hash_strndup(h, val, val_len);

return p->val;

}

p = p->next;

}

if (UNEXPECTED(h->buckets->idx >= FCGI_HASH_TABLE_SIZE)) {

fcgi_hash_buckets *b = (fcgi_hash_buckets*)malloc(sizeof(fcgi_hash_buckets));

b->idx = 0;

b->next = h->buckets;

h->buckets = b;

}

p = h->buckets->data + h->buckets->idx;

h->buckets->idx++;

p->next = h->hash_table[idx];

h->hash_table[idx] = p;

p->list_next = h->list;

h->list = p;

p->hash_value = hash_value;

p->var_len = var_len;

p->var = fcgi_hash_strndup(h, var, var_len);

p->val_len = val_len;

p->val = fcgi_hash_strndup(h, val, val_len);

return p->val;

}

static void fcgi_hash_del(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len)

{

unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK;

fcgi_hash_bucket **p = &h->hash_table[idx];

while (*p != NULL) {

if ((*p)->hash_value == hash_value &&

(*p)->var_len == var_len &&

memcmp((*p)->var, var, var_len) == 0) {

(*p)->val = NULL; /* NULL value means deleted */

(*p)->val_len = 0;

*p = (*p)->next;

return;

}

p = &(*p)->next;

}

}

static char *fcgi_hash_get(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, unsigned int *val_len)

{

unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK;

fcgi_hash_bucket *p = h->hash_table[idx];

while (p != NULL) {

if (p->hash_value == hash_value &&

p->var_len == var_len &&

memcmp(p->var, var, var_len) == 0) {

*val_len = p->val_len;

return p->val;

}

p = p->next;

}

return NULL;

}

static void fcgi_hash_apply(fcgi_hash *h, fcgi_apply_func func, void *arg TSRMLS_DC)

{

fcgi_hash_bucket *p = h->list;

while (p) {

if (EXPECTED(p->val != NULL)) {

func(p->var, p->var_len, p->val, p->val_len, arg TSRMLS_CC);

}

p = p->list_next;

}

}

struct _fcgi_request {

};

#ifdef _WIN32

static DWORD WINAPI fcgi_shutdown_thread(LPVOID arg)

{

HANDLE shutdown_event = (HANDLE) arg;

WaitForSingleObject(shutdown_event, INFINITE);

in_shutdown = 1;

return 0;

}

static void fcgi_signal_handler(int signo)

{

if (signo == SIGUSR1 || signo == SIGTERM) {

in_shutdown = 1;

}

}

static void fcgi_setup_signals(void)

{

struct sigaction new_sa, old_sa;

sigemptyset(&new_sa.sa_mask);

new_sa.sa_flags = 0;

new_sa.sa_handler = fcgi_signal_handler;

sigaction(SIGUSR1, &new_sa, NULL);

sigaction(SIGTERM, &new_sa, NULL);

sigaction(SIGPIPE, NULL, &old_sa);

if (old_sa.sa_handler == SIG_DFL) {

sigaction(SIGPIPE, &new_sa, NULL);

}

}

int fcgi_in_shutdown(void)

{

return in_shutdown;

}

void fcgi_terminate(void)

{

in_shutdown = 1;

}

int fcgi_init(void)

{

if (!is_initialized) {

#ifndef _WIN32

sa_t sa;

socklen_t len = sizeof(sa);

zend_hash_init(&fcgi_mgmt_vars, 0, NULL, fcgi_free_mgmt_var_cb, 1);

fcgi_set_mgmt_var("FCGI_MPXS_CONNS", sizeof("FCGI_MPXS_CONNS")-1, "0", sizeof("0")-1);

is_initialized = 1;

#ifdef _WIN32

# if 0

/* TODO: Support for TCP sockets */

WSADATA wsaData;

if (WSAStartup(MAKEWORD(2,0), &wsaData)) {

fprintf(stderr, "Error starting Windows Sockets. Error: %d", WSAGetLastError());

return 0;

}

if ((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&

(GetStdHandle(STD_ERROR_HANDLE) == INVALID_HANDLE_VALUE) &&

(GetStdHandle(STD_INPUT_HANDLE) != INVALID_HANDLE_VALUE)) {

char *str;

DWORD pipe_mode = PIPE_READMODE_BYTE | PIPE_WAIT;

HANDLE pipe = GetStdHandle(STD_INPUT_HANDLE);

SetNamedPipeHandleState(pipe, &pipe_mode, NULL, NULL);

str = getenv("_FCGI_SHUTDOWN_EVENT_");

if (str != NULL) {

HANDLE shutdown_event = (HANDLE) atoi(str);

if (!CreateThread(NULL, 0, fcgi_shutdown_thread,

shutdown_event, 0, NULL)) {

return -1;

}

}

str = getenv("_FCGI_MUTEX_");

if (str != NULL) {

fcgi_accept_mutex = (HANDLE) atoi(str);

}

return is_fastcgi = 1;

} else {

return is_fastcgi = 0;

}

errno = 0;

if (getpeername(0, (struct sockaddr *)&sa, &len) != 0 && errno == ENOTCONN) {

fcgi_setup_signals();

return is_fastcgi = 1;

} else {

return is_fastcgi = 0;

}

}

return is_fastcgi;

}

int fcgi_is_fastcgi(void)

{

if (!is_initialized) {

return fcgi_init();

} else {

return is_fastcgi;

}

}

void fcgi_shutdown(void)

{

if (is_initialized) {

zend_hash_destroy(&fcgi_mgmt_vars);

}

is_fastcgi = 0;

if (allowed_clients) {

free(allowed_clients);

}

}

#ifdef _WIN32

static PACL prepare_named_pipe_acl(PSECURITY_DESCRIPTOR sd, LPSECURITY_ATTRIBUTES sa)

{

DWORD req_acl_size;

char everyone_buf[32], owner_buf[32];

PSID sid_everyone, sid_owner;

SID_IDENTIFIER_AUTHORITY

siaWorld = SECURITY_WORLD_SID_AUTHORITY,

siaCreator = SECURITY_CREATOR_SID_AUTHORITY;

PACL acl;

sid_everyone = (PSID)&everyone_buf;

sid_owner = (PSID)&owner_buf;

req_acl_size = sizeof(ACL) +

(2 * ((sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) + GetSidLengthRequired(1)));

acl = malloc(req_acl_size);

if (acl == NULL) {

return NULL;

}

if (!InitializeSid(sid_everyone, &siaWorld, 1)) {

goto out_fail;

}

*GetSidSubAuthority(sid_everyone, 0) = SECURITY_WORLD_RID;

if (!InitializeSid(sid_owner, &siaCreator, 1)) {

goto out_fail;

}

*GetSidSubAuthority(sid_owner, 0) = SECURITY_CREATOR_OWNER_RID;

if (!InitializeAcl(acl, req_acl_size, ACL_REVISION)) {

goto out_fail;

}

if (!AddAccessAllowedAce(acl, ACL_REVISION, FILE_GENERIC_READ | FILE_GENERIC_WRITE, sid_everyone)) {

goto out_fail;

}

if (!AddAccessAllowedAce(acl, ACL_REVISION, FILE_ALL_ACCESS, sid_owner)) {

goto out_fail;

}

if (!InitializeSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION)) {

goto out_fail;

}

if (!SetSecurityDescriptorDacl(sd, TRUE, acl, FALSE)) {

goto out_fail;

}

sa->lpSecurityDescriptor = sd;

return acl;

out_fail:

free(acl);

return NULL;

}

static int is_port_number(const char *bindpath)

{

while (*bindpath) {

if (*bindpath < '0' || *bindpath > '9') {

return 0;

}

bindpath++;

}

return 1;

}

int fcgi_listen(const char *path, int backlog)

{

char *s;

int tcp = 0;

char host[MAXPATHLEN];

short port = 0;

int listen_socket;

sa_t sa;

socklen_t sock_len;

#ifdef SO_REUSEADDR

# ifdef _WIN32

BOOL reuse = 1;

int reuse = 1;

if ((s = strchr(path, ':'))) {

port = atoi(s+1);

if (port != 0 && (s-path) < MAXPATHLEN) {

strncpy(host, path, s-path);

host[s-path] = '\0';

tcp = 1;

}

} else if (is_port_number(path)) {

port = atoi(path);

if (port != 0) {

host[0] = '\0';

tcp = 1;

}

}

/* Prepare socket address */

if (tcp) {

memset(&sa.sa_inet, 0, sizeof(sa.sa_inet));

sa.sa_inet.sin_family = AF_INET;

sa.sa_inet.sin_port = htons(port);

sock_len = sizeof(sa.sa_inet);

if (!*host || !strncmp(host, "*", sizeof("*")-1)) {

sa.sa_inet.sin_addr.s_addr = htonl(INADDR_ANY);

} else {

sa.sa_inet.sin_addr.s_addr = inet_addr(host);

if (sa.sa_inet.sin_addr.s_addr == INADDR_NONE) {

struct hostent *hep;

hep = gethostbyname(host);

if (!hep || hep->h_addrtype != AF_INET || !hep->h_addr_list[0]) {

fprintf(stderr, "Cannot resolve host name '%s'!\n", host);

return -1;

} else if (hep->h_addr_list[1]) {

fprintf(stderr, "Host '%s' has multiple addresses. You must choose one explicitly!\n", host);

return -1;

}

sa.sa_inet.sin_addr.s_addr = ((struct in_addr*)hep->h_addr_list[0])->s_addr;

}

}

} else {

#ifdef _WIN32

SECURITY_DESCRIPTOR sd;

SECURITY_ATTRIBUTES saw;

PACL acl;

HANDLE namedPipe;

memset(&sa, 0, sizeof(saw));

saw.nLength = sizeof(saw);

saw.bInheritHandle = FALSE;

acl = prepare_named_pipe_acl(&sd, &saw);

namedPipe = CreateNamedPipe(path,

PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,

PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_READMODE_BYTE,

PIPE_UNLIMITED_INSTANCES,

8192, 8192, 0, &saw);

if (namedPipe == INVALID_HANDLE_VALUE) {

return -1;

}

listen_socket = _open_osfhandle((long)namedPipe, 0);

if (!is_initialized) {

fcgi_init();

}

is_fastcgi = 1;

return listen_socket;

int path_len = strlen(path);

if (path_len >= sizeof(sa.sa_unix.sun_path)) {

fprintf(stderr, "Listening socket's path name is too long.\n");

return -1;

}

memset(&sa.sa_unix, 0, sizeof(sa.sa_unix));

sa.sa_unix.sun_family = AF_UNIX;

memcpy(sa.sa_unix.sun_path, path, path_len + 1);

sock_len = (size_t)(((struct sockaddr_un *)0)->sun_path) + path_len;

#ifdef HAVE_SOCKADDR_UN_SUN_LEN

sa.sa_unix.sun_len = sock_len;

unlink(path);

}

/* Create, bind socket and start listen on it */

if ((listen_socket = socket(sa.sa.sa_family, SOCK_STREAM, 0)) < 0 ||

#ifdef SO_REUSEADDR

setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse)) < 0 ||

bind(listen_socket, (struct sockaddr *) &sa, sock_len) < 0 ||

listen(listen_socket, backlog) < 0) {

fprintf(stderr, "Cannot bind/listen socket - [%d] %s.\n",errno, strerror(errno));

return -1;

}

if (!tcp) {

chmod(path, 0777);

} else {

char *ip = getenv("FCGI_WEB_SERVER_ADDRS");

char *cur, *end;

int n;

if (ip) {

ip = strdup(ip);

cur = ip;

n = 0;

while (*cur) {

if (*cur == ',') n++;

cur++;

}

allowed_clients = malloc(sizeof(in_addr_t) * (n+2));

n = 0;

cur = ip;

while (cur) {

end = strchr(cur, ',');

if (end) {

*end = 0;

end++;

}

allowed_clients[n] = inet_addr(cur);

if (allowed_clients[n] == INADDR_NONE) {

fprintf(stderr, "Wrong IP address '%s' in FCGI_WEB_SERVER_ADDRS\n", cur);

}

n++;

cur = end;

}

allowed_clients[n] = INADDR_NONE;

free(ip);

}

}

if (!is_initialized) {

fcgi_init();

}

is_fastcgi = 1;

#ifdef _WIN32

if (tcp) {

listen_socket = _open_osfhandle((long)listen_socket, 0);

}

fcgi_setup_signals();

return listen_socket;

}

fcgi_request *fcgi_init_request(int listen_socket)

{

fcgi_request *req = (fcgi_request*)calloc(1, sizeof(fcgi_request));

req->listen_socket = listen_socket;

req->fd = -1;

req->id = -1;

req->in_len = 0;

req->in_pad = 0;

req->out_hdr = NULL;

req->out_pos = req->out_buf;

#ifdef _WIN32

req->tcp = !GetNamedPipeInfo((HANDLE)_get_osfhandle(req->listen_socket), NULL, NULL, NULL, NULL);

#ifdef TCP_NODELAY

req->nodelay = 0;

fcgi_hash_init(&req->env);

return req;

}

void fcgi_destroy_request(fcgi_request *req)

{

fcgi_hash_destroy(&req->env);

free(req);

}

static inline ssize_t safe_write(fcgi_request *req, const void *buf, size_t count)

{

int ret;

size_t n = 0;

do {

errno = 0;

#ifdef _WIN32

if (!req->tcp) {

ret = write(req->fd, ((char*)buf)+n, count-n);

} else {

ret = send(req->fd, ((char*)buf)+n, count-n, 0);

if (ret <= 0) {

errno = WSAGetLastError();

}

}

ret = write(req->fd, ((char*)buf)+n, count-n);

if (ret > 0) {

n += ret;

} else if (ret <= 0 && errno != 0 && errno != EINTR) {

return ret;

}

} while (n != count);

return n;

}

static inline ssize_t safe_read(fcgi_request *req, const void *buf, size_t count)

{

int ret;

size_t n = 0;

do {

errno = 0;

#ifdef _WIN32

if (!req->tcp) {

ret = read(req->fd, ((char*)buf)+n, count-n);

} else {

ret = recv(req->fd, ((char*)buf)+n, count-n, 0);

if (ret <= 0) {

errno = WSAGetLastError();

}

}

ret = read(req->fd, ((char*)buf)+n, count-n);

if (ret > 0) {

n += ret;

} else if (ret == 0 && errno == 0) {

return n;

} else if (ret <= 0 && errno != 0 && errno != EINTR) {

return ret;

}

} while (n != count);

return n;

}

static inline int fcgi_make_header(fcgi_header *hdr, fcgi_request_type type, int req_id, int len)

{

int pad = ((len + 7) & ~7) - len;

hdr->contentLengthB0 = (unsigned char)(len & 0xff);

hdr->contentLengthB1 = (unsigned char)((len >> 8) & 0xff);

hdr->paddingLength = (unsigned char)pad;

hdr->requestIdB0 = (unsigned char)(req_id & 0xff);

hdr->requestIdB1 = (unsigned char)((req_id >> 8) & 0xff);

hdr->reserved = 0;

hdr->type = type;

hdr->version = FCGI_VERSION_1;

if (pad) {

memset(((unsigned char*)hdr) + sizeof(fcgi_header) + len, 0, pad);

}

return pad;

}

static int fcgi_get_params(fcgi_request *req, unsigned char *p, unsigned char *end)

{

unsigned int name_len, val_len;

while (p < end) {

name_len = *p++;

if (UNEXPECTED(name_len >= 128)) {

if (UNEXPECTED(p + 3 >= end)) return 0;

name_len = ((name_len & 0x7f) << 24);

name_len |= (*p++ << 16);

name_len |= (*p++ << 8);

name_len |= *p++;

}

if (UNEXPECTED(p >= end)) return 0;

val_len = *p++;

if (UNEXPECTED(val_len >= 128)) {

if (UNEXPECTED(p + 3 >= end)) return 0;

val_len = ((val_len & 0x7f) << 24);

val_len |= (*p++ << 16);

val_len |= (*p++ << 8);

val_len |= *p++;

}

if (UNEXPECTED(name_len + val_len > (unsigned int) (end - p))) {

/* Malformated request */

return 0;

}

fcgi_hash_set(&req->env, FCGI_HASH_FUNC(p, name_len), (char*)p, name_len, (char*)p + name_len, val_len);

p += name_len + val_len;

}

return 1;

}

static int fcgi_read_request(fcgi_request *req)

{

fcgi_header hdr;

int len, padding;

unsigned char buf[FCGI_MAX_LENGTH+8];

req->keep = 0;

req->closed = 0;

req->in_len = 0;

req->out_hdr = NULL;

req->out_pos = req->out_buf;

req->has_env = 1;

if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||

hdr.version < FCGI_VERSION_1) {

return 0;

}

len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;

padding = hdr.paddingLength;

while (hdr.type == FCGI_STDIN && len == 0) {

if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||

hdr.version < FCGI_VERSION_1) {

return 0;

}

len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;

padding = hdr.paddingLength;

}

if (len + padding > FCGI_MAX_LENGTH) {

return 0;

}

req->id = (hdr.requestIdB1 << 8) + hdr.requestIdB0;

if (hdr.type == FCGI_BEGIN_REQUEST && len == sizeof(fcgi_begin_request)) {

if (safe_read(req, buf, len+padding) != len+padding) {

return 0;

}

req->keep = (((fcgi_begin_request*)buf)->flags & FCGI_KEEP_CONN);

#ifdef TCP_NODELAY

if (req->keep && req->tcp && !req->nodelay) {

# ifdef _WIN32

BOOL on = 1;

int on = 1;

setsockopt(req->fd, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));

req->nodelay = 1;

}

switch ((((fcgi_begin_request*)buf)->roleB1 << 8) + ((fcgi_begin_request*)buf)->roleB0) {

case FCGI_RESPONDER:

fcgi_hash_set(&req->env, FCGI_HASH_FUNC("FCGI_ROLE", sizeof("FCGI_ROLE")-1), "FCGI_ROLE", sizeof("FCGI_ROLE")-1, "RESPONDER", sizeof("RESPONDER")-1);

break;

case FCGI_AUTHORIZER:

fcgi_hash_set(&req->env, FCGI_HASH_FUNC("FCGI_ROLE", sizeof("FCGI_ROLE")-1), "FCGI_ROLE", sizeof("FCGI_ROLE")-1, "AUTHORIZER", sizeof("AUTHORIZER")-1);

break;

case FCGI_FILTER:

fcgi_hash_set(&req->env, FCGI_HASH_FUNC("FCGI_ROLE", sizeof("FCGI_ROLE")-1), "FCGI_ROLE", sizeof("FCGI_ROLE")-1, "FILTER", sizeof("FILTER")-1);

break;

default:

return 0;

}

if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||

hdr.version < FCGI_VERSION_1) {

return 0;

}

len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;

padding = hdr.paddingLength;

while (hdr.type == FCGI_PARAMS && len > 0) {

if (len + padding > FCGI_MAX_LENGTH) {

return 0;

}

if (safe_read(req, buf, len+padding) != len+padding) {

req->keep = 0;

return 0;

}

if (!fcgi_get_params(req, buf, buf+len)) {

req->keep = 0;

return 0;

}

if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||

hdr.version < FCGI_VERSION_1) {

req->keep = 0;

return 0;

}

len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;

padding = hdr.paddingLength;

}

} else if (hdr.type == FCGI_GET_VALUES) {

unsigned char *p = buf + sizeof(fcgi_header);

zval ** value;

unsigned int zlen;

fcgi_hash_bucket *q;

if (safe_read(req, buf, len+padding) != len+padding) {

req->keep = 0;

return 0;

}

if (!fcgi_get_params(req, buf, buf+len)) {

req->keep = 0;

return 0;

}

q = req->env.list;

while (q != NULL) {

if (zend_hash_find(&fcgi_mgmt_vars, q->var, q->var_len, (void**) &value) != SUCCESS) {

continue;

}

zlen = Z_STRLEN_PP(value);

if ((p + 4 + 4 + q->var_len + zlen) >= (buf + sizeof(buf))) {

break;

}

if (q->var_len < 0x80) {

*p++ = q->var_len;