Added some stubs.

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) \

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
 

dlls/urlmon/comimpl.c

@@ -0,0 +1,444 @@
+/*
+ * A basic implementation for COM DLL implementor.
+ *
+ * Copyright (C) 2002 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
+ *
+ * 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 );
+}
+

dlls/urlmon/comimpl.h

@@ -0,0 +1,171 @@
+/*
+ * A basic implementation for COM DLL implementor.
+ *
+ * Copyright (C) 2002 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
+ *
+ * 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 <pshpack4.h>
+
+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 <poppack.h>
+
+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 */

dlls/urlmon/moniker.c

@@ -0,0 +1,446 @@
+/*
+ * URL Moniker
+ *
+ * FIXME - stub
+ *
+ * Copyright (C) 2002 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
+ *
+ * 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;
+}
+

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;
 }

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 DllCanUnloadNow() COMIMPL_DllCanUnloadNow
-@ stdcall DllGetClassObject(ptr ptr ptr) URLMON_DllGetClassObject
+@ 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
+@ stdcall FindMediaType(str ptr) FindMediaType
-@ stub FindMediaTypeClass
+@ stdcall FindMediaTypeClass(ptr str ptr long) FindMediaTypeClass
-@ stub FindMimeFromData
+@ stdcall FindMimeFromData(ptr wstr ptr long wstr long ptr long) FindMimeFromData
-@ stub GetClassFileOrMime
+@ stdcall GetClassFileOrMime(ptr wstr ptr long wstr long ptr) GetClassFileOrMime
-@ stub GetClassURL
+@ stdcall GetClassURL(wstr ptr) GetClassURL
 @ stub GetComponentIDFromCLSSPEC
 @ stub GetMarkOfTheWeb
-@ stub GetSoftwareUpdateInfo
+@ stdcall GetSoftwareUpdateInfo(wstr ptr) GetSoftwareUpdateInfo
-@ stub HlinkGoBack
+@ stdcall HlinkGoBack(ptr) HlinkGoBack
-@ stub HlinkGoForward
+@ stdcall HlinkGoForward(ptr) HlinkGoForward
-@ stub HlinkNavigateMoniker
+@ stdcall HlinkNavigateMoniker(ptr ptr) HlinkNavigateMoniker
-@ stub HlinkNavigateString
+@ stdcall HlinkNavigateString(ptr wstr) HlinkNavigateString
-@ stub HlinkSimpleNavigateToMoniker
+@ stdcall HlinkSimpleNavigateToMoniker(ptr wstr wstr ptr ptr ptr long long) HlinkSimpleNavigateToMoniker
-@ stub HlinkSimpleNavigateToString
+@ stdcall HlinkSimpleNavigateToString(wstr wstr wstr ptr ptr ptr long long) HlinkSimpleNavigateToString
-@ stub IsAsyncMoniker
+@ stdcall IsAsyncMoniker(ptr) IsAsyncMoniker
-@ stub IsLoggingEnabledA
+@ stdcall IsLoggingEnabledA(str) IsLoggingEnabledA
-@ stub IsLoggingEnabledW
+@ stdcall IsLoggingEnabledW(wstr) IsLoggingEnabledW
-@ stub IsValidURL
+@ stdcall IsValidURL(ptr wstr long) IsValidURL
-@ stub MkParseDisplayNameEx
+@ stdcall MkParseDisplayNameEx(ptr wstr ptr ptr) MkParseDisplayNameEx
 @ stdcall ObtainUserAgentString(long str ptr) ObtainUserAgentString
 @ stub PrivateCoInstall
 @ stdcall RegisterBindStatusCallback(ptr ptr ptr long) RegisterBindStatusCallback
-@ stub RegisterFormatEnumerator
+@ stdcall RegisterFormatEnumerator(ptr ptr long) RegisterFormatEnumerator
-@ stub RegisterMediaTypeClass
+@ stdcall RegisterMediaTypeClass(ptr long ptr ptr long) RegisterMediaTypeClass
-@ stub RegisterMediaTypes
+@ stdcall RegisterMediaTypes(long ptr ptr) RegisterMediaTypes
-@ stub ReleaseBindInfo
+@ stdcall ReleaseBindInfo(ptr) ReleaseBindInfo
 @ stdcall RevokeBindStatusCallback(ptr ptr) RevokeBindStatusCallback
-@ stub RevokeFormatEnumerator
+@ stdcall RevokeFormatEnumerator(ptr ptr) RevokeFormatEnumerator
-@ stub SetSoftwareUpdateAdvertisementState
+@ stdcall SetSoftwareUpdateAdvertisementState(wstr long long long) SetSoftwareUpdateAdvertisementState
 @ stub URLDownloadA
-@ stub URLDownloadToCacheFileA
+@ stdcall URLDownloadToCacheFileA(ptr str ptr long long ptr) URLDownloadToCacheFileA
-@ stub URLDownloadToCacheFileW
+@ stdcall URLDownloadToCacheFileW(ptr wstr ptr long long ptr) URLDownloadToCacheFileW
-@ stub URLDownloadToFileA
+@ stdcall URLDownloadToFileA(ptr str str long ptr) URLDownloadToFileA
-@ stub URLDownloadToFileW
+@ stdcall URLDownloadToFileW(ptr wstr wstr long ptr) URLDownloadToFileW
 @ stub URLDownloadW
-@ stub URLOpenBlockingStreamA
+@ stdcall URLOpenBlockingStreamA(ptr str ptr long ptr) URLOpenBlockingStreamA
-@ stub URLOpenBlockingStreamW
+@ stdcall URLOpenBlockingStreamW(ptr wstr ptr long ptr) URLOpenBlockingStreamW
-@ stub URLOpenPullStreamA
+@ stdcall URLOpenPullStreamA(ptr str long ptr) URLOpenPullStreamA
-@ stub URLOpenPullStreamW
+@ stdcall URLOpenPullStreamW(ptr wstr long ptr) URLOpenPullStreamW
-@ stub URLOpenStreamA
+@ stdcall URLOpenStreamA(ptr str long ptr) URLOpenStreamA
-@ stub URLOpenStreamW
+@ 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
 

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;
+}
+
+