The current unicast packet type does not contain the orig source address. This patches add a new unicast packet (called UNICAST_4ADDR) which provides two new fields: the originator source address and the subtype (the type of the data contained in the packet payload). The former is useful to identify the node which injected the packet into the network and the latter is useful to avoid creating new unicast packet types in the future: a macro defining a new subtype will be enough.

Signed-off-by: Antonio Quartulli ordex@autistici.org --- main.c | 2 ++ packet.h | 27 +++++++++++----- routing.c | 8 +++-- unicast.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++----------- unicast.h | 20 +++++++++++- 5 files changed, 130 insertions(+), 29 deletions(-)

diff --git a/main.c b/main.c index 2a1f243..ad0d2fe 100644 --- a/main.c +++ b/main.c @@ -274,6 +274,8 @@ static void batadv_recv_handler_init(void)

/* batman icmp packet */ batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; + /* unicast with 4 addresses packet */ + batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet; /* unicast packet */ batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; /* fragmented unicast packet */ diff --git a/packet.h b/packet.h index db21230..e48f066 100644 --- a/packet.h +++ b/packet.h @@ -23,14 +23,19 @@ #define BATADV_ETH_P_BATMAN 0x4305 /* unofficial/not registered Ethertype */

enum batadv_packettype { - BATADV_IV_OGM = 0x01, - BATADV_ICMP = 0x02, - BATADV_UNICAST = 0x03, - BATADV_BCAST = 0x04, - BATADV_VIS = 0x05, - BATADV_UNICAST_FRAG = 0x06, - BATADV_TT_QUERY = 0x07, - BATADV_ROAM_ADV = 0x08, + BATADV_IV_OGM = 0x01, + BATADV_ICMP = 0x02, + BATADV_UNICAST = 0x03, + BATADV_BCAST = 0x04, + BATADV_VIS = 0x05, + BATADV_UNICAST_FRAG = 0x06, + BATADV_TT_QUERY = 0x07, + BATADV_ROAM_ADV = 0x08, + BATADV_UNICAST_4ADDR = 0x09, +}; + +enum batadv_subtype { + BATADV_P_DATA = 0x01, };

/* this file is included by batctl which needs these defines */ @@ -161,6 +166,12 @@ struct batadv_unicast_packet { uint8_t dest[ETH_ALEN]; } __packed;

+struct batadv_unicast_4addr_packet { + struct batadv_unicast_packet u; + uint8_t src[ETH_ALEN]; + uint8_t subtype; +} __packed; + struct batadv_unicast_frag_packet { struct batadv_header header; uint8_t ttvn; /* destination translation table version number */ diff --git a/routing.c b/routing.c index b043ef9..191f531 100644 --- a/routing.c +++ b/routing.c @@ -1015,14 +1015,18 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, struct batadv_unicast_packet *unicast_packet; int hdr_size = sizeof(*unicast_packet);

+ unicast_packet = (struct batadv_unicast_packet *)skb->data; + + /* the caller function should have already pulled 2 bytes */ + if (unicast_packet->header.packet_type == BATADV_UNICAST_4ADDR) + hdr_size = sizeof(struct batadv_unicast_4addr_packet); + if (batadv_check_unicast_packet(skb, hdr_size) < 0) return NET_RX_DROP;

if (!batadv_check_unicast_ttvn(bat_priv, skb)) return NET_RX_DROP;

- unicast_packet = (struct batadv_unicast_packet *)skb->data; - /* packet for me */ if (batadv_is_my_mac(unicast_packet->dest)) { batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size, diff --git a/unicast.c b/unicast.c index 0016464..b3adbd0 100644 --- a/unicast.c +++ b/unicast.c @@ -288,7 +288,73 @@ out: return ret; }

-int batadv_unicast_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv) +static bool batadv_pull_and_fill_unicast(struct sk_buff *skb, int hdr_size, + struct batadv_orig_node *orig_node) +{ + struct batadv_unicast_packet *unicast_packet; + + if (batadv_skb_head_push(skb, hdr_size) < 0) + return false; + + unicast_packet = (struct batadv_unicast_packet *)skb->data; + unicast_packet->header.version = BATADV_COMPAT_VERSION; + /* batman packet type: unicast */ + unicast_packet->header.packet_type = BATADV_UNICAST; + /* set unicast ttl */ + unicast_packet->header.ttl = BATADV_TTL; + /* copy the destination for faster routing */ + memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN); + /* set the destination tt version number */ + unicast_packet->ttvn = + (uint8_t)atomic_read(&orig_node->last_ttvn); + + return true; +} + +static bool batadv_prepare_unicast_packet(struct sk_buff *skb, + struct batadv_orig_node *orig_node) +{ + size_t uni_size = sizeof(struct batadv_unicast_packet); + return batadv_pull_and_fill_unicast(skb, uni_size, orig_node); +} + +static bool batadv_prepare_unicast_4addr_packet(struct batadv_priv *bat_priv, + struct sk_buff *skb, + struct batadv_orig_node *orig, + int packet_subtype) +{ + struct batadv_hard_iface *primary_if; + struct batadv_unicast_4addr_packet *unicast_4addr_packet; + bool ret = false; + + primary_if = batadv_primary_if_get_selected(bat_priv); + if (!primary_if) + goto out; + + /* pull the header space and fill the unicast_packet substructure. + * We can do that because the first member of the unicast_4addr_packet + * is of type struct unicast_packet + */ + if (!batadv_pull_and_fill_unicast(skb, sizeof(*unicast_4addr_packet), + orig)) + goto out; + + unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; + unicast_4addr_packet->u.header.packet_type = BATADV_UNICAST_4ADDR; + memcpy(unicast_4addr_packet->src, primary_if->net_dev->dev_addr, + ETH_ALEN); + unicast_4addr_packet->subtype = packet_subtype; + + ret = true; +out: + if (primary_if) + batadv_hardif_free_ref(primary_if); + return ret; +} + +int batadv_unicast_generic_send_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv, + int packet_type, int packet_subtype) { struct ethhdr *ethhdr = (struct ethhdr *)skb->data; struct batadv_unicast_packet *unicast_packet; @@ -310,33 +376,32 @@ int batadv_unicast_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv) */ orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source, ethhdr->h_dest); - find_router: /* find_router(): * - if orig_node is NULL it returns NULL * - increases neigh_nodes refcount if found. */ neigh_node = batadv_find_router(bat_priv, orig_node, NULL); - if (!neigh_node) goto out;

- if (batadv_skb_head_push(skb, sizeof(*unicast_packet)) < 0) + switch (packet_type) { + case BATADV_UNICAST: + batadv_prepare_unicast_packet(skb, orig_node); + break; + case BATADV_UNICAST_4ADDR: + batadv_prepare_unicast_4addr_packet(bat_priv, skb, orig_node, + packet_subtype); + break; + default: + /* this function supports UNICAST and UNICAST_4ADDR only. It + * should never be invoked with any other packet type + */ goto out; + }

unicast_packet = (struct batadv_unicast_packet *)skb->data;

- unicast_packet->header.version = BATADV_COMPAT_VERSION; - /* batman packet type: unicast */ - unicast_packet->header.packet_type = BATADV_UNICAST; - /* set unicast ttl */ - unicast_packet->header.ttl = BATADV_TTL; - /* copy the destination for faster routing */ - memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN); - /* set the destination tt version number */ - unicast_packet->ttvn = - (uint8_t)atomic_read(&orig_node->last_ttvn); - /* inform the destination node that we are still missing a correct route * for this client. The destination will receive this packet and will * try to reroute it because the ttvn contained in the header is less @@ -346,8 +411,10 @@ find_router: unicast_packet->ttvn = unicast_packet->ttvn - 1;

dev_mtu = neigh_node->if_incoming->net_dev->mtu; - if (atomic_read(&bat_priv->fragmentation) && - data_len + sizeof(*unicast_packet) > dev_mtu) { + /* fragmentation mechanism only works for UNICAST (now) */ + if (packet_type == BATADV_UNICAST && + atomic_read(&bat_priv->fragmentation) && + data_len + dev_mtu) { /* send frag skb decreases ttl */ unicast_packet->header.ttl++; ret = batadv_frag_send_skb(skb, bat_priv, @@ -358,7 +425,6 @@ find_router:

batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = 0; - goto out;

out: if (neigh_node) diff --git a/unicast.h b/unicast.h index 1c46e2e..23d526e 100644 --- a/unicast.h +++ b/unicast.h @@ -29,10 +29,28 @@ int batadv_frag_reassemble_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, struct sk_buff **new_skb); void batadv_frag_list_free(struct list_head *head); -int batadv_unicast_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv); int batadv_frag_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, struct batadv_hard_iface *hard_iface, const uint8_t dstaddr[]); +int batadv_unicast_generic_send_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv, + int packet_type, int packet_subtype); + +static inline int batadv_unicast_send_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv) +{ + return batadv_unicast_generic_send_skb(skb, bat_priv, BATADV_UNICAST, + 0); +} + +static inline int batadv_unicast_4addr_send_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv, + int packet_subtype) +{ + return batadv_unicast_generic_send_skb(skb, bat_priv, + BATADV_UNICAST_4ADDR, + packet_subtype); +}

static inline int batadv_frag_can_reassemble(const struct sk_buff *skb, int mtu) {

Add all the relevant functions in order to manage a Distributed Hash Table over the B.A.T.M.A.N.-adv network. It will later be used to store several ARP entries and implement DAT (Distributed ARP Table)

Signed-off-by: Antonio Quartulli ordex@autistici.org --- Makefile.kbuild | 1 + distributed-arp-table.c | 239 +++++++++++++++++++++++++++++++++++++++++++++++ distributed-arp-table.h | 49 ++++++++++ hard-interface.c | 3 + main.h | 6 ++ originator.c | 2 + types.h | 14 +++ unicast.c | 8 +- unicast.h | 4 + 9 files changed, 322 insertions(+), 4 deletions(-) create mode 100644 distributed-arp-table.c create mode 100644 distributed-arp-table.h

diff --git a/Makefile.kbuild b/Makefile.kbuild index 8676d2b..7604159 100644 --- a/Makefile.kbuild +++ b/Makefile.kbuild @@ -23,6 +23,7 @@ batman-adv-y += bat_iv_ogm.o batman-adv-y += bitarray.o batman-adv-$(CONFIG_BATMAN_ADV_BLA) += bridge_loop_avoidance.o batman-adv-y += debugfs.o +batman-adv-y += distributed-arp-table.o batman-adv-y += gateway_client.o batman-adv-y += gateway_common.o batman-adv-y += hard-interface.o diff --git a/distributed-arp-table.c b/distributed-arp-table.c new file mode 100644 index 0000000..68c739c --- /dev/null +++ b/distributed-arp-table.c @@ -0,0 +1,239 @@ +/* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors: + * + * Antonio Quartulli + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU General Public + * License as published by the Free Software Foundation. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#include <linux/if_ether.h> +#include <linux/if_arp.h> + +#include "main.h" +#include "distributed-arp-table.h" +#include "hard-interface.h" +#include "originator.h" +#include "send.h" +#include "types.h" +#include "unicast.h" + +/* hash function to choose an entry in a hash table of given size. + * hash algorithm from http://en.wikipedia.org/wiki/Hash_table + */ +static uint32_t batadv_hash_dat_global(const void *data, uint32_t size) +{ + const unsigned char *key = data; + uint32_t hash = 0; + size_t i; + + for (i = 0; i < 4; i++) { + hash += key[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash % size; +} + +static bool batadv_is_orig_node_eligible(struct batadv_dht_candidate *res, + int select, batadv_dat_addr_t tmp_max, + batadv_dat_addr_t max, + batadv_dat_addr_t last_max, + struct batadv_orig_node *candidate, + struct batadv_orig_node *max_orig_node) +{ + bool ret = false; + int j; + + /* Check if we have already selected this neighbour... */ + for (j = 0; j < select; j++) + if (res[j].orig_node == candidate) + break; + /* ..and possibly skip it */ + if (j < select) + goto out; + /* sanity check: has it already been selected? This should not happen */ + if (tmp_max > last_max) + goto out; + /* check if during this iteration we have already found an originator + * with a closer dht address + */ + if (tmp_max < max) + goto out; + /* this is an hash collision with the temporary selected node. Choose + * the one with the lowest address + */ + if ((tmp_max == max) && + (batadv_compare_eth(candidate->orig, max_orig_node->orig) > 0)) + goto out; + + ret = true; +out: + return ret; +} + +/* selects the next candidate by populating cands[select] and modifies last_max + * accordingly + */ +static void batadv_choose_next_candidate(struct batadv_priv *bat_priv, + struct batadv_dht_candidate *cands, + int select, batadv_dat_addr_t ip_key, + batadv_dat_addr_t *last_max) +{ + batadv_dat_addr_t max = 0, tmp_max = 0; + struct batadv_orig_node *orig_node, *max_orig_node = NULL; + struct batadv_hashtable *hash = bat_priv->orig_hash; + struct hlist_node *node; + struct hlist_head *head; + int i; + + /* if no node is eligible as candidate, we will leave the candidate as + * NOT_FOUND + */ + cands[select].type = DHT_CANDIDATE_NOT_FOUND; + + /* iterate over the originator list and find the node with closest + * dht_address which has not been selected yet + */ + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) { + /* the dht space is a ring and addresses are unsigned */ + tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dht_addr + + ip_key; + + if (!batadv_is_orig_node_eligible(cands, select, + tmp_max, max, + *last_max, orig_node, + max_orig_node)) + continue; + + if (!atomic_inc_not_zero(&orig_node->refcount)) + continue; + + max = tmp_max; + if (max_orig_node) + batadv_orig_node_free_ref(max_orig_node); + max_orig_node = orig_node; + } + rcu_read_unlock(); + } + if (max_orig_node) { + cands[select].type = DHT_CANDIDATE_ORIG; + cands[select].orig_node = max_orig_node; + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "dht_select_candidates() %d: selected %pM addr=%u dist=%u\n", + select, max_orig_node->orig, max_orig_node->dht_addr, + max); + } + *last_max = max; +} + +/* Given a key, selects the candidates which the DHT message has to be sent to. + * An originator O is selected if and only if its DHT_ID value is one of three + * closest values (from the LEFT, with wrap around if needed) then the hash + * value of the key. ip_dst is the key. + * + * return an array of size DHT_CANDIDATES_NUM + */ +static struct batadv_dht_candidate * +batadv_dht_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst) +{ + int select; + batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key; + struct batadv_dht_candidate *res; + + if (!bat_priv->orig_hash) + return NULL; + + res = kmalloc(DHT_CANDIDATES_NUM * sizeof(*res), GFP_ATOMIC); + if (!res) + return NULL; + + ip_key = (batadv_dat_addr_t)batadv_hash_dat_global(&ip_dst, + BATADV_DAT_ADDR_MAX); + + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "dht_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst, + ip_key); + + for (select = 0; select < DHT_CANDIDATES_NUM; select++) + batadv_choose_next_candidate(bat_priv, res, select, ip_key, + &last_max); + + return res; +} + +/* Sends the skb payload passed as argument to the candidates selected for + * the data represented by 'ip'. The skb is copied by means of pskb_copy() + * and is sent as unicast packet to each of the selected candidate. + * + * If the packet is successfully sent to at least one candidate, then this + * function returns true + */ +static bool batadv_dht_send_data(struct batadv_priv *bat_priv, + struct sk_buff *skb, __be32 ip, + int packet_subtype) +{ + int i; + bool ret = false; + int send_status; + struct batadv_neigh_node *neigh_node = NULL; + struct sk_buff *tmp_skb; + struct batadv_dht_candidate *cand; + + cand = batadv_dht_select_candidates(bat_priv, ip); + if (!cand) + goto out; + + batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip); + + for (i = 0; i < DHT_CANDIDATES_NUM; i++) { + if (cand[i].type == DHT_CANDIDATE_NOT_FOUND) + continue; + + neigh_node = batadv_orig_node_get_router(cand[i].orig_node); + if (!neigh_node) + goto free_orig; + + tmp_skb = pskb_copy(skb, GFP_ATOMIC); + if (!batadv_prepare_unicast_4addr_packet(bat_priv, tmp_skb, + cand[i].orig_node, + packet_subtype)) { + kfree_skb(tmp_skb); + goto free_neigh; + } + + send_status = batadv_send_skb_packet(tmp_skb, + neigh_node->if_incoming, + neigh_node->addr); + if (send_status == NET_XMIT_SUCCESS) + /* packet sent to a candidate: we can return true */ + ret = true; +free_neigh: + batadv_neigh_node_free_ref(neigh_node); +free_orig: + batadv_orig_node_free_ref(cand[i].orig_node); + } + +out: + kfree(cand); + return ret; +} diff --git a/distributed-arp-table.h b/distributed-arp-table.h new file mode 100644 index 0000000..8d26c90 --- /dev/null +++ b/distributed-arp-table.h @@ -0,0 +1,49 @@ +/* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors: + * + * Antonio Quartulli + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU General Public + * License as published by the Free Software Foundation. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _NET_BATMAN_ADV_ARP_H_ +#define _NET_BATMAN_ADV_ARP_H_ + +#include "types.h" +#include "originator.h" + +#define BATADV_DAT_ADDR_MAX ((batadv_dat_addr_t)~(batadv_dat_addr_t)0) + +static inline void +batadv_dat_init_orig_node_dht_addr(struct batadv_orig_node *orig_node) +{ + uint32_t addr; + + addr = batadv_choose_orig(orig_node->orig, BATADV_DAT_ADDR_MAX); + orig_node->dht_addr = (batadv_dat_addr_t)addr; +} + +static inline void +batadv_dat_init_own_dht_addr(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if) +{ + uint32_t addr; + + addr = batadv_choose_orig(primary_if->net_dev->dev_addr, + BATADV_DAT_ADDR_MAX); + + bat_priv->dht_addr = (batadv_dat_addr_t)addr; +} + +#endif /* _NET_BATMAN_ADV_ARP_H_ */ diff --git a/hard-interface.c b/hard-interface.c index 2c5a247..0f55cca 100644 --- a/hard-interface.c +++ b/hard-interface.c @@ -18,6 +18,7 @@ */

#include "main.h" +#include "distributed-arp-table.h" #include "hard-interface.h" #include "soft-interface.h" #include "send.h" @@ -108,6 +109,8 @@ static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, if (!primary_if) goto out;

+ batadv_dat_init_own_dht_addr(bat_priv, primary_if); + vis_packet = (struct batadv_vis_packet *) bat_priv->my_vis_info->skb_packet->data; memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN); diff --git a/main.h b/main.h index 7e64dbd..076dbc5 100644 --- a/main.h +++ b/main.h @@ -73,6 +73,9 @@

#define BATADV_LOG_BUF_LEN 8192 /* has to be a power of 2 */

+/* numbers of originator to contact for any PUT/GET DHT operation */ +#define DHT_CANDIDATES_NUM 3 + #define BATADV_VIS_INTERVAL 5000 /* 5 seconds */

/* how much worse secondary interfaces may be to be considered as bonding @@ -117,6 +120,9 @@ enum batadv_uev_type {

#define BATADV_GW_THRESHOLD 50

+#define DHT_CANDIDATE_NOT_FOUND 0 +#define DHT_CANDIDATE_ORIG 1 + /* Debug Messages */ #ifdef pr_fmt #undef pr_fmt diff --git a/originator.c b/originator.c index ac9bdf8..06f8bd6 100644 --- a/originator.c +++ b/originator.c @@ -18,6 +18,7 @@ */

#include "main.h" +#include "distributed-arp-table.h" #include "originator.h" #include "hash.h" #include "translation-table.h" @@ -223,6 +224,7 @@ struct batadv_orig_node *batadv_get_orig_node(struct batadv_priv *bat_priv, orig_node->tt_poss_change = false; orig_node->bat_priv = bat_priv; memcpy(orig_node->orig, addr, ETH_ALEN); + batadv_dat_init_orig_node_dht_addr(orig_node); orig_node->router = NULL; orig_node->tt_crc = 0; atomic_set(&orig_node->last_ttvn, 0); diff --git a/types.h b/types.h index 591bd28..f9de55a 100644 --- a/types.h +++ b/types.h @@ -28,6 +28,13 @@ (ETH_HLEN + max(sizeof(struct batadv_unicast_packet), \ sizeof(struct batadv_bcast_packet)))

+/* batadv_dat_addr_t is the type used for all DHT addresses. If it is changed, + * BATADV_DAT_ADDR_MAX is changed as well. + * + * *Please be careful: batadv_dat_addr_t must be UNSIGNED* + */ +#define batadv_dat_addr_t uint16_t + struct batadv_hard_iface { struct list_head list; int16_t if_num; @@ -62,6 +69,7 @@ struct batadv_orig_node { uint8_t orig[ETH_ALEN]; uint8_t primary_addr[ETH_ALEN]; struct batadv_neigh_node __rcu *router; /* rcu protected pointer */ + batadv_dat_addr_t dht_addr; unsigned long *bcast_own; uint8_t *bcast_own_sum; unsigned long last_seen; @@ -241,6 +249,7 @@ struct batadv_priv { struct batadv_hard_iface __rcu *primary_if; /* rcu protected pointer */ struct batadv_vis_info *my_vis_info; struct batadv_algo_ops *bat_algo_ops; + batadv_dat_addr_t dht_addr; };

struct batadv_socket_client { @@ -413,4 +422,9 @@ struct batadv_algo_ops { void (*bat_ogm_emit)(struct batadv_forw_packet *forw_packet); };

+struct batadv_dht_candidate { + int type; + struct batadv_orig_node *orig_node; +}; + #endif /* _NET_BATMAN_ADV_TYPES_H_ */ diff --git a/unicast.c b/unicast.c index b3adbd0..56cfc35 100644 --- a/unicast.c +++ b/unicast.c @@ -318,10 +318,10 @@ static bool batadv_prepare_unicast_packet(struct sk_buff *skb, return batadv_pull_and_fill_unicast(skb, uni_size, orig_node); }

-static bool batadv_prepare_unicast_4addr_packet(struct batadv_priv *bat_priv, - struct sk_buff *skb, - struct batadv_orig_node *orig, - int packet_subtype) +bool batadv_prepare_unicast_4addr_packet(struct batadv_priv *bat_priv, + struct sk_buff *skb, + struct batadv_orig_node *orig, + int packet_subtype) { struct batadv_hard_iface *primary_if; struct batadv_unicast_4addr_packet *unicast_4addr_packet; diff --git a/unicast.h b/unicast.h index 23d526e..9ce8c04 100644 --- a/unicast.h +++ b/unicast.h @@ -32,6 +32,10 @@ void batadv_frag_list_free(struct list_head *head); int batadv_frag_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, struct batadv_hard_iface *hard_iface, const uint8_t dstaddr[]); +bool batadv_prepare_unicast_4addr_packet(struct batadv_priv *bat_priv, + struct sk_buff *skb, + struct batadv_orig_node *orig_node, + int packet_subtype); int batadv_unicast_generic_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, int packet_type, int packet_subtype);

ARP messages are now parsed to make it possible to trigger special actions depending on their types (snooping).

Signed-off-by: Antonio Quartulli ordex@autistici.org --- distributed-arp-table.c | 160 +++++++++++++++++++++++++++++++++++++++++++++++ distributed-arp-table.h | 2 + packet.h | 5 +- 3 files changed, 166 insertions(+), 1 deletion(-)

diff --git a/distributed-arp-table.c b/distributed-arp-table.c index 4688399..eabcd42 100644 --- a/distributed-arp-table.c +++ b/distributed-arp-table.c @@ -21,6 +21,7 @@ #include <linux/if_arp.h>

#include "main.h" +#include "hash.h" #include "distributed-arp-table.h" #include "hard-interface.h" #include "originator.h" @@ -91,6 +92,31 @@ static int batadv_compare_dat(const struct hlist_node *node, const void *data2) return (memcmp(data1, data2, sizeof(__be32)) == 0 ? 1 : 0); }

+static uint8_t *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size) +{ + uint8_t *addr; + + addr = (uint8_t *)(skb->data + hdr_size); + addr += ETH_HLEN + sizeof(struct arphdr); + + return addr; +} + +static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size) +{ + return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN); +} + +static uint8_t *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size) +{ + return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4; +} + +static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size) +{ + return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4); +} + /* hash function to choose an entry in a hash table of given size. * hash algorithm from http://en.wikipedia.org/wiki/Hash_table */ @@ -214,6 +240,84 @@ out: batadv_dat_entry_free_ref(dat_entry); }

+#ifdef CONFIG_BATMAN_ADV_DEBUG + +static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, + uint16_t type, int hdr_size, char *msg) +{ + struct batadv_unicast_4addr_packet *unicast_4addr_packet; + struct batadv_bcast_packet *bcast_pkt; + uint8_t *orig_addr; + __be32 ip_src, ip_dst; + + if (msg) + batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg); + + ip_src = batadv_arp_ip_src(skb, hdr_size); + ip_dst = batadv_arp_ip_dst(skb, hdr_size); + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n", + batadv_arp_hw_src(skb, hdr_size), &ip_src, + batadv_arp_hw_dst(skb, hdr_size), &ip_dst); + + if (hdr_size == 0) + return; + + /* if the ARP packet is encapsulated in a batman packet, let's print + * some debug messages + */ + unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; + + switch (unicast_4addr_packet->u.header.packet_type) { + case BATADV_UNICAST: + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "* encapsulated within a UNICAST packet\n"); + break; + case BATADV_UNICAST_4ADDR: + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n", + unicast_4addr_packet->src); + switch (unicast_4addr_packet->subtype) { + case BATADV_P_DAT_DHT_PUT: + batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n"); + break; + case BATADV_P_DAT_DHT_GET: + batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n"); + break; + case BATADV_P_DAT_CACHE_REPLY: + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "* type: DAT_CACHE_REPLY\n"); + break; + case BATADV_P_DATA: + batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n"); + break; + default: + batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown!\n"); + } + break; + case BATADV_BCAST: + bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet; + orig_addr = bcast_pkt->orig; + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "* encapsulated within a BCAST packet (src: %pM)\n", + orig_addr); + break; + default: + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "* encapsulated within an unknown packet type (0x%x)\n", + unicast_4addr_packet->u.header.packet_type); + } +} + +#else + +static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, + uint16_t type, int hdr_size, char *msg) +{ +} + +#endif /* CONFIG_BATMAN_ADV_DEBUG */ + static bool batadv_is_orig_node_eligible(struct batadv_dht_candidate *res, int select, batadv_dat_addr_t tmp_max, batadv_dat_addr_t max, @@ -511,3 +615,59 @@ out: batadv_hardif_free_ref(primary_if); return ret; } + +/* Returns arphdr->ar_op if the skb contains a valid ARP packet, otherwise + * returns 0 + */ +static uint16_t batadv_arp_get_type(struct batadv_priv *bat_priv, + struct sk_buff *skb, int hdr_size) +{ + struct arphdr *arphdr; + struct ethhdr *ethhdr; + __be32 ip_src, ip_dst; + uint16_t type = 0; + + /* pull the ethernet header */ + if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN))) + goto out; + + ethhdr = (struct ethhdr *)(skb->data + hdr_size); + + if (ethhdr->h_proto != htons(ETH_P_ARP)) + goto out; + + /* pull the ARP payload */ + if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN + + arp_hdr_len(skb->dev)))) + goto out; + + arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN); + + /* Check whether the ARP packet carries a valid + * IP information + */ + if (arphdr->ar_hrd != htons(ARPHRD_ETHER)) + goto out; + + if (arphdr->ar_pro != htons(ETH_P_IP)) + goto out; + + if (arphdr->ar_hln != ETH_ALEN) + goto out; + + if (arphdr->ar_pln != 4) + goto out; + + /* Check for bad reply/request. If the ARP message is not sane, DAT + * will simply ignore it + */ + ip_src = batadv_arp_ip_src(skb, hdr_size); + ip_dst = batadv_arp_ip_dst(skb, hdr_size); + if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) || + ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst)) + goto out; + + type = ntohs(arphdr->ar_op); +out: + return type; +} diff --git a/distributed-arp-table.h b/distributed-arp-table.h index 0014583..9096749 100644 --- a/distributed-arp-table.h +++ b/distributed-arp-table.h @@ -23,6 +23,8 @@ #include "types.h" #include "originator.h"

+#include <linux/if_arp.h> + #define BATADV_DAT_ADDR_MAX ((batadv_dat_addr_t)~(batadv_dat_addr_t)0)

static inline void diff --git a/packet.h b/packet.h index e48f066..803517a 100644 --- a/packet.h +++ b/packet.h @@ -35,7 +35,10 @@ enum batadv_packettype { };

enum batadv_subtype { - BATADV_P_DATA = 0x01, + BATADV_P_DATA = 0x01, + BATADV_P_DAT_DHT_GET = 0x02, + BATADV_P_DAT_DHT_PUT = 0x03, + BATADV_P_DAT_CACHE_REPLY = 0x04, };

/* this file is included by batctl which needs these defines */

This patch makes it possible to decide whether to include DAT within the batman-adv binary or not. It is extremely useful when the user wants to reduce the size of the resulting module by cutting off any not needed feature.

Signed-off-by: Antonio Quartulli ordex@autistici.org --- Makefile | 2 ++ Makefile.kbuild | 2 +- README.external | 1 + compat.c | 2 ++ debugfs.c | 7 ++++- distributed-arp-table.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++ gen-compat-autoconf.sh | 1 + types.h | 11 +++++++- 8 files changed, 89 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile index bd8d30c..c6266a2 100644 --- a/Makefile +++ b/Makefile @@ -23,6 +23,8 @@ export CONFIG_BATMAN_ADV_DEBUG=n # B.A.T.M.A.N. bridge loop avoidance: export CONFIG_BATMAN_ADV_BLA=y +# B.A.T.M.A.N. distributed ARP table: +export CONFIG_BATMAN_ADV_DAT=y

PWD:=$(shell pwd) KERNELPATH ?= /lib/modules/$(shell uname -r)/build diff --git a/Makefile.kbuild b/Makefile.kbuild index 7604159..e45e3b4 100644 --- a/Makefile.kbuild +++ b/Makefile.kbuild @@ -23,7 +23,7 @@ batman-adv-y += bat_iv_ogm.o batman-adv-y += bitarray.o batman-adv-$(CONFIG_BATMAN_ADV_BLA) += bridge_loop_avoidance.o batman-adv-y += debugfs.o -batman-adv-y += distributed-arp-table.o +batman-adv-$(CONFIG_BATMAN_ADV_DAT) += distributed-arp-table.o batman-adv-y += gateway_client.o batman-adv-y += gateway_common.o batman-adv-y += hard-interface.o diff --git a/README.external b/README.external index e032ef1..9b2a973 100644 --- a/README.external +++ b/README.external @@ -37,6 +37,7 @@ module). Available options and their possible values are

* CONFIG_BATMAN_ADV_DEBUG=[y|n*] (B.A.T.M.A.N. debugging) * CONFIG_BATMAN_ADV_BLA=[y*|n] (B.A.T.M.A.N. bridge loop avoidance) + * CONFIG_BATMAN_ADV_DAT=[y*|n] (B.A.T.M.A.N. Distributed ARP Table)

e.g., debugging can be enabled by

diff --git a/compat.c b/compat.c index 21f23fe..c8006c6 100644 --- a/compat.c +++ b/compat.c @@ -64,6 +64,7 @@ void batadv_free_rcu_backbone_gw(struct rcu_head *rcu) } #endif

+#ifdef CONFIG_BATMAN_ADV_DAT void batadv_free_rcu_dat_entry(struct rcu_head *rcu) { struct batadv_dat_entry *dat_entry; @@ -71,5 +72,6 @@ void batadv_free_rcu_dat_entry(struct rcu_head *rcu) dat_entry = container_of(rcu, struct batadv_dat_entry, rcu); kfree(dat_entry); } +#endif

#endif /* < KERNEL_VERSION(3, 0, 0) */ diff --git a/debugfs.c b/debugfs.c index f7cf001..7e3d4ff 100644 --- a/debugfs.c +++ b/debugfs.c @@ -279,12 +279,13 @@ static int batadv_bla_backbone_table_open(struct inode *inode,

#endif

+#ifdef CONFIG_BATMAN_ADV_DAT static int batadv_dat_cache_open(struct inode *inode, struct file *file) { struct net_device *net_dev = (struct net_device *)inode->i_private; return single_open(file, batadv_dat_cache_seq_print_text, net_dev); } - +#endif

static int batadv_transtable_local_open(struct inode *inode, struct file *file) { @@ -325,7 +326,9 @@ static BATADV_DEBUGINFO(bla_claim_table, S_IRUGO, batadv_bla_claim_table_open); static BATADV_DEBUGINFO(bla_backbone_table, S_IRUGO, batadv_bla_backbone_table_open); #endif +#ifdef CONFIG_BATMAN_ADV_DAT static BATADV_DEBUGINFO(dat_cache, S_IRUGO, batadv_dat_cache_open); +#endif static BATADV_DEBUGINFO(transtable_local, S_IRUGO, batadv_transtable_local_open); static BATADV_DEBUGINFO(vis_data, S_IRUGO, batadv_vis_data_open); @@ -338,7 +341,9 @@ static struct batadv_debuginfo *batadv_mesh_debuginfos[] = { &batadv_debuginfo_bla_claim_table, &batadv_debuginfo_bla_backbone_table, #endif +#ifdef CONFIG_BATMAN_ADV_DAT &batadv_debuginfo_dat_cache, +#endif &batadv_debuginfo_transtable_local, &batadv_debuginfo_vis_data, NULL, diff --git a/distributed-arp-table.h b/distributed-arp-table.h index 9f366a3..9cc4337 100644 --- a/distributed-arp-table.h +++ b/distributed-arp-table.h @@ -20,6 +20,8 @@ #ifndef _NET_BATMAN_ADV_ARP_H_ #define _NET_BATMAN_ADV_ARP_H_

+#ifdef CONFIG_BATMAN_ADV_DAT + #include "types.h" #include "originator.h"

@@ -63,4 +65,68 @@ int batadv_dat_init(struct batadv_priv *bat_priv); void batadv_dat_free(struct batadv_priv *bat_priv); int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset);

+#else + +static inline bool +batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv, + struct sk_buff *skb) +{ + return false; +} + +static inline bool +batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, + struct sk_buff *skb, int hdr_size, + bool is4addr) +{ + return false; +} + +static inline bool +batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, + struct sk_buff *skb) +{ + return false; +} + +static inline bool +batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, + struct sk_buff *skb, int hdr_size) +{ + return false; +} + +static inline bool +batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv, + struct batadv_forw_packet *forw_packet) +{ + return false; +} + +static inline void +batadv_dat_init_orig_node_dht_addr(struct batadv_orig_node *orig_node) +{ +} + +static inline void batadv_dat_init_own_dht_addr(struct batadv_priv *bat_priv, + struct batadv_hard_iface *iface) +{ +} + +static inline void batadv_arp_change_timeout(struct net_device *soft_iface, + const char *name) +{ +} + +static inline int batadv_dat_init(struct batadv_priv *bat_priv) +{ + return 0; +} + +static inline void batadv_dat_free(struct batadv_priv *bat_priv) +{ +} + +#endif /* CONFIG_BATMAN_ADV_DAT */ + #endif /* _NET_BATMAN_ADV_ARP_H_ */ diff --git a/gen-compat-autoconf.sh b/gen-compat-autoconf.sh index 7cf621b..7ea42aa 100755 --- a/gen-compat-autoconf.sh +++ b/gen-compat-autoconf.sh @@ -38,6 +38,7 @@ gen_config() { # write config variables gen_config 'CONFIG_BATMAN_ADV_DEBUG' ${CONFIG_BATMAN_ADV_DEBUG:="n"} >> "${TMP}" gen_config 'CONFIG_BATMAN_ADV_BLA' ${CONFIG_BATMAN_ADV_BLA:="y"} >> "${TMP}" +gen_config 'CONFIG_BATMAN_ADV_DAT' ${CONFIG_BATMAN_ADV_DAT:="y"} >> "${TMP}"

# only regenerate compat-autoconf.h when config was changed diff "${TMP}" "${TARGET}" > /dev/null 2>&1 || cp "${TMP}" "${TARGET}" diff --git a/types.h b/types.h index e826a7b..8ffdf5f 100644 --- a/types.h +++ b/types.h @@ -28,6 +28,8 @@ (ETH_HLEN + max(sizeof(struct batadv_unicast_packet), \ sizeof(struct batadv_bcast_packet)))

+#ifdef CONFIG_BATMAN_ADV_DAT + /* batadv_dat_addr_t is the type used for all DHT addresses. If it is changed, * BATADV_DAT_ADDR_MAX is changed as well. * @@ -35,6 +37,8 @@ */ #define batadv_dat_addr_t uint16_t

+#endif /* CONFIG_BATMAN_ADV_DAT */ + struct batadv_hard_iface { struct list_head list; int16_t if_num; @@ -69,7 +73,9 @@ struct batadv_orig_node { uint8_t orig[ETH_ALEN]; uint8_t primary_addr[ETH_ALEN]; struct batadv_neigh_node __rcu *router; /* rcu protected pointer */ +#ifdef CONFIG_BATMAN_ADV_DAT batadv_dat_addr_t dht_addr; +#endif unsigned long *bcast_own; uint8_t *bcast_own_sum; unsigned long last_seen; @@ -218,7 +224,9 @@ struct batadv_priv { struct batadv_hashtable *claim_hash; struct batadv_hashtable *backbone_hash; #endif +#ifdef CONFIG_BATMAN_ADV_DAT struct batadv_hashtable *dat_hash; +#endif struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; struct batadv_hashtable *vis_hash; @@ -251,8 +259,9 @@ struct batadv_priv { struct batadv_hard_iface __rcu *primary_if; /* rcu protected pointer */ struct batadv_vis_info *my_vis_info; struct batadv_algo_ops *bat_algo_ops; +#ifdef CONFIG_BATMAN_ADV_DAT batadv_dat_addr_t dht_addr; - +#endif };

struct batadv_socket_client {