PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - sapi/cgi - fastcgi.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 31 508 6.1 %
Date: 2014-07-23 Functions: 5 27 18.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Dmitry Stogov <dmitry@zend.com>                             |
      16             :    +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "php.h"
      22             : #include "fastcgi.h"
      23             : 
      24             : #include <string.h>
      25             : #include <stdlib.h>
      26             : #include <stdio.h>
      27             : #include <stdarg.h>
      28             : #include <errno.h>
      29             : 
      30             : #ifdef _WIN32
      31             : 
      32             : #include <windows.h>
      33             : 
      34             :         typedef unsigned int in_addr_t;
      35             : 
      36             :         struct sockaddr_un {
      37             :                 short   sun_family;
      38             :                 char    sun_path[MAXPATHLEN];
      39             :         };
      40             : 
      41             :         static HANDLE fcgi_accept_mutex = INVALID_HANDLE_VALUE;
      42             :         static int is_impersonate = 0;
      43             : 
      44             : #define FCGI_LOCK(fd) \
      45             :         if (fcgi_accept_mutex != INVALID_HANDLE_VALUE) { \
      46             :                 DWORD ret; \
      47             :                 while ((ret = WaitForSingleObject(fcgi_accept_mutex, 1000)) == WAIT_TIMEOUT) { \
      48             :                         if (in_shutdown) return -1; \
      49             :                 } \
      50             :                 if (ret == WAIT_FAILED) { \
      51             :                         fprintf(stderr, "WaitForSingleObject() failed\n"); \
      52             :                         return -1; \
      53             :                 } \
      54             :         }
      55             : 
      56             : #define FCGI_UNLOCK(fd) \
      57             :         if (fcgi_accept_mutex != INVALID_HANDLE_VALUE) { \
      58             :                 ReleaseMutex(fcgi_accept_mutex); \
      59             :         }
      60             : 
      61             : #else
      62             : 
      63             : # include <sys/types.h>
      64             : # include <sys/stat.h>
      65             : # include <unistd.h>
      66             : # include <fcntl.h>
      67             : # include <sys/socket.h>
      68             : # include <sys/un.h>
      69             : # include <netinet/in.h>
      70             : # include <arpa/inet.h>
      71             : # include <netdb.h>
      72             : # include <signal.h>
      73             : 
      74             : # define closesocket(s) close(s)
      75             : 
      76             : # if defined(HAVE_SYS_POLL_H) && defined(HAVE_POLL)
      77             : #  include <sys/poll.h>
      78             : # endif
      79             : # if defined(HAVE_SYS_SELECT_H)
      80             : #  include <sys/select.h>
      81             : # endif
      82             : 
      83             : #ifndef INADDR_NONE
      84             : #define INADDR_NONE ((unsigned long) -1)
      85             : #endif
      86             : 
      87             : # ifndef HAVE_SOCKLEN_T
      88             :         typedef unsigned int socklen_t;
      89             : # endif
      90             : 
      91             : # ifdef USE_LOCKING
      92             : #  define FCGI_LOCK(fd)                                                         \
      93             :         do {                                                                                    \
      94             :                 struct flock lock;                                                      \
      95             :                 lock.l_type = F_WRLCK;                                          \
      96             :                 lock.l_start = 0;                                                       \
      97             :                 lock.l_whence = SEEK_SET;                                       \
      98             :                 lock.l_len = 0;                                                         \
      99             :                 if (fcntl(fd, F_SETLKW, &lock) != -1) {             \
     100             :                         break;                                                                  \
     101             :                 } else if (errno != EINTR || in_shutdown) {     \
     102             :                         return -1;                                                              \
     103             :                 }                                                                                       \
     104             :         } while (1)
     105             : 
     106             : #  define FCGI_UNLOCK(fd)                                                       \
     107             :         do {                                                                                    \
     108             :                 int orig_errno = errno;                                         \
     109             :                 while (1) {                                                                     \
     110             :                         struct flock lock;                                              \
     111             :                         lock.l_type = F_UNLCK;                                  \
     112             :                         lock.l_start = 0;                                               \
     113             :                         lock.l_whence = SEEK_SET;                               \
     114             :                         lock.l_len = 0;                                                 \
     115             :                         if (fcntl(fd, F_SETLK, &lock) != -1) {      \
     116             :                                 break;                                                          \
     117             :                         } else if (errno != EINTR) {                    \
     118             :                                 return -1;                                                      \
     119             :                         }                                                                               \
     120             :                 }                                                                                       \
     121             :                 errno = orig_errno;                                                     \
     122             :         } while (0)
     123             : # else
     124             : #  define FCGI_LOCK(fd)
     125             : #  define FCGI_UNLOCK(fd)
     126             : # endif
     127             : 
     128             : #endif
     129             : 
     130             : typedef union _sa_t {
     131             :         struct sockaddr     sa;
     132             :         struct sockaddr_un  sa_unix;
     133             :         struct sockaddr_in  sa_inet;
     134             : } sa_t;
     135             : 
     136             : static HashTable fcgi_mgmt_vars;
     137             : 
     138             : static int is_initialized = 0;
     139             : static int is_fastcgi = 0;
     140             : static int in_shutdown = 0;
     141             : static in_addr_t *allowed_clients = NULL;
     142             : 
     143             : #ifdef _WIN32
     144             : 
     145             : static DWORD WINAPI fcgi_shutdown_thread(LPVOID arg)
     146             : {
     147             :         HANDLE shutdown_event = (HANDLE) arg;
     148             :         WaitForSingleObject(shutdown_event, INFINITE);
     149             :         in_shutdown = 1;
     150             :         return 0;
     151             : }
     152             : 
     153             : #else
     154             : 
     155           0 : static void fcgi_signal_handler(int signo)
     156             : {
     157           0 :         if (signo == SIGUSR1 || signo == SIGTERM) {
     158           0 :                 in_shutdown = 1;
     159             :         }
     160           0 : }
     161             : 
     162           0 : static void fcgi_setup_signals(void)
     163             : {
     164             :         struct sigaction new_sa, old_sa;
     165             : 
     166           0 :         sigemptyset(&new_sa.sa_mask);
     167           0 :         new_sa.sa_flags = 0;
     168           0 :         new_sa.sa_handler = fcgi_signal_handler;
     169           0 :         sigaction(SIGUSR1, &new_sa, NULL);
     170           0 :         sigaction(SIGTERM, &new_sa, NULL);
     171           0 :         sigaction(SIGPIPE, NULL, &old_sa);
     172           0 :         if (old_sa.sa_handler == SIG_DFL) {
     173           0 :                 sigaction(SIGPIPE, &new_sa, NULL);
     174             :         }
     175           0 : }
     176             : #endif
     177             : 
     178           0 : int fcgi_in_shutdown(void)
     179             : {
     180           0 :         return in_shutdown;
     181             : }
     182             : 
     183         342 : int fcgi_init(void)
     184             : {
     185         342 :         if (!is_initialized) {
     186             : #ifndef _WIN32
     187             :                 sa_t sa;
     188         342 :                 socklen_t len = sizeof(sa);
     189             : #endif
     190         342 :                 zend_hash_init(&fcgi_mgmt_vars, 0, NULL, fcgi_free_mgmt_var_cb, 1);
     191         342 :                 fcgi_set_mgmt_var("FCGI_MPXS_CONNS", sizeof("FCGI_MPXS_CONNS")-1, "0", sizeof("0")-1);
     192             : 
     193         342 :                 is_initialized = 1;
     194             : #ifdef _WIN32
     195             : # if 0
     196             :                 /* TODO: Support for TCP sockets */
     197             :                 WSADATA wsaData;
     198             : 
     199             :                 if (WSAStartup(MAKEWORD(2,0), &wsaData)) {
     200             :                         fprintf(stderr, "Error starting Windows Sockets.  Error: %d", WSAGetLastError());
     201             :                         return 0;
     202             :                 }
     203             : # endif
     204             :                 if ((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&
     205             :                     (GetStdHandle(STD_ERROR_HANDLE)  == INVALID_HANDLE_VALUE) &&
     206             :                     (GetStdHandle(STD_INPUT_HANDLE)  != INVALID_HANDLE_VALUE)) {
     207             :                         char *str;
     208             :                         DWORD pipe_mode = PIPE_READMODE_BYTE | PIPE_WAIT;
     209             :                         HANDLE pipe = GetStdHandle(STD_INPUT_HANDLE);
     210             : 
     211             :                         SetNamedPipeHandleState(pipe, &pipe_mode, NULL, NULL);
     212             : 
     213             :                         str = getenv("_FCGI_SHUTDOWN_EVENT_");
     214             :                         if (str != NULL) {
     215             :                                 HANDLE shutdown_event = (HANDLE) atoi(str);
     216             :                                 if (!CreateThread(NULL, 0, fcgi_shutdown_thread,
     217             :                                                   shutdown_event, 0, NULL)) {
     218             :                                         return -1;
     219             :                                 }
     220             :                         }
     221             :                         str = getenv("_FCGI_MUTEX_");
     222             :                         if (str != NULL) {
     223             :                                 fcgi_accept_mutex = (HANDLE) atoi(str);
     224             :                         }
     225             :                         return is_fastcgi = 1;
     226             :                 } else {
     227             :                         return is_fastcgi = 0;
     228             :                 }
     229             : #else
     230         342 :                 errno = 0;
     231         342 :                 if (getpeername(0, (struct sockaddr *)&sa, &len) != 0 && errno == ENOTCONN) {
     232           0 :                         fcgi_setup_signals();
     233           0 :                         return is_fastcgi = 1;
     234             :                 } else {
     235         342 :                         return is_fastcgi = 0;
     236             :                 }
     237             : #endif
     238             :         }
     239           0 :         return is_fastcgi;
     240             : }
     241             : 
     242             : 
     243       10375 : int fcgi_is_fastcgi(void)
     244             : {
     245       10375 :         if (!is_initialized) {
     246         342 :                 return fcgi_init();
     247             :         } else {
     248       10033 :                 return is_fastcgi;
     249             :         }
     250             : }
     251             : 
     252         332 : void fcgi_shutdown(void)
     253             : {
     254         332 :         if (is_initialized) {
     255         332 :                 zend_hash_destroy(&fcgi_mgmt_vars);
     256             :         }
     257         332 :         is_fastcgi = 0;
     258         332 :         if (allowed_clients) {
     259           0 :                 free(allowed_clients);
     260             :         }
     261         332 : }
     262             : 
     263             : #ifdef _WIN32
     264             : /* Do some black magic with the NT security API.
     265             :  * We prepare a DACL (Discretionary Access Control List) so that
     266             :  * we, the creator, are allowed all access, while "Everyone Else"
     267             :  * is only allowed to read and write to the pipe.
     268             :  * This avoids security issues on shared hosts where a luser messes
     269             :  * with the lower-level pipe settings and screws up the FastCGI service.
     270             :  */
     271             : static PACL prepare_named_pipe_acl(PSECURITY_DESCRIPTOR sd, LPSECURITY_ATTRIBUTES sa)
     272             : {
     273             :         DWORD req_acl_size;
     274             :         char everyone_buf[32], owner_buf[32];
     275             :         PSID sid_everyone, sid_owner;
     276             :         SID_IDENTIFIER_AUTHORITY
     277             :                 siaWorld = SECURITY_WORLD_SID_AUTHORITY,
     278             :                 siaCreator = SECURITY_CREATOR_SID_AUTHORITY;
     279             :         PACL acl;
     280             : 
     281             :         sid_everyone = (PSID)&everyone_buf;
     282             :         sid_owner = (PSID)&owner_buf;
     283             : 
     284             :         req_acl_size = sizeof(ACL) +
     285             :                 (2 * ((sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) + GetSidLengthRequired(1)));
     286             : 
     287             :         acl = malloc(req_acl_size);
     288             : 
     289             :         if (acl == NULL) {
     290             :                 return NULL;
     291             :         }
     292             : 
     293             :         if (!InitializeSid(sid_everyone, &siaWorld, 1)) {
     294             :                 goto out_fail;
     295             :         }
     296             :         *GetSidSubAuthority(sid_everyone, 0) = SECURITY_WORLD_RID;
     297             : 
     298             :         if (!InitializeSid(sid_owner, &siaCreator, 1)) {
     299             :                 goto out_fail;
     300             :         }
     301             :         *GetSidSubAuthority(sid_owner, 0) = SECURITY_CREATOR_OWNER_RID;
     302             : 
     303             :         if (!InitializeAcl(acl, req_acl_size, ACL_REVISION)) {
     304             :                 goto out_fail;
     305             :         }
     306             : 
     307             :         if (!AddAccessAllowedAce(acl, ACL_REVISION, FILE_GENERIC_READ | FILE_GENERIC_WRITE, sid_everyone)) {
     308             :                 goto out_fail;
     309             :         }
     310             : 
     311             :         if (!AddAccessAllowedAce(acl, ACL_REVISION, FILE_ALL_ACCESS, sid_owner)) {
     312             :                 goto out_fail;
     313             :         }
     314             : 
     315             :         if (!InitializeSecurityDescriptor(sd, SECURITY_DESCRIPTOR_REVISION)) {
     316             :                 goto out_fail;
     317             :         }
     318             : 
     319             :         if (!SetSecurityDescriptorDacl(sd, TRUE, acl, FALSE)) {
     320             :                 goto out_fail;
     321             :         }
     322             : 
     323             :         sa->lpSecurityDescriptor = sd;
     324             : 
     325             :         return acl;
     326             : 
     327             : out_fail:
     328             :         free(acl);
     329             :         return NULL;
     330             : }
     331             : #endif
     332             : 
     333           0 : static int is_port_number(const char *bindpath)
     334             : {
     335           0 :         while (*bindpath) {
     336           0 :                 if (*bindpath < '0' || *bindpath > '9') {
     337           0 :                         return 0;
     338             :                 }
     339           0 :                 bindpath++;
     340             :         }
     341           0 :         return 1;
     342             : }
     343             : 
     344           0 : int fcgi_listen(const char *path, int backlog)
     345             : {
     346             :         char     *s;
     347           0 :         int       tcp = 0;
     348             :         char      host[MAXPATHLEN];
     349           0 :         short     port = 0;
     350             :         int       listen_socket;
     351             :         sa_t      sa;
     352             :         socklen_t sock_len;
     353             : #ifdef SO_REUSEADDR
     354             : # ifdef _WIN32
     355             :         BOOL reuse = 1;
     356             : # else
     357           0 :         int reuse = 1;
     358             : # endif
     359             : #endif
     360             : 
     361           0 :         if ((s = strchr(path, ':'))) {
     362           0 :                 port = atoi(s+1);
     363           0 :                 if (port != 0 && (s-path) < MAXPATHLEN) {
     364           0 :                         strncpy(host, path, s-path);
     365           0 :                         host[s-path] = '\0';
     366           0 :                         tcp = 1;
     367             :                 }
     368           0 :         } else if (is_port_number(path)) {
     369           0 :                 port = atoi(path);
     370           0 :                 if (port != 0) {
     371           0 :                         host[0] = '\0';
     372           0 :                         tcp = 1;
     373             :                 }
     374             :         }
     375             : 
     376             :         /* Prepare socket address */
     377           0 :         if (tcp) {
     378           0 :                 memset(&sa.sa_inet, 0, sizeof(sa.sa_inet));
     379           0 :                 sa.sa_inet.sin_family = AF_INET;
     380           0 :                 sa.sa_inet.sin_port = htons(port);
     381           0 :                 sock_len = sizeof(sa.sa_inet);
     382             : 
     383           0 :                 if (!*host || !strncmp(host, "*", sizeof("*")-1)) {
     384           0 :                         sa.sa_inet.sin_addr.s_addr = htonl(INADDR_ANY);
     385             :                 } else {
     386           0 :                         sa.sa_inet.sin_addr.s_addr = inet_addr(host);
     387           0 :                         if (sa.sa_inet.sin_addr.s_addr == INADDR_NONE) {
     388             :                                 struct hostent *hep;
     389             : 
     390           0 :                                 hep = gethostbyname(host);
     391           0 :                                 if (!hep || hep->h_addrtype != AF_INET || !hep->h_addr_list[0]) {
     392           0 :                                         fprintf(stderr, "Cannot resolve host name '%s'!\n", host);
     393           0 :                                         return -1;
     394           0 :                                 } else if (hep->h_addr_list[1]) {
     395           0 :                                         fprintf(stderr, "Host '%s' has multiple addresses. You must choose one explicitly!\n", host);
     396           0 :                                         return -1;
     397             :                                 }
     398           0 :                                 sa.sa_inet.sin_addr.s_addr = ((struct in_addr*)hep->h_addr_list[0])->s_addr;
     399             :                         }
     400             :                 }
     401             :         } else {
     402             : #ifdef _WIN32
     403             :                 SECURITY_DESCRIPTOR  sd;
     404             :                 SECURITY_ATTRIBUTES  saw;
     405             :                 PACL                 acl;
     406             :                 HANDLE namedPipe;
     407             : 
     408             :                 memset(&sa, 0, sizeof(saw));
     409             :                 saw.nLength = sizeof(saw);
     410             :                 saw.bInheritHandle = FALSE;
     411             :                 acl = prepare_named_pipe_acl(&sd, &saw);
     412             : 
     413             :                 namedPipe = CreateNamedPipe(path,
     414             :                         PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
     415             :                         PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_READMODE_BYTE,
     416             :                         PIPE_UNLIMITED_INSTANCES,
     417             :                         8192, 8192, 0, &saw);
     418             :                 if (namedPipe == INVALID_HANDLE_VALUE) {
     419             :                         return -1;
     420             :                 }               
     421             :                 listen_socket = _open_osfhandle((long)namedPipe, 0);
     422             :                 if (!is_initialized) {
     423             :                         fcgi_init();
     424             :                 }
     425             :                 is_fastcgi = 1;
     426             :                 return listen_socket;
     427             : 
     428             : #else
     429           0 :                 int path_len = strlen(path);
     430             : 
     431           0 :                 if (path_len >= sizeof(sa.sa_unix.sun_path)) {
     432           0 :                         fprintf(stderr, "Listening socket's path name is too long.\n");
     433           0 :                         return -1;
     434             :                 }
     435             : 
     436           0 :                 memset(&sa.sa_unix, 0, sizeof(sa.sa_unix));
     437           0 :                 sa.sa_unix.sun_family = AF_UNIX;
     438           0 :                 memcpy(sa.sa_unix.sun_path, path, path_len + 1);
     439           0 :                 sock_len = (size_t)(((struct sockaddr_un *)0)->sun_path)     + path_len;
     440             : #ifdef HAVE_SOCKADDR_UN_SUN_LEN
     441             :                 sa.sa_unix.sun_len = sock_len;
     442             : #endif
     443           0 :                 unlink(path);
     444             : #endif
     445             :         }
     446             : 
     447             :         /* Create, bind socket and start listen on it */
     448           0 :         if ((listen_socket = socket(sa.sa.sa_family, SOCK_STREAM, 0)) < 0 ||
     449             : #ifdef SO_REUSEADDR
     450           0 :             setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse)) < 0 ||
     451             : #endif
     452           0 :             bind(listen_socket, (struct sockaddr *) &sa, sock_len) < 0 ||
     453           0 :             listen(listen_socket, backlog) < 0) {
     454             : 
     455           0 :                 fprintf(stderr, "Cannot bind/listen socket - [%d] %s.\n",errno, strerror(errno));
     456           0 :                 return -1;
     457             :         }
     458             : 
     459           0 :         if (!tcp) {
     460           0 :                 chmod(path, 0777);
     461             :         } else {
     462           0 :                         char *ip = getenv("FCGI_WEB_SERVER_ADDRS");
     463             :                         char *cur, *end;
     464             :                         int n;
     465             :                         
     466           0 :                         if (ip) {
     467           0 :                                 ip = strdup(ip);
     468           0 :                                 cur = ip;
     469           0 :                                 n = 0;
     470           0 :                                 while (*cur) {
     471           0 :                                         if (*cur == ',') n++;
     472           0 :                                         cur++;
     473             :                                 }
     474           0 :                                 allowed_clients = malloc(sizeof(in_addr_t) * (n+2));
     475           0 :                                 n = 0;
     476           0 :                                 cur = ip;
     477           0 :                                 while (cur) {
     478           0 :                                         end = strchr(cur, ',');
     479           0 :                                         if (end) {
     480           0 :                                                 *end = 0;
     481           0 :                                                 end++;
     482             :                                         }
     483           0 :                                         allowed_clients[n] = inet_addr(cur);
     484           0 :                                         if (allowed_clients[n] == INADDR_NONE) {
     485           0 :                                         fprintf(stderr, "Wrong IP address '%s' in FCGI_WEB_SERVER_ADDRS\n", cur);
     486             :                                         }
     487           0 :                                         n++;
     488           0 :                                         cur = end;
     489             :                                 }
     490           0 :                                 allowed_clients[n] = INADDR_NONE;
     491           0 :                         free(ip);
     492             :                 }
     493             :         }
     494             : 
     495           0 :         if (!is_initialized) {
     496           0 :                 fcgi_init();
     497             :         }
     498           0 :         is_fastcgi = 1;
     499             : 
     500             : #ifdef _WIN32
     501             :         if (tcp) {
     502             :                 listen_socket = _open_osfhandle((long)listen_socket, 0);
     503             :         }
     504             : #else
     505           0 :         fcgi_setup_signals();
     506             : #endif
     507           0 :         return listen_socket;
     508             : }
     509             : 
     510           0 : void fcgi_init_request(fcgi_request *req, int listen_socket)
     511             : {
     512           0 :         memset(req, 0, sizeof(fcgi_request));
     513           0 :         req->listen_socket = listen_socket;
     514           0 :         req->fd = -1;
     515           0 :         req->id = -1;
     516             : 
     517           0 :         req->in_len = 0;
     518           0 :         req->in_pad = 0;
     519             : 
     520           0 :         req->out_hdr = NULL;
     521           0 :         req->out_pos = req->out_buf;
     522             : 
     523             : #ifdef _WIN32
     524             :         req->tcp = !GetNamedPipeInfo((HANDLE)_get_osfhandle(req->listen_socket), NULL, NULL, NULL, NULL);
     525             : #endif
     526           0 : }
     527             : 
     528           0 : static inline ssize_t safe_write(fcgi_request *req, const void *buf, size_t count)
     529             : {
     530             :         int    ret;
     531           0 :         size_t n = 0;
     532             : 
     533             :         do {
     534           0 :                 errno = 0;
     535             : #ifdef _WIN32
     536             :                 if (!req->tcp) {
     537             :                         ret = write(req->fd, ((char*)buf)+n, count-n);
     538             :                 } else {
     539             :                         ret = send(req->fd, ((char*)buf)+n, count-n, 0);
     540             :                         if (ret <= 0) {
     541             :                                 errno = WSAGetLastError();
     542             :                         }
     543             :                 }
     544             : #else
     545           0 :                 ret = write(req->fd, ((char*)buf)+n, count-n);
     546             : #endif
     547           0 :                 if (ret > 0) {
     548           0 :                         n += ret;
     549           0 :                 } else if (ret <= 0 && errno != 0 && errno != EINTR) {
     550           0 :                         return ret;
     551             :                 }
     552           0 :         } while (n != count);
     553           0 :         return n;
     554             : }
     555             : 
     556           0 : static inline ssize_t safe_read(fcgi_request *req, const void *buf, size_t count)
     557             : {
     558             :         int    ret;
     559           0 :         size_t n = 0;
     560             : 
     561             :         do {
     562           0 :                 errno = 0;
     563             : #ifdef _WIN32
     564             :                 if (!req->tcp) {
     565             :                         ret = read(req->fd, ((char*)buf)+n, count-n);
     566             :                 } else {
     567             :                         ret = recv(req->fd, ((char*)buf)+n, count-n, 0);
     568             :                         if (ret <= 0) {
     569             :                                 errno = WSAGetLastError();
     570             :                         }
     571             :                 }
     572             : #else
     573           0 :                 ret = read(req->fd, ((char*)buf)+n, count-n);
     574             : #endif
     575           0 :                 if (ret > 0) {
     576           0 :                         n += ret;
     577           0 :                 } else if (ret == 0 && errno == 0) {
     578           0 :                         return n;
     579           0 :                 } else if (ret <= 0 && errno != 0 && errno != EINTR) {
     580           0 :                         return ret;
     581             :                 }
     582           0 :         } while (n != count);
     583           0 :         return n;
     584             : }
     585             : 
     586           0 : static inline int fcgi_make_header(fcgi_header *hdr, fcgi_request_type type, int req_id, int len)
     587             : {
     588           0 :         int pad = ((len + 7) & ~7) - len;
     589             : 
     590           0 :         hdr->contentLengthB0 = (unsigned char)(len & 0xff);
     591           0 :         hdr->contentLengthB1 = (unsigned char)((len >> 8) & 0xff);
     592           0 :         hdr->paddingLength = (unsigned char)pad;
     593           0 :         hdr->requestIdB0 = (unsigned char)(req_id & 0xff);
     594           0 :         hdr->requestIdB1 = (unsigned char)((req_id >> 8) & 0xff);
     595           0 :         hdr->reserved = 0;
     596           0 :         hdr->type = type;
     597           0 :         hdr->version = FCGI_VERSION_1;
     598           0 :         if (pad) {
     599           0 :                 memset(((unsigned char*)hdr) + sizeof(fcgi_header) + len, 0, pad);
     600             :         }
     601           0 :         return pad;
     602             : }
     603             : 
     604           0 : static int fcgi_get_params(fcgi_request *req, unsigned char *p, unsigned char *end)
     605             : {
     606             :         char buf[128];
     607           0 :         char *tmp = buf;
     608           0 :         size_t buf_size = sizeof(buf);
     609             :         unsigned int name_len, val_len;
     610             :         char *s;
     611           0 :         int ret = 1;
     612             : 
     613           0 :         while (p < end) {
     614           0 :                 name_len = *p++;
     615           0 :                 if (name_len >= 128) {
     616           0 :                         if (p + 3 >= end) {
     617           0 :                                 ret = 0;
     618           0 :                                 break;
     619             :                         }
     620           0 :                         name_len = ((name_len & 0x7f) << 24);
     621           0 :                         name_len |= (*p++ << 16);
     622           0 :                         name_len |= (*p++ << 8);
     623           0 :                         name_len |= *p++;
     624             :                 }
     625           0 :                 if (p >= end) {
     626           0 :                         ret = 0;
     627           0 :                         break;
     628             :                 }
     629           0 :                 val_len = *p++;
     630           0 :                 if (val_len >= 128) {
     631           0 :                         if (p + 3 >= end) {
     632           0 :                                 ret = 0;
     633           0 :                                 break;
     634             :                         }
     635           0 :                         val_len = ((val_len & 0x7f) << 24);
     636           0 :                         val_len |= (*p++ << 16);
     637           0 :                         val_len |= (*p++ << 8);
     638           0 :                         val_len |= *p++;
     639             :                 }
     640           0 :                 if (name_len + val_len > end - p) {
     641             :                         /* Malformated request */
     642           0 :                         ret = 0;
     643           0 :                         break;
     644             :                 }
     645           0 :                 if (name_len+1 >= buf_size) {
     646           0 :                         buf_size = name_len + 64;
     647           0 :                         tmp = (tmp == buf ? emalloc(buf_size): erealloc(tmp, buf_size));
     648             :                 }
     649           0 :                 memcpy(tmp, p, name_len);
     650           0 :                 tmp[name_len] = 0;
     651           0 :                 s = estrndup((char*)p + name_len, val_len);
     652           0 :                 zend_hash_update(req->env, tmp, name_len+1, &s, sizeof(char*), NULL);
     653           0 :                 p += name_len + val_len;
     654             :         }
     655           0 :         if (tmp != buf && tmp != NULL) {
     656           0 :                 efree(tmp);
     657             :         }
     658           0 :         return ret;
     659             : }
     660             : 
     661           0 : static void fcgi_free_var(char **s)
     662             : {
     663           0 :         efree(*s);
     664           0 : }
     665             : 
     666           0 : static int fcgi_read_request(fcgi_request *req)
     667             : {
     668             :         fcgi_header hdr;
     669             :         int len, padding;
     670             :         unsigned char buf[FCGI_MAX_LENGTH+8];
     671             : 
     672           0 :         req->keep = 0;
     673           0 :         req->closed = 0;
     674           0 :         req->in_len = 0;
     675           0 :         req->out_hdr = NULL;
     676           0 :         req->out_pos = req->out_buf;
     677           0 :         ALLOC_HASHTABLE(req->env);
     678           0 :         zend_hash_init(req->env, 0, NULL, (void (*)(void *)) fcgi_free_var, 0);
     679             : 
     680           0 :         if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
     681           0 :             hdr.version < FCGI_VERSION_1) {
     682           0 :                 return 0;
     683             :         }
     684             : 
     685           0 :         len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;
     686           0 :         padding = hdr.paddingLength;
     687             : 
     688           0 :         while (hdr.type == FCGI_STDIN && len == 0) {
     689           0 :                 if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
     690           0 :                     hdr.version < FCGI_VERSION_1) {
     691           0 :                         return 0;
     692             :                 }
     693             : 
     694           0 :                 len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;
     695           0 :                 padding = hdr.paddingLength;
     696             :         }
     697             : 
     698           0 :         if (len + padding > FCGI_MAX_LENGTH) {
     699           0 :                 return 0;
     700             :         }
     701             : 
     702           0 :         req->id = (hdr.requestIdB1 << 8) + hdr.requestIdB0;
     703             : 
     704           0 :         if (hdr.type == FCGI_BEGIN_REQUEST && len == sizeof(fcgi_begin_request)) {
     705             :                 char *val;
     706             : 
     707           0 :                 if (safe_read(req, buf, len+padding) != len+padding) {
     708           0 :                         return 0;
     709             :                 }
     710             : 
     711           0 :                 req->keep = (((fcgi_begin_request*)buf)->flags & FCGI_KEEP_CONN);
     712           0 :                 switch ((((fcgi_begin_request*)buf)->roleB1 << 8) + ((fcgi_begin_request*)buf)->roleB0) {
     713             :                         case FCGI_RESPONDER:
     714           0 :                                 val = estrdup("RESPONDER");
     715           0 :                                 zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);
     716           0 :                                 break;
     717             :                         case FCGI_AUTHORIZER:
     718           0 :                                 val = estrdup("AUTHORIZER");
     719           0 :                                 zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);
     720           0 :                                 break;
     721             :                         case FCGI_FILTER:
     722           0 :                                 val = estrdup("FILTER");
     723           0 :                                 zend_hash_update(req->env, "FCGI_ROLE", sizeof("FCGI_ROLE"), &val, sizeof(char*), NULL);
     724           0 :                                 break;
     725             :                         default:
     726           0 :                                 return 0;
     727             :                 }
     728             : 
     729           0 :                 if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
     730           0 :                     hdr.version < FCGI_VERSION_1) {
     731           0 :                         return 0;
     732             :                 }
     733             : 
     734           0 :                 len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;
     735           0 :                 padding = hdr.paddingLength;
     736             : 
     737           0 :                 while (hdr.type == FCGI_PARAMS && len > 0) {
     738           0 :                         if (len + padding > FCGI_MAX_LENGTH) {
     739           0 :                                 return 0;
     740             :                         }
     741             : 
     742           0 :                         if (safe_read(req, buf, len+padding) != len+padding) {
     743           0 :                                 req->keep = 0;
     744           0 :                                 return 0;
     745             :                         }
     746             : 
     747           0 :                         if (!fcgi_get_params(req, buf, buf+len)) {
     748           0 :                                 req->keep = 0;
     749           0 :                                 return 0;
     750             :                         }
     751             : 
     752           0 :                         if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
     753           0 :                             hdr.version < FCGI_VERSION_1) {
     754           0 :                                 req->keep = 0;
     755           0 :                                 return 0;
     756             :                         }
     757           0 :                         len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;
     758           0 :                         padding = hdr.paddingLength;
     759             :                 }
     760           0 :         } else if (hdr.type == FCGI_GET_VALUES) {
     761           0 :                 unsigned char *p = buf + sizeof(fcgi_header);
     762             :                 HashPosition pos;
     763             :                 char * str_index;
     764             :                 uint str_length;
     765             :                 ulong num_index;
     766             :                 int key_type;
     767             :                 zval ** value;
     768             : 
     769           0 :                 if (safe_read(req, buf, len+padding) != len+padding) {
     770           0 :                         req->keep = 0;
     771           0 :                         return 0;
     772             :                 }
     773             : 
     774           0 :                 if (!fcgi_get_params(req, buf, buf+len)) {
     775           0 :                         req->keep = 0;
     776           0 :                         return 0;
     777             :                 }
     778             : 
     779           0 :                 zend_hash_internal_pointer_reset_ex(req->env, &pos);
     780           0 :                 while ((key_type = zend_hash_get_current_key_ex(req->env, &str_index, &str_length, &num_index, 0, &pos)) != HASH_KEY_NON_EXISTANT) {
     781             :                         int zlen;
     782           0 :                         zend_hash_move_forward_ex(req->env, &pos);
     783           0 :                         if (key_type != HASH_KEY_IS_STRING) {
     784           0 :                                 continue;
     785             :                         }
     786           0 :                         if (zend_hash_find(&fcgi_mgmt_vars, str_index, str_length, (void**) &value) != SUCCESS) {
     787           0 :                                 continue;
     788             :                         }
     789           0 :                         --str_length;
     790           0 :                         zlen = Z_STRLEN_PP(value);
     791           0 :                         if ((p + 4 + 4 + str_length + zlen) >= (buf + sizeof(buf))) {
     792           0 :                                 break;
     793             :                         }
     794           0 :                         if (str_length < 0x80) {
     795           0 :                                 *p++ = str_length;
     796             :                         } else {
     797           0 :                                 *p++ = ((str_length >> 24) & 0xff) | 0x80;
     798           0 :                                 *p++ = (str_length >> 16) & 0xff;
     799           0 :                                 *p++ = (str_length >> 8) & 0xff;
     800           0 :                                 *p++ = str_length & 0xff;
     801             :                         }
     802           0 :                         if (zlen < 0x80) {
     803           0 :                                 *p++ = zlen;
     804             :                         } else {
     805           0 :                                 *p++ = ((zlen >> 24) & 0xff) | 0x80;
     806           0 :                                 *p++ = (zlen >> 16) & 0xff;
     807           0 :                                 *p++ = (zlen >> 8) & 0xff;
     808           0 :                                 *p++ = zlen & 0xff;
     809             :                         }
     810           0 :                         memcpy(p, str_index, str_length);
     811           0 :                         p += str_length;
     812           0 :                         memcpy(p, Z_STRVAL_PP(value), zlen);
     813           0 :                         p += zlen;
     814             :                 }
     815           0 :                 len = p - buf - sizeof(fcgi_header);
     816           0 :                 len += fcgi_make_header((fcgi_header*)buf, FCGI_GET_VALUES_RESULT, 0, len);
     817           0 :                 if (safe_write(req, buf, sizeof(fcgi_header)+len) != (int)sizeof(fcgi_header)+len) {
     818           0 :                         req->keep = 0;
     819           0 :                         return 0;
     820             :                 }
     821           0 :                 return 0;
     822             :         } else {
     823           0 :                 return 0;
     824             :         }
     825             : 
     826           0 :         return 1;
     827             : }
     828             : 
     829           0 : int fcgi_read(fcgi_request *req, char *str, int len)
     830             : {
     831             :         int ret, n, rest;
     832             :         fcgi_header hdr;
     833             :         unsigned char buf[255];
     834             : 
     835           0 :         n = 0;
     836           0 :         rest = len;
     837           0 :         while (rest > 0) {
     838           0 :                 if (req->in_len == 0) {
     839           0 :                         if (safe_read(req, &hdr, sizeof(fcgi_header)) != sizeof(fcgi_header) ||
     840           0 :                             hdr.version < FCGI_VERSION_1 ||
     841           0 :                             hdr.type != FCGI_STDIN) {
     842           0 :                                 req->keep = 0;
     843           0 :                                 return 0;
     844             :                         }
     845           0 :                         req->in_len = (hdr.contentLengthB1 << 8) | hdr.contentLengthB0;
     846           0 :                         req->in_pad = hdr.paddingLength;
     847           0 :                         if (req->in_len == 0) {
     848           0 :                                 return n;
     849             :                         }
     850             :                 }
     851             : 
     852           0 :                 if (req->in_len >= rest) {
     853           0 :                         ret = safe_read(req, str, rest);
     854             :                 } else {
     855           0 :                         ret = safe_read(req, str, req->in_len);
     856             :                 }
     857           0 :                 if (ret < 0) {
     858           0 :                         req->keep = 0;
     859           0 :                         return ret;
     860           0 :                 } else if (ret > 0) {
     861           0 :                         req->in_len -= ret;
     862           0 :                         rest -= ret;
     863           0 :                         n += ret;
     864           0 :                         str += ret;
     865           0 :                         if (req->in_len == 0) {
     866           0 :                                 if (req->in_pad) {
     867           0 :                                         if (safe_read(req, buf, req->in_pad) != req->in_pad) {
     868           0 :                                                 req->keep = 0;
     869           0 :                                                 return ret;
     870             :                                         }
     871             :                                 }
     872             :                         } else {
     873           0 :                                 return n;
     874             :                         }
     875             :                 } else {
     876           0 :                         return n;
     877             :                 }
     878             :         }
     879           0 :         return n;
     880             : }
     881             : 
     882           0 : static inline void fcgi_close(fcgi_request *req, int force, int destroy)
     883             : {
     884           0 :         if (destroy && req->env) {
     885           0 :                 zend_hash_destroy(req->env);
     886           0 :                 FREE_HASHTABLE(req->env);
     887           0 :                 req->env = NULL;
     888             :         }
     889             : 
     890             : #ifdef _WIN32
     891             :         if (is_impersonate && !req->tcp) {
     892             :                 RevertToSelf();
     893             :         }
     894             : #endif
     895             : 
     896           0 :         if ((force || !req->keep) && req->fd >= 0) {
     897             : #ifdef _WIN32
     898             :                 if (!req->tcp) {
     899             :                         HANDLE pipe = (HANDLE)_get_osfhandle(req->fd);
     900             : 
     901             :                         if (!force) {
     902             :                                 FlushFileBuffers(pipe);
     903             :                         }
     904             :                         DisconnectNamedPipe(pipe);
     905             :                 } else {
     906             :                         if (!force) {
     907             :                                 char buf[8];
     908             : 
     909             :                                 shutdown(req->fd, 1);
     910             :                                 while (recv(req->fd, buf, sizeof(buf), 0) > 0) {}
     911             :                         }
     912             :                         closesocket(req->fd);
     913             :                 }
     914             : #else
     915           0 :                 if (!force) {
     916             :                         char buf[8];
     917             : 
     918           0 :                         shutdown(req->fd, 1);
     919           0 :                         while (recv(req->fd, buf, sizeof(buf), 0) > 0) {}
     920             :                 }
     921           0 :                 close(req->fd);
     922             : #endif
     923           0 :                 req->fd = -1;
     924             :         }
     925           0 : }
     926             : 
     927           0 : int fcgi_accept_request(fcgi_request *req)
     928             : {
     929             : #ifdef _WIN32
     930             :         HANDLE pipe;
     931             :         OVERLAPPED ov;
     932             : #endif
     933             : 
     934             :         while (1) {
     935           0 :                 if (req->fd < 0) {
     936             :                         while (1) {
     937           0 :                                 if (in_shutdown) {
     938           0 :                                         return -1;
     939             :                                 }
     940             : #ifdef _WIN32
     941             :                                 if (!req->tcp) {
     942             :                                         pipe = (HANDLE)_get_osfhandle(req->listen_socket);
     943             :                                         FCGI_LOCK(req->listen_socket);
     944             :                                         ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
     945             :                                         if (!ConnectNamedPipe(pipe, &ov)) {
     946             :                                                 errno = GetLastError();
     947             :                                                 if (errno == ERROR_IO_PENDING) {
     948             :                                                         while (WaitForSingleObject(ov.hEvent, 1000) == WAIT_TIMEOUT) {
     949             :                                                                 if (in_shutdown) {
     950             :                                                                         CloseHandle(ov.hEvent);
     951             :                                                                         FCGI_UNLOCK(req->listen_socket);
     952             :                                                                         return -1;
     953             :                                                                 }
     954             :                                                         }
     955             :                                                 } else if (errno != ERROR_PIPE_CONNECTED) {
     956             :                                                 }
     957             :                                         }
     958             :                                         CloseHandle(ov.hEvent);
     959             :                                         req->fd = req->listen_socket;
     960             :                                         FCGI_UNLOCK(req->listen_socket);
     961             :                                 } else {
     962             :                                         SOCKET listen_socket = (SOCKET)_get_osfhandle(req->listen_socket);
     963             : #else
     964             :                                 {
     965           0 :                                         int listen_socket = req->listen_socket;
     966             : #endif
     967             :                                         sa_t sa;
     968           0 :                                         socklen_t len = sizeof(sa);
     969             : 
     970             :                                         FCGI_LOCK(req->listen_socket);
     971           0 :                                         req->fd = accept(listen_socket, (struct sockaddr *)&sa, &len);
     972             :                                         FCGI_UNLOCK(req->listen_socket);
     973           0 :                                         if (req->fd >= 0 && allowed_clients) {
     974           0 :                                                 int n = 0;
     975           0 :                                                 int allowed = 0;
     976             : 
     977           0 :                                                         while (allowed_clients[n] != INADDR_NONE) {
     978           0 :                                                                 if (allowed_clients[n] == sa.sa_inet.sin_addr.s_addr) {
     979           0 :                                                                         allowed = 1;
     980           0 :                                                                         break;
     981             :                                                                 }
     982           0 :                                                                 n++;
     983             :                                                         }
     984           0 :                                                 if (!allowed) {
     985           0 :                                                         fprintf(stderr, "Connection from disallowed IP address '%s' is dropped.\n", inet_ntoa(sa.sa_inet.sin_addr));
     986           0 :                                                         closesocket(req->fd);
     987           0 :                                                         req->fd = -1;
     988           0 :                                                         continue;
     989             :                                                 }
     990             :                                         }
     991             :                                 }
     992             : 
     993             : #ifdef _WIN32
     994             :                                 if (req->fd < 0 && (in_shutdown || errno != EINTR)) {
     995             : #else
     996           0 :                                 if (req->fd < 0 && (in_shutdown || (errno != EINTR && errno != ECONNABORTED))) {
     997             : #endif
     998           0 :                                         return -1;
     999             :                                 }
    1000             : 
    1001             : #ifdef _WIN32
    1002             :                                 break;
    1003             : #else
    1004           0 :                                 if (req->fd >= 0) {
    1005             : #if defined(HAVE_SYS_POLL_H) && defined(HAVE_POLL)
    1006             :                                         struct pollfd fds;
    1007             :                                         int ret;
    1008             : 
    1009           0 :                                         fds.fd = req->fd;
    1010           0 :                                         fds.events = POLLIN;
    1011           0 :                                         fds.revents = 0;
    1012             :                                         do {
    1013           0 :                                                 errno = 0;
    1014           0 :                                                 ret = poll(&fds, 1, 5000);
    1015           0 :                                         } while (ret < 0 && errno == EINTR);
    1016           0 :                                         if (ret > 0 && (fds.revents & POLLIN)) {
    1017           0 :                                                 break;
    1018             :                                         }
    1019           0 :                                         fcgi_close(req, 1, 0);
    1020             : #else
    1021             :                                         if (req->fd < FD_SETSIZE) {
    1022             :                                                 struct timeval tv = {5,0};
    1023             :                                                 fd_set set;
    1024             :                                                 int ret;
    1025             : 
    1026             :                                                 FD_ZERO(&set);
    1027             :                                                 FD_SET(req->fd, &set);
    1028             :                                                 do {
    1029             :                                                         errno = 0;
    1030             :                                                         ret = select(req->fd + 1, &set, NULL, NULL, &tv) >= 0;
    1031             :                                                 } while (ret < 0 && errno == EINTR);
    1032             :                                                 if (ret > 0 && FD_ISSET(req->fd, &set)) {
    1033             :                                                         break;
    1034             :                                                 }
    1035             :                                                 fcgi_close(req, 1, 0);
    1036             :                                         } else {
    1037             :                                                 fprintf(stderr, "Too many open file descriptors. FD_SETSIZE limit exceeded.");
    1038             :                                                 fcgi_close(req, 1, 0);
    1039             :                                         }
    1040             : #endif
    1041             :                                 }
    1042             : #endif
    1043           0 :                         }
    1044           0 :                 } else if (in_shutdown) {
    1045           0 :                         return -1;
    1046             :                 }
    1047           0 :                 if (fcgi_read_request(req)) {
    1048             : #ifdef _WIN32
    1049             :                         if (is_impersonate && !req->tcp) {
    1050             :                                 pipe = (HANDLE)_get_osfhandle(req->fd);
    1051             :                                 if (!ImpersonateNamedPipeClient(pipe)) {
    1052             :                                         fcgi_close(req, 1, 1);
    1053             :                                         continue;
    1054             :                                 }
    1055             :                         }
    1056             : #endif
    1057           0 :                         return req->fd;
    1058             :                 } else {
    1059           0 :                         fcgi_close(req, 1, 1);
    1060             :                 }
    1061           0 :         }
    1062             : }
    1063             : 
    1064           0 : static inline fcgi_header* open_packet(fcgi_request *req, fcgi_request_type type)
    1065             : {
    1066           0 :         req->out_hdr = (fcgi_header*) req->out_pos;
    1067           0 :         req->out_hdr->type = type;
    1068           0 :         req->out_pos += sizeof(fcgi_header);
    1069           0 :         return req->out_hdr;
    1070             : }
    1071             : 
    1072           0 : static inline void close_packet(fcgi_request *req)
    1073             : {
    1074           0 :         if (req->out_hdr) {
    1075           0 :                 int len = req->out_pos - ((unsigned char*)req->out_hdr + sizeof(fcgi_header));
    1076             : 
    1077           0 :                 req->out_pos += fcgi_make_header(req->out_hdr, (fcgi_request_type)req->out_hdr->type, req->id, len);
    1078           0 :                 req->out_hdr = NULL;
    1079             :         }
    1080           0 : }
    1081             : 
    1082           0 : int fcgi_flush(fcgi_request *req, int close)
    1083             : {
    1084             :         int len;
    1085             : 
    1086           0 :         close_packet(req);
    1087             : 
    1088           0 :         len = req->out_pos - req->out_buf;
    1089             : 
    1090           0 :         if (close) {
    1091           0 :                 fcgi_end_request_rec *rec = (fcgi_end_request_rec*)(req->out_pos);
    1092             : 
    1093           0 :                 fcgi_make_header(&rec->hdr, FCGI_END_REQUEST, req->id, sizeof(fcgi_end_request));
    1094           0 :                 rec->body.appStatusB3 = 0;
    1095           0 :                 rec->body.appStatusB2 = 0;
    1096           0 :                 rec->body.appStatusB1 = 0;
    1097           0 :                 rec->body.appStatusB0 = 0;
    1098           0 :                 rec->body.protocolStatus = FCGI_REQUEST_COMPLETE;
    1099           0 :                 len += sizeof(fcgi_end_request_rec);
    1100             :         }
    1101             : 
    1102           0 :         if (safe_write(req, req->out_buf, len) != len) {
    1103           0 :                 req->keep = 0;
    1104           0 :                 return 0;
    1105             :         }
    1106             : 
    1107           0 :         req->out_pos = req->out_buf;
    1108           0 :         return 1;
    1109             : }
    1110             : 
    1111           0 : int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len)
    1112             : {
    1113             :         int limit, rest;
    1114             : 
    1115           0 :         if (len <= 0) {
    1116           0 :                 return 0;
    1117             :         }
    1118             : 
    1119           0 :         if (req->out_hdr && req->out_hdr->type != type) {
    1120           0 :                 close_packet(req);
    1121             :         }
    1122             : #if 0
    1123             :         /* Unoptimized, but clear version */
    1124             :         rest = len;
    1125             :         while (rest > 0) {
    1126             :                 limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
    1127             : 
    1128             :                 if (!req->out_hdr) {
    1129             :                         if (limit < sizeof(fcgi_header)) {
    1130             :                                 if (!fcgi_flush(req, 0)) {
    1131             :                                         return -1;
    1132             :                                 }
    1133             :                         }
    1134             :                         open_packet(req, type);
    1135             :                 }
    1136             :                 limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
    1137             :                 if (rest < limit) {
    1138             :                         memcpy(req->out_pos, str, rest);
    1139             :                         req->out_pos += rest;
    1140             :                         return len;
    1141             :                 } else {
    1142             :                         memcpy(req->out_pos, str, limit);
    1143             :                         req->out_pos += limit;
    1144             :                         rest -= limit;
    1145             :                         str += limit;
    1146             :                         if (!fcgi_flush(req, 0)) {
    1147             :                                 return -1;
    1148             :                         }
    1149             :                 }
    1150             :         }
    1151             : #else
    1152             :         /* Optimized version */
    1153           0 :         limit = sizeof(req->out_buf) - (req->out_pos - req->out_buf);
    1154           0 :         if (!req->out_hdr) {
    1155           0 :                 limit -= sizeof(fcgi_header);
    1156           0 :                 if (limit < 0) limit = 0;
    1157             :         }
    1158             : 
    1159           0 :         if (len < limit) {
    1160           0 :                 if (!req->out_hdr) {
    1161           0 :                         open_packet(req, type);
    1162             :                 }
    1163           0 :                 memcpy(req->out_pos, str, len);
    1164           0 :                 req->out_pos += len;
    1165           0 :         } else if (len - limit < sizeof(req->out_buf) - sizeof(fcgi_header)) {
    1166           0 :                 if (!req->out_hdr) {
    1167           0 :                         open_packet(req, type);
    1168             :                 }
    1169           0 :                 if (limit > 0) {
    1170           0 :                         memcpy(req->out_pos, str, limit);
    1171           0 :                         req->out_pos += limit;
    1172             :                 }
    1173           0 :                 if (!fcgi_flush(req, 0)) {
    1174           0 :                         return -1;
    1175             :                 }
    1176           0 :                 if (len > limit) {
    1177           0 :                         open_packet(req, type);
    1178           0 :                         memcpy(req->out_pos, str + limit, len - limit);
    1179           0 :                         req->out_pos += len - limit;
    1180             :                 }
    1181             :         } else {
    1182           0 :                 int pos = 0;
    1183             :                 int pad;
    1184             : 
    1185           0 :                 close_packet(req);
    1186           0 :                 while ((len - pos) > 0xffff) {
    1187           0 :                         open_packet(req, type);
    1188           0 :                         fcgi_make_header(req->out_hdr, type, req->id, 0xfff8);
    1189           0 :                         req->out_hdr = NULL;
    1190           0 :                         if (!fcgi_flush(req, 0)) {
    1191           0 :                                 return -1;
    1192             :                         }
    1193           0 :                         if (safe_write(req, str + pos, 0xfff8) != 0xfff8) {
    1194           0 :                                 req->keep = 0;
    1195           0 :                                 return -1;
    1196             :                         }
    1197           0 :                         pos += 0xfff8;
    1198             :                 }               
    1199             :                 
    1200           0 :                 pad = (((len - pos) + 7) & ~7) - (len - pos);
    1201           0 :                 rest = pad ? 8 - pad : 0;
    1202             : 
    1203           0 :                 open_packet(req, type);
    1204           0 :                 fcgi_make_header(req->out_hdr, type, req->id, (len - pos) - rest);
    1205           0 :                 req->out_hdr = NULL;
    1206           0 :                 if (!fcgi_flush(req, 0)) {
    1207           0 :                         return -1;
    1208             :                 }
    1209           0 :                 if (safe_write(req, str + pos, (len - pos) - rest) != (len - pos) - rest) {
    1210           0 :                         req->keep = 0;
    1211           0 :                         return -1;
    1212             :                 }
    1213           0 :                 if (pad) {
    1214           0 :                         open_packet(req, type);
    1215           0 :                         memcpy(req->out_pos, str + len - rest,  rest);
    1216           0 :                         req->out_pos += rest;
    1217             :                 }
    1218             :         }
    1219             : #endif
    1220           0 :         return len;
    1221             : }
    1222             : 
    1223           0 : int fcgi_finish_request(fcgi_request *req, int force_close)
    1224             : {
    1225           0 :         int ret = 1;
    1226             : 
    1227           0 :         if (req->fd >= 0) {
    1228           0 :                 if (!req->closed) {
    1229           0 :                         ret = fcgi_flush(req, 1);
    1230           0 :                         req->closed = 1;
    1231             :                 }
    1232           0 :                 fcgi_close(req, force_close, 1);
    1233             :         }
    1234           0 :         return ret;
    1235             : }
    1236             : 
    1237           0 : char* fcgi_getenv(fcgi_request *req, const char* var, int var_len)
    1238             : {
    1239             :         char **val;
    1240             : 
    1241           0 :         if (!req) return NULL;
    1242             : 
    1243           0 :         if (zend_hash_find(req->env, (char*)var, var_len+1, (void**)&val) == SUCCESS) {
    1244           0 :                 return *val;
    1245             :         }
    1246           0 :         return NULL;
    1247             : }
    1248             : 
    1249           0 : char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val)
    1250             : {
    1251           0 :         if (var && req) {
    1252           0 :                 if (val == NULL) {
    1253           0 :                         zend_hash_del(req->env, var, var_len+1);
    1254             :                 } else {
    1255             :                         char **ret;
    1256             : 
    1257           0 :                         val = estrdup(val);
    1258           0 :                         if (zend_hash_update(req->env, var, var_len+1, &val, sizeof(char*), (void**)&ret) == SUCCESS) {
    1259           0 :                                 return *ret;
    1260             :                         }
    1261             :                 }
    1262             :         }
    1263           0 :         return NULL;
    1264             : }
    1265             : 
    1266             : #ifdef _WIN32
    1267             : void fcgi_impersonate(void)
    1268             : {
    1269             :         char *os_name;
    1270             : 
    1271             :         os_name = getenv("OS");
    1272             :         if (os_name && stricmp(os_name, "Windows_NT") == 0) {
    1273             :                 is_impersonate = 1;
    1274             :         }
    1275             : }
    1276             : #endif
    1277             : 
    1278         342 : void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len)
    1279             : {
    1280             :         zval * zvalue;
    1281         342 :         zvalue = pemalloc(sizeof(*zvalue), 1);
    1282         342 :         Z_TYPE_P(zvalue) = IS_STRING;
    1283         342 :         Z_STRVAL_P(zvalue) = pestrndup(value, value_len, 1);
    1284         342 :         Z_STRLEN_P(zvalue) = value_len;
    1285         342 :         zend_hash_add(&fcgi_mgmt_vars, name, name_len + 1, &zvalue, sizeof(zvalue), NULL);
    1286         342 : }
    1287             : 
    1288         332 : void fcgi_free_mgmt_var_cb(void * ptr)
    1289             : {
    1290         332 :         zval ** var = (zval **)ptr;
    1291         332 :         pefree(Z_STRVAL_PP(var), 1);
    1292         332 :         pefree(*var, 1);
    1293         332 : }
    1294             : 
    1295             : /*
    1296             :  * Local variables:
    1297             :  * tab-width: 4
    1298             :  * c-basic-offset: 4
    1299             :  * End:
    1300             :  * vim600: sw=4 ts=4 fdm=marker
    1301             :  * vim<600: sw=4 ts=4
    1302             :  */

Generated by: LCOV version 1.10

Generated at Wed, 23 Jul 2014 19:58:46 +0000 (21 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.