5 * Copyright (c) 1995 Open Market, Inc.
8 * This file contains proprietary and confidential information and
9 * remains the unpublished property of Open Market, Inc. Use,
10 * disclosure, or reproduction is prohibited except as permitted by
11 * express written license agreement with Open Market, Inc.
14 * snapper@openmarket.com
16 * (Special thanks to Karen and Bill. They made my job much easier and
17 * significantly more enjoyable.)
20 static const char rcsid[] = "$Id: os_win32.c,v 1.19 2001/06/22 03:00:18 robs Exp $";
23 #define WIN32_LEAN_AND_MEAN
29 #include <sys/timeb.h>
31 #define DLLAPI __declspec(dllexport)
35 #define WIN32_OPEN_MAX 128 /* XXX: Small hack */
38 * millisecs to wait for a client connection before checking the
39 * shutdown flag (then go back to waiting for a connection, etc).
41 #define ACCEPT_TIMEOUT 1000
43 #define MUTEX_VARNAME "_FCGI_MUTEX_"
44 #define SHUTDOWN_EVENT_NAME "_FCGI_SHUTDOWN_EVENT_"
45 #define LOCALHOST "localhost"
47 static HANDLE hIoCompPort = INVALID_HANDLE_VALUE;
48 static HANDLE hStdinCompPort = INVALID_HANDLE_VALUE;
49 static HANDLE hStdinThread = INVALID_HANDLE_VALUE;
51 static HANDLE stdioHandles[3] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE,
52 INVALID_HANDLE_VALUE};
54 static HANDLE acceptMutex = INVALID_HANDLE_VALUE;
56 static BOOLEAN shutdownPending = FALSE;
59 * An enumeration of the file types
60 * supported by the FD_TABLE structure.
62 * XXX: Not all currently supported. This allows for future
82 * Structure used to map file handle and socket handle
83 * values into values that can be used to create unix-like
84 * select bitmaps, read/write for both sockets/files.
91 unsigned long instance;
93 int offset; /* only valid for async file writes */
94 LPDWORD offsetHighPtr; /* pointers to offset high and low words */
95 LPDWORD offsetLowPtr; /* only valid for async file writes (logs) */
96 HANDLE hMapMutex; /* mutex handle for multi-proc offset update */
97 LPVOID ovList; /* List of associated OVERLAPPED_REQUESTs */
101 * XXX Note there is no dyanmic sizing of this table, so if the
102 * number of open file descriptors exceeds WIN32_OPEN_MAX the
105 static struct FD_TABLE fdTable[WIN32_OPEN_MAX];
107 static CRITICAL_SECTION fdTableCritical;
109 struct OVERLAPPED_REQUEST {
110 OVERLAPPED overlapped;
111 unsigned long instance; /* file instance (won't match after a close) */
112 OS_AsyncProc procPtr; /* callback routine */
113 ClientData clientData; /* callback argument */
114 ClientData clientData1; /* additional clientData */
116 typedef struct OVERLAPPED_REQUEST *POVERLAPPED_REQUEST;
118 static const char *bindPathPrefix = "\\\\.\\pipe\\FastCGI\\";
120 static enum FILE_TYPE listenType = FD_UNUSED;
122 // XXX This should be a DESCRIPTOR
123 static HANDLE hListen = INVALID_HANDLE_VALUE;
125 static OVERLAPPED listenOverlapped;
126 static BOOLEAN libInitialized = FALSE;
129 *--------------------------------------------------------------
131 * Win32NewDescriptor --
133 * Set up for I/O descriptor masquerading.
136 * Returns "fake id" which masquerades as a UNIX-style "small
137 * non-negative integer" file/socket descriptor.
138 * Win32_* routine below will "do the right thing" based on the
139 * descriptor's actual type. -1 indicates failure.
142 * Entry in fdTable is reserved to represent the socket/file.
144 *--------------------------------------------------------------
146 static int Win32NewDescriptor(FILE_TYPE type, int fd, int desiredFd)
150 EnterCriticalSection(&fdTableCritical);
153 * If desiredFd is set, try to get this entry (this is used for
154 * mapping stdio handles). Otherwise try to get the fd entry.
155 * If this is not available, find a the first empty slot. .
157 if (desiredFd >= 0 && desiredFd < WIN32_OPEN_MAX)
159 if (fdTable[desiredFd].type == FD_UNUSED)
166 if (fd < WIN32_OPEN_MAX && fdTable[fd].type == FD_UNUSED)
174 for (i = 1; i < WIN32_OPEN_MAX; ++i)
176 if (fdTable[i].type == FD_UNUSED)
187 fdTable[index].fid.value = fd;
188 fdTable[index].type = type;
189 fdTable[index].path = NULL;
190 fdTable[index].Errno = NO_ERROR;
191 fdTable[index].status = 0;
192 fdTable[index].offset = -1;
193 fdTable[index].offsetHighPtr = fdTable[index].offsetLowPtr = NULL;
194 fdTable[index].hMapMutex = NULL;
195 fdTable[index].ovList = NULL;
198 LeaveCriticalSection(&fdTableCritical);
203 *--------------------------------------------------------------
207 * This thread performs I/O on stadard input. It is needed
208 * because you can't guarantee that all applications will
209 * create standard input with sufficient access to perform
210 * asynchronous I/O. Since we don't want to block the app
211 * reading from stdin we make it look like it's using I/O
212 * completion ports to perform async I/O.
215 * Data is read from stdin and posted to the io completion
221 *--------------------------------------------------------------
223 static void StdinThread(LPDWORD startup){
227 unsigned long bytesRead;
228 POVERLAPPED_REQUEST pOv;
230 // Touch the arg to prevent warning
235 * Block until a request to read from stdin comes in or a
236 * request to terminate the thread arrives (fd = -1).
238 if (!GetQueuedCompletionStatus(hStdinCompPort, &bytesRead, &fd,
239 (LPOVERLAPPED *)&pOv, (DWORD)-1) && !pOv) {
244 ASSERT((fd == STDIN_FILENO) || (fd == -1));
249 ASSERT(pOv->clientData1 != NULL);
251 if(ReadFile(stdioHandles[STDIN_FILENO], pOv->clientData1, bytesRead,
253 PostQueuedCompletionStatus(hIoCompPort, bytesRead,
254 STDIN_FILENO, (LPOVERLAPPED)pOv);
264 static DWORD WINAPI ShutdownRequestThread(LPVOID arg)
266 HANDLE shutdownEvent = (HANDLE) arg;
268 if (WaitForSingleObject(shutdownEvent, INFINITE) == WAIT_FAILED)
270 // Assuming it will happen again, all we can do is exit the thread
275 // "Simple reads and writes to properly-aligned 32-bit variables are atomic"
276 shutdownPending = TRUE;
278 // Before an accept() is entered the shutdownPending flag is checked.
279 // If set, OS_Accept() will return -1. If not, it waits
280 // on a connection request for one second, checks the flag, & repeats.
281 // Only one process/thread is allowed to do this at time by
282 // wrapping the accept() with mutex.
288 *--------------------------------------------------------------
292 * Set up the OS library for use.
295 * Returns 0 if success, -1 if not.
298 * Sockets initialized, pseudo file descriptors setup, etc.
300 *--------------------------------------------------------------
302 int OS_LibInit(int stdioFds[3])
309 char *cLenPtr = NULL;
315 InitializeCriticalSection(&fdTableCritical);
318 * Initialize windows sockets library.
320 wVersion = MAKEWORD(2,0);
321 err = WSAStartup( wVersion, &wsaData );
323 fprintf(stderr, "Error starting Windows Sockets. Error: %d",
329 * Create the I/O completion port to be used for our I/O queue.
331 if (hIoCompPort == INVALID_HANDLE_VALUE) {
332 hIoCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
334 if(hIoCompPort == INVALID_HANDLE_VALUE) {
335 printf("<H2>OS_LibInit Failed CreateIoCompletionPort! ERROR: %d</H2>\r\n\r\n",
342 * If a shutdown event is in the env, save it (I don't see any to
343 * remove it from the environment out from under the application).
344 * Spawn a thread to wait on the shutdown request.
346 val = getenv(SHUTDOWN_EVENT_NAME);
349 HANDLE shutdownEvent = (HANDLE) atoi(val);
351 if (! CreateThread(NULL, 0, ShutdownRequestThread,
352 shutdownEvent, 0, NULL))
359 * If an accept mutex is in the env, save it and remove it.
361 val = getenv(MUTEX_VARNAME);
364 acceptMutex = (HANDLE) atoi(val);
369 * Determine if this library is being used to listen for FastCGI
370 * connections. This is communicated by STDIN containing a
371 * valid handle to a listener object. In this case, both the
372 * "stdout" and "stderr" handles will be INVALID (ie. closed) by
373 * the starting process.
375 * The trick is determining if this is a pipe or a socket...
377 * XXX: Add the async accept test to determine socket or handle to a
380 if((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&
381 (GetStdHandle(STD_ERROR_HANDLE) == INVALID_HANDLE_VALUE) &&
382 (GetStdHandle(STD_INPUT_HANDLE) != INVALID_HANDLE_VALUE) )
384 DWORD pipeMode = PIPE_READMODE_BYTE | PIPE_WAIT;
385 HANDLE oldStdIn = GetStdHandle(STD_INPUT_HANDLE);
387 // Move the handle to a "low" number
388 if (! DuplicateHandle(GetCurrentProcess(), oldStdIn,
389 GetCurrentProcess(), &hListen,
390 0, TRUE, DUPLICATE_SAME_ACCESS))
395 if (! SetStdHandle(STD_INPUT_HANDLE, hListen))
400 CloseHandle(oldStdIn);
403 * Set the pipe handle state so that it operates in wait mode.
405 * NOTE: The listenFd is not mapped to a pseudo file descriptor
406 * as all work done on it is contained to the OS library.
408 * XXX: Initial assumption is that SetNamedPipeHandleState will
409 * fail if this is an IP socket...
411 if (SetNamedPipeHandleState(hListen, &pipeMode, NULL, NULL))
413 listenType = FD_PIPE_SYNC;
414 listenOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
418 listenType = FD_SOCKET_SYNC;
423 * If there are no stdioFds passed in, we're done.
425 if(stdioFds == NULL) {
431 * Setup standard input asynchronous I/O. There is actually a separate
432 * thread spawned for this purpose. The reason for this is that some
433 * web servers use anonymous pipes for the connection between itself
434 * and a CGI application. Anonymous pipes can't perform asynchronous
435 * I/O or use I/O completion ports. Therefore in order to present a
436 * consistent I/O dispatch model to an application we emulate I/O
437 * completion port behavior by having the standard input thread posting
438 * messages to the hIoCompPort which look like a complete overlapped
439 * I/O structure. This keeps the event dispatching simple from the
440 * application perspective.
442 stdioHandles[STDIN_FILENO] = GetStdHandle(STD_INPUT_HANDLE);
444 if(!SetHandleInformation(stdioHandles[STDIN_FILENO],
445 HANDLE_FLAG_INHERIT, 0)) {
447 * XXX: Causes error when run from command line. Check KB
448 err = GetLastError();
454 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
455 (int)stdioHandles[STDIN_FILENO],
456 STDIN_FILENO)) == -1) {
460 * Set stdin equal to our pseudo FD and create the I/O completion
461 * port to be used for async I/O.
463 stdioFds[STDIN_FILENO] = fakeFd;
467 * Create the I/O completion port to be used for communicating with
468 * the thread doing I/O on standard in. This port will carry read
469 * and possibly thread termination requests to the StdinThread.
471 if (hStdinCompPort == INVALID_HANDLE_VALUE) {
472 hStdinCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
474 if(hStdinCompPort == INVALID_HANDLE_VALUE) {
475 printf("<H2>OS_LibInit Failed CreateIoCompletionPort: STDIN! ERROR: %d</H2>\r\n\r\n",
482 * Create the thread that will read stdin if the CONTENT_LENGTH
485 if((cLenPtr = getenv("CONTENT_LENGTH")) != NULL &&
487 hStdinThread = CreateThread(NULL, 8192,
488 (LPTHREAD_START_ROUTINE)&StdinThread,
490 if (hStdinThread == NULL) {
491 printf("<H2>OS_LibInit Failed to create STDIN thread! ERROR: %d</H2>\r\n\r\n",
498 * STDOUT will be used synchronously.
500 * XXX: May want to convert this so that it could be used for OVERLAPPED
501 * I/O later. If so, model it after the Stdin I/O as stdout is
502 * also incapable of async I/O on some servers.
504 stdioHandles[STDOUT_FILENO] = GetStdHandle(STD_OUTPUT_HANDLE);
505 if(!SetHandleInformation(stdioHandles[STDOUT_FILENO],
506 HANDLE_FLAG_INHERIT, FALSE)) {
511 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
512 (int)stdioHandles[STDOUT_FILENO],
513 STDOUT_FILENO)) == -1) {
517 * Set stdout equal to our pseudo FD
519 stdioFds[STDOUT_FILENO] = fakeFd;
522 stdioHandles[STDERR_FILENO] = GetStdHandle(STD_ERROR_HANDLE);
523 if(!SetHandleInformation(stdioHandles[STDERR_FILENO],
524 HANDLE_FLAG_INHERIT, FALSE)) {
528 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
529 (int)stdioHandles[STDERR_FILENO],
530 STDERR_FILENO)) == -1) {
534 * Set stderr equal to our pseudo FD
536 stdioFds[STDERR_FILENO] = fakeFd;
543 *--------------------------------------------------------------
547 * Shutdown the OS library.
553 * Memory freed, handles closed.
555 *--------------------------------------------------------------
557 void OS_LibShutdown()
560 if (hIoCompPort != INVALID_HANDLE_VALUE)
562 CloseHandle(hIoCompPort);
563 hIoCompPort = INVALID_HANDLE_VALUE;
566 if (hStdinCompPort != INVALID_HANDLE_VALUE)
568 CloseHandle(hStdinCompPort);
569 hStdinCompPort = INVALID_HANDLE_VALUE;
572 if (acceptMutex != INVALID_HANDLE_VALUE)
574 ReleaseMutex(acceptMutex);
577 DisconnectNamedPipe(hListen);
586 *--------------------------------------------------------------
588 * Win32FreeDescriptor --
590 * Free I/O descriptor entry in fdTable.
593 * Frees I/O descriptor entry in fdTable.
598 *--------------------------------------------------------------
600 static void Win32FreeDescriptor(int fd)
602 /* Catch it if fd is a bogus value */
603 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
605 EnterCriticalSection(&fdTableCritical);
607 if (fdTable[fd].type != FD_UNUSED)
609 switch (fdTable[fd].type)
614 /* Free file path string */
615 ASSERT(fdTable[fd].path != NULL);
616 free(fdTable[fd].path);
617 fdTable[fd].path = NULL;
624 ASSERT(fdTable[fd].path == NULL);
626 fdTable[fd].type = FD_UNUSED;
627 fdTable[fd].path = NULL;
628 fdTable[fd].Errno = NO_ERROR;
629 fdTable[fd].offsetHighPtr = fdTable[fd].offsetLowPtr = NULL;
631 if (fdTable[fd].hMapMutex != NULL)
633 CloseHandle(fdTable[fd].hMapMutex);
634 fdTable[fd].hMapMutex = NULL;
638 LeaveCriticalSection(&fdTableCritical);
643 static short getPort(const char * bindPath)
646 char * p = strchr(bindPath, ':');
655 port = (short) atoi(buf);
662 * OS_CreateLocalIpcFd --
664 * This procedure is responsible for creating the listener pipe
665 * on Windows NT for local process communication. It will create a
666 * named pipe and return a file descriptor to it to the caller.
669 * Listener pipe created. This call returns either a valid
670 * pseudo file descriptor or -1 on error.
673 * Listener pipe and IPC address are stored in the FCGI info
675 * 'errno' will set on errors (-1 is returned).
677 *----------------------------------------------------------------------
679 int OS_CreateLocalIpcFd(const char *bindPath, int backlog)
682 short port = getPort(bindPath);
683 HANDLE mutex = CreateMutex(NULL, FALSE, NULL);
684 char * mutexEnvString;
691 if (! SetHandleInformation(mutex, HANDLE_FLAG_INHERIT, TRUE))
696 // This is a nail for listening to more than one port..
697 // This should really be handled by the caller.
699 mutexEnvString = malloc(strlen(MUTEX_VARNAME) + 7);
700 sprintf(mutexEnvString, MUTEX_VARNAME "=%d", (int) mutex);
701 putenv(mutexEnvString);
703 // There's nothing to be gained (at the moment) by a shutdown Event
705 if (port && *bindPath != ':' && strncmp(bindPath, LOCALHOST, strlen(LOCALHOST)))
707 fprintf(stderr, "To start a service on a TCP port can not "
708 "specify a host name.\n"
709 "You should either use \"localhost:<port>\" or "
710 " just use \":<port>.\"\n");
714 listenType = (port) ? FD_SOCKET_SYNC : FD_PIPE_ASYNC;
719 struct sockaddr_in sockAddr;
720 int sockLen = sizeof(sockAddr);
722 memset(&sockAddr, 0, sizeof(sockAddr));
723 sockAddr.sin_family = AF_INET;
724 sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
725 sockAddr.sin_port = htons(port);
727 listenSock = socket(AF_INET, SOCK_STREAM, 0);
728 if (listenSock == INVALID_SOCKET)
733 if (! bind(listenSock, (struct sockaddr *) &sockAddr, sockLen)
734 || ! listen(listenSock, backlog))
739 pseudoFd = Win32NewDescriptor(listenType, listenSock, -1);
743 closesocket(listenSock);
747 hListen = (HANDLE) listenSock;
751 HANDLE hListenPipe = INVALID_HANDLE_VALUE;
752 char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
759 strcpy(pipePath, bindPathPrefix);
760 strcat(pipePath, bindPath);
762 hListenPipe = CreateNamedPipe(pipePath,
763 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
764 PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_READMODE_BYTE,
765 PIPE_UNLIMITED_INSTANCES,
766 4096, 4096, 0, NULL);
770 if (hListenPipe == INVALID_HANDLE_VALUE)
775 if (! SetHandleInformation(hListenPipe, HANDLE_FLAG_INHERIT, TRUE))
780 pseudoFd = Win32NewDescriptor(listenType, (int) hListenPipe, -1);
784 CloseHandle(hListenPipe);
788 hListen = (HANDLE) hListenPipe;
795 *----------------------------------------------------------------------
799 * Create the pipe pathname connect to the remote application if
803 * -1 if fail or a valid handle if connection succeeds.
806 * Remote connection established.
808 *----------------------------------------------------------------------
810 int OS_FcgiConnect(char *bindPath)
812 short port = getPort(bindPath);
819 struct sockaddr_in sockAddr;
820 int sockLen = sizeof(sockAddr);
823 if (*bindPath != ':')
825 char * p = strchr(bindPath, ':');
826 int len = p - bindPath + 1;
829 strncpy(host, bindPath, len);
833 hp = gethostbyname(host ? host : LOCALHOST);
842 fprintf(stderr, "Unknown host: %s\n", bindPath);
846 memset(&sockAddr, 0, sizeof(sockAddr));
847 sockAddr.sin_family = AF_INET;
848 memcpy(&sockAddr.sin_addr, hp->h_addr, hp->h_length);
849 sockAddr.sin_port = htons(port);
851 sock = socket(AF_INET, SOCK_STREAM, 0);
852 if (sock == INVALID_SOCKET)
857 if (! connect(sock, (struct sockaddr *) &sockAddr, sockLen))
863 pseudoFd = Win32NewDescriptor(FD_SOCKET_SYNC, sock, -1);
872 char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
880 strcpy(pipePath, bindPathPrefix);
881 strcat(pipePath, bindPath);
883 hPipe = CreateFile(pipePath,
884 GENERIC_WRITE | GENERIC_READ,
885 FILE_SHARE_READ | FILE_SHARE_WRITE,
888 FILE_FLAG_OVERLAPPED,
893 if( hPipe == INVALID_HANDLE_VALUE)
898 pseudoFd = Win32NewDescriptor(FD_PIPE_ASYNC, (int) hPipe, -1);
907 * Set stdin equal to our pseudo FD and create the I/O completion
908 * port to be used for async I/O.
910 if (! CreateIoCompletionPort(hPipe, hIoCompPort, pseudoFd, 1))
912 Win32FreeDescriptor(pseudoFd);
922 *--------------------------------------------------------------
926 * Pass through to the appropriate NT read function.
929 * Returns number of byes read. Mimics unix read:.
930 * n bytes read, 0 or -1 failure: errno contains actual error
935 *--------------------------------------------------------------
937 int OS_Read(int fd, char * buf, size_t len)
942 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
944 switch (fdTable[fd].type)
951 if (ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead, NULL))
957 fdTable[fd].Errno = GetLastError();
963 case FD_SOCKET_ASYNC:
965 ret = recv(fdTable[fd].fid.sock, buf, len, 0);
966 if (ret == SOCKET_ERROR)
968 fdTable[fd].Errno = WSAGetLastError();
983 *--------------------------------------------------------------
987 * Perform a synchronous OS write.
990 * Returns number of bytes written. Mimics unix write:
991 * n bytes written, 0 or -1 failure (??? couldn't find man page).
996 *--------------------------------------------------------------
998 int OS_Write(int fd, char * buf, size_t len)
1003 ASSERT(fd >= 0 && fd < WIN32_OPEN_MAX);
1005 switch (fdTable[fd].type)
1012 if (WriteFile(fdTable[fd].fid.fileHandle, buf, len, &bytesWritten, NULL))
1018 fdTable[fd].Errno = GetLastError();
1023 case FD_SOCKET_SYNC:
1024 case FD_SOCKET_ASYNC:
1026 ret = send(fdTable[fd].fid.sock, buf, len, 0);
1027 if (ret == SOCKET_ERROR)
1029 fdTable[fd].Errno = WSAGetLastError();
1044 *----------------------------------------------------------------------
1048 * Spawns a new server listener process, and stores the information
1049 * relating to the child in the supplied record. A wait handler is
1050 * registered on the child's completion. This involves creating
1051 * a process on NT and preparing a command line with the required
1052 * state (currently a -childproc flag and the server socket to use
1053 * for accepting connections).
1056 * 0 if success, -1 if error.
1059 * Child process spawned.
1061 *----------------------------------------------------------------------
1063 int OS_SpawnChild(char *execPath, int listenFd)
1065 STARTUPINFO StartupInfo;
1066 PROCESS_INFORMATION pInfo;
1069 memset((void *)&StartupInfo, 0, sizeof(STARTUPINFO));
1070 StartupInfo.cb = sizeof (STARTUPINFO);
1071 StartupInfo.lpReserved = NULL;
1072 StartupInfo.lpReserved2 = NULL;
1073 StartupInfo.cbReserved2 = 0;
1074 StartupInfo.lpDesktop = NULL;
1077 * FastCGI on NT will set the listener pipe HANDLE in the stdin of
1078 * the new process. The fact that there is a stdin and NULL handles
1079 * for stdout and stderr tells the FastCGI process that this is a
1080 * FastCGI process and not a CGI process.
1082 StartupInfo.dwFlags = STARTF_USESTDHANDLES;
1084 * XXX: Do I have to dup the handle before spawning the process or is
1085 * it sufficient to use the handle as it's reference counted
1088 StartupInfo.hStdInput = fdTable[listenFd].fid.fileHandle;
1089 StartupInfo.hStdOutput = INVALID_HANDLE_VALUE;
1090 StartupInfo.hStdError = INVALID_HANDLE_VALUE;
1093 * Make the listener socket inheritable.
1095 success = SetHandleInformation(StartupInfo.hStdInput, HANDLE_FLAG_INHERIT,
1102 * XXX: Might want to apply some specific security attributes to the
1105 success = CreateProcess(execPath, /* LPCSTR address of module name */
1106 NULL, /* LPCSTR address of command line */
1107 NULL, /* Process security attributes */
1108 NULL, /* Thread security attributes */
1109 TRUE, /* Inheritable Handes inherited. */
1110 0, /* DWORD creation flags */
1111 NULL, /* Use parent environment block */
1112 NULL, /* Address of current directory name */
1113 &StartupInfo, /* Address of STARTUPINFO */
1114 &pInfo); /* Address of PROCESS_INFORMATION */
1123 *--------------------------------------------------------------
1125 * OS_AsyncReadStdin --
1127 * This initiates an asynchronous read on the standard
1128 * input handle. This handle is not guaranteed to be
1129 * capable of performing asynchronous I/O so we send a
1130 * message to the StdinThread to do the synchronous read.
1133 * -1 if error, 0 otherwise.
1136 * Asynchronous message is queued to the StdinThread and an
1137 * overlapped structure is allocated/initialized.
1139 *--------------------------------------------------------------
1141 int OS_AsyncReadStdin(void *buf, int len, OS_AsyncProc procPtr,
1142 ClientData clientData)
1144 POVERLAPPED_REQUEST pOv;
1146 ASSERT(fdTable[STDIN_FILENO].type != FD_UNUSED);
1148 pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
1150 memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
1151 pOv->clientData1 = (ClientData)buf;
1152 pOv->instance = fdTable[STDIN_FILENO].instance;
1153 pOv->procPtr = procPtr;
1154 pOv->clientData = clientData;
1156 PostQueuedCompletionStatus(hStdinCompPort, len, STDIN_FILENO,
1162 *--------------------------------------------------------------
1166 * This initiates an asynchronous read on the file
1167 * handle which may be a socket or named pipe.
1169 * We also must save the ProcPtr and ClientData, so later
1170 * when the io completes, we know who to call.
1172 * We don't look at any results here (the ReadFile may
1173 * return data if it is cached) but do all completion
1174 * processing in OS_Select when we get the io completion
1175 * port done notifications. Then we call the callback.
1178 * -1 if error, 0 otherwise.
1181 * Asynchronous I/O operation is queued for completion.
1183 *--------------------------------------------------------------
1185 int OS_AsyncRead(int fd, int offset, void *buf, int len,
1186 OS_AsyncProc procPtr, ClientData clientData)
1189 POVERLAPPED_REQUEST pOv;
1192 * Catch any bogus fd values
1194 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
1196 * Confirm that this is an async fd
1198 ASSERT(fdTable[fd].type != FD_UNUSED);
1199 ASSERT(fdTable[fd].type != FD_FILE_SYNC);
1200 ASSERT(fdTable[fd].type != FD_PIPE_SYNC);
1201 ASSERT(fdTable[fd].type != FD_SOCKET_SYNC);
1203 pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
1205 memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
1207 * Only file offsets should be non-zero, but make sure.
1209 if (fdTable[fd].type == FD_FILE_ASYNC)
1210 if (fdTable[fd].offset >= 0)
1211 pOv->overlapped.Offset = fdTable[fd].offset;
1213 pOv->overlapped.Offset = offset;
1214 pOv->instance = fdTable[fd].instance;
1215 pOv->procPtr = procPtr;
1216 pOv->clientData = clientData;
1219 * ReadFile returns: TRUE success, FALSE failure
1221 if (!ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead,
1222 (LPOVERLAPPED)pOv)) {
1223 fdTable[fd].Errno = GetLastError();
1224 if(fdTable[fd].Errno == ERROR_NO_DATA ||
1225 fdTable[fd].Errno == ERROR_PIPE_NOT_CONNECTED) {
1226 PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
1229 if(fdTable[fd].Errno != ERROR_IO_PENDING) {
1230 PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
1233 fdTable[fd].Errno = 0;
1239 *--------------------------------------------------------------
1243 * This initiates an asynchronous write on the "fake" file
1244 * descriptor (which may be a file, socket, or named pipe).
1245 * We also must save the ProcPtr and ClientData, so later
1246 * when the io completes, we know who to call.
1248 * We don't look at any results here (the WriteFile generally
1249 * completes immediately) but do all completion processing
1250 * in OS_DoIo when we get the io completion port done
1251 * notifications. Then we call the callback.
1254 * -1 if error, 0 otherwise.
1257 * Asynchronous I/O operation is queued for completion.
1259 *--------------------------------------------------------------
1261 int OS_AsyncWrite(int fd, int offset, void *buf, int len,
1262 OS_AsyncProc procPtr, ClientData clientData)
1265 POVERLAPPED_REQUEST pOv;
1268 * Catch any bogus fd values
1270 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
1272 * Confirm that this is an async fd
1274 ASSERT(fdTable[fd].type != FD_UNUSED);
1275 ASSERT(fdTable[fd].type != FD_FILE_SYNC);
1276 ASSERT(fdTable[fd].type != FD_PIPE_SYNC);
1277 ASSERT(fdTable[fd].type != FD_SOCKET_SYNC);
1279 pOv = (POVERLAPPED_REQUEST)malloc(sizeof(struct OVERLAPPED_REQUEST));
1281 memset((void *)pOv, 0, sizeof(struct OVERLAPPED_REQUEST));
1283 * Only file offsets should be non-zero, but make sure.
1285 if (fdTable[fd].type == FD_FILE_ASYNC)
1287 * Only file opened via OS_AsyncWrite with
1288 * O_APPEND will have an offset != -1.
1290 if (fdTable[fd].offset >= 0)
1292 * If the descriptor has a memory mapped file
1293 * handle, take the offsets from there.
1295 if (fdTable[fd].hMapMutex != NULL) {
1297 * Wait infinitely; this *should* not cause problems.
1299 WaitForSingleObject(fdTable[fd].hMapMutex, INFINITE);
1302 * Retrieve the shared offset values.
1304 pOv->overlapped.OffsetHigh = *(fdTable[fd].offsetHighPtr);
1305 pOv->overlapped.Offset = *(fdTable[fd].offsetLowPtr);
1308 * Update the shared offset values for the next write
1310 *(fdTable[fd].offsetHighPtr) += 0; /* XXX How do I handle overflow */
1311 *(fdTable[fd].offsetLowPtr) += len;
1313 ReleaseMutex(fdTable[fd].hMapMutex);
1315 pOv->overlapped.Offset = fdTable[fd].offset;
1317 pOv->overlapped.Offset = offset;
1318 pOv->instance = fdTable[fd].instance;
1319 pOv->procPtr = procPtr;
1320 pOv->clientData = clientData;
1323 * WriteFile returns: TRUE success, FALSE failure
1325 if (!WriteFile(fdTable[fd].fid.fileHandle, buf, len, &bytesWritten,
1326 (LPOVERLAPPED)pOv)) {
1327 fdTable[fd].Errno = GetLastError();
1328 if(fdTable[fd].Errno != ERROR_IO_PENDING) {
1329 PostQueuedCompletionStatus(hIoCompPort, 0, fd, (LPOVERLAPPED)pOv);
1332 fdTable[fd].Errno = 0;
1334 if (fdTable[fd].offset >= 0)
1335 fdTable[fd].offset += len;
1340 *--------------------------------------------------------------
1344 * Closes the descriptor with routine appropriate for
1345 * descriptor's type.
1348 * Socket or file is closed. Return values mimic Unix close:
1349 * 0 success, -1 failure
1352 * Entry in fdTable is marked as free.
1354 *--------------------------------------------------------------
1356 int OS_Close(int fd)
1361 * Catch it if fd is a bogus value
1363 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
1364 ASSERT(fdTable[fd].type != FD_UNUSED);
1366 switch (fdTable[fd].type) {
1373 case FD_SOCKET_SYNC:
1374 case FD_SOCKET_ASYNC:
1376 * Closing a socket that has an async read outstanding causes a
1377 * tcp reset and possible data loss. The shutdown call seems to
1380 shutdown(fdTable[fd].fid.sock, 2);
1382 * closesocket returns: 0 success, SOCKET_ERROR failure
1384 if (closesocket(fdTable[fd].fid.sock) == SOCKET_ERROR)
1388 return -1; /* fake failure */
1391 Win32FreeDescriptor(fd);
1396 *--------------------------------------------------------------
1400 * Cancel outstanding asynchronous reads and prevent subsequent
1401 * reads from completing.
1404 * Socket or file is shutdown. Return values mimic Unix shutdown:
1405 * 0 success, -1 failure
1407 *--------------------------------------------------------------
1409 int OS_CloseRead(int fd)
1414 * Catch it if fd is a bogus value
1416 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
1417 ASSERT(fdTable[fd].type == FD_SOCKET_ASYNC
1418 || fdTable[fd].type == FD_SOCKET_SYNC);
1420 if (shutdown(fdTable[fd].fid.sock,0) == SOCKET_ERROR)
1426 *--------------------------------------------------------------
1430 * This function was formerly OS_Select. It's purpose is
1431 * to pull I/O completion events off the queue and dispatch
1432 * them to the appropriate place.
1438 * Handlers are called.
1440 *--------------------------------------------------------------
1442 int OS_DoIo(struct timeval *tmo)
1445 unsigned long bytes;
1446 POVERLAPPED_REQUEST pOv;
1453 * We can loop in here, but not too long, as wait handlers
1455 * For cgi stdin, apparently select returns when io completion
1456 * ports don't, so don't wait the full timeout.
1459 ms = (tmo->tv_sec*1000 + tmo->tv_usec/1000) / 2;
1463 ms_last = tb.time*1000 + tb.millitm;
1465 if(tmo && (ms = tmo->tv_sec*1000 + tmo->tv_usec/1000)> 100)
1467 if (!GetQueuedCompletionStatus(hIoCompPort, &bytes, &fd,
1468 (LPOVERLAPPED *)&pOv, ms) && !pOv) {
1469 err = WSAGetLastError();
1470 return 0; /* timeout */
1473 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
1474 /* call callback if descriptor still valid */
1476 if(pOv->instance == fdTable[fd].instance)
1477 (*pOv->procPtr)(pOv->clientData, bytes);
1481 ms -= (tb.time*1000 + tb.millitm - ms_last);
1482 ms_last = tb.time*1000 + tb.millitm;
1488 static int CALLBACK isAddrOK(LPWSABUF lpCallerId,
1495 DWORD dwCallbackData)
1497 const char *okAddrs = (char *) dwCallbackData;
1498 struct sockaddr *sockaddr = (struct sockaddr *) lpCallerId->buf;
1500 // Touch the args to avoid warnings
1501 dc0 = NULL; dc1 = NULL; dc2 = NULL; dc3 = NULL; dc4 = NULL; dc5 = NULL;
1503 if (okAddrs == NULL || sockaddr->sa_family != AF_INET)
1509 static const char *token = " ,;:\t";
1510 struct sockaddr_in * inet_sockaddr = (struct sockaddr_in *) sockaddr;
1511 char *ipaddr = inet_ntoa(inet_sockaddr->sin_addr);
1512 char *p = strstr(okAddrs, ipaddr);
1518 else if (p == okAddrs)
1520 p += strlen(ipaddr);
1521 return (strchr(token, *p) != NULL);
1523 else if (strchr(token, *--p))
1525 p += strlen(ipaddr) + 1;
1526 return (strchr(token, *p) != NULL);
1535 static printLastError(const char * text)
1540 FORMAT_MESSAGE_ALLOCATE_BUFFER |
1541 FORMAT_MESSAGE_FROM_SYSTEM |
1542 FORMAT_MESSAGE_IGNORE_INSERTS,
1551 fprintf(stderr, "%s: %s\n", text, (LPCTSTR) buf);
1555 static int acceptNamedPipe()
1559 if (! ConnectNamedPipe(hListen, &listenOverlapped))
1561 switch (GetLastError())
1563 case ERROR_PIPE_CONNECTED:
1565 // A client connected after CreateNamedPipe but
1566 // before ConnectNamedPipe. Its a good connection.
1570 case ERROR_IO_PENDING:
1572 // Wait for a connection to complete.
1574 while (WaitForSingleObject(listenOverlapped.hEvent,
1575 ACCEPT_TIMEOUT) == WAIT_TIMEOUT)
1577 if (shutdownPending)
1586 case ERROR_PIPE_LISTENING:
1588 // The pipe handle is in nonblocking mode.
1592 // The previous client closed its handle (and we failed
1593 // to call DisconnectNamedPipe)
1597 printLastError("unexpected ConnectNamedPipe() error");
1601 ipcFd = Win32NewDescriptor(FD_PIPE_SYNC, (int) hListen, -1);
1604 DisconnectNamedPipe(hListen);
1610 static int acceptSocket(const char *webServerAddrs)
1612 struct sockaddr sockaddr;
1613 int sockaddrLen = sizeof(sockaddr);
1615 const struct timeval timeout = {1, 0};
1620 FD_SET((unsigned int) hListen, &readfds);
1622 while (select(0, &readfds, NULL, NULL, &timeout) == 0)
1624 if (shutdownPending)
1631 hSock = (webServerAddrs == NULL)
1632 ? accept((SOCKET) hListen,
1635 : WSAAccept((unsigned int) hListen,
1639 (DWORD) webServerAddrs);
1642 if (hSock == INVALID_SOCKET)
1644 // Can I use FormatMessage()?
1645 fprintf(stderr, "accept()/WSAAccept() failed: %d", WSAGetLastError());
1649 ipcFd = Win32NewDescriptor(FD_SOCKET_SYNC, hSock, -1);
1659 *----------------------------------------------------------------------
1663 * Accepts a new FastCGI connection. This routine knows whether
1664 * we're dealing with TCP based sockets or NT Named Pipes for IPC.
1666 * fail_on_intr is ignored in the Win lib.
1669 * -1 if the operation fails, otherwise this is a valid IPC fd.
1671 *----------------------------------------------------------------------
1673 int OS_Accept(int listen_sock, int fail_on_intr, const char *webServerAddrs)
1677 // Touch args to prevent warnings
1678 listen_sock = 0; fail_on_intr = 0;
1680 // @todo Muliple listen sockets and sockets other than 0 are not
1681 // supported due to the use of globals.
1683 if (shutdownPending)
1689 // The mutex is to keep other processes (and threads, when supported)
1690 // from going into the accept cycle. The accept cycle needs to
1691 // periodically break out to check the state of the shutdown flag
1692 // and there's no point to having more than one thread do that.
1694 if (acceptMutex != INVALID_HANDLE_VALUE)
1696 if (WaitForSingleObject(acceptMutex, INFINITE) == WAIT_FAILED)
1698 printLastError("WaitForSingleObject() failed");
1703 if (shutdownPending)
1707 else if (listenType == FD_PIPE_SYNC)
1709 ipcFd = acceptNamedPipe();
1711 else if (listenType == FD_SOCKET_SYNC)
1713 ipcFd = acceptSocket(webServerAddrs);
1717 fprintf(stderr, "unknown listenType (%d)\n", listenType);
1720 if (acceptMutex != INVALID_HANDLE_VALUE)
1722 ReleaseMutex(acceptMutex);
1729 *----------------------------------------------------------------------
1733 * OS IPC routine to close an IPC connection.
1739 * IPC connection is closed.
1741 *----------------------------------------------------------------------
1743 int OS_IpcClose(int ipcFd)
1749 * Catch it if fd is a bogus value
1751 ASSERT((ipcFd >= 0) && (ipcFd < WIN32_OPEN_MAX));
1752 ASSERT(fdTable[ipcFd].type != FD_UNUSED);
1754 switch(listenType) {
1758 * Make sure that the client (ie. a Web Server in this case) has
1759 * read all data from the pipe before we disconnect.
1761 if(!FlushFileBuffers(fdTable[ipcFd].fid.fileHandle))
1763 if(DisconnectNamedPipe(fdTable[ipcFd].fid.fileHandle)) {
1771 case FD_SOCKET_SYNC:
1784 *----------------------------------------------------------------------
1788 * Determines whether this process is a FastCGI process or not.
1791 * Returns 1 if FastCGI, 0 if not.
1796 *----------------------------------------------------------------------
1798 int OS_IsFcgi(int sock)
1800 // Touch args to prevent warnings
1803 /* XXX This is broken for sock */
1805 return (listenType != FD_UNUSED);
1809 *----------------------------------------------------------------------
1813 * Sets selected flag bits in an open file descriptor. Currently
1814 * this is only to put a SOCKET into non-blocking mode.
1816 *----------------------------------------------------------------------
1818 void OS_SetFlags(int fd, int flags)
1820 unsigned long pLong = 1L;
1823 if (fdTable[fd].type == FD_SOCKET_SYNC && flags == O_NONBLOCK) {
1824 if (ioctlsocket(fdTable[fd].fid.sock, FIONBIO, &pLong) ==
1826 exit(WSAGetLastError());
1828 if (!CreateIoCompletionPort((HANDLE)fdTable[fd].fid.sock,
1829 hIoCompPort, fd, 1)) {
1830 err = GetLastError();
1834 fdTable[fd].type = FD_SOCKET_ASYNC;