This commit was manufactured by cvs2svn to create branch 'PHP_5'.PHP-5

1 files changed, 0 insertions, 2067 deletions

diff --git a/sapi/cgi/libfcgi/os_win32.c b/sapi/cgi/libfcgi/os_win32.c
deleted file mode 100644
index 723ef81060..0000000000
--- a/sapi/cgi/libfcgi/os_win32.c
+++ /dev/null
@@ -1,2067 +0,0 @@
-/*
- * os_win32.c --
- *
- *
- *  Copyright (c) 1995 Open Market, Inc.
- *  All rights reserved.
- *
- *  This file contains proprietary and confidential information and
- *  remains the unpublished property of Open Market, Inc. Use,
- *  disclosure, or reproduction is prohibited except as permitted by
- *  express written license agreement with Open Market, Inc.
- *
- *  Bill Snapper
- *  snapper@openmarket.com
- *
- * (Special thanks to Karen and Bill.  They made my job much easier and
- *  significantly more enjoyable.)
- */
-#ifndef lint
-static const char rcsid[] = "$Id$";
-#endif /* not lint */
-
-#define WIN32_LEAN_AND_MEAN 
-#include <windows.h>
-#include <winsock2.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <stdio.h>
-#include <sys/timeb.h>
-
-#define DLLAPI  __declspec(dllexport)
-
-#include "fcgimisc.h"
-#include "fcgios.h"
-
-#define WIN32_OPEN_MAX 128 /* XXX: Small hack */
-
-/*
- * millisecs to wait for a client connection before checking the 
- * shutdown flag (then go back to waiting for a connection, etc).
- */
-#define ACCEPT_TIMEOUT 1000
-
-#define LOCALHOST "localhost"
-
-static HANDLE hIoCompPort = INVALID_HANDLE_VALUE;
-static HANDLE hStdinCompPort = INVALID_HANDLE_VALUE;
-static HANDLE hStdinThread = INVALID_HANDLE_VALUE;
-
-static HANDLE stdioHandles[3] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE,
-				 INVALID_HANDLE_VALUE};
-
-static HANDLE acceptMutex = INVALID_HANDLE_VALUE;
-
-static BOOLEAN shutdownPending = FALSE;
-static BOOLEAN shutdownNow = FALSE;
-
-static BOOLEAN bImpersonate = FALSE;
-/*
- * An enumeration of the file types
- * supported by the FD_TABLE structure.
- *
- * XXX: Not all currently supported.  This allows for future
- *      functionality.
- */
-typedef enum {
-    FD_UNUSED,
-    FD_FILE_SYNC,
-    FD_FILE_ASYNC,
-    FD_SOCKET_SYNC,
-    FD_SOCKET_ASYNC,
-    FD_PIPE_SYNC,
-    FD_PIPE_ASYNC
-} FILE_TYPE;
-
-typedef union {
-    HANDLE fileHandle;
-    SOCKET sock;
-    unsigned int value;
-} DESCRIPTOR;
-
-/*
- * Structure used to map file handle and socket handle
- * values into values that can be used to create unix-like
- * select bitmaps, read/write for both sockets/files.
- */
-struct FD_TABLE {
-    DESCRIPTOR fid;
-    FILE_TYPE type;
-    char *path;
-    DWORD Errno;
-    unsigned long instance;
-    int status;
-    int offset;			/* only valid for async file writes */
-    LPDWORD offsetHighPtr;	/* pointers to offset high and low words */
-    LPDWORD offsetLowPtr;	/* only valid for async file writes (logs) */
-    HANDLE  hMapMutex;		/* mutex handle for multi-proc offset update */
-    LPVOID  ovList;		/* List of associated OVERLAPPED_REQUESTs */
-};
-
-/* 
- * XXX Note there is no dyanmic sizing of this table, so if the
- * number of open file descriptors exceeds WIN32_OPEN_MAX the 
- * app will blow up.
- */
-static struct FD_TABLE fdTable[WIN32_OPEN_MAX];
-
-static CRITICAL_SECTION  fdTableCritical;
-
-struct OVERLAPPED_REQUEST {
-    OVERLAPPED overlapped;
-    unsigned long instance;	/* file instance (won't match after a close) */
-    OS_AsyncProc procPtr;	/* callback routine */
-    ClientData clientData;	/* callback argument */
-    ClientData clientData1;	/* additional clientData */
-};
-typedef struct OVERLAPPED_REQUEST *POVERLAPPED_REQUEST;
-
-static const char *bindPathPrefix = "\\\\.\\pipe\\FastCGI\\";
-
-static FILE_TYPE listenType = FD_UNUSED;
-
-// XXX This should be a DESCRIPTOR
-static HANDLE hListen = INVALID_HANDLE_VALUE;
-
-static OVERLAPPED listenOverlapped;
-static BOOLEAN libInitialized = FALSE;
-
-/*
- *--------------------------------------------------------------
- *
- * Win32NewDescriptor --
- *
- *	Set up for I/O descriptor masquerading.
- *
- * Results:
- *	Returns "fake id" which masquerades as a UNIX-style "small
- *	non-negative integer" file/socket descriptor.
- *	Win32_* routine below will "do the right thing" based on the
- *	descriptor's actual type. -1 indicates failure.
- *
- * Side effects:
- *	Entry in fdTable is reserved to represent the socket/file.
- *
- *--------------------------------------------------------------
- */
-static int Win32NewDescriptor(FILE_TYPE type, int fd, int desiredFd)
-{
-    int index = -1;
-
-    EnterCriticalSection(&fdTableCritical);
-
-    /*
-     * If desiredFd is set, try to get this entry (this is used for
-     * mapping stdio handles).  Otherwise try to get the fd entry.
-     * If this is not available, find a the first empty slot.  .
-     */
-    if (desiredFd >= 0 && desiredFd < WIN32_OPEN_MAX)
-    {
-        if (fdTable[desiredFd].type == FD_UNUSED) 
-        {
-            index = desiredFd;
-        }
-	}
-    else if (fd > 0)
-    {
-        if (fd < WIN32_OPEN_MAX && fdTable[fd].type == FD_UNUSED)
-        {
-	        index = fd;
-        }
-        else 
-        {
-            int i;
-
-            for (i = 1; i < WIN32_OPEN_MAX; ++i)
-            {
-	            if (fdTable[i].type == FD_UNUSED)
-                {
-                    index = i;
-                    break;
-                }
-            }
-        }
-    }
-    
-    if (index != -1) 
-    {
-        fdTable[index].fid.value = fd;
-        fdTable[index].type = type;
-        fdTable[index].path = NULL;
-        fdTable[index].Errno = NO_ERROR;
-        fdTable[index].status = 0;
-        fdTable[index].offset = -1;
-        fdTable[index].offsetHighPtr = fdTable[index].offsetLowPtr = NULL;
-        fdTable[index].hMapMutex = NULL;
-        fdTable[index].ovList = NULL;
-    }
-
-    LeaveCriticalSection(&fdTableCritical);
-    return index;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * StdinThread--
- *
- *	This thread performs I/O on stadard input.  It is needed
- *      because you can't guarantee that all applications will
- *      create standard input with sufficient access to perform
- *      asynchronous I/O.  Since we don't want to block the app
- *      reading from stdin we make it look like it's using I/O
- *      completion ports to perform async I/O.
- *
- * Results:
- *	Data is read from stdin and posted to the io completion
- *      port.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-static void StdinThread(LPDWORD startup){
-
-    int doIo = TRUE;
-    unsigned long fd;
-    unsigned long bytesRead;
-    POVERLAPPED_REQUEST pOv;
-
-    // Touch the arg to prevent warning
-    startup = NULL;
-
-    while(doIo) {
-        /*
-         * Block until a request to read from stdin comes in or a
-         * request to terminate the thread arrives (fd = -1).
-         */
-        if (!GetQueuedCompletionStatus(hStdinCompPort, &bytesRead, &fd,
-	    (LPOVERLAPPED *)&pOv, (DWORD)-1) && !pOv) {
-            doIo = 0;
-            break;
-        }
-
-	ASSERT((fd == STDIN_FILENO) || (fd == -1));
-        if(fd == -1) {
-            doIo = 0;
-            break;
-        }
-        ASSERT(pOv->clientData1 != NULL);
-
-        if(ReadFile(stdioHandles[STDIN_FILENO], pOv->clientData1, bytesRead,
-                    &bytesRead, NULL)) {
-            PostQueuedCompletionStatus(hIoCompPort, bytesRead,
-                                       STDIN_FILENO, (LPOVERLAPPED)pOv);
-        } else {
-            doIo = 0;
-            break;
-        }
-    }
-
-    ExitThread(0);
-}
-
-void OS_ShutdownPending(void)
-{
-    shutdownPending = TRUE;
-}
-
-/* XXX Need a shutdown now event */
-static DWORD WINAPI ShutdownRequestThread(LPVOID arg)
-{
-    HANDLE shutdownEvent = (HANDLE) arg;
-    WaitForSingleObject(shutdownEvent, INFINITE);
-    shutdownPending = TRUE;
-    // Before an accept() is entered the shutdownPending flag is checked.
-    // If set, OS_Accept() will return -1.  If not, it waits
-    // on a connection request for one second, checks the flag, & repeats.
-    // Only one process/thread is allowed to do this at time by
-    // wrapping the accept() with mutex.
-    return 0;
-}
-
-int OS_SetImpersonate(void)
-{
-	char *os_name = NULL;
-	os_name = getenv("OS");
-	if (os_name && stricmp(os_name, "Windows_NT") == 0) {
-		bImpersonate = TRUE;
-		return 1;
-	}
-	return 0;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_LibInit --
- *
- *	Set up the OS library for use.
- *
- * Results:
- *	Returns 0 if success, -1 if not.
- *
- * Side effects:
- *	Sockets initialized, pseudo file descriptors setup, etc.
- *
- *--------------------------------------------------------------
- */
-int OS_LibInit(int stdioFds[3])
-{
-    WORD  wVersion;
-    WSADATA wsaData;
-    int err;
-    int fakeFd;
-    DWORD threadId;
-    char *cLenPtr = NULL;
-    char *val = NULL;
-        
-    if(libInitialized)
-        return 0;
-
-    InitializeCriticalSection(&fdTableCritical);   
-    
-    /*
-     * Initialize windows sockets library.
-     */
-    wVersion = MAKEWORD(2,0);
-    err = WSAStartup( wVersion, &wsaData );
-    if (err) {
-        fprintf(stderr, "Error starting Windows Sockets.  Error: %d",
-		WSAGetLastError());
-	//exit(111);
-		return -1;
-    }
-
-    /*
-     * Create the I/O completion port to be used for our I/O queue.
-     */
-    if (hIoCompPort == INVALID_HANDLE_VALUE) {
-	hIoCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
-					      0, 1);
-	if(hIoCompPort == INVALID_HANDLE_VALUE) {
-	    printf("<H2>OS_LibInit Failed CreateIoCompletionPort!  ERROR: %d</H2>\r\n\r\n",
-	       GetLastError());
-	    return -1;
-	}
-    }
-
-    /*
-     * If a shutdown event is in the env, save it (I don't see any to 
-     * remove it from the environment out from under the application).
-     * Spawn a thread to wait on the shutdown request.
-     */
-    val = getenv(SHUTDOWN_EVENT_NAME);
-    if (val != NULL) 
-    {
-        HANDLE shutdownEvent = (HANDLE) atoi(val);
-
-        if (! CreateThread(NULL, 0, ShutdownRequestThread, 
-                           shutdownEvent, 0, NULL))
-        {
-            return -1;
-        }
-    }
-
-    /*
-     * If an accept mutex is in the env, save it and remove it.
-     */
-    val = getenv(MUTEX_VARNAME);
-    if (val != NULL) 
-    {
-        acceptMutex = (HANDLE) atoi(val);
-    }
-
-
-    /*
-     * Determine if this library is being used to listen for FastCGI
-     * connections.  This is communicated by STDIN containing a
-     * valid handle to a listener object.  In this case, both the
-     * "stdout" and "stderr" handles will be INVALID (ie. closed) by
-     * the starting process.
-     *
-     * The trick is determining if this is a pipe or a socket...
-     *
-     * XXX: Add the async accept test to determine socket or handle to a
-     *      pipe!!!
-     */
-    if((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&
-       (GetStdHandle(STD_ERROR_HANDLE)  == INVALID_HANDLE_VALUE) &&
-       (GetStdHandle(STD_INPUT_HANDLE)  != INVALID_HANDLE_VALUE) ) 
-    {
-        DWORD pipeMode = PIPE_READMODE_BYTE | PIPE_WAIT;
-        HANDLE oldStdIn = GetStdHandle(STD_INPUT_HANDLE);
-
-        // Move the handle to a "low" number
-        if (! DuplicateHandle(GetCurrentProcess(), oldStdIn,
-                              GetCurrentProcess(), &hListen,
-                              0, TRUE, DUPLICATE_SAME_ACCESS))
-        {
-            return -1;
-        }
-
-        if (! SetStdHandle(STD_INPUT_HANDLE, hListen))
-        {
-            return -1;
-        }
-
-        CloseHandle(oldStdIn);
-
-	/*
-	 * Set the pipe handle state so that it operates in wait mode.
-	 *
-	 * NOTE: The listenFd is not mapped to a pseudo file descriptor
-	 *       as all work done on it is contained to the OS library.
-	 *
-	 * XXX: Initial assumption is that SetNamedPipeHandleState will
-	 *      fail if this is an IP socket...
-	 */
-        if (SetNamedPipeHandleState(hListen, &pipeMode, NULL, NULL)) 
-        {
-            listenType = FD_PIPE_SYNC;
-            listenOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-        } 
-        else 
-        {
-            listenType = FD_SOCKET_SYNC;
-        }
-    }
-
-    /*
-     * If there are no stdioFds passed in, we're done.
-     */
-    if(stdioFds == NULL) {
-        libInitialized = 1;
-        return 0;
-    }
-
-    /*
-     * Setup standard input asynchronous I/O.  There is actually a separate
-     * thread spawned for this purpose.  The reason for this is that some
-     * web servers use anonymous pipes for the connection between itself
-     * and a CGI application.  Anonymous pipes can't perform asynchronous
-     * I/O or use I/O completion ports.  Therefore in order to present a
-     * consistent I/O dispatch model to an application we emulate I/O
-     * completion port behavior by having the standard input thread posting
-     * messages to the hIoCompPort which look like a complete overlapped
-     * I/O structure.  This keeps the event dispatching simple from the
-     * application perspective.
-     */
-    stdioHandles[STDIN_FILENO] = GetStdHandle(STD_INPUT_HANDLE);
-
-    if(!SetHandleInformation(stdioHandles[STDIN_FILENO],
-			     HANDLE_FLAG_INHERIT, 0)) {
-/*
- * XXX: Causes error when run from command line.  Check KB
-        err = GetLastError();
-        DebugBreak();
-	exit(99);
- */
-		return -1;
-    }
-
-    if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
-				     (int)stdioHandles[STDIN_FILENO],
-				     STDIN_FILENO)) == -1) {
-        return -1;
-    } else {
-        /*
-	 * Set stdin equal to our pseudo FD and create the I/O completion
-	 * port to be used for async I/O.
-	 */
-	stdioFds[STDIN_FILENO] = fakeFd;
-    }
-
-    /*
-     * Create the I/O completion port to be used for communicating with
-     * the thread doing I/O on standard in.  This port will carry read
-     * and possibly thread termination requests to the StdinThread.
-     */
-    if (hStdinCompPort == INVALID_HANDLE_VALUE) {
-	hStdinCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
-					      0, 1);
-	if(hStdinCompPort == INVALID_HANDLE_VALUE) {
-	    printf("<H2>OS_LibInit Failed CreateIoCompletionPort: STDIN!  ERROR: %d</H2>\r\n\r\n",
-	       GetLastError());
-	    return -1;
-	}
-    }
-
-    /*
-     * Create the thread that will read stdin if the CONTENT_LENGTH
-     * is non-zero.
-     */
-    if((cLenPtr = getenv("CONTENT_LENGTH")) != NULL &&
-       atoi(cLenPtr) > 0) {
-        hStdinThread = CreateThread(NULL, 8192,
-				    (LPTHREAD_START_ROUTINE)&StdinThread,
-				    NULL, 0, &threadId);
-	if (hStdinThread == NULL) {
-	    printf("<H2>OS_LibInit Failed to create STDIN thread!  ERROR: %d</H2>\r\n\r\n",
-		   GetLastError());
-	    return -1;
-        }
-    }
-
-    /*
-     * STDOUT will be used synchronously.
-     *
-     * XXX: May want to convert this so that it could be used for OVERLAPPED
-     *      I/O later.  If so, model it after the Stdin I/O as stdout is
-     *      also incapable of async I/O on some servers.
-     */
-    stdioHandles[STDOUT_FILENO] = GetStdHandle(STD_OUTPUT_HANDLE);
-    if(!SetHandleInformation(stdioHandles[STDOUT_FILENO],
-			     HANDLE_FLAG_INHERIT, FALSE)) {
-	//exit(99);
-		return -1;
-    }
-
-    if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
-				     (int)stdioHandles[STDOUT_FILENO],
-				     STDOUT_FILENO)) == -1) {
-        return -1;
-    } else {
-        /*
-	 * Set stdout equal to our pseudo FD
-	 */
-	stdioFds[STDOUT_FILENO] = fakeFd;
-    }
-
-    stdioHandles[STDERR_FILENO] = GetStdHandle(STD_ERROR_HANDLE);
-    if(!SetHandleInformation(stdioHandles[STDERR_FILENO],
-			     HANDLE_FLAG_INHERIT, FALSE)) {
-	//exit(99);
-		return -1;
-    }
-    if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
-				     (int)stdioHandles[STDERR_FILENO],
-				     STDERR_FILENO)) == -1) {
-        return -1;
-    } else {
-        /*
-	 * Set stderr equal to our pseudo FD
-	 */
-	stdioFds[STDERR_FILENO] = fakeFd;
-    }
-
-    return 0;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_LibShutdown --
- *
- *	Shutdown the OS library.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Memory freed, handles closed.
- *
- *--------------------------------------------------------------
- */
-void OS_LibShutdown()
-{
-
-    if (hIoCompPort != INVALID_HANDLE_VALUE) 
-    {
-        CloseHandle(hIoCompPort);
-        hIoCompPort = INVALID_HANDLE_VALUE;
-    }
-
-    if (hStdinCompPort != INVALID_HANDLE_VALUE) 
-    {
-        CloseHandle(hStdinCompPort);
-        hStdinCompPort = INVALID_HANDLE_VALUE;
-    }
-
-    if (acceptMutex != INVALID_HANDLE_VALUE) 
-    {
-        ReleaseMutex(acceptMutex);
-		CloseHandle(acceptMutex);
-    }
-
-	/* we only want to do this if we're not a web server */
-    if (stdioHandles[0] != INVALID_HANDLE_VALUE) {
-		DisconnectNamedPipe(hListen);
-		CancelIo(hListen);
-		if (bImpersonate) RevertToSelf();
-	}
-
-	DeleteCriticalSection(&fdTableCritical);
-    WSACleanup();
-}
-
-/*
- *--------------------------------------------------------------
- *
- * Win32FreeDescriptor --
- *
- *	Free I/O descriptor entry in fdTable.
- *
- * Results:
- *	Frees I/O descriptor entry in fdTable.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-static void Win32FreeDescriptor(int fd)
-{
-    /* Catch it if fd is a bogus value */
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-
-    EnterCriticalSection(&fdTableCritical);
-    
-    if (fdTable[fd].type != FD_UNUSED)
-    {   
-        switch (fdTable[fd].type) 
-        {
-	    case FD_FILE_SYNC:
-	    case FD_FILE_ASYNC:
-        
-	        /* Free file path string */
-	        ASSERT(fdTable[fd].path != NULL);
-			
-	        free(fdTable[fd].path);
-	        fdTable[fd].path = NULL;
-	        break;
-		case FD_PIPE_ASYNC:
-			break;
-	    default:
-	        break;
-        }
-
-        ASSERT(fdTable[fd].path == NULL);
-
-        fdTable[fd].type = FD_UNUSED;
-        fdTable[fd].path = NULL;
-        fdTable[fd].Errno = NO_ERROR;
-        fdTable[fd].offsetHighPtr = fdTable[fd].offsetLowPtr = NULL;
-
-        if (fdTable[fd].hMapMutex != NULL) 
-        {
-            CloseHandle(fdTable[fd].hMapMutex);
-            fdTable[fd].hMapMutex = NULL;
-        }
-    }
-
-    LeaveCriticalSection(&fdTableCritical);
-
-    return;
-}
-
-static short getPort(const char * bindPath)
-{
-    short port = 0;
-    char * p = strchr(bindPath, ':');
-
-    if (p && *++p) 
-    {
-        char buf[6];
-
-        strncpy(buf, p, 6);
-        buf[5] = '\0';
-
-        port = (short) atoi(buf);
-    }
- 
-    return port;
-}
-
-/**
-This function builds a Dacl which grants the creator of the objects
-FILE_ALL_ACCESS and Everyone FILE_GENERIC_READ and FILE_GENERIC_WRITE
-access to the object.
-
-This Dacl allows for higher security than a NULL Dacl, which is common for
-named-pipes, as this only grants the creator/owner write access to the
-security descriptor, and grants Everyone the ability to "use" the named-pipe.
-This scenario prevents a malevolent user from disrupting service by preventing
-arbitrary access manipulation.
-**/
-BOOL
-BuildNamedPipeAcl(
-    PACL pAcl,
-    PDWORD cbAclSize
-    )
-{
-    DWORD dwAclSize;
-
-    SID_IDENTIFIER_AUTHORITY siaWorld = SECURITY_WORLD_SID_AUTHORITY;
-    SID_IDENTIFIER_AUTHORITY siaCreator = SECURITY_CREATOR_SID_AUTHORITY;
-
-    BYTE BufEveryoneSid[32];
-    BYTE BufOwnerSid[32];
-
-    PSID pEveryoneSid = (PSID)BufEveryoneSid;
-    PSID pOwnerSid = (PSID)BufOwnerSid;
-
-    //
-    // compute size of acl
-    //
-    dwAclSize = sizeof(ACL) +
-        2 * ( sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) ) +
-        GetSidLengthRequired( 1 ) + // well-known Everyone Sid
-        GetSidLengthRequired( 1 ) ; // well-known Creator Owner Sid
-
-    if(*cbAclSize < dwAclSize) {
-        *cbAclSize = dwAclSize;
-        return FALSE;
-    }
-
-    *cbAclSize = dwAclSize;
-
-    //
-    // intialize well known sids
-    //
-
-    if(!InitializeSid(pEveryoneSid, &siaWorld, 1)) return FALSE;
-    *GetSidSubAuthority(pEveryoneSid, 0) = SECURITY_WORLD_RID;
-
-    if(!InitializeSid(pOwnerSid, &siaCreator, 1)) return FALSE;
-    *GetSidSubAuthority(pOwnerSid, 0) = SECURITY_CREATOR_OWNER_RID;
-
-    if(!InitializeAcl(pAcl, dwAclSize, ACL_REVISION))
-        return FALSE;
-
-    //
-    //
-    if(!AddAccessAllowedAce(
-        pAcl,
-        ACL_REVISION,
-        FILE_GENERIC_READ | FILE_GENERIC_WRITE,
-        pEveryoneSid
-        ))
-        return FALSE;
-
-    //
-    //
-    return AddAccessAllowedAce(
-        pAcl,
-        ACL_REVISION,
-        FILE_ALL_ACCESS,
-        pOwnerSid
-        );
-}
-
-
-/*
- * OS_CreateLocalIpcFd --
- *
- *   This procedure is responsible for creating the listener pipe
- *   on Windows NT for local process communication.  It will create a
- *   named pipe and return a file descriptor to it to the caller.
- *
- * Results:
- *      Listener pipe created.  This call returns either a valid
- *      pseudo file descriptor or -1 on error.
- *
- * Side effects:
- *      Listener pipe and IPC address are stored in the FCGI info
- *         structure.
- *      'errno' will set on errors (-1 is returned).
- *
- *----------------------------------------------------------------------
- */
-int OS_CreateLocalIpcFd(const char *bindPath, int backlog, int bCreateMutex)
-{
-    int pseudoFd = -1;
-    short port = getPort(bindPath);
-    HANDLE mutex = INVALID_HANDLE_VALUE;
-    char mutexEnvString[100];
-
-	if (bCreateMutex) {
-		mutex = CreateMutex(NULL, FALSE, NULL);
-		if (! SetHandleInformation(mutex, HANDLE_FLAG_INHERIT, TRUE))
-		{
-			CloseHandle(mutex);
-			return -3;
-		}
-		// This is a nail for listening to more than one port..
-		// This should really be handled by the caller.
-		_snprintf(mutexEnvString, sizeof(mutexEnvString)-1, MUTEX_VARNAME "=%d", (int) mutex);
-		putenv(mutexEnvString);
-	}
-
-    // There's nothing to be gained (at the moment) by a shutdown Event    
-
-    if (port && *bindPath != ':' && strncmp(bindPath, LOCALHOST, strlen(LOCALHOST)))
-    {
-	    fprintf(stderr, "To start a service on a TCP port can not "
-			    "specify a host name.\n"
-			    "You should either use \"localhost:<port>\" or "
-			    " just use \":<port>.\"\n");
-	    //exit(1);
-		if (bCreateMutex) CloseHandle(mutexEnvString);
-		return -1;
-    }
-
-    listenType = (port) ? FD_SOCKET_SYNC : FD_PIPE_ASYNC;
-    
-    if (port) 
-    {
-        SOCKET listenSock;
-        struct  sockaddr_in	sockAddr;
-        int sockLen = sizeof(sockAddr);
-        
-        memset(&sockAddr, 0, sizeof(sockAddr));
-        sockAddr.sin_family = AF_INET;
-        sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
-        sockAddr.sin_port = htons(port);
-
-        listenSock = socket(AF_INET, SOCK_STREAM, 0);
-        if (listenSock == INVALID_SOCKET) 
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-	        return -4;
-	    }
-
-	    if (bind(listenSock, (struct sockaddr *) &sockAddr, sockLen)  )
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-	        return -12;
-	    }
-
-	    if (listen(listenSock, backlog)) 
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-	        return -5;
-	    }
-
-        pseudoFd = Win32NewDescriptor(listenType, listenSock, -1);
-        
-        if (pseudoFd == -1) 
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-            closesocket(listenSock);
-            return -6;
-        }
-
-        hListen = (HANDLE) listenSock;        
-    }
-    else
-    {
-		SECURITY_ATTRIBUTES sa;
-		SECURITY_DESCRIPTOR sd;
-		BYTE AclBuf[ 64 ];
-		DWORD cbAclSize = 64;
-		PACL pAcl = (PACL)AclBuf;
-
-		HANDLE hListenPipe = INVALID_HANDLE_VALUE;
-        char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
-        
-        if (! pipePath) 
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-            return -7;
-        }
-
-        strcpy(pipePath, bindPathPrefix);
-        strcat(pipePath, bindPath);
-
-		if (bImpersonate) {
-			// get the security attributes for Everybody to connect
-			// we do this so that multithreaded servers that run
-			// threads under secured users can access pipes created
-			// by a system level thread (for instance, IIS)
-			//
-			// suppress errors regarding startup directory, etc
-			//
-			SetErrorMode(SEM_FAILCRITICALERRORS);
-
-			if(!BuildNamedPipeAcl(pAcl, &cbAclSize)) {
-				fprintf(stderr, "BuildNamedPipeAcl");
-				return -100;
-			}
-
-			if(!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
-				fprintf(stderr, "InitializeSecurityDescriptor");
-				return -100;
-			}
-
-			if(!SetSecurityDescriptorDacl(&sd, TRUE, pAcl, FALSE)) {
-				fprintf(stderr, "SetSecurityDescriptorDacl");
-				return -100;
-			}
-
-		    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-			sa.lpSecurityDescriptor = &sd; // default Dacl of caller
-			sa.bInheritHandle = TRUE;
-
-		}
-
-        hListenPipe = CreateNamedPipe(pipePath,
-		        PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
-		        PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_READMODE_BYTE,
-		        PIPE_UNLIMITED_INSTANCES,
-				4096, 4096, 0, bImpersonate?&sa:NULL);
-        
-        free(pipePath);
-
-        if (hListenPipe == INVALID_HANDLE_VALUE)
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-            return -8;
-        }
-
-        if (! SetHandleInformation(hListenPipe, HANDLE_FLAG_INHERIT, TRUE))
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-            return -9;
-        }
-
-        pseudoFd = Win32NewDescriptor(listenType, (int) hListenPipe, -1);
-        
-        if (pseudoFd == -1) 
-        {
-			if (bCreateMutex)CloseHandle(mutexEnvString);
-            CloseHandle(hListenPipe);
-            return -10;
-        }
-
-        hListen = (HANDLE) hListenPipe;
-    }
-
-    return pseudoFd;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_FcgiConnect --
- *
- *	Create the pipe pathname connect to the remote application if
- *      possible.
- *
- * Results:
- *      -1 if fail or a valid handle if connection succeeds.
- *
- * Side effects:
- *      Remote connection established.
- *
- *----------------------------------------------------------------------
- */
-int OS_FcgiConnect(char *bindPath)
-{
-    short port = getPort(bindPath);
-    int pseudoFd = -1;
-    unsigned int flags = FILE_FLAG_OVERLAPPED;
-    if (port) 
-    {
-	    struct hostent *hp;
-        char *host = NULL;
-        struct sockaddr_in sockAddr;
-        int sockLen = sizeof(sockAddr);
-        SOCKET sock;
-        
-        if (*bindPath != ':')
-        {
-            char * p = strchr(bindPath, ':');
-            if (p) {
-                int len = p - bindPath + 1;
-
-                host = (char *)malloc(len);
-                if (!host) {
-                    fprintf(stderr, "Unable to allocate memory\n");
-                    return -1;
-                }
-                strncpy(host, bindPath, len);
-                host[len-1] = '\0';
-            }
-        }
-        
-        hp = gethostbyname(host ? host : LOCALHOST);
-
-        if (host)
-        {
-            free(host);
-        }
-
-	    if (hp == NULL) 
-        {
-	        fprintf(stderr, "Unknown host: %s\n", bindPath);
-	        return -1;
-	    }
-       
-        memset(&sockAddr, 0, sizeof(sockAddr));
-        sockAddr.sin_family = AF_INET;
-	    memcpy(&sockAddr.sin_addr, hp->h_addr, hp->h_length);
-	    sockAddr.sin_port = htons(port);
-
-	    sock = socket(AF_INET, SOCK_STREAM, 0);
-        if (sock == INVALID_SOCKET)
-        {
-            return -1;
-        }
-
-        if (connect(sock, (struct sockaddr *) &sockAddr, sockLen) == SOCKET_ERROR) 
-        {
-	        closesocket(sock);
-	        return -1;
-	    }
-
-	    pseudoFd = Win32NewDescriptor(FD_SOCKET_SYNC, sock, -1);
-	    if (pseudoFd == -1) 
-        {
-	        closesocket(sock);
-            return -1;
-	    }
-    }
-    else
-    {
-        char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
-        HANDLE hPipe;
-        
-        if (! pipePath) 
-        {
-            return -1;
-        }
-
-        strcpy(pipePath, bindPathPrefix);
-        strcat(pipePath, bindPath);
-
-		if (bImpersonate) {
-			flags |= SECURITY_SQOS_PRESENT | SECURITY_IMPERSONATION;
-		}
-
-        hPipe = CreateFile(pipePath,
-			    GENERIC_WRITE | GENERIC_READ,
-			    FILE_SHARE_READ | FILE_SHARE_WRITE,
-			    NULL,
-			    OPEN_EXISTING,
-			    flags,
-			    NULL);
-
-        free(pipePath);
-
-        if( hPipe == INVALID_HANDLE_VALUE || hPipe == 0) 
-        {
-            return -1;
-        }
-
-        pseudoFd = Win32NewDescriptor(FD_PIPE_ASYNC, (int) hPipe, -1);
-        
-        if (pseudoFd == -1) 
-        {
-            CloseHandle(hPipe);
-            return -1;
-        } 
-        
-        /*
-	     * Set stdin equal to our pseudo FD and create the I/O completion
-	     * port to be used for async I/O.
-	     */
-        if (! CreateIoCompletionPort(hPipe, hIoCompPort, pseudoFd, 1))
-        {
-	        Win32FreeDescriptor(pseudoFd);
-	        CloseHandle(hPipe);
-	        return -1;
-	    }
-    }
-
-    return pseudoFd;    
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_Read --
- *
- *	Pass through to the appropriate NT read function.
- *
- * Results:
- *	Returns number of byes read. Mimics unix read:.
- *		n bytes read, 0 or -1 failure: errno contains actual error
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-int OS_Read(int fd, char * buf, size_t len)
-{
-    DWORD bytesRead;
-    int ret = -1;
-
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-
-    if (shutdownNow) return -1;
-
-    switch (fdTable[fd].type) 
-    {
-	case FD_FILE_SYNC:
-	case FD_FILE_ASYNC:
-	case FD_PIPE_SYNC:
-	case FD_PIPE_ASYNC:
-
-	    if (ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead, NULL)) 
-        {
-            ret = bytesRead;
-        }
-        else
-        {
-		    fdTable[fd].Errno = GetLastError();
-			ret = -1;
-	    }
-
-        break;
-
-	case FD_SOCKET_SYNC:
-	case FD_SOCKET_ASYNC:
-
-        ret = recv(fdTable[fd].fid.sock, buf, len, 0);
-	    if (ret == SOCKET_ERROR) 
-        {
-		    fdTable[fd].Errno = WSAGetLastError();
-		    ret = -1;
-	    }
-
-        break;
-        
-    default:
-
-        ASSERT(0);
-    }
-
-    return ret;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_Write --
- *
- *	Perform a synchronous OS write.
- *
- * Results:
- *	Returns number of bytes written. Mimics unix write:
- *		n bytes written, 0 or -1 failure (??? couldn't find man page).
- *
- * Side effects:
- *	none.
- *
- *--------------------------------------------------------------
- */
-int OS_Write(int fd, char * buf, size_t len)
-{
-    DWORD bytesWritten;
-    int ret = -1;
-
-    ASSERT(fd >= 0 && fd < WIN32_OPEN_MAX);
-
-    if (shutdownNow) return -1;
-
-    switch (fdTable[fd].type) 
-    {
-	case FD_FILE_SYNC:
-	case FD_FILE_ASYNC:
-	case FD_PIPE_SYNC:
-	case FD_PIPE_ASYNC:
-
-        if (WriteFile(fdTable[fd].fid.fileHandle, buf, len, &bytesWritten, NULL)) 
-        {
-            ret = bytesWritten;
-        }
-        else
-        {
-		    fdTable[fd].Errno = GetLastError();
-	    }
-
-        break;
-
-	case FD_SOCKET_SYNC:
-	case FD_SOCKET_ASYNC:
-
-        ret = send(fdTable[fd].fid.sock, buf, len, 0);
-        if (ret == SOCKET_ERROR) 
-        {
-		    fdTable[fd].Errno = WSAGetLastError();
-		    ret = -1;
-	    }
-
-        break;
-
-    default:
-
-        ASSERT(0);
-    }
-
-    return ret;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_SpawnChild --
- *
- *	Spawns a new server listener process, and stores the information
- *      relating to the child in the supplied record.  A wait handler is
- *	registered on the child's completion.  This involves creating
- *        a process on NT and preparing a command line with the required
- *        state (currently a -childproc flag and the server socket to use
- *        for accepting connections).
- *
- * Results:
- *      0 if success, -1 if error.
- *
- * Side effects:
- *      Child process spawned.
- *
- *----------------------------------------------------------------------
- */
-int OS_SpawnChild(char *execPath, int listenFd, PROCESS_INFORMATION *pInfo, char *env)
-{
-    STARTUPINFO StartupInfo;
-    BOOL success;
-
-    memset((void *)&StartupInfo, 0, sizeof(STARTUPINFO));
-    StartupInfo.cb = sizeof (STARTUPINFO);
-    StartupInfo.lpReserved = NULL;
-    StartupInfo.lpReserved2 = NULL;
-    StartupInfo.cbReserved2 = 0;
-    StartupInfo.lpDesktop = NULL;
-	StartupInfo.wShowWindow = SW_HIDE;
-    /*
-     * FastCGI on NT will set the listener pipe HANDLE in the stdin of
-     * the new process.  The fact that there is a stdin and NULL handles
-     * for stdout and stderr tells the FastCGI process that this is a
-     * FastCGI process and not a CGI process.
-     */
-    StartupInfo.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
-    /*
-     * XXX: Do I have to dup the handle before spawning the process or is
-     *      it sufficient to use the handle as it's reference counted
-     *      by NT anyway?
-     */
-    StartupInfo.hStdInput  = fdTable[listenFd].fid.fileHandle;
-    StartupInfo.hStdOutput = INVALID_HANDLE_VALUE;
-    StartupInfo.hStdError  = INVALID_HANDLE_VALUE;
-
-    /*
-     * Make the listener socket inheritable.
-     */
-    success = SetHandleInformation(StartupInfo.hStdInput, HANDLE_FLAG_INHERIT,
-				   TRUE);
-    if(!success) {
-        //exit(99);
-		return -1;
-    }
-
-    /*
-     * XXX: Might want to apply some specific security attributes to the
-     *      processes.
-     */
-    success = CreateProcess(execPath,	/* LPCSTR address of module name */
-			NULL,           /* LPCSTR address of command line */
-		        NULL,		/* Process security attributes */
-			NULL,		/* Thread security attributes */
-			TRUE,		/* Inheritable Handes inherited. */
-			0,		/* DWORD creation flags  */
-		    env,           /* Use parent environment block */
-			NULL,		/* Address of current directory name */
-			&StartupInfo,   /* Address of STARTUPINFO  */
-			pInfo);	/* Address of PROCESS_INFORMATION   */
-    if(success) {
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_AsyncReadStdin --
- *
- *	This initiates an asynchronous read on the standard
- *	input handle.  This handle is not guaranteed to be
- *      capable of performing asynchronous I/O so we send a
- *      message to the StdinThread to do the synchronous read.
- *
- * Results:
- *	-1 if error, 0 otherwise.
- *
- * Side effects:
- *	Asynchronous message is queued to the StdinThread and an
- *      overlapped structure is allocated/initialized.
- *
- *--------------------------------------------------------------
- */
-int OS_AsyncReadStdin(void *buf, int len, OS_AsyncProc procPtr,
-                      ClientData clientData)
-{
-    POVERLAPPED_REQUEST pOv;
-
-    ASSERT(fdTable[STDIN_FILENO].type != FD_UNUSED);
-
-    pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
-    ASSERT(pOv);
-    memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
-    pOv->clientData1 = (ClientData)buf;
-    pOv->instance = fdTable[STDIN_FILENO].instance;
-    pOv->procPtr = procPtr;
-    pOv->clientData = clientData;
-
-    PostQueuedCompletionStatus(hStdinCompPort, len, STDIN_FILENO,
-                               (LPOVERLAPPED)pOv);
-    return 0;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_AsyncRead --
- *
- *	This initiates an asynchronous read on the file
- *	handle which may be a socket or named pipe.
- *
- *	We also must save the ProcPtr and ClientData, so later
- *	when the io completes, we know who to call.
- *
- *	We don't look at any results here (the ReadFile may
- *	return data if it is cached) but do all completion
- *	processing in OS_Select when we get the io completion
- *	port done notifications.  Then we call the callback.
- *
- * Results:
- *	-1 if error, 0 otherwise.
- *
- * Side effects:
- *	Asynchronous I/O operation is queued for completion.
- *
- *--------------------------------------------------------------
- */
-int OS_AsyncRead(int fd, int offset, void *buf, int len,
-		 OS_AsyncProc procPtr, ClientData clientData)
-{
-    DWORD bytesRead;
-    POVERLAPPED_REQUEST pOv;
-
-    /*
-     * Catch any bogus fd values
-     */
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-    /*
-     * Confirm that this is an async fd
-     */
-    ASSERT(fdTable[fd].type != FD_UNUSED);
-    ASSERT(fdTable[fd].type != FD_FILE_SYNC);
-    ASSERT(fdTable[fd].type != FD_PIPE_SYNC);
-    ASSERT(fdTable[fd].type != FD_SOCKET_SYNC);
-
-    pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
-    ASSERT(pOv);
-    memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
-    /*
-     * Only file offsets should be non-zero, but make sure.
-     */
-    if (fdTable[fd].type == FD_FILE_ASYNC)
-	if (fdTable[fd].offset >= 0)
-	    pOv->overlapped.Offset = fdTable[fd].offset;
-	else
-	    pOv->overlapped.Offset = offset;
-    pOv->instance = fdTable[fd].instance;
-    pOv->procPtr = procPtr;
-    pOv->clientData = clientData;
-    bytesRead = fd;
-    /*
-     * ReadFile returns: TRUE success, FALSE failure
-     */
-    if (!ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead,
-	(LPOVERLAPPED)pOv)) {
-	fdTable[fd].Errno = GetLastError();
-	if(fdTable[fd].Errno == ERROR_NO_DATA ||
-	   fdTable[fd].Errno == ERROR_PIPE_NOT_CONNECTED) {
-	    PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
-	    return 0;
-	}
-	if(fdTable[fd].Errno != ERROR_IO_PENDING) {
-	    PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
-	    return -1;
-	}
-	fdTable[fd].Errno = 0;
-    }
-    return 0;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_AsyncWrite --
- *
- *	This initiates an asynchronous write on the "fake" file
- *	descriptor (which may be a file, socket, or named pipe).
- *	We also must save the ProcPtr and ClientData, so later
- *	when the io completes, we know who to call.
- *
- *	We don't look at any results here (the WriteFile generally
- *	completes immediately) but do all completion processing
- *	in OS_DoIo when we get the io completion port done
- *	notifications.  Then we call the callback.
- *
- * Results:
- *	-1 if error, 0 otherwise.
- *
- * Side effects:
- *	Asynchronous I/O operation is queued for completion.
- *
- *--------------------------------------------------------------
- */
-int OS_AsyncWrite(int fd, int offset, void *buf, int len,
-		  OS_AsyncProc procPtr, ClientData clientData)
-{
-    DWORD bytesWritten;
-    POVERLAPPED_REQUEST pOv;
-
-    /*
-     * Catch any bogus fd values
-     */
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-    /*
-     * Confirm that this is an async fd
-     */
-    ASSERT(fdTable[fd].type != FD_UNUSED);
-    ASSERT(fdTable[fd].type != FD_FILE_SYNC);
-    ASSERT(fdTable[fd].type != FD_PIPE_SYNC);
-    ASSERT(fdTable[fd].type != FD_SOCKET_SYNC);
-
-    pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
-    ASSERT(pOv);
-    memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
-    /*
-     * Only file offsets should be non-zero, but make sure.
-     */
-    if (fdTable[fd].type == FD_FILE_ASYNC)
-	/*
-	 * Only file opened via OS_AsyncWrite with
-	 * O_APPEND will have an offset != -1.
-	 */
-	if (fdTable[fd].offset >= 0)
-	    /*
-	     * If the descriptor has a memory mapped file
-	     * handle, take the offsets from there.
-	     */
-	    if (fdTable[fd].hMapMutex != NULL) {
-		/*
-		 * Wait infinitely; this *should* not cause problems.
-		 */
-		WaitForSingleObject(fdTable[fd].hMapMutex, INFINITE);
-
-		/*
-		 * Retrieve the shared offset values.
-		 */
-		pOv->overlapped.OffsetHigh = *(fdTable[fd].offsetHighPtr);
-		pOv->overlapped.Offset = *(fdTable[fd].offsetLowPtr);
-
-		/*
-		 * Update the shared offset values for the next write
-		 */
-		*(fdTable[fd].offsetHighPtr) += 0;	/* XXX How do I handle overflow */
-		*(fdTable[fd].offsetLowPtr) += len;
-
-		ReleaseMutex(fdTable[fd].hMapMutex);
-	    } else
-	        pOv->overlapped.Offset = fdTable[fd].offset;
-	else
-	    pOv->overlapped.Offset = offset;
-    pOv->instance = fdTable[fd].instance;
-    pOv->procPtr = procPtr;
-    pOv->clientData = clientData;
-    bytesWritten = fd;
-    /*
-     * WriteFile returns: TRUE success, FALSE failure
-     */
-    if (!WriteFile(fdTable[fd].fid.fileHandle, buf, len, &bytesWritten,
-	(LPOVERLAPPED)pOv)) {
-	fdTable[fd].Errno = GetLastError();
-	if(fdTable[fd].Errno != ERROR_IO_PENDING) {
-	    PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
-	    return -1;
-	}
-	fdTable[fd].Errno = 0;
-    }
-    if (fdTable[fd].offset >= 0)
-	fdTable[fd].offset += len;
-    return 0;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_Close --
- *
- *	Closes the descriptor with routine appropriate for
- *      descriptor's type.
- *
- * Results:
- *	Socket or file is closed. Return values mimic Unix close:
- *		0 success, -1 failure
- *
- * Side effects:
- *	Entry in fdTable is marked as free.
- *
- *--------------------------------------------------------------
- */
-int OS_Close(int fd)
-{
-    int ret = 0;
-
-    /*
-     * Catch it if fd is a bogus value
-     */
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-    ASSERT(fdTable[fd].type != FD_UNUSED);
-
-    switch (fdTable[fd].type) {
-	case FD_PIPE_SYNC:
-	case FD_PIPE_ASYNC:
-	case FD_FILE_SYNC:
-	case FD_FILE_ASYNC:
-        /*
-         * CloseHandle returns: TRUE success, 0 failure
-         */
-        /*
-        XXX don't close here, fcgi apps fail if we do so
-        need to examine resource leaks if any might exist
-		if (CloseHandle(fdTable[fd].fid.fileHandle) == FALSE)
-			ret = -1;
-	*/
-        break;
-    case FD_SOCKET_SYNC:
-	case FD_SOCKET_ASYNC:
-	    /*
-	     * Closing a socket that has an async read outstanding causes a
-	     * tcp reset and possible data loss.  The shutdown call seems to
-	     * prevent this.
-	     */
-
-        /* shutdown(fdTable[fd].fid.sock, SD_BOTH); */
-
-        {
-        char buf[16];
-        int r;
-
-        shutdown(fdTable[fd].fid.sock,SD_SEND);
-
-        do
-        { 
-            r = recv(fdTable[fd].fid.sock,buf,16,0);
-        } while (r > 0);
-        }
-        /*
-	     * closesocket returns: 0 success, SOCKET_ERROR failure
-	     */
-	    if (closesocket(fdTable[fd].fid.sock) == SOCKET_ERROR)
-			ret = -1;
-	    break;
-	default:
-	    return -1;		/* fake failure */
-    }
-
-    Win32FreeDescriptor(fd);
-    return ret;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_CloseRead --
- *
- *	Cancel outstanding asynchronous reads and prevent subsequent
- *      reads from completing.
- *
- * Results:
- *	Socket or file is shutdown. Return values mimic Unix shutdown:
- *		0 success, -1 failure
- *
- *--------------------------------------------------------------
- */
-int OS_CloseRead(int fd)
-{
-    int ret = 0;
-
-    /*
-     * Catch it if fd is a bogus value
-     */
-    ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-    ASSERT(fdTable[fd].type == FD_SOCKET_ASYNC
-	|| fdTable[fd].type == FD_SOCKET_SYNC);
-
-    if (shutdown(fdTable[fd].fid.sock,SD_RECEIVE) == SOCKET_ERROR)
-	ret = -1;
-    return ret;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * OS_DoIo --
- *
- *	This function was formerly OS_Select.  It's purpose is
- *      to pull I/O completion events off the queue and dispatch
- *      them to the appropriate place.
- *
- * Results:
- *	Returns 0.
- *
- * Side effects:
- *	Handlers are called.
- *
- *--------------------------------------------------------------
- */
-int OS_DoIo(struct timeval *tmo)
-{
-    unsigned long fd;
-    unsigned long bytes;
-    POVERLAPPED_REQUEST pOv;
-    struct timeb tb;
-    int ms;
-    int ms_last;
-    int err;
-
-    /* XXX
-     * We can loop in here, but not too long, as wait handlers
-     * must run.
-     * For cgi stdin, apparently select returns when io completion
-     * ports don't, so don't wait the full timeout.
-     */
-    if(tmo)
-	ms = (tmo->tv_sec*1000 + tmo->tv_usec/1000) / 2;
-    else
-	ms = 1000;
-    ftime(&tb);
-    ms_last = tb.time*1000 + tb.millitm;
-    while (ms >= 0) {
-	if(tmo && (ms = tmo->tv_sec*1000 + tmo->tv_usec/1000)> 100)
-	    ms = 100;
-	if (!GetQueuedCompletionStatus(hIoCompPort, &bytes, &fd,
-	    (LPOVERLAPPED *)&pOv, ms) && !pOv) {
-	    err = WSAGetLastError();
-	    return 0; /* timeout */
-        }
-
-	ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
-	/* call callback if descriptor still valid */
-	ASSERT(pOv);
-	if(pOv->instance == fdTable[fd].instance)
-	  (*pOv->procPtr)(pOv->clientData, bytes);
-	free(pOv);
-
-	ftime(&tb);
-	ms -= (tb.time*1000 + tb.millitm - ms_last);
-	ms_last = tb.time*1000 + tb.millitm;
-    }
-    return 0;
-}
-
-static int isAddrOK(struct sockaddr_in * inet_sockaddr, const char * okAddrs)
-{
-    static const char *token = " ,;:\t";
-    char *ipaddr;
-    char *p;
-
-    if (okAddrs == NULL) return TRUE;
-
-    ipaddr = inet_ntoa(inet_sockaddr->sin_addr);
-    p = strstr(okAddrs, ipaddr);
-
-    if (p == NULL) return FALSE;
-
-    if (p == okAddrs)
-    {
-        p += strlen(ipaddr);
-        return (strchr(token, *p) != NULL);
-    }
-
-    if (strchr(token, *--p) != NULL)
-    {
-        p += strlen(ipaddr) + 1;
-        return (strchr(token, *p) != NULL);
-    }
-
-    return FALSE;
-}
-
-#ifndef NO_WSAACEPT
-static int CALLBACK isAddrOKCallback(LPWSABUF  lpCallerId,
-                                     LPWSABUF  dc0,
-                                     LPQOS     dc1,
-                                     LPQOS     dc2,
-                                     LPWSABUF  dc3,
-                                     LPWSABUF  dc4,
-                                     GROUP     *dc5,
-                                     DWORD     data)
-{
-    struct sockaddr_in *sockaddr = (struct sockaddr_in *) lpCallerId->buf;
-
-    // Touch the args to avoid warnings
-    dc0 = NULL; dc1 = NULL; dc2 = NULL; dc3 = NULL; dc4 = NULL; dc5 = NULL;
-
-    if ((void *) data == NULL) return CF_ACCEPT;
-
-    if (sockaddr->sin_family != AF_INET) return CF_ACCEPT;
-
-    return isAddrOK(sockaddr, (const char *) data) ? CF_ACCEPT : CF_REJECT;
-}
-#endif
-
-static printLastError(const char * text)
-{
-    LPVOID buf;
-
-    FormatMessage( 
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-        FORMAT_MESSAGE_FROM_SYSTEM | 
-        FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
-        GetLastError(),
-        0,
-        (LPTSTR) &buf,
-        0,
-        NULL 
-    );
-    
-    fprintf(stderr, "%s: %s\n", text, (LPCTSTR) buf);
-    LocalFree(buf);
-}
-
-static int acceptNamedPipe()
-{
-    int ipcFd = -1;
-
-    if (! ConnectNamedPipe(hListen, &listenOverlapped))
-    {
-        switch (GetLastError())
-        {
-            case ERROR_PIPE_CONNECTED:
-
-                // A client connected after CreateNamedPipe but
-                // before ConnectNamedPipe. Its a good connection.
-
-                break;
-        
-            case ERROR_IO_PENDING:
-
-                // Wait for a connection to complete.
-
-                while (WaitForSingleObject(listenOverlapped.hEvent, 
-                                           ACCEPT_TIMEOUT) == WAIT_TIMEOUT) 
-                {
-                    if (shutdownPending) 
-                    {
-                        OS_LibShutdown();
-                        return -1;
-                    }            
-                }
-
-                break;
-
-            case ERROR_PIPE_LISTENING:
-
-                // The pipe handle is in nonblocking mode.
-
-            case ERROR_NO_DATA:
-
-                // The previous client closed its handle (and we failed
-                // to call DisconnectNamedPipe)
-
-            default:
-
-                printLastError("unexpected ConnectNamedPipe() error");
-        }
-    }
-
-    //
-    // impersonate the client
-    //
-    if(bImpersonate && !ImpersonateNamedPipeClient(hListen)) {
-        DisconnectNamedPipe(hListen);
-    } else {
-		ipcFd = Win32NewDescriptor(FD_PIPE_SYNC, (int) hListen, -1);
-		if (ipcFd == -1) 
-		{
-			DisconnectNamedPipe(hListen);
-			if (bImpersonate) RevertToSelf();
-		}
-	}
-
-    return ipcFd;
-}
-
-static int acceptSocket(const char *webServerAddrs)
-{
-    SOCKET hSock;
-    int ipcFd = -1;
-
-    for (;;)
-    {
-        struct sockaddr sockaddr;
-        int sockaddrLen = sizeof(sockaddr);
-
-        for (;;)
-        {
-            const struct timeval timeout = {1, 0};
-            fd_set readfds;
-
-            FD_ZERO(&readfds);
-            FD_SET((unsigned int) hListen, &readfds);
-
-            if (select(0, &readfds, NULL, NULL, &timeout) == 0)
-            {
-                if (shutdownPending) 
-                {
-                    OS_LibShutdown();
-                    return -1;
-                }
-            }
-            else 
-            {
-                break;
-            }
-        }
-    
-#if NO_WSAACEPT
-        hSock = accept((SOCKET) hListen, &sockaddr, &sockaddrLen);
-
-        if (hSock == INVALID_SOCKET)
-        {
-            break;
-        }
-
-        if (isAddrOK((struct sockaddr_in *) &sockaddr, webServerAddrs))
-        {
-            break;
-        }
-
-        closesocket(hSock);
-#else
-        hSock = WSAAccept((unsigned int) hListen,                    
-                          &sockaddr,  
-                          &sockaddrLen,               
-                          isAddrOKCallback,  
-                          (DWORD) webServerAddrs);
-
-        if (hSock != INVALID_SOCKET)
-        {
-            break;
-        }
-        
-        if (WSAGetLastError() != WSAECONNREFUSED)
-        {
-            break;
-        }
-#endif
-    }
-
-    if (hSock == INVALID_SOCKET) 
-    {
-        /* Use FormatMessage() */
-        fprintf(stderr, "accept()/WSAAccept() failed: %d", WSAGetLastError());
-        return -1;
-    }
-    
-    ipcFd = Win32NewDescriptor(FD_SOCKET_SYNC, hSock, -1);
-	if (ipcFd == -1) 
-    {
-	    closesocket(hSock);
-	}
-
-    return ipcFd;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_Accept --
- *
- *  Accepts a new FastCGI connection.  This routine knows whether
- *  we're dealing with TCP based sockets or NT Named Pipes for IPC.
- *
- *  fail_on_intr is ignored in the Win lib.
- *
- * Results:
- *      -1 if the operation fails, otherwise this is a valid IPC fd.
- *
- *----------------------------------------------------------------------
- */
-int OS_Accept(int listen_sock, int fail_on_intr, const char *webServerAddrs)
-{
-    int ipcFd = -1;
-
-    // Touch args to prevent warnings
-    listen_sock = 0; fail_on_intr = 0;
-
-    // @todo Muliple listen sockets and sockets other than 0 are not
-    // supported due to the use of globals.
-
-    if (shutdownPending) 
-    {
-        OS_LibShutdown();
-        return -1;
-    }
-
-    // The mutex is to keep other processes (and threads, when supported)
-    // from going into the accept cycle.  The accept cycle needs to
-    // periodically break out to check the state of the shutdown flag
-    // and there's no point to having more than one thread do that.
-    
-    if (acceptMutex != INVALID_HANDLE_VALUE) 
-    {
-		DWORD ret;
-        while ((ret = WaitForSingleObject(acceptMutex, ACCEPT_TIMEOUT)) == WAIT_TIMEOUT) 
-        {
-			if (shutdownPending) break;
-		}
-		if (ret == WAIT_FAILED) {
-            printLastError("WaitForSingleObject() failed");
-            return -1;
-        }
-    }
-    
-    if (shutdownPending) 
-    {
-        OS_LibShutdown();
-    }
-    else if (listenType == FD_PIPE_SYNC) 
-    {
-        ipcFd = acceptNamedPipe();
-    }
-    else if (listenType == FD_SOCKET_SYNC)
-    {
-        ipcFd = acceptSocket(webServerAddrs);
-    }
-    else
-    {
-        fprintf(stderr, "unknown listenType (%d)\n", listenType);
-    }
-	    
-    if (acceptMutex != INVALID_HANDLE_VALUE) 
-    {
-        ReleaseMutex(acceptMutex);
-    }
-
-    return ipcFd;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_IpcClose
- *
- *	OS IPC routine to close an IPC connection.
- *
- * Results:
- *
- *
- * Side effects:
- *      IPC connection is closed.
- *
- *----------------------------------------------------------------------
- */
-int OS_IpcClose(int ipcFd)
-{
-    if (ipcFd == -1)
-        return 0;
-
-    /*
-     * Catch it if fd is a bogus value
-     */
-    ASSERT((ipcFd >= 0) && (ipcFd < WIN32_OPEN_MAX));
-    ASSERT(fdTable[ipcFd].type != FD_UNUSED);
-
-    switch(listenType) {
-
-    case FD_PIPE_SYNC:
-	/*
-	 * Make sure that the client (ie. a Web Server in this case) has
-	 * read all data from the pipe before we disconnect.
-	 */
-	if(!FlushFileBuffers(fdTable[ipcFd].fid.fileHandle))
-	    return -1;
-	if(DisconnectNamedPipe(fdTable[ipcFd].fid.fileHandle)) {
-	    OS_Close(ipcFd);
-		if (bImpersonate) RevertToSelf();
-	    return 0;
-	} else {
-	    return -1;
-	}
-	break;
-
-    case FD_SOCKET_SYNC:
-	OS_Close(ipcFd);
-        return 0;
-	break;
-
-    case FD_UNUSED:
-    default:
-	//exit(106);
-	return -1;
-	break;
-    }
-	return -1;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_IsFcgi --
- *
- *	Determines whether this process is a FastCGI process or not.
- *
- * Results:
- *      Returns 1 if FastCGI, 0 if not.
- *
- * Side effects:
- *      None.
- *
- *----------------------------------------------------------------------
- */
-int OS_IsFcgi(int sock)
-{
-    // Touch args to prevent warnings
-    sock = 0;
-
-    /* XXX This is broken for sock */
-
-	return (listenType != FD_UNUSED); 
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * OS_SetFlags --
- *
- *      Sets selected flag bits in an open file descriptor.  Currently
- *      this is only to put a SOCKET into non-blocking mode.
- *
- *----------------------------------------------------------------------
- */
-void OS_SetFlags(int fd, int flags)
-{
-    unsigned long pLong = 1L;
-
-    if (fdTable[fd].type == FD_SOCKET_SYNC && flags == O_NONBLOCK) {
-        if (ioctlsocket(fdTable[fd].fid.sock, FIONBIO, &pLong) ==
-	        SOCKET_ERROR) {
-	    //exit(WSAGetLastError());
-			SetLastError(WSAGetLastError());
-			return;
-        }
-        if (!CreateIoCompletionPort((HANDLE)fdTable[fd].fid.sock,
-				    hIoCompPort, fd, 1)) {
-	    //err = GetLastError();
-	    //exit(err);
-			return;
-	}
-
-        fdTable[fd].type = FD_SOCKET_ASYNC;
-    }
-    return;
-}
-