You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5492 lines
143 KiB
5492 lines
143 KiB
/*++
|
|
|
|
Copyright (c) 1990-1994 Microsoft Corporation
|
|
All rights reserved
|
|
|
|
Module Name:
|
|
|
|
winspla.c
|
|
|
|
Abstract:
|
|
|
|
Ansi end to winspool.drv
|
|
|
|
Author:
|
|
|
|
Environment:
|
|
|
|
User Mode -Win32
|
|
|
|
Revision History:
|
|
|
|
amaxa July 2000 - Modified GetPrinterData(Ex)A and SetPrinterData(Ex)A to
|
|
have the same behavior like the unicode functions.
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "client.h"
|
|
#include "defprn.h"
|
|
#include "winsprlp.h"
|
|
|
|
typedef int (FAR WINAPI *INT_FARPROC)();
|
|
|
|
typedef struct {
|
|
BOOL bOsVersionEx;
|
|
union {
|
|
OSVERSIONINFOW *pOsVersion;
|
|
OSVERSIONINFOEXW *pOsVersionEx;
|
|
} Unicode;
|
|
union {
|
|
OSVERSIONINFOA *pOsVersion;
|
|
OSVERSIONINFOEXA *pOsVersionEx;
|
|
} Ansi;
|
|
} OSVERSIONWRAP;
|
|
|
|
WCHAR *szCurDevMode = L"Printers\\DevModes2";
|
|
|
|
BOOL
|
|
KickoffThread(
|
|
LPWSTR pName,
|
|
HWND hWnd,
|
|
LPWSTR pPortName,
|
|
INT_FARPROC pfn
|
|
);
|
|
|
|
LPWSTR
|
|
AllocateUnicodeStringWithSize(
|
|
LPSTR pPrinterName,
|
|
DWORD cbBytes
|
|
);
|
|
|
|
VOID
|
|
ValidatePaperFields(
|
|
LPCWSTR pUnicodeDeviceName,
|
|
LPCWSTR pUnicodePort,
|
|
LPDEVMODEW pDevModeIn
|
|
);
|
|
|
|
#define NULL_TERMINATED 0
|
|
|
|
DWORD
|
|
UnicodeToAnsi(
|
|
IN LPBYTE pUnicode,
|
|
IN DWORD cchUnicode,
|
|
IN OUT LPBYTE pData,
|
|
IN DWORD cbData,
|
|
IN OUT DWORD *pcbCopied OPTIONAL
|
|
);
|
|
|
|
/* AnsiToUnicodeString
|
|
*
|
|
* Parameters:
|
|
*
|
|
* pAnsi - A valid source ANSI string.
|
|
*
|
|
* pUnicode - A pointer to a buffer large enough to accommodate
|
|
* the converted string.
|
|
*
|
|
* StringLength - The length of the source ANSI string.
|
|
* If 0 (NULL_TERMINATED), the string is assumed to be
|
|
* null-terminated.
|
|
*
|
|
* Return:
|
|
*
|
|
* The return value from MultiByteToWideChar, the number of
|
|
* wide characters returned.
|
|
*
|
|
*/
|
|
INT AnsiToUnicodeString( LPSTR pAnsi, LPWSTR pUnicode, DWORD StringLength )
|
|
{
|
|
INT iReturn;
|
|
|
|
if( StringLength == NULL_TERMINATED )
|
|
StringLength = strlen( pAnsi );
|
|
|
|
iReturn = MultiByteToWideChar(CP_THREAD_ACP,
|
|
MB_PRECOMPOSED,
|
|
pAnsi,
|
|
StringLength + 1,
|
|
pUnicode,
|
|
StringLength + 1 );
|
|
|
|
//
|
|
// Ensure NULL termination.
|
|
//
|
|
pUnicode[StringLength] = 0;
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
/* UnicodeToAnsiString
|
|
*
|
|
* Parameters:
|
|
*
|
|
* pUnicode - A valid source Unicode string.
|
|
*
|
|
* pANSI - A pointer to a buffer large enough to accommodate
|
|
* the converted string.
|
|
*
|
|
* StringLength - The length of the source Unicode string.
|
|
* If 0 (NULL_TERMINATED), the string is assumed to be
|
|
* null-terminated.
|
|
*
|
|
*
|
|
* Notes:
|
|
* With DBCS enabled, we will allocate twice the size of the
|
|
* buffer including the null terminator to take care of double
|
|
* byte character strings - KrishnaG
|
|
*
|
|
* pUnicode is truncated to StringLength characters.
|
|
*
|
|
* Return:
|
|
*
|
|
* The return value from WideCharToMultiByte, the number of
|
|
* multi-byte characters returned.
|
|
*
|
|
*/
|
|
INT
|
|
UnicodeToAnsiString(
|
|
LPWSTR pUnicode,
|
|
LPSTR pAnsi,
|
|
DWORD StringLength)
|
|
{
|
|
LPSTR pTempBuf = NULL;
|
|
INT rc = 0;
|
|
LPWSTR pAlignedUnicode = NULL;
|
|
|
|
if ((ULONG_PTR)pUnicode != (((ULONG_PTR) (pUnicode) + (sizeof(WCHAR) - 1))&~(sizeof(WCHAR) - 1))) {
|
|
|
|
//
|
|
// Calculate the length of the unaligned string.
|
|
//
|
|
if(StringLength == NULL_TERMINATED) {
|
|
|
|
for (StringLength = 0;
|
|
!( ((LPSTR)pUnicode)[StringLength] == '\0' &&
|
|
((LPSTR)pUnicode)[StringLength+1] == '\0' );
|
|
StringLength += 2)
|
|
;
|
|
|
|
StringLength /= 2;
|
|
|
|
} else {
|
|
|
|
//
|
|
// WideCharToMultiByte doesn't NULL terminate if we're copying
|
|
// just part of the string, so terminate here.
|
|
//
|
|
((LPSTR)(pUnicode + StringLength))[0] = '\0';
|
|
((LPSTR)(pUnicode + StringLength))[1] = '\0';
|
|
}
|
|
|
|
StringLength++;
|
|
|
|
pAlignedUnicode = LocalAlloc(LPTR, StringLength * sizeof(WCHAR));
|
|
|
|
if (pAlignedUnicode) {
|
|
|
|
memcpy(pAlignedUnicode, pUnicode, StringLength * sizeof(WCHAR));
|
|
}
|
|
|
|
} else {
|
|
|
|
pAlignedUnicode = pUnicode;
|
|
|
|
if(StringLength == NULL_TERMINATED) {
|
|
|
|
//
|
|
// StringLength is just the
|
|
// number of characters in the string
|
|
//
|
|
StringLength = wcslen(pAlignedUnicode);
|
|
}
|
|
|
|
//
|
|
// WideCharToMultiByte doesn't NULL terminate if we're copying
|
|
// just part of the string, so terminate here.
|
|
//
|
|
pAlignedUnicode[StringLength] = 0;
|
|
|
|
StringLength++;
|
|
}
|
|
|
|
|
|
//
|
|
// Unfortunately, WideCharToMultiByte doesn't do conversion in place,
|
|
// so allocate a temporary buffer, which we can then copy:
|
|
//
|
|
if( pAnsi == (LPSTR)pAlignedUnicode )
|
|
{
|
|
pTempBuf = LocalAlloc( LPTR, StringLength * sizeof(WCHAR) );
|
|
pAnsi = pTempBuf;
|
|
}
|
|
|
|
if( pAnsi && pAlignedUnicode )
|
|
{
|
|
rc = WideCharToMultiByte( CP_THREAD_ACP,
|
|
0,
|
|
pAlignedUnicode,
|
|
StringLength,
|
|
pAnsi,
|
|
StringLength*2,
|
|
NULL,
|
|
NULL );
|
|
}
|
|
|
|
//
|
|
// If pTempBuf is non-null, we must copy the resulting string
|
|
// so that it looks as if we did it in place:
|
|
//
|
|
if( pTempBuf )
|
|
{
|
|
if( rc > 0 )
|
|
{
|
|
pAnsi = (LPSTR)pAlignedUnicode;
|
|
if (FAILED(StringCbCopyExA( pAnsi, StringLength * sizeof(WCHAR), pTempBuf, NULL, NULL, STRSAFE_FILL_ON_FAILURE)))
|
|
{
|
|
rc = 0;
|
|
}
|
|
}
|
|
|
|
LocalFree( pTempBuf );
|
|
}
|
|
|
|
if (pAlignedUnicode != pUnicode) {
|
|
|
|
LocalFree(pAlignedUnicode);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
void
|
|
ConvertUnicodeToAnsiStrings(
|
|
LPBYTE pStructure,
|
|
LPDWORD pOffsets
|
|
)
|
|
{
|
|
register DWORD i=0;
|
|
LPWSTR pUnicode;
|
|
LPSTR pAnsi;
|
|
|
|
while (pOffsets[i] != -1) {
|
|
|
|
pUnicode = *(LPWSTR *)(pStructure+pOffsets[i]);
|
|
pAnsi = (LPSTR)pUnicode;
|
|
|
|
if (pUnicode) {
|
|
UnicodeToAnsiString(pUnicode, pAnsi, NULL_TERMINATED);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
|
|
LPWSTR
|
|
AllocateUnicodeString(
|
|
LPSTR pPrinterName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeString;
|
|
|
|
if (!pPrinterName)
|
|
return NULL;
|
|
|
|
pUnicodeString = LocalAlloc(LPTR, strlen(pPrinterName)*sizeof(WCHAR) +
|
|
sizeof(WCHAR));
|
|
|
|
if (pUnicodeString)
|
|
AnsiToUnicodeString(pPrinterName, pUnicodeString, NULL_TERMINATED);
|
|
|
|
return pUnicodeString;
|
|
}
|
|
|
|
|
|
LPWSTR
|
|
AllocateUnicodeStringWithSize(
|
|
LPSTR pData,
|
|
DWORD cbData
|
|
)
|
|
{
|
|
LPWSTR pUnicodeString = NULL;
|
|
DWORD iReturn;
|
|
|
|
if (pData &&
|
|
(pUnicodeString = LocalAlloc(LPTR, cbData*sizeof(WCHAR))))
|
|
{
|
|
iReturn = MultiByteToWideChar(CP_THREAD_ACP,
|
|
MB_PRECOMPOSED,
|
|
pData,
|
|
cbData,
|
|
pUnicodeString,
|
|
cbData);
|
|
|
|
if (iReturn != cbData)
|
|
{
|
|
LocalFree(pUnicodeString);
|
|
|
|
pUnicodeString = NULL;
|
|
}
|
|
}
|
|
|
|
return pUnicodeString;
|
|
}
|
|
|
|
|
|
LPWSTR
|
|
FreeUnicodeString(
|
|
LPWSTR pUnicodeString
|
|
)
|
|
{
|
|
if (!pUnicodeString)
|
|
return NULL;
|
|
|
|
return LocalFree(pUnicodeString);
|
|
}
|
|
|
|
LPBYTE
|
|
AllocateUnicodeStructure(
|
|
LPBYTE pAnsiStructure,
|
|
DWORD cbStruct,
|
|
LPDWORD pOffsets
|
|
)
|
|
{
|
|
DWORD i, j;
|
|
LPWSTR *ppUnicodeString;
|
|
LPSTR *ppAnsiString;
|
|
LPBYTE pUnicodeStructure;
|
|
|
|
|
|
if (!pAnsiStructure) {
|
|
return NULL;
|
|
}
|
|
pUnicodeStructure = LocalAlloc(LPTR, cbStruct);
|
|
|
|
if (pUnicodeStructure) {
|
|
|
|
memcpy(pUnicodeStructure, pAnsiStructure, cbStruct);
|
|
|
|
for (i = 0 ; pOffsets[i] != -1 ; ++i) {
|
|
|
|
ppAnsiString = (LPSTR *)(pAnsiStructure+pOffsets[i]);
|
|
ppUnicodeString = (LPWSTR *)(pUnicodeStructure+pOffsets[i]);
|
|
|
|
*ppUnicodeString = AllocateUnicodeString(*ppAnsiString);
|
|
|
|
if (*ppAnsiString && !*ppUnicodeString) {
|
|
|
|
for( j = 0 ; j < i ; ++j) {
|
|
ppUnicodeString = (LPWSTR *)(pUnicodeStructure+pOffsets[j]);
|
|
FreeUnicodeString(*ppUnicodeString);
|
|
}
|
|
LocalFree(pUnicodeStructure);
|
|
pUnicodeStructure = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pUnicodeStructure;
|
|
}
|
|
|
|
DWORD
|
|
CopyOsVersionUnicodeToAnsi(
|
|
IN OUT OSVERSIONWRAP Arg
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
CopyOsVersionUnicodeToAnsi
|
|
|
|
Routine Description:
|
|
|
|
Copies the contents of the UNICODE structure OSVERSIONINFO(EX) into the ANSI structure.
|
|
|
|
Arguments:
|
|
|
|
An OSVERSIONWRAP structure
|
|
|
|
Return Value:
|
|
|
|
Win32 error core
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwError = ERROR_INVALID_PARAMETER;
|
|
|
|
OSVERSIONINFOEXW *pIn = Arg.Unicode.pOsVersionEx;
|
|
OSVERSIONINFOEXA *pOut = Arg.Ansi.pOsVersionEx;
|
|
|
|
if (pIn && pOut)
|
|
{
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
pOut->dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
|
|
pOut->dwMajorVersion = pIn->dwMajorVersion;
|
|
pOut->dwMinorVersion = pIn->dwMinorVersion;
|
|
pOut->dwBuildNumber = pIn->dwBuildNumber;
|
|
pOut->dwPlatformId = pIn->dwPlatformId;
|
|
|
|
//
|
|
// Initialize the array of chars szCSDVersion to 0 so that we are consistent with
|
|
// the return of the UNICODE versions of GetPrinterData(Ex).
|
|
//
|
|
memset(pOut->szCSDVersion, 0, COUNTOF(pOut->szCSDVersion));
|
|
|
|
UnicodeToAnsiString(pIn->szCSDVersion, pOut->szCSDVersion, NULL_TERMINATED);
|
|
|
|
//
|
|
// Copy the rest of the Ex structure
|
|
//
|
|
if (Arg.bOsVersionEx)
|
|
{
|
|
pOut->dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
|
|
pOut->wServicePackMajor = pIn->wServicePackMajor;
|
|
pOut->wServicePackMinor = pIn->wServicePackMinor;
|
|
pOut->wSuiteMask = pIn->wSuiteMask;
|
|
pOut->wProductType = pIn->wProductType;
|
|
pOut->wReserved = pIn->wReserved;
|
|
}
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
DWORD
|
|
ComputeMaxStrlenW(
|
|
LPWSTR pString,
|
|
DWORD cchBufMax)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the length of the Unicode string, EXCLUDING the NULL. If the
|
|
string (plus NULL) won't fit into the cchBufMax, then the string len is
|
|
decreased.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD cchLen;
|
|
|
|
//
|
|
// Include space for the NULL.
|
|
//
|
|
cchBufMax--;
|
|
|
|
cchLen = wcslen(pString);
|
|
|
|
if (cchLen > cchBufMax)
|
|
return cchBufMax;
|
|
|
|
return cchLen;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ComputeMaxStrlenA(
|
|
LPSTR pString,
|
|
DWORD cchBufMax)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the length of the Ansi string, EXCLUDING the NULL. If the
|
|
string (plus NULL) won't fit into the cchBufMax, then the string len is
|
|
decreased.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD cchLen;
|
|
|
|
//
|
|
// Include space for the NULL.
|
|
//
|
|
cchBufMax--;
|
|
|
|
cchLen = lstrlenA(pString);
|
|
|
|
if (cchLen > cchBufMax)
|
|
return cchBufMax;
|
|
|
|
return cchLen;
|
|
}
|
|
|
|
|
|
|
|
/***************************** Function Header ******************************
|
|
* AllocateUnicodeDevMode
|
|
* Allocate a UNICODE version of the DEVMODE structure, and optionally
|
|
* copy the contents of the ANSI version passed in.
|
|
*
|
|
* RETURNS:
|
|
* Address of newly allocated structure, 0 if storage not available.
|
|
*
|
|
*
|
|
***************************************************************************/
|
|
|
|
LPDEVMODEW
|
|
AllocateUnicodeDevMode(
|
|
LPDEVMODEA pANSIDevMode
|
|
)
|
|
{
|
|
LPDEVMODEW pUnicodeDevMode;
|
|
LPBYTE p1, p2;
|
|
DWORD dwSize;
|
|
|
|
//
|
|
// If the devmode is NULL, then return NULL -- KrishnaG
|
|
//
|
|
if ( !pANSIDevMode || !pANSIDevMode->dmSize ) {
|
|
return NULL;
|
|
}
|
|
|
|
SPLASSERT(BoolFromHResult(SplIsValidDevmodeNoSizeA(pANSIDevMode)));
|
|
|
|
//
|
|
// Determine output structure size. This has two components: the
|
|
// DEVMODEW structure size, plus any private data area. The latter
|
|
// is only meaningful when a structure is passed in.
|
|
//
|
|
dwSize = pANSIDevMode->dmSize + pANSIDevMode->dmDriverExtra
|
|
+ sizeof(DEVMODEW) - sizeof(DEVMODEA);
|
|
|
|
pUnicodeDevMode = (LPDEVMODEW) LocalAlloc(LPTR, dwSize);
|
|
|
|
if( !pUnicodeDevMode ) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Copy dmDeviceName which is a string
|
|
//
|
|
if (pANSIDevMode->dmDeviceName)
|
|
{
|
|
AnsiToUnicodeString(pANSIDevMode->dmDeviceName,
|
|
pUnicodeDevMode->dmDeviceName,
|
|
ComputeMaxStrlenA(pANSIDevMode->dmDeviceName,
|
|
sizeof pANSIDevMode->dmDeviceName));
|
|
}
|
|
|
|
//
|
|
// Does the devmode we got have a dmFormName? (Windows 3.1 had
|
|
// DevMode of size 40 and did not have dmFormName)
|
|
//
|
|
if ( (LPBYTE)pANSIDevMode + pANSIDevMode->dmSize >
|
|
(LPBYTE) pANSIDevMode->dmFormName ) {
|
|
|
|
//
|
|
// Copy everything between dmDeviceName and dmFormName
|
|
//
|
|
p1 = (LPBYTE) pANSIDevMode->dmDeviceName +
|
|
sizeof(pANSIDevMode->dmDeviceName);
|
|
p2 = (LPBYTE) pANSIDevMode->dmFormName;
|
|
|
|
|
|
CopyMemory((LPBYTE) pUnicodeDevMode->dmDeviceName +
|
|
sizeof(pUnicodeDevMode->dmDeviceName),
|
|
p1,
|
|
p2 - p1);
|
|
|
|
//
|
|
// Copy dmFormName which is a string
|
|
//
|
|
if (pANSIDevMode->dmFormName)
|
|
{
|
|
AnsiToUnicodeString(pANSIDevMode->dmFormName,
|
|
pUnicodeDevMode->dmFormName,
|
|
ComputeMaxStrlenA(pANSIDevMode->dmFormName,
|
|
sizeof pANSIDevMode->dmFormName));
|
|
}
|
|
|
|
//
|
|
// Copy everything after dmFormName
|
|
//
|
|
p1 = (LPBYTE) pANSIDevMode->dmFormName +
|
|
sizeof(pANSIDevMode->dmFormName);
|
|
p2 = (LPBYTE) pANSIDevMode + pANSIDevMode->dmSize
|
|
+ pANSIDevMode->dmDriverExtra;
|
|
|
|
CopyMemory((LPBYTE) pUnicodeDevMode->dmFormName +
|
|
sizeof(pUnicodeDevMode->dmFormName),
|
|
p1,
|
|
p2 - p1);
|
|
|
|
pUnicodeDevMode->dmSize = pANSIDevMode->dmSize + sizeof(DEVMODEW)
|
|
- sizeof(DEVMODEA);
|
|
} else {
|
|
|
|
//
|
|
// Copy everything after dmDeviceName
|
|
//
|
|
p1 = (LPBYTE) pANSIDevMode->dmDeviceName +
|
|
sizeof(pANSIDevMode->dmDeviceName);
|
|
p2 = (LPBYTE) pANSIDevMode + pANSIDevMode->dmSize + pANSIDevMode->dmDriverExtra;
|
|
|
|
CopyMemory((LPBYTE) pUnicodeDevMode->dmDeviceName +
|
|
sizeof(pUnicodeDevMode->dmDeviceName),
|
|
p1,
|
|
p2-p1);
|
|
|
|
pUnicodeDevMode->dmSize = pANSIDevMode->dmSize
|
|
+ sizeof(pUnicodeDevMode->dmDeviceName)
|
|
- sizeof(pANSIDevMode->dmDeviceName);
|
|
}
|
|
|
|
SPLASSERT(pUnicodeDevMode->dmDriverExtra == pANSIDevMode->dmDriverExtra);
|
|
|
|
|
|
return pUnicodeDevMode;
|
|
}
|
|
|
|
/************************** Function Header ******************************
|
|
* CopyAnsiDevModeFromUnicodeDevMode
|
|
* Converts the UNICODE version of the DEVMODE to the ANSI version.
|
|
*
|
|
* RETURNS:
|
|
* Nothing.
|
|
*
|
|
**************************************************************************/
|
|
|
|
void
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
LPDEVMODEA pANSIDevMode, /* Filled in by us */
|
|
LPDEVMODEW pUnicodeDevMode /* Source of data to fill above */
|
|
)
|
|
{
|
|
LPBYTE p1, p2, pExtra;
|
|
WORD dmSize, dmDriverExtra;
|
|
|
|
//
|
|
// NOTE: THE TWO INPUT STRUCTURES MAY BE THE SAME.
|
|
//
|
|
dmSize = pUnicodeDevMode->dmSize;
|
|
dmDriverExtra = pUnicodeDevMode->dmDriverExtra;
|
|
pExtra = (LPBYTE) pUnicodeDevMode + pUnicodeDevMode->dmSize;
|
|
|
|
if (dmSize)
|
|
{
|
|
//
|
|
// Copy dmDeviceName which is a string
|
|
//
|
|
UnicodeToAnsiString(pUnicodeDevMode->dmDeviceName,
|
|
pANSIDevMode->dmDeviceName,
|
|
ComputeMaxStrlenW(pUnicodeDevMode->dmDeviceName,
|
|
sizeof pANSIDevMode->dmDeviceName));
|
|
|
|
//
|
|
// Does the devmode we got have a dmFormName? (Windows 3.1 had
|
|
// DevMode of size 40 and did not have dmFormName)
|
|
//
|
|
if ( (LPBYTE)pUnicodeDevMode + dmSize >
|
|
(LPBYTE) pUnicodeDevMode->dmFormName ) {
|
|
|
|
//
|
|
// Copy everything between dmDeviceName and dmFormName
|
|
//
|
|
p1 = (LPBYTE) pUnicodeDevMode->dmDeviceName +
|
|
sizeof(pUnicodeDevMode->dmDeviceName);
|
|
p2 = (LPBYTE) pUnicodeDevMode->dmFormName;
|
|
|
|
MoveMemory((LPBYTE) pANSIDevMode->dmDeviceName +
|
|
sizeof(pANSIDevMode->dmDeviceName),
|
|
p1,
|
|
p2 - p1);
|
|
|
|
//
|
|
// Copy dmFormName which is a string
|
|
//
|
|
UnicodeToAnsiString(pUnicodeDevMode->dmFormName,
|
|
pANSIDevMode->dmFormName,
|
|
ComputeMaxStrlenW(pUnicodeDevMode->dmFormName,
|
|
sizeof pANSIDevMode->dmFormName));
|
|
|
|
//
|
|
// Copy everything after dmFormName
|
|
//
|
|
p1 = (LPBYTE) pUnicodeDevMode->dmFormName +
|
|
sizeof(pUnicodeDevMode->dmFormName);
|
|
p2 = (LPBYTE) pUnicodeDevMode + dmSize + dmDriverExtra;
|
|
|
|
MoveMemory((LPBYTE) pANSIDevMode->dmFormName +
|
|
sizeof(pANSIDevMode->dmFormName),
|
|
p1,
|
|
p2 - p1);
|
|
|
|
|
|
pANSIDevMode->dmSize = dmSize + sizeof(DEVMODEA) - sizeof(DEVMODEW);
|
|
} else {
|
|
|
|
//
|
|
// Copy everything after dmDeviceName
|
|
//
|
|
p1 = (LPBYTE) pUnicodeDevMode->dmDeviceName +
|
|
sizeof(pUnicodeDevMode->dmDeviceName);
|
|
p2 = (LPBYTE) pUnicodeDevMode + dmSize + dmDriverExtra;
|
|
|
|
MoveMemory((LPBYTE) pANSIDevMode->dmDeviceName +
|
|
sizeof(pANSIDevMode->dmDeviceName),
|
|
p1,
|
|
p2 - p1);
|
|
|
|
|
|
pANSIDevMode->dmSize = dmSize + sizeof(pANSIDevMode->dmDeviceName)
|
|
- sizeof(pUnicodeDevMode->dmDeviceName);
|
|
}
|
|
|
|
SPLASSERT(pANSIDevMode->dmDriverExtra == dmDriverExtra);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ConvertAnsiDevModeToUnicodeDevmode(
|
|
PDEVMODEA pAnsiDevMode,
|
|
PDEVMODEW pUnicodeDevMode,
|
|
DWORD dwUnicodeDevModeSize,
|
|
PDWORD pcbNeeded
|
|
)
|
|
{
|
|
PDEVMODEW pDevModeW = NULL;
|
|
BOOL bRet = FALSE;
|
|
|
|
if ( !pAnsiDevMode ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
SPLASSERT(BoolFromHResult(SplIsValidDevmodeNoSizeA(pAnsiDevMode)));
|
|
|
|
pDevModeW = AllocateUnicodeDevMode(pAnsiDevMode);
|
|
if ( !pDevModeW ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
*pcbNeeded = pDevModeW->dmSize + pDevModeW->dmDriverExtra;
|
|
|
|
if ( *pcbNeeded > dwUnicodeDevModeSize ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
CopyMemory((LPBYTE)pUnicodeDevMode,
|
|
(LPBYTE)pDevModeW,
|
|
*pcbNeeded);
|
|
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
|
|
if ( pDevModeW )
|
|
LocalFree(pDevModeW);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ConvertUnicodeDevModeToAnsiDevmode(
|
|
PDEVMODEW pUnicodeDevMode,
|
|
PDEVMODEA pAnsiDevMode,
|
|
DWORD dwAnsiDevModeSize,
|
|
PDWORD pcbNeeded
|
|
)
|
|
{
|
|
LPBYTE pDevMode = NULL;
|
|
BOOL bRet = FALSE;
|
|
DWORD dwSize;
|
|
|
|
if ( !pUnicodeDevMode ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwSize = pUnicodeDevMode->dmSize + pUnicodeDevMode->dmDriverExtra;
|
|
|
|
pDevMode = LocalAlloc(LPTR, dwSize);
|
|
|
|
if ( !pDevMode ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
CopyMemory(pDevMode,
|
|
(LPBYTE)pUnicodeDevMode,
|
|
dwSize);
|
|
|
|
CopyAnsiDevModeFromUnicodeDevMode((PDEVMODEA) pDevMode,
|
|
(PDEVMODEW) pDevMode);
|
|
|
|
*pcbNeeded = ((PDEVMODEA)pDevMode)->dmSize + ((PDEVMODEA)pDevMode)->dmDriverExtra;
|
|
|
|
if ( *pcbNeeded > dwAnsiDevModeSize ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
CopyMemory((LPBYTE)pAnsiDevMode,
|
|
pDevMode,
|
|
*pcbNeeded);
|
|
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
if ( pDevMode )
|
|
LocalFree(pDevMode);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
void
|
|
FreeUnicodeStructure(
|
|
LPBYTE pUnicodeStructure,
|
|
LPDWORD pOffsets
|
|
)
|
|
{
|
|
DWORD i=0;
|
|
|
|
if ( pUnicodeStructure == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if (pOffsets) {
|
|
while (pOffsets[i] != -1) {
|
|
|
|
FreeUnicodeString(*(LPWSTR *)(pUnicodeStructure+pOffsets[i]));
|
|
i++;
|
|
}
|
|
}
|
|
|
|
LocalFree( pUnicodeStructure );
|
|
}
|
|
|
|
BOOL
|
|
EnumPrintersA(
|
|
DWORD Flags,
|
|
LPSTR Name,
|
|
DWORD Level,
|
|
LPBYTE pPrinterEnum,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName;
|
|
|
|
switch (Level) {
|
|
|
|
case STRESSINFOLEVEL:
|
|
pOffsets = PrinterInfoStressStrings;
|
|
cbStruct = sizeof(PRINTER_INFO_STRESS);
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = PrinterInfo4Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_4);
|
|
break;
|
|
|
|
case 1:
|
|
pOffsets = PrinterInfo1Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = PrinterInfo2Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_2);
|
|
break;
|
|
|
|
case 5:
|
|
pOffsets = PrinterInfo5Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_5);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(Name);
|
|
if (Name && !pUnicodeName)
|
|
return FALSE;
|
|
|
|
ReturnValue = EnumPrintersW(Flags, pUnicodeName, Level, pPrinterEnum,
|
|
cbBuf, pcbNeeded, pcReturned);
|
|
|
|
if (ReturnValue && pPrinterEnum) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
|
|
ConvertUnicodeToAnsiStrings(pPrinterEnum, pOffsets);
|
|
|
|
if ((Level == 2) && pPrinterEnum) {
|
|
|
|
PRINTER_INFO_2 *pPrinterInfo2 = (PRINTER_INFO_2 *)pPrinterEnum;
|
|
|
|
if (pPrinterInfo2->pDevMode)
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
(LPDEVMODEA)pPrinterInfo2->pDevMode,
|
|
(LPDEVMODEW)pPrinterInfo2->pDevMode);
|
|
}
|
|
|
|
pPrinterEnum+=cbStruct;
|
|
}
|
|
}
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
OpenPrinterA(
|
|
LPSTR pPrinterName,
|
|
LPHANDLE phPrinter,
|
|
LPPRINTER_DEFAULTSA pDefault
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
LPWSTR pUnicodePrinterName = NULL;
|
|
PRINTER_DEFAULTSW UnicodeDefaults={NULL, NULL, 0};
|
|
|
|
pUnicodePrinterName = AllocateUnicodeString(pPrinterName);
|
|
if (pPrinterName && !pUnicodePrinterName)
|
|
goto Cleanup;
|
|
|
|
if (pDefault) {
|
|
|
|
UnicodeDefaults.pDatatype = AllocateUnicodeString(pDefault->pDatatype);
|
|
if (pDefault->pDatatype && !UnicodeDefaults.pDatatype)
|
|
goto Cleanup;
|
|
|
|
//
|
|
// Milestones etc. 4.5 passes in a bogus devmode in pDefaults.
|
|
// Be sure to validate here.
|
|
//
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(pDefault->pDevMode))){
|
|
|
|
UnicodeDefaults.pDevMode = AllocateUnicodeDevMode(
|
|
pDefault->pDevMode );
|
|
|
|
if( !UnicodeDefaults.pDevMode ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
UnicodeDefaults.DesiredAccess = pDefault->DesiredAccess;
|
|
}
|
|
|
|
ReturnValue = OpenPrinterW(pUnicodePrinterName, phPrinter, &UnicodeDefaults);
|
|
|
|
if (ReturnValue) {
|
|
|
|
((PSPOOL)*phPrinter)->Status |= SPOOL_STATUS_ANSI;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if (UnicodeDefaults.pDevMode)
|
|
LocalFree(UnicodeDefaults.pDevMode);
|
|
|
|
FreeUnicodeString(UnicodeDefaults.pDatatype);
|
|
FreeUnicodeString(pUnicodePrinterName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
ResetPrinterA(
|
|
HANDLE hPrinter,
|
|
LPPRINTER_DEFAULTSA pDefault
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
PRINTER_DEFAULTSW UnicodeDefaults={NULL, NULL, 0};
|
|
|
|
if (pDefault) {
|
|
|
|
if (pDefault->pDatatype == (LPSTR)-1) {
|
|
UnicodeDefaults.pDatatype = (LPWSTR)-1;
|
|
} else {
|
|
|
|
UnicodeDefaults.pDatatype = AllocateUnicodeString(pDefault->pDatatype);
|
|
if (pDefault->pDatatype && !UnicodeDefaults.pDatatype)
|
|
return FALSE;
|
|
}
|
|
|
|
if (pDefault->pDevMode == (LPDEVMODEA)-1) {
|
|
UnicodeDefaults.pDevMode = (LPDEVMODEW)-1;
|
|
} else {
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(pDefault->pDevMode))){
|
|
|
|
UnicodeDefaults.pDevMode = AllocateUnicodeDevMode(
|
|
pDefault->pDevMode );
|
|
|
|
if( !UnicodeDefaults.pDevMode ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ReturnValue = ResetPrinterW(hPrinter, &UnicodeDefaults);
|
|
|
|
if (UnicodeDefaults.pDevMode &&
|
|
(UnicodeDefaults.pDevMode != (LPDEVMODEW)-1)){
|
|
|
|
LocalFree(UnicodeDefaults.pDevMode);
|
|
}
|
|
|
|
|
|
Cleanup:
|
|
|
|
if (UnicodeDefaults.pDatatype && (UnicodeDefaults.pDatatype != (LPWSTR)-1)) {
|
|
FreeUnicodeString(UnicodeDefaults.pDatatype);
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
SetJobA(
|
|
HANDLE hPrinter,
|
|
DWORD JobId,
|
|
DWORD Level,
|
|
LPBYTE pJob,
|
|
DWORD Command
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
LPBYTE pUnicodeStructure=NULL;
|
|
LPDEVMODEW pDevModeW = NULL;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 0:
|
|
break;
|
|
|
|
case 1:
|
|
pOffsets = JobInfo1Strings;
|
|
cbStruct = sizeof(JOB_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = JobInfo2Strings;
|
|
cbStruct = sizeof(JOB_INFO_2);
|
|
break;
|
|
|
|
case 3:
|
|
return SetJobW( hPrinter, JobId, Level, pJob, Command );
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (Level) {
|
|
pUnicodeStructure = AllocateUnicodeStructure(pJob, cbStruct, pOffsets);
|
|
if (pJob && !pUnicodeStructure)
|
|
return FALSE;
|
|
}
|
|
|
|
if ( Level == 2 && pUnicodeStructure && pJob ) {
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(((LPJOB_INFO_2A)pJob)->pDevMode))){
|
|
|
|
pDevModeW = AllocateUnicodeDevMode(((LPJOB_INFO_2A)pJob)->pDevMode);
|
|
|
|
if( !pDevModeW ){
|
|
ReturnValue = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
((LPJOB_INFO_2W) pUnicodeStructure)->pDevMode = pDevModeW;
|
|
}
|
|
}
|
|
|
|
ReturnValue = SetJobW(hPrinter, JobId, Level, pUnicodeStructure, Command);
|
|
|
|
if ( pDevModeW ) {
|
|
|
|
LocalFree(pDevModeW);
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetJobA(
|
|
HANDLE hPrinter,
|
|
DWORD JobId,
|
|
DWORD Level,
|
|
LPBYTE pJob,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = JobInfo1Strings;
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = JobInfo2Strings;
|
|
break;
|
|
|
|
case 3:
|
|
return GetJobW( hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded );
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (GetJob(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded)) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pJob, pOffsets);
|
|
|
|
//
|
|
// Convert the devmode in place for INFO_2.
|
|
//
|
|
if( Level == 2 ){
|
|
|
|
PJOB_INFO_2A pJobInfo2 = (PJOB_INFO_2A)pJob;
|
|
|
|
if( pJobInfo2->pDevMode ){
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
(LPDEVMODEA)pJobInfo2->pDevMode,
|
|
(LPDEVMODEW)pJobInfo2->pDevMode);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
} else
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
EnumJobsA(
|
|
HANDLE hPrinter,
|
|
DWORD FirstJob,
|
|
DWORD NoJobs,
|
|
DWORD Level,
|
|
LPBYTE pJob,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
DWORD i, cbStruct, *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = JobInfo1Strings;
|
|
cbStruct = sizeof(JOB_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = JobInfo2Strings;
|
|
cbStruct = sizeof(JOB_INFO_2);
|
|
break;
|
|
|
|
case 3:
|
|
return EnumJobsW( hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned );
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (EnumJobsW(hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded,
|
|
pcReturned)) {
|
|
|
|
i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pJob, pOffsets);
|
|
|
|
//
|
|
// Convert the devmode in place for INFO_2.
|
|
//
|
|
if( Level == 2 ){
|
|
|
|
PJOB_INFO_2A pJobInfo2 = (PJOB_INFO_2A)pJob;
|
|
|
|
if( pJobInfo2->pDevMode ){
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
(LPDEVMODEA)pJobInfo2->pDevMode,
|
|
(LPDEVMODEW)pJobInfo2->pDevMode);
|
|
}
|
|
}
|
|
|
|
pJob += cbStruct;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
} else
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
HANDLE
|
|
AddPrinterA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
LPBYTE pPrinter
|
|
)
|
|
{
|
|
HANDLE hPrinter = NULL;
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
LPDEVMODEW pDevModeW = NULL;
|
|
LPWSTR pUnicodeName = NULL;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 2:
|
|
pOffsets = PrinterInfo2Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_2);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return NULL;
|
|
}
|
|
|
|
if (!pPrinter) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return NULL;
|
|
}
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pPrinter, cbStruct, pOffsets);
|
|
if (pPrinter && !pUnicodeStructure)
|
|
goto Cleanup;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
if ( pUnicodeStructure ) {
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(((LPPRINTER_INFO_2A)pPrinter)->pDevMode))){
|
|
pDevModeW = AllocateUnicodeDevMode(
|
|
((LPPRINTER_INFO_2A)pPrinter)->pDevMode);
|
|
|
|
if( !pDevModeW ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
((LPPRINTER_INFO_2W)pUnicodeStructure)->pDevMode = pDevModeW;
|
|
|
|
hPrinter = AddPrinterW(pUnicodeName, Level, pUnicodeStructure);
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString( pUnicodeName );
|
|
|
|
if ( pDevModeW ) {
|
|
|
|
LocalFree(pDevModeW);
|
|
}
|
|
|
|
FreeUnicodeStructure( pUnicodeStructure, pOffsets );
|
|
|
|
return hPrinter;
|
|
}
|
|
|
|
BOOL
|
|
AddPrinterConnectionA(
|
|
LPSTR pName
|
|
)
|
|
{
|
|
BOOL rc;
|
|
LPWSTR pUnicodeName;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
return FALSE;
|
|
|
|
rc = AddPrinterConnectionW(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
DeletePrinterConnectionA(
|
|
LPSTR pName
|
|
)
|
|
{
|
|
BOOL rc;
|
|
LPWSTR pUnicodeName;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
return FALSE;
|
|
|
|
rc = DeletePrinterConnectionW(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
SetPrinterA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pPrinter,
|
|
DWORD Command
|
|
)
|
|
{
|
|
LPBYTE pUnicodeStructure; /* Unicode version of input data */
|
|
DWORD cbStruct; /* Size of the output structure */
|
|
DWORD *pOffsets; /* -1 terminated list of addresses */
|
|
DWORD ReturnValue=FALSE;
|
|
|
|
//
|
|
// For APP compat. Win9x handled this
|
|
//
|
|
if (eProtectHandle(hPrinter, FALSE))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
switch (Level) {
|
|
|
|
case 0:
|
|
//
|
|
// This could be 2 cases. STRESSINFOLEVEL, or the real 0 level.
|
|
// If Command is 0 then it is STRESSINFOLEVEL, else real 0 level
|
|
//
|
|
if ( !Command ) {
|
|
|
|
pOffsets = PrinterInfoStressStrings;
|
|
cbStruct = sizeof( PRINTER_INFO_STRESS );
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
pOffsets = PrinterInfo1Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_1 );
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = PrinterInfo2Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_2 );
|
|
break;
|
|
|
|
case 3:
|
|
pOffsets = PrinterInfo3Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_3 );
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = PrinterInfo4Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_4 );
|
|
break;
|
|
|
|
case 5:
|
|
pOffsets = PrinterInfo5Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_5 );
|
|
break;
|
|
|
|
case 6:
|
|
break;
|
|
|
|
case 7:
|
|
pOffsets = PrinterInfo7Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_7 );
|
|
break;
|
|
|
|
case 8:
|
|
pOffsets = PrinterInfo8Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_8 );
|
|
break;
|
|
|
|
case 9:
|
|
pOffsets = PrinterInfo9Strings;
|
|
cbStruct = sizeof( PRINTER_INFO_9 );
|
|
break;
|
|
|
|
default:
|
|
SetLastError( ERROR_INVALID_LEVEL );
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// The structure needs to have its CONTENTS converted from
|
|
// ANSI to Unicode. The above switch() statement filled in
|
|
// the two important pieces of information needed to accomplish
|
|
// this goal. First is the size of the structure, second is
|
|
// a list of the offset within the structure to UNICODE
|
|
// string pointers. The AllocateUnicodeStructure() call will
|
|
// allocate a wide version of the structure, copy its contents
|
|
// and convert the strings to Unicode as it goes. That leaves
|
|
// us to deal with any other pieces needing conversion.
|
|
//
|
|
|
|
//
|
|
// If Level == 0 and Command != 0 then pPrinter is a DWORD
|
|
//
|
|
if ( Level == 6 || (!Level && Command) ) {
|
|
|
|
if ( Level == 6 || Command == PRINTER_CONTROL_SET_STATUS )
|
|
pUnicodeStructure = pPrinter;
|
|
else
|
|
pUnicodeStructure = NULL;
|
|
|
|
} else {
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pPrinter, cbStruct, pOffsets);
|
|
if (pPrinter && !pUnicodeStructure)
|
|
{
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
#define pPrinterInfo2W ((LPPRINTER_INFO_2W)pUnicodeStructure)
|
|
#define pPrinterInfo2A ((LPPRINTER_INFO_2A)pPrinter)
|
|
|
|
//
|
|
// The Level 2 structure has a DEVMODE struct in it: convert now
|
|
//
|
|
if ( Level == 2 &&
|
|
pPrinterInfo2A &&
|
|
pPrinterInfo2A->pDevMode ) {
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(pPrinterInfo2A->pDevMode))){
|
|
pPrinterInfo2W->pDevMode = AllocateUnicodeDevMode(
|
|
pPrinterInfo2A->pDevMode );
|
|
|
|
if( !pPrinterInfo2W->pDevMode)
|
|
{
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define pPrinterInfo8W ((LPPRINTER_INFO_8W)pUnicodeStructure)
|
|
#define pPrinterInfo8A ((LPPRINTER_INFO_8A)pPrinter)
|
|
|
|
if (( Level == 8 || Level == 9 ) &&
|
|
pPrinterInfo8A &&
|
|
pPrinterInfo8A->pDevMode ) {
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(pPrinterInfo8A->pDevMode))){
|
|
pPrinterInfo8W->pDevMode = AllocateUnicodeDevMode(
|
|
pPrinterInfo8A->pDevMode );
|
|
|
|
if( !pPrinterInfo8W->pDevMode)
|
|
{
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReturnValue = SetPrinterW( hPrinter, Level, pUnicodeStructure, Command );
|
|
|
|
//
|
|
// Free the DEVMODE we allocated (if we did!), then the
|
|
// the Unicode structure and its contents.
|
|
//
|
|
if (Level == 2 &&
|
|
pPrinterInfo2W &&
|
|
pPrinterInfo2W->pDevMode ) {
|
|
|
|
LocalFree( pPrinterInfo2W->pDevMode );
|
|
}
|
|
|
|
if ((Level == 8 || Level == 9) &&
|
|
pUnicodeStructure &&
|
|
pPrinterInfo8W->pDevMode ) {
|
|
|
|
LocalFree( pPrinterInfo8W->pDevMode );
|
|
}
|
|
|
|
//
|
|
// STRESS_INFO and Levels 1-5
|
|
//
|
|
if ( Level != 6 && (Level || !Command) )
|
|
FreeUnicodeStructure( pUnicodeStructure, pOffsets );
|
|
|
|
#undef pPrinterInfo2W
|
|
#undef pPrinterInfo2A
|
|
|
|
Done:
|
|
|
|
vUnprotectHandle(hPrinter);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetPrinterA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pPrinter,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case STRESSINFOLEVEL:
|
|
pOffsets = PrinterInfoStressOffsets;
|
|
break;
|
|
|
|
case 1:
|
|
pOffsets = PrinterInfo1Strings;
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = PrinterInfo2Strings;
|
|
break;
|
|
|
|
case 3:
|
|
pOffsets = PrinterInfo3Strings;
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = PrinterInfo4Strings;
|
|
break;
|
|
|
|
case 5:
|
|
pOffsets = PrinterInfo5Strings;
|
|
break;
|
|
|
|
case 6:
|
|
pOffsets = PrinterInfo6Strings;
|
|
break;
|
|
|
|
case 7:
|
|
pOffsets = PrinterInfo7Strings;
|
|
break;
|
|
|
|
case 8:
|
|
pOffsets = PrinterInfo8Strings;
|
|
break;
|
|
|
|
case 9:
|
|
pOffsets = PrinterInfo9Strings;
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded)) {
|
|
|
|
if (pPrinter) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pPrinter, pOffsets);
|
|
|
|
if ((Level == 2) && pPrinter) {
|
|
|
|
PRINTER_INFO_2 *pPrinterInfo2 = (PRINTER_INFO_2 *)pPrinter;
|
|
|
|
if (pPrinterInfo2->pDevMode)
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
(LPDEVMODEA)pPrinterInfo2->pDevMode,
|
|
(LPDEVMODEW)pPrinterInfo2->pDevMode);
|
|
}
|
|
|
|
if ((Level == 8 || Level == 9) && pPrinter) {
|
|
|
|
PRINTER_INFO_8 *pPrinterInfo8 = (PRINTER_INFO_8 *)pPrinter;
|
|
|
|
if (pPrinterInfo8->pDevMode)
|
|
CopyAnsiDevModeFromUnicodeDevMode(
|
|
(LPDEVMODEA)pPrinterInfo8->pDevMode,
|
|
(LPDEVMODEW)pPrinterInfo8->pDevMode);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
UnicodeToAnsiMultiSz(
|
|
LPWSTR pUnicodeDependentFiles
|
|
)
|
|
{
|
|
LPWSTR pAlignedUnicodeStr = NULL;
|
|
LPWSTR pUnicodeStr;
|
|
DWORD StringLength, rc;
|
|
DWORD Index;
|
|
BOOL bReturn = FALSE;
|
|
|
|
//
|
|
// Conversion in place
|
|
//
|
|
if (!(pUnicodeDependentFiles) || !*pUnicodeDependentFiles) {
|
|
|
|
bReturn = TRUE;
|
|
|
|
} else {
|
|
|
|
if ((ULONG_PTR)pUnicodeDependentFiles != (((ULONG_PTR) (pUnicodeDependentFiles) + (sizeof(WCHAR) - 1))&~(sizeof(WCHAR) - 1))) {
|
|
|
|
//
|
|
// Calculate the length of the unaligned multisz string
|
|
//
|
|
for (StringLength = 0;
|
|
!( ((LPSTR)pUnicodeDependentFiles)[StringLength] == '\0' &&
|
|
((LPSTR)pUnicodeDependentFiles)[StringLength + 1] == '\0' &&
|
|
((LPSTR)pUnicodeDependentFiles)[StringLength + 2] == '\0' &&
|
|
((LPSTR)pUnicodeDependentFiles)[StringLength + 3] == '\0' );
|
|
StringLength += 2)
|
|
;
|
|
|
|
StringLength /= 2;
|
|
|
|
//
|
|
// Include NULL terminator for last string and NULL terminator for MULTI SZ
|
|
//
|
|
StringLength +=2;
|
|
|
|
} else {
|
|
|
|
//
|
|
// The string is WCHAR aligned.
|
|
//
|
|
pUnicodeStr = pUnicodeDependentFiles;
|
|
|
|
while ( *pUnicodeStr ) {
|
|
|
|
pUnicodeStr += wcslen(pUnicodeStr) + 1;
|
|
}
|
|
|
|
StringLength = (DWORD) (pUnicodeStr - pUnicodeDependentFiles + 1);
|
|
}
|
|
|
|
//
|
|
// Since WideCharToMultiByte doesn't do in place conversion,
|
|
// duplicate the pUnicodeDependentFiles regardless if it is aligned or not.
|
|
//
|
|
if (pAlignedUnicodeStr = LocalAlloc(LPTR, StringLength * sizeof(char) * 2)) {
|
|
|
|
memcpy( pAlignedUnicodeStr, pUnicodeDependentFiles, StringLength * sizeof(char)* 2);
|
|
|
|
rc = WideCharToMultiByte(CP_THREAD_ACP,
|
|
0,
|
|
pAlignedUnicodeStr,
|
|
StringLength,
|
|
(LPSTR)pUnicodeDependentFiles,
|
|
StringLength * 2,
|
|
NULL, NULL );
|
|
|
|
LocalFree( pAlignedUnicodeStr );
|
|
|
|
bReturn = rc > 0;
|
|
}
|
|
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
AnsiToUnicodeMultiSz(
|
|
LPSTR pAnsiDependentFiles,
|
|
LPWSTR *pUnicodeDependentFiles
|
|
)
|
|
{
|
|
LPWSTR pUnicodeStr;
|
|
LPSTR pAnsiStr;
|
|
DWORD len, rc;
|
|
|
|
if ( ! (pAnsiStr = pAnsiDependentFiles) || !*pAnsiStr ) {
|
|
*pUnicodeDependentFiles = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
while ( *pAnsiStr )
|
|
pAnsiStr += strlen(pAnsiStr) + 1;
|
|
len = (DWORD) (pAnsiStr - pAnsiDependentFiles + 1);
|
|
|
|
if ( !(*pUnicodeDependentFiles = LocalAlloc(LPTR, len * sizeof(WCHAR))) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
AnsiToUnicodeString(pAnsiDependentFiles, *pUnicodeDependentFiles, len-1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
AddPrinterDriverExA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
PBYTE pPrinter,
|
|
DWORD dwFileCopyFlags
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
LPDWORD pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 2:
|
|
pOffsets = DriverInfo2Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_2);
|
|
break;
|
|
|
|
case 3:
|
|
pOffsets = DriverInfo3Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_3);
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = DriverInfo4Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_4);
|
|
break;
|
|
|
|
case 6:
|
|
pOffsets = DriverInfo6Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_6);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!pPrinter) {
|
|
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pPrinter, cbStruct, pOffsets);
|
|
if (pPrinter && !pUnicodeStructure)
|
|
goto Error;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Error;
|
|
|
|
|
|
//
|
|
// Handle dependent files which is upto \0\0
|
|
//
|
|
if ( ( Level == 3 || Level == 4 || Level ==6 ) &&
|
|
!AnsiToUnicodeMultiSz(
|
|
(LPSTR) ((PDRIVER_INFO_3A)pPrinter)->pDependentFiles,
|
|
&(((PDRIVER_INFO_3W)pUnicodeStructure)->pDependentFiles)) ) {
|
|
|
|
goto Error;
|
|
}
|
|
|
|
//
|
|
// Handle pszzPreviousNames which is upto \0\0
|
|
//
|
|
if ( ( Level == 4 || Level == 6 ) &&
|
|
!AnsiToUnicodeMultiSz(
|
|
(LPSTR) ((PDRIVER_INFO_4A)pPrinter)->pszzPreviousNames,
|
|
&(((PDRIVER_INFO_4W)pUnicodeStructure)->pszzPreviousNames)) ) {
|
|
|
|
goto Error;
|
|
}
|
|
|
|
ReturnValue = AddPrinterDriverExW(pUnicodeName, Level, pUnicodeStructure,dwFileCopyFlags);
|
|
|
|
if ( ( Level == 3 || Level == 4 || Level == 6) &&
|
|
((PDRIVER_INFO_3W)pUnicodeStructure)->pDependentFiles ) {
|
|
|
|
LocalFree(((PDRIVER_INFO_3W)pUnicodeStructure)->pDependentFiles);
|
|
}
|
|
|
|
if ( (Level == 4 || Level == 6 )&&
|
|
(((PDRIVER_INFO_4)pUnicodeStructure)->pszzPreviousNames) )
|
|
LocalFree(((PDRIVER_INFO_4)pUnicodeStructure)->pszzPreviousNames);
|
|
|
|
Error:
|
|
|
|
FreeUnicodeStructure( pUnicodeStructure, pOffsets );
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddPrinterDriverA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
PBYTE pPrinter
|
|
)
|
|
{
|
|
return AddPrinterDriverExA(pName, Level, pPrinter, APD_COPY_NEW_FILES);
|
|
}
|
|
|
|
BOOL
|
|
EnumPrinterDriversA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
DWORD Level,
|
|
LPBYTE pDriverInfo,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = DriverInfo1Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = DriverInfo2Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_2);
|
|
break;
|
|
|
|
case 3:
|
|
pOffsets = DriverInfo3Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_3);
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = DriverInfo4Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_4);
|
|
break;
|
|
|
|
case 5:
|
|
pOffsets = DriverInfo5Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_5);
|
|
break;
|
|
|
|
case 6:
|
|
pOffsets = DriverInfo6Strings;
|
|
cbStruct = sizeof(DRIVER_INFO_6);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
if (ReturnValue = EnumPrinterDriversW(pUnicodeName, pUnicodeEnvironment,
|
|
Level, pDriverInfo, cbBuf,
|
|
pcbNeeded, pcReturned)) {
|
|
if (pDriverInfo) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pDriverInfo, pOffsets);
|
|
|
|
if ( ( Level == 3 || Level == 4 || Level == 6) &&
|
|
!UnicodeToAnsiMultiSz(
|
|
((PDRIVER_INFO_3) pDriverInfo)->pDependentFiles) )
|
|
ReturnValue = FALSE;
|
|
|
|
if ( ( Level == 4 || Level == 6 ) &&
|
|
!UnicodeToAnsiMultiSz(
|
|
((PDRIVER_INFO_4) pDriverInfo)->pszzPreviousNames) )
|
|
ReturnValue = FALSE;
|
|
|
|
pDriverInfo+=cbStruct;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetPrinterDriverA(
|
|
HANDLE hPrinter,
|
|
LPSTR pEnvironment,
|
|
DWORD Level,
|
|
LPBYTE pDriverInfo,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
BOOL ReturnValue;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = DriverInfo1Strings;
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = DriverInfo2Strings;
|
|
break;
|
|
|
|
case 3:
|
|
pOffsets = DriverInfo3Strings;
|
|
break;
|
|
|
|
case 4:
|
|
pOffsets = DriverInfo4Strings;
|
|
break;
|
|
|
|
case 5:
|
|
pOffsets = DriverInfo5Strings;
|
|
break;
|
|
|
|
case 6:
|
|
pOffsets = DriverInfo6Strings;
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
return FALSE;
|
|
|
|
if (ReturnValue = GetPrinterDriverW(hPrinter, pUnicodeEnvironment, Level,
|
|
pDriverInfo, cbBuf, pcbNeeded)) {
|
|
if (pDriverInfo) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pDriverInfo, pOffsets);
|
|
|
|
if ( ( Level == 3 || Level == 4 || Level == 6) &&
|
|
!UnicodeToAnsiMultiSz(
|
|
((PDRIVER_INFO_3)pDriverInfo)->pDependentFiles) ) {
|
|
|
|
ReturnValue = FALSE;
|
|
}
|
|
|
|
if ( ( Level == 4 || Level == 6 ) &&
|
|
!UnicodeToAnsiMultiSz(
|
|
((PDRIVER_INFO_4)pDriverInfo)->pszzPreviousNames) ) {
|
|
|
|
ReturnValue = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If called to get the size of buffer it will return the size of a W structure and strings
|
|
// rather than the A version. also see enum
|
|
// This cannot cause any harm since we are only allocating more memory than we need.
|
|
//
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetPrinterDriverDirectoryA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
DWORD Level,
|
|
LPBYTE pDriverDirectory,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pDriverDirectoryW = NULL;
|
|
BOOL ReturnValue = FALSE;
|
|
DWORD Offsets[]={0,(DWORD)-1};
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = DriverInfo1Offsets;
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
if (ReturnValue = GetPrinterDriverDirectoryW(pUnicodeName,
|
|
pUnicodeEnvironment, Level,
|
|
pDriverDirectory,
|
|
cbBuf, pcbNeeded)) {
|
|
|
|
if (pDriverDirectory) {
|
|
|
|
UnicodeToAnsiString((LPWSTR)pDriverDirectory, pDriverDirectory, NULL_TERMINATED);
|
|
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DeletePrinterDriverExA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pDriverName,
|
|
DWORD dwDeleteFlag,
|
|
DWORD dwVersionNum
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodeDriverName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodeDriverName = AllocateUnicodeString(pDriverName);
|
|
if (pDriverName && !pUnicodeDriverName)
|
|
goto Cleanup;
|
|
|
|
rc = DeletePrinterDriverExW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
pUnicodeDriverName,
|
|
dwDeleteFlag,
|
|
dwVersionNum);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodeDriverName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DeletePrinterDriverA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pDriverName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodeDriverName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodeDriverName = AllocateUnicodeString(pDriverName);
|
|
if (pDriverName && !pUnicodeDriverName)
|
|
goto Cleanup;
|
|
|
|
rc = DeletePrinterDriverW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
pUnicodeDriverName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodeDriverName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddPerMachineConnectionA(
|
|
LPCSTR pServer,
|
|
LPCSTR pPrinterName,
|
|
LPCSTR pPrintServer,
|
|
LPCSTR pProvider
|
|
)
|
|
{
|
|
|
|
LPWSTR pUnicodeServer = NULL;
|
|
LPWSTR pUnicodePrinterName = NULL;
|
|
LPWSTR pUnicodePrintServer = NULL;
|
|
LPWSTR pUnicodeProvider = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeServer = AllocateUnicodeString((LPSTR)pServer);
|
|
if (pServer && !pUnicodeServer)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrinterName = AllocateUnicodeString((LPSTR)pPrinterName);
|
|
if (pPrinterName && !pUnicodePrinterName)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrintServer = AllocateUnicodeString((LPSTR)pPrintServer);
|
|
if (pPrintServer && !pUnicodePrintServer)
|
|
goto Cleanup;
|
|
|
|
pUnicodeProvider = AllocateUnicodeString((LPSTR)pProvider);
|
|
if (pProvider && !pUnicodeProvider)
|
|
goto Cleanup;
|
|
|
|
|
|
rc = AddPerMachineConnectionW((LPCWSTR) pUnicodeServer,
|
|
(LPCWSTR) pUnicodePrinterName,
|
|
(LPCWSTR) pUnicodePrintServer,
|
|
(LPCWSTR) pUnicodeProvider);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeServer);
|
|
|
|
FreeUnicodeString(pUnicodePrinterName);
|
|
|
|
FreeUnicodeString(pUnicodePrintServer);
|
|
|
|
FreeUnicodeString(pUnicodeProvider);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
DeletePerMachineConnectionA(
|
|
LPCSTR pServer,
|
|
LPCSTR pPrinterName
|
|
)
|
|
{
|
|
|
|
LPWSTR pUnicodeServer = NULL;
|
|
LPWSTR pUnicodePrinterName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeServer = AllocateUnicodeString((LPSTR)pServer);
|
|
if (pServer && !pUnicodeServer)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrinterName = AllocateUnicodeString((LPSTR)pPrinterName);
|
|
if (pPrinterName && !pUnicodePrinterName)
|
|
goto Cleanup;
|
|
|
|
rc = DeletePerMachineConnectionW((LPCWSTR) pUnicodeServer,
|
|
(LPCWSTR) pUnicodePrinterName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeServer);
|
|
|
|
FreeUnicodeString(pUnicodePrinterName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
EnumPerMachineConnectionsA(
|
|
LPCSTR pServer,
|
|
LPBYTE pPrinterEnum,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct,index;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeServer = NULL;
|
|
|
|
pOffsets = PrinterInfo4Strings;
|
|
cbStruct = sizeof(PRINTER_INFO_4);
|
|
|
|
pUnicodeServer = AllocateUnicodeString((LPSTR)pServer);
|
|
if (pServer && !pUnicodeServer)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = EnumPerMachineConnectionsW((LPCWSTR) pUnicodeServer,
|
|
pPrinterEnum,
|
|
cbBuf,
|
|
pcbNeeded,
|
|
pcReturned);
|
|
|
|
if (ReturnValue && pPrinterEnum) {
|
|
index=*pcReturned;
|
|
while (index--) {
|
|
ConvertUnicodeToAnsiStrings(pPrinterEnum, pOffsets);
|
|
pPrinterEnum+=cbStruct;
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeServer);
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
AddPrintProcessorA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pPathName,
|
|
LPSTR pPrintProcessorName
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodePathName = NULL;
|
|
LPWSTR pUnicodePrintProcessorName = NULL;
|
|
|
|
if (!pPathName || !*pPathName) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!pPrintProcessorName || !*pPrintProcessorName) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodePathName = AllocateUnicodeString(pPathName);
|
|
if (pPathName && !pUnicodePathName)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrintProcessorName = AllocateUnicodeString(pPrintProcessorName);
|
|
if (pPrintProcessorName && !pUnicodePrintProcessorName)
|
|
goto Cleanup;
|
|
|
|
|
|
if (pUnicodePathName && pUnicodePrintProcessorName) {
|
|
|
|
ReturnValue = AddPrintProcessorW(pUnicodeName, pUnicodeEnvironment,
|
|
pUnicodePathName,
|
|
pUnicodePrintProcessorName);
|
|
}
|
|
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
FreeUnicodeString(pUnicodePathName);
|
|
FreeUnicodeString(pUnicodePrintProcessorName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
EnumPrintProcessorsA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
DWORD Level,
|
|
LPBYTE pPrintProcessorInfo,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = PrintProcessorInfo1Strings;
|
|
cbStruct = sizeof(PRINTPROCESSOR_INFO_1);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
if (ReturnValue = EnumPrintProcessorsW(pUnicodeName,
|
|
pUnicodeEnvironment, Level,
|
|
pPrintProcessorInfo, cbBuf,
|
|
pcbNeeded, pcReturned)) {
|
|
if (pPrintProcessorInfo) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pPrintProcessorInfo, pOffsets);
|
|
|
|
pPrintProcessorInfo+=cbStruct;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetPrintProcessorDirectoryA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
DWORD Level,
|
|
LPBYTE pPrintProcessorInfo,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = GetPrintProcessorDirectoryW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
Level,
|
|
pPrintProcessorInfo,
|
|
cbBuf, pcbNeeded);
|
|
|
|
if (ReturnValue && pPrintProcessorInfo) {
|
|
UnicodeToAnsiString((LPWSTR)pPrintProcessorInfo,
|
|
(LPSTR)pPrintProcessorInfo,
|
|
NULL_TERMINATED);
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
EnumPrintProcessorDatatypesA(
|
|
LPSTR pName,
|
|
LPSTR pPrintProcessorName,
|
|
DWORD Level,
|
|
LPBYTE pDatatype,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodePrintProcessorName = NULL;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = DatatypeInfo1Strings;
|
|
cbStruct = sizeof(DATATYPES_INFO_1);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrintProcessorName = AllocateUnicodeString(pPrintProcessorName);
|
|
if (pPrintProcessorName && !pUnicodePrintProcessorName)
|
|
goto Cleanup;
|
|
|
|
if (ReturnValue = EnumPrintProcessorDatatypesW(pUnicodeName,
|
|
pUnicodePrintProcessorName,
|
|
Level,
|
|
pDatatype,
|
|
cbBuf,
|
|
pcbNeeded,
|
|
pcReturned)) {
|
|
if (pDatatype) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pDatatype, pOffsets);
|
|
|
|
pDatatype += cbStruct;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodePrintProcessorName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
DWORD
|
|
StartDocPrinterA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pDocInfo
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
DWORD cbStruct;
|
|
|
|
// level 2 is supported on win95 and not on NT
|
|
switch (Level) {
|
|
case 1:
|
|
cbStruct = sizeof(DOC_INFO_1A);
|
|
break;
|
|
case 3:
|
|
cbStruct = sizeof(DOC_INFO_3A);
|
|
break;
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pDocInfo, cbStruct, DocInfo1Offsets);
|
|
if (pDocInfo && !pUnicodeStructure)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = StartDocPrinterW(hPrinter, Level, pUnicodeStructure);
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeStructure(pUnicodeStructure, DocInfo1Offsets);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
AddJobA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pData,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
|
|
if( Level == 2 || Level == 3 ){
|
|
|
|
SetLastError( ERROR_INVALID_LEVEL );
|
|
return FALSE;
|
|
}
|
|
|
|
if (ReturnValue = AddJobW(hPrinter, Level, pData,
|
|
cbBuf, pcbNeeded))
|
|
|
|
ConvertUnicodeToAnsiStrings(pData, AddJobStrings);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
DWORD
|
|
GetPrinterDataA(
|
|
HANDLE hPrinter,
|
|
LPSTR pValueName,
|
|
LPDWORD pType,
|
|
LPBYTE pData,
|
|
DWORD nSize,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD ReturnValue = ERROR_SUCCESS;
|
|
DWORD ReturnType = 0;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString(pValueName);
|
|
|
|
//
|
|
// pUnicodeValueName will be NULL if the caller passed NULL for pValueName. The
|
|
// invalid situation is when pValueName is non NULL and pUnicodeValueName is NULL
|
|
//
|
|
if (pUnicodeValueName || !pValueName)
|
|
{
|
|
if (!pType)
|
|
{
|
|
pType = (PDWORD)&ReturnType;
|
|
}
|
|
|
|
if (pUnicodeValueName && !_wcsicmp(pUnicodeValueName, SPLREG_OS_VERSION))
|
|
{
|
|
//
|
|
// The caller wants OSVersion
|
|
//
|
|
OSVERSIONINFOW osw = {0};
|
|
|
|
ReturnValue = GetPrinterDataW(hPrinter,
|
|
pUnicodeValueName,
|
|
pType,
|
|
(PBYTE)&osw,
|
|
nSize >= sizeof(OSVERSIONINFOA) ? sizeof(osw) : nSize,
|
|
pcbNeeded);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && pData)
|
|
{
|
|
OSVERSIONWRAP wrap = {0};
|
|
|
|
wrap.bOsVersionEx = FALSE;
|
|
wrap.Unicode.pOsVersion = &osw;
|
|
wrap.Ansi.pOsVersion = (OSVERSIONINFOA *)pData;
|
|
|
|
ReturnValue = CopyOsVersionUnicodeToAnsi(wrap);
|
|
}
|
|
|
|
//
|
|
// Set correct number of bytes required/returned
|
|
//
|
|
if (pcbNeeded)
|
|
{
|
|
*pcbNeeded = sizeof(OSVERSIONINFOA);
|
|
}
|
|
}
|
|
else if (pUnicodeValueName && !_wcsicmp(pUnicodeValueName, SPLREG_OS_VERSIONEX))
|
|
{
|
|
//
|
|
// The caller wants OSVersionEx
|
|
//
|
|
OSVERSIONINFOEXW osexw = {0};
|
|
|
|
ReturnValue = GetPrinterDataW(hPrinter,
|
|
pUnicodeValueName,
|
|
pType,
|
|
(PBYTE)&osexw,
|
|
nSize >= sizeof(OSVERSIONINFOEXA) ? sizeof(osexw) : nSize,
|
|
pcbNeeded);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && pData)
|
|
{
|
|
OSVERSIONWRAP wrap = {0};
|
|
|
|
wrap.bOsVersionEx = TRUE;
|
|
wrap.Unicode.pOsVersionEx = &osexw;
|
|
wrap.Ansi.pOsVersionEx = (OSVERSIONINFOEXA *)pData;
|
|
|
|
ReturnValue = CopyOsVersionUnicodeToAnsi(wrap);
|
|
}
|
|
|
|
//
|
|
// Set correct number of bytes required/returned
|
|
//
|
|
if (pcbNeeded)
|
|
{
|
|
*pcbNeeded = sizeof(OSVERSIONINFOEXA);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = GetPrinterDataW(hPrinter, pUnicodeValueName, pType, pData, nSize, pcbNeeded);
|
|
|
|
//
|
|
// Special case string values
|
|
//
|
|
if ((ReturnValue == ERROR_MORE_DATA || ReturnValue == ERROR_SUCCESS) &&
|
|
(*pType == REG_MULTI_SZ || *pType == REG_SZ || *pType == REG_EXPAND_SZ))
|
|
{
|
|
if (ReturnValue==ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// The buffer passed in by the caller was large enough. We only need to
|
|
// convert from UNICODE to ANSI. It can happen that a UNICODE char will
|
|
// be represented on 3 ansi chars, so we cannot assume that if a buffer
|
|
// is large enough for a unicode string, it can also accomodate the converted
|
|
// ansi string.
|
|
//
|
|
ReturnValue = UnicodeToAnsi(NULL,
|
|
0,
|
|
pData,
|
|
*pcbNeeded,
|
|
pcbNeeded);
|
|
}
|
|
else
|
|
{
|
|
BYTE *pBuf = NULL;
|
|
|
|
if (pBuf = LocalAlloc(LPTR, *pcbNeeded))
|
|
{
|
|
if ((ReturnValue = GetPrinterDataW(hPrinter,
|
|
pUnicodeValueName,
|
|
pType,
|
|
pBuf,
|
|
*pcbNeeded,
|
|
pcbNeeded)) == ERROR_SUCCESS)
|
|
{
|
|
ReturnValue = UnicodeToAnsi(pBuf,
|
|
*pcbNeeded / sizeof(WCHAR),
|
|
pData,
|
|
nSize,
|
|
pcbNeeded);
|
|
}
|
|
|
|
LocalFree(pBuf);
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// pUnicodeValueName is NULL and pValueName is NOT NULL, so AllocateUnicodeString failed
|
|
// AllocateUnicodeString sets the LastError correctly
|
|
//
|
|
ReturnValue = GetLastError();
|
|
}
|
|
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
DWORD
|
|
GetPrinterDataExA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName,
|
|
LPCSTR pValueName,
|
|
LPDWORD pType,
|
|
LPBYTE pData,
|
|
DWORD nSize,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
DWORD ReturnValue = ERROR_SUCCESS;
|
|
DWORD ReturnType = 0;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString((LPSTR) pValueName);
|
|
if (pValueName && !pUnicodeValueName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
if (!pType) {
|
|
pType = (PDWORD) &ReturnType;
|
|
}
|
|
|
|
if (pUnicodeValueName && !_wcsicmp(pUnicodeValueName, SPLREG_OS_VERSION))
|
|
{
|
|
//
|
|
// The caller wants OSVersion
|
|
//
|
|
OSVERSIONINFOW osw = {0};
|
|
|
|
ReturnValue = GetPrinterDataExW(hPrinter,
|
|
(LPCWSTR)pUnicodeKeyName,
|
|
(LPCWSTR)pUnicodeValueName,
|
|
pType,
|
|
(PBYTE)&osw,
|
|
nSize >= sizeof(OSVERSIONINFOA) ? sizeof(osw) : nSize,
|
|
pcbNeeded);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && pData)
|
|
{
|
|
OSVERSIONWRAP wrap = {0};
|
|
|
|
wrap.bOsVersionEx = FALSE;
|
|
wrap.Unicode.pOsVersion = &osw;
|
|
wrap.Ansi.pOsVersion = (OSVERSIONINFOA *)pData;
|
|
|
|
ReturnValue = CopyOsVersionUnicodeToAnsi(wrap);
|
|
}
|
|
|
|
//
|
|
// Set correct number of bytes required/returned
|
|
//
|
|
if (pcbNeeded)
|
|
{
|
|
*pcbNeeded = sizeof(OSVERSIONINFOA);
|
|
}
|
|
}
|
|
else if (pUnicodeValueName && !_wcsicmp(pUnicodeValueName, SPLREG_OS_VERSIONEX))
|
|
{
|
|
//
|
|
// The caller wants OSVersionEx
|
|
//
|
|
OSVERSIONINFOEXW osexw = {0};
|
|
|
|
ReturnValue = GetPrinterDataExW(hPrinter,
|
|
(LPCWSTR)pUnicodeKeyName,
|
|
(LPCWSTR)pUnicodeValueName,
|
|
pType,
|
|
(PBYTE)&osexw,
|
|
nSize >= sizeof(OSVERSIONINFOEXA) ? sizeof(osexw) : nSize,
|
|
pcbNeeded);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && pData)
|
|
{
|
|
OSVERSIONWRAP wrap = {0};
|
|
|
|
wrap.bOsVersionEx = TRUE;
|
|
wrap.Unicode.pOsVersionEx = &osexw;
|
|
wrap.Ansi.pOsVersionEx = (OSVERSIONINFOEXA *)pData;
|
|
|
|
ReturnValue = CopyOsVersionUnicodeToAnsi(wrap);
|
|
}
|
|
|
|
//
|
|
// Set correct number of bytes required/returned
|
|
//
|
|
if (pcbNeeded)
|
|
{
|
|
*pcbNeeded = sizeof(OSVERSIONINFOEXA);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = GetPrinterDataExW(hPrinter,
|
|
(LPCWSTR)pUnicodeKeyName,
|
|
(LPCWSTR)pUnicodeValueName,
|
|
pType,
|
|
pData,
|
|
nSize,
|
|
pcbNeeded);
|
|
|
|
//
|
|
// Special case string values
|
|
//
|
|
if ((ReturnValue == ERROR_MORE_DATA || ReturnValue == ERROR_SUCCESS) &&
|
|
(*pType == REG_MULTI_SZ || *pType == REG_SZ || *pType == REG_EXPAND_SZ))
|
|
{
|
|
if (ReturnValue==ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// The buffer passed in by the caller was large enough. We only need to
|
|
// convert from UNICODE to ANSI. It can happen that a UNICODE char will
|
|
// be represented on 3 ansi chars, so we cannot assume that if a buffer
|
|
// is large enough for a unicode string, it can also accomodate the converted
|
|
// ansi string.
|
|
//
|
|
ReturnValue = UnicodeToAnsi(NULL,
|
|
0,
|
|
pData,
|
|
*pcbNeeded,
|
|
pcbNeeded);
|
|
}
|
|
else
|
|
{
|
|
BYTE *pBuf = NULL;
|
|
|
|
if (pBuf = LocalAlloc(LPTR, *pcbNeeded))
|
|
{
|
|
if ((ReturnValue = GetPrinterDataExW(hPrinter,
|
|
(LPCWSTR)pUnicodeKeyName,
|
|
(LPCWSTR)pUnicodeValueName,
|
|
pType,
|
|
pBuf,
|
|
*pcbNeeded,
|
|
pcbNeeded)) == ERROR_SUCCESS)
|
|
{
|
|
ReturnValue = UnicodeToAnsi(pBuf,
|
|
*pcbNeeded / sizeof(WCHAR),
|
|
pData,
|
|
nSize,
|
|
pcbNeeded);
|
|
}
|
|
|
|
LocalFree(pBuf);
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
EnumPrinterDataA(
|
|
HANDLE hPrinter,
|
|
DWORD dwIndex, // index of value to query
|
|
LPSTR pValueName, // address of buffer for value string
|
|
DWORD cbValueName, // size of pValueName
|
|
LPDWORD pcbValueName, // address for size of value buffer
|
|
LPDWORD pType, // address of buffer for type code
|
|
LPBYTE pData, // address of buffer for value data
|
|
DWORD cbData, // size of pData
|
|
LPDWORD pcbData // address for size of data buffer
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
DWORD i;
|
|
|
|
|
|
ReturnValue = EnumPrinterDataW(hPrinter,
|
|
dwIndex,
|
|
(LPWSTR) pValueName,
|
|
cbValueName,
|
|
pcbValueName,
|
|
pType,
|
|
pData,
|
|
cbData,
|
|
pcbData);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && (cbValueName || cbData))
|
|
{
|
|
if (pData && pType &&
|
|
(*pType==REG_SZ ||
|
|
*pType==REG_MULTI_SZ ||
|
|
*pType==REG_EXPAND_SZ))
|
|
{
|
|
//
|
|
// For this API we will require a buffer size that can accomodate UNICODE strings
|
|
// We do not want UnicodeToAnsi to update the number of bytes needed to store
|
|
// the string converted to ansi.
|
|
//
|
|
UnicodeToAnsi(NULL, 0, pData, *pcbData, NULL);
|
|
}
|
|
|
|
UnicodeToAnsiString((LPWSTR) pValueName, (LPSTR) pValueName, NULL_TERMINATED);
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
DWORD
|
|
EnumPrinterDataExA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName,
|
|
LPBYTE pEnumValues,
|
|
DWORD cbEnumValues,
|
|
LPDWORD pcbEnumValues,
|
|
LPDWORD pnEnumValues
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
DWORD i;
|
|
PPRINTER_ENUM_VALUES pEnumValue;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
|
|
ReturnValue = EnumPrinterDataExW(hPrinter,
|
|
(LPCWSTR) pUnicodeKeyName,
|
|
pEnumValues,
|
|
cbEnumValues,
|
|
pcbEnumValues,
|
|
pnEnumValues);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS) {
|
|
|
|
pEnumValue = (PPRINTER_ENUM_VALUES) pEnumValues;
|
|
|
|
for(i = 0 ; i < *pnEnumValues ; ++i, ++pEnumValue) {
|
|
|
|
if (pEnumValue->cbValueName) {
|
|
UnicodeToAnsiString((LPWSTR) pEnumValue->pValueName,
|
|
(LPSTR) pEnumValue->pValueName,
|
|
NULL_TERMINATED);
|
|
}
|
|
|
|
if (pEnumValue->pData &&
|
|
(pEnumValue->dwType == REG_SZ ||
|
|
pEnumValue->dwType == REG_MULTI_SZ ||
|
|
pEnumValue->dwType == REG_EXPAND_SZ)) {
|
|
|
|
//
|
|
// For this API we will require a buffer size that can accomodate UNICODE strings
|
|
// We do not want UnicodeToAnsi to update the number of bytes needed to store
|
|
// the string converted to ansi.
|
|
//
|
|
UnicodeToAnsi(NULL,
|
|
0,
|
|
pEnumValue->pData,
|
|
pEnumValue->cbData,
|
|
NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
EnumPrinterKeyA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName,
|
|
LPSTR pSubkey, // address of buffer for value string
|
|
DWORD cbSubkey, // size of pValueName
|
|
LPDWORD pcbSubkey // address for size of value buffer
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
|
|
ReturnValue = EnumPrinterKeyW( hPrinter,
|
|
(LPCWSTR) pUnicodeKeyName,
|
|
(LPWSTR) pSubkey,
|
|
cbSubkey,
|
|
pcbSubkey);
|
|
|
|
if (ReturnValue == ERROR_SUCCESS && cbSubkey)
|
|
{
|
|
ReturnValue = UnicodeToAnsi(NULL,
|
|
0,
|
|
pSubkey,
|
|
*pcbSubkey,
|
|
pcbSubkey);
|
|
}
|
|
else if (ReturnValue == ERROR_MORE_DATA)
|
|
{
|
|
BYTE *pBuf = NULL;
|
|
|
|
if (pBuf = LocalAlloc(LPTR, *pcbSubkey))
|
|
{
|
|
if ((ReturnValue = EnumPrinterKeyW(hPrinter,
|
|
(LPCWSTR)pUnicodeKeyName,
|
|
(LPWSTR)pBuf,
|
|
*pcbSubkey,
|
|
pcbSubkey)) == ERROR_SUCCESS)
|
|
{
|
|
ReturnValue = UnicodeToAnsi(pBuf,
|
|
*pcbSubkey / sizeof(WCHAR),
|
|
pSubkey,
|
|
cbSubkey,
|
|
pcbSubkey);
|
|
}
|
|
|
|
LocalFree(pBuf);
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = GetLastError();
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DeletePrinterDataA(
|
|
HANDLE hPrinter,
|
|
LPSTR pValueName
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString(pValueName);
|
|
if (pValueName && !pUnicodeValueName)
|
|
goto Cleanup;
|
|
|
|
|
|
ReturnValue = DeletePrinterDataW(hPrinter, (LPWSTR) pUnicodeValueName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DeletePrinterDataExA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName,
|
|
LPCSTR pValueName
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString((LPSTR) pValueName);
|
|
if (pValueName && !pUnicodeValueName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = DeletePrinterDataExW(hPrinter, (LPCWSTR) pUnicodeKeyName, (LPCWSTR) pUnicodeValueName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DeletePrinterKeyA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = DeletePrinterKeyW(hPrinter, (LPCWSTR) pUnicodeKeyName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
SetPrinterDataA(
|
|
HANDLE hPrinter,
|
|
LPSTR pValueName,
|
|
DWORD Type,
|
|
LPBYTE pData,
|
|
DWORD cbData
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
LPWSTR pUnicodeData = NULL;
|
|
DWORD cbDataString;
|
|
DWORD i;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString(pValueName);
|
|
|
|
if (pValueName && !pUnicodeValueName)
|
|
goto Cleanup;
|
|
|
|
if (Type == REG_SZ || Type == REG_EXPAND_SZ || Type == REG_MULTI_SZ)
|
|
{
|
|
//
|
|
// No matter if reg_sz or multi_sz, we want to mimic the registry APIs
|
|
// in behavior. This means we will not check strings for null termination.
|
|
// We will set as many bytes as specified by cbData
|
|
//
|
|
pUnicodeData = AllocateUnicodeStringWithSize(pData, cbData);
|
|
|
|
if (pUnicodeData)
|
|
{
|
|
cbData *= sizeof(WCHAR);
|
|
ReturnValue = SetPrinterDataW(hPrinter, pUnicodeValueName, Type, (LPBYTE) pUnicodeData, cbData);
|
|
FreeUnicodeString(pUnicodeData);
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = SetPrinterDataW(hPrinter, pUnicodeValueName, Type, pData, cbData);
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
DWORD
|
|
SetPrinterDataExA(
|
|
HANDLE hPrinter,
|
|
LPCSTR pKeyName,
|
|
LPCSTR pValueName,
|
|
DWORD Type,
|
|
LPBYTE pData,
|
|
DWORD cbData
|
|
)
|
|
{
|
|
DWORD ReturnValue = 0;
|
|
LPWSTR pUnicodeKeyName = NULL;
|
|
LPWSTR pUnicodeValueName = NULL;
|
|
LPWSTR pUnicodeData = NULL;
|
|
DWORD cbDataString;
|
|
DWORD i;
|
|
|
|
pUnicodeKeyName = AllocateUnicodeString((LPSTR) pKeyName);
|
|
if (pKeyName && !pUnicodeKeyName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeValueName = AllocateUnicodeString((LPSTR) pValueName);
|
|
if (pValueName && !pUnicodeValueName)
|
|
goto Cleanup;
|
|
|
|
if (Type == REG_SZ || Type == REG_EXPAND_SZ || Type == REG_MULTI_SZ)
|
|
{
|
|
//
|
|
// No matter if reg_sz or multi_sz, we want to mimic the registry APIs
|
|
// in behavior. This means we will not check strings for null termination.
|
|
// We will set as many bytes as specified by cbData
|
|
//
|
|
pUnicodeData = AllocateUnicodeStringWithSize(pData, cbData);
|
|
|
|
if (pUnicodeData)
|
|
{
|
|
cbData *= sizeof(WCHAR);
|
|
ReturnValue = SetPrinterDataExW(hPrinter,
|
|
(LPCWSTR) pUnicodeKeyName,
|
|
(LPCWSTR) pUnicodeValueName,
|
|
Type,
|
|
(LPBYTE) pUnicodeData,
|
|
cbData);
|
|
FreeUnicodeString(pUnicodeData);
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnValue = SetPrinterDataExW(hPrinter,
|
|
(LPCWSTR) pUnicodeKeyName,
|
|
(LPCWSTR) pUnicodeValueName,
|
|
Type,
|
|
pData,
|
|
cbData);
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeValueName);
|
|
FreeUnicodeString(pUnicodeKeyName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
|
|
/**************************** Function Header *******************************
|
|
* DocumentPropertiesA
|
|
* The ANSI version of the DocumentProperties function. Basically
|
|
* converts the input parameters to UNICODE versions and calls
|
|
* the DocumentPropertiesW function.
|
|
*
|
|
* CAVEATS: PRESUMES THAT IF pDevModeOutput IS SUPPLIED, IT HAS THE SIZE
|
|
* OF THE UNICODE VERSION. THIS WILL USUALLY HAPPEN IF THE CALLER
|
|
* FIRST CALLS TO FIND THE SIZE REQUIRED>
|
|
*
|
|
* RETURNS:
|
|
* Somesort of LONG.
|
|
*
|
|
****************************************************************************/
|
|
|
|
LONG
|
|
DocumentPropertiesA(
|
|
HWND hWnd,
|
|
HANDLE hPrinter,
|
|
LPSTR pDeviceName,
|
|
PDEVMODEA pDevModeOutput,
|
|
PDEVMODEA pDevModeInput,
|
|
DWORD fMode
|
|
)
|
|
{
|
|
LPWSTR pUnicodeDeviceName = NULL;
|
|
LPDEVMODEW pUnicodeDevModeInput = NULL;
|
|
LPDEVMODEW pUnicodeDevModeOutput = NULL;
|
|
LONG ReturnValue = -1;
|
|
|
|
pUnicodeDeviceName = AllocateUnicodeString(pDeviceName);
|
|
if (pDeviceName && !pUnicodeDeviceName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = DocumentPropertiesW(hWnd, hPrinter, pUnicodeDeviceName,
|
|
NULL, NULL, 0);
|
|
|
|
if (ReturnValue > 0) {
|
|
|
|
if (fMode) {
|
|
|
|
if (pUnicodeDevModeOutput = LocalAlloc(LMEM_FIXED, ReturnValue)) {
|
|
|
|
//
|
|
// Only convert the input buffer if one is specified
|
|
// and fMode indicates it's valid. WinNT 3.51 used
|
|
// pDevModeInput regardless of DM_IN_BUFFER, but this
|
|
// broke Borland Delphi for win95 + Corel Flow for win95.
|
|
//
|
|
if( pDevModeInput && ( fMode & DM_IN_BUFFER )){
|
|
|
|
//
|
|
// If the devmode is invalid, then don't pass one in.
|
|
// This fixes MS Imager32 (which passes dmSize == 0) and
|
|
// Milestones etc. 4.5.
|
|
//
|
|
// Note: this assumes that pDevModeOutput is still the
|
|
// correct size!
|
|
//
|
|
if( !BoolFromHResult(SplIsValidDevmodeNoSizeA(pDevModeInput))){
|
|
|
|
fMode &= ~DM_IN_BUFFER;
|
|
|
|
} else {
|
|
|
|
pUnicodeDevModeInput = AllocateUnicodeDevMode(
|
|
pDevModeInput );
|
|
|
|
if( !pUnicodeDevModeInput ){
|
|
ReturnValue = -1;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReturnValue = DocumentPropertiesW(hWnd, hPrinter,
|
|
pUnicodeDeviceName,
|
|
pUnicodeDevModeOutput,
|
|
pUnicodeDevModeInput, fMode );
|
|
|
|
//
|
|
// The printer driver has filled in the DEVMODEW
|
|
// structure - if one was passed in. Now convert it
|
|
// back to a DEVMODEA structure.
|
|
//
|
|
if (pDevModeOutput && (ReturnValue == IDOK)) {
|
|
CopyAnsiDevModeFromUnicodeDevMode(pDevModeOutput,
|
|
pUnicodeDevModeOutput);
|
|
}
|
|
|
|
} else
|
|
|
|
ReturnValue = -1;
|
|
|
|
} else
|
|
|
|
ReturnValue-=sizeof(DEVMODEW)-sizeof(DEVMODEA);
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if (pUnicodeDevModeInput)
|
|
LocalFree(pUnicodeDevModeInput);
|
|
|
|
if (pUnicodeDevModeOutput)
|
|
LocalFree(pUnicodeDevModeOutput);
|
|
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
WriteCurDevModeToRegistry(
|
|
LPWSTR pPrinterName,
|
|
LPDEVMODEW pDevMode
|
|
)
|
|
{
|
|
DWORD Status;
|
|
HKEY hDevMode;
|
|
|
|
SPLASSERT(pDevMode);
|
|
|
|
Status = RegCreateKeyEx(HKEY_CURRENT_USER,
|
|
szCurDevMode,
|
|
0,
|
|
NULL,
|
|
0,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hDevMode,
|
|
NULL);
|
|
|
|
if ( Status == ERROR_SUCCESS ) {
|
|
|
|
Status = RegSetValueExW(hDevMode,
|
|
pPrinterName,
|
|
0,
|
|
REG_BINARY,
|
|
(LPBYTE)pDevMode,
|
|
pDevMode->dmSize + pDevMode->dmDriverExtra);
|
|
|
|
RegCloseKey(hDevMode);
|
|
}
|
|
|
|
return Status == ERROR_SUCCESS;
|
|
}
|
|
|
|
BOOL
|
|
DeleteCurDevModeFromRegistry(
|
|
PWSTR pPrinterName
|
|
)
|
|
{
|
|
DWORD Status;
|
|
HKEY hDevModeKey;
|
|
|
|
Status = RegCreateKeyEx(HKEY_CURRENT_USER,
|
|
szCurDevMode,
|
|
0,
|
|
NULL,
|
|
0,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hDevModeKey,
|
|
NULL);
|
|
|
|
if ( Status == ERROR_SUCCESS ) {
|
|
Status = RegDeleteValue(hDevModeKey, pPrinterName);
|
|
RegCloseKey(hDevModeKey);
|
|
}
|
|
|
|
return Status == ERROR_SUCCESS;
|
|
}
|
|
|
|
LPDEVMODEW
|
|
AllocateCurDevMode(
|
|
HANDLE hPrinter,
|
|
LPWSTR pDeviceName,
|
|
LONG cbDevMode
|
|
)
|
|
{
|
|
LPDEVMODEW pRegDevMode = NULL;
|
|
LPDEVMODEW pRealDevMode = NULL;
|
|
LPDEVMODEW pRetDevMode = NULL;
|
|
BOOL bUpdateReg = FALSE;
|
|
HANDLE hKeyDevMode = INVALID_HANDLE_VALUE;
|
|
DWORD dwStatus, dwType;
|
|
LONG lDocStatus;
|
|
|
|
//
|
|
// This code now checks to see that the DEVMODE in the registry matches that of
|
|
// the driver. If it does not, then 1. The driver has been migrated. 2. The user has been
|
|
// using an incompatible driver. In this case, the per user DEVMODE settings are overwritten
|
|
// with those obtained from the driver.
|
|
//
|
|
|
|
dwStatus = RegCreateKeyEx( HKEY_CURRENT_USER,
|
|
szCurDevMode,
|
|
0,
|
|
NULL,
|
|
0,
|
|
KEY_READ,
|
|
NULL,
|
|
&hKeyDevMode,
|
|
NULL);
|
|
|
|
if( dwStatus != ERROR_SUCCESS )
|
|
goto Cleanup;
|
|
|
|
pRegDevMode = (PDEVMODEW)LocalAlloc(LMEM_FIXED, cbDevMode);
|
|
pRealDevMode = (PDEVMODEW)LocalAlloc(LMEM_FIXED, cbDevMode);
|
|
|
|
//
|
|
// This cbDevMode is obtained via a call to DocumentPropertiesW, thus it is
|
|
// correct (unless race condition).
|
|
//
|
|
if( pRegDevMode == NULL || pRealDevMode == NULL)
|
|
goto Cleanup;
|
|
|
|
lDocStatus = DocumentPropertiesW( NULL,
|
|
hPrinter,
|
|
pDeviceName,
|
|
pRealDevMode,
|
|
NULL,
|
|
DM_COPY );
|
|
|
|
dwStatus = RegQueryValueExW(hKeyDevMode,
|
|
pDeviceName,
|
|
0,
|
|
&dwType,
|
|
(LPBYTE)pRegDevMode,
|
|
&cbDevMode);
|
|
|
|
bUpdateReg = (dwStatus != ERROR_SUCCESS || dwType != REG_BINARY)
|
|
&& lDocStatus == IDOK;
|
|
|
|
if (dwStatus == ERROR_SUCCESS && lDocStatus == IDOK && !bUpdateReg) {
|
|
|
|
if (BoolFromHResult(SplIsValidDevmodeNoSizeW(pRegDevMode)))
|
|
{
|
|
//
|
|
// Check to see that our DEVMODE structures are compatible
|
|
//
|
|
bUpdateReg = pRealDevMode->dmSize != pRegDevMode->dmSize ||
|
|
pRealDevMode->dmDriverExtra != pRegDevMode->dmDriverExtra ||
|
|
pRealDevMode->dmSpecVersion != pRegDevMode->dmSpecVersion ||
|
|
pRealDevMode->dmDriverVersion != pRegDevMode->dmDriverVersion;
|
|
|
|
if (!bUpdateReg)
|
|
pRetDevMode = pRegDevMode;
|
|
}
|
|
}
|
|
|
|
if (bUpdateReg) {
|
|
//
|
|
// The Registry is out of date, The read from the Document properties must have
|
|
// succeded
|
|
//
|
|
if (!WriteCurDevModeToRegistry(pDeviceName, pRealDevMode) )
|
|
goto Cleanup;
|
|
else
|
|
pRetDevMode = pRealDevMode;
|
|
}
|
|
|
|
Cleanup:
|
|
if (pRegDevMode != pRetDevMode && pRegDevMode != NULL)
|
|
LocalFree(pRegDevMode);
|
|
|
|
if (pRealDevMode != pRetDevMode && pRealDevMode != NULL)
|
|
LocalFree(pRealDevMode);
|
|
|
|
if (hKeyDevMode != INVALID_HANDLE_VALUE)
|
|
RegCloseKey( hKeyDevMode );
|
|
|
|
return pRetDevMode;
|
|
}
|
|
|
|
|
|
VOID
|
|
MergeDevMode(
|
|
LPDEVMODEW pDMOut,
|
|
LPDEVMODEW pDMIn
|
|
)
|
|
{
|
|
|
|
//
|
|
// Simply check each bit in the dmFields entry. If set, then copy
|
|
// the input data to the output data.
|
|
//
|
|
|
|
if ( pDMIn->dmFields & DM_ORIENTATION ) {
|
|
|
|
pDMOut->dmOrientation = pDMIn->dmOrientation;
|
|
pDMOut->dmFields |= DM_ORIENTATION;
|
|
}
|
|
|
|
if( (pDMIn->dmFields & (DM_FORMNAME | DM_PAPERSIZE)) ||
|
|
(pDMIn->dmFields & (DM_PAPERLENGTH | DM_PAPERWIDTH)) ==
|
|
(DM_PAPERLENGTH | DM_PAPERWIDTH) )
|
|
{
|
|
//
|
|
// Value user fields, so use them. And delete ALL ours!
|
|
//
|
|
pDMOut->dmFields &= ~(DM_FORMNAME | DM_PAPERSIZE | DM_PAPERLENGTH | DM_PAPERWIDTH);
|
|
|
|
if( pDMIn->dmFields & DM_PAPERSIZE )
|
|
{
|
|
pDMOut->dmPaperSize = pDMIn->dmPaperSize;
|
|
pDMOut->dmFields |= DM_PAPERSIZE;
|
|
}
|
|
|
|
if( pDMIn->dmFields & DM_PAPERLENGTH )
|
|
{
|
|
pDMOut->dmPaperLength = pDMIn->dmPaperLength;
|
|
pDMOut->dmFields |= DM_PAPERLENGTH;
|
|
}
|
|
|
|
if( pDMIn->dmFields & DM_PAPERWIDTH )
|
|
{
|
|
pDMOut->dmPaperWidth = pDMIn->dmPaperWidth;
|
|
pDMOut->dmFields |= DM_PAPERWIDTH;
|
|
}
|
|
|
|
if( pDMIn->dmFields & DM_FORMNAME )
|
|
{
|
|
CopyMemory( pDMOut->dmFormName, pDMIn->dmFormName,
|
|
sizeof( pDMOut->dmFormName ) );
|
|
pDMOut->dmFields |= DM_FORMNAME;
|
|
}
|
|
|
|
}
|
|
|
|
if( pDMIn->dmFields & DM_SCALE ) {
|
|
|
|
pDMOut->dmScale = pDMIn->dmScale;
|
|
pDMOut->dmFields |= DM_SCALE;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_COPIES ) {
|
|
|
|
pDMOut->dmCopies = pDMIn->dmCopies;
|
|
pDMOut->dmFields |= DM_COPIES;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_DEFAULTSOURCE ) {
|
|
|
|
pDMOut->dmDefaultSource = pDMIn->dmDefaultSource;
|
|
pDMOut->dmFields |= DM_DEFAULTSOURCE;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_PRINTQUALITY ) {
|
|
|
|
pDMOut->dmPrintQuality = pDMIn->dmPrintQuality;
|
|
pDMOut->dmFields |= DM_PRINTQUALITY;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_COLOR ) {
|
|
|
|
pDMOut->dmColor = pDMIn->dmColor;
|
|
pDMOut->dmFields |= DM_COLOR;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_DUPLEX ) {
|
|
|
|
pDMOut->dmDuplex = pDMIn->dmDuplex;
|
|
pDMOut->dmFields |= DM_DUPLEX;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_YRESOLUTION ) {
|
|
|
|
//
|
|
// Note that DM_YRESOLUTION implies there is data in dmPrintQuality.
|
|
// This latter field is used to specify the desired X resolution,
|
|
// which is only required for dot matrix printers.
|
|
//
|
|
pDMOut->dmYResolution = pDMIn->dmYResolution;
|
|
pDMOut->dmPrintQuality = pDMIn->dmPrintQuality;
|
|
pDMOut->dmFields |= DM_YRESOLUTION;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_TTOPTION ) {
|
|
|
|
pDMOut->dmTTOption = pDMIn->dmTTOption;
|
|
pDMOut->dmFields |= DM_TTOPTION;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_COLLATE ) {
|
|
|
|
pDMOut->dmCollate = pDMIn->dmCollate;
|
|
pDMOut->dmFields |= DM_COLLATE;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_ICMMETHOD ) {
|
|
|
|
pDMOut->dmICMMethod = pDMIn->dmICMMethod;
|
|
pDMOut->dmFields |= DM_ICMMETHOD;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_ICMINTENT ) {
|
|
|
|
pDMOut->dmICMIntent = pDMIn->dmICMIntent;
|
|
pDMOut->dmFields |= DM_ICMINTENT;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_MEDIATYPE ) {
|
|
|
|
pDMOut->dmMediaType = pDMIn->dmMediaType;
|
|
pDMOut->dmFields |= DM_MEDIATYPE;
|
|
}
|
|
|
|
if ( pDMIn->dmFields & DM_DITHERTYPE ) {
|
|
|
|
pDMOut->dmDitherType = pDMIn->dmDitherType;
|
|
pDMOut->dmFields |= DM_DITHERTYPE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
LONG
|
|
ExtDeviceMode(
|
|
HWND hWnd,
|
|
HANDLE hInst,
|
|
LPDEVMODEA pDevModeOutput,
|
|
LPSTR pDeviceName,
|
|
LPSTR pPort,
|
|
LPDEVMODEA pDevModeInput,
|
|
LPSTR pProfile,
|
|
DWORD fMode
|
|
)
|
|
{
|
|
HANDLE hPrinter = NULL;
|
|
LONG cbDevMode;
|
|
DWORD NewfMode;
|
|
LPDEVMODEW pNewDevModeIn = NULL;
|
|
LPDEVMODEW pNewDevModeOut = NULL, pTempDevMode = NULL;
|
|
LONG ReturnValue = -1;
|
|
PRINTER_DEFAULTSW PrinterDefaults={NULL, NULL, PRINTER_READ};
|
|
LPWSTR pUnicodeDeviceName;
|
|
LPWSTR pUnicodePort;
|
|
|
|
pUnicodeDeviceName = AllocateUnicodeString(pDeviceName);
|
|
if (pDeviceName && !pUnicodeDeviceName)
|
|
return ReturnValue;
|
|
|
|
pUnicodePort = AllocateUnicodeString(pPort);
|
|
if (pPort && !pUnicodePort) {
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
return ReturnValue;
|
|
}
|
|
|
|
if (OpenPrinterW(pUnicodeDeviceName, &hPrinter, &PrinterDefaults)) {
|
|
|
|
cbDevMode = DocumentPropertiesW(hWnd, hPrinter, pUnicodeDeviceName,
|
|
NULL, NULL, 0);
|
|
|
|
if (!fMode || cbDevMode <= 0) {
|
|
ClosePrinter(hPrinter);
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
FreeUnicodeString(pUnicodePort);
|
|
if (!fMode)
|
|
cbDevMode -= sizeof(DEVMODEW) - sizeof(DEVMODEA);
|
|
return cbDevMode;
|
|
}
|
|
|
|
pNewDevModeOut = (PDEVMODEW)LocalAlloc( LMEM_FIXED, cbDevMode );
|
|
|
|
if( !pNewDevModeOut ){
|
|
|
|
ClosePrinter(hPrinter);
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
FreeUnicodeString(pUnicodePort);
|
|
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// If our flags specify an input DevMode, and we have
|
|
// an input devmode, use it.
|
|
//
|
|
if(( fMode & DM_IN_BUFFER ) && pDevModeInput ){
|
|
|
|
//
|
|
// App may specify one or two fields in dmFields and expect us
|
|
// to merge it with the global 16-bit devmode
|
|
//
|
|
pNewDevModeIn = AllocateCurDevMode(hPrinter,
|
|
pUnicodeDeviceName,
|
|
cbDevMode);
|
|
|
|
pTempDevMode = AllocateUnicodeDevMode(pDevModeInput);
|
|
|
|
//
|
|
// correct any bogus field settings for the papersize stuff
|
|
//
|
|
ValidatePaperFields(pUnicodeDeviceName,
|
|
pUnicodePort,
|
|
pTempDevMode);
|
|
|
|
if ( !pNewDevModeIn || !pTempDevMode ) {
|
|
|
|
if ( pNewDevModeIn )
|
|
LocalFree(pNewDevModeIn);
|
|
|
|
if ( pTempDevMode )
|
|
LocalFree(pTempDevMode);
|
|
|
|
ClosePrinter(hPrinter);
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
FreeUnicodeString(pUnicodePort);
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Some apps will just set the public fields they want to be changed
|
|
// from global devmode, so we need to merge input devmode with global
|
|
// devmode
|
|
//
|
|
MergeDevMode(pNewDevModeIn, pTempDevMode);
|
|
|
|
//
|
|
// Copy input devmode's private section if present else send the
|
|
// the private section from global devmode
|
|
//
|
|
if ( pTempDevMode->dmDriverExtra &&
|
|
pTempDevMode->dmDriverExtra == pNewDevModeIn->dmDriverExtra ) {
|
|
|
|
CopyMemory((LPBYTE)pNewDevModeIn + pNewDevModeIn->dmSize,
|
|
(LPBYTE)pTempDevMode + pTempDevMode->dmSize,
|
|
pTempDevMode->dmDriverExtra);
|
|
}
|
|
|
|
LocalFree(pTempDevMode);
|
|
pTempDevMode = NULL;
|
|
} else {
|
|
|
|
//
|
|
// Get the win16 global devmode.
|
|
//
|
|
pNewDevModeIn = AllocateCurDevMode( hPrinter,
|
|
pUnicodeDeviceName,
|
|
cbDevMode );
|
|
|
|
if (!pNewDevModeIn) {
|
|
ClosePrinter(hPrinter);
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
FreeUnicodeString(pUnicodePort);
|
|
return -1;
|
|
}
|
|
fMode |= DM_IN_BUFFER;
|
|
}
|
|
|
|
NewfMode = fMode;
|
|
|
|
//
|
|
// If DM_UPDATE is set, turn on DM_COPY so that we can update
|
|
// the win16 devmode.
|
|
//
|
|
if (fMode & DM_UPDATE)
|
|
NewfMode |= DM_COPY;
|
|
|
|
ReturnValue = DocumentPropertiesW(hWnd,
|
|
hPrinter,
|
|
pUnicodeDeviceName,
|
|
pNewDevModeOut,
|
|
pNewDevModeIn,
|
|
NewfMode);
|
|
|
|
if ( ReturnValue == IDOK &&
|
|
(fMode & DM_UPDATE) ) {
|
|
|
|
if ( WriteCurDevModeToRegistry(pUnicodeDeviceName,
|
|
pNewDevModeOut) ) {
|
|
|
|
|
|
SendNotifyMessageW(HWND_BROADCAST,
|
|
WM_DEVMODECHANGE,
|
|
0,
|
|
(LPARAM)pUnicodeDeviceName);
|
|
} else {
|
|
|
|
ReturnValue = -1;
|
|
}
|
|
}
|
|
|
|
if (pNewDevModeIn)
|
|
LocalFree(pNewDevModeIn);
|
|
|
|
if ((ReturnValue == IDOK) && (fMode & DM_COPY) && pDevModeOutput)
|
|
CopyAnsiDevModeFromUnicodeDevMode(pDevModeOutput, pNewDevModeOut);
|
|
|
|
if (pNewDevModeOut)
|
|
LocalFree(pNewDevModeOut);
|
|
|
|
ClosePrinter(hPrinter);
|
|
}
|
|
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
FreeUnicodeString(pUnicodePort);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
void
|
|
DeviceMode(
|
|
HWND hWnd,
|
|
HANDLE hModule,
|
|
LPSTR pDevice,
|
|
LPSTR pPort
|
|
)
|
|
{
|
|
HANDLE hPrinter, hDevMode;
|
|
DWORD cbDevMode;
|
|
LPDEVMODEW pNewDevMode, pDevMode=NULL;
|
|
PRINTER_DEFAULTSW PrinterDefaults={NULL, NULL, PRINTER_READ};
|
|
DWORD Status, Type, cb;
|
|
LPWSTR pUnicodeDevice;
|
|
|
|
pUnicodeDevice = AllocateUnicodeString(pDevice);
|
|
if (pDevice && !pUnicodeDevice)
|
|
return;
|
|
|
|
if (OpenPrinterW(pUnicodeDevice, &hPrinter, &PrinterDefaults)) {
|
|
|
|
Status = RegCreateKeyExW(HKEY_CURRENT_USER, szCurDevMode,
|
|
0, NULL, 0, KEY_WRITE | KEY_READ,
|
|
NULL, &hDevMode, NULL);
|
|
|
|
if (Status == ERROR_SUCCESS) {
|
|
|
|
Status = RegQueryValueExW(hDevMode, pUnicodeDevice, 0, &Type,
|
|
NULL, &cb);
|
|
|
|
if (Status == ERROR_SUCCESS) {
|
|
|
|
pDevMode = LocalAlloc(LMEM_FIXED, cb);
|
|
|
|
if (pDevMode) {
|
|
|
|
Status = RegQueryValueExW(hDevMode, pUnicodeDevice, 0,
|
|
&Type, (LPBYTE)pDevMode, &cb);
|
|
|
|
if (Status != ERROR_SUCCESS || BoolFromHResult(SplIsValidDevmodeNoSizeW(pDevMode))) {
|
|
LocalFree(pDevMode);
|
|
pDevMode = NULL;
|
|
}
|
|
|
|
} else {
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
cbDevMode = DocumentPropertiesW(hWnd, hPrinter,
|
|
pUnicodeDevice, NULL,
|
|
pDevMode, 0);
|
|
if (cbDevMode > 0) {
|
|
|
|
if (pNewDevMode = (PDEVMODEW)LocalAlloc(LMEM_FIXED,
|
|
cbDevMode)) {
|
|
|
|
if (DocumentPropertiesW(hWnd,
|
|
hPrinter, pUnicodeDevice,
|
|
pNewDevMode,
|
|
pDevMode,
|
|
DM_COPY | DM_PROMPT | DM_MODIFY)
|
|
== IDOK) {
|
|
|
|
Status = RegSetValueExW(hDevMode,
|
|
pUnicodeDevice, 0,
|
|
REG_BINARY,
|
|
(LPBYTE)pNewDevMode,
|
|
pNewDevMode->dmSize +
|
|
pNewDevMode->dmDriverExtra);
|
|
|
|
//
|
|
// Everything succeeded if Status == ERROR_SUCCESS.
|
|
//
|
|
}
|
|
LocalFree(pNewDevMode);
|
|
}
|
|
}
|
|
|
|
if (pDevMode)
|
|
LocalFree(pDevMode);
|
|
|
|
RegCloseKey(hDevMode);
|
|
}
|
|
|
|
ClosePrinter(hPrinter);
|
|
}
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeDevice);
|
|
|
|
return;
|
|
}
|
|
|
|
LONG
|
|
AdvancedDocumentPropertiesA(
|
|
HWND hWnd,
|
|
HANDLE hPrinter,
|
|
LPSTR pDeviceName,
|
|
PDEVMODEA pDevModeOutput,
|
|
PDEVMODEA pDevModeInput
|
|
)
|
|
{
|
|
LONG ReturnValue = FALSE;
|
|
LPWSTR pUnicodeDeviceName = NULL;
|
|
LPDEVMODEW pUnicodeDevModeInput = NULL;
|
|
LPDEVMODEW pUnicodeDevModeOutput = NULL;
|
|
|
|
LONG cbOutput = 0;
|
|
|
|
pUnicodeDeviceName = AllocateUnicodeString(pDeviceName);
|
|
if (pDeviceName && !pUnicodeDeviceName)
|
|
goto Cleanup;
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA(pDevModeInput))){
|
|
pUnicodeDevModeInput = AllocateUnicodeDevMode(pDevModeInput);
|
|
if( !pUnicodeDevModeInput ){
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// The output DevMode must be at least as big as the input
|
|
// DevMode.
|
|
//
|
|
cbOutput = pDevModeInput->dmSize +
|
|
pDevModeInput->dmDriverExtra +
|
|
sizeof(DEVMODEW) - sizeof(DEVMODEA);
|
|
}
|
|
|
|
if( pDevModeOutput ){
|
|
|
|
if( !cbOutput ){
|
|
|
|
//
|
|
// We don't know the output size of the devmode, so make
|
|
// call DocumentPropertiesW to find out.
|
|
//
|
|
cbOutput = DocumentPropertiesW( hWnd,
|
|
hPrinter,
|
|
pUnicodeDeviceName,
|
|
NULL,
|
|
NULL,
|
|
0 );
|
|
if( cbOutput <= 0 ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
pUnicodeDevModeOutput = (PDEVMODEW)LocalAlloc( LPTR, cbOutput );
|
|
if( !pUnicodeDevModeOutput ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
ReturnValue = AdvancedDocumentPropertiesW(hWnd, hPrinter,
|
|
pUnicodeDeviceName,
|
|
pUnicodeDevModeOutput,
|
|
pUnicodeDevModeInput );
|
|
|
|
if( pDevModeOutput && (ReturnValue > 0) ){
|
|
CopyAnsiDevModeFromUnicodeDevMode(pDevModeOutput,
|
|
pUnicodeDevModeOutput);
|
|
}
|
|
|
|
if ( !pDevModeOutput && ReturnValue > 0 )
|
|
ReturnValue -= sizeof(DEVMODEW) - sizeof(DEVMODEA);
|
|
|
|
Cleanup:
|
|
if (pUnicodeDevModeOutput)
|
|
LocalFree(pUnicodeDevModeOutput);
|
|
|
|
if (pUnicodeDevModeInput)
|
|
LocalFree(pUnicodeDevModeInput);
|
|
|
|
FreeUnicodeString(pUnicodeDeviceName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
LONG
|
|
AdvancedSetupDialog(
|
|
HWND hWnd,
|
|
HANDLE hInst,
|
|
LPDEVMODEA pDevModeInput,
|
|
LPDEVMODEA pDevModeOutput
|
|
)
|
|
{
|
|
HANDLE hPrinter;
|
|
LONG ReturnValue = -1;
|
|
|
|
if (OpenPrinterA(pDevModeInput->dmDeviceName, &hPrinter, NULL)) {
|
|
ReturnValue = AdvancedDocumentPropertiesA(hWnd, hPrinter,
|
|
pDevModeInput->dmDeviceName,
|
|
pDevModeOutput,
|
|
pDevModeInput);
|
|
ClosePrinter(hPrinter);
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
AddFormA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pForm
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
LPBYTE pUnicodeForm;
|
|
|
|
pUnicodeForm = AllocateUnicodeStructure(pForm, sizeof(FORM_INFO_1A), FormInfo1Strings);
|
|
if (pForm && !pUnicodeForm)
|
|
return FALSE;
|
|
|
|
ReturnValue = AddFormW(hPrinter, Level, pUnicodeForm);
|
|
|
|
FreeUnicodeStructure(pUnicodeForm, FormInfo1Offsets);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
DeleteFormA(
|
|
HANDLE hPrinter,
|
|
LPSTR pFormName
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
LPWSTR pUnicodeFormName;
|
|
|
|
pUnicodeFormName = AllocateUnicodeString(pFormName);
|
|
if (pFormName && !pUnicodeFormName)
|
|
return FALSE;
|
|
|
|
ReturnValue = DeleteFormW(hPrinter, pUnicodeFormName);
|
|
|
|
FreeUnicodeString(pUnicodeFormName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
GetFormA(
|
|
HANDLE hPrinter,
|
|
LPSTR pFormName,
|
|
DWORD Level,
|
|
LPBYTE pForm,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeFormName;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = FormInfo1Strings;
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeFormName = AllocateUnicodeString(pFormName);
|
|
if (pFormName && !pUnicodeFormName)
|
|
return FALSE;
|
|
|
|
ReturnValue = GetFormW(hPrinter, pUnicodeFormName, Level, pForm,
|
|
cbBuf, pcbNeeded);
|
|
|
|
if (ReturnValue && pForm)
|
|
|
|
ConvertUnicodeToAnsiStrings(pForm, pOffsets);
|
|
|
|
FreeUnicodeString(pUnicodeFormName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
SetFormA(
|
|
HANDLE hPrinter,
|
|
LPSTR pFormName,
|
|
DWORD Level,
|
|
LPBYTE pForm
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
LPWSTR pUnicodeFormName = NULL;
|
|
LPBYTE pUnicodeForm = NULL;
|
|
|
|
pUnicodeFormName = AllocateUnicodeString(pFormName);
|
|
if (pFormName && !pUnicodeFormName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeForm = AllocateUnicodeStructure(pForm, sizeof(FORM_INFO_1A), FormInfo1Strings);
|
|
if (pForm && !pUnicodeForm)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = SetFormW(hPrinter, pUnicodeFormName, Level, pUnicodeForm);
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeFormName);
|
|
|
|
FreeUnicodeStructure(pUnicodeForm, FormInfo1Offsets);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
EnumFormsA(
|
|
HANDLE hPrinter,
|
|
DWORD Level,
|
|
LPBYTE pForm,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = FormInfo1Strings;
|
|
cbStruct = sizeof(FORM_INFO_1);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
ReturnValue = EnumFormsW(hPrinter, Level, pForm, cbBuf,
|
|
pcbNeeded, pcReturned);
|
|
|
|
if (ReturnValue && pForm) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pForm, pOffsets);
|
|
|
|
pForm+=cbStruct;
|
|
}
|
|
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
EnumPortsA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
LPBYTE pPort,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName = NULL;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = PortInfo1Strings;
|
|
cbStruct = sizeof(PORT_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = PortInfo2Strings;
|
|
cbStruct = sizeof(PORT_INFO_2);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = EnumPortsW(pUnicodeName, Level, pPort, cbBuf,
|
|
pcbNeeded, pcReturned);
|
|
|
|
if (ReturnValue && pPort) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pPort, pOffsets);
|
|
|
|
pPort+=cbStruct;
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
EnumMonitorsA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
LPBYTE pMonitor,
|
|
DWORD cbBuf,
|
|
LPDWORD pcbNeeded,
|
|
LPDWORD pcReturned
|
|
)
|
|
{
|
|
BOOL ReturnValue = FALSE;
|
|
DWORD cbStruct;
|
|
DWORD *pOffsets;
|
|
LPWSTR pUnicodeName = NULL;
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = MonitorInfo1Strings;
|
|
cbStruct = sizeof(MONITOR_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = MonitorInfo2Strings;
|
|
cbStruct = sizeof(MONITOR_INFO_2);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = EnumMonitorsW(pUnicodeName, Level, pMonitor, cbBuf,
|
|
pcbNeeded, pcReturned);
|
|
|
|
if (ReturnValue && pMonitor) {
|
|
|
|
DWORD i=*pcReturned;
|
|
|
|
while (i--) {
|
|
|
|
ConvertUnicodeToAnsiStrings(pMonitor, pOffsets);
|
|
|
|
pMonitor+=cbStruct;
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
AddPortA(
|
|
LPSTR pName,
|
|
HWND hWnd,
|
|
LPSTR pMonitorName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeMonitorName = NULL;
|
|
DWORD ReturnValue = FALSE;
|
|
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeMonitorName = AllocateUnicodeString(pMonitorName);
|
|
if (pMonitorName && !pUnicodeMonitorName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = AddPortW( pUnicodeName, hWnd, pUnicodeMonitorName );
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeMonitorName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
ConfigurePortA(
|
|
LPSTR pName,
|
|
HWND hWnd,
|
|
LPSTR pPortName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodePortName = NULL;
|
|
DWORD ReturnValue = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodePortName = AllocateUnicodeString(pPortName);
|
|
if (pPortName && !pUnicodePortName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = ConfigurePortW( pUnicodeName, hWnd, pUnicodePortName );
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodePortName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
DeletePortA(
|
|
LPSTR pName,
|
|
HWND hWnd,
|
|
LPSTR pPortName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodePortName = NULL;
|
|
DWORD ReturnValue = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodePortName = AllocateUnicodeString(pPortName);
|
|
if (pPortName && !pUnicodePortName)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = DeletePortW( pUnicodeName, hWnd, pUnicodePortName );
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodePortName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
DWORD
|
|
PrinterMessageBoxA(
|
|
HANDLE hPrinter,
|
|
DWORD Error,
|
|
HWND hWnd,
|
|
LPSTR pText,
|
|
LPSTR pCaption,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
DWORD ReturnValue=FALSE;
|
|
LPWSTR pTextW = NULL;
|
|
LPWSTR pCaptionW = NULL;
|
|
|
|
pTextW = AllocateUnicodeString(pText);
|
|
if (pText && !pTextW)
|
|
goto Cleanup;
|
|
|
|
pCaptionW = AllocateUnicodeString(pCaption);
|
|
if (pCaption && !pCaptionW)
|
|
goto Cleanup;
|
|
|
|
ReturnValue = PrinterMessageBoxW(hPrinter, Error, hWnd, pTextW,
|
|
pCaptionW, dwType);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pTextW);
|
|
FreeUnicodeString(pCaptionW);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
int
|
|
DeviceCapabilitiesA(
|
|
LPCSTR pDevice,
|
|
LPCSTR pPort,
|
|
WORD fwCapability,
|
|
LPSTR pOutput,
|
|
CONST DEVMODEA *pDevMode
|
|
)
|
|
{
|
|
LPWSTR pDeviceW = NULL;
|
|
LPWSTR pPortW = NULL;
|
|
LPWSTR pOutputW = NULL;
|
|
LPWSTR pKeepW = NULL;
|
|
LPDEVMODEW pDevModeW = NULL;
|
|
DWORD c, Size;
|
|
int cb = 0;
|
|
int rc = GDI_ERROR;
|
|
|
|
pDeviceW = AllocateUnicodeString((LPSTR)pDevice);
|
|
if (pDevice && !pDeviceW)
|
|
goto Cleanup;
|
|
|
|
pPortW = AllocateUnicodeString((LPSTR)pPort);
|
|
if (pPort && !pPortW)
|
|
goto Cleanup;
|
|
|
|
if( BoolFromHResult(SplIsValidDevmodeNoSizeA((LPDEVMODEA)pDevMode))){
|
|
pDevModeW = AllocateUnicodeDevMode((LPDEVMODEA)pDevMode);
|
|
if( !pDevModeW ){
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
switch (fwCapability) {
|
|
//
|
|
// These will require Unicode to Ansi conversion
|
|
//
|
|
case DC_BINNAMES:
|
|
case DC_FILEDEPENDENCIES:
|
|
case DC_PAPERNAMES:
|
|
case DC_PERSONALITY:
|
|
case DC_MEDIAREADY:
|
|
case DC_MEDIATYPENAMES:
|
|
|
|
if (pOutput) {
|
|
|
|
cb = DeviceCapabilitiesW(pDeviceW, pPortW, fwCapability,
|
|
NULL, pDevModeW);
|
|
if (cb >= 0) {
|
|
|
|
switch (fwCapability) {
|
|
|
|
case DC_BINNAMES:
|
|
cb *= 48;
|
|
break;
|
|
|
|
case DC_PERSONALITY:
|
|
cb *= 64;
|
|
break;
|
|
|
|
case DC_FILEDEPENDENCIES:
|
|
case DC_PAPERNAMES:
|
|
case DC_MEDIAREADY:
|
|
case DC_MEDIATYPENAMES:
|
|
cb *= 128;
|
|
break;
|
|
|
|
}
|
|
|
|
pOutputW = pKeepW = LocalAlloc(LPTR, cb);
|
|
|
|
if (pKeepW) {
|
|
|
|
c = rc = DeviceCapabilitiesW(pDeviceW, pPortW, fwCapability,
|
|
pOutputW, pDevModeW);
|
|
|
|
switch (fwCapability) {
|
|
|
|
case DC_BINNAMES:
|
|
Size = 24;
|
|
break;
|
|
|
|
case DC_PERSONALITY:
|
|
Size = 32;
|
|
break;
|
|
|
|
case DC_FILEDEPENDENCIES:
|
|
case DC_PAPERNAMES:
|
|
case DC_MEDIAREADY:
|
|
case DC_MEDIATYPENAMES:
|
|
Size = 64;
|
|
break;
|
|
}
|
|
|
|
for (; c; c--) {
|
|
|
|
UnicodeToAnsiString(pOutputW, pOutput, NULL_TERMINATED);
|
|
|
|
pOutputW += Size;
|
|
pOutput += Size;
|
|
}
|
|
|
|
LocalFree(pKeepW);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
rc = DeviceCapabilitiesW(pDeviceW, pPortW, fwCapability,
|
|
NULL, pDevModeW);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
rc = DeviceCapabilitiesW(pDeviceW, pPortW, fwCapability, (LPWSTR)pOutput, pDevModeW);
|
|
|
|
//
|
|
// If the call to find size of public portion of devmode and
|
|
// it was succesful adjust the size for UNICODE->ANSI conversion
|
|
//
|
|
if ( fwCapability == DC_SIZE && rc > 0 ) {
|
|
|
|
rc -= sizeof(DEVMODEW) - sizeof(DEVMODEA);
|
|
}
|
|
}
|
|
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeString(pDeviceW);
|
|
FreeUnicodeString(pPortW);
|
|
if (pDevModeW)
|
|
LocalFree(pDevModeW);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
AddMonitorA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
LPBYTE pMonitorInfo
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
LPDWORD pOffsets;
|
|
|
|
switch (Level) {
|
|
|
|
case 2:
|
|
pOffsets = MonitorInfo2Strings;
|
|
cbStruct = sizeof(MONITOR_INFO_2);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pMonitorInfo, cbStruct, pOffsets);
|
|
if (pMonitorInfo && !pUnicodeStructure)
|
|
goto Cleanup;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
if (pUnicodeStructure) {
|
|
|
|
ReturnValue = AddMonitorW(pUnicodeName, Level, pUnicodeStructure);
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
DeleteMonitorA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pMonitorName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodeMonitorName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodeMonitorName = AllocateUnicodeString(pMonitorName);
|
|
if (pMonitorName && !pUnicodeMonitorName)
|
|
goto Cleanup;
|
|
|
|
rc = DeleteMonitorW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
pUnicodeMonitorName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodeMonitorName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
DeletePrintProcessorA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pPrintProcessorName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodePrintProcessorName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
if (!pPrintProcessorName || !*pPrintProcessorName) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrintProcessorName = AllocateUnicodeString(pPrintProcessorName);
|
|
if (pPrintProcessorName && !pUnicodePrintProcessorName)
|
|
goto Cleanup;
|
|
|
|
rc = DeletePrintProcessorW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
pUnicodePrintProcessorName);
|
|
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodePrintProcessorName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOL
|
|
AddPrintProvidorA(
|
|
LPSTR pName,
|
|
DWORD Level,
|
|
LPBYTE pProvidorInfo
|
|
)
|
|
{
|
|
BOOL ReturnValue=FALSE;
|
|
DWORD cbStruct;
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
LPDWORD pOffsets;
|
|
|
|
if (!pProvidorInfo)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
switch (Level) {
|
|
|
|
case 1:
|
|
pOffsets = ProvidorInfo1Strings;
|
|
cbStruct = sizeof(PROVIDOR_INFO_1);
|
|
break;
|
|
|
|
case 2:
|
|
pOffsets = ProvidorInfo2Strings;
|
|
cbStruct = sizeof(PROVIDOR_INFO_2);
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_LEVEL);
|
|
return FALSE;
|
|
}
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pProvidorInfo, cbStruct, pOffsets);
|
|
if (!pProvidorInfo || !pUnicodeStructure)
|
|
goto CleanUp;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto CleanUp;
|
|
|
|
if ((Level == 2) &&
|
|
!AnsiToUnicodeMultiSz((LPSTR) ((PPROVIDOR_INFO_2A) pProvidorInfo)->pOrder,
|
|
&(((PPROVIDOR_INFO_2W) pUnicodeStructure)->pOrder))) {
|
|
|
|
goto CleanUp;
|
|
}
|
|
|
|
if (pUnicodeStructure) {
|
|
|
|
ReturnValue = AddPrintProvidorW(pUnicodeName, Level,
|
|
pUnicodeStructure);
|
|
}
|
|
|
|
if ((Level == 2) &&
|
|
((PPROVIDOR_INFO_2W) pUnicodeStructure)->pOrder) {
|
|
|
|
LocalFree(((PPROVIDOR_INFO_2W) pUnicodeStructure)->pOrder);
|
|
((PPROVIDOR_INFO_2W) pUnicodeStructure)->pOrder = NULL;
|
|
}
|
|
|
|
CleanUp:
|
|
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
BOOL
|
|
DeletePrintProvidorA(
|
|
LPSTR pName,
|
|
LPSTR pEnvironment,
|
|
LPSTR pPrintProvidorName
|
|
)
|
|
{
|
|
LPWSTR pUnicodeName = NULL;
|
|
LPWSTR pUnicodeEnvironment = NULL;
|
|
LPWSTR pUnicodePrintProvidorName = NULL;
|
|
BOOL rc = FALSE;
|
|
|
|
pUnicodeName = AllocateUnicodeString(pName);
|
|
if (pName && !pUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeEnvironment = AllocateUnicodeString(pEnvironment);
|
|
if (pEnvironment && !pUnicodeEnvironment)
|
|
goto Cleanup;
|
|
|
|
pUnicodePrintProvidorName = AllocateUnicodeString(pPrintProvidorName);
|
|
if (pPrintProvidorName && !pUnicodePrintProvidorName)
|
|
goto Cleanup;
|
|
|
|
rc = DeletePrintProvidorW(pUnicodeName,
|
|
pUnicodeEnvironment,
|
|
pUnicodePrintProvidorName);
|
|
|
|
Cleanup:
|
|
FreeUnicodeString(pUnicodeName);
|
|
|
|
FreeUnicodeString(pUnicodeEnvironment);
|
|
|
|
FreeUnicodeString(pUnicodePrintProvidorName);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddPortExA(
|
|
IN LPSTR pName, OPTIONAL
|
|
IN DWORD Level,
|
|
IN LPBYTE pBuffer,
|
|
IN LPSTR pMonitorName
|
|
)
|
|
{
|
|
PPORT_INFO_1A pPortInfo1;
|
|
PPORT_INFO_FFA pPortInfoFF;
|
|
|
|
LPWSTR pNameW = NULL;
|
|
LPWSTR pMonitorNameW = NULL;
|
|
LPWSTR pPortNameW = NULL;
|
|
|
|
PORT_INFO_1W PortInfo1;
|
|
PORT_INFO_FFW PortInfoFF;
|
|
|
|
DWORD LastError = ERROR_SUCCESS;
|
|
BOOL bReturnValue = FALSE;
|
|
|
|
//
|
|
// Initialize variables that will be freed in error cases.
|
|
//
|
|
pNameW = AllocateUnicodeString( pName);
|
|
if (pName && !pNameW) {
|
|
LastError = GetLastError();
|
|
goto Done;
|
|
}
|
|
|
|
pPortNameW = NULL;
|
|
|
|
pMonitorNameW = AllocateUnicodeString( pMonitorName);
|
|
if (pMonitorName && !pMonitorNameW) {
|
|
LastError = GetLastError();
|
|
goto Done;
|
|
}
|
|
|
|
if( !pBuffer || !pMonitorName ){
|
|
LastError = ERROR_INVALID_PARAMETER;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Catch out of memory conditions.
|
|
//
|
|
if( !pMonitorNameW || ( pName && !pNameW )){
|
|
LastError = GetLastError();
|
|
goto Done;
|
|
}
|
|
|
|
switch( Level ){
|
|
case (DWORD)-1:
|
|
|
|
pPortInfoFF = (PPORT_INFO_FFA)pBuffer;
|
|
|
|
if( !pPortInfoFF->pName || !pPortInfoFF->pName[0] ){
|
|
LastError = ERROR_INVALID_PARAMETER;
|
|
goto Done;
|
|
}
|
|
|
|
pPortNameW = PortInfoFF.pName = AllocateUnicodeString( pPortInfoFF->pName);
|
|
|
|
if( !pPortNameW ){
|
|
LastError = GetLastError();
|
|
goto Done;
|
|
}
|
|
|
|
PortInfoFF.cbMonitorData = pPortInfoFF->cbMonitorData;
|
|
PortInfoFF.pMonitorData = pPortInfoFF->pMonitorData;
|
|
|
|
bReturnValue = AddPortExW( pNameW,
|
|
Level,
|
|
(LPBYTE)&PortInfoFF,
|
|
pMonitorNameW );
|
|
|
|
if( !bReturnValue ){
|
|
LastError = GetLastError();
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
|
|
pPortInfo1 = (PPORT_INFO_1A)pBuffer;
|
|
|
|
if( !pPortInfo1->pName || !pPortInfo1->pName[0] ){
|
|
LastError = ERROR_INVALID_PARAMETER;
|
|
goto Done;
|
|
}
|
|
|
|
pPortNameW = PortInfo1.pName = AllocateUnicodeString( pPortInfo1->pName);
|
|
|
|
if( !pPortNameW ){
|
|
LastError = GetLastError();
|
|
goto Done;
|
|
}
|
|
|
|
bReturnValue = AddPortExW( pNameW,
|
|
Level,
|
|
(LPBYTE)&PortInfo1,
|
|
pMonitorNameW );
|
|
|
|
if( !bReturnValue ){
|
|
LastError = GetLastError();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
LastError = ERROR_INVALID_LEVEL;
|
|
break;
|
|
}
|
|
|
|
Done:
|
|
|
|
FreeUnicodeString( pNameW );
|
|
FreeUnicodeString( pPortNameW );
|
|
FreeUnicodeString( pMonitorNameW );
|
|
|
|
if( !bReturnValue ){
|
|
|
|
SetLastError( LastError );
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
LPSTR
|
|
StartDocDlgA(
|
|
HANDLE hPrinter,
|
|
DOCINFOA *pDocInfo
|
|
)
|
|
{
|
|
DOCINFOW DocInfoW;
|
|
LPSTR lpszAnsiOutput = NULL;
|
|
LPSTR lpszAnsiString = NULL;
|
|
LPWSTR lpszUnicodeString = NULL;
|
|
DWORD dwLen = 0;
|
|
|
|
if (!pDocInfo) {
|
|
DBGMSG(DBG_WARNING, ("StartDocDlgA: Null pDocInfo passed in\n"));
|
|
return NULL;
|
|
}
|
|
memset(&DocInfoW, 0, sizeof(DOCINFOW));
|
|
if (pDocInfo->lpszDocName) {
|
|
DocInfoW.lpszDocName = (LPCWSTR)AllocateUnicodeString ((LPSTR)pDocInfo->lpszDocName);
|
|
if (pDocInfo->lpszDocName && !DocInfoW.lpszDocName)
|
|
return NULL;
|
|
}
|
|
if (pDocInfo->lpszOutput) {
|
|
DocInfoW.lpszOutput = (LPCWSTR)AllocateUnicodeString((LPSTR)pDocInfo->lpszOutput);
|
|
if (pDocInfo->lpszOutput && !DocInfoW.lpszOutput) {
|
|
FreeUnicodeString((LPWSTR) DocInfoW.lpszDocName);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
lpszUnicodeString = StartDocDlgW(hPrinter, &DocInfoW);
|
|
|
|
if (lpszUnicodeString == (LPWSTR)-1) {
|
|
lpszAnsiString = (LPSTR)-1;
|
|
} else if (lpszUnicodeString == (LPWSTR)-2) {
|
|
lpszAnsiString = (LPSTR)-2;
|
|
} else if (lpszUnicodeString){
|
|
dwLen = wcslen(lpszUnicodeString);
|
|
if (lpszAnsiString = LocalAlloc(LPTR, dwLen+1)){
|
|
UnicodeToAnsiString(lpszUnicodeString, lpszAnsiString, dwLen);
|
|
LocalFree(lpszUnicodeString);
|
|
} else {
|
|
DBGMSG(DBG_WARNING, ("StartDocDlgA: LocalAlloc failed returning NULL\n"));
|
|
}
|
|
}
|
|
|
|
if (DocInfoW.lpszDocName ) {
|
|
FreeUnicodeString((LPWSTR)DocInfoW.lpszDocName);
|
|
}
|
|
|
|
if (DocInfoW.lpszOutput) {
|
|
|
|
//
|
|
// we might have changed the DocInfoW.lpszOutput as well
|
|
// for pooled printing; so reconstruct pDocInfo->lpszOutput
|
|
//
|
|
dwLen = wcslen(DocInfoW.lpszOutput);
|
|
UnicodeToAnsiString((LPWSTR)DocInfoW.lpszOutput, (LPSTR)pDocInfo->lpszOutput, dwLen);
|
|
|
|
FreeUnicodeString((LPWSTR)DocInfoW.lpszOutput);
|
|
}
|
|
|
|
return lpszAnsiString;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SetPortA(
|
|
LPSTR pszName,
|
|
LPSTR pszPortName,
|
|
DWORD dwLevel,
|
|
LPBYTE pPorts
|
|
)
|
|
{
|
|
LPBYTE pUnicodeStructure = NULL;
|
|
DWORD cbStruct;
|
|
PDWORD pOffsets = NULL;
|
|
LPWSTR pszUnicodeName = NULL;
|
|
LPWSTR pszUnicodePortName = NULL;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
switch (dwLevel) {
|
|
|
|
case 3:
|
|
pOffsets = PortInfo3Offsets;
|
|
cbStruct = sizeof(PORT_INFO_3);
|
|
break;
|
|
|
|
default:
|
|
SetLastError( ERROR_INVALID_LEVEL );
|
|
return FALSE;
|
|
}
|
|
|
|
pszUnicodeName = AllocateUnicodeString(pszName);
|
|
if (pszName && !pszUnicodeName)
|
|
goto Cleanup;
|
|
|
|
pszUnicodePortName = AllocateUnicodeString(pszPortName);
|
|
if (pszPortName && !pszUnicodePortName)
|
|
goto Cleanup;
|
|
|
|
pUnicodeStructure = AllocateUnicodeStructure(pPorts, cbStruct, pOffsets);
|
|
if (pPorts && !pUnicodeStructure)
|
|
goto Cleanup;
|
|
|
|
bRet = SetPortW(pszUnicodeName, pszUnicodePortName, dwLevel, pUnicodeStructure);
|
|
|
|
Cleanup:
|
|
|
|
FreeUnicodeStructure(pUnicodeStructure, pOffsets);
|
|
FreeUnicodeString(pszUnicodePortName);
|
|
FreeUnicodeString(pszUnicodeName);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsValidDevmodeA
|
|
|
|
Description:
|
|
|
|
Check to see whether the devmode passed is valid.
|
|
|
|
Arguments:
|
|
|
|
pDevmode - The devmode
|
|
DevmodeSize - The size of the buffer.
|
|
|
|
Return Value:
|
|
|
|
TRUE if succeeded.
|
|
|
|
--*/
|
|
BOOL
|
|
IsValidDevmodeA(
|
|
IN PDEVMODEA pDevmode,
|
|
IN size_t DevmodeSize
|
|
)
|
|
{
|
|
return BoolFromHResult(SplIsValidDevmodeA(pDevmode, DevmodeSize));
|
|
}
|
|
|
|
/********************************************************************
|
|
|
|
Ansi version entry points for the default printer api set.
|
|
|
|
********************************************************************/
|
|
BOOL
|
|
GetDefaultPrinterA(
|
|
IN LPSTR pszBuffer,
|
|
IN LPDWORD pcchBuffer
|
|
)
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
LPWSTR pszUnicodeBuffer = NULL;
|
|
LPDWORD pcchUnicodeBuffer = pcchBuffer;
|
|
|
|
if( pszBuffer && pcchBuffer && *pcchBuffer )
|
|
{
|
|
pszUnicodeBuffer = LocalAlloc( LMEM_FIXED, *pcchBuffer * sizeof( WCHAR ) );
|
|
|
|
bRetval = pszUnicodeBuffer ? TRUE : FALSE;
|
|
}
|
|
|
|
if( bRetval )
|
|
{
|
|
bRetval = GetDefaultPrinterW( pszUnicodeBuffer, pcchUnicodeBuffer );
|
|
|
|
if( bRetval && pszUnicodeBuffer )
|
|
{
|
|
bRetval = UnicodeToAnsiString( pszUnicodeBuffer, pszBuffer, 0 ) > 0;
|
|
}
|
|
}
|
|
|
|
if( pszUnicodeBuffer )
|
|
{
|
|
LocalFree( pszUnicodeBuffer );
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
BOOL
|
|
SetDefaultPrinterA(
|
|
IN LPCSTR pszPrinter
|
|
)
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
LPWSTR pszUnicode = NULL;
|
|
|
|
if( pszPrinter )
|
|
{
|
|
pszUnicode = AllocateUnicodeString( (PSTR) pszPrinter );
|
|
|
|
bRetval = pszUnicode ? TRUE : FALSE;
|
|
}
|
|
|
|
if( bRetval )
|
|
{
|
|
bRetval = SetDefaultPrinterW( pszUnicode );
|
|
}
|
|
|
|
if( pszUnicode )
|
|
{
|
|
FreeUnicodeString( pszUnicode );
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PublishPrinterA(
|
|
HWND hwnd,
|
|
PCSTR pszUNCName,
|
|
PCSTR pszDN,
|
|
PCSTR pszCN,
|
|
PSTR *ppszDN,
|
|
DWORD dwAction
|
|
)
|
|
{
|
|
PWSTR pszUnicodeUNCName = NULL;
|
|
PWSTR pszUnicodeDN = NULL;
|
|
PWSTR pszUnicodeCN = NULL;
|
|
BOOL bRet = FALSE;
|
|
|
|
pszUnicodeUNCName = AllocateUnicodeString((PSTR) pszUNCName);
|
|
if (pszUNCName && !pszUnicodeUNCName)
|
|
goto error;
|
|
|
|
pszUnicodeDN = AllocateUnicodeString((PSTR) pszDN);
|
|
if (pszDN && !pszUnicodeDN)
|
|
goto error;
|
|
|
|
pszUnicodeCN = AllocateUnicodeString((PSTR) pszCN);
|
|
if (pszCN && !pszUnicodeCN)
|
|
goto error;
|
|
|
|
bRet = PublishPrinterW( hwnd,
|
|
pszUnicodeUNCName,
|
|
pszUnicodeDN,
|
|
pszUnicodeCN,
|
|
(PWSTR *) ppszDN,
|
|
dwAction);
|
|
|
|
if (ppszDN && *ppszDN) {
|
|
if (!UnicodeToAnsiString((PWSTR) *ppszDN, *ppszDN, NULL_TERMINATED))
|
|
bRet = FALSE;
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
FreeUnicodeString(pszUnicodeUNCName);
|
|
FreeUnicodeString(pszUnicodeDN);
|
|
FreeUnicodeString(pszUnicodeCN);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
ValidatePaperFields(
|
|
LPCWSTR pUnicodeDeviceName,
|
|
LPCWSTR pUnicodePort,
|
|
LPDEVMODEW pDevModeIn
|
|
)
|
|
{
|
|
POINTS ptMinSize, ptMaxSize;
|
|
|
|
|
|
if(!pUnicodeDeviceName ||
|
|
!pUnicodeDeviceName[0] ||
|
|
!pUnicodePort ||
|
|
!pUnicodePort[0] ||
|
|
!pDevModeIn) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// this logic was swiped from the MergeDevMode() code for the Win3.1 UNIDRV
|
|
//
|
|
// According to UNIDRV, dmPaperSize must be set to DMPAPER_USER if custom
|
|
// paper sizes are going to be taken seriously.
|
|
//
|
|
if((pDevModeIn->dmPaperSize == DMPAPER_USER) &&
|
|
(pDevModeIn->dmFields & DM_PAPERWIDTH) &&
|
|
(pDevModeIn->dmFields & DM_PAPERLENGTH)) {
|
|
|
|
pDevModeIn->dmFields |= (DM_PAPERLENGTH | DM_PAPERLENGTH);
|
|
|
|
//
|
|
// Get the minimum size this printer supports
|
|
//
|
|
if(DeviceCapabilitiesW(pUnicodeDeviceName,
|
|
pUnicodePort,
|
|
DC_MINEXTENT,
|
|
(PWSTR) &ptMinSize,
|
|
NULL) == -1) {
|
|
//
|
|
// No changes.
|
|
//
|
|
return;
|
|
}
|
|
|
|
if(DeviceCapabilitiesW(pUnicodeDeviceName,
|
|
pUnicodePort,
|
|
DC_MAXEXTENT,
|
|
(PWSTR) &ptMaxSize,
|
|
NULL) == -1) {
|
|
//
|
|
// No changes.
|
|
//
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Force the custom paper size to fit the machine's capabilities
|
|
//
|
|
if(pDevModeIn->dmPaperWidth < ptMinSize.x)
|
|
pDevModeIn->dmPaperWidth = ptMinSize.x;
|
|
else if(pDevModeIn->dmPaperWidth > ptMaxSize.x)
|
|
pDevModeIn->dmPaperWidth = ptMaxSize.x;
|
|
|
|
if(pDevModeIn->dmPaperLength < ptMinSize.y)
|
|
pDevModeIn->dmPaperLength = ptMinSize.y;
|
|
else if(pDevModeIn->dmPaperLength > ptMaxSize.y)
|
|
pDevModeIn->dmPaperLength = ptMaxSize.y;
|
|
|
|
}
|
|
//
|
|
// Else if they don't have it right, turn these guys off so they don't
|
|
// get merged into the default devmode later.
|
|
//
|
|
else {
|
|
pDevModeIn->dmFields &= ~(DM_PAPERLENGTH | DM_PAPERWIDTH);
|
|
pDevModeIn->dmPaperWidth = 0;
|
|
pDevModeIn->dmPaperLength = 0;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
UnicodeToAnsi(
|
|
IN LPBYTE pUnicode,
|
|
IN DWORD cchUnicode,
|
|
IN OUT LPBYTE pData,
|
|
IN DWORD cbData,
|
|
IN OUT DWORD *pcbCopied OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
UnicodeToAnsi
|
|
|
|
Routine Description:
|
|
|
|
Converts the content of a buffer from unicode to ansi. There is no assumption about
|
|
NULL terminator. If pUnicode is not NULL, then it must be WCHAR aligned and cchUnicode
|
|
indicates the number of WCHARs in the buffer that will be converted to ansi. If pUnicode
|
|
is NULL, then the function converts in place the contents of pData from Unicode to Ansi.
|
|
|
|
Arguments:
|
|
|
|
pUnicode - buffer aligned to WCHAR that contains a unicode string
|
|
cchUnicode - number of WCHARs in pUnicode buffer
|
|
pData - buffer that will hold the converted string
|
|
cbData - sizeo in bytes of the buffer pDa
|
|
pcbCopied - number of bytes copied to pData or needed to accomodate the converted string
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
DWORD cReturn = cbData;
|
|
DWORD cbCopied = 0;
|
|
DWORD Error = ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// If the size of both input buffer is 0, then we do not do anything and return success.
|
|
// Otherwise, the caller must give us either valid pData or a valid pUnicode that is
|
|
// WCHAR aligned
|
|
//
|
|
if (!cbData && !cchUnicode)
|
|
{
|
|
Error = ERROR_SUCCESS;
|
|
}
|
|
else if (pData || pUnicode && !((ULONG_PTR)pUnicode % sizeof(WCHAR)))
|
|
{
|
|
LPWSTR pAligned = (LPWSTR)pUnicode;
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
if (!pAligned)
|
|
{
|
|
//
|
|
// We convert contents of pData from unicode to ansi
|
|
//
|
|
if (pAligned = LocalAlloc(LPTR, cbData))
|
|
{
|
|
memcpy(pAligned, pData, cbData);
|
|
|
|
cchUnicode = cbData / sizeof(WCHAR);
|
|
}
|
|
else
|
|
{
|
|
Error = GetLastError();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Convert data to ansi or find out how many bytes are
|
|
// necessary to accomodate the string
|
|
//
|
|
if (Error == ERROR_SUCCESS)
|
|
{
|
|
cbCopied = WideCharToMultiByte(CP_THREAD_ACP,
|
|
0,
|
|
pAligned,
|
|
cchUnicode,
|
|
pData,
|
|
cbData,
|
|
NULL,
|
|
NULL);
|
|
|
|
//
|
|
// WideCharToMultiByte tells us how many bytes we need
|
|
//
|
|
if (!cbCopied)
|
|
{
|
|
Error = ERROR_MORE_DATA;
|
|
|
|
cbCopied = WideCharToMultiByte(CP_THREAD_ACP,
|
|
0,
|
|
pAligned,
|
|
cchUnicode,
|
|
pData,
|
|
0,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
else if (!cbData)
|
|
{
|
|
Error = ERROR_MORE_DATA;
|
|
}
|
|
|
|
if (pAligned != (LPWSTR)pUnicode)
|
|
{
|
|
LocalFree(pAligned);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pcbCopied)
|
|
{
|
|
*pcbCopied = cbCopied;
|
|
}
|
|
|
|
return Error;
|
|
}
|