[thirdparty/hostap.git] / src / ap / ndisc_snoop.c

/*
 * Neighbor Discovery snooping for Proxy ARP
 * Copyright (c) 2014, Qualcomm Atheros, Inc.
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "utils/includes.h"
#include <netinet/ip6.h>
#include <netinet/icmp6.h>

#include "utils/common.h"
#include "l2_packet/l2_packet.h"
#include "hostapd.h"
#include "sta_info.h"
#include "ap_drv_ops.h"
#include "list.h"
#include "x_snoop.h"
#include "ndisc_snoop.h"

struct ip6addr {
	struct in6_addr addr;
	struct dl_list list;
};

struct icmpv6_ndmsg {
	struct ip6_hdr ipv6h;
	struct icmp6_hdr icmp6h;
	struct in6_addr target_addr;
	u8 opt_type;
	u8 len;
	u8 opt_lladdr[0];
} STRUCT_PACKED;

#define ROUTER_ADVERTISEMENT	134
#define NEIGHBOR_SOLICITATION	135
#define NEIGHBOR_ADVERTISEMENT	136
#define SOURCE_LL_ADDR		1

static int sta_ip6addr_add(struct sta_info *sta, struct in6_addr *addr)
{
	struct ip6addr *ip6addr;

	ip6addr = os_zalloc(sizeof(*ip6addr));
	if (!ip6addr)
		return -1;

	os_memcpy(&ip6addr->addr, addr, sizeof(*addr));

	dl_list_add_tail(&sta->ip6addr, &ip6addr->list);

	return 0;
}


void sta_ip6addr_del(struct hostapd_data *hapd, struct sta_info *sta)
{
	struct ip6addr *ip6addr, *prev;

	dl_list_for_each_safe(ip6addr, prev, &sta->ip6addr, struct ip6addr,
			      list) {
		hostapd_drv_br_delete_ip_neigh(hapd, 6, (u8 *) &ip6addr->addr);
		os_free(ip6addr);
	}
}


static int sta_has_ip6addr(struct sta_info *sta, struct in6_addr *addr)
{
	struct ip6addr *ip6addr;

	dl_list_for_each(ip6addr, &sta->ip6addr, struct ip6addr, list) {
		if (ip6addr->addr.s6_addr32[0] == addr->s6_addr32[0] &&
		    ip6addr->addr.s6_addr32[1] == addr->s6_addr32[1] &&
		    ip6addr->addr.s6_addr32[2] == addr->s6_addr32[2] &&
		    ip6addr->addr.s6_addr32[3] == addr->s6_addr32[3])
			return 1;
	}

	return 0;
}


static void ucast_to_stas(struct hostapd_data *hapd, const u8 *buf, size_t len)
{
	struct sta_info *sta;

	for (sta = hapd->sta_list; sta; sta = sta->next) {
		if (!(sta->flags & WLAN_STA_AUTHORIZED))
			continue;
		x_snoop_mcast_to_ucast_convert_send(hapd, sta, (u8 *) buf, len);
	}
}


static void handle_ndisc(void *ctx, const u8 *src_addr, const u8 *buf,
			 size_t len)
{
	struct hostapd_data *hapd = ctx;
	struct icmpv6_ndmsg *msg;
	struct in6_addr saddr;
	struct sta_info *sta;
	int res;
	char addrtxt[INET6_ADDRSTRLEN + 1];

	if (len < ETH_HLEN + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr))
		return;
	msg = (struct icmpv6_ndmsg *) &buf[ETH_HLEN];
	switch (msg->icmp6h.icmp6_type) {
	case NEIGHBOR_SOLICITATION:
		if (len < ETH_HLEN + sizeof(*msg))
			return;
		if (msg->opt_type != SOURCE_LL_ADDR)
			return;

		/*
		 * IPv6 header may not be 32-bit aligned in the buffer, so use
		 * a local copy to avoid unaligned reads.
		 */
		os_memcpy(&saddr, &msg->ipv6h.ip6_src, sizeof(saddr));
		if (!(saddr.s6_addr32[0] == 0 && saddr.s6_addr32[1] == 0 &&
		      saddr.s6_addr32[2] == 0 && saddr.s6_addr32[3] == 0)) {
			if (len < ETH_HLEN + sizeof(*msg) + ETH_ALEN)
				return;
			sta = ap_get_sta(hapd, msg->opt_lladdr);
			if (!sta)
				return;

			if (sta_has_ip6addr(sta, &saddr))
				return;

			if (inet_ntop(AF_INET6, &saddr, addrtxt,
				      sizeof(addrtxt)) == NULL)
				addrtxt[0] = '\0';
			wpa_printf(MSG_DEBUG, "ndisc_snoop: Learned new IPv6 address %s for "
				   MACSTR, addrtxt, MAC2STR(sta->addr));
			hostapd_drv_br_delete_ip_neigh(hapd, 6, (u8 *) &saddr);
			res = hostapd_drv_br_add_ip_neigh(hapd, 6,
							  (u8 *) &saddr,
							  128, sta->addr);
			if (res) {
				wpa_printf(MSG_ERROR,
					   "ndisc_snoop: Adding ip neigh failed: %d",
					   res);
				return;
			}

			if (sta_ip6addr_add(sta, &saddr))
				return;
		}
		break;
	case ROUTER_ADVERTISEMENT:
		if (hapd->conf->disable_dgaf)
			ucast_to_stas(hapd, buf, len);
		break;
	case NEIGHBOR_ADVERTISEMENT:
		if (hapd->conf->na_mcast_to_ucast)
			ucast_to_stas(hapd, buf, len);
		break;
	default:
		break;
	}
}


int ndisc_snoop_init(struct hostapd_data *hapd)
{
	hapd->sock_ndisc = x_snoop_get_l2_packet(hapd, handle_ndisc,
						 L2_PACKET_FILTER_NDISC);
	if (hapd->sock_ndisc == NULL) {
		wpa_printf(MSG_DEBUG,
			   "ndisc_snoop: Failed to initialize L2 packet processing for NDISC packets: %s",
			   strerror(errno));
		return -1;
	}

	return 0;
}


void ndisc_snoop_deinit(struct hostapd_data *hapd)
{
	l2_packet_deinit(hapd->sock_ndisc);
	hapd->sock_ndisc = NULL;
}
Commit	Line	Data
bd00c431 KP	1	/*
	2	* Neighbor Discovery snooping for Proxy ARP
	3	* Copyright (c) 2014, Qualcomm Atheros, Inc.
	4	*
	5	* This software may be distributed under the terms of the BSD license.
	6	* See README for more details.
	7	*/
	8
	9	#include "utils/includes.h"
a437378f JM	10	#include <netinet/ip6.h>
a437378f JM	11	#include <netinet/icmp6.h>
bd00c431 KP	12
	13	#include "utils/common.h"
	14	#include "l2_packet/l2_packet.h"
	15	#include "hostapd.h"
	16	#include "sta_info.h"
	17	#include "ap_drv_ops.h"
	18	#include "list.h"
	19	#include "x_snoop.h"
bbae0f03	20	#include "ndisc_snoop.h"
bd00c431 KP	21
	22	struct ip6addr {
	23	struct in6_addr addr;
	24	struct dl_list list;
	25	};
	26
	27	struct icmpv6_ndmsg {
a437378f JM	28	struct ip6_hdr ipv6h;
a437378f JM	29	struct icmp6_hdr icmp6h;
bd00c431 KP	30	struct in6_addr target_addr;
	31	u8 opt_type;
	32	u8 len;
	33	u8 opt_lladdr[0];
a7fb5ea4	34	} STRUCT_PACKED;
bd00c431	35
47261405	36	#define ROUTER_ADVERTISEMENT 134
bd00c431 KP	37	#define NEIGHBOR_SOLICITATION 135
	38	#define NEIGHBOR_ADVERTISEMENT 136
	39	#define SOURCE_LL_ADDR 1
	40
	41	static int sta_ip6addr_add(struct sta_info sta, struct in6_addr addr)
	42	{
	43	struct ip6addr *ip6addr;
	44
	45	ip6addr = os_zalloc(sizeof(*ip6addr));
	46	if (!ip6addr)
	47	return -1;
	48
	49	os_memcpy(&ip6addr->addr, addr, sizeof(*addr));
	50
	51	dl_list_add_tail(&sta->ip6addr, &ip6addr->list);
	52
	53	return 0;
	54	}
	55
	56
	57	void sta_ip6addr_del(struct hostapd_data hapd, struct sta_info sta)
	58	{
	59	struct ip6addr ip6addr, prev;
	60
	61	dl_list_for_each_safe(ip6addr, prev, &sta->ip6addr, struct ip6addr,
	62	list) {
	63	hostapd_drv_br_delete_ip_neigh(hapd, 6, (u8 *) &ip6addr->addr);
	64	os_free(ip6addr);
	65	}
	66	}
	67
	68
	69	static int sta_has_ip6addr(struct sta_info sta, struct in6_addr addr)
	70	{
	71	struct ip6addr *ip6addr;
	72
	73	dl_list_for_each(ip6addr, &sta->ip6addr, struct ip6addr, list) {
	74	if (ip6addr->addr.s6_addr32[0] == addr->s6_addr32[0] &&
	75	ip6addr->addr.s6_addr32[1] == addr->s6_addr32[1] &&
	76	ip6addr->addr.s6_addr32[2] == addr->s6_addr32[2] &&
	77	ip6addr->addr.s6_addr32[3] == addr->s6_addr32[3])
	78	return 1;
	79	}
	80
	81	return 0;
	82	}
	83
	84
4a7ce984 JM	85	static void ucast_to_stas(struct hostapd_data hapd, const u8 buf, size_t len)
	86	{
	87	struct sta_info *sta;
	88
	89	for (sta = hapd->sta_list; sta; sta = sta->next) {
	90	if (!(sta->flags & WLAN_STA_AUTHORIZED))
	91	continue;
	92	x_snoop_mcast_to_ucast_convert_send(hapd, sta, (u8 *) buf, len);
	93	}
	94	}
	95
	96
bd00c431 KP	97	static void handle_ndisc(void ctx, const u8 src_addr, const u8 *buf,
	98	size_t len)
	99	{
	100	struct hostapd_data *hapd = ctx;
	101	struct icmpv6_ndmsg *msg;
cf6fd19b	102	struct in6_addr saddr;
bd00c431 KP	103	struct sta_info *sta;
bd00c431 KP	104	int res;
a6b4ee21	105	char addrtxt[INET6_ADDRSTRLEN + 1];
bd00c431	106
8c5043b4	107	if (len < ETH_HLEN + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr))
bd00c431 KP	108	return;
	109	msg = (struct icmpv6_ndmsg *) &buf[ETH_HLEN];
	110	switch (msg->icmp6h.icmp6_type) {
	111	case NEIGHBOR_SOLICITATION:
8c5043b4 JM	112	if (len < ETH_HLEN + sizeof(*msg))
8c5043b4 JM	113	return;
bd00c431 KP	114	if (msg->opt_type != SOURCE_LL_ADDR)
	115	return;
	116
cf6fd19b JM	117	/*
	118	* IPv6 header may not be 32-bit aligned in the buffer, so use
	119	* a local copy to avoid unaligned reads.
	120	*/
	121	os_memcpy(&saddr, &msg->ipv6h.ip6_src, sizeof(saddr));
	122	if (!(saddr.s6_addr32[0] == 0 && saddr.s6_addr32[1] == 0 &&
	123	saddr.s6_addr32[2] == 0 && saddr.s6_addr32[3] == 0)) {
bd00c431 KP	124	if (len < ETH_HLEN + sizeof(*msg) + ETH_ALEN)
	125	return;
	126	sta = ap_get_sta(hapd, msg->opt_lladdr);
	127	if (!sta)
	128	return;
	129
cf6fd19b	130	if (sta_has_ip6addr(sta, &saddr))
bd00c431 KP	131	return;
bd00c431 KP	132
cf6fd19b JM	133	if (inet_ntop(AF_INET6, &saddr, addrtxt,
cf6fd19b JM	134	sizeof(addrtxt)) == NULL)
a6b4ee21 JM	135	addrtxt[0] = '\0';
	136	wpa_printf(MSG_DEBUG, "ndisc_snoop: Learned new IPv6 address %s for "
	137	MACSTR, addrtxt, MAC2STR(sta->addr));
cf6fd19b JM	138	hostapd_drv_br_delete_ip_neigh(hapd, 6, (u8 *) &saddr);
	139	res = hostapd_drv_br_add_ip_neigh(hapd, 6,
	140	(u8 *) &saddr,
bd00c431 KP	141	128, sta->addr);
	142	if (res) {
	143	wpa_printf(MSG_ERROR,
	144	"ndisc_snoop: Adding ip neigh failed: %d",
	145	res);
	146	return;
	147	}
	148
cf6fd19b	149	if (sta_ip6addr_add(sta, &saddr))
bd00c431 KP	150	return;
	151	}
	152	break;
47261405	153	case ROUTER_ADVERTISEMENT:
4a7ce984 JM	154	if (hapd->conf->disable_dgaf)
	155	ucast_to_stas(hapd, buf, len);
	156	break;
bd00c431	157	case NEIGHBOR_ADVERTISEMENT:
4a7ce984 JM	158	if (hapd->conf->na_mcast_to_ucast)
4a7ce984 JM	159	ucast_to_stas(hapd, buf, len);
bd00c431 KP	160	break;
	161	default:
	162	break;
	163	}
	164	}
	165
	166
	167	int ndisc_snoop_init(struct hostapd_data *hapd)
	168	{
	169	hapd->sock_ndisc = x_snoop_get_l2_packet(hapd, handle_ndisc,
	170	L2_PACKET_FILTER_NDISC);
	171	if (hapd->sock_ndisc == NULL) {
	172	wpa_printf(MSG_DEBUG,
	173	"ndisc_snoop: Failed to initialize L2 packet processing for NDISC packets: %s",
	174	strerror(errno));
	175	return -1;
	176	}
	177
	178	return 0;
	179	}
	180
	181
	182	void ndisc_snoop_deinit(struct hostapd_data *hapd)
	183	{
	184	l2_packet_deinit(hapd->sock_ndisc);
d4359923	185	hapd->sock_ndisc = NULL;
bd00c431	186	}