Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 20:23:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Sync to Wine-20041201

Browse source 
Robert Shearman <rob@codeweavers.com>
- Add some function declarations to objbase.h.
- Add stubs for server ref counting.
- Implement HRESULT marshaling.
- Implement OleDuplicateData.
Eric Pouech <pouech-eric@wanadoo.fr>
- Const correctness fixes.
Mike Hearn <mh@codeweavers.com>
- Improve OLE function documentation.
- Bail out with CO_E_NOTINITIALIZED when apt is null.
Dmitry Timoshkov <dmitry@codeweavers.com>
- Remove bogus use of nStatCounter and hOleAut32 in CoSetState.
- Remove a comment about protecting per thread data by a critical section.
Francois Gouget <fgouget@free.fr>
- Assorted spelling fixes.
Mike Hearn <mh@codeweavers.com>
- Trace the OLE error info strings.

svn path=/trunk/; revision=11962
This commit is contained in:
Gé van Geldorp 2004-12-06 10:07:19 +00:00
parent 8679951253
commit 87ac9421e8
9 changed files with 312 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

226
reactos/lib/ole32/compobj.c
View file

@ -160,7 +160,8 @@ void COMPOBJ_InitProcess( void )
* following class is created. The *caller* of CoMarshalInterface (ie the * following class is created. The *caller* of CoMarshalInterface (ie the
* application) is responsible for pumping the message loop in that thread. * application) is responsible for pumping the message loop in that thread.
* The WM_USER messages which point to the RPCs are then dispatched to * The WM_USER messages which point to the RPCs are then dispatched to
* COM_AptWndProc by the user's code. * COM_AptWndProc by the user's code from the apartment in which the interface
* was unmarshalled.
*/ */
memset(&wclass, 0, sizeof(wclass)); memset(&wclass, 0, sizeof(wclass));
wclass.lpfnWndProc = &COM_AptWndProc; wclass.lpfnWndProc = &COM_AptWndProc;
@ -192,6 +193,8 @@ static void COM_InitMTA(void)
This method of generating an OXID is therefore wrong as it doesn't work across This method of generating an OXID is therefore wrong as it doesn't work across
a network, but for local RPC only it's OK. We can distinguish between MTAs and a network, but for local RPC only it's OK. We can distinguish between MTAs and
STAs because STAs use the thread ID as well, and no thread can have an ID of zero. STAs because STAs use the thread ID as well, and no thread can have an ID of zero.
The algorithm Microsoft use is currently unknown.
*/ */
MTA.oxid = ((OXID)GetCurrentProcessId() << 32); MTA.oxid = ((OXID)GetCurrentProcessId() << 32);
InitializeCriticalSection(&MTA.cs); InitializeCriticalSection(&MTA.cs);
@ -266,7 +269,7 @@ static void COM_DestroyApartment(APARTMENT *apt)
} }
/* The given OXID must be local to this process: you cannot use apartment /* The given OXID must be local to this process: you cannot use apartment
windows to send RPCs to other processes */ windows to send RPCs to other processes. This all needs to move to rpcrt4 */
HWND COM_GetApartmentWin(OXID oxid) HWND COM_GetApartmentWin(OXID oxid)
{ {
APARTMENT *apt; APARTMENT *apt;
@ -377,9 +380,11 @@ DWORD WINAPI CoBuildVersion(void)
/****************************************************************************** /******************************************************************************
* CoInitialize [OLE32.@] * CoInitialize [OLE32.@]
* *
* Initializes the COM libraries. * Initializes the COM libraries by calling CoInitializeEx with
* COINIT_APARTMENTTHREADED, ie it enters a STA thread.
* *
* See CoInitializeEx * SEE ALSO
* CoInitializeEx
*/ */
HRESULT WINAPI CoInitialize( HRESULT WINAPI CoInitialize(
LPVOID lpReserved /* [in] pointer to win32 malloc interface LPVOID lpReserved /* [in] pointer to win32 malloc interface
@ -395,14 +400,22 @@ HRESULT WINAPI CoInitialize(
/****************************************************************************** /******************************************************************************
* CoInitializeEx [OLE32.@] * CoInitializeEx [OLE32.@]
* *
* Initializes the COM libraries. The behavior used to set the win32 IMalloc * Initializes the COM libraries. The behavior used to set the win32
* used for memory management is obsolete. * IMalloc used for memory management is obsolete. If
* COINIT_APARTMENTTHREADED is specified this thread enters a new STA
* (single threaded apartment), otherwise COINIT_MULTITHREADED should
* be specified which indicates that the thread will enter the MTA.
*
* Currently STA threading is only partly implemented.
* *
* RETURNS * RETURNS
* S_OK if successful, * S_OK if successful,
* S_FALSE if this function was called already. * S_FALSE if this function was called already.
* RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another * RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
* threading model. * threading model.
*
* SEE ALSO
* CoUninitialize
*/ */
HRESULT WINAPI CoInitializeEx( HRESULT WINAPI CoInitializeEx(
LPVOID lpReserved, /* [in] pointer to win32 malloc interface LPVOID lpReserved, /* [in] pointer to win32 malloc interface
@ -427,7 +440,7 @@ HRESULT WINAPI CoInitializeEx(
{ {
/* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
code then we are probably using the wrong threading model to implement that API. */ code then we are probably using the wrong threading model to implement that API. */
WARN("Attempt to change threading model of this apartment from 0x%lx to 0x%lx\n", apt->model, dwCoInit); ERR("Attempt to change threading model of this apartment from 0x%lx to 0x%lx\n", apt->model, dwCoInit);
return RPC_E_CHANGED_MODE; return RPC_E_CHANGED_MODE;
} }
hr = S_FALSE; hr = S_FALSE;
@ -483,9 +496,18 @@ void COM_FlushMessageQueue(void)
/*********************************************************************** /***********************************************************************
* CoUninitialize [OLE32.@] * CoUninitialize [OLE32.@]
* *
* This method will release the COM libraries. * This method will decrement the refcount on the COM libraries,
* potentially unloading them. The current thread leaves the apartment
* it's currently in. If not in an apartment, the routine does
* nothing.
* *
* See the windows documentation for more details. * If COM is to be shut down, any outstanding proxies are
* disconnected, all registered class objects are unregistered and the
* message queue for the thread is flushed (if native does
* this or not is unknown).
*
* SEE ALSO
* CoInitializeEx
*/ */
void WINAPI CoUninitialize(void) void WINAPI CoUninitialize(void)
{ {
@ -516,7 +538,7 @@ void WINAPI CoUninitialize(void)
/* disconnect proxies to release the corresponding stubs. /* disconnect proxies to release the corresponding stubs.
* It is confirmed in "Essential COM" in the sub-chapter on * It is confirmed in "Essential COM" in the sub-chapter on
* "Lifecycle Management and Marshaling" that the native version also * "Lifecycle Management and Marshalling" that the native version also
* does some kind of proxy cleanup in this function. * does some kind of proxy cleanup in this function.
* FIXME: does it just disconnect or completely destroy the proxies? * FIXME: does it just disconnect or completely destroy the proxies?
* FIXME: should this be in the apartment destructor? */ * FIXME: should this be in the apartment destructor? */
@ -562,6 +584,11 @@ HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
/****************************************************************************** /******************************************************************************
* CoCreateGuid[OLE32.@] * CoCreateGuid[OLE32.@]
* *
* Simply forwards to UuidCreate in RPCRT4.
*
* SEE ALSO
* UuidCreate
*
*/ */
HRESULT WINAPI CoCreateGuid( HRESULT WINAPI CoCreateGuid(
GUID *pguid /* [out] points to the GUID to initialize */ GUID *pguid /* [out] points to the GUID to initialize */
@ -572,20 +599,23 @@ HRESULT WINAPI CoCreateGuid(
/****************************************************************************** /******************************************************************************
* CLSIDFromString [OLE32.@] * CLSIDFromString [OLE32.@]
* IIDFromString [OLE32.@] * IIDFromString [OLE32.@]
*
* Converts a unique identifier from its string representation into * Converts a unique identifier from its string representation into
* the GUID struct. * the GUID struct.
* *
* UNDOCUMENTED * In Windows, if idstr is not a valid CLSID string then it gets
* If idstr is not a valid CLSID string then it gets treated as a ProgID * treated as a ProgID. Wine currently doesn't do this. If idstr is
* NULL it's treated as an all-zero GUID.
* *
* RETURNS * RETURNS
* the converted GUID * S_OK on success
* CO_E_CLASSSTRING if idstr is not a valid CLSID
*/ */
HRESULT WINAPI __CLSIDFromStringA( HRESULT WINAPI __CLSIDFromStringA(
LPCSTR idstr, /* [in] string representation of guid */ LPCSTR idstr, /* [in] string representation of guid */
CLSID *id) /* [out] GUID converted from string */ CLSID *id) /* [out] GUID converted from string */
{ {
const BYTE *s = (BYTE *) idstr; const BYTE *s = (const BYTE *) idstr;
int i; int i;
BYTE table[256]; BYTE table[256];
@ -661,15 +691,7 @@ HRESULT WINAPI CLSIDFromString(
return ret; return ret;
} }
/****************************************************************************** /* Converts a GUID into the respective string representation. */
* WINE_StringFromCLSID [Internal]
* Converts a GUID into the respective string representation.
*
* NOTES
*
* RETURNS
* the string representation and HRESULT
*/
HRESULT WINE_StringFromCLSID( HRESULT WINE_StringFromCLSID(
const CLSID *id, /* [in] GUID to be converted */ const CLSID *id, /* [in] GUID to be converted */
LPSTR idstr /* [out] pointer to buffer to contain converted guid */ LPSTR idstr /* [out] pointer to buffer to contain converted guid */
@ -707,20 +729,23 @@ HRESULT WINE_StringFromCLSID(
/****************************************************************************** /******************************************************************************
* StringFromCLSID [OLE32.@] * StringFromCLSID [OLE32.@]
* StringFromIID [OLE32.@] * StringFromIID [OLE32.@]
*
* Converts a GUID into the respective string representation. * Converts a GUID into the respective string representation.
* The target string is allocated using the OLE IMalloc. * The target string is allocated using the OLE IMalloc.
*
* RETURNS * RETURNS
* the string representation and HRESULT * S_OK
* E_FAIL
*/ */
HRESULT WINAPI StringFromCLSID( HRESULT WINAPI StringFromCLSID(
REFCLSID id, /* [in] the GUID to be converted */ REFCLSID id, /* [in] the GUID to be converted */
LPOLESTR *idstr /* [out] a pointer to a to-be-allocated pointer pointing to the resulting string */ LPOLESTR *idstr /* [out] a pointer to a to-be-allocated pointer pointing to the resulting string */
) { ) {
char buf[80]; char buf[80];
HRESULT ret; HRESULT ret;
LPMALLOC mllc; LPMALLOC mllc;
if ((ret=CoGetMalloc(0,&mllc))) if ((ret = CoGetMalloc(0,&mllc)))
return ret; return ret;
ret=WINE_StringFromCLSID(id,buf); ret=WINE_StringFromCLSID(id,buf);
@ -736,15 +761,16 @@ HRESULT WINAPI StringFromCLSID(
* StringFromGUID2 [COMPOBJ.76] * StringFromGUID2 [COMPOBJ.76]
* StringFromGUID2 [OLE32.@] * StringFromGUID2 [OLE32.@]
* *
* Converts a global unique identifier into a string of an API- * Modified version of StringFromCLSID that allows you to specify max
* specified fixed format. (The usual {.....} stuff.) * buffer size.
* *
* RETURNS * RETURNS
* The (UNICODE) string representation of the GUID in 'str'
* The length of the resulting string, 0 if there was any problem. * The length of the resulting string, 0 if there was any problem.
*/ */
INT WINAPI INT WINAPI StringFromGUID2(
StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax) REFGUID id, /* [in] GUID to convert to string */
LPOLESTR str, /* [out] Unicode buffer to hold result */
INT cmax)
{ {
char xguid[80]; char xguid[80];
@ -754,12 +780,16 @@ StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
} }
/****************************************************************************** /******************************************************************************
* ProgIDFromCLSID [OLE32.@] * ProgIDFromCLSID [OLE32.@]
* Converts a class id into the respective Program ID. (By using a registry lookup) *
* RETURNS S_OK on success * Converts a class id into the respective Program ID. (By using a
* riid associated with the progid * registry lookup)
*
* RETURNS
* S_OK
* E_OUTOFMEMORY
* REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
*/ */
HRESULT WINAPI ProgIDFromCLSID( HRESULT WINAPI ProgIDFromCLSID(
REFCLSID clsid, /* [in] class id as found in registry */ REFCLSID clsid, /* [in] class id as found in registry */
LPOLESTR *lplpszProgID/* [out] associated Prog ID */ LPOLESTR *lplpszProgID/* [out] associated Prog ID */
@ -805,12 +835,6 @@ HRESULT WINAPI ProgIDFromCLSID(
return ret; return ret;
} }
/******************************************************************************
* CLSIDFromProgID [COMPOBJ.61]
* Converts a program id into the respective GUID. (By using a registry lookup)
* RETURNS
* riid associated with the progid
*/
HRESULT WINAPI CLSIDFromProgID16( HRESULT WINAPI CLSIDFromProgID16(
LPCOLESTR16 progid, /* [in] program id as found in registry */ LPCOLESTR16 progid, /* [in] program id as found in registry */
LPCLSID riid /* [out] associated CLSID */ LPCLSID riid /* [out] associated CLSID */
@ -837,13 +861,17 @@ HRESULT WINAPI CLSIDFromProgID16(
} }
/****************************************************************************** /******************************************************************************
* CLSIDFromProgID [OLE32.@] * CLSIDFromProgID [COMPOBJ.61]
* Converts a program id into the respective GUID. (By using a registry lookup) *
* Converts a program id into the respective GUID. (By using a
* registry lookup)
*
* RETURNS * RETURNS
* riid associated with the progid * S_OK
* CO_E_CLASSSTRING if the given ProgID cannot be found
*/ */
HRESULT WINAPI CLSIDFromProgID( HRESULT WINAPI CLSIDFromProgID(
LPCOLESTR progid, /* [in] program id as found in registry */ LPCOLESTR progid, /* [in] Unicode program id as found in registry */
LPCLSID riid ) /* [out] associated CLSID */ LPCLSID riid ) /* [out] associated CLSID */
{ {
static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 }; static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
@ -875,22 +903,30 @@ HRESULT WINAPI CLSIDFromProgID(
/***************************************************************************** /*****************************************************************************
* CoGetPSClsid [OLE32.@] * CoGetPSClsid [OLE32.@]
* *
* This function returns the CLSID of the proxy/stub factory that implements IPSFactoryBuffer * This function returns the CLSID of the proxy/stub factory that
* for the specified interface. * implements IPSFactoryBuffer for the specified interface.
* *
* The standard marshaller activates the object with the CLSID returned and uses the * The standard marshaller activates the object with the CLSID
* CreateProxy and CreateStub methods on its IPSFactoryBuffer interface to construct * returned and uses the CreateProxy and CreateStub methods on its
* the proxies and stubs for a given object. * IPSFactoryBuffer interface to construct the proxies and stubs for a
* given object.
* *
* CoGetPSClsid determines this CLSID by searching the * CoGetPSClsid determines this CLSID by searching the
* HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32 in the registry * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
* and any interface id registered by CoRegisterPSClsid within the current process. * in the registry and any interface id registered by
* CoRegisterPSClsid within the current process.
* *
* FIXME: We only search the registry, not ids registered with CoRegisterPSClsid. * FIXME: We only search the registry, not ids registered with
* CoRegisterPSClsid.
*
* RETURNS
* S_OK
* E_OUTOFMEMORY
* E_INVALIDARG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
*/ */
HRESULT WINAPI CoGetPSClsid( HRESULT WINAPI CoGetPSClsid(
REFIID riid, /* [in] Interface whose proxy/stub CLSID is to be returned */ REFIID riid, /* [in] Interface whose proxy/stub CLSID is to be returned */
CLSID *pclsid ) /* [out] Where to store returned proxy/stub CLSID */ CLSID *pclsid ) /* [out] Where to store returned proxy/stub CLSID */
{ {
char *buf, buf2[40]; char *buf, buf2[40];
DWORD buf2len; DWORD buf2len;
@ -1139,29 +1175,40 @@ _LocalServerThread(LPVOID param) {
/****************************************************************************** /******************************************************************************
* CoRegisterClassObject [OLE32.@] * CoRegisterClassObject [OLE32.@]
*
* This method will register the class object for a given class
* ID. Servers housed in EXE files use this method instead of
* exporting DllGetClassObject to allow other code to connect to their
* objects.
* *
* This method will register the class object for a given class ID. Servers housed * When a class object (an object which implements IClassFactory) is
* in EXE files use this method instead of exporting DllGetClassObject to allow other * registered in this way, a new thread is started which listens for
* code to connect to their objects. * connections on a named pipe specific to the registered CLSID. When
* something else connects to it, it writes out the marshalled
* IClassFactory interface to the pipe. The code on the other end uses
* this buffer to unmarshal the class factory, and can then call
* methods on it.
* *
* When a class object (an object which implements IClassFactory) is registered in * In Windows, such objects are registered with the RPC endpoint
* this way, a new thread is started which listens for connections on a named pipe * mapper, not with a unique named pipe.
* specific to the registered CLSID. When something else connects to it, it writes
* out the marshalled IClassFactory interface to the pipe. The code on the other end
* uses this buffer to unmarshal the class factory, and can then call methods on it.
* *
* In Windows, such objects are registered with the RPC endpoint mapper, not with * MSDN claims that multiple interface registrations are legal, but we
* a unique named pipe. * can't do that with our current implementation.
* *
* See the Windows documentation for more details. * RETURNS
* S_OK on success,
* E_INVALIDARG if lpdwRegister or pUnk are NULL,
* CO_E_OBJISREG if the object is already registered. We should not return this.
*
* SEE ALSO
* CoRevokeClassObject, CoGetClassObject
*/ */
HRESULT WINAPI CoRegisterClassObject( HRESULT WINAPI CoRegisterClassObject(
REFCLSID rclsid, REFCLSID rclsid, /* [in] CLSID of the object to register */
LPUNKNOWN pUnk, LPUNKNOWN pUnk, /* [in] IUnknown of the object */
DWORD dwClsContext, /* [in] CLSCTX flags indicating the context in which to run the executable */ DWORD dwClsContext, /* [in] CLSCTX flags indicating the context in which to run the executable */
DWORD flags, /* [in] REGCLS flags indicating how connections are made */ DWORD flags, /* [in] REGCLS flags indicating how connections are made */
LPDWORD lpdwRegister LPDWORD lpdwRegister) /* [out] A unique cookie that can be passed to CoRevokeClassObject */
)
{ {
RegisteredClass* newClass; RegisteredClass* newClass;
LPUNKNOWN foundObject; LPUNKNOWN foundObject;
@ -1178,9 +1225,6 @@ HRESULT WINAPI CoRegisterClassObject(
/* /*
* First, check if the class is already registered. * First, check if the class is already registered.
* If it is, this should cause an error. * If it is, this should cause an error.
*
* MSDN claims that multiple interface registrations are legal, but we can't do that with
* our current implementation.
*/ */
hr = COM_GetRegisteredClassObject(rclsid, dwClsContext, &foundObject); hr = COM_GetRegisteredClassObject(rclsid, dwClsContext, &foundObject);
if (hr == S_OK) { if (hr == S_OK) {
@ -1525,9 +1569,11 @@ HRESULT WINAPI CoCreateInstance(
REFIID iid, REFIID iid,
LPVOID *ppv) LPVOID *ppv)
{ {
HRESULT hres; HRESULT hres;
LPCLASSFACTORY lpclf = 0; LPCLASSFACTORY lpclf = 0;
if (!COM_CurrentApt()) return CO_E_NOTINITIALIZED;
/* /*
* Sanity check * Sanity check
*/ */
@ -1962,9 +2008,6 @@ HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) {
return 0; return 0;
} }
static int nStatCounter = 0; /* global */
static HMODULE hOleAut32 = 0; /* global */
/*********************************************************************** /***********************************************************************
* CoGetState [OLE32.@] * CoGetState [OLE32.@]
* *
@ -1990,7 +2033,6 @@ HRESULT WINAPI CoGetState(IUnknown ** ppv)
/*********************************************************************** /***********************************************************************
* CoSetState [OLE32.@] * CoSetState [OLE32.@]
* *
* NOTES: FIXME: protect this with a crst
*/ */
HRESULT WINAPI CoSetState(IUnknown * pv) HRESULT WINAPI CoSetState(IUnknown * pv)
{ {
@ -2002,15 +2044,11 @@ HRESULT WINAPI CoSetState(IUnknown * pv)
if (pv) { if (pv) {
IUnknown_AddRef(pv); IUnknown_AddRef(pv);
nStatCounter++;
if (nStatCounter == 1) LoadLibraryA("OLEAUT32.DLL");
} }
if (apt->state) { if (apt->state) {
TRACE("-- release %p now\n", apt->state); TRACE("-- release %p now\n", apt->state);
IUnknown_Release(apt->state); IUnknown_Release(apt->state);
nStatCounter--;
if (!nStatCounter) FreeLibrary(hOleAut32);
} }
apt->state = pv; apt->state = pv;
return S_OK; return S_OK;
@ -2211,3 +2249,21 @@ HRESULT WINAPI CoSuspendClassObjects(void)
FIXME("\n"); FIXME("\n");
return S_OK; return S_OK;
} }
/***********************************************************************
* CoAddRefServerProcess [OLE32.@]
*/
ULONG WINAPI CoAddRefServerProcess(void)
{
FIXME("\n");
return 2;
}
/***********************************************************************
* CoReleaseServerProcess [OLE32.@]
*/
ULONG WINAPI CoReleaseServerProcess(void)
{
FIXME("\n");
return 1;
}

4
reactos/lib/ole32/errorinfo.c
View file

@ -358,7 +358,7 @@ static HRESULT WINAPI ICreateErrorInfoImpl_SetSource(
LPOLESTR szSource) LPOLESTR szSource)
{ {
_ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface); _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
TRACE("(%p)\n",This); TRACE("(%p): %s\n",This, debugstr_w(szSource));
if (This->bstrSource != NULL) if (This->bstrSource != NULL)
ERRORINFO_SysFreeString(This->bstrSource); ERRORINFO_SysFreeString(This->bstrSource);
This->bstrSource = ERRORINFO_SysAllocString(szSource); This->bstrSource = ERRORINFO_SysAllocString(szSource);
@ -371,7 +371,7 @@ static HRESULT WINAPI ICreateErrorInfoImpl_SetDescription(
LPOLESTR szDescription) LPOLESTR szDescription)
{ {
_ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface); _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
TRACE("(%p)\n",This); TRACE("(%p): %s\n",This, debugstr_w(szDescription));
if (This->bstrDescription != NULL) if (This->bstrDescription != NULL)
ERRORINFO_SysFreeString(This->bstrDescription); ERRORINFO_SysFreeString(This->bstrDescription);
This->bstrDescription = ERRORINFO_SysAllocString(szDescription); This->bstrDescription = ERRORINFO_SysAllocString(szDescription);

44
reactos/lib/ole32/marshal.c
View file

@ -763,3 +763,47 @@ MARSHAL_GetStandardMarshalCF(LPVOID *ppv) {
*ppv = &pdfmarshalcfvtbl; *ppv = &pdfmarshalcfvtbl;
return S_OK; return S_OK;
} }
/***********************************************************************
* CoMarshalHresult [OLE32.@]
*
* Marshals an HRESULT value into a stream.
*
* PARAMS
* pStm [I] Stream that hresult will be marshaled into.
* hresult [I] HRESULT to be marshaled.
*
* RETURNS
* Success: S_OK
* Failure: A COM error code
*
* SEE
* CoUnmarshalHresult().
*/
HRESULT WINAPI
CoMarshalHresult(LPSTREAM pStm, HRESULT hresult)
{
return IStream_Write(pStm, &hresult, sizeof(hresult), NULL);
}
/***********************************************************************
* CoUnmarshalHresult [OLE32.@]
*
* Unmarshals an HRESULT value from a stream.
*
* PARAMS
* pStm [I] Stream that hresult will be unmarshaled from.
* phresult [I] Pointer to HRESULT where the value will be unmarshaled to.
*
* RETURNS
* Success: S_OK
* Failure: A COM error code
*
* SEE
* CoMarshalHresult().
*/
HRESULT WINAPI
CoUnmarshalHresult(LPSTREAM pStm, HRESULT * phresult)
{
return IStream_Read(pStm, phresult, sizeof(*phresult), NULL);
}

107
reactos/lib/ole32/ole2impl.c
View file

@ -195,3 +195,110 @@ HRESULT WINAPI OleCreateFromData(LPDATAOBJECT pSrcDataObject, REFIID riid,
return DV_E_FORMATETC; return DV_E_FORMATETC;
} }
/******************************************************************************
* OleDuplicateData [OLE32.@]
*
* Duplicates clipboard data.
*
* PARAMS
* hSrc [I] Handle of the source clipboard data.
* cfFormat [I] The clipboard format of hSrc.
* uiFlags [I] Flags to pass to GlobalAlloc.
*
* RETURNS
* Success: handle to the duplicated data.
* Failure: NULL.
*/
HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
UINT uiFlags)
{
HANDLE hDst = NULL;
TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
if (!uiFlags) uiFlags = GMEM_MOVEABLE;
switch (cfFormat)
{
case CF_ENHMETAFILE:
hDst = CopyEnhMetaFileW(hSrc, NULL);
break;
case CF_METAFILEPICT:
hDst = CopyMetaFileW(hSrc, NULL);
break;
case CF_PALETTE:
{
LOGPALETTE * logpalette;
UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
if (!nEntries) return NULL;
logpalette = HeapAlloc(GetProcessHeap(), 0,
FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
if (!logpalette) return NULL;
if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
{
HeapFree(GetProcessHeap(), 0, logpalette);
return NULL;
}
logpalette->palVersion = 0x300;
logpalette->palNumEntries = (WORD)nEntries;
hDst = CreatePalette(logpalette);
HeapFree(GetProcessHeap(), 0, logpalette);
break;
}
case CF_BITMAP:
{
LONG size;
BITMAP bm;
if (!GetObjectW(hSrc, sizeof(bm), &bm))
return NULL;
size = GetBitmapBits(hSrc, 0, NULL);
if (!size) return NULL;
bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
if (!bm.bmBits) return NULL;
if (!GetBitmapBits(hSrc, size, bm.bmBits))
return NULL;
hDst = CreateBitmapIndirect(&bm);
HeapFree(GetProcessHeap(), 0, bm.bmBits);
break;
}
default:
{
SIZE_T size = GlobalSize(hSrc);
LPVOID pvSrc = NULL;
LPVOID pvDst = NULL;
/* allocate space for object */
if (!size) return NULL;
hDst = GlobalAlloc(uiFlags, size);
if (!hDst) return NULL;
/* lock pointers */
pvSrc = GlobalLock(hSrc);
if (!pvSrc)
{
GlobalFree(hDst);
return NULL;
}
pvDst = GlobalLock(hDst);
if (!pvDst)
{
GlobalUnlock(hSrc);
GlobalFree(hDst);
return NULL;
}
/* copy data */
memcpy(pvDst, pvSrc, size);
/* cleanup */
GlobalUnlock(hDst);
GlobalUnlock(hSrc);
}
}
TRACE("returning %p\n", hDst);
return hDst;
}

12
reactos/lib/ole32/ole2stubs.c
View file

@ -43,18 +43,6 @@ HRESULT WINAPI OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid,
return E_NOTIMPL; return E_NOTIMPL;
} }
/******************************************************************************
* OleDuplicateData [OLE32.@]
*/
HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
UINT uiFlags)
{
FIXME("(%p,%x,%x), stub!\n", hSrc, cfFormat, uiFlags);
return NULL;
}
/****************************************************************************** /******************************************************************************
* SetConvertStg [OLE32.@] * SetConvertStg [OLE32.@]
*/ */

8
reactos/lib/ole32/ole32.spec
View file

@ -5,7 +5,7 @@
@ stub CLIPFORMAT_UserUnmarshal @ stub CLIPFORMAT_UserUnmarshal
@ stdcall CLSIDFromProgID(wstr ptr) @ stdcall CLSIDFromProgID(wstr ptr)
@ stdcall CLSIDFromString(wstr ptr) @ stdcall CLSIDFromString(wstr ptr)
@ stub CoAddRefServerProcess @ stdcall CoAddRefServerProcess()
@ stdcall CoBuildVersion() @ stdcall CoBuildVersion()
@ stub CoCopyProxy #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED @ stub CoCopyProxy #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED
@ stdcall CoCreateFreeThreadedMarshaler(ptr ptr) @ stdcall CoCreateFreeThreadedMarshaler(ptr ptr)
@ -44,7 +44,7 @@
@ stdcall CoIsOle1Class (ptr) @ stdcall CoIsOle1Class (ptr)
@ stdcall CoLoadLibrary(wstr long) @ stdcall CoLoadLibrary(wstr long)
@ stdcall CoLockObjectExternal(ptr long long) @ stdcall CoLockObjectExternal(ptr long long)
@ stub CoMarshalHresult #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED @ stdcall CoMarshalHresult(ptr long)
@ stdcall CoMarshalInterThreadInterfaceInStream(ptr ptr ptr) @ stdcall CoMarshalInterThreadInterfaceInStream(ptr ptr ptr)
@ stdcall CoMarshalInterface(ptr ptr ptr long ptr long) @ stdcall CoMarshalInterface(ptr ptr ptr long ptr long)
@ stub CoQueryAuthenticationServices @ stub CoQueryAuthenticationServices
@ -58,7 +58,7 @@
@ stub CoRegisterPSClsid #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED @ stub CoRegisterPSClsid #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED
@ stub CoRegisterSurrogate @ stub CoRegisterSurrogate
@ stdcall CoReleaseMarshalData(ptr) @ stdcall CoReleaseMarshalData(ptr)
@ stub CoReleaseServerProcess #@ stdcall () return 0,ERR_NOTIMPLEMENTED @ stdcall CoReleaseServerProcess()
@ stdcall CoResumeClassObjects() @ stdcall CoResumeClassObjects()
@ stub CoRevertToSelf #@ stdcall () return 0,ERR_NOTIMPLEMENTED @ stub CoRevertToSelf #@ stdcall () return 0,ERR_NOTIMPLEMENTED
@ stdcall CoRevokeClassObject(long) @ stdcall CoRevokeClassObject(long)
@ -73,7 +73,7 @@
@ stdcall CoTreatAsClass(ptr ptr) @ stdcall CoTreatAsClass(ptr ptr)
@ stdcall CoUninitialize() @ stdcall CoUninitialize()
@ stub CoUnloadingWOW @ stub CoUnloadingWOW
@ stub CoUnmarshalHresult #@ stdcall (ptr ptr) return 0,ERR_NOTIMPLEMENTED @ stdcall CoUnmarshalHresult(ptr ptr)
@ stdcall CoUnmarshalInterface(ptr ptr ptr) @ stdcall CoUnmarshalInterface(ptr ptr ptr)
@ stdcall CreateAntiMoniker(ptr) @ stdcall CreateAntiMoniker(ptr)
@ stdcall CreateBindCtx(long ptr) @ stdcall CreateBindCtx(long ptr)

2
reactos/lib/ole32/storage.c
View file

@ -1125,7 +1125,7 @@ HRESULT WINAPI IStream16_fnWrite(
ULONG *byteswritten=pcbWrite,xxwritten; ULONG *byteswritten=pcbWrite,xxwritten;
int oldsize,newsize,i,curoffset=0,lastblocknr,blocknr,cc; int oldsize,newsize,i,curoffset=0,lastblocknr,blocknr,cc;
HANDLE hf = This->hf; HANDLE hf = This->hf;
LPBYTE pbv = (LPBYTE)pv; const BYTE* pbv = (const BYTE*)pv;
if (!pcbWrite) byteswritten=&xxwritten; if (!pcbWrite) byteswritten=&xxwritten;
*byteswritten = 0; *byteswritten = 0;

22
reactos/lib/ole32/storage32.c
View file

@ -144,8 +144,8 @@ static void updatePropertyChain(
StgProperty newProperty); StgProperty newProperty);
static LONG propertyNameCmp( static LONG propertyNameCmp(
OLECHAR *newProperty, const OLECHAR *newProperty,
OLECHAR *currentProperty); const OLECHAR *currentProperty);
/*********************************************************************** /***********************************************************************
@ -1158,7 +1158,7 @@ HRESULT WINAPI StorageImpl_CreateStorage(
*/ */
hr = IStorage_OpenStorage( hr = IStorage_OpenStorage(
iface, iface,
(OLECHAR*)pwcsName, (const OLECHAR*)pwcsName,
0, 0,
grfMode, grfMode,
0, 0,
@ -1284,8 +1284,8 @@ static ULONG getFreeProperty(
* 0 when newPrpoerty == currentProperty * 0 when newPrpoerty == currentProperty
*/ */
static LONG propertyNameCmp( static LONG propertyNameCmp(
OLECHAR *newProperty, const OLECHAR *newProperty,
OLECHAR *currentProperty) const OLECHAR *currentProperty)
{ {
LONG diff = lstrlenW(newProperty) - lstrlenW(currentProperty); LONG diff = lstrlenW(newProperty) - lstrlenW(currentProperty);
@ -3962,8 +3962,8 @@ ULONG IEnumSTATSTGImpl_FindProperty(
currentProperty); currentProperty);
if ( propertyNameCmp( if ( propertyNameCmp(
(OLECHAR*)currentProperty->name, (const OLECHAR*)currentProperty->name,
(OLECHAR*)lpszPropName) == 0) (const OLECHAR*)lpszPropName) == 0)
return currentSearchNode; return currentSearchNode;
/* /*
@ -4348,7 +4348,7 @@ BOOL BlockChainStream_WriteAt(BlockChainStream* This,
ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->bigBlockSize; ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->bigBlockSize;
ULONG bytesToWrite; ULONG bytesToWrite;
ULONG blockIndex; ULONG blockIndex;
BYTE* bufferWalker; const BYTE* bufferWalker;
BYTE* bigBlockBuffer; BYTE* bigBlockBuffer;
/* /*
@ -4385,7 +4385,7 @@ BOOL BlockChainStream_WriteAt(BlockChainStream* This,
* This is OK since we don't intend to modify that buffer. * This is OK since we don't intend to modify that buffer.
*/ */
*bytesWritten = 0; *bytesWritten = 0;
bufferWalker = (BYTE*)buffer; bufferWalker = (const BYTE*)buffer;
while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) ) while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
{ {
@ -5095,7 +5095,7 @@ BOOL SmallBlockChainStream_WriteAt(
ULONG bytesToWriteInBuffer; ULONG bytesToWriteInBuffer;
ULONG blockIndex; ULONG blockIndex;
ULONG bytesWrittenFromBigBlockFile; ULONG bytesWrittenFromBigBlockFile;
BYTE* bufferWalker; const BYTE* bufferWalker;
/* /*
* This should never happen on a small block file. * This should never happen on a small block file.
@ -5121,7 +5121,7 @@ BOOL SmallBlockChainStream_WriteAt(
* This is OK since we don't intend to modify that buffer. * This is OK since we don't intend to modify that buffer.
*/ */
*bytesWritten = 0; *bytesWritten = 0;
bufferWalker = (BYTE*)buffer; bufferWalker = (const BYTE*)buffer;
while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) ) while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
{ {
/* /*

36
reactos/lib/ole32/winehq2ros.patch
View file

@ -1,26 +1,10 @@
Index: Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/ole32/Makefile.in,v
retrieving revision 1.39
diff -u -r1.39 Makefile.in
--- Makefile.in 21 Sep 2004 00:35:03 -0000 1.39
+++ Makefile.in 20 Oct 2004 09:21:24 -0000
@@ -53,7 +53,7 @@
ole2thk.spec \
storage.spec
-RC_SRCS = ole32res.rc version.rc
+RC_SRCS = ole32res.rc
RC_BINSRC = ole32res.rc
RC_BINARIES = \
drag_copy.cur \
Index: ifs.h Index: ifs.h
=================================================================== ===================================================================
RCS file: /home/wine/wine/dlls/ole32/ifs.h,v RCS file: /home/wine/wine/dlls/ole32/ifs.h,v
retrieving revision 1.13 retrieving revision 1.13
diff -u -r1.13 ifs.h diff -u -r1.13 ifs.h
--- ifs.h 5 Oct 2004 04:16:21 -0000 1.13 --- ifs.h 5 Oct 2004 04:16:21 -0000 1.13
+++ ifs.h 20 Oct 2004 09:21:25 -0000 +++ ifs.h 6 Dec 2004 10:15:06 -0000
@@ -33,8 +33,7 @@ @@ -33,8 +33,7 @@
* IMalloc16 interface * IMalloc16 interface
*/ */
@ -66,29 +50,13 @@ diff -u -r1.13 ifs.h
#define INTERFACE IStorage16 #define INTERFACE IStorage16
DECLARE_INTERFACE_(IStorage16,IUnknown) DECLARE_INTERFACE_(IStorage16,IUnknown)
Index: ole32res.rc
===================================================================
RCS file: /home/wine/wine/dlls/ole32/ole32res.rc,v
retrieving revision 1.5
diff -u -r1.5 ole32res.rc
--- ole32res.rc 3 Oct 2003 05:01:34 -0000 1.5
+++ ole32res.rc 20 Oct 2004 09:21:25 -0000
@@ -23,6 +23,8 @@
#include "winuser.h"
#include "winnls.h"
+#include "version.rc"
+
/*
* Everything that does not depend on language,
* like textless bitmaps etc, go into the
Index: oleproxy.c Index: oleproxy.c
=================================================================== ===================================================================
RCS file: /home/wine/wine/dlls/ole32/oleproxy.c,v RCS file: /home/wine/wine/dlls/ole32/oleproxy.c,v
retrieving revision 1.23 retrieving revision 1.23
diff -u -r1.23 oleproxy.c diff -u -r1.23 oleproxy.c
--- oleproxy.c 7 Oct 2004 03:06:49 -0000 1.23 --- oleproxy.c 7 Oct 2004 03:06:49 -0000 1.23
+++ oleproxy.c 20 Oct 2004 09:21:25 -0000 +++ oleproxy.c 6 Dec 2004 10:15:06 -0000
@@ -38,6 +38,7 @@ @@ -38,6 +38,7 @@
#include <stdlib.h> #include <stdlib.h>