windows-xp/Source/XPSP1/NT/net/wlbs/driver/main.c

/*++

Copyright(c) 1998,99  Microsoft Corporation

Module Name:

    main.c

Abstract:

    Windows Load Balancing Service (WLBS)
    Driver - packet handling

Author:

    kyrilf

--*/

#include <ndis.h>

#include "main.h"
#include "prot.h"
#include "nic.h"
#include "univ.h"
#include "wlbsip.h"
#include "util.h"
#include "load.h"
#include "wlbsparm.h"
#include "params.h"
#include "log.h"
#include "trace.h"

EXPORT
VOID
NdisIMCopySendPerPacketInfo(
	IN PNDIS_PACKET DstPacket,
	IN PNDIS_PACKET SrcPacket
	);

EXPORT
VOID
NdisIMCopySendCompletePerPacketInfo(
	IN PNDIS_PACKET DstPacket,
	PNDIS_PACKET SrcPacket
	);


//
// Internal functions
//
BOOLEAN Main_ApplyChangeWithoutReStart(PMAIN_CTXT ctxtp,
                                       CVY_PARAMS* pOldParams, 
                                       const CVY_PARAMS* pCurParam);
#if defined (SBH)
NDIS_STATUS Main_QueryPerf (
    PMAIN_CTXT              ctxtp,
    PCVY_DRIVER_PERF          pPerf);
#endif
    
/* GLOBALS */

MAIN_ADAPTER            univ_adapters [CVY_MAX_ADAPTERS]; // ###### ramkrish
ULONG                   univ_adapters_count = 0;

/* need this to bootstrap Main_ioctl since it will run without any context */

static PVOID                ioctrl_ctxtp;

static ULONG log_module_id = LOG_MODULE_MAIN;

/* The head of the BDA team list. */
PBDA_TEAM univ_bda_teaming_list = NULL;

/* PROCEDURES */

/*
 * Function: Main_alloc_team
 * Description: This function allocates and initializes a BDA_TEAM structure.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter
 * Returns: PBDA_TEAM - a pointer to a new BDA_TEAM structure if successful, NULL if not.
 * Author: shouse, 3.29.01
 * Notes: 
 */
PBDA_TEAM Main_alloc_team (IN PMAIN_CTXT ctxtp, IN PWSTR team_id) {
    PUCHAR      ptr;
    PBDA_TEAM   team;
    NDIS_STATUS status;

    UNIV_PRINT(("Main_alloc_team:  Entering..."));

    /* Allocate a BDA_TEAM structure. */
    status = NdisAllocateMemoryWithTag(&ptr, sizeof(BDA_TEAM), UNIV_POOL_TAG);
    
    if (status != NDIS_STATUS_SUCCESS) {
        UNIV_PRINT(("Main_alloc_team:  Unable to allocate a team.  Exiting..."));
        LOG_MSG2(MSG_ERROR_MEMORY, MSG_NONE, sizeof(BDA_TEAM), status);
        return NULL;
    }

    /* Make sure that ptr actually points to something. */
    ASSERT(ptr);

    /* Zero the memory out. */
    NdisZeroMemory(ptr, sizeof(BDA_TEAM));

    /* Cast the new memory to a team pointer. */
    team = (PBDA_TEAM)ptr;

    /* Set the default field values.  This is redundant (since 
       we just called NdisZeroMemory), but whatever. */
    team->prev = NULL;
    team->next = NULL;
    team->load = NULL;
    team->load_lock = NULL;
    team->active = FALSE;
    team->membership_count = 0;
    team->membership_fingerprint = 0;
    team->membership_map = 0;
    team->consistency_map = 0;

    /* Copy the team ID into the team structure. */
    NdisMoveMemory(team->team_id, team_id, CVY_MAX_BDA_TEAM_ID * sizeof(WCHAR));

    UNIV_PRINT(("Main_alloc_team:  Exiting..."));

    return team;
}

/*
 * Function: Main_free_team
 * Description: This function frees the memory used by a BDA_TEAM.
 * Parameters: team - a pointer to the team to be freed.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: 
 */
VOID Main_free_team (IN PBDA_TEAM team) {
 
    UNIV_PRINT(("Main_free_team:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Free the memory that the team structure is using. */
    NdisFreeMemory((PUCHAR)team, sizeof(BDA_TEAM), 0);
    
    UNIV_PRINT(("Main_free_team:  Exiting..."));
}

/*
 * Function: Main_find_team
 * Description: This function searches the linked list of teams looking for
 *              a given team ID.  If team with the same ID is found, a pointer
 *              to that team is returned, otherwise NULL is returned to indicate
 *              that no such team exists.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this team.
 *             team_id - a unicode string containing the team ID, which must be a GUID.
 * Returns: PBDA_TEAM - a pointer to the team if found, NULL otherwise.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the global teaming lock already acquired!!!
 */
PBDA_TEAM Main_find_team (IN PMAIN_CTXT ctxtp, IN PWSTR team_id) {
    NDIS_STRING existing_team;
    NDIS_STRING new_team;
    PBDA_TEAM   team;
    
    UNIV_PRINT(("Main_find_team:  Entering..."));

    /* Loop through all teams in the linked list.  If we find a matching
       team ID, return a pointer to the team; otherwise, return NULL. */
    for (team = univ_bda_teaming_list; team; team = team->next) {
        /* If we have a match, return a pointer to the team. */
        if (NdisEqualMemory((PVOID)team->team_id, (PVOID)team_id, sizeof(WCHAR) * CVY_MAX_BDA_TEAM_ID)) {
            UNIV_PRINT(("Main_find_team:  Team found.  Exiting..."));
            return team;
        }
    }

    UNIV_PRINT(("Main_find_team:  Team not found.  Exiting..."));

    return NULL;
}

/*
 * Function: Main_teaming_get_member_id
 * Description: This function assigns a team member a unique, zero-indexed integer ID, 
 *              which is used by the member as in index in a consistency bit map.  Each 
 *              member sets their bit in the consistecy bit map, based on heartbeat 
 *              observations, that is used by the master of the team to determine whether
 *              or not the team should be in an active state.
 * Parameters: team - a pointer to the team which the adapter is joining.
 *             id - out parameter to hold the new ID.
 * Returns: BOOLEAN - always TRUE now, but there may be a need to return failure in the future.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the team lock already acquired!!!
 */
BOOLEAN Main_teaming_get_member_id (IN PBDA_TEAM team, OUT PULONG id) {
    ULONG index;
    ULONG map;

    UNIV_PRINT(("Main_teaming_get_member_id:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Make sure that ID actually points to something. */
    ASSERT(id);

    /* Loop through the membership map looking for the first reset bit.  Because members
       can come and go, this bit will not always be in the (num_membes)th position.  For 
       example, it is perfectly plausible for the membership_map to look like (binary)
       0000 0000 0000 0000 0000 0100 1110 0111, in which case the ID returned by this 
       function would be three. */
    for (index = 0, map = team->membership_map; 
         index <= CVY_BDA_MAXIMUM_MEMBER_ID, map; 
         index++, map >>= 1)
        if (!(map & 0x00000001)) break;

    /* We assert that the index must be less than the maximum number of adapters 
       (CVY_BDA_MAXIMUM_MEMBER_ID = CVY_MAX_ADAPTERS - 1). */
    ASSERT(index <= CVY_BDA_MAXIMUM_MEMBER_ID);

    /* Set the member ID. */
    *id = index;

    /* Set our bit in the membership map. */
    team->membership_map |= (1 << *id);

    /* Set our bit in the consistency map.  By default, we assume that this member
       is consistent and heartbeats on this adapter can deternmine otherwise. */
    team->consistency_map |= (1 << *id);

    UNIV_PRINT(("Main_teaming_get_member_id:  Exiting..."));

    /* We may have reason to fail this call in the future, but for now, we always succeed. */
    return TRUE;
}

/*
 * Function: Main_teaming_put_member_id
 * Description: This function is called when a member leaves its team, at which
 *              time its ID is put back into the ID pool.
 * Parameters: team - a pointer to the team which this adapter is leaving.
 *             id - the ID, which this function will reset before returning.
 * Returns: BOOLEAN - always TRUE now, but there may be a need to return failure in the future.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the team lock already acquired!!!
 */
BOOLEAN Main_teaming_put_member_id (IN PBDA_TEAM team, IN OUT PULONG id) {

    UNIV_PRINT(("Main_teaming_put_member_id:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Make sure that ID actually points to something. */
    ASSERT(id);

    /* Reet our bit in the membership map.  This effectively prevents 
       us from influencing the active state of the team. */
    team->membership_map &= ~(1 << *id);

    /* Reet our bit in the consistency map. */
    team->consistency_map &= ~(1 << *id);

    /* Set the member ID back to an invalid value. */
    *id = CVY_BDA_INVALID_MEMBER_ID;

    UNIV_PRINT(("Main_teaming_put_member_id:  Exiting..."));

    /* We may have reason to fail this call in the future, but for now, we always succeed. */
    return TRUE;
}

/*
 * Function: Main_queue_team
 * Description: This fuction queues a team onto the global doubly-linked list of BDA teams
 *              (univ_bda_teaming_list).  Insertions always occur at the front of the list.
 * Parameters: team - a pointer to the team to queue onto the list.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the global teaming lock already acquired!!!
 */
VOID Main_queue_team (IN PBDA_TEAM team) {

    UNIV_PRINT(("Main_queue_team:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Insert at the head of the list by setting next to the current 
       head and pointing the global head pointer to the new team. */
    team->prev = NULL;
    team->next = univ_bda_teaming_list;
    univ_bda_teaming_list = team;

    /* If we are not the only team in the list, then we have to 
       set my successor's previous pointer to point to me. */
    if (team->next) team->next->prev = team;
    
    UNIV_PRINT(("Main_queue_team:  Exiting..."));
}

/*
 * Function: Main_dequeue_team
 * Description: This function removes a given team from the global doubly-linked 
 *              list of teams (univ_bda_teaming_list).
 * Parameters: team - a pointer to the team to remove from the list.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the global teaming lock already acquired!!!
 */
VOID Main_dequeue_team (IN PBDA_TEAM team) {

    UNIV_PRINT(("Main_dequeue_team:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Special case when we are the first team in the list, in which case, we
       have no previous pointer and the head of the list needs to be reset. */
    if (!team->prev) {
        /* Point the global head of the list to the next team in the list, 
           which CAN be NULL, meaning that the list is now empty. */
        univ_bda_teaming_list = team->next;
        
        /* If there was a team after me in the list, who is now the new 
           head of the list, set its previous pointer to NULL. */
        if (team->next) team->next->prev = NULL;
    } else {
        /* Point the previous node's next pointer to my successor in the
           list, which CAN be NULL if I was the last team in the list. */
        team->prev->next = team->next;

        /* If there is a team after me in the list, point its previous 
           pointer to my predecessor. */
        if (team->next) team->next->prev = team->prev;
    }

    UNIV_PRINT(("Main_dequeue_team:  Exiting..."));
}

/*
 * Function: Main_get_team
 * Description: This function returns a team for the given team ID.  If the team already
 *              exists in the global teaming list, it is returned.  Otherwise, a new team
 *              is allocated, initialized and returned.  Before a team is returned, however,
 *              it is properly referenced by incrementing the reference count (membership_count),
 *              assigning a team member ID to the requestor and fingerprinting the team with
 *              the member's primary cluster IP address.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             team_id - a unicode string (GUID) uniquely identifying the team to retrieve.
 * Returns: PBDA_TEAM - a pointer to the requested team.  NULL if it does not exists and
 *          a new team cannot be allocated, or if the team ID is invalid (empty).
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the global teaming lock already acquired!!!
 */
PBDA_TEAM Main_get_team (IN PMAIN_CTXT ctxtp, IN PWSTR team_id) {
    PBDA_TEAM team;

    UNIV_PRINT(("Main_get_team:  Entering..."));

    /* Make sure that team_id actually points to something. */
    if (!team_id || team_id[0] == L'\0') {
        UNIV_PRINT(("Main_get_team:  Invalid parameter.  Exiting..."));
        return NULL;
    }

    /* Try to find a previous instance of this team in the global list.
       If we can't find it in the list, then allocate a new team. */
    if (!(team = Main_find_team(ctxtp, ctxtp->params.bda_teaming.team_id))) {
        /* Allocate and initialize a new team. */
        if (!(team = Main_alloc_team(ctxtp, ctxtp->params.bda_teaming.team_id))) {
            UNIV_PRINT(("Main_get_team:  Error attempting to allocate memory for a team.  Exiting..."));
            return NULL;
        }
     
        /* If a new team was allocated, insert it into the list. */
        Main_queue_team(team);
    }

    /* Increment the reference count on this team.  This reference count prevents
       a team from being destroyed while somebody is still using it. */
    team->membership_count++;

    /* Get a team member ID, which is my index into the consistency bit map. */
    Main_teaming_get_member_id(team, &ctxtp->bda_teaming.member_id);

    /* The fingerprint field is a cumulative XOR of all primary cluster IPs in the team.  We
       only use the two least significant bytes of the cluster IP, which, because the 
       cluster IP address is stored in host order, are the two most significant bytes. */    
    team->membership_fingerprint ^= ((ctxtp->cl_ip_addr >> 16) & 0x0000ffff);

    UNIV_PRINT(("Main_get_team:  Exiting..."));

    return team;
}

/*
 * Function: Main_put_team
 * Description: This function releases a reference on a team and frees the team if
 *              no references remain.  Dereferencing includes decrementing the 
 *              membership_count, releasing this member's ID and removing our
 *              fingerprint from the team.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             team - a pointer to the team to dereference.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: This function should be called with the global teaming lock already acquired!!!
 */
VOID Main_put_team (IN PMAIN_CTXT ctxtp, IN PBDA_TEAM team) {
    
    UNIV_PRINT(("Main_put_team:  Entering..."));

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* The fingerprint field is a cumulative XOR of all primary cluster IPs in the team.  
       We only use the two least significant bytes of the cluster IP, which, because the 
       cluster IP address is stored in host order, are the two most significant bytes. 
       Because a fingerprint is an XOR, the act of removing our fingerprint is the same
       as it was to add it - we simply XOR our primary cluster IP address to remove it. 
       ((NUM1 ^ NUM2) ^ NUM2) equals NUM1. */    
    team->membership_fingerprint ^= ((ctxtp->cl_ip_addr >> 16) & 0x0000ffff);

    /* Release our team member ID back into the free pool. */
    Main_teaming_put_member_id(team, &ctxtp->bda_teaming.member_id);

    /* Decrement the number of adapters in this team and remove and free the team 
       if this is the last reference on the team. */
    if (!--team->membership_count) {
        /* Remove the team from the list. */
        Main_dequeue_team(team);

        /* Free the memory used by the team. */
        Main_free_team(team);
    }

    UNIV_PRINT(("Main_put_team:  Exiting..."));
}

/*
 * Function: Main_teaming_check_consistency
 * Description: This function is called by all adapters during Main_ping, wherein
 *              the master of every team should check its team for consitency and
 *              mark the team active if it is consistent.  Teams are marked incon-
 *              sistent and inactive by the load module or when the master of an 
 *              existing team is removed.  Because on the master performs the con-
 *              sistency check in this function, a team without a master can NEVER
 *              be marked active.
 * Parameters: ctxtp - a pointer to the adapter's MAIN_CTXT structure.
 * Returns: Nothing
 * Author: shouse, 3.29.01
 * Notes: This function acquires the global teaming lock.
 */
VOID Main_teaming_check_consistency (IN PMAIN_CTXT ctxtp) {
    PBDA_TEAM team;

    /* We check whether or not we are teaming without grabbing the global teaming
       lock in an effort to minimize the common case - teaming is a special mode
       of operation that is only really useful in a clustered firewall scenario.
       So, if we aren't teaming, just bail out here; if we really aren't teaming,
       or are in the process of leaving a team, then no worries; if however, we were
       teaming or in the process of joining a team, then we'll just catch this
       the next time through.  If we do think we're teaming, then we'll go ahead
       and grab the global lock to make sure. */
    if (!ctxtp->bda_teaming.active) return;

    NdisAcquireSpinLock(&univ_bda_teaming_lock);

    /* If we actually aren't part of a team, bail out - nothing to do. */
    if (!ctxtp->bda_teaming.active) {
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return;
    }

    /* If we aren't the master of our team, bail out - nothing to do.  
       Only the master can change the state of a team to active. */
    if (!ctxtp->bda_teaming.master) {
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return;
    }

    /* Extract a pointer to my team. */
    team = ctxtp->bda_teaming.bda_team;

    /* Make sure that the team exists. */
    ASSERT(team);

    /* If all members of my team are consistent, then activate the team. */
    if (team->membership_map == team->consistency_map) {
        if (!team->active) {
            LOG_MSG(MSG_INFO_BDA_TEAM_REACTIVATED, MSG_NONE);
            team->active = TRUE;
        }
    }

    NdisReleaseSpinLock(&univ_bda_teaming_lock);
}

/*
 * Function: Main_teaming_ip_addr_change
 * Description: This function is called from Main_ip_addr_init when the primary
 *              cluster IP address of an adapter changes (potentially).  We need
 *              to recognize this to properly re-fingerprint the team.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             old_ip - the old cluster IP addres (as a DWORD).
 *             new_ip - the new cluster IP address (as a DWORD).
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: This function acquires the global teaming lock.
 */
VOID Main_teaming_ip_addr_change (IN PMAIN_CTXT ctxtp, IN ULONG old_ip, IN ULONG new_ip) {
    PBDA_TEAM team;

    UNIV_PRINT(("Main_teaming_ip_addr_change:  Entering..."));

    NdisAcquireSpinLock(&univ_bda_teaming_lock);

    /* If we aren't part of a team, bail out - nothing to do.  Because this function is only
       called during a re-configuration, we won't worry about optimizing and not grabbing the 
       lock as is done in some of the hot paths. */
    if (!ctxtp->bda_teaming.active) {
        UNIV_PRINT(("Main_teaming_ip_addr_change:  This adapter is not part of a team.  Exiting..."));
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return;
    }

    /* Grab a pointer to the team. */
    team = ctxtp->bda_teaming.bda_team;

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* Remove the old cluster IP address by undoing the XOR.  We only use the two
       least significant bytes of the cluster IP, which, because the cluster IP 
       address is stored in host order, are the two most significant bytes. */
    team->membership_fingerprint ^= ((old_ip >> 16) & 0x0000ffff);

    /* XOR with the new cluster IP address. We only use the two least
       significant bytes of the cluster IP, which, because the cluster IP 
       address is stored in host order, are the two most significant bytes. */
    team->membership_fingerprint ^= ((new_ip >> 16) & 0x0000ffff);

    NdisReleaseSpinLock(&univ_bda_teaming_lock);

    UNIV_PRINT(("Main_teaming_ip_addr_change:  Exiting..."));
}

/*
 * Function: Main_teaming_cleanup
 * Description: This function is called from Main_cleanup (or Main_teaming_init) to
 *              cleanup any teaming configuration that may exist on an adapter.  To
 *              do so, we cleanup our membership state and dereference the team. If
 *              we are the master for the team, however, we have to wait until there
 *              are no more references on our load module before allowing the operation
 *              to complete, because this might be called in the unbind path, in 
 *              which case, our load module would be going away.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: This function acquires the global teaming lock.
 */
VOID Main_teaming_cleanup (IN PMAIN_CTXT ctxtp) {
    PBDA_TEAM team;
    
    UNIV_PRINT(("Main_teaming_cleanup:  Entering..."));

    NdisAcquireSpinLock(&univ_bda_teaming_lock);

    /* If we aren't part of a team, bail out - nothing to do. */
    if (!ctxtp->bda_teaming.active) {
        UNIV_PRINT(("Main_teaming_cleanup:  This adapter is not part of a team.  Exiting..."));
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return;
    }

    /* Inactivate teaming on this adapter.  This will cause other entities like the 
       load module and send/receive paths to stop thinking in teaming mode. */
    ctxtp->bda_teaming.active = FALSE;    

    /* Grab a pointer to the team. */
    team = ctxtp->bda_teaming.bda_team;

    /* Make sure that team actually points to something. */
    ASSERT(team);

    /* If we are the master for this team, make sure that all references to our load
       module have been released and then remove our load information from the team. */
    if (ctxtp->bda_teaming.master) {
        /* Mark the team as inactive - a team cannot function without a master.  Members
           of an inactive team will NOT accept packets and therefore will not reference
           our load module further while we wait for the reference count to go to zero. */
        team->active = FALSE;
        
        NdisReleaseSpinLock(&univ_bda_teaming_lock);

        /* No need to worry - the team pointer cannot go away even though we don't have 
           the lock acquired; we have a reference on the team until we call Main_put_team. */
        while (Load_get_reference_count(team->load)) {
            UNIV_PRINT(("Main_teaming_cleanup:  Sleeping...\n"));

            /* Sleep while there are references on our load module. */
            Nic_sleep(10);
        }

        NdisAcquireSpinLock(&univ_bda_teaming_lock);   

        /* Remove the pointer to my load module.  We wait until now to prevent another 
           adapter from joining the team claiming to be the master until we are done
           waiting for references on our load module to go away. */
        team->load = NULL;
        team->load_lock = NULL;

        /* If we have just left a team without a master, log an event to notify
           the user that a team cannot function without a designated master. */
        LOG_MSG(MSG_INFO_BDA_MASTER_LEAVE, MSG_NONE);
    }

    /* Reset the teaming context (member_id is set and reset by Main_get(put)_team). */
    ctxtp->bda_teaming.reverse_hash = 0;
    ctxtp->bda_teaming.master = 0;
        
    /* Remove the pointer to the team structure. */
    ctxtp->bda_teaming.bda_team = NULL;

    /* Decrements the reference count and frees the team if necessary. */
    Main_put_team(ctxtp, team);

    NdisReleaseSpinLock(&univ_bda_teaming_lock);

    UNIV_PRINT(("Main_teaming_cleanup:  Exiting..."));

    return;
}

/*
 * Function: Main_teaming_init
 * Description: This function is called by either Main_init or Main_ctrl to re-initialize
 *              the teaming confguration on this adapter.  If the new teaming configuration,
 *              which is stored in ctxtp->params is the same as the current configuration, 
 *              then we don't need to bother.  Otherwise, if we are already part of a team,
 *              we begin by cleaning up that state, which may unnecssary in some cases, but
 *              it makes things simpler and more straight-forward, so we'll live with it.  
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter. 
 * Returns: BOOLEAN - TRUE if successful, FALSE if unsuccessful.
 * Author: shouse, 3.29.01
 * Notes: This function acquires the global teaming lock.
 */
BOOLEAN Main_teaming_init (IN PMAIN_CTXT ctxtp) {
    PBDA_TEAM team;
    
    UNIV_PRINT(("Main_teaming_init:  Entering..."));

    NdisAcquireSpinLock(&univ_bda_teaming_lock);

    /* If the parameters are invalid, do nothing. */
    if (!ctxtp->params_valid) {
        UNIV_PRINT(("Main_teaming_init:  Parameters are invalid.  Exiting..."));
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return TRUE;
    }

    /* Check to see if the state of teaming has changed.  If we were actively teaming 
       before and we are still part of a team, then we may be able to get out of here
       without disturbing anything, if the rest of the configuration hasn't changed. */
    if (ctxtp->bda_teaming.active == ctxtp->params.bda_teaming.active) { 
        if (ctxtp->bda_teaming.active) {
            /* Make sure that I have a pointer to my team. */
            ASSERT(ctxtp->bda_teaming.bda_team);

            /* If all other teaming parameters are unchanged, then we can bail out 
               because no  part of the teaming configuration changed. */
            if ((ctxtp->bda_teaming.master == ctxtp->params.bda_teaming.master) &&
                (ctxtp->bda_teaming.reverse_hash == ctxtp->params.bda_teaming.reverse_hash) &&
                NdisEqualMemory((PVOID)ctxtp->bda_teaming.bda_team->team_id, (PVOID)ctxtp->params.bda_teaming.team_id, sizeof(WCHAR) * CVY_MAX_BDA_TEAM_ID)) {
                NdisReleaseSpinLock(&univ_bda_teaming_lock);
                return TRUE;
            }
        } else {
            /* If I wasn't teaming before, and I'm not teaming now, there's nothing for me to do. */
            NdisReleaseSpinLock(&univ_bda_teaming_lock);
            return TRUE;
        }
    }

    /* If this adapter is already in a team, cleanup first.  At this point, we know that 
       some part of the teaming configuration has changed, so we'll cleanup our old state
       if we need to and then re-build it with the new parameters if necessary. */
    if (ctxtp->bda_teaming.active) {
        UNIV_PRINT(("Main_teaming_init:  This adapter is already part of a team."));

        NdisReleaseSpinLock(&univ_bda_teaming_lock);

        /* Cleanup our old teaming state first. */
        Main_teaming_cleanup(ctxtp);

        NdisAcquireSpinLock(&univ_bda_teaming_lock);
    } 

    /* If, according to the new configuration, this adapter is not part of a team, do nothing. */
    if (!ctxtp->params.bda_teaming.active) {
        UNIV_PRINT(("Main_teaming_init:  This adapter is not part of a team.  Exiting..."));
        ctxtp->bda_teaming.member_id = CVY_BDA_INVALID_MEMBER_ID;
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return TRUE;
    }

    /* Try to find a previous instance of this team.  If the team does not
       exist, Main_get_team will allocate, intialize and reference a new team. */
    if (!(team = Main_get_team(ctxtp, ctxtp->params.bda_teaming.team_id))) {
        UNIV_PRINT(("Main_teaming_init:  Error attempting to allocate memory for a team.  Exiting..."));
        NdisReleaseSpinLock(&univ_bda_teaming_lock);
        return FALSE;
    }

    /* If we are supposed to be the master for this team, we need to make sure that the
       team doesn't already have a master, and if so, setup the shared load context. */
    if (ctxtp->params.bda_teaming.master) {
        /* If we are supposed to be the master for this team, check for an existing master. */
        if (team->load) {
            /* If the load pointer is set, then this team already has a master. */
            UNIV_PRINT(("Main_teaming_init:  This team already has a master.  Exiting..."));

            LOG_MSG(MSG_INFO_BDA_MULTIPLE_MASTERS, MSG_NONE);

            /* Release our reference on this team. */
            Main_put_team(ctxtp, team);

            NdisReleaseSpinLock(&univ_bda_teaming_lock);

            return FALSE;            
        } else {
            /* Otherwise, we are it.  Set the global load state pointers
               to our load module and load lock. */
            team->load = &ctxtp->load;
            team->load_lock = &ctxtp->load_lock;

            /* If all members of my team are consistent, then activate the team. */
            if (team->membership_map == team->consistency_map) team->active = TRUE;

            /* Log the fact that a master has now been assigned to this team. */
            LOG_MSG(MSG_INFO_BDA_MASTER_JOIN, MSG_NONE);
        }
    }

    /* If we have just joined a team without a master, log an event to notify
       the user that a team cannot function without a designated master. */
    if (!team->load) {
        LOG_MSG(MSG_INFO_BDA_NO_MASTER, MSG_NONE);
    }

    /* Store a pointer to the team in the adapter's teaming context. */
    ctxtp->bda_teaming.bda_team = team;

    /* Copy the teaming configuration from the parameters into the teaming context. */
    ctxtp->bda_teaming.master = ctxtp->params.bda_teaming.master;
    ctxtp->bda_teaming.reverse_hash = ctxtp->params.bda_teaming.reverse_hash;
    ctxtp->bda_teaming.active = TRUE;

    NdisReleaseSpinLock(&univ_bda_teaming_lock);

    UNIV_PRINT(("Main_teaming_init:  Exiting..."));

    return TRUE;
}

/*
 * Function: Main_teaming_acquire_load
 * Description: This function determines which load module a particular adapter should be unsing,
 *              sets the appropriate pointers, and references the appropriate load module.  If an
 *              adapter is not part of a BDA team, then it should always be using its own load
 *              module - in that case, this function does nothing.  If the adapter is part of a 
 *              team, but the team in inactive, we return FALSE to indicate that the adapter should
 *              not accept this packet - inactive teams drop all traffic except traffic to the DIP.  
 *              If the adapter is part of an active team, then we set the load and lock pointers to
 *              point to the team's master load state and appropriately set the reverse hashing
 *              indication based on the parameter setting for this adapter.  In this scenario, which
 *              creates a cross-adapter load reference, we reference the master's load module so
 *              that it doesn't go away while we are using a pointer to it. 
 * Parameters: member - a pointer to the teaming member information for this adapter.
 *             ppLoad - an out pointer to a pointer to a load module set appropriately upon exit.
 *             ppLock - an out pointer to a pointer to a load lock set appropriately upon exit.
 *             pbTeaming - an out pointer to a boolean that we set if this adapter is teaming.
 *             pbReverse - an out pointer to a boolean that we set if this adapter is teaming.
 * Returns: BOOLEAN - an indication of whether or not this packet is refused (TRUE = drop it).
 * Author: shouse, 3.29.01
 * Notes: This function acquires the global teaming lock.
 */
BOOLEAN Main_teaming_acquire_load (IN PBDA_MEMBER member, OUT PLOAD_CTXT * ppLoad, OUT PNDIS_SPIN_LOCK * ppLock, OUT BOOLEAN * pbTeaming, OUT ULONG * pbReverse) {
    
    NdisAcquireSpinLock(&univ_bda_teaming_lock);
    
    /* Assert that the team membership information actually points to something. */
    ASSERT(member);

    /* Assert that the load pointer and the pointer to the load pointer actually point to something. */
    ASSERT(ppLoad && *ppLoad);

    /* Assert that the lock pointer and the pointer to the lock pointer actually point to something. */
    ASSERT(ppLock && *ppLock);

    /* Assert that the reverse hashing pointer actually points to something. */
    ASSERT(pbReverse);

    /* Assert that the teaming pointer actually points to something. */
    ASSERT(pbTeaming);

    /* If we are an active BDA team participant, check the team state to see whether we
       should accept this packet and fill in the load module/configuration parameters. */
    if (member->active) {
        PBDA_TEAM team = member->bda_team;
        
        /* Assert that the team actually points to something. */
        ASSERT(team);
        
        /* If the team is inactive, we will not handle this packet. */
        if (!team->active) {
            NdisReleaseSpinLock(&univ_bda_teaming_lock);
            return TRUE;
        }
        
        /* Otherwise, tell the caller to use the team's load lock and module. */
        *ppLoad = team->load;
        *ppLock = team->load_lock;
        
        /* Fill in the reverse-hashing flag and tell the caller that it is indeed teaming. */
        *pbReverse = member->reverse_hash;
        *pbTeaming = TRUE;        

        /* In the case of cross-adapter load module reference, add a reference to 
           the load module we are going to use to keep it from disappering on us. */
        Load_add_reference(*ppLoad);
    }
    
    NdisReleaseSpinLock(&univ_bda_teaming_lock);

    return FALSE;
}

/*
 * Function: Main_teaming_release_load
 * Description: This function releases a reference to a load module if necessary.  If we did not
 *              acquire this load module pointer in teaming mode, then this is unnessary.  Other-
 *              wise, we need to decrement the count, now that we are done using the pointer.
 * Parameters: pLoad - a pointer to the load module to dereference.
 *             pLock - a pointer to the load lock corresponding to the load module pointer (unused).
 *             bTeaming - a boolean indication of whether or not we acquired this pointer in teaming mode.
 * Returns: Nothing.
 * Author: shouse, 3.29.01
 * Notes: 
 */
VOID Main_teaming_release_load (IN PLOAD_CTXT pLoad, IN PNDIS_SPIN_LOCK pLock, IN BOOLEAN bTeaming) {
    
    /* Assert that the load pointer actually points to something. */
    ASSERT(pLoad);

    /* Assert that the lock pointer actually points to something. */
    ASSERT(pLock);

    /* If this load module was referenced, remove the reference. */
    if (bTeaming) Load_release_reference(pLoad);
}

/*
 * Function: Main_packet_check
 * Description: This function is, for all intents and purposed, a teaming-aware wrapper
 *              around Load_packet_check.  It determines which load module to utilize,
 *              based on the BDA teaming configuration on this adapter.  Adapters that
 *              are not part of a team continue to use their own load modules (Which is
 *              BY FAR, the most common case).  Adapters that are part of a team will
 *              use the load context of the adapter configured as the team's master as
 *              long as the team is in an active state.  In such as case, because of 
 *              the cross-adapter referencing of load modules, the reference count on
 *              the master's load module is incremented to keep it from "going away"
 *              while another team member is using it.  When a team is marke inactive,
 *              which is the result of a misconfigured team either on this host or 
 *              another host in the cluster, the adapter handles NO traffic that would
 *              require the use of a load module.  Other traffic, such as traffic to 
 *              the DIP, or RAW IP traffic, is allowed to pass.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             svr_addr - the server IP address (source IP on send, destination IP on recv).
 *             svr_port - the server port (source port on send, destination port on recv).
 *             clt_addr - the client IP address (detination IP on send, source IP on recv).
 *             clt_port - the client port (destination port on send, source port on recv).
 *             protocol - the protocol for this packet. 
 *             pbRefused - an out parameter to indicate whether BDA teaming has refused service.
 *             bFilterTeamingOnly - TRUE indicates that this packet should be filtered only if BDA teaming.
 * Returns: BOOLEAN - indication of whether or not to accept the packet.
 * Author: shouse, 3.29.01
 * Notes: 
 */
__inline BOOLEAN Main_packet_check (PMAIN_CTXT ctxtp, 
                                    ULONG      svr_addr, 
                                    ULONG      svr_port, 
                                    ULONG      clt_addr, 
                                    ULONG      clt_port, 
                                    USHORT     protocol, 
                                    BOOLEAN *  pbRefused, 
                                    BOOLEAN    bFilterTeamingOnly) 
{
    /* For BDA teaming, initialize load pointer, lock pointer, reverse hashing flag and teaming flag
       assuming that we are not teaming.  Main_teaming_acquire_load will change them appropriately. */
    PLOAD_CTXT      pLoad = &ctxtp->load;
    PNDIS_SPIN_LOCK pLock = &ctxtp->load_lock;
    ULONG           bReverse = FALSE;
    BOOLEAN         bTeaming = FALSE;
    BOOLEAN         acpt = TRUE;

    /* We check whether or not we are teaming without grabbing the global teaming
       lock in an effort to minimize the common case - teaming is a special mode
       of operation that is only really useful in a clustered firewall scenario.
       So, if we don't think we're teaming, don't bother to check for sure, just
       use our own load module and go with it - in the worst case, we handle a
       packet we perhaps shouldn't have while we were joining a team or changing
       our current team configuration. */
    if (ctxtp->bda_teaming.active) {
        /* Check the teaming configuration and add a reference to the load module before consulting the load 
           module.  If the return value is TRUE, then the load module was NOT referenced, so we can bail out. */
        *pbRefused = Main_teaming_acquire_load(&ctxtp->bda_teaming, &pLoad, &pLock, &bTeaming, &bReverse);
    
        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (*pbRefused) return FALSE;
    }
    
    if (!bTeaming && bFilterTeamingOnly) {
        /* If we are only supposed to filter this packet if we are in a BDA team,
           then if we are not, we can just return TRUE now to indicate that it is
           OK to allow the packet to pass. */
        return TRUE;
    }

    NdisAcquireSpinLock(pLock);
    
    /* If this adapter is reverse hashing, then simply flip the source and 
       destination IP addresses and ports when sending them to the load module. */
    if (bReverse)
        acpt = Load_packet_check(pLoad, clt_addr, clt_port, svr_addr, svr_port, protocol, bTeaming);
    else
        acpt = Load_packet_check(pLoad, svr_addr, svr_port, clt_addr, clt_port, protocol, bTeaming);
    
    NdisReleaseSpinLock(pLock);  
    
    /* Release the reference on the load module if necessary.  If we aren't teaming, even in 
       the case we skipped calling Main_teaming_Acquire_load_module above bTeaming is FALSE, 
       so there is no need to call this function to release a reference. */
    if (bTeaming) Main_teaming_release_load(pLoad, pLock, bTeaming);

    return acpt;
}

/*
 * Function: Main_conn_advise
 * Description: This function is, for all intents and purposed, a teaming-aware wrapper
 *              around Load_conn_advise.  It determines which load module to utilize,
 *              based on the BDA teaming configuration on this adapter.  Adapters that
 *              are not part of a team continue to use their own load modules (Which is
 *              BY FAR, the most common case).  Adapters that are part of a team will
 *              use the load context of the adapter configured as the team's master as
 *              long as the team is in an active state.  In such as case, because of 
 *              the cross-adapter referencing of load modules, the reference count on
 *              the master's load module is incremented to keep it from "going away"
 *              while another team member is using it.  When a team is marke inactive,
 *              which is the result of a misconfigured team either on this host or 
 *              another host in the cluster, the adapter handles NO traffic that would
 *              require the use of a load module.  Other traffic, such as traffic to 
 *              the DIP, or RAW IP traffic, is allowed to pass. 
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             svr_addr - the server IP address (source IP on send, destination IP on recv).
 *             svr_port - the server port (source port on send, destination port on recv).
 *             clt_addr - the client IP address (detination IP on send, source IP on recv).
 *             clt_port - the client port (destination port on send, source port on recv).
 *             protocol - the protocol for this packet. 
 *             conn_status - the TCP flag in this packet - SYN (UP), FIN (DOWN) or RST (RESET).
 *             pbRefused - an out parameter to indicate whether BDA teaming has refused service.
 *             bFilterTeamingOnly - TRUE indicates that this packet should be filtered only if BDA teaming.
 * Returns: BOOLEAN - indication of whether or not to accept the packet.
 * Author: shouse, 3.29.01
 * Notes: 
 */
__inline BOOLEAN Main_conn_advise (PMAIN_CTXT ctxtp, 
                                   ULONG      svr_addr, 
                                   ULONG      svr_port, 
                                   ULONG      clt_addr, 
                                   ULONG      clt_port,
                                   USHORT     protocol, 
                                   ULONG      conn_status, 
                                   BOOLEAN *  pbRefused, 
                                   BOOLEAN    bFilterTeamingOnly) 
{
    /* For BDA teaming, initialize load pointer, lock pointer, reverse hashing flag and teaming flag
       assuming that we are not teaming.  Main_teaming_acquire_load will change them appropriately. */
    PLOAD_CTXT      pLoad = &ctxtp->load;
    PNDIS_SPIN_LOCK pLock = &ctxtp->load_lock;
    ULONG           bReverse = FALSE;
    BOOLEAN         bTeaming = FALSE;
    BOOLEAN         acpt = TRUE;

    /* We check whether or not we are teaming without grabbing the global teaming
       lock in an effort to minimize the common case - teaming is a special mode
       of operation that is only really useful in a clustered firewall scenario.
       So, if we don't think we're teaming, don't bother to check for sure, just
       use our own load module and go with it - in the worst case, we handle a
       packet we perhaps shouldn't have while we were joining a team or changing
       our current team configuration. */
    if (ctxtp->bda_teaming.active) {
        /* Check the teaming configuration and add a reference to the load module before consulting the load 
           module.  If the return value is TRUE, then the load module was NOT referenced, so we can bail out. */
        *pbRefused = Main_teaming_acquire_load(&ctxtp->bda_teaming, &pLoad, &pLock, &bTeaming, &bReverse);
        
        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (*pbRefused) return FALSE;
    }
    
    if (!bTeaming && bFilterTeamingOnly) {
        /* If we are only supposed to filter this packet if we are in a BDA team,
           then if we are not, we can just return TRUE now to indicate that it is
           OK to allow the packet to pass. */
        return TRUE;
    }

    NdisAcquireSpinLock(pLock);
    
    /* If this adapter is reverse hashing, then simply flip the source and 
       destination IP addresses and ports when sending them to the load module. */
    if (bReverse)
        acpt = Load_conn_advise(pLoad, clt_addr, clt_port, svr_addr, svr_port, protocol, conn_status, bTeaming);
    else
        acpt = Load_conn_advise(pLoad, svr_addr, svr_port, clt_addr, clt_port, protocol, conn_status, bTeaming);
    
    NdisReleaseSpinLock(pLock);  
    
    /* Release the reference on the load module if necessary.  If we aren't teaming, even in 
       the case we skipped calling Main_teaming_Acquire_load_module above, bTeaming is FALSE, 
       so there is no need to call this function to release a reference. */
    if (bTeaming) Main_teaming_release_load(pLoad, pLock, bTeaming);

    return acpt;
}

/*
 * Function: Main_create_dscr
 * Description: This function is, for all intents and purposed, a teaming-aware wrapper
 *              around Loas_create_dscr.  It determines which load module to utilize,
 *              based on the BDA teaming configuration on this adapter.  Adapters that
 *              are not part of a team continue to use their own load modules (Which is
 *              BY FAR, the most common case).  Adapters that are part of a team will
 *              use the load context of the adapter configured as the team's master as
 *              long as the team is in an active state.  In such as case, because of 
 *              the cross-adapter referencing of load modules, the reference count on
 *              the master's load module is incremented to keep it from "going away"
 *              while another team member is using it.  When a team is marke inactive,
 *              which is the result of a misconfigured team either on this host or 
 *              another host in the cluster, the adapter handles NO traffic that would
 *              require the use of a load module.  Other traffic, such as traffic to 
 *              the DIP, or RAW IP traffic, is allowed to pass.  This function creates
 *              a connection descriptor in the load module without consulting load-
 *              balancing state - it is simply a direction, on an outgoing TCP SYN, for
 *              the load module to create state.  Under the restrictions placed on port
 *              rules in bi-directional affinity teaming, if we create this descriptor
 *              on the outbound path, we can guarantee that connections originating on
 *              this NLB host ALWAYS return to this host, even if convergence has
 *              occurred.
 * Parameters: ctxtp - a pointer to the MAIN_CTXT structure for this adapter.
 *             svr_addr - the server IP address (source IP on send, destination IP on recv).
 *             svr_port - the server port (source port on send, destination port on recv).
 *             clt_addr - the client IP address (detination IP on send, source IP on recv).
 *             clt_port - the client port (destination port on send, source port on recv).
 *             protocol - the protocol for this packet. 
 *             pbRefused - an out parameter to indicate whether BDA teaming has refused service.
 *             bFilterTeamingOnly - TRUE indicates that this packet should be filtered only if BDA teaming.
 * Returns: BOOLEAN - indication of whether or not to accept the packet (based on the success of descriptor creation).
 * Author: shouse, 3.29.01
 * Notes: 
 */
__inline BOOLEAN Main_create_dscr (PMAIN_CTXT ctxtp, 
                                   ULONG      svr_addr, 
                                   ULONG      svr_port, 
                                   ULONG      clt_addr,
                                   ULONG      clt_port, 
                                   USHORT     protocol,
                                   BOOLEAN *  pbRefused, 
                                   BOOLEAN    bFilterTeamingOnly) 
{
    /* For BDA teaming, initialize load pointer, lock pointer, reverse hashing flag and teaming flag
       assuming that we are not teaming.  Main_teaming_acquire_load will change them appropriately. */
    PLOAD_CTXT      pLoad = &ctxtp->load;
    PNDIS_SPIN_LOCK pLock = &ctxtp->load_lock;
    ULONG           bReverse = FALSE;
    BOOLEAN         bTeaming = FALSE;
    BOOLEAN         acpt = TRUE;

    /* We check whether or not we are teaming without grabbing the global teaming
       lock in an effort to minimize the common case - teaming is a special mode
       of operation that is only really useful in a clustered firewall scenario.
       So, if we don't think we're teaming, don't bother to check for sure, just
       use our own load module and go with it - in the worst case, we handle a
       packet we perhaps shouldn't have while we were joining a team or changing
       our current team configuration. */
    if (ctxtp->bda_teaming.active) {
        /* Check the teaming configuration and add a reference to the load module before consulting the load module.  
           If the return value is TRUE, then the load module was NOT referenced, so we can bail out. */
        *pbRefused = Main_teaming_acquire_load(&ctxtp->bda_teaming, &pLoad, &pLock, &bTeaming, &bReverse);
        
        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (*pbRefused) return FALSE;
    }    

    if (!bTeaming && bFilterTeamingOnly) {
        /* If we are only supposed to filter this packet if we are in a BDA team,
           then if we are not, we can just return TRUE now to indicate that it is
           OK to allow the packet to pass. */
        return TRUE;
    }

    /* If we are in a BDA team, then we want to create a descriptor for an outgoing SYN. */
    NdisAcquireSpinLock(pLock);
    
    /* If this adapter is reverse hashing, then simply flip the source and 
       destination IP addresses and ports when sending them to the load module. */
    if (bReverse)
        acpt = Load_create_dscr(pLoad, clt_addr, clt_port, svr_addr, svr_port, protocol, bTeaming);
    else
        acpt = Load_create_dscr(pLoad, svr_addr, svr_port, clt_addr, clt_port, protocol, bTeaming);
    
    NdisReleaseSpinLock(pLock);  
    
    /* Release the reference on the load module if necessary.  If we aren't teaming, even in 
       the case we skipped calling Main_teaming_Acquire_load_module above, bTeaming is FALSE, 
       so there is no need to call this function to release a reference. */
    if (bTeaming) Main_teaming_release_load(pLoad, pLock, bTeaming);

    return acpt;
}

/* 
 * Function: Main_query_packet_filter
 * Desctription:
 * Parameters:
 * Returns:
 * Author: shouse, 5.18.01
 * Notes:
 */
VOID Main_query_packet_filter (PMAIN_CTXT ctxtp, PIOCTL_QUERY_STATE_PACKET_FILTER pQuery)
{
    /* For BDA teaming, initialize load pointer, lock pointer, reverse hashing flag and teaming flag
       assuming that we are not teaming.  Main_teaming_acquire_load will change them appropriately. */
    PLOAD_CTXT      pLoad = &ctxtp->load;
    PNDIS_SPIN_LOCK pLock = &ctxtp->load_lock;
    ULONG           bReverse = FALSE;
    BOOLEAN         bTeaming = FALSE;
    BOOLEAN         bRefused = FALSE;
    BOOLEAN         acpt = TRUE;
    
    /* NOTE: This entire operation assumes RECEIVE path semantics - most outgoing traffic
       is not filtered by NLB anyway, so there isn't much need to query send filtering. */

    /* First check for remote control packets, which are always UDP and are always allowed to pass. */
    if (pQuery->Protocol == TCPIP_PROTOCOL_UDP) {
        /* If the client UDP port is the remote control port, then this is a remote control 
           response from another NLB cluster host.  These are always allowed to pass. */
        if (pQuery->ClientPort == ctxtp->params.rct_port || pQuery->ClientPort == CVY_DEF_RCT_PORT_OLD) {
            pQuery->Results.Accept = NLB_ACCEPT_REMOTE_CONTROL_RESPONSE;
            return; 
        /* Otherwise, if the server UDP port is the remote control port, then this is an incoming
           remote control request from another NLB cluster host.  These are always allowed to pass. */
        } else if (pQuery->ServerPort == ctxtp->params.rct_port || pQuery->ServerPort == CVY_DEF_RCT_PORT_OLD) {
            pQuery->Results.Accept = NLB_ACCEPT_REMOTE_CONTROL_REQUEST;
            return;            
        }
    }

    /* Check for traffic destined for the dedicated IP address of this host, or to the cluster
       or dedicated broadcast IP addresses.  These packets are always allowed to pass. */
    if (pQuery->ServerIPAddress == ctxtp->ded_ip_addr || pQuery->ServerIPAddress == ctxtp->ded_bcast_addr || pQuery->ServerIPAddress == ctxtp->cl_bcast_addr) {
        pQuery->Results.Accept = NLB_ACCEPT_DIP_OR_BROADCAST;
        return;
    }
    
    /* Check for passthru packets.  When the cluster IP address has not been specified, the
       cluster moves into passthru mode, in which it passes up ALL packets received. */
    if (ctxtp->cl_ip_addr == 0) {
        pQuery->Results.Accept = NLB_ACCEPT_PASSTHRU_MODE;
        return;
    }
    
    /* If the cluster is not operational, which can happen, for example as a result of a wlbs.exe
       command such as "wlbs stop", or as a result of bad parameter settings, then drop all traffic 
       that does not meet the above conditions. */
    if (!ctxtp->convoy_enabled) {
        pQuery->Results.Accept = NLB_REJECT_CLUSTER_STOPPED;
        return;
    }
    
    /* We check whether or not we are teaming without grabbing the global teaming
       lock in an effort to minimize the common case - teaming is a special mode
       of operation that is only really useful in a clustered firewall scenario.
       So, if we don't think we're teaming, don't bother to check for sure, just
       use our own load module and go with it - in the worst case, we handle a
       packet we perhaps shouldn't have while we were joining a team or changing
       our current team configuration. */
    if (ctxtp->bda_teaming.active) {
        /* Check the teaming configuration and add a reference to the load module before consulting the load 
           module.  If the return value is TRUE, then the load module was NOT referenced, so we can bail out. */
        bRefused = Main_teaming_acquire_load(&ctxtp->bda_teaming, &pLoad, &pLock, &bTeaming, &bReverse);
        
        /* If teaming has suggested that we not allow this packet to pass, the cluster will
           drop it.  This occurs when teams are inconsistently configured, or when a team is
           without a master, in which case there is no load context to consult anyway. */
        if (bRefused) {
            pQuery->Results.Accept = NLB_REJECT_BDA_TEAMING_REFUSED;
            return;
        }
    }

    NdisAcquireSpinLock(pLock);
    
    /* If this adapter is reverse hashing, then simply flip the source and destination IP addresses 
       and ports when sending them to the load module.  This function will run the NLB hashing 
       algorithm using the provided IP tuple and protocol information and fill in the query buffer
       with appropriate hashing and connection descriptor information. */
    if (bReverse)
        Load_query_packet_filter(pQuery, pLoad, pQuery->ClientIPAddress, pQuery->ClientPort, pQuery->ServerIPAddress, pQuery->ServerPort, pQuery->Protocol, bTeaming);
    else
        Load_query_packet_filter(pQuery, pLoad, pQuery->ServerIPAddress, pQuery->ServerPort, pQuery->ClientIPAddress, pQuery->ClientPort, pQuery->Protocol, bTeaming);

    NdisReleaseSpinLock(pLock);  
    
    /* Release the reference on the load module if necessary.  If we aren't teaming, even in 
       the case we skipped calling Main_teaming_Acquire_load_module above, bTeaming is FALSE, 
       so there is no need to call this function to release a reference. */
    if (bTeaming) Main_teaming_release_load(pLoad, pLock, bTeaming);
}

ULONG   Main_ip_addr_init (
    PMAIN_CTXT          ctxtp)
{
    ULONG               byte [4];
    ULONG               i;
    PWCHAR              tmp;
    ULONG               old_ip_addr;


    /* initialize dedicated IP address from the register string */

    tmp = ctxtp -> params . ded_ip_addr;
    ctxtp -> ded_ip_addr  = 0;

    /* do not initialize if one was not specified */

    if (tmp [0] == 0)
        goto ded_netmask;

    for (i = 0; i < 4; i ++)
    {
        if (! Univ_str_to_ulong (byte + i, tmp, & tmp, 3, 10) ||
            (i < 3 && * tmp != L'.'))
        {
            UNIV_PRINT (("bad dedicated IP address"));
            LOG_MSG (MSG_WARN_DED_IP_ADDR, ctxtp -> params . ded_ip_addr);
            ctxtp -> ded_net_mask = 0;
            goto ded_netmask;
        }

        tmp ++;
    }

    IP_SET_ADDR (& ctxtp -> ded_ip_addr, byte [0], byte [1], byte [2], byte [3]);

    UNIV_PRINT  (("Dedicated IP address: %d.%d.%d.%d = %x", byte [0], byte [1], byte [2], byte [3], ctxtp -> ded_ip_addr));

ded_netmask:

    /* initialize dedicated net mask from the register string */

    tmp = ctxtp -> params . ded_net_mask;
    ctxtp -> ded_net_mask = 0;

    /* do not initialize if one was not specified */

    if (tmp [0] == 0)
        goto cluster;

    for (i = 0; i < 4; i ++)
    {
        if (! Univ_str_to_ulong (byte + i, tmp, & tmp, 3, 10) ||
            (i < 3 && * tmp != L'.'))
        {
            UNIV_PRINT (("bad dedicated net mask address"));
            LOG_MSG (MSG_WARN_DED_NET_MASK, ctxtp -> params . ded_net_mask);
            ctxtp -> ded_ip_addr = 0;
            goto cluster;
        }

        tmp ++;
    }

    IP_SET_ADDR (& ctxtp -> ded_net_mask, byte [0], byte [1], byte [2], byte [3]);

    UNIV_PRINT  (("Dedicated net mask: %d.%d.%d.%d = %x", byte [0], byte [1], byte [2], byte [3], ctxtp -> ded_net_mask));

cluster:

    /* initialize cluster IP address from the register string */

    tmp = ctxtp -> params . cl_ip_addr;

    /* Save the previous cluster IP address to notify bi-directional affinity teaming. */
    old_ip_addr = ctxtp -> cl_ip_addr;

    ctxtp -> cl_ip_addr = 0;

    for (i = 0; i < 4; i ++)
    {
        if (! Univ_str_to_ulong (byte + i, tmp, & tmp, 3, 10) ||
            (i < 3 && * tmp != L'.'))
        {
            UNIV_PRINT (("bad cluster IP address"));
            LOG_MSG (MSG_ERROR_CL_IP_ADDR, ctxtp -> params . cl_ip_addr);
            ctxtp -> cl_net_mask = 0;
            return FALSE;
        }

        tmp ++;
    }

    IP_SET_ADDR (& ctxtp -> cl_ip_addr, byte [0], byte [1], byte [2], byte [3]);

    UNIV_PRINT  (("Cluster IP address: %d.%d.%d.%d = %x", byte [0], byte [1], byte [2], byte [3], ctxtp -> cl_ip_addr));

    /* Notify BDA teaming config that a cluster IP address might have changed. */
    Main_teaming_ip_addr_change(ctxtp, old_ip_addr, ctxtp->cl_ip_addr);

    /* initialize cluster net mask from the register string */

    tmp = ctxtp -> params . cl_net_mask;
    ctxtp -> cl_net_mask = 0;

    /* do not initialize if one was not specified */

    for (i = 0; i < 4; i ++)
    {
        if (! Univ_str_to_ulong (byte + i, tmp, & tmp, 3, 10) ||
            (i < 3 && * tmp != L'.'))
        {
            UNIV_PRINT (("bad cluster net mask address"));
            LOG_MSG (MSG_ERROR_CL_NET_MASK, ctxtp -> params . cl_net_mask);
            return FALSE;
        }

        tmp ++;
    }

    IP_SET_ADDR (& ctxtp -> cl_net_mask, byte [0], byte [1], byte [2], byte [3]);

    UNIV_PRINT  (("Cluster net mask: %d.%d.%d.%d = %x", byte [0], byte [1], byte [2], byte [3], ctxtp -> cl_net_mask));

    if (ctxtp -> params . mcast_support && ctxtp -> params . igmp_support)
    {
	/* Initialize the multicast IP address for IGMP support */

	tmp = ctxtp -> params . cl_igmp_addr;
	ctxtp -> cl_igmp_addr = 0;

	/* do not initialize if one was not specified */

	for (i = 0; i < 4; i ++)
	{
	    if (! Univ_str_to_ulong (byte + i, tmp, & tmp, 3, 10) ||
		(i < 3 && * tmp != L'.'))
            {
		UNIV_PRINT (("bad cluster net mask address"));
//		LOG_MSG (MSG_ERROR_CL_NET_MASK, ctxtp -> params . cl_igmp_addr); // is this required since it is checked in the APIs?
		return FALSE;
	    }

	    tmp ++;
	}

	IP_SET_ADDR (& ctxtp -> cl_igmp_addr, byte [0], byte [1], byte [2], byte [3]);

	UNIV_PRINT  (("Cluster IGMP Address: %d.%d.%d.%d = %x", byte [0], byte [1], byte [2], byte [3], ctxtp -> cl_igmp_addr));
    }

    if ((ctxtp -> ded_ip_addr != 0 && ctxtp -> ded_net_mask == 0) ||
        (ctxtp -> ded_ip_addr == 0 && ctxtp -> ded_net_mask != 0))
    {
        UNIV_PRINT (("need to specify both dedicated IP address AND network mask"));
        LOG_MSG (MSG_WARN_DED_MISMATCH, MSG_NONE);
        ctxtp -> ded_ip_addr = 0;
        ctxtp -> ded_net_mask = 0;
    }

    IP_SET_BCAST (& ctxtp -> cl_bcast_addr, ctxtp -> cl_ip_addr, ctxtp -> cl_net_mask);
    UNIV_PRINT  (("Cluster broadcast address: %d.%d.%d.%d = %x", ctxtp -> cl_bcast_addr & 0xff, (ctxtp -> cl_bcast_addr >> 8) & 0xff, (ctxtp -> cl_bcast_addr >> 16) & 0xff, (ctxtp -> cl_bcast_addr >> 24) & 0xff, ctxtp -> cl_bcast_addr));

    if (ctxtp -> ded_ip_addr != 0)
    {
        IP_SET_BCAST (& ctxtp -> ded_bcast_addr, ctxtp -> ded_ip_addr, ctxtp -> ded_net_mask);
        UNIV_PRINT  (("Dedicated broadcast address: %d.%d.%d.%d = %x", ctxtp -> ded_bcast_addr & 0xff, (ctxtp -> ded_bcast_addr >> 8) & 0xff, (ctxtp -> ded_bcast_addr >> 16) & 0xff, (ctxtp -> ded_bcast_addr >> 24) & 0xff, ctxtp -> ded_bcast_addr));
    }
    else
        ctxtp -> ded_bcast_addr = 0;

    if (ctxtp -> cl_ip_addr == 0)
    {
        UNIV_PRINT (("Cluster IP address = 0. Cluster host stopped"));
        return FALSE;
    }

    return TRUE;

} /* end Main_ip_addr_init */


ULONG   Main_mac_addr_init (
    PMAIN_CTXT          ctxtp)
{
    ULONG               i, b, len;
    PUCHAR              ap;
    PWCHAR              tmp;
    PUCHAR              srcp, dstp;
    ULONG               non_zero = 0;
    CVY_MAC_ADR         old_mac_addr;

    /* remember old mac address so we can yank it out of the multicast list */

    old_mac_addr = ctxtp->cl_mac_addr;

    /* at the time this routine is called by Prot_bind - ded_mad_addr is
       already set */

    tmp = ctxtp -> params . cl_mac_addr;
    len = CVY_MAC_ADDR_LEN (ctxtp -> medium);

    ap = (PUCHAR) & ctxtp -> cl_mac_addr;

    for (i = 0; i < len; i ++)
    {
        /* setup destination broadcast and source cluster addresses */

        if (! Univ_str_to_ulong (& b, tmp, & tmp, 2, 16) ||
            (i < len - 1 && * tmp != L'-' && * tmp != L':'))
        {
            UNIV_PRINT (("bad cluster network address"));
            LOG_MSG (MSG_ERROR_NET_ADDR, ctxtp -> params . cl_mac_addr);

            /* WLBS 2.3 prevent from failing if no MAC address - just use the
               dedicated one as cluster */

            NdisMoveMemory (& ctxtp -> cl_mac_addr, & ctxtp -> ded_mac_addr, len);
            non_zero = 1;
            break;
        }

        tmp ++;
        ap [i] = (UCHAR) b;

        /* WLBS 2.3 sum up bytes for future non-zero check */

        non_zero += b;
    }

    /* WLBS 2.3 - use dedicated address as cluster address if specified address
       is zero - this could be due to parameter errors */

    if (non_zero == 0)
        NdisMoveMemory (& ctxtp -> cl_mac_addr, & ctxtp -> ded_mac_addr, len);

    /* enforce group flag to proper value */

    if (ctxtp -> params . mcast_support)
        ap [0] |= ETHERNET_GROUP_FLAG;
    else
        ap [0] &= ~ETHERNET_GROUP_FLAG;

    if (ctxtp -> medium == NdisMedium802_3)
    {
        dstp = ctxtp -> media_hdr . ethernet . dst . data;
        srcp = ctxtp -> media_hdr . ethernet . src . data;
        len = ETHERNET_ADDRESS_FIELD_SIZE;

        CVY_ETHERNET_ETYPE_SET (& ctxtp -> media_hdr . ethernet, MAIN_FRAME_SIG);
    }

    ctxtp -> etype_old = FALSE;

    /* V1.3.1b - load multicast address as destination instead of broadcast */

    for (i = 0; i < len; i ++)
    {
        if (ctxtp -> params . mcast_support)
            dstp [i] = ap [i];
        else
            dstp [i] = 0xff;

        srcp [i] = ((PUCHAR) & ctxtp -> ded_mac_addr) [i];

    }

    if (! ctxtp -> params . mcast_support)
    {
        /* V2.0.6 - override source MAC address to prevent switch confusion */

        if (ctxtp -> params . mask_src_mac)
        {
            CVY_MAC_ADDR_LAA_SET (ctxtp -> medium, srcp);

            * ((PUCHAR) (srcp + 1)) = (UCHAR) ctxtp -> params . host_priority;
            * ((PULONG) (srcp + 2)) = ctxtp -> cl_ip_addr;
        }

        /* make source address look difference than our dedicated to prevent
           Compaq drivers from optimizing their reception out */

        else
            CVY_MAC_ADDR_LAA_TOGGLE (ctxtp -> medium, srcp);
    }

#if defined (NLB_MIXED_MODE_CLUSTERS)
    PUCHAR              s,d;

    len = CVY_MAC_ADDR_LEN (ctxtp -> medium);
    /* derive the unicast mac address */
    s = (PUCHAR) (& (ctxtp -> unic_mac_addr));
    s[0]  = 0x02;
    s[1]  = 0xbf;
    s[2]  = (UCHAR) (ctxtp -> cl_ip_addr & 0xff);
    s[3]  = (UCHAR) ((ctxtp -> cl_ip_addr & 0xff00) >> 8);
    s[4]  = (UCHAR) ((ctxtp -> cl_ip_addr & 0xff0000) >> 16);
    s[5]  = (UCHAR) ((ctxtp -> cl_ip_addr & 0xff000000) >> 24);

    /* derive the multicast mac address */
    NdisMoveMemory ( & ctxtp -> mult_mac_addr, & ctxtp -> unic_mac_addr, len);
    d = (PUCHAR) (& (ctxtp -> mult_mac_addr));
    d[0]  = 0x03;

    /* derive the igmp mac address */
    NdisMoveMemory ( & ctxtp -> igmp_mac_addr, & ctxtp -> unic_mac_addr, len);
    d = (PUCHAR) (& (ctxtp -> igmp_mac_addr));
    d[0]  = 0x01;
    d[1]  = 0x00;
    d[2]  = 0x5e;
    d[3]  = 0x7f;

    CVY_MAC_ADDR_PRINT (ctxtp -> medium, "Unicast mac address: ", (PUCHAR) & ctxtp -> unic_mac_addr);
    CVY_MAC_ADDR_PRINT (ctxtp -> medium, "Multicast mac address: ", (PUCHAR) & ctxtp -> mult_mac_addr);
    CVY_MAC_ADDR_PRINT (ctxtp -> medium, "IGMP mac address: ", (PUCHAR) & ctxtp -> igmp_mac_addr);
#endif /* NLB_MIXED_MODE_CLUSTERS */

    CVY_MAC_ADDR_PRINT (ctxtp -> medium, "Cluster network address: ", ap);
    CVY_MAC_ADDR_PRINT (ctxtp -> medium, "Dedicated network address: ", srcp);

    /* Load cluster address as multicast one to the NIC.  If the cluster IP address 0.0.0.0, then we
       don't want to add the multicast MAC address to the NIC - we retain the current MAC address. */
    if (ctxtp -> params . mcast_support && ctxtp -> params . cl_ip_addr != 0)
    {
        ULONG               xferred;
        ULONG               needed;
        PNDIS_REQUEST       request;
        MAIN_ACTION         act;
        PUCHAR              ptr;
        NDIS_STATUS         status;
        ULONG               size, i, len;


        len = CVY_MAC_ADDR_LEN (ctxtp->medium);
        size = ctxtp->max_mcast_list_size * len;

        status = NdisAllocateMemoryWithTag (& ptr, size, UNIV_POOL_TAG);

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating space %d %x", size, status));
            LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
            return FALSE;
        }

        act . code  = MAIN_ACTION_CODE;
        act . ctxtp = ctxtp;
        request = & act . op . request . req;
        act . op . request . xferred = & xferred;
        act . op . request . needed  = & needed;

        /* get current mcast list */

        request -> RequestType = NdisRequestQueryInformation;

        if (ctxtp -> medium == NdisMedium802_3)
            request -> DATA . QUERY_INFORMATION . Oid = OID_802_3_MULTICAST_LIST;

        request -> DATA . QUERY_INFORMATION . InformationBufferLength = size;
        request -> DATA . QUERY_INFORMATION . InformationBuffer = ptr;

        status = Prot_request (ctxtp, & act, FALSE);

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error %x querying multicast address list %d %d", status, xferred, needed));
            NdisFreeMemory (ptr, size, 0);
            return FALSE;
        }

        for (i = 0; i < xferred; i += len)
        {
            if (CVY_MAC_ADDR_COMP (ctxtp -> medium, (PUCHAR) ptr + i, & old_mac_addr))
            {
                UNIV_PRINT (("old cluster MAC matched"));
                CVY_MAC_ADDR_PRINT (ctxtp -> medium, "", & old_mac_addr);
                UNIV_PRINT (("copying new MAC into %dth entry in the multicast list", i));
                CVY_MAC_ADDR_PRINT (ctxtp -> medium, "", & ctxtp->cl_mac_addr);

                CVY_MAC_ADDR_COPY (ctxtp->medium, (PUCHAR) ptr + i, & ctxtp->cl_mac_addr);

                break;
            }
            else
                CVY_MAC_ADDR_PRINT (ctxtp -> medium, "", & ctxtp -> cl_mac_addr);
        }

        /* add MAC if not present */

        if (i >= xferred)
        {
            UNIV_PRINT (("adding new MAC"));
            CVY_MAC_ADDR_PRINT (ctxtp -> medium, "", & ctxtp->cl_mac_addr);

            if (xferred + len > size)
            {
                UNIV_PRINT (("no room for cluster mac %d", ctxtp->max_mcast_list_size));
                LOG_MSG1 (MSG_ERROR_MCAST_LIST_SIZE, L"", ctxtp->max_mcast_list_size);
                NdisFreeMemory (ptr, size, 0);
                return FALSE;
            }

            UNIV_PRINT (("copying new MAC into %dth entry in the multicast list", i));
            CVY_MAC_ADDR_PRINT (ctxtp -> medium, "", & ctxtp->cl_mac_addr);

            CVY_MAC_ADDR_COPY (ctxtp->medium, (PUCHAR) ptr + xferred, & ctxtp->cl_mac_addr);

            xferred += len;
        }

        request -> RequestType = NdisRequestSetInformation;

        if (ctxtp -> medium == NdisMedium802_3)
            request -> DATA . SET_INFORMATION . Oid = OID_802_3_MULTICAST_LIST;

        request -> DATA . SET_INFORMATION . InformationBufferLength = xferred;
        request -> DATA . SET_INFORMATION . InformationBuffer = ptr;

        status = Prot_request (ctxtp, & act, FALSE);

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error %x setting multicast address %d %d", status, xferred, needed));
            NdisFreeMemory (ptr, size, 0);
            return FALSE;
        }

        NdisFreeMemory (ptr, size, 0);
    }

    return TRUE;

} /* end Main_mac_addr_init */


/* Initialize the Ethernet Header and IP packet for sending out IGMP joins/leaves */
ULONG Main_igmp_init (
    PMAIN_CTXT          ctxtp,
    BOOLEAN             join)
{
    PUCHAR              ptr;
    ULONG               checksum;
    PMAIN_IGMP_DATA     igmpd = & (ctxtp -> igmp_frame . igmp_data);
    PMAIN_IP_HEADER     iph  = & (ctxtp -> igmp_frame . ip_data);
    PUCHAR              srcp, dstp;
    UINT                i;


    if ((!ctxtp -> params . mcast_support) || (!ctxtp -> params . igmp_support))
	return FALSE;

    /* Fill in the igmp data */
    igmpd -> igmp_vertype = 0x12; /* Needs to be changed for join/leave */
    igmpd -> igmp_unused  = 0x00;
    igmpd -> igmp_xsum    = 0x0000;
    igmpd -> igmp_address = ctxtp -> cl_igmp_addr;

    /* Compute the IGMP checksum */
    ptr = (PUCHAR) igmpd;
    checksum = 0;

    for (i = 0; i < sizeof (MAIN_IGMP_DATA) / 2; i ++, ptr += 2)
        checksum += (ULONG) ((ptr [0] << 8) | ptr [1]);

    checksum = (checksum >> 16) + (checksum & 0xffff);
    checksum += (checksum >> 16);
    checksum  = (~ checksum);

    ptr = (PUCHAR) (& igmpd -> igmp_xsum);
    ptr [0] = (CHAR) ((checksum >> 8) & 0xff);
    ptr [1] = (CHAR) (checksum & 0xff);

    /* Fill in the IP Header */
    iph -> iph_verlen   = 0x45;
    iph -> iph_tos      = 0;
    iph -> iph_length   = 0x1c00;
    iph -> iph_id       = 0xabcd; /* Need to find the significance of this later */
    iph -> iph_offset   = 0;
    iph -> iph_ttl      = 0x1;
    iph -> iph_protocol = 0x2;
    iph -> iph_xsum     = 0x0;
    iph -> iph_src      = ctxtp -> cl_ip_addr;
    iph -> iph_dest     = ctxtp -> cl_igmp_addr;

    /* Compute the checksum for the IP header */
    checksum = Tcpip_chksum (& ctxtp -> tcpip, (PIP_HDR) iph, NULL, TCPIP_PROTOCOL_IP);
    IP_SET_CHKSUM ((PIP_HDR) iph, (USHORT) checksum);

    /* Fill in the ethernet header */
    if (ctxtp -> medium == NdisMedium802_3)
    {
        dstp = ctxtp -> media_hdr_igmp . ethernet . dst . data;
        srcp = ctxtp -> media_hdr_igmp . ethernet . src . data;

        CVY_ETHERNET_ETYPE_SET (& ctxtp -> media_hdr_igmp . ethernet, MAIN_IP_SIG);
    }

    CVY_MAC_ADDR_COPY (ctxtp -> medium, dstp, & ctxtp -> cl_mac_addr);
    CVY_MAC_ADDR_COPY (ctxtp -> medium, srcp, & ctxtp -> ded_mac_addr);

    return TRUE;

} /* end Main_igmp_init */


NDIS_STATUS Main_init (
    PMAIN_CTXT          ctxtp)
{
    ULONG               i, size;
    NDIS_STATUS         status;
    PMAIN_FRAME_DSCR    dscrp;

    /* hook the IRP_MJ_DEVICE_CONTROL entry point in order to catch user-mode
       requests to the driver. this is probably a hack, since there has to
       be an IOCTL to NDIS-installed handler that will cause our
       QueryInformationHandler to be called. could not find it in the
       documentation though */

    ioctrl_ctxtp = ctxtp;

#if 0
    univ_ioctl_hdlr = ((PDRIVER_OBJECT) univ_driver_ptr) -> MajorFunction [IRP_MJ_DEVICE_CONTROL];
    ((PDRIVER_OBJECT) univ_driver_ptr) -> MajorFunction [IRP_MJ_DEVICE_CONTROL] = Main_ioctl;
#endif

    /* V2.0.6 */

//    UNIV_ASSERT_VAL (sizeof (MAIN_PROTOCOL_RESERVED) <= 16, sizeof (MAIN_PROTOCOL_RESERVED));

    /* V1.3.2b */

    if (sizeof (PING_MSG) + sizeof (MAIN_FRAME_HDR) > ctxtp -> max_frame_size)
    {
        UNIV_PRINT (("ping message will not fit in the media frame %d > %d", sizeof (PING_MSG) + sizeof (MAIN_FRAME_HDR), ctxtp -> max_frame_size));
        LOG_MSG2 (MSG_ERROR_INTERNAL, MSG_NONE, sizeof (PING_MSG) + sizeof (MAIN_FRAME_HDR), ctxtp -> max_frame_size);
        goto error;
    }

    /* V2.0.6 initialize IP addresses - might be used in the Main_mac_addr_init
       so have to do it here */

    if (! Main_ip_addr_init (ctxtp))
    {
        ctxtp -> convoy_enabled = FALSE;
        ctxtp -> params_valid   = FALSE;
        UNIV_PRINT (("error initializing IP addresses"));
    }

    /* V1.3.1b parse cluster MAC address from parameters */

    if (! Main_mac_addr_init (ctxtp))
    {
        ctxtp -> convoy_enabled = FALSE;
        ctxtp -> params_valid   = FALSE;
        UNIV_PRINT (("error initializing cluster MAC address"));
    }

    /* Initialize IGMP message if in igmp mode */

    if (ctxtp -> params . mcast_support && ctxtp -> params . igmp_support)
    {
	if (! Main_igmp_init (ctxtp, TRUE))
	{
	    ctxtp -> convoy_enabled = FALSE;
	    ctxtp -> params_valid   = FALSE;
	    UNIV_PRINT (("error initializing IGMP message"));
	}

	UNIV_PRINT (("IGMP message initialized"));
    }

    /* can extract the send message pointer even if load is not inited yet V1.1.4 */

    ctxtp -> load_msgp = Load_snd_msg_get (& ctxtp -> load);

    /* initalize lists and locks */

    NdisInitializeListHead (& ctxtp -> sync_list[0]);
    NdisInitializeListHead (& ctxtp -> sync_list[1]);
    NdisInitializeListHead (& ctxtp -> act_list);
    NdisInitializeListHead (& ctxtp -> buf_list);
    NdisInitializeListHead (& ctxtp -> frame_list);
    NdisInitializeListHead (& ctxtp -> rct_list);

    NdisAllocateSpinLock (& ctxtp -> sync_lock);
    NdisAllocateSpinLock (& ctxtp -> act_lock);
    NdisAllocateSpinLock (& ctxtp -> buf_lock);
    NdisAllocateSpinLock (& ctxtp -> recv_lock);
    NdisAllocateSpinLock (& ctxtp -> send_lock);
    NdisAllocateSpinLock (& ctxtp -> frame_lock);
    NdisAllocateSpinLock (& ctxtp -> rct_lock);
    NdisAllocateSpinLock (& ctxtp -> load_lock);

    /* #ps# */
    NdisInitializeNPagedLookasideList (& ctxtp -> resp_list, NULL, NULL, 0,
                                       sizeof (MAIN_PROTOCOL_RESERVED),
                                       UNIV_POOL_TAG, 0);

    /* capture boot-time parameters */

    ctxtp -> num_packets   = ctxtp -> params . num_packets;
    ctxtp -> num_actions   = ctxtp -> params . num_actions;
    ctxtp -> num_send_msgs = ctxtp -> params . num_send_msgs;

#if 0
    /* ###### for tracking pending packets - ramkrish */
    NdisAllocateSpinLock (& ctxtp -> pending_lock);
    ctxtp -> pending_count  = 0;
    ctxtp -> pending_first  = 0;
    ctxtp -> pending_last   = 0;
    ctxtp -> pending_access = 0;

    /* ###### for tracking send filtering - ramkrish */
    ctxtp -> sends_in        = 0;
    ctxtp -> sends_completed = 0;
    ctxtp -> sends_filtered  = 0;
    ctxtp -> arps_filtered   = 0;
    ctxtp -> mac_modified    = 0;
    ctxtp -> arps_count      = 0;
    ctxtp -> uninited_return = 0;
#endif

    /* V1.1.1 - initalize other contexts */

    if (! Tcpip_init (& ctxtp -> tcpip, & ctxtp -> params))
    {
        UNIV_PRINT (("error initializing tcpip layer"));
        goto error;
    }

    UNIV_PRINT (("Initialized tcpip"));
    Load_init (& ctxtp -> load, & ctxtp -> params);
    UNIV_PRINT (("Initialized load"));

    /* don't try to init addresses if already encountered error - strings
       could be bad ! */

    if (ctxtp -> params_valid && ctxtp -> params . cluster_mode && ctxtp -> convoy_enabled)
    {
        UNIV_PRINT (("Main_init: calling load_start"));
        Load_start (& ctxtp -> load);
    }

    /* allocate actions */

    size = sizeof (MAIN_ACTION);
#ifdef _WIN64 // 64-bit -- ramkrish
    ctxtp -> act_size = (size & 0x7) ? (size + 8 - (size & 0x7) ) : size;
#else
    ctxtp -> act_size = size;
#endif

    if (! Main_actions_alloc (ctxtp))
        goto error;

    /* V1.3.2b - allocate buffers */

    ctxtp -> buf_mac_hdr_len = CVY_MAC_HDR_LEN (ctxtp -> medium);
    ctxtp -> buf_size = sizeof (MAIN_BUFFER) + ctxtp -> buf_mac_hdr_len +
                        ctxtp -> max_frame_size - 1;

    /* 64-bit -- ramkrish */
    UNIV_PRINT (("ctxtp -> buf_size = %d", ctxtp -> buf_size));
    size = ctxtp -> buf_size;
#ifdef _WIN64
    ctxtp -> buf_size = (size & 0x7) ? (size + 8 - (size & 0x7)) : size;
    UNIV_PRINT (("ctxtp -> buf_size = %d", ctxtp -> buf_size));
#else
    ctxtp -> buf_size = size;
#endif

    if (! Main_bufs_alloc (ctxtp))
        goto error;

    size = ctxtp -> num_packets;

    /* V1.1.2 - allocate packet pools */

    NdisAllocatePacketPool (& status, & (ctxtp -> send_pool_handle [0]),
                            ctxtp -> num_packets,
                            sizeof (MAIN_PROTOCOL_RESERVED));

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating send packet pool %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    ctxtp -> num_send_packet_allocs = 1;
    ctxtp -> cur_send_packet_pool   = 0;
    ctxtp -> num_sends_alloced = ctxtp->num_packets;

    NdisAllocatePacketPool (& status, & (ctxtp -> recv_pool_handle [0]),
                            ctxtp -> num_packets,
                            sizeof (MAIN_PROTOCOL_RESERVED));

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating recv packet pool %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    ctxtp -> num_recv_packet_allocs = 1;
    ctxtp -> cur_recv_packet_pool   = 0;
    ctxtp -> num_recvs_alloced = ctxtp->num_packets;

    /* allocate support for heartbeat ping messages */

    size = sizeof (MAIN_FRAME_DSCR) * ctxtp -> num_send_msgs;

    status = NdisAllocateMemoryWithTag (& ctxtp -> frame_dscrp, size,
                                        UNIV_POOL_TAG);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating frame descriptors %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    size = ctxtp -> num_send_msgs;

    NdisAllocatePacketPool (& status, & ctxtp -> frame_pool_handle,
                            ctxtp -> num_send_msgs,
                            sizeof (MAIN_PROTOCOL_RESERVED));

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating ping packet pool %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    size = 5 * ctxtp -> num_send_msgs;

    NdisAllocateBufferPool (& status, & ctxtp -> frame_buf_pool_handle,
                            5 * ctxtp -> num_send_msgs);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating ping buffer pool %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    for (i = 0; i < ctxtp -> num_send_msgs; i ++)
    {
        dscrp = & (ctxtp -> frame_dscrp [i]);

        if (ctxtp -> medium == NdisMedium802_3)
        {
            /* this buffer describes Ethernet MAC header */

            size = sizeof (CVY_ETHERNET_HDR);

            NdisAllocateBuffer (& status, & dscrp -> media_hdr_bufp,
                                ctxtp -> frame_buf_pool_handle,
                                & dscrp -> media_hdr . ethernet,
                                sizeof (CVY_ETHERNET_HDR));

            if (status != NDIS_STATUS_SUCCESS)
            {
                UNIV_PRINT (("error allocating ethernet header buffer %d %x", i, status));
                LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
                goto error;
            }

            dscrp -> recv_len = 0;
        }

        dscrp -> recv_len += sizeof (MAIN_FRAME_HDR) + sizeof (PING_MSG);

        /* this buffer describes frame headers */

        size = sizeof (MAIN_FRAME_HDR);

        NdisAllocateBuffer (& status, & dscrp -> frame_hdr_bufp,
                            ctxtp -> frame_buf_pool_handle,
                            & dscrp -> frame_hdr,
                            sizeof (MAIN_FRAME_HDR));

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating frame header buffer %d %x", i, status));
            LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
            return FALSE;
        }

        /* this buffer describes receive ping message buffer V1.1.4 */

        size = sizeof (PING_MSG);

        NdisAllocateBuffer (& status, & dscrp -> recv_data_bufp,
                            ctxtp -> frame_buf_pool_handle,
                            & dscrp -> msg,
                            sizeof (PING_MSG));

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating recv msg buffer %d %x", i, status));
            LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
            return FALSE;
        }

        /* this buffer describes send ping message buffer V1.1.4 */
#if 0
        size = sizeof (PING_MSG);

        NdisAllocateBuffer (& status, & dscrp -> send_data_bufp,
                            ctxtp -> frame_buf_pool_handle,
                            ctxtp -> load_msgp,
                            sizeof (PING_MSG));

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating send msg buffer %d %x", i, status));
            LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
            return FALSE;
        }
#endif
	dscrp -> send_data_bufp = NULL; /* Allocate this in Main_frame_get */

        NdisInterlockedInsertTailList (& ctxtp -> frame_list,
                                       & dscrp -> link,
                                       & ctxtp -> frame_lock);
    }

    /* Initialize the bi-directional affinity teaming if it has been configured. */
    if (!Main_teaming_init(ctxtp))
    {
        ctxtp -> convoy_enabled = FALSE;
        ctxtp -> params_valid   = FALSE;
        UNIV_PRINT (("error initializing bi-directional affinity teaming"));
    }

    UNIV_PRINT (("Initialized bi-directional affinity teaming"));        

    return NDIS_STATUS_SUCCESS;

error:

    Main_cleanup (ctxtp);

    return NDIS_STATUS_FAILURE;

} /* end Main_init */


VOID Main_cleanup (
    PMAIN_CTXT          ctxtp)
{
    ULONG               i, j;
    PMAIN_BUFFER        bp;


    /* V1.1.4 */

    /* #ps# */
    /* While using packet stacking, ensure that all packets are returned
     * before clearing up the context
     */

#if 0 // no longer needed, since Ndis will take care of this for us
    while (1)
    {
        NDIS_STATUS status;
        ULONG       count;

        status = NdisQueryPendingIOCount (ctxtp -> mac_handle, & count);
        if (status != NDIS_STATUS_SUCCESS || count == 0)
            break;

        Nic_sleep (10);
    }
#endif

    NdisDeleteNPagedLookasideList (& ctxtp -> resp_list);

    for (i = 0; i < CVY_MAX_ALLOCS; i ++)
    {
        if (ctxtp -> send_pool_handle [i] != NULL)
        {
            while (1)
            {
                if (NdisPacketPoolUsage (ctxtp -> send_pool_handle [i]) == 0)
                    break;

                Nic_sleep (10); /* wait for 10 milliseconds for the packets to be returned */
            }

            NdisFreePacketPool (ctxtp -> send_pool_handle [i]);
            ctxtp -> send_pool_handle [i] = NULL;
        }

        if (ctxtp -> recv_pool_handle [i] != NULL)
        {
            while (1)
            {
                if (NdisPacketPoolUsage (ctxtp -> recv_pool_handle [i]) == 0)
                    break;

                Nic_sleep (10); /* wait for 10 milliseconds for the packets to be returned */
            }

            NdisFreePacketPool (ctxtp -> recv_pool_handle [i]);
            ctxtp -> recv_pool_handle [i] = NULL;
        }

        if (ctxtp -> act_buf [i] != NULL)
            NdisFreeMemory (ctxtp -> act_buf [i],
                            ctxtp -> num_actions * ctxtp -> act_size, 0);

        /* V1.3.2b */

        if (ctxtp -> buf_array [i] != NULL)
        {
            for (j = 0; j < ctxtp -> num_packets; j ++)
            {
                bp = (PMAIN_BUFFER) (ctxtp -> buf_array [i] + j * ctxtp -> buf_size);

                if (bp -> full_bufp != NULL)
                {
                    NdisAdjustBufferLength (bp -> full_bufp,
                                            ctxtp -> buf_mac_hdr_len +
                                            ctxtp -> max_frame_size);
                    NdisFreeBuffer (bp -> full_bufp);
                }

                if (bp -> frame_bufp != NULL)
                {
                    NdisAdjustBufferLength (bp -> frame_bufp,
                                            ctxtp -> max_frame_size);
                    NdisFreeBuffer (bp -> frame_bufp);
                }
            }

            NdisFreeMemory (ctxtp -> buf_array [i],
                            ctxtp -> num_packets * ctxtp -> buf_size, 0);
        }

        if (ctxtp -> buf_pool_handle [i] != NULL)
            NdisFreeBufferPool (ctxtp -> buf_pool_handle [i]);
    }

    if (ctxtp -> frame_dscrp != NULL)
    {
        for (i = 0; i < ctxtp -> num_send_msgs; i ++)
        {
            if (ctxtp -> frame_dscrp [i] . media_hdr_bufp != NULL)
                NdisFreeBuffer (ctxtp -> frame_dscrp [i] . media_hdr_bufp);

            if (ctxtp -> frame_dscrp [i] . frame_hdr_bufp != NULL)
                NdisFreeBuffer (ctxtp -> frame_dscrp [i] . frame_hdr_bufp);

            if (ctxtp -> frame_dscrp [i] . send_data_bufp != NULL)
                NdisFreeBuffer (ctxtp -> frame_dscrp [i] . send_data_bufp);

            if (ctxtp -> frame_dscrp [i] . recv_data_bufp != NULL)
                NdisFreeBuffer (ctxtp -> frame_dscrp [i] . recv_data_bufp);
        }

        NdisFreeMemory (ctxtp -> frame_dscrp, sizeof (MAIN_FRAME_DSCR) *
                        ctxtp -> num_send_msgs, 0);
    }

    if (ctxtp -> frame_buf_pool_handle != NULL)
        NdisFreeBufferPool (ctxtp -> frame_buf_pool_handle);

    /* This packet pool is being used only for the heartbeat messages,
     * so prefer not to check the packet pool usage.
     */
    if (ctxtp -> frame_pool_handle != NULL)
        NdisFreePacketPool (ctxtp -> frame_pool_handle);

    NdisFreeSpinLock (& ctxtp -> sync_lock);
    NdisFreeSpinLock (& ctxtp -> act_lock);
    NdisFreeSpinLock (& ctxtp -> buf_lock);     /* V1.3.2b */
    NdisFreeSpinLock (& ctxtp -> recv_lock);
    NdisFreeSpinLock (& ctxtp -> send_lock);
    NdisFreeSpinLock (& ctxtp -> frame_lock);
    NdisFreeSpinLock (& ctxtp -> rct_lock);

    /* Cleanup BDA teaming state. Note: this function will sleep under certain circumstances. */
    Main_teaming_cleanup(ctxtp);

    if (ctxtp -> convoy_enabled)
        Load_stop (& ctxtp -> load);

    Load_cleanup (& ctxtp -> load);

    NdisFreeSpinLock (& ctxtp -> load_lock);

    return;
} /* end Main_cleanup */


ULONG   Main_arp_handle (
    PMAIN_CTXT          ctxtp,
    PARP_HDR            arp_hdrp,
    ULONG               len,       /* v2.0.6 */
    ULONG               send)
{
    PUCHAR              macp;

    /* V1.3.0b multicast support - ARP spoofing. use either this one or
       code in Nic_request_complete that makes TCP/IP believe that station
       current MAC address is the multicast one */

    /* V1.3.1b */

    if (len < sizeof(ARP_HDR))  /* v2.0.6 */
        return FALSE;

#if defined(TRACE_ARP)
    DbgPrint ("(ARP) %s\n", send ? "send" : "recv");
    DbgPrint ("    MAC type      = %x\n",  ARP_GET_MAC_TYPE (arp_hdrp));
    DbgPrint ("    prot type     = %x\n",  ARP_GET_PROT_TYPE (arp_hdrp));
    DbgPrint ("    MAC length    = %d\n",  ARP_GET_MAC_LEN (arp_hdrp));
    DbgPrint ("    prot length   = %d\n",  ARP_GET_PROT_LEN (arp_hdrp));
    DbgPrint ("    message type  = %d\n",  ARP_GET_MSG_TYPE (arp_hdrp));
    DbgPrint ("    src MAC addr  = %02x-%02x-%02x-%02x-%02x-%02x\n",
                                           ARP_GET_SRC_MAC (arp_hdrp, 0),
                                           ARP_GET_SRC_MAC (arp_hdrp, 1),
                                           ARP_GET_SRC_MAC (arp_hdrp, 2),
                                           ARP_GET_SRC_MAC (arp_hdrp, 3),
                                           ARP_GET_SRC_MAC (arp_hdrp, 4),
                                           ARP_GET_SRC_MAC (arp_hdrp, 5));
    DbgPrint ("    src prot addr = %d.%d.%d.%d\n",
                                           ARP_GET_SRC_PROT (arp_hdrp, 0),
                                           ARP_GET_SRC_PROT (arp_hdrp, 1),
                                           ARP_GET_SRC_PROT (arp_hdrp, 2),
                                           ARP_GET_SRC_PROT (arp_hdrp, 3));
    DbgPrint ("    dst MAC addr  = %02x-%02x-%02x-%02x-%02x-%02x\n",
                                           ARP_GET_DST_MAC (arp_hdrp, 0),
                                           ARP_GET_DST_MAC (arp_hdrp, 1),
                                           ARP_GET_DST_MAC (arp_hdrp, 2),
                                           ARP_GET_DST_MAC (arp_hdrp, 3),
                                           ARP_GET_DST_MAC (arp_hdrp, 4),
                                           ARP_GET_DST_MAC (arp_hdrp, 5));
    DbgPrint ("    dst prot addr = %d.%d.%d.%d\n",
                                           ARP_GET_DST_PROT (arp_hdrp, 0),
                                           ARP_GET_DST_PROT (arp_hdrp, 1),
                                           ARP_GET_DST_PROT (arp_hdrp, 2),
                                           ARP_GET_DST_PROT (arp_hdrp, 3));
#endif

    /* block sending out ARPs while we are changing IPs */

    if (send && univ_changing_ip > 0)
    {
        /* if source IP is the one we are switching to - stop blocking ARPs */

        if (ARP_GET_SRC_PROT_64(arp_hdrp) == ctxtp->cl_ip_addr) /* 64-bit -- ramkrish */
        {
            NdisAcquireSpinLock (& ctxtp -> load_lock);
            univ_changing_ip = 0;
            NdisReleaseSpinLock (& ctxtp -> load_lock);

            UNIV_PRINT (("IP address changed - stop blocking"));
        }
        else if (ARP_GET_SRC_PROT_64(arp_hdrp) != ctxtp -> ded_ip_addr) /* 64-bit -- ramkrish */
        {
#if defined(TRACE_ARP)
            DbgPrint ("blocked due to IP switching\n");
#endif
//            ctxtp -> arps_filtered ++;
            return FALSE;
        }
    }

    if (ctxtp -> params . mcast_spoof &&
        ctxtp -> params . mcast_support &&
        ARP_GET_PROT_TYPE (arp_hdrp) == ARP_PROT_TYPE_IP &&
        ARP_GET_PROT_LEN  (arp_hdrp) == ARP_PROT_LEN_IP)
    {
        if (send)
        {
            /* if this is a cluster IP address and our dedicated MAC -
               replace dedicated MAC with cluster MAC */

            if (ARP_GET_SRC_PROT_64 (arp_hdrp) != ctxtp -> ded_ip_addr) /* 64-bit -- ramkrish */
            {
                macp = ARP_GET_SRC_MAC_PTR (arp_hdrp);

                if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr))
                    CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr);
            }

#if defined (NLB_MIXED_MODE_CLUSTERS)
	    return TRUE;
#endif /* NLB_MIXED_MODE_CLUSTERS */

        }
#if 0
        else
        {
            /* if this is a cluster IP address and our cluster MAC -
               replace cluster MAC with dedicated MAC */

            if (ARP_GET_SRC_PROT_64 (arp_hdrp) != ctxtp -> ded_ip_addr) /* 64-bit -- ramkrish */
            {
                macp = ARP_GET_SRC_MAC_PTR (arp_hdrp);

                if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr))
                    CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
            }

            if (ARP_GET_DST_PROT_64 (arp_hdrp) != ctxtp -> ded_ip_addr) /* 64-bit -- ramkrish */
            {
                macp = ARP_GET_DST_MAC_PTR (arp_hdrp);

                if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr))
                    CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
            }
        }
#endif
    }

#if defined (NLB_MIXED_MODE_CLUSTERS)
    // code for migrating between cluster modes
    if (!send)
    {
	if (ARP_GET_SRC_PROT_64 (arp_hdrp) != ctxtp -> ded_ip_addr)
	{
	    macp = ARP_GET_SRC_MAC_PTR (arp_hdrp);

	    if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr))
	    {
		if (ctxtp -> params . mcast_support) /* only change for multicast support */
		{
		    CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
		}
	    }
	    else /* some machine could be in another mode. Avoid the IP address conflict, but warn the user */
	    {
		if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> unic_mac_addr) ||
		    CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> mult_mac_addr) ||
		    CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> igmp_mac_addr))
		{
		    UNIV_PRINT (("Detected a host with a different mode"));
		    if (! ctxtp -> mac_addr_warned)
		    {
			ctxtp -> mac_addr_warned = TRUE;
			LOG_MSG(MSG_WARN_DIFFERENT_MODE, MSG_NONE);
		    }

		    if (ctxtp -> params . mcast_support)
			CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
		    else
			CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr);
		}
		else
		{
		    ; /* This will be a genuine IP address conflict */
		}
	    }
	}

	if (ARP_GET_DST_PROT_64 (arp_hdrp) != ctxtp -> ded_ip_addr)
	{
	    macp = ARP_GET_DST_MAC_PTR (arp_hdrp);

	    if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr))
	    {
		if (ctxtp -> params . mcast_support) /* only change for multicast support */
                {
		    CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
		}
	    }
	    else /* some machine could be in another mode. Avoid the IP address conflict, but warn the user */
	    {
		if (CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> unic_mac_addr) ||
		    CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> mult_mac_addr) ||
		    CVY_MAC_ADDR_COMP (ctxtp -> medium, macp, & ctxtp -> igmp_mac_addr))
                {
		    UNIV_PRINT (("Detected a host with a different mode"));
		    if (! ctxtp -> mac_addr_warned)
		    {
			ctxtp -> mac_addr_warned = TRUE;
			LOG_MSG(MSG_WARN_DIFFERENT_MODE, MSG_NONE);
		    }

		    if (ctxtp -> params . mcast_support)
			CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> ded_mac_addr);
		    else
			CVY_MAC_ADDR_COPY (ctxtp -> medium, macp, & ctxtp -> cl_mac_addr);
		}
		else
		{
		    ; /* This will be a genuine IP address conflict */
		}
	    }
	}
    }
#endif /* NLB_MIXED_MODE_CLUSTERS */

#if defined(TRACE_ARP)
    DbgPrint ("---- spoofed to -----\n");
    DbgPrint ("    src MAC addr  = %02x-%02x-%02x-%02x-%02x-%02x\n",
                                           ARP_GET_SRC_MAC (arp_hdrp, 0),
                                           ARP_GET_SRC_MAC (arp_hdrp, 1),
                                           ARP_GET_SRC_MAC (arp_hdrp, 2),
                                           ARP_GET_SRC_MAC (arp_hdrp, 3),
                                           ARP_GET_SRC_MAC (arp_hdrp, 4),
                                           ARP_GET_SRC_MAC (arp_hdrp, 5));
    DbgPrint ("    src prot addr = %d.%d.%d.%d\n",
                                           ARP_GET_SRC_PROT (arp_hdrp, 0),
                                           ARP_GET_SRC_PROT (arp_hdrp, 1),
                                           ARP_GET_SRC_PROT (arp_hdrp, 2),
                                           ARP_GET_SRC_PROT (arp_hdrp, 3));
    DbgPrint ("    dst MAC addr  = %02x-%02x-%02x-%02x-%02x-%02x\n",
                                           ARP_GET_DST_MAC (arp_hdrp, 0),
                                           ARP_GET_DST_MAC (arp_hdrp, 1),
                                           ARP_GET_DST_MAC (arp_hdrp, 2),
                                           ARP_GET_DST_MAC (arp_hdrp, 3),
                                           ARP_GET_DST_MAC (arp_hdrp, 4),
                                           ARP_GET_DST_MAC (arp_hdrp, 5));
    DbgPrint ("    dst prot addr = %d.%d.%d.%d\n",
                                           ARP_GET_DST_PROT (arp_hdrp, 0),
                                           ARP_GET_DST_PROT (arp_hdrp, 1),
                                           ARP_GET_DST_PROT (arp_hdrp, 2),
                                           ARP_GET_DST_PROT (arp_hdrp, 3));
#endif

    return TRUE;

} /* end Main_arp_handle */

#if defined (NLB_SESSION_SUPPORT)
/*
 * Function: Main_parse_ipsec
 * Description: This function parses UDP packets received on port 500, which are IPSec
 *              control packets.  This function attempts to recognize the start of an 
 *              IPSec session - its virtual 'SYN' packet.  IPSec sessions begin with an
 *              IKE key exchange which is an IKE Main Mode Security Association.  This 
 *              function parses the IKE header and payload to identify the Main Mode
 *              SAs, which NLB will treat like TCP SYNs - all other UDP 500 and IPSec 
 *              traffic is treated like TCP data packets.  The problem is that NLB 
 *              cannot necessarily tell the difference between a new Main Mode SA and
 *              a re-key of an existing Main Mode SA.  Therefore, if the client does not
 *              support intitial contact notification, then every Main Mode SA will be
 *              considered a new session, which means that sessions can potentially 
 *              break depending on how often Main Mode SAs are negotiated.  However, if
 *              the client does support initial contact notification, then the only Main 
 *              Mode SAs that will be reported as such are the initial ones (when no state 
 *              currently exists between the client and the server), which allows NLB to 
 *              distinguish the two types of Main Mode SAs, which should allow NLB to 
 *              reliably keep IPSec sessions "sticky".  Note that there is no TCP FIN
 *              equivalent, so the descriptor for these sessions will be around forever,
 *              or until the load module is reset, or a new initial Main Mode SA arrives
 *              with the same address tuple, at which time the descriptor is removed and
 *              the correct host accepts the session and creates a new descriptor.  IPSec
 *              can however, if desired, notify NLB through the connection notification
 *              APIs, telling NLB that the session has gone down, allowing NLB to clean 
 *              out the descriptor for the session.  This is not necessarily critical, 
 *              but would be useful in the case where a host with stale information 
 *              rejoins the cluster, which could cause two hosts to pass up packets for
 *              the same session - IPSec will toss them out, unless its a Main Mode SA.
 *              Its also useful in the case where IPSec has refused a connection, in
 *              which case there is no reason for NLB to keep the descriptors around.
 * Parameters: pIKEPacket - a pointer to the IKE packet buffer (this is beyond the UDP header).
 *             cUDPDataLenght - the length of the corresponding buffer.
 * Returns: BOOLEAN - TRUE if the packet is a new IPSec session, FALSE if it is not.
 * Author: Created by shouse, 4.28.01
 */
BOOLEAN Main_parse_ipsec (PUCHAR pIKEPacket, ULONG cUDPDataLength) {
    /* Pointer to the IKE header. */
    PIPSEC_ISAKMP_HDR  pISAKMPHeader = (PIPSEC_ISAKMP_HDR)pIKEPacket;
    /* Pointer to the subsequent generic payloads in the IKE packet. */
    PIPSEC_GENERIC_HDR pGenericHeader;                   

    /* The responder cookie - should be zero for a new MM SA. */
    UCHAR              MainModeRCookie[IPSEC_ISAKMP_HEADER_RCOOKIE_LENGTH] = IPSEC_ISAKMP_MAIN_MODE_RCOOKIE;    
    /* The initiator cookie - should be non-zero if this is really an IKE packet. */
    UCHAR              EncapsulatedIPSecICookie[IPSEC_ISAKMP_HEADER_ICOOKIE_LENGTH] = IPSEC_ISAKMP_ENCAPSULATED_IPSEC_ICOOKIE;    
    /* The Microsoft client vendor ID - used to determine whether or not the client supports initial contact notification. */
    UCHAR              VIDMicrosoftClient[IPSEC_VENDOR_HEADER_VENDOR_ID_LENGTH] = IPSEC_VENDOR_ID_MICROSOFT;      

    /* Whether or not we've determined the client to be compatible. */                                                                                                                      
    BOOLEAN            bInitialContactEnabled = FALSE;
    /* Whether or not this is indeed an initial contact. */
    BOOLEAN            bInitialContact = FALSE;

    /* The length of the IKE packet. */            
    ULONG              cISAKMPPacketLength;
    /* The next payload code in the IKE payload chain. */  
    UCHAR              NextPayload;        

    UNIV_PRINT(("Sniffing IKE header %p\n", pISAKMPHeader));

    /* The UDP data should be at least as long as the initiator cookie.  If the packet is 
       UDP encapsulated IPSec, then the I cookie will be 0 to indicate such. */
    if (cUDPDataLength < IPSEC_ISAKMP_HEADER_ICOOKIE_LENGTH) {
        UNIV_PRINT(("Malformed UDP data: UDP data length = %u\n", cUDPDataLength));
        return FALSE;
    }

    /* Need to check the init cookie, which will distinguish clients behind a NAT, 
       which also send their IPSec (ESP) traffic to UDP port 500.  If the I cookie
       is zero, then this is NOT an IKE packet, so we return FALSE. */
    if (NdisEqualMemory((PVOID)IPSEC_ISAKMP_GET_ICOOKIE_POINTER(pISAKMPHeader), (PVOID)&EncapsulatedIPSecICookie[0], sizeof(UCHAR) * IPSEC_ISAKMP_HEADER_ICOOKIE_LENGTH)) {
        UNIV_PRINT(("This packet is UDP encapsulated IPSec traffic, not an IKE packet\n"));
        return FALSE;
    }

    /* At this point, this packet should be IKE, so the UDP data should be at least 
       as long as an ISAKMP header. */
    if (cUDPDataLength < IPSEC_ISAKMP_HEADER_LENGTH) {
        UNIV_PRINT(("Malformed ISAKMP header: UDP data length = %u\n", cUDPDataLength));
        return FALSE;
    }

    /* Get the total length of the IKE packet from the ISAKMP header. */
    cISAKMPPacketLength = IPSEC_ISAKMP_GET_PACKET_LENGTH(pISAKMPHeader);

    /* The IKE packet should be at least as long as an ISAKMP header (a whole lot longer, actually). */
    if (cISAKMPPacketLength < IPSEC_ISAKMP_HEADER_LENGTH) {
        UNIV_PRINT(("Malformed ISAKMP header: ISAKMP Packet length = %u\n", cISAKMPPacketLength));
        return FALSE;
    }

    /* Sanity check - the UDP data length and IKE packet length SHOULD be the same. */
    if (cUDPDataLength != cISAKMPPacketLength) {
        UNIV_PRINT(("Expected equal packet lenghts: UDP data length = %u, ISAKMP packet length = %u\n", cUDPDataLength, cISAKMPPacketLength));
        return FALSE;
    }

    /* Get the first payload type out of the ISAKMP header. */
    NextPayload = IPSEC_ISAKMP_GET_NEXT_PAYLOAD(pISAKMPHeader);

    /* IKE security associations are identified by a payload type byte in the header.
       Check that first - this does not ensure that this is what we are looking for 
       because this check will not exclude, for instance, main mode re-keys. */
    if (NextPayload != IPSEC_ISAKMP_SA) {
        UNIV_PRINT(("Not a Main Mode Security Association\n"));
        return FALSE;
    } 

    /* Now check the resp cookie.  If the cookie is all zeros, this is a new main mode 
       SA.  However, we are only really interested in initial contact main mode SAs 
       (the first SA for a particular client), so we need to look a bit further. */
    if (!NdisEqualMemory((PVOID)IPSEC_ISAKMP_GET_RCOOKIE_POINTER(pISAKMPHeader), (PVOID)&MainModeRCookie[0], sizeof(UCHAR) * IPSEC_ISAKMP_HEADER_RCOOKIE_LENGTH)) {
        UNIV_PRINT(("Not a new Main Mode Security Association\n"));
        return FALSE;
    }

    /* Calculate a pointer to the fist generic payload, which is directly after the ISAKMP header. */
    pGenericHeader = (PIPSEC_GENERIC_HDR)((PUCHAR)pISAKMPHeader + IPSEC_ISAKMP_HEADER_LENGTH);

    /* We are looping through the generic payloads looking for the vendor ID and/or notify information. */
    while ((PUCHAR)pGenericHeader <= ((PUCHAR)pISAKMPHeader + cISAKMPPacketLength - IPSEC_GENERIC_HEADER_LENGTH)) {
        /* Extract the payload length from the generic header. */
        USHORT cPayloadLength = IPSEC_GENERIC_GET_PAYLOAD_LENGTH(pGenericHeader);

        /* Not all clients are going to support this (in fact, only the Microsoft client
           will support it, so we need to first see what the vendor ID of the client is.
           if it is a Microsoft client that supports the initial contact vendor ID, then
           we'll look for the initial contact, which provides better stickiness for IPSec
           connections.  If either the client is non-MS, or if it is not a version that
           supports initial contact, then we can revert to the "second-best" solution, 
           which is to provide stickiness _between_ Main Mode SAs.  This means that if a
           client re-keys their Main Mode session, they _may_ be rebalanced to another
           server.  This is still better than the old UDP implementation, but the only
           way to provide full session support for IPSec (without the distributed session
           table nightmare) is to be able to distinguish initial Main Mode SAs from sub-
           sequent Main Mode SAs (re-keys). */
        if (NextPayload == IPSEC_ISAKMP_VENDOR_ID) {
            PIPSEC_VENDOR_HDR pVendorHeader = (PIPSEC_VENDOR_HDR)pGenericHeader;

            /* Make sure that the vendor ID payload is at least as long as a vendor ID. */
            if (cPayloadLength < (IPSEC_GENERIC_HEADER_LENGTH + IPSEC_VENDOR_HEADER_VENDOR_ID_LENGTH)) {
                UNIV_PRINT(("Malformed vendor ID header: Payload length = %d\n", cPayloadLength));
                break;
            }

            /* Look for the Microsoft client vendor ID.  If it is the right version, then we know that 
               the client is going to appropriately set the initial contact information, allowing NLB
               to provide the best possible support for session stickiness. */
            if (NdisEqualMemory((PVOID)IPSEC_VENDOR_ID_GET_ID_POINTER(pVendorHeader), (PVOID)&VIDMicrosoftClient[0], sizeof(UCHAR) * IPSEC_VENDOR_HEADER_VENDOR_ID_LENGTH)) {
                /* Make sure that their is a version number attached to the Microsoft Vendor ID.  Not 
                   all vendor IDs have versions attached, but the Microsoft vendor ID should. */
                if (cPayloadLength < (IPSEC_GENERIC_HEADER_LENGTH + IPSEC_VENDOR_ID_PAYLOAD_LENGTH)) {
                    UNIV_PRINT(("Unable to determine MS client version: Payload length = %d\n", cPayloadLength));
                    break;
                }

                if (IPSEC_VENDOR_ID_GET_VERSION(pVendorHeader) >= IPSEC_VENDOR_ID_MICROSOFT_MIN_VERSION) {
                    /* Microsoft clients whose version is greater than or equal to 4 will support
                       initial contact.  Non-MS clients, or old MS clients will not, so they 
                       receive decent, but not guaranteed sitckines, based solely on MM SAs. */
                    bInitialContactEnabled = TRUE;
                }
            }
        } else if (NextPayload == IPSEC_ISAKMP_NOTIFY) {
            PIPSEC_NOTIFY_HDR pNotifyHeader = (PIPSEC_NOTIFY_HDR)pGenericHeader;

            /* Make sure that the notify payload is the correct length. */
            if (cPayloadLength < (IPSEC_GENERIC_HEADER_LENGTH + IPSEC_NOTIFY_PAYLOAD_LENGTH)) {
                UNIV_PRINT(("Malformed notify header: Payload length = %d\n", cPayloadLength));
                break;
            }

            if (IPSEC_NOTIFY_GET_NOTIFY_MESSAGE(pNotifyHeader) == IPSEC_NOTIFY_INITIAL_CONTACT) {
                /* This is an initial contact notification from the client, which means that this is
                   the first time that the client has contacted this server; more precisely, the client
                   currently has no state associated with this peer.  NLB will "re-balance" on initial 
                   contact notifications, but not other Main Mode key exchanges as long as it can 
                   determine that the client will comply with initial contact notification. */
                bInitialContact = TRUE;
            }
        }

        /* Get the next payload type out of the generic header. */
        NextPayload = IPSEC_GENERIC_GET_NEXT_PAYLOAD(pGenericHeader);
        
        /* Calculate a pointer to the next generic payload. */
        pGenericHeader = (PIPSEC_GENERIC_HDR)((PUCHAR)pGenericHeader + cPayloadLength);
    }

    /* If the vendor ID did not indicate that this client supports initial contact notification,
       then return TRUE, and we go with the less-than-optimal solution of treating Main Mode
       SAs as the connection boundaries, which potentially breaks sessions on MM SA re-keys. */
    if (!bInitialContactEnabled) {
        UNIV_PRINT(("This client does not support initial contact notifications.\n")); 
        return TRUE;
    }

    /* If this was a Main Mode SA from a client that supports initial contact, but did not
       specify the initial contact vendor ID, then this is a re-key for an existing session. */
    if (!bInitialContact) {
        UNIV_PRINT(("Not an initial contact Main Mode Security Association\n"));
        return FALSE;
    }

    /* Otherwise, this IS a Main Mode SA initial contact, which the IPSec 'SYN'. */
    UNIV_PRINT(("Found an initial contact Main Mode Security Association\n"));

    return TRUE;
}
#else  /* !NLB_SESSION_SUPPORT */
BOOLEAN Main_parse_ipsec (PUCHAR pIKEPacket, ULONG cUDPDataLength) {

    return FALSE;
}
#endif /* NLB_SESSION_SUPPORT */

//+----------------------------------------------------------------------------
//
// Function:   Main_ip_send_filter 
//
// Description:  Filter outgoing IP packets
//
// Arguments: MAIN_CTXT      ctxtp - 
//            const PIP_HDR   ip_hdrp - 
//            const PUCHAR    hdrp - 
//            ULONG           len - 
//            IN OUT PULONG   pOperation - 
//                  IN: has to be MAIN_FILTER_OP_NONE
//                  OUT: MAIN_FILTER_OP_NONE or MAIN_FILTER_OP_CTRL
//
// Returns:   BOOLEAN  - TRUE if to allow the packet to go through
//                     FALSE if to drop the packet
//
// History:   kyrilf initial code
//            fengsun Created seperate function 11/14/00
//
//+----------------------------------------------------------------------------
BOOLEAN   Main_ip_send_filter (
    PMAIN_CTXT      ctxtp,
    const PIP_HDR   ip_hdrp,
    const PUCHAR    hdrp,
    ULONG           len,      
    IN OUT PULONG   pOperation)
{
    PUDP_HDR            udp_hdrp = NULL;
    PTCP_HDR            tcp_hdrp = NULL;
    BOOLEAN             acpt = TRUE;       // Whether or not to accept the packet.
    ULONG               svr_port;          // Port for this host.
    ULONG               svr_addr;          // IP address for this host.
    ULONG               clt_port;          // Port for destination client.
    ULONG               clt_addr;          // IP address for destination client.
    ULONG               flags;             // TCP flags.
    ULONG               hlen; 
    ULONG               Protocol;          // Protocol derived from IP header.
    BOOLEAN             bRefused = FALSE;  // TRUE -> BDA has refused handling this packet.

    hlen = sizeof (ULONG) * IP_GET_HLEN (ip_hdrp);
    
    if (len < hlen)
        return FALSE;
    
#if defined(TRACE_IP)
    DbgPrint ("(IP) send \n");
    DbgPrint ("    version       = %d\n",     IP_GET_VERS (ip_hdrp));
    DbgPrint ("    header length = %d\n",     IP_GET_HLEN (ip_hdrp));
    DbgPrint ("    service type  = 0x%x\n",   IP_GET_SRVC (ip_hdrp));
    DbgPrint ("    packet length = %d\n",     IP_GET_PLEN (ip_hdrp));
    DbgPrint ("    frag ident    = %d\n",     IP_GET_FRAG_ID (ip_hdrp));
    DbgPrint ("    frag flags    = 0x%x\n",   IP_GET_FRAG_FLGS (ip_hdrp));
    DbgPrint ("    frag offset   = %d\n",     IP_GET_FRAG_OFF (ip_hdrp));
    DbgPrint ("    time to live  = %d\n",     IP_GET_TTL (ip_hdrp));
    DbgPrint ("    checksum      = 0x04%x\n", IP_GET_CHKSUM (ip_hdrp));
    DbgPrint ("    protocol      = %d ",      IP_GET_PROT (ip_hdrp));
#endif

    UNIV_ASSERT(*pOperation == MAIN_FILTER_OP_NONE);  

    if (IP_GET_FRAG_OFF(ip_hdrp) != 0)
    {
#if defined(TRACE_FRAGS)
        if ((IP_GET_FRAG_FLGS(ip_hdrp) & 0x1) == 0)
            DbgPrint("Fragmented datagram id %d flgs %x off %d received from %d.%d.%d.%d\n",
                     IP_GET_FRAG_ID(ip_hdrp),
                     IP_GET_FRAG_FLGS(ip_hdrp),
                     IP_GET_FRAG_OFF(ip_hdrp),
                     IP_GET_SRC_ADDR (ip_hdrp, 0),
                     IP_GET_SRC_ADDR (ip_hdrp, 1),
                     IP_GET_SRC_ADDR (ip_hdrp, 2),
                     IP_GET_SRC_ADDR (ip_hdrp, 3));
#endif
        /* Always let fragmented packets go out. */
        return TRUE;
    }

    /* Server address is the source IP and client address is the destination IP. */
    svr_addr = IP_GET_SRC_ADDR_64 (ip_hdrp);
    clt_addr = IP_GET_DST_ADDR_64 (ip_hdrp);

    /* Get the IP protocol form the IP header. */
    Protocol = IP_GET_PROT(ip_hdrp);

    /* Packets directed to the dedicated IP address are always passed through.  If the 
       cluster IP address hasn't been set (parameter error), then fall into a pass-
       through mode and pass all traffic up to the upper-layer protocols. */
    if (svr_addr == ctxtp -> ded_ip_addr || ctxtp -> cl_ip_addr == 0)
    {
        if (Protocol != TCPIP_PROTOCOL_UDP)
        {
            /* For UDP protocol, remote control packet has to be handled seperately, so don't accept it yet. */
            return TRUE;
        }
    }

    switch (IP_GET_PROT (ip_hdrp))
    {
    case TCPIP_PROTOCOL_TCP:
#if defined(TRACE_IP) || defined(TRACE_TCP)
        DbgPrint ("(TCP) send \n");
#endif
        
        tcp_hdrp = (PTCP_HDR) hdrp;
        
        hlen += sizeof (ULONG) * TCP_GET_HLEN (tcp_hdrp);  /* v2.0.6 */
        
        if (len < hlen)
            return FALSE;
        
#if defined(TRACE_TCP)
        DbgPrint ("    source port   = %d\n",  TCP_GET_SRC_PORT (tcp_hdrp));
        DbgPrint ("    dest port     = %d\n",  TCP_GET_DST_PORT (tcp_hdrp));
        DbgPrint ("    seq no.       = %d\n",  TCP_GET_SEQ_NO (tcp_hdrp));
        DbgPrint ("    ack no.       = %d\n",  TCP_GET_ACK_NO (tcp_hdrp));
        DbgPrint ("    flags         = %d\n",  TCP_GET_FLAGS (tcp_hdrp));
#endif
        
        svr_port = TCP_GET_SRC_PORT (tcp_hdrp);
        clt_port = TCP_GET_DST_PORT (tcp_hdrp);
        
        /* For PPTP support, because we cannot extract a source port number from the subsequent GRE packets
           in order to match them to an existing PPTP TCP descriptor, we will hardcode the source port number
           here and then do the same for GRE packets.  This way, we can treat GRE packets like TCP data packets
           on this TCP connection.  Note that this breaks when clients are behind a NAT because a single client
           IP address will have many connections to port 1723, each with a different source port.  In that case,
           we break because we are not reference counting SYNs v. FINs - i.e., the first PPTP connection to go
           down would destroy the TCP descriptor for (Client IP, 0, Server IP, 1723).  There are two solutions;
           (1) reference count re-used descriptors (so we require 2 FINs per SYN, not just 2 period), or (2)
           have PPTP use our notification APIs to give us something that we can look for in the GRE packets, 
           such as a call ID, to identify the GRE packet as belonging to a known session. */
        if (svr_port == PPTP_CTRL_PORT)
        {
            if (ctxtp -> convoy_enabled)
            {
                if (NLB_PPTP_SESSION_SUPPORT_ENABLED()) // JosephJ: added 0 && because I'm disabling PPTP session support for now...
                {
                    clt_port = 0;
                }
                else
                {
                    acpt = Main_packet_check(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
                    
                    /* If teaming has suggested that we not allow this packet to pass, dump it. */
                    if (bRefused) acpt = FALSE;

                    break;
                }
            }
            else
            {
                acpt = FALSE;

                break;
            }            
        }
        
        UNIV_ASSERT(IP_GET_FRAG_OFF(ip_hdrp) == 0);
        
        /* Apply filtering algorithm. process connection boundaries different from regular packets. */
        
        /* Get the TCP flags to find out the packet type. */
        flags = TCP_GET_FLAGS (tcp_hdrp);
        
        if (flags & TCP_FLAG_SYN)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("outgoing SYN %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif
            
            /* In the case of an outgoing SYN, we always want to allow the packet to pass, 
               unless the operation was refused (in the case on an inactive BDA team), so
               we ignore the return value, which is the response from the load module, and
               check only refused to determine whether or not to drop the packet.  If this 
               adapter is part of a BDA team, this function will create a descriptor for 
               this TCP connection on the way out to make sure that it will come back to 
               this host, even if a convergence and bucket redistribution occurs before the
               SYNACK is returned from the destination. */
            if (ctxtp -> convoy_enabled) 
            {
                Main_create_dscr(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, &bRefused, TRUE);
            
                /* If teaming has suggested that we not allow this packet to pass, dump it. */
                if (bRefused) acpt = FALSE;
            }
        } 
        else if (flags & TCP_FLAG_FIN)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("outgoing FIN %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif

            /* In the case of an outgoing FIN, we always want to allow the packet to pass, 
               unless the operation was refused (in the case on an inactive BDA team), so
               we ignore the return value, which is the response from the load module, and
               check only refused to determine whether or not to drop the packet. */
            Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, CVY_CONN_DOWN, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;
        }
        else if (flags & TCP_FLAG_RST)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("outgoing RST %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif

            /* In the case of an outgoing RST, we always want to allow the packet to pass, 
               unless the operation was refused (in the case on an inactive BDA team), so
               we ignore the return value, which is the response from the load module, and
               check only refused to determine whether or not to drop the packet. */
            Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, CVY_CONN_RESET, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;
        }

        break;

    case TCPIP_PROTOCOL_UDP:
#if defined(TRACE_IP) || defined(TRACE_UDP)
        DbgPrint ("(UDP) send\n");
#endif
        udp_hdrp = (PUDP_HDR) hdrp;
            
        hlen += sizeof (UDP_HDR);

        if (len < hlen)
            return FALSE;

#if defined(TRACE_UDP)
        DbgPrint ("    source port   = %d\n",  UDP_GET_SRC_PORT (udp_hdrp));
        DbgPrint ("    dest port     = %d\n",  UDP_GET_DST_PORT (udp_hdrp));
        DbgPrint ("    length        = %d\n",  UDP_GET_LEN (udp_hdrp));
#endif

        svr_port = UDP_GET_SRC_PORT (udp_hdrp);
        clt_port = UDP_GET_DST_PORT (udp_hdrp);
            
        /* IP broadcast UDPs generated by wlbs.exe.  Note that we cannot look past UDP header on send and thus check the code. */
        if ((clt_port == ctxtp -> params . rct_port || clt_port == CVY_DEF_RCT_PORT_OLD) && clt_addr == TCPIP_BCAST_ADDR) {
            /* This flag is used by Main_send to enable loop back so that we can respond to a query originated on this host. */
            *pOperation = MAIN_FILTER_OP_CTRL;  
        }

        /* Always allow outgoing UDP packets to go through. */
        UNIV_ASSERT(acpt == TRUE);

        break;

    case TCPIP_PROTOCOL_GRE:
#if defined(TRACE_IP) || defined(TRACE_GRE)
        DbgPrint ("(GRE) send\n");
#endif

        if (ctxtp -> convoy_enabled)
        {
            if (!NLB_PPTP_SESSION_SUPPORT_ENABLED())
            {
                acpt = Main_packet_check(ctxtp, svr_addr, PPTP_CTRL_PORT, clt_addr, 0, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
                
                /* If teaming has suggested that we not allow this packet to pass, dump it. */
                if (bRefused) acpt = FALSE;
            }

            /* Otherwise, PPTP packets are treated like TCP data, which are always allowed to pass. */
        }
        else 
        {
            acpt = FALSE;
        }

#if defined(TRACE_IP) || defined(TRACE_GRE)
        DbgPrint ("accepted %d\n", acpt);
#endif
        break;
    case TCPIP_PROTOCOL_IPSEC1:
    case TCPIP_PROTOCOL_IPSEC2:
#if defined(TRACE_IP) || defined(TRACE_IPSEC)
        DbgPrint ("(IPSEC %d) send \n", IP_GET_PROT (ip_hdrp));
#endif
        if (ctxtp -> convoy_enabled)
        {
            if (!NLB_IPSEC_SESSION_SUPPORT_ENABLED())
            {
                acpt = Main_packet_check(ctxtp, svr_addr, IPSEC_CTRL_PORT, clt_addr, 0, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
                
                /* If teaming has suggested that we not allow this packet to pass, dump it. */
                if (bRefused) acpt = FALSE;
            }

            /* Otherwise, IPSec packets are treated kind of like TCP data, which are always allowed to pass. */
        }
        else
        {
            acpt = FALSE;
        }

#if defined(TRACE_IP) || defined(TRACE_IPSEC)
        DbgPrint ("accepted %d\n", acpt);
#endif
        break;
    case TCPIP_PROTOCOL_ICMP:
#if defined(TRACE_IP)
        DbgPrint ("(ICMP)\n");
#endif
        /* Allow all outgoing ICMP to pass; incoming ICMP may be filtered, however. */
        break;
    default:
        /* Allow other protocols to go out on all hosts. */
#if defined(TRACE_IP)
        DbgPrint ("(unknown)\n");
#endif
        break;
    }

#if defined(TRACE_IP) || defined(TRACE_TCP) || defined(TRACE_UDP)
    DbgPrint ("    src address   = %d.%d.%d.%d\n",
              IP_GET_SRC_ADDR (ip_hdrp, 0),
              IP_GET_SRC_ADDR (ip_hdrp, 1),
              IP_GET_SRC_ADDR (ip_hdrp, 2),
              IP_GET_SRC_ADDR (ip_hdrp, 3));
    DbgPrint ("    dst address   = %d.%d.%d.%d\n",
              IP_GET_DST_ADDR (ip_hdrp, 0),
              IP_GET_DST_ADDR (ip_hdrp, 1),
              IP_GET_DST_ADDR (ip_hdrp, 2),
              IP_GET_DST_ADDR (ip_hdrp, 3));

    DbgPrint ("\n");
#endif

    return acpt;
} 

//+----------------------------------------------------------------------------
//
// Function:   Main_ip_recv_filter 
//
// Description:  Filter incoming IP packets
//
// Arguments: MAIN_CTXT      ctxtp - 
//            const PIP_HDR   ip_hdrp - 
//            const PUCHAR    hdrp - 
//            ULONG           len - 
//            IN OUT PULONG   pOperation - 
//                  IN: has to be MAIN_FILTER_OP_NONE
//                  OUT: MAIN_FILTER_OP_NONE 
//                       MAIN_FILTER_OP_CTRL 
//                       MAIN_FILTER_OP_NBT
//
// Returns:   BOOLEAN  - TRUE if to allow the packet to go through
//                     FALSE if to drop the packet
//
// History:   kyrilf initial code
//            fengsun Created seperate function 11/14/00
//
//+----------------------------------------------------------------------------
BOOLEAN   Main_ip_recv_filter(
    PMAIN_CTXT          ctxtp,
    const PIP_HDR       ip_hdrp,
    const PUCHAR        hdrp,
    ULONG               len,       
    IN OUT PULONG       pOperation)
{
    PUDP_HDR            udp_hdrp = NULL;
    PTCP_HDR            tcp_hdrp = NULL;
    BOOLEAN             acpt = TRUE;         // Whether or not to accept the packet.
    ULONG               svr_port;            // Port for this host.
    ULONG               svr_addr;            // IP address for this host.
    ULONG               clt_port;            // Port for destination client.
    ULONG               clt_addr;            // IP address for destination client.
    ULONG               flags;               // TCP flags.
    ULONG               hlen;
    BOOLEAN             fragmented = FALSE;
    ULONG               Protocol;            // Protocol derived from IP header.
    BOOLEAN             bRefused = FALSE;    // TRUE -> BDA has refused handling this packet.

    hlen = sizeof (ULONG) * IP_GET_HLEN (ip_hdrp);

    if (len < hlen)
        return FALSE;

#if defined(TRACE_IP)
    DbgPrint ("(IP) recv\n");
    DbgPrint ("    version       = %d\n",     IP_GET_VERS (ip_hdrp));
    DbgPrint ("    header length = %d\n",     IP_GET_HLEN (ip_hdrp));
    DbgPrint ("    service type  = 0x%x\n",   IP_GET_SRVC (ip_hdrp));
    DbgPrint ("    packet length = %d\n",     IP_GET_PLEN (ip_hdrp));
    DbgPrint ("    frag ident    = %d\n",     IP_GET_FRAG_ID (ip_hdrp));
    DbgPrint ("    frag flags    = 0x%x\n",   IP_GET_FRAG_FLGS (ip_hdrp));
    DbgPrint ("    frag offset   = %d\n",     IP_GET_FRAG_OFF (ip_hdrp));
    DbgPrint ("    time to live  = %d\n",     IP_GET_TTL (ip_hdrp));
    DbgPrint ("    checksum      = 0x04%x\n", IP_GET_CHKSUM (ip_hdrp));
    DbgPrint ("    protocol      = %d ",      IP_GET_PROT (ip_hdrp));
#endif

    UNIV_ASSERT(*pOperation == MAIN_FILTER_OP_NONE);  

    /* Server address is the destination IP and client address is the source IP. */
    svr_addr = IP_GET_DST_ADDR_64(ip_hdrp);
    clt_addr = IP_GET_SRC_ADDR_64(ip_hdrp);

    /* Get the protocol ID from the IP header. */
    Protocol = IP_GET_PROT(ip_hdrp);

    /* Packets directed to the dedicated IP address are always passed through.  If the 
       cluster IP address hasn't been set (parameter error), then fall into a pass-
       through mode and pass all traffic up to the upper-layer protocols. */
    if (svr_addr == ctxtp -> ded_ip_addr || ctxtp -> cl_ip_addr == 0 ||
        svr_addr == ctxtp -> ded_bcast_addr || svr_addr == ctxtp -> cl_bcast_addr)
    {
        if (Protocol != TCPIP_PROTOCOL_UDP)
        {
            /* For UDP protocol, remote control packet has to be handled seperately, so don't accept it yet. */
            return TRUE;
        }
    }

    /* If the load module is stopped, drop most packets. */
    if (! ctxtp -> convoy_enabled)
    {
        /* Drop TCP, GRE and IPSEC immediately.  Non-remote-control UDP will also
           be dropped, but other protocols will be allowed to pass. */
        if (Protocol == TCPIP_PROTOCOL_TCP || Protocol == TCPIP_PROTOCOL_GRE ||
            Protocol == TCPIP_PROTOCOL_IPSEC1 || Protocol == TCPIP_PROTOCOL_IPSEC2)
        {
            /* For UDP protocol, remote control packet has to be handled seperately, so don't accept it yet. */
            return FALSE; 
        }
    }

#if defined(TRACE_FRAGS)
    if ((IP_GET_FRAG_FLGS(ip_hdrp) & 0x1) != 0)
    {
        DbgPrint("Fragmented datagram id %d flgs %x off %d received from %d.%d.%d.%d\n",
                 IP_GET_FRAG_ID(ip_hdrp),
                 IP_GET_FRAG_FLGS(ip_hdrp),
                 IP_GET_FRAG_OFF(ip_hdrp),
                 IP_GET_SRC_ADDR (ip_hdrp, 0),
                 IP_GET_SRC_ADDR (ip_hdrp, 1),
                 IP_GET_SRC_ADDR (ip_hdrp, 2),
                 IP_GET_SRC_ADDR (ip_hdrp, 3));
    }
#endif

    if (IP_GET_FRAG_OFF(ip_hdrp) != 0)
    {
#if defined(TRACE_FRAGS)
        if ((IP_GET_FRAG_FLGS(ip_hdrp) & 0x1) == 0)
            DbgPrint("Fragmented datagram id %d flgs %x off %d received from %d.%d.%d.%d\n",
                     IP_GET_FRAG_ID(ip_hdrp),
                     IP_GET_FRAG_FLGS(ip_hdrp),
                     IP_GET_FRAG_OFF(ip_hdrp),
                     IP_GET_SRC_ADDR (ip_hdrp, 0),
                     IP_GET_SRC_ADDR (ip_hdrp, 1),
                     IP_GET_SRC_ADDR (ip_hdrp, 2),
                     IP_GET_SRC_ADDR (ip_hdrp, 3));
#endif
        /* In optimized-fragment mode; If we have no rules, or a single rule that will
           not look at anything or only source IP address (the only exception to this
           is multiple handling mode with no affinity that also uses source port for
           its decision making), then we can just rely on normal mechanism to handle
           every fragmented packet, since the algorithm will not attempt to look past 
           the IP header.

           For multiple rules, or single rule with no affinity, apply algorithm only
           to the first packet that has UDP/TCP header and then let fragmented packets
           up on all of the systems.  TCP will then do the right thing and throw away
           the fragments on all of the systems other than the one that handled the first 
           fragment.

           If port rules will not let us handle IP fragments reliably, let TCP filter 
           them out based on sequence numbers. */

        if (! ctxtp -> optimized_frags)
            return TRUE;
        
        fragmented = TRUE;
    }
    
    switch (Protocol)
    {
    case TCPIP_PROTOCOL_TCP:
#if defined(TRACE_IP) || defined(TRACE_TCP)
        DbgPrint ("(TCP) recv\n");
#endif

        tcp_hdrp = (PTCP_HDR) hdrp;
        
        if (! fragmented)
        {
            hlen += sizeof (ULONG) * TCP_GET_HLEN (tcp_hdrp);
            
            if (len < hlen)
                return FALSE;
            
#if defined(TRACE_TCP)
            DbgPrint ("    source port   = %d\n",  TCP_GET_SRC_PORT (tcp_hdrp));
            DbgPrint ("    dest port     = %d\n",  TCP_GET_DST_PORT (tcp_hdrp));
            DbgPrint ("    seq no.       = %d\n",  TCP_GET_SEQ_NO (tcp_hdrp));
            DbgPrint ("    ack no.       = %d\n",  TCP_GET_ACK_NO (tcp_hdrp));
            DbgPrint ("    flags         = %d\n",  TCP_GET_FLAGS (tcp_hdrp));
#endif

            clt_port = TCP_GET_SRC_PORT (tcp_hdrp);
            svr_port = TCP_GET_DST_PORT (tcp_hdrp);

            /* For PPTP support, because we cannot extract a source port number from the subsequent GRE packets
               in order to match them to an existing PPTP TCP descriptor, we will hardcode the source port number
               here and then do the same for GRE packets.  This way, we can treat GRE packets like TCP data packets
               on this TCP connection.  Note that this breaks when clients are behind a NAT because a single client
               IP address will have many connections to port 1723, each with a different source port.  In that case,
               we break because we are not reference counting SYNs v. FINs - i.e., the first PPTP connection to go
               down would destroy the TCP descriptor for (Client IP, 0, Server IP, 1723).  There are two solutions;
               (1) reference count re-used descriptors (so we require 2 FINs per SYN, not just 2 period), or (2)
               have PPTP use our notification APIs to give us something that we can look for in the GRE packets, 
               such as a call ID, to identify the GRE packet as belonging to a known session. */
            if (svr_port == PPTP_CTRL_PORT)
            {
                if (NLB_PPTP_SESSION_SUPPORT_ENABLED())
                {
                    clt_port = 0;
                }
                else
                {
                    UNIV_ASSERT(ctxtp -> convoy_enabled);
                    
                    acpt = Main_packet_check(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
	            
                    /* If teaming has suggested that we not allow this packet to pass, dump it. */
                    if (bRefused) acpt = FALSE;
                    
                    break;
                }
            }

            flags = TCP_GET_FLAGS (tcp_hdrp);
        }
        else
        {
            clt_port = 0;
            svr_port = 0;
            flags = 0;
        }

        /* Apply filtering algorithm.  Process connection boundaries different from regular packets. */

        if (flags & TCP_FLAG_SYN)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("incoming SYN %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif
            acpt = Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, CVY_CONN_UP, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;
        }
        else if (flags & TCP_FLAG_FIN)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("incoming FIN %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif
            acpt = Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, CVY_CONN_DOWN, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;
        }
        else if (flags & TCP_FLAG_RST)
        {
#if defined(TRACE_CNCT)
            DbgPrint ("incoming RST %x from %d.%d.%d.%d:%d\n",
                      TCP_GET_FLAGS (tcp_hdrp),
                      IP_GET_SRC_ADDR (ip_hdrp, 0),
                      IP_GET_SRC_ADDR (ip_hdrp, 1),
                      IP_GET_SRC_ADDR (ip_hdrp, 2),
                      IP_GET_SRC_ADDR (ip_hdrp, 3),
                      TCP_GET_SRC_PORT (tcp_hdrp));
#endif
            acpt = Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, CVY_CONN_RESET, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;
        }
        else
        {
            UNIV_ASSERT(! (flags & (TCP_FLAG_SYN | TCP_FLAG_FIN | TCP_FLAG_RST)));

            acpt = Main_packet_check(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_TCP, &bRefused, FALSE);

            /* If teaming has suggested that we not allow this packet to pass, dump it. */
            if (bRefused) acpt = FALSE;

            /* Post-process NBT traffic on receive. */
            if (svr_port == NBT_SESSION_PORT && ctxtp -> params . nbt_support && acpt)
                * pOperation = MAIN_FILTER_OP_NBT;
        }

        break;

    case TCPIP_PROTOCOL_UDP:
#if defined(TRACE_IP) || defined(TRACE_UDP)
        DbgPrint ("(UDP) recv \n");
#endif
        udp_hdrp = (PUDP_HDR) hdrp;

        hlen += sizeof (UDP_HDR);

        if (! fragmented)
        {
            if (len < hlen)
                return FALSE;

#if defined(TRACE_UDP)
            DbgPrint ("    source port   = %d\n",  UDP_GET_SRC_PORT (udp_hdrp));
            DbgPrint ("    dest port     = %d\n",  UDP_GET_DST_PORT (udp_hdrp));
            DbgPrint ("    length        = %d\n",  UDP_GET_LEN (udp_hdrp));
#endif
        }

        if (! fragmented)
        {
            clt_port = UDP_GET_SRC_PORT (udp_hdrp);
            svr_port = UDP_GET_DST_PORT (udp_hdrp);
        }
        else
        {
            clt_port = 0;
            svr_port = 0;
        }

        if (! fragmented)
        {
            if (clt_port == ctxtp -> params . rct_port || clt_port == CVY_DEF_RCT_PORT_OLD)
            {
                /* Allow incoming remote control response to go through on all hosts. */
                PIOCTL_REMOTE_HDR rct_hdrp = (PIOCTL_REMOTE_HDR) UDP_GET_DGRAM_PTR(udp_hdrp);

                if (rct_hdrp -> code == IOCTL_REMOTE_CODE) break;
            }

            /* Let remote control request go through regardless whether remote control is 
               enabled.  Remote query could be processed even if remote control is disabled.
               The request will be queued up and handled on receive complete. */
            if (svr_port == ctxtp -> params . rct_port || svr_port == CVY_DEF_RCT_PORT_OLD)
            {
                PIOCTL_REMOTE_HDR rct_hdrp = (PIOCTL_REMOTE_HDR) UDP_GET_DGRAM_PTR(udp_hdrp);

                /* Make sure this is our remote message. note that we are assuming that RCT
                   header imediatelly folows the UDP header.  This is only TRUE on receive. */
                if (rct_hdrp -> code == IOCTL_REMOTE_CODE)
                {
                    /* Consume receives and handle them during the receive complete event. */
#if defined(TRACE_RCT)
                    DbgPrint ("(RCT) received on port %d from %d.%d.%d.%d:%d\n",
                              svr_port,
                              IP_GET_SRC_ADDR (ip_hdrp, 0),
                              IP_GET_SRC_ADDR (ip_hdrp, 1),
                              IP_GET_SRC_ADDR (ip_hdrp, 2),
                              IP_GET_SRC_ADDR (ip_hdrp, 3),
                              clt_port);
#endif
                    *pOperation = MAIN_FILTER_OP_CTRL;
                    break;
                }
            }
        }

        /* Packets directed to the dedicated IP address are always passed through.  If the 
           cluster IP address hasn't been set (parameter error), then fall into a pass-
           through mode and pass all traffic up to the upper-layer protocols. */
        if (svr_addr == ctxtp -> ded_ip_addr || ctxtp -> cl_ip_addr == 0 ||
            svr_addr == ctxtp -> ded_bcast_addr || svr_addr == ctxtp -> cl_bcast_addr)
            break;

        /* Apply filtering algorithm. */
        if (ctxtp -> convoy_enabled)
        {
            /* UDP packets that arrive on port 500 are IPSec control packets. */
            if (NLB_IPSEC_SESSION_SUPPORT_ENABLED() && svr_port == IPSEC_CTRL_PORT)
            {
                /* First, parse the IKE payload to find out whether or not 
                   this is an initial contact IKE Main Mode SA. */
                BOOLEAN bIsIKEInitialContact = Main_parse_ipsec((PUCHAR)udp_hdrp + sizeof(UDP_HDR), len - hlen);
                
                /* If this is an intial contact, treat this as a TCP SYN.  Otherwise, treat it like a TCP data packet. */
                if (bIsIKEInitialContact) {
                    /* Because there may not be an explicit connection down notififcation from IPSec, we first need to clean out any 
                       descriptor that might already exist for this tuple.  If we still own the bucket, we'll just end up re-creating 
                       it, but if we do not, then somebody else will, so we have to clean out the descriptor to keep us from handling
                       another host's traffic.  Since this is just as likely to fail as succeed, and we don't really care either way,
                       ignore the return value. */
                    Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_IPSEC1, CVY_CONN_RESET, &bRefused, FALSE);
                        
                    /* If we own the bucket for this tuple, we'll create a descriptor and accept the packet.  If the client is not behind a 
                       NAT, then the source port will be IPSEC_CTRL_PORT (500).  If the client is behind a NAT, the source port will be 
                       arbitrary, but will persist for the entire IPSec session, so we can use it to distinguish clients behind a NAT.  In
                       such a scenario, all IPSec data (non-control traffic) is encapsulated in UDP packets, so the packet check will be 
                       performed in the else case of this branch.  In a non-NAT case, the data is in IPSec1/2 protocol packets, which will
                       be handled analagously in another case of this protocol switch statement. */
                    acpt = Main_conn_advise(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_IPSEC1, CVY_CONN_UP, &bRefused, FALSE);
                } else {
                    /* If this is part of an existing IPSec session, then we have to have a descriptor in order to accpet it.  This will 
                       keep all IPSec traffic during the key exchange sticky, plus the data exchange if the client is behind a NAT. */
                    acpt = Main_packet_check(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_IPSEC1, &bRefused, FALSE);
                }
                
                if (bRefused) acpt = FALSE;
            } else {
                acpt = Main_packet_check(ctxtp, svr_addr, svr_port, clt_addr, clt_port, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
                
                /* If teaming has suggested that we not allow this packet to pass, dump it. */
                if (bRefused) acpt = FALSE;
            }
        }
        else
        {
            acpt = FALSE;
        }

        break;

    case TCPIP_PROTOCOL_GRE:
#if defined(TRACE_IP) || defined(TRACE_GRE)
        DbgPrint ("(GRE) recv");
#endif
        
        if (NLB_PPTP_SESSION_SUPPORT_ENABLED())
        {
            /* For PPTP support, because we cannot extract a source port number from the subsequent GRE packets
               in order to match them to an existing PPTP TCP descriptor, we will hardcode the source port number
               here and then do the same for GRE packets.  This way, we can treat GRE packets like TCP data packets
               on this TCP connection.  Note that this breaks when clients are behind a NAT because a single client
               IP address will have many connections to port 1723, each with a different source port.  In that case,
               we break because we are not reference counting SYNs v. FINs - i.e., the first PPTP connection to go
               down would destroy the TCP descriptor for (Client IP, 0, Server IP, 1723).  There are two solutions;
               (1) reference count re-used descriptors (so we require 2 FINs per SYN, not just 2 period), or (2)
               have PPTP use our notification APIs to give us something that we can look for in the GRE packets, 
               such as a call ID, to identify the GRE packet as belonging to a known session. */
            acpt = Main_packet_check(ctxtp, svr_addr, PPTP_CTRL_PORT, clt_addr, 0, TCPIP_PROTOCOL_TCP, &bRefused, FALSE);
        }
        else
        {
            acpt = Main_packet_check(ctxtp, svr_addr, PPTP_CTRL_PORT, clt_addr, 0, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
        }
        
        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (bRefused) acpt = FALSE;

#if defined(TRACE_IP) || defined(TRACE_GRE)
        DbgPrint ("accepted %d\n", acpt);
#endif
        break;

    case TCPIP_PROTOCOL_IPSEC1:
    case TCPIP_PROTOCOL_IPSEC2:
#if defined(TRACE_IP) || defined(TRACE_IPSEC)
        DbgPrint ("(IPSEC %d) recv \n", IP_GET_PROT (ip_hdrp));
#endif
        if (NLB_IPSEC_SESSION_SUPPORT_ENABLED()) 
        {
            /* NLB_SESSION_SUPPORT: If this is part of an existing IPSec session, then we have to have a descriptor in order to accpet it.  Because 
               this can only happen in the case where the client is NOT behind a NAT, we can safely hardcode the client port
               to IPSEC_CTRL_PORT (500).  In NAT scenarios, the data traffic is UDP encapsulated, not IPSec protocol type 
               traffic, and is distinguished by source port. */
            acpt = Main_packet_check(ctxtp, svr_addr, IPSEC_CTRL_PORT, clt_addr, IPSEC_CTRL_PORT, TCPIP_PROTOCOL_IPSEC1, &bRefused, FALSE);
        }
        else
        {
            acpt = Main_packet_check(ctxtp, svr_addr, IPSEC_CTRL_PORT, clt_addr, 0, TCPIP_PROTOCOL_UDP, &bRefused, FALSE);
        }

        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (bRefused) acpt = FALSE;

#if defined(TRACE_IP) || defined(TRACE_IPSEC)
        DbgPrint ("accepted %d\n", acpt);
#endif
        break;
    case TCPIP_PROTOCOL_ICMP:
        /* In BDA teaming mode, we don't want all hosts to send up ICMP traffic, just one, due
           to multiplicitive effects in a clustered router configuration.  Hardcode the ports,
           since ICMP has no notion of port numbers. */
        acpt = Main_packet_check(ctxtp, svr_addr, 0, clt_addr, 0, TCPIP_PROTOCOL_UDP, &bRefused, TRUE);

        /* If teaming has suggested that we not allow this packet to pass, dump it. */
        if (bRefused) acpt = FALSE;

        break;
    default:
        //
        //  Allow other protocols to go through on all hosts
        //
#if defined(TRACE_IP)
        DbgPrint ("(unknown)\n");
#endif
        break;
    }

#if defined(TRACE_IP) || defined(TRACE_TCP) || defined(TRACE_UDP)
    DbgPrint ("    src address   = %d.%d.%d.%d\n",
              IP_GET_SRC_ADDR (ip_hdrp, 0),
              IP_GET_SRC_ADDR (ip_hdrp, 1),
              IP_GET_SRC_ADDR (ip_hdrp, 2),
              IP_GET_SRC_ADDR (ip_hdrp, 3));
    DbgPrint ("    dst address   = %d.%d.%d.%d\n",
              IP_GET_DST_ADDR (ip_hdrp, 0),
              IP_GET_DST_ADDR (ip_hdrp, 1),
              IP_GET_DST_ADDR (ip_hdrp, 2),
              IP_GET_DST_ADDR (ip_hdrp, 3));

    DbgPrint ("\n");
#endif

    return acpt;
} 



ULONG   Main_recv_ping (
    PMAIN_CTXT          ctxtp,
    PMAIN_FRAME_HDR     cvy_hdrp)
{
#if defined(TRACE_CVY)
    DbgPrint ("(CVY %d)\n", cvy_hdrp -> host);
#endif

    /* V1.3.2b - do not need to protect here since we are not making the
       decision to call Load_ routines */

    if (! ctxtp -> convoy_enabled)
        return FALSE;

    /* only accept messages from our cluster */

    if (cvy_hdrp->cl_ip_addr == 0 ||
        cvy_hdrp->cl_ip_addr != ctxtp -> cl_ip_addr)
        return FALSE;

    /* sanity check host id */

    if (cvy_hdrp -> host == 0 || cvy_hdrp -> host > CVY_MAX_HOSTS)
    {
        UNIV_PRINT (("bad host id %d", cvy_hdrp -> host));

        if (! ctxtp -> bad_host_warned)
        {
            LOG_MSG1 (MSG_ERROR_HOST_ID, MSG_NONE, cvy_hdrp -> host);
            ctxtp -> bad_host_warned = TRUE;
        }

        return FALSE;
    }

    if ((cvy_hdrp -> host != ctxtp -> params . host_priority) &&
        (cvy_hdrp -> ded_ip_addr == ctxtp -> ded_ip_addr) &&
        (ctxtp -> ded_ip_addr != 0))
    {
        UNIV_PRINT (("duplicate dedicated IP address 0x%x", ctxtp -> ded_ip_addr));

        if (! ctxtp -> dup_ded_ip_warned)
        {
            LOG_MSG (MSG_ERROR_DUP_DED_IP_ADDR, ctxtp -> params . ded_ip_addr);
            ctxtp -> dup_ded_ip_warned = TRUE;
        }
    } 

    /* might want to take appropriate actions for a message from a host
       running different version number of software */

    if (cvy_hdrp -> version != CVY_VERSION_FULL)
    {
        ;
    }

    return TRUE;

} /* end Main_recv_ping */


PNDIS_PACKET Main_send (
    PMAIN_CTXT          ctxtp,
    PNDIS_PACKET        packetp,
    PULONG              exhausted)
{
    PUCHAR              hdrp, mac_hdrp;
    ULONG               plen;
    USHORT              sig;
    PUCHAR              tcp_hdrp;
    PNDIS_PACKET        newp;
    ULONG               op = MAIN_FILTER_OP_NONE;
    USHORT              group;


    * exhausted = FALSE;

    /* extract payload, IP and MAC pointers */

    hdrp = Main_frame_parse (ctxtp, packetp, & mac_hdrp, 0, & tcp_hdrp, & plen,
                             & sig, & group, TRUE);

    if (hdrp == NULL)
        return NULL;

    /* process IP frames */

    if (sig == TCPIP_IP_SIG)  /* v2.0.6 */
    {
        if (tcp_hdrp == NULL ||
            ! Main_ip_send_filter (ctxtp, (PIP_HDR) hdrp, tcp_hdrp, plen, & op))
            return NULL;
    }

    /* process ARP frames */

    else if (sig == TCPIP_ARP_SIG)
    {
//        ctxtp -> arps_count ++;
        if (! Main_arp_handle (ctxtp, (PARP_HDR) hdrp, plen, TRUE))  /* v2.0.6 */
            return NULL;
    }

    /* if still sending out - get a new packet */

    newp = Main_packet_get (ctxtp, packetp, TRUE, group, plen);

    * exhausted = (newp == NULL);

    /* in unicast mode, if this is a remote control packet, make sure it will
       loopback to us. */

    if (newp != NULL && op == MAIN_FILTER_OP_CTRL)
        NdisClearPacketFlags(newp, NDIS_FLAGS_DONT_LOOPBACK);

    return newp;

} /* end Main_send */


PNDIS_PACKET Main_recv (
    PMAIN_CTXT          ctxtp,
    PNDIS_PACKET        packetp)
{
    PMAIN_FRAME_HDR     cvy_hdrp;
    PUCHAR              hdrp, mac_hdrp;
    ULONG               len, dlen, plen;
    USHORT              sig = 0;
    PUCHAR              tcp_hdrp;
    PNDIS_PACKET        newp;
    PMAIN_BUFFER        bp;
    PMAIN_PROTOCOL_RESERVED resp;
    PNDIS_PACKET_OOB_DATA   oobp;
    ULONG               size, xferred;
    PLIST_ENTRY         entryp;
    ULONG               op = MAIN_FILTER_OP_NONE;
    PNBT_HDR            nbt_hdrp;
    USHORT              group;
    ULONG               packet_lowmark;

    /* extract payload, IP and MAC pointers */

    hdrp = Main_frame_parse (ctxtp, packetp, & mac_hdrp, 0, & tcp_hdrp, & len,
                             & sig, & group, FALSE);

    if (hdrp == NULL)
        return NULL;

    plen = len;

    cvy_hdrp = (PMAIN_FRAME_HDR) hdrp;

    /* process IP frames */

    if (sig == TCPIP_IP_SIG)  /* v2.0.6 */
    {
        if (tcp_hdrp == NULL ||
            ! Main_ip_recv_filter (ctxtp, (PIP_HDR) hdrp, tcp_hdrp, plen, & op))
            return NULL;
    }

    /* process ARP frames */

    else if (sig == TCPIP_ARP_SIG)
    {
        if (! Main_arp_handle (ctxtp, (PARP_HDR) hdrp, plen, FALSE))  /* v2.0.6 */
            return NULL;
    }

    /* process heartbeat frames */

    else if ((sig == MAIN_FRAME_SIG || sig == MAIN_FRAME_SIG_OLD) &&
             cvy_hdrp -> code == MAIN_FRAME_CODE)
    {
        /* make sure it looks acceptable */

        if (len >= sizeof (MAIN_FRAME_HDR) && Main_recv_ping (ctxtp, cvy_hdrp))
        {

#if defined (NLB_MIXED_MODE_CLUSTERS)
	    // code for migrating between cluster modes
	    /* reject the packet if the mac address is not ours to allow unicast and multicast clusters to exist */
	    {
		ULONG    doff = CVY_MAC_DST_OFF (ctxtp -> medium);


		if (ctxtp -> params . mcast_support &&
		    (! CVY_MAC_ADDR_COMP (ctxtp -> medium, mac_hdrp + doff, & ctxtp -> ded_mac_addr)))
		{
		    return NULL;
		}
	    }
#endif /* NLB_MIXED_MODE_CLUSTERS */

            /* V2.2 switch into backward compatibility mode if a convoy hearbeat
               is detected */

            if (sig == MAIN_FRAME_SIG_OLD && ! ctxtp -> etype_old)
            {
                if (ctxtp -> medium == NdisMedium802_3)
                {
                    CVY_ETHERNET_ETYPE_SET (& ctxtp -> media_hdr . ethernet, MAIN_FRAME_SIG_OLD);
                }

                ctxtp -> etype_old = TRUE;
            }

            if (len >= (sizeof (MAIN_FRAME_HDR) + sizeof (PING_MSG)))
            {
                /* recompute pointer to the ping message */

                Main_frame_parse (ctxtp, packetp, & mac_hdrp, sizeof (MAIN_FRAME_HDR),
                                  & hdrp, & len, & sig, & group, FALSE);

                /* have load deal with contents */

                NdisAcquireSpinLock (& ctxtp -> load_lock);
                if (ctxtp -> convoy_enabled && hdrp != NULL) /* V1.3.2b, V2.0.6 */
                    Load_msg_rcv (& ctxtp -> load, (PPING_MSG) hdrp);
                NdisReleaseSpinLock (& ctxtp -> load_lock);
            }
            else
            {
                UNIV_PRINT (("PING message size mismatch %d vs %d", len, sizeof (MAIN_FRAME_HDR) + sizeof (PING_MSG)));
            }
        }

        if (! ctxtp -> params . netmon_alive)
            return NULL;
    }

    /* post-process NBT traffic */

    if (op == MAIN_FILTER_OP_NBT)
    {
        dlen = TCP_GET_DGRAM_LEN ((PIP_HDR) hdrp, (PTCP_HDR) tcp_hdrp);

        /* have to re-parse packet to find offset to NBT header */

        hdrp = Main_frame_parse (ctxtp, packetp, & mac_hdrp, len - dlen,
                                 (PUCHAR * ) & nbt_hdrp, & len, & sig, & group,
                                 FALSE);

        /* V2.1 let TCP module mask machine name if necessary */

        if (hdrp != NULL && nbt_hdrp != NULL &&
            plen >= (((PUCHAR) nbt_hdrp) - ((PUCHAR) hdrp) + dlen))
        {
            Tcpip_nbt_handle (& ctxtp -> tcpip, (PIP_HDR) hdrp, (PTCP_HDR) tcp_hdrp,
                              dlen, nbt_hdrp);
        }
    }

    /* get a new packet */

    if (op != MAIN_FILTER_OP_CTRL)
    {
        newp = Main_packet_get (ctxtp, packetp, FALSE, group, plen);

        if (newp == NULL)
            ctxtp -> cntr_recv_no_buf ++; /* V2.0.6 */
    }

    /* copy incoming remote control packet into our own, so we re-use it later
       to send back reply */

    else
    {
        /* V1.3.2b */

        newp = Main_packet_alloc (ctxtp, FALSE, & packet_lowmark);

        if (newp == NULL)
        {
            ctxtp -> cntr_recv_no_buf ++; /* V2.0.6 */
            return NULL;
        }

        /* get a buffer */

        while (1)
        {
            NdisAcquireSpinLock (& ctxtp -> buf_lock);
            entryp = RemoveHeadList (& ctxtp -> buf_list);

            if (entryp != & ctxtp -> buf_list)
            {
                ctxtp->num_bufs_out++;
                NdisReleaseSpinLock (& ctxtp -> buf_lock);
                break;
            }

            NdisReleaseSpinLock (& ctxtp -> buf_lock);

            UNIV_PRINT (("OUT OF BUFFERS!!!"));

            if (! Main_bufs_alloc (ctxtp))
            {
                NdisFreePacket (newp);
                ctxtp -> cntr_recv_no_buf ++; /* V2.0.6 */
                return NULL;
            }
        }

        bp = CONTAINING_RECORD (entryp, MAIN_BUFFER, link);
        UNIV_ASSERT (bp -> code == MAIN_BUFFER_CODE);

        size = ctxtp -> buf_mac_hdr_len + len;

        NdisAdjustBufferLength (bp -> full_bufp, size);
        NdisChainBufferAtFront (newp, bp -> full_bufp);

        /* copy actual data */

        NdisCopyFromPacketToPacket (newp, 0, size, packetp, 0, & xferred);

        /* copy OOB info */

        oobp = NDIS_OOB_DATA_FROM_PACKET (newp);
        oobp -> HeaderSize               = ctxtp -> buf_mac_hdr_len;
        oobp -> MediaSpecificInformation = NULL;
        oobp -> SizeMediaSpecificInfo    = 0;
        oobp -> TimeSent                 = 0;
        oobp -> TimeReceived             = 0;

        /* shouse - Because packets marked as CTRL never pass above NLB in the 
           network stack, we can always use the ProtocolReserved field. */
        resp = MAIN_PROTOCOL_FIELD (newp);
        
        if (packet_lowmark)
            NDIS_SET_PACKET_STATUS (newp, NDIS_STATUS_RESOURCES);

        /* set protocol reserved fields */

        resp -> type   = MAIN_PACKET_TYPE_CTRL;
        resp -> miscp  = bp;
        resp -> data   = 0;

        /* V2.0.6 */

        resp -> group  = group;
        resp -> len    = plen; /* 64-bit -- ramkrish */

        /* Because this is a remote control packet, MiniportReserved
           should not contain a pointer to a private protocol buffer. */
        ASSERT(!MAIN_MINIPORT_FIELD(newp));
    }

    return newp;

} /* end Main_recv */


PNDIS_PACKET Main_recv_indicate (
    PMAIN_CTXT          ctxtp,
    NDIS_HANDLE         handle,
    PUCHAR              look_buf,
    UINT                look_len,
    UINT                packet_len,
    PUCHAR              head_buf,
    UINT                head_len,
    PBOOLEAN            accept)
{
    PIP_HDR             ip_hdrp;
    PUCHAR              tcp_hdrp;
    USHORT              sig = 0;
    PMAIN_FRAME_HDR     cvy_hdrp;
    PUCHAR              hdrp;
    PNDIS_PACKET        newp;
    PMAIN_PROTOCOL_RESERVED resp = NULL;
    PLIST_ENTRY         entryp;
    PMAIN_BUFFER        bp;
    NDIS_STATUS         status;
    ULONG               op = MAIN_FILTER_OP_NONE;
    ULONG               len, xferred, off, dlen;
    PNBT_HDR            nbt_hdrp;
    ULONG               plen;
    USHORT              group;
    ULONG               packet_lowmark;
    UINT                offset;


    /* find pointer to payload */

    *accept = FALSE;
    hdrp = Main_frame_find (ctxtp, head_buf, look_buf, look_len, & sig);

    if (hdrp == NULL)
        return NULL;

    cvy_hdrp = (PMAIN_FRAME_HDR) hdrp;

    /* V2.0.6 find out actual payload length (minus LLC/SNAP) */

    plen = (ULONG)(packet_len - (hdrp - look_buf));

    /* process IP frames */

    if (sig == TCPIP_IP_SIG)
    {
        ip_hdrp = (PIP_HDR) hdrp;

        tcp_hdrp = hdrp + sizeof (ULONG) * IP_GET_HLEN (ip_hdrp);

        if (! Main_ip_recv_filter (ctxtp, ip_hdrp, tcp_hdrp, plen, & op))
            return NULL;
    }

    /* process heartbeat frames */

    else if ((sig == MAIN_FRAME_SIG || sig == MAIN_FRAME_SIG_OLD) &&
             cvy_hdrp -> code == MAIN_FRAME_CODE)
    {
        /* make sure frame looks acceptable */

        if (plen >= (sizeof (MAIN_FRAME_HDR) + sizeof (PING_MSG)))
        {
            /* V2.2 switch into backward compatibility mode if a convoy hearbeat
               is detected */

            if (sig == MAIN_FRAME_SIG_OLD && ! ctxtp -> etype_old)
            {
                if (ctxtp -> medium == NdisMedium802_3)
                {
                    CVY_ETHERNET_ETYPE_SET (& ctxtp -> media_hdr . ethernet, MAIN_FRAME_SIG_OLD);
                }

                ctxtp -> etype_old = TRUE;
            }

            if (Main_recv_ping (ctxtp, cvy_hdrp))
            {
#if defined (NLB_MIXED_MODE_CLUSTERS)
		// code for migrating between cluster modes
		/* reject the packet if the mac address is broadcast to allow unicast and multicast clusters to exist */
		{
		    ULONG    doff = CVY_MAC_DST_OFF (ctxtp -> medium);


		    if (ctxtp -> params . mcast_support &&
			(! CVY_MAC_ADDR_COMP (ctxtp -> medium, head_buf + doff, & ctxtp -> cl_mac_addr)))
		    {
			return NULL;
		    }
		}
#endif /* NLB_MIXED_MODE_CLUSTERS */

                /* V1.3.2b - if entire frame is in lookahead - let load deal with
                   it now */

#ifndef _WIN64 /* 64-bit -- ramkrish */
/* The data in the buffer may not be aligned. so copy the data into our own structure */
                if (look_len == packet_len)
                {
                    NdisAcquireSpinLock (& ctxtp -> load_lock);
                    if (ctxtp -> convoy_enabled)
                        Load_msg_rcv (& ctxtp -> load, (PPING_MSG) (cvy_hdrp + 1));
                    NdisReleaseSpinLock (& ctxtp -> load_lock);
                }

                /* get a fresh frame descriptor and perform data transfer */

                else
#endif         /* 64-bit -- ramkrish */
                {
                    newp = Main_frame_get (ctxtp, FALSE, & len, MAIN_PACKET_TYPE_PING);

                    if (newp == NULL)
                    {
                        UNIV_PRINT (("error getting frame packet"));
                        return NULL;
                    }

                    NdisTransferData (& status, ctxtp -> mac_handle, handle, 0,
                                        len, newp, & xferred);

                    if (status != NDIS_STATUS_PENDING)
                        Main_xfer_done (ctxtp, newp, status, xferred);
                }
            }
        }
        else
        {
            UNIV_PRINT (("PING message size mismatch %d vs %d", packet_len - (hdrp - look_buf), sizeof (MAIN_FRAME_HDR) + sizeof (PING_MSG)));
        }

        if (! ctxtp -> params . netmon_alive)
            return NULL;
    }

    /* If statement added for NT 5.1 - ramkrish */
    * accept = TRUE;

    /* If the packet is being accepted and indicated to the protocol layer,
     * then modify the destination mac address in multicast mode.
     */
    if (sig == TCPIP_IP_SIG && op == MAIN_FILTER_OP_NONE)
    {
        offset = CVY_MAC_DST_OFF(ctxtp -> medium);

        if (ctxtp -> params . mcast_support &&
            CVY_MAC_ADDR_COMP(ctxtp -> medium, head_buf + offset, & ctxtp -> cl_mac_addr) )
        {
                CVY_MAC_ADDR_COPY(ctxtp -> medium, head_buf + offset, & ctxtp -> ded_mac_addr);
        }

        return NULL;
    }

    /* The ARPs and NBT packets need to be modified */
    /* V1.3.2b - get fresh packet */

    /* shouse - On indicated receives, we need to use the MiniportReserved field to store
       our private data.  If allocation fails, bail out and dump the packet.  CTRL packets
       can continue to use ProtocolReserved because they never go up the stack. */
    if (op != MAIN_FILTER_OP_CTRL) {
        resp = (PMAIN_PROTOCOL_RESERVED) NdisAllocateFromNPagedLookasideList (& ctxtp -> resp_list);
    
        if (!resp) {
            * accept = FALSE; /* ###### no resources for the packet, so drop it */
            return NULL;
        }
    }

    newp = Main_packet_alloc (ctxtp, FALSE, & packet_lowmark);

    if (newp == NULL)
    {
        * accept = FALSE; /* ###### cannot allocate packet, so drop it */
        ctxtp -> cntr_recv_no_buf ++; /* V2.0.6 */

        /* shouse - If we can't allocate a packet, put the private buffer back on the list. */
        if (resp) NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);

        return NULL;
    }

    /* get fresh buffer */

    while (1)
    {

        NdisAcquireSpinLock (& ctxtp -> buf_lock);
        entryp = RemoveHeadList (& ctxtp -> buf_list);

        if (entryp != & ctxtp -> buf_list)
        {
            ctxtp->num_bufs_out++;
            NdisReleaseSpinLock (& ctxtp -> buf_lock);
            break;
        }

        NdisReleaseSpinLock (& ctxtp -> buf_lock);

        UNIV_PRINT (("OUT OF BUFFERS!!!"));

        if (! Main_bufs_alloc (ctxtp))
        {
            NdisFreePacket (newp);
            ctxtp -> cntr_recv_no_buf ++; /* V2.0.6 */
            * accept = FALSE; /* ###### no resources for the packet, so drop it */

            /* shouse - If buffer allocation fails, put the resp buffer back on the list. */
            if (resp) NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);

            return NULL;
        }
    }

    bp = CONTAINING_RECORD (entryp, MAIN_BUFFER, link);
    UNIV_ASSERT (bp -> code == MAIN_BUFFER_CODE);

    UNIV_ASSERT_VAL2 (head_len == ctxtp -> buf_mac_hdr_len, head_len, ctxtp -> buf_mac_hdr_len);

    /* copy media header into the buffer */

    NdisMoveMemory (bp -> data, head_buf, head_len);

    /* V1.3.0b multicast support V1.3.1b */

    off = CVY_MAC_DST_OFF (ctxtp -> medium);

    /* V2.0.6 figure out frame type for statistics */

    if (! CVY_MAC_ADDR_MCAST (ctxtp -> medium, head_buf + off))
        group = MAIN_FRAME_DIRECTED;
    else
    {
        if (CVY_MAC_ADDR_BCAST (ctxtp -> medium, head_buf + off))
            group = MAIN_FRAME_BROADCAST;
        else
            group = MAIN_FRAME_MULTICAST;
    }

    /* mask cluster MAC address so not to confuse the protocol */

    if (ctxtp -> params . mcast_support)
    {
        if (CVY_MAC_ADDR_COMP (ctxtp -> medium, bp -> data + off, & ctxtp -> cl_mac_addr))
            CVY_MAC_ADDR_COPY (ctxtp -> medium, bp -> data + off, & ctxtp -> ded_mac_addr);
    }

    NdisAdjustBufferLength (bp -> full_bufp, head_len + packet_len);

    /* only bother to transfer lookahead buffer if entire packet fits into
        it - for some reason doing NdisTransferData with offset does not
        work on some cards (ex. Intel 10 ISA) */

    UNIV_ASSERT_VAL2 (packet_len <= ctxtp -> max_frame_size, packet_len, ctxtp -> max_frame_size);

    if (look_len < packet_len)
    {
        NdisAdjustBufferLength (bp -> frame_bufp, packet_len);
        NdisChainBufferAtFront (newp, bp -> frame_bufp);
    }
    else
    {
        UNIV_ASSERT_VAL2 (look_len <= ctxtp -> max_frame_size, look_len, ctxtp -> max_frame_size);
        UNIV_ASSERT_VAL2 (bp -> framep == bp -> data + ctxtp -> buf_mac_hdr_len, (LONG_PTR) bp -> framep, (LONG_PTR) bp -> data);
        NdisMoveMemory (bp -> framep, look_buf, look_len);
        NdisChainBufferAtFront (newp, bp -> full_bufp);
    }

    /* after lookahead has been copied - do data modification. note that we
       are assuming that frames that require modification fit in the lookahead
       buffer */

    if (sig == TCPIP_ARP_SIG)
    {
        UNIV_ASSERT_VAL2 (look_len == packet_len, look_len, packet_len);

        /* recompute the offset from the beginning of frame */

        hdrp = Main_frame_find (ctxtp, bp -> data, bp -> framep, look_len, & sig);

        if (hdrp != NULL)
            (void) Main_arp_handle (ctxtp, (PARP_HDR) hdrp, plen, FALSE);  /* v2.0.6 */
    }

    if (op == MAIN_FILTER_OP_NBT)
    {
        UNIV_ASSERT_VAL2 (look_len == packet_len, look_len, packet_len);

        /* recompute the offset from the beginning of frame */

        hdrp = Main_frame_find (ctxtp, bp -> data, bp -> framep, look_len, & sig);

        if (hdrp != NULL)
        {
            ip_hdrp = (PIP_HDR) hdrp;
            tcp_hdrp = hdrp + sizeof (ULONG) * IP_GET_HLEN (ip_hdrp);

            dlen = TCP_GET_DGRAM_LEN (ip_hdrp, (PTCP_HDR) tcp_hdrp);
            nbt_hdrp = (PNBT_HDR) TCP_GET_DGRAM_PTR ((PTCP_HDR) tcp_hdrp);

            if (plen >= (((PUCHAR) nbt_hdrp) - ((PUCHAR) ip_hdrp) + dlen))  /* v2.0.6 */
                Tcpip_nbt_handle (& ctxtp -> tcpip, (PIP_HDR) hdrp, (PTCP_HDR) tcp_hdrp,
                                  dlen, nbt_hdrp);
        }
    }

    NDIS_SET_PACKET_HEADER_SIZE(newp, head_len);

    /* setup protocol reserved fields */

    /* shouse - For non-CTRL packets, Use MiniportReserved to store a pointer to our 
       private data.  CTRL continues to use ProtocolReserved. */
    if (op != MAIN_FILTER_OP_CTRL) {
        MAIN_MINIPORT_FIELD (newp) = resp;
        resp -> type = MAIN_PACKET_TYPE_INDICATE;
    } else {
        resp = MAIN_PROTOCOL_FIELD (newp);
        resp -> type = MAIN_PACKET_TYPE_CTRL;
    }

    resp -> miscp  = bp;
    resp -> data   = (LONG) (look_len < packet_len ? packet_len : 0); /* 64-bit -- ramkrish */

    /* V2.0.6 */

    resp -> len   = plen; /* 64-bit -- ramkrish */
    resp -> group = group;

    /* if we have less than a half of allocation block number of buffers left -
       allocate more until either alloc fails or we get above the watermark.
       if alloc fails - mark packet so that it is not retained by the protocol
       and is returned back to us. */

    while (ctxtp->num_bufs_alloced - ctxtp->num_bufs_out < ctxtp->num_packets / 2)
    {
        if (!Main_bufs_alloc(ctxtp))
        {
            NDIS_SET_PACKET_STATUS (newp, NDIS_STATUS_RESOURCES);
            return newp;
        }
    }

    if (packet_lowmark)
        NDIS_SET_PACKET_STATUS (newp, NDIS_STATUS_RESOURCES);
    else
        NDIS_SET_PACKET_STATUS (newp, NDIS_STATUS_SUCCESS);
    
    if (op == MAIN_FILTER_OP_CTRL) {
        /* Because this is a remote control packet, MiniportReserved
           should not contain a pointer to a private protocol buffer. */
        ASSERT(!MAIN_MINIPORT_FIELD(newp));
    }

    return newp;

} /* end Main_recv_indicate */


ULONG   Main_actions_alloc (
    PMAIN_CTXT              ctxtp)
{
    PMAIN_ACTION            actp;
    ULONG                   size, index, i;
    NDIS_STATUS             status;


    NdisAcquireSpinLock (& ctxtp -> act_lock);

    if (ctxtp -> num_action_allocs >= CVY_MAX_ALLOCS)
    {
        if (! ctxtp -> actions_warned)
        {
            LOG_MSG1 (MSG_WARN_RESOURCES, CVY_NAME_NUM_ACTIONS, ctxtp -> num_actions);
            ctxtp -> actions_warned = TRUE;
        }

        NdisReleaseSpinLock (& ctxtp -> act_lock);
        return FALSE;
    }

    index = ctxtp -> num_action_allocs;
    NdisReleaseSpinLock (& ctxtp -> act_lock);

    size = ctxtp -> num_actions * ctxtp -> act_size; /* 64-bit -- ramkrish */

    status = NdisAllocateMemoryWithTag (& (ctxtp -> act_buf [index]), size,
                                        UNIV_POOL_TAG);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating actions %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        return FALSE;
    }

    NdisAcquireSpinLock (& ctxtp -> act_lock);
    ctxtp -> num_action_allocs ++;
    NdisReleaseSpinLock (& ctxtp -> act_lock);

    for (i = 0; i < ctxtp -> num_actions; i++)
    {
        /* ensure that actp is aligned along 8-byte boundaries */
        actp = (PMAIN_ACTION) ( (PUCHAR) (ctxtp -> act_buf [index]) + i * ctxtp -> act_size);
        actp -> code  = MAIN_ACTION_CODE;
        actp -> ctxtp = ctxtp;

        NdisInterlockedInsertTailList (& ctxtp -> act_list,
                                       & actp -> link,
                                       & ctxtp -> act_lock);
    }

#if 0 /* 64-bit -- ramkrish */
    for (i = 0, actp = ctxtp -> act_buf [index];
         i < ctxtp -> num_actions;
         i ++, actp ++)
    {
        actp -> code  = MAIN_ACTION_CODE;
        actp -> ctxtp = ctxtp;

        NdisInterlockedInsertTailList (& ctxtp -> act_list,
                                       & actp -> link,
                                       & ctxtp -> act_lock);
    }
#endif

    return TRUE;

} /* end Main_actions_alloc */


PMAIN_ACTION Main_action_get (
    PMAIN_CTXT              ctxtp)
{
    PLIST_ENTRY             entryp;
    PMAIN_ACTION            actp;


    while (1)
    {
        NdisAcquireSpinLock (& ctxtp -> act_lock);
        entryp = RemoveHeadList (& ctxtp -> act_list);
        NdisReleaseSpinLock (& ctxtp -> act_lock);

        if (entryp != & ctxtp -> act_list)
            break;

        UNIV_PRINT (("OUT OF ACTIONS!!!"));

        if (! Main_actions_alloc (ctxtp))
            return NULL;
    }

    actp = CONTAINING_RECORD (entryp, MAIN_ACTION, link);
    UNIV_ASSERT (actp -> code == MAIN_ACTION_CODE);

    return actp;

} /* end Main_action_get */


VOID Main_action_put (
    PMAIN_CTXT              ctxtp,
    PMAIN_ACTION            actp)
{
    UNIV_ASSERT (actp -> code == MAIN_ACTION_CODE);


    NdisAcquireSpinLock (& ctxtp -> act_lock);
    InsertTailList (& ctxtp -> act_list, & actp -> link);
    NdisReleaseSpinLock (& ctxtp -> act_lock);

} /* end Main_action_put */


VOID Main_action_slow_put (
    PMAIN_CTXT              ctxtp,
    PMAIN_ACTION            actp)
{
    UNIV_ASSERT (actp -> code == MAIN_ACTION_CODE);


    NdisAcquireSpinLock (& ctxtp -> act_lock);
    InsertTailList (& ctxtp -> act_list, & actp -> link);
    NdisReleaseSpinLock (& ctxtp -> act_lock);

} /* end Main_action_slow_put */


ULONG   Main_bufs_alloc (
    PMAIN_CTXT              ctxtp)
{
    PMAIN_BUFFER        bp;
    NDIS_STATUS         status;
    ULONG               i, size, index;


    NdisAcquireSpinLock (& ctxtp -> buf_lock);

    if (ctxtp -> num_buf_allocs >= CVY_MAX_ALLOCS)
    {
        if (! ctxtp -> packets_warned)
        {
            LOG_MSG1 (MSG_WARN_RESOURCES, CVY_NAME_NUM_PACKETS, ctxtp -> num_packets);
            ctxtp -> packets_warned = TRUE;
        }

        NdisReleaseSpinLock (& ctxtp -> buf_lock);
        return FALSE;
    }

    index = ctxtp -> num_buf_allocs;
    NdisReleaseSpinLock (& ctxtp -> buf_lock);

    /* get twice as many buffer descriptors (one for entire buffer and one
       just for the payload portion) */

    size = 2 * ctxtp -> num_packets;

    NdisAllocateBufferPool (& status, & (ctxtp -> buf_pool_handle [index]),
                            2 * ctxtp -> num_packets);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating buffer pool %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        return FALSE;
    }

    /* allocate memory for the payload */

    size = ctxtp -> num_packets * ctxtp -> buf_size;

    status = NdisAllocateMemoryWithTag (& (ctxtp -> buf_array [index]), size,
                                        UNIV_POOL_TAG);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error allocating buffer space %d %x", size, status));
        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        goto error;
    }

    NdisZeroMemory (ctxtp -> buf_array [index], size);

    for (i = 0; i < ctxtp -> num_packets; i ++)
    {
        bp = (PMAIN_BUFFER) (ctxtp -> buf_array [index] + i * ctxtp -> buf_size);

        bp -> code = MAIN_BUFFER_CODE;

        /* setup buffer descriptors to describe entire buffer and just the
           payload */

        size = ctxtp -> buf_mac_hdr_len + ctxtp -> max_frame_size;

        NdisAllocateBuffer (& status, & bp -> full_bufp,
                            ctxtp -> buf_pool_handle [index],
                            bp -> data, size);

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating header buffer %d %x", i, status));
            LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
            goto error;
        }

        bp -> framep = bp -> data + ctxtp -> buf_mac_hdr_len;
        size = ctxtp -> max_frame_size;

        NdisAllocateBuffer (& status, & bp -> frame_bufp,
                            ctxtp -> buf_pool_handle [index],
                            bp -> framep, size);

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating frame buffer %d %x", i, status));
            LOG_MSG3 (MSG_ERROR_MEMORY, MSG_NONE, i, size, status);
            goto error;
        }

        NdisInterlockedInsertTailList (& ctxtp -> buf_list,
                                       & bp -> link,
                                       & ctxtp -> buf_lock);
    }

    NdisAcquireSpinLock (& ctxtp -> buf_lock);
    ctxtp -> num_buf_allocs ++;
    ctxtp->num_bufs_alloced += ctxtp->num_packets;
    NdisReleaseSpinLock (& ctxtp -> buf_lock);

    return TRUE;

error:

    if (ctxtp -> buf_array [index] != NULL)
    {
        for (i = 0; i < ctxtp -> num_packets; i ++)
        {
            bp = (PMAIN_BUFFER) (ctxtp -> buf_array [index] + i * ctxtp -> buf_size);

            if (bp -> full_bufp != NULL)
            {
                NdisAdjustBufferLength (bp -> full_bufp,
                                        ctxtp -> buf_mac_hdr_len +
                                        ctxtp -> max_frame_size);
                NdisFreeBuffer (bp -> full_bufp);
            }

            if (bp -> frame_bufp != NULL)
            {
                NdisAdjustBufferLength (bp -> frame_bufp,
                                        ctxtp -> max_frame_size);
                NdisFreeBuffer (bp -> frame_bufp);
            }
        }

        NdisFreeMemory (ctxtp -> buf_array [index],
                        ctxtp -> num_packets * ctxtp -> buf_size, 0);
    }

    if (ctxtp -> buf_pool_handle [index] != NULL)
        NdisFreeBufferPool (ctxtp -> buf_pool_handle [index]);

    return FALSE;

} /* end Main_bufs_alloc */


PNDIS_PACKET Main_frame_get (
    PMAIN_CTXT          ctxtp,
    ULONG               send,
    PULONG              lenp,
    USHORT              frame_type)
{
    PLIST_ENTRY         entryp;
    PMAIN_FRAME_DSCR    dscrp;
    NDIS_STATUS         status;
    PMAIN_PROTOCOL_RESERVED resp;
    PNDIS_PACKET        packet;
    PNDIS_PACKET_STACK  pktstk;
    BOOLEAN             stack_left;


    NdisAllocatePacket (& status, & packet, ctxtp -> frame_pool_handle);

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("OUT OF PING PACKETS!!!"));

#if 0 /* V1.3.2b */
        if (! ctxtp -> send_msgs_warned)
        {
            LOG_MSG1 (MSG_WARN_RESOURCES, CVY_NAME_NUM_SEND_MSGS, ctxtp -> num_send_msgs);
            ctxtp -> send_msgs_warned = TRUE;
        }
#endif

        return NULL;
    }

    /* #ps# -- ramkrish */
    pktstk = NdisIMGetCurrentPacketStack (packet, & stack_left);
    if (pktstk)
    {
        MAIN_IMRESERVED_FIELD(pktstk) = NULL;
    }

    /* Make sure that the MiniportReserved field is initially NULL. */
    MAIN_MINIPORT_FIELD(packet) = NULL;

    NdisAcquireSpinLock (& ctxtp -> frame_lock);
    entryp = RemoveHeadList (& ctxtp -> frame_list);
    NdisReleaseSpinLock (& ctxtp -> frame_lock);

    if (entryp == & ctxtp -> frame_list)
    {
        UNIV_PRINT (("OUT OF PING MESSAGES!!!"));

#if 0 /* V1.3.2b */
        if (! ctxtp -> send_msgs_warned)
        {
            LOG_MSG1 (MSG_WARN_RESOURCES, CVY_NAME_NUM_SEND_MSGS, ctxtp -> num_send_msgs);
            ctxtp -> send_msgs_warned = TRUE;
        }
#endif

        NdisFreePacket (packet);
        return NULL;
    }

    dscrp = CONTAINING_RECORD (entryp, MAIN_FRAME_DSCR, link);

    /* if sending heartbeat - fill out the header. in both cases - chain
       the necessary buffer descriptors to the packet */

    if (send)
    {
	PVOID         address = NULL;
	ULONG         size = 0;


	UNIV_ASSERT_VAL (frame_type == MAIN_PACKET_TYPE_PING ||
			 frame_type == MAIN_PACKET_TYPE_IGMP,
			 frame_type);

        /* V2.0.6, V2.2 moved here */

	/* Differentiate between igmp and heartbeat messages and allocate buffers */
	if (frame_type == MAIN_PACKET_TYPE_PING)
	{
	    size = sizeof (PING_MSG);
	    address = (PVOID)(ctxtp -> load_msgp);
	}
	else if (frame_type == MAIN_PACKET_TYPE_IGMP)
	{
	    size = sizeof (MAIN_IGMP_FRAME);
	    address = (PVOID) (& ctxtp -> igmp_frame);
	}
	else
	{
	    UNIV_PRINT (("Invalid frame type passed to Main_frame_get 0x%x", frame_type));
	    UNIV_ASSERT(0);
	}

	/* Allocate the buffer for sending the data */
	NdisAllocateBuffer (& status, & dscrp -> send_data_bufp,
			    ctxtp -> frame_buf_pool_handle,
			    address, size);

	if (status != NDIS_STATUS_SUCCESS)
	{
	    UNIV_PRINT (("Failed to allocate buffer for 0x%x", frame_type));

	    dscrp -> send_data_bufp = NULL;

	    NdisAcquireSpinLock (& ctxtp -> frame_lock);
	    InsertTailList (& ctxtp -> frame_list, & dscrp -> link);
	    NdisReleaseSpinLock (& ctxtp -> frame_lock);

	    NdisFreePacket (packet);
	    return NULL;
	}

        /* since packet length is always the same, and so are destination
           and source addresses - can use generic media header */

	if (frame_type == MAIN_PACKET_TYPE_PING)
	{
	    dscrp -> media_hdr               = ctxtp -> media_hdr;

	    dscrp -> frame_hdr . code        = MAIN_FRAME_CODE;
	    dscrp -> frame_hdr . version     = CVY_VERSION_FULL;
	    dscrp -> frame_hdr . host        = (UCHAR) ctxtp -> params . host_priority;
	    dscrp -> frame_hdr . cl_ip_addr  = ctxtp -> cl_ip_addr;
	    dscrp -> frame_hdr . ded_ip_addr = ctxtp -> ded_ip_addr;

	    NdisChainBufferAtFront (packet, dscrp -> send_data_bufp); /* V1.1.4 */
	    NdisChainBufferAtFront (packet, dscrp -> frame_hdr_bufp);

	}
	else if (frame_type == MAIN_PACKET_TYPE_IGMP)
	{
	    dscrp -> media_hdr               = ctxtp -> media_hdr_igmp;
	    NdisChainBufferAtFront (packet, dscrp -> send_data_bufp); /* V1.1.4 */
	}
	else
	{
	    UNIV_PRINT (("Invalid frame type passed to Main_frame_get 0x%x", frame_type));
	    UNIV_ASSERT(0);
	}

        NdisChainBufferAtFront (packet, dscrp -> media_hdr_bufp);
    }
    else
    {
        NdisChainBufferAtFront (packet, dscrp -> recv_data_bufp); /* V1.1.4 */
        NdisChainBufferAtFront (packet, dscrp -> frame_hdr_bufp);
    }

    /* fill out protocol reserved fields */

    /* shouse - Again, since these packets are hidden from upper layers, we should
       be OK using the protocol reserved field regardless of send/receive. */

    resp = MAIN_PROTOCOL_FIELD (packet);
    resp -> type   = frame_type;
    resp -> miscp  = dscrp;
    resp -> data   = 0;
    resp -> len    = 0;
    resp -> group  = 0;

    * lenp = dscrp -> recv_len;

    return packet;

} /* end Main_frame_get */


VOID Main_frame_put (
    PMAIN_CTXT          ctxtp,
    PNDIS_PACKET        packet,
    PMAIN_FRAME_DSCR    dscrp)
{
    PNDIS_BUFFER        bufp;

    /* shouse - Again, since these packets are hidden from upper layers, we should
       be OK using the protocol reserved field regardless of send/receive. */

    PMAIN_PROTOCOL_RESERVED resp = MAIN_PROTOCOL_FIELD (packet);


    UNIV_ASSERT_VAL (resp -> type == MAIN_PACKET_TYPE_PING ||
		     resp -> type == MAIN_PACKET_TYPE_IGMP, resp -> type);

    /* strip buffers from the packet buffer chain */

    do
    {
        NdisUnchainBufferAtFront (packet, & bufp);
    }
    while (bufp != NULL);

    /* recyle the packet */

    NdisReinitializePacket (packet);

    NdisFreePacket (packet);

    /* If the send buffer is not null, free this buffer */

    if (dscrp -> send_data_bufp != NULL)
    {
	NdisFreeBuffer (dscrp -> send_data_bufp);
	dscrp -> send_data_bufp = NULL;
    }
    /* put frame descriptor back on the free list */

    NdisAcquireSpinLock (& ctxtp -> frame_lock);
    InsertTailList (& ctxtp -> frame_list, & dscrp -> link);
    NdisReleaseSpinLock (& ctxtp -> frame_lock);

} /* end Main_frame_return */


PNDIS_PACKET Main_packet_alloc (
    PMAIN_CTXT              ctxtp,
    ULONG                   send,
    PULONG                  low)
{
    PNDIS_PACKET            newp = NULL;
    PNDIS_HANDLE            poolh;
    ULONG                   i, max, size, start;
    NDIS_STATUS             status;
    PNDIS_PACKET_STACK      pktstk;
    BOOLEAN                 stack_left;


    /* !!! assume that recv and send paths are not re-entrant, otherwise need
       to lock this. make sure that NdisAllocatePacket... routines are not
       called holding a spin lock */

    /* V1.1.2 */
    *low = FALSE;

    if (send)
    {
        poolh = ctxtp -> send_pool_handle;

        NdisAcquireSpinLock (& ctxtp -> send_lock);
        max   = ctxtp -> num_send_packet_allocs;
        start = ctxtp -> cur_send_packet_pool;
        ctxtp -> cur_send_packet_pool = (start + 1) % max;
        NdisReleaseSpinLock (& ctxtp -> send_lock);
    }
    else
    {
        poolh = ctxtp -> recv_pool_handle;

        NdisAcquireSpinLock (& ctxtp -> recv_lock);
        max   = ctxtp -> num_recv_packet_allocs;
        start = ctxtp -> cur_recv_packet_pool;
        ctxtp -> cur_recv_packet_pool = (start + 1) % max;
        NdisReleaseSpinLock (& ctxtp -> recv_lock);
    }

    /* Try to allocate a packet from the existing packet pools */
    i = start;

    do
    {
        NdisAllocatePacket (& status, & newp, poolh [i]);

        if (status == NDIS_STATUS_SUCCESS)
        {
            /* #ps# -- ramkrish */
            pktstk = NdisIMGetCurrentPacketStack (newp, & stack_left);

            if (pktstk)
            {
                MAIN_IMRESERVED_FIELD (pktstk) = NULL;
            }

            /* Make sure that the MiniportReserved field is initially NULL. */
            MAIN_MINIPORT_FIELD(newp) = NULL;

            if (send)
            {
                NdisAcquireSpinLock (& ctxtp -> send_lock);

                /* Because the decrement is interlocked, so should the increment. */
                NdisInterlockedIncrement(& ctxtp -> num_sends_out);

                if ((ctxtp -> num_sends_alloced - ctxtp -> num_sends_out)
                    < (ctxtp -> num_packets / 2))
                {
                    NdisReleaseSpinLock (& ctxtp -> send_lock);
                    break;
                }
                NdisReleaseSpinLock (& ctxtp -> send_lock);
            }
            else
            {
                NdisAcquireSpinLock (& ctxtp -> recv_lock);

                /* Because the decrement is interlocked, so should the increment. */
                NdisInterlockedIncrement(& ctxtp -> num_recvs_out);

                if ((ctxtp -> num_recvs_alloced - ctxtp -> num_recvs_out)
                    < (ctxtp -> num_packets / 2))
                {
                    NdisReleaseSpinLock (& ctxtp -> recv_lock);
                    break;
                }
                NdisReleaseSpinLock (& ctxtp -> recv_lock);
            }

            return newp;
        }

        /* pick the next pool to improve number of tries until we get something */

        i = (i + 1) % max;

    } while (i != start);

    /* At this point, the high level mark has been reached, so allocate a new packet pool */

    if (send)
    {
        NdisAcquireSpinLock (& ctxtp -> send_lock);

        if (ctxtp -> num_send_packet_allocs >= CVY_MAX_ALLOCS)
        {
            * low = TRUE;
            NdisReleaseSpinLock (& ctxtp -> send_lock);
            return newp;
        }

        if (ctxtp -> send_allocing)
        {
            * low = TRUE; /* do not know whether the allocation by another thread will succeed or not */
            NdisReleaseSpinLock (& ctxtp -> send_lock);
            return newp;
        }
        else
        {
            max = ctxtp -> num_send_packet_allocs;
            ctxtp -> send_allocing = TRUE;
            NdisReleaseSpinLock (& ctxtp -> send_lock);
        }
    }
    else
    {
        NdisAcquireSpinLock (& ctxtp -> recv_lock);

        if (ctxtp -> num_recv_packet_allocs >= CVY_MAX_ALLOCS)
        {
            * low = TRUE;
            NdisReleaseSpinLock (& ctxtp -> recv_lock);
            return newp;
        }

        if (ctxtp -> recv_allocing)
        {
            * low = TRUE; /* do not know whether the allocation by another thread will succeed or not */
            NdisReleaseSpinLock (& ctxtp -> recv_lock);
            return newp;
        }
        else
        {
            max = ctxtp -> num_recv_packet_allocs;
            ctxtp -> recv_allocing = TRUE;
            NdisReleaseSpinLock (& ctxtp -> recv_lock);
        }
    }

    /* Due to the send_allocing and recv_allocing flag, at most 1 send or recv thread will be in this portion at any time */
    size = ctxtp -> num_packets;

    NdisAllocatePacketPool (& status, & (poolh [max]),
                            ctxtp -> num_packets,
                            sizeof (MAIN_PROTOCOL_RESERVED));

    if (status != NDIS_STATUS_SUCCESS)
    {
        if (send)
        {
            UNIV_PRINT (("error allocating send packet pool %d %x", size, status));
        }
        else
        {
            UNIV_PRINT (("error allocating recv packet pool %d %x", size, status));
        }

        LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
        * low = TRUE;
    }
    else
    {
        if (send)
        {
            NdisAcquireSpinLock (& ctxtp -> send_lock);
            ctxtp -> num_send_packet_allocs ++;
            ctxtp -> num_sends_alloced += ctxtp -> num_packets;
            ctxtp -> send_allocing = FALSE;
            NdisReleaseSpinLock (& ctxtp -> send_lock);
        }
        else
        {
            NdisAcquireSpinLock (& ctxtp -> recv_lock);
            ctxtp -> num_recv_packet_allocs ++;
            ctxtp -> num_recvs_alloced += ctxtp -> num_packets;
            ctxtp -> recv_allocing = FALSE;
            NdisReleaseSpinLock (& ctxtp -> recv_lock);
        }

        * low = FALSE;
    }

    return newp;
} /* Main_packet_alloc */


/* V1.3.2b */
#if 0
PNDIS_PACKET Main_packet_alloc (
    PMAIN_CTXT              ctxtp,
    ULONG                   send)
{
    PNDIS_PACKET            newp;
    PNDIS_HANDLE            poolh;
    ULONG                   i, max, size, start;
    NDIS_STATUS             status;


    /* !!! assume that recv and send paths are not re-entrant, otherwise need
       to lock this. make sure that NdisAllocatePacket... routines are not
       called holding a spin lock */

    /* V1.1.2 */

    if (send)
    {
        poolh = ctxtp -> send_pool_handle;

        NdisAcquireSpinLock (& ctxtp -> send_lock);
        max   = ctxtp -> num_send_packet_allocs;
        start = ctxtp -> cur_send_packet_pool;
        ctxtp -> cur_send_packet_pool = (start + 1) % max;
        NdisReleaseSpinLock (& ctxtp -> send_lock);
    }
    else
    {
        poolh = ctxtp -> recv_pool_handle;

        NdisAcquireSpinLock (& ctxtp -> recv_lock);
        max   = ctxtp -> num_recv_packet_allocs;
        start = ctxtp -> cur_recv_packet_pool;
        ctxtp -> cur_recv_packet_pool = (start + 1) % max;
        NdisReleaseSpinLock (& ctxtp -> recv_lock);
    }

    i = start;

    while (1)
    {
        NdisAllocatePacket (& status, & newp, poolh [i]);

        if (status == NDIS_STATUS_SUCCESS)
        {
            if (send)
                NdisInterlockedIncrement(& ctxtp -> num_sends_out);
            else
                NdisInterlockedIncrement(& ctxtp -> num_recvs_out);

            return newp;
        }

        /* pick the next pool to improve number of tries until we get something */

        i = (i + 1) % max;

        if (i != start)
            continue;

        if (send)
        {
            UNIV_PRINT (("OUT OF SEND PACKETS!!!"));
        }
        else
        {
            UNIV_PRINT (("OUT OF RECV PACKETS!!!"));
        }

        /* allocate another packet pool if we can */

        if (max >= CVY_MAX_ALLOCS)
        {
            if (! ctxtp -> packets_warned)
            {
                LOG_MSG1 (MSG_WARN_RESOURCES, CVY_NAME_NUM_PACKETS, ctxtp -> num_packets);
                ctxtp -> packets_warned = TRUE;
            }

            break;
        }

        size = ctxtp -> num_packets;

        NdisAllocatePacketPool (& status, & (poolh [max]),
                                ctxtp -> num_packets,
                                sizeof (MAIN_PROTOCOL_RESERVED));

        if (status != NDIS_STATUS_SUCCESS)
        {
            UNIV_PRINT (("error allocating recv packet pool %d %x", size, status));
            LOG_MSG2 (MSG_ERROR_MEMORY, MSG_NONE, size, status);
            break;
        }

        if (send)
        {
            NdisAcquireSpinLock (& ctxtp -> send_lock);
            ctxtp -> num_send_packet_allocs ++;
            ctxtp -> cur_send_packet_pool = max;
            ctxtp -> num_sends_alloced += ctxtp->num_packets;
            NdisReleaseSpinLock (& ctxtp -> send_lock);
        }
        else
        {
            NdisAcquireSpinLock (& ctxtp -> recv_lock);
            ctxtp -> num_recv_packet_allocs ++;
            ctxtp -> cur_recv_packet_pool = max;
            ctxtp -> num_recvs_alloced += ctxtp->num_packets;
            NdisReleaseSpinLock (& ctxtp -> recv_lock);
        }

        i = max;
        max ++;
    }

    return NULL;

} /* end Main_packet_alloc */
#endif

PNDIS_PACKET Main_packet_get (
    PMAIN_CTXT              ctxtp,
    PNDIS_PACKET            packet,
    ULONG                   send,
    USHORT                  group,
    ULONG                   len)
{
    PNDIS_PACKET            newp;
//    PNDIS_PACKET_OOB_DATA   new_oobp, old_oobp;
    PMAIN_PROTOCOL_RESERVED resp = NULL;
    ULONG                   packet_lowmark;
    PNDIS_PACKET_STACK      pktstk = NULL;
    BOOLEAN                 stack_left;


    /* #ps# */
    pktstk = NdisIMGetCurrentPacketStack (packet, & stack_left);

    if (stack_left)
    {
        resp = (PMAIN_PROTOCOL_RESERVED) NdisAllocateFromNPagedLookasideList (& ctxtp -> resp_list);

        MAIN_IMRESERVED_FIELD (pktstk) = resp;

        if (resp)
        {
            resp -> type   = MAIN_PACKET_TYPE_PASS;
            resp -> miscp  = packet;
            resp -> data   = 0;

            /* V2.0.6 */

            resp -> group  = group;
            resp -> len    = len; /* 64-bit -- ramkrish */

            return packet;
        }
    }
        
    /* get a packet */

    /* shouse - If this is a receive, then we are using MiniportReserved and must allocate a 
       buffer to hold our private data.  If it fails, bail out and dump the packet. */
    if (!send) {
        resp = (PMAIN_PROTOCOL_RESERVED) NdisAllocateFromNPagedLookasideList (& ctxtp -> resp_list);

        if (!resp) return NULL;
    }

    newp = Main_packet_alloc (ctxtp, send, & packet_lowmark);

    if (newp == NULL) {
        /* shouse - If packet allocation fails, put the resp buffer back on the list if this is a receive. */
        if (resp) NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);

        return NULL;
    }

    pktstk = NdisIMGetCurrentPacketStack (newp, & stack_left);     /* #ps# */

    if (pktstk)
    {
        MAIN_IMRESERVED_FIELD(pktstk) = NULL;
    }

    /* Make sure that the MiniportReserved field is initially NULL. */
    MAIN_MINIPORT_FIELD(newp) = NULL;

    /* make new packet resemble the outside one */

    if (send)
    {
        PVOID			        media_info = NULL;
        ULONG			        media_info_size = 0;


        newp->Private.Head = packet->Private.Head;
        newp->Private.Tail = packet->Private.Tail;

        NdisGetPacketFlags(newp) = NdisGetPacketFlags(packet);

        NdisSetPacketFlags(newp, NDIS_FLAGS_DONT_LOOPBACK);

        // Copy the OOB Offset from the original packet to the new
        // packet.

        NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(newp),
                       NDIS_OOB_DATA_FROM_PACKET(packet),
                       sizeof(NDIS_PACKET_OOB_DATA));

        // Copy the per packet info into the new packet

        NdisIMCopySendPerPacketInfo(newp, packet);

        // Copy the Media specific information

        NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(packet, & media_info, & media_info_size);

        if (media_info != NULL || media_info_size != 0)
        {
            NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(newp, media_info, media_info_size);
        }
    }
    else
    {
        newp->Private.Head = packet->Private.Head;
        newp->Private.Tail = packet->Private.Tail;

        // Get the original packet(it could be the same packet as one received or a different one
        // based on # of layered MPs) and set it on the indicated packet so the OOB stuff is visible
        // correctly at the top.

        NDIS_SET_ORIGINAL_PACKET(newp, NDIS_GET_ORIGINAL_PACKET(packet));
        NDIS_SET_PACKET_HEADER_SIZE(newp, NDIS_GET_PACKET_HEADER_SIZE(packet));
        NdisGetPacketFlags(newp) = NdisGetPacketFlags(packet);

        if (packet_lowmark)
            NDIS_SET_PACKET_STATUS(newp, NDIS_STATUS_RESOURCES);
        else
            NDIS_SET_PACKET_STATUS(newp, NDIS_GET_PACKET_STATUS(packet));
        }

#if 0
    newp -> Private . PhysicalCount   = packet -> Private . PhysicalCount;
    newp -> Private . TotalLength     = packet -> Private . TotalLength;
    newp -> Private . Head            = packet -> Private . Head;
    newp -> Private . Tail            = packet -> Private . Tail;
    newp -> Private . Count           = packet -> Private . Count;
    newp -> Private . Flags           = packet -> Private . Flags;
    newp -> Private . ValidCounts     = packet -> Private . ValidCounts;
    newp -> Private . NdisPacketFlags = packet -> Private . NdisPacketFlags;

    old_oobp = NDIS_OOB_DATA_FROM_PACKET (packet);
    new_oobp = NDIS_OOB_DATA_FROM_PACKET (newp);

    * new_oobp = * old_oobp;
#endif

    /* fill out protocol reserved field */

    /* shouse - Sends should use ProtocolReserved and receives should use MiniportReserved.  Buffer
       space for MiniportReserved is allocated further up in this function. */
    if (send) { 
        resp = MAIN_PROTOCOL_FIELD (newp);
    } else { 
        MAIN_MINIPORT_FIELD (newp) = resp;
    }

    resp -> type   = MAIN_PACKET_TYPE_PASS;
    resp -> miscp  = packet;
    resp -> data   = 0;

    /* V2.0.6 */

    resp -> group  = group;
    resp -> len    = len; /* 64-bit -- ramkrish */

    return newp;

} /* end Main_packet_get*/


PNDIS_PACKET Main_packet_put (
    PMAIN_CTXT              ctxtp,
    PNDIS_PACKET            packet,
    ULONG                   send,
    NDIS_STATUS             status)
{
    PNDIS_PACKET            oldp = NULL;
    PNDIS_PACKET_STACK      pktstk;
    BOOLEAN                 stack_left;
    PMAIN_PROTOCOL_RESERVED resp; /* #ps# */
//    PMAIN_PROTOCOL_RESERVED resp = MAIN_PROTOCOL_FIELD (packet);
    PMAIN_BUFFER            bp;
    PNDIS_BUFFER            bufp;


    /* #ps# */
    MAIN_RESP_FIELD(packet, stack_left, pktstk, resp, send);

    UNIV_ASSERT(resp);

    /* Because CTRL packets are actually allocated on the receive path,
       we need to change the send flag to false to get the logic right. */
    if (resp->type == MAIN_PACKET_TYPE_CTRL) {
        ASSERT(send);
        send = FALSE;
    }

    /* V2.0.6 update statistics */

    if (send)
    {
        if (status == NDIS_STATUS_SUCCESS)
        {
            ctxtp -> cntr_xmit_ok ++;

            switch (resp -> group)
            {
                case MAIN_FRAME_DIRECTED:
                    ctxtp -> cntr_xmit_frames_dir ++;
                    ctxtp -> cntr_xmit_bytes_dir += (ULONGLONG) (resp -> len);
                    break;

                case MAIN_FRAME_MULTICAST:
                    ctxtp -> cntr_xmit_frames_mcast ++;
                    ctxtp -> cntr_xmit_bytes_mcast += (ULONGLONG) (resp -> len);
                    break;

                case MAIN_FRAME_BROADCAST:
                    ctxtp -> cntr_xmit_frames_bcast ++;
                    ctxtp -> cntr_xmit_bytes_bcast += (ULONGLONG) (resp -> len);
                    break;

                default:
                    break;
            }
        }
        else
            ctxtp -> cntr_xmit_err ++;
    }
    else
    {
        if (status == NDIS_STATUS_SUCCESS)
        {
            ctxtp -> cntr_recv_ok ++;

            switch (resp -> group)
            {
                case MAIN_FRAME_DIRECTED:
                    ctxtp -> cntr_recv_frames_dir ++;
                    ctxtp -> cntr_recv_bytes_dir += (ULONGLONG) (resp -> len);
                    break;

                case MAIN_FRAME_MULTICAST:
                    ctxtp -> cntr_recv_frames_mcast ++;
                    ctxtp -> cntr_recv_bytes_mcast += (ULONGLONG) (resp -> len);
                    break;

                case MAIN_FRAME_BROADCAST:
                    ctxtp -> cntr_recv_frames_bcast ++;
                    ctxtp -> cntr_recv_bytes_bcast += (ULONGLONG) (resp -> len);
                    break;

                default:
                    break;
            }
        }
        else
            ctxtp -> cntr_recv_err ++;
    }

    /* V1.3.2b - if this is our buffer packet - get rid of the buffer */

    if (resp -> type == MAIN_PACKET_TYPE_INDICATE ||
        resp -> type == MAIN_PACKET_TYPE_CTRL)
    {
        /* strip buffers from the packet buffer chain */

        NdisUnchainBufferAtFront (packet, & bufp);

        bp = (PMAIN_BUFFER) resp -> miscp;
        UNIV_ASSERT (bp -> code == MAIN_BUFFER_CODE);

        NdisAcquireSpinLock (& ctxtp -> buf_lock);
        ctxtp -> num_bufs_out--;
        InsertTailList (& ctxtp -> buf_list, & bp -> link);
        NdisReleaseSpinLock (& ctxtp -> buf_lock);

        /* Indicated packets use MiniportReserved, while CTRL packets use ProtocolReserved,
           so indicated packets need to free the resp buffer back to the list. */
        if (resp -> type == MAIN_PACKET_TYPE_INDICATE) {
            resp -> type = MAIN_PACKET_TYPE_NONE;
            NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);
        }
    }
    else
    {
        UNIV_ASSERT_VAL (resp -> type == MAIN_PACKET_TYPE_PASS ||
                         resp -> type == MAIN_PACKET_TYPE_TRANSFER,
                         resp -> type);

        oldp = (PNDIS_PACKET) resp -> miscp;

        /* If the old packet is the same as this packet, then we were using
           NDIS packet stacking to hold our private data.  In this case, we
           ALWAYS need to free the resp buffer back to our list. */
        if (oldp == packet)
        {
            resp -> type = MAIN_PACKET_TYPE_NONE;
            NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);
            return packet;
        }

#if defined (SBH)
        /* It used to be that if a new packet was allocated, we always used 
           protocol reseved, so there was never a need to free our private
           buffer (it was part of the packet itself).  However, now in the 
           case where packet != oldp (we allocated a new packet) we may have
           to free the private data buffer.  If we allocate a packet on the
           send path, we play the part of protocol and use the protocol
           reserved field, which is the former behavior.  However, if we 
           allocate a packet on the receive path, we pull a resp buffer off
           of our lookaside list and store a pointer in the miniport reserved
           field of the packet.  Therefore, if this is the completion of a 
           receive, free the private buffer. */
        if (!send)
            NdisFreeToNPagedLookasideList (& ctxtp -> resp_list, resp);
#endif
        // Copy the per packet info into the new packet

        if (send)
            NdisIMCopySendCompletePerPacketInfo(oldp, packet);

        resp -> type = MAIN_PACKET_TYPE_NONE;
    }

    /* These conters ONLY count outstanding allocated packets - for resource tracking. */
    if (send)
        NdisInterlockedDecrement(& ctxtp -> num_sends_out);
    else
        NdisInterlockedDecrement(& ctxtp -> num_recvs_out);

    NdisReinitializePacket (packet);
    NdisFreePacket (packet);

    return oldp;

} /* end Main_packet_put */


#ifdef PERIODIC_RESET
static ULONG countdown = 0;
ULONG   resetting = FALSE;
#endif

VOID Main_ping (
    PMAIN_CTXT              ctxtp,
    PULONG                  toutp)
{
    ULONG                   len, conns;
    BOOLEAN                 alive, converging;
    PNDIS_PACKET            packet;
    NDIS_STATUS             status;
    BOOLEAN                 send_heartbeat = TRUE;


#ifdef PERIODIC_RESET   /* enable this to simulate periodic resets */

    if (countdown++ == 15)
    {
        NDIS_STATUS     status;

        resetting = TRUE;

        NdisReset (& status, ctxtp -> mac_handle);

        if (status == NDIS_STATUS_SUCCESS)
            resetting = FALSE;

        countdown = 0;
    }

#endif

    /* If unbind handler has been called, return here */
    if (ctxtp -> unbind_handle)
	return;

    /* The master adapter must check the consistency of its team's configuration
       and appropriately activate/de-activate the team once per timeout. */
    Main_teaming_check_consistency(ctxtp);

    /* count down time left for blocking ARPs */

    NdisAcquireSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

    if (*toutp > univ_changing_ip)
        univ_changing_ip = 0;
    else
        univ_changing_ip -= *toutp;

    alive = Load_timeout (& ctxtp -> load, toutp, & converging, & conns);

    /* moving release to the end of the function locks up one of the testbeds.
       guessing because of some reentrancy problem with NdisSend that is being
       called by ctxtp_frame_send */

    if (! ctxtp -> convoy_enabled && ! ctxtp -> stopping)
    {
        UNIV_ASSERT (! ctxtp -> draining);
        NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */
	send_heartbeat   = FALSE;
//	return;
    }

    /* V2.1 if draining and no more connections - stop cluster mode */

    if (send_heartbeat)
    {
	if (ctxtp -> draining && conns == 0 && ! converging)
        {
	    IOCTL_CVY_BUF       buf;

	    ctxtp -> draining = FALSE;
	    NdisReleaseSpinLock (& ctxtp -> load_lock);

	    Main_ctrl (ctxtp, (ULONG) IOCTL_CVY_CLUSTER_OFF, & buf, NULL);
	}
	else
	    NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

	/* V2.1 clear stopping flag here since we are going to send out the frame
	   that will initiate convergence */

	ctxtp -> stopping = FALSE;
    }

    /* V1.3.2b */

    if (! ctxtp -> media_connected || ! MAIN_PNP_DEV_ON(ctxtp))
        return;

    /* V1.1.2 do not send pings if the card below is resetting */

    if (ctxtp -> reset_state != MAIN_RESET_NONE)
        return;

    if (send_heartbeat)
    {
	packet = Main_frame_get (ctxtp, TRUE, & len, MAIN_PACKET_TYPE_PING);

	if (packet == NULL)
        {
	    UNIV_PRINT (("error getting frame packet"));
	    return;
	}

	NdisSend (& status, ctxtp -> mac_handle, packet);

	if (status != NDIS_STATUS_PENDING)
	    Main_send_done (ctxtp, packet, status);
    }

    /* Check to see if igmp message needs to be sent out.  If the cluster IP address is 0.0.0.0, we 
       don't want to join the multicast IGMP group.  Likewise, in multicast or unicast mode. */
    if (ctxtp -> params . mcast_support && ctxtp -> params . igmp_support && ctxtp -> params . cl_ip_addr != 0)
    {
	ctxtp -> igmp_sent += ctxtp -> curr_tout;

	if (ctxtp -> igmp_sent < CVY_DEF_IGMP_INTERVAL)
	    return;

	ctxtp -> igmp_sent = 0;
	packet = Main_frame_get (ctxtp, TRUE, & len, MAIN_PACKET_TYPE_IGMP);

	if (packet == NULL)
        {
	    UNIV_PRINT (("error getting igmp packet"));
	    return;
	}

	NdisSend (& status, ctxtp -> mac_handle, packet);

	if (status != NDIS_STATUS_PENDING)
	    Main_send_done (ctxtp, packet, status);
    }

} /* Main_ping */


VOID Main_send_done (
    PVOID                   cp,
    PNDIS_PACKET            packetp,
    NDIS_STATUS             status)
{
    PMAIN_CTXT              ctxtp = (PMAIN_CTXT) cp;
    PMAIN_FRAME_DSCR        dscrp;

    /* shouse - This function is only called for ping and IGMP messages, so
       we can continue to allow it to access the protocol reserved field. */
    PMAIN_PROTOCOL_RESERVED resp = MAIN_PROTOCOL_FIELD (packetp);

    UNIV_ASSERT_VAL (resp -> type == MAIN_PACKET_TYPE_PING ||
		     resp -> type == MAIN_PACKET_TYPE_IGMP, resp -> type);

    /* attempt to see if this packet is part of our frame descriptor */

    dscrp = (PMAIN_FRAME_DSCR) resp -> miscp;

    if (status != NDIS_STATUS_SUCCESS)
        UNIV_PRINT (("error sending %x error 0x%x", resp -> type, status));

    Main_frame_put (ctxtp, packetp, dscrp);

} /* end Main_send_done */


VOID Main_xfer_done (
    PVOID                   cp,
    PNDIS_PACKET            packetp,
    NDIS_STATUS             status,
    ULONG                   xferred)
{
    PMAIN_CTXT              ctxtp = (PMAIN_CTXT) cp;
    PMAIN_FRAME_DSCR         dscrp;

    /* shouse - This function is only called for ping messages, so we can 
       continue to allow it to access the protocol reserved field. */
    PMAIN_PROTOCOL_RESERVED resp = MAIN_PROTOCOL_FIELD (packetp);

    UNIV_ASSERT_VAL (resp -> type == MAIN_PACKET_TYPE_PING, resp -> type);

    dscrp = (PMAIN_FRAME_DSCR) resp -> miscp;

    if (status != NDIS_STATUS_SUCCESS)
    {
        UNIV_PRINT (("error transferring %x", status));
    }
    else if (xferred != dscrp -> recv_len)
    {
        UNIV_PRINT (("only xferred %d out of %d bytes", xferred, sizeof (MAIN_FRAME_HDR)));
    }
    else
    {
        /* let load deal with received heartbeat */

        NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3 */
        if (ctxtp -> convoy_enabled)    /* V1.3.2b */
            Load_msg_rcv (& ctxtp -> load, & dscrp -> msg);     /* V1.1.4 */
        NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */
    }

    Main_frame_put (ctxtp, packetp, dscrp);

} /* end Main_xfer_done */


PUCHAR Main_frame_parse (
    PMAIN_CTXT          ctxtp,
    PNDIS_PACKET        packetp,
    PUCHAR *            startp,     /* destination for the MAC header */
    ULONG               off,        /* offset from beginning of data - 0 means
                                       right after IP header */
    PUCHAR *            locp,       /* destination for the TCP/UDP/other header */
    PULONG              lenp,       /* length without media header */
    PUSHORT             sigp,        /* signature from the MAC header */
    PUSHORT             group,      /* directed, multicast or broadcast */
    ULONG               send)
/*
  Parse packet extracting real pointers to specified offsets

  returns PUCHAR:
    <pointer to specified offset>
*/
{
    PNDIS_BUFFER        bufp;
    PUCHAR              memp, retp;
    UINT                len, total_len;
    ULONG               curr_len = 0, hdr_len, offset;


    /* get basic frame info */

    NdisGetFirstBufferFromPacket (packetp, & bufp, & memp, & len, & total_len);

    if (bufp == NULL)
        return NULL;

//    NdisQueryBuffer (bufp, & memp, & len);

    * startp = memp;

    offset = CVY_MAC_DST_OFF (ctxtp -> medium);

    /* V2.0.6 - figure out frame type for stats */

    if (! CVY_MAC_ADDR_MCAST (ctxtp -> medium, memp + offset))
        * group = MAIN_FRAME_DIRECTED;
    else
    {
        if (CVY_MAC_ADDR_BCAST (ctxtp -> medium, memp + offset))
            * group = MAIN_FRAME_BROADCAST;
        else
            * group = MAIN_FRAME_MULTICAST;
    }

    /* V1.3.0b multicast support V1.3.1b - on receive mask the cluster MAC
       so that protocol does not get confused */

    if (ctxtp -> params . mcast_support)
    {
        if (! send &&
            CVY_MAC_ADDR_COMP (ctxtp -> medium, memp + offset, & ctxtp -> cl_mac_addr))
            CVY_MAC_ADDR_COPY (ctxtp -> medium, memp + offset, & ctxtp -> ded_mac_addr);
    }

    /* V2.0.6 source MAC address shadowing to prevent switches from learning */

    else if (send && ctxtp -> params . mask_src_mac)
    {
        offset = CVY_MAC_SRC_OFF (ctxtp -> medium);

        if (CVY_MAC_ADDR_COMP (ctxtp -> medium, memp + offset, & ctxtp -> cl_mac_addr))
        {
            CVY_MAC_ADDR_COPY (ctxtp -> medium, memp + offset, & ctxtp -> ded_mac_addr);

            //
            // Change to the unique mac.  
            // Note, this can be done during initialization to improve performance
            //
            CVY_MAC_ADDR_LAA_SET (ctxtp -> medium, memp + offset);
            * ((PUCHAR) (memp + offset + 1)) = (UCHAR) ctxtp -> params . host_priority;
/*          // 64-bit -- ramkrish
            * ((PULONG) (memp + offset + 2)) = ctxtp -> cl_ip_addr;
*/
//            ctxtp -> mac_modified ++;
        }
    }

    /* get header length and signature from the frame depending on the medium */

    if (ctxtp -> medium == NdisMedium802_3)
    {
        hdr_len = sizeof (CVY_ETHERNET_HDR);

        * sigp = CVY_ETHERNET_ETYPE_GET (memp);
    }

    if (total_len < hdr_len)
    {
        return NULL;
    }

    /* get payload length */

    * lenp = total_len - hdr_len;

    /* traverse buffers until we find payload offset and remember the pointer */

    while (1)
    {
        if (curr_len + len > hdr_len)
        {
            retp = memp + (hdr_len - curr_len);
            break;
        }

        curr_len += len;

        NdisGetNextBuffer (bufp, & bufp);

        if (bufp == NULL)
            return NULL;

        NdisQueryBuffer (bufp, & memp, & len);
    }

    /* by default assume next offset is after IP header */

    if (off == 0)
        off = sizeof (ULONG) * IP_GET_HLEN ((PIP_HDR) retp);

    hdr_len += off;

    /* traverse buffers until we find next offset and remember the pointer */

    while (1)
    {
        if (curr_len + len > hdr_len)
        {
            * locp = memp + (hdr_len - curr_len);
            break;
        }

        curr_len += len;

        NdisGetNextBuffer (bufp, & bufp);

        if (bufp == NULL)
        {
            * locp = NULL;
            break;
        }

        NdisQueryBuffer (bufp, & memp, & len);
    }

    return retp;

} /* end Main_frame_parse */


PUCHAR Main_frame_find (
    PMAIN_CTXT          ctxtp,
    PUCHAR              head_buf,
    PUCHAR              look_buf,
    UINT                look_len,
    PUSHORT             sigp)
{
    /* get payload location and signature from the frame depending on the medium */

    if (ctxtp -> medium == NdisMedium802_3)
    {
        * sigp = CVY_ETHERNET_ETYPE_GET (head_buf);
        return look_buf;
    }

    return look_buf;

} /* end Main_frame_find */

NDIS_STATUS Main_dispatch (
    PVOID                   DeviceObject, 
    PVOID                   Irp) 
{
    PIRP                    pIrp = Irp;
    PIO_STACK_LOCATION      irpStack;
    NDIS_STATUS	            status = NDIS_STATUS_SUCCESS;
    
    UNIV_PRINT(("Main_dispatch: Device=%p, Irp=%p \n", DeviceObject, Irp));

    irpStack = IoGetCurrentIrpStackLocation(pIrp);
    
    switch (irpStack->MajorFunction) {
    case IRP_MJ_DEVICE_CONTROL:
        status = Main_ioctl(DeviceObject, Irp);
        break;        
    default:
        break;
    }
    
    pIrp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    
    return status;
} 

NDIS_STATUS Main_ioctl (
    PVOID                   device, 
    PVOID                   irp_irp) 
{
    PIRP                    irp = irp_irp;
    PIO_STACK_LOCATION      irp_sp;
    ULONG                   ilen, olen, info = 0;
    NDIS_STATUS             status = NDIS_STATUS_SUCCESS;
    ULONG                   io_ctrl_code;
    PMAIN_CTXT              ctxtp = ioctrl_ctxtp;
    PIOCTL_LOCAL_HDR        bufp;
    ULONG                   adapter_index;

    irp_sp = IoGetCurrentIrpStackLocation (irp);
    io_ctrl_code = irp_sp -> Parameters . DeviceIoControl . IoControlCode;

    ilen = irp_sp -> Parameters . DeviceIoControl . InputBufferLength;
    olen = irp_sp -> Parameters . DeviceIoControl . OutputBufferLength;
    bufp = irp -> AssociatedIrp . SystemBuffer;

    switch (io_ctrl_code)
    {
    case IOCTL_CVY_CLUSTER_ON:
    case IOCTL_CVY_CLUSTER_OFF:
    case IOCTL_CVY_PORT_ON:
    case IOCTL_CVY_PORT_OFF:
    case IOCTL_CVY_QUERY:
    case IOCTL_CVY_RELOAD:
    case IOCTL_CVY_PORT_SET:
    case IOCTL_CVY_PORT_DRAIN:
    case IOCTL_CVY_CLUSTER_DRAIN:
    case IOCTL_CVY_CLUSTER_SUSPEND:
    case IOCTL_CVY_CLUSTER_RESUME:
        /* Picking univ_ctxt_hanlde here is not kosher, since we should 
           get the callback cookie out of callb_ctxtp from ctxtp context. 
           Since we do not have it - do what we can now - cheat :) */
        
        if (ilen != sizeof (IOCTL_LOCAL_HDR) || olen != sizeof (IOCTL_LOCAL_HDR) || bufp == NULL)
        {
            UNIV_PRINT(("Buffer is missing or not the expected (%d) size: %d, %d", sizeof(IOCTL_LOCAL_HDR), ilen, olen));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        adapter_index = Main_adapter_get (bufp -> device_name);
        
        if (adapter_index == MAIN_ADAPTER_NOT_FOUND)
        {
            UNIV_PRINT(("Unknown adapter: %ls", bufp -> device_name));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        UNIV_PRINT(("Ioctl %d for adapter %ls", io_ctrl_code, bufp -> device_name));
        
        ctxtp = univ_adapters [adapter_index] . ctxtp;
        
        irp -> IoStatus . Information = sizeof (IOCTL_LOCAL_HDR);
        
        /* Process the IOCTL.  All necessary information except the VIP is in the IOCTL_CVY_BUF.  For
           backward compatiblilty reasons, we need to store the virtual IP address in the local buffer. */
        status = Main_ctrl (ctxtp, io_ctrl_code, & (bufp -> ctrl), & (bufp -> options));
        
        break;
    case IOCTL_CVY_QUERY_STATE:
        /* Check the lengths of the input and output buffers specified by the user-space application. */
        if (ilen != sizeof (IOCTL_LOCAL_HDR) || olen != sizeof (IOCTL_LOCAL_HDR) || !bufp) {
            UNIV_PRINT(("Buffer is missing or not the expected (%d) size: input=%d, output=%d", sizeof(IOCTL_LOCAL_HDR), ilen, olen));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        /* Map from the GUID to the adapter index. */
        if ((adapter_index = Main_adapter_get(bufp->device_name)) == MAIN_ADAPTER_NOT_FOUND) {
            UNIV_PRINT(("Unknown adapter: %ls", bufp->device_name));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        UNIV_PRINT(("Ioctl for adapter %ls", bufp->device_name));

        /* Fill in the number of bytes written.  This IOCTL always writes the same number of bytes that it 
           reads.  That is, the input and output buffers should be identical structures. */
        irp->IoStatus.Information = sizeof(IOCTL_LOCAL_HDR);
        
        /* Retrieve the context pointer from the global arrary of adapters. */
        ctxtp = univ_adapters[adapter_index].ctxtp;
        
        /* Call the query state IOCTL handler. */
        status = Query_state_ctrl(ctxtp, bufp->options.state.flags, &bufp->options.state.query);
        
        break;
#if defined (NLB_SESSION_SUPPORT)
    case IOCTL_CVY_CONNECTION_NOTIFY:
        /* Check the lengths of the input and output buffers specified by the user-space application. */
        if (ilen != sizeof (IOCTL_LOCAL_HDR) || olen != sizeof (IOCTL_LOCAL_HDR) || !bufp) {
            UNIV_PRINT(("Buffer is missing or not the expected (%d) size: input=%d, output=%d", sizeof(IOCTL_LOCAL_HDR), ilen, olen));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        /* Map from the GUID to the adapter index. */
        if ((adapter_index = Main_adapter_get(bufp->device_name)) == MAIN_ADAPTER_NOT_FOUND) {
            UNIV_PRINT(("Unknown adapter: %ls", bufp->device_name));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        UNIV_PRINT(("Ioctl for adapter %ls", bufp->device_name));

        /* Fill in the number of bytes written.  This IOCTL always writes the same number of bytes that it 
           reads.  That is, the input and output buffers should be identical structures. */
        irp->IoStatus.Information = sizeof(IOCTL_LOCAL_HDR);
        
        /* Retrieve the context pointer from the global arrary of adapters. */
        ctxtp = univ_adapters[adapter_index].ctxtp;
        
        /* Call the connection notification IOCTL handler. */
        status = Conn_notify_ctrl(ctxtp, bufp->options.notify.flags, &bufp->options.notify.conn);
        
        break;
#endif
#if defined (SBH)
    case IOCTL_CVY_QUERY_PERF:
        irp -> IoStatus . Information = 0;
        
        if (ilen != sizeof (IOCTL_LOCAL_HDR) || olen != sizeof (CVY_DRIVER_PERF) || bufp == NULL)
        {
            UNIV_PRINT(("Buffer is missing or not the expected (%d) size: %d, %d", sizeof(IOCTL_LOCAL_HDR), ilen, olen));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        adapter_index = Main_adapter_get (bufp -> device_name);
        
        if (adapter_index == MAIN_ADAPTER_NOT_FOUND)
        {
            UNIV_PRINT(("Unknown adapter: %ls", bufp -> device_name));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        
        UNIV_PRINT(("Ioctl perf for adapter %ls", bufp -> device_name));
        
        ctxtp = univ_adapters [adapter_index] . ctxtp;
        
        status = Main_QueryPerf(ctxtp, (PCVY_DRIVER_PERF)bufp);
        
        if (status == NDIS_STATUS_SUCCESS)
        {
            irp -> IoStatus . Information = sizeof (CVY_DRIVER_PERF);
        }
        
        break;
#endif /* SBH */
    default:
        UNIV_PRINT(("Unknown Ioctl code: %x", io_ctrl_code));
        break;
    }
    
    return status;
    
} /* end Main_ioctl */

/* 
 * Function: Query_state_ctrl
 * Description: 
 * Parameters: 
 * Returns: 
 * Author: shouse 5.18.01
 */
NDIS_STATUS Query_state_ctrl (PMAIN_CTXT ctxtp, ULONG fOptions, PIOCTL_QUERY_STATE pQuery) {
    PMAIN_ADAPTER pAdapter = &(univ_adapters[ctxtp->adapter_id]);

    NdisAcquireSpinLock(&univ_bind_lock);

    /* If the adapter isn't initialized yet, refuse the request. */
    if (!pAdapter->inited) {
        NdisReleaseSpinLock(&univ_bind_lock);
        pQuery->ReturnCode = NLB_QUERY_STATE_FAILURE;
        return NDIS_STATUS_SUCCESS;
    }

    NdisReleaseSpinLock(&univ_bind_lock);

    switch (pQuery->Operation) {
    case NLB_QUERY_REG_PARAMS:
    case NLB_QUERY_PORT_RULE_STATE:
    case NLB_QUERY_BDA_TEAM_STATE:
    case NLB_QUERY_PACKET_STATISTICS:
        UNIV_PRINT (("Unimplemented operation: %d", pQuery->Operation));

        pQuery->ReturnCode = NLB_QUERY_STATE_FAILURE;        

        break;

    /* Given a IP tuple (client IP, client port, server IP, server port) and a protocol, 
       determine whether or not this host would accept the packet and why or why not. It
       is important that this is performed completely unobtrusively and has no side-effects
       on the actual operation of NLB and the load module. */
    case NLB_QUERY_PACKET_FILTER:
        /* Being by Zero'ing out the results portion of the buffer. */
        NdisZeroMemory(&pQuery->Filter.Results, sizeof(pQuery->Filter.Results));

        /* Query NLB for packet filter information for this IP tuple and protocol.  Main_query_packet_filter
           checks the NDIS driver information for filtering issues such as DIP traffic, BDA teaming and 
           NLB driver state (on/off due to wlbs.exe commands and parameter errors).  If necessary, it then
           consults the load module to perform the actual port rule lookup and determine packet acceptance. */
        Main_query_packet_filter(ctxtp, &pQuery->Filter);
        
        /* This should always result in success, whether the packet is accepted or not. */
        pQuery->ReturnCode = NLB_QUERY_STATE_SUCCESS;

        break;
    default:
        UNIV_PRINT (("Unknown operation: %d", pQuery->Operation));

        pQuery->ReturnCode = NLB_QUERY_STATE_FAILURE;

        break;
    }
    
    return NDIS_STATUS_SUCCESS;
}


#if defined (NLB_SESSION_SUPPORT)
/* 
 * Function: Conn_notify_ctrl
 * Description: 
 * Parameters: 
 * Returns: 
 * Author: shouse 4.30.01
 */
NDIS_STATUS Conn_notify_ctrl (PMAIN_CTXT ctxtp, ULONG fOptions, PIOCTL_CONN_NOTIFICATION pConn) {
    PMAIN_ADAPTER pAdapter = &(univ_adapters[ctxtp->adapter_id]);
    BOOLEAN bRefused = FALSE;
    BOOLEAN bRet = TRUE;

    NdisAcquireSpinLock(&univ_bind_lock);

    /* If the adapter isn't initialized yet, refuse the request. */
    if (!pAdapter->inited) {
        NdisReleaseSpinLock(&univ_bind_lock);
        pConn->ReturnCode = NLB_ERROR_GENERIC_FAILURE;
        return NDIS_STATUS_SUCCESS;
    }

    NdisReleaseSpinLock(&univ_bind_lock);

    /* Make sure that the parameters from the input buffer are valid. */
    if ((pConn->Protocol != TCPIP_PROTOCOL_IPSEC1) || (pConn->ServerPort > CVY_MAX_PORT) || 
        (pConn->ClientPort > CVY_MAX_PORT) || (!pConn->ServerIPAddress) || (!pConn->ClientIPAddress)) {
        /* Use the return code in the IOCTL buffer to relay a parameter error and return success. */
        pConn->ReturnCode = NLB_ERROR_INVALID_PARAMETER;
        return NDIS_STATUS_SUCCESS;
    }

    switch (pConn->Operation) {
    case NLB_CONN_UP:
        /* Notify the load module of the upcoming connection. */
        bRet = Main_create_dscr(ctxtp, pConn->ServerIPAddress, pConn->ServerPort, pConn->ClientIPAddress, pConn->ClientPort, pConn->Protocol, &bRefused, FALSE);

        /* If the packet was refused by BDA or rejected by the load module, return refusal error, otherwise, it succeeded. */
        if (bRefused || !bRet) 
            pConn->ReturnCode = NLB_ERROR_REQUEST_REFUSED;
        else 
            pConn->ReturnCode = NLB_ERROR_SUCCESS;

        break;
    case NLB_CONN_DOWN:
    case NLB_CONN_RESET:
        /* Notify the load module that a connection is being torn down. */
        bRet = Main_conn_advise(ctxtp, pConn->ServerIPAddress, pConn->ServerPort, pConn->ClientIPAddress, pConn->ClientPort, pConn->Protocol, CVY_CONN_DOWN, &bRefused, FALSE);

        /* If the packet was refused by BDA or rejected by the load module, return refusal error, otherwise, it succeeded. */
        if (bRefused || !bRet) 
            pConn->ReturnCode = NLB_ERROR_REQUEST_REFUSED;
        else
            pConn->ReturnCode = NLB_ERROR_SUCCESS;

        break;
    default:
        UNIV_PRINT (("Unknown operation: %d", pConn->Operation));

        /* This should never, ever happen, but if it does, signal a generic NLB error and fail. */
        pConn->ReturnCode = NLB_ERROR_GENERIC_FAILURE;
        break;
    }

    return NDIS_STATUS_SUCCESS;
}
#endif

NDIS_STATUS Main_ctrl (
    PMAIN_CTXT              ctxtp,
    ULONG                   io_ctrl_code,
    PIOCTL_CVY_BUF          bufp,
    /* Note: optionsp CAN be NULL, so you must check it first. */
    PIOCTL_OPTIONS          optionsp) 
{
    WCHAR                   num [20];
    ULONG                   mode;
    ULONG                   old_ip;
    PMAIN_ADAPTER           adapterp = & (univ_adapters [ctxtp -> adapter_id]);


    NdisAcquireSpinLock(& univ_bind_lock);
    if (! adapterp -> inited)
    {
        NdisReleaseSpinLock(& univ_bind_lock);
        UNIV_PRINT (("unbound from all NICs"));
        return NDIS_STATUS_FAILURE;
    }

    NdisReleaseSpinLock(& univ_bind_lock);

    /* make sure data is written into bufp AFTER taking everything we need
       out of it !!! */

    switch (io_ctrl_code)
    {
        case IOCTL_CVY_RELOAD:
        {
            CVY_PARAMS old_params;
            CVY_PARAMS new_params;

            if (KeGetCurrentIrql () > PASSIVE_LEVEL)
            {
                UNIV_PRINT (("!!! IRQL IS TOO HIGH %d\n", KeGetCurrentIrql ()));
                return NDIS_STATUS_FAILURE;
            }

            /* Take a snapshot of the old parameter set for later comparison. */
            RtlCopyMemory(&old_params, &ctxtp -> params, sizeof(ctxtp -> params));

            /* Spin locks can not be acquired when we are calling Params_init
               since it will be doing registry access operations that depend on
               running at PASSIVEL_IRQL_LEVEL.  Therefore, we gather the new
               parameters into a temporary structure and copy them in the NLB
               context protected by a spin lock. */
            if (Params_init(ctxtp, univ_reg_path, adapterp->device_name + 8, &new_params) != NDIS_STATUS_SUCCESS) 
            {
                UNIV_PRINT (("error retrieving registry parameters"));
                bufp->ret_code = IOCTL_CVY_BAD_PARAMS;
                break;
            }
            
            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

            /* At this point, we have verified that the new parameters are valid,
               so copy them into the permanent parameters structure. */
            RtlCopyMemory(&ctxtp->params, &new_params, sizeof(ctxtp->params));
            ctxtp->params_valid = TRUE;

            Univ_ulong_to_str (ctxtp -> params . host_priority, num, 10);

            if (ctxtp -> convoy_enabled && 
                Main_ApplyChangeWithoutReStart(ctxtp, &old_params, &ctxtp -> params)) 
            {
                //
                // Changes is applied with no need to restart
                //
                NdisReleaseSpinLock (& ctxtp -> load_lock); 
                bufp -> ret_code = IOCTL_CVY_OK;
                break;
            }

            mode = ctxtp -> convoy_enabled;

            bufp -> ret_code = IOCTL_CVY_OK;

            if (ctxtp -> convoy_enabled)
            {
                ctxtp -> convoy_enabled = FALSE;
                Load_stop (& ctxtp -> load);

                if (ctxtp -> draining)
                {
                    ctxtp -> draining = FALSE;
                    NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */

                    UNIV_PRINT (("connection draining interrupted"));
                    LOG_MSG (MSG_INFO_DRAINING_STOPPED, MSG_NONE);

                    bufp -> ret_code = IOCTL_CVY_DRAINING_STOPPED;
                }
                else
                    NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */

                UNIV_PRINT (("cluster mode stopped"));
                LOG_MSG (MSG_INFO_STOPPED, MSG_NONE);
            }
            else
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */


            old_ip = ctxtp->cl_ip_addr;

            if (! Main_ip_addr_init (ctxtp) || ! Main_mac_addr_init (ctxtp) || ! Main_teaming_init(ctxtp))
            {
                ctxtp -> params_valid = FALSE;
                UNIV_PRINT (("parameter error"));
                LOG_MSG (MSG_ERROR_DISABLED, MSG_NONE);
                bufp -> ret_code  = IOCTL_CVY_BAD_PARAMS;
                break;
            }

	    if (ctxtp -> params . mcast_support && ctxtp -> params . igmp_support)
		Main_igmp_init (ctxtp, TRUE);

            if (old_ip != ctxtp->cl_ip_addr)
            {
                NdisAcquireSpinLock (& ctxtp -> load_lock);
                univ_changing_ip = ctxtp -> params.ip_chg_delay;
                NdisReleaseSpinLock (& ctxtp -> load_lock);

                UNIV_PRINT (("changing IP address with delay %d", univ_changing_ip));
            }

            LOG_MSG (MSG_INFO_RELOADED, MSG_NONE);

            if (mode)
            {
                NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

                Load_start (& ctxtp -> load);
                ctxtp -> convoy_enabled = TRUE;

                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */

                UNIV_PRINT (("cluster mode started"));
                LOG_MSG (MSG_INFO_STARTED, num);
            }

            ctxtp -> bad_host_warned = FALSE;

            UNIV_PRINT (("parameters reloaded"));

            break;
        }
        

        case IOCTL_CVY_CLUSTER_RESUME:

            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

            if (! ctxtp -> suspended)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("cluster mode already resumed"));
                bufp -> ret_code = IOCTL_CVY_ALREADY;
                break;
            }

            UNIV_ASSERT (! ctxtp -> convoy_enabled);
            UNIV_ASSERT (! ctxtp -> draining);

            ctxtp -> suspended = FALSE;
            NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */

            UNIV_PRINT (("cluster mode resumed"));
            LOG_MSG (MSG_INFO_RESUMED, MSG_NONE);

            bufp -> ret_code = IOCTL_CVY_OK;
            break;

        case IOCTL_CVY_CLUSTER_ON:

            Univ_ulong_to_str (ctxtp -> params . host_priority, num, 10);

            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

            if (ctxtp -> suspended)
            {
                UNIV_ASSERT (! ctxtp -> convoy_enabled);
                UNIV_ASSERT (! ctxtp -> draining);

                NdisReleaseSpinLock (& ctxtp -> load_lock);
                UNIV_PRINT (("cluster mode is suspended"));
                bufp -> ret_code = IOCTL_CVY_SUSPENDED;
                break;
            }

            /* V2.1 */

            if (ctxtp -> draining)
            {
                UNIV_ASSERT (ctxtp -> convoy_enabled);

                UNIV_PRINT(("START: Calling Load_port_change -> VIP=%08x, port=%d, load=%d\n", 
                            IOCTL_ALL_VIPS, IOCTL_ALL_PORTS, 0));

                bufp -> ret_code = Load_port_change (& ctxtp -> load,
                                                     IOCTL_ALL_VIPS,
                                                     IOCTL_ALL_PORTS,
                                                     (ULONG) IOCTL_CVY_CLUSTER_PLUG,
                                                     0);

                ctxtp -> draining = FALSE;

                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */

                UNIV_PRINT (("connection draining interrupted"));
                LOG_MSG (MSG_INFO_DRAINING_STOPPED, MSG_NONE);

                UNIV_PRINT (("cluster mode started"));
                LOG_MSG (MSG_INFO_STARTED, num);

                bufp -> ret_code = IOCTL_CVY_DRAINING_STOPPED;
                break;
            }

            if (ctxtp -> convoy_enabled)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("cluster mode already started"));
                bufp -> ret_code = IOCTL_CVY_ALREADY;
                break;
            }

            if (! ctxtp -> params_valid)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("parameter error"));
                LOG_MSG (MSG_ERROR_DISABLED, MSG_NONE);
                bufp -> ret_code  = IOCTL_CVY_BAD_PARAMS;
                break;
            }

            Load_start (& ctxtp -> load);
            ctxtp -> convoy_enabled = TRUE;
            NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */

            ctxtp -> bad_host_warned = FALSE;

            UNIV_PRINT (("cluster mode started"));
            LOG_MSG (MSG_INFO_STARTED, num);

            bufp -> ret_code = IOCTL_CVY_OK;
            break;

        case IOCTL_CVY_CLUSTER_SUSPEND:

            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

            if (ctxtp -> suspended)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("cluster mode already suspended"));
                bufp -> ret_code = IOCTL_CVY_ALREADY;
                break;
            }

            ctxtp -> suspended = TRUE;

            if (ctxtp -> convoy_enabled)
            {
                ctxtp -> convoy_enabled = FALSE;
                ctxtp -> stopping = TRUE;
                Load_stop (& ctxtp -> load);

                /* V2.1 */

                if (ctxtp -> draining)
                {
                    ctxtp -> draining = FALSE;

                    NdisReleaseSpinLock (& ctxtp -> load_lock);
                    UNIV_PRINT (("connection draining interrupted"));
                    LOG_MSG (MSG_INFO_DRAINING_STOPPED, MSG_NONE);

                    bufp -> ret_code = IOCTL_CVY_DRAINING_STOPPED;
                }
                else
                {
                    NdisReleaseSpinLock (& ctxtp -> load_lock);
                    bufp -> ret_code = IOCTL_CVY_STOPPED;
                }

                UNIV_PRINT (("cluster mode stopped"));
                LOG_MSG (MSG_INFO_STOPPED, MSG_NONE);
            }
            else
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);
                bufp -> ret_code = IOCTL_CVY_OK;
            }

            UNIV_PRINT (("cluster mode suspended"));
            LOG_MSG (MSG_INFO_SUSPENDED, MSG_NONE);

            break;

        case IOCTL_CVY_CLUSTER_OFF:

            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3, V1.3.2b */

            if (ctxtp -> suspended)
            {
                UNIV_ASSERT (! ctxtp -> convoy_enabled);
                UNIV_ASSERT (! ctxtp -> draining);

                NdisReleaseSpinLock (& ctxtp -> load_lock);
                UNIV_PRINT (("cluster mode is suspended"));
                bufp -> ret_code = IOCTL_CVY_SUSPENDED;
                break;
            }

            if (! ctxtp -> convoy_enabled)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("cluster mode already stopped"));
                bufp -> ret_code = IOCTL_CVY_ALREADY;
                break;
            }

            ctxtp -> convoy_enabled = FALSE;
            ctxtp -> stopping = TRUE;
            Load_stop (& ctxtp -> load);

            /* V2.1 */

            if (ctxtp -> draining)
            {
                ctxtp -> draining = FALSE;
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */

                UNIV_PRINT (("connection draining interrupted"));
                LOG_MSG (MSG_INFO_DRAINING_STOPPED, MSG_NONE);

                bufp -> ret_code = IOCTL_CVY_DRAINING_STOPPED;
            }
            else
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3 */
                bufp -> ret_code = IOCTL_CVY_OK;
            }

            UNIV_PRINT (("cluster mode stopped"));
            LOG_MSG (MSG_INFO_STOPPED, MSG_NONE);

            break;

        /* V2.1 */

        case IOCTL_CVY_CLUSTER_DRAIN:

            NdisAcquireSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            if (ctxtp -> suspended)
            {
                UNIV_ASSERT (! ctxtp -> convoy_enabled);
                UNIV_ASSERT (! ctxtp -> draining);

                NdisReleaseSpinLock (& ctxtp -> load_lock);
                UNIV_PRINT (("cluster mode is suspended"));
                bufp -> ret_code = IOCTL_CVY_SUSPENDED;
                break;
            }

            if (! ctxtp -> convoy_enabled)
            {
                UNIV_ASSERT (! ctxtp -> draining);
                NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */
                UNIV_PRINT (("cannot drain connections while cluster is stopped"));
                bufp -> ret_code = IOCTL_CVY_STOPPED;
                break;
            }

            if (ctxtp -> draining)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);     /* V1.0.3, V1.3.2b */
                UNIV_PRINT (("already draining"));
                bufp -> ret_code = IOCTL_CVY_ALREADY;
                break;
            }

            ctxtp -> draining = TRUE;

            UNIV_PRINT(("DRAIN: Calling Load_port_change -> VIP=%08x, port=%d, load=%d\n", 
                        IOCTL_ALL_VIPS, IOCTL_ALL_PORTS, 0));

            bufp -> ret_code = Load_port_change (& ctxtp -> load,
                                                 IOCTL_ALL_VIPS,
                                                 IOCTL_ALL_PORTS,
                                                 io_ctrl_code,
                                                 0);

            NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            if (bufp -> ret_code == IOCTL_CVY_OK)
            {
                UNIV_PRINT (("connection draining started"));
                LOG_MSG (MSG_INFO_CLUSTER_DRAINED, MSG_NONE);
            }

            break;

        case IOCTL_CVY_PORT_ON:
        case IOCTL_CVY_PORT_SET:

            Univ_ulong_to_str (bufp -> data . port . num, num, 10);

            NdisAcquireSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            if (ctxtp -> suspended)
            {
                UNIV_ASSERT (! ctxtp -> convoy_enabled);
                UNIV_ASSERT (! ctxtp -> draining);

                NdisReleaseSpinLock (& ctxtp -> load_lock);
                UNIV_PRINT (("cluster mode is suspended"));
                bufp -> ret_code = IOCTL_CVY_SUSPENDED;
                break;
            }

            if (! ctxtp -> convoy_enabled)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */
                UNIV_PRINT (("cannot enable/disable port while cluster is stopped"));
                LOG_MSG (MSG_WARN_CLUSTER_STOPPED, MSG_NONE);
                bufp -> ret_code = IOCTL_CVY_STOPPED;
                break;
            }

            UNIV_PRINT(("ENABLE: Calling Load_port_change -> VIP=%08x, port=%d, load=%d\n", 
                        (optionsp) ? optionsp->port.virtual_ip_addr : IOCTL_ALL_VIPS, bufp->data.port.num, bufp->data.port.load));

            bufp -> ret_code = Load_port_change (& ctxtp -> load,
                                                 (optionsp) ? optionsp->port.virtual_ip_addr : IOCTL_ALL_VIPS,
                                                 bufp->data.port.num,
                                                 io_ctrl_code,
                                                 bufp->data.port.load);

            NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            if (bufp -> ret_code == IOCTL_CVY_NOT_FOUND)
            {
                UNIV_PRINT (("port %d not found in any of the valid port rules", bufp -> data . port . num));
                LOG_MSG (MSG_WARN_PORT_NOT_FOUND, num);
            }
            else if (bufp -> ret_code == IOCTL_CVY_OK)
            {
                if (io_ctrl_code == IOCTL_CVY_PORT_ON)
                {
                    if (bufp -> data . port . num == IOCTL_ALL_PORTS)
                    {
                        UNIV_PRINT (("all port rules enabled"));
                        LOG_MSG (MSG_INFO_PORT_ENABLED_ALL, MSG_NONE);
                    }
                    else
                    {
                        UNIV_PRINT (("rule for port %d enabled", bufp -> data . port . num));
                        LOG_MSG (MSG_INFO_PORT_ENABLED, num);
                    }
                }
                else
                {
                    if (bufp -> data . port . num == IOCTL_ALL_PORTS)
                    {
                        UNIV_PRINT (("all port rules adjusted"));
                        LOG_MSG (MSG_INFO_PORT_ADJUSTED_ALL, MSG_NONE);
                    }
                    else
                    {
                        UNIV_PRINT (("rule for port %d adjusted to %d", bufp -> data . port . num, bufp -> data . port . load));
                        LOG_MSG (MSG_INFO_PORT_ADJUSTED, num);
                    }
                }
            }
            else
            {
                UNIV_PRINT (("port %d already enabled", bufp -> data . port . num));
            }

            break;

        case IOCTL_CVY_PORT_OFF:
        case IOCTL_CVY_PORT_DRAIN:

            Univ_ulong_to_str (bufp -> data . port . num, num, 10);

            NdisAcquireSpinLock (& ctxtp -> load_lock);   /* V1.0.3 */

            if (ctxtp -> suspended)
            {
                UNIV_ASSERT (! ctxtp -> convoy_enabled);
                UNIV_ASSERT (! ctxtp -> draining);

                NdisReleaseSpinLock (& ctxtp -> load_lock);
                UNIV_PRINT (("cluster mode is suspended"));
                bufp -> ret_code = IOCTL_CVY_SUSPENDED;
                break;
            }

            if (! ctxtp -> convoy_enabled)
            {
                NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */
                UNIV_PRINT (("cannot enable/disable port while cluster is stopped"));
                LOG_MSG (MSG_WARN_CLUSTER_STOPPED, MSG_NONE);
                bufp -> ret_code = IOCTL_CVY_STOPPED;
                break;
            }

            UNIV_PRINT(("DISABLE: Calling Load_port_change -> VIP=%08x, port=%d, load=%d\n", 
                        (optionsp) ? optionsp->port.virtual_ip_addr : IOCTL_ALL_VIPS, bufp->data.port.num, bufp->data.port.load));

            bufp -> ret_code = Load_port_change (& ctxtp -> load,
                                                 (optionsp) ? optionsp->port.virtual_ip_addr : IOCTL_ALL_VIPS,
                                                 bufp->data.port.num,
                                                 io_ctrl_code,
                                                 bufp->data.port.load);

            NdisReleaseSpinLock (& ctxtp -> load_lock); /* V1.0.3 */

            if (bufp -> ret_code == IOCTL_CVY_NOT_FOUND)
            {
                UNIV_PRINT (("port %d not found in any of the valid port rules", bufp -> data . port . num));
                LOG_MSG (MSG_WARN_PORT_NOT_FOUND, num);
            }
            else if (bufp -> ret_code == IOCTL_CVY_OK)
            {
                if (io_ctrl_code == IOCTL_CVY_PORT_OFF)
                {
                    if (bufp -> data . port . num == IOCTL_ALL_PORTS)
                    {
                        UNIV_PRINT (("all port rules disabled"));
                        LOG_MSG (MSG_INFO_PORT_DISABLED_ALL, MSG_NONE);
                    }
                    else
                    {
                        UNIV_PRINT (("rule for port %d disabled", bufp -> data . port . num));
                        LOG_MSG (MSG_INFO_PORT_DISABLED, num);
                    }
                }
                else
                {
                    if (bufp -> data . port . num == IOCTL_ALL_PORTS)
                    {
                        UNIV_PRINT (("all port rules drained"));
                        LOG_MSG (MSG_INFO_PORT_DRAINED_ALL, MSG_NONE);
                    }
                    else
                    {
                        UNIV_PRINT (("rule for port %d drained", bufp -> data . port . num));
                        LOG_MSG (MSG_INFO_PORT_DRAINED, num);
                    }
                }
            }
            else
            {
                UNIV_PRINT (("port %d already disabled", bufp -> data . port . num));
            }

            break;

        case IOCTL_CVY_QUERY:

            NdisAcquireSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            if (ctxtp -> suspended)
            {
                UNIV_PRINT (("cannot query status - this host is suspended"));
                bufp -> data . query . state = IOCTL_CVY_SUSPENDED;
            }
            else if (! ctxtp -> convoy_enabled)
            {
                UNIV_PRINT (("cannot query status - this host is not part of the cluster"));
                bufp -> data . query . state = IOCTL_CVY_STOPPED;
            }
            else if (!ctxtp -> media_connected || !MAIN_PNP_DEV_ON(ctxtp))
            {
                UNIV_PRINT (("cannot query status - this host is not connected to the network"));
                bufp -> data . query . state = IOCTL_CVY_DISCONNECTED;
            }
            else
            {
                ULONG     tmp_host_map; /* 64-bit -- ramkrish */

                bufp -> data . query . state = (USHORT) Load_hosts_query (& ctxtp -> load, FALSE,
                                                                          & tmp_host_map);
                bufp -> data . query . host_map = tmp_host_map;

                /* V2.1 */

                if (ctxtp -> draining &&
                    bufp -> data . query . state != IOCTL_CVY_CONVERGING)
                    bufp -> data . query . state = IOCTL_CVY_DRAINING;
            }

            bufp -> data . query . host_id = (USHORT) ctxtp -> params . host_priority;

            NdisReleaseSpinLock (& ctxtp -> load_lock);  /* V1.0.3 */

            /* If the user-level application has requested the hostname, return it. */
            if (optionsp && (optionsp->query.flags & IOCTL_OPTIONS_QUERY_HOSTNAME))
                NdisMoveMemory(optionsp->query.hostname, ctxtp->params.hostname, CVY_MAX_HOST_NAME + 1);

            break;

        default:
            UNIV_PRINT (("bad IOCTL %x", io_ctrl_code));
            return NDIS_STATUS_FAILURE;
    }

    return NDIS_STATUS_SUCCESS;

} /* end Main_ctrl */




//+----------------------------------------------------------------------------
//
// Function:  Main_ctrl_recv
//
// Description:  Process remote control request packet
//
// Arguments: MAIN_CTXT          ctxtp - 
//            PNDIS_PACKET        packet - 
//
// Returns:   Nothing
//
// History:   kyrilf initial code
//            fengsun Created Header    11/15/00
//
//+----------------------------------------------------------------------------
VOID Main_ctrl_recv (
    PMAIN_CTXT          ctxtp,
    PNDIS_PACKET        packet)
{
    NDIS_STATUS         status = NDIS_STATUS_SUCCESS;
    PIP_HDR             ip_hdrp;
    PUCHAR              mac_hdrp;
    PUDP_HDR            udp_hdrp;
    ULONG               len;
    USHORT              sig;
    ULONG               soff, doff;
    CVY_MAC_ADR         tmp_mac;
    PIOCTL_REMOTE_HDR   rct_hdrp;
    ULONG               state, host_map;
    USHORT              checksum, group;
    ULONG               i;
    ULONG               tmp_src_addr, tmp_dst_addr;   /* 64-bit -- ramkrish */
    USHORT              tmp_src_port, tmp_dst_port;   /* 64-bit -- ramkrish */
    BOOLEAN             IgnorePassword = FALSE;   // whether to ignore remote control password

    UNIV_PRINT (("Main_ctrl_recv: processing"));

    ip_hdrp = (PIP_HDR) Main_frame_parse (ctxtp, packet, & mac_hdrp, 0,
                                          (PUCHAR *) & udp_hdrp, & len, & sig,
                                          & group, FALSE);

    if (ip_hdrp == NULL || udp_hdrp == NULL)  /* v2.0.6 */
        goto quit;

    /* v2.0.6 */

    if (len < NLB_MIN_RCTL_PACKET_LEN(ip_hdrp))
    {
        UNIV_PRINT(("remote control packet not expected length: got %d bytes, expected at least %d bytes\n", len, NLB_MIN_RCTL_PACKET_LEN(ip_hdrp)));
        goto quit;
    }

    checksum = Tcpip_chksum (& ctxtp -> tcpip, ip_hdrp, NULL, TCPIP_PROTOCOL_IP);

    if (IP_GET_CHKSUM (ip_hdrp) != checksum)
    {
        UNIV_PRINT (("bad PP checksum %x vs %x\n", IP_GET_CHKSUM (ip_hdrp), checksum))
        goto quit;
    }

    checksum = Tcpip_chksum (& ctxtp -> tcpip, ip_hdrp, (PUCHAR) udp_hdrp, TCPIP_PROTOCOL_UDP);

    if (UDP_GET_CHKSUM (udp_hdrp) != checksum)
    {
        UNIV_PRINT (("bad UDP checksum %x vs %x\n", UDP_GET_CHKSUM (udp_hdrp), checksum))
        goto quit;
    }

    rct_hdrp = (PIOCTL_REMOTE_HDR) UDP_GET_DGRAM_PTR (udp_hdrp);

    /* double-check the code */

    if (rct_hdrp -> code != IOCTL_REMOTE_CODE)
    {
        UNIV_PRINT (("bad RCT code %x\n", rct_hdrp -> code));
        goto quit;
    }

    /* might want to take appropriate actions for a message from a host
       running different version number of software */

    if (rct_hdrp -> version != CVY_VERSION_FULL)
    {
        UNIV_PRINT (("version mismatch %x vs %x", rct_hdrp -> version, CVY_VERSION_FULL));
    }

    /* see if this message is destined for this cluster */

    if (rct_hdrp -> cluster != ctxtp -> cl_ip_addr)
    {
        UNIV_PRINT (("message for cluster %08X rejected on cluster %08X", rct_hdrp -> cluster, ctxtp -> cl_ip_addr));
        goto quit;
    }

    /* 64-bit -- ramkrish */

    tmp_src_addr = IP_GET_SRC_ADDR_64(ip_hdrp);
    tmp_dst_addr = IP_GET_DST_ADDR_64(ip_hdrp);

    /* do not trust src addr in header, since winsock does not resolve
       multihomed addresses properly */

    rct_hdrp -> addr = tmp_src_addr;

    /* If remote control is disabled, we drop the requests. */
    if (!ctxtp->params.rct_enabled) {
        /* If remote control is disabled, still allows query originated from a machine in 
           the same cluster.  This way, an application running on one host can get a list 
           of all hosts (include stopped host) even if remote control is disabled. */
        if (rct_hdrp->ioctrl != IOCTL_CVY_QUERY)
            goto quit;

        /* This in only supported using the XP remote control packet format. */
        if (rct_hdrp->version != CVY_VERSION_FULL)
            goto quit;

        /* Make sure that the packet length is what we expect, or we may fault. */
        if (len < NLB_WINXP_RCTL_PACKET_LEN(ip_hdrp))
            goto quit;

        /* Check to see if the request originated on a member of the cluster for
           which the query is destined.  The user-level software on the initiator
           checks its own NLB configuration and sets this bit if it is a member
           of the target cluster. */
        if (!(rct_hdrp->options.query.flags & IOCTL_OPTIONS_QUERY_CLUSTER_MEMBER))
            goto quit;

        /* Ignore the password in such an instance. */
        IgnorePassword = TRUE;
    }

    /* query load to see if we are the master, etc. */

    if (! ctxtp -> convoy_enabled)
        state = IOCTL_CVY_STOPPED;
    else
        state = Load_hosts_query (& ctxtp -> load, FALSE, & host_map);

    /* check if this message is destined to us */

    //
    // The host id in the remote control packet could be
    //      IOCTL_MASTER_HOST (0) for master host
    //      IOCTL_ALL_HOSTS (FFFFFFFF) for all hosts
    //      Host ID, for one host
    //      Dedicated IP, for one host
    //      Cluster IP, for all hosts in the cluster
    //
    
    if (rct_hdrp -> host == IOCTL_MASTER_HOST)
    {
        if (state != IOCTL_CVY_MASTER)
        {
            UNIV_PRINT (("RCT request for MASTER host rejected"));
            goto quit;
        }
    }
    else if (rct_hdrp -> host != IOCTL_ALL_HOSTS)
    {
        if (rct_hdrp -> host > CVY_MAX_HOSTS)
        {
            if (! ((ctxtp -> ded_ip_addr != 0 &&
                    rct_hdrp -> host == ctxtp -> ded_ip_addr) ||
                    rct_hdrp -> host == ctxtp -> cl_ip_addr))
            {
                UNIV_PRINT (("RCT request for host IP %x rejected", rct_hdrp -> host));
                goto quit;
            }
        }
        else
        {
            if (! (rct_hdrp -> host == ctxtp -> params . host_priority ||
                   rct_hdrp -> host == 0))
            {
                UNIV_PRINT (("RCT request for host ID %d rejected", rct_hdrp -> host));
                goto quit;
            }
        }
    }



    /* if this is VR remote maintenance password */

    if (rct_hdrp -> password == IOCTL_REMOTE_VR_CODE)
    {
        /* if user disabled this function - drop the packet */

        if (ctxtp -> params . rmt_password == 0)
        {
            UNIV_PRINT (("VR remote password rejected"));
            goto quit;
        }
        else
        {
            UNIV_PRINT (("VR remote password accepted"));
        }
    }


    //
    // This is a new remote control request, with a different source IP 
    //  or newer ID.
    // Log an event if the password does not match or if the command is not query
    //
    if (! (rct_hdrp -> addr == ctxtp -> rct_last_addr &&
           rct_hdrp -> id   <= ctxtp -> rct_last_id))
    {
        WCHAR               buf [256];  
        PWCHAR              ptr = buf;

        //
        // Generate string "SourceIp:SourcePort"
        //
        for (i = 0; i < 4; i ++)
        {
            ptr = Univ_ulong_to_str (IP_GET_SRC_ADDR (ip_hdrp, i), ptr, 10);

            * ptr = L'.';
            ptr ++;
        }

        ptr --;
        * ptr = L':';
        ptr ++;

        ptr = Univ_ulong_to_str (UDP_GET_SRC_PORT (udp_hdrp), ptr, 10);
        * ptr = 0;

        if (!IgnorePassword &&
            ctxtp -> params . rct_password != 0 &&
            rct_hdrp -> password != ctxtp -> params . rct_password)
        {
            LOG_MSG (MSG_WARN_RCT_HACK, buf);

            UNIV_PRINT (("RCT hack attempt on port %d from %d.%d.%d.%d:%d",
                                                UDP_GET_DST_PORT (udp_hdrp),
                                                IP_GET_SRC_ADDR (ip_hdrp, 0),
                                                IP_GET_SRC_ADDR (ip_hdrp, 1),
                                                IP_GET_SRC_ADDR (ip_hdrp, 2),
                                                IP_GET_SRC_ADDR (ip_hdrp, 3),
                                                UDP_GET_SRC_PORT (udp_hdrp)));
        }

        /* only log error commands and commands that affect cluster state */

        else if (rct_hdrp -> ioctrl != IOCTL_CVY_QUERY)
        {
            PWSTR           cmd;

            switch (rct_hdrp -> ioctrl)
            {
                case IOCTL_CVY_CLUSTER_ON:
                    cmd = L"START";
                    break;

                case IOCTL_CVY_CLUSTER_OFF:
                    cmd = L"STOP";
                    break;

                case IOCTL_CVY_CLUSTER_DRAIN:
                    cmd = L"DRAINSTOP";
                    break;

                case IOCTL_CVY_PORT_ON:
                    cmd = L"ENABLE";
                    break;

                case IOCTL_CVY_PORT_SET:
                    cmd = L"ADJUST";
                    break;

                case IOCTL_CVY_PORT_OFF:
                    cmd = L"DISABLE";
                    break;

                case IOCTL_CVY_PORT_DRAIN:
                    cmd = L"DRAIN";
                    break;

                case IOCTL_CVY_QUERY:
                    cmd = L"QUERY";
                    break;

                case IOCTL_CVY_CLUSTER_SUSPEND:
                    cmd = L"SUSPEND";
                    break;

                case IOCTL_CVY_CLUSTER_RESUME:
                    cmd = L"RESUME";
                    break;

                default:
                    cmd = L"UNKNOWN";
                    break;
            }


            LOG_MSGS (MSG_INFO_RCT_RCVD, cmd, buf);

            UNIV_PRINT (("RCT command %x port %d from %d.%d.%d.%d:%d",
                                                rct_hdrp -> ioctrl,
                                                UDP_GET_DST_PORT (udp_hdrp),
                                                IP_GET_SRC_ADDR (ip_hdrp, 0),
                                                IP_GET_SRC_ADDR (ip_hdrp, 1),
                                                IP_GET_SRC_ADDR (ip_hdrp, 2),
                                                IP_GET_SRC_ADDR (ip_hdrp, 3),
                                                UDP_GET_SRC_PORT (udp_hdrp)));
        }
    }

    ctxtp -> rct_last_addr = rct_hdrp -> addr;
    ctxtp -> rct_last_id   = rct_hdrp -> id;

    /* make sure remote control password matches ours */

    if (!IgnorePassword &&
        ctxtp -> params . rct_password != 0 &&
        rct_hdrp -> password != ctxtp -> params . rct_password)
    {
        rct_hdrp -> ctrl . ret_code = IOCTL_CVY_BAD_PASSWORD;
        goto send;
    }

    if (rct_hdrp->version == CVY_NT40_VERSION_FULL) {
        /* Make sure that the packet length is what we expect, or we may fault. */
        if (len < NLB_NT40_RCTL_PACKET_LEN(ip_hdrp)) {
            UNIV_PRINT(("NT 4.0 remote control packet not expected length: got %d bytes, expected %d bytes\n", len, NLB_NT40_RCTL_PACKET_LEN(ip_hdrp)));
            goto quit;
        }

        /* If this remote control packet came from an NT 4.0 host, check our current effective version
           and drop it if we are operating in a Whistler-specific mode (virtual clusters, BDA, etc.). */
        if (ctxtp->params.effective_ver == CVY_VERSION_FULL &&
            (rct_hdrp->ioctrl == IOCTL_CVY_PORT_ON          ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_OFF         ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_SET         ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_DRAIN))
            goto quit;
        /* Otherwise, perform the operation.  Since this request came from a win2K/NT4 host, then hardcode 
           the VIP, which should be ignored by Main_ctrl since we aren't using Virtual clusters. */
        else
            status = Main_ctrl(ctxtp, rct_hdrp->ioctrl, &rct_hdrp->ctrl, NULL);
    } else if (rct_hdrp->version == CVY_WIN2K_VERSION_FULL) {
        /* Make sure that the packet length is what we expect, or we may fault. */
        if (len < NLB_WIN2K_RCTL_PACKET_LEN(ip_hdrp)) {
            UNIV_PRINT(("Windows 2000 remote control packet not expected length: got %d bytes, expected %d bytes\n", len, NLB_WIN2K_RCTL_PACKET_LEN(ip_hdrp)));
            goto quit;
        }

        /* If this remote control packet came from an Win2k host, check our current effective version
           and drop it if we are operating in a Whistler-specific mode (virtual clusters, BDA, etc.). */
        if (ctxtp->params.effective_ver == CVY_VERSION_FULL &&
            (rct_hdrp->ioctrl == IOCTL_CVY_PORT_ON          ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_OFF         ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_SET         ||
             rct_hdrp->ioctrl == IOCTL_CVY_PORT_DRAIN))           
            goto quit;
        /* Otherwise, perform the operation.  Since this request came from a win2K/NT4 host, then hardcode 
           the VIP, which should be ignored by Main_ctrl since we aren't using Virtual clusters. */
        else
            status = Main_ctrl(ctxtp, rct_hdrp->ioctrl, &rct_hdrp->ctrl, NULL);
    } else {
        /* Make sure that the packet length is what we expect, or we may fault. */
        if (len < NLB_WINXP_RCTL_PACKET_LEN(ip_hdrp)) {
            UNIV_PRINT(("Windows XP remote control packet not expected length: got %d bytes, expected %d bytes\n", len, NLB_WINXP_RCTL_PACKET_LEN(ip_hdrp)));
            goto quit;
        }

        /* Perform the operation.  The virtual IP address is stored in the remote control 
           buffer, not in the IOCTL buffer for reasons of backward compatibility. */
        status = Main_ctrl(ctxtp, rct_hdrp->ioctrl, &rct_hdrp->ctrl, &rct_hdrp->options);
    }

    /* if did not succeed - just drop the packet - client will timeout and
       resend the request */

    if (status != NDIS_STATUS_SUCCESS)
        goto quit;

send:

    rct_hdrp -> version = CVY_VERSION_FULL;
    rct_hdrp -> host    = ctxtp -> params . host_priority;
    rct_hdrp -> addr    = ctxtp -> ded_ip_addr;

    /* flip source and destination MAC, IP addresses and UDP ports to prepare
       for sending this message back */

    soff = CVY_MAC_SRC_OFF (ctxtp -> medium);
    doff = CVY_MAC_DST_OFF (ctxtp -> medium);

    /* V2.0.6 recoded for clarity */

    if (ctxtp -> params . mcast_support)
    {
        if (CVY_MAC_ADDR_BCAST (ctxtp -> medium, mac_hdrp + doff))
            CVY_MAC_ADDR_COPY (ctxtp -> medium, & tmp_mac, & ctxtp -> ded_mac_addr);
        else
            CVY_MAC_ADDR_COPY (ctxtp -> medium, & tmp_mac, mac_hdrp + doff);

        CVY_MAC_ADDR_COPY (ctxtp -> medium, mac_hdrp + doff, mac_hdrp + soff);
        CVY_MAC_ADDR_COPY (ctxtp -> medium, mac_hdrp + soff, & tmp_mac);
    }
    else
    {
        if (! CVY_MAC_ADDR_BCAST (ctxtp -> medium, mac_hdrp + doff))
        {
            CVY_MAC_ADDR_COPY (ctxtp -> medium, & tmp_mac, mac_hdrp + doff);
            CVY_MAC_ADDR_COPY (ctxtp -> medium, mac_hdrp + doff, mac_hdrp + soff);
        }
        else
            CVY_MAC_ADDR_COPY (ctxtp -> medium, & tmp_mac, & ctxtp -> ded_mac_addr);

        /* V2.0.6 spoof source mac to prevent switches from getting confused */

        if (ctxtp -> params . mask_src_mac &&
            CVY_MAC_ADDR_COMP (ctxtp -> medium, & tmp_mac, & ctxtp -> cl_mac_addr))
        {
            CVY_MAC_ADDR_LAA_SET (ctxtp -> medium, mac_hdrp + soff);

            * ((PUCHAR) (mac_hdrp + soff + 1)) = (UCHAR) ctxtp -> params . host_priority;
            * ((PULONG) (mac_hdrp + soff + 2)) = ctxtp -> cl_ip_addr;
        }
        else
            CVY_MAC_ADDR_COPY (ctxtp -> medium, mac_hdrp + soff, & tmp_mac);
    }


    /* 64-bit -- ramkrish */
    if (tmp_dst_addr == TCPIP_BCAST_ADDR)
    {
        tmp_dst_addr = ctxtp -> cl_ip_addr;

        if (ctxtp -> params . mcast_support)
            IP_SET_DST_ADDR_64 (ip_hdrp, tmp_src_addr);  /* 64-bit -- ramkrish */
    }
    else
        IP_SET_DST_ADDR_64 (ip_hdrp, tmp_src_addr); /* 64-bit -- ramkrish */

    IP_SET_SRC_ADDR_64 (ip_hdrp, tmp_dst_addr);

    checksum = Tcpip_chksum (& ctxtp -> tcpip, ip_hdrp, NULL, TCPIP_PROTOCOL_IP);
    IP_SET_CHKSUM (ip_hdrp, checksum);

    /* 64-bit -- ramkrish */
    tmp_src_port = (USHORT) UDP_GET_SRC_PORT (udp_hdrp);
    tmp_dst_port = (USHORT) UDP_GET_DST_PORT (udp_hdrp);

    UDP_SET_SRC_PORT_64 (udp_hdrp, tmp_dst_port);
    UDP_SET_DST_PORT_64 (udp_hdrp, tmp_src_port);

    checksum = Tcpip_chksum (& ctxtp -> tcpip, ip_hdrp, (PUCHAR) udp_hdrp, TCPIP_PROTOCOL_UDP);
    UDP_SET_CHKSUM (udp_hdrp, checksum);

#if defined(TRACE_RCT)
            DbgPrint ("(RCT) sending reply to %d.%d.%d.%d:%d [%02x-%02x-%02x-%02x-%02x-%02x]\n",
                                                IP_GET_DST_ADDR (ip_hdrp, 0),
                                                IP_GET_DST_ADDR (ip_hdrp, 1),
                                                IP_GET_DST_ADDR (ip_hdrp, 2),
                                                IP_GET_DST_ADDR (ip_hdrp, 3),
                                                UDP_GET_DST_PORT (udp_hdrp),
                                                * (mac_hdrp + doff + 0),
                                                * (mac_hdrp + doff + 1),
                                                * (mac_hdrp + doff + 2),
                                                * (mac_hdrp + doff + 3),
                                                * (mac_hdrp + doff + 4),
                                                * (mac_hdrp + doff + 5));
            DbgPrint ("                  from %d.%d.%d.%d:%d [%02x-%02x-%02x-%02x-%02x-%02x]\n",
                                                IP_GET_SRC_ADDR (ip_hdrp, 0),
                                                IP_GET_SRC_ADDR (ip_hdrp, 1),
                                                IP_GET_SRC_ADDR (ip_hdrp, 2),
                                                IP_GET_SRC_ADDR (ip_hdrp, 3),
                                                UDP_GET_SRC_PORT (udp_hdrp),
                                                * (mac_hdrp + soff + 0),
                                                * (mac_hdrp + soff + 1),
                                                * (mac_hdrp + soff + 2),
                                                * (mac_hdrp + soff + 3),
                                                * (mac_hdrp + soff + 4),
                                                * (mac_hdrp + soff + 5));

#endif

    /* send back response */

    NdisSend (& status, ctxtp -> mac_handle, packet);

quit:

    /* note that we have to put packet back 'unoptimized' way since we are
       running at PASSIVE IRQL from RecvComplete */

    if (status != NDIS_STATUS_PENDING)
    {
        UNIV_PRINT (("Main_ctrl_recv: packet not pending\n"));
        Main_packet_put (ctxtp, packet, TRUE, status);
    }

} /* end Main_ctrl_recv */


// ###### code added for multiple nic support - ramkrish
INT Main_adapter_alloc (
    PWSTR               device_name)
{
    INT                 i;


    UNIV_PRINT (("Main_adapter_alloc: for %ls", device_name));

    NdisAcquireSpinLock (& univ_bind_lock);

    if (univ_adapters_count == CVY_MAX_ADAPTERS)
    {
        NdisReleaseSpinLock (& univ_bind_lock);
        return MAIN_ADAPTER_NOT_FOUND;
    }

    NdisReleaseSpinLock (& univ_bind_lock);

    for (i = 0 ; i < CVY_MAX_ADAPTERS; i++)
    {
        NdisAcquireSpinLock (& univ_bind_lock);
        if (univ_adapters [i] . used == FALSE)
        {
            univ_adapters [i] . used = TRUE;
            univ_adapters_count ++;
            NdisReleaseSpinLock (& univ_bind_lock);
            break;
        }
        NdisReleaseSpinLock (& univ_bind_lock);
    }

    if (i >= CVY_MAX_ADAPTERS)
        return MAIN_ADAPTER_NOT_FOUND;

    NdisAcquireSpinLock (& univ_bind_lock);

    univ_adapters [i] . bound = FALSE;
    univ_adapters [i] . inited = FALSE;
    univ_adapters [i] . announced = FALSE;

    NdisReleaseSpinLock (& univ_bind_lock);

    return i;
} /* end Main_adapter_alloc */


INT Main_adapter_get (
    PWSTR               device_name)
{
    INT i;
    NDIS_STRING         new_device_name, cur_device_name;


    if (device_name == NULL)
        return MAIN_ADAPTER_NOT_FOUND;

    NdisInitUnicodeString (& new_device_name, device_name);

    for (i = 0 ; i < CVY_MAX_ADAPTERS; i++)
    {
        if (univ_adapters [i] . used &&
            univ_adapters [i] . bound &&
            univ_adapters [i] . inited &&
            univ_adapters [i] . device_name_len)
        {
            NdisInitUnicodeString (& cur_device_name, univ_adapters [i] . device_name);
            if (NdisEqualUnicodeString (& new_device_name, & cur_device_name, TRUE))
                return i;
        }
    }

    return MAIN_ADAPTER_NOT_FOUND; /* adapter not found */
} /* end Main_adapter_get */


INT Main_adapter_put (
    PMAIN_ADAPTER       adapterp)
{
    INT adapter_id;
    INT i;


    UNIV_ASSERT (adapterp -> code == MAIN_ADAPTER_CODE);

    for (i = 0 ; i < CVY_MAX_ADAPTERS; i++)
    {
        if (adapterp == univ_adapters + i)
        {
            adapter_id = i;
            UNIV_PRINT (("Main_adapter_put: for adapter id 0x%x\n", adapter_id));
            break;
        }
    }

    if (!adapterp -> used)
        return adapter_id;

    UNIV_ASSERT (univ_adapters_count > 0);
    NdisAcquireSpinLock (& univ_bind_lock);

    univ_adapters [adapter_id] . bound           = FALSE;
    univ_adapters [adapter_id] . inited          = FALSE;
    univ_adapters [adapter_id] . announced       = FALSE;
    univ_adapters [adapter_id] . device_name_len = 0;
    univ_adapters [adapter_id] . device_name     = NULL;
    univ_adapters [adapter_id] . ctxtp           = NULL;

    univ_adapters [adapter_id] . used = FALSE;
    univ_adapters_count --;

    NdisReleaseSpinLock (& univ_bind_lock);

    return adapter_id;
} /* end Main_adapter_put*/


INT Main_adapter_selfbind (
    PWSTR               device_name)
{
    INT                 i;
    NDIS_STRING         new_device_name, cur_device_name;


    UNIV_PRINT (("Main_adapter_selfbind: %ls", device_name));
    if (device_name == NULL)
        return MAIN_ADAPTER_NOT_FOUND;

    NdisInitUnicodeString (& new_device_name, device_name);
    for (i = 0 ; i < CVY_MAX_ADAPTERS; i++)
    {
        if (univ_adapters [i] . used &&
            univ_adapters [i] . bound &&
            univ_adapters [i] . inited)
        {
            NdisInitUnicodeString (& cur_device_name, univ_adapters [i] . ctxtp -> virtual_nic_name);
            UNIV_PRINT (("Main_adapter_selfbind: comparing %ls %ls",
                         new_device_name . Buffer,
                         cur_device_name . Buffer));
            if (NdisEqualUnicodeString (&new_device_name, &cur_device_name, TRUE))
                return i;
        }
    }

    return MAIN_ADAPTER_NOT_FOUND;
} /* end Main_adapter_selfbind */

//+----------------------------------------------------------------------------
//
// Function:  Main_ApplyChangeWithoutReStart
//
// Description:  Apply setting changes without re-start.
//              ctxtp -> load_lock should be hold before calling this function
//
// Arguments: PMAIN_CTXT ctxtp -
//            CVY_PARAMS* pOldParams - the old parameters
//            const CVY_PARAMS* pCurParam - new parameters
//
// Returns:   BOOLEAN  - TRUE if the change is applied without re-start
//                       otherwise, no changes is applied
//
// History:   fengsun Created Header    9/28/00
//
//+----------------------------------------------------------------------------
BOOLEAN Main_ApplyChangeWithoutReStart(PMAIN_CTXT ctxtp,
                                       CVY_PARAMS* pOldParams, 
                                       const CVY_PARAMS* pCurParam) 
{
    CVY_RULE    OldRules[CVY_MAX_RULES - 1];
    ULONG i;

    if (pOldParams->num_rules != pCurParam->num_rules)
    {
        //
        // Different number of rules
        //
        return FALSE;
    }

    UNIV_ASSERT(sizeof(OldRules) == sizeof(pOldParams->port_rules));

    //
    // Save the old rules and copy the new rule weight over old settings
    //
    RtlCopyMemory(&OldRules, pOldParams->port_rules, sizeof(OldRules));

    for (i=0; i<pCurParam->num_rules; i++)
    {
        if (pCurParam->port_rules[i].mode == CVY_MULTI)
        {
            pOldParams->port_rules[i].mode_data.multi.equal_load = 
                                    pCurParam->port_rules[i].mode_data.multi.equal_load;

            pOldParams->port_rules[i].mode_data.multi.load = 
                                    pCurParam->port_rules[i].mode_data.multi.load;
        }
    }

    if(RtlCompareMemory(pOldParams, pCurParam, sizeof(CVY_PARAMS)) != sizeof(CVY_PARAMS))
    {
        //
        // There are other changes besides port rule weight
        //
        return FALSE;
    }



    //
    //  The only change is the weight.  Now change the weight
    //
    for (i=0; i<pCurParam->num_rules; i++)
    {
        ULONG NewWeight;

        switch (OldRules[i].mode)
        {
        case CVY_MULTI:
            if (OldRules[i].mode_data.multi.equal_load && pCurParam->port_rules[i].mode_data.multi.equal_load)
            {
                continue;  // no weight change
            }

            if (!OldRules[i].mode_data.multi.equal_load && 
                !pCurParam->port_rules[i].mode_data.multi.equal_load &&
                OldRules[i].mode_data.multi.load == pCurParam->port_rules[i].mode_data.multi.load)
            {
                continue; // no weight change
            }

            if (pCurParam->port_rules[i].mode_data.multi.equal_load)
            {
                NewWeight = CVY_EQUAL_LOAD;
            }
            else
            {
                NewWeight = pCurParam->port_rules[i].mode_data.multi.load;
            }

            //
            // Change the weight of the port.  Return code ignored
            //

            UNIV_PRINT(("RELOAD: Calling Load_port_change -> VIP=%08x, port=%d, load=%d\n", 
                        OldRules[i].virtual_ip_addr, OldRules[i].start_port, NewWeight));
                       
            Load_port_change (& ctxtp -> load,
                                 OldRules[i].virtual_ip_addr,
                                 OldRules[i].start_port,
                                 IOCTL_CVY_PORT_SET,
                                 NewWeight);

            break;

        case CVY_SINGLE:
        case CVY_NEVER:
        default:
            break;
        }
    }

    LOG_MSG(MSG_INFO_CONFIGURE_CHANGE_CONVERGING, MSG_NONE);

    return TRUE;
}

#if defined (SBH)
//+----------------------------------------------------------------------------
//
// Function:  Main_QueryPerf
//
// Description:  Query the perfomrance related state from the driver
//
// Arguments: MAIN_CTXT  ctxtp - 
//            PCVY_DRIVER_PERF  pPerf - 
//
// Returns:   NDIS_STATUS - 
//
// History:   fengsun Created Header    11/13/00
//
//+----------------------------------------------------------------------------
NDIS_STATUS Main_QueryPerf(
    PMAIN_CTXT              ctxtp,
    OUT PCVY_DRIVER_PERF          pPerf)
{
    ULONG i;
    ULONG Status;
    
    //
    // Call WlbsQuery
    //
    IOCTL_CVY_BUF QueryBuf;

    /* This IOCTL will actually ignore the VIP argument, but set it to a reasonable value anyway. */
    Status = Main_ctrl(ctxtp, IOCTL_CVY_QUERY, &QueryBuf, NULL);

    if (Status != NDIS_STATUS_SUCCESS)
    {
        return Status;
    }

    pPerf->QueryState = QueryBuf.data.query.state;
    pPerf->HostId = QueryBuf.data.query.host_id;
    pPerf->HostMap = QueryBuf.data.query.host_map;

    NdisAcquireSpinLock(&ctxtp -> load_lock);

    //
    // Ethernet header
    //
    UNIV_ASSERT(sizeof(pPerf->EthernetDstAddr) == ETHERNET_ADDRESS_FIELD_SIZE);
    UNIV_ASSERT(sizeof(pPerf->EthernetSrcAddr) == ETHERNET_ADDRESS_FIELD_SIZE);
    RtlCopyMemory (&pPerf->EthernetDstAddr, &ctxtp->media_hdr.ethernet.dst,
                    sizeof(pPerf->EthernetDstAddr));
    RtlCopyMemory (&pPerf->EthernetSrcAddr, &ctxtp->media_hdr.ethernet.src, 
                    sizeof(pPerf->EthernetSrcAddr));

    //
    // Heatbeart
    //
    pPerf->HeartbeatVersion = ctxtp->frame_dscrp->frame_hdr.version;   
    pPerf->ClusterIp = ctxtp->frame_dscrp->frame_hdr.cl_ip_addr;
    pPerf->DedicatedIp = ctxtp->frame_dscrp->frame_hdr.ded_ip_addr;
    pPerf->master_id = ctxtp->load_msgp->master_id;
    pPerf->state = ctxtp->load_msgp->state;                      
    pPerf->nrules = ctxtp->load_msgp->nrules;                     
    pPerf->UniqueCode = ctxtp->load_msgp->hcode;                      
    pPerf->pkt_count = ctxtp->load_msgp->pkt_count;                  
    pPerf->teaming = ctxtp->load_msgp->teaming;
    pPerf->reserved2 = ctxtp->load_msgp->reserved2;

    UNIV_ASSERT(sizeof(pPerf->rcode) == sizeof(ctxtp->load_msgp->rcode));
    RtlCopyMemory(pPerf->rcode, ctxtp->load_msgp->rcode, sizeof(pPerf->rcode));

    UNIV_ASSERT(sizeof(pPerf->cur_map) == sizeof(ctxtp->load_msgp->cur_map));
    RtlCopyMemory(pPerf->cur_map, ctxtp->load_msgp->cur_map, sizeof(pPerf->cur_map));

    UNIV_ASSERT(sizeof(pPerf->new_map) == sizeof(ctxtp->load_msgp->new_map));
    RtlCopyMemory(pPerf->new_map, ctxtp->load_msgp->new_map, sizeof(pPerf->new_map));

    UNIV_ASSERT(sizeof(pPerf->idle_map) == sizeof(ctxtp->load_msgp->idle_map));
    RtlCopyMemory(pPerf->idle_map, ctxtp->load_msgp->idle_map, sizeof(pPerf->idle_map));

    UNIV_ASSERT(sizeof(pPerf->rdy_bins) == sizeof(ctxtp->load_msgp->rdy_bins));
    RtlCopyMemory(pPerf->rdy_bins, ctxtp->load_msgp->rdy_bins, sizeof(pPerf->rdy_bins));

    UNIV_ASSERT(sizeof(pPerf->load_amt) == sizeof(ctxtp->load_msgp->load_amt));
    RtlCopyMemory(pPerf->load_amt, ctxtp->load_msgp->load_amt, sizeof(pPerf->load_amt));

    UNIV_ASSERT(sizeof(pPerf->pg_rsvd1) == sizeof(ctxtp->load_msgp->pg_rsvd1));
    RtlCopyMemory(pPerf->pg_rsvd1, ctxtp->load_msgp->pg_rsvd1, sizeof(pPerf->pg_rsvd1));
    
    //
    // Load module
    //
    pPerf->Convergence = 0;
    pPerf->nDescAllocated = ctxtp->load.nqalloc * ctxtp->load.dscr_per_alloc+
        CVY_MAX_CHASH+CVY_INIT_QCONN;
    pPerf->nDescInUse = ctxtp->load.nconn;
    pPerf->PacketCount = ctxtp->load.pkt_count;
    pPerf->DirtyClientWaiting = ctxtp->load.cln_waiting;

    UNIV_ASSERT(sizeof(pPerf->CurrentMap[i]) == 
            sizeof(ctxtp->load.pg_state[0].cur_map));
            
    for (i=0; i<ctxtp->load_msgp->nrules; i++)
    {
        pPerf->AllIdleMap[i] = ctxtp->load.pg_state[i].all_idle_map;
        RtlCopyMemory(pPerf->CurrentMap[i], ctxtp->load.pg_state[i].cur_map,
            sizeof(pPerf->CurrentMap[i]));
    }

    NdisReleaseSpinLock (&ctxtp -> load_lock);   

    return NDIS_STATUS_SUCCESS;
}
#endif /* SBH */