497 lines
12 KiB
C
497 lines
12 KiB
C
/*
|
|
* Copyright (C) 2010-2014 Martin Willi
|
|
* Copyright (C) 2010-2014 revosec AG
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
|
*
|
|
* This program 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 General Public License
|
|
* for more details.
|
|
*/
|
|
|
|
#include "forecast_forwarder.h"
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <netinet/ip.h>
|
|
#include <netinet/udp.h>
|
|
#include <linux/socket.h>
|
|
#include <netinet/if_ether.h>
|
|
#include <linux/if_packet.h>
|
|
#include <linux/filter.h>
|
|
#include <sys/ioctl.h>
|
|
#include <ifaddrs.h>
|
|
#include <net/if.h>
|
|
|
|
#include <hydra.h>
|
|
#include <daemon.h>
|
|
#include <threading/thread.h>
|
|
#include <processing/jobs/callback_job.h>
|
|
|
|
#define BOOTP_SERVER_PORT 67
|
|
#define BOOTP_CLIENT_PORT 68
|
|
|
|
typedef struct private_forecast_forwarder_t private_forecast_forwarder_t;
|
|
typedef struct private_kernel_listener_t private_kernel_listener_t;
|
|
|
|
/**
|
|
* Private data of registered kernel listener
|
|
*/
|
|
struct private_kernel_listener_t {
|
|
|
|
/**
|
|
* Implements kernel_listener_t
|
|
*/
|
|
kernel_listener_t listener;
|
|
|
|
/**
|
|
* Listener that knows active addresses
|
|
*/
|
|
forecast_listener_t *fc;
|
|
|
|
/**
|
|
* current broadcast address of internal network
|
|
*/
|
|
u_int32_t broadcast;
|
|
|
|
/**
|
|
* LAN interface index
|
|
*/
|
|
int ifindex;
|
|
|
|
/**
|
|
* Packet socket
|
|
*/
|
|
int pkt;
|
|
|
|
/**
|
|
* RAW socket
|
|
*/
|
|
int raw;
|
|
};
|
|
|
|
/**
|
|
* Private data of an forecast_forwarder_t object.
|
|
*/
|
|
struct private_forecast_forwarder_t {
|
|
|
|
/**
|
|
* Public forecast_forwarder_t interface.
|
|
*/
|
|
forecast_forwarder_t public;
|
|
|
|
/**
|
|
* Public kernel_listener_t interface.
|
|
*/
|
|
private_kernel_listener_t kernel;
|
|
};
|
|
|
|
/**
|
|
* Send a broadcast/multicast packet to a network
|
|
*/
|
|
static void send_net(private_forecast_forwarder_t *this,
|
|
struct sockaddr_ll *addr, void *buf, size_t len)
|
|
{
|
|
if (sendto(this->kernel.pkt, buf, len, 0,
|
|
(struct sockaddr*)addr, sizeof(*addr)) != len)
|
|
{
|
|
DBG1(DBG_NET, "forecast send_net() failed: %s", strerror(errno));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send a broadcast/multicast packet to a peer
|
|
*/
|
|
static void send_peer(private_forecast_forwarder_t *this, u_int32_t dst,
|
|
void *buf, size_t len, int mark)
|
|
{
|
|
struct sockaddr_in addr = {
|
|
.sin_family = AF_INET,
|
|
.sin_addr.s_addr = dst,
|
|
};
|
|
|
|
if (setsockopt(this->kernel.raw, SOL_SOCKET, SO_MARK,
|
|
&mark, sizeof(mark)) != 0)
|
|
{
|
|
DBG1(DBG_NET, "forecast setting SO_MARK failed: %s", strerror(errno));
|
|
}
|
|
if (sendto(this->kernel.raw, buf, len, 0,
|
|
(struct sockaddr*)&addr, sizeof(addr)) != len)
|
|
{
|
|
DBG1(DBG_NET, "forecast send_peer() failed: %s", strerror(errno));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if an IP packet is BOOTP/DHCP
|
|
*/
|
|
static bool is_bootp(void *buf, size_t len)
|
|
{
|
|
struct __attribute__((__packed__)) {
|
|
struct iphdr ip;
|
|
struct udphdr udp;
|
|
} *pkt = buf;
|
|
|
|
if (len > sizeof(*pkt))
|
|
{
|
|
if (ntohs(pkt->udp.source) == BOOTP_CLIENT_PORT &&
|
|
ntohs(pkt->udp.dest) == BOOTP_SERVER_PORT)
|
|
{
|
|
return TRUE;
|
|
}
|
|
if (ntohs(pkt->udp.source) == BOOTP_SERVER_PORT &&
|
|
ntohs(pkt->udp.dest) == BOOTP_CLIENT_PORT)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Broadcast/Multicast receiver
|
|
*/
|
|
static bool receive_casts(private_forecast_forwarder_t *this)
|
|
{
|
|
struct __attribute__((packed)) {
|
|
struct iphdr hdr;
|
|
char data[2048];
|
|
} buf;
|
|
char *type;
|
|
ssize_t len;
|
|
u_int mark, origin = 0;
|
|
host_t *src, *dst;
|
|
traffic_selector_t *ts;
|
|
enumerator_t *enumerator;
|
|
struct sockaddr_ll addr;
|
|
socklen_t alen = sizeof(addr);
|
|
bool reinject;
|
|
|
|
len = recvfrom(this->kernel.pkt, &buf, sizeof(buf), MSG_DONTWAIT,
|
|
(struct sockaddr*)&addr, &alen);
|
|
if (len < 0)
|
|
{
|
|
if (errno != EAGAIN && errno != EWOULDBLOCK)
|
|
{
|
|
DBG1(DBG_NET, "receiving from forecast socket failed: %s",
|
|
strerror(errno));
|
|
}
|
|
return TRUE;
|
|
}
|
|
else if (len < sizeof(struct iphdr))
|
|
{
|
|
DBG1(DBG_NET, "received short forecast packet: %zd bytes", len);
|
|
return TRUE;
|
|
}
|
|
if (is_bootp(&buf, len))
|
|
{ /* don't forward DHCP broadcasts */
|
|
return TRUE;
|
|
}
|
|
|
|
src = host_create_from_chunk(AF_INET, chunk_from_thing(buf.hdr.saddr), 0);
|
|
dst = host_create_from_chunk(AF_INET, chunk_from_thing(buf.hdr.daddr), 0);
|
|
|
|
/* create valid broadcast/multicast MAC to send out */
|
|
if (IN_MULTICAST(ntohl(buf.hdr.daddr)))
|
|
{
|
|
type = "multi";
|
|
ETHER_MAP_IP_MULTICAST(&buf.hdr.daddr, addr.sll_addr);
|
|
}
|
|
else
|
|
{
|
|
type = "broad";
|
|
memset(&addr.sll_addr, 0xFF, sizeof(addr.sll_addr));
|
|
}
|
|
DBG2(DBG_NET, "forecast intercepted packet: %H to %H", src, dst);
|
|
|
|
/* find mark of originating tunnel */
|
|
enumerator = this->kernel.fc->create_enumerator(this->kernel.fc, FALSE);
|
|
while (enumerator->enumerate(enumerator, &ts, &mark, &reinject))
|
|
{
|
|
if (ts->includes(ts, src))
|
|
{
|
|
origin = mark;
|
|
break;
|
|
}
|
|
}
|
|
enumerator->destroy(enumerator);
|
|
|
|
/* send packet over all tunnels, but not the packets origin */
|
|
enumerator = this->kernel.fc->create_enumerator(this->kernel.fc, FALSE);
|
|
while (enumerator->enumerate(enumerator, &ts, &mark, &reinject))
|
|
{
|
|
if (ts->includes(ts, dst))
|
|
{
|
|
if ((reinject && origin != mark) || origin == 0)
|
|
{
|
|
DBG2(DBG_NET, "forwarding a %H %scast from %H to peer %R (%u)",
|
|
dst, type, src, ts, mark);
|
|
send_peer(this, buf.hdr.daddr, &buf, len, mark);
|
|
}
|
|
}
|
|
}
|
|
enumerator->destroy(enumerator);
|
|
|
|
if (origin)
|
|
{
|
|
/* forward broadcast/multicast from client to network */
|
|
DBG2(DBG_NET, "forwarding a %H %scast from peer %H to internal network",
|
|
dst, type, src);
|
|
addr.sll_ifindex = this->kernel.ifindex;
|
|
send_net(this, &addr, &buf, len);
|
|
}
|
|
|
|
dst->destroy(dst);
|
|
src->destroy(src);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Join a multicast group
|
|
*/
|
|
static void join_group(private_kernel_listener_t *this, char *group,
|
|
struct sockaddr *addr)
|
|
{
|
|
struct sockaddr_in *in;
|
|
struct ip_mreqn mreq;
|
|
host_t *host;
|
|
|
|
host = host_create_from_string(group, 0);
|
|
if (host)
|
|
{
|
|
memset(&mreq, 0, sizeof(mreq));
|
|
memcpy(&mreq.imr_multiaddr.s_addr, host->get_address(host).ptr, 4);
|
|
if (addr->sa_family == AF_INET)
|
|
{
|
|
in = (struct sockaddr_in*)addr;
|
|
memcpy(&mreq.imr_address, &in->sin_addr.s_addr,
|
|
sizeof(in->sin_addr.s_addr));
|
|
}
|
|
mreq.imr_ifindex = this->ifindex;
|
|
if (setsockopt(this->raw, IPPROTO_IP, IP_ADD_MEMBERSHIP,
|
|
&mreq, sizeof(mreq)) == -1)
|
|
{
|
|
if (errno != EADDRINUSE)
|
|
{
|
|
DBG1(DBG_NET, "forecast multicast join to %s failed: %s",
|
|
group, strerror(errno));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DBG2(DBG_NET, "forwarding multicast group %s", group);
|
|
}
|
|
host->destroy(host);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* (Re-)Join all multicast groups we want to forward
|
|
*/
|
|
static void join_groups(private_kernel_listener_t *this, struct sockaddr *addr)
|
|
{
|
|
enumerator_t *enumerator;
|
|
char *groups, *group;
|
|
static char *def =
|
|
"224.0.0.1," /* host multicast */
|
|
"224.0.0.22," /* IGMP */
|
|
"224.0.0.251," /* mDNS */
|
|
"224.0.0.252," /* LLMNR */
|
|
"239.255.255.250"; /* SSDP/WS-discovery */
|
|
|
|
groups = lib->settings->get_str(lib->settings,
|
|
"%s.plugins.forecast.groups", def, lib->ns);
|
|
DBG1(DBG_CFG, "joining forecast multicast groups: %s", groups);
|
|
enumerator = enumerator_create_token(groups, ",", " ");
|
|
while (enumerator->enumerate(enumerator, &group))
|
|
{
|
|
join_group(this, group, addr);
|
|
}
|
|
enumerator->destroy(enumerator);
|
|
}
|
|
|
|
/**
|
|
* Attach the socket filter to the socket
|
|
*/
|
|
static bool attach_filter(int fd, u_int32_t broadcast)
|
|
{
|
|
struct sock_filter filter_code[] = {
|
|
/* destination address: is ... */
|
|
BPF_STMT(BPF_LD+BPF_W+BPF_ABS, offsetof(struct iphdr, daddr)),
|
|
/* broadcast, as received from the local network */
|
|
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ntohl(broadcast), 4, 0),
|
|
/* broadcast, as Win7 sends them */
|
|
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xFFFFFFFF, 3, 0),
|
|
/* any multicast, 224.0.0.0/4 */
|
|
BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xF0000000),
|
|
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0xE0000000, 1, 0),
|
|
BPF_STMT(BPF_RET+BPF_K, 0),
|
|
BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0),
|
|
BPF_STMT(BPF_RET+BPF_A, 0),
|
|
};
|
|
struct sock_fprog filter = {
|
|
sizeof(filter_code) / sizeof(struct sock_filter),
|
|
filter_code,
|
|
};
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER,
|
|
&filter, sizeof(filter)) < 0)
|
|
{
|
|
DBG1(DBG_NET, "installing forecast PACKET socket filter failed: %s",
|
|
strerror(errno));
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Get the interface index of an interface name
|
|
*/
|
|
static int get_ifindex(private_kernel_listener_t *this, char *ifname)
|
|
{
|
|
struct ifreq ifr = {};
|
|
|
|
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
|
|
if (ioctl(this->raw, SIOCGIFINDEX, &ifr) == 0)
|
|
{
|
|
return ifr.ifr_ifindex;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Set up the interface for broad/multicast forwarding
|
|
*/
|
|
static void setup_interface(private_kernel_listener_t *this)
|
|
{
|
|
struct ifaddrs *addrs, *current;
|
|
struct sockaddr_in *in;
|
|
host_t *host;
|
|
char *name;
|
|
|
|
name = lib->settings->get_str(lib->settings,
|
|
"%s.plugins.forecast.interface", NULL, lib->ns);
|
|
if (getifaddrs(&addrs) == 0)
|
|
{
|
|
for (current = addrs; current; current = current->ifa_next)
|
|
{
|
|
if (name && !streq(name, current->ifa_name))
|
|
{
|
|
continue;
|
|
}
|
|
if (current->ifa_flags & IFF_BROADCAST &&
|
|
current->ifa_broadaddr &&
|
|
current->ifa_broadaddr->sa_family == AF_INET)
|
|
{
|
|
DBG1(DBG_NET, "using forecast interface %s", current->ifa_name);
|
|
this->ifindex = get_ifindex(this, current->ifa_name);
|
|
in = (struct sockaddr_in*)current->ifa_broadaddr;
|
|
attach_filter(this->pkt, in->sin_addr.s_addr);
|
|
join_groups(this, current->ifa_addr);
|
|
host = host_create_from_sockaddr(current->ifa_broadaddr);
|
|
if (host)
|
|
{
|
|
this->fc->set_broadcast(this->fc, host);
|
|
host->destroy(host);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
freeifaddrs(addrs);
|
|
}
|
|
|
|
METHOD(kernel_listener_t, roam, bool,
|
|
private_kernel_listener_t *this, bool address)
|
|
{
|
|
if (address)
|
|
{
|
|
setup_interface(this);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
METHOD(forecast_forwarder_t, destroy, void,
|
|
private_forecast_forwarder_t *this)
|
|
{
|
|
if (this->kernel.raw != -1)
|
|
{
|
|
close(this->kernel.raw);
|
|
}
|
|
if (this->kernel.pkt != -1)
|
|
{
|
|
lib->watcher->remove(lib->watcher, this->kernel.pkt);
|
|
close(this->kernel.pkt);
|
|
}
|
|
hydra->kernel_interface->remove_listener(hydra->kernel_interface,
|
|
&this->kernel.listener);
|
|
free(this);
|
|
}
|
|
|
|
/**
|
|
* See header
|
|
*/
|
|
forecast_forwarder_t *forecast_forwarder_create(forecast_listener_t *listener)
|
|
{
|
|
private_forecast_forwarder_t *this;
|
|
int on = 1;
|
|
|
|
INIT(this,
|
|
.public = {
|
|
.destroy = _destroy,
|
|
},
|
|
.kernel = {
|
|
.listener = {
|
|
.roam = _roam,
|
|
},
|
|
.raw = -1,
|
|
.pkt = -1,
|
|
.fc = listener,
|
|
},
|
|
);
|
|
|
|
this->kernel.pkt = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
|
|
if (this->kernel.pkt == -1)
|
|
{
|
|
DBG1(DBG_NET, "opening PACKET socket failed: %s", strerror(errno));
|
|
destroy(this);
|
|
return NULL;
|
|
}
|
|
this->kernel.raw = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
|
|
if (this->kernel.raw == -1)
|
|
{
|
|
DBG1(DBG_NET, "opening RAW socket failed: %s", strerror(errno));
|
|
destroy(this);
|
|
return NULL;
|
|
}
|
|
if (setsockopt(this->kernel.raw, IPPROTO_IP, IP_HDRINCL,
|
|
&on, sizeof(on)) == -1)
|
|
{
|
|
DBG1(DBG_NET, "forecast socket HDRINCL failed: %s", strerror(errno));
|
|
destroy(this);
|
|
return NULL;
|
|
}
|
|
if (setsockopt(this->kernel.raw, SOL_SOCKET, SO_BROADCAST,
|
|
&on, sizeof(on)) == -1)
|
|
{
|
|
DBG1(DBG_NET, "forecast socket BROADCAST failed: %s", strerror(errno));
|
|
destroy(this);
|
|
return NULL;
|
|
}
|
|
|
|
setup_interface(&this->kernel);
|
|
|
|
hydra->kernel_interface->add_listener(hydra->kernel_interface,
|
|
&this->kernel.listener);
|
|
|
|
lib->watcher->add(lib->watcher, this->kernel.pkt, WATCHER_READ,
|
|
(watcher_cb_t)receive_casts, this);
|
|
|
|
return &this->public;
|
|
}
|