#include "php.h"
#include "php_network.h"
-#include "fastcgi.h"
#include <string.h>
#include <stdlib.h>
#define MAXFQDNLEN 255
#endif
-static fcgi_logger flog;
-
#ifdef _WIN32
#include <windows.h>
#endif
+#include "fastcgi.h"
+
+/* maybe it's better to use weak name instead */
+static fcgi_logger logger;
+
typedef union _sa_t {
struct sockaddr sa;
struct sockaddr_un sa_unix;
struct sockaddr_in sa_inet;
+ struct sockaddr_in6 sa_inet6;
} 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;
+static sa_t *allowed_clients = NULL;
+static sa_t client_sa;
/* hash table */
-
-#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 {
- unsigned int hash_value;
- unsigned int var_len;
- char *var;
- unsigned int val_len;
- char *val;
- struct _fcgi_hash_bucket *next;
- struct _fcgi_hash_bucket *list_next;
-} fcgi_hash_bucket;
-
-typedef struct _fcgi_hash_buckets {
- unsigned int idx;
- struct _fcgi_hash_buckets *next;
- struct _fcgi_hash_bucket data[FCGI_HASH_TABLE_SIZE];
-} fcgi_hash_buckets;
-
-typedef struct _fcgi_data_seg {
- char *pos;
- char *end;
- struct _fcgi_data_seg *next;
- char data[1];
-} fcgi_data_seg;
-
-typedef struct _fcgi_hash {
- fcgi_hash_bucket *hash_table[FCGI_HASH_TABLE_SIZE];
- fcgi_hash_bucket *list;
- fcgi_hash_buckets *buckets;
- fcgi_data_seg *data;
-} fcgi_hash;
-
static void fcgi_hash_init(fcgi_hash *h)
{
memset(h->hash_table, 0, sizeof(h->hash_table));
}
}
-struct _fcgi_request {
- int listen_socket;
- int tcp;
- int fd;
- int id;
- int keep;
-#ifdef TCP_NODELAY
- int nodelay;
-#endif
- int closed;
-
- 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)];
-
- int has_env;
- fcgi_hash env;
-};
-
#ifdef _WIN32
static DWORD WINAPI fcgi_shutdown_thread(LPVOID arg)
}
#endif
+void fcgi_set_in_shutdown(int new_value)
+{
+ in_shutdown = new_value;
+}
+
int fcgi_in_shutdown(void)
{
return in_shutdown;
in_shutdown = 1;
}
-void fcgi_set_logger(fcgi_logger logger) {
- flog = logger;
+void fcgi_set_logger(fcgi_logger lg) {
+ logger = lg;
}
int fcgi_init(void)
hep = gethostbyname(host);
}
if (!hep || hep->h_addrtype != AF_INET || !hep->h_addr_list[0]) {
- flog(FCGI_ERROR, "Cannot resolve host name '%s'!\n", host);
+ logger(FCGI_ERROR, "Cannot resolve host name '%s'!\n", host);
return -1;
} else if (hep->h_addr_list[1]) {
- flog(FCGI_ERROR, "Host '%s' has multiple addresses. You must choose one explicitly!\n", host);
+ logger(FCGI_ERROR, "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;
int path_len = strlen(path);
if (path_len >= sizeof(sa.sa_unix.sun_path)) {
- flog(FCGI_ERROR, "Listening socket's path name is too long.\n");
+ logger(FCGI_ERROR, "Listening socket's path name is too long.\n");
return -1;
}
bind(listen_socket, (struct sockaddr *) &sa, sock_len) < 0 ||
listen(listen_socket, backlog) < 0) {
- flog(FCGI_ERROR, "Cannot bind/listen socket - [%d] %s.\n",errno, strerror(errno));
+ logger(FCGI_ERROR, "Cannot bind/listen socket - [%d] %s.\n",errno, strerror(errno));
return -1;
}
if (*cur == ',') n++;
cur++;
}
- allowed_clients = malloc(sizeof(in_addr_t) * (n+2));
+ allowed_clients = malloc(sizeof(sa_t) * (n+2));
n = 0;
cur = ip;
while (cur) {
*end = 0;
end++;
}
- allowed_clients[n] = inet_addr(cur);
- if (allowed_clients[n] == INADDR_NONE) {
- flog(FCGI_ERROR, "Wrong IP address '%s' in FCGI_WEB_SERVER_ADDRS\n", cur);
+ if (inet_pton(AF_INET, cur, &allowed_clients[n].sa_inet.sin_addr)>0) {
+ allowed_clients[n].sa.sa_family = AF_INET;
+ n++;
+#ifdef HAVE_IPV6
+ } else if (inet_pton(AF_INET6, cur, &allowed_clients[n].sa_inet6.sin6_addr)>0) {
+ allowed_clients[n].sa.sa_family = AF_INET6;
+ n++;
+#endif
+ } else {
+ logger(FCGI_ERROR, "Wrong IP address '%s' in listen.allowed_clients", cur);
}
- n++;
cur = end;
}
- allowed_clients[n] = INADDR_NONE;
+ allowed_clients[n].sa.sa_family = 0;
free(ip);
+ if (!n) {
+ logger(FCGI_ERROR, "There are no allowed addresses");
+ /* don't clear allowed_clients as it will create an "open for all" security issue */
+ }
}
}
return listen_socket;
}
-fcgi_request *fcgi_init_request(int listen_socket)
+void fcgi_set_allowed_clients(char *ip)
+{
+ char *cur, *end;
+ int n;
+
+ if (ip) {
+ ip = strdup(ip);
+ cur = ip;
+ n = 0;
+ while (*cur) {
+ if (*cur == ',') n++;
+ cur++;
+ }
+ if (allowed_clients) free(allowed_clients);
+ allowed_clients = malloc(sizeof(sa_t) * (n+2));
+ n = 0;
+ cur = ip;
+ while (cur) {
+ end = strchr(cur, ',');
+ if (end) {
+ *end = 0;
+ end++;
+ }
+ if (inet_pton(AF_INET, cur, &allowed_clients[n].sa_inet.sin_addr)>0) {
+ allowed_clients[n].sa.sa_family = AF_INET;
+ n++;
+#ifdef HAVE_IPV6
+ } else if (inet_pton(AF_INET6, cur, &allowed_clients[n].sa_inet6.sin6_addr)>0) {
+ allowed_clients[n].sa.sa_family = AF_INET6;
+ n++;
+#endif
+ } else {
+ logger(FCGI_ERROR, "Wrong IP address '%s' in listen.allowed_clients", cur);
+ }
+ cur = end;
+ }
+ allowed_clients[n].sa.sa_family = 0;
+ free(ip);
+ if (!n) {
+ logger(FCGI_ERROR, "There are no allowed addresses");
+ /* don't clear allowed_clients as it will create an "open for all" security issue */
+ }
+ }
+}
+
+fcgi_request *fcgi_init_request(fcgi_request *req, int listen_socket)
{
- fcgi_request *req = (fcgi_request*)calloc(1, sizeof(fcgi_request));
+ 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;
-
-#ifdef _WIN32
- req->tcp = !GetNamedPipeInfo((HANDLE)_get_osfhandle(req->listen_socket), NULL, NULL, NULL, NULL);
-#endif
#ifdef TCP_NODELAY
req->nodelay = 0;
#endif
- fcgi_hash_init(&req->env);
+ req->env = NULL;
+ req->has_env = 0;
- return req;
-}
+ */
+ req->out_pos = req->out_buf;
-void fcgi_destroy_request(fcgi_request *req)
-{
- fcgi_hash_destroy(&req->env);
- free(req);
+#ifdef _WIN32
+ req->tcp = !GetNamedPipeInfo((HANDLE)_get_osfhandle(req->listen_socket), NULL, NULL, NULL, NULL);
+#endif
+
+ return req;
}
static inline ssize_t safe_write(fcgi_request *req, const void *buf, size_t count)
req->in_len = 0;
req->out_hdr = NULL;
req->out_pos = req->out_buf;
+ fcgi_hash_init(&req->env);
req->has_env = 1;
if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
}
len = (int)(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) != (int)sizeof(fcgi_header)+len) {
+ if (safe_write(req, buf, sizeof(fcgi_header) + len) != (ssize_t)sizeof(fcgi_header)+len) {
req->keep = 0;
return 0;
}
return n;
}
-static inline void fcgi_close(fcgi_request *req, int force, int destroy)
+void fcgi_close(fcgi_request *req, int force, int destroy)
{
if (destroy && req->has_env) {
fcgi_hash_clean(&req->env);
+ fcgi_hash_destroy(&req->env);
req->has_env = 0;
}
req->nodelay = 0;
#endif
req->fd = -1;
+
+ if (req->hook.on_close) {
+ req->hook.on_close();
+ }
+ }
+}
+
+int fcgi_is_closed(fcgi_request *req)
+{
+ return (req->fd < 0);
+}
+
+static int fcgi_is_allowed() {
+ int i;
+
+ if (client_sa.sa.sa_family == AF_UNIX) {
+ return 1;
+ }
+ if (!allowed_clients) {
+ return 1;
}
+ if (client_sa.sa.sa_family == AF_INET) {
+ for (i = 0; allowed_clients[i].sa.sa_family ; i++) {
+ if (allowed_clients[i].sa.sa_family == AF_INET
+ && !memcmp(&client_sa.sa_inet.sin_addr, &allowed_clients[i].sa_inet.sin_addr, 4)) {
+ return 1;
+ }
+ }
+ }
+#ifdef HAVE_IPV6
+ if (client_sa.sa.sa_family == AF_INET6) {
+ for (i = 0; allowed_clients[i].sa.sa_family ; i++) {
+ if (allowed_clients[i].sa.sa_family == AF_INET6
+ && !memcmp(&client_sa.sa_inet6.sin6_addr, &allowed_clients[i].sa_inet6.sin6_addr, 12)) {
+ return 1;
+ }
+#ifdef IN6_IS_ADDR_V4MAPPED
+ if (allowed_clients[i].sa.sa_family == AF_INET
+ && IN6_IS_ADDR_V4MAPPED(&client_sa.sa_inet6.sin6_addr)
+ && !memcmp(((char *)&client_sa.sa_inet6.sin6_addr)+12, &allowed_clients[i].sa_inet.sin_addr, 4)) {
+ return 1;
+ }
+#endif
+ }
+ }
+#endif
+
+ logger(FCGI_ERROR, "Connection disallowed: IP address '%s' has been dropped.", fcgi_get_last_client_ip());
+ return 0;
}
int fcgi_accept_request(fcgi_request *req)
sa_t sa;
socklen_t len = sizeof(sa);
+ if (req->hook.on_accept) {
+ req->hook.on_accept();
+ }
+
FCGI_LOCK(req->listen_socket);
req->fd = accept(listen_socket, (struct sockaddr *)&sa, &len);
FCGI_UNLOCK(req->listen_socket);
- if (req->fd >= 0) {
- if (((struct sockaddr *)&sa)->sa_family == AF_INET) {
-#ifndef _WIN32
- req->tcp = 1;
-#endif
- if (allowed_clients) {
- int n = 0;
- int allowed = 0;
-
- while (allowed_clients[n] != INADDR_NONE) {
- if (allowed_clients[n] == sa.sa_inet.sin_addr.s_addr) {
- allowed = 1;
- break;
- }
- n++;
- }
- if (!allowed) {
- flog(FCGI_ERROR, "Connection from disallowed IP address '%s' is dropped.\n", inet_ntoa(sa.sa_inet.sin_addr));
- closesocket(req->fd);
- req->fd = -1;
- continue;
- }
- }
-#ifndef _WIN32
- } else {
- req->tcp = 0;
-#endif
- }
+
+ client_sa = sa;
+ if (req->fd >= 0 && !fcgi_is_allowed()) {
+ closesocket(req->fd);
+ req->fd = -1;
+ continue;
}
}
struct pollfd fds;
int ret;
+ if (req->hook.on_read) {
+ req->hook.on_read();
+ }
+
fds.fd = req->fd;
fds.events = POLLIN;
fds.revents = 0;
}
fcgi_close(req, 1, 0);
#else
+ if (req->hook.on_read) {
+ req->hook.on_read();
+ }
+
if (req->fd < FD_SETSIZE) {
struct timeval tv = {5,0};
fd_set set;
}
fcgi_close(req, 1, 0);
} else {
- flog(FCGI_ERROR, "Too many open file descriptors. FD_SETSIZE limit exceeded.");
+ logger(FCGI_ERROR, "Too many open file descriptors. FD_SETSIZE limit exceeded.");
fcgi_close(req, 1, 0);
}
#endif
pefree(Z_STR_P(zv), 1);
}
+const char *fcgi_get_last_client_ip()
+{
+ static char str[INET6_ADDRSTRLEN];
+
+ /* Ipv4 */
+ if (client_sa.sa.sa_family == AF_INET) {
+ return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet.sin_addr, str, INET6_ADDRSTRLEN);
+ }
+#ifdef HAVE_IPV6
+#ifdef IN6_IS_ADDR_V4MAPPED
+ /* Ipv4-Mapped-Ipv6 */
+ if (client_sa.sa.sa_family == AF_INET6
+ && IN6_IS_ADDR_V4MAPPED(&client_sa.sa_inet6.sin6_addr)) {
+ return inet_ntop(AF_INET, ((char *)&client_sa.sa_inet6.sin6_addr)+12, str, INET6_ADDRSTRLEN);
+ }
+#endif
+ /* Ipv6 */
+ if (client_sa.sa.sa_family == AF_INET6) {
+ return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet6.sin6_addr, str, INET6_ADDRSTRLEN);
+ }
+#endif
+ /* Unix socket */
+ return NULL;
+}
+
/*
* Local variables:
* tab-width: 4
FCGI_FILTER = 3
} fcgi_role;
-typedef enum _fcgi_code {
- FCGI_NOTICE,
- FCGI_WARNING,
- FCGI_ERROR,
-} fcgi_code;
+enum {
+ FCGI_DEBUG = 1,
+ FCGI_NOTICE = 2,
+ FCGI_WARNING = 3,
+ FCGI_ERROR = 4,
+ FCGI_ALERT = 5,
+};
typedef enum _fcgi_request_type {
FCGI_BEGIN_REQUEST = 1, /* [in] */
typedef void (*fcgi_apply_func)(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg);
-typedef void (*fcgi_logger)(int type, const char *format, ...);
+typedef void (*fcgi_logger)(int type, const char *fmt, ...);
+
+#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 {
+ unsigned int hash_value;
+ unsigned int var_len;
+ char *var;
+ unsigned int val_len;
+ char *val;
+ struct _fcgi_hash_bucket *next;
+ struct _fcgi_hash_bucket *list_next;
+} fcgi_hash_bucket;
+
+typedef struct _fcgi_hash_buckets {
+ unsigned int idx;
+ struct _fcgi_hash_buckets *next;
+ struct _fcgi_hash_bucket data[FCGI_HASH_TABLE_SIZE];
+} fcgi_hash_buckets;
+
+typedef struct _fcgi_data_seg {
+ char *pos;
+ char *end;
+ struct _fcgi_data_seg *next;
+ char data[1];
+} fcgi_data_seg;
+
+typedef struct _fcgi_hash {
+ fcgi_hash_bucket *hash_table[FCGI_HASH_TABLE_SIZE];
+ fcgi_hash_bucket *list;
+ fcgi_hash_buckets *buckets;
+ fcgi_data_seg *data;
+} fcgi_hash;
+
+typedef struct _fcgi_request fcgi_request;
+typedef struct _fcgi_req_hook fcgi_req_hook;
+
+struct _fcgi_req_hook {
+ void(*on_accept)();
+ void(*on_read)();
+ void(*on_close)();
+};
+
+struct _fcgi_request {
+ int listen_socket;
+ int tcp;
+ int fd;
+ int id;
+ int keep;
+#ifdef TCP_NODELAY
+ int nodelay;
+#endif
+ int closed;
+
+ fcgi_req_hook hook;
+
+ 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)];
-typedef struct _fcgi_request fcgi_request;
+ int has_env;
+ fcgi_hash env;
+};
int fcgi_init(void);
void fcgi_shutdown(void);
int fcgi_is_fastcgi(void);
+int fcgi_is_closed(fcgi_request *req);
+void fcgi_close(fcgi_request *req, int force, int destroy);
int fcgi_in_shutdown(void);
void fcgi_terminate(void);
int fcgi_listen(const char *path, int backlog);
-fcgi_request* fcgi_init_request(int listen_socket);
-void fcgi_destroy_request(fcgi_request *req);
+fcgi_request* fcgi_init_request(fcgi_request *request, int listen_socket);
+void fcgi_set_allowed_clients(char *ip);
int fcgi_accept_request(fcgi_request *req);
int fcgi_finish_request(fcgi_request *req, int force_close);
-void fcgi_set_logger(fcgi_logger logger);
+void fcgi_set_logger(fcgi_logger lg);
+const char *fcgi_get_last_client_ip();
+void fcgi_set_in_shutdown(int new_value);
char* fcgi_getenv(fcgi_request *req, const char* var, int var_len);
char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val);
/* }}} */
#define CGI_GETENV(name) \
- ((request) ? \
+ ((request->has_env) ? \
FCGI_GETENV(request, name) : \
getenv(name))
#define CGI_PUTENV(name, value) \
- ((request) ? \
+ ((request->has_env) ? \
FCGI_PUTENV(request, name, value) : \
_sapi_cgi_putenv(name, sizeof(name)-1, value))
int fastcgi;
char *bindpath = NULL;
int fcgi_fd = 0;
- fcgi_request *request = NULL;
+ fcgi_request request = {0};
int warmup_repeats = 0;
int repeats = 1;
int benchmark = 0;
php_import_environment_variables = cgi_php_import_environment_variables;
/* library is already initialized, now init our request */
- request = fcgi_init_request(fcgi_fd);
+ fcgi_init_request(&request, fcgi_fd);
#ifndef PHP_WIN32
- /* Pre-fork, if required */
- if (getenv("PHP_FCGI_CHILDREN")) {
- char * children_str = getenv("PHP_FCGI_CHILDREN");
- children = atoi(children_str);
- if (children < 0) {
- fprintf(stderr, "PHP_FCGI_CHILDREN is not valid\n");
- return FAILURE;
+ /* Pre-fork, if required */
+ if (getenv("PHP_FCGI_CHILDREN")) {
+ char * children_str = getenv("PHP_FCGI_CHILDREN");
+ children = atoi(children_str);
+ if (children < 0) {
+ fprintf(stderr, "PHP_FCGI_CHILDREN is not valid\n");
+ return FAILURE;
+ }
+ fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, children_str, strlen(children_str));
+ /* This is the number of concurrent requests, equals FCGI_MAX_CONNS */
+ fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, children_str, strlen(children_str));
+ } else {
+ fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, "1", sizeof("1")-1);
+ fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, "1", sizeof("1")-1);
}
- fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, children_str, strlen(children_str));
- /* This is the number of concurrent requests, equals FCGI_MAX_CONNS */
- fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, children_str, strlen(children_str));
- } else {
- fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, "1", sizeof("1")-1);
- fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, "1", sizeof("1")-1);
- }
- if (children) {
- int running = 0;
- pid_t pid;
+ if (children) {
+ int running = 0;
+ pid_t pid;
- /* Create a process group for ourself & children */
- setsid();
- pgroup = getpgrp();
+ /* Create a process group for ourself & children */
+ setsid();
+ pgroup = getpgrp();
#ifdef DEBUG_FASTCGI
- fprintf(stderr, "Process group %d\n", pgroup);
+ fprintf(stderr, "Process group %d\n", pgroup);
#endif
- /* Set up handler to kill children upon exit */
- act.sa_flags = 0;
- act.sa_handler = fastcgi_cleanup;
- if (sigaction(SIGTERM, &act, &old_term) ||
- sigaction(SIGINT, &act, &old_int) ||
- sigaction(SIGQUIT, &act, &old_quit)
- ) {
- perror("Can't set signals");
- exit(1);
- }
+ /* Set up handler to kill children upon exit */
+ act.sa_flags = 0;
+ act.sa_handler = fastcgi_cleanup;
+ if (sigaction(SIGTERM, &act, &old_term) ||
+ sigaction(SIGINT, &act, &old_int) ||
+ sigaction(SIGQUIT, &act, &old_quit)
+ ) {
+ perror("Can't set signals");
+ exit(1);
+ }
- if (fcgi_in_shutdown()) {
- goto parent_out;
- }
+ if (fcgi_in_shutdown()) {
+ goto parent_out;
+ }
- while (parent) {
- do {
+ while (parent) {
+ do {
#ifdef DEBUG_FASTCGI
- fprintf(stderr, "Forking, %d running\n", running);
-#endif
- pid = fork();
- switch (pid) {
- case 0:
- /* One of the children.
- * Make sure we don't go round the
- * fork loop any more
- */
- parent = 0;
+ fprintf(stderr, "Forking, %d running\n", running);
+#endif
+ pid = fork();
+ switch (pid) {
+ case 0:
+ /* One of the children.
+ * Make sure we don't go round the
+ * fork loop any more
+ */
+ parent = 0;
- /* don't catch our signals */
- sigaction(SIGTERM, &old_term, 0);
- sigaction(SIGQUIT, &old_quit, 0);
- sigaction(SIGINT, &old_int, 0);
- break;
- case -1:
- perror("php (pre-forking)");
- exit(1);
- break;
- default:
- /* Fine */
- running++;
- break;
- }
- } while (parent && (running < children));
+ /* don't catch our signals */
+ sigaction(SIGTERM, &old_term, 0);
+ sigaction(SIGQUIT, &old_quit, 0);
+ sigaction(SIGINT, &old_int, 0);
+ break;
+ case -1:
+ perror("php (pre-forking)");
+ exit(1);
+ break;
+ default:
+ /* Fine */
+ running++;
+ break;
+ }
+ } while (parent && (running < children));
- if (parent) {
+ if (parent) {
#ifdef DEBUG_FASTCGI
- fprintf(stderr, "Wait for kids, pid %d\n", getpid());
+ fprintf(stderr, "Wait for kids, pid %d\n", getpid());
#endif
- parent_waiting = 1;
- while (1) {
- if (wait(&status) >= 0) {
- running--;
- break;
- } else if (exit_signal) {
- break;
+ parent_waiting = 1;
+ while (1) {
+ if (wait(&status) >= 0) {
+ running--;
+ break;
+ } else if (exit_signal) {
+ break;
+ }
}
- }
- if (exit_signal) {
+ if (exit_signal) {
#if 0
- while (running > 0) {
- while (wait(&status) < 0) {
+ while (running > 0) {
+ while (wait(&status) < 0) {
+ }
+ running--;
}
- running--;
- }
#endif
- goto parent_out;
+ goto parent_out;
+ }
}
}
+ } else {
+ parent = 0;
}
- } else {
- parent = 0;
- }
#endif /* WIN32 */
}
break;
case 'h':
case '?':
- if (request) {
- fcgi_destroy_request(request);
- }
fcgi_shutdown();
no_headers = 1;
SG(headers_sent) = 1;
fcgi_impersonate();
}
#endif
- while (!fastcgi || fcgi_accept_request(request) >= 0) {
- SG(server_context) = fastcgi ? (void *) request : (void *) 1;
- init_request_info(request);
+ while (!fastcgi || fcgi_accept_request(&request) >= 0) {
+ SG(server_context) = fastcgi ? (void *)&request : (void *) 1;
+ init_request_info(&request);
if (!cgi && !fastcgi) {
while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
* get path_translated */
if (php_request_startup() == FAILURE) {
if (fastcgi) {
- fcgi_finish_request(request, 1);
+ fcgi_finish_request(&request, 1);
}
SG(server_context) = NULL;
php_module_shutdown();
/* only fastcgi will get here */
requests++;
if (max_requests && (requests == max_requests)) {
- fcgi_finish_request(request, 1);
+ fcgi_finish_request(&request, 1);
if (bindpath) {
free(bindpath);
}
}
/* end of fastcgi loop */
}
- if (request) {
- fcgi_destroy_request(request);
- }
fcgi_shutdown();
if (cgi_sapi_module.php_ini_path_override) {
PHP_FPM_CFLAGS="-I$abs_srcdir/sapi/fpm"
- PHP_FPM_FILES="fpm/fastcgi.c \
- fpm/fpm.c \
+ PHP_FPM_FILES="fpm/fpm.c \
fpm/fpm_children.c \
fpm/fpm_cleanup.c \
fpm/fpm_clock.c \
+++ /dev/null
-/*
- +----------------------------------------------------------------------+
- | PHP Version 7 |
- +----------------------------------------------------------------------+
- | Copyright (c) 1997-2015 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.01 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_01.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 |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Authors: Dmitry Stogov <dmitry@zend.com> |
- +----------------------------------------------------------------------+
-*/
-
-/* $Id: fastcgi.c 287777 2009-08-26 19:17:32Z pajoye $ */
-
-#include "php.h"
-#include "fastcgi.h"
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <errno.h>
-#include <limits.h>
-
-#include <php_config.h>
-#include "fpm.h"
-#include "fpm_request.h"
-#include "zlog.h"
-
-#ifdef _WIN32
-
-#include <windows.h>
-
- 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 <signal.h>
-
-# define closesocket(s) close(s)
-
-# if defined(HAVE_SYS_POLL_H) && defined(HAVE_POLL)
-# include <sys/poll.h>
-# endif
-# if defined(HAVE_SYS_SELECT_H)
-# include <sys/select.h>
-# endif
-
-#ifndef INADDR_NONE
-#define INADDR_NONE ((unsigned long) -1)
-#endif
-
-# 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;
- struct sockaddr_in6 sa_inet6;
-} sa_t;
-
-static HashTable fcgi_mgmt_vars;
-
-static int is_initialized = 0;
-static int in_shutdown = 0;
-static sa_t *allowed_clients = NULL;
-
-static sa_t client_sa;
-
-/* hash table */
-
-#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 {
- unsigned int hash_value;
- unsigned int var_len;
- char *var;
- unsigned int val_len;
- char *val;
- struct _fcgi_hash_bucket *next;
- struct _fcgi_hash_bucket *list_next;
-} fcgi_hash_bucket;
-
-typedef struct _fcgi_hash_buckets {
- unsigned int idx;
- struct _fcgi_hash_buckets *next;
- struct _fcgi_hash_bucket data[FCGI_HASH_TABLE_SIZE];
-} fcgi_hash_buckets;
-
-typedef struct _fcgi_data_seg {
- char *pos;
- char *end;
- struct _fcgi_data_seg *next;
- char data[1];
-} fcgi_data_seg;
-
-typedef struct _fcgi_hash {
- fcgi_hash_bucket *hash_table[FCGI_HASH_TABLE_SIZE];
- fcgi_hash_bucket *list;
- fcgi_hash_buckets *buckets;
- fcgi_data_seg *data;
-} 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)
-{
- 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);
- }
- p = p->list_next;
- }
-}
-
-struct _fcgi_request {
- int listen_socket;
-#ifdef _WIN32
- int tcp;
-#endif
- int fd;
- int id;
- int keep;
-#ifdef TCP_NODELAY
- int nodelay;
-#endif
- int closed;
-
- 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)];
-
- int has_env;
- fcgi_hash env;
-};
-
-#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 || 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);
- }
-}
-#endif
-
-int fcgi_in_shutdown(void)
-{
- return in_shutdown;
-}
-
-void fcgi_terminate(void)
-{
- in_shutdown = 1;
-}
-
-int fcgi_init(void)
-{
- if (!is_initialized) {
- zend_hash_init(&fcgi_mgmt_vars, 8, 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;
- }
-# endif
- {
- 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 1;
- }
-#else
- fcgi_setup_signals();
- return 1;
-#endif
- }
- return 1;
-}
-
-void fcgi_set_in_shutdown(int new_value)
-{
- in_shutdown = new_value;
-}
-
-void fcgi_shutdown(void)
-{
- if (is_initialized) {
- zend_hash_destroy(&fcgi_mgmt_vars);
- }
- if (allowed_clients) {
- free(allowed_clients);
- }
-}
-
-void fcgi_set_allowed_clients(char *ip)
-{
- char *cur, *end;
- int n;
-
- if (ip) {
- ip = strdup(ip);
- cur = ip;
- n = 0;
- while (*cur) {
- if (*cur == ',') n++;
- cur++;
- }
- if (allowed_clients) free(allowed_clients);
- allowed_clients = malloc(sizeof(sa_t) * (n+2));
- n = 0;
- cur = ip;
- while (cur) {
- end = strchr(cur, ',');
- if (end) {
- *end = 0;
- end++;
- }
- if (inet_pton(AF_INET, cur, &allowed_clients[n].sa_inet.sin_addr)>0) {
- allowed_clients[n].sa.sa_family = AF_INET;
- n++;
- } else if (inet_pton(AF_INET6, cur, &allowed_clients[n].sa_inet6.sin6_addr)>0) {
- allowed_clients[n].sa.sa_family = AF_INET6;
- n++;
- } else {
- zlog(ZLOG_ERROR, "Wrong IP address '%s' in listen.allowed_clients", cur);
- }
- cur = end;
- }
- allowed_clients[n].sa.sa_family = 0;
- free(ip);
- if (!n) {
- zlog(ZLOG_ERROR, "There are no allowed addresses for this pool");
- /* don't clear allowed_clients as it will create an "open for all" security issue */
- }
- }
-}
-
-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);
-#endif
-
-#ifdef TCP_NODELAY
- req->nodelay = 0;
-#endif
-
- 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();
- }
- }
-#else
- ret = write(req->fd, ((char*)buf)+n, count-n);
-#endif
- 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();
- }
- }
-#else
- ret = read(req->fd, ((char*)buf)+n, count-n);
-#endif
- 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)
-{
- int name_len = 0;
- int val_len = 0;
-
- 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 > (INT_MAX - val_len)) || /* would the addition overflow? */
- UNEXPECTED(name_len + val_len > end - p)) { /* would we exceed the buffer? */
- /* Malformated request */
- return 0;
- }
-
- /*
- * get the effective length of the name in case it's not a valid string
- * don't do this on the value because it can be binary data
- */
- if (UNEXPECTED(memchr(p, 0, name_len) != NULL)) {
- /* Malicious 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 void fcgi_free_var(zval *zv)
-{
- efree(Z_PTR_P(zv));
-}
-
-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;
-# else
- int on = 1;
-# endif
-
- setsockopt(req->fd, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));
- req->nodelay = 1;
- }
-#endif
- 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 ((value = zend_hash_str_find(&fcgi_mgmt_vars, q->var, q->var_len)) == NULL) {
- q = q->list_next;
- continue;
- }
- zlen = (unsigned int)Z_STRLEN_P(value);
- if ((p + 4 + 4 + q->var_len + zlen) >= (buf + sizeof(buf))) {
- break;
- }
- if (q->var_len < 0x80) {
- *p++ = q->var_len;
- } else {
- *p++ = ((q->var_len >> 24) & 0xff) | 0x80;
- *p++ = (q->var_len >> 16) & 0xff;
- *p++ = (q->var_len >> 8) & 0xff;
- *p++ = q->var_len & 0xff;
- }
- if (zlen < 0x80) {
- *p++ = zlen;
- } else {
- *p++ = ((zlen >> 24) & 0xff) | 0x80;
- *p++ = (zlen >> 16) & 0xff;
- *p++ = (zlen >> 8) & 0xff;
- *p++ = zlen & 0xff;
- }
- memcpy(p, q->var, q->var_len);
- p += q->var_len;
- memcpy(p, Z_STRVAL_P(value), zlen);
- p += zlen;
- q = q->list_next;
- }
- 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) != (int)sizeof(fcgi_header)+len) {
- req->keep = 0;
- 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[255];
-
- 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;
-}
-
-void fcgi_close(fcgi_request *req, int force, int destroy)
-{
- if (destroy && req->has_env) {
- fcgi_hash_clean(&req->env);
- req->has_env = 0;
- }
-
-#ifdef _WIN32
- if (is_impersonate && !req->tcp) {
- RevertToSelf();
- }
-#endif
-
- if ((force || !req->keep) && req->fd >= 0) {
-#ifdef _WIN32
- if (!req->tcp) {
- HANDLE pipe = (HANDLE)_get_osfhandle(req->fd);
-
- if (!force) {
- FlushFileBuffers(pipe);
- }
- DisconnectNamedPipe(pipe);
- } else {
- if (!force) {
- char buf[8];
-
- shutdown(req->fd, 1);
- while (recv(req->fd, buf, sizeof(buf), 0) > 0) {}
- }
- closesocket(req->fd);
- }
-#else
- if (!force) {
- char buf[8];
-
- shutdown(req->fd, 1);
- while (recv(req->fd, buf, sizeof(buf), 0) > 0) {}
- }
- close(req->fd);
-#endif
-#ifdef TCP_NODELAY
- req->nodelay = 0;
-#endif
- req->fd = -1;
- fpm_request_finished();
- }
-}
-
-int fcgi_is_closed(fcgi_request *req)
-{
- return (req->fd < 0);
-}
-
-static int fcgi_is_allowed() {
- int i;
-
- if (client_sa.sa.sa_family == AF_UNIX) {
- return 1;
- }
- if (!allowed_clients) {
- return 1;
- }
- if (client_sa.sa.sa_family == AF_INET) {
- for (i=0 ; allowed_clients[i].sa.sa_family ; i++) {
- if (allowed_clients[i].sa.sa_family == AF_INET
- && !memcmp(&client_sa.sa_inet.sin_addr, &allowed_clients[i].sa_inet.sin_addr, 4)) {
- return 1;
- }
- }
- }
- if (client_sa.sa.sa_family == AF_INET6) {
- for (i=0 ; allowed_clients[i].sa.sa_family ; i++) {
- if (allowed_clients[i].sa.sa_family == AF_INET6
- && !memcmp(&client_sa.sa_inet6.sin6_addr, &allowed_clients[i].sa_inet6.sin6_addr, 12)) {
- return 1;
- }
-#ifdef IN6_IS_ADDR_V4MAPPED
- if (allowed_clients[i].sa.sa_family == AF_INET
- && IN6_IS_ADDR_V4MAPPED(&client_sa.sa_inet6.sin6_addr)
- && !memcmp(((char *)&client_sa.sa_inet6.sin6_addr)+12, &allowed_clients[i].sa_inet.sin_addr, 4)) {
- return 1;
- }
-#endif
- }
- }
-
- zlog(ZLOG_ERROR, "Connection disallowed: IP address '%s' has been dropped.", fcgi_get_last_client_ip());
- return 0;
-}
-
-int fcgi_accept_request(fcgi_request *req)
-{
-#ifdef _WIN32
- HANDLE pipe;
- OVERLAPPED ov;
-#endif
-
- while (1) {
- if (req->fd < 0) {
- while (1) {
- if (in_shutdown) {
- return -1;
- }
-#ifdef _WIN32
- if (!req->tcp) {
- pipe = (HANDLE)_get_osfhandle(req->listen_socket);
- 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);
- req->fd = req->listen_socket;
- FCGI_UNLOCK(req->listen_socket);
- } else {
- SOCKET listen_socket = (SOCKET)_get_osfhandle(req->listen_socket);
-#else
- {
- int listen_socket = req->listen_socket;
-#endif
- sa_t sa;
- socklen_t len = sizeof(sa);
-
- fpm_request_accepting();
-
- FCGI_LOCK(req->listen_socket);
- req->fd = accept(listen_socket, (struct sockaddr *)&sa, &len);
- FCGI_UNLOCK(req->listen_socket);
-
- client_sa = sa;
- if (req->fd >= 0 && !fcgi_is_allowed()) {
- closesocket(req->fd);
- req->fd = -1;
- continue;
- }
- }
-
-#ifdef _WIN32
- if (req->fd < 0 && (in_shutdown || errno != EINTR)) {
-#else
- if (req->fd < 0 && (in_shutdown || (errno != EINTR && errno != ECONNABORTED))) {
-#endif
- return -1;
- }
-
-#ifdef _WIN32
- break;
-#else
- if (req->fd >= 0) {
-#if defined(HAVE_SYS_POLL_H) && defined(HAVE_POLL)
- struct pollfd fds;
- int ret;
-
- fpm_request_reading_headers();
-
- fds.fd = req->fd;
- fds.events = POLLIN;
- fds.revents = 0;
- do {
- errno = 0;
- ret = poll(&fds, 1, 5000);
- } while (ret < 0 && errno == EINTR);
- if (ret > 0 && (fds.revents & POLLIN)) {
- break;
- }
- fcgi_close(req, 1, 0);
-#else
- fpm_request_reading_headers();
-
- if (req->fd < FD_SETSIZE) {
- struct timeval tv = {5,0};
- fd_set set;
- int ret;
-
- FD_ZERO(&set);
- FD_SET(req->fd, &set);
- do {
- errno = 0;
- ret = select(req->fd + 1, &set, NULL, NULL, &tv) >= 0;
- } while (ret < 0 && errno == EINTR);
- if (ret > 0 && FD_ISSET(req->fd, &set)) {
- break;
- }
- fcgi_close(req, 1, 0);
- } else {
- zlog(ZLOG_ERROR, "Too many open file descriptors. FD_SETSIZE limit exceeded.");
- fcgi_close(req, 1, 0);
- }
-#endif
- }
-#endif
- }
- } else if (in_shutdown) {
- return -1;
- }
- if (fcgi_read_request(req)) {
-#ifdef _WIN32
- if (is_impersonate && !req->tcp) {
- pipe = (HANDLE)_get_osfhandle(req->fd);
- if (!ImpersonateNamedPipeClient(pipe)) {
- fcgi_close(req, 1, 1);
- continue;
- }
- }
-#endif
- 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, (fcgi_request_type)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;
- req->out_pos = req->out_buf;
- return 0;
- }
-
- req->out_pos = req->out_buf;
- return 1;
-}
-
-ssize_t 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);
- }
-
- /* Optimized version */
- limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
- if (!req->out_hdr) {
- limit -= sizeof(fcgi_header);
- if (limit < 0) limit = 0;
- }
-
- if (len < limit) {
- if (!req->out_hdr) {
- open_packet(req, type);
- }
- memcpy(req->out_pos, str, len);
- req->out_pos += len;
- } else if (len - limit < sizeof(req->out_buf) - sizeof(fcgi_header)) {
- if (!req->out_hdr) {
- open_packet(req, type);
- }
- if (limit > 0) {
- memcpy(req->out_pos, str, limit);
- req->out_pos += limit;
- }
- if (!fcgi_flush(req, 0)) {
- return -1;
- }
- if (len > limit) {
- open_packet(req, type);
- memcpy(req->out_pos, str + limit, len - limit);
- req->out_pos += len - limit;
- }
- } else {
- int pos = 0;
- int pad;
-
- close_packet(req);
- while ((len - pos) > 0xffff) {
- open_packet(req, type);
- fcgi_make_header(req->out_hdr, type, req->id, 0xfff8);
- req->out_hdr = NULL;
- if (!fcgi_flush(req, 0)) {
- return -1;
- }
- if (safe_write(req, str + pos, 0xfff8) != 0xfff8) {
- req->keep = 0;
- return -1;
- }
- pos += 0xfff8;
- }
-
- pad = (((len - pos) + 7) & ~7) - (len - pos);
- rest = pad ? 8 - pad : 0;
-
- open_packet(req, type);
- fcgi_make_header(req->out_hdr, type, req->id, (len - pos) - rest);
- req->out_hdr = NULL;
- if (!fcgi_flush(req, 0)) {
- return -1;
- }
- if (safe_write(req, str + pos, (len - pos) - rest) != (len - pos) - rest) {
- req->keep = 0;
- return -1;
- }
- if (pad) {
- open_packet(req, type);
- memcpy(req->out_pos, str + len - rest, rest);
- req->out_pos += rest;
- }
- }
-
- return len;
-}
-
-int fcgi_finish_request(fcgi_request *req, int force_close)
-{
- int ret = 1;
-
- if (req->fd >= 0) {
- if (!req->closed) {
- ret = fcgi_flush(req, 1);
- req->closed = 1;
- }
- fcgi_close(req, force_close, 1);
- }
- return ret;
-}
-
-char* fcgi_getenv(fcgi_request *req, const char* var, int var_len)
-{
- unsigned int val_len;
-
- if (!req) return NULL;
-
- return fcgi_hash_get(&req->env, FCGI_HASH_FUNC(var, var_len), (char*)var, var_len, &val_len);
-}
-
-char* fcgi_quick_getenv(fcgi_request *req, const char* var, int var_len, unsigned int hash_value)
-{
- unsigned int val_len;
-
- return fcgi_hash_get(&req->env, hash_value, (char*)var, var_len, &val_len);
-}
-
-char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val)
-{
- if (!req) return NULL;
- if (val == NULL) {
- fcgi_hash_del(&req->env, FCGI_HASH_FUNC(var, var_len), var, var_len);
- return NULL;
- } else {
- return fcgi_hash_set(&req->env, FCGI_HASH_FUNC(var, var_len), var, var_len, val, (unsigned int)strlen(val));
- }
-}
-
-char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val)
-{
- if (val == NULL) {
- fcgi_hash_del(&req->env, hash_value, var, var_len);
- return NULL;
- } else {
- return fcgi_hash_set(&req->env, hash_value, var, var_len, val, (unsigned int)strlen(val));
- }
-}
-
-void fcgi_loadenv(fcgi_request *req, fcgi_apply_func func, zval *array)
-{
- fcgi_hash_apply(&req->env, func, array);
-}
-
-void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len)
-{
- zval zvalue;
- ZVAL_NEW_STR(&zvalue, zend_string_init(value, value_len, 1));
- zend_hash_str_add(&fcgi_mgmt_vars, name, name_len, &zvalue);
-}
-
-void fcgi_free_mgmt_var_cb(zval *zv)
-{
- zend_string_free(Z_STR_P(zv));
-}
-
-const char *fcgi_get_last_client_ip() /* {{{ */
-{
- static char str[INET6_ADDRSTRLEN];
-
- /* Ipv4 */
- if (client_sa.sa.sa_family == AF_INET) {
- return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet.sin_addr, str, INET6_ADDRSTRLEN);
- }
-#ifdef IN6_IS_ADDR_V4MAPPED
- /* Ipv4-Mapped-Ipv6 */
- if (client_sa.sa.sa_family == AF_INET6
- && IN6_IS_ADDR_V4MAPPED(&client_sa.sa_inet6.sin6_addr)) {
- return inet_ntop(AF_INET, ((char *)&client_sa.sa_inet6.sin6_addr)+12, str, INET6_ADDRSTRLEN);
- }
-#endif
- /* Ipv6 */
- if (client_sa.sa.sa_family == AF_INET6) {
- return inet_ntop(client_sa.sa.sa_family, &client_sa.sa_inet6.sin6_addr, str, INET6_ADDRSTRLEN);
- }
- /* Unix socket */
- return NULL;
-}
-/* }}} */
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- +----------------------------------------------------------------------+
- | PHP Version 7 |
- +----------------------------------------------------------------------+
- | Copyright (c) 1997-2015 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.01 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_01.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 |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Authors: Dmitry Stogov <dmitry@zend.com> |
- +----------------------------------------------------------------------+
-*/
-
-/* $Id: fastcgi.h 272370 2008-12-31 11:15:49Z sebastian $ */
-
-/* FastCGI protocol */
-
-#define FCGI_VERSION_1 1
-
-#define FCGI_MAX_LENGTH 0xffff
-
-#define FCGI_KEEP_CONN 1
-
-/* this is near the perfect hash function for most useful FastCGI variables
- * which combines efficiency and minimal hash collisions
- */
-
-#define FCGI_HASH_FUNC(var, var_len) \
- (UNEXPECTED(var_len < 3) ? var_len : \
- (((unsigned int)var[3]) << 2) + \
- (((unsigned int)var[var_len-2]) << 4) + \
- (((unsigned int)var[var_len-1]) << 2) + \
- var_len)
-
-#define FCGI_GETENV(request, name) \
- fcgi_quick_getenv(request, name, sizeof(name)-1, FCGI_HASH_FUNC(name, sizeof(name)-1))
-
-#define FCGI_PUTENV(request, name, value) \
- fcgi_quick_putenv(request, name, sizeof(name)-1, FCGI_HASH_FUNC(name, sizeof(name)-1), value)
-
-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 void (*fcgi_apply_func)(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg);
-
-typedef struct _fcgi_request fcgi_request;
-
-int fcgi_init(void);
-void fcgi_shutdown(void);
-int fcgi_in_shutdown(void);
-void fcgi_terminate(void);
-fcgi_request* fcgi_init_request(int listen_socket);
-void fcgi_destroy_request(fcgi_request *req);
-int fcgi_accept_request(fcgi_request *req);
-int fcgi_finish_request(fcgi_request *req, int force_close);
-
-void fcgi_set_allowed_clients(char *);
-void fcgi_close(fcgi_request *req, int force, int destroy);
-int fcgi_is_closed(fcgi_request *req);
-
-char* fcgi_getenv(fcgi_request *req, const char* var, int var_len);
-char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val);
-char* fcgi_quick_getenv(fcgi_request *req, const char* var, int var_len, unsigned int hash_value);
-char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val);
-void fcgi_loadenv(fcgi_request *req, fcgi_apply_func load_func, zval *array);
-
-int fcgi_read(fcgi_request *req, char *str, int len);
-
-ssize_t fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len);
-int fcgi_flush(fcgi_request *req, int close);
-
-void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len);
-void fcgi_free_mgmt_var_cb(zval *ptr);
-
-const char *fcgi_get_last_client_ip();
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
#define TRANSLATE_SLASHES(path)
#endif
-static int print_module_info(zval *zv)
+static int print_module_info(zval *zv) /* {{{ */
{
zend_module_entry *module = Z_PTR_P(zv);
php_printf("%s\n", module->name);
return 0;
}
+/* }}} */
-static int module_name_cmp(const void *a, const void *b)
+static int module_name_cmp(const void *a, const void *b) /* {{{ */
{
Bucket *f = (Bucket *) a;
Bucket *s = (Bucket *) b;
return strcasecmp( ((zend_module_entry *) Z_PTR(f->val))->name,
((zend_module_entry *) Z_PTR(s->val))->name);
}
+/* }}} */
-static void print_modules(void)
+static void print_modules(void) /* {{{ */
{
HashTable sorted_registry;
zend_hash_apply(&sorted_registry, print_module_info);
zend_hash_destroy(&sorted_registry);
}
+/* }}} */
-static int print_extension_info(zend_extension *ext, void *arg)
+static int print_extension_info(zend_extension *ext, void *arg) /* {{{ */
{
php_printf("%s\n", ext->name);
return 0;
}
+/* }}} */
-static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s)
+static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s) /* {{{ */
{
return strcmp( ((zend_extension *)(*f)->data)->name,
((zend_extension *)(*s)->data)->name);
}
+/* }}} */
-static void print_extensions(void)
+static void print_extensions(void) /* {{{ */
{
zend_llist sorted_exts;
zend_llist_apply_with_argument(&sorted_exts, (llist_apply_with_arg_func_t) print_extension_info, NULL);
zend_llist_destroy(&sorted_exts);
}
+/* }}} */
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
-static inline size_t sapi_cgibin_single_write(const char *str, uint str_length)
+static inline size_t sapi_cgibin_single_write(const char *str, uint str_length) /* {{{ */
{
ssize_t ret;
return fwrite(str, 1, MIN(str_length, 16384), stdout);
#endif
}
+/* }}} */
-static size_t sapi_cgibin_ub_write(const char *str, size_t str_length)
+static size_t sapi_cgibin_ub_write(const char *str, size_t str_length) /* {{{ */
{
const char *ptr = str;
uint remaining = str_length;
return str_length;
}
+/* }}} */
-
-static void sapi_cgibin_flush(void *server_context)
+static void sapi_cgibin_flush(void *server_context) /* {{{ */
{
/* fpm has started, let use fcgi instead of stdout */
if (fpm_is_running) {
php_handle_aborted_connection();
}
}
+/* }}} */
#define SAPI_CGI_MAX_HEADER_LENGTH 1024
-static int sapi_cgi_send_headers(sapi_headers_struct *sapi_headers)
+static int sapi_cgi_send_headers(sapi_headers_struct *sapi_headers) /* {{{ */
{
char buf[SAPI_CGI_MAX_HEADER_LENGTH];
sapi_header_struct *h;
return SAPI_HEADER_SENT_SUCCESSFULLY;
}
+/* }}} */
#ifndef STDIN_FILENO
# define STDIN_FILENO 0
#endif
-static size_t sapi_cgi_read_post(char *buffer, size_t count_bytes)
+static void fpm_fcgi_log(int type, const char *fmt, ...) /* {{{ */
+{
+ va_list args;
+ va_start(args, fmt);
+ vzlog("", 0, type, fmt, args);
+ va_end(args);
+}
+/* }}} */
+
+static size_t sapi_cgi_read_post(char *buffer, size_t count_bytes) /* {{{ */
{
uint read_bytes = 0;
int tmp_read_bytes;
}
return read_bytes;
}
+/* }}} */
-static char *sapi_cgibin_getenv(char *name, size_t name_len)
+static char *sapi_cgibin_getenv(char *name, size_t name_len) /* {{{ */
{
/* if fpm has started, use fcgi env */
if (fpm_is_running) {
/* if fpm has not started yet, use std env */
return getenv(name);
}
+/* }}} */
-static char *_sapi_cgibin_putenv(char *name, char *value)
+static char *_sapi_cgibin_putenv(char *name, char *value) /* {{{ */
{
int name_len;
fcgi_request *request = (fcgi_request*) SG(server_context);
return fcgi_putenv(request, name, name_len, value);
}
+/* }}} */
-static char *sapi_cgi_read_cookies(void)
+static char *sapi_cgi_read_cookies(void) /* {{{ */
{
fcgi_request *request = (fcgi_request*) SG(server_context);
return FCGI_GETENV(request, "HTTP_COOKIE");
}
+/* }}} */
-static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg)
+static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg) /* {{{ */
{
zval *array_ptr = (zval*)arg;
int filter_arg = (Z_ARR_P(array_ptr) == Z_ARR(PG(http_globals)[TRACK_VARS_ENV]))?PARSE_ENV:PARSE_SERVER;
php_register_variable_safe(var, val, new_val_len, array_ptr);
}
}
+/* }}} */
-void cgi_php_import_environment_variables(zval *array_ptr)
+void cgi_php_import_environment_variables(zval *array_ptr) /* {{{ */
{
fcgi_request *request;
- zend_string *var;
- char *val;
- int filter_arg;
if (Z_TYPE(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&
Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_ENV]) &&
request = (fcgi_request*) SG(server_context);
fcgi_loadenv(request, cgi_php_load_env_var, array_ptr);
}
+/* }}} */
-static void sapi_cgi_register_variables(zval *track_vars_array)
+static void sapi_cgi_register_variables(zval *track_vars_array) /* {{{ */
{
fcgi_request *request = (fcgi_request*) SG(server_context);
size_t php_self_len;
}
}
}
+/* }}} */
/* {{{ sapi_cgi_log_fastcgi
*
}
/* }}} */
-static int sapi_cgi_activate(void)
+static int sapi_cgi_activate(void) /* {{{ */
{
fcgi_request *request = (fcgi_request*) SG(server_context);
char *path, *doc_root, *server_name;
return SUCCESS;
}
+/* }}} */
-static int sapi_cgi_deactivate(void)
+static int sapi_cgi_deactivate(void) /* {{{ */
{
/* flush only when SAPI was started. The reasons are:
1. SAPI Deactivate is called from two places: module init and request shutdown
}
return SUCCESS;
}
+/* }}} */
-static int php_cgi_startup(sapi_module_struct *sapi_module)
+static int php_cgi_startup(sapi_module_struct *sapi_module) /* {{{ */
{
if (php_module_startup(sapi_module, &cgi_module_entry, 1) == FAILURE) {
return FAILURE;
}
return SUCCESS;
}
+/* }}} */
/* {{{ sapi_module_struct cgi_sapi_module
*/
}
/* }}} */
+static void fpm_init_request(fcgi_request *req, int listen_fd) /* {{{ */ {
+ fcgi_init_request(req, listen_fd);
+ req->hook.on_accept = fpm_request_accepting;
+ req->hook.on_read = fpm_request_reading_headers;
+ req->hook.on_close = fpm_request_finished;
+}
+/* }}} */
+
static void fastcgi_ini_parser(zval *arg1, zval *arg2, zval *arg3, int callback_type, void *arg) /* {{{ */
{
int *mode = (int *)arg;
int max_requests = 500;
int requests = 0;
int fcgi_fd = 0;
- fcgi_request *request;
+ fcgi_request request;
char *fpm_config = NULL;
char *fpm_prefix = NULL;
char *fpm_pid = NULL;
cgi_sapi_module.php_ini_path_override = NULL;
cgi_sapi_module.php_ini_ignore_cwd = 1;
+ fcgi_set_logger(fpm_fcgi_log);
fcgi_init();
#ifdef PHP_WIN32
php_import_environment_variables = cgi_php_import_environment_variables;
/* library is already initialized, now init our request */
- request = fcgi_init_request(fcgi_fd);
+ fpm_init_request(&request, fcgi_fd);
zend_first_try {
- while (fcgi_accept_request(request) >= 0) {
+ while (fcgi_accept_request(&request) >= 0) {
request_body_fd = -1;
- SG(server_context) = (void *) request;
+ SG(server_context) = (void *) &request;
init_request_info();
char *primary_script = NULL;
/* request startup only after we've done all we can to
* get path_translated */
if (php_request_startup() == FAILURE) {
- fcgi_finish_request(request, 1);
+ fcgi_finish_request(&request, 1);
SG(server_context) = NULL;
php_module_shutdown();
return FPM_EXIT_SOFTWARE;
requests++;
if (max_requests && (requests == max_requests)) {
- fcgi_finish_request(request, 1);
+ fcgi_finish_request(&request, 1);
break;
}
/* end of fastcgi loop */
}
- fcgi_destroy_request(request);
fcgi_shutdown();
if (cgi_sapi_module.php_ini_path_override) {
}
/* }}} */
-void zlog_ex(const char *function, int line, int flags, const char *fmt, ...) /* {{{ */
+void vzlog(const char *function, int line, int flags, const char *fmt, va_list args) /* {{{ */
{
struct timeval tv;
char buf[MAX_LINE_LENGTH];
const size_t buf_size = MAX_LINE_LENGTH;
- va_list args;
size_t len = 0;
int truncated = 0;
int saved_errno;
if (external_logger) {
- va_start(args, fmt);
len = vsnprintf(buf, buf_size, fmt, args);
- va_end(args);
if (len >= buf_size) {
memcpy(buf + buf_size - sizeof("..."), "...", sizeof("...") - 1);
len = buf_size - 1;
}
if (!truncated) {
- va_start(args, fmt);
len += vsnprintf(buf + len, buf_size - len, fmt, args);
- va_end(args);
if (len >= buf_size) {
truncated = 1;
}
}
/* }}} */
+void zlog_ex(const char *function, int line, int flags, const char *fmt, ...) /* {{{ */ {
+ va_list args;
+ va_start(args, fmt);
+ vzlog(function, line, flags, fmt, args);
+ va_end(args);
+}
+/* }}} */
#ifndef ZLOG_H
#define ZLOG_H 1
+#include <stdarg.h>
+
#define zlog(flags,...) zlog_ex(__func__, __LINE__, flags, __VA_ARGS__)
struct timeval;
size_t zlog_print_time(struct timeval *tv, char *timebuf, size_t timebuf_len);
+void vzlog(const char *function, int line, int flags, const char *fmt, va_list args);
void zlog_ex(const char *function, int line, int flags, const char *fmt, ...)
__attribute__ ((format(printf,4,5)));
extern const int syslog_priorities[];
#endif
+/* keep this same as FCGI_ERROR */
enum {
ZLOG_DEBUG = 1,
ZLOG_NOTICE = 2,
projects / php / commitdiff