You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
581 lines
20 KiB
581 lines
20 KiB
#include "stdafx.h"
|
|
#include "netplace.h"
|
|
#include "msdasc.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
CNetworkPlace::CNetworkPlace() :
|
|
_pidl(NULL), _fSupportWebFolders(FALSE), _fIsWebFolder(FALSE), _fDeleteWebFolder(FALSE)
|
|
{
|
|
_szTarget[0] = TEXT('\0');
|
|
_szName[0] = TEXT('\0');
|
|
_szDescription[0] = TEXT('\0');
|
|
}
|
|
|
|
// destructor - clean up our state
|
|
CNetworkPlace::~CNetworkPlace()
|
|
{
|
|
_InvalidateCache();
|
|
}
|
|
|
|
void CNetworkPlace::_InvalidateCache()
|
|
{
|
|
// web folders will create a shortcut to objects if we go through its binding
|
|
// process, therefore when we attempt to invalidate our cache we should
|
|
// clean up our mess.
|
|
//
|
|
// if the user has commited the change then we can/will keep the shortcut
|
|
// around, otherwise we call the delete verb on it.
|
|
|
|
if (_fIsWebFolder && _fDeleteWebFolder && _pidl)
|
|
{
|
|
IShellFolder *psf;
|
|
LPCITEMIDLIST pidlLast;
|
|
HRESULT hr = SHBindToIDListParent(_pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IContextMenu *pcm;
|
|
hr = psf->GetUIObjectOf(NULL, 1, &pidlLast, IID_X_PPV_ARG(IContextMenu, NULL, &pcm));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CMINVOKECOMMANDINFO ici = {0};
|
|
ici.cbSize = sizeof (ici);
|
|
ici.fMask = CMIC_MASK_FLAG_NO_UI;
|
|
ici.lpVerb = "Delete";
|
|
ici.nShow = SW_SHOWNORMAL;
|
|
|
|
hr = pcm->InvokeCommand(&ici);
|
|
pcm->Release();
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
|
|
// now clean up the rest of our state.
|
|
|
|
ILFree(_pidl);
|
|
_pidl = NULL;
|
|
|
|
_szTarget[0] = TEXT('\0');
|
|
_szName[0] = TEXT('\0');
|
|
_szDescription[0] = TEXT('\0');
|
|
|
|
_fIsWebFolder = FALSE;
|
|
_fDeleteWebFolder = FALSE;
|
|
}
|
|
|
|
|
|
HRESULT CNetworkPlace::SetTarget(HWND hwnd, LPCWSTR pszTarget, DWORD dwFlags)
|
|
{
|
|
_InvalidateCache();
|
|
|
|
HRESULT hr = S_OK;
|
|
if (pszTarget)
|
|
{
|
|
// set our state accordingly
|
|
_fSupportWebFolders = (dwFlags & NPTF_ALLOWWEBFOLDERS) != 0;
|
|
|
|
// copy the URL and prepare for parsing
|
|
StrCpyN(_szTarget, pszTarget, ARRAYSIZE(_szTarget));
|
|
|
|
INT cchTarget = lstrlen(_szTarget)-1;
|
|
if ((_szTarget[cchTarget] == L'\\') || (_szTarget[cchTarget] == '/'))
|
|
{
|
|
_szTarget[cchTarget] = TEXT('\0');
|
|
}
|
|
|
|
if (dwFlags & NPTF_VALIDATE)
|
|
{
|
|
// connecting to a server root or local path is not supported
|
|
if (PathIsUNCServer(_szTarget) || PathGetDriveNumber(_szTarget) != -1)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
// check the policy to see if we are setting this.
|
|
if (PathIsUNC(_szTarget) && SHRestricted(REST_NONETCONNECTDISCONNECT))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
hr = _IDListFromTarget(hwnd);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (hwnd && !(dwFlags & NPTF_SILENT))
|
|
{
|
|
::DisplayFormatMessage(hwnd,
|
|
IDS_ANP_CAPTION,
|
|
PathIsUNCServer(_szTarget) ? IDS_PUB_ONLYSERVER:IDS_CANTFINDFOLDER,
|
|
MB_OK|MB_ICONERROR);
|
|
}
|
|
_InvalidateCache();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CNetworkPlace::SetName(HWND hwnd, LPCWSTR pszName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!_fIsWebFolder)
|
|
{
|
|
// check to see if we are going to overwrite an existing place, if we
|
|
// are then display a prompt and let the user choose. if they answer
|
|
// yes, then have at it!
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
if (hwnd && _IsPlaceTaken(pszName, szPath))
|
|
{
|
|
if (IDNO == ::DisplayFormatMessage(hwnd,
|
|
IDS_ANP_CAPTION , IDS_FRIENDLYNAMEINUSE,
|
|
MB_YESNO|MB_ICONQUESTION,
|
|
pszName))
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we succeed the above then lets use the new name.
|
|
|
|
if (SUCCEEDED(hr))
|
|
StrCpyN(_szName, pszName, ARRAYSIZE(_szName));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CNetworkPlace::SetDescription(LPCWSTR pszDescription)
|
|
{
|
|
StrCpyN(_szDescription, pszDescription, ARRAYSIZE(_szDescription));
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// recompute the URL based on the new user/password information that
|
|
// we were just given.
|
|
|
|
HRESULT CNetworkPlace::SetLoginInfo(LPCWSTR pszUser, LPCWSTR pszPassword)
|
|
{
|
|
TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH + 1];
|
|
TCHAR szUrlPath[INTERNET_MAX_PATH_LENGTH + 1];
|
|
TCHAR szExtraInfo[MAX_PATH + 1]; // Includes Port Number and download type (ASCII, Binary, Detect)
|
|
|
|
URL_COMPONENTS urlComps = {0};
|
|
urlComps.dwStructSize = sizeof(urlComps);
|
|
urlComps.lpszHostName = szServer;
|
|
urlComps.dwHostNameLength = ARRAYSIZE(szServer);
|
|
urlComps.lpszUrlPath = szUrlPath;
|
|
urlComps.dwUrlPathLength = ARRAYSIZE(szUrlPath);
|
|
urlComps.lpszExtraInfo = szExtraInfo;
|
|
urlComps.dwExtraInfoLength = ARRAYSIZE(szExtraInfo);
|
|
|
|
// WARNING - the ICU_DECODE/ICU_ESCAPE is a lossy roundtrip - ZekeL - 26-MAR-2001
|
|
// many escaped characters are not correctly identified and re-escaped.
|
|
// any characters that are reserved for URL parsing purposes
|
|
// will be interpreted as their parsing char (ie '/').
|
|
BOOL fResult = InternetCrackUrl(_szTarget, 0, 0, &urlComps);
|
|
if (fResult)
|
|
{
|
|
urlComps.lpszUserName = (LPTSTR) pszUser;
|
|
urlComps.dwUserNameLength = (pszUser ? lstrlen(pszUser) : 0);
|
|
urlComps.lpszPassword = (LPTSTR) pszPassword;
|
|
urlComps.dwPasswordLength = (pszPassword ? lstrlen(pszPassword) : 0);
|
|
|
|
DWORD cchSize = ARRAYSIZE(_szTarget);
|
|
fResult = InternetCreateUrl(&urlComps, (ICU_ESCAPE | ICU_USERNAME), _szTarget, &cchSize);
|
|
|
|
// if we have a cached IDList then lets ensure that we clear it up
|
|
// so that we rebind and the FTP namespace gets a crack at it.
|
|
|
|
if (fResult && _pidl)
|
|
{
|
|
ILFree(_pidl);
|
|
_pidl = NULL;
|
|
}
|
|
}
|
|
return fResult ? S_OK : HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
|
|
HRESULT CNetworkPlace::GetIDList(HWND hwnd, LPITEMIDLIST *ppidl)
|
|
{
|
|
HRESULT hr = _IDListFromTarget(hwnd);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILClone(_pidl, ppidl);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CNetworkPlace::GetObject(HWND hwnd, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = _IDListFromTarget(hwnd);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHBindToObject(NULL, riid, _pidl, ppv);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetworkPlace::GetName(LPWSTR pszBuffer, int cchBuffer)
|
|
{
|
|
HRESULT hr = _IDListFromTarget(NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
StrCpyN(pszBuffer, _szName, cchBuffer);
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// check to see if we are going to overwrite a network place
|
|
|
|
BOOL CNetworkPlace::_IsPlaceTaken(LPCTSTR pszName, LPTSTR pszPath)
|
|
{
|
|
BOOL fOverwriting = FALSE;
|
|
|
|
SHGetSpecialFolderPath(NULL, pszPath, CSIDL_NETHOOD, TRUE);
|
|
PathCombine(pszPath, pszPath, pszName);
|
|
|
|
IShellFolder *psf;
|
|
HRESULT hr = SHGetDesktopFolder(&psf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(psf->ParseDisplayName(NULL, NULL, pszPath, NULL, &pidl, NULL)))
|
|
{
|
|
// we think we are going to overwrite an existing net place, so lets
|
|
// check first to see if the place which is there is not actually
|
|
// pointing at our new target. if its is then we can just
|
|
// ignore all of this.
|
|
|
|
TCHAR szTarget[INTERNET_MAX_URL_LENGTH];
|
|
hr = _GetTargetPath(pidl, szTarget, ARRAYSIZE(szTarget));
|
|
if (FAILED(hr) || (0 != StrCmpI(szTarget, _szTarget)))
|
|
{
|
|
fOverwriting = TRUE;
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
psf->Release();
|
|
}
|
|
|
|
return fOverwriting;
|
|
}
|
|
|
|
|
|
// handle creating the web folders IDLIST for this item. we check with the
|
|
// rosebud binder to find out if this scheme is supported, if so then
|
|
// we attempt to have the Web Folders code crack the URL
|
|
|
|
static const BYTE c_pidlWebFolders[] =
|
|
{
|
|
0x14,0x00,0x1F,0x0F,0xE0,0x4F,0xD0,0x20,
|
|
0xEA,0x3A,0x69,0x10,0xA2,0xD8,0x08,0x00,
|
|
0x2B,0x30,0x30,0x9D,0x14,0x00,0x2E,0x00,
|
|
0x00,0xDF,0xEA,0xBD,0x65,0xC2,0xD0,0x11,
|
|
0xBC,0xED,0x00,0xA0,0xC9,0x0A,0xB5,0x0F,
|
|
0x00,0x00
|
|
};
|
|
|
|
HRESULT CNetworkPlace::_TryWebFolders(HWND hwnd)
|
|
{
|
|
// lets see if Rosebud can handle this scheme item by checking the
|
|
// scheme and seeing if the rosebud binder can handle it.
|
|
TCHAR szScheme[INTERNET_MAX_SCHEME_LENGTH + 1];
|
|
DWORD cchScheme = ARRAYSIZE(szScheme);
|
|
HRESULT hr = UrlGetPart(_szTarget, szScheme, &cchScheme, URL_PART_SCHEME, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IRegisterProvider *prp;
|
|
hr = CoCreateInstance(CLSID_RootBinder, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IRegisterProvider, &prp));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// let the web folders code have a go at creating a link to this storage,
|
|
// the IDLIST we generate points to the folder inside My Computer (hidden)
|
|
|
|
CLSID clsidOut;
|
|
hr = prp->GetURLMapping(szScheme, 0, &clsidOut);
|
|
if (hr == S_OK)
|
|
{
|
|
IShellFolder *psf;
|
|
hr = SHBindToObject(NULL, IID_IShellFolder, (LPCITEMIDLIST)c_pidlWebFolders, (void**)&psf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IBindCtx *pbc;
|
|
hr = CreateBindCtx(NULL, &pbc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BIND_OPTS bo = {sizeof(bo), 0, STGM_CREATE};
|
|
hr = pbc->SetBindOptions(&bo);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// we need to pase NULL hWnd to this so that Web Folders doesn't display any
|
|
// UI, in particular its ever so useful NULL error message box... mumble mumble
|
|
|
|
LPITEMIDLIST pidl;
|
|
hr = psf->ParseDisplayName(NULL, pbc, _szTarget, NULL, &pidl, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ASSERT(!_pidl);
|
|
hr = SHILCombine((LPCITEMIDLIST)c_pidlWebFolders, pidl, &_pidl);
|
|
ILFree(pidl);
|
|
|
|
_fDeleteWebFolder = TRUE; // we now have the magic web folders link (clean it up)
|
|
}
|
|
}
|
|
|
|
pbc->Release();
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
prp->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// dereference a link and get the target path
|
|
|
|
HRESULT CNetworkPlace::_GetTargetPath(LPCITEMIDLIST pidl, LPTSTR pszPath, int cchPath)
|
|
{
|
|
LPITEMIDLIST pidlTarget;
|
|
HRESULT hr = SHGetTargetFolderIDList(pidl, &pidlTarget);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SHGetNameAndFlags(pidlTarget, SHGDN_FORPARSING, pszPath, cchPath, NULL);
|
|
ILFree(pidlTarget);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// create an IDLIST for the target that we have, this code attempts to parse the name and
|
|
// then set our state for the item. if we fail to parse then we attempt to have Web Folders
|
|
// look at it - this most common scenario for this will be the DAV RDR failing because
|
|
// the server isn't a DAV store, so instead we try Web Folders to handle WEC etc.
|
|
|
|
HRESULT CNetworkPlace::_IDListFromTarget(HWND hwnd)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if (!_pidl)
|
|
{
|
|
if (_szTarget[0])
|
|
{
|
|
_fIsWebFolder = FALSE; // not a web folder
|
|
|
|
BINDCTX_PARAM rgParams[] =
|
|
{
|
|
{ STR_PARSE_PREFER_FOLDER_BROWSING, NULL},
|
|
{ L"BUT NOT WEBFOLDERS", NULL},
|
|
};
|
|
IBindCtx *pbc;
|
|
hr = BindCtx_RegisterObjectParams(NULL, rgParams, ARRAYSIZE(rgParams), &pbc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IBindCtx *pbcWindow;
|
|
hr = BindCtx_RegisterUIWindow(pbc, hwnd, &pbcWindow);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SFGAOF sfgao;
|
|
hr = SHParseDisplayName(_szTarget, pbcWindow, &_pidl, SFGAO_FOLDER, &sfgao);
|
|
|
|
// if we parsed something that turns out to not
|
|
// be a folder, we want to throw it away
|
|
if (SUCCEEDED(hr) && !(sfgao & SFGAO_FOLDER))
|
|
{
|
|
ILFree(_pidl);
|
|
_pidl = 0;
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
// if that failed, its is a HTTP/HTTPS and we have web folders support then lets try
|
|
// and fall back to the old behaviour.
|
|
|
|
if (FAILED(hr) && _fSupportWebFolders)
|
|
{
|
|
DWORD scheme = GetUrlScheme(_szTarget);
|
|
if (scheme == URL_SCHEME_HTTP || scheme == URL_SCHEME_HTTPS)
|
|
{
|
|
switch (hr)
|
|
{
|
|
#if 0
|
|
case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
|
|
case HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND):
|
|
case HRESULT_FROM_WIN32(ERROR_BAD_NET_NAME):
|
|
case HRESULT_FROM_WIN32(ERROR_BAD_NETPATH):
|
|
#endif
|
|
case HRESULT_FROM_WIN32(ERROR_CANCELLED):
|
|
break;
|
|
|
|
default:
|
|
{
|
|
hr = _TryWebFolders(hwnd);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_fIsWebFolder = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// given that we may have translated the name above for the parse
|
|
// to work, lets read back the name we used into our _szTarget.
|
|
SHGetNameAndFlags(_pidl, SHGDN_FORPARSING, _szTarget, ARRAYSIZE(_szTarget), NULL);
|
|
}
|
|
pbcWindow->Release();
|
|
}
|
|
|
|
// compute the place name for the location we have hit, this includes reusing
|
|
// any places we have already created.
|
|
|
|
if (SUCCEEDED(hr) && !_szName[0])
|
|
{
|
|
SHGetNameAndFlags(_pidl, SHGDN_NORMAL, _szName, ARRAYSIZE(_szName), NULL);
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
if (!_fIsWebFolder && _IsPlaceTaken(_szName, szPath))
|
|
{
|
|
PathYetAnotherMakeUniqueName(szPath, szPath, NULL, NULL);
|
|
StrCpyN(_szName, PathFindFileName(szPath), ARRAYSIZE(_szName)); // update our state
|
|
}
|
|
}
|
|
pbc->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// handle creating the network place shortcut
|
|
|
|
HRESULT CNetworkPlace::CreatePlace(HWND hwnd, BOOL fOpen)
|
|
{
|
|
HRESULT hr = _IDListFromTarget(hwnd);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// web folders already have their links created, therefore we can ignore this
|
|
// whole process for them, and instead fall back to just executing their link.
|
|
//
|
|
// for regular folders though we must attempt to find a unique name and create
|
|
// the link, or if the link already exists that we can use then just open it.
|
|
|
|
if (!_fIsWebFolder)
|
|
{
|
|
IShellLink *psl;
|
|
hr = CoCreateInstance(CLSID_FolderShortcut, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLink, &psl));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psl->SetIDList(_pidl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = psl->SetDescription(_szDescription[0] ? _szDescription:_szTarget);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IPersistFile *ppf;
|
|
hr = psl->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// get the name to the shortcut, we assume that this is unique
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
SHGetSpecialFolderPath(NULL, szPath, CSIDL_NETHOOD, TRUE);
|
|
PathCombine(szPath, szPath, _szName);
|
|
|
|
hr = ppf->Save(szPath, TRUE);
|
|
ppf->Release();
|
|
}
|
|
}
|
|
psl->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this is the web folder case, so we now need to set the display
|
|
// name for this guy. note that we don't have any control over
|
|
// the description text we are going to be seeing.
|
|
|
|
IShellFolder *psf;
|
|
LPCITEMIDLIST pidlLast;
|
|
hr = SHBindToIDListParent(_pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlNew;
|
|
hr = psf->SetNameOf(hwnd, pidlLast, _szName, SHGDN_INFOLDER, &pidlNew);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_fDeleteWebFolder = FALSE;
|
|
//Web folders will return S_FALSE with bogus pidlNew if _szName is the same as the current name
|
|
if (S_OK == hr)
|
|
{
|
|
ILFree(_pidl);
|
|
hr = SHILCombine((LPCITEMIDLIST)c_pidlWebFolders, pidlNew, &_pidl);
|
|
}
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
|
|
// now open the target if thats what they asked for
|
|
|
|
if (SUCCEEDED(hr) && fOpen)
|
|
{
|
|
LPITEMIDLIST pidlNetPlaces;
|
|
hr = SHGetSpecialFolderLocation(hwnd, CSIDL_NETWORK, &pidlNetPlaces);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolder *psf;
|
|
hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidlNetPlaces, &psf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
hr = psf->ParseDisplayName(hwnd, NULL, _szName, NULL, &pidl, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlToOpen;
|
|
hr = SHILCombine(pidlNetPlaces, pidl, &pidlToOpen);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BrowseToPidl(pidlToOpen);
|
|
ILFree(pidlToOpen);
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
psf->Release();
|
|
}
|
|
ILFree(pidlNetPlaces);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|