vipl_priv_conn_recv.c

Go to the documentation of this file.

/********************************************************
 * Myricom VI-GM  networking software and documentation *
 * Copyright (c) 2001 by Myricom, Inc.                  *
 * All rights reserved.                                 *
 * See the file `COPYING' for copyright notice.         *
 ********************************************************/

#include <string.h>

#include "vipl_priv.h"

static void
vip_send_conn_request (VIP_CONN * vip_conn_ptr, VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_PACKET_CONN_REQ *pkt_ptr;
  VIP_DEBUG_LABEL (("vip_send_conn_request"));

  vip_vi_ptr = vip_conn_ptr->vip_vi_ptr;
  if (VIP_INVALID_VI_HANDLE (vip_vi_ptr))
    {
      VIP_DEBUG (("Invalid VI handle"));
      return;
    }

  if ((vip_conn_ptr->type == VIP_CONN_TYPE_PEER) 
      && (vip_conn_ptr->waiting_list == VIP_FALSE))
    {
      return;
    }

  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_CONN_REQ));
  VIP_ASSERT (vip_send_req_ptr != NULL);

  /* fill the packet and send it */
  pkt_ptr = (VIP_PACKET_CONN_REQ *) (vip_send_req_ptr->ptr);
  if (vip_conn_ptr->type == VIP_CONN_TYPE_PEER)
    {
      pkt_ptr->type = VIP_HTON_UCHAR (VIP_CONN_PEER_REQ_PKT);
    }
  else
    {
      pkt_ptr->type = VIP_HTON_UCHAR (VIP_CONN_REQ_PKT);
    }
  pkt_ptr->clt_seq_num = VIP_HTON_UINT16 (vip_conn_ptr->handle.seq_num);
  pkt_ptr->clt_conn_ptr = VIP_HTON_UINT64 (vip_addr2addrbits (vip_conn_ptr));
  pkt_ptr->srv_net_magic =
    vip_conn_ptr->net_srv_magic[vip_conn_ptr->remote_port_id];

  pkt_ptr->qos = VIP_HTON_UINT64 (vip_addr2addrbits (vip_vi_ptr->qos));
  pkt_ptr->mtu = VIP_HTON_UINT32 (vip_vi_ptr->mtu);
  pkt_ptr->reliability = VIP_HTON_UINT16 (vip_vi_ptr->reliability);
  pkt_ptr->rdma_write = VIP_HTON_UCHAR (vip_vi_ptr->rdma_write);

  pkt_ptr->clt_disc_len = VIP_HTON_UINT16 (vip_conn_ptr->locale_disc_len);
  memcpy (pkt_ptr->clt_net_addr, vip_conn_ptr->locale_net_addr,
          VI_GM_MAC_ADDRESS_LEN + vip_conn_ptr->locale_disc_len);
  pkt_ptr->srv_disc_len = VIP_HTON_UINT16 (vip_conn_ptr->remote_disc_len);
  memcpy (pkt_ptr->srv_net_addr, vip_conn_ptr->remote_net_addr,
          VI_GM_MAC_ADDRESS_LEN + vip_conn_ptr->remote_disc_len);

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = vip_conn_ptr->remote_port_id;
  vip_send_req_ptr->dest_gm_id = vip_conn_ptr->remote_gm_id;
  vip_send_req_ptr->vip_nic_ptr = vip_conn_ptr->handle.vip_nic_ptr;
  vip_send_req_ptr->vip_vi_ptr = vip_vi_ptr;
  vip_send_data (vip_send_req_ptr);
}

void
vip_handle_conn_list (VIP_PACKET_CONN_LIST * ptr, VIP_GM * vip_gm_ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_UCHAR srv_port_id;
  VIP_NET_UINT32 srv_net_magic;
  VIP_DEBUG_LABEL (("vip_handle_conn_list"));

  /* check conn handle ptr */
  vip_conn_ptr = 
    (VIP_CONN *) vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->clt_conn_ptr));
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in CONN_LIST message"));
      return;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* check conn handle sequence number */
  if (VIP_NTOH_UINT16 (ptr->clt_seq_num) != vip_conn_ptr->handle.seq_num)
    {
      VIP_DEBUG (("Invalid CONN seq number in CONN_LIST message"));
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      return;
    }
  VIP_ASSERT ((vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT)
              || (vip_conn_ptr->type == VIP_CONN_TYPE_PEER));

  memcpy (vip_conn_ptr->net_srv_magic, ptr->net_srv_magic,
          VI_GM_MAX_PORTS * sizeof (VIP_NET_UINT32));

  /* look for the first possible endpoint */
  srv_port_id = vip_conn_ptr->remote_port_id;
  srv_net_magic = VIP_HTON_UINT32 (0);
  while (srv_port_id < VI_GM_MAX_PORTS)
    {
      if (VIP_NTOH_UINT32 (ptr->net_srv_magic[srv_port_id]) != 0)
        {
          srv_net_magic = ptr->net_srv_magic[srv_port_id];
          break;
        }
      srv_port_id++;
    }

  if (VIP_NTOH_UINT32 (srv_net_magic) == 0)
    {
      if (vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT)
        {
          /* no luck, return NO_MATCH */
          vip_conn_ptr->status = VIP_NO_MATCH;
          VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
        }
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      VIP_DEBUG (("No match"));
      return;
    }

  /* we got a winner, send a connection request */
  vip_conn_ptr->remote_port_id = srv_port_id;
  vip_send_conn_request (vip_conn_ptr, vip_gm_ptr);

  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Connection request sent to first endpoint"));
}

void
vip_handle_conn_req (VIP_PACKET_CONN_REQ * ptr,
                     gm_recv_event_t * gm_event, 
                     VIP_GM * vip_gm_ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_CONN *vip_tmp_conn_ptr;
  VIP_RETURN peer_status;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_PACKET *pkt_ptr;
  VIP_DEBUG_LABEL (("vip_handle_conn_req"));

  /* check magic number */
  if (VIP_NTOH_UINT32 (ptr->srv_net_magic) != vip_gm_ptr->magic)
    {
      goto send_nomatch;
    }

  /* search for matching connection */
  vip_conn_ptr = vip_gm_ptr->head_waiting_conn_ptr;
  while (vip_conn_ptr != NULL)
    {
      VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      VIP_ASSERT (vip_conn_ptr->waiting_list == VIP_TRUE);

      /* process a client/server connection request or a peer request */
      if (VIP_NTOH_UCHAR (ptr->type) == VIP_CONN_REQ_PKT)
        {
          /* client/server model */
          if ((vip_conn_ptr->type == VIP_CONN_TYPE_SERVER)
              && (vip_conn_ptr->status == VIP_NOT_DONE)
              && (VIP_NTOH_UINT16 (ptr->srv_disc_len)
                  == vip_conn_ptr->locale_disc_len)
              && (memcmp (ptr->srv_net_addr,
                          vip_conn_ptr->locale_net_addr,
                          VI_GM_MAC_ADDRESS_LEN
                          + vip_conn_ptr->locale_disc_len) == 0))
            {
              vip_conn_ptr->net_remote_seq_num = ptr->clt_seq_num;
              vip_conn_ptr->net_remote_conn_ptr = ptr->clt_conn_ptr;
              vip_conn_ptr->remote_vi_attribs.ReliabilityLevel =
                VIP_NTOH_UINT16 (ptr->reliability);
              vip_conn_ptr->remote_vi_attribs.MaxTransferSize =
                VIP_NTOH_UINT32 (ptr->mtu);
              vip_conn_ptr->remote_vi_attribs.QoS =
                vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->qos));
              vip_conn_ptr->remote_vi_attribs.EnableRdmaWrite =
                VIP_NTOH_UCHAR (ptr->rdma_write);
              vip_conn_ptr->remote_vi_attribs.EnableRdmaRead = VIP_FALSE;
              vip_conn_ptr->remote_disc_len =
                VIP_NTOH_UINT16 (ptr->clt_disc_len);
              memcpy (vip_conn_ptr->remote_net_addr, ptr->clt_net_addr,
                      VI_GM_MAC_ADDRESS_LEN + vip_conn_ptr->remote_disc_len);
              vip_conn_ptr->remote_gm_id =
                gm_ntohs (gm_event->recv.sender_node_id);
              vip_conn_ptr->remote_port_id =
                gm_ntohc (gm_event->recv.sender_port_id);

              /* remove the connection from the waiting list */
              vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);

              vip_conn_ptr->status = VIP_SUCCESS;
              VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
              VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
              VIP_DEBUG (("Success (client/server model)"));
              return;
            }
        }
      else
        {
          /* handling connection peer request */
          VIP_ASSERT (VIP_NTOH_UCHAR (ptr->type) == VIP_CONN_PEER_REQ_PKT);

          if ((vip_conn_ptr->type == VIP_CONN_TYPE_PEER)
              && (vip_conn_ptr->status == VIP_NOT_DONE)
              && ((vip_conn_ptr->handle.vip_nic_ptr->vip_gm_ptr->gm_port_id
                   != gm_ntohc (gm_event->recv.sender_port_id))
                  || (vip_conn_ptr->handle.vip_nic_ptr->vip_gm_ptr->gm_id
                      != gm_ntohs (gm_event->recv.sender_node_id))
                  || (VIP_NTOH_UINT16 (ptr->clt_seq_num)
                      != vip_conn_ptr->handle.seq_num)
                  || (vip_conn_ptr != (VIP_CONN *)
                      vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->clt_conn_ptr))))
              && (VIP_NTOH_UINT16 (ptr->srv_disc_len)
                  == vip_conn_ptr->locale_disc_len)
              && (memcmp (ptr->clt_net_addr, vip_conn_ptr->remote_net_addr,
                          VI_GM_MAC_ADDRESS_LEN) == 0)
              && (memcmp (ptr->srv_net_addr, vip_conn_ptr->locale_net_addr,
                          VI_GM_MAC_ADDRESS_LEN) == 0)
              && (memcmp (&(ptr->srv_net_addr[VI_GM_MAC_ADDRESS_LEN]),
                          &(vip_conn_ptr->remote_net_addr
                            [VI_GM_MAC_ADDRESS_LEN]),
                          vip_conn_ptr->locale_disc_len) == 0))
            {
              /* check the peer conn request matches vi attributes */
              if (vip_conn_ptr->remote_vi_attribs.ReliabilityLevel
                  != VIP_NTOH_UINT16 (ptr->reliability))
                {
                  peer_status = VIP_INVALID_RELIABILITY_LEVEL;
                  goto peer_reject;
                }

              if (vip_conn_ptr->remote_vi_attribs.MaxTransferSize
                  != VIP_NTOH_UINT32 (ptr->mtu))
                {
                  peer_status = VIP_INVALID_MTU;
                  goto peer_reject;
                }

              if (vip_conn_ptr->remote_vi_attribs.QoS
                  != vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->qos)))
                {
                  peer_status = VIP_INVALID_MTU;
                  goto peer_reject;
                }

              vip_conn_ptr->remote_vi_attribs.EnableRdmaWrite =
                VIP_NTOH_UCHAR (ptr->rdma_write);
              vip_conn_ptr->remote_gm_id =
                gm_ntohs (gm_event->recv.sender_node_id);
              vip_conn_ptr->remote_port_id =
                gm_ntohc (gm_event->recv.sender_port_id);

              gm_cancel_alarm (&(vip_conn_ptr->peer_timeout_alarm));
              vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);

              /* send a conn peer accept message */
              vip_send_req_ptr =
                vip_allocate_packet (vip_gm_ptr,
                                     sizeof (VIP_PACKET_CONN_ACCEPT));
              VIP_ASSERT (vip_send_req_ptr != NULL);

              pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
              pkt_ptr->vip_pkt_conn_accept.type =
                VIP_HTON_UCHAR (VIP_CONN_PEER_ACCEPT_PKT);
              pkt_ptr->vip_pkt_conn_accept.rdma_write =
                VIP_HTON_UCHAR (vip_conn_ptr->vip_vi_ptr->rdma_write);
              pkt_ptr->vip_pkt_conn_accept.clt_conn_ptr = ptr->clt_conn_ptr;
              pkt_ptr->vip_pkt_conn_accept.clt_seq_num = ptr->clt_seq_num;
              pkt_ptr->vip_pkt_conn_accept.srv_seq_num =
                VIP_HTON_UINT16 (vip_conn_ptr->handle.seq_num);
              pkt_ptr->vip_pkt_conn_accept.srv_conn_ptr =
                VIP_HTON_UINT64 (vip_addr2addrbits (vip_conn_ptr));
              pkt_ptr->vip_pkt_conn_accept.net_local_nic_index =
                VIP_HTON_UINT16 
                (vip_conn_ptr->vip_vi_ptr->handle.vip_nic_ptr->index);
              pkt_ptr->vip_pkt_conn_accept.net_local_vi_index =
                VIP_HTON_UINT16 (vip_conn_ptr->vip_vi_ptr->index);

              vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
              vip_send_req_ptr->dest_port_id = vip_conn_ptr->remote_port_id;
              vip_send_req_ptr->dest_gm_id = vip_conn_ptr->remote_gm_id;
              vip_send_req_ptr->vip_nic_ptr =
                vip_conn_ptr->handle.vip_nic_ptr;
              vip_send_req_ptr->vip_vi_ptr = vip_conn_ptr->vip_vi_ptr;
              vip_send_data (vip_send_req_ptr);

              VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
              VIP_DEBUG (("Success (peer model)"));
              return;
            }
        }

      VIP_ASSERT ((vip_conn_ptr->next_waiting_conn_ptr != NULL)
                  || (vip_conn_ptr == vip_gm_ptr->tail_waiting_conn_ptr));
      vip_tmp_conn_ptr = vip_conn_ptr->next_waiting_conn_ptr;
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      vip_conn_ptr = vip_tmp_conn_ptr;
    }

 send_nomatch:
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_CONN_NOMATCH));
  VIP_ASSERT (vip_send_req_ptr != NULL);

  /* fill the packet and send it */
  pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
  pkt_ptr->vip_pkt_conn_nomatch.type = VIP_HTON_UCHAR (VIP_CONN_NOMATCH_PKT);
  pkt_ptr->vip_pkt_conn_nomatch.clt_seq_num = ptr->clt_seq_num;
  pkt_ptr->vip_pkt_conn_nomatch.clt_conn_ptr = ptr->clt_conn_ptr;

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = gm_ntohc (gm_event->recv.sender_port_id);
  vip_send_req_ptr->dest_gm_id = gm_ntohs (gm_event->recv.sender_node_id);
  vip_send_data (vip_send_req_ptr);

  VIP_DEBUG (("No match (client/server model)"));
  return;

 peer_reject:
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_CONN_REJECT));
  VIP_ASSERT (vip_send_req_ptr != NULL);

  /* fill the packet and send it */
  pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
  pkt_ptr->vip_pkt_conn_reject.type =
    VIP_HTON_UCHAR (VIP_CONN_PEER_REJECT_PKT);
  pkt_ptr->vip_pkt_conn_reject.peer_status = VIP_HTON_UCHAR (peer_status);
  pkt_ptr->vip_pkt_conn_reject.clt_seq_num = ptr->clt_seq_num;
  pkt_ptr->vip_pkt_conn_reject.clt_conn_ptr = ptr->clt_conn_ptr;

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = gm_ntohc (gm_event->recv.sender_port_id);
  vip_send_req_ptr->dest_gm_id = gm_ntohs (gm_event->recv.sender_node_id);
  vip_send_req_ptr->vip_nic_ptr = vip_conn_ptr->handle.vip_nic_ptr;
  vip_send_req_ptr->vip_vi_ptr = vip_conn_ptr->vip_vi_ptr;
  vip_send_data (vip_send_req_ptr);

  gm_cancel_alarm (&(vip_conn_ptr->peer_timeout_alarm));
  vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);
  vip_conn_ptr->status = peer_status;
  VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Conn Peer request rejected"));
}

void
vip_handle_conn_nomatch (VIP_PACKET_CONN_NOMATCH * ptr, VIP_GM * vip_gm_ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_UCHAR srv_port_id;
  VIP_NET_UINT32 srv_net_magic;
  VIP_DEBUG_LABEL (("vip_handle_conn_nomatch"));

  /* check conn handle ptr */
  vip_conn_ptr = 
    (VIP_CONN *) vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->clt_conn_ptr));
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in CONN_NOMATCH message"));
      return;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* check conn handle sequence number */
  if (VIP_NTOH_UINT16 (ptr->clt_seq_num) != vip_conn_ptr->handle.seq_num)
    {
      VIP_DEBUG (("Invalid CONN seq number in CONN_NOMATCH message"));
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      return;
    }
  VIP_ASSERT ((vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT)
              || (vip_conn_ptr->type == VIP_CONN_TYPE_PEER));

  /* look for the next possible endpoint */
  srv_port_id = vip_conn_ptr->remote_port_id + 1;
  srv_net_magic = VIP_HTON_UINT32 (0);
  while (srv_port_id < VI_GM_MAX_PORTS)
    {
      if (VIP_NTOH_UINT32 (vip_conn_ptr->net_srv_magic[srv_port_id]) != 0)
        {
          srv_net_magic = vip_conn_ptr->net_srv_magic[srv_port_id];
          break;
        }
      srv_port_id++;
    }

  if (VIP_NTOH_UINT32 (srv_net_magic) == 0)
    {
      /* no luck, return NO_MATCH */
      if (vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT)
        {
          vip_conn_ptr->status = VIP_NO_MATCH;
          VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
        }
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      VIP_DEBUG (("No match"));
      return;
    }

  /* we got another winner, send a connection request */
  vip_conn_ptr->remote_port_id = srv_port_id;
  vip_send_conn_request (vip_conn_ptr, vip_gm_ptr);
  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Connection request sent to next endpoint"));
}

void
vip_handle_conn_accept (VIP_PACKET_CONN_ACCEPT * ptr, 
                        gm_recv_event_t * gm_event, 
                        VIP_GM * vip_gm_ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_PACKET_CONN_ACK *pkt_ack_ptr;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_DEBUG_LABEL (("vip_handle_conn_accept"));

  /* check conn handle ptr */
  vip_conn_ptr = 
    (VIP_CONN *) vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->clt_conn_ptr));
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in CONN_ACCEPT message"));
      goto sending_nack;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* check conn handle sequence number */
  if (VIP_NTOH_UINT16 (ptr->clt_seq_num) != vip_conn_ptr->handle.seq_num)
    {
      VIP_DEBUG (("Invalid CONN seq number in CONN_ACCEPT message"));
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      goto sending_nack;
    }

  vip_conn_ptr->net_remote_conn_ptr = ptr->srv_conn_ptr;
  vip_conn_ptr->net_remote_seq_num = ptr->srv_seq_num;
  vip_conn_ptr->remote_vi_attribs.EnableRdmaWrite =
    VIP_NTOH_UCHAR (ptr->rdma_write);

  /* connection established */
  vip_conn_ptr->vip_vi_ptr->net_remote_nic_index = ptr->net_local_nic_index;
  vip_conn_ptr->vip_vi_ptr->net_remote_vi_index = ptr->net_local_vi_index;
  vip_conn_ptr->vip_vi_ptr->gm_dest_id = vip_conn_ptr->remote_gm_id;
  vip_conn_ptr->vip_vi_ptr->gm_dest_port = vip_conn_ptr->remote_port_id;

  VIP_ASSERT ((vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT)
              || (vip_conn_ptr->type == VIP_CONN_TYPE_PEER));

  if (vip_conn_ptr->type == VIP_CONN_TYPE_PEER)
    {
      vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                              sizeof (VIP_PACKET_CONN_ACK));
      VIP_ASSERT (vip_send_req_ptr != NULL);
      pkt_ack_ptr = (VIP_PACKET_CONN_ACK *) (vip_send_req_ptr->ptr);
      pkt_ack_ptr->type = VIP_HTON_UCHAR (VIP_CONN_ACK_PKT);
      pkt_ack_ptr->status = VIP_HTON_UCHAR (VIP_SUCCESS);
      pkt_ack_ptr->srv_seq_num = ptr->srv_seq_num;
      pkt_ack_ptr->net_local_nic_index =
        VIP_HTON_UINT16 (vip_conn_ptr->vip_vi_ptr->handle.vip_nic_ptr->index);
      pkt_ack_ptr->net_local_vi_index = 
        VIP_HTON_UINT16 (vip_conn_ptr->vip_vi_ptr->index);
      pkt_ack_ptr->srv_conn_ptr = ptr->srv_conn_ptr;

      vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
      vip_send_req_ptr->dest_port_id = vip_conn_ptr->remote_port_id;
      vip_send_req_ptr->dest_gm_id = vip_conn_ptr->remote_gm_id;
      vip_send_req_ptr->vip_nic_ptr = vip_conn_ptr->handle.vip_nic_ptr;
      vip_send_req_ptr->vip_vi_ptr = vip_conn_ptr->vip_vi_ptr;
      vip_send_data (vip_send_req_ptr);

      if (vip_conn_ptr->waiting_list == VIP_TRUE)
        {
          gm_cancel_alarm (&(vip_conn_ptr->peer_timeout_alarm));
          vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);
        }
    }
  else
    {
      vip_conn_ptr->vip_vi_ptr->state = VIP_STATE_CONNECTED;
    }

  vip_conn_ptr->status = VIP_SUCCESS;
  VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Success"));
  return;

 sending_nack:
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_CONN_ACK));
  VIP_ASSERT (vip_send_req_ptr != NULL);
  pkt_ack_ptr = (VIP_PACKET_CONN_ACK *) (vip_send_req_ptr->ptr);
  pkt_ack_ptr->type = VIP_HTON_UCHAR (VIP_CONN_ACK_PKT);
  pkt_ack_ptr->status = VIP_HTON_UCHAR (VIP_TIMEOUT);
  pkt_ack_ptr->srv_seq_num = ptr->srv_seq_num;
  pkt_ack_ptr->srv_conn_ptr = ptr->srv_conn_ptr;

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = gm_ntohc (gm_event->recv.sender_port_id);
  vip_send_req_ptr->dest_gm_id = gm_ntohs (gm_event->recv.sender_node_id);
  vip_send_data (vip_send_req_ptr);

  VIP_DEBUG (("CONN nACK sent back to server"));
  return;
}

void
vip_handle_conn_reject (VIP_PACKET_CONN_REJECT * ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_DEBUG_LABEL (("vip_handle_conn_reject"));

  /* check conn handle ptr */
  vip_conn_ptr = 
    (VIP_CONN *) vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->clt_conn_ptr));
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in CONN_REJECT message"));
      return;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* check conn handle sequence number */
  if (VIP_NTOH_UINT16 (ptr->clt_seq_num) != vip_conn_ptr->handle.seq_num)
    {
      VIP_DEBUG (("Invalid CONN seq number in CONN_REJECT message"));
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      return;
    }

  if (VIP_NTOH_UCHAR (ptr->type) == VIP_CONN_REJECT_PKT)
    {
      VIP_ASSERT (vip_conn_ptr->type == VIP_CONN_TYPE_CLIENT);
      vip_conn_ptr->status = VIP_REJECT;
    }
  else
    {
      VIP_ASSERT (VIP_NTOH_UCHAR (ptr->type) == VIP_CONN_PEER_REJECT_PKT);
      VIP_ASSERT (vip_conn_ptr->type == VIP_CONN_TYPE_PEER);
      if (vip_conn_ptr->waiting_list == VIP_TRUE)
        {
          gm_cancel_alarm (&(vip_conn_ptr->peer_timeout_alarm));
          vip_remove_conn_waiting_list
            (vip_conn_ptr->handle.vip_nic_ptr->vip_gm_ptr, vip_conn_ptr);
        }
      vip_conn_ptr->status = VIP_NTOH_UCHAR (ptr->peer_status);
    }

  VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Success"));
}

void
vip_handle_conn_ack (VIP_PACKET_CONN_ACK * ptr)
{
  VIP_CONN *vip_conn_ptr;
  VIP_DEBUG_LABEL (("vip_handle_conn_ack"));

  /* check conn handle ptr */
  vip_conn_ptr = 
    (VIP_CONN *) vip_addrbits2addr (VIP_NTOH_UINT64 (ptr->srv_conn_ptr));
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in CONN_ACK message"));
      return;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* check conn handle sequence number */
  if (VIP_NTOH_UINT16 (ptr->srv_seq_num) != vip_conn_ptr->handle.seq_num)
    {
      VIP_DEBUG (("Invalid CONN seq number in CONN_ACK message"));
      VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
      return;
    }

  VIP_ASSERT ((vip_conn_ptr->type == VIP_CONN_TYPE_SERVER)
              || (vip_conn_ptr->type == VIP_CONN_TYPE_PEER));
  vip_conn_ptr->status = VIP_NTOH_UCHAR (ptr->status);

  if (vip_conn_ptr->status == VIP_SUCCESS)
    {
      /* connection established */
      vip_conn_ptr->vip_vi_ptr->net_remote_nic_index = 
        ptr->net_local_nic_index;
      vip_conn_ptr->vip_vi_ptr->net_remote_vi_index = ptr->net_local_vi_index;
      vip_conn_ptr->vip_vi_ptr->gm_dest_id = vip_conn_ptr->remote_gm_id;
      vip_conn_ptr->vip_vi_ptr->gm_dest_port = vip_conn_ptr->remote_port_id;
    }

  if (vip_conn_ptr->type == VIP_CONN_TYPE_SERVER)
    {
      vip_conn_ptr->vip_vi_ptr->state = VIP_STATE_CONNECTED;
    }

  VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Success"));
}