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: 26 610 4.3 %
Date: 2015-03-20 Functions: 5 39 12.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Fri, 20 Mar 2015 23:40:42 +0000 (7 days ago)

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