pimd/pim_msdp_socket.c

   1 /*
   2  * IP MSDP socket management
   3  * Copyright (C) 2016 Cumulus Networks, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include <lib/log.h>
  23 #include <lib/network.h>
  24 #include <lib/sockunion.h>
  25 #include <lib/thread.h>
  26 #include <lib/vty.h>
  27 #include <lib/if.h>
  28 #include <lib/vrf.h>
  29
  30 #include "pimd.h"
  31 #include "pim_sock.h"
  32
  33 #include "pim_msdp.h"
  34 #include "pim_msdp_socket.h"
  35
  36 /* increase socket send buffer size */
  37 static void pim_msdp_update_sock_send_buffer_size(int fd)
  38 {
  39         int size = PIM_MSDP_SOCKET_SNDBUF_SIZE;
  40         int optval;
  41         socklen_t optlen = sizeof(optval);
  42
  43         if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
  44                 zlog_err("getsockopt of SO_SNDBUF failed %s\n",
  45                          safe_strerror(errno));
  46                 return;
  47         }
  48
  49         if (optval < size) {
  50                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
  51                     < 0) {
  52                         zlog_err("Couldn't increase send buffer: %s\n",
  53                                  safe_strerror(errno));
  54                 }
  55         }
  56 }
  57
  58 /* passive peer socket accept */
  59 static int pim_msdp_sock_accept(struct thread *thread)
  60 {
  61         union sockunion su;
  62         struct pim_instance *pim = THREAD_ARG(thread);
  63         int accept_sock;
  64         int msdp_sock;
  65         struct pim_msdp_peer *mp;
  66         char buf[SU_ADDRSTRLEN];
  67
  68         sockunion_init(&su);
  69
  70         /* re-register accept thread */
  71         accept_sock = THREAD_FD(thread);
  72         if (accept_sock < 0) {
  73                 zlog_err("accept_sock is negative value %d", accept_sock);
  74                 return -1;
  75         }
  76         pim->msdp.listener.thread = NULL;
  77         thread_add_read(master, pim_msdp_sock_accept, pim, accept_sock,
  78                         &pim->msdp.listener.thread);
  79
  80         /* accept client connection. */
  81         msdp_sock = sockunion_accept(accept_sock, &su);
  82         if (msdp_sock < 0) {
  83                 zlog_err("pim_msdp_sock_accept failed (%s)",
  84                          safe_strerror(errno));
  85                 return -1;
  86         }
  87
  88         /* see if have peer config for this */
  89         mp = pim_msdp_peer_find(pim, su.sin.sin_addr);
  90         if (!mp || !PIM_MSDP_PEER_IS_LISTENER(mp)) {
  91                 ++pim->msdp.rejected_accepts;
  92                 if (PIM_DEBUG_MSDP_EVENTS) {
  93                         zlog_err("msdp peer connection refused from %s",
  94                                  sockunion2str(&su, buf, SU_ADDRSTRLEN));
  95                 }
  96                 close(msdp_sock);
  97                 return -1;
  98         }
  99
 100         if (PIM_DEBUG_MSDP_INTERNAL) {
 101                 zlog_debug("MSDP peer %s accept success%s", mp->key_str,
 102                            mp->fd >= 0 ? "(dup)" : "");
 103         }
 104
 105         /* if we have an existing connection we need to kill that one
 106          * with this one */
 107         if (mp->fd >= 0) {
 108                 if (PIM_DEBUG_MSDP_EVENTS) {
 109                         zlog_err(
 110                                 "msdp peer new connection from %s stop old connection",
 111                                 sockunion2str(&su, buf, SU_ADDRSTRLEN));
 112                 }
 113                 pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
 114         }
 115         mp->fd = msdp_sock;
 116         set_nonblocking(mp->fd);
 117         pim_msdp_update_sock_send_buffer_size(mp->fd);
 118         pim_msdp_peer_established(mp);
 119         return 0;
 120 }
 121
 122 /* global listener for the MSDP well know TCP port */
 123 int pim_msdp_sock_listen(struct pim_instance *pim)
 124 {
 125         int sock;
 126         int socklen;
 127         struct sockaddr_in sin;
 128         int rc;
 129         struct pim_msdp_listener *listener = &pim->msdp.listener;
 130
 131         if (pim->msdp.flags & PIM_MSDPF_LISTENER) {
 132                 /* listener already setup */
 133                 return 0;
 134         }
 135
 136         sock = socket(AF_INET, SOCK_STREAM, 0);
 137         if (sock < 0) {
 138                 zlog_err("socket: %s", safe_strerror(errno));
 139                 return sock;
 140         }
 141
 142         memset(&sin, 0, sizeof(struct sockaddr_in));
 143         sin.sin_family = AF_INET;
 144         sin.sin_port = htons(PIM_MSDP_TCP_PORT);
 145         socklen = sizeof(struct sockaddr_in);
 146 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 147         sin.sin_len = socklen;
 148 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 149
 150         sockopt_reuseaddr(sock);
 151         sockopt_reuseport(sock);
 152
 153         if (pim->vrf_id != VRF_DEFAULT) {
 154                 struct interface *ifp =
 155                         if_lookup_by_name(pim->vrf->name, pim->vrf_id);
 156                 if (!ifp) {
 157                         zlog_err("%s: Unable to lookup vrf interface: %s",
 158                                  __PRETTY_FUNCTION__, pim->vrf->name);
 159                         close(sock);
 160                         return -1;
 161                 }
 162                 if (pim_socket_bind(sock, ifp)) {
 163                         zlog_err("%s: Unable to bind to socket: %s",
 164                                  __PRETTY_FUNCTION__, safe_strerror(errno));
 165                         close(sock);
 166                         return -1;
 167                 }
 168         }
 169
 170         if (pimd_privs.change(ZPRIVS_RAISE)) {
 171                 zlog_err("pim_msdp_socket: could not raise privs, %s",
 172                          safe_strerror(errno));
 173         }
 174
 175         /* bind to well known TCP port */
 176         rc = bind(sock, (struct sockaddr *)&sin, socklen);
 177
 178         if (pimd_privs.change(ZPRIVS_LOWER)) {
 179                 zlog_err("pim_msdp_socket: could not lower privs, %s",
 180                          safe_strerror(errno));
 181         }
 182
 183         if (rc < 0) {
 184                 zlog_err("pim_msdp_socket bind to port %d: %s",
 185                          ntohs(sin.sin_port), safe_strerror(errno));
 186                 close(sock);
 187                 return rc;
 188         }
 189
 190         rc = listen(sock, 3 /* backlog */);
 191         if (rc < 0) {
 192                 zlog_err("pim_msdp_socket listen: %s", safe_strerror(errno));
 193                 close(sock);
 194                 return rc;
 195         }
 196
 197         /* add accept thread */
 198         listener->fd = sock;
 199         memcpy(&listener->su, &sin, socklen);
 200         listener->thread = NULL;
 201         thread_add_read(pim->msdp.master, pim_msdp_sock_accept, pim, sock,
 202                         &listener->thread);
 203
 204         pim->msdp.flags |= PIM_MSDPF_LISTENER;
 205         return 0;
 206 }
 207
 208 /* active peer socket setup */
 209 int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
 210 {
 211         int rc;
 212
 213         if (PIM_DEBUG_MSDP_INTERNAL) {
 214                 zlog_debug("MSDP peer %s attempt connect%s", mp->key_str,
 215                            mp->fd < 0 ? "" : "(dup)");
 216         }
 217
 218         /* if we have an existing connection we need to kill that one
 219          * with this one */
 220         if (mp->fd >= 0) {
 221                 if (PIM_DEBUG_MSDP_EVENTS) {
 222                         zlog_err(
 223                                 "msdp duplicate connect to %s nuke old connection",
 224                                 mp->key_str);
 225                 }
 226                 pim_msdp_peer_stop_tcp_conn(mp, false /* chg_state */);
 227         }
 228
 229         /* Make socket for the peer. */
 230         mp->fd = sockunion_socket(&mp->su_peer);
 231         if (mp->fd < 0) {
 232                 zlog_err("pim_msdp_socket socket failure: %s",
 233                          safe_strerror(errno));
 234                 return -1;
 235         }
 236
 237         if (mp->pim->vrf_id != VRF_DEFAULT) {
 238                 struct interface *ifp =
 239                         if_lookup_by_name(mp->pim->vrf->name, mp->pim->vrf_id);
 240                 if (!ifp) {
 241                         zlog_err("%s: Unable to lookup vrf interface: %s",
 242                                  __PRETTY_FUNCTION__, mp->pim->vrf->name);
 243                         return -1;
 244                 }
 245                 if (pim_socket_bind(mp->fd, ifp)) {
 246                         zlog_err("%s: Unable to bind to socket: %s",
 247                                  __PRETTY_FUNCTION__, safe_strerror(errno));
 248                         close(mp->fd);
 249                         mp->fd = -1;
 250                         return -1;
 251                 }
 252         }
 253
 254         set_nonblocking(mp->fd);
 255
 256         /* Set socket send buffer size */
 257         pim_msdp_update_sock_send_buffer_size(mp->fd);
 258         sockopt_reuseaddr(mp->fd);
 259         sockopt_reuseport(mp->fd);
 260
 261         /* source bind */
 262         rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
 263         if (rc < 0) {
 264                 zlog_err("pim_msdp_socket connect bind failure: %s",
 265                          safe_strerror(errno));
 266                 close(mp->fd);
 267                 mp->fd = -1;
 268                 return rc;
 269         }
 270
 271         /* Connect to the remote mp. */
 272         return (sockunion_connect(mp->fd, &mp->su_peer,
 273                                   htons(PIM_MSDP_TCP_PORT), 0));
 274 }