<ServiceTask1
    URL = "http://www.proseware.com/service/html/Music.asp">
    <ButtonText>Proseware\nMusic</ButtonText>
    <ButtonTip>Proseware Music Store</ButtonTip>
</ServiceTask1>

<OBJECT id = "plugin" height = 0 width = 0
    classid = "CLSID:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx">
</OBJECT>

// Call the revokeAll() method of the 
// object named "plugin"
plugin.revokeAll();

DECLARE_CLASSFACTORY_SINGLETON(CProsewarePlugin)

<%
Response.Buffer = True
Response.Expires = 0
On Error Resume Next

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Declare variables.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
Dim ChallengeObj           ' WMRMChallenge object
Dim HeaderObj              ' WMRMHeader object    
Dim KeyObj                 ' WMRMKeys object
Dim RightsObj              ' WMRMRights object
Dim RestrictObj            ' WMRMRestrictions object
Dim LicenseObj             ' WMRMLicGen object
Dim ResponseObj            ' WMRMResponse object

Dim ContentDistributor     ' Online store key name.
Dim ClientVersionInfo      ' Version of the client
Dim ContentID              ' Content ID
Dim ContentServerPubKey    ' Public key of the content server
Dim Delivery               ' Delivery flag
Dim IndiVersion            ' Security version of the DRM component
Dim LeafKey                ' Key for the leaf license
Dim LeafKID                ' Key ID of the leaf license
Dim RootKey                ' Key for the root license
Dim RootKID                ' Key ID of the root license
Dim License                ' License to deliver
Dim Rights                 ' Rights string for the license
Dim LicResponse            ' License response
Dim LicRevPubKey           ' Public key for license revocation
Dim PlayRestrictions       ' Playback restrictions
Dim CopyRestrictions       ' Copy restrictions
Dim Seed                   ' License key seed
Dim strLicenseRequested    ' License request string
Dim varClientInfo          ' Client information
Dim Licensetype            ' Flag for root or leaf license
Dim UserID                 ' User ID of the client
Dim NeedsCopies            ' License requested for additional copy count
Dim CopyCount              ' Number of copies to grant
Dim MeterCert              ' Metering certificate

Do

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Set variables.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Variables passed by query string parameters.
ContentID = Request("cid")
UserID = Request("uid")
NeedsCopies = Request("NeedsCopies")

RootKID = "<Replace this with the key ID for the root.>"
ContentDistributor = "Proseware"
Delivery = "" 
ContentServerPubKey = "<Replace this with the content server public key.>"
Seed = "<Replace this with the key seed.>"
LicRevPubKey = "<Replace this with the license revocation public key.>"
MeterCert = "<Replace this with the metering certificate.>"

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Determine the type of license requested.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
If (ContentID = "root") Then
    Licensetype = "root"
Else
    Licensetype = "leaf"

    ' Retrieve the key ID for the leaf license.
    ' GetLeafKID() is a custom function not implemented
    ' in this example. In practice, this function would 
    ' retrieve the key ID from a database.
    LeafKID = GetLeafKID(ContentID)

    ' If the leaf is requested with the NeedsCopies flag set to true
    ' grant 1 additional right to copy.
    ' If the flag is set to false, then issue a new leaf with a
    ' copy count of 5.
    If NeedsCopies = "true" Then
        CopyCount = 1
    Else
        CopyCount = 5
    End If

End If

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Create objects.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
Set ChallengeObj = Server.CreateObject("WMRMObjs.WMRMChallenge")
Set HeaderObj = Server.CreateObject("WMRMObjs.WMRMHeader")
Set KeyObj = Server.CreateObject("WMRMObjs.WMRMKeys")
Set RightsObj = Server.CreateObject("WMRMObjs.WMRMRights")
Set RestrictObj = Server.CreateObject("WMRMObjs.WMRMRestrictions")    
Set ResponseObj = Server.CreateObject("WMRMObjs.WMRMResponse")
Set LicenseObj = Server.CreateObject("WMRMObjs.WMRMLicGen")

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Get the license challenge.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
strLicenseRequested = Request("challenge")
    If (strLicenseRequested = "") Then Exit Do

ChallengeObj.Challenge = strLicenseRequested
    If (Err.Number <> 0) Then Exit Do

varClientInfo = ChallengeObj.ClientInfo
    If (Err.Number <> 0) Then Exit Do

HeaderObj.Header = ChallengeObj.Header
    If (Err.Number <> 0) Then Exit Do

' Verify the header with the public key
    lResult = HeaderObj.Verify(ContentServerPubKey)
    If (lResult = 0) Then Exit Do

IndiVersion = HeaderObj.IndividualizedVersion
    If (Err.Number <> 0) Then Err.clear

' GetCurrentIndiv() is a placeholder function for a custom
' routine that retrieves the minimum inidividualization 
' version you want to support.
If IndiVersion < GetCurrentIndiv() Then Exit Do

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Check the version of the client player.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
ClientVersionInfo = ChallengeObj.ClientVersion
    If (Err.Number <> 0) Then Exit Do

ClientVersionArray = Split(ClientVersionInfo, ".")
    If (ClientVersionArray(0) < 10) Then 
        ' The user needs to upgrade the Player version.
        Exit Do
    End If

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate the keys. A root key is required for both
' leaf and root licenses.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
KeyObj.Seed = Seed
    If (Err.Number <> 0) Then Exit Do

If (Licensetype = "leaf") Then 
    KeyObj.KeyID = LeafKID
        If (Err.Number <> 0) Then Exit Do

    LeafKey = KeyObj.GenerateKey()
        If (Err.Number <> 0) Then Exit Do
End If

KeyObj.KeyID = RootKID
    If (Err.Number <> 0) Then Exit Do

RootKey = KeyObj.GenerateKeyEx(8)
    If (Err.Number <> 0) Then Exit Do

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Set the rights for leaf or root licenses.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
    RightsObj.AllowPlay = True
    RightsObj.AllowCopy = True
    RightsObj.AllowCollaborativePlay = True
    RightsObj.AllowBackupRestore = False
    RightsObj.AllowPlaylistBurn = False
    RightsObj.MinimumClientSDKSecurity = 1000
    RightsObj.MinimumSecurityLevel = 1000

If (Licensetype = "leaf") Then    ' Set rights for a leaf license
    RightsObj.CopyCount = CopyCount

    ' Set copy restrictions.
    Call RestrictObj.AddRestriction(6, 0)     
    CopyRestrictions = RestrictObj.GetRestrictions
    RightsObj.CopyRestrictions = CopyRestrictions
        If (Err.Number <> 0) Then Exit Do

Elseif (Licensetype = "root") Then    ' Set rights for a root license
    ' GetExpirationDateUser() is a placeholder function that retrieves
    ' the next expiration date for the current subscriber's account.
    RightsObj.ExpirationDate = GetExpirationDateUser(UserID)
    RightsObj.DeleteOnClockRollback = False
    RightsObj.DisableOnClockRollback = True

End If

Rights = RightsObj.GetAllRights()
    If (Err.Number <> 0) Then Exit Do

'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate the license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
If (Licensetype = "leaf") Then 
    LicenseObj.KeyID = LeafKID
        If (Err.Number <> 0) Then Exit Do

    Call LicenseObj.SetKey("", LeafKey)
        If (Err.Number <> 0) Then Exit Do
Elseif (Licensetype = "root") Then
    LicenseObj.KeyID = RootKID
        If (Err.Number <> 0) Then Exit Do

    Call LicenseObj.SetKey("", RootKey)
        If (Err.Number <> 0) Then Exit Do
End If

' Only meter on the leaf license.
If(LicenseType = "leaf") Then
    LicenseObj.MeteringCertificate = MeterCert
        If (Err.Number <> 0) Then Exit Do
End If

LicenseObj.Attribute("ContentDistributor") = ContentDistributor
    If (Err.Number <> 0) Then Exit Do

' UID and LGPUBKEY are needed only when you want to support
' license revocation.
LicenseObj.Attribute("UID") = UserID
    If (Err.Number <> 0) Then Exit Do
LicenseObj.Attribute("LGPUBKEY") = LicRevPubKey 
    If (Err.Number <> 0) Then Exit Do

LicenseObj.Rights = Rights
    If (Err.Number <> 0) Then Exit Do

LicenseObj.ClientInfo = varClientInfo
    If (Err.Number <> 0) Then Exit Do

LicenseObj.IndividualizedVersion = IndiVersion
    If (Err.Number <> 0) Then Exit Do

' GetNextPriorityUser is a placeholder function
' that retrieves the correct priority value. 
LicenseObj.Priority = GetNextPriorityUser(UserID)
    If (Err.Number <> 0) Then Exit Do

LicenseObj.BindToPubKey = ContentServerPubKey
    If (Err.Number <> 0) Then Exit Do

If (Licensetype = "leaf") Then  
    ' Link to the root license
    ' for license chaining.
    LicenseObj.UplinkKid = RootKid
    LicenseObj.UplinkKey = RootKey
        If (Err.Number <> 0) Then Exit Do
End If

License = LicenseObj.GetLicenseToDeliver
    If (Err.Number <> 0) Then Exit Do

Delivery = "deliver"

Loop While False

' This page handles pre-delivery only.
If (Delivery = "deliver") Then
    Call ResponseObj.AddLicense("2.0.0.0", License)
    LicResponse = ResponseObj.GetLicenseResponse()
    Response.Write LicResponse
End if

' """""""""""""""""""""""""""""""""""""""""""""""""""""
' Clear the objects.
' """""""""""""""""""""""""""""""""""""""""""""""""""""
Set ChallengeObj = Nothing
Set HeaderObj = Nothing
Set KeyObj = Nothing
Set RightsObj = Nothing
Set RestrictObj = Nothing
Set LicenseObj = Nothing
Set ResponseObj = Nothing

%>

<HTML>
<BODY>
Simple Web page that embeds the RMGetLicense object

<OBJECT name = RMGetLicense
        id = RMGetLicense
        classid = clsid:A9FC132B-096D-460B-B7D5-1DB0FAE0C062
        height = 0 width = 0>
</OBJECT>

</BODY>
</HTML>

<SCRIPT Language = "JScript">
    // Pre-deliver a root or leaf license.
    // cid is the content ID for the digital media
    // file being downloaded. A value of "root" will
    // cause a root license to be issued.
    // uid is a unique user ID.
    function GetLicenseFromURL(cid, uid)
    {
        var PreDelURL = "http://www.proseware.com/Predeliver.asp?";
        PreDelURL += "cid=";
        PreDelURL += cid;
        PreDelURL += "&uid=";
        PreDelURL += uid;

        try
        {
            RMGetLicense.GetLicenseFromURL("", PreDelURL);
        }
        catch
        {
             // GetLicenseFromURL doesn't return error codes.
             // However, calling GetLicenseFromURL can cause
             // an exception to be raised from ouside Windows Media
             // Rights Manager. This empty catch block
             // intentionallydiscards these
             // exceptions so the call fails silently.
        }
    }
</SCRIPT>

#include <stdio.h>
#include <windows.h>
#include <wmsdk.h> // Windows Media Format 9.5 SDK header
#include <atlbase.h>
#include <atlcom.h>

#define CNS_PER_DAY 864000000000 // 100ns units per day.

class CLicenseExpirationChecker
{
public:
    HRESULT Initialize();
    HRESULT CheckExpiration(BSTR  bstrFileName, 
                            DWORD dwExpirationWindow, 
                            BSTR* pbstrUpdateContentID);

private:
    HRESULT GetContentID(BSTR* pbstrContentID);

    CComPtr<IWMMetadataEditor> m_spEditor;
    CComPtr<IWMDRMEditor>      m_spDRMEditor;
};

HRESULT CLicenseExpirationChecker::Initialize()
{
    HRESULT hr = S_OK;

    // Create the metadata editor object.
    hr = WMCreateEditor(&m_spEditor);

    if(SUCCEEDED(hr))
    {
        // Get the DRM metadata editor interface.
        hr = m_spEditor.QueryInterface(&m_spDRMEditor);
    }

    return hr;
}

HRESULT CLicenseExpirationChecker::CheckExpiration(
    BSTR  bstrFileName, 
    DWORD dwExpirationWindow, 
    BSTR* pbstrUpdateContentID)
{
    // Check for initialization.
    if(!m_spDRMEditor)
    {
        return NS_E_INVALID_REQUEST; 
    }

    // Parameter checking.
    if(NULL == bstrFileName || 
        0 == SysStringLen(bstrFileName) ||
        NULL == pbstrUpdateContentID)
    {
        return E_INVALIDARG;
    }

    HRESULT hr = S_OK;

    // Time variables to hold the current and expiration times.
    FILETIME           CurrentTime;
    ZeroMemory(&CurrentTime, sizeof(FILETIME));
    FILETIME*          pExpireTime = NULL;
    ULARGE_INTEGER     uliCurrent,
                       uliExpire;
    ZeroMemory(&uliCurrent, sizeof(ULARGE_INTEGER));
    ZeroMemory(&uliExpire, sizeof(ULARGE_INTEGER));
    ULONGLONG          uliDiff = 0; 

    // Variables for retrieving the license state information.
    WM_LICENSE_STATE_DATA*  pWMLicState  = NULL;
    WMT_ATTR_DATATYPE       DataType = WMT_TYPE_DWORD;       
    BYTE* pbData = NULL;
    WORD  cbData = 0;
    BOOL bProtected = FALSE;  
    CComBSTR bstrRoot;
    hr = bstrRoot.Append(L"root");

    if(SUCCEEDED(hr))
    {
        // Ensure we are working with protected content.
        hr = WMIsContentProtected((WCHAR*)bstrFileName, &bProtected);
    } 

    if(SUCCEEDED(hr))
    {
        if(FALSE == bProtected)
        {
            hr = NS_E_INVALID_REQUEST;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Open the file for metadata editing.
        hr = m_spEditor->Open((WCHAR*)(bstrFileName));
    }

    if(SUCCEEDED(hr))
    {
        // Get the current time from the system.
        GetSystemTimeAsFileTime(&CurrentTime);

        // Get the license state data.

        // First get the size of the data.
        hr = m_spDRMEditor->GetDRMProperty(
                   g_wszWMDRM_LicenseState_Playback,
                   &DataType,
                   NULL,
                   &cbData);
    }

    // License state data attributes should always be 
    // a binary data type.
    if(SUCCEEDED(hr) && DataType == WMT_TYPE_BINARY)
    {   
        // Allocate memory for the data.
        pbData = new BYTE[cbData];
        if(pbData == NULL)
        {
            hr = E_OUTOFMEMORY;
        }

        if(SUCCEEDED(hr))
        {
            // Get the actual data.
            hr = m_spDRMEditor->GetDRMProperty(
                        g_wszWMDRM_LicenseState_Playback,
                        &DataType,
                        pbData,
                        &cbData);
        }

        if(SUCCEEDED(hr))
        {
            // Set the license state data pointer.
            pWMLicState = (WM_LICENSE_STATE_DATA*)pbData;

            // Depending on the category of restriction, 
            // there will be a varying number
            // of dates in the license state data.
            switch(pWMLicState->stateData->dwCategory)
            {
            case WM_DRM_LICENSE_STATE_UNTIL:
            case WM_DRM_LICENSE_STATE_COUNT_UNTIL:
                {
                    if(pWMLicState->stateData->dwNumDates != 1)
                    {
                        hr = E_UNEXPECTED;
                        break;
                    }
                    pExpireTime = &pWMLicState->stateData->datetime[0];
                    break;
                }
            case WM_DRM_LICENSE_STATE_FROM_UNTIL:
            case WM_DRM_LICENSE_STATE_COUNT_FROM_UNTIL:
                {
                    if(pWMLicState->stateData->dwNumDates != 2)
                    {
                        hr = E_UNEXPECTED;
                        break;
                    }
                    pExpireTime = &pWMLicState->stateData->datetime[1];
                    break;
                }
            //  If the state category is NORIGHT, then either 
            //  the leaf license or the root license needs 
            //  to be acquired. In this case, set the string to 
            //  the content ID.
            case WM_DRM_LICENSE_STATE_NORIGHT:
                {
                    hr = GetContentID(pbstrUpdateContentID);
                    break;
                }
            default:
                {
                    hr = E_UNEXPECTED;
                    break;
                }
            }

            if(pExpireTime)
            {
                // Copy the FILETIME values to their 
                // ULARGE_INTEGER counterparts.
                memcpy((void*)&uliCurrent, (void*)&CurrentTime, 
                        sizeof(uliCurrent));
                memcpy((void*)&uliExpire, (void*)pExpireTime, 
                        sizeof(uliCurrent));

                // Compare the dates.
                if(uliExpire.QuadPart > uliCurrent.QuadPart)
                {
                    // Get the difference between the current time 
                    // and the expiration time.
                    uliDiff = uliExpire.QuadPart - uliCurrent.QuadPart;

                    // If the difference is less than the number of days 
                    // specified in the call to this function, the file 
                    // needs an update.
                    if(uliDiff <= 
                        (((ULONGLONG)CNS_PER_DAY) * dwExpirationWindow))
                    {
                        hr = bstrRoot.CopyTo(pbstrUpdateContentID);
                    }
                }
                else // Expiration date is in the past.
                {
                    hr = bstrRoot.CopyTo(pbstrUpdateContentID);
                }
            }
        }
    }

// Clean up.
    m_spEditor->Close();

    if(pbData)
    {
        delete[] pbData;
        pbData = NULL;
    }

    pWMLicState = NULL;
    pExpireTime = NULL;

    return hr;
}

HRESULT CLicenseExpirationChecker::GetContentID(BSTR* pbstrContentID)
{
    // Check for initialization.
    ATLASSERT(m_spDRMEditor);
    ATLASSERT(pbstrContentID);
 
    HRESULT hr = S_OK;
    WMT_ATTR_DATATYPE DataType = WMT_TYPE_DWORD;
    WORD cbContentID = 0;
    WCHAR *pwszContentID = NULL;
    
    // Get the size needed for the attribute.
    hr = m_spDRMEditor->GetDRMProperty(g_wszWMDRM_DRMHeader_ContentID, 
                                       &DataType, 
                                       NULL, 
                                       &cbContentID);

    // Verify that the attribute is a string.
    if(SUCCEEDED(hr) && 
       (DataType != WMT_TYPE_STRING || cbContentID % sizeof(WCHAR) != 0))
    {
        hr = E_UNEXPECTED;
    }

    if(SUCCEEDED(hr))
    {
        // Allocate memory for the string.
        pwszContentID = new WCHAR[cbContentID / sizeof(WCHAR)];
        if(pwszContentID == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Get the attribute.
        hr = m_spDRMEditor->GetDRMProperty(g_wszWMDRM_DRMHeader_ContentID, 
                                           &DataType, 
                                           (BYTE*)pwszContentID, 
                                           &cbContentID);
    }
    
    if(SUCCEEDED(hr))
    {       
        // Allocate and return the BSTR.
        *pbstrContentID = SysAllocString(pwszContentID);
        if(NULL == pbstrContentID)
        {
            hr = E_OUTOFMEMORY;
        }
    }
   
    if(pwszContentID)
    {
        delete[] pwszContentID;
        pwszContentID = NULL;
    }

    return hr;
}

public:
// Event handles
HANDLE m_hExitThreadsEvent;
HANDLE m_hPauseThreadsEvent;
private:
// Thread handle
HANDLE m_hLicenseUpdateThread;

if(SUCCEEDED(hr))
{
    // Create an event to signal running background
    // threads to exit.
    m_hExitThreadsEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

    if(0 == m_hExitThreadsEvent)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }
}

if(SUCCEEDED(hr))
{
    // Create an event to signal running background
    // threads to pause.
    m_hPauseThreadsEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

    if(0 == m_hPauseThreadsEvent)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }
}

// Flag to only run license update thread once per session.
BOOL m_bRanLicenseUpdate;

// Thread function for background license updating.
DWORD WINAPI LicenseUpdateThread(void *pArg);

HRESULT CProsewarePlugin::startBackgroundProcessing(HWND hwnd)
{
    // This example code runs a background thread once
    // per session. You might choose to perform this operation 
    // less frequently.

    HRESULT hr = S_OK;
 
    // Check whether the background thread is live
    if(m_hLicenseUpdateThread)
    {
        DWORD dwExitCode = 0;
        if(GetExitCodeThread(m_hLicenseUpdateThread, &dwExitCode))
        {
            if(STILL_ACTIVE == dwExitCode)
            {                  
                // Signal the event to restart the 
                // license background thread.
                ResetEvent(m_hPauseThreadsEvent);
            }
        }
    }
    else if(!m_bRanLicenseUpdate)
    {
        m_hLicenseUpdateThread = CreateThread(NULL, 0,
                                    LicenseUpdateThread, 
                                    (LPVOID)this, NULL, 0);

        if(NULL == m_hLicenseUpdateThread)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
        else
        {
            // Set the flag.
            m_bRanLicenseUpdate = TRUE;
        }
    }    

    return hr;
}

HRESULT CProsewarePlugin::stopBackgroundProcessing(void)
{
    // Check whether the background thread is live
    if(m_hLicenseUpdateThread)
    {
        DWORD dwExitCode = 0;
        if(GetExitCodeThread(m_hLicenseUpdateThread, &dwExitCode))
        {
            if(STILL_ACTIVE == dwExitCode)
            {
                // Signal the event to pause the 
                // license background thread
                SetEvent(m_hPauseThreadsEvent);
            }
        }
    }
   
    return S_OK;
}

#include <msnetobj.h> // Header required for RMGetLicense object.
const WCHAR kszPredeliveryURL[] = 
    L"http://www.proseware.com/MusicStoreLicense.asp";

class CLicenseDelivery
{
private:
    CComPtr<IRMGetLicense> m_spGetLicense;

public:
    HRESULT Init()
    {
        return m_spGetLicense.CoCreateInstance(
            __uuidof(RMGetLicense), 
            0,
            CLSCTX_INPROC_SERVER);
    }

    
    HRESULT preDeliverLicense(BSTR bstrCID, 
                              BSTR bstrUID, 
                              bool bNeedsCopies)
    {
        if(!m_spGetLicense)
        {
            return NS_E_INVALID_REQUEST;
        }

        if(NULL == bstrCID)
        {
            return E_INVALIDARG;
        }

        HRESULT hr = S_OK;

        CComBSTR bstrURL;
        hr = bstrURL.Append(kszPredeliveryURL);

        if(SUCCEEDED(hr))
        {
            hr = bstrURL.Append(L"?cid=");
        }

        if(SUCCEEDED(hr))
        {
            hr = bstrURL.AppendBSTR(bstrCID);
        }

        if(SUCCEEDED(hr))
        {
            hr = bstrURL.Append(L"&uid=");
        }

        if(SUCCEEDED(hr))
        {
            hr = bstrURL.AppendBSTR(bstrUID);
        }

        if(SUCCEEDED(hr))
        {
            hr = bstrURL.Append(L"&NeedsCopies=");
        }

        if(SUCCEEDED(hr))
        {
            if(true == bNeedsCopies)
            {
                hr = bstrURL.Append(L"true");
            }
            else
            {
                hr = bstrURL.Append(L"false");
            }
        }

        if(SUCCEEDED(hr))
        {
            hr = m_spGetLicense->GetLicenseFromURL(CComBSTR(NULL), bstrURL);
        }

        return hr;
    }

};

DWORD WINAPI LicenseUpdateThread(void *pArg)
{ 
    // Do parameter validation.
    if(!pArg)
    {
        SetLastError(E_INVALIDARG);
        return 1;
    }

    // Threads must always call CoInitialize.
    CoInitialize(NULL);

    // Declare and initialize variables.
    HRESULT hr = S_OK;
    CComBSTR bstrUID(kszUserID);
    CComPtr<IWMPCore> spPlayer;  // Smart pointer to IWMPCore interface.
    CComPtr<IWMPMediaCollection> spMediaCollection;
    CComPtr<IWMPPlaylist> spPlaylist;
    CProsewarePlugin *pPlugin = (CProsewarePlugin*)pArg;
    long lCount = 0;
    bool bGotRoot = false; // Flag to store whether the root
                          // license has been acquired.
    CLicenseDelivery *pLicenseDelivery = NULL;
    CLicenseExpirationChecker *pLicExpChk = NULL;
    // Variables to query for our content from the library.
    CComBSTR bstrAttName;  // "WM/ContentDistributor"
    CComBSTR bstrAttVal;  // "Proseware"

    hr = bstrAttName.Append(L"WM/ContentDistributor");

    if(SUCCEEDED(hr))
    {
        hr = bstrAttVal.Append(L"Proseware");
    }

    if(SUCCEEDED(hr))
    {
        // Create an instance of the license expiration checker class.
        pLicExpChk = new CLicenseExpirationChecker();
        if(NULL == pLicExpChk)
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Create an instance of the license delivery class.
        pLicenseDelivery = new CLicenseDelivery;

        if(NULL == pLicenseDelivery)
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Initialize license expiration checker.
        hr = pLicExpChk->Initialize();
    }

    ATLASSERT(pPlugin);

    if(SUCCEEDED(hr))
    {
        // Create an instance of the Windows Media Player 10
        // object. We do this here because the plug-in does not
        // have a pointer to IWMPCore and creating the object in
        // the worker thread avoids the need to marshal COM pointers
        // across apartment boundaries.
        hr = spPlayer.CoCreateInstance(__uuidof(WindowsMediaPlayer),
                                        0, CLSCTX_INPROC_SERVER);
    }

    if(SUCCEEDED(hr))
    {
        // Retrieve a pointer to the media collection.
        hr = spPlayer->get_mediaCollection(&spMediaCollection);
    }

    if(SUCCEEDED(hr))
    {
        // Retrieve a playlist filled with online store media
        // from the user's library.
        hr = spMediaCollection->getByAttribute(bstrAttName, 
                                               bstrAttVal,
                                               &spPlaylist);
    }

    if(SUCCEEDED(hr))
    {
       hr = spPlaylist->get_count(&lCount);
    }

    if(SUCCEEDED(hr))
    {
        // Initialize the license delivery class
        hr = pLicenseDelivery->Init();
    }

    if(SUCCEEDED(hr))
    {   
        // We need to cache the last contentID so we can 
        // handle the case where
        // we have the leaf license, but the root is missing
        // or corrupted.
        CComBSTR bstrLastCID; 

        // Loop through the playlist.
        for(long i = 0; i < lCount; i++)
        {            
            CComPtr<IWMPMedia> spMedia;
            CComBSTR bstrURL;
            CComBSTR bstrCID;
            // Retrieve a pointer to the next media item.
            hr = spPlaylist->get_item(i, &spMedia);

            if(SUCCEEDED(hr))
            {                
                // Retrieve the path to the media item.
                hr = spMedia->get_sourceURL(&bstrURL);
            }

            if(SUCCEEDED(hr) && bstrURL.Length())
            {
                // Check the license for expiration within a week.
                hr = pLicExpChk->CheckExpiration(bstrURL, 7, &bstrCID); 
            }

            // Test whether the license expiration checker is requesting 
            // a root license and the root has already been retrieved.
            if(SUCCEEDED(hr) && bstrCID.Length() &&
               0 == _wcsicmp(bstrCID, L"root") &&
               true == bGotRoot)
            {
                // Cache the CID
                bstrLastCID.Empty();
                hr = bstrLastCID.AppendBSTR(bstrCID); 

                // Don't do any license acquisition 
                // in this iteration.
                bstrCID.Empty();
            }

            if(SUCCEEDED(hr) && bstrCID.Length())
            { 
                // Test whether this CID is a repeat of the last.
                // If not, acquire a root instead of a leaf.
                // Note: The "!=" operator here is the overloaded one
                // from the CComBSTR class. It compares strings,
                // not pointers.
                if(bstrCID != bstrLastCID &&
                   false == bGotRoot &&
                   0 != _wcsicmp(bstrCID, L"root"))
                {
                    // Cache the CID
                    bstrLastCID.Empty();
                    hr = bstrLastCID.AppendBSTR(bstrCID);
                    if(SUCCEEDED(hr))
                    {
                        bstrCID.Empty();
                        bstrCID = L"root";
                    }
                }
                else
                {
                     bstrLastCID.Empty();
                     hr = bstrLastCID.AppendBSTR(bstrCID);
                }

                if(SUCCEEDED(hr))
                {
                    // The usual scenario is that bstrCID equals "root" 
                    // because the root is expired or missing.
                    // This call would then get the root license.
                    // It's possible bstrCID contains a content ID.
                    // In that case, this call would get the leaf license.
                    hr = pLicenseDelivery->preDeliverLicense(bstrCID, 
                                                             bstrUID, 
                                                             false);
                 }

                if(SUCCEEDED(hr) && 0 == _wcsicmp(bstrCID, L"root"))
                {
                    // Check this item
                    // again to ensure we have a leaf.
                    i--;

                    // Set the flag.
                    bGotRoot = true;
                }
            }

            // Sleep if the pause event is signaled.          
            while(WAIT_OBJECT_0 == WaitForSingleObject(
                    pPlugin->m_hPauseThreadsEvent, 1000))
            {
                // Keep waiting for the event to be non-signaled.
            }

            // Exit if the exit event is signaled.          
            if(WAIT_OBJECT_0 == WaitForSingleObject(
                   pPlugin->m_hExitThreadsEvent, 0))
            {
                break;
            }
        }
    }

    if(pLicExpChk)
    {
        delete pLicExpChk;
        pLicExpChk = NULL;
    }

    if(pLicenseDelivery)
    {
        delete pLicenseDelivery;
        pLicenseDelivery = NULL;
    }

    CoUninitialize();

    return SUCCEEDED(hr)?0:1;
}

// Signal threads to exit.
SetEvent(m_hExitThreadsEvent);
// Wake up sleeping background threads.
ResetEvent(m_hPauseThreadsEvent);

HANDLE hThreads[1] = {m_hLicenseUpdateThread};
// Wait for the threads to exit.
WaitForMultipleObjects(1, hThreads, TRUE, 15000);

private:
UINT  m_uMarshalCustom; // Window message to complete the callbacks.
HWND  m_hPluginWindow; // Handle of the plug-in's hidden window.
HANDLE  m_hPrepareForSyncThread; // Thread handle
UINT  m_uExitPrepareForSync; // Window message to exit the thread.
DWORD  m_dwPrepareForSyncThreadId; // Thread ID.
UINT  m_uPrepareMediaSync; // Window message for license work.

m_uMarshalCustom = RegisterWindowMessage(_T("ProsewarePlugin_CB"));
if(0 == m_uMarshalCustom)
{
    hr = HRESULT_FROM_WIN32(GetLastError());
}

if(SUCCEEDED(hr))
{
    m_uExitPrepareForSync = RegisterWindowMessage(
        _T("ProsewarePlugin_ExitPrepareForSync"));
    if(0 == m_uExitPrepareForSync)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }
}

if(SUCCEEDED(hr))
{
    m_uPrepareMediaSync = RegisterWindowMessage(
        _T("ProsewarePlugin_PrepareMediaSync"));
    if(0 == m_uPrepareMediaSync)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }
}

STDMETHODIMP prepareMedia(BSTR bstrFile, 
                   IWMPSubscriptionServiceCallback *pCB, 
                   HWND hWndCB);

struct ThreadParams{
    BSTR bstrName; // Canonical name of device or file name
    void *pCB; // Callback pointer
    HWND hWndCB; // HWND to send callback pointer to
    HANDLE hInit; // Event handle to signal thread has started
    HRESULT hr; // Return code from thread initialization
};

HRESULT CProsewarePlugin::prepareMedia(
    BSTR bstrFile, 
    IWMPSubscriptionServiceCallback *pCB,
    HWND hWndCB)
{
    if(NULL == hWndCB ||
       NULL == pCB)
    {
        return E_INVALIDARG;
    }

    HRESULT hr = S_OK;
    BOOL bResult = FALSE;

    CComBSTR bstrFileName;
    bstrFileName.Append(bstrFile);    

    // Create the thread if none exists.
    if(!m_hPrepareForSyncThread)
    {   
        ThreadParams *pTP = NULL;
        HANDLE hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);

        if(NULL == hEvent)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }

        if(SUCCEEDED(hr))
        {
            pTP = new ThreadParams();
            if(!pTP)
            {
                hr = E_OUTOFMEMORY;
            }
        }

        if(SUCCEEDED(hr))
        {
            ZeroMemory(pTP, sizeof(ThreadParams));
            pTP->hInit = hEvent;

            // Create the thread.
            // There should only be one thread of this type per session.
            m_hPrepareForSyncThread = CreateThread(
                NULL, 
                0,
                PrepareForSyncThread, 
                (void*)pTP, NULL, 
                &m_dwPrepareForSyncThreadId);

            if(m_hPrepareForSyncThread)
            {
                // Wait for the thread to finish initialization.
                if(WAIT_OBJECT_0 != WaitForSingleObject(
                       pTP->hInit, 30000))
                {
                    // Failed to create thread
                    CloseHandle(m_hPrepareForSyncThread);
                    m_hPrepareForSyncThread = NULL;
                    hr = pTP->hr;
                }

                // Clean up.
                CloseHandle(pTP->hInit);
                pTP->hInit = NULL;
                delete pTP;
                pTP = NULL;
            }
        }
    }

    // If we have a worker thread, fill in the ThreadParams struct
    // and post a message.
    if(m_hPrepareForSyncThread)
    {
        // Prepare the message
        ThreadParams *pThreadParams = new ThreadParams();
        if(!pThreadParams)
        {
            hr = E_OUTOFMEMORY;
        }

        if(SUCCEEDED(hr))
        {
            // Increment the reference count on the
            // callback pointer.
            pCB->AddRef();

            // Fill in the ThreadParams struct.
            ZeroMemory(pThreadParams, sizeof(ThreadParams));
            bstrFileName.CopyTo(&pThreadParams->bstrName);
            pThreadParams->hWndCB = hWndCB;
            pThreadParams->pCB = reinterpret_cast<void*>(pCB);

            if(m_dwPrepareForSyncThreadId)
            {
                // Send the struct pointer to the thread's message queue.
                bResult = PostThreadMessage(m_dwPrepareForSyncThreadId, 
                                            m_uPrepareMediaSync, 0, 
                                            (LPARAM)pThreadParams);
            }

            if(FALSE == bResult)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
            }
        }
    }

    return hr;
}

// Thread function for prepare for sync.
DWORD WINAPI PrepareForSyncThread(void *pArg);

DWORD WINAPI PrepareForSyncThread(void *pArg)
{
    // Parameter checking.
    if(NULL == pArg)
    {
        SetLastError(E_INVALIDARG);
        return 1;
    }

    CoInitialize(NULL);

    MSG msg; 
    ZeroMemory(&msg, sizeof(MSG));
    HRESULT hr = S_OK;
    CLicenseExpirationChecker *pLicExpChk = NULL;
    ThreadParams *pTP = reinterpret_cast<ThreadParams*>(pArg);
    UINT uExitPrepareForSync = 0;
    UINT uPrepareMediaSync = 0;

    // Create an instance of the license deliver class.
    CLicenseDelivery *pLicenseDelivery = new CLicenseDelivery();
    if(NULL == pLicenseDelivery)
    {
        hr = E_OUTOFMEMORY;
    }

    if(SUCCEEDED(hr))
    {
        hr = pLicenseDelivery->Init();
    }

    if(SUCCEEDED(hr))
    {
        // Create an instance of the license expiration checker class.
        pLicExpChk = new CLicenseExpirationChecker();
        if(NULL == pLicExpChk)
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if(SUCCEEDED(hr))
    {
        hr = pLicExpChk->Initialize();
    }

    if(SUCCEEDED(hr))
    {
        uExitPrepareForSync = RegisterWindowMessage(
                 _T("ProsewarePlugin_ExitPrepareForSync"));
        uPrepareMediaSync = RegisterWindowMessage(
                 _T("ProsewarePlugin_PrepareMediaSync"));
    }

    // Set the return code.
    pTP->hr = hr;
    // Signal that we're ready to pump messages. 
    SetEvent(pTP->hInit);

    if(SUCCEEDED(hr))
    {        
        BOOL bRet = FALSE;

        while((bRet = ::GetMessage(&msg, 0, 0, 0)) != 0)
        {
            if(-1 == bRet)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                break;
            }

            if(uPrepareMediaSync == msg.message)
            {
                if(msg.lParam != NULL)
                {
                    PrepareMediaForSync(
                        pLicenseDelivery, 
                        pLicExpChk,
                        (LPVOID)msg.lParam);
                }
            }
            else if(uExitPrepareForSync == msg.message)
            {
                UINT uMarshalCustom = RegisterWindowMessage(
                                _T("ProsewarePlugin_CB"));
                if(NULL == uMarshalCustom)
                {
                    hr = HRESULT_FROM_WIN32(GetLastError());
                }

                if(SUCCEEDED(hr))
                {
                    // Empty the message queue.
                    while(0 == PeekMessage(
                                 &msg, 
                                 (HWND)INVALID_HANDLE_VALUE, 
                                 0, 0, PM_REMOVE))
                    {
                        if(uPrepareMediaSync == msg.message)
                        {                            
                            ThreadParams *pPrep = 
                              reinterpret_cast<ThreadParams*>(msg.lParam);
                            ATLASSERT(pPrep);

                            HWND hwndCB = pPrep->hWndCB;
                            void *pCB = pPrep->pCB;
                            if(hwndCB && pCB)
                            {
                                // Do the callback
                                PostMessage(hwndCB,
                                            uMarshalCustom,
                                            (WPARAM)NS_E_USER_STOP,
                                            (LPARAM)pCB);
                            }
                           
                            SysFreeString(pPrep->bstrName);
                            delete pPrep;
                            pPrep = NULL;
                        }
                        else
                        {
                            DispatchMessage(&msg);
                        }
                    }
                }
                break;
            }
            else
            {
                DispatchMessage(&msg);
            }
        }
    }
    
    if(pLicExpChk)
    {
        delete pLicExpChk;
        pLicExpChk = NULL;
    }

    CoUninitialize();
 
    return SUCCEEDED(hr)?0:1;
}

void PrepareMediaForSync(CLicenseDelivery *pLicenseDelivery, 
                         CLicenseExpirationChecker *pLicExpChk,
                         void* pv)

HRESULT CLicenseExpirationChecker::CheckCopyCount(
    BSTR  bstrFileName,
    DWORD dwCountWindow,
    BSTR* pbstrUpdateContentID)
{
    // Check for initialization.
    if(!m_spDRMEditor)
    {
        return NS_E_INVALID_REQUEST;
    }

    // Parameter checking.
    if(NULL == pbstrUpdateContentID ||
       NULL == bstrFileName ||
       0 == SysStringLen(bstrFileName))
    {
        return E_INVALIDARG;
    }

    ///// Local variables
    HRESULT hr = S_OK;

    // Variables for retrieving the license state information.
    WM_LICENSE_STATE_DATA*  pWMLicState  = NULL;

    WMT_ATTR_DATATYPE       DataType = WMT_TYPE_DWORD;       
    BYTE* pbData = NULL;
    WORD  cbData = 0;
    BOOL bProtected = FALSE;

    // Make sure the content is DRM protected.
    hr = WMIsContentProtected((WCHAR*)bstrFileName, &bProtected);

    if(SUCCEEDED(hr))
    {
        if(FALSE == bProtected)
        {
            hr = NS_E_INVALID_REQUEST;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Open the file for metadata editing.
        hr = m_spEditor->Open((WCHAR*)bstrFileName);
    }

    if(SUCCEEDED(hr))
    {
        // Get the license state data.

        // First get the size of the data.
        hr = m_spDRMEditor->GetDRMProperty(g_wszWMDRM_LicenseState_Copy,
                                           &DataType,
                                           NULL,
                                           &cbData);
    }

    // License state data attributes should always be a binary data type.
    if(SUCCEEDED(hr) && DataType != WMT_TYPE_BINARY)
    { 
        hr = E_UNEXPECTED;
    }

    if(SUCCEEDED(hr))
    {
        // Allocate memory for the data.
        pbData = new BYTE[cbData];
        if(pbData == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if(SUCCEEDED(hr))
    {
        // Get the actual data.
        hr = m_spDRMEditor->GetDRMProperty(g_wszWMDRM_LicenseState_Copy,
                                           &DataType,
                                           pbData,
                                           &cbData);
    }

    if(SUCCEEDED(hr))
    {
        // Set the license state data pointer.
        pWMLicState = (WM_LICENSE_STATE_DATA*)pbData;

        switch(pWMLicState->stateData->dwCategory)
        {
        // If the state category is NORIGHT, then either the 
        // leaf license or the root license needs to be acquired.
        // In this case, set the string to the content ID.
        case WM_DRM_LICENSE_STATE_NORIGHT:
            {
                hr = GetContentID(pbstrUpdateContentID);
                break;
            }
        case WM_DRM_LICENSE_STATE_COUNT:
        case WM_DRM_LICENSE_STATE_COUNT_FROM:
        case WM_DRM_LICENSE_STATE_COUNT_UNTIL:
        case WM_DRM_LICENSE_STATE_COUNT_FROM_UNTIL:
            {
                // Compare the count with the specified window.
                if(pWMLicState->stateData->dwCount[0] < dwCountWindow)
                {
                    hr = GetContentID(pbstrUpdateContentID);
                }

                break;
            }
        default:
            {
                hr = E_UNEXPECTED;
                break;
            }
        }        
    }
    
    m_spEditor->Close();

    if(pbData)
    {
        delete[] pbData;
        pbData = NULL;
    }

    pWMLicState = NULL;
    return hr;
}

void PrepareMediaForSync(CLicenseDelivery *pLicenseDelivery, 
                         CLicenseExpirationChecker *pLicExpChk,
                         void* pv)
{
    ATLASSERT(pLicenseDelivery);
    ATLASSERT(pLicExpChk);
    ATLASSERT(pv);
    
    HRESULT hr = S_OK;
    static bool bHaveRoot = false; // Only get the root once per session.
    ThreadParams *pPrep = reinterpret_cast<ThreadParams*>(pv);
    CComBSTR bstrFileName;
    bstrFileName.Attach(pPrep->bstrName);
    CComBSTR bstrUID;
    hr = bstrUID.Append(kszUserID);
    HWND hwndCB = pPrep->hWndCB;
    void *pCB = pPrep->pCB;
    CComBSTR bstrCID;

    // Free the ThreadParams struct.
    if(pPrep)
    {
        delete pPrep;
        pPrep = NULL;
    }

    hr = pLicExpChk->CheckExpiration(bstrFileName, 7, &bstrCID);

    if(SUCCEEDED(hr) && bstrCID.Length())
    {        
        // The normal scenario is that bstrCID == "root" when the root
        // is expired.
        // This code would then get the root license.
        // It's possible bstrCID contains a content ID. In that case,
        // This code would get the leaf license.
        hr = pLicenseDelivery->preDeliverLicense(bstrCID, bstrUID, false);

        if(SUCCEEDED(hr))
        {
            // Check a second time in case the root is invalid.
            // If the first pre-delivery got a leaf, we might still
            // need a root.
            bstrCID.Empty();
            hr = pLicExpChk->CheckExpiration(bstrFileName, 7, &bstrCID);
        }

        if(SUCCEEDED(hr) && 
           bstrCID.Length() &&
           false == bHaveRoot)
        {            
            // Retrieve a root license.
            hr = pLicenseDelivery->preDeliverLicense(CComBSTR("root"), 
                                                      bstrUID, false);

            if(SUCCEEDED(hr))
            { 
                bHaveRoot = true;
            }
        }
    }

    bstrCID.Empty();
    // Test whether this content has copy rights left.
    hr = pLicExpChk->CheckCopyCount(bstrFileName, 1, &bstrCID);

    if(SUCCEEDED(hr) && bstrCID.Length())
    {  
        // Set the third parameter to true to signal the 
        // server code that you're asking for a leaf because 
        // the copy count is 0.
        // This gives the server a chance to apply 
        // business rules to determine whether
        // the user should be granted additional copies.
        hr = pLicenseDelivery->preDeliverLicense(bstrCID, bstrUID, true);
    }
 
    // Post the callback message back to the main thread.
    if(hwndCB && pCB)
    {
        UINT uMarshalCustom = RegisterWindowMessage(
                               _T("ProsewarePlugin_CB"));

        if(uMarshalCustom)
        {
            // Post a message to the plug-in window to make 
            // the callback to Windows Media Player.
            PostMessage(hwndCB, uMarshalCustom, (WPARAM)hr, (LPARAM)pCB);
        }
    }
}

LRESULT OnMarshalCB(UINT nMsg, 
                    WPARAM wParam, 
                    LPARAM lParam, 
                    BOOL& bHandled)
{  
    CComPtr<IWMPSubscriptionServiceCallback> spCB;
    // Note that the smart pointer will call Release() on the 
    // callback pointer (the LPARAM) when out of scope.
    spCB.Attach(
        reinterpret_cast<IWMPSubscriptionServiceCallback*>(lParam));

    if(spCB)
    {
        spCB->onComplete((HRESULT)wParam); 
    }

    return 0;
}

// Wake up sleeping background threads.
ResetEvent(m_hPauseThreadsEvent);
// Signal threads to exit.
SetEvent(m_hExitThreadsEvent);
PostThreadMessage(m_dwPrepareForSyncThreadId, 
                  m_uExitPrepareForSync,
                  0, 
                  0);

HANDLE hThreads[2] = {m_hLicenseUpdateThread, 
                      m_hPrepareForSyncThread};
// Wait for the threads to exit.
WaitForMultipleObjects(2, hThreads, TRUE, 15000);

<%@ LANGUAGE="VBScript"%>
<%
Response.Buffer = True
Response.Expires = 0
Do
    On Error Resume Next

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Declare variables
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    Dim MObj                    ' WMRMMetering object
    Dim MDataObj                ' WMRMMeteringData object
    Dim MContentCollObj         ' WMRMMeteringContentCollection object
    Dim MContentObj             ' WMRMMeteringContent object
    Dim MActionCollObj          ' WMRMMeteringActionCollection object
    Dim MActionObj              ' WMRMMeteringAction object

    Dim MeterChallenge          ' Metering challenge from the client
    Dim MASPrivateKey           ' Private key
    Dim MeterCert               ' Metering certificate
    Dim MeterID                 ' Metering ID
    Dim TransID                 ' Transaction ID
    Dim ContentCollLength       ' Number of items in the 
                                ' content collection
    Dim ContentKeyID            ' Key ID for a content item
    Dim ActionCollLength        ' Number of items in the action collection
    Dim ActionName              ' Action name
    Dim ActionValue             ' Action count
    Dim MeterResponseString     ' Metering response string
    Dim x, y, a, b              ' Counters
    Dim ActionPlay              ' Metered play count
    Dim ActionCopy              ' Metered copy count.

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Set variables.
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' This example assumes that the metering challenge was transmitted
    ' using the name "mchall".
    MeterChallenge = Request.form("mchall")
    MeterCert = "<Replace this with the metering certificate>"
    MASPrivateKey = "<Replace this with the private key.>"

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Extract metering data as a WMRMMeteringData object and as a string.
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    Set MObj = Server.CreateObject("WMRMObjs.WMRMMetering")
    MObj.ServerPrivateKey = MASPrivateKey
    MObj.Challenge = MeterChallenge
    Set MDataObj = MObj.GetMeteringData
    MeterID = MDataObj.MeteringId
    TransID = MDataObj.TransactionId

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Retrieve the collection of content items.
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    Set MContentCollObj = MDataObj.ContentCollection
    ContentCollLength = MContentCollObj.length

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Retrieve the key ID and action data for each content item.
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    For x = 0 To (ContentCollLength - 1)
        ActionPlay = 0
        ActionCopy = 0

        Set MContentObj = MContentCollObj.item(x)
        ContentKeyID = MContentObj.KeyID

        ' Retrieve the collection of actions for the current content item.
        Set MActionCollObj = MContentObj.Actions
        ActionCollLength = MActionCollObj.length

        ' Retrieve each action and its value.
        For y = 0 To ActionCollLength - 1
            Set MActionObj = MActionCollObj.item(y)
            ActionName = MActionObj.Name
            ActionValue = MActionObj.Value
            If (ActionName = "Play") then ActionPlay = ActionValue
            If (ActionName = "Copy") then ActionCopy = ActionValue
        Next
        
        ' AggregateData() is a custom function not implemented
        ' in this example. In practice, this function would 
        ' increment play count and copy count values in a database.
        ' Including the transaction ID ensures that actions
        ' are not counted multiple times. 
        ' You should adjust counts to use the most
        ' recent totals for a given transaction ID.
        AggregateData(ContentKeyID, TransID, ActionPlay, ActionCopy)
    Next

    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    ' Generate the metering response.
    '"""""""""""""""""""""""""""""""""""""""""""""""""""""
    MObj.MeteringCertificate = MeterCert
    MeterResponseString = MObj.GetMeteringResponse
    response.write MeterResponseString

Loop while false

%>

// WMDM 10 includes.
#include <wmdrmdeviceapp.h>
#include <Scclient.h>
#include <mswmdm_i.c>
#include "wmdrmdeviceapp_i.c"

// Thread handle for the
// metering worker thread.
HANDLE  m_hMeteringThread

STDMETHODIMP doMetering(BSTR bstrDeviceName,
                        IWMPSubscriptionServiceCallback *pCB, 
                        HWND hWndCB);

HRESULT CProsewarePlugin::doMetering(BSTR bstrDeviceName, 
                      IWMPSubscriptionServiceCallback *pCB, 
                      HWND hWndCB)
{
    HRESULT hr = S_OK;
    CComBSTR bstrDevName;
    hr = bstrDevName.Append(bstrDeviceName);
    void *pvCB = NULL;

    if(SUCCEEDED(hr) && m_hMeteringThread)
    {
        DWORD dwExitCode = 0;
        // Test whether the thread handle represents
        // an active metering thread. If not, close 
        // it so we can create a new thread.
        if(GetExitCodeThread(m_hMeteringThread, &dwExitCode))
        {
            if(STILL_ACTIVE != dwExitCode)
            {
                CloseHandle(m_hMeteringThread);
                m_hMeteringThread = NULL;
            }
        }
    }
  
    if(SUCCEEDED(hr) && 
       NULL == m_hMeteringThread)
    {
        ThreadParams *pTP = new ThreadParams;
        if(NULL == pTP)
        {
            hr = E_OUTOFMEMORY;
        }

        if(SUCCEEDED(hr))
        {
            if(pCB)
            {   
                pCB->AddRef();
                pvCB = reinterpret_cast<void*>(pCB);
            }

            // Fill in the struct.
            ZeroMemory(pTP, sizeof(ThreadParams));
            bstrDevName.CopyTo(&pTP->bstrName);
            pTP->pCB = pvCB;
            pTP->hWndCB = hWndCB;
      
            m_hMeteringThread = CreateThread(NULL, 0, 
                       MeteringThread, (LPVOID)pTP, NULL, 0);
        }
    }
    else
    {
        hr = E_ACCESSDENIED;
    }

    return hr;
}

// Variable to contain metering certificate.
const WCHAR *METERCERT = L"<Replace this with the metering certificate.>";

DWORD WINAPI MeteringThread(void *pArg)
{
    if(!pArg)
    {
        return 1;
    }
  
    CoInitialize(NULL);
    HRESULT hr = S_OK;

    // Get the members from the param struct.
    // It is valid for all of these to be NULL
    // except pThis.
    ThreadParams *pTP = reinterpret_cast<ThreadParams*>(pArg);    
    void *pCB = pTP->pCB;
    CComBSTR bstrDeviceName;
    bstrDeviceName.Attach(pTP->bstrName);
    HWND hwndCB = pTP->hWndCB;

    CComPtr<IWMDRMDeviceApp> spDeviceApp;
    CComPtr<IWMDeviceManager> spDevMgr;
    CComPtr<IWMDeviceManager2> spDevMgr2;
    CComPtr<IWMDMDevice> spDevice;
    CComBSTR bstrMeterCert;
    hr = bstrMeterCert.Append(METERCERT);
    CComBSTR bstrMeterURL;
    CComBSTR bstrMeteringData;
    CComBSTR bstrResponse;
    DWORD dwProcessFlags = 0;
    DWORD dwBufferSize = 0;
 
    if(SUCCEEDED(hr))
    {
        // Create the WMDRMDeviceApp object.
        hr = spDeviceApp.CoCreateInstance(CLSID_WMDRMDeviceApp, 0,
                CLSCTX_ALL); 
    }

    if(SUCCEEDED(hr))
    {
        // Create the Device Manager object.
        hr = spDevMgr.CoCreateInstance(CLSID_MediaDevMgr, 0, CLSCTX_ALL);
    }

    // Test whether called with a device name.
    if(bstrDeviceName.Length() > 0)
    {
        // QueryInterface for IWMDeviceManager2.
        hr = spDevMgr.QueryInterface(&spDevMgr2);
        if(SUCCEEDED(hr))
        {   
            // Retrieve a pointer to the device.
            hr = spDevMgr2->GetDeviceFromCanonicalName(bstrDeviceName,
                                                       &spDevice);
        }

        if(SUCCEEDED(hr) && spDevice)
        {
            // Verify that the device supports metering.
            CComPtr<IWMDMDevice2> spDevice2;
            DWORD dwFlags = 0;

            hr = spDevice->QueryInterface(&spDevice2);
            if(SUCCEEDED(hr))
            {
                hr = spDeviceApp->QueryDeviceStatus(spDevice2, &dwFlags);
            }

            if(SUCCEEDED(hr))
            {
                if(!(dwFlags & WMDRM_DEVICE_ISWMDRM))
                {
                    hr = NS_E_DEVICE_NOT_WMDRM_DEVICE;
                }
            }
        }
    }
   
    if(SUCCEEDED(hr) &&
        spDeviceApp)
    {
        // NULL device pointer means to meter the PC license store.
        hr =  spDeviceApp->GenerateMeterChallenge(spDevice,
                                                  bstrMeterCert,
                                                  &bstrMeterURL,
                                                  &bstrMeteringData);
    }
   
    if(SUCCEEDED(hr) &&
       bstrMeteringData.Length())
    {
        // Call the function that sends the challenge to the ASP
        // page using HTTP and receives the metering response.
        // This is a placeholder function for this example.
        hr = doChallengeResponse(bstrMeterURL,
                                 bstrMeteringData,
                                 &bstrResponse);
    } 

    if(SUCCEEDED(hr) &&
       bstrResponse.Length())
    {
        dwBufferSize = bstrResponse.ByteLength();
        BYTE *pbyte = new BYTE[dwBufferSize];
        if(NULL == pbyte)
        {
            hr = E_OUTOFMEMORY;
        }

        if(SUCCEEDED(hr))
        {
            // Process the metering response to reset the
            // the metering store. 
            memcpy(pbyte, bstrResponse.m_str, dwBufferSize);
            hr = spDeviceApp->ProcessMeterResponse(spDevice, pbyte, 
                                                dwBufferSize, 
                                                &dwProcessFlags);
        }

        if(pbyte)
        {
            delete[] pbyte;
            pbyte = NULL;
        }
    }

    if(hwndCB && pCB)
    {
        UINT uMarshalCustom = RegisterWindowMessage(
                        _T("MSSampleMusicPlugin_CB"));

        if(uMarshalCustom)
        {
            // Post a message to the plug-in window to make the callback 
            // to Windows Media Player.
            PostMessage(hwndCB, uMarshalCustom, (WPARAM)hr, (LPARAM)pCB);
        }
    }

    if(pTP)
    {
        delete pTP;
        pTP = NULL;
    }

    ATLASSERT(hr);

    CoUninitialize();

    return SUCCEEDED(hr)? 0:1;
}

HANDLE hThreads[3] = {m_hLicenseUpdateThread, 
                      m_hPrepareForSyncThread,
                      m_hMeteringThread};
// Wait for the threads to exit.
WaitForMultipleObjects(3, hThreads, TRUE, 15000);