urlmon.idl File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
interface	IInternet
interface	IBinding
interface	IBindStatusCallback
struct	IBindStatusCallback::_tagBINDINFO
struct	IBindStatusCallback::_REMSECURITY_ATTRIBUTES
struct	IBindStatusCallback::_tagRemBINDINFO
struct	IBindStatusCallback::tagRemFORMATETC
interface	IBindStatusCallbackEx
interface	IAuthenticate
interface	IHttpNegotiate
interface	IHttpNegotiate2
interface	IBindHost
interface	IWinInetInfo
interface	IWinInetHttpInfo
interface	IWindowForBindingUI
interface	ICodeInstall
interface	IHttpSecurity
interface	IPersistMoniker
interface	IMonikerProp
interface	IBindProtocol
interface	IInternetBindInfo
interface	IInternetPriority
interface	IInternetProtocolRoot
struct	IInternetProtocolRoot::_tagPROTOCOLDATA
interface	IInternetProtocolSink
interface	IInternetProtocol
interface	IInternetProtocolInfo
interface	IInternetSession
interface	IInternetSecurityMgrSite
interface	IInternetSecurityManager
interface	IInternetSecurityManagerEx
interface	IInternetSecurityManagerEx2
interface	IInternetHostSecurityManager
interface	IInternetZoneManager
struct	IInternetZoneManager::_ZONEATTRIBUTES
interface	IInternetZoneManagerEx
interface	struct
struct	_tagCODEBASEHOLD
interface	enum
struct	_tagPROTOCOLFILTERDATA
interface	IUri
interface	IUriContainer
interface	IUriBuilder
interface	IUriBuilderFactory
interface	IInternetProtocolEx
interface	IGetBindHandle
interface	IBindCallbackRedirect
struct	CONFIRMSAFETY

Typedefs
typedef struct _tagCODEBASEHOLD	CODEBASEHOLD
typedef struct _tagCODEBASEHOLD *	LPCODEBASEHOLD
typedef enum	FEATURE_ZONE_ELEVATION
typedef enum	FEATURE_MIME_HANDLING
typedef enum	FEATURE_MIME_SNIFFING
typedef enum	FEATURE_WINDOW_RESTRICTIONS
typedef enum	FEATURE_WEBOC_POPUPMANAGEMENT
typedef enum	FEATURE_BEHAVIORS
typedef enum	FEATURE_DISABLE_MK_PROTOCOL
typedef enum	FEATURE_LOCALMACHINE_LOCKDOWN
typedef enum	FEATURE_SECURITYBAND
typedef enum	FEATURE_RESTRICT_ACTIVEXINSTALL
typedef enum	FEATURE_VALIDATE_NAVIGATE_URL
typedef enum	FEATURE_RESTRICT_FILEDOWNLOAD
typedef enum	FEATURE_ADDON_MANAGEMENT
typedef enum	FEATURE_PROTOCOL_LOCKDOWN
typedef enum	FEATURE_HTTP_USERNAME_PASSWORD_DISABLE
typedef enum	FEATURE_SAFE_BINDTOOBJECT
typedef enum	FEATURE_UNC_SAVEDFILECHECK
typedef enum	FEATURE_GET_URL_DOM_FILEPATH_UNENCODED
typedef enum	FEATURE_TABBED_BROWSING
typedef enum	FEATURE_SSLUX
typedef enum	FEATURE_DISABLE_NAVIGATION_SOUNDS
typedef enum	FEATURE_DISABLE_LEGACY_COMPRESSION
typedef enum	FEATURE_FORCE_ADDR_AND_STATUS
typedef enum	FEATURE_XMLHTTP
typedef enum	FEATURE_DISABLE_TELNET_PROTOCOL
typedef enum	FEATURE_FEEDS
typedef enum	FEATURE_BLOCK_INPUT_PROMPTS
typedef enum	INTERNETFEATURELIST
typedef struct _tagPROTOCOLFILTERDATA	PROTOCOLFILTERDATA

Functions
HRESULT WINAPI	CreateUri (LPCWSTR, DWORD, DWORD_PTR, IUri **)
HRESULT WINAPI	CreateUriWithFragment (LPCWSTR, LPCWSTR, DWORD, DWORD_PTR, IUri **)
HRESULT WINAPI	CreateUriFromMultiByteString (LPCSTR, DWORD, DWORD, DWORD, DWORD_PTR, IUri **)
HRESULT WINAPI	CreateIUriBuilder (IUri *, DWORD, DWORD_PTR, IUriBuilder **)
	DEFINE_GUID (CLSID_InternetSecurityManager, 0x7b8a2d94, 0x0ac9, 0x11d1, 0x89, 0x6c, 0x00, 0xc0, 0x4f, 0xB6, 0xbf, 0xc4)
	DEFINE_GUID (CLSID_InternetZoneManager, 0x7B8A2D95, 0x0AC9, 0x11D1, 0x89, 0x6C, 0x00, 0xC0, 0x4F, 0xB6, 0xBF, 0xC4)
	DEFINE_GUID (IID_IAsyncMoniker, 0x79EAC9D3, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (IID_IAsyncBindCtx, 0x79EAC9D4, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_DeCompMimeFilter, 0x8f6b0360, 0xb80d, 0x11d0, 0xa9, 0xb3, 0x00, 0x60, 0x97, 0x94, 0x23, 0x11)
	DEFINE_GUID (CLSID_CdlProtocol, 0x3dd53d40, 0x7b8b, 0x11D0, 0xb0, 0x13, 0x00, 0xaa, 0x00, 0x59, 0xce, 0x02)
	DEFINE_GUID (CLSID_FileProtocol, 0x79EAC9E7, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_FtpProtocol, 0x79EAC9E3, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_GopherProtocol, 0x79EAC9E4, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_HttpProtocol, 0x79EAC9E2, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_HttpSProtocol, 0x79EAC9E5, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
	DEFINE_GUID (CLSID_MkProtocol, 0x79EAC9E6, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B)
HRESULT WINAPI	CoGetClassObjectFromURL (REFCLSID, LPCWSTR, DWORD, DWORD, LPCWSTR, LPBINDCTX, DWORD, LPVOID, REFIID, LPVOID *)
HRESULT WINAPI	CreateURLMoniker (IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
HRESULT WINAPI	CreateURLMonikerEx (IMoniker *, LPCWSTR, IMoniker **, DWORD)
HRESULT WINAPI	CreateURLMonikerEx2 (IMoniker *, IUri *, IMoniker **, DWORD)
HRESULT WINAPI	RegisterBindStatusCallback (IBindCtx *pbc, IBindStatusCallback *pbsc, IBindStatusCallback **ppbsc, DWORD dwReserved)
HRESULT WINAPI	CompareSecurityIds (BYTE *, DWORD, BYTE *, DWORD, DWORD)
HRESULT WINAPI	URLDownloadToFileA (LPUNKNOWN, LPCSTR, LPCSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLDownloadToFileW (LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLDownloadToCacheFileA (LPUNKNOWN, LPCSTR, LPSTR, DWORD, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLDownloadToCacheFileW (LPUNKNOWN, LPCWSTR, LPWSTR, DWORD, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	CoInternetGetSession (DWORD, IInternetSession **, DWORD)
HRESULT WINAPI	MkParseDisplayNameEx (IBindCtx *, LPCWSTR, ULONG *, IMoniker **)
HRESULT WINAPI	IsAsyncMoniker (IMoniker *pmk)
HRESULT WINAPI	CreateAsyncBindCtx (DWORD, IBindStatusCallback *, IEnumFORMATETC *, IBindCtx **)
HRESULT WINAPI	CreateAsyncBindCtxEx (IBindCtx *, DWORD, IBindStatusCallback *, IEnumFORMATETC *, IBindCtx **, DWORD)
HRESULT WINAPI	CoInternetCreateSecurityManager (IServiceProvider *, IInternetSecurityManager **, DWORD)
HRESULT WINAPI	CoInternetCombineUrl (LPCWSTR, LPCWSTR, DWORD, LPWSTR, DWORD, DWORD *, DWORD)
HRESULT WINAPI	CoInternetCombineUrlEx (IUri *, LPCWSTR, DWORD, IUri **, DWORD_PTR)
HRESULT WINAPI	CoInternetCompareUrl (LPCWSTR, LPCWSTR, DWORD)
HRESULT WINAPI	CoInternetCombineIUri (IUri *, IUri *, DWORD, IUri **, DWORD_PTR)
HRESULT WINAPI	CoInternetCreateZoneManager (IServiceProvider *, IInternetZoneManager **, DWORD)
HRESULT WINAPI	CoInternetParseUrl (LPCWSTR, PARSEACTION, DWORD, LPWSTR, DWORD, DWORD *, DWORD)
HRESULT WINAPI	CoInternetParseIUri (IUri *, PARSEACTION, DWORD, LPWSTR, DWORD, DWORD *, DWORD_PTR)
HRESULT WINAPI	CoInternetQueryInfo (LPCWSTR, QUERYOPTION, DWORD, LPVOID, DWORD, DWORD *, DWORD)
HRESULT WINAPI	CoInternetSetFeatureEnabled (INTERNETFEATURELIST, DWORD, BOOL)
HRESULT WINAPI	CoInternetIsFeatureEnabled (INTERNETFEATURELIST, DWORD dwFlags)
HRESULT WINAPI	CoInternetIsFeatureEnabledForUrl (INTERNETFEATURELIST, DWORD, LPCWSTR, IInternetSecurityManager *)
HRESULT WINAPI	CoInternetGetSecurityUrl (LPCWSTR, LPWSTR *, PSUACTION, DWORD)
HRESULT WINAPI	CoInternetGetSecurityUrlEx (IUri *, IUri **, PSUACTION, DWORD_PTR)
HRESULT WINAPI	AsyncInstallDistributionUnit (LPCWSTR, LPCWSTR, LPCWSTR, DWORD, DWORD, LPCWSTR, IBindCtx *, LPVOID, DWORD)
HRESULT WINAPI	CreateFormatEnumerator (UINT, FORMATETC *, IEnumFORMATETC **)
HRESULT WINAPI	GetSoftwareUpdateInfo (LPCWSTR szDistUnit, LPSOFTDISTINFO psdi)
HRESULT WINAPI	FaultInIEFeature (HWND, uCLSSPEC *, QUERYCONTEXT *, DWORD)
HRESULT WINAPI	FindMimeFromData (LPBC, LPCWSTR, LPVOID, DWORD, LPCWSTR, DWORD, LPWSTR *, DWORD)
HRESULT WINAPI	GetClassFileOrMime (LPBC, LPCWSTR, LPVOID, DWORD, LPCWSTR, DWORD, CLSID *)
HRESULT WINAPI	HlinkGoBack (IUnknown *)
HRESULT WINAPI	HlinkGoForward (IUnknown *)
HRESULT WINAPI	HlinkNavigateMoniker (IUnknown *, IMoniker *)
HRESULT WINAPI	HlinkNavigateString (IUnknown *, LPCWSTR)
HRESULT WINAPI	HlinkSimpleNavigateToMoniker (IMoniker *, LPCWSTR, LPCWSTR, IUnknown *, IBindCtx *, IBindStatusCallback *, DWORD, DWORD)
HRESULT WINAPI	HlinkSimpleNavigateToString (LPCWSTR, LPCWSTR, LPCWSTR, IUnknown *, IBindCtx *, IBindStatusCallback *, DWORD, DWORD)
HRESULT WINAPI	IsValidURL (LPBC, LPCWSTR, DWORD)
HRESULT WINAPI	ObtainUserAgentString (DWORD, LPSTR, DWORD *)
HRESULT WINAPI	RegisterFormatEnumerator (LPBC, IEnumFORMATETC *, DWORD)
HRESULT WINAPI	RevokeFormatEnumerator (LPBC, IEnumFORMATETC *)
HRESULT WINAPI	RevokeBindStatusCallback (LPBC, IBindStatusCallback *)
HRESULT WINAPI	CopyStgMedium (const STGMEDIUM *, STGMEDIUM *)
HRESULT WINAPI	CopyBindInfo (const BINDINFO *, BINDINFO *)
void WINAPI	ReleaseBindInfo (BINDINFO *)
HRESULT WINAPI	UrlMkGetSessionOption (DWORD, LPVOID, DWORD, DWORD *, DWORD)
HRESULT WINAPI	UrlMkSetSessionOption (DWORD, LPVOID, DWORD, DWORD)
HRESULT WINAPI	URLOpenStreamA (LPUNKNOWN, LPCSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLOpenStreamW (LPUNKNOWN, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLOpenPullStreamA (LPUNKNOWN, LPCSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLOpenPullStreamW (LPUNKNOWN, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLOpenBlockingStreamA (LPUNKNOWN, LPCSTR, LPSTREAM *, DWORD, LPBINDSTATUSCALLBACK)
HRESULT WINAPI	URLOpenBlockingStreamW (LPUNKNOWN, LPCWSTR, LPSTREAM *, DWORD, LPBINDSTATUSCALLBACK)
BOOL WINAPI	IsLoggingEnabledA (LPCSTR)
BOOL WINAPI	IsLoggingEnabledW (LPCWSTR)

Variables
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
*	LPSOFTDISTINFO
EXTERN_C const GUID	GUID_CUSTOM_CONFIRMOBJECTSAFETY

Typedef Documentation

CODEBASEHOLD

typedef struct _tagCODEBASEHOLD CODEBASEHOLD

FEATURE_ADDON_MANAGEMENT

typedef enum FEATURE_ADDON_MANAGEMENT

FEATURE_BEHAVIORS

typedef enum FEATURE_BEHAVIORS

FEATURE_BLOCK_INPUT_PROMPTS

typedef enum FEATURE_BLOCK_INPUT_PROMPTS

FEATURE_DISABLE_LEGACY_COMPRESSION

typedef enum FEATURE_DISABLE_LEGACY_COMPRESSION

FEATURE_DISABLE_MK_PROTOCOL

typedef enum FEATURE_DISABLE_MK_PROTOCOL

FEATURE_DISABLE_NAVIGATION_SOUNDS

typedef enum FEATURE_DISABLE_NAVIGATION_SOUNDS

FEATURE_DISABLE_TELNET_PROTOCOL

typedef enum FEATURE_DISABLE_TELNET_PROTOCOL

FEATURE_FEEDS

typedef enum FEATURE_FEEDS

FEATURE_FORCE_ADDR_AND_STATUS

typedef enum FEATURE_FORCE_ADDR_AND_STATUS

FEATURE_GET_URL_DOM_FILEPATH_UNENCODED

typedef enum FEATURE_GET_URL_DOM_FILEPATH_UNENCODED

FEATURE_HTTP_USERNAME_PASSWORD_DISABLE

typedef enum FEATURE_HTTP_USERNAME_PASSWORD_DISABLE

FEATURE_LOCALMACHINE_LOCKDOWN

typedef enum FEATURE_LOCALMACHINE_LOCKDOWN

FEATURE_MIME_HANDLING

typedef enum FEATURE_MIME_HANDLING

FEATURE_MIME_SNIFFING

typedef enum FEATURE_MIME_SNIFFING

FEATURE_PROTOCOL_LOCKDOWN

typedef enum FEATURE_PROTOCOL_LOCKDOWN

FEATURE_RESTRICT_ACTIVEXINSTALL

typedef enum FEATURE_RESTRICT_ACTIVEXINSTALL

FEATURE_RESTRICT_FILEDOWNLOAD

typedef enum FEATURE_RESTRICT_FILEDOWNLOAD

FEATURE_SAFE_BINDTOOBJECT

typedef enum FEATURE_SAFE_BINDTOOBJECT

FEATURE_SECURITYBAND

typedef enum FEATURE_SECURITYBAND

FEATURE_SSLUX

typedef enum FEATURE_SSLUX

FEATURE_TABBED_BROWSING

typedef enum FEATURE_TABBED_BROWSING

FEATURE_UNC_SAVEDFILECHECK

typedef enum FEATURE_UNC_SAVEDFILECHECK

FEATURE_VALIDATE_NAVIGATE_URL

typedef enum FEATURE_VALIDATE_NAVIGATE_URL

FEATURE_WEBOC_POPUPMANAGEMENT

typedef enum FEATURE_WEBOC_POPUPMANAGEMENT

FEATURE_WINDOW_RESTRICTIONS

typedef enum FEATURE_WINDOW_RESTRICTIONS

FEATURE_XMLHTTP

typedef enum FEATURE_XMLHTTP

FEATURE_ZONE_ELEVATION

typedef enum FEATURE_ZONE_ELEVATION

INTERNETFEATURELIST

typedef enum INTERNETFEATURELIST

LPCODEBASEHOLD

typedef struct _tagCODEBASEHOLD * LPCODEBASEHOLD

PROTOCOLFILTERDATA

typedef struct _tagPROTOCOLFILTERDATA PROTOCOLFILTERDATA

Function Documentation

AsyncInstallDistributionUnit()

HRESULT WINAPI AsyncInstallDistributionUnit	(	LPCWSTR	,
		LPCWSTR	,
		LPCWSTR	,
		DWORD	,
		DWORD	,
		LPCWSTR	,
		IBindCtx *	,
		LPVOID	,
		DWORD
	)

CoGetClassObjectFromURL()

HRESULT WINAPI CoGetClassObjectFromURL	(	REFCLSID	rclsid,
		LPCWSTR	szCodeURL,
		DWORD	dwFileVersionMS,
		DWORD	dwFileVersionLS,
		LPCWSTR	szContentType,
		LPBINDCTX	pBindCtx,
		DWORD	dwClsContext,
		LPVOID	pvReserved,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 550 of file urlmon_main.c.

{
    FIXME("(%s %s %d %d %s %p %d %p %s %p) Stub!\n", debugstr_guid(rclsid), debugstr_w(szCodeURL),
    dwFileVersionMS, dwFileVersionLS, debugstr_w(szContentType), pBindCtx, dwClsContext, pvReserved,
    debugstr_guid(riid), ppv);
    return E_NOINTERFACE;
}

CoInternetCombineIUri()

HRESULT WINAPI CoInternetCombineIUri	(	IUri *	pBaseUri,
		IUri *	pRelativeUri,
		DWORD	dwCombineFlags,
		IUri **	ppCombinedUri,
		DWORD_PTR	dwReserved
	)

Definition at line 6716 of file uri.c.

{
    HRESULT hr;
    IInternetProtocolInfo *info;
    Uri *relative, *base;
    TRACE("(%p %p %x %p %x)\n", pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
 
    if(!ppCombinedUri)
        return E_INVALIDARG;
 
    if(!pBaseUri || !pRelativeUri) {
        *ppCombinedUri = NULL;
        return E_INVALIDARG;
    }
 
    relative = get_uri_obj(pRelativeUri);
    base = get_uri_obj(pBaseUri);
    if(!relative || !base) {
        *ppCombinedUri = NULL;
        FIXME("(%p %p %x %p %x) Unknown IUri types not supported yet.\n",
            pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(base->canon_uri);
    if(info) {
        WCHAR result[INTERNET_MAX_URL_LENGTH+1];
        DWORD result_len = 0;
 
        hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, relative->canon_uri, dwCombineFlags,
                                              result, INTERNET_MAX_URL_LENGTH+1, &result_len, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) {
            hr = CreateUri(result, Uri_CREATE_ALLOW_RELATIVE, 0, ppCombinedUri);
            if(SUCCEEDED(hr))
                return hr;
        }
    }
 
    return combine_uri(base, relative, dwCombineFlags, ppCombinedUri, 0);
}

Referenced by CreateURLMonikerEx2().

CoInternetCombineUrl()

HRESULT WINAPI CoInternetCombineUrl	(	LPCWSTR	pwzBaseUrl,
		LPCWSTR	pwzRelativeUrl,
		DWORD	dwCombineFlags,
		LPWSTR	pwzResult,
		DWORD	cchResult,
		DWORD *	pcchResult,
		DWORD	dwReserved
	)

Definition at line 426 of file internet.c.

{
    IInternetProtocolInfo *protocol_info;
    DWORD size = cchResult;
    HRESULT hres;
    
    TRACE("(%s,%s,0x%08x,%p,%d,%p,%d)\n", debugstr_w(pwzBaseUrl),
          debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult, pcchResult,
          dwReserved);
 
    protocol_info = get_protocol_info(pwzBaseUrl);
 
    if(protocol_info) {
        hres = IInternetProtocolInfo_CombineUrl(protocol_info, pwzBaseUrl, pwzRelativeUrl,
                dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
        IInternetProtocolInfo_Release(protocol_info);
        if(SUCCEEDED(hres))
            return hres;
    }
 
 
    hres = UrlCombineW(pwzBaseUrl, pwzRelativeUrl, pwzResult, &size, dwCombineFlags);
 
    if(pcchResult)
        *pcchResult = size;
 
    return hres;
}

CoInternetCombineUrlEx()

HRESULT WINAPI CoInternetCombineUrlEx	(	IUri *	pBaseUri,
		LPCWSTR	pwzRelativeUrl,
		DWORD	dwCombineFlags,
		IUri **	ppCombinedUri,
		DWORD_PTR	dwReserved
	)

Definition at line 6762 of file uri.c.

{
    IUri *relative;
    Uri *base;
    HRESULT hr;
    IInternetProtocolInfo *info;
 
    TRACE("(%p %s %x %p %x)\n", pBaseUri, debugstr_w(pwzRelativeUrl), dwCombineFlags,
        ppCombinedUri, (DWORD)dwReserved);
 
    if(!ppCombinedUri)
        return E_POINTER;
 
    if(!pwzRelativeUrl) {
        *ppCombinedUri = NULL;
        return E_UNEXPECTED;
    }
 
    if(!pBaseUri) {
        *ppCombinedUri = NULL;
        return E_INVALIDARG;
    }
 
    base = get_uri_obj(pBaseUri);
    if(!base) {
        *ppCombinedUri = NULL;
        FIXME("(%p %s %x %p %x) Unknown IUri's not supported yet.\n", pBaseUri, debugstr_w(pwzRelativeUrl),
            dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(base->canon_uri);
    if(info) {
        WCHAR result[INTERNET_MAX_URL_LENGTH+1];
        DWORD result_len = 0;
 
        hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, pwzRelativeUrl, dwCombineFlags,
                                              result, INTERNET_MAX_URL_LENGTH+1, &result_len, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) {
            hr = CreateUri(result, Uri_CREATE_ALLOW_RELATIVE, 0, ppCombinedUri);
            if(SUCCEEDED(hr))
                return hr;
        }
    }
 
    hr = CreateUri(pwzRelativeUrl, Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &relative);
    if(FAILED(hr)) {
        *ppCombinedUri = NULL;
        return hr;
    }
 
    hr = combine_uri(base, get_uri_obj(relative), dwCombineFlags, ppCombinedUri, COMBINE_URI_FORCE_FLAG_USE);
 
    IUri_Release(relative);
    return hr;
}

Referenced by check_codebase(), combine_url(), create_relative_uri(), CreateURLMonikerEx(), and navigate_url().

CoInternetCompareUrl()

HRESULT WINAPI CoInternetCompareUrl	(	LPCWSTR	pwzUrl1,
		LPCWSTR	pwzUrl2,
		DWORD	dwCompareFlags
	)

Definition at line 460 of file internet.c.

{
    IInternetProtocolInfo *protocol_info;
    HRESULT hres;
 
    TRACE("(%s,%s,%08x)\n", debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 
    protocol_info = get_protocol_info(pwzUrl1);
 
    if(protocol_info) {
        hres = IInternetProtocolInfo_CompareUrl(protocol_info, pwzUrl1, pwzUrl2, dwCompareFlags);
        IInternetProtocolInfo_Release(protocol_info);
        if(SUCCEEDED(hres))
            return hres;
    }
 
    return UrlCompareW(pwzUrl1, pwzUrl2, dwCompareFlags) ? S_FALSE : S_OK;
}

CoInternetCreateSecurityManager()

HRESULT WINAPI CoInternetCreateSecurityManager	(	IServiceProvider *	pSP,
		IInternetSecurityManager **	ppSM,
		DWORD	dwReserved
	)

Definition at line 1841 of file sec_mgr.c.

{
    TRACE("%p %p %d\n", pSP, ppSM, dwReserved );
 
    if(pSP)
        FIXME("pSP not supported\n");
 
    return SecManagerImpl_Construct(NULL, (void**) ppSM);
}

Referenced by HTMLOuterWindow_Create(), and security_enum_zones().

CoInternetCreateZoneManager()

HRESULT WINAPI CoInternetCreateZoneManager	(	IServiceProvider *	pSP,
		IInternetZoneManager **	ppZM,
		DWORD	dwReserved
	)

Definition at line 1855 of file sec_mgr.c.

{
    TRACE("(%p %p %x)\n", pSP, ppZM, dwReserved);
    return ZoneMgrImpl_Construct(NULL, (void**)ppZM);
}

Referenced by security_enum_zones().

CoInternetGetSecurityUrl()

HRESULT WINAPI CoInternetGetSecurityUrl	(	LPCWSTR	pwzUrl,
		LPWSTR *	ppwzSecUrl,
		PSUACTION	psuAction,
		DWORD	dwReserved
	)

Definition at line 1977 of file sec_mgr.c.

{
    WCHAR *secure_url;
    HRESULT hres;
 
    TRACE("(%p,%p,%u,%u)\n", pwzUrl, ppwzSecUrl, psuAction, dwReserved);
 
    hres = parse_security_url(pwzUrl, psuAction, &secure_url);
    if(FAILED(hres))
        return hres;
 
    if(psuAction != PSU_SECURITY_URL_ONLY) {
        PARSEDURLW parsed_url = { sizeof(parsed_url) };
        DWORD size;
 
        /* FIXME: Use helpers from uri.c */
        if(SUCCEEDED(ParseURLW(secure_url, &parsed_url))) {
            WCHAR *new_url;
 
            switch(parsed_url.nScheme) {
            case URL_SCHEME_FTP:
            case URL_SCHEME_HTTP:
            case URL_SCHEME_HTTPS:
                size = lstrlenW(secure_url)+1;
                new_url = CoTaskMemAlloc(size * sizeof(WCHAR));
                if(new_url)
                    hres = UrlGetPartW(secure_url, new_url, &size, URL_PART_HOSTNAME, URL_PARTFLAG_KEEPSCHEME);
                else
                    hres = E_OUTOFMEMORY;
                CoTaskMemFree(secure_url);
                if(hres != S_OK) {
                    WARN("UrlGetPart failed: %08x\n", hres);
                    CoTaskMemFree(new_url);
                    return FAILED(hres) ? hres : E_FAIL;
                }
                secure_url = new_url;
            }
        }
    }
 
    *ppwzSecUrl = secure_url;
    return S_OK;
}

Referenced by map_url_to_zone().

CoInternetGetSecurityUrlEx()

HRESULT WINAPI CoInternetGetSecurityUrlEx	(	IUri *	pUri,
		IUri **	ppSecUri,
		PSUACTION	psuAction,
		DWORD_PTR	dwReserved
	)

Definition at line 2024 of file sec_mgr.c.

{
    URL_SCHEME scheme_type;
    BSTR secure_uri;
    WCHAR *ret_url;
    HRESULT hres;
 
    TRACE("(%p,%p,%u,%u)\n", pUri, ppSecUri, psuAction, (DWORD)dwReserved);
 
    if(!pUri || !ppSecUri)
        return E_INVALIDARG;
 
    hres = IUri_GetDisplayUri(pUri, &secure_uri);
    if(FAILED(hres))
        return hres;
 
    hres = parse_security_url(secure_uri, psuAction, &ret_url);
    SysFreeString(secure_uri);
    if(FAILED(hres))
        return hres;
 
    /* File URIs have to hierarchical. */
    hres = IUri_GetScheme(pUri, (DWORD*)&scheme_type);
    if(SUCCEEDED(hres) && scheme_type == URL_SCHEME_FILE) {
        const WCHAR *tmp = ret_url;
 
        /* Check and see if a "//" is after the scheme name. */
        tmp += ARRAY_SIZE(fileW);
        if(*tmp != '/' || *(tmp+1) != '/')
            hres = E_INVALIDARG;
    }
 
    if(SUCCEEDED(hres))
        hres = CreateUri(ret_url, Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME, 0, ppSecUri);
    CoTaskMemFree(ret_url);
    return hres;
}

Referenced by map_uri_to_zone().

CoInternetGetSession()

HRESULT WINAPI CoInternetGetSession	(	DWORD	dwSessionMode,
		IInternetSession **	ppIInternetSession,
		DWORD	dwReserved
	)

Definition at line 485 of file session.c.

{
    TRACE("(%d %p %d)\n", dwSessionMode, ppIInternetSession, dwReserved);
 
    if(dwSessionMode)
        ERR("dwSessionMode=%d\n", dwSessionMode);
    if(dwReserved)
        ERR("dwReserved=%d\n", dwReserved);
 
    IInternetSession_AddRef(&InternetSession);
    *ppIInternetSession = &InternetSession;
    return S_OK;
}

Referenced by register_protocol(), and register_protocols().

CoInternetIsFeatureEnabled()

HRESULT WINAPI CoInternetIsFeatureEnabled	(	INTERNETFEATURELIST	FeatureEntry,
		DWORD	dwFlags
	)

Definition at line 685 of file internet.c.

{
    TRACE("(%d, %08x)\n", FeatureEntry, dwFlags);
    return get_internet_feature(FeatureEntry, dwFlags);
}

Referenced by CoInternetIsFeatureEnabledForUrl(), and CoInternetIsFeatureZoneElevationEnabled().

CoInternetIsFeatureEnabledForUrl()

HRESULT WINAPI CoInternetIsFeatureEnabledForUrl	(	INTERNETFEATURELIST	FeatureEntry,
		DWORD	dwFlags,
		LPCWSTR	szURL,
		IInternetSecurityManager *	pSecMgr
	)

Definition at line 694 of file internet.c.

{
    DWORD urlaction = 0;
    HRESULT hres;
 
    TRACE("(%d %08x %s %p)\n", FeatureEntry, dwFlags, debugstr_w(szURL), pSecMgr);
 
    if(FeatureEntry == FEATURE_MIME_SNIFFING)
        urlaction = URLACTION_FEATURE_MIME_SNIFFING;
    else if(FeatureEntry == FEATURE_WINDOW_RESTRICTIONS)
        urlaction = URLACTION_FEATURE_WINDOW_RESTRICTIONS;
    else if(FeatureEntry == FEATURE_ZONE_ELEVATION)
        urlaction = URLACTION_FEATURE_ZONE_ELEVATION;
 
    if(!szURL || !urlaction || !pSecMgr)
        return CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
 
    switch(dwFlags) {
    case GET_FEATURE_FROM_THREAD:
    case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
    case GET_FEATURE_FROM_THREAD_INTRANET:
    case GET_FEATURE_FROM_THREAD_TRUSTED:
    case GET_FEATURE_FROM_THREAD_INTERNET:
    case GET_FEATURE_FROM_THREAD_RESTRICTED:
        FIXME("unsupported flags %x\n", dwFlags);
        return E_NOTIMPL;
 
    case GET_FEATURE_FROM_PROCESS:
        hres = CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
        if(hres != S_OK)
            return hres;
        /* fall through */
 
    default: {
        DWORD policy = URLPOLICY_DISALLOW;
 
        hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szURL, urlaction,
                (BYTE*)&policy, sizeof(DWORD), NULL, 0, PUAF_NOUI, 0);
        if(hres!=S_OK || policy!=URLPOLICY_ALLOW)
            return S_OK;
        return S_FALSE;
    }
    }
}

CoInternetParseIUri()

HRESULT WINAPI CoInternetParseIUri	(	IUri *	pIUri,
		PARSEACTION	ParseAction,
		DWORD	dwFlags,
		LPWSTR	pwzResult,
		DWORD	cchResult,
		DWORD *	pcchResult,
		DWORD_PTR	dwReserved
	)

Definition at line 7247 of file uri.c.

{
    HRESULT hr;
    Uri *uri;
    IInternetProtocolInfo *info;
 
    TRACE("(%p %d %x %p %d %p %x)\n", pIUri, ParseAction, dwFlags, pwzResult,
        cchResult, pcchResult, (DWORD)dwReserved);
 
    if(!pcchResult)
        return E_POINTER;
 
    if(!pwzResult || !pIUri) {
        *pcchResult = 0;
        return E_INVALIDARG;
    }
 
    if(!(uri = get_uri_obj(pIUri))) {
        *pcchResult = 0;
        FIXME("(%p %d %x %p %d %p %x) Unknown IUri's not supported for this action.\n",
            pIUri, ParseAction, dwFlags, pwzResult, cchResult, pcchResult, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(uri->canon_uri);
    if(info) {
        hr = IInternetProtocolInfo_ParseUrl(info, uri->canon_uri, ParseAction, dwFlags,
                                            pwzResult, cchResult, pcchResult, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) return hr;
    }
 
    switch(ParseAction) {
    case PARSE_CANONICALIZE:
        hr = parse_canonicalize(uri, dwFlags, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_FRIENDLY:
        hr = parse_friendly(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_ROOTDOCUMENT:
        hr = parse_rootdocument(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_DOCUMENT:
        hr = parse_document(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_PATH_FROM_URL:
        hr = parse_path_from_url(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_URL_FROM_PATH:
        hr = parse_url_from_path(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SCHEMA:
        hr = parse_schema(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SITE:
        hr = parse_site(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_DOMAIN:
        hr = parse_domain(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_LOCATION:
    case PARSE_ANCHOR:
        hr = parse_anchor(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SECURITY_URL:
    case PARSE_MIME:
    case PARSE_SERVER:
    case PARSE_SECURITY_DOMAIN:
        *pcchResult = 0;
        hr = E_FAIL;
        break;
    default:
        *pcchResult = 0;
        hr = E_NOTIMPL;
        FIXME("(%p %d %x %p %d %p %x) Partial stub.\n", pIUri, ParseAction, dwFlags,
            pwzResult, cchResult, pcchResult, (DWORD)dwReserved);
    }
 
    return hr;
}

Referenced by FileProtocol_StartEx(), and nsFileURL_GetFile().

CoInternetParseUrl()

HRESULT WINAPI CoInternetParseUrl	(	LPCWSTR	pwzUrl,
		PARSEACTION	ParseAction,
		DWORD	dwFlags,
		LPWSTR	pszResult,
		DWORD	cchResult,
		DWORD *	pcchResult,
		DWORD	dwReserved
	)

Definition at line 392 of file internet.c.

{
    if(dwReserved)
        WARN("dwReserved = %d\n", dwReserved);
 
    switch(ParseAction) {
    case PARSE_CANONICALIZE:
        return parse_canonicalize_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_SECURITY_URL:
        return parse_security_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_ENCODE:
    case PARSE_UNESCAPE:
        return parse_encode(pwzUrl, ParseAction, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_PATH_FROM_URL:
        return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_SCHEMA:
        return parse_schema(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_SECURITY_DOMAIN:
        return parse_security_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_DOMAIN:
        return parse_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    case PARSE_ROOTDOCUMENT:
        return parse_rootdocument(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
    default:
        FIXME("not supported action %d\n", ParseAction);
    }
 
    return E_NOTIMPL;
}

Referenced by get_protocol_info(), is_registered_protocol(), OleLoadPicturePath(), ResProtocol_Start(), try_application_url(), and UniformResourceLocatorW_InvokeCommand().

CoInternetQueryInfo()

HRESULT WINAPI CoInternetQueryInfo	(	LPCWSTR	pwzUrl,
		QUERYOPTION	QueryOption,
		DWORD	dwQueryFlags,
		LPVOID	pvBuffer,
		DWORD	cbBuffer,
		DWORD *	pcbBuffer,
		DWORD	dwReserved
	)

Definition at line 485 of file internet.c.

{
    IInternetProtocolInfo *protocol_info;
    HRESULT hres;
 
    TRACE("(%s, %x, %x, %p, %x, %p, %x)\n", debugstr_w(pwzUrl),
          QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 
    protocol_info = get_protocol_info(pwzUrl);
 
    if(protocol_info) {
        hres = IInternetProtocolInfo_QueryInfo(protocol_info, pwzUrl, QueryOption, dwQueryFlags,
                pvBuffer, cbBuffer, pcbBuffer, dwReserved);
        IInternetProtocolInfo_Release(protocol_info);
 
        return SUCCEEDED(hres) ? hres : E_FAIL;
    }
 
    switch(QueryOption) {
    case QUERY_USES_NETWORK:
        if(!pvBuffer || cbBuffer < sizeof(DWORD))
            return E_FAIL;
 
        *(DWORD*)pvBuffer = 0;
        if(pcbBuffer)
            *pcbBuffer = sizeof(DWORD);
        break;
 
    default:
        FIXME("Not supported option %d\n", QueryOption);
        return E_NOTIMPL;
    }
 
    return S_OK;
}

CoInternetSetFeatureEnabled()

HRESULT WINAPI CoInternetSetFeatureEnabled	(	INTERNETFEATURELIST	FeatureEntry,
		DWORD	dwFlags,
		BOOL	fEnable
	)

Definition at line 676 of file internet.c.

{
    TRACE("(%d, %08x, %x)\n", FeatureEntry, dwFlags, fEnable);
    return set_internet_feature(FeatureEntry, dwFlags, fEnable);
}

CompareSecurityIds()

HRESULT WINAPI CompareSecurityIds	(	BYTE *	secid1,
		DWORD	size1,
		BYTE *	secid2,
		DWORD	size2,
		DWORD	reserved
	)

Definition at line 2065 of file sec_mgr.c.

{
    FIXME("(%p %d %p %d %x)\n", secid1, size1, secid2, size2, reserved);
    return E_NOTIMPL;
}

CopyBindInfo()

HRESULT WINAPI CopyBindInfo	(	const BINDINFO *	pcbiSrc,
		BINDINFO *	pcbiDest
	)

Definition at line 654 of file urlmon_main.c.

{
    DWORD size;
    HRESULT hres;
 
    TRACE("(%p %p)\n", pcbiSrc, pcbiDest);
 
    if(!pcbiSrc || !pcbiDest)
        return E_POINTER;
    if(!pcbiSrc->cbSize || !pcbiDest->cbSize)
        return E_INVALIDARG;
 
    size = pcbiDest->cbSize;
    if(size > pcbiSrc->cbSize) {
        memcpy(pcbiDest, pcbiSrc, pcbiSrc->cbSize);
        memset((char*)pcbiDest+pcbiSrc->cbSize, 0, size-pcbiSrc->cbSize);
    } else {
        memcpy(pcbiDest, pcbiSrc, size);
    }
    pcbiDest->cbSize = size;
 
    size = FIELD_OFFSET(BINDINFO, szExtraInfo)+sizeof(void*);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szExtraInfo) {
        size = (lstrlenW(pcbiSrc->szExtraInfo)+1)*sizeof(WCHAR);
        pcbiDest->szExtraInfo = CoTaskMemAlloc(size);
        if(!pcbiDest->szExtraInfo)
            return E_OUTOFMEMORY;
        memcpy(pcbiDest->szExtraInfo, pcbiSrc->szExtraInfo, size);
    }
 
    size = FIELD_OFFSET(BINDINFO, stgmedData)+sizeof(STGMEDIUM);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size) {
        hres = CopyStgMedium(&pcbiSrc->stgmedData, &pcbiDest->stgmedData);
        if(FAILED(hres)) {
            CoTaskMemFree(pcbiDest->szExtraInfo);
            return hres;
        }
    }
 
    size = FIELD_OFFSET(BINDINFO, szCustomVerb)+sizeof(void*);
    if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szCustomVerb) {
        size = (lstrlenW(pcbiSrc->szCustomVerb)+1)*sizeof(WCHAR);
        pcbiDest->szCustomVerb = CoTaskMemAlloc(size);
        if(!pcbiDest->szCustomVerb) {
            CoTaskMemFree(pcbiDest->szExtraInfo);
            ReleaseStgMedium(&pcbiDest->stgmedData);
            return E_OUTOFMEMORY;
        }
        memcpy(pcbiDest->szCustomVerb, pcbiSrc->szCustomVerb, size);
    }
 
    size = FIELD_OFFSET(BINDINFO, securityAttributes)+sizeof(SECURITY_ATTRIBUTES);
    if(pcbiDest->cbSize >= size)
        memset(&pcbiDest->securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
 
    if(pcbiSrc->pUnk)
        IUnknown_AddRef(pcbiDest->pUnk);
 
    return S_OK;
}

Referenced by InternetBindInfo_GetBindInfo().

CopyStgMedium()

HRESULT WINAPI CopyStgMedium	(	const STGMEDIUM *	src,
		STGMEDIUM *	dst
	)

Definition at line 597 of file urlmon_main.c.

{
    TRACE("(%p %p)\n", src, dst);
 
    if(!src || !dst)
        return E_POINTER;
 
    *dst = *src;
 
    switch(dst->tymed) {
    case TYMED_NULL:
        break;
    case TYMED_FILE:
        if(src->u.lpszFileName && !src->pUnkForRelease) {
            DWORD size = (lstrlenW(src->u.lpszFileName)+1)*sizeof(WCHAR);
            dst->u.lpszFileName = CoTaskMemAlloc(size);
            if(!dst->u.lpszFileName)
                return E_OUTOFMEMORY;
            memcpy(dst->u.lpszFileName, src->u.lpszFileName, size);
        }
        break;
    case TYMED_ISTREAM:
        if(dst->u.pstm)
            IStream_AddRef(dst->u.pstm);
        break;
    case TYMED_ISTORAGE:
        if(dst->u.pstg)
            IStorage_AddRef(dst->u.pstg);
        break;
    case TYMED_HGLOBAL:
        if(dst->u.hGlobal) {
            SIZE_T size = GlobalSize(src->u.hGlobal);
            char *src_ptr, *dst_ptr;
 
            dst->u.hGlobal = GlobalAlloc(GMEM_FIXED, size);
            if(!dst->u.hGlobal)
                return E_OUTOFMEMORY;
            dst_ptr = GlobalLock(dst->u.hGlobal);
            src_ptr = GlobalLock(src->u.hGlobal);
            memcpy(dst_ptr, src_ptr, size);
            GlobalUnlock(src_ptr);
            GlobalUnlock(dst_ptr);
        }
        break;
    default:
        FIXME("Unimplemented tymed %d\n", src->tymed);
    }
 
    if(dst->pUnkForRelease)
        IUnknown_AddRef(dst->pUnkForRelease);
 
    return S_OK;
}

Referenced by CopyBindInfo().

CreateAsyncBindCtx()

HRESULT WINAPI CreateAsyncBindCtx	(	DWORD	reserved,
		IBindStatusCallback *	callback,
		IEnumFORMATETC *	format,
		IBindCtx **	pbind
	)

Definition at line 899 of file bindctx.c.

{
    IBindCtx *bindctx;
    HRESULT hres;
 
    TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind);
 
    if(!pbind || !callback)
        return E_INVALIDARG;
 
    hres = CreateBindCtx(0, &bindctx);
    if(FAILED(hres))
        return hres;
 
    hres = init_bindctx(bindctx, 0, callback, format);
    if(FAILED(hres)) {
        IBindCtx_Release(bindctx);
        return hres;
    }
 
    *pbind = bindctx;
    return S_OK;
}

Referenced by BindAsyncMoniker(), download_to_cache(), download_url(), hlink_frame_navigate(), install_codebase(), MimeHtmlProtocol_Start(), navigate_bsc(), navigate_new_window(), start_binding(), test_BindToObject(), test_BindToStorage(), test_CreateAsyncBindCtx(), test_ReportResult(), test_StdURLMoniker(), and URLDownloadToFileW().

CreateAsyncBindCtxEx()

HRESULT WINAPI CreateAsyncBindCtxEx	(	IBindCtx *	ibind,
		DWORD	options,
		IBindStatusCallback *	callback,
		IEnumFORMATETC *	format,
		IBindCtx **	pbind,
		DWORD	reserved
	)

Definition at line 929 of file bindctx.c.

{
    AsyncBindCtx *ret;
    IBindCtx *bindctx;
    HRESULT hres;
 
    TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved);
 
    if(!pbind)
        return E_INVALIDARG;
 
    if(reserved)
        WARN("reserved=%d\n", reserved);
 
    if(ibind) {
        IBindCtx_AddRef(ibind);
        bindctx = ibind;
    }else {
        hres = CreateBindCtx(0, &bindctx);
        if(FAILED(hres))
            return hres;
    }
 
    ret = heap_alloc(sizeof(AsyncBindCtx));
 
    ret->IBindCtx_iface.lpVtbl = &AsyncBindCtxVtbl;
    ret->ref = 1;
    ret->bindctx = bindctx;
 
    hres = init_bindctx(&ret->IBindCtx_iface, options, callback, format);
    if(FAILED(hres)) {
        IBindCtx_Release(&ret->IBindCtx_iface);
        return hres;
    }
 
    *pbind = &ret->IBindCtx_iface;
    return S_OK;
}

Referenced by load_doc_mon().

CreateFormatEnumerator()

HRESULT WINAPI CreateFormatEnumerator	(	UINT	cfmtetc,
		FORMATETC *	rgfmtetc,
		IEnumFORMATETC **	ppenumfmtetc
	)

Definition at line 177 of file format.c.

{
    TRACE("(%d %p %p)\n", cfmtetc, rgfmtetc, ppenumfmtetc);
 
    if(!ppenumfmtetc)
        return E_INVALIDARG;
    if(!cfmtetc)
        return E_FAIL;
 
    *ppenumfmtetc = EnumFORMATETC_Create(cfmtetc, rgfmtetc, 0);
    return S_OK;
}

Referenced by RegisterDefaultAcceptHeaders(), test_CreateFormatEnum(), and test_RegisterFormatEnumerator().

CreateIUriBuilder()

HRESULT WINAPI CreateIUriBuilder	(	IUri *	pIUri,
		DWORD	dwFlags,
		DWORD_PTR	dwReserved,
		IUriBuilder **	ppIUriBuilder
	)

Definition at line 6353 of file uri.c.

{
    UriBuilder *ret;
 
    TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
 
    if(!ppIUriBuilder)
        return E_POINTER;
 
    ret = heap_alloc_zero(sizeof(UriBuilder));
    if(!ret)
        return E_OUTOFMEMORY;
 
    ret->IUriBuilder_iface.lpVtbl = &UriBuilderVtbl;
    ret->ref = 1;
 
    if(pIUri) {
        Uri *uri;
 
        if((uri = get_uri_obj(pIUri))) {
            if(!uri->create_flags) {
                heap_free(ret);
                return E_UNEXPECTED;
            }
            IUri_AddRef(pIUri);
            ret->uri = uri;
 
            if(uri->has_port)
                /* Windows doesn't set 'has_port' to TRUE in this case. */
                ret->port = uri->port;
 
        } else {
            heap_free(ret);
            *ppIUriBuilder = NULL;
            FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri, dwFlags,
                (DWORD)dwReserved, ppIUriBuilder);
            return E_NOTIMPL;
        }
    }
 
    *ppIUriBuilder = &ret->IUriBuilder_iface;
    return S_OK;
}

Referenced by ensure_uri_builder(), get_uri_nofrag(), nsURI_GetPrePath(), UriBuilderFactory_CreateInitializedIUriBuilder(), and UriBuilderFactory_CreateIUriBuilder().

CreateUri()

HRESULT WINAPI CreateUri	(	LPCWSTR	pwzURI,
		DWORD	dwFlags,
		DWORD_PTR	dwReserved,
		IUri **	ppURI
	)

Definition at line 5700 of file uri.c.

{
    const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME|
        Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE|
        Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES|
        Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI|
        Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH;
    Uri *ret;
    HRESULT hr;
    parse_data data;
 
    TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
 
    if(!ppURI)
        return E_INVALIDARG;
 
    if(!pwzURI) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Check for invalid flags. */
    if(has_invalid_flag_combination(dwFlags)) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Currently unsupported. */
    if(dwFlags & ~supported_flags)
        FIXME("Ignoring unsupported flag(s) %x\n", dwFlags & ~supported_flags);
 
    hr = Uri_Construct(NULL, (void**)&ret);
    if(FAILED(hr)) {
        *ppURI = NULL;
        return hr;
    }
 
    /* Explicitly set the default flags if it doesn't cause a flag conflict. */
    apply_default_flags(&dwFlags);
 
    /* Pre process the URI, unless told otherwise. */
    if(!(dwFlags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI))
        ret->raw_uri = pre_process_uri(pwzURI);
    else
        ret->raw_uri = SysAllocString(pwzURI);
 
    if(!ret->raw_uri) {
        heap_free(ret);
        return E_OUTOFMEMORY;
    }
 
    memset(&data, 0, sizeof(parse_data));
    data.uri = ret->raw_uri;
 
    /* Validate and parse the URI into its components. */
    if(!parse_uri(&data, dwFlags)) {
        /* Encountered an unsupported or invalid URI */
        IUri_Release(&ret->IUri_iface);
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Canonicalize the URI. */
    hr = canonicalize_uri(&data, ret, dwFlags);
    if(FAILED(hr)) {
        IUri_Release(&ret->IUri_iface);
        *ppURI = NULL;
        return hr;
    }
 
    ret->create_flags = dwFlags;
 
    *ppURI = &ret->IUri_iface;
    return S_OK;
}

Referenced by AsyncInstallDistributionUnit(), BindProtocol_Start(), CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetGetSecurityUrlEx(), create_uri(), CreateUriWithFragment(), CreateURLMonikerEx(), FileProtocol_Start(), FtpProtocol_Start(), get_security_id_for_url(), GopherProtocol_Start(), HttpProtocol_Start(), map_url_to_zone(), MkProtocol_Start(), and URLMoniker_Load().

CreateUriFromMultiByteString()

HRESULT WINAPI CreateUriFromMultiByteString	(	LPCSTR	,
		DWORD	,
		DWORD	,
		DWORD	,
		DWORD_PTR	,
		IUri **
	)

CreateUriWithFragment()

HRESULT WINAPI CreateUriWithFragment	(	LPCWSTR	pwzURI,
		LPCWSTR	pwzFragment,
		DWORD	dwFlags,
		DWORD_PTR	dwReserved,
		IUri **	ppURI
	)

Definition at line 5795 of file uri.c.

{
    HRESULT hres;
    TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, (DWORD)dwReserved, ppURI);
 
    if(!ppURI)
        return E_INVALIDARG;
 
    if(!pwzURI) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Check if a fragment should be appended to the URI string. */
    if(pwzFragment) {
        WCHAR *uriW;
        DWORD uri_len, frag_len;
        BOOL add_pound;
 
        /* Check if the original URI already has a fragment component. */
        if(StrChrW(pwzURI, '#')) {
            *ppURI = NULL;
            return E_INVALIDARG;
        }
 
        uri_len = lstrlenW(pwzURI);
        frag_len = lstrlenW(pwzFragment);
 
        /* If the fragment doesn't start with a '#', one will be added. */
        add_pound = *pwzFragment != '#';
 
        if(add_pound)
            uriW = heap_alloc((uri_len+frag_len+2)*sizeof(WCHAR));
        else
            uriW = heap_alloc((uri_len+frag_len+1)*sizeof(WCHAR));
 
        if(!uriW)
            return E_OUTOFMEMORY;
 
        memcpy(uriW, pwzURI, uri_len*sizeof(WCHAR));
        if(add_pound)
            uriW[uri_len++] = '#';
        memcpy(uriW+uri_len, pwzFragment, (frag_len+1)*sizeof(WCHAR));
 
        hres = CreateUri(uriW, dwFlags, 0, ppURI);
 
        heap_free(uriW);
    } else
        /* A fragment string wasn't specified, so just forward the call. */
        hres = CreateUri(pwzURI, dwFlags, 0, ppURI);
 
    return hres;
}

CreateURLMoniker()

HRESULT WINAPI CreateURLMoniker	(	IMoniker *	pmkContext,
		LPCWSTR	szURL,
		IMoniker **	ppmk
	)

Definition at line 732 of file umon.c.

{
    return CreateURLMonikerEx(pmkContext, szURL, ppmk, URL_MK_LEGACY);
}

Referenced by create_doc_from_url(), create_moniker(), generate_moniker(), hlink_frame_navigate(), IHlink_fnSetStringReference(), MimeHtmlProtocol_Start(), MimeOleObjectFromMoniker(), MkParseDisplayNameEx(), OleLoadPicturePath(), perform_test(), PersistStreamInit_InitNew(), PersistStreamInit_Load(), PHBindHost_CreateMoniker(), run_js_script(), setup_edit_mode(), test_BindToObject(), test_BindToStorage(), test_BindToStorage_fail(), test_create(), test_CreateURLMoniker(), test_HTMLDocument_http(), test_MimeOleObjectFromMoniker(), test_ReportResult(), URLDownloadToFileW(), and URLStartDownload().

CreateURLMonikerEx()

HRESULT WINAPI CreateURLMonikerEx	(	IMoniker *	pmkContext,
		LPCWSTR	szURL,
		IMoniker **	ppmk,
		DWORD	dwFlags
	)

Definition at line 616 of file umon.c.

{
    IUri *uri, *base_uri = NULL;
    URLMoniker *obj;
    HRESULT hres;
 
    TRACE("(%p, %s, %p, %08x)\n", pmkContext, debugstr_w(szURL), ppmk, dwFlags);
 
    if (ppmk)
        *ppmk = NULL;
 
    if (!szURL || !ppmk)
        return E_INVALIDARG;
 
    if(dwFlags >= ARRAY_SIZE(create_flags_map)) {
        FIXME("Unsupported flags %x\n", dwFlags);
        return E_INVALIDARG;
    }
 
    if(pmkContext) {
        IUriContainer *uri_container;
 
        hres = IMoniker_QueryInterface(pmkContext, &IID_IUriContainer, (void**)&uri_container);
        if(SUCCEEDED(hres)) {
            hres = IUriContainer_GetIUri(uri_container, &base_uri);
            IUriContainer_Release(uri_container);
            if(FAILED(hres))
                return hres;
        }
    }
 
    if(base_uri) {
        hres = CoInternetCombineUrlEx(base_uri, szURL, combine_flags_map[dwFlags], &uri, 0);
        IUri_Release(base_uri);
    }else {
        hres = CreateUri(szURL, Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|create_flags_map[dwFlags], 0, &uri);
    }
    if(FAILED(hres))
        return hres;
 
    hres = create_moniker(uri, &obj);
    IUri_Release(uri);
    if(FAILED(hres))
    return hres;
 
    *ppmk = &obj->IMoniker_iface;
    return S_OK;
}

Referenced by CreateURLMoniker().

CreateURLMonikerEx2()

HRESULT WINAPI CreateURLMonikerEx2	(	IMoniker *	pmkContext,
		IUri *	pUri,
		IMoniker **	ppmk,
		DWORD	dwFlags
	)

Definition at line 668 of file umon.c.

{
    IUri *context_uri = NULL, *uri;
    IUriContainer *uri_container;
    URLMoniker *ret;
    HRESULT hres;
 
    TRACE("(%p %p %p %x)\n", pmkContext, pUri, ppmk, dwFlags);
 
    if (ppmk)
        *ppmk = NULL;
 
    if (!pUri || !ppmk)
        return E_INVALIDARG;
 
    if(dwFlags >= ARRAY_SIZE(create_flags_map)) {
        FIXME("Unsupported flags %x\n", dwFlags);
        return E_INVALIDARG;
    }
 
    if(pmkContext) {
        hres = IMoniker_QueryInterface(pmkContext, &IID_IUriContainer, (void**)&uri_container);
        if(SUCCEEDED(hres)) {
            hres = IUriContainer_GetIUri(uri_container, &context_uri);
            if(FAILED(hres))
                context_uri = NULL;
            IUriContainer_Release(uri_container);
        }
    }
 
    if(context_uri) {
        hres = CoInternetCombineIUri(context_uri, pUri, combine_flags_map[dwFlags], &uri, 0);
        IUri_Release(context_uri);
        if(FAILED(hres))
            return hres;
    }else {
        uri = pUri;
        IUri_AddRef(uri);
    }
 
    hres = create_moniker(uri, &ret);
    IUri_Release(uri);
    if(FAILED(hres))
        return hres;
 
    *ppmk = &ret->IMoniker_iface;
    return S_OK;
}

Referenced by async_open(), bind_script_to_text(), create_moniker_from_url(), download_to_cache(), super_navigate(), and TargetFramePriv2_AggregatedNavigation2().

DEFINE_GUID() [1/13]

DEFINE_GUID	(	CLSID_CdlProtocol	,
		0x3dd53d40	,
		0x7b8b	,
		0x11D0	,
		0xb0	,
		0x13	,
		0x00	,
		0xaa	,
		0x00	,
		0x59	,
		0xce	,
		0x02
	)

DEFINE_GUID() [2/13]

DEFINE_GUID	(	CLSID_DeCompMimeFilter	,
		0x8f6b0360	,
		0xb80d	,
		0x11d0	,
		0xa9	,
		0xb3	,
		0x00	,
		0x60	,
		0x97	,
		0x94	,
		0x23	,
		0x11
	)

DEFINE_GUID() [3/13]

DEFINE_GUID	(	CLSID_FileProtocol	,
		0x79EAC9E7	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [4/13]

DEFINE_GUID	(	CLSID_FtpProtocol	,
		0x79EAC9E3	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [5/13]

DEFINE_GUID	(	CLSID_GopherProtocol	,
		0x79EAC9E4	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [6/13]

DEFINE_GUID	(	CLSID_HttpProtocol	,
		0x79EAC9E2	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [7/13]

DEFINE_GUID	(	CLSID_HttpSProtocol	,
		0x79EAC9E5	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [8/13]

DEFINE_GUID	(	CLSID_InternetSecurityManager	,
		0x7b8a2d94	,
		0x0ac9	,
		0x11d1	,
		0x89	,
		0x6c	,
		0x00	,
		0xc0	,
		0x4f	,
		0xB6	,
		0xbf	,
		0xc4
	)

DEFINE_GUID() [9/13]

DEFINE_GUID	(	CLSID_InternetZoneManager	,
		0x7B8A2D95	,
		0x0AC9	,
		0x11D1	,
		0x89	,
		0x6C	,
		0x00	,
		0xC0	,
		0x4F	,
		0xB6	,
		0xBF	,
		0xC4
	)

DEFINE_GUID() [10/13]

DEFINE_GUID	(	CLSID_MkProtocol	,
		0x79EAC9E6	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [11/13]

DEFINE_GUID	(	CLSID_StdURLMoniker	,
		0x79EAC9E0	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [12/13]

DEFINE_GUID	(	IID_IAsyncBindCtx	,
		0x79EAC9D4	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

DEFINE_GUID() [13/13]

DEFINE_GUID	(	IID_IAsyncMoniker	,
		0x79EAC9D3	,
		0xBAF9	,
		0x11CE	,
		0x8C	,
		0x82	,
		0x00	,
		0xAA	,
		0x00	,
		0x4B	,
		0xA9	,
		0x0B
	)

FaultInIEFeature()

HRESULT WINAPI FaultInIEFeature	(	HWND	hwnd,
		uCLSSPEC *	pClassSpec,
		QUERYCONTEXT *	pQuery,
		DWORD	flags
	)

Definition at line 540 of file urlmon_main.c.

{
    FIXME("%p %p %p %08x\n", hwnd, pClassSpec, pQuery, flags);
    return E_NOTIMPL;
}

FindMimeFromData()

HRESULT WINAPI FindMimeFromData	(	LPBC	pBC,
		LPCWSTR	pwzUrl,
		LPVOID	pBuffer,
		DWORD	cbSize,
		LPCWSTR	pwzMimeProposed,
		DWORD	dwMimeFlags,
		LPWSTR *	ppwzMimeOut,
		DWORD	dwReserved
	)

Definition at line 680 of file mimefilter.c.

{
    TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize,
            debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved);
 
    if(dwMimeFlags)
        WARN("dwMimeFlags=%08x\n", dwMimeFlags);
    if(dwReserved)
        WARN("dwReserved=%d\n", dwReserved);
 
    /* pBC seems to not be used */
 
    if(!ppwzMimeOut || (!pwzUrl && !pBuffer))
        return E_INVALIDARG;
 
    if(pwzMimeProposed || pBuffer)
        return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, pwzUrl, ppwzMimeOut);
 
    return find_mime_from_url(pwzUrl, ppwzMimeOut);
}

Referenced by ITSProtocol_Start(), MkProtocol_StartEx(), ProtocolSinkHandler_ReportData(), read_stream_data(), and ResProtocol_Start().

GetClassFileOrMime()

HRESULT WINAPI GetClassFileOrMime	(	LPBC	pBC,
		LPCWSTR	pszFilename,
		LPVOID	pBuffer,
		DWORD	cbBuffer,
		LPCWSTR	pszMimeType,
		DWORD	dwReserved,
		CLSID *	pclsid
	)

Definition at line 720 of file urlmon_main.c.

{
    FIXME("(%p, %s, %p, %d, %s, 0x%08x, %p): stub\n", pBC, debugstr_w(pszFilename), pBuffer,
            cbBuffer, debugstr_w(pszMimeType), dwReserved, pclsid);
    return E_NOTIMPL;
}

GetSoftwareUpdateInfo()

HRESULT WINAPI GetSoftwareUpdateInfo	(	LPCWSTR	szDistUnit,
		LPSOFTDISTINFO	psdi
	)

Definition at line 963 of file umon.c.

{
    FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );
    return E_FAIL;
}

HlinkGoBack()

HRESULT WINAPI HlinkGoBack

(

IUnknown *

)

HlinkGoForward()

HRESULT WINAPI HlinkGoForward

(

IUnknown *

)

HlinkNavigateMoniker()

HRESULT WINAPI HlinkNavigateMoniker	(	IUnknown *	,
		IMoniker *
	)

HlinkNavigateString()

HRESULT WINAPI HlinkNavigateString	(	IUnknown *	pUnk,
		LPCWSTR	szTarget
	)

Definition at line 953 of file umon.c.

{
    TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
    return HlinkSimpleNavigateToString( 
               szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
}

HlinkSimpleNavigateToMoniker()

HRESULT WINAPI HlinkSimpleNavigateToMoniker	(	IMoniker *	pmkTarget,
		LPCWSTR	szLocation,
		LPCWSTR	szTargetFrameName,
		IUnknown *	pUnk,
		IBindCtx *	pbc,
		IBindStatusCallback *	pbsc,
		DWORD	grfHLNF,
		DWORD	dwReserved
	)

Definition at line 901 of file umon.c.

{
    LPWSTR target;
    HRESULT hres;
 
    TRACE("\n");
 
    hres = IMoniker_GetDisplayName(pmkTarget, pbc, 0, &target);
    if(hres == S_OK)
        hres = HlinkSimpleNavigateToString( target, szLocation, szTargetFrameName,
                                            pUnk, pbc, pbsc, grfHLNF, dwReserved );
    CoTaskMemFree(target);
 
    return hres;
}

HlinkSimpleNavigateToString()

HRESULT WINAPI HlinkSimpleNavigateToString	(	LPCWSTR	szTarget,
		LPCWSTR	szLocation,
		LPCWSTR	szTargetFrameName,
		IUnknown *	pUnk,
		IBindCtx *	pbc,
		IBindStatusCallback *	pbsc,
		DWORD	grfHLNF,
		DWORD	dwReserved
	)

Definition at line 922 of file umon.c.

{
    FIXME("%s %s %s %p %p %p %u %u partial stub\n", debugstr_w( szTarget ), debugstr_w( szLocation ),
          debugstr_w( szTargetFrameName ), pUnk, pbc, pbsc, grfHLNF, dwReserved);
 
    /* undocumented: 0 means HLNF_OPENINNEWWINDOW*/
    if (!grfHLNF) grfHLNF = HLNF_OPENINNEWWINDOW;
 
    if (grfHLNF == HLNF_OPENINNEWWINDOW)
    {
        SHELLEXECUTEINFOW sei;
        static const WCHAR openW[] = { 'o', 'p', 'e', 'n', 0 };
 
        memset(&sei, 0, sizeof(sei));
        sei.cbSize = sizeof(sei);
        sei.lpVerb = openW;
        sei.nShow = SW_SHOWNORMAL;
        sei.fMask = SEE_MASK_FLAG_NO_UI | SEE_MASK_NO_CONSOLE;
        sei.lpFile = szTarget;
 
        if (ShellExecuteExW(&sei)) return S_OK;
    }
 
    return E_NOTIMPL;
}

Referenced by general_dlg_proc(), HlinkNavigateString(), HlinkSimpleNavigateToMoniker(), and user_notice_dlg_proc().

IsAsyncMoniker()

HRESULT WINAPI IsAsyncMoniker

(

IMoniker *

pmk

)

Definition at line 740 of file umon.c.

{
    IUnknown *am;
    
    TRACE("(%p)\n", pmk);
    if(!pmk)
        return E_INVALIDARG;
    if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
        IUnknown_Release(am);
        return S_OK;
    }
    return S_FALSE;
}

IsLoggingEnabledA()

BOOL WINAPI IsLoggingEnabledA

(

LPCSTR

url

)

Definition at line 749 of file urlmon_main.c.

{
    FIXME("(%s)\n", debugstr_a(url));
    return FALSE;
}

IsLoggingEnabledW()

BOOL WINAPI IsLoggingEnabledW

(

LPCWSTR

url

)

Definition at line 758 of file urlmon_main.c.

{
    FIXME("(%s)\n", debugstr_w(url));
    return FALSE;
}

IsValidURL()

HRESULT WINAPI IsValidURL	(	LPBC	pBC,
		LPCWSTR	szURL,
		DWORD	dwReserved
	)

Definition at line 525 of file urlmon_main.c.

{
    FIXME("(%p, %s, %d): stub\n", pBC, debugstr_w(szURL), dwReserved);
 
    if (dwReserved || !szURL)
        return E_INVALIDARG;
 
    return S_OK;
}

Referenced by test_IsValidURL().

MkParseDisplayNameEx()

HRESULT WINAPI MkParseDisplayNameEx	(	IBindCtx *	,
		LPCWSTR	,
		ULONG *	,
		IMoniker **
	)

ObtainUserAgentString()

HRESULT WINAPI ObtainUserAgentString	(	DWORD	dwOption,
		LPSTR	pcszUAOut,
		DWORD *	cbSize
	)

Definition at line 725 of file session.c.

{
    DWORD size;
    HRESULT hres = E_FAIL;
 
    TRACE("(%d %p %p)\n", dwOption, pcszUAOut, cbSize);
 
    if(!pcszUAOut || !cbSize)
        return E_INVALIDARG;
 
    EnterCriticalSection(&session_cs);
 
    ensure_useragent();
    if(user_agent) {
        size = WideCharToMultiByte(CP_ACP, 0, user_agent, -1, NULL, 0, NULL, NULL);
 
        if(size <= *cbSize) {
            WideCharToMultiByte(CP_ACP, 0, user_agent, -1, pcszUAOut, *cbSize, NULL, NULL);
            hres = S_OK;
        }else {
            hres = E_OUTOFMEMORY;
        }
 
        *cbSize = size;
    }
 
    LeaveCriticalSection(&session_cs);
    return hres;
}

Referenced by OmNavigator_get_appVersion(), OmNavigator_get_userAgent(), and test_navigator().

RegisterBindStatusCallback()

HRESULT WINAPI RegisterBindStatusCallback	(	IBindCtx *	pbc,
		IBindStatusCallback *	pbsc,
		IBindStatusCallback **	ppbsc,
		DWORD	dwReserved
	)

Definition at line 615 of file bindctx.c.

{
    BindStatusCallback *holder;
    IBindStatusCallback *bsc, *prev = NULL;
    HRESULT hres;
 
    TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
 
    if (!pbc || !pbsc)
        return E_INVALIDARG;
 
    bsc = bsch_from_bctx(pbc);
    if(bsc) {
        hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
        if(SUCCEEDED(hres)) {
            if(ppbscPrevious) {
                IBindStatusCallback_AddRef(holder->callback);
                *ppbscPrevious = holder->callback;
            }
 
            set_callback(holder, pbsc);
 
            IBindStatusCallback_Release(bsc);
            IBindStatusCallbackEx_Release(&holder->IBindStatusCallbackEx_iface);
            return S_OK;
        }else {
            prev = bsc;
        }
 
        IBindCtx_RevokeObjectParam(pbc, bscb_holderW);
    }
 
    hres = wrap_callback(pbsc, &bsc);
    if(SUCCEEDED(hres)) {
        hres = IBindCtx_RegisterObjectParam(pbc, bscb_holderW, (IUnknown*)bsc);
        IBindStatusCallback_Release(bsc);
    }
    if(FAILED(hres)) {
        if(prev)
            IBindStatusCallback_Release(prev);
        return hres;
    }
 
    if(ppbscPrevious)
        *ppbscPrevious = prev;
    return S_OK;
}

Referenced by bind_url(), HlinkResolveMonikerForData(), IHlink_fnNavigate(), init_bindctx(), PersistMoniker_Load(), start_binding(), test_BindToStorage(), test_RegisterBindStatusCallback(), and URLStartDownload().

RegisterFormatEnumerator()

HRESULT WINAPI RegisterFormatEnumerator	(	LPBC	pBC,
		IEnumFORMATETC *	pEFetc,
		DWORD	reserved
	)

Definition at line 194 of file format.c.

{
    TRACE("(%p %p %d)\n", pBC, pEFetc, reserved);
 
    if(reserved)
        WARN("reserved != 0\n");
 
    if(!pBC || !pEFetc)
        return E_INVALIDARG;
 
    return IBindCtx_RegisterObjectParam(pBC, wszEnumFORMATETC, (IUnknown*)pEFetc);
}

Referenced by RegisterDefaultAcceptHeaders(), and test_RegisterFormatEnumerator().

ReleaseBindInfo()

void WINAPI ReleaseBindInfo

(

BINDINFO *

pbindinfo

)

Definition at line 572 of file urlmon_main.c.

{
    DWORD size;
 
    TRACE("(%p)\n", pbindinfo);
 
    if(!pbindinfo || !(size = pbindinfo->cbSize))
        return;
 
    CoTaskMemFree(pbindinfo->szExtraInfo);
    ReleaseStgMedium(&pbindinfo->stgmedData);
 
    if(offsetof(BINDINFO, szExtraInfo) < size)
        CoTaskMemFree(pbindinfo->szCustomVerb);
 
    if(pbindinfo->pUnk && offsetof(BINDINFO, pUnk) < size)
        IUnknown_Release(pbindinfo->pUnk);
 
    memset(pbindinfo, 0, size);
    pbindinfo->cbSize = size;
}

Referenced by AboutProtocol_Start(), Binding_Release(), DownloadBSC_GetBindInfo(), FileProtocol_StartEx(), internet_status_callback(), ITSProtocol_Start(), MkProtocol_StartEx(), navigate_hlink(), ResProtocol_Start(), and test_bsc_marshaling().

RevokeBindStatusCallback()

HRESULT WINAPI RevokeBindStatusCallback	(	LPBC	,
		IBindStatusCallback *
	)

RevokeFormatEnumerator()

HRESULT WINAPI RevokeFormatEnumerator	(	LPBC	pbc,
		IEnumFORMATETC *	pEFetc
	)

Definition at line 210 of file format.c.

{
    TRACE("(%p %p)\n", pbc, pEFetc);
 
    if(!pbc)
        return E_INVALIDARG;
 
    return IBindCtx_RevokeObjectParam(pbc, wszEnumFORMATETC);
}

Referenced by test_RegisterFormatEnumerator().

URLDownloadToCacheFileA()

HRESULT WINAPI URLDownloadToCacheFileA	(	LPUNKNOWN	lpUnkCaller,
		LPCSTR	szURL,
		LPSTR	szFileName,
		DWORD	dwBufLength,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	pBSC
	)

Definition at line 819 of file umon.c.

{
    LPWSTR url = NULL, file_name = NULL;
    int len;
    HRESULT hres;
 
    TRACE("(%p %s %p %d %d %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
            dwBufLength, dwReserved, pBSC);
 
    if(szURL) {
        len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
        url = heap_alloc(len*sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, len);
    }
 
    if(szFileName)
        file_name = heap_alloc(dwBufLength*sizeof(WCHAR));
 
    hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
            dwReserved, pBSC);
 
    if(SUCCEEDED(hres) && file_name)
        WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
 
    heap_free(url);
    heap_free(file_name);
 
    return hres;
}

URLDownloadToCacheFileW()

HRESULT WINAPI URLDownloadToCacheFileW	(	LPUNKNOWN	lpUnkCaller,
		LPCWSTR	szURL,
		LPWSTR	szFileName,
		DWORD	dwBufLength,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	pBSC
	)

Definition at line 853 of file umon.c.

{
    WCHAR cache_path[MAX_PATH + 1];
    FILETIME expire, modified;
    HRESULT hr;
    LPWSTR ext;
 
    static WCHAR header[] = {
        'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
        'O','K','\\','r','\\','n','\\','r','\\','n',0
    };
 
    TRACE("(%p, %s, %p, %d, %d, %p)\n", lpUnkCaller, debugstr_w(szURL),
          szFileName, dwBufLength, dwReserved, pBSC);
 
    if (!szURL || !szFileName)
        return E_INVALIDARG;
 
    ext = PathFindExtensionW(szURL);
 
    if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
        return E_FAIL;
 
    hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
    if (FAILED(hr))
        return hr;
 
    expire.dwHighDateTime = 0;
    expire.dwLowDateTime = 0;
    modified.dwHighDateTime = 0;
    modified.dwLowDateTime = 0;
 
    if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
                              header, sizeof(header), NULL, NULL))
        return E_FAIL;
 
    if (lstrlenW(cache_path) > dwBufLength)
        return E_OUTOFMEMORY;
 
    lstrcpyW(szFileName, cache_path);
 
    return S_OK;
}

Referenced by msi_download_file(), and URLDownloadToCacheFileA().

URLDownloadToFileA()

HRESULT WINAPI URLDownloadToFileA	(	LPUNKNOWN	pCaller,
		LPCSTR	szURL,
		LPCSTR	szFileName,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 482 of file download.c.

{
    LPWSTR urlW, file_nameW;
    HRESULT hres;
 
    TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB);
 
    urlW = heap_strdupAtoW(szURL);
    file_nameW = heap_strdupAtoW(szFileName);
 
    hres = URLDownloadToFileW(pCaller, urlW, file_nameW, dwReserved, lpfnCB);
 
    heap_free(urlW);
    heap_free(file_nameW);
 
    return hres;
}

URLDownloadToFileW()

HRESULT WINAPI URLDownloadToFileW	(	LPUNKNOWN	pCaller,
		LPCWSTR	szURL,
		LPCWSTR	szFileName,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 427 of file download.c.

{
    DownloadBSC *callback;
    IUnknown *unk;
    IMoniker *mon;
    IBindCtx *bindctx;
    HRESULT hres;
 
    TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
 
    if(pCaller)
        FIXME("pCaller not supported\n");
 
    hres = DownloadBSC_Create(lpfnCB, szFileName, &callback);
    if(FAILED(hres))
        return hres;
 
    hres = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bindctx);
    IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
    if(FAILED(hres))
        return hres;
 
    hres = CreateURLMoniker(NULL, szURL, &mon);
    if(FAILED(hres)) {
        IBindCtx_Release(bindctx);
        return hres;
    }
 
    hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
    IMoniker_Release(mon);
    IBindCtx_Release(bindctx);
 
    if(unk)
        IUnknown_Release(unk);
 
    return hres == MK_S_ASYNCHRONOUS ? S_OK : hres;
}

Referenced by download_proc(), test_URLDownloadToFile(), test_URLDownloadToFile_abort(), URLDownloadToCacheFileW(), and URLDownloadToFileA().

UrlMkGetSessionOption()

HRESULT WINAPI UrlMkGetSessionOption	(	DWORD	dwOption,
		LPVOID	pBuffer,
		DWORD	dwBufferLength,
		DWORD *	pdwBufferLength,
		DWORD	dwReserved
	)

Definition at line 622 of file session.c.

{
    TRACE("(%x, %p, %d, %p)\n", dwOption, pBuffer, dwBufferLength, pdwBufferLength);
 
    if(dwReserved)
        WARN("dwReserved = %d\n", dwReserved);
 
    switch(dwOption) {
    case URLMON_OPTION_USERAGENT: {
        HRESULT hres = E_OUTOFMEMORY;
        DWORD size;
 
        if(!pdwBufferLength)
            return E_INVALIDARG;
 
        EnterCriticalSection(&session_cs);
 
        ensure_useragent();
        if(user_agent) {
            size = WideCharToMultiByte(CP_ACP, 0, user_agent, -1, NULL, 0, NULL, NULL);
            *pdwBufferLength = size;
            if(size <= dwBufferLength) {
                if(pBuffer)
                    WideCharToMultiByte(CP_ACP, 0, user_agent, -1, pBuffer, size, NULL, NULL);
                else
                    hres = E_INVALIDARG;
            }
        }
 
        LeaveCriticalSection(&session_cs);
 
        /* Tests prove that we have to return E_OUTOFMEMORY on success. */
        return hres;
    }
    case URLMON_OPTION_URL_ENCODING: {
        DWORD encoding = 0;
 
        if(!pBuffer || dwBufferLength < sizeof(DWORD) || !pdwBufferLength)
            return E_INVALIDARG;
 
        if(!get_url_encoding(HKEY_CURRENT_USER, &encoding))
            get_url_encoding(HKEY_LOCAL_MACHINE, &encoding);
 
        *pdwBufferLength = sizeof(DWORD);
        *(DWORD*)pBuffer = encoding ? URL_ENCODING_DISABLE_UTF8 : URL_ENCODING_ENABLE_UTF8;
        return S_OK;
    }
    default:
        FIXME("unsupported option %x\n", dwOption);
    }
 
    return E_INVALIDARG;
}

UrlMkSetSessionOption()

HRESULT WINAPI UrlMkSetSessionOption	(	DWORD	dwOption,
		LPVOID	pBuffer,
		DWORD	dwBufferLength,
		DWORD	Reserved
	)

Definition at line 680 of file session.c.

{
    TRACE("(%x %p %x)\n", dwOption, pBuffer, dwBufferLength);
 
    switch(dwOption) {
    case URLMON_OPTION_USERAGENT: {
        LPWSTR new_user_agent;
        char *buf = pBuffer;
        DWORD len, size;
 
        if(!pBuffer || !dwBufferLength)
            return E_INVALIDARG;
 
        for(len=0; len<dwBufferLength && buf[len]; len++);
 
        TRACE("Setting user agent %s\n", debugstr_an(buf, len));
 
        size = MultiByteToWideChar(CP_ACP, 0, buf, len, NULL, 0);
        new_user_agent = heap_alloc((size+1)*sizeof(WCHAR));
        if(!new_user_agent)
            return E_OUTOFMEMORY;
        MultiByteToWideChar(CP_ACP, 0, buf, len, new_user_agent, size);
        new_user_agent[size] = 0;
 
        EnterCriticalSection(&session_cs);
 
        heap_free(user_agent);
        user_agent = new_user_agent;
        update_user_agent(user_agent);
 
        LeaveCriticalSection(&session_cs);
        break;
    }
    default:
        FIXME("Unknown option %x\n", dwOption);
        return E_INVALIDARG;
    }
 
    return S_OK;
}

Referenced by test_user_agent().

URLOpenBlockingStreamA()

HRESULT WINAPI URLOpenBlockingStreamA	(	LPUNKNOWN	pCaller,
		LPCSTR	szURL,
		LPSTREAM *	ppStream,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 258 of file umstream.c.

{
    LPWSTR szURLW;
    int len;
    HRESULT hr;
 
    TRACE("(%p, %s, %p, 0x%x, %p)\n", pCaller, szURL, ppStream, dwReserved, lpfnCB);
 
    if (!szURL || !ppStream)
        return E_INVALIDARG;
 
    len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
    szURLW = heap_alloc(len * sizeof(WCHAR));
    if (!szURLW)
    {
        *ppStream = NULL;
        return E_OUTOFMEMORY;
    }
    MultiByteToWideChar(CP_ACP, 0, szURL, -1, szURLW, len);
 
    hr = URLOpenBlockingStreamW(pCaller, szURLW, ppStream, dwReserved, lpfnCB);
 
    heap_free(szURLW);
 
    return hr;
}

URLOpenBlockingStreamW()

HRESULT WINAPI URLOpenBlockingStreamW	(	LPUNKNOWN	pCaller,
		LPCWSTR	szURL,
		LPSTREAM *	ppStream,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 290 of file umstream.c.

{
    ProxyBindStatusCallback blocking_bsc;
 
    TRACE("(%p, %s, %p, 0x%x, %p)\n", pCaller, debugstr_w(szURL), ppStream,
          dwReserved, lpfnCB);
 
    if (!szURL || !ppStream)
        return E_INVALIDARG;
 
    blocking_bsc.IBindStatusCallback_iface.lpVtbl = &BlockingBindStatusCallbackVtbl;
    blocking_bsc.pBSC = lpfnCB;
 
    return URLStartDownload(szURL, ppStream, &blocking_bsc.IBindStatusCallback_iface);
}

Referenced by test_URLOpenBlockingStreamW(), and URLOpenBlockingStreamA().

URLOpenPullStreamA()

HRESULT WINAPI URLOpenPullStreamA	(	LPUNKNOWN	,
		LPCSTR	,
		DWORD	,
		LPBINDSTATUSCALLBACK
	)

URLOpenPullStreamW()

HRESULT WINAPI URLOpenPullStreamW	(	LPUNKNOWN	,
		LPCWSTR	,
		DWORD	,
		LPBINDSTATUSCALLBACK
	)

URLOpenStreamA()

HRESULT WINAPI URLOpenStreamA	(	LPUNKNOWN	pCaller,
		LPCSTR	szURL,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 311 of file umstream.c.

{
    LPWSTR szURLW;
    int len;
    HRESULT hr;
 
    TRACE("(%p, %s, 0x%x, %p)\n", pCaller, szURL, dwReserved, lpfnCB);
 
    if (!szURL)
        return E_INVALIDARG;
 
    len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
    szURLW = heap_alloc(len * sizeof(WCHAR));
    if (!szURLW)
        return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, szURL, -1, szURLW, len);
 
    hr = URLOpenStreamW(pCaller, szURLW, dwReserved, lpfnCB);
 
    heap_free(szURLW);
 
    return hr;
}

URLOpenStreamW()

HRESULT WINAPI URLOpenStreamW	(	LPUNKNOWN	pCaller,
		LPCWSTR	szURL,
		DWORD	dwReserved,
		LPBINDSTATUSCALLBACK	lpfnCB
	)

Definition at line 339 of file umstream.c.

{
    HRESULT hr;
    ProxyBindStatusCallback async_bsc;
    IStream *pStream;
 
    TRACE("(%p, %s, 0x%x, %p)\n", pCaller, debugstr_w(szURL), dwReserved,
          lpfnCB);
 
    if (!szURL)
        return E_INVALIDARG;
 
    async_bsc.IBindStatusCallback_iface.lpVtbl = &AsyncBindStatusCallbackVtbl;
    async_bsc.pBSC = lpfnCB;
 
    hr = URLStartDownload(szURL, &pStream, &async_bsc.IBindStatusCallback_iface);
    if (SUCCEEDED(hr) && pStream)
        IStream_Release(pStream);
 
    return hr;
}

Referenced by test_URLOpenStreamW(), and URLOpenStreamA().

Variable Documentation

dwAdState

DWORD dwAdState

Definition at line 1592 of file urlmon.idl.

dwAdvertisedVersionLS

DWORD dwAdvertisedVersionLS

Definition at line 1601 of file urlmon.idl.

dwAdvertisedVersionMS

DWORD dwAdvertisedVersionMS

Definition at line 1600 of file urlmon.idl.

dwFlags

DWORD dwFlags

Definition at line 1591 of file urlmon.idl.

dwInstalledVersionLS

DWORD dwInstalledVersionLS

Definition at line 1597 of file urlmon.idl.

dwInstalledVersionMS

DWORD dwInstalledVersionMS

Definition at line 1596 of file urlmon.idl.

dwReserved

DWORD dwReserved

Definition at line 1602 of file urlmon.idl.

dwUpdateVersionLS

DWORD dwUpdateVersionLS

Definition at line 1599 of file urlmon.idl.

dwUpdateVersionMS

DWORD dwUpdateVersionMS

Definition at line 1598 of file urlmon.idl.

GUID_CUSTOM_CONFIRMOBJECTSAFETY

EXTERN_C const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY

Definition at line 2097 of file urlmon.idl.

LPSOFTDISTINFO

* LPSOFTDISTINFO

Definition at line 1603 of file urlmon.idl.

SOFTDISTINFO

SOFTDISTINFO

Definition at line 1603 of file urlmon.idl.

szAbstract

LPWSTR szAbstract

Definition at line 1594 of file urlmon.idl.

szHREF

LPWSTR szHREF

Definition at line 1595 of file urlmon.idl.

szTitle

LPWSTR szTitle

Definition at line 1593 of file urlmon.idl.

Referenced by EventDetailsCtrl().