All our packets have a TTL and with the last batman header patch also at the same place in a batman encapsulated packet. We can therefore savely do one single TTL check before sending any batman packet type.

This commit also modifies the TTL handling to be more consistent with how it is done in other network protocols (like IPv6): The TTL is always decreased before transmitting a packet and not on receiption for one thing. And packets with a TTL of zero will never be be sent out on a network interface for another. Compare with: RFC1812; RFC2460,4.4; RFC3443,2.3

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- aggregation.c | 4 +- hard-interface.c | 2 +- routing.c | 90 --------------------------------------- send.c | 123 +++++++++++++++++++++++++++++++++++++++++++++++------- unicast.c | 3 - vis.c | 6 --- 6 files changed, 110 insertions(+), 118 deletions(-)

diff --git a/aggregation.c b/aggregation.c index 5bd74e1..d9ca9ae 100644 --- a/aggregation.c +++ b/aggregation.c @@ -69,7 +69,7 @@ static bool can_aggregate_with(struct batman_packet *new_batman_packet, * are flooded through the net */ if ((!directlink) && (!(batman_packet->flags & DIRECTLINK)) && - (batman_packet->header.ttl != 1) && + (batman_packet->header.ttl != 2) &&

/* own packets originating non-primary * interfaces leave only that interface */ @@ -80,7 +80,7 @@ static bool can_aggregate_with(struct batman_packet *new_batman_packet, /* if the incoming packet is sent via this one * interface only - we still can aggregate */ if ((directlink) && - (new_batman_packet->header.ttl == 1) && + (new_batman_packet->header.ttl == 2) && (forw_packet->if_incoming == if_incoming) &&

/* packets from direct neighbors or diff --git a/hard-interface.c b/hard-interface.c index 3637602..b0105e9 100644 --- a/hard-interface.c +++ b/hard-interface.c @@ -314,7 +314,7 @@ int hardif_enable_interface(struct hard_iface *hard_iface, char *iface_name) batman_packet = (struct batman_packet *)(hard_iface->packet_buff); batman_packet->header.packet_type = BAT_PACKET; batman_packet->header.version = COMPAT_VERSION; - batman_packet->header.ttl = 2; + batman_packet->header.ttl = 3; batman_packet->flags = 0; batman_packet->tq = TQ_MAX_VALUE; batman_packet->num_hna = 0; diff --git a/routing.c b/routing.c index 115a8de..c60296c 100644 --- a/routing.c +++ b/routing.c @@ -930,73 +930,6 @@ out: return ret; }

-static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, - struct sk_buff *skb) -{ - struct orig_node *orig_node = NULL; - struct neigh_node *neigh_node = NULL; - struct icmp_packet *icmp_packet; - int ret = NET_RX_DROP; - - icmp_packet = (struct icmp_packet *)skb->data; - - /* send TTL exceeded if packet is an echo request (traceroute) */ - if (icmp_packet->msg_type != ECHO_REQUEST) { - pr_debug("Warning - can't forward icmp packet from %pM to " - "%pM: ttl exceeded\n", icmp_packet->orig, - icmp_packet->dst); - goto out; - } - - if (!bat_priv->primary_if) - goto out; - - /* get routing information */ - rcu_read_lock(); - orig_node = orig_hash_find(bat_priv, icmp_packet->orig); - - if (!orig_node) - goto unlock; - - neigh_node = orig_node->router; - - if (!neigh_node) - goto unlock; - - if (!atomic_inc_not_zero(&neigh_node->refcount)) { - neigh_node = NULL; - goto unlock; - } - - rcu_read_unlock(); - - /* create a copy of the skb, if needed, to modify it. */ - if (skb_cow(skb, sizeof(struct ethhdr)) < 0) - goto out; - - icmp_packet = (struct icmp_packet *)skb->data; - - memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); - memcpy(icmp_packet->orig, - bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); - icmp_packet->msg_type = TTL_EXCEEDED; - icmp_packet->header.ttl = TTL; - - send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); - ret = NET_RX_SUCCESS; - goto out; - -unlock: - rcu_read_unlock(); -out: - if (neigh_node) - neigh_node_free_ref(neigh_node); - if (orig_node) - orig_node_free_ref(orig_node); - return ret; -} - - int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) { struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); @@ -1045,10 +978,6 @@ int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (is_my_mac(icmp_packet->dst)) return recv_my_icmp_packet(bat_priv, skb, hdr_size);

- /* TTL exceeded */ - if (icmp_packet->header.ttl < 2) - return recv_icmp_ttl_exceeded(bat_priv, skb); - /* get routing information */ rcu_read_lock(); orig_node = orig_hash_find(bat_priv, icmp_packet->dst); @@ -1074,9 +1003,6 @@ int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)

icmp_packet = (struct icmp_packet_rr *)skb->data;

- /* decrement ttl */ - icmp_packet->header.ttl--; - /* route it */ send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = NET_RX_SUCCESS; @@ -1269,20 +1195,11 @@ int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) struct orig_node *orig_node = NULL; struct neigh_node *neigh_node = NULL; struct unicast_packet *unicast_packet; - struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb); int ret = NET_RX_DROP; struct sk_buff *new_skb;

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

- /* TTL exceeded */ - if (unicast_packet->header.ttl < 2) { - pr_debug("Warning - can't forward unicast packet from %pM to " - "%pM: ttl exceeded\n", ethhdr->h_source, - unicast_packet->dest); - goto out; - } - /* get routing information */ rcu_read_lock(); orig_node = orig_hash_find(bat_priv, unicast_packet->dest); @@ -1327,12 +1244,8 @@ int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) }

skb = new_skb; - unicast_packet = (struct unicast_packet *)skb->data; }

- /* decrement ttl */ - unicast_packet->header.ttl--; - /* route it */ send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = NET_RX_SUCCESS; @@ -1435,9 +1348,6 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (is_my_mac(bcast_packet->orig)) goto out;

- if (bcast_packet->header.ttl < 2) - goto out; - rcu_read_lock(); orig_node = orig_hash_find(bat_priv, bcast_packet->orig);

diff --git a/send.c b/send.c index 93e4f8f..1f1afce 100644 --- a/send.c +++ b/send.c @@ -22,6 +22,7 @@ #include "main.h" #include "send.h" #include "routing.h" +#include "hash.h" #include "translation-table.h" #include "soft-interface.h" #include "hard-interface.h" @@ -53,13 +54,105 @@ static unsigned long forward_send_time(void) return jiffies + msecs_to_jiffies(random32() % (JITTER/2)); }

+static int send_icmp_ttl_exceeded(struct bat_priv *bat_priv, + struct sk_buff *skb) +{ + struct orig_node *orig_node = NULL; + struct neigh_node *neigh_node = NULL; + struct icmp_packet *icmp_packet; + int ret = NET_RX_DROP; + + icmp_packet = (struct icmp_packet *)skb->data; + + /* send TTL exceeded if packet is an echo request (traceroute) */ + if (icmp_packet->msg_type != ECHO_REQUEST) { + pr_debug("Warning - can't forward icmp packet from %pM to " + "%pM: ttl exceeded\n", icmp_packet->orig, + icmp_packet->dst); + goto out; + } + + if (!bat_priv->primary_if) + goto out; + + /* get routing information */ + rcu_read_lock(); + orig_node = orig_hash_find(bat_priv, icmp_packet->orig); + + if (!orig_node) + goto unlock; + + neigh_node = orig_node->router; + + if (!neigh_node) + goto unlock; + + if (!atomic_inc_not_zero(&neigh_node->refcount)) { + neigh_node = NULL; + goto unlock; + } + + rcu_read_unlock(); + + /* create a copy of the skb, if needed, to modify it. */ + if (skb_cow(skb, sizeof(struct ethhdr)) < 0) + goto out; + + icmp_packet = (struct icmp_packet *)skb->data; + + memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); + memcpy(icmp_packet->orig, + bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); + icmp_packet->msg_type = TTL_EXCEEDED; + icmp_packet->header.ttl = TTL; + + send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); + ret = NET_RX_SUCCESS; + goto out; + +unlock: + rcu_read_unlock(); +out: + if (neigh_node) + neigh_node_free_ref(neigh_node); + if (orig_node) + orig_node_free_ref(orig_node); + return ret; +} + +static void print_ttl_exceeded(struct sk_buff *skb, int packet_type, + struct bat_priv *bat_priv) { + switch (packet_type) { + case BAT_PACKET: + bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n"); + break; + case BAT_ICMP: + send_icmp_ttl_exceeded(bat_priv, skb); + break; + case BAT_VIS: + pr_debug("Error - can't send vis packet: ttl exceeded\n"); + break; + case BAT_UNICAST: + pr_debug("Warning - can't forward unicast packet from %pM to " + "%pM: ttl exceeded\n", + ((struct ethhdr *)skb->data)->h_source, + ((struct unicast_packet *)skb->data)->dest); + break; + default: + break; + } +} + /* send out an already prepared packet to the given address via the - * specified batman interface */ + * specified batman interface; drops it if the current TTL is 1 or less + * or else reduces the TTL by one */ int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface, uint8_t *dst_addr) { struct ethhdr *ethhdr; + struct batman_header *batman_header; + struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);

if (hard_iface->if_status != IF_ACTIVE) goto send_skb_err; @@ -73,6 +166,15 @@ int send_skb_packet(struct sk_buff *skb, goto send_skb_err; }

+ if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet)))) + goto send_skb_err; + batman_header = (struct batman_header *) skb->data; + if (batman_header->ttl <= 1) { + print_ttl_exceeded(skb, batman_header->packet_type, bat_priv); + goto send_skb_err; + } + batman_header->ttl--; + /* push to the ethernet header. */ if (my_skb_head_push(skb, sizeof(struct ethhdr)) < 0) goto send_skb_err; @@ -182,7 +284,7 @@ static void send_packet(struct forw_packet *forw_packet)

/* multihomed peer assumed */ /* non-primary OGMs are only broadcasted on their interface */ - if ((directlink && (batman_packet->header.ttl == 1)) || + if ((directlink && (batman_packet->header.ttl == 2)) || (forw_packet->own && (forw_packet->if_incoming->if_num > 0))) {

/* FIXME: what about aggregated packets ? */ @@ -311,15 +413,9 @@ void schedule_forward_packet(struct orig_node *orig_node, unsigned char in_tq, in_ttl, tq_avg = 0; unsigned long send_time;

- if (batman_packet->header.ttl <= 1) { - bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n"); - return; - } - in_tq = batman_packet->tq; in_ttl = batman_packet->header.ttl;

- batman_packet->header.ttl--; memcpy(batman_packet->prev_sender, ethhdr->h_source, ETH_ALEN);

/* rebroadcast tq of our best ranking neighbor to ensure the rebroadcast @@ -332,7 +428,7 @@ void schedule_forward_packet(struct orig_node *orig_node,

if (orig_node->router->last_ttl) batman_packet->header.ttl = - orig_node->router->last_ttl - 1; + orig_node->router->last_ttl; }

tq_avg = orig_node->router->tq_avg; @@ -344,8 +440,8 @@ void schedule_forward_packet(struct orig_node *orig_node, bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: tq_orig: %i, tq_avg: %i, " "tq_forw: %i, ttl_orig: %i, ttl_forw: %i\n", - in_tq, tq_avg, batman_packet->tq, in_ttl - 1, - batman_packet->header.ttl); + in_tq, tq_avg, batman_packet->tq, in_ttl, + batman_packet->header.ttl - 1);

batman_packet->seqno = htonl(batman_packet->seqno);

@@ -400,7 +496,6 @@ static void _add_bcast_packet_to_list(struct bat_priv *bat_priv, int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb) { struct forw_packet *forw_packet; - struct bcast_packet *bcast_packet;

if (!atomic_dec_not_zero(&bat_priv->bcast_queue_left)) { bat_dbg(DBG_BATMAN, bat_priv, "bcast packet queue full\n"); @@ -419,10 +514,6 @@ int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb) if (!skb) goto packet_free;

- /* as we have a copy now, it is safe to decrease the TTL */ - bcast_packet = (struct bcast_packet *)skb->data; - bcast_packet->header.ttl--; - skb_reset_mac_header(skb);

forw_packet->skb = skb; diff --git a/unicast.c b/unicast.c index a57033a..2677c06 100644 --- a/unicast.c +++ b/unicast.c @@ -250,7 +250,6 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,

memcpy(frag1, &tmp_uc, sizeof(struct unicast_packet));

- frag1->header.ttl--; frag1->header.version = COMPAT_VERSION; frag1->header.packet_type = BAT_UNICAST_FRAG;

@@ -327,8 +326,6 @@ find_router: if (atomic_read(&bat_priv->fragmentation) && data_len + sizeof(struct unicast_packet) > neigh_node->if_incoming->net_dev->mtu) { - /* send frag skb decreases ttl */ - unicast_packet->header.ttl++; ret = frag_send_skb(skb, bat_priv, neigh_node->if_incoming, neigh_node->addr); goto out; diff --git a/vis.c b/vis.c index 491430c..cde91f4 100644 --- a/vis.c +++ b/vis.c @@ -819,20 +819,14 @@ static void send_vis_packet(struct bat_priv *bat_priv, struct vis_info *info) struct vis_packet *packet;

packet = (struct vis_packet *)info->skb_packet->data; - if (packet->header.ttl < 2) { - pr_debug("Error - can't send vis packet: ttl exceeded\n"); - return; - }

memcpy(packet->sender_orig, bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); - packet->header.ttl--;

if (is_broadcast_ether_addr(packet->target_orig)) broadcast_vis_packet(bat_priv, info); else unicast_vis_packet(bat_priv, info); - packet->header.ttl++; /* restore TTL */ }

/* called from timer; send (and maybe generate) vis packet. */

This removes some redundancy present in unicast_send_skb(). It now invokes route_unicast_packet() for the next hop decision and sending.

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- routing.c | 15 ++++++++------- routing.h | 5 +++-- soft-interface.c | 3 ++- unicast.c | 39 +++++++-------------------------------- 4 files changed, 20 insertions(+), 42 deletions(-)

diff --git a/routing.c b/routing.c index 118b841..97e99ce 100644 --- a/routing.c +++ b/routing.c @@ -1189,10 +1189,10 @@ static int check_unicast_packet(struct sk_buff *skb, int hdr_size) return 0; }

-int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, - uint8_t *dest, uint8_t packet_type) +int route_unicast_packet(struct bat_priv *bat_priv, struct sk_buff *skb, + struct hard_iface *recv_if, uint8_t *dest, + uint8_t packet_type) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); struct orig_node *orig_node = NULL; struct neigh_node *neigh_node = NULL; int ret = NET_RX_DROP; @@ -1259,6 +1259,7 @@ out:

int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) { + struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); struct unicast_packet *unicast_packet; int hdr_size = sizeof(struct unicast_packet);

@@ -1273,8 +1274,8 @@ int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) return NET_RX_SUCCESS; }

- return route_unicast_packet(skb, recv_if, unicast_packet->dest, - unicast_packet->header.packet_type); + return route_unicast_packet(bat_priv, skb, recv_if, + unicast_packet->dest, unicast_packet->header.packet_type); }

int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) @@ -1307,8 +1308,8 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) return NET_RX_SUCCESS; }

- return route_unicast_packet(skb, recv_if, unicast_packet->dest, - unicast_packet->header.packet_type); + return route_unicast_packet(bat_priv, skb, recv_if, + unicast_packet->dest, unicast_packet->header.packet_type); }

diff --git a/routing.h b/routing.h index 88e8ef5..5972bf3 100644 --- a/routing.h +++ b/routing.h @@ -30,8 +30,9 @@ void receive_bat_packet(struct ethhdr *ethhdr, void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node, struct neigh_node *neigh_node, unsigned char *hna_buff, int hna_buff_len); -int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, - uint8_t *dest, uint8_t packet_type); +int route_unicast_packet(struct bat_priv *bat_priv, struct sk_buff *skb, + struct hard_iface *recv_if, uint8_t *dest, + uint8_t packet_type); int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if); diff --git a/soft-interface.c b/soft-interface.c index fdb3586..bd460b3 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -462,7 +462,8 @@ void interface_rx(struct net_device *soft_iface,

memcpy(unicast_packet->dest, bat_priv->softif_neigh->addr, ETH_ALEN); - ret = route_unicast_packet(skb, recv_if, unicast_packet->dest, + ret = route_unicast_packet(bat_priv, skb, recv_if, + unicast_packet->dest, unicast_packet->header.packet_type); if (ret == NET_RX_DROP) goto dropped; diff --git a/unicast.c b/unicast.c index 2677c06..c6c465c 100644 --- a/unicast.c +++ b/unicast.c @@ -282,34 +282,19 @@ int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) struct ethhdr *ethhdr = (struct ethhdr *)skb->data; struct unicast_packet *unicast_packet; struct orig_node *orig_node; - struct neigh_node *neigh_node; - int data_len = skb->len; - int ret = 1; + int ret = NET_RX_DROP;

/* get routing information */ if (is_multicast_ether_addr(ethhdr->h_dest)) { orig_node = (struct orig_node *)gw_get_selected(bat_priv); if (orig_node) - goto find_router; + goto route; }

/* check for hna host - increases orig_node refcount */ orig_node = transtable_search(bat_priv, ethhdr->h_dest);

-find_router: - /** - * find_router(): - * - if orig_node is NULL it returns NULL - * - increases neigh_nodes refcount if found. - */ - neigh_node = find_router(bat_priv, orig_node, NULL); - - if (!neigh_node) - goto out; - - if (neigh_node->if_incoming->if_status != IF_ACTIVE) - goto out; - +route: if (my_skb_head_push(skb, sizeof(struct unicast_packet)) < 0) goto out;

@@ -323,24 +308,14 @@ find_router: /* copy the destination for faster routing */ memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);

- if (atomic_read(&bat_priv->fragmentation) && - data_len + sizeof(struct unicast_packet) > - neigh_node->if_incoming->net_dev->mtu) { - ret = frag_send_skb(skb, bat_priv, - neigh_node->if_incoming, neigh_node->addr); - goto out; - } - - send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); - ret = 0; - goto out; + ret = route_unicast_packet(orig_node->bat_priv, skb, NULL, + unicast_packet->dest, unicast_packet->header.packet_type);

out: - if (neigh_node) - neigh_node_free_ref(neigh_node); if (orig_node) orig_node_free_ref(orig_node); - if (ret == 1) + if (ret == NET_RX_DROP) kfree_skb(skb); + return ret; }

Instead of branching the code paths and having several possible methods doing the final preparation and sending of an skb, depending on whether a packet needs to be fragmented or not, this commit now decouples the sending procedure from the fragmentation methods: The fragmentation methods are only manipulating a packet_list and packet_list_entries now so that the fragmentation process becomes transparent for route_unicast_packet().

This further allows easier integration of future extensions that send copies of multiple (modified) unicast packets to several next hop neighbours.

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- routing.c | 76 +++++++++++++++----------------------- routing.h | 4 +-- send.c | 14 +++++++ send.h | 7 ++++ soft-interface.c | 3 +- unicast.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++++----- unicast.h | 25 +------------ 7 files changed, 153 insertions(+), 83 deletions(-)

diff --git a/routing.c b/routing.c index 60579fc..ba4756c 100644 --- a/routing.c +++ b/routing.c @@ -1021,21 +1021,24 @@ out: /* find a suitable router for this originator, and use * bonding if possible. increases the found neighbors * refcount.*/ -struct neigh_node *find_router(struct orig_node *orig_node, - struct hard_iface *recv_if) +static void find_router(struct orig_node *orig_node, + struct hard_iface *recv_if, + struct sk_buff *skb, + struct hlist_head *packet_list) { struct bat_priv *bat_priv; struct orig_node *primary_orig_node; struct orig_node *router_orig; struct neigh_node *router, *first_candidate, *tmp_neigh_node; + struct packet_list_entry *entry; static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; int bonding_enabled;

if (!orig_node) - return NULL; + return;

if (!orig_node->router) - return NULL; + return;

bat_priv = orig_node->bat_priv;

@@ -1049,7 +1052,7 @@ struct neigh_node *find_router(struct orig_node *orig_node, router_orig = orig_node->router->orig_node; if (!router_orig || !atomic_inc_not_zero(&router->refcount)) { rcu_read_unlock(); - return NULL; + return; }

if ((!recv_if) && (!bonding_enabled)) @@ -1111,7 +1114,7 @@ struct neigh_node *find_router(struct orig_node *orig_node,

if (!router) { rcu_read_unlock(); - return NULL; + return; }

/* selected should point to the next element @@ -1163,7 +1166,16 @@ struct neigh_node *find_router(struct orig_node *orig_node, } return_router: rcu_read_unlock(); - return router; + + entry = kmalloc(sizeof(struct packet_list_entry), GFP_ATOMIC); + if (!entry) { + kfree_skb(skb); + return; + } + + entry->skb = skb; + entry->neigh_node = router; + hlist_add_head(&entry->list, packet_list); }

static int check_unicast_packet(struct sk_buff *skb, int hdr_size) @@ -1192,55 +1204,29 @@ static int check_unicast_packet(struct sk_buff *skb, int hdr_size) }

int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, - struct orig_node *orig_node, uint8_t packet_type) + struct orig_node *orig_node) { - struct neigh_node *neigh_node = NULL; int ret = NET_RX_DROP; - struct sk_buff *new_skb; + struct hlist_head packet_list;

- /* find_router() increases neigh_nodes refcount if found. */ - neigh_node = find_router(orig_node, recv_if); - - if (!neigh_node) - goto out; + INIT_HLIST_HEAD(&packet_list);

/* create a copy of the skb, if needed, to modify it. */ if (skb_cow(skb, sizeof(struct ethhdr)) < 0) goto out;

- if (packet_type == BAT_UNICAST && - atomic_read(&orig_node->bat_priv->fragmentation) && - skb->len > neigh_node->if_incoming->net_dev->mtu) { - ret = frag_send_skb(skb, orig_node->bat_priv, - neigh_node->if_incoming, neigh_node->addr); - goto out; - } - - if (packet_type == BAT_UNICAST_FRAG && - frag_can_reassemble(skb, neigh_node->if_incoming->net_dev->mtu)) { - - ret = frag_reassemble_skb(skb, orig_node->bat_priv, &new_skb); - - if (ret == NET_RX_DROP) - goto out; - - /* packet was buffered for late merge */ - if (!new_skb) { - ret = NET_RX_SUCCESS; - goto out; - } + /* creates the (initial) packet list */ + find_router(orig_node, recv_if, skb, &packet_list);

- skb = new_skb; - } + /* split packets that won't fit or maybe buffer fragments */ + frag_packet_list(orig_node->bat_priv, &packet_list);

- /* route it */ - send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); + /* route them */ + send_packet_list(&packet_list); ret = NET_RX_SUCCESS; goto out;

out: - if (neigh_node) - neigh_node_free_ref(neigh_node); if (orig_node) orig_node_free_ref(orig_node); return ret; @@ -1265,8 +1251,7 @@ int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) }

orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - return route_unicast_packet(skb, recv_if, orig_node, - unicast_packet->header.packet_type); + return route_unicast_packet(skb, recv_if, orig_node); }

int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) @@ -1301,8 +1286,7 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) }

orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - return route_unicast_packet(skb, recv_if, orig_node, - unicast_packet->header.packet_type); + return route_unicast_packet(skb, recv_if, orig_node); }

diff --git a/routing.h b/routing.h index d97f720..681512b 100644 --- a/routing.h +++ b/routing.h @@ -31,15 +31,13 @@ void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node, struct neigh_node *neigh_node, unsigned char *hna_buff, int hna_buff_len); int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, - struct orig_node *orig_node, uint8_t packet_type); + struct orig_node *orig_node); int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_bat_packet(struct sk_buff *skb, struct hard_iface *recv_if); -struct neigh_node *find_router(struct orig_node *orig_node, - struct hard_iface *recv_if); void bonding_candidate_del(struct orig_node *orig_node, struct neigh_node *neigh_node);

diff --git a/send.c b/send.c index 1f1afce..862ce79 100644 --- a/send.c +++ b/send.c @@ -202,6 +202,20 @@ send_skb_err: return NET_XMIT_DROP; }

+void send_packet_list(struct hlist_head *packet_list) +{ + struct packet_list_entry *entry; + struct hlist_node *pos, *tmp; + + hlist_for_each_entry_safe(entry, pos, tmp, packet_list, list) { + send_skb_packet(entry->skb, entry->neigh_node->if_incoming, + entry->neigh_node->addr); + neigh_node_free_ref(entry->neigh_node); + hlist_del(&entry->list); + kfree(entry); + } +} + /* Send a packet to a given interface */ static void send_packet_to_if(struct forw_packet *forw_packet, struct hard_iface *hard_iface) diff --git a/send.h b/send.h index 7b2ff19..290195e 100644 --- a/send.h +++ b/send.h @@ -22,9 +22,16 @@ #ifndef _NET_BATMAN_ADV_SEND_H_ #define _NET_BATMAN_ADV_SEND_H_

+struct packet_list_entry { + struct hlist_node list; + struct sk_buff *skb; + struct neigh_node *neigh_node; +}; + int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface, uint8_t *dst_addr); +void send_packet_list(struct hlist_head *packet_list); void schedule_own_packet(struct hard_iface *hard_iface); void schedule_forward_packet(struct orig_node *orig_node, struct ethhdr *ethhdr, diff --git a/soft-interface.c b/soft-interface.c index 07fe7c8..8224fdc 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -466,8 +466,7 @@ void interface_rx(struct net_device *soft_iface, bat_priv->softif_neigh->addr, ETH_ALEN);

orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - ret = route_unicast_packet(skb, recv_if, orig_node, - unicast_packet->header.packet_type); + ret = route_unicast_packet(skb, recv_if, orig_node); if (ret == NET_RX_DROP) goto dropped;

diff --git a/unicast.c b/unicast.c index 54e956b..07ef785 100644 --- a/unicast.c +++ b/unicast.c @@ -217,17 +217,43 @@ out: return ret; }

-int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, - struct hard_iface *hard_iface, uint8_t dstaddr[]) +static void frag_reassemble_packet(struct packet_list_entry *entry, + struct bat_priv *bat_priv) +{ + struct sk_buff *new_skb = NULL; + int ret; + + ret = frag_reassemble_skb(entry->skb, bat_priv, &new_skb); + + /* Could reassemble packet, leave this new one in list */ + if (new_skb) { + entry->skb = new_skb; + return; + } + + /* merge failed */ + if (ret == NET_RX_DROP) + kfree_skb(entry->skb); + + /* merge failed or skb is buffered, remove from send list */ + neigh_node_free_ref(entry->neigh_node); + hlist_del(&entry->list); + kfree(entry); +} + +static void frag_skb(struct packet_list_entry *entry, struct bat_priv *bat_priv) { struct unicast_packet tmp_uc, *unicast_packet; struct sk_buff *frag_skb; struct unicast_frag_packet *frag1, *frag2; + struct packet_list_entry *frag_entry; int uc_hdr_len = sizeof(struct unicast_packet); int ucf_hdr_len = sizeof(struct unicast_frag_packet); - int data_len = skb->len - uc_hdr_len; + int data_len = entry->skb->len - uc_hdr_len; int large_tail = 0; uint16_t seqno; + struct sk_buff *skb = entry->skb; + struct hard_iface *hard_iface = entry->neigh_node->if_incoming;

if (!bat_priv->primary_if) goto dropped; @@ -266,15 +292,79 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, frag1->seqno = htons(seqno - 1); frag2->seqno = htons(seqno);

- send_skb_packet(skb, hard_iface, dstaddr); - send_skb_packet(frag_skb, hard_iface, dstaddr); - return NET_RX_SUCCESS; + frag_entry = kmalloc(sizeof(struct packet_list_entry), GFP_ATOMIC); + if (!frag_entry) + goto drop_frag; + + if (!atomic_inc_not_zero(&entry->neigh_node->refcount)) + goto drop_frag; + + frag_entry->skb = frag_skb; + frag_entry->neigh_node = entry->neigh_node; + hlist_add_before(&frag_entry->list, &entry->list);

drop_frag: kfree_skb(frag_skb); dropped: kfree_skb(skb); - return NET_RX_DROP; + neigh_node_free_ref(entry->neigh_node); + hlist_del(&entry->list); + kfree(entry); +} + +static inline int frag_can_reassemble(struct sk_buff *skb, int mtu) +{ + struct unicast_frag_packet *unicast_packet; + int uneven_correction = 0; + unsigned int merged_size; + + unicast_packet = (struct unicast_frag_packet *)skb->data; + + if (unicast_packet->flags & UNI_FRAG_LARGETAIL) { + if (unicast_packet->flags & UNI_FRAG_HEAD) + uneven_correction = 1; + else + uneven_correction = -1; + } + + merged_size = (skb->len - 2 * sizeof(struct unicast_frag_packet)); + merged_size += sizeof(struct unicast_packet) + uneven_correction; + + return merged_size <= mtu; +} + +void frag_packet_list(struct bat_priv *bat_priv, + struct hlist_head *packet_list) +{ + struct packet_list_entry *entry; + struct hlist_node *pos, *tmp; + uint8_t packet_type; + + hlist_for_each_entry_safe(entry, pos, tmp, packet_list, list) { + packet_type = ((struct batman_header *) + entry->skb->data)->packet_type; + + switch (packet_type) { + case BAT_UNICAST: + if (!atomic_read(&bat_priv->fragmentation) || + entry->skb->len <= + entry->neigh_node->if_incoming->net_dev->mtu) + break; + + frag_skb(entry, bat_priv); + break; + case BAT_UNICAST_FRAG: + if (!frag_can_reassemble(entry->skb, + entry->neigh_node->if_incoming->net_dev->mtu)) + break; + + frag_reassemble_packet(entry, bat_priv); + break; + default: + /* We should never be here... */ + break; + } + } }

int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) @@ -308,8 +398,7 @@ route: /* copy the destination for faster routing */ memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);

- ret = route_unicast_packet(skb, NULL, orig_node, - unicast_packet->header.packet_type); + ret = route_unicast_packet(skb, NULL, orig_node);

out: if (ret == NET_RX_DROP) diff --git a/unicast.h b/unicast.h index 16ad7a9..1b4dbb0 100644 --- a/unicast.h +++ b/unicast.h @@ -30,29 +30,8 @@ int frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv, struct sk_buff **new_skb); void frag_list_free(struct list_head *head); +void frag_packet_list(struct bat_priv *bat_priv, + struct hlist_head *packet_list); int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv); -int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, - struct hard_iface *hard_iface, uint8_t dstaddr[]); - -static inline int frag_can_reassemble(struct sk_buff *skb, int mtu) -{ - struct unicast_frag_packet *unicast_packet; - int uneven_correction = 0; - unsigned int merged_size; - - unicast_packet = (struct unicast_frag_packet *)skb->data; - - if (unicast_packet->flags & UNI_FRAG_LARGETAIL) { - if (unicast_packet->flags & UNI_FRAG_HEAD) - uneven_correction = 1; - else - uneven_correction = -1; - } - - merged_size = (skb->len - sizeof(struct unicast_frag_packet)) * 2; - merged_size += sizeof(struct unicast_packet) + uneven_correction; - - return merged_size <= mtu; -}

#endif /* _NET_BATMAN_ADV_UNICAST_H_ */

When bonding is enabled, then enabling red_bonding too changes the behavior from throughput bonding (round robin sending on interfaces) to redundant bonding (sending every packet on all interfaces available for bonding).

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- bat_sysfs.c | 10 ++++++++++ soft-interface.c | 1 + types.h | 1 + 3 files changed, 12 insertions(+), 0 deletions(-)

diff --git a/bat_sysfs.c b/bat_sysfs.c index e449bf6..3b8cf26 100644 --- a/bat_sysfs.c +++ b/bat_sysfs.c @@ -356,8 +356,17 @@ static ssize_t store_gw_bwidth(struct kobject *kobj, struct attribute *attr, return gw_bandwidth_set(net_dev, buff, count); }

+static void print_bonding_notice(struct net_device *net_dev) +{ + bat_info(net_dev, "Redundant Bonding mode is currently not compatible " + "with batman-adv's link layer fragmentation and will " + "be ignored. Also make sure to activate general " + "bonding for redundant bonding to take effect.\n"); +} + BAT_ATTR_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(bonding, S_IRUGO | S_IWUSR, NULL); +BAT_ATTR_BOOL(red_bonding, S_IRUGO | S_IWUSR, print_bonding_notice); BAT_ATTR_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu); static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode); static BAT_ATTR(gw_mode, S_IRUGO | S_IWUSR, show_gw_mode, store_gw_mode); @@ -374,6 +383,7 @@ BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 3, NULL); static struct bat_attribute *mesh_attrs[] = { &bat_attr_aggregated_ogms, &bat_attr_bonding, + &bat_attr_red_bonding, &bat_attr_fragmentation, &bat_attr_vis_mode, &bat_attr_gw_mode, diff --git a/soft-interface.c b/soft-interface.c index 8224fdc..7f0e768 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -571,6 +571,7 @@ struct net_device *softif_create(char *name)

atomic_set(&bat_priv->aggregated_ogms, 1); atomic_set(&bat_priv->bonding, 0); + atomic_set(&bat_priv->red_bonding, 0); atomic_set(&bat_priv->vis_mode, VIS_TYPE_CLIENT_UPDATE); atomic_set(&bat_priv->gw_mode, GW_MODE_OFF); atomic_set(&bat_priv->gw_sel_class, 20); diff --git a/types.h b/types.h index 83445cf..0ce4b99 100644 --- a/types.h +++ b/types.h @@ -133,6 +133,7 @@ struct bat_priv { struct net_device_stats stats; atomic_t aggregated_ogms; /* boolean */ atomic_t bonding; /* boolean */ + atomic_t red_bonding; /* boolean */ atomic_t fragmentation; /* boolean */ atomic_t vis_mode; /* VIS_TYPE_* */ atomic_t gw_mode; /* GW_MODE_* */

With this feature unicast packets can be send in a redundancy bonding instead of throughput bonding mode on all interfaces available towards a common node. This shall increase the robustness of unicast data transfer / decrease packet loss in cases where bursty packet loss on only one channel, which batman-adv's link quality measurements cannot detect, is to be expected or where batman-adv's metric adaptation is expected to be too slow for certain scenarios.

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- main.h | 5 ++ packet.h | 8 ++++ routing.c | 117 ++++++++++++++++++++++++++++++++++++++++++++++++----- routing.h | 3 +- soft-interface.c | 8 +++- types.h | 1 + unicast.c | 10 +++-- unicast.h | 2 +- 8 files changed, 135 insertions(+), 19 deletions(-)

diff --git a/main.h b/main.h index a0059dd..c6d4848 100644 --- a/main.h +++ b/main.h @@ -97,6 +97,11 @@ * Vis */

+/* Bonding modes */ +#define THROUGHPUT_BONDING 1 +#define REDUNDANT_BONDING 2 + + /* * Kernel headers */ diff --git a/packet.h b/packet.h index ae7a0ce..e5a897c 100644 --- a/packet.h +++ b/packet.h @@ -30,6 +30,7 @@ #define BAT_BCAST 0x04 #define BAT_VIS 0x05 #define BAT_UNICAST_FRAG 0x06 +#define BAT_UNICAST_SAFE 0x07

/* this file is included by batctl which needs these defines */ #define COMPAT_VERSION 12 @@ -101,6 +102,13 @@ struct unicast_packet { uint8_t dest[6]; } __packed;

+struct unicast_packet_safe { + struct batman_header header; + uint8_t dest[6]; + uint8_t orig[6]; + uint32_t seqno; +} __packed; + struct unicast_frag_packet { struct batman_header header; uint8_t dest[6]; diff --git a/routing.c b/routing.c index ba4756c..f17834a 100644 --- a/routing.c +++ b/routing.c @@ -1018,10 +1018,77 @@ out: return ret; }

+static int unicast_to_unicast_safe(struct sk_buff *skb, + struct bat_priv *bat_priv) +{ + struct unicast_packet unicast_packet; + struct unicast_packet_safe *unicast_packet_safe; + + memcpy(&unicast_packet, skb->data, sizeof(unicast_packet)); + if (my_skb_head_push(skb, sizeof(struct unicast_packet_safe) - + sizeof(struct unicast_packet)) < 0) + return -1; + + unicast_packet_safe = (struct unicast_packet_safe *) skb->data; + unicast_packet_safe->header = unicast_packet.header; + memcpy(unicast_packet_safe->dest, unicast_packet.dest, ETH_ALEN); + unicast_packet_safe->header.packet_type = BAT_UNICAST_SAFE; + memcpy(unicast_packet_safe->orig, + bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); + unicast_packet_safe->seqno = + htonl(atomic_inc_return(&bat_priv->dup_seqno)); + + return 0; +} + +static void red_bonding_copy(struct sk_buff *skb, struct list_head *bond_list, + struct hlist_head *packet_list, + struct bat_priv *bat_priv) +{ + struct neigh_node *neigh_node; + struct packet_list_entry *entry; + int num_entries = 0; + int packet_type = ((struct batman_header *) skb->data)->packet_type; + + /* We only expect either BAT_UNICAST or BAT_UNICAST_SAFE here */ + if (packet_type == BAT_UNICAST) { + if (unicast_to_unicast_safe(skb, bat_priv) < 0) { + kfree_skb(skb); + return; + } + } + + list_for_each_entry_rcu(neigh_node, bond_list, bonding_list) { + entry = kmalloc(sizeof(struct packet_list_entry), GFP_ATOMIC); + if (!entry) { + kfree_skb(skb); + return; + } + if (!num_entries) + entry->skb = skb; + else { + entry->skb = skb_copy(skb, GFP_ATOMIC); + if (!entry->skb) { + kfree_skb(skb); + kfree(entry); + return; + } + } + entry->neigh_node = neigh_node; + if (!atomic_inc_not_zero(&neigh_node->refcount)) { + kfree_skb(entry->skb); + kfree(entry); + continue; + } + hlist_add_head(&entry->list, packet_list); + num_entries++; + } +} + /* find a suitable router for this originator, and use * bonding if possible. increases the found neighbors * refcount.*/ -static void find_router(struct orig_node *orig_node, +static void find_router(int bonding_mode, struct orig_node *orig_node, struct hard_iface *recv_if, struct sk_buff *skb, struct hlist_head *packet_list) @@ -1032,7 +1099,6 @@ static void find_router(struct orig_node *orig_node, struct neigh_node *router, *first_candidate, *tmp_neigh_node; struct packet_list_entry *entry; static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; - int bonding_enabled;

if (!orig_node) return; @@ -1044,7 +1110,6 @@ static void find_router(struct orig_node *orig_node,

/* without bonding, the first node should * always choose the default router. */ - bonding_enabled = atomic_read(&bat_priv->bonding);

rcu_read_lock(); /* select default router to output */ @@ -1055,7 +1120,7 @@ static void find_router(struct orig_node *orig_node, return; }

- if ((!recv_if) && (!bonding_enabled)) + if ((!recv_if) && (!bonding_mode)) goto return_router;

/* if we have something in the primary_addr, we can search @@ -1091,7 +1156,7 @@ static void find_router(struct orig_node *orig_node, first_candidate = NULL; router = NULL;

- if (bonding_enabled) { + if (bonding_mode == THROUGHPUT_BONDING) { /* in the bonding case, send the packets in a round * robin fashion over the remaining interfaces. */

@@ -1127,6 +1192,11 @@ static void find_router(struct orig_node *orig_node, &router->bonding_list); spin_unlock_bh(&primary_orig_node->neigh_list_lock);

+ } else if (bonding_mode == REDUNDANT_BONDING) { + red_bonding_copy(skb, &primary_orig_node->bond_list, + packet_list, bat_priv); + rcu_read_unlock(); + return; } else { /* if bonding is disabled, use the best of the * remaining candidates which are not using @@ -1203,12 +1273,16 @@ static int check_unicast_packet(struct sk_buff *skb, int hdr_size) return 0; }

-int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, +int route_unicast_packet(int bonding_mode, struct sk_buff *skb, + struct hard_iface *recv_if, struct orig_node *orig_node) { int ret = NET_RX_DROP; struct hlist_head packet_list;

+ if (!orig_node) + goto out; + INIT_HLIST_HEAD(&packet_list);

/* create a copy of the skb, if needed, to modify it. */ @@ -1216,10 +1290,10 @@ int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, goto out;

/* creates the (initial) packet list */ - find_router(orig_node, recv_if, skb, &packet_list); + find_router(bonding_mode, orig_node, recv_if, skb, &packet_list);

/* split packets that won't fit or maybe buffer fragments */ - frag_packet_list(orig_node->bat_priv, &packet_list); + frag_packet_list(bonding_mode, orig_node->bat_priv, &packet_list);

/* route them */ send_packet_list(&packet_list); @@ -1238,6 +1312,7 @@ int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) struct unicast_packet *unicast_packet; struct orig_node *orig_node; int hdr_size = sizeof(struct unicast_packet); + int bonding_mode;

if (check_unicast_packet(skb, hdr_size) < 0) return NET_RX_DROP; @@ -1250,8 +1325,10 @@ int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) return NET_RX_SUCCESS; }

+ bonding_mode = atomic_read(&bat_priv->bonding) << + atomic_read(&bat_priv->red_bonding); orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - return route_unicast_packet(skb, recv_if, orig_node); + return route_unicast_packet(bonding_mode, skb, recv_if, orig_node); }

int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) @@ -1261,7 +1338,7 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) struct orig_node *orig_node; int hdr_size = sizeof(struct unicast_frag_packet); struct sk_buff *new_skb = NULL; - int ret; + int ret, bonding_mode;

if (check_unicast_packet(skb, hdr_size) < 0) return NET_RX_DROP; @@ -1285,8 +1362,26 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) return NET_RX_SUCCESS; }

+ /* The redundant bonding mode currently cannot handle fragmented + * packets, therefore need to defrag them first */ + bonding_mode = atomic_read(&bat_priv->bonding) << + atomic_read(&bat_priv->red_bonding); + + if (bonding_mode == REDUNDANT_BONDING) { + ret = frag_reassemble_skb(skb, bat_priv, &new_skb); + + if (ret == NET_RX_DROP) + return NET_RX_DROP; + + /* packet was buffered for late merge */ + if (!new_skb) + return NET_RX_SUCCESS; + + skb = new_skb; + } + orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - return route_unicast_packet(skb, recv_if, orig_node); + return route_unicast_packet(bonding_mode, skb, recv_if, orig_node); }

diff --git a/routing.h b/routing.h index 681512b..1530c6d 100644 --- a/routing.h +++ b/routing.h @@ -30,7 +30,8 @@ void receive_bat_packet(struct ethhdr *ethhdr, void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node, struct neigh_node *neigh_node, unsigned char *hna_buff, int hna_buff_len); -int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if, +int route_unicast_packet(int bonding_mode, struct sk_buff *skb, + struct hard_iface *recv_if, struct orig_node *orig_node); int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if); diff --git a/soft-interface.c b/soft-interface.c index 7f0e768..15e08cf 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -424,7 +424,7 @@ void interface_rx(struct net_device *soft_iface, struct ethhdr *ethhdr; struct vlan_ethhdr *vhdr; short vid = -1; - int ret; + int ret, bonding_mode;

/* check if enough space is available for pulling, and pull */ if (!pskb_may_pull(skb, hdr_size)) @@ -465,8 +465,11 @@ void interface_rx(struct net_device *soft_iface, memcpy(unicast_packet->dest, bat_priv->softif_neigh->addr, ETH_ALEN);

+ bonding_mode = atomic_read(&bat_priv->bonding) << + atomic_read(&bat_priv->red_bonding); orig_node = orig_hash_find(bat_priv, unicast_packet->dest); - ret = route_unicast_packet(skb, recv_if, orig_node); + ret = route_unicast_packet(bonding_mode, skb, recv_if, + orig_node); if (ret == NET_RX_DROP) goto dropped;

@@ -585,6 +588,7 @@ struct net_device *softif_create(char *name)

atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); atomic_set(&bat_priv->bcast_seqno, 1); + atomic_set(&bat_priv->dup_seqno, 1); atomic_set(&bat_priv->hna_local_changed, 0);

bat_priv->primary_if = NULL; diff --git a/types.h b/types.h index 0ce4b99..3f625aa 100644 --- a/types.h +++ b/types.h @@ -143,6 +143,7 @@ struct bat_priv { atomic_t hop_penalty; /* uint */ atomic_t log_level; /* uint */ atomic_t bcast_seqno; + atomic_t dup_seqno; atomic_t bcast_queue_left; atomic_t batman_queue_left; char num_ifaces; diff --git a/unicast.c b/unicast.c index 07ef785..9261607 100644 --- a/unicast.c +++ b/unicast.c @@ -30,7 +30,6 @@ #include "routing.h" #include "hard-interface.h"

- static struct sk_buff *frag_merge_packet(struct list_head *head, struct frag_packet_list_entry *tfp, struct sk_buff *skb) @@ -333,7 +332,7 @@ static inline int frag_can_reassemble(struct sk_buff *skb, int mtu) return merged_size <= mtu; }

-void frag_packet_list(struct bat_priv *bat_priv, +void frag_packet_list(int bonding, struct bat_priv *bat_priv, struct hlist_head *packet_list) { struct packet_list_entry *entry; @@ -347,6 +346,7 @@ void frag_packet_list(struct bat_priv *bat_priv, switch (packet_type) { case BAT_UNICAST: if (!atomic_read(&bat_priv->fragmentation) || + bonding == REDUNDANT_BONDING || entry->skb->len <= entry->neigh_node->if_incoming->net_dev->mtu) break; @@ -372,7 +372,7 @@ int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) struct ethhdr *ethhdr = (struct ethhdr *)skb->data; struct unicast_packet *unicast_packet; struct orig_node *orig_node; - int ret = NET_RX_DROP; + int ret = NET_RX_DROP, bonding_mode;

/* get routing information */ if (is_multicast_ether_addr(ethhdr->h_dest)) { @@ -398,7 +398,9 @@ route: /* copy the destination for faster routing */ memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);

- ret = route_unicast_packet(skb, NULL, orig_node); + bonding_mode = atomic_read(&bat_priv->bonding) << + atomic_read(&bat_priv->red_bonding); + ret = route_unicast_packet(bonding_mode, skb, NULL, orig_node);

out: if (ret == NET_RX_DROP) diff --git a/unicast.h b/unicast.h index 1b4dbb0..e87597b 100644 --- a/unicast.h +++ b/unicast.h @@ -30,7 +30,7 @@ int frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv, struct sk_buff **new_skb); void frag_list_free(struct list_head *head); -void frag_packet_list(struct bat_priv *bat_priv, +void frag_packet_list(int bonding, struct bat_priv *bat_priv, struct hlist_head *packet_list); int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv);

With this commit unicast_safe packets generated by a node in redundant bonding mode will be processed on reception. It is being transformed back to a normal unicast packet if the packet is for the node itself or if redundant bonding mode is deactivated on this node. Otherwise it is being passed on as is to the routing functions.

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- hard-interface.c | 5 ++++ routing.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++--- routing.h | 1 + 3 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/hard-interface.c b/hard-interface.c index b0105e9..7164b1f 100644 --- a/hard-interface.c +++ b/hard-interface.c @@ -624,6 +624,11 @@ static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, ret = recv_ucast_frag_packet(skb, hard_iface); break;

+ /* fragmented unicast packet */ + case BAT_UNICAST_SAFE: + ret = recv_ucast_safe_packet(skb, hard_iface); + break; + /* broadcast packet */ case BAT_BCAST: ret = recv_bcast_packet(skb, hard_iface); diff --git a/routing.c b/routing.c index f17834a..d31a7ad 100644 --- a/routing.c +++ b/routing.c @@ -1018,6 +1018,29 @@ out: return ret; }

+static void unicast_safe_to_unicast(struct sk_buff *skb) +{ + struct unicast_packet_safe unicast_packet_safe; + struct unicast_packet *unicast_packet; + + unicast_packet_safe = *((struct unicast_packet_safe *)skb->data); + unicast_packet = (struct unicast_packet *) skb_pull(skb, + sizeof(struct unicast_packet_safe) - + sizeof(struct unicast_packet)); + + unicast_packet->header = unicast_packet_safe.header; + unicast_packet->header.packet_type = BAT_UNICAST; + memcpy(unicast_packet->dest, unicast_packet_safe.dest, ETH_ALEN); +} + +static void set_unicast_safe_options(struct bat_priv *bat_priv, + struct unicast_packet_safe *unicast_packet) +{ + memcpy(unicast_packet->orig, bat_priv->primary_if->net_dev->dev_addr, + ETH_ALEN); + unicast_packet->seqno = htonl(atomic_inc_return(&bat_priv->dup_seqno)); +} + static int unicast_to_unicast_safe(struct sk_buff *skb, struct bat_priv *bat_priv) { @@ -1033,10 +1056,7 @@ static int unicast_to_unicast_safe(struct sk_buff *skb, unicast_packet_safe->header = unicast_packet.header; memcpy(unicast_packet_safe->dest, unicast_packet.dest, ETH_ALEN); unicast_packet_safe->header.packet_type = BAT_UNICAST_SAFE; - memcpy(unicast_packet_safe->orig, - bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); - unicast_packet_safe->seqno = - htonl(atomic_inc_return(&bat_priv->dup_seqno)); + set_unicast_safe_options(bat_priv, unicast_packet_safe);

return 0; } @@ -1384,6 +1404,38 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) return route_unicast_packet(bonding_mode, skb, recv_if, orig_node); }

+int recv_ucast_safe_packet(struct sk_buff *skb, struct hard_iface *recv_if) +{ + struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct unicast_packet_safe *unicast_packet; + struct orig_node *orig_node; + int hdr_size = sizeof(struct unicast_packet); + int bonding_mode; + + if (check_unicast_packet(skb, hdr_size) < 0) + return NET_RX_DROP; + + unicast_packet = (struct unicast_packet_safe *)skb->data; + + /* packet for me */ + if (is_my_mac(unicast_packet->dest)) { + unicast_safe_to_unicast(skb); + + interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); + return NET_RX_SUCCESS; + } + + bonding_mode = atomic_read(&bat_priv->bonding) << + atomic_read(&bat_priv->red_bonding); + + if (bonding_mode != REDUNDANT_BONDING) + unicast_safe_to_unicast(skb); + else + set_unicast_safe_options(bat_priv, unicast_packet); + + orig_node = hash_find_orig(bat_priv, unicast_packet->dest); + return route_unicast_packet(bonding_mode, skb, recv_if, orig_node); +}

int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) { diff --git a/routing.h b/routing.h index 1530c6d..8608ac3 100644 --- a/routing.h +++ b/routing.h @@ -36,6 +36,7 @@ int route_unicast_packet(int bonding_mode, struct sk_buff *skb, int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if); +int recv_ucast_safe_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if); int recv_bat_packet(struct sk_buff *skb, struct hard_iface *recv_if);

With the new redundant bonding mode a node might receive a unicast_safe packet more than once. Therefore duplicate checks on any unicast_safe packet need to be performed before further processing.

Signed-off-by: Linus Lüssing linus.luessing@ascom.ch --- originator.c | 3 +++ routing.c | 14 +++++++++++++- types.h | 2 ++ 3 files changed, 18 insertions(+), 1 deletions(-)

diff --git a/originator.c b/originator.c index 57cb5c9..3be8460 100644 --- a/originator.c +++ b/originator.c @@ -198,6 +198,7 @@ struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr) INIT_LIST_HEAD(&orig_node->bond_list); spin_lock_init(&orig_node->ogm_cnt_lock); spin_lock_init(&orig_node->bcast_seqno_lock); + spin_lock_init(&orig_node->ucast_safe_seqno_lock); spin_lock_init(&orig_node->neigh_list_lock);

/* extra reference for return */ @@ -209,6 +210,8 @@ struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr) orig_node->hna_buff = NULL; orig_node->bcast_seqno_state.seqno_reset = jiffies - 1 - msecs_to_jiffies(RESET_PROTECTION_MS); + orig_node->ucast_safe_seqno_state.seqno_reset = jiffies - 1 + - msecs_to_jiffies(RESET_PROTECTION_MS); orig_node->batman_seqno_reset = jiffies - 1 - msecs_to_jiffies(RESET_PROTECTION_MS);

diff --git a/routing.c b/routing.c index a2c55fd..d19eb77 100644 --- a/routing.c +++ b/routing.c @@ -1440,13 +1440,25 @@ int recv_ucast_safe_packet(struct sk_buff *skb, struct hard_iface *recv_if) struct unicast_packet_safe *unicast_packet; struct orig_node *orig_node; int hdr_size = sizeof(struct unicast_packet); - int bonding_mode; + int ret, bonding_mode;

if (check_unicast_packet(skb, hdr_size) < 0) return NET_RX_DROP;

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

+ orig_node = orig_hash_find(bat_priv, unicast_packet->orig); + if (!orig_node) + return NET_RX_DROP; + + ret = check_duplicate(bat_priv, ntohl(unicast_packet->seqno), + &orig_node->ucast_safe_seqno_state, + &orig_node->ucast_safe_seqno_lock); + + orig_node_free_ref(orig_node); + if (ret == NET_RX_DROP) + return NET_RX_DROP; + /* packet for me */ if (is_my_mac(unicast_packet->dest)) { unicast_safe_to_unicast(skb); diff --git a/types.h b/types.h index cceff07..bfab0c7 100644 --- a/types.h +++ b/types.h @@ -93,11 +93,13 @@ struct orig_node { struct bat_priv *bat_priv; unsigned long last_frag_packet; struct seqno_state bcast_seqno_state; + struct seqno_state ucast_safe_seqno_state; spinlock_t ogm_cnt_lock; /* protects: bcast_own, bcast_own_sum, * neigh_node->real_bits, * neigh_node->real_packet_count */ spinlock_t bcast_seqno_lock; /* protects bcast_bits, * last_bcast_seqno */ + spinlock_t ucast_safe_seqno_lock; /* protects ucast_safe_seqno_state */ atomic_t bond_candidates; struct list_head bond_list; };