| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* -------------------------------------------------------------------- |
| * |
| * wintty : a Apache/WinNT support utility for monitoring and |
| * reflecting user feedback from the Apache process via |
| * stdin/stdout, even as running within the service context. |
| * |
| * Originally contributed by William Rowe <wrowe covalent.net> |
| * |
| * Note: this implementation is _very_ experimental, and error handling |
| * is far from complete. Using it as a cgi or pipe process allows the |
| * programmer to discover if facilities such as reliable piped logs |
| * are working as expected, or answer operator prompts that would |
| * otherwise be discarded by the service process. |
| * |
| * Also note the isservice detection semantics, which far exceed any |
| * mechanism we have discovered thus far. |
| * |
| * -------------------------------------------------------------------- |
| */ |
| |
| #define WIN32_LEAN_AND_MEAN |
| #include <windows.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| |
| #if defined(_MSC_VER) && _MSC_VER >= 1400 |
| #define _CRT_SECURE_NO_DEPRECATE |
| #pragma warning(disable: 4996) |
| #endif |
| |
| const char *options = |
| "\nwintty: a utility for echoing the stdin stream to a new console window,\n" |
| "\teven when invoked from within a service (such as the Apache server.)\n" |
| "\tAlso reflects the console input back to the stdout stream, allowing\n" |
| "\tthe operator to respond to prompts from the context of a service.\n\n" |
| "Syntax: %s [opts] [-t \"Window Title\"]\n\n" |
| " opts: -c{haracter} or -l{ine} input\n" |
| "\t-q{uiet} or -e{cho} input\n" |
| "\t-u{nprocessed} or -p{rocessed} input\n" |
| "\t-n{owrap} or -w{rap} output lines\n" |
| "\t-f{ormatted} or -r{aw} output lines\n" |
| "\t-O{output} [number of seconds]\n" |
| "\t-v{erbose} error reporting (for debugging)\n" |
| "\t-? for this message\n\n"; |
| |
| BOOL verbose = FALSE; |
| |
| void printerr(char *fmt, ...) |
| { |
| char str[1024]; |
| va_list args; |
| if (!verbose) |
| return; |
| va_start(args, fmt); |
| wvsprintf(str, fmt, args); |
| OutputDebugString(str); |
| } |
| |
| DWORD WINAPI feedback(LPVOID args); |
| |
| typedef struct feedback_args_t { |
| HANDLE in; |
| HANDLE out; |
| } feedback_args_t; |
| |
| int main(int argc, char** argv) |
| { |
| char str[1024], *contitle = NULL; |
| HANDLE hproc, thread; |
| HANDLE hwinsta = NULL, hsavewinsta; |
| HANDLE hdesk = NULL, hsavedesk = NULL; |
| HANDLE conin, conout; |
| HANDLE hstdin, hstdout, hstderr, hdup; |
| feedback_args_t feed; |
| DWORD conmode; |
| DWORD newinmode = 0, notinmode = 0; |
| DWORD newoutmode = 0, notoutmode = 0; |
| DWORD tid; |
| DWORD len; |
| DWORD timeout = INFINITE; |
| BOOL isservice = FALSE; |
| char *arg0 = argv[0]; |
| |
| while (--argc) { |
| ++argv; |
| if (**argv == '/' || **argv == '-') { |
| switch (tolower((*argv)[1])) { |
| case 'c': |
| notinmode |= ENABLE_LINE_INPUT; break; |
| case 'l': |
| newinmode |= ENABLE_LINE_INPUT; break; |
| case 'q': |
| notinmode |= ENABLE_ECHO_INPUT; break; |
| case 'e': |
| newinmode |= ENABLE_ECHO_INPUT; break; |
| case 'u': |
| notinmode |= ENABLE_PROCESSED_INPUT; break; |
| case 'p': |
| newinmode |= ENABLE_PROCESSED_INPUT; break; |
| case 'n': |
| notoutmode |= ENABLE_WRAP_AT_EOL_OUTPUT; break; |
| case 'w': |
| newoutmode |= ENABLE_WRAP_AT_EOL_OUTPUT; break; |
| case 'r': |
| notoutmode |= ENABLE_PROCESSED_OUTPUT; break; |
| case 'f': |
| newoutmode |= ENABLE_PROCESSED_OUTPUT; break; |
| case 'o': |
| if (*(argv + 1) && *(argv + 1)[0] != '-') { |
| *(++argv); |
| timeout = atoi(*argv) / 1000; |
| --argc; |
| } |
| else { |
| timeout = 0; |
| } |
| break; |
| case 'v': |
| verbose = TRUE; |
| break; |
| case 't': |
| contitle = *(++argv); |
| --argc; |
| break; |
| case '?': |
| printf(options, arg0); |
| exit(1); |
| default: |
| printf("wintty option %s not recognized, use -? for help.\n\n", *argv); |
| exit(1); |
| } |
| } |
| else { |
| printf("wintty argument %s not understood, use -? for help.\n\n", *argv); |
| exit(1); |
| } |
| } |
| |
| hproc = GetCurrentProcess(); |
| hsavewinsta = GetProcessWindowStation(); |
| if (!hsavewinsta || hsavewinsta == INVALID_HANDLE_VALUE) { |
| printerr("GetProcessWindowStation() failed (%d)\n", GetLastError()); |
| } |
| else if (!GetUserObjectInformation(hsavewinsta, UOI_NAME, str, sizeof(str), &len)) { |
| printerr("GetUserObjectInfoformation(hWinSta) failed (%d)\n", GetLastError()); |
| } |
| else if (strnicmp(str, "Service-", 8) == 0) { |
| printerr("WindowStation Name %s is a service\n", str); |
| isservice = TRUE; |
| } |
| SetLastError(0); |
| |
| hstdin = GetStdHandle(STD_INPUT_HANDLE); |
| if (!hstdin || hstdin == INVALID_HANDLE_VALUE) { |
| printerr("GetStdHandle(STD_INPUT_HANDLE) failed (%d)\n", |
| GetLastError()); |
| } |
| else if (DuplicateHandle(hproc, hstdin, hproc, &hdup, 0, |
| isservice, DUPLICATE_SAME_ACCESS)) { |
| CloseHandle(hstdin); |
| hstdin = hdup; |
| } |
| else { |
| printerr("DupHandle(stdin [%x]) failed (%d)\n", |
| hstdin, GetLastError()); |
| } |
| |
| hstdout = GetStdHandle(STD_OUTPUT_HANDLE); |
| if (!hstdout || hstdout == INVALID_HANDLE_VALUE) { |
| printerr("GetStdHandle(STD_OUTPUT_HANDLE) failed (%d)\n", |
| GetLastError()); |
| } |
| else if (DuplicateHandle(hproc, hstdout, hproc, &hdup, 0, |
| isservice, DUPLICATE_SAME_ACCESS)) { |
| CloseHandle(hstdout); |
| hstdout = hdup; |
| } |
| else { |
| printerr("DupHandle(stdout [%x]) failed (%d)\n", |
| hstdout, GetLastError()); |
| } |
| |
| hstderr = GetStdHandle(STD_ERROR_HANDLE); |
| if (!hstderr || hstderr == INVALID_HANDLE_VALUE) { |
| printerr("GetStdHandle(STD_ERROR_HANDLE) failed (%d)\n", |
| GetLastError()); |
| } |
| else if (DuplicateHandle(hproc, hstderr, hproc, &hdup, 0, |
| isservice, DUPLICATE_SAME_ACCESS)) { |
| CloseHandle(hstderr); |
| hstderr = hdup; |
| } |
| else { |
| printerr("DupHandle(stderr [%x]) failed (%d)\n", |
| hstderr, GetLastError()); |
| } |
| |
| /* You can't close the console till all the handles above were |
| * rescued by DuplicateHandle() |
| */ |
| if (!FreeConsole()) |
| printerr("FreeConsole() failed (%d)\n", GetLastError()); |
| |
| if (isservice) { |
| #ifdef WE_EVER_FIGURE_OUT_WHY_THIS_DOESNT_WORK |
| hsavedesk = GetThreadDesktop(GetCurrentThreadId()); |
| if (!hsavedesk || hsavedesk == INVALID_HANDLE_VALUE) { |
| printerr("GetThreadDesktop(GetTID()) failed (%d)\n", GetLastError()); |
| } |
| CloseWindowStation(hwinsta); |
| hwinsta = OpenWindowStation("WinSta0", TRUE, MAXIMUM_ALLOWED); |
| if (!hwinsta || hwinsta == INVALID_HANDLE_VALUE) { |
| printerr("OpenWinSta(WinSta0) failed (%d)\n", GetLastError()); |
| } |
| else if (!SetProcessWindowStation(hwinsta)) { |
| printerr("SetProcWinSta(WinSta0) failed (%d)\n", GetLastError()); |
| } |
| hdesk = OpenDesktop("Default", 0, TRUE, MAXIMUM_ALLOWED); |
| if (!hdesk || hdesk == INVALID_HANDLE_VALUE) { |
| printerr("OpenDesktop(Default) failed (%d)\n", GetLastError()); |
| } |
| else if (!SetThreadDesktop(hdesk)) { |
| printerr("SetThreadDesktop(Default) failed (%d)\n", GetLastError()); |
| } |
| #else |
| PROCESS_INFORMATION pi; |
| STARTUPINFO si; |
| DWORD exitcode = 1; |
| char appbuff[MAX_PATH]; |
| char *appname = NULL; |
| char *cmdline = GetCommandLine(); |
| |
| if (!GetModuleFileName(NULL, appbuff, sizeof(appbuff))) { |
| appname = appbuff; |
| } |
| |
| memset(&si, 0, sizeof(si)); |
| si.cb = sizeof(si); |
| si.dwFlags = STARTF_USESHOWWINDOW |
| | STARTF_USESTDHANDLES; |
| si.lpDesktop = "WinSta0\\Default"; |
| si.wShowWindow = 1; /* SW_SHOWNORMAL */ |
| si.hStdInput = hstdin; |
| si.hStdOutput = hstdout; |
| si.hStdError = hstderr; |
| |
| /* Instantly, upon creating the new process, we will close our |
| * copies of the handles so our parent isn't confused when the |
| * child closes their copy of the handle. Without this action, |
| * we would hold a copy of the handle, and the parent would not |
| * receive their EOF notification. |
| */ |
| if (CreateProcess(appname, cmdline, NULL, NULL, TRUE, |
| CREATE_SUSPENDED | CREATE_NEW_CONSOLE, |
| NULL, NULL, &si, &pi)) { |
| CloseHandle(si.hStdInput); |
| CloseHandle(si.hStdOutput); |
| CloseHandle(si.hStdError); |
| ResumeThread(pi.hThread); |
| CloseHandle(pi.hThread); |
| WaitForSingleObject(pi.hProcess, INFINITE); |
| GetExitCodeProcess(pi.hProcess, &exitcode); |
| CloseHandle(pi.hProcess); |
| return exitcode; |
| } |
| return 1; |
| #endif |
| } |
| |
| if (!AllocConsole()) { |
| printerr("AllocConsole(Default) failed (%d)\n", GetLastError()); |
| } |
| |
| if (contitle && !SetConsoleTitle(contitle)) { |
| printerr("SetConsoleTitle() failed (%d)\n", GetLastError()); |
| } |
| |
| conout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE, |
| FILE_SHARE_READ | FILE_SHARE_WRITE, |
| FALSE, OPEN_EXISTING, 0, NULL); |
| if (!conout || conout == INVALID_HANDLE_VALUE) { |
| printerr("CreateFile(CONOUT$) failed (%d)\n", GetLastError()); |
| } |
| else if (!GetConsoleMode(conout, &conmode)) { |
| printerr("GetConsoleMode(CONOUT) failed (%d)\n", GetLastError()); |
| } |
| else if (!SetConsoleMode(conout, conmode = ((conmode | newoutmode) |
| & ~notoutmode))) { |
| printerr("SetConsoleMode(CONOUT, 0x%x) failed (%d)\n", |
| conmode, GetLastError()); |
| } |
| |
| conin = CreateFile("CONIN$", GENERIC_READ | GENERIC_WRITE, |
| FILE_SHARE_READ | FILE_SHARE_WRITE, |
| FALSE, OPEN_EXISTING, 0, NULL); |
| if (!conin || conin == INVALID_HANDLE_VALUE) { |
| printerr("CreateFile(CONIN$) failed (%d)\n", GetLastError()); |
| } |
| else if (!GetConsoleMode(conin, &conmode)) { |
| printerr("GetConsoleMode(CONIN) failed (%d)\n", GetLastError()); |
| } |
| else if (!SetConsoleMode(conin, conmode = ((conmode | newinmode) |
| & ~notinmode))) { |
| printerr("SetConsoleMode(CONIN, 0x%x) failed (%d)\n", |
| conmode, GetLastError()); |
| } |
| |
| feed.in = conin; |
| feed.out = hstdout; |
| thread = CreateThread(NULL, 0, feedback, (LPVOID)&feed, 0, &tid); |
| |
| while (ReadFile(hstdin, str, sizeof(str), &len, NULL)) |
| if (!len || !WriteFile(conout, str, len, &len, NULL)) |
| break; |
| |
| printerr("[EOF] from stdin (%d)\n", GetLastError()); |
| |
| CloseHandle(stdout); |
| if (!GetConsoleTitle(str, sizeof(str))) { |
| printerr("SetConsoleTitle() failed (%d)\n", GetLastError()); |
| } |
| else { |
| strcat(str, " - [Finished]"); |
| if (!SetConsoleTitle(str)) { |
| printerr("SetConsoleTitle() failed (%d)\n", GetLastError()); |
| } |
| } |
| |
| WaitForSingleObject(thread, timeout); |
| FreeConsole(); |
| if (isservice) { |
| if (!SetProcessWindowStation(hsavewinsta)) { |
| len = GetLastError(); |
| } |
| if (!SetThreadDesktop(hsavedesk)) { |
| len = GetLastError(); |
| } |
| CloseDesktop(hdesk); |
| CloseWindowStation(hwinsta); |
| } |
| return 0; |
| } |
| |
| |
| DWORD WINAPI feedback(LPVOID arg) |
| { |
| feedback_args_t *feed = (feedback_args_t*)arg; |
| char *str[1024]; |
| DWORD len; |
| |
| while (ReadFile(feed->in, str, sizeof(str), &len, NULL)) |
| if (!len || !WriteFile(feed->out, str, len, &len, NULL)) |
| break; |
| |
| printerr("[EOF] from Console (%d)\n", GetLastError()); |
| |
| return 0; |
| } |
