Exemple #1
0
/* TCP connection open.  Next we send open message to remote peer. And
   add read thread for reading open message. */
static int
bgp_connect_success (struct peer *peer)
{
  char buf1[BUFSIZ];

  if (peer->fd < 0)
    {
      zlog_err ("bgp_connect_success peer's fd is negative value %d",
		peer->fd);
      return -1;
    }
  BGP_READ_ON (peer->t_read, bgp_read, peer->fd);

  if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
    bgp_getsockname (peer);

  if (BGP_DEBUG (normal, NORMAL))
    {
      if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
	zlog_debug ("%s open active, local address %s", peer->host,
		    sockunion2str (peer->su_local, buf1, SU_ADDRSTRLEN));
      else
	zlog_debug ("%s passive open", peer->host);
    }

  if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
    bgp_open_send (peer);

  return 0;
}
Exemple #2
0
/* This function is the first starting point of all BGP connection. It
   try to connect to remote peer with non-blocking IO. */
int
bgp_start (struct peer *peer)
{
  int status;

  /* If the peer is passive mode, force to move to Active mode. */
  if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE))
    {
      BGP_EVENT_ADD (peer, TCP_connection_open_failed);
      return 0;
    }

  status = bgp_connect (peer);

  switch (status)
    {
    case connect_error:
      if (BGP_DEBUG (fsm, FSM))
	plog_info (peer->log, "%s [FSM] Connect error", peer->host);
      BGP_EVENT_ADD (peer, TCP_connection_open_failed);
      break;
    case connect_success:
      if (BGP_DEBUG (fsm, FSM))
	plog_info (peer->log, "%s [FSM] Connect immediately success",
		   peer->host);
      BGP_EVENT_ADD (peer, TCP_connection_open);
      break;
    case connect_in_progress:
      /* To check nonblocking connect, we wait until socket is
         readable or writable. */
      if (BGP_DEBUG (fsm, FSM))
	plog_info (peer->log, "%s [FSM] Non blocking connect waiting result",
		   peer->host);
      if (peer->fd < 0)
	{
	  zlog_err ("bgp_start peer's fd is negative value %d",
		    peer->fd);
	  return -1;
	}
      BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
      BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
      break;
    }
  return 0;
}
Exemple #3
0
/* TCP connection open.  Next we send open message to remote peer. And
   add read thread for reading open message. */
int
bgp_connect_success (struct peer *peer)
{
  if (peer->fd < 0)
    {
      zlog_err ("bgp_connect_success peer's fd is negative value %d",
		peer->fd);
      return -1;
    }
  BGP_READ_ON (peer->t_read, bgp_read, peer->fd);

  /* bgp_getsockname (peer); */

  if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
    bgp_open_send (peer);

  return 0;
}
Exemple #4
0
    /* Add thread to Listen Thread List */
    tmp_lnode = XCALLOC (MTYPE_TMP,
                         sizeof (struct bgp_listen_sock_lnode));
    if (! tmp_lnode)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock:"
                  " Cannot allocate memory (%d) @ %s:%d",
                  sizeof (struct bgp_peer_inconn_req), __FILE__, __LINE__);

        SSOCK_FD_CLOSE (&BLG, bgp_sock);
        BGP_READ_OFF (&BLG, t_accept);

        continue;
      }

    tmp_lnode->listen_sock = bgp_sock;
    tmp_lnode->t_accept = t_accept;
    if (bgp->listen_sock_lnode)
      tmp_lnode->next = bgp->listen_sock_lnode;
    bgp->listen_sock_lnode = tmp_lnode;

  } 

  pal_sock_freeaddrinfo (ainfo_head);

  return ret;
}
#else /* HAVE_IPV6 && !NRL */
s_int32_t
bpn_sock_listen (struct bgp *bgp, u_int16_t port)
{
  struct bgp_listen_sock_lnode *tmp_lnode;
  struct thread *t_accept;
  union sockunion su;
  s_int32_t bgp_sock;
  fib_id_t fib_id;
  s_int32_t ret;

  pal_mem_set (&su, 0, sizeof (union sockunion));

  t_accept = NULL;
  ret = 0;

  if (! bgp)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: Invalid 'bgp' instance");

      ret = -1;
      goto EXIT;
    }

  fib_id = LIB_VRF_GET_FIB_ID (bgp->owning_ivrf);

  /* Specify address family. */
  su.sa.sa_family = AF_INET;

  bgp_sock = pal_sock (&BLG, su.sa.sa_family, SOCK_STREAM, 0);
  if (bgp_sock < 0)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: socket() Failed, FIB-ID %d, "
                "Err:%d-%s", fib_id, errno, pal_strerror (errno));

      ret = -1;
      goto EXIT;
    }

  pal_sock_set_reuseaddr (bgp_sock, PAL_TRUE);
  pal_sock_set_reuseport (bgp_sock, PAL_TRUE);

  /* Bind socket to FIB. */
  ret = pal_sock_set_bindtofib (bgp_sock, fib_id);
  if (ret < 0)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: bindtofib() Failed, Sock %d"
                ", FIB-ID %d, Err:%d-%s", bgp_sock, fib_id, errno,
                pal_strerror (errno));

      SSOCK_FD_CLOSE (&BLG, bgp_sock);

      /* Ignore platform error */
      ret = 0;
      goto EXIT;
    }

  ret = sockunion_bind (&BLG, bgp_sock, &su, port, NULL);
  if (ret < 0)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: bind() Failed, Err: %d-%s",
                errno, pal_strerror (errno));

      SSOCK_FD_CLOSE (&BLG, bgp_sock);

      /* Ignore platform error */
      ret = 0;
      goto EXIT;
    }

#ifdef HAVE_TCP_MD5SIG
  bgp_md5_set_server (bgp, bgp_sock);
#endif /* TCP_MD5SIG */

  ret = pal_sock_listen (bgp_sock, BGP_SOCK_LISTEN_BACKLOG);
  if (ret < 0)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: listen() Failed, Sock %d, "
                "FIB-ID %d, Err:%d-%s", bgp_sock, fib_id, errno,
                pal_strerror (errno));

      SSOCK_FD_CLOSE (&BLG, bgp_sock);

      /* Ignore platform error */
      ret = 0;
      goto EXIT;
    }

  /* Start a fresh Accept Thread */
  BGP_READ_ON (&BLG, t_accept, bgp, bpn_sock_accept, bgp_sock);

  /* Add thread to Listen Thread List */
  tmp_lnode = XCALLOC (MTYPE_TMP, sizeof (struct bgp_listen_sock_lnode));
  if (! tmp_lnode)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock:"
                " Cannot allocate memory (%d) @ %s:%d",
                sizeof (struct bgp_peer_inconn_req), __FILE__, __LINE__);

      SSOCK_FD_CLOSE (&BLG, bgp_sock);
      BGP_READ_OFF (&BLG, t_accept);

      ret = -1;
      goto EXIT;
    }

  tmp_lnode->listen_sock = bgp_sock;
  tmp_lnode->t_accept = t_accept;
  if (bgp->listen_sock_lnode)
    tmp_lnode->next = bgp->listen_sock_lnode;
  bgp->listen_sock_lnode = tmp_lnode;

 EXIT:

  return ret;
}
Exemple #5
0
s_int32_t
bpn_sock_listen (struct bgp *bgp, u_int16_t port)
{
  struct bgp_listen_sock_lnode *tmp_lnode;
  u_int8_t port_str [SU_ADDRSTRLEN];
  struct pal_addrinfo *ainfo_save[2], *ainfo_head;
  struct pal_addrinfo *ainfo;
  struct pal_sockaddr_in4 ain4;
  struct pal_sockaddr_in6 ain6;
  struct pal_addrinfo req;
  struct thread *t_accept;
  s_int32_t bgp_sock;
  u_int8_t addr_set;
  fib_id_t fib_id;
  s_int32_t ret;	
  int i, flags = 1;

  pal_mem_set (&req, 0, sizeof (struct pal_addrinfo));
  t_accept = NULL;
  ainfo_save[0] = NULL;
  ainfo_save[1] = NULL;
  ret = 0;
  addr_set = 0;

  if (! bgp)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: Invalid 'bgp' instance");

      return -1;
    }

  fib_id = LIB_VRF_GET_FIB_ID (bgp->owning_ivrf);
  req.ai_flags = AI_PASSIVE;
  req.ai_family = AF_UNSPEC;
  req.ai_socktype = SOCK_STREAM;
  pal_snprintf (port_str, SU_ADDRSTRLEN, "%d", port);
  port_str[sizeof (port_str) - 1] = '\0';

  ret = pal_sock_getaddrinfo (NULL, port_str, &req, &ainfo);
  if (ret != 0)
    {
      zlog_err (&BLG, "[NETWORK] Server Sock: getaddrinfo() failed: %d-%s",
                errno, pal_strerror (errno));

      return ret;
    }

  ainfo_head = ainfo;
  /* IPv4 can connect to IPv6 socket, not other way around. */
  while (ainfo)
    {
      if (ainfo->ai_family == AF_INET)
        ainfo_save[1] = ainfo;
      else if (ainfo->ai_family == AF_INET6)
        ainfo_save[0] = ainfo;

      ainfo = ainfo->ai_next;
    }

  for (i = 0; i < 2; i++) {
    ainfo = ainfo_save[i];

    if (! ainfo)
      continue;

    if (ainfo->ai_family != AF_INET && ainfo->ai_family != AF_INET6)
      continue;

    bgp_sock = pal_sock (&BLG, ainfo->ai_family, ainfo->ai_socktype,
                         ainfo->ai_protocol);
    if (bgp_sock < 0)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock: socket() Failed for AF"
                  "=%d, FIB-ID %d, Err:%d-%s", ainfo->ai_family,
                  fib_id, errno, pal_strerror (errno));

        continue;
      }

    /* set socket as ipv6 only */
    if (ainfo->ai_family == AF_INET6)
      {
        ret = setsockopt(bgp_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &flags, sizeof(flags));
        if (ret < 0)
          {
            zlog_err (&BLG, "[NETWORK] Server Sock: socket() failed to"
                      "set option for AF=%d, Err:%d-%s", ainfo->ai_family,
                      errno, pal_strerror (errno));
          }
      }

    ret = pal_sock_set_reuseaddr (bgp_sock, PAL_TRUE);
    pal_sock_set_reuseport (bgp_sock, PAL_TRUE);

    /* Bind socket to FIB. */
    ret = pal_sock_set_bindtofib (bgp_sock, fib_id);
    if (ret < 0)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock: bindtofib() Failed for"
                  " AF=%d, Sock %d, FIB-ID %d, Err:%d-%s",
                  ainfo->ai_family, bgp_sock, fib_id, errno,
                  pal_strerror (errno));

        SSOCK_FD_CLOSE (&BLG, bgp_sock);

        ret = 0;

        continue;
      }

    /* If the ai_addr is NULL, bind it to the port. */
    if (ainfo->ai_addr == NULL)
      {
        if (ainfo->ai_family == AF_INET)
          {
            pal_mem_set (&ain4, 0, sizeof (ain4)); 

            ain4.sin_family = AF_INET;
            ain4.sin_port   = pal_hton16 (port);

            ainfo->ai_addr    = (struct pal_sockaddr *) &ain4;
            ainfo->ai_addrlen = sizeof (struct pal_sockaddr_in4);
            addr_set = 1;
          }
        else if (ainfo->ai_family == AF_INET6)
          {
            pal_mem_set (&ain6, 0, sizeof (ain6));

            ain6.sin6_family = AF_INET6;
            ain6.sin6_port   = pal_hton16 (port);

            ainfo->ai_addr    = (struct pal_sockaddr *) &ain6;
            ainfo->ai_addrlen = sizeof (struct pal_sockaddr_in6);
            addr_set = 1;
          }
        else
          {
            zlog_err (&BLG, "[NETWORK] Server Sock: getaddrinfo() returned"
                      "invalid address"
                      " AF=%d, Sock %d",
                      ainfo->ai_family, bgp_sock);
              
            SSOCK_FD_CLOSE (&BLG, bgp_sock);
              
            ret = 0;
              
            continue;
          }
      }

    ret = pal_sock_bind (bgp_sock, ainfo->ai_addr, ainfo->ai_addrlen);

    if (addr_set)
      ainfo->ai_addr = NULL;

    if (ret < 0)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock: bind() Failed for AF="
                  "%d, Err: %d-%s, port[%d]", ainfo->ai_family, errno,
                  pal_strerror (errno),  port);

        SSOCK_FD_CLOSE (&BLG, bgp_sock);

        ret = 0;

        continue;
      }

#ifdef HAVE_TCP_MD5SIG
    bgp_md5_set_server (bgp, bgp_sock);
#endif /* TCP_MD5SIG */

    ret = pal_sock_listen (bgp_sock, BGP_SOCK_LISTEN_BACKLOG);
    if (ret < 0)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock: listen() Failed for "
                  "AF=%d, Sock %d, FIB-ID %d, Err:%d-%s",
                  ainfo->ai_family, bgp_sock, fib_id, errno,
                  pal_strerror (errno));

        SSOCK_FD_CLOSE (&BLG, bgp_sock);

        ret = 0;

        continue;
      }

    /* Start a fresh Accept Thread */
    t_accept = NULL;
    BGP_READ_ON (&BLG, t_accept, bgp, bpn_sock_accept, bgp_sock);

    /* Add thread to Listen Thread List */
    tmp_lnode = XCALLOC (MTYPE_TMP,
                         sizeof (struct bgp_listen_sock_lnode));
    if (! tmp_lnode)
      {
        zlog_err (&BLG, "[NETWORK] Server Sock:"
                  " Cannot allocate memory (%d) @ %s:%d",
                  sizeof (struct bgp_peer_inconn_req), __FILE__, __LINE__);

        SSOCK_FD_CLOSE (&BLG, bgp_sock);
        BGP_READ_OFF (&BLG, t_accept);

        continue;
      }

    tmp_lnode->listen_sock = bgp_sock;
    tmp_lnode->t_accept = t_accept;
    if (bgp->listen_sock_lnode)
      tmp_lnode->next = bgp->listen_sock_lnode;
    bgp->listen_sock_lnode = tmp_lnode;

  } 

  pal_sock_freeaddrinfo (ainfo_head);

  return ret;
}
Exemple #6
0
/* BGP Peer Incoming Connection Accept thread handler */
s_int32_t
bpn_sock_accept (struct thread *t_accept)
{
  struct bgp_listen_sock_lnode *tmp_lnode;
  struct bgp_peer_inconn_req *peer_icr;
  u_int8_t su_buf [SU_ADDRSTRLEN];
  pal_sock_handle_t accept_sock;
  pal_sock_handle_t bgp_sock;
  struct lib_globals *blg;
  struct bgp_peer *peer;
  union sockunion su;
  struct bgp *bgp;
  s_int32_t ret;

  bgp_sock = THREAD_FD (t_accept);
  blg = THREAD_GLOB (t_accept);
  bgp = THREAD_ARG (t_accept);
  ret = 0;

  /* Sanity check thread variables */
  if (! blg || &BLG != blg)
    {
      ret = -1;
      goto EXIT;
    }

  if (! bgp)
    {
      zlog_err (&BLG, "[NETWORK] Accept Thread: Invalid Vital Vars, "
                "blg(%p) bgp(%p)", blg, bgp);

      ret = -1;
      goto EXIT;
    }

  /* Verify integrity of thread variables */
  for (tmp_lnode = bgp->listen_sock_lnode; tmp_lnode;
       tmp_lnode = tmp_lnode->next)
    {
      if (tmp_lnode->listen_sock == bgp_sock)
        break;
    }

  if (! tmp_lnode)
    {
      zlog_err (&BLG, "[NETWORK] Accept Thread: Mismatch in thread args"
                "blg(%p) bgp(%p)", blg, bgp);

      ret = -1;
      goto EXIT;
    }

  /* Set BGP VR Context */
  BGP_SET_VR_CONTEXT (&BLG, bgp->owning_bvr);

  /* Re-regiser accept thread */
  t_accept = NULL;
  BGP_READ_ON (&BLG, t_accept, bgp, bpn_sock_accept, bgp_sock);

  /* Update the Accept Thread List Node */
  tmp_lnode->t_accept = t_accept;

  /* Accept Incoming Connection (Blocking) */
  accept_sock = sockunion_accept (&BLG, bgp_sock, &su);
  if (accept_sock < 0)
    {
      zlog_err (&BLG, "[NETWORK] Accept Thread: accept() Failed for Server"
                " Sock %d, Err:%d-%s", bgp_sock, errno, pal_strerror (errno));

      ret = -1;
      goto EXIT;
    }

  if (BGP_DEBUG (events, EVENTS))
    zlog_info (&BLG, "[NETWORK] Accept Thread: Incoming conn from host"
               " %s (FD=%u)", inet_sutop (&su, su_buf), accept_sock);

  /* Search for Configured Peer with same Remote IP address */
  peer = bgp_peer_search (bgp, &su);

  if (! peer)
    {
      if (BGP_DEBUG (events, EVENTS))
        zlog_info (&BLG, "[NETWORK] Accept Thread: %s - No such Peer "
                   "configured", inet_sutop (&su, su_buf));

      SSOCK_FD_CLOSE (&BLG, accept_sock);

      ret = -1;
      goto EXIT;
    }

  /* Prepare an Incoming Connection Req. Info structure */
  peer_icr = XCALLOC (MTYPE_TMP, sizeof (struct bgp_peer_inconn_req));
  if (! peer_icr)
    {
      zlog_err (&BLG, "[NETWORK] Accept Thread:"
                " Cannot allocate memory (%d) @ %s:%d",
                sizeof (struct bgp_peer_inconn_req), __FILE__, __LINE__);

      SSOCK_FD_CLOSE (&BLG, accept_sock);

      ret = -1;
      goto EXIT;
    }

  /* Initialize the FIFO Node */
  FIFO_INIT (&peer_icr->icr_fifo);

  /* Store the ICR Information */
  peer_icr->icr_sock = accept_sock;
  switch (su.sa.sa_family)
    {
    case AF_INET:
      peer_icr->icr_port = su.sin.sin_port;
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      peer_icr->icr_port = su.sin6.sin6_port;
      break;
#endif /* HAVE_IPV6 */
    }

  /* Enqueue into Peer's 'bicr_fifo' */
  FIFO_ADD (&peer->bicr_fifo, &peer_icr->icr_fifo);

  /* Generate BGP Peer FSM ICR Event */
  BGP_PEER_FSM_EVENT_ADD (&BLG, peer, BPF_EVENT_TCP_CONN_VALID);

 EXIT:

  return ret;
}
Exemple #7
0
/* This function is the first starting point of all BGP connection. It
   try to connect to remote peer with non-blocking IO. */
int
bgp_start (struct peer *peer)
{
  int status;

  if (BGP_PEER_START_SUPPRESSED (peer))
    {
      if (BGP_DEBUG (fsm, FSM))
        plog_err (peer->log, "%s [FSM] Trying to start suppressed peer"
                  " - this is never supposed to happen!", peer->host);
      return -1;
    }

  /* Scrub some information that might be left over from a previous,
   * session
   */
  /* Connection information. */
  if (peer->su_local)
    {
      sockunion_free (peer->su_local);
      peer->su_local = NULL;
    }

  if (peer->su_remote)
    {
      sockunion_free (peer->su_remote);
      peer->su_remote = NULL;
    }

  /* Clear remote router-id. */
  peer->remote_id.s_addr = 0;

  /* Clear peer capability flag. */
  peer->cap = 0;
    
  /* If the peer is passive mode, force to move to Active mode. */
  if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE))
    {
      BGP_EVENT_ADD (peer, TCP_connection_open_failed);
      return 0;
    }

  status = bgp_connect (peer);

  switch (status)
    {
    case connect_error:
      if (BGP_DEBUG (fsm, FSM))
	plog_debug (peer->log, "%s [FSM] Connect error", peer->host);
      BGP_EVENT_ADD (peer, TCP_connection_open_failed);
      break;
    case connect_success:
      if (BGP_DEBUG (fsm, FSM))
	plog_debug (peer->log, "%s [FSM] Connect immediately success",
		   peer->host);
      BGP_EVENT_ADD (peer, TCP_connection_open);
      break;
    case connect_in_progress:
      /* To check nonblocking connect, we wait until socket is
         readable or writable. */
      if (BGP_DEBUG (fsm, FSM))
	plog_debug (peer->log, "%s [FSM] Non blocking connect waiting result",
		   peer->host);
      if (peer->fd < 0)
	{
	  zlog_err ("bgp_start peer's fd is negative value %d",
		    peer->fd);
	  return -1;
	}
      BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
      BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
      break;
    }
  return 0;
}