OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/inetcore/urlmon/trans/urlmon.cxx

2366 lines
60 KiB
C++
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1994.
//
// File: urlmon.cxx
//
// Contents: contains URL moniker implementation
//
// Classes:
//
// Functions:
//
// History: 12-11-95 JohannP (Johann Posch) Created
//
//----------------------------------------------------------------------------
#include <trans.h>
#ifndef unix
#include "..\iapp\curl.hxx"
#else
#include "../iapp/curl.hxx"
#endif /* unix */
#include "urlmk.hxx"
PerfDbgTag(tagCUrlMon, "Urlmon", "Log CUrlMon", DEB_URLMON);
BOOL IsOInetProtocol(IBindCtx *pbc, LPCWSTR wzProtocol);
// prototypes of helper functions (used by RelativePathTo)
CUrlMon *CreateEmptyPathUrlMon();
HRESULT HrCreateCUrlFromUrlStr(LPCWSTR pwzUrl, BOOL fParseUrl, CUrl **ppUrl);
HRESULT HrCreateCUrlFromUrlMon(LPMONIKER pmkUrl, BOOL fParseUrl, CUrl **ppUrl);
HRESULT HrGetRelativePath(LPSTR lpszBase, LPSTR lpszOther, DWORD dwProto, LPSTR lpszHost,LPSTR lpszRelPath);
// #define URLMON_RELPATHTO_PARSE_QUERY_PARAMS
#ifdef URLMON_RELPATHTO_PARSE_QUERY_PARAMS
// These are helper routines used by RelativePathTo to deal with the Query
// and Params sub-strings of a URL, according to rfc 1808.
// These routines are not enabled because ComposeWith does not deal with
// these sub-strings in any special way, and we want RelativePathTo to be
// compatible with ComposeWith.
void ParseUrlQuery(LPSTR pszURL, LPSTR *ppszQuery);
void ParseUrlParams(LPSTR pszURL, LPSTR *ppszParams);
void AddParamsAndQueryToRelPath(LPSTR szRelPath,
LPSTR pszParamsBase, LPSTR pszParamsOther,
LPSTR pszQueryBase, LPSTR pszQueryOther);
#endif // URLMON_RELPATHTO_PARSE_QUERY_PARAMS
// Macros for Double-Byte Character Support (DBCS)
#if 1
// Beware of double evaluation
#define IncLpch(sz) ((sz)=CharNext((sz)))
#define DecLpch(szStart, sz) ((sz)=CharPrev ((szStart),(sz)))
#else
#define IncLpch(sz) (++(sz))
#define DecLpch(szStart,sz) (--(sz))
#endif
CUrlMon::CUrlMon(LPWSTR pszUrl) : _CRefs()
{
DEBUG_ENTER((DBG_MONIKER,
None,
"CUrlMon::CUrlMon",
"this=%#x",
this
));
_pwzUrl = pszUrl;
DllAddRef();
DEBUG_LEAVE(0);
}
CUrlMon::~CUrlMon()
{
DEBUG_ENTER((DBG_MONIKER,
None,
"CUrlMon::~CUrlMon",
"this=%#x",
this
));
if (_pwzUrl)
{
delete [] _pwzUrl;
}
DllRelease();
DEBUG_LEAVE(0);
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::QueryInterface
//
// Synopsis:
//
// Arguments: [riid] --
// [ppvObj] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::QueryInterface(REFIID riid, void **ppvObj)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IUnknown::QueryInterface",
"this=%#x, %#x, %#x",
this, &riid, ppvObj
));
VDATEPTROUT(ppvObj, void *);
HRESULT hr = NOERROR;
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::QueryInterface");
if ( riid == IID_IUnknown
|| riid == IID_IMoniker
|| riid == IID_IAsyncMoniker
|| riid == IID_IPersist
|| riid == IID_IPersistStream)
{
*ppvObj = this;
}
else if (riid == IID_IROTData)
{
*ppvObj = (void*)(IROTData *) this;
}
else if (riid == IID_IMarshal)
{
*ppvObj = (void*) (IMarshal *) this;
}
else
{
*ppvObj = NULL;
hr = E_NOINTERFACE;
}
if (hr == NOERROR)
{
AddRef();
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::QueryInterface (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CUrlMon::AddRef
//
// Synopsis:
//
// Arguments: [ULONG] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CUrlMon::AddRef(void)
{
DEBUG_ENTER((DBG_MONIKER,
Dword,
"CUrlMon::IUnknown::AddRef",
"this=%#x",
this
));
LONG lRet = ++_CRefs;
PerfDbgLog1(tagCUrlMon, this, "CUrlMon::AddRef (cRefs:%ld)", lRet);
DEBUG_LEAVE(lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Function: CUrlMon::Release
//
// Synopsis:
//
// Arguments: [ULONG] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CUrlMon::Release(void)
{
DEBUG_ENTER((DBG_MONIKER,
Dword,
"CUrlMon::IUnknown::Release",
"this=%#x",
this
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Release");
LONG lRet = --_CRefs;
if (_CRefs == 0)
{
delete this;
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::Release (cRefs:%ld)", lRet);
DEBUG_LEAVE(lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::GetClassID
//
// Synopsis:
//
// Arguments: [pClassID] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::GetClassID(CLSID *pClassID)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IPersist::GetClassID",
"this=%#x, %#x",
this, pClassID
));
VDATEPTRIN(pClassID, CLSID);
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::GetClassID");
*pClassID = CLSID_StdURLMoniker;
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::GetClassID (hr:%lx)", NOERROR);
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsDirty
//
// Synopsis:
//
// Arguments: (none)
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::IsDirty()
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IPersistStream::IsDirty",
"this=%#x",
this
));
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Load
//
// Synopsis:
//
// Arguments: [pistm] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Load(IStream *pistm)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IPersistStream::Load",
"this=%#x, %#x",
this, pistm
));
VDATEIFACE(pistm);
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Load");
HRESULT hr = NOERROR;
ULONG cbLen = 0;
// Read in the new URL from the stream
hr = pistm->Read(&cbLen, sizeof(ULONG), NULL);
if ((hr == NOERROR) && (cbLen > 0))
{
LPWSTR wszUrlLocal = new WCHAR [cbLen / sizeof(WCHAR)];
DbgLog2(tagCUrlMon, this, "=== CUrlMon::Load (cbBytes:%ld, cbLen:%ld)", cbLen, cbLen / sizeof(WCHAR));
if (wszUrlLocal)
{
hr = pistm->Read(wszUrlLocal, cbLen, NULL);
DbgLog2(tagCUrlMon, this, "=== CUrlMon::Load (cbLen:%ld, hr:%lx)", cbLen, hr);
if (hr == NOERROR)
{
// If we already had a URL, delete it
if (_pwzUrl)
{
delete [] _pwzUrl;
}
_pwzUrl = wszUrlLocal;
}
else
{
delete [] wszUrlLocal;
}
}
}
PerfDbgLog2(tagCUrlMon, this, "-CUrlMon::Load (hr:%lx, szUrl:%ws)", hr, _pwzUrl?_pwzUrl:L"");
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Save
//
// Synopsis:
//
// Arguments: [pistm] --
// [fClearDirty] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Save(IStream *pistm, BOOL fClearDirty)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IPersistStream::Save",
"this=%#x, %#x, %B",
this, pistm, fClearDirty
));
VDATEIFACE(pistm);
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Save");
UrlMkAssert((_pwzUrl));
HRESULT hr = E_FAIL;
if (_pwzUrl)
{
ULONG cbLen = (wcslen(_pwzUrl) + 1) * sizeof(WCHAR);
DbgLog2(tagCUrlMon, this, "=== CUrlMon::Save (cbLen:%ld, cbLen:%ld)", cbLen, cbLen / sizeof(WCHAR));
// Write the URL to the stream
hr = pistm->Write(&cbLen, sizeof(ULONG), NULL);
if (hr == NOERROR)
{
hr = pistm->Write(_pwzUrl, cbLen, NULL);
}
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::Save (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::GetSizeMax
//
// Synopsis:
//
// Arguments: [pcbSize] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IPersistStream::GetSizeMax",
"this=%#x, %#x",
this, pcbSize
));
VDATEPTROUT (pcbSize, ULONG);
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::GetSizeMax");
UrlMkAssert((_pwzUrl));
UrlMkAssert((pcbSize));
// length of url
ULISet32(*pcbSize, ((wcslen(_pwzUrl) + 1) * sizeof(WCHAR)) + sizeof(ULONG));
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::GetSizeMax (hr:%lx)", NOERROR);
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::BindToObject
//
// Synopsis:
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [riidRes] --
// [ppvRes] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::BindToObject(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riidRes, void **ppvRes)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::BindToObject",
"this=%#x, %#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, &riidRes, ppvRes
));
VDATEPTROUT(ppvRes, LPVOID);
VDATEIFACE(pbc);
PerfDbgLog2(tagCUrlMon, this, "+CUrlMon::BindToObject (IBindCtx:%lx, pmkToLeft:%lx)", pbc, pmkToLeft);
*ppvRes = NULL;
if (pmkToLeft)
{
VDATEIFACE(pmkToLeft);
}
HRESULT hr;
CLSID clsid;
BIND_OPTS bindopts;
CBinding *pCBdg = NULL;
CBSC *pBSC = NULL;
WCHAR wzURL[MAX_URL_SIZE + 1];
*ppvRes = NULL;
// Step 1: check if the object is runining
// if so QI for the requested interface
//
{
IRunningObjectTable *pROT = NULL;
// check if the object is already running
hr = IsRunningROT(pbc, pmkToLeft, &pROT);
if (hr == NOERROR)
{
// object is running
IUnknown *pUnk = NULL;
// object is running
// get the object and Qi for the requested interface
hr = pROT->GetObject(this, &pUnk);
if (SUCCEEDED(hr))
{
hr = pUnk->QueryInterface(riidRes, ppvRes);
pUnk->Release();
}
pROT->Release();
goto End;
}
else
{
if (pROT)
{
pROT->Release();
}
if (FAILED(hr))
{
// did not get ROT!!
goto End;
}
}
}
// Step 2: get the bind options from the bind context
bindopts.cbStruct = sizeof(BIND_OPTS);
hr = pbc->GetBindOptions(&bindopts);
if (FAILED(hr))
{
goto End;
}
// Step 3: create a CBinding and releated objects and
// start a transaction
hr = StartBinding(TRUE, pbc, pmkToLeft, riidRes, ppvRes);
End:
PerfDbgLog2(tagCUrlMon, this, "-CUrlMon::BindToObject (hr:%lx, ppvobj:%lx)",
hr, (hr == S_OK) ? *ppvRes : NULL);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::BindToStorage
//
// Synopsis:
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [riid] --
// [ppvObj] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::BindToStorage(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **ppvObj)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::BindToStorage",
"this=%#x, %#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, &riid, ppvObj
));
VDATEPTROUT(ppvObj, LPVOID);
VDATEIFACE(pbc);
PerfDbgLog2(tagCUrlMon, this, "+CUrlMon::BindToStorage (IBindCtx:%lx, pmkToLeft:%lx)", pbc, pmkToLeft);
if (pmkToLeft)
{
VDATEIFACE(pmkToLeft);
}
CBSC *pBSC = NULL;
HRESULT hr;
BIND_OPTS bindopts;
CBinding *pCBdg = NULL;
FORMATETC fetc;
WCHAR wzURL[MAX_URL_SIZE + 1];
IID iidLocal = riid;
*ppvObj = NULL;
#if DBG==1
{
LPOLESTR pszStr;
StringFromCLSID(riid, &pszStr);
DbgLog2(tagCUrlMon, this, "CUrlMon::BindToStorage (szUrl:%ws)(iid:%ws)",
GetUrl(), pszStr);
delete pszStr;
}
#endif
hr = StartBinding(FALSE, pbc, pmkToLeft, riid, ppvObj);
PerfDbgLog2(tagCUrlMon, this, "-CUrlMon::BindToStorage (hr:%lx, ppvobj:%lx)",
hr, (hr == S_OK) ? *ppvObj : NULL);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::StartBinding
//
// Synopsis: sets up the cbinding and starts the transaction
//
// Arguments: [fBindToObject] --
// [pbc] --
// [pmkToLeft] --
// [riid] --
// [ppvObj] --
//
// Returns:
//
// History: 8-20-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::StartBinding(BOOL fBindToObject, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **ppvObj)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::StartBinding",
"this=%#x, %B, %#x, %#x, %#x, %#x",
this, fBindToObject, pbc, pmkToLeft, &riid, ppvObj
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::StartBinding");
HRESULT hr = NOERROR;
WCHAR wzURL[MAX_URL_SIZE + 1];
CBSC *pBSC = NULL;
CBinding *pCBdg = NULL;
BOOL fUnknown = FALSE;
do
{
// No need to canonicalize URL here. This should have already been done
// by CreateURLMoniker.
hr = ConstructURL(pbc, NULL, pmkToLeft, GetUrl(), wzURL, sizeof(wzURL),CU_NO_CANONICALIZE);
if (hr != NOERROR)
{
break;
}
// moved to CBinding::StartBinding
// BUG-WORK
//if (!IsOInetProtocol(pbc, wzURL))
//{
// hr = INET_E_UNKNOWN_PROTOCOL;
// break;
//}
// check if a BSC is registerted if not register our own one - for Office!
IUnknown *pUnk = NULL;
hr = GetObjectParam(pbc, REG_BSCB_HOLDER, IID_IBindStatusCallback, (IUnknown**)&pUnk);
if ((hr == NOERROR) && pUnk)
{
// release - nothing to do
pUnk->Release();
}
else
{
hr = NOERROR;
if (fBindToObject)
{
pBSC = new CBSC(Medium_Unknown);
}
else
{
Medium medium = (riid == IID_IStorage) ? Medium_Storage : Medium_Stream;
pBSC = new CBSC(medium);
if (medium == Medium_Storage)
{
fUnknown = TRUE;
}
}
// no IBSC - create our own one and register
if (pBSC)
{
hr = RegisterBindStatusCallback(pbc, pBSC, 0, 0);
}
else
{
hr = E_OUTOFMEMORY;
}
}
if (hr != NOERROR)
{
break;
}
// Create a CBinding object
hr = CBinding::Create(NULL, wzURL, pbc, (fUnknown) ? IID_IUnknown : riid, fBindToObject, &pCBdg);
if (hr != NOERROR)
{
break;
}
UrlMkAssert((pCBdg != NULL));
if (fBindToObject)
{
pCBdg->SetMoniker(this);
}
{
LPWSTR pwzExtra = NULL;
// start the transaction now
hr = pCBdg->StartBinding(wzURL, pbc, (fUnknown) ? IID_IUnknown : riid, fBindToObject, &pwzExtra, ppvObj);
if (pwzExtra)
{
SetUrl(GetUrl(), pwzExtra);
}
}
if( hr == INET_E_USE_EXTEND_BINDING )
{
// rosebud
hr = NOERROR;
// there is no need to return IBinding to client, se should
// free it here.
pCBdg->Release();
break;
}
if (SUCCEEDED(hr))
{
if (pCBdg->IsAsyncTransaction() == FALSE)
{
hr = pCBdg->CompleteTransaction();
if (SUCCEEDED(hr))
{
// retrieve the requested object
if (pBSC)
{
hr = pBSC->GetRequestedObject(pbc, ppvObj);
}
else
{
hr = pCBdg->GetRequestedObject(pbc, (IUnknown **)ppvObj);
}
}
}
else
{
hr = pCBdg->GetRequestedObject(pbc, (IUnknown **)ppvObj);
}
}
// in case the transaction could not be started,
// the following release we terminate all releated objects
pCBdg->Release();
break;
} while (TRUE);
if (pBSC)
{
RevokeBindStatusCallback(pbc, pBSC);
pBSC->Release();
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::StartBinding (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Reduce
//
// Synopsis:
//
// Arguments: [pbc] --
// [dwReduceHowFar] --
// [IMoniker] --
// [ppmkReduced] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Reduce(IBindCtx *pbc, DWORD dwReduceHowFar,
IMoniker **ppmkToLeft,IMoniker **ppmkReduced)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::Reduce",
"this=%#x, %#x, %#x, %#x, %#x",
this, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Reduce");
// There is nothing we can do to reduce our moniker
*ppmkReduced = this;
AddRef();
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::Reduce (hr:%lx)", MK_S_REDUCED_TO_SELF);
DEBUG_LEAVE(MK_S_REDUCED_TO_SELF);
return MK_S_REDUCED_TO_SELF;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::ComposeWith
//
// Synopsis:
//
// Arguments: [pmkRight] --
// [fOnlyIfNotGeneric] --
// [ppmkComposite] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::ComposeWith(IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::ComposeWith",
"this=%#x, %#x, %B, %#x",
this, pmkRight, fOnlyIfNotGeneric, ppmkComposite
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::ComposeWith");
VDATEIFACE(pmkRight);
VDATEPTROUT(ppmkComposite, LPMONIKER);
HRESULT hr = NOERROR;
DWORD dwMnk = 0;
LPWSTR wzURLRelative = NULL;
*ppmkComposite = NULL;
pmkRight->IsSystemMoniker(&dwMnk);
if (dwMnk == MKSYS_URLMONIKER)
{
hr = pmkRight->GetDisplayName(NULL, NULL, &wzURLRelative);
if (hr == NOERROR)
{
hr = CreateURLMoniker(this, wzURLRelative, ppmkComposite);
}
}
else if (fOnlyIfNotGeneric)
{
hr = MK_E_NEEDGENERIC;
}
else
{
hr = CreateGenericComposite(this, pmkRight, ppmkComposite);
}
if (wzURLRelative)
{
delete wzURLRelative;
}
PerfDbgLog(tagCUrlMon, this, "-CUrlMon::ComposeWith");
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Enum
//
// Synopsis:
//
// Arguments: [fForward] --
// [ppenumMoniker] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Enum(BOOL fForward, IEnumMoniker **ppenumMoniker)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::Enum",
"this=%#x, %B, %#x",
this, fForward, ppenumMoniker
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Enum");
VDATEPTROUT(ppenumMoniker, LPENUMMONIKER);
*ppenumMoniker = NULL;
PerfDbgLog(tagCUrlMon, this, "-CUrlMon::Enum (hr:0)");
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsEqual
//
// Synopsis:
//
// Arguments: [pMnkOther] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
// REVIEW: this code will not work cross process. What is the
// correct implementation?
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::IsEqual(IMoniker *pMnkOther)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::IsEqual",
"this=%#x, %#x",
this, pMnkOther
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::IsEqual");
HRESULT hr = S_FALSE;
VDATEIFACE(pMnkOther);
// We only worry about URL monikers
if (this == pMnkOther)
{
// same object
hr = NOERROR;
}
else if (IsUrlMoniker(pMnkOther))
{
LPWSTR szDispName = NULL;
// The other moniker is a URL moniker.
// get and compare the display names
hr = pMnkOther->GetDisplayName(NULL, NULL, &szDispName);
// Compare the URL's
if (hr == NOERROR)
{
UrlMkAssert((_pwzUrl));
UrlMkAssert((szDispName));
hr = wcscmp(_pwzUrl, szDispName) ? S_FALSE : NOERROR;
}
if (szDispName)
{
delete szDispName;
}
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::IsEqual (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Hash
//
// Synopsis:
//
// Arguments: [pdwHash] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// 9-02-95 AdriaanC (Adriaan Canter)
// Modified to use Pearson's Method
//
// Notes:
// 32 bit hashing operator for IMoniker::Hash(DWORD*)
//
// Method based upon "Fast Hashing of Variable Length Text Strings" ,
// by Peter K. Pearson, Communications of the ACM,
// June 1990 Vol. 33, Number 6. pp 677-680.
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Hash(DWORD* pdwHash)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::Hash",
"this=%#x, %#x",
this, pdwHash
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Hash");
UrlMkAssert((_pwzUrl != NULL));
HRESULT hr = NOERROR;
UCHAR c0, c1, c2, c3;
UCHAR* idx = (UCHAR*) _pwzUrl;
static UCHAR T[256] =
{
1, 14,110, 25, 97,174,132,119,138,170,125,118, 27,233,140, 51,
87,197,177,107,234,169, 56, 68, 30, 7,173, 73,188, 40, 36, 65,
49,213,104,190, 57,211,148,223, 48,115, 15, 2, 67,186,210, 28,
12,181,103, 70, 22, 58, 75, 78,183,167,238,157,124,147,172,144,
176,161,141, 86, 60, 66,128, 83,156,241, 79, 46,168,198, 41,254,
178, 85,253,237,250,154,133, 88, 35,206, 95,116,252,192, 54,221,
102,218,255,240, 82,106,158,201, 61, 3, 89, 9, 42,155,159, 93,
166, 80, 50, 34,175,195,100, 99, 26,150, 16,145, 4, 33, 8,189,
121, 64, 77, 72,208,245,130,122,143, 55,105,134, 29,164,185,194,
193,239,101,242, 5,171,126, 11, 74, 59,137,228,108,191,232,139,
6, 24, 81, 20,127, 17, 91, 92,251,151,225,207, 21, 98,113,112,
84,226, 18,214,199,187, 13, 32, 94,220,224,212,247,204,196, 43,
249,236, 45,244,111,182,153,136,129, 90,217,202, 19,165,231, 71,
230,142, 96,227, 62,179,246,114,162, 53,160,215,205,180, 47,109,
44, 38, 31,149,135, 0,216, 52, 63, 23, 37, 69, 39,117,146,184,
163,200,222,235,248,243,219, 10,152,131,123,229,203, 76,120,209
};
c0 = T[*idx];
c1 = T[*idx+1 % 256];
c2 = T[*idx+2 % 256];
c3 = T[*idx+3 % 256];
#ifndef unix
while ((WCHAR) *(WCHAR*) ++idx != L'\0')
#else
// We are trying to cast a UCHAR as a WCHAR in the windows code. We will need
// to handle alignments correctly here, as we cant randomly cast
// a UCHAR * to a WCHAR *.
WCHAR wend = 0;
while (memcmp(++idx,&wend,sizeof(WCHAR)))
#endif /* unix */
{
c0 = T[c0^*idx]; c1 = T[c1^*idx];
c2 = T[c2^*idx]; c3 = T[c3^*idx];
}
*(((UCHAR*) pdwHash)+0) = c0;
*(((UCHAR*) pdwHash)+1) = c1;
*(((UCHAR*) pdwHash)+2) = c2;
*(((UCHAR*) pdwHash)+3) = c3;
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::Hash (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsRunning
//
// Synopsis:
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [pmkNewlyRunning] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::IsRunning(IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::IsRunning",
"this=%#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, pmkNewlyRunning
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::IsRunning");
HRESULT hr = NOERROR;
VDATEIFACE(pbc);
if (pmkToLeft)
VDATEIFACE(pmkToLeft);
if (pmkNewlyRunning)
VDATEIFACE(pmkNewlyRunning);
// This implementation was shamelessly stolen from the OLE sources.
if (pmkToLeft == NULL)
{
if (pmkNewlyRunning != NULL)
{
hr = pmkNewlyRunning->IsEqual(this);
}
else
{
hr = IsRunningROT(pbc, NULL, NULL);
}
}
else
{
UrlMkAssert((FALSE));
hr = S_FALSE;
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::IsRunning (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::GetTimeOfLastChange
//
// Synopsis:
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [pFileTime] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::GetTimeOfLastChange(IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::GetTimeOfLastChange",
"this=%#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, pFileTime
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::GetTimeOfLastChange");
VDATEIFACE(pbc);
if (pmkToLeft)
{
VDATEIFACE(pmkToLeft);
}
VDATEPTROUT(pFileTime, FILETIME);
HRESULT hr = MK_E_UNAVAILABLE;
IRunningObjectTable *pROT;
hr = pbc->GetRunningObjectTable(&pROT);
if (SUCCEEDED(hr))
{
hr = pROT->GetTimeOfLastChange(this, pFileTime);
pROT->Release();
}
else
{
hr = MK_E_UNAVAILABLE;
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::GetTimeOfLastChange (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::Inverse
//
// Synopsis:
//
// Arguments: [ppmk] --
//
// Returns:
//
// History: 1-16-96 JohannP (Johann Posch) Created
//
// Notes: urlmon does not have aninverse
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::Inverse(IMoniker **ppmk)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::Inverse",
"this=%#x, %#x",
this, ppmk
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::Inverse");
VDATEPTROUT(ppmk, LPMONIKER);
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::Inverse (hr:%lx)", MK_E_NOINVERSE);
DEBUG_LEAVE(MK_E_NOINVERSE);
return MK_E_NOINVERSE;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::CommonPrefixWith
//
// Synopsis:
//
// Arguments: [pmkOther] --
// [ppmkPrefix] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::CommonPrefixWith(IMoniker *pmkOther, IMoniker **ppmkPrefix)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::CommonPrefixWith",
"this=%#x, %#x, %#x",
this, pmkOther, ppmkPrefix
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::CommonPrefixWith");
HRESULT hr = E_NOTIMPL;
VDATEPTROUT(ppmkPrefix, LPMONIKER);
*ppmkPrefix = NULL;
VDATEIFACE(pmkOther);
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::CommonPrefixWith (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::RelativePathTo
//
// Synopsis:
//
// Arguments: [pmkOther] --
// [ppmkRelPath] --
//
// Returns:
//
// History: 1-16-96 JohannP (Johann Posch) Created
// 8-20-96 ClarG (Clarence Glasse) Implemented
//
// Notes: Code is based on composition algorithm in rfc 1808 (this code does
// the reverse of that).
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::RelativePathTo(IMoniker *pmkOther, IMoniker **ppmkRelPath)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::RelativePathTo",
"this=%#x, %#x, %#x",
this, pmkOther, ppmkRelPath
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::RelativePathTo");
HRESULT hr = NOERROR;
VDATEPTROUT(ppmkRelPath, LPMONIKER);
*ppmkRelPath = NULL;
VDATEIFACE(pmkOther);
CUrl *pUrlThis = NULL;
CUrl *pUrlOther = NULL;
LPSTR pch = NULL;
LPSTR pszQueryThis = NULL;
LPSTR pszQueryOther = NULL;
LPSTR pszParamsThis = NULL;
LPSTR pszParamsOther = NULL;
char szRelPath[MAX_URL_SIZE + 1];
if (!_pwzUrl)
{
hr = MK_E_NOTBINDABLE;
goto End;
}
if (IsEqual(pmkOther) == S_OK)
{
// we are equal to pmkOther, so create an empty path URL moniker.
if ((*ppmkRelPath = CreateEmptyPathUrlMon()) == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
// CUrlmon has refcount of 1 now
}
else if (IsUrlMoniker(pmkOther))
{
if ((hr = HrCreateCUrlFromUrlMon(pmkOther, TRUE, &pUrlOther)) != NOERROR)
{
if (hr == MK_E_SYNTAX)
hr = MK_E_NOTBINDABLE;
goto End;
}
if ((hr = HrCreateCUrlFromUrlStr(_pwzUrl, TRUE, &pUrlThis)) != NOERROR)
{
if (hr == MK_E_SYNTAX)
hr = MK_E_NOTBINDABLE;
goto End;
}
// Each URL has been parsed into its separate components.
// Now compute the relative path.
if ((pUrlThis->_dwProto == DLD_PROTOCOL_NONE) ||
(pUrlOther->_dwProto == DLD_PROTOCOL_NONE))
{
// Unrecognized protocol; return MK_S_HIM or MK_E_NOTBINDABLE
if (pUrlThis->_pszProtocol[0] && pUrlOther->_pszProtocol[0])
{
*ppmkRelPath = pmkOther;
pmkOther->AddRef();
hr = MK_S_HIM;
}
else
{
hr = MK_E_NOTBINDABLE;
}
goto End;
}
// if the scheme and net_loc portion of the url are not equal,
// return MK_S_HIM
if ((pUrlThis->_dwProto != pUrlOther->_dwProto) ||
(lstrcmpi(pUrlThis->_pszServerName, pUrlOther->_pszServerName) != 0) ||
(pUrlThis->_ipPort != pUrlOther->_ipPort) ||
(lstrcmpi(pUrlThis->_pszUserName, pUrlOther->_pszUserName) != 0) ||
(lstrcmpi(pUrlThis->_pszPassword, pUrlOther->_pszPassword) != 0))
{
*ppmkRelPath = pmkOther;
pmkOther->AddRef();
hr = MK_S_HIM;
goto End;
}
#ifdef URLMON_RELPATHTO_PARSE_QUERY_PARAMS
// parse the query and params info
ParseUrlQuery(pUrlThis->_pszObject, &pszQueryThis);
ParseUrlQuery(pUrlOther->_pszObject, &pszQueryOther);
ParseUrlParams(pUrlThis->_pszObject, &pszParamsThis);
ParseUrlParams(pUrlOther->_pszObject, &pszParamsOther);
#endif // URLMON_RELPATHTO_PARSE_QUERY_PARAMS
// compute the relative path
hr = HrGetRelativePath(
pUrlThis->_pszObject, pUrlOther->_pszObject,
pUrlThis->_dwProto, pUrlThis->_pszServerName, szRelPath);
if (FAILED(hr))
goto End;
#ifdef URLMON_RELPATHTO_PARSE_QUERY_PARAMS
// append the appropriate query and params info
AddParamsAndQueryToRelPath(
szRelPath, pszParamsThis, pszParamsOther, pszQueryThis, pszQueryOther);
#endif // URLMON_RELPATHTO_PARSE_QUERY_PARAMS
if (szRelPath[0])
{
HRESULT hr2 = NOERROR;
WCHAR wzObjRel[MAX_URL_SIZE + 1];
A2W(szRelPath, wzObjRel, MAX_URL_SIZE);
hr2 = CreateURLMoniker(NULL, wzObjRel, ppmkRelPath);
if (FAILED(hr2))
hr = hr2;
}
else
{
*ppmkRelPath = CreateEmptyPathUrlMon();
if (!(*ppmkRelPath))
hr = E_OUTOFMEMORY;
}
}
else
{
hr = MonikerRelativePathTo(this, pmkOther, ppmkRelPath, TRUE);
}
End:
if (pUrlThis)
delete pUrlThis;
if (pUrlOther)
delete pUrlOther;
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::RelativePathTo (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::GetDisplayName
//
// Synopsis:
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [ppszDisplayName] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::GetDisplayName(IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::GetDisplayName",
"this=%#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, ppszDisplayName
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::GetDisplayName");
HRESULT hr = NOERROR;
VDATEPTROUT(ppszDisplayName, LPSTR);
*ppszDisplayName = NULL;
if (pbc)
{
VDATEIFACE(pbc);
}
if (pmkToLeft)
{
VDATEIFACE(pmkToLeft);
}
*ppszDisplayName = OLESTRDuplicate(_pwzUrl);
if (*ppszDisplayName == NULL)
{
hr = E_OUTOFMEMORY;
}
PerfDbgLog2(tagCUrlMon, this, "-CUrlMon::GetDisplayName (hr:%lx) [%ws]", hr, *ppszDisplayName ? *ppszDisplayName : L"");
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::ParseDisplayName
//
// Synopsis:
//
// Arguments: [IMoniker] --
// [pmkToLeft] --
// [ULONG] --
// [IMoniker] --
// [ppmkOut] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::ParseDisplayName(IBindCtx *pbc,IMoniker *pmkToLeft,
LPOLESTR pozDisplayName,ULONG *pchEaten,IMoniker **ppmkOut)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::ParseDisplayName",
"this=%#x, %#x, %#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, pozDisplayName, pchEaten, ppmkOut
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::ParseDisplayName");
HRESULT hr;
WCHAR wzURL[MAX_URL_SIZE + 1];
VDATEPTROUT(ppmkOut, LPMONIKER);
*ppmkOut = NULL;
VDATEIFACE(pbc);
if (pmkToLeft) VDATEIFACE(pmkToLeft);
VDATEPTRIN(pozDisplayName, char);
VDATEPTROUT(pchEaten, ULONG);
hr = ConstructURL(pbc, this, pmkToLeft, pozDisplayName, wzURL,
sizeof(wzURL), CU_CANONICALIZE);
if (hr != NOERROR)
{
goto End;
}
if (!wcscmp(_pwzUrl, wzURL))
{
// Return ourselves if new URL is the same.
*ppmkOut = this;
AddRef();
hr = NOERROR;
}
else
{
hr = CreateURLMoniker(NULL, wzURL, ppmkOut);
}
if (hr == NOERROR)
{
// We have eaten all the characters
*pchEaten = wcslen(pozDisplayName);
}
End:
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::ParseDisplayName (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsSystemMoniker
//
// Synopsis:
//
// Arguments: [pdwMksys] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CUrlMon::IsSystemMoniker(DWORD *pdwMksys)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IMoniker::IsSystemMoniker",
"this=%#x, %#x",
this, pdwMksys
));
PerfDbgLog(tagCUrlMon, this, "CUrlMon::IsSystemMoniker");
VDATEPTROUT(pdwMksys, DWORD);
*pdwMksys = MKSYS_URLMONIKER;
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
// Delete the URL string if we have one
void CUrlMon::DeleteUrl()
{
DEBUG_ENTER((DBG_MONIKER,
None,
"CUrlMon::DeleteUrl",
"this=%#x",
this
));
if (_pwzUrl)
delete [] _pwzUrl;
_pwzUrl = NULL;
DEBUG_LEAVE(0);
}
HRESULT CUrlMon::SetUrl(LPWSTR pwzUrl, LPWSTR pwzExtra)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::SetUrl",
"this=%#x, %.80wq, %.80wq",
this, pwzUrl, pwzExtra
));
int clen;
HRESULT hr = NOERROR;
TransAssert((pwzUrl));
clen = wcslen(pwzUrl) + 1;
if (pwzExtra)
{
clen += wcslen(pwzExtra);
}
LPWSTR pwzStr = (LPWSTR) new WCHAR [clen];
if (pwzStr)
{
wcscpy(pwzStr, pwzUrl);
if (pwzExtra)
{
wcscat(pwzStr, pwzExtra);
}
if (_pwzUrl)
{
delete [] _pwzUrl;
}
_pwzUrl = pwzStr;
}
else
{
hr = E_OUTOFMEMORY;
}
DEBUG_LEAVE(hr);
return hr;
}
// Helper function for IMoniker::IsRunning and BindToObject.
// Return NOERROR if running, and S_FALSE if not.
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsRunningROT
//
// Synopsis: Checks if the moniker is running
//
// Arguments: [pbc] --
// [pmkToLeft] --
// [ppROT] --
//
// Returns:
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT CUrlMon::IsRunningROT(IBindCtx *pbc, IMoniker *pmkToLeft, IRunningObjectTable **ppROT)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"CUrlMon::IsRunningROT",
"this=%#x, %#x, %#x, %#x",
this, pbc, pmkToLeft, ppROT
));
HRESULT hr;
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::IsRunningROT");
IRunningObjectTable *pROT;
hr = pbc->GetRunningObjectTable(&pROT);
if (SUCCEEDED(hr))
{
hr = pROT->IsRunning(this);
if (ppROT != NULL && SUCCEEDED(hr))
{
*ppROT = pROT;
}
else
{
pROT->Release();
}
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::IsRunningROT (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CUrlMon::IsUrlMoniker
//
// Synopsis: Checks if pMk is a URL moniker
//
// Arguments: [pMk] -- the moniker to be checked
//
// Returns: true if moniker is URL moniker
//
// History: 1-19-96 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
BOOL CUrlMon::IsUrlMoniker(IMoniker *pMk)
{
DEBUG_ENTER((DBG_MONIKER,
Bool,
"CUrlMon::IsUrlMoniker",
"this=%#x, %#x",
this, pMk
));
PerfDbgLog(tagCUrlMon, this, "+CUrlMon::IsUrlMoniker");
BOOL fRet = FALSE;
if (pMk)
{
DWORD dwMnk = 0;
pMk->IsSystemMoniker(&dwMnk);
fRet = (dwMnk == MKSYS_URLMONIKER);
}
PerfDbgLog1(tagCUrlMon, this, "-CUrlMon::IsUrlMoniker (fRet:%d)", fRet);
DEBUG_LEAVE(fRet);
return fRet;
}
// ********** Helper Functions **********
// These functions are used by RelativePathTo
//+---------------------------------------------------------------------------
//
// Function: CreateEmptyPathUrlMon
//
// Synopsis: Create a UrlMon with empty path "", such that composing it onto
// a base UrlMon via IMoniker::ComposeWith will yield a moniker
// equal to the base UrlMon.
// We don't call CreateUrlMoniker(""), to do this because that will
// return a UrlMon with path "/". Composing such a moniker onto
// a base UrlMon out everything after the host name.
//
// Arguments: (none)
//
// Returns:
//
// History: 8-16-96 ClarG (Clarence Glasse) Created
//
// Notes:
//
//----------------------------------------------------------------------------
CUrlMon * CreateEmptyPathUrlMon()
{
DEBUG_ENTER((DBG_MONIKER,
Pointer,
"CreateEmptyPathUrlMon",
NULL
));
PerfDbgLog(tagCUrlMon, NULL, "+CreateEmptyPathUrlMon");
CUrlMon * pUMk = NULL;
LPWSTR pwzUrlEmpty = NULL;
// allocate empty string
if ((pwzUrlEmpty = new WCHAR [1]) == NULL)
{
goto End;
}
pwzUrlEmpty[0] = 0;
if ((pUMk = new CUrlMon(pwzUrlEmpty)) == NULL)
{
delete pwzUrlEmpty;
goto End;
}
// pUMk has refcount of 1 now
End:
PerfDbgLog1(tagCUrlMon, NULL, "-CreateEmptyPathUrlMon, pUMk:%lx", pUMk);
DEBUG_LEAVE(pUMk);
return pUMk;
}
//+---------------------------------------------------------------------------
//
// Function: HrCreateCUrlFromUrlMon
//
// Synopsis: Given a Url moniker pmkUrl, create a CUrl object. Assumes that
// pmkUrl is indeed a Url moniker.
//
// Arguments: [pmkUrl] -- Url moniker
// [fParseUrl] -- if TRUE, parse the URL.
// [ppUrl] -- returns created CUrl obj, which caller must delete
// when finished with it.
//
// Returns: NOERROR is successful.
//
// History: 8-16-96 ClarG (Clarence Glasse) Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT HrCreateCUrlFromUrlMon(LPMONIKER pmkUrl, BOOL fParseUrl, CUrl **ppUrl)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"HrCreateCUrlFromUrlMon",
"%#x, %B, %#x",
pmkUrl, fParseUrl, ppUrl
));
PerfDbgLog(tagCUrlMon, NULL, "+HrCreateCUrlFromUrlMon");
UrlMkAssert((pmkUrl));
UrlMkAssert((ppUrl));
HRESULT hr = NOERROR;
LPBC pbc = NULL;
LPWSTR pwzUrl = NULL;
if ((*ppUrl = new CUrl) == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
if( !(*ppUrl)->CUrlInitAll() )
{
hr = E_OUTOFMEMORY;
goto End;
}
if ((hr = CreateBindCtx(0, &pbc)) != NOERROR)
{
goto End;
}
if ((hr = pmkUrl->GetDisplayName(pbc, NULL, &pwzUrl)) != NOERROR)
{
goto End;
}
W2A(pwzUrl, (*ppUrl)->_pszBaseURL, MAX_URL_SIZE);
if (fParseUrl)
{
if (!(*ppUrl)->ParseUrl())
{
hr = MK_E_SYNTAX;
goto End;
}
}
End:
if (pbc)
pbc->Release();
if (pwzUrl)
CoTaskMemFree(pwzUrl);
if ((hr != NOERROR) && (*ppUrl != NULL))
{
delete *ppUrl;
*ppUrl = NULL;
}
PerfDbgLog1(tagCUrlMon, NULL, "-HrCreateCUrlFromUrlMon (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrCreateCUrlFromUrlStr
//
// Synopsis: Given a Url string pwzUrl, create a CUrl object.
//
// Arguments: [pwzUrl] -- Url string
// [fParseUrl] -- if TRUE, parse the URL.
// [ppUrl] -- returns created CUrl obj, which caller must delete
// when finished with it.
//
// Returns: NOERROR is successful.
//
// History: 8-16-96 ClarG (Clarence Glasse) Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT HrCreateCUrlFromUrlStr(LPCWSTR pwzUrl, BOOL fParseUrl, CUrl **ppUrl)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"HrCreateCUrlFromUrlStr",
"%.80wq, %B, %#x",
pwzUrl, fParseUrl, ppUrl
));
PerfDbgLog(tagCUrlMon, NULL, "+HrCreateCUrlFromUrlStr");
UrlMkAssert((pwzUrl));
UrlMkAssert((ppUrl));
HRESULT hr = NOERROR;
if ((*ppUrl = new CUrl) == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
if( !(*ppUrl)->CUrlInitAll() )
{
hr = E_OUTOFMEMORY;
goto End;
}
W2A(pwzUrl, (*ppUrl)->_pszBaseURL, MAX_URL_SIZE);
if (fParseUrl)
{
if (!(*ppUrl)->ParseUrl())
{
hr = MK_E_SYNTAX;
goto End;
}
}
End:
if ((hr != NOERROR) && (*ppUrl != NULL))
{
delete *ppUrl;
*ppUrl = NULL;
}
PerfDbgLog1(tagCUrlMon, NULL, "-HrCreateCUrlFromUrlStr (hr:%lx)", hr);
DEBUG_LEAVE(hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: IsSeparator
//
// Synopsis: Return TRUE if ch is a file path or url path separator char.
//
// Arguments: [ch] -- the char in question
// when finished with it.
//
// Returns: TRUE if ch is a separator char
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is taken from OLE2 file moniker code
//
//----------------------------------------------------------------------------
inline BOOL IsSeparator( char ch )
{
DEBUG_ENTER((DBG_MONIKER,
Bool,
"IsSeparator",
"%c",
ch
));
BOOL fRet = (ch == '\\' || ch == '/' || ch == ':');
DEBUG_LEAVE(fRet);
return fRet;
}
//+---------------------------------------------------------------------------
//
// Function: CountSegments
//
// Synopsis: Return the number of segments in file or url path pch.
//
// Arguments: [pch] -- the string in question.
//
// Returns: number of segments in pch
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is taken from OLE2 file moniker code
//
//----------------------------------------------------------------------------
int CountSegments ( LPSTR pch )
{
DEBUG_ENTER((DBG_MONIKER,
Int,
"CountSegments",
"%.80q",
pch
));
PerfDbgLog(tagCUrlMon, NULL, "+CountSegments");
// counts the number of pieces in a path, after the first colon, if
// there is one
int n = 0;
LPSTR pch1;
pch1 = pch;
while (*pch1 != '\0' && *pch1 != ':') IncLpch(pch1);
if (*pch1 == ':') pch = ++pch1;
while (*pch != '\0')
{
while (*pch && IsSeparator(*pch)) pch++;
if (*pch) n++;
while (*pch && (!IsSeparator(*pch))) IncLpch(pch);
}
PerfDbgLog1(tagCUrlMon, NULL, "-CountSegments (n:%ld)", n);
DEBUG_LEAVE(n);
return n;
}
//+---------------------------------------------------------------------------
//
// Function: HrGetRelativePath
//
// Synopsis: Compute and return relative path from url path
// lpszBase to url path lpszOther.
//
// Arguments: [lpszBase] -- the base path without the scheme and host info
// [lpszOther] -- the target path without the scheme and host
// [dwProto] -- DLD_PROTOCOL_XXX value, indicating the scheme
// of the urls.
// [lpszHost] -- the host name for the urls
// [lpszRelPath] -- buffer of size MAX_URL_SIZE that returns the
// relative path.
//
// Returns: NOERROR, MK_S_HIM, MK_E_NOTBINDABLE, or some other hresult.
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is based on OLE2 file moniker code
//
//----------------------------------------------------------------------------
HRESULT HrGetRelativePath(
LPSTR lpszBase, LPSTR lpszOther, DWORD dwProto, LPSTR lpszHost,
LPSTR lpszRelPath)
{
DEBUG_ENTER((DBG_MONIKER,
Hresult,
"HrGetRelativePath",
"%.80q, %.80q, %#x, %.80q, %.80q",
lpszBase, lpszOther, dwProto, lpszHost, lpszRelPath
));
PerfDbgLog(tagCUrlMon, NULL, "+HrGetRelativePath");
HRESULT hr = NOERROR;
LPSTR lpszRover;
LPSTR lpszMarker;
LPSTR lpch;
LPSTR lpchStripBaseSav = NULL;
char ch1;
char ch2;
char chStripBaseSav;
char chNull = '\0';
int i;
int cAnti;
lpszRelPath[0] = 0;
// if neither lpszBase nor lpszRelPath look like absolute url or file
// paths, return MK_E_NOTBINDALBE
if (!lpszBase[0] || !lpszOther[0])
{
hr = MK_E_NOTBINDABLE;
goto End;
}
if ((lpszBase[0] != '\\') && (lpszBase[0] != '/') && (lpszBase[1] != ':'))
{
hr = MK_E_NOTBINDABLE;
goto End;
}
if ((lpszOther[0] != '\\') && (lpszOther[0] != '/') && (lpszOther[1] != ':'))
{
hr = MK_E_NOTBINDABLE;
goto End;
}
if (lstrcmpi(lpszBase, lpszOther) == 0)
{
// if paths are equal, relative path is empty string
lpszRelPath[0] = 0;
hr = NOERROR;
goto End;
}
// if base does not end in a separator, remove its last piece
lpch = lpszBase + lstrlen(lpszBase);
for( ; ((!(IsSeparator(*lpch))) && (lpch > lpszBase)); DecLpch(lpszBase, lpch) );
if (IsSeparator(*lpch))
{
IncLpch(lpch);
lpchStripBaseSav = lpch;
chStripBaseSav = *lpch;
*lpch = '\0';
}
lpszRover = lpszBase;
lpszMarker = lpszRover;
i = 0;
lpszOther = lpszOther;
while (*lpszRover != '\0')
{
while (*lpszRover && IsSeparator(*lpszRover)) lpszRover++;
while (*lpszRover && !IsSeparator(*lpszRover)) IncLpch(lpszRover);
// the first part of the path is between m_szPath and
// lpszRover
i = (int) (lpszRover - lpszBase);
ch1 = *lpszRover;
ch2 = *(lpszOther + i);
*lpszRover = '\0';
*(lpszOther + i) = '\0';
if (lstrcmpi(lpszBase, lpszOther) == 0)
lpszMarker = lpszRover;
else
lpszRover = &chNull;
*(lpszBase + i) = ch1;
*(lpszOther + i) = ch2;
}
// common portion is from lpszBase to lpszMarker
i = (int) (lpszMarker - lpszBase);
if ((!lpszHost || !lpszHost[0]) && (i == 0))
{
lstrcpy(lpszRelPath, lpszOther);
hr = MK_S_HIM;
goto End;
}
lpszRover = lpszRelPath;
while (IsSeparator(*(lpszOther+i))) i++;
cAnti = CountSegments(lpszMarker);
while (cAnti)
{
if (dwProto != DLD_PROTOCOL_FILE)
lstrcpy(lpszRover, "../");
else
lstrcpy(lpszRover, "..\\");
lpszRover += 3;
cAnti--;
}
lstrcpy(lpszRover, lpszOther + i);
End:
if (lpchStripBaseSav)
{
*lpchStripBaseSav = chStripBaseSav;
}
PerfDbgLog2(tagCUrlMon, NULL, "-HrGetRelativePath [%s], hr:%lx", lpszRelPath?lpszRelPath:"", hr);
DEBUG_LEAVE(hr);
return hr;
}
#ifdef URLMON_RELPATHTO_PARSE_QUERY_PARAMS
//+---------------------------------------------------------------------------
//
// Function: ParseUrlQuery
//
// Synopsis: Parse the Query portion of a url
//
// Arguments: [pszURL] -- url to parse; the query portion is "removed" from
// pszURL when function returns.
// [ppszQuery] -- returns pointer to query portion of URL
//
// Returns: nothing
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is based on OLE2 file moniker code
//
//----------------------------------------------------------------------------
void ParseUrlQuery(LPSTR pszURL, LPSTR *ppszQuery)
{
DEBUG_ENTER((DBG_MONIKER,
None,
"ParseUrlQuery",
"%.80q, %#x",
pszURL, ppszQuery
));
PerfDbgLog(tagCUrlMon, NULL, "+ParseUrlQuery");
LPSTR pch = NULL;
*ppszQuery = NULL;
for (pch = pszURL; *pch; IncLpch(pch))
{
if (*pch == '?')
{
*pch = '\0';
pch++;
if (*pch)
*ppszQuery = pch;
break;
}
}
PerfDbgLog(tagCUrlMon, NULL, "-ParseUrlQuery");
DEBUG_LEAVE(0);
}
//+---------------------------------------------------------------------------
//
// Function: ParseUrlParams
//
// Synopsis: Parse the Params portion of a url
//
// Arguments: [pszURL] -- url to parse; the params portion is "removed" from
// pszURL when function returns.
// [ppszParams] -- returns pointer to params portion of URL
//
// Returns: nothing
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is based on OLE2 file moniker code
//
//----------------------------------------------------------------------------
void ParseUrlParams(LPSTR pszURL, LPSTR *ppszParams)
{
DEBUG_ENTER((DBG_MONIKER,
None,
"ParseUrlParams",
"%.80q, %#x",
pszURL, ppszParams
));
PerfDbgLog(tagCUrlMon, NULL, "+ParseUrlParams");
LPSTR pch = NULL;
*ppszParams = NULL;
for (pch = pszURL; *pch; IncLpch(pch))
{
if (*pch == ';')
{
*pch = '\0';
pch++;
if (*pch)
*ppszParams = pch;
break;
}
}
PerfDbgLog(tagCUrlMon, NULL, "-ParseUrlParams");
DEBUG_LEAVE(0);
}
//+---------------------------------------------------------------------------
//
// Function: AddParamsAndQueryToRelPath
//
// Synopsis: Given a computed relative URL path from a base to a target,
// append the appropriate Params and Query info.
//
// Arguments: [szRelPath] -- computed relative path
// [pszParamsBase] -- Params info of base URL
// [pszParamsOther] -- Params info of target URL
// [pszQueryBase] -- Query info of base URL
// [pszQueryOther] -- Query info of target URL
//
// Returns: nothing
//
// History: 8-20-96 ClarG (Clarence Glasse) Created
//
// Notes: This is based on OLE2 file moniker code
//
//----------------------------------------------------------------------------
void AddParamsAndQueryToRelPath(
LPSTR szRelPath,
LPSTR pszParamsBase, LPSTR pszParamsOther,
LPSTR pszQueryBase, LPSTR pszQueryOther)
{
DEBUG_ENTER((DBG_MONIKER,
None,
"AddParamsAndQueryToRelPath",
"%.80q, %.80q, %.80q, %.80q, %.80q",
szRelPath, pszParamsBase, pszParamsOther, pszQueryBase, pszQueryOther
));
PerfDbgLog(tagCUrlMon, NULL, "+AddParamsAndQueryToRelPath");
if (szRelPath[0])
{
if (pszParamsOther)
{
lstrcat(szRelPath, ";");
lstrcat(szRelPath, pszParamsOther);
}
if (pszQueryOther)
{
lstrcat(szRelPath, "?");
lstrcat(szRelPath, pszQueryOther);
}
}
else
{
if (pszParamsOther &&
(!pszParamsBase || (lstrcmpi(pszParamsOther, pszParamsBase) != 0)))
{
lstrcat(szRelPath, ";");
lstrcat(szRelPath, pszParamsOther);
if (pszQueryOther)
{
lstrcat(szRelPath, "?");
lstrcat(szRelPath, pszQueryOther);
}
}
else if (pszQueryOther &&
(!pszQueryBase || (lstrcmpi(pszQueryOther, pszQueryBase) != 0)))
{
lstrcat(szRelPath, "?");
lstrcat(szRelPath, pszQueryOther);
}
}
PerfDbgLog(tagCUrlMon, NULL, "-AddParamsAndQueryToRelPath");
DEBUG_LEAVE(0);
}
#endif // URLMON_RELPATHTO_PARSE_QUERY_PARAMS
Copy Permalink