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.31 2002/02/28 15:21:26 robs Exp $";
23 #define WIN32_LEAN_AND_MEAN
29 #include <sys/timeb.h>
32 #define DLLAPI __declspec(dllexport)
37 #define WIN32_OPEN_MAX 128 /* XXX: Small hack */
40 * millisecs to wait for a client connection before checking the
41 * shutdown flag (then go back to waiting for a connection, etc).
43 #define ACCEPT_TIMEOUT 1000
45 #define MUTEX_VARNAME "_FCGI_MUTEX_"
46 #define SHUTDOWN_EVENT_NAME "_FCGI_SHUTDOWN_EVENT_"
47 #define LOCALHOST "localhost"
49 static HANDLE hIoCompPort = INVALID_HANDLE_VALUE;
50 static HANDLE hStdinCompPort = INVALID_HANDLE_VALUE;
51 static HANDLE hStdinThread = INVALID_HANDLE_VALUE;
53 static HANDLE stdioHandles[3] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE,
54 INVALID_HANDLE_VALUE};
56 // This is a nail for listening to more than one port..
57 static HANDLE acceptMutex = INVALID_HANDLE_VALUE;
59 static BOOLEAN shutdownPending = FALSE;
60 static BOOLEAN shutdownNow = FALSE;
63 * An enumeration of the file types
64 * supported by the FD_TABLE structure.
66 * XXX: Not all currently supported. This allows for future
86 * Structure used to map file handle and socket handle
87 * values into values that can be used to create unix-like
88 * select bitmaps, read/write for both sockets/files.
95 unsigned long instance;
97 int offset; /* only valid for async file writes */
98 LPDWORD offsetHighPtr; /* pointers to offset high and low words */
99 LPDWORD offsetLowPtr; /* only valid for async file writes (logs) */
100 HANDLE hMapMutex; /* mutex handle for multi-proc offset update */
101 LPVOID ovList; /* List of associated OVERLAPPED_REQUESTs */
105 * XXX Note there is no dyanmic sizing of this table, so if the
106 * number of open file descriptors exceeds WIN32_OPEN_MAX the
109 static struct FD_TABLE fdTable[WIN32_OPEN_MAX];
111 static CRITICAL_SECTION fdTableCritical;
113 struct OVERLAPPED_REQUEST {
114 OVERLAPPED overlapped;
115 unsigned long instance; /* file instance (won't match after a close) */
116 OS_AsyncProc procPtr; /* callback routine */
117 ClientData clientData; /* callback argument */
118 ClientData clientData1; /* additional clientData */
120 typedef struct OVERLAPPED_REQUEST *POVERLAPPED_REQUEST;
122 static const char *bindPathPrefix = "\\\\.\\pipe\\FastCGI\\";
124 static FILE_TYPE listenType = FD_UNUSED;
126 // XXX This should be a DESCRIPTOR
127 static HANDLE hListen = INVALID_HANDLE_VALUE;
129 static BOOLEAN libInitialized = FALSE;
132 *--------------------------------------------------------------
134 * Win32NewDescriptor --
136 * Set up for I/O descriptor masquerading.
139 * Returns "fake id" which masquerades as a UNIX-style "small
140 * non-negative integer" file/socket descriptor.
141 * Win32_* routine below will "do the right thing" based on the
142 * descriptor's actual type. -1 indicates failure.
145 * Entry in fdTable is reserved to represent the socket/file.
147 *--------------------------------------------------------------
149 static int Win32NewDescriptor(FILE_TYPE type, int fd, int desiredFd)
153 EnterCriticalSection(&fdTableCritical);
156 * If desiredFd is set, try to get this entry (this is used for
157 * mapping stdio handles). Otherwise try to get the fd entry.
158 * If this is not available, find a the first empty slot. .
160 if (desiredFd >= 0 && desiredFd < WIN32_OPEN_MAX)
162 if (fdTable[desiredFd].type == FD_UNUSED)
169 if (fd < WIN32_OPEN_MAX && fdTable[fd].type == FD_UNUSED)
177 for (i = 1; i < WIN32_OPEN_MAX; ++i)
179 if (fdTable[i].type == FD_UNUSED)
190 fdTable[index].fid.value = fd;
191 fdTable[index].type = type;
192 fdTable[index].path = NULL;
193 fdTable[index].Errno = NO_ERROR;
194 fdTable[index].status = 0;
195 fdTable[index].offset = -1;
196 fdTable[index].offsetHighPtr = fdTable[index].offsetLowPtr = NULL;
197 fdTable[index].hMapMutex = NULL;
198 fdTable[index].ovList = NULL;
201 LeaveCriticalSection(&fdTableCritical);
206 *--------------------------------------------------------------
210 * This thread performs I/O on stadard input. It is needed
211 * because you can't guarantee that all applications will
212 * create standard input with sufficient access to perform
213 * asynchronous I/O. Since we don't want to block the app
214 * reading from stdin we make it look like it's using I/O
215 * completion ports to perform async I/O.
218 * Data is read from stdin and posted to the io completion
224 *--------------------------------------------------------------
226 static void StdinThread(void * startup)
230 unsigned long bytesRead;
231 POVERLAPPED_REQUEST pOv;
233 // Touch the arg to prevent warning
238 * Block until a request to read from stdin comes in or a
239 * request to terminate the thread arrives (fd = -1).
241 if (!GetQueuedCompletionStatus(hStdinCompPort, &bytesRead, &fd,
242 (LPOVERLAPPED *)&pOv, (DWORD)-1) && !pOv) {
247 ASSERT((fd == STDIN_FILENO) || (fd == -1));
252 ASSERT(pOv->clientData1 != NULL);
254 if(ReadFile(stdioHandles[STDIN_FILENO], pOv->clientData1, bytesRead,
256 PostQueuedCompletionStatus(hIoCompPort, bytesRead,
257 STDIN_FILENO, (LPOVERLAPPED)pOv);
267 void OS_ShutdownPending(void)
269 shutdownPending = TRUE;
272 static void ShutdownRequestThread(void * arg)
274 HANDLE shutdownEvent = (HANDLE) arg;
277 WaitForSingleObject(shutdownEvent, INFINITE);
279 shutdownPending = TRUE;
281 if (listenType == FD_PIPE_SYNC)
283 // Its a hassle to get ConnectNamedPipe to return early,
284 // so just wack the whole process - yes, this will toast
285 // any requests in progress, but at least its a clean
286 // shutdown (its better than TerminateProcess())
290 // FD_SOCKET_SYNC: When in Accept(), select() is used to poll
291 // the shutdownPending flag - yeah this isn't pretty either
292 // but its only one process doing it if an Accept mutex is used.
293 // This at least buys no toasted requests.
297 *--------------------------------------------------------------
301 * Set up the OS library for use.
304 * Returns 0 if success, -1 if not.
307 * Sockets initialized, pseudo file descriptors setup, etc.
309 *--------------------------------------------------------------
311 int OS_LibInit(int stdioFds[3])
317 char *cLenPtr = NULL;
323 InitializeCriticalSection(&fdTableCritical);
326 * Initialize windows sockets library.
328 wVersion = MAKEWORD(2,0);
329 err = WSAStartup( wVersion, &wsaData );
331 fprintf(stderr, "Error starting Windows Sockets. Error: %d",
337 * Create the I/O completion port to be used for our I/O queue.
339 if (hIoCompPort == INVALID_HANDLE_VALUE) {
340 hIoCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
342 if(hIoCompPort == INVALID_HANDLE_VALUE) {
343 printf("<H2>OS_LibInit Failed CreateIoCompletionPort! ERROR: %d</H2>\r\n\r\n",
350 * If a shutdown event is in the env, save it (I don't see any to
351 * remove it from the environment out from under the application).
352 * Spawn a thread to wait on the shutdown request.
354 val = getenv(SHUTDOWN_EVENT_NAME);
357 HANDLE shutdownEvent = (HANDLE) atoi(val);
359 if (_beginthread(ShutdownRequestThread, 0, shutdownEvent) == -1)
365 if (acceptMutex == INVALID_HANDLE_VALUE)
367 /* If an accept mutex is in the env, use it */
368 val = getenv(MUTEX_VARNAME);
371 acceptMutex = (HANDLE) atoi(val);
376 * Determine if this library is being used to listen for FastCGI
377 * connections. This is communicated by STDIN containing a
378 * valid handle to a listener object. In this case, both the
379 * "stdout" and "stderr" handles will be INVALID (ie. closed) by
380 * the starting process.
382 * The trick is determining if this is a pipe or a socket...
384 * XXX: Add the async accept test to determine socket or handle to a
387 if((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&
388 (GetStdHandle(STD_ERROR_HANDLE) == INVALID_HANDLE_VALUE) &&
389 (GetStdHandle(STD_INPUT_HANDLE) != INVALID_HANDLE_VALUE) )
391 DWORD pipeMode = PIPE_READMODE_BYTE | PIPE_WAIT;
392 HANDLE oldStdIn = GetStdHandle(STD_INPUT_HANDLE);
394 // Move the handle to a "low" number
395 if (! DuplicateHandle(GetCurrentProcess(), oldStdIn,
396 GetCurrentProcess(), &hListen,
397 0, TRUE, DUPLICATE_SAME_ACCESS))
402 if (! SetStdHandle(STD_INPUT_HANDLE, hListen))
407 CloseHandle(oldStdIn);
410 * Set the pipe handle state so that it operates in wait mode.
412 * NOTE: The listenFd is not mapped to a pseudo file descriptor
413 * as all work done on it is contained to the OS library.
415 * XXX: Initial assumption is that SetNamedPipeHandleState will
416 * fail if this is an IP socket...
418 if (SetNamedPipeHandleState(hListen, &pipeMode, NULL, NULL))
420 listenType = FD_PIPE_SYNC;
424 listenType = FD_SOCKET_SYNC;
429 * If there are no stdioFds passed in, we're done.
431 if(stdioFds == NULL) {
437 * Setup standard input asynchronous I/O. There is actually a separate
438 * thread spawned for this purpose. The reason for this is that some
439 * web servers use anonymous pipes for the connection between itself
440 * and a CGI application. Anonymous pipes can't perform asynchronous
441 * I/O or use I/O completion ports. Therefore in order to present a
442 * consistent I/O dispatch model to an application we emulate I/O
443 * completion port behavior by having the standard input thread posting
444 * messages to the hIoCompPort which look like a complete overlapped
445 * I/O structure. This keeps the event dispatching simple from the
446 * application perspective.
448 stdioHandles[STDIN_FILENO] = GetStdHandle(STD_INPUT_HANDLE);
450 if(!SetHandleInformation(stdioHandles[STDIN_FILENO],
451 HANDLE_FLAG_INHERIT, 0)) {
453 * XXX: Causes error when run from command line. Check KB
454 err = GetLastError();
460 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
461 (int)stdioHandles[STDIN_FILENO],
462 STDIN_FILENO)) == -1) {
466 * Set stdin equal to our pseudo FD and create the I/O completion
467 * port to be used for async I/O.
469 stdioFds[STDIN_FILENO] = fakeFd;
473 * Create the I/O completion port to be used for communicating with
474 * the thread doing I/O on standard in. This port will carry read
475 * and possibly thread termination requests to the StdinThread.
477 if (hStdinCompPort == INVALID_HANDLE_VALUE) {
478 hStdinCompPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL,
480 if(hStdinCompPort == INVALID_HANDLE_VALUE) {
481 printf("<H2>OS_LibInit Failed CreateIoCompletionPort: STDIN! ERROR: %d</H2>\r\n\r\n",
488 * Create the thread that will read stdin if the CONTENT_LENGTH
491 if((cLenPtr = getenv("CONTENT_LENGTH")) != NULL &&
493 hStdinThread = (HANDLE) _beginthread(StdinThread, 0, NULL);
494 if (hStdinThread == (HANDLE) -1) {
495 printf("<H2>OS_LibInit Failed to create STDIN thread! ERROR: %d</H2>\r\n\r\n",
502 * STDOUT will be used synchronously.
504 * XXX: May want to convert this so that it could be used for OVERLAPPED
505 * I/O later. If so, model it after the Stdin I/O as stdout is
506 * also incapable of async I/O on some servers.
508 stdioHandles[STDOUT_FILENO] = GetStdHandle(STD_OUTPUT_HANDLE);
509 if(!SetHandleInformation(stdioHandles[STDOUT_FILENO],
510 HANDLE_FLAG_INHERIT, FALSE)) {
515 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
516 (int)stdioHandles[STDOUT_FILENO],
517 STDOUT_FILENO)) == -1) {
521 * Set stdout equal to our pseudo FD
523 stdioFds[STDOUT_FILENO] = fakeFd;
526 stdioHandles[STDERR_FILENO] = GetStdHandle(STD_ERROR_HANDLE);
527 if(!SetHandleInformation(stdioHandles[STDERR_FILENO],
528 HANDLE_FLAG_INHERIT, FALSE)) {
532 if ((fakeFd = Win32NewDescriptor(FD_PIPE_SYNC,
533 (int)stdioHandles[STDERR_FILENO],
534 STDERR_FILENO)) == -1) {
538 * Set stderr equal to our pseudo FD
540 stdioFds[STDERR_FILENO] = fakeFd;
547 *--------------------------------------------------------------
551 * Shutdown the OS library.
557 * Memory freed, handles closed.
559 *--------------------------------------------------------------
561 void OS_LibShutdown()
564 if (hIoCompPort != INVALID_HANDLE_VALUE)
566 CloseHandle(hIoCompPort);
567 hIoCompPort = INVALID_HANDLE_VALUE;
570 if (hStdinCompPort != INVALID_HANDLE_VALUE)
572 CloseHandle(hStdinCompPort);
573 hStdinCompPort = INVALID_HANDLE_VALUE;
576 if (acceptMutex != INVALID_HANDLE_VALUE)
578 ReleaseMutex(acceptMutex);
581 DisconnectNamedPipe(hListen);
590 *--------------------------------------------------------------
592 * Win32FreeDescriptor --
594 * Free I/O descriptor entry in fdTable.
597 * Frees I/O descriptor entry in fdTable.
602 *--------------------------------------------------------------
604 static void Win32FreeDescriptor(int fd)
606 /* Catch it if fd is a bogus value */
607 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
609 EnterCriticalSection(&fdTableCritical);
611 if (fdTable[fd].type != FD_UNUSED)
613 switch (fdTable[fd].type)
618 /* Free file path string */
619 ASSERT(fdTable[fd].path != NULL);
620 free(fdTable[fd].path);
621 fdTable[fd].path = NULL;
628 ASSERT(fdTable[fd].path == NULL);
630 fdTable[fd].type = FD_UNUSED;
631 fdTable[fd].path = NULL;
632 fdTable[fd].Errno = NO_ERROR;
633 fdTable[fd].offsetHighPtr = fdTable[fd].offsetLowPtr = NULL;
635 if (fdTable[fd].hMapMutex != NULL)
637 CloseHandle(fdTable[fd].hMapMutex);
638 fdTable[fd].hMapMutex = NULL;
642 LeaveCriticalSection(&fdTableCritical);
647 static short getPort(const char * bindPath)
650 char * p = strchr(bindPath, ':');
659 port = (short) atoi(buf);
666 * OS_CreateLocalIpcFd --
668 * This procedure is responsible for creating the listener pipe
669 * on Windows NT for local process communication. It will create a
670 * named pipe and return a file descriptor to it to the caller.
673 * Listener pipe created. This call returns either a valid
674 * pseudo file descriptor or -1 on error.
677 * Listener pipe and IPC address are stored in the FCGI info
679 * 'errno' will set on errors (-1 is returned).
681 *----------------------------------------------------------------------
683 int OS_CreateLocalIpcFd(const char *bindPath, int backlog)
686 short port = getPort(bindPath);
688 if (acceptMutex == INVALID_HANDLE_VALUE)
690 acceptMutex = CreateMutex(NULL, FALSE, NULL);
691 if (acceptMutex == NULL) return -2;
692 if (! SetHandleInformation(acceptMutex, HANDLE_FLAG_INHERIT, TRUE)) return -3;
695 // There's nothing to be gained (at the moment) by a shutdown Event
697 if (port && *bindPath != ':' && strncmp(bindPath, LOCALHOST, strlen(LOCALHOST)))
699 fprintf(stderr, "To start a service on a TCP port can not "
700 "specify a host name.\n"
701 "You should either use \"localhost:<port>\" or "
702 " just use \":<port>.\"\n");
706 listenType = (port) ? FD_SOCKET_SYNC : FD_PIPE_ASYNC;
711 struct sockaddr_in sockAddr;
712 int sockLen = sizeof(sockAddr);
714 memset(&sockAddr, 0, sizeof(sockAddr));
715 sockAddr.sin_family = AF_INET;
716 sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
717 sockAddr.sin_port = htons(port);
719 listenSock = socket(AF_INET, SOCK_STREAM, 0);
720 if (listenSock == INVALID_SOCKET)
725 if (bind(listenSock, (struct sockaddr *) &sockAddr, sockLen) )
730 if (listen(listenSock, backlog))
735 pseudoFd = Win32NewDescriptor(listenType, listenSock, -1);
739 closesocket(listenSock);
743 hListen = (HANDLE) listenSock;
747 HANDLE hListenPipe = INVALID_HANDLE_VALUE;
748 char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
755 strcpy(pipePath, bindPathPrefix);
756 strcat(pipePath, bindPath);
758 hListenPipe = CreateNamedPipe(pipePath,
760 PIPE_TYPE_BYTE | PIPE_WAIT | PIPE_READMODE_BYTE,
761 PIPE_UNLIMITED_INSTANCES,
762 4096, 4096, 0, NULL);
766 if (hListenPipe == INVALID_HANDLE_VALUE)
771 if (! SetHandleInformation(hListenPipe, HANDLE_FLAG_INHERIT, TRUE))
776 pseudoFd = Win32NewDescriptor(listenType, (int) hListenPipe, -1);
780 CloseHandle(hListenPipe);
784 hListen = (HANDLE) hListenPipe;
791 *----------------------------------------------------------------------
795 * Create the pipe pathname connect to the remote application if
799 * -1 if fail or a valid handle if connection succeeds.
802 * Remote connection established.
804 *----------------------------------------------------------------------
806 int OS_FcgiConnect(char *bindPath)
808 short port = getPort(bindPath);
815 struct sockaddr_in sockAddr;
816 int sockLen = sizeof(sockAddr);
819 if (*bindPath != ':')
821 char * p = strchr(bindPath, ':');
822 int len = p - bindPath + 1;
825 strncpy(host, bindPath, len);
829 hp = gethostbyname(host ? host : LOCALHOST);
838 fprintf(stderr, "Unknown host: %s\n", bindPath);
842 memset(&sockAddr, 0, sizeof(sockAddr));
843 sockAddr.sin_family = AF_INET;
844 memcpy(&sockAddr.sin_addr, hp->h_addr, hp->h_length);
845 sockAddr.sin_port = htons(port);
847 sock = socket(AF_INET, SOCK_STREAM, 0);
848 if (sock == INVALID_SOCKET)
853 if (! connect(sock, (struct sockaddr *) &sockAddr, sockLen))
859 pseudoFd = Win32NewDescriptor(FD_SOCKET_SYNC, sock, -1);
868 char *pipePath = malloc(strlen(bindPathPrefix) + strlen(bindPath) + 1);
876 strcpy(pipePath, bindPathPrefix);
877 strcat(pipePath, bindPath);
879 hPipe = CreateFile(pipePath,
880 GENERIC_WRITE | GENERIC_READ,
881 FILE_SHARE_READ | FILE_SHARE_WRITE,
884 FILE_FLAG_OVERLAPPED,
889 if( hPipe == INVALID_HANDLE_VALUE)
894 pseudoFd = Win32NewDescriptor(FD_PIPE_ASYNC, (int) hPipe, -1);
903 * Set stdin equal to our pseudo FD and create the I/O completion
904 * port to be used for async I/O.
906 if (! CreateIoCompletionPort(hPipe, hIoCompPort, pseudoFd, 1))
908 Win32FreeDescriptor(pseudoFd);
918 *--------------------------------------------------------------
922 * Pass through to the appropriate NT read function.
925 * Returns number of byes read. Mimics unix read:.
926 * n bytes read, 0 or -1 failure: errno contains actual error
931 *--------------------------------------------------------------
933 int OS_Read(int fd, char * buf, size_t len)
938 ASSERT((fd >= 0) && (fd < WIN32_OPEN_MAX));
940 if (shutdownNow) return -1;
942 switch (fdTable[fd].type)
949 if (ReadFile(fdTable[fd].fid.fileHandle, buf, len, &bytesRead, NULL))
955 fdTable[fd].Errno = GetLastError();
961 case FD_SOCKET_ASYNC:
963 ret = recv(fdTable[fd].fid.sock, buf, len, 0);
964 if (ret == SOCKET_ERROR)
966 fdTable[fd].Errno = WSAGetLastError();
981 *--------------------------------------------------------------
985 * Perform a synchronous OS write.
988 * Returns number of bytes written. Mimics unix write:
989 * n bytes written, 0 or -1 failure (??? couldn't find man page).
994 *--------------------------------------------------------------
996 int OS_Write(int fd, char * buf, size_t len)
1001 ASSERT(fd >= 0 && fd < WIN32_OPEN_MAX);
1003 if (shutdownNow) return -1;
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;
1487 static int isAddrOK(struct sockaddr_in * inet_sockaddr, const char * okAddrs)
1489 static const char *token = " ,;:\t";
1493 if (okAddrs == NULL) return TRUE;
1495 ipaddr = inet_ntoa(inet_sockaddr->sin_addr);
1496 p = strstr(okAddrs, ipaddr);
1498 if (p == NULL) return FALSE;
1502 p += strlen(ipaddr);
1503 return (strchr(token, *p) != NULL);
1506 if (strchr(token, *--p) != NULL)
1508 p += strlen(ipaddr) + 1;
1509 return (strchr(token, *p) != NULL);
1516 static int CALLBACK isAddrOKCallback(LPWSABUF lpCallerId,
1525 struct sockaddr_in *sockaddr = (struct sockaddr_in *) lpCallerId->buf;
1527 // Touch the args to avoid warnings
1528 dc0 = NULL; dc1 = NULL; dc2 = NULL; dc3 = NULL; dc4 = NULL; dc5 = NULL;
1530 if ((void *) data == NULL) return CF_ACCEPT;
1532 if (sockaddr->sin_family != AF_INET) return CF_ACCEPT;
1534 return isAddrOK(sockaddr, (const char *) data) ? CF_ACCEPT : CF_REJECT;
1538 static void printLastError(const char * text)
1543 FORMAT_MESSAGE_ALLOCATE_BUFFER |
1544 FORMAT_MESSAGE_FROM_SYSTEM |
1545 FORMAT_MESSAGE_IGNORE_INSERTS,
1554 fprintf(stderr, "%s: %s\n", text, (LPCTSTR) buf);
1558 static int acceptNamedPipe()
1562 if (! ConnectNamedPipe(hListen, NULL))
1564 switch (GetLastError())
1566 case ERROR_PIPE_CONNECTED:
1568 // A client connected after CreateNamedPipe but
1569 // before ConnectNamedPipe. Its a good connection.
1573 case ERROR_IO_PENDING:
1575 // The NamedPipe was opened with an Overlapped structure
1576 // and there is a pending io operation. mod_fastcgi
1577 // did this in 2.2.12 (fcgi_pm.c v1.52).
1579 case ERROR_PIPE_LISTENING:
1581 // The pipe handle is in nonblocking mode.
1585 // The previous client closed its handle (and we failed
1586 // to call DisconnectNamedPipe)
1590 printLastError("unexpected ConnectNamedPipe() error");
1594 ipcFd = Win32NewDescriptor(FD_PIPE_SYNC, (int) hListen, -1);
1597 DisconnectNamedPipe(hListen);
1603 static int acceptSocket(const char *webServerAddrs)
1610 struct sockaddr sockaddr;
1611 int sockaddrLen = sizeof(sockaddr);
1615 const struct timeval timeout = {1, 0};
1620 #pragma warning( disable : 4127 )
1621 FD_SET((unsigned int) hListen, &readfds);
1622 #pragma warning( default : 4127 )
1624 if (select(0, &readfds, NULL, NULL, &timeout) == 0)
1626 if (shutdownPending)
1639 hSock = accept((SOCKET) hListen, &sockaddr, &sockaddrLen);
1641 if (hSock == INVALID_SOCKET)
1646 if (isAddrOK((struct sockaddr_in *) &sockaddr, webServerAddrs))
1653 hSock = WSAAccept((unsigned int) hListen,
1657 (DWORD) webServerAddrs);
1659 if (hSock != INVALID_SOCKET)
1664 if (WSAGetLastError() != WSAECONNREFUSED)
1671 if (hSock == INVALID_SOCKET)
1673 /* Use FormatMessage() */
1674 fprintf(stderr, "accept()/WSAAccept() failed: %d", WSAGetLastError());
1678 ipcFd = Win32NewDescriptor(FD_SOCKET_SYNC, hSock, -1);
1688 *----------------------------------------------------------------------
1692 * Accepts a new FastCGI connection. This routine knows whether
1693 * we're dealing with TCP based sockets or NT Named Pipes for IPC.
1695 * fail_on_intr is ignored in the Win lib.
1698 * -1 if the operation fails, otherwise this is a valid IPC fd.
1700 *----------------------------------------------------------------------
1702 int OS_Accept(int listen_sock, int fail_on_intr, const char *webServerAddrs)
1706 // Touch args to prevent warnings
1707 listen_sock = 0; fail_on_intr = 0;
1709 // @todo Muliple listen sockets and sockets other than 0 are not
1710 // supported due to the use of globals.
1712 if (shutdownPending)
1718 // The mutex is to keep other processes (and threads, when supported)
1719 // from going into the accept cycle. The accept cycle needs to
1720 // periodically break out to check the state of the shutdown flag
1721 // and there's no point to having more than one thread do that.
1723 if (acceptMutex != INVALID_HANDLE_VALUE)
1725 if (WaitForSingleObject(acceptMutex, INFINITE) == WAIT_FAILED)
1727 printLastError("WaitForSingleObject() failed");
1732 if (shutdownPending)
1736 else if (listenType == FD_PIPE_SYNC)
1738 ipcFd = acceptNamedPipe();
1740 else if (listenType == FD_SOCKET_SYNC)
1742 ipcFd = acceptSocket(webServerAddrs);
1746 fprintf(stderr, "unknown listenType (%d)\n", listenType);
1749 if (acceptMutex != INVALID_HANDLE_VALUE)
1751 ReleaseMutex(acceptMutex);
1758 *----------------------------------------------------------------------
1762 * OS IPC routine to close an IPC connection.
1768 * IPC connection is closed.
1770 *----------------------------------------------------------------------
1772 int OS_IpcClose(int ipcFd)
1774 if (ipcFd == -1) return 0;
1777 * Catch it if fd is a bogus value
1779 ASSERT((ipcFd >= 0) && (ipcFd < WIN32_OPEN_MAX));
1780 ASSERT(fdTable[ipcFd].type != FD_UNUSED);
1786 * Make sure that the client (ie. a Web Server in this case) has
1787 * read all data from the pipe before we disconnect.
1789 if (! FlushFileBuffers(fdTable[ipcFd].fid.fileHandle)) return -1;
1791 if (! DisconnectNamedPipe(fdTable[ipcFd].fid.fileHandle)) return -1;
1795 case FD_SOCKET_SYNC:
1811 *----------------------------------------------------------------------
1815 * Determines whether this process is a FastCGI process or not.
1818 * Returns 1 if FastCGI, 0 if not.
1823 *----------------------------------------------------------------------
1825 int OS_IsFcgi(int sock)
1827 // Touch args to prevent warnings
1830 /* XXX This is broken for sock */
1832 return (listenType != FD_UNUSED);
1836 *----------------------------------------------------------------------
1840 * Sets selected flag bits in an open file descriptor. Currently
1841 * this is only to put a SOCKET into non-blocking mode.
1843 *----------------------------------------------------------------------
1845 void OS_SetFlags(int fd, int flags)
1847 unsigned long pLong = 1L;
1850 if (fdTable[fd].type == FD_SOCKET_SYNC && flags == O_NONBLOCK) {
1851 if (ioctlsocket(fdTable[fd].fid.sock, FIONBIO, &pLong) ==
1853 exit(WSAGetLastError());
1855 if (!CreateIoCompletionPort((HANDLE)fdTable[fd].fid.sock,
1856 hIoCompPort, fd, 1)) {
1857 err = GetLastError();
1861 fdTable[fd].type = FD_SOCKET_ASYNC;