net/batman-adv/gateway_client.c

   1 /*
   2  * Copyright (C) 2009-2010 B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA
  19  *
  20  */
  21
  22 #include "main.h"
  23 #include "gateway_client.h"
  24 #include "gateway_common.h"
  25 #include "hard-interface.h"
  26 #include <linux/ip.h>
  27 #include <linux/ipv6.h>
  28 #include <linux/udp.h>
  29 #include <linux/if_vlan.h>
  30
  31 static void gw_node_free_ref(struct kref *refcount)
  32 {
  33         struct gw_node *gw_node;
  34
  35         gw_node = container_of(refcount, struct gw_node, refcount);
  36         kfree(gw_node);
  37 }
  38
  39 static void gw_node_free_rcu(struct rcu_head *rcu)
  40 {
  41         struct gw_node *gw_node;
  42
  43         gw_node = container_of(rcu, struct gw_node, rcu);
  44         kref_put(&gw_node->refcount, gw_node_free_ref);
  45 }
  46
  47 void *gw_get_selected(struct bat_priv *bat_priv)
  48 {
  49         struct gw_node *curr_gateway_tmp = bat_priv->curr_gw;
  50
  51         if (!curr_gateway_tmp)
  52                 return NULL;
  53
  54         return curr_gateway_tmp->orig_node;
  55 }
  56
  57 void gw_deselect(struct bat_priv *bat_priv)
  58 {
  59         struct gw_node *gw_node = bat_priv->curr_gw;
  60
  61         bat_priv->curr_gw = NULL;
  62
  63         if (gw_node)
  64                 kref_put(&gw_node->refcount, gw_node_free_ref);
  65 }
  66
  67 static struct gw_node *gw_select(struct bat_priv *bat_priv,
  68                           struct gw_node *new_gw_node)
  69 {
  70         struct gw_node *curr_gw_node = bat_priv->curr_gw;
  71
  72         if (new_gw_node)
  73                 kref_get(&new_gw_node->refcount);
  74
  75         bat_priv->curr_gw = new_gw_node;
  76         return curr_gw_node;
  77 }
  78
  79 void gw_election(struct bat_priv *bat_priv)
  80 {
  81         struct hlist_node *node;
  82         struct gw_node *gw_node, *curr_gw_tmp = NULL, *old_gw_node = NULL;
  83         uint8_t max_tq = 0;
  84         uint32_t max_gw_factor = 0, tmp_gw_factor = 0;
  85         int down, up;
  86
  87         /**
  88          * The batman daemon checks here if we already passed a full originator
  89          * cycle in order to make sure we don't choose the first gateway we
  90          * hear about. This check is based on the daemon's uptime which we
  91          * don't have.
  92          **/
  93         if (atomic_read(&bat_priv->gw_mode) != GW_MODE_CLIENT)
  94                 return;
  95
  96         if (bat_priv->curr_gw)
  97                 return;
  98
  99         rcu_read_lock();
 100         if (hlist_empty(&bat_priv->gw_list)) {
 101                 rcu_read_unlock();
 102
 103                 if (bat_priv->curr_gw) {
 104                         bat_dbg(DBG_BATMAN, bat_priv,
 105                                 "Removing selected gateway - "
 106                                 "no gateway in range\n");
 107                         gw_deselect(bat_priv);
 108                 }
 109
 110                 return;
 111         }
 112
 113         hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw_list, list) {
 114                 if (!gw_node->orig_node->router)
 115                         continue;
 116
 117                 if (gw_node->deleted)
 118                         continue;
 119
 120                 switch (atomic_read(&bat_priv->gw_sel_class)) {
 121                 case 1: /* fast connection */
 122                         gw_bandwidth_to_kbit(gw_node->orig_node->gw_flags,
 123                                              &down, &up);
 124
 125                         tmp_gw_factor = (gw_node->orig_node->router->tq_avg *
 126                                          gw_node->orig_node->router->tq_avg *
 127                                          down * 100 * 100) /
 128                                          (TQ_LOCAL_WINDOW_SIZE *
 129                                          TQ_LOCAL_WINDOW_SIZE * 64);
 130
 131                         if ((tmp_gw_factor > max_gw_factor) ||
 132                             ((tmp_gw_factor == max_gw_factor) &&
 133                              (gw_node->orig_node->router->tq_avg > max_tq)))
 134                                 curr_gw_tmp = gw_node;
 135                         break;
 136
 137                 default: /**
 138                           * 2:  stable connection (use best statistic)
 139                           * 3:  fast-switch (use best statistic but change as
 140                           *     soon as a better gateway appears)
 141                           * XX: late-switch (use best statistic but change as
 142                           *     soon as a better gateway appears which has
 143                           *     $routing_class more tq points)
 144                           **/
 145                         if (gw_node->orig_node->router->tq_avg > max_tq)
 146                                 curr_gw_tmp = gw_node;
 147                         break;
 148                 }
 149
 150                 if (gw_node->orig_node->router->tq_avg > max_tq)
 151                         max_tq = gw_node->orig_node->router->tq_avg;
 152
 153                 if (tmp_gw_factor > max_gw_factor)
 154                         max_gw_factor = tmp_gw_factor;
 155         }
 156
 157         if (bat_priv->curr_gw != curr_gw_tmp) {
 158                 if ((bat_priv->curr_gw) && (!curr_gw_tmp))
 159                         bat_dbg(DBG_BATMAN, bat_priv,
 160                                 "Removing selected gateway - "
 161                                 "no gateway in range\n");
 162                 else if ((!bat_priv->curr_gw) && (curr_gw_tmp))
 163                         bat_dbg(DBG_BATMAN, bat_priv,
 164                                 "Adding route to gateway %pM "
 165                                 "(gw_flags: %i, tq: %i)\n",
 166                                 curr_gw_tmp->orig_node->orig,
 167                                 curr_gw_tmp->orig_node->gw_flags,
 168                                 curr_gw_tmp->orig_node->router->tq_avg);
 169                 else
 170                         bat_dbg(DBG_BATMAN, bat_priv,
 171                                 "Changing route to gateway %pM "
 172                                 "(gw_flags: %i, tq: %i)\n",
 173                                 curr_gw_tmp->orig_node->orig,
 174                                 curr_gw_tmp->orig_node->gw_flags,
 175                                 curr_gw_tmp->orig_node->router->tq_avg);
 176
 177                 old_gw_node = gw_select(bat_priv, curr_gw_tmp);
 178         }
 179
 180         rcu_read_unlock();
 181
 182         /* the kfree() has to be outside of the rcu lock */
 183         if (old_gw_node)
 184                 kref_put(&old_gw_node->refcount, gw_node_free_ref);
 185 }
 186
 187 void gw_check_election(struct bat_priv *bat_priv, struct orig_node *orig_node)
 188 {
 189         struct gw_node *curr_gateway_tmp = bat_priv->curr_gw;
 190         uint8_t gw_tq_avg, orig_tq_avg;
 191
 192         if (!curr_gateway_tmp)
 193                 return;
 194
 195         if (!curr_gateway_tmp->orig_node)
 196                 goto deselect;
 197
 198         if (!curr_gateway_tmp->orig_node->router)
 199                 goto deselect;
 200
 201         /* this node already is the gateway */
 202         if (curr_gateway_tmp->orig_node == orig_node)
 203                 return;
 204
 205         if (!orig_node->router)
 206                 return;
 207
 208         gw_tq_avg = curr_gateway_tmp->orig_node->router->tq_avg;
 209         orig_tq_avg = orig_node->router->tq_avg;
 210
 211         /* the TQ value has to be better */
 212         if (orig_tq_avg < gw_tq_avg)
 213                 return;
 214
 215         /**
 216          * if the routing class is greater than 3 the value tells us how much
 217          * greater the TQ value of the new gateway must be
 218          **/
 219         if ((atomic_read(&bat_priv->gw_sel_class) > 3) &&
 220             (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))
 221                 return;
 222
 223         bat_dbg(DBG_BATMAN, bat_priv,
 224                 "Restarting gateway selection: better gateway found (tq curr: "
 225                 "%i, tq new: %i)\n",
 226                 gw_tq_avg, orig_tq_avg);
 227
 228 deselect:
 229         gw_deselect(bat_priv);
 230 }
 231
 232 static void gw_node_add(struct bat_priv *bat_priv,
 233                         struct orig_node *orig_node, uint8_t new_gwflags)
 234 {
 235         struct gw_node *gw_node;
 236         int down, up;
 237
 238         gw_node = kmalloc(sizeof(struct gw_node), GFP_ATOMIC);
 239         if (!gw_node)
 240                 return;
 241
 242         memset(gw_node, 0, sizeof(struct gw_node));
 243         INIT_HLIST_NODE(&gw_node->list);
 244         gw_node->orig_node = orig_node;
 245         kref_init(&gw_node->refcount);
 246
 247         spin_lock_bh(&bat_priv->gw_list_lock);
 248         hlist_add_head_rcu(&gw_node->list, &bat_priv->gw_list);
 249         spin_unlock_bh(&bat_priv->gw_list_lock);
 250
 251         gw_bandwidth_to_kbit(new_gwflags, &down, &up);
 252         bat_dbg(DBG_BATMAN, bat_priv,
 253                 "Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n",
 254                 orig_node->orig, new_gwflags,
 255                 (down > 2048 ? down / 1024 : down),
 256                 (down > 2048 ? "MBit" : "KBit"),
 257                 (up > 2048 ? up / 1024 : up),
 258                 (up > 2048 ? "MBit" : "KBit"));
 259 }
 260
 261 void gw_node_update(struct bat_priv *bat_priv,
 262                     struct orig_node *orig_node, uint8_t new_gwflags)
 263 {
 264         struct hlist_node *node;
 265         struct gw_node *gw_node;
 266
 267         rcu_read_lock();
 268         hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw_list, list) {
 269                 if (gw_node->orig_node != orig_node)
 270                         continue;
 271
 272                 bat_dbg(DBG_BATMAN, bat_priv,
 273                         "Gateway class of originator %pM changed from "
 274                         "%i to %i\n",
 275                         orig_node->orig, gw_node->orig_node->gw_flags,
 276                         new_gwflags);
 277
 278                 gw_node->deleted = 0;
 279
 280                 if (new_gwflags == 0) {
 281                         gw_node->deleted = jiffies;
 282                         bat_dbg(DBG_BATMAN, bat_priv,
 283                                 "Gateway %pM removed from gateway list\n",
 284                                 orig_node->orig);
 285
 286                         if (gw_node == bat_priv->curr_gw) {
 287                                 rcu_read_unlock();
 288                                 gw_deselect(bat_priv);
 289                                 return;
 290                         }
 291                 }
 292
 293                 rcu_read_unlock();
 294                 return;
 295         }
 296         rcu_read_unlock();
 297
 298         if (new_gwflags == 0)
 299                 return;
 300
 301         gw_node_add(bat_priv, orig_node, new_gwflags);
 302 }
 303
 304 void gw_node_delete(struct bat_priv *bat_priv, struct orig_node *orig_node)
 305 {
 306         return gw_node_update(bat_priv, orig_node, 0);
 307 }
 308
 309 void gw_node_purge(struct bat_priv *bat_priv)
 310 {
 311         struct gw_node *gw_node;
 312         struct hlist_node *node, *node_tmp;
 313         unsigned long timeout = 2 * PURGE_TIMEOUT * HZ;
 314
 315         spin_lock_bh(&bat_priv->gw_list_lock);
 316
 317         hlist_for_each_entry_safe(gw_node, node, node_tmp,
 318                                   &bat_priv->gw_list, list) {
 319                 if (((!gw_node->deleted) ||
 320                      (time_before(jiffies, gw_node->deleted + timeout))) &&
 321                     atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE)
 322                         continue;
 323
 324                 if (bat_priv->curr_gw == gw_node)
 325                         gw_deselect(bat_priv);
 326
 327                 hlist_del_rcu(&gw_node->list);
 328                 call_rcu(&gw_node->rcu, gw_node_free_rcu);
 329         }
 330
 331
 332         spin_unlock_bh(&bat_priv->gw_list_lock);
 333 }
 334
 335 static int _write_buffer_text(struct bat_priv *bat_priv,
 336                               struct seq_file *seq, struct gw_node *gw_node)
 337 {
 338         int down, up;
 339
 340         gw_bandwidth_to_kbit(gw_node->orig_node->gw_flags, &down, &up);
 341
 342         return seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %3i - %i%s/%i%s\n",
 343                        (bat_priv->curr_gw == gw_node ? "=>" : "  "),
 344                        gw_node->orig_node->orig,
 345                        gw_node->orig_node->router->tq_avg,
 346                        gw_node->orig_node->router->addr,
 347                        gw_node->orig_node->router->if_incoming->net_dev->name,
 348                        gw_node->orig_node->gw_flags,
 349                        (down > 2048 ? down / 1024 : down),
 350                        (down > 2048 ? "MBit" : "KBit"),
 351                        (up > 2048 ? up / 1024 : up),
 352                        (up > 2048 ? "MBit" : "KBit"));
 353 }
 354
 355 int gw_client_seq_print_text(struct seq_file *seq, void *offset)
 356 {
 357         struct net_device *net_dev = (struct net_device *)seq->private;
 358         struct bat_priv *bat_priv = netdev_priv(net_dev);
 359         struct gw_node *gw_node;
 360         struct hlist_node *node;
 361         int gw_count = 0;
 362
 363         if (!bat_priv->primary_if) {
 364
 365                 return seq_printf(seq, "BATMAN mesh %s disabled - please "
 366                                   "specify interfaces to enable it\n",
 367                                   net_dev->name);
 368         }
 369
 370         if (bat_priv->primary_if->if_status != IF_ACTIVE) {
 371
 372                 return seq_printf(seq, "BATMAN mesh %s disabled - "
 373                                        "primary interface not active\n",
 374                                        net_dev->name);
 375         }
 376
 377         seq_printf(seq, "      %-12s (%s/%i) %17s [%10s]: gw_class ... "
 378                    "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%pM (%s)]\n",
 379                    "Gateway", "#", TQ_MAX_VALUE, "Nexthop",
 380                    "outgoingIF", SOURCE_VERSION, REVISION_VERSION_STR,
 381                    bat_priv->primary_if->net_dev->name,
 382                    bat_priv->primary_if->net_dev->dev_addr, net_dev->name);
 383
 384         rcu_read_lock();
 385         hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw_list, list) {
 386                 if (gw_node->deleted)
 387                         continue;
 388
 389                 if (!gw_node->orig_node->router)
 390                         continue;
 391
 392                 _write_buffer_text(bat_priv, seq, gw_node);
 393                 gw_count++;
 394         }
 395         rcu_read_unlock();
 396
 397         if (gw_count == 0)
 398                 seq_printf(seq, "No gateways in range ...\n");
 399
 400         return 0;
 401 }
 402
 403 int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb)
 404 {
 405         struct ethhdr *ethhdr;
 406         struct iphdr *iphdr;
 407         struct ipv6hdr *ipv6hdr;
 408         struct udphdr *udphdr;
 409         unsigned int header_len = 0;
 410
 411         if (atomic_read(&bat_priv->gw_mode) == GW_MODE_OFF)
 412                 return 0;
 413
 414         /* check for ethernet header */
 415         if (!pskb_may_pull(skb, header_len + ETH_HLEN))
 416                 return 0;
 417         ethhdr = (struct ethhdr *)skb->data;
 418         header_len += ETH_HLEN;
 419
 420         /* check for initial vlan header */
 421         if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
 422                 if (!pskb_may_pull(skb, header_len + VLAN_HLEN))
 423                         return 0;
 424                 ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
 425                 header_len += VLAN_HLEN;
 426         }
 427
 428         /* check for ip header */
 429         switch (ntohs(ethhdr->h_proto)) {
 430         case ETH_P_IP:
 431                 if (!pskb_may_pull(skb, header_len + sizeof(struct iphdr)))
 432                         return 0;
 433                 iphdr = (struct iphdr *)(skb->data + header_len);
 434                 header_len += iphdr->ihl * 4;
 435
 436                 /* check for udp header */
 437                 if (iphdr->protocol != IPPROTO_UDP)
 438                         return 0;
 439
 440                 break;
 441         case ETH_P_IPV6:
 442                 if (!pskb_may_pull(skb, header_len + sizeof(struct ipv6hdr)))
 443                         return 0;
 444                 ipv6hdr = (struct ipv6hdr *)(skb->data + header_len);
 445                 header_len += sizeof(struct ipv6hdr);
 446
 447                 /* check for udp header */
 448                 if (ipv6hdr->nexthdr != IPPROTO_UDP)
 449                         return 0;
 450
 451                 break;
 452         default:
 453                 return 0;
 454         }
 455
 456         if (!pskb_may_pull(skb, header_len + sizeof(struct udphdr)))
 457                 return 0;
 458         udphdr = (struct udphdr *)(skb->data + header_len);
 459         header_len += sizeof(struct udphdr);
 460
 461         /* check for bootp port */
 462         if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&
 463              (ntohs(udphdr->dest) != 67))
 464                 return 0;
 465
 466         if ((ntohs(ethhdr->h_proto) == ETH_P_IPV6) &&
 467             (ntohs(udphdr->dest) != 547))
 468                 return 0;
 469
 470         if (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER)
 471                 return -1;
 472
 473         if (!bat_priv->curr_gw)
 474                 return 0;
 475
 476         return 1;
 477 }