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.
963 lines
28 KiB
963 lines
28 KiB
/*++
|
|
|
|
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;
|
|
}
|