[mirror_frr.git] / pimd / pim_msdp_socket.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * IP MSDP socket management
 * Copyright (C) 2016 Cumulus Networks, Inc.
 */

#include <zebra.h>

#include <lib/log.h>
#include <lib/network.h>
#include <lib/sockunion.h>
#include "frrevent.h"
#include <lib/vty.h>
#include <lib/if.h>
#include <lib/vrf.h>
#include <lib/lib_errors.h>

#include "pimd.h"
#include "pim_instance.h"
#include "pim_sock.h"
#include "pim_errors.h"

#include "pim_msdp.h"
#include "pim_msdp_socket.h"

#include "sockopt.h"

/* increase socket send buffer size */
static void pim_msdp_update_sock_send_buffer_size(int fd)
{
	int size = PIM_MSDP_SOCKET_SNDBUF_SIZE;
	int optval;
	socklen_t optlen = sizeof(optval);

	if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "getsockopt of SO_SNDBUF failed %s",
			     safe_strerror(errno));
		return;
	}

	if (optval < size) {
		if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
		    < 0) {
			flog_err_sys(EC_LIB_SOCKET,
				     "Couldn't increase send buffer: %s",
				     safe_strerror(errno));
		}
	}
}

/* passive peer socket accept */
static void pim_msdp_sock_accept(struct event *thread)
{
	union sockunion su;
	struct pim_instance *pim = EVENT_ARG(thread);
	int accept_sock;
	int msdp_sock;
	struct pim_msdp_peer *mp;

	sockunion_init(&su);

	/* re-register accept thread */
	accept_sock = EVENT_FD(thread);
	if (accept_sock < 0) {
		flog_err(EC_LIB_DEVELOPMENT, "accept_sock is negative value %d",
			 accept_sock);
		return;
	}
	pim->msdp.listener.thread = NULL;
	event_add_read(router->master, pim_msdp_sock_accept, pim, accept_sock,
		       &pim->msdp.listener.thread);

	/* accept client connection. */
	msdp_sock = sockunion_accept(accept_sock, &su);
	if (msdp_sock < 0) {
		flog_err_sys(EC_LIB_SOCKET, "pim_msdp_sock_accept failed (%s)",
			     safe_strerror(errno));
		return;
	}

	/* see if have peer config for this */
	mp = pim_msdp_peer_find(pim, su.sin.sin_addr);
	if (!mp || !PIM_MSDP_PEER_IS_LISTENER(mp)) {
		++pim->msdp.rejected_accepts;
		if (PIM_DEBUG_MSDP_EVENTS) {
			flog_err(EC_PIM_MSDP_PACKET,
				 "msdp peer connection refused from %pSU", &su);
		}
		close(msdp_sock);
		return;
	}

	if (PIM_DEBUG_MSDP_INTERNAL) {
		zlog_debug("MSDP peer %s accept success%s", mp->key_str,
			   mp->fd >= 0 ? "(dup)" : "");
	}

	/* if we have an existing connection we need to kill that one
	 * with this one */
	if (mp->fd >= 0) {
		if (PIM_DEBUG_MSDP_EVENTS) {
			zlog_notice(
				"msdp peer new connection from %pSU stop old connection",
				&su);
		}
		pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
	}
	mp->fd = msdp_sock;
	set_nonblocking(mp->fd);
	pim_msdp_update_sock_send_buffer_size(mp->fd);
	pim_msdp_peer_established(mp);
}

/* global listener for the MSDP well know TCP port */
int pim_msdp_sock_listen(struct pim_instance *pim)
{
	int sock;
	int socklen;
	struct sockaddr_in sin;
	int rc;
	struct pim_msdp_listener *listener = &pim->msdp.listener;

	if (pim->msdp.flags & PIM_MSDPF_LISTENER) {
		/* listener already setup */
		return 0;
	}

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0) {
		flog_err_sys(EC_LIB_SOCKET, "socket: %s", safe_strerror(errno));
		return sock;
	}

	memset(&sin, 0, sizeof(struct sockaddr_in));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(PIM_MSDP_TCP_PORT);
	socklen = sizeof(struct sockaddr_in);
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	sin.sin_len = socklen;
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */

	sockopt_reuseaddr(sock);
	sockopt_reuseport(sock);

	if (pim->vrf->vrf_id != VRF_DEFAULT) {
		struct interface *ifp =
			if_lookup_by_name(pim->vrf->name, pim->vrf->vrf_id);
		if (!ifp) {
			flog_err(EC_LIB_INTERFACE,
				 "%s: Unable to lookup vrf interface: %s",
				 __func__, pim->vrf->name);
			close(sock);
			return -1;
		}
		if (pim_socket_bind(sock, ifp)) {
			flog_err_sys(EC_LIB_SOCKET,
				     "%s: Unable to bind to socket: %s",
				     __func__, safe_strerror(errno));
			close(sock);
			return -1;
		}
	}

	frr_with_privs(&pimd_privs) {
		/* bind to well known TCP port */
		rc = bind(sock, (struct sockaddr *)&sin, socklen);
	}

	if (rc < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "pim_msdp_socket bind to port %d: %s",
			     ntohs(sin.sin_port), safe_strerror(errno));
		close(sock);
		return rc;
	}

	rc = listen(sock, 3 /* backlog */);
	if (rc < 0) {
		flog_err_sys(EC_LIB_SOCKET, "pim_msdp_socket listen: %s",
			     safe_strerror(errno));
		close(sock);
		return rc;
	}

	/* Set socket DSCP byte */
	if (setsockopt_ipv4_tos(sock, IPTOS_PREC_INTERNETCONTROL)) {
		zlog_warn("can't set sockopt IP_TOS to MSDP socket %d: %s",
				sock, safe_strerror(errno));
	}

	/* add accept thread */
	listener->fd = sock;
	memcpy(&listener->su, &sin, socklen);
	event_add_read(pim->msdp.master, pim_msdp_sock_accept, pim, sock,
		       &listener->thread);

	pim->msdp.flags |= PIM_MSDPF_LISTENER;
	return 0;
}

/* active peer socket setup */
int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
{
	int rc;

	if (PIM_DEBUG_MSDP_INTERNAL) {
		zlog_debug("MSDP peer %s attempt connect%s", mp->key_str,
			   mp->fd < 0 ? "" : "(dup)");
	}

	/* if we have an existing connection we need to kill that one
	 * with this one */
	if (mp->fd >= 0) {
		if (PIM_DEBUG_MSDP_EVENTS) {
			zlog_notice(
				"msdp duplicate connect to %s nuke old connection",
				mp->key_str);
		}
		pim_msdp_peer_stop_tcp_conn(mp, false /* chg_state */);
	}

	/* Make socket for the peer. */
	mp->fd = sockunion_socket(&mp->su_peer);
	if (mp->fd < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "pim_msdp_socket socket failure: %s",
			     safe_strerror(errno));
		return -1;
	}

	if (mp->pim->vrf->vrf_id != VRF_DEFAULT) {
		struct interface *ifp = if_lookup_by_name(mp->pim->vrf->name,
							  mp->pim->vrf->vrf_id);
		if (!ifp) {
			flog_err(EC_LIB_INTERFACE,
				 "%s: Unable to lookup vrf interface: %s",
				 __func__, mp->pim->vrf->name);
			return -1;
		}
		if (pim_socket_bind(mp->fd, ifp)) {
			flog_err_sys(EC_LIB_SOCKET,
				     "%s: Unable to bind to socket: %s",
				     __func__, safe_strerror(errno));
			close(mp->fd);
			mp->fd = -1;
			return -1;
		}
	}

	set_nonblocking(mp->fd);

	/* Set socket send buffer size */
	pim_msdp_update_sock_send_buffer_size(mp->fd);
	sockopt_reuseaddr(mp->fd);
	sockopt_reuseport(mp->fd);

	/* source bind */
	rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
	if (rc < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "pim_msdp_socket connect bind failure: %s",
			     safe_strerror(errno));
		close(mp->fd);
		mp->fd = -1;
		return rc;
	}

	/* Set socket DSCP byte */
	if (setsockopt_ipv4_tos(mp->fd, IPTOS_PREC_INTERNETCONTROL)) {
		zlog_warn("can't set sockopt IP_TOS to MSDP socket %d: %s",
				mp->fd, safe_strerror(errno));
	}

	/* Connect to the remote mp. */
	return (sockunion_connect(mp->fd, &mp->su_peer,
				  htons(PIM_MSDP_TCP_PORT), 0));
}
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
2a333e0f	2	/*
	3	* IP MSDP socket management
	4	* Copyright (C) 2016 Cumulus Networks, Inc.
2a333e0f	5	*/
	6
	7	#include <zebra.h>
	8
	9	#include <lib/log.h>
	10	#include <lib/network.h>
2a333e0f	11	#include <lib/sockunion.h>
24a58196	12	#include "frrevent.h"
3c72d654	13	#include <lib/vty.h>
62fde409 DS	14	#include <lib/if.h>
62fde409 DS	15	#include <lib/vrf.h>
3613d898	16	#include <lib/lib_errors.h>
2a333e0f	17
2a333e0f	18	#include "pimd.h"
993e3d8e	19	#include "pim_instance.h"
62fde409	20	#include "pim_sock.h"
d9ff4302	21	#include "pim_errors.h"
2a333e0f	22
	23	#include "pim_msdp.h"
	24	#include "pim_msdp_socket.h"
	25
b069b568 AMR	26	#include "sockopt.h"
b069b568 AMR	27
2a333e0f	28	/* increase socket send buffer size */
d62a17ae	29	static void pim_msdp_update_sock_send_buffer_size(int fd)
2a333e0f	30	{
d62a17ae	31	int size = PIM_MSDP_SOCKET_SNDBUF_SIZE;
	32	int optval;
	33	socklen_t optlen = sizeof(optval);
	34
	35	if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
450971aa	36	flog_err_sys(EC_LIB_SOCKET,
1d5453d6	37	"getsockopt of SO_SNDBUF failed %s",
09c866e3	38	safe_strerror(errno));
d62a17ae	39	return;
	40	}
	41
	42	if (optval < size) {
	43	if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
	44	< 0) {
450971aa	45	flog_err_sys(EC_LIB_SOCKET,
1d5453d6	46	"Couldn't increase send buffer: %s",
09c866e3	47	safe_strerror(errno));
d62a17ae	48	}
d62a17ae	49	}
2a333e0f	50	}
	51
	52	/* passive peer socket accept */
e6685141	53	static void pim_msdp_sock_accept(struct event *thread)
2a333e0f	54	{
d62a17ae	55	union sockunion su;
e16d030c	56	struct pim_instance *pim = EVENT_ARG(thread);
d62a17ae	57	int accept_sock;
	58	int msdp_sock;
	59	struct pim_msdp_peer *mp;
d62a17ae	60
	61	sockunion_init(&su);
	62
	63	/* re-register accept thread */
e16d030c	64	accept_sock = EVENT_FD(thread);
d62a17ae	65	if (accept_sock < 0) {
1c50c1c0 QY	66	flog_err(EC_LIB_DEVELOPMENT, "accept_sock is negative value %d",
1c50c1c0 QY	67	accept_sock);
cc9f21da	68	return;
d62a17ae	69	}
472ad383	70	pim->msdp.listener.thread = NULL;
907a2395 DS	71	event_add_read(router->master, pim_msdp_sock_accept, pim, accept_sock,
907a2395 DS	72	&pim->msdp.listener.thread);
d62a17ae	73
	74	/* accept client connection. */
	75	msdp_sock = sockunion_accept(accept_sock, &su);
	76	if (msdp_sock < 0) {
450971aa	77	flog_err_sys(EC_LIB_SOCKET, "pim_msdp_sock_accept failed (%s)",
09c866e3	78	safe_strerror(errno));
cc9f21da	79	return;
d62a17ae	80	}
	81
	82	/* see if have peer config for this */
472ad383	83	mp = pim_msdp_peer_find(pim, su.sin.sin_addr);
d62a17ae	84	if (!mp \|\| !PIM_MSDP_PEER_IS_LISTENER(mp)) {
472ad383	85	++pim->msdp.rejected_accepts;
d62a17ae	86	if (PIM_DEBUG_MSDP_EVENTS) {
298004a1	87	flog_err(EC_PIM_MSDP_PACKET,
6b73800b	88	"msdp peer connection refused from %pSU", &su);
d62a17ae	89	}
d62a17ae	90	close(msdp_sock);
cc9f21da	91	return;
d62a17ae	92	}
	93
	94	if (PIM_DEBUG_MSDP_INTERNAL) {
	95	zlog_debug("MSDP peer %s accept success%s", mp->key_str,
	96	mp->fd >= 0 ? "(dup)" : "");
	97	}
	98
	99	/* if we have an existing connection we need to kill that one
	100	* with this one */
	101	if (mp->fd >= 0) {
	102	if (PIM_DEBUG_MSDP_EVENTS) {
3613d898	103	zlog_notice(
6b73800b DS	104	"msdp peer new connection from %pSU stop old connection",
6b73800b DS	105	&su);
d62a17ae	106	}
	107	pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
	108	}
	109	mp->fd = msdp_sock;
	110	set_nonblocking(mp->fd);
	111	pim_msdp_update_sock_send_buffer_size(mp->fd);
	112	pim_msdp_peer_established(mp);
2a333e0f	113	}
	114
	115	/* global listener for the MSDP well know TCP port */
472ad383	116	int pim_msdp_sock_listen(struct pim_instance *pim)
2a333e0f	117	{
d62a17ae	118	int sock;
	119	int socklen;
	120	struct sockaddr_in sin;
	121	int rc;
472ad383	122	struct pim_msdp_listener *listener = &pim->msdp.listener;
d62a17ae	123
472ad383	124	if (pim->msdp.flags & PIM_MSDPF_LISTENER) {
d62a17ae	125	/* listener already setup */
	126	return 0;
	127	}
	128
	129	sock = socket(AF_INET, SOCK_STREAM, 0);
	130	if (sock < 0) {
1c50c1c0	131	flog_err_sys(EC_LIB_SOCKET, "socket: %s", safe_strerror(errno));
d62a17ae	132	return sock;
	133	}
	134
	135	memset(&sin, 0, sizeof(struct sockaddr_in));
	136	sin.sin_family = AF_INET;
	137	sin.sin_port = htons(PIM_MSDP_TCP_PORT);
	138	socklen = sizeof(struct sockaddr_in);
2a333e0f	139	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
d62a17ae	140	sin.sin_len = socklen;
2a333e0f	141	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
2a333e0f	142
d62a17ae	143	sockopt_reuseaddr(sock);
	144	sockopt_reuseport(sock);
	145
d3cc1e45	146	if (pim->vrf->vrf_id != VRF_DEFAULT) {
2267994c	147	struct interface *ifp =
d3cc1e45	148	if_lookup_by_name(pim->vrf->name, pim->vrf->vrf_id);
449a3f5b	149	if (!ifp) {
450971aa	150	flog_err(EC_LIB_INTERFACE,
1c50c1c0	151	"%s: Unable to lookup vrf interface: %s",
5e81f5dd	152	__func__, pim->vrf->name);
e691f179 DS	153	close(sock);
	154	return -1;
	155	}
	156	if (pim_socket_bind(sock, ifp)) {
450971aa	157	flog_err_sys(EC_LIB_SOCKET,
09c866e3	158	"%s: Unable to bind to socket: %s",
5e81f5dd	159	__func__, safe_strerror(errno));
e691f179	160	close(sock);
449a3f5b DS	161	return -1;
449a3f5b DS	162	}
2267994c DS	163	}
2267994c DS	164
0cf6db21	165	frr_with_privs(&pimd_privs) {
6bb30c2c DL	166	/* bind to well known TCP port */
6bb30c2c DL	167	rc = bind(sock, (struct sockaddr *)&sin, socklen);
d62a17ae	168	}
	169
	170	if (rc < 0) {
450971aa	171	flog_err_sys(EC_LIB_SOCKET,
09c866e3 QY	172	"pim_msdp_socket bind to port %d: %s",
09c866e3 QY	173	ntohs(sin.sin_port), safe_strerror(errno));
d62a17ae	174	close(sock);
	175	return rc;
	176	}
	177
	178	rc = listen(sock, 3 /* backlog */);
	179	if (rc < 0) {
450971aa	180	flog_err_sys(EC_LIB_SOCKET, "pim_msdp_socket listen: %s",
09c866e3	181	safe_strerror(errno));
d62a17ae	182	close(sock);
	183	return rc;
	184	}
	185
b069b568 AMR	186	/* Set socket DSCP byte */
	187	if (setsockopt_ipv4_tos(sock, IPTOS_PREC_INTERNETCONTROL)) {
	188	zlog_warn("can't set sockopt IP_TOS to MSDP socket %d: %s",
	189	sock, safe_strerror(errno));
	190	}
	191
d62a17ae	192	/* add accept thread */
	193	listener->fd = sock;
	194	memcpy(&listener->su, &sin, socklen);
907a2395 DS	195	event_add_read(pim->msdp.master, pim_msdp_sock_accept, pim, sock,
907a2395 DS	196	&listener->thread);
d62a17ae	197
472ad383	198	pim->msdp.flags \|= PIM_MSDPF_LISTENER;
d62a17ae	199	return 0;
2a333e0f	200	}
	201
	202	/* active peer socket setup */
d62a17ae	203	int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
2a333e0f	204	{
d62a17ae	205	int rc;
	206
	207	if (PIM_DEBUG_MSDP_INTERNAL) {
	208	zlog_debug("MSDP peer %s attempt connect%s", mp->key_str,
	209	mp->fd < 0 ? "" : "(dup)");
	210	}
	211
	212	/* if we have an existing connection we need to kill that one
	213	* with this one */
	214	if (mp->fd >= 0) {
	215	if (PIM_DEBUG_MSDP_EVENTS) {
3613d898	216	zlog_notice(
d62a17ae	217	"msdp duplicate connect to %s nuke old connection",
	218	mp->key_str);
	219	}
	220	pim_msdp_peer_stop_tcp_conn(mp, false /* chg_state */);
	221	}
	222
	223	/* Make socket for the peer. */
	224	mp->fd = sockunion_socket(&mp->su_peer);
	225	if (mp->fd < 0) {
450971aa	226	flog_err_sys(EC_LIB_SOCKET,
09c866e3 QY	227	"pim_msdp_socket socket failure: %s",
09c866e3 QY	228	safe_strerror(errno));
d62a17ae	229	return -1;
	230	}
	231
d3cc1e45 DS	232	if (mp->pim->vrf->vrf_id != VRF_DEFAULT) {
	233	struct interface *ifp = if_lookup_by_name(mp->pim->vrf->name,
	234	mp->pim->vrf->vrf_id);
449a3f5b	235	if (!ifp) {
450971aa	236	flog_err(EC_LIB_INTERFACE,
1c50c1c0	237	"%s: Unable to lookup vrf interface: %s",
15569c58	238	__func__, mp->pim->vrf->name);
449a3f5b DS	239	return -1;
449a3f5b DS	240	}
e691f179	241	if (pim_socket_bind(mp->fd, ifp)) {
450971aa	242	flog_err_sys(EC_LIB_SOCKET,
09c866e3	243	"%s: Unable to bind to socket: %s",
15569c58	244	__func__, safe_strerror(errno));
e691f179 DS	245	close(mp->fd);
	246	mp->fd = -1;
	247	return -1;
	248	}
62fde409 DS	249	}
62fde409 DS	250
d62a17ae	251	set_nonblocking(mp->fd);
	252
	253	/* Set socket send buffer size */
	254	pim_msdp_update_sock_send_buffer_size(mp->fd);
	255	sockopt_reuseaddr(mp->fd);
	256	sockopt_reuseport(mp->fd);
	257
	258	/* source bind */
	259	rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
	260	if (rc < 0) {
450971aa	261	flog_err_sys(EC_LIB_SOCKET,
09c866e3 QY	262	"pim_msdp_socket connect bind failure: %s",
09c866e3 QY	263	safe_strerror(errno));
d62a17ae	264	close(mp->fd);
	265	mp->fd = -1;
	266	return rc;
	267	}
	268
b069b568 AMR	269	/* Set socket DSCP byte */
	270	if (setsockopt_ipv4_tos(mp->fd, IPTOS_PREC_INTERNETCONTROL)) {
	271	zlog_warn("can't set sockopt IP_TOS to MSDP socket %d: %s",
	272	mp->fd, safe_strerror(errno));
	273	}
	274
d62a17ae	275	/* Connect to the remote mp. */
	276	return (sockunion_connect(mp->fd, &mp->su_peer,
	277	htons(PIM_MSDP_TCP_PORT), 0));
2a333e0f	278	}