zeev Mon Dec 26 07:25:45 2005 EDT
Added files:
/php-src/sapi/cgi fastcgi.c fastcgi.h
Log:
Commit missing files - sorry!
http://cvs.php.net/viewcvs.cgi/php-src/sapi/cgi/fastcgi.c?view=markup&rev=1.1
Index: php-src/sapi/cgi/fastcgi.c
+++ php-src/sapi/cgi/fastcgi.c
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2005 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.0 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_0.txt. |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [EMAIL PROTECTED] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Dmitry Stogov <[EMAIL PROTECTED]> |
+----------------------------------------------------------------------+
*/
/* $Id: fastcgi.c,v 1.1 2005/12/26 07:25:45 zeev Exp $ */
#include "php_config.h"
#include "fastcgi.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
#ifndef MAXPATHLEN
# ifdef PATH_MAX
# define MAXPATHLEN PATH_MAX
# else
# define MAXPATHLEN 512
# endif
#endif
#ifdef _WIN32
#include <windows.h>
# define inline __inline
# define vsnprintf _vsnprintf
typedef int socklen_t;
typedef int ssize_t;
typedef unsigned int size_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); \
}
#else
# 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 <arpa/inet.h>
# include <netdb.h>
# include <sys/signal.h>
# ifndef HAVE_SOCKLEN_T
typedef unsigned int socklen_t;
# endif
# 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)
# else
# define FCGI_LOCK(fd)
# define FCGI_UNLOCK(fd)
# endif
#endif
typedef union _sa_t {
struct sockaddr sa;
struct sockaddr_un sa_unix;
struct sockaddr_in sa_inet;
} sa_t;
typedef struct _fcgi_mgmt_rec {
char* name;
char val;
} fcgi_mgmt_rec;
static const fcgi_mgmt_rec fcgi_mgmt_vars[] = {
{"FCGI_MAX_CONNS", 1},
{"FCGI_MAX_REQS", 1},
{"FCGI_MPXS_CONNS", 0}
};
static int is_initialized = 0;
static int is_fastcgi = 0;
static int in_shutdown = 0;
static inline char* fcgi_strndup(const char *str, int len)
{
char *s = malloc(len+1);
memcpy(s, str, len+1);
return s;
}
#ifdef _WIN32
static DWORD WINAPI fcgi_shutdown_thread(LPVOID arg)
{
HANDLE shutdown_event = (HANDLE) arg;
WaitForSingleObject(shutdown_event, INFINITE);
in_shutdown = 1;
return 0;
}
#else
static void fcgi_signal_handler(int signo)
{
if (signo == SIGUSR1) {
in_shutdown = 1;
}
}
#endif
int fcgi_init(void)
{
if (!is_initialized) {
#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;
}
# endif
is_initialized = 1;
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;
}
#else
sa_t sa;
socklen_t len = sizeof(sa);
is_initialized = 1;
errno = 0;
if (getpeername(0, (struct sockaddr *)&sa, &len) != 0 && errno
== ENOTCONN) {
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(SIGPIPE, NULL, &old_sa);
if (old_sa.sa_handler == SIG_DFL) {
sigaction(SIGPIPE, &new_sa, NULL);
}
return is_fastcgi = 1;
} else {
return is_fastcgi = 0;
}
#endif
}
return is_fastcgi;
}
int fcgi_is_fastcgi(void)
{
if (!is_initialized) {
return fcgi_init();
} else {
return is_fastcgi;
}
}
int fcgi_listen(const char *path, int backlog)
{
#ifdef _WIN32
/* TODO: Support for manual binding on TCP sockets (php -b <port>) */
return -1;
#else
char *s;
int tcp = 0;
char host[MAXPATHLEN];
short port = 0;
int listen_socket;
sa_t sa;
socklen_t sa_len;
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;
}
}
/* 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);
sa_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 {
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);
sa_len = sizeof(sa.sa_unix.sun_family) + path_len;
#ifdef HAVE_SOCKADDR_UN_SUN_LEN
sa_len += sizeof(sa.sa_unix.sun_len) + 1;
sa.sa_unix.sun_len = sa_len;
#endif
unlink(path);
}
/* Create, bind socket and start listen on it */
if ((listen_socket = socket(sa.sa.sa_family, SOCK_STREAM, 0)) < 0 ||
bind(listen_socket, (struct sockaddr *) &sa, sa_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);
}
if (!is_initialized) {
fcgi_init();
}
is_fastcgi = 1;
return listen_socket;
#endif
}
void fcgi_init_request(fcgi_request *req, int listen_socket)
{
memset(req, 0, 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;
}
static inline ssize_t safe_write(fcgi_request *req, const void *buf, size_t
count)
{
int ret;
size_t n = 0;
do {
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 {
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;
return pad;
}
static int fcgi_get_params(fcgi_request *req, unsigned char *p, unsigned char
*end, int n)
{
int name_len, val_len;
char *s;
while (p < end) {
name_len = *p++;
if (name_len >= 128) {
name_len = ((name_len & 0x7f) << 24);
name_len |= (*p++ << 16);
name_len |= (*p++ << 8);
name_len |= *p++;
}
val_len = *p++;
if (val_len >= 128) {
val_len = ((val_len & 0x7f) << 24);
val_len |= (*p++ << 16);
val_len |= (*p++ << 8);
val_len |= *p++;
}
req->env[n] = s = malloc(name_len + val_len + 2);
memcpy(s, p, name_len);
p += name_len;
s[name_len] = '=';
memcpy(s+name_len+1, p, val_len);
p += val_len;
s[name_len+1+val_len] = '\0';
n++;
if (n > sizeof(req->env)/sizeof(req->env[0])) {
/* TODO: to many environment variables */
return n;
}
}
return n;
}
static int fcgi_read_request(fcgi_request *req)
{
fcgi_header hdr;
int len, padding;
int n = 1;
char *s;
unsigned char buf[FCGI_MAX_LENGTH+8];
req->keep = 0;
req->in_len = 0;
req->out_hdr = NULL;
req->out_pos = req->out_buf;
memset(req->env, 0, sizeof(req->env));
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;
}
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);
switch ((((fcgi_begin_request*)buf)->roleB1 << 8) +
((fcgi_begin_request*)buf)->roleB0) {
case FCGI_RESPONDER:
req->env[0] =
fcgi_strndup("FCGI_ROLE=RESPONDER", sizeof("FCGI_ROLE=RESPONDER")-1);
break;
case FCGI_AUTHORIZER:
req->env[0] =
fcgi_strndup("FCGI_ROLE=AUTHORIZER", sizeof("FCGI_ROLE=AUTHORIZER")-1);
break;
case FCGI_FILTER:
req->env[0] = fcgi_strndup("FCGI_ROLE=FILTER",
sizeof("FCGI_ROLE=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 (safe_read(req, buf, len+padding) != len+padding) {
req->keep = 0;
return 0;
}
n = fcgi_get_params(req, buf, buf+len, n);
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) {
int i, j;
int name_len;
unsigned char *p = buf + sizeof(fcgi_header);
if (safe_read(req, buf, len+padding) != len+padding) {
return 0;
}
n = fcgi_get_params(req, buf, buf+len, 0);
for (i = 0; i < n; i++) {
if ((s = strchr(req->env[i], '=')) != NULL) {
*s = '\0';
name_len = s - req->env[i];
} else {
name_len = strlen(req->env[i]);
}
for (j = 0; j <
sizeof(fcgi_mgmt_vars)/sizeof(fcgi_mgmt_vars[0]); j++) {
if (strncmp(req->env[i],
fcgi_mgmt_vars[j].name, name_len) == 0) {
sprintf((char*)p, "%c%c%s%c", name_len, 1,
fcgi_mgmt_vars[j].name, fcgi_mgmt_vars[j].val);
p += name_len+3;
}
}
}
len = p - buf - sizeof(fcgi_header);
len += fcgi_make_header((fcgi_header*)buf,
FCGI_GET_VALUES_RESULT, 0, len);
if (safe_write(req, buf, sizeof(fcgi_header)+len) !=
sizeof(fcgi_header)+len) {
return 0;
}
return 0;
} else {
return 0;
}
return 1;
}
int fcgi_read(fcgi_request *req, char *str, int len)
{
int ret, n, rest;
fcgi_header hdr;
unsigned char buf[8];
n = 0;
rest = len;
while (rest > 0) {
if (req->in_len == 0) {
if (safe_read(req, &hdr, sizeof(fcgi_header)) !=
sizeof(fcgi_header) ||
hdr.version < FCGI_VERSION_1 ||
hdr.type != FCGI_STDIN) {
req->keep = 0;
return 0;
}
req->in_len = (hdr.contentLengthB1 << 8) |
hdr.contentLengthB0;
req->in_pad = hdr.paddingLength;
if (req->in_len == 0) {
return n;
}
}
if (req->in_len >= rest) {
ret = safe_read(req, str, rest);
} else {
ret = safe_read(req, str, req->in_len);
}
if (ret < 0) {
req->keep = 0;
return ret;
} else if (ret > 0) {
req->in_len -= ret;
rest -= ret;
n += ret;
str += ret;
if (req->in_len == 0) {
if (req->in_pad) {
if (safe_read(req, buf, req->in_pad) !=
req->in_pad) {
req->keep = 0;
return ret;
}
}
} else {
return n;
}
} else {
return n;
}
}
return n;
}
static inline void fcgi_close(fcgi_request *req, int force, int destroy)
{
if (destroy) {
char **env = req->env;
while (*env) {
free(*env++);
}
}
if ((force || !req->keep) && req->fd >= 0) {
#ifdef _WIN32
HANDLE pipe = (HANDLE)_get_osfhandle(req->fd);
if (!force) {
FlushFileBuffers(pipe);
}
DisconnectNamedPipe(pipe);
if (is_impersonate) {
RevertToSelf();
}
#else
close(req->fd);
#endif
req->fd = -1;
}
}
int fcgi_accept_request(fcgi_request *req)
{
fcgi_finish_request(req);
while (1) {
if (req->fd < 0) {
while (1) {
#ifdef _WIN32
HANDLE pipe =
(HANDLE)_get_osfhandle(req->listen_socket);
OVERLAPPED ov;
FCGI_LOCK(req->listen_socket);
ov.hEvent = CreateEvent(NULL, TRUE, FALSE,
NULL);
if (!ConnectNamedPipe(pipe, &ov)) {
errno = GetLastError();
if (errno == ERROR_IO_PENDING) {
while
(WaitForSingleObject(ov.hEvent, 1000) == WAIT_TIMEOUT) {
if (in_shutdown) {
CloseHandle(ov.hEvent);
FCGI_UNLOCK(req->listen_socket);
return -1;
}
}
} else if (errno !=
ERROR_PIPE_CONNECTED) {
}
}
CloseHandle(ov.hEvent);
if (is_impersonate &&
!ImpersonateNamedPipeClient(pipe)) {
DisconnectNamedPipe(pipe);
req->fd = -1;
} else {
req->fd = req->listen_socket;
}
FCGI_UNLOCK(req->listen_socket);
#else
sa_t sa;
socklen_t len = sizeof(sa);
FCGI_LOCK(req->listen_socket);
req->fd = accept(req->listen_socket, (struct
sockaddr *)&sa, &len);
FCGI_UNLOCK(req->listen_socket);
#endif
if (in_shutdown || (req->fd < 0 && errno !=
EINTR)) {
return -1;
}
#ifdef _WIN32
break;
#else
if (req->fd >= 0) {
struct timeval tv = {1,0};
fd_set set;
FD_ZERO(&set);
FD_SET(req->fd, &set);
try_again:
errno = 0;
if (select(req->fd + 1, &set, NULL,
NULL, &tv) >= 0 && FD_ISSET(req->fd, &set)) {
break;
}
if (errno == EINTR) goto try_again;
fcgi_close(req, 1, 0);
}
#endif
}
}
if (fcgi_read_request(req)) {
return req->fd;
} else {
fcgi_close(req, 1, 1);
}
}
}
static inline fcgi_header* open_packet(fcgi_request *req, fcgi_request_type
type)
{
req->out_hdr = (fcgi_header*) req->out_pos;
req->out_hdr->type = type;
req->out_pos += sizeof(fcgi_header);
return req->out_hdr;
}
static inline void close_packet(fcgi_request *req)
{
if (req->out_hdr) {
int len = req->out_pos - ((unsigned char*)req->out_hdr +
sizeof(fcgi_header));
req->out_pos += fcgi_make_header(req->out_hdr,
req->out_hdr->type, req->id, len);
req->out_hdr = NULL;
}
}
int fcgi_flush(fcgi_request *req, int close)
{
int len;
close_packet(req);
len = req->out_pos - req->out_buf;
if (close) {
fcgi_end_request_rec *rec =
(fcgi_end_request_rec*)(req->out_pos);
fcgi_make_header(&rec->hdr, FCGI_END_REQUEST, req->id,
sizeof(fcgi_end_request));
rec->body.appStatusB3 = 0;
rec->body.appStatusB2 = 0;
rec->body.appStatusB1 = 0;
rec->body.appStatusB0 = 0;
rec->body.protocolStatus = FCGI_REQUEST_COMPLETE;
len += sizeof(fcgi_end_request_rec);
}
if (safe_write(req, req->out_buf, len) != len) {
req->keep = 0;
return 0;
}
req->out_pos = req->out_buf;
return 1;
}
int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int
len)
{
int limit, rest;
if (len <= 0) {
return 0;
}
if (req->out_hdr && req->out_hdr->type != type) {
close_packet(req);
}
rest = len;
#if 0
/* Unoptinmzed, but clear version */
while (rest > 0) {
limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
if (!req->out_hdr) {
if (limit < sizeof(fcgi_header)) {
fcgi_flush(req, 0);
}
open_packet(req, type);
}
limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
if (rest < limit) {
memcpy(req->out_pos, str, rest);
req->out_pos += rest;
return len;
} else {
memcpy(req->out_pos, str, limit);
req->out_pos += limit;
rest -= limit;
str += limit;
fcgi_flush(req, 0);
}
}
#else
/* Optinmzed version */
if (!req->out_hdr) {
rest += sizeof(fcgi_header);
}
limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
if (rest < limit) {
if (!req->out_hdr) {
open_packet(req, type);
}
memcpy(req->out_pos, str, len);
req->out_pos += len;
} else if (rest - limit < sizeof(req->out_buf) - sizeof(fcgi_header)) {
if (!req->out_hdr) {
open_packet(req, type);
}
memcpy(req->out_pos, str, limit);
req->out_pos += limit;
fcgi_flush(req, 0);
open_packet(req, type);
memcpy(req->out_pos, str + limit, len - limit);
req->out_pos += len - limit;
} else {
int pad = ((len + 7) & ~7) - len;
rest = pad ? 8 - pad : 0;
close_packet(req);
open_packet(req, type);
fcgi_make_header(req->out_hdr, type, req->id, len - rest);
req->out_hdr = NULL;
fcgi_flush(req, 0);
if (safe_write(req, str, len - rest) != len - rest) {
req->keep = 0;
return -1;
}
if (pad) {
open_packet(req, type);
memcpy(req->out_pos, str + len - rest, rest);
req->out_pos += rest;
}
}
#endif
return len;
}
int fcgi_finish_request(fcgi_request *req)
{
fcgi_flush(req, 1);
fcgi_close(req, 0, 1);
return 1;
}
char* fcgi_getenv_helper(char** env, const char *name, int len)
{
if (name && env) {
while (*env) {
if ((strncmp(name, *env, len) == 0) && ((*env)[len] ==
'=')) {
return *env+len+1;
}
env++;
}
}
return NULL;
}
char* fcgi_getenv(fcgi_request *req, const char* var, int var_len)
{
if (!req) return NULL;
return fcgi_getenv_helper(req->env, var, var_len);
}
void fcgi_putenv(fcgi_request *req, char* var, int var_len)
{
if (var && req) {
char **env = req->env;
char *s = strchr(var, '=');
int len;
if (!s) return ;
len = s - var + 1;
while (*env) {
if ((strncmp(var, *env, len) == 0)) {
free(*env);
*env = fcgi_strndup(var, var_len);
return;
}
env++;
}
*env = fcgi_strndup(var, var_len);
}
}
int FCGX_FPrintF(FCGX_Stream stream, const char *format, ...)
{
int result;
va_list args;
char buf[4096];
va_start(args, format);
result = vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
fcgi_write(stream.req, stream.type, buf, result);
return result;
}
#ifdef _WIN32
void OS_SetImpersonate(void)
{
char *os_name;
os_name = getenv("OS");
if (os_name && stricmp(os_name, "Windows_NT") == 0) {
is_impersonate = 1;
}
}
#endif
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 fdm=marker
* vim<600: sw=4 ts=4
*/
http://cvs.php.net/viewcvs.cgi/php-src/sapi/cgi/fastcgi.h?view=markup&rev=1.1
Index: php-src/sapi/cgi/fastcgi.h
+++ php-src/sapi/cgi/fastcgi.h
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2005 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.0 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_0.txt. |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [EMAIL PROTECTED] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Dmitry Stogov <[EMAIL PROTECTED]> |
+----------------------------------------------------------------------+
*/
/* $Id: fastcgi.h,v 1.1 2005/12/26 07:25:45 zeev Exp $ */
/* FastCGI protocol */
#define FCGI_VERSION_1 1
#define FCGI_MAX_LENGTH 0xffff
#define FCGI_KEEP_CONN 1
typedef enum _fcgi_role {
FCGI_RESPONDER = 1,
FCGI_AUTHORIZER = 2,
FCGI_FILTER = 3
} fcgi_role;
typedef enum _fcgi_request_type {
FCGI_BEGIN_REQUEST = 1, /* [in]
*/
FCGI_ABORT_REQUEST = 2, /* [in] (not supported)
*/
FCGI_END_REQUEST = 3, /* [out]
*/
FCGI_PARAMS = 4, /* [in] environment
variables */
FCGI_STDIN = 5, /* [in] post data
*/
FCGI_STDOUT = 6, /* [out] response
*/
FCGI_STDERR = 7, /* [out] errors
*/
FCGI_DATA = 8, /* [in] filter data (not
supported) */
FCGI_GET_VALUES = 9, /* [in]
*/
FCGI_GET_VALUES_RESULT = 10 /* [out] */
} fcgi_request_type;
typedef enum _fcgi_protocol_status {
FCGI_REQUEST_COMPLETE = 0,
FCGI_CANT_MPX_CONN = 1,
FCGI_OVERLOADED = 2,
FCGI_UNKNOWN_ROLE = 3
} dcgi_protocol_status;
typedef struct _fcgi_header {
unsigned char version;
unsigned char type;
unsigned char requestIdB1;
unsigned char requestIdB0;
unsigned char contentLengthB1;
unsigned char contentLengthB0;
unsigned char paddingLength;
unsigned char reserved;
} fcgi_header;
typedef struct _fcgi_begin_request {
unsigned char roleB1;
unsigned char roleB0;
unsigned char flags;
unsigned char reserved[5];
} fcgi_begin_request;
typedef struct _fcgi_begin_request_rec {
fcgi_header hdr;
fcgi_begin_request body;
} fcgi_begin_request_rec;
typedef struct _fcgi_end_request {
unsigned char appStatusB3;
unsigned char appStatusB2;
unsigned char appStatusB1;
unsigned char appStatusB0;
unsigned char protocolStatus;
unsigned char reserved[3];
} fcgi_end_request;
typedef struct _fcgi_end_request_rec {
fcgi_header hdr;
fcgi_end_request body;
} fcgi_end_request_rec;
/* FastCGI client API */
typedef struct _fcgi_request {
int listen_socket;
int fd;
int id;
int keep;
int in_len;
int in_pad;
fcgi_header *out_hdr;
unsigned char *out_pos;
unsigned char out_buf[1024*8];
unsigned char reserved[sizeof(fcgi_end_request_rec)];
char *env[128];
} fcgi_request;
int fcgi_init(void);
int fcgi_is_fastcgi(void);
int fcgi_listen(const char *path, int backlog);
void fcgi_init_request(fcgi_request *req, int listen_socket);
int fcgi_accept_request(fcgi_request *req);
int fcgi_finish_request(fcgi_request *req);
char* fcgi_getenv(fcgi_request *req, const char* var, int var_len);
void fcgi_putenv(fcgi_request *req, char* var, int var_len);
int fcgi_read(fcgi_request *req, char *str, int len);
int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int
len);
int fcgi_flush(fcgi_request *req, int close);
/* Some defines for limited libfcgi comatibility */
typedef struct _FCGX_Stream {
fcgi_request *req;
fcgi_request_type type;
} FCGX_Stream;
typedef struct _FCGX_Request {
fcgi_request req;
FCGX_Stream in;
FCGX_Stream out;
FCGX_Stream err;
char **envp;
} FCGX_Request;
#define FCGX_Init()
#define FCGX_IsCGI()
(!fcgi_is_fastcgi())
#define FCGX_OpenSocket(path, backlog) fcgi_listen(path, backlog)
#define FCGX_InitRequest(r, sock, flags) \
do {
\
fcgi_init_request(&(r)->req, sock); \
(r)->in.req = &(r)->req; \
(r)->out.req = &(r)->req; \
(r)->err.req = &(r)->req; \
(r)->in.type = FCGI_STDIN; \
(r)->out.type = FCGI_STDOUT; \
(r)->err.type = FCGI_STDERR; \
(r)->envp = (r)->req.env; \
} while (0);
#define FCGX_Accept_r(r)
fcgi_accept_request(&(r)->req)
#define FCGX_Finish_r(r)
fcgi_finish_request(&(r)->req)
#define FCGX_PutStr(str, len, stream) fcgi_write((stream).req,
(stream).type, str, len)
#define FCGX_PutS(str, len, stream)
fcgi_write((stream).req, (stream).type, str, len)
#define FCGX_FFlush(stream) fcgi_flush((stream).req, 0)
#define FCGX_GetStr(str, len, stream) fcgi_read((stream).req, str, len)
#define FCGX_GetParam(var, envp)
fcgi_getenv_helper(envp, var, strlen(var));
#define FCGX_PutEnv(r, var)
fcgi_putenv(&(r)->req, var, strlen(var));
int FCGX_FPrintF(FCGX_Stream stream, const char *format, ...);
/* Internal helper functions. They shouldn't be used directly. */
char* fcgi_getenv_helper(char** env, const char *name, int len);
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 fdm=marker
* vim<600: sw=4 ts=4
*/
--
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
