![Sven Eckelmann](/assets/img/avatar_default.png)
Documentation/CodingStyle sets a strongly prefered limit of 80 characters per line in "Chapter 2: Breaking long lines and strings". Strings must be broken into smaller parts and long statements must be rewritten. Reported-by: Mikal Sande <mikal.sande@gmail.com> Reported-by: Mark Rankilor <reodge@gmail.com> Signed-off-by: Sven Eckelmann <sven.eckelmann@gmx.de> Signed-off-by: Marek Lindner <lindner_marek@yahoo.de> Signed-off-by: Andrew Lunn <andrew@lunn.ch> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
513 lines
12 KiB
C
513 lines
12 KiB
C
/*
|
|
* Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
|
|
*
|
|
* Marek Lindner, Simon Wunderlich
|
|
*
|
|
* 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 "main.h"
|
|
#include "translation-table.h"
|
|
#include "soft-interface.h"
|
|
#include "types.h"
|
|
#include "hash.h"
|
|
|
|
struct hashtable_t *hna_local_hash;
|
|
static struct hashtable_t *hna_global_hash;
|
|
atomic_t hna_local_changed;
|
|
|
|
DEFINE_SPINLOCK(hna_local_hash_lock);
|
|
static DEFINE_SPINLOCK(hna_global_hash_lock);
|
|
|
|
static DECLARE_DELAYED_WORK(hna_local_purge_wq, hna_local_purge);
|
|
|
|
static void hna_local_start_timer(void)
|
|
{
|
|
queue_delayed_work(bat_event_workqueue, &hna_local_purge_wq, 10 * HZ);
|
|
}
|
|
|
|
int hna_local_init(void)
|
|
{
|
|
if (hna_local_hash)
|
|
return 1;
|
|
|
|
hna_local_hash = hash_new(128, compare_orig, choose_orig);
|
|
|
|
if (!hna_local_hash)
|
|
return 0;
|
|
|
|
atomic_set(&hna_local_changed, 0);
|
|
hna_local_start_timer();
|
|
|
|
return 1;
|
|
}
|
|
|
|
void hna_local_add(uint8_t *addr)
|
|
{
|
|
struct hna_local_entry *hna_local_entry;
|
|
struct hna_global_entry *hna_global_entry;
|
|
struct hashtable_t *swaphash;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
hna_local_entry =
|
|
((struct hna_local_entry *)hash_find(hna_local_hash, addr));
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
|
|
if (hna_local_entry != NULL) {
|
|
hna_local_entry->last_seen = jiffies;
|
|
return;
|
|
}
|
|
|
|
/* only announce as many hosts as possible in the batman-packet and
|
|
space in batman_packet->num_hna That also should give a limit to
|
|
MAC-flooding. */
|
|
if ((num_hna + 1 > (ETH_DATA_LEN - BAT_PACKET_LEN) / ETH_ALEN) ||
|
|
(num_hna + 1 > 255)) {
|
|
bat_dbg(DBG_ROUTES,
|
|
"Can't add new local hna entry (%pM): "
|
|
"number of local hna entries exceeds packet size\n",
|
|
addr);
|
|
return;
|
|
}
|
|
|
|
bat_dbg(DBG_ROUTES, "Creating new local hna entry: %pM\n",
|
|
addr);
|
|
|
|
hna_local_entry = kmalloc(sizeof(struct hna_local_entry), GFP_ATOMIC);
|
|
if (!hna_local_entry)
|
|
return;
|
|
|
|
memcpy(hna_local_entry->addr, addr, ETH_ALEN);
|
|
hna_local_entry->last_seen = jiffies;
|
|
|
|
/* the batman interface mac address should never be purged */
|
|
if (compare_orig(addr, soft_device->dev_addr))
|
|
hna_local_entry->never_purge = 1;
|
|
else
|
|
hna_local_entry->never_purge = 0;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
hash_add(hna_local_hash, hna_local_entry);
|
|
num_hna++;
|
|
atomic_set(&hna_local_changed, 1);
|
|
|
|
if (hna_local_hash->elements * 4 > hna_local_hash->size) {
|
|
swaphash = hash_resize(hna_local_hash,
|
|
hna_local_hash->size * 2);
|
|
|
|
if (swaphash == NULL)
|
|
printk(KERN_ERR "batman-adv:"
|
|
"Couldn't resize local hna hash table\n");
|
|
else
|
|
hna_local_hash = swaphash;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
|
|
/* remove address from global hash if present */
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
|
|
hna_global_entry =
|
|
((struct hna_global_entry *)hash_find(hna_global_hash, addr));
|
|
|
|
if (hna_global_entry != NULL)
|
|
_hna_global_del_orig(hna_global_entry, "local hna received");
|
|
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
}
|
|
|
|
int hna_local_fill_buffer(unsigned char *buff, int buff_len)
|
|
{
|
|
struct hna_local_entry *hna_local_entry;
|
|
HASHIT(hashit);
|
|
int i = 0;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
while (hash_iterate(hna_local_hash, &hashit)) {
|
|
|
|
if (buff_len < (i + 1) * ETH_ALEN)
|
|
break;
|
|
|
|
hna_local_entry = hashit.bucket->data;
|
|
memcpy(buff + (i * ETH_ALEN), hna_local_entry->addr, ETH_ALEN);
|
|
|
|
i++;
|
|
}
|
|
|
|
/* if we did not get all new local hnas see you next time ;-) */
|
|
if (i == num_hna)
|
|
atomic_set(&hna_local_changed, 0);
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
|
|
return i;
|
|
}
|
|
|
|
int hna_local_fill_buffer_text(struct net_device *net_dev, char *buff,
|
|
size_t count, loff_t off)
|
|
{
|
|
struct bat_priv *bat_priv = netdev_priv(net_dev);
|
|
struct hna_local_entry *hna_local_entry;
|
|
HASHIT(hashit);
|
|
int bytes_written = 0;
|
|
unsigned long flags;
|
|
size_t hdr_len;
|
|
|
|
if (!bat_priv->primary_if) {
|
|
if (off == 0)
|
|
return sprintf(buff,
|
|
"BATMAN mesh %s disabled - "
|
|
"please specify interfaces to enable it\n",
|
|
net_dev->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
hdr_len = sprintf(buff,
|
|
"Locally retrieved addresses (from %s) "
|
|
"announced via HNA:\n",
|
|
net_dev->name);
|
|
|
|
if (off < hdr_len)
|
|
bytes_written = hdr_len;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
while (hash_iterate(hna_local_hash, &hashit)) {
|
|
hdr_len += 21;
|
|
|
|
if (count < bytes_written + 22)
|
|
break;
|
|
|
|
if (off >= hdr_len)
|
|
continue;
|
|
|
|
hna_local_entry = hashit.bucket->data;
|
|
|
|
bytes_written += snprintf(buff + bytes_written, 22,
|
|
" * " MAC_FMT "\n",
|
|
hna_local_entry->addr[0],
|
|
hna_local_entry->addr[1],
|
|
hna_local_entry->addr[2],
|
|
hna_local_entry->addr[3],
|
|
hna_local_entry->addr[4],
|
|
hna_local_entry->addr[5]);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
return bytes_written;
|
|
}
|
|
|
|
static void _hna_local_del(void *data)
|
|
{
|
|
kfree(data);
|
|
num_hna--;
|
|
atomic_set(&hna_local_changed, 1);
|
|
}
|
|
|
|
static void hna_local_del(struct hna_local_entry *hna_local_entry,
|
|
char *message)
|
|
{
|
|
bat_dbg(DBG_ROUTES, "Deleting local hna entry (%pM): %s\n",
|
|
hna_local_entry->addr, message);
|
|
|
|
hash_remove(hna_local_hash, hna_local_entry->addr);
|
|
_hna_local_del(hna_local_entry);
|
|
}
|
|
|
|
void hna_local_remove(uint8_t *addr, char *message)
|
|
{
|
|
struct hna_local_entry *hna_local_entry;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
hna_local_entry = (struct hna_local_entry *)
|
|
hash_find(hna_local_hash, addr);
|
|
if (hna_local_entry)
|
|
hna_local_del(hna_local_entry, message);
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
}
|
|
|
|
void hna_local_purge(struct work_struct *work)
|
|
{
|
|
struct hna_local_entry *hna_local_entry;
|
|
HASHIT(hashit);
|
|
unsigned long flags;
|
|
unsigned long timeout;
|
|
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
while (hash_iterate(hna_local_hash, &hashit)) {
|
|
hna_local_entry = hashit.bucket->data;
|
|
|
|
timeout = hna_local_entry->last_seen +
|
|
((LOCAL_HNA_TIMEOUT / 1000) * HZ);
|
|
if ((!hna_local_entry->never_purge) &&
|
|
time_after(jiffies, timeout))
|
|
hna_local_del(hna_local_entry, "address timed out");
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
hna_local_start_timer();
|
|
}
|
|
|
|
void hna_local_free(void)
|
|
{
|
|
if (!hna_local_hash)
|
|
return;
|
|
|
|
cancel_delayed_work_sync(&hna_local_purge_wq);
|
|
hash_delete(hna_local_hash, _hna_local_del);
|
|
hna_local_hash = NULL;
|
|
}
|
|
|
|
int hna_global_init(void)
|
|
{
|
|
if (hna_global_hash)
|
|
return 1;
|
|
|
|
hna_global_hash = hash_new(128, compare_orig, choose_orig);
|
|
|
|
if (!hna_global_hash)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void hna_global_add_orig(struct orig_node *orig_node,
|
|
unsigned char *hna_buff, int hna_buff_len)
|
|
{
|
|
struct hna_global_entry *hna_global_entry;
|
|
struct hna_local_entry *hna_local_entry;
|
|
struct hashtable_t *swaphash;
|
|
int hna_buff_count = 0;
|
|
unsigned long flags;
|
|
unsigned char *hna_ptr;
|
|
|
|
while ((hna_buff_count + 1) * ETH_ALEN <= hna_buff_len) {
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
|
|
hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN);
|
|
hna_global_entry = (struct hna_global_entry *)
|
|
hash_find(hna_global_hash, hna_ptr);
|
|
|
|
if (hna_global_entry == NULL) {
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
|
|
hna_global_entry =
|
|
kmalloc(sizeof(struct hna_global_entry),
|
|
GFP_ATOMIC);
|
|
|
|
if (!hna_global_entry)
|
|
break;
|
|
|
|
memcpy(hna_global_entry->addr, hna_ptr, ETH_ALEN);
|
|
|
|
bat_dbg(DBG_ROUTES,
|
|
"Creating new global hna entry: "
|
|
"%pM (via %pM)\n",
|
|
hna_global_entry->addr, orig_node->orig);
|
|
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
hash_add(hna_global_hash, hna_global_entry);
|
|
|
|
}
|
|
|
|
hna_global_entry->orig_node = orig_node;
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
|
|
/* remove address from local hash if present */
|
|
spin_lock_irqsave(&hna_local_hash_lock, flags);
|
|
|
|
hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN);
|
|
hna_local_entry = (struct hna_local_entry *)
|
|
hash_find(hna_local_hash, hna_ptr);
|
|
|
|
if (hna_local_entry != NULL)
|
|
hna_local_del(hna_local_entry, "global hna received");
|
|
|
|
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
|
|
|
|
hna_buff_count++;
|
|
}
|
|
|
|
/* initialize, and overwrite if malloc succeeds */
|
|
orig_node->hna_buff = NULL;
|
|
orig_node->hna_buff_len = 0;
|
|
|
|
if (hna_buff_len > 0) {
|
|
orig_node->hna_buff = kmalloc(hna_buff_len, GFP_ATOMIC);
|
|
if (orig_node->hna_buff) {
|
|
memcpy(orig_node->hna_buff, hna_buff, hna_buff_len);
|
|
orig_node->hna_buff_len = hna_buff_len;
|
|
}
|
|
}
|
|
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
|
|
if (hna_global_hash->elements * 4 > hna_global_hash->size) {
|
|
swaphash = hash_resize(hna_global_hash,
|
|
hna_global_hash->size * 2);
|
|
|
|
if (swaphash == NULL)
|
|
printk(KERN_ERR "batman-adv:"
|
|
"Couldn't resize global hna hash table\n");
|
|
else
|
|
hna_global_hash = swaphash;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
}
|
|
|
|
int hna_global_fill_buffer_text(struct net_device *net_dev, char *buff,
|
|
size_t count, loff_t off)
|
|
{
|
|
struct bat_priv *bat_priv = netdev_priv(net_dev);
|
|
struct hna_global_entry *hna_global_entry;
|
|
HASHIT(hashit);
|
|
int bytes_written = 0;
|
|
unsigned long flags;
|
|
size_t hdr_len;
|
|
|
|
if (!bat_priv->primary_if) {
|
|
if (off == 0)
|
|
return sprintf(buff,
|
|
"BATMAN mesh %s disabled - "
|
|
"please specify interfaces to enable it\n",
|
|
net_dev->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
hdr_len = sprintf(buff,
|
|
"Globally announced HNAs received via the mesh %s "
|
|
"(translation table):\n",
|
|
net_dev->name);
|
|
|
|
if (off < hdr_len)
|
|
bytes_written = hdr_len;
|
|
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
|
|
while (hash_iterate(hna_global_hash, &hashit)) {
|
|
hdr_len += 43;
|
|
|
|
if (count < bytes_written + 44)
|
|
break;
|
|
|
|
if (off >= hdr_len)
|
|
continue;
|
|
|
|
hna_global_entry = hashit.bucket->data;
|
|
|
|
bytes_written += snprintf(buff + bytes_written, 44,
|
|
" * " MAC_FMT " via " MAC_FMT "\n",
|
|
hna_global_entry->addr[0],
|
|
hna_global_entry->addr[1],
|
|
hna_global_entry->addr[2],
|
|
hna_global_entry->addr[3],
|
|
hna_global_entry->addr[4],
|
|
hna_global_entry->addr[5],
|
|
hna_global_entry->orig_node->orig[0],
|
|
hna_global_entry->orig_node->orig[1],
|
|
hna_global_entry->orig_node->orig[2],
|
|
hna_global_entry->orig_node->orig[3],
|
|
hna_global_entry->orig_node->orig[4],
|
|
hna_global_entry->orig_node->orig[5]);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
return bytes_written;
|
|
}
|
|
|
|
void _hna_global_del_orig(struct hna_global_entry *hna_global_entry,
|
|
char *message)
|
|
{
|
|
bat_dbg(DBG_ROUTES, "Deleting global hna entry %pM (via %pM): %s\n",
|
|
hna_global_entry->addr, hna_global_entry->orig_node->orig,
|
|
message);
|
|
|
|
hash_remove(hna_global_hash, hna_global_entry->addr);
|
|
kfree(hna_global_entry);
|
|
}
|
|
|
|
void hna_global_del_orig(struct orig_node *orig_node, char *message)
|
|
{
|
|
struct hna_global_entry *hna_global_entry;
|
|
int hna_buff_count = 0;
|
|
unsigned long flags;
|
|
unsigned char *hna_ptr;
|
|
|
|
if (orig_node->hna_buff_len == 0)
|
|
return;
|
|
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
|
|
while ((hna_buff_count + 1) * ETH_ALEN <= orig_node->hna_buff_len) {
|
|
hna_ptr = orig_node->hna_buff + (hna_buff_count * ETH_ALEN);
|
|
hna_global_entry = (struct hna_global_entry *)
|
|
hash_find(hna_global_hash, hna_ptr);
|
|
|
|
if ((hna_global_entry != NULL) &&
|
|
(hna_global_entry->orig_node == orig_node))
|
|
_hna_global_del_orig(hna_global_entry, message);
|
|
|
|
hna_buff_count++;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
|
|
orig_node->hna_buff_len = 0;
|
|
kfree(orig_node->hna_buff);
|
|
orig_node->hna_buff = NULL;
|
|
}
|
|
|
|
static void hna_global_del(void *data)
|
|
{
|
|
kfree(data);
|
|
}
|
|
|
|
void hna_global_free(void)
|
|
{
|
|
if (!hna_global_hash)
|
|
return;
|
|
|
|
hash_delete(hna_global_hash, hna_global_del);
|
|
hna_global_hash = NULL;
|
|
}
|
|
|
|
struct orig_node *transtable_search(uint8_t *addr)
|
|
{
|
|
struct hna_global_entry *hna_global_entry;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&hna_global_hash_lock, flags);
|
|
hna_global_entry = (struct hna_global_entry *)
|
|
hash_find(hna_global_hash, addr);
|
|
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
|
|
|
|
if (hna_global_entry == NULL)
|
|
return NULL;
|
|
|
|
return hna_global_entry->orig_node;
|
|
}
|