#include <sys/types.h>
#include <stdbool.h>
+#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#if defined(NMRPFLASH_LINUX)
#define NMRPFLASH_AF_PACKET AF_PACKET
#include <linux/if_packet.h>
+#include <netlink/route/addr.h>
+#include <netlink/route/neighbour.h>
#else
#define NMRPFLASH_AF_PACKET AF_LINK
#include <net/if_types.h>
return 0;
}
+static int systemf(const char *fmt, ...)
+{
+ char cmd[1024];
+ int ret;
+ va_list va;
+ va_start(va, fmt);
+
+ ret = vsnprintf(cmd, sizeof(cmd) - 1, fmt, va);
+ if (ret >= sizeof(cmd) - 1) {
+ return -1;
+ }
+
+ ret = system(cmd);
+ va_end(va);
+
+ return ret;
+}
+
#ifndef NMRPFLASH_WINDOWS
static inline bool sockaddr_get_hwaddr(struct sockaddr *sa, uint8_t *hwaddr)
{
}
#ifdef NMRPFLASH_LINUX
-static int open_stp_state(const char *intf)
+static int bridge_stp_state(const char *intf)
{
char name[256];
snprintf(name, sizeof(name), "/sys/class/net/%s/bridge/stp_state", intf);
return open(name, O_RDWR, 0644);
}
-static bool is_stp_enabled(const char *intf)
+static bool bridge_stp_enabled(const char *intf)
{
char c;
- int fd = open_stp_state(intf);
+ int fd = bridge_stp_state(intf);
if (fd == -1) {
return false;
}
return c == '1';
}
-static bool set_stp_enabled(const char *intf, bool enabled)
+static bool bridge_stp(const char *intf, bool enabled)
{
bool ret;
const char *s = enabled ? "1\n" : "0\n";
- int fd = open_stp_state(intf);
+ int fd = bridge_stp_state(intf);
if (fd == -1) {
return false;
}
return ret;
}
+
+static bool xrtnl_addr_set(struct rtnl_addr *ra, uint32_t addr, int (*cb)(struct rtnl_addr*, struct nl_addr*))
+{
+ int err;
+ struct nl_addr *na = nl_addr_build(AF_INET, &addr, 4);
+
+ if (!na) {
+ xperror("nl_addr_build");
+ return false;
+ }
+
+ if ((err = cb(ra, na)) != 0 && verbosity) {
+ nl_perror(err, __func__);
+ }
+ nl_addr_put(na);
+
+ return true;
+}
+
+static struct nl_sock *xnl_socket_route()
+{
+ int err;
+ struct nl_sock *sk = nl_socket_alloc();
+ if (sk) {
+ if (!(err = nl_connect(sk, NETLINK_ROUTE))) {
+ return sk;
+ }
+ nl_socket_free(sk);
+ nl_perror(err, "nl_connect");
+ } else {
+ xperror("nl_socket_alloc");
+ }
+
+ return NULL;
+}
+
+static bool intf_add_del_ip(const char *intf, uint32_t ipaddr, uint32_t ipmask, bool add)
+{
+ struct rtnl_addr *ra = NULL;
+ struct nl_sock *sk = NULL;
+ int err = 1;
+
+ if (!(sk = xnl_socket_route())) {
+ return false;
+ }
+
+ if (!(ra = rtnl_addr_alloc())) {
+ xperror("rtnl_addr_alloc");
+ goto out;
+ }
+
+ rtnl_addr_set_ifindex(ra, if_nametoindex(intf));
+ rtnl_addr_set_prefixlen(ra, bitcount(ipmask));
+
+ if (!xrtnl_addr_set(ra, (ipaddr & ipmask) | ~ipmask, &rtnl_addr_set_broadcast)
+ || !xrtnl_addr_set(ra, ipaddr, &rtnl_addr_set_local)) {
+ goto out;
+ }
+
+ if ((err = add ? rtnl_addr_add(sk, ra, 0) : rtnl_addr_delete(sk, ra, 0)) < 0) {
+ if (add && err == -NLE_EXIST) {
+ err = 0;
+ } else if (add || verbosity > 1) {
+ nl_perror(err, add ? "rtnl_addr_add" : "rtnl_addr_delete");
+ }
+ }
+
+out:
+ rtnl_addr_put(ra);
+ nl_socket_free(sk);
+
+ return !err;
+}
+
+static bool intf_add_del_arp(const char *intf, uint32_t ipaddr, uint8_t *hwaddr, bool add)
+{
+ struct nl_sock *sk;
+ struct rtnl_neigh *neigh;
+ struct nl_addr *mac, *ip;
+ int err = 1;
+
+ sk = NULL;
+ neigh = NULL;
+ mac = ip = NULL;
+
+ if (!(sk = xnl_socket_route())) {
+ goto out;
+ }
+
+ if (!(neigh = rtnl_neigh_alloc())) {
+ xperror("rtnl_neigh_alloc");
+ goto out;
+ }
+
+ if (!(mac = nl_addr_build(AF_PACKET, hwaddr, 6))) {
+ xperror("nl_addr_build");
+ goto out;
+ }
+
+ if (!(ip = nl_addr_build(AF_INET, &ipaddr, 4))) {
+ xperror("nl_addr_build");
+ goto out;
+ }
+
+ rtnl_neigh_set_ifindex(neigh, if_nametoindex(intf));
+ rtnl_neigh_set_dst(neigh, ip);
+
+ err = rtnl_neigh_delete(sk, neigh, 0);
+
+ if (add) {
+ rtnl_neigh_set_lladdr(neigh, mac);
+ rtnl_neigh_set_state(neigh, NUD_PERMANENT);
+ system("arp -an");
+ err = rtnl_neigh_add(sk, neigh, NLM_F_CREATE);
+ system("arp -an");
+ }
+
+ if (err && (add || verbosity > 1)) {
+ nl_perror(err, add ? "rtnl_neigh_add" : "rtnl_neigh_delete");
+ }
+
+out:
+ nl_addr_put(ip);
+ nl_addr_put(mac);
+ rtnl_neigh_put(neigh);
+ nl_socket_free(sk);
+
+ return !err;
+}
+
#endif
-static bool get_intf_info(const char *intf, uint8_t *hwaddr, bool *bridge)
+static bool intf_get_info(const char *intf, uint8_t *hwaddr, bool *bridge)
{
struct ifaddrs *ifas, *ifa;
bool found;
}
}
-static bool get_intf_info(const char *intf, uint8_t *hwaddr, DWORD *index)
+static bool intf_get_info(const char *intf, uint8_t *hwaddr, DWORD *index)
{
PIP_ADAPTER_INFO adapters, adapter;
DWORD ret;
struct ethsock *ethsock_create(const char *intf, uint16_t protocol)
{
char buf[PCAP_ERRBUF_SIZE];
- struct bpf_program fp;
+ struct bpf_program bpf;
struct ethsock *sock;
bool is_bridge;
int err;
}
#ifndef NMRPFLASH_WINDOWS
- err = !get_intf_info(intf, sock->hwaddr, &is_bridge);
+ err = !intf_get_info(intf, sock->hwaddr, &is_bridge);
#else
- err = !get_intf_info(intf, sock->hwaddr, &sock->index);
+ err = !intf_get_info(intf, sock->hwaddr, &sock->index);
#endif
if (err) {
fprintf(stderr, "Failed to get interface info.\n");
}
#endif
- snprintf(buf, sizeof(buf), "ether proto 0x%04x and not ether src %s",
- protocol, mac_to_str(sock->hwaddr));
+ err = pcap_setdirection(sock->pcap, PCAP_D_IN);
+ if (err) {
+ pcap_perror(sock->pcap, "pcap_setdirection");
+ goto cleanup;
+ }
+
+ snprintf(buf, sizeof(buf), "ether proto 0x%04x", protocol);
- err = pcap_compile(sock->pcap, &fp, buf, 0, 0);
+ err = pcap_compile(sock->pcap, &bpf, buf, 0, 0);
if (err) {
pcap_perror(sock->pcap, "pcap_compile");
goto cleanup;
}
- err = pcap_setfilter(sock->pcap, &fp);
- pcap_freecode(&fp);
+ err = pcap_setfilter(sock->pcap, &bpf);
+ pcap_freecode(&bpf);
if (err) {
pcap_perror(sock->pcap, "pcap_setfilter");
#ifdef NMRPFLASH_LINUX
// nmrpflash does not work on bridge interfaces with STP enabled
- if ((sock->stp = is_stp_enabled(intf))) {
- if (!set_stp_enabled(intf, false)) {
+ if ((sock->stp = bridge_stp_enabled(intf))) {
+ if (!bridge_stp(intf, false)) {
fprintf(stderr, "Warning: failed to disable STP on %s.\n", intf);
}
}
#ifdef NMRPFLASH_LINUX
if (sock->stp) {
- set_stp_enabled(sock->intf, true);
+ bridge_stp(sock->intf, true);
}
#endif
if (sock->pcap) {
return 0;
}
-#ifndef NMRPFLASH_WINDOWS
-int ethsock_arp_add(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
-{
- return 0;
-}
-
-int ethsock_arp_del(struct ethsock *sock, struct ethsock_arp_undo **undo)
-{
- return 0;
-}
-#else
static int ethsock_arp(struct ethsock *sock, uint8_t *hwaddr, uint32_t ipaddr, struct ethsock_arp_undo **undo)
{
- DWORD ret;
+#if defined(NMRPFLASH_UNIX) && !defined(NMRPFLASH_LINUX)
+ struct in_addr addr = { .s_addr = ipaddr };
+#elif defined(NMRPFLASH_WINDOWS)
+ DWORD err;
MIB_IPNETROW arp = {
.dwIndex = sock->index,
.dwPhysAddrLen = 6,
};
memcpy(arp.bPhysAddr, hwaddr, 6);
+#endif
if (undo) {
- ret = CreateIpNetEntry(&arp);
- if (ret != NO_ERROR) {
- win_perror2("CreateIpNetEntry", ret);
+#if defined(NMRPFLASH_LINUX)
+ if (!intf_add_del_arp(sock->intf, ipaddr, hwaddr, true)) {
+ return -1;
+ }
+#elif defined(NMRPFLASH_WINDOWS)
+ err = CreateIpNetEntry(&arp);
+ if (err != NO_ERROR) {
+ win_perror2("CreateIpNetEntry", err);
+ return -1;
+ }
+#else
+ if (systemf("arp -s %s %s", inet_ntoa(addr), mac_to_str(hwaddr)) != 0) {
return -1;
}
+#endif
*undo = malloc(sizeof(struct ethsock_arp_undo));
if (!*undo) {
(*undo)->ipaddr = ipaddr;
memcpy((*undo)->hwaddr, hwaddr, 6);
} else {
- DeleteIpNetEntry(&arp);
+#if defined(NMRPFLASH_LINUX)
+ if (!intf_add_del_arp(sock->intf, ipaddr, hwaddr, false)) {
+ return -1;
+ }
+#elif defined(NMRPFLASH_WINDOWS)
+ return DeleteIpNetEntry(&arp) ? 0 : -1;
+#else
+ return systemf("arp -d %s", inet_ntoa(addr));
+#endif
}
return 0;
*undo = NULL;
return ret;
}
-#endif
static bool get_hwaddr_from_pcap(const pcap_if_t *dev, uint8_t *hwaddr)
{
}
#endif
- return get_intf_info(dev->name, hwaddr, NULL);
+ return intf_get_info(dev->name, hwaddr, NULL);
}
int ethsock_list_all(void)
#endif
}
-#ifndef NMRPFLASH_WINDOWS
-static bool set_interface_up(int fd, const char *intf, bool up)
+#if !defined(NMRPFLASH_WINDOWS) && !defined(NMRPFLASH_LINUX)
+static bool intf_up(int fd, const char *intf, bool up)
{
struct ifreq ifr;
strncpy(ifr.ifr_name, intf, IFNAMSIZ);
return true;
}
-
#endif
-int ethsock_ip_add(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo)
+static int ethsock_ip_add_del(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo, bool add)
{
- if (undo && !(*undo = malloc(sizeof(struct ethsock_ip_undo)))) {
- xperror("malloc");
- return -1;
+ int ret, fd;
+
+ if (add && undo) {
+ if (!(*undo = malloc(sizeof(struct ethsock_ip_undo)))) {
+ xperror("malloc");
+ return -1;
+ }
+
+ memset(*undo, 0, sizeof(**undo));
}
- int ret = -1;
- int fd = socket(AF_INET, SOCK_DGRAM, 0);
- if (!fd) {
+ ret = -1;
+ fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (fd < 0) {
sock_perror("socket");
goto out;
}
#ifndef NMRPFLASH_WINDOWS
- // XXX: undo is non-zero only if we're adding an IP
- bool add = undo;
#ifdef NMRPFLASH_LINUX
- struct ifreq ifr;
- strncpy(ifr.ifr_name, sock->intf, IFNAMSIZ);
- // FIXME: automatically determine the next free alias
- strcat(ifr.ifr_name, ":42");
-
if (add) {
- set_addr(&ifr.ifr_addr, ipaddr);
- if (ioctl(fd, SIOCSIFADDR, &ifr) != 0) {
- xperror("ioctl(SIOSIFADDR)");
- goto out;
- }
-
- set_addr(&ifr.ifr_netmask, ipmask);
- if (ioctl(fd, SIOCSIFNETMASK, &ifr) != 0) {
- xperror("ioctl(SIOCSIFNETMASK)");
- goto out;
- }
-
(*undo)->ip[0] = ipaddr;
(*undo)->ip[1] = ipmask;
}
- if (!set_interface_up(fd, ifr.ifr_name, add)) {
+ if (!intf_add_del_ip(sock->intf, (*undo)->ip[0], (*undo)->ip[1], add)) {
goto out;
}
#else // NMRPFLASH_OSX (or any other BSD)
if (add) {
(*undo)->ip[0] = ipaddr;
(*undo)->ip[1] = ipmask;
- set_interface_up(fd, ifra.ifra_name, true);
+ intf_up(fd, ifra.ifra_name, true);
}
#endif
return ret;
}
+int ethsock_ip_add(struct ethsock *sock, uint32_t ipaddr, uint32_t ipmask, struct ethsock_ip_undo **undo)
+{
+ return ethsock_ip_add_del(sock, ipaddr, ipmask, undo, true);
+}
+
int ethsock_ip_del(struct ethsock *sock, struct ethsock_ip_undo **undo)
{
if (!*undo) {
#ifndef NMRPFLASH_WINDOWS
if ((*undo)->ip[0] != INADDR_NONE) {
- ret = ethsock_ip_add(sock, (*undo)->ip[0], (*undo)->ip[1], NULL);
+ ret = ethsock_ip_add_del(sock, (*undo)->ip[0], (*undo)->ip[1], undo, false);
} else {
ret = 0;
}
#else
- DeleteIPAddress((*undo)->context);
- ret = 0;
+ ret = DeleteIPAddress((*undo)->context) ? 0 : -1;
#endif
free(*undo);
projects / oweals / nmrpflash.git / blobdiff