4874 lines
158 KiB
C++
4874 lines
158 KiB
C++
#include "shellprv.h"
|
|
#include "caggunk.h"
|
|
#include "views.h"
|
|
#include "ids.h"
|
|
#include "shitemid.h"
|
|
#include "fstreex.h"
|
|
#include "clsobj.h"
|
|
#include "datautil.h"
|
|
#include "winnetp.h" // RESOURCE_SHAREABLE
|
|
#include "prop.h"
|
|
#include "infotip.h"
|
|
#include "basefvcb.h"
|
|
#include "netview.h"
|
|
#include "printer.h"
|
|
#include "fsdata.h"
|
|
#include "idldrop.h"
|
|
#include "enumidlist.h"
|
|
#include "util.h"
|
|
#include <webvw.h>
|
|
|
|
|
|
#define WNNC_NET_LARGEST WNNC_NET_SYMFONET
|
|
|
|
|
|
HRESULT CNetRootDropTarget_CreateInstance(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt);
|
|
|
|
class CNetData : public CFSIDLData
|
|
{
|
|
public:
|
|
CNetData(LPCITEMIDLIST pidlFolder, UINT cidl, LPCITEMIDLIST apidl[]): CFSIDLData(pidlFolder, cidl, apidl, NULL) { };
|
|
|
|
// IDataObject methods overwrite
|
|
STDMETHODIMP GetData(FORMATETC *pFmtEtc, STGMEDIUM *pstm);
|
|
STDMETHODIMP QueryGetData(FORMATETC *pFmtEtc);
|
|
|
|
protected:
|
|
STDMETHODIMP GetHDrop(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);
|
|
};
|
|
|
|
|
|
// {22BEB58B-0794-11d2-A4AA-00C04F8EEB3E}
|
|
const GUID CLSID_CNetFldr = { 0x22beb58b, 0x794, 0x11d2, 0xa4, 0xaa, 0x0, 0xc0, 0x4f, 0x8e, 0xeb, 0x3e };
|
|
|
|
// idlist.c
|
|
STDAPI_(void) StrRetFormat(STRRET *pStrRet, LPCITEMIDLIST pidlRel, LPCTSTR pszTemplate, LPCTSTR pszAppend);
|
|
|
|
// in stdenum.cpp
|
|
STDAPI_(void *) CStandardEnum_CreateInstance(REFIID riid, BOOL bInterfaces, int cElement, int cbElement, void *rgElements,
|
|
void (WINAPI * pfnCopyElement)(void *, const void *, DWORD));
|
|
|
|
// is a \\server\printer object
|
|
BOOL _IsPrintShare(LPCIDNETRESOURCE pidn)
|
|
{
|
|
return NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_SHARE &&
|
|
NET_GetType(pidn) == RESOURCETYPE_PRINT;
|
|
}
|
|
|
|
|
|
// column information
|
|
|
|
enum
|
|
{
|
|
ICOL_NAME = 0,
|
|
ICOL_COMMENT,
|
|
ICOL_COMPUTERNAME,
|
|
ICOL_NETWORKLOCATION
|
|
};
|
|
|
|
const COLUMN_INFO s_net_cols[] =
|
|
{
|
|
DEFINE_COL_STR_ENTRY(SCID_NAME, 30, IDS_NAME_COL),
|
|
DEFINE_COL_STR_ENTRY(SCID_Comment, 30, IDS_EXCOL_COMMENT),
|
|
DEFINE_COL_STR_ENTRY(SCID_COMPUTERNAME, 30, IDS_EXCOL_COMPUTER),
|
|
DEFINE_COL_STR_ENTRY(SCID_NETWORKLOCATION, 30, IDS_NETWORKLOCATION),
|
|
};
|
|
|
|
#define MAX_ICOL_NETFOLDER (ICOL_COMMENT+1)
|
|
#define MAX_ICOL_NETROOT (ICOL_NETWORKLOCATION+1)
|
|
|
|
STDAPI CNetwork_DFMCallBackBG(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
class CNetFolderViewCB;
|
|
class CNetFolderEnum;
|
|
|
|
class CNetFolder : public CAggregatedUnknown,
|
|
public IShellFolder2,
|
|
public IPersistFolder3,
|
|
public IShellIconOverlay
|
|
{
|
|
friend CNetFolderViewCB;
|
|
friend CNetFolderEnum;
|
|
|
|
public:
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj)
|
|
{ return CAggregatedUnknown::QueryInterface(riid, ppvObj); };
|
|
STDMETHODIMP_(ULONG) AddRef(void)
|
|
{ return CAggregatedUnknown::AddRef(); };
|
|
STDMETHODIMP_(ULONG) Release(void)
|
|
{ return CAggregatedUnknown::Release(); };
|
|
|
|
// IShellFolder
|
|
STDMETHODIMP ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR lpszDisplayName,
|
|
ULONG* pchEaten, LPITEMIDLIST* ppidl, ULONG* pdwAttributes);
|
|
STDMETHODIMP EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList ** ppenumIDList);
|
|
STDMETHODIMP BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv);
|
|
STDMETHODIMP BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvObj);
|
|
STDMETHODIMP CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
|
|
STDMETHODIMP CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv);
|
|
STDMETHODIMP GetAttributesOf(UINT cidl, LPCITEMIDLIST* apidl, ULONG* rgfInOut);
|
|
STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST* apidl,
|
|
REFIID riid, UINT* prgfInOut, void **ppv);
|
|
STDMETHODIMP GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET lpName);
|
|
STDMETHODIMP SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD uFlags,
|
|
LPITEMIDLIST* ppidlOut);
|
|
|
|
// IShellFolder2
|
|
STDMETHODIMP GetDefaultSearchGUID(GUID *pGuid);
|
|
STDMETHODIMP EnumSearches(IEnumExtraSearch **ppenum);
|
|
STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG* pSort, ULONG* pDisplay);
|
|
STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD* pbState)
|
|
{ return _GetDefaultColumnState(MAX_ICOL_NETFOLDER, iColumn, pbState); }
|
|
STDMETHODIMP GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID* pscid, VARIANT* pv);
|
|
STDMETHODIMP GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS* pDetails)
|
|
{ return _GetDetailsOf(MAX_ICOL_NETFOLDER, pidl, iColumn, pDetails); }
|
|
STDMETHODIMP MapColumnToSCID(UINT iColumn, SHCOLUMNID* pscid)
|
|
{ return _MapColumnToSCID(MAX_ICOL_NETFOLDER, iColumn, pscid); }
|
|
|
|
// IPersist
|
|
STDMETHODIMP GetClassID(CLSID* pClassID);
|
|
// IPersistFolder
|
|
STDMETHODIMP Initialize(LPCITEMIDLIST pidl);
|
|
// IPersistFolder2
|
|
STDMETHODIMP GetCurFolder(LPITEMIDLIST* ppidl);
|
|
// IPersistFolder3
|
|
STDMETHOD(InitializeEx)(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfai);
|
|
STDMETHOD(GetFolderTargetInfo)(PERSIST_FOLDER_TARGET_INFO *ppfai);
|
|
|
|
// *** IShellIconOverlay methods***
|
|
STDMETHOD(GetOverlayIndex)(LPCITEMIDLIST pidl, int * pIndex);
|
|
STDMETHOD(GetOverlayIconIndex)(LPCITEMIDLIST pidl, int * pIconIndex);
|
|
|
|
protected:
|
|
CNetFolder(IUnknown* punkOuter);
|
|
~CNetFolder();
|
|
|
|
virtual HRESULT v_GetFileFolder(IShellFolder2 **ppsfFiles)
|
|
{ *ppsfFiles = NULL; return E_NOTIMPL; };
|
|
|
|
// used by the CAggregatedUnknown stuff
|
|
HRESULT v_InternalQueryInterface(REFIID riid, void **ppvObj);
|
|
|
|
HRESULT _OpenKeys(LPCIDNETRESOURCE pidn, HKEY ahkeys[]);
|
|
LPCTSTR _GetProvider(LPCIDNETRESOURCE pidn, IBindCtx *pbc, LPTSTR pszProvider, UINT cchProvider);
|
|
DWORD _OpenEnum(HWND hwnd, DWORD grfFlags, LPNETRESOURCE pnr, HANDLE *phEnum);
|
|
|
|
static HRESULT _CreateNetIDList(LPIDNETRESOURCE pidnIn,
|
|
LPCTSTR pszName, LPCTSTR pszProvider, LPCTSTR pszComment,
|
|
LPITEMIDLIST *ppidl);
|
|
|
|
static HRESULT _NetResToIDList(NETRESOURCE *pnr,
|
|
BOOL fKeepNullRemoteName,
|
|
BOOL fKeepProviderName,
|
|
BOOL fKeepComment,
|
|
LPITEMIDLIST *ppidl);
|
|
|
|
static HRESULT _CreateEntireNetwork(LPITEMIDLIST *ppidl);
|
|
|
|
static HRESULT _CreateEntireNetworkFullIDList(LPITEMIDLIST *ppidl);
|
|
|
|
LPTSTR _GetNameForParsing(LPCWSTR pwszName, LPTSTR pszBuffer, INT cchBuffer, LPTSTR *ppszRegItem);
|
|
HRESULT _ParseRest(LPBC pbc, LPCWSTR pszRest, LPITEMIDLIST* ppidl, DWORD* pdwAttributes);
|
|
HRESULT _AddUnknownIDList(DWORD dwDisplayType, LPITEMIDLIST *ppidl);
|
|
HRESULT _ParseSimple(LPBC pbc, LPWSTR pszName, LPITEMIDLIST* ppidl, DWORD* pdwAttributes);
|
|
HRESULT _NetResToIDLists(NETRESOURCE *pnr, DWORD dwbuf, LPITEMIDLIST *ppidl);
|
|
|
|
HRESULT _ParseNetName(HWND hwnd, LPBC pbc, LPCWSTR pwszName, ULONG* pchEaten,
|
|
LPITEMIDLIST* ppidl, DWORD* pdwAttributes);
|
|
LONG _GetFilePIDLType(LPCITEMIDLIST pidl);
|
|
LPITEMIDLIST _AddProviderToPidl(LPITEMIDLIST pidl, LPCTSTR lpProvider);
|
|
BOOL _MakeStripToLikeKinds(UINT *pcidl, LPCITEMIDLIST **papidl, BOOL fNetObjects);
|
|
HRESULT _GetDefaultColumnState(UINT cColumns, UINT iColumn, DWORD* pdwState);
|
|
HRESULT _GetDetailsOf(UINT cColumns, LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails);
|
|
HRESULT _MapColumnToSCID(UINT cColumns, UINT iColumn, SHCOLUMNID* pscid);
|
|
|
|
LPFNDFMCALLBACK _GetCallbackType(LPCIDNETRESOURCE pidn)
|
|
{ return _IsPrintShare(pidn) ? &PrinterDFMCallBack : &DFMCallBack; };
|
|
|
|
static HRESULT CALLBACK _AttributesCallbackRoot(IShellFolder2* psf, LPCITEMIDLIST pidl, ULONG* prgfInOut);
|
|
|
|
LPITEMIDLIST _pidl;
|
|
LPITEMIDLIST _pidlTarget; // pidl of where the folder is in the namespace
|
|
LPCIDNETRESOURCE _pidnForProvider; // optional provider for this container...
|
|
LPTSTR _pszResName; // optional resource name of this container
|
|
UINT _uDisplayType; // display type of the folder
|
|
IShellFolder2* _psfFiles;
|
|
IUnknown* _punkReg;
|
|
|
|
private:
|
|
HRESULT _CreateInstance(LPCITEMIDLIST pidlAbs, LPCITEMIDLIST pidlTarget,
|
|
UINT uDisplayType,
|
|
LPCIDNETRESOURCE pidnForProvider, LPCTSTR pszResName,
|
|
REFIID riid, void **ppv);
|
|
friend HRESULT CNetwork_DFMCallBackBG(IShellFolder *psf, HWND hwnd,
|
|
IDataObject *pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam);
|
|
static DWORD CALLBACK _PropertiesThreadProc(void *pv);
|
|
static HRESULT DFMCallBack(IShellFolder* psf, HWND hwnd,
|
|
IDataObject* pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam);
|
|
static HRESULT PrinterDFMCallBack(IShellFolder* psf, HWND hwnd,
|
|
IDataObject* pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam);
|
|
static HRESULT CALLBACK _AttributesCallback(IShellFolder2* psf, LPCITEMIDLIST pidl, ULONG* prgfInOut);
|
|
|
|
BOOL _GetPathForShare(LPCIDNETRESOURCE pidn, LPTSTR pszPath);
|
|
HRESULT _GetPathForItem(LPCIDNETRESOURCE pidn, LPTSTR pszPath);
|
|
HRESULT _GetPathForItemW(LPCIDNETRESOURCE pidn, LPWSTR pszPath);
|
|
HRESULT _CreateFolderForItem(LPBC pbc, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlTarget, LPCIDNETRESOURCE pidnForProvider, REFIID riid, void **ppv);
|
|
HRESULT _GetFormatName(LPCIDNETRESOURCE pidn, STRRET* pStrRet);
|
|
HRESULT _GetIconOverlayInfo(LPCIDNETRESOURCE pidn, int *pIndex, DWORD dwFlags);
|
|
HKEY _OpenProviderTypeKey(LPCIDNETRESOURCE pidn);
|
|
HKEY _OpenProviderKey(LPCIDNETRESOURCE pidn);
|
|
static void WINAPI _CopyEnumElement(void* pDest, const void* pSource, DWORD dwSize);
|
|
HRESULT _GetNetResource(LPCIDNETRESOURCE pidn, NETRESOURCEW* pnr, int cb);
|
|
};
|
|
|
|
|
|
class CNetRootFolder : public CNetFolder
|
|
{
|
|
public:
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj)
|
|
{ return CNetFolder::QueryInterface(riid, ppvObj); };
|
|
STDMETHODIMP_(ULONG) AddRef(void)
|
|
{ return CNetFolder::AddRef(); };
|
|
STDMETHODIMP_(ULONG) Release(void)
|
|
{ return CNetFolder::Release(); };
|
|
|
|
// IShellFolder
|
|
STDMETHODIMP ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR lpszDisplayName,
|
|
ULONG* pchEaten, LPITEMIDLIST* ppidl, ULONG* pdwAttributes);
|
|
STDMETHODIMP EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList ** ppenumIDList);
|
|
STDMETHODIMP BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv);
|
|
STDMETHODIMP BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvObj)
|
|
{ return CNetFolder::BindToStorage(pidl, pbc, riid, ppvObj); };
|
|
STDMETHODIMP CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
|
|
STDMETHODIMP CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv);
|
|
STDMETHODIMP GetAttributesOf(UINT cidl, LPCITEMIDLIST* apidl, ULONG* rgfInOut);
|
|
STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST* apidl,
|
|
REFIID riid, UINT* prgfInOut, void **ppv);
|
|
STDMETHODIMP GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET lpName);
|
|
STDMETHODIMP SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD uFlags,
|
|
LPITEMIDLIST* ppidlOut);
|
|
|
|
// IShellFolder2
|
|
STDMETHODIMP GetDefaultSearchGUID(GUID *pGuid)
|
|
{ return CNetFolder::GetDefaultSearchGUID(pGuid); };
|
|
STDMETHODIMP EnumSearches(IEnumExtraSearch **ppenum)
|
|
{ return CNetFolder::EnumSearches(ppenum); };
|
|
STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG* pSort, ULONG* pDisplay)
|
|
{ return CNetFolder::GetDefaultColumn(dwRes, pSort, pDisplay); };
|
|
STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD* pbState)
|
|
{ return _GetDefaultColumnState(MAX_ICOL_NETROOT, iColumn, pbState); } // +1 for <= check
|
|
STDMETHODIMP GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID* pscid, VARIANT* pv)
|
|
{ return CNetFolder::GetDetailsEx(pidl, pscid, pv); };
|
|
STDMETHODIMP GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS* pDetails)
|
|
{ return _GetDetailsOf(MAX_ICOL_NETROOT, pidl, iColumn, pDetails); };
|
|
STDMETHODIMP MapColumnToSCID(UINT iColumn, SHCOLUMNID* pscid)
|
|
{ return _MapColumnToSCID(MAX_ICOL_NETROOT, iColumn, pscid); }
|
|
|
|
// IPersist
|
|
STDMETHODIMP GetClassID(CLSID* pClassID);
|
|
|
|
// IPersistFolder
|
|
STDMETHODIMP Initialize(LPCITEMIDLIST pidl);
|
|
|
|
// IPersistFolder2
|
|
STDMETHODIMP GetCurFolder(LPITEMIDLIST* ppidl) { return CNetFolder::GetCurFolder(ppidl); };
|
|
|
|
// IPersistFolder3
|
|
STDMETHOD(InitializeEx)(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfai)
|
|
{ return CNetFolder::InitializeEx(pbc, pidlRoot, ppfai); };
|
|
STDMETHOD(GetFolderTargetInfo)(PERSIST_FOLDER_TARGET_INFO *ppfai)
|
|
{ return CNetFolder::GetFolderTargetInfo(ppfai); };
|
|
|
|
protected:
|
|
CNetRootFolder(IUnknown* punkOuter) : CNetFolder(punkOuter) { };
|
|
~CNetRootFolder() { ASSERT(NULL != _spThis); _spThis = NULL; };
|
|
|
|
BOOL v_HandleDelete(PLONG pcRef);
|
|
HRESULT v_GetFileFolder(IShellFolder2 **ppsfFiles);
|
|
|
|
private:
|
|
HRESULT _TryParseEntireNet(HWND hwnd, LPBC pbc, WCHAR *pwszName, LPITEMIDLIST *ppidl, DWORD *pdwAttributes);
|
|
|
|
friend HRESULT CNetwork_CreateInstance(IUnknown* punkOuter, REFIID riid, void **ppv);
|
|
static CNetRootFolder* _spThis;
|
|
};
|
|
|
|
class CNetFolderViewCB : public CBaseShellFolderViewCB
|
|
{
|
|
public:
|
|
CNetFolderViewCB(CNetFolder *pFolder);
|
|
|
|
// IShellFolderViewCB
|
|
STDMETHODIMP RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
private:
|
|
~CNetFolderViewCB();
|
|
HRESULT OnINVOKECOMMAND(DWORD pv, UINT wP);
|
|
HRESULT OnGETHELPTEXT(DWORD pv, UINT wPl, UINT wPh, LPTSTR lP);
|
|
HRESULT OnREFRESH(DWORD pv, BOOL fPreRefresh);
|
|
HRESULT OnDELAYWINDOWCREATE(DWORD pv, HWND hwnd);
|
|
HRESULT OnGETCOLSAVESTREAM(DWORD pv, WPARAM wP, IStream **pps);
|
|
HRESULT OnDEFITEMCOUNT(DWORD pv, UINT *pnItems);
|
|
HRESULT OnGetZone(DWORD pv, DWORD * pdwZone);
|
|
HRESULT OnEnumeratedItems(DWORD pv, UINT celt, LPCITEMIDLIST *rgpidl);
|
|
HRESULT OnDefViewMode(DWORD pv, FOLDERVIEWMODE* pvm);
|
|
HRESULT OnGetDeferredViewSettings(DWORD pv, SFVM_DEFERRED_VIEW_SETTINGS* pSettings);
|
|
|
|
BOOL _GetProviderKeyName(LPTSTR pszName, UINT uNameLen);
|
|
BOOL _EntireNetworkAvailable();
|
|
|
|
CNetFolder *_pFolder;
|
|
UINT _cItems;
|
|
|
|
// Web View implementation
|
|
HRESULT OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData);
|
|
HRESULT OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData);
|
|
HRESULT OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks);
|
|
public:
|
|
static HRESULT _CanShowHNW(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
|
|
static HRESULT _CanViewComputersNearMe(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
|
|
static HRESULT _CanSearchActiveDirectory(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState);
|
|
|
|
static HRESULT _DoRunDll32(LPTSTR pszParameters); // helper to do a ShellExecute of RunDll32.
|
|
|
|
static HRESULT _OnViewNetConnections(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
|
|
static HRESULT _OnAddNetworkPlace(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
|
|
{ return _DoRunDll32(TEXT("netplwiz.dll,AddNetPlaceRunDll")); }
|
|
static HRESULT _OnHomeNetworkWizard(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
|
|
{ return _DoRunDll32(TEXT("hnetwiz.dll,HomeNetWizardRunDll")); }
|
|
static HRESULT _OnViewComputersNearMe(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);
|
|
static HRESULT _OnSearchActiveDirectory(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
|
|
{ return _DoRunDll32(TEXT("dsquery.dll,OpenQueryWindow")); }
|
|
};
|
|
|
|
#define NETFLDR_EVENTS \
|
|
SHCNE_RENAMEITEM | SHCNE_RENAMEFOLDER | \
|
|
SHCNE_CREATE | SHCNE_DELETE | SHCNE_UPDATEDIR | SHCNE_UPDATEITEM | \
|
|
SHCNE_MKDIR | SHCNE_RMDIR
|
|
|
|
CNetFolderViewCB::CNetFolderViewCB(CNetFolder *pFolder) :
|
|
CBaseShellFolderViewCB(pFolder->_pidl, NETFLDR_EVENTS), _pFolder(pFolder)
|
|
{
|
|
_pFolder->AddRef();
|
|
}
|
|
|
|
CNetFolderViewCB::~CNetFolderViewCB()
|
|
{
|
|
_pFolder->Release();
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnINVOKECOMMAND(DWORD pv, UINT wP)
|
|
{
|
|
return CNetwork_DFMCallBackBG(_pFolder, _hwndMain, NULL, DFM_INVOKECOMMAND, wP, 0);
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGETHELPTEXT(DWORD pv, UINT wPl, UINT wPh, LPTSTR lP)
|
|
{
|
|
return CNetwork_DFMCallBackBG(_pFolder, _hwndMain, NULL, DFM_GETHELPTEXTW, MAKEWPARAM(wPl, wPh), (LPARAM)lP);
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnREFRESH(DWORD pv, BOOL fPreRefresh)
|
|
{
|
|
if (fPreRefresh)
|
|
{
|
|
RefreshNetCrawler();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnDELAYWINDOWCREATE(DWORD pv, HWND hwnd)
|
|
{
|
|
// only do delay window processing in the net root.
|
|
|
|
if (RESOURCEDISPLAYTYPE_GENERIC == _pFolder->_uDisplayType) // MyNetPlaces
|
|
{
|
|
RefreshNetCrawler();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGETCOLSAVESTREAM(DWORD pv, WPARAM wP, IStream **pps)
|
|
{
|
|
LPCTSTR pszValName;
|
|
|
|
switch (_pFolder->_uDisplayType)
|
|
{
|
|
case RESOURCEDISPLAYTYPE_DOMAIN:
|
|
pszValName = TEXT("NetDomainColsX");
|
|
break;
|
|
|
|
case RESOURCEDISPLAYTYPE_SERVER:
|
|
pszValName = TEXT("NetServerColsX");
|
|
break;
|
|
|
|
default:
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pps = OpenRegStream(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER, pszValName, (DWORD) wP);
|
|
return *pps ? S_OK : E_FAIL;
|
|
}
|
|
|
|
// HRESULT CNetFolderViewCB::OnGetZone(DWORD pv, DWORD * pdwZone);
|
|
|
|
HRESULT CNetFolderViewCB::OnEnumeratedItems(DWORD pv, UINT celt, LPCITEMIDLIST *rgpidl)
|
|
{
|
|
_cItems = celt;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnDefViewMode(DWORD pv, FOLDERVIEWMODE* pvm)
|
|
{
|
|
if (_cItems < DEFVIEW_FVM_MANY_CUTOFF)
|
|
*pvm = FVM_TILE;
|
|
else
|
|
*pvm = FVM_ICON; // used to pick icon only for My Net Places ((_pFolder->_uDisplayType == RESOURCEDISPLAYTYPE_GENERIC))
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGetDeferredViewSettings(DWORD pv, SFVM_DEFERRED_VIEW_SETTINGS* pSettings)
|
|
{
|
|
OnDefViewMode(pv, &pSettings->fvm);
|
|
|
|
// if this is the root folder then lets sort accordingly
|
|
if (_pFolder->_uDisplayType == RESOURCEDISPLAYTYPE_GENERIC)
|
|
{
|
|
pSettings->fGroupView = TRUE;
|
|
pSettings->uSortCol = ICOL_NETWORKLOCATION;
|
|
pSettings->iSortDirection = 1;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGetZone(DWORD pv, DWORD * pdwZone)
|
|
{
|
|
if (pdwZone)
|
|
*pdwZone = URLZONE_INTRANET; // default is "Local Intranet"
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CNetFolderViewCB::OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData)
|
|
{
|
|
ZeroMemory(pData, sizeof(*pData));
|
|
pData->dwLayout = SFVMWVL_NORMAL;
|
|
return S_OK;
|
|
}
|
|
|
|
// HNW is shown on X86 pro or personal workgroup only
|
|
HRESULT CNetFolderViewCB::_CanShowHNW(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
|
|
{
|
|
#ifdef _WIN64
|
|
*puisState = UIS_DISABLED;
|
|
return S_OK;
|
|
#else
|
|
if (IsOS(OS_ANYSERVER))
|
|
*puisState = UIS_DISABLED; // Server-type OS
|
|
else
|
|
*puisState = !IsOS(OS_DOMAINMEMBER) ? UIS_ENABLED : UIS_DISABLED;
|
|
return S_OK;
|
|
#endif
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::_CanViewComputersNearMe(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
|
|
{
|
|
if (!SHRestricted(REST_NOCOMPUTERSNEARME))
|
|
*puisState = !IsOS(OS_DOMAINMEMBER) ? UIS_ENABLED : UIS_DISABLED;
|
|
else
|
|
*puisState = UIS_DISABLED;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::_CanSearchActiveDirectory(IUnknown* pv, IShellItemArray *psiItemArray, BOOL fOkToBeSlow, UISTATE* puisState)
|
|
{
|
|
if (IsOS(OS_DOMAINMEMBER) && (GetEnvironmentVariable(TEXT("USERDNSDOMAIN"), NULL, 0) > 0))
|
|
*puisState = UIS_ENABLED;
|
|
else
|
|
*puisState = UIS_DISABLED;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::_OnViewNetConnections(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr = SHGetFolderLocation(NULL, CSIDL_CONNECTIONS, NULL, 0, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ((CNetFolderViewCB*)(void*)pv)->_BrowseObject(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::_DoRunDll32(LPTSTR pszParameters)
|
|
{
|
|
SHELLEXECUTEINFO sei = {0};
|
|
sei.cbSize = sizeof(sei);
|
|
sei.lpFile = TEXT("rundll32.exe");
|
|
sei.lpParameters = pszParameters;
|
|
sei.nShow = SW_SHOWNORMAL;
|
|
|
|
return ShellExecuteEx(&sei) ? S_OK : E_FAIL;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::_OnViewComputersNearMe(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr = SHGetFolderLocation(NULL, CSIDL_COMPUTERSNEARME, NULL, 0, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ((CNetFolderViewCB*)(void*)pv)->_BrowseObject(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
const WVTASKITEM c_MyNetPlacesTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_MYNETPLACES, IDS_HEADER_MYNETPLACES_TT);
|
|
const WVTASKITEM c_MyNetPlacesTaskList[] =
|
|
{
|
|
WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_ADDNETWORKPLACE, IDS_TASK_ADDNETWORKPLACE_TT, IDI_TASK_ADDNETWORKPLACE, NULL, CNetFolderViewCB::_OnAddNetworkPlace),
|
|
WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_VIEWNETCONNECTIONS, IDS_TASK_VIEWNETCONNECTIONS_TT, IDI_TASK_VIEWNETCONNECTIONS, NULL, CNetFolderViewCB::_OnViewNetConnections),
|
|
WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_HOMENETWORKWIZARD, IDS_TASK_HOMENETWORKWIZARD_TT, IDI_TASK_HOMENETWORKWIZARD, CNetFolderViewCB::_CanShowHNW, CNetFolderViewCB::_OnHomeNetworkWizard),
|
|
WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_COMPUTERSNEARME, IDS_TASK_COMPUTERSNEARME_TT, IDI_GROUP, CNetFolderViewCB::_CanViewComputersNearMe, CNetFolderViewCB::_OnViewComputersNearMe),
|
|
WVTI_ENTRY_ALL(CLSID_NULL, L"shell32.dll", IDS_TASK_SEARCHDS, IDS_TASK_SEARCHDS_TT, IDI_TASK_SEARCHDS, CNetFolderViewCB::_CanSearchActiveDirectory, CNetFolderViewCB::_OnSearchActiveDirectory),
|
|
};
|
|
|
|
BOOL CNetFolderViewCB::_EntireNetworkAvailable()
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
// Only enable if we're in a Domain
|
|
if (IsOS(OS_DOMAINMEMBER) && !SHRestricted(REST_NOENTIRENETWORK))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(CNetFolder::_CreateEntireNetworkFullIDList(&pidl)))
|
|
{
|
|
// ... and we're not already in the "Entire Network" folder.
|
|
if (!ILIsEqual(_pidl, pidl))
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData)
|
|
{
|
|
ZeroMemory(pData, sizeof(*pData));
|
|
|
|
Create_IUIElement(&c_MyNetPlacesTaskHeader, &(pData->pFolderTaskHeader));
|
|
|
|
LPCTSTR rgCsidls[] = { MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_PERSONAL), MAKEINTRESOURCE(CSIDL_COMMON_DOCUMENTS), MAKEINTRESOURCE(CSIDL_PRINTERS) };
|
|
|
|
if (_EntireNetworkAvailable())
|
|
{
|
|
LPITEMIDLIST pidlEntireNetwork = NULL;
|
|
CNetFolder::_CreateEntireNetworkFullIDList(&pidlEntireNetwork);
|
|
CreateIEnumIDListOnCSIDLs2(_pidl, pidlEntireNetwork, rgCsidls, ARRAYSIZE(rgCsidls), &(pData->penumOtherPlaces));
|
|
ILFree(pidlEntireNetwork);
|
|
}
|
|
else
|
|
{
|
|
CreateIEnumIDListOnCSIDLs(_pidl, rgCsidls, ARRAYSIZE(rgCsidls), &(pData->penumOtherPlaces));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CNetFolderViewCB::OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks)
|
|
{
|
|
ZeroMemory(pTasks, sizeof(*pTasks));
|
|
|
|
Create_IEnumUICommand((IUnknown*)(void*)this, c_MyNetPlacesTaskList, ARRAYSIZE(c_MyNetPlacesTaskList), &pTasks->penumFolderTasks);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolderViewCB::RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
HANDLE_MSG(0, SFVM_INVOKECOMMAND, OnINVOKECOMMAND);
|
|
HANDLE_MSG(0, SFVM_GETHELPTEXT, OnGETHELPTEXT);
|
|
HANDLE_MSG(0, SFVM_DELAYWINDOWCREATE, OnDELAYWINDOWCREATE);
|
|
HANDLE_MSG(0, SFVM_GETCOLSAVESTREAM, OnGETCOLSAVESTREAM);
|
|
HANDLE_MSG(0, SFVM_GETZONE, OnGetZone);
|
|
HANDLE_MSG(0, SFVM_ENUMERATEDITEMS, OnEnumeratedItems);
|
|
HANDLE_MSG(0, SFVM_DEFVIEWMODE, OnDefViewMode);
|
|
HANDLE_MSG(0, SFVM_GETDEFERREDVIEWSETTINGS, OnGetDeferredViewSettings);
|
|
HANDLE_MSG(0, SFVM_REFRESH, OnREFRESH);
|
|
HANDLE_MSG(0, SFVM_GETWEBVIEWLAYOUT, OnGetWebViewLayout);
|
|
HANDLE_MSG(0, SFVM_GETWEBVIEWCONTENT, OnGetWebViewContent);
|
|
HANDLE_MSG(0, SFVM_GETWEBVIEWTASKS, OnGetWebViewTasks);
|
|
|
|
default:
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// Replace all the space characters in the provider name with '_'.
|
|
void ReplaceSpacesWithUnderscore(LPTSTR psz)
|
|
{
|
|
while (psz = StrChr(psz, TEXT(' ')))
|
|
{
|
|
*psz = TEXT('_');
|
|
psz++; // DBCS safe
|
|
}
|
|
}
|
|
|
|
BOOL CNetFolderViewCB::_GetProviderKeyName(LPTSTR pszName, UINT uNameLen)
|
|
{
|
|
if (_pFolder->_GetProvider(NULL, NULL, pszName, uNameLen))
|
|
{
|
|
ReplaceSpacesWithUnderscore(pszName);
|
|
}
|
|
return (BOOL)*pszName;
|
|
}
|
|
|
|
|
|
// Define a collate order for the hood object types
|
|
#define _HOOD_COL_RON 0
|
|
#define _HOOD_COL_REMOTE 1
|
|
#define _HOOD_COL_FILE 2
|
|
#define _HOOD_COL_NET 3
|
|
|
|
const static ICONMAP c_aicmpNet[] = {
|
|
{ SHID_NET_NETWORK , II_NETWORK },
|
|
{ SHID_NET_DOMAIN , II_GROUP },
|
|
{ SHID_NET_SERVER , II_SERVER },
|
|
{ SHID_NET_SHARE , (UINT)EIRESID(IDI_SERVERSHARE) },
|
|
{ SHID_NET_DIRECTORY , II_FOLDER },
|
|
{ SHID_NET_PRINTER , II_PRINTER },
|
|
{ SHID_NET_RESTOFNET , II_WORLD },
|
|
{ SHID_NET_SHAREADMIN , II_DRIVEFIXED },
|
|
{ SHID_NET_TREE , II_TREE },
|
|
{ SHID_NET_NDSCONTAINER, (UINT)EIRESID(IDI_NDSCONTAINER) },
|
|
};
|
|
|
|
enum
|
|
{
|
|
NKID_PROVIDERTYPE = 0,
|
|
NKID_PROVIDER,
|
|
NKID_NETCLASS,
|
|
NKID_NETWORK,
|
|
NKID_DIRECTORY,
|
|
NKID_FOLDER
|
|
};
|
|
|
|
#define NKID_COUNT 6
|
|
|
|
|
|
// This is one-entry cache for remote junctions resolution
|
|
TCHAR g_szLastAttemptedJunctionName[MAX_PATH] = {0};
|
|
TCHAR g_szLastResolvedJunctionName[MAX_PATH] = {0};
|
|
|
|
REGITEMSINFO g_riiNetRoot =
|
|
{
|
|
REGSTR_PATH_EXPLORER TEXT("\\NetworkNeighborhood\\NameSpace"),
|
|
NULL,
|
|
TEXT(':'),
|
|
SHID_NET_REGITEM,
|
|
1,
|
|
SFGAO_CANLINK,
|
|
0,
|
|
NULL,
|
|
RIISA_ORIGINAL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
CNetRootFolder* CNetRootFolder::_spThis = NULL;
|
|
|
|
HRESULT CNetFolder::_CreateInstance(LPCITEMIDLIST pidlAbs, LPCITEMIDLIST pidlTarget, UINT uDisplayType,
|
|
LPCIDNETRESOURCE pidnForProvider, LPCTSTR pszResName,
|
|
REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (!ILIsEmpty(pidlAbs))
|
|
{
|
|
CNetFolder* pNetF = new CNetFolder(NULL);
|
|
if (NULL != pNetF)
|
|
{
|
|
pNetF->_uDisplayType = uDisplayType;
|
|
|
|
if (pidnForProvider)
|
|
{
|
|
//Make sure that the pidnProvider has provider information.
|
|
ASSERT(NET_FHasProvider(pidnForProvider))
|
|
|
|
//We are interested only in the provider informarion which is contained in the first entry.
|
|
//Its enough if we clone only the first item in the pidl.
|
|
pNetF->_pidnForProvider = (LPCIDNETRESOURCE)ILCloneFirst((LPCITEMIDLIST)pidnForProvider);
|
|
}
|
|
|
|
if (pszResName && *pszResName)
|
|
pNetF->_pszResName = StrDup(pszResName);
|
|
|
|
pNetF->_pidl = ILClone(pidlAbs);
|
|
pNetF->_pidlTarget = ILClone(pidlTarget);
|
|
|
|
if (pNetF->_pidl && (!pidlTarget || (pidlTarget && pNetF->_pidlTarget)))
|
|
{
|
|
if (uDisplayType == RESOURCEDISPLAYTYPE_SERVER)
|
|
{
|
|
// This is a remote computer. See if there are any remote
|
|
// computer registry items. If so, aggregate with the registry
|
|
// class.
|
|
|
|
REGITEMSINFO riiComputer =
|
|
{
|
|
REGSTR_PATH_EXPLORER TEXT("\\RemoteComputer\\NameSpace"),
|
|
NULL,
|
|
TEXT(':'),
|
|
SHID_NET_REMOTEREGITEM,
|
|
-1,
|
|
SFGAO_FOLDER | SFGAO_CANLINK,
|
|
0, // no required reg items
|
|
NULL,
|
|
RIISA_ORIGINAL,
|
|
pszResName,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
CRegFolder_CreateInstance(&riiComputer,
|
|
(IUnknown*) (IShellFolder*) pNetF,
|
|
IID_PPV_ARG(IUnknown, &pNetF->_punkReg));
|
|
}
|
|
else if (uDisplayType == RESOURCEDISPLAYTYPE_ROOT)
|
|
{
|
|
//
|
|
// this is the entire net icon, so lets create an instance of the regitem folder
|
|
// so we can merge in the items from there.
|
|
//
|
|
|
|
REGITEMSINFO riiEntireNet =
|
|
{
|
|
REGSTR_PATH_EXPLORER TEXT("\\NetworkNeighborhood\\EntireNetwork\\NameSpace"),
|
|
NULL,
|
|
TEXT(':'),
|
|
SHID_NET_REGITEM,
|
|
-1,
|
|
SFGAO_CANLINK,
|
|
0, // no required reg items
|
|
NULL,
|
|
RIISA_ORIGINAL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
CRegFolder_CreateInstance(&riiEntireNet,
|
|
(IUnknown*) (IShellFolder*) pNetF,
|
|
IID_PPV_ARG(IUnknown, &pNetF->_punkReg));
|
|
}
|
|
else
|
|
{
|
|
ASSERT(hr == E_OUTOFMEMORY);
|
|
}
|
|
hr = pNetF->QueryInterface(riid, ppv);
|
|
}
|
|
pNetF->Release();
|
|
}
|
|
else
|
|
{
|
|
ASSERT(hr == E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0);
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetwork_CreateInstance(IUnknown* punkOuter, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
*ppv = NULL;
|
|
|
|
// Must enter critical section to avoid racing against v_HandleDelete
|
|
ENTERCRITICAL;
|
|
|
|
if (NULL != CNetRootFolder::_spThis)
|
|
{
|
|
hr = CNetRootFolder::_spThis->QueryInterface(riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
CNetRootFolder* pNetRootF = new CNetRootFolder(punkOuter);
|
|
if (pNetRootF)
|
|
{
|
|
// Initialize it ourselves to ensure that the cached value
|
|
// is the correct one.
|
|
hr = pNetRootF->Initialize((LPCITEMIDLIST)&c_idlNet);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pNetRootF->_uDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
|
|
ASSERT(NULL == pNetRootF->_punkReg);
|
|
|
|
if (SHRestricted(REST_NOSETFOLDERS))
|
|
g_riiNetRoot.iReqItems = 0;
|
|
|
|
// create the regitems object, he has the NetRoot object as his outer guy.
|
|
|
|
hr = CRegFolder_CreateInstance(&g_riiNetRoot,
|
|
SAFECAST(pNetRootF, IShellFolder2*),
|
|
IID_PPV_ARG(IUnknown, &pNetRootF->_punkReg));
|
|
|
|
// NOTE: not using SHInterlockedCompareExchange() because we have the critsec
|
|
CNetRootFolder::_spThis = pNetRootF;
|
|
hr = pNetRootF->QueryInterface(riid, ppv);
|
|
}
|
|
|
|
// Release the self-reference, but keep the the _spThis pointer intact
|
|
// (it will be reset to NULL in the destructor)
|
|
pNetRootF->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
LEAVECRITICAL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
CNetFolder::CNetFolder(IUnknown* punkOuter) :
|
|
CAggregatedUnknown (punkOuter)
|
|
{
|
|
// Assert that we're still using a zero-init flag inside the new operator
|
|
ASSERT(NULL == _pidl);
|
|
ASSERT(NULL == _pidlTarget);
|
|
ASSERT(NULL == _pidnForProvider);
|
|
ASSERT(NULL == _pszResName);
|
|
ASSERT(0 == _uDisplayType);
|
|
ASSERT(NULL == _psfFiles);
|
|
ASSERT(NULL == _punkReg);
|
|
|
|
DllAddRef();
|
|
}
|
|
|
|
|
|
CNetFolder::~CNetFolder()
|
|
{
|
|
ILFree(_pidl);
|
|
ILFree(_pidlTarget);
|
|
ILFree((LPITEMIDLIST)_pidnForProvider);
|
|
|
|
if (NULL != _pszResName)
|
|
{
|
|
LocalFree(_pszResName);
|
|
}
|
|
|
|
if (_psfFiles)
|
|
{
|
|
_psfFiles->Release();
|
|
}
|
|
|
|
SHReleaseInnerInterface(SAFECAST(this, IShellFolder *), &_punkReg);
|
|
DllRelease();
|
|
}
|
|
|
|
CNetFolder *FolderToNetFolder(IUnknown *punk)
|
|
{
|
|
CNetFolder * pThis = NULL;
|
|
return punk && SUCCEEDED(punk->QueryInterface(CLSID_CNetFldr, (void **)&pThis)) ? pThis : NULL;
|
|
}
|
|
|
|
HRESULT CNetFolder::v_InternalQueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CNetFolder, IShellFolder2), // IID_IShellFolder2
|
|
QITABENTMULTI(CNetFolder, IShellFolder, IShellFolder2), // IID_IShellFolder
|
|
QITABENT(CNetFolder, IPersistFolder3), // IID_IPersistFolder3
|
|
QITABENT(CNetFolder, IShellIconOverlay), // IID_IShellIconOverlay
|
|
QITABENTMULTI(CNetFolder, IPersistFolder2, IPersistFolder3), // IID_IPersistFolder2
|
|
QITABENTMULTI(CNetFolder, IPersistFolder, IPersistFolder3), // IID_IPersistFolder
|
|
QITABENTMULTI(CNetFolder, IPersist, IPersistFolder3), // IID_IPersist
|
|
QITABENTMULTI2(CNetFolder, IID_IPersistFreeThreadedObject, IPersist), // IID_IPersistFreeThreadedObject
|
|
{ 0 },
|
|
};
|
|
|
|
if (IsEqualIID(riid, CLSID_CNetFldr))
|
|
{
|
|
*ppv = this; // get class pointer (unrefed!)
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT hr;
|
|
if (_punkReg && RegGetsFirstShot(riid))
|
|
{
|
|
hr = _punkReg->QueryInterface(riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
hr = QISearch(this, qit, riid, ppv);
|
|
if ((E_NOINTERFACE == hr) && _punkReg)
|
|
{
|
|
hr = _punkReg->QueryInterface(riid, ppv);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
BOOL CNetRootFolder::v_HandleDelete(PLONG pcRef)
|
|
{
|
|
ASSERT(NULL != pcRef);
|
|
|
|
ENTERCRITICAL;
|
|
|
|
// Once inside the critical section things are slightly more stable.
|
|
// CNetwork_CreateInstance won't be able to rescue the cached reference
|
|
// (and bump the refcount from 0 to 1). And we don't have to worry
|
|
// about somebody Release()ing us down to zero a second time, since
|
|
// no new references can show up.
|
|
//
|
|
// HOWEVER! All those scary things could've happened WHILE WE WERE
|
|
// WAITING TO ENTER THE CRITICAL SECTION.
|
|
//
|
|
// While we were waiting, somebody could've called CNetwork_CreateInstance,
|
|
// which bumps the reference count back up. So don't destroy ourselves
|
|
// if our object got "rescued".
|
|
//
|
|
// What's more, while we were waiting, that somebody could've then
|
|
// Release()d us back down to zero, causing us to be called on that
|
|
// other thread, notice that the refcount is indeed zero, and destroy
|
|
// the object, all on that other thread. So if we are not the cached
|
|
// instance, then don't destroy ourselves since that other thread did
|
|
// it already.
|
|
//
|
|
// And even more, somebody might call CNetwork_CreateInstance again
|
|
// and create a brand new object, which might COINCIDENTALLY happen
|
|
// to have the same address as the old object we are trying to destroy
|
|
// here. But in that case, it's okay to destroy the new object because
|
|
// it is indeed the case that the object's reference count is zero and
|
|
// deserves to be destroyed.
|
|
|
|
if (this == _spThis && 0 == *pcRef)
|
|
{
|
|
*pcRef = 1000; // protect against cached pointers bumping us up then down
|
|
delete this;
|
|
}
|
|
LEAVECRITICAL;
|
|
// return TRUE to indicate that we've implemented this function
|
|
// (regardless of whether or not this object was actually deleted)
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::ParseDisplayName(HWND hwnd, LPBC pbc, WCHAR* pszName, ULONG* pchEaten,
|
|
LPITEMIDLIST* ppidl, DWORD* pdwAttributes)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
// new for Win2K, this enables enuming the hidden admin shares
|
|
#ifndef RESOURCE_SHAREABLE
|
|
#define RESOURCE_SHAREABLE 0x00000006
|
|
#endif
|
|
|
|
//
|
|
// in:
|
|
// hwnd NULL indicates no UI.
|
|
// grfFlags IShellFolder::EnumObjects() SHCONTF_ flags
|
|
// pnr in/out params
|
|
//
|
|
//
|
|
DWORD CNetFolder::_OpenEnum(HWND hwnd, DWORD grfFlags, LPNETRESOURCE pnr, HANDLE *phEnum)
|
|
{
|
|
DWORD dwType = (grfFlags & SHCONTF_NETPRINTERSRCH) ? RESOURCETYPE_PRINT : RESOURCETYPE_ANY;
|
|
DWORD dwScope = pnr ? RESOURCE_GLOBALNET : RESOURCE_CONTEXT;
|
|
|
|
if ((_uDisplayType == RESOURCEDISPLAYTYPE_SERVER) &&
|
|
(grfFlags & SHCONTF_SHAREABLE))
|
|
{
|
|
dwScope = RESOURCE_SHAREABLE; // hidden admin shares for this server
|
|
}
|
|
|
|
DWORD err = WNetOpenEnum(dwScope, dwType, RESOURCEUSAGE_ALL, pnr, phEnum);
|
|
if ((err != WN_SUCCESS) && hwnd)
|
|
{
|
|
// If it failed because you are not authenticated yet,
|
|
// we need to let the user loggin to this network resource.
|
|
//
|
|
// REVIEW: Ask LenS to review this code.
|
|
if (err == WN_NOT_AUTHENTICATED ||
|
|
err == ERROR_LOGON_FAILURE ||
|
|
err == WN_BAD_PASSWORD ||
|
|
err == WN_ACCESS_DENIED)
|
|
{
|
|
// Retry with password dialog box.
|
|
err = WNetAddConnection3(hwnd, pnr, NULL, NULL, CONNECT_TEMPORARY | CONNECT_INTERACTIVE);
|
|
if (err == WN_SUCCESS)
|
|
err = WNetOpenEnum(dwScope, dwType, RESOURCEUSAGE_ALL, pnr, phEnum);
|
|
}
|
|
|
|
UINT idTemplate = pnr && pnr->lpRemoteName ? IDS_ENUMERR_NETTEMPLATE2 : IDS_ENUMERR_NETTEMPLATE1;
|
|
SHEnumErrorMessageBox(hwnd, idTemplate, err, pnr ? pnr->lpRemoteName : NULL, TRUE, MB_OK | MB_ICONHAND);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
// find the share part of a UNC
|
|
// \\server\share
|
|
// return pointer to "share" or pointer to empty string if none
|
|
|
|
LPCTSTR PathFindShareName(LPCTSTR pszUNC)
|
|
{
|
|
LPCTSTR psz = SkipServerSlashes(pszUNC);
|
|
if (*psz)
|
|
{
|
|
psz = StrChr(psz + 1, TEXT('\\'));
|
|
if (psz)
|
|
psz++;
|
|
else
|
|
psz = TEXT("");
|
|
}
|
|
return psz;
|
|
}
|
|
|
|
// Flags for the dwRemote field
|
|
#define RMF_CONTEXT 0x00000001 // Entire network is being enumerated
|
|
#define RMF_SHOWREMOTE 0x00000002 // Return Remote Services for next enumeration
|
|
#define RMF_STOP_ENUM 0x00000004 // Stop enumeration
|
|
#define RMF_GETLINKENUM 0x00000008 // Hoodlinks enum needs to be fetched
|
|
#define RMF_SHOWLINKS 0x00000010 // Hoodlinks need to be shown
|
|
#define RMF_FAKENETROOT 0x00000020 // Don't enumerate the workgroup items
|
|
|
|
#define RMF_ENTIRENETSHOWN 0x40000000 // Entire network object shown
|
|
#define RMF_REMOTESHOWN 0x80000000 // Return Remote Services for next enumeration
|
|
|
|
|
|
class CNetFolderEnum : public CEnumIDListBase
|
|
{
|
|
public:
|
|
// IEnumIDList
|
|
STDMETHOD(Next)(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched);
|
|
|
|
private:
|
|
CNetFolderEnum(CNetFolder *pnf, DWORD grfFlags, DWORD dwRemote, HANDLE hEnum);
|
|
~CNetFolderEnum();
|
|
friend HRESULT Create_NetFolderEnum(CNetFolder* pnsf, DWORD grfFlags, DWORD dwRemote, HANDLE hEnum, IEnumIDList** ppenum);
|
|
|
|
CNetFolder *_pnsf; // CNetFolder object we're enumerating
|
|
HANDLE _hEnum;
|
|
DWORD _grfFlags;
|
|
LONG _cItems; // Count of items in buffer
|
|
LONG _iItem; // Current index of the item in the buffer
|
|
DWORD _dwRemote;
|
|
union {
|
|
NETRESOURCE _anr[0];
|
|
BYTE _szBuffer[8192];
|
|
};
|
|
IEnumIDList *_peunk; // used for enumerating file system items (links)
|
|
};
|
|
|
|
CNetFolderEnum::CNetFolderEnum(CNetFolder *pnsf, DWORD grfFlags, DWORD dwRemote, HANDLE hEnum) : CEnumIDListBase()
|
|
{
|
|
_pnsf = pnsf;
|
|
_pnsf->AddRef();
|
|
|
|
_grfFlags = grfFlags;
|
|
_dwRemote = dwRemote;
|
|
|
|
_hEnum = hEnum;
|
|
}
|
|
|
|
HRESULT Create_NetFolderEnum(CNetFolder* pnf, DWORD grfFlags, DWORD dwRemote, HANDLE hEnum, IEnumIDList** ppenum)
|
|
{
|
|
HRESULT hr;
|
|
CNetFolderEnum* p= new CNetFolderEnum(pnf, grfFlags, dwRemote, hEnum);
|
|
if (p)
|
|
{
|
|
hr = p->QueryInterface(IID_PPV_ARG(IEnumIDList, ppenum));
|
|
p->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
*ppenum = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
CNetFolderEnum::~CNetFolderEnum()
|
|
{
|
|
_pnsf->Release(); // release the "this" ptr we have
|
|
|
|
if (_peunk)
|
|
_peunk->Release();
|
|
|
|
if (_hEnum)
|
|
WNetCloseEnum(_hEnum);
|
|
}
|
|
|
|
STDMETHODIMP CNetFolderEnum::Next(ULONG celt, LPITEMIDLIST *ppidl, ULONG *pceltFetched)
|
|
{
|
|
HRESULT hr;
|
|
|
|
*ppidl = NULL;
|
|
if (pceltFetched)
|
|
*pceltFetched = 0;
|
|
|
|
// Time to stop enumeration?
|
|
if (_dwRemote & RMF_STOP_ENUM)
|
|
return S_FALSE; // Yes
|
|
|
|
// should we try and get the links enumerator?
|
|
if (_dwRemote & RMF_GETLINKENUM)
|
|
{
|
|
IShellFolder2* psfNetHood;
|
|
if (SUCCEEDED(_pnsf->v_GetFileFolder(&psfNetHood)))
|
|
psfNetHood->EnumObjects(NULL, _grfFlags, &_peunk);
|
|
|
|
if (_peunk)
|
|
_dwRemote |= RMF_SHOWLINKS;
|
|
|
|
_dwRemote &= ~RMF_GETLINKENUM;
|
|
}
|
|
|
|
// should we be showing the links?
|
|
if (_dwRemote & RMF_SHOWLINKS)
|
|
{
|
|
if (_peunk)
|
|
{
|
|
ULONG celtFetched;
|
|
LPITEMIDLIST pidl;
|
|
|
|
hr = _peunk->Next(1, &pidl, &celtFetched);
|
|
if (hr == S_OK && celtFetched == 1)
|
|
{
|
|
*ppidl = pidl;
|
|
if (pceltFetched)
|
|
*pceltFetched = celtFetched;
|
|
return S_OK; // Added link
|
|
}
|
|
}
|
|
|
|
_dwRemote &= ~RMF_SHOWLINKS; // Done enumerating links
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
// Do we add the remote folder?
|
|
// (Note: as a hack to ensure that the remote folder is added
|
|
// to the 'hood despite what MPR says, RMF_SHOWREMOTE can be
|
|
// set without RMF_CONTEXT set.)
|
|
if ((_dwRemote & RMF_SHOWREMOTE) && !(_dwRemote & RMF_REMOTESHOWN))
|
|
{
|
|
// Yes
|
|
// Only try to put the remote entry in once.
|
|
_dwRemote |= RMF_REMOTESHOWN;
|
|
|
|
// Is this not the Context container?
|
|
// (See note above as to why we are asking this question.)
|
|
if (!(_dwRemote & RMF_CONTEXT))
|
|
{
|
|
// Yes; stop after the next time
|
|
_dwRemote |= RMF_STOP_ENUM;
|
|
}
|
|
|
|
// We have fallen thru because the remote services is not
|
|
// installed.
|
|
|
|
// Is this not the Context container AND the remote folder
|
|
// is not installed?
|
|
if (!(_dwRemote & RMF_CONTEXT))
|
|
{
|
|
// Yes; nothing else to enumerate
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
if (_dwRemote & RMF_FAKENETROOT)
|
|
{
|
|
if ((!(_dwRemote & RMF_ENTIRENETSHOWN)) &&
|
|
(S_FALSE != SHShouldShowWizards(_punkSite)))
|
|
{
|
|
_pnsf->_CreateEntireNetwork(ppidl); // fake entire net
|
|
_dwRemote |= RMF_ENTIRENETSHOWN;
|
|
}
|
|
else
|
|
{
|
|
return S_FALSE; // no more to enumerate
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (TRUE)
|
|
{
|
|
ULONG err = WN_SUCCESS;
|
|
LPNETRESOURCE pnr;
|
|
|
|
if (_iItem >= _cItems)
|
|
{
|
|
DWORD dwSize = sizeof(_szBuffer);
|
|
|
|
_cItems = -1; // its signed
|
|
_iItem = 0;
|
|
|
|
err = WNetEnumResource(_hEnum, (DWORD*)&_cItems, _szBuffer, &dwSize);
|
|
DebugMsg(DM_TRACE, TEXT("Net EnumCallback: err=%d Count=%d"), err, _cItems);
|
|
}
|
|
|
|
pnr = &_anr[_iItem++];
|
|
|
|
// Note: the <= below is correct as we already incremented the index...
|
|
if (err == WN_SUCCESS && (_iItem <= _cItems))
|
|
{
|
|
// decide if the thing is a folder or not
|
|
ULONG grfFlagsItem = ((pnr->dwUsage & RESOURCEUSAGE_CONTAINER) ||
|
|
(pnr->dwType == RESOURCETYPE_DISK) ||
|
|
(pnr->dwType == RESOURCETYPE_ANY)) ?
|
|
SHCONTF_FOLDERS : SHCONTF_NONFOLDERS;
|
|
|
|
// If this is the context enumeration, we want to insert the
|
|
// Remote Services after the first container.
|
|
//
|
|
// Remember that we need to return the Remote Services in the next iteration.
|
|
|
|
if ((pnr->dwUsage & RESOURCEUSAGE_CONTAINER) &&
|
|
(_dwRemote & RMF_CONTEXT))
|
|
{
|
|
_dwRemote |= RMF_SHOWREMOTE;
|
|
}
|
|
|
|
if ((_pnsf->_uDisplayType == RESOURCEDISPLAYTYPE_SERVER) &&
|
|
(_grfFlags & SHCONTF_SHAREABLE))
|
|
{
|
|
// filter out ADMIN$ and IPC$, based on str len
|
|
if (lstrlen(PathFindShareName(pnr->lpRemoteName)) > 2)
|
|
{
|
|
grfFlagsItem = 0;
|
|
}
|
|
}
|
|
|
|
// if this is a network object, work out if we should hide or note, so
|
|
// convert the provider to its type number and open the key under:
|
|
//
|
|
// HKEY_CLASSES_ROOT\Network\Type\<type string>
|
|
|
|
if ((pnr->dwDisplayType == RESOURCEDISPLAYTYPE_NETWORK) &&
|
|
!(_grfFlags & SHCONTF_INCLUDEHIDDEN))
|
|
{
|
|
DWORD dwType;
|
|
if (WNetGetProviderType(pnr->lpProvider, &dwType) == WN_SUCCESS)
|
|
{
|
|
TCHAR szRegValue[MAX_PATH];
|
|
wsprintf(szRegValue, TEXT("Network\\Type\\%d"), HIWORD(dwType));
|
|
|
|
BOOL fHide = FALSE;
|
|
DWORD cb = sizeof(fHide);
|
|
if ((ERROR_SUCCESS == SHGetValue(HKEY_CLASSES_ROOT, szRegValue, TEXT("HideProvider"), NULL, &fHide, &cb)) && fHide)
|
|
{
|
|
grfFlagsItem = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if we found requested type of net resource.
|
|
if (_grfFlags & grfFlagsItem)
|
|
{
|
|
if (SUCCEEDED(_pnsf->_NetResToIDList(pnr, FALSE, TRUE, (_grfFlags & SHCONTF_NONFOLDERS), ppidl)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (err == WN_NO_MORE_ENTRIES)
|
|
{
|
|
hr = S_FALSE; // no more element
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("sh ER - WNetEnumResource failed (%lx)"), err);
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = (S_OK == hr) ? 1 : 0;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList** ppenum)
|
|
{
|
|
NETRESOURCE nr = {0};
|
|
TCHAR szProvider[MAX_PATH];
|
|
|
|
nr.lpProvider = (LPTSTR) _GetProvider(NULL, NULL, szProvider, ARRAYSIZE(szProvider));
|
|
|
|
if (_uDisplayType != RESOURCEDISPLAYTYPE_ROOT &&
|
|
_uDisplayType != RESOURCEDISPLAYTYPE_NETWORK)
|
|
{
|
|
nr.lpRemoteName = _pszResName;
|
|
}
|
|
|
|
HRESULT hr;
|
|
HANDLE hEnum;
|
|
DWORD err = _OpenEnum(hwnd, grfFlags, &nr, &hEnum);
|
|
if (err == WN_SUCCESS)
|
|
{
|
|
hr = Create_NetFolderEnum(this, grfFlags, 0, hEnum, ppenum);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
WNetCloseEnum(hEnum);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(err);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
LPCIDNETRESOURCE NET_IsValidID(LPCITEMIDLIST pidl)
|
|
{
|
|
if (pidl && !ILIsEmpty(pidl) && ((pidl->mkid.abID[0] & SHID_GROUPMASK) == SHID_NET))
|
|
return (LPCIDNETRESOURCE)pidl;
|
|
return NULL;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
LPCIDNETRESOURCE pidn;
|
|
|
|
*ppv = NULL;
|
|
|
|
pidn = NET_IsValidID(pidl);
|
|
if (pidn)
|
|
{
|
|
IShellFolder *psfJunction;
|
|
LPITEMIDLIST pidlInit = NULL;
|
|
LPITEMIDLIST pidlTarget = NULL;
|
|
LPCITEMIDLIST pidlRight = _ILNext(pidl);
|
|
BOOL fRightIsEmpty = ILIsEmpty(pidlRight);
|
|
LPCIDNETRESOURCE pidnProvider = NET_FHasProvider(pidn) ? pidn :_pidnForProvider;
|
|
|
|
hr = S_OK;
|
|
|
|
// lets get the IDLISTs we are going to use to initialize the shell folder
|
|
// if we are doing a single level bind then then ILCombine otherwise
|
|
// be more careful.
|
|
|
|
pidlInit = ILCombineParentAndFirst(_pidl, pidl, pidlRight);
|
|
if (_pidlTarget)
|
|
pidlTarget = ILCombineParentAndFirst(_pidlTarget, pidl, pidlRight);
|
|
|
|
if (!pidlInit || (!pidlTarget && _pidlTarget))
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
// now create the folder object we are using, and either return that
|
|
// object to the caller, or continue the binding down.
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _CreateFolderForItem(pbc, pidlInit, pidlTarget, pidnProvider,
|
|
fRightIsEmpty ? riid : IID_IShellFolder,
|
|
fRightIsEmpty ? ppv : (void **)&psfJunction);
|
|
|
|
if (!fRightIsEmpty && SUCCEEDED(hr))
|
|
{
|
|
hr = psfJunction->BindToObject(pidlRight, pbc, riid, ppv);
|
|
psfJunction->Release();
|
|
}
|
|
}
|
|
|
|
ILFree(pidlInit);
|
|
ILFree(pidlTarget);
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
return BindToObject(pidl, pbc, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::CompareIDs(LPARAM iCol, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
LPCIDNETRESOURCE pidn1 = NET_IsValidID(pidl1);
|
|
LPCIDNETRESOURCE pidn2 = NET_IsValidID(pidl2);
|
|
|
|
if (pidn1 && pidn2)
|
|
{
|
|
TCHAR szBuff1[MAX_PATH], szBuff2[MAX_PATH];
|
|
|
|
switch (iCol & SHCIDS_COLUMNMASK)
|
|
{
|
|
case ICOL_COMMENT:
|
|
{
|
|
hr = ResultFromShort(StrCmpLogicalRestricted(NET_CopyComment(pidn1, szBuff1, ARRAYSIZE(szBuff1)),
|
|
NET_CopyComment(pidn2, szBuff2, ARRAYSIZE(szBuff2))));
|
|
|
|
if (hr != 0)
|
|
return hr;
|
|
|
|
// drop down into the name comparison
|
|
}
|
|
|
|
case ICOL_NAME:
|
|
{
|
|
// Compare by name. This is the one case where we need to handle
|
|
// simple ids in either place. We will try to resync the items
|
|
// if we find a case of this before do the compares.
|
|
// Check for relative IDs. In particular if one item is at
|
|
// a server and the other is at RestOfNet then try to resync
|
|
// the two
|
|
//
|
|
|
|
if (NET_IsFake(pidn1) || NET_IsFake(pidn2))
|
|
{
|
|
// if either pidn1 or pidn2 is fake then we assume they are identical,
|
|
// this allows us to compare a simple net ID to a real net ID. we
|
|
// assume that if this fails later then the world will be happy
|
|
|
|
hr = 0;
|
|
}
|
|
else
|
|
{
|
|
// otherwise lets look at the names and provider strings accordingly
|
|
|
|
NET_CopyResName(pidn1, szBuff1, ARRAYSIZE(szBuff1));
|
|
NET_CopyResName(pidn2, szBuff2, ARRAYSIZE(szBuff2));
|
|
hr = ResultFromShort(StrCmpLogicalRestricted(szBuff1, szBuff2));
|
|
|
|
// If they're still identical, compare provider names.
|
|
|
|
if ((hr == 0) && (iCol & SHCIDS_ALLFIELDS))
|
|
{
|
|
LPCTSTR pszProv1 = _GetProvider(pidn1, NULL, szBuff1, ARRAYSIZE(szBuff1));
|
|
LPCTSTR pszProv2 = _GetProvider(pidn2, NULL, szBuff2, ARRAYSIZE(szBuff2));
|
|
|
|
if (pszProv1 && pszProv2)
|
|
hr = ResultFromShort(lstrcmp(pszProv1, pszProv2));
|
|
else
|
|
{
|
|
if (pszProv1 || pszProv2)
|
|
hr = ResultFromShort(pszProv1 ? 1 : -1);
|
|
else
|
|
hr = ResultFromShort(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If they identical, compare the rest of IDs.
|
|
|
|
if (hr == 0)
|
|
hr = ILCompareRelIDs((IShellFolder*)this, (LPCITEMIDLIST)pidn1, (LPCITEMIDLIST)pidn2, iCol);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (IsEqualIID(riid, IID_IShellView))
|
|
{
|
|
SFV_CREATE sSFV;
|
|
|
|
sSFV.cbSize = sizeof(sSFV);
|
|
sSFV.psvOuter = NULL;
|
|
sSFV.psfvcb = new CNetFolderViewCB(this); // failure is OK, we just get generic support
|
|
|
|
QueryInterface(IID_PPV_ARG(IShellFolder, &sSFV.pshf)); // in case we are agregated
|
|
|
|
hr = SHCreateShellFolderView(&sSFV, (IShellView**) ppv);
|
|
|
|
if (sSFV.pshf)
|
|
sSFV.pshf->Release();
|
|
|
|
if (sSFV.psfvcb)
|
|
sSFV.psfvcb->Release();
|
|
}
|
|
else if (IsEqualIID(riid, IID_IContextMenu))
|
|
{
|
|
IShellFolder* psfOuter;
|
|
hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfOuter));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = CDefFolderMenu_Create(_pidl, hwnd, 0, NULL, psfOuter,
|
|
CNetwork_DFMCallBackBG, NULL, NULL, (IContextMenu**) ppv);
|
|
psfOuter->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
typedef HRESULT (CALLBACK *PFNGAOCALLBACK)(IShellFolder2 *psf, LPCITEMIDLIST pidl, ULONG* prgfInOut);
|
|
|
|
STDAPI GetAttributesCallback(IShellFolder2 *psf, UINT cidl, LPCITEMIDLIST* apidl, ULONG *prgfInOut, PFNGAOCALLBACK pfnGAOCallback)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG rgfOut = 0;
|
|
|
|
for (UINT i = 0; i < cidl; i++)
|
|
{
|
|
ULONG rgfT = *prgfInOut;
|
|
hr = pfnGAOCallback(psf, apidl[i], &rgfT);
|
|
if (FAILED(hr))
|
|
{
|
|
rgfOut = 0;
|
|
break;
|
|
}
|
|
rgfOut |= rgfT;
|
|
}
|
|
|
|
*prgfInOut &= rgfOut;
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST* apidl, ULONG* prgfInOut)
|
|
{
|
|
HRESULT hr;
|
|
if (IsSelf(cidl, apidl))
|
|
{
|
|
*prgfInOut &= (SFGAO_CANLINK | SFGAO_HASPROPSHEET | SFGAO_HASSUBFOLDER |
|
|
SFGAO_FOLDER | SFGAO_FILESYSANCESTOR);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = GetAttributesCallback(SAFECAST(this, IShellFolder2*), cidl, apidl, prgfInOut, _AttributesCallback);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, STRRET* pStrRet)
|
|
{
|
|
HRESULT hr;
|
|
LPCIDNETRESOURCE pidn = NET_IsValidID(pidl);
|
|
if (pidn)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
LPCITEMIDLIST pidlNext = _ILNext(pidl);
|
|
|
|
if (dwFlags & SHGDN_FORPARSING)
|
|
{
|
|
if ((dwFlags & SHGDN_INFOLDER) ||
|
|
((dwFlags & SHGDN_FORADDRESSBAR) && (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_ROOT))) // the non-infolder name for the root is not good for the address bar
|
|
{
|
|
NET_CopyResName(pidn, szPath, ARRAYSIZE(szPath));
|
|
if (ILIsEmpty(pidlNext))
|
|
{
|
|
// we just need the last part of the display name (IN FOLDER)
|
|
LPTSTR pszT = StrRChr(szPath, NULL, TEXT('\\'));
|
|
|
|
if (!pszT)
|
|
pszT = szPath;
|
|
else
|
|
pszT++; // move past '\'
|
|
hr = StringToStrRet(pszT, pStrRet);
|
|
}
|
|
else
|
|
{
|
|
hr = ILGetRelDisplayName((IShellFolder*) this, pStrRet, pidl, szPath, MAKEINTRESOURCE(IDS_DSPTEMPLATE_WITH_BACKSLASH), dwFlags);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LPCITEMIDLIST pidlRight = _ILNext(pidl);
|
|
|
|
if (ILIsEmpty(pidlRight))
|
|
{
|
|
hr = _GetPathForItem(pidn, szPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = StringToStrRet(szPath, pStrRet);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IShellFolder *psfJunction;
|
|
//Get the pidn which has network provider information.
|
|
LPCIDNETRESOURCE pidnProvider = NET_FHasProvider(pidn) ? pidn :_pidnForProvider;
|
|
LPITEMIDLIST pidlInit, pidlTarget = NULL;
|
|
|
|
pidlInit = ILCombineParentAndFirst(_pidl, pidl, pidlRight);
|
|
if (_pidlTarget)
|
|
pidlTarget = ILCombineParentAndFirst(_pidlTarget, pidl, pidlRight);
|
|
|
|
if (!pidlInit || (_pidlTarget && !pidlTarget))
|
|
return E_OUTOFMEMORY;
|
|
|
|
hr = _CreateFolderForItem(NULL, pidlInit, pidlTarget, pidnProvider, IID_PPV_ARG(IShellFolder, &psfJunction));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psfJunction->GetDisplayNameOf(pidlRight, dwFlags, pStrRet);
|
|
psfJunction->Release();
|
|
}
|
|
|
|
ILFree(pidlInit);
|
|
ILFree(pidlTarget);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = _GetFormatName(pidn, pStrRet);
|
|
if (SUCCEEDED(hr) && !(dwFlags & SHGDN_INFOLDER) && (NET_GetFlags(pidn) & SHID_JUNCTION))
|
|
{
|
|
TCHAR szServer[MAX_PATH];
|
|
SHGetNameAndFlags(_pidlTarget ? _pidlTarget:_pidl, SHGDN_FORPARSING, szServer, ARRAYSIZE(szServer), NULL);
|
|
|
|
TCHAR szDisplay[MAX_PATH];
|
|
hr = SHGetComputerDisplayName(szServer, 0x0, szDisplay, ARRAYSIZE(szDisplay));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
StrRetFormat(pStrRet, pidl, MAKEINTRESOURCE(IDS_DSPTEMPLATE_WITH_ON), szDisplay);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD dwRes, LPITEMIDLIST* ppidl)
|
|
{
|
|
if (ppidl)
|
|
*ppidl = NULL;
|
|
|
|
return E_NOTIMPL; // not supported
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST* apidl,
|
|
REFIID riid, UINT* prgfInOut, void **ppv)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
LPCIDNETRESOURCE pidn = cidl ? NET_IsValidID(apidl[0]) : NULL;
|
|
|
|
*ppv = NULL;
|
|
|
|
if ((IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) && pidn)
|
|
{
|
|
UINT iIndex;
|
|
|
|
if (_IsPrintShare(pidn))
|
|
iIndex = (UINT)EIRESID(IDI_PRINTER_NET);
|
|
else if (NET_IsRemoteFld(pidn))
|
|
iIndex = II_RNA;
|
|
else
|
|
iIndex = SILGetIconIndex(apidl[0], c_aicmpNet, ARRAYSIZE(c_aicmpNet));
|
|
|
|
hr = SHCreateDefExtIcon(NULL, iIndex, iIndex, GIL_PERCLASS, II_FOLDER, riid, ppv);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IContextMenu) && pidn)
|
|
{
|
|
HKEY ahkeys[NKID_COUNT];
|
|
|
|
hr = _OpenKeys(pidn, ahkeys);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolder* psfOuter;
|
|
hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfOuter));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = CDefFolderMenu_Create2(_pidl, hwnd, cidl, apidl,
|
|
psfOuter, _GetCallbackType(pidn),
|
|
ARRAYSIZE(ahkeys), ahkeys, (IContextMenu**) ppv);
|
|
psfOuter->Release();
|
|
}
|
|
|
|
SHRegCloseKeys(ahkeys, ARRAYSIZE(ahkeys));
|
|
}
|
|
}
|
|
else if (cidl && IsEqualIID(riid, IID_IDataObject))
|
|
{
|
|
// Point & Print printer installation assumes that the
|
|
// netresources from CNetData_GetData and the
|
|
// pidls from CIDLData_GetData are in the same order.
|
|
// Keep it this way.
|
|
|
|
CNetData *pnd = new CNetData(_pidl, cidl, apidl);
|
|
if (pnd)
|
|
{
|
|
hr = pnd->QueryInterface(riid, ppv);
|
|
pnd->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else if (pidn && IsEqualIID(riid, IID_IDropTarget))
|
|
{
|
|
// special support because this is an item (not a folder)
|
|
if (_IsPrintShare(pidn))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
hr = SHILCombine(_pidl, apidl[0], &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = CPrinterDropTarget_CreateInstance(hwnd, pidl, (IDropTarget**)ppv);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IShellFolder *psf;
|
|
|
|
hr = BindToObject(apidl[0], NULL, IID_PPV_ARG(IShellFolder, &psf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psf->CreateViewObject(hwnd, riid, ppv);
|
|
psf->Release();
|
|
}
|
|
}
|
|
}
|
|
else if (pidn && IsEqualIID(riid, IID_IQueryInfo))
|
|
{
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_ROOT)
|
|
{
|
|
hr = CreateInfoTipFromText(MAKEINTRESOURCE(IDS_RESTOFNETTIP), riid, ppv);
|
|
}
|
|
else
|
|
{
|
|
// Someday maybe have infotips for other things too
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::GetDefaultSearchGUID(LPGUID pguid)
|
|
{
|
|
*pguid = SRCID_SFindComputer;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void WINAPI CNetFolder::_CopyEnumElement(void* pDest, const void* pSource, DWORD dwSize)
|
|
{
|
|
if (pDest && pSource)
|
|
memcpy(pDest, pSource, dwSize);
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::EnumSearches(IEnumExtraSearch** ppenum)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
*ppenum = NULL;
|
|
|
|
// if the restriction is set then this item should be enumerated from the registry
|
|
// so we fail, else enumerate it
|
|
// only enumerate if we actually have a network to search against
|
|
if (!SHRestricted(REST_HASFINDCOMPUTERS) &&
|
|
(GetSystemMetrics(SM_NETWORK) & RNC_NETWORKS))
|
|
{
|
|
EXTRASEARCH *pxs = (EXTRASEARCH *)LocalAlloc(LPTR, sizeof(EXTRASEARCH));
|
|
if (pxs)
|
|
{
|
|
pxs->guidSearch = SRCID_SFindComputer;
|
|
if (LoadStringW(g_hinst, IDS_FC_NAME, pxs->wszFriendlyName, sizeof(pxs->wszFriendlyName)))
|
|
{
|
|
*ppenum = (IEnumExtraSearch*)CStandardEnum_CreateInstance(IID_IEnumExtraSearch, FALSE,
|
|
1, sizeof(EXTRASEARCH), pxs, _CopyEnumElement);
|
|
if (*ppenum == NULL)
|
|
{
|
|
LocalFree(pxs);
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::GetDefaultColumn(DWORD dwRes, ULONG* pSort, ULONG* pDisplay)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT CNetFolder::_GetDefaultColumnState(UINT cColumns, UINT iColumn, DWORD* pdwState)
|
|
{
|
|
*pdwState = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
if (iColumn < cColumns)
|
|
{
|
|
*pdwState = s_net_cols[iColumn].csFlags;
|
|
if (iColumn >= 1)
|
|
*pdwState |= SHCOLSTATE_SLOW; // comment is slow for net root
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID* pscid, VARIANT* pv)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
LPCIDNETRESOURCE pidn = NET_IsValidID(pidl);
|
|
if (pidn)
|
|
{
|
|
if (IsEqualSCID(*pscid, SCID_NETRESOURCE))
|
|
{
|
|
// Office calls SHGetDataFromIDList() with a large buffer to hold all
|
|
// of the strings in the NETRESOURCE structure, so we need to make sure
|
|
// that our variant can hold enough data to pass back to it:
|
|
BYTE rgBuffer[sizeof(NETRESOURCEW) + (4 * MAX_PATH * sizeof(WCHAR))];
|
|
hr = _GetNetResource(pidn, (NETRESOURCEW*) rgBuffer, sizeof(rgBuffer));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = InitVariantFromBuffer(pv, rgBuffer, sizeof(rgBuffer));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Fixup pointers in structure to point within the variant
|
|
// instead of our stack variable (rgBuffer):
|
|
ASSERT(pv->vt == (VT_ARRAY | VT_UI1));
|
|
NETRESOURCEW* pnrw = (NETRESOURCEW*) pv->parray->pvData;
|
|
if (pnrw->lpLocalName)
|
|
{
|
|
pnrw->lpLocalName = (LPWSTR) ((BYTE*) pnrw +
|
|
((BYTE*) pnrw->lpLocalName - rgBuffer));
|
|
}
|
|
if (pnrw->lpRemoteName)
|
|
{
|
|
pnrw->lpRemoteName = (LPWSTR) ((BYTE*) pnrw +
|
|
((BYTE*) pnrw->lpRemoteName - rgBuffer));
|
|
}
|
|
if (pnrw->lpComment)
|
|
{
|
|
pnrw->lpComment = (LPWSTR) ((BYTE*) pnrw +
|
|
((BYTE*) pnrw->lpComment - rgBuffer));
|
|
}
|
|
if (pnrw->lpProvider)
|
|
{
|
|
pnrw->lpProvider = (LPWSTR) ((BYTE*) pnrw +
|
|
((BYTE*) pnrw->lpProvider - rgBuffer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (IsEqualSCID(*pscid, SCID_DESCRIPTIONID))
|
|
{
|
|
SHDESCRIPTIONID did;
|
|
|
|
switch(SIL_GetType(pidl) & SHID_TYPEMASK)
|
|
{
|
|
case SHID_NET_DOMAIN:
|
|
did.dwDescriptionId = SHDID_NET_DOMAIN;
|
|
break;
|
|
|
|
case SHID_NET_SERVER:
|
|
did.dwDescriptionId = SHDID_NET_SERVER;
|
|
break;
|
|
|
|
case SHID_NET_SHARE:
|
|
did.dwDescriptionId = SHDID_NET_SHARE;
|
|
break;
|
|
|
|
case SHID_NET_RESTOFNET:
|
|
did.dwDescriptionId = SHDID_NET_RESTOFNET;
|
|
break;
|
|
|
|
default:
|
|
did.dwDescriptionId = SHDID_NET_OTHER;
|
|
break;
|
|
}
|
|
|
|
did.clsid = CLSID_NULL;
|
|
hr = InitVariantFromBuffer(pv, &did, sizeof(did));
|
|
}
|
|
else if (IsEqualSCID(*pscid, SCID_Comment))
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
hr = InitVariantFromStr(pv, NET_CopyComment(pidn, szTemp, ARRAYSIZE(szTemp)));
|
|
}
|
|
else if (IsEqualSCID(*pscid, SCID_NAME))
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
hr = InitVariantFromStr(pv, NET_CopyResName(pidn, szTemp, ARRAYSIZE(szTemp)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
hr = v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->GetDetailsEx(pidl, pscid, pv);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetFolder::_GetDetailsOf(UINT cColumns, LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
pDetails->str.uType = STRRET_CSTR;
|
|
pDetails->str.cStr[0] = 0;
|
|
|
|
if (NULL == pidl)
|
|
{
|
|
hr = GetDetailsOfInfo(s_net_cols, cColumns, iColumn, pDetails);
|
|
}
|
|
else
|
|
{
|
|
SHCOLUMNID scid;
|
|
hr = MapColumnToSCID(iColumn, &scid);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
VARIANT var;
|
|
hr = GetDetailsEx(pidl, &scid, &var);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
hr = SHFormatForDisplay(scid.fmtid,
|
|
scid.pid,
|
|
(PROPVARIANT*)&var,
|
|
PUIFFDF_DEFAULT,
|
|
szTemp,
|
|
ARRAYSIZE(szTemp));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = StringToStrRet(szTemp, &pDetails->str);
|
|
}
|
|
|
|
VariantClear(&var);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CNetFolder::_MapColumnToSCID(UINT cColumns, UINT iColumn, SHCOLUMNID* pscid)
|
|
{
|
|
return MapColumnToSCIDImpl(s_net_cols, cColumns, iColumn, pscid);
|
|
}
|
|
|
|
|
|
// IPersist methods
|
|
|
|
STDMETHODIMP CNetFolder::GetClassID(CLSID* pCLSID)
|
|
{
|
|
switch (_uDisplayType)
|
|
{
|
|
case RESOURCEDISPLAYTYPE_ROOT:
|
|
*pCLSID = CLSID_NetworkRoot;
|
|
break;
|
|
|
|
case RESOURCEDISPLAYTYPE_SERVER:
|
|
*pCLSID = CLSID_NetworkServer;
|
|
break;
|
|
|
|
case RESOURCEDISPLAYTYPE_DOMAIN:
|
|
*pCLSID = CLSID_NetworkDomain;
|
|
break;
|
|
|
|
case RESOURCEDISPLAYTYPE_SHARE:
|
|
*pCLSID = CLSID_NetworkShare;
|
|
break;
|
|
|
|
default:
|
|
*pCLSID = CLSID_NULL;
|
|
break;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// IPersistFolder method
|
|
|
|
STDMETHODIMP CNetFolder::Initialize(LPCITEMIDLIST pidl)
|
|
{
|
|
ILFree(_pidl);
|
|
ILFree(_pidlTarget);
|
|
_pidl = _pidlTarget = NULL;
|
|
|
|
return SHILClone(pidl, &_pidl);
|
|
}
|
|
|
|
|
|
// IPersistFolder2 method
|
|
|
|
STDMETHODIMP CNetFolder::GetCurFolder(LPITEMIDLIST* ppidl)
|
|
{
|
|
return GetCurFolderImpl(_pidl, ppidl);
|
|
}
|
|
|
|
|
|
// IPersistFolder3 methods
|
|
|
|
STDMETHODIMP CNetFolder::InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *pfti)
|
|
{
|
|
ILFree(_pidl);
|
|
ILFree(_pidlTarget);
|
|
_pidl = _pidlTarget = NULL;
|
|
|
|
HRESULT hr = SHILClone(pidlRoot, &_pidl);
|
|
if (SUCCEEDED(hr) && pfti && pfti->pidlTargetFolder)
|
|
{
|
|
hr = SHILClone(pfti->pidlTargetFolder, &_pidlTarget);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetFolder::GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *pfti)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ZeroMemory(pfti, sizeof(*pfti));
|
|
|
|
if (_pidlTarget)
|
|
hr = SHILClone(_pidlTarget, &pfti->pidlTargetFolder);
|
|
|
|
pfti->dwAttributes = FILE_ATTRIBUTE_DIRECTORY; // maybe add system?
|
|
pfti->csidl = -1;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// IShellIconOverlay
|
|
|
|
HRESULT CNetFolder::_GetIconOverlayInfo(LPCIDNETRESOURCE pidn, int *pIndex, DWORD dwFlags)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
//
|
|
// For netshare objects we want to get the icon overlay.
|
|
// If the share is "pinned" to be available offline it will
|
|
// have the "Offline Files" overlay.
|
|
//
|
|
if (RESOURCEDISPLAYTYPE_SHARE == NET_GetDisplayType(pidn))
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
hr = _GetPathForItem(pidn, szPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellIconOverlayManager *psiom;
|
|
hr = GetIconOverlayManager(&psiom);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR szPathW[MAX_PATH];
|
|
SHTCharToUnicode(szPath, szPathW, ARRAYSIZE(szPathW));
|
|
hr = psiom->GetFileOverlayInfo(szPathW, 0, pIndex, dwFlags);
|
|
psiom->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::GetOverlayIndex(LPCITEMIDLIST pidl, int *pIndex)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPCIDNETRESOURCE pidn = NET_IsValidID(pidl);
|
|
|
|
if (NULL != pidn)
|
|
{
|
|
hr = _GetIconOverlayInfo(pidn, pIndex, SIOM_OVERLAYINDEX);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNetFolder::GetOverlayIconIndex(LPCITEMIDLIST pidl, int *pIndex)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPCIDNETRESOURCE pidn = NET_IsValidID(pidl);
|
|
|
|
if (NULL != pidn)
|
|
{
|
|
hr = _GetIconOverlayInfo(pidn, pIndex, SIOM_ICONINDEX);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Helper function to allow external callers to query information from a
|
|
// network pidl...
|
|
//
|
|
// NOTE NOTE - This function returns a NETRESOURCE structure whose string
|
|
// pointers are not valid. On Win95 they were pointers back into the pidl's
|
|
// strings (even though the strings were copied into the supplied pv buffer.)
|
|
// Now we make the pointers really point into the buffer.
|
|
//
|
|
HRESULT CNetFolder::_GetNetResource(LPCIDNETRESOURCE pidn, NETRESOURCEW* pnr, int cb)
|
|
{
|
|
TCHAR szStrings[3][MAX_PATH];
|
|
LPWSTR psz, lpsz[3] = {NULL, NULL, NULL};
|
|
int i, cchT;
|
|
|
|
if (cb < sizeof(*pnr))
|
|
return DISP_E_BUFFERTOOSMALL;
|
|
|
|
ZeroMemory(pnr, cb);
|
|
|
|
NET_CopyResName(pidn, szStrings[0], ARRAYSIZE(szStrings[0]));
|
|
NET_CopyComment(pidn, szStrings[1], ARRAYSIZE(szStrings[1]));
|
|
_GetProvider(pidn, NULL, szStrings[2], ARRAYSIZE(szStrings[2]));
|
|
|
|
// Fill in some of the stuff first.
|
|
// pnr->dwScope = 0;
|
|
pnr->dwType = NET_GetType(pidn);
|
|
pnr->dwDisplayType = NET_GetDisplayType(pidn);
|
|
pnr->dwUsage = NET_GetUsage(pidn);
|
|
// pnr->lpLocalName = NULL;
|
|
|
|
// Now lets copy the strings into the buffer and make the pointers
|
|
// relative to the buffer...
|
|
psz = (LPWSTR)(pnr + 1);
|
|
cb -= sizeof(*pnr);
|
|
|
|
for (i = 0; i < ARRAYSIZE(szStrings); i++)
|
|
{
|
|
if (*szStrings[i])
|
|
{
|
|
cchT = (lstrlen(szStrings[i]) + 1) * sizeof(TCHAR);
|
|
if (cchT <= cb)
|
|
{
|
|
SHTCharToUnicode(szStrings[i], psz, cb/sizeof(TCHAR));
|
|
lpsz[i] = psz;
|
|
psz += cchT;
|
|
cb -= cchT * sizeof(TCHAR);
|
|
}
|
|
else
|
|
{
|
|
// A hint that the structure is ok,
|
|
// but the strings are missing
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
}
|
|
}
|
|
}
|
|
|
|
pnr->lpRemoteName = lpsz[0];
|
|
pnr->lpComment = lpsz[1];
|
|
pnr->lpProvider = lpsz[2];
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// This function opens a reg. database key based on the "network provider".
|
|
//
|
|
// Returns: hkey
|
|
//
|
|
// The caller is responsibe to close the key by calling RegCloseKey().
|
|
//
|
|
HKEY CNetFolder::_OpenProviderKey(LPCIDNETRESOURCE pidn)
|
|
{
|
|
TCHAR szProvider[MAX_PATH];
|
|
|
|
if (_GetProvider(pidn, NULL, szProvider, ARRAYSIZE(szProvider)))
|
|
{
|
|
HKEY hkeyProgID = NULL;
|
|
ReplaceSpacesWithUnderscore(szProvider);
|
|
RegOpenKey(HKEY_CLASSES_ROOT, szProvider, &hkeyProgID);
|
|
return hkeyProgID;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// This function opens a reg. database key based on the network provider type.
|
|
// The type is a number that is not localized, as opposed to the provider name
|
|
// which may be localized.
|
|
//
|
|
// Arguments:
|
|
// pidlAbs -- Absolute IDList to a network resource object.
|
|
//
|
|
// Returns: hkey
|
|
//
|
|
// Notes:
|
|
// The caller is responsible to close the key by calling RegCloseKey().
|
|
//
|
|
|
|
HKEY CNetFolder::_OpenProviderTypeKey(LPCIDNETRESOURCE pidn)
|
|
{
|
|
HKEY hkeyProgID = NULL;
|
|
TCHAR szProvider[MAX_PATH];
|
|
|
|
if (_GetProvider(pidn, NULL, szProvider, ARRAYSIZE(szProvider)))
|
|
{
|
|
// Now that we've got the provider name, get the provider id.
|
|
DWORD dwType;
|
|
if (WNetGetProviderType(szProvider, &dwType) == WN_SUCCESS)
|
|
{
|
|
// convert nis.wNetType to a string, and then open the key
|
|
// HKEY_CLASSES_ROOT\Network\Type\<type string>
|
|
|
|
TCHAR szRegValue[MAX_PATH];
|
|
wsprintf(szRegValue, TEXT("Network\\Type\\%d"), HIWORD(dwType));
|
|
RegOpenKey(HKEY_CLASSES_ROOT, szRegValue, &hkeyProgID);
|
|
}
|
|
}
|
|
|
|
return hkeyProgID;
|
|
}
|
|
|
|
HRESULT CNetFolder::_OpenKeys(LPCIDNETRESOURCE pidn, HKEY ahkeys[NKID_COUNT])
|
|
{
|
|
// See if there is a key specific to the type of Network object...
|
|
COMPILETIME_ASSERT(6 == NKID_COUNT);
|
|
ahkeys[0] = ahkeys[1] = ahkeys[2] = ahkeys[3] = ahkeys[4] = ahkeys[5] = NULL;
|
|
ahkeys[NKID_PROVIDERTYPE] = _OpenProviderTypeKey(pidn);
|
|
ahkeys[NKID_PROVIDER] = _OpenProviderKey(pidn);
|
|
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_SHARE)
|
|
RegOpenKey(HKEY_CLASSES_ROOT, TEXT("NetShare"), &ahkeys[NKID_NETCLASS]);
|
|
else if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_SERVER)
|
|
RegOpenKey(HKEY_CLASSES_ROOT, TEXT("NetServer"), &ahkeys[NKID_NETCLASS]);
|
|
|
|
RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Network"), &ahkeys[NKID_NETWORK]);
|
|
|
|
// make sure it is not a printer before adding "Folder" or "directory"
|
|
|
|
if (!_IsPrintShare(pidn))
|
|
{
|
|
// Shares should also support directory stuff...
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_SHARE)
|
|
RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Directory"), &ahkeys[NKID_DIRECTORY]);
|
|
|
|
RegOpenKey(HKEY_CLASSES_ROOT, c_szFolderClass, &ahkeys[NKID_FOLDER]);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
#define WNFMT_PLATFORM WNFMT_ABBREVIATED | WNFMT_INENUM
|
|
|
|
//
|
|
// This function retrieves the formatted (display) name of the specified network object.
|
|
//
|
|
HRESULT CNetFolder::_GetFormatName(LPCIDNETRESOURCE pidn, STRRET* pStrRet)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
TCHAR szName[MAX_PATH];
|
|
|
|
NET_CopyResName(pidn, szName, ARRAYSIZE(szName));
|
|
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_SERVER)
|
|
{
|
|
TCHAR szMachineName[MAX_PATH];
|
|
TCHAR szComment[MAX_PATH];
|
|
|
|
NET_CopyResName(pidn, szMachineName, ARRAYSIZE(szMachineName));
|
|
NET_CopyComment(pidn, szComment, ARRAYSIZE(szComment));
|
|
|
|
hr = SHBuildDisplayMachineName(szMachineName, szComment, szName, ARRAYSIZE(szName));
|
|
}
|
|
|
|
if (FAILED(hr) &&
|
|
(NET_GetDisplayType(pidn) != RESOURCEDISPLAYTYPE_ROOT) &&
|
|
(NET_GetDisplayType(pidn) != RESOURCEDISPLAYTYPE_NETWORK))
|
|
{
|
|
TCHAR szDisplayName[MAX_PATH], szProvider[MAX_PATH];
|
|
DWORD dwSize = ARRAYSIZE(szDisplayName);
|
|
|
|
LPCTSTR pszProvider = _GetProvider(pidn, NULL, szProvider, ARRAYSIZE(szProvider));
|
|
if (pszProvider)
|
|
{
|
|
DWORD dwRes = WNetFormatNetworkName(pszProvider, szName, szDisplayName, &dwSize, WNFMT_PLATFORM, 8 + 1 + 3);
|
|
if (dwRes == WN_SUCCESS)
|
|
lstrcpy(szName, szDisplayName);
|
|
}
|
|
}
|
|
|
|
return StringToStrRet(szName, pStrRet);
|
|
}
|
|
|
|
|
|
//
|
|
// resolve non-UNC share names (novell) to UNC style names
|
|
//
|
|
// returns:
|
|
// TRUE translated the name
|
|
// FALSE didn't translate (maybe error case)
|
|
//
|
|
// WARNING: If we use too much stack space then we will cause
|
|
// faults by over flowing the stack. Millennium #94818
|
|
BOOL CNetFolder::_GetPathForShare(LPCIDNETRESOURCE pidn, LPTSTR pszPath)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
*pszPath = TEXT('\0');
|
|
|
|
LPTSTR pszAccessName = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR) * MAX_PATH * 3);
|
|
if (pszAccessName)
|
|
{
|
|
LPTSTR pszRemoteName = pszAccessName + MAX_PATH;
|
|
LPTSTR pszProviderName = pszRemoteName + MAX_PATH;
|
|
|
|
NET_CopyResName(pidn, pszRemoteName, MAX_PATH);
|
|
if (NULL != _pszResName)
|
|
{
|
|
//
|
|
// Combine the folder name with the share name
|
|
// to create a UNC path.
|
|
//
|
|
// Borrow the pszProviderName buffer for a bit.
|
|
//
|
|
PathCombine(pszProviderName, _pszResName, pszRemoteName);
|
|
|
|
//
|
|
// To be safe: UNC prefix implies that name is available using FS access
|
|
// Theoretically it also should be routed to MPR, but it is late to do this
|
|
//
|
|
if (PathIsUNC(pszProviderName))
|
|
{
|
|
lstrcpy(pszPath, pszProviderName);
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pszProviderName[0] = TEXT('\0');
|
|
}
|
|
}
|
|
|
|
if (!*pszPath)
|
|
{
|
|
// Check cache
|
|
ENTERCRITICAL;
|
|
if (lstrcmpi(g_szLastAttemptedJunctionName, pszRemoteName) == 0)
|
|
{
|
|
// cache hit
|
|
lstrcpy(pszPath, g_szLastResolvedJunctionName);
|
|
fRet = TRUE;
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
if (!*pszPath)
|
|
{
|
|
NETRESOURCE nr = {0};
|
|
DWORD err, dwRedir, dwResult;
|
|
DWORD cchAccessName;
|
|
|
|
nr.lpRemoteName = pszRemoteName;
|
|
nr.lpProvider = (LPTSTR) _GetProvider(pidn, NULL, pszProviderName, MAX_PATH);
|
|
nr.dwType = NET_GetType(pidn);
|
|
nr.dwUsage = NET_GetUsage(pidn);
|
|
nr.dwDisplayType = NET_GetDisplayType(pidn);
|
|
|
|
dwRedir = CONNECT_TEMPORARY;
|
|
|
|
// Prepare access name buffer and net resource request buffer
|
|
//
|
|
cchAccessName = MAX_PATH;
|
|
pszAccessName[0] = 0;
|
|
|
|
err = WNetUseConnection(NULL, &nr, NULL, NULL, dwRedir, pszAccessName, &cchAccessName, &dwResult);
|
|
if ((WN_SUCCESS != err) || !pszAccessName[0])
|
|
{
|
|
// perf idea: might be good to cache the last failed junction bind
|
|
// and early out on the next attempt. One slight problem this
|
|
// might encounter: what if we cache a failure, the user changes
|
|
// state to fix the problem, but we hit our failure cache...
|
|
//
|
|
lstrcpy(pszPath, pszRemoteName);
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// Get the return name
|
|
lstrcpy(pszPath, pszAccessName);
|
|
fRet = TRUE;
|
|
|
|
// Update success cache entry
|
|
ENTERCRITICAL;
|
|
|
|
lstrcpy(g_szLastAttemptedJunctionName, pszRemoteName);
|
|
lstrcpy(g_szLastResolvedJunctionName, pszAccessName);
|
|
|
|
LEAVECRITICAL;
|
|
}
|
|
}
|
|
|
|
LocalFree(pszAccessName);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
// in:
|
|
// pidn may be multi-level net resource pidl like
|
|
// [entire net] [provider] [server] [share] [... file sys]
|
|
// or [server] [share] [... file sys]
|
|
|
|
HRESULT CNetFolder::_GetPathForItem(LPCIDNETRESOURCE pidn, LPTSTR pszPath)
|
|
{
|
|
*pszPath = 0;
|
|
|
|
// loop down
|
|
for (; !ILIsEmpty((LPCITEMIDLIST)pidn) ; pidn = (LPCIDNETRESOURCE)_ILNext((LPCITEMIDLIST)pidn))
|
|
{
|
|
if (NET_GetFlags(pidn) & SHID_JUNCTION) // \\server\share or strike/sys
|
|
{
|
|
_GetPathForShare(pidn, pszPath);
|
|
break; // below this we don't know about any of the PIDLs
|
|
}
|
|
else
|
|
{
|
|
// if this is entire network then return the canonical name for
|
|
// this object.
|
|
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_ROOT)
|
|
StrCpyN(pszPath, TEXT("EntireNetwork"), MAX_PATH);
|
|
else
|
|
NET_CopyResName(pidn, pszPath, MAX_PATH);
|
|
}
|
|
}
|
|
return *pszPath ? S_OK : E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT CNetFolder::_GetPathForItemW(LPCIDNETRESOURCE pidn, LPWSTR pszPath)
|
|
{
|
|
return _GetPathForItem(pidn, pszPath);
|
|
}
|
|
|
|
|
|
// in:
|
|
// pidl
|
|
//
|
|
// takes the last items and create a folder for it, assuming the first section is the
|
|
// used to initialze. the riid and ppv are used to return an object.
|
|
//
|
|
|
|
HRESULT CNetFolder::_CreateFolderForItem(LPBC pbc, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlTarget, LPCIDNETRESOURCE pidnForProvider, REFIID riid, void **ppv)
|
|
{
|
|
LPCITEMIDLIST pidlLast = ILFindLastID(pidl);
|
|
LPCIDNETRESOURCE pidn = NET_IsValidID(pidlLast);
|
|
|
|
if (!pidn)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr;
|
|
if (NET_IsRemoteFld(pidn))
|
|
{
|
|
// note: I think this is dead functionality. it was used in NT4 but we can't find
|
|
// the impl of this CLSID_Remote anymore...
|
|
IPersistFolder * ppf;
|
|
hr = SHCoCreateInstance(NULL, &CLSID_Remote, NULL, IID_PPV_ARG(IPersistFolder, &ppf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr= ppf->Initialize(pidl);
|
|
if (SUCCEEDED(hr))
|
|
hr = ppf->QueryInterface(riid, ppv);
|
|
ppf->Release();
|
|
}
|
|
}
|
|
else if (NET_GetFlags(pidn) & SHID_JUNCTION) // \\server\share or strike/sys
|
|
{
|
|
PERSIST_FOLDER_TARGET_INFO * ppfti = (PERSIST_FOLDER_TARGET_INFO *) LocalAlloc(LPTR, sizeof(PERSIST_FOLDER_TARGET_INFO));
|
|
if (ppfti)
|
|
{
|
|
ppfti->pidlTargetFolder = (LPITEMIDLIST)pidlTarget;
|
|
_GetPathForItemW(pidn, ppfti->szTargetParsingName);
|
|
ppfti->csidl = -1;
|
|
ppfti->dwAttributes = FILE_ATTRIBUTE_DIRECTORY; // maybe add system?
|
|
|
|
hr = CFSFolder_CreateFolder(NULL, pbc, pidl, ppfti, riid, ppv);
|
|
LocalFree(ppfti);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
NET_CopyResName(pidn, szPath, ARRAYSIZE(szPath));
|
|
|
|
hr = _CreateInstance(pidl, pidlTarget, NET_GetDisplayType(pidn), pidnForProvider, szPath, riid, ppv);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// get the provider for an item or the folder itself. since some items don't have the
|
|
// provider stored we fall back to the folder to get the provider in that case
|
|
//
|
|
// in:
|
|
// pidn item to get provider for. if NULL get provider for the folder
|
|
// pbc IBindCtx to get provider for. if NULL get provider from pidn or folder.
|
|
//
|
|
// returns:
|
|
// NULL no provider in the item or the folder
|
|
// non NULL address of passed in buffer
|
|
|
|
LPCTSTR CNetFolder::_GetProvider(LPCIDNETRESOURCE pidn, IBindCtx *pbc, LPTSTR pszProvider, UINT cchProvider)
|
|
{
|
|
// attempt to get the provider from the property bag
|
|
IPropertyBag *ppb;
|
|
if (pbc && SUCCEEDED(pbc->GetObjectParam(STR_PARSE_NETFOLDER_INFO, (IUnknown**)&ppb)))
|
|
{
|
|
HRESULT hr = SHPropertyBag_ReadStr(ppb, STR_PARSE_NETFOLDER_PROVIDERNAME, pszProvider, cchProvider);
|
|
ppb->Release();
|
|
if (SUCCEEDED(hr) && *pszProvider)
|
|
{
|
|
return pszProvider;
|
|
}
|
|
}
|
|
|
|
// from the IDLIST
|
|
if (pidn && NET_CopyProviderName(pidn, pszProvider, cchProvider))
|
|
return pszProvider;
|
|
|
|
// from our state
|
|
if (_pidnForProvider)
|
|
{
|
|
NET_CopyProviderName(_pidnForProvider, pszProvider, cchProvider);
|
|
return pszProvider;
|
|
}
|
|
|
|
*pszProvider = 0;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const NETPROVIDERS c_rgProviderMap[] =
|
|
{
|
|
{ TEXT("Microsoft Network"), HIWORD(WNNC_NET_LANMAN) },
|
|
{ TEXT("NetWare"), HIWORD(WNNC_NET_NETWARE) }
|
|
};
|
|
|
|
|
|
// construct a net idlist either copying the existing data from a pidl or
|
|
// from a NETRESOURCE structure
|
|
|
|
HRESULT CNetFolder::_CreateNetIDList(LPIDNETRESOURCE pidnIn,
|
|
LPCTSTR pszName, LPCTSTR pszProvider, LPCTSTR pszComment,
|
|
LPITEMIDLIST *ppidl)
|
|
{
|
|
LPBYTE pb;
|
|
UINT cbmkid = sizeof(IDNETRESOURCE) - sizeof(CHAR);
|
|
UINT cchName, cchProvider, cchComment, cbProviderType = 0;
|
|
LPIDNETRESOURCE pidn;
|
|
WORD wNetType = 0;
|
|
BOOL fUnicode = FALSE;
|
|
UINT cchAnsiName, cchAnsiProvider, cchAnsiComment;
|
|
CHAR szAnsiName[MAX_PATH], szAnsiProvider[MAX_PATH], szAnsiComment[MAX_PATH];
|
|
|
|
ASSERT(ppidl != NULL);
|
|
*ppidl = NULL;
|
|
|
|
if (!pszName)
|
|
pszName = c_szNULL; // For now put in an empty string...
|
|
|
|
if (pszProvider)
|
|
cbProviderType += sizeof(WORD);
|
|
|
|
// Win9x shipped with one set of provider name which are
|
|
// different on NT. Therefore lets convert the NT one to
|
|
// something that Win9x can understand.
|
|
|
|
if (pszProvider)
|
|
{
|
|
cbProviderType = sizeof(WORD);
|
|
DWORD dwType, dwRes = WNetGetProviderType(pszProvider, &dwType);
|
|
if (dwRes == WN_SUCCESS)
|
|
{
|
|
wNetType = HIWORD(dwType);
|
|
for (int i = 0; i < ARRAYSIZE(c_rgProviderMap); i++)
|
|
{
|
|
if (c_rgProviderMap[i].wNetType == wNetType)
|
|
{
|
|
pszProvider = c_rgProviderMap[i].lpName;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// compute the string lengths ready to build an IDLIST
|
|
|
|
cchName = lstrlen(pszName)+1;
|
|
cchProvider = pszProvider ? lstrlen(pszProvider)+1 : 0;
|
|
cchComment = pszComment ? lstrlen(pszComment)+1 : 0;
|
|
|
|
cchAnsiName = 0;
|
|
cchAnsiProvider = 0;
|
|
cchAnsiComment = 0;
|
|
|
|
fUnicode = !DoesStringRoundTrip(pszName, szAnsiName, ARRAYSIZE(szAnsiProvider));
|
|
cchAnsiName = lstrlenA(szAnsiName)+1;
|
|
|
|
if (pszProvider)
|
|
{
|
|
fUnicode |= !DoesStringRoundTrip(pszProvider, szAnsiProvider, ARRAYSIZE(szAnsiProvider));
|
|
cchAnsiProvider = lstrlenA(szAnsiProvider)+1;
|
|
}
|
|
|
|
if (pszComment)
|
|
{
|
|
fUnicode |= !DoesStringRoundTrip(pszComment, szAnsiComment, ARRAYSIZE(szAnsiComment));
|
|
cchAnsiComment = lstrlenA(szAnsiComment)+1;
|
|
}
|
|
|
|
// allocate and fill the IDLIST header
|
|
|
|
cbmkid += cbProviderType+cchAnsiName + cchAnsiProvider + cchAnsiComment;
|
|
|
|
if (fUnicode)
|
|
cbmkid += (sizeof(WCHAR)*(cchName+cchProvider+cchComment));
|
|
|
|
pidn = (LPIDNETRESOURCE)_ILCreate(cbmkid + sizeof(USHORT));
|
|
if (!pidn)
|
|
return E_OUTOFMEMORY;
|
|
|
|
pidn->cb = (WORD)cbmkid;
|
|
pidn->bFlags = pidnIn->bFlags;
|
|
pidn->uType = pidnIn->uType;
|
|
pidn->uUsage = pidnIn->uUsage;
|
|
|
|
if (pszProvider)
|
|
pidn->uUsage |= NET_HASPROVIDER;
|
|
|
|
if (pszComment)
|
|
pidn->uUsage |= NET_HASCOMMENT;
|
|
|
|
pb = (LPBYTE) pidn->szNetResName;
|
|
|
|
//
|
|
// write the ANSI strings into the IDLIST
|
|
//
|
|
|
|
StrCpyA((PSTR) pb, szAnsiName);
|
|
pb += cchAnsiName;
|
|
|
|
if (pszProvider)
|
|
{
|
|
StrCpyA((PSTR) pb, szAnsiProvider);
|
|
pb += cchAnsiProvider;
|
|
}
|
|
|
|
if (pszComment)
|
|
{
|
|
StrCpyA((PSTR) pb, szAnsiComment);
|
|
pb += cchAnsiComment;
|
|
}
|
|
|
|
// if we are going to be UNICODE then lets write those strings also.
|
|
// Note that we must use unaligned string copies since the is no
|
|
// promse that the ANSI strings will have an even number of characters
|
|
// in them.
|
|
if (fUnicode)
|
|
{
|
|
pidn->uUsage |= NET_UNICODE;
|
|
|
|
ualstrcpyW((UNALIGNED WCHAR *)pb, pszName);
|
|
pb += cchName*sizeof(WCHAR);
|
|
|
|
if (pszProvider)
|
|
{
|
|
ualstrcpyW((UNALIGNED WCHAR *)pb, pszProvider);
|
|
pb += cchProvider*sizeof(WCHAR);
|
|
}
|
|
|
|
if (pszComment)
|
|
{
|
|
ualstrcpyW((UNALIGNED WCHAR *)pb, pszComment);
|
|
pb += cchComment*sizeof(WCHAR);
|
|
}
|
|
}
|
|
|
|
//
|
|
// and the trailing provider type
|
|
//
|
|
|
|
if (cbProviderType)
|
|
{
|
|
// Store the provider type
|
|
pb = (LPBYTE)pidn + pidn->cb - sizeof(WORD);
|
|
*((UNALIGNED WORD *)pb) = wNetType;
|
|
}
|
|
|
|
*ppidl = (LPITEMIDLIST)pidn;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// wrapper for converting a NETRESOURCE into an IDLIST via _CreateNetPidl
|
|
|
|
HRESULT CNetFolder::_NetResToIDList(NETRESOURCE *pnr,
|
|
BOOL fKeepNullRemoteName,
|
|
BOOL fKeepProviderName,
|
|
BOOL fKeepComment,
|
|
LPITEMIDLIST *ppidl)
|
|
{
|
|
NETRESOURCE nr = *pnr;
|
|
LPITEMIDLIST pidl;
|
|
LPTSTR pszName, pszProvider, pszComment;
|
|
IDNETRESOURCE idn;
|
|
LPTSTR psz;
|
|
|
|
if (ppidl)
|
|
*ppidl = NULL;
|
|
|
|
switch (pnr->dwDisplayType)
|
|
{
|
|
case RESOURCEDISPLAYTYPE_NETWORK:
|
|
pszName = pnr->lpProvider;
|
|
break;
|
|
|
|
case RESOURCEDISPLAYTYPE_ROOT:
|
|
pszName =pnr->lpComment;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
pszName = pnr->lpRemoteName;
|
|
|
|
if (!fKeepNullRemoteName && (!pszName || !*pszName))
|
|
return E_FAIL;
|
|
|
|
if (pszName && *pszName)
|
|
{
|
|
psz = (LPTSTR)SkipServerSlashes(pnr->lpRemoteName);
|
|
if ( *psz )
|
|
PathMakePretty(psz);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
pszProvider = fKeepProviderName ? nr.lpProvider:NULL;
|
|
pszComment = fKeepComment ? nr.lpComment:NULL;
|
|
|
|
idn.bFlags = (BYTE)(SHID_NET | (pnr->dwDisplayType & 0x0f));
|
|
idn.uType = (BYTE)(pnr->dwType & 0x0f);
|
|
idn.uUsage = (BYTE)(pnr->dwUsage & 0x0f);
|
|
|
|
// Is the current resource a share of some kind and not a container
|
|
if ((pnr->dwDisplayType == RESOURCEDISPLAYTYPE_SHARE || pnr->dwDisplayType == RESOURCEDISPLAYTYPE_SHAREADMIN) &&
|
|
!(pnr->dwUsage & RESOURCEUSAGE_CONTAINER))
|
|
{
|
|
// If so, remember to delegate children of this folder to FSFolder
|
|
idn.bFlags |= (BYTE)SHID_JUNCTION; // \\server\share type thing
|
|
}
|
|
|
|
HRESULT hr = _CreateNetIDList(&idn, pszName, pszProvider, pszComment, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (ppidl)
|
|
*ppidl = pidl;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetFolder::_CreateEntireNetwork(LPITEMIDLIST *ppidl)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
NETRESOURCE nr = {0};
|
|
|
|
// We need to add the Rest of network entry. This is psuedo
|
|
// bogus, as we should either always do it ourself or have
|
|
// MPR always do it, but here it goes...
|
|
LoadString(HINST_THISDLL, IDS_RESTOFNET, szPath, ARRAYSIZE(szPath));
|
|
nr.dwDisplayType = RESOURCEDISPLAYTYPE_ROOT;
|
|
nr.dwType = RESOURCETYPE_ANY;
|
|
nr.dwUsage = RESOURCEUSAGE_CONTAINER;
|
|
nr.lpComment = szPath;
|
|
|
|
return _NetResToIDList(&nr, FALSE, FALSE, FALSE, ppidl);
|
|
}
|
|
|
|
HRESULT CNetFolder::_CreateEntireNetworkFullIDList(LPITEMIDLIST *ppidl)
|
|
{
|
|
// CLSID_NetworkPlaces\EntireNetwork
|
|
return SHILCreateFromPath(TEXT("::{208D2C60-3AEA-1069-A2D7-08002B30309D}\\EntireNetwork"), ppidl, NULL);
|
|
}
|
|
|
|
//
|
|
// To be called back from within CDefFolderMenu
|
|
//
|
|
STDAPI CNetwork_DFMCallBackBG(IShellFolder *psf, HWND hwnd,
|
|
IDataObject *pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CNetFolder *pThis = FolderToNetFolder(psf);
|
|
|
|
if (NULL == pThis)
|
|
return E_UNEXPECTED;
|
|
|
|
switch(uMsg)
|
|
{
|
|
case DFM_MERGECONTEXTMENU_BOTTOM:
|
|
if (!(wParam & (CMF_VERBSONLY | CMF_DVFILE)))
|
|
{
|
|
CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_PROPERTIES_BG, 0, (LPQCMINFO)lParam);
|
|
}
|
|
break;
|
|
|
|
case DFM_GETHELPTEXT:
|
|
LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_GETHELPTEXTW:
|
|
LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_INVOKECOMMAND:
|
|
switch (wParam)
|
|
{
|
|
case FSIDM_PROPERTIESBG:
|
|
hr = SHPropertiesForPidl(hwnd, pThis->_pidl, (LPCTSTR)lParam);
|
|
break;
|
|
|
|
default:
|
|
// This is one of view menu items, use the default code.
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// To be called back from within CDefFolderMenu
|
|
//
|
|
STDAPI CNetFolder::DFMCallBack(IShellFolder* psf, HWND hwnd,
|
|
IDataObject* pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
switch(uMsg)
|
|
{
|
|
case DFM_MERGECONTEXTMENU:
|
|
if (pdtobj)
|
|
{
|
|
STGMEDIUM medium;
|
|
LPIDA pida;
|
|
LPQCMINFO pqcm = (LPQCMINFO)lParam;
|
|
UINT idCmdBase = pqcm->idCmdFirst; // must be called before merge
|
|
CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_NETWORK_ITEM, 0, pqcm);
|
|
|
|
pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
if (pida->cidl > 0)
|
|
{
|
|
LPIDNETRESOURCE pidn = (LPIDNETRESOURCE)IDA_GetIDListPtr(pida, 0);
|
|
|
|
// Only enable "connect" command if the first one is a share.
|
|
if (pidn)
|
|
{
|
|
ULONG rgf = 0;
|
|
if(NET_GetFlags(pidn) & SHID_JUNCTION &&
|
|
!SHRestricted(REST_NONETCONNECTDISCONNECT))
|
|
{
|
|
EnableMenuItem(pqcm->hmenu, idCmdBase + FSIDM_CONNECT,
|
|
MF_CHECKED | MF_BYCOMMAND);
|
|
}
|
|
}
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DFM_GETHELPTEXT:
|
|
LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_GETHELPTEXTW:
|
|
LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_INVOKECOMMAND:
|
|
switch(wParam)
|
|
{
|
|
case DFM_CMD_PROPERTIES:
|
|
hr = SHLaunchPropSheet(_PropertiesThreadProc, pdtobj, (LPCTSTR)lParam, psf, NULL);
|
|
break;
|
|
|
|
case DFM_CMD_LINK:
|
|
{
|
|
hr = S_FALSE; // do the default shortcut stuff
|
|
CNetFolder *pThis = FolderToNetFolder(psf);
|
|
if (pThis)
|
|
{
|
|
// net hood special case. in this case we want to create the shortuct
|
|
// in the net hood, not offer to put this on the desktop
|
|
IShellFolder2* psfFiles;
|
|
if (SUCCEEDED(pThis->v_GetFileFolder(&psfFiles)))
|
|
{
|
|
CFSFolder_CreateLinks(hwnd, psfFiles, pdtobj, (LPCTSTR)lParam, CMIC_MASK_FLAG_NO_UI);
|
|
hr = S_OK; // we created the links
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FSIDM_CONNECT:
|
|
if (pdtobj)
|
|
{
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
for (UINT i = 0; i < pida->cidl; i++)
|
|
{
|
|
LPIDNETRESOURCE pidn = (LPIDNETRESOURCE)IDA_GetIDListPtr(pida, i);
|
|
|
|
// Only execute "connect" on shares.
|
|
if (NET_GetFlags(pidn) & SHID_JUNCTION)
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
LPTSTR pszName = NET_CopyResName(pidn, szName, ARRAYSIZE(szName));
|
|
DWORD err = SHStartNetConnectionDialog(hwnd, pszName, RESOURCETYPE_DISK);
|
|
DebugMsg(DM_TRACE, TEXT("CNet FSIDM_CONNECT (%s, %x)"), szName, err);
|
|
|
|
// events will get generated automatically
|
|
}
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// This is one of view menu items, use the default code.
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI CNetFolder::PrinterDFMCallBack(IShellFolder* psf, HWND hwnd,
|
|
IDataObject* pdtobj, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
switch(uMsg)
|
|
{
|
|
case DFM_MERGECONTEXTMENU:
|
|
//
|
|
// Returning S_FALSE indicates no need to get verbs from
|
|
// extensions.
|
|
//
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
// if anyone hooks our context menu, we want to be on top (Open)
|
|
case DFM_MERGECONTEXTMENU_TOP:
|
|
if (pdtobj)
|
|
{
|
|
LPQCMINFO pqcm = (LPQCMINFO)lParam;
|
|
|
|
// insert verbs
|
|
CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_NETWORK_PRINTER, 0, pqcm);
|
|
SetMenuDefaultItem(pqcm->hmenu, 0, MF_BYPOSITION);
|
|
}
|
|
break;
|
|
|
|
case DFM_GETHELPTEXT:
|
|
LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_GETHELPTEXTW:
|
|
LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));
|
|
break;
|
|
|
|
case DFM_INVOKECOMMAND:
|
|
switch (wParam)
|
|
{
|
|
case DFM_CMD_PROPERTIES:
|
|
hr = SHLaunchPropSheet(_PropertiesThreadProc, pdtobj, (LPCTSTR)lParam, psf, NULL);
|
|
break;
|
|
|
|
case DFM_CMD_LINK:
|
|
// do the default create shortcut crap
|
|
return S_FALSE;
|
|
|
|
case FSIDM_OPENPRN:
|
|
case FSIDM_NETPRN_INSTALL:
|
|
{
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
UINT action;
|
|
|
|
// set up the operation we are going to perform
|
|
switch (wParam)
|
|
{
|
|
case FSIDM_OPENPRN:
|
|
action = PRINTACTION_OPENNETPRN;
|
|
break;
|
|
case FSIDM_NETPRN_INSTALL:
|
|
action = PRINTACTION_NETINSTALL;
|
|
break;
|
|
default: // FSIDM_CONNECT_PRN
|
|
action = (UINT)-1;
|
|
break;
|
|
}
|
|
|
|
for (UINT i = 0; i < pida->cidl; i++)
|
|
{
|
|
LPIDNETRESOURCE pidn = (LPIDNETRESOURCE)IDA_GetIDListPtr(pida, i);
|
|
|
|
// Only execute command for a net print share
|
|
if (_IsPrintShare(pidn))
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
NET_CopyResName(pidn,szName,ARRAYSIZE(szName));
|
|
|
|
SHInvokePrinterCommand(hwnd, action, szName, NULL, FALSE);
|
|
}
|
|
} // for (i...
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
} // if (medium.hGlobal)
|
|
break;
|
|
} // case ID_NETWORK_PRINTER_INSTALL, FSIDM_CONNECT_PRN
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
break;
|
|
|
|
} // switch(wparam)
|
|
break;
|
|
|
|
default:
|
|
hr = E_NOTIMPL;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// REVIEW: Almost identical code in fstreex.c
|
|
//
|
|
DWORD CALLBACK CNetFolder::_PropertiesThreadProc(void *pv)
|
|
{
|
|
PROPSTUFF* pps = (PROPSTUFF *)pv;
|
|
ULONG_PTR dwCookie = 0;
|
|
ActivateActCtx(NULL, &dwCookie);
|
|
CNetFolder *pThis = FolderToNetFolder(pps->psf);
|
|
if (pThis)
|
|
{
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pps->pdtobj, &medium);
|
|
if (pida)
|
|
{
|
|
// Yes, do context menu.
|
|
HKEY ahkeys[NKID_COUNT];
|
|
LPCIDNETRESOURCE pnid = (LPCIDNETRESOURCE)IDA_GetIDListPtr(pida, 0);
|
|
if (pnid)
|
|
{
|
|
HRESULT hr = pThis->_OpenKeys(pnid, ahkeys);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPTSTR pszCaption = SHGetCaption(medium.hGlobal);
|
|
SHOpenPropSheet(pszCaption, ahkeys, ARRAYSIZE(ahkeys),
|
|
&CLSID_ShellNetDefExt,
|
|
pps->pdtobj, NULL, pps->pStartPage);
|
|
if (pszCaption)
|
|
SHFree(pszCaption);
|
|
|
|
SHRegCloseKeys(ahkeys, ARRAYSIZE(ahkeys));
|
|
}
|
|
}
|
|
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDAPI CNetFolder::_AttributesCallback(IShellFolder2* psf, LPCITEMIDLIST pidl, ULONG* prgfInOut)
|
|
{
|
|
LPCIDNETRESOURCE pidn = (LPCIDNETRESOURCE)pidl;
|
|
ULONG rgfOut = SFGAO_CANLINK | SFGAO_HASPROPSHEET | SFGAO_HASSUBFOLDER |
|
|
SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR;
|
|
|
|
if (NET_GetFlags(pidn) & SHID_JUNCTION)
|
|
{
|
|
if ((NET_GetType(pidn) == RESOURCETYPE_DISK) ||
|
|
(NET_GetType(pidn) == RESOURCETYPE_ANY))
|
|
rgfOut |= SFGAO_FILESYSTEM | SFGAO_DROPTARGET | SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_STORAGE;
|
|
else
|
|
rgfOut &= ~(SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR);
|
|
}
|
|
|
|
if (_IsPrintShare(pidn))
|
|
{
|
|
rgfOut |= SFGAO_DROPTARGET; // for drag and drop printing
|
|
rgfOut &= ~(SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_HASSUBFOLDER);
|
|
}
|
|
|
|
if (NET_IsRemoteFld(pidn))
|
|
{
|
|
rgfOut &= ~(SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSTEM);
|
|
}
|
|
|
|
*prgfInOut = rgfOut;
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
// This is only used by the CNetRootFolder subclass, but because we can only QI for
|
|
// CLSID_NetFldr, and we can't access protected members of any CNetFolder instance
|
|
// from a member function of CNetRootFolder, we'll make it belong to CNetFolder
|
|
|
|
HRESULT CALLBACK CNetFolder::_AttributesCallbackRoot(IShellFolder2* psf, LPCITEMIDLIST pidl, ULONG* prgfInOut)
|
|
{
|
|
HRESULT hr;
|
|
CNetFolder* pNetF = FolderToNetFolder(psf);
|
|
if (pNetF)
|
|
{
|
|
if (NET_IsValidID(pidl))
|
|
{
|
|
hr = pNetF->CNetFolder::GetAttributesOf(1, &pidl, prgfInOut);
|
|
}
|
|
else
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
hr = pNetF->v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->GetAttributesOf(1, &pidl, prgfInOut);
|
|
}
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|
|
// this is called by netfind.c
|
|
|
|
STDAPI CNetwork_EnumSearches(IShellFolder2* psf2, IEnumExtraSearch **ppenum)
|
|
{
|
|
*ppenum = NULL;
|
|
|
|
CNetFolder* pNetF = FolderToNetFolder(psf2);
|
|
return pNetF ? pNetF->EnumSearches(ppenum) : E_INVALIDARG;
|
|
}
|
|
|
|
|
|
// given the resulting ppidl and a pszRest continue to parse through and add in the remainder
|
|
// of the file system path.
|
|
|
|
HRESULT CNetFolder::_ParseRest(LPBC pbc, LPCWSTR pszRest, LPITEMIDLIST* ppidl, DWORD* pdwAttributes)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// skip leading \ if there is one present
|
|
if (pszRest && pszRest[0] == L'\\')
|
|
pszRest++;
|
|
|
|
if (pszRest && pszRest[0])
|
|
{
|
|
// need to QI to get the agregated case
|
|
IShellFolder* psfBind;
|
|
hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfBind));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// pass down to pick off stuff below including regitems and file names
|
|
IShellFolder* psfSub;
|
|
hr = psfBind->BindToObject(*ppidl, NULL, IID_PPV_ARG(IShellFolder, &psfSub));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlSubDir;
|
|
hr = psfSub->ParseDisplayName(NULL, pbc, (LPWSTR)pszRest, NULL, &pidlSubDir, pdwAttributes);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILAppend(pidlSubDir, ppidl);
|
|
}
|
|
psfSub->Release();
|
|
}
|
|
psfBind->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pdwAttributes)
|
|
{
|
|
LPCITEMIDLIST apidlLast[1] = { ILFindLastID(*ppidl) };
|
|
hr = GetAttributesOf(1, apidlLast, pdwAttributes);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// generate an IDLIST from the NETRESOURCESTRUCTURE we have by
|
|
// walking up its parents trying to determine where we
|
|
// are in the namespace
|
|
|
|
BOOL _GetParentResource(NETRESOURCE *pnr, DWORD *pdwbuf)
|
|
{
|
|
if ((pnr->dwDisplayType == RESOURCEDISPLAYTYPE_ROOT) ||
|
|
(WN_SUCCESS != WNetGetResourceParent(pnr, pnr, pdwbuf)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT CNetFolder::_NetResToIDLists(NETRESOURCE *pnr, DWORD dwbuf, LPITEMIDLIST *ppidl)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
do
|
|
{
|
|
LPITEMIDLIST pidlT;
|
|
hr = _NetResToIDList(pnr, TRUE, TRUE, TRUE, &pidlT);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILPrepend(pidlT, ppidl); // NOTE: SHILPrepend frees on failure
|
|
}
|
|
}
|
|
while (SUCCEEDED(hr) && _GetParentResource(pnr, &dwbuf));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// get the parsable network name from the object
|
|
|
|
LPTSTR CNetFolder::_GetNameForParsing(LPCWSTR pwszName, LPTSTR pszBuffer, INT cchBuffer, LPTSTR *ppszRegItem)
|
|
{
|
|
LPTSTR pszRegItem = NULL;
|
|
INT cSlashes = 0;
|
|
|
|
*ppszRegItem = NULL;
|
|
|
|
SHUnicodeToTChar(pwszName, pszBuffer, cchBuffer);
|
|
|
|
// remove the trailing \ if there is one, NTLanMan barfs if we pass a string containing it
|
|
|
|
INT cchPath = lstrlen(pszBuffer)-1;
|
|
if (cchPath > 2)
|
|
{
|
|
// We don't need to call CharPrev if cchPath <= 2.
|
|
// Calling CharPrev is expensive.
|
|
LPTSTR lpTmp = CharPrev(pszBuffer, pszBuffer + cchPath + 1);
|
|
if (*lpTmp == TEXT('\\'))
|
|
*lpTmp = TEXT('\0');
|
|
}
|
|
|
|
// lets walk the name, look for \:: squence to signify the start of a regitem name,
|
|
// and if the number of slashes is > 2 then we should bail
|
|
|
|
LPTSTR pszUNC = pszBuffer+2;
|
|
while (pszUNC && *pszUNC && (cSlashes < 2))
|
|
{
|
|
if ((pszUNC[0] == TEXT('\\')) &&
|
|
(pszUNC[1] == TEXT(':')) && (pszUNC[2] == TEXT(':')))
|
|
{
|
|
*ppszRegItem = pszUNC;
|
|
break;
|
|
}
|
|
|
|
pszUNC = StrChr(pszUNC+1, TEXT('\\'));
|
|
cSlashes++;
|
|
}
|
|
|
|
return pszUNC;
|
|
}
|
|
|
|
|
|
HRESULT CNetFolder::_ParseNetName(HWND hwnd, LPBC pbc,
|
|
LPCWSTR pwszName, ULONG* pchEaten,
|
|
LPITEMIDLIST *ppidl, DWORD *pdwAttrib)
|
|
{
|
|
HRESULT hr;
|
|
struct _NRTEMP
|
|
{
|
|
NETRESOURCE nr;
|
|
TCHAR szBuffer[1024];
|
|
} nrOut = { 0 };
|
|
TCHAR szPath[MAX_PATH];
|
|
DWORD dwres, dwbuf = sizeof(nrOut.szBuffer);
|
|
LPTSTR pszServerShare = NULL;
|
|
LPTSTR pszRestOfName = NULL;
|
|
LPTSTR pszFakeRestOfName = NULL;
|
|
LPTSTR pszRegItem = NULL;
|
|
|
|
// validate the name before we start cracking it...
|
|
|
|
pszFakeRestOfName = _GetNameForParsing(pwszName, szPath, ARRAYSIZE(szPath), &pszRegItem);
|
|
|
|
NETRESOURCE nr = { 0 };
|
|
nr.lpRemoteName = szPath;
|
|
nr.dwType = RESOURCETYPE_ANY;
|
|
|
|
TCHAR szProviderTemp[256];
|
|
nr.lpProvider = (LPTSTR)_GetProvider(NULL, pbc, szProviderTemp, ARRAYSIZE(szProviderTemp));
|
|
|
|
dwres = WNetGetResourceInformation(&nr, &nrOut.nr, &dwbuf, &pszRestOfName);
|
|
if (WN_SUCCESS != dwres)
|
|
{
|
|
TCHAR cT;
|
|
LPTSTR pszTemp;
|
|
|
|
// truncate the string at the \\server\share to try and parse the name,
|
|
// note at this point if MPR resolves the alias on a Novel server this could
|
|
// get very confusing (eg. \\strike\foo\bah may resolve to \\string\bla,
|
|
// yet our concept of what pszRestOfName will be wrong!
|
|
|
|
if (pszFakeRestOfName)
|
|
{
|
|
cT = *pszFakeRestOfName;
|
|
*pszFakeRestOfName = TEXT('\0');
|
|
}
|
|
|
|
dwres = WNetGetResourceInformation(&nr, &nrOut.nr, &dwbuf, &pszTemp);
|
|
if (dwres != WN_SUCCESS)
|
|
{
|
|
// we failed to get a net connection using the truncated string,
|
|
// so lets try and use a new connect (eg. prompt for creds)
|
|
|
|
// NOTE: shouldn't we only be doing this if its an access denied type error?
|
|
|
|
dwres = WNetUseConnection(hwnd, &nr, NULL, NULL, hwnd ? CONNECT_INTERACTIVE:0, NULL, NULL, NULL);
|
|
if (dwres == WN_SUCCESS)
|
|
{
|
|
dwres = WNetGetResourceInformation(&nr, &nrOut, &dwbuf, &pszTemp);
|
|
}
|
|
}
|
|
|
|
if (pszFakeRestOfName)
|
|
*pszFakeRestOfName = cT;
|
|
|
|
pszRestOfName = pszFakeRestOfName;
|
|
}
|
|
|
|
if (WN_SUCCESS == dwres)
|
|
{
|
|
WCHAR wszRestOfName[MAX_PATH] = { 0 };
|
|
|
|
if (pszRestOfName)
|
|
SHTCharToUnicode(pszRestOfName, wszRestOfName, ARRAYSIZE(wszRestOfName));
|
|
|
|
// assume we are truncating at the regitem and parsing through
|
|
|
|
if (pszRegItem)
|
|
pszRestOfName = pszRegItem;
|
|
|
|
// attempt to convert the NETRESOURCE to a string to IDLISTS by walking the
|
|
// parents, then add in Entire Network
|
|
|
|
hr = _NetResToIDLists(&nrOut.nr, dwbuf, ppidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlT;
|
|
hr = _CreateEntireNetwork(&pidlT);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILPrepend(pidlT, ppidl); // NOTE: SHILPrepend frees on failure
|
|
}
|
|
}
|
|
|
|
// if we have a local string then lets continue to parse it by binding to
|
|
// its parent folder, otherwise we just want to return the attributes
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (SUCCEEDED(DisplayNameOf(this, *ppidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath))))
|
|
{
|
|
NPTRegisterNameToPidlTranslation(szPath, *ppidl); // no _ILNext b/c this is relative to the Net Places folder
|
|
}
|
|
hr = _ParseRest(pbc, wszRestOfName, ppidl, pdwAttrib);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(dwres);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// simple name parsing for the network paths. this makes big assumptions about the
|
|
// \\server\share format we are given, and the type of IDLISTs to return.
|
|
//
|
|
|
|
HRESULT CNetFolder::_AddUnknownIDList(DWORD dwDisplayType, LPITEMIDLIST *ppidl)
|
|
{
|
|
NETRESOURCE nr = { 0 };
|
|
|
|
nr.dwScope = RESOURCE_GLOBALNET;
|
|
nr.dwDisplayType = dwDisplayType;
|
|
nr.dwUsage = RESOURCEUSAGE_CONTAINER;
|
|
nr.lpRemoteName = TEXT("\0"); // null name means fake item
|
|
|
|
LPITEMIDLIST pidlT;
|
|
HRESULT hr = _NetResToIDList(&nr, TRUE, FALSE, FALSE, &pidlT);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILAppend(pidlT, ppidl);
|
|
if (FAILED(hr))
|
|
ILFree(pidlT);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetFolder::_ParseSimple(LPBC pbc, LPWSTR pszName, LPITEMIDLIST* ppidl, DWORD* pdwAttributes)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
NETRESOURCE nr = {0};
|
|
LPWSTR pszSlash;
|
|
LPITEMIDLIST pidlT;
|
|
USES_CONVERSION;
|
|
|
|
*ppidl = NULL;
|
|
|
|
// create the entire network IDLIST, provider and domain elements
|
|
|
|
hr = _CreateEntireNetwork(ppidl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = _AddUnknownIDList(RESOURCEDISPLAYTYPE_NETWORK, ppidl);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = _AddUnknownIDList(RESOURCEDISPLAYTYPE_DOMAIN, ppidl);
|
|
|
|
// create the server IDLIST
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pszSlash = StrChrW(pszName+2, L'\\');
|
|
|
|
if (pszSlash)
|
|
*pszSlash = L'\0';
|
|
|
|
nr.dwScope = RESOURCE_GLOBALNET;
|
|
nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
|
|
nr.dwType = RESOURCETYPE_DISK;
|
|
nr.dwUsage = RESOURCEUSAGE_CONTAINER;
|
|
nr.lpRemoteName = W2T(pszName);
|
|
|
|
hr = _NetResToIDList(&nr, FALSE, FALSE, FALSE, &pidlT);
|
|
if (SUCCEEDED(hr))
|
|
hr = SHILAppend(pidlT, ppidl);
|
|
|
|
if (pszSlash)
|
|
*pszSlash = L'\\';
|
|
|
|
// if we have a trailing \ then lets add in the share part of the IDLIST
|
|
|
|
if (SUCCEEDED(hr) && pszSlash)
|
|
{
|
|
pszSlash = StrChrW(pszSlash+1, L'\\');
|
|
if (pszSlash)
|
|
*pszSlash = L'\0';
|
|
|
|
nr.dwDisplayType = RESOURCEDISPLAYTYPE_SHARE;
|
|
nr.dwUsage = RESOURCEUSAGE_CONNECTABLE;
|
|
nr.lpRemoteName = W2T(pszName);
|
|
|
|
hr = _NetResToIDList(&nr, FALSE, FALSE, FALSE, &pidlT);
|
|
if (SUCCEEDED(hr))
|
|
hr = SHILAppend(pidlT, ppidl);
|
|
|
|
if (pszSlash)
|
|
*pszSlash = L'\\';
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _ParseRest(pbc, pszSlash, ppidl, pdwAttributes);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// try parsing out the EntireNet or localised version. if we find that object then try and
|
|
// parse through that to the regitems or other objects which live below. this inturn
|
|
// will cause an instance of CNetFolder to be created to generate the other parsing names.
|
|
//
|
|
// returns:
|
|
// S_FALSE - not rest of net, try something else
|
|
// S_OK - was rest of net, use this
|
|
// FAILED(hr) - error result, return
|
|
|
|
HRESULT CNetRootFolder::_TryParseEntireNet(HWND hwnd, LPBC pbc, WCHAR *pwszName, LPITEMIDLIST *ppidl, DWORD *pdwAttributes)
|
|
{
|
|
HRESULT hr = S_FALSE; // skip, not rest of net
|
|
|
|
*ppidl = NULL;
|
|
|
|
if (!PathIsUNCW(pwszName))
|
|
{
|
|
const WCHAR szEntireNetwork[] = L"EntireNetwork";
|
|
WCHAR szRestOfNet[128];
|
|
INT cchRestOfNet = LoadStringW(HINST_THISDLL, IDS_RESTOFNET, szRestOfNet, ARRAYSIZE(szRestOfNet));
|
|
|
|
BOOL fRestOfNet = !StrCmpNIW(szRestOfNet, pwszName, cchRestOfNet);
|
|
if (!fRestOfNet && !StrCmpNIW(szEntireNetwork, pwszName, ARRAYSIZE(szEntireNetwork)-1))
|
|
{
|
|
fRestOfNet = TRUE;
|
|
cchRestOfNet = ARRAYSIZE(szEntireNetwork)-1;
|
|
}
|
|
|
|
if (fRestOfNet)
|
|
{
|
|
hr = _CreateEntireNetwork(ppidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pdwAttributes)
|
|
{
|
|
GetAttributesOf(1, (LPCITEMIDLIST *)ppidl, pdwAttributes);
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
|
|
//
|
|
// if we find extra stuff after the name then lets bind and continue the parsing
|
|
// from there on. this is needed so the we can access regitems burried inside
|
|
// entire net.
|
|
//
|
|
// eg: EntireNetwork\\::{clsid}
|
|
//
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
(pwszName[cchRestOfNet] == L'\\') && pwszName[cchRestOfNet+1])
|
|
{
|
|
IShellFolder *psfRestOfNet;
|
|
hr = BindToObject(*ppidl, NULL, IID_PPV_ARG(IShellFolder, &psfRestOfNet));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
hr = psfRestOfNet->ParseDisplayName(hwnd, pbc, pwszName+cchRestOfNet+1, NULL, &pidl, pdwAttributes);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHILAppend(pidl, ppidl);
|
|
}
|
|
psfRestOfNet->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// CNetRootFolder::ParseDisplayname
|
|
// - swtich based on the file system context to see if we need to do a simple parse or not,
|
|
// - check for "EntireNet" and delegate parsing as required.
|
|
|
|
STDMETHODIMP CNetRootFolder::ParseDisplayName(HWND hwnd, LPBC pbc, WCHAR* pszName, ULONG* pchEaten, LPITEMIDLIST* ppidl, DWORD* pdwAttributes)
|
|
{
|
|
if (!ppidl)
|
|
return E_INVALIDARG;
|
|
|
|
*ppidl = NULL;
|
|
|
|
if (!pszName)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr = _TryParseEntireNet(hwnd, pbc, pszName, ppidl, pdwAttributes);
|
|
if (hr == S_FALSE)
|
|
{
|
|
if (PathIsUNCW(pszName))
|
|
{
|
|
LPCITEMIDLIST pidlMapped;
|
|
LPTSTR pszRest = NPTMapNameToPidl(pszName, &pidlMapped);
|
|
if (pidlMapped)
|
|
{
|
|
hr = SHILClone(pidlMapped, ppidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _ParseRest(pbc, pszRest, ppidl, pdwAttributes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (S_OK == SHIsFileSysBindCtx(pbc, NULL))
|
|
{
|
|
hr = _ParseSimple(pbc, pszName, ppidl, pdwAttributes);
|
|
}
|
|
else
|
|
{
|
|
hr = _ParseNetName(hwnd, pbc, pszName, pchEaten, ppidl, pdwAttributes);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_NET_NAME);
|
|
}
|
|
|
|
if ((HRESULT_FROM_WIN32(ERROR_BAD_NET_NAME) == hr))
|
|
{
|
|
IShellFolder2 *psfFiles;
|
|
if (SUCCEEDED(v_GetFileFolder(&psfFiles)))
|
|
{
|
|
hr = psfFiles->ParseDisplayName(hwnd, pbc, pszName, pchEaten, ppidl, pdwAttributes);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
ILFree(*ppidl);
|
|
*ppidl = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP CNetRootFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList** ppenum)
|
|
{
|
|
DWORD dwRemote = RMF_GETLINKENUM;
|
|
HANDLE hEnum = NULL;
|
|
|
|
// Do we enumerate the workgroup?
|
|
if (!SHRestricted(REST_ENUMWORKGROUP))
|
|
{
|
|
// Don't enumerate the workgroup, if the restriction says so
|
|
dwRemote |= RMF_FAKENETROOT;
|
|
|
|
// Check the WNet policy to see if we should be showing the
|
|
// entire net object. If not, mark it as shown so that the
|
|
// enumerator doesn't return it.
|
|
if (SHRestricted(REST_NOENTIRENETWORK))
|
|
dwRemote |= RMF_ENTIRENETSHOWN;
|
|
}
|
|
|
|
// if we are not faking the net root then lets call _OpenEnum, otherwise lets ignore
|
|
|
|
if (!(dwRemote & RMF_FAKENETROOT))
|
|
{
|
|
DWORD err = _OpenEnum(hwnd, grfFlags, NULL, &hEnum);
|
|
|
|
// Always add the remote folder to the 'hood
|
|
if (WN_SUCCESS != err)
|
|
{
|
|
// Yes; still show remote anyway (only)
|
|
dwRemote |= RMF_SHOWREMOTE;
|
|
}
|
|
else
|
|
{
|
|
// No; allow everything to be enumerated in the 'hood.
|
|
dwRemote |= RMF_CONTEXT;
|
|
}
|
|
}
|
|
|
|
HRESULT hr = Create_NetFolderEnum(this, grfFlags, dwRemote, hEnum, ppenum);
|
|
|
|
if (FAILED(hr) && hEnum)
|
|
{
|
|
WNetCloseEnum(hEnum);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
if (NET_IsValidID(pidl))
|
|
hr = CNetFolder::BindToObject(pidl, pbc, riid, ppv);
|
|
else
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
hr = v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->BindToObject(pidl, pbc, riid, ppv);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::CompareIDs(LPARAM iCol, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
// First obtain the collate type of the pidls and their respective
|
|
// collate order.
|
|
|
|
LONG iColateType1 = _GetFilePIDLType(pidl1);
|
|
LONG iColateType2 = _GetFilePIDLType(pidl2);
|
|
|
|
if (iColateType1 == iColateType2)
|
|
{
|
|
// pidls are of same type.
|
|
if (iColateType1 == _HOOD_COL_FILE) // two file system pidls
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
if (SUCCEEDED(v_GetFileFolder(&psfFiles)))
|
|
{
|
|
if (0 == (iCol & SHCIDS_COLUMNMASK))
|
|
{
|
|
// special case this for perf, this is the name compare
|
|
hr = psfFiles->CompareIDs(iCol, pidl1, pidl2);
|
|
}
|
|
else
|
|
{
|
|
SHCOLUMNID scid;
|
|
MapColumnToSCID((UINT)iCol & SHCIDS_COLUMNMASK, &scid);
|
|
int iRet = CompareBySCID(psfFiles, &scid, pidl1, pidl2);
|
|
hr = ResultFromShort(iRet);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pidls same and are not of type file,
|
|
// so both must be a type understood
|
|
// by the CNetwork class - pass on to compare.
|
|
|
|
hr = CNetFolder::CompareIDs(iCol, pidl1, pidl2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ensure that entire network ends up at the head of the list
|
|
|
|
LPCIDNETRESOURCE pidn1 = NET_IsValidID(pidl1);
|
|
LPCIDNETRESOURCE pidn2 = NET_IsValidID(pidl2);
|
|
|
|
if ((pidn1 && (NET_GetDisplayType(pidn1) == RESOURCEDISPLAYTYPE_ROOT)) ||
|
|
(pidn2 && (NET_GetDisplayType(pidn2) == RESOURCEDISPLAYTYPE_ROOT)))
|
|
{
|
|
if (iColateType1 == _HOOD_COL_FILE)
|
|
return ResultFromShort(1);
|
|
else
|
|
return ResultFromShort(-1);
|
|
}
|
|
|
|
// pidls are not of same type, so have already been correctly
|
|
// collated (consequently, sorting is first by type and
|
|
// then by subfield).
|
|
|
|
hr = ResultFromShort(((iColateType2 - iColateType1) > 0) ? 1 : -1);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv)
|
|
{
|
|
ASSERT(ILIsEqual(_pidl, (LPCITEMIDLIST)&c_idlNet));
|
|
|
|
if (IsEqualIID(riid, IID_IDropTarget))
|
|
{
|
|
return CNetRootDropTarget_CreateInstance(hwnd, _pidl, (IDropTarget**) ppv);
|
|
}
|
|
return CNetFolder::CreateViewObject(hwnd, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG* prgfInOut)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (IsSelf(cidl, apidl))
|
|
{
|
|
// The user can rename links in the hood.
|
|
hr = CNetFolder::GetAttributesOf(cidl, apidl, prgfInOut);
|
|
*prgfInOut |= SFGAO_CANRENAME;
|
|
}
|
|
else
|
|
{
|
|
hr = GetAttributesCallback(SAFECAST(this, IShellFolder2*), cidl, apidl, prgfInOut, _AttributesCallbackRoot);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, STRRET* pStrRet)
|
|
{
|
|
HRESULT hr;
|
|
if (NET_IsValidID(pidl) || IsSelf(1, &pidl))
|
|
{
|
|
hr = CNetFolder::GetDisplayNameOf(pidl, dwFlags, pStrRet);
|
|
}
|
|
else
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
hr = v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->GetDisplayNameOf(pidl, dwFlags, pStrRet);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName,
|
|
DWORD dwRes, LPITEMIDLIST* ppidl)
|
|
{
|
|
HRESULT hr;
|
|
if (NET_IsValidID(pidl))
|
|
{
|
|
hr = CNetFolder::SetNameOf(hwnd, pidl, lpszName, dwRes, ppidl);
|
|
}
|
|
else
|
|
{
|
|
IShellFolder2* psfFiles;
|
|
hr = v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->SetNameOf(hwnd, pidl, lpszName, dwRes, ppidl);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST* apidl,
|
|
REFIID riid, UINT* prgfInOut, void **ppv)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
LPCIDNETRESOURCE pidn = cidl ? NET_IsValidID(apidl[0]) : NULL;
|
|
BOOL fStriped = FALSE;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (pidn)
|
|
{
|
|
fStriped = _MakeStripToLikeKinds(&cidl, &apidl, TRUE);
|
|
|
|
if (IsEqualIID(riid, IID_IContextMenu))
|
|
{
|
|
HKEY ahkeys[NKID_COUNT];
|
|
|
|
hr = _OpenKeys(pidn, ahkeys);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolder* psfOuter;
|
|
hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfOuter));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = CDefFolderMenu_Create2(_pidl, hwnd, cidl, apidl,
|
|
psfOuter, _GetCallbackType(pidn),
|
|
ARRAYSIZE(ahkeys), ahkeys, (IContextMenu**) ppv);
|
|
psfOuter->Release();
|
|
}
|
|
SHRegCloseKeys(ahkeys, ARRAYSIZE(ahkeys));
|
|
}
|
|
}
|
|
else
|
|
hr = CNetFolder::GetUIObjectOf(hwnd, cidl, apidl, riid, prgfInOut, ppv);
|
|
}
|
|
else
|
|
{
|
|
fStriped = _MakeStripToLikeKinds(&cidl, &apidl, FALSE);
|
|
|
|
IShellFolder2* psfFiles;
|
|
hr = v_GetFileFolder(&psfFiles);
|
|
if (SUCCEEDED(hr))
|
|
hr = psfFiles->GetUIObjectOf(hwnd, cidl, apidl, riid, prgfInOut, ppv);
|
|
}
|
|
|
|
if (fStriped)
|
|
LocalFree((HLOCAL)apidl);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::GetClassID(CLSID* pCLSID)
|
|
{
|
|
*pCLSID = CLSID_NetworkPlaces;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootFolder::Initialize(LPCITEMIDLIST pidl)
|
|
{
|
|
ASSERT(ILIsEqual(pidl, (LPCITEMIDLIST)&c_idlNet));
|
|
ASSERT(AssertIsIDListInNameSpace(pidl, &CLSID_NetworkPlaces) && ILIsEmpty(_ILNext(pidl)));
|
|
// Only allow the Net root on the desktop
|
|
|
|
// Don't initialize more than once; we are a singleton object.
|
|
// This is theoretically redundant with the InterlockedCompareExchange
|
|
// below, but redundant reinitialization is by far the common case
|
|
// so we'll optimize it.
|
|
if (_pidl)
|
|
return S_OK;
|
|
|
|
LPITEMIDLIST pidlNew;
|
|
HRESULT hr = SHILClone(pidl, &pidlNew);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (SHInterlockedCompareExchange((void**)&_pidl, pidlNew, 0))
|
|
{
|
|
// Some other thread raced with us, throw away our copy
|
|
ILFree(pidlNew);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
LONG CNetFolder::_GetFilePIDLType(LPCITEMIDLIST pidl)
|
|
{
|
|
if (NET_IsValidID(pidl))
|
|
{
|
|
if (NET_IsRemoteFld((LPIDNETRESOURCE)pidl))
|
|
{
|
|
return _HOOD_COL_REMOTE;
|
|
}
|
|
if (NET_GetDisplayType((LPIDNETRESOURCE)pidl) == RESOURCEDISPLAYTYPE_ROOT)
|
|
{
|
|
return _HOOD_COL_RON;
|
|
}
|
|
return _HOOD_COL_NET;
|
|
}
|
|
return _HOOD_COL_FILE;
|
|
}
|
|
|
|
|
|
/* This function adds a provider name to an IDLIST that doesn't already have one. */
|
|
/* A new IDLIST pointer is returned; the old pointer is no longer valid. */
|
|
|
|
LPITEMIDLIST CNetFolder::_AddProviderToPidl(LPITEMIDLIST pidl, LPCTSTR lpProvider)
|
|
{
|
|
LPIDNETRESOURCE pidn = (LPIDNETRESOURCE)pidl;
|
|
|
|
if (!NET_FHasProvider(pidn))
|
|
{
|
|
LPITEMIDLIST pidlres;
|
|
TCHAR szName[MAX_PATH], szComment[MAX_PATH];
|
|
|
|
// construct a new IDLIST preserving the name, comment and other information
|
|
|
|
NET_CopyResName(pidn, szName, ARRAYSIZE(szName));
|
|
NET_CopyComment(pidn, szComment, ARRAYSIZE(szComment));
|
|
|
|
HRESULT hr = _CreateNetIDList(pidn, szName, lpProvider, szComment[0] ? szComment:NULL, &pidlres);
|
|
if (SUCCEEDED(hr) && !ILIsEmpty(_ILNext(pidl)))
|
|
{
|
|
LPITEMIDLIST pidlT;
|
|
hr = SHILCombine(pidlres, _ILNext(pidl), &pidlT);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ILFree(pidlres);
|
|
pidlres = pidlT;
|
|
}
|
|
}
|
|
|
|
// if we have a result, free the old PIDL and return the new
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ILFree(pidl);
|
|
pidl = pidlres;
|
|
}
|
|
}
|
|
|
|
return pidl;
|
|
}
|
|
|
|
BOOL CNetFolder::_MakeStripToLikeKinds(UINT *pcidl, LPCITEMIDLIST **papidl, BOOL fNetObjects)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
LPITEMIDLIST *apidl = (LPITEMIDLIST*)*papidl;
|
|
int cidl = *pcidl;
|
|
|
|
for (int i = 0; i < cidl; i++)
|
|
{
|
|
if ((NET_IsValidID(apidl[i]) != NULL) != fNetObjects)
|
|
{
|
|
LPCITEMIDLIST *apidlHomo = (LPCITEMIDLIST *)LocalAlloc(LPTR, sizeof(*apidlHomo) * cidl);
|
|
if (!apidlHomo)
|
|
return FALSE;
|
|
|
|
int cpidlHomo = 0;
|
|
for (i = 0; i < cidl; i++)
|
|
{
|
|
if ((NET_IsValidID(apidl[i]) != NULL) == fNetObjects)
|
|
apidlHomo[cpidlHomo++] = apidl[i];
|
|
}
|
|
|
|
// Setup to use the stripped version of the pidl array...
|
|
*pcidl = cpidlHomo;
|
|
*papidl = apidlHomo;
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
HRESULT CNetRootFolder::v_GetFileFolder(IShellFolder2 **psf)
|
|
{
|
|
HRESULT hr = SHCacheTrackingFolder((LPCITEMIDLIST)&c_idlNet, CSIDL_NETHOOD, &_psfFiles);
|
|
*psf = _psfFiles;
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// pmedium and pformatetcIn == NULL if we are handling QueryGetData
|
|
//
|
|
HRESULT CNetData::GetHDrop(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
|
|
{
|
|
HRESULT hr = E_INVALIDARG; // assume error
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(this, &medium);
|
|
if (pida)
|
|
{
|
|
// Get the first one to see the type.
|
|
LPCIDNETRESOURCE pidn = (LPCIDNETRESOURCE)IDA_GetIDListPtr(pida, 0);
|
|
|
|
if (NULL == pidn)
|
|
hr = E_FAIL;
|
|
|
|
if (pidn && (NET_GetFlags(pidn) & SHID_JUNCTION) &&
|
|
(NET_GetType(pidn) == RESOURCETYPE_DISK))
|
|
{
|
|
// Get HDrop only if we are handling IDataObject::GetData (pmedium != NULL)
|
|
if (pmedium)
|
|
{
|
|
// We have non-null FORMATETC and STGMEDIUM - get the HDrop
|
|
hr = CFSIDLData::GetHDrop(pformatetcIn, pmedium);
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK; // We were handling QueryGetData
|
|
}
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
LPTSTR NET_GetProviderFromRes(LPCIDNETRESOURCE pidn, LPTSTR pszBuff, UINT cchBuff);
|
|
|
|
// By the way...Win95 shipped with the below provider
|
|
// names. Since the name can be changed and be localized,
|
|
// we have to try and map these correctly for net pidl
|
|
// interop.
|
|
|
|
//
|
|
// get the network resource name from an item. this is not a file system path!
|
|
//
|
|
// example:
|
|
// server \\server or strike/sys
|
|
// share \\server\share or strike/sys
|
|
// printer \\server\printer
|
|
// provider "provider name"
|
|
// entire net "Entire Network"
|
|
//
|
|
// in:
|
|
// pidn the item
|
|
// cchBuff size of buffer in chars.
|
|
//
|
|
// out:
|
|
// pszBuff return buffer
|
|
//
|
|
// returns:
|
|
// address of the input buffer (pszBuff)
|
|
//
|
|
LPTSTR NET_CopyResName(LPCIDNETRESOURCE pidn, LPTSTR pszBuff, UINT cchBuff)
|
|
{
|
|
if (NET_IsUnicode(pidn))
|
|
{
|
|
LPBYTE pb = (LPBYTE)pidn->szNetResName;
|
|
pb += lstrlenA((LPSTR)pb) + 1; // Skip over ansi net name
|
|
if (NET_FHasProvider(pidn))
|
|
pb += lstrlenA((LPSTR)pb) + 1; // Skip over ansi provider
|
|
if (NET_FHasComment(pidn))
|
|
pb += lstrlenA((LPSTR)pb) + 1; // Skip over comment
|
|
ualstrcpyn(pszBuff, (LPNWSTR)pb, cchBuff);
|
|
}
|
|
else
|
|
{
|
|
SHAnsiToTChar(pidn->szNetResName, pszBuff, cchBuff);
|
|
}
|
|
return pszBuff;
|
|
}
|
|
|
|
//
|
|
// get the provider name from an item. some items do not have providers stored
|
|
// in them. for example the "*" indicates where the provider is stored in the
|
|
// two different forms of network pidls.
|
|
// [entire net] [provider *] [server] [share] [... file system]
|
|
// [server *] [share] [... file system]
|
|
// in:
|
|
// pidn item (single item PIDL) to try to get the provider name from
|
|
// cchBuff size in chars.
|
|
// out:
|
|
// pszBuff output
|
|
//
|
|
LPTSTR NET_CopyProviderName(LPCIDNETRESOURCE pidn, LPTSTR pszBuff, UINT cchBuff)
|
|
{
|
|
*pszBuff = 0;
|
|
|
|
if (!NET_FHasProvider(pidn))
|
|
return NULL;
|
|
|
|
// try the wNetType at the end of the pidl
|
|
|
|
const BYTE *pb = (LPBYTE)pidn + pidn->cb - sizeof(WORD);
|
|
DWORD dwNetType = *((UNALIGNED WORD *)pb) << 16;
|
|
|
|
if (dwNetType && (dwNetType <= WNNC_NET_LARGEST) &&
|
|
(WNetGetProviderName(dwNetType, pszBuff, (ULONG*)&cchBuff) == WN_SUCCESS))
|
|
{
|
|
return pszBuff;
|
|
}
|
|
|
|
// Try the old way...
|
|
|
|
pb = (LPBYTE)pidn->szNetResName + lstrlenA(pidn->szNetResName) + 1; // Skip over ansi net name
|
|
|
|
if (NET_IsUnicode(pidn))
|
|
{
|
|
pb += lstrlenA((LPSTR)pb) + 1; // Skip over ansi provider
|
|
if (NET_FHasComment(pidn))
|
|
pb += lstrlenA((LPSTR)pb) + 1; // Skip over comment
|
|
pb += (ualstrlen((LPNWSTR)pb) + 1) * sizeof(WCHAR); // skip over unicode net name
|
|
ualstrcpyn(pszBuff, (LPNWSTR)pb, cchBuff);
|
|
}
|
|
else
|
|
{
|
|
SHAnsiToTChar((LPSTR)pb, pszBuff, cchBuff);
|
|
}
|
|
|
|
// Map from Win95 net provider name if possible...
|
|
for (int i = 0; i < ARRAYSIZE(c_rgProviderMap); i++)
|
|
{
|
|
if (lstrcmp(pszBuff, c_rgProviderMap[i].lpName) == 0)
|
|
{
|
|
DWORD dwNetType = c_rgProviderMap[i].wNetType << 16;
|
|
if (dwNetType && (dwNetType <= WNNC_NET_LARGEST))
|
|
{
|
|
*pszBuff = 0;
|
|
WNetGetProviderName(dwNetType, pszBuff, (LPDWORD)&cchBuff);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return pszBuff;
|
|
}
|
|
|
|
//
|
|
// get the comment if there is one from the net item
|
|
//
|
|
LPTSTR NET_CopyComment(LPCIDNETRESOURCE pidn, LPTSTR pszBuff, UINT cchBuff)
|
|
{
|
|
*pszBuff = 0;
|
|
|
|
LPCSTR pszT = pidn->szNetResName + lstrlenA(pidn->szNetResName) + 1;
|
|
if (NET_FHasComment(pidn))
|
|
{
|
|
if (NET_FHasProvider(pidn))
|
|
pszT += lstrlenA(pszT) + 1;
|
|
if (NET_IsUnicode(pidn))
|
|
{
|
|
pszT += lstrlenA(pszT) + 1; // Skip Ansi comment
|
|
|
|
LPNCWSTR pszW = (LPNCWSTR)pszT; // We're at the unicode portion of the pidl
|
|
pszW += ualstrlen(pszW) + 1; // Skip Unicode Name
|
|
if (NET_FHasProvider(pidn))
|
|
pszW += ualstrlen(pszW) + 1; // Skip Unicode Provider
|
|
ualstrcpyn(pszBuff, pszW, cchBuff);
|
|
}
|
|
else
|
|
{
|
|
SHAnsiToUnicode(pszT, pszBuff, cchBuff);
|
|
}
|
|
}
|
|
return pszBuff;
|
|
}
|
|
|
|
// pidlRemainder will be filled in (only in the TRUE return case) with a
|
|
// pointer to the part of the IDL (if any) past the remote regitem.
|
|
// This value may be used, for example, to differentiate between a remote
|
|
// printer folder and a printer under a remote printer folder
|
|
|
|
BOOL NET_IsRemoteRegItem(LPCITEMIDLIST pidl, REFCLSID rclsid, LPCITEMIDLIST* ppidlRemainder)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
// in "My Network Places"
|
|
if (pidl && IsIDListInNameSpace(pidl, &CLSID_NetworkPlaces))
|
|
{
|
|
LPCITEMIDLIST pidlStart = pidl; // save this
|
|
|
|
// Now, search for a server item. HACKHACK: this assume everything from
|
|
// the NetHood to the server item is a shell pidl with a bFlags field!!
|
|
|
|
for (pidl = _ILNext(pidl); !ILIsEmpty(pidl); pidl = _ILNext(pidl))
|
|
{
|
|
if ((SIL_GetType(pidl) & SHID_TYPEMASK) == SHID_NET_SERVER)
|
|
{
|
|
LPITEMIDLIST pidlToTest;
|
|
|
|
// Found a server. Is the thing after it a remote registry item?
|
|
pidl = _ILNext(pidl);
|
|
|
|
*ppidlRemainder = _ILNext(pidl);
|
|
|
|
pidlToTest = ILCloneUpTo(pidlStart, *ppidlRemainder);
|
|
if (pidlToTest)
|
|
{
|
|
CLSID clsid;
|
|
bRet = SUCCEEDED(GetCLSIDFromIDList(pidlToTest, &clsid)) && IsEqualCLSID(rclsid, clsid);
|
|
ILFree(pidlToTest);
|
|
}
|
|
break; // done
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Get the provider name from an absolute IDLIST.
|
|
// Parameters:
|
|
// pidlAbs -- Specifies the Absolute IDList to the file system object
|
|
//
|
|
LPTSTR NET_GetProviderFromIDList(LPCITEMIDLIST pidlAbs, LPTSTR pszBuff, UINT cchBuff)
|
|
{
|
|
return NET_GetProviderFromRes((LPCIDNETRESOURCE)_ILNext(pidlAbs), pszBuff, cchBuff);
|
|
}
|
|
|
|
//
|
|
// Get the provider name from a relative IDLIST.
|
|
// in:
|
|
// pidn potentially multi level item to try to get the resource from
|
|
//
|
|
LPTSTR NET_GetProviderFromRes(LPCIDNETRESOURCE pidn, LPTSTR pszBuffer, UINT cchBuffer)
|
|
{
|
|
// If this guy is the REST of network item, we increment to the
|
|
// next IDLIST - If at root return NULL
|
|
if (pidn->cb == 0)
|
|
return NULL;
|
|
|
|
//
|
|
// If the IDLIST starts with a ROOT_REGITEM, then skip to the
|
|
// next item in the list...
|
|
if (pidn->bFlags == SHID_ROOT_REGITEM)
|
|
{
|
|
pidn = (LPIDNETRESOURCE)_ILNext((LPITEMIDLIST)pidn);
|
|
if (pidn->cb == 0)
|
|
return NULL;
|
|
}
|
|
|
|
// If the IDLIST includes Entire Network, the provider will be
|
|
// part of the next component.
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_ROOT)
|
|
{
|
|
pidn = (LPIDNETRESOURCE)_ILNext((LPITEMIDLIST)pidn);
|
|
if (pidn->cb == 0)
|
|
return NULL;
|
|
}
|
|
|
|
// If the next component after the 'hood or Entire Network is
|
|
// a network object, its name is the provider name, else the
|
|
// provider name comes after the remote name.
|
|
if (NET_GetDisplayType(pidn) == RESOURCEDISPLAYTYPE_NETWORK)
|
|
{
|
|
// Simply return the name field back for the item.
|
|
return NET_CopyResName(pidn, pszBuffer, cchBuffer);
|
|
}
|
|
else
|
|
{
|
|
// Nope one of the items in the neighborhood view was selected
|
|
// The Provider name is stored after ther resource name
|
|
return NET_CopyProviderName(pidn, pszBuffer, cchBuffer);
|
|
}
|
|
}
|
|
|
|
#define PTROFFSET(pBase, p) ((int) ((LPBYTE)(p) - (LPBYTE)(pBase)))
|
|
|
|
|
|
//
|
|
// fill in pmedium with a NRESARRAY
|
|
//
|
|
// pmedium == NULL if we are handling QueryGetData
|
|
//
|
|
STDAPI CNetData_GetNetResource(IDataObject *pdtobj, STGMEDIUM *pmedium)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
LPITEMIDLIST pidl;
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
|
|
ASSERT(pida && pida->cidl);
|
|
|
|
// First, get the provider name from the first one (assuming they are common).
|
|
pidl = IDA_ILClone(pida, 0);
|
|
if (pidl)
|
|
{
|
|
TCHAR szProvider[MAX_PATH];
|
|
LPCTSTR pszProvider = NET_GetProviderFromIDList(pidl, szProvider, ARRAYSIZE(szProvider));
|
|
if (pmedium)
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
UINT cbHeader = sizeof(NRESARRAY) + (sizeof(NETRESOURCE) * (pida->cidl - 1));
|
|
UINT cbRequired, iItem;
|
|
|
|
// Calculate required size
|
|
cbRequired = cbHeader;
|
|
if (pszProvider)
|
|
cbRequired += (lstrlen(pszProvider) + 1) * sizeof(TCHAR);
|
|
|
|
for (iItem = 0; iItem < pida->cidl; iItem++)
|
|
{
|
|
LPCIDNETRESOURCE pidn = (LPCIDNETRESOURCE)IDA_GetIDListPtr(pida, iItem);
|
|
NET_CopyResName(pidn, szName, ARRAYSIZE(szName));
|
|
cbRequired += (lstrlen(szName) + 1) * sizeof(TCHAR);
|
|
}
|
|
|
|
//
|
|
// Indicate that the caller should release hmem.
|
|
//
|
|
pmedium->pUnkForRelease = NULL;
|
|
pmedium->tymed = TYMED_HGLOBAL;
|
|
pmedium->hGlobal = GlobalAlloc(GPTR, cbRequired);
|
|
if (pmedium->hGlobal)
|
|
{
|
|
LPNRESARRAY panr = (LPNRESARRAY)pmedium->hGlobal;
|
|
LPTSTR pszT = (LPTSTR)((LPBYTE)panr + cbHeader);
|
|
LPTSTR pszEnd = (LPTSTR)((LPBYTE)panr + cbRequired);
|
|
UINT offProvider = 0;
|
|
|
|
panr->cItems = pida->cidl;
|
|
|
|
// Copy the provider name. This is not necessary,
|
|
// if we are dragging providers.
|
|
if (pszProvider)
|
|
{
|
|
lstrcpy(pszT, pszProvider);
|
|
offProvider = PTROFFSET(panr, pszT);
|
|
pszT += lstrlen(pszT) + 1;
|
|
}
|
|
|
|
//
|
|
// For each item, fill each NETRESOURCE and append resource
|
|
// name at the end. Note that we should put offsets in
|
|
// lpProvider and lpRemoteName.
|
|
//
|
|
for (iItem = 0; iItem < pida->cidl; iItem++)
|
|
{
|
|
LPNETRESOURCE pnr = &panr->nr[iItem];
|
|
LPCIDNETRESOURCE pidn = (LPCIDNETRESOURCE)IDA_GetIDListPtr(pida, iItem);
|
|
|
|
ASSERT(pnr->dwScope == 0);
|
|
ASSERT(pnr->lpLocalName==NULL);
|
|
ASSERT(pnr->lpComment==NULL);
|
|
|
|
pnr->dwType = NET_GetType(pidn);
|
|
pnr->dwDisplayType = NET_GetDisplayType(pidn);
|
|
pnr->dwUsage = NET_GetUsage(pidn);
|
|
NET_CopyResName(pidn, pszT, (UINT)(pszEnd-pszT));
|
|
|
|
if (pnr->dwDisplayType == RESOURCEDISPLAYTYPE_ROOT)
|
|
{
|
|
pnr->lpProvider = NULL;
|
|
pnr->lpRemoteName = NULL;
|
|
}
|
|
else if (pnr->dwDisplayType == RESOURCEDISPLAYTYPE_NETWORK)
|
|
{
|
|
*((UINT *) &pnr->lpProvider) = PTROFFSET(panr, pszT);
|
|
ASSERT(pnr->lpRemoteName == NULL);
|
|
}
|
|
else
|
|
{
|
|
*((UINT *) &pnr->lpProvider) = offProvider;
|
|
*((UINT *) &pnr->lpRemoteName) = PTROFFSET(panr, pszT);
|
|
}
|
|
pszT += lstrlen(pszT) + 1;
|
|
}
|
|
|
|
ASSERT(pszEnd == pszT);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK; // handing QueryGetData, yes, we have it
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// fill in pmedium with an HGLOBAL version of a NRESARRAY
|
|
|
|
STDAPI CNetData_GetNetResourceForFS(IDataObject *pdtobj, STGMEDIUM *pmedium)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
LPITEMIDLIST pidlAbs;
|
|
STGMEDIUM medium;
|
|
LPIDA pida = DataObj_GetHIDA(pdtobj, &medium);
|
|
|
|
ASSERT(pida && medium.hGlobal); // we created this...
|
|
|
|
//
|
|
// NOTES: Even though we may have multiple FS objects in this HIDA,
|
|
// we know that they share the root. Therefore, getting the pidl for
|
|
// the first item is always sufficient.
|
|
//
|
|
|
|
pidlAbs = IDA_ILClone(pida, 0);
|
|
if (pidlAbs)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
|
|
ASSERT(AssertIsIDListInNameSpace(pidlAbs, &CLSID_NetworkPlaces));
|
|
|
|
//
|
|
// Look for the JUNCTION point (starting from the second ID)
|
|
//
|
|
for (pidl = _ILNext(pidlAbs); !ILIsEmpty(pidl); pidl = _ILNext(pidl))
|
|
{
|
|
LPIDNETRESOURCE pidn = (LPIDNETRESOURCE)pidl;
|
|
if (NET_GetFlags(pidn) & SHID_JUNCTION)
|
|
{
|
|
//
|
|
// We found the JUNCTION point (which is s share).
|
|
// Return the HNRES to it.
|
|
//
|
|
TCHAR szProvider[MAX_PATH];
|
|
TCHAR szRemote[MAX_PATH];
|
|
UINT cbRequired;
|
|
LPCTSTR pszProvider = NET_GetProviderFromIDList(pidlAbs, szProvider, ARRAYSIZE(szProvider));
|
|
LPCTSTR pszRemoteName = NET_CopyResName(pidn, szRemote, ARRAYSIZE(szRemote));
|
|
UINT cbProvider = lstrlen(pszProvider) * sizeof(TCHAR) + sizeof(TCHAR);
|
|
|
|
//
|
|
// This should not be a provider node.
|
|
// This should not be the last ID in pidlAbs.
|
|
//
|
|
ASSERT(pszProvider != pszRemoteName);
|
|
ASSERT(!ILIsEmpty(_ILNext(pidl)));
|
|
|
|
cbRequired = sizeof(NRESARRAY) + cbProvider + lstrlen(pszRemoteName) * sizeof(TCHAR) + sizeof(TCHAR);
|
|
|
|
pmedium->pUnkForRelease = NULL;
|
|
pmedium->tymed = TYMED_HGLOBAL;
|
|
pmedium->hGlobal = GlobalAlloc(GPTR, cbRequired);
|
|
if (pmedium->hGlobal)
|
|
{
|
|
LPNRESARRAY panr = (LPNRESARRAY)pmedium->hGlobal;
|
|
LPNETRESOURCE pnr = &panr->nr[0];
|
|
LPTSTR pszT = (LPTSTR)(panr + 1);
|
|
|
|
ASSERT(pnr->dwScope == 0);
|
|
ASSERT(pnr->lpLocalName == NULL);
|
|
ASSERT(pnr->lpComment == NULL);
|
|
|
|
panr->cItems = 1;
|
|
|
|
pnr->dwType = NET_GetType(pidn);
|
|
pnr->dwDisplayType = NET_GetDisplayType(pidn);
|
|
pnr->dwUsage = NET_GetUsage(pidn);
|
|
|
|
*((UINT *) &pnr->lpProvider) = sizeof(NRESARRAY);
|
|
lstrcpy(pszT, pszProvider);
|
|
ASSERT(PTROFFSET(panr, pszT) == sizeof(NRESARRAY));
|
|
pszT += cbProvider / sizeof(TCHAR);
|
|
|
|
*((UINT *) &pnr->lpRemoteName) = sizeof(NRESARRAY) + cbProvider;
|
|
ASSERT(PTROFFSET(panr, pszT) == (int)sizeof(NRESARRAY) + (int)cbProvider);
|
|
lstrcpy(pszT, pszRemoteName);
|
|
|
|
ASSERT(((LPBYTE)panr) + cbRequired == (LPBYTE)pszT + (lstrlen(pszT) + 1) * sizeof(TCHAR));
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ASSERT(!ILIsEmpty(pidl)); // We should have found the junction point.
|
|
ILFree(pidlAbs);
|
|
}
|
|
HIDA_ReleaseStgMedium(pida, &medium);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CNetData::QueryGetData(FORMATETC *pformatetc)
|
|
{
|
|
if (pformatetc->tymed & TYMED_HGLOBAL)
|
|
{
|
|
if (pformatetc->cfFormat == g_cfNetResource)
|
|
return CNetData_GetNetResource(this, NULL);
|
|
|
|
if (pformatetc->cfFormat == CF_HDROP)
|
|
return GetHDrop(NULL, NULL);
|
|
}
|
|
|
|
return CFSIDLData::QueryGetData(pformatetc);
|
|
}
|
|
|
|
STDMETHODIMP CNetData::GetData(FORMATETC *pformatetc, STGMEDIUM *pmedium)
|
|
{
|
|
if (pformatetc->tymed & TYMED_HGLOBAL)
|
|
{
|
|
if (pformatetc->cfFormat == g_cfNetResource)
|
|
return CNetData_GetNetResource(this, pmedium);
|
|
|
|
if (pformatetc->cfFormat == CF_HDROP)
|
|
return GetHDrop(pformatetc, pmedium);
|
|
}
|
|
|
|
return CFSIDLData::GetData(pformatetc, pmedium);
|
|
}
|
|
|
|
BOOL GetPathFromDataObject(IDataObject *pdtobj, DWORD dwData, LPTSTR pszFileName)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
BOOL fUnicode = FALSE;
|
|
HRESULT hr;
|
|
|
|
if (dwData & (DTID_FDESCW | DTID_FDESCA))
|
|
{
|
|
FORMATETC fmteW = {g_cfFileGroupDescriptorW, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
STGMEDIUM medium = {0};
|
|
|
|
hr = pdtobj->GetData(&fmteW, &medium);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fUnicode = TRUE;
|
|
}
|
|
else
|
|
{
|
|
FORMATETC fmteA = {g_cfFileGroupDescriptorA, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
hr = pdtobj->GetData(&fmteA, &medium);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fUnicode)
|
|
{
|
|
FILEGROUPDESCRIPTORW *pfgdW = (FILEGROUPDESCRIPTORW *)GlobalLock(medium.hGlobal);
|
|
if (pfgdW)
|
|
{
|
|
if (pfgdW->cItems == 1)
|
|
{
|
|
SHUnicodeToTChar(pfgdW->fgd[0].cFileName, pszFileName, MAX_PATH);
|
|
}
|
|
bRet = TRUE;
|
|
GlobalUnlock(medium.hGlobal);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FILEGROUPDESCRIPTORA *pfgdA = (FILEGROUPDESCRIPTORA*)GlobalLock(medium.hGlobal);
|
|
if (pfgdA)
|
|
{
|
|
if (pfgdA->cItems == 1)
|
|
{
|
|
SHAnsiToTChar(pfgdA->fgd[0].cFileName, pszFileName, MAX_PATH);
|
|
}
|
|
bRet = TRUE;
|
|
GlobalUnlock(medium.hGlobal);
|
|
}
|
|
}
|
|
ReleaseStgMedium(&medium);
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
class CNetRootDropTarget : public CIDLDropTarget
|
|
{
|
|
friend HRESULT CNetRootDropTarget_CreateInstance(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt);
|
|
public:
|
|
CNetRootDropTarget(HWND hwnd) : CIDLDropTarget(hwnd) { };
|
|
|
|
// IDropTarget methods overwirte
|
|
STDMETHODIMP DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
|
|
STDMETHODIMP Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
|
|
|
|
private:
|
|
~CNetRootDropTarget();
|
|
IDropTarget *_pdtgHood; // file system drop target
|
|
};
|
|
|
|
CNetRootDropTarget::~CNetRootDropTarget()
|
|
{
|
|
if (_pdtgHood)
|
|
_pdtgHood->Release();
|
|
}
|
|
|
|
STDMETHODIMP CNetRootDropTarget::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
CIDLDropTarget::DragEnter(pdtobj, grfKeyState, pt, pdwEffect);
|
|
|
|
if ((m_dwData & (DTID_NETRES | DTID_HIDA)) == (DTID_NETRES | DTID_HIDA))
|
|
{
|
|
// NETRESOURCE (DTID_NETRES) allow link
|
|
*pdwEffect &= DROPEFFECT_LINK;
|
|
}
|
|
else if (((m_dwData & (DTID_FDESCW | DTID_CONTENTS)) == (DTID_FDESCW | DTID_CONTENTS)) ||
|
|
((m_dwData & (DTID_FDESCA | DTID_CONTENTS)) == (DTID_FDESCA | DTID_CONTENTS)) )
|
|
{
|
|
// dragging an URL from the web browser gives a FILECONTENTS version
|
|
// of a .URL file. accept that here for Internet Shortcut (.url)
|
|
TCHAR szFileName[MAX_PATH];
|
|
if (GetPathFromDataObject(pdtobj, m_dwData, szFileName) &&
|
|
(0 == lstrcmpi(PathFindExtension(szFileName), TEXT(".url"))))
|
|
{
|
|
*pdwEffect &= DROPEFFECT_LINK;
|
|
}
|
|
else
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
}
|
|
|
|
m_dwEffectLastReturned = *pdwEffect;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CNetRootDropTarget::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
*pdwEffect &= DROPEFFECT_LINK;
|
|
|
|
HRESULT hr = CIDLDropTarget::DragDropMenu(DROPEFFECT_LINK, pdtobj,
|
|
pt, pdwEffect, NULL, NULL, POPUP_NONDEFAULTDD, grfKeyState);
|
|
if (*pdwEffect)
|
|
{
|
|
if (!_pdtgHood)
|
|
{
|
|
LPITEMIDLIST pidl = SHCloneSpecialIDList(NULL, CSIDL_NETHOOD, FALSE);
|
|
if (pidl)
|
|
{
|
|
IShellFolder *psf;
|
|
if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidl, &psf))))
|
|
{
|
|
psf->CreateViewObject(_GetWindow(), IID_PPV_ARG(IDropTarget, &_pdtgHood));
|
|
psf->Release();
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
|
|
if (_pdtgHood)
|
|
{
|
|
// force link through the dwEffect and keyboard
|
|
*pdwEffect &= DROPEFFECT_LINK;
|
|
grfKeyState = MK_LBUTTON | MK_CONTROL | MK_SHIFT | MK_FAKEDROP;
|
|
hr = SHSimulateDrop(_pdtgHood, pdtobj, grfKeyState, NULL, pdwEffect);
|
|
}
|
|
else
|
|
*pdwEffect = 0;
|
|
}
|
|
|
|
CIDLDropTarget::DragLeave();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CNetRootDropTarget_CreateInstance(HWND hwnd, LPCITEMIDLIST pidl, IDropTarget **ppdropt)
|
|
{
|
|
*ppdropt = NULL;
|
|
|
|
HRESULT hr;
|
|
CNetRootDropTarget *pnrdt = new CNetRootDropTarget(hwnd);
|
|
if (pnrdt)
|
|
{
|
|
hr = pnrdt->_Init(pidl);
|
|
if (SUCCEEDED(hr))
|
|
pnrdt->QueryInterface(IID_PPV_ARG(IDropTarget, ppdropt));
|
|
pnrdt->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
return hr;
|
|
}
|
|
|
|
// This part is psuedo bogus. Basically we have problems at times doing a
|
|
// translation from things like \\pyrex\user to the appropriate PIDL,
|
|
// especially if you want to avoid the overhead of hitting the network and
|
|
// also problems of knowing if the server is in the "HOOD"
|
|
//
|
|
// We must maintain the mapping table in UNICODE internally, because
|
|
// IShellFolder::ParseDisplayName uses UNICODE, and we don't want to have
|
|
// to deal with lstrlen(dbcs) != lstrlen(sbcs) problems.
|
|
//
|
|
|
|
typedef struct _NPT_ITEM
|
|
{
|
|
struct _NPT_ITEM *pnptNext; // Pointer to next item;
|
|
LPCITEMIDLIST pidl; // The pidl
|
|
USHORT cchName; // size of the name in characters.
|
|
WCHAR szName[1]; // The name to translate from
|
|
} NPT_ITEM;
|
|
|
|
// Each process will maintain their own list.
|
|
NPT_ITEM *g_pnptHead = NULL;
|
|
|
|
//
|
|
// Function to register translations from Path to IDList translations.
|
|
//
|
|
void NPTRegisterNameToPidlTranslation(LPCTSTR pszPath, LPCITEMIDLIST pidl)
|
|
{
|
|
NPT_ITEM *pnpt;
|
|
int cItemsRemoved = 0;
|
|
WCHAR szPath[MAX_PATH];
|
|
|
|
// We currently are only interested in UNC Roots
|
|
// If the table becomes large we can reduce this to only servers...
|
|
|
|
if (!PathIsUNC(pszPath))
|
|
return; // Not interested.
|
|
|
|
//
|
|
// If this item is not a root we need to count how many items to remove
|
|
//
|
|
SHTCharToUnicode(pszPath, szPath, ARRAYSIZE(szPath));
|
|
while (!PathIsUNCServerShare(szPath))
|
|
{
|
|
cItemsRemoved++;
|
|
if (!PathRemoveFileSpecW(szPath))
|
|
return; // Did not get back to a valid root
|
|
}
|
|
|
|
ENTERCRITICAL;
|
|
|
|
// We don't want to add duplicates
|
|
for (pnpt = g_pnptHead; pnpt != NULL ; pnpt = pnpt->pnptNext)
|
|
{
|
|
if (StrCmpIW(szPath, pnpt->szName) == 0)
|
|
break;
|
|
}
|
|
|
|
if (pnpt == NULL)
|
|
{
|
|
UINT cch = lstrlenW(szPath);
|
|
pnpt = (NPT_ITEM *)LocalAlloc(LPTR, sizeof(NPT_ITEM) + cch * sizeof(WCHAR));
|
|
if (pnpt)
|
|
{
|
|
pnpt->pidl = ILClone(pidl);
|
|
if (pnpt->pidl)
|
|
{
|
|
while (cItemsRemoved--)
|
|
{
|
|
ILRemoveLastID((LPITEMIDLIST)pnpt->pidl);
|
|
}
|
|
pnpt->pnptNext = g_pnptHead;
|
|
g_pnptHead = pnpt;
|
|
pnpt->cchName = (USHORT) cch;
|
|
lstrcpyW(pnpt->szName, szPath);
|
|
}
|
|
else
|
|
{
|
|
LocalFree((HLOCAL)pnpt);
|
|
}
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
}
|
|
|
|
// The main function to attemp to map a portion of the name into an idlist
|
|
// Right now limit it to UNC roots
|
|
//
|
|
LPWSTR NPTMapNameToPidl(LPCWSTR pszPath, LPCITEMIDLIST *ppidl)
|
|
{
|
|
NPT_ITEM *pnpt;
|
|
|
|
*ppidl = NULL;
|
|
|
|
ENTERCRITICAL;
|
|
|
|
// See if we can find the item in the list.
|
|
for (pnpt = g_pnptHead; pnpt != NULL ; pnpt = pnpt->pnptNext)
|
|
{
|
|
if (IntlStrEqNIW(pszPath, pnpt->szName, pnpt->cchName) &&
|
|
((pszPath[pnpt->cchName] == TEXT('\\')) || (pszPath[pnpt->cchName] == TEXT('\0'))))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
// See if we found a match
|
|
if (pnpt == NULL)
|
|
return NULL;
|
|
|
|
// Found a match
|
|
*ppidl = pnpt->pidl;
|
|
return (LPWSTR)pszPath + pnpt->cchName; // points to slash
|
|
}
|