|
|
/*++
Copyright (c) 1997 Microsoft Corporation
Abstract:
This module provides functionality for publishing printers
Author:
Steve Wilson (NT) November 1997
Revision History:
--*/#include "precomp.h"
#pragma hdrstop
#include "pubprn.hxx"
#include "varconv.hxx"
#include "property.hxx"
#include "dsutil.hxx"
#include "client.h"
#define PPM_FACTOR 48
BOOLPublishPrinterW( HWND hwnd, PCWSTR pszUNCName, PCWSTR pszDN, PCWSTR pszCN, PWSTR *ppszDN, DWORD dwAction){ PRINTER_DEFAULTS Defaults; HANDLE hPrinter = NULL; HANDLE hServer = NULL; PWSTR pszServerName = NULL; PWSTR pszPrinterName = NULL; PPRINTER_INFO_2 pInfo2 = NULL; DWORD dwRet = ERROR_SUCCESS; DWORD dwType; DWORD dwMajorVersion; DWORD dwDsPresent; DWORD cbNeeded; DWORD dwLength; HRESULT hr; WCHAR szDNSMachineName[INTERNET_MAX_HOST_NAME_LENGTH + 1]; WCHAR szFullUNCName[MAX_UNC_PRINTER_NAME]; WCHAR szShortServerName[MAX_PATH+1]; PWSTR pszFullUNCName; PWSTR pszShortServerName; PWSTR pszFullServerName;
if (InCSRProcess()) { SetLastError(ERROR_NOT_SUPPORTED); return FALSE; }
hr = CoInitialize(NULL); if (hr != S_OK && hr != S_FALSE) { SetLastError((DWORD)((HRESULT_FACILITY(hr) == FACILITY_WIN32) ? HRESULT_CODE(hr) : hr)); return FALSE; }
if (ppszDN) *ppszDN = NULL; //
// Get server name
//
if (dwRet = UNC2Server(pszUNCName, &pszServerName)) goto error;
if(!OpenPrinter(pszServerName, &hServer, NULL)) { dwMajorVersion = 0;
} else { dwRet = GetPrinterData( hServer, SPLREG_MAJOR_VERSION, &dwType, (PBYTE) &dwMajorVersion, sizeof dwMajorVersion, &cbNeeded); if (dwRet != ERROR_SUCCESS) { //
// ignore errors and assume lowest version
//
dwMajorVersion = 0; dwRet = ERROR_SUCCESS; }
if (dwMajorVersion >= WIN2000_SPOOLER_VERSION) {
hr = MachineIsInMyForest(pszServerName);
if (FAILED(hr)) { dwRet = HRESULT_CODE(hr); goto error; } else if(HRESULT_CODE(hr) == 1) { //
// Machine is in my forest and is NT5+
//
dwRet = ERROR_INVALID_LEVEL; goto error; } else { //
// Downgrade the version for NT5+ printers published in a non-DS domain
//
dwMajorVersion = WIN2000_SPOOLER_VERSION; } } }
Defaults.pDatatype = NULL; Defaults.pDevMode = NULL;
Defaults.DesiredAccess = PRINTER_ACCESS_USE;
if (!OpenPrinter((PWSTR) pszUNCName, &hPrinter, &Defaults)) { dwRet = GetLastError(); goto error; }
hr = GetPrinterInfo2(hPrinter, &pInfo2); if (FAILED(hr)) { dwRet = HRESULT_CODE(hr); goto error; }
if (dwRet = UNC2Printer(pInfo2->pPrinterName, &pszPrinterName)) goto error;
if( dwMajorVersion >= WIN2000_SPOOLER_VERSION){ if(dwRet = GetPrinterData( hServer, SPLREG_DNS_MACHINE_NAME, &dwType, (PBYTE) szDNSMachineName, (INTERNET_MAX_HOST_NAME_LENGTH + 1) * sizeof(WCHAR), &cbNeeded) != ERROR_SUCCESS ) { goto error; }
if (FAILED(hr = StringCchPrintf( szFullUNCName, COUNTOF(szFullUNCName), L"\\\\%s\\%s", szDNSMachineName, pszPrinterName ))) { dwRet = HRESULT_CODE(hr); goto error; }
dwLength = MAX_PATH + 1; if (!DnsHostnameToComputerName(pszServerName, szShortServerName, &dwLength)) { dwRet = GetLastError(); goto error; }
pszFullUNCName = szFullUNCName; pszFullServerName = szDNSMachineName; pszShortServerName = szShortServerName+2;
} else {
pszFullUNCName = (PWSTR)pszUNCName; pszFullServerName = pszServerName+2; pszShortServerName = pszServerName+2; }
//
// Verify PrintQueue doesn't already exist
//
if (dwAction != PUBLISHPRINTER_IGNORE_DUPLICATES) { if(dwRet = PrintQueueExists(hwnd, hPrinter, pszFullUNCName, dwAction, (PWSTR) pszDN, (PWSTR *) ppszDN)) goto error; }
if (dwRet = PublishDownlevelPrinter(hPrinter, (PWSTR) pszDN, (PWSTR) pszCN, pszFullServerName, pszShortServerName, pszFullUNCName, pszPrinterName, dwMajorVersion, ppszDN)) goto error;
error:
if (hPrinter != NULL) ClosePrinter(hPrinter);
if (hServer != NULL) ClosePrinter(hServer);
if (pszServerName) FreeSplMem(pszServerName);
if (pszPrinterName) FreeSplMem(pszPrinterName);
FreeSplMem(pInfo2);
if (dwRet != ERROR_SUCCESS) { SetLastError(dwRet); return FALSE; }
CoUninitialize();
return TRUE;}
DWORDPublishDownlevelPrinter( HANDLE hPrinter, PWSTR pszDN, PWSTR pszCN, PWSTR pszServerName, PWSTR pszShortServerName, PWSTR pszUNCName, PWSTR pszPrinterName, DWORD dwVersion, PWSTR *ppszObjectDN){ HRESULT hr = S_OK; DWORD dwRet = ERROR_SUCCESS; IADs *pPrintQueue = NULL; IADsContainer *pADsContainer = NULL; IDispatch *pDispatch = NULL; PWSTR pszCommonName = pszCN; BSTR bstrADsPath = NULL; PWSTR pszDNWithDC = NULL;
if (ppszObjectDN) *ppszObjectDN = NULL; //
// If pszCN is not supplied, generate default common name
//
if (!pszCommonName || !*pszCommonName) { dwRet = GetCommonName(hPrinter, &pszCommonName); if (dwRet != ERROR_SUCCESS) { hr = dw2hr(dwRet); BAIL_ON_FAILURE(hr); } }
//
// Stick DC in DN
//
if (!(pszDNWithDC = GetDNWithServer(pszDN))) { pszDNWithDC = pszDN; }
//
// Get container
//
hr = ADsGetObject(pszDNWithDC, IID_IADsContainer, (void **) &pADsContainer); BAIL_ON_FAILURE(hr);
//
// Create printqueue
//
hr = pADsContainer->Create(SPLDS_PRINTER_CLASS, pszCommonName, &pDispatch); BAIL_ON_FAILURE(hr);
hr = pDispatch->QueryInterface(IID_IADs, (void **) &pPrintQueue); BAIL_ON_FAILURE(hr);
//
// Set properties
//
hr = SetProperties( hPrinter, pszServerName, pszShortServerName, pszUNCName, pszPrinterName, dwVersion, pPrintQueue); BAIL_ON_FAILURE(hr);
//
// Get ADsPath to printQueue
//
if (ppszObjectDN) { hr = pPrintQueue->get_ADsPath(&bstrADsPath); BAIL_ON_FAILURE(hr);
if (!(*ppszObjectDN = AllocGlobalStr(bstrADsPath))) { dwRet = GetLastError(); hr = dw2hr(dwRet); BAIL_ON_FAILURE(hr); } }
error:
if (pszDNWithDC != pszDN) FreeSplMem(pszDNWithDC);
if (bstrADsPath) SysFreeString(bstrADsPath);
if (pszCommonName != pszCN) FreeSplMem(pszCommonName);
if (pADsContainer) pADsContainer->Release();
if (pDispatch) pDispatch->Release();
if (pPrintQueue) pPrintQueue->Release();
if (FAILED(hr) && ppszObjectDN && *ppszObjectDN) FreeGlobalStr(*ppszObjectDN);
return hr2dw(hr);}
HRESULTSetProperties( HANDLE hPrinter, PWSTR pszServerName, PWSTR pszShortServerName, PWSTR pszUNCName, PWSTR pszPrinterName, DWORD dwVersion, IADs *pPrintQueue){ HRESULT hr;
hr = SetMandatoryProperties(pszServerName, pszShortServerName, pszUNCName, pszPrinterName, dwVersion, pPrintQueue); BAIL_ON_FAILURE(hr);
SetSpoolerProperties(hPrinter, pPrintQueue, dwVersion); SetDriverProperties(hPrinter, pPrintQueue);
error:
return hr;}
HRESULTSetMandatoryProperties( PWSTR pszServerName, PWSTR pszShortServerName, PWSTR pszUNCName, PWSTR pszPrinterName, DWORD dwVersion, IADs *pPrintQueue){ HRESULT hr; //
// ServerName
//
hr = put_BSTR_Property(pPrintQueue, SPLDS_SERVER_NAME, pszServerName); BAIL_ON_FAILURE(hr);
//
// ShortServerName
//
hr = put_BSTR_Property(pPrintQueue, SPLDS_SHORT_SERVER_NAME, pszShortServerName); BAIL_ON_FAILURE(hr);
//
// UNC Name
//
hr = put_BSTR_Property(pPrintQueue, SPLDS_UNC_NAME, pszUNCName); BAIL_ON_FAILURE(hr);
//
// PrinterName
//
hr = put_BSTR_Property(pPrintQueue, SPLDS_PRINTER_NAME, pszPrinterName); BAIL_ON_FAILURE(hr);
//
// versionNumber
//
hr = put_DWORD_Property(pPrintQueue, SPLDS_VERSION_NUMBER, &dwVersion); BAIL_ON_FAILURE(hr);
hr = pPrintQueue->SetInfo(); if (FAILED(hr)) pPrintQueue->GetInfo();
error:
return hr;}
HRESULTSetSpoolerProperties( HANDLE hPrinter, IADs *pPrintQueue, DWORD dwVersion){ HRESULT hr = E_FAIL; PPRINTER_INFO_2 pInfo2 = NULL; DWORD cbNeeded; BYTE Byte; PWSTR psz;
//
// Get PRINTER_INFO_2 properties
//
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, 0, &cbNeeded)) {
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { hr = dw2hr(GetLastError()); goto error; }
if (!(pInfo2 = (PPRINTER_INFO_2) AllocSplMem(cbNeeded))) { hr = dw2hr(GetLastError()); goto error; }
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, cbNeeded, &cbNeeded)) { hr = dw2hr(GetLastError()); goto error; } //
// Description
//
hr = PublishDsData( pPrintQueue, SPLDS_DESCRIPTION, REG_SZ, (PBYTE) pInfo2->pComment); //
// Driver-Name
//
hr = PublishDsData( pPrintQueue, SPLDS_DRIVER_NAME, REG_SZ, (PBYTE) pInfo2->pDriverName); //
// Location
//
hr = PublishDsData( pPrintQueue, SPLDS_LOCATION, REG_SZ, (PBYTE) pInfo2->pLocation); //
// portName (Port1,Port2,Port3)
//
if (pInfo2->pPortName) {
PWSTR pszPortName; //
// copy comma delimited strings to Multi-sz format
//
pszPortName = DelimString2MultiSz(pInfo2->pPortName, L',');
if (pszPortName) { hr = PublishDsData( pPrintQueue, SPLDS_PORT_NAME, REG_MULTI_SZ, (PBYTE) pszPortName);
FreeSplMem(pszPortName); } }
//
// startTime
//
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_START_TIME, REG_DWORD, (PBYTE) &pInfo2->StartTime); //
// endTime
//
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_END_TIME, REG_DWORD, (PBYTE) &pInfo2->UntilTime);
// keepPrintedJobs
Byte = pInfo2->Attributes & PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS ? 1 : 0;
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_KEEP_PRINTED_JOBS, REG_BINARY, (PBYTE) &Byte ); //
// printSeparatorFile
//
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_SEPARATOR_FILE, REG_SZ, (PBYTE) pInfo2->pSepFile); //
// printShareName
//
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_SHARE_NAME, REG_SZ, (PBYTE) pInfo2->pShareName); //
// printSpooling
//
if (pInfo2->Attributes & PRINTER_ATTRIBUTE_DIRECT) { psz = L"PrintDirect"; } else if (pInfo2->Attributes & PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST) { psz = L"PrintAfterSpooled"; } else { psz = L"PrintWhileSpooling"; }
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_SPOOLING, REG_SZ, (PBYTE) psz);
//
// priority
//
hr = PublishDsData( pPrintQueue, SPLDS_PRIORITY, REG_DWORD, (PBYTE) &pInfo2->Priority);
//
// Non-Info2 properties
// URL - downlevel machines don't support http printers, so don't publish useless url
//
if (dwVersion >= WIN2000_SPOOLER_VERSION) {
DWORD dwRet, dwType; PWSTR pszUrl = NULL;
//
// Get the url from the print server
//
dwRet = GetPrinterDataEx( hPrinter, SPLDS_SPOOLER_KEY, SPLDS_URL, &dwType, (PBYTE) pszUrl, 0, &cbNeeded);
if (dwRet == ERROR_MORE_DATA) { if ((pszUrl = (PWSTR) AllocSplMem(cbNeeded))) { dwRet = GetPrinterDataEx( hPrinter, SPLDS_SPOOLER_KEY, SPLDS_URL, &dwType, (PBYTE) pszUrl, cbNeeded, &cbNeeded);
if (dwRet == ERROR_SUCCESS && dwType == REG_SZ) { hr = PublishDsData( pPrintQueue, SPLDS_URL, REG_SZ, (PBYTE) pszUrl); } FreeSplMem(pszUrl); } } } }
error:
FreeSplMem(pInfo2);
return hr;}
HRESULTSetDriverProperties( HANDLE hPrinter, IADs *pPrintQueue){
DWORD i, cbBytes, dwCount; LPWSTR pStr; DWORD dwResult; LPWSTR pOutput = NULL, pTemp = NULL, pTemp1 = NULL; DWORD cOutputBytes, cTempBytes; POINTS point; WCHAR pBuf[100]; BOOL bInSplSem = TRUE; DWORD dwTemp, dwPrintRate, dwPrintRateUnit, dwPrintPPM; HRESULT hr = S_OK; PPRINTER_INFO_2 pInfo2 = NULL; PWSTR pszUNCName;
//
// Get UNCName
//
hr = GetPrinterInfo2(hPrinter, &pInfo2); BAIL_ON_FAILURE(hr);
if (!pInfo2) { hr = dw2hr(GetLastError()); goto error; }
pszUNCName = pInfo2->pPrinterName;
//
// DeviceCapability properties
//
pOutput = (PWSTR) AllocSplMem(cOutputBytes = 200); if (!pOutput) { hr = dw2hr(GetLastError()); goto error; }
pTemp = (PWSTR) AllocSplMem(cTempBytes = 200); if (!pTemp) { hr = dw2hr(GetLastError()); goto error; }
//
// printBinNames
//
DevCapMultiSz( pszUNCName, pPrintQueue, DC_BINNAMES, 24, SPLDS_PRINT_BIN_NAMES);
//
// printCollate (awaiting DC_COLLATE)
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_COLLATE, NULL, NULL);
if (dwResult != GDI_ERROR) {
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_COLLATE, REG_BINARY, (PBYTE) &dwResult); }
//
// printColor
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_COLORDEVICE, NULL, NULL);
if (dwResult == GDI_ERROR) { //
// Try alternative method
//
dwResult = ThisIsAColorPrinter(pszUNCName); }
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_COLOR, REG_BINARY, (PBYTE) &dwResult);
//
// printDuplexSupported
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_DUPLEX, NULL, NULL); if (dwResult != GDI_ERROR) { hr = PublishDsData( pPrintQueue, SPLDS_PRINT_DUPLEX_SUPPORTED, REG_BINARY, (PBYTE) &dwResult); }
//
// printStaplingSupported
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_STAPLE, NULL, NULL); if (dwResult != GDI_ERROR) { hr = PublishDsData( pPrintQueue, SPLDS_PRINT_STAPLING_SUPPORTED, REG_BINARY, (PBYTE) &dwResult); }
//
// printMaxXExtent & printMaxYExtent
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_MAXEXTENT, NULL, NULL); if (dwResult != GDI_ERROR) {
*((DWORD *) &point) = dwResult;
dwTemp = (DWORD) point.x; hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MAX_X_EXTENT, REG_DWORD, (PBYTE) &dwTemp);
dwTemp = (DWORD) point.y; hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MAX_Y_EXTENT, REG_DWORD, (PBYTE) &dwTemp);
}
//
// printMinXExtent & printMinYExtent
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_MINEXTENT, NULL, NULL); if (dwResult != GDI_ERROR) {
*((DWORD *) &point) = dwResult;
dwTemp = (DWORD) point.x; hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MIN_X_EXTENT, REG_DWORD, (PBYTE) &dwTemp);
dwTemp = (DWORD) point.y; hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MIN_Y_EXTENT, REG_DWORD, (PBYTE) &dwTemp);
}
//
// printMediaSupported
//
DevCapMultiSz( pszUNCName, pPrintQueue, DC_PAPERNAMES, 64, SPLDS_PRINT_MEDIA_SUPPORTED);
//
// printMediaReady
//
DevCapMultiSz( pszUNCName, pPrintQueue, DC_MEDIAREADY, 64, SPLDS_PRINT_MEDIA_READY);
//
// printNumberUp
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_NUP, NULL, NULL); if (dwResult != GDI_ERROR) { //
// DS NUp is boolean
//
dwResult = !!dwResult;
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_DUPLEX_SUPPORTED, REG_DWORD, (PBYTE) &dwResult); }
//
// printMemory
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_PRINTERMEM, NULL, NULL);
if (dwResult != GDI_ERROR) {
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MEMORY, REG_DWORD, (PBYTE) &dwResult); }
//
// printOrientationsSupported
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_ORIENTATION, NULL, NULL); if (dwResult != GDI_ERROR) {
StringCchCopy(pStr = pBuf, COUNTOF(pBuf), L"PORTRAIT"); if (dwResult == 90 || dwResult == 270) {
ULONG cchBuf = wcslen(pBuf) + 1; StringCchCopy(pStr = pBuf + cchBuf, COUNTOF(pBuf) - cchBuf, L"LANDSCAPE"); } else { pStr = pBuf; }
pStr += wcslen(pStr) + 1; *pStr++ = L'\0';
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_ORIENTATIONS_SUPPORTED, REG_MULTI_SZ, (PBYTE) pBuf); }
//
// printMaxResolutionSupported
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_ENUMRESOLUTIONS, NULL, NULL); if (dwResult != GDI_ERROR) {
if (cOutputBytes < dwResult*2*sizeof(DWORD)) { if(!(pTemp1 = (PWSTR) ReallocSplMem(pOutput, 0, cOutputBytes = dwResult*2*sizeof(DWORD)))) goto error; pOutput = pTemp1; }
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_ENUMRESOLUTIONS, pOutput, NULL); if (dwResult == GDI_ERROR) goto error;
//
// Find the maximum resolution: we have dwResult*2 resolutions to check
//
for(i = dwTemp = 0 ; i < dwResult*2 ; ++i) { if (((DWORD *) pOutput)[i] > dwTemp) dwTemp = ((DWORD *) pOutput)[i]; }
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_MAX_RESOLUTION_SUPPORTED, REG_DWORD, (PBYTE) &dwTemp); }
//
// printLanguage
//
DevCapMultiSz( pszUNCName, pPrintQueue, DC_PERSONALITY, 32, SPLDS_PRINT_LANGUAGE);
//
// printRate
// NOTE: If PrintRate is 0, no value is published
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_PRINTRATE, NULL, NULL);
dwPrintRate = dwResult ? dwResult : GDI_ERROR; if (dwPrintRate != GDI_ERROR) {
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_RATE, REG_DWORD, (PBYTE) &dwPrintRate); }
//
// printRateUnit
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_PRINTRATEUNIT, NULL, NULL);
dwPrintRateUnit = dwResult; if (dwPrintRateUnit != GDI_ERROR) {
switch (dwPrintRateUnit) { case PRINTRATEUNIT_PPM: pStr = L"PagesPerMinute"; break;
case PRINTRATEUNIT_CPS: pStr = L"CharactersPerSecond"; break;
case PRINTRATEUNIT_LPM: pStr = L"LinesPerMinute"; break;
case PRINTRATEUNIT_IPM: pStr = L"InchesPerMinute"; break;
default: pStr = L""; break; }
hr = PublishDsData( pPrintQueue, SPLDS_PRINT_RATE_UNIT, REG_SZ, (PBYTE) pStr); }
//
// printPagesPerMinute
// DevCap returns 0 if there is no entry in GPD
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_PRINTRATEPPM, NULL, NULL);
if (dwResult == GDI_ERROR) dwResult = 0;
dwPrintPPM = dwResult;
//
// If dwPrintPPM == 0, then calculate PPM from PrintRate
//
if (dwPrintPPM == 0) { if (dwPrintRate == GDI_ERROR) { dwPrintPPM = GDI_ERROR; } else { switch (dwPrintRateUnit) { case PRINTRATEUNIT_PPM: dwPrintPPM = dwPrintRate; break;
case PRINTRATEUNIT_CPS: case PRINTRATEUNIT_LPM: dwPrintPPM = dwPrintRate/PPM_FACTOR; if (dwPrintPPM == 0) { //
// min PPM is 1
//
dwPrintPPM = 1; } break;
default: dwPrintPPM = GDI_ERROR; break; } } }
if (dwPrintPPM != GDI_ERROR) { hr = PublishDsData( pPrintQueue, SPLDS_PRINT_PAGES_PER_MINUTE, REG_DWORD, (PBYTE) &dwPrintPPM); }
//
// printDriverVersion
//
dwResult = DeviceCapabilities( pszUNCName, NULL, DC_VERSION, NULL, NULL);
if (dwResult != GDI_ERROR) { hr = PublishDsData( pPrintQueue, SPLDS_DRIVER_VERSION, REG_DWORD, (PBYTE) &dwResult); }
error:
FreeSplMem(pInfo2);
if (pOutput) FreeSplMem(pOutput);
if (pTemp) FreeSplMem(pTemp);
return hr;}
HRESULTPublishDsData( IADs *pADs, PWSTR pValue, DWORD dwType, PBYTE pData){ HRESULT hr; BOOL bCreated = FALSE;
switch (dwType) { case REG_SZ: hr = put_BSTR_Property(pADs, pValue, (LPWSTR) pData); break;
case REG_MULTI_SZ: hr = put_MULTISZ_Property(pADs, pValue, (LPWSTR) pData); break;
case REG_DWORD: hr = put_DWORD_Property(pADs, pValue, (DWORD *) pData); break;
case REG_BINARY: hr = put_BOOL_Property(pADs, pValue, (BOOL *) pData); break;
default: hr = dw2hr(ERROR_INVALID_PARAMETER); } BAIL_ON_FAILURE(hr);
hr = pADs->SetInfo(); if (FAILED(hr)) pADs->GetInfo();
error:
return hr;}
|
