|
|
//****************************************************************************
// WOW32 fax support.
//
// History:
// 02-jan-95 nandurir created.
// 01-feb-95 reedb Clean-up, support printer install and bug fixes.
//
//****************************************************************************
//****************************************************************************
// This expalins how all this works (sort of) using WinFax as example.
// Install:
// 1. Setup app calls WriteProfileString("devices","WINFAX","WINFAX,Com1:")
// to register a "printer" in Win.ini a-la Win3.1
// 2. Our thunks of WritexxxProfileString() look for the "devices" string
// and pass the call to IsFaxPrinterWriteProfileString(lpszSection,lpszKey,
// lpszString).
// 3. If lpszKey ("WINFAX" in this case) is in our supported fax drivers list
// (See Reg\SW\MS\WinNT\CurrentVersion\WOW\WOWFax\SupportedFaxDrivers)
// (by call to IsFaxPrinterSupportedDevice()), we call InstallWowFaxPrinter
// to add the printer the NT way -- via AddPrinter().
// 4. To set up the call to AddPrinter, we copy WOWFAX.DLL and WOWFAXUI.DLL to
// the print spooler driver directory (\NT\system32\spool\drivers\w32x86\2)
// 5. We next call AddPrinterDriver to register the wowfax driver.
// 6. We then call wow32!DoAddPrinterStuff which launches a new thread,
// wow32!AddPrinterThread, which calls winspool.drv!AddPrinter() for us. The
// PrinterInfo.pPrinterName = the 16-bit fax driver name,"WINFAX" in this
// case. WinSpool.drv then does a RPC call into the spooler.
// 7. During the AddPrinter() call, the spooler calls back into the driver to
// get driver specific info. These callbacks are handled by our WOWFAX
// driver in the spooler's process. They essentially callback into WOW
// via wow32!WOWFaxWndProc().
// 8. WOWFaxWndProc() passes the callback onto WOW32FaxHandler, which calls
// back to wowexec!FaxWndProc().
// 9. FaxWndProc then calls the 16-bit LoadLibrary() to open the 16-bit fax
// driver (WinFax.drv in this case).
// 10. The messages sent to FaxWndProc tell it which exported function it needs
// call in the 16-bit driver on behalf of the spooler.
// 11. Any info the spooler wants to pass to the 16-bit driver or get from it
// essentially goes through the mechanism in steps 7 - 10.
// Now you know (sort of).
//****************************************************************************
//
// Notes on what allows us to support a 16-bit fax driver:
// Essentially we have to know in advance which API's an app will call in the
// driver so we can handle the thunks. It turns out that fax drivers only
// need to export a small essential list of API's:
// Control, Disable, Enable, BitBlt, ExtDeviceMode, DeviceCapabilities
// (see mvdm\inc\wowfax.h\_WOWFAXINFO16 struct (all the PASCAL declarations)
// and mvdm\wow16\test\shell\wowexfax.c\FaxWndProc() )
// The list is way too big to support 16-bit printer & display drivers.
// If a 16-bit fax driver exports these API's there's a pretty good chance
// we can support it in WOW. Other issues to look into: the dlgproc's the
// driver export's, any obsolete Win 3.0 API's that the NT spooler won't know
// how to call.
//
//****************************************************************************
#include "precomp.h"
#pragma hdrstop
#define WOWFAX_INC_COMMON_CODE
#include "wowgdip.h"
#define DEFINE_DDRV_DEBUG_STRINGS
#include "wowfax.h"
#include "winddi.h"
#include "winspool.h"
MODNAME(wowfax.c);
typedef struct _WOWADDPRINTER { LPVOID pPrinterStuff; INT iCode; BOOL bRet;} WOWADDPRINTER, *PWOWADDPRINTER;
//****************************************************************************
// globals -
//
//****************************************************************************
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo);DWORD ExtDevModeHandler(LPWOWFAXINFO lpfaxinfo);BOOL ConvertDevMode(PDEVMODE16 lpdm16, LPDEVMODEW lpdmW, BOOL fTo16);BOOL ConvertGdiInfo(LPGDIINFO16 lpginfo16, PGDIINFO lpginfo, BOOL fTo16);
extern HANDLE hmodWOW32;
LPWOWFAXINFO glpfaxinfoCur = 0;WOWFAXINFO gfaxinfo;
UINT uNumSupFaxDrv;LPSTR *SupFaxDrv;
//****************************************************************************
// SortedInsert - Alpha sort.
//****************************************************************************
VOID SortedInsert(LPSTR lpElement, LPSTR *alpList){ LPSTR lpTmp, lpSwap;
while (*alpList) { if (WOW32_stricmp(lpElement, *alpList) < 0) { break; } alpList++; } lpTmp = *alpList; *alpList++ = lpElement; while (lpTmp) { // SWAP(*alpList, lpTmp);
lpSwap = *alpList; *alpList = lpTmp; lpTmp = lpSwap; alpList++; }}
//****************************************************************************
// BuildStrList - Find the starting point of strings in a list (lpList) of
// NULL terminated strings which is double NULL terminated.
// If a non-NULL alpList parameter is passed, it will be
// filled with an array of pointers to the starting point
// of each string in the list. The number of strings in the
// list is always returned.
//****************************************************************************
UINT BuildStrList(LPSTR lpList, LPSTR *alpList){ LPSTR lp; TCHAR cLastChar = 1; UINT uCount = 0;
lp = lpList; while ((cLastChar) || (*lp)) { if ((*lp == 0) && (lp != lpList)) { uCount++; }
if ((lpList == lp) || (cLastChar == 0)) { if ((*lp) && (alpList)) { SortedInsert(lp, alpList); } } cLastChar = *lp++; } return uCount;}
//****************************************************************************
// GetSupportedFaxDrivers - Read in the SupFaxDrv name list from the
// registry. This list is used to determine if we will
// install a 16-bit fax printer driver during
// WriteProfileString and WritePrivateProfileString.
//****************************************************************************
LPSTR *GetSupportedFaxDrivers(UINT *uCount){ HKEY hKey = 0; DWORD dwType; DWORD cbBufSize=0; LPSTR lpSupFaxDrvBuf; LPSTR *alpSupFaxDrvList = NULL;
*uCount = 0;
// Open the registry key.
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\\SupportedFaxDrivers", 0, KEY_READ, &hKey ) != ERROR_SUCCESS) { goto GSFD_error; }
// Query value for size of buffer and allocate.
if (RegQueryValueEx(hKey, "DriverNames", 0, &dwType, NULL, &cbBufSize) != ERROR_SUCCESS) { goto GSFD_error; } if ((dwType != REG_MULTI_SZ) || ((lpSupFaxDrvBuf = (LPSTR) malloc_w(cbBufSize)) == NULL)) { goto GSFD_error; }
if (RegQueryValueEx(hKey, "DriverNames", 0, &dwType, lpSupFaxDrvBuf, &cbBufSize) != ERROR_SUCCESS) { goto GSFD_error; }
// Get the number of elements in the list
if (*uCount = BuildStrList(lpSupFaxDrvBuf, NULL)) { // Build an array of pointers to the start of the strings in the list.
alpSupFaxDrvList = (LPSTR *) malloc_w(*uCount * sizeof(LPSTR)); if (alpSupFaxDrvList) { // Fill the array with string starting points.
RtlZeroMemory(alpSupFaxDrvList, *uCount * sizeof(LPSTR)); BuildStrList(lpSupFaxDrvBuf, alpSupFaxDrvList); } else { goto GSFD_error; } } goto GSFD_exit;
GSFD_error: LOGDEBUG(0,("WOW32!GetSupportedFaxDrivers failed!\n"));
GSFD_exit: if (hKey) { RegCloseKey(hKey); } return alpSupFaxDrvList;}
//****************************************************************************
// WowFaxWndProc - This is the 32-bit WndProc which will SubClass the 16-bit
// FaxWndProc in WOWEXEC.EXE. It's main function is to
// convert 32-bit data passed from the WOW 32-bit generic
// fax driver to 16-bit data to be used by the various 16-bit
// fax printer drivers.
//****************************************************************************
LONG WowFaxWndProc(HWND hwnd, UINT uMsg, UINT uParam, LONG lParam){ TCHAR lpPath[MAX_PATH]; HANDLE hMap;
if ((uMsg >= WM_DDRV_FIRST) && (uMsg <= WM_DDRV_LAST)) { //
// WM_DDRV_* message: uParam = idMap
// lParam = unused.
//
// The corresponding data is obtained from the shared memory.
//
GetFaxDataMapName(uParam, lpPath); hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, lpPath); if (hMap) { LPWOWFAXINFO lpT; if (lpT = (LPWOWFAXINFO)MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0)) { WOW32FaxHandler(lpT->msg, (LPSTR)lpT);
// Set the status to TRUE indicating that the message
// has been 'processed' by WOW. This doesnot indicate
// the success or the failure of the actual processing
// of the message.
lpT->status = TRUE; UnmapViewOfFile(lpT); CloseHandle(hMap); return(TRUE); } CloseHandle(hMap); } LOGDEBUG(0,("WowFaxWndProc failed to setup shared data mapping!\n")); // WOW32ASSERT(FALSE); // turn this off - Procomm tries to install
// this many times.
} else {
// Not a WM_DDRV_* message. Pass it on to the original proc.
return CallWindowProc(gfaxinfo.proc16, hwnd, uMsg, uParam, lParam); } return(TRUE);}
//**************************************************************************
// WOW32FaxHandler -
//
// Handles various WowFax related operations.
//
//**************************************************************************
ULONG WOW32FaxHandler(UINT iFun, LPSTR lpIn){ LPWOWFAXINFO lpT = (LPWOWFAXINFO)lpIn; LPWOWFAXINFO16 lpT16; HWND hwnd = gfaxinfo.hwnd; LPBYTE lpData; VPVOID vp;
#ifdef DEBUG
int DebugStringIndex = iFun - (WM_USER+0x100+1);
if ((DebugStringIndex >= WM_DDRV_FIRST) && (DebugStringIndex <= WM_DDRV_LAST) ) { LOGDEBUG(0,("WOW32FaxHandler, %s, 0x%lX\n", (LPSTR)szWmDdrvDebugStrings[DebugStringIndex], (LPSTR) lpIn)); }#endif
switch (iFun) { case WM_DDRV_SUBCLASS: //
// Subclass the window - This is so that we get a chance to
// transform the 32bit data to 16bit data and vice versa. A
// NULL HWND, passed in lpIn, indicates don't subclass.
//
if (gfaxinfo.hwnd = (HWND)lpIn) { gfaxinfo.proc16 = (WNDPROC)SetWindowLong((HWND)lpIn, GWL_WNDPROC, (DWORD)WowFaxWndProc); gfaxinfo.tid = GetWindowThreadProcessId((HWND)lpIn, NULL); }
WOW32ASSERT(sizeof(DEVMODE16) + 4 == sizeof(DEVMODE31));
//
// Read in the SupFaxDrv name list from the registry.
//
SupFaxDrv = GetSupportedFaxDrivers(&uNumSupFaxDrv);
break;
case WM_DDRV_ENABLE:
// Enable the driver:
// . first intialize the 16bit faxinfo datastruct
// . then inform the driver (dll name) to be loaded
//
// format of ddrv_message:
// wParam = hdc (just a unique id)
// lparam = 16bit faxinfo struct with relevant data
// Must call 'callwindowproc' not 'sendmessage' because
// WowFaxWndProc is a subclass of the 16-bit FaxWndProc.
//
WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL); lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16, hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0); if (lpT->lpinfo16) { vp = malloc16(lpT->cData); GETVDMPTR(vp, lpT->cData, lpData); if (lpData == 0) { break; }
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16); if (lpT16) { if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) { WideCharToMultiByte(CP_ACP, 0, lpT->szDeviceName, lstrlenW(lpT->szDeviceName) + 1, lpT16->szDeviceName, sizeof(lpT16->szDeviceName), NULL, NULL);
lpT16->lpDriverName = lpT->lpDriverName; if (lpT->lpDriverName) { lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName; WideCharToMultiByte(CP_ACP, 0, (PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName), lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1, lpData + (DWORD)lpT->lpDriverName, lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1, NULL, NULL); }
lpT16->lpPortName = lpT->lpPortName; if (lpT->lpPortName) { lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpT->lpPortName; WideCharToMultiByte(CP_ACP, 0, (PWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName), lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1, lpData + (DWORD)lpT->lpPortName, lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1, NULL, NULL); }
lpT16->lpIn = lpT->lpIn;
if (lpT->lpIn) { lpT16->lpIn = (LPBYTE)vp + (DWORD)lpT->lpIn; ConvertDevMode((PDEVMODE16)(lpData + (DWORD)lpT->lpIn), (LPDEVMODEW)((LPSTR)lpT + (DWORD)lpT->lpIn), TRUE); } WOW32ASSERT((sizeof(GDIINFO16) + sizeof(POINT16)) <= sizeof(GDIINFO)); lpT16->lpOut = (LPBYTE)vp + (DWORD)lpT->lpOut; FREEVDMPTR(lpData); FREEVDMPTR(lpT16); lpT->retvalue = CallWindowProc( gfaxinfo.proc16, hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16); if (lpT->retvalue) { GETVDMPTR(vp, lpT->cData, lpData); ConvertGdiInfo((LPGDIINFO16)(lpData + (DWORD)lpT->lpOut), (PGDIINFO)((LPSTR)lpT + (DWORD)lpT->lpOut), FALSE);
} } } free16(vp); } break;
case WM_DDRV_ESCAPE: GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16); if (lpT16) { lpT16->wCmd = lpT->wCmd; } FREEVDMPTR(lpT16); lpT->retvalue = CallWindowProc( gfaxinfo.proc16, hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16); break;
case WM_DDRV_PRINTPAGE: //
// set the global variable. When the 16bit driver calls DMBitBlt we
// get the bitmap info from here. Since WOW is single threaded we
// won't receive another printpage msg before we return from here.
//
// All pointers in the faxinfo structure are actually
// 'offsets from the start of the mapfile' to relevant data.
//
glpfaxinfoCur = lpT; lpT->lpbits = (LPBYTE)lpT + (DWORD)lpT->lpbits;
// fall through;
case WM_DDRV_STARTDOC: // WowFax (EasyFax Ver2.0) support...
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16); if (lpT16) { WideCharToMultiByte(CP_ACP, 0, lpT->szDocName, lstrlenW(lpT->szDocName) + 1, lpT16->szDocName, sizeof(lpT16->szDocName), NULL, NULL); } lpT->retvalue = CallWindowProc( gfaxinfo.proc16, hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16); break;
case WM_DDRV_ENDDOC: lpT->retvalue = CallWindowProc( gfaxinfo.proc16, hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16); break;
case WM_DDRV_DISABLE: CallWindowProc( gfaxinfo.proc16, hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16); lpT->retvalue = TRUE; break;
case WM_DDRV_EXTDMODE: case WM_DDRV_DEVCAPS: WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL); lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16, hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0); if (lpT->lpinfo16) { vp = malloc16(lpT->cData); GETVDMPTR(vp, lpT->cData, lpData); if (lpData == 0) { break; } GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16); if (lpT16) { if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) { WideCharToMultiByte(CP_ACP, 0, lpT->szDeviceName, lstrlenW(lpT->szDeviceName) + 1, lpT16->szDeviceName, sizeof(lpT16->szDeviceName), NULL, NULL);
lpT16->lpDriverName = lpT->lpDriverName; if (lpT->lpDriverName) { lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName; WideCharToMultiByte(CP_ACP, 0, (PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName), lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1, lpData + (DWORD)lpT->lpDriverName, lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1, NULL, NULL); }
FREEVDMPTR(lpData); FREEVDMPTR(lpT16); lpT->retvalue = CallWindowProc( gfaxinfo.proc16, hwnd, WM_DDRV_LOAD, lpT->hdc, (LPARAM)lpT->lpinfo16); if (lpT->retvalue) { lpT->retvalue = (iFun == WM_DDRV_DEVCAPS) ? DeviceCapsHandler(lpT) : ExtDevModeHandler(lpT) ; } CallWindowProc( gfaxinfo.proc16, hwnd, WM_DDRV_UNLOAD, lpT->hdc, (LPARAM)lpT->lpinfo16); } } free16(vp); } break; }
return TRUE;}
//**************************************************************************
// gDC_CopySize -
//
// Indicates the size of a list item in bytes for use during
// the DeviceCapsHandler thunk. A zero entry indicates that an
// allocate and copy is not needed for the query.
//
//**************************************************************************
BYTE gDC_ListItemSize[DC_COPIES + 1] = { 0, 0, // DC_FIELDS 1
sizeof(WORD), // DC_PAPERS 2
sizeof(POINT), // DC_PAPERSIZE 3
sizeof(POINT), // DC_MINEXTENT 4
sizeof(POINT), // DC_MAXEXTENT 5
sizeof(WORD), // DC_BINS 6
0, // DC_DUPLEX 7
0, // DC_SIZE 8
0, // DC_EXTRA 9
0, // DC_VERSION 10
0, // DC_DRIVER 11
24, // DC_BINNAMES 12 //ANSI
sizeof(LONG) * 2, // DC_ENUMRESOLUTIONS 13
64, // DC_FILEDEPENDENCIES 14 //ANSI
0, // DC_TRUETYPE 15
64, // DC_PAPERNAMES 16 //ANSI
0, // DC_ORIENTATION 17
0 // DC_COPIES 18
};
//**************************************************************************
// DeviceCapsHandler -
//
// Makes a single call down to the 16-bit printer driver for queries
// which don't need to allocate and copy. For queries which do, two
// calls to the 16-bit printer driver are made. One to get the number
// of items, and a second to get the actual data.
//
//**************************************************************************
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo){ LPWOWFAXINFO16 lpWFI16; LPSTR lpSrc; LPBYTE lpDest; INT i; DWORD cbData16; // Size of data items.
UINT cbUni;
LOGDEBUG(0,("DeviceCapsHandler, lpfaxinfo: %X, wCmd: %X\n", lpfaxinfo, lpfaxinfo->wCmd));
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpWFI16);
// Get the number of data items with a call to the 16-bit printer driver.
lpWFI16->lpDriverName = 0; lpWFI16->lpPortName = 0; lpWFI16->wCmd = lpfaxinfo->wCmd; lpWFI16->cData = 0; lpWFI16->lpOut = 0; lpfaxinfo->cData = 0;
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd, lpfaxinfo->msg, lpfaxinfo->hdc, (LPARAM)lpfaxinfo->lpinfo16);
cbData16 = gDC_ListItemSize[lpfaxinfo->wCmd]; if (lpfaxinfo->lpOut && cbData16 && lpfaxinfo->retvalue) {
// We need to allocate and copy for this query
lpWFI16->cData = cbData16 * lpfaxinfo->retvalue;
// assert the size of output buffer - and set it the actual data size
switch (lpfaxinfo->wCmd) { case DC_BINNAMES: case DC_PAPERNAMES: // These fields need extra room for ANSI to UNICODE conversion.
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData * sizeof(WCHAR)); lpfaxinfo->cData = lpWFI16->cData * sizeof(WCHAR); break; default: WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData); lpfaxinfo->cData = lpWFI16->cData; break; }
if ((lpWFI16->lpOut = (LPSTR)malloc16(lpWFI16->cData)) == NULL) { lpfaxinfo->retvalue = 0; goto LeaveDeviceCapsHandler; }
// Get the list data with a call to the 16-bit printer driver.
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd, lpfaxinfo->msg, lpfaxinfo->hdc, (LPARAM)lpfaxinfo->lpinfo16);
GETVDMPTR(lpWFI16->lpOut, 0, lpSrc); lpDest = (LPBYTE)lpfaxinfo + (DWORD)lpfaxinfo->lpOut;
switch (lpfaxinfo->wCmd) { case DC_BINNAMES: case DC_PAPERNAMES: for (i = 0; i < (INT)lpfaxinfo->retvalue; i++) { RtlMultiByteToUnicodeN((LPWSTR)lpDest, cbData16 * sizeof(WCHAR), (PULONG)&cbUni, (LPBYTE)lpSrc, cbData16); lpDest += cbData16 * sizeof(WCHAR); lpSrc += cbData16; } break;
default:#ifdef FE_SB // for buggy fax driver such as CB-FAX Pro (Bother Corp.)
try { RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData); } except(EXCEPTION_EXECUTE_HANDLER) { // What can I do for the exception... ????
// Anyway, we don't want to die.....
#if DBG
LOGDEBUG(0,("Exception during copying some data\n")); #endif
}#else // !FE_SB
RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData);#endif // !FE_SB
break; } free16((VPVOID)lpWFI16->lpOut); FREEVDMPTR(lpSrc); }
LeaveDeviceCapsHandler: FREEVDMPTR(lpWFI16); return lpfaxinfo->retvalue;}
//**************************************************************************
// ExtDevModeHandler
//
//**************************************************************************
DWORD ExtDevModeHandler(LPWOWFAXINFO lpfaxinfo){ LPWOWFAXINFO16 lpT16; LPSTR lpT; VPVOID vp;
LOGDEBUG(0,("ExtDevModeHandler\n"));
(LONG)lpfaxinfo->retvalue = -1;
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
if (lpT16) {
// assumption that 16bit data won't be larger than 32bit data.
// this makes life easy in two ways; first we don't need to calculate
// the exact size and secondly the 16bit pointers can be set to same
// relative offsets as input(32 bit) pointers
vp = malloc16(lpfaxinfo->cData); if (vp) { GETVDMPTR(vp, lpfaxinfo->cData, lpT); if (lpT) { lpT16->wCmd = lpfaxinfo->wCmd; lpT16->lpOut = (LPSTR)lpfaxinfo->lpOut; lpT16->lpIn = (LPSTR)lpfaxinfo->lpIn; lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpDriverName; lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpPortName; WideCharToMultiByte(CP_ACP, 0, (PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName), lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1, lpT + (DWORD)lpfaxinfo->lpDriverName, lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1, NULL, NULL); WideCharToMultiByte(CP_ACP, 0, (PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName), lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1, lpT + (DWORD)lpfaxinfo->lpPortName, lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1, NULL, NULL); if (lpfaxinfo->lpIn) { lpT16->lpIn = (LPBYTE)vp + (DWORD)lpfaxinfo->lpIn; ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpIn), (LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpIn), TRUE); }
if (lpfaxinfo->lpOut) { lpT16->lpOut = (LPBYTE)vp + (DWORD)lpfaxinfo->lpOut; }
lpT16->hwndui = GETHWND16(lpfaxinfo->hwndui);
FREEVDMPTR(lpT); lpfaxinfo->retvalue = CallWindowProc( gfaxinfo.proc16, gfaxinfo.hwnd, lpfaxinfo->msg, lpfaxinfo->hdc, (LPARAM)lpfaxinfo->lpinfo16);
if ((lpfaxinfo->wCmd == 0) && (lpfaxinfo->retvalue > 0)) { // the 16bit driver has returned 16bit struct size. change
// the return value to correspond to the devmodew struct.
//
// since devmode16 (the 3.0 version) is smaller than devmode31
// the retvalue will take careof both win30/win31 devmode
WOW32ASSERT(sizeof(DEVMODE16) < sizeof(DEVMODE31)); lpfaxinfo->retvalue += (sizeof(DEVMODEW) - sizeof(DEVMODE16)); }
GETVDMPTR(vp, lpfaxinfo->cData, lpT);
if ((lpfaxinfo->wCmd & DM_COPY) && lpfaxinfo->lpOut && (lpfaxinfo->retvalue == IDOK)) { ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpOut), (LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpOut), FALSE); }
} free16(vp); }
}
FREEVDMPTR(lpT16);
return lpfaxinfo->retvalue;}
//***************************************************************************
// ConvertDevMode
//***************************************************************************
BOOL ConvertDevMode(PDEVMODE16 lpdm16, LPDEVMODEW lpdmW, BOOL fTo16){ LOGDEBUG(0,("ConvertDevMode\n"));
if (!lpdm16 || !lpdmW) return TRUE;
if (fTo16) { RtlZeroMemory(lpdm16, sizeof(DEVMODE16));
WideCharToMultiByte(CP_ACP, 0, lpdmW->dmDeviceName, sizeof(lpdmW->dmDeviceName) / sizeof(lpdmW->dmDeviceName[0]), lpdm16->dmDeviceName, sizeof(lpdm16->dmDeviceName) / sizeof(lpdm16->dmDeviceName[0]), NULL, NULL);
lpdm16->dmSpecVersion = lpdmW->dmSpecVersion; lpdm16->dmDriverVersion = lpdmW->dmDriverVersion; lpdm16->dmSize = lpdmW->dmSize; lpdm16->dmDriverExtra = lpdmW->dmDriverExtra; lpdm16->dmFields = lpdmW->dmFields; lpdm16->dmOrientation = lpdmW->dmOrientation; lpdm16->dmPaperSize = lpdmW->dmPaperSize; lpdm16->dmPaperLength = lpdmW->dmPaperLength; lpdm16->dmPaperWidth = lpdmW->dmPaperWidth; lpdm16->dmScale = lpdmW->dmScale; lpdm16->dmCopies = lpdmW->dmCopies; lpdm16->dmDefaultSource = lpdmW->dmDefaultSource; lpdm16->dmPrintQuality = lpdmW->dmPrintQuality; lpdm16->dmColor = lpdmW->dmColor; lpdm16->dmDuplex = lpdmW->dmDuplex;
// adjust lpdm16->dmSize (between win30 and win31 version)
lpdm16->dmSize = (lpdm16->dmSpecVersion > 0x300) ? sizeof(DEVMODE31) : sizeof(DEVMODE16); if (lpdm16->dmSize >= sizeof(DEVMODE31)) { ((PDEVMODE31)lpdm16)->dmYResolution = lpdmW->dmYResolution; ((PDEVMODE31)lpdm16)->dmTTOption = lpdmW->dmTTOption; }
RtlCopyMemory((LPBYTE)lpdm16 + (DWORD)lpdm16->dmSize, (lpdmW + 1), lpdmW->dmDriverExtra); } else {
// LATER: should specversion be NT version rather than win30 driver version?
MultiByteToWideChar(CP_ACP, 0, lpdm16->dmDeviceName, sizeof(lpdm16->dmDeviceName) / sizeof(lpdm16->dmDeviceName[0]), lpdmW->dmDeviceName, sizeof(lpdmW->dmDeviceName) / sizeof(lpdmW->dmDeviceName[0]));
lpdmW->dmSpecVersion = lpdm16->dmSpecVersion; lpdmW->dmDriverVersion = lpdm16->dmDriverVersion; lpdmW->dmSize = lpdm16->dmSize; lpdmW->dmDriverExtra = lpdm16->dmDriverExtra; lpdmW->dmFields = lpdm16->dmFields; lpdmW->dmOrientation = lpdm16->dmOrientation; lpdmW->dmPaperSize = lpdm16->dmPaperSize; lpdmW->dmPaperLength = lpdm16->dmPaperLength; lpdmW->dmPaperWidth = lpdm16->dmPaperWidth; lpdmW->dmScale = lpdm16->dmScale; lpdmW->dmCopies = lpdm16->dmCopies; lpdmW->dmDefaultSource = lpdm16->dmDefaultSource; lpdmW->dmPrintQuality = lpdm16->dmPrintQuality; lpdmW->dmColor = lpdm16->dmColor; lpdmW->dmDuplex = lpdm16->dmDuplex;
if (lpdm16->dmSize >= sizeof(DEVMODE31)) { lpdmW->dmYResolution = ((PDEVMODE31)lpdm16)->dmYResolution; lpdmW->dmTTOption = ((PDEVMODE31)lpdm16)->dmTTOption; }
// 16bit world doesnot know anything about the fields like
// formname etc.
RtlCopyMemory(lpdmW + 1, (LPBYTE)lpdm16 + lpdm16->dmSize, lpdm16->dmDriverExtra);
// adjust size for 32bit world
lpdmW->dmSize = sizeof(*lpdmW);
}
return TRUE;}
//**************************************************************************
// ConvertGdiInfo
//
//**************************************************************************
BOOL ConvertGdiInfo(LPGDIINFO16 lpginfo16, PGDIINFO lpginfo, BOOL fTo16){ LOGDEBUG(0,("ConvertGdiInfo\n"));
if (!lpginfo16 || !lpginfo) return FALSE;
if (!fTo16) { lpginfo->ulTechnology = lpginfo16->dpTechnology; lpginfo->ulLogPixelsX = lpginfo16->dpLogPixelsX; lpginfo->ulLogPixelsY = lpginfo16->dpLogPixelsY; lpginfo->ulDevicePelsDPI = lpginfo->ulLogPixelsX; lpginfo->ulHorzSize = lpginfo16->dpHorzSize; lpginfo->ulVertSize = lpginfo16->dpVertSize; lpginfo->ulHorzRes = lpginfo16->dpHorzRes; lpginfo->ulVertRes = lpginfo16->dpVertRes; lpginfo->cBitsPixel = lpginfo16->dpBitsPixel; lpginfo->cPlanes = lpginfo16->dpPlanes; lpginfo->ulNumColors = lpginfo16->dpNumColors; lpginfo->ptlPhysOffset.x = ((PPOINT16)(lpginfo16+1))->x; lpginfo->ptlPhysOffset.y = ((PPOINT16)(lpginfo16+1))->y; lpginfo->szlPhysSize.cx = lpginfo->ulHorzRes; lpginfo->szlPhysSize.cy = lpginfo->ulVertRes; lpginfo->ulPanningHorzRes = lpginfo->ulHorzRes; lpginfo->ulPanningVertRes = lpginfo->ulVertRes; lpginfo->ulAspectX = lpginfo16->dpAspectX; lpginfo->ulAspectY = lpginfo16->dpAspectY; lpginfo->ulAspectXY = lpginfo16->dpAspectXY;
//
// RASDD tries to be smart as to whether the x and y DPI are equal or
// not. In the case of 200dpi in the x direction and 100dpi in the
// y direction, you may want to adjust this to 2 for xStyleStep, 1 for
// yStyleStep and dpi/50 for denStyleStep. This basicaly determines
// how long dashes/dots will be when drawing with styled pens.
// Since we just hard code denStyleStep to 3, we get different lines
// at 100dpi vs 200dpi
//
lpginfo->xStyleStep = 1; lpginfo->yStyleStep = 1; lpginfo->denStyleStep = 3; }
return TRUE;}
//**************************************************************************
// DMBitBlt -
// The 16bit winfax.drv calls this , in response to a device driver
// 'bitblt' call.
//
//**************************************************************************
ULONG FASTCALL WG32DMBitBlt( PVDMFRAME pFrame){ register PDMBITBLT16 parg16;#ifdef DBCS /* wowfax support */
register PDEV_BITMAP16 pbm16;#else // !DBCS
register PBITMAP16 pbm16;#endif /* !DBCS */
LPBYTE lpDest, lpSrc; UINT cBytes; LPBYTE lpbits, lpbitsEnd;
LOGDEBUG(0,("WG32DMBitBlt\n"));
GETARGPTR(pFrame, sizeof(DMBITBLT16), parg16);#ifdef DBCS /* wowfax support */
GETVDMPTR(parg16->pbitmapdest, sizeof(DEV_BITMAP16), pbm16);#else // !DBCS
GETVDMPTR(parg16->pbitmapdest, sizeof(BITMAP16), pbm16);#endif /* !DBCS */
GETVDMPTR(pbm16->bmBits, 0, lpDest);
WOW32ASSERT(glpfaxinfoCur != NULL); lpbits = glpfaxinfoCur->lpbits; lpbitsEnd = (LPBYTE)lpbits + glpfaxinfoCur->bmHeight * glpfaxinfoCur->bmWidthBytes;
#ifdef DBCS /* wowfax support */
lpSrc = (LPBYTE)lpbits + (parg16->srcx / glpfaxinfoCur->bmPixPerByte) + (parg16->srcy * glpfaxinfoCur->bmWidthBytes);
if (lpSrc >= lpbits) {
WORD extx,exty,srcx,srcy,desty,destx;
extx = FETCHWORD(parg16->extx); exty = FETCHWORD(parg16->exty); srcx = FETCHWORD(parg16->srcx); srcy = FETCHWORD(parg16->srcy); destx = FETCHWORD(parg16->destx); desty = FETCHWORD(parg16->desty);
#if DBG
LOGDEBUG(10,("\n")); LOGDEBUG(10,("bmType = %d\n",pbm16->bmType)); LOGDEBUG(10,("bmWidth = %d\n",pbm16->bmWidth)); LOGDEBUG(10,("bmHeight = %d\n",pbm16->bmHeight)); LOGDEBUG(10,("bmWidthBytes = %d\n",pbm16->bmWidthBytes)); LOGDEBUG(10,("bmPlanes = %d\n",pbm16->bmPlanes)); LOGDEBUG(10,("bmBitsPixel = %d\n",pbm16->bmBitsPixel)); LOGDEBUG(10,("bmBits = %x\n",pbm16->bmBits)); LOGDEBUG(10,("bmWidthPlances = %d\n",pbm16->bmWidthPlanes)); LOGDEBUG(10,("bmlpPDevice = %x\n",pbm16->bmlpPDevice)); LOGDEBUG(10,("bmSegmentIndex = %d\n",pbm16->bmSegmentIndex)); LOGDEBUG(10,("bmScanSegment = %d\n",pbm16->bmScanSegment)); LOGDEBUG(10,("bmFillBytes = %d\n",pbm16->bmFillBytes)); LOGDEBUG(10,("\n")); LOGDEBUG(10,("bmWidthBytesSrc= %d\n",glpfaxinfoCur->bmWidthBytes)); LOGDEBUG(10,("\n")); LOGDEBUG(10,("extx = %d\n",extx)); LOGDEBUG(10,("exty = %d\n",exty)); LOGDEBUG(10,("srcx = %d\n",srcx)); LOGDEBUG(10,("srcy = %d\n",srcy)); LOGDEBUG(10,("destx = %d\n",destx)); LOGDEBUG(10,("desty = %d\n",desty)); LOGDEBUG(10,("\n")); #endif
if (pbm16->bmSegmentIndex) {
SHORT WriteSegment; SHORT WriteOffset; SHORT Segment=0,SegmentMax=0; LPBYTE DstScan0,SrcScan0; UINT cBytesInLastSegment; INT RestLine = (INT) exty;
WriteSegment = desty / pbm16->bmScanSegment; WriteOffset = desty % pbm16->bmScanSegment;
if (WriteOffset) { WriteSegment += 1; }
#if DBG
LOGDEBUG(10,("WriteSegment = %d\n",WriteSegment)); LOGDEBUG(10,("WriteOffset = %d\n",WriteOffset)); LOGDEBUG(10,("\n")); LOGDEBUG(10,("lpDest = %x\n",lpDest)); LOGDEBUG(10,("\n")); #endif
SegmentMax = exty / pbm16->bmScanSegment; if ( exty % pbm16->bmScanSegment) { SegmentMax += 1; }
cBytes = glpfaxinfoCur->bmWidthBytes * pbm16->bmScanSegment; lpDest = lpDest + destx + (WriteSegment * 0x10000L) + (WriteOffset * pbm16->bmWidthBytes);
#if DBG
LOGDEBUG(10,("SourceBitmap = %x\n",lpSrc)); LOGDEBUG(10,("DestinationBitmap = %x\n",lpDest)); LOGDEBUG(10,("SegmentMax = %d\n",SegmentMax)); LOGDEBUG(10,("\n")); LOGDEBUG(10,("cBytes = %d\n",cBytes)); LOGDEBUG(10,("\n")); #endif
if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) {
try { for( Segment = 1,DstScan0 = lpDest,SrcScan0 = lpSrc; Segment < SegmentMax; Segment++,DstScan0 += 0x10000L, SrcScan0 += cBytes,RestLine -= pbm16->bmScanSegment ) {
#if DBG
LOGDEBUG(10,("%d ",Segment-1)); #endif
RtlCopyMemory(DstScan0,SrcScan0,cBytes); RtlZeroMemory(DstScan0+cBytes,pbm16->bmFillBytes); }
#if DBG
LOGDEBUG(10,("%d\n",Segment-1)); #endif
if( RestLine > 0 ) { cBytesInLastSegment = RestLine * pbm16->bmWidthBytes;
#if DBG
LOGDEBUG(10,("RestLine = %d\n",RestLine)); LOGDEBUG(10,("cBytesInLastSegment = %d\n",cBytes)); #endif
// do for last segment..
RtlCopyMemory(DstScan0,SrcScan0,cBytesInLastSegment); }
} except(EXCEPTION_EXECUTE_HANDLER) { #if DBG
LOGDEBUG(10,("Exception during copying image\n")); #endif
}
} else if ((DWORD)glpfaxinfoCur->bmWidthBytes > (DWORD)pbm16->bmWidthBytes) {
SHORT Line; UINT cSrcAdvance = glpfaxinfoCur->bmWidthBytes; UINT cDstAdvance = pbm16->bmWidthBytes;
try { for( Segment = 1,DstScan0 = lpDest,SrcScan0 = lpSrc; Segment < SegmentMax; Segment++,DstScan0 += 0x10000L, SrcScan0 += cBytes,RestLine -= pbm16->bmScanSegment ) {
LPBYTE DstScanl = DstScan0; LPBYTE SrcScanl = SrcScan0;
#if DBG
LOGDEBUG(10,("%d ",Segment-1)); #endif
for( Line = 0; Line < pbm16->bmScanSegment; Line++,DstScanl += cDstAdvance,SrcScanl += cSrcAdvance ) {
RtlCopyMemory(DstScanl,SrcScanl,cDstAdvance); } }
#if DBG
LOGDEBUG(10,("%d\n",Segment-1)); #endif
if( RestLine > 0 ) {
LPBYTE DstScanl = DstScan0; LPBYTE SrcScanl = SrcScan0;
for( Line = 0; Line < RestLine; Line++,DstScanl += cDstAdvance,SrcScanl += cSrcAdvance ) {
RtlCopyMemory(DstScanl,SrcScanl,cDstAdvance); } } } except(EXCEPTION_EXECUTE_HANDLER) { #if DBG
LOGDEBUG(10,("Exception during copying image\n")); #endif
} } else { WOW32ASSERT(FALSE); }
} else {
lpDest = lpDest + destx + desty * pbm16->bmWidthBytes;
if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) { cBytes = parg16->exty * glpfaxinfoCur->bmWidthBytes; if (cBytes > (UINT)(pbm16->bmHeight * pbm16->bmWidthBytes)) { cBytes = pbm16->bmHeight * pbm16->bmWidthBytes; WOW32ASSERT(FALSE); } if ((lpSrc + cBytes) <= lpbitsEnd) { RtlCopyMemory(lpDest, lpSrc, cBytes); } } else { int i;
// we need to transfer bits one partial scanline at a time
WOW32ASSERT((DWORD)pbm16->bmHeight <= (DWORD)glpfaxinfoCur->bmHeight); WOW32ASSERT((DWORD)parg16->exty <= (DWORD)pbm16->bmHeight);
cBytes = ((DWORD)pbm16->bmWidthBytes < (DWORD)glpfaxinfoCur->bmWidthBytes) ? pbm16->bmWidthBytes : glpfaxinfoCur->bmWidthBytes;
for (i = 0; i < parg16->exty; i++) { if ((lpSrc + cBytes) <= lpbitsEnd) { RtlCopyMemory(lpDest, lpSrc, cBytes); } lpDest += pbm16->bmWidthBytes; lpSrc += glpfaxinfoCur->bmWidthBytes; } } } }#else // !DBCS
lpDest = lpDest + parg16->destx + parg16->desty * pbm16->bmWidthBytes; lpSrc = (LPBYTE)lpbits + (parg16->srcx / glpfaxinfoCur->bmPixPerByte) + parg16->srcy * glpfaxinfoCur->bmWidthBytes; if (lpSrc >= lpbits) { if ((DWORD)glpfaxinfoCur->bmWidthBytes == (DWORD)pbm16->bmWidthBytes) { cBytes = parg16->exty * glpfaxinfoCur->bmWidthBytes; if (cBytes > (UINT)(pbm16->bmHeight * pbm16->bmWidthBytes)) { cBytes = pbm16->bmHeight * pbm16->bmWidthBytes; WOW32ASSERT(FALSE); } if ((lpSrc + cBytes) <= lpbitsEnd) { RtlCopyMemory(lpDest, lpSrc, cBytes); } } else if ((DWORD)glpfaxinfoCur->bmWidthBytes > (DWORD)pbm16->bmWidthBytes) { int i;
// we need to transfer bits one partial scanline at a time
WOW32ASSERT((DWORD)pbm16->bmHeight <= (DWORD)glpfaxinfoCur->bmHeight); WOW32ASSERT((DWORD)parg16->exty <= (DWORD)pbm16->bmHeight);
for (i = 0; i < parg16->exty; i++) { if ((lpSrc + pbm16->bmWidthBytes) <= lpbitsEnd) { RtlCopyMemory(lpDest, lpSrc, pbm16->bmWidthBytes); } lpDest += pbm16->bmWidthBytes; lpSrc += glpfaxinfoCur->bmWidthBytes; }
} else { WOW32ASSERT(FALSE); }
}#endif /* !DBCS */
return (ULONG)TRUE;}
PSZ StrDup(PSZ szStr){ int len; PSZ pszTmp;
if(szStr) { len = strlen(szStr)+1; pszTmp = malloc_w(len); if(pszTmp) { strcpy(pszTmp, szStr); return(pszTmp); } } return NULL;}
PSZ BuildPath(PSZ szPath, PSZ szFileName){ int len; char szTmp[MAX_PATH];
len = strlen(szPath); len += strlen(szFileName); len += 2; // add in the '\' char and the terminating '\0';
szTmp[0] = '\0'; if(len < sizeof(szTmp)) { strcpy(szTmp, szPath); strcat(szTmp, "\\"); strcat(szTmp, szFileName); } WOW32ASSERT((szTmp[0] != '\0')); // Note: StrDup uses HeapAlloc() to allocate a buffer.
return(StrDup(szTmp));}
//**************************************************************************
// AddPrinterThread -
//
// Worker thread to make the AddPrinter call into the spooler.
//
//**************************************************************************
VOID AddPrinterThread(PWOWADDPRINTER pWowAddPrinter){
if ((*spoolerapis[pWowAddPrinter->iCode].lpfn)(NULL, 2, pWowAddPrinter->pPrinterStuff)) { pWowAddPrinter->bRet = TRUE; } else { if (GetLastError() == ERROR_PRINTER_ALREADY_EXISTS) { pWowAddPrinter->bRet = TRUE; } else {#ifdef DBG
LOGDEBUG(0,("AddPrinterThread, AddPrinterxxx call failed: 0x%X\n", GetLastError()));#endif
pWowAddPrinter->bRet = FALSE; } }}
//**************************************************************************
// DoAddPrinterStuff -
//
// Spin a worker thread to make the AddPrinterxxx calls into
// spooler. This is needed to prevent a deadlock when spooler
// RPC's to spoolss.
//
// This thread added for bug #107426.
//**************************************************************************
BOOL DoAddPrinterStuff(LPVOID pPrinterStuff, INT iCode){ WOWADDPRINTER WowAddPrinter; HANDLE hWaitObjects; DWORD dwEvent, dwUnused; MSG msg;
// Spin the worker thread.
WowAddPrinter.pPrinterStuff = pPrinterStuff; WowAddPrinter.iCode = iCode; WowAddPrinter.bRet = FALSE; if (hWaitObjects = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)AddPrinterThread, &WowAddPrinter, 0, &dwUnused)) {
// Pump messages while we wait for AddPrinterThread to finish.
for (;;) { dwEvent = MsgWaitForMultipleObjects(1, &hWaitObjects, FALSE, INFINITE, QS_ALLEVENTS | QS_SENDMESSAGE);
if (dwEvent == WAIT_OBJECT_0 + 0) {
// Worker thread done.
break;
} else { // pump messages so the callback into wowexec!FaxWndProc doesn't
// get hung
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } } } CloseHandle(hWaitObjects); } else { LOGDEBUG(0, ("DoAddPrinterStuff, CreateThread on AddPrinterThread failed\n")); }
return WowAddPrinter.bRet;}
//**************************************************************************
// InstallWowFaxPrinter -
//
// Installs the WowFax 32-bit print driver when a 16-bit fax printer
// installation is detected.
//
//**************************************************************************
BOOL InstallWowFaxPrinter(PSZ szSection, PSZ szKey, PSZ szString){ CHAR szTmp[MAX_PATH]; PSZ szSrcPath; DWORD dwNeeded; DRIVER_INFO_2 DriverInfo; PRINTER_INFO_2 PrinterInfo; PORT_INFO_1 PortInfo; HKEY hKey = 0, hSubKey = 0; BOOL bRetVal=FALSE;
LOGDEBUG(0,("InstallWowFaxPrinter, Section = %s, Key = %s, String = %s\n", szSection, szKey, szString));
// Write the entry to the registry. We'll keep shadow entries
// in the registry for the WOW fax applications and drivers to
// read, since the entries that the spooler writes pertain
// to winspool, not the 16-bit fax driver.
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax", 0, KEY_WRITE, &hKey ) == ERROR_SUCCESS) { if (RegCreateKey(hKey, szSection, &hSubKey) == ERROR_SUCCESS) { RegSetValueEx(hSubKey, szKey, 0, REG_SZ, szString, strlen(szString)+1); RegCloseKey(hKey); RegCloseKey(hSubKey);
// Dynamically link to spooler API's
if (!(spoolerapis[WOW_GetPrinterDriverDirectory].lpfn)) { if (!LoadLibraryAndGetProcAddresses(L"WINSPOOL.DRV", spoolerapis, WOW_SPOOLERAPI_COUNT)) { LOGDEBUG(0,("InstallWowFaxPrinter, Unable to load WINSPOOL API's\n")); return(FALSE); } }
// Copy the printer driver files.
RtlZeroMemory(&DriverInfo, sizeof(DRIVER_INFO_2)); RtlZeroMemory(&PrinterInfo, sizeof(PRINTER_INFO_2)); if (!(*spoolerapis[WOW_GetPrinterDriverDirectory].lpfn)(NULL, NULL, 1, szTmp, MAX_PATH, &dwNeeded)) { LOGDEBUG(0,("InstallWowFaxPrinter, GetPrinterDriverDirectory failed: 0x%X\n", GetLastError())); return(FALSE); }
// This is a dummy. We've no data file, but spooler won't take NULL.
DriverInfo.pDataFile = BuildPath(szTmp, WOWFAX_DLL_NAME_A);
if ( !DriverInfo.pDataFile ) { goto IWFP_error; }
DriverInfo.pDriverPath = BuildPath(szTmp, WOWFAX_DLL_NAME_A);
if ( !DriverInfo.pDriverPath ) { goto IWFP_error; } LOGDEBUG(0,("InstallWowFaxPrinter, pDriverPath = %s\n", DriverInfo.pDataFile)); szSrcPath = BuildPath(pszSystemDirectory, WOWFAX_DLL_NAME_A); if ( !szSrcPath ) { goto IWFP_error; }
CopyFile(szSrcPath, DriverInfo.pDriverPath, FALSE); free_w(szSrcPath);
DriverInfo.pConfigFile = BuildPath(szTmp, WOWFAXUI_DLL_NAME_A); szSrcPath = BuildPath(pszSystemDirectory, WOWFAXUI_DLL_NAME_A); if ( !szSrcPath ) { goto IWFP_error; } CopyFile(szSrcPath, DriverInfo.pConfigFile, FALSE); free_w(szSrcPath);
// Install the printer driver.
DriverInfo.cVersion = 1; DriverInfo.pName = "Windows 3.1 Compatible Fax Driver"; if ((bRetVal = DoAddPrinterStuff((LPVOID)&DriverInfo, WOW_AddPrinterDriver)) == FALSE) {
// if the driver is already installed, it won't hurt to install
// it a second time. This might be necessary if the user is
// upgrading from WinFax Lite to WinFax Pro.
bRetVal = (GetLastError() == ERROR_PRINTER_DRIVER_ALREADY_INSTALLED); }
if (bRetVal) { // Parse out the printer name.
RtlZeroMemory(&PrinterInfo, sizeof(PRINTER_INFO_2)); PrinterInfo.pPrinterName = szKey;
LOGDEBUG(0,("InstallWowFaxPrinter, pPrinterName = %s\n", PrinterInfo.pPrinterName));
// Use private API to add a NULL port. Printer guys need to fix
// redirection to NULL bug.
RtlZeroMemory(&PortInfo, sizeof(PORT_INFO_1)); PrinterInfo.pPortName = "NULL"; PortInfo.pName = PrinterInfo.pPortName;
// Get "Local Port" string.
LoadString(hmodWOW32, iszWowFaxLocalPort, szTmp, sizeof szTmp);
(*spoolerapis[WOW_AddPortEx].lpfn)(NULL, 1, &PortInfo, szTmp);
// Set the other defaults and install the printer.
PrinterInfo.pDriverName = "Windows 3.1 Compatible Fax Driver"; PrinterInfo.pPrintProcessor = "WINPRINT"; PrinterInfo.pDatatype = "RAW"; bRetVal = DoAddPrinterStuff((LPVOID)&PrinterInfo, WOW_AddPrinter);#ifdef DBG
if (!bRetVal) { LOGDEBUG(0,("InstallWowFaxPrinter, AddPrinter failed: 0x%X\n", GetLastError())); }#endif
} else { LOGDEBUG(0,("InstallWowFaxPrinter, AddPrinterDriver failed: 0x%X\n", GetLastError())); }IWFP_error: if ( DriverInfo.pDataFile ) { free_w(DriverInfo.pDataFile); }
if ( DriverInfo.pDriverPath ) { free_w(DriverInfo.pDriverPath); }
if ( DriverInfo.pConfigFile) { free_w(DriverInfo.pConfigFile); }
return(bRetVal); } else { LOGDEBUG(0,("InstallWowFaxPrinter, Unable to create Key: %s\n", szSection)); } } else { LOGDEBUG(0,("InstallWowFaxPrinter, Unable to open key: HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\n")); }
if (hKey) { RegCloseKey(hKey); if (hSubKey) { RegCloseKey(hSubKey); } } return(FALSE);}
// Come here if szSection=="devices" or if gbWinFaxHack==TRUE
BOOL IsFaxPrinterWriteProfileString(PSZ szSection, PSZ szKey, PSZ szString){ BOOL Result = FALSE;
// Don't install if trying to clear an entry.
if (!szString || *szString == '\0') { goto Done; }
// Trying to install a fax printer?
LOGDEBUG(0,("IsFaxPrinterWriteProfileString, Section = devices, Key = %s\n", szKey));
// Is the WinFax Lite hack enabled?
if(gbWinFaxHack) {
// if ("WINFAX", "modem", "xxx") we know the WinFax install program
// has had a chance to copy "WinFax.drv" to the hard drive. So
// now we can call AddPrinter which can callback into WinFax.drv to
// its hearts content.
if(!WOW32_strcmp(szSection, szWINFAX) && !WOW32_stricmp(szKey, szModem)) {
// Our hack has run its course. We set this before making the call
// to AddPrinter because it calls back into WinFax.drv which calls
// WriteProfileString()!
gbWinFaxHack = FALSE;
// Call into the spooler to add our driver to the registry.
if (!InstallWowFaxPrinter(szDevices, szWINFAX, szWINFAXCOMx)) { WOW32ASSERTMSG(FALSE, "Install of generic fax printer failed.\n"); } } Result = TRUE; goto Done; }
// Is it one of the fax drivers we recognize?
if (IsFaxPrinterSupportedDevice(szKey)) {
// Time to enable the WinFax Lite hack?
// if("devices", "WINFAX", "WINFAX,COMx:") we need to avoid the call to
// InstallWOWFaxPrinter() at this time -- the install program hasn't
// copied the driver to the hard drive yet!! This causes loadLibrary
// of WinFax.drv to fail when the spooler tries to callback into it.
// We also don't want this particular call to WriteProfileString to
// really be written to the registry -- we let the later call to
// AddPrinter take care of all the registration stuff.
if(!WOW32_strcmp(szKey, szWINFAX) && !WOW32_strncmp(szString, szWINFAX, 6) && (szString[6] == ',')) {
VPVOID vpPathName; PSZ pszPathName; char szFileName[32];
// get the install program file name
// be sure allocation size matches stackfree16() size below
if(vpPathName = stackalloc16(MAX_PATH)) { GetModuleFileName16(CURRENTPTD()->hMod16, vpPathName, MAX_PATH); GETVDMPTR(vpPathName, MAX_PATH, pszPathName); _splitpath(pszPathName,NULL,NULL,szFileName,NULL);
// WinFax Lite is "INSTALL", WinFax Pro 4.0 is "SETUP"
if(!WOW32_stricmp(szINSTALL, szFileName)) {
strcpy(szWINFAXCOMx, szString); // save the port string
gbWinFaxHack = TRUE; // enable the hack
Result = TRUE; stackfree16(vpPathName, MAX_PATH); goto Done; // skip the call to InstallWowFaxPrinter
} // No hack needed for WinFax Pro 4.0, the driver is copied
// to the hard disk long before they update win.ini
else { stackfree16(vpPathName, MAX_PATH); } } }
if (!InstallWowFaxPrinter(szSection, szKey, szString)) { WOW32ASSERTMSG(FALSE, "Install of generic fax printer failed.\n"); } Result = TRUE; }
Done: return Result;}
BOOL IsFaxPrinterSupportedDevice(PSZ pszDevice){ UINT i, iNotFound;
// Trying to read from a fax printer entry?
LOGDEBUG(0,("IsFaxPrinterSupportedDevice, Device = %s\n", pszDevice));
//If initialization of SupFaxDrv failed with memory exhaust
//which isn't very likely to happen
if (!SupFaxDrv ) { return FALSE; }
// Is it one of the fax drivers we recognize?
for (i = 0; i < uNumSupFaxDrv; i++) { iNotFound = WOW32_stricmp(pszDevice, SupFaxDrv[i]); if (iNotFound > 0) continue; if (iNotFound == 0) { LOGDEBUG(0,("IsFaxPrinterSupportedDevice returns TRUE\n")); return(TRUE); } else { break; } } return(FALSE);}
DWORD GetFaxPrinterProfileString(PSZ szSection, PSZ szKey, PSZ szDefault, PSZ szRetBuf, DWORD cbBufSize){ DWORD len; char szTmp[MAX_PATH]; HKEY hKey = 0; DWORD dwType;
// Read the entry from the shadow entries in registry.
strcpy(szTmp, "Software\\Microsoft\\Windows NT\\CurrentVersion\\WOW\\WowFax\\"); WOW32ASSERT(strlen(szTmp) < MAX_PATH);
len = strlen(szTmp); len += strlen(szSection); len ++; // account for '\0'
if(len <= sizeof(szTmp)) { strcat(szTmp, szSection); if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szTmp, 0, KEY_READ, &hKey ) == ERROR_SUCCESS) { if (RegQueryValueEx(hKey, szKey, 0, &dwType, szRetBuf, &cbBufSize) == ERROR_SUCCESS) { RegCloseKey(hKey); return(cbBufSize); } }
if (hKey) { RegCloseKey(hKey); } } WOW32WARNMSG(FALSE, ("GetFaxPrinterProfileString Failed. Section = %s, Key = %s\n", szSection, szKey)); if(szDefault && szRetBuf) {
len = strlen(szDefault); if(len < cbBufSize) { strncpy(szRetBuf, szDefault, cbBufSize); szRetBuf[cbBufSize-1] = '\0'; return(len); } } WOW32ASSERT(FALSE); return(0);}
|
