SAFEARRAY

Try#ifdef _DEBUG
#include <assert.h>
#define CHECK( x) assert( x)
#else
#define CHECK( x) x //if ( !x) ... to be continued...
#endif

SAFEARRAY* SafeArrayFromData (  const   LPBYTE   pData,
                                const   LONG     lnDataPacketSize
                             )
{
    SAFEARRAY        psa = NULL;
    SAFEARRAYBOUND   saBound[ 1];
    HRESULT          hres;

    PCHAR            pcDataPacket   =   ( char *)   pData;


    saBound->lLbound        =   0;
    saBound->cElements  =   lnDataPacketSize;

    CHECK   (     psa          =    SafeArrayCreate (   VT_UI1,
                                                        1,
                                                        saBound
                                                    )
            );

    for (   long    lIndex  =   0;  lIndex  <   lnDataPacketSize;   lIndex++)
        {
            hres    =   SafeArrayPutElement (    psa,
                                                &lIndex,
                                                 pData + lIndex
                                            );

            CHECK   (   S_OK    ==  hres);
        }

        return psa;
}

void* DataFromSafeArray (   SAFEARRAY FAR   *psa,   BOOL    bCleanup, DWORD* pdwSize)
{
    HRESULT          hres;
    LONG             lnLBound;
    LONG             lnUBound;
    UINT             unElementSize;
    UINT             uFlags         =   GMEM_FIXED | GMEM_ZEROINIT;

    void            *pvData         =   NULL;


    CHECK   ( S_OK  ==  ( hres  =   SafeArrayLock       (   psa)));

    CHECK   ( S_OK  ==  ( hres  =   SafeArrayGetLBound  (    psa,
                                                             1,
                                                            &lnLBound
                                                        )
                        )
            );

    CHECK   ( S_OK  ==  ( hres  =   SafeArrayGetUBound  (    psa,
                                                             1,
                                                            &lnUBound
                                                        )
                        )
            );

    unElementSize       =   SafeArrayGetElemsize(   psa);

    pvData              =   psa->pvData;

    ulDataPacketSize    =   ( lnUBound - lnLBound + 1) * unElementSize;
                            // + 1 as the 0th element also counts...

    pvDataPacket        =   ( PVOID)    GlobalAlloc (   uFlags,
                                                        m_ulDataPacketSize
                                                    );

    CHECK   (   pvDataPacket);

    CopyMemory  (   pvDataPacket,   pvData, ulDataPacketSize);

       
    CHECK   ( S_OK  ==  ( hres  =   SafeArrayUnlock     (   psa)));

    if  (   bCleanup)   SafeArrayDestroy    (   psa);

    *pdwSize = ulDataPacketSize;

    return pvData;

}



HRESULT STDMETHODCALLTYPE ReadFile(/*[in]*/ BSTR fileName, /*[out,retval]*/ VARIANT * theData)
{

    _bstr_t bstr (fileName);

    HANDLE hFile = CreateFile( (char*) bstr, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);

    if (!hFile) return E_FAIL);

    DWORD dwRead;
    DWORD dwSize = GetFileSize(hFile,NULL);

    BYTE* pBuf = new BYTE[dwSize];

    if (!ReadFile(hFile,pBuf,dwSize,&dwRead,NULL))
    {
        delete [] pBuf;
        return E_FAIL;
    }

    CloseHandle(hFile);

    VARIANT pvar = new VARIANT;

    pvar->vt = VT_ARRAY;
    pvar->parray = SafeArrayFromData( pBuf, dwSize);

    *theData = *pVar;

    delete [] pBuf;

    return S_OK;
}

HRESULT STDMETHODCALLTYPE WriteFile(/*[in]*/ BSTR fileName, /*[in]*/ VARIANT theData)
{

    _bstr_t bstr (fileName);

    if ( theData.vt != VT_ARRAY) return E_INVALIDARG;

    HANDLE hFile = CreateFile( (char*) bstr, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);

    if (!hFile) return E_FAIL;

    DWORD dwSize;
    DWORD dwWritten;

    BYTE* pBuf = (BYTE*) DataFromSafeArray(theData.parray, TRUE, &dwSize);

    if (!WriteFile(hFile,pBuf,dwSize,&dwRead,NULL))
    {
        delete [] pBuf;
        return E_FAIL;
    }

    CloseHandle(hFile);

    return S_OK;
}

(taken from production code and added file handling)