/*++

Copyright (c) 1991-1992  Microsoft Corporation

Module Name:

    MBCS.C

Abstract:

    Contains mapping functions which transform Unicode strings
    (used by the NT Net APIs) into MBCS strings (used by the
    command-line interface program).

    Scheme for MBCS-Unicode mapping layer for Netcmd.

    The Netcmd assembles its structures using a variant of infostructs
    wherein s/LPWSTR/LPSTR.  (It actually redefines LPWSTR, WCHAR and
    friends to use single-byte characters.)  It then invokes Netapi
    through Mnet, the mapping layer.

    Mnet generates LPWSTR strings for each explicit LPSTR string parm
    passed to Netapi.  It will deallocate these strings before returning
    to the client.

    Mnet also handles strings imbedded within infostructs.  For outgoing
    structs (NetXAdd, various forms of Set and SetInfo), Mnet scans
    the struct's REM description, replacing each found REM_ASCIZ item
    with a pointer to a generated LPWSTR string; once the Netapi returns,
    Mnet will restore the original LPSTR pointers within the munged struct
    (in case the client code uses the submitted struct elsewhere),
    deallocating the generated LPWSTR temporaries.

    For incoming structs (GetInfo, Enum) Mnet operates slightly
    differently, performing no mapping on the struct itself until
    Netapi returns with the goods.  It then scans through the struct,
    again locating REM_ASCIZ fields in the description; however,
    instead of replacing the LPWSTR pointers with pointers to generated
    LPSTR temporaries, it overwrites the wide-character data with its
    own MBCS mapping.  This will always have enough space for a safe
    conversion, since the MBCS version will always occupy no more storage
    than the Unicode version.  When Mnet returns to its client, the
    client will see MBCS strings where Netapi placed Unicode strings.
    (Remember that the client is using a variant infostruct definition.)

Author:

    Ben Goetter     (beng)  26-Aug-1991

Environment:

    User Mode - Win32

Revision History:

    26-Aug-1991     beng
        Created
    03-Oct-1991     JohnRo
        Fixed MIPS build error.
    08-Oct-1991     W-ShankN
        Added AsciifyRpcBufferAux, plus fixes.
    17-Apr-1992     beng
        Bugfix in MxMapClientBuffer
    07-May-1992     beng
        Use official wchar.h header file
    20-Sep-1992     KeithMo
        Map CHAR <-> WCHAR via current console input/output code page.

--*/


//
// INCLUDES
//

#include <windef.h>
#include <excpt.h>      // needed with winbase.h
#include <stdarg.h>     // needed with winbase.h
#include <winbase.h>    // needed for GetLastError()
#include <winnls.h>

#include <time.h>
#include <string.h>
#include <malloc.h>
#include <stddef.h>
#include <stdarg.h>
#include <wchar.h>      // wcslen, for wide-char strings

#include <lmcons.h>
#include <lmerr.h>      // NERR_

#include <remtypes.h>
#include <rap.h>
#include <netdebug.h>   // NetpAssert().
#include <netlib.h>     // NetpMemoryFree

#include "port1632.h"   // includes mbcs.h, others


#if 0

/*
 *  MxAllocUnicode
 *  Given a MBCS string, allocate a new Unicode translation of that string
 *
 *  IN
 *      pszAscii        - pointer to original MBCS string
 *      ppwszUnicode    - pointer to cell to hold new Unicode string addr
 *  OUT
 *      ppwszUnicode    - contains new Unicode string
 *
 *  RETURNS
 *      Error code, 0 if successful.
 *
 *  The client must free the allocated string with MxFreeUnicode.
 */

UINT
MxAllocUnicode(
    LPTSTR    pszAscii,
    LPWSTR * ppwszUnicode )
{
    WORD     err;
    INT      errNlsApi;
    BYTE *   pbAlloc;
    INT      cbAscii;

    if (pszAscii == NULL)
    {
        *ppwszUnicode = NULL;
        return NERR_Success;
    }

    // Calculate size of Unicode string.

    cbAscii = strlen(pszAscii)+1;
    err = MAllocMem(sizeof(WCHAR) * cbAscii, &pbAlloc);
    if (err)
        return err;

    *ppwszUnicode = (LPWSTR)pbAlloc;

    errNlsApi = MultiByteToWideChar(CP_OEMCP,
                                    MB_PRECOMPOSED,
                                    pszAscii,
                                    cbAscii,
                                    *ppwszUnicode,
                                    cbAscii);
    if (errNlsApi == 0)
    {
        *ppwszUnicode = NULL;
        MFreeMem(pbAlloc);
        return ( (UINT)GetLastError() );
    }

    return NERR_Success;
}


UINT
MxAllocUnicodeVector(
    LPTSTR * ppszAscii,
    LPWSTR* ppwszUnicode,
    UINT    cpwszUnicode )
{
    UINT    err;
    UINT    i;

    for (i = 0; i < cpwszUnicode; ++i)
    {
        err = MxAllocUnicode(ppszAscii[i], ppwszUnicode+i);
        if (err)
        {
            MxFreeUnicodeVector(ppwszUnicode,i);
            return err;
        }
    }

    return NERR_Success;
}

/*
 *  MxAllocUnicodeBuffer
 *  Given a MBCS buffer, translate it into a new Unicode buffer.
 *
 *  IN
 *      pbAscii         - pointer to original MBCS buffer
 *      ppwchUnicode    - pointer to cell to hold new Unicode buffer addr
 *      cbAscii         - size of original MBCS buffer
 *  OUT
 *      ppwchUnicode    - contains new Unicode buffer
 *
 *  RETURNS
 *      Error code, 0 if successful.
 *
 *  The client must free the allocated string with MxFreeUnicodeBuffer.
 *  To find the new buffer size, use MxUnicodeBufferSize(cbAscii).
 */

UINT
MxAllocUnicodeBuffer(
    LPBYTE  pbAscii,
    LPWCH*  ppwchUnicode,
    UINT    cbAscii )
{
    WORD     err;
    INT      errNlsApi;
    LPBYTE   pbAlloc;
    INT      cbUnicode;

    if (pbAscii == NULL || cbAscii == 0)
    {
        *ppwchUnicode = (LPWCH)pbAscii;
        return NERR_Success;
    }

    cbUnicode = MxUnicodeBufferSize(cbAscii);

    err = MAllocMem(cbUnicode, &pbAlloc);
    if (err)
        return err;

    *ppwchUnicode = (LPWSTR)pbAlloc;

    errNlsApi = MultiByteToWideChar(CP_OEMCP,
                                    MB_PRECOMPOSED,
                                    pbAscii,
                                    cbAscii,
                                    *ppwchUnicode,
                                    cbUnicode / sizeof(WCHAR));
    if (errNlsApi == 0)
    {
        *ppwchUnicode = NULL;
        MFreeMem(pbAlloc);
        return ( (UINT)GetLastError() );
    }

    return NERR_Success;
}

/*
 *  MxFreeUnicode
 *  Deallocates a Unicode string alloc'd by MxAllocUnicode (q.v.).
 *
 *  IN
 *      pwszUnicode - pointer to the alloc'd string
 *  OUT
 *      pwszUnicode - invalid pointer - string has been freed
 */

VOID
MxFreeUnicode( LPWSTR pwszUnicode )
{
    if (pwszUnicode != NULL)
        MFreeMem((LPBYTE)pwszUnicode);
}


VOID
MxFreeUnicodeVector(
    LPWSTR * ppwsz,
    UINT     cpwsz )
{
    while (cpwsz-- > 0)
        MxFreeUnicode(*ppwsz++);
}


UINT
MxAsciifyInplace( LPWSTR pwszUnicode )
{
    BOOL  fUsedDefault;
    UINT  cwUnicode;
    UINT  cbAscii;
    BYTE *pbAllocTemp;
    WORD  err;
    INT   errNlsApi;

    if (pwszUnicode == NULL)  // Nothing doing!
        return NERR_Success;

    // Temp space needed for conversion.

    cwUnicode = wcslen(pwszUnicode)+1;
    cbAscii = 2 * sizeof(CHAR) * cwUnicode; // A Unichar might expand
                                            // into a multibyte sequence.
    err = MAllocMem(cbAscii, &pbAllocTemp);
    if (err)
        return err;

    errNlsApi = WideCharToMultiByte(CP_OEMCP,
                                    0,
                                    pwszUnicode,
                                    cwUnicode,
                                    pbAllocTemp,
                                    cbAscii,
                                    NULL, // use system default char
                                    &fUsedDefault);
    if (errNlsApi == 0)
    {
        MFreeMem(pbAllocTemp);
        return ( (UINT)GetLastError() );
    }

    // Copy the converted string back into the original caller's buffer

    strcpy((CHAR*)pwszUnicode, pbAllocTemp);
    MFreeMem(pbAllocTemp);

    return NERR_Success;
}

/*
 *  MxMapParameters
 *
 *  Passed an arbitrary number of ASCIZ string parameters, maps
 *  them to Unicode for submission to Netapi. New space is allocated
 *  (if possible) for the Unicode strings, and the routine returns
 *  pointer to these strings in an array of LPWSTR's provided by the
 *  caller.
 *
 *  IN
 *      cParam       - Count of parameters provided.
 *      ...          - Variable number of string parameters
 *
 *  OUT
 *      ppwszUnicode - Pointers to newly allocated Unicode strings.
 *
 *  RETURNS
 *      Error code, 0 if successful
 *
 *  Upon return from Netapi, call MxFreeUnicodeVector to free the Unicode
 *  strings.
 */

UINT
MxMapParameters( UINT cParam, LPWSTR* ppwszUnicode, ... )
{
    va_list ppszAscii;
    LPSTR pszParam;
    UINT iParam;
    UINT err;

    va_start(ppszAscii, ppwszUnicode);
    for ( iParam = 0; iParam < cParam; iParam++ )
    {
        pszParam = va_arg(ppszAscii, LPSTR);
        err = MxAllocUnicode(pszParam, ppwszUnicode + iParam);
        if (err)
        {
            MxFreeUnicodeVector(ppwszUnicode,iParam);
            va_end(ppszAscii);
            return err;
        }
    }

    va_end(ppszAscii);
    return NERR_Success;
}

/*
 *  MxMapClientBuffer
 *  Given a client buffer, map each ASCIZ string to Unicode for
 *  submission to Netapi, saving the original arguments away for
 *  later restoration.
 *
 *  IN
 *      pbInput     - client buffer
 *      ppmxsavlst  - points to a pointer to MXSAVELIST structure to
 *                    instantiate (alloc'ing a MXSAVELIST in the process)
 *      cRecords    - the number of records in the client's buffer
 *      pszDesc     - The REM dope vector describing buffer
 *
 *  OUT
 *      pbInput     - munged
 *      ppmxsavlst  - instantiated with a pointer to a structure
 *                    containing all replaced strings (possibly none).
 *
 *  RETURNS
 *      Error code, 0 if successful
 *
 *  Upon return from Netapi, call MxRestoreClientBuffer to
 *  restore the client's original pointers.
 */

UINT
MxMapClientBuffer(
    BYTE *        pbInput,
    MXSAVELIST ** ppmxsavlst,
    UINT          cRecords,
    CHAR *        pszDesc )
{
    UINT          cmxsav;
    UINT          cmxsavrec;
    UINT          imxsavrec;
    UINT          ibRec;
    CHAR *        pch;
    UINT          err;
    UINT          off;
    UINT          cbRecordSize;
    MXSAVELIST *  pmxsavlst;
    MXSAVEARG *   pmxsav;

    // First, determine the number of args this needs to save

    for (cmxsavrec = 0, pch = strchr(pszDesc, REM_ASCIZ);
         pch != NULL;
         ++cmxsavrec, pch = strchr(pch+1, REM_ASCIZ))
        ;
    cmxsav = cmxsavrec * cRecords;

    // Get the vector of saveargs (may be 0)

    err = MxAllocSaveargs(cmxsav, &pmxsavlst);
    if (err)
        return err;

    *ppmxsavlst = pmxsavlst;

    // Locate, save, then replace each consecutive arg.

    // Compare this scanning loop with that of AsciifyRpcBuffer.
    // Since clients frequently call MapClientBuffer with cRecords
    // set to 1, this lets such calls skip scanning trailing fields
    // in a record once it processes the last asciz argument.

    // If cRecords > 1, then the first time around, the record size
    // is saved. On further passes, non-string data at the end of
    // each record is not scanned.

    off = 0;
    ibRec = 0;
    cbRecordSize = 0;
    imxsavrec = cmxsavrec;
    pch = pszDesc;
    pmxsav = pmxsavlst->pmxsav;
    while (cmxsav > 0) // (now this becomes the count of remaining args)
    {
        if (imxsavrec == 0 && (cbRecordSize != 0 || *pch == 0))
        {
            // Buffer contains multiple records, and is starting
            // a new record.

            NetpAssert(cRecords > 1);

            // If unknown, remember the size of a complete record,
            // so we can skip during future passes.

            if (cbRecordSize == 0)
                cbRecordSize = off;

            // Done with all strings in this entry; skip over any
            // data at the end.

            ibRec += cbRecordSize;
            off = ibRec;

            // Rewind record descriptor to beginning

            imxsavrec = cmxsavrec;
            pch = pszDesc;
        }

        if (*pch == REM_ASCIZ)
        {
            LPWSTR pwszConverted;
            err = MxAllocUnicode( *((LPSTR*)(pbInput+off)), &pwszConverted );
            if (err)
            {
                // Ran out of memory at a most awkward time...

                // Patch count of saved args for the unwind.
                //
                pmxsavlst->cmxsav -= cmxsav;

                // Unwind and return.
                //
                MxRestoreClientBuffer(pbInput, pmxsavlst);
                *ppmxsavlst = NULL;
                return err;
            }

            pmxsav->offThis = off;
            pmxsav->pszOriginal = *((LPSTR*)(pbInput+off));

            *((LPWSTR*)(pbInput+off)) = pwszConverted;

            ++pmxsav;
            --cmxsav;
            --imxsavrec;
        }

        // Skip to the next field

        off += RapGetFieldSize(pch, &pch, Both);
        ++pch;
    }

    return NERR_Success;
}


/*
 *  MxMapClientBufferAux
 *  Given a client buffer, map each ASCIZ string to Unicode for
 *  submission to Netapi, saving the original arguments away for
 *  later restoration.  This version handles those lanman structs
 *  which are followed by "auxiliary" structures: e.g. access_info_1.
 *
 *  IN
 *      pbInput     - client buffer
 *      pszDesc     - The REM dope vector describing buffer
 *      pbInputAux  - pointer to start of aux data in buffer
 *      cRecordsAux - the number of auxiliary records in the
 *                    client's buffer.  This routine assumes only
 *                    one primary structure.
 *      pszDescAux  - describes auxiliary structure
 *      ppmxsavlst  - points to a pointer to MXSAVELIST structure to
 *                    instantiate (alloc'ing a MXSAVELIST in the process)
 *
 *  OUT
 *      pbInput     - munged
 *      ppmxsavlst  - instantiated with a pointer to a structure
 *                    containing all replaced strings (possibly none).
 *
 *  RETURNS
 *      Error code, 0 if successful
 *
 *  Upon return from Netapi, call MxRestoreClientBuffer to
 *  restore the client's original pointers.
 */

UINT
MxMapClientBufferAux(
    BYTE *        pbInput,
    CHAR *        pszDesc,
    BYTE *        pbInputAux,
    UINT          cRecordsAux,
    CHAR *        pszDescAux,
    MXSAVELIST ** ppmxsavlst )
{
    UINT          err;
    MXSAVELIST *  pmxsavlstMain;
    MXSAVELIST *  pmxsavlstAux;
    MXSAVELIST *  pmxsavlstTotal;

    err = MxMapClientBuffer(pbInput, &pmxsavlstMain,
                            1, pszDesc);
    if (err)
    {
        *ppmxsavlst = NULL;
        return err;
    }

    err = MxMapClientBuffer(pbInputAux, &pmxsavlstAux,
                            cRecordsAux, pszDescAux);
    if (err)
    {
        MxRestoreClientBuffer(pbInput, pmxsavlstMain);
        *ppmxsavlst = NULL;
        return err;
    }

    // N.b. Join-saveargs *replaces* the first and second savearg vectors
    // with one composite vector if it succeeds.  On failure, it leaves
    // the original vectors around for proper cleanup.

    err = MxJoinSaveargs(pmxsavlstMain, pmxsavlstAux,
                         pbInputAux-pbInput, &pmxsavlstTotal);
    if (err)
    {
        MxRestoreClientBuffer(pbInputAux, pmxsavlstAux);
        MxRestoreClientBuffer(pbInput, pmxsavlstMain);
        *ppmxsavlst = NULL;
        return err;
    }

    *ppmxsavlst = pmxsavlstTotal;
    return NERR_Success;
}


/*
 *  MxRestoreClientBuffer
 *  Given a mapped buffer and a list of saved args, restore that
 *  buffer to its original state.
 *
 *  IN
 *      pbBuffer    - points to munged client buffer
 *      pmxsavlst   - points to saved args
 *  OUT
 *      pbBuffer    - restored
 *      pmxsavlst   - invalid pointer - structure has been freed
 *
 */

VOID
MxRestoreClientBuffer(
    BYTE *       pbBuffer,
    MXSAVELIST * pmxsavlst )
{
    UINT         imxsav;
    UINT         imxsavLim = pmxsavlst->cmxsav;
    MXSAVEARG *  pmxsav = pmxsavlst->pmxsav;

    for (imxsav = 0; imxsav < imxsavLim; ++imxsav, ++pmxsav)
    {
        UINT off = pmxsav->offThis;
        MxFreeUnicode( *((LPWSTR*)(pbBuffer+off)) );
        *((LPSTR*)(pbBuffer+off)) = pmxsav->pszOriginal;
    }

    MxFreeSaveargs(pmxsavlst);
}


/*
 *  MxAsciifyRpcBuffer
 *  Convert a buffer returned by Netapi into ASCII (actually MBCS) for
 *  stupid apps such as netcmd.
 *
 *  IN
 *      pbInput - buffer full of fun, courtesy of the Netapi
 *      cRecords- the number of entries Netapi claims to have returned
 *      pszDesc - REM-format description of the data buffer
 *  OUT
 *      pbInput - extensively munged.  All Unicode strings have been
 *                overwritten with their MBCS equivalents.
 *
 *  RETURNS
 *      0 on success; otherwise, error cascaded back from Winnls.
 */

UINT
MxAsciifyRpcBuffer(
    BYTE *  pbInput,
    DWORD   cRecords,
    CHAR *  pszDesc )
{
    UINT    off;
    UINT    iRecord;

    // Step through each record returned by the Enum (1 only, if GetInfo)

    for (off = 0, iRecord = 0; iRecord < cRecords; ++iRecord)
    {
        // Examine each field in the record

        // CODEWORK: where cRecords > 1, this could cache a single
        // set of relative offsets and reuse them for each subsequent
        // record.

        CHAR * pch;
        for (pch = pszDesc; *pch != 0; pch++ ) {
            if (*pch == REM_ASCIZ)
            {
                UINT err;
                err = MxAsciifyInplace( *((LPWSTR*)(pbInput+off)) );
                if (err)
                {
                    // WINNLS error at a most inconvenient time.
                    //
                    return err;
                }
            }
            off += RapGetFieldSize(pch, &pch, Both);
        }
    }

    return NERR_Success;
}

/*
 *  MxAsciifyRpcBufferAux
 *
 *  Convert a buffer returned by Netapi into ASCII (actually MBCS) for
 *  stupid apps such as netcmd. This version handles those lanman structs
 *  which are followed by "auxiliary" structures: e.g. access_info_1.
 *
 *  IN
 *      pbInput     - buffer full of fun, courtesy of the Netapi
 *      pszDesc     - REM-format description of the data buffer
 *      pbInputAux  - pointer to start of aux data in buffer
 *      cRecordsAux - the number of auxiliary records in the
 *                    client's buffer.  This routine assumes only
 *                    one primary structure.
 *      pszDescAux  - describes auxiliary structure
 *  OUT
 *      pbInput     - extensively munged.  All Unicode strings have been
 *                    overwritten with their MBCS equivalents.
 *
 *  RETURNS
 *      0 on success; otherwise, error cascaded back from Winnls.
 */

UINT
MxAsciifyRpcBufferAux(
    BYTE *  pbInput,
    CHAR *  pszDesc,
    BYTE *  pbInputAux,
    DWORD   cRecordsAux,
    CHAR *  pszDescAux )
{
    UINT err;

    err = MxAsciifyRpcBuffer(pbInput, 1, pszDesc);
    if (err)
    {
        return err;
    }

    err = MxAsciifyRpcBuffer(pbInputAux, cRecordsAux, pszDescAux);
    if (err)
    {
        // We're in trouble
        return err;
    }

    return NERR_Success;

}

/*
 *  MxAsciifyRpcEnumBufferAux
 *
 *  Convert a buffer returned by Netapi into ASCII (actually MBCS) for
 *  stupid apps such as netcmd. This version handles buffers with multiple
 *  lanman struct records, each followed by an arbitrary number of"auxiliary"
 *  structures: e.g. access_info_1.
 *
 *  IN
 *      pbInput     - buffer full of fun, courtesy of the Netapi
 *      cRecords    - the number of entries Netapi claims to have returned
 *      pszDesc     - REM-format description of the data buffer
 *      pszDescAux  - describes auxiliary structure
 *  OUT
 *      pbInput     - extensively munged.  All Unicode strings have been
 *                    overwritten with their MBCS equivalents.
 *
 *  RETURNS
 *      0 on success; otherwise, error cascaded back from Winnls.
 */

UINT
MxAsciifyRpcEnumBufferAux(
    BYTE *  pbInput,
    DWORD   cRecords,
    CHAR *  pszDesc,
    CHAR *  pszDescAux )
{
    UINT err;
    UINT offcRecordsAux;
    UINT cbRecordSize;
    UINT cbRecordSizeAux;
    UINT i;
    CHAR * pch;

    // Examine main descriptor to find total size of a record, and
    // a relative offset to the descriptor data.

    offcRecordsAux = 0;
    cbRecordSize = 0;
    for ( pch = pszDesc; *pch != '\0';  pch++ )
    {
        if ( *pch == REM_AUX_NUM_DWORD )
        {
            offcRecordsAux = cbRecordSize;
        }
        cbRecordSize += RapGetFieldSize( pch, &pch, Both );
    }

    // Examine auxiliary descriptor to find total size of an auxiliary
    // record.

    cbRecordSizeAux = 0;
    for ( pch = pszDescAux; *pch != '\0'; pch++ ) {
           cbRecordSizeAux += RapGetFieldSize( pch, &pch, Both );
    }

    for ( i = 0; i < cRecords; i++ )
    {
        err = MxAsciifyRpcBufferAux(pbInput, pszDesc, pbInput+cbRecordSize,
                  *((DWORD*)(pbInput+offcRecordsAux)), pszDescAux);
        if (err)
        {
            // We're in trouble
            return err;
        }

        pbInput += (cbRecordSize
                    + *((DWORD*)(pbInput+offcRecordsAux)) * cbRecordSizeAux);
    }

    return NERR_Success;

}


UINT
MxAllocSaveargs(
    UINT         cmxsav,
    MXSAVELIST **ppmxsavlstSet )
{
    WORD         err;
    BYTE *       pbAlloc;

    err = MAllocMem(sizeof(MXSAVELIST), &pbAlloc);
    if (err)
        return err;

    *ppmxsavlstSet = (MXSAVELIST *)pbAlloc;

    err = MAllocMem((sizeof(MXSAVEARG)*cmxsav), &pbAlloc);
    if (err)
    {
        MFreeMem( (LPBYTE)*ppmxsavlstSet );
        *ppmxsavlstSet = NULL;
        return err;
    }

    (*ppmxsavlstSet)->pmxsav = (MXSAVEARG *)pbAlloc;
    (*ppmxsavlstSet)->cmxsav = cmxsav;
    return NERR_Success;
}


VOID
MxFreeSaveargs( MXSAVELIST * pmxsavlst )
{
    if (pmxsavlst != NULL)
    {
        if (pmxsavlst->pmxsav != NULL)
            MFreeMem((LPBYTE)(pmxsavlst->pmxsav));

        MFreeMem((LPBYTE)pmxsavlst);
    }
}


/*
 *  MxJoinSaveargs
 *  Take two savearg vectors - one from a primary struct, one from
 *  its auxiliaries - and compile a single vector, with all offsets
 *  calculated from the original
 *
 * ...tbw
 */

UINT
MxJoinSaveargs(
    MXSAVELIST * pmxsavlstMain,
    MXSAVELIST * pmxsavlstAux,
    UINT         dbFixupAux,
    MXSAVELIST **ppmxsavlstOut )
{
    UINT         err;
    MXSAVELIST * pmxsavlstNew;
    MXSAVEARG *  pmxsav;
    UINT         cmxsav;

    err = MxAllocSaveargs(pmxsavlstMain->cmxsav + pmxsavlstAux->cmxsav,
                          &pmxsavlstNew);
    if (err)
    {
        *ppmxsavlstOut = NULL;
        return err;
    }

    // Quickly copy old vectors into composite new vector

    memcpy(pmxsavlstNew->pmxsav,
           pmxsavlstMain->pmxsav,
           pmxsavlstMain->cmxsav * sizeof(MXSAVEARG));
    memcpy(pmxsavlstNew->pmxsav + pmxsavlstMain->cmxsav,
           pmxsavlstAux->pmxsav,
           pmxsavlstAux->cmxsav * sizeof(MXSAVEARG));

    // Fix up auxiliary vector offsets to express relative to origin

    for (pmxsav = pmxsavlstNew->pmxsav + pmxsavlstMain->cmxsav,
         cmxsav = pmxsavlstAux->cmxsav;
         cmxsav > 0;
         --cmxsav, ++pmxsav)
    {
        pmxsav->offThis += dbFixupAux;
    }

    MxFreeSaveargs(pmxsavlstMain);
    MxFreeSaveargs(pmxsavlstAux);

    *ppmxsavlstOut = pmxsavlstNew;

    return NERR_Success;
}
#endif /* 0 */


/*
 *  MxCalcNewInfoFromOldParm
 *  Given the old-style infolevel and parmnum, calc the new infolevel.
 *
 *  IN
 *      nOldInfo    - old infolevel
 *      nOldParm    - old parmnum
 *
 *  RETURNS
 *      New infolevel
 *
 *  This routine has nothing to do with MBCS, yeah, yeah...
 */

UINT
MxCalcNewInfoFromOldParm( UINT nOldInfo, UINT nOldParm )
{
    return (nOldParm > 0)
           ? (nOldParm + PARMNUM_BASE_INFOLEVEL)
           : nOldInfo;
}


#if 0
/*
 *  MxMapSetinfoBuffer
 *  Given a client buffer intended for a Netapi SetInfo call, map each
 *  ASCIZ string therein to Unicode for submission to Netapi, saving the
 *  original arguments away for later restoration.
 *
 *  IN
 *      ppbInput    - points to a pointer to client buffer
 *      pmxsavlst   - points to a pointer to MXSAVELIST structure to
 *                    instantiate (alloc'ing a MXSAVELIST in the process)
 *      pszDesc     - A special version of the REM descriptor, with info
 *                    about supported fields.
 *      pszRealDesc - The REM descriptor.
 *      nField      - the fieldinfo number (NOT the "parmnum") of the attr
 *                    to setinfo - 0 for "all parms."  These differ due to
 *                    historical accident.
 *                    BUGBUG - if REM strings are used, the fieldinfo should
 *                             correspond to a 16-bit parmnum, not a field no.
 *
 *  OUT
 *      pbInput     - munged, or buffer address possibly changed
 *      ppmxsavlst  - instantiated with a pointer to a structure
 *                    containing all replaced strings (possibly none).
 *
 *  RETURNS
 *      Error code, 0 if successful
 *
 *  Upon return from Netapi, call MxRestoreSetinfoBuffer to
 *  restore the client's original pointers.
 *
 *  nField had well better agree with pszDesc, or else there will be
 *  hell to pay.  There's no good way to check this.
 */

UINT
MxMapSetinfoBuffer(
    BYTE * *      ppbInput,
    MXSAVELIST ** ppmxsavlst,
    CHAR *        pszDesc,
    CHAR *        pszRealDesc,
    UINT          nField )
{
    UINT          nRes;
    CHAR *        pszDescNew;

    // If no sub-parameter given, pass the parms through to the
    // usual mapper.

    if (nField == 0)
        return MxMapClientBuffer(*ppbInput, ppmxsavlst, 1, pszRealDesc);

    // Must build a tiny descriptor string for the single field
    // being setinfo'd.

    pszDescNew = RapParmNumDescriptor(pszDesc, nField, Both, TRUE);
    if (pszDescNew == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
    if ((*pszDescNew == REM_UNSUPPORTED_FIELD)||(*pszDescNew == REM_IGNORE))
    {
        NetpMemoryFree(pszDescNew);         // Free the string
        return ERROR_INVALID_PARAMETER;
    }

    // Data for a string is inline, not referenced by a pointer in structure.
    if (*pszDescNew == REM_ASCIZ)
    {
        nRes = MxMapClientBuffer((BYTE *)ppbInput, ppmxsavlst, 1, pszDescNew);
    }
    else
    {
        nRes = MxMapClientBuffer(*ppbInput, ppmxsavlst, 1, pszDescNew);
    }

    NetpMemoryFree(pszDescNew); // Rap uses the Netp allocator
    return nRes;
}


UINT
MxRestoreSetinfoBuffer(
    BYTE * *      ppbBuffer,
    MXSAVELIST *  pmxsavlst,
    CHAR *        pszDesc,
    UINT          nField )
{
    CHAR *        pszDescNew;

    // If no sub-parameter given, pass the parms through to the
    // usual restoration function.

    if (nField == 0)
    {
        MxRestoreClientBuffer(*ppbBuffer, pmxsavlst);
        return NERR_Success;
    }

    // Must build a tiny descriptor string for the single field
    // being setinfo'd.

    pszDescNew = RapParmNumDescriptor(pszDesc, nField, Both, TRUE);
    if (pszDescNew == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
    // If the buffer has been converted already, assume field no. is correct.
    NetpAssert (*pszDescNew != REM_UNSUPPORTED_FIELD);

    // Data for a string is inline, not referenced by a pointer in structure.
    if (*pszDescNew == REM_ASCIZ)
    {
        MxRestoreClientBuffer((BYTE *)ppbBuffer, pmxsavlst);
    }
    else
    {
        MxRestoreClientBuffer(*ppbBuffer, pmxsavlst);
    }

    NetpMemoryFree(pszDescNew); // Rap uses the Netp allocator
    return NERR_Success;
}

/*
 *  MxMapStringsToTStrings
 *
 *  This routine is used by code which is completely portable between
 *  Ascii and Unicode, rather than Unicode only. Given an arbitrary
 *  number of ASCII strings, they will be mapped to the portable TSTRING
 *  type. If this is UNICODE, memory will be allocated.
 *
 *  IN
 *      cStrings     - Count of strings provided.
 *      ...          - 2*cParam parameters of the form :
 *                          LPSTR pszSource, LPTSTR * pptszDest
 *
 *  OUT
 *      ...          - Each of the pptsz's above will have pointers to the
 *                     portable strings.
 *
 *  RETURNS
 *      Error code, 0 if successful
 *
 *  Upon return from Netapi, call MxFreeTStrings. If this is in UNICODE,
 *  the allocated strings will be freed.
 */

UINT
MxMapStringsToTStrings( UINT cStrings, ... )
{
    va_list pParam;
    LPSTR pszParamIn;
    LPTSTR * pptszParamOut;
    UINT iString;
    UINT err;

    va_start(pParam, cStrings);
    for ( iString = 0; iString < cStrings; iString++ )
    {
        pszParamIn = va_arg(pParam, LPSTR);
        pptszParamOut = va_arg(pParam, LPTSTR *);
        err = MxAllocTString(pszParamIn, pptszParamOut);
        if (err)
        {
            // Long way to rewind
            va_end(pParam);
            va_start(pParam, cStrings);
            for (; iString > 0; iString--)
            {
                pszParamIn = va_arg(pParam, LPSTR);
                pptszParamOut = va_arg(pParam, LPTSTR *);
                MxFreeTString(*pptszParamOut);
            }
            va_end(pParam);
            return err;
        }
    }

    va_end(pParam);
    return NERR_Success;
}

UINT
MxFreeTStrings( UINT cStrings, ... )
{
    va_list pptszParam;
    LPTSTR ptszParam;
    UINT iString;

    va_start(pptszParam, cStrings);
    for ( iString = 0; iString < cStrings; iString++ )
    {
        ptszParam = va_arg(pptszParam, LPTSTR);
        MxFreeTString(ptszParam);
    }

    va_end(pptszParam);
    return NERR_Success;
}
#endif /* 0 */