1638 lines
39 KiB
C
1638 lines
39 KiB
C
/*++
|
|
|
|
Copyright (c) 1990 - 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
util.c
|
|
|
|
Abstract:
|
|
|
|
This module provides all the utility functions for the Routing Layer and
|
|
the local Print Providor
|
|
|
|
Author:
|
|
|
|
Dave Snipp (DaveSn) 15-Mar-1991
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#define NOMINMAX
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <winsock2.h>
|
|
#include <ws2tcpip.h>
|
|
#include <dsrole.h>
|
|
#include <commctrl.h>
|
|
#include <winddiui.h>
|
|
#include <winspool.h>
|
|
#include <w32types.h>
|
|
#include <local.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <splcom.h>
|
|
#include <splapip.h>
|
|
#include <offsets.h>
|
|
|
|
MODULE_DEBUG_INIT( DBG_ERROR, DBG_ERROR );
|
|
|
|
// used to break infinite loop in ConvertDevMode
|
|
LPCWSTR pszCnvrtdmToken = L",DEVMODE";
|
|
LPCWSTR pszDrvConvert = L",DrvConvert";
|
|
|
|
DWORD
|
|
Win32IsOlderThan(
|
|
DWORD i,
|
|
DWORD j
|
|
);
|
|
|
|
|
|
VOID
|
|
SplInSem(
|
|
VOID
|
|
)
|
|
{
|
|
if (SpoolerSection.OwningThread != (HANDLE) ULongToPtr(GetCurrentThreadId())) {
|
|
DBGMSG(DBG_ERROR, ("Not in spooler semaphore\n"));
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SplOutSem(
|
|
VOID
|
|
)
|
|
{
|
|
if (SpoolerSection.OwningThread == (HANDLE) ULongToPtr(GetCurrentThreadId())) {
|
|
DBGMSG(DBG_ERROR, ("Inside spooler semaphore !!\n"));
|
|
}
|
|
}
|
|
|
|
|
|
#if DBG
|
|
DWORD dwLeave = 0;
|
|
DWORD dwEnter = 0;
|
|
#endif
|
|
|
|
VOID
|
|
EnterSplSem(
|
|
VOID
|
|
)
|
|
{
|
|
#if DBG
|
|
LPDWORD pRetAddr;
|
|
#endif
|
|
EnterCriticalSection(&SpoolerSection);
|
|
#if i386
|
|
#if DBG
|
|
pRetAddr = (LPDWORD)&pRetAddr;
|
|
pRetAddr++;
|
|
pRetAddr++;
|
|
dwEnter = *pRetAddr;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
VOID
|
|
LeaveSplSem(
|
|
VOID
|
|
)
|
|
{
|
|
#if i386
|
|
#if DBG
|
|
LPDWORD pRetAddr;
|
|
pRetAddr = (LPDWORD)&pRetAddr;
|
|
pRetAddr++;
|
|
pRetAddr++;
|
|
dwLeave = *pRetAddr;
|
|
#endif
|
|
#endif
|
|
SplInSem();
|
|
LeaveCriticalSection(&SpoolerSection);
|
|
}
|
|
|
|
|
|
PWINIPORT
|
|
FindPort(
|
|
LPWSTR pName,
|
|
PWINIPORT pFirstPort
|
|
)
|
|
{
|
|
PWINIPORT pIniPort;
|
|
|
|
pIniPort = pFirstPort;
|
|
|
|
if (pName) {
|
|
while (pIniPort) {
|
|
|
|
if (!lstrcmpi( pIniPort->pName, pName )) {
|
|
return pIniPort;
|
|
}
|
|
|
|
pIniPort=pIniPort->pNext;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
MyName(
|
|
LPWSTR pName
|
|
)
|
|
{
|
|
if (!pName || !*pName)
|
|
return TRUE;
|
|
|
|
if (*pName == L'\\' && *(pName+1) == L'\\')
|
|
if (!lstrcmpi(pName, szMachineName))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Determines whether or not a machine name contains the local machine name.
|
|
|
|
Localspl enum calls fail if pName != local machine name (\\Machine).
|
|
Remote enum provider is then called. The remote enum provider must check
|
|
if the UNC name refers to the local machine, and fail if it does to avoid
|
|
endless recursion.
|
|
|
|
Arguments:
|
|
|
|
LPWSTR pName - UNC name.
|
|
|
|
Return Value:
|
|
|
|
TRUE: pName == \\szMachineName\...
|
|
- or -
|
|
pName == \\szMachineName
|
|
|
|
FALSE: anything else
|
|
|
|
Author: swilson
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
CheckMyName(
|
|
PWSTR pNameStart
|
|
)
|
|
{
|
|
PWCHAR pMachine;
|
|
LPWSTR pName;
|
|
DWORD i;
|
|
|
|
SplInSem();
|
|
|
|
if (VALIDATE_NAME(pNameStart)) {
|
|
for (i = 0 , pName = pNameStart + 2 ; i < gcOtherNames ; ++i , pName = pNameStart + 2) {
|
|
for(pMachine = gppszOtherNames[i] ;
|
|
*pName && towupper(*pName) == towupper(*pMachine) ;
|
|
++pName, ++pMachine)
|
|
;
|
|
|
|
if(!*pMachine && (!*pName || *pName == L'\\'))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
RefreshMachineNamesCache(
|
|
)
|
|
{
|
|
PWSTR *ppszOtherNames;
|
|
DWORD cOtherNames;
|
|
|
|
SplInSem();
|
|
|
|
//
|
|
// Get other machine names first. Only if it succeeds do we replace the cache.
|
|
//
|
|
if (!BuildOtherNamesFromMachineName(&ppszOtherNames, &cOtherNames))
|
|
return FALSE;
|
|
|
|
FreeOtherNames(&gppszOtherNames, &gcOtherNames);
|
|
gppszOtherNames = ppszOtherNames;
|
|
gcOtherNames = cOtherNames;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
MachineNameHasDot(
|
|
PWSTR pName
|
|
)
|
|
{
|
|
PWSTR psz;
|
|
|
|
if (!VALIDATE_NAME(pName))
|
|
return FALSE;
|
|
|
|
//
|
|
// pName may be \\Server or \\Server\Printer and we only care about the Server
|
|
//
|
|
for (psz = pName + 2 ; *psz && *psz != L'\\' ; ++psz)
|
|
{
|
|
if (*psz == L'.')
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
MyUNCName(
|
|
PWSTR pName
|
|
)
|
|
{
|
|
BOOL bRet;
|
|
|
|
EnterSplSem();
|
|
|
|
if (!(bRet = CheckMyName(pName)) && MachineNameHasDot(pName) && RefreshMachineNamesCache())
|
|
{
|
|
bRet = CheckMyName(pName);
|
|
}
|
|
|
|
LeaveSplSem();
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
#define MAX_CACHE_ENTRIES 20
|
|
|
|
LMCACHE LMCacheTable[MAX_CACHE_ENTRIES];
|
|
|
|
|
|
DWORD
|
|
FindEntryinLMCache(
|
|
LPWSTR pServerName,
|
|
LPWSTR pShareName
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
DBGMSG(DBG_TRACE, ("FindEntryinLMCache with %ws and %ws\n", pServerName, pShareName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
|
|
if (LMCacheTable[i].bAvailable) {
|
|
if (!_wcsicmp(LMCacheTable[i].szServerName, pServerName)
|
|
&& !_wcsicmp(LMCacheTable[i].szShareName, pShareName)) {
|
|
//
|
|
// update the time stamp so that it is current and not old
|
|
//
|
|
GetSystemTime(&LMCacheTable[i].st);
|
|
|
|
//
|
|
//
|
|
//
|
|
DBGMSG(DBG_TRACE, ("FindEntryinLMCache returning with %d\n", i));
|
|
return(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
DBGMSG(DBG_TRACE, ("FindEntryinLMCache returning with -1\n"));
|
|
return((DWORD)-1);
|
|
}
|
|
|
|
|
|
DWORD
|
|
AddEntrytoLMCache(
|
|
LPWSTR pServerName,
|
|
LPWSTR pShareName
|
|
)
|
|
{
|
|
|
|
DWORD LRUEntry = (DWORD)-1;
|
|
DWORD i;
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoLMCache with %ws and %ws\n", pServerName, pShareName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
|
|
if (!LMCacheTable[i].bAvailable) {
|
|
LMCacheTable[i].bAvailable = TRUE;
|
|
wcscpy(LMCacheTable[i].szServerName, pServerName);
|
|
wcscpy(LMCacheTable[i]. szShareName, pShareName);
|
|
//
|
|
// update the time stamp so that we know when this entry was made
|
|
//
|
|
GetSystemTime(&LMCacheTable[i].st);
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoLMCache returning with %d\n", i));
|
|
return(i);
|
|
} else {
|
|
if ((LRUEntry == (DWORD)-1) ||
|
|
(i == IsOlderThan(i, LRUEntry))){
|
|
LRUEntry = i;
|
|
}
|
|
}
|
|
|
|
}
|
|
//
|
|
// We have no available entries, replace with the
|
|
// LRU Entry
|
|
|
|
LMCacheTable[LRUEntry].bAvailable = TRUE;
|
|
wcscpy(LMCacheTable[LRUEntry].szServerName, pServerName);
|
|
wcscpy(LMCacheTable[LRUEntry].szShareName, pShareName);
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoLMCache returning with %d\n", LRUEntry));
|
|
return(LRUEntry);
|
|
}
|
|
|
|
|
|
VOID
|
|
DeleteEntryfromLMCache(
|
|
LPWSTR pServerName,
|
|
LPWSTR pShareName
|
|
)
|
|
{
|
|
DWORD i;
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromLMCache with %ws and %ws\n", pServerName, pShareName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
if (LMCacheTable[i].bAvailable) {
|
|
if (!_wcsicmp(LMCacheTable[i].szServerName, pServerName)
|
|
&& !_wcsicmp(LMCacheTable[i].szShareName, pShareName)) {
|
|
//
|
|
// reset the available flag on this node
|
|
//
|
|
|
|
LMCacheTable[i].bAvailable = FALSE;
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromLMCache returning after deleting the %d th entry\n", i));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromLMCache returning after not finding an entry to delete\n"));
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
IsOlderThan(
|
|
DWORD i,
|
|
DWORD j
|
|
)
|
|
{
|
|
SYSTEMTIME *pi, *pj;
|
|
DWORD iMs, jMs;
|
|
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan entering with i %d j %d\n", i, j));
|
|
pi = &(LMCacheTable[i].st);
|
|
pj = &(LMCacheTable[j].st);
|
|
DBGMSG(DBG_TRACE, ("Index i %d - %d:%d:%d:%d:%d:%d:%d\n",
|
|
i, pi->wYear, pi->wMonth, pi->wDay, pi->wHour, pi->wMinute, pi->wSecond, pi->wMilliseconds));
|
|
|
|
|
|
DBGMSG(DBG_TRACE,("Index j %d - %d:%d:%d:%d:%d:%d:%d\n",
|
|
j, pj->wYear, pj->wMonth, pj->wDay, pj->wHour, pj->wMinute, pj->wSecond, pj->wMilliseconds));
|
|
|
|
if (pi->wYear < pj->wYear) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wYear > pj->wYear) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan than returns %d\n", j));
|
|
return(j);
|
|
} else if (pi->wMonth < pj->wMonth) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wMonth > pj->wMonth) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan than returns %d\n", j));
|
|
return(j);
|
|
} else if (pi->wDay < pj->wDay) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wDay > pj->wDay) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan than returns %d\n", j));
|
|
return(j);
|
|
} else {
|
|
iMs = ((((pi->wHour * 60) + pi->wMinute)*60) + pi->wSecond)* 1000 + pi->wMilliseconds;
|
|
jMs = ((((pj->wHour * 60) + pj->wMinute)*60) + pj->wSecond)* 1000 + pj->wMilliseconds;
|
|
|
|
if (iMs <= jMs) {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else {
|
|
DBGMSG(DBG_TRACE, ("IsOlderThan than returns %d\n", j));
|
|
return(j);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
WIN32LMCACHE Win32LMCacheTable[MAX_CACHE_ENTRIES];
|
|
|
|
DWORD
|
|
FindEntryinWin32LMCache(
|
|
LPWSTR pServerName
|
|
)
|
|
{
|
|
DWORD i;
|
|
DBGMSG(DBG_TRACE, ("FindEntryinWin32LMCache with %ws\n", pServerName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
|
|
if (Win32LMCacheTable[i].bAvailable) {
|
|
if (!_wcsicmp(Win32LMCacheTable[i].szServerName, pServerName)) {
|
|
//
|
|
// update the time stamp so that it is current and not old
|
|
//
|
|
GetSystemTime(&Win32LMCacheTable[i].st);
|
|
|
|
//
|
|
//
|
|
//
|
|
DBGMSG(DBG_TRACE, ("FindEntryinWin32LMCache returning with %d\n", i));
|
|
return(i);
|
|
}
|
|
}
|
|
}
|
|
DBGMSG(DBG_TRACE, ("FindEntryinWin32LMCache returning with -1\n"));
|
|
return((DWORD)-1);
|
|
}
|
|
|
|
|
|
DWORD
|
|
AddEntrytoWin32LMCache(
|
|
LPWSTR pServerName
|
|
)
|
|
{
|
|
|
|
DWORD LRUEntry = (DWORD)-1;
|
|
DWORD i;
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoWin32LMCache with %ws\n", pServerName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
|
|
if (!Win32LMCacheTable[i].bAvailable) {
|
|
Win32LMCacheTable[i].bAvailable = TRUE;
|
|
wcscpy(Win32LMCacheTable[i].szServerName, pServerName);
|
|
//
|
|
// update the time stamp so that we know when this entry was made
|
|
//
|
|
GetSystemTime(&Win32LMCacheTable[i].st);
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoWin32LMCache returning with %d\n", i));
|
|
return(i);
|
|
} else {
|
|
if ((LRUEntry == -1) ||
|
|
(i == Win32IsOlderThan(i, LRUEntry))){
|
|
LRUEntry = i;
|
|
}
|
|
}
|
|
|
|
}
|
|
//
|
|
// We have no available entries, replace with the
|
|
// LRU Entry
|
|
|
|
Win32LMCacheTable[LRUEntry].bAvailable = TRUE;
|
|
wcscpy(Win32LMCacheTable[LRUEntry].szServerName, pServerName);
|
|
DBGMSG(DBG_TRACE, ("AddEntrytoWin32LMCache returning with %d\n", LRUEntry));
|
|
return(LRUEntry);
|
|
}
|
|
|
|
|
|
VOID
|
|
DeleteEntryfromWin32LMCache(
|
|
LPWSTR pServerName
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromWin32LMCache with %ws\n", pServerName));
|
|
for (i = 0; i < MAX_CACHE_ENTRIES; i++ ) {
|
|
if (Win32LMCacheTable[i].bAvailable) {
|
|
if (!_wcsicmp(Win32LMCacheTable[i].szServerName, pServerName)) {
|
|
//
|
|
// reset the available flag on this node
|
|
//
|
|
|
|
Win32LMCacheTable[i].bAvailable = FALSE;
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromWin32LMCache returning after deleting the %d th entry\n", i));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
DBGMSG(DBG_TRACE, ("DeleteEntryFromWin32LMCache returning after not finding an entry to delete\n"));
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
Win32IsOlderThan(
|
|
DWORD i,
|
|
DWORD j
|
|
)
|
|
{
|
|
SYSTEMTIME *pi, *pj;
|
|
DWORD iMs, jMs;
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan entering with i %d j %d\n", i, j));
|
|
pi = &(Win32LMCacheTable[i].st);
|
|
pj = &(Win32LMCacheTable[j].st);
|
|
DBGMSG(DBG_TRACE, ("Index i %d - %d:%d:%d:%d:%d:%d:%d\n",
|
|
i, pi->wYear, pi->wMonth, pi->wDay, pi->wHour, pi->wMinute, pi->wSecond, pi->wMilliseconds));
|
|
|
|
|
|
DBGMSG(DBG_TRACE,("Index j %d - %d:%d:%d:%d:%d:%d:%d\n",
|
|
j, pj->wYear, pj->wMonth, pj->wDay, pj->wHour, pj->wMinute, pj->wSecond, pj->wMilliseconds));
|
|
|
|
if (pi->wYear < pj->wYear) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wYear > pj->wYear) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", j));
|
|
return(j);
|
|
} else if (pi->wMonth < pj->wMonth) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wMonth > pj->wMonth) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", j));
|
|
return(j);
|
|
} else if (pi->wDay < pj->wDay) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else if (pi->wDay > pj->wDay) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", j));
|
|
return(j);
|
|
} else {
|
|
iMs = ((((pi->wHour * 60) + pi->wMinute)*60) + pi->wSecond)* 1000 + pi->wMilliseconds;
|
|
jMs = ((((pj->wHour * 60) + pj->wMinute)*60) + pj->wSecond)* 1000 + pj->wMilliseconds;
|
|
|
|
if (iMs <= jMs) {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", i));
|
|
return(i);
|
|
} else {
|
|
DBGMSG(DBG_TRACE, ("Win32IsOlderThan returns %d\n", j));
|
|
return(j);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
GetSid(
|
|
PHANDLE phToken
|
|
)
|
|
{
|
|
if (!OpenThreadToken( GetCurrentThread(),
|
|
TOKEN_IMPERSONATE,
|
|
TRUE,
|
|
phToken)) {
|
|
|
|
DBGMSG(DBG_WARNING, ("OpenThreadToken failed: %d\n", GetLastError()));
|
|
return FALSE;
|
|
|
|
} else {
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
SetCurrentSid(
|
|
HANDLE hToken
|
|
)
|
|
{
|
|
#if DBG
|
|
WCHAR UserName[256];
|
|
DWORD cbUserName=256;
|
|
|
|
if( MODULE_DEBUG & DBG_TRACE )
|
|
GetUserName(UserName, &cbUserName);
|
|
|
|
DBGMSG(DBG_TRACE, ("SetCurrentSid BEFORE: user name is %ws\n", UserName));
|
|
#endif
|
|
|
|
NtSetInformationThread(NtCurrentThread(), ThreadImpersonationToken,
|
|
&hToken, sizeof(hToken));
|
|
|
|
#if DBG
|
|
cbUserName = 256;
|
|
|
|
if( MODULE_DEBUG & DBG_TRACE )
|
|
GetUserName(UserName, &cbUserName);
|
|
|
|
DBGMSG(DBG_TRACE, ("SetCurrentSid AFTER: user name is %ws\n", UserName));
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
ValidateW32SpoolHandle(
|
|
PWSPOOL pSpool
|
|
)
|
|
{
|
|
SplOutSem();
|
|
try {
|
|
if (!pSpool || (pSpool->signature != WSJ_SIGNATURE)) {
|
|
|
|
DBGMSG( DBG_TRACE, ("ValidateW32SpoolHandle error invalid handle %x\n", pSpool));
|
|
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return(FALSE);
|
|
}
|
|
return(TRUE);
|
|
} except (1) {
|
|
DBGMSG( DBG_TRACE, ("ValidateW32SpoolHandle error invalid handle %x\n", pSpool));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
ValidRawDatatype(
|
|
LPCWSTR pszDatatype
|
|
)
|
|
{
|
|
if( !pszDatatype || _wcsnicmp( pszDatatype, pszRaw, 3 )){
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
HANDLE
|
|
LoadDriverFiletoConvertDevmodeFromPSpool(
|
|
HANDLE hSplPrinter
|
|
)
|
|
/*++
|
|
Finds out full path to the driver file and creates a DEVMODECHG_INFO
|
|
(which does a LoadLibrary)
|
|
|
|
Arguments:
|
|
h : A cache handle
|
|
|
|
Return Value:
|
|
On succes a valid pointer, else NULL
|
|
--*/
|
|
{
|
|
LPBYTE pDriver = NULL;
|
|
LPWSTR pConfigFile;
|
|
HANDLE hDevModeChgInfo = NULL;
|
|
DWORD dwNeeded;
|
|
DWORD dwServerMajorVersion = 0, dwServerMinorVersion = 0;
|
|
|
|
if ( hSplPrinter == INVALID_HANDLE_VALUE ) {
|
|
|
|
SPLASSERT(hSplPrinter != INVALID_HANDLE_VALUE);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
SplGetPrinterDriverEx(hSplPrinter,
|
|
szEnvironment,
|
|
2,
|
|
NULL,
|
|
0,
|
|
&dwNeeded,
|
|
cThisMajorVersion,
|
|
cThisMinorVersion,
|
|
&dwServerMajorVersion,
|
|
&dwServerMinorVersion);
|
|
|
|
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
|
|
goto Cleanup;
|
|
|
|
pDriver = AllocSplMem(dwNeeded);
|
|
|
|
if ( !pDriver ||
|
|
!SplGetPrinterDriverEx(hSplPrinter,
|
|
szEnvironment,
|
|
2,
|
|
(LPBYTE)pDriver,
|
|
dwNeeded,
|
|
&dwNeeded,
|
|
cThisMajorVersion,
|
|
cThisMinorVersion,
|
|
&dwServerMajorVersion,
|
|
&dwServerMinorVersion) )
|
|
goto Cleanup;
|
|
|
|
pConfigFile = ((LPDRIVER_INFO_2)pDriver)->pConfigFile;
|
|
hDevModeChgInfo = LoadDriverFiletoConvertDevmode(pConfigFile);
|
|
|
|
Cleanup:
|
|
|
|
if ( pDriver )
|
|
FreeSplMem(pDriver);
|
|
|
|
return hDevModeChgInfo;
|
|
}
|
|
|
|
BOOL
|
|
DoDevModeConversionAndBuildNewPrinterInfo2(
|
|
IN LPPRINTER_INFO_2 pInPrinter2,
|
|
IN DWORD dwInSize,
|
|
IN OUT LPBYTE pOutBuf,
|
|
IN DWORD dwOutSize,
|
|
IN OUT LPDWORD pcbNeeded,
|
|
IN PWSPOOL pSpool
|
|
)
|
|
/*++
|
|
Calls driver to do a devmode conversion and builds a new printer info 2.
|
|
|
|
Devmode is put at the end and then strings are packed from there.
|
|
|
|
|
|
Arguments:
|
|
|
|
pInPrinter2 - Printer Info2 structure with devmode info
|
|
|
|
dwInSize - Number of characters needed to pack info in pInPrinter
|
|
(not necessarily the size of the input buffer)
|
|
|
|
dwOutSize - buffer size
|
|
|
|
pOutBuf - Buffer to do the operation
|
|
|
|
pcbNeeded - Amount of memory copied (in characters)
|
|
|
|
pSpool - Points to w32 handle
|
|
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
LPDEVMODE pNewDevMode = NULL, pCacheDevMode, pInDevMode;
|
|
DWORD dwDevModeSize, dwSecuritySize, dwNeeded = 0;
|
|
HANDLE hDevModeChgInfo = NULL;
|
|
|
|
LPWSTR SourceStrings[sizeof(PRINTER_INFO_2)/sizeof(LPWSTR)];
|
|
LPWSTR *pSourceStrings=SourceStrings;
|
|
LPDWORD pOffsets;
|
|
LPBYTE pEnd;
|
|
PWCACHEINIPRINTEREXTRA pExtraData;
|
|
|
|
LPWSTR pPrinterName = NULL;
|
|
|
|
VALIDATEW32HANDLE(pSpool);
|
|
|
|
pInDevMode = pInPrinter2->pDevMode;
|
|
|
|
if ( !pInDevMode || pSpool->hSplPrinter == INVALID_HANDLE_VALUE ) {
|
|
|
|
goto AfterDevModeConversion;
|
|
}
|
|
|
|
if ( !SplGetPrinterExtra(pSpool->hSplPrinter,
|
|
&(PBYTE)pExtraData) ) {
|
|
|
|
DBGMSG(DBG_ERROR,
|
|
("DoDevModeConversionAndBuildNewPrinterInfo2: SplGetPrinterExtra error %d\n",
|
|
GetLastError()));
|
|
goto AfterDevModeConversion;
|
|
}
|
|
|
|
//
|
|
// Only time we do not have to convert devmode is if the server is running
|
|
// same version NT and also we have a devmode which matches the server
|
|
// devmode in dmSize, dmDriverExtra, dmSpecVersion, and dmDriverVersion
|
|
//
|
|
pCacheDevMode = pExtraData->pPI2 ? pExtraData->pPI2->pDevMode : NULL;
|
|
if ( (pExtraData->dwServerVersion == gdwThisGetVersion ||
|
|
(pSpool->Status & WSPOOL_STATUS_CNVRTDEVMODE)) &&
|
|
pCacheDevMode &&
|
|
pInDevMode->dmSize == pCacheDevMode->dmSize &&
|
|
pInDevMode->dmDriverExtra == pCacheDevMode->dmDriverExtra &&
|
|
pInDevMode->dmSpecVersion == pCacheDevMode->dmSpecVersion &&
|
|
pInDevMode->dmDriverVersion == pCacheDevMode->dmDriverVersion ) {
|
|
|
|
dwDevModeSize = pInDevMode->dmSize + pInDevMode->dmDriverExtra;
|
|
dwNeeded = dwInSize;
|
|
if ( dwOutSize < dwNeeded ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Put DevMode at the end
|
|
//
|
|
pNewDevMode = (LPDEVMODE)(pOutBuf + dwOutSize - dwDevModeSize);
|
|
CopyMemory((LPBYTE)pNewDevMode,
|
|
(LPBYTE)pInDevMode,
|
|
dwDevModeSize);
|
|
goto AfterDevModeConversion;
|
|
}
|
|
|
|
|
|
hDevModeChgInfo = LoadDriverFiletoConvertDevmodeFromPSpool(pSpool->hSplPrinter);
|
|
|
|
if ( !hDevModeChgInfo )
|
|
goto AfterDevModeConversion;
|
|
|
|
dwDevModeSize = 0;
|
|
|
|
SPLASSERT( pSpool->pName != NULL );
|
|
|
|
//
|
|
// Append ,DEVMODE to end of pSpool->pName
|
|
//
|
|
pPrinterName = AllocSplMem((lstrlen(pSpool->pName) + lstrlen(pszCnvrtdmToken) + 1) * sizeof pPrinterName[0]);
|
|
if ( !pPrinterName )
|
|
goto Cleanup;
|
|
|
|
wcscpy(pPrinterName,pSpool->pName);
|
|
wcscat(pPrinterName,pszCnvrtdmToken);
|
|
|
|
//
|
|
// Findout size of default devmode
|
|
//
|
|
if ( ERROR_INSUFFICIENT_BUFFER != CallDrvDevModeConversion(hDevModeChgInfo,
|
|
pPrinterName,
|
|
NULL,
|
|
(LPBYTE *)&pNewDevMode,
|
|
&dwDevModeSize,
|
|
CDM_DRIVER_DEFAULT,
|
|
FALSE) )
|
|
goto AfterDevModeConversion;
|
|
|
|
//
|
|
// Findout size needed to have current version devmode
|
|
//
|
|
dwNeeded = dwInSize + dwDevModeSize - pInDevMode->dmSize
|
|
- pInDevMode->dmDriverExtra;
|
|
|
|
if ( dwOutSize < dwNeeded ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Put DevMode at the end
|
|
//
|
|
pNewDevMode = (LPDEVMODE)(pOutBuf + dwOutSize - dwDevModeSize);
|
|
|
|
//
|
|
// Get default devmode and then convert remote devmode to that format
|
|
//
|
|
if ( ERROR_SUCCESS != CallDrvDevModeConversion(hDevModeChgInfo,
|
|
pPrinterName,
|
|
NULL,
|
|
(LPBYTE *)&pNewDevMode,
|
|
&dwDevModeSize,
|
|
CDM_DRIVER_DEFAULT,
|
|
FALSE) ||
|
|
ERROR_SUCCESS != CallDrvDevModeConversion(hDevModeChgInfo,
|
|
pPrinterName,
|
|
(LPBYTE)pInDevMode,
|
|
(LPBYTE *)&pNewDevMode,
|
|
&dwDevModeSize,
|
|
CDM_CONVERT,
|
|
FALSE) ) {
|
|
|
|
pNewDevMode = NULL;
|
|
goto AfterDevModeConversion;
|
|
}
|
|
|
|
|
|
AfterDevModeConversion:
|
|
//
|
|
// At this point if pNewDevMode != NULL dev mode conversion has been done
|
|
// by the driver. If not either we did not get a devmode or conversion failed
|
|
// In either case set devmode to NULL
|
|
//
|
|
if ( !pNewDevMode ) {
|
|
|
|
dwNeeded = dwInSize;
|
|
|
|
if ( dwOutSize < dwNeeded ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
bReturn = TRUE;
|
|
|
|
CopyMemory(pOutBuf, (LPBYTE)pInPrinter2, sizeof(PRINTER_INFO_2));
|
|
((LPPRINTER_INFO_2)pOutBuf)->pDevMode = pNewDevMode;
|
|
|
|
pEnd = (pNewDevMode ? (LPBYTE) pNewDevMode
|
|
: (LPBYTE) (pOutBuf + dwOutSize));
|
|
|
|
|
|
if ( pInPrinter2->pSecurityDescriptor ) {
|
|
|
|
dwSecuritySize = GetSecurityDescriptorLength(
|
|
pInPrinter2->pSecurityDescriptor);
|
|
pEnd -= dwSecuritySize;
|
|
CopyMemory(pEnd, pInPrinter2->pSecurityDescriptor, dwSecuritySize);
|
|
((LPPRINTER_INFO_2)pOutBuf)->pSecurityDescriptor =
|
|
(PSECURITY_DESCRIPTOR) pEnd;
|
|
} else {
|
|
|
|
((LPPRINTER_INFO_2)pOutBuf)->pSecurityDescriptor = NULL;
|
|
|
|
}
|
|
|
|
pOffsets = PrinterInfo2Strings;
|
|
|
|
*pSourceStrings++ = pInPrinter2->pServerName;
|
|
*pSourceStrings++ = pInPrinter2->pPrinterName;
|
|
*pSourceStrings++ = pInPrinter2->pShareName;
|
|
*pSourceStrings++ = pInPrinter2->pPortName;
|
|
*pSourceStrings++ = pInPrinter2->pDriverName;
|
|
*pSourceStrings++ = pInPrinter2->pComment;
|
|
*pSourceStrings++ = pInPrinter2->pLocation;
|
|
*pSourceStrings++ = pInPrinter2->pSepFile;
|
|
*pSourceStrings++ = pInPrinter2->pPrintProcessor;
|
|
*pSourceStrings++ = pInPrinter2->pDatatype;
|
|
*pSourceStrings++ = pInPrinter2->pParameters;
|
|
|
|
pEnd = PackStrings(SourceStrings, (LPBYTE)pOutBuf, pOffsets, pEnd);
|
|
|
|
SPLASSERT(pEnd > pOutBuf && pEnd < pOutBuf + dwOutSize);
|
|
|
|
bReturn = TRUE;
|
|
|
|
Cleanup:
|
|
|
|
*pcbNeeded = dwNeeded;
|
|
|
|
if ( hDevModeChgInfo )
|
|
UnloadDriverFile(hDevModeChgInfo);
|
|
|
|
if (pPrinterName)
|
|
FreeSplMem(pPrinterName);
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
|
|
PWSTR
|
|
StripString(
|
|
PWSTR pszString,
|
|
PCWSTR pszStrip,
|
|
PCWSTR pszTerminator
|
|
)
|
|
{
|
|
//
|
|
// Strips the first occurence of pszStrip from pszString if
|
|
// the next character after pszStrip is one of the characters
|
|
// in pszTerminator. NULL is an implicit terminator, so if you
|
|
// want to strip pszStrip only at the end of pszString, just pass
|
|
// in an empty string for pszTerminator.
|
|
//
|
|
// Returns: Pointer to pszString if pszStrip was found
|
|
// NULL is pszStrip was not found
|
|
//
|
|
|
|
|
|
PWSTR psz;
|
|
DWORD dwStripLength;
|
|
|
|
if (!pszStrip || !pszString || !pszTerminator)
|
|
return NULL;
|
|
|
|
dwStripLength = wcslen(pszStrip);
|
|
|
|
for(psz = pszString ; psz ;) {
|
|
|
|
// find pszStrip in pszString
|
|
if ((psz = wcsstr(psz, pszStrip))) {
|
|
|
|
// check for the terminator & strip pszStrip
|
|
if (!*(psz + dwStripLength) || wcschr(pszTerminator, *(psz + dwStripLength))) {
|
|
wcscpy(psz, psz + dwStripLength);
|
|
return pszString;
|
|
} else {
|
|
++psz;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
AddDriverFromLocalCab(
|
|
LPTSTR pszDriverName,
|
|
LPHANDLE pIniSpooler
|
|
)
|
|
{
|
|
DRIVER_INFO_7 DriverInfo7;
|
|
|
|
if( GetPolicy() & SERVER_INSTALL_ONLY ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
DriverInfo7.cbSize = sizeof( DriverInfo7 );
|
|
DriverInfo7.cVersion = 0;
|
|
DriverInfo7.pszDriverName = pszDriverName;
|
|
DriverInfo7.pszInfName = NULL;
|
|
DriverInfo7.pszInstallSourceRoot = NULL;
|
|
|
|
return ( SplAddPrinterDriverEx( NULL,
|
|
7,
|
|
(LPBYTE)&DriverInfo7,
|
|
APD_COPY_NEW_FILES,
|
|
pIniSpooler,
|
|
DO_NOT_USE_SCRATCH_DIR,
|
|
FALSE ) );
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
IsAdminAccess
|
|
|
|
Description:
|
|
|
|
This returns whether the given printer defaults are asking for admin access,
|
|
we consider the request to be admin access if the printer defaults are
|
|
non-NULL and have PRINTER_ACCESS_ADMINISTER or WRITE_DAC specified.
|
|
|
|
Arguments:
|
|
|
|
pDefaults - The printer defaults, may be NULL.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
BOOL
|
|
IsAdminAccess(
|
|
IN PRINTER_DEFAULTS *pDefaults
|
|
)
|
|
{
|
|
return pDefaults && (pDefaults->DesiredAccess & (PRINTER_ACCESS_ADMINISTER | WRITE_DAC));
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
AreWeOnADomain
|
|
|
|
Description:
|
|
|
|
This returns whether this machine is a domain joined machine or not.
|
|
|
|
Arguments:
|
|
|
|
pbDomain - If TRUE, we are on a domain.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
AreWeOnADomain(
|
|
OUT BOOL *pbDomain
|
|
)
|
|
{
|
|
HRESULT hr = pbDomain ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pRoleInfo = NULL;
|
|
BOOL bOnDomain = FALSE;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HResultFromWin32(DsRoleGetPrimaryDomainInformation(NULL,
|
|
DsRolePrimaryDomainInfoBasic,
|
|
(BYTE **)(&pRoleInfo)));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bOnDomain = pRoleInfo->MachineRole == DsRole_RoleMemberWorkstation ||
|
|
pRoleInfo->MachineRole == DsRole_RoleMemberServer ||
|
|
pRoleInfo->MachineRole == DsRole_RoleBackupDomainController ||
|
|
pRoleInfo->MachineRole == DsRole_RolePrimaryDomainController;
|
|
}
|
|
|
|
if (pRoleInfo)
|
|
{
|
|
DsRoleFreeMemory((VOID *)pRoleInfo);
|
|
}
|
|
|
|
if (pbDomain)
|
|
{
|
|
*pbDomain = bOnDomain;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
GetServerNameFromQueue
|
|
|
|
Description:
|
|
|
|
This returns the server name from the given queue name.
|
|
|
|
Arguments:
|
|
|
|
pszQueue - The queue name,
|
|
ppszServerName - The server name.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
GetServerNameFromPrinterName(
|
|
IN PCWSTR pszQueue,
|
|
OUT PWSTR *ppszServerName
|
|
)
|
|
{
|
|
HRESULT hr = pszQueue && ppszServerName ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
PWSTR pszServer = NULL;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = *pszQueue++ == L'\\' && *pszQueue++ == L'\\' ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PRINTER_NAME);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pszServer = AllocSplStr(pszQueue);
|
|
|
|
hr = pszServer ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
PWSTR pszSlash = wcschr(&pszServer[2], L'\\');
|
|
|
|
//
|
|
// If there was no second slash, then what we have is the server name.
|
|
//
|
|
if (pszSlash)
|
|
{
|
|
*pszSlash = L'\0';
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppszServerName = pszServer;
|
|
pszServer = NULL;
|
|
}
|
|
|
|
FreeSplMem(pszServer);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
GetDNSNameFromServerName
|
|
|
|
Description:
|
|
|
|
This returns a fully qualified DNS name from the server name. It is
|
|
basically copied from localspl because this is dead-end code. In CSR,
|
|
we will fix this properly.
|
|
|
|
Arguments:
|
|
|
|
pszServerName - The server name whose fully qualified name we are obtaining.
|
|
ppszFullyQualified -
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
GetDNSNameFromServerName(
|
|
IN PCWSTR pszServerName,
|
|
OUT PWSTR *ppszFullyQualified
|
|
)
|
|
{
|
|
PSTR pszAnsiMachineName = NULL;
|
|
struct hostent *pHostEnt;
|
|
WORD wVersion;
|
|
WSADATA WSAData;
|
|
HRESULT hr = pszServerName && *pszServerName && ppszFullyQualified ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
|
|
|
|
PWSTR pszDummy = NULL;
|
|
GetFullyQualifiedDomainName(pszServerName, &pszDummy);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
wVersion = MAKEWORD(1, 1);
|
|
|
|
hr = HResultFromWin32(WSAStartup(wVersion, &WSAData));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = UnicodeToAnsiString(pszServerName, &pszAnsiMachineName);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pHostEnt = gethostbyname(pszAnsiMachineName);
|
|
|
|
hr = pHostEnt ? S_OK : HResultFromWin32(WSAGetLastError());
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppszFullyQualified = AnsiToUnicodeStringWithAlloc(pHostEnt->h_name);
|
|
|
|
hr = *ppszFullyQualified ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
|
|
}
|
|
|
|
WSACleanup();
|
|
}
|
|
|
|
FreeSplMem(pszAnsiMachineName);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
UnicodeToAnsiString
|
|
|
|
Routine Description:
|
|
|
|
This allocates an ANSI string and converts it using the thread's codepage.
|
|
|
|
Arguments:
|
|
|
|
pszUnicode - The incoming, non-NULL, NULL terminated unicode string.
|
|
ppszAnsi - The returned ANSI string.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT
|
|
|
|
--*/
|
|
HRESULT
|
|
UnicodeToAnsiString(
|
|
IN PCWSTR pszUnicode,
|
|
OUT PSTR *ppszAnsi
|
|
)
|
|
{
|
|
HRESULT hRetval = E_FAIL;
|
|
PSTR pszAnsi = NULL;
|
|
INT AnsiStringLength = 0;
|
|
|
|
hRetval = pszUnicode && ppszAnsi ? S_OK : E_INVALIDARG;
|
|
|
|
if (ppszAnsi)
|
|
{
|
|
*ppszAnsi = NULL;
|
|
}
|
|
|
|
if (SUCCEEDED(hRetval))
|
|
{
|
|
AnsiStringLength = WideCharToMultiByte(CP_THREAD_ACP, 0, pszUnicode, -1, NULL, 0, NULL, NULL);
|
|
|
|
hRetval = AnsiStringLength != 0 ? S_OK : GetLastErrorAsHResult();
|
|
}
|
|
|
|
if (SUCCEEDED(hRetval))
|
|
{
|
|
pszAnsi = AllocSplMem(AnsiStringLength);
|
|
|
|
hRetval = pszAnsi ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (SUCCEEDED(hRetval))
|
|
{
|
|
hRetval = WideCharToMultiByte(CP_THREAD_ACP, 0, pszUnicode, -1, pszAnsi, AnsiStringLength, NULL, NULL) != 0 ? S_OK : GetLastErrorAsHResult();
|
|
}
|
|
|
|
if (SUCCEEDED(hRetval))
|
|
{
|
|
*ppszAnsi = pszAnsi;
|
|
pszAnsi = NULL;
|
|
}
|
|
|
|
FreeSplMem(pszAnsi);
|
|
|
|
return hRetval;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
AnsiToUnicodeStringWithAlloc
|
|
|
|
Description:
|
|
|
|
Convert ANSI string to UNICODE. Routine allocates memory from the heap
|
|
which should be freed by the caller.
|
|
|
|
Arguments:
|
|
|
|
pAnsi - Points to the ANSI string
|
|
|
|
Return Value:
|
|
|
|
Pointer to UNICODE string
|
|
|
|
--*/
|
|
LPWSTR
|
|
AnsiToUnicodeStringWithAlloc(
|
|
LPSTR pAnsi
|
|
)
|
|
{
|
|
LPWSTR pUnicode;
|
|
DWORD rc;
|
|
|
|
rc = MultiByteToWideChar(CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
pAnsi,
|
|
-1,
|
|
NULL,
|
|
0);
|
|
|
|
rc *= sizeof(WCHAR);
|
|
if ( !rc || !(pUnicode = (LPWSTR) AllocSplMem(rc)) )
|
|
return NULL;
|
|
|
|
rc = MultiByteToWideChar(CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
pAnsi,
|
|
-1,
|
|
pUnicode,
|
|
rc);
|
|
|
|
if ( rc )
|
|
return pUnicode;
|
|
else {
|
|
FreeSplMem(pUnicode);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
CheckSamePhysicalAddress
|
|
|
|
Description:
|
|
|
|
This checks to see whether two servers share a same network address. What it
|
|
does is check to see whether the first physical network address of the first
|
|
print server can be found in the list of addresses supported by the second
|
|
print server.
|
|
|
|
Arguments:
|
|
|
|
pszServer1 - The first server in the list.
|
|
pszServer2 - The second server in the list.
|
|
pbSameAddress - If TRUE, the first physical address of server1 can be found
|
|
in server2.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
CheckSamePhysicalAddress(
|
|
IN PCWSTR pszServer1,
|
|
IN PCWSTR pszServer2,
|
|
OUT BOOL *pbSameAddress
|
|
)
|
|
{
|
|
BOOL bSameAddress = FALSE;
|
|
PSTR pszAnsiServer1 = NULL;
|
|
PSTR pszAnsiServer2 = NULL;
|
|
ADDRINFO *pAddrInfo1 = NULL;
|
|
ADDRINFO *pAddrInfo2 = NULL;
|
|
WSADATA WSAData;
|
|
WORD wVersion;
|
|
HRESULT hr = pszServer1 && pszServer2 && pbSameAddress ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
wVersion = MAKEWORD(1, 1);
|
|
|
|
hr = HResultFromWin32(WSAStartup(wVersion, &WSAData));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ADDRINFO *pAddrInfoScan = NULL;
|
|
|
|
hr = UnicodeToAnsiString(pszServer1, &pszAnsiServer1);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = UnicodeToAnsiString(pszServer2, &pszAnsiServer2);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = getaddrinfo(pszAnsiServer1, NULL, NULL, &pAddrInfo1) == 0 ? S_OK : HResultFromWin32(WSAGetLastError());
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = getaddrinfo(pszAnsiServer2, NULL, NULL, &pAddrInfo2) == 0 ? S_OK : HResultFromWin32(WSAGetLastError());
|
|
}
|
|
|
|
//
|
|
// OK, now for the hokey bit, we check to see whether we can exactly
|
|
// match the first element in pAddrInfo1 anywhere in pAddrInfo2.
|
|
//
|
|
for(pAddrInfoScan = pAddrInfo2; pAddrInfo2 && !bSameAddress; pAddrInfo2 = pAddrInfo2->ai_next)
|
|
{
|
|
//
|
|
// If the lengths of the addresses are the same, then compare the
|
|
// actual addresses.
|
|
//
|
|
if (pAddrInfoScan->ai_addrlen == pAddrInfo1->ai_addrlen &&
|
|
!memcmp(pAddrInfoScan->ai_addr, pAddrInfo1->ai_addr, pAddrInfoScan->ai_addrlen))
|
|
{
|
|
bSameAddress = TRUE;
|
|
}
|
|
}
|
|
|
|
freeaddrinfo(pAddrInfo1);
|
|
freeaddrinfo(pAddrInfo2);
|
|
|
|
WSACleanup();
|
|
}
|
|
|
|
if (pbSameAddress)
|
|
{
|
|
*pbSameAddress = bSameAddress;
|
|
}
|
|
|
|
FreeSplMem(pszAnsiServer1);
|
|
FreeSplMem(pszAnsiServer2);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
CheckUserPrintAdmin
|
|
|
|
Description:
|
|
|
|
This checks to see whether the given user is a print admin.
|
|
|
|
Arguments:
|
|
|
|
pbUserAdmin - If TRUE, the user is a print admin.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
CheckUserPrintAdmin(
|
|
OUT BOOL *pbUserAdmin
|
|
)
|
|
{
|
|
//
|
|
// Check to see whether the caller has access to the local print
|
|
// server, if we do have access, then we allow point and print.
|
|
//
|
|
HANDLE hServer = NULL;
|
|
PRINTER_DEFAULTS Defaults = {NULL, NULL, SERVER_ACCESS_ADMINISTER };
|
|
HRESULT hr = pbUserAdmin ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
|
|
//
|
|
// This actually calls into the router and not into winspool.drv.
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
}
|
|
hr = OpenPrinterW(NULL, &hServer, &Defaults) ? S_OK : GetLastErrorAsHResultAndFail();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pbUserAdmin = TRUE;
|
|
}
|
|
else if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
|
|
{
|
|
*pbUserAdmin = FALSE;
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (hServer)
|
|
{
|
|
ClosePrinter(hServer);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Name:
|
|
|
|
GetFullyQualifiedDomainName
|
|
|
|
Description:
|
|
|
|
This returns a truly fully qualified name, being the name that the endpoint
|
|
expects to use, or
|
|
|
|
Arguments:
|
|
|
|
pszServerName - The server name whose fully qualified name we are obtaining.
|
|
ppszFullyQualified - The returned fully qualified name.
|
|
|
|
Return Value:
|
|
|
|
An HRESULT.
|
|
|
|
--*/
|
|
HRESULT
|
|
GetFullyQualifiedDomainName(
|
|
IN PCWSTR pszServerName,
|
|
OUT PWSTR *ppszFullyQualified
|
|
)
|
|
{
|
|
WORD wVersion;
|
|
WSADATA WSAData;
|
|
PSTR pszAnsiMachineName = NULL;
|
|
HRESULT hr = pszServerName && *pszServerName && ppszFullyQualified ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
wVersion = MAKEWORD(1, 1);
|
|
|
|
hr = HResultFromWin32(WSAStartup(wVersion, &WSAData));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ADDRINFO *pAddrInfo = NULL;
|
|
CHAR HostName[NI_MAXHOST];
|
|
|
|
hr = UnicodeToAnsiString(pszServerName, &pszAnsiMachineName);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = getaddrinfo(pszAnsiMachineName, NULL, NULL, &pAddrInfo) == 0 ? S_OK : HResultFromWin32(WSAGetLastError());
|
|
}
|
|
|
|
//
|
|
// Now the we have a socket addr, do a reverse name lookup on the name.
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HResultFromWin32(getnameinfo(pAddrInfo->ai_addr, pAddrInfo->ai_addrlen, HostName, sizeof(HostName), NULL, 0, NI_NAMEREQD));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppszFullyQualified = AnsiToUnicodeStringWithAlloc(HostName);
|
|
|
|
hr = *ppszFullyQualified ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
|
|
}
|
|
|
|
if (pAddrInfo)
|
|
{
|
|
freeaddrinfo(pAddrInfo);
|
|
}
|
|
|
|
WSACleanup();
|
|
}
|
|
|
|
FreeSplMem(pszAnsiMachineName);
|
|
|
|
return hr;
|
|
}
|
|
|