* significantly more enjoyable.)
*/
#ifndef lint
-static const char rcsid[] = "$Id: os_win32.c,v 1.12 2001/03/30 16:49:22 robs Exp $";
+static const char rcsid[] = "$Id: os_win32.c,v 1.22 2001/09/04 18:44:11 robs Exp $";
#endif /* not lint */
-#include "fcgi_config.h"
-
-#define DLLAPI __declspec(dllexport)
-
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <winsock2.h>
+#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <sys/timeb.h>
-#include <Winsock2.h>
-#include <Windows.h>
-#include "fcgios.h"
+#define DLLAPI __declspec(dllexport)
-#define ASSERT assert
+#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 MUTEX_VARNAME "_FCGI_MUTEX_"
#define SHUTDOWN_EVENT_NAME "_FCGI_SHUTDOWN_EVENT_"
#define LOCALHOST "localhost"
static const char *bindPathPrefix = "\\\\.\\pipe\\FastCGI\\";
-static enum FILE_TYPE listenType = FD_UNUSED;
+static FILE_TYPE listenType = FD_UNUSED;
// XXX This should be a DESCRIPTOR
static HANDLE hListen = INVALID_HANDLE_VALUE;
index = desiredFd;
}
}
- else
+ else if (fd > 0)
{
- if (fd > 0 && fd < WIN32_OPEN_MAX)
+ if (fd < WIN32_OPEN_MAX && fdTable[fd].type == FD_UNUSED)
{
- if (fdTable[fd].type == FD_UNUSED)
- {
- index = fd;
- }
- else
- {
- int i;
+ index = fd;
+ }
+ else
+ {
+ int i;
- for (i = 1; i < WIN32_OPEN_MAX; ++i)
+ for (i = 1; i < WIN32_OPEN_MAX; ++i)
+ {
+ if (fdTable[i].type == FD_UNUSED)
{
- if (fdTable[i].type == FD_UNUSED)
- {
- index = i;
- break;
- }
+ index = i;
+ break;
}
}
}
}
-
if (index != -1)
{
static void StdinThread(LPDWORD startup){
int doIo = TRUE;
- int fd;
- int bytesRead;
+ 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
if (WaitForSingleObject(shutdownEvent, INFINITE) == WAIT_FAILED)
{
// Assuming it will happen again, all we can do is exit the thread
- return -1;
+ return 1;
}
else
{
{
HANDLE shutdownEvent = (HANDLE) atoi(val);
- putenv(SHUTDOWN_EVENT_NAME"=");
-
if (! CreateThread(NULL, 0, ShutdownRequestThread,
shutdownEvent, 0, NULL))
{
void OS_LibShutdown()
{
- if(hIoCompPort != INVALID_HANDLE_VALUE) {
+ if (hIoCompPort != INVALID_HANDLE_VALUE)
+ {
CloseHandle(hIoCompPort);
- hIoCompPort = INVALID_HANDLE_VALUE;
+ hIoCompPort = INVALID_HANDLE_VALUE;
}
- if(hStdinCompPort != INVALID_HANDLE_VALUE) {
+ if (hStdinCompPort != INVALID_HANDLE_VALUE)
+ {
CloseHandle(hStdinCompPort);
- hStdinCompPort = INVALID_HANDLE_VALUE;
+ hStdinCompPort = INVALID_HANDLE_VALUE;
}
- /*
- * Shutdown the socket library.
- */
+ if (acceptMutex != INVALID_HANDLE_VALUE)
+ {
+ ReleaseMutex(acceptMutex);
+ }
+
+ DisconnectNamedPipe(hListen);
+
+ CancelIo(hListen);
+
+
WSACleanup();
- return;
}
/*
strncpy(buf, p, 6);
buf[5] = '\0';
- port = atoi(buf);
+ port = (short) atoi(buf);
}
return port;
if (mutex == NULL)
{
- return -1;
+ return -2;
}
if (! SetHandleInformation(mutex, HANDLE_FLAG_INHERIT, TRUE))
{
- return -1;
+ return -3;
}
// This is a nail for listening to more than one port..
listenSock = socket(AF_INET, SOCK_STREAM, 0);
if (listenSock == INVALID_SOCKET)
{
- return -1;
+ return -4;
}
- if (! bind(listenSock, (struct sockaddr *) &sockAddr, sockLen)
- || ! listen(listenSock, backlog))
+ if (bind(listenSock, (struct sockaddr *) &sockAddr, sockLen) )
{
- return -1;
+ return -12;
+ }
+
+ if (listen(listenSock, backlog))
+ {
+ return -5;
}
pseudoFd = Win32NewDescriptor(listenType, listenSock, -1);
if (pseudoFd == -1)
{
closesocket(listenSock);
- return -1;
+ return -6;
}
hListen = (HANDLE) listenSock;
if (! pipePath)
{
- return -1;
+ return -7;
}
strcpy(pipePath, bindPathPrefix);
if (hListenPipe == INVALID_HANDLE_VALUE)
{
- return -1;
+ return -8;
}
if (! SetHandleInformation(hListenPipe, HANDLE_FLAG_INHERIT, TRUE))
{
- return -1;
+ return -9;
}
pseudoFd = Win32NewDescriptor(listenType, (int) hListenPipe, -1);
if (pseudoFd == -1)
{
CloseHandle(hListenPipe);
- return -1;
+ return -10;
}
hListen = (HANDLE) hListenPipe;
int OS_Read(int fd, char * buf, size_t len)
{
DWORD bytesRead;
- int ret;
+ int ret = -1;
- /*
- * Catch any bogus fd values
- */
ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
- switch (fdTable[fd].type) {
+ switch (fdTable[fd].type)
+ {
case FD_FILE_SYNC:
case FD_FILE_ASYNC:
case FD_PIPE_SYNC:
case FD_PIPE_ASYNC:
- bytesRead = fd;
- /*
- * ReadFile returns: TRUE success, FALSE failure
- */
- if (!ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead,
- NULL)) {
- fdTable[fd].Errno = GetLastError();
- return -1;
+
+ if (ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead, NULL))
+ {
+ ret = bytesRead;
+ }
+ else
+ {
+ fdTable[fd].Errno = GetLastError();
}
- return bytesRead;
+
+ break;
case FD_SOCKET_SYNC:
case FD_SOCKET_ASYNC:
- /* winsock recv returns n bytes recv'ed, SOCKET_ERROR failure */
- /*
- * XXX: Test this with ReadFile. If it works, remove this code
- * to simplify the routine.
- */
- if ((ret = recv(fdTable[fd].fid.sock, buf, len, 0)) ==
- SOCKET_ERROR) {
- fdTable[fd].Errno = WSAGetLastError();
- return -1;
+
+ ret = recv(fdTable[fd].fid.sock, buf, len, 0);
+ if (ret == SOCKET_ERROR)
+ {
+ fdTable[fd].Errno = WSAGetLastError();
+ ret = -1;
}
- return ret;
- default:
- return -1;
+
+ break;
+
+ default:
+
+ ASSERT(0);
}
+
+ return ret;
}
/*
int OS_Write(int fd, char * buf, size_t len)
{
DWORD bytesWritten;
- int ret;
+ int ret = -1;
- /*
- * Catch any bogus fd values
- */
- ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
- ASSERT((fdTable[fd].type > FD_UNUSED) &&
- (fdTable[fd].type <= FD_PIPE_ASYNC));
+ ASSERT(fd >= 0 && fd < WIN32_OPEN_MAX);
- switch (fdTable[fd].type) {
+ switch (fdTable[fd].type)
+ {
case FD_FILE_SYNC:
case FD_FILE_ASYNC:
case FD_PIPE_SYNC:
case FD_PIPE_ASYNC:
- bytesWritten = fd;
- /*
- * WriteFile returns: TRUE success, FALSE failure
- */
- if (!WriteFile(fdTable[fd].fid.fileHandle, buf, len,
- &bytesWritten, NULL)) {
- fdTable[fd].Errno = GetLastError();
- return -1;
+
+ if (WriteFile(fdTable[fd].fid.fileHandle, buf, len, &bytesWritten, NULL))
+ {
+ ret = bytesWritten;
+ }
+ else
+ {
+ fdTable[fd].Errno = GetLastError();
}
- return bytesWritten;
+
+ break;
+
case FD_SOCKET_SYNC:
case FD_SOCKET_ASYNC:
- /* winsock send returns n bytes written, SOCKET_ERROR failure */
- /*
- * XXX: Test this with WriteFile. If it works, remove this code
- * to simplify the routine.
- */
- if ((ret = send(fdTable[fd].fid.sock, buf, len, 0)) ==
- SOCKET_ERROR) {
- fdTable[fd].Errno = WSAGetLastError();
- return -1;
+
+ ret = send(fdTable[fd].fid.sock, buf, len, 0);
+ if (ret == SOCKET_ERROR)
+ {
+ fdTable[fd].Errno = WSAGetLastError();
+ ret = -1;
}
- return ret;
- default:
- return -1;
+
+ break;
+
+ default:
+
+ ASSERT(0);
}
+
+ return ret;
}
/*
*/
int OS_DoIo(struct timeval *tmo)
{
- int fd;
- int bytes;
+ unsigned long fd;
+ unsigned long bytes;
POVERLAPPED_REQUEST pOv;
struct timeb tb;
int ms;
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 CALLBACK isAddrOK(LPWSABUF lpCallerId,
- LPWSABUF dc0,
- LPQOS dc1,
- LPQOS dc2,
- LPWSABUF dc3,
- LPWSABUF dc4,
- GROUP *dc5,
- DWORD dwCallbackData)
+static int acceptNamedPipe()
{
- const char *okAddrs = (char *) dwCallbackData;
- struct sockaddr *sockaddr = (struct sockaddr *) lpCallerId->buf;
+ int ipcFd = -1;
- if (okAddrs == NULL || sockaddr->sa_family != AF_INET)
+ if (! ConnectNamedPipe(hListen, &listenOverlapped))
{
- return TRUE;
+ 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");
+ }
}
- else
+
+ ipcFd = Win32NewDescriptor(FD_PIPE_SYNC, (int) hListen, -1);
+ if (ipcFd == -1)
{
- static const char *token = " ,;:\t";
- struct sockaddr_in * inet_sockaddr = (struct sockaddr_in *) sockaddr;
- char *ipaddr = inet_ntoa(inet_sockaddr->sin_addr);
- char *p = strstr(okAddrs, ipaddr);
+ DisconnectNamedPipe(hListen);
+ }
- if (p == NULL)
+ 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)
{
- return FALSE;
+ break;
}
- else if (p == okAddrs)
+
+ if (isAddrOK((struct sockaddr_in *) &sockaddr, webServerAddrs))
{
- p += strlen(ipaddr);
- return (strchr(token, *p) != NULL);
+ break;
}
- else if (strchr(token, *--p))
+
+ closesocket(hSock);
+#else
+ hSock = WSAAccept((unsigned int) hListen,
+ &sockaddr,
+ &sockaddrLen,
+ isAddrOKCallback,
+ (DWORD) webServerAddrs);
+
+ if (hSock != INVALID_SOCKET)
{
- p += strlen(ipaddr) + 1;
- return (strchr(token, *p) != NULL);
+ break;
}
- else
+
+ if (WSAGetLastError() != WSAECONNREFUSED)
{
- return FALSE;
+ 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.
+ * 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.
*
- * Side effects:
- * New IPC connection is accepted.
- *
*----------------------------------------------------------------------
*/
int OS_Accept(int listen_sock, int fail_on_intr, const char *webServerAddrs)
{
- /* XXX This is broken for listen_sock & fail_on_intr */
int ipcFd = -1;
- BOOL pConnected;
- SOCKET hSock;
+
+ // 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;
}
{
if (WaitForSingleObject(acceptMutex, INFINITE) == WAIT_FAILED)
{
+ printLastError("WaitForSingleObject() failed");
return -1;
}
}
if (shutdownPending)
{
- if (acceptMutex != INVALID_HANDLE_VALUE)
- {
- ReleaseMutex(acceptMutex);
- }
- return -1;
+ OS_LibShutdown();
}
-
- if (listenType == FD_PIPE_SYNC)
+ else if (listenType == FD_PIPE_SYNC)
{
- pConnected = ConnectNamedPipe(hListen, &listenOverlapped)
- ? TRUE
- : (GetLastError() == ERROR_PIPE_CONNECTED);
-
- if (! pConnected)
- {
- while (WaitForSingleObject(listenOverlapped.hEvent, 1000) == WAIT_TIMEOUT)
- {
- if (shutdownPending)
- {
- if (acceptMutex != INVALID_HANDLE_VALUE)
- {
- ReleaseMutex(acceptMutex);
- }
- CancelIo(hListen);
- return -1;
- }
- }
- }
-
- if (acceptMutex != INVALID_HANDLE_VALUE)
- {
- ReleaseMutex(acceptMutex);
- }
-
- ipcFd = Win32NewDescriptor(FD_PIPE_SYNC, (int) hListen, -1);
- if (ipcFd == -1)
- {
- DisconnectNamedPipe(hListen);
- }
+ ipcFd = acceptNamedPipe();
}
else if (listenType == FD_SOCKET_SYNC)
{
- struct sockaddr sockaddr;
- int sockaddrLen = sizeof(sockaddr);
- fd_set readfds;
- const struct timeval timeout = {1, 0};
-
- FD_ZERO(&readfds);
- FD_SET((unsigned int) hListen, &readfds);
-
- while (select(0, &readfds, NULL, NULL, &timeout) == 0)
- {
- if (shutdownPending)
- {
- return -1;
- }
- }
-
- hSock = (webServerAddrs == NULL)
- ? accept((SOCKET) hListen,
- &sockaddr,
- &sockaddrLen)
- : WSAAccept((unsigned int) hListen,
- &sockaddr,
- &sockaddrLen,
- isAddrOK,
- (DWORD) webServerAddrs);
-
- if (acceptMutex != INVALID_HANDLE_VALUE)
- {
- ReleaseMutex(acceptMutex);
- }
-
- if (hSock == -1)
- {
- return -1;
- }
-
- ipcFd = Win32NewDescriptor(FD_SOCKET_SYNC, hSock, -1);
- if (ipcFd == -1)
- {
- closesocket(hSock);
- }
+ ipcFd = acceptSocket(webServerAddrs);
}
else
{
- ASSERT(0);
+ fprintf(stderr, "unknown listenType (%d)\n", listenType);
}
+ if (acceptMutex != INVALID_HANDLE_VALUE)
+ {
+ ReleaseMutex(acceptMutex);
+ }
+
return ipcFd;
}
*/
int OS_IsFcgi(int sock)
{
+ // Touch args to prevent warnings
+ sock = 0;
+
/* XXX This is broken for sock */
- if(listenType == FD_UNUSED) {
- return FALSE;
- } else {
- return TRUE;
- }
+
+ return (listenType != FD_UNUSED);
}
/*