able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/rpcxlate/rxapi/rxaccess.c

964 lines
27 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991-1993 Microsoft Corporation
Module Name:
rxaccess.c
Abstract:
Contains down-level remoted NetAccess routines:
RxNetAccessAdd
RxNetAccessDel
RxNetAccessEnum
RxNetAccessGetInfo
RxNetAccessGetUserPerms
RxNetAccessSetInfo
(GetAccessDescriptors)
(MapResourceName)
Author:
Richard Firth (rfirth) 20-May-1991
Environment:
Win-32/flat address space
Notes:
Routines in this module assume that caller-supplied parameters have
already been verified. No effort is made to further check the veracity
of parms. Any actions causing exceptions must be trapped at a higher
level. This applies to ALL parameters - strings, pointers, buffers, etc.
Revision History:
20-May-1991 RFirth
Created
13-Sep-1991 JohnRo
Use correct typedef for descriptors (LPDESC, not LPTSTR).
Made changes as suggested by PC-LINT.
16-Sep-1991 JohnRo
Use DBGSTATIC for nonexported routines.
25-Sep-1991 JohnRo
Correct UNICODE use. (Use POSSIBLE_WCSSIZE() for LPWSTR types.)
Fixed MIPS build error.
21-Nov-1991 JohnRo
Removed NT dependencies to reduce recompiles.
05-Dec-1991 RFirth
Enum returns in TotalEntries (or EntriesLeft) the number of items to
be enumerated BEFORE this call. Used to be number left after this call
07-Feb-1992 JohnRo
Avoid compiler warnings.
Use NetApiBufferAllocate() instead of private version.
11-Jan-1993 JohnRo
Made changes suggested by PC-LINT 5.0
30-Apr-1993 JohnRo
Fix NET_API_FUNCTION references. (NetAccess routines are just #define'd
as RxNetAccess routines in lmaccess.h, so we need NET_API_FUNCTION here
too!)
--*/
#include <nt.h>
#include <ntrtl.h>
#include "downlevl.h"
#include <lmaccess.h>
// Don't complain about "unneeded" includes of these files:
/*lint -efile(764,rxaccess.h) */
/*lint -efile(766,rxaccess.h) */
#include "rxaccess.h"
#include <lmuse.h>
//
// local prototypes
//
DBGSTATIC void
GetAccessDescriptors(
IN DWORD Level,
OUT LPDESC* pDesc16,
OUT LPDESC* pDesc32,
OUT LPDESC* pDescSmb,
OUT LPDWORD pDataSize
);
DBGSTATIC
BOOL
MapResourceName(
IN LPTSTR LocalName,
OUT LPTSTR RemoteName
);
//
// routines
//
NET_API_STATUS NET_API_FUNCTION
RxNetAccessAdd(
IN LPCWSTR ServerName,
IN DWORD Level,
IN LPBYTE Buffer,
OUT LPDWORD ParmError OPTIONAL
)
/*++
Routine Description:
Add a user account to a remote down-level server database. Buffer contains
an ACCESS_INFO_1 structure followed by a list of ACCESS_LIST structures
Assumes:
1. all parameters already verified at higher level
Arguments:
ServerName - at which server to perform this request
Level - of information being supplied. Must be 1
Buffer - pointer to user's buffer containing ACCESS_INFO_1 struct
ParmError - optional pointer to place to deposit parameter error
Return Value:
NET_API_STATUS:
Success - NERR_Success
Failure - ERROR_INVALID_PARAMETER
One of the fields in the ACCESS_INFO_1 structure may blow
a down-level limit
--*/
{
NET_API_STATUS rc;
DWORD badparm;
DWORD buflen;
DWORD count;
DWORD len;
PACCESS_LIST aclptr;
TCHAR mappedName[MAX_PATH];
LPACCESS_INFO_1 infoPtr = NULL;
//
// set up default for ParmError and probe writability if value given
//
if (ParmError == NULL) {
ParmError = &badparm;
}
*ParmError = PARM_ERROR_UNKNOWN;
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// Down-level servers only support 1 level of Add information - 1. If this
// isn't it then throw out this request without further ado
//
if (Level != 1) {
return ERROR_INVALID_LEVEL;
}
//
// calculate the size of the buffer we are passing in (32-bit size)
//
//
// How to calculate the maximum for the resource name (PATHLEN?)
// try to blow up a down-level server by submitting eg 4K string
//
buflen = sizeof(ACCESS_INFO_1); // fixed part
len = POSSIBLE_STRLEN(((ACCESS_INFO_1*)Buffer)->acc1_resource_name);
if (!len) {
*ParmError = ACCESS_RESOURCE_NAME_INFOLEVEL;
return ERROR_INVALID_PARAMETER;
}
buflen += len;
//
// loop through the list of ACLs, checking the user/group name against the
// down-level limit
//
//
// STRSIZE returns the number of characters, so all
// we need is count * sizeof(16-bit ACCESS_LIST structure) + sizeof(16-bit
// ACCESS_INFO_1 structure) + STRSIZE(resource name)
//
aclptr = (PACCESS_LIST)(Buffer + sizeof(ACCESS_INFO_1));
for (count = ((ACCESS_INFO_1*)Buffer)->acc1_count; count; --count) {
buflen += sizeof(ACCESS_LIST); // fixed part of access list
if (len = POSSIBLE_STRLEN(aclptr->acl_ugname)) {
if (len > LM20_UNLEN) {
*ParmError = ACCESS_ACCESS_LIST_INFOLEVEL;
return ERROR_INVALID_PARAMETER;
}
}
}
//
// if we need to map the resource name then we have to create a new buffer
// for the access list
//
if (MapResourceName(((LPACCESS_INFO_1)Buffer)->acc1_resource_name, mappedName)) {
infoPtr = (LPACCESS_INFO_1)NetpMemoryAllocate(buflen);
if (infoPtr == NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
}
RtlMoveMemory(infoPtr, Buffer, buflen);
infoPtr->acc1_resource_name = mappedName;
Buffer = (LPBYTE)infoPtr;
}
rc = RxRemoteApi(API_WAccessAdd, // API #
(LPWSTR) ServerName, // where it will run
REMSmb_NetAccessAdd_P, // parameter descriptor
REM16_access_info_1, // Data descriptor/16-bit
REM32_access_info_1, // Data descriptor/32-bit
REMSmb_access_info_1, // Data descriptor/SMB
REM16_access_list, // Aux descriptor/16-bit
REM32_access_list, // Aux descriptor/32-bit
REMSmb_access_list, // Aux descriptor/SMB
FALSE, // this call needs user to be logged on
1, // level. Since there's only 1 push immediate
Buffer, // caller's share_info_1 struct
buflen // parameter supplied by us
);
//
// if we mapped the resource name free up the buffer
//
if (infoPtr) {
NetpMemoryFree(infoPtr);
}
//
// we didn't expect to get any data in return. Just pass the return
// code back to our caller
//
return rc;
}
//NET_API_STATUS
//RxNetAccessCheck(
// )
//{
// /** CANNOT BE REMOTED **/
//}
NET_API_STATUS NET_API_FUNCTION
RxNetAccessDel(
IN LPCWSTR ServerName,
IN LPCWSTR ResourceName
)
/*++
Routine Description:
Remotely delete a resource's Access Control List entry from a down-level
server database. The caller must have Admin privilege to successfully
execute this routine
Arguments:
ServerName - at which server to perform this request
ResourceName- name of thing to delete
Return Value:
NET_API_STATUS:
Success = NERR_Success
Failure =
--*/
{
TCHAR mappedName[MAX_PATH];
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// The ResourceName parameter must be a non-NUL(L) string
//
if (!VALID_STRING(ResourceName)) {
return ERROR_INVALID_PARAMETER;
}
if (MapResourceName((LPWSTR)ResourceName, mappedName)) {
ResourceName = mappedName;
}
return RxRemoteApi(API_WAccessDel, // API #
(LPWSTR) ServerName, // where it will run
REMSmb_NetAccessDel_P, // parameter descriptor
NULL, // Data descriptor/16-bit
NULL, // Data descriptor/32-bit
NULL, // Data descriptor/SMB
NULL, // Aux descriptor/16-bit
NULL, // Aux descriptor/32-bit
NULL, // Aux descriptor/SMB
FALSE, // this call needs user to be logged on
ResourceName
);
}
NET_API_STATUS NET_API_FUNCTION
RxNetAccessEnum(
IN LPCWSTR ServerName,
IN LPCWSTR BasePath,
IN DWORD Recursive,
IN DWORD Level,
OUT LPBYTE* Buffer,
IN DWORD PrefMaxLen,
OUT LPDWORD EntriesRead,
OUT LPDWORD EntriesLeft,
IN OUT LPDWORD ResumeHandle OPTIONAL
)
/*++
Routine Description:
Retrieves access info from a remote down-level server
NOTE: Assumes that calling routine (NetAccessEnum) has validated the
caller's pointers: Buffer, EntriesRead and EntriesLeft are all
valid, writable pointers
Arguments:
ServerName - at which server to perform this request
BasePath - for the resource(s)
Recursive - flag: 0 = return information only for resources identified
in BasePath. !0 = return information for all resources under
BasePath
Level - of information requested. Must be zero
Buffer - pointer to place to store pointer to returned buffer
PrefMaxLen - caller's preferred maximum buffer size
EntriesRead - pointer to returned number of enum elements in buffer
EntriesLeft - pointer to returned total enum elements available to the caller
ResumeHandle- optional pointer to handle for resuming interrupted searches
Return Value:
NET_API_STATUS:
Success = NERR_Success
Failure =
--*/
{
NET_API_STATUS rc;
LPDESC pDesc16;
LPDESC pDesc32;
LPDESC pDescSmb;
LPBYTE ourbuf;
DWORD infolen, entries_read, total_avail;
TCHAR mappedName[MAX_PATH];
UNREFERENCED_PARAMETER(PrefMaxLen);
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// Set the number of entries read and total available to sensible defaults.
// Side effect of testing writability of supplied parameters
//
*Buffer = NULL;
*EntriesRead = 0;
*EntriesLeft = 0;
//
// Check for invalid parameters.
// NB Assumes that DWORD is unsigned
// NB Assume that calling routine (ie NetAccessEnum) has validated the
// caller's pointers
// Ensure that:
// Level is not >1
// ResumeHandle is NULL or a pointer to NULL
//
if (!NULL_REFERENCE(ResumeHandle)) {
return ERROR_INVALID_PARAMETER;
}
if (Level > 1) {
return ERROR_INVALID_LEVEL;
}
//
// Decide which descriptors to use, based on the Level parameter
//
GetAccessDescriptors(Level, &pDesc16, &pDesc32, &pDescSmb, &infolen);
//
// allocate the buffer in which to return the enumerated info, using the
// supplied size criteria. If we fail then return the error code to the
// caller
//
ourbuf = NULL;
if (MapResourceName((LPWSTR)BasePath, mappedName)) {
BasePath = mappedName;
}
rc = RxRemoteApi(API_WAccessEnum, // API number
(LPWSTR) ServerName, // where it will run
REMSmb_NetAccessEnum_P, // parameter descriptor
pDesc16, // Data descriptor/16-bit
pDesc32, // Data descriptor/32-bit
pDescSmb, // Data descriptor/SMB
REM16_access_list, // Aux descriptor/16-bit
REM32_access_list, // Aux descriptor/32-bit
REMSmb_access_list, // Aux descriptor/SMB
ALLOCATE_RESPONSE,
BasePath, // where to start
Recursive, // get tree or not
Level, // level parameter
&ourbuf,
65535,
&entries_read, // pointer to entries read variable
&total_avail // pointer to total entries variable
);
if (rc) {
if (ourbuf != NULL) {
(void) NetApiBufferFree(ourbuf);
}
} else {
*Buffer = ourbuf;
*EntriesRead = entries_read;
*EntriesLeft = total_avail;
}
return rc;
}
NET_API_STATUS NET_API_FUNCTION
RxNetAccessGetInfo(
IN LPCWSTR ServerName,
IN LPCWSTR ResourceName,
IN DWORD Level,
OUT LPBYTE* Buffer
)
/*++
Routine Description:
Retrieves access information about a specific resource from a remote
down-level server
Arguments:
ServerName - at which server to perform this request
ResourceName- name of resource we are trying to get info for
Level - of information required: 0 or 1
Buffer - pointer to place to store address of buffer containing
requested information
Return Value:
NET_API_STATUS:
Success = NERR_Success
Failure = ERROR_INVALID_LEVEL
Specified Level parameter can not be accepted
ERROR_INVALID_PARAMETER
ResourceName or Buffer not valid
--*/
{
NET_API_STATUS rc;
LPDESC pDesc16; // pointer to 16-bit info descriptor for RxRemoteApi
LPDESC pDesc32; // pointer to 32-bit info descriptor for RxRemoteApi
LPDESC pDescSmb; // pointer to SMB info descriptor for RxRemoteApi
LPDESC pAuxDesc16; // pointer to 16-bit aux info descriptor for RxRemoteApi
LPDESC pAuxDesc32; // pointer to 32-bit aux info descriptor for RxRemoteApi
LPDESC pAuxDescSmb; // pointer to SMB aux info descriptor for RxRemoteApi
LPBYTE ourbuf; // buffer we allocate, fill, and give to the caller
DWORD total_avail; // 32-bit total available if supplied buffer too small
DWORD infolen; // 32-bit place to store size of required buffer
TCHAR mappedName[MAX_PATH];
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// Perform parameter validity checks:
// Level must be in range 0 <= Level <= 1
// ResourceName must be non-NULL pointer to non-NULL string
// Buffer must be non-NULL pointer
// NB. Assumes DWORD unsigned
//
if (Level > 1) {
return ERROR_INVALID_LEVEL;
}
if (NULL_REFERENCE(ResourceName) || !Buffer) {
return ERROR_INVALID_PARAMETER;
}
//
// set Buffer to default value and catch any bad address errors
//
*Buffer = NULL;
//
// Work out the descriptor and buffer size requirements based on the
// requested level
//
GetAccessDescriptors(Level, &pDesc16, &pDesc32, &pDescSmb, &infolen);
if (Level == 1) {
pAuxDesc16 = REM16_access_list;
pAuxDesc32 = REM32_access_list;
pAuxDescSmb = REMSmb_access_list;
} else {
pAuxDesc16 = NULL;
pAuxDesc32 = NULL;
pAuxDescSmb = NULL;
}
//
// get a better way to allocate the buffer length
//
infolen = 4096;
//
// allocate a buffer size required to fit in 1 structure at info level
// requested. If the allocation fails then return the error
//
if (rc = NetApiBufferAllocate(infolen, (LPVOID *) &ourbuf)) {
return rc;
}
if (MapResourceName((LPWSTR)ResourceName, mappedName)) {
ResourceName = mappedName;
}
rc = RxRemoteApi(API_WAccessGetInfo,
(LPWSTR) ServerName, // where it will happen
REMSmb_NetAccessGetInfo_P, // parameter descriptor
pDesc16, // Data descriptor/16-bit
pDesc32, // Data descriptor/32-bit
pDescSmb, // Data descriptor/SMB
pAuxDesc16, // Aux descriptor/16-bit
pAuxDesc32, // Aux descriptor/32-bit
pAuxDescSmb, // Aux descriptor/SMB
FALSE, // this call needs user to be logged on
ResourceName, // pointer to thing to get info on
Level, // level of info
ourbuf, // pointer to buffer sourced by us
infolen, // size of our sourced buffer
&total_avail // pointer to total available
);
//
// If the remote NetShareGetInfo call succeeded then give the returned
// buffer to the caller
//
if (rc == NERR_Success) {
*Buffer = ourbuf;
} else {
//
// if we didn't record a success then free the buffer previously allocated
//
(void) NetApiBufferFree(ourbuf);
}
return rc;
}
NET_API_STATUS NET_API_FUNCTION
RxNetAccessGetUserPerms(
IN LPCWSTR ServerName,
IN LPCWSTR UserName,
IN LPCWSTR ResourceName,
OUT LPDWORD Perms
)
/*++
Routine Description:
Retrieves the access information for a particular resource for a
specified user or group
Arguments:
ServerName - at which server to perform this request
UserName - name of user or group which can access resource
ResourceName- name of resource to get information for
Perms - pointer to place to store permissions
Return Value:
NET_API_STATUS:
Success = NERR_Success
Failure = ERROR_INVALID_PARAMETER
(return code from remoted NetAccessGetUserPerms)
--*/
{
TCHAR mappedName[MAX_PATH];
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// set *Perms to default value and verify writability of Perms
//
*Perms = 0;
//
// Perform parameter validity checks:
// UserName must be non-NULL pointer to non-NULL string
// ResourceName must be non-NULL pointer to non-NULL string
// Perms must be non-NULL pointer
//
if (!VALID_STRING(UserName) || !VALID_STRING(ResourceName)) {
return ERROR_INVALID_PARAMETER;
}
if (MapResourceName( (LPWSTR) ResourceName, mappedName)) {
ResourceName = mappedName;
}
return RxRemoteApi(API_WAccessGetUserPerms, // API #
(LPWSTR) ServerName, // where it will run
REMSmb_NetAccessGetUserPerms_P, // parameter descriptor
NULL, // Data descriptor/16-bit
NULL, // Data descriptor/32-bit
NULL, // Data descriptor/SMB
NULL, // Aux descriptor/16-bit
NULL, // Aux descriptor/32-bit
NULL, // Aux descriptor/SMB
FALSE, // this call needs user to be logged on
UserName, // for whom the bells toll
ResourceName, // pointer to thing to get info on
Perms // pointer to returned permissions
);
}
NET_API_STATUS NET_API_FUNCTION
RxNetAccessSetInfo(
IN LPCWSTR ServerName,
IN LPCWSTR ResourceName,
IN DWORD Level,
IN LPBYTE Buffer,
OUT LPDWORD ParmError OPTIONAL
)
/*++
Routine Description:
Changes the access control information for a resource at a specific
down-level remote server
Arguments:
ServerName - at which server to perform this request
ResourceName- name of resource to change access information
Level - level of information buffer being supplied
- 1 or ACCESS_ATTR_INFOLEVEL
Buffer - pointer to buffer containing information
ParmError - optional pointer to place to store parameter error
Return Value:
NET_API_STATUS:
Success = NERR_Success
Failure =
--*/
{
DWORD parmnum;
TCHAR mappedName[MAX_PATH];
UNREFERENCED_PARAMETER(ParmError);
//
// Don't allow null servername
//
if ( ServerName == NULL || *ServerName == L'\0' ) {
return(NERR_InvalidComputer);
}
//
// Perform parameter validity checks:
// Level must be 1 or 1002
// ResourceName must be non-NULL pointer to non-NULL string
// Buffer must be non-NULL
// ParmNum must be in range
// NB. Does not assume that DWORD is unsigned
//
if ((Level != 1) && (Level != ACCESS_ATTR_INFOLEVEL)) {
return ERROR_INVALID_LEVEL;
}
if (!VALID_STRING(ResourceName) || !Buffer) {
return ERROR_INVALID_PARAMETER;
}
//
// convert the NT level information to down-level. Level must be 1 at down-
// level server. ParmNum can be PARMNUM_ALL (0) or ACCESS_ATTR_PARMNUM (2)
// Note that the size of the data being passed to the down-level server will
// be calculated in RxRemoteApi. We do not need to pass in a valid buffer
// length, although the parameter string (REMSmb_NetAccessSetInfo_P) has a
// 'T' descriptor saying this is what the server is getting. We just need
// a place-holder on the stack, hence 0
//
parmnum = (Level == 1) ? PARMNUM_ALL : ACCESS_ATTR_PARMNUM;
if (MapResourceName( (LPWSTR) ResourceName, mappedName)) {
ResourceName = mappedName;
}
return RxRemoteApi(
API_WAccessSetInfo, // API #
(LPWSTR) ServerName, // where it will run
REMSmb_NetAccessSetInfo_P, // parameter descriptor
REM16_access_info_1_setinfo, // Data descriptor/16-bit
REM32_access_info_1_setinfo, // Data descriptor/32-bit
REMSmb_access_info_1_setinfo, // Data descriptor/SMB
REM16_access_list, // Aux descriptor/16-bit
REM32_access_list, // Aux descriptor/32-bit
REMSmb_access_list, // Aux descriptor/SMB
FALSE, // this call needs user to be logged on
ResourceName, // pointer to thing to set info on
1, // level of info
Buffer, // pointer to buffer sourced by caller
0, // size of our buffer IGNORED!
//
// in this case, the field index and parm num are the
// same value
//
MAKE_PARMNUM_PAIR(parmnum, parmnum)
);
}
DBGSTATIC void
GetAccessDescriptors(
IN DWORD level,
OUT LPDESC* pDesc16,
OUT LPDESC* pDesc32,
OUT LPDESC* pDescSmb,
OUT LPDWORD pDataSize
)
/*++
Routine Description:
A routinette to return pointers to the 16- and 32-bit access info
structure descriptor strings for each level (0, 1). Also returns
the size of the 16-bit structure
Arguments:
level - of information to be returned
pDesc16 - pointer to returned 16-bit descriptor string
pDesc32 - pointer to returned 32-bit descriptor string
pDescSmb - pointer to returned SMB descriptor string
pDataSize - pointer to returned size of 16-bit structure
Return Value:
None.
--*/
{
switch (level) {
case 0:
*pDesc16 = REM16_access_info_0;
*pDesc32 = REM32_access_info_0;
*pDescSmb = REMSmb_access_info_0;
*pDataSize = sizeof(ACCESS_INFO_0);
break;
case 1:
*pDesc16 = REM16_access_info_1;
*pDesc32 = REM32_access_info_1;
*pDescSmb = REMSmb_access_info_1;
*pDataSize = sizeof(ACCESS_INFO_1);
break;
#if DBG
//
// just to be completely paranoid...
//
default:
NetpKdPrint(("%s.%u Unknown Level parameter: %u\n", __FILE__, __LINE__, level));
#endif
}
}
DBGSTATIC
BOOL
MapResourceName(
IN LPTSTR LocalName,
OUT LPTSTR RemoteName
)
/*++
Routine Description:
Maps a local resource name to the remote name. Only applies to resource
names which start with a drive specification "[A-Z]:" and then only if
the drive letter specifies a remoted drive
ASSUMES: RemoteName is large enough to hold the mapped name
Arguments:
LocalName - pointer to name of local resource specification
RemoteName - pointer to buffer which will receive mapped resource name
Return Value:
BOOL
TRUE - name was mapped
FALSE - name not mapped
--*/
{
TCHAR driveName[3];
NET_API_STATUS status;
LPUSE_INFO_0 lpUse;
LPTSTR resourceName;
BOOL mapped;
DWORD i;
if (LocalName[1] != TCHAR_COLON) {
(VOID) STRCPY(RemoteName, LocalName);
return FALSE;
}
driveName[0] = LocalName[0];
driveName[1] = TCHAR_COLON;
driveName[2] = TCHAR_EOS;
//
// map the local drive name to the UNC name. If NetUseGetInfo returns
// any error, then don't map
//
status = NetUseGetInfo(NULL, driveName, 0, (LPBYTE*)(LPVOID)&lpUse);
if (status == NERR_Success) {
(VOID) STRCPY(RemoteName, lpUse->ui0_remote);
resourceName = LocalName + 2;
//
// if the rest of the resource name does not start with a path
// separator (it should!) then add one
//
if (!IS_PATH_SEPARATOR(*resourceName) && *resourceName) {
(VOID) STRCAT(RemoteName, (LPTSTR) TEXT("\\"));
}
(VOID) NetApiBufferFree((LPBYTE)lpUse);
mapped = TRUE;
} else {
*RemoteName = TCHAR_EOS;
resourceName = LocalName;
mapped = FALSE;
}
//
// concatenate the rest of the resource name to the UNC. If NetUseGetInfo
// failed then the UNC is a NULL string and the rest of the resource name
// is LocalName
//
(VOID) STRCAT(RemoteName, resourceName);
//
// strip trailing path separators
//
for (i = STRLEN(RemoteName) - 1; IS_PATH_SEPARATOR(RemoteName[i]); --i) {
;
}
RemoteName[i+1] = TCHAR_EOS;
return mapped;
}
Reference in a new issue Copy permalink