392 lines
8.3 KiB
C
392 lines
8.3 KiB
C
/* $OpenBSD: socket.c,v 1.10 2019/06/28 13:32:48 deraadt Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2016 Renato Westphal <renato@openbsd.org>
|
|
* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
|
|
* Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
|
|
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/ip.h>
|
|
#include <netinet/tcp.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
|
|
#include "ldpd.h"
|
|
#include "ldpe.h"
|
|
#include "log.h"
|
|
|
|
int
|
|
ldp_create_socket(int af, enum socket_type type)
|
|
{
|
|
int fd, domain, proto;
|
|
union ldpd_addr addr;
|
|
struct sockaddr_storage local_sa;
|
|
int opt;
|
|
|
|
/* create socket */
|
|
switch (type) {
|
|
case LDP_SOCKET_DISC:
|
|
case LDP_SOCKET_EDISC:
|
|
domain = SOCK_DGRAM;
|
|
proto = IPPROTO_UDP;
|
|
break;
|
|
case LDP_SOCKET_SESSION:
|
|
domain = SOCK_STREAM;
|
|
proto = IPPROTO_TCP;
|
|
break;
|
|
default:
|
|
fatalx("ldp_create_socket: unknown socket type");
|
|
}
|
|
fd = socket(af, domain | SOCK_NONBLOCK | SOCK_CLOEXEC, proto);
|
|
if (fd == -1) {
|
|
log_warn("%s: error creating socket", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
/* bind to a local address/port */
|
|
switch (type) {
|
|
case LDP_SOCKET_DISC:
|
|
/* listen on all addresses */
|
|
memset(&addr, 0, sizeof(addr));
|
|
memcpy(&local_sa, addr2sa(af, &addr, LDP_PORT),
|
|
sizeof(local_sa));
|
|
break;
|
|
case LDP_SOCKET_EDISC:
|
|
case LDP_SOCKET_SESSION:
|
|
addr = (ldp_af_conf_get(ldpd_conf, af))->trans_addr;
|
|
memcpy(&local_sa, addr2sa(af, &addr, LDP_PORT),
|
|
sizeof(local_sa));
|
|
if (sock_set_bindany(fd, 1) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
break;
|
|
}
|
|
if (sock_set_reuse(fd, 1) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (bind(fd, (struct sockaddr *)&local_sa, local_sa.ss_len) == -1) {
|
|
log_warn("%s: error binding socket", __func__);
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
|
|
/* set options */
|
|
switch (af) {
|
|
case AF_INET:
|
|
if (sock_set_ipv4_tos(fd, IPTOS_PREC_INTERNETCONTROL) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (type == LDP_SOCKET_DISC) {
|
|
if (sock_set_ipv4_mcast_ttl(fd,
|
|
IP_DEFAULT_MULTICAST_TTL) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (sock_set_ipv4_mcast_loop(fd) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
if (type == LDP_SOCKET_DISC || type == LDP_SOCKET_EDISC) {
|
|
if (sock_set_ipv4_recvif(fd, 1) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
if (type == LDP_SOCKET_SESSION) {
|
|
if (sock_set_ipv4_ucast_ttl(fd, 255) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
case AF_INET6:
|
|
if (sock_set_ipv6_dscp(fd, IPTOS_PREC_INTERNETCONTROL) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (type == LDP_SOCKET_DISC) {
|
|
if (sock_set_ipv6_mcast_loop(fd) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (sock_set_ipv6_mcast_hops(fd, 255) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
if (!(ldpd_conf->ipv6.flags & F_LDPD_AF_NO_GTSM)) {
|
|
if (sock_set_ipv6_minhopcount(fd, 255) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
}
|
|
if (type == LDP_SOCKET_DISC || type == LDP_SOCKET_EDISC) {
|
|
if (sock_set_ipv6_pktinfo(fd, 1) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
if (type == LDP_SOCKET_SESSION) {
|
|
if (sock_set_ipv6_ucast_hops(fd, 255) == -1) {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
switch (type) {
|
|
case LDP_SOCKET_DISC:
|
|
case LDP_SOCKET_EDISC:
|
|
sock_set_recvbuf(fd);
|
|
break;
|
|
case LDP_SOCKET_SESSION:
|
|
if (listen(fd, LDP_BACKLOG) == -1)
|
|
log_warn("%s: error listening on socket", __func__);
|
|
|
|
opt = 1;
|
|
if (setsockopt(fd, IPPROTO_TCP, TCP_MD5SIG, &opt,
|
|
sizeof(opt)) == -1) {
|
|
if (errno == ENOPROTOOPT) { /* system w/o md5sig */
|
|
log_warnx("md5sig not available, disabling");
|
|
sysdep.no_md5sig = 1;
|
|
} else {
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return (fd);
|
|
}
|
|
|
|
void
|
|
sock_set_recvbuf(int fd)
|
|
{
|
|
int bsize;
|
|
|
|
bsize = 65535;
|
|
while (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bsize,
|
|
sizeof(bsize)) == -1)
|
|
bsize /= 2;
|
|
}
|
|
|
|
int
|
|
sock_set_reuse(int fd, int enable)
|
|
{
|
|
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &enable,
|
|
sizeof(int)) == -1) {
|
|
log_warn("%s: error setting SO_REUSEADDR", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_bindany(int fd, int enable)
|
|
{
|
|
if (setsockopt(fd, SOL_SOCKET, SO_BINDANY, &enable,
|
|
sizeof(int)) == -1) {
|
|
log_warn("%s: error setting SO_BINDANY", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_tos(int fd, int tos)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IP, IP_TOS, (int *)&tos, sizeof(tos)) == -1) {
|
|
log_warn("%s: error setting IP_TOS to 0x%x", __func__, tos);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_recvif(int fd, int enable)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IP, IP_RECVIF, &enable,
|
|
sizeof(enable)) == -1) {
|
|
log_warn("%s: error setting IP_RECVIF", __func__);
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_minttl(int fd, int ttl)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IP, IP_MINTTL, &ttl, sizeof(ttl)) == -1) {
|
|
log_warn("%s: error setting IP_MINTTL", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_ucast_ttl(int fd, int ttl)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) == -1) {
|
|
log_warn("%s: error setting IP_TTL", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_mcast_ttl(int fd, uint8_t ttl)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL,
|
|
(char *)&ttl, sizeof(ttl)) == -1) {
|
|
log_warn("%s: error setting IP_MULTICAST_TTL to %d",
|
|
__func__, ttl);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_mcast(struct iface *iface)
|
|
{
|
|
in_addr_t addr;
|
|
|
|
addr = if_get_ipv4_addr(iface);
|
|
|
|
if (setsockopt(global.ipv4.ldp_disc_socket, IPPROTO_IP, IP_MULTICAST_IF,
|
|
&addr, sizeof(addr)) == -1) {
|
|
log_warn("%s: error setting IP_MULTICAST_IF, interface %s",
|
|
__func__, iface->name);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv4_mcast_loop(int fd)
|
|
{
|
|
uint8_t loop = 0;
|
|
|
|
if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
|
|
(char *)&loop, sizeof(loop)) == -1) {
|
|
log_warn("%s: error setting IP_MULTICAST_LOOP", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_dscp(int fd, int dscp)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &dscp,
|
|
sizeof(dscp)) == -1) {
|
|
log_warn("%s: error setting IPV6_TCLASS", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_pktinfo(int fd, int enable)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &enable,
|
|
sizeof(enable)) == -1) {
|
|
log_warn("%s: error setting IPV6_RECVPKTINFO", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_minhopcount(int fd, int hoplimit)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MINHOPCOUNT,
|
|
&hoplimit, sizeof(hoplimit)) == -1) {
|
|
log_warn("%s: error setting IPV6_MINHOPCOUNT", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_ucast_hops(int fd, int hoplimit)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
|
|
&hoplimit, sizeof(hoplimit)) == -1) {
|
|
log_warn("%s: error setting IPV6_UNICAST_HOPS", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_mcast_hops(int fd, int hoplimit)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
|
|
&hoplimit, sizeof(hoplimit)) == -1) {
|
|
log_warn("%s: error setting IPV6_MULTICAST_HOPS", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_mcast(struct iface *iface)
|
|
{
|
|
if (setsockopt(global.ipv6.ldp_disc_socket, IPPROTO_IPV6,
|
|
IPV6_MULTICAST_IF, &iface->ifindex, sizeof(iface->ifindex)) == -1) {
|
|
log_warn("%s: error setting IPV6_MULTICAST_IF, interface %s",
|
|
__func__, iface->name);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
sock_set_ipv6_mcast_loop(int fd)
|
|
{
|
|
unsigned int loop = 0;
|
|
|
|
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
|
|
&loop, sizeof(loop)) == -1) {
|
|
log_warn("%s: error setting IPV6_MULTICAST_LOOP", __func__);
|
|
return (-1);
|
|
}
|
|
|
|
return (0);
|
|
}
|