From b54389b3ed3f77d92b72633e13241a1f69299017 Mon Sep 17 00:00:00 2001 From: Hidenori Takeshima Date: Mon, 8 Apr 2002 22:45:34 +0000 Subject: [PATCH] Added some stubs. --- dlls/Makefile.in | 3 +- dlls/urlmon/Makefile.in | 3 + dlls/urlmon/comimpl.c | 444 +++++++++++++++++++++++++++++++++++++ dlls/urlmon/comimpl.h | 171 +++++++++++++++ dlls/urlmon/moniker.c | 446 ++++++++++++++++++++++++++++++++++++++ dlls/urlmon/umon.c | 25 +-- dlls/urlmon/urlmon.spec | 80 +++---- dlls/urlmon/urlmon_main.c | 295 ++++++++++++++++++++++--- 8 files changed, 1379 insertions(+), 88 deletions(-) create mode 100644 dlls/urlmon/comimpl.c create mode 100644 dlls/urlmon/comimpl.h create mode 100644 dlls/urlmon/moniker.c diff --git a/dlls/Makefile.in b/dlls/Makefile.in index f44b2646de0..f9ea8503acd 100644 --- a/dlls/Makefile.in +++ b/dlls/Makefile.in @@ -718,7 +718,8 @@ twain/twain_32.dll$(DLLEXT): dummy user32.dll$(DLLEXT) gdi32.dll$(DLLEXT) \ url/url.dll$(DLLEXT): dummy ntdll.dll$(DLLEXT) @cd url && $(MAKE) url.dll$(DLLEXT) -urlmon/urlmon.dll$(DLLEXT): dummy ole32.dll$(DLLEXT) ntdll.dll$(DLLEXT) +urlmon/urlmon.dll$(DLLEXT): dummy ole32.dll$(DLLEXT) kernel32.dll$(DLLEXT) \ + ntdll.dll$(DLLEXT) @cd urlmon && $(MAKE) urlmon.dll$(DLLEXT) user/user32.dll$(DLLEXT): dummy gdi32.dll$(DLLEXT) advapi32.dll$(DLLEXT) \ diff --git a/dlls/urlmon/Makefile.in b/dlls/urlmon/Makefile.in index 7827f1b3de7..65c947028ef 100644 --- a/dlls/urlmon/Makefile.in +++ b/dlls/urlmon/Makefile.in @@ -3,11 +3,14 @@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = urlmon.dll +EXTRALIBS = $(LIBUUID) LDDLLFLAGS = @LDDLLFLAGS@ SYMBOLFILE = $(MODULE).tmp.o C_SRCS = \ + comimpl.c \ + moniker.c \ umon.c \ urlmon_main.c diff --git a/dlls/urlmon/comimpl.c b/dlls/urlmon/comimpl.c new file mode 100644 index 00000000000..4793dc2c2de --- /dev/null +++ b/dlls/urlmon/comimpl.c @@ -0,0 +1,444 @@ +/* + * A basic implementation for COM DLL implementor. + * + * Copyright (C) 2002 Hidenori TAKESHIMA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#include "windef.h" +#include "winerror.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "winnls.h" +#include "ole2.h" + +#include "wine/debug.h" +WINE_DEFAULT_DEBUG_CHANNEL(comimpl); + +#include "comimpl.h" + +/* + - All threading model including Apartment and Both are supported. + - Aggregation is supported. + - CoFreeUnusedLibraries() is supported. + - DisableThreadLibraryCalls() is supported. + */ + +static CRITICAL_SECTION csComImpl; +static DWORD dwComImplRef; + + +static HRESULT WINAPI +IUnknown_fnQueryInterface(IUnknown* iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(COMIMPL_IUnkImpl,iface); + size_t ofs; + DWORD dwIndex; + COMIMPL_IFDelegation* pDelegation; + HRESULT hr; + + TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj); + + if ( ppobj == NULL ) + return E_POINTER; + *ppobj = NULL; + + ofs = 0; + + if ( IsEqualGUID( &IID_IUnknown, riid ) ) + { + TRACE("IID_IUnknown - returns inner object.\n"); + } + else + { + for ( dwIndex = 0; dwIndex < This->dwEntries; dwIndex++ ) + { + if ( IsEqualGUID( This->pEntries[dwIndex].piid, riid ) ) + { + ofs = This->pEntries[dwIndex].ofsVTPtr; + break; + } + } + if ( dwIndex == This->dwEntries ) + { + hr = E_NOINTERFACE; + + /* delegation */ + pDelegation = This->pDelegationFirst; + while ( pDelegation != NULL ) + { + hr = (*pDelegation->pOnQueryInterface)( iface, riid, ppobj ); + if ( hr != E_NOINTERFACE ) + break; + pDelegation = pDelegation->pNext; + } + + if ( hr == E_NOINTERFACE ) + { + FIXME("(%p) unknown interface: %s\n",This,debugstr_guid(riid)); + } + + return hr; + } + } + + *ppobj = (LPVOID)(((char*)This) + ofs); + IUnknown_AddRef((IUnknown*)(*ppobj)); + + return S_OK; +} + +static ULONG WINAPI +IUnknown_fnAddRef(IUnknown* iface) +{ + ICOM_THIS(COMIMPL_IUnkImpl,iface); + + TRACE("(%p)->()\n",This); + + return InterlockedExchangeAdd(&(This->ref),1) + 1; +} + +static ULONG WINAPI +IUnknown_fnRelease(IUnknown* iface) +{ + ICOM_THIS(COMIMPL_IUnkImpl,iface); + LONG ref; + + TRACE("(%p)->()\n",This); + ref = InterlockedExchangeAdd(&(This->ref),-1) - 1; + if ( ref > 0 ) + return (ULONG)ref; + + This->ref ++; + if ( This->pOnFinalRelease != NULL ) + (*(This->pOnFinalRelease))(iface); + This->ref --; + + COMIMPL_FreeObj(This); + + return 0; +} + + +static ICOM_VTABLE(IUnknown) iunknown = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + /* IUnknown fields */ + IUnknown_fnQueryInterface, + IUnknown_fnAddRef, + IUnknown_fnRelease, +}; + + +void COMIMPL_IUnkInit( COMIMPL_IUnkImpl* pImpl, IUnknown* punkOuter ) +{ + TRACE("(%p)\n",pImpl); + + ICOM_VTBL(pImpl) = &iunknown; + pImpl->pEntries = NULL; + pImpl->dwEntries = 0; + pImpl->pDelegationFirst = NULL; + pImpl->pOnFinalRelease = NULL; + pImpl->ref = 1; + pImpl->punkControl = (IUnknown*)pImpl; + + /* for implementing aggregation. */ + if ( punkOuter != NULL ) + pImpl->punkControl = punkOuter; +} + +void COMIMPL_IUnkAddDelegationHandler( + COMIMPL_IUnkImpl* pImpl, COMIMPL_IFDelegation* pDelegation ) +{ + pDelegation->pNext = pImpl->pDelegationFirst; + pImpl->pDelegationFirst = pDelegation; +} + + + +/************************************************************************/ + + +static HRESULT WINAPI +IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj); +static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface); +static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface); +static HRESULT WINAPI IClassFactory_fnCreateInstance(LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj); +static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock); + +static ICOM_VTABLE(IClassFactory) iclassfact = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IClassFactory_fnQueryInterface, + IClassFactory_fnAddRef, + IClassFactory_fnRelease, + IClassFactory_fnCreateInstance, + IClassFactory_fnLockServer +}; + +typedef struct +{ + /* IUnknown fields */ + ICOM_VFIELD(IClassFactory); + LONG ref; + /* IClassFactory fields */ + const COMIMPL_CLASSENTRY* pEntry; +} IClassFactoryImpl; + + +static HRESULT WINAPI +IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IClassFactoryImpl,iface); + + TRACE("(%p)->(%p,%p)\n",This,riid,ppobj); + if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) || + ( IsEqualGUID( &IID_IClassFactory, riid ) ) ) + { + *ppobj = iface; + IClassFactory_AddRef(iface); + return S_OK; + } + + return E_NOINTERFACE; +} + +static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface) +{ + ICOM_THIS(IClassFactoryImpl,iface); + + TRACE("(%p)->()\n",This); + + return InterlockedExchangeAdd(&(This->ref),1) + 1; +} + +static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface) +{ + ICOM_THIS(IClassFactoryImpl,iface); + LONG ref; + + TRACE("(%p)->()\n",This); + ref = InterlockedExchangeAdd(&(This->ref),-1) - 1; + if ( ref > 0 ) + return (ULONG)ref; + + COMIMPL_FreeObj(This); + return 0; +} + +static HRESULT WINAPI IClassFactory_fnCreateInstance(LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IClassFactoryImpl,iface); + HRESULT hr; + IUnknown* punk; + + TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj); + + if ( ppobj == NULL ) + return E_POINTER; + if ( pOuter != NULL && !IsEqualGUID( riid, &IID_IUnknown ) ) + return CLASS_E_NOAGGREGATION; + + *ppobj = NULL; + + hr = (*This->pEntry->pCreateIUnk)(pOuter,(void**)&punk); + if ( hr != S_OK ) + return hr; + + hr = IUnknown_QueryInterface(punk,riid,ppobj); + IUnknown_Release(punk); + + return hr; +} + +static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock) +{ + ICOM_THIS(IClassFactoryImpl,iface); + HRESULT hr; + + TRACE("(%p)->(%d)\n",This,dolock); + if (dolock) + hr = IClassFactory_AddRef(iface); + else + hr = IClassFactory_Release(iface); + + return hr; +} + + + +static HRESULT IClassFactory_Alloc( const CLSID* pclsid, void** ppobj ) +{ + const COMIMPL_CLASSENTRY* pEntry; + IClassFactoryImpl* pImpl; + + TRACE( "(%s,%p)\n", debugstr_guid(pclsid), ppobj ); + + pEntry = COMIMPL_ClassList; + while ( pEntry->pclsid != NULL ) + { + if ( IsEqualGUID( pclsid, pEntry->pclsid ) ) + goto found; + pEntry ++; + } + + return CLASS_E_CLASSNOTAVAILABLE; +found: + pImpl = (IClassFactoryImpl*)COMIMPL_AllocObj( sizeof(IClassFactoryImpl) ); + if ( pImpl == NULL ) + return E_OUTOFMEMORY; + + TRACE( "allocated successfully.\n" ); + + ICOM_VTBL(pImpl) = &iclassfact; + pImpl->ref = 1; + pImpl->pEntry = pEntry; + + *ppobj = (void*)pImpl; + return S_OK; +} + + + + +/*********************************************************************** + * COMIMPL_InitProcess (internal) + */ +static BOOL COMIMPL_InitProcess( HINSTANCE hInstDLL ) +{ + TRACE("()\n"); + + dwComImplRef = 0; + InitializeCriticalSection( &csComImpl ); + +#ifndef COMIMPL_PERTHREAD_INIT + DisableThreadLibraryCalls((HMODULE)hInstDLL); +#endif /* COMIMPL_PERTHREAD_INIT */ + + return TRUE; +} + +/*********************************************************************** + * COMIMPL_UninitProcess (internal) + */ +static void COMIMPL_UninitProcess( HINSTANCE hInstDLL ) +{ + CHAR szThisDLL[ MAX_PATH ]; + + TRACE("()\n"); + + if ( dwComImplRef != 0 ) + { + szThisDLL[0] = '\0'; + if ( !GetModuleFileNameA( (HMODULE)hInstDLL, szThisDLL, MAX_PATH ) ) + szThisDLL[0] = '\0'; + ERR( "you must release some objects allocated from %s.\n", szThisDLL ); + } + DeleteCriticalSection( &csComImpl ); +} + + +/*********************************************************************** + * COMIMPL_DllMain + */ +BOOL WINAPI COMIMPL_DllMain( + HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved ) +{ + TRACE("(%08x,%08lx,%p)\n",hInstDLL,fdwReason,lpvReserved); + + switch ( fdwReason ) + { + case DLL_PROCESS_ATTACH: + if ( !COMIMPL_InitProcess( hInstDLL ) ) + return FALSE; + break; + case DLL_PROCESS_DETACH: + COMIMPL_UninitProcess( hInstDLL ); + break; + case DLL_THREAD_ATTACH: + break; + case DLL_THREAD_DETACH: + break; + } + + return TRUE; +} + +/*********************************************************************** + * COMIMPL_DllGetClassObject + */ +HRESULT WINAPI COMIMPL_DllGetClassObject( + const CLSID* pclsid,const IID* piid,void** ppv) +{ + *ppv = NULL; + if ( IsEqualGUID( &IID_IUnknown, piid ) || + IsEqualGUID( &IID_IClassFactory, piid ) ) + { + return IClassFactory_Alloc( pclsid, ppv ); + } + + return CLASS_E_CLASSNOTAVAILABLE; +} + +/*********************************************************************** + * COMIMPL_DllCanUnloadNow + * + * RETURNS + * Success: S_OK + * Failure: S_FALSE + */ +HRESULT WINAPI COMIMPL_DllCanUnloadNow(void) +{ + HRESULT hr; + + EnterCriticalSection( &csComImpl ); + hr = ( dwComImplRef == 0 ) ? S_OK : S_FALSE; + LeaveCriticalSection( &csComImpl ); + + return hr; +} + +/*********************************************************************** + * COMIMPL_AllocObj + */ +void* COMIMPL_AllocObj( DWORD dwSize ) +{ + void* pv; + + EnterCriticalSection( &csComImpl ); + dwComImplRef ++; + pv = HeapAlloc( COMIMPL_hHeap, 0, dwSize ); + if ( pv == NULL ) + dwComImplRef --; + LeaveCriticalSection( &csComImpl ); + + return pv; +} + +/*********************************************************************** + * COMIMPL_FreeObj + */ +void COMIMPL_FreeObj( void* pobj ) +{ + EnterCriticalSection( &csComImpl ); + HeapFree( COMIMPL_hHeap, 0, pobj ); + dwComImplRef --; + LeaveCriticalSection( &csComImpl ); +} + diff --git a/dlls/urlmon/comimpl.h b/dlls/urlmon/comimpl.h new file mode 100644 index 00000000000..443906e32f9 --- /dev/null +++ b/dlls/urlmon/comimpl.h @@ -0,0 +1,171 @@ +/* + * A basic implementation for COM DLL implementor. + * + * Copyright (C) 2002 Hidenori TAKESHIMA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef WINE_COMIMPL_H +#define WINE_COMIMPL_H + +/* + This code provides a basic thread-safe COM implementation + including aggregation(and an IClassFactory implementation). + This code is based on my quartz code. + + The usage of this library is: + + 1) copy comimpl.h and comimpl.c. + 2) implement the global class entries 'COMIMPL_ClassList'. + 3) export COMIMPL_DllMain, COMIMPL_DllGetClassObject and + COMIMPL_DllCanUnloadNow. + 4) add 'comimpl' to your debug channels. + 5) implement your IUnknown as a thunk to call + COMIMPL_IUnkImpl.punk methods. + 6) provide pointers of vtables in constructor. + 7) optionally, you can edit comimpl.h and/or comimpl.c. + + A sample allocator of class COne that supports + two interface IOne and ITwo is: + + const COMIMPL_CLASSENTRY COMIMPL_ClassList[] = + { + { &CLSID_COne, &COne_AllocObj }, + { NULL, NULL } << the last entry must be NULL >> + }; + + typedef struct COne + { + COMIMPL_IUnkImpl vfunk; << must be the first member of this struct >> + struct { ICOM_VFIELD(IOne); } vfone; + struct { ICOM_VFIELD(ITwo); } vftwo; + << ... >> + } COne; + #define COne_THIS(iface,member) COne* This = ((COne*)(((char*)iface)-offsetof(COne,member))) + + static COMIMPL_IFEntry IFEntries[] = + { + << all supported interfaces >> + { &IID_IOne, offsetof(COne,vfone)-offsetof(COne,vfunk) }, + { &IID_ITwo, offsetof(COne,vftwo)-offsetof(COne,vfunk) }, + }; + + static void COne_Destructor(IUnknown* iface) + { + COne_THIS(iface,vfunk); + + << ... implement destructor ... >> + } + + HRESULT COne_AllocObj(IUnknown* punkOuter,void** ppobj) + { + COne* This; + + This = (COne*)COMIMPL_AllocObj( sizeof(COne) ); + if ( This == NULL ) return E_OUTOFMEMORY; + COMIMPL_IUnkInit( &This->vfunk, punkOuter ); + This->vfunk.pEntries = IFEntries; + This->vfunk.dwEntries = sizeof(IFEntries)/sizeof(IFEntries[0]); + This->vfunk.pOnFinalRelease = COne_Destructor; + + ICOM_VTBL(&This->vfone) = &ione; + ICOM_VTBL(&This->vftwo) = &itwo; + + << ... implement constructor ... >> + << if error occurs in constructing, you can call simply + punk::Release() and return HRESULT. >> + + *ppobj = (void*)(&This->vfunk); + + return S_OK; << return S_OK if succeeded >> + } + */ + +/* if per-thread initialization is needed, uncomment the following line */ +/*#define COMIMPL_PERTHREAD_INIT*/ +/* If an own heap is needed, customize the following line */ +#define COMIMPL_hHeap GetProcessHeap() + + +typedef HRESULT (*COMIMPL_pCreateIUnknown)(IUnknown* punkOuter,void** ppobj); +typedef void (*COMIMPL_pOnFinalRelease)(IUnknown* punkInner); + +typedef struct COMIMPL_IFEntry COMIMPL_IFEntry; +typedef struct COMIMPL_IFDelegation COMIMPL_IFDelegation; +typedef struct COMIMPL_IUnkImpl COMIMPL_IUnkImpl; + +struct COMIMPL_IFEntry +{ + const IID* piid; /* interface ID. */ + size_t ofsVTPtr; /* offset from IUnknown. */ +}; + +struct COMIMPL_IFDelegation +{ + struct COMIMPL_IFDelegation* pNext; + HRESULT (*pOnQueryInterface)( + IUnknown* punk, const IID* piid, void** ppobj ); +}; + +/* COMIMPL_IUnkimpl must be aligned for InterlockedExchangeAdd. */ +#include + +struct COMIMPL_IUnkImpl +{ + /* pointer of IUnknown interface. */ + ICOM_VFIELD(IUnknown); + + /* array of supported IIDs and offsets. */ + const COMIMPL_IFEntry* pEntries; + DWORD dwEntries; + /* list of delegation handlers. */ + COMIMPL_IFDelegation* pDelegationFirst; + /* called on final release. */ + COMIMPL_pOnFinalRelease pOnFinalRelease; + + /* IUnknown fields. */ + LONG ref; + IUnknown* punkControl; +}; + +#include + +typedef struct COMIMPL_CLASSENTRY +{ + const CLSID* pclsid; + COMIMPL_pCreateIUnknown pCreateIUnk; +} COMIMPL_CLASSENTRY; + + +extern const COMIMPL_CLASSENTRY COMIMPL_ClassList[]; /* must be provided */ + +void COMIMPL_IUnkInit( COMIMPL_IUnkImpl* pImpl, IUnknown* punkOuter ); +void COMIMPL_IUnkAddDelegationHandler( + COMIMPL_IUnkImpl* pImpl, COMIMPL_IFDelegation* pDelegation ); + +BOOL WINAPI COMIMPL_DllMain( + HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved ); +HRESULT WINAPI COMIMPL_DllGetClassObject( + const CLSID* pclsid,const IID* piid,void** ppv); +HRESULT WINAPI COMIMPL_DllCanUnloadNow(void); + +void* COMIMPL_AllocObj( DWORD dwSize ); +void COMIMPL_FreeObj( void* pobj ); /* for internal use only. */ + + + + +#endif /* WINE_COMIMPL_H */ diff --git a/dlls/urlmon/moniker.c b/dlls/urlmon/moniker.c new file mode 100644 index 00000000000..6a68b30ba18 --- /dev/null +++ b/dlls/urlmon/moniker.c @@ -0,0 +1,446 @@ +/* + * URL Moniker + * + * FIXME - stub + * + * Copyright (C) 2002 Hidenori TAKESHIMA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "config.h" + +#include "windef.h" +#include "winerror.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" + +#include "wine/debug.h" +WINE_DEFAULT_DEBUG_CHANNEL(comimpl); + +#include "comimpl.h" + + +/* + * NOTE: + * URL Moniker supports the following protocols(at least): + * + * CLSID_HttpProtocol + * CLSID_FtpProtocol + * CLSID_GopherProtocol + * CLSID_HttpSProtocol + * CLSID_FileProtocol + * + */ + +typedef struct CURLMonikerImpl +{ + COMIMPL_IUnkImpl vfunk; + struct { ICOM_VFIELD(IMoniker); } moniker; + struct { ICOM_VFIELD(IROTData); } rotd; + + /* IMoniker stuffs */ +} CURLMonikerImpl; + +#define CURLMonikerImpl_THIS(iface,member) CURLMonikerImpl* This = ((CURLMonikerImpl*)(((char*)iface)-offsetof(CURLMonikerImpl,member))) + + +static HRESULT WINAPI +IMoniker_fnQueryInterface(IMoniker* iface,REFIID riid,void** ppobj) +{ + CURLMonikerImpl_THIS(iface,moniker); + + TRACE("(%p)->()\n",This); + + return IUnknown_QueryInterface(This->vfunk.punkControl,riid,ppobj); +} + +static ULONG WINAPI +IMoniker_fnAddRef(IMoniker* iface) +{ + CURLMonikerImpl_THIS(iface,moniker); + + TRACE("(%p)->()\n",This); + + return IUnknown_AddRef(This->vfunk.punkControl); +} + +static ULONG WINAPI +IMoniker_fnRelease(IMoniker* iface) +{ + CURLMonikerImpl_THIS(iface,moniker); + + TRACE("(%p)->()\n",This); + + return IUnknown_Release(This->vfunk.punkControl); +} + +static HRESULT WINAPI IMoniker_fnGetClassID(IMoniker* iface, CLSID *pClassID) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub\n",This); + + return E_NOTIMPL; +#if 0 + TRACE("(%p)->()\n",This); + + if ( pClassID == NULL ) + return E_POINTER; + memcpy( pClassID, &CLSID_StdURLMoniker, sizeof(CLSID) ); + + return NOERROR; +#endif +} + +static HRESULT WINAPI IMoniker_fnIsDirty(IMoniker* iface) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnLoad(IMoniker* iface, IStream* pStm) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnSave(IMoniker* iface, IStream* pStm, BOOL fClearDirty) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnGetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnBindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->(%p,%p,%s,%p)\n",This, + pbc,pmkToLeft,debugstr_guid(riid),ppvResult); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnBindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->(%p,%p,%s,%p)\n",This, + pbc,pmkToLeft,debugstr_guid(riid),ppvResult); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnReduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnEnum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnIsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnHash(IMoniker* iface,DWORD* pdwHash) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnIsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnGetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pCompositeTime) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnInverse(IMoniker* iface,IMoniker** ppmk) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnCommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnRelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnGetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI IMoniker_fnIsSystemMoniker(IMoniker* iface,DWORD* pdwMksys) +{ + CURLMonikerImpl_THIS(iface,moniker); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + + +static ICOM_VTABLE(IMoniker) imoniker = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + /* IUnknown fields */ + IMoniker_fnQueryInterface, + IMoniker_fnAddRef, + IMoniker_fnRelease, + /* IPersist fields */ + IMoniker_fnGetClassID, + /* IPersistStream fields */ + IMoniker_fnIsDirty, + IMoniker_fnLoad, + IMoniker_fnSave, + IMoniker_fnGetSizeMax, + /* IMoniker fields */ + IMoniker_fnBindToObject, + IMoniker_fnBindToStorage, + IMoniker_fnReduce, + IMoniker_fnComposeWith, + IMoniker_fnEnum, + IMoniker_fnIsEqual, + IMoniker_fnHash, + IMoniker_fnIsRunning, + IMoniker_fnGetTimeOfLastChange, + IMoniker_fnInverse, + IMoniker_fnCommonPrefixWith, + IMoniker_fnRelativePathTo, + IMoniker_fnGetDisplayName, + IMoniker_fnParseDisplayName, + IMoniker_fnIsSystemMoniker, +}; + + + + +static HRESULT WINAPI +IROTData_fnQueryInterface(IROTData* iface,REFIID riid,void** ppobj) +{ + CURLMonikerImpl_THIS(iface,rotd); + + TRACE("(%p)->()\n",This); + + return IUnknown_QueryInterface(This->vfunk.punkControl,riid,ppobj); +} + +static ULONG WINAPI +IROTData_fnAddRef(IROTData* iface) +{ + CURLMonikerImpl_THIS(iface,rotd); + + TRACE("(%p)->()\n",This); + + return IUnknown_AddRef(This->vfunk.punkControl); +} + +static ULONG WINAPI +IROTData_fnRelease(IROTData* iface) +{ + CURLMonikerImpl_THIS(iface,rotd); + + TRACE("(%p)->()\n",This); + + return IUnknown_Release(This->vfunk.punkControl); +} + +static HRESULT WINAPI IROTData_fnGetComparisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData) +{ + CURLMonikerImpl_THIS(iface,rotd); + + FIXME("(%p)->() stub!\n",This); + + return E_NOTIMPL; +} + + + +static ICOM_VTABLE(IROTData) irotdata = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + /* IUnknown fields */ + IROTData_fnQueryInterface, + IROTData_fnAddRef, + IROTData_fnRelease, + /* IROTData fields */ + IROTData_fnGetComparisonData, +}; + + + +static COMIMPL_IFEntry IFEntries[] = +{ + { &IID_IPersist, offsetof(CURLMonikerImpl,moniker)-offsetof(CURLMonikerImpl,vfunk) }, + { &IID_IPersistStream, offsetof(CURLMonikerImpl,moniker)-offsetof(CURLMonikerImpl,vfunk) }, + { &IID_IMoniker, offsetof(CURLMonikerImpl,moniker)-offsetof(CURLMonikerImpl,vfunk) }, + { &IID_IROTData, offsetof(CURLMonikerImpl,rotd)-offsetof(CURLMonikerImpl,vfunk) }, +}; + +static void CURLMonikerImpl_Destructor(IUnknown* iface) +{ + CURLMonikerImpl_THIS(iface,vfunk); + + TRACE("(%p)\n",This); +} + +static HRESULT CURLMonikerImpl_AllocObj( + void** ppobj, + IMoniker* pmonContext, + LPCWSTR lpwszURL ) +{ + CURLMonikerImpl* This; + + This = (CURLMonikerImpl*)COMIMPL_AllocObj( sizeof(CURLMonikerImpl) ); + if ( This == NULL ) return E_OUTOFMEMORY; + COMIMPL_IUnkInit( &This->vfunk, NULL ); + This->vfunk.pEntries = IFEntries; + This->vfunk.dwEntries = sizeof(IFEntries)/sizeof(IFEntries[0]); + This->vfunk.pOnFinalRelease = CURLMonikerImpl_Destructor; + + ICOM_VTBL(&This->moniker) = &imoniker; + ICOM_VTBL(&This->rotd) = &irotdata; + + *ppobj = (void*)(&This->vfunk); + + return S_OK; +} + + +/*********************************************************************** + * + * CreateURLMoniker (URLMON.@) + * + * S_OK success + * E_OUTOFMEMORY out of memory + * MK_E_SYNTAX not a valid url + * + */ + +HRESULT WINAPI CreateURLMoniker( + IMoniker* pmonContext, + LPCWSTR lpwszURL, + IMoniker** ppmon ) +{ + HRESULT hr; + IUnknown* punk = NULL; + + FIXME("(%p,%s,%p)\n",pmonContext,debugstr_w(lpwszURL),ppmon); + + if ( ppmon == NULL ) + return E_POINTER; + *ppmon = NULL; + + hr = CURLMonikerImpl_AllocObj( (void**)&punk, pmonContext, lpwszURL ); + if ( FAILED(hr) ) + return hr; + + hr = IUnknown_QueryInterface( punk, &IID_IMoniker, (void**)ppmon ); + IUnknown_Release( punk ); + + return hr; +} + diff --git a/dlls/urlmon/umon.c b/dlls/urlmon/umon.c index 3eb20fcce02..3f31b5073ff 100644 --- a/dlls/urlmon/umon.c +++ b/dlls/urlmon/umon.c @@ -47,27 +47,6 @@ HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, } -/*********************************************************************** - * CreateURLMoniker (URLMON.@) - * - * Create a url moniker - * - * RETURNS - * S_OK success - * E_OUTOFMEMORY out of memory - * MK_E_SYNTAX not a valid url - * - */ -HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk) -{ - TRACE("\n"); - - if (NULL != pmkContext) - FIXME("Non-null pmkContext not implemented\n"); - - return CreateFileMoniker(szURL, ppmk); -} - /*********************************************************************** * RegisterBindStatusCallback (URLMON.@) * @@ -146,7 +125,7 @@ HRESULT WINAPI RevokeBindStatusCallback( */ HRESULT WINAPI Extract(DWORD Param1, DWORD Param2) { - TRACE("%lx %lx\n", Param1, Param2); + FIXME("%lx %lx\n", Param1, Param2); - return S_OK; + return E_NOTIMPL; } diff --git a/dlls/urlmon/urlmon.spec b/dlls/urlmon/urlmon.spec index f40bb667e0a..f05d06b8210 100644 --- a/dlls/urlmon/urlmon.spec +++ b/dlls/urlmon/urlmon.spec @@ -1,10 +1,12 @@ name urlmon type win32 +init COMIMPL_DllMain import ole32.dll +import kernel32.dll import ntdll.dll -debug_channels (urlmon win32) +debug_channels (comimpl urlmon) 1 stub CDLGetLongPathNameA 2 stub CDLGetLongPathNameW @@ -26,60 +28,60 @@ debug_channels (urlmon win32) @ stub CopyStgMedium @ stub CreateAsyncBindCtx @ stdcall CreateAsyncBindCtxEx(ptr long ptr ptr ptr long) CreateAsyncBindCtxEx -@ stub CreateFormatEnumerator +@ stdcall CreateFormatEnumerator(long ptr ptr) CreateFormatEnumerator @ stdcall CreateURLMoniker(ptr str ptr) CreateURLMoniker -@ stdcall DllCanUnloadNow() URLMON_DllCanUnloadNow -@ stdcall DllGetClassObject(ptr ptr ptr) URLMON_DllGetClassObject +@ stdcall DllCanUnloadNow() COMIMPL_DllCanUnloadNow +@ stdcall DllGetClassObject(ptr ptr ptr) COMIMPL_DllGetClassObject @ stdcall DllInstall(long ptr) URLMON_DllInstall @ stdcall DllRegisterServer() URLMON_DllRegisterServer @ stdcall DllRegisterServerEx() URLMON_DllRegisterServerEx @ stdcall DllUnregisterServer() URLMON_DllUnregisterServer @ stdcall Extract(long long) Extract @ stub FaultInIEFeature -@ stub FindMediaType -@ stub FindMediaTypeClass -@ stub FindMimeFromData -@ stub GetClassFileOrMime -@ stub GetClassURL +@ stdcall FindMediaType(str ptr) FindMediaType +@ stdcall FindMediaTypeClass(ptr str ptr long) FindMediaTypeClass +@ stdcall FindMimeFromData(ptr wstr ptr long wstr long ptr long) FindMimeFromData +@ stdcall GetClassFileOrMime(ptr wstr ptr long wstr long ptr) GetClassFileOrMime +@ stdcall GetClassURL(wstr ptr) GetClassURL @ stub GetComponentIDFromCLSSPEC @ stub GetMarkOfTheWeb -@ stub GetSoftwareUpdateInfo -@ stub HlinkGoBack -@ stub HlinkGoForward -@ stub HlinkNavigateMoniker -@ stub HlinkNavigateString -@ stub HlinkSimpleNavigateToMoniker -@ stub HlinkSimpleNavigateToString -@ stub IsAsyncMoniker -@ stub IsLoggingEnabledA -@ stub IsLoggingEnabledW -@ stub IsValidURL -@ stub MkParseDisplayNameEx +@ stdcall GetSoftwareUpdateInfo(wstr ptr) GetSoftwareUpdateInfo +@ stdcall HlinkGoBack(ptr) HlinkGoBack +@ stdcall HlinkGoForward(ptr) HlinkGoForward +@ stdcall HlinkNavigateMoniker(ptr ptr) HlinkNavigateMoniker +@ stdcall HlinkNavigateString(ptr wstr) HlinkNavigateString +@ stdcall HlinkSimpleNavigateToMoniker(ptr wstr wstr ptr ptr ptr long long) HlinkSimpleNavigateToMoniker +@ stdcall HlinkSimpleNavigateToString(wstr wstr wstr ptr ptr ptr long long) HlinkSimpleNavigateToString +@ stdcall IsAsyncMoniker(ptr) IsAsyncMoniker +@ stdcall IsLoggingEnabledA(str) IsLoggingEnabledA +@ stdcall IsLoggingEnabledW(wstr) IsLoggingEnabledW +@ stdcall IsValidURL(ptr wstr long) IsValidURL +@ stdcall MkParseDisplayNameEx(ptr wstr ptr ptr) MkParseDisplayNameEx @ stdcall ObtainUserAgentString(long str ptr) ObtainUserAgentString @ stub PrivateCoInstall @ stdcall RegisterBindStatusCallback(ptr ptr ptr long) RegisterBindStatusCallback -@ stub RegisterFormatEnumerator -@ stub RegisterMediaTypeClass -@ stub RegisterMediaTypes -@ stub ReleaseBindInfo +@ stdcall RegisterFormatEnumerator(ptr ptr long) RegisterFormatEnumerator +@ stdcall RegisterMediaTypeClass(ptr long ptr ptr long) RegisterMediaTypeClass +@ stdcall RegisterMediaTypes(long ptr ptr) RegisterMediaTypes +@ stdcall ReleaseBindInfo(ptr) ReleaseBindInfo @ stdcall RevokeBindStatusCallback(ptr ptr) RevokeBindStatusCallback -@ stub RevokeFormatEnumerator -@ stub SetSoftwareUpdateAdvertisementState +@ stdcall RevokeFormatEnumerator(ptr ptr) RevokeFormatEnumerator +@ stdcall SetSoftwareUpdateAdvertisementState(wstr long long long) SetSoftwareUpdateAdvertisementState @ stub URLDownloadA -@ stub URLDownloadToCacheFileA -@ stub URLDownloadToCacheFileW -@ stub URLDownloadToFileA -@ stub URLDownloadToFileW +@ stdcall URLDownloadToCacheFileA(ptr str ptr long long ptr) URLDownloadToCacheFileA +@ stdcall URLDownloadToCacheFileW(ptr wstr ptr long long ptr) URLDownloadToCacheFileW +@ stdcall URLDownloadToFileA(ptr str str long ptr) URLDownloadToFileA +@ stdcall URLDownloadToFileW(ptr wstr wstr long ptr) URLDownloadToFileW @ stub URLDownloadW -@ stub URLOpenBlockingStreamA -@ stub URLOpenBlockingStreamW -@ stub URLOpenPullStreamA -@ stub URLOpenPullStreamW -@ stub URLOpenStreamA -@ stub URLOpenStreamW +@ stdcall URLOpenBlockingStreamA(ptr str ptr long ptr) URLOpenBlockingStreamA +@ stdcall URLOpenBlockingStreamW(ptr wstr ptr long ptr) URLOpenBlockingStreamW +@ stdcall URLOpenPullStreamA(ptr str long ptr) URLOpenPullStreamA +@ stdcall URLOpenPullStreamW(ptr wstr long ptr) URLOpenPullStreamW +@ stdcall URLOpenStreamA(ptr str long ptr) URLOpenStreamA +@ stdcall URLOpenStreamW(ptr wstr long ptr) URLOpenStreamW @ stub UrlMkBuildVersion -@ stub UrlMkGetSessionOption +@ stdcall UrlMkGetSessionOption(long ptr long ptr long) UrlMkGetSessionOption @ stdcall UrlMkSetSessionOption(long ptr long long) UrlMkSetSessionOption -@ stub WriteHitLogging +@ stdcall WriteHitLogging(ptr) WriteHitLogging @ stub ZonesReInit diff --git a/dlls/urlmon/urlmon_main.c b/dlls/urlmon/urlmon_main.c index b58a2296b3f..543bdb7077b 100644 --- a/dlls/urlmon/urlmon_main.c +++ b/dlls/urlmon/urlmon_main.c @@ -21,10 +21,22 @@ #include "windef.h" #include "winerror.h" #include "wtypes.h" +#include "ole2.h" +#include "urlmon.h" + +#include "comimpl.h" #include "wine/debug.h" -WINE_DEFAULT_DEBUG_CHANNEL(win32); +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + + +const COMIMPL_CLASSENTRY COMIMPL_ClassList[] = +{ + /* list of exported classes */ + { NULL, NULL } +}; + /*********************************************************************** * DllInstall (URLMON.@) @@ -37,28 +49,6 @@ HRESULT WINAPI URLMON_DllInstall(BOOL bInstall, LPCWSTR cmdline) return S_OK; } -/*********************************************************************** - * DllCanUnloadNow (URLMON.@) - */ -HRESULT WINAPI URLMON_DllCanUnloadNow(void) -{ - FIXME("(void): stub\n"); - - return S_FALSE; -} - -/*********************************************************************** - * DllGetClassObject (URLMON.@) - */ -HRESULT WINAPI URLMON_DllGetClassObject(REFCLSID rclsid, REFIID riid, - LPVOID *ppv) -{ - FIXME("(%p, %p, %p): stub\n", debugstr_guid(rclsid), - debugstr_guid(riid), ppv); - - return CLASS_E_CLASSNOTAVAILABLE; -} - /*********************************************************************** * DllRegisterServer (URLMON.@) */ @@ -118,7 +108,7 @@ HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, ERR("dwReserved: %ld, must be zero\n", dwReserved); } - return S_OK; + return E_NOTIMPL; } @@ -133,5 +123,260 @@ HRESULT WINAPI ObtainUserAgentString(DWORD dwOption, LPCSTR pcszUAOut, DWORD *cb ERR("dwOption: %ld, must be zero\n", dwOption); } - return S_OK; + return E_NOTIMPL; } + +/***************************************************************************** + * stubs + */ + +typedef struct +{ + DWORD dwStructSize; + LPSTR lpszLoggedUrlName; + SYSTEMTIME StartTime; + SYSTEMTIME EndTime; + LPSTR lpszExtendedInfo; +} HIT_LOGGING_INFO; + + +typedef struct +{ + ULONG cbSize; + DWORD dwFlags; + DWORD dwAdState; + LPWSTR szTitle; + LPWSTR szAbstract; + LPWSTR szHREF; + DWORD dwInstalledVersionMS; + DWORD dwInstalledVersionLS; + DWORD dwUpdateVersionMS; + DWORD dwUpdateVersionLS; + DWORD dwAdvertisedVersionMS; + DWORD dwAdvertisedVersionLS; + DWORD dwReserved; +} SOFTDISTINFO; + + +HRESULT WINAPI CreateFormatEnumerator(UINT cFormatEtcs,FORMATETC* pFormatEtcs,IEnumFORMATETC** ppenum) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI FindMediaType(LPCSTR pszTypes,CLIPFORMAT* pcfTypes) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI FindMediaTypeClass(IBindCtx* pbc,LPCSTR pszType,CLSID* pclsid,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI FindMimeFromData(IBindCtx* pbc,LPCWSTR pwszURL,void* pbuf,DWORD cb,LPCWSTR pwszMimeProposed,DWORD dwMimeFlags,LPWSTR* ppwszMimeOut,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI GetClassFileOrMime(IBindCtx* pbc,LPCWSTR pwszFilename,void* pbuf,DWORD cb,LPCWSTR pwszMime,DWORD dwReserved,CLSID* pclsid) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI GetClassURL(LPCWSTR pwszURL,CLSID* pclsid) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI GetSoftwareUpdateInfo(LPCWSTR pwszDistUnit,SOFTDISTINFO* psdi) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkGoBack(IUnknown* punk) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkGoForward(IUnknown* punk) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkNavigateMoniker(IUnknown* punk,IMoniker* pmonTarget) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkNavigateString(IUnknown* punk,LPCWSTR szTarget) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkSimpleNavigateToMoniker( + IMoniker* pmonTarget,LPCWSTR pwszLocation,LPCWSTR pwszTargetFrame, + IUnknown* punk,IBindCtx* pbc,IBindStatusCallback* pbscb, + DWORD dwHLNF,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI HlinkSimpleNavigateToString( + LPCWSTR pwszTarget,LPCWSTR pwszLocation,LPCWSTR pwszTargetFrame, + IUnknown* punk,IBindCtx* pbc,IBindStatusCallback* pbscb, + DWORD dwHLNF,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI IsAsyncMoniker(IMoniker* pmon) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +BOOL WINAPI IsLoggingEnabledA(LPCSTR pszURL) +{ + FIXME("() stub\n"); + return FALSE; +} + +BOOL WINAPI IsLoggingEnabledW(LPCWSTR pwszURL) +{ + FIXME("() stub\n"); + return FALSE; +} + +HRESULT WINAPI IsValidURL(IBindCtx* pbc,LPCWSTR pwszURL,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI MkParseDisplayNameEx(IBindCtx* pbc,LPCWSTR pwszDisplayName,ULONG* pulCharEaten,IMoniker** ppmon) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI RegisterFormatEnumerator(IBindCtx* pbc,IEnumFORMATETC* penum,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI RegisterMediaTypeClass(IBindCtx* pbc,UINT cTypes,const LPCSTR* pszTypes,CLSID* pclsid,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI RegisterMediaTypes(UINT cTypes,const LPCSTR* pszTypes,CLIPFORMAT* pcfTypes) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +void WINAPI ReleaseBindInfo(BINDINFO* pbi) +{ + FIXME("() stub\n"); +} + +HRESULT WINAPI RevokeFormatEnumerator(IBindCtx* pbc,IEnumFORMATETC* penum) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI SetSoftwareUpdateAdvertisementState(LPCWSTR pwszDistUnit,DWORD dwAdvState,DWORD dwAdvVerMS,DWORD dwAdvVerLS) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLDownloadToCacheFileA(IUnknown* punk,LPCSTR pszURL,LPSTR pszNameBuf,DWORD dwNameBufLen,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLDownloadToCacheFileW(IUnknown* punk,LPCWSTR pwszURL,LPWSTR pwszNameBuf,DWORD dwNameBufLen,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLDownloadToFileA(IUnknown* punk,LPCSTR pszURL,LPCSTR pszFileName,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLDownloadToFileW(IUnknown* punk,LPCWSTR pwszURL,LPCWSTR pwszFileName,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenBlockingStreamA(IUnknown* punk,LPCSTR pszURL,IStream** ppstream,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenBlockingStreamW(IUnknown* punk,LPCWSTR pwszURL,IStream** ppstream,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenPullStreamA(IUnknown* punk,LPCSTR pszURL,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenPullStreamW(IUnknown* punk,LPCWSTR pwszURL,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenStreamA(IUnknown* punk,LPCSTR pszURL,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI URLOpenStreamW(IUnknown* punk,LPCWSTR pwszURL,DWORD dwReserved,IBindStatusCallback* pbscb) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI UrlMkGetSessionOption(DWORD dwOpt,void* pvBuf,DWORD dwBufLen,DWORD* pdwLen,DWORD dwReserved) +{ + FIXME("() stub\n"); + return E_NOTIMPL; +} + +BOOL WINAPI WriteHitLogging(HIT_LOGGING_INFO* pli) +{ + FIXME("() stub\n"); + return FALSE; +} + +