Win9xConHook.c revision bc8fd1b0b1afdf89b8d28eefa8cd74e26ba97986
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
#ifdef WIN32
/*
* Win9xConHook.dll - a hook proc to clean up Win95/98 console behavior.
*
* It is well(?) documented by Microsoft that the Win9x HandlerRoutine
* hooked by the SetConsoleCtrlHandler never receives the CTRL_CLOSE_EVENT,
* CTRL_LOGOFF_EVENT or CTRL_SHUTDOWN_EVENT signals.
*
* It is possible to have a second window to monitor the WM_ENDSESSION
* message, but the close button still fails..
*
* There is a 16bit polling method for the close window option, but this
* is CPU intensive and requires thunking.
*
* Attempts to subclass the 'tty' console fail, since that message thread
* is actually owned by the 16 bit winoldap.mod process, although the
* window reports it is owned by the process/thread of the console app.
*
* Win9xConHook is thunks the WM_CLOSE and WM_ENDSESSION messages,
* first through a window hook procedure in the winoldap context, into
* a subclass WndProc, and on to a second hidden monitor window in the
* console application's context that dispatches them to the console app's
* registered HandlerRoutine.
*/
/* This debugging define turns on output to COM1, although you better init
* the port first (even using hyperterm). It's the only way to catch the
* goings on within system logoff/shutdown.
* #define DBG 1
*/
#include <windows.h>
/* Variables used within any process context:
* hookwndmsg is a shared message to send Win9xConHook signals
* origwndprop is a wndprop atom to store the orig wndproc of the tty
* hookwndprop is a wndprop atom to store the hwnd of the hidden child
* is_service reminds us to unmark this process on the way out
*/
static UINT hookwndmsg = 0;
static LPCTSTR origwndprop;
static LPCTSTR hookwndprop;
static BOOL is_service = 0;
//static HMODULE hmodThis = NULL;
/* Variables used within the tty processes' context:
* is_tty flags this process; -1 == unknown, 1 == if tty, 0 == if not
* hw_tty is the handle of the top level tty in this process context
* is_subclassed is toggled to assure DllMain removes the subclass on unload
* hmodLock is there to try and prevent this dll from being unloaded if the
* hook is removed while we are subclassed
*/
static int is_tty = -1;
static HWND hwtty = NULL;
static BOOL is_subclassed = 0;
// This simply causes a gpfault the moment it tries to FreeLibrary within
// the subclass procedure ... not good.
//static HMODULE hmodLock = NULL;
/* Variables used within the service or console app's context:
* hmodHook is the instance handle of this module for registering the hooks
* hhkGetMessage is the hook handle for catching Posted messages
* hhkGetMessage is the hook handle for catching Sent messages
* monitor_hwnd is the invisible window that handles our tty messages
* the tty_info strucure is used to pass args into the hidden window's thread
*/
static HMODULE hmodHook = NULL;
static HHOOK hhkGetMessage;
//static HHOOK hhkCallWndProc;
static HWND monitor_hwnd = NULL;
typedef struct {
PHANDLER_ROUTINE phandler;
HINSTANCE instance;
HWND parent;
INT type;
LPCSTR name;
} tty_info;
/* These are the GetWindowLong offsets for the hidden window's internal info
* gwltty_phandler is the address of the app's HandlerRoutine
* gwltty_ttywnd is the tty this hidden window will handle messages from
*/
#define gwltty_phandler 0
#define gwltty_ttywnd 4
/* Forward declaration prototypes for internal functions
*/
static BOOL CALLBACK EnumttyWindow(HWND wnd, LPARAM retwnd);
static LRESULT WINAPI RegisterWindows9xService(BOOL set_service);
static LRESULT CALLBACK ttyConsoleCtrlWndProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam);
static DWORD WINAPI ttyConsoleCtrlThread(LPVOID tty);
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam);
static int HookProc(int hc, HWND *hwnd, UINT *msg,
WPARAM *wParam, LPARAM *lParam);
#ifdef DBG
static VOID DbgPrintf(LPTSTR fmt, ...);
#endif
/* DllMain is invoked by every process in the entire system that is hooked
* by our window hooks, notably the tty processes' context, and by the user
* who wants tty messages (the app). Keep it light and simple.
*/
BOOL __declspec(dllexport) APIENTRY DllMain(HINSTANCE hModule, ULONG ulReason,
LPVOID pctx)
{
if (ulReason == DLL_PROCESS_ATTACH)
{
//hmodThis = hModule;
if (!hookwndmsg) {
origwndprop = MAKEINTATOM(GlobalAddAtom("Win9xConHookOrigProc"));
hookwndprop = MAKEINTATOM(GlobalAddAtom("Win9xConHookThunkWnd"));
hookwndmsg = RegisterWindowMessage("Win9xConHookMsg");
}
#ifdef DBG
// DbgPrintf("H ProcessAttach:%8.8x\r\n",
// GetCurrentProcessId());
#endif
}
else if ( ulReason == DLL_PROCESS_DETACH )
{
#ifdef DBG
// DbgPrintf("H ProcessDetach:%8.8x\r\n", GetCurrentProcessId());
#endif
if (monitor_hwnd)
SendMessage(monitor_hwnd, WM_DESTROY, 0, 0);
if (is_subclassed)
SendMessage(hwtty, hookwndmsg, 0, (LPARAM)hwtty);
if (hmodHook)
{
if (hhkGetMessage) {
UnhookWindowsHookEx(hhkGetMessage);
hhkGetMessage = NULL;
}
//if (hhkCallWndProc) {
// UnhookWindowsHookEx(hhkCallWndProc);
// hhkCallWndProc = NULL;
//}
FreeLibrary(hmodHook);
hmodHook = NULL;
}
if (is_service)
RegisterWindows9xService(FALSE);
if (hookwndmsg) {
GlobalDeleteAtom((ATOM)origwndprop);
GlobalDeleteAtom((ATOM)hookwndprop);
hookwndmsg = 0;
}
}
return TRUE;
}
/* This group of functions are provided for the service/console app
* to register itself a HandlerRoutine to accept tty or service messages
*/
/* Exported function that creates a Win9x 'service' via a hidden window,
* that notifies the process via the HandlerRoutine messages.
*/
BOOL __declspec(dllexport) WINAPI Windows9xServiceCtrlHandler(
PHANDLER_ROUTINE phandler,
LPCSTR name)
{
/* If we have not yet done so */
FreeConsole();
if (name)
{
DWORD tid;
HANDLE hThread;
/* NOTE: this is static so the module can continue to
* access these args while we go on to other things
*/
static tty_info tty;
tty.instance = GetModuleHandle(NULL);
tty.phandler = phandler;
tty.parent = NULL;
tty.name = name;
tty.type = 2;
RegisterWindows9xService(TRUE);
hThread = CreateThread(NULL, 0, ttyConsoleCtrlThread,
(LPVOID)&tty, 0, &tid);
if (hThread)
{
CloseHandle(hThread);
return TRUE;
}
}
else /* remove */
{
if (monitor_hwnd)
SendMessage(monitor_hwnd, WM_DESTROY, 0, 0);
RegisterWindows9xService(FALSE);
return TRUE;
}
return FALSE;
}
/* Exported function that registers a HandlerRoutine to accept missing
* Win9x CTRL_EVENTs from the tty window, as NT does without a hassle.
* If add is 1 or 2, register the handler, if 2 also mark it as a service.
* If add is 0 deregister the handler, and unmark if a service
*/
BOOL __declspec(dllexport) WINAPI FixConsoleCtrlHandler(
PHANDLER_ROUTINE phandler,
INT add)
{
HWND parent;
if (add)
{
HANDLE hThread;
DWORD tid;
/* NOTE: this is static so the module can continue to
* access these args while we go on to other things
*/
static tty_info tty;
EnumWindows(EnumttyWindow, (LPARAM)&parent);
if (!parent) {
#ifdef DBG
DbgPrintf("A EnumttyWindow failed (%d)\r\n", GetLastError());
#endif
return FALSE;
}
tty.instance = GetModuleHandle(NULL);
tty.phandler = phandler;
tty.parent = parent;
tty.type = add;
if (add == 2) {
tty.name = "ttyService";
RegisterWindows9xService(TRUE);
}
else
tty.name = "ttyMonitor";
hThread = CreateThread(NULL, 0, ttyConsoleCtrlThread,
(LPVOID)&tty, 0, &tid);
if (!hThread)
return FALSE;
CloseHandle(hThread);
hmodHook = LoadLibrary("Win9xConHook.dll");
if (hmodHook)
{
hhkGetMessage = SetWindowsHookEx(WH_GETMESSAGE,
(HOOKPROC)GetProcAddress(hmodHook, "GetMsgProc"), hmodHook, 0);
//hhkCallWndProc = SetWindowsHookEx(WH_CALLWNDPROC,
// (HOOKPROC)GetProcAddress(hmodHook, "CallWndProc"), hmodHook, 0);
}
return TRUE;
}
else /* remove */
{
if (monitor_hwnd) {
SendMessage(monitor_hwnd, WM_DESTROY, 0, 0);
}
if (hmodHook)
{
if (hhkGetMessage) {
UnhookWindowsHookEx(hhkGetMessage);
hhkGetMessage = NULL;
}
//if (hhkCallWndProc) {
// UnhookWindowsHookEx(hhkCallWndProc);
// hhkCallWndProc = NULL;
//}
FreeLibrary(hmodHook);
hmodHook = NULL;
}
if (is_service)
RegisterWindows9xService(FALSE);
return TRUE;
}
return FALSE;
}
/* The following internal helpers are only used within the app's context
*/
/* ttyConsoleCreateThread is the process that runs within the user app's
* context. It creates and pumps the messages of a hidden monitor window,
* watching for messages from the system, or the associated subclassed tty
* window. Things can happen in our context that can't be done from the
* tty's context, and visa versa, so the subclass procedure and this hidden
* window work together to make it all happen.
*/
static DWORD WINAPI ttyConsoleCtrlThread(LPVOID tty)
{
WNDCLASS wc;
MSG msg;
wc.style = CS_GLOBALCLASS;
wc.lpfnWndProc = ttyConsoleCtrlWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 8;
wc.hInstance = NULL;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
if (((tty_info*)tty)->parent)
wc.lpszClassName = "ttyConHookChild";
else
wc.lpszClassName = "ApacheWin95ServiceMonitor";
if (!RegisterClass(&wc)) {
#ifdef DBG
DbgPrintf("A proc %8.8x Error creating class %s (%d)\r\n",
GetCurrentProcessId(), wc.lpszClassName, GetLastError());
#endif
return 0;
}
/* Create an invisible window */
monitor_hwnd = CreateWindow(wc.lpszClassName, ((tty_info*)tty)->name,
WS_OVERLAPPED & ~WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL,
((tty_info*)tty)->instance, tty);
if (!monitor_hwnd) {
#ifdef DBG
DbgPrintf("A proc %8.8x Error creating window %s %s (%d)\r\n",
GetCurrentProcessId(), wc.lpszClassName,
((tty_info*)tty)->name, GetLastError());
#endif
return 0;
}
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
/* Tag again as deleted, just in case we missed WM_DESTROY */
monitor_hwnd = NULL;
return 0;
}
/* This is the WndProc procedure for our invisible window.
* When our subclasssed tty window receives the WM_CLOSE, WM_ENDSESSION,
* or WM_QUERYENDSESSION messages, the message is dispatched to our hidden
* window (this message process), and we call the installed HandlerRoutine
* that was registered by the app.
*/
static LRESULT CALLBACK ttyConsoleCtrlWndProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
if (msg == WM_CREATE)
{
tty_info *tty = (tty_info*)(((LPCREATESTRUCT)lParam)->lpCreateParams);
SetWindowLong(hwnd, gwltty_phandler, (LONG)tty->phandler);
SetWindowLong(hwnd, gwltty_ttywnd, (LONG)tty->parent);
#ifdef DBG
DbgPrintf("A proc %8.8x created %8.8x %s for tty wnd %8.8x\r\n",
GetCurrentProcessId(), hwnd,
tty->name, tty->parent);
#endif
if (tty->parent) {
SetProp(tty->parent, hookwndprop, hwnd);
PostMessage(tty->parent, hookwndmsg,
tty->type, (LPARAM)tty->parent);
}
return 0;
}
else if (msg == WM_DESTROY)
{
HWND parent = (HWND)GetWindowLong(hwnd, gwltty_ttywnd);
#ifdef DBG
DbgPrintf("A proc %8.8x destroyed %8.8x ttyConHookChild\r\n",
GetCurrentProcessId(), hwnd);
#endif
if (parent) {
RemoveProp(parent, hookwndprop);
SendMessage(parent, hookwndmsg, 0, (LPARAM)parent);
}
monitor_hwnd = NULL;
}
else if (msg == WM_CLOSE)
{
PHANDLER_ROUTINE phandler =
(PHANDLER_ROUTINE)GetWindowLong(hwnd, gwltty_phandler);
LRESULT rv = phandler(CTRL_CLOSE_EVENT);
#ifdef DBG
DbgPrintf("A proc %8.8x invoked CTRL_CLOSE_EVENT "
"returning %d\r\n",
GetCurrentProcessId(), rv);
#endif
if (rv)
return !rv;
}
else if ((msg == WM_QUERYENDSESSION) || (msg == WM_ENDSESSION))
{
if (lParam & ENDSESSION_LOGOFF)
{
PHANDLER_ROUTINE phandler =
(PHANDLER_ROUTINE)GetWindowLong(hwnd, gwltty_phandler);
LRESULT rv = phandler(CTRL_LOGOFF_EVENT);
#ifdef DBG
DbgPrintf("A proc %8.8x invoked CTRL_LOGOFF_EVENT "
"returning %d\r\n",
GetCurrentProcessId(), rv);
#endif
if (rv)
return ((msg == WM_QUERYENDSESSION) ? rv : !rv);
}
else
{
PHANDLER_ROUTINE phandler =
(PHANDLER_ROUTINE)GetWindowLong(hwnd, gwltty_phandler);
LRESULT rv = phandler(CTRL_SHUTDOWN_EVENT);
#ifdef DBG
DbgPrintf("A proc %8.8x invoked CTRL_SHUTDOWN_EVENT "
"returning %d\r\n", GetCurrentProcessId(), rv);
#endif
if (rv)
return ((msg == WM_QUERYENDSESSION) ? rv : !rv);
}
}
return (DefWindowProc(hwnd, msg, wParam, lParam));
}
/* The following internal helpers are invoked by the hooked tty and our app
*/
/* Register or deregister the current process as a Windows9x style service.
* Experience shows this call is ignored across processes, so the second
* arg to RegisterServiceProcess (process group id) is effectively useless.
*/
static LRESULT WINAPI RegisterWindows9xService(BOOL set_service)
{
static HINSTANCE hkernel;
static DWORD (WINAPI *register_service_process)(DWORD, DWORD) = NULL;
BOOL rv;
if (set_service == is_service)
return 1;
#ifdef DBG
DbgPrintf("R %s proc %8.8x as a service\r\n",
set_service ? "installing" : "removing",
GetCurrentProcessId());
#endif
if (!register_service_process)
{
/* Obtain a handle to the kernel library */
hkernel = LoadLibrary("KERNEL32.DLL");
if (!hkernel)
return 0;
/* Find the RegisterServiceProcess function */
register_service_process = (DWORD (WINAPI *)(DWORD, DWORD))
GetProcAddress(hkernel, "RegisterServiceProcess");
if (register_service_process == NULL) {
FreeLibrary(hkernel);
return 0;
}
}
/* Register this process as a service */
rv = register_service_process(0, set_service != FALSE);
if (rv)
is_service = set_service;
if (!is_service)
{
/* Unload the kernel library */
FreeLibrary(hkernel);
register_service_process = NULL;
}
return rv;
}
/*
* This function only works when this process is the active process
* (e.g. once it is running a child process, it can no longer determine
* which console window is its own.)
*/
static BOOL CALLBACK EnumttyWindow(HWND wnd, LPARAM retwnd)
{
char tmp[8];
if (GetClassName(wnd, tmp, sizeof(tmp)) && !strcmp(tmp, "tty"))
{
DWORD wndproc, thisproc = GetCurrentProcessId();
GetWindowThreadProcessId(wnd, &wndproc);
if (wndproc == thisproc) {
*((HWND*)retwnd) = wnd;
return FALSE;
}
}
return TRUE;
}
/* The remaining code all executes --in the tty's own process context--
*
* That means special attention must be paid to what it's doing...
*/
/* Subclass message process for the tty window
*
* This code -handles- WM_CLOSE, WM_ENDSESSION and WM_QUERYENDSESSION
* by dispatching them to the window identified by the hookwndprop
* property atom set against our window. Messages are then dispatched
* to origwndprop property atom we set against the window when we
* injected this subclass. This trick did not work with simply a hook.
*/
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
WNDPROC origproc = (WNDPROC) GetProp(hwnd, origwndprop);
if (!origproc)
return 0;
if (msg == WM_NCDESTROY
|| (msg == hookwndmsg && !LOWORD(wParam) && (HWND)lParam == hwnd))
{
if (is_subclassed) {
#ifdef DBG
DbgPrintf("W proc %08x hwnd:%08x Subclass removed\r\n",
GetCurrentProcessId(), hwnd);
#endif
if (is_service)
RegisterWindows9xService(FALSE);
SetWindowLong(hwnd, GWL_WNDPROC, (LONG)origproc);
RemoveProp(hwnd, origwndprop);
RemoveProp(hwnd, hookwndprop);
is_subclassed = FALSE;
//if (hmodLock)
// FreeLibrary(hmodLock);
//hmodLock = NULL;
}
}
else if (msg == WM_CLOSE || msg == WM_ENDSESSION
|| msg == WM_QUERYENDSESSION)
{
HWND child = (HWND)GetProp(hwnd, hookwndprop);
if (child) {
#ifdef DBG
DbgPrintf("W proc %08x hwnd:%08x forwarded msg:%d\r\n",
GetCurrentProcessId(), hwnd, msg);
#endif
return SendMessage(child, msg, wParam, lParam);
}
}
return CallWindowProc(origproc, hwnd, msg, wParam, lParam);
}
/* HookProc, once installed, is responsible for subclassing the system
* tty windows. It generally does nothing special itself, since
* research indicates that it cannot deal well with the messages we are
* interested in, that is, WM_CLOSE, WM_QUERYSHUTDOWN and WM_SHUTDOWN
* of the tty process.
*
* Respond and subclass only when a WM_NULL is received by the window.
*/
int HookProc(int hc, HWND *hwnd, UINT *msg, WPARAM *wParam, LPARAM *lParam)
{
if (is_tty == -1 && *hwnd)
{
char ttybuf[8];
HWND htty;
hwtty = *hwnd;
while (htty = GetParent(hwtty))
hwtty = htty;
is_tty = (GetClassName(hwtty, ttybuf, sizeof(ttybuf))
&& !strcmp(ttybuf, "tty"));
#ifdef DBG
if (is_tty)
DbgPrintf("H proc %08x tracking hwnd %08x\r\n",
GetCurrentProcessId(), hwtty);
#endif
}
if (*msg == hookwndmsg && *wParam && *lParam == (LPARAM)hwtty && is_tty)
{
WNDPROC origproc = (WNDPROC)GetWindowLong(hwtty, GWL_WNDPROC);
//char myname[MAX_PATH];
//if (GetModuleFileName(hmodThis, myname, sizeof(myname)))
// hmodLock = LoadLibrary(myname);
SetProp(hwtty, origwndprop, origproc);
SetWindowLong(hwtty, GWL_WNDPROC, (LONG)WndProc);
is_subclassed = TRUE;
#ifdef DBG
DbgPrintf("H proc %08x hwnd:%08x Subclassed\r\n",
GetCurrentProcessId(), hwtty);
#endif
if (LOWORD(*wParam) == 2)
RegisterWindows9xService(TRUE);
}
return -1;
}
/*
* PostMessage Hook:
*/
LRESULT __declspec(dllexport) CALLBACK GetMsgProc(INT hc, WPARAM wParam,
LPARAM lParam)
{
PMSG pmsg;
pmsg = (PMSG)lParam;
if (pmsg) {
int rv = HookProc(hc, &pmsg->hwnd, &pmsg->message,
&pmsg->wParam, &pmsg->lParam);
if (rv != -1)
return rv;
}
/*
* CallNextHookEx apparently ignores the hhook argument, so pass NULL
*/
return CallNextHookEx(NULL, hc, wParam, lParam);
}
/*
* SendMessage Hook:
*/
LRESULT __declspec(dllexport) CALLBACK CallWndProc(INT hc, WPARAM wParam,
LPARAM lParam)
{
PCWPSTRUCT pcwps = (PCWPSTRUCT)lParam;
if (pcwps) {
int rv = HookProc(hc, &pcwps->hwnd, &pcwps->message,
&pcwps->wParam, &pcwps->lParam);
if (rv != -1)
return rv;
}
/*
* CallNextHookEx apparently ignores the hhook argument, so pass NULL
*/
return CallNextHookEx(NULL, hc, wParam, lParam);
}
#ifdef DBG
VOID DbgPrintf(
LPTSTR fmt,
...
)
{
static HANDLE mutex;
va_list marker;
TCHAR szBuf[256];
DWORD t;
HANDLE gDbgOut;
va_start(marker, fmt);
wvsprintf(szBuf, fmt, marker);
va_end(marker);
if (!mutex)
mutex = CreateMutex(NULL, FALSE, "Win9xConHookDbgOut");
WaitForSingleObject(mutex, INFINITE);
gDbgOut = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
WriteFile(gDbgOut, szBuf, strlen(szBuf), &t, NULL);
CloseHandle(gDbgOut);
ReleaseMutex(mutex);
}
#endif
#endif /* WIN32 */