Método IWMDMOperation::TransferObjectData (mswmdm.h)

Artigo
08/25/2023

O método TransferObjectData é chamado para permitir que o aplicativo transfira um bloco de dados de ou para o computador.

Sintaxe

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

Parâmetros

pData

Ponteiro para um buffer que contém os dados. Esse buffer é sempre alocado e liberado pela Gerenciador de Dispositivos do Windows Media. Seu aplicativo nunca deve alocar ou liberar esse buffer.

BeginRead[in] Durante uma leitura do dispositivo, os dados de entrada que devem ser descriptografados usando o método CSecureChannelClient::D ecryptParam . O aplicativo não precisa desalocar o buffer.

BeginWrite[in, out] Durante uma gravação no dispositivo, na entrada há um buffer de memória pdwSize bytes longo, alocado pelo Windows Media Gerenciador de Dispositivos. O aplicativo deve preencher esse buffer com dados que foram criptografados usando o método CSecureChannelClient::EncryptParam .

pdwSize

Ponteiro para um DWORD que especifica o tamanho do buffer de transferência.

BeginRead[in, out] Na entrada, o tamanho dos dados de entrada no pData. Na saída, a quantidade de dados que o aplicativo realmente leu.

Entrada BeginWriteOn , o tamanho do buffer pData . Na saída, o tamanho real dos dados enviados.

abMac

Matriz de bytes especificando o código de autenticação de mensagem para os dados de parâmetro desse método.

BeginRead[in] Um MAC gerado a partir de pData e pdwSize que o aplicativo deve marcar depois que pData é descriptografado, para verificar se os dados não foram modificados.

BeginWrite[out] Um MAC gerado a partir de pData e pdwSize antes de pData ser criptografado.

Retornar valor

O aplicativo deve retornar um dos seguintes valores HRESULT .

Código de retorno	Descrição
S_OK	A operação de leitura deve continuar.
WMDM_E_USER_CANCELLED	A operação de leitura deve ser cancelada sem término.
E_FAIL	Ocorreu um erro não especificado e a operação de leitura deve ser cancelada sem término.

Comentários

O aplicativo pode determinar se os dados estão sendo lidos ou gravados no dispositivo monitorando se BeginRead ou BeginWrite foi chamado pouco antes desse método ser chamado.

Exemplos

O código C++ a seguir demonstra como um aplicativo pode implementar TransferObjectData para lidar com a própria transferência de arquivo. O código mostrado lida com dados de leitura e gravação de dados no dispositivo. A direção do fluxo de dados é indicada por uma variável de membro m_OperationStatus, definida em uma chamada anterior para BeginRead ou 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;
}