Metodo IWMDMOperation::TransferObjectData (mswmdm.h)

Articolo
03/05/2024

Il metodo TransferObjectData viene chiamato per consentire all'applicazione di trasferire un blocco di dati verso o dal computer.

Sintassi

HRESULT TransferObjectData(
  BYTE     *pData,
  DWORD    *pdwSize,
  BYTE [8] abMac
);

Parametri

pData

Puntatore a un buffer contenente i dati. Questo buffer viene sempre allocato e liberato da Windows Media Gestione dispositivi. L'applicazione non deve mai allocare o liberare questo buffer.

BeginRead[in] Durante una lettura dal dispositivo, i dati in ingresso che devono essere decrittografati usando il metodo CSecureChannelClient::D ecryptParam . L'applicazione non deve deallocare il buffer.

BeginWrite[in, out] Durante una scrittura nel dispositivo, in input è un buffer di memoria pdwSize byte lungo, allocato da Windows Media Gestione dispositivi. L'applicazione deve riempire questo buffer con dati crittografati usando il metodo CSecureChannelClient::EncryptParam .

pdwSize

Puntatore a un DWORD che specifica le dimensioni del buffer di trasferimento.

BeginRead[in, out] In input, le dimensioni dei dati in ingresso in pData. Nell'output la quantità di dati che l'applicazione ha effettivamente letto.

Input BeginWriteOn , dimensioni del buffer pData . In output, le dimensioni effettive dei dati inviati.

abMac

Matrice di byte che specifica il codice di autenticazione del messaggio per i dati dei parametri di questo metodo.

BeginRead[in] Un MAC generato da pData e pdwSize che l'applicazione deve controllare dopo la decrittografiapData , per verificare che i dati non siano stati modificati.

BeginWrite[out] Un MAC generato da pData e pdwSize prima che pData sia crittografato.

Valore restituito

L'applicazione deve restituire uno dei valori HRESULT seguenti.

Codice restituito	Descrizione
S_OK	L'operazione di lettura deve continuare.
WMDM_E_USER_CANCELLED	L'operazione di lettura deve essere annullata senza completare.
E_FAIL	Si è verificato un errore non specificato e l'operazione di lettura deve essere annullata senza terminare.

Commenti

L'applicazione può determinare se i dati vengono letti o scritti nel dispositivo monitorando se BeginRead o BeginWrite è stato chiamato appena prima della chiamata di questo metodo.

Esempio

Il codice C++ seguente illustra come un'applicazione potrebbe implementare TransferObjectData per gestire il trasferimento di file stesso. Il codice illustrato gestisce sia la lettura dei dati da che la scrittura dei dati nel dispositivo. La direzione del flusso di dati è indicata da una variabile membro m_OperationStatus, impostata in una chiamata precedente a BeginRead o BeginWrite.


HRESULT TransferObjectData(BYTE* pData, DWORD* pdwSize, BYTE* pMac)
{
    HRESULT hr = S_OK;

    // Verify parameters.
    if (pData == NULL || pdwSize == NULL || pMac == NULL || m_File == INVALID_HANDLE_VALUE) 
    {
        // TODO: Display the message: "Invalid argument in SetObjectTotalSize."
        return E_INVALIDARG;
    }
    if ((m_OperationStatus != OPERATION_READ) && (m_OperationStatus != OPERATION_WRITE))
    {
        // TODO: Display the message: "Unable to determine direction of data transfer."
        return E_FAIL;
    }

    //////////////////////////////////////////////////////////////////////////
// Sending data to the device.
//////////////////////////////////////////////////////////////////////////
    if (m_OperationStatus == OPERATION_WRITE)
    {
        DWORD   dwReadLen;
        // The SAC is used to encrypt the data sent to the device.
        if (m_pSAC == NULL) 
        {
               // TODO: Display the message: "SAC not initialized in TransferObjectData."
            return E_FAIL;
        }

        // Read pdwSize bytes from the file into pData.
        dwReadLen = *pdwSize;
        if (ReadFile(m_File, pData, dwReadLen, pdwSize, NULL) == FALSE) 
        {
               // TODO: Display the message: "Couldn't read the file in TransferObjectData."
            return E_FAIL;
        }

        // If there is no more data, terminate the transfer.
        if (*pdwSize == 0)
        {
            return S_FALSE;
        }

        // Create the MAC to return to Windows Media Device Manager.
        HMAC hMAC;
        hr = m_pSAC->MACInit(&hMAC);
        hr = m_pSAC->MACUpdate(hMAC, (BYTE*)(pData), *pdwSize);
        hr = m_pSAC->MACUpdate(hMAC, (BYTE*)(pdwSize), sizeof(DWORD));
        hr = m_pSAC->MACFinal(hMAC, (BYTE*)pMac);
        if (hr != S_OK) return E_FAIL;

        // Encrypt the data to send to the service provider/device.
        hr = m_pSAC->EncryptParam((BYTE*)(pData), *pdwSize);
        if (hr != S_OK) 
        {
            return E_FAIL;
        }
    }
    //////////////////////////////////////////////////////////////////////////
// Receiving data from the device.
//////////////////////////////////////////////////////////////////////////
    else 
    {
        // Copy the data to a temporary file for decryption.
        BYTE *pTmpData = new BYTE [*pdwSize];
        if (pTmpData == NULL)
        {
            return E_OUTOFMEMORY;
        }
        memcpy(pTmpData, pData, *pdwSize);

        // Decrypt the pData Parameter
        hr = m_pSAC->DecryptParam(pTmpData, *pdwSize);
        
        // Verify the MAC of the decrypted data.
        HMAC hMAC;
        BYTE pTestMac[WMDM_MAC_LENGTH];
        hr = m_pSAC->MACInit(&hMAC);
        hr = m_pSAC->MACUpdate(hMAC, (BYTE*)(pTmpData), *pdwSize);
        hr = m_pSAC->MACUpdate(hMAC, (BYTE*)(pdwSize), sizeof(*pdwSize));
        hr = m_pSAC->MACFinal(hMAC, pTestMac);
        if ((memcmp(pMac, pTestMac, WMDM_MAC_LENGTH) != 0) || (hr != S_OK))
        {
            delete [] pTmpData;
            return WMDM_E_MAC_CHECK_FAILED;
        }

        // Write the data to file, and record the amount of data written.
        DWORD dwWritten = 0;
        if (WriteFile(m_File,pTmpData,*pdwSize,&dwWritten,NULL))
        {
            hr = S_OK;
            *pdwSize = dwWritten;
        }
        else 
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
        if (pTmpData)
        {
            delete [] pTmpData;
        }
    }
    return hr;
}