storage32.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winuser.h"
#include "wine/debug.h"
#include "ole2.h"
#include "winreg.h"
#include "wine/wingdi16.h"

Include dependency graph for storage32.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Enumerations
enum	stream_1ole_flags { OleStream_LinkedObject = 0x00000001 , OleStream_Convert = 0x00000004 , OleStream_LinkedObject = 0x00000001 , OleStream_Convert = 0x00000004 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (storage)
HRESULT WINAPI	WriteClassStg (IStorage *pStg, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStg (IStorage *pstg, CLSID *pclsid)
HRESULT WINAPI	WriteClassStm (IStream *pStm, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStm (IStream *pStm, CLSID *pclsid)
HRESULT WINAPI	GetConvertStg (IStorage *stg)
HRESULT WINAPI	StgIsStorageILockBytes (ILockBytes *plkbyt)
HRESULT WINAPI	StgIsStorageFile (LPCOLESTR fn)
HRESULT WINAPI	StgCreatePropSetStg (IStorage *pstg, DWORD reserved, IPropertySetStorage **propset)

Variables
static const BYTE	STORAGE_magic [8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1}

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 39 of file storage32.c.

Enumeration Type Documentation

stream_1ole_flags

enum stream_1ole_flags

Enumerator
OleStream_LinkedObject
OleStream_Convert
OleStream_LinkedObject
OleStream_Convert

Definition at line 133 of file storage32.c.

                       {
    OleStream_LinkedObject = 0x00000001,
    OleStream_Convert      = 0x00000004
};

Function Documentation

GetConvertStg()

HRESULT WINAPI GetConvertStg

(

IStorage *

stg

)

Definition at line 141 of file storage32.c.

{
    static const DWORD version_magic = 0x02000001;
    DWORD header[2];
    IStream *stream;
    HRESULT hr;
 
    TRACE("%p\n", stg);
 
    if (!stg) return E_INVALIDARG;
 
    hr = IStorage_OpenStream(stg, L"\1Ole", NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
    if (FAILED(hr)) return hr;
 
    hr = IStream_Read(stream, header, sizeof(header), NULL);
    IStream_Release(stream);
    if (FAILED(hr)) return hr;
 
    if (header[0] != version_magic)
    {
        ERR("got wrong version magic for 1Ole stream, %#lx.\n", header[0]);
        return E_FAIL;
    }
 
    return header[1] & OleStream_Convert ? S_OK : S_FALSE;
}

Referenced by test_convert().

ReadClassStg()

HRESULT WINAPI ReadClassStg	(	IStorage *	pstg,
		CLSID *	pclsid
	)

Definition at line 72 of file storage32.c.

{
    STATSTG pstatstg;
    HRESULT hRes;
 
    TRACE("(%p, %p)\n", pstg, pclsid);
 
    if (!pstg || !pclsid)
        return E_INVALIDARG;
 
   /*
    * read a STATSTG structure (contains the clsid) from the storage
    */
    hRes = IStorage_Stat(pstg, &pstatstg, STATFLAG_NONAME);
 
    if (SUCCEEDED(hRes))
        *pclsid = pstatstg.clsid;
 
    return hRes;
}

Referenced by DataCache_InitNew(), DataCache_Load(), GetClassFile(), render_embed_source_hack(), and test_writeclassstg().

ReadClassStm()

HRESULT WINAPI ReadClassStm	(	IStream *	pStm,
		CLSID *	pclsid
	)

Definition at line 109 of file storage32.c.

{
    ULONG nbByte;
    HRESULT res;
 
    TRACE("(%p,%p)\n", pStm, pclsid);
 
    if (!pStm || !pclsid)
        return E_INVALIDARG;
 
    /* clear the output args */
    *pclsid = CLSID_NULL;
 
    res = IStream_Read(pStm, pclsid, sizeof(CLSID), &nbByte);
 
    if (FAILED(res))
        return res;
 
    if (nbByte != sizeof(CLSID))
        return STG_E_READFAULT;
    else
        return S_OK;
}

Referenced by OleLoadFromStream(), ReadFmtUserTypeStg(), and test_ReadClassStm().

StgCreatePropSetStg()

HRESULT WINAPI StgCreatePropSetStg	(	IStorage *	pstg,
		DWORD	reserved,
		IPropertySetStorage **	propset
	)

Definition at line 233 of file storage32.c.

{
    TRACE("%p, %#lx, %p.\n", pstg, reserved, propset);
    if (reserved)
        return STG_E_INVALIDPARAMETER;
 
    return IStorage_QueryInterface(pstg, &IID_IPropertySetStorage, (void**)propset);
}

Referenced by test_propertyset_storage_enum(), testCodepage(), and testPropsHelper().

StgIsStorageFile()

HRESULT WINAPI StgIsStorageFile

(

LPCOLESTR

fn

)

Definition at line 191 of file storage32.c.

{
    HANDLE hf;
    BYTE magic[8];
    DWORD bytes_read;
 
    TRACE("%s\n", debugstr_w(fn));
    hf = CreateFileW(fn, GENERIC_READ,
                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                     NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 
    if (hf == INVALID_HANDLE_VALUE)
        return STG_E_FILENOTFOUND;
 
    if (!ReadFile(hf, magic, 8, &bytes_read, NULL))
    {
        WARN(" unable to read file\n");
        CloseHandle(hf);
        return S_FALSE;
    }
 
    CloseHandle(hf);
 
    if (bytes_read != 8)
    {
        TRACE(" too short\n");
        return S_FALSE;
    }
 
    if (!memcmp(magic, STORAGE_magic, 8))
    {
        TRACE(" -> YES\n");
        return S_OK;
    }
 
    TRACE(" -> Invalid header.\n");
    return S_FALSE;
}

Referenced by GetClassFile().

StgIsStorageILockBytes()

HRESULT WINAPI StgIsStorageILockBytes

(

ILockBytes *

plkbyt

)

Definition at line 171 of file storage32.c.

{
    BYTE sig[sizeof(STORAGE_magic)];
    ULARGE_INTEGER offset;
    ULONG read = 0;
 
    offset.HighPart = 0;
    offset.LowPart  = 0;
 
    ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), &read);
 
    if (read == sizeof(sig) && memcmp(sig, STORAGE_magic, sizeof(sig)) == 0)
      return S_OK;
 
    return S_FALSE;
}

Referenced by get_stgmed_for_storage(), and test_hglobal_storage_stat().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

storage

)

WriteClassStg()

HRESULT WINAPI WriteClassStg	(	IStorage *	pStg,
		REFCLSID	rclsid
	)

Definition at line 58 of file storage32.c.

{
    if (!pStg)
        return E_INVALIDARG;
 
    if (!rclsid)
        return STG_E_INVALIDPOINTER;
 
    return IStorage_SetClass(pStg, rclsid);
}

Referenced by OleCreateStaticFromData(), OleSave(), test_hglobal_storage_stat(), test_overwrite(), test_storage_refcount(), test_streamenum(), test_transacted_shared(), and test_writeclassstg().

WriteClassStm()

HRESULT WINAPI WriteClassStm	(	IStream *	pStm,
		REFCLSID	rclsid
	)

Definition at line 96 of file storage32.c.

{
    TRACE("(%p,%p)\n", pStm, rclsid);
 
    if (!pStm || !rclsid)
        return E_INVALIDARG;
 
    return IStream_Write(pStm, rclsid, sizeof(CLSID), NULL);
}

Referenced by OLECONVERT_CreateCompObjStream(), OleSaveToStream(), STORAGE_WriteCompObj(), and test_ReadClassStm().

Variable Documentation

STORAGE_magic

const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1}

static

Definition at line 53 of file storage32.c.

Referenced by OleConvertOLESTREAMToIStorage(), StgIsStorageFile(), StgIsStorageILockBytes(), StorageImpl_LoadFileHeader(), and StorageImpl_SaveFileHeader().