windows-server-2003/ds/netapi/rpcxlate/rxapi/rxaccess.c

/*++

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;
}