teamd/teamd_common.c

/*
 *   teamd_common.c - Common teamd functions
 *   Copyright (C) 2012-2015 Jiri Pirko <jiri@resnulli.us>
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <pwd.h>
#include <sys/stat.h>
#include <linux/if_packet.h>
#include <linux/filter.h>
#include <private/misc.h>

#include "teamd.h"

static struct sock_filter bad_flt[] = {
	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, -1),
	BPF_STMT(BPF_RET + BPF_K, 0),
};

static const struct sock_fprog bad_fprog = {
	.len = ARRAY_SIZE(bad_flt),
	.filter = bad_flt,
};

static int attach_filter(int sock, const struct sock_fprog *pref_fprog,
			 const struct sock_fprog *alt_fprog)
{
	int ret;
	const struct sock_fprog *fprog;

	if (!pref_fprog)
		return 0;

	/* Now we are in tough situation. Older kernels (<3.8) does not
	 * support SKF_AD_VLAN_TAG_PRESENT and SKF_AD_VLAN_TAG. But the kernel
	 * check if these are supported was added after that:
	 * aa1113d9f85da59dcbdd32aeb5d71da566e46def
	 * But it was added close enough. So try to attach obviously bad
	 * filter and assume that is it does not fail, kernel does not support
	 * accessing skb->vlan_tci getting and use alternative filter instead.
	 */

	ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
			 &bad_fprog, sizeof(bad_fprog));
	if (ret == -1) {
		if (errno != EINVAL)
			return -errno;
		fprog = pref_fprog;
	}
	else if (alt_fprog) {
		teamd_log_warn("Kernel does not support accessing skb->vlan_tci from BPF,\n"
			       "falling back to alternative filter. Expect vlan-tagged ARPs\n"
			       "to be accounted on non-tagged link monitor and vice versa.");
		fprog = alt_fprog;
	} else {
		return 0;
	}

	ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
			 fprog, sizeof(*fprog));
	if (ret == -1)
		return -errno;
	return 0;
}

int teamd_packet_sock_open_type(int type, int *sock_p, const uint32_t ifindex,
				const unsigned short family,
				const struct sock_fprog *fprog,
				const struct sock_fprog *alt_fprog)
{
	struct sockaddr_ll ll_my;
	int sock;
	int ret;
	int err;

	sock = socket(PF_PACKET, type, 0);
	if (sock == -1) {
		teamd_log_err("Failed to create packet socket.");
		return -errno;
	}

	err = attach_filter(sock, fprog, alt_fprog);
	if (err) {
		teamd_log_err("Failed to attach filter.");
		goto close_sock;
	}

	memset(&ll_my, 0, sizeof(ll_my));
	ll_my.sll_family = AF_PACKET;
	ll_my.sll_ifindex = ifindex;
	ll_my.sll_protocol = family;
	ret = bind(sock, (struct sockaddr *) &ll_my, sizeof(ll_my));
	if (ret == -1) {
		teamd_log_err("Failed to bind socket.");
		err = -errno;
		goto close_sock;
	}

	*sock_p = sock;
	return 0;
close_sock:
	close(sock);
	return err;
}

int teamd_packet_sock_open(int *sock_p, const uint32_t ifindex,
			   const unsigned short family,
			   const struct sock_fprog *fprog,
			   const struct sock_fprog *alt_fprog)
{
	return teamd_packet_sock_open_type(SOCK_DGRAM, sock_p, ifindex, family,
					   fprog, alt_fprog);
}

int teamd_getsockname_hwaddr(int sock, struct sockaddr_ll *addr,
			     size_t expected_len)
{
	socklen_t addr_len;
	int ret;

	addr_len = sizeof(*addr);
	ret = getsockname(sock, (struct sockaddr *) addr, &addr_len);
	if (ret == -1) {
		teamd_log_err("Failed to getsockname.");
		return -errno;
	}
	if (expected_len && addr->sll_halen != expected_len) {
		teamd_log_err("Unexpected length of hw address.");
		return -ENOTSUP;
	}
	return 0;
}

int teamd_sendto(int sockfd, const void *buf, size_t len, int flags,
		 const struct sockaddr *dest_addr, socklen_t addrlen)
{
	ssize_t ret;

resend:
	ret = sendto(sockfd, buf, len, flags, dest_addr, addrlen);
	if (ret == -1) {
		switch(errno) {
		case EINTR:
			goto resend;
		case ENETDOWN:
		case ENETUNREACH:
		case EADDRNOTAVAIL:
		case ENXIO:
			return 0;
		default:
			teamd_log_err("sendto failed.");
			return -errno;
		}
	}
	return 0;
}

int teamd_send(int sockfd, const void *buf, size_t len, int flags)
{
	ssize_t ret;

resend:
	ret = send(sockfd, buf, len, flags);
	if (ret == -1) {
		switch(errno) {
		case EINTR:
			goto resend;
		case ENETDOWN:
		case ENETUNREACH:
		case EADDRNOTAVAIL:
		case ENXIO:
			return 0;
		default:
			teamd_log_err("send failed.");
			return -errno;
		}
	}
	return 0;
}

int teamd_recvfrom(int sockfd, void *buf, size_t len, int flags,
		   struct sockaddr *src_addr, socklen_t addrlen)
{
	size_t ret;
	socklen_t tmp_addrlen = addrlen;

rerecv:
	ret = recvfrom(sockfd, buf, len, flags, src_addr, &tmp_addrlen);
	if (ret == -1) {
		switch(errno) {
		case EINTR:
			goto rerecv;
		case ENETDOWN:
			return 0;
		default:
			teamd_log_err("recvfrom failed.");
			return -errno;
		}
	}
	return ret;
}