windows-nt-4.0/private/rpc/runtime/mtrt/win32c/netbcom.c

/*++

Copyright (c) 1993 Microsoft Corporation

Module Name:

    netbcom.c

Abstract:

    NetBios transport common code between server and client.

Author:

    Steven Zeck (stevez) 2/12/92

    Danny Glasser (dannygl) 3/1/93

--*/

#include "NetBCom.h"

// The maximum value of a lana number
#define MAX_LANA_NUMBER     UCHAR_MAX

// This the netbios name of this (self) machine.
// NOTE:  We assume one-byte characters here

unsigned char MachineName[NCBNAMSZ];
size_t MachineNameLengthUnpadded;

CRITICAL_SECTION NetBiosMutex;

PROTOCOL_MAP ProtoToLana[MAX_LANA];



#define MAX_MAP_ENTRIES 20

void RPC_ENTRY
InitNBMutex (
    void
    )
/*++

Routine Description:

    This function initializes the critical section object used to serialize
    access to the global data structures.  It is called by both the client
    and server DLLs (once by each), both of which use this critical section
    object.

    Note: There is a small potential race condition in which the client and
    server could both call this function at the same time.  Given the design
    of the RPC runtime, however, this is highly unlikely if not impossible.
    Even if it were to occur, it would probably not be harmful.
--*/
{
#ifdef WIN32RPC
    static char AlreadyDone = 0;

    if (! AlreadyDone)
        {
        AlreadyDone = 1;

        InitializeCriticalSection(&NetBiosMutex);
        }
#endif // WIN32RPC
}

RPC_STATUS
MapProtocol(
    IN RPC_CHAR *ProtoSeq,
    IN int DriverNumber,
    OUT PPROTOCOL_MAP *ProtocolEntry
    )

/*++

Routine Description:

    This function maps a protocol string into a protocol map entry.

    In the non-NT versions, it looks up the information dynamically
    in the registry.  In the NT version, the registry information is
    pre-loaded

Arguments:

    ProtoSeq - the protocol sequence that we want to map

    DriverNumber - the logical driver number for the protocol.

    ProtocolEntry - pointer to place to return the results.

Return Value:

    RPC_S_OK, RPC_S_OUT_OF_RESOURCES, RPC_S_INVALID_ENDPOINT_FORMAT

    The output pointer is set to the corresponding entry when found.

--*/
{
    long status;
    int i;
    HKEY RegHandle;
    char Protocol[40];
    char LanaString[10];
    DWORD dtype;
    long BufferLength = sizeof(LanaString);

    // Copy the possible unicode protocol string to ascii.

    for (i = 0; (Protocol[i] = (char) ProtoSeq[i]) && i < sizeof(Protocol); i++) ;

    // Add the logical driver number to the protocol string.  This
    // allows multiple drivers (net cards) to be attached to the same
    // logical protocol.

    Protocol[i] = (char) ('0' + DriverNumber);
    Protocol[i+1] = 0;

    // First look in the proto sequences that we have already mapped.

    for (i = 0; ProtocolTable[i].ProtoSeq && i < MAX_LANA; i++)
        {
        // If found, set the output pointer.

        if (strcmp(ProtocolTable[i].ProtoSeq, Protocol) == 0)
            {
            *ProtocolEntry = &ProtocolTable[i];
            return(RPC_S_OK);
            }
        }

    if (i >= MAX_LANA)
        return(RPC_S_PROTSEQ_NOT_FOUND);

    status = RegOpenKeyEx(RPC_REG_ROOT, REG_NETBIOS, 0, KEY_READ, &RegHandle);

    if (status)
        return(RPC_S_PROTSEQ_NOT_FOUND);

    status = RegQueryValueExA(RegHandle, Protocol, 0, &dtype, LanaString, &BufferLength);

    RegCloseKey(RegHandle);

    if (status || ! (*LanaString >= '0' && *LanaString <= '9'))
        return(RPC_S_PROTSEQ_NOT_FOUND);

    // Now we have a Lana number for the protocol sequence.  Put this
    // info in the protocol to lana mapping structure.

    if (! (ProtocolTable[i].ProtoSeq
           = (char *) I_RpcAllocate(strlen(Protocol)+1)) )
        {
        return(RPC_S_OUT_OF_RESOURCES);
        }

    strcpy(ProtocolTable[i].ProtoSeq, Protocol);
    ProtocolTable[i].Lana = (unsigned char) (*LanaString - '0');

    *ProtocolEntry = &ProtocolTable[i];

    return(RPC_S_OK);
}


RPC_STATUS RPC_ENTRY
MapErrorCode (
    IN ERROR_TABLE * MapTable,
    IN RPC_OS_ERROR Status,
    IN RPC_STATUS DefaultStatus
    )
/*++

Routine Description:

    This function maps a OS specific error code into a generic RPC
    status code.  The ERROR_TABLE is an unordered list of pairs, with
    a value of 0 terminating the table.  So don't try to translate a
    0 OS_ERROR.

    You will see this routine called , with the return value ignored.
    This is done when we don't need the translated error code, but
    want to check for unexpected failures.

Arguments:

    MapTable - The table to OS codes to RPC_STATUS codes.

    Status - The OS specific error that we wish to map.

    DefaultStatus - The status to return if none of the codes match.
        We will ASSERT in the debug version if we have to take this action.

Return Value:

    The translated error code if there is match, else the value
    of DefaultStatus.

--*/
{
    int TableIndex;

    ASSERT(MapTable);

#ifdef DEBUGRPC
    PrintToDebugger("RPC NetBIOS Map Status %x(%d)\n", Status, DefaultStatus);
#endif

    for (TableIndex = 0; MapTable[TableIndex].OScode != 0; TableIndex++)
        if (MapTable[TableIndex].OScode == Status)
            return (MapTable[TableIndex].RpcStatus);

    return (DefaultStatus);
}


int
SetupNetBios (
    IN RPC_CHAR * RpcProtocolSequence
    )

/*++

Routine Description:

    Loadable transport initialization function.  Get the machine name
    of this workstation into MachineName and perform other OS specific
    initiailization.

Arguments:

    RpcProtocolSequence - the protocol string that mapped to this library.

Returns:

    TRUE if the initialization was OK.

--*/

{
    int i;
    BOOLEAN BooleanStatus;
    DWORD Status;
    DWORD ComputerNameLength = MAX_COMPUTERNAME_LENGTH + 1;
    unsigned char ComputerName[MAX_COMPUTERNAME_LENGTH + 1];

    Status = GetComputerNameA(ComputerName, &ComputerNameLength);

    ASSERT(Status == TRUE);

    _strupr(ComputerName);

    // Store padded machine name (and save unpadded length)

    MachineNameLengthUnpadded = strlen(ComputerName);
    memcpy(MachineName, ComputerName, MachineNameLengthUnpadded);
    memset(MachineName + MachineNameLengthUnpadded,
           NETBIOS_NAME_PAD_BYTE,
           sizeof(MachineName) - MachineNameLengthUnpadded);

    ASSERT(MachineNameLengthUnpadded < sizeof(MachineName));

    PUNUSED(RpcProtocolSequence);

    return(1);
}



UCHAR RPC_ENTRY
AdapterReset (
    IN PPROTOCOL_MAP ProtocolEntry
    )
/*++

Routine Description:

    This function is used by both the client and server NetBIOS transports
    to submit the RESET NCB for a process, as is required by NetBIOS on NT.

    We need to perform this in a single place to allow a process to act
    as both an RPC client and server over NetBIOS.  Otherwise, both the
    client and server transports would submit RESETs and the second one
    would destroy the state of the first.

Arguments:

    ProtocolEntry - This is the entry in the protocol map for the adapter
        to be reset.

Returns:

    The return code of the RESET NCB, if it's submitted.

    0 if the RESET has already occurred.
--*/
{
    unsigned char status = 0;

    // Make sure that no other threads are accessing this function
    CRITICAL_ENTER();

    // Perform the reset, if necessary
    if (! ProtocolEntry->ResetDone)
        {
        NCB theNCB;

        memset(&theNCB, 0 , sizeof(theNCB));
        theNCB.ncb_lana_num = ProtocolEntry->Lana;

        // The values are needed for the server
        theNCB.ncb_callname[0] = 254;       // max sessions
        theNCB.ncb_callname[1] = 64;        // max commands
        theNCB.ncb_callname[2] = 32;        // max names

        status = execNCB(NCBRESET, &theNCB);

        // If the NCB was successfully invoked, get the status from the
        // completed NCB itself.
        if (status == 0)
            {
            status = theNCB.ncb_retcode;
            }

        // Set the flag so the reset is performed only once (per process).
        if (status == 0)
            {
            ProtocolEntry->ResetDone = 1;
            }
        }

    // Allow other threads to run again
    CRITICAL_LEAVE();

    return status;
}


unsigned char RPC_ENTRY
execNCB(
    IN unsigned char command,
    IN OUT NCB *pNCB
    )
/*++

Routine Description:

    Pass an NCB to the NetBios software to execute.  This function hides
    the differences of the OS from the other parts of the driver.

Arguments:

    command - command to execute

    pNCB - NCB to act on

Returns:

    The result of ncb_retcode field from the NCB executed.

--*/
{
    unsigned char result;

    pNCB->ncb_command = command;

#if defined(WIN32RPC)
    result = Netbios(pNCB);

#elif defined(WIN)
    // If the command is an async one, call the transport helper
    // functions to corrdinate the waiting.

   _asm
        {
        les  bx,pNCB
        call NetBiosCall

        mov  al,es:[bx+1]
        mov  result,al
        }

    if (result == NRC_PENDING)
        result = 0;

#else // DOS
    _asm {
	les	bx, pNCB
        int     05ch            ; call NetBios Directly
        mov     result,al
    };

    if (result == NRC_PENDING)
        result = 0;

#endif

    return(result);
}