396 lines
11 KiB
C++
396 lines
11 KiB
C++
#include "shellprv.h"
|
|
#include "netview.h"
|
|
#include "mtpt.h"
|
|
#include "ids.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
// from mtptarun.cpp
|
|
STDAPI_(void) CMtPt_SetWantUI(int iDrive);
|
|
|
|
//
|
|
// Converts an offset to a string to a string pointer.
|
|
//
|
|
|
|
LPCTSTR _Offset2Ptr(LPTSTR pszBase, UINT_PTR offset, UINT * pcb)
|
|
{
|
|
LPTSTR pszRet;
|
|
if (offset == 0)
|
|
{
|
|
pszRet = NULL;
|
|
*pcb = 0;
|
|
}
|
|
else
|
|
{
|
|
pszRet = (LPTSTR)((LPBYTE)pszBase + offset);
|
|
*pcb = (lstrlen(pszRet) + 1) * sizeof(TCHAR);
|
|
}
|
|
return pszRet;
|
|
}
|
|
|
|
|
|
//
|
|
// exported networking APIs from shell32
|
|
//
|
|
|
|
STDAPI_(UINT) SHGetNetResource(HNRES hnres, UINT iItem, LPNETRESOURCE pnresOut, UINT cbMax)
|
|
{
|
|
UINT iRet = 0; // assume error
|
|
LPNRESARRAY panr = (LPNRESARRAY)GlobalLock(hnres);
|
|
if (panr)
|
|
{
|
|
if (iItem==(UINT)-1)
|
|
{
|
|
iRet = panr->cItems;
|
|
}
|
|
else if (iItem < panr->cItems)
|
|
{
|
|
UINT cbProvider, cbRemoteName;
|
|
LPCTSTR pszProvider = _Offset2Ptr((LPTSTR)panr, (UINT_PTR)panr->nr[iItem].lpProvider, &cbProvider);
|
|
LPCTSTR pszRemoteName = _Offset2Ptr((LPTSTR)panr, (UINT_PTR)panr->nr[iItem].lpRemoteName, &cbRemoteName);
|
|
iRet = sizeof(NETRESOURCE) + cbProvider + cbRemoteName;
|
|
if (iRet <= cbMax)
|
|
{
|
|
DWORD cch;
|
|
LPTSTR psz = (LPTSTR)(pnresOut + 1);
|
|
*pnresOut = panr->nr[iItem];
|
|
if (pnresOut->lpProvider)
|
|
{
|
|
cch = cbProvider / sizeof(TCHAR); // Includes NULL terminator
|
|
|
|
pnresOut->lpProvider = psz;
|
|
StrCpyN(psz, pszProvider, cch);
|
|
psz += cch;
|
|
}
|
|
if (pnresOut->lpRemoteName)
|
|
{
|
|
cch = cbRemoteName / sizeof(TCHAR); // Includes NULL terminator
|
|
pnresOut->lpRemoteName = psz;
|
|
StrCpyN(psz, pszRemoteName, cch);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iRet = 0; // FAIL if not enough space in the buffer!
|
|
}
|
|
}
|
|
GlobalUnlock(hnres);
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
|
|
STDAPI_(DWORD) SHNetConnectionDialog(HWND hwnd, LPTSTR pszRemoteName, DWORD dwType)
|
|
{
|
|
CONNECTDLGSTRUCT cds = {0};
|
|
NETRESOURCE nr = {0};
|
|
|
|
cds.cbStructure = sizeof(cds); /* size of this structure in bytes */
|
|
cds.hwndOwner = hwnd; /* owner window for the dialog */
|
|
cds.lpConnRes = &nr; /* Requested Resource info */
|
|
cds.dwFlags = CONNDLG_USE_MRU; /* flags (see below) */
|
|
|
|
nr.dwType = dwType;
|
|
|
|
if (pszRemoteName)
|
|
{
|
|
nr.lpRemoteName = pszRemoteName;
|
|
cds.dwFlags = CONNDLG_RO_PATH;
|
|
}
|
|
DWORD mnr = WNetConnectionDialog1(&cds);
|
|
if (mnr == WN_SUCCESS && dwType != RESOURCETYPE_PRINT && cds.dwDevNum != 0)
|
|
{
|
|
TCHAR szPath[4];
|
|
|
|
CMountPoint::WantAutorunUI(PathBuildRoot(szPath, cds.dwDevNum - 1 /* 1-based! */));
|
|
}
|
|
return mnr;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
HWND hwnd;
|
|
TCHAR szRemoteName[MAX_PATH];
|
|
DWORD dwType;
|
|
} SHNETCONNECT;
|
|
|
|
DWORD CALLBACK _NetConnectThreadProc(void *pv)
|
|
{
|
|
SHNETCONNECT *pshnc = (SHNETCONNECT *)pv;
|
|
HWND hwndDestroy = NULL;
|
|
|
|
if (!pshnc->hwnd)
|
|
{
|
|
RECT rc;
|
|
LPPOINT ppt;
|
|
DWORD pid;
|
|
|
|
// Wild multimon guess - Since we don't have a parent window,
|
|
// we will arbitrarily position ourselves in the same location as
|
|
// the foreground window, if the foreground window belongs to our
|
|
// process.
|
|
HWND hwnd = GetForegroundWindow();
|
|
|
|
if (hwnd &&
|
|
GetWindowThreadProcessId(hwnd, &pid) &&
|
|
(pid == GetCurrentProcessId()) &&
|
|
GetWindowRect(hwnd, &rc))
|
|
{
|
|
// Don't use the upper left corner exactly; slide down by
|
|
// some fudge factor. We definitely want to get past the
|
|
// caption.
|
|
rc.top += GetSystemMetrics(SM_CYCAPTION) * 4;
|
|
rc.left += GetSystemMetrics(SM_CXVSCROLL) * 4;
|
|
ppt = (LPPOINT)&rc;
|
|
}
|
|
else
|
|
{
|
|
ppt = NULL;
|
|
}
|
|
|
|
// Create a stub window so the wizard can establish an Alt+Tab icon
|
|
hwndDestroy = _CreateStubWindow(ppt, NULL);
|
|
pshnc->hwnd = hwndDestroy;
|
|
}
|
|
|
|
SHNetConnectionDialog(pshnc->hwnd, pshnc->szRemoteName[0] ? pshnc->szRemoteName : NULL, pshnc->dwType);
|
|
|
|
if (hwndDestroy)
|
|
DestroyWindow(hwndDestroy);
|
|
|
|
LocalFree(pshnc);
|
|
|
|
SHChangeNotifyHandleEvents();
|
|
return 0;
|
|
}
|
|
|
|
|
|
STDAPI SHStartNetConnectionDialog(HWND hwnd, LPCTSTR pszRemoteName OPTIONAL, DWORD dwType)
|
|
{
|
|
SHNETCONNECT *pshnc = (SHNETCONNECT *)LocalAlloc(LPTR, sizeof(SHNETCONNECT));
|
|
if (pshnc)
|
|
{
|
|
pshnc->hwnd = hwnd;
|
|
pshnc->dwType = dwType;
|
|
if (pszRemoteName)
|
|
StrCpyN(pshnc->szRemoteName, pszRemoteName, ARRAYSIZE(pshnc->szRemoteName));
|
|
|
|
if (!SHCreateThread(_NetConnectThreadProc, pshnc, CTF_PROCESS_REF | CTF_COINIT, NULL))
|
|
{
|
|
LocalFree((HLOCAL)pshnc);
|
|
}
|
|
}
|
|
return S_OK; // whole thing is async, value here is meaningless
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
|
|
STDAPI SHStartNetConnectionDialogA(HWND hwnd, LPCSTR pszRemoteName, DWORD dwType)
|
|
{
|
|
WCHAR wsz[MAX_PATH];
|
|
|
|
if (pszRemoteName)
|
|
{
|
|
SHAnsiToUnicode(pszRemoteName, wsz, SIZECHARS(wsz));
|
|
pszRemoteName = (LPCSTR)wsz;
|
|
}
|
|
return SHStartNetConnectionDialog(hwnd, (LPCTSTR)pszRemoteName, dwType);
|
|
}
|
|
|
|
#else
|
|
|
|
STDAPI SHStartNetConnectionDialogW(HWND hwnd, LPCWSTR pszRemoteName, DWORD dwType)
|
|
{
|
|
char sz[MAX_PATH];
|
|
|
|
if (pszRemoteName)
|
|
{
|
|
SHUnicodeToAnsi(pszRemoteName, sz, SIZECHARS(sz));
|
|
pszRemoteName = (LPCWSTR)sz;
|
|
}
|
|
|
|
return SHStartNetConnectionDialog(hwnd, (LPCTSTR)pszRemoteName, dwType);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// These are wrappers around the same WNet APIs, but play with the parameters
|
|
// to make it easier to call. They accept full paths rather than just drive letters.
|
|
//
|
|
DWORD APIENTRY SHWNetDisconnectDialog1 (LPDISCDLGSTRUCT lpConnDlgStruct)
|
|
{
|
|
TCHAR szLocalName[3];
|
|
|
|
if (lpConnDlgStruct && lpConnDlgStruct->lpLocalName && lstrlen(lpConnDlgStruct->lpLocalName) > 2)
|
|
{
|
|
// Kludge allert, don't pass c:\ to API, instead only pass C:
|
|
szLocalName[0] = lpConnDlgStruct->lpLocalName[0];
|
|
szLocalName[1] = TEXT(':');
|
|
szLocalName[2] = 0;
|
|
lpConnDlgStruct->lpLocalName = szLocalName;
|
|
}
|
|
|
|
return WNetDisconnectDialog1 (lpConnDlgStruct);
|
|
}
|
|
|
|
|
|
DWORD APIENTRY SHWNetGetConnection (LPCTSTR lpLocalName, LPTSTR lpRemoteName, LPDWORD lpnLength)
|
|
{
|
|
TCHAR szLocalName[3];
|
|
|
|
if (lpLocalName && lstrlen(lpLocalName) > 2)
|
|
{
|
|
// Kludge allert, don't pass c:\ to API, instead only pass C:
|
|
szLocalName[0] = lpLocalName[0];
|
|
szLocalName[1] = TEXT(':');
|
|
szLocalName[2] = 0;
|
|
lpLocalName = szLocalName;
|
|
}
|
|
|
|
return WNetGetConnection (lpLocalName, lpRemoteName, lpnLength);
|
|
}
|
|
|
|
|
|
// exported for netfind.cpp to use
|
|
|
|
STDAPI SHGetDomainWorkgroupIDList(LPITEMIDLIST *ppidl)
|
|
{
|
|
*ppidl = NULL;
|
|
|
|
IShellFolder *psfDesktop;
|
|
HRESULT hr = SHGetDesktopFolder(&psfDesktop);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
|
|
StrCpyN(szName, TEXT("\\\\"), ARRAYSIZE(szName));
|
|
|
|
if (RegGetValueString(HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\CurrentControlSet\\Control\\ComputerName\\ComputerName"),
|
|
TEXT("ComputerName"), szName + 2, sizeof(szName) - 2 * sizeof(TCHAR)))
|
|
{
|
|
WCHAR wszName[MAX_PATH];
|
|
|
|
SHTCharToUnicode(szName, wszName, ARRAYSIZE(wszName));
|
|
|
|
hr = psfDesktop->ParseDisplayName(NULL, NULL, wszName, NULL, ppidl, NULL);
|
|
if (SUCCEEDED(hr))
|
|
ILRemoveLastID(*ppidl);
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
|
|
psfDesktop->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// SHGetComputerDisplayName - formats and returns the computer name for display.
|
|
|
|
#define REGSTR_PATH_COMPUTERDESCCACHE REGSTR_PATH_EXPLORER TEXT("\\ComputerDescriptions")
|
|
|
|
STDAPI_(void) SHCacheComputerDescription(LPCTSTR pszMachineName, LPCTSTR pszDescription)
|
|
{
|
|
if (pszDescription)
|
|
{
|
|
DWORD cb = (lstrlen(pszDescription) + 1) * sizeof(*pszDescription);
|
|
SHSetValue(HKEY_CURRENT_USER, REGSTR_PATH_COMPUTERDESCCACHE, SkipServerSlashes(pszMachineName), REG_SZ, pszDescription, cb);
|
|
}
|
|
}
|
|
|
|
STDAPI _GetComputerDescription(LPCTSTR pszMachineName, LPTSTR pszDescription, DWORD cchDescription)
|
|
{
|
|
SERVER_INFO_101 *psv101 = NULL;
|
|
HRESULT hr = ResultFromWin32(NetServerGetInfo((LPWSTR)pszMachineName, 101, (BYTE**)&psv101));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (psv101->sv101_comment && psv101->sv101_comment[0])
|
|
{
|
|
StrCpyN(pszDescription, psv101->sv101_comment, cchDescription);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
NetApiBufferFree(psv101);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _GetCachedComputerDescription(LPCTSTR pszMachineName, LPTSTR pszDescription, int cchDescription)
|
|
{
|
|
ULONG cb = cchDescription*sizeof(*pszDescription);
|
|
return ResultFromWin32(SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_COMPUTERDESCCACHE, SkipServerSlashes(pszMachineName), NULL, pszDescription, &cb));
|
|
}
|
|
|
|
STDAPI SHGetComputerDisplayNameW(LPCWSTR pszMachineName, DWORD dwFlags, LPWSTR pszDisplay, DWORD cchDisplay)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// map the NULL machine name to the local computer name - so we can cache correctly.
|
|
|
|
WCHAR szMachineName[CNLEN + 1];
|
|
if (!pszMachineName)
|
|
{
|
|
DWORD cchMachine = ARRAYSIZE(szMachineName);
|
|
if (GetComputerName(szMachineName, &cchMachine))
|
|
{
|
|
pszMachineName = szMachineName;
|
|
dwFlags |= SGCDNF_NOCACHEDENTRY;
|
|
}
|
|
}
|
|
|
|
// we must have a machine name, so we can perform the look up.
|
|
|
|
if (pszMachineName)
|
|
{
|
|
WCHAR szDescription[256];
|
|
|
|
// can we read the name from teh cache, if not/or the user says they don't want
|
|
// the cached name then lets hit the wire and read it.
|
|
|
|
if (!(dwFlags & SGCDNF_NOCACHEDENTRY))
|
|
hr = _GetCachedComputerDescription(pszMachineName, szDescription, ARRAYSIZE(szDescription));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
hr = _GetComputerDescription(pszMachineName, szDescription, ARRAYSIZE(szDescription));
|
|
if (FAILED(hr))
|
|
{
|
|
*szDescription = _TEXT('\0');
|
|
}
|
|
if (!(dwFlags & SGCDNF_NOCACHEDENTRY))
|
|
{
|
|
SHCacheComputerDescription(pszMachineName, szDescription); // write through to cache
|
|
}
|
|
}
|
|
|
|
// we have a name, so lets format it, if they request description only / or we failed
|
|
// above lets just return raw string. otherwise we build a new machine name based
|
|
// on the remote name and the description we fetched.
|
|
|
|
if (SUCCEEDED(hr) && *szDescription)
|
|
{
|
|
if (dwFlags & SGCDNF_DESCRIPTIONONLY)
|
|
{
|
|
StrCpyN(pszDisplay, szDescription, cchDisplay);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = SHBuildDisplayMachineName(pszMachineName, szDescription, pszDisplay, cchDisplay);
|
|
}
|
|
}
|
|
else if (!(dwFlags & SGCDNF_DESCRIPTIONONLY))
|
|
{
|
|
StrCpyN(pszDisplay, SkipServerSlashes(pszMachineName), cchDisplay);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|