path: root/private/net/svcdlls/nwsap/server/sdmd.c

/*++

Copyright (c) 1994  Microsoft Corporation
Copyright (c) 1993  Micro Computer Systems, Inc.

Module Name:

    net\svcdlls\nwsap\server\sdmd.c

Abstract:

    This file contains the database routines for storing and
    accessing the SAP records.

    SDMD = Specialized Dynamic Memory Database

Author:

    Brian Walker (MCS) 06-15-1993

Revision History:

--*/

#include "precomp.h"
#pragma hdrstop

/** **/

INT SdmdCurrentTime;
PSAP_RECORD SdmdTablePtr;
SDMD_LIST_ENTRY SdmdLists[SAP_NUM_LISTINDEX];
PSDMD_LIST_ENTRY SdmdNameHashTable;

/** Internal Function Prototypes **/

PSAP_RECORD
SdmdGetFreeEntry(
    VOID);


/*++
*******************************************************************
        S a p I n i t S d m d

Routine Description:

        This routine is called to initialize the database.

Arguments:

        None

Return Value:

        0 = OK
        Else = Error
*******************************************************************
--*/

INT
SapInitSdmd(
    VOID)
{
    PSAP_RECORD Entry;
    PSDMD_LIST_ENTRY ListHead;
    PSAP_RECORD HeadEntry;
    INT i;
    INT j;

    /** Set current time to start **/

    SdmdCurrentTime = 0;

    /** Initialize all the lists **/

    for (i = 0 ; i < SAP_NUM_LISTINDEX ; i++)
        SdmdInitializeListHead(i);

    /** Initialize the Critical Section we use for synch. **/

    SdmdSynchEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
    if (SdmdSynchEvent == NULL) {
        SapError = 0;
        SapEventId = NWSAP_EVENT_SDMDEVENT_FAIL;
        return -1;
    }
    SdmdLockCount = 0;

    /** Allocate the buffer for the database table **/

    SdmdTablePtr = (PSAP_RECORD)SAP_MALLOC(SapNumArrayEntries * SAP_RECORD_SIZE, "SdmdInit");
    if (SdmdTablePtr == NULL) {
        SapError = 0;
        SapEventId = NWSAP_EVENT_TABLE_MALLOC_FAILED;
        return -1;
    }

    /** Allocate the hash table **/

    SdmdNameHashTable = (PSDMD_LIST_ENTRY)SAP_MALLOC(SapHashTableSize * sizeof(SDMD_LIST_ENTRY), "SdmdHashInit");
    if (SdmdNameHashTable == NULL) {
        SapError = 0;
        SapEventId = NWSAP_EVENT_HASHTABLE_MALLOC_FAILED;
        return -1;
    }

    /** Initialize the hash list **/

    ListHead = SdmdNameHashTable;
    for (i = 0 ; i < SapHashTableSize ; i++,ListHead++) {
        ListHead->Flink = SDMD_ENDOFLIST;
        ListHead->Blink = SDMD_ENDOFLIST;
        ListHead->ListIndex = i;
    }

    /**
        This list of free entries is kept on the Server Type list
        with the type being set to 0xFFFF.  This way to find a
        free entry - just go look at the tail of the Server Type
        list.
    **/

    Entry = SdmdTablePtr;
    for (i = 0 ; i < SapNumArrayEntries ; i++,Entry++) {

        /** Init the Index number **/

        Entry->Index = i;

        /** Init the links for this table **/

        for (j = 0 ; j < SAP_NUM_LISTINDEX ; j++) {
            Entry->Links[j].Flink = SDMD_ENDOFLIST;
            Entry->Links[j].Blink = SDMD_ENDOFLIST;
            Entry->Links[j].ListIndex = j;
        }

        /** Mark this as a free entry **/

        Entry->ServType  = 0xFFFF;
        Entry->HashIndex = -1;

        /**
            Add this to the free list.  The first entry goes on the
            tail of the TYPE list.  Each other entry goes under the
            first entry.
        **/

        if (i == 0) {
            SdmdInsertTailList(SAP_TYPELIST_INDEX, Entry);
            HeadEntry = Entry;
            HeadEntry->HeadIndex = SDMD_ENDOFLIST;
        }
        else {
            SdmdInsertTailSubList(HeadEntry, SAP_SUBLIST_INDEX, Entry);
        }
    }

    /** All Done OK **/

    return 0;
}


/*++
*******************************************************************
        S a p S h u t d o w n S d m d

Routine Description:

        The SAP Agent is stopping - clean up the database.  All threads
        are stopped when we get here.

Arguments:

        None

Return Value:

        Nothing
*******************************************************************
--*/

VOID
SapShutdownSdmd(
    VOID)
{
    /** Free the table **/

    if (SdmdTablePtr) {
        SAP_FREE(SdmdTablePtr, "SDMD Shutdown - SAP Table");
    }

    if (SdmdNameHashTable) {
        SAP_FREE(SdmdNameHashTable, "SDMD Shutdown, HASH Table");
    }

    /**
        Clean up the Synchronization.  The critical section
        is initialized after the SynchEvent is created.  This
        way if InitSdmd never got called, we don't die if we close down.
    **/

    if (SdmdSynchEvent) {
        CloseHandle(SdmdSynchEvent);
    }

    /** All Done **/

    return;
}


/*++
*******************************************************************
        S d m d G e t F r e e E n t r y

Routine Description:

        This routine gets an entry from the free list.  If no
        entry is available, it grows the table.  The WRITERS
        lock should be held when calling this routine

Arguments:

        None

Return Value:

        Pointer to an entry to use.
        NULL = There are no free entries.  We tried
               to increase the size of the table, but the
               allocation failed.


        IMPORTANT:  When calling this function, make sure that
        any pointers you have into the database are updated after
        the call.  This call can move the database.
*******************************************************************
--*/

PSAP_RECORD
SdmdGetFreeEntry(
    VOID)
{
    PSAP_RECORD Entry;
    PSAP_RECORD HeadEntry;
    PSAP_RECORD Newtable;
    INT Newnum;
    INT i;
    INT j;

    /**
        Get ptr to the last entry in the type list.  The
        type list can never be empty so there will always
        be something in here.
    **/

    HeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Blink);

    /** If this is free (type == 0xFFFF) - then return the entry **/

    if (HeadEntry->ServType == 0xFFFF) {

        /**
            If there are no entries in this list - then we need to go
            make more entries.

            Else - we take an entry out of the list of free ones.
        **/

        if (HeadEntry->Links[SAP_SUBLIST_INDEX].Flink != SDMD_ENDOFLIST) {
            Entry = SdmdRemoveTailSubEntryList(HeadEntry, SAP_SUBLIST_INDEX);
        }
        else
            Entry = NULL;

        /** If we have an entry - return it **/

        if (Entry) {
            Entry->Links[SAP_SUBLIST_INDEX].Flink = SDMD_ENDOFLIST;
            Entry->Links[SAP_SUBLIST_INDEX].Blink = SDMD_ENDOFLIST;
            Entry->HeadIndex = SDMD_ENDOFLIST;
            Entry->HashIndex = -1;  /* Not in hash table */
            return Entry;
        }
    }

    /**
        There are no free entries - we must grow the list.

        We grow the list by 1 1/2 times its current size.
    **/

    /** Allocate the buffer for how many entries **/

    Newnum = SapNumArrayEntries * 3 / 2;
    IF_DEBUG(SDMD) {
        SS_PRINT(("GROWING TABLE: oldnum = %d, Newnum = %d\n", SapNumArrayEntries, Newnum));
    }

    Newtable = (PSAP_RECORD)SAP_MALLOC(Newnum * SAP_RECORD_SIZE, "SdmdGrow");
    if (Newtable == NULL) {
        IF_DEBUG(ERRORS) {
            SS_PRINT(("GROWING: Allocation failed\n"));
        }
        return NULL;
    }

    /** Copy the old table into the new place **/

    memcpy(Newtable, SdmdTablePtr, SapNumArrayEntries * SAP_RECORD_SIZE);

    /** Free the current table **/

    SAP_FREE(SdmdTablePtr, "Free old table on grow");

    /** Set the new pointer **/

    SdmdTablePtr = Newtable;

    /** Get new ptr to the head entry of the free list **/

    HeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Blink);
    SS_ASSERT(HeadEntry);

    /** Link up all the new entries into the free list. **/

    Entry = SdmdTablePtr + SapNumArrayEntries;
    for (i = SapNumArrayEntries ; i < Newnum ; i++,Entry++) {

        /** Init the Index number **/

        Entry->Index = i;

        /** Init the links for this table **/

        for (j = 0 ; j < SAP_NUM_LISTINDEX ; j++) {
            Entry->Links[j].Flink = SDMD_ENDOFLIST;
            Entry->Links[j].Blink = SDMD_ENDOFLIST;
            Entry->Links[j].ListIndex = j;
        }

        /** Add entry to free list **/

        Entry->ServType  = 0xFFFF;
        Entry->HashIndex = -1;

        /**
            If this is the last entry in the list - do not add
            it to the free list.  We will return it as the
            new entry to use.
        **/

        if (i == (Newnum - 1))
            break;

        /**
            We already have a head entry for the free list.  So we will
            just add these entries to the end of the free sub list.
        **/

        SdmdInsertTailSubList(HeadEntry, SAP_SUBLIST_INDEX, Entry);
    }

    /** Set the new number **/

    SapNumArrayEntries = Newnum;

    /** Return ptr to the new entry **/

    Entry->HeadIndex = SDMD_ENDOFLIST;
    return Entry;
}


/*++
*******************************************************************
        S d m d F r e e E n t r y

Routine Description:

        Free the given record back to the free pool
        The WRITERS lock must be held when calling here.

Arguments:

        Entry = Ptr to the entry to free

Return Value:

        Nothing
*******************************************************************
--*/

VOID
SdmdFreeEntry(
    PSAP_RECORD Entry)
{
    PSAP_RECORD HeadEntry;
    PSAP_RECORD FreeHeadEntry;

    /** Save ptr to current head entry **/

    HeadEntry = GETPTRFROMINDEX(Entry->HeadIndex);

    /**
        Remove the entry from all of it's lists.  If we do not have
        a head entry - then we have not been put in any lists.
    **/

    if (HeadEntry) {
        SdmdRemoveEntryList(SAP_TIMELIST_INDEX, Entry);
        SdmdRemoveSubEntryList(HeadEntry, SAP_SUBLIST_INDEX, Entry);
    }

    /** If in hash table - take it out **/

    if (Entry->HashIndex != -1) {

        PSDMD_LIST_ENTRY ListHead;

        /** Make sure the hash index is good **/

        SS_ASSERT(Entry->HashIndex < SapHashTableSize);

        /** Get ptr to the list head for the hash index **/

        ListHead = SdmdNameHashTable + Entry->HashIndex;

        /** Remove the entry from the hash **/

        SdmdRemoveEntryFromHash(ListHead, Entry);
    }
    else {
        SS_PRINT(("SdmdFreeEntry: HashEntry for Entry 0x%lx is -1\n", Entry));
    }

    /** Change the type to free **/

    Entry->ServType  = 0xFFFF;
    Entry->HashIndex = -1;

    /**
        Put this on the end of the type list.  If there
        are no free entries - make this the first one.  If there
        are, then just put this on the end of those.
    **/

    FreeHeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Blink);
    SS_ASSERT(FreeHeadEntry);   /* SHOULD NEVER BE NULL HERE */
    SdmdInsertTailSubList(FreeHeadEntry, SAP_SUBLIST_INDEX, Entry);

    /**
        If this entry was in a sub list and the sublist is empty,
        then we want to free the head entry.
    **/

    if (HeadEntry) {

        if (HeadEntry->Links[SAP_SUBLIST_INDEX].Flink == SDMD_ENDOFLIST) {
            IF_DEBUG(SDMD) {
                SS_PRINT(("NWSAP: Freeing Head entry 0x%lx\n", HeadEntry));
            }

            /** Take it out of the list **/

            SdmdRemoveEntryList(SAP_TYPELIST_INDEX, HeadEntry);

            /** Put it on the free list **/

            HeadEntry->ServType = 0xFFFF;
            SdmdInsertTailSubList(FreeHeadEntry, SAP_SUBLIST_INDEX, HeadEntry);
        }
    }

    /** All Done **/

    return;
}


/*++
*******************************************************************
        S d m d U p d a t e E n t r y

Routine Description:

        This is called to update an entry in the sap table.  If
        the entry does not exists - then it will be created.

Arguments:

        ServerName     = 48 byte name of the server
        ServerType     = Object type of the server (Host Order)
        ServerAddr     = 12 byte address of the server
        ServerHopCount = Hop count to get to the server (Host Order)
        CardNumber     = Card Number this came in on
                         CARDRET_MYSELF   = 0xFE = Internal Server advertised by us
                         CARDRET_INTERNAL = 0xFF = Internal Server not advertised by us.
        SendersAddress = Node address of who sent the packet

Return Value:

        0  = Entry was updated
        1  = Entry was created
        2  = Name is zero length or too long
        3  = Invalid Object type
        4  = IPX Address is our own but service is not internal
        -1 = Entry could not be created
        -2 = Lock error
*******************************************************************
--*/

INT
SdmdUpdateEntry(
    IN PUCHAR ServerName,
    IN USHORT ServerType,
    IN PUCHAR ServerAddr,
    IN USHORT ServerHopCount,
    IN INT    CardNumber,
    IN PUCHAR SendersAddress,
    IN BOOL   WanFlag)
{
    PSAP_RECORD Entry;
    PSAP_RECORD HeadEntry;
    PSDMD_LIST_ENTRY ListHead;
    PUCHAR Ptr;
    INT HashIndex;
    INT BackIndex;
    INT HeadBackIndex;
    INT EntryIndex;
    INT Length;
    INT rc;
    UCHAR Internal;

    /**
        Cannot have an FFFF as an object type.  If they pass an invalid
        object type - then just bail out here.
    **/

    if (ServerType == 0xFFFF)
        return 3;

    /**
        Check if this is internal or not.  Set the
        flag accordingly.
    **/

    if (CardNumber == CARDRET_INTERNAL) {
        if (SapRespondForInternal)
            Internal = 1;
        else
            Internal = 0;
        CardNumber = 0;
    }
    else if (CardNumber == CARDRET_MYSELF) {
        Internal = 2;
        CardNumber = 0;
    }
    else {

        Internal = 0;

        //
        //  check if the address of the service is ours... if so, then a
        //  router has send in one of our own services since we rebooted.
        //

        if ( (memcmp(  ServerAddr,
                       SapNetNum,
                       SAP_NET_LEN) == 0) &&
             (memcmp(  ServerAddr+SAP_NET_LEN,
                       SapNodeNum,
                       SAP_NODE_LEN) == 0) ) {

            IF_DEBUG(SDMD) {
                SS_PRINT(("NWSAP: SdmdUpdateEntry: entry from net is for our address!\n"));
            }
            return 4;
        }
    }

    /**
        If name starts with 0 - don't save it.  The Novell docs
        imply that all names should be ASCIIZ.  There have been a couple
        of cases of a SAP coming out that has a name of 0.  A Novell 3.11
        server does not save the name so we will not either.
    **/

    if (*ServerName == '\0')
        return 2;

    /**
        Make sure the name is not too long.  The name should be
        a max of 47 chars long (48 including the ending 0).  If
        the name is too long, then it is tossed.

        Also make sure to uppercase the name.

        This is a combo strlen/strupr routine.
    **/

    Ptr = ServerName;
    Length = SAP_OBJNAME_LEN;
    while (Length) {

        /** If at end - break **/

        if (*Ptr == '\0')       /* If found end - break */
            break;

        /** Uppercase this letter **/

        *Ptr = (UCHAR)toupper(*Ptr);

        /** If at end - break out **/

        if (Length == 1) {
            Length = 0;
            break;
        }

        /** Goto the next byte **/

        Ptr++;
        Length--;
    }

    /** If we did not find the 0 - return error **/

    if (!Length && (*Ptr != '\0'))
        return 2;

    /** Lock the database **/

    ACQUIRE_WRITERS_LOCK(rc, "Update Entry");

    /** If error on acquire lock - just leave **/

    if (rc) {

        IF_DEBUG(ERRORS) {
            SS_PRINT(("NWSAP: SdmdUpdateEntry: Error acquiring writers lock\n"));
        }

        return -2;
    }

    /**
        Find the name and type in the hash list.
    **/

    HashIndex = SdmdCalcHash(ServerName);

    /** Get ptr to the list head for the hash index **/

    ListHead = SdmdNameHashTable + HashIndex;

    /** Find the name in the list **/

    BackIndex = SDMD_ENDOFLIST;
    Entry = GETPTRFROMINDEX(ListHead->Flink);
    while (Entry) {

        /** Make sure the Server Type is correct **/

        if (Entry->ServType == ServerType) {

            /** Check if this is the name **/

            rc = SAP_NAMECMP(Entry->ServName, ServerName);

            /** If this is it - break out to handle it **/

            if (!rc)
                break;

            /**
                Since the names are stored in alphabetical order, if we
                get past the name we are looking for, then we can just
                give up now instead of having to search the whole list.
            **/

            if (rc > 0) {
                Entry = NULL;
                break;
            }
        }

        /** Goto the next entry **/

        BackIndex = Entry->Index;
        Entry = GETPTRFROMINDEX(Entry->Links[SAP_HASHLIST_INDEX].Flink);
    }

    /** If we found the entry - Update it **/

    if (Entry) {

        /**
            If the hop count is 16, then this server is going
            down.  We set the hopcount to 16 so that the next
            time we advertise - we will toss the entry after we
            tell everyone about the fact that this server is down.
        **/

        if (ServerHopCount >= 16) {

            /**
                If from this same advertiser - then mark for deletion.
                If this was from another advertiser, just ignore it
                because we have kept the better route and are ignoring
                all other routes to this server.
            **/

            if ((CardNumber == Entry->CardNumber) &&
                (!memcmp(SendersAddress, Entry->Advertiser, SAP_NODE_LEN))) {

                Entry->HopCount = 16;
                Entry->Changed  = TRUE;
                SapChanged = TRUE;
            }
            RELEASE_WRITERS_LOCK("Update Entry X1");
            return 0;
        }

        /**
            If this is from the same advertiser, then update the
            entry.  We are keeping the best route.  If we get
            an advertise from someone else for the same name
            (another router, we will check below if it is a better
            router).  If the hop count for this entry is 16, we update
            regardless of who sent it since it a good route.
        **/

        if ( ((CardNumber == Entry->CardNumber) &&
             (!memcmp(SendersAddress, Entry->Advertiser, SAP_NODE_LEN)))

                ||

            (Entry->HopCount == 16)


             ) {

            /** Set the new time on this entry **/

            Entry->Timeout = SdmdCurrentTime + SapTimeoutInterval;

            /**
                If any information changed - then update the information
                and set the changed flag.  This includes if a service
                was marked for deletion (16 hops) and now another route
                has been found.
            **/

            if (Entry->HopCount == 16) {

                /**
                    This is another route for a service we think
                    is going down.  We change over to the new
                    advertiser here.
                **/

                SAP_COPY_ADDRESS(Entry->ServAddress, ServerAddr);
                memcpy(Entry->Advertiser, SendersAddress, SAP_NODE_LEN);
                Entry->HopCount   = ServerHopCount;
                Entry->CardNumber = CardNumber;
                Entry->Internal   = Internal;
                Entry->FromWan    = WanFlag;

                Entry->Changed = TRUE;
                SapChanged     = TRUE;
            }
            else if ((Entry->HopCount != ServerHopCount) ||
                     (memcmp(Entry->ServAddress, ServerAddr, SAP_ADDR_LEN)) ||
                     (Entry->Internal != Internal)) {

                /**
                    This is an advertise from a router who has changed
                    his route to a service.  We update our table to
                    show the new change.
                **/

                Entry->HopCount = ServerHopCount;
                SAP_COPY_ADDRESS(Entry->ServAddress, ServerAddr);
                Entry->Internal = Internal;
                Entry->FromWan  = WanFlag;
                Entry->Changed = TRUE;
                SapChanged = TRUE;
            }

            /** Put this on the end of the timeout list **/

            SdmdRemoveEntryList(SAP_TIMELIST_INDEX, Entry);
            SdmdInsertTailList(SAP_TIMELIST_INDEX, Entry);
        }
        else {

            /**
                This is from somebody else advertising the same
                name.  If this is a better route then the one we
                have then we should replace the current one with
                this one.  Since this is the same name and type, we
                don't check the network delay time, only the hop count.

                The reason for this is that it is to the same dest
                address to the service.  Therefore the address of the
                service is the same, so the delay time will be the
                same for RIP since RIP is in charge of getting the
                best time for us later anyway.
            **/

            if (ServerHopCount < Entry->HopCount) {

                /** Fill in the new entry **/

                SAP_COPY_ADDRESS(Entry->ServAddress, ServerAddr);
                memcpy(Entry->Advertiser, SendersAddress, SAP_NODE_LEN);
                Entry->HopCount   = ServerHopCount;
                Entry->CardNumber = CardNumber;
                Entry->Internal   = Internal;
                Entry->FromWan    = WanFlag;

                /** This entry has changed **/

                Entry->Changed = TRUE;
                SapChanged = TRUE;

                /** Set the new time on this entry **/

                Entry->Timeout = SdmdCurrentTime + SapTimeoutInterval;

                /** Put this on the end of the timeout list **/

                SdmdRemoveEntryList(SAP_TIMELIST_INDEX, Entry);
                SdmdInsertTailList(SAP_TIMELIST_INDEX, Entry);
            }
        }

        /** Release the lock and leave **/

        RELEASE_WRITERS_LOCK("Update Entry X2");
        return 0;
    }

    /**
        The entry was not found in our list - so we need to
        create it in the database now.
    **/

    /** If this is for a down server - just ignore it **/

    if (ServerHopCount >= 16) {
        RELEASE_WRITERS_LOCK("Update Entry X3");
        return 0;
    }

    /** Get a free entry **/

    Entry = SdmdGetFreeEntry();
    if (Entry == NULL) {
        RELEASE_WRITERS_LOCK("Update Entry X4");
        return -1;
    }

    /**
        Find the HeadEntry that this entry belongs in.
    **/

    HeadBackIndex = SDMD_ENDOFLIST;
    HeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Flink);
    while (HeadEntry && (HeadEntry->ServType < ServerType)) {
        HeadBackIndex = HeadEntry->Index;
        HeadEntry = GETPTRFROMINDEX(HeadEntry->Links[SAP_TYPELIST_INDEX].Flink);
    }

    /** If this type not found - then we need to create a HeadEntry **/

    if ((HeadEntry == NULL) || (HeadEntry->ServType != ServerType)) {

        /**
            Get a new head entry - we must save the EntryIndex and
            get a ptr back to after the call to GetFreeEntry because
            the database could have moved in memory during the
            GetFreeEntry call.
        **/

        EntryIndex = Entry->Index;      /* Save entry index */
        HeadEntry = SdmdGetFreeEntry();

        /** Get ptr to entry back **/

        Entry = GETPTRFROMINDEX(EntryIndex);
        SS_ASSERT(Entry);

        /** If no head entry alloc'd - return error **/

        if (HeadEntry == NULL) {
            SdmdFreeEntry(Entry);
            RELEASE_WRITERS_LOCK("Update Entry X6");
            return -1;
        }

        /** Insert this entry in the TYPE list **/

        HeadEntry->ServType  = ServerType;
        HeadEntry->HeadIndex = SDMD_ENDOFLIST;
        SdmdInsertList(SAP_TYPELIST_INDEX, HeadEntry, HeadBackIndex);
    }

    /** **/

    SS_ASSERT(HeadEntry);

    /** Fill in the entry **/

    memset(Entry->ServName, '\0', SAP_OBJNAME_LEN);
    strcpy(Entry->ServName, ServerName);
    SAP_COPY_ADDRESS(Entry->ServAddress, ServerAddr);
    memcpy(Entry->Advertiser, SendersAddress, SAP_NODE_LEN);
    Entry->ServType   = ServerType;
    Entry->HopCount   = ServerHopCount;
    Entry->CardNumber = CardNumber;
    Entry->Timeout    = SdmdCurrentTime + SapTimeoutInterval;
    Entry->Internal   = Internal;
    Entry->Changed    = TRUE;
    Entry->FromWan    = WanFlag;

    /** Mark that we have changed our database **/

    SapChanged = TRUE;

    /** Now put this entry onto the head entry **/

    SdmdInsertTailSubList(HeadEntry, SAP_SUBLIST_INDEX, Entry);

    /** Put this on the end of the timeout list **/

    SdmdInsertTailList(SAP_TIMELIST_INDEX, Entry);

    /** Add this entry to the hash list **/

    SdmdInsertEntryInHash(ListHead, Entry, BackIndex);

    /** Release the lock **/

    RELEASE_WRITERS_LOCK("Update Entry X5");

    /** All Done **/

    return 1;
}


/*++
*******************************************************************
        S d m d T i m e o u t C h e c k

Routine Description:

        This routine is called once every minute to check if
        any entries have timed out and if they have, then to
        free them.

Arguments:

        None

Return Value:

        0 = Nothing Timed out
        1 = Something Timed out
*******************************************************************
--*/

INT
SdmdTimeoutCheck(
    VOID)
{
    PSAP_RECORD Entry;
    INT rc;

    /** Lock the database **/

    ACQUIRE_WRITERS_LOCK(rc, "Timeout Check");

    /** If error getting lock - return it **/

    if (rc) {

        /** **/

        IF_DEBUG(ERRORS) {
            SS_PRINT(("NWSAP: SdmdTimeoutCheck: Error getting writers lock\n"));
        }

        /** Nothing timed out **/

        return 0;
    }

    /** Add to the current time **/

    SdmdCurrentTime++;

    /**
        We check the head of the TIMEOUT list for entries that
        are timing out.  Since this list is ordered by time, we
        can check if very easily.
    **/

    rc = 0;
    Entry = GETPTRFROMINDEX(SdmdLists[SAP_TIMELIST_INDEX].Flink);
    while (Entry) {

        /** If time does not match - leave **/

        if (Entry->Timeout != SdmdCurrentTime)
            break;

        /**
            If this is from a WAN - just put it on the
            end of the list.
        **/

        if (Entry->FromWan) {
            Entry->Timeout = SdmdCurrentTime + SapTimeoutInterval;
            SdmdRemoveEntryList(SAP_TIMELIST_INDEX, Entry);
            SdmdInsertTailList(SAP_TIMELIST_INDEX, Entry);
        }
        else {

            /** Time matches - toss this entry **/

            IF_DEBUG(SDMD) {
                SS_PRINT(("Timing out entry index %d\n", Entry->Index));
            }
            Entry->HopCount = 16;       /* Entry no longer valid */
            Entry->Changed  = TRUE;
            SapChanged = TRUE;
            rc = 1;
        }

        /** Goto the next entry in the list **/

        Entry = GETPTRFROMINDEX(Entry->Links[SAP_TIMELIST_INDEX].Flink);
    }

    /** Release the lock **/

    RELEASE_WRITERS_LOCK("Timeout Check X");

    /** All Done **/

    return rc;
}


/*++
*******************************************************************
        S d m d G e t N e a r e s t S e r v e r L a n

Routine Description:

        When we get a GET NEAREST SERVICE QUERY and we are not
        advertising for a service of that type.  There could
        be a service that is on this local machine that we need
        to response for.  If there is no internal server, then
        we find one that is not too far away.

Arguments:

        Ptr      = Ptr to the buffer to fill in with the response
        ServType = Service type that the requestor wants
                   (Cannot be 0xFFFF).
        Cardnum  = Card number that request was received on.
        Bcast    = 0 - Unicast request received
                   Else = Broadcast request received

Return Value:

        0    = No service found
        Else = Size of the return buffer
*******************************************************************
--*/

INT
SdmdGetNearestServerLan(
    PUCHAR Ptr,
    USHORT ServType,
    INT    Cardnum,
    UCHAR  Bcast)
{
    PSAP_RECORD Entry;
    PSAP_RECORD HeadEntry;
    PSAP_RECORD NEntry;
    PSAP_HEADER Hdrp;
    USHORT HopInc;
    USHORT DelayTime;
    USHORT CurDelay;
    UCHAR Local;
    BOOL  Flag;

    /** Get the readers lock **/

    ACQUIRE_READERS_LOCK("SdmdGetNearestServerLan");

    /** Goto the server entries of the type given **/

    HeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Flink);
    while (HeadEntry && (HeadEntry->ServType < ServType)) {
        HeadEntry = GETPTRFROMINDEX(HeadEntry->Links[SAP_TYPELIST_INDEX].Flink);
    }

    /** If not found - just return nothing **/

    if ((HeadEntry == NULL) || (HeadEntry->ServType != ServType)) {
        RELEASE_READERS_LOCK("SdmdGetNearestServerLan X1");
        return 0;
    }

    /**
        Search the entries to find the nearest server we can.
        If there is not a nearest - just return 0.
    **/

    NEntry = NULL;              /* No nearest entry yet */
    Local  = 0;                 /* No local net entry found */

    /**
        Go thru all the entries of this type to see if they
        match.
    **/

    Entry = GETPTRFROMINDEX(HeadEntry->Links[SAP_SUBLIST_INDEX].Flink);
    while (Entry) {

        /**
            If this entry is internal to me - skip it
        **/

        if (Entry->Internal == 2)
            goto next_entry;

        /** If Hopcount is 16 - skip this entry. It is going away **/

        if (Entry->HopCount != 16) {

            /**
                If this is internal to our server - respond for it, then
                we will check to see if we need to put it in our list to
                respond for.
            **/

            if (Entry->Internal) {
                NEntry = Entry;
                HopInc = 0;
                Local  = 0;     /* For Bcast/Local check to fail */
                break;          /* Send it back now */
            }

            /**
                If this server is for the same card as the request
                came in on, then we mark that we found a local server
                so that we can check it later.  We do not want to
                respond with a remote server if there is one locally.

                In the case that the request is a bcast, we will not
                respond for the local server because that server will
                respond for itself.  If the request is not bcast, then
                we must respond because we are the only machine that has
                seen this request.
            **/

            if (Entry->CardNumber == Cardnum) {

                /** Remember we found this local server **/

                NEntry = Entry;
                HopInc = 0;
                Local = 1;
            }
            else if (Local == 0) {

                /**
                    If this entry came from a LAN (which is not
                    the same card as the request came in on) AND
                    we are not routing from LAN to LAN - then skip
                    this entry.
                **/

                if ((!Entry->FromWan) && (SapDontHopLans))
                    Flag = FALSE;
                else {

                    /**
                        See if we are allowed to send this server
                        across.
                    **/

                    Flag = SapShouldIAdvertiseByName(Entry->ServName);
                }

                /**
                    If we are allowed to return this entry -
                    then check to see if it is closer then any
                    other entry we have.
                **/

                if (Flag) {

                    /**
                        If we have no server on the net that the
                        request was recv'd on, find a remote server that
                        is as close as we can get.  If we find a local server
                        later, we will use it instead of a remote server.
                    **/

                    if (NEntry) {

                        /**
                            If the travel time (reported from RIP) is shorter,
                            then use this entry, else if the travel
                            times are the same and the hopcount is
                            smaller, use this entry.

                            We don't check for 0xFFFF because it is always
                            greater then everything else being a USHORT.
                        **/

                        DelayTime = SapGetDelayTime(Entry->ServAddress);
                        if (DelayTime < CurDelay) {
                            NEntry = Entry;
                            HopInc = 1;
                            CurDelay = DelayTime;
                        }
                        else if (DelayTime == CurDelay) {
                            if (Entry->HopCount < NEntry->HopCount) {
                                NEntry = Entry;
                                HopInc = 1;
                            }
                        }
                    }
                    else {

                        /**
                            This is the first remote entry we have found.  Remember
                            it because it is the closest one we know about so far.
                        **/

                        DelayTime = SapGetDelayTime(Entry->ServAddress);

                        NEntry = Entry;
                        HopInc = 1;
                        CurDelay = DelayTime;
                    }
                }
            }
        }

        /** Goto the next entry **/

next_entry:
        Entry = GETPTRFROMINDEX(Entry->Links[SAP_SUBLIST_INDEX].Flink);
    }

    /** If no server found - return it **/

    if (NEntry == NULL) {
        RELEASE_READERS_LOCK("SdmdGetNearestServerLan X2");
        return 0;
    }

    /**
        If the request was broadcast and we found a local server, then
        we need to just ignore the request.  This means that there
        is a local server on the network that can respond.  Local
        being set means that we only found servers that were local
        to the requestor.  We have nothing to respond with.
    **/

    if (Bcast && Local) {
        RELEASE_READERS_LOCK("SdmdGetNearestServerLan X2A");
        return 0;
    }

    /** Build response code **/

    *(PUSHORT)Ptr = htons(SAPTYPE_NEAREST_SERVICE_RESPONSE);
    Ptr += sizeof(USHORT);

    /** Build the data about the entry **/

    Hdrp = (PSAP_HEADER)Ptr;
    Hdrp->ServerType = htons(NEntry->ServType);
    Hdrp->Hopcount   = htons((USHORT)(NEntry->HopCount + HopInc));
    SAP_COPY_SERVNAME(Hdrp->ServerName, NEntry->ServName);
    SAP_COPY_ADDRESS(Hdrp->Address, NEntry->ServAddress);

    /** Release the lock on the list **/

    RELEASE_READERS_LOCK("SdmdGetNearestServerLan X3");

    /** Return the size of the entry **/

    return SAP_HEADER_SIZE + sizeof(USHORT);
}


/*++
*******************************************************************
        S d m d G e t N e a r e s t S e r v e r W a n

Routine Description:

        When we get a GET NEAREST SERVICE QUERY and we are not
        advertising for a service of that type.  There could
        be a service that is on this local machine that we need
        to response for.  If there is no internal server, then
        we find one that is not too far away.

        For WAN - we support sending up to 4 responses.  We
        build them here.  We assume the Maxnump will always hold
        the numbers 1 or 4.  This simplifies the code and makes
        it where we don't have to write a bunch of extra code to
        handle smaller numbers.

Arguments:

        Ptr       = Ptr to the buffer to fill in with the response
        ServType  = Service type that the requestor wants
                    (Cannot be 0xFFFF).
        Cardnum   = Card number that request was received on.
        Bcast     = 0 - Unicast request received
                    Else = Broadcast request received
        NumFoundp = Ptr to store number of return entries we built

Return Value:

        0    = No services of that type are in the database
               (*NumFoundp is also set to 0)
        Else = Size of one return buffer
               (*NumFoundp = Number of entries to return)

        Do not depend on the return length to see if any were built.
        Always check the NumFoundp value.
*******************************************************************
--*/

INT
SdmdGetNearestServerWan(
    PUCHAR Ptr,
    USHORT ServType,
    INT    Cardnum,
    UCHAR  Bcast,
    INT    *NumFoundp)
{
    INT Maxtodo;
    INT i;
    PSAP_RECORD Entry;
    PSAP_RECORD HeadEntry;
    PSAP_HEADER Hdrp;
    PSAP_RECORD NEntry[4];
    USHORT HopInc[4];
    USHORT DelayTime[4];
    USHORT CurDelay;
    UCHAR Local;
    BOOL  Flag;

    /** Start as none returned **/

    *NumFoundp = 0;

    /**
        We must acquire this lock here to avoid a deadlock condition
        where we would have a lock order problem.
    **/

    ACQUIRE_SENDTABLE_LOCK();

    /** Get the readers lock **/

    ACQUIRE_READERS_LOCK("SdmdGetNearestServerWan");

    /** Goto the server entries of the type given **/

    HeadEntry = GETPTRFROMINDEX(SdmdLists[SAP_TYPELIST_INDEX].Flink);
    while (HeadEntry && (HeadEntry->ServType < ServType)) {
        HeadEntry = GETPTRFROMINDEX(HeadEntry->Links[SAP_TYPELIST_INDEX].Flink);
    }

    /** If not found - just return nothing **/

    if ((HeadEntry == NULL) || (HeadEntry->ServType != ServType)) {
        RELEASE_READERS_LOCK("SdmdGetNearestServerWan X1");
        RELEASE_SENDTABLE_LOCK();
        return 0;
    }

    /**
        Search the entries to find the nearest server we can.
        If there is not a nearest - just return 0.
    **/

    NEntry[0] = NULL;             /* No nearest entry yet */
    NEntry[1] = NULL;             /* No nearest entry yet */
    NEntry[2] = NULL;             /* No nearest entry yet */
    NEntry[3] = NULL;             /* No nearest entry yet */

    /** Get the max we are to do **/

    Maxtodo = 4;

    /**
        Go thru all the entries of this type to see if they
        match.
    **/

    Entry = GETPTRFROMINDEX(HeadEntry->Links[SAP_SUBLIST_INDEX].Flink);
    while (Entry) {

        /** If Hopcount is 16 - skip this entry. It is going away **/

        if (Entry->HopCount != 16) {

            /**
                If this is internal to our server - respond for it, then
                we will check to see if we need to put it in our list to
                respond for.
            **/

            if (Entry->Internal) {

                /**
                    If this entry is being advertised by me, then
                    I need to see if I am allowed to respond for it
                    using the GetNearestServer call.
                **/

                if (Entry->Internal == 2) {

                    /** See if I am allowed **/

                    Flag = SapCanIRespondNearest(
                                Entry->ServName,
                                Entry->ServType);

                    /** If no - skip the entry **/

                    if (Flag == FALSE) {
                        goto next_entry;
                    }
                }

                /**
                    We have more than one to return, so we will
                    find one not assigned yet.
                **/

                for (i = 0 ; i < Maxtodo ; i++) {

                    /** If this one empty - set it up **/

                    if (NEntry[i] == NULL) {
                        NEntry[i]    = Entry;
                        HopInc[i]    = 0;
                        DelayTime[i] = 0;
                        break;
                    }
                }

                /**
                    If all slots have something in them now, then we
                    will find the one farthest away and replace it with
                    this new one.
                **/

                if (i == Maxtodo) {
                    INT Best = -1;      /* Find Best one */

                    /** Go find one to replace with this one **/

                    for (i = 0 ; i < Maxtodo ; i++){

                        /**
                            If this entry is internal, then do not
                            replace it because the entry we have is
                            internal also and we do not need to
                            replace an internal with an internal.
                        **/

                        if (NEntry[i]->Internal)
                            continue;

                        /**
                            If this server is local to the network that
                            the request came from - then do not
                            overwrite with an internal one of mine.
                        **/

                        if (NEntry[i]->CardNumber == Cardnum)
                            continue;

                        /** If Best not set yet - set to replace this one **/

                        if (Best = -1) {
                            Best = i;
                            CurDelay = DelayTime[i];
                            continue;
                        }

                        /**
                            NEntry[Best] is not internal and
                            NEntry[i] is not internal.

                            If this current one (Index 'i') is closer
                            then the current best one (Index 'Best'), then
                            we should replace the current best one with
                            this one.
                        **/

                        if (DelayTime[i] < CurDelay) {
                            Best = i;
                            CurDelay = DelayTime[i];
                        }
                        else if (DelayTime[i] == CurDelay) {
                            if (NEntry[i]->HopCount < NEntry[Best]->HopCount) {
                                Best = i;   /* CurDelay already set OK */
                            }
                        }
                    } /* For i = .. */

                    /**
                        If we found an entry to replace the best one -
                        replace it here.
                    **/

                    if (Best != -1) {
                        NEntry[Best]    = Entry;
                        HopInc[Best]    = 0;
                        DelayTime[Best] = CurDelay;
                    }
                } /* If i == Maxtodo */

                /** Skip to the next entry **/

                goto next_entry;
            } /* If Entry->Internal */

            /**
                If this server is on the same card as the request
                came in on, then we have found a server on the
                same network as the requestee.  In this case it means
                there is a server across the WAN link that the client
                can use.

                If this request is broadcast, then we will ignore
                the request because that server will respond.

                If the reqeust is NOT broadcast, then we will respond
                for this server.
            **/

            if (Entry->CardNumber == Cardnum) {

                /**
                    If the request was BCAST, then we do not respond
                    because there are servers local to the requestee
                    that can.  We will just ignore the request.
                **/

                if (Bcast) {
                    RELEASE_READERS_LOCK("SdmdGetNearestServerWan X2");
                    RELEASE_SENDTABLE_LOCK();
                    return 0;
                }

                /**
                    The request was UNICAST - we will respond.  We go
                    find the worst server there is and replace it with
                    this one.
                **/

                Local = 1;              /* Local to the requestee       */
                Flag  = 1;              /* We will respond for this one */
            }
            else {
                Local = 0;              /* Not local to the requestee   */

                /** Check filter list if we should respond **/

                Flag = SapShouldIAdvertiseByName(Entry->ServName);
            }

            /**
                Now see if we should replace a server in our list with
                this server.
            **/

            if (Flag) {

                /**
                    If there is an empty slot - just put this
                    server in it.
                **/

                for (i = 0 ; i < Maxtodo ; i++) {

                    /**
                        If all the entries are not full yet, then we
                        just put this entry in a free slot.
                    **/

                    if (NEntry[i] == NULL) {
                        NEntry[i] = Entry;
                        if (Local) {
                            HopInc[i]    = 0;
                            DelayTime[i] = 0;
                        }
                        else {
                            HopInc[i]    = 1;
                            DelayTime[i] = SapGetDelayTime(Entry->ServAddress);
                        }
                        break;
                    }
                }

                /**
                    If no free entries found - we need to find
                    the worst entry there is and replace it if
                    it is worse then this new entry.
                **/

                if (i == Maxtodo) {
                    INT Worst = -1;

                    /**
                        Go thru the current list and see if there is
                        one in the current list that is not as good
                        as the one we are checking.

                        First we go thru the 4 entries and find the
                        worst one.  Then when we get done, we
                        check it against the new entry and see if it
                        is better/worst.  If new entry is better, then
                        we put it in place of the worst entry.
                    **/

                    for (i = 0 ; i < Maxtodo ; i++) {

                        /**
                            If this NEntry is local to the requestee,
                            do not replace it ever.
                        **/

                        if (NEntry[i]->CardNumber == Cardnum)
                            continue;

                        /**
                            If worst not set yet - use this one as the
                            worst.
                        **/

                        if (Worst == -1) {
                            Worst = i;
                            continue;
                        }

                        /**
                            If the worst one so far is internal, then
                            we check if the current one we are checking
                            is internal.  If they are both internal, then
                            they are EQUAL and we just skip to the next
                            entry.

                            If the current one is not internal, then we
                            make it the worst one.
                        **/

                        if (NEntry[Worst]->Internal) {

                            /** If also internal - skip it **/

                            if (NEntry[i]->Internal)
                                continue;

                            /** Make this the worst one **/

                            Worst = i;
                            continue;
                        }

                        /**
                            The worst one is not local and not internal.
                            So we check here.  If the one we are checking
                            is internal, then it will not be as bad as the
                            worst one we have - so we skip to the next entry.
                        **/

                        if (NEntry[i]->Internal)
                            continue;

                        /**
                            NEntry[Worst] and NEntry[i] are both not
                            local and not internal.  So we check the
                            travel time and hops to decide which is worst.

                            If NEntry[i] is worse then NEntry[Worst], then
                            we replace Worst with entry i.

                            If the DelayTime for the current entry (i)
                            is greater then the DelayTime of the Worst
                            entry, then replace it.

                            If the DelayTimes are the same - then check
                            the HopCounts.  If the HopCount for the
                            current entry is greater then the HopCount
                            for the Worst entry, then replace it.
                        **/

                        if (DelayTime[Worst] < DelayTime[i]) {
                            Worst = i;
                        }
                        else if (DelayTime[Worst] == DelayTime[i]) {
                            if (NEntry[Worst]->HopCount < NEntry[i]->HopCount) {
                                Worst = i;
                            }
                        }
                    }

                    /**
                        If we found a worst entry, then we need to
                        check it against the new entry.  If the new entry
                        is better then the worst entry we found, then
                        we can replace the worst with this one.
                    **/

                    if (Worst != -1) {

                        /**
                            If this new entry is local to the
                            requestee, then we know that the Worst
                            is not local to the requestee and we
                            can just replace it.
                        **/

                        if (Local) {
                            NEntry[Worst]    = Entry;
                            DelayTime[Worst] = 0;
                            HopInc[Worst]    = 0;
                        }
                        else {

                            /**
                                New Entry is not local, so we have to
                                check internal.

                                If the new entry is internal and the Worst
                                entry is internal then they are equal,
                                Do not replace.  If the Worst entry
                                is NOT internal, then replace it.
                            **/

                            if (Entry->Internal) {

                                if (NEntry[Worst]->Internal == 0) {
                                    NEntry[Worst]    = Entry;
                                    DelayTime[Worst] = 0;
                                    HopInc[Worst]    = 0;
                                }
                            }
                            else {

                                /** Get the delay time for the new entry **/

                                CurDelay = SapGetDelayTime(Entry->ServAddress);

                                /**
                                    Compare this entry to the Worst entry and
                                    see if we can replace it.
                                **/

                                if (DelayTime[Worst] > CurDelay) {
                                    NEntry[Worst]    = Entry;
                                    DelayTime[Worst] = CurDelay;
                                    HopInc[Worst]    = 1;
                                }
                                else if (DelayTime[Worst] == CurDelay) {
                                    if (NEntry[Worst]->HopCount > Entry->HopCount) {
                                        NEntry[Worst] = Entry;
                                        HopInc[Worst] = 1;
                                    }
                                }
                            } /* If Entry->Internal, else */
                        } /* If Local, else */
                    } /* If Worst != -1 */
                } /* If i == Maxtodo */
            } /* If Flag */
        } /* If Entry->HopCount != 16 */

        /** Goto the next entry **/

next_entry:
        Entry = GETPTRFROMINDEX(Entry->Links[SAP_SUBLIST_INDEX].Flink);
    }

    /**
        We now have up to 4 entries to send back.

        Now we need to sort the entries we have to get them in
        order to send back.  We want the best entry to be in slot 0,
        then slot 1,....
    **/

    for (i = 0 ; i < Maxtodo - 1 ; i++) {
        INT j;
        INT Best;

        /** If entry not there - skip it **/

        if (NEntry[i] == NULL)
            continue;

        /** If this entry local - cannot be made to move down **/

        if (NEntry[i]->CardNumber == Cardnum)
            continue;

        /**
            Scan the rest of entries to find a better one.  If a better
            one is found - switch this one (i) and the better one.
        **/

        Best = i;              /* Start with this as best one */
        for (j = i + 1 ; j < Maxtodo ; j++) {

            /** If entry not there - skip it **/

            if (NEntry[j] == NULL)
                continue;

            /**
                1) If this entry is local - it is better.

                2) If this entry (j) is internal and the best entry
                   is not - then this entry (j) is better.

                3) This entry (j) is not local and is not internal.
                   If the best entry is internal, it is better, so we
                   do not switch.

                4) Compare the delay time/Hop count to see if entry
                   Best is better then this entry (j).
            **/

            if (NEntry[j]->CardNumber == Cardnum)   /* 1 */
                Best = j;
            else if (NEntry[j]->Internal) {         /* 2 */

                if (NEntry[Best]->Internal == 0)    /* 2 */
                    Best = j;
            }
            else {

                /** If Best internal - it is better, skip to next **/

                if (NEntry[Best]->Internal)         /* 3 */
                    continue;

                /**
                    Entry j is not internal or local.  Entry Best
                    is not internal or local.  Compare these to
                    find the best one.

                    Step 4.
                **/

                if (DelayTime[Best] > DelayTime[j]) {
                    Best = j;
                }
                else if (DelayTime[Best] == DelayTime[j]) {
                    if (NEntry[Best]->HopCount > NEntry[j]->HopCount) {
                        Best = j;
                    }
                }
            }
        }

        /**
            If a found a better one - switch these entries.
        **/

        if (Best != i) {
            PSAP_RECORD TEntry;
            USHORT THopInc;
            USHORT TDelay;

            /** Save entry i **/

            TEntry  = NEntry[i];
            TDelay  = DelayTime[i];
            THopInc = HopInc[i];

            /** Copy over new entry **/

            NEntry[i]    = NEntry[Best];
            DelayTime[i] = DelayTime[Best];
            HopInc[i]    = HopInc[Best];

            /** Set the best entry with old stuff **/

            NEntry[Best]    = TEntry;
            DelayTime[Best] = TDelay;
            HopInc[Best]    = THopInc;
        }
    } /* For i = 0 ... */

    /**
        Build the entries into the request buffer.  We assume that
        the buffer will hold all the entries we need.
    **/

    for (i = 0 ; i < Maxtodo ; i++) {

        /** Build it only if there **/

        if (NEntry[i] != NULL) {

            /** Build response code **/

            *(PUSHORT)Ptr = htons(SAPTYPE_NEAREST_SERVICE_RESPONSE);
            Ptr += sizeof(USHORT);

            /** Build the data about the entry **/

            Hdrp = (PSAP_HEADER)Ptr;
            Hdrp->ServerType = htons(NEntry[i]->ServType);
            Hdrp->Hopcount   = htons((USHORT)(NEntry[i]->HopCount + HopInc[i]));
            SAP_COPY_SERVNAME(Hdrp->ServerName, NEntry[i]->ServName);
            SAP_COPY_ADDRESS(Hdrp->Address, NEntry[i]->ServAddress);
            Ptr += SAP_HEADER_SIZE;
            *NumFoundp += 1;
        }
    }

    /** Release the lock on the list **/

    RELEASE_READERS_LOCK("SdmdGetNearestServerWan X3");
    RELEASE_SENDTABLE_LOCK();

    /** Return the size of one entry **/

    return SAP_HEADER_SIZE + sizeof(USHORT);
}


/*++
*******************************************************************
        S d m d C a l c H a s h

Routine Description:

        Calculate the hash index on a name for an entry.

Arguments:

        ServerName = Ptr to name to calculate hash index for

Return Value:

        The hash index is returned.
*******************************************************************
--*/

INT
SdmdCalcHash(
    PUCHAR ServerName)
{
    INT HashIndex;

    /** Add up all the bytes in the name **/

    HashIndex = 0;
    while (*ServerName) {
        HashIndex += (INT)*ServerName;
        ServerName++;
    }

    /** Divide by the size of the hash table **/

    HashIndex = HashIndex % SapHashTableSize;

    /** Return the hash index **/

    return HashIndex;
}


/*++
*******************************************************************
        S d m d I s S e r v e r I n T a b l e

Routine Description:

        Check to see if the given ServerName/ServerType is in
        our table.

Arguments:

        ServerName = Ptr to name to calculate hash index for
        ServerType = Object type to find

Return Value:

        TRUE  = The name is in our table
        FALSE = The name is not in our table

        The hash index is returned.
*******************************************************************
--*/

BOOL
SdmdIsServerInTable(
    PUCHAR ServerName,
    USHORT ServerType)
{
    PSAP_RECORD Entry;
    PSDMD_LIST_ENTRY ListHead;
    INT Retcode;
    INT HashIndex;

    /** Lock the database **/

    ACQUIRE_READERS_LOCK("SdmdIsServerInTable");

    /**
        Find the name and type in the hash list.
    **/

    HashIndex = SdmdCalcHash(ServerName);

    /** Get ptr to the list head for the hash index **/

    ListHead = SdmdNameHashTable + HashIndex;

    /** Find the name in the list **/

    Entry = GETPTRFROMINDEX(ListHead->Flink);
    while (Entry) {

        /** Make sure the Server Type is correct **/

        if (Entry->ServType == ServerType) {

            /** Check if this is the name **/

            Retcode = SAP_NAMECMP(Entry->ServName, ServerName);

            /**
                If this is it - then we need to see if this is a
                good or bad thing.

                If the server is one we are advertising - then
                return that we did not find it.

                If not - then check the AllowDuplicateServers flag
                to see if we are suppossed to return it as found or
                just ignore it.
            **/

            if (Retcode == 0) {

                /**
                    If advertised by me (Sap agent) - then return not
                    found - this will get replaced when the new AddAdvertise
                    starts getting advertised.
                **/

                if (Entry->Internal == 2) {
                    RELEASE_READERS_LOCK("SdmdIsServerInTable XGOOD 1");
                    return FALSE;
                }

                /**
                    If on the same machine - but advertised by the process
                    and not me - let that slide too.  If a process is doing
                    both this will let them work (per andyhe).
                **/

                if (Entry->Internal == 1) {
                    RELEASE_READERS_LOCK("SdmdIsServerInTable XGOOD 2");
                    return FALSE;
                }

                /** Release the lock **/

                RELEASE_READERS_LOCK("SdmdIsServerInTable XGOOD 3");

                /**
                    If allow dups - then return not found, we do
                    not keep looking since their should be only
                    one server for a name/type pair.
                **/

                if (SapAllowDuplicateServers)
                    return FALSE;

                /** Dups not allowed - return bad **/

                return TRUE;
            }

            /**
                Since the names are stored in alphabetical order, if we
                get past the name we are looking for, then we can just
                give up now instead of having to search the whole list.
            **/

            if (Retcode > 0) {
                break;
            }
        }

        /** Goto the next entry **/

        Entry = GETPTRFROMINDEX(Entry->Links[SAP_HASHLIST_INDEX].Flink);
    }

    /** Not in the list - return it **/

    RELEASE_READERS_LOCK("SdmdIsServerInTable XBAD");
    return FALSE;
}