/*===================================================================== File: OfflinePublishing.cpp THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. Copyright (C) Microsoft Corporation. All rights reserved. =====================================================================*/ // // This sample demonstrates offline publishing. It acquires the appropriate // licenses and certificates, initializes the environment, and signs the // publishing license offline. See the comments at the beginning of wmain() // for a more detailed description. // #include #include #include #include #include "msdrm.h" #include "msdrmdefs.h" #include "msdrmerror.h" // // Values to put into the unsigned issuance license // #define APP_SPECIFIC_DATA_NAME L"AppSpecificName" #define APP_SPECIFIC_DATA_VALUE L"AppSpecificValue" #define INTERVAL_TIME_DAYS 30 #define SKU_ID L"SKUId" #define SKU_ID_TYPE L"SKUIdType" #define CONTENT_TYPE L"ContentType" #define CONTENT_NAME L"ContentName" #define NAME_AND_DESCRIPTION_NAME L"Name" #define NAME_AND_DESCRIPTION_DESCRIPTION L"Description" #define USAGE_POLICY_APPLICATION_NAME L"ApplicationName" #define USAGE_POLICY_MIN_VERSION L"1.0.0.0" #define USAGE_POLICY_MAX_VERSION L"3.0.0.0" #define RIGHT_NAME L"EDIT" // // Time to wait for "downloads" to complete // static const DWORD DW_WAIT_TIME_SECONDS = 60 * 1000; // // Length of a GUID string // static const UINT GUID_STRING_LENGTH = 128; // // Unicode Byte Order Mark Length // static const UINT UTF16_BOM_LENGTH = 2; // // Struct to hold the callback information // typedef struct Drm_Context { HANDLE hEvent; HRESULT hr; PWSTR wszData; } DRM_CONTEXT, *PDRM_CONTEXT; // // Print the correct usage of this application // void PrintUsage() { wprintf( L"Usage:\n" ); wprintf( L"\n OfflinePublishing -U UserID -M ManifestFile "\ L"[-A ActivationSvr] [-L LicensingSvr]\n" ); wprintf( L" -U: specifies the UserID.\n" ); wprintf( L" example: user@yourdomain.com\n" ); wprintf( L" -M: specifies the manifest file to use.\n" ); wprintf( L" example: manifest.xml\n" ); wprintf( L" -A: specifies the Activation Server. (optional)\n" ); wprintf( L" example: http://localhost/_wmcs/certification\n" ); wprintf( L" -L: specifies the Licensing Server. (optional)\n" ); wprintf( L" example: http://localhost/_wmcs/licensing\n" ); } // // Parse the values passed in through the command line // HRESULT ParseCommandLine( int argc, __in_ecount( argc )WCHAR **argv, __deref_out_opt PWCHAR *pwszUserID, __deref_out PWCHAR *pwszActivationSvr, __deref_out PWCHAR *pwszLicensingSvr, __deref_out_opt PWCHAR *pwszManifestFile ) { HRESULT hr = S_OK; size_t uiUserIDLength = 0; size_t uiActSvrUrlLength = 0; size_t uiLicSvrUrlLength = 0; size_t uiManifestFileLength = 0; // // Initialize parameters // *pwszUserID = NULL; *pwszManifestFile = NULL; // // Check input parameters. // if ( ( 5 != argc ) && ( 7 != argc ) && ( 9 != argc ) ) { return E_INVALIDARG; } for( int i = 1; SUCCEEDED( hr ) && i < argc - 1; i ++ ) { if ( ( '-' != argv[ i ][ 0 ] ) && ( '/' != argv[ i ][ 0 ] ) ) { hr = E_INVALIDARG; break; } else if ( ( '-' == argv[ i + 1 ][ 0 ] ) || ( '/' == argv[ i + 1 ][ 0 ] ) ) { hr = E_INVALIDARG; break; } switch( toupper( argv[ i ][ 1 ] ) ) { // // User ID // case 'U': if ( wcsstr( argv[ i + 1 ], ( wchar_t* )L"@\0" ) == NULL ) { // // An invalid User ID was provided // hr = E_INVALIDARG; break; } // // Retrieve the length of the user ID // hr = StringCchLengthW( argv[ i + 1 ], STRSAFE_MAX_CCH, &uiUserIDLength ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x\n", hr ); break; } // // Allocate memory for the user ID // *pwszUserID = new WCHAR[ uiUserIDLength + 1 ]; if ( NULL == *pwszUserID ) { wprintf( L"\nFailed to allocate memory for pwszUserID.\n" ); hr = E_OUTOFMEMORY; break; } // // Copy the user ID into the pwszUserID buffer // hr = StringCchCopyW( ( wchar_t* )*pwszUserID, uiUserIDLength + 1 , argv[ i + 1 ] ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x\n", hr ); break; } i++; break; case 'A': if ( ( _wcsnicmp( argv[ i + 1 ], L"http://", 7 ) != 0 ) && ( _wcsnicmp( argv[ i + 1 ], L"https://", 8 ) != 0 ) ) { wprintf( L"\nInvalid activation URL provided.\n" ); hr = E_INVALIDARG; break; } // // Retrieve the length of the activation server URL // hr = StringCchLengthW( argv[ i + 1 ], STRSAFE_MAX_CCH, &uiActSvrUrlLength ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x\n", hr ); break; } // // Allocate memory for the URL // *pwszActivationSvr = new WCHAR[ uiActSvrUrlLength + 1 ]; if( NULL == *pwszActivationSvr ) { wprintf( L"\nFailed to allocate memory "\ L"for pwszActivationSvr.\n" ); hr = E_OUTOFMEMORY; break; } // // Copy the URL into the pwszActivationSvr buffer // hr = StringCchCopyW( ( wchar_t* )*pwszActivationSvr, uiActSvrUrlLength + 1 , argv[ i + 1 ] ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x\n", hr ); break; } i++; break; case 'L': if ( ( _wcsnicmp( argv[ i + 1 ], L"http://", 7 ) != 0 ) && ( _wcsnicmp( argv[ i + 1 ], L"https://", 8 ) != 0 ) ) { wprintf( L"\nInvalid licensing URL provided.\n" ); hr = E_INVALIDARG; break; } // // Retrieve the length of the licensing server URL // hr = StringCchLengthW( argv[ i + 1 ], STRSAFE_MAX_CCH, &uiLicSvrUrlLength ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x\n", hr ); break; } // // Allocate memory for the URL // *pwszLicensingSvr = new WCHAR[ uiLicSvrUrlLength + 1 ]; if( NULL == *pwszLicensingSvr ) { wprintf( L"\nFailed to allocate memory "\ L"for pwszLicensingSvr.\n" ); hr = E_OUTOFMEMORY; break; } // // Copy the URL into the pwszLicensingSvr buffer // hr = StringCchCopyW( ( wchar_t* )*pwszLicensingSvr, uiLicSvrUrlLength + 1 , argv[ i + 1 ] ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x\n", hr ); break; } i++; break; case 'M': if ( ( wcsstr( argv[ i + 1 ], L".xml" ) == NULL ) && ( wcsstr( argv[ i + 1 ], L".XML" ) == NULL ) ) { wprintf( L"\nInvalid manifest file name provided.\n" ); hr = E_INVALIDARG; break; } // // Retrieve the length of the manifest name // hr = StringCchLengthW( argv[ i + 1 ], STRSAFE_MAX_CCH, &uiManifestFileLength ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x\n", hr ); break; } // // Allocate memory for the manifest file name // *pwszManifestFile = new WCHAR[ uiManifestFileLength + 1 ]; if( NULL == *pwszManifestFile ) { wprintf( L"\nFailed to allocate memory "\ L"for pwszActivationSvr.\n" ); hr = E_OUTOFMEMORY; break; } // // Copy the manifest name into the pwszManifestFile buffer // hr = StringCchCopyW( ( wchar_t* )*pwszManifestFile, uiManifestFileLength + 1 , argv[ i + 1 ] ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x\n", hr ); break; } i++; break; default: hr = E_INVALIDARG; break; } } if ( NULL == *pwszUserID ) { wprintf( L"\nA user ID value is required.\n" ); hr = E_INVALIDARG; } if ( NULL == *pwszManifestFile ) { wprintf( L"\nA manifest file is required.\n" ); hr = E_INVALIDARG; } return hr; } // // Copy the contents of the file into a string buffer // HRESULT ReadFileToWideString( __in PWSTR szFileName, __deref_out PWCHAR *pwszManifestString ) { HRESULT hr = S_OK; HANDLE hFile = INVALID_HANDLE_VALUE; DWORD dwBytesRead = 0; UINT uiUnicode = 0; BYTE bBOMValue[UTF16_BOM_LENGTH]; BY_HANDLE_FILE_INFORMATION fileInfo; // // Validate the parameters // if ( ( NULL == szFileName ) || ( FAILED( StringCchLengthW( szFileName, MAX_PATH, NULL ) ) ) || ( NULL == pwszManifestString ) ) { hr = E_INVALIDARG; goto e_Exit; } // // Get a handle to the file // hFile = CreateFileW( szFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL ); if ( INVALID_HANDLE_VALUE == hFile ) { wprintf( L"\nCreateFileW failed. hFile == INVALID_HANDLE_VALUE\n" ); hr = HRESULT_FROM_WIN32( GetLastError() ) ; goto e_Exit; } if ( 0 == GetFileInformationByHandle( hFile, &fileInfo ) ) { wprintf( L"\nGetFileInformationByHandle failed.\n" ); hr = HRESULT_FROM_WIN32( GetLastError() ); goto e_Exit; } // // Check for files that are too long and unsigned integer overflow // if ( ( 0 != fileInfo.nFileSizeHigh ) || ( fileInfo.nFileSizeLow + sizeof( WCHAR ) < fileInfo.nFileSizeLow ) ) { wprintf(L"\nFile too long.\n"); hr = E_FAIL; goto e_Exit; } memset(bBOMValue, 0, sizeof(bBOMValue) ); // // First check to see if the file is in UTF-16 format // if (0 == ReadFile( hFile, (LPVOID)bBOMValue, UTF16_BOM_LENGTH, &dwBytesRead, 0 ) ) { hr = HRESULT_FROM_WIN32( GetLastError() ); goto e_Exit; } if( (bBOMValue[0] == 0xFF ) && ( bBOMValue[1] == 0xFE ) ) { uiUnicode = UTF16_BOM_LENGTH; } else { // //Reset the pointer if this file is not in UTF-16 format // if(0 == SetFilePointer( hFile, 0, NULL, FILE_BEGIN ) ) { hr = HRESULT_FROM_WIN32( GetLastError() ); goto e_Exit; } } *pwszManifestString = new WCHAR[ fileInfo.nFileSizeLow + sizeof(WCHAR) ]; if ( NULL == *pwszManifestString ) { wprintf( L"\nMemory allocation for pwszManifestString failed.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } memset(*pwszManifestString, 0, (fileInfo.nFileSizeLow + sizeof(WCHAR) ) * sizeof(WCHAR) ); // // Put the contents of the file into pwszManifestString // if(0 == ReadFile( hFile, *pwszManifestString, fileInfo.nFileSizeLow - uiUnicode, &dwBytesRead, 0 ) ) { hr = HRESULT_FROM_WIN32( GetLastError() ); goto e_Exit; } e_Exit: if ( INVALID_HANDLE_VALUE != hFile ) { CloseHandle( hFile ); } return hr; } // // Callback function for asynchronous ADRMS client functions // HRESULT __stdcall StatusCallback( DRM_STATUS_MSG msg, HRESULT hr, void *pvParam, void *pvContext ) { size_t uiSignedILLength = 0; PDRM_CONTEXT pContext = ( PDRM_CONTEXT )pvContext; if ( pContext ) { pContext->hr = hr; } else { return E_FAIL; } if ( FAILED( pContext->hr ) && pContext->hEvent ) { // // Signal the event // SetEvent( ( HANDLE )pContext->hEvent ); return S_OK; } // // Print the callback status message // switch( msg ) { case DRM_MSG_ACTIVATE_MACHINE: wprintf( L"\nCallback status msg = DRM_MSG_ACTIVATE_MACHINE " ); break; case DRM_MSG_ACTIVATE_GROUPIDENTITY: wprintf( L"\nCallback status msg = DRM_MSG_ACTIVATE_GROUPIDENTITY " ); break; case DRM_MSG_ACQUIRE_CLIENTLICENSOR: wprintf( L"\nCallback status msg = DRM_MSG_ACQUIRE_CLIENTLICENSOR " ); break; case DRM_MSG_SIGN_ISSUANCE_LICENSE: wprintf( L"\nCallback status msg = DRM_MSG_SIGN_ISSUANCE_LICENSE " ); break; default: wprintf( L"\nDefault callback status msg = 0x%x ", msg ); break; } // // Print the callback error code // switch( pContext->hr ) { case S_DRM_ALREADY_ACTIVATED: wprintf( L"Callback hr = S_DRM_ALREADY_ACTIVATED\n" ); break; case S_DRM_CONNECTING: wprintf( L"Callback hr = S_DRM_CONNECTING\n" ); break; case S_DRM_CONNECTED: wprintf( L"Callback hr = S_DRM_CONNECTED\n" ); break; case S_DRM_INPROGRESS: wprintf( L"Callback hr = S_DRM_INPROGRESS\n" ); break; case S_DRM_COMPLETED: wprintf( L"Callback hr = S_DRM_COMPLETED\n" ); pContext->hr = S_OK; if ( ( msg == DRM_MSG_SIGN_ISSUANCE_LICENSE ) && pvParam ) { if ( NULL != pvParam ) { // // Retrieve the length of the signed issuance license // hr = StringCchLengthW( ( PWSTR )pvParam, STRSAFE_MAX_CCH, &uiSignedILLength ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x\n", hr ); break; } // // Allocate memory for the signed issuance license // pContext->wszData = new WCHAR[ uiSignedILLength + 1 ]; if( NULL == pContext->wszData ) { wprintf( L"\nFailed to allocate memory "\ L"for the signed issuance license.\n" ); hr = E_OUTOFMEMORY; break; } // // Copy the signed issuance license into the // pContext->wszData buffer // hr = StringCchCopyW( ( wchar_t* )pContext->wszData, uiSignedILLength + 1 , ( PWSTR )pvParam ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x\n", hr ); break; } } } if ( pContext->hEvent ) { SetEvent( ( HANDLE )pContext->hEvent ); } break; case E_DRM_ACTIVATIONFAILED: wprintf( L"Callback hr = E_DRM_ACTIVATIONFAILED\n" ); break; case E_DRM_HID_CORRUPTED: wprintf( L"Callback hr = E_DRM_HID_CORRUPTED\n" ); break; case E_DRM_INSTALLATION_FAILED: wprintf( L"Callback hr = E_DRM_INSTALLATION_FAILED\n" ); break; case E_DRM_ALREADY_IN_PROGRESS: wprintf( L"Callback hr = E_DRM_ALREADY_IN_PROGRESS\n" ); break; case E_DRM_NO_CONNECT: wprintf( L"Callback hr = E_DRM_NO_CONNECT\n" ); break; case E_DRM_ABORTED: wprintf( L"Callback hr = E_DRM_ABORTED\n" ); break; case E_DRM_SERVER_ERROR: wprintf( L"Callback hr = E_DRM_SERVER_ERROR\n" ); break; case E_DRM_INVALID_SERVER_RESPONSE: wprintf( L"Callback hr = E_DRM_INVALID_SERVER_RESPONSE\n" ); break; case E_DRM_SERVER_NOT_FOUND: wprintf( L"Callback hr = E_DRM_SERVER_NOT_FOUND\n" ); break; case E_DRM_AUTHENTICATION_FAILED: wprintf( L"Callback hr = E_DRM_AUTHENTICATION_FAILED\n" ); break; case E_DRM_EMAIL_NOT_VERIFIED: wprintf( L"Callback hr = E_DRM_EMAIL_NOT_VERIFIED\n" ); break; case E_DRM_AD_ENTRY_NOT_FOUND: wprintf( L"Callback hr = E_DRM_AD_ENTRY_NOT_FOUND\n" ); break; case E_DRM_NEEDS_MACHINE_ACTIVATION: wprintf( L"Callback hr = E_DRM_NEEDS_MACHINE_ACTIVATION\n" ); break; case E_DRM_REQUEST_DENIED: wprintf( L"Callback hr = E_DRM_REQUEST_DENIED\n" ); break; case E_DRM_INVALID_EMAIL: wprintf( L"Callback hr = E_DRM_INVALID_EMAIL\n" ); break; case E_DRM_SERVICE_GONE: wprintf( L"Callback hr = E_DRM_SERVICE_GONE\n" ); break; case E_DRM_SERVICE_MOVED: wprintf( L"Callback hr = E_DRM_SERVICE_MOVED\n" ); break; case E_DRM_VALIDITYTIME_VIOLATION: wprintf( L"Callback hr = E_DRM_VALIDITYTIME_VIOLATION\n" ); break; case S_DRM_REQUEST_PREPARED: wprintf( L"Callback hr = S_DRM_REQUEST_PREPARED\n" ); break; case E_DRM_NO_LICENSE: wprintf( L"Callback hr = E_DRM_NO_LICENSE\n" ); break; case E_DRM_SERVICE_NOT_FOUND: wprintf( L"Callback hr = E_DRM_SERVICE_NOT_FOUND\n" ); break; default: wprintf( L"Default callback hr = 0x%x\n", hr ); pContext->hr = S_OK; if ( pContext->hEvent ) { SetEvent( ( HANDLE )pContext->hEvent ); } break; } return S_OK; } // // This function performs the following actions: // 1. Validate the parameters // 2. Create an event for the callback function // 3. Populate the wszURL member of the DRM_ACTSERV_INFO struct // with the activation server URL. This value can be from: // (a) a command line argument // (b) service discovery // 4. Activate the machine // 5. Wait for the callback to return // 6. Clean up and free memory HRESULT __stdcall DoMachineActivation( DRMHSESSION hClient, __in PWCHAR wszActivationSvr ) { HRESULT hr = E_FAIL; DRM_ACTSERV_INFO *pdasi = NULL; UINT uiStrLen = 0; size_t cchActivationSvr = 0; DWORD dwWaitResult; DRM_CONTEXT context; context.hEvent = NULL; // // 1. Validate the parameters // if ( NULL == hClient ) { wprintf( L"\nThe client session was NULL.\n" ); hr = E_INVALIDARG; goto e_Exit; } // // 2. Create an event for the callback function // if ( NULL == ( context.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ) ) ) { wprintf( L"\ncontext.hEvent was NULL after the CreateEvent call\n" ); goto e_Exit; } // // Allocate memory for the DRM_ACTSERV_INFO structure for activation // pdasi = new DRM_ACTSERV_INFO; if ( NULL == pdasi ) { wprintf( L"\nMemory allocation failed for DRM_ACTSERV_INFO.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } pdasi->wszURL = NULL; // // 3. Copy the activation server URL into the wszURL member // of the DRM_ACTSERV_INFO struct // if ( NULL != wszActivationSvr ) { // // 3(a). Use the URL provided through the command line argument // hr = StringCchLengthW( wszActivationSvr, STRSAFE_MAX_CCH, &cchActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x.\n", hr ); goto e_Exit; } // // Allocate memory for the URL member of // the DRM_ACTSERV_INFO structure // pdasi->wszURL = new WCHAR[ cchActivationSvr + 1 ]; if ( NULL == pdasi->wszURL ) { wprintf( L"\nMemory allocation failed for the "\ L"activation URL string.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = StringCchCopyW( pdasi->wszURL, cchActivationSvr + 1, wszActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x.\n", hr ); goto e_Exit; } wprintf( L"\nMachine Activation server URL:\n%s\n", pdasi->wszURL ); } else { // // 3(b). Try to find the service location where activation // is available. // The first call is to get - // (a) whether there is a service location and // (b) if so, the size needed for a buffer to // hold the URL for the service. // hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_ACTIVATION, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, NULL ); if ( SUCCEEDED( hr ) ) { // // There is a service location; reserve space // for the URL. // pdasi->wszURL = new WCHAR[ uiStrLen ]; if ( NULL == pdasi->wszURL ) { wprintf( L"\nMemory allocation failed for activation "\ L"URL string.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } // // Call second time to get the actual service location // copied into the URL. // hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_ACTIVATION, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, pdasi->wszURL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetServiceLocation (ENTERPRISE) failed. "\ L"hr = 0x%x\n", hr ); goto e_Exit; } wprintf( L"\nDRMGetServiceLocation (ENTERPRISE) succeeded.\n\n"\ L"Machine Activation server URL:\n%s\n", pdasi->wszURL ); } else { wprintf( L"\nDRMGetServiceLocation failed. hr = 0x%x. "\ L"\nPassing NULL server info to DRMActivate.\n", hr ); } } // // 4. Activate the machine // hr = DRMActivate( hClient, DRM_ACTIVATE_MACHINE | DRM_ACTIVATE_SILENT, 0, pdasi, ( VOID* )&context, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMActivate (DRM_ACTIVATE_MACHINE) "\ L"failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 5. Wait for the callback to return // dwWaitResult = WaitForSingleObject( context.hEvent, DW_WAIT_TIME_SECONDS ); if ( WAIT_TIMEOUT == dwWaitResult ) { wprintf( L"\nWaitForSingleObject timed out.\n" ); goto e_Exit; } if ( FAILED( context.hr ) ) { // // In case a failure was reported via the callback function // note it also. // wprintf( L"\nThe callback function returned a failure "\ L"code. hr = 0x%x\n", context.hr ); hr = context.hr; goto e_Exit; } wprintf( L"\nThe machine is now activated.\n" ); e_Exit: // // 6. Clean up and free memory // if ( NULL != pdasi ) { if ( NULL != pdasi->wszURL ) { delete [] pdasi->wszURL; } delete pdasi; } if ( NULL != context.hEvent ) { CloseHandle( context.hEvent ); } return hr; } // // This function performs the following actions: // 1. Validate the parameters // 2. Create an event for the callback function // 3. Populate the wszURL member of the DRM_ACTSERV_INFO struct with // the user activation server URL. This value can be from: // (a) a command line argument // (b) service discovery // 4. Activate the user // 5. Wait for the callback to return // 6. Clean up and free memory HRESULT __stdcall DoUserActivation( DRMHSESSION hClient, __in PWCHAR wszActivationSvr ) { HRESULT hr = E_FAIL; DRM_ACTSERV_INFO *pdasi = NULL; UINT uiStrLen = 0; size_t cchActivationSvr = 0; DWORD dwWaitResult; DRM_CONTEXT context; context.hEvent = NULL; // // 1. Validate the parameters // if ( NULL == hClient ) { wprintf( L"\nThe client session was NULL.\n" ); hr = E_INVALIDARG; goto e_Exit; } // // 2. Create an event for the callback function // if ( NULL == ( context.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ) ) ) { wprintf( L"\ncontext.hEvent was NULL after the CreateEvent call\n" ); goto e_Exit; } // // Allocate memory for the DRM_ACTSERV_INFO structure for activation // pdasi = new DRM_ACTSERV_INFO; if ( NULL == pdasi ) { wprintf( L"\nMemory allocation failed for DRM_ACTSERV_INFO.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } pdasi->wszURL = NULL; // // 3. Copy the activation server URL into the wszURL member // of the DRM_ACTSERV_INFO struct // if ( NULL != wszActivationSvr ) { // // 3(a). Use the URL provided through the command line argument // hr = StringCchLengthW( wszActivationSvr, STRSAFE_MAX_CCH, &cchActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchLengthW failed. hr = 0x%x.\n", hr ); goto e_Exit; } // // Allocate memory for the URL member of // the DRM_ACTSERV_INFO structure // pdasi->wszURL = new WCHAR[ cchActivationSvr + 1 ]; if ( NULL == pdasi->wszURL ) { wprintf( L"\nMemory allocation failed for user "\ L"activation URL string.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = StringCchCopyW( pdasi->wszURL, cchActivationSvr + 1, wszActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nStringCchCopyW failed. hr = 0x%x.\n", hr ); goto e_Exit; } wprintf( L"\nUser Activation server URL:\n%s\n", pdasi->wszURL ); } else { // // 3(b). Try to find the service location where user activation // is available. // The first call is to get - // (a) whether there is a service location and // (b) if so, the size needed for a buffer to // hold the URL for the service. // hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_CERTIFICATION, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, NULL ); if ( SUCCEEDED( hr ) ) { // // There is a service location; reserve space // for the URL. // pdasi->wszURL = new WCHAR[ uiStrLen ]; if ( NULL == pdasi->wszURL ) { wprintf( L"\nMemory allocation failed for user activation "\ L"URL string.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } // // Call second time to get the actual service location // copied into the URL. // hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_CERTIFICATION, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, pdasi->wszURL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetServiceLocation (ENTERPRISE) failed. "\ L"hr = 0x%x\n", hr ); goto e_Exit; } wprintf( L"\nDRMGetServiceLocation (ENTERPRISE) succeeded.\n\n"\ L"User Activation server URL:\n%s\n", pdasi->wszURL ); } else { wprintf( L"\nDRMGetServiceLocation failed. hr = 0x%x. "\ L"\nPassing NULL server info to DRMActivate.\n", hr ); } } // // 4. Activate the user // hr = DRMActivate( hClient, DRM_ACTIVATE_GROUPIDENTITY | DRM_ACTIVATE_SILENT, 0, pdasi, ( VOID* )&context, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMActivate (DRM_ACTIVATE_GROUPIDENTITY) "\ L"failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 5. Wait for the callback to return // dwWaitResult = WaitForSingleObject( context.hEvent, DW_WAIT_TIME_SECONDS ); if ( WAIT_TIMEOUT == dwWaitResult ) { wprintf( L"\nWaitForSingleObject timed out.\n" ); goto e_Exit; } if ( FAILED( context.hr ) ) { // // In case a failure was reported via the callback function // note it also. // wprintf( L"\nThe callback function returned a failure "\ L"code. hr = 0x%x\n", context.hr ); hr = context.hr; goto e_Exit; } wprintf( L"\nThe user is now activated.\n" ); e_Exit: // // 6. Clean up and free memory // if ( NULL != pdasi ) { if ( NULL != pdasi->wszURL ) { delete [] pdasi->wszURL; } delete pdasi; } if ( NULL != context.hEvent ) { CloseHandle( context.hEvent ); } return hr; } // // This function performs the following actions: // 1. Validate the parameters // 2. Create an event for the callback function // 3. Populate the wszLicensingSvr parameter. This value can // be from: // (a) a command line argument // (b) service discovery // 4. Acquire the client licensor certificate // 5. Wait for the callback to return // 6. Enumerate the client licensor certificate // 7. Clean up and free memory // HRESULT DoAcquireClientLicensorCertificate( DRMHSESSION hClient, __in PWCHAR wszLicensingSvr, __in PWCHAR wszUserId, __deref_out PWCHAR *wszClientLicensorCert ) { HRESULT hr = E_FAIL; UINT uiStrLen = 0; UINT uiClientLicensorCertLength = 0; BOOL fShared = false; DRM_CONTEXT context; DWORD dwWaitResult; context.hEvent = NULL; // // 1. Validate the parameters // if ( ( NULL == hClient ) || ( NULL == wszUserId ) ) { wprintf( L"\nInvalid parameter.\n" ); hr = E_INVALIDARG; goto e_Exit; } // // 2. Create an event for the callback function. This event will be // passed as a void pointer to DRMAcquireLicense. DRMAcquireLicense // simply passes back this pointer to the StatusCallback callback // function which knows that it is an event and will thus signal it // when completed. // if ( NULL == ( context.hEvent = CreateEvent( NULL, FALSE, FALSE, NULL ) ) ) { wprintf( L"\ncontext.hEvent was NULL after the CreateEvent call.\n" ); goto e_Exit; } // // 3. If the licensing URL was not passed in via the command line, // find the licensing URL through service discovery // if ( NULL == wszLicensingSvr ) { // The first call is to get - // (a) whether there is a service location and // (b) if so, the size needed for a buffer to // hold the URL for the service. // hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_CLIENTLICENSOR, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetServiceLocation failed. hr = 0x%x\n", hr ); goto e_Exit; } wszLicensingSvr = new WCHAR[ uiStrLen ]; if ( NULL == wszLicensingSvr ) { wprintf( L"\nMemory allocation failed for the "\ L"licensing URL string.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = DRMGetServiceLocation( hClient, DRM_SERVICE_TYPE_CLIENTLICENSOR, DRM_SERVICE_LOCATION_ENTERPRISE, NULL, &uiStrLen, wszLicensingSvr ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetServiceLocation failed. hr = 0x%x\n", hr ); goto e_Exit; } } wprintf( L"\nLicensing server URL:\n%s\n", wszLicensingSvr ); // // 4. Acquire the client licensor certificate // hr = DRMAcquireLicense( hClient, 0, NULL, NULL, NULL, wszLicensingSvr, ( VOID* )&context ); if ( FAILED( hr ) ) { wprintf( L"\nDRMAcquireLicense failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 5. Wait for the callback to return // dwWaitResult = WaitForSingleObject( context.hEvent, DW_WAIT_TIME_SECONDS ); if ( WAIT_TIMEOUT == dwWaitResult ) { wprintf( L"\nWaitForSingleObject timed out.\n" ); goto e_Exit; } if ( FAILED( context.hr ) ) { // // In case a failure was reported via the callback function // note it also. // hr = context.hr; wprintf( L"\nThe callback function returned a failure "\ L"code. hr = 0x%x\n", context.hr ); goto e_Exit; } wprintf( L"\nA client licensor certificate has been acquired.\n" ); // // 6. Enumerate the client licensor certificate to return it // hr = DRMEnumerateLicense( hClient, DRM_EL_SPECIFIED_CLIENTLICENSOR, 0, &fShared, &uiClientLicensorCertLength, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMEnumerateLicense (DRM_EL_SPECIFIED_CLIENTLICENSOR) "\ L"failed. hr = 0x%x\n", hr ); goto e_Exit; } *wszClientLicensorCert = new WCHAR[ uiClientLicensorCertLength ]; if ( NULL == *wszClientLicensorCert ) { wprintf( L"\nMemory allocation for wszClientLicensorCert failed.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = DRMEnumerateLicense( hClient, DRM_EL_SPECIFIED_CLIENTLICENSOR, 0, &fShared, &uiClientLicensorCertLength, *wszClientLicensorCert ); if ( FAILED( hr ) ) { wprintf( L"\nDRMEnumerateLicense(DRM_EL_SPECIFIED_CLIENTLICENSOR)"\ L" failed. hr = 0x%x\n", hr ); goto e_Exit; } e_Exit: // // 7. Clean up and free memory // if ( NULL != context.hEvent ) { CloseHandle( context.hEvent ); } return hr; } // // This sample will perform the following actions: // 1. Create a client session // 2. Determine if the machine is already activated // 3. Call DoMachineActivation if the machine needs to be activated // 4. Enumerate the machine certificate // 5. Determine if the user is already activated // 6. Call DoUserActivation if the user needs to be activated // 7. Enumerate the client licensor certificates to determine if one // has already been acquired // 8. If there are no client licensor certificates, call // DoAcquireClientLicensorCertificate to acquire one // 9. Read the manifest file into a buffer // 10. Get the security provider // 11. Initialize an environment // 12. Create an unsigned issuance license from scratch // 13. Set the metadata, application specific data, interval time, // and usage policy in the unsigned issuance license // 14. Create a user and right and add those to the // unsigned issuance license // 15. Sign the unsigned issuance license offline // 16. Wait for the callback to return // 17. Clean up and free memory // int __cdecl wmain( int argc, __in_ecount( argc )WCHAR **argv ) { HRESULT hr = E_FAIL; DRMHSESSION hClient = NULL; DRMPUBHANDLE hIssuanceLicense = NULL; DRMPUBHANDLE hUser = NULL; DRMPUBHANDLE hRight = NULL; DRMENVHANDLE hEnv = NULL; DRMHANDLE hLib = NULL; GUID guid; BOOL fShared = false; SYSTEMTIME stTimeFrom, stTimeUntil; PWSTR wszGUID = NULL; PWCHAR wszUserId = NULL; PWCHAR wszActivationSvr = NULL; PWCHAR wszLicensingSvr = NULL; PWCHAR wszManifestFileName = NULL; PWCHAR wszManifest = NULL; PWCHAR wszClientLicensorCert = NULL; PWCHAR wszSecurityProviderType = NULL; PWCHAR wszSecurityProviderPath = NULL; PWCHAR wszMachineCertificate = NULL; UINT uiMachineCertLength = 0; UINT uiSecurityProviderTypeLength = 0; UINT uiSecurityProviderPathLength = 0; UINT uiGUIDLength = 0; UINT uiClientLicensorCertLength = 0; DRM_CONTEXT context; DWORD dwWaitResult; context.hEvent = NULL; context.wszData = NULL; if ( FAILED ( ParseCommandLine( argc, argv, &wszUserId, &wszActivationSvr, &wszLicensingSvr, &wszManifestFileName ) ) ) { PrintUsage(); goto e_Exit; } wprintf( L"\nRunning sample OfflinePublishing...\n" ); // // 1. Create a client session // hr = DRMCreateClientSession( &StatusCallback, 0, DRM_DEFAULTGROUPIDTYPE_WINDOWSAUTH, wszUserId, &hClient ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCreateClientSession failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 2. Call DRMIsActivated to determine if the machine is already activated // hr = DRMIsActivated( hClient, DRM_ACTIVATE_MACHINE, NULL ); if ( E_DRM_NEEDS_MACHINE_ACTIVATION == hr ) { // // 3. Call DoMachineActivation to activate the machine if // it's not activated // hr = DoMachineActivation( hClient, wszActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nDoMachineActivation failed. hr = 0x%x\n", hr ); goto e_Exit; } } else if ( hr == S_OK ) { wprintf( L"\nThe machine is already activated.\n" ); } else { wprintf( L"\nDRMIsActivated returned an unexpected failure: 0x%x. "\ L"E_DRM_NEEDS_MACHINE_ACTIVATION was expected.\n", hr ); goto e_Exit; } // // 4. Enumerate the machine certificate // hr = DRMEnumerateLicense( hClient, DRM_EL_MACHINE, 0, &fShared, &uiMachineCertLength, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMEnumerateLicense failed. hr = 0x%x\n", hr ); goto e_Exit; } wszMachineCertificate = new WCHAR[ uiMachineCertLength ]; if ( NULL == wszMachineCertificate ) { wprintf( L"\nMemory allocation failed for wszMachineCertificate\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = DRMEnumerateLicense( hClient, DRM_EL_MACHINE, 0, &fShared, &uiMachineCertLength, wszMachineCertificate ); if ( FAILED( hr ) ) { wprintf( L"\nDRMEnumerateLicense failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 5. Call DRMIsActivated to determine if the user is // already activated. // hr = DRMIsActivated( hClient, DRM_ACTIVATE_GROUPIDENTITY, NULL ); if ( SUCCEEDED( hr ) ) { wprintf( L"\nThe user is already activated.\n" ); } else if ( E_DRM_NEEDS_GROUPIDENTITY_ACTIVATION == hr ) { // // 6. Call DoUserActivation to activate the user if the user // is not activated // hr = DoUserActivation( hClient, wszActivationSvr ); if ( FAILED( hr ) ) { wprintf( L"\nDoUserActivation failed. hr = 0x%x\n", hr ); goto e_Exit; } } else if ( E_DRM_NEEDS_GROUPIDENTITY_ACTIVATION != hr ) { wprintf( L"\nDRMIsActivated returned an unexpected failure: 0x%x. "\ L"E_DRM_NEEDS_GROUPIDENTITY_ACTIVATION "\ L"was expected.\n", hr ); goto e_Exit; } // // 7. Enumerate the client licensor certificates to determine if one // has already been acquired. If not, get a client licensor cert. // hr = DRMEnumerateLicense( hClient, DRM_EL_SPECIFIED_CLIENTLICENSOR, 0, &fShared, &uiClientLicensorCertLength, NULL ); if ( FAILED( hr ) && ( E_DRM_NO_MORE_DATA != hr ) ) { wprintf( L"\nDRMEnumerateLicense (DRM_EL_SPECIFIED_CLIENTLICENSOR) "\ L"failed. hr = 0x%x\n", hr ); goto e_Exit; } else if ( E_DRM_NO_MORE_DATA == hr ) { // 8. If there are no client licensor certificates, call // DoAcquireClientLicensorCertificate to acquire one hr = DoAcquireClientLicensorCertificate( hClient, wszLicensingSvr, wszUserId, &wszClientLicensorCert ); if ( FAILED( hr ) ) { wprintf( L"\nDoAcquireClientLicensorCertificate failed. "\ L"hr = 0x%x\n", hr ); goto e_Exit; } } else { wprintf( L"\nA client licensor certificate is "\ L"already in the license store.\n" ); wszClientLicensorCert = new WCHAR[ uiClientLicensorCertLength ]; if ( NULL == wszClientLicensorCert ) { wprintf( L"\nMemory allocation of wszClientLicensorCert "\ L"failed.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = DRMEnumerateLicense( hClient, DRM_EL_SPECIFIED_CLIENTLICENSOR, 0, &fShared, &uiClientLicensorCertLength, wszClientLicensorCert ); if ( FAILED( hr ) ) { wprintf( L"\nDRMEnumerateLicense(DRM_EL_SPECIFIED_CLIENTLICENSOR)"\ L" failed. hr = 0x%x\n", hr ); goto e_Exit; } } // // 9. Read the manifest file into a buffer // hr = ReadFileToWideString( wszManifestFileName, &wszManifest ); if ( FAILED( hr ) ) { wprintf( L"\nReadFileToWideString failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 10. Get the security provider // hr = DRMGetSecurityProvider( 0, &uiSecurityProviderTypeLength, NULL, &uiSecurityProviderPathLength, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetSecurityProvider failed. hr = 0x%x\n", hr ); goto e_Exit; } wszSecurityProviderType = new WCHAR[ uiSecurityProviderTypeLength ]; if ( NULL == wszSecurityProviderType ) { wprintf( L"\nMemory allocation for wszSecurityProviderType "\ L"failed.\n" ); hr = E_OUTOFMEMORY; goto e_Exit; } wszSecurityProviderPath = new WCHAR[ uiSecurityProviderPathLength ]; if ( NULL == wszSecurityProviderPath ) { wprintf( L"\nMemory allocation for wszSecurityProviderPath "\ L"failed." ); hr = E_OUTOFMEMORY; goto e_Exit; } hr = DRMGetSecurityProvider( 0, &uiSecurityProviderTypeLength, wszSecurityProviderType, &uiSecurityProviderPathLength, wszSecurityProviderPath ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetSecurityProvider failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 11. Initialize an environment // hr = DRMInitEnvironment( DRMSECURITYPROVIDERTYPE_SOFTWARESECREP, DRMSPECTYPE_FILENAME, wszSecurityProviderPath, wszManifest, wszMachineCertificate, &hEnv, &hLib ); if ( FAILED( hr ) ) { wprintf( L"\nDRMInitEnvironment failed. hr = 0x%x.\n", hr ); goto e_Exit; } // // Get the system time for the starting and ending validity times // in the unsigned issuance license // GetSystemTime( &stTimeFrom ); GetSystemTime( &stTimeUntil ); FILETIME ft = { 0 }; SystemTimeToFileTime(&stTimeUntil, &ft); ULARGE_INTEGER u = { 0 }; memcpy(&u, &ft, sizeof(u)); u.QuadPart += 90 * 24 * 60 * 60 * 10000000LLU; // 90 days memcpy(&ft, &u, sizeof(ft)); FileTimeToSystemTime(&ft, &stTimeUntil); // // 12. Create an unsigned issuance license from scratch // hr = DRMCreateIssuanceLicense( &stTimeFrom, &stTimeUntil, NULL, NULL, NULL, NULL, NULL, &hIssuanceLicense ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCreateIssuanceLicense failed. hr = 0x%x\n", hr ); goto e_Exit; } // // Create a GUID to use as a unique content ID // in the issuance license // hr = CoCreateGuid( &guid ); if ( FAILED( hr ) ) { wprintf( L"\nCoCreateGuid failed. hr = 0x%x\n", hr ); goto e_Exit; } wszGUID = new WCHAR[ GUID_STRING_LENGTH ]; if ( NULL == wszGUID ) { wprintf( L"\nFailed to allocate memory for wszGUID\n" ); goto e_Exit; } uiGUIDLength = StringFromGUID2( guid, wszGUID, GUID_STRING_LENGTH ); if ( 0 == uiGUIDLength ) { wprintf( L"\nStringFromGUID2 failed.\n" ); hr = E_FAIL; goto e_Exit; } // // 13. Set the metadata, application specific data, interval time, and // usage policy in the unsigned issuance license // hr = DRMSetMetaData( hIssuanceLicense, wszGUID, L"MS-GUID", SKU_ID, SKU_ID_TYPE, CONTENT_TYPE, CONTENT_NAME ); if ( FAILED( hr ) ) { wprintf( L"\nDRMSetMetaData failed. hr = 0x%x\n", hr ); goto e_Exit; } // // Set the application specific data // hr = DRMSetApplicationSpecificData( hIssuanceLicense, false, APP_SPECIFIC_DATA_NAME, APP_SPECIFIC_DATA_VALUE ); if ( FAILED( hr ) ) { wprintf( L"\nDRMSetApplicationSpecificData failed. hr = 0x%x\n", hr ); goto e_Exit; } // // Set the interval time // hr = DRMSetIntervalTime( hIssuanceLicense, INTERVAL_TIME_DAYS ); if ( FAILED( hr ) ) { wprintf( L"\nDRMSetIntervalTime failed. hr = 0x%x\n", hr ); goto e_Exit; } // // Set the usage policy // hr = DRMSetUsagePolicy( hIssuanceLicense, DRM_USAGEPOLICY_TYPE_BYNAME, false, true, USAGE_POLICY_APPLICATION_NAME, USAGE_POLICY_MIN_VERSION, USAGE_POLICY_MAX_VERSION, NULL, NULL, NULL, NULL ); if ( FAILED( hr ) ) { wprintf( L"\nDRMSetUsagePolicy failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 14. Create a user and right and add that to // the unsigned issuance license // hr = DRMCreateUser( wszUserId, NULL, L"Windows", &hUser ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCreateUser failed. hr = 0x%x\n", hr ); goto e_Exit; } hr = DRMCreateRight( RIGHT_NAME, &stTimeFrom, &stTimeUntil, 0, NULL, NULL, &hRight ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCreateRight failed. hr = 0x%x\n", hr ); goto e_Exit; } hr = DRMAddRightWithUser( hIssuanceLicense, hRight, hUser ); if ( FAILED( hr ) ) { wprintf( L"\nDRMAddRightWithUser failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 15. Sign the issuance license offline // hr = DRMGetSignedIssuanceLicense( hEnv, hIssuanceLicense, DRM_SIGN_OFFLINE | DRM_AUTO_GENERATE_KEY, NULL, 0, L"AES", wszClientLicensorCert, &StatusCallback, wszLicensingSvr, ( VOID* )&context ); if ( FAILED( hr ) ) { wprintf( L"\nDRMGetSignedIssuanceLicense failed. hr = 0x%x\n", hr ); goto e_Exit; } // // 16. Wait for the callback to return // dwWaitResult = WaitForSingleObject( context.hEvent, DW_WAIT_TIME_SECONDS ); if ( WAIT_TIMEOUT == dwWaitResult ) { wprintf( L"\nWaitForSingleObject timed out.\n" ); goto e_Exit; } if ( FAILED( context.hr ) ) { // // In case a failure was reported via the callback function // note it also. // wprintf( L"\nThe callback function returned a failure "\ L"code. hr = 0x%x\n", context.hr ); hr = context.hr; goto e_Exit; } wprintf( L"\nThe signed issuance license is: \n\n%s\n", context.wszData ); wprintf( L"\nDRMGetSignedIssuanceLicense succeeded.\n" ); e_Exit: // // 17. Clean up and free memory // if ( NULL != hClient ) { hr = DRMCloseSession( hClient ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCloseSession failed while closing "\ L"hClient. hr = 0x%x\n", hr ); } } if ( NULL != context.wszData ) { delete [] context.wszData; } if ( NULL != context.hEvent ) { CloseHandle( context.hEvent ); } if ( NULL != hIssuanceLicense ) { hr = DRMClosePubHandle( hIssuanceLicense ); if ( FAILED( hr ) ) { wprintf( L"\nDRMClosePubHandle failed while closing "\ L"hIssuanceLicense. hr = 0x%x\n", hr ); } } if ( NULL != hUser ) { hr = DRMClosePubHandle( hUser ); if ( FAILED( hr ) ) { wprintf( L"\nDRMClosePubHandle failed while closing "\ L"hUser. hr = 0x%x\n", hr ); } } if ( NULL != hRight ) { hr = DRMClosePubHandle( hRight ); if ( FAILED( hr ) ) { wprintf( L"\nDRMClosePubHandle failed while closing "\ L"hRight. hr = 0x%x\n", hr ); } } if ( NULL != hLib ) { hr = DRMCloseHandle( hLib ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCloseHandle failed while closing "\ L"hLib. hr = 0x%x\n", hr ); } } if ( NULL != hEnv ) { hr = DRMCloseEnvironmentHandle( hEnv ); if ( FAILED( hr ) ) { wprintf( L"\nDRMCloseEnvironmentHandle failed while closing "\ L"hEnv. hr = 0x%x\n", hr ); } } if ( NULL != wszGUID ) { delete [] wszGUID; } if ( NULL != wszUserId ) { delete [] wszUserId; } if ( NULL != wszActivationSvr ) { delete [] wszActivationSvr; } if ( NULL != wszLicensingSvr ) { delete [] wszLicensingSvr; } if ( NULL != wszManifestFileName ) { delete [] wszManifestFileName; } if ( NULL != wszManifest ) { delete [] wszManifest; } if ( NULL != wszClientLicensorCert ) { delete [] wszClientLicensorCert; } if ( NULL != wszSecurityProviderType ) { delete [] wszSecurityProviderType; } if ( NULL != wszSecurityProviderPath ) { delete [] wszSecurityProviderPath; } if ( NULL != wszMachineCertificate ) { delete [] wszMachineCertificate; } if ( FAILED( hr ) ) { wprintf( L"\nOfflinePublishing failed. hr = 0x%x\n", hr ); } return hr; }