Headers diff for msdrm.dll between 6.1.7601.18332-Windows_7.0 and 6.3.9600.17415-Windows_8.1 versions

msdrm.h (6.1.7601.18332-Windows_7.0)		msdrm.h (6.3.9600.17415-Windows_8.1)
#pragma once		#pragma once

#ifndef __MSDRM_H_		#ifndef __MSDRM_H_
#define __MSDRM_H_		#define __MSDRM_H_


		#include <winapifamily.h>

		#pragma region Desktop Family
		#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

//-----------------------------------------------------------------------------		//-----------------------------------------------------------------------------
//		//
//		//
// File: msdrm.h		// File: msdrm.h
//		//
// Copyright (C) 2001-2004 Microsoft Corporation. All Rights Reserved.		// Copyright (C) 2001-2004 Microsoft Corporation. All Rights Reserved.
//		//
//-----------------------------------------------------------------------------		//-----------------------------------------------------------------------------

#include "msdrmdefs.h"		#include "msdrmdefs.h"

skipping to change at line 30		skipping to change at line 35
IN DRMGLOBALOPTIONS eGlobalOptions,		IN DRMGLOBALOPTIONS eGlobalOptions,
IN LPVOID pvdata,		IN LPVOID pvdata,
IN DWORD dwlen);		IN DWORD dwlen);

DRMEXPORT HRESULT UDAPICALL DRMGetClientVersion(		DRMEXPORT HRESULT UDAPICALL DRMGetClientVersion(
OUT DRM_CLIENT_VERSION_INFO *pDRMClientVersionInfo);		OUT DRM_CLIENT_VERSION_INFO *pDRMClientVersionInfo);

DRMEXPORT HRESULT UDAPICALL DRMInitEnvironment (		DRMEXPORT HRESULT UDAPICALL DRMInitEnvironment (
IN DRMSECURITYPROVIDERTYPE eSecurityProviderType,		IN DRMSECURITYPROVIDERTYPE eSecurityProviderType,
IN DRMSPECTYPE eSpecification,		IN DRMSPECTYPE eSpecification,

__in_opt PWSTR wszSecurityProvider,		_In_opt_ PWSTR wszSecurityProvider,
__in_opt PWSTR wszManifestCredentials,		_In_opt_ PWSTR wszManifestCredentials,
__in PWSTR wszMachineCredentials,		_In_ PWSTR wszMachineCredentials,
OUT DRMENVHANDLE* phEnv,		OUT DRMENVHANDLE* phEnv,
OUT DRMHANDLE* phDefaultLibrary);		OUT DRMHANDLE* phDefaultLibrary);

DRMEXPORT HRESULT UDAPICALL DRMLoadLibrary (		DRMEXPORT HRESULT UDAPICALL DRMLoadLibrary (
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,
IN DRMSPECTYPE eSpecification,		IN DRMSPECTYPE eSpecification,

__in PWSTR wszLibraryProvider,		_In_ PWSTR wszLibraryProvider,
__in_opt PWSTR wszCredentials,		_In_opt_ PWSTR wszCredentials,
OUT DRMHANDLE* phLibrary);		OUT DRMHANDLE* phLibrary);

DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingPrincipal (		DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingPrincipal (
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,
IN DRMHANDLE hLibrary,		IN DRMHANDLE hLibrary,

__in PWSTR wszObject,		_In_ PWSTR wszObject,
IN DRMID* pidPrincipal,		IN DRMID* pidPrincipal,

__in PWSTR wszCredentials,		_In_ PWSTR wszCredentials,
OUT DRMHANDLE* phEnablingPrincipal);		OUT DRMHANDLE* phEnablingPrincipal);

DRMEXPORT HRESULT UDAPICALL DRMCloseHandle(		DRMEXPORT HRESULT UDAPICALL DRMCloseHandle(
IN DRMHANDLE handle);		IN DRMHANDLE handle);

DRMEXPORT HRESULT UDAPICALL DRMCloseEnvironmentHandle(		DRMEXPORT HRESULT UDAPICALL DRMCloseEnvironmentHandle(
IN DRMENVHANDLE hEnv);		IN DRMENVHANDLE hEnv);

DRMEXPORT HRESULT UDAPICALL DRMDuplicateHandle(		DRMEXPORT HRESULT UDAPICALL DRMDuplicateHandle(
IN DRMHANDLE hToCopy,		IN DRMHANDLE hToCopy,
OUT DRMHANDLE* phCopy);		OUT DRMHANDLE* phCopy);

DRMEXPORT HRESULT UDAPICALL DRMDuplicateEnvironmentHandle(		DRMEXPORT HRESULT UDAPICALL DRMDuplicateEnvironmentHandle(
IN DRMENVHANDLE hToCopy,		IN DRMENVHANDLE hToCopy,
OUT DRMENVHANDLE* phCopy);		OUT DRMENVHANDLE* phCopy);

DRMEXPORT HRESULT UDAPICALL DRMRegisterRevocationList (		DRMEXPORT HRESULT UDAPICALL DRMRegisterRevocationList (
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,

__in_opt PWSTR wszRevocationList);		_In_opt_ PWSTR wszRevocationList);

DRMEXPORT HRESULT UDAPICALL DRMCheckSecurity(		DRMEXPORT HRESULT UDAPICALL DRMCheckSecurity(
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,
IN UINT cLevel);		IN UINT cLevel);

DRMEXPORT HRESULT UDAPICALL DRMRegisterContent(		DRMEXPORT HRESULT UDAPICALL DRMRegisterContent(
IN BOOL fRegister);		IN BOOL fRegister);

// cryptographic functions		// cryptographic functions


skipping to change at line 99		skipping to change at line 104
IN UINT cNumInBytes,		IN UINT cNumInBytes,
IN BYTE* pbInData,		IN BYTE* pbInData,
IN OUT UINT* pcNumOutBytes,		IN OUT UINT* pcNumOutBytes,
OUT BYTE* pbOutData);		OUT BYTE* pbOutData);

// license binding and enabling bits		// license binding and enabling bits

DRMEXPORT HRESULT UDAPICALL DRMCreateBoundLicense (		DRMEXPORT HRESULT UDAPICALL DRMCreateBoundLicense (
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,
IN DRMBOUNDLICENSEPARAMS* pParams,		IN DRMBOUNDLICENSEPARAMS* pParams,

__in PWSTR wszLicenseChain,		_In_ PWSTR wszLicenseChain,
OUT DRMHANDLE* phBoundLicense,		OUT DRMHANDLE* phBoundLicense,
OUT DRMHANDLE* phErrorLog);		OUT DRMHANDLE* phErrorLog);

DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingBitsDecryptor (		DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingBitsDecryptor (
IN DRMHANDLE hBoundLicense,		IN DRMHANDLE hBoundLicense,

__in_opt PWSTR wszRight,		_In_opt_ PWSTR wszRight,
IN DRMHANDLE hAuxLib,		IN DRMHANDLE hAuxLib,

__in_opt PWSTR wszAuxPlug,		_In_opt_ PWSTR wszAuxPlug,
OUT DRMHANDLE* phDecryptor);		OUT DRMHANDLE* phDecryptor);

DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingBitsEncryptor (		DRMEXPORT HRESULT UDAPICALL DRMCreateEnablingBitsEncryptor (
IN DRMHANDLE hBoundLicense,		IN DRMHANDLE hBoundLicense,

__in_opt PWSTR wszRight,		_In_opt_ PWSTR wszRight,
IN DRMHANDLE hAuxLib,		IN DRMHANDLE hAuxLib,

__in_opt PWSTR wszAuxPlug,		_In_opt_ PWSTR wszAuxPlug,
OUT DRMHANDLE* phEncryptor);		OUT DRMHANDLE* phEncryptor);

// inter-environment security attestation		// inter-environment security attestation

DRMEXPORT HRESULT UDAPICALL DRMAttest (		DRMEXPORT HRESULT UDAPICALL DRMAttest (
IN DRMHANDLE hEnablingPrincipal,		IN DRMHANDLE hEnablingPrincipal,

__in PWSTR wszData,		_In_ PWSTR wszData,
IN DRMATTESTTYPE eType,		IN DRMATTESTTYPE eType,

__inout UINT* pcAttestedBlob,		_Inout_ UINT* pcAttestedBlob,
__out_ecount(*pcAttestedBlob) PWSTR wszAttestedBlob);		_Out_writes_(*pcAttestedBlob) PWSTR wszAttestedBlob);

// miscellaneous calls and helper functions		// miscellaneous calls and helper functions

DRMEXPORT HRESULT UDAPICALL DRMGetTime (		DRMEXPORT HRESULT UDAPICALL DRMGetTime (
IN DRMENVHANDLE hEnv,		IN DRMENVHANDLE hEnv,
IN DRMTIMETYPE eTimerIdType,		IN DRMTIMETYPE eTimerIdType,
OUT SYSTEMTIME* poTimeObject);		OUT SYSTEMTIME* poTimeObject);

DRMEXPORT HRESULT UDAPICALL DRMGetInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetInfo(

__in DRMHANDLE handle,		_In_ DRMHANDLE handle,
__in PWSTR wszAttribute,		_In_ PWSTR wszAttribute,
__in DRMENCODINGTYPE* peEncoding,		_In_ DRMENCODINGTYPE* peEncoding,
__inout UINT* pcBuffer,		_Inout_ UINT* pcBuffer,
OUT BYTE* pbBuffer);		OUT BYTE* pbBuffer);

DRMEXPORT HRESULT UDAPICALL DRMGetEnvironmentInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetEnvironmentInfo(
IN DRMENVHANDLE handle,		IN DRMENVHANDLE handle,

__in_opt PWSTR wszAttribute,		_In_opt_ PWSTR wszAttribute,
OUT DRMENCODINGTYPE* peEncoding,		OUT DRMENCODINGTYPE* peEncoding,
IN OUT UINT* pcBuffer,		IN OUT UINT* pcBuffer,
OUT BYTE* pbBuffer);		OUT BYTE* pbBuffer);

DRMEXPORT HRESULT UDAPICALL DRMGetProcAddress(		DRMEXPORT HRESULT UDAPICALL DRMGetProcAddress(
IN DRMHANDLE hLibrary,		IN DRMHANDLE hLibrary,

__in PWSTR wszProcName,		_In_ PWSTR wszProcName,
OUT FARPROC* ppfnProcAddress);		OUT FARPROC* ppfnProcAddress);

// support for querying bound licenses		// support for querying bound licenses

DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseObjectCount(		DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseObjectCount(
IN DRMHANDLE hQueryRoot,		IN DRMHANDLE hQueryRoot,

__in PWSTR wszSubObjectType,		_In_ PWSTR wszSubObjectType,
OUT UINT* pcSubObjects);		OUT UINT* pcSubObjects);

DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseObject(		DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseObject(
IN DRMHANDLE hQueryRoot,		IN DRMHANDLE hQueryRoot,

__in PWSTR wszSubObjectType,		_In_ PWSTR wszSubObjectType,
IN UINT iWhich,		IN UINT iWhich,
OUT DRMHANDLE* phSubObject);		OUT DRMHANDLE* phSubObject);

DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseAttributeCount(		DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseAttributeCount(
IN DRMHANDLE hQueryRoot,		IN DRMHANDLE hQueryRoot,

__in PWSTR wszAttribute,		_In_ PWSTR wszAttribute,
OUT UINT* pcAttributes);		OUT UINT* pcAttributes);

DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseAttribute(		DRMEXPORT HRESULT UDAPICALL DRMGetBoundLicenseAttribute(
IN DRMHANDLE hQueryRoot,		IN DRMHANDLE hQueryRoot,

__in PWSTR wszAttribute,		_In_ PWSTR wszAttribute,
IN UINT iWhich,		IN UINT iWhich,
OUT DRMENCODINGTYPE* peEncoding,		OUT DRMENCODINGTYPE* peEncoding,
IN OUT UINT* pcBuffer,		IN OUT UINT* pcBuffer,
OUT BYTE* pbBuffer);		OUT BYTE* pbBuffer);

DRMEXPORT HRESULT UDAPICALL DRMCreateClientSession(		DRMEXPORT HRESULT UDAPICALL DRMCreateClientSession(
IN DRMCALLBACK pfnCallback, // Callback		IN DRMCALLBACK pfnCallback, // Callback
IN UINT uCallbackVersion, // Version of the callback		IN UINT uCallbackVersion, // Version of the callback

__in PWSTR wszGroupIDProviderType, // one of		_In_ PWSTR wszGroupIDProviderType, // one of
WINDOWSAUTH/PASSPORT		WINDOWSAUTH/PASSPORT
__in_opt PWSTR wszGroupID, // Group I		_In_opt_ PWSTR wszGroupID, // Group I
D		D
OUT DRMHSESSION* phClient );		OUT DRMHSESSION* phClient );

DRMEXPORT HRESULT UDAPICALL DRMIsActivated(		DRMEXPORT HRESULT UDAPICALL DRMIsActivated(
IN DRMHSESSION hClient, // Client session		IN DRMHSESSION hClient, // Client session
IN UINT uFlags, // One of DRM_ACTIVA TE_MACHINE/GROUPIDENTITY		IN UINT uFlags, // One of DRM_ACTIVA TE_MACHINE/GROUPIDENTITY
IN DRM_ACTSERV_INFO* pActServInfo);// Optional activati on server info		IN DRM_ACTSERV_INFO* pActServInfo);// Optional activati on server info

DRMEXPORT HRESULT UDAPICALL DRMActivate(		DRMEXPORT HRESULT UDAPICALL DRMActivate(
IN DRMHSESSION hClient, // Client session		IN DRMHSESSION hClient, // Client session
IN UINT uFlags, // One/both: DRM_A CTIVATE_MACHINE/GROUPIDENTITY		IN UINT uFlags, // One/both: DRM_A CTIVATE_MACHINE/GROUPIDENTITY
IN UINT uLangID, // Language ID		IN UINT uLangID, // Language ID
IN DRM_ACTSERV_INFO* pActServInfo, // Optional activati on server info		IN DRM_ACTSERV_INFO* pActServInfo, // Optional activati on server info
IN VOID* pvContext, // Context used fo r callback		IN VOID* pvContext, // Context used fo r callback
IN HWND hParentWnd); // Parent window H andle		IN HWND hParentWnd); // Parent window H andle

DRMEXPORT HRESULT UDAPICALL DRMGetServiceLocation(		DRMEXPORT HRESULT UDAPICALL DRMGetServiceLocation(
IN DRMHSESSION hClient, // Client sessi on		IN DRMHSESSION hClient, // Client sessi on
IN UINT uServiceType, //One of DRM_SE RVICE_TYPE		IN UINT uServiceType, //One of DRM_SE RVICE_TYPE
IN UINT uServiceLocation, //One of DRM_SE RVICE_LOCATION		IN UINT uServiceLocation, //One of DRM_SE RVICE_LOCATION

__in_opt PWSTR wszIssuanceLicense, //Optiona l		_In_opt_ PWSTR wszIssuanceLicense, //Optiona l
IN OUT UINT* puServiceURLLength,		IN OUT UINT* puServiceURLLength,

__out_ecount_opt(*puServiceURLLength) PWSTR w szServiceURL);		_Out_writes_opt_(*puServiceURLLength) PWSTR w szServiceURL);

// LicenseStorage		// LicenseStorage
DRMEXPORT HRESULT UDAPICALL DRMCreateLicenseStorageSession(		DRMEXPORT HRESULT UDAPICALL DRMCreateLicenseStorageSession(
IN DRMENVHANDLE hEnv, // Environment Hand le ( o/p of DRMInitEnvironment)		IN DRMENVHANDLE hEnv, // Environment Hand le ( o/p of DRMInitEnvironment)
IN DRMHANDLE hDefaultLibrary, // Default Library Handle (o/p of DRMInitEnvironment)		IN DRMHANDLE hDefaultLibrary, // Default Library Handle (o/p of DRMInitEnvironment)
IN DRMHSESSION hClient, // Client session		IN DRMHSESSION hClient, // Client session
IN UINT uFlags, // Reserved		IN UINT uFlags, // Reserved

__in PWSTR wszIssuanceLicense, // IssuanceLicens e		_In_ PWSTR wszIssuanceLicense, // IssuanceLicens e
OUT DRMHSESSION* phLicenseStorage);		OUT DRMHSESSION* phLicenseStorage);

DRMEXPORT HRESULT UDAPICALL DRMAddLicense(		DRMEXPORT HRESULT UDAPICALL DRMAddLicense(
IN DRMHSESSION hLicenseStorage, // LicenseStorage se ssion		IN DRMHSESSION hLicenseStorage, // LicenseStorage se ssion
IN UINT uFlags, // One of DRM_ADD_LI CENSE_FLAGS		IN UINT uFlags, // One of DRM_ADD_LI CENSE_FLAGS

__in PWSTR wszLicense); // License to add to the inmemory license store		_In_ PWSTR wszLicense); // License to add to the inmemory license store

DRMEXPORT HRESULT UDAPICALL DRMAcquireAdvisories(		DRMEXPORT HRESULT UDAPICALL DRMAcquireAdvisories(
IN DRMHSESSION hLicenseStorage,		IN DRMHSESSION hLicenseStorage,

__in PWSTR wszLicense,		_In_ PWSTR wszLicense,
__in_opt PWSTR wszURL,//Optional		_In_opt_ PWSTR wszURL,//Optional
IN VOID* pvContext);		IN VOID* pvContext);

DRMEXPORT HRESULT UDAPICALL DRMEnumerateLicense(		DRMEXPORT HRESULT UDAPICALL DRMEnumerateLicense(
IN DRMHSESSION hSession, // Client /License Storage session		IN DRMHSESSION hSession, // Client /License Storage session
IN UINT uFlags, // One of DRM_ENUMERATE_LICENSE_FLAGS		IN UINT uFlags, // One of DRM_ENUMERATE_LICENSE_FLAGS
IN UINT uIndex, // Cert i ndex		IN UINT uIndex, // Cert i ndex
IN OUT BOOL* pfSharedFlag, // Shared Flag		IN OUT BOOL* pfSharedFlag, // Shared Flag
IN OUT UINT* puCertificateDataLen, // String Length of wszCertificateData buffer		IN OUT UINT* puCertificateDataLen, // String Length of wszCertificateData buffer

__out_ecount_opt(*puCertificateDataLen) PWSTR w szCertificateData ); // CertChain		_Out_writes_opt_(*puCertificateDataLen) PWSTR w szCertificateData ); // CertChain

DRMEXPORT HRESULT UDAPICALL DRMAcquireLicense(		DRMEXPORT HRESULT UDAPICALL DRMAcquireLicense(
IN DRMHSESSION hSession, //Client/License Storage session		IN DRMHSESSION hSession, //Client/License Storage session
IN UINT uFlags, //DRM_ACQUIRE_LIC ENSE_FLAGS		IN UINT uFlags, //DRM_ACQUIRE_LIC ENSE_FLAGS

__in_opt PWSTR wszGroupIdentityCredential,// O		_In_opt_ PWSTR wszGroupIdentityCredential,// O
ptional		ptional
__in_opt PWSTR wszRequestedRights, //RESERVED,		_In_opt_ PWSTR wszRequestedRights, //RESERVED,
must be NULL.		must be NULL.
__in_opt PWSTR wszCustomData, //Custom da		_In_opt_ PWSTR wszCustomData, //Custom da
ta that goes with the request		ta that goes with the request
__in_opt PWSTR wszURL, //		_In_opt_ PWSTR wszURL, //
IN VOID* pvContext );		IN VOID* pvContext );

DRMEXPORT HRESULT UDAPICALL DRMDeleteLicense(		DRMEXPORT HRESULT UDAPICALL DRMDeleteLicense(
IN DRMHSESSION hSession, //Client/License Sto rage session		IN DRMHSESSION hSession, //Client/License Sto rage session

__in PWSTR wszLicenseId);		_In_ PWSTR wszLicenseId);

DRMEXPORT HRESULT UDAPICALL DRMCloseSession(		DRMEXPORT HRESULT UDAPICALL DRMCloseSession(
IN DRMHSESSION hSession);		IN DRMHSESSION hSession);

DRMEXPORT HRESULT UDAPICALL DRMDuplicateSession(		DRMEXPORT HRESULT UDAPICALL DRMDuplicateSession(
IN DRMHSESSION hSessionIn,		IN DRMHSESSION hSessionIn,
OUT DRMHSESSION *phSessionOut);		OUT DRMHSESSION *phSessionOut);

DRMEXPORT HRESULT UDAPICALL DRMGetSecurityProvider(		DRMEXPORT HRESULT UDAPICALL DRMGetSecurityProvider(
IN UINT uFlags,		IN UINT uFlags,
IN OUT UINT* puTypeLen,		IN OUT UINT* puTypeLen,

__out_ecount_opt(*puTypeLen) PWSTR wszType,		_Out_writes_opt_(*puTypeLen) PWSTR wszType,
IN OUT UINT* puPathLen,		IN OUT UINT* puPathLen,

__out_ecount_opt(*puPathLen) PWSTR wszPath);		_Out_writes_opt_(*puPathLen) PWSTR wszPath);

DRMEXPORT HRESULT UDAPICALL DRMEncode(		DRMEXPORT HRESULT UDAPICALL DRMEncode(

__in PWSTR wszAlgID,		_In_ PWSTR wszAlgID,
IN UINT uDataLen,		IN UINT uDataLen,
IN BYTE* pbDecodedData,		IN BYTE* pbDecodedData,
IN OUT UINT* puEncodedStringLen,		IN OUT UINT* puEncodedStringLen,

__out_ecount_opt(*puEncodedStringLen) PWSTR wszEncoded String);		_Out_writes_opt_(*puEncodedStringLen) PWSTR wszEncoded String);

DRMEXPORT HRESULT UDAPICALL DRMDecode(		DRMEXPORT HRESULT UDAPICALL DRMDecode(

__in PWSTR wszAlgID,		_In_ PWSTR wszAlgID,
__in PWSTR wszEncodedString,		_In_ PWSTR wszEncodedString,
IN OUT UINT* puDecodedDataLen,		IN OUT UINT* puDecodedDataLen,
OUT BYTE* pbDecodedData);		OUT BYTE* pbDecodedData);

DRMEXPORT HRESULT UDAPICALL DRMConstructCertificateChain(		DRMEXPORT HRESULT UDAPICALL DRMConstructCertificateChain(
IN UINT cCertificates,		IN UINT cCertificates,

__in_ecount(cCertificates) PWSTR* rgwszCertificates ,		_In_reads_(cCertificates) PWSTR* rgwszCertificates,
IN OUT UINT* pcChain,		IN OUT UINT* pcChain,

__out_ecount_opt(*pcChain) PWSTR wszChain);		_Out_writes_opt_(*pcChain) PWSTR wszChain);

// support for unbound license querying		// support for unbound license querying

DRMEXPORT HRESULT UDAPICALL DRMParseUnboundLicense(		DRMEXPORT HRESULT UDAPICALL DRMParseUnboundLicense(

__in PWSTR wszCertificate,		_In_ PWSTR wszCertificate,
OUT DRMQUERYHANDLE* phQueryRoot);		OUT DRMQUERYHANDLE* phQueryRoot);

DRMEXPORT HRESULT UDAPICALL DRMCloseQueryHandle(		DRMEXPORT HRESULT UDAPICALL DRMCloseQueryHandle(
IN DRMQUERYHANDLE hQuery);		IN DRMQUERYHANDLE hQuery);

DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseObjectCount(		DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseObjectCount(
IN DRMQUERYHANDLE hQueryRoot,		IN DRMQUERYHANDLE hQueryRoot,

__in PWSTR wszSubObjectType,		_In_ PWSTR wszSubObjectType,
OUT UINT* pcSubObjects);		OUT UINT* pcSubObjects);

DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseObject(		DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseObject(
IN DRMQUERYHANDLE hQueryRoot,		IN DRMQUERYHANDLE hQueryRoot,

__in PWSTR wszSubObjectType,		_In_ PWSTR wszSubObjectType,
IN UINT iIndex,		IN UINT iIndex,
OUT DRMQUERYHANDLE* phSubQuery);		OUT DRMQUERYHANDLE* phSubQuery);

DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseAttributeCount(		DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseAttributeCount(
IN DRMQUERYHANDLE hQueryRoot,		IN DRMQUERYHANDLE hQueryRoot,

__in PWSTR wszAttributeType,		_In_ PWSTR wszAttributeType,
OUT UINT* pcAttributes);		OUT UINT* pcAttributes);

DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseAttribute(		DRMEXPORT HRESULT UDAPICALL DRMGetUnboundLicenseAttribute(
IN DRMQUERYHANDLE hQueryRoot,		IN DRMQUERYHANDLE hQueryRoot,

__in PWSTR wszAttributeType,		_In_ PWSTR wszAttributeType,
IN UINT iWhich,		IN UINT iWhich,
OUT DRMENCODINGTYPE* peEncoding,		OUT DRMENCODINGTYPE* peEncoding,
IN OUT UINT* pcBuffer,		IN OUT UINT* pcBuffer,
OUT BYTE* pbBuffer);		OUT BYTE* pbBuffer);

DRMEXPORT HRESULT UDAPICALL DRMGetCertificateChainCount(		DRMEXPORT HRESULT UDAPICALL DRMGetCertificateChainCount(

__in PWSTR wszChain,		_In_ PWSTR wszChain,
OUT UINT* pcCertCount);		OUT UINT* pcCertCount);

DRMEXPORT HRESULT UDAPICALL DRMDeconstructCertificateChain(		DRMEXPORT HRESULT UDAPICALL DRMDeconstructCertificateChain(

__in PWSTR wszChain,		_In_ PWSTR wszChain,
IN UINT iWhich,		IN UINT iWhich,
IN OUT UINT* pcCert,		IN OUT UINT* pcCert,

__out_ecount_opt(*pcCert) PWSTR wszCert);		_Out_writes_opt_(*pcCert) PWSTR wszCert);

DRMEXPORT HRESULT UDAPICALL DRMVerify (		DRMEXPORT HRESULT UDAPICALL DRMVerify (

__in_opt PWSTR wszData,		_In_opt_ PWSTR wszData,
UINT* pcAttestedData,		UINT* pcAttestedData,

__out_ecount_opt(*pcAttestedData) PWSTR wszAttestedData,		_Out_writes_opt_(*pcAttestedData) PWSTR wszAttestedData,
DRMATTESTTYPE* peType,		DRMATTESTTYPE* peType,
UINT* pcPrincipal,		UINT* pcPrincipal,

__out_ecount_opt(*pcPrincipal) PWSTR wszPrincipal,		_Out_writes_opt_(*pcPrincipal) PWSTR wszPrincipal,
UINT* pcManifest,		UINT* pcManifest,

__out_ecount_opt(*pcManifest) PWSTR wszManifest);		_Out_writes_opt_(*pcManifest) PWSTR wszManifest);

DRMEXPORT HRESULT UDAPICALL DRMCreateUser(		DRMEXPORT HRESULT UDAPICALL DRMCreateUser(

__in_opt PWSTR wszUserName,		_In_opt_ PWSTR wszUserName,
__in_opt PWSTR wszUserId,		_In_opt_ PWSTR wszUserId,
__in_opt PWSTR wszUserIdType,		_In_opt_ PWSTR wszUserIdType,
OUT DRMPUBHANDLE* phUser);		OUT DRMPUBHANDLE* phUser);

DRMEXPORT HRESULT UDAPICALL DRMCreateRight(		DRMEXPORT HRESULT UDAPICALL DRMCreateRight(

__in PWSTR wszRightName,		_In_ PWSTR wszRightName,
IN SYSTEMTIME* pstFrom,		IN SYSTEMTIME* pstFrom,
IN SYSTEMTIME* pstUntil,		IN SYSTEMTIME* pstUntil,
IN UINT cExtendedInfo,		IN UINT cExtendedInfo,

__in_ecount_opt(cExtendedInfo) PWSTR* p		_In_reads_opt_(cExtendedInfo) PWSTR* pw
wszExtendedInfoName,		szExtendedInfoName,
__in_ecount_opt(cExtendedInfo) PWSTR* p		_In_reads_opt_(cExtendedInfo) PWSTR* pw
wszExtendedInfoValue,		szExtendedInfoValue,
OUT DRMPUBHANDLE *phRight);		OUT DRMPUBHANDLE *phRight);

DRMEXPORT HRESULT UDAPICALL DRMCreateIssuanceLicense(		DRMEXPORT HRESULT UDAPICALL DRMCreateIssuanceLicense(
IN SYSTEMTIME* pstTimeFrom,		IN SYSTEMTIME* pstTimeFrom,
IN SYSTEMTIME* pstTimeUntil,		IN SYSTEMTIME* pstTimeUntil,

__in_opt PWSTR wszReferralInfoName,		_In_opt_ PWSTR wszReferralInfoName,
__in_opt PWSTR wszReferralInfoURL,		_In_opt_ PWSTR wszReferralInfoURL,
IN DRMPUBHANDLE hOwner,//Use created using D RMCreateUser.		IN DRMPUBHANDLE hOwner,//Use created using D RMCreateUser.


__in_opt PWSTR wszIssuanceLicense,//I ssuance License Template or Signed Issuance License		_In_opt_ PWSTR wszIssuanceLicense,//I ssuance License Template or Signed Issuance License
IN DRMHANDLE hBoundLicense,		IN DRMHANDLE hBoundLicense,
OUT DRMPUBHANDLE* phIssuanceLicense);		OUT DRMPUBHANDLE* phIssuanceLicense);

DRMEXPORT HRESULT UDAPICALL DRMAddRightWithUser(		DRMEXPORT HRESULT UDAPICALL DRMAddRightWithUser(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN DRMPUBHANDLE hRight,		IN DRMPUBHANDLE hRight,
IN DRMPUBHANDLE hUser);		IN DRMPUBHANDLE hUser);

DRMEXPORT HRESULT UDAPICALL DRMClearAllRights(		DRMEXPORT HRESULT UDAPICALL DRMClearAllRights(
IN DRMPUBHANDLE hIssuanceLicense);		IN DRMPUBHANDLE hIssuanceLicense);

DRMEXPORT HRESULT UDAPICALL DRMSetMetaData(		DRMEXPORT HRESULT UDAPICALL DRMSetMetaData(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,

__in PWSTR wszContentId,		_In_ PWSTR wszContentId,
__in PWSTR wszContentIdType,		_In_ PWSTR wszContentIdType,
__in_opt PWSTR wszSKUId,		_In_opt_ PWSTR wszSKUId,
__in_opt PWSTR wszSKUIdType,		_In_opt_ PWSTR wszSKUIdType,
__in_opt PWSTR wszContentType,		_In_opt_ PWSTR wszContentType,
__in_opt PWSTR wszContentName);		_In_opt_ PWSTR wszContentName);

DRMEXPORT HRESULT UDAPICALL DRMSetUsagePolicy(		DRMEXPORT HRESULT UDAPICALL DRMSetUsagePolicy(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN DRM_USAGEPOLICY_TYPE eUsagePolicyType,		IN DRM_USAGEPOLICY_TYPE eUsagePolicyType,
IN BOOL fDelete,		IN BOOL fDelete,
IN BOOL fExclusion,		IN BOOL fExclusion,


__in_opt PWSTR wszName,//Set usage po		_In_opt_ PWSTR wszName,//Set usage po
licy by Name		licy by Name
__in_opt PWSTR wszMinVersion,		_In_opt_ PWSTR wszMinVersion,
__in_opt PWSTR wszMaxVersion,		_In_opt_ PWSTR wszMaxVersion,


__in_opt PWSTR wszPublicKey,//Set usa ge policy by public key		_In_opt_ PWSTR wszPublicKey,//Set usa ge policy by public key


__in_opt PWSTR wszDigestAlgorithm,//S et usage policy by digest		_In_opt_ PWSTR wszDigestAlgorithm,//S et usage policy by digest
IN BYTE* pbDigest,		IN BYTE* pbDigest,
IN UINT cbDigest);		IN UINT cbDigest);

DRMEXPORT HRESULT UDAPICALL DRMSetRevocationPoint(		DRMEXPORT HRESULT UDAPICALL DRMSetRevocationPoint(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN BOOL fDelete,		IN BOOL fDelete,

__in PWSTR wszId,		_In_ PWSTR wszId,
__in PWSTR wszIdType,		_In_ PWSTR wszIdType,
__in PWSTR wszURL,		_In_ PWSTR wszURL,
IN SYSTEMTIME* pstFrequency,		IN SYSTEMTIME* pstFrequency,

__in_opt PWSTR wszName,//Optional		_In_opt_ PWSTR wszName,//Optional
__in_opt PWSTR wszPublicKey);		_In_opt_ PWSTR wszPublicKey);

DRMEXPORT HRESULT UDAPICALL DRMSetApplicationSpecificData(		DRMEXPORT HRESULT UDAPICALL DRMSetApplicationSpecificData(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN BOOL fDelete,		IN BOOL fDelete,

__in_opt PWSTR wszName,		_In_opt_ PWSTR wszName,
__in_opt PWSTR wszValue);		_In_opt_ PWSTR wszValue);

DRMEXPORT HRESULT UDAPICALL DRMSetNameAndDescription(		DRMEXPORT HRESULT UDAPICALL DRMSetNameAndDescription(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN BOOL fDelete,		IN BOOL fDelete,
IN UINT lcid,		IN UINT lcid,

__in_opt PWSTR wszName,		_In_opt_ PWSTR wszName,
__in_opt PWSTR wszDescription);		_In_opt_ PWSTR wszDescription);

DRMEXPORT HRESULT UDAPICALL DRMSetIntervalTime(		DRMEXPORT HRESULT UDAPICALL DRMSetIntervalTime(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT cDays);		IN UINT cDays);

DRMEXPORT HRESULT UDAPICALL DRMGetIssuanceLicenseTemplate(		DRMEXPORT HRESULT UDAPICALL DRMGetIssuanceLicenseTemplate(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN OUT UINT* puIssuanceLicenseTemplateLe ngth,		IN OUT UINT* puIssuanceLicenseTemplateLe ngth,

__out_ecount_opt(*puIssuanceLicenseTemplateLengt h) PWSTR wszIssuanceLicenseTemplate);		_Out_writes_opt_(*puIssuanceLicenseTemplateLengt h) PWSTR wszIssuanceLicenseTemplate);

DRMEXPORT HRESULT UDAPICALL DRMGetSignedIssuanceLicense(		DRMEXPORT HRESULT UDAPICALL DRMGetSignedIssuanceLicense(
IN DRMENVHANDLE hEnv,//Optional.Mandatory f or DRM_SIGN_OFFLINE		IN DRMENVHANDLE hEnv,//Optional.Mandatory f or DRM_SIGN_OFFLINE
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT uFlags,//DRM_SIGN_ONLINE/DR M_SIGN_OFFLINE/DRM_SIGN_CANCEL		IN UINT uFlags,//DRM_SIGN_ONLINE/DR M_SIGN_OFFLINE/DRM_SIGN_CANCEL

IN BYTE* pbSymKey,		IN BYTE* pbSymKey,
IN UINT cbSymKey,		IN UINT cbSymKey,

__in_opt PWSTR wszSymKeyType,		_In_opt_ PWSTR wszSymKeyType,


__in_opt PWSTR wszClientLicensorCert ificate,//Should be NULL for DRM_SIGN_ONLINE , not NULL otherwise		_In_opt_ PWSTR wszClientLicensorCert ificate,//Should be NULL for DRM_SIGN_ONLINE , not NULL otherwise
IN DRMCALLBACK pfnCallback,		IN DRMCALLBACK pfnCallback,

__in_opt PWSTR wszURL,//Mandatory if uFlags is DRM_SIGN_ONLINE		_In_opt_ PWSTR wszURL,//Mandatory if uFlags is DRM_SIGN_ONLINE

IN VOID* pvContext);//Optional		IN VOID* pvContext);//Optional

DRMEXPORT HRESULT UDAPICALL DRMGetSignedIssuanceLicenseEx(		DRMEXPORT HRESULT UDAPICALL DRMGetSignedIssuanceLicenseEx(
DRMENVHANDLE hEnv,		DRMENVHANDLE hEnv,
DRMPUBHANDLE hIssuanceLicense,		DRMPUBHANDLE hIssuanceLicense,
UINT uFlags,		UINT uFlags,

__in_bcount_opt(cbSymKey) BYTE* pbSymKey,		_In_reads_bytes_opt_(cbSymKey) BYTE* pbSymKey,
UINT cbSymKey,		UINT cbSymKey,

__in_opt PWSTR wszSymKeyType,		_In_opt_ PWSTR wszSymKeyType,
__in_opt PVOID pvReserved,		_In_opt_ PVOID pvReserved,
__in DRMHANDLE hEnablingPrincipal,		_In_ DRMHANDLE hEnablingPrincipal,
__in DRMHANDLE hBoundLicenseCLC,		_In_ DRMHANDLE hBoundLicenseCLC,
__in DRMCALLBACK pfnCallback,		_In_ DRMCALLBACK pfnCallback,
__in PVOID pvContext);		_In_ PVOID pvContext);

DRMEXPORT HRESULT UDAPICALL DRMClosePubHandle(		DRMEXPORT HRESULT UDAPICALL DRMClosePubHandle(
IN DRMPUBHANDLE hPub);		IN DRMPUBHANDLE hPub);

DRMEXPORT HRESULT UDAPICALL DRMDuplicatePubHandle(		DRMEXPORT HRESULT UDAPICALL DRMDuplicatePubHandle(
IN DRMPUBHANDLE hPubIn,		IN DRMPUBHANDLE hPubIn,
OUT DRMPUBHANDLE* phPubOut);		OUT DRMPUBHANDLE* phPubOut);

DRMEXPORT HRESULT UDAPICALL DRMGetUserInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetUserInfo(
IN DRMPUBHANDLE hUser,		IN DRMPUBHANDLE hUser,
IN OUT UINT* puUserNameLength,		IN OUT UINT* puUserNameLength,

__out_ecount_opt(*puUserNameLength) PWSTR wszUserName,		_Out_writes_opt_(*puUserNameLength) PWSTR wszUserName,
IN OUT UINT* puUserIdLength,		IN OUT UINT* puUserIdLength,

__out_ecount_opt(*puUserIdLength) PWSTR wszUserId,		_Out_writes_opt_(*puUserIdLength) PWSTR wszUserId,
IN OUT UINT* puUserIdTypeLength,		IN OUT UINT* puUserIdTypeLength,

__out_ecount_opt(*puUserIdTypeLength) PWSTR wszUserIdType);		_Out_writes_opt_(*puUserIdTypeLength) PWSTR wszUserIdType);

DRMEXPORT HRESULT UDAPICALL DRMGetRightInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetRightInfo(
IN DRMPUBHANDLE hRight,		IN DRMPUBHANDLE hRight,
IN OUT UINT* puRightNameLength,		IN OUT UINT* puRightNameLength,

__out_ecount_opt(*puRightNameLength) PWSTR wszRightName,		_Out_writes_opt_(*puRightNameLength) PWSTR wszRightName,
OUT SYSTEMTIME* pstFrom,		OUT SYSTEMTIME* pstFrom,
OUT SYSTEMTIME* pstUntil);		OUT SYSTEMTIME* pstUntil);

DRMEXPORT HRESULT UDAPICALL DRMGetRightExtendedInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetRightExtendedInfo(
IN DRMPUBHANDLE hRight,		IN DRMPUBHANDLE hRight,
IN UINT uIndex,		IN UINT uIndex,
IN OUT UINT* puExtendedInfoNameLength ,		IN OUT UINT* puExtendedInfoNameLength ,

__out_ecount_opt(*puExtendedInfoNameLength) PWSTR wszExtendedInfoName,		_Out_writes_opt_(*puExtendedInfoNameLength) PWSTR wszExtendedInfoName,
IN OUT UINT* puExtendedInfoValueLengt h,		IN OUT UINT* puExtendedInfoValueLengt h,

__out_ecount_opt(*puExtendedInfoValueLength) PWSTR wszExtendedInfoValue);		_Out_writes_opt_(*puExtendedInfoValueLength) PWSTR wszExtendedInfoValue);

DRMEXPORT HRESULT UDAPICALL DRMGetUsers(		DRMEXPORT HRESULT UDAPICALL DRMGetUsers(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT uIndex,		IN UINT uIndex,
OUT DRMPUBHANDLE* phUser);		OUT DRMPUBHANDLE* phUser);

DRMEXPORT HRESULT UDAPICALL DRMGetUserRights(		DRMEXPORT HRESULT UDAPICALL DRMGetUserRights(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN DRMPUBHANDLE hUser,		IN DRMPUBHANDLE hUser,
IN UINT uIndex,		IN UINT uIndex,
OUT DRMPUBHANDLE* phRight);		OUT DRMPUBHANDLE* phRight);

DRMEXPORT HRESULT UDAPICALL DRMGetMetaData(		DRMEXPORT HRESULT UDAPICALL DRMGetMetaData(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN OUT UINT* puContentIdLength,		IN OUT UINT* puContentIdLength,

__out_ecount_opt(*puContentIdLength) PWSTR wszContentId,		_Out_writes_opt_(*puContentIdLength) PWSTR wszContentId,
IN OUT UINT* puContentIdTypeLength,		IN OUT UINT* puContentIdTypeLength,

__out_ecount_opt(*puContentIdTypeLength) PWSTR wszContentIdType,		_Out_writes_opt_(*puContentIdTypeLength) PWSTR wszContentIdType,
IN OUT UINT* puSKUIdLength,		IN OUT UINT* puSKUIdLength,

__out_ecount_opt(*puSKUIdLength) PWSTR wszSKUId,		_Out_writes_opt_(*puSKUIdLength) PWSTR wszSKUId,
IN OUT UINT* puSKUIdTypeLength,		IN OUT UINT* puSKUIdTypeLength,

__out_ecount_opt(*puSKUIdTypeLength) PWSTR wszSKUIdType,		_Out_writes_opt_(*puSKUIdTypeLength) PWSTR wszSKUIdType,
IN OUT UINT* puContentTypeLength,		IN OUT UINT* puContentTypeLength,

__out_ecount_opt(*puContentTypeLength) PWSTR wszContentType,		_Out_writes_opt_(*puContentTypeLength) PWSTR wszContentType,
IN OUT UINT* puContentNameLength,		IN OUT UINT* puContentNameLength,

__out_ecount_opt(*puContentNameLength) PWSTR wszContentName);		_Out_writes_opt_(*puContentNameLength) PWSTR wszContentName);

DRMEXPORT HRESULT UDAPICALL DRMGetApplicationSpecificData(		DRMEXPORT HRESULT UDAPICALL DRMGetApplicationSpecificData(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT uIndex,		IN UINT uIndex,
IN OUT UINT* puNameLength,		IN OUT UINT* puNameLength,

__out_ecount_opt(*puNameLength) PWSTR wszN ame,		_Out_writes_opt_(*puNameLength) PWSTR wszN ame,
IN OUT UINT* puValueLength,		IN OUT UINT* puValueLength,

__out_ecount_opt(*puValueLength) PWSTR wszV alue);		_Out_writes_opt_(*puValueLength) PWSTR wszV alue);

DRMEXPORT HRESULT UDAPICALL DRMGetIssuanceLicenseInfo(		DRMEXPORT HRESULT UDAPICALL DRMGetIssuanceLicenseInfo(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
OUT SYSTEMTIME* pstTimeFrom,		OUT SYSTEMTIME* pstTimeFrom,
OUT SYSTEMTIME* pstTimeUntil,		OUT SYSTEMTIME* pstTimeUntil,
IN UINT uFlags,		IN UINT uFlags,
IN OUT UINT* puDistributionPointNameL ength,		IN OUT UINT* puDistributionPointNameL ength,

__out_ecount_opt(*puDistributionPointNameLength) PWSTR wszDistributionPointName,		_Out_writes_opt_(*puDistributionPointNameLength) PWSTR wszDistributionPointName,
IN OUT UINT* puDistributionPointURLLe ngth,		IN OUT UINT* puDistributionPointURLLe ngth,

__out_ecount_opt(*puDistributionPointURLLength) PWSTR wszDistributionPointURL,		_Out_writes_opt_(*puDistributionPointURLLength) PWSTR wszDistributionPointURL,
OUT DRMPUBHANDLE* phOwner,		OUT DRMPUBHANDLE* phOwner,
OUT BOOL* pfOfficial);		OUT BOOL* pfOfficial);

DRMEXPORT HRESULT UDAPICALL DRMGetRevocationPoint(		DRMEXPORT HRESULT UDAPICALL DRMGetRevocationPoint(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN OUT UINT* puIdLength,		IN OUT UINT* puIdLength,

__out_ecount_opt(*puIdLength) PWSTR ws zId,		_Out_writes_opt_(*puIdLength) PWSTR ws zId,
IN OUT UINT* puIdTypeLength,		IN OUT UINT* puIdTypeLength,

__out_ecount_opt(*puIdTypeLength) PWSTR ws zIdType,		_Out_writes_opt_(*puIdTypeLength) PWSTR ws zIdType,
IN OUT UINT* puURLLength,		IN OUT UINT* puURLLength,

__out_ecount_opt(*puURLLength) PWSTR ws zRL,		_Out_writes_opt_(*puURLLength) PWSTR ws zRL,
OUT SYSTEMTIME* pstFrequency,		OUT SYSTEMTIME* pstFrequency,
IN OUT UINT* puNameLength,		IN OUT UINT* puNameLength,

__out_ecount_opt(*puNameLength) PWSTR ws zName,		_Out_writes_opt_(*puNameLength) PWSTR ws zName,
IN OUT UINT* puPublicKeyLength,		IN OUT UINT* puPublicKeyLength,

__out_ecount_opt(*puPublicKeyLength) PWSTR ws zPublicKey);		_Out_writes_opt_(*puPublicKeyLength) PWSTR ws zPublicKey);

DRMEXPORT HRESULT UDAPICALL DRMGetUsagePolicy(		DRMEXPORT HRESULT UDAPICALL DRMGetUsagePolicy(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT uIndex,		IN UINT uIndex,
OUT DRM_USAGEPOLICY_TYPE* peUsagePolicyType,		OUT DRM_USAGEPOLICY_TYPE* peUsagePolicyType,
OUT BOOL* pfExclusion,		OUT BOOL* pfExclusion,
IN OUT UINT* puNameLength,		IN OUT UINT* puNameLength,

__out_ecount_opt(*puNameLength) PWSTR wszName,		_Out_writes_opt_(*puNameLength) PWSTR wszName,
IN OUT UINT* puMinVersionLength,		IN OUT UINT* puMinVersionLength,

__out_ecount_opt(*puMinVersionLength) PWSTR wszMinVersion,		_Out_writes_opt_(*puMinVersionLength) PWSTR wszMinVersion,
IN OUT UINT* puMaxVersionLength,		IN OUT UINT* puMaxVersionLength,

__out_ecount_opt(*puMaxVersionLength) PWSTR wszMaxVersion,		_Out_writes_opt_(*puMaxVersionLength) PWSTR wszMaxVersion,
IN OUT UINT* puPublicKeyLength,		IN OUT UINT* puPublicKeyLength,

__out_ecount_opt(*puPublicKeyLength) PWSTR wszPublicKey,		_Out_writes_opt_(*puPublicKeyLength) PWSTR wszPublicKey,
IN OUT UINT* puDigestAlgorithmLength,		IN OUT UINT* puDigestAlgorithmLength,

__out_ecount_opt(*puDigestAlgorithmLength) PWST R wszDigestAlgorithm,		_Out_writes_opt_(*puDigestAlgorithmLength) PWST R wszDigestAlgorithm,
IN OUT UINT* pcbDigest,		IN OUT UINT* pcbDigest,
OUT BYTE* pbDigest);		OUT BYTE* pbDigest);

DRMEXPORT HRESULT UDAPICALL DRMGetNameAndDescription(		DRMEXPORT HRESULT UDAPICALL DRMGetNameAndDescription(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN UINT uIndex,		IN UINT uIndex,
OUT UINT* pulcid,		OUT UINT* pulcid,
IN OUT UINT* puNameLength,		IN OUT UINT* puNameLength,

__out_ecount_opt(*puNameLength) PWSTR wszName,		_Out_writes_opt_(*puNameLength) PWSTR wszName,
IN OUT UINT* puDescriptionLength,		IN OUT UINT* puDescriptionLength,

__out_ecount_opt(*puDescriptionLength) PWSTR wszDescription);		_Out_writes_opt_(*puDescriptionLength) PWSTR wszDescription);

DRMEXPORT HRESULT UDAPICALL DRMGetOwnerLicense(		DRMEXPORT HRESULT UDAPICALL DRMGetOwnerLicense(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
IN OUT UINT* puOwnerLicenseLength,		IN OUT UINT* puOwnerLicenseLength,

__out_ecount_opt(*puOwnerLicenseLength) PWST R wszOwnerLicense);		_Out_writes_opt_(*puOwnerLicenseLength) PWST R wszOwnerLicense);

DRMEXPORT HRESULT UDAPICALL DRMGetIntervalTime(		DRMEXPORT HRESULT UDAPICALL DRMGetIntervalTime(
IN DRMPUBHANDLE hIssuanceLicense,		IN DRMPUBHANDLE hIssuanceLicense,
OUT UINT* pcDays);		OUT UINT* pcDays);

DRMEXPORT HRESULT UDAPICALL DRMRepair();		DRMEXPORT HRESULT UDAPICALL DRMRepair();

DRMEXPORT HRESULT UDAPICALL DRMRegisterProtectedWindow(		DRMEXPORT HRESULT UDAPICALL DRMRegisterProtectedWindow(
IN D RMENVHANDLE hEnv,		IN D RMENVHANDLE hEnv,
IN H WND hwnd);		IN H WND hwnd);

DRMEXPORT HRESULT UDAPICALL DRMIsWindowProtected(		DRMEXPORT HRESULT UDAPICALL DRMIsWindowProtected(
IN H WND hwnd,		IN H WND hwnd,
OUT B OOL* pfProtected);		OUT B OOL* pfProtected);

DRMEXPORT HRESULT UDAPICALL DRMAcquireIssuanceLicenseTemplate(		DRMEXPORT HRESULT UDAPICALL DRMAcquireIssuanceLicenseTemplate(
IN D RMHSESSION hClient,		IN D RMHSESSION hClient,
IN U INT uFlags,		IN U INT uFlags,
IN V OID* pvReserved,		IN V OID* pvReserved,
IN U INT cTemplates,		IN U INT cTemplates,

__in_ecount_opt(c		_In_reads_opt_(cT
Templates) PWSTR* pwszTemplateIds,		emplates) PWSTR* pwszTemplateIds,
__in PWSTR wszUrl		_In_ PWSTR wszUrl
,		,
IN V OID* pvContext);		IN V OID* pvContext);


		#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
		#pragma endregion

#endif // #ifndef __MSDRM_H_		#endif // #ifndef __MSDRM_H_

End of changes. 98 change blocks.
141 lines changed or deleted		149 lines changed or added

This html diff was produced by rfcdiff 1.41.