Open-Mesh » batman-adv

/* This is the offset of the options field in a dhcp packet starting at

* the beginning of the dhcp header */

#define DHCP_OPTIONS_OFFSET 240

#define DHCP_REQUEST 3

#include "translation-table.h"

#include "originator.h"

#include "routing.h"

#include <linux/ip.h>

#include <linux/ipv6.h>

#include <linux/udp.h>

#include <linux/if_vlan.h>

static inline void gw_node_free_ref(struct gw_node *gw_node)

{

if (atomic_dec_and_test(&gw_node->refcount))

kfree_rcu(gw_node, rcu);

}

static inline struct gw_node *gw_get_selected_gw_node(struct bat_priv *bat_priv)

{

struct gw_node *gw_node;

rcu_read_lock();

gw_node = rcu_dereference(bat_priv->curr_gw);

if (!gw_node)

goto out;

if (!atomic_inc_not_zero(&gw_node->refcount))

gw_node = NULL;

out:

rcu_read_unlock();

return gw_node;

}

static inline bool is_type_dhcprequest(struct sk_buff *skb, int header_len)

{

int ret = false;

unsigned char *p;

int pkt_len;

if (skb_linearize(skb) < 0)

goto out;

pkt_len = skb_headlen(skb);

if (pkt_len < header_len + DHCP_OPTIONS_OFFSET + 1)

goto out;

p = skb->data + header_len + DHCP_OPTIONS_OFFSET;

pkt_len -= header_len + DHCP_OPTIONS_OFFSET + 1;

/* Access the dhcp option lists. Each entry is made up by:

* - octect 1: option type

* - octect 2: option data len (only if type != 255 and 0)

* - octect 3: option data */

while (*p != 255 && !ret) {

/* p now points to the first octect: option type */

if (*p == 53) {

/* type 53 is the message type option.

* Jump the len octect and go to the data octect */

if (pkt_len < 2)

goto out;

p += 2;

/* check if the message type is what we need */

if (*p == DHCP_REQUEST)

ret = true;

break;

} else if (*p == 0) {

/* option type 0 (padding), just go forward */

if (pkt_len < 1)

goto out;

pkt_len--;

p++;

} else {

/* This is any other option. So we get the length... */

if (pkt_len < 1)

goto out;

pkt_len--;

p++;

/* ...and then we jump over the data */

if (pkt_len < *p)

goto out;

pkt_len -= *p;

p += (*p);

}

}

out:

return ret;

}

static inline bool gw_is_dhcp_target(struct sk_buff *skb,

unsigned int *header_len)

{

struct ethhdr *ethhdr;

struct iphdr *iphdr;

struct ipv6hdr *ipv6hdr;

struct udphdr *udphdr;

/* check for ethernet header */

if (!pskb_may_pull(skb, *header_len + ETH_HLEN))

return false;

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

*header_len += ETH_HLEN;

/* check for initial vlan header */

if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {

if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))

return false;

ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);

*header_len += VLAN_HLEN;

}

/* check for ip header */

switch (ntohs(ethhdr->h_proto)) {

case ETH_P_IP:

if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))

return false;

iphdr = (struct iphdr *)(skb->data + *header_len);

*header_len += iphdr->ihl * 4;

/* check for udp header */

if (iphdr->protocol != IPPROTO_UDP)

return false;

break;

case ETH_P_IPV6:

if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))

return false;

ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);

*header_len += sizeof(*ipv6hdr);

/* check for udp header */

if (ipv6hdr->nexthdr != IPPROTO_UDP)

return false;

break;

default:

return false;

}

if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))

return false;

udphdr = (struct udphdr *)(skb->data + *header_len);

*header_len += sizeof(*udphdr);

/* check for bootp port */

if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&

(ntohs(udphdr->dest) != 67))

return false;

if ((ntohs(ethhdr->h_proto) == ETH_P_IPV6) &&

(ntohs(udphdr->dest) != 547))

return false;

return true;

}

static inline bool gw_out_of_range(struct bat_priv *bat_priv,

struct sk_buff *skb, struct ethhdr *ethhdr)

{

struct neigh_node *neigh_curr = NULL, *neigh_old = NULL;

struct orig_node *orig_dst_node = NULL;

struct gw_node *curr_gw = NULL;

bool ret, out_of_range = false;

unsigned int header_len = 0;

ret = gw_is_dhcp_target(skb, &header_len);

if (!ret)

goto out;

orig_dst_node = transtable_search(bat_priv, ethhdr->h_dest);

if (!orig_dst_node)

goto out;

if (!orig_dst_node->gw_flags)

goto out;

curr_gw = gw_get_selected_gw_node(bat_priv);

if (!curr_gw)

goto out;

/* packet is going to our gateway */

if (curr_gw->orig_node == orig_dst_node)

goto out;

/* TODO: what happens if the node itself is a gateway ? */

ret = is_type_dhcprequest(skb, header_len);

if (!ret)

goto out;

/* If the dhcp packet has been sent to a different gw,

* we have to evaluate whether the old gw is still

* reliable enough */

neigh_curr = find_router(bat_priv, curr_gw->orig_node, NULL);

if (!neigh_curr)

goto out;

neigh_old = find_router(bat_priv, orig_dst_node, NULL);

if (!!neigh_old)

goto out;

if (neigh_curr->tq_avg - neigh_old->tq_avg > GW_THRESHOLD)

out_of_range = true;

out:

if (orig_dst_node)

orig_node_free_ref(orig_dst_node);

if (curr_gw)

gw_node_free_ref(curr_gw);

if (neigh_old)

neigh_node_free_ref(neigh_old);

if (neigh_curr)

neigh_node_free_ref(neigh_curr);

return out_of_range;

}

unsigned int header_len = 0;

if (is_multicast_ether_addr(ethhdr->h_dest)) {

do_bcast = true;

switch (atomic_read(&bat_priv->gw_mode)) {

case GW_MODE_SERVER:

/* gateway servers should not send dhcp

* requests into the mesh */

ret = gw_is_dhcp_target(skb, &header_len);

if (ret)

goto dropped;

break;

case GW_MODE_CLIENT:

/* gateway clients should send dhcp requests

* via unicast to their gateway */

ret = gw_is_dhcp_target(skb, &header_len);

if (ret)

do_bcast = false;

break;

case GW_MODE_OFF:

printk(KERN_INFO "interface_tx(): bcast check: gw mode off\n");

break;

}

if (atomic_read(&bat_priv->gw_mode) != GW_MODE_OFF) {

ret = gw_out_of_range(bat_priv, skb, ethhdr);

if (ret)

goto dropped;

}