|
|
/*++
� 1998 Seagate Software, Inc. All rights reserved
Module Name:
RmsNTMS.cpp
Abstract:
Implementation of CRmsNTMS
Author:
Brian Dodd [brian] 14-May-1997
Revision History:
--*/
#include "stdafx.h"
#include "RmsServr.h"
#include "RmsNTMS.h"
typedef struct RmsNTMSSearchHandle { WCHAR FindName[NTMS_OBJECTNAME_LENGTH]; NTMS_GUID FindId; DWORD FindType; LPNTMS_GUID Objects; DWORD NumberOfObjects; DWORD MaxObjects; DWORD Next; DWORD LastError;} RMS_NTMS_SEARCH_HANDLE, *LPRMS_NTMS_SEARCH_HANDLE;
#define ADD_ACE_MASK_BITS 1
#define REMOVE_ACE_MASK_BITS 2
//
// We use application name in RSM interface for media pool name.
// Media pool name is an identifier of the media pool in RSM, therefore, we cannot allow
// this string to be localized. Localizing this string would create another pool after
// installing a foreign language MUI.
//
#define REMOTE_STORAGE_APP_NAME OLESTR("Remote Storage")
/////////////////////////////////////////////////////////////////////////////
// IRmsNTMS implementation
/*
HINSTANCE hInstDll; typedef DWORD (*FunctionName)( void ); FunctionName FunctionNameFn; hInstDll = LoadLibrary( "dll" ); FunctionNameFn = (FunctionName) GetProcAddress( hInstDll, "FunctionName" ); result = (FunctionNameFn)();*/
STDMETHODIMPCRmsNTMS::FinalConstruct(void)/*++
Implements:
CComObjectRoot::FinalConstruct
--*/{ HRESULT hr = S_OK; CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = this;
WsbTraceIn(OLESTR("CRmsNTMS::FinalConstruct"), OLESTR(""));
m_pLibGuids = NULL; m_dwNofLibs = 0;
try { WsbAffirmHr(CComObjectRoot::FinalConstruct());
WsbAffirmHr( changeState( RmsNtmsStateStarting ));
m_SessionHandle = INVALID_HANDLE_VALUE; m_IsRmsConfiguredForNTMS = FALSE; m_IsNTMSRegistered = FALSE; m_Name = RMS_NTMS_OBJECT_NAME; m_Description = RMS_NTMS_OBJECT_DESCRIPTION;
if ( S_OK == getNtmsSupportFromRegistry(NULL) ) { m_IsRmsConfiguredForNTMS = TRUE; }
HKEY hKeyMachine = 0; HKEY hKey = 0;
if ( S_OK == WsbOpenRegistryKey(NULL, RMS_NTMS_REGISTRY_STRING, KEY_QUERY_VALUE, &hKeyMachine, &hKey) ) { WsbCloseRegistryKey (&hKeyMachine, &hKey); m_IsNTMSRegistered = TRUE; }
// Failure precedence.
WsbAffirm(m_IsRmsConfiguredForNTMS, RMS_E_NOT_CONFIGURED_FOR_NTMS); WsbAffirm(m_IsNTMSRegistered, RMS_E_NTMS_NOT_REGISTERED);
WsbAffirmHr( changeState( RmsNtmsStateStarted ));
} WsbCatchAndDo(hr, pObject->Disable( hr ); WsbLogEvent(RMS_MESSAGE_NTMS_CONNECTION_NOT_ESABLISHED, 0, NULL, WsbHrAsString(hr), NULL);
// Always construct!
hr = S_OK; );
WsbTraceOut(OLESTR("CRmsNTMS::FinalConstruct"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMPCRmsNTMS::FinalRelease(void)/*++
Implements:
CComObjectRoot::FinalRelease
--*/{ HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsNTMS::FinalRelease"), OLESTR(""));
try {
WsbAffirmHr( changeState( RmsNtmsStateStopping ));
endSession();
if (m_pLibGuids) { WsbFree(m_pLibGuids); }
CComObjectRoot::FinalRelease();
WsbAffirmHr( changeState( RmsNtmsStateStopped ));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::FinalRelease"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMP CRmsNTMS::IsInstalled(void){ HRESULT hr = S_OK;
try {
if ( !m_IsEnabled ) {
if ( !m_IsNTMSRegistered ) { // check again... NTMS can get registered at anytime.
HKEY hKeyMachine = 0; HKEY hKey = 0;
WsbAffirm(S_OK == WsbOpenRegistryKey(NULL, RMS_NTMS_REGISTRY_STRING, KEY_QUERY_VALUE, &hKeyMachine, &hKey), RMS_E_NTMS_NOT_REGISTERED); WsbCloseRegistryKey (&hKeyMachine, &hKey);
m_IsNTMSRegistered = TRUE;
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = this; pObject->Enable();
// now need to initialize
WsbAffirmHr(InitializeInAnotherThread()); }
WsbAffirm(m_IsRmsConfiguredForNTMS, RMS_E_NOT_CONFIGURED_FOR_NTMS); WsbAffirm(m_IsNTMSRegistered, RMS_E_NTMS_NOT_REGISTERED);
}
} WsbCatch(hr);
return hr;}
STDMETHODIMPCRmsNTMS::Initialize(void){ HRESULT hr = E_FAIL; CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = this;
WsbTraceIn(OLESTR("CRmsNTMS::Initialize"), OLESTR(""));
try {
WsbAffirmHr( changeState( RmsNtmsStateInitializing ));
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbAffirmHr(beginSession()); }
HANDLE hSession = m_SessionHandle;
//
// Create Remote Storage specific NTMS media pools
//
WsbAffirmHr( createMediaPools() );
//
// Report on other NTMS objects of interest
//
HANDLE hFind = NULL; NTMS_OBJECTINFORMATION objectInfo;
hr = findFirstNtmsObject( NTMS_MEDIA_TYPE, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
hr = findFirstNtmsObject( NTMS_CHANGER, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
hr = findFirstNtmsObject( NTMS_CHANGER_TYPE, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
hr = findFirstNtmsObject( NTMS_DRIVE, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
hr = findFirstNtmsObject( NTMS_DRIVE_TYPE, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
WsbAffirmHr( changeState( RmsNtmsStateReady )); hr = S_OK;
} WsbCatchAndDo(hr, pObject->Disable( hr ); WsbLogEvent( RMS_MESSAGE_NTMS_INITIALIZATION_FAILED, 0, NULL, WsbHrAsString(hr), NULL ); );
WsbTraceOut( OLESTR("CRmsNTMS::Initialize"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULT CRmsNTMS::findFirstNtmsObject( IN DWORD objectType, IN REFGUID containerId, IN WCHAR *objectName, IN REFGUID objectId, OUT HANDLE *hFindObject, OUT LPNTMS_OBJECTINFORMATION pFindObjectData ){
HRESULT hr = E_FAIL;
try { int maxObjects = 16; // Initial size of object id array to allocate
LPRMS_NTMS_SEARCH_HANDLE pFind;
HANDLE hSession = m_SessionHandle; DWORD errCode; DWORD numberOfObjects = maxObjects; LPNTMS_GUID pId = ( containerId == GUID_NULL ) ? NULL : (GUID *)&containerId; LPNTMS_GUID pObjects = NULL; NTMS_OBJECTINFORMATION objectInfo;
WsbAssertPointer( hFindObject );
if ( INVALID_HANDLE_VALUE == hSession ) { WsbThrow( E_UNEXPECTED ); }
*hFindObject = NULL;
memset( &objectInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
pObjects = (LPNTMS_GUID)WsbAlloc( maxObjects*sizeof(NTMS_GUID) ); WsbAffirmPointer( pObjects );
// NTMS - enumerate all objects of the given type
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); errCode = EnumerateNtmsObject( hSession, pId, pObjects, &numberOfObjects, objectType, 0 );
if ( (ERROR_OBJECT_NOT_FOUND == errCode) || (0 == numberOfObjects) ) { // Don't count on NTMS returning the correct errCode
WsbThrow( RMS_E_NTMS_OBJECT_NOT_FOUND ); } else if ( ERROR_INSUFFICIENT_BUFFER == errCode ) {
while ( ERROR_INSUFFICIENT_BUFFER == errCode ) { // Allocate a new buffer, and retry.
WsbTrace(OLESTR("CRmsNTMS::findFirstNtmsObject - Reallocating for %d objects @1.\n"), numberOfObjects); maxObjects = numberOfObjects; LPVOID pTemp = WsbRealloc( pObjects, maxObjects*sizeof(NTMS_GUID) ); if( !pTemp ) { WsbFree( pObjects ); WsbThrow( E_OUTOFMEMORY ); } pObjects = (LPNTMS_GUID)pTemp;
// NTMS - enumerate all objects of the given type
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); errCode = EnumerateNtmsObject( hSession, pId, pObjects, &numberOfObjects, objectType, 0 ); } } WsbAffirmNoError( errCode );
HANDLE hTemp = (HANDLE)WsbAlloc( sizeof( RMS_NTMS_SEARCH_HANDLE) ); *hFindObject = hTemp; WsbAffirmPointer( *hFindObject );
pFind = (LPRMS_NTMS_SEARCH_HANDLE)*hFindObject;
// Initialize the search handle
if ( objectName ) { wcscpy( pFind->FindName, objectName ); } else { wcscpy( pFind->FindName, OLESTR("") ); }
pFind->FindId = objectId; pFind->FindType = objectType; pFind->Objects = pObjects; pFind->NumberOfObjects = numberOfObjects; pFind->MaxObjects = maxObjects; pFind->Next = 0; pFind->LastError = NO_ERROR;
BOOL bFound = FALSE;
while( pFind->Next < pFind->NumberOfObjects ) {
objectInfo.dwType = pFind->FindType; objectInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get object information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &pObjects[pFind->Next++], &objectInfo ); pFind->LastError = errCode;
// Media Pools require special handling because they contain other Media Pools
if ( (NTMS_MEDIA_POOL == pFind->FindType) && (objectInfo.Info.MediaPool.dwNumberOfMediaPools > 0) ) {
DWORD numberToAdd = objectInfo.Info.MediaPool.dwNumberOfMediaPools; do { numberOfObjects = pFind->NumberOfObjects + numberToAdd;
// Allocate a new buffer, and retry.
WsbTrace(OLESTR("CRmsNTMS::findFirstNtmsObject - Reallocating for %d objects @2.\n"), numberOfObjects); maxObjects = numberOfObjects; pObjects = (LPNTMS_GUID)WsbRealloc( pFind->Objects, maxObjects*sizeof(NTMS_GUID) ); WsbAffirmAlloc( pObjects ); pFind->Objects = pObjects;
// NTMS - enumerate all objects of the given type
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); errCode = EnumerateNtmsObject( hSession, &objectInfo.ObjectGuid, &pObjects[pFind->NumberOfObjects], &numberToAdd, pFind->FindType, 0 ); } while ( ERROR_INSUFFICIENT_BUFFER == errCode ) ;
if ( NO_ERROR == errCode ) { pFind->NumberOfObjects += numberToAdd; pFind->MaxObjects = maxObjects; } else { WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("EnumerateNtmsObject"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL ); WsbAffirmNoError(errCode); } }
if ( NO_ERROR == pFind->LastError ) {
// Now see if it is the one we're looking for
if ( GUID_NULL != pFind->FindId ) {
if ( pFind->FindId == objectInfo.ObjectGuid ) { // Match the GUID
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); } break;
} } else if ( wcslen( pFind->FindName ) > 0 ) { // Match the Name
if ( 0 == wcscmp( pFind->FindName, objectInfo.szName ) ) {
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); }
break;
}
} else { // Any GUID or Name
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); } break;
}
} else { WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNTMSObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL ); WsbThrow( RMS_E_NTMS_OBJECT_NOT_FOUND ); }
}
hr = ( bFound ) ? S_OK : RMS_E_NTMS_OBJECT_NOT_FOUND;
} WsbCatch(hr);
return hr;}
HRESULT CRmsNTMS::findNextNtmsObject( IN HANDLE hFindObject, OUT LPNTMS_OBJECTINFORMATION pFindObjectData ){ HRESULT hr = E_FAIL;
try {
HANDLE hSession = m_SessionHandle; DWORD errCode;
LPRMS_NTMS_SEARCH_HANDLE pFind = (LPRMS_NTMS_SEARCH_HANDLE)hFindObject;
LPNTMS_GUID pObjects = pFind->Objects;
NTMS_OBJECTINFORMATION objectInfo;
if ( INVALID_HANDLE_VALUE == hSession ) { WsbThrow( E_UNEXPECTED ); }
BOOL bFound = FALSE;
while( pFind->Next < pFind->NumberOfObjects ) {
objectInfo.dwType = pFind->FindType; objectInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - get object information of next object
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &pObjects[pFind->Next++], &objectInfo ); pFind->LastError = errCode;
// Media Pools require special handling because they contain other Media Pools
if ( (NTMS_MEDIA_POOL == pFind->FindType) && (objectInfo.Info.MediaPool.dwNumberOfMediaPools > 0) ) {
DWORD maxObjects; DWORD numberOfObjects; DWORD numberToAdd = objectInfo.Info.MediaPool.dwNumberOfMediaPools; do { numberOfObjects = pFind->NumberOfObjects + numberToAdd;
// Allocate a new buffer, and retry.
WsbTrace(OLESTR("CRmsNTMS::findNextNtmsObject - Reallocating for %d objects.\n"), numberOfObjects); maxObjects = numberOfObjects; pObjects = (LPNTMS_GUID)WsbRealloc( pFind->Objects, maxObjects*sizeof(NTMS_GUID) ); WsbAffirmAlloc( pObjects ); pFind->Objects = pObjects;
// NTMS - enumerate all objects of the given type
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); errCode = EnumerateNtmsObject( hSession, &objectInfo.ObjectGuid, &pObjects[pFind->NumberOfObjects], &numberToAdd, pFind->FindType, 0 ); } while ( ERROR_INSUFFICIENT_BUFFER == errCode ) ;
if ( NO_ERROR == errCode ) { pFind->NumberOfObjects += numberToAdd; pFind->MaxObjects = maxObjects; } else { WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("EnumerateNtmsObject"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL ); WsbAffirmNoError(errCode); } }
if ( NO_ERROR == pFind->LastError ) {
// Now see if it is the one we're looking for
if ( GUID_NULL != pFind->FindId ) {
if ( pFind->FindId == objectInfo.ObjectGuid ) { // Match the GUID
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); } break;
} } else if ( wcslen( pFind->FindName ) > 0 ) { // Match the Name
if ( 0 == wcscmp( pFind->FindName, objectInfo.szName ) ) {
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); } break;
}
} else { // Any GUID or Name
bFound = TRUE; if ( pFindObjectData != NULL ) { memcpy( pFindObjectData, &objectInfo, sizeof( NTMS_OBJECTINFORMATION ) ); } break;
}
} else { WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNTMSObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL ); WsbThrow( RMS_E_NTMS_OBJECT_NOT_FOUND ); } }
hr = (bFound) ? S_OK : RMS_E_NTMS_OBJECT_NOT_FOUND;
} WsbCatch(hr);
return hr;}
HRESULT CRmsNTMS::findCloseNtmsObject( IN HANDLE hFindObject){ HRESULT hr = S_OK;
try {
WsbAffirmPointer(hFindObject); // We don't need to assert here... It's possible to call
// findCloseNtmsObject even if nothing was found with
// findFirstNtmsObject. Skip the free step.
WsbFree(((LPRMS_NTMS_SEARCH_HANDLE)hFindObject)->Objects); WsbFree(hFindObject);
} WsbCatch(hr);
return hr;}
HRESULT CRmsNTMS::reportNtmsObjectInformation( IN LPNTMS_OBJECTINFORMATION pObjectInfo){
HRESULT hr = S_OK;
static DWORD lastTypeReported = 0;
try { WsbAssertPointer( pObjectInfo );
BOOL bHeaders = (lastTypeReported == pObjectInfo->dwType) ? FALSE : TRUE;
lastTypeReported = pObjectInfo->dwType;
// Output a header to trace file
if ( bHeaders ) { switch ( pObjectInfo->dwType ) {
case NTMS_UNKNOWN: case NTMS_OBJECT: WsbTrace( OLESTR("!!! WARNING !!! - CRmsServer::reportNtmsObjectInformation: report for NTMS object type: %d is not available.\n") ); break;
case NTMS_CHANGER: break;
case NTMS_CHANGER_TYPE: break;
case NTMS_COMPUTER: WsbTrace( OLESTR("!!! WARNING !!! - CRmsServer::reportNtmsObjectInformation: report for NTMS object type: %d is not available.\n") ); break;
case NTMS_DRIVE: case NTMS_DRIVE_TYPE: break;
case NTMS_IEDOOR: case NTMS_IEPORT: WsbTrace( OLESTR("!!! WARNING !!! - CRmsServer::reportNtmsObjectInformation: report for NTMS object type: %d is not available.\n") ); break;
case NTMS_LIBRARY: break;
case NTMS_LIBREQUEST: case NTMS_LOGICAL_MEDIA: WsbTrace( OLESTR("!!! WARNING !!! - CRmsServer::reportNtmsObjectInformation: report for NTMS object type: %d is not available.\n") ); break;
case NTMS_MEDIA_POOL: WsbTrace( OLESTR("GUID Enabl Type Media Type GUID Parent GUID A-Pol D-Pol Allocate Physical Logical Pools Name / Description\n") ); WsbTrace( OLESTR("====================================== ===== ==== ====================================== ====================================== ===== ===== ======== ======== ======== ===== ========================================\n") ); break;
case NTMS_MEDIA_TYPE:
WsbTrace( OLESTR("GUID Enabl Type Sides RW Name / Description\n") ); WsbTrace( OLESTR("====================================== ===== ==== ===== == ========================================\n") ); break;
case NTMS_PARTITION: break;
case NTMS_PHYSICAL_MEDIA: case NTMS_STORAGESLOT: case NTMS_OPREQUEST: default: WsbTrace( OLESTR("!!! WARNING !!! - CRmsServer::reportNtmsObjectInformation: report for object type: %d is not supported\n") ); break; } }
// Convert SYSTEMTIME to FILETIME for output.
SYSTEMTIME sCreated, sModified; FILETIME fCreated, fModified;
sCreated = pObjectInfo->Created; sModified = pObjectInfo->Modified;
SystemTimeToFileTime(&sCreated, &fCreated); SystemTimeToFileTime(&sModified, &fModified);
switch ( pObjectInfo->dwType ) {
case NTMS_UNKNOWN: case NTMS_OBJECT: break;
case NTMS_CHANGER:
WsbTrace(OLESTR("Changer %d Information:\n"), pObjectInfo->Info.Changer.Number ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" Number......... %-d\n"), pObjectInfo->Info.Changer.Number ); WsbTrace(OLESTR(" Changer Type... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Changer.ChangerType) ); WsbTrace(OLESTR(" Serial Number.. <%-ls>\n"), pObjectInfo->Info.Changer.szSerialNumber ); WsbTrace(OLESTR(" Revision....... <%-ls>\n"), pObjectInfo->Info.Changer.szRevision ); WsbTrace(OLESTR(" Device Name.... <%-ls>\n"), pObjectInfo->Info.Changer.szDeviceName ); WsbTrace(OLESTR(" SCSI Port...... %-d\n"), pObjectInfo->Info.Changer.ScsiPort ); WsbTrace(OLESTR(" SCSI Bus....... %-d\n"), pObjectInfo->Info.Changer.ScsiBus ); WsbTrace(OLESTR(" SCSI Target.... %-d\n"), pObjectInfo->Info.Changer.ScsiTarget ); WsbTrace(OLESTR(" SCSI Lun....... %-d\n"), pObjectInfo->Info.Changer.ScsiLun ); WsbTrace(OLESTR(" Library....... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Changer.Library) );
break;
case NTMS_CHANGER_TYPE: WsbTrace(OLESTR("Changer Type Information:\n") ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" Vendor......... <%-ls>\n"), pObjectInfo->Info.ChangerType.szVendor ); WsbTrace(OLESTR(" Product........ <%-ls>\n"), pObjectInfo->Info.ChangerType.szProduct ); WsbTrace(OLESTR(" Device Type.... %-d\n"), pObjectInfo->Info.ChangerType.DeviceType ); break;
case NTMS_COMPUTER: break;
case NTMS_DRIVE: WsbTrace(OLESTR("Drive %d Information:\n"), pObjectInfo->Info.Drive.Number ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" Number......... %-d\n"), pObjectInfo->Info.Drive.Number ); WsbTrace(OLESTR(" State.......... %-d\n"), pObjectInfo->Info.Drive.State ); WsbTrace(OLESTR(" Drive Type..... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Drive.DriveType) ); WsbTrace(OLESTR(" Device Name.... <%-ls>\n"), pObjectInfo->Info.Drive.szDeviceName ); WsbTrace(OLESTR(" Serial Number.. <%-ls>\n"), pObjectInfo->Info.Drive.szSerialNumber ); WsbTrace(OLESTR(" Revision....... <%-ls>\n"), pObjectInfo->Info.Drive.szRevision ); WsbTrace(OLESTR(" SCSI Port...... %-d\n"), pObjectInfo->Info.Drive.ScsiPort ); WsbTrace(OLESTR(" SCSI Bus....... %-d\n"), pObjectInfo->Info.Drive.ScsiBus ); WsbTrace(OLESTR(" SCSI Target.... %-d\n"), pObjectInfo->Info.Drive.ScsiTarget ); WsbTrace(OLESTR(" SCSI Lun....... %-d\n"), pObjectInfo->Info.Drive.ScsiLun ); WsbTrace(OLESTR(" Mount Count.... %-d\n"), pObjectInfo->Info.Drive.dwMountCount ); WsbTrace(OLESTR(" Last Cleaned... %02d/%02d/%02d %02d:%02d:%02d.%03d\n"), pObjectInfo->Info.Drive.LastCleanedTs.wMonth, pObjectInfo->Info.Drive.LastCleanedTs.wDay, pObjectInfo->Info.Drive.LastCleanedTs.wYear, pObjectInfo->Info.Drive.LastCleanedTs.wHour, pObjectInfo->Info.Drive.LastCleanedTs.wMinute, pObjectInfo->Info.Drive.LastCleanedTs.wSecond, pObjectInfo->Info.Drive.LastCleanedTs.wMilliseconds ); WsbTrace(OLESTR(" Partition...... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Drive.SavedPartitionId) ); WsbTrace(OLESTR(" Library........ %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Drive.Library) ); break;
case NTMS_DRIVE_TYPE: WsbTrace(OLESTR("Drive Type Information:\n") ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" Vendor......... <%-ls>\n"), pObjectInfo->Info.DriveType.szVendor ); WsbTrace(OLESTR(" Product........ <%-ls>\n"), pObjectInfo->Info.DriveType.szProduct ); WsbTrace(OLESTR(" Number of Heads %-d\n"), pObjectInfo->Info.DriveType.NumberOfHeads ); WsbTrace(OLESTR(" Device Type.... %-d\n"), pObjectInfo->Info.DriveType.DeviceType ); break;
case NTMS_IEDOOR: case NTMS_IEPORT: break;
case NTMS_LIBRARY: WsbTrace(OLESTR("Library Information:\n") ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" Library Type... %-d\n"), pObjectInfo->Info.Library.LibraryType ); WsbTrace(OLESTR(" CleanerSlot.... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Library.CleanerSlot) ); WsbTrace(OLESTR(" CleanerSlotD... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Library.CleanerSlotDefault) ); WsbTrace(OLESTR(" Can Clean...... %-ls\n"), WsbBoolAsString(pObjectInfo->Info.Library.LibrarySupportsDriveCleaning) ); WsbTrace(OLESTR(" Has Bar Code... %-ls\n"), WsbBoolAsString(pObjectInfo->Info.Library.BarCodeReaderInstalled) ); WsbTrace(OLESTR(" Inventory Method %-d\n"), pObjectInfo->Info.Library.InventoryMethod ); WsbTrace(OLESTR(" Cleans Remaining %-d\n"), pObjectInfo->Info.Library.dwCleanerUsesRemaining ); WsbTrace(OLESTR(" Drives......... %-d (%d)\n"), pObjectInfo->Info.Library.dwNumberOfDrives, pObjectInfo->Info.Library.FirstDriveNumber); WsbTrace(OLESTR(" Slots.......... %-d (%d)\n"), pObjectInfo->Info.Library.dwNumberOfSlots, pObjectInfo->Info.Library.FirstSlotNumber); WsbTrace(OLESTR(" Doors.......... %-d (%d)\n"), pObjectInfo->Info.Library.dwNumberOfDoors, pObjectInfo->Info.Library.FirstDoorNumber); WsbTrace(OLESTR(" Ports.......... %-d (%d)\n"), pObjectInfo->Info.Library.dwNumberOfPorts, pObjectInfo->Info.Library.FirstPortNumber); WsbTrace(OLESTR(" Changers....... %-d (%d)\n"), pObjectInfo->Info.Library.dwNumberOfChangers, pObjectInfo->Info.Library.FirstChangerNumber); WsbTrace(OLESTR(" Media Count.... %-d\n"), pObjectInfo->Info.Library.dwNumberOfMedia ); WsbTrace(OLESTR(" Media Types.... %-d\n"), pObjectInfo->Info.Library.dwNumberOfMediaTypes ); WsbTrace(OLESTR(" Requests....... %-d\n"), pObjectInfo->Info.Library.dwNumberOfLibRequests ); break;
case NTMS_LIBREQUEST: case NTMS_LOGICAL_MEDIA: break;
case NTMS_MEDIA_POOL: { // We need some temporaries since WsbGuidAsString() uses static memory to store string.
CWsbStringPtr g1 = pObjectInfo->ObjectGuid; CWsbStringPtr g2 = pObjectInfo->Info.MediaPool.MediaType; CWsbStringPtr g3 = pObjectInfo->Info.MediaPool.Parent;
WsbTrace( OLESTR("%ls %5ls %4d %ls %ls %5d %5d %8d %8d %8d %5d <%ls> / <%ls>\n"), (WCHAR *)g1, WsbBoolAsString(pObjectInfo->Enabled), pObjectInfo->Info.MediaPool.PoolType, (WCHAR *)g2, (WCHAR *)g3, pObjectInfo->Info.MediaPool.AllocationPolicy, pObjectInfo->Info.MediaPool.DeallocationPolicy, pObjectInfo->Info.MediaPool.dwMaxAllocates, pObjectInfo->Info.MediaPool.dwNumberOfPhysicalMedia, pObjectInfo->Info.MediaPool.dwNumberOfLogicalMedia, pObjectInfo->Info.MediaPool.dwNumberOfMediaPools, pObjectInfo->szName, pObjectInfo->szDescription ); } break;
case NTMS_MEDIA_TYPE: WsbTrace( OLESTR("%ls %5ls %4d %5d %2d <%ls> / <%ls>\n"), WsbGuidAsString(pObjectInfo->ObjectGuid), WsbBoolAsString(pObjectInfo->Enabled), pObjectInfo->Info.MediaType.MediaType, pObjectInfo->Info.MediaType.NumberOfSides, pObjectInfo->Info.MediaType.ReadWriteCharacteristics, pObjectInfo->szName, pObjectInfo->szDescription ); break;
case NTMS_PARTITION: WsbTrace(OLESTR("Partion Information:\n") ); WsbTrace(OLESTR(" GUID........... %-ls\n"), WsbGuidAsString(pObjectInfo->ObjectGuid) ); WsbTrace(OLESTR(" Name........... <%-ls>\n"), pObjectInfo->szName ); WsbTrace(OLESTR(" Description.... <%-ls>\n"), pObjectInfo->szDescription ); WsbTrace(OLESTR(" Enabled........ %-ls\n"), WsbBoolAsString(pObjectInfo->Enabled) ); WsbTrace(OLESTR(" Op State....... %-ls\n"), WsbLongAsString(pObjectInfo->dwOperationalState) ); WsbTrace(OLESTR(" Created........ %-ls\n"), WsbFiletimeAsString(FALSE, fCreated) ); WsbTrace(OLESTR(" Modified....... %-ls\n"), WsbFiletimeAsString(FALSE, fModified) ); WsbTrace(OLESTR(" PhysicalMedia.. %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Partition.PhysicalMedia)); WsbTrace(OLESTR(" LogicalMedia... %-ls\n"), WsbGuidAsString(pObjectInfo->Info.Partition.LogicalMedia)); WsbTrace(OLESTR(" State.......... %-d\n"), pObjectInfo->Info.Partition.State); WsbTrace(OLESTR(" Side........... %-d\n"), pObjectInfo->Info.Partition.Side); WsbTrace(OLESTR(" OmidLabelIdLen %-d\n"), pObjectInfo->Info.Partition.dwOmidLabelIdLength); WsbTrace(OLESTR(" OmidLableId:\n")); WsbTraceBuffer(pObjectInfo->Info.Partition.dwOmidLabelIdLength, pObjectInfo->Info.Partition.OmidLabelId); WsbTrace(OLESTR(" OmidLabelType.. %-ls\n"), pObjectInfo->Info.Partition.szOmidLabelType); WsbTrace(OLESTR(" OmidLabelInfo.. %-ls\n"), pObjectInfo->Info.Partition.szOmidLabelInfo); WsbTrace(OLESTR(" MountCount..... %-d\n"), pObjectInfo->Info.Partition.dwMountCount); WsbTrace(OLESTR(" AllocateCount.. %-d\n"), pObjectInfo->Info.Partition.dwAllocateCount); WsbTrace(OLESTR(" Capacity....... %-I64d\n"), pObjectInfo->Info.Partition.Capacity.QuadPart); break;
case NTMS_PHYSICAL_MEDIA: case NTMS_STORAGESLOT: case NTMS_OPREQUEST: default: break; }
} WsbCatch(hr);
return hr;}
HRESULTCRmsNTMS::getNtmsSupportFromRegistry( OUT DWORD *pNTMSSupportValue)/*++
Routine Description:
Determines if NTMS flag is set in the Registry.
Arguments:
pNTMSSupportValue - Receives the actual value of the regstry key value. Any non-zero values indicates NTMS support.
Return Values:
S_OK - NTMS support flag is on. S_FALSE - NTMS support flag is off.
--*/{ HRESULT hr = S_OK; DWORD val = RMS_DEFAULT_NTMS_SUPPORT;
WsbTraceIn(OLESTR("CRmsNTMS::getNtmsSupportFromRegistry"), OLESTR(""));
try { DWORD sizeGot; const int cDataSizeToGet = 100; OLECHAR dataString[cDataSizeToGet]; OLECHAR *stopString;
//
// Get the value. If the key doesn't exists, the default value is used.
//
try {
WsbAffirmHrOk(WsbEnsureRegistryKeyExists(NULL, RMS_REGISTRY_STRING)); WsbAffirmHrOk(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_NTMS_SUPPORT, dataString, cDataSizeToGet, &sizeGot)); val = wcstoul(dataString, &stopString, 10);
} WsbCatch(hr);
if (pNTMSSupportValue != NULL) { *pNTMSSupportValue = val; }
hr = (val) ? S_OK : S_FALSE;
} WsbCatchAndDo( hr, hr = S_FALSE; );
WsbTraceOut(OLESTR("CRmsNTMS::getNtmsSupportFromRegistry"), OLESTR("hr = <%ls>, val = <%ld>"), WsbHrAsString(hr), val);
return hr;}
HRESULT CRmsNTMS::beginSession(void)/*++
Implements:
CRmsNTMS::beginSession
--*/{ HRESULT hr = S_OK; WsbTraceIn( OLESTR("CRmsNTMS::beginSession"), OLESTR("") );
try {
WsbAffirmHrOk(IsInstalled()); WsbAffirmHrOk(endSession()); // clear the old session
WsbAffirmHrOk(waitUntilReady()); // starts a new session
//WsbAffirmHrOk(waitForScratchPool());
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::beginSession"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULT CRmsNTMS::endSession(void)/*++
Implements:
CRmsNTMS::endSession
--*/{ HRESULT hr = S_OK; WsbTraceIn( OLESTR("CRmsNTMS::endSession"), OLESTR("") );
try {
if ( m_SessionHandle != INVALID_HANDLE_VALUE ) { // NTMS - Close session
WsbTraceAlways(OLESTR("CloseNtmsSession()\n")); WsbAffirmNoError(CloseNtmsSession(m_SessionHandle)); }
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_CONNECTION_UNAVAIL: case ERROR_INVALID_HANDLE: break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("CloseNtmsSession"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } );
m_SessionHandle = INVALID_HANDLE_VALUE; hr = S_OK;
WsbTraceOut( OLESTR("CRmsNTMS::endSession"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULTCRmsNTMS::waitUntilReady(void){ HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::waitUntilReady"), OLESTR(""));
try {
int retry = 360; // number of retries
// Retrieve the NotificationWaitTime parameter
DWORD size; OLECHAR tmpString[256]; DWORD notificationWaitTime = RMS_DEFAULT_NOTIFICATION_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_NOTIFICATION_WAIT_TIME, tmpString, 256, &size))) { notificationWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("NotificationWaitTime is %d milliseconds.\n"), notificationWaitTime); }
do { // NTMS - Open session
WsbTraceAlways(OLESTR("OpenNtmsSession()\n"));
CWsbStringPtr appName; WsbAffirmHr(appName.LoadFromRsc(_Module.m_hInst, IDS_PRODUCT_NAME));
m_SessionHandle = OpenNtmsSession(NULL, (WCHAR *) appName, 0); if ( m_SessionHandle != INVALID_HANDLE_VALUE ) { break; } else { hr = HRESULT_FROM_WIN32(GetLastError()); switch (HRESULT_CODE(hr)) { case ERROR_NOT_READY: if ( retry > 0 ) { WsbTrace(OLESTR("Waiting for NTMS to come ready - Seconds remaining before timeout: %d\n"), retry*notificationWaitTime/1000); Sleep(notificationWaitTime); hr = S_OK; } else { //
// This is the last try, so log the failure.
//
WsbLogEvent(RMS_MESSAGE_NTMS_CONNECTION_NOT_ESABLISHED, 0, NULL, WsbHrAsString(hr), NULL); WsbThrow(RMS_E_NTMS_NOT_CONNECTED); } break;
case ERROR_INVALID_COMPUTERNAME: case ERROR_INVALID_PARAMETER: case ERROR_NO_NETWORK: case ERROR_NOT_CONNECTED: WsbLogEvent(RMS_MESSAGE_NTMS_CONNECTION_NOT_ESABLISHED, 0, NULL, WsbHrAsString(hr), NULL); WsbThrow(hr); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("OpenNtmsSession"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); WsbThrow(hr); break; } } } while( retry-- > 0 ) ;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::waitUntilReady"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
HRESULTCRmsNTMS::waitForScratchPool(void){ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR; DWORD err3 = NO_ERROR; HANDLE hNotify = INVALID_HANDLE_VALUE;
WsbTraceIn(OLESTR("CRmsNTMS::waitForScratchPool"), OLESTR(""));
try {
int retry = 60; // number of retries
// Retrieve the NotificationWaitTime parameter
DWORD size; OLECHAR tmpString[256]; DWORD notificationWaitTime = RMS_DEFAULT_NOTIFICATION_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_NOTIFICATION_WAIT_TIME, tmpString, 256, &size))) { notificationWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("NotificationWaitTime is %d milliseconds.\n"), notificationWaitTime); }
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbThrow(E_UNEXPECTED); }
HANDLE hSession = m_SessionHandle;
NTMS_OBJECTINFORMATION objectInfo; NTMS_OBJECTINFORMATION scratchInfo; NTMS_NOTIFICATIONINFORMATION notifyInfo; HANDLE hFind = NULL;
BOOL bFound = FALSE;
// TODO: We really should wait around until all libraries are classified.
DWORD mediaCount = 0;
hr = findFirstNtmsObject( NTMS_LIBRARY, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &objectInfo ); mediaCount += objectInfo.Info.Library.dwNumberOfMedia; hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
if ( 0 == mediaCount) { WsbThrow( RMS_E_NTMS_OBJECT_NOT_FOUND ); }
/*
// First see if there is any media to be classified, if not we don't bother waiting around for
// nothing to happen.
hr = findFirstNtmsObject( NTMS_PHYSICAL_MEDIA, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); WsbAffirmHrOk( hr ); findCloseNtmsObject( hFind ); */
// NTMS - Open notification channel
WsbTraceAlways(OLESTR("OpenNtmsNotification()\n")); hNotify = OpenNtmsNotification(hSession, NTMS_MEDIA_POOL); if ( INVALID_HANDLE_VALUE == hNotify ) { err1 = GetLastError(); WsbAffirmNoError(err1); WsbThrow(E_UNEXPECTED); }
do { err2 = NO_ERROR; //
// Count the number of NTMS Scratch pools, and if
// there are more than one, we return. If not,
// we wait until the root level scratch pool object
// is updated.
//
// More that one scratch media pools implies that at
// least one unit of media was classified. We don't
// know until we complete the initialization if it
// was one of the media types supported by RemoteStorage.
//
int count = 0;
hr = findFirstNtmsObject( NTMS_MEDIA_POOL, GUID_NULL, NULL, GUID_NULL, &hFind, &objectInfo); while( S_OK == hr ) { if ( NTMS_POOLTYPE_SCRATCH == objectInfo.Info.MediaPool.PoolType ) { count++; if ( count == 1 ) { // Assueme this is the rool pool and one we'll check on for updates
// If the assumption is wrong count will end up > 1.
memcpy(&scratchInfo, &objectInfo, sizeof(NTMS_OBJECTINFORMATION)); } } hr = findNextNtmsObject( hFind, &objectInfo ); } findCloseNtmsObject( hFind );
if ( count > 1 ) { bFound = TRUE; hr = S_OK; break; // Normal exit.
}
if ( count == 0 ) { WsbThrow(E_UNEXPECTED); }
// Just one scratch pool detected... wait until a media-type specific pool
// is added root scratch pool. This will show up as an update to the root
// scratch pool.
do {
WsbTrace(OLESTR("Waiting for NTMS scratch pool - Seconds remaining before timeout: %d\n"), retry*notificationWaitTime/1000);
// NTMS - Wait for notification
WsbTraceAlways(OLESTR("WaitForNtmsNotification()\n")); err2 = WaitForNtmsNotification(hNotify, ¬ifyInfo, notificationWaitTime); if ( NO_ERROR == err2 ) { //
// Note: With this notification mechanism, chances
// are slim that we got notified on the object we really
// care about.
//
WsbTrace(OLESTR("Processing: <%d> %ls\n"), notifyInfo.dwOperation, WsbGuidAsString(notifyInfo.ObjectId)); if ( notifyInfo.ObjectId != scratchInfo.ObjectGuid ) { WsbTrace(OLESTR("Wrong object, try again...\n")); continue; // skip this one
} else { if ( NTMS_OBJ_UPDATE != notifyInfo.dwOperation ) { WsbTrace(OLESTR("Wrong operation, try again...\n")); continue; // skip this one
} else { WsbTrace(OLESTR("Scratch pool update detected.\n")); break; // A scratch pool may have inserted, go check it out...
} } } else if ( ERROR_TIMEOUT != err2 && ERROR_NO_DATA != err2 ) { WsbAffirmNoError(err2); } retry--; } while( (retry > 0) && (!bFound) ); } while( (retry > 0) && (!bFound) );
// NTMS - Close notification channel
WsbTraceAlways(OLESTR("CloseNtmsNotification()\n")); err3 = CloseNtmsNotification(hNotify); WsbAffirmNoError(err3);
if ( !bFound ) { hr = RMS_E_RESOURCE_UNAVAILABLE; }
} WsbCatchAndDo(hr,
if ( hNotify != INVALID_HANDLE_VALUE ) { // NTMS - Close notification channel
WsbTraceAlways(OLESTR("CloseNtmsNotification()\n")); err3 = CloseNtmsNotification(hNotify); }
if (err1 != NO_ERROR) { // OpenNtmsNotification
switch (HRESULT_CODE(hr)) { case ERROR_DATABASE_FAILURE: case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("OpenNtmsNotification"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("OpenNtmsNotification"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } if (err2 != NO_ERROR) { // WaitForNtmsNotification
switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case ERROR_DATABASE_FAILURE: case ERROR_TIMEOUT: case ERROR_NO_DATA: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("WaitForNtmsNotification"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("WaitForNtmsNotification"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } if (err3 != NO_ERROR) { // CloseNtmsNotification
switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case ERROR_DATABASE_FAILURE: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("CloseNtmsNotification"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("CloseNtmsNotification"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::waitForScratchPool"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
HRESULTCRmsNTMS::storageMediaTypeToRmsMedia( IN NTMS_MEDIATYPEINFORMATION *pMediaTypeInfo, OUT RmsMedia *pTranslatedMediaType){ HRESULT hr = S_OK;
DWORD size; OLECHAR tmpString[256];
// Media type is the main criteria
WsbAssertPointer(pMediaTypeInfo); STORAGE_MEDIA_TYPE mediaType = (STORAGE_MEDIA_TYPE)(pMediaTypeInfo->MediaType);
DWORD tapeEnabled = RMS_DEFAULT_TAPE; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_TAPE, tmpString, 256, &size))) { // Get the value.
tapeEnabled = wcstol(tmpString, NULL, 10); }
DWORD opticalEnabled = RMS_DEFAULT_OPTICAL; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_OPTICAL, tmpString, 256, &size))) { // Get the value.
opticalEnabled = wcstol(tmpString, NULL, 10); }
DWORD dvdEnabled = RMS_DEFAULT_DVD; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_DVD, tmpString, 256, &size))) { // Get the value.
dvdEnabled = wcstol(tmpString, NULL, 10); }
switch ( mediaType ) {
case DDS_4mm: // Tape - DAT DDS1,2,... (all vendors) (0x20)
*pTranslatedMediaType = (tapeEnabled) ? RmsMedia4mm : RmsMediaUnknown; break;
case MiniQic: // Tape - miniQIC Tape
case Travan: // Tape - Travan TR-1,2,3,...
case QIC: // Tape - QIC
*pTranslatedMediaType = RmsMediaUnknown; break;
case MP_8mm: // Tape - 8mm Exabyte Metal Particle
case AME_8mm: // Tape - 8mm Exabyte Advanced Metal Evap
case AIT1_8mm: // Tape - 8mm Sony AIT1
*pTranslatedMediaType = (tapeEnabled) ? RmsMedia8mm : RmsMediaUnknown; break;
case DLT: // Tape - DLT Compact IIIxt: IV
*pTranslatedMediaType = (tapeEnabled) ? RmsMediaDLT : RmsMediaUnknown; break;
case NCTP: // Tape - Philips NCTP
case IBM_3480: // Tape - IBM 3480
case IBM_3490E: // Tape - IBM 3490E
case IBM_Magstar_3590: // Tape - IBM Magstar 3590
case IBM_Magstar_MP: // Tape - IBM Magstar MP
case STK_DATA_D3: // Tape - STK Data D3
case SONY_DTF: // Tape - Sony DTF
case DV_6mm: // Tape - 6mm Digital Video
case DMI: // Tape - Exabyte DMI and compatibles
case SONY_D2: // Tape - Sony D2S and D2L
case CLEANER_CARTRIDGE: // Cleaner - All Drive types that support Drive Cleaners
case CD_ROM: // Opt_Disk - CD
case CD_R: // Opt_Disk - CD-Recordable (Write Once)
case CD_RW: // Opt_Disk - CD-Rewriteable
case DVD_ROM: // Opt_Disk - DVD-ROM
case DVD_R: // Opt_Disk - DVD-Recordable (Write Once)
case MO_5_WO: // Opt_Disk - MO 5.25" Write Once
*pTranslatedMediaType = RmsMediaUnknown; break;
case DVD_RW: // Opt_Disk - DVD-Rewriteable
*pTranslatedMediaType = (dvdEnabled) ? RmsMediaDVD : RmsMediaUnknown; break;
case MO_5_RW: // Opt_Disk - MO 5.25" Rewriteable (not LIMDOW)
case MO_3_RW: // Opt_Disk - 3.5" Rewriteable MO Disk
case MO_5_LIMDOW: // Opt_Disk - MO 5.25" Rewriteable (LIMDOW)
case PC_5_RW: // Opt_Disk - Phase Change 5.25" Rewriteable
case PD_5_RW: // Opt_Disk - PhaseChange Dual Rewriteable
case PINNACLE_APEX_5_RW: // Opt_Disk - Pinnacle Apex 4.6GB Rewriteable Optical
case NIKON_12_RW: // Opt_Disk - Nikon 12" Rewriteable
*pTranslatedMediaType = (opticalEnabled) ? RmsMediaOptical : RmsMediaUnknown; break;
case PC_5_WO: // Opt_Disk - Phase Change 5.25" Write Once Optical
case ABL_5_WO: // Opt_Disk - Ablative 5.25" Write Once Optical
*pTranslatedMediaType = RmsMediaUnknown; break;
case SONY_12_WO: // Opt_Disk - Sony 12" Write Once
case PHILIPS_12_WO: // Opt_Disk - Philips/LMS 12" Write Once
case HITACHI_12_WO: // Opt_Disk - Hitachi 12" Write Once
case CYGNET_12_WO: // Opt_Disk - Cygnet/ATG 12" Write Once
case KODAK_14_WO: // Opt_Disk - Kodak 14" Write Once
case MO_NFR_525: // Opt_Disk - Near Field Recording (Terastor)
case IOMEGA_ZIP: // Mag_Disk - Iomega Zip
case IOMEGA_JAZ: // Mag_Disk - Iomega Jaz
case SYQUEST_EZ135: // Mag_Disk - Syquest EZ135
case SYQUEST_EZFLYER: // Mag_Disk - Syquest EzFlyer
case SYQUEST_SYJET: // Mag_Disk - Syquest SyJet
case AVATAR_F2: // Mag_Disk - 2.5" Floppy
*pTranslatedMediaType = RmsMediaUnknown; break;
case RemovableMedia: // This is reported on stand-alone optical drives.
default: // Check RSM characteristics for Rewriteable Disk
if ((pMediaTypeInfo->ReadWriteCharacteristics == NTMS_MEDIARW_REWRITABLE) && (pMediaTypeInfo->DeviceType == FILE_DEVICE_DISK)) { *pTranslatedMediaType = (opticalEnabled) ? RmsMediaOptical : RmsMediaUnknown; } else { // Not a rewritable disk and not one of the supported tape types...
*pTranslatedMediaType = RmsMediaUnknown; } break; }
if ((*pTranslatedMediaType == RmsMediaUnknown) && (pMediaTypeInfo->DeviceType == FILE_DEVICE_TAPE)) { // Check in the Registry whether there are additional tapes that we need to support
ULONG *pTypes= NULL; ULONG uTypes = 0;
if (SUCCEEDED(WsbGetRegistryValueUlongAsMultiString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_ADDITIONAL_TAPE, &pTypes, &uTypes))) { // Compare Registry types to the media type we have
for (ULONG u=0; u<uTypes; u++) { if ((STORAGE_MEDIA_TYPE)(pTypes[u]) == mediaType) { // Support it !!
WsbTraceAlways(OLESTR("CRmsNTMS::storageMediaTypeToRmsMedia: Registry asks to support tape type %lu\n"), pTypes[u]);
*pTranslatedMediaType = RmsMediaTape;
break; } } }
if (pTypes != NULL) { WsbFree(pTypes); pTypes = NULL; } }
return hr;}
HRESULTCRmsNTMS::createMediaPools(void){ HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsNTMS::createMediaPools"), OLESTR(""));
try {
HANDLE hSession; NTMS_GUID rootPoolId = GUID_NULL;
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbAffirmHr(beginSession()); }
hSession = m_SessionHandle;
try {
// NTMS - Create Application Media Pool.
WsbTraceAlways(OLESTR("CreateNtmsMediaPool()\n"));
WsbAffirmNoError(CreateNtmsMediaPool(hSession, REMOTE_STORAGE_APP_NAME, NULL, NTMS_OPEN_ALWAYS, NULL, &rootPoolId));
// Now set access permissions on the pool: turn off ordinary users access
WsbAffirmHrOk(setPoolDACL(&rootPoolId, DOMAIN_ALIAS_RID_USERS, REMOVE_ACE_MASK_BITS,NTMS_USE_ACCESS | NTMS_MODIFY_ACCESS | NTMS_CONTROL_ACCESS));
} WsbCatchAndDo(hr, switch(HRESULT_CODE(hr)) { case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_INVALID_NAME: case ERROR_OBJECT_NOT_FOUND: case ERROR_ALREADY_EXISTS: case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: WsbLogEvent( RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("CreateNtmsMediaPool"), OLESTR(""), WsbHrAsString(hr), NULL ); break; default: WsbLogEvent( RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("CreateNtmsMediaPool"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL ); break; } WsbThrow(hr); );
//
// Only one of the following should be executed, comment out the other.
//
WsbAffirmHr( createMediaPoolForEveryMediaType(rootPoolId) ); // New way
/*
WsbAffirmHr( replicateScratchMediaPool(rootPoolId) ); // Old way
*/
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::createMediaPools"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULTCRmsNTMS::replicateScratchMediaPool( IN REFGUID /*rootPoolId*/){ HRESULT hr = E_FAIL;
WsbTraceIn(OLESTR("CRmsNTMS::replicateScratchMediaPool"), OLESTR(""));
try {
HANDLE hSession; DWORD errCode; NTMS_OBJECTINFORMATION mediaTypeInfo; NTMS_OBJECTINFORMATION mediaPoolInfo; HANDLE hFind = NULL; NTMS_GUID poolId = GUID_NULL;
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbAffirmHr(beginSession()); }
hSession = m_SessionHandle;
// For each media pool in the scratch pool create an application specific pool.
hr = findFirstNtmsObject( NTMS_MEDIA_POOL, GUID_NULL, NULL, GUID_NULL, &hFind, &mediaPoolInfo); while( S_OK == hr ) { reportNtmsObjectInformation( &mediaPoolInfo ); poolId = GUID_NULL;
try {
// Set up application specific NTMS Media Pools. One for each compatible type.
//
// To get here we had to already detect a media-type specific scratch pool
// in waitForScratchPool()
if ( NTMS_POOLTYPE_SCRATCH == mediaPoolInfo.Info.MediaPool.PoolType && 0 == mediaPoolInfo.Info.MediaPool.dwNumberOfMediaPools ) {
// This is a base level scratch media pool.
// Create a similar pool for application specific use.
CWsbStringPtr name = REMOTE_STORAGE_APP_NAME; name.Append( OLESTR("\\") ); name.Append( mediaPoolInfo.szName );
NTMS_GUID mediaTypeId = mediaPoolInfo.Info.MediaPool.MediaType;
// We need more information about the media type.
memset( &mediaTypeInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
mediaTypeInfo.dwType = NTMS_MEDIA_TYPE; mediaTypeInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &mediaTypeId, &mediaTypeInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Translate the NTMS media type into something understood by RMS
RmsMedia translatedMediaType; storageMediaTypeToRmsMedia(&(mediaTypeInfo.Info.MediaType), &translatedMediaType);
if ( translatedMediaType != RmsMediaUnknown ) {
// This something that Remote Storage can deal with
CWsbBstrPtr mediaSetName = RMS_UNDEFINED_STRING; CWsbBstrPtr mediaSetDesc = RMS_UNDEFINED_STRING; BOOL mediaSetIsEnabled = FALSE;
// NTMS - Create Application Media Pool.
WsbTraceAlways(OLESTR("CreateNtmsMediaPool()\n")); errCode = CreateNtmsMediaPool( hSession, (WCHAR *) name, &mediaTypeId, NTMS_CREATE_NEW, NULL, &poolId );
if ( ERROR_ALREADY_EXISTS == errCode ) {
// We still need the poolId of the existing pool.
// NTMS - Create Application Media Pool.
WsbTraceAlways(OLESTR("CreateNtmsMediaPool()\n")); errCode = CreateNtmsMediaPool( hSession, (WCHAR *)name, &mediaTypeId, NTMS_OPEN_EXISTING, NULL, &poolId ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("CreateNtmsMediaPool"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
NTMS_OBJECTINFORMATION mediaPoolInfo;
memset( &mediaPoolInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED ); }
// Save relevant info
mediaSetName = mediaPoolInfo.szName; mediaSetDesc = mediaPoolInfo.szDescription; mediaSetIsEnabled = mediaPoolInfo.Enabled;
} else if ( NO_ERROR == errCode ) {
memset( &mediaPoolInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
WsbAssert( NTMS_POOLTYPE_APPLICATION == mediaPoolInfo.Info.MediaPool.PoolType, E_UNEXPECTED );
// Set media pool parameters
// Aallocation/deallocation policy
mediaPoolInfo.Info.MediaPool.AllocationPolicy = NTMS_ALLOCATE_FROMSCRATCH; mediaPoolInfo.Info.MediaPool.DeallocationPolicy = 0;
// Max number of allocates per media
mediaPoolInfo.Info.MediaPool.dwMaxAllocates = 5;// Just a few... we automatically
// deallocate media if there's
// problem with scratch mount
// operation.
// NOTE: This can be overridden using
// the NTMS GUI.
// NTMS - Set Media Pool Information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); errCode = SetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("SetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Save relevant info
mediaSetName = mediaPoolInfo.szName; mediaSetDesc = mediaPoolInfo.szDescription; mediaSetIsEnabled = mediaPoolInfo.Enabled;
} else {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("CreateNtmsMediaPool"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Now we have an NTMS media pool for our specific use. Now expose it
// through the RMS interface by creating a CRmsMediaSet.
if ( poolId != GUID_NULL ) { CComPtr<IRmsMediaSet> pMediaSet;
// Find the RmsMediaSet with the same id, or create a new one.
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; WsbAffirmHr( pServer->CreateObject( poolId, CLSID_CRmsMediaSet, IID_IRmsMediaSet, RmsOpenAlways, (void **)&pMediaSet ) );
WsbTrace(OLESTR("CRmsNTMS::replicateScratchMediaPool - type %d CRmsMediaSet created.\n"), translatedMediaType);
WsbAffirmHr( pMediaSet->SetMediaSetType( RmsMediaSetNTMS ) ); WsbAffirmHr( pMediaSet->SetMediaSupported( translatedMediaType ) );
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pMediaSet; WsbTrace(OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType - MediaSet: <%ls/%ls>; Enabled: %ls\n"), WsbQuickString(WsbStringAsString(mediaSetName)), WsbQuickString(WsbStringAsString(mediaSetDesc)), WsbQuickString(WsbBoolAsString(mediaSetIsEnabled))); WsbAffirmHr(pObject->SetName(mediaSetName)); WsbAffirmHr(pObject->SetDescription(mediaSetDesc)); if (!mediaSetIsEnabled) { WsbAffirmHr(pObject->Disable(E_FAIL)); }
if (S_OK == IsMediaCopySupported(poolId)) { WsbAffirmHr( pMediaSet->SetIsMediaCopySupported(TRUE)); } hr = pMediaSet->IsMediaCopySupported();
WsbTrace(OLESTR("CRmsNTMS::replicateScratchMediaPool - media copies are %ls.\n"), (S_OK == pMediaSet->IsMediaCopySupported()) ? OLESTR("enabled") : OLESTR("disabled"));
} } }
} WsbCatch(hr);
hr = findNextNtmsObject( hFind, &mediaPoolInfo ); } // while finding media pools
findCloseNtmsObject( hFind );
hr = S_OK;
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::replicateScratchMediaPool"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULTCRmsNTMS::createMediaPoolForEveryMediaType( IN REFGUID /*rootPoolId*/){ HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType"), OLESTR(""));
try { DWORD errCode;
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbAffirmHr(beginSession()); }
HANDLE hSession = m_SessionHandle;
HANDLE hFindLib = NULL; NTMS_OBJECTINFORMATION libraryInfo;
BOOL bSupportedLib = FALSE; m_dwNofLibs = 0;
hr = findFirstNtmsObject( NTMS_LIBRARY, GUID_NULL, NULL, GUID_NULL, &hFindLib, &libraryInfo); while( S_OK == hr ) { bSupportedLib = FALSE;
reportNtmsObjectInformation( &libraryInfo );
if (libraryInfo.Info.Library.dwNumberOfMediaTypes > 0) {
HANDLE hFindType = NULL; NTMS_OBJECTINFORMATION mediaTypeInfo;
hr = findFirstNtmsObject( NTMS_MEDIA_TYPE, libraryInfo.ObjectGuid, NULL, GUID_NULL, &hFindType, &mediaTypeInfo); while( S_OK == hr ) { //
// Create an application Media Pool for each type
//
NTMS_GUID poolId;
// This is a base level scratch media pool.
// Create a similar pool for application specific use.
CWsbStringPtr name = REMOTE_STORAGE_APP_NAME; name.Append( OLESTR("\\") ); name.Append( mediaTypeInfo.szName );
NTMS_GUID mediaTypeId = mediaTypeInfo.ObjectGuid;
// Translate the NTMS media type into something understood by RMS
RmsMedia translatedMediaType; storageMediaTypeToRmsMedia(&(mediaTypeInfo.Info.MediaType), &translatedMediaType);
if ( translatedMediaType != RmsMediaUnknown ) {
// This something that Remote Storage can deal with
CWsbBstrPtr mediaSetName = RMS_UNDEFINED_STRING; CWsbBstrPtr mediaSetDesc = RMS_UNDEFINED_STRING; BOOL mediaSetIsEnabled = FALSE;
// NTMS - Create Application Media Pool.
WsbTraceAlways(OLESTR("CreateNtmsMediaPool(<%ls>) - Try New.\n"), (WCHAR *) name); errCode = CreateNtmsMediaPool( hSession, (WCHAR *) name, &mediaTypeId, NTMS_CREATE_NEW, NULL, &poolId );
if ( ERROR_ALREADY_EXISTS == errCode ) { WsbTraceAlways(OLESTR("MediaPool <%ls> already exists.\n"), (WCHAR *) name);
// We still need the poolId of the existing pool.
// NTMS - Create Application Media Pool.
WsbTraceAlways(OLESTR("CreateNtmsMediaPool(<%ls>) - Try Existing.\n"), (WCHAR *) name); errCode = CreateNtmsMediaPool( hSession, (WCHAR *)name, &mediaTypeId, NTMS_OPEN_EXISTING, NULL, &poolId ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("CreateNtmsMediaPool"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
WsbTraceAlways(OLESTR("Media Pool %ls detected.\n"), WsbGuidAsString(poolId));
NTMS_OBJECTINFORMATION mediaPoolInfo;
memset( &mediaPoolInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Save relevant info
mediaSetName = mediaPoolInfo.szName; mediaSetDesc = mediaPoolInfo.szDescription; mediaSetIsEnabled = mediaPoolInfo.Enabled;
} else if ( NO_ERROR == errCode ) { WsbTraceAlways(OLESTR("MediaPool <%ls> created.\n"), (WCHAR *) name);
NTMS_OBJECTINFORMATION mediaPoolInfo;
memset( &mediaPoolInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION );
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); errCode = GetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
WsbAssert( NTMS_POOLTYPE_APPLICATION == mediaPoolInfo.Info.MediaPool.PoolType, E_UNEXPECTED );
// Set media pool parameters
// Aallocation/deallocation policy
mediaPoolInfo.Info.MediaPool.AllocationPolicy = NTMS_ALLOCATE_FROMSCRATCH; mediaPoolInfo.Info.MediaPool.DeallocationPolicy = 0;
// Max number of allocates per media
mediaPoolInfo.Info.MediaPool.dwMaxAllocates = 0;// Unlimited... we automatically
// deallocate media if there's
// problem with scratch mount
// operation.
// TODO: Verify that NTMS always allocates
// media with the lowest allocation
// count.
// NOTE: This can be overridden using
// the NTMS GUI.
// NTMS - Set Media Pool Information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); errCode = SetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("SetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Save relevant info
mediaSetName = mediaPoolInfo.szName; mediaSetDesc = mediaPoolInfo.szDescription; mediaSetIsEnabled = mediaPoolInfo.Enabled; } else {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("CreateNtmsMediaPool"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
// Now set access permissions on the pool: turn off ordinary users access
WsbAffirmHrOk(setPoolDACL(&poolId, DOMAIN_ALIAS_RID_USERS, REMOVE_ACE_MASK_BITS,NTMS_USE_ACCESS | NTMS_MODIFY_ACCESS | NTMS_CONTROL_ACCESS));
// Now we have an NTMS media pool for our specific use. Now expose it
// through the RMS interface by creating a CRmsMediaSet.
if ( poolId != GUID_NULL ) {
//
// Add to CRmsMediaSet collection
//
CComPtr<IRmsMediaSet> pMediaSet;
// Find the CRmsMediaSet with the same id, or create a new one.
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; WsbAffirmHr( pServer->CreateObject( poolId, CLSID_CRmsMediaSet, IID_IRmsMediaSet, RmsOpenAlways, (void **)&pMediaSet ) );
WsbTrace(OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType - type %d CRmsMediaSet established.\n"), translatedMediaType);
WsbAffirmHr( pMediaSet->SetMediaSetType( RmsMediaSetNTMS ) ); WsbAffirmHr( pMediaSet->SetMediaSupported( translatedMediaType ) );
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pMediaSet; WsbTrace(OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType - MediaSet: <%ls/%ls> %ls; Enabled: %ls\n"), WsbQuickString(WsbStringAsString(mediaSetName)), WsbQuickString(WsbStringAsString(mediaSetDesc)), WsbQuickString(WsbGuidAsString(poolId)), WsbQuickString(WsbBoolAsString(mediaSetIsEnabled))); WsbAffirmHr(pObject->SetName(mediaSetName)); WsbAffirmHr(pObject->SetDescription(mediaSetDesc)); if (!mediaSetIsEnabled) { WsbAffirmHr(pObject->Disable(E_FAIL)); }
if (S_OK == IsMediaCopySupported(poolId)) { WsbAffirmHr( pMediaSet->SetIsMediaCopySupported(TRUE)); } hr = pMediaSet->IsMediaCopySupported();
WsbTrace(OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType - media copies are %ls.\n"), (S_OK == pMediaSet->IsMediaCopySupported()) ? OLESTR("enabled") : OLESTR("disabled"));
}
// The library has a supported media type
bSupportedLib = TRUE; } hr = findNextNtmsObject( hFindType, &mediaTypeInfo ); } findCloseNtmsObject( hFindType ); }
// Check if the library has supported media type
if (bSupportedLib) { // Add library GUI to the libraries list
// (Realloc one item each time since we don't expect many items)
m_dwNofLibs++; LPVOID pTemp = WsbRealloc(m_pLibGuids, m_dwNofLibs*sizeof(NTMS_GUID)); if (!pTemp) { WsbThrow(E_OUTOFMEMORY); } m_pLibGuids = (LPNTMS_GUID)pTemp; m_pLibGuids[m_dwNofLibs-1] = libraryInfo.ObjectGuid; } // Continue library enumeration
hr = findNextNtmsObject( hFindLib, &libraryInfo ); } findCloseNtmsObject( hFindLib );
hr = S_OK;
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::createMediaPoolForEveryMediaType"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMP CRmsNTMS::Allocate( IN REFGUID fromMediaSet, IN REFGUID prevSideId, IN OUT LONGLONG *pFreeSpace, IN BSTR displayName, IN DWORD dwOptions, OUT IRmsCartridge **ppCartridge)/*++
Implements:
IRmsNTMS::Allocate
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR; DWORD err3 = NO_ERROR; DWORD err4 = NO_ERROR; DWORD err5 = NO_ERROR; DWORD err6 = NO_ERROR; DWORD err7 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::Allocate"), OLESTR("<%ls> <%ls> <%ls> <%ls> <0x%08x"), WsbGuidAsString(fromMediaSet), WsbGuidAsString(prevSideId), WsbPtrToLonglongAsString(pFreeSpace), WsbStringAsString(displayName), dwOptions);
try { WsbAssert(fromMediaSet != GUID_NULL, E_INVALIDARG); WsbAssertPointer(ppCartridge);
// Retrieve the AllocateWaitTime and RequestWaitTime parameters
DWORD size; OLECHAR tmpString[256]; DWORD allocateWaitTime; DWORD requestWaitTime;
BOOL bShortTimeout = ( dwOptions & RMS_SHORT_TIMEOUT ) ? TRUE : FALSE;
BOOL bFailOnSize = ( dwOptions & RMS_FAIL_ALLOCATE_ON_SIZE ) ? TRUE : FALSE;
if (bShortTimeout) { allocateWaitTime = RMS_DEFAULT_SHORT_WAIT_TIME; requestWaitTime = RMS_DEFAULT_SHORT_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_SHORT_WAIT_TIME, tmpString, 256, &size))) { allocateWaitTime = wcstol(tmpString, NULL, 10); requestWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("allocateWaitTime (Short) is %d milliseconds.\n"), allocateWaitTime); WsbTrace(OLESTR("RequestWaitTime (Short) is %d milliseconds.\n"), requestWaitTime); } } else { allocateWaitTime = RMS_DEFAULT_ALLOCATE_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_ALLOCATE_WAIT_TIME, tmpString, 256, &size))) { allocateWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("AllocateWaitTime is %d milliseconds.\n"), allocateWaitTime); } requestWaitTime = RMS_DEFAULT_REQUEST_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_REQUEST_WAIT_TIME, tmpString, 256, &size))) { requestWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("RequestWaitTime is %d milliseconds.\n"), requestWaitTime); } }
// Special error recovery to handle when NTMS is down, or was cycled.
do { hr = S_OK;
HANDLE hSession = m_SessionHandle; NTMS_GUID setId = fromMediaSet; NTMS_GUID partId = GUID_NULL; NTMS_GUID *pPartId = NULL; NTMS_GUID requestId;
err1 = NO_ERROR; err2 = NO_ERROR; err3 = NO_ERROR; err4 = NO_ERROR; err5 = NO_ERROR; err6 = NO_ERROR; err7 = NO_ERROR;
try {
// Look for a specific media ourselves if:
// 1. A specific capacity is required AND
// 2. We do not try to allocate a second side
if (pFreeSpace && (prevSideId == GUID_NULL)) { if (*pFreeSpace > 0) { int retry = 3; // Give the operator 3 chances to get it right!
do { // We need to allocate a unit of media that matches the capacity specified.
// However, if fail-on-size is indicated AND free media exists, we need to fail
// instead of asking the operator for free media with the required size
//
// Enumerate the partitions in the scratch pool of the same type as
// specified to find a capatible unit of media
//
BOOL bFreeMediaExists = FALSE;
// First find the media type we looking for
NTMS_OBJECTINFORMATION mediaPoolInfo; NTMS_OBJECTINFORMATION partitionInfo; HANDLE hFindPool = NULL; HANDLE hFindPart = NULL; BOOL bFound = FALSE; NTMS_GUID scratchPoolId;
err1 = NO_ERROR; err2 = NO_ERROR; err3 = NO_ERROR; err4 = NO_ERROR; err5 = NO_ERROR; err6 = NO_ERROR; err7 = NO_ERROR;
// First look in our pool for scratch media of the correct size
hr = findFirstNtmsObject(NTMS_PARTITION, setId, NULL, GUID_NULL, &hFindPart, &partitionInfo); while(S_OK == hr) { reportNtmsObjectInformation(&partitionInfo); if ((TRUE == partitionInfo.Enabled) && (NTMS_READY == partitionInfo.dwOperationalState) && (NTMS_PARTSTATE_AVAILABLE == partitionInfo.Info.Partition.State)) {
NTMS_GUID physicalPartMediaId = partitionInfo.Info.Partition.PhysicalMedia; try { // Check if the media is online and enabled
NTMS_OBJECTINFORMATION mediaPartInfo; mediaPartInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaPartInfo.dwType = NTMS_PHYSICAL_MEDIA;
// NTMS - Get physical media information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); WsbAffirmNoError( GetNtmsObjectInformation( hSession, &physicalPartMediaId, &mediaPartInfo ) );
// Check location type, if enabled & if all new
if ( (mediaPartInfo.Info.PhysicalMedia.LocationType != NTMS_UNKNOWN) && (mediaPartInfo.Enabled) ) {
// Ensure that ALL sides are not allocated yet
hr = EnsureAllSidesNotAllocated(physicalPartMediaId);
if (S_OK == hr) {
// Check required free space
if (partitionInfo.Info.Partition.Capacity.QuadPart >= *pFreeSpace) { // We'll use this unit of media.
// Save parameterers required for Allocate.
bFound = TRUE; partId = partitionInfo.ObjectGuid; pPartId = &partId; break; } else { // Track the fact that we found a free media which meets
// all criteria besides capacity
bFreeMediaExists = TRUE; } } else if (S_FALSE != hr) { WsbAffirmHr(hr); } }
} WsbCatchAndDo (hr, WsbTraceAlways(OLESTR("CRmsNTMS::Allocate: Failed to check media <%ls> hr = <%ls>\n"), WsbGuidAsString(physicalPartMediaId), WsbHrAsString(hr)); hr = S_OK; ) }
hr = findNextNtmsObject(hFindPart, &partitionInfo); } // while finding media pools
findCloseNtmsObject(hFindPart); hr = S_OK;
if (!bFound) {
// Now try the Scratch Pool
memset(&mediaPoolInfo, 0, sizeof(NTMS_OBJECTINFORMATION));
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION);
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_MEDIA_POOL)\n")); err3 = GetNtmsObjectInformation(hSession, &setId, &mediaPoolInfo); WsbAffirmNoError( err3 );
// Save the media type for the media pool
NTMS_GUID mediaTypeId = mediaPoolInfo.Info.MediaPool.MediaType;
// Find the scratch pool with the same media type
hr = findFirstNtmsObject(NTMS_MEDIA_POOL, GUID_NULL, NULL, GUID_NULL, &hFindPool, &mediaPoolInfo); while(S_OK == hr) { if ((NTMS_POOLTYPE_SCRATCH == mediaPoolInfo.Info.MediaPool.PoolType) && (mediaTypeId == mediaPoolInfo.Info.MediaPool.MediaType)) { // This is a base level scratch media pool for type we're looking for.
scratchPoolId = mediaPoolInfo.ObjectGuid;
hr = findFirstNtmsObject(NTMS_PARTITION, scratchPoolId, NULL, GUID_NULL, &hFindPart, &partitionInfo); while(S_OK == hr) { reportNtmsObjectInformation(&partitionInfo); if ((TRUE == partitionInfo.Enabled) && (NTMS_READY == partitionInfo.dwOperationalState) && (NTMS_PARTSTATE_AVAILABLE == partitionInfo.Info.Partition.State)) {
// Check if the media is online and enabled
DWORD errPart = NO_ERROR; NTMS_OBJECTINFORMATION mediaPartInfo; NTMS_GUID physicalPartMediaId = partitionInfo.Info.Partition.PhysicalMedia; mediaPartInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaPartInfo.dwType = NTMS_PHYSICAL_MEDIA;
// NTMS - Get physical media information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); errPart = GetNtmsObjectInformation( hSession, &physicalPartMediaId, &mediaPartInfo );
// Ignore error here, just don't use this partition
if (errPart == NO_ERROR) {
// Check location type and if enabled
if ( (mediaPartInfo.Info.PhysicalMedia.LocationType != NTMS_UNKNOWN) && (mediaPartInfo.Enabled) ) {
// Check required free space
if (partitionInfo.Info.Partition.Capacity.QuadPart >= *pFreeSpace) { // We'll use this unit of media.
// Save parameterers required for Allocate.
bFound = TRUE; partId = partitionInfo.ObjectGuid; pPartId = &partId; break; } else { // Track the fact that we found a free media which meets
// all criteria besides capacity
bFreeMediaExists = TRUE; } } } else { WsbTraceAlways(OLESTR("CRmsNTMS::Allocate: Failed to get object info for media <%ls> hr = <%ls>\n"), WsbGuidAsString(physicalPartMediaId), WsbHrAsString(HRESULT_FROM_WIN32(errPart))); } } hr = findNextNtmsObject(hFindPart, &partitionInfo); } // while finding media pools
findCloseNtmsObject(hFindPart); hr = S_OK; break; } hr = findNextNtmsObject(hFindPool, &mediaPoolInfo); } // while finding media pools
findCloseNtmsObject(hFindPool); hr = S_OK; }
if (bFound) { // Found free media to allocate
break; } else if (bFreeMediaExists && bFailOnSize) { // Free media exists, but not with the right capacity - fail
WsbTrace(OLESTR("CRmsNTMS::Allocate: Failing allocate request since there are free media but all with too small capacity\n")); WsbThrow(RMS_E_SCRATCH_NOT_FOUND_TOO_SMALL); } else { // No sufficient free media - submit operator request
OLECHAR * messageText = NULL; WCHAR *stringArr[2]; WCHAR capString[40]; DWORD dwMessageId;
WsbShortSizeFormat64(*pFreeSpace, capString);
stringArr[0] = mediaPoolInfo.szName; stringArr[1] = capString;
// Set which request to sumbit (with or without size specification)
if (bFailOnSize) { dwMessageId = RMS_MESSAGE_SCRATCH_MEDIA_NO_SIZE_REQUEST; } else { dwMessageId = RMS_MESSAGE_SCRATCH_MEDIA_REQUEST; }
if (0 == FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY, LoadLibraryEx( WSB_FACILITY_PLATFORM_NAME, NULL, LOAD_LIBRARY_AS_DATAFILE ), dwMessageId, MAKELANGID ( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPTSTR)&messageText, 0, (va_list *)stringArr)) { WsbTrace(OLESTR("CRmsNTMS::Allocate: FormatMessage failed: %ls\n"), WsbHrAsString(HRESULT_FROM_WIN32(GetLastError()))); }
// NTMS - Submit operator request
WsbTraceAlways(OLESTR("SubmitNtmsOperatorRequest()\n")); err5 = SubmitNtmsOperatorRequest(hSession, NTMS_OPREQ_NEWMEDIA, messageText, &scratchPoolId, NULL, &requestId); LocalFree(messageText); WsbAffirmNoError(err5);
// NTMS - Wait for operator request
WsbTraceAlways(OLESTR("WaitForNtmsOperatorRequest()\n")); err6 = WaitForNtmsOperatorRequest(hSession, &requestId, requestWaitTime); //
// !!! NOTE !!! At the time of this writting WaitForNtmsOperatorRequest
// did not return ERROR_TIMEOUT.
//
if (ERROR_TIMEOUT == err6) { // Best effort cleanup...
// NTMS - Cancel operator request
WsbTraceAlways(OLESTR("CancelNtmsOperatorRequest()\n")); err7 = CancelNtmsOperatorRequest(hSession, &requestId); } WsbAffirmNoError(err6); } WsbAssertHrOk(hr);
// At this point the operator added a compatable unit of media...
// Verify until we're exceed the retry count.
retry--; } while (retry > 0); if (0 == retry) { WsbThrow(RMS_E_SCRATCH_NOT_FOUND); } } } // NTMS - Allocate a unit of scratch media
WsbTraceAlways(OLESTR("AllocateNtmsMedia()\n"));
// Set additional allocation settings
DWORD dwAllocateOptions = 0; NTMS_GUID mediaId = prevSideId; if (mediaId == GUID_NULL) { dwAllocateOptions |= NTMS_ALLOCATE_NEW; } else { // Allocating the second side: mediaId should hold the LMID of the first side
dwAllocateOptions |= NTMS_ALLOCATE_NEXT; } if (dwOptions & RMS_ALLOCATE_NO_BLOCK) { dwAllocateOptions |= NTMS_ALLOCATE_ERROR_IF_UNAVAILABLE; allocateWaitTime = 0; }
err1 = AllocateNtmsMedia( hSession, &setId, pPartId, &mediaId, dwAllocateOptions, allocateWaitTime, NULL ); WsbAffirmNoError( err1 );
// Now get/set the various information fields for the unit of media.
DWORD sideNo = 2; NTMS_GUID side[2];
// NTMS - Enumerate the sides of a unit of media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err2 = EnumerateNtmsObject(hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0); WsbAffirmNoError( err2 );
NTMS_OBJECTINFORMATION partitionInfo; partitionInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); partitionInfo.dwType = NTMS_PARTITION;
// NTMS - Get partition information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err3 = GetNtmsObjectInformation( hSession, &side[0], &partitionInfo ); WsbAffirmNoError( err3 );
NTMS_OBJECTINFORMATION mediaInfo; NTMS_GUID physicalMediaId = partitionInfo.Info.Partition.PhysicalMedia; mediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaInfo.dwType = NTMS_PHYSICAL_MEDIA;
// NTMS - Get physical media information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); err3 = GetNtmsObjectInformation( hSession, &physicalMediaId, &mediaInfo ); WsbAffirmNoError( err3 );
NTMS_OBJECTINFORMATION logicalMediaInfo; logicalMediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); logicalMediaInfo.dwType = NTMS_LOGICAL_MEDIA;
// NTMS - Get physical media information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_LOGICAL_MEDIA)\n")); err3 = GetNtmsObjectInformation( hSession, &mediaId, &logicalMediaInfo ); WsbAffirmNoError( err3 );
// Save the capacity for the return arg.
if (pFreeSpace) { *pFreeSpace = partitionInfo.Info.Partition.Capacity.QuadPart; }
// Set name & description
CWsbStringPtr mediaDisplayName;
// Set new physical media name for first side
// Modify original name for second side
if ( !(dwAllocateOptions & NTMS_ALLOCATE_NEXT) ) { mediaDisplayName = (WCHAR *)displayName; } else { WCHAR *dashPtr = wcsrchr((WCHAR *)displayName, L'-'); mediaDisplayName = mediaInfo.szName; if (dashPtr) { WsbAffirmHr(mediaDisplayName.Append(dashPtr)); } }
// Set the Name to the displayName, only if there's no bar code.
if ( NTMS_BARCODESTATE_OK != mediaInfo.Info.PhysicalMedia.BarCodeState) { wcscpy(mediaInfo.szName, mediaDisplayName); wcscpy(partitionInfo.szName, (WCHAR *) displayName);
// NTMS doesn't allow dup logical media names. We set
// the name to the mediaId to keep it unique. The logical
// media name is not displayed in the Removable Storage UI.
CWsbStringPtr strGuid; WsbAffirmHr(WsbSafeGuidAsString(mediaId, strGuid)); wcscpy(logicalMediaInfo.szName, (WCHAR *)strGuid); }
// Set the Description to the displayName
wcscpy(logicalMediaInfo.szDescription, (WCHAR *) displayName); wcscpy(partitionInfo.szDescription, (WCHAR *) displayName); wcscpy(mediaInfo.szDescription, (WCHAR *) mediaDisplayName);
// NTMS - Set partition information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); err4 = SetNtmsObjectInformation( hSession, &side[0], &partitionInfo ); WsbAffirmNoError( err4 );
// NTMS - Set physical media information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); err4 = SetNtmsObjectInformation( hSession, &physicalMediaId, &mediaInfo ); WsbAffirmNoError( err4 );
// NTMS - Set logical media information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); err4 = SetNtmsObjectInformation( hSession, &mediaId, &logicalMediaInfo ); WsbAffirmNoError( err4 );
WsbAssertHrOk(FindCartridge(mediaId, ppCartridge)); WsbAssertHr((*ppCartridge)->SetStatus(RmsStatusScratch));
break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // AllocateNtmsMedia
switch (HRESULT_CODE(hr)) { case ERROR_TIMEOUT: case ERROR_MEDIA_UNAVAILABLE: hr = RMS_E_SCRATCH_NOT_FOUND; break;
case ERROR_CANCELLED: hr = RMS_E_CANCELLED; break;
case ERROR_MEDIA_OFFLINE: hr = RMS_E_MEDIA_OFFLINE; break;
case ERROR_REQUEST_REFUSED: hr = RMS_E_REQUEST_REFUSED; break;
case ERROR_WRITE_PROTECT: hr = RMS_E_WRITE_PROTECT; break;
case ERROR_INVALID_MEDIA_POOL: hr = RMS_E_MEDIASET_NOT_FOUND; break;
case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: case ERROR_DEVICE_NOT_AVAILABLE: case ERROR_INVALID_HANDLE: case ERROR_INVALID_MEDIA: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("AllocateNtmsMedia"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("AllocateNtmsMedia"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INSUFFICIENT_BUFFER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err3 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err4 != NO_ERROR) { // SetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_OBJECT_NOT_FOUND: case ERROR_OBJECT_ALREADY_EXISTS: // bmd: 1/18/99 - Not documented, but NTMS doesn't allow dup logical media names.
WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err5 != NO_ERROR) { // SubmitNtmsOperatorRequest
switch (HRESULT_CODE(hr)) { case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_CONNECTED: case ERROR_OBJECT_NOT_FOUND: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SubmitNtmsOperatorRequest"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SubmitNtmsOperatorRequest"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err6 != NO_ERROR) { // WaitForNtmsOperatorRequest
switch (HRESULT_CODE(hr)) { case ERROR_TIMEOUT: hr = RMS_E_TIMEOUT; break;
case ERROR_CANCELLED: hr = RMS_E_CANCELLED; break;
case ERROR_REQUEST_REFUSED: hr = RMS_E_REQUEST_REFUSED; break;
case ERROR_ACCESS_DENIED: case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_CONNECTED: case ERROR_OBJECT_NOT_FOUND: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("WaitForNtmsOperatorRequest"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("WaitForNtmsOperatorRequest"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::Allocate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMP CRmsNTMS::Mount( IN IRmsCartridge *pCart, IN OUT IRmsDrive **ppDrive, IN DWORD dwOptions OPTIONAL, IN DWORD threadId OPTIONAL)/*++
Implements:
IRmsNTMS::Mount
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR; DWORD err3 = NO_ERROR; DWORD err4 = NO_ERROR;
BOOL mediaMounted = FALSE;
BOOL bNoBlock = ( dwOptions & RMS_MOUNT_NO_BLOCK ) ? TRUE : FALSE;
// declared outside try block so it can be accessible throughout the method
DWORD sideNo = 2; NTMS_GUID side[2]; WsbTraceIn( OLESTR("CRmsNTMS::Mount"), OLESTR("") );
try { WsbAssertPointer(pCart);
CComPtr<IRmsDrive> pDrive;
// determine the timeout for the operator request
DWORD size; OLECHAR tmpString[256]; BOOL bShortTimeout = ( dwOptions & RMS_SHORT_TIMEOUT ) ? TRUE : FALSE; DWORD mountWaitTime; if (bShortTimeout) { mountWaitTime = RMS_DEFAULT_SHORT_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_SHORT_WAIT_TIME, tmpString, 256, &size))) { mountWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("MountWaitTime (Short) is %d milliseconds.\n"), mountWaitTime); } } else { mountWaitTime = RMS_DEFAULT_MOUNT_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_MOUNT_WAIT_TIME, tmpString, 256, &size))) { mountWaitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("MountWaitTime is %d milliseconds.\n"), mountWaitTime); } }
NTMS_OBJECTINFORMATION driveInfo; memset( &driveInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
// Special error recovery to handle when NTMS is down, or was cycled.
do { hr = S_OK;
HANDLE hSession = m_SessionHandle;
NTMS_GUID mediaId = GUID_NULL; WsbAffirmHr(pCart->GetCartridgeId(&mediaId)); WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
err1 = NO_ERROR; err2 = NO_ERROR; err3 = NO_ERROR;
try {
// NTMS - enumerate the sides of a unit of media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject( hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0 ); WsbAffirmNoError( err1 );
DWORD count = 1; NTMS_GUID driveId;
// NTMS - issue mount request
WsbTraceAlways(OLESTR("MountNtmsMedia()\n")); DWORD dwOpt = NTMS_MOUNT_READ | NTMS_MOUNT_WRITE; if (bNoBlock) { dwOpt |= (NTMS_MOUNT_ERROR_NOT_AVAILABLE | NTMS_MOUNT_ERROR_OFFLINE); } if (dwOptions & RMS_USE_MOUNT_NO_DEADLOCK) { /*
DEADLOCK AVOIDANCE: when RSM support for MountNtmsMediaDA is in, the next line should be uncommented, and the other 2 lines in this 'if' block should be removed. err2 = MountNtmsMediaDA( hSession, &side[0], &driveId, count, dwOpt, NTMS_PRIORITY_NORMAL, mountWaitTime, NULL, &threadId, 1); */ UNREFERENCED_PARAMETER(threadId); err2 = MountNtmsMedia( hSession, &side[0], &driveId, count, dwOpt, NTMS_PRIORITY_NORMAL, mountWaitTime, NULL); } else { err2 = MountNtmsMedia( hSession, &side[0], &driveId, count, dwOpt, NTMS_PRIORITY_NORMAL, mountWaitTime, NULL);
} WsbAffirmNoError( err2 ); mediaMounted = TRUE;
//
// We now need two critical pieces of information. The Device name and
// the kind of media we just mounted. This gives use the essential information
// to create a data mover. Since we drill through NTMS to get this information
// we also create cartridge, drive objects.
//
driveInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); driveInfo.dwType = NTMS_DRIVE;
// NTMS - get drive information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_DRIVE)\n")); err3 = GetNtmsObjectInformation( hSession, &driveId, &driveInfo ); WsbAffirmNoError( err3 ); break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
RmsMedia mediaType; WsbAffirmHr(pCart->GetType((LONG *)&mediaType));
// Create Drive
WsbAssertHr(CoCreateInstance(CLSID_CRmsDrive, 0, CLSCTX_SERVER, IID_IRmsDrive, (void **)&pDrive));
CComQIPtr<IRmsChangerElement, &IID_IRmsChangerElement> pElmt = pDrive;
WsbAssertHr(pElmt->SetMediaSupported(mediaType));
CComQIPtr<IRmsDevice, &IID_IRmsDevice> pDevice = pDrive;
WsbAssertHr(pDevice->SetDeviceAddress( (BYTE) driveInfo.Info.Drive.ScsiPort, (BYTE) driveInfo.Info.Drive.ScsiBus, (BYTE) driveInfo.Info.Drive.ScsiTarget, (BYTE) driveInfo.Info.Drive.ScsiLun));
CWsbBstrPtr deviceName = driveInfo.Info.Drive.szDeviceName;
////////////////////////////////////////////////////////////////////////////////////////
// Convert the NTMS device name to something usable.
//
switch (mediaType) { case RmsMediaOptical: case RmsMediaDVD: case RmsMediaDisk: { // We need to convert \\.\PhysicalDriveN to something accessible by the file system.
WCHAR *szDriveLetter = NULL; WCHAR *szVolumeName = NULL; err4 = GetVolumesFromDrive( (WCHAR *)deviceName, &szVolumeName, &szDriveLetter ); if (szVolumeName) { delete [] szVolumeName; // don't need it for now
} if (NO_ERROR == err4) { if (szDriveLetter) { deviceName = szDriveLetter; } else { WsbTraceAlways(OLESTR("CRmsNTMS::Mount: GetVolumesFromDrive succeeded but output drive is NULL !!\n")); WsbThrow(RMS_E_RESOURCE_UNAVAILABLE); } } if (szDriveLetter) { delete [] szDriveLetter; } WsbAffirmNoError( err4 ); WsbTrace(OLESTR("CRmsNTMS::Mount: device name after convert is %s\n"), (WCHAR *)deviceName); } break;
default: break; } ////////////////////////////////////////////////////////////////////////////////////////
WsbAssertHr(pDevice->SetDeviceName(deviceName));
WsbAssertHr(pCart->SetDrive(pDrive));
// Fill in the return arguments.
*ppDrive = pDrive; pDrive.p->AddRef();
} WsbCatchAndDo(hr, // Process the exception
if (err1 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INSUFFICIENT_BUFFER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // MountNtmsMedia
switch (HRESULT_CODE(hr)) { case ERROR_TIMEOUT: hr = RMS_E_CARTRIDGE_UNAVAILABLE; break;
case ERROR_CANCELLED: hr = RMS_E_CANCELLED; break;
case ERROR_MEDIA_OFFLINE: hr = RMS_E_MEDIA_OFFLINE; if (bNoBlock) { DWORD errSub = NO_ERROR;
try { // Since we are not blocking for NTMS to ask the operator
// to mount the offline media, we do it ourselves
// create operator message
CWsbBstrPtr cartridgeName = ""; CWsbBstrPtr cartridgeDesc = ""; OLECHAR * messageText = NULL; WCHAR *stringArr[2];
cartridgeName.Free(); WsbAffirmHr(pCart->GetName(&cartridgeName)); cartridgeDesc.Free(); WsbAffirmHr(pCart->GetDescription(&cartridgeDesc)); stringArr[0] = (WCHAR *) cartridgeName; stringArr[1] = (WCHAR *) cartridgeDesc;
if (0 == FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY, LoadLibraryEx( WSB_FACILITY_PLATFORM_NAME, NULL, LOAD_LIBRARY_AS_DATAFILE ), RMS_MESSAGE_OFFLINE_MEDIA_REQUEST, MAKELANGID ( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPTSTR)&messageText, 0, (va_list *)stringArr)) { WsbTrace(OLESTR("CRmsNTMS::Mount: FormatMessage failed: %ls\n"), WsbHrAsString(HRESULT_FROM_WIN32(GetLastError()))); messageText = NULL; }
NTMS_GUID mediaId = GUID_NULL; NTMS_GUID libId = GUID_NULL; NTMS_GUID requestId = GUID_NULL; WsbAffirmHr(pCart->GetCartridgeId(&mediaId)); WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
// Library Id should be gathered here - need to clarify why
// does the GetHome return a null id !!!
// WsbAffirmHr(pCart->GetHome(NULL, &libId, NULL, NULL, NULL, NULL, NULL, NULL));
// WsbAssert(libId != GUID_NULL, E_INVALIDARG);
// submit operator request
errSub = SubmitNtmsOperatorRequest(m_SessionHandle, NTMS_OPREQ_MOVEMEDIA, messageText, &mediaId, &libId, &requestId); LocalFree(messageText); WsbAffirmNoError (errSub);
} WsbCatchAndDo(hr, // Process the error of the Corrective Action
if (errSub != NO_ERROR ) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SubmitNtmsOperatorRequest"), OLESTR(""), WsbHrAsString(hr), NULL); }
// place back the original mane error
hr = RMS_E_MEDIA_OFFLINE; ); } break;
case ERROR_REQUEST_REFUSED: hr = RMS_E_REQUEST_REFUSED; break;
case ERROR_WRITE_PROTECT: hr = RMS_E_WRITE_PROTECT; break;
case ERROR_INVALID_STATE: case ERROR_INVALID_DRIVE: { // when performing NTMS mount in non-blocking mode , this error may
// just mean that a corrective action such as drive cleaning should
// be performed before mounting (note that ONLY when not blocking,
// NTMS can not instruct corrective actions by itself)
if (bNoBlock) { try { CWsbBstrPtr cartridgeName = ""; CWsbBstrPtr cartridgeDesc = ""; cartridgeName.Free(); WsbAffirmHr(pCart->GetName(&cartridgeName)); cartridgeDesc.Free(); WsbAffirmHr(pCart->GetDescription(&cartridgeDesc)); WsbLogEvent(RMS_MESSAGE_DRIVE_NOT_AVAILABLE, 0, NULL, (WCHAR *) cartridgeName, (WCHAR *) cartridgeDesc, NULL);
} WsbCatch(hr);
break; } } case ERROR_RESOURCE_DISABLED: { // Check if the the media (cartridge) is disabled - different error should
// be returned for media and for other resources (library, drive, etc.)
HRESULT hrOrg = hr; DWORD errSub1 = NO_ERROR; DWORD errSub2 = NO_ERROR; try { // get physical media information
NTMS_OBJECTINFORMATION objectInfo; objectInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); objectInfo.dwType = NTMS_PARTITION; WsbAssert(side[0] != GUID_NULL, E_INVALIDARG); errSub1 = GetNtmsObjectInformation( m_SessionHandle, &side[0], &objectInfo ); WsbAffirmNoError (errSub1);
NTMS_GUID physicalMediaId = objectInfo.Info.Partition.PhysicalMedia; WsbAssert(physicalMediaId != GUID_NULL, E_INVALIDARG); objectInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); objectInfo.dwType = NTMS_PHYSICAL_MEDIA; errSub2 = GetNtmsObjectInformation( m_SessionHandle, &physicalMediaId, &objectInfo ); WsbAffirmNoError (errSub2);
// set our dedicated error only if (physical) media is disabled
if (! objectInfo.Enabled) { hr = RMS_E_CARTRIDGE_DISABLED; }
} WsbCatchAndDo(hr, // Process the error of the get-info requests
if (errSub1 != NO_ERROR ) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation (Partition)"), OLESTR(""), WsbHrAsString(hr), NULL); } else if (errSub2 != NO_ERROR ) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation (Physical Media)"), OLESTR(""), WsbHrAsString(hr), NULL); }
// place back the original mane error
hr = hrOrg; ); break; }
case ERROR_ACCESS_DENIED: case ERROR_BUSY: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: case ERROR_DRIVE_MEDIA_MISMATCH: case ERROR_INVALID_LIBRARY: case ERROR_INVALID_MEDIA: case ERROR_NOT_ENOUGH_MEMORY: { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("MountNtmsMedia"), OLESTR(""), WsbHrAsString(hr), NULL); break; } default: { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("MountNtmsMedia"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } } else if (err3 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err4 != NO_ERROR) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetVolumesFromDrive"), OLESTR("Unexpected Failure: "), WsbHrAsString(hr), NULL); }
if (mediaMounted) { // Something failed after the mount completed, so need to clean up...
// Dismount the media to release the resource before returning.
Dismount(pCart, FALSE); } );
WsbTraceOut( OLESTR("CRmsNTMS::Mount"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMP CRmsNTMS::Dismount( IN IRmsCartridge *pCart, IN DWORD dwOptions)/*++
Implements:
IRmsNTMS::Dismount
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR;
WsbTraceIn( OLESTR("CRmsNTMS::Dismount"), OLESTR("") );
try { WsbAssertPointer(pCart);
do { hr = S_OK;
HANDLE hSession = m_SessionHandle;
NTMS_GUID mediaId = GUID_NULL; WsbAffirmHr(pCart->GetCartridgeId(&mediaId)); WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
NTMS_GUID side[2]; DWORD sideNo = 2;
err1 = NO_ERROR; err2 = NO_ERROR;
try {
// NTMS - enumerate the sides of a unit of media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject( hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0 ); WsbAffirmNoError( err1 );
// NTMS - dismount media
DWORD dwNtmsOptions = 0; WsbTraceAlways(OLESTR("DismountNtmsMedia()\n")); if (! ( dwOptions & RMS_DISMOUNT_IMMEDIATE )) { dwNtmsOptions |= NTMS_DISMOUNT_DEFERRED; } err2 = DismountNtmsMedia( hSession, &side[0], 1, dwNtmsOptions );#ifdef DBG
// TODO: Remove this trap for the unexpected ERROR_ACCESS_DENIED error.
WsbAssert(err2 != ERROR_ACCESS_DENIED, HRESULT_FROM_WIN32(err2));#endif
WsbAffirmNoError( err2 );
// Since RSM Dismount is asyncronous, we may need to wait some arbitrary time,
// in order that when we come back, the media is really dismounted
if ( (dwOptions & RMS_DISMOUNT_DEFERRED_ONLY) && (!(dwOptions & RMS_DISMOUNT_IMMEDIATE)) ) { CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; if (S_OK == pServer->IsReady()) { DWORD size; OLECHAR tmpString[256]; DWORD waitTime = RMS_DEFAULT_AFTER_DISMOUNT_WAIT_TIME; if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_AFTER_DISMOUNT_WAIT_TIME, tmpString, 256, &size))) { waitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("AfterDismountWaitTime is %d milliseconds.\n"), waitTime); }
Sleep(waitTime); } }
break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_OBJECT_NOT_FOUND: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INSUFFICIENT_BUFFER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // DismountNtmsMedia
switch (HRESULT_CODE(hr)) { case ERROR_MEDIA_OFFLINE: hr = RMS_E_MEDIA_OFFLINE; break;
case ERROR_TIMEOUT: case ERROR_INVALID_MEDIA: case ERROR_INVALID_LIBRARY: case ERROR_DEVICE_NOT_AVAILABLE: case ERROR_MEDIA_NOT_AVAILABLE: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INVALID_STATE: case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("DismountNtmsMedia"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("DismountNtmsMedia"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut( OLESTR("CRmsNTMS::Dismount"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMP CRmsNTMS::Deallocate( IN IRmsCartridge *pCart)/*++
Implements:
IRmsNTMS::DeallocateMedia
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR; DWORD err3 = NO_ERROR; DWORD err4 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::Deallocate"), OLESTR(""));
try { WsbAssertPointer(pCart);
do { hr = S_OK;
HANDLE hSession = m_SessionHandle;
NTMS_GUID mediaId = GUID_NULL; WsbAffirmHr(pCart->GetCartridgeId(&mediaId)); WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
err1 = NO_ERROR; err2 = NO_ERROR; err3 = NO_ERROR; err4 = NO_ERROR;
NTMS_OBJECTINFORMATION partitionInfo; memset( &partitionInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
DWORD sideNo = 2; NTMS_GUID side[2];
try { // NTMS - enumerate the sides of a unit of media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject( hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0 ); WsbAffirmNoError( err1 );
// NTMS - get partition information
partitionInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); partitionInfo.dwType = NTMS_PARTITION;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err2 = GetNtmsObjectInformation( hSession, &side[0], &partitionInfo ); WsbAffirmNoError( err2 );
// NULL the Description
wcscpy(partitionInfo.szDescription, L"");
// NTMS - Set partition information.
WsbTraceAlways(OLESTR("SetNtmsObjectInformation()\n")); err3 = SetNtmsObjectInformation( hSession, &side[0], &partitionInfo ); WsbAffirmNoError( err3 );
// NTMS - deallocate media
WsbTraceAlways(OLESTR("DeallocateNtmsMedia()\n")); err4 = DeallocateNtmsMedia( hSession, &mediaId, 0 ); WsbAffirmNoError( err4 );
break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INSUFFICIENT_BUFFER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err3 != NO_ERROR) { // SetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_OBJECT_NOT_FOUND: case ERROR_OBJECT_ALREADY_EXISTS: // bmd: 1/18/99 - Not documented, but NTMS doesn't allow dup logical media names.
WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err4 != NO_ERROR) { // DeallocateNtmsMedia
switch (HRESULT_CODE(hr)) { case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_INVALID_MEDIA: //case ERROR_INVALID_PARTITION:
case ERROR_NOT_ENOUGH_MEMORY: case ERROR_DATABASE_FAILURE: case ERROR_DATABASE_FULL: case ERROR_ACCESS_DENIED: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("DeallocateNtmsMedia"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("DeallocateNtmsMedia"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::Deallocate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMPCRmsNTMS::UpdateOmidInfo( IN REFGUID cartId, IN BYTE *pBuffer, IN LONG size, IN LONG type)/*++
Implements:
IRmsNTMS::UpdateOmidInfo
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR;
WsbTraceIn( OLESTR("CRmsNTMS::UpdateOmidInfo"), OLESTR("<%ls> <0x%08x> <%d>"), WsbGuidAsString(cartId), pBuffer, size );
try { WsbAssert(cartId != GUID_NULL, E_INVALIDARG); WsbAssertPointer(pBuffer); WsbAssert(size > 0, E_INVALIDARG);
WsbTraceBuffer(size, pBuffer);
do { hr = S_OK;
HANDLE hSession = m_SessionHandle; NTMS_GUID mediaId = cartId;
err1 = NO_ERROR;
try {
// NTMS - update on media information.
WsbTraceAlways(OLESTR("UpdateNtmsOmidInfo()\n")); switch((RmsOnMediaIdentifier)type) { case RmsOnMediaIdentifierMTF: err1 = UpdateNtmsOmidInfo(hSession, &mediaId, NTMS_OMID_TYPE_RAW_LABEL, size, pBuffer); break; case RmsOnMediaIdentifierWIN32: WsbAssert(size == sizeof(NTMS_FILESYSTEM_INFO), E_UNEXPECTED); err1 = UpdateNtmsOmidInfo(hSession, &mediaId, NTMS_OMID_TYPE_FILESYSTEM_INFO, size, pBuffer); break; default: WsbThrow(E_UNEXPECTED); } WsbAffirmNoError( err1 ); break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // UpdateNtmsOmidInfo
switch (HRESULT_CODE(hr)) { case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_INVALID_HANDLE: case ERROR_INVALID_MEDIA: //case ERROR_INVALID_PARTITION:
case ERROR_INVALID_PARAMETER: case ERROR_NOT_CONNECTED: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("UpdateNtmsOmidInfo"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("UpdateNtmsOmidInfo"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut( OLESTR("CRmsNTMS::UpdateOmidInfo"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMPCRmsNTMS::GetBlockSize( IN REFGUID cartId, OUT LONG *pBlockSize )/*++
Implements:
IRmsNTMS::GetBlockSize
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::GetBlockSize"), OLESTR("<%ls> <x%08x>"), WsbGuidAsString(cartId), pBlockSize);
try { WsbAssertPointer(pBlockSize);
do { hr = S_OK; err1 = NO_ERROR;
HANDLE hSession = m_SessionHandle; NTMS_GUID mediaId = cartId;
DWORD nBlockSize; DWORD sizeOfBlockSize = sizeof(DWORD); try {
err1 = GetNtmsObjectAttribute(hSession, &mediaId, NTMS_LOGICAL_MEDIA, OLESTR("BlockSize"), (LPVOID) &nBlockSize, &sizeOfBlockSize); WsbAffirmNoError(err1); *pBlockSize = (LONG) nBlockSize; break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // GetNtmsObjectAttribute
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: // Don't log this error. Attribute doesn't
break; // exist for new media. We skip this error
// and let the caller deal with it.
case ERROR_DATABASE_FAILURE: // Log these errors.
case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case ERROR_INSUFFICIENT_BUFFER: case ERROR_NO_DATA: case ERROR_INVALID_PARAMETER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectAttribute"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectAttribute"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::GetBlockSize"), OLESTR("hr = <%ls>, BlockSize = <%d>"), WsbHrAsString(hr), *pBlockSize);
return hr;}
STDMETHODIMPCRmsNTMS::SetBlockSize( IN REFGUID cartId, IN LONG blockSize )/*++
Implements:
IRmsNTMS::SetBlockSize
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::SetBlockSize"), OLESTR("<%ls> <%d>"), WsbGuidAsString(cartId), blockSize);
try {
do { hr = S_OK; err1 = NO_ERROR;
HANDLE hSession = m_SessionHandle; NTMS_GUID mediaId = cartId;
DWORD nBlockSize = blockSize; DWORD sizeOfBlockSize = sizeof(DWORD);
try {
err1 = SetNtmsObjectAttribute(hSession, &mediaId, NTMS_LOGICAL_MEDIA, OLESTR("BlockSize"), (LPVOID) &nBlockSize, sizeOfBlockSize); WsbAffirmNoError(err1); break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // SetNtmsObjectAttribute
switch (HRESULT_CODE(hr)) { case ERROR_DATABASE_FAILURE: case ERROR_INVALID_HANDLE: case ERROR_INSUFFICIENT_BUFFER: case ERROR_NOT_CONNECTED: case ERROR_NO_DATA: case ERROR_INVALID_PARAMETER: case ERROR_OBJECT_NOT_FOUND: case ERROR_INVALID_NAME: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectAttribute"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("SetNtmsObjectAttribute"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::SetBlockSize"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
HRESULTCRmsNTMS::changeState( IN LONG newState )/*++
Routine Description:
Changes the state of the NTMS object.
Arguments:
None.
Return Values:
S_OK - Success.
--*/{
HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::changeState"), OLESTR("<%d>"), newState);
try {
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = this; WsbAssertPointer( pObject );
// TODO: Validate the state change
WsbAffirmHr(pObject->SetState(newState));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::changeState"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMPCRmsNTMS::ExportDatabase(void)/*++
Implements:
CRmsNTMS::ExportDatabase
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR;
WsbTraceIn( OLESTR("CRmsNTMS::ExportDatabase"), OLESTR(""));
try {
do { hr = S_OK;
HANDLE hSession = m_SessionHandle; err1 = NO_ERROR;
try {
err1 = ExportNtmsDatabase(hSession); WsbAffirmNoError(err1); break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running
case RPC_S_CALL_FAILED_DNE: // Media Services is up, handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { // ExportNtmsDatabase
switch (HRESULT_CODE(hr)) { case ERROR_ACCESS_DENIED: case ERROR_DATABASE_FAILURE: case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("ExportNtmsDatabase"), OLESTR(""), WsbHrAsString(hr), NULL); break; default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("ExportNtmsDatabase"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::ExportDatabase"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMPCRmsNTMS::FindCartridge( IN REFGUID cartId, OUT IRmsCartridge **ppCartridge)/*++
Implements:
CRmsNTMS::FindCartridge
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR;
WsbTraceIn( OLESTR("CRmsNTMS::FindCartridge"), OLESTR("<%ls> <0x%08x>"), WsbGuidAsString(cartId), ppCartridge);
try { WsbAssert(cartId != GUID_NULL, E_INVALIDARG); WsbAssertPointer(ppCartridge);
NTMS_OBJECTINFORMATION partitionInfo; memset( &partitionInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
NTMS_OBJECTINFORMATION mediaInfo; memset( &mediaInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
NTMS_OBJECTINFORMATION mediaTypeInfo; memset( &mediaTypeInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
NTMS_OBJECTINFORMATION libraryInfo; memset( &libraryInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
NTMS_OBJECTINFORMATION logicalMediaInfo; memset( &logicalMediaInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
RmsMedia translatedMediaType = RmsMediaUnknown;
// Special error recovery to handle when NTMS is down, or was cycled.
do { hr = S_OK;
HANDLE hSession = m_SessionHandle; NTMS_GUID mediaId = cartId; DWORD sideNo = 2; NTMS_GUID side[2];
err1 = NO_ERROR; err2 = NO_ERROR;
try {
// NTMS - enumerate the sides of a unit of media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject( hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0 ); WsbAffirmNoError( err1 );
// NTMS - get partition information
partitionInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); partitionInfo.dwType = NTMS_PARTITION;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err2 = GetNtmsObjectInformation( hSession, &side[0], &partitionInfo ); WsbAffirmNoError( err2 );
// NTMS - get physical media information
NTMS_GUID physicalMediaId = partitionInfo.Info.Partition.PhysicalMedia;
mediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaInfo.dwType = NTMS_PHYSICAL_MEDIA;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); err2 = GetNtmsObjectInformation( hSession, &physicalMediaId, &mediaInfo ); WsbAffirmNoError( err2);
// NTMS - get media type information
NTMS_GUID mediaTypeId = mediaInfo.Info.PhysicalMedia.MediaType;
mediaTypeInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaTypeInfo.dwType = NTMS_MEDIA_TYPE;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_MEDIA_TYPE)\n")); err2 = GetNtmsObjectInformation( hSession, &mediaTypeId, &mediaTypeInfo ); WsbAffirmNoError( err2 );
// Translate the NTMS media type into something understood by RMS
storageMediaTypeToRmsMedia(&(mediaTypeInfo.Info.MediaType), &translatedMediaType);
// NTMS - get logical media information
logicalMediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); logicalMediaInfo.dwType = NTMS_LOGICAL_MEDIA;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_LOGICAL_MEDIA)\n")); err2 = GetNtmsObjectInformation( hSession, &mediaId, &logicalMediaInfo ); WsbAffirmNoError( err2 );
// NTMS - get library information
NTMS_GUID libraryId = mediaInfo.Info.PhysicalMedia.CurrentLibrary;
libraryInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); libraryInfo.dwType = NTMS_LIBRARY;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_LIBRARY)\n")); err2 = GetNtmsObjectInformation( hSession, &libraryId, &libraryInfo ); WsbAffirmNoError( err2 );
break;
} WsbCatchAndDo(hr, switch (HRESULT_CODE(hr)) { case ERROR_INVALID_HANDLE: case ERROR_NOT_CONNECTED: case RPC_S_SERVER_UNAVAILABLE: // Media Services is not running.
case RPC_S_CALL_FAILED_DNE: // Media Services is up; handle is not valid.
case RPC_S_CALL_FAILED: // Media Services crashed.
WsbAffirmHr(beginSession()); continue; } WsbThrow(hr); ); } while(1);
// Create Cartridge
IRmsCartridge *pCart = 0; WsbAssertHr(CoCreateInstance(CLSID_CRmsCartridge, 0, CLSCTX_SERVER, IID_IRmsCartridge, (void **)&pCart));
// Fill in the object data
// The media Name is what is displaye by NTMS UI
CWsbBstrPtr name = mediaInfo.szName; WsbAffirmHr(pCart->SetName(name));
// The partition Description is what is displayed by NTMS UI.
CWsbBstrPtr desc = partitionInfo.szDescription; WsbAffirmHr(pCart->SetDescription(desc));
WsbAffirmHr(pCart->SetCartridgeId(cartId));
CWsbBstrPtr barCode = mediaInfo.Info.PhysicalMedia.szBarCode; CWsbBstrPtr seqNo = mediaInfo.Info.PhysicalMedia.szSequenceNumber; // Not used
WsbAffirmHr(pCart->SetTagAndNumber(barCode, 0));
WsbAffirmHr(pCart->SetType((LONG) translatedMediaType));
switch (mediaInfo.Info.PhysicalMedia.MediaState) { case NTMS_MEDIASTATE_IDLE: case NTMS_MEDIASTATE_UNLOADED: WsbAffirmHr(pCart->SetIsAvailable(TRUE)); break;
default: WsbAffirmHr(pCart->SetIsAvailable(FALSE)); break; } RmsElement type = RmsElementUnknown;
if ( NTMS_LIBRARYTYPE_ONLINE == libraryInfo.Info.Library.LibraryType ) {
switch (mediaInfo.Info.PhysicalMedia.LocationType) { case NTMS_STORAGESLOT: type = RmsElementStorage; break;
case NTMS_DRIVE: type = RmsElementDrive; break;
case NTMS_IEPORT: type = RmsElementIEPort; break;
case NTMS_CHANGER: type = RmsElementChanger; break;
default: type = RmsElementUnknown; break; } } else if ( NTMS_LIBRARYTYPE_STANDALONE == libraryInfo.Info.Library.LibraryType ) {
switch (mediaInfo.Info.PhysicalMedia.LocationType) { case NTMS_DRIVE: type = RmsElementDrive; break;
default: type = RmsElementUnknown; break; } } else { type = RmsElementShelf; }
WsbAffirmHr(pCart->SetLocation(type, mediaInfo.Info.PhysicalMedia.CurrentLibrary, logicalMediaInfo.Info.LogicalMedia.MediaPool, 0, 0, 0, 0, 0));
WsbAffirmHr(pCart->SetManagedBy((LONG)RmsMediaManagerNTMS));
WsbAssertHr(pCart->SetStatus(RmsStatusPrivate));
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObj = pCart; if (!mediaInfo.Enabled) { WsbAffirmHr(pObj->Disable(RMS_E_CARTRIDGE_DISABLED)); }
CComQIPtr<IRmsStorageInfo, &IID_IRmsStorageInfo> pInfo = pCart; WsbAffirmHr(pInfo->SetCapacity(partitionInfo.Info.Partition.Capacity.QuadPart));
WsbTrace(OLESTR("Cartridge id <name/desc>: %ls <%ls/%ls>\n"), WsbGuidAsString(cartId), (WCHAR *) name, (WCHAR *) desc); WsbTrace(OLESTR("Cartridge <barCode/seqNo>: <%ls/%ls>\n"), (WCHAR *) barCode, (WCHAR *) seqNo ); WsbTrace(OLESTR("Cartridge Enabled: %ls\n"), WsbHrAsString(pObj->IsEnabled())); WsbTrace(OLESTR("Cartridge type: %d\n"), translatedMediaType); WsbTrace(OLESTR("Cartridge capacity: %I64d\n"), partitionInfo.Info.Partition.Capacity.QuadPart); WsbTrace(OLESTR("Cartridge domain: %ls\n"), WsbGuidAsString(logicalMediaInfo.Info.LogicalMedia.MediaPool));
if (mediaInfo.Info.PhysicalMedia.MediaPool != logicalMediaInfo.Info.LogicalMedia.MediaPool) { CWsbStringPtr idPhysical = mediaInfo.Info.PhysicalMedia.CurrentLibrary; CWsbStringPtr idLogical = logicalMediaInfo.Info.LogicalMedia.MediaPool; WsbTraceAlways(OLESTR("CRmsNTMS::FindCartridge - Media Pool Id mismatch %ls != %ls\n"), idPhysical, idLogical ); }
// Fill in the return argument.
*ppCartridge = pCart;
} WsbCatchAndDo( hr, WsbTrace(OLESTR("CRmsNTMS::FindCartridge - %ls Not Found. hr = <%ls>\n"),WsbGuidAsString(cartId),WsbHrAsString(hr)); if (err1 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INSUFFICIENT_BUFFER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Undocumented Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut( OLESTR("CRmsNTMS::FindCartridge"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMPCRmsNTMS::Suspend(void)/*++
Implements:
CRmsNTMS::Suspend
--*/{ HRESULT hr = S_OK;
WsbTraceIn( OLESTR("CRmsNTMS::Suspend"), OLESTR(""));
try {
WsbAffirmHr(changeState(RmsNtmsStateSuspending)); WsbAffirmHr(endSession()); WsbAffirmHr(changeState(RmsNtmsStateSuspended));
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::Suspend"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
STDMETHODIMPCRmsNTMS::Resume(void)/*++
Implements:
CRmsNTMS::Resume
--*/{ HRESULT hr = S_OK;
WsbTraceIn( OLESTR("CRmsNTMS::Resume"), OLESTR(""));
try {
WsbAffirmHr(changeState(RmsNtmsStateResuming)); WsbAffirmHr(beginSession()); WsbAffirmHr(changeState(RmsNtmsStateReady));
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::Resume"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULT CRmsNTMS::InitializeInAnotherThread(void){ HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::InitializeInAnotherThread"), OLESTR(""));
try {
DWORD threadId; HANDLE hThread; CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; WsbAffirmHr( pServer->ChangeState( RmsServerStateInitializing )); WsbAffirmHandle(hThread = CreateThread(NULL, 1024, CRmsNTMS::InitializationThread, this, 0, &threadId)); CloseHandle(hThread);
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::InitializeInAnotherThread"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
DWORD WINAPICRmsNTMS::InitializationThread( IN LPVOID pv){ HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::InitializationThread"), OLESTR(""));
try { WsbAssertPointer(pv); CRmsNTMS *pNTMS = (CRmsNTMS*)pv; WsbAffirmHr(pNTMS->Initialize()); CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; WsbAffirmHr( pServer->ChangeState( RmsServerStateReady ));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::InitializationThread"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr; }
HRESULTCRmsNTMS::isReady(void){
HRESULT hr = S_OK;
try {
BOOL isEnabled; HRESULT status; RmsServerState state;
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = this; WsbAssertPointer( pObject );
WsbAffirmHr( isEnabled = pObject->IsEnabled()); WsbAffirmHr( pObject->GetState( (LONG *)&state )); WsbAffirmHr( pObject->GetStatusCode( &status ));
if ( S_OK == isEnabled ) { if ( RmsServerStateReady == state ) { hr = S_OK; } else { if ( S_OK == status ) { WsbThrow(E_UNEXPECTED); } else { WsbThrow(status); } } } else { if ( S_OK == status ) { WsbThrow(E_UNEXPECTED); } else { WsbThrow(status); } }
} WsbCatch(hr);
return hr;}
HRESULTCRmsNTMS::setPoolDACL ( IN OUT NTMS_GUID *pPoolId, IN DWORD subAuthority, IN DWORD action, IN DWORD mask)
{
HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::SetPoolDACL"), OLESTR("%ls <%d> <%d> <%d>"), WsbGuidAsString(*pPoolId), subAuthority, action, mask);
PSID psidAccount = NULL; PSECURITY_DESCRIPTOR psdRePoolSd = NULL;
try {
SID_IDENTIFIER_AUTHORITY ntauth = SECURITY_NT_AUTHORITY; DWORD errCode = NO_ERROR, sizeTry = 5, sizeReturned = 0; PACL paclDis = NULL; BOOL daclPresent = FALSE, daclDefaulted = FALSE; HANDLE hSession = m_SessionHandle;
WsbAffirmStatus(AllocateAndInitializeSid(&ntauth, 2, SECURITY_BUILTIN_DOMAIN_RID, subAuthority, 0, 0, 0, 0, 0, 0, &psidAccount));
//Get the security descriptor for the pool
for (;;) { if (psdRePoolSd != NULL) { free(psdRePoolSd); } psdRePoolSd = (PSECURITY_DESCRIPTOR)malloc(sizeTry); WsbAffirm(NULL != psdRePoolSd, E_OUTOFMEMORY);
errCode = GetNtmsObjectSecurity(hSession, pPoolId, NTMS_MEDIA_POOL, DACL_SECURITY_INFORMATION, psdRePoolSd, sizeTry, &sizeReturned);
if (errCode == ERROR_SUCCESS) { break; } else if (errCode == ERROR_INSUFFICIENT_BUFFER) { sizeTry = sizeReturned; continue; } else { WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectSecurity"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL ); WsbAffirmNoError(errCode); } }
// Get a pointer to the DACL
WsbAffirmStatus(GetSecurityDescriptorDacl(psdRePoolSd, &daclPresent, &paclDis, &daclDefaulted));
// Go through the DACL and change the mask of the ACE that matches the SID
for (DWORD i = 0;i < paclDis->AceCount; ++i) {
// Get the ACE and its header
LPVOID pAce = NULL; WsbAffirmStatus(GetAce(paclDis, i, &pAce)); ACE_HEADER * pAceHeader = (ACE_HEADER*) pAce; // Ignore non-allowed ACEs - BUG 584785
if (pAceHeader->AceType != ACCESS_ALLOWED_ACE_TYPE) continue;
// Take out the flags
ACCESS_ALLOWED_ACE *pAccessAllowedAce = (ACCESS_ALLOWED_ACE *)pAce; if (EqualSid(psidAccount, &(pAccessAllowedAce->SidStart))) { if (action == ADD_ACE_MASK_BITS) { pAccessAllowedAce->Mask |= mask; } else { pAccessAllowedAce->Mask &= ~mask; } } }
// Set the pool security descriptor
errCode = SetNtmsObjectSecurity(hSession, pPoolId, NTMS_MEDIA_POOL, DACL_SECURITY_INFORMATION, psdRePoolSd); WsbAffirmNoError(errCode);
} WsbCatch(hr);
if (psdRePoolSd) { free(psdRePoolSd); }
if (psidAccount) { FreeSid(psidAccount); }
WsbTraceOut(OLESTR("CRmsNTMS::SetPoolDACL"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
HRESULTCRmsNTMS::IsMediaCopySupported ( IN REFGUID mediaPoolId){
HRESULT hr = S_OK; WsbTraceIn(OLESTR("CRmsNTMS::IsMediaCopySupported"), OLESTR("%ls"), WsbGuidAsString(mediaPoolId));
try {
// If we can find two drives that support this media type then
// the media copy operation is supported.
// For each drive known to NTMS we need to find what media types
// it supports. NTMS doesn't keep media type information for the
// drive, but assumes homogeneous drives in a library (per HighGound) -
// so detecting this is a bit convoluted.
// we'll search through each library and find the media types
// supported, and count the number of drives in the library.
if ( INVALID_HANDLE_VALUE == m_SessionHandle ) { WsbAffirmHr(beginSession()); }
HANDLE hSession = m_SessionHandle;
NTMS_OBJECTINFORMATION mediaPoolInfo; NTMS_GUID poolId = mediaPoolId;
memset(&mediaPoolInfo, 0, sizeof(NTMS_OBJECTINFORMATION));
mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION);
// NTMS - Get Media Pool Information
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); DWORD errCode = GetNtmsObjectInformation( hSession, &poolId, &mediaPoolInfo ); if ( errCode != NO_ERROR ) {
WsbLogEvent( RMS_MESSAGE_NTMS_FAILURE, 0, NULL, OLESTR("GetNtmsObjectInformation"), WsbHrAsString(HRESULT_FROM_WIN32(errCode)), NULL );
WsbThrow( E_UNEXPECTED );
}
NTMS_GUID mediaTypeId = mediaPoolInfo.Info.MediaPool.MediaType;
NTMS_OBJECTINFORMATION libInfo; HANDLE hFindLib = NULL; int driveCount = 0;
hr = findFirstNtmsObject( NTMS_LIBRARY, GUID_NULL, NULL, GUID_NULL, &hFindLib, &libInfo); while( S_OK == hr ) { HANDLE hFindLib2 = NULL; // now see if the library in which the drive is contained supported
// the specified media type
if ( libInfo.Info.Library.dwNumberOfDrives > 0 ) { hr = findFirstNtmsObject( NTMS_MEDIA_TYPE, libInfo.ObjectGuid, NULL, mediaTypeId, &hFindLib2, NULL); WsbTrace(OLESTR("Searching <%ls> for media type and drives; hr = %ls (state = %d, enabled = %ls, drives = %d)\n"), libInfo.szName, WsbHrAsString(hr), libInfo.dwOperationalState, WsbBoolAsString(libInfo.Enabled), libInfo.Info.Library.dwNumberOfDrives); if ((S_OK == hr) && ((NTMS_READY == libInfo.dwOperationalState) || (NTMS_INITIALIZING == libInfo.dwOperationalState)) && (libInfo.Enabled)) {
driveCount += libInfo.Info.Library.dwNumberOfDrives; } findCloseNtmsObject( hFindLib2 ); }
hr = findNextNtmsObject( hFindLib, &libInfo ); } findCloseNtmsObject( hFindLib );
hr = (driveCount > 1) ? S_OK : S_FALSE;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::IsMediaCopySupported"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
STDMETHODIMP CRmsNTMS::UpdateDrive( IN IRmsDrive *pDrive)/*++
Implements:
IRmsNTMS::UpdateDrive
--*/{ HRESULT hr = S_OK; CComPtr<IRmsComObject> pObject; GUID driveId; DWORD err1 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::UpdateDrive"), OLESTR(""));
try { // get drive information
WsbAffirmHr(pDrive->QueryInterface(IID_IRmsComObject, (void **)&pObject)); WsbAffirmHr(pObject->GetObjectId(&driveId));
NTMS_OBJECTINFORMATION objectInfo; objectInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); objectInfo.dwType = NTMS_DRIVE; WsbAssert(driveId != GUID_NULL, E_INVALIDARG); err1 = GetNtmsObjectInformation( m_SessionHandle, &driveId, &objectInfo ); WsbAffirmNoError (err1);
// Note: Currently, the method updates only the enable/disable state of the drive
// If required, the method may update more fields
if (objectInfo.Enabled) { WsbAffirmHr(pObject->Enable()); } else { WsbAffirmHr(pObject->Disable(S_OK)); }
} WsbCatchAndDo(hr, // Process the error of the get-info request
if (err1 != NO_ERROR ) { if (err1 == ERROR_OBJECT_NOT_FOUND) { hr = RMS_E_NTMS_OBJECT_NOT_FOUND; } WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation (Drive)"), OLESTR(""), WsbHrAsString(hr), NULL); } );
WsbTraceOut(OLESTR("CRmsNTMS::UpdateDrive"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr);}
HRESULT CRmsNTMS::GetNofAvailableDrives( OUT DWORD* pdwNofDrives )
/*++
Implements:
IRmsNTMS::GetNofAvailableDrives().
--*/{ HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsNTMS::GetNofAvailableDrives"), OLESTR(""));
*pdwNofDrives = 0; // Enumerate over all libraries that HSM uses
// (Outside the try block, since we want to continue if a failure occur on a specific library)
WsbTrace(OLESTR("CRmsNTMS::GetNofAvailableDrives: Total number of libraries is %lu\n"), m_dwNofLibs); for (int j=0; j<(int)m_dwNofLibs; j++) {
LPNTMS_GUID pObjects = NULL; DWORD errCode = NO_ERROR;
// get library id
GUID libId = m_pLibGuids[j];
// If object is suspended/suspending, just terminate (without logging an error)
if ((m_State == RmsNtmsStateSuspended) || (m_State == RmsNtmsStateSuspending)) { WsbTrace(OLESTR("CRmsNTMS::GetNofAvailableDrives: Object is suspended/suspending - exit\n")); break; }
try {
// Enumerate on all drives in the library
DWORD dwNofObjects = 16; // Initial size of object id array to allocate
int nRetry = 0;
// Allocate according to
pObjects = (LPNTMS_GUID)WsbAlloc( dwNofObjects*sizeof(NTMS_GUID) ); WsbAffirmPointer( pObjects );
// Enumerate all drives
do { errCode = EnumerateNtmsObject(m_SessionHandle, &libId, pObjects, &dwNofObjects, NTMS_DRIVE, 0); WsbTraceAlways(OLESTR("CRmsNTMS::GetNofAvailableDrives: Total number of drives is %lu\n"), dwNofObjects); nRetry++;
if ( (ERROR_OBJECT_NOT_FOUND == errCode) || (0 == dwNofObjects) ) { // Don't count on NTMS returning the correct errCode
// Not considered as an NTMS error, prevent logging by setting to NO_ERROR
errCode = NO_ERROR; WsbThrow( RMS_E_NTMS_OBJECT_NOT_FOUND ); } else if (ERROR_INSUFFICIENT_BUFFER == errCode) { // Don't retry more than 3 times
if (3 <= nRetry) { WsbThrow(HRESULT_FROM_WIN32(errCode)); }
// Allocate a new buffer, and retry.
WsbTrace(OLESTR("CRmsNTMS::GetNofAvailableDrives: Reallocating buffer\n")); LPVOID pTemp = WsbRealloc( pObjects, dwNofObjects*sizeof(NTMS_GUID) ); if (!pTemp) { WsbThrow(E_OUTOFMEMORY); } pObjects = (LPNTMS_GUID)pTemp; } else { // Other unexpected error
WsbAffirmNoError(errCode); }
} while (ERROR_INSUFFICIENT_BUFFER == errCode);
// go over all drives, get information and check availablity
for (int i = 0; i < (int)dwNofObjects; i++) {
GUID driveId = pObjects[i]; try { NTMS_OBJECTINFORMATION objectInfo; memset( &objectInfo, 0, sizeof(NTMS_OBJECTINFORMATION) ); objectInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION); objectInfo.dwType = NTMS_DRIVE; WsbAssert(driveId != GUID_NULL, E_INVALIDARG); errCode = GetNtmsObjectInformation(m_SessionHandle, &driveId, &objectInfo ); WsbAffirmNoError (errCode);
WsbTrace(OLESTR("CRmsNTMS::GetNofAvailableDrives: drive <%ls> enable/disable = %ls\n"), WsbGuidAsString(driveId), WsbBoolAsString(objectInfo.Enabled)); if (objectInfo.Enabled) { (*pdwNofDrives)++; }
} WsbCatchAndDo(hr, // Log error and go on to the next drive
if (errCode != NO_ERROR ) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation (Drive)"), OLESTR(""), WsbHrAsString(hr), NULL); }
WsbTraceAlways(OLESTR("CRmsNTMS::GetNofAvailableDrives: Failed to get info for drive <%ls> hr = <%ls>\n"), WsbGuidAsString(driveId), WsbHrAsString(hr)); hr = S_OK; ); }
} WsbCatchAndDo(hr, // Log error and go on to the next library
if (errCode != NO_ERROR ) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject (Drive)"), OLESTR(""), WsbHrAsString(hr), NULL); }
WsbTraceAlways(OLESTR("CRmsNTMS::GetNofAvailableDrives: Failed to enumerate drives in library <%ls> hr = <%ls>\n"), WsbGuidAsString(libId), WsbHrAsString(hr)); hr = S_OK; );
if (pObjects) { WsbFree(pObjects); }
} // of for
WsbTraceOut(OLESTR("CRmsNTMS::GetNofAvailableDrives"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr);}
HRESULT CRmsNTMS::CheckSecondSide( IN REFGUID firstSideId, OUT BOOL *pbValid, OUT GUID *pSecondSideId )
/*++
Implements:
IRmsNTMS::CheckSecondSide().
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::CheckSecondSide"), OLESTR(""));
*pbValid = FALSE; *pSecondSideId = GUID_NULL;
try {
WsbAssert(firstSideId != GUID_NULL, E_INVALIDARG); WsbAssertPointer(pbValid); WsbAssertPointer(pSecondSideId);
NTMS_OBJECTINFORMATION partitionInfo; memset( &partitionInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
NTMS_OBJECTINFORMATION mediaInfo; memset( &mediaInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
HANDLE hSession = m_SessionHandle; NTMS_GUID mediaId = firstSideId; NTMS_GUID firstSidePartitionId; NTMS_GUID side[2]; DWORD sideNo = 2;
// NTMS - get Partition from LMID
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject(hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0); WsbAffirmNoError(err1); firstSidePartitionId = side[0];
// NTMS - get partition information (using size 0 - LMID relates 1:1 to Partition
partitionInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); partitionInfo.dwType = NTMS_PARTITION;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err2 = GetNtmsObjectInformation(hSession, &firstSidePartitionId, &partitionInfo); WsbAffirmNoError(err2);
// NTMS - get physical media information
NTMS_GUID physicalMediaId = partitionInfo.Info.Partition.PhysicalMedia; mediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaInfo.dwType = NTMS_PHYSICAL_MEDIA;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); err2 = GetNtmsObjectInformation(hSession, &physicalMediaId, &mediaInfo); WsbAffirmNoError(err2);
// Check whether there are more than one side
if (mediaInfo.Info.PhysicalMedia.dwNumberOfPartitions > 1) { // Enumerate physical meida - expect 2 sides here.
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); sideNo = 2; err1 = EnumerateNtmsObject(hSession, &physicalMediaId, side, &sideNo, NTMS_PARTITION, 0); WsbAffirmNoError(err1); WsbAffirm(sideNo > 1, RMS_E_NOT_FOUND);
// Look for a side whos partition id is different from first side
for (DWORD i=0; i<sideNo; i++) { if (firstSidePartitionId != side[i]) { *pbValid = TRUE; // Valid second side found
// Get its LMID
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err2 = GetNtmsObjectInformation(hSession, &side[i], &partitionInfo); WsbAffirmNoError(err2);
*pSecondSideId = partitionInfo.Info.Partition.LogicalMedia; } } } // of if two sides
} WsbCatchAndDo( hr, WsbTrace(OLESTR("CRmsNTMS::CheckSecondSide - of %ls failed: hr = <%ls>\n"),WsbGuidAsString(firstSideId),WsbHrAsString(hr)); if (err1 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INSUFFICIENT_BUFFER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Unexpected Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Unexpected Error: "), WsbHrAsString(hr), NULL); break; } } ); WsbTraceOut(OLESTR("CRmsNTMS::CheckSecondSide"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr);}
HRESULTCRmsNTMS::EnsureAllSidesNotAllocated( IN REFGUID mediaId ){ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::EnsureAllSidesNotAllocated"), OLESTR(""));
try { WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
NTMS_OBJECTINFORMATION partitionInfo; memset( &partitionInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) ); NTMS_OBJECTINFORMATION mediaInfo; memset( &mediaInfo, 0, sizeof( NTMS_OBJECTINFORMATION ) );
HANDLE hSession = m_SessionHandle;
NTMS_GUID physicalMediaId = mediaId; mediaInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); mediaInfo.dwType = NTMS_PHYSICAL_MEDIA; partitionInfo.dwSize = sizeof( NTMS_OBJECTINFORMATION ); partitionInfo.dwType = NTMS_PARTITION;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PHYSICAL_MEDIA)\n")); err2 = GetNtmsObjectInformation(hSession, &physicalMediaId, &mediaInfo); WsbAffirmNoError(err2);
// Check whether there are more than one side
if (mediaInfo.Info.PhysicalMedia.dwNumberOfPartitions > 1) { // Enumerate physical meida - expect 2 sides here.
NTMS_GUID side[2]; DWORD sideNo = 2; WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject(hSession, &physicalMediaId, side, &sideNo, NTMS_PARTITION, 0); WsbAffirmNoError(err1);
// Look for a side which is allocated
for (DWORD i=0; i<sideNo; i++) { WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_PARTITION)\n")); err2 = GetNtmsObjectInformation(hSession, &side[i], &partitionInfo); WsbAffirmNoError(err2);
if (GUID_NULL != partitionInfo.Info.Partition.LogicalMedia) { hr = S_FALSE; break; } } } // of if two sides
} WsbCatchAndDo( hr, WsbTrace(OLESTR("CRmsNTMS::EnsureAllSidesNotAllocated - of %ls failed: hr = <%ls>\n"),WsbGuidAsString(mediaId),WsbHrAsString(hr)); if (err1 != NO_ERROR ) { // EnumerateNtmsObject
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_PARAMETER: case ERROR_INVALID_HANDLE: case ERROR_NOT_ENOUGH_MEMORY: case ERROR_INSUFFICIENT_BUFFER: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("EnumerateNtmsObject"), OLESTR("Unexpected Error: "), WsbHrAsString(hr), NULL); break; } } else if (err2 != NO_ERROR) { // GetNtmsObjectInformation
switch (HRESULT_CODE(hr)) { case ERROR_OBJECT_NOT_FOUND: hr = RMS_E_CARTRIDGE_NOT_FOUND; break;
case ERROR_INVALID_HANDLE: case ERROR_INVALID_PARAMETER: case ERROR_NOT_ENOUGH_MEMORY: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR(""), WsbHrAsString(hr), NULL); break;
default: WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("GetNtmsObjectInformation"), OLESTR("Unexpected Error: "), WsbHrAsString(hr), NULL); break; } } );
WsbTraceOut(OLESTR("CRmsNTMS::EnsureAllSidesNotAllocated"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr);}
STDMETHODIMP CRmsNTMS::DismountAll( IN REFGUID fromMediaSet, IN DWORD dwOptions)/*++
Implements:
IRmsNTMS::DismountAll
--*/{ HRESULT hr = S_OK;
WsbTraceIn( OLESTR("CRmsNTMS::DismountAll"), OLESTR("") );
try { WsbAssert(GUID_NULL != fromMediaSet, E_INVALIDARG);
HANDLE hFindMedia = NULL; DWORD err1 = NO_ERROR; HANDLE hSession = m_SessionHandle; NTMS_OBJECTINFORMATION physicalMediaInfo; NTMS_GUID setId = fromMediaSet; NTMS_GUID partId = GUID_NULL;
// Dismount all mounted medias from the given pool
hr = findFirstNtmsObject(NTMS_PHYSICAL_MEDIA, setId, NULL, GUID_NULL, &hFindMedia, &physicalMediaInfo); while(S_OK == hr) { switch (physicalMediaInfo.Info.PhysicalMedia.MediaState) { case NTMS_MEDIASTATE_LOADED: case NTMS_MEDIASTATE_MOUNTED: // Dismount the media
try { partId = physicalMediaInfo.Info.PhysicalMedia.MountedPartition; WsbAffirm(GUID_NULL != partId, E_UNEXPECTED);
DWORD dwNtmsOptions = 0; WsbTraceAlways(OLESTR("DismountNtmsMedia()\n")); if (! ( dwOptions & RMS_DISMOUNT_IMMEDIATE )) { dwNtmsOptions |= NTMS_DISMOUNT_DEFERRED; } err1 = DismountNtmsMedia(hSession, &partId, 1, dwNtmsOptions); WsbAffirmNoError(err1);
} WsbCatchAndDo(hr, if (err1 != NO_ERROR) { WsbLogEvent(RMS_MESSAGE_NTMS_FAULT, 0, NULL, OLESTR("DismountNtmsMedia"), OLESTR(""), WsbHrAsString(hr), NULL); } );
break;
default: // Media is not mounted - skip it
break; }
hr = findNextNtmsObject(hFindMedia, &physicalMediaInfo); }
findCloseNtmsObject(hFindMedia); hr = S_OK;
} WsbCatch(hr);
WsbTraceOut( OLESTR("CRmsNTMS::DismountAll"), OLESTR("hr = <%ls>"), WsbHrAsString(hr) );
return hr;}
HRESULTCRmsNTMS::GetMaxMediaCapacity( IN REFGUID fromMediaSet, OUT LONGLONG *pMaxCapacity )/*++
Implements:
IRmsNTMS::GetMaxMediaCapacity
Notes: Traverse all the media in the Remote Storage pool & the free media pool and retruns max capacity
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR; DWORD err2 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::GetMaxMediaCapacity"), OLESTR(""));
try { WsbAssert(fromMediaSet != GUID_NULL, E_INVALIDARG); WsbAssertPointer(pMaxCapacity);
*pMaxCapacity = 0;
NTMS_GUID setId = fromMediaSet;
HANDLE hFindPart = NULL; NTMS_OBJECTINFORMATION partitionInfo;
HANDLE hFindPool = NULL; NTMS_OBJECTINFORMATION mediaPoolInfo;
NTMS_GUID scratchPoolId;
HANDLE hSession = m_SessionHandle;
// First look in RSS pool for media which are OK for capacity comparison
hr = findFirstNtmsObject(NTMS_PARTITION, setId, NULL, GUID_NULL, &hFindPart, &partitionInfo); while(S_OK == hr) { BOOL bCheckState = (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_ALLOCATED) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_AVAILABLE) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_COMPLETE) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_RESERVED);
if ((TRUE == partitionInfo.Enabled) && (NTMS_READY == partitionInfo.dwOperationalState) && (TRUE == bCheckState)) {
// Compare capacity to maximum
if (partitionInfo.Info.Partition.Capacity.QuadPart > *pMaxCapacity) { *pMaxCapacity = partitionInfo.Info.Partition.Capacity.QuadPart; } }
hr = findNextNtmsObject(hFindPart, &partitionInfo); }
findCloseNtmsObject(hFindPart); hr = S_OK;
// Now look in scratch pool for media which are OK for capacity comparison
// Get and save the media type for the RSS media pool
memset(&mediaPoolInfo, 0, sizeof(NTMS_OBJECTINFORMATION)); mediaPoolInfo.dwType = NTMS_MEDIA_POOL; mediaPoolInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION);
WsbTraceAlways(OLESTR("GetNtmsObjectInformation(NTMS_MEDIA_POOL)\n")); WsbAffirmNoError(GetNtmsObjectInformation(hSession, &setId, &mediaPoolInfo));
NTMS_GUID mediaTypeId = mediaPoolInfo.Info.MediaPool.MediaType;
// Find the scratch pool with the same media type
hr = findFirstNtmsObject(NTMS_MEDIA_POOL, GUID_NULL, NULL, GUID_NULL, &hFindPool, &mediaPoolInfo); while(S_OK == hr) { if ((NTMS_POOLTYPE_SCRATCH == mediaPoolInfo.Info.MediaPool.PoolType) && (mediaTypeId == mediaPoolInfo.Info.MediaPool.MediaType)) {
// This is a base level scratch media pool for type we're looking for.
scratchPoolId = mediaPoolInfo.ObjectGuid;
hr = findFirstNtmsObject(NTMS_PARTITION, scratchPoolId, NULL, GUID_NULL, &hFindPart, &partitionInfo); while(S_OK == hr) { BOOL bCheckState = (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_ALLOCATED) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_AVAILABLE) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_COMPLETE) || (partitionInfo.Info.Partition.State == NTMS_PARTSTATE_RESERVED);
if ((TRUE == partitionInfo.Enabled) && (NTMS_READY == partitionInfo.dwOperationalState) && (TRUE == bCheckState)) {
// Compare capacity to maximum
if (partitionInfo.Info.Partition.Capacity.QuadPart > *pMaxCapacity) { *pMaxCapacity = partitionInfo.Info.Partition.Capacity.QuadPart; } }
hr = findNextNtmsObject(hFindPart, &partitionInfo); }
findCloseNtmsObject(hFindPart); hr = S_OK;
// Get out - no need to traverse more pools...
break; }
hr = findNextNtmsObject(hFindPool, &mediaPoolInfo); } // while finding media pools
findCloseNtmsObject(hFindPool); hr = S_OK;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::GetMaxMediaCapacity"), OLESTR("hr = <%ls>, Max-media-size = %I64d"), WsbHrAsString(hr), *pMaxCapacity); return(hr);}
STDMETHODIMP CRmsNTMS::DisableAndEject( IN IRmsCartridge *pCart, IN DWORD dwOptions )
/*++
Implements:
IRmsNTMS::DisableAndEject
Notes: 1) Currently, the operator request to eject media has a format failure as a reason. In the future, the dwOptions parameter could be used to specify other operator requests or the method may get a partial text for the operator request from the caller
2) The dwOptions is not used at all for now. In the future, it may be used to speficy disable-only, other operator requests, etc.
--*/{ HRESULT hr = S_OK; DWORD err1 = NO_ERROR;
WsbTraceIn(OLESTR("CRmsNTMS::DisableAndEject"), OLESTR(""));
UNREFERENCED_PARAMETER(dwOptions);
try { WsbAssertPointer(pCart);
HANDLE hSession = m_SessionHandle; DWORD sideNo = 2; NTMS_GUID side[2];
NTMS_GUID mediaId = GUID_NULL; WsbAffirmHr(pCart->GetCartridgeId(&mediaId)); WsbAssert(mediaId != GUID_NULL, E_INVALIDARG);
// Enumerate to get partition id out of a logical media
WsbTraceAlways(OLESTR("EnumerateNtmsObject()\n")); err1 = EnumerateNtmsObject(hSession, &mediaId, side, &sideNo, NTMS_PARTITION, 0); WsbAffirmNoError(err1); WsbAssert(side[0] != GUID_NULL, E_INVALIDARG);
// Get physical media id
NTMS_OBJECTINFORMATION partInfo; partInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION); partInfo.dwType = NTMS_PARTITION;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); err1 = GetNtmsObjectInformation(hSession, &side[0], &partInfo ); WsbAffirmNoError(err1); NTMS_GUID physicalMediaId = partInfo.Info.Partition.PhysicalMedia; WsbAssert(physicalMediaId != GUID_NULL, E_INVALIDARG);
// Disable the media
WsbTraceAlways(OLESTR("DisableNtmsObject()\n")); err1 = DisableNtmsObject(hSession, NTMS_PHYSICAL_MEDIA, &physicalMediaId);
// Since RSM Disable object is asyncronous, we may need to wait some arbitrary time,
// in order that when we come back, the media is really disabled
if (NO_ERROR == err1) { DWORD size; OLECHAR tmpString[256]; DWORD waitTime = RMS_DEFAULT_AFTER_DISABLE_WAIT_TIME;
if (SUCCEEDED(WsbGetRegistryValueString(NULL, RMS_REGISTRY_STRING, RMS_PARAMETER_AFTER_DISABLE_WAIT_TIME, tmpString, 256, &size))) { waitTime = wcstol(tmpString, NULL, 10); WsbTrace(OLESTR("AfterDisableWaitTime is %d milliseconds.\n"), waitTime); }
Sleep(waitTime); }
// Continue even if there's an error
if (NO_ERROR != err1) { WsbTraceAlways(OLESTR("CRmsNTMS::DisableAndEject: DisableNtmsObject on media %ls failed with error %lu\n"), WsbGuidAsString(physicalMediaId), err1); }
// Try to get the slot number for the operator request. ignore error - slot is set to blank
WCHAR slotNumber[16]; wcscpy(slotNumber, L" ");
NTMS_OBJECTINFORMATION mediaInfo; mediaInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION); mediaInfo.dwType = NTMS_PHYSICAL_MEDIA;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); err1 = GetNtmsObjectInformation(hSession, &physicalMediaId, &mediaInfo); if (NO_ERROR == err1) { NTMS_GUID homeSlotId = mediaInfo.Info.PhysicalMedia.HomeSlot;
NTMS_OBJECTINFORMATION slotInfo; slotInfo.dwSize = sizeof(NTMS_OBJECTINFORMATION); slotInfo.dwType = NTMS_STORAGESLOT;
WsbTraceAlways(OLESTR("GetNtmsObjectInformation()\n")); err1 = GetNtmsObjectInformation(hSession, &homeSlotId, &slotInfo); if (NO_ERROR == err1) { swprintf(slotNumber, L"%lu", slotInfo.Info.StorageSlot.Number); } else { WsbTraceAlways(OLESTR("CRmsNTMS::DisableAndEject: GetNtmsObjectInformation failed for slot %ls with error %lu\n"), WsbGuidAsString(homeSlotId), err1); }
} else { WsbTraceAlways(OLESTR("CRmsNTMS::DisableAndEject: GetNtmsObjectInformation failed for media %ls with error %lu\n"), WsbGuidAsString(physicalMediaId), err1); }
// Get text for the operator request (assume eject due to a format failure for now)
CWsbBstrPtr cartridgeName; WCHAR *messageText = NULL; WCHAR *stringArr[2];
WsbAffirmHr(pCart->GetName(&cartridgeName)); stringArr[0] = (WCHAR *)cartridgeName; stringArr[1] = (WCHAR *)slotNumber;
WsbAffirmStatus(FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY, LoadLibraryEx( WSB_FACILITY_PLATFORM_NAME, NULL, LOAD_LIBRARY_AS_DATAFILE ), RMS_MESSAGE_EJECT_BAD_MEDIA_REQUEST, MAKELANGID ( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPTSTR)&messageText, 0, (va_list *)stringArr));
// Submit an operator request to eject the media
NTMS_GUID libId = GUID_NULL; NTMS_GUID requestId = GUID_NULL;
WsbTraceAlways(OLESTR("SubmitNtmsOperatorRequest()\n")); err1 = SubmitNtmsOperatorRequest(hSession, NTMS_OPREQ_MESSAGE, messageText, &physicalMediaId, &libId, &requestId); LocalFree(messageText); WsbAffirmNoError (err1);
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsNTMS::DisableAndEject"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;}
|
