windows-nt-4.0/private/rpc/runtime/mtrt/dos/gethost.c

/*++

Copyright (c) 1992 Microsoft Corporation

Module Name:

    gethost.c

Abstract:

    This file contains the a version of GetHostByName for IPX/SPX for
    dos and windows.

Author:

    31 May 94   AlexMit

    15 Oct 94   JRoberts - changed to avoid using Novell headers and libs
--*/


#include "sysinc.h"
#include "rpc.h"
#include "rpctran.h"
#include "novell.h"
#include "gethost.h"
#include "netcons.h"
#include "ncb.h"

#ifdef WIN
#    include "windows.h"
#    define I_RpcAllocate                   (*(RpcRuntimeInfo->Allocate))
#    define I_RpcFree                       (*(RpcRuntimeInfo->Free))
#else
#    include "regalloc.h"
#endif

#define NAME_LEN           48
#define SAP_ECB_COUNT      5

/********************************************************************/

#ifdef WIN
#define CACHE_LENGTH 16
#else
#define CACHE_LENGTH 4
#endif

#define CACHE_EXPIRATION_TIME  (10 * 60 * 18)

struct
{
    char        Name[16];
    IPX_ADDRESS Address;
    unsigned long Time;
}
ServerCache[CACHE_LENGTH];

/********************************************************************/

extern int atoi(const char *);

/********************************************************************/
unsigned char chtob( unsigned char c1, unsigned char c2 )
/* Convert two hex digits (stored as ascii) into one byte. */

{
   unsigned char out;

   if (c1 >= '0' && c1 <= '9')
      out = (c1 - '0') << 4;
   else
   {
      if (c1 >= 'a' && c1 <= 'f')
     out = (c1 - 'a' + 10) << 4;
      else if (c1 >= 'A' && c1 <= 'F')
     out = (c1 - 'A' + 10) << 4;
      else
     out = 0;
   }

   if (c2 >= '0' && c2 <= '9')
      out |= c2 -'0';
   else
   {
      if (c2 >= 'a' && c2 <= 'f')
     out |= c2 - 'a' + 10;
      else if (c2 >= 'A' && c2 <= 'F')
     out |= c2 - 'A' + 10;
      else
         out = 0;
   }

   return out;
}

unsigned char chtob( unsigned char c1, unsigned char c2 );
RPC_STATUS    FromBindery( IPX_ADDRESS __RPC_FAR *host,
                           RPC_CHAR __RPC_FAR *name );

unsigned long
DosGetTickCount(
    )
/*++

Routine Description:

    Returns the number of ticks since the last time it was midnight.
    There are 65536 ticks per hour.

--*/

{
    _asm
    {
        push    bp
        push    si
        push    di

        xor     ax, ax
        int     0x1a
        mov     ax, dx
        mov     dx, cx

        pop     di
        pop     si
        pop     bp
    }
}

void
AddServerToCache(
    char PAPI * Name,
    IPX_ADDRESS PAPI * Address
    )
{
    unsigned i;

    //
    // If the server is already in the table, overwrite the existing entry.
    //
    for (i=0; i < CACHE_LENGTH; ++i)
        {
        if (0 == _fstrnicmp(ServerCache[i].Name, Name, 16))
            {
            break;
            }
        }

    //
    // If it is not in the table, try to find an empty entry to fill.
    //
    if (i == CACHE_LENGTH)
        {
        for (i=0; i < CACHE_LENGTH; ++i)
            {
            if (ServerCache[i].Name[0] == '\0')
                {
                break;
                }
            }
        }

    //
    // If all entries are full, overwrite the oldest one.
    //
    if (i == CACHE_LENGTH)
        {
        unsigned long BestTime = ~0;
        unsigned BestIndex;

        for (i=0; i < CACHE_LENGTH; ++i)
            {
            if (ServerCache[i].Time <= BestTime)
                {
                BestTime = ServerCache[i].Time;
                BestIndex = i;
                }
            }

        i = BestIndex;
        }

    //
    // Update the entry's information.
    //
    _fstrcpy(ServerCache[i].Name, Name);
    _fmemcpy(&ServerCache[i].Address, Address, sizeof(IPX_ADDRESS));

    ServerCache[i].Time = DosGetTickCount();
}

IPX_ADDRESS *
FindServerInCache(
    char PAPI * Name
    )
{
    unsigned i;

    for (i=0; i < CACHE_LENGTH; ++i)
        {
        if (0 == _fstrcmp(ServerCache[i].Name, Name))
            {
            return &ServerCache[i].Address;
            }
        }

    return 0;
}

void
CachedServerContacted(
    char PAPI * Name
    )
{
    unsigned i;

    for (i=0; i < CACHE_LENGTH; ++i)
        {
        if (0 == _fstrcmp(ServerCache[i].Name, Name))
            {
            ServerCache[i].Time = DosGetTickCount();
            break;
            }
        }
}

BOOL
CachedServerNotContacted(
    char PAPI * Name
    )
{
    BOOL Flushed = FALSE;
    unsigned i;

    for (i=0; i < CACHE_LENGTH; ++i)
        {
        if (0 == _fstrcmp(ServerCache[i].Name, Name))
            {
            if (DosGetTickCount() - ServerCache[i].Time > CACHE_EXPIRATION_TIME)
                {
                ServerCache[i].Name[0] = '\0';
                Flushed = TRUE;
                break;
                }
            }
        }

    return Flushed;
}

BOOL               PreferredServerFound = FALSE;
NETWARE_CONNECTION PreferredServer;


RPC_STATUS
SearchBindery(
    RPC_CHAR __RPC_FAR *name,
    IPX_ADDRESS __RPC_FAR *Address,
    unsigned BindingTimeout
    )
{
    char buffer[128];
    unsigned SapTickCount;
    unsigned RetryCount = 0;

    //
    //
    //
    if (FALSE == PreferredServerFound)
        {
reconnect:

        PreferredServer.TickLimit = 19;
        SapTickCount              = 19;

        if (BindingTimeout > RPC_C_BINDING_DEFAULT_TIMEOUT)
            {
            PreferredServer.TickLimit <<= BindingTimeout - RPC_C_BINDING_DEFAULT_TIMEOUT;
            SapTickCount              <<= BindingTimeout - RPC_C_BINDING_DEFAULT_TIMEOUT;
            }

        ConnectToAnyFileServer(&PreferredServer, SapTickCount);

        if (PreferredServer.ReturnCode || PreferredServer.ConnectionStatus)
            {
            DisconnectFromServer(&PreferredServer);
            PreferredServerFound = FALSE;
            return RPC_S_SERVER_UNAVAILABLE;
            }

        PreferredServerFound = TRUE;
        }

    //
    // Read from the bindery.
    //
    ReadPropertyValue(&PreferredServer,
                      name,
                      RPC_SAP_TYPE,
                      "NET_ADDRESS",
                      1,
                      buffer,
                      0,
                      0
                      );

    if (PreferredServer.ReturnCode)
        {
        DisconnectFromServer(&PreferredServer);
        PreferredServerFound = FALSE;

        if (RetryCount++)
            {
            return RPC_S_SERVER_UNAVAILABLE;
            }
        else
            {
            goto reconnect;
            }
        }

    //
    // Save the host address.
    //
    _fmemcpy( Address, buffer, 10 );

    DisconnectFromServer(&PreferredServer);
    return RPC_S_OK;
}


/********************************************************************/
RPC_STATUS
SearchWithSap(
    RPC_CHAR __RPC_FAR *name,
    IPX_ADDRESS __RPC_FAR *host,
    unsigned Timeout

#ifdef WIN
                  , RPC_CLIENT_RUNTIME_INFO PAPI * RpcRuntimeInfo
#endif
                  )
{
    WORD            start;
    unsigned        SapSocket;
    int             result;
    int             i;
    int             retry;

    struct
    {
        ECB             ecb;
        IPX_HEADER      ipx;
        SAP_REQUEST     req;
    } send;

    struct SAP_RESPONSE_ECB
    {
        ECB             ecb;
        IPX_HEADER      ipx;
        SAP_RESPONSE    resp;
    }
    __RPC_FAR * mem;

    RPC_STATUS     status = RPC_S_SERVER_UNAVAILABLE;

    //
    // The base timeout is two seconds; max is a minute.
    //
    if (Timeout <= RPC_C_BINDING_DEFAULT_TIMEOUT)
        {
        Timeout = 18 * 2;
        }
    else
        {
        Timeout = (18 * 2) << (Timeout - RPC_C_BINDING_DEFAULT_TIMEOUT);
        }

    result = IPXOpenSocket(TASKID_C &SapSocket, 0);
    if (result != 0)
        return RPC_S_OUT_OF_RESOURCES;

    // Allocate memory for ECBs.
#ifdef WIN
    mem = I_RpcAllocate( SAP_ECB_COUNT * sizeof(*mem) );
#else
    mem = I_RpcRegisteredBufferAllocate( SAP_ECB_COUNT * sizeof(*mem) );
#endif

    if (mem == NULL)
        {
        status = RPC_S_OUT_OF_MEMORY;
        goto cleanup;
        }

    _fmemset( mem, 0, SAP_ECB_COUNT * sizeof(mem) );

    //
    // Post some ECBs.
    //
    for (i = 0; i < SAP_ECB_COUNT; i++)
        {
        SetupEcb(&mem[i].ecb, SapSocket, sizeof(SAP_RESPONSE));
        IPXListenForPacket(TASKID_C  &mem[i].ecb );
        }

    //
    // We want to send a SAP request and scan responses for the server
    // that we want.  We transmit the request up to two times because
    // servers sometimes miss a single broadcast.
    //
    for (retry = 0; retry < 2 ; ++retry)
        {
        send.ipx.PacketType = IPX_PACKET_TYPE;
        send.ipx.Destination.Network = 0;
        send.ipx.Destination.Socket  = SAP_SOCKET;
        _fmemset( send.ipx.Destination.Node, 0xff, sizeof(send.ipx.Destination.Node) );

        SetupEcb(&send.ecb, SapSocket, sizeof(send));
        _fmemset( send.ecb.immediateAddress, 0xff, sizeof(send.ecb.immediateAddress) );

        // Send the data.

        send.req.QueryType  = SAP_GENERAL_QUERY;
        send.req.ServerType = RPC_SAP_TYPE_SWAPPED;

        IPXSendPacket(TASKID_C &send.ecb );

        while (send.ecb.inUseFlag)
            IPXRelinquishControl();

        // Verify that the send was successful.

        if (send.ecb.completionCode)
            {
            goto cleanup;
            }

        //
        // Get packets till timeout is returned or a good reply is returned.
        //
        start = IPXGetIntervalMarker(TASKID);
        do
            {
            struct SAP_RESPONSE_ECB __RPC_FAR * curr;

            for (curr = mem; curr < mem + SAP_ECB_COUNT; curr++)
                {
                if (curr->ecb.inUseFlag == 0)
                    {
                    if (curr->ecb.completionCode == 0x00)
                        {
                        // Verify the packet.
                        //
                        curr->ipx.Length = ByteSwapShort( curr->ipx.Length );
                        curr->ipx.Length -= sizeof(IPX_HEADER);

                        if (curr->ipx.Source.Socket == SAP_SOCKET     &&
                            curr->ipx.Length >= sizeof (SAP_RESPONSE) &&
                            curr->resp.PacketType == SAP_GENERAL_RESPONSE )
                            {
                            unsigned num_entry = curr->ipx.Length / sizeof(SAP_ENTRY);
                            for (i = 0; i < num_entry; i++)
                                {
                                if (0 == _fstrnicmp( name, curr->resp.Entries[i].Name, NAME_LEN))
                                    {
                                    // Only copy the network and node numbers, not the socket.
                                    //
                                    _fmemcpy( host, &curr->resp.Entries[i].Address, 10 );
                                    status = RPC_S_OK;
                                    goto cleanup;
                                    }
                                }
                            }
                        }
                    //
                    // Repost the receive.
                    //
                    IPXListenForPacket( TASKID_C &curr->ecb );
                    }
                }
            IPXRelinquishControl();
            }
        while (IPXGetIntervalMarker(TASKID) - start < Timeout);
        }

cleanup:

    //
    // Cancel the ECBs.
    //
    if (mem)
        {
        for (i = 0; i < SAP_ECB_COUNT; i++)
            {
            if (mem[i].ecb.inUseFlag)
                {
                IPXCancelEvent( TASKID_C &mem[i].ecb );
                while (mem[i].ecb.inUseFlag)
                    {
                    IPXRelinquishControl();
                    }
                }
            }

        //
        // Free the memory.
        //
#ifdef WIN
        I_RpcFree( mem );
#else
        I_RpcRegisteredBufferFree( mem );
#endif
        }

    IPXCloseSocket(TASKID_C SapSocket);

    return status;
}

/********************************************************************/
RPC_STATUS
IpxGetHostByName(
    RPC_CHAR    __RPC_FAR * name,
    IPX_ADDRESS __RPC_FAR * Address,
    RPC_CHAR    __RPC_FAR * endpoint,
    unsigned                Timeout
#ifdef WIN
    , RPC_CLIENT_RUNTIME_INFO * RpcClientRuntimeInfo
#endif
    )
{
    RPC_STATUS status;
    int        i;
    int        length;
    IPX_ADDRESS * CachedAddress;

    // Set the endpoint.
    Address->Socket = ByteSwapShort(atoi(endpoint));

    // Fail if no address was specified.
    if (name == NULL || name[0] == '\0')
        return RPC_S_SERVER_UNAVAILABLE;

    // If the name starts with ~, convert it directly to a network address.
    length = _fstrlen(name);
    if (name[0] == '~')
        {
        unsigned char __RPC_FAR * Temp;

        if (length != 21)
            return RPC_S_INVALID_NET_ADDR;

        Temp = (unsigned char __RPC_FAR *) &Address->Network;
        for (i = 0; i < 4; i++)
            {
            Temp[i] = chtob( name[2*i + 1], name[2*i + 2] );
            }

        Temp = (unsigned char __RPC_FAR *) Address->Node;
        for (i = 0; i < 6; i++)
            {
            Temp[i] = chtob( name[2*i + 9], name[2*i + 10] );
            }

        return RPC_S_OK;
        }

    if (length > 15)
        {
        return RPC_S_INVALID_NET_ADDR;
        }

    CachedAddress = FindServerInCache(name);
    if (CachedAddress)
        {
        _fmemcpy(Address, CachedAddress, 10);
        return RPC_S_OK;
        }

    // Try the bindery.
    status = SearchBindery(name, Address, Timeout);
    if (status && !PreferredServerFound)
        {
        status = SearchWithSap(name,
                      Address,
                      Timeout
#ifdef WIN
                      , RpcClientRuntimeInfo
#endif
                      );
        }

    if (!status)
        {
        AddServerToCache(name, Address);
        }

    return status;
}