mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1956 lines
50 KiB
1956 lines
50 KiB
/*
|
|
* cnrlink.c - CNRLink ADT module.
|
|
*/
|
|
|
|
|
|
/* Headers
|
|
**********/
|
|
|
|
#include "project.h"
|
|
#pragma hdrstop
|
|
|
|
#include "cnrlink.h"
|
|
#include "server.h"
|
|
|
|
|
|
/* Constants
|
|
************/
|
|
|
|
/* WNetUseConnection() flag combinations */
|
|
|
|
#define ALL_CONNECT_IN_FLAGS (CONNECT_UPDATE_PROFILE |\
|
|
CONNECT_UPDATE_RECENT |\
|
|
CONNECT_TEMPORARY |\
|
|
CONNECT_INTERACTIVE |\
|
|
CONNECT_PROMPT |\
|
|
CONNECT_REDIRECT)
|
|
|
|
#define ALL_CONNECT_OUT_FLAGS (CONNECT_REFCOUNT |\
|
|
CONNECT_LOCALDRIVE)
|
|
|
|
|
|
/* Macros
|
|
*********/
|
|
|
|
/* macros for accessing ICNRLINK data */
|
|
|
|
#define ICNRL_Remote_Name_PtrA(picnrl) \
|
|
((LPSTR)(((PBYTE)(picnrl)) + (picnrl)->ucbNetNameOffset))
|
|
|
|
#define ICNRL_Device_PtrA(picnrl) \
|
|
((LPSTR)(((PBYTE)(picnrl)) + (picnrl)->ucbDeviceOffset))
|
|
|
|
#define ICNRL_Remote_Name_PtrW(picnrl) \
|
|
((LPWSTR)(((PBYTE)(picnrl)) + (picnrl)->ucbNetNameOffsetW))
|
|
|
|
#define ICNRL_Device_PtrW(picnrl) \
|
|
((LPWSTR)(((PBYTE)(picnrl)) + (picnrl)->ucbDeviceOffsetW))
|
|
|
|
#define IS_ICNRL_ANSI(picnrl) \
|
|
((PBYTE)(picnrl) + ((PICNRLINKW)(picnrl))->ucbNetNameOffset) == (PBYTE)&(((PICNRLINKW)(picnrl))->ucbNetNameOffsetW)
|
|
|
|
#ifdef UNICODE
|
|
#define ICNRL_Remote_Name_Ptr(picnrl) ICNRL_Remote_Name_PtrW(picnrl)
|
|
#define ICNRL_Device_Ptr(picnrl) ICNRL_Device_PtrW(picnrl)
|
|
#else
|
|
#define ICNRL_Remote_Name_Ptr(picnrl) ICNRL_Remote_Name_PtrA(picnrl)
|
|
#define ICNRL_Device_Ptr(picnrl) ICNRL_Device_PtrA(picnrl)
|
|
#endif
|
|
|
|
/* Types
|
|
********/
|
|
|
|
/*
|
|
@doc INTERNAL
|
|
|
|
@enum ICNRLINKFLAGS | Internal CNRLink structure flags.
|
|
*/
|
|
|
|
typedef enum _icnrlinkflags
|
|
{
|
|
/*
|
|
@emem ICNRL_FL_VALID_DEVICE | If set, last redirected drive is valid. If
|
|
clear, last redirected drive is not valid.
|
|
*/
|
|
|
|
ICNRL_FL_VALID_DEVICE = 0x0001,
|
|
|
|
/*
|
|
@emem ICNRL_FL_VALID_NET_TYPE | If set, net type is valid. If clear, net
|
|
type is not valid.
|
|
*/
|
|
|
|
ICNRL_FL_VALID_NET_TYPE = 0x0002,
|
|
|
|
/* @emem ALL_ICNRL_FLAGS | All internal CNRLink structure flags. */
|
|
|
|
ALL_ICNRL_FLAGS = (ICNRL_FL_VALID_DEVICE |
|
|
ICNRL_FL_VALID_NET_TYPE)
|
|
}
|
|
ICNRLINKFLAGS;
|
|
|
|
/*
|
|
@doc INTERNAL
|
|
|
|
@struct ICNRLINK | Internal definition of relocatable connectable network
|
|
resource (CNR) link structure. An <t ILINKINFO> structure may contain an
|
|
ICNRLINK structure. An ICNRLINK structure consists of a header described as
|
|
below, followed by variable-length data.
|
|
*/
|
|
|
|
typedef struct _icnrlinkA
|
|
{
|
|
/*
|
|
@field UINT | ucbSize | Length of ICNRLINK structure in bytes, including
|
|
ucbSize field.
|
|
*/
|
|
|
|
UINT ucbSize;
|
|
|
|
/*
|
|
@field DWORD | dwFlags | A bit mask of flags from the <t ICNRLINKFLAGS>
|
|
enumeration.
|
|
*/
|
|
|
|
DWORD dwFlags;
|
|
|
|
/*
|
|
@field UINT | ucbNetNameOffset | Offset in bytes of CNR name string from
|
|
base of structure. The CNR name string may be passed to
|
|
WNetUseConnection() to add a connection to the CNR.<nl>
|
|
Example CNRLink name string: "\\\\fredbird\\work".
|
|
*/
|
|
|
|
UINT ucbNetNameOffset;
|
|
|
|
/*
|
|
@field UINT | ucbDeviceOffset | Offset in bytes of last redirected local
|
|
device string from base of structure. This field is only valid if
|
|
ICNRL_FL_VALID_DEVICE is set in dwFlags. The last redirected local
|
|
device string may be passed to WNetUseConnection() to add a redirected
|
|
device connection to the CNR.<nl>
|
|
Example last redirected local device string: "D:".
|
|
*/
|
|
|
|
UINT ucbDeviceOffset;
|
|
|
|
/*
|
|
@field DWORD | dwNetType | The network type as returned in a
|
|
NETINFOSTRUCT. This field is only valid if ICNRL_FL_VALID_NET_TYPE is
|
|
set in dwFlags. The net type is used to retrieve the host net resource's
|
|
host NP's name to use in calling WNetUseConnection().<nl>
|
|
Example net type: WNNC_NET_NETWARE.
|
|
*/
|
|
|
|
DWORD dwNetType;
|
|
}
|
|
ICNRLINKA;
|
|
DECLARE_STANDARD_TYPES(ICNRLINKA);
|
|
|
|
#ifdef UNICODE
|
|
typedef struct _icnrlinkW
|
|
{
|
|
/*
|
|
@field UINT | ucbSize | Length of ICNRLINK structure in bytes, including
|
|
ucbSize field.
|
|
*/
|
|
|
|
UINT ucbSize;
|
|
|
|
/*
|
|
@field DWORD | dwFlags | A bit mask of flags from the <t ICNRLINKFLAGS>
|
|
enumeration.
|
|
*/
|
|
|
|
DWORD dwFlags;
|
|
|
|
/*
|
|
@field UINT | ucbNetNameOffset | Offset in bytes of CNR name string from
|
|
base of structure. The CNR name string may be passed to
|
|
WNetUseConnection() to add a connection to the CNR.<nl>
|
|
Example CNRLink name string: "\\\\fredbird\\work".
|
|
*/
|
|
|
|
UINT ucbNetNameOffset;
|
|
|
|
/*
|
|
@field UINT | ucbDeviceOffset | Offset in bytes of last redirected local
|
|
device string from base of structure. This field is only valid if
|
|
ICNRL_FL_VALID_DEVICE is set in dwFlags. The last redirected local
|
|
device string may be passed to WNetUseConnection() to add a redirected
|
|
device connection to the CNR.<nl>
|
|
Example last redirected local device string: "D:".
|
|
*/
|
|
|
|
UINT ucbDeviceOffset;
|
|
|
|
/*
|
|
@field DWORD | dwNetType | The network type as returned in a
|
|
NETINFOSTRUCT. This field is only valid if ICNRL_FL_VALID_NET_TYPE is
|
|
set in dwFlags. The net type is used to retrieve the host net resource's
|
|
host NP's name to use in calling WNetUseConnection().<nl>
|
|
Example net type: WNNC_NET_NETWARE.
|
|
*/
|
|
|
|
DWORD dwNetType;
|
|
|
|
/*
|
|
These members are for storing the unicode version of the strings
|
|
*/
|
|
UINT ucbNetNameOffsetW;
|
|
UINT ucbDeviceOffsetW;
|
|
}
|
|
ICNRLINKW;
|
|
DECLARE_STANDARD_TYPES(ICNRLINKW);
|
|
#endif
|
|
|
|
#ifdef UNICODE
|
|
#define ICNRLINK ICNRLINKW
|
|
#define PICNRLINK PICNRLINKW
|
|
#define CICNRLINK CICNRLINKW
|
|
#define PCICNRLINK PCICNRLINKW
|
|
#else
|
|
#define ICNRLINK ICNRLINKA
|
|
#define PICNRLINK PICNRLINKA
|
|
#define CICNRLINK CICNRLINKA
|
|
#define PCICNRLINK PCICNRLINKA
|
|
#endif
|
|
|
|
/* Exported from MPR.DLL, but not in winnetwk.h
|
|
*/
|
|
#ifdef UNICODE
|
|
DWORD APIENTRY WNetGetResourceInformationW (LPNETRESOURCE lpNetResource, LPVOID lpBuffer, LPDWORD cbBuffer, LPTSTR * lplpSystem);
|
|
#define WNetGetResourceInformation WNetGetResourceInformationW
|
|
#else
|
|
DWORD APIENTRY WNetGetResourceInformationA (LPNETRESOURCE lpNetResource, LPVOID lpBuffer, LPDWORD cbBuffer, LPTSTR * lplpSystem);
|
|
#define WNetGetResourceInformation WNetGetResourceInformationA
|
|
#endif
|
|
|
|
|
|
/***************************** Private Functions *****************************/
|
|
|
|
/* Module Prototypes
|
|
********************/
|
|
|
|
PRIVATE_CODE BOOL GetNetPathFromLocalPath(LPCTSTR, LPTSTR, LPCTSTR *, PBOOL, PDWORD);
|
|
PRIVATE_CODE BOOL UnifyICNRLinkInfo(LPCTSTR, DWORD, LPCTSTR, DWORD, PICNRLINK *, PUINT);
|
|
PRIVATE_CODE BOOL GetNetType(LPCTSTR, PDWORD);
|
|
PRIVATE_CODE BOOL GetNetProviderName(PCICNRLINK, LPTSTR);
|
|
PRIVATE_CODE COMPARISONRESULT CompareNetNames(LPCTSTR, LPCTSTR);
|
|
PRIVATE_CODE BOOL SearchForRedirectedConnection(PCICNRLINK, LPTSTR);
|
|
|
|
#if defined(DEBUG) || defined (VSTF)
|
|
|
|
PRIVATE_CODE BOOL IsValidDevice(LPCTSTR);
|
|
PRIVATE_CODE BOOL IsValidNetType(DWORD);
|
|
PRIVATE_CODE BOOL IsValidPCICNRLINK(PCICNRLINK);
|
|
|
|
#endif
|
|
|
|
#if defined(DEBUG)
|
|
|
|
PRIVATE_CODE BOOL IsValidNetProviderName(LPCTSTR);
|
|
|
|
#endif
|
|
|
|
#if 0
|
|
|
|
DWORD APIENTRY
|
|
WNetGetNetworkInformationW(
|
|
LPCWSTR lpProvider,
|
|
LPNETINFOSTRUCT lpNetInfoStruct
|
|
)
|
|
{
|
|
if (wcsicmp(lpProvider, L"Microsoft Windows Network") == 0)
|
|
{
|
|
lpNetInfoStruct->wNetType = (WORD)WNNC_NET_LANMAN;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
else if (wcsicmp(lpProvider, L"Novell Network") == 0)
|
|
{
|
|
lpNetInfoStruct->wNetType = (WORD)WNNC_NET_NETWARE;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
return ERROR_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** GetNetPathFromLocalPath()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL GetNetPathFromLocalPath(LPCTSTR pcszLocalPath,
|
|
LPTSTR pszNetNameBuf,
|
|
LPCTSTR *ppcszCommonPathSuffix,
|
|
PBOOL pbIsShared, PDWORD pdwNetType)
|
|
{
|
|
BOOL bResult = TRUE;
|
|
PCSERVERVTABLE pcsvt;
|
|
|
|
ASSERT(IsDrivePath(pcszLocalPath));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszNetNameBuf, STR, MAX_PATH_LEN));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppcszCommonPathSuffix, LPCTSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pbIsShared, BOOL));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwNetType, DWORD));
|
|
|
|
*pbIsShared = FALSE;
|
|
|
|
if (GetServerVTable(&pcsvt))
|
|
{
|
|
TCHAR rgchSharedPath[MAX_PATH_LEN];
|
|
|
|
ASSERT(lstrlen(pcszLocalPath) < ARRAYSIZE(rgchSharedPath));
|
|
lstrcpy(rgchSharedPath, pcszLocalPath);
|
|
|
|
FOREVER
|
|
{
|
|
if ((pcsvt->GetNetResourceFromLocalPath)(rgchSharedPath,
|
|
pszNetNameBuf, MAX_PATH_LEN,
|
|
pdwNetType))
|
|
{
|
|
ASSERT(lstrlen(pszNetNameBuf) < MAX_PATH_LEN);
|
|
|
|
/* Determine common path suffix. */
|
|
|
|
*ppcszCommonPathSuffix = pcszLocalPath + lstrlen(rgchSharedPath);
|
|
|
|
/* Skip any leading slash. */
|
|
|
|
if (IS_SLASH(**ppcszCommonPathSuffix))
|
|
*ppcszCommonPathSuffix = CharNext(*ppcszCommonPathSuffix);
|
|
|
|
ASSERT(! IS_SLASH(**ppcszCommonPathSuffix));
|
|
|
|
// if it is terminated with a $ it is a hidden share, in that
|
|
// case don't consider this shared
|
|
*pbIsShared = pszNetNameBuf[lstrlen(pszNetNameBuf) -1] != TEXT('$');
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (! DeleteLastDrivePathElement(rgchSharedPath))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
! *pbIsShared ||
|
|
(EVAL(IsUNCPath(pszNetNameBuf)) &&
|
|
IS_VALID_STRING_PTR(*ppcszCommonPathSuffix, CSTR) &&
|
|
EVAL(*ppcszCommonPathSuffix >= pcszLocalPath) &&
|
|
EVAL(IsStringContained(pcszLocalPath, *ppcszCommonPathSuffix)) &&
|
|
EVAL(IsValidNetType(*pdwNetType))));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** UnifyICNRLinkInfo()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL UnifyICNRLinkInfo(LPCTSTR pcszNetName, DWORD dwFlags,
|
|
LPCTSTR pcszDevice, DWORD dwNetType,
|
|
PICNRLINK *ppicnrl, PUINT pucbICNRLinkLen)
|
|
{
|
|
BOOL bResult;
|
|
UINT ucbDataOffset;
|
|
#ifdef UNICODE
|
|
BOOL bUnicode;
|
|
UINT cchChars;
|
|
CHAR szAnsiNetName[MAX_PATH];
|
|
CHAR szAnsiDevice[MAX_PATH];
|
|
UINT cbAnsiNetName;
|
|
UINT cbWideNetName;
|
|
UINT cbAnsiDevice;
|
|
UINT cbWideDevice;
|
|
UINT cbChars;
|
|
#endif
|
|
|
|
ASSERT(IsUNCPath(pcszNetName));
|
|
ASSERT(FLAGS_ARE_VALID(dwFlags, ALL_ICNRL_FLAGS));
|
|
ASSERT(IS_FLAG_CLEAR(dwFlags, ICNRL_FL_VALID_DEVICE) ||
|
|
IsValidDevice(pcszDevice));
|
|
ASSERT(IS_FLAG_CLEAR(dwFlags, ICNRL_FL_VALID_NET_TYPE) ||
|
|
IsValidNetType(dwNetType));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppicnrl, PCNRLINK));
|
|
ASSERT(IS_VALID_WRITE_PTR(pucbICNRLinkLen, UINT));
|
|
|
|
#ifdef UNICODE
|
|
bUnicode = FALSE;
|
|
|
|
cbAnsiNetName = WideCharToMultiByte(CP_ACP, 0,
|
|
pcszNetName, -1,
|
|
szAnsiNetName, MAX_PATH,
|
|
0, 0);
|
|
if ( cbAnsiNetName == 0 )
|
|
{
|
|
bUnicode = FALSE;
|
|
}
|
|
else
|
|
{
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
|
|
cbChars = MultiByteToWideChar(CP_ACP, 0,
|
|
szAnsiNetName, -1,
|
|
szWideNetName, MAX_PATH);
|
|
if ( cbChars == 0 || lstrcmp(pcszNetName,szWideNetName) != 0 )
|
|
{
|
|
bUnicode = TRUE;
|
|
}
|
|
}
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
{
|
|
cbAnsiDevice = WideCharToMultiByte(CP_ACP, 0,
|
|
pcszDevice, -1,
|
|
szAnsiDevice, MAX_PATH,
|
|
0, 0);
|
|
if ( cbAnsiDevice == 0 )
|
|
{
|
|
bUnicode = FALSE;
|
|
}
|
|
else
|
|
{
|
|
WCHAR szWideDevice[MAX_PATH];
|
|
|
|
cchChars = MultiByteToWideChar(CP_ACP, 0,
|
|
szAnsiDevice, -1,
|
|
szWideDevice, MAX_PATH);
|
|
if ( cchChars == 0 || lstrcmp(pcszDevice,szWideDevice) != 0 )
|
|
{
|
|
bUnicode = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cbAnsiDevice = 0;
|
|
}
|
|
|
|
if ( bUnicode )
|
|
{
|
|
ucbDataOffset = SIZEOF(ICNRLINKW);
|
|
|
|
/* (+ 1) for null terminator. */
|
|
cbWideNetName = (lstrlen(pcszNetName) + 1) * sizeof(TCHAR);
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
cbWideDevice = (lstrlen(pcszDevice) + 1) * sizeof(TCHAR);
|
|
else
|
|
cbWideDevice = 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
ucbDataOffset = SIZEOF(ICNRLINKA);
|
|
|
|
cbWideNetName = 0;
|
|
cbWideDevice = 0;
|
|
}
|
|
|
|
*pucbICNRLinkLen = ucbDataOffset +
|
|
cbAnsiNetName +
|
|
cbAnsiDevice;
|
|
if ( bUnicode )
|
|
{
|
|
*pucbICNRLinkLen = ALIGN_WORD_CNT(*pucbICNRLinkLen) +
|
|
cbWideNetName +
|
|
cbWideDevice;
|
|
}
|
|
|
|
#else
|
|
|
|
/* Assume we won't overflow *pucbICNRLinkLen here. */
|
|
|
|
/* (+ 1) for null terminator. */
|
|
|
|
*pucbICNRLinkLen = SIZEOF(**ppicnrl) +
|
|
(lstrlen(pcszNetName) + 1) * SIZEOF(TCHAR);
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
/* (+ 1) for null terminator. */
|
|
*pucbICNRLinkLen += (lstrlen(pcszDevice) + 1) * SIZEOF(TCHAR);
|
|
|
|
ucbDataOffset = SIZEOF(ICNRLINKA);
|
|
#endif
|
|
|
|
bResult = AllocateMemory(*pucbICNRLinkLen, ppicnrl);
|
|
|
|
if (bResult)
|
|
{
|
|
(*ppicnrl)->ucbSize = *pucbICNRLinkLen;
|
|
(*ppicnrl)->dwFlags = dwFlags;
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_NET_TYPE))
|
|
(*ppicnrl)->dwNetType = dwNetType;
|
|
else
|
|
(*ppicnrl)->dwNetType = 0;
|
|
|
|
/* Append remote name. */
|
|
|
|
(*ppicnrl)->ucbNetNameOffset = ucbDataOffset;
|
|
|
|
#ifdef UNICODE
|
|
lstrcpyA(ICNRL_Remote_Name_PtrA(*ppicnrl), szAnsiNetName);
|
|
ucbDataOffset += cbAnsiNetName;
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
{
|
|
/* Append device name. */
|
|
|
|
(*ppicnrl)->ucbDeviceOffset = ucbDataOffset;
|
|
lstrcpyA(ICNRL_Device_PtrA(*ppicnrl), szAnsiDevice);
|
|
|
|
ucbDataOffset += cbAnsiDevice;
|
|
}
|
|
else
|
|
{
|
|
(*ppicnrl)->ucbDeviceOffset = 0;
|
|
}
|
|
|
|
if ( bUnicode )
|
|
{
|
|
ucbDataOffset = ALIGN_WORD_CNT(ucbDataOffset);
|
|
|
|
(*ppicnrl)->ucbNetNameOffsetW = ucbDataOffset;
|
|
|
|
lstrcpy(ICNRL_Remote_Name_PtrW(*ppicnrl), pcszNetName);
|
|
ucbDataOffset += cbWideNetName;
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
{
|
|
/* Append device name. */
|
|
|
|
(*ppicnrl)->ucbDeviceOffsetW = ucbDataOffset;
|
|
lstrcpy(ICNRL_Device_Ptr(*ppicnrl), pcszDevice);
|
|
|
|
/* (+ 1) for null terminator. */
|
|
ucbDataOffset += cbWideDevice;
|
|
}
|
|
else
|
|
{
|
|
(*ppicnrl)->ucbDeviceOffsetW = 0;
|
|
}
|
|
|
|
}
|
|
#else
|
|
lstrcpy(ICNRL_Remote_Name_Ptr(*ppicnrl), pcszNetName);
|
|
/* (+ 1) for null terminator. */
|
|
ucbDataOffset += lstrlen(pcszNetName) + 1;
|
|
|
|
if (IS_FLAG_SET(dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
{
|
|
/* Append device name. */
|
|
|
|
(*ppicnrl)->ucbDeviceOffset = ucbDataOffset;
|
|
lstrcpy(ICNRL_Device_Ptr(*ppicnrl), pcszDevice);
|
|
#ifdef DEBUG
|
|
/* (+ 1) for null terminator. */
|
|
ucbDataOffset += (lstrlen(pcszDevice) + 1) * SIZEOF(TCHAR);
|
|
#endif
|
|
}
|
|
else
|
|
(*ppicnrl)->ucbDeviceOffset = 0;
|
|
#endif
|
|
|
|
/* Do all the calculated lengths match? */
|
|
|
|
ASSERT(ucbDataOffset == (*ppicnrl)->ucbSize);
|
|
ASSERT(ucbDataOffset == *pucbICNRLinkLen);
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
(IS_VALID_STRUCT_PTR(*ppicnrl, CICNRLINK) &&
|
|
EVAL(*pucbICNRLinkLen == GetCNRLinkLen((PCCNRLINK)*ppicnrl))));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetNetType()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL GetNetType(LPCTSTR pcszCNRName, PDWORD pdwNetType)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
NETRESOURCE nrIn;
|
|
NETRESOURCEBUF nrbufOut;
|
|
DWORD dwcbBufLen = SIZEOF(nrbufOut);
|
|
LPTSTR pszFileSysPath;
|
|
DWORD dwNetResult;
|
|
#ifdef DEBUG
|
|
DWORD dwcmsTicks;
|
|
#endif
|
|
|
|
ASSERT(IsValidCNRName(pcszCNRName));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwNetType, DWORD));
|
|
|
|
/* RAIDRAID: (15691) We only support disk resource connections here. */
|
|
|
|
ZeroMemory(&nrIn, SIZEOF(nrIn));
|
|
nrIn.lpRemoteName = (LPTSTR)pcszCNRName;
|
|
nrIn.dwType = RESOURCETYPE_DISK;
|
|
|
|
#ifdef DEBUG
|
|
dwcmsTicks = GetTickCount();
|
|
#endif
|
|
|
|
dwNetResult = WNetGetResourceInformation(&nrIn, &(nrbufOut.rgbyte),
|
|
&dwcbBufLen, &pszFileSysPath);
|
|
|
|
#ifdef DEBUG
|
|
|
|
dwcmsTicks = GetTickCount() - dwcmsTicks;
|
|
|
|
TRACE_OUT((TEXT("GetRemotePathInfo(): WNetGetResourceInformation() on net resource %s took %lu.%03lu seconds."),
|
|
pcszCNRName,
|
|
(dwcmsTicks / 1000),
|
|
(dwcmsTicks % 1000)));
|
|
|
|
#endif
|
|
|
|
if (dwNetResult == ERROR_SUCCESS)
|
|
{
|
|
if (nrbufOut.nr.lpProvider)
|
|
{
|
|
NETINFOSTRUCT nis;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(nrbufOut.nr.lpProvider, STR));
|
|
|
|
nis.cbStructure = SIZEOF(nis);
|
|
|
|
dwNetResult = WNetGetNetworkInformation(nrbufOut.nr.lpProvider, &nis);
|
|
|
|
if (dwNetResult == ERROR_SUCCESS)
|
|
{
|
|
*pdwNetType = ((nis.wNetType) << 16);
|
|
bResult = TRUE;
|
|
|
|
TRACE_OUT((TEXT("GetNetType(): Net type for CNR %s is %#08lx."),
|
|
pcszCNRName,
|
|
*pdwNetType));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("GetNetType(): WNetGetNetworkInformation() failed for %s NP, returning %lu."),
|
|
nrbufOut.nr.lpProvider,
|
|
dwNetResult));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("GetNetType(): WNetGetResourceInformation() was unable to determine the NP for CNR %s."),
|
|
pcszCNRName));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("GetNetType(): WNetGetResourceInformation() failed for CNR %s, returning %lu."),
|
|
pcszCNRName,
|
|
dwNetResult));
|
|
|
|
ASSERT(! bResult ||
|
|
IsValidNetType(*pdwNetType));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetNetProviderName()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL GetNetProviderName(PCICNRLINK pcicnrl, LPTSTR pszNPNameBuf)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcicnrl, CICNRLINK));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszNPNameBuf, STR, MAX_PATH_LEN));
|
|
|
|
if (IS_FLAG_SET(pcicnrl->dwFlags, ICNRL_FL_VALID_NET_TYPE))
|
|
{
|
|
DWORD dwcbNPNameBufLen;
|
|
DWORD dwNetResult;
|
|
|
|
dwcbNPNameBufLen = MAX_PATH_LEN;
|
|
|
|
dwNetResult = WNetGetProviderName(pcicnrl->dwNetType, pszNPNameBuf,
|
|
&dwcbNPNameBufLen);
|
|
|
|
if (dwNetResult == ERROR_SUCCESS)
|
|
{
|
|
bResult = TRUE;
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// Unicode builds need to accept both ansi and unicode ICNRLINK structures.
|
|
// Note the use of '%S' (upper case). This will accept an ANSI string
|
|
// in a UNICODE build environment.
|
|
//
|
|
if (IS_ICNRL_ANSI(pcicnrl))
|
|
TRACE_OUT((TEXT("GetNetProviderName(): NP for CNR %S is %s."),
|
|
ICNRL_Remote_Name_PtrA(pcicnrl),
|
|
pszNPNameBuf));
|
|
else
|
|
#endif
|
|
TRACE_OUT((TEXT("GetNetProviderName(): NP for CNR %s is %s."),
|
|
ICNRL_Remote_Name_Ptr(pcicnrl),
|
|
pszNPNameBuf));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("GetNetProviderName(): WNetGetProviderName() failed for CNR %s's net type %#08lx, returning %lu."),
|
|
TEXT("<Remote Name>"), // ICNRL_Remote_Name_Ptr(pcicnrl),
|
|
pcicnrl->dwNetType,
|
|
dwNetResult));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("GetNetProviderName(): Net type for CNR %s is not known. Unable to determine NP name."),
|
|
TEXT("<Remote Name>"))); // ICNRL_Remote_Name_Ptr(pcicnrl)));
|
|
|
|
ASSERT(! bResult ||
|
|
IsValidNetProviderName(pszNPNameBuf));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** CompareNetNames()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE COMPARISONRESULT CompareNetNames(LPCTSTR pcszFirstNetName,
|
|
LPCTSTR pcszSecondNetName)
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFirstNetName, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszSecondNetName, CSTR));
|
|
|
|
return(MapIntToComparisonResult(lstrcmp(pcszFirstNetName,
|
|
pcszSecondNetName)));
|
|
}
|
|
|
|
|
|
/*
|
|
** SearchForRedirectedConnection()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL SearchForRedirectedConnection(PCICNRLINK pcicnrl,
|
|
LPTSTR pszRootPathBuf)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HANDLE henum;
|
|
DWORD dwNetResult;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcicnrl, CICNRLINK));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszRootPathBuf, STR, MAX_PATH_LEN));
|
|
|
|
#ifdef DEBUG
|
|
#ifdef UNICODE
|
|
{
|
|
LPWSTR pszWideNetName;
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
|
|
if (IS_ICNRL_ANSI(pcicnrl))
|
|
{
|
|
pszWideNetName = szWideNetName;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA(pcicnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
} else {
|
|
pszWideNetName = ICNRL_Remote_Name_PtrW(pcicnrl);
|
|
}
|
|
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): Enumerating local connections searching for redirected connection to CNR \"%s\"."),
|
|
pszWideNetName));
|
|
}
|
|
#else
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): Enumerating local connections searching for redirected connection to CNR \"%s\"."),
|
|
ICNRL_Remote_Name_Ptr(pcicnrl)));
|
|
#endif
|
|
#endif
|
|
|
|
/* RAIDRAID: (15691) We only support container resources here. */
|
|
|
|
dwNetResult = WNetOpenEnum(RESOURCE_CONNECTED, RESOURCETYPE_DISK,
|
|
RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_ATTACHED,
|
|
NULL, &henum);
|
|
|
|
if (dwNetResult == WN_SUCCESS)
|
|
{
|
|
DWORD dwc = 1;
|
|
NETRESOURCEBUF nrbuf;
|
|
DWORD dwcbBufLen = SIZEOF(nrbuf);
|
|
|
|
while ((dwNetResult = WNetEnumResource(henum, &dwc, &(nrbuf.rgbyte),
|
|
&dwcbBufLen))
|
|
== WN_SUCCESS)
|
|
{
|
|
/* Is this a redirected connection? */
|
|
|
|
if (nrbuf.nr.lpRemoteName != NULL)
|
|
{
|
|
if (nrbuf.nr.lpLocalName != NULL)
|
|
{
|
|
/* Yes. Is it a redirected connection to the desired CNR? */
|
|
|
|
#ifdef UNICODE
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
LPWSTR pszWideNetName;
|
|
|
|
if (IS_ICNRL_ANSI(pcicnrl))
|
|
{
|
|
pszWideNetName = szWideNetName;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA(pcicnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
}
|
|
else
|
|
{
|
|
pszWideNetName = ICNRL_Remote_Name_Ptr(pcicnrl);
|
|
}
|
|
if (CompareNetNames(pszWideNetName,
|
|
nrbuf.nr.lpRemoteName)
|
|
== CR_EQUAL)
|
|
#else
|
|
if (CompareNetNames(ICNRL_Remote_Name_Ptr(pcicnrl),
|
|
nrbuf.nr.lpRemoteName)
|
|
== CR_EQUAL)
|
|
#endif
|
|
{
|
|
/* Yes. */
|
|
|
|
ASSERT(lstrlen(nrbuf.nr.lpLocalName) < MAX_PATH_LEN);
|
|
|
|
lstrcpy(pszRootPathBuf, nrbuf.nr.lpLocalName);
|
|
bResult = TRUE;
|
|
|
|
TRACE_OUT((TEXT("SearchForRedirectedConnection(): Found CNR \"%s\" connected to %s."),
|
|
nrbuf.nr.lpRemoteName,
|
|
pszRootPathBuf));
|
|
|
|
break;
|
|
}
|
|
else
|
|
/* No. */
|
|
TRACE_OUT((TEXT("SearchForRedirectedConnection(): Skipping unmatched enumerated connection to CNR \"%s\" on %s."),
|
|
nrbuf.nr.lpRemoteName,
|
|
nrbuf.nr.lpLocalName));
|
|
}
|
|
else
|
|
/* No. */
|
|
TRACE_OUT((TEXT("SearchForRedirectedConnection(): Skipping enumerated deviceless connection to CNR \"%s\"."),
|
|
nrbuf.nr.lpRemoteName));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): Skipping enumerated connection with no CNR name.")));
|
|
}
|
|
|
|
if (! bResult && dwNetResult != WN_NO_MORE_ENTRIES)
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): WNetEnumResource() failed, returning %lu."),
|
|
dwNetResult));
|
|
|
|
dwNetResult = WNetCloseEnum(henum);
|
|
|
|
if (dwNetResult != WN_SUCCESS)
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): WNetCloseEnum() failed, returning %lu."),
|
|
dwNetResult));
|
|
}
|
|
else
|
|
WARNING_OUT((TEXT("SearchForRedirectedConnection(): WNetOpenEnum() failed, returning %lu."),
|
|
dwNetResult));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
#if defined(DEBUG) || defined (VSTF)
|
|
|
|
/*
|
|
** IsValidDevice()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidDevice(LPCTSTR pcszDevice)
|
|
{
|
|
/* Any valid string < MAX_PATH_LEN bytes long is a valid device name. */
|
|
|
|
return(IS_VALID_STRING_PTR(pcszDevice, CSTR) &&
|
|
EVAL(lstrlen(pcszDevice) < MAX_PATH_LEN));
|
|
}
|
|
|
|
|
|
/*
|
|
** IsValidNetType()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidNetType(DWORD dwNetType)
|
|
{
|
|
BOOL bResult;
|
|
|
|
switch (dwNetType & 0xffff0000)
|
|
{
|
|
default:
|
|
WARNING_OUT((TEXT("IsValidNetType(): Unexpected net type %#08lx is neither NetWare nor LANMan."),
|
|
dwNetType));
|
|
/* Fall through... */
|
|
|
|
case WNNC_NET_LANMAN:
|
|
case WNNC_NET_NETWARE:
|
|
bResult = TRUE;
|
|
break;
|
|
|
|
}
|
|
|
|
if (dwNetType & 0x0000ffff)
|
|
WARNING_OUT((TEXT("IsValidNetType(): Low word of net type %#08lx is non-zero."),
|
|
dwNetType));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** IsValidPCICNRLINK()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidPCICNRLINK(PCICNRLINK pcicnrl)
|
|
{
|
|
BOOL bResult;
|
|
|
|
if (IS_VALID_READ_PTR(pcicnrl, CICNRLINK) &&
|
|
IS_VALID_READ_BUFFER_PTR(pcicnrl, CICNRLINK, pcicnrl->ucbSize) &&
|
|
FLAGS_ARE_VALID(pcicnrl->dwFlags, ALL_ICNRL_FLAGS) &&
|
|
EVAL(IsValidCNRName(ICNRL_Remote_Name_Ptr(pcicnrl))) &&
|
|
EVAL(IsContained(pcicnrl, pcicnrl->ucbSize,
|
|
ICNRL_Remote_Name_PtrA(pcicnrl),
|
|
lstrlenA(ICNRL_Remote_Name_PtrA(pcicnrl)))) &&
|
|
(IS_FLAG_CLEAR(pcicnrl->dwFlags, ICNRL_FL_VALID_NET_TYPE) ||
|
|
EVAL(IsValidNetType(pcicnrl->dwNetType))))
|
|
{
|
|
if (IS_FLAG_CLEAR(pcicnrl->dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
{
|
|
ASSERT(! pcicnrl->ucbDeviceOffset);
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = (EVAL(IsValidDevice(ICNRL_Device_Ptr(pcicnrl))) &&
|
|
EVAL(IsContained(pcicnrl, pcicnrl->ucbSize,
|
|
ICNRL_Device_PtrA(pcicnrl),
|
|
lstrlenA(ICNRL_Device_PtrA(pcicnrl)))));
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
/*
|
|
** IsValidNetProviderName()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PRIVATE_CODE BOOL IsValidNetProviderName(LPCTSTR pcszNetProvider)
|
|
{
|
|
/* Any string < MAX_PATH_LEN characters long is a valid NP name. */
|
|
|
|
return(IS_VALID_STRING_PTR(pcszNetProvider, CSTR) &&
|
|
lstrlen(pcszNetProvider) < MAX_PATH_LEN);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************** Public Functions *****************************/
|
|
|
|
|
|
/*
|
|
** CreateLocalCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** If TRUE is returned:
|
|
** 1) *ppcnrl is only valid if *pucbCNRLinkLen > 0.
|
|
** 2) pszLocalBasePathBuf is valid.
|
|
** 3) *ppcszCommonPathSuffix is valid.
|
|
**
|
|
** If *pucbCNRLinkLen == 0, pszLocalBasePathBuf is a copy of pcszLocalPath, and
|
|
** *ppcszCommonPathSuffix points at the null terminator of pcszLocalPath.
|
|
**
|
|
** If *pucbCNRLinkLen > 0, pszLocalBasePathBuf is the closest shared local base
|
|
** path, and *ppcszCommonPathSuffix points at that path's suffix in
|
|
** pcszLocalPath.
|
|
*/
|
|
PUBLIC_CODE BOOL CreateLocalCNRLink(LPCTSTR pcszLocalPath, PCNRLINK *ppcnrl,
|
|
PUINT pucbCNRLinkLen,
|
|
LPTSTR pszLocalBasePathBuf,
|
|
LPCTSTR *ppcszCommonPathSuffix)
|
|
{
|
|
BOOL bResult;
|
|
TCHAR rgchNetName[MAX_PATH_LEN];
|
|
BOOL bShared;
|
|
DWORD dwNetType;
|
|
|
|
ASSERT(IsDrivePath(pcszLocalPath));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppcnrl, PCNRLINK));
|
|
ASSERT(IS_VALID_WRITE_PTR(pucbCNRLinkLen, UINT));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszLocalBasePathBuf, STR, MAX_PATH_LEN));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppcszCommonPathSuffix, LPCTSTR));
|
|
|
|
bResult = GetNetPathFromLocalPath(pcszLocalPath, rgchNetName,
|
|
ppcszCommonPathSuffix, &bShared,
|
|
&dwNetType);
|
|
|
|
if (bResult)
|
|
{
|
|
if (bShared)
|
|
{
|
|
bResult = UnifyICNRLinkInfo(rgchNetName, ICNRL_FL_VALID_NET_TYPE,
|
|
NULL, dwNetType, (PICNRLINK *)ppcnrl,
|
|
pucbCNRLinkLen);
|
|
|
|
if (bResult)
|
|
{
|
|
UINT ucbLocalBasePathLen;
|
|
|
|
/* Copy local base path into output buffer. */
|
|
|
|
ASSERT(*ppcszCommonPathSuffix >= pcszLocalPath);
|
|
ucbLocalBasePathLen = (UINT)(*ppcszCommonPathSuffix - pcszLocalPath);
|
|
|
|
CopyMemory(pszLocalBasePathBuf, pcszLocalPath, ucbLocalBasePathLen * sizeof(TCHAR));
|
|
pszLocalBasePathBuf[ucbLocalBasePathLen] = TEXT('\0');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Not shared. No CNRLink. */
|
|
|
|
*pucbCNRLinkLen = 0;
|
|
|
|
/* Copy entire local path into output buffer. */
|
|
|
|
lstrcpy(pszLocalBasePathBuf, pcszLocalPath);
|
|
|
|
/* Common path suffix is the empty string. */
|
|
|
|
*ppcszCommonPathSuffix = pcszLocalPath + lstrlen(pcszLocalPath);
|
|
}
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
(EVAL(IsDrivePath(pszLocalBasePathBuf)) &&
|
|
IS_VALID_STRING_PTR(*ppcszCommonPathSuffix, CSTR) &&
|
|
EVAL(IsStringContained(pcszLocalPath, *ppcszCommonPathSuffix)) &&
|
|
(! *pucbCNRLinkLen ||
|
|
(IS_VALID_STRUCT_PTR((PCICNRLINK)*ppcnrl, CICNRLINK) &&
|
|
EVAL(*pucbCNRLinkLen == GetCNRLinkLen(*ppcnrl))))));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** CreateRemoteCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL CreateRemoteCNRLink(LPCTSTR pcszRemotePath, LPCTSTR pcszCNRName,
|
|
PCNRLINK *ppcnrl, PUINT pucbCNRLinkLen)
|
|
{
|
|
BOOL bResult;
|
|
/* "D:" + null terminator. */
|
|
TCHAR rgchDrive[3];
|
|
DWORD dwNetType;
|
|
|
|
ASSERT(IsCanonicalPath(pcszRemotePath));
|
|
ASSERT(IsValidCNRName(pcszCNRName));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppcnrl, PCNRLINK));
|
|
ASSERT(IS_VALID_WRITE_PTR(pucbCNRLinkLen, UINT));
|
|
|
|
/* Determine net provider. */
|
|
|
|
bResult = GetNetType(pcszCNRName, &dwNetType);
|
|
|
|
if (bResult)
|
|
{
|
|
DWORD dwFlags = ICNRL_FL_VALID_NET_TYPE;
|
|
|
|
/* Determine last redirected drive, if any. */
|
|
|
|
if (IsDrivePath(pcszRemotePath))
|
|
{
|
|
MyLStrCpyN(rgchDrive, pcszRemotePath, ARRAYSIZE(rgchDrive));
|
|
SET_FLAG(dwFlags, ICNRL_FL_VALID_DEVICE);
|
|
}
|
|
else
|
|
rgchDrive[0] = TEXT('\0');
|
|
|
|
bResult = UnifyICNRLinkInfo(pcszCNRName, dwFlags, rgchDrive, dwNetType,
|
|
(PICNRLINK *)ppcnrl, pucbCNRLinkLen);
|
|
}
|
|
|
|
ASSERT(! bResult ||
|
|
(IS_VALID_STRUCT_PTR((PCICNRLINK)*ppcnrl, CICNRLINK) &&
|
|
EVAL(*pucbCNRLinkLen == GetCNRLinkLen(*ppcnrl))));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** DestroyCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void DestroyCNRLink(PCNRLINK pcnrl)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pcnrl, CCNRLINK));
|
|
|
|
FreeMemory(pcnrl);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** CompareCNRLinks()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
**
|
|
** CNR link data is compared in the following order:
|
|
**
|
|
** 1) net name
|
|
**
|
|
** N.b., net types are ignored when comparing CNRLinks.
|
|
*/
|
|
PUBLIC_CODE COMPARISONRESULT CompareCNRLinks(PCCNRLINK pccnrlFirst,
|
|
PCCNRLINK pccnrlSecond)
|
|
{
|
|
#ifdef UNICODE
|
|
WCHAR szWideNetNameFirst[MAX_PATH];
|
|
LPWSTR pszWideNetNameFirst;
|
|
WCHAR szWideNetNameSecond[MAX_PATH];
|
|
LPWSTR pszWideNetNameSecond;
|
|
#endif
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrlFirst, CCNRLINK));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrlSecond, CCNRLINK));
|
|
|
|
#ifdef UNICODE
|
|
if (IS_ICNRL_ANSI(pccnrlFirst))
|
|
{
|
|
pszWideNetNameFirst = szWideNetNameFirst;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrlFirst), -1,
|
|
szWideNetNameFirst, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszWideNetNameFirst = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrlFirst);
|
|
}
|
|
|
|
if (IS_ICNRL_ANSI(pccnrlSecond))
|
|
{
|
|
pszWideNetNameSecond = szWideNetNameSecond;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrlSecond), -1,
|
|
szWideNetNameSecond, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszWideNetNameSecond = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrlSecond);
|
|
}
|
|
|
|
return(CompareNetNames(pszWideNetNameFirst,pszWideNetNameSecond));
|
|
#else
|
|
return(CompareNetNames(ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrlFirst),
|
|
ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrlSecond)));
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
** GetLocalPathFromCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetLocalPathFromCNRLink(PCCNRLINK pccnrl,
|
|
LPTSTR pszLocalPathBuf,
|
|
PDWORD pdwOutFlags)
|
|
{
|
|
BOOL bResult;
|
|
PCSERVERVTABLE pcsvt;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszLocalPathBuf, STR, MAX_PATH_LEN));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwOutFlags, DWORD));
|
|
|
|
*pdwOutFlags = 0;
|
|
|
|
bResult = GetServerVTable(&pcsvt);
|
|
|
|
if (bResult)
|
|
{
|
|
DWORD dwNetType;
|
|
BOOL bIsLocal;
|
|
|
|
/*
|
|
* Get local path for share. N.b., the share name must be in upper case
|
|
* here for MSSHRUI.DLL.
|
|
*/
|
|
|
|
dwNetType = (IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags,
|
|
ICNRL_FL_VALID_NET_TYPE) ?
|
|
((PCICNRLINK)pccnrl)->dwNetType :
|
|
0);
|
|
|
|
#ifdef UNICODE
|
|
{
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
LPWSTR pszWideNetName = szWideNetName;
|
|
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszWideNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
bResult = (pcsvt->GetLocalPathFromNetResource)(
|
|
pszWideNetName, dwNetType,
|
|
pszLocalPathBuf, MAX_PATH_LEN, &bIsLocal);
|
|
}
|
|
#else
|
|
bResult = (pcsvt->GetLocalPathFromNetResource)(
|
|
ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl), dwNetType,
|
|
pszLocalPathBuf, MAX_PATH_LEN, &bIsLocal);
|
|
#endif
|
|
|
|
if (bIsLocal)
|
|
SET_FLAG(*pdwOutFlags, CNR_FL_LOCAL);
|
|
}
|
|
|
|
ASSERT(FLAGS_ARE_VALID(*pdwOutFlags, ALL_CNR_FLAGS) &&
|
|
(! bResult ||
|
|
(EVAL(IS_FLAG_SET(*pdwOutFlags, CNR_FL_LOCAL)) &&
|
|
EVAL(IsLocalDrivePath(pszLocalPathBuf)))));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetRemotePathFromCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void GetRemotePathFromCNRLink(PCCNRLINK pccnrl,
|
|
LPTSTR pszRemotePathBuf)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszRemotePathBuf, STR, MAX_PATH_LEN));
|
|
|
|
/* It's ok that this is broken for non-UNC CNR names. */
|
|
|
|
/* (- 1) for trailing slash. */
|
|
|
|
#ifdef UNICODE
|
|
ASSERT(IS_ICNRL_ANSI(pccnrl) ? (lstrlenA(ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl)) < MAX_PATH_LEN - 1) :
|
|
(lstrlenW(ICNRL_Remote_Name_PtrW((PCICNRLINK)pccnrl)) < MAX_PATH_LEN - 1));
|
|
#else
|
|
ASSERT(lstrlenA(ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl)) < MAX_PATH_LEN - 1);
|
|
#endif
|
|
|
|
#ifdef UNICODE
|
|
{
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
LPWSTR pszWideNetName;
|
|
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
pszWideNetName = szWideNetName;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszWideNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
lstrcpy(pszRemotePathBuf, pszWideNetName);
|
|
}
|
|
#else
|
|
lstrcpy(pszRemotePathBuf, ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl));
|
|
#endif
|
|
CatPath(pszRemotePathBuf, TEXT("\\"));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** ConnectToCNR()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL ConnectToCNR(PCCNRLINK pccnrl, DWORD dwInFlags,
|
|
HWND hwndOwner, LPTSTR pszRootPathBuf,
|
|
PDWORD pdwOutFlags)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
BOOL bValidDevice;
|
|
BOOL bRedirect;
|
|
BOOL bTryLastDevice = FALSE;
|
|
DWORD dwcbRootPathBufLen;
|
|
LPTSTR pszNetName;
|
|
LPTSTR pszDevice;
|
|
#ifdef UNICODE
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
WCHAR szWideDevice[MAX_PATH];
|
|
#endif
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
ASSERT(FLAGS_ARE_VALID(dwInFlags, ALL_CONNECT_IN_FLAGS));
|
|
ASSERT(IS_FLAG_CLEAR(dwInFlags, CONNECT_INTERACTIVE) ||
|
|
IS_VALID_HANDLE(hwndOwner, WND));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszRootPathBuf, STR, MAX_PATH_LEN));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwOutFlags, DWORD));
|
|
|
|
*pdwOutFlags = 0;
|
|
|
|
#ifdef UNICODE
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
pszNetName = szWideNetName;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
#else
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
#endif
|
|
|
|
/* Do we have an old redirected device to try? */
|
|
|
|
bValidDevice = IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags,
|
|
ICNRL_FL_VALID_DEVICE);
|
|
|
|
#ifdef UNICODE
|
|
if ( bValidDevice )
|
|
{
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
pszDevice = szWideDevice;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Device_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideDevice, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszDevice = ICNRL_Device_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
}
|
|
#else
|
|
pszDevice = ICNRL_Device_Ptr((PCICNRLINK)pccnrl);
|
|
#endif
|
|
|
|
bRedirect = (bValidDevice || IS_FLAG_SET(dwInFlags, CONNECT_REDIRECT));
|
|
|
|
if (bRedirect)
|
|
{
|
|
if (bValidDevice)
|
|
{
|
|
DWORD dwNetResult;
|
|
/* "X:" + null terminator */
|
|
TCHAR rgchDrive[2 + 1];
|
|
|
|
/* Yes. Is it already connected to the desired CNR? */
|
|
|
|
TRACE_OUT((TEXT("ConnectToCNR(): Calling WNetGetConnection() to check %s for CNR \"%s\"."),
|
|
pszDevice, pszNetName));
|
|
|
|
dwcbRootPathBufLen = MAX_PATH_LEN;
|
|
|
|
/* WNetGetConnection requires the device name to have no trailing
|
|
** backslash.
|
|
*/
|
|
MyLStrCpyN(rgchDrive, pszDevice, ARRAYSIZE(rgchDrive));
|
|
dwNetResult = WNetGetConnection(rgchDrive, pszRootPathBuf, &dwcbRootPathBufLen);
|
|
|
|
if (dwNetResult == WN_SUCCESS)
|
|
{
|
|
if (CompareNetNames(pszNetName, pszRootPathBuf)
|
|
== CR_EQUAL)
|
|
{
|
|
TRACE_OUT((TEXT("ConnectToCNR(): Found matching CNR \"%s\" on %s."),
|
|
pszRootPathBuf,
|
|
pszDevice));
|
|
|
|
ASSERT(lstrlenA(ICNRL_Device_PtrA((PCICNRLINK)pccnrl)) < MAX_PATH_LEN);
|
|
lstrcpy(pszRootPathBuf, pszDevice);
|
|
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
TRACE_OUT((TEXT("ConnectToCNR(): Found unmatched CNR \"%s\" on %s."),
|
|
pszRootPathBuf,
|
|
pszDevice));
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT((TEXT("ConnectToCNR(): WNetGetConnection() failed on %s."),
|
|
pszDevice));
|
|
|
|
/*
|
|
* Only attempt a connection to the last redirected device if that
|
|
* device is not already in use.
|
|
*/
|
|
|
|
bTryLastDevice = (GetDriveType(pszDevice)
|
|
== DRIVE_NO_ROOT_DIR);
|
|
}
|
|
}
|
|
|
|
if (! bResult)
|
|
/* See if the desired CNR is connected to any local device. */
|
|
bResult = SearchForRedirectedConnection((PCICNRLINK)pccnrl,
|
|
pszRootPathBuf);
|
|
/*
|
|
* Assume that no reference count is maintained for redirected device
|
|
* connections, so we do not have to add a found redirected device
|
|
* connection again.
|
|
*/
|
|
}
|
|
|
|
if (! bResult)
|
|
{
|
|
NETRESOURCE nr;
|
|
TCHAR rgchNPName[MAX_PATH_LEN];
|
|
|
|
/* RAIDRAID: (15691) We only support disk resource connections here. */
|
|
|
|
ZeroMemory(&nr, SIZEOF(nr));
|
|
nr.lpRemoteName = pszNetName;
|
|
nr.dwType = RESOURCETYPE_DISK;
|
|
if (GetNetProviderName((PCICNRLINK)pccnrl, rgchNPName))
|
|
nr.lpProvider = rgchNPName;
|
|
|
|
/* Shall we try the old device? */
|
|
|
|
if (bTryLastDevice)
|
|
{
|
|
/* Yes. */
|
|
|
|
ASSERT(bValidDevice);
|
|
|
|
nr.lpLocalName = pszDevice;
|
|
|
|
WARNING_OUT((TEXT("ConnectToCNR(): Calling WNetUseConnection() to attempt to connect %s to CNR \"%s\"."),
|
|
nr.lpLocalName,
|
|
nr.lpRemoteName));
|
|
}
|
|
else
|
|
{
|
|
/* No. Shall we attempt to force a redirected connection? */
|
|
|
|
if (bValidDevice)
|
|
{
|
|
/*
|
|
* Yes. N.b., the caller may already have set CONNECT_REDIRECT in
|
|
* dwInFlags here.
|
|
*/
|
|
|
|
SET_FLAG(dwInFlags, CONNECT_REDIRECT);
|
|
|
|
WARNING_OUT((TEXT("ConnectToCNR(): Calling WNetUseConnection() to establish auto-picked redirected connection to CNR \"%s\"."),
|
|
nr.lpRemoteName));
|
|
}
|
|
else
|
|
/* No. */
|
|
WARNING_OUT((TEXT("ConnectToCNR(): Calling WNetUseConnection() to establish connection to CNR \"%s\"."),
|
|
TEXT("<nr.lpRemoteName>"))); // nr.lpRemoteName));
|
|
|
|
ASSERT(! nr.lpLocalName);
|
|
}
|
|
|
|
dwcbRootPathBufLen = MAX_PATH_LEN;
|
|
|
|
bResult = (WNetUseConnection(hwndOwner, &nr, NULL, NULL, dwInFlags,
|
|
pszRootPathBuf, &dwcbRootPathBufLen,
|
|
pdwOutFlags)
|
|
== NO_ERROR);
|
|
}
|
|
|
|
if (bResult)
|
|
CatPath(pszRootPathBuf, TEXT("\\"));
|
|
|
|
ASSERT(! bResult ||
|
|
(IS_VALID_STRING_PTR(pszRootPathBuf, STR) &&
|
|
FLAGS_ARE_VALID(*pdwOutFlags, ALL_CONNECT_OUT_FLAGS)));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** DisconnectFromCNR()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL DisconnectFromCNR(PCCNRLINK pccnrl)
|
|
{
|
|
DWORD dwNetResult;
|
|
LPTSTR pszNetName;
|
|
#ifdef UNICODE
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
#endif
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
#ifdef UNICODE
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
pszNetName = szWideNetName;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
#else
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
#endif
|
|
|
|
dwNetResult = WNetCancelConnection2(pszNetName,
|
|
CONNECT_REFCOUNT, FALSE);
|
|
|
|
if (dwNetResult == NO_ERROR)
|
|
WARNING_OUT((TEXT("DisconnectFromCNR(): Reduced connection reference count on CNR \"%s\"."),
|
|
pszNetName));
|
|
else
|
|
WARNING_OUT((TEXT("DisconnectFromCNR(): Failed to reduce connection reference count on CNR \"%s\". WNetCancelConnection2() returned %lu."),
|
|
pszNetName));
|
|
|
|
return(dwNetResult == NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
** IsCNRAvailable()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsCNRAvailable(PCCNRLINK pccnrl)
|
|
{
|
|
TCHAR rgchCNRRoot[MAX_PATH_LEN];
|
|
LPTSTR pszNetName;
|
|
#ifdef UNICODE
|
|
WCHAR szWideNetName[MAX_PATH];
|
|
#endif
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
#ifdef UNICODE
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
{
|
|
pszNetName = szWideNetName;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl), -1,
|
|
szWideNetName, MAX_PATH);
|
|
|
|
}
|
|
else
|
|
{
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
}
|
|
#else
|
|
pszNetName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
#endif
|
|
|
|
ASSERT(lstrlen(pszNetName) < ARRAYSIZE(rgchCNRRoot) - 1);
|
|
lstrcpy(rgchCNRRoot, pszNetName);
|
|
CatPath(rgchCNRRoot, TEXT("\\"));
|
|
|
|
return(PathExists(rgchCNRRoot));
|
|
}
|
|
|
|
|
|
/*
|
|
** GetCNRLinkLen()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE UINT GetCNRLinkLen(PCCNRLINK pccnrl)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
return(((PCICNRLINK)pccnrl)->ucbSize);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetCNRNetType()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetCNRNetType(PCCNRLINK pccnrl, PCDWORD *ppcdwNetType)
|
|
{
|
|
BOOL bResult;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
bResult = IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags,
|
|
ICNRL_FL_VALID_NET_TYPE);
|
|
|
|
if (bResult)
|
|
*ppcdwNetType = &(((PCICNRLINK)pccnrl)->dwNetType);
|
|
|
|
ASSERT(! bResult ||
|
|
IsValidNetType(**ppcdwNetType));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
/*
|
|
** GetCNRName()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetCNRName(PCCNRLINK pccnrl, LPCSTR *ppcszCNRName)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
*ppcszCNRName = ICNRL_Remote_Name_PtrA((PCICNRLINK)pccnrl);
|
|
|
|
ASSERT(IS_VALID_STRING_PTRA(*ppcszCNRName, CSTR));
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
/*
|
|
** GetCNRNameW()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetCNRNameW(PCCNRLINK pccnrl, LPCWSTR *ppcszCNRName)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
*ppcszCNRName = NULL;
|
|
else
|
|
{
|
|
*ppcszCNRName = ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl);
|
|
ASSERT(IS_VALID_STRING_PTR(*ppcszCNRName, CSTR));
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** GetLastRedirectedDevice()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetLastRedirectedDevice(PCCNRLINK pccnrl, LPCSTR *ppcszDevice)
|
|
{
|
|
BOOL bResult;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
bResult = IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags, ICNRL_FL_VALID_DEVICE);
|
|
|
|
if (bResult)
|
|
*ppcszDevice = ICNRL_Device_PtrA((PCICNRLINK)pccnrl);
|
|
|
|
ASSERT(! bResult ||
|
|
IS_VALID_STRING_PTRA(*ppcszDevice, CSTR));
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
/*
|
|
** GetLastRedirectedDeviceW()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL GetLastRedirectedDeviceW(PCCNRLINK pccnrl, LPCWSTR *ppcszDevice)
|
|
{
|
|
BOOL bResult;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
bResult = IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags, ICNRL_FL_VALID_DEVICE);
|
|
|
|
if (bResult)
|
|
if (IS_ICNRL_ANSI(pccnrl))
|
|
*ppcszDevice = NULL;
|
|
else
|
|
{
|
|
*ppcszDevice = ICNRL_Device_Ptr((PCICNRLINK)pccnrl);
|
|
ASSERT(! bResult ||
|
|
IS_VALID_STRING_PTR(*ppcszDevice, CSTR));
|
|
}
|
|
|
|
return(bResult);
|
|
}
|
|
#endif
|
|
|
|
#if defined(DEBUG) || defined (VSTF)
|
|
|
|
/*
|
|
** IsValidPCCNRLINK()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE BOOL IsValidPCCNRLINK(PCCNRLINK pccnrl)
|
|
{
|
|
return(IS_VALID_STRUCT_PTR((PCICNRLINK)pccnrl, CICNRLINK));
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/*
|
|
** DumpCNRLink()
|
|
**
|
|
**
|
|
**
|
|
** Arguments:
|
|
**
|
|
** Returns:
|
|
**
|
|
** Side Effects: none
|
|
*/
|
|
PUBLIC_CODE void DumpCNRLink(PCCNRLINK pccnrl)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(pccnrl, CCNRLINK));
|
|
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] ucbSize %#x"),
|
|
INDENT_STRING,
|
|
INDENT_STRING,
|
|
((PCICNRLINK)pccnrl)->ucbSize));
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] dwFLags = %#08lx"),
|
|
INDENT_STRING,
|
|
INDENT_STRING,
|
|
((PCICNRLINK)pccnrl)->dwFlags));
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] CNR name \"%s\""),
|
|
INDENT_STRING,
|
|
INDENT_STRING,
|
|
ICNRL_Remote_Name_Ptr((PCICNRLINK)pccnrl)));
|
|
if (IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags, ICNRL_FL_VALID_NET_TYPE))
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] net type %#08lx"),
|
|
INDENT_STRING,
|
|
INDENT_STRING,
|
|
((PCICNRLINK)pccnrl)->dwNetType));
|
|
else
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] net type unknown"),
|
|
INDENT_STRING,
|
|
INDENT_STRING));
|
|
if (IS_FLAG_SET(((PCICNRLINK)pccnrl)->dwFlags, ICNRL_FL_VALID_DEVICE))
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] last redirected local device \"%s\""),
|
|
INDENT_STRING,
|
|
INDENT_STRING,
|
|
ICNRL_Device_Ptr((PCICNRLINK)pccnrl)));
|
|
else
|
|
PLAIN_TRACE_OUT((TEXT("%s%s[CNR link] no last redirected local device"),
|
|
INDENT_STRING,
|
|
INDENT_STRING));
|
|
|
|
return;
|
|
}
|
|
|
|
#endif
|