IDENTITY_ATTRIBUTE_BLOB (Estructura)

Artículo
08/10/2011

Contiene información sobre un único atributo de un ensamblado y se compone de tres DWORD. Cada DWORD es un desplazamiento en un búfer de caracteres generado por el método CurrentIntoBuffer de la interfaz IEnumIDENTITY_ATTRIBUTE

typedef struct _IDENTITY_ATTRIBUTE_BLOB {
    DWORD  ofsNamespace;
    DWORD  ofsName;
    DWORD  ofsValue;
}   IDENTITY_ATTRIBUTE_BLOB;

Miembros

Miembro	Descripción
ofsNamespace	El primer desplazamiento en el búfer de caracteres. Este desplazamiento no va seguido del espacio de nombres del atributo, sino de una serie de caracteres nulos. Por lo tanto, no se utiliza.
ofsName	El segundo desplazamiento en el búfer de caracteres. Esta ubicación marca el inicio del nombre del atributo.
ofsValue	El tercer desplazamiento en el búfer de caracteres. Esta ubicación marca el inicio del nombre del valor.

Ejemplo

El ejemplo siguiente muestra varios pasos básicos, que acaban por producir una estructura IDENTITY_ATTRIBUTE_BLOB rellena:

Obtenga una IReferenceIdentity para el ensamblado.
Llame al método IReferenceIdentity::EnumAttributes y obtenga un IEnumIDENTITY_ATTRIBUTE.
Cree un búfer de caracteres y conviértalo como una estructura IDENTITY_ATTRIBUTE_BLOB.
Llame al método CurrentIntoBuffer de la interfaz IEnumIDENTITY_ATTRIBUTE. Este método copia los atributos Namespace, Name y Value en el búfer de caracteres. Los tres desplazamientos a esas cadenas estarán disponibles en la estructura IDENTITY_ATTRIBUTE_BLOB.

// EnumAssemblyAttributes.cpp : main project file.

#include "stdafx.h"

#include "fusion.h"
#include "windows.h"
#include "stdio.h"
#include "mscoree.h"
#include "isolation.h"

typedef HRESULT (__stdcall *PFNGETREF)(LPCWSTR pwzFile, REFIID riid, IUnknown **ppUnk);
typedef HRESULT (__stdcall *PFNGETAUTH)(IIdentityAuthority **ppIIdentityAuthority);

PFNGETREF                   g_pfnGetAssemblyIdentityFromFile = NULL;
PFNGETAUTH                  g_pfnGetIdentityAuthority = NULL;
IUnknown                    *g_pUnk = NULL;

bool Init()
{
    HRESULT     hr = S_OK;
    DWORD       dwSize = 0;
    bool        bRC = false;
    
    hr = CorBindToRuntimeEx(NULL, L"wks", 0, CLSID_CorRuntimeHost,
                           IID_ICorRuntimeHost, (void **)&g_pUnk);
    if(FAILED(hr)) {
        printf("Error: Failed to initialize CLR runtime! hr = 0x%0x\n",
                hr);
        goto Exit;
    }
   
    if (SUCCEEDED(hr)) {
        hr = GetRealProcAddress("GetAssemblyIdentityFromFile",
                         (VOID **)&g_pfnGetAssemblyIdentityFromFile);
    }

    if (SUCCEEDED(hr)) {
        hr = GetRealProcAddress("GetIdentityAuthority",
                                (VOID **)&g_pfnGetIdentityAuthority);
    }

    if (!g_pfnGetAssemblyIdentityFromFile || 
        !g_pfnGetIdentityAuthority)
    {
        printf("Error: Cannot get required APIs from fusion.dll!\n");
        goto Exit;
    }

    bRC = true;

Exit:
    return bRC;
}

void Shutdown()
{
    if(g_pUnk) {
        g_pUnk->Release();
        g_pUnk = NULL;
    }
}

void Usage()
{
    printf("EnumAssemblyAttributes: A tool to enumerate the identity 
            attributes of a given assembly.\n\n");
    printf("Usage: EnumAssemblyAttributes AssemblyFilePath\n");
    printf("\n");
}

int _cdecl wmain(int argc, LPCWSTR argv[])
{
    int     iResult = 1;
    IUnknown                    *pUnk  = NULL;
    IReferenceIdentity          *pRef  = NULL;
    HRESULT                     hr     = S_OK;   
    IEnumIDENTITY_ATTRIBUTE     *pEnum = NULL;
    BYTE                        abData[1024];
    DWORD                       cbAvailable;
    DWORD                       cbUsed;
    IDENTITY_ATTRIBUTE_BLOB     *pBlob;

    if(argc != 2) {
        Usage();
        goto Exit;
    }

    if(!Init()) {
        printf("Failure initializing EnumIdAttr.\n");
        goto Exit;
    }

    hr = g_pfnGetAssemblyIdentityFromFile(argv[1], 
                            __uuidof(IReferenceIdentity), &pUnk);

    if (FAILED(hr)) {
        printf("GetAssemblyIdentityFromFile failed with hr = 0x%x", 
                hr);
        goto Exit;
    }

    hr = pUnk->QueryInterface(__uuidof(IReferenceIdentity), 
                              (void**)&pRef);
    if (FAILED(hr)) {
        goto Exit;
    }

    hr = pRef->EnumAttributes(&pEnum);
    if (FAILED(hr)) {
        printf("IReferenceIdentity::EnumAttributes failed with hr = 
                0x%x", hr);
        goto Exit;
    }

    pBlob = (IDENTITY_ATTRIBUTE_BLOB *)(abData);
    while (1) {
        cbAvailable = sizeof(abData);
        hr = pEnum->CurrentIntoBuffer(cbAvailable, abData, &cbUsed);
        if (FAILED(hr)) {
            printf("IEnumIDENTITY_ATTRIBUTE::CurrentIntoBuffer failed 
                    with hr = 0x%x", hr);
            goto Exit;
        }

        if (! cbUsed) {
            break;
        }

        LPWSTR pwzNameSpace = (LPWSTR)(abData + pBlob->ofsNamespace);
        LPWSTR pwzName      = (LPWSTR)(abData + pBlob->ofsName);
        LPWSTR pwzValue     = (LPWSTR)(abData + pBlob->ofsValue);
        printf("%ws: %ws = %ws\n", pwzNameSpace, pwzName, pwzValue);

        hr = pEnum->Skip(1);
        if (FAILED(hr)) {
            printf("IEnumIDENTITY_ATTRIBUTE::Skip failed with hr = 
                    0x%x", hr);
            goto Exit;
        }
    }

    iResult = 0;

Exit:

    Shutdown();

    if (pUnk) {
        pUnk->Release();
    }

    if (pRef) {
        pRef->Release();
    }

    if (pEnum) {
        pEnum->Release();
    }

    return iResult;
}