[git] batman-adv branch, linux, updated. GregKH-20091208-22731-ge361098
by postmasterï¼ open-mesh.net 06 Jun '10
by postmasterï¼ open-mesh.net 06 Jun '10
06 Jun '10
The following commit has been merged in the linux branch:
commit e36109825a5d38db310a87e8cee439add80fdc91
Merge: a1a9b2b0de53e60f5139488ff6c869c2e2c732d1 f720902bcc3b35d955e9831757f71dc3fee7b0fc
Author: Sven Eckelmann <sven.eckelmann(a)gmx.de>
Date: Sun Jun 6 20:28:45 2010 +0200
Merge branch 'maint' into linux
Conflicts:
drivers/staging/batman-adv/bat_printk.c
drivers/staging/batman-adv/compat.h
diff --combined drivers/staging/batman-adv/icmp_socket.c
index f1d790b,0000000..d4411cb
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/icmp_socket.c
+++ b/drivers/staging/batman-adv/icmp_socket.c
@@@ -1,328 -1,0 +1,328 @@@
+/*
+ * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
+ *
+ * Marek Lindner
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA
+ *
+ */
+
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include "main.h"
+#include "icmp_socket.h"
+#include "send.h"
+#include "types.h"
+#include "hash.h"
+#include "hard-interface.h"
+
+
+static struct socket_client *socket_client_hash[256];
+
+static void bat_socket_add_packet(struct socket_client *socket_client,
+ struct icmp_packet *icmp_packet);
+
+void bat_socket_init(void)
+{
+ memset(socket_client_hash, 0, sizeof(socket_client_hash));
+}
+
+static int bat_socket_open(struct inode *inode, struct file *file)
+{
+ unsigned int i;
+ struct socket_client *socket_client;
+
+ socket_client = kmalloc(sizeof(struct socket_client), GFP_KERNEL);
+
+ if (!socket_client)
+ return -ENOMEM;
+
+ for (i = 0; i < ARRAY_SIZE(socket_client_hash); i++) {
+ if (!socket_client_hash[i]) {
+ socket_client_hash[i] = socket_client;
+ break;
+ }
+ }
+
+ if (i == ARRAY_SIZE(socket_client_hash)) {
+ printk(KERN_ERR "batman-adv:"
+ "Error - can't add another packet client: "
+ "maximum number of clients reached\n");
+ kfree(socket_client);
+ return -EXFULL;
+ }
+
+ INIT_LIST_HEAD(&socket_client->queue_list);
+ socket_client->queue_len = 0;
+ socket_client->index = i;
+ spin_lock_init(&socket_client->lock);
+ init_waitqueue_head(&socket_client->queue_wait);
+
+ file->private_data = socket_client;
+
+ inc_module_count();
+ return 0;
+}
+
+static int bat_socket_release(struct inode *inode, struct file *file)
+{
+ struct socket_client *socket_client =
+ (struct socket_client *)file->private_data;
+ struct socket_packet *socket_packet;
+ struct list_head *list_pos, *list_pos_tmp;
+ unsigned long flags;
+
+ spin_lock_irqsave(&socket_client->lock, flags);
+
+ /* for all packets in the queue ... */
+ list_for_each_safe(list_pos, list_pos_tmp, &socket_client->queue_list) {
+ socket_packet = list_entry(list_pos,
+ struct socket_packet, list);
+
+ list_del(list_pos);
+ kfree(socket_packet);
+ }
+
+ socket_client_hash[socket_client->index] = NULL;
+ spin_unlock_irqrestore(&socket_client->lock, flags);
+
+ kfree(socket_client);
+ dec_module_count();
+
+ return 0;
+}
+
+static ssize_t bat_socket_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct socket_client *socket_client =
+ (struct socket_client *)file->private_data;
+ struct socket_packet *socket_packet;
+ int error;
+ unsigned long flags;
+
+ if ((file->f_flags & O_NONBLOCK) && (socket_client->queue_len == 0))
+ return -EAGAIN;
+
+ if ((!buf) || (count < sizeof(struct icmp_packet)))
+ return -EINVAL;
+
+ if (!access_ok(VERIFY_WRITE, buf, count))
+ return -EFAULT;
+
+ error = wait_event_interruptible(socket_client->queue_wait,
+ socket_client->queue_len);
+
+ if (error)
+ return error;
+
+ spin_lock_irqsave(&socket_client->lock, flags);
+
+ socket_packet = list_first_entry(&socket_client->queue_list,
+ struct socket_packet, list);
+ list_del(&socket_packet->list);
+ socket_client->queue_len--;
+
+ spin_unlock_irqrestore(&socket_client->lock, flags);
+
+ error = __copy_to_user(buf, &socket_packet->icmp_packet,
+ sizeof(struct icmp_packet));
+
+ kfree(socket_packet);
+
+ if (error)
- return error;
++ return -EFAULT;
+
+ return sizeof(struct icmp_packet);
+}
+
+static ssize_t bat_socket_write(struct file *file, const char __user *buff,
+ size_t len, loff_t *off)
+{
+ struct socket_client *socket_client =
+ (struct socket_client *)file->private_data;
+ struct icmp_packet icmp_packet;
+ struct orig_node *orig_node;
+ struct batman_if *batman_if;
+ uint8_t dstaddr[ETH_ALEN];
+ unsigned long flags;
+
+ if (len < sizeof(struct icmp_packet)) {
+ bat_dbg(DBG_BATMAN, "batman-adv:"
+ "Error - can't send packet from char device: "
+ "invalid packet size\n");
+ return -EINVAL;
+ }
+
+ if (!access_ok(VERIFY_READ, buff, sizeof(struct icmp_packet)))
+ return -EFAULT;
+
+ if (__copy_from_user(&icmp_packet, buff, sizeof(icmp_packet)))
+ return -EFAULT;
+
+ if (icmp_packet.packet_type != BAT_ICMP) {
+ bat_dbg(DBG_BATMAN, "batman-adv:"
+ "Error - can't send packet from char device: "
+ "got bogus packet type (expected: BAT_ICMP)\n");
+ return -EINVAL;
+ }
+
+ if (icmp_packet.msg_type != ECHO_REQUEST) {
+ bat_dbg(DBG_BATMAN, "batman-adv:"
+ "Error - can't send packet from char device: "
+ "got bogus message type (expected: ECHO_REQUEST)\n");
+ return -EINVAL;
+ }
+
+ icmp_packet.uid = socket_client->index;
+
+ if (icmp_packet.version != COMPAT_VERSION) {
+ icmp_packet.msg_type = PARAMETER_PROBLEM;
+ icmp_packet.ttl = COMPAT_VERSION;
+ bat_socket_add_packet(socket_client, &icmp_packet);
+ goto out;
+ }
+
+ if (atomic_read(&module_state) != MODULE_ACTIVE)
+ goto dst_unreach;
+
+ spin_lock_irqsave(&orig_hash_lock, flags);
+ orig_node = ((struct orig_node *)hash_find(orig_hash, icmp_packet.dst));
+
+ if (!orig_node)
+ goto unlock;
+
+ if (!orig_node->router)
+ goto unlock;
+
+ batman_if = orig_node->router->if_incoming;
+ memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
+
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+
+ if (!batman_if)
+ goto dst_unreach;
+
+ if (batman_if->if_status != IF_ACTIVE)
+ goto dst_unreach;
+
+ memcpy(icmp_packet.orig,
+ batman_if->net_dev->dev_addr,
+ ETH_ALEN);
+
+ send_raw_packet((unsigned char *)&icmp_packet,
+ sizeof(struct icmp_packet),
+ batman_if, dstaddr);
+
+ goto out;
+
+unlock:
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+dst_unreach:
+ icmp_packet.msg_type = DESTINATION_UNREACHABLE;
+ bat_socket_add_packet(socket_client, &icmp_packet);
+out:
+ return len;
+}
+
+static unsigned int bat_socket_poll(struct file *file, poll_table *wait)
+{
+ struct socket_client *socket_client =
+ (struct socket_client *)file->private_data;
+
+ poll_wait(file, &socket_client->queue_wait, wait);
+
+ if (socket_client->queue_len > 0)
+ return POLLIN | POLLRDNORM;
+
+ return 0;
+}
+
+static const struct file_operations fops = {
+ .owner = THIS_MODULE,
+ .open = bat_socket_open,
+ .release = bat_socket_release,
+ .read = bat_socket_read,
+ .write = bat_socket_write,
+ .poll = bat_socket_poll,
+};
+
+int bat_socket_setup(struct bat_priv *bat_priv)
+{
+ struct dentry *d;
+
+ if (!bat_priv->debug_dir)
+ goto err;
+
+ d = debugfs_create_file(ICMP_SOCKET, S_IFREG | S_IWUSR | S_IRUSR,
+ bat_priv->debug_dir, NULL, &fops);
+ if (d)
+ goto err;
+
+ return 0;
+
+err:
+ return 1;
+}
+
+static void bat_socket_add_packet(struct socket_client *socket_client,
+ struct icmp_packet *icmp_packet)
+{
+ struct socket_packet *socket_packet;
+ unsigned long flags;
+
+ socket_packet = kmalloc(sizeof(struct socket_packet), GFP_ATOMIC);
+
+ if (!socket_packet)
+ return;
+
+ INIT_LIST_HEAD(&socket_packet->list);
+ memcpy(&socket_packet->icmp_packet, icmp_packet,
+ sizeof(struct icmp_packet));
+
+ spin_lock_irqsave(&socket_client->lock, flags);
+
+ /* while waiting for the lock the socket_client could have been
+ * deleted */
+ if (!socket_client_hash[icmp_packet->uid]) {
+ spin_unlock_irqrestore(&socket_client->lock, flags);
+ kfree(socket_packet);
+ return;
+ }
+
+ list_add_tail(&socket_packet->list, &socket_client->queue_list);
+ socket_client->queue_len++;
+
+ if (socket_client->queue_len > 100) {
+ socket_packet = list_first_entry(&socket_client->queue_list,
+ struct socket_packet, list);
+
+ list_del(&socket_packet->list);
+ kfree(socket_packet);
+ socket_client->queue_len--;
+ }
+
+ spin_unlock_irqrestore(&socket_client->lock, flags);
+
+ wake_up(&socket_client->queue_wait);
+}
+
+void bat_socket_receive_packet(struct icmp_packet *icmp_packet)
+{
+ struct socket_client *hash = socket_client_hash[icmp_packet->uid];
+
+ if (hash)
+ bat_socket_add_packet(hash, icmp_packet);
+}
diff --combined drivers/staging/batman-adv/main.c
index 1d52018,0000000..72fccb1
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/main.c
+++ b/drivers/staging/batman-adv/main.c
@@@ -1,303 -1,0 +1,299 @@@
+/*
+ * 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 "bat_sysfs.h"
+#include "bat_debugfs.h"
+#include "routing.h"
+#include "send.h"
+#include "originator.h"
+#include "soft-interface.h"
+#include "icmp_socket.h"
+#include "translation-table.h"
+#include "hard-interface.h"
+#include "types.h"
+#include "vis.h"
+#include "hash.h"
+
+struct list_head if_list;
+struct hlist_head forw_bat_list;
+struct hlist_head forw_bcast_list;
+struct hashtable_t *orig_hash;
+
+DEFINE_SPINLOCK(orig_hash_lock);
+DEFINE_SPINLOCK(forw_bat_list_lock);
+DEFINE_SPINLOCK(forw_bcast_list_lock);
+
- atomic_t vis_interval;
+atomic_t bcast_queue_left;
+atomic_t batman_queue_left;
+
+int16_t num_hna;
+
+struct net_device *soft_device;
+
+unsigned char broadcastAddr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+atomic_t module_state;
+
+static struct packet_type batman_adv_packet_type __read_mostly = {
+ .type = __constant_htons(ETH_P_BATMAN),
+ .func = batman_skb_recv,
+};
+
+struct workqueue_struct *bat_event_workqueue;
+
+#ifdef CONFIG_BATMAN_ADV_DEBUG
+int debug;
+
+module_param(debug, int, 0644);
+
+int bat_debug_type(int type)
+{
+ return debug & type;
+}
+#endif
+
+int init_module(void)
+{
+ int retval;
+
+ INIT_LIST_HEAD(&if_list);
+ INIT_HLIST_HEAD(&forw_bat_list);
+ INIT_HLIST_HEAD(&forw_bcast_list);
+
+ atomic_set(&module_state, MODULE_INACTIVE);
+
- atomic_set(&vis_interval, 1000);/* TODO: raise this later, this is only
- * for debugging now. */
+ atomic_set(&bcast_queue_left, BCAST_QUEUE_LEN);
+ atomic_set(&batman_queue_left, BATMAN_QUEUE_LEN);
+
+ /* the name should not be longer than 10 chars - see
+ * http://lwn.net/Articles/23634/ */
+ bat_event_workqueue = create_singlethread_workqueue("bat_events");
+
+ if (!bat_event_workqueue)
+ return -ENOMEM;
+
+ bat_socket_init();
+ debugfs_init();
+
+ /* initialize layer 2 interface */
+ soft_device = alloc_netdev(sizeof(struct bat_priv) , "bat%d",
+ interface_setup);
+
+ if (!soft_device) {
+ printk(KERN_ERR "batman-adv:"
+ "Unable to allocate the batman interface\n");
+ goto end;
+ }
+
+ retval = register_netdev(soft_device);
+
+ if (retval < 0) {
+ printk(KERN_ERR "batman-adv:"
+ "Unable to register the batman interface: %i\n", retval);
+ goto free_soft_device;
+ }
+
+ retval = sysfs_add_meshif(soft_device);
+
+ if (retval < 0)
+ goto unreg_soft_device;
+
+ retval = debugfs_add_meshif(soft_device);
+
+ if (retval < 0)
+ goto unreg_sysfs;
+
+ register_netdevice_notifier(&hard_if_notifier);
+ dev_add_pack(&batman_adv_packet_type);
+
+ printk(KERN_INFO "batman-adv:"
+ "B.A.T.M.A.N. advanced %s%s (compatibility version %i) loaded\n",
+ SOURCE_VERSION, REVISION_VERSION_STR, COMPAT_VERSION);
+
+ return 0;
+
+unreg_sysfs:
+ sysfs_del_meshif(soft_device);
+unreg_soft_device:
+ unregister_netdev(soft_device);
+ soft_device = NULL;
+ return -ENOMEM;
+
+free_soft_device:
+ free_netdev(soft_device);
+ soft_device = NULL;
+end:
+ return -ENOMEM;
+}
+
+void cleanup_module(void)
+{
+ deactivate_module();
+
+ unregister_netdevice_notifier(&hard_if_notifier);
+ hardif_remove_interfaces();
+
+ if (soft_device) {
+ debugfs_del_meshif(soft_device);
+ sysfs_del_meshif(soft_device);
+ unregister_netdev(soft_device);
+ soft_device = NULL;
+ }
+
+ dev_remove_pack(&batman_adv_packet_type);
+
+ destroy_workqueue(bat_event_workqueue);
+ bat_event_workqueue = NULL;
+}
+
+/* activates the module, starts timer ... */
+void activate_module(void)
+{
+ if (originator_init() < 1)
+ goto err;
+
+ if (hna_local_init() < 1)
+ goto err;
+
+ if (hna_global_init() < 1)
+ goto err;
+
+ hna_local_add(soft_device->dev_addr);
+
+ if (vis_init() < 1)
+ goto err;
+
+ update_min_mtu();
+ atomic_set(&module_state, MODULE_ACTIVE);
+ goto end;
+
+err:
+ printk(KERN_ERR "batman-adv:"
+ "Unable to allocate memory for mesh information structures: "
+ "out of mem ?\n");
+ deactivate_module();
+end:
+ return;
+}
+
+/* shuts down the whole module.*/
+void deactivate_module(void)
+{
+ atomic_set(&module_state, MODULE_DEACTIVATING);
+
+ purge_outstanding_packets(NULL);
+ flush_workqueue(bat_event_workqueue);
+
+ vis_quit();
+
+ /* TODO: unregister BATMAN pack */
+
+ originator_free();
+
+ hna_local_free();
+ hna_global_free();
+
+ synchronize_net();
+ debugfs_destroy();
+
+ synchronize_rcu();
+ atomic_set(&module_state, MODULE_INACTIVE);
+}
+
+void inc_module_count(void)
+{
+ try_module_get(THIS_MODULE);
+}
+
+void dec_module_count(void)
+{
+ module_put(THIS_MODULE);
+}
+
+int addr_to_string(char *buff, uint8_t *addr)
+{
- return sprintf(buff, MAC_FMT,
- addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
++ return sprintf(buff, "%pM", addr);
+}
+
+/* returns 1 if they are the same originator */
+
+int compare_orig(void *data1, void *data2)
+{
+ return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
+}
+
+/* hashfunction to choose an entry in a hash table of given size */
+/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
+int choose_orig(void *data, int32_t size)
+{
+ unsigned char *key = data;
+ uint32_t hash = 0;
+ size_t i;
+
+ for (i = 0; i < 6; i++) {
+ hash += key[i];
+ hash += (hash << 10);
+ hash ^= (hash >> 6);
+ }
+
+ hash += (hash << 3);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
+
+ return hash % size;
+}
+
+int is_my_mac(uint8_t *addr)
+{
+ struct batman_if *batman_if;
+ rcu_read_lock();
+ list_for_each_entry_rcu(batman_if, &if_list, list) {
+ if ((batman_if->net_dev) &&
+ (compare_orig(batman_if->net_dev->dev_addr, addr))) {
+ rcu_read_unlock();
+ return 1;
+ }
+ }
+ rcu_read_unlock();
+ return 0;
+
+}
+
+int is_bcast(uint8_t *addr)
+{
+ return (addr[0] == (uint8_t)0xff) && (addr[1] == (uint8_t)0xff);
+}
+
+int is_mcast(uint8_t *addr)
+{
+ return *addr & 0x01;
+}
+
+MODULE_LICENSE("GPL");
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_SUPPORTED_DEVICE(DRIVER_DEVICE);
+#ifdef REVISION_VERSION
+MODULE_VERSION(SOURCE_VERSION "-" REVISION_VERSION);
+#else
+MODULE_VERSION(SOURCE_VERSION);
+#endif
diff --combined drivers/staging/batman-adv/main.h
index 232fc25,7cb0b18..7cb0b18
--- a/drivers/staging/batman-adv/main.h
+++ b/drivers/staging/batman-adv/main.h
@@@ -57,6 -57,8 +57,8 @@@
#define LOG_BUF_LEN 8192 /* has to be a power of 2 */
#define ETH_STR_LEN 20
+ #define VIS_INTERVAL 5000 /* 5 seconds */
+
#define MAX_AGGREGATION_BYTES 512 /* should not be bigger than 512 bytes or
* change the size of
* forw_packet->direct_link_flags */
@@@ -135,7 -137,6 +137,6 @@@ extern spinlock_t orig_hash_lock
extern spinlock_t forw_bat_list_lock;
extern spinlock_t forw_bcast_list_lock;
- extern atomic_t vis_interval;
extern atomic_t bcast_queue_left;
extern atomic_t batman_queue_left;
extern int16_t num_hna;
diff --combined drivers/staging/batman-adv/translation-table.c
index 604122c,0000000..d9233b0
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/translation-table.c
+++ b/drivers/staging/batman-adv/translation-table.c
@@@ -1,513 -1,0 +1,496 @@@
+/*
+ * 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_seq_print_text(struct seq_file *seq, void *offset)
+{
+ struct net_device *net_dev = (struct net_device *)seq->private;
+ struct bat_priv *bat_priv = netdev_priv(net_dev);
+ struct hna_local_entry *hna_local_entry;
+ HASHIT(hashit);
+ HASHIT(hashit_count);
+ unsigned long flags;
+ size_t buf_size, pos;
+ char *buff;
+
+ if (!bat_priv->primary_if) {
+ return seq_printf(seq, "BATMAN mesh %s disabled - "
+ "please specify interfaces to enable it\n",
+ net_dev->name);
+ }
+
+ seq_printf(seq, "Locally retrieved addresses (from %s) "
+ "announced via HNA:\n",
+ net_dev->name);
+
+ spin_lock_irqsave(&hna_local_hash_lock, flags);
+
+ buf_size = 1;
+ /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
+ while (hash_iterate(hna_local_hash, &hashit_count))
+ buf_size += 21;
+
+ buff = kmalloc(buf_size, GFP_ATOMIC);
+ if (!buff) {
+ spin_unlock_irqrestore(&hna_local_hash_lock, flags);
+ return -ENOMEM;
+ }
+ buff[0] = '\0';
+ pos = 0;
+
+ while (hash_iterate(hna_local_hash, &hashit)) {
+ hna_local_entry = hashit.bucket->data;
+
- pos += snprintf(buff + pos, 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]);
++ pos += snprintf(buff + pos, 22, " * %pM\n",
++ hna_local_entry->addr);
+ }
+
+ spin_unlock_irqrestore(&hna_local_hash_lock, flags);
+
+ seq_printf(seq, "%s", buff);
+ kfree(buff);
+ return 0;
+}
+
+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_seq_print_text(struct seq_file *seq, void *offset)
+{
+ struct net_device *net_dev = (struct net_device *)seq->private;
+ struct bat_priv *bat_priv = netdev_priv(net_dev);
+ struct hna_global_entry *hna_global_entry;
+ HASHIT(hashit);
+ HASHIT(hashit_count);
+ unsigned long flags;
+ size_t buf_size, pos;
+ char *buff;
+
+ if (!bat_priv->primary_if) {
+ return seq_printf(seq, "BATMAN mesh %s disabled - "
+ "please specify interfaces to enable it\n",
+ net_dev->name);
+ }
+
- seq_printf(seq, "Globally announced HNAs received via the mesh %s "
- "(translation table):\n",
++ seq_printf(seq, "Globally announced HNAs received via the mesh %s\n",
+ net_dev->name);
+
+ spin_lock_irqsave(&hna_global_hash_lock, flags);
+
+ buf_size = 1;
+ /* Estimate length for: " * xx:xx:xx:xx:xx:xx via xx:xx:xx:xx:xx:xx\n"*/
+ while (hash_iterate(hna_global_hash, &hashit_count))
+ buf_size += 43;
+
+ buff = kmalloc(buf_size, GFP_ATOMIC);
+ if (!buff) {
+ spin_unlock_irqrestore(&hna_global_hash_lock, flags);
+ return -ENOMEM;
+ }
+ buff[0] = '\0';
+ pos = 0;
+
+ while (hash_iterate(hna_global_hash, &hashit)) {
+ hna_global_entry = hashit.bucket->data;
+
+ pos += snprintf(buff + pos, 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]);
++ " * %pM via %pM\n", hna_global_entry->addr,
++ hna_global_entry->orig_node->orig);
+ }
+
+ spin_unlock_irqrestore(&hna_global_hash_lock, flags);
+
+ seq_printf(seq, "%s", buff);
+ kfree(buff);
+ return 0;
+}
+
+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;
+}
diff --combined drivers/staging/batman-adv/vis.c
index 2b109db,0000000..c73774b
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/vis.c
+++ b/drivers/staging/batman-adv/vis.c
@@@ -1,817 -1,0 +1,817 @@@
+/*
+ * Copyright (C) 2008-2010 B.A.T.M.A.N. contributors:
+ *
+ * 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 "send.h"
+#include "translation-table.h"
+#include "vis.h"
+#include "soft-interface.h"
+#include "hard-interface.h"
+#include "hash.h"
+
+/* Returns the smallest signed integer in two's complement with the sizeof x */
+#define smallest_signed_int(x) (1u << (7u + 8u * (sizeof(x) - 1u)))
+
+/* Checks if a sequence number x is a predecessor/successor of y.
+ they handle overflows/underflows and can correctly check for a
+ predecessor/successor unless the variable sequence number has grown by
+ more then 2**(bitwidth(x)-1)-1.
+ This means that for a uint8_t with the maximum value 255, it would think:
+ * when adding nothing - it is neither a predecessor nor a successor
+ * before adding more than 127 to the starting value - it is a predecessor,
+ * when adding 128 - it is neither a predecessor nor a successor,
+ * after adding more than 127 to the starting value - it is a successor */
+#define seq_before(x, y) ({typeof(x) _dummy = (x - y); \
+ _dummy > smallest_signed_int(_dummy); })
+#define seq_after(x, y) seq_before(y, x)
+
+struct hashtable_t *vis_hash;
+DEFINE_SPINLOCK(vis_hash_lock);
+static DEFINE_SPINLOCK(recv_list_lock);
+static struct vis_info *my_vis_info;
+static struct list_head send_list; /* always locked with vis_hash_lock */
+
+static void start_vis_timer(void);
+
+/* free the info */
+static void free_info(struct kref *ref)
+{
+ struct vis_info *info = container_of(ref, struct vis_info, refcount);
+ struct recvlist_node *entry, *tmp;
+ unsigned long flags;
+
+ list_del_init(&info->send_list);
+ spin_lock_irqsave(&recv_list_lock, flags);
+ list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
+ list_del(&entry->list);
+ kfree(entry);
+ }
+ spin_unlock_irqrestore(&recv_list_lock, flags);
+ kfree(info);
+}
+
+/* Compare two vis packets, used by the hashing algorithm */
+static int vis_info_cmp(void *data1, void *data2)
+{
+ struct vis_info *d1, *d2;
+ d1 = data1;
+ d2 = data2;
+ return compare_orig(d1->packet.vis_orig, d2->packet.vis_orig);
+}
+
+/* hash function to choose an entry in a hash table of given size */
+/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
+static int vis_info_choose(void *data, int size)
+{
+ struct vis_info *vis_info = data;
+ unsigned char *key;
+ uint32_t hash = 0;
+ size_t i;
+
+ key = vis_info->packet.vis_orig;
+ for (i = 0; i < ETH_ALEN; i++) {
+ hash += key[i];
+ hash += (hash << 10);
+ hash ^= (hash >> 6);
+ }
+
+ hash += (hash << 3);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
+
+ return hash % size;
+}
+
+/* insert interface to the list of interfaces of one originator, if it
+ * does not already exist in the list */
+static void vis_data_insert_interface(const uint8_t *interface,
+ struct hlist_head *if_list,
+ bool primary)
+{
+ struct if_list_entry *entry;
+ struct hlist_node *pos;
+
+ hlist_for_each_entry(entry, pos, if_list, list) {
+ if (compare_orig(entry->addr, (void *)interface))
+ return;
+ }
+
+ /* its a new address, add it to the list */
+ entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
+ if (!entry)
+ return;
+ memcpy(entry->addr, interface, ETH_ALEN);
+ entry->primary = primary;
+ hlist_add_head(&entry->list, if_list);
+}
+
+static ssize_t vis_data_read_prim_sec(char *buff, struct hlist_head *if_list)
+{
+ struct if_list_entry *entry;
+ struct hlist_node *pos;
+ char tmp_addr_str[ETH_STR_LEN];
+ size_t len = 0;
+
+ hlist_for_each_entry(entry, pos, if_list, list) {
+ if (entry->primary)
+ len += sprintf(buff + len, "PRIMARY, ");
+ else {
+ addr_to_string(tmp_addr_str, entry->addr);
+ len += sprintf(buff + len, "SEC %s, ", tmp_addr_str);
+ }
+ }
+
+ return len;
+}
+
+static size_t vis_data_count_prim_sec(struct hlist_head *if_list)
+{
+ struct if_list_entry *entry;
+ struct hlist_node *pos;
+ size_t count = 0;
+
+ hlist_for_each_entry(entry, pos, if_list, list) {
+ if (entry->primary)
+ count += 9;
+ else
+ count += 23;
+ }
+
+ return count;
+}
+
+/* read an entry */
+static ssize_t vis_data_read_entry(char *buff, struct vis_info_entry *entry,
+ uint8_t *src, bool primary)
+{
+ char to[18];
+
+ /* maximal length: max(4+17+2, 3+17+1+3+2) == 26 */
+ addr_to_string(to, entry->dest);
+ if (primary && entry->quality == 0)
+ return sprintf(buff, "HNA %s, ", to);
+ else if (compare_orig(entry->src, src))
+ return sprintf(buff, "TQ %s %d, ", to, entry->quality);
+
+ return 0;
+}
+
+int vis_seq_print_text(struct seq_file *seq, void *offset)
+{
+ HASHIT(hashit);
+ HASHIT(hashit_count);
+ struct vis_info *info;
+ struct vis_info_entry *entries;
+ struct net_device *net_dev = (struct net_device *)seq->private;
+ struct bat_priv *bat_priv = netdev_priv(net_dev);
+ HLIST_HEAD(vis_if_list);
+ struct if_list_entry *entry;
+ struct hlist_node *pos, *n;
+ int i;
+ char tmp_addr_str[ETH_STR_LEN];
+ unsigned long flags;
+ int vis_server = atomic_read(&bat_priv->vis_mode);
+ size_t buff_pos, buf_size;
+ char *buff;
+
+ if ((!bat_priv->primary_if) ||
+ (vis_server == VIS_TYPE_CLIENT_UPDATE))
+ return 0;
+
+ buf_size = 1;
+ /* Estimate length */
+ spin_lock_irqsave(&vis_hash_lock, flags);
+ while (hash_iterate(vis_hash, &hashit_count)) {
+ info = hashit_count.bucket->data;
+ entries = (struct vis_info_entry *)
+ ((char *)info + sizeof(struct vis_info));
+
+ for (i = 0; i < info->packet.entries; i++) {
+ if (entries[i].quality == 0)
+ continue;
+ vis_data_insert_interface(entries[i].src, &vis_if_list,
+ compare_orig(entries[i].src,
+ info->packet.vis_orig));
+ }
+
+ hlist_for_each_entry(entry, pos, &vis_if_list, list) {
+ buf_size += 18 + 26 * info->packet.entries;
+
+ /* add primary/secondary records */
+ if (compare_orig(entry->addr, info->packet.vis_orig))
+ buf_size +=
+ vis_data_count_prim_sec(&vis_if_list);
+
+ buf_size += 1;
+ }
+
+ hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
+ hlist_del(&entry->list);
+ kfree(entry);
+ }
+ }
+
+ buff = kmalloc(buf_size, GFP_ATOMIC);
+ if (!buff) {
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+ return -ENOMEM;
+ }
+ buff[0] = '\0';
+ buff_pos = 0;
+
+ while (hash_iterate(vis_hash, &hashit)) {
+ info = hashit.bucket->data;
+ entries = (struct vis_info_entry *)
+ ((char *)info + sizeof(struct vis_info));
+
+ for (i = 0; i < info->packet.entries; i++) {
+ if (entries[i].quality == 0)
+ continue;
+ vis_data_insert_interface(entries[i].src, &vis_if_list,
+ compare_orig(entries[i].src,
+ info->packet.vis_orig));
+ }
+
+ hlist_for_each_entry(entry, pos, &vis_if_list, list) {
+ addr_to_string(tmp_addr_str, entry->addr);
+ buff_pos += sprintf(buff + buff_pos, "%s,",
+ tmp_addr_str);
+
+ for (i = 0; i < info->packet.entries; i++)
+ buff_pos += vis_data_read_entry(buff + buff_pos,
+ &entries[i],
+ entry->addr,
+ entry->primary);
+
+ /* add primary/secondary records */
+ if (compare_orig(entry->addr, info->packet.vis_orig))
+ buff_pos +=
+ vis_data_read_prim_sec(buff + buff_pos,
+ &vis_if_list);
+
+ buff_pos += sprintf(buff + buff_pos, "\n");
+ }
+
+ hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
+ hlist_del(&entry->list);
+ kfree(entry);
+ }
+ }
+
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+
+ seq_printf(seq, "%s", buff);
+ kfree(buff);
+
+ return 0;
+}
+
+/* add the info packet to the send list, if it was not
+ * already linked in. */
+static void send_list_add(struct vis_info *info)
+{
+ if (list_empty(&info->send_list)) {
+ kref_get(&info->refcount);
+ list_add_tail(&info->send_list, &send_list);
+ }
+}
+
+/* delete the info packet from the send list, if it was
+ * linked in. */
+static void send_list_del(struct vis_info *info)
+{
+ if (!list_empty(&info->send_list)) {
+ list_del_init(&info->send_list);
+ kref_put(&info->refcount, free_info);
+ }
+}
+
+/* tries to add one entry to the receive list. */
+static void recv_list_add(struct list_head *recv_list, char *mac)
+{
+ struct recvlist_node *entry;
+ unsigned long flags;
+
+ entry = kmalloc(sizeof(struct recvlist_node), GFP_ATOMIC);
+ if (!entry)
+ return;
+
+ memcpy(entry->mac, mac, ETH_ALEN);
+ spin_lock_irqsave(&recv_list_lock, flags);
+ list_add_tail(&entry->list, recv_list);
+ spin_unlock_irqrestore(&recv_list_lock, flags);
+}
+
+/* returns 1 if this mac is in the recv_list */
+static int recv_list_is_in(struct list_head *recv_list, char *mac)
+{
+ struct recvlist_node *entry;
+ unsigned long flags;
+
+ spin_lock_irqsave(&recv_list_lock, flags);
+ list_for_each_entry(entry, recv_list, list) {
+ if (memcmp(entry->mac, mac, ETH_ALEN) == 0) {
+ spin_unlock_irqrestore(&recv_list_lock, flags);
+ return 1;
+ }
+ }
+ spin_unlock_irqrestore(&recv_list_lock, flags);
+ return 0;
+}
+
+/* try to add the packet to the vis_hash. return NULL if invalid (e.g. too old,
+ * broken.. ). vis hash must be locked outside. is_new is set when the packet
+ * is newer than old entries in the hash. */
+static struct vis_info *add_packet(struct vis_packet *vis_packet,
+ int vis_info_len, int *is_new,
+ int make_broadcast)
+{
+ struct vis_info *info, *old_info;
+ struct vis_info search_elem;
+
+ *is_new = 0;
+ /* sanity check */
+ if (vis_hash == NULL)
+ return NULL;
+
+ /* see if the packet is already in vis_hash */
+ memcpy(search_elem.packet.vis_orig, vis_packet->vis_orig, ETH_ALEN);
+ old_info = hash_find(vis_hash, &search_elem);
+
+ if (old_info != NULL) {
+ if (!seq_after(vis_packet->seqno, old_info->packet.seqno)) {
+ if (old_info->packet.seqno == vis_packet->seqno) {
+ recv_list_add(&old_info->recv_list,
+ vis_packet->sender_orig);
+ return old_info;
+ } else {
+ /* newer packet is already in hash. */
+ return NULL;
+ }
+ }
+ /* remove old entry */
+ hash_remove(vis_hash, old_info);
+ send_list_del(old_info);
+ kref_put(&old_info->refcount, free_info);
+ }
+
+ info = kmalloc(sizeof(struct vis_info) + vis_info_len, GFP_ATOMIC);
+ if (info == NULL)
+ return NULL;
+
+ kref_init(&info->refcount);
+ INIT_LIST_HEAD(&info->send_list);
+ INIT_LIST_HEAD(&info->recv_list);
+ info->first_seen = jiffies;
+ memcpy(&info->packet, vis_packet,
+ sizeof(struct vis_packet) + vis_info_len);
+
+ /* initialize and add new packet. */
+ *is_new = 1;
+
+ /* Make it a broadcast packet, if required */
+ if (make_broadcast)
+ memcpy(info->packet.target_orig, broadcastAddr, ETH_ALEN);
+
+ /* repair if entries is longer than packet. */
+ if (info->packet.entries * sizeof(struct vis_info_entry) > vis_info_len)
+ info->packet.entries = vis_info_len /
+ sizeof(struct vis_info_entry);
+
+ recv_list_add(&info->recv_list, info->packet.sender_orig);
+
+ /* try to add it */
+ if (hash_add(vis_hash, info) < 0) {
+ /* did not work (for some reason) */
+ kref_put(&old_info->refcount, free_info);
+ info = NULL;
+ }
+
+ return info;
+}
+
+/* handle the server sync packet, forward if needed. */
+void receive_server_sync_packet(struct bat_priv *bat_priv,
+ struct vis_packet *vis_packet,
+ int vis_info_len)
+{
+ struct vis_info *info;
+ int is_new, make_broadcast;
+ unsigned long flags;
+ int vis_server = atomic_read(&bat_priv->vis_mode);
+
+ make_broadcast = (vis_server == VIS_TYPE_SERVER_SYNC);
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+ info = add_packet(vis_packet, vis_info_len, &is_new, make_broadcast);
+ if (info == NULL)
+ goto end;
+
+ /* only if we are server ourselves and packet is newer than the one in
+ * hash.*/
+ if (vis_server == VIS_TYPE_SERVER_SYNC && is_new)
+ send_list_add(info);
+end:
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+}
+
+/* handle an incoming client update packet and schedule forward if needed. */
+void receive_client_update_packet(struct bat_priv *bat_priv,
+ struct vis_packet *vis_packet,
+ int vis_info_len)
+{
+ struct vis_info *info;
+ int is_new;
+ unsigned long flags;
+ int vis_server = atomic_read(&bat_priv->vis_mode);
+ int are_target = 0;
+
+ /* clients shall not broadcast. */
+ if (is_bcast(vis_packet->target_orig))
+ return;
+
+ /* Are we the target for this VIS packet? */
+ if (vis_server == VIS_TYPE_SERVER_SYNC &&
+ is_my_mac(vis_packet->target_orig))
+ are_target = 1;
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+ info = add_packet(vis_packet, vis_info_len, &is_new, are_target);
+ if (info == NULL)
+ goto end;
+ /* note that outdated packets will be dropped at this point. */
+
+
+ /* send only if we're the target server or ... */
+ if (are_target && is_new) {
+ info->packet.vis_type = VIS_TYPE_SERVER_SYNC; /* upgrade! */
+ send_list_add(info);
+
+ /* ... we're not the recipient (and thus need to forward). */
+ } else if (!is_my_mac(info->packet.target_orig)) {
+ send_list_add(info);
+ }
+end:
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+}
+
+/* Walk the originators and find the VIS server with the best tq. Set the packet
+ * address to its address and return the best_tq.
+ *
+ * Must be called with the originator hash locked */
+static int find_best_vis_server(struct vis_info *info)
+{
+ HASHIT(hashit);
+ struct orig_node *orig_node;
+ int best_tq = -1;
+
+ while (hash_iterate(orig_hash, &hashit)) {
+ orig_node = hashit.bucket->data;
+ if ((orig_node != NULL) &&
+ (orig_node->router != NULL) &&
+ (orig_node->flags & VIS_SERVER) &&
+ (orig_node->router->tq_avg > best_tq)) {
+ best_tq = orig_node->router->tq_avg;
+ memcpy(info->packet.target_orig, orig_node->orig,
+ ETH_ALEN);
+ }
+ }
+ return best_tq;
+}
+
+/* Return true if the vis packet is full. */
+static bool vis_packet_full(struct vis_info *info)
+{
+ if (info->packet.entries + 1 >
+ (1000 - sizeof(struct vis_info)) / sizeof(struct vis_info_entry))
+ return true;
+ return false;
+}
+
+/* generates a packet of own vis data,
+ * returns 0 on success, -1 if no packet could be generated */
+static int generate_vis_packet(struct bat_priv *bat_priv)
+{
+ HASHIT(hashit_local);
+ HASHIT(hashit_global);
+ struct orig_node *orig_node;
+ struct vis_info *info = (struct vis_info *)my_vis_info;
+ struct vis_info_entry *entry, *entry_array;
+ struct hna_local_entry *hna_local_entry;
+ int best_tq = -1;
+ unsigned long flags;
+
+ info->first_seen = jiffies;
+ info->packet.vis_type = atomic_read(&bat_priv->vis_mode);
+
+ spin_lock_irqsave(&orig_hash_lock, flags);
+ memcpy(info->packet.target_orig, broadcastAddr, ETH_ALEN);
+ info->packet.ttl = TTL;
+ info->packet.seqno++;
+ info->packet.entries = 0;
+
+ if (info->packet.vis_type == VIS_TYPE_CLIENT_UPDATE) {
+ best_tq = find_best_vis_server(info);
+ if (best_tq < 0) {
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+ return -1;
+ }
+ }
+
+ entry_array = (struct vis_info_entry *)
+ ((char *)info + sizeof(struct vis_info));
+
+ while (hash_iterate(orig_hash, &hashit_global)) {
+ orig_node = hashit_global.bucket->data;
+ if (orig_node->router != NULL
+ && compare_orig(orig_node->router->addr,
+ orig_node->orig)
+ && (orig_node->router->if_incoming->if_status ==
+ IF_ACTIVE)
+ && orig_node->router->tq_avg > 0) {
+
+ /* fill one entry into buffer. */
+ entry = &entry_array[info->packet.entries];
+ memcpy(entry->src,
+ orig_node->router->if_incoming->net_dev->dev_addr,
+ ETH_ALEN);
+ memcpy(entry->dest, orig_node->orig, ETH_ALEN);
+ entry->quality = orig_node->router->tq_avg;
+ info->packet.entries++;
+
+ if (vis_packet_full(info)) {
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+ return 0;
+ }
+ }
+ }
+
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+
+ spin_lock_irqsave(&hna_local_hash_lock, flags);
+ while (hash_iterate(hna_local_hash, &hashit_local)) {
+ hna_local_entry = hashit_local.bucket->data;
+ entry = &entry_array[info->packet.entries];
+ memset(entry->src, 0, ETH_ALEN);
+ memcpy(entry->dest, hna_local_entry->addr, ETH_ALEN);
+ entry->quality = 0; /* 0 means HNA */
+ info->packet.entries++;
+
+ if (vis_packet_full(info)) {
+ spin_unlock_irqrestore(&hna_local_hash_lock, flags);
+ return 0;
+ }
+ }
+ spin_unlock_irqrestore(&hna_local_hash_lock, flags);
+ return 0;
+}
+
+/* free old vis packets. Must be called with this vis_hash_lock
+ * held */
+static void purge_vis_packets(void)
+{
+ HASHIT(hashit);
+ struct vis_info *info;
+
+ while (hash_iterate(vis_hash, &hashit)) {
+ info = hashit.bucket->data;
+ if (info == my_vis_info) /* never purge own data. */
+ continue;
+ if (time_after(jiffies,
+ info->first_seen + (VIS_TIMEOUT*HZ)/1000)) {
+ hash_remove_bucket(vis_hash, &hashit);
+ send_list_del(info);
+ kref_put(&info->refcount, free_info);
+ }
+ }
+}
+
+static void broadcast_vis_packet(struct vis_info *info, int packet_length)
+{
+ HASHIT(hashit);
+ struct orig_node *orig_node;
+ unsigned long flags;
+ struct batman_if *batman_if;
+ uint8_t dstaddr[ETH_ALEN];
+
+ spin_lock_irqsave(&orig_hash_lock, flags);
+
+ /* send to all routers in range. */
+ while (hash_iterate(orig_hash, &hashit)) {
+ orig_node = hashit.bucket->data;
+
+ /* if it's a vis server and reachable, send it. */
+ if ((!orig_node) || (!orig_node->router))
+ continue;
+ if (!(orig_node->flags & VIS_SERVER))
+ continue;
+ /* don't send it if we already received the packet from
+ * this node. */
+ if (recv_list_is_in(&info->recv_list, orig_node->orig))
+ continue;
+
+ memcpy(info->packet.target_orig, orig_node->orig, ETH_ALEN);
+ batman_if = orig_node->router->if_incoming;
+ memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+
+ send_raw_packet((unsigned char *)&info->packet,
+ packet_length, batman_if, dstaddr);
+
+ spin_lock_irqsave(&orig_hash_lock, flags);
+
+ }
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+ memcpy(info->packet.target_orig, broadcastAddr, ETH_ALEN);
+}
+
+static void unicast_vis_packet(struct vis_info *info, int packet_length)
+{
+ struct orig_node *orig_node;
+ unsigned long flags;
+ struct batman_if *batman_if;
+ uint8_t dstaddr[ETH_ALEN];
+
+ spin_lock_irqsave(&orig_hash_lock, flags);
+ orig_node = ((struct orig_node *)
+ hash_find(orig_hash, info->packet.target_orig));
+
+ if ((!orig_node) || (!orig_node->router))
+ goto out;
+
+ /* don't lock while sending the packets ... we therefore
+ * copy the required data before sending */
+ batman_if = orig_node->router->if_incoming;
+ memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+
+ send_raw_packet((unsigned char *)&info->packet,
+ packet_length, batman_if, dstaddr);
+ return;
+
+out:
+ spin_unlock_irqrestore(&orig_hash_lock, flags);
+}
+
+/* only send one vis packet. called from send_vis_packets() */
+static void send_vis_packet(struct vis_info *info)
+{
+ int packet_length;
+
+ if (info->packet.ttl < 2) {
+ printk(KERN_WARNING "batman-adv: Error - can't send vis packet: ttl exceeded\n");
+ return;
+ }
+
+ memcpy(info->packet.sender_orig, mainIfAddr, ETH_ALEN);
+ info->packet.ttl--;
+
+ packet_length = sizeof(struct vis_packet) +
+ info->packet.entries * sizeof(struct vis_info_entry);
+
+ if (is_bcast(info->packet.target_orig))
+ broadcast_vis_packet(info, packet_length);
+ else
+ unicast_vis_packet(info, packet_length);
+ info->packet.ttl++; /* restore TTL */
+}
+
+/* called from timer; send (and maybe generate) vis packet. */
+static void send_vis_packets(struct work_struct *work)
+{
+ struct vis_info *info, *temp;
+ unsigned long flags;
+ /* FIXME: each batman_if will be attached to a softif */
+ struct bat_priv *bat_priv = netdev_priv(soft_device);
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+
+ purge_vis_packets();
+
+ if (generate_vis_packet(bat_priv) == 0) {
+ /* schedule if generation was successful */
+ send_list_add(my_vis_info);
+ }
+
+ list_for_each_entry_safe(info, temp, &send_list, send_list) {
+
+ kref_get(&info->refcount);
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+
+ send_vis_packet(info);
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+ send_list_del(info);
+ kref_put(&info->refcount, free_info);
+ }
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+ start_vis_timer();
+}
+static DECLARE_DELAYED_WORK(vis_timer_wq, send_vis_packets);
+
+/* init the vis server. this may only be called when if_list is already
+ * initialized (e.g. bat0 is initialized, interfaces have been added) */
+int vis_init(void)
+{
+ unsigned long flags;
+ if (vis_hash)
+ return 1;
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+
+ vis_hash = hash_new(256, vis_info_cmp, vis_info_choose);
+ if (!vis_hash) {
+ printk(KERN_ERR "batman-adv:Can't initialize vis_hash\n");
+ goto err;
+ }
+
+ my_vis_info = kmalloc(1000, GFP_ATOMIC);
+ if (!my_vis_info) {
+ printk(KERN_ERR "batman-adv:Can't initialize vis packet\n");
+ goto err;
+ }
+
+ /* prefill the vis info */
- my_vis_info->first_seen = jiffies - atomic_read(&vis_interval);
++ my_vis_info->first_seen = jiffies - msecs_to_jiffies(VIS_INTERVAL);
+ INIT_LIST_HEAD(&my_vis_info->recv_list);
+ INIT_LIST_HEAD(&my_vis_info->send_list);
+ kref_init(&my_vis_info->refcount);
+ my_vis_info->packet.version = COMPAT_VERSION;
+ my_vis_info->packet.packet_type = BAT_VIS;
+ my_vis_info->packet.ttl = TTL;
+ my_vis_info->packet.seqno = 0;
+ my_vis_info->packet.entries = 0;
+
+ INIT_LIST_HEAD(&send_list);
+
+ memcpy(my_vis_info->packet.vis_orig, mainIfAddr, ETH_ALEN);
+ memcpy(my_vis_info->packet.sender_orig, mainIfAddr, ETH_ALEN);
+
+ if (hash_add(vis_hash, my_vis_info) < 0) {
+ printk(KERN_ERR
+ "batman-adv:Can't add own vis packet into hash\n");
+ /* not in hash, need to remove it manually. */
+ kref_put(&my_vis_info->refcount, free_info);
+ goto err;
+ }
+
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+ start_vis_timer();
+ return 1;
+
+err:
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+ vis_quit();
+ return 0;
+}
+
+/* Decrease the reference count on a hash item info */
+static void free_info_ref(void *data)
+{
+ struct vis_info *info = data;
+
+ send_list_del(info);
+ kref_put(&info->refcount, free_info);
+}
+
+/* shutdown vis-server */
+void vis_quit(void)
+{
+ unsigned long flags;
+ if (!vis_hash)
+ return;
+
+ cancel_delayed_work_sync(&vis_timer_wq);
+
+ spin_lock_irqsave(&vis_hash_lock, flags);
+ /* properly remove, kill timers ... */
+ hash_delete(vis_hash, free_info_ref);
+ vis_hash = NULL;
+ my_vis_info = NULL;
+ spin_unlock_irqrestore(&vis_hash_lock, flags);
+}
+
+/* schedule packets for (re)transmission */
+static void start_vis_timer(void)
+{
+ queue_delayed_work(bat_event_workqueue, &vis_timer_wq,
- (atomic_read(&vis_interval) * HZ) / 1000);
++ (VIS_INTERVAL * HZ) / 1000);
+}
--
batman-adv
1
0
Author: simon
Date: 2010-06-05 19:58:38 +0200 (Sat, 05 Jun 2010)
New Revision: 1691
Modified:
trunk/batman/batman.c
Log:
batman: Correct gw_speed down bit mask
We want to get bits .OOOO... and not as the mask would suggest .OOOOO..
when we decode the encoded bits for the download part of the gateway
speed.
Reported-By: Bill Meier <wmeier(a)newsguy.com>
Signed-off-by: Sven Eckelmann <sven.eckelmann(a)gmx.de>
Modified: trunk/batman/batman.c
===================================================================
--- trunk/batman/batman.c 2010-06-05 17:57:18 UTC (rev 1690)
+++ trunk/batman/batman.c 2010-06-05 17:58:38 UTC (rev 1691)
@@ -482,7 +482,7 @@
void get_gw_speeds(unsigned char gw_class, int *down, int *up)
{
char sbit = (gw_class & 0x80) >> 7;
- char dpart = (gw_class & 0x7C) >> 3;
+ char dpart = (gw_class & 0x78) >> 3;
char upart = (gw_class & 0x07);
*down = 32 * (sbit + 2) * (1 << dpart);
1
0
Author: simon
Date: 2010-06-05 19:57:18 +0200 (Sat, 05 Jun 2010)
New Revision: 1690
Modified:
trunk/batman-adv-kernelland/gateway_common.c
Log:
batman-adv: Correct gw_speed down bit mask
We want to get bits .OOOO... and not as the mask would suggest .OOOOO..
when we decode the encoded bits for the download part of the gateway
speed.
Reported-By: Bill Meier <wmeier(a)newsguy.com>
Signed-off-by: Sven Eckelmann <sven.eckelmann(a)gmx.de>
Modified: trunk/batman-adv-kernelland/gateway_common.c
===================================================================
--- trunk/batman-adv-kernelland/gateway_common.c 2010-06-05 17:47:28 UTC (rev 1689)
+++ trunk/batman-adv-kernelland/gateway_common.c 2010-06-05 17:57:18 UTC (rev 1690)
@@ -63,7 +63,7 @@
void gw_srv_class_to_kbit(uint8_t gw_srv_class, int *down, int *up)
{
char sbit = (gw_srv_class & 0x80) >> 7;
- char dpart = (gw_srv_class & 0x7C) >> 3;
+ char dpart = (gw_srv_class & 0x78) >> 3;
char upart = (gw_srv_class & 0x07);
if (!gw_srv_class) {
1
0
Author: simon
Date: 2010-06-05 19:47:28 +0200 (Sat, 05 Jun 2010)
New Revision: 1689
Modified:
trunk/batman-adv-kernelland/icmp_socket.c
Log:
batman-adv: return -EFAULT on copy_to_user errors
copy_to_user() returns the number of bites remaining but we want to
return a negative error code here.
Signed-off-by: Dan Carpenter <error27(a)gmail.com>
[sven.eckelmann(a)gmx.de: Move change from device.c to icmp_socket.c]
Signed-off-by: Sven Eckelmann <sven.eckelmann(a)gmx.de>
Modified: trunk/batman-adv-kernelland/icmp_socket.c
===================================================================
--- trunk/batman-adv-kernelland/icmp_socket.c 2010-06-05 17:42:40 UTC (rev 1688)
+++ trunk/batman-adv-kernelland/icmp_socket.c 2010-06-05 17:47:28 UTC (rev 1689)
@@ -148,7 +148,7 @@
kfree(socket_packet);
if (error)
- return error;
+ return -EFAULT;
return packet_len;
}
1
0
Author: simon
Date: 2010-06-05 19:42:40 +0200 (Sat, 05 Jun 2010)
New Revision: 1688
Modified:
trunk/batman-adv-kernelland/bat_printk.c
trunk/batman-adv-kernelland/compat.h
trunk/batman-adv-kernelland/main.c
trunk/batman-adv-kernelland/translation-table.c
Log:
batman-adv: Convert MAC_FMT to %pM
Remove the last uses of MAC_FMT
Signed-off-by: Joe Perches <joe(a)perches.com>
[sven.eckelmann(a)gmx.de: Adapted for current batman-adv version]
Signed-off-by: Sven Eckelmann <sven.eckelmann(a)gmx.de>
Modified: trunk/batman-adv-kernelland/bat_printk.c
===================================================================
--- trunk/batman-adv-kernelland/bat_printk.c 2010-06-04 19:44:14 UTC (rev 1687)
+++ trunk/batman-adv-kernelland/bat_printk.c 2010-06-05 17:42:40 UTC (rev 1688)
@@ -859,3 +859,53 @@
return printk("%s", buf);
}
+
+/**
+ * sprintf - Format a string and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @fmt: The format string to use
+ * @...: Arguments for the format string
+ *
+ * The function returns the number of characters written
+ * into @buf. Use snprintf() or scnprintf() in order to avoid
+ * buffer overflows.
+ *
+ * See the vsnprintf() documentation for format string extensions over C99.
+ */
+int bat_sprintf(char *buf, const char *fmt, ...)
+{
+ va_list args;
+ int i;
+
+ va_start(args, fmt);
+ i = bat_vsnprintf(buf, INT_MAX, fmt, args);
+ va_end(args);
+
+ return i;
+}
+
+/**
+ * snprintf - Format a string and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @size: The size of the buffer, including the trailing null space
+ * @fmt: The format string to use
+ * @...: Arguments for the format string
+ *
+ * The return value is the number of characters which would be
+ * generated for the given input, excluding the trailing null,
+ * as per ISO C99. If the return is greater than or equal to
+ * @size, the resulting string is truncated.
+ *
+ * See the vsnprintf() documentation for format string extensions over C99.
+ */
+int bat_snprintf(char *buf, size_t size, const char *fmt, ...)
+{
+ va_list args;
+ int i;
+
+ va_start(args, fmt);
+ i = bat_vsnprintf(buf, size, fmt, args);
+ va_end(args);
+
+ return i;
+}
Modified: trunk/batman-adv-kernelland/compat.h
===================================================================
--- trunk/batman-adv-kernelland/compat.h 2010-06-04 19:44:14 UTC (rev 1687)
+++ trunk/batman-adv-kernelland/compat.h 2010-06-05 17:42:40 UTC (rev 1688)
@@ -74,12 +74,6 @@
#endif /* < KERNEL_VERSION(2, 6, 23) */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
-
-#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
-
-#endif /* < KERNEL_VERSION(2, 6, 24) */
-
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
#define strict_strtoul(cp, base, res) \
@@ -235,6 +229,12 @@
asmlinkage int bat_printk(const char *fmt, ...);
#define printk bat_printk
+int bat_sprintf(char *buf, const char *fmt, ...);
+#define sprintf bat_sprintf
+
+int bat_snprintf(char *buf, size_t size, const char *fmt, ...);
+#define snprintf bat_snprintf
+
static inline struct net_device_stats *dev_get_stats(struct net_device *dev)
{
if (dev->get_stats)
Modified: trunk/batman-adv-kernelland/main.c
===================================================================
--- trunk/batman-adv-kernelland/main.c 2010-06-04 19:44:14 UTC (rev 1687)
+++ trunk/batman-adv-kernelland/main.c 2010-06-05 17:42:40 UTC (rev 1688)
@@ -227,8 +227,7 @@
int addr_to_string(char *buff, uint8_t *addr)
{
- return sprintf(buff, MAC_FMT,
- addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+ return sprintf(buff, "%pM", addr);
}
/* returns 1 if they are the same originator */
Modified: trunk/batman-adv-kernelland/translation-table.c
===================================================================
--- trunk/batman-adv-kernelland/translation-table.c 2010-06-04 19:44:14 UTC (rev 1687)
+++ trunk/batman-adv-kernelland/translation-table.c 2010-06-05 17:42:40 UTC (rev 1688)
@@ -200,13 +200,8 @@
while (hash_iterate(hna_local_hash, &hashit)) {
hna_local_entry = hashit.bucket->data;
- pos += snprintf(buff + pos, 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]);
+ pos += snprintf(buff + pos, 22, " * %pM\n",
+ hna_local_entry->addr);
}
spin_unlock_irqrestore(&hna_local_hash_lock, flags);
@@ -418,19 +413,8 @@
hna_global_entry = hashit.bucket->data;
pos += snprintf(buff + pos, 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]);
+ " * %pM via %pM\n", hna_global_entry->addr,
+ hna_global_entry->orig_node->orig);
}
spin_unlock_irqrestore(&hna_global_hash_lock, flags);
1
0
Author: axel
Date: 2010-06-04 21:44:14 +0200 (Fri, 04 Jun 2010)
New Revision: 1687
Modified:
trunk/bmx/bmx.c
trunk/bmx/bmx.h
trunk/bmx/msg.c
trunk/bmx/route.c
Log:
bmx.c.h route.c msg.c : hunting for bugs... temporary eliminate merge_neigh_nodes() and purge involved data-structrues instead
Modified: trunk/bmx/bmx.c
===================================================================
--- trunk/bmx/bmx.c 2010-06-04 13:50:59 UTC (rev 1686)
+++ trunk/bmx/bmx.c 2010-06-04 19:44:14 UTC (rev 1687)
@@ -193,7 +193,8 @@
}
-uint32_t update_metric(struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe)
+uint32_t update_metric(struct link_node *ln, struct orig_node *on,
+ struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe)
{
dbgf_all( DBGT_INFO,
@@ -243,6 +244,13 @@
// mr->clr out of any range:
if ( mr->clr ) {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "ln %s on %s sqn_min %d updated %u ",
+ ln ? ln->llip4_str : "---",
+ on ? on->id.name : "---",
+ on ? on->ogm_sqn_min : 0,
+ on ? on->updated_timestamp : 0);
+
dbgf(DBGL_SYS, DBGT_ERR,
"sqn_in %d sqn_max %d probe %u "
"metric_algo: mask 0x%X steps %d window %d lounge %d metric_record: clr %d, set %d val %u",
@@ -371,6 +379,8 @@
* purging ln->neigh->dhn and dhn->neigh
*/
//BMX3 (done)
+/*
+
STATIC_FUNC
struct neigh_node *merge_neigh_nodes(struct link_node *ln, struct dhash_node * dhn)
{
@@ -411,6 +421,7 @@
return neigh;
}
+*/
//BMX3 (done)
@@ -462,12 +473,26 @@
//always if new dhash: assertion(-500450, 0); //this never happen! or ?
neigh = ln->neigh;
+ assertion(-500518, (neigh->dhn != my_orig_node.dhn));
} else {
- neigh = merge_neigh_nodes( ln, dhn);
+ //neigh = merge_neigh_nodes( ln, dhn); //they are the same!
+ dbgf(DBGL_SYS, DBGT_ERR, "Neigh restarted ?!! purging ln %s %jX and dhn %s %jX",
+ ln->neigh->dhn->on->desc0->id.name,
+ ln->neigh->dhn->on->desc0->id.rand.u64[0],
+ dhn->on->desc0->id.name, dhn->on->desc0->id.rand.u64[0]);
+
+ invalidate_dhash_node( dhn );
+ invalidate_dhash_node( ln->neigh->dhn );
+
+ return FAILURE;
+
+
+ assertion(-500519, (neigh->dhn != my_orig_node.dhn));
+
}
} else {
@@ -481,16 +506,20 @@
neigh = ln->neigh = dhn->neigh;
avl_insert(&neigh->link_tree, ln, -300173);
+ assertion(-500516, (neigh->dhn != my_orig_node.dhn));
+
+
} else {
neigh = create_neigh_node( ln, dhn );
-
+ assertion(-500517, (neigh->dhn != my_orig_node.dhn));
}
-
}
assign_best_rtq_link(neigh);
+ assertion(-500510, (neigh->dhn != my_orig_node.dhn));
+
return update_neighIID4x_repository(neigh, neighIID4neigh, neigh->dhn);
}
@@ -576,7 +605,7 @@
// update_lounged_metric(0, lounge_size, sqn, sqn_max, &lndev->sqr[sqr], local_lws);
- update_metric(&lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, 0);
+ update_metric(ln, NULL, &lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, 0);
}
@@ -585,9 +614,9 @@
if (this_lndev) {
// update_lounged_metric(probe, lounge_size, sqn, sqn_max, &this_lndev->sqr[sqr], local_lws);
-
- update_metric(&this_lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, probe);
+ update_metric(ln, NULL, &this_lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, probe);
+
if (probe && sqr == SQR_RTQ) {
this_lndev->rtq_time_max = bmx_time;
@@ -852,8 +881,8 @@
memcpy(&key, &rn->key, sizeof (struct link_key));
if (purge_all || !avl_find(&link_dev_tree, &rn->key)) {
+ avl_remove(&on->router_tree, &rn->key, -300226);
debugFree(rn, -300225);
- avl_remove(&on->router_tree, &rn->key, -300226);
}
}
}
@@ -898,7 +927,7 @@
} else {
- metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, ogm_sqn_max_rcvd, 0);
+ metric_temp = update_metric(pb->ln, on, &rn->mr, &on->path_metric_algo, 0, ogm_sqn_max_rcvd, 0);
if (metric_best < metric_temp) {
@@ -928,10 +957,13 @@
rn_in = debugMalloc(sizeof (struct router_node), -300222);
memset( rn_in, 0, sizeof(struct router_node));
memcpy( &rn_in->key, &pb->lndev->key, sizeof(struct link_key));
+
+ rn_in->mr.clr = on->ogm_sqn_max_rcvd & mask;
+
avl_insert(&on->router_tree, rn_in, -300223);
}
- metric_in = update_metric(&rn_in->mr, &on->path_metric_algo, orig_sqn, ogm_sqn_max_rcvd, pb->lndev->mr[SQR_RTQ].val);
+ metric_in = update_metric(pb->ln, on, &rn_in->mr, &on->path_metric_algo, orig_sqn, ogm_sqn_max_rcvd, pb->lndev->mr[SQR_RTQ].val);
if (metric_in > metric_best && GREAT_SQN(rn_in->mr.set & mask, on->ogm_sqn_to_be_send & mask)) {
@@ -952,12 +984,11 @@
ipStr(rn_in ? rn_in->key.llip4 : 0), rn_in ? rn_in->key.dev->name : "---", metric_in,
ipStr(on->router_key.llip4), lndev_old ? on->router_key.dev->name : "---");
- assertion(-500504, (!on->router_key.llip4 || lndev_old));
+ //assertion(-500504, (!on->router_key.llip4 || lndev_old)); lndev_old not needed anymore beyond this point
if (on->router_key.llip4) {
configure_route(on->primary_ip4, 32, 0, on->router_key.llip4, 0,
- on->router_key.dev->index, on->router_key.dev->name,
- RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
+ 0, NULL, RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
}
configure_route(on->primary_ip4, 32, 0, rn_in->key.llip4, my_orig_node.primary_ip4,
@@ -987,8 +1018,7 @@
if (on->router_key.llip4) {
configure_route(on->primary_ip4, 32, 0, on->router_key.llip4, 0,
- on->router_key.dev->index, on->router_key.dev->name,
- RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
+ 0, NULL, RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
}
Modified: trunk/bmx/bmx.h
===================================================================
--- trunk/bmx/bmx.h 2010-06-04 13:50:59 UTC (rev 1686)
+++ trunk/bmx/bmx.h 2010-06-04 19:44:14 UTC (rev 1687)
@@ -836,7 +836,7 @@
/*
* PARANOIA ERROR CODES:
* Negative numbers are used as SIGSEV error codes !
- * Currently used numbers are: -500000 ... -500501
+ * Currently used numbers are: -500000 ... -500520
*/
#ifdef NO_PARANOIA
@@ -878,7 +878,8 @@
IDM_T validate_metric_algo(struct metric_algo *ma, struct ctrl_node *cn);
-uint32_t update_metric(struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe);
+uint32_t update_metric(struct link_node *ln, struct orig_node *on,
+ struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe);
void update_link_node(struct link_node *ln, struct dev_node *iif, SQN_T sqn, SQN_T sqn_max, uint8_t sqr, uint32_t probe);
Modified: trunk/bmx/msg.c
===================================================================
--- trunk/bmx/msg.c 2010-06-04 13:50:59 UTC (rev 1686)
+++ trunk/bmx/msg.c 2010-06-04 19:44:14 UTC (rev 1687)
@@ -1104,7 +1104,7 @@
// update_lounged_metric(0, local_rtq_lounge, ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, &lndev->sqr[SQR_RTQ], local_lws);
- update_metric(&lndev->mr[SQR_RTQ], &link_metric_algo[SQR_RTQ], ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, 0);
+ update_metric(NULL, NULL, &lndev->mr[SQR_RTQ], &link_metric_algo[SQR_RTQ], ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, 0);
}
dbgf_all( DBGT_INFO, "%s %s SQN %d", ttn->dev->name, ttn->dev->ip4_str, ttn->dev->ogm_sqn);
@@ -1395,6 +1395,8 @@
IDM_T invalid = NO;
struct description *cache = NULL;
+ assertion(-500511, (!ln || !ln->neigh || (ln->neigh->dhn != my_orig_node.dhn)));
+
if (avl_find(&dhash_invalid_tree, dhash)) {
invalid = YES;
@@ -1434,17 +1436,27 @@
}
}
- if (is_sender)
- update_neigh_node(ln, orig_dhn, neighIID4x);
+ if (is_sender) {
- else if (update_neighIID4x_repository(ln->neigh, neighIID4x, orig_dhn) == FAILURE)
+ if (update_neigh_node(ln, orig_dhn, neighIID4x) == FAILURE )
+ return FAILURE_POINTER;
+
+ assertion(-500512, (!ln->neigh || (ln->neigh->dhn != my_orig_node.dhn)));
+
+ } else if (update_neighIID4x_repository(ln->neigh, neighIID4x, orig_dhn) == FAILURE) {
+
return FAILURE_POINTER;
+ }
} else {
if (is_sender) {
- update_neigh_node(ln, orig_dhn, neighIID4x);
+ if (update_neigh_node(ln, orig_dhn, neighIID4x) == FAILURE)
+ return FAILURE_POINTER;
+
+ assertion(-500513, (!ln->neigh || (ln->neigh->dhn != my_orig_node.dhn)));
+
} else {
//update_neigh_node(ln, dhn, IID_RSVD_UNUSED);
//update_neigh_iid_repos(ln->neigh, neighIID4x, dhn);
@@ -1461,7 +1473,11 @@
if ((orig_dhn = process_description(pb, cache, dhash))) {
- update_neigh_node(ln, orig_dhn, neighIID4x);
+ if (update_neigh_node(ln, orig_dhn, neighIID4x) == FAILURE)
+ return FAILURE_POINTER;
+
+ assertion(-500514, (!ln->neigh || (ln->neigh->dhn != my_orig_node.dhn)));
+
}
} else if (ln->neigh && (cache = rem_cached_description(dhash))) {
@@ -1562,7 +1578,8 @@
dhn = process_dhash_description_neighIID4x(pb, &dhash0, desc0, neighIID4x, is_sender);
dbgf_all( DBGT_INFO, "rcvd %s desc0: %jX via %s NB %s",
- dhn ? "accepted" : "denied", desc0->id.rand.u64[0], pb->iif->name, pb->neigh_str);
+ (dhn && dhn != FAILURE_POINTER) ? "accepted" : "denied",
+ desc0->id.rand.u64[0], pb->iif->name, pb->neigh_str);
if (dhn == FAILURE_POINTER) {
Modified: trunk/bmx/route.c
===================================================================
--- trunk/bmx/route.c 2010-06-04 13:50:59 UTC (rev 1686)
+++ trunk/bmx/route.c 2010-06-04 19:44:14 UTC (rev 1687)
@@ -1298,7 +1298,7 @@
}
-static int8_t track_route_and_proceed( uint32_t dest, int16_t mask, uint32_t metric, uint32_t gw, uint32_t src, int32_t ifi, char *dev,
+static int8_t track_route_and_proceed( uint32_t dest, int16_t mask, uint32_t metric, uint32_t gw, uint32_t src, char *dev,
int16_t rt_table, int16_t rta_type, int8_t del, int8_t track_t )
{
@@ -1418,7 +1418,7 @@
- if ( track_route_and_proceed(dest, mask, metric, gw, src, ifi, dev, rt_table, rta_type, del, track_t) == NO )
+ if ( track_route_and_proceed(dest, mask, metric, gw, src, dev, rt_table, rta_type, del, track_t) == NO )
return;
if ( track_t != TRACK_OTHER_HOST )
1
0
Author: simon
Date: 2010-06-04 15:50:59 +0200 (Fri, 04 Jun 2010)
New Revision: 1686
Modified:
trunk/batman-adv-kernelland/hard-interface.c
trunk/batman-adv-kernelland/routing.c
trunk/batman-adv-kernelland/routing.h
trunk/batman-adv-kernelland/soft-interface.c
Log:
batman-adv: bonding and interface alternating
This patch adds interface alternating to the new bonding feature. By
default, we now try to avoid forwarding packets on the receiving
interface, instead choosing alternative interfaces. This feature
works only on nodes which have multiple interfaces connected to the
mesh. This approach should reduce problems of the half-duplex nature
of WiFi Hardware and thus increase performance.
The patch also includes a bug fix for the interference detection.
Neighbors which are not (yet) candidates should not be considered for
the interference.
Signed-off-by: Simon Wunderlich <siwu(a)hrz.tu-chemnitz.de>
Acked-by: Marek Lindner <lindner_marek(a)yahoo.de>
---
Note that unlike the first bonding/alternating patch, the interface
alternating is now activated by default. We have concluded at the
WBMv3 that this is generally a good idea.
We also did tests on dual radio meshnodes, and the link appeared
much more stable (steady 25 Mbit/s, instead of switching between
15 and 25 Mbit/s).
Modified: trunk/batman-adv-kernelland/hard-interface.c
===================================================================
--- trunk/batman-adv-kernelland/hard-interface.c 2010-06-04 13:34:00 UTC (rev 1685)
+++ trunk/batman-adv-kernelland/hard-interface.c 2010-06-04 13:50:59 UTC (rev 1686)
@@ -514,7 +514,7 @@
/* unicast packet */
case BAT_UNICAST:
- ret = recv_unicast_packet(skb);
+ ret = recv_unicast_packet(skb, batman_if);
break;
/* broadcast packet */
Modified: trunk/batman-adv-kernelland/routing.c
===================================================================
--- trunk/batman-adv-kernelland/routing.c 2010-06-04 13:34:00 UTC (rev 1685)
+++ trunk/batman-adv-kernelland/routing.c 2010-06-04 13:50:59 UTC (rev 1686)
@@ -416,12 +416,6 @@
struct batman_packet *batman_packet)
{
- /* don't care if bonding is not enabled */
- if (!atomic_read(&bat_priv->bonding_enabled)) {
- orig_node->bond.candidates = 0;
- return;
- }
-
if (batman_packet->flags & PRIMARIES_FIRST_HOP)
memcpy(orig_neigh_node->primary_addr,
orig_node->orig, ETH_ALEN);
@@ -429,7 +423,7 @@
return;
}
-/* mark possible bonding candidates in the neighbor list */
+/* mark possible bond.candidates in the neighbor list */
void update_bonding_candidates(struct bat_priv *bat_priv,
struct orig_node *orig_node)
{
@@ -439,12 +433,6 @@
struct neigh_node *tmp_neigh_node, *tmp_neigh_node2;
struct neigh_node *first_candidate, *last_candidate;
- /* don't care if bonding is not enabled */
- if (!atomic_read(&bat_priv->bonding_enabled)) {
- orig_node->bond.candidates = 0;
- return;
- }
-
/* update the candidates for this originator */
if (!orig_node->router) {
orig_node->bond.candidates = 0;
@@ -453,7 +441,7 @@
best_tq = orig_node->router->tq_avg;
- /* update bonding candidates */
+ /* update bond.candidates */
candidates = 0;
@@ -490,6 +478,12 @@
if (tmp_neigh_node2 == tmp_neigh_node)
continue;
+ /* we only care if the other candidate is even
+ * considered as candidate. */
+ if (tmp_neigh_node2->next_bond_candidate == NULL)
+ continue;
+
+
if ((tmp_neigh_node->if_incoming ==
tmp_neigh_node2->if_incoming)
|| (memcmp(tmp_neigh_node->addr,
@@ -1007,14 +1001,16 @@
/* find a suitable router for this originator, and use
* bonding if possible. */
-struct neigh_node *find_router(struct orig_node *orig_node)
+struct neigh_node *find_router(struct orig_node *orig_node,
+ struct batman_if *recv_if)
{
/* FIXME: each orig_node->batman_if will be attached to a softif */
struct bat_priv *bat_priv = netdev_priv(soft_device);
struct orig_node *primary_orig_node;
struct orig_node *router_orig;
- struct neigh_node *router;
+ struct neigh_node *router, *first_candidate, *best_router;
static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
+ int bonding_enabled;
if (!orig_node)
return NULL;
@@ -1022,10 +1018,13 @@
if (!orig_node->router)
return NULL;
- /* don't care if bonding is not enabled */
- if (!atomic_read(&bat_priv->bonding_enabled))
- return orig_node->router;
+ /* without bonding, the first node should
+ * always choose the default router. */
+ bonding_enabled = atomic_read(&bat_priv->bonding_enabled);
+ if (!bonding_enabled && (recv_if == NULL))
+ return orig_node->router;
+
router_orig = orig_node->router->orig_node;
/* if we have something in the primary_addr, we can search
@@ -1052,19 +1051,48 @@
if (primary_orig_node->bond.candidates < 2)
return orig_node->router;
- router = primary_orig_node->bond.selected;
- /* sanity check - this should never happen. */
- if (!router)
- return orig_node->router;
+ /* all nodes between should choose a candidate which
+ * is is not on the interface where the packet came
+ * in. */
+ first_candidate = primary_orig_node->bond.selected;
+ router = first_candidate;
- /* select the next bonding partner ... */
- primary_orig_node->bond.selected = router->next_bond_candidate;
+ if (bonding_enabled) {
+ /* in the bonding case, send the packets in a round
+ * robin fashion over the remaining interfaces. */
+ do {
+ /* recv_if == NULL on the first node. */
+ if (router->if_incoming != recv_if)
+ break;
+ router = router->next_bond_candidate;
+ } while (router != first_candidate);
+
+ primary_orig_node->bond.selected = router->next_bond_candidate;
+
+ } else {
+ /* if bonding is disabled, use the best of the
+ * remaining candidates which are not using
+ * this interface. */
+ best_router = first_candidate;
+
+ do {
+ /* recv_if == NULL on the first node. */
+ if ((router->if_incoming != recv_if) &&
+ (router->tq_avg > best_router->tq_avg))
+ best_router = router;
+
+ router = router->next_bond_candidate;
+ } while (router != first_candidate);
+
+ router = best_router;
+ }
+
return router;
}
-int recv_unicast_packet(struct sk_buff *skb)
+int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if)
{
struct unicast_packet *unicast_packet;
struct orig_node *orig_node;
@@ -1116,7 +1144,7 @@
orig_node = ((struct orig_node *)
hash_find(orig_hash, unicast_packet->dest));
- router = find_router(orig_node);
+ router = find_router(orig_node, recv_if);
if (!router) {
spin_unlock_irqrestore(&orig_hash_lock, flags);
Modified: trunk/batman-adv-kernelland/routing.h
===================================================================
--- trunk/batman-adv-kernelland/routing.h 2010-06-04 13:34:00 UTC (rev 1685)
+++ trunk/batman-adv-kernelland/routing.h 2010-06-04 13:50:59 UTC (rev 1686)
@@ -32,11 +32,12 @@
struct neigh_node *neigh_node,
unsigned char *hna_buff, int hna_buff_len);
int recv_icmp_packet(struct sk_buff *skb);
-int recv_unicast_packet(struct sk_buff *skb);
+int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if);
int recv_bcast_packet(struct sk_buff *skb);
int recv_vis_packet(struct sk_buff *skb);
int recv_bat_packet(struct sk_buff *skb,
struct batman_if *batman_if);
-struct neigh_node *find_router(struct orig_node *orig_node);
+struct neigh_node *find_router(struct orig_node *orig_node,
+ struct batman_if *recv_if);
void update_bonding_candidates(struct bat_priv *bat_priv,
struct orig_node *orig_node);
Modified: trunk/batman-adv-kernelland/soft-interface.c
===================================================================
--- trunk/batman-adv-kernelland/soft-interface.c 2010-06-04 13:34:00 UTC (rev 1685)
+++ trunk/batman-adv-kernelland/soft-interface.c 2010-06-04 13:50:59 UTC (rev 1686)
@@ -250,7 +250,7 @@
if (!orig_node)
orig_node = transtable_search(ethhdr->h_dest);
- router = find_router(orig_node);
+ router = find_router(orig_node, NULL);
if (!router)
goto unlock;
1
0
Author: axel
Date: 2010-06-04 15:34:00 +0200 (Fri, 04 Jun 2010)
New Revision: 1685
Modified:
trunk/bmx/bmx.c
trunk/bmx/bmx.h
trunk/bmx/hna.c
trunk/bmx/iid.c
trunk/bmx/iid.h
trunk/bmx/msg.c
Log:
iid.c hna.c msg.c bmx.ch CPU performance optimization
Modified: trunk/bmx/bmx.c
===================================================================
--- trunk/bmx/bmx.c 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/bmx.c 2010-06-04 13:34:00 UTC (rev 1685)
@@ -157,7 +157,7 @@
IDM_T blacklisted_neighbor(struct packet_buff *pb, struct description_hash *dhash)
{
- dbgf(DBGL_ALL, DBGT_INFO, "%s via %s", pb->neigh_str, pb->iif->name);
+ dbgf_all(DBGT_INFO, "%s via %s", pb->neigh_str, pb->iif->name);
return NO;
}
@@ -196,7 +196,7 @@
uint32_t update_metric(struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe)
{
- dbgf(DBGL_ALL, DBGT_INFO,
+ dbgf_all( DBGT_INFO,
"sqn_in %d sqn_max %d probe %u "
"metric_algo: mask 0x%X steps %d window %d lounge %d metric_record: clr %d, set %d val %u",
sqn_in, sqn_max, probe,
@@ -326,7 +326,7 @@
assertion( -500451, (nn));
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s", nn->dhn->on->id.name);
+ dbgf_all( DBGT_INFO, "%s", nn->dhn->on->id.name);
while ((ln = avl_iterate_item(&nn->link_tree, &an))) {
@@ -443,7 +443,7 @@
{
struct neigh_node *neigh = NULL;
- dbgf( DBGL_CHANGES, DBGT_INFO, "neigh %s neighIID4neigh %d dhn->orig %s",
+ dbgf_all( DBGT_INFO, "neigh %s neighIID4neigh %d dhn->orig %s",
ln->llip4_str, neighIID4neigh, dhn->on->desc0->id.name);
assertion(-500389, (ln && neighIID4neigh > IID_RSVD_MAX));
@@ -516,7 +516,7 @@
lndev->key.dev = dev;
lndev->key.llip4 = ln->llip4;
- dbgf( DBGL_CHANGES, DBGT_INFO, "creating new lndev %16s %10s %s",
+ dbgf_all( DBGT_INFO, "creating new lndev %16s %10s %s",
ipStr(ln->llip4), dev->name, dev->ip4_str );
list_add_tail(&ln->lndev_list, &lndev->list);
@@ -607,7 +607,7 @@
ln->rq_sqn_max = sqn;
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s dev %s",
+ dbgf_all(DBGT_INFO, "%s dev %s",
ipStr(ln->llip4), this_lndev ? this_lndev->key.dev->name : "???");
}
@@ -621,7 +621,7 @@
struct link_node *ln;
uint32_t itip4 = 0;
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s only_expired",
+ dbgf_all( DBGT_INFO, "%s %s %s only_expired",
ipStr(only_llip4), only_dev ? only_dev->name : "---", only_expired ? " " : "not");
while ((an = (only_llip4 ? (avl_find(&link_tree, &only_llip4)) : (avl_next(&link_tree, &itip4)))) && (ln = an->item)) {
@@ -639,7 +639,7 @@
if ((!only_dev || only_dev == lndev->key.dev) &&
(!only_expired || (((uint32_t) (bmx_time - lndev->pkt_time_max)) > (uint32_t) purge_to))) {
- dbgf(DBGL_SYS, DBGT_INFO, "purging lndev %16s %10s %s",
+ dbgf(DBGL_CHANGES, DBGT_INFO, "purging lndev %16s %10s %s",
ipStr(ln->llip4), lndev->key.dev->name, lndev->key.dev->ip4_str);
list_del_next(&ln->lndev_list, prev);
@@ -662,14 +662,9 @@
avl_remove(&nn->link_tree, &ln->llip4, -300198);
- dbgf(DBGL_SYS, DBGT_INFO, "ln->neigh %s (%d more link_tree.items)",
- ln->llip4_str, nn->link_tree.items);
-
if (!nn->link_tree.items) {
if (nn->dhn) {
- dbgf(DBGL_SYS, DBGT_INFO, "setting ln->neigh->dhn (%s) = NULL",
- nn->dhn->on->id.name);
nn->dhn->neigh = NULL;
}
@@ -705,7 +700,7 @@
dhn->on = on;
on->dhn = dhn;
- dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X.. myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+ dbgf_all(DBGT_INFO, "dhash %8X.. myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
return dhn;
}
@@ -734,13 +729,13 @@
struct dhash_node *dhn;
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
+ dbgf_all( DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
while ((dhn = plist_get_first(&dhash_invalid_plist)) ) {
if (purge_all || ((uint32_t) (bmx_time - dhn->referred_timestamp) > MIN_DHASH_TO)) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+ dbgf_all( DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
plist_rem_head(&dhash_invalid_plist);
avl_remove(&dhash_invalid_tree, &dhn->dhash, -300194);
@@ -756,7 +751,7 @@
STATIC_FUNC
void unlink_dhash_node(struct dhash_node *dhn)
{
- dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+ dbgf_all(DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
if (dhn->neigh) {
@@ -765,7 +760,7 @@
while ((an = dhn->neigh->link_tree.root) && (ln = an->item)) {
- dbgf(DBGL_SYS, DBGT_INFO, "dhn->neigh->link_tree item %s", ln->llip4_str);
+ dbgf_all(DBGT_INFO, "dhn->neigh->link_tree item %s", ln->llip4_str);
assertion(-500284, (ln->neigh == dhn->neigh));
@@ -808,7 +803,7 @@
void invalidate_dhash_node( struct dhash_node *dhn )
{
- dbgf(DBGL_CHANGES, DBGT_INFO,
+ dbgf_all( DBGT_INFO,
"dhash %8X myIID4orig %d, my_iid_repository: used %d, inactive %d min_free %d max_free %d ",
dhn->dhash.h.u32[0], dhn->myIID4orig,
my_iid_repos.tot_used, dhash_invalid_tree.items+1, my_iid_repos.min_free, my_iid_repos.max_free);
@@ -865,45 +860,51 @@
IDM_T update_orig_metrics(struct packet_buff *pb, struct orig_node *on, IID_T orig_sqn)
{
- dbgf(DBGL_ALL, DBGT_INFO, "%s orig_sqn %d via neigh %s", on->id.name, orig_sqn,pb->neigh_str);
+ dbgf_all( DBGT_INFO, "%s orig_sqn %d via neigh %s", on->id.name, orig_sqn,pb->neigh_str);
struct router_node *rn_in = NULL;
uint32_t metric_in, metric_best = 0;
SQN_T mask = on->path_metric_algo.sqn_mask;
-// SQN_T range = on->ogm_sqn_range;
+ struct link_key *key_in = &pb->lndev->key;
-// return SUCCESS;
-
if (on->blocked || (((SQN_T) (orig_sqn - on->ogm_sqn_min)) >= on->ogm_sqn_range))
return FAILURE;
-/*
+ SQN_T ogm_sqn_max_rcvd = MAX_SQ(on->ogm_sqn_max_rcvd, orig_sqn);
- if (((SQN_T) (((orig_sqn & mask) - (on->ogm_sqn_max_rcvd & mask)) - 1)) < on->ogm_sqn_range) {
+ if (((SQN_T) ((ogm_sqn_max_rcvd & mask) - (orig_sqn & mask))) > on->path_metric_algo.sqn_lounge ) {
+ dbgf(DBGL_CHANGES, DBGT_WARN, "%s orig_sqn %d to old max_sqn %d via neigh %s",
+ on->id.name, orig_sqn, on->ogm_sqn_max_rcvd, pb->neigh_str);
+
+ return FAILURE;
+ }
+
+ if (LESS_SQN((on->ogm_sqn_max_rcvd & mask), (orig_sqn & mask))) {
+
for (;;) {
struct router_node *rn;
struct avl_node *an;
-// SQN_T min_sqn_level = ((orig_sqn & mask) - on->ogm_sqn_steps);
struct router_node *rn_best = NULL;
uint32_t metric_temp;
metric_best = 0;
for (an = NULL; (rn = avl_iterate_item(&on->router_tree, &an));) {
- if (memcmp(&rn->key, &pb->lndev->key, sizeof (struct link_key))) {
+ if (rn->key.dev == key_in->dev && rn->key.llip4 == key_in->llip4) {
- metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, orig_sqn, 0);
+ rn_in = rn;
+ } else {
+
+ metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, ogm_sqn_max_rcvd, 0);
+
if (metric_best < metric_temp) {
metric_best = metric_temp;
rn_best = rn;
}
-
- } else {
- rn_in = rn;
}
}
@@ -916,69 +917,27 @@
}
} else {
- rn_in = avl_find_item(&on->router_tree, &pb->lndev->key);
- }
+ // already cleaned up, simple use last best_metric:
- on->ogm_sqn_max_rcvd = MAX_SQ(on->ogm_sqn_max_rcvd, orig_sqn);
+ metric_best = on->router_best_metric;
- */
- on->ogm_sqn_max_rcvd = MAX_SQ(on->ogm_sqn_max_rcvd, orig_sqn);
-
- if (((SQN_T) ((on->ogm_sqn_max_rcvd & mask) - (orig_sqn & mask))) > on->path_metric_algo.sqn_lounge ) {
-
- dbgf(DBGL_CHANGES, DBGT_WARN, "%s orig_sqn %d to old max_sqn %d via neigh %s",
- on->id.name, orig_sqn, on->ogm_sqn_max_rcvd, pb->neigh_str);
-
- return FAILURE;
+ rn_in = avl_find_item( &on->router_tree, key_in );
}
- for (;;) {
- struct router_node *rn;
- struct avl_node *an;
- struct router_node *rn_best = NULL;
- uint32_t metric_temp;
- metric_best = 0;
-
- for (an = NULL; (rn = avl_iterate_item(&on->router_tree, &an));) {
-
- if (memcmp(&rn->key, &pb->lndev->key, sizeof (struct link_key))) {
-
- metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, on->ogm_sqn_max_rcvd, 0);
-
- if (metric_best < metric_temp) {
-
- metric_best = metric_temp;
- rn_best = rn;
- }
-
- } else {
- rn_in = rn;
- }
- }
-
- if (rn_best && !avl_find(&link_dev_tree, &rn_best->key)) {
- purge_router_tree(on, NO);
- continue;
- } else {
- break;
- }
- }
-
-
if (!rn_in) {
rn_in = debugMalloc(sizeof (struct router_node), -300222);
memset( rn_in, 0, sizeof(struct router_node));
memcpy( &rn_in->key, &pb->lndev->key, sizeof(struct link_key));
-// rn_in->ogm_sqn_to_be_send = ((on->ogm_sqn_max_rcvd & mask) - on->ogm_sqn_steps);
avl_insert(&on->router_tree, rn_in, -300223);
}
- metric_in = update_metric(&rn_in->mr, &on->path_metric_algo, orig_sqn, on->ogm_sqn_max_rcvd, pb->lndev->mr[SQR_RTQ].val);
+ metric_in = update_metric(&rn_in->mr, &on->path_metric_algo, orig_sqn, ogm_sqn_max_rcvd, pb->lndev->mr[SQR_RTQ].val);
if (metric_in > metric_best && GREAT_SQN(rn_in->mr.set & mask, on->ogm_sqn_to_be_send & mask)) {
on->router_path_metric = metric_in;
+ on->router_best_metric = metric_in;
on->ogm_sqn_to_be_send = rn_in->mr.set;
ogm_aggreg_pending++;
@@ -1007,7 +966,13 @@
memcpy(&on->router_key, &rn_in->key, sizeof (struct link_key));
}
+
+ } else {
+ on->router_best_metric = metric_best;
}
+
+ on->ogm_sqn_max_rcvd = ogm_sqn_max_rcvd;
+
return SUCCESS;
}
@@ -1050,7 +1015,7 @@
void purge_orig(struct dev_node *only_dev, IDM_T only_expired)
{
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s only expired",
+ dbgf_all( DBGT_INFO, "%s %s only expired",
only_dev ? only_dev->name : "---", only_expired ? " " : "NOT");
purge_link_node( 0, only_dev, only_expired );
@@ -1165,7 +1130,7 @@
pb->lndev->pkt_time_max = bmx_time;
- dbgf(DBGL_ALL, DBGT_INFO, "rcvd packet from %s size %d via dev %s",
+ dbgf_all( DBGT_INFO, "rcvd packet from %s size %d via dev %s",
pb->neigh_str, hdr->pkt_length, iif->name);
if (blacklisted_neighbor(pb, NULL))
@@ -2197,13 +2162,13 @@
memcpy( &id, &on->id, sizeof(struct description_id));
- dbgf(DBGL_CHANGES, DBGT_INFO, "trying to unblock %s...", on->desc0->id.name);
+ dbgf_all( DBGT_INFO, "trying to unblock %s...", on->desc0->id.name);
IDM_T tlvs_res = process_description_tlvs(on, on->desc0, TLV_DEL_TEST_ADD, NULL);
assertion(-500364, (tlvs_res == TLVS_BLOCKED || tlvs_res == TLVS_SUCCESS));
- dbgf(DBGL_CHANGES, DBGT_INFO, "...unblocking %s %s !",
+ dbgf(DBGL_CHANGES, DBGT_INFO, "unblocking %s %s !",
on->desc0->id.name, tlvs_res == TLVS_SUCCESS ? "success" : "failed");
}
Modified: trunk/bmx/bmx.h
===================================================================
--- trunk/bmx/bmx.h 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/bmx.h 2010-06-04 13:34:00 UTC (rev 1685)
@@ -714,6 +714,7 @@
struct link_key router_key; // the neighbor which is the currently best_next_hop
struct avl_tree router_tree;
uint32_t router_path_metric;
+ uint32_t router_best_metric;
/*
Modified: trunk/bmx/hna.c
===================================================================
--- trunk/bmx/hna.c 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/hna.c 2010-06-04 13:34:00 UTC (rev 1685)
@@ -146,7 +146,7 @@
set_uhna4_key(&key, uhna4[m].prefix_len, uhna4[m].ip4, ntohl(uhna4[m].metric));
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s/%d metric %d",
+ dbgf_all( DBGT_INFO, "%s %s %s/%d metric %d",
tlv_op_str[op], glip4 ? "glip4:" : "uhna4:",
ipStr(key.glip4), key.prefix_len, ntohl(key.metric_be));
Modified: trunk/bmx/iid.c
===================================================================
--- trunk/bmx/iid.c 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/iid.c 2010-06-04 13:34:00 UTC (rev 1685)
@@ -26,7 +26,7 @@
int8_t iid_extend_repos(struct iid_repos *rep)
{
- dbgf( DBGL_CHANGES, DBGT_INFO, "sizeof iid: %lu, tot_used %d arr_size %d ",
+ dbgf_all(DBGT_INFO, "sizeof iid: %lu, tot_used %d arr_size %d ",
(rep == &my_iid_repos) ? sizeof (IID_NODE_T*) : sizeof (IID_T), rep->tot_used, rep->arr_size);
paranoia(-500217, (rep == &my_iid_repos && rep->tot_used != rep->arr_size));
@@ -103,7 +103,7 @@
rep->tot_used--;
- dbgf(DBGL_CHANGES, DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
+ dbgf_all( DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
m, iid, rep->tot_used, rep->min_free, rep->max_free);
if (rep->tot_used > 0 && rep->tot_used <= IID_MIN_USED) {
@@ -130,7 +130,7 @@
if (dhn) {
if (!dhn->on) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "myIID4x %d INVALIDATED %d sec ago",
+ dbgf_all( DBGT_INFO, "myIID4x %d INVALIDATED %d sec ago",
myIID4x, (bmx_time - dhn->referred_timestamp) / 1000);
}
@@ -246,7 +246,7 @@
if (p < rep->max_free && rep->arr.ref[p].myIID4x == myIID4x) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "removed stale rep->arr.sid[%d] = %d", p, myIID4x);
+ dbgf_all(DBGT_INFO, "removed stale rep->arr.sid[%d] = %d", p, myIID4x);
iid_free(rep, p);
}
@@ -272,7 +272,7 @@
my_iid_repos.min_free = pos;
my_iid_repos.max_free = MAX(pos, my_iid_repos.max_free);
- dbgf(DBGL_CHANGES, DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
+ dbgf_all(DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
1, mid, my_iid_repos.tot_used, my_iid_repos.min_free, my_iid_repos.max_free);
dhn->referred_timestamp = bmx_time;
Modified: trunk/bmx/iid.h
===================================================================
--- trunk/bmx/iid.h 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/iid.h 2010-06-04 13:34:00 UTC (rev 1685)
@@ -27,7 +27,7 @@
#define IID_NODE_T struct dhash_node
extern IID_NODE_T *unused2; // ensure knowledge of this type
-#define IID_REPOS_SIZE_BLOCK 2
+#define IID_REPOS_SIZE_BLOCK 128
#define IID_REPOS_SIZE_MAX ((IID_T)(-1))
#define IID_REPOS_SIZE_WARN 1024
Modified: trunk/bmx/msg.c
===================================================================
--- trunk/bmx/msg.c 2010-06-03 23:50:21 UTC (rev 1684)
+++ trunk/bmx/msg.c 2010-06-04 13:34:00 UTC (rev 1685)
@@ -198,7 +198,7 @@
struct description_hash tmp_dhash;
memset( &tmp_dhash, 0, sizeof(struct description_hash));
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
+ dbgf_all( DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
paranoia( -500349, (!is_zero((char*)&tmp_dhash, BMX_HASH0_LEN)));
@@ -234,7 +234,7 @@
return;
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "%8X..", dhash->h.u32[0]);
+ dbgf_all( DBGT_INFO, "%8X..", dhash->h.u32[0]);
paranoia(-500261, (description_cache_tree.items > DEF_DESC0_CACHE_SIZE));
@@ -273,7 +273,7 @@
memset(&key, 0, sizeof (struct tx_timestamp_key));
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s", dev->name, purge_all ? "purge_all" : "only_expired");
+ dbgf_all( DBGT_INFO, "%s %s", dev->name, purge_all ? "purge_all" : "only_expired");
while ((an = avl_next(&dev->tx_timestamp_tree, (ttn ? &ttn->key : &key)))) {
@@ -410,7 +410,7 @@
continue;
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s dsc_sqn %d size %d ",
+ dbgf_all( DBGT_INFO, "%s %s dsc_sqn %d size %d ",
tlv_op_str[op], desc->id.name, ntohs(desc->dsc_sqn), ntohs(desc->dsc_tlvs_len));
@@ -524,7 +524,7 @@
int id_name_len;
- dbgf( DBGL_CHANGES, DBGT_INFO, "via dev: %s NB %s:dhash %8X.. id.rand %jX",
+ dbgf_all( DBGT_INFO, "via dev: %s NB %s:dhash %8X.. id.rand %jX",
pb->iif->name, pb->neigh_str, dhash->h.u32[0], desc->id.rand.u64[0]);
if (
@@ -592,7 +592,7 @@
avl_insert(&orig_tree, on, -300148);
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "rcvd new desc SQN %d (old %d) from %s via %s NB %s",
+ dbgf_all( DBGT_INFO, "rcvd new desc SQN %d (old %d) from %s via %s NB %s",
ntohs(desc->dsc_sqn), on->desc0_sqn, desc->id.name, pb->iif->name, pb->neigh_str);
if (process_description_tlvs(on, desc, TLV_DEL_TEST_ADD, NULL) == TLVS_FAILURE)
@@ -690,7 +690,7 @@
if (tx_creator_result != ((int) ((ttn)->frame_data_length_target))) {
- dbgf(DBGL_CHANGES, DBGT_WARN, "msg %s to %s via %s mid4o %d send_data %d != target_data %d ",
+ dbgf_all( DBGT_WARN, "msg %s to %s via %s mid4o %d send_data %d != target_data %d ",
frame_handler[(ttn)->frame_type].name,
ipStr((ttn)->dst_ip4),
(ttn)->dev->name,
@@ -727,7 +727,7 @@
// struct link_node *ln_out = lndev_out ? lndev_out->link : NULL;
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s sqn %d myIID4x %d neighIID4x %d",
+ dbgf_all( DBGT_INFO, "%s %s %s sqn %d myIID4x %d neighIID4x %d",
frame_handler[frame_type].name, ipStr(dest_ip4), dev_out->name, sqn, myIID4x, neighIID4x);
if (frame_handler[ frame_type ].min_rtq > (lndev_out ? lndev_out->mr[SQR_RTQ].val : 0)) {
@@ -824,7 +824,7 @@
void create_ogm_aggregation(void)
{
- dbgf(DBGL_CHANGES, DBGT_INFO, " ");
+ dbgf_all( DBGT_INFO, " ");
uint32_t n = 0;
@@ -840,7 +840,7 @@
IID_T start_iid = curr_iid;
- dbgf(DBGL_CHANGES, DBGT_INFO, "pending %d target %d start %d",
+ dbgf_all( DBGT_INFO, "pending %d target %d start %d",
ogm_aggreg_pending, target_aggregations, start_iid);
do {
@@ -855,10 +855,15 @@
on->ogm_sqn_aggregated + on->path_metric_algo.sqn_steps))
warn++;
- dbgf(warn ? DBGL_CHANGES : DBGL_ALL, warn ? DBGT_WARN : DBGT_INFO, "%s %s %d < %d",
- on->id.name, warn ? "delayed!" : "in-time",
- on->ogm_sqn_aggregated, on->ogm_sqn_to_be_send);
+ if ( warn ) {
+ dbgf(DBGL_CHANGES, DBGT_WARN, "%s delayed %d < %d",
+ on->id.name, on->ogm_sqn_aggregated, on->ogm_sqn_to_be_send);
+ } else {
+ dbgf_all(DBGT_INFO, "%s in-time %d < %d",
+ on->id.name, on->ogm_sqn_aggregated, on->ogm_sqn_to_be_send);
+ }
+
on->ogm_sqn_aggregated = on->ogm_sqn_to_be_send & on->path_metric_algo.sqn_mask;
ogm[n].orig_sqn = htons(on->ogm_sqn_to_be_send);
@@ -896,7 +901,7 @@
oan->tx_timestamp = (bmx_time - DEF_OGM_RESEND_INTERVAL);
oan->sqn = ++ogm_aggreg_sqn_max;
- dbgf(DBGL_CHANGES, DBGT_INFO, "aggregation_sqn %d aggregated_ogms %d", oan->sqn, n);
+ dbgf_all( DBGT_INFO, "aggregation_sqn %d aggregated_ogms %d", oan->sqn, n);
list_add_tail(&ogm_aggreg_list, &oan->list);
@@ -935,9 +940,9 @@
if ( oan_criteria || dhn_criteria ) {
if (oan_criteria) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "aggreg_sqn %d ", oan_criteria->sqn);
+ dbgf_all(DBGT_INFO, "aggreg_sqn %d ", oan_criteria->sqn);
} else if (dhn_criteria) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "NOT %s ", dhn_criteria->on->id.name);
+ dbgf_all(DBGT_INFO, "NOT %s ", dhn_criteria->on->id.name);
}
for (an = NULL; (dev = avl_iterate_item(&dev_ip4_tree, &an));)
@@ -958,7 +963,7 @@
assertion(-500446, (nn->best_rtq->key.dev));
assertion(-500447, (nn->best_rtq->key.dev->active));
- dbgf(DBGL_CHANGES, DBGT_INFO, " via %s to %s (redundant %d)",
+ dbgf_all( DBGT_INFO, " via %s to %s (redundant %d)",
nn->best_rtq->key.dev->name, nn->best_rtq->link->llip4_str,
nn->best_rtq->key.dev->misc_flag);
@@ -986,7 +991,7 @@
if (dev) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s max %d active aggregations %d pending ogms %d expiery in %d ms",
+ dbgf_all( DBGT_INFO, "%s max %d active aggregations %d pending ogms %d expiery in %d ms",
dev->name, ogm_aggreg_sqn_max, ogm_aggreg_list.items, ogm_aggreg_pending,
(DEF_OGM_AGGREG_INTERVAL - ((uint32_t) (bmx_time - timestamp))));
@@ -1072,7 +1077,7 @@
hey0_rep->receiver_ip4 = ttn->dst_ip4;
hey0_rep->hello_dev_sqn = htons(ttn->sqn);
- dbgf(DBGL_CHANGES, DBGT_INFO, "dev %s %s to %s SQN %d",// dest_sid: %d",
+ dbgf_all( DBGT_INFO, "dev %s %s to %s SQN %d",// dest_sid: %d",
ttn->dev->name, ttn->dev->ip4_str, ipStr(ttn->dst_ip4), ttn->sqn/*, dtn->my_id_for_neigh*/);
return sizeof (struct msg_hello_reply);
@@ -1102,7 +1107,7 @@
update_metric(&lndev->mr[SQR_RTQ], &link_metric_algo[SQR_RTQ], ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, 0);
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s SQN %d", ttn->dev->name, ttn->dev->ip4_str, ttn->dev->ogm_sqn);
+ dbgf_all( DBGT_INFO, "%s %s SQN %d", ttn->dev->name, ttn->dev->ip4_str, ttn->dev->ogm_sqn);
return sizeof (struct msg_hello_adv);
}
@@ -1117,7 +1122,7 @@
req->receiver_ip4 = ttn->dst_ip4;
req->receiverIID4x = htons(ttn->neighIID4x);
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s oif %s to %s requesting orig_did %d",
+ dbgf_all( DBGT_INFO, "%s oif %s to %s requesting orig_did %d",
frame_handler[ttn->frame_type].name, ttn->dev->name, ipStr(ttn->dst_ip4), ttn->neighIID4x);
return sizeof ( struct msg_description_request);
@@ -1204,7 +1209,7 @@
assertion(-500428, (ttn->frame_data_length_target <= buff_size));
- dbgf(DBGL_CHANGES, DBGT_INFO, " aggregation_sqn %d", ttn->sqn );
+ dbgf_all( DBGT_INFO, " aggregation_sqn %d", ttn->sqn );
list_for_each( list_pos, &ogm_aggreg_list )
{
@@ -1237,7 +1242,7 @@
ack->receiver_ip4 = ttn->dst_ip4;
ack->aggregation_sqn = htons(ttn->sqn);
- dbgf(DBGL_CHANGES, DBGT_INFO, " aggreg_sqn %d to %s", ttn->sqn, ipStr(ttn->dst_ip4));
+ dbgf_all( DBGT_INFO, " aggreg_sqn %d to %s", ttn->sqn, ipStr(ttn->dst_ip4));
return sizeof (struct msg_ogm_ack);
}
@@ -1255,10 +1260,10 @@
uint16_t msgs = (frame->length - (sizeof (struct frame_header) + sizeof (struct hdr_ogm_adv))) /
sizeof (struct msg_ogm_adv);
- dbgf(DBGL_CHANGES, DBGT_INFO, " ");
+ dbgf_all( DBGT_INFO, " ");
if (!nn) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "via unknown neigh %s", pb->neigh_str );
+ dbgf_all( DBGT_INFO, "via unknown neigh %s", pb->neigh_str );
schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_REQS, 0, 0, 0, IID_RSVD_4YOU);
return frame->length;
}
@@ -1269,7 +1274,7 @@
if (bit_get(nn->ogm_aggregations_rcvd, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn)) {
- dbgf(DBGL_CHANGES, DBGT_INFO, "already known ogm_aggregation_sqn %d from neigh %s",
+ dbgf_all( DBGT_INFO, "already known ogm_aggregation_sqn %d from neigh %s",
aggregation_sqn, nn->dhn->on->id.name);
return frame->length;
@@ -1277,7 +1282,7 @@
if (((uint16_t) (nn->ogm_aggregation_rcvd_max - aggregation_sqn)) > OGM_AGGREG_SQN_CACHE_WARN) {
- dbgf( DBGL_SYS, DBGT_WARN, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
+ dbgf(DBGL_CHANGES, DBGT_WARN, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
pb->neigh_str, "OLD", aggregation_sqn, nn->ogm_aggregation_rcvd_max, msgs);
}
@@ -1298,7 +1303,7 @@
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
+ dbgf_all(DBGT_INFO, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
pb->neigh_str, "NEW", aggregation_sqn, nn->ogm_aggregation_rcvd_max, msgs);
uint16_t m;
@@ -1316,7 +1321,7 @@
if (dhn && (on = dhn->on) && ((SQN_T) (orig_sqn - on->ogm_sqn_min)) < on->ogm_sqn_range) {
- dbgf(DBGL_CHANGES, DBGT_INFO, " new orig_sqn %d / %d from %s neighIID4x %d via %s ",
+ dbgf_all(DBGT_INFO, " new orig_sqn %d / %d from %s neighIID4x %d via %s ",
orig_sqn, on->ogm_sqn_to_be_send, on->id.name, neighIID4x, pb->neigh_str);
update_orig_metrics(pb, on, orig_sqn);
@@ -1365,7 +1370,7 @@
bit_set(pb->ln->neigh->ogm_aggregations_acked, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn, 1);
- dbgf(DBGL_CHANGES, DBGT_INFO, "neigh %s sqn %d <= sqn_max %d",
+ dbgf_all(DBGT_INFO, "neigh %s sqn %d <= sqn_max %d",
pb->neigh_str, aggregation_sqn, ogm_aggreg_sqn_max);
@@ -1402,7 +1407,7 @@
if (orig_dhn == my_orig_node.dhn) {
- dbgf(DBGL_CHANGES, DBGT_INFO,
+ dbgf_all( DBGT_INFO,
"msg refers myself via %s neighIID4neigh %d neighIID4me %d",
pb->neigh_str, ln->neigh->neighIID4neigh, neighIID4x);
@@ -1470,7 +1475,7 @@
}
- dbgf(DBGL_CHANGES, DBGT_INFO, "via dev: %s NB %s:dhash %8X.. %s neighIID4x %d is_sender %d %s",
+ dbgf_all( DBGT_INFO, "via dev: %s NB %s:dhash %8X.. %s neighIID4x %d is_sender %d %s",
pb->iif->name, pb->neigh_str, dhash->h.u32[0],
(dsc ? "DESCRIPTION" : (cache ? "CACHED_DESCRIPTION" : (orig_dhn?"KNOWN":"UNDESCRIBED"))),
neighIID4x, is_sender,
@@ -1556,7 +1561,7 @@
dhn = process_dhash_description_neighIID4x(pb, &dhash0, desc0, neighIID4x, is_sender);
- dbgf(DBGL_CHANGES, DBGT_INFO, "rcvd %s desc0: %jX via %s NB %s",
+ dbgf_all( DBGT_INFO, "rcvd %s desc0: %jX via %s NB %s",
dhn ? "accepted" : "denied", desc0->id.rand.u64[0], pb->iif->name, pb->neigh_str);
@@ -1606,7 +1611,7 @@
IID_T myIID4x = ntohs(req->receiverIID4x);
uint16_t desc0_len = 0;
- dbg(DBGL_CHANGES, DBGT_INFO, "%s dest_llip4 %s myIID4x %d",
+ dbgf_all( DBGT_INFO, "%s dest_llip4 %s myIID4x %d",
frame_handler[frame_type].name, ipStr(req->receiver_ip4), myIID4x);
if ( req->receiver_ip4 != pb->iif->ip4_addr ) // if I am not asked
@@ -1666,7 +1671,7 @@
SQN_T sqn = ntohs(msg->hello_dev_sqn);
- dbgf(DBGL_CHANGES, DBGT_INFO, "via NB %s dev %s %s to %s SQN %d",
+ dbgf_all( DBGT_INFO, "via NB %s dev %s %s to %s SQN %d",
pb->neigh_str, pb->iif->name, pb->iif->ip4_str, ipStr(msg->receiver_ip4), sqn);
if ( msg->receiver_ip4 != pb->iif->ip4_addr )
@@ -1675,7 +1680,7 @@
if ((SQN_T) (pb->iif->ogm_sqn - sqn) > (SQN_T) local_rtq_lounge) {
- dbgf(DBGL_SYS, DBGT_INFO, "DAD-Alert invalid Link-Local SQN %d!=%d from %s via %s",
+ dbgf(DBGL_SYS, DBGT_ERR, "DAD-Alert invalid Link-Local SQN %d!=%d from %s via %s",
sqn, pb->iif->ogm_sqn, pb->neigh_str, pb->iif->name);
return FAILURE;
@@ -1722,7 +1727,7 @@
SQN_T sqn = ntohs(msg->hello_dev_sqn);
- dbgf(DBGL_CHANGES, DBGT_INFO, "NB %s via %s SQN %d ", pb->neigh_str, pb->iif->name, sqn);
+ dbgf_all( DBGT_INFO, "NB %s via %s SQN %d ", pb->neigh_str, pb->iif->name, sqn);
// skip updateing link_node if this SQN is known but not new
if ((ln->rq_sqn_max || ln->rq_time_max) &&
@@ -1768,7 +1773,7 @@
struct pkt_frame_handler *fhdl = &frame_handler[t];
- dbgf(DBGL_CHANGES, DBGT_INFO, "type %s size %d flags 0x%X",
+ dbgf_all( DBGT_INFO, "type %s size %d flags 0x%X",
fhdl->name, flength, fhdr->flags);
@@ -1913,7 +1918,7 @@
assertion(-500424, (fhdl->tx_msg_creator));
assertion(-500441, (ttn->myIID4x == IID_RSVD_4YOU));
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s type %d=%s %s",
+ dbgf_all( DBGT_INFO, "%s type %d=%s %s",
dev->name, type, fhdl->name, "from dev->my_tx_tasks");
if (tx_task_obsolete(dev, type, ttn)) {
@@ -1962,7 +1967,7 @@
assertion(-500440, (ttn->frame_type == type));
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s type %d=%s %s",
+ dbgf_all( DBGT_INFO, "%s type %d=%s %s",
dev->name, type, fhdl->name, "from dev->tx_tasks_list");
if (ttn->tx_timestamp == bmx_time) {
@@ -2037,7 +2042,7 @@
frame_hdr->length = htons(length);
frame_hdr->flags |= flags;
- dbgf(DBGL_ALL, DBGT_INFO, "send frame type %s size %d", fhdl->name, length);
+ dbgf_all( DBGT_INFO, "send frame type %s size %d", fhdl->name, length);
}
@@ -2053,7 +2058,7 @@
send_udp_packet(tx_buff, packet_size, &dev->ip4_netwbrc_addr, dev->unicast_sock);
- dbgf(DBGL_ALL, DBGT_INFO, "send packet size %d via dev %s", packet_size, dev->name);
+ dbgf_all( DBGT_INFO, "send packet size %d via dev %s", packet_size, dev->name);
packet_size = sizeof ( struct packet_header);
packet_full = NO;
@@ -2081,7 +2086,7 @@
register_task( my_hello_interval, schedule_my_hello_message, dev );
- dbgf(DBGL_CHANGES, DBGT_INFO, "%s", dev->name);
+ dbgf_all( DBGT_INFO, "%s", dev->name);
if (!LIST_EMPTY(&(dev->tx_tasks_list[FRAME_TYPE_HI40_ADVS]))) {
dbgf( DBGL_SYS, DBGT_ERR, " ");
@@ -2101,7 +2106,7 @@
if (((uint32_t) (my_orig_node.ogm_sqn_to_be_send + 1 - my_orig_node.ogm_sqn_min)) < my_orig_node.ogm_sqn_range) {
ogm_aggreg_pending++;
- dbgf(DBGL_CHANGES, DBGT_INFO, "ogm_sqn %d", my_orig_node.ogm_sqn_to_be_send);
+ dbgf_all(DBGT_INFO, "ogm_sqn %d", my_orig_node.ogm_sqn_to_be_send);
} else {
@@ -2194,7 +2199,7 @@
my_desc0_tlv_len += sizeof (struct frame_header) + msgs_size;
- dbgf(DBGL_CHANGES, DBGT_INFO, "added %s size %d",
+ dbgf_all(DBGT_INFO, "added %s size %d",
description0_tlv_handler[tlvt].name, msgs_size);
}
@@ -2206,7 +2211,7 @@
dsc->dsc_tlvs_len = htons(my_desc0_tlv_len);
- dbgf(DBGL_CHANGES, DBGT_INFO, "added tlv total of %d ", my_desc0_tlv_len);
+ dbgf_all(DBGT_INFO, "added tlv total of %d ", my_desc0_tlv_len);
// calculate hash: like shown in CTaoCrypt Usage Reference:
ShaUpdate(&bmx_sha, (byte*)dsc, (sizeof (struct description) + my_desc0_tlv_len));
1
0
Author: axel
Date: 2010-06-04 01:50:21 +0200 (Fri, 04 Jun 2010)
New Revision: 1684
Modified:
trunk/bmx/Makefile
trunk/bmx/bmx.c
trunk/bmx/bmx.h
trunk/bmx/msg.c
trunk/bmx/msg.h
Log:
Makefile bmx.h : fix -DREVISION_VERSION=0
bmx.c msg.c : less system logging
msg.h changed parametrization
Modified: trunk/bmx/Makefile
===================================================================
--- trunk/bmx/Makefile 2010-06-03 20:07:47 UTC (rev 1683)
+++ trunk/bmx/Makefile 2010-06-03 23:50:21 UTC (rev 1684)
@@ -13,9 +13,8 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA
-REVISION_VERSION = 0$(shell if [ -d .svn ]; then which svn > /dev/null && which sed > /dev/null && which awk > /dev/null && { svn info | grep "Rev:" | sed -e '1p' -n | awk '{print $$4}';} fi )
+REVISION_VERSION = $(shell if [ -d .svn ]; then which svn > /dev/null && which sed > /dev/null && which awk > /dev/null && { svn info | grep "Rev:" | sed -e '1p' -n | awk '{print $$4}';};else echo 0; fi )
-
##CFLAGS ?= -I./lua-5.1.4/src -I./cyassl-1.4.0/include -O0 -ggdb3
##LDFLAGS ?= -L./lua-5.1.4/src -L./cyassl-1.4.0/src/.libs
Modified: trunk/bmx/bmx.c
===================================================================
--- trunk/bmx/bmx.c 2010-06-03 20:07:47 UTC (rev 1683)
+++ trunk/bmx/bmx.c 2010-06-03 23:50:21 UTC (rev 1684)
@@ -443,7 +443,7 @@
{
struct neigh_node *neigh = NULL;
- dbgf( DBGL_SYS, DBGT_INFO, "neigh %s neighIID4neigh %d dhn->orig %s",
+ dbgf( DBGL_CHANGES, DBGT_INFO, "neigh %s neighIID4neigh %d dhn->orig %s",
ln->llip4_str, neighIID4neigh, dhn->on->desc0->id.name);
assertion(-500389, (ln && neighIID4neigh > IID_RSVD_MAX));
Modified: trunk/bmx/bmx.h
===================================================================
--- trunk/bmx/bmx.h 2010-06-03 20:07:47 UTC (rev 1683)
+++ trunk/bmx/bmx.h 2010-06-03 23:50:21 UTC (rev 1684)
@@ -31,6 +31,10 @@
#include "allocate.h"
+#ifndef REVISION_VERSION
+#define REVISION_VERSION 0
+#endif
+
/*
* from other headers:
*/
Modified: trunk/bmx/msg.c
===================================================================
--- trunk/bmx/msg.c 2010-06-03 20:07:47 UTC (rev 1683)
+++ trunk/bmx/msg.c 2010-06-03 23:50:21 UTC (rev 1684)
@@ -742,7 +742,7 @@
if ((ttn = dev_out->my_tx_tasks[frame_type])) {
- dbgf(DBGL_SYS, DBGT_WARN, "my_tx_task for %s %s myIID4x %d neighIID4x %d dst %s NOT NULL",
+ dbgf(DBGL_CHANGES, DBGT_WARN, "my_tx_task for %s %s myIID4x %d neighIID4x %d dst %s NOT NULL",
frame_handler[frame_type].name, dev_out->name, myIID4x, neighIID4x, ipStr(dest_ip4));
assertion(-500442, (ttn->myIID4x == IID_RSVD_4YOU));
@@ -1323,7 +1323,7 @@
} else {
- dbgf(!dhn ? DBGL_CHANGES : DBGL_SYS, DBGT_WARN,
+ dbgf((dhn && on) ? DBGL_SYS : DBGL_CHANGES, DBGT_WARN,
" %s orig_sqn %d or neighIID4x %d via %s orig %s sqn_min %d sqn_range %d",
!dhn ? "UNKNOWN" : on ? "EXCEEDED OGM_SQN RANGE" : "INVALIDATED",
orig_sqn, neighIID4x, pb->neigh_str, on ? on->id.name:"---",
@@ -1691,7 +1691,7 @@
}
if (found > 1) {
- dbgf(DBGL_SYS, DBGT_WARN,
+ dbgf(DBGL_CHANGES, DBGT_WARN,
"rcvd %d %s messages in %d-bytes frame",
found, frame_handler[FRAME_TYPE_HI40_REPS].name, frame->length);
}
@@ -1794,7 +1794,7 @@
} else if (fhdl->min_rtq && (!pb->lndev || pb->lndev->mr[SQR_RTQ].val < fhdl->min_rtq)) {
- dbg_mute(60, DBGL_SYS, DBGT_WARN,
+ dbg_mute(60, DBGL_CHANGES, DBGT_WARN,
"non-sufficient bidirectional link %s - %s (rtq %d), skipping frame type %s",
pb->iif->ip4_str, pb->neigh_str,
pb->lndev ? pb->lndev->mr[SQR_RTQ].val : 0, fhdl->name);
Modified: trunk/bmx/msg.h
===================================================================
--- trunk/bmx/msg.h 2010-06-03 20:07:47 UTC (rev 1683)
+++ trunk/bmx/msg.h 2010-06-03 23:50:21 UTC (rev 1684)
@@ -34,14 +34,14 @@
#define ARG_AGGREG_INTERVAL "aggregation_interval"
#define ARG_HELLO_INTERVAL "hello_interval"
-#define DEF_HELLO_INTERVAL DEF_OGM_AGGREG_INTERVAL
+#define DEF_HELLO_INTERVAL DEF_AGGREG_INTERVAL
#define MIN_HELLO_INTERVAL 50
#define MAX_HELLO_INTERVAL 10000
extern int32_t my_hello_interval;
#define ARG_OGM_INTERVAL "ogm_interval"
-#define DEF_OGM_INTERVAL 2000
+#define DEF_OGM_INTERVAL 2500
#define MIN_OGM_INTERVAL 200
#define MAX_OGM_INTERVAL 60000
extern int32_t my_ogm_interval;
@@ -52,16 +52,16 @@
-#define MIN_OGM_AGGREG_INTERVAL ( MIN_OGM_INTERVAL/10 )
-#define MAX_OGM_AGGREG_INTERVAL ( DEF_OGM_INTERVAL/2 )
-#define DEF_OGM_AGGREG_INTERVAL ( DEF_OGM_INTERVAL/5 )
+#define MIN_OGM_AGGREG_INTERVAL ( (MIN_AGGREG_INTERVAL / 3) * 2 )
+#define MAX_OGM_AGGREG_INTERVAL ( (MAX_AGGREG_INTERVAL / 3) * 2 )
+#define DEF_OGM_AGGREG_INTERVAL ( (DEF_AGGREG_INTERVAL / 3) * 2 )
#define MAX_OGM_RESEND_INTERVAL (MAX_AGGREG_INTERVAL * 2)
#define DEF_OGM_RESEND_INTERVAL ((DEF_AGGREG_INTERVAL * 2) / 3)
#define MIN_OGM_RESEND_ATTEMPTS 0
#define MAX_OGM_RESEND_ATTEMPTS 5
-#define DEF_OGM_RESEND_ATTEMPTS 3
+#define DEF_OGM_RESEND_ATTEMPTS 2
#define ARG_OGM_RESEND_ATTEMPTS "ogm_resend_attempts"
#define MIN_NBDISC_RTQ (PROBE_RANGE / 8)
1
0
r1683 - in trunk: . batman bmx bmx/cyassl bmx/lib bmx/lib/bmx_uci_config
by postmasterï¼ open-mesh.net 03 Jun '10
by postmasterï¼ open-mesh.net 03 Jun '10
03 Jun '10
Author: axel
Date: 2010-06-03 22:07:47 +0200 (Thu, 03 Jun 2010)
New Revision: 1683
Added:
trunk/bmx/
trunk/bmx/Makefile
trunk/bmx/allocate.c
trunk/bmx/allocate.h
trunk/bmx/avl.c
trunk/bmx/avl.h
trunk/bmx/bmx.c
trunk/bmx/bmx.h
trunk/bmx/control.c
trunk/bmx/control.h
trunk/bmx/cyassl/
trunk/bmx/cyassl/config.h
trunk/bmx/cyassl/misc.c
trunk/bmx/cyassl/misc.h
trunk/bmx/cyassl/sha.c
trunk/bmx/cyassl/sha.h
trunk/bmx/cyassl/types.h
trunk/bmx/hna.c
trunk/bmx/hna.h
trunk/bmx/iid.c
trunk/bmx/iid.h
trunk/bmx/lib/
trunk/bmx/lib/Makefile
trunk/bmx/lib/bmx_uci_config/
trunk/bmx/lib/bmx_uci_config/Makefile
trunk/bmx/lib/bmx_uci_config/uci_config.c
trunk/bmx/lib/bmx_uci_config/uci_config.h
trunk/bmx/list.c
trunk/bmx/list.h
trunk/bmx/msg.c
trunk/bmx/msg.h
trunk/bmx/plugin.c
trunk/bmx/plugin.h
trunk/bmx/route.c
trunk/bmx/route.h
trunk/bmx/schedule.c
trunk/bmx/schedule.h
Modified:
trunk/batman/Makefile
Log:
starting BMX-v0.4 development cycle, (incompatible with BatMan-eXperimental v0.3 branch)
Modified: trunk/batman/Makefile
===================================================================
--- trunk/batman/Makefile 2010-06-02 15:47:07 UTC (rev 1682)
+++ trunk/batman/Makefile 2010-06-03 20:07:47 UTC (rev 1683)
@@ -29,7 +29,7 @@
#NO_POLICY_ROUTING = -DNO_POLICY_ROUTING
CC = gcc
-CFLAGS += -pedantic -Wall -W -O1 -g3 -std=gnu99
+CFLAGS += -pedantic -Wall -W -Os -g3 -std=gnu99
EXTRA_CFLAGS = -DDEBUG_MALLOC -DMEMORY_USAGE -DPROFILE_DATA $(NO_POLICY_ROUTING) -DREVISION_VERSION=$(REVISION_VERSION)
LDFLAGS += -lpthread
Added: trunk/bmx/Makefile
===================================================================
--- trunk/bmx/Makefile (rev 0)
+++ trunk/bmx/Makefile 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,168 @@
+# Copyright (C) 2010 BMX contributors:
+# 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
+
+REVISION_VERSION = 0$(shell if [ -d .svn ]; then which svn > /dev/null && which sed > /dev/null && which awk > /dev/null && { svn info | grep "Rev:" | sed -e '1p' -n | awk '{print $$4}';} fi )
+
+
+##CFLAGS ?= -I./lua-5.1.4/src -I./cyassl-1.4.0/include -O0 -ggdb3
+##LDFLAGS ?= -L./lua-5.1.4/src -L./cyassl-1.4.0/src/.libs
+
+#CFLAGS ?= -I$(shell pwd)/cyassl-1.4.0/ctaocrypt/include -DHAVE_CONFIG_H
+#LDFLAGS ?= -L./cyassl-1.4.0/src/.libs
+
+
+CFLAGS += -pedantic -Wall -W -Wno-unused-parameter -Os -g3 -std=gnu99 -I./ \
+ -DHAVE_CONFIG_H -DREVISION_VERSION=$(REVISION_VERSION) -DDEBUG_MALLOC -DMEMORY_USAGE
+
+LDFLAGS += -Wl,-export-dynamic -ldl -g3 -lm
+
+#-lcyassl
+#LDFLAGS += -shared -lssl -lcrypto
+# -static
+# -pg
+
+
+#CFLAGS += -DTESTDEBUG
+#CFLAGS += -DAVL_DEBUG -DAVL_TEST
+#CFLAGS += -DPROFILING -DEXTREME_PARANOIA -D
+
+#EXTRA_CFLAGS +=
+#EXTRA_LDFLAGS +=
+
+# Recommended defines and approximate binary sizes with gcc-x86
+# -static
+# -pedantic -Wall -W -Wno-unused-parameter -O1 -g3 -std=gnu99
+# -pg # "-pg" with openWrt toolchain results in "gcrt1.o: No such file" ?!
+#
+
+# compared to -O1 stripped:
+# -Os - ~29k
+
+# -DDEBUG_MALLOC + ~0k
+# -DMEMORY_USAGE + ~1k
+
+# optional defines (you may disable these features if you dont need it):
+# -DNOTRAILER - ~3K
+# -DNODEBUGALL - ~13k
+# -DLESS_OPTIONS - ~8K
+#
+# -DNOTUNNEL (only affects this node) - ~23k
+# -DNOSRV (only affects this node) - ~3k
+# -DNOVIS (only affects this node) - ~2k
+
+# -DNODEPRECATED (for backward compatibility) - ~2k
+
+# experimental or advanced defines (please dont touch):
+# -DNOHNA (affects all nodes in network) - ~6k
+# -DNO_PARANOIA (makes bug-hunting impossible) - ~2k
+# -DEXTREME_PARANOIA
+# -DEXTDEBUG (this eats your cpu) + ~0k
+# -DTESTDEBUG (testing syntax of __VA_ARGS__ dbg...() macros)
+# -DWITHUNUSED (includes yet unused stuff)
+# -DPROFILING (no static functions)
+
+
+SBINDIR = $(INSTALL_PREFIX)/usr/sbin
+
+LOG_BRANCH= trunk/bmx2
+
+SRC_FILES= "\(\.c\)\|\(\.h\)\|\(Makefile\)\|\(INSTALL\)\|\(LIESMICH\)\|\(README\)\|\(THANKS\)\|\(./posix\)\|\(./linux\)\|\(./man\)\|\(./doc\)"
+
+SRC_C= bmx.c msg.c plugin.c list.c allocate.c avl.c iid.c hna.c control.c schedule.c route.c cyassl/sha.c
+SRC_H= bmx.h msg.h plugin.h list.h allocate.h avl.h iid.h hna.h control.h schedule.h route.h cyassl/sha.h
+OBJS= $(SRC_C:.c=.o)
+
+#
+#
+
+
+PACKAGE_NAME= bmxd
+BINARY_NAME= bmxd
+
+
+
+SOURCE_VERSION_HEADER= bmx.h
+
+
+BAT_VERSION= $(shell grep "^\#define SOURCE_VERSION " $(SOURCE_VERSION_HEADER) | sed -e '1p' -n | awk -F '"' '{print $$2}' | awk '{print $$1}')
+FILE_NAME= $(PACKAGE_NAME)_$(BAT_VERSION)-rv$(REVISION_VERSION)_$@
+
+NOW= $(shell date +%Y%m%d%H%M)-$(REVISION_VERSION)
+
+IPKG_DEPENDS= "kmod-tun"
+
+SNAPSHOT_DIR= ../bmx-snapshots
+
+
+all:
+ $(MAKE) $(BINARY_NAME)
+ # further make targets: help, libs, build_all, strip[_libs|_all], install[_libs|_all], clean[_libs|_all]
+
+libs: all
+ $(MAKE) -C lib all CORE_CFLAGS='$(CFLAGS)'
+
+
+
+$(BINARY_NAME): $(OBJS) Makefile
+ $(CC) $(OBJS) -o $@ $(LDFLAGS) $(EXTRA_LDFLAGS)
+
+%.o: %.c %.h Makefile $(SRC_H)
+ $(CC) $(CFLAGS) $(EXTRA_CFLAGS) -c $< -o $@
+
+%.o: %.c Makefile $(SRC_H)
+ $(CC) $(CFLAGS) $(EXTRA_CFLAGS) -c $< -o $@
+
+
+strip: all
+ strip $(BINARY_NAME)
+
+strip_libs: all libs
+ $(MAKE) -C lib strip
+
+
+
+
+install: all
+ mkdir -p $(SBINDIR)
+ install -m 0755 $(BINARY_NAME) $(SBINDIR)
+
+install_libs: all
+ $(MAKE) -C lib install CORE_CFLAGS='$(CFLAGS)'
+
+
+
+clean:
+ rm -f $(BINARY_NAME) *.o posix/*.o linux/*.o cyassl/*.o
+
+clean_libs:
+ $(MAKE) -C lib clean
+
+
+clean_all: clean clean_libs
+build_all: all libs
+strip_all: strip strip_libs
+install_all: install install_libs
+
+
+help:
+ # further make targets:
+ # help show this help
+ # all compile bmxd core only
+ # libs compile bmx plugins
+ # build_all compile bmxd and plugins
+ # strip / strip_libs / strip_all strip bmxd / plugins / all
+ # install / install_libs / install_all install bmxd / plugins / all
+ # clean / clean_libs / clean_all clean bmxd / libs / all
+
Added: trunk/bmx/allocate.c
===================================================================
--- trunk/bmx/allocate.c (rev 0)
+++ trunk/bmx/allocate.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,401 @@
+/*
+ * Copyright (C) 2006 B.A.T.M.A.N. contributors:
+ * Thomas Lopatic, Corinna 'Elektra' Aichele, Axel Neumann, Marek Lindner
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+
+#include "bmx.h"
+
+
+#define MAGIC_NUMBER 0x12345678
+
+#if defined DEBUG_MALLOC
+
+
+struct chunkHeader *chunkList = NULL;
+
+struct chunkHeader
+{
+ struct chunkHeader *next;
+ uint32_t length;
+ int32_t tag;
+ uint32_t magicNumber;
+};
+
+struct chunkTrailer
+{
+ uint32_t magicNumber;
+};
+
+
+
+#if defined MEMORY_USAGE
+
+struct memoryUsage *memoryList = NULL;
+
+
+struct memoryUsage
+{
+ struct memoryUsage *next;
+ uint32_t length;
+ uint32_t counter;
+ int32_t tag;
+};
+
+
+void addMemory( uint32_t length, int32_t tag ) {
+
+ struct memoryUsage *walker;
+
+ for ( walker = memoryList; walker != NULL; walker = walker->next ) {
+
+ if ( walker->tag == tag ) {
+
+ walker->counter++;
+ break;
+ }
+ }
+
+ if ( walker == NULL ) {
+
+ walker = malloc( sizeof(struct memoryUsage) );
+
+ walker->length = length;
+ walker->tag = tag;
+ walker->counter = 1;
+
+ walker->next = memoryList;
+ memoryList = walker;
+ }
+
+}
+
+
+void removeMemory( int32_t tag, int32_t freetag ) {
+
+ struct memoryUsage *walker;
+
+ for ( walker = memoryList; walker != NULL; walker = walker->next ) {
+
+ if ( walker->tag == tag ) {
+
+ if ( walker->counter == 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "Freeing more memory than was allocated: malloc tag = %d, free tag = %d",
+ tag, freetag );
+ cleanup_all( -500069 );
+
+ }
+
+ walker->counter--;
+ break;
+
+ }
+
+ }
+
+ if ( walker == NULL ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "Freeing memory that was never allocated: malloc tag = %d, free tag = %d",
+ tag, freetag );
+ cleanup_all( -500070 );
+ }
+}
+
+#endif
+
+#if defined MEMORY_USAGE
+
+void debugMemory( struct ctrl_node *cn ) {
+
+ struct memoryUsage *memoryWalker;
+
+ dbg_printf( cn, "\nMemory usage information:\n" );
+
+ for ( memoryWalker = memoryList; memoryWalker != NULL; memoryWalker = memoryWalker->next ) {
+
+ if ( memoryWalker->counter != 0 )
+ dbg_printf( cn, " tag: %4i, num malloc: %4i, bytes per malloc: %4i, total: %6i\n",
+ memoryWalker->tag, memoryWalker->counter, memoryWalker->length,
+ memoryWalker->counter * memoryWalker->length );
+
+ }
+ dbg_printf( cn, "\n" );
+
+}
+
+#endif
+
+
+void checkIntegrity(void)
+{
+ struct chunkHeader *walker;
+ struct chunkTrailer *chunkTrailer;
+ unsigned char *memory;
+
+// dbgf_all(DBGT_INFO, " ");
+
+ for (walker = chunkList; walker != NULL; walker = walker->next)
+ {
+ if (walker->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in header: %08x, malloc tag = %d",
+ walker->magicNumber, walker->tag );
+ cleanup_all( -500073 );
+ }
+
+ memory = (unsigned char *)walker;
+
+ chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + walker->length);
+
+ if (chunkTrailer->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in trailer: %08x, malloc tag = %d",
+ chunkTrailer->magicNumber, walker->tag );
+ cleanup_all( -500075 );
+ }
+ }
+
+}
+
+void checkLeak(void)
+{
+ struct chunkHeader *walker;
+
+ if ( chunkList != NULL ) {
+
+ openlog( "bmx", LOG_PID, LOG_DAEMON );
+
+
+ for (walker = chunkList; walker != NULL; walker = walker->next) {
+ syslog( LOG_ERR, "Memory leak detected, malloc tag = %d\n", walker->tag );
+
+ fprintf( stderr, "Memory leak detected, malloc tag = %d \n", walker->tag );
+
+ }
+
+ closelog();
+ }
+
+}
+
+void *_debugMalloc(uint32_t length, int32_t tag) {
+
+ unsigned char *memory;
+ struct chunkHeader *chunkHeader;
+ struct chunkTrailer *chunkTrailer;
+ unsigned char *chunk;
+
+ memory = malloc(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer));
+
+ if (memory == NULL)
+ {
+ dbg( DBGL_SYS, DBGT_ERR, "Cannot allocate %u bytes, malloc tag = %d",
+ (unsigned int)(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer)), tag );
+ cleanup_all( -500076 );
+ }
+
+ chunkHeader = (struct chunkHeader *)memory;
+ chunk = memory + sizeof(struct chunkHeader);
+ chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + length);
+
+ chunkHeader->length = length;
+ chunkHeader->tag = tag;
+ chunkHeader->magicNumber = MAGIC_NUMBER;
+
+ chunkTrailer->magicNumber = MAGIC_NUMBER;
+
+ chunkHeader->next = chunkList;
+ chunkList = chunkHeader;
+
+#if defined MEMORY_USAGE
+
+ addMemory( length, tag );
+
+#endif
+
+ return chunk;
+}
+
+void *_debugRealloc(void *memoryParameter, uint32_t length, int32_t tag) {
+
+ unsigned char *memory;
+ struct chunkHeader *chunkHeader=NULL;
+ struct chunkTrailer *chunkTrailer;
+ unsigned char *result;
+ uint32_t copyLength;
+
+ if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */
+ memory = memoryParameter;
+ chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));
+
+ if (chunkHeader->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in header: %08x, malloc tag = %d",
+ chunkHeader->magicNumber, chunkHeader->tag );
+ cleanup_all( -500078 );
+ }
+
+ chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);
+
+ if (chunkTrailer->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in trailer: %08x, malloc tag = %d",
+ chunkTrailer->magicNumber, chunkHeader->tag );
+ cleanup_all( -500079 );
+ }
+ }
+
+
+ result = _debugMalloc(length, tag);
+ if (memoryParameter) {
+ copyLength = length;
+
+ if (copyLength > chunkHeader->length)
+ copyLength = chunkHeader->length;
+
+ memcpy(result, memoryParameter, copyLength);
+ debugFree(memoryParameter, -300000);
+ }
+
+ return result;
+}
+
+void _debugFree(void *memoryParameter, int tag) {
+
+ unsigned char *memory;
+ struct chunkHeader *chunkHeader;
+ struct chunkTrailer *chunkTrailer;
+ struct chunkHeader *walker;
+ struct chunkHeader *previous;
+
+ memory = memoryParameter;
+ chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));
+
+ if (chunkHeader->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in header: %08x, malloc tag = %d, free tag = %d",
+ chunkHeader->magicNumber, chunkHeader->tag, tag );
+ cleanup_all( -500080 );
+ }
+
+ previous = NULL;
+
+ for (walker = chunkList; walker != NULL; walker = walker->next)
+ {
+ if (walker == chunkHeader)
+ break;
+
+ previous = walker;
+ }
+
+ if (walker == NULL)
+ {
+ dbg( DBGL_SYS, DBGT_ERR, "Double free detected, malloc tag = %d, free tag = %d",
+ chunkHeader->tag, tag );
+ cleanup_all( -500081 );
+ }
+
+ if (previous == NULL)
+ chunkList = walker->next;
+
+ else
+ previous->next = walker->next;
+
+
+ chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);
+
+ if (chunkTrailer->magicNumber != MAGIC_NUMBER)
+ {
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "invalid magic number in trailer: %08x, malloc tag = %d, free tag = %d",
+ chunkTrailer->magicNumber, chunkHeader->tag, tag );
+ cleanup_all( -500082 );
+ }
+
+#if defined MEMORY_USAGE
+
+ removeMemory( chunkHeader->tag, tag );
+
+#endif
+
+ free(chunkHeader);
+
+
+}
+
+#else
+
+void checkIntegrity(void)
+{
+}
+
+void checkLeak(void)
+{
+}
+
+void debugMemory( struct ctrl_node *cn )
+{
+}
+
+void *_debugMalloc(uint32_t length, int32_t tag)
+{
+ void *result;
+
+ result = malloc(length);
+
+ if (result == NULL)
+ {
+ dbg( DBGL_SYS, DBGT_ERR, "Cannot allocate %u bytes, malloc tag = %d", length, tag );
+ cleanup_all( -500072 );
+ }
+
+ return result;
+}
+
+void *_debugRealloc(void *memory, uint32_t length, int32_t tag)
+{
+ void *result;
+
+ result = realloc(memory, length);
+
+ if (result == NULL) {
+ dbg( DBGL_SYS, DBGT_ERR, "Cannot re-allocate %u bytes, malloc tag = %d", length, tag );
+ cleanup_all( -500071 );
+ }
+
+ return result;
+}
+
+void _debugFree(void *memory, int32_t tag)
+{
+ free(memory);
+}
+
+#endif
Added: trunk/bmx/allocate.h
===================================================================
--- trunk/bmx/allocate.h (rev 0)
+++ trunk/bmx/allocate.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2006 B.A.T.M.A.N. contributors:
+ * Thomas Lopatic, Corinna 'Elektra' Aichele, Axel Neumann, Marek Lindner
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA
+ *
+ */
+
+
+#ifndef _ALLOCATE_H
+#define _ALLOCATE_H 1
+#include <stdint.h>
+
+
+// currently used memory tags: -300000 .. -300228
+#define debugMalloc( l,t ) _debugMalloc( (l), (t) )
+#define debugRealloc( m,l,t ) _debugRealloc( (m), (l), (t) )
+#define debugFree( m,t ) _debugFree( (m), (t) )
+void *_debugMalloc(uint32_t length, int32_t tag);
+void *_debugRealloc(void *memory, uint32_t length, int32_t tag);
+void _debugFree(void *memoryParameter, int32_t tag);
+
+void checkIntegrity(void);
+void checkLeak(void);
+void debugMemory( struct ctrl_node *cn );
+
+
+#endif
Added: trunk/bmx/avl.c
===================================================================
--- trunk/bmx/avl.c (rev 0)
+++ trunk/bmx/avl.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,684 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+/*
+ * avl code inspired by:
+ * http://eternallyconfuzzled.com/tuts/datastructures/jsw_tut_avl.aspx
+ * where Julienne Walker said (web page from 28. 2. 2010 12:55):
+ * ...Once again, all of the code in this tutorial is in the public domain.
+ * You can do whatever you want with it, but I assume no responsibility
+ * for any damages from improper use. ;-)
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+#include "bmx.h"
+
+#include "avl.h"
+
+
+struct avl_node *avl_find( struct avl_tree *tree, void *key )
+{
+ struct avl_node *an = tree->root;
+ int cmp;
+
+ // Search for a dead path or a matching entry
+// while ( an && ( cmp = memcmp( an->key, key, tree->key_size) ) )
+ while ( an && ( cmp = memcmp( AVL_NODE_KEY( tree, an ), key, tree->key_size) ) )
+ an = an->link[ cmp < 0 ];
+
+ return an;
+}
+
+void *avl_find_item(struct avl_tree *tree, void *key)
+{
+ struct avl_node *an;
+
+ return ((an = avl_find(tree, key)) ? an->item : NULL);
+
+}
+
+struct avl_node *avl_next(struct avl_tree *tree, void *key)
+{
+ struct avl_node *an = tree->root;
+ struct avl_node *best = NULL;
+ int cmp;
+
+ while (an) {
+
+ cmp = (memcmp(AVL_NODE_KEY(tree, an), key, tree->key_size) <= 0);
+
+ if (an->link[cmp]) {
+ best = cmp ? best : an;
+ an = an->link[cmp];
+ } else {
+ return cmp ? best : an;
+ }
+
+ }
+ return NULL;
+}
+
+void * avl_next_item( struct avl_tree *tree, void *key)
+{
+ struct avl_node *an = avl_next(tree, key);
+
+ return an ? an->item : NULL;
+}
+
+
+struct avl_node *avl_iterate(struct avl_tree *tree, struct avl_node *an )
+{
+
+ if ( !an || an->link[1] ) {
+
+ an = an ? an->link[1] : tree->root;
+
+ while ( an && an->link[0] )
+ an = an->link[0];
+
+ return an;
+ }
+
+ struct avl_node *prev = an;
+
+ while ((an = an->up)) {
+
+ if ( an->link[0] == prev )
+ return an;
+
+ prev = an;
+ }
+
+ return NULL;
+}
+
+void *avl_iterate_item(struct avl_tree *tree, struct avl_node **an )
+{
+
+ if ( !(*an) || (*an)->link[1] ) {
+
+ (*an) = (*an) ? (*an)->link[1] : tree->root;
+
+ while ( (*an) && (*an)->link[0] )
+ (*an) = (*an)->link[0];
+
+ return (*an) ? (*an)->item : NULL;
+ }
+
+ struct avl_node *prev = (*an);
+
+ while (((*an) = (*an)->up)) {
+
+ if ( (*an)->link[0] == prev)
+ return (*an)->item;
+
+ prev = (*an);
+ }
+
+ return NULL;
+}
+
+
+
+static struct avl_node *avl_create_node(void *node, int32_t tag)
+{
+ struct avl_node *an = debugMalloc(sizeof (struct avl_node), tag);
+
+ memset( an, 0, sizeof( struct avl_node) );
+ an->item = node;
+
+ return an;
+}
+
+static struct avl_node *avl_rotate_single(struct avl_node *root, int dir)
+{
+ struct avl_node *save;
+ int rlh, rrh, slh;
+
+ /* Rotate */
+ save = root->link[!dir];
+
+ root->link[!dir] = save->link[dir];
+
+ if (root->link[!dir])
+ root->link[!dir]->up = root;
+
+ save->link[dir] = root;
+
+ if ( root )
+ root->up = save;
+
+ /* Update balance factors */
+ rlh = avl_height(root->link[0]);
+ rrh = avl_height(root->link[1]);
+ slh = avl_height(save->link[!dir]);
+
+ root->balance = avl_max(rlh, rrh) + 1;
+ save->balance = avl_max(slh, root->balance) + 1;
+
+ return save;
+}
+
+static struct avl_node *avl_rotate_double(struct avl_node *root, int dir)
+{
+ root->link[!dir] = avl_rotate_single(root->link[!dir], !dir);
+
+ if (root->link[!dir])
+ root->link[!dir]->up = root;
+
+ return avl_rotate_single(root, dir);
+}
+
+
+void avl_insert(struct avl_tree *tree, void *node, int32_t tag) {
+
+ if (tree->root) {
+
+ struct avl_node *it = tree->root;
+ struct avl_node *up[AVL_MAX_HEIGHT];
+ int upd[AVL_MAX_HEIGHT], top = 0;
+ int done = 0;
+
+ /* Search for an empty link, save the path */
+ for (;;) {
+ /* Push direction and node onto stack */
+// upd[top] = memcmp(it->key, key, tree->key_size) <= 0;
+ upd[top] = memcmp(AVL_NODE_KEY(tree, it), AVL_ITEM_KEY(tree, node), tree->key_size) <= 0;
+
+ up[top++] = it;
+
+ if (it->link[upd[top - 1]] == NULL)
+ break;
+
+ it = it->link[upd[top - 1]];
+ }
+
+ /* Insert a new node at the bottom of the tree */
+ it->link[upd[top - 1]] = avl_create_node(node, tag);
+ it->link[upd[top - 1]]->up = it;
+
+ paranoia(-500178, (it->link[upd[top - 1]] == NULL));
+
+ /* Walk back up the search path */
+ while (--top >= 0 && !done) {
+
+ int lh, rh, max;
+
+ lh = avl_height(up[top]->link[upd[top]]);
+ rh = avl_height(up[top]->link[!upd[top]]);
+
+ /* Terminate or rebalance as necessary */
+ if (lh - rh == 0)
+ done = 1;
+ if (lh - rh >= 2) {
+ struct avl_node *a = up[top]->link[upd[top]]->link[upd[top]];
+ struct avl_node *b = up[top]->link[upd[top]]->link[!upd[top]];
+
+ if (avl_height(a) >= avl_height(b))
+ up[top] = avl_rotate_single(up[top], !upd[top]);
+ else
+ up[top] = avl_rotate_double(up[top], !upd[top]);
+
+ /* Fix parent */
+ if (top != 0) {
+ up[top - 1]->link[upd[top - 1]] = up[top];
+ up[top]->up = up[top - 1];
+ } else {
+ tree->root = up[0];
+ up[0]->up = NULL;
+
+ }
+
+ done = 1;
+ }
+
+ /* Update balance factors */
+ lh = avl_height(up[top]->link[upd[top]]);
+ rh = avl_height(up[top]->link[!upd[top]]);
+ max = avl_max(lh, rh);
+
+ up[top]->balance = max + 1;
+ }
+
+ } else {
+
+ tree->root = avl_create_node(node, tag);
+ }
+
+ tree->items++;
+
+ return;
+}
+
+
+
+void *avl_remove(struct avl_tree *tree, void *key, int32_t tag)
+{
+ struct avl_node *it = tree->root;
+ struct avl_node *up[AVL_MAX_HEIGHT];
+ int upd[AVL_MAX_HEIGHT], top = 0, cmp;
+
+ if (!it)
+ return NULL;
+
+// while ((cmp = memcmp(it->key, key, tree->key_size)) ) {
+ while ((cmp = memcmp(AVL_NODE_KEY(tree, it), key, tree->key_size)) ||
+ (it->link[0] && !memcmp(AVL_NODE_KEY(tree, it->link[0]), key, tree->key_size))) {
+
+ // Push direction and node onto stack
+ upd[top] = (cmp < 0);
+ up[top] = it;
+ top++;
+
+ if (!(it = it->link[(cmp < 0)]))
+ return NULL;
+
+ }
+
+ // remember and return the found node. It might have been another one than intended
+ void *node = it->item;
+
+ // Remove the node:
+ if (!(it->link[0] && it->link[1])) { // at least one child is NULL:
+
+ // Which child is not null?
+ int dir = !(it->link[0]);
+
+ /* Fix parent */
+ if (top) {
+ up[top - 1]->link[upd[top - 1]] = it->link[dir];
+ if (it->link[dir])
+ it->link[dir]->up = up[top - 1];
+ } else {
+ tree->root = it->link[dir];
+ if (tree->root)
+ tree->root->up = NULL;
+ }
+ debugFree(it, tag);
+
+ } else { // both childs NOT NULL:
+
+ // Find the inorder successor
+ struct avl_node *heir = it->link[1];
+
+ // Save the path
+ upd[top] = 1;
+ up[top] = it;
+ top++;
+
+ while (heir->link[0]) {
+ upd[top] = 0;
+ up[top] = heir;
+ top++;
+ heir = heir->link[0];
+ }
+
+ // Swap data
+ it->item = heir->item;
+
+ // Unlink successor and fix parent
+ up[top - 1]->link[ (up[top - 1] == it) ] = heir->link[1];
+
+ if ( heir->link[1])
+ heir->link[1]->up = up[top - 1];
+
+ debugFree(heir, tag);
+ }
+
+ tree->items--;
+
+ // Walk back up the search path
+ while (--top >= 0) {
+ int lh = avl_height(up[top]->link[upd[top]]);
+ int rh = avl_height(up[top]->link[!upd[top]]);
+ int max = avl_max(lh, rh);
+
+ /* Update balance factors */
+ up[top]->balance = max + 1;
+
+
+ // Terminate or re-balance as necessary:
+ if (lh - rh >= 0) // re-balance upper path...
+ continue;
+
+ if (lh - rh == -1) // balance for upper path unchanged!
+ break;
+
+ if (!(up[top]) || !(up[top]->link[!upd[top]])) {
+ dbgf(DBGL_SYS, DBGT_ERR, "up(top) %p link %p lh %d rh %d",
+ (void*)(up[top]), (void*)((up[top]) ? (up[top]->link[!upd[top]]) : NULL), lh, rh);
+
+ paranoia(-500187, (!(up[top])));
+ paranoia(-500188, (!(up[top]->link[!upd[top]])));
+ }
+
+ // if (lh - rh <= -2): rebalance here and upper path
+
+ struct avl_node *a = up[top]->link[!upd[top]]->link[upd[top]];
+ struct avl_node *b = up[top]->link[!upd[top]]->link[!upd[top]];
+
+ if (avl_height(a) <= avl_height(b))
+ up[top] = avl_rotate_single(up[top], upd[top]);
+ else
+ up[top] = avl_rotate_double(up[top], upd[top]);
+
+ // Fix parent:
+ if (top) {
+ up[top - 1]->link[upd[top - 1]] = up[top];
+ up[top]->up = up[top - 1];
+ } else {
+ tree->root = up[0];
+ tree->root->up = NULL;
+ }
+ }
+
+ return node;
+
+}
+
+#ifdef AVL_DEBUG
+
+struct avl_node *_avl_iter_down(int dir, struct avl_node *an, struct avl_iterator *it ) {
+
+ for (; an; it->top++) {
+ /* Push direction and node onto stack */
+ it->up[it->top] = an;
+ it->upd[it->top] = dir;
+
+ an = an->link[dir];
+ }
+ it->top--;
+ return it->up[it->top];
+}
+
+struct avl_node *avl_iter(struct avl_tree *tree, struct avl_iterator *it ) {
+
+ struct avl_node *an = tree->root;
+ if ( !an )
+ return NULL;
+
+ if (!it->up[0]) {
+ // Get initial element and fill stack:
+ // go left...
+ it->top=0;
+ return _avl_iter_down( 0/*left*/, an, it );
+ }
+
+ if ((an = it->up[(it->top)]->link[1])) {
+ //go one right, then left...
+ it->upd[it->top] = 1;
+ it->top++;
+ return _avl_iter_down(0, an, it);
+ }
+
+ while (it->top > 0 && it->upd[(it->top) - 1] == 1 /*was: down right*/) {
+ //so go one back up (up-left = opposite of down right)
+ it->top--;
+ }
+
+ if (it->top > 0 && it->upd[(it->top) - 1] == 0 /*was: down left*/) {
+ //so go one back up (up-right = opposite of down left)):
+ it->top--;
+ return it->up[it->top];
+ }
+
+ it->up[0] = NULL;
+ return NULL;
+}
+
+void avl_debug( struct avl_tree *tree ) {
+
+ #define AVL_DBG_COL_CHARS 6
+
+ int i,j;
+
+ int depth_min = 0;
+
+ struct avl_node *an;
+ for (an = tree->root; an; an = an->link[0])
+ depth_min++;
+
+ int depth_max = depth_min+2;
+ int width = 1<<depth_max;
+
+ char * dbg_mem = malloc( depth_max * width * AVL_DBG_COL_CHARS + 1);
+ memset( dbg_mem, ' ', depth_max * width * AVL_DBG_COL_CHARS + 1 );
+
+ for( i=1; i<=depth_max; i++ )
+ dbg_mem[(i*width*AVL_DBG_COL_CHARS)-1] = '\n';
+
+ dbg_mem[ depth_max * width * AVL_DBG_COL_CHARS ] = 0;
+
+ struct avl_iterator it;
+ memset ( &it, 0, sizeof( struct avl_iterator ) );
+
+ while( (an = avl_iter( tree, &it )) ) {
+
+ j = (width - 1) * AVL_DBG_COL_CHARS / 2;
+
+ for (i = 0; i < it.top; i++) {
+
+ int k = ((width - 1) * AVL_DBG_COL_CHARS );
+ int l = 4<<i;
+ int m = ( it.upd[i]?1:-1);
+
+ j = j + (m * k / l);
+ }
+
+// dbg_mem[((i * width * AVL_DBG_COL_CHARS) + j)] = 'x';
+
+ snprintf(&dbg_mem[((i * width * AVL_DBG_COL_CHARS) + j)], AVL_DBG_COL_CHARS,
+ "%3d/%1d", ((int*) AVL_NODE_KEY(tree, an))[0], ((int*) AVL_NODE_KEY(tree, an))[1]);
+
+ dbg_mem[((i * width * AVL_DBG_COL_CHARS) + j + (AVL_DBG_COL_CHARS-1))] = ' ';
+
+
+ printf("%3d/%1d ", ((int*) AVL_NODE_KEY(tree, an))[0], ((int*) AVL_NODE_KEY(tree, an))[1]);
+ }
+
+
+ dbg_mem[ depth_max * width * AVL_DBG_COL_CHARS ] = 0;
+
+ printf("\n-----\n%s\n-----\n", dbg_mem );
+
+}
+#endif
+
+#ifdef AVL_TEST
+
+void avl_test( int max ) {
+
+#define AVL_TEST_MAX max
+
+ struct test_type {
+ int32_t test_key;
+ int32_t v;
+ uint8_t k;
+ int32_t test_key2;
+ int32_t w;
+ };
+
+ struct avl_node *an = NULL;
+ AVL_TREE(test_tree, struct test_type, test_key );
+ AVL_TREE(test_tree2, struct test_type, test_key2 );
+
+ int32_t i, j;
+
+ struct test_type * t;
+
+
+
+ // insert something:
+
+ for (i = 0; i <= AVL_TEST_MAX; i++) {
+ t = debugMalloc(sizeof ( struct test_type), -300004);
+ t->test_key = i;
+ t->test_key2 = AVL_TEST_MAX-i;
+ t->v = t->w = 0;
+ avl_insert(&test_tree, t);
+ avl_insert(&test_tree2, t);
+ printf(" inserted %d/%d %d/%d\n", t->test_key, t->v, t->test_key2, t->w );
+ }
+
+/*
+ // remove something:
+
+ for (i = AVL_TEST_MAX/2; i >= 0; i--) {
+
+ t = avl_remove(&test_tree, &i);
+
+ if ( t != avl_remove(&test_tree2, &t->test_key2) )
+ printf("ERROR...\n");
+
+ printf(" removed %d/%d %d/%d\n", t->test_key, t->v, t->test_key2, t->w );
+ debugFree( t, -300038 );
+ }
+*/
+
+
+
+
+ // debug test_tree:
+
+ printf("\navl_iterate( test_tree ):\n");
+ i=0;
+ an = NULL;
+ while( (an = avl_iterate( &test_tree, an ) ) ) {
+ t = ((struct test_type*)(an->item));
+ if ( i > t->test_key)
+ printf("\nERROR %d > %d \n", i, t->test_key);
+ i = t->test_key;
+ printf( "%3d/%1d ", t->test_key, t->v );
+ }
+
+ printf("\navl_next():\n");
+ i = 0; j = 0;
+ while( (an = avl_next( &test_tree, &j )) ) {
+ t = ((struct test_type*)(an->item));
+ j = t->test_key;
+ if ( i > t->test_key)
+ printf("\nERROR %d > %d \n", i, t->test_key);
+
+ i = t->test_key;
+
+ printf( "N%4d/%1d ", t->test_key, t->v );
+
+ if ( i%10 == 0 )
+ printf("\n");
+
+ }
+
+#ifdef AVL_DEBUG
+ printf("\navl_debug():\n");
+ avl_debug( &test_tree );
+#endif
+
+ printf("\n");
+
+
+
+
+ // debug test_tree2:
+
+ printf("\navl_iterate( test_tree2 ):\n");
+ i=0;
+ an = NULL;
+ while( (an = avl_iterate( &test_tree2, an ) ) ) {
+ t = ((struct test_type*)(an->item));
+ if ( i > t->test_key2)
+ printf("\nERROR %d > %d \n", i, t->test_key2);
+ i = t->test_key2;
+ printf( "%3d/%1d ", t->test_key2, t->w );
+ }
+
+ printf("\navl_next( test_tree2):\n");
+ i = 0; j = 0;
+ while( (an = avl_next( &test_tree2, &j )) ) {
+ t = ((struct test_type*)(an->item));
+ j = t->test_key2;
+ if ( i > t->test_key2)
+ printf("\nERROR %d > %d \n", i, t->test_key2);
+
+ i = t->test_key2;
+
+ printf( "N%4d/%1d ", t->test_key2, t->w );
+
+ if ( i%10 == 0 )
+ printf("\n");
+
+ }
+
+#ifdef AVL_DEBUG
+ printf("\navl_debug():\n");
+ avl_debug( &test_tree2 );
+#endif
+
+ printf("\n");
+
+
+ // remove whats left:
+
+ while( test_tree.root ) {
+ t = (struct test_type*)test_tree.root->item;
+ avl_remove(&test_tree, &t->test_key, -300190);
+ avl_remove(&test_tree2, &t->test_key2, -300191);
+ printf(" removed %d/%d %d/%d\n", t->test_key, t->v, t->test_key2, t->w );
+ debugFree( t, -300042 );
+ }
+
+ printf("\n");
+ cleanup_all(CLEANUP_SUCCESS);
+}
+
+
+static int32_t tree_max = 5;
+static int32_t opt_tree ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY )
+ avl_test(tree_max);
+
+ return SUCCESS;
+}
+
+static struct opt_type msg_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ {ODI,0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\navl tree debuggin options:"}
+,
+ {ODI,0,"tree", 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &tree_max, 0, 20, 1, opt_tree,
+ ARG_VALUE_FORM, "show tree with given number of elements"}
+
+};
+
+
+
+#endif
+
+void init_avl( void )
+{
+#ifdef AVL_TEST
+ register_options_array( msg_options, sizeof( msg_options ) );
+#endif
+}
Added: trunk/bmx/avl.h
===================================================================
--- trunk/bmx/avl.h (rev 0)
+++ trunk/bmx/avl.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+/*
+ * avl code inspired by:
+ * http://eternallyconfuzzled.com/tuts/datastructures/jsw_tut_avl.aspx
+ * where Julienne Walker said (web page from 28. 2. 2010 12:55):
+ * ...Once again, all of the code in this tutorial is in the public domain.
+ * You can do whatever you want with it, but I assume no responsibility
+ * for any damages from improper use. ;-)
+ */
+
+#ifndef _AVL_H
+#define _AVL_H
+
+#include <stdint.h>
+
+
+#define AVL_MAX_HEIGHT 128
+
+
+struct avl_node {
+ void *item;
+ int balance;
+ struct avl_node * up;
+ struct avl_node * link[2];
+};
+
+// obtain key pointer based on avl_node pointer
+#define AVL_NODE_KEY( a_tree, a_node ) ( (void*) ( ((char*)(a_node)->item)+((a_tree)->key_offset) ) )
+
+// obtain key pointer based on item pointer
+#define AVL_ITEM_KEY( a_tree, a_item ) ( (void*) ( ((char*)(a_item))+((a_tree)->key_offset) ) )
+
+struct avl_tree {
+ struct avl_node *root;
+ uint16_t key_size;
+ uint16_t key_offset;
+ uint32_t items;
+};
+
+
+#define AVL_INIT_TREE(tree, element_type, key_field) do { \
+ tree.root = NULL; \
+ tree.key_size = sizeof( (((element_type *) 0)->key_field) ); \
+ tree.key_offset = ((unsigned long) (&((element_type *) 0)->key_field)); \
+ tree.items = 0; \
+ } while (0)
+
+#define AVL_TREE(tree, element_type, key_field) struct avl_tree (tree) = { \
+ NULL, \
+ (sizeof( (((element_type *) 0)->key_field) )), \
+ ((unsigned long)(&((element_type *)0)->key_field)), \
+ 0 }
+
+#define avl_height(p) ((p) == NULL ? -1 : (p)->balance)
+#define avl_max(a,b) ((a) > (b) ? (a) : (b))
+
+
+struct avl_node *avl_find( struct avl_tree *tree, void *key );
+void *avl_find_item( struct avl_tree *tree, void *key );
+struct avl_node *avl_next( struct avl_tree *tree, void *key );
+void *avl_next_item(struct avl_tree *tree, void *key);
+struct avl_node *avl_iterate(struct avl_tree *tree, struct avl_node *it );
+void *avl_iterate_item(struct avl_tree *tree, struct avl_node **it );
+
+void avl_insert(struct avl_tree *tree, void *node, int32_t tag);
+void *avl_remove(struct avl_tree *tree, void *key, int32_t tag);
+
+void init_avl(void);
+
+#ifdef AVL_DEBUG
+struct avl_iterator {
+ struct avl_node * up[AVL_MAX_HEIGHT];
+ int upd[AVL_MAX_HEIGHT];
+ int top;
+};
+
+struct avl_node *avl_iter(struct avl_tree *tree, struct avl_iterator *it );
+void avl_debug( struct avl_tree *tree );
+void avl_test(int m);
+#endif
+
+
+#endif
Added: trunk/bmx/bmx.c
===================================================================
--- trunk/bmx/bmx.c (rev 0)
+++ trunk/bmx/bmx.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,2279 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+#define _GNU_SOURCE
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/if.h> /* ifr_if, ifr_tun */
+#include <linux/rtnetlink.h>
+#include <time.h>
+
+#include "bmx.h"
+#include "msg.h"
+#include "hna.h"
+#include "plugin.h"
+#include "schedule.h"
+#include "route.h"
+
+#define DEF_HELLO_IVAL 500
+#define MIN_HELLO_IVAL 10
+#define MAX_HELLO_IVAL 10000
+#define ARG_HELLO_IVAL "hello_interval"
+
+
+
+int32_t my_pws = DEF_PWS;
+
+int32_t local_lws = DEF_LWS;
+
+int32_t local_rtq_lounge = DEF_RTQ_LOUNGE;
+
+int32_t my_path_lounge = DEF_PATH_LOUNGE;
+
+int32_t dad_to = DEF_DAD_TO;
+
+int32_t my_ttl = DEF_TTL;
+
+int32_t wl_clones = DEF_WL_CLONES;
+
+int32_t my_path_hystere = DEF_PATH_HYST;
+
+int32_t my_rcnt_hystere = DEF_RCNT_HYST;
+
+int32_t my_rcnt_pws = DEF_RCNT_PWS;
+
+int32_t my_rcnt_fk = DEF_RCNT_FK;
+
+int32_t my_late_penalty = DEF_LATE_PENAL;
+
+static int32_t drop_2hop_loop = DEF_DROP_2HLOOP;
+
+
+static int32_t Asocial_device = DEF_ASOCIAL;
+
+
+int32_t asym_weight = DEF_ASYM_WEIGHT;
+int32_t sym_weight = DEF_SYM_WEIGHT;
+
+static int32_t asym_exp = DEF_ASYM_EXP;
+
+int32_t my_hop_penalty = DEF_HOP_PENALTY;
+
+
+static int32_t ogi_pwrsave = MIN_OGM_INTERVAL;
+
+
+static int32_t purge_to = DEF_PURGE_TO;
+
+
+void* FAILURE_POINTER = &FAILURE_POINTER;
+
+static int8_t stop = 0;
+
+static struct timeval start_time_tv;
+static struct timeval ret_tv, new_tv, diff_tv, acceptable_m_tv, acceptable_p_tv, max_tv = {0,(2000*MAX_SELECT_TIMEOUT_MS)};
+
+
+uint32_t My_pid = 0;
+
+uint32_t bmx_time = 0;
+uint32_t bmx_time_sec = 0;
+
+uint8_t on_the_fly = NO;
+
+uint32_t s_curr_avg_cpu_load = 0;
+
+struct dev_node *primary_if = NULL;
+
+
+struct metric_algo link_metric_algo[SQR_RANGE];
+
+
+
+struct orig_node my_orig_node;
+
+
+AVL_TREE(dev_ip4_tree, struct dev_node, ip4_addr);
+AVL_TREE(dev_name_tree, struct dev_node, name);
+
+AVL_TREE(link_tree, struct link_node, llip4);
+AVL_TREE(blacklisted_tree, struct black_node, dhash);
+
+AVL_TREE(link_dev_tree, struct link_dev_node, key);
+
+AVL_TREE(neigh_tree, struct neigh_node, nnkey);
+
+AVL_TREE(dhash_tree, struct dhash_node, dhash);
+AVL_TREE(dhash_invalid_tree, struct dhash_node, dhash);
+LIST_SIMPEL( dhash_invalid_plist, struct plist_node, list );
+
+AVL_TREE(orig_tree, struct orig_node, id);
+AVL_TREE(blocked_tree, struct orig_node, id);
+
+
+/*
+STATIC_FUNC
+void purge_neigh_node( struct link_node *ln, struct dhash_node *dhn );
+*/
+
+/***********************************************************
+ Data Infrastructure
+ ************************************************************/
+
+
+
+void blacklist_neighbor(struct packet_buff *pb)
+{
+
+ dbgf(DBGL_SYS, DBGT_ERR, "%s via %s", pb->neigh_str, pb->iif->name);
+}
+
+
+IDM_T blacklisted_neighbor(struct packet_buff *pb, struct description_hash *dhash)
+{
+
+ dbgf(DBGL_ALL, DBGT_INFO, "%s via %s", pb->neigh_str, pb->iif->name);
+ return NO;
+}
+
+
+IDM_T validate_metric_algo(struct metric_algo *ma, struct ctrl_node *cn)
+{
+
+ if (ma->sqn_window <= ma->sqn_steps) {
+
+ dbg_cn(cn, DBGL_SYS, DBGT_ERR, "SQN: window=%d MUST be greater than steps=%d",
+ ma->sqn_window, ma->sqn_steps);
+
+ } else if (ma->sqn_window <= ma->sqn_lounge) {
+
+ dbg_cn(cn, DBGL_SYS, DBGT_ERR, "SQN: window=%d MUST BE greater than lounge=%d",
+ ma->sqn_window, ma->sqn_lounge);
+
+ } else if (ma->sqn_window % ma->sqn_steps) {
+
+ dbg_cn(cn, DBGL_SYS, DBGT_ERR, "SQN: window=%d MUST BE multiple of steps=%d",
+ ma->sqn_window, ma->sqn_steps);
+
+ } else if (ma->sqn_lounge % ma->sqn_steps) {
+
+ dbg_cn(cn, DBGL_SYS, DBGT_ERR, "SQN: lounge=%d MUST BE multiple of steps=%d",
+ ma->sqn_lounge, ma->sqn_steps);
+ } else {
+
+ return SUCCESS;
+ }
+
+ return FAILURE;
+}
+
+
+uint32_t update_metric(struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe)
+{
+
+ dbgf(DBGL_ALL, DBGT_INFO,
+ "sqn_in %d sqn_max %d probe %u "
+ "metric_algo: mask 0x%X steps %d window %d lounge %d metric_record: clr %d, set %d val %u",
+ sqn_in, sqn_max, probe,
+ ma->sqn_mask, ma->sqn_steps, ma->sqn_window, ma->sqn_lounge, mr->clr, mr->set, mr->val);
+
+
+ ASSERTION(-500491, (ma->sqn_mask == (SQN_T) (0XFFFF << (bits_count(((SQN_T) ~(ma->sqn_mask)))))));
+ ASSERTION(-500492, (ma->sqn_steps == (SQN_T) (0X0001 << (bits_count(((SQN_T) ~(ma->sqn_mask)))))));
+ assertion(-500493, (ma->sqn_window > ma->sqn_steps));
+ assertion(-500494, (ma->sqn_window > ma->sqn_lounge));
+ assertion(-500495, (!(ma->sqn_window & ((SQN_T)~(ma->sqn_mask)))));
+ assertion(-500496, (!(ma->sqn_lounge & ((SQN_T)~(ma->sqn_mask)))));
+ assertion(-500497, (!(mr->clr & ((SQN_T) ~(ma->sqn_mask)))));
+
+// assertion(-500498, (probe >= ma->sqn_window * ma->sqn_steps)); // may cause zero metric (which is ok)
+// assertion(-500499, (!(probe % (ma->sqn_window * ma->sqn_steps)))); // may cause slightly unfair metric
+ assertion( -500500, (probe <= ma->metric_max));
+
+ sqn_max &= ma->sqn_mask;
+ SQN_T sqn_min = sqn_max - ma->sqn_lounge;
+ SQN_T sqn_low_boundary = sqn_min + ma->sqn_steps - ma->sqn_window;
+ SQN_T i;
+
+
+ // first purge out-of-lounge positioned records:
+
+ if (((SQN_T) (mr->clr - sqn_low_boundary)) < (ma->sqn_window - ma->sqn_steps)) {
+ // mr->clr within A:
+ SQN_T sqn_purge = sqn_min - mr->clr;
+ SQN_T metric_purge = sqn_purge / ma->sqn_steps;
+ mr->clr = sqn_min;
+
+ assertion(-500500, (((SQN_T) (metric_purge - 1)) < ((ma->sqn_window / ma->sqn_steps) - 1)));
+
+ for (i = 0; i < metric_purge; i++)
+ mr->val -= (mr->val / ma->regression);
+
+
+ } else if (((SQN_T) (mr->clr - sqn_min)) <= ma->sqn_lounge) {
+
+ // mr->clr within B: FINE!
+
+ } else {
+
+ // mr->clr out of any range:
+ if ( mr->clr ) {
+ dbgf(DBGL_SYS, DBGT_ERR,
+ "sqn_in %d sqn_max %d probe %u "
+ "metric_algo: mask 0x%X steps %d window %d lounge %d metric_record: clr %d, set %d val %u",
+ sqn_in, sqn_max, probe,
+ ma->sqn_mask, ma->sqn_steps, ma->sqn_window, ma->sqn_lounge, mr->clr, mr->set, mr->val);
+ }
+
+ mr->clr = sqn_min;
+ mr->val = 0;
+ }
+
+
+ if (!probe)
+ return mr->val;
+
+ // then update the metric:
+
+ if (((SQN_T) (sqn_in - sqn_min)) < (ma->sqn_lounge + ma->sqn_steps)) {
+
+ // sqn_in within B:
+
+// if (((SQN_T) ((mr->set) - sqn_min)) >= (ma->sqn_lounge + ma->sqn_steps)) {
+ if (((SQN_T) ((mr->set & ma->sqn_mask) - sqn_min)) >= (ma->sqn_lounge + ma->sqn_steps)) {
+
+ // mr->set out of B (fix maybe illegal mr->set): then set to mr->clr - sqn_steps
+ mr->set = sqn_min - ma->sqn_steps;
+ }
+
+
+ if ((((sqn_in & ma->sqn_mask) == (mr->set & ma->sqn_mask)))) {
+
+ // sqn_in already set !
+
+ } else if (((SQN_T) ((sqn_in & ma->sqn_mask)-(mr->set & ma->sqn_mask))) <= ma->sqn_lounge + ma->sqn_steps) {
+
+ // sqn_in > mr->set:
+
+ SQN_T sqn_purge = ((sqn_in & ma->sqn_mask)-(mr->clr & ma->sqn_mask));
+ SQN_T metric_purge = sqn_purge / ma->sqn_steps;
+
+ for (i = 0; i < metric_purge; i++)
+ mr->val -= (mr->val / ma->regression);
+
+ mr->val += (((((SQN_T) (sqn_in & ~(ma->sqn_mask))) + 1) * (probe / ma->regression)) / ma->sqn_steps);
+
+ mr->set = mr->clr = sqn_in & ma->sqn_mask;
+
+ uint64_t add = ((((SQN_T) (sqn_in & ~(ma->sqn_mask))) * probe) + (rand_num(probe - 1))) / ma->metric_max;
+
+ assertion(-500501, (add <= ((SQN_T) (sqn_in & ~(ma->sqn_mask)))));
+
+ mr->set += add;
+
+
+ } else {
+
+ dbgf(DBGL_CHANGES, DBGT_WARN,
+ "sqn_in %d sqn_max %d probe %u "
+ "metric_algo: mask 0x%X steps %d window %d lounge %d metric_record: clr %d, set %d val %u",
+ sqn_in, sqn_max, probe,
+ ma->sqn_mask, ma->sqn_steps, ma->sqn_window, ma->sqn_lounge, mr->clr, mr->set, mr->val);
+ // impossible ?? assertion(-500502, (0));
+ }
+ }
+
+ assertion(-500503, (mr->val <= ma->metric_max));
+ return mr->val;
+}
+
+
+
+
+
+STATIC_FUNC
+void assign_best_rtq_link(struct neigh_node *nn)
+{
+ struct list_node *lndev_pos;
+ struct link_dev_node *lndev_best = NULL;
+ struct link_node *ln;
+ struct avl_node *an = NULL;
+
+ assertion( -500451, (nn));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s", nn->dhn->on->id.name);
+
+ while ((ln = avl_iterate_item(&nn->link_tree, &an))) {
+
+ list_for_each(lndev_pos, &ln->lndev_list)
+ {
+ struct link_dev_node *lndev = list_entry(lndev_pos, struct link_dev_node, list);
+
+ if (!lndev_best ||
+ lndev->mr[SQR_RTQ].val > lndev_best->mr[SQR_RTQ].val ||
+ GREAT_U32(lndev->rtq_time_max, lndev_best->rtq_time_max)
+ )
+ lndev_best = lndev;
+
+ }
+
+ }
+ assertion( -500406, (lndev_best));
+
+ nn->best_rtq = lndev_best;
+
+}
+
+
+
+//BMX3 (done)
+STATIC_FUNC
+void free_neigh_node(struct neigh_node *nn)
+{
+ paranoia(-500321, (nn->link_tree.items));
+
+ dbgf(DBGL_SYS, DBGT_INFO," ");
+
+ avl_remove(&neigh_tree, &nn->nnkey, -300196);
+ iid_purge_repos(&nn->neighIID4x_repos);
+ debugFree(nn, -300129);
+}
+
+
+/*
+ * merging dhn->neigh into ln->neigh
+ * keeping ln->neigh and dhn
+ * purging ln->neigh->dhn and dhn->neigh
+ */
+//BMX3 (done)
+STATIC_FUNC
+struct neigh_node *merge_neigh_nodes(struct link_node *ln, struct dhash_node * dhn)
+{
+ struct neigh_node *neigh = ln->neigh;
+
+ dbgf(DBGL_SYS, DBGT_ERR, "Neigh restarted ?!! purging %s %jX, keeping %s %jX",
+ neigh->dhn->on->desc0->id.name, neigh->dhn->on->desc0->id.rand.u64[0],
+ dhn->on->desc0->id.name, dhn->on->desc0->id.rand.u64[0]);
+
+ if (dhn->neigh) {
+ struct neigh_node *del_neigh = dhn->neigh;
+
+ dbgf(DBGL_SYS, DBGT_ERR, "Merging neigh_nodes, purging %d neighIID4x entries ",
+ del_neigh->neighIID4x_repos.tot_used);
+
+ assertion(-500406, (del_neigh->link_tree.items));
+
+ struct avl_node *an;
+ while ((an = del_neigh->link_tree.root)) {
+
+ struct link_node * mv_ln = an->item;
+
+ ASSERTION(-500408, (!avl_find(&neigh->link_tree, &mv_ln->llip4)));
+ assertion(-500409, (mv_ln != ln));
+
+ avl_insert(&neigh->link_tree, mv_ln, -300140);
+ mv_ln->neigh = neigh;
+ avl_remove(&del_neigh->link_tree, &mv_ln->llip4, -300199);
+ }
+
+ free_neigh_node(del_neigh);
+ }
+
+ neigh->dhn->neigh = NULL;
+ invalidate_dhash_node(neigh->dhn);
+ neigh->dhn = dhn;
+ dhn->neigh = neigh;
+
+ return neigh;
+}
+
+
+//BMX3 (done)
+STATIC_FUNC
+struct neigh_node * create_neigh_node(struct link_node *ln, struct dhash_node * dhn)
+{
+ assertion( -500400, ( ln && !ln->neigh && dhn && !dhn->neigh ) );
+
+ struct neigh_node *nn = debugMalloc(sizeof ( struct neigh_node), -300131);
+
+ memset(nn, 0, sizeof ( struct neigh_node));
+
+ AVL_INIT_TREE(nn->link_tree, struct link_node, llip4);
+
+ avl_insert(&nn->link_tree, ln, -300172);
+
+ nn->dhn = dhn;
+
+ nn->nnkey = nn;
+ avl_insert(&neigh_tree, nn, -300141);
+
+ dhn->neigh = ln->neigh = nn;
+
+ return nn;
+}
+
+
+//BMX3 (done)
+IDM_T update_neigh_node(struct link_node *ln, struct dhash_node *dhn, IID_T neighIID4neigh)
+{
+ struct neigh_node *neigh = NULL;
+
+ dbgf( DBGL_SYS, DBGT_INFO, "neigh %s neighIID4neigh %d dhn->orig %s",
+ ln->llip4_str, neighIID4neigh, dhn->on->desc0->id.name);
+
+ assertion(-500389, (ln && neighIID4neigh > IID_RSVD_MAX));
+ assertion(-500390, (dhn && dhn->on));
+
+ if (ln->neigh) {
+
+ assertion(-500405, (ln->neigh->dhn && ln->neigh->dhn->on ));
+ assertion(-500391, (ln->neigh->dhn->neigh == ln->neigh));
+ ASSERTION(-500392, (avl_find(&ln->neigh->link_tree, &ln->llip4)));
+
+ if (ln->neigh == dhn->neigh) {
+
+ assertion(-500393, (ln->neigh->dhn == dhn));
+
+//always if new dhash: assertion(-500450, 0); //this never happen! or ?
+
+ neigh = ln->neigh;
+
+
+ } else {
+
+ neigh = merge_neigh_nodes( ln, dhn);
+
+ }
+
+ } else {
+
+ if ( dhn->neigh ) {
+
+ assertion(-500394, (dhn->neigh->dhn == dhn));
+ assertion(-500395, (dhn->neigh->link_tree.items));
+ ASSERTION(-500396, (!avl_find(&dhn->neigh->link_tree, &ln->llip4)));
+
+ neigh = ln->neigh = dhn->neigh;
+ avl_insert(&neigh->link_tree, ln, -300173);
+
+ } else {
+
+ neigh = create_neigh_node( ln, dhn );
+
+ }
+
+ }
+
+ assign_best_rtq_link(neigh);
+
+ return update_neighIID4x_repository(neigh, neighIID4neigh, neigh->dhn);
+}
+
+
+STATIC_FUNC
+struct link_dev_node *get_link_dev_node(struct link_node *ln, struct dev_node *dev)
+{
+ struct list_node *lndev_pos;
+ struct link_dev_node *lndev;
+
+ list_for_each( lndev_pos, &ln->lndev_list ) {
+
+ lndev = list_entry( lndev_pos, struct link_dev_node, list );
+
+ if ( lndev->key.dev == dev )
+ return lndev;
+ }
+
+ lndev = debugMalloc( sizeof( struct link_dev_node ), -300023 );
+
+ memset( lndev, 0, sizeof( struct link_dev_node ) );
+
+ lndev->key.dev = dev;
+ lndev->key.llip4 = ln->llip4;
+
+ dbgf( DBGL_CHANGES, DBGT_INFO, "creating new lndev %16s %10s %s",
+ ipStr(ln->llip4), dev->name, dev->ip4_str );
+
+ list_add_tail(&ln->lndev_list, &lndev->list);
+
+ ASSERTION( -500489, !avl_find( &link_dev_tree, &lndev->key));
+
+ avl_insert( &link_dev_tree, lndev, -300220 );
+
+ lndev->link = ln;
+
+ return lndev;
+}
+
+STATIC_FUNC
+struct link_node *get_link_node(uint32_t llip4)
+{
+
+ dbgf_all( DBGT_INFO, "%s", ipStr(llip4) );
+
+ paranoia(-500210, !llip4);
+
+ struct link_node *ln = avl_find_item(&link_tree, &llip4);
+
+ if (!ln) {
+
+ ln = debugMalloc(sizeof (struct link_node), -300024);
+ memset(ln, 0, sizeof (struct link_node));
+
+ LIST_INIT_HEAD(ln->lndev_list, struct link_dev_node, list);
+
+ ln->llip4 = llip4;
+
+ addr_to_str(llip4, ln->llip4_str);
+
+ avl_insert(&link_tree, ln, -300147);
+ }
+
+ return ln;
+}
+
+void update_link_node(struct link_node *ln, struct dev_node *iif, SQN_T sqn, SQN_T sqn_max, uint8_t sqr, uint32_t probe)
+{
+// uint8_t lounge_size = (sqr == SQR_RQ) ? RQ_LINK_LOUNGE : local_rtq_lounge;
+
+ struct list_node *lndev_pos;
+ struct link_dev_node *lndev, *this_lndev = NULL;
+
+ list_for_each(lndev_pos, &ln->lndev_list)
+ {
+ lndev = list_entry(lndev_pos, struct link_dev_node, list);
+
+ if (lndev->key.dev == iif) {
+
+ this_lndev = lndev;
+
+ } else {
+
+// update_lounged_metric(0, lounge_size, sqn, sqn_max, &lndev->sqr[sqr], local_lws);
+
+ update_metric(&lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, 0);
+
+ }
+
+ }
+
+ if (this_lndev) {
+
+// update_lounged_metric(probe, lounge_size, sqn, sqn_max, &this_lndev->sqr[sqr], local_lws);
+
+ update_metric(&this_lndev->mr[sqr], &link_metric_algo[sqr], sqn, sqn_max, probe);
+
+ if (probe && sqr == SQR_RTQ) {
+
+ this_lndev->rtq_time_max = bmx_time;
+
+ if (
+ ln->neigh &&
+ (!ln->neigh->best_rtq ||
+ ln->neigh->best_rtq->mr[SQR_RTQ].val <= this_lndev->mr[SQR_RTQ].val)) {
+
+ ln->neigh->best_rtq = this_lndev;
+ }
+ }
+ }
+
+ if (probe && sqr == SQR_RQ) {
+ ln->rq_time_max = bmx_time;
+ ln->rq_sqn_max = sqn;
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s dev %s",
+ ipStr(ln->llip4), this_lndev ? this_lndev->key.dev->name : "???");
+
+}
+
+
+
+STATIC_FUNC
+void purge_link_node(uint32_t only_llip4, struct dev_node *only_dev, IDM_T only_expired)
+{
+ struct avl_node *an;
+ struct link_node *ln;
+ uint32_t itip4 = 0;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s only_expired",
+ ipStr(only_llip4), only_dev ? only_dev->name : "---", only_expired ? " " : "not");
+
+ while ((an = (only_llip4 ? (avl_find(&link_tree, &only_llip4)) : (avl_next(&link_tree, &itip4)))) && (ln = an->item)) {
+
+ struct list_node *pos, *tmp, *prev = (struct list_node *) & ln->lndev_list;
+ struct neigh_node *nn = ln->neigh;
+ IDM_T removed_lndev = NO;
+
+ itip4 = ln->llip4;
+
+ list_for_each_safe(pos, tmp, &ln->lndev_list)
+ {
+ struct link_dev_node *lndev = list_entry(pos, struct link_dev_node, list);
+
+ if ((!only_dev || only_dev == lndev->key.dev) &&
+ (!only_expired || (((uint32_t) (bmx_time - lndev->pkt_time_max)) > (uint32_t) purge_to))) {
+
+ dbgf(DBGL_SYS, DBGT_INFO, "purging lndev %16s %10s %s",
+ ipStr(ln->llip4), lndev->key.dev->name, lndev->key.dev->ip4_str);
+
+ list_del_next(&ln->lndev_list, prev);
+ avl_remove(&link_dev_tree, &lndev->key, -300221);
+ debugFree(pos, -300044);
+ removed_lndev = YES;
+
+ } else {
+ prev = pos;
+ }
+ }
+
+ assertion(-500323, (only_dev || only_expired || ln->lndev_list.items==0));
+
+ if (!ln->lndev_list.items) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "purging: %s %s", ipStr(itip4), only_dev ? only_dev->name : "???");
+
+ if (nn) {
+
+ avl_remove(&nn->link_tree, &ln->llip4, -300198);
+
+ dbgf(DBGL_SYS, DBGT_INFO, "ln->neigh %s (%d more link_tree.items)",
+ ln->llip4_str, nn->link_tree.items);
+
+ if (!nn->link_tree.items) {
+
+ if (nn->dhn) {
+ dbgf(DBGL_SYS, DBGT_INFO, "setting ln->neigh->dhn (%s) = NULL",
+ nn->dhn->on->id.name);
+ nn->dhn->neigh = NULL;
+ }
+
+ free_neigh_node(nn);
+ nn = NULL;
+ }
+ }
+
+ avl_remove(&link_tree, &ln->llip4, -300193 );
+
+ debugFree( ln, -300045 );
+ }
+
+ if (nn && removed_lndev)
+ assign_best_rtq_link(nn);
+
+ if ( only_llip4 )
+ break;
+ }
+}
+
+struct dhash_node* create_dhash_node(struct description_hash *dhash, struct orig_node *on)
+{
+
+ struct dhash_node * dhn = debugMalloc(sizeof ( struct dhash_node), -300001);
+ memset(dhn, 0, sizeof ( struct dhash_node));
+ memcpy(&dhn->dhash, dhash, BMX_HASH0_LEN);
+ avl_insert(&dhash_tree, dhn, -300142);
+
+ dhn->myIID4orig = iid_new_myIID4x(dhn);
+
+ on->updated_timestamp = bmx_time;
+ dhn->on = on;
+ on->dhn = dhn;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X.. myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+
+ return dhn;
+}
+
+STATIC_FUNC
+void free_dhash_iid(struct dhash_node *dhn)
+{
+ struct avl_node *an;
+ struct neigh_node *nn;
+
+ iid_free(&my_iid_repos, dhn->myIID4orig);
+
+ //reset all neigh_node->oid_repos[x]=dhn->mid4o entries
+ for (an = NULL; (nn = avl_iterate_item(&neigh_tree, &an));) {
+
+ iid_free_neighIID4x_by_myIID4x(&nn->neighIID4x_repos, dhn->myIID4orig);
+
+ }
+
+ debugFree(dhn, -300112);
+
+}
+
+STATIC_FUNC
+ void purge_dhash_to_list( IDM_T purge_all ) {
+
+ struct dhash_node *dhn;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
+
+ while ((dhn = plist_get_first(&dhash_invalid_plist)) ) {
+
+ if (purge_all || ((uint32_t) (bmx_time - dhn->referred_timestamp) > MIN_DHASH_TO)) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+
+ plist_rem_head(&dhash_invalid_plist);
+ avl_remove(&dhash_invalid_tree, &dhn->dhash, -300194);
+
+ free_dhash_iid(dhn);
+
+ } else {
+ break;
+ }
+ }
+}
+
+STATIC_FUNC
+void unlink_dhash_node(struct dhash_node *dhn)
+{
+ dbgf(DBGL_CHANGES, DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+
+ if (dhn->neigh) {
+
+ struct avl_node *an;
+ struct link_node *ln;
+
+ while ((an = dhn->neigh->link_tree.root) && (ln = an->item)) {
+
+ dbgf(DBGL_SYS, DBGT_INFO, "dhn->neigh->link_tree item %s", ln->llip4_str);
+
+ assertion(-500284, (ln->neigh == dhn->neigh));
+
+ ln->neigh = NULL;
+
+ avl_remove(&dhn->neigh->link_tree, &ln->llip4, -300197);
+ }
+
+ free_neigh_node(dhn->neigh);
+
+ dhn->neigh = NULL;
+ }
+
+ if (dhn->on) {
+ dhn->on->dhn = NULL;
+ free_orig_node( dhn->on );
+ dhn->on = NULL;
+ }
+
+
+
+ avl_remove(&dhash_tree, &dhn->dhash, -300195);
+
+}
+
+
+void free_dhash_node( struct dhash_node *dhn )
+{
+ dbgf(DBGL_SYS, DBGT_INFO, "dhash %8X myIID4orig %d", dhn->dhash.h.u32[0], dhn->myIID4orig);
+
+ invalidate_dhash_node(dhn);
+ return;
+
+ unlink_dhash_node(dhn);
+
+ free_dhash_iid(dhn);
+
+}
+
+void invalidate_dhash_node( struct dhash_node *dhn )
+{
+
+ dbgf(DBGL_CHANGES, DBGT_INFO,
+ "dhash %8X myIID4orig %d, my_iid_repository: used %d, inactive %d min_free %d max_free %d ",
+ dhn->dhash.h.u32[0], dhn->myIID4orig,
+ my_iid_repos.tot_used, dhash_invalid_tree.items+1, my_iid_repos.min_free, my_iid_repos.max_free);
+
+ unlink_dhash_node(dhn); // will clear dhn->on
+
+ avl_insert(&dhash_invalid_tree, dhn, -300168);
+ plist_add_tail(&dhash_invalid_plist, dhn);
+ dhn->referred_timestamp = bmx_time;
+
+
+ //dhn->invalid=YES;
+}
+
+
+
+
+
+
+//BMX3 (done)
+IDM_T update_neighIID4x_repository(struct neigh_node *neigh, IID_T neighIID4x, struct dhash_node *dhn)
+{
+ assertion(-500386, (neigh->dhn != my_orig_node.dhn));
+
+ if (dhn == my_orig_node.dhn)
+ neigh->neighIID4me = neighIID4x;
+
+ if (dhn == neigh->dhn)
+ neigh->neighIID4neigh = neighIID4x;
+
+ return iid_set_neighIID4x(&neigh->neighIID4x_repos, neighIID4x, dhn->myIID4orig);
+}
+
+
+STATIC_FUNC
+void purge_router_tree( struct orig_node *on, IDM_T purge_all )
+{
+ struct avl_node *an;
+ struct link_key key;
+ memset( &key, 0, sizeof(struct link_key));
+
+ while ((an = avl_next(&on->router_tree, &key))) {
+
+ struct router_node *rn = an->item;
+
+ memcpy(&key, &rn->key, sizeof (struct link_key));
+
+ if (purge_all || !avl_find(&link_dev_tree, &rn->key)) {
+ debugFree(rn, -300225);
+ avl_remove(&on->router_tree, &rn->key, -300226);
+ }
+ }
+}
+
+IDM_T update_orig_metrics(struct packet_buff *pb, struct orig_node *on, IID_T orig_sqn)
+{
+ dbgf(DBGL_ALL, DBGT_INFO, "%s orig_sqn %d via neigh %s", on->id.name, orig_sqn,pb->neigh_str);
+
+ struct router_node *rn_in = NULL;
+ uint32_t metric_in, metric_best = 0;
+ SQN_T mask = on->path_metric_algo.sqn_mask;
+// SQN_T range = on->ogm_sqn_range;
+
+// return SUCCESS;
+
+ if (on->blocked || (((SQN_T) (orig_sqn - on->ogm_sqn_min)) >= on->ogm_sqn_range))
+ return FAILURE;
+
+/*
+
+ if (((SQN_T) (((orig_sqn & mask) - (on->ogm_sqn_max_rcvd & mask)) - 1)) < on->ogm_sqn_range) {
+
+
+ for (;;) {
+ struct router_node *rn;
+ struct avl_node *an;
+// SQN_T min_sqn_level = ((orig_sqn & mask) - on->ogm_sqn_steps);
+ struct router_node *rn_best = NULL;
+ uint32_t metric_temp;
+ metric_best = 0;
+
+ for (an = NULL; (rn = avl_iterate_item(&on->router_tree, &an));) {
+
+ if (memcmp(&rn->key, &pb->lndev->key, sizeof (struct link_key))) {
+
+ metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, orig_sqn, 0);
+
+ if (metric_best < metric_temp) {
+
+ metric_best = metric_temp;
+ rn_best = rn;
+ }
+
+ } else {
+ rn_in = rn;
+ }
+ }
+
+ if (rn_best && !avl_find(&link_dev_tree, &rn_best->key)) {
+ purge_router_tree(on, NO);
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ } else {
+ rn_in = avl_find_item(&on->router_tree, &pb->lndev->key);
+ }
+
+ on->ogm_sqn_max_rcvd = MAX_SQ(on->ogm_sqn_max_rcvd, orig_sqn);
+
+ */
+ on->ogm_sqn_max_rcvd = MAX_SQ(on->ogm_sqn_max_rcvd, orig_sqn);
+
+ if (((SQN_T) ((on->ogm_sqn_max_rcvd & mask) - (orig_sqn & mask))) > on->path_metric_algo.sqn_lounge ) {
+
+ dbgf(DBGL_CHANGES, DBGT_WARN, "%s orig_sqn %d to old max_sqn %d via neigh %s",
+ on->id.name, orig_sqn, on->ogm_sqn_max_rcvd, pb->neigh_str);
+
+ return FAILURE;
+ }
+
+ for (;;) {
+ struct router_node *rn;
+ struct avl_node *an;
+ struct router_node *rn_best = NULL;
+ uint32_t metric_temp;
+ metric_best = 0;
+
+ for (an = NULL; (rn = avl_iterate_item(&on->router_tree, &an));) {
+
+ if (memcmp(&rn->key, &pb->lndev->key, sizeof (struct link_key))) {
+
+ metric_temp = update_metric(&rn->mr, &on->path_metric_algo, 0, on->ogm_sqn_max_rcvd, 0);
+
+ if (metric_best < metric_temp) {
+
+ metric_best = metric_temp;
+ rn_best = rn;
+ }
+
+ } else {
+ rn_in = rn;
+ }
+ }
+
+ if (rn_best && !avl_find(&link_dev_tree, &rn_best->key)) {
+ purge_router_tree(on, NO);
+ continue;
+ } else {
+ break;
+ }
+ }
+
+
+ if (!rn_in) {
+ rn_in = debugMalloc(sizeof (struct router_node), -300222);
+ memset( rn_in, 0, sizeof(struct router_node));
+ memcpy( &rn_in->key, &pb->lndev->key, sizeof(struct link_key));
+// rn_in->ogm_sqn_to_be_send = ((on->ogm_sqn_max_rcvd & mask) - on->ogm_sqn_steps);
+ avl_insert(&on->router_tree, rn_in, -300223);
+ }
+
+ metric_in = update_metric(&rn_in->mr, &on->path_metric_algo, orig_sqn, on->ogm_sqn_max_rcvd, pb->lndev->mr[SQR_RTQ].val);
+
+
+ if (metric_in > metric_best && GREAT_SQN(rn_in->mr.set & mask, on->ogm_sqn_to_be_send & mask)) {
+
+ on->router_path_metric = metric_in;
+ on->ogm_sqn_to_be_send = rn_in->mr.set;
+ ogm_aggreg_pending++;
+
+ if (memcmp(&on->router_key, &rn_in->key, sizeof (struct link_key))) {
+
+ struct link_dev_node *lndev_old = avl_find_item(&link_dev_tree, &on->router_key);
+
+ dbgf((!on->router_key.llip4 || lndev_old) ? DBGL_CHANGES : DBGL_SYS,
+ (!on->router_key.llip4 || lndev_old) ? DBGT_INFO : DBGT_ERR,
+ "changing router to %s %s via %s %s metric %d (prev %s %s)",
+ on->id.name, on->primary_ip4_str,
+ ipStr(rn_in ? rn_in->key.llip4 : 0), rn_in ? rn_in->key.dev->name : "---", metric_in,
+ ipStr(on->router_key.llip4), lndev_old ? on->router_key.dev->name : "---");
+
+ assertion(-500504, (!on->router_key.llip4 || lndev_old));
+
+ if (on->router_key.llip4) {
+ configure_route(on->primary_ip4, 32, 0, on->router_key.llip4, 0,
+ on->router_key.dev->index, on->router_key.dev->name,
+ RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
+ }
+
+ configure_route(on->primary_ip4, 32, 0, rn_in->key.llip4, my_orig_node.primary_ip4,
+ rn_in->key.dev->index, rn_in->key.dev->name,
+ RT_TABLE_HOSTS, RTN_UNICAST, ADD, TRACK_OTHER_HOST);
+
+ memcpy(&on->router_key, &rn_in->key, sizeof (struct link_key));
+ }
+ }
+ return SUCCESS;
+}
+
+
+
+void free_orig_node(struct orig_node *on)
+{
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s", on->primary_ip4_str);
+
+ if ( on == &my_orig_node)
+ return;
+
+ if (on->router_key.llip4) {
+ configure_route(on->primary_ip4, 32, 0, on->router_key.llip4, 0,
+ on->router_key.dev->index, on->router_key.dev->name,
+ RT_TABLE_HOSTS, RTN_UNICAST, DEL, TRACK_OTHER_HOST);
+ }
+
+
+ process_description_tlvs(on, NULL, TLV_DEL_TEST_ADD, NULL);
+
+
+ if ( on->dhn ) {
+ on->dhn->on = NULL;
+ free_dhash_node(on->dhn);
+ }
+
+ purge_router_tree(on, YES);
+
+ avl_remove(&orig_tree, &on->id, -300200);
+ avl_remove(&blocked_tree, &on->id, -300201);
+
+ debugFree( on->desc0, -300228 );
+ debugFree( on, -300086 );
+}
+
+
+
+
+void purge_orig(struct dev_node *only_dev, IDM_T only_expired)
+{
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s only expired",
+ only_dev ? only_dev->name : "---", only_expired ? " " : "NOT");
+
+ purge_link_node( 0, only_dev, only_expired );
+
+ int i;
+ for (i = IID_RSVD_MAX + 1; i < my_iid_repos.max_free; i++) {
+
+ struct dhash_node *dhn;
+
+ if ((dhn = my_iid_repos.arr.node[i]) && dhn->on) {
+
+ if ( only_dev ) {
+
+ //TODO: keep on and only remove route
+ if ( dhn->on->router_key.dev == only_dev)
+ free_orig_node(dhn->on);
+
+ } else if (!only_expired || ((uint32_t) (bmx_time - dhn->referred_timestamp)) > (uint32_t) purge_to) {
+
+ free_orig_node(dhn->on);
+ }
+ }
+ }
+}
+
+struct dev_node * get_bif(char *dev)
+{
+ char dev_name[IFNAMSIZ];
+ memset(dev_name, 0, IFNAMSIZ);
+
+ strncpy(dev_name, dev, IFNAMSIZ - 1);
+
+ return avl_find_item(&dev_name_tree, dev_name);
+
+}
+
+
+void rx_packet( struct packet_buff *pb )
+{
+ struct dev_node *dev;
+ struct dev_node *iif = pb->iif;
+ struct packet_header *hdr = (struct packet_header *) pb->packet_in;
+ hdr->pkt_length = ntohs(hdr->pkt_length);
+ hdr->pkt_dev_sqn = ntohs(hdr->pkt_dev_sqn);
+
+ if (pb->pkt_buff_llip4 == iif->ip4_broad) {
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "drop OGM: %s via %s ignoring all packets with broadcast source IP",
+ ipStr(pb->pkt_buff_llip4), pb->iif->name);
+ return;
+ }
+
+ if ((dev = avl_find_item(&dev_ip4_tree, &pb->pkt_buff_llip4))) {
+ // mark own packets;
+ pb->oif = iif;
+ } else {
+ pb->oif = NULL;
+ }
+
+
+ addr_to_str( pb->pkt_buff_llip4, pb->neigh_str );
+
+ // immediately drop invalid packets...
+ // we acceppt longer packets than specified by pos->size to allow padding for equal packet sizes
+ if ( pb->total_length < (int) (sizeof (struct packet_header) + sizeof (struct frame_header)) ||
+ hdr->pkt_length < (int) (sizeof (struct packet_header) + sizeof (struct frame_header)) ||
+ hdr->bmx_version != COMPAT_VERSION ||
+ hdr->pkt_length > pb->total_length || hdr->pkt_length > MAX_UDPD_SIZE) {
+
+ goto process_packet_error_hdr;
+ }
+
+ dbgf_all( DBGT_INFO, "version? %i, reserved? %X, size? %i, sqn %d rcvd udp_len %d via NB %s %s %s",
+ hdr->bmx_version, hdr->bmx_capabilities, hdr->pkt_length, hdr->pkt_dev_sqn,
+ pb->total_length, pb->neigh_str, iif->name, pb->unicast ? "UNICAST" : "BRC");
+
+
+ if (!pb->oif) {
+
+ iif->link_activity_timestamp = bmx_time;
+
+ } else if (((SQN_T) (pb->oif->packet_sqn - hdr->pkt_dev_sqn)) > 2) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "DAD-Alert via dev %s Somebody is using my Link-Local Address %s pkt_sqn %d != %d!!!",
+ iif->name, pb->oif->ip4_str, hdr->pkt_dev_sqn, pb->oif->packet_sqn);
+
+ goto process_packet_error_hdr;
+
+ } else {
+ return;
+ }
+
+
+ struct link_node *ln = get_link_node(pb->pkt_buff_llip4);
+
+ if (ln->pkt_time_max && ln->pkt_sqn_max && ((SQN_T) (hdr->pkt_dev_sqn - ln->pkt_sqn_max)) > SQN_DAD_RANGE) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "NB %s (via %s) reinitialized (or DAD?!) pkt_sqn %d != %d! Reinitializing link_node",
+ pb->neigh_str, iif->name, hdr->pkt_dev_sqn, ln->pkt_sqn_max);
+
+ purge_link_node(ln->llip4, NULL, NO);
+ ASSERTION( -500213, !avl_find(&link_tree, &pb->pkt_buff_llip4 ) );
+ ln = get_link_node(pb->pkt_buff_llip4);
+ }
+
+ ln->pkt_sqn_max = hdr->pkt_dev_sqn;
+ ln->pkt_time_max = bmx_time;
+ pb->ln = ln;
+ pb->lndev = get_link_dev_node(ln, pb->iif);
+ pb->lndev->pkt_time_max = bmx_time;
+
+
+ dbgf(DBGL_ALL, DBGT_INFO, "rcvd packet from %s size %d via dev %s",
+ pb->neigh_str, hdr->pkt_length, iif->name);
+
+ if (blacklisted_neighbor(pb, NULL))
+ return;
+
+ if (rx_frames(pb, hdr->pkt_data, hdr->pkt_length - sizeof (struct packet_header)) == SUCCESS)
+ return;
+
+process_packet_error_hdr:
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "Drop (remaining) packet: rcvd problematic packet via NB %s %s"
+ "(version? %i, reserved? %X, pkt_size? %i), rcvd udp_len % d My version is % d, max_udpd_size %d",
+ pb->neigh_str, iif->name,
+ hdr->bmx_version, hdr->bmx_capabilities, hdr->pkt_length, pb->total_length,
+ COMPAT_VERSION, MAX_UDPD_SIZE);
+
+ return;
+}
+
+
+/***********************************************************
+ Runtime Infrastructure
+************************************************************/
+
+void upd_time( struct timeval *precise_tv ) {
+
+ timeradd( &max_tv, &new_tv, &acceptable_p_tv );
+ timercpy( &acceptable_m_tv, &new_tv );
+ gettimeofday( &new_tv, NULL );
+
+ if ( timercmp( &new_tv, &acceptable_p_tv, > ) ) {
+
+ timersub( &new_tv, &acceptable_p_tv, &diff_tv );
+ timeradd( &start_time_tv, &diff_tv, &start_time_tv );
+
+ dbg( DBGL_SYS, DBGT_WARN,
+ "critical system time drift detected: ++ca %ld s, %ld us! Correcting reference!",
+ diff_tv.tv_sec, diff_tv.tv_usec );
+
+ if ( diff_tv.tv_sec > CRITICAL_PURGE_TIME_DRIFT )
+ purge_orig(NULL, NO);
+
+ } else if ( timercmp( &new_tv, &acceptable_m_tv, < ) ) {
+
+ timersub( &acceptable_m_tv, &new_tv, &diff_tv );
+ timersub( &start_time_tv, &diff_tv, &start_time_tv );
+
+ dbg( DBGL_SYS, DBGT_WARN,
+ "critical system time drift detected: --ca %ld s, %ld us! Correcting reference!",
+ diff_tv.tv_sec, diff_tv.tv_usec );
+
+ if ( diff_tv.tv_sec > CRITICAL_PURGE_TIME_DRIFT )
+ purge_orig(NULL, NO);
+
+ }
+
+ timersub( &new_tv, &start_time_tv, &ret_tv );
+
+ if ( precise_tv ) {
+ precise_tv->tv_sec = ret_tv.tv_sec;
+ precise_tv->tv_usec = ret_tv.tv_usec;
+ }
+
+ bmx_time = ( (ret_tv.tv_sec * 1000) + (ret_tv.tv_usec / 1000) );
+ bmx_time_sec = ret_tv.tv_sec;
+
+}
+
+
+
+char *get_human_uptime( uint32_t reference ) {
+ // DD:HH:MM:SS
+ static char ut[32]="00:00:00:00";
+
+ sprintf( ut, "%2i:%i%i:%i%i:%i%i",
+ (((bmx_time_sec-reference)/86400)),
+ (((bmx_time_sec-reference)%86400)/36000)%10,
+ (((bmx_time_sec-reference)%86400)/3600)%10,
+ (((bmx_time_sec-reference)%3600)/600)%10,
+ (((bmx_time_sec-reference)%3600)/60)%10,
+ (((bmx_time_sec-reference)%60)/10)%10,
+ (((bmx_time_sec-reference)%60))%10
+ );
+
+ return ut;
+}
+
+
+void wait_sec_msec( uint32_t sec, uint32_t msec ) {
+
+ struct timeval time;
+
+ //no debugging here because this is called from debug_output() -> dbg_fprintf() which may case a loop!
+ //dbgf_all( DBGT_INFO, "%d sec %d msec...", sec, msec );
+
+ time.tv_sec = sec + (msec/1000) ;
+ time.tv_usec = ( msec * 1000 ) % 1000000;
+
+ select( 0, NULL, NULL, NULL, &time );
+
+ //update_bmx_time( NULL ); //this will cause critical system time drift message from the client
+ //dbgf_all( DBGT_INFO, "bat_wait(): done");
+
+ return;
+}
+
+
+
+int32_t rand_num( uint32_t limit ) {
+
+ return ( limit == 0 ? 0 : rand() % limit );
+}
+
+
+
+int8_t terminating() {
+
+ return stop != 0;
+
+}
+
+
+static void handler( int32_t sig ) {
+
+ if ( !Client_mode ) {
+ dbgf( DBGL_SYS, DBGT_ERR, "called with signal %d", sig);
+ }
+
+ printf("\n");// to have a newline after ^C
+
+ stop = 1;
+ cb_plugin_hooks( NULL, PLUGIN_CB_TERM );
+
+}
+
+
+/* counting bits based on http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable */
+
+static unsigned char BitsSetTable256[256];
+
+STATIC_FUNC
+void init_set_bits_table256(void)
+{
+ BitsSetTable256[0] = 0;
+ int i;
+ for (i = 0; i < 256; i++)
+ {
+ BitsSetTable256[i] = (i & 1) + BitsSetTable256[i / 2];
+ }
+}
+
+// count the number of true bits in v
+
+uint8_t bits_count(uint32_t v)
+{
+ uint8_t c=0;
+ uint32_t w = v;
+
+ for (; v; v = v>>8 )
+ c += BitsSetTable256[v & 0xff];
+
+ dbgf_all( DBGT_INFO, "%8X, counted %d bits", w, c);
+
+ return c;
+}
+
+uint8_t bit_get(uint8_t *array, uint16_t array_bit_size, uint16_t bit)
+{
+ bit = bit % array_bit_size;
+
+ uint16_t byte_pos = bit / 8;
+ uint8_t bit_pos = bit % 8;
+
+ return (array[byte_pos] & (0x01 << bit_pos)) ? 1 : 0;
+}
+
+void bit_set(uint8_t *array, uint16_t array_bit_size, uint16_t bit, IDM_T value)
+{
+ bit = bit % array_bit_size;
+
+ uint16_t byte_pos = bit / 8;
+ uint8_t bit_pos = bit % 8;
+
+ if (value)
+ array[byte_pos] |= (0x01 << bit_pos);
+ else
+ array[byte_pos] &= ~(0x01 << bit_pos);
+
+ assertion(-500415, (!value == !bit_get(array, array_bit_size, bit)));
+}
+
+/*
+ * clears bit range between and including begin and end
+ */
+void bit_clear(uint8_t *array, uint16_t array_bit_size, uint16_t begin_bit, uint16_t end_bit)
+{
+ assertion(-500435, (array_bit_size % 8 == 0));
+
+ if (((uint16_t) (end_bit - begin_bit)) >= (array_bit_size - 1)) {
+
+ memset(array, 0, array_bit_size / 8);
+ return;
+ }
+
+ begin_bit = begin_bit % array_bit_size;
+ end_bit = end_bit % array_bit_size;
+
+ uint16_t begin_byte = begin_bit/8;
+ uint16_t end_byte = end_bit/8;
+ uint16_t array_byte_size = array_bit_size/8;
+
+
+ if (begin_byte != end_byte && ((begin_byte + 1) % array_byte_size) != end_byte)
+ byte_clear(array, array_byte_size, begin_byte + 1, end_byte - 1);
+
+
+ uint8_t begin_mask = ~(0xFF << (begin_bit%8));
+ uint8_t end_mask = (0xFF >> ((end_bit%8)+1));
+
+ if (begin_byte == end_byte) {
+
+ array[begin_byte] &= (begin_mask | end_mask);
+
+ } else {
+
+ array[begin_byte] &= begin_mask;
+ array[end_byte] &= end_mask;
+ }
+}
+
+/*
+ * clears byte range between and including begin and end
+ */
+void byte_clear(uint8_t *array, uint16_t array_size, uint16_t begin, uint16_t end)
+{
+
+ assertion(-500436, (array_size % 2 == 0));
+
+ begin = begin % array_size;
+ end = end % array_size;
+
+ memset(array + begin, 0, end >= begin ? end + 1 - begin : array_size - begin);
+
+ if ( begin > end)
+ memset(array, 0, end + 1);
+
+
+}
+
+uint8_t is_zero(char *data, int len)
+{
+ int i;
+
+ for (i = 0; i < len && !data[i]; i++);
+
+ if ( i < len )
+ return NO;
+
+ return YES;
+}
+
+
+
+static int segfault = NO;
+static int cleaning_up = NO;
+
+static void segmentation_fault(int32_t sig)
+{
+
+ dbg(DBGL_SYS, DBGT_ERR, "SIGSEGV %d received, try cleaning up (%s-rv%d)...",
+ sig, SOURCE_VERSION, REVISION_VERSION);
+
+ if (!segfault) {
+
+ segfault = YES;
+
+ signal(SIGSEGV, SIG_DFL);
+
+
+ if (!on_the_fly)
+ dbg(DBGL_SYS, DBGT_ERR,
+ "check up-to-dateness of bmx libs in default lib path %s or customized lib path defined by %s !",
+ BMX_DEF_LIB_PATH, BMX_ENV_LIB_PATH);
+
+
+ if (!cleaning_up)
+ cleanup_all(CLEANUP_RETURN);
+
+ dbg(DBGL_SYS, DBGT_ERR, "raising SIGSEGV again ...");
+ }
+
+ errno=0;
+ if ( raise( SIGSEGV ) ) {
+ dbg( DBGL_SYS, DBGT_ERR, "raising SIGSEGV failed: %s...", strerror(errno) );
+ }
+}
+
+
+void cleanup_all(int status)
+{
+
+ if (status < 0) {
+ dbg(DBGL_SYS, DBGT_ERR, "Terminating with error code %d ! Please notify a developer", status);
+ segmentation_fault(1);
+ }
+
+ if (!cleaning_up) {
+
+ dbgf_all(DBGT_INFO, "cleaning up (status %d)...", status);
+
+ cleaning_up = YES;
+
+ // first, restore defaults...
+
+ stop = 1;
+
+ cleanup_schedule();
+
+
+ if (my_orig_node.dhn) {
+ my_orig_node.dhn->on = NULL;
+ free_dhash_node(my_orig_node.dhn);
+ }
+
+ avl_remove(&orig_tree, &(my_orig_node.id), -300203);
+
+ purge_orig( NULL, NO );
+
+ cleanup_plugin();
+
+ cleanup_config();
+
+ cleanup_route();
+
+ cleanup_msg();
+
+ purge_dhash_to_list(YES);
+
+
+ while (dev_name_tree.items) {
+
+ struct dev_node *dev = dev_name_tree.root->item;
+
+ if ( dev->active )
+ dev_deactivate( dev );
+
+ avl_remove(&dev_name_tree, &dev->name, -300204);
+
+ debugFree(dev, -300046);
+
+ }
+
+ // last, close debugging system and check for forgotten resources...
+ cleanup_control();
+
+ checkLeak();
+
+ dbgf_all( DBGT_ERR, "...cleaning up done");
+
+ if (status == CLEANUP_SUCCESS) {
+
+ exit(EXIT_SUCCESS);
+
+ } else if (status == CLEANUP_FAILURE) {
+
+ exit(EXIT_FAILURE);
+
+ } else if (status == CLEANUP_RETURN) {
+
+ return;
+
+ }
+
+ exit(EXIT_FAILURE);
+ dbg(DBGL_SYS, DBGT_ERR, "exit ignored!?");
+ }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+/***********************************************************
+ Configuration data and handlers
+************************************************************/
+
+
+STATIC_FUNC
+int32_t opt_show_origs(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ int rq, tq, rtq;
+
+ if ( cmd == OPT_APPLY ) {
+
+ if (!strcmp(opt->long_name, ARG_ORIGINATORS)) {
+
+ dbg_printf(cn, "Originator: rand primary_ip via "
+ "metric mid4o descSQN ogmSQN < max lupd lref pogi pws\n");
+
+ struct avl_node *it = NULL;
+
+ while ((it = avl_iterate(&orig_tree, it))) {
+
+ struct orig_node *on = it->item;
+
+ struct link_dev_node *lndev = avl_find_item(&link_dev_tree, &on->router_key);
+
+ dbg_printf(cn, "%-22s %8X%8X %-15s %-15s %-10s" "%6i %5d %5d %5d %5d %5d %4d %5d %4d\n",
+ on->id.name, ntohl(on->id.rand.u32[0]), ntohl(on->id.rand.u32[1]),
+ on->blocked ? "BLOCKED" : on->primary_ip4_str,
+ ipStr(lndev ? lndev->key.llip4 : 0),
+ lndev ? lndev->key.dev->name : "---",
+ on->router_path_metric,
+ on->dhn->myIID4orig, on->desc0_sqn,
+ on->ogm_sqn_to_be_send,
+ (on->ogm_sqn_min + on->ogm_sqn_range),
+ (bmx_time - on->updated_timestamp) / 1000,
+ (bmx_time - on->dhn->referred_timestamp) / 1000,
+ ntohs(on->desc0->path_ogi), ntohs(on->desc0->path_window_size)
+ );
+
+ //process_description_tlvs( on, NULL, TLV_DEBUG, cn );
+ }
+
+
+ } else if (!strcmp(opt->long_name, ARG_STATUS)) {
+
+ dbg_printf(cn, "BMX %s-rv%d, %s, LWS %i, PWS %i, OGI %4ims, UT %s, CPU %d.%1d\n",
+ SOURCE_VERSION, REVISION_VERSION, my_orig_node.primary_ip4_str, local_lws, my_pws, my_ogm_interval,
+ get_human_uptime(0), s_curr_avg_cpu_load / 10, s_curr_avg_cpu_load % 10);
+
+
+ } else if ( !strcmp( opt->long_name, ARG_LINKS ) ) {
+
+ dbg_printf(cn, "LinkLocalIP viaIF bestIF primaryIP RTQ RQ TQ oid4m lseq lvld\n");
+
+ struct avl_node *it = NULL;
+
+ while ((it = avl_iterate(&link_tree, it))) {
+
+ struct link_node *ln = it->item;
+ struct neigh_node *nn = ln->neigh;
+ struct orig_node *on = nn ? nn->dhn->on : NULL;
+
+ struct list_node *lndev_pos;
+
+ list_for_each( lndev_pos, &ln->lndev_list ) {
+ struct link_dev_node *lndev = list_entry( lndev_pos, struct link_dev_node, list );
+
+ rq = lndev->mr[SQR_RQ].val;
+ tq = TQ_RATE( lndev, PROBE_RANGE); // tq_rate( lndev, PROBE_RANGE );
+ rtq = lndev->mr[SQR_RTQ].val;
+
+
+ dbg_printf( cn, "%-15s %-10s %-10s %-15s %4i %4i %4i %5d %5i %4i\n",
+ ipStr(ln->llip4),
+ lndev->key.dev->name,
+ ln->neigh && ln->neigh->best_rtq ? ln->neigh->best_rtq->key.dev->name : "---",
+ on ? on->primary_ip4_str : "???",
+ rtq , rq, tq,
+ nn ? nn->neighIID4me : 0,
+ ln->rq_sqn_max,
+ (bmx_time - lndev->rtq_time_max) / 1000
+ );
+
+ }
+
+ }
+
+ } else {
+ return FAILURE;
+ }
+
+ dbg_printf( cn, "\n" );
+ }
+
+ return SUCCESS;
+}
+
+
+STATIC_FUNC
+int32_t opt_dev_show(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ if ( cmd == OPT_APPLY ) {
+
+ struct avl_node *it=NULL;
+ struct dev_node *dev;
+ while ((dev = avl_iterate_item(&dev_name_tree, &it))) {
+
+ dbg_cn( cn, DBGL_ALL, DBGT_NONE, "%-10s %5d %8s %15s/%-2d brc %-15s SQN %5d %14s %8s %11s",
+ dev->name,
+ dev->index,
+ !dev->active ? "-" :
+ ( dev->linklayer == VAL_DEV_LL_LO ? "loopback":
+ ( dev->linklayer == VAL_DEV_LL_LAN ? "ethernet":
+ ( dev->linklayer == VAL_DEV_LL_WLAN ? "wireless": "???" ) ) ),
+ dev->ip4_str,
+ dev->ip4_prefix_length,
+ ipStr(dev->ip4_broad),
+ dev->ogm_sqn,
+ dev->announce ? "announced" : "not announced",
+ dev->active ? "active" : "inactive",
+ dev == primary_if ? "primary" : "non-primary"
+ );
+
+ }
+ }
+ return SUCCESS;
+}
+STATIC_FUNC
+int32_t opt_dev(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ struct list_node *list_pos;
+ struct dev_node *dev = NULL;
+
+ struct dev_node test_bif;
+
+ char *colon_ptr;
+
+ dbgf_all( DBGT_INFO, "cmd: %s opt: %s instance %s",
+ opt_cmd2str[cmd], opt->long_name, patch ? patch->p_val : "");
+
+ if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ if ( strlen(patch->p_val) >= IFNAMSIZ ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "dev name MUST be smaller than %d chars", IFNAMSIZ );
+ return FAILURE;
+ }
+
+ dev = get_bif( patch->p_val );
+
+ if ( patch->p_diff == DEL ) {
+
+ if ( dev && primary_if == dev ) {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "primary interface %s %s can not be removed!",
+ dev->name, dev->ip4_str );
+
+ return FAILURE;
+
+ } else if ( dev && cmd == OPT_APPLY ) {
+
+ if ( dev->active )
+ dev_deactivate( dev );
+
+ avl_remove( &dev_name_tree, &dev->name, -300205 );
+
+ debugFree(dev, -300048);
+
+ return SUCCESS;
+
+
+ } else if ( !dev ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "Interface does not exist!" );
+ return FAILURE;
+ }
+ }
+
+ if ( !dev ) {
+
+ if ( cmd == OPT_APPLY ) {
+ int i;
+ dev = debugMalloc( sizeof(struct dev_node), -300002 );
+ memset(dev, 0, sizeof (struct dev_node));
+
+ if (!dev_name_tree.items)
+ primary_if = dev;
+
+ snprintf(dev->name, wordlen(patch->p_val) + 1, "%s", patch->p_val);
+
+ avl_insert( &dev_name_tree, dev, -300144 );
+
+ for (i = 0; i < FRAME_TYPE_ARRSZ; i++) {
+ LIST_INIT_HEAD(dev->tx_tasks_list[i], struct tx_task_node, list);
+ }
+
+ AVL_INIT_TREE( dev->tx_timestamp_tree, struct tx_timestamp_node, key );
+
+
+
+ } else {
+
+ dev = &test_bif;
+ memset(dev, 0, sizeof (struct dev_node));
+ snprintf(dev->name, wordlen(patch->p_val) + 1, "%s", patch->p_val);
+
+ }
+
+// bif->aggregation_out = bif->aggregation_out_buff;
+
+ snprintf( dev->name_phy, wordlen(patch->p_val)+1, "%s", patch->p_val );
+
+ /* if given interface is an alias record physical interface name*/
+ if ( ( colon_ptr = strchr( dev->name_phy, ':' ) ) != NULL )
+ *colon_ptr = '\0';
+
+ dbgf_all( DBGT_INFO, "assign dev %s physical name %s", dev->name, dev->name_phy );
+
+ dev->ogm_sqn = rand_num(MAX_SQN);
+
+ dev->packet_sqn = rand_num(MAX_SQN);
+
+ // bif->aggregation_len = sizeof( struct bmx_pkt_hdr );
+
+
+ // some configurable interface values - initialized to unspecified:
+ dev->send_clones_conf = -1;
+ dev->antenna_diversity_conf = -1;
+ dev->linklayer_conf = -1;
+ dev->announce_conf = -1;
+
+ }
+
+ if ( cmd == OPT_CHECK )
+ return SUCCESS;
+
+ list_for_each( list_pos, &patch->childs_instance_list ) {
+
+ struct opt_child *c = list_entry( list_pos, struct opt_child, list );
+
+ int32_t val = c->c_val ? strtol( c->c_val , NULL , 10 ) : -1 ;
+
+ if ( !strcmp( c->c_opt->long_name, ARG_DEV_CLONE ) ) {
+
+ dev->send_clones_conf = val;
+
+ } else if ( !strcmp( c->c_opt->long_name, ARG_DEV_ANTDVSTY ) ) {
+
+ dev->antenna_diversity_conf = val;
+
+ } else if ( !strcmp( c->c_opt->long_name, ARG_DEV_LL ) ) {
+
+ dev->linklayer_conf = val;
+ dev->hard_conf_changed = YES;
+
+ } else if ( !strcmp( c->c_opt->long_name, ARG_DEV_ANNOUNCE ) ) {
+
+ dev->announce_conf = val;
+ }
+
+ dev->soft_conf_changed = YES;
+
+ }
+
+
+ } else if ( cmd == OPT_POST && opt && !opt->parent_name ) {
+
+ dev_check(); //will always be called whenever a parameter is changed (due to OPT_POST)
+
+ }
+
+ return SUCCESS;
+}
+
+STATIC_FUNC
+int32_t opt_purge(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ if ( cmd == OPT_APPLY)
+ purge_orig(NULL, NO);
+
+ return SUCCESS;
+}
+
+
+/*
+STATIC_FUNC
+int32_t opt_if_soft(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ if ( cmd == OPT_APPLY )
+ if_conf_soft_changed = YES;
+
+ return SUCCESS;
+}
+*/
+
+#ifdef WITHUNUSED
+
+STATIC_FUNC
+int32_t opt_if_hard(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ if ( cmd == OPT_APPLY )
+ if_conf_hard_changed = YES;
+
+ return SUCCESS;
+}
+#endif
+
+
+int32_t opt_update_description(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+ if ( cmd == OPT_APPLY )
+ if_conf_soft_changed = YES;
+
+ return SUCCESS;
+}
+
+STATIC_FUNC
+int32_t opt_path_metric(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+
+
+ if (cmd == OPT_CHECK || cmd == OPT_APPLY || cmd == OPT_REGISTER) {
+
+ struct metric_algo test_algo;
+ memset(&test_algo, 0, sizeof (struct metric_algo));
+
+ test_algo.sqn_mask = ((SQN_T)(0xFFFF << DEF_OGM0_PQ_BITS));
+ test_algo.sqn_steps = (0x01 << DEF_OGM0_PQ_BITS);
+ test_algo.regression = my_pws / test_algo.sqn_steps / 2;
+ test_algo.sqn_lounge = my_path_lounge;
+ test_algo.sqn_window = my_pws;
+ test_algo.metric_max = PROBE_RANGE;
+
+ if (validate_metric_algo(&test_algo, cn) == FAILURE)
+ return FAILURE;
+
+ if (cmd == OPT_APPLY || cmd == OPT_REGISTER)
+ memcpy(&(my_orig_node.path_metric_algo), &test_algo, sizeof (struct metric_algo));
+
+ }
+
+ if ( cmd == OPT_APPLY )
+ if_conf_soft_changed = YES;
+
+ return SUCCESS;
+}
+
+STATIC_FUNC
+int32_t opt_link_metric(uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn)
+{
+ if (cmd == OPT_CHECK || cmd == OPT_APPLY || cmd == OPT_REGISTER) {
+
+ struct metric_algo test_algo[SQR_RANGE];
+ memset(test_algo, 0, SQR_RANGE * sizeof (struct metric_algo));
+
+ test_algo[SQR_RTQ].sqn_mask = 0xFFFF;
+ test_algo[SQR_RTQ].sqn_steps = 1;
+ test_algo[SQR_RTQ].regression = local_lws / 2;
+ test_algo[SQR_RTQ].sqn_lounge = local_rtq_lounge;
+ test_algo[SQR_RTQ].sqn_window = local_lws;
+ test_algo[SQR_RTQ].metric_max = PROBE_RANGE;
+
+ if (validate_metric_algo(&(test_algo[SQR_RTQ]), cn) == FAILURE)
+ return FAILURE;
+
+ test_algo[SQR_RQ].sqn_mask = 0xFFFF;
+ test_algo[SQR_RQ].sqn_steps = 1;
+ test_algo[SQR_RQ].regression = local_lws / 2;
+ test_algo[SQR_RQ].sqn_lounge = RQ_LINK_LOUNGE;
+ test_algo[SQR_RQ].sqn_window = local_lws;
+ test_algo[SQR_RQ].metric_max = PROBE_RANGE;
+
+ if (validate_metric_algo(&(test_algo[SQR_RQ]), cn) == FAILURE)
+ return FAILURE;
+
+ if (cmd == OPT_APPLY || cmd == OPT_REGISTER)
+ memcpy(link_metric_algo, test_algo, SQR_RANGE * sizeof (struct metric_algo));
+
+
+ }
+
+ return SUCCESS;
+}
+
+
+static struct opt_type bmx_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ {ODI,0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nProtocol options:"},
+
+ {ODI,0,ARG_STATUS, 0, 5,A_PS0,A_USR,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_origs,
+ 0, "show status\n"},
+
+ {ODI,0,ARG_ROUTES, 0, 5,A_PS0,A_USR,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_origs,
+ 0, "show routes\n"},
+
+ {ODI,0,ARG_LINKS, 0, 5,A_PS0,A_USR,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_origs,
+ 0, "show links\n"},
+
+ {ODI,0,ARG_ORIGINATORS, 0, 5,A_PS0,A_USR,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_origs,
+ 0, "show originators\n"},
+
+ {ODI,0,ARG_DEV, 0, 5,A_PMN,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_dev,
+ "<interface-name>", "add or change device or its configuration, options for specified device are:"},
+
+#ifndef LESS_OPTIONS
+ {ODI,ARG_DEV,ARG_DEV_TTL, 't',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, MIN_TTL, MAX_TTL, DEF_TTL, opt_dev,
+ ARG_VALUE_FORM, "set TTL of generated OGMs"},
+
+ {ODI,ARG_DEV,ARG_DEV_CLONE, 'c',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, MIN_WL_CLONES, MAX_WL_CLONES, DEF_WL_CLONES, opt_dev,
+ ARG_VALUE_FORM, "broadcast OGMs per ogm-interval with given probability (e.g. 200% will broadcast the same OGM twice)"},
+
+ /* Antenna-diversity support for bmxd seems working but unfortunately there are few wireless drivers which support
+ * my understanding of the typical antenna-diversity implementation. This is what I hoped (maybe I am wrong):
+ * - The RX-antenna is detected on-the-fly on a per-packet basis by comparing
+ * the rcvd signal-strength via each antenna during reception of the phy-preamble.
+ * - The TX-antenna is determined per MAC-address based on the last detected best RX-antenna for this MAC.
+ * - Broadcast packets should be send round-robin like via each enabled TX-antenna (e.g. alternating via ant1 and ant2). */
+ {ODI,ARG_DEV,ARG_DEV_ANTDVSTY, 0, 5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 1, 2, 1, opt_dev,
+ ARG_VALUE_FORM, 0/*"set number of broadcast antennas (e.g. for antenna-diversity use /d=2 /c=400 aggreg_interval=100)"*/},
+
+
+ {ODI,ARG_DEV,ARG_DEV_ANNOUNCE, 'a',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 1, DEF_DEV_ANNOUNCE,opt_dev,
+ ARG_VALUE_FORM, "disable/enable announcement of interface IP"},
+#endif
+
+ {ODI,ARG_DEV,ARG_DEV_LL, 'l',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, VAL_DEV_LL_LAN, VAL_DEV_LL_WLAN,0, opt_dev,
+ ARG_VALUE_FORM, "manually set device type for linklayer specific optimization (1=lan, 2=wlan)"},
+
+ {ODI,0,ARG_INTERFACES, 0, 5,A_PS0,A_USR,A_DYI,A_ARG,A_ANY, 0, 0, 1, 0, opt_dev_show,
+ 0, "show configured interfaces"},
+
+ {ODI,0,ARG_LWS, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &local_lws, MIN_LWS, MAX_LWS, DEF_LWS, opt_link_metric,
+ ARG_VALUE_FORM, "set link window size (LWS) for link-quality calculation (link metric)"},
+
+#ifndef LESS_OPTIONS
+
+ {ODI,0,ARG_RTQ_LOUNGE, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &local_rtq_lounge,MIN_RTQ_LOUNGE,MAX_RTQ_LOUNGE,DEF_RTQ_LOUNGE, opt_link_metric,
+ ARG_VALUE_FORM, "set local LLS buffer size to artificially delay OGM processing for ordered link-quality calulation"},
+
+ {ODI,0,ARG_PWS, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_pws, MIN_PWS, MAX_PWS, DEF_PWS, opt_path_metric,
+ ARG_VALUE_FORM, "set path window size (PWS) for end2end path-quality calculation (path metric)"},
+
+ {ODI,0,ARG_PATH_LOUNGE, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_path_lounge,MIN_PATH_LOUNGE,MAX_PATH_LOUNGE,DEF_PATH_LOUNGE, opt_path_metric,
+ ARG_VALUE_FORM, "set default PLS buffer size to artificially delay my OGM processing for ordered path-quality calulation"},
+
+ {ODI,0,ARG_PATH_HYST, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_path_hystere,MIN_PATH_HYST, MAX_PATH_HYST, DEF_PATH_HYST, opt_path_metric,
+ ARG_VALUE_FORM, "use hysteresis to delay route switching to alternative next-hop neighbors with better path metric"},
+
+
+ {ODI,0,ARG_RCNT_PWS, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_rcnt_pws, MIN_RCNT_PWS, MAX_RCNT_PWS, DEF_RCNT_PWS, opt_path_metric,
+ ARG_VALUE_FORM, ""},
+
+ {ODI,0,ARG_RCNT_HYST, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_rcnt_hystere,MIN_RCNT_HYST, MAX_RCNT_HYST, DEF_RCNT_HYST, opt_path_metric,
+ ARG_VALUE_FORM, "use hysteresis to delay fast-route switching to alternative next-hop neighbors with a recently extremely better path metric"},
+
+ {ODI,0,ARG_RCNT_FK, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_rcnt_fk, MIN_RCNT_FK, MAX_RCNT_FK, DEF_RCNT_FK, opt_path_metric,
+ ARG_VALUE_FORM, "configure threshold faktor for dead-path detection"},
+
+
+ {ODI,0,ARG_DROP_2HLOOP, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &drop_2hop_loop,MIN_DROP_2HLOOP,MAX_DROP_2HLOOP,DEF_DROP_2HLOOP,0,
+ ARG_VALUE_FORM, "drop OGMs received via two-hop loops"},
+
+
+ {ODI,0,ARG_ASYM_EXP, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &asym_exp, MIN_ASYM_EXP, MAX_ASYM_EXP, DEF_ASYM_EXP, 0,
+ ARG_VALUE_FORM, "ignore OGMs (rcvd via asymmetric links) with TQ^<val> to radically reflect asymmetric-links"},
+
+ {ODI,0,"asocial_device", 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &Asocial_device,MIN_ASOCIAL, MAX_ASOCIAL, DEF_ASOCIAL, 0,
+ ARG_VALUE_FORM, "disable/enable asocial mode for devices unwilling to forward other nodes' traffic"},
+
+ {ODI,0,ARG_WL_CLONES, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &wl_clones, MIN_WL_CLONES, MAX_WL_CLONES, DEF_WL_CLONES, opt_path_metric,
+ ARG_VALUE_FORM, "broadcast OGMs per ogm-interval for wireless devices with\n"
+ " given probability [%] (eg 200% will broadcast the same OGM twice)"},
+
+ {ODI,0,ARG_ASYM_WEIGHT, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &asym_weight, MIN_ASYM_WEIGHT,MAX_ASYM_WEIGHT,DEF_ASYM_WEIGHT,opt_path_metric,
+ ARG_VALUE_FORM, "ignore OGMs (rcvd via asymmetric links) with given probability [%] to better reflect asymmetric-links"},
+
+ // there SHOULD! be a minimal lateness_penalty >= 1 ! Otherwise a shorter path with equal path-cost than a longer path will never dominate
+ {ODI,0,ARG_LATE_PENAL, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_late_penalty,MIN_LATE_PENAL,MAX_LATE_PENAL, DEF_LATE_PENAL, opt_path_metric,
+ ARG_VALUE_FORM, "penalize non-first rcvd OGMs "},
+
+#endif
+ {ODI,0,ARG_DAD_TO, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &dad_to, MIN_DAD_TO, MAX_DAD_TO, DEF_DAD_TO, 0,
+ ARG_VALUE_FORM, "duplicate address (DAD) detection timout in seconds"},
+
+ {ODI,0,ARG_TTL, 't',5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &my_ttl, MIN_TTL, MAX_TTL, DEF_TTL, opt_path_metric,
+ ARG_VALUE_FORM, "set time-to-live (TTL) for OGMs of primary interface"},
+
+ {ODI,0,ARG_PURGE_TO, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &purge_to, MIN_PURGE_TO, MAX_PURGE_TO, DEF_PURGE_TO, 0,
+ ARG_VALUE_FORM, "timeout in seconds for purging stale originators"}
+,
+
+ {ODI,0,"flush_all", 0, 5,A_PS0,A_ADM,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_purge,
+ 0, "purge all neighbors and routes on the fly"},
+
+ {ODI,0,ARG_OGI_PWRSAVE, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &ogi_pwrsave, MIN_OGM_INTERVAL, MAX_OGM_INTERVAL, MIN_OGM_INTERVAL, 0,
+ ARG_VALUE_FORM, "enable power-saving feature by setting increased OGI when no other nodes are in range"}
+
+
+};
+
+IDM_T validate_name( char* name ) {
+
+ int i,len;
+ if ( (len = strlen( name )) >= DESCRIPTION0_ID_NAME_LEN )
+ return FAILURE;
+
+ for (i = 0; i < len; i++) {
+
+ char c = name[i];
+
+ if (c == '"' || c < ' ' || c > '~')
+ return FAILURE;
+
+ }
+
+ return SUCCESS;
+}
+
+STATIC_FUNC
+void init_bmx(void)
+{
+
+ static uint8_t my_desc0[MAX_PKT_MSG_SIZE];
+
+ memset( &my_orig_node, 0, sizeof(struct orig_node));
+
+ AVL_INIT_TREE((my_orig_node.router_tree), struct router_node, key);
+
+ my_orig_node.desc0 = (struct description *) my_desc0;
+
+ if (gethostname(my_orig_node.id.name, DESCRIPTION0_ID_NAME_LEN))
+ cleanup_all(-500240);
+
+ my_orig_node.id.name[DESCRIPTION0_ID_NAME_LEN - 1] = 0;
+
+ if (validate_name(my_orig_node.id.name) == FAILURE) {
+ dbg(DBGL_SYS, DBGT_ERR, "illegal hostname %s", my_orig_node.id.name);
+ cleanup_all(-500272);
+ }
+
+ my_orig_node.id.rand.u16[0] = (uint16_t) rand_num(U16_MAX);
+ my_orig_node.id.rand.u16[1] = (uint16_t) rand_num(U16_MAX);
+ my_orig_node.id.rand.u16[2] = (uint16_t) rand_num(U16_MAX);
+ my_orig_node.id.rand.u16[3] = (uint16_t) rand_num(U16_MAX);
+
+ my_orig_node.ogm_sqn_min = (((uint16_t) rand_num(MAX_SQN)) & (MAX_SQN << MAX_OGM0_PQ_BITS));
+
+ my_orig_node.desc0_sqn = rand_num(MAX_SQN);
+
+ avl_insert( &orig_tree, &my_orig_node, -300175 );
+
+ register_options_array( bmx_options, sizeof( bmx_options ) );
+
+}
+
+
+
+
+STATIC_FUNC
+void bmx(void)
+{
+
+ struct list_node *list_pos;
+ struct dev_node *dev;
+ uint32_t regular_timeout, statistic_timeout;
+
+ uint32_t s_last_cpu_time = 0, s_curr_cpu_time = 0;
+
+ regular_timeout = statistic_timeout = bmx_time;
+
+ on_the_fly = YES;
+
+ while ( !terminating() ) {
+
+ uint32_t wait = whats_next( );
+
+ if ( wait )
+ wait4Event( MIN( wait, MAX_SELECT_TIMEOUT_MS ) );
+
+ // The regular tasks...
+ if ( LESS_U32( regular_timeout + 1000, bmx_time ) ) {
+
+
+ // check for changed kernel konfigurations...
+ check_kernel_config( NULL );
+
+ // check for changed interface konfigurations...
+ struct avl_node *an = NULL;
+ while ((dev = avl_iterate_item(&dev_name_tree, &an))) {
+
+ if ( dev->active )
+ check_kernel_config( dev );
+
+ purge_tx_timestamp_tree(dev, NO);
+
+ }
+
+ purge_orig(NULL, YES);
+
+ purge_dhash_to_list(NO);
+
+ close_ctrl_node( CTRL_CLEANUP, 0 );
+
+ list_for_each( list_pos, &dbgl_clients[DBGL_ALL] ) {
+
+ struct ctrl_node *cn = (list_entry( list_pos, struct dbgl_node, list ))->cn;
+
+ dbg_printf( cn, "------------------ DEBUG ------------------ \n" );
+
+ check_apply_parent_option( ADD, OPT_APPLY, 0, get_option( 0, 0, ARG_STATUS ), 0, cn );
+ check_apply_parent_option( ADD, OPT_APPLY, 0, get_option( 0, 0, ARG_LINKS ), 0, cn );
+ check_apply_parent_option( ADD, OPT_APPLY, 0, get_option( 0, 0, ARG_ORIGINATORS ), 0, cn );
+ dbg_printf( cn, "--------------- END DEBUG ---------------\n" );
+
+ }
+
+ /* preparing the next debug_timeout */
+ regular_timeout = bmx_time;
+ }
+
+
+ if ( LESS_U32( statistic_timeout + 5000, bmx_time ) ) {
+
+ struct orig_node *on;
+ struct description_id id;
+
+ memset(&id, 0, sizeof (struct description_id));
+
+ while ((on = avl_next_item(&blocked_tree, &id))) {
+
+ memcpy( &id, &on->id, sizeof(struct description_id));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "trying to unblock %s...", on->desc0->id.name);
+
+ IDM_T tlvs_res = process_description_tlvs(on, on->desc0, TLV_DEL_TEST_ADD, NULL);
+
+ assertion(-500364, (tlvs_res == TLVS_BLOCKED || tlvs_res == TLVS_SUCCESS));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "...unblocking %s %s !",
+ on->desc0->id.name, tlvs_res == TLVS_SUCCESS ? "success" : "failed");
+
+ }
+
+
+ // check for corrupted memory..
+ checkIntegrity();
+
+
+ /* generating cpu load statistics... */
+ s_curr_cpu_time = (uint32_t)clock();
+
+ s_curr_avg_cpu_load = ( (s_curr_cpu_time - s_last_cpu_time) / (uint32_t)(bmx_time - statistic_timeout) );
+
+ s_last_cpu_time = s_curr_cpu_time;
+
+ statistic_timeout = bmx_time;
+ }
+ }
+
+}
+
+int main( int argc, char *argv[] )
+{
+
+
+ // make sure we are using compatible description0 sizes:
+ assertion(-500201, (MSG_DESCRIPTION0_ADV_SIZE == sizeof ( struct msg_description_adv)));
+
+ gettimeofday( &start_time_tv, NULL );
+ gettimeofday( &new_tv, NULL );
+
+ upd_time( NULL );
+
+ My_pid = getpid();
+
+ srand( My_pid );
+
+ init_set_bits_table256();
+
+
+ signal( SIGINT, handler );
+ signal( SIGTERM, handler );
+ signal( SIGPIPE, SIG_IGN );
+ signal( SIGSEGV, segmentation_fault );
+
+ init_control();
+
+ init_route();
+
+ init_bmx();
+
+ init_msg();
+
+ init_schedule();
+
+ init_avl();
+
+ init_plugin();
+
+ apply_init_args( argc, argv );
+
+ check_kernel_config( NULL );
+
+ bmx();
+
+ cleanup_all( CLEANUP_SUCCESS );
+
+ return -1;
+}
+
+
+
Added: trunk/bmx/bmx.h
===================================================================
--- trunk/bmx/bmx.h (rev 0)
+++ trunk/bmx/bmx.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,932 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <stdint.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <linux/if.h>
+
+#include "cyassl/sha.h"
+
+#include "avl.h"
+#include "list.h"
+#include "iid.h"
+#include "control.h"
+#include "allocate.h"
+
+
+/*
+ * from other headers:
+ */
+
+#define IDM_T int8_t // int which size does NOT matter
+
+// dont touch this for compatibility reasons:
+#define IP4_T uint32_t
+
+#define DESCRIPTION0_ID_RANDOM_T uint64_t
+#define DESCRIPTION0_ID_RANDOM_LEN sizeof( DESCRIPTION0_ID_RANDOM_T )
+#define DESCRIPTION0_ID_NAME_LEN 22
+
+#define BMX_HASH0_LEN SHA_DIGEST_SIZE // sha.h: 20 bytes
+#define BMX_PKEY0_LEN 1024
+
+struct description_id {
+ char name[DESCRIPTION0_ID_NAME_LEN];
+ union {
+ uint8_t u8[DESCRIPTION0_ID_RANDOM_LEN];
+ uint16_t u16[DESCRIPTION0_ID_RANDOM_LEN / sizeof(uint16_t)];
+ uint32_t u32[DESCRIPTION0_ID_RANDOM_LEN / sizeof(uint32_t)];
+ uint64_t u64[DESCRIPTION0_ID_RANDOM_LEN / sizeof( uint64_t)];
+ } rand;
+} __attribute__((packed));
+
+struct description_hash {
+ union {
+ uint8_t u8[BMX_HASH0_LEN];
+ uint32_t u32[BMX_HASH0_LEN/sizeof(uint32_t)];
+ } h;
+};
+
+// from msg.h
+#define FRAME_TYPE_ARRSZ 14
+
+
+/*
+ * bmx.h:
+ */
+
+
+#define MIN_OGM0_SQN_RANGE 64
+#define MAX_OGM0_SQN_RANGE 8192// <=> 4096 / ogm_sqn_step_size=8 * ogm_interval=1000 = ~512sec
+#define DEF_OGM0_SQN_RANGE 8192// <=> 1024 / ogm_sqn_step_size=8 * ogm_interval=1000 = ~128sec
+
+#define ARG_OGM0_SQN_RANGE "ogm0_validity_range"
+
+#define SQN_DAD_RANGE 64 // if rcvd sqn is >= last_rcvd_sqn + SQN_TIMEOUT_RANGE then DAD
+#define SQN_T uint16_t
+
+#define MIN_SQN 0
+#define MAX_SQN ((SQN_T)-1)
+#define DEF_SQN 0 /* causes seqno to be randomized */
+
+
+#define MIN_OGM0_PQ_BITS 0
+#define MAX_OGM0_PQ_BITS 5
+#define DEF_OGM0_PQ_BITS 5
+#define ARG_OGM0_PQ_BITS "path_quality_bits"
+
+
+
+
+
+
+#define MIN_MASK 1
+#define MAX_MASK 32
+#define ARG_MASK "netmask"
+#define ARG_NETW "network"
+
+
+#define ARG_DEBUG "debug"
+#define ARG_NO_FORK "no_fork"
+#define ARG_QUIT "quit"
+
+#define ARG_CONNECT "connect"
+#define ARG_RUN_DIR "runtime_dir"
+#define DEF_RUN_DIR "/var/run/bmx"
+
+
+extern uint32_t My_pid;
+#define BMX_ENV_LIB_PATH "BMX_LIB_PATH"
+#define BMX_DEF_LIB_PATH "/usr/lib"
+// e.g. sudo BMX_LIB_PATH="$(pwd)/lib" ./bmxd -d3 eth0:bmx
+#define BMX_ENV_DEBUG "BMX_DEBUG"
+
+
+
+
+#define ARG_HELP "help"
+#define ARG_VERBOSE_HELP "verbose_help"
+#define ARG_EXP "exp_help"
+#define ARG_VERBOSE_EXP "verbose_exp_help"
+
+#define ARG_VERSION "version"
+#define ARG_TRAILER "trailer"
+
+#define ARG_TEST "test"
+#define ARG_SHOW_CHANGED "options"
+
+
+#define ARG_DEV "dev"
+#define ARG_DEV_TTL "ttl"
+#define ARG_DEV_CLONE "clone"
+#define ARG_DEV_ANTDVSTY "ant_diversity"
+#define ARG_DEV_LL "linklayer"
+#define ARG_DEV_ANNOUNCE "announce"
+#define DEF_DEV_ANNOUNCE YES
+
+#define VAL_DEV_LL_LO 0
+#define VAL_DEV_LL_LAN 1
+#define VAL_DEV_LL_WLAN 2
+
+
+#define ARG_ORIGINATORS "originators"
+#define ARG_STATUS "status"
+#define ARG_LINKS "links"
+#define ARG_ROUTES "routes"
+#define ARG_INTERFACES "interfaces"
+
+#define ARG_THROW "throw"
+
+
+#define PROBE_RANGE 1024
+
+
+
+#define MAX_PWS 1024 /* 250 TBD: should not be larger until ogm->ws and neigh_node.packet_count (and related variables) is only 8 bit */
+#define MIN_PWS 32
+#define DEF_PWS 256 /* NBRF: NeighBor Ranking sequence Frame) sliding packet range of received orginator messages in squence numbers (should be a multiple of our word size) */
+#define ARG_PWS "path_window_size"
+extern int32_t my_pws; // my path window size used to quantify the end to end path quality between me and other nodes
+
+
+#define DEF_LWS 64
+#define MAX_LWS 250
+#define MIN_LWS 1
+#define ARG_LWS "link_window_size"
+extern int32_t local_lws; // my link window size used to quantify the link qualities to direct neighbors
+
+
+// the default link_lounge_size of 2 is good to compensate for ogi ~ but <= aggreg_interval
+#define MIN_RTQ_LOUNGE 0
+#define MAX_RTQ_LOUNGE 10
+#define DEF_RTQ_LOUNGE 2
+#define ARG_RTQ_LOUNGE "link_lounge_size"
+extern int32_t local_rtq_lounge;
+
+#define RQ_LINK_LOUNGE 0 /* may also be rtq_link_lounge */
+
+
+#define MIN_PATH_LOUNGE 0
+#define MAX_PATH_LOUNGE (0x01 << MAX_OGM0_PQ_BITS)
+#define DEF_PATH_LOUNGE (0x01 << DEF_OGM0_PQ_BITS)
+#define ARG_PATH_LOUNGE "path_lounge_size"
+extern int32_t my_path_lounge;
+
+#define MIN_PATH_HYST 0
+#define MAX_PATH_HYST (PROBE_RANGE)/2
+#define DEF_PATH_HYST 0
+#define ARG_PATH_HYST "path_hysteresis"
+extern int32_t my_path_hystere;
+
+#define MIN_RCNT_HYST 0
+#define MAX_RCNT_HYST (PROBE_RANGE)/2
+#define DEF_RCNT_HYST 10
+#define ARG_RCNT_HYST "fast_path_hysteresis"
+extern int32_t my_rcnt_hystere;
+
+#define DEF_RCNT_PWS 10
+#define MIN_RCNT_PWS 2
+#define MAX_RCNT_PWS 50
+#define ARG_RCNT_PWS "fast_path_window_size"
+extern int32_t my_rcnt_pws;
+
+
+#define DEF_RCNT_FK 4
+#define MIN_RCNT_FK 1
+#define MAX_RCNT_FK 11
+#define ARG_RCNT_FK "fast_path_faktor"
+extern int32_t my_rcnt_fk;
+
+#define MIN_LATE_PENAL 0
+#define MAX_LATE_PENAL 100
+#define DEF_LATE_PENAL 1
+#define ARG_LATE_PENAL "lateness_penalty"
+extern int32_t my_late_penalty;
+
+#define MIN_DROP_2HLOOP NO
+#define MAX_DROP_2HLOOP YES
+#define DEF_DROP_2HLOOP NO
+#define ARG_DROP_2HLOOP "drop_two_hop_loops"
+
+
+#define DEF_DAD_TO 50000
+#define MIN_DAD_TO 100
+#define MAX_DAD_TO 360000000
+#define ARG_DAD_TO "dad_timeout"
+extern int32_t dad_to;
+
+#define MIN_ASOCIAL NO
+#define MAX_ASOCIAL YES
+#define DEF_ASOCIAL NO
+
+#define DEF_TTL 50 /* Time To Live of OGM broadcast messages */
+#define MAX_TTL 63
+#define MIN_TTL 1
+#define ARG_TTL "ttl"
+extern int32_t my_ttl;
+
+#define DEF_WL_CLONES 200
+#define MIN_WL_CLONES 0
+#define MAX_WL_CLONES 400
+#define ARG_WL_CLONES "ogm_broadcasts"
+extern int32_t wl_clones;
+
+#define DEF_LAN_CLONES 100
+
+
+#define DEF_ASYM_WEIGHT 100
+#define MIN_ASYM_WEIGHT 0
+#define MAX_ASYM_WEIGHT 100
+#define ARG_ASYM_WEIGHT "asymmetric_weight"
+extern int32_t asym_weight;
+
+
+
+#define DEF_SYM_WEIGHT 80
+#define MIN_SYM_WEIGHT 0
+#define MAX_SYM_WEIGHT 100
+#define ARG_SYM_WEIGHT "symmetric_weight"
+extern int32_t sym_weight;
+
+#define DEF_ASYM_EXP 1
+#define MIN_ASYM_EXP 0
+#define MAX_ASYM_EXP 3
+#define ARG_ASYM_EXP "asymmetric_exp"
+
+#define DEF_HOP_PENALTY 1
+#define MIN_HOP_PENALTY 0
+#define MAX_HOP_PENALTY 100
+#define ARG_HOP_PENALTY "hop_penalty"
+extern int32_t my_hop_penalty;
+
+#define ARG_OGI_PWRSAVE "ogi_power_save"
+
+
+
+#define DEF_PURGE_TO 50000
+#define MIN_PURGE_TO 100
+#define MAX_PURGE_TO 864000000 /*10 days*/
+#define ARG_PURGE_TO "purge_timeout"
+// extern int32_t purge_to;
+
+#define MIN_DHASH_TO 300000
+#define DHASH_TO_TOLERANCE_FK 10
+
+
+
+
+
+#define OGM_AGGREG_SQN_CACHE_RANGE 64
+#define OGM_AGGREG_SQN_CACHE_WARN (OGM_AGGREG_SQN_CACHE_RANGE/2)
+#define OGM_AGGREG_ARRAY_BYTE_SIZE (OGM_AGGREG_SQN_CACHE_RANGE/8)
+
+
+
+
+
+
+#define SOURCE_VERSION "0.4-alpha" //put exactly one distinct word inside the string like "0.3-pre-alpha" or "0.3-rc1" or "0.3"
+
+#define COMPAT_VERSION 11
+
+#define IP4_STR_LEN 16
+
+#define MAX_DBG_STR_SIZE 1500
+#define OUT_SEQNO_OFFSET 1
+
+enum NoYes {
+ NO,
+ YES
+};
+
+enum ADGSN {
+ ADD,
+ DEL,
+ GET,
+ SET,
+ NOP
+};
+
+
+#define SUCCESS 0
+#define FAILURE -1
+
+extern void* FAILURE_POINTER;
+
+#define ILLEGAL_STATE "Illegal program state. This should not happen!"
+
+#ifndef REVISION_VERSION
+#define REVISION_VERSION 0
+#endif
+
+#define MAX_SELECT_TIMEOUT_MS 400 /* MUST be smaller than (1000/2) to fit into max tv_usec */
+#define CRITICAL_PURGE_TIME_DRIFT 5
+
+#define RAND_INIT_DELAY 50
+#define COMMON_OBSERVATION_WINDOW (DEF_OGM_INTERVAL*DEF_PWS)
+
+//#define TYPE_OF_WORD unsigned long /* you should choose something big, if you don't want to waste cpu */
+//#define WORD_BIT_SIZE ( sizeof(TYPE_OF_WORD) * 8 )
+
+#define MAX( a, b ) ( (a>b) ? (a) : (b) )
+#define MIN( a, b ) ( (a<b) ? (a) : (b) )
+
+#define U32_MAX 4294967296
+#define I32_MAX 2147483647
+#define U16_MAX 65536
+#define I16_MAX 32767
+#define U8_MAX 256
+#define I8_MAX 127
+
+
+
+#define LESS_SQN( a, b ) ( ((uint16_t)( (a) - (b) ) ) > I16_MAX )
+#define LSEQ_SQN( a, b ) ( ((uint16_t)( (b) - (a) ) ) <= I16_MAX )
+#define GREAT_SQN( a, b ) ( ((uint16_t)( (b) - (a) ) ) > I16_MAX )
+#define GRTEQ_SQN( a, b ) ( ((uint16_t)( (a) - (b) ) ) <= I16_MAX )
+
+#define LESS_U32( a, b ) ( ((uint32_t)( (a) - (b) ) ) > I32_MAX )
+#define LSEQ_U32( a, b ) ( ((uint32_t)( (b) - (a) ) ) <= I32_MAX )
+#define GREAT_U32( a, b ) ( ((uint32_t)( (b) - (a) ) ) > I32_MAX )
+#define GRTEQ_U32( a, b ) ( ((uint32_t)( (a) - (b) ) ) <= I32_MAX )
+
+#define MAX_SQ( a, b ) ( (GREAT_SQN( (a), (b) )) ? (a) : (b) )
+
+
+
+
+#define WARNING_PERIOD 20000
+
+#define MAX_PATH_SIZE 300
+#define MAX_ARG_SIZE 200
+
+
+extern uint32_t bmx_time;
+extern uint32_t bmx_time_sec;
+
+extern uint8_t on_the_fly;
+
+
+extern uint32_t s_curr_avg_cpu_load;
+
+
+
+
+
+extern struct dev_node *primary_if;
+
+
+extern struct orig_node my_orig_node;
+
+
+//extern struct list_head if_list;
+
+extern struct avl_tree dev_ip4_tree;
+extern struct avl_tree dev_name_tree;
+
+extern struct avl_tree link_tree;
+extern struct avl_tree link_dev_tree;
+
+extern struct avl_tree neigh_tree;
+
+extern struct avl_tree dhash_tree;
+extern struct avl_tree dhash_invalid_tree;
+
+extern struct avl_tree orig_tree;
+extern struct avl_tree blocked_tree;
+extern struct avl_tree blacklisted_tree;
+
+
+
+
+
+/**
+ * The most important data structures
+ */
+
+
+struct ogm_aggreg_node {
+
+ struct list_node list;
+
+ struct msg_ogm_adv *ogm_advs;
+
+ uint16_t aggregated_ogms;
+
+ SQN_T sqn;
+ uint8_t tx_attempts;
+ uint32_t tx_timestamp;
+};
+
+
+struct packet_buff {
+
+ //filled by wait4Event()
+#define pkt_buff_llip4 addr.sin_addr.s_addr
+
+ unsigned char packet_in[2001];
+ struct sockaddr_in addr;
+ struct timeval tv_stamp;
+ struct dev_node *iif;
+ int total_length;
+ uint8_t unicast;
+
+ //filled in by rx_packet()
+ char neigh_str[IP4_STR_LEN];
+ struct dev_node *oif;
+ struct link_node *ln;
+
+ //filled in by rx_frm_hey0_reps() or rx_frame()
+ struct link_dev_node *lndev;
+
+};
+
+
+
+
+struct task_node
+{
+ struct list_node list;
+ uint32_t expire;
+ void (* task) (void *fpara); // pointer to the function to be executed
+ void *data; //NULL or pointer to data to be given to function. Data will be freed after functio is called.
+};
+
+
+
+struct tx_task_node {
+ struct list_node list;
+
+ IP4_T dst_ip4;
+ IID_T myIID4x;
+ IID_T neighIID4x;
+ SQN_T sqn;
+ uint16_t frame_data_length_target; // because some variable msgs sizes may vary between scheduling and tx
+ uint8_t frame_type;
+ uint8_t tx_iterations;
+ uint32_t tx_timestamp;
+ struct dev_node *dev; // the outgoing interface to be used for transmitting
+
+};
+
+struct tx_timestamp_key {
+ IP4_T myIID4x_or_dest_ip4;
+ IID_T neighIID4x;
+ uint16_t type;
+};
+
+struct tx_timestamp_node {
+ struct tx_timestamp_key key;
+ uint32_t timestamp;
+};
+
+struct dev_node
+{
+ struct list_node list;
+ char name[IFNAMSIZ];
+ char name_phy[IFNAMSIZ];
+
+ char ip4_str[IP4_STR_LEN];
+
+ int32_t index;
+
+ uint8_t active;
+
+ uint16_t ip4_prefix_length;
+
+ uint32_t ip4_addr;
+ uint32_t ip4_tree_addr;
+ uint32_t ip4_netaddr;
+ uint32_t ip4_broad;
+ uint32_t ip4_netmask;
+
+ int ip4_mtu;
+
+ int32_t rp_filter_orig;
+ int32_t send_redirects_orig;
+
+
+ struct sockaddr_in ip4_unicast_addr;
+ struct sockaddr_in ip4_netwbrc_addr;
+
+ int32_t unicast_sock;
+ int32_t netwbrc_sock;
+ int32_t fullbrc_sock;
+
+ SQN_T packet_sqn;
+ SQN_T ogm_sqn;
+ uint32_t link_activity_timestamp;
+ uint32_t next_powersave_hardbeat;
+
+ uint16_t misc_flag;
+
+ struct list_head tx_tasks_list[FRAME_TYPE_ARRSZ]; // scheduled frames and messages
+ struct tx_task_node *my_tx_tasks[FRAME_TYPE_ARRSZ];
+ uint16_t tx_frames_data_len_target; // target (should) length of all currently scheduled tx messages (not including packet- or frame-headers
+
+ struct avl_tree tx_timestamp_tree; // timestamps of recently send messages, ordered by type and iid
+
+ // having a pointer right before the following array ensures 32/64 bit alignment.
+// unsigned char *aggregation_out;
+// unsigned char aggregation_out_buff[MAX_UDPD_SIZE + 1];
+
+// int16_t aggregation_len;
+
+
+ int8_t soft_conf_changed;
+ int8_t hard_conf_changed;
+
+ int8_t linklayer_conf;
+ int8_t linklayer;
+
+ int16_t send_clones_conf;
+ int16_t send_clones;
+
+ int16_t antenna_diversity_conf;
+ int16_t antenna_diversity;
+
+ int8_t announce_conf;
+ int8_t announce;
+
+};
+
+
+
+struct metric_algo {
+ SQN_T sqn_mask;
+ SQN_T sqn_steps; // e.g. 2
+ SQN_T sqn_window; // MUST be given as multiple of sqn_steps
+ SQN_T sqn_lounge; // MUST be given as multiple of sqn_steps e.g. 6
+ uint32_t regression; // e.g. window_size/2
+ uint32_t metric_max; // e.g. 256
+};
+
+#define SQR_RTQ 0x00
+#define SQR_RQ 0x01
+#define SQR_RANGE 0x02
+
+extern struct metric_algo link_metric_algo[SQR_RANGE];
+
+#define TQ_RATE( lndev, range) ( ((lndev)->mr[SQR_RQ].val ) ? \
+(MIN( ( ((range) * ((lndev)->mr[SQR_RTQ].val) ) / ((lndev)->mr[SQR_RQ].val) ), (range) )): \
+(0) )
+
+
+struct metric_record {
+ SQN_T clr; // SQN upto which waightedAverageVal has been purged
+ SQN_T set; // SQN which has been applied (if equals wa_pos) then wa_unscaled MUST NOT be set again!
+ uint32_t val;
+};
+
+
+
+
+
+struct link_key {
+ IP4_T llip4;
+ struct dev_node *dev;
+};
+
+struct link_dev_node {
+ struct list_node list;
+
+ struct link_key key;
+
+ uint32_t pkt_time_max;
+
+ uint32_t rtq_time_max;
+
+ struct link_node *link;
+
+// struct sq_record sqr[SQR_RANGE];
+
+ struct metric_record mr[SQR_RANGE];
+
+};
+
+/* MUST be allocated and initiated all or nothing !
+ * MUST be initiated with any unidirectional received OGM
+ * from a direct link NB
+ */
+/* Only OG interfaces which are direct link neighbors have a link_node
+ * Because neighboring interfaces may be seen via several of our own interfaces
+ * each link_node points to one or several link_node_dev structures
+ */
+struct link_node
+{
+ uint32_t llip4;
+ char llip4_str[IP4_STR_LEN];
+
+ uint32_t pkt_time_max;
+ SQN_T pkt_sqn_max;
+
+ SQN_T rq_sqn_max;
+ uint32_t rq_time_max;
+
+ struct neigh_node *neigh;
+
+ struct list_head lndev_list; // list with one link_node_dev element per link
+
+};
+
+
+
+/* Path statistics per neighbor via which OGMs of the parent orig_node have been received */
+/* Every OG has one ore several neigh_nodes. */
+struct router_node {
+
+ struct link_key key;
+
+// SQN_T ogm_sqn_to_be_send;
+
+ struct metric_record mr;
+
+// uint32_t metric;
+
+
+
+};
+
+struct orig_node {
+
+ // filled in by validate_new_link_desc0():
+
+ struct description_id id;
+
+ struct dhash_node *dhn;
+ struct description *desc0;
+// struct orig_node *orig_key;
+
+ uint32_t updated_timestamp; // last time this on's desc was succesfully updated
+// uint32_t referred_timestamp;// use dhn->referred_timestamp instead
+
+ SQN_T desc0_sqn;
+
+ SQN_T ogm_sqn_min;
+ SQN_T ogm_sqn_to_be_send;
+ SQN_T ogm_sqn_aggregated;
+
+ SQN_T ogm_sqn_range;
+
+// SQN_T ogm_sqn_mask;
+// SQN_T ogm_sqn_steps;
+
+ SQN_T ogm_sqn_max_rcvd;
+
+ uint8_t ogm_sqn_pq_bits;
+
+ struct metric_algo path_metric_algo;
+
+ uint8_t blocked;
+
+ // not yet filled in:
+
+ // filled in by process_desc0_tlvs()->
+
+ uint32_t primary_ip4;
+ char primary_ip4_str[IP4_STR_LEN];
+
+
+ // filled in by ???
+
+
+ struct link_key router_key; // the neighbor which is the currently best_next_hop
+ struct avl_tree router_tree;
+ uint32_t router_path_metric;
+
+
+/*
+ // old unused:
+
+
+
+
+ uint32_t last_aware; // when last valid ogm via this node was received
+ uint32_t last_valid_time; // when last valid ogm from this node was received
+
+ uint32_t first_valid_sec; // only used for debugging purposes
+
+ SQN_T last_decided_sqn;
+ SQN_T last_accepted_sqn; // last squence number acceppted for metric
+ SQN_T last_valid_sqn; // last and best known squence number
+ SQN_T last_wavg_sqn; // last sequence number used for estimating ogi
+
+ uint8_t last_path_ttl;
+ int8_t last_path_change_scenario;
+
+ uint8_t pws;
+ uint8_t path_lounge;
+ uint8_t path_hystere;
+ uint8_t late_penalty;
+
+ uint8_t rcnt_pws;
+ uint8_t rcnt_hystere;
+ uint8_t rcnt_fk;
+
+ uint32_t ogi_wavg;
+ uint32_t rt_changes;
+*/
+ /*size of plugin data is defined during intialization and depends on registered plugin-data hooks */
+ void *plugin_data[];
+
+};
+
+
+struct neigh_node {
+
+ struct neigh_node *nnkey;
+
+ struct avl_tree link_tree;
+
+ struct dhash_node *dhn;
+
+
+ // filled in by ???:
+
+ IID_T neighIID4me;
+ IID_T neighIID4neigh;
+
+ struct iid_repos neighIID4x_repos;
+
+ // filled in by ???:
+ struct link_dev_node *best_rtq;
+
+ // filled in by ???:
+ SQN_T ogm_aggregation_rcvd_max;
+ uint8_t ogm_aggregations_acked[OGM_AGGREG_ARRAY_BYTE_SIZE];
+ uint8_t ogm_aggregations_rcvd[OGM_AGGREG_ARRAY_BYTE_SIZE];
+
+};
+
+
+struct dhash_node {
+
+ struct description_hash dhash;
+
+ // filled in by rx_frm_hiX0_advs() -> get_orig_node():
+
+ uint32_t referred_timestamp; // last time this dhn was referred
+
+ struct neigh_node *neigh;
+
+ IID_T myIID4orig;
+
+
+ // filled in by rx_frm_hi40_reps():
+
+ struct orig_node *on;
+
+ // filled in by expire_dhash_node()
+ // uint8_t invalid; equal to on == NULL
+};
+
+
+struct black_node {
+
+ struct description_hash dhash;
+};
+
+
+
+
+/* list element to store all the disabled tunnel rule netmasks */
+struct throw_node
+{
+ struct list_node list;
+ uint32_t addr;
+ uint8_t netmask;
+};
+
+
+
+
+# define timercpy(d, a) (d)->tv_sec = (a)->tv_sec; (d)->tv_usec = (a)->tv_usec;
+
+
+
+enum {
+ CLEANUP_SUCCESS,
+ CLEANUP_FAILURE,
+ CLEANUP_MY_SIGSEV,
+ CLEANUP_RETURN
+};
+
+/*
+ * PARANOIA ERROR CODES:
+ * Negative numbers are used as SIGSEV error codes !
+ * Currently used numbers are: -500000 ... -500501
+ */
+
+#ifdef NO_PARANOIA
+#define paranoia( ... )
+#define assertion( ... )
+#define ASSERTION( ... )
+#else
+#define paranoia( code , problem ); do { if ( (problem) ) { cleanup_all( code ); } }while(0)
+#define assertion( code , condition ); do { if ( !(condition) ) { cleanup_all( code ); } }while(0)
+#ifdef EXTREME_PARANOIA
+#define ASSERTION( code , condition ); do { if ( !(condition) ) { cleanup_all( code ); } }while(0)
+#define CHECK_INTEGRITY( ... ) checkIntegrity()
+#else
+#define CHECK_INTEGRITY( ... )
+#define ASSERTION( ... )
+#endif
+#endif
+
+
+#ifndef PROFILING
+#define STATIC_FUNC static
+#else
+#define STATIC_FUNC
+#endif
+
+#ifdef STATIC_VARIABLES
+#define STATIC_VAR static
+#else
+#define STATIC_VAR
+#endif
+
+/***********************************************************
+ Data Infrastructure
+ ************************************************************/
+
+void blacklist_neighbor(struct packet_buff *pb);
+
+IDM_T blacklisted_neighbor(struct packet_buff *pb, struct description_hash *dhash);
+
+IDM_T validate_metric_algo(struct metric_algo *ma, struct ctrl_node *cn);
+
+uint32_t update_metric(struct metric_record *mr, struct metric_algo *ma, SQN_T sqn_in, SQN_T sqn_max, uint32_t probe);
+
+void update_link_node(struct link_node *ln, struct dev_node *iif, SQN_T sqn, SQN_T sqn_max, uint8_t sqr, uint32_t probe);
+
+void purge_orig(struct dev_node *only_dev, IDM_T only_expired);
+void free_orig_node(struct orig_node *on);
+
+IDM_T update_orig_metrics(struct packet_buff *pb, struct orig_node *on, IID_T orig_sqn);
+
+struct dhash_node* create_dhash_node(struct description_hash *dhash, struct orig_node *on);
+void free_dhash_node( struct dhash_node *dhn );
+void invalidate_dhash_node( struct dhash_node *dhn );
+
+
+IDM_T update_neigh_node(struct link_node *ln, struct dhash_node *dhn, IID_T neighIID4neigh);
+
+IDM_T update_neighIID4x_repository(struct neigh_node *neigh, IID_T neighIID4x, struct dhash_node *dhn);
+
+struct dev_node * get_bif(char *dev);
+
+void rx_packet( struct packet_buff *pb );
+/***********************************************************
+ Runtime Infrastructure
+************************************************************/
+void wait_sec_msec( uint32_t sec, uint32_t msec );
+
+void cleanup_all( int status );
+
+void upd_time( struct timeval *precise_tv );
+
+char *get_human_uptime( uint32_t reference );
+
+int32_t rand_num( uint32_t limit );
+
+int8_t terminating();
+
+uint8_t bits_count( uint32_t v );
+
+uint8_t bit_get(uint8_t *array, uint16_t array_bit_size, uint16_t bit);
+
+void bit_set(uint8_t *array, uint16_t array_bit_size, uint16_t bit, IDM_T value);
+
+void bit_clear(uint8_t *array, uint16_t array_bit_size, uint16_t begin, uint16_t end);
+
+void byte_clear(uint8_t *array, uint16_t array_size, uint16_t begin, uint16_t range);
+
+uint8_t is_zero(char *data, int len);
+
+
+/***********************************************************
+ Configuration data and handlers
+************************************************************/
+
+
+IDM_T validate_name( char* name );
+
+int32_t opt_update_description ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn );
Added: trunk/bmx/control.c
===================================================================
--- trunk/bmx/control.c (rev 0)
+++ trunk/bmx/control.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,3324 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <paths.h>
+
+#include "bmx.h"
+#include "plugin.h"
+#include "schedule.h"
+
+
+
+#define MAX_DBG_STR_SIZE 1500
+
+static char run_dir[MAX_PATH_SIZE] = DEF_RUN_DIR;
+
+static int32_t debug_level = -1;
+static int32_t dbg_mute_to;
+
+#define MIN_LOOP_INTERVAL 100
+#define MAX_LOOP_INTERVAL 10000
+#define DEF_LOOP_INTERVAL 1000
+static int32_t loop_interval = DEF_LOOP_INTERVAL;
+
+static int32_t loop_mode;
+
+#define MIN_PEDANT_CHK NO
+#define MAX_PEDANT_CHK YES
+#define DEF_PEDANT_CHK NO
+static int32_t pedantic_check = DEF_PEDANT_CHK;
+
+
+int unix_sock = 0;
+
+LIST_SIMPEL( ctrl_list, struct ctrl_node, list );
+
+struct list_head dbgl_clients[DBGL_MAX+1];
+static struct dbg_histogram dbgl_history[2][DBG_HIST_SIZE];
+
+static uint8_t debug_system_active = NO;
+
+
+static char *init_string = NULL;
+
+static int32_t Testing = NO;
+int32_t Load_config;
+
+char *prog_name;
+
+struct opt_type Patch_opt;
+
+LIST_SIMPEL( opt_list, struct opt_data, list ); // global opt_list
+
+
+int32_t Client_mode = NO; //this one must be initialized manually!
+
+static void remove_dbgl_node( struct ctrl_node *cn ) {
+
+ int8_t i;
+ struct dbgl_node *dn;
+ struct list_node *list_pos, *list_tmp, *list_prev;
+
+ for ( i = DBGL_MIN; i <= DBGL_MAX; i++ ) {
+
+ list_prev = (struct list_node *)&dbgl_clients[i];
+
+ list_for_each_safe( list_pos, list_tmp, (struct list_node *)&dbgl_clients[i] ) {
+
+ dn = list_entry(list_pos, struct dbgl_node, list);
+
+ if ( dn->cn == cn ) {
+ list_del_next(&dbgl_clients[i], list_prev);
+ debugFree( list_pos, -300049 );
+ } else {
+ list_prev = &dn->list;
+ }
+ }
+ }
+
+ cn->dbgl = -1;
+}
+
+
+static void add_dbgl_node( struct ctrl_node *cn, int dbgl ) {
+
+ if ( !cn || dbgl < DBGL_MIN || dbgl > DBGL_MAX )
+ return;
+
+ struct dbgl_node *dn = debugMalloc( sizeof( struct dbgl_node ), -300009 );
+ memset( dn, 0, sizeof( struct dbgl_node ) );
+
+ dn->cn = cn;
+ cn->dbgl = dbgl;
+ list_add_tail(&dbgl_clients[dbgl], &dn->list);
+
+ if ( dbgl == DBGL_SYS || dbgl == DBGL_CHANGES ) {
+ dbg( DBGL_CHANGES, DBGT_INFO, "resetting muted dbg history" );
+ memset( dbgl_history, 0, sizeof( dbgl_history ) );
+ }
+
+}
+
+
+static int daemonize() {
+
+ int fd;
+
+ switch( fork() ) {
+
+ case -1:
+ return -1;
+
+ case 0:
+ break;
+
+ default:
+ exit(EXIT_SUCCESS);
+
+ }
+
+ if ( setsid() == -1 )
+ return -1;
+
+ /* Ensure we are no session leader */
+ if ( fork() )
+ exit(EXIT_SUCCESS);
+
+
+ errno=0;
+ if ( chdir( "/" ) < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "could not chdir to /: %s", strerror(errno) );
+ }
+
+ if ( ( fd = open( _PATH_DEVNULL, O_RDWR, 0) ) != -1 ) {
+
+ dup2(fd, STDIN_FILENO);
+ dup2(fd, STDOUT_FILENO);
+ dup2(fd, STDERR_FILENO);
+
+ if ( fd > 2 )
+ close(fd);
+
+ }
+
+ return 0;
+
+}
+
+static int update_pid_file( void ) {
+
+ char tmp_path[MAX_PATH_SIZE+20] = "";
+ int tmp_fd = 0;
+
+ My_pid = getpid();
+
+ sprintf( tmp_path, "%s/pid", run_dir );
+
+ if ( (tmp_fd = open( tmp_path, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH )) < 0 ) { //check permissions of generated file
+
+ dbgf( DBGL_SYS, DBGT_ERR, "could not open %s - %s", tmp_path, strerror(errno) );
+ return FAILURE;
+ }
+
+ dprintf( tmp_fd, "%d\n", My_pid );
+
+ close ( tmp_fd );
+ return SUCCESS;
+}
+
+static void activate_debug_system( void ) {
+
+ if ( !debug_system_active ) {
+
+ /* daemonize */
+ if ( debug_level == -1 ) {
+
+ if ( daemonize() < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "can't fork to background: %s", strerror(errno) );
+ cleanup_all( -500093 );
+ }
+
+ // fork will result in a new pid
+ if ( update_pid_file() == FAILURE )
+ cleanup_all( -500132 );
+
+
+ } else {
+
+ struct ctrl_node *cn = create_ctrl_node( STDOUT_FILENO, NULL, NO/*admin rights not necessary*/ );
+
+ add_dbgl_node( cn, debug_level );
+
+ }
+
+ //dbg( DBGL_CHANGES, DBGT_INFO, "resetting muted dbg history" );
+ memset( dbgl_history, 0, sizeof( dbgl_history ) );
+
+ debug_system_active = YES;
+
+ dbgf_all( DBGT_INFO, "activated level %d", debug_level);
+
+ dbg( DBGL_CHANGES, DBGT_INFO, "BMX (BatMan-eXp) %s-rv%d (compatibility version %d): %s",
+ SOURCE_VERSION, REVISION_VERSION, COMPAT_VERSION, init_string);
+
+ }
+}
+
+struct ctrl_node *create_ctrl_node( int fd, void (*cn_fd_handler) (struct ctrl_node *), uint8_t authorized ) {
+
+ struct ctrl_node *cn = debugMalloc( sizeof(struct ctrl_node), -300010 );
+ memset( cn, 0, sizeof(struct ctrl_node) );
+
+ list_add_tail(&ctrl_list, &cn->list);
+
+ cn->fd = fd;
+ cn->cn_fd_handler = cn_fd_handler;
+ cn->dbgl = -1;
+ cn->authorized = authorized;
+
+ return cn;
+}
+
+
+void close_ctrl_node( uint8_t cmd, struct ctrl_node *ctrl_node ) {
+
+ struct list_node* list_pos, *list_prev, *list_tmp;
+ int trash;
+
+ list_prev = (struct list_node *)&ctrl_list;
+
+ list_for_each_safe( list_pos, list_tmp, &ctrl_list ) {
+
+ struct ctrl_node *cn = list_entry(list_pos, struct ctrl_node, list);
+
+ if ( ( cmd == CTRL_CLOSE_ERROR || cmd == CTRL_CLOSE_SUCCESS || cmd == CTRL_CLOSE_DELAY ) && cn == ctrl_node ) {
+
+ if ( cn->fd > 0 && cn->fd != STDOUT_FILENO ) {
+
+ cn->closing_stamp = MAX(bmx_time,1);
+ remove_dbgl_node( cn );
+
+ //leaving this after remove_dbgl_node() prevents debugging via broken -d4 pipe
+ dbgf_all( DBGT_INFO, "closed ctrl node fd %d with cmd %d", cn->fd, cmd );
+
+
+ if ( cmd == CTRL_CLOSE_SUCCESS )
+ trash=write( cn->fd, CONNECTION_END_STR, strlen(CONNECTION_END_STR) );
+
+ if ( cmd != CTRL_CLOSE_DELAY ) {
+ close( cn->fd );
+ cn->fd = 0;
+ change_selects();
+ }
+
+ }
+
+ return;
+
+ } else if ( ( cmd == CTRL_CLOSE_STRAIGHT && cn == ctrl_node ) ||
+ ( cmd == CTRL_PURGE_ALL ) ||
+ ( cmd == CTRL_CLEANUP && cn->closing_stamp &&/* cn->fd <= 0 && */
+ GREAT_U32( bmx_time, cn->closing_stamp + CTRL_CLOSING_TIMEOUT ) ) )
+ {
+
+ if ( cn->fd > 0 && cn->fd != STDOUT_FILENO ) {
+ remove_dbgl_node( cn );
+ //leaving this after remove_dbgl_node() prevents debugging via broken -d4 pipe
+ dbgf_all( DBGT_INFO, "closed ctrl node fd %d", cn->fd );
+
+ close( cn->fd );
+ cn->fd = 0;
+ change_selects();
+ }
+
+ list_del_next(&ctrl_list, list_prev);
+ debugFree( cn, -300050 );
+
+ } else {
+
+ list_prev = (struct list_node *)&cn->list;
+
+ }
+ }
+}
+
+
+void accept_ctrl_node( void ) {
+
+ struct sockaddr addr;
+ socklen_t addr_size = sizeof(struct sockaddr);
+ int32_t unix_opts;
+
+ int fd = accept( unix_sock, (struct sockaddr *)&addr, &addr_size);
+
+ if ( fd < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "can't accept unix client: %s", strerror(errno) );
+ return;
+ }
+
+ /* make unix socket non blocking */
+ unix_opts = fcntl( fd, F_GETFL, 0 );
+ fcntl( fd, F_SETFL, unix_opts | O_NONBLOCK );
+
+ create_ctrl_node( fd, NULL, YES );
+
+ change_selects();
+
+ dbgf_all( DBGT_INFO, "got unix control connection" );
+
+}
+
+
+
+void handle_ctrl_node( struct ctrl_node *cn ) {
+ char buff[MAX_UNIX_MSG_SIZE+1];
+
+ if ( cn->cn_fd_handler ) {
+ (cn->cn_fd_handler) (cn);
+ return;
+ }
+
+ errno=0;
+ int input = read( cn->fd, buff, MAX_UNIX_MSG_SIZE );
+
+ buff[input]='\0';
+
+ if ( input > 0 && input < MAX_UNIX_MSG_SIZE ) {
+
+ dbgf_all( DBGT_INFO, "rcvd ctrl stream via fd %d, %d bytes, auth %d: %s",
+ cn->fd, input, cn->authorized, buff );
+
+ if ( (apply_stream_opts( buff, OPT_CHECK, NO/*no cfg by default*/, cn ) == FAILURE) ||
+ (apply_stream_opts( buff, OPT_APPLY, NO/*no cfg by default*/, cn ) == FAILURE) )
+ {
+
+ dbg( DBGL_SYS, DBGT_ERR, "invalid ctrl stream via fd %d, %d bytes, auth %d: %s",
+ cn->fd, input, cn->authorized, buff );
+
+ close_ctrl_node( CTRL_CLOSE_ERROR, cn );
+ return;
+ }
+
+ respect_opt_order( OPT_APPLY, 0, 99, NULL, NO/*load_cofig*/, OPT_POST, 0/*probably closed*/ );
+
+ cb_plugin_hooks( NULL, PLUGIN_CB_CONF );
+
+ } else {
+
+ close_ctrl_node( CTRL_CLOSE_STRAIGHT, cn );
+
+ //leaving this after close_ctrl_node() -> remove_dbgl_node() prevents debugging via broken -d4 pipe
+ dbgf_all( DBGT_INFO, "closed fd %d, rcvd %d bytes, auth %d: %s",
+ cn->fd, input, cn->authorized, buff );
+
+ }
+
+ return;
+}
+
+
+#ifndef TESTDEBUG
+
+// returns DBG_HIST_NEW, DBG_HIST_MUTING, or DBG_HIST_MUTED
+static uint8_t check_dbg_history ( int8_t dbgl, char *s, uint16_t check_len ) {
+
+ static int r=0;
+ int i, unused_i, h;
+
+ check_len = MIN(check_len, DBG_HIST_TEXT_SIZE);
+
+ if ( !strlen(s) || !dbg_mute_to || !check_len )
+ return DBG_HIST_NEW;
+
+ if ( dbgl == DBGL_SYS )
+ h=0;
+
+ else if ( dbgl == DBGL_CHANGES )
+ h=1;
+
+ else
+ return DBG_HIST_NEW;
+
+
+ unused_i = -1;
+ i = r = (r+1) % DBG_HIST_SIZE;
+
+ do {
+
+ if ( dbgl_history[h][i].check_len == check_len &&
+ dbgl_history[h][i].expire == dbg_mute_to &&
+ !memcmp( s, dbgl_history[h][i].text, MIN(check_len, strlen(s)) ) ) {
+
+ if ( LESS_U32( bmx_time, dbgl_history[h][i].print_stamp + dbg_mute_to ) &&
+ GRTEQ_U32( bmx_time, dbgl_history[h][i].print_stamp ) )
+ {
+
+ dbgl_history[h][i].catched++;
+
+ if ( dbgl_history[h][i].catched == 2 )
+ return DBG_HIST_MUTING;
+
+ else
+ return DBG_HIST_MUTED;
+
+ }
+
+ dbgl_history[h][i].print_stamp = bmx_time;
+ dbgl_history[h][i].catched = 1;
+ return DBG_HIST_NEW;
+
+ }
+
+ if ( unused_i == -1 &&
+ ( dbgl_history[h][i].catched == 0 ||
+ !( LESS_U32( bmx_time, dbgl_history[h][i].print_stamp + dbg_mute_to ) &&
+ GRTEQ_U32( bmx_time, dbgl_history[h][i].print_stamp ) ) ) )
+ {
+
+ unused_i = i;
+ }
+
+
+ i = ( (i+1) % DBG_HIST_SIZE );
+
+ } while ( i != r );
+
+ if ( unused_i == -1 )
+ unused_i = r;
+
+ dbgl_history[h][unused_i].expire = dbg_mute_to;
+ dbgl_history[h][unused_i].check_len = check_len;
+ dbgl_history[h][unused_i].print_stamp = bmx_time;
+ dbgl_history[h][unused_i].catched = 1;
+ memcpy( dbgl_history[h][unused_i].text, s, MIN( check_len, strlen(s) ) );
+
+ return DBG_HIST_NEW;
+
+}
+
+
+
+#define MAX_DBG_WRITES 4
+void dbg_printf( struct ctrl_node *cn, char *last, ... ) {
+
+ if ( !cn || cn->fd <= 0 )
+ return;
+
+ static char s[ MAX_DBG_STR_SIZE + 1 ];
+ ssize_t w, out=0;
+ int i = 1;
+
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( s, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+
+ // CONNECTION_END_CHR is reserved for signaling connection end
+ paranoia( -500146, (strchr( s, CONNECTION_END_CHR ) ) );
+
+ errno=0;
+
+ while ( (w=write( cn->fd, s+out, strlen(s+out) )) != (ssize_t)strlen(s+out) ) {
+
+ if ( errno == EPIPE || i >= MAX_DBG_WRITES || cn->dbgl==DBGL_ALL ) {
+
+ if ( cn->dbgl != DBGL_ALL ) {
+ syslog( LOG_ERR, "failed %d times writing %d instead of %d/%d bytes (%s)! Giving up: %s\n",
+ i, (int)w, (int)strlen(s+out), (int)strlen(s), strerror(errno), s+out );
+ }
+
+ break;
+ }
+ i++;
+
+ wait_sec_msec( 0, 10 );
+
+ if( w > 0 )
+ out+=w;
+
+ errno=0;
+ }
+}
+
+
+static void debug_output ( uint32_t check_len, struct ctrl_node *cn, int8_t dbgl, int8_t dbgt, char const *f, char *s ) {
+
+ static uint16_t dbgl_all_msg_num = 0;
+ static char *dbgt2str[] = {"", "INFO ", "WARN ", "ERROR "};
+
+ struct list_node *list_pos;
+ int16_t dbgl_out[DBGL_MAX+1];
+ int i = 0, j;
+
+ uint8_t mute_dbgl_sys = DBG_HIST_NEW;
+ uint8_t mute_dbgl_changes = DBG_HIST_NEW;
+
+
+ if ( cn && cn->fd != STDOUT_FILENO )
+ dbg_printf( cn, "%s%s%s%s\n", dbgt2str[dbgt], f?f:"", f?"(): ":"", s );
+
+
+ if ( !debug_system_active ) {
+
+ if ( dbgl == DBGL_SYS || debug_level == DBGL_ALL || debug_level == dbgl )
+ printf( "[%d %8u] %s%s%s%s\n", My_pid, bmx_time, dbgt2str[dbgt], f?f:"", f?"(): ":"", s );
+
+ if ( dbgl == DBGL_SYS )
+ syslog( LOG_ERR, "%s%s%s%s\n", dbgt2str[dbgt], f?f:"", f?"(): ":"", s );
+
+ return;
+ }
+
+
+ if ( dbgl == DBGL_ALL ) {
+
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_ALL ] ) ) dbgl_out[i++] = DBGL_ALL;
+
+ } else if ( dbgl == DBGL_CHANGES ) {
+
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_CHANGES ] ) ) dbgl_out[i++] = DBGL_CHANGES;
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_ALL ] ) ) dbgl_out[i++] = DBGL_ALL;
+
+ } else if ( dbgl == DBGL_TEST ) {
+
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_TEST ] ) ) dbgl_out[i++] = DBGL_TEST;
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_ALL ] ) ) dbgl_out[i++] = DBGL_ALL;
+
+ } else if ( dbgl == DBGL_PROFILE ) {
+
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_PROFILE ] ) ) dbgl_out[i++] = DBGL_PROFILE;
+
+ } else if ( dbgl == DBGL_SYS ) {
+
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_SYS ] ) ) dbgl_out[i++] = DBGL_SYS;
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_CHANGES ] ) ) dbgl_out[i++] = DBGL_CHANGES;
+ if ( !LIST_EMPTY( &dbgl_clients[DBGL_ALL ] ) ) dbgl_out[i++] = DBGL_ALL;
+
+ if ( check_len )
+ mute_dbgl_sys = check_dbg_history( DBGL_SYS, s, check_len );
+
+ if ( mute_dbgl_sys != DBG_HIST_MUTED )
+ syslog( LOG_ERR, "%s%s%s%s\n", dbgt2str[dbgt], f?f:"", f?"(): ":"", s );
+
+ if ( mute_dbgl_sys == DBG_HIST_MUTING )
+ syslog( LOG_ERR, "%smuting further messages (with equal first %d bytes) for at most %d seconds\n",
+ dbgt2str[DBGT_WARN], check_len, dbg_mute_to/1000 );
+
+ }
+
+ for ( j = 0; j < i; j++ ) {
+
+ int level = dbgl_out[j];
+
+ if ( level == DBGL_ALL )
+ dbgl_all_msg_num++;
+
+ if ( level == DBGL_CHANGES && check_len &&
+ (mute_dbgl_changes = check_dbg_history( DBGL_CHANGES, s, check_len )) == DBG_HIST_MUTED )
+ continue;
+
+ if ( level == DBGL_SYS && mute_dbgl_sys == DBG_HIST_MUTED )
+ continue;
+
+
+ list_for_each ( list_pos, (struct list_node *)&(dbgl_clients[level]) ) {
+
+ struct dbgl_node *dn = list_entry(list_pos, struct dbgl_node, list);
+
+ if ( !dn->cn || dn->cn->fd <= 0 )
+ continue;
+
+ if ( level == DBGL_CHANGES ||
+ level == DBGL_TEST ||
+ level == DBGL_PROFILE ||
+ level == DBGL_SYS )
+ dbg_printf( dn->cn, "[%d %8u] ", My_pid, bmx_time );
+
+
+ if ( level == DBGL_ALL )
+ dbg_printf( dn->cn, "[%d %8u %5u] ", My_pid, bmx_time, dbgl_all_msg_num );
+
+
+ dbg_printf( dn->cn, "%s%s%s%s\n", dbgt2str[dbgt], f?f:"", f?"(): ":"", s );
+
+ if ( ( level == DBGL_SYS && mute_dbgl_sys == DBG_HIST_MUTING ) ||
+ ( level == DBGL_CHANGES && mute_dbgl_changes == DBG_HIST_MUTING ) )
+ dbg_printf( dn->cn,
+ "[%d %8u] %smuting further messages (with equal first %d bytes) for at most %d seconds\n",
+ My_pid, bmx_time, dbgt2str[DBGT_WARN], check_len, dbg_mute_to/1000 );
+
+ }
+ }
+}
+
+
+
+// this static array of char is used by all following dbg functions.
+static char dbg_string_out[ MAX_DBG_STR_SIZE + 1 ];
+
+void dbg ( int8_t dbgl, int8_t dbgt, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( 0, 0, dbgl, dbgt, 0, dbg_string_out );
+}
+
+void _dbgf ( int8_t dbgl, int8_t dbgt, char const *f, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( 0, 0, dbgl, dbgt, f, dbg_string_out );
+}
+
+void dbg_cn ( struct ctrl_node *cn, int8_t dbgl, int8_t dbgt, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( 0, cn, dbgl, dbgt, 0, dbg_string_out );
+}
+
+void _dbgf_cn ( struct ctrl_node *cn, int8_t dbgl, int8_t dbgt, char const *f, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( 0, cn, dbgl, dbgt, f, dbg_string_out );
+}
+
+void dbg_mute ( uint32_t check_len, int8_t dbgl, int8_t dbgt, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( check_len, 0, dbgl, dbgt, 0, dbg_string_out );
+}
+
+void _dbgf_all ( int8_t dbgt, char const *f, char *last, ... ) {
+ va_list ap;
+ va_start( ap, last );
+ vsnprintf( dbg_string_out, MAX_DBG_STR_SIZE, last, ap );
+ va_end( ap );
+ debug_output ( 0, 0, DBGL_ALL, dbgt, f, dbg_string_out );
+}
+
+uint8_t __dbgf_all( void ) {
+
+ if ( debug_level != DBGL_ALL && LIST_EMPTY( &dbgl_clients[DBGL_ALL] ) )
+ return NO;
+
+ return YES;
+}
+#endif
+
+
+
+
+
+
+
+int (*load_config_cb) ( uint8_t test, struct opt_type *opt, struct ctrl_node *cn ) = NULL;
+
+int (*save_config_cb) ( uint8_t del, struct opt_type *opt, char *parent, char *val, struct ctrl_node *cn ) = NULL;
+
+int (*derive_config) ( char *reference, char *derivation, struct ctrl_node *cn ) = NULL;
+
+
+void get_init_string( int g_argc, char **g_argv ) {
+
+ uint32_t size = 1, dbg_init_out = 0;
+ int i;
+ char *dbg_init_str;
+
+ for (i=0; i < g_argc; i++)
+ size+=( 1 + strlen( g_argv[i]) );
+
+ dbg_init_str = debugMalloc( size, -300012 );
+
+ for (i=0; i < g_argc; i++)
+ dbg_init_out = dbg_init_out + sprintf( (dbg_init_str + dbg_init_out), "%s ", g_argv[i] );
+
+ init_string = dbg_init_str;
+}
+
+
+static void free_init_string ( void ) {
+
+ if ( init_string )
+ debugFree( init_string, -300052 );
+
+ init_string = NULL;
+}
+
+#ifndef NODEPRECATED
+static int32_t opt_deprecated ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ char c = opt->short_name;
+
+ if ( cmd == OPT_ADJUST )
+ dbg( DBGL_SYS, DBGT_WARN, "option --%s%s%c%sis DEPRECATED and ignored!",
+ opt->long_name, c?", -":"", c?c:' ', c?" ":"" );
+
+ return SUCCESS;
+}
+#endif
+
+
+
+
+
+int32_t get_tracked_network( struct opt_type *opt, struct opt_parent *patch, char *out, uint32_t *ip, int32_t *mask, struct ctrl_node *cn ) {
+
+ struct opt_child *nc, *mc;
+ struct opt_parent *p = get_opt_parent_val( opt, patch->p_val );
+
+ if ( !p || !(nc = get_opt_child(get_option(opt,0,ARG_NETW), p) ) || !nc->c_val )
+ return FAILURE;
+
+ if ( !p || !(mc = get_opt_child(get_option(opt,0,ARG_MASK), p) ) || !mc->c_val )
+ return FAILURE;
+
+ sprintf( out, "%s/%s", nc->c_val, mc->c_val );
+
+ if ( str2netw( out, ip, '/', cn, mask, 32 ) == FAILURE )
+ return FAILURE;
+
+ return SUCCESS;
+}
+
+
+int32_t adj_patched_network( struct opt_type *opt, struct opt_parent *patch, char *out, uint32_t *ip, int32_t *mask, struct ctrl_node *cn ) {
+
+ struct opt_child *nc, *mc;
+ struct opt_parent *p;
+
+ if ( strpbrk( patch->p_val, "*'\"#\\/~?^°,;|<>()[]{}$%&=`´" ) ) {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "%s %s with /%s and /%s MUST NOT be named with special characters or a leading number",
+ opt->long_name, patch->p_val, ARG_MASK, ARG_NETW );
+ return FAILURE;
+ }
+
+ // obtain netmask:
+
+ p = get_opt_parent_val( opt, patch->p_val );
+
+ if ( (mc = get_opt_child( get_option(opt,0,ARG_MASK), patch ) ) && mc->c_val ) {
+
+ // obtain the just-given netmask:
+
+ if ( str2netw( mc->c_val, ip, '/', cn, 0,0 ) == SUCCESS ) {
+
+ // the 255.255.255.0 notation:
+
+ if ( *ip == htonl( 0xFFFFFFFF<<( 32 - (*mask=bits_count( *ip )) ) ) ) {
+ sprintf( out, "%d", *mask );
+ set_opt_child_val( mc, out );
+ } else {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "invalid %s %s /%s %s",
+ opt->long_name, patch->p_val, ARG_MASK, mc->c_val );
+ return FAILURE;
+ }
+
+ } else if ( (*mask=strtol(mc->c_val, NULL, 10)) ) {
+
+ // the prefix_len /24 notation:
+
+ if ( *mask < MIN_MASK || *mask > MAX_MASK ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "invalid prefix-length %s %s /%s %s",
+ opt->long_name, patch->p_val, ARG_MASK, mc->c_val );
+ return FAILURE;
+ }
+
+ } else {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "missing prefix-length %s %s /%s %s",
+ opt->long_name, patch->p_val, ARG_MASK, mc->c_val );
+ return FAILURE;
+ }
+
+ } else if ( p && (mc = get_opt_child(get_option(opt,0,ARG_MASK), p) ) && mc->c_val ) {
+
+ // obtain the already-configured netmask:
+ *mask = strtol( mc->c_val , NULL , 10 );
+
+ } else {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "missing %s %s /%s",
+ opt->long_name, patch->p_val, ARG_MASK );
+ return FAILURE;
+ }
+
+
+ // obtain the network:
+
+ if ((nc = get_opt_child(get_option(opt, 0, ARG_NETW), patch)) && nc->c_val) {
+
+ // obtain the just-given network:
+
+ sprintf( out, "%s/%d", nc->c_val, *mask );
+ if ( str2netw( out, ip, '/', cn, mask, 32 ) == FAILURE ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "invalid patch %s %s /%s %s",
+ opt->long_name, patch->p_val, ARG_NETW, mc->c_val );
+ return FAILURE;
+ }
+
+ set_opt_child_val( nc, ipStr( validate_net_mask( *ip, *mask, 0 ) ) );
+
+ } else if ( p && (nc=get_opt_child( get_option(opt,0,ARG_NETW), p )) && nc->c_val ) {
+
+ // obtain the already-configured network:
+
+ sprintf( out, "%s/%d", nc->c_val, *mask );
+ if ( str2netw( out, ip, '/', cn, mask, 32 ) == FAILURE ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "invalid trac %s %s /%s %s",
+ opt->long_name, patch->p_val, ARG_NETW, mc->c_val );
+ return FAILURE;
+ }
+
+ } else {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "missing %s %s /%s",
+ opt->long_name, patch->p_val, ARG_NETW );
+
+ return FAILURE;
+ }
+
+ sprintf( out, "%s/%d", nc->c_val, *mask );
+ return SUCCESS;
+}
+
+static char* nextword( char *s ) {
+
+ uint32_t i = 0;
+ uint8_t found_gap = NO;
+
+ if ( !s )
+ return NULL;
+
+ for( i=0; i<strlen(s); i++ ) {
+
+ if ( s[i] == '\0' || s[i] == '\n' )
+ return NULL;
+
+ if ( !found_gap && ( s[i]==' ' || s[i]=='\t' ))
+ found_gap = YES;
+
+ if ( found_gap && ( s[i]!=' ' && s[i]!='\t' ) )
+ return &(s[i]);
+
+ }
+
+ return NULL;
+
+}
+
+static char *debugWordDup( char* word, int32_t tag ) {
+
+ if ( !word )
+ return NULL;
+
+ char *ret = debugMalloc( wordlen(word)+1, tag );
+ snprintf( ret, wordlen(word)+1, "%s", word );
+ return ret;
+}
+
+
+
+
+static void strchange( char *s, char i, char o ) {
+
+ char *p;
+ while ( s && (p=strchr( s, i )) )
+ p[0] = o;
+
+}
+
+
+static int32_t end_of_cmd_stream( struct opt_type *opt, char *s ) {
+
+ char test[MAX_ARG_SIZE]="";
+ snprintf( test, wordlen(s)+1, "%s", s );
+ strchange( test, '-', '_' );
+
+ if ( opt->opt_t != A_PS0 )
+ s = nextword(s);
+ else if ( wordlen(s)>1 && !strncasecmp( test, opt->long_name, wordlen(opt->long_name) ) )
+ s = nextword(s);
+ else if ( wordlen(s)>1 )
+ s = s+1;
+ else
+ s = nextword(s);
+
+ if ( s && ( s[0] != EOS_DELIMITER || wordlen(s)>1 ) )
+ return NO;
+
+ return YES;
+
+}
+
+
+static int8_t is_valid_opt_ival( struct opt_type *opt, char *s, struct ctrl_node *cn ) {
+
+ if ( opt->imin == opt->imax )
+ return SUCCESS;
+
+ char* invalids = NULL;
+
+ errno=0;
+ int ival = strtol(s, &invalids , 10);
+
+ if ( wordlen(s) < 1 ||
+ ival < opt->imin || ival > opt->imax ||
+ invalids!=(s+wordlen(s)) ||
+ errno == ERANGE || errno == EINVAL )
+ {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "--%s value %d is invalid! Must be %d <= <value> <= %d !",
+ opt->long_name, ival, opt->imin, opt->imax );
+
+ return FAILURE;
+ }
+
+ return SUCCESS;
+}
+
+
+/*
+ * call given function for each applied option
+ * thus: if several hna are active func() is called once for each
+ */
+int8_t func_for_each_opt( struct ctrl_node *cn, void *data, char* func_name,
+ int8_t (*func) ( struct ctrl_node *cn, void *data, struct opt_type *opt, struct opt_parent *p, struct opt_child *c ) )
+{
+
+ struct list_node *list_pos;
+
+ list_for_each( list_pos, &opt_list ) {
+
+ struct opt_type *opt = (struct opt_type *)list_entry( list_pos, struct opt_data, list );
+
+ if ( /* !opt->help || we are also interested in uncommented configurations*/ !opt->long_name )
+ continue;
+
+ struct list_node *p_pos;
+
+ list_for_each( p_pos, &(opt->d.parents_instance_list) ) {
+
+ struct opt_parent *p = (struct opt_parent*)list_entry( p_pos, struct opt_parent, list );
+
+ if ( (*func)( cn, data, opt, p, NULL ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "func()=%s with %s %s failed",
+ func_name, opt->long_name, p->p_val );
+
+ return FAILURE;
+ }
+
+ struct list_node *c_pos;
+
+ list_for_each( c_pos, &p->childs_instance_list ) {
+
+ struct opt_child *c = (struct opt_child*)list_entry( c_pos, struct opt_child, list );
+
+ if ( (*func)( cn, data, opt, p, c ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "func()=%s with %s %s %s %s failed",
+ func_name, opt->long_name, p->p_val, c->c_opt->long_name, c->c_val );
+
+ return FAILURE;
+ }
+ }
+ }
+ }
+
+ return SUCCESS;
+}
+
+
+static void show_opts_help( uint8_t all_opts, uint8_t verbose, struct ctrl_node *cn ) {
+
+ if ( !cn )
+ return;
+
+ dbg_printf(cn, "\n");
+ dbg_printf(cn, "Usage: %s [LONGOPT [%c]VAL] | [-SHORTOPT[SHORTOPT...] [%c]VAL] ...\n",
+ prog_name, ARG_RESET_CHAR , ARG_RESET_CHAR);
+ dbg_printf(cn, " e.g. %s -cid8\n", prog_name);
+ dbg_printf(cn, " e.g. %s -c a 192.200.200.1/24\n", prog_name);
+ dbg_printf(cn, " e.g. %s -c %s my-vpn /n=192.168.115.0 /m=24\n", prog_name, ARG_THROW);
+ dbg_printf(cn, " e.g. %s -c %s -my-vpn \n", prog_name, ARG_THROW);
+ dbg_printf(cn, "\n");
+ //dbg_printf(cn, "\nValid options are:\n" );
+
+ struct list_node *list_pos;
+
+ list_for_each( list_pos, &opt_list ) {
+
+ struct list_node *pos;
+ struct opt_type *opt = (struct opt_type *)list_entry( list_pos, struct opt_data, list );
+ char sn[5], st[3 * MAX_ARG_SIZE], defaults[100];
+
+ if ( !( all_opts || opt->short_name ) )
+ continue;
+
+#ifndef NODEPRECATED
+ if ( opt->call_custom_option == opt_deprecated )
+ continue;
+#endif
+
+ if ( opt->long_name && opt->help && !opt->parent_name ) {
+
+
+ if ( opt->short_name )
+ snprintf( sn,5, ", -%c", opt->short_name );
+ else
+ *sn = '\0';
+
+ sprintf( st, "--%s%s %s ", opt->long_name, sn, opt->syntax ? opt->syntax: "" );
+
+ if ( opt->opt_t != A_PS0 && opt->imin != opt->imax )
+ sprintf( defaults, "def: %-6d range: [ %d %s %d ]",
+ opt->idef, opt->imin, opt->imin+1 == opt->imax ? ",": "...", opt->imax );
+ else
+ defaults[0]='\0';
+
+ dbg_printf( cn, "\n%-40s %s\n", st, defaults );
+
+ if ( verbose )
+ dbg_printf( cn, " %s\n", opt->help );
+
+
+
+ } else if ( !opt->long_name && opt->help ) {
+
+ dbg_printf( cn, "\n%s \n",opt->help );
+
+ }
+
+
+ list_for_each( pos, &opt->d.childs_type_list ) {
+
+ struct opt_type *c_opt = (struct opt_type *)list_entry( pos, struct opt_data, list );
+
+ if ( !c_opt->parent_name || !c_opt->help )
+ continue;
+
+#ifndef NODEPRECATED
+ if ( c_opt->call_custom_option == opt_deprecated )
+ continue;
+#endif
+
+ if ( c_opt->short_name )
+ snprintf( sn,5, ", /%c", c_opt->short_name );
+ else
+ *sn = '\0';
+
+ sprintf( st, " /%s%s %s ", c_opt->long_name, sn, c_opt->syntax ? c_opt->syntax: "" );
+
+ if ( c_opt->opt_t != A_PS0 && c_opt->imin != c_opt->imax )
+ sprintf( defaults, "def: %-6d range: [ %d %s %d ]",
+ c_opt->idef, c_opt->imin, c_opt->imin+1 == c_opt->imax ? ",": "...", c_opt->imax );
+ else
+ defaults[0]='\0';
+
+ dbg_printf( cn, "%-40s %s\n", st, defaults );
+
+ if ( verbose )
+ dbg_printf( cn, " %s\n", c_opt->help );
+
+ }
+ }
+
+ dbg_printf( cn, "\n");
+
+ if ( all_opts ) {
+ dbg_printf( cn, "Environment variables (e.g. sudo %s=/usr/src/bmx/lib %s -d3 eth0:bmx ):\n",
+ BMX_ENV_LIB_PATH, prog_name );
+
+ dbg_printf(cn, "\t%s\n", BMX_ENV_LIB_PATH );
+ dbg_printf(cn, "\t%s\n", BMX_ENV_DEBUG );
+ }
+
+ dbg_printf( cn, "\n");
+
+}
+
+void register_option( struct opt_type *opt ) {
+
+ dbgf_all( DBGT_INFO, "%s", (opt&&opt->long_name) ? opt->long_name : "" );
+
+ struct opt_type *tmp_opt = NULL;
+ struct list_node *tmp_pos;
+
+ // these are the valid combinations:
+ if ( !(
+ //ival is validated and if valid assigned by call_option()
+ ( (opt->ival) && (opt->call_custom_option) && (opt->long_name) ) ||
+ //ival is validated and if valid assigned
+ ( (opt->ival) && !(opt->call_custom_option) && (opt->long_name) ) ||
+ //call_option() is called
+ ( !(opt->ival) && (opt->call_custom_option) && (opt->long_name) ) ||
+ //
+ ( !(opt->ival) && !(opt->call_custom_option) && !(opt->long_name) && opt->help )
+ ) )
+ goto failure;
+
+
+ // arg_t A_PS0 with no function can only be YES/NO:
+ paranoia( -500111, ( opt->opt_t == A_PS0 && opt->ival && ( opt->imin != NO || opt->imax != YES || opt->idef != NO ) ) );
+
+ // arg_t A_PS0 can not be stored
+ paranoia( -500112, ( opt->opt_t == A_PS0 && opt->cfg_t != A_ARG ) );
+
+ paranoia( -500113, ( opt->order < 0 || opt->order > 99 ) );
+
+ paranoia( -500114, ( (opt->parent_name && strchr( opt->parent_name, '-')) || (opt->long_name && strchr( opt->long_name, '-')) ) );
+
+
+ memset( &(opt->d), 0, sizeof( struct opt_data ) );
+
+ if ( opt->ival )
+ *opt->ival = opt->idef;
+
+ if ( opt->parent_name ) {
+
+ list_for_each( tmp_pos, &opt_list ) {
+ tmp_opt = (struct opt_type *)list_entry( tmp_pos, struct opt_data, list );
+
+ if ( tmp_opt->long_name == opt->parent_name )
+ break;
+ else
+ tmp_opt = NULL;
+ }
+
+ if ( opt->opt_t != A_CS1 || !tmp_opt || tmp_opt->opt_t != A_PMN )
+ goto failure;
+
+ opt->d.parent_opt = tmp_opt;
+
+ list_add_tail( &tmp_opt->d.childs_type_list, &opt->d.list );
+
+ } else {
+
+ LIST_INIT_HEAD( opt->d.childs_type_list, struct opt_data, list);
+ LIST_INIT_HEAD( opt->d.parents_instance_list, struct opt_parent, list);
+
+ if ( opt->order ) {
+
+ struct list_node *prev_pos = (struct list_node *)&opt_list;
+
+ list_for_each( tmp_pos, &opt_list ) {
+
+ tmp_opt = (struct opt_type *)list_entry( tmp_pos, struct opt_data, list );
+
+ if ( tmp_opt->order > opt->order ) {
+ list_add_after(&opt_list, prev_pos, &opt->d.list);
+ break;
+ } else {
+ prev_pos = &tmp_opt->d.list;
+ tmp_opt = NULL;
+ }
+ }
+ }
+
+ if ( !tmp_opt)
+ list_add_tail(&opt_list, &opt->d.list);
+
+ }
+
+ if ( opt->call_custom_option && ((opt->call_custom_option)( OPT_REGISTER, 0, opt, 0,0 )) == FAILURE ) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "%s failed!", opt->long_name );
+ goto failure;
+ }
+
+
+ return;
+
+failure:
+
+ dbgf( DBGL_SYS, DBGT_ERR, "invalid data, tmp_opt: %c %s - option %c %s",
+ (tmp_opt && tmp_opt->short_name)?tmp_opt->short_name:'?',
+ (tmp_opt && tmp_opt->long_name)?tmp_opt->long_name:"??",
+ (opt && opt->short_name)?opt->short_name:'?', (opt && opt->long_name) ?opt->long_name:"??" );
+
+ paranoia( -500091, YES );
+}
+
+
+static void remove_option( struct opt_type *opt ) {
+
+ struct list_node *tmp_pos, *list_pos, *prev_pos;
+
+ del_opt_parent( opt, NULL );
+
+ prev_pos = (struct list_node *)&opt_list;
+
+ list_for_each_safe( list_pos, tmp_pos, &opt_list ) {
+
+ struct opt_type *tmp_opt = (struct opt_type *)list_entry( list_pos, struct opt_data, list );
+
+ if ( opt == tmp_opt ) {
+
+ if ( !opt->parent_name && opt->call_custom_option &&
+ ((opt->call_custom_option)( OPT_UNREGISTER, 0, opt, 0,0 )) == FAILURE )
+ {
+ dbgf( DBGL_SYS, DBGT_ERR, "%s failed!", opt->long_name );
+ }
+
+ list_del_next(&opt_list, prev_pos);
+ return;
+
+ } else {
+
+ prev_pos = &tmp_opt->d.list;
+
+ }
+
+ }
+
+ dbgf( DBGL_SYS, DBGT_ERR, "%s no matching opt found", opt->long_name );
+}
+
+
+void register_options_array ( struct opt_type *fixed_options, int size ) {
+
+ int i = 0;
+ int i_max = size / sizeof( struct opt_type );
+
+ paranoia( -500149, ((size % sizeof( struct opt_type )) != 0 ) );
+
+ while ( i<i_max && (fixed_options[i].long_name || fixed_options[i].help) )
+ register_option( &(fixed_options[i++]) );
+
+}
+
+/*
+void remove_options_array ( struct opt_type *fixed_options ) {
+
+ int i = 0;
+
+ while ( fixed_options[i].long_name != NULL || fixed_options[i].help != NULL )
+ remove_option( &(fixed_options[i++]) );
+
+}
+*/
+
+
+struct opt_type *get_option( struct opt_type *parent_opt, uint8_t short_opt, char *sin ) {
+
+ struct list_node *list_pos;
+ int32_t len = 0;
+ struct list_head *list;
+ struct opt_type *opt = NULL;
+ char *equalp = NULL;
+ char s[MAX_ARG_SIZE]="";
+
+ if ( parent_opt && short_opt )
+ goto get_option_failure;
+
+ if ( !sin || wordlen(sin)+1 >= MAX_ARG_SIZE )
+ goto get_option_failure;
+
+ snprintf( s, wordlen(sin)+1, "%s", sin );
+ strchange( s, '-', '_' );
+
+ if ( short_opt )
+ len = 1;
+ else if ( (equalp = index( s, '=' )) && equalp < s+wordlen(s) )
+ len = equalp - s;
+ else
+ len = wordlen(s);
+
+
+ if ( parent_opt == NULL )
+ list = &opt_list;
+ else
+ list = &parent_opt->d.childs_type_list;
+
+ dbgf_all( DBGT_INFO, "searching %s", s );
+
+ list_for_each( list_pos, list ) {
+
+ opt = (struct opt_type *)list_entry( list_pos, struct opt_data, list );
+
+ if ( !opt->long_name )
+ continue;
+
+ else if ( !short_opt && len == (int)strlen( opt->long_name ) && !strncasecmp( s, opt->long_name, len ) )
+ break;
+
+ else if ( !short_opt && len == 1 && s[0] == opt->short_name && on_the_fly && opt->dyn_t != A_INI )
+ break;
+
+ else if ( !short_opt && len == 1 && s[0] == opt->short_name && !on_the_fly && opt->dyn_t != A_DYN )
+ break;
+
+ else if ( short_opt && s[0] == opt->short_name && on_the_fly && opt->dyn_t != A_INI )
+ break;
+
+ else if ( short_opt && s[0] == opt->short_name && !on_the_fly && opt->dyn_t != A_DYN )
+ break;
+
+
+ opt = NULL;
+ }
+
+ if ( opt && opt->long_name ) {
+ dbgf_all( DBGT_INFO,
+ "Success! short_opt %d, opt: %s %c, type %d, dyn %d, ival %d, imin %d, imax %d, idef %d",
+ short_opt, opt->long_name ? opt->long_name : "-", opt->short_name ? opt->short_name : '-',
+ opt->opt_t, opt->dyn_t,
+ opt->ival ? *opt->ival : 0, opt->imin, opt->imax, opt->idef );
+
+ return opt;
+ }
+
+
+get_option_failure:
+
+ dbgf_all( DBGT_WARN, "Failed! called with parent %s, opt %c %s, len %d",
+ parent_opt?"YES":"NO", (short_opt ? s[0]: '-'), (!short_opt ? s : "-"), len );
+
+ return NULL;
+
+}
+
+
+
+struct opt_child *get_opt_child ( struct opt_type *opt, struct opt_parent *p ) {
+
+ struct list_node *pos;
+
+ paranoia( -500026, ( opt->opt_t != A_CS1 ) );
+
+ paranoia( -500119, ( !p ) );
+
+
+ list_for_each( pos, &(p->childs_instance_list) ) {
+
+ struct opt_child *c = list_entry( pos, struct opt_child, list );
+
+ if ( c->c_opt == opt )
+ return c;
+
+ }
+
+ return NULL;
+}
+
+void set_opt_child_val( struct opt_child *c, char *val ) {
+
+ if ( val && c->c_val && wordsEqual( c->c_val, val ) )
+ return;
+
+ if ( c->c_val )
+ debugFree( c->c_val, -300053 );
+
+ c->c_val = NULL;
+
+ if ( val)
+ c->c_val = debugWordDup(val, -300013);
+}
+
+static void set_opt_child_ref( struct opt_child *c, char *ref ) {
+
+ if ( ref && c->c_ref && wordsEqual( c->c_ref, ref ) )
+ return;
+
+ if ( c->c_ref )
+ debugFree( c->c_ref, -300054 );
+
+ c->c_ref = NULL;
+
+ if ( ref )
+ c->c_ref = debugWordDup( ref, -300014 );
+}
+
+
+static void del_opt_child_save( struct list_node *prev, struct list_node *pos, struct opt_parent *p ) {
+
+ struct opt_child *c = list_entry( pos, struct opt_child, list );
+
+ list_del_next(&p->childs_instance_list, prev);
+
+ set_opt_child_val( c, NULL );
+ set_opt_child_ref( c, NULL );
+
+ debugFree( pos, -300055 );
+ return;
+}
+
+static void del_opt_child( struct opt_parent *p, struct opt_type *opt ) {
+
+ struct list_node *pos, *tmp, *prev;
+
+ prev = (struct list_node*)&p->childs_instance_list;
+
+ list_for_each_safe( pos, tmp, &(p->childs_instance_list) ) {
+
+ struct opt_child *c = list_entry( pos, struct opt_child, list );
+
+ if ( !opt || c->c_opt == opt )
+ del_opt_child_save( prev, pos, p );
+ else
+ prev = pos;
+ }
+}
+
+static struct opt_child *add_opt_child( struct opt_type *opt, struct opt_parent *p ) {
+
+ struct opt_child *c = debugMalloc( sizeof( struct opt_child ), -300017 );
+ memset( c, 0, sizeof(struct opt_child) );
+
+ c->c_opt = opt;
+ c->parent_instance = p;
+ list_add_tail(&p->childs_instance_list, &c->list);
+
+ return c;
+}
+
+
+
+
+void set_opt_parent_val( struct opt_parent *p, char *val ) {
+
+ if ( val && p->p_val && wordsEqual( p->p_val, val ) )
+ return;
+
+ if ( p->p_val )
+ debugFree( p->p_val, -300056 );
+
+ p->p_val = NULL;
+
+ if ( val)
+ p->p_val = debugWordDup( val, -300015 );
+}
+
+void set_opt_parent_ref( struct opt_parent *p, char *ref ) {
+
+ if ( ref && p->p_ref && wordsEqual( p->p_ref, ref ) )
+ return;
+
+ if ( p->p_ref )
+ debugFree( p->p_ref, -300057 );
+
+ p->p_ref = NULL;
+
+ if ( ref )
+ p->p_ref = debugWordDup( ref, -300016 );
+}
+
+
+struct opt_parent *add_opt_parent( struct opt_type *opt ) {
+
+ struct opt_parent *p = debugMalloc( sizeof( struct opt_parent ), -300018 );
+ memset( p, 0, sizeof(struct opt_parent) );
+
+ LIST_INIT_HEAD( p->childs_instance_list, struct opt_child, list );
+
+ list_add_tail(&opt->d.parents_instance_list, &p->list);
+
+ return p;
+}
+
+static void del_opt_parent_save( struct opt_type *opt, struct list_node *prev, struct list_node *pos ) {
+
+ struct opt_parent *p = list_entry( pos, struct opt_parent, list );
+
+ list_del_next(&opt->d.parents_instance_list, prev);
+
+ del_opt_child( p, NULL );
+
+ set_opt_parent_val( p, NULL );
+ set_opt_parent_ref( p, NULL );
+
+ debugFree( p, -300058 );
+}
+
+void del_opt_parent( struct opt_type *opt, struct opt_parent *parent ) {
+
+ struct list_node *pos, *tmp, *prev = (struct list_node*)&(opt->d.parents_instance_list);
+
+ list_for_each_safe( pos, tmp, &(opt->d.parents_instance_list) ) {
+
+ struct opt_parent *p = list_entry( pos, struct opt_parent, list );
+
+ if ( !parent || p == parent )
+ del_opt_parent_save( opt, prev, pos );
+ else
+ prev = pos;
+ }
+}
+
+
+struct opt_parent *get_opt_parent_val ( struct opt_type *opt, char *val ) {
+
+ struct opt_parent *p = NULL;
+ struct list_node *pos;
+
+ paranoia( -500118, ( opt->cfg_t == A_ARG ) );
+
+// paranoia( -500117, ( (opt->opt_t == A_PS0 || opt->opt_t == A_PS1) && opt->d.found_parents > 1 ) );
+ paranoia( -500117, ( (opt->opt_t == A_PS0 || opt->opt_t == A_PS1) && opt->d.parents_instance_list.items > 1 ) );
+
+ list_for_each( pos, &(opt->d.parents_instance_list) ) {
+
+ p = list_entry( pos, struct opt_parent, list );
+
+ if ( !val || wordsEqual( p->p_val, val ) )
+ return p;
+
+ }
+
+ return NULL;
+}
+
+struct opt_parent *get_opt_parent_ref ( struct opt_type *opt, char *ref ) {
+
+ struct opt_parent *p = NULL;
+ struct list_node *pos;
+
+ paranoia( -500124, ( opt->cfg_t == A_ARG ) );
+
+// paranoia( -500116, ( (opt->opt_t == A_PS0 || opt->opt_t == A_PS1) && opt->d.found_parents > 1 ) );
+ paranoia( -500116, ( (opt->opt_t == A_PS0 || opt->opt_t == A_PS1) && opt->d.parents_instance_list.items > 1 ) );
+
+ list_for_each( pos, &(opt->d.parents_instance_list) ) {
+
+ p = list_entry( pos, struct opt_parent, list );
+
+ if ( ref && wordsEqual( p->p_ref, ref ) )
+ return p;
+
+ }
+
+ return NULL;
+}
+
+static struct opt_parent *dup_opt_parent ( struct opt_type *opt, struct opt_parent *p ) {
+
+ struct opt_parent *dup_p = add_opt_parent( opt );
+ set_opt_parent_val ( dup_p, p->p_val );
+ set_opt_parent_ref ( dup_p, p->p_ref );
+
+ dup_p->p_diff = p->p_diff;
+
+ struct list_node *pos;
+ list_for_each( pos, &(p->childs_instance_list) ) {
+
+ struct opt_child *c = list_entry( pos, struct opt_child, list );
+
+ struct opt_child *dup_c = add_opt_child( c->c_opt, dup_p );
+ set_opt_child_val( dup_c, c->c_val );
+ set_opt_child_ref( dup_c, c->c_ref );
+ }
+
+ return dup_p;
+}
+
+
+
+
+char *opt_cmd2str[] = {
+ "OPT_REGISTER",
+ "OPT_PATCH",
+ "OPT_ADJUST",
+ "OPT_CHECK",
+ "OPT_APPLY",
+ "OPT_SET_POST",
+ "OPT_POST",
+ "OPT_UNREGISTER"
+};
+
+
+int32_t check_apply_parent_option( uint8_t del, uint8_t cmd, uint8_t _save, struct opt_type *opt, char *in, struct ctrl_node *cn ) {
+
+ int32_t ret;
+
+ paranoia( -500102, ( (cmd != OPT_CHECK && cmd != OPT_APPLY) || opt->parent_name ) );
+
+ struct opt_parent *p = add_opt_parent( &Patch_opt );
+
+ if ((ret = call_option(del, OPT_PATCH, _save, opt, p, in, cn)) == FAILURE ||
+ call_option(del, OPT_ADJUST, _save, opt, p, in, cn) == FAILURE ||
+ call_option(del, cmd, _save, opt, p, in, cn) == FAILURE)
+ ret = FAILURE;
+
+ del_opt_parent( &Patch_opt, p );
+
+ dbgf_all( DBGT_INFO, "del:%d, %s, save:%d, %s %s returns: %d",
+ del, opt_cmd2str[cmd], _save, opt->long_name, in, ret );
+
+ return ret;
+}
+
+
+
+static int32_t call_opt_patch( uint8_t ad, struct opt_type *opt, struct opt_parent *patch, char *strm, struct ctrl_node *cn ) {
+
+ dbgf_all( DBGT_INFO, "ad:%d opt:%s val:%s strm:%s",
+ ad, opt->long_name, patch->p_val, strm );
+
+ if ( opt->opt_t == A_PS0 ) {
+
+ patch->p_diff = ((ad==ADD) ? ADD : DEL);
+
+ } else if ( opt->opt_t == A_PS1 || opt->opt_t == A_PMN || opt->opt_t == A_CS1 ) {
+
+ char *ref = NULL;
+ char tmp[MAX_ARG_SIZE];
+
+ // assign one or more values
+ if ( ad == ADD || opt->opt_t == A_PMN ) {
+
+ if ( !strm || !wordlen(strm) || strm[0] == EOS_DELIMITER )
+ return FAILURE;
+
+ if ( strm && wordlen(strm) > strlen( REFERENCE_KEY_WORD ) &&
+ !strncmp( strm, REFERENCE_KEY_WORD, strlen( REFERENCE_KEY_WORD ) ) )
+ {
+ ref = strm;
+
+ if ( ad == ADD ) {
+
+ if ( !derive_config || derive_config( ref, tmp, cn ) == FAILURE || !wordlen(strm) ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "%s. Could not derive reference %s",
+ derive_config ? "invalid config" : "undefined callback", strm );
+ return FAILURE;
+ }
+
+ strm = tmp;
+
+ } else if ( ad == DEL ) {
+
+ struct opt_parent *p_track = get_opt_parent_ref( opt, strm );
+
+ if ( !p_track || !p_track->p_val ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "Could not derive reference %s from tracked options", strm );
+ return FAILURE;
+ }
+
+ strm = p_track->p_val;
+ }
+ }
+
+ if ( is_valid_opt_ival( opt, strm, cn ) == FAILURE )
+ return FAILURE;
+
+ }
+
+ if ( opt->opt_t == A_PS1 || opt->opt_t == A_PMN ) {
+
+ set_opt_parent_val( patch, strm );
+ set_opt_parent_ref( patch, ref );
+
+ patch->p_diff = ((ad==ADD) ? ADD : DEL);
+
+ } else if ( opt->opt_t == A_CS1 ) {
+
+ struct opt_child *c = add_opt_child( opt, patch );
+
+ if ( ad == ADD )
+ set_opt_child_val( c, strm );
+
+ set_opt_child_ref( c, ref );
+ }
+ }
+
+ return SUCCESS;
+}
+
+
+static int32_t cleanup_patch( struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ uint8_t del = patch->p_diff;
+ char *val = patch->p_val;
+
+ dbgf_all( DBGT_INFO, "del %d opt %s val %s", del, opt->long_name, val );
+
+ if ( opt->cfg_t == A_ARG )
+ return SUCCESS;
+
+ if ( opt->opt_t == A_PS0 ) {
+
+// if ( (del && !opt->d.found_parents) || (!del && opt->d.found_parents) )
+ if ((del && !opt->d.parents_instance_list.items) || (!del && opt->d.parents_instance_list.items))
+ patch->p_diff = NOP;
+
+
+ } else if ( opt->opt_t == A_PS1 ) {
+
+// if ( (del && !opt->d.found_parents) || (!del && get_opt_parent_val( opt, val )) )
+ if ((del && !opt->d.parents_instance_list.items) || (!del && get_opt_parent_val(opt, val)))
+ patch->p_diff = NOP;
+
+
+ } else if ( opt->opt_t == A_PMN ) {
+
+ struct opt_parent *p_track = NULL;
+ struct list_node *c_pos, *c_tmp;
+ struct list_node *c_prev = (struct list_node*)&patch->childs_instance_list;
+
+ list_for_each_safe( c_pos, c_tmp, &patch->childs_instance_list ) {
+
+ struct opt_child *c = list_entry( c_pos, struct opt_child, list );
+ struct opt_child *c_track = NULL;
+ uint8_t c_del = c->c_val ? ADD : DEL;
+
+ p_track = NULL;
+
+ dbgf_all( DBGT_INFO, "p_val:%s", patch->p_val );
+
+ if ( (p_track = get_opt_parent_val( opt, val )) )
+ c_track = get_opt_child( c->c_opt, p_track );
+
+ if ( ( c_del && !c_track ) ||
+ ( !c_del && c_track && wordsEqual( c_track->c_val, c->c_val ) ) )
+ {
+ del_opt_child_save( c_prev, c_pos, patch );
+ } else {
+ c_prev = c_pos;
+ }
+ }
+
+
+ p_track = get_opt_parent_val( opt, val );
+
+ if ( ( del && !p_track ) || ( !del && p_track ) )
+ patch->p_diff = NOP;
+
+ } else {
+ return FAILURE;
+ }
+
+ return SUCCESS;
+}
+
+
+
+static int32_t _opt_connect ( uint8_t cmd, struct opt_type *opt, struct ctrl_node *cn, char *curr_strm_pos ) {
+
+ char tmp_path[MAX_PATH_SIZE+20] = "";
+ char unix_buff[MAX_UNIX_MSG_SIZE+1] = "";
+ int trash;
+
+ dbgf_all( DBGT_INFO, "cmd %s, opt_name %s, stream %s",
+ opt_cmd2str[cmd], opt->long_name, curr_strm_pos );
+
+ if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ if ( !curr_strm_pos )
+ cleanup_all( -500141 );
+
+ sprintf( tmp_path, "%s/sock", run_dir );
+
+ struct sockaddr_un unix_addr;
+
+ memset( &unix_addr, 0, sizeof(struct sockaddr_un) );
+ unix_addr.sun_family = AF_LOCAL;
+ strcpy( unix_addr.sun_path, tmp_path );
+
+
+ if ( strlen( curr_strm_pos ) + 4 + strlen( ARG_TEST ) > sizeof( unix_buff ) ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "message too long: %s", curr_strm_pos );
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+ if ( cmd == OPT_CHECK )
+ return SUCCESS;
+
+ Client_mode = YES;
+
+ do {
+
+ dbgf_all( DBGT_INFO, "called with %s",curr_strm_pos);
+
+ if ( strlen(curr_strm_pos) > strlen(ARG_CONNECT) &&
+ !strncmp( curr_strm_pos, ARG_CONNECT, strlen(ARG_CONNECT) ) &&
+ (curr_strm_pos+strlen(ARG_CONNECT))[0] == ' ' )
+ {
+ sprintf( unix_buff, "%s %c", nextword(curr_strm_pos), EOS_DELIMITER );
+
+ } else if ( strlen(curr_strm_pos) > strlen(ARG_CONNECT) &&
+ !strncmp( curr_strm_pos, ARG_CONNECT, strlen(ARG_CONNECT) ) &&
+ (curr_strm_pos+strlen(ARG_CONNECT))[0] == '=' )
+ {
+ sprintf( unix_buff, "%s %c", curr_strm_pos+strlen(ARG_CONNECT)+1 , EOS_DELIMITER );
+
+ } else if ( strlen(curr_strm_pos) > 1 && curr_strm_pos[0] == opt->short_name && curr_strm_pos[1] == ' ' ) {
+ sprintf( unix_buff, "%s %c", nextword(curr_strm_pos), EOS_DELIMITER );
+
+ } else if ( strlen(curr_strm_pos) > 1 && curr_strm_pos[0] == opt->short_name && curr_strm_pos[1] != ' ' ) {
+ sprintf( unix_buff, "-%s %c", curr_strm_pos+1, EOS_DELIMITER );
+
+ } else {
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "invalid connect stream %s",curr_strm_pos);
+ return FAILURE;
+ }
+
+ unix_sock = socket( AF_LOCAL, SOCK_STREAM, 0 );
+
+ /* make unix_sock socket non blocking */
+ int sock_opts = fcntl( unix_sock, F_GETFL, 0 );
+ fcntl( unix_sock, F_SETFL, sock_opts | O_NONBLOCK );
+
+
+ if ( connect ( unix_sock, (struct sockaddr *)&unix_addr, sizeof(struct sockaddr_un) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "can't connect to unix socket '%s': %s ! Is bmxd running on this host ?",
+ tmp_path, strerror(errno) );
+
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+ if ( write( unix_sock, unix_buff, strlen( unix_buff ) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't write to unix socket: %s", strerror(errno) );
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+ //printf("::::::::::::::::: from %s begin :::::::::::::::::::\n", tmp_path );
+
+ if ( loop_mode )
+ trash=system( "clear" );
+
+ int32_t recv_buff_len = 0;
+
+ while ( !terminating() ) {
+
+ recv_buff_len = 0;
+
+ fd_set unix_wait_set;
+
+ FD_ZERO(&unix_wait_set);
+ FD_SET(unix_sock, &unix_wait_set);
+
+ struct timeval to = {0, 100000};
+
+ select( unix_sock+1, &unix_wait_set, NULL, NULL, &to );
+
+ if ( !FD_ISSET( unix_sock, &unix_wait_set ) )
+ continue;
+
+ do {
+ errno = 0;
+ recv_buff_len = read( unix_sock, unix_buff, MAX_UNIX_MSG_SIZE );
+
+ if ( recv_buff_len > 0 ) {
+
+ char *p;
+ unix_buff[recv_buff_len] = '\0';
+
+ if ( (p=strchr( unix_buff, CONNECTION_END_CHR )) ) {
+ *p='\0';
+ printf( "%s", unix_buff );
+ break;
+
+ }
+
+ printf( "%s", unix_buff );
+ }
+
+ } while ( recv_buff_len > 0 );
+
+ if ( recv_buff_len < 0 && ( errno == EWOULDBLOCK || errno == EAGAIN ) )
+ continue;
+
+ if ( recv_buff_len < 0 ) {
+ dbgf(DBGL_SYS, DBGT_INFO, "sock returned %d errno %d: %s",
+ recv_buff_len, errno, strerror(errno) );
+ }
+
+ if ( recv_buff_len <= 0 )
+ cleanup_all( CLEANUP_FAILURE );
+
+ break;
+ }
+
+ close( unix_sock );
+ unix_sock = 0;
+
+ if ( loop_mode && !terminating() )
+ wait_sec_msec( loop_interval/1000, loop_interval%1000 );
+
+
+ } while ( loop_mode && !terminating() );
+
+ cleanup_all( CLEANUP_SUCCESS );
+
+
+ }
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_connect ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ char tmp_path[MAX_PATH_SIZE+20] = "";
+
+ if ( cmd == OPT_SET_POST && !on_the_fly ) {
+
+ // create unix sock:
+
+ struct sockaddr_un unix_addr;
+
+ sprintf( tmp_path, "%s/sock", run_dir );
+
+ memset( &unix_addr, 0, sizeof(struct sockaddr_un) );
+ unix_addr.sun_family = AF_LOCAL;
+ strcpy( unix_addr.sun_path, tmp_path );
+
+ // Testing for open and used unix socket
+
+ unix_sock = socket( AF_LOCAL, SOCK_STREAM, 0 );
+
+ if ( connect ( unix_sock, (struct sockaddr *)&unix_addr, sizeof(struct sockaddr_un) ) < 0 ) {
+
+ dbgf_all( DBGT_INFO, "found unbound %s, going to unlink and reuse!", tmp_path );
+
+ close( unix_sock );
+ unlink( tmp_path );
+ unix_sock = socket( AF_LOCAL, SOCK_STREAM, 0 );
+
+ } else {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "%s busy! Probably bmxd is already running! Use [--%s %s] -c ... to connect to a running bmxd",
+ tmp_path, ARG_RUN_DIR, run_dir );
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+
+ if ( bind ( unix_sock, (struct sockaddr *)&unix_addr, sizeof (struct sockaddr_un) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't bind unix socket '%s': %s", tmp_path, strerror(errno) );
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+ if ( listen( unix_sock, 10 ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't listen unix socket '%s': %s", tmp_path, strerror(errno) );
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+ if ( update_pid_file() == FAILURE )
+ return FAILURE;
+
+ }
+
+ return SUCCESS;
+}
+
+static int32_t call_opt_apply( uint8_t cmd, uint8_t save, struct opt_type *opt, struct opt_parent *_patch, char *in, struct ctrl_node *cn ) {
+
+ paranoia( -500154, ( cmd != OPT_CHECK && cmd != OPT_APPLY ) );
+
+ //cleanup_patch will change the patch, so we'll work with a duplicate and destroy it afterwards
+ struct opt_parent *patch = dup_opt_parent( &Patch_opt, _patch );
+
+ dbgf_all( DBGT_INFO, "%s save=%d %s p_diff=%d p_val:%s p_ref:%s strm:%s",
+ opt_cmd2str[cmd], save, opt->long_name, patch->p_diff, patch->p_val, patch->p_ref, in );
+
+ if ( cleanup_patch( opt, patch, cn ) == FAILURE )
+ goto call_opt_apply_error;
+
+ if ( patch->p_diff == NOP && LIST_EMPTY( &(patch->childs_instance_list) ) ) {
+ del_opt_parent( &Patch_opt, patch );
+ return SUCCESS;
+ }
+
+ // keep this check after cleanup_patch and p_diff==NOP and list_empty check to let config_reload
+ // apply all unchanged options
+
+ if ( (!on_the_fly && opt->dyn_t == A_DYN) || ( on_the_fly && opt->dyn_t == A_INI) ) {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "--%s%s%c can %s be applied at startup",
+ opt->long_name, opt->short_name ? ", -" : "", opt->short_name ? opt->short_name : ' ',
+ on_the_fly ? "ONLY" : "NOT" );
+
+ goto call_opt_apply_error;
+ }
+
+
+ if ( opt->call_custom_option == opt_connect ) {
+
+ if ( _opt_connect( cmd, opt, cn, in ) == FAILURE )
+ goto call_opt_apply_error;
+
+
+ } else if ( cmd == OPT_CHECK ) {
+
+ if ( opt->call_custom_option &&
+ (opt->call_custom_option)(OPT_CHECK, save, opt, patch, cn) == FAILURE) {
+
+ goto call_opt_apply_error;
+ }
+
+
+
+ } else if ( cmd == OPT_APPLY ) {
+
+ if ( opt->auth_t == A_ADM ) {
+
+ dbg(DBGL_CHANGES, DBGT_INFO, "--%-22s %-30s", opt->long_name, patch->p_val);
+
+ dbgf_all( DBGT_INFO, "--%-22s %-30s (%s order %d)",
+ opt->long_name, patch->p_val, opt_cmd2str[ cmd ], opt->order );
+ }
+
+ if ( opt->ival && patch->p_diff == DEL )
+ *(opt->ival) = opt->idef;
+
+ else if ( opt->opt_t == A_PS0 && opt->ival && patch->p_diff == ADD )
+ *(opt->ival) = opt->imax;
+
+ else if ( opt->opt_t != A_PS0 && opt->ival && patch->p_diff == ADD )
+ *(opt->ival) = strtol( patch->p_val, NULL , 10 );
+
+ if ( opt->call_custom_option &&
+ (opt->call_custom_option)( OPT_APPLY, save, opt, patch, cn ) == FAILURE )
+ {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "failed setting the already succesfully tested option %s to %s",
+ opt->long_name, patch->p_val );
+
+ // this may happen when:
+ // - overwriting a config-file option with a startup-option (pain in the ass!)
+ // - configuring the same PMN option twice in one command-line
+ goto call_opt_apply_error;
+ }
+
+
+ }
+
+ del_opt_parent( &Patch_opt, patch );
+ return SUCCESS;
+
+call_opt_apply_error:
+
+ del_opt_parent( &Patch_opt, patch );
+ return FAILURE;
+}
+
+
+/* this table lists what could happen and how its' handled in track_opt_parent():
+
+patch tracked patch tracked config-
+p_val t_val p_ref t_ref -> file track
+ value: value: ref:
+
+DEL/0 x x x DEL DEL DEL | if ( !p_val && t_val )
+
+DEL/0 NULL x x NOP NOP NOP | else if ( !p_val && !t_val )
+
+A A A A NOP NOP NOP | else if ( p_val && p_val == t_val && p_ref == t_ref )
+A A 0 0 NOP NOP NOP |
+
+ | else [if ( p_val && (p_val != t_val || p_ref != t_ref )]
+ |
+A A A B ref value ref | | if ( p_ref )
+A A A 0 ref value ref | |
+A B/NULL A A (*) ref value ref | |
+A B/NULL A B (-) ref value ref | |
+A B/NULL A 0 (-) ref value ref | |
+ |
+A A 0 B value value 0 | | else [if( !p_ref)]
+A B/NULL 0 0 value NOP 0 | |
+A B/NULL 0 A (*) value value 0 | |
+
+(*) in these cases, when configuring parent-options
+we have to reset the old (currently active) tracked t_val option
+before configuring the new patched p_val parent value
+This has already been done during call_option( cmd==CHECK || cmd==APPLY )
+
+(-) impossible to configue in one step for parent-options
+
+*/
+static int32_t track_opt_parent( uint8_t cmd, uint8_t save, struct opt_type *p_opt, struct opt_parent *p_patch, struct ctrl_node *cn ) {
+
+ struct list_node *pos;
+ struct opt_parent *p_reftr = get_opt_parent_ref( p_opt, p_opt->opt_t == A_PMN ? p_patch->p_ref : NULL );
+ struct opt_parent *p_track = get_opt_parent_val( p_opt, p_opt->opt_t == A_PMN ? p_patch->p_val : NULL );
+
+ paranoia( -500125, ( p_reftr && p_track && p_reftr != p_track ) );
+
+ p_track = p_track ? p_track : p_reftr;
+
+ dbgf_all( DBGT_INFO, "%s %s save=%d patch_diff:%d patch_val:%s patch_ref:%s track_val:%s track_ref:%s",
+ opt_cmd2str[cmd], p_opt->long_name, save, p_patch->p_diff,
+ p_patch->p_val, p_patch->p_ref, p_track?p_track->p_val:"-", p_track?p_track->p_ref:"-");
+
+ if ( p_patch->p_diff == DEL && p_track ) {
+
+ if ( cmd==OPT_APPLY ) {
+
+ if ( save && save_config_cb )
+ save_config_cb( DEL, p_opt, p_track->p_ref ? p_track->p_ref : p_track->p_val, NULL, cn );
+
+ del_opt_parent( p_opt, p_track );
+ }
+
+ } else {
+
+ uint8_t changed = NO;
+
+ if ( p_patch->p_diff == DEL && !p_track ) {
+
+ if ( save ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "--%s %s does not exist", p_opt->long_name, p_patch->p_val );
+ return FAILURE;
+ }
+
+ return SUCCESS;
+
+ } else if ( ( p_patch->p_diff == ADD && p_patch->p_val && p_track && wordsEqual( p_patch->p_val, p_track->p_val ) ) &&
+ ( ( p_patch->p_ref && p_track->p_ref && wordsEqual( p_patch->p_ref, p_track->p_ref) ) ||
+ ( !p_patch->p_ref && !p_track->p_ref ) ) )
+ {
+
+ } else if ( p_patch->p_val /*&& (patch_c->c_ref || !patch_c->c_ref)*/ ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ if ( !p_track ) {
+ p_track = add_opt_parent( p_opt );
+ set_opt_parent_val( p_track, p_patch->p_val );
+ set_opt_parent_ref( p_track, p_patch->p_ref );
+ }
+
+ if ( save && save_config_cb )
+ save_config_cb( ADD, p_opt,
+ p_track->p_ref ? p_track->p_ref : p_track->p_val,
+ p_patch->p_ref ? p_patch->p_ref : p_patch->p_val, cn );
+
+ set_opt_parent_val( p_track, p_patch->p_val );
+ set_opt_parent_ref( p_track, p_patch->p_ref );
+ }
+ changed=YES;
+
+ } else {
+ paranoia( -500121, YES );
+ }
+
+ if ( cmd == OPT_APPLY && changed && p_opt->auth_t == A_ADM )
+ dbg_cn( cn, DBGL_CHANGES, DBGT_INFO, "--%-22s %c%-30s",
+ p_opt->long_name, p_patch->p_diff==DEL?'-':' ', p_patch->p_val);
+
+ if ( p_track ) {
+
+ list_for_each( pos, &p_patch->childs_instance_list ) {
+
+ uint8_t changed_child=NO;
+ char *save_val = p_track->p_ref ? p_track->p_ref : p_track->p_val;
+ struct opt_child *c_patch = list_entry( pos, struct opt_child, list );
+ struct opt_child *c_track = get_opt_child( c_patch->c_opt, p_track );
+
+
+ if ( !c_patch->c_val && c_track ) {
+
+ if ( cmd == OPT_APPLY ) {
+ if ( save && save_config_cb && c_track->c_opt->cfg_t != A_ARG )
+ save_config_cb( DEL, c_track->c_opt, save_val, c_track->c_ref ? c_track->c_ref : c_track->c_val, cn );
+
+ del_opt_child( p_track, c_track->c_opt );
+ }
+ changed_child=changed=YES;
+
+ } else if ( !c_patch->c_val && !c_track ) {
+
+ if ( save ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "--%s %s /%s does not exist",
+ p_opt->long_name, p_patch->p_val, c_patch->c_opt->long_name );
+ return FAILURE;
+ }
+
+ } else if ( ( c_patch->c_val && c_track && wordsEqual(c_patch->c_val, c_track->c_val) ) &&
+ ( ( c_patch->c_ref && c_track->c_ref && wordsEqual( c_patch->c_ref, c_track->c_ref) ) ||
+ ( !c_patch->c_ref && !c_track->c_ref ) ) )
+ {
+
+ dbgf_all( DBGT_INFO, "--%s %s /%s %s already configured",
+ p_opt->long_name, p_patch->p_val, c_patch->c_opt->long_name, c_patch->c_val );
+
+ } else if ( c_patch->c_val ) {
+
+ if ( cmd == OPT_APPLY ) {
+ if ( save && save_config_cb && c_patch->c_opt->cfg_t != A_ARG )
+ save_config_cb( ADD, c_patch->c_opt, save_val, c_patch->c_ref ? c_patch->c_ref : c_patch->c_val, cn );
+
+ if ( !c_track )
+ c_track = add_opt_child( c_patch->c_opt, p_track );
+
+ set_opt_child_val( c_track, c_patch->c_val );
+ set_opt_child_ref( c_track, c_patch->c_ref );
+ }
+
+ changed_child=changed=YES;
+
+ } else {
+
+ paranoia( -500122, YES );
+ }
+
+ if ( cmd == OPT_APPLY && changed_child && c_patch->c_opt->auth_t == A_ADM )
+ dbg_cn( cn, DBGL_CHANGES, DBGT_INFO, "--%-22s %-30s /%-22s %c%-30s",
+ p_opt->long_name, p_patch->p_val,
+ c_patch->c_opt->long_name, c_patch->c_val?' ':'-', c_patch->c_val );
+
+ }
+ }
+
+ // be pedantic only after startup (!on_the_fly) and not reload-config (!save)
+ if ( !changed && on_the_fly && save && pedantic_check ) {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "--%s %s already configured",
+ p_opt->long_name, p_patch->p_val );
+
+ // actually here we can be pedantic or not because cleanup_patch()
+ // have already checked for double applied options
+ return FAILURE;
+ }
+ }
+
+ return SUCCESS;
+}
+
+int32_t call_option( uint8_t ad, uint8_t cmd, uint8_t save, struct opt_type *opt, struct opt_parent *patch, char *in, struct ctrl_node *cn ) {
+
+ dbgf_all( DBGT_INFO, "%s (cmd %s del %d save %d parent_name %s order %d) p_val: %s in: %s",
+ opt->long_name, opt_cmd2str[ cmd ], ad, save, opt->parent_name, opt->order, patch?patch->p_val:"-", in );
+
+ if ( !opt ) // might be NULL when referring to disabled plugin functionality
+ return SUCCESS;
+
+ paranoia( -500104, ( !( ad == ADD || ad == DEL ) ) );
+
+ paranoia( -500103, ( ( cmd == OPT_PATCH || cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) && !patch ) );
+
+ paranoia( -500147, ( ( cmd == OPT_PATCH || cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) && !cn ) );
+
+ if ( ( cmd == OPT_PATCH || cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) &&
+ !cn->authorized && opt->auth_t == A_ADM )
+ {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "insufficient permissions to use command %s", opt->long_name );
+ return FAILURE;
+ }
+
+ if ( ad == DEL && ( /*!on_the_fly this is what concurrent -r and -g configurations do || */
+ /* opt->dyn_t == A_INI this is what conf-reload tries ||*/ opt->cfg_t == A_ARG ) ) {
+ dbg( DBGL_SYS, DBGT_ERR, "option %s can not be resetted during startup!", opt->long_name );
+ return FAILURE;
+ }
+
+
+ if ( (opt->pos_t==A_END || opt->pos_t==A_ETE) && in && !end_of_cmd_stream( opt, in ) ) {
+
+ if ( cn ) {
+ dbg_cn( cn, DBGL_CHANGES, DBGT_ERR, "--%s%s%c MUST be last option before line feed",
+ opt->long_name, opt->short_name?", -":"", opt->short_name?opt->short_name:' ' );
+ }
+
+ goto call_option_failure;
+ }
+
+
+ if ( cmd == OPT_PATCH ) {
+
+ if ( (call_opt_patch( ad, opt, patch, in, cn )) == FAILURE )
+ goto call_option_failure;
+
+ if ( ( opt->pos_t == A_EAT || opt->pos_t == A_ETE ) && in )
+ return strlen( in );
+ else
+ return SUCCESS;
+
+
+ } else if ( cmd == OPT_ADJUST ) {
+
+ if ( opt->call_custom_option &&
+ ((opt->call_custom_option)( OPT_ADJUST, 0, opt, patch, cn )) == FAILURE )
+ goto call_option_failure;
+ else
+ return SUCCESS;
+
+
+ } else if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ paranoia( -500105, ( opt->parent_name ) );
+
+ paranoia( -500128, ( opt->cfg_t != A_ARG && ( opt->opt_t == A_PMN || patch->p_diff != DEL ) && !patch->p_val ) );
+
+ if ( opt->cfg_t != A_ARG && opt->opt_t == A_PMN ) {
+
+ struct opt_parent *p_reftr = get_opt_parent_ref( opt, patch->p_ref );
+ struct opt_parent *p_track = get_opt_parent_val( opt, patch->p_val );
+
+ paranoia( -500129, ( p_reftr && p_track && p_reftr != p_track ) );
+
+ p_track = p_track ? p_track : p_reftr;
+
+ if ( ( patch->p_diff == ADD && patch->p_val && p_track &&
+ !wordsEqual( patch->p_val, p_track->p_val ) ) &&
+ ( patch->p_ref || p_track->p_ref ) )
+ check_apply_parent_option( DEL, cmd, save, opt, p_track->p_val, cn );
+
+ }
+
+ if ( (call_opt_apply( cmd, save, opt, patch, in, cn )) == FAILURE )
+ goto call_option_failure;
+
+ if ( opt->cfg_t != A_ARG && track_opt_parent( cmd, save, opt, patch, cn ) == FAILURE )
+ goto call_option_failure;
+
+ return SUCCESS;
+
+
+ } else if ( cmd == OPT_SET_POST || cmd == OPT_POST ) {
+
+ if ( opt->call_custom_option && ((opt->call_custom_option)( cmd, 0, opt, 0, cn )) == FAILURE )
+ goto call_option_failure;
+
+ return SUCCESS;
+ }
+
+
+call_option_failure:
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "--%s %s Failed ! "
+ "( diff:%d ad:%d val:%d min:%d max:%d def:%d %s %d %d %d )",
+ opt->long_name ? opt->long_name : "-", in ? in: "-",
+ patch ? patch->p_diff : -1,
+ ad, opt->ival ? *(opt->ival) : 0, opt->imin, opt->imax, opt->idef,
+ opt_cmd2str[cmd], opt->opt_t, on_the_fly, wordlen(in) );
+
+ /* This results in too much side effects. And MUST be handled by calling function like apply_stream_opts()
+ if ( !on_the_fly && !pedantic_cmd_check && ( cmd == OPT_PATCH || cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "ignored SYNTAX ERROR in startup configuration due to disabled --%s! FIX YOUR CONFIG NOW !!",
+ ARG_PEDANTIC_CMDCHECK );
+
+ return SUCCESS;
+ }
+ */
+
+ return FAILURE;
+}
+
+
+
+int respect_opt_order( uint8_t test, int8_t last, int8_t next, struct opt_type *on, uint8_t load, uint8_t cmd, struct ctrl_node *cn ) {
+
+ struct list_node *list_pos;
+ struct opt_type *opt;
+
+ dbgf_all( DBGT_INFO, "%s, cmd: %s, last %d, next %d, opt %s load %d",
+ opt_cmd2str[ test ], opt_cmd2str[ cmd ], last, next, on?on->long_name:"???", load );
+
+ paranoia( -500002, ( test != OPT_CHECK && test != OPT_APPLY ) );
+
+ paranoia( -500107, ( cmd == OPT_CHECK || cmd == OPT_APPLY ) );
+
+
+ if ( next == 0 )
+ return last;
+
+ if ( last > next ) {
+
+ // debug which option caused the problems !
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "--%s%s%c (order=%d option) MUST appear earlier in command sequence!",
+ on?on->long_name:"???", on&&on->short_name?", ":"",on&&on->short_name?on->short_name:' ', next );
+
+ return FAILURE;
+ }
+
+ if ( last == next )
+ return next;
+
+
+ list_for_each( list_pos, &opt_list ) {
+
+ opt = (struct opt_type *)list_entry( list_pos, struct opt_data, list );
+
+ if ( load && opt->order >= last+1 && opt->order <= next ) {
+
+ if ( load_config_cb && load_config_cb( test, opt, cn ) == FAILURE ) {
+
+ dbgf_all( DBGT_ERR, "load_config_cb() %s failed",
+ opt->long_name );
+
+ return FAILURE;
+ }
+ }
+
+ if ( test == OPT_APPLY && opt->order >= last && opt->order <= next-1 ) {
+
+ if ( call_option( ADD, cmd, 0/*save*/, opt, 0,0, cn ) == FAILURE ) {
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "call_option() %s cmd %s failed",
+ opt->long_name, opt_cmd2str[cmd] );
+
+ return FAILURE;
+ }
+ }
+ }
+
+ return next;
+}
+
+
+// if returns SUCCESS then fd might be closed ( called remove_ctrl_node( fd ) ) or not.
+// if returns FAILURE then fd IS open and must be closed
+int8_t apply_stream_opts( char *s, uint8_t cmd, uint8_t load_cfg, struct ctrl_node *cn ) {
+
+ enum {
+ NEXT_OPT, // 0
+ NEW_OPT, // 1
+ SHORT_OPT, // 2
+ LONG_OPT, // 3
+ LONG_OPT_VAL, // 4
+ LONG_OPT_WHAT, // 5
+ LONG_OPT_ARG, // 6
+ LONG_OPT_ARG_VAL, // 7
+ };
+
+ char *state2str[] = {"NEXT_OPT","NEW_OPT","SHORT_OPT","LONG_OPT","LONG_OPT_VAL","LONG_OPT_WHAT","LONG_OPT_ARG","LONG_OPT_ARG_VAL"};
+
+
+ int8_t state = NEW_OPT;
+ struct opt_type *opt = NULL;
+ struct opt_type *opt_arg = NULL;
+ char* equalp = NULL;
+ char* pmn_s = NULL;
+ int8_t order = 0;
+ int32_t pb;
+ char argument[MAX_ARG_SIZE];
+ struct opt_parent *patch = NULL;
+
+ if ( cmd != OPT_CHECK && cmd != OPT_APPLY )
+ return FAILURE;
+
+ uint8_t del;
+
+ Load_config = load_cfg;
+ Testing = 0;
+
+
+ while ( s && strlen(s) >= 1 ) {
+
+ dbgf_all( DBGT_INFO, "cmd: %-10s, state: %s opt: %s, wordlen: %d rest: %s",
+ opt_cmd2str[cmd], state2str[state], opt?opt->long_name:"null", wordlen(s), s );
+
+ if ( Testing ) {
+ Testing = 0;
+ close_ctrl_node( CTRL_CLOSE_SUCCESS, cn );
+ return SUCCESS;
+ }
+
+
+ if ( state == NEXT_OPT ) {
+ // assumes s points to last successfully processed word or its following gap
+ s = nextword(s);
+ state = NEW_OPT;
+
+ } else if ( state == NEW_OPT && wordlen(s) >= 2 && s[0]=='-' && s[1]!='-' ) {
+
+ s++;
+ state=SHORT_OPT;
+
+ } else if ( state == NEW_OPT && wordlen(s) >=3 && s[0]=='-' && s[1]=='-' ) {
+
+ s+=2;
+ state=LONG_OPT;
+
+ } else if ( state == NEW_OPT && wordlen(s) >=1 && s[0]!='-' && s[0]!='/' ) {
+
+ state=LONG_OPT;
+
+ } else if ( state == SHORT_OPT && wordlen(s) >=1 ) {
+
+ if ( !(opt = get_option( NULL, YES, s )) )
+ goto apply_args_error;
+
+ if ( (order=respect_opt_order( cmd, order, opt->order, opt, Load_config, OPT_SET_POST, cn )) < 0 )
+ goto apply_args_error;
+
+ if ( opt->opt_t == A_PS0 ) {
+
+ if ( (pb=check_apply_parent_option( ADD, cmd, 0/*save*/, opt, s, cn )) == FAILURE )
+ goto apply_args_error;
+
+
+ if ( pb ) {
+ s+=pb;
+ state = NEXT_OPT;
+ } else if ( wordlen(s+1) >= 1 ) {
+ s++;
+ state = SHORT_OPT;
+ } else if ( wordlen(s+1) == 0 ) {
+ s++;
+ state = NEXT_OPT;
+ } else {
+ goto apply_args_error;
+ }
+
+ } else if ( opt->opt_t == A_PS1 || opt->opt_t == A_PMN ) {
+
+ s++;
+
+ if ( wordlen(s) > 1 && s[0] == '=' )
+ s++;
+
+ if ( wordlen(s) == 0 && !(s = nextword(s)) )
+ goto apply_args_error;
+
+ state = LONG_OPT_VAL;
+ }
+
+
+ } else if ( state == LONG_OPT && wordlen(s) >= 1 ) {
+
+ opt = get_option( NULL, NO, s );
+
+ if ( opt ) {
+
+ if ( (order=respect_opt_order( cmd, order, opt->order, opt, Load_config, OPT_SET_POST, cn )) < 0 )
+ goto apply_args_error;
+
+
+ if ( opt->opt_t == A_PS0 ) {
+
+ if ( (pb=check_apply_parent_option( ADD, cmd, 0/*save*/, opt, s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ if ( pb )
+ s+=pb;
+ else
+ s+=wordlen(s);
+
+ state = NEXT_OPT;
+
+ } else if ( opt->opt_t == A_PS1 || opt->opt_t == A_PMN ) {
+
+ equalp=index( s, '=' );
+
+ if ( equalp && equalp < s+wordlen(s) ) {
+
+ s = equalp+1;
+
+ } else {
+
+ if ( (s=nextword(s)) == NULL )
+ goto apply_args_error;
+
+ }
+
+ state = LONG_OPT_VAL;
+
+ } else {
+ goto apply_args_error;
+ }
+
+ } else {
+
+ goto apply_args_error;
+ }
+
+
+ } else if ( state == LONG_OPT_VAL && wordlen(s) >=1 ) {
+
+ if ( opt->opt_t == A_PS1 ) {
+
+ s = s + (del = ((s[0]==ARG_RESET_CHAR) ? 1 : 0) );
+
+ if ( (pb=check_apply_parent_option( del, cmd, (on_the_fly?YES:NO)/*save*/, opt, s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ s+=pb;
+ state = NEXT_OPT;
+
+ } else if ( opt->opt_t == A_PMN ) {
+
+ s = s + (del = ((s[0] == ARG_RESET_CHAR) ? 1 : 0));
+
+ patch = add_opt_parent( &Patch_opt );
+
+ if ( (pb=call_option( del, OPT_PATCH, 0/*save*/, opt, patch, s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ pmn_s = s;
+ s+=pb;
+
+ state = LONG_OPT_WHAT;
+
+ } else {
+ goto apply_args_error;
+ }
+
+ } else if ( state == LONG_OPT_WHAT ) {
+
+ if ( opt->opt_t != A_PMN )
+ goto apply_args_error;
+
+ char* slashp = index( s, '/' );
+
+ if ( slashp && slashp == nextword(s) && patch->p_diff == DEL ) {
+
+ wordCopy( argument, slashp+1 );
+
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR,
+ "--%s %s can not be resetted and refined at the same time. Just omit /%s!",
+ opt->long_name, patch->p_val, argument );
+
+ goto apply_args_error;
+
+ } else if ( slashp && slashp == nextword(s) ) {
+
+ //nextword starts with slashp
+
+ s = slashp+1;
+ state = LONG_OPT_ARG;
+
+ } else {
+
+ if ( (call_option( ADD, OPT_ADJUST, 0/*save*/, opt, patch, pmn_s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ //indicate end of LONG_OPT_ARGs
+ if ( (call_option( ADD, cmd, (on_the_fly?YES:NO)/*save*/, opt, patch, pmn_s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ del_opt_parent( &Patch_opt, patch );
+ patch = NULL;
+ state = NEXT_OPT;
+ }
+
+
+ } else if ( state == LONG_OPT_ARG && wordlen(s) >=1 ) {
+
+ opt_arg = get_option( opt, NO, s );
+
+ if ( !opt_arg || opt_arg->opt_t != A_CS1 || opt_arg->order != opt->order )
+ goto apply_args_error;
+
+ equalp=index( s, '=' );
+
+ if ( equalp && equalp < s+wordlen(s) ) {
+
+ s = equalp+1;
+
+ } else {
+
+ if ( (s=nextword(s))==NULL )
+ goto apply_args_error;
+ }
+
+ state = LONG_OPT_ARG_VAL;
+
+
+ } else if ( state == LONG_OPT_ARG_VAL && wordlen(s) >=1 ) {
+
+ s = s + (del = ((s[0] == ARG_RESET_CHAR) ? 1 : 0));
+
+ if ( (pb=call_option( del, OPT_PATCH, 0/*save*/, opt_arg, patch, s, cn )) == FAILURE )
+ goto apply_args_error;
+
+ s+=pb;
+
+ state = LONG_OPT_WHAT;
+
+
+ } else {
+ goto apply_args_error;
+ }
+
+ continue;
+ }
+
+
+ if ( state != LONG_OPT_ARG && state != NEW_OPT && state != NEXT_OPT )
+ goto apply_args_error;
+
+
+ dbgf_all( DBGT_INFO, "all opts and args succesfully called with %s", opt_cmd2str[cmd] );
+
+ if ( (order=respect_opt_order( cmd, order, 99, NULL, Load_config, OPT_SET_POST, cn )) < 0 )
+ goto apply_args_error;
+
+
+ return SUCCESS;
+
+apply_args_error:
+
+ if ( patch )
+ del_opt_parent( &Patch_opt, patch );
+
+ snprintf( argument, MIN( sizeof(argument), wordlen(s)+1 ), "%s", s );
+
+ //otherwise invalid sysntax identified only by apply_stream_opts is not printed;
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "invalid argument: %s", argument );
+
+ return FAILURE;
+
+}
+
+
+
+void apply_init_args( int argc, char *argv[] ) {
+
+ prog_name = argv[0];
+
+ get_init_string( argc, argv );
+
+ char *stream_opts = nextword( init_string );
+
+ struct ctrl_node *cn = create_ctrl_node( STDOUT_FILENO, NULL, (getuid() | getgid())/*are we root*/ ? NO : YES );
+
+ if ( ( apply_stream_opts( stream_opts, OPT_CHECK, YES/*load cfg*/, cn ) == FAILURE ) ||
+ ( apply_stream_opts( stream_opts, OPT_APPLY, YES/*load cfg*/, cn ) == FAILURE ) )
+ cleanup_all( CLEANUP_FAILURE );
+
+ respect_opt_order( OPT_APPLY, 0, 99, NULL, NO/*load_cofig*/, OPT_POST, 0/*probably closed*/ );
+
+ close_ctrl_node( CTRL_CLOSE_STRAIGHT, cn );
+
+ cb_plugin_hooks( NULL, PLUGIN_CB_CONF );
+
+ free_init_string();
+}
+
+
+
+
+
+
+
+
+char *ipStr( uint32_t addr ) {
+#define IP2S_ARRAY_LEN 10
+ static uint8_t c=0;
+ static char str[IP2S_ARRAY_LEN][IP4_STR_LEN];
+
+ c = (c+1) % IP2S_ARRAY_LEN;
+
+ inet_ntop( AF_INET, &addr, str[c], IP4_STR_LEN );
+
+ return str[c];
+}
+
+
+
+int8_t str2netw( char* args, uint32_t *ip, char delimiter, struct ctrl_node *cn, int32_t *val, int32_t max ) {
+
+ struct in_addr tmp_ip_holder;
+ char *slashptr = NULL;
+
+ char switch_arg[30];
+
+ if ( wordlen( args ) < 1 || wordlen( args ) > 29 )
+ return FAILURE;
+
+ wordCopy( switch_arg, args );
+ switch_arg[wordlen( args )] = '\0';
+
+ if ( val ) {
+
+ if ( ( slashptr = strchr( switch_arg, delimiter ) ) != NULL ) {
+ char *end = NULL;
+
+ *slashptr = '\0';
+
+ errno = 0;
+ *val = strtol( slashptr+1, &end, 10 );
+
+ if ( ( errno == ERANGE ) || *val > max || *val < 0 ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "invalid argument %s %s",
+ args, strerror( errno ) );
+
+ return FAILURE;
+
+ } else if ( end==slashptr+1 || wordlen(end) ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "invalid argument trailer %s", end );
+ return FAILURE;
+ }
+
+ } else {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "invalid argument %s! Fix you parameters!", switch_arg );
+ return FAILURE;
+ }
+ }
+
+ errno = 0;
+
+ if ( (inet_pton( AF_INET, switch_arg, &tmp_ip_holder )) < 1 || !tmp_ip_holder.s_addr ) {
+
+ dbgf_all( DBGT_WARN, "invalid argument: %s: %s", args, strerror(errno) );
+ return FAILURE;
+ }
+
+ *ip = tmp_ip_holder.s_addr;
+
+ return SUCCESS;
+}
+
+
+void addr_to_str( uint32_t addr, char *str ) {
+
+ inet_ntop( AF_INET, &addr, str, IP4_STR_LEN );
+ return;
+}
+
+
+
+uint32_t validate_net_mask( uint32_t ip, uint32_t mask, struct ctrl_node *cn ) {
+
+ uint32_t nip = ip & htonl( 0xFFFFFFFF<<( 32 - mask ) );
+
+ if ( cn && nip != ip )
+ dbg_cn( cn, DBGL_CHANGES, DBGT_WARN,
+ "inconsistent network prefix %s/%d - probably you mean: %s/%d",
+ ipStr(ip), mask, ipStr(nip), mask);
+
+ return nip;
+}
+
+
+
+int32_t check_file( char *path, uint8_t write, uint8_t exec ) {
+
+ struct stat fstat;
+
+ errno = 0;
+ int stat_ret = stat( path, &fstat );
+
+ if ( stat_ret < 0 ) {
+
+ dbgf( DBGL_CHANGES, DBGT_WARN, "%s does not exist! (%s)",
+ path, strerror(errno));
+
+ } else {
+
+ if ( S_ISREG( fstat.st_mode ) &&
+ (S_IRUSR & fstat.st_mode) &&
+ ((S_IWUSR & fstat.st_mode) || !write) &&
+ ((S_IXUSR & fstat.st_mode) || !exec) )
+ return SUCCESS;
+
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "%s exists but has inapropriate permissions (%s)",
+ path, strerror(errno));
+
+ }
+
+ return FAILURE;
+}
+
+int32_t check_dir( char *path, uint8_t create, uint8_t write ) {
+
+ struct stat fstat;
+
+ errno = 0;
+ int stat_ret = stat( path, &fstat );
+
+ if ( stat_ret < 0 ) {
+
+ if ( create && mkdir( path, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH ) >= 0 )
+ return SUCCESS;
+
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "directory %s does not exist and can not be created (%s)", path, strerror(errno));
+
+ } else {
+
+ if ( S_ISDIR( fstat.st_mode ) &&
+ ( S_IRUSR & fstat.st_mode) &&
+ ( S_IXUSR & fstat.st_mode) &&
+ ((S_IWUSR & fstat.st_mode) || !write) )
+ return SUCCESS;
+
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "directory %s exists but has inapropriate permissions (%s)", path, strerror(errno));
+
+ }
+
+ return FAILURE;
+
+}
+
+
+
+
+uint32_t wordlen ( char *s ) {
+
+ uint32_t i = 0;
+
+ if ( !s )
+ return 0;
+
+ for( i=0; i<strlen(s); i++ ) {
+
+ if ( s[i] == '\0' || s[i] == '\n' || s[i]==' ' || s[i]=='\t' )
+ return i;
+ }
+
+ return i;
+}
+
+
+int8_t wordsEqual ( char *a, char *b ) {
+
+ if ( wordlen( a ) == wordlen ( b ) && !strncmp( a, b, wordlen(a) ) )
+ return YES;
+
+ return NO;
+}
+
+
+void wordCopy( char *out, char *in ) {
+
+ if ( out && in && wordlen(in) < MAX_ARG_SIZE ) {
+
+ snprintf( out, wordlen(in)+1, "%s", in );
+
+ } else if ( out && !in ) {
+
+ out[0]=0;
+
+ } else {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "called with out: %s and in: %s", out, in );
+ cleanup_all( -500017 );
+
+ }
+}
+
+
+static int8_t show_info ( struct ctrl_node *cn, void *data, struct opt_type *opt, struct opt_parent *p, struct opt_child *c ) {
+
+ if ( c )
+ dbg_printf( cn, " /%-18s %-20s %s%s\n",
+ c->c_opt->long_name, c->c_val, (c->c_ref ? "resolved from " : ""), (c->c_ref ? c->c_ref : "") );
+ else
+ dbg_printf( cn, " %-22s %-20s %s%s\n",
+ opt->long_name, p->p_val, (p->p_ref ? "resolved from " : ""), (p->p_ref ? p->p_ref : "") );
+
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_show_info ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ /*
+ //TBD: include all routing tables
+ dbg_printf(cn, " source_version %s\n", SOURCE_VERSION);
+ dbg_printf(cn, " compat_version %i\n", COMPAT_VERSION);
+ dbg_printf(cn, "\n");
+ */
+
+ func_for_each_opt( cn, NULL, "opt_show_info()", show_info );
+
+ if ( !on_the_fly )
+ cleanup_all(CLEANUP_SUCCESS);
+
+
+ }
+
+ return SUCCESS;
+}
+
+
+
+static int32_t opt_no_fork ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ debug_level = strtol( patch->p_val, NULL , 10);
+
+ activate_debug_system();
+
+ } else if ( cmd == OPT_POST && !on_the_fly ) {
+
+ activate_debug_system();
+
+ }
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_debug ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ int ival = strtol( patch->p_val, NULL , 10);
+
+
+ if ( ival == DBGL_SYS ||
+ ival == DBGL_CHANGES ||
+ ival == DBGL_TEST ||
+ ival == DBGL_ALL )
+ {
+
+ remove_dbgl_node( cn );
+ add_dbgl_node( cn, ival );
+ return SUCCESS;
+
+ } else if ( ival == DBGL_ROUTES ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_ROUTES ), 0, cn );
+
+ } else if ( ival == DBGL_LINKS ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_LINKS ), 0, cn );
+
+ } else if ( ival == DBGL_DETAILS ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, 0, get_option( 0, 0, ARG_STATUS ), 0, cn );
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_LINKS ), 0, cn );
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_ORIGINATORS ), 0, cn );
+/*
+ } else if ( ival == DBGL_SERVICES ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_SERVICES ), 0, cn );
+
+ } else if ( ival == DBGL_HNAS ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_HNAS ), 0, cn );
+
+ } else if ( ival == DBGL_GATEWAYS ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_GATEWAYS ), 0, cn );
+*/
+ } else if ( ival == DBGL_PROFILE ) {
+
+#if defined MEMORY_USAGE
+ debugMemory( cn );
+#endif
+ }
+ close_ctrl_node( CTRL_CLOSE_SUCCESS, cn );
+ }
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_help ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd != OPT_APPLY )
+ return SUCCESS;
+
+ if ( !cn )
+ return FAILURE;
+
+
+ if ( !strcmp(opt->long_name, ARG_VERBOSE_HELP)) {
+
+ show_opts_help( NO, YES, cn );
+
+ } else if ( !strcmp(opt->long_name, ARG_HELP) ) {
+
+ show_opts_help( NO, NO, cn );
+
+ } else if ( !strcmp(opt->long_name, ARG_VERBOSE_EXP) ) {
+
+ show_opts_help( YES, YES, cn );
+
+ } else if ( !strcmp(opt->long_name, ARG_EXP) ) {
+
+ show_opts_help( YES, NO, cn );
+
+ } else if ( !strcmp(opt->long_name, ARG_VERSION) ) {
+
+ dbg_printf( cn, "BMX (BatMan-eXp) %s-rv%d (compatibility version %i)\n",
+ SOURCE_VERSION, REVISION_VERSION, COMPAT_VERSION);
+
+ } else {
+
+ show_opts_help( NO, NO, cn );
+ }
+
+ if ( !on_the_fly )
+ cleanup_all(CLEANUP_SUCCESS);
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_quit ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY )
+ close_ctrl_node( CTRL_CLOSE_SUCCESS, cn );
+
+ return SUCCESS;
+}
+
+
+
+static int32_t opt_run_dir ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ char tmp_dir[MAX_PATH_SIZE] = "";
+
+ if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ if ( wordlen( patch->p_val )+1 >= MAX_PATH_SIZE || patch->p_val[0] != '/' )
+ return FAILURE;
+
+ snprintf( tmp_dir, wordlen(patch->p_val)+1, "%s", patch->p_val );
+
+ if ( check_dir( tmp_dir, YES/*create*/, YES/*writable*/ ) == FAILURE )
+ return FAILURE;
+
+ if ( cmd == OPT_APPLY ) {
+ strcpy( run_dir, tmp_dir );
+ }
+
+ } else if ( cmd == OPT_SET_POST && !on_the_fly ) {
+
+ if ( check_dir( run_dir, YES/*create*/, YES/*writable*/ ) == FAILURE )
+ return FAILURE;
+
+ }
+
+ return SUCCESS;
+}
+
+
+
+
+
+
+
+
+
+static struct opt_type control_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+ {ODI,0,0, 0, 0,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nGeneral configuration options:"},
+
+ {ODI,0,ARG_HELP, 'h',0,A_PS0,A_USR,A_DYI,A_ARG,A_END, 0, 0, 0, 0, opt_help,
+ 0, "summarize help"},
+
+ {ODI,0,ARG_VERBOSE_HELP, 'H',0,A_PS0,A_USR,A_DYI,A_ARG,A_END, 0, 0, 0, 0, opt_help,
+ 0, "show help"},
+
+ {ODI,0,ARG_EXP, 'x',0,A_PS0,A_USR,A_DYI,A_ARG,A_END, 0, 0, 0, 0, opt_help,
+ 0, "summarize advanced and experimental options"},
+
+ {ODI,0,ARG_VERBOSE_EXP, 'X',0,A_PS0,A_USR,A_DYI,A_ARG,A_END, 0, 0, 0, 0, opt_help,
+ 0, "show advanced and experimental options"},
+
+ {ODI,0,ARG_VERSION, 'v',0,A_PS0,A_USR,A_DYI,A_ARG,A_ANY, 0, 0, 0, 0, opt_help,
+ 0, "show version"},
+#ifndef NOTRAILER
+ {ODI,0,ARG_TRAILER, 'V',0,A_PS0,A_USR,A_INI,A_ARG,A_END, 0, 0, 0, 0, opt_help,
+ 0, "show trailer"},
+#endif
+
+ {ODI,0,ARG_TEST, 0, 0,A_PS0,A_ADM,A_DYI,A_ARG,A_ANY, &Testing, 0, 1, 0, 0,
+ 0, "test remaining args and provide feedback about projected success (without applying them)"},
+
+ {ODI,0,ARG_NO_FORK, 'd',0,A_PS1,A_ADM,A_INI,A_ARG,A_ANY, 0, DBGL_MIN, DBGL_MAX, -1, opt_no_fork,
+ ARG_VALUE_FORM, "print debug information instead of forking to background\n" },
+ {ODI,0,ARG_DEBUG, 'd',0,A_PS1,A_ADM,A_DYN,A_ARG,A_ETE, 0, DBGL_MIN, DBGL_MAX, -1, opt_debug,
+ ARG_VALUE_FORM, "show debug information:\n"
+ " 0 : system\n"
+ " 1 : originators\n"
+ " 2 : gateways\n"
+ " 3 : changes\n"
+ " 4 : verbose changes\n"
+ " 5 : profiling (depends on -DDEBUG_MALLOC -DMEMORY_USAGE -DPROFILE_DATA)\n"
+ " 7 : services\n"
+ " 8 : details\n"
+ " 9 : announced networks and interfaces\n"
+ " 10 : links\n"
+ " 11 : testing" },
+
+ {ODI,0,ARG_RUN_DIR, 0, 2,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, 0, 0, 0, 0, opt_run_dir,
+ ARG_DIR_FORM, "set runtime DIR of pid, socket,... - default: " DEF_RUN_DIR " (must be defined before --" ARG_CONNECT ")."},
+
+
+
+ {ODI,0,"loop_mode", 'l',3,A_PS0,A_ADM,A_INI,A_ARG,A_ANY, &loop_mode, 0, 1, 0, 0,
+ 0, "put client daemon in loop mode to periodically refresh debug information"},
+
+#ifndef LESS_OPTIONS
+ {ODI,0,"loop_interval", 0, 3,A_PS1,A_ADM,A_INI,A_ARG,A_ANY, &loop_interval, MIN_LOOP_INTERVAL,MAX_LOOP_INTERVAL,DEF_LOOP_INTERVAL,0,
+ ARG_VALUE_FORM, "periodicity in ms with which client daemon in loop-mode refreshes debug information"},
+#endif
+
+#ifndef NODEPRECATED
+ {ODI,0,"batch_mode", 'b',3,A_PS0,A_ADM,A_INI,A_ARG,A_ANY, 0, 0, 0, 0, opt_deprecated,0,0},
+#endif
+
+ {ODI,0,ARG_CONNECT, 'c',3,A_PS0,A_ADM,A_INI,A_ARG,A_EAT, 0, 0, 0, 0, opt_connect,
+ 0, "set client mode. Connect and forward remaining args to main routing daemon"},
+
+ //order=5: so when used during startup it also shows the config-file options
+ {ODI,0,ARG_SHOW_CHANGED, 'i',5,A_PS0,A_ADM,A_DYI,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_info,
+ 0, "inform about configured options" },
+#ifndef LESS_OPTIONS
+ {ODI,0,ARG_PEDANTIC_CMDCHECK, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &pedantic_check,MIN_PEDANT_CHK, MAX_PEDANT_CHK, DEF_PEDANT_CHK, 0,
+ ARG_VALUE_FORM, "disable/enable pedantic checking of command-line parameters and context -\n"
+ " ( e.g. fail setting a parameter without changing it)" },
+#endif
+ {ODI,0,"dbg_mute_timeout", 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &dbg_mute_to, 0, 10000000, 100000, 0,
+ ARG_VALUE_FORM, "set timeout in ms for muting frequent messages"},
+
+
+ {ODI,0,ARG_QUIT,EOS_DELIMITER, 5,A_PS0,A_USR,A_DYN,A_ARG,A_END, 0, 0, 0, 0, opt_quit,0,0}
+};
+
+
+
+void init_control( void ) {
+
+ int i;
+
+ char *d = getenv(BMX_ENV_DEBUG);
+ if ( d && strtol(d, NULL , 10) >= DBGL_MIN && strtol(d, NULL , 10) <= DBGL_MAX )
+ debug_level = strtol(d, NULL , 10);
+
+ for ( i = DBGL_MIN; i <= DBGL_MAX; i++ )
+ LIST_INIT_HEAD( dbgl_clients[i], struct dbgl_node, list );
+
+ openlog( "bmx", LOG_PID, LOG_DAEMON );
+
+ memset( &Patch_opt, 0, sizeof( struct opt_type ) );
+
+ LIST_INIT_HEAD( Patch_opt.d.childs_type_list, struct opt_data, list);
+ LIST_INIT_HEAD( Patch_opt.d.parents_instance_list, struct opt_parent, list);
+
+ register_options_array( control_options, sizeof( control_options ) );
+
+}
+
+void cleanup_config( void ) {
+
+ del_opt_parent( &Patch_opt, NULL );
+
+ while( !LIST_EMPTY( &opt_list ) )
+ remove_option( (struct opt_type*)list_entry( (&opt_list)->next, struct opt_data, list ) );
+
+ free_init_string();
+
+}
+
+
+
+void cleanup_control( void ) {
+
+ int8_t i;
+
+ debug_system_active = NO;
+ closelog();
+
+ if ( unix_sock )
+ close( unix_sock );
+
+ unix_sock = 0;
+
+ close_ctrl_node( CTRL_PURGE_ALL, 0 );
+
+ for ( i = DBGL_MIN; i <= DBGL_MAX; i++ ) {
+
+ while( !LIST_EMPTY( &dbgl_clients[i] ) )
+ remove_dbgl_node( (list_entry( (&dbgl_clients[i])->next, struct dbgl_node, list ))->cn );
+
+ }
+
+}
+
Added: trunk/bmx/control.h
===================================================================
--- trunk/bmx/control.h (rev 0)
+++ trunk/bmx/control.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,434 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+
+#define MIN_UPTIME 0
+#define MAX_UPTIME 2147383 /*(((TP32/1000)/2)-100) /1000 to talk about seconds and not ms, /2 to not render scheduled events outdated, -100 to be save */
+#define DEF_UPTIME 0
+
+#define DBGT_NONE 0
+#define DBGT_INFO 1
+#define DBGT_WARN 2
+#define DBGT_ERR 3
+
+
+//extern int debug_level;
+#define DBGL_MIN 0
+#define DBGL_SYS 0
+#define DBGL_ROUTES 1
+#define DBGL_GATEWAYS 2
+#define DBGL_CHANGES 3
+#define DBGL_ALL 4
+#define DBGL_PROFILE 5
+#define DBGL_UNUSED 6
+#define DBGL_SERVICES 7
+#define DBGL_DETAILS 8
+#define DBGL_HNAS 9
+#define DBGL_LINKS 10
+#define DBGL_TEST 11
+#define DBGL_MAX 11
+#define DBGL_INVALID 12
+
+
+extern int unix_sock;
+
+extern struct list_head ctrl_list;
+
+#define ARG_PEDANTIC_CMDCHECK "pedantic_cmd_check"
+
+
+extern int32_t Client_mode;
+
+
+#define CONNECTION_END_STR "$"
+#define CONNECTION_END_CHR '$'
+
+enum {
+ CTRL_CLOSE_ERROR,
+ CTRL_CLOSE_SUCCESS,
+ CTRL_CLOSE_STRAIGHT,
+ CTRL_CLOSE_DELAY,
+ CTRL_CLEANUP,
+ CTRL_PURGE_ALL
+};
+
+#define CTRL_CLOSING_TIMEOUT 5000
+
+
+struct ctrl_node
+{
+ struct list_node list;
+ int fd;
+ void (*cn_fd_handler) (struct ctrl_node *);
+ uint32_t closing_stamp;
+ uint8_t authorized;
+ int8_t dbgl;
+};
+
+extern struct list_head dbgl_clients[DBGL_MAX+1];
+
+struct dbgl_node
+{
+ struct list_node list;
+ struct ctrl_node *cn;
+};
+
+
+
+// muting does not help if a changing value like time or seqno occurs durig the first DBG_HIST_TEXT_SIZE bytes
+#define DBG_HIST_TEXT_SIZE 80
+#define DBG_HIST_SIZE 20
+//#define DBG_HIST_EXPIRE 100000
+
+struct dbg_histogram {
+ uint32_t print_stamp;
+ int32_t expire;
+ uint16_t check_len;
+ uint16_t catched;
+ char text[ DBG_HIST_TEXT_SIZE ];
+};
+
+
+#ifndef TESTDEBUG
+
+#define DBG_HIST_NEW 0x00
+#define DBG_HIST_MUTING 0x01
+#define DBG_HIST_MUTED 0x02
+
+#ifdef NODEBUGALL
+#define dbgf_all(...) {;}
+#else
+#define dbgf_all( dbgt, ... ); do { if ( __dbgf_all() ) { _dbgf_all( dbgt, __FUNCTION__, __VA_ARGS__ ); } } while (0)
+#endif
+
+#ifdef EXTDEBUG
+#define dbgf_ext( dbgt, ... ); do { if ( __dbgf_all() ) { _dbgf_all( dbgt, __FUNCTION__, __VA_ARGS__ ); } } while (0)
+#else
+#define dbgf_ext(...) {;}
+#endif
+
+#define dbgf( dbgl, dbgt, ...); _dbgf( dbgl, dbgt, __FUNCTION__, __VA_ARGS__ );
+#define dbgf_cn( cn, dbgl, dbgt, ...); _dbgf_cn( cn, dbgl, dbgt, __FUNCTION__, __VA_ARGS__ );
+
+void dbg ( int8_t dbgl, int8_t dbgt, char *last, ... );
+void _dbgf ( int8_t dbgl, int8_t dbgt, char const *f, char *last, ... );
+void dbg_cn ( struct ctrl_node *cn, int8_t dbgl, int8_t dbgt, char *last, ... );
+void _dbgf_cn ( struct ctrl_node *cn, int8_t dbgl, int8_t dbgt, char const *f, char *last, ... );
+void dbg_mute ( uint32_t check_len, int8_t dbgl, int8_t dbgt, char *last, ... );
+void _dbgf_all ( int8_t dbgt, char const *f, char *last, ... );
+uint8_t __dbgf_all( void );
+
+void dbg_printf( struct ctrl_node *cn, char *last, ... );
+
+#else
+
+#define dbgf( dbgl, dbgt, ...); printf( __VA_ARGS__ )
+#define dbgf_cn( cn, dbgl, dbgt, ...); printf( __VA_ARGS__ )
+#define dbg( dbgl, dbgt, ... ) printf( __VA_ARGS__ )
+#define dbg_cn( cn, dbgl, dbgt, ... ) printf( __VA_ARGS__ )
+#define dbg_mute( check_len, dbgl, dbgt, ... ) printf( __VA_ARGS__ )
+#define dbgf_all( dbgt, ... ) printf( __VA_ARGS__ )
+#define dbgf_ext( dbgt, ... ) printf( __VA_ARGS__ )
+#define dbg_printf( cn, ... ) printf( __VA_ARGS__ )
+
+
+#endif
+
+void accept_ctrl_node( void );
+void handle_ctrl_node( struct ctrl_node *cn );
+void close_ctrl_node( uint8_t cmd, struct ctrl_node *cn );
+struct ctrl_node *create_ctrl_node( int fd, void (*cn_fd_handler) (struct ctrl_node *), uint8_t authorized );
+
+
+
+
+#define REFERENCE_KEY_WORD "ref:"
+
+#define EOS_DELIMITER '#'
+
+#define MAX_UNIX_MSG_SIZE 2000
+
+extern struct list_head opt_list;
+
+
+/* opt_t types (Parent/Child, Single/Multiple, 0/1/N-arguments) */
+#define A_PS0 0x01
+#define A_PS1 0x02
+#define A_PMN 0x14
+#define A_CS1 0x22
+
+
+/* auth_t types */
+#define A_ADM 0x10
+#define A_USR 0x00
+
+/* dyn_t types: */
+// can only be used on-the-fly
+#define A_DYN 0x20
+// can never be used on-the-fly
+#define A_INI 0x40
+// can be used during init and on-the-fly
+#define A_DYI 0x60
+
+/* cfg_t types: */
+// can only be set as command-line argument. NOT shows as relevant parameter
+#define A_ARG 0x02
+// can be set in config file and as command-line argument. Shows as relevant parameter
+#define A_CFA 0x03
+
+/* pos_t types: */
+// must be given as first argument
+#define A_BEG 0x01 NOT IMPLEMENTED
+// may appera anywhere in command stream
+#define A_ANY 0x02
+// must appear as last argument
+#define A_END 0x03
+// may appera anywhere in command stream but consumes remaining arguments
+#define A_EAT 0x04
+// must appear as last argunent and cosumes remaining arguments
+#define A_ETE 0x05
+
+
+extern char *opt_cmd2str[];
+
+
+struct opt_child {
+
+ struct list_node list;
+
+ struct opt_type *c_opt; // key, pointing to related opt_type
+ struct opt_parent *parent_instance;
+
+ char *c_val;
+
+ uint8_t p_diff; //ADD, DEL, NOP
+
+ char *c_ref;
+};
+
+
+struct opt_parent {
+
+ struct list_node list;
+
+ struct list_head childs_instance_list;
+
+ char *p_val; //key
+
+ uint8_t p_diff; //ADD, DEL, NOP
+
+ char *p_ref;
+
+};
+
+#define ODI {{0},0,{0,0,0,0},{0,0,0,0}}
+
+struct opt_data {
+
+ struct list_node list;
+
+ struct opt_type *parent_opt; //REMOVE THIS and use casting instead !
+
+ struct list_head childs_type_list; //if this opt is a section type, then further sub-opts types can be listed here
+
+ struct list_head parents_instance_list; //
+// uint16_t found_parents;
+
+};
+
+struct opt_type {
+
+ struct opt_data d; //MUST be first structure in opt_type to allow casting between struct opt_data and struct opt_type
+
+// int8_t old_order; // enforces an order during the init process, (0==anytime????), 1..99: in this order. Might become removed
+
+ char *parent_name;
+ char *long_name;
+
+ char short_name;
+ int8_t order; // enforces an order during the init process, (0==anytime????), 1..99: in this order. Might become removed
+
+ uint8_t opt_t;
+
+ uint8_t auth_t;
+ uint8_t dyn_t;
+ uint8_t cfg_t;
+ uint8_t pos_t;
+
+ // if != NULL call_option() will be initialize / reset(ARG_RESET) to idef
+ int32_t *ival;
+ // if imin != imax call_option() will test for validity
+ int32_t imin;
+ int32_t imax;
+ int32_t idef;
+
+ int32_t (*call_custom_option)( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn );
+
+#define ARG_VALUE_FORM "<VAL>"
+#define ARG_FILE_FORM "<FILE>"
+#define ARG_DIR_FORM "<DIRECTORY>"
+#define ARG_PORT_FORM "<PORT>"
+#define ARG_ADDR_FORM "<ADDRESS>"
+#define ARG_PREFIX_FORM "<NETADDR>/<PREFIX-LENGTH>"
+#define ARG_NETW_FORM "<NETADDR>"
+#define ARG_MASK_FORM "<NETMASK>"
+
+ char *syntax;
+ char *help;
+
+};
+
+
+#define ARG_RESET "-" /* s-string preamble for call_option() to reset opt to default */
+#define ARG_RESET_CHAR '-'
+
+
+enum opt_cmd {
+ // option handlers are registered, configured, and unregistered using primitives.
+ // for registration and unregistration the primitives OPT_REGISTER and OPT_UNREGISTER are used
+ // for configuration the primitives OPT_PATCH, OPT_ADJUST, OPT_CHECK, OPT_APPLY, OPT_SET_POST, OPT_POST are used
+
+
+ // called once for each option after registration
+ // Returns FAILURE or SUCCESS
+ OPT_REGISTER,
+
+
+ OPT_PATCH,
+ // opt values are configured by creating, extending, adjusting and finally testing and applying a patch
+ // option handler usually dont care about the creation of the patch.
+ // they get a complete patch which includes
+ // the option type-value pair and optional child type-valued pairs.
+
+
+ OPT_ADJUST,
+ // patched type-values pairs can be adjusted to a unified format before being checked or applied
+ // this has the following advantages:
+ // tracked and applied values are equal (different value notations can be adjusted to a unified format)
+ // -> track knows about already configured values (even when given with different notation)
+ // -> can prevent/warn reconfiguration of already configured values
+ // -> can reject resetting of non-configured values
+
+
+ OPT_CHECK,
+ // to test a given patch (type-value pair) !
+ // Returns FAILURE or n>=0 of processed bytes-1
+
+
+ OPT_APPLY,
+ // to apply a previously created and adjusted patch
+ // Returns FAILURE or n>=0 of processed bytes-1
+
+
+ OPT_SET_POST,
+ // called whenever any option is changed and
+ // called ordered for each option and before next higher-order option
+ // Returns FAILURE or SUCCESS
+
+
+ OPT_POST,
+ // called whenever any option is changed and
+ // called ordered for each option after all options were (re-)set
+ // Returns FAILURE or SUCCESS
+
+
+ OPT_UNREGISTER
+ // called once before an option is unregistered
+ // Returns FAILURE or SUCCESS
+
+};
+
+// evaluates global variable: "on_the_fly"
+// fd may be set (>0) or not (=0)
+// cmd==OPT_SET_POST / OPT_POST:
+// s MBZ, return value is SUCCESS or FAILURE
+int32_t call_option( uint8_t del, uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *parent, char *in, struct ctrl_node *cn );
+
+int32_t check_apply_parent_option( uint8_t del, uint8_t cmd, uint8_t _save, struct opt_type *opt, char *in, struct ctrl_node *cn );
+
+struct opt_type *get_option( struct opt_type *parent_opt, uint8_t short_opt, char *s );
+
+
+
+void set_opt_child_val ( struct opt_child *c, char *val );
+struct opt_child * get_opt_child ( struct opt_type *opt, struct opt_parent *p );
+
+
+void del_opt_parent( struct opt_type *opt, struct opt_parent *parent );
+struct opt_parent * add_opt_parent( struct opt_type *opt );
+
+void set_opt_parent_val ( struct opt_parent *p, char *val );
+struct opt_parent * get_opt_parent_val ( struct opt_type *opt, char *val );
+void set_opt_parent_ref ( struct opt_parent *p, char *ref );
+struct opt_parent * get_opt_parent_ref ( struct opt_type *opt, char *ref );
+
+
+
+int8_t func_for_each_opt( struct ctrl_node *cn, void *data, char* func_name,
+ int8_t (*func) ( struct ctrl_node *cn, void *data, struct opt_type *opt, struct opt_parent *p, struct opt_child *c ) );
+
+int respect_opt_order( uint8_t test, int8_t last, int8_t next, struct opt_type *on, uint8_t load_config, uint8_t cmd, struct ctrl_node *cn );
+
+int8_t apply_stream_opts( char *s, uint8_t dryrun, uint8_t load_cfg, struct ctrl_node *cn );
+
+
+extern int (*load_config_cb) ( uint8_t test, struct opt_type *opt, struct ctrl_node *cn );
+
+extern int (*save_config_cb) ( uint8_t del, struct opt_type *opt, char *parent, char *val, struct ctrl_node *cn );
+
+extern int (*derive_config) ( char *reference, char *derivation, struct ctrl_node *cn );
+
+
+void register_option( struct opt_type *opt );
+//void remove_option( struct opt_type *opt );
+void register_options_array ( struct opt_type *fixed_options, int size );
+
+extern int32_t Load_config;
+
+
+int32_t get_tracked_network( struct opt_type *opt, struct opt_parent *patch, char *out, uint32_t *ip, int32_t *mask, struct ctrl_node *cn );
+int32_t adj_patched_network( struct opt_type *opt, struct opt_parent *patch, char *out, uint32_t *ip, int32_t *mask, struct ctrl_node *cn );
+
+
+void apply_init_args ( int argc, char *argv[] );
+
+extern struct opt_type Patch_opt;
+
+
+void init_control( void );
+void cleanup_control( void );
+
+void cleanup_config( void );
+
+
+//char *debugWordDup( char* word, int32_t tag );
+//static void strchange( char *s, char i, char o );
+//char* nextword( char *s );
+
+
+//usefult tools:
+char *ipStr( uint32_t addr );
+int8_t str2netw( char* args, uint32_t *ip, char delimiter, struct ctrl_node *cn, int32_t *val, int32_t max );
+void addr_to_str( uint32_t addr, char *str );
+
+int8_t wordsEqual ( char *a, char *b );
+void wordCopy( char *out, char *in );
+uint32_t wordlen ( char *s );
+int32_t check_file( char *path, uint8_t write, uint8_t exec );
+int32_t check_dir( char *path, uint8_t create, uint8_t write );
+uint32_t validate_net_mask( uint32_t ip, uint32_t mask, struct ctrl_node *cn );
Added: trunk/bmx/cyassl/config.h
===================================================================
--- trunk/bmx/cyassl/config.h (rev 0)
+++ trunk/bmx/cyassl/config.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,73 @@
+/* ctaocrypt/include/config.h. Generated from config.h.in by configure. */
+/* ctaocrypt/include/config.h.in. Generated from configure.in by autoheader. */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define if you have POSIX threads libraries and header files. */
+#define HAVE_PTHREAD 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Name of package */
+#define PACKAGE "cyassl"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+ your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `long long', as computed by sizeof. */
+#define SIZEOF_LONG_LONG 8
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "1.4.0"
+
+/* Define to 1 if your processor stores words with the most significant byte
+ first (like Motorola and SPARC, unlike Intel and VAX). */
+/* #undef WORDS_BIGENDIAN */
Added: trunk/bmx/cyassl/misc.c
===================================================================
--- trunk/bmx/cyassl/misc.c (rev 0)
+++ trunk/bmx/cyassl/misc.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,128 @@
+/* misc.c
+ *
+ * Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
+ *
+ * This file is part of CyaSSL.
+ *
+ * CyaSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * CyaSSL 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#include "misc.h"
+
+/* inlining these functions is a huge speed increase and a small size decrease,
+ because the functions are smaller than function call setup/cleanup, e.g.,
+ md5 benchmark is twice as fast with inline. If you don't want it, then
+ define NO_INLINE and compile this file into cyassl, otherwise it's used as
+ a source header
+ */
+
+#ifdef NO_INLINE
+ #define STATIC
+#else
+ #define STATIC static
+#endif
+
+
+#ifdef INTEL_INTRINSICS
+
+ #include <stdlib.h> /* get intrinsic definitions */
+
+ #pragma intrinsic(_lrotl, _lrotr)
+
+ STATIC INLINE word32 rotlFixed(word32 x, word32 y)
+ {
+ return y ? _lrotl(x, y) : x;
+ }
+
+ STATIC INLINE word32 rotrFixed(word32 x, word32 y)
+ {
+ return y ? _lrotr(x, y) : x;
+ }
+
+#else /* generic */
+
+ STATIC INLINE word32 rotlFixed(word32 x, word32 y)
+ {
+ return (x << y) | (x >> (sizeof(y) * 8 - y));
+ }
+
+
+ STATIC INLINE word32 rotrFixed(word32 x, word32 y)
+ {
+ return (x >> y) | (x << (sizeof(y) * 8 - y));
+ }
+
+#endif
+
+
+STATIC INLINE word32 ByteReverseWord32(word32 value)
+{
+#ifdef PPC_INTRINSICS
+ /* PPC: load reverse indexed instruction */
+ return (word32)__lwbrx(&value,0);
+#elif defined(FAST_ROTATE)
+ /* 5 instructions with rotate instruction, 9 without */
+ return (rotrFixed(value, 8U) & 0xff00ff00) |
+ (rotlFixed(value, 8U) & 0x00ff00ff);
+#else
+ /* 6 instructions with rotate instruction, 8 without */
+ value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
+ return rotlFixed(value, 16U);
+#endif
+}
+
+
+STATIC INLINE void ByteReverseWords(word32* out, const word32* in,
+ word32 byteCount)
+{
+ word32 count = byteCount/sizeof(word32), i;
+
+ for (i = 0; i < count; i++)
+ out[i] = ByteReverseWord32(in[i]);
+
+}
+
+
+STATIC INLINE void ByteReverseBytes(byte* out, const byte* in, word32 byteCount)
+{
+ word32* op = (word32*)out;
+ const word32* ip = (const word32*)in;
+
+ ByteReverseWords(op, ip, byteCount);
+}
+
+
+STATIC INLINE void XorWords(word* r, const word* a, word32 n)
+{
+ word32 i;
+
+ for (i = 0; i < n; i++) r[i] ^= a[i];
+}
+
+
+STATIC INLINE void xorbuf(byte* buf, const byte* mask, word32 count)
+{
+ if (((size_t)buf | (size_t)mask | count) % WORD_SIZE == 0)
+ XorWords( (word*)buf, (const word*)mask, count / WORD_SIZE);
+ else {
+ word32 i;
+ for (i = 0; i < count; i++) buf[i] ^= mask[i];
+ }
+}
+
+
+#undef STATIC
+
Added: trunk/bmx/cyassl/misc.h
===================================================================
--- trunk/bmx/cyassl/misc.h (rev 0)
+++ trunk/bmx/cyassl/misc.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,56 @@
+/* misc.h
+ *
+ * Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
+ *
+ * This file is part of CyaSSL.
+ *
+ * CyaSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * CyaSSL 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#ifndef CTAO_CRYPT_MISC_H
+#define CTAO_CRYPT_MISC_H
+
+
+#include "types.h"
+#include <string.h>
+
+
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+
+#ifdef NO_INLINE
+word32 rotlFixed(word32, word32);
+word32 rotrFixed(word32, word32);
+
+word32 ByteReverseWord32(word32);
+void ByteReverseWords(word32*, const word32*, word32);
+void ByteReverseBytes(byte*, const byte*, word32);
+
+void XorWords(word*, const word*, word32);
+void xorbuf(byte*, const byte*, word32);
+#endif /* NO_INLINE */
+
+
+#ifdef __cplusplus
+ } /* extern "C" */
+#endif
+
+
+#endif /* CTAO_CRYPT_MISC_H */
+
Added: trunk/bmx/cyassl/sha.c
===================================================================
--- trunk/bmx/cyassl/sha.c (rev 0)
+++ trunk/bmx/cyassl/sha.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,208 @@
+/* sha.c
+ *
+ * Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
+ *
+ * This file is part of CyaSSL.
+ *
+ * CyaSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * CyaSSL 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#include "sha.h"
+#ifdef NO_INLINE
+ #include "misc.h"
+#else
+ #include "misc.c"
+#endif
+#include <string.h>
+#include <assert.h>
+
+
+#ifndef min
+
+ static INLINE word32 min(word32 a, word32 b)
+ {
+ return a > b ? b : a;
+ }
+
+#endif /* min */
+
+
+void InitSha(Sha* sha)
+{
+ sha->digest[0] = 0x67452301L;
+ sha->digest[1] = 0xEFCDAB89L;
+ sha->digest[2] = 0x98BADCFEL;
+ sha->digest[3] = 0x10325476L;
+ sha->digest[4] = 0xC3D2E1F0L;
+
+ sha->buffLen = 0;
+ sha->loLen = 0;
+ sha->hiLen = 0;
+}
+
+
+#define f1(x,y,z) (z^(x &(y^z)))
+#define f2(x,y,z) (x^y^z)
+#define f3(x,y,z) ((x&y)|(z&(x|y)))
+#define f4(x,y,z) (x^y^z)
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+= f1(w,x,y) + W[i] + 0x5A827999+ \
+ rotlFixed(v,5); w = rotlFixed(w,30);
+#define R1(v,w,x,y,z,i) z+= f1(w,x,y) + W[i] + 0x5A827999+ \
+ rotlFixed(v,5); w = rotlFixed(w,30);
+#define R2(v,w,x,y,z,i) z+= f2(w,x,y) + W[i] + 0x6ED9EBA1+ \
+ rotlFixed(v,5); w = rotlFixed(w,30);
+#define R3(v,w,x,y,z,i) z+= f3(w,x,y) + W[i] + 0x8F1BBCDC+ \
+ rotlFixed(v,5); w = rotlFixed(w,30);
+#define R4(v,w,x,y,z,i) z+= f4(w,x,y) + W[i] + 0xCA62C1D6+ \
+ rotlFixed(v,5); w = rotlFixed(w,30);
+
+
+static void Transform(Sha* sha)
+{
+ word32 W[80], i;
+
+ /* Copy context->state[] to working vars */
+ word32 a = sha->digest[0];
+ word32 b = sha->digest[1];
+ word32 c = sha->digest[2];
+ word32 d = sha->digest[3];
+ word32 e = sha->digest[4];
+
+ for (i = 0; i < 16; i++)
+ W[i] = sha->buffer[i];
+
+ for (i = 16; i < 80; i++)
+ W[i] = rotlFixed(W[i-3]^W[i-8]^W[i-14]^W[i-16],1);
+
+ /* 4 rounds of 20 operations each. */
+ for (i = 0; i < 20; ) {
+ R0(a,b,c,d,e,i); i++;
+ R0(e,a,b,c,d,i); i++;
+ R0(d,e,a,b,c,i); i++;
+ R0(c,d,e,a,b,i); i++;
+ R0(b,c,d,e,a,i); i++;
+ }
+
+ for (i = 20; i < 40; ) {
+ R2(a,b,c,d,e,i); i++;
+ R2(e,a,b,c,d,i); i++;
+ R2(d,e,a,b,c,i); i++;
+ R2(c,d,e,a,b,i); i++;
+ R2(b,c,d,e,a,i); i++;
+ }
+
+ for (i = 40; i < 60; ) {
+ R3(a,b,c,d,e,i); i++;
+ R3(e,a,b,c,d,i); i++;
+ R3(d,e,a,b,c,i); i++;
+ R3(c,d,e,a,b,i); i++;
+ R3(b,c,d,e,a,i); i++;
+ }
+
+ for (i = 60; i < 80; ) {
+ R4(a,b,c,d,e,i); i++;
+ R4(e,a,b,c,d,i); i++;
+ R4(d,e,a,b,c,i); i++;
+ R4(c,d,e,a,b,i); i++;
+ R4(b,c,d,e,a,i); i++;
+ }
+
+ /* Add the working vars back into digest state[] */
+ sha->digest[0] += a;
+ sha->digest[1] += b;
+ sha->digest[2] += c;
+ sha->digest[3] += d;
+ sha->digest[4] += e;
+}
+
+
+static INLINE void AddLength(Sha* sha, word32 len)
+{
+ word32 tmp = sha->loLen;
+ if ( (sha->loLen += len) < tmp)
+ sha->hiLen++; /* carry low to high */
+}
+
+
+void ShaUpdate(Sha* sha, const byte* data, word32 len)
+{
+ /* do block size increments */
+ byte* local = (byte*)sha->buffer;
+
+ while (len) {
+ word32 add = min(len, SHA_BLOCK_SIZE - sha->buffLen);
+ memcpy(&local[sha->buffLen], data, add);
+
+ sha->buffLen += add;
+ data += add;
+ len -= add;
+
+ if (sha->buffLen == SHA_BLOCK_SIZE) {
+ #ifdef LITTLE_ENDIAN_ORDER
+ ByteReverseBytes(local, local, SHA_BLOCK_SIZE);
+ #endif
+ Transform(sha);
+ AddLength(sha, SHA_BLOCK_SIZE);
+ sha->buffLen = 0;
+ }
+ }
+}
+
+
+void ShaFinal(Sha* sha, byte* hash)
+{
+ byte* local = (byte*)sha->buffer;
+
+ AddLength(sha, sha->buffLen); /* before adding pads */
+
+ local[sha->buffLen++] = 0x80; /* add 1 */
+
+ /* pad with zeros */
+ if (sha->buffLen > SHA_PAD_SIZE) {
+ memset(&local[sha->buffLen], 0, SHA_BLOCK_SIZE - sha->buffLen);
+ sha->buffLen += SHA_BLOCK_SIZE - sha->buffLen;
+
+ #ifdef LITTLE_ENDIAN_ORDER
+ ByteReverseBytes(local, local, SHA_BLOCK_SIZE);
+ #endif
+ Transform(sha);
+ sha->buffLen = 0;
+ }
+ memset(&local[sha->buffLen], 0, SHA_PAD_SIZE - sha->buffLen);
+
+ /* put lengths in bits */
+ sha->loLen = sha->loLen << 3;
+ sha->hiLen = (sha->loLen >> (8*sizeof(sha->loLen) - 3)) +
+ (sha->hiLen << 3);
+
+ /* store lengths */
+ #ifdef LITTLE_ENDIAN_ORDER
+ ByteReverseBytes(local, local, SHA_BLOCK_SIZE);
+ #endif
+ memcpy(&local[SHA_PAD_SIZE], &sha->hiLen, sizeof(word32));
+ memcpy(&local[SHA_PAD_SIZE + sizeof(word32)], &sha->loLen, sizeof(word32));
+
+ Transform(sha);
+ #ifdef LITTLE_ENDIAN_ORDER
+ ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE);
+ #endif
+ memcpy(hash, sha->digest, SHA_DIGEST_SIZE);
+
+ InitSha(sha); /* reset state */
+}
+
Added: trunk/bmx/cyassl/sha.h
===================================================================
--- trunk/bmx/cyassl/sha.h (rev 0)
+++ trunk/bmx/cyassl/sha.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,62 @@
+/* sha.h
+ *
+ * Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
+ *
+ * This file is part of CyaSSL.
+ *
+ * CyaSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * CyaSSL 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#ifndef CTAO_CRYPT_SHA_H
+#define CTAO_CRYPT_SHA_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+
+
+/* in bytes */
+enum {
+ SHA_BLOCK_SIZE = 64,
+ SHA_DIGEST_SIZE = 20,
+ SHA_PAD_SIZE = 56
+};
+
+
+/* Sha digest */
+typedef struct Sha {
+ word32 buffLen; /* in bytes */
+ word32 loLen; /* length in bytes */
+ word32 hiLen; /* length in bytes */
+ word32 digest[SHA_DIGEST_SIZE / sizeof(word32)];
+ word32 buffer[SHA_BLOCK_SIZE / sizeof(word32)];
+} Sha;
+
+
+void InitSha(Sha*);
+void ShaUpdate(Sha*, const byte*, word32);
+void ShaFinal(Sha*, byte*);
+
+
+#ifdef __cplusplus
+ } /* extern "C" */
+#endif
+
+#endif /* CTAO_CRYPT_SHA_H */
+
Added: trunk/bmx/cyassl/types.h
===================================================================
--- trunk/bmx/cyassl/types.h (rev 0)
+++ trunk/bmx/cyassl/types.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,153 @@
+/* types.h
+ *
+ * Copyright (C) 2006-2009 Sawtooth Consulting Ltd.
+ *
+ * This file is part of CyaSSL.
+ *
+ * CyaSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * CyaSSL 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#ifndef CTAO_CRYPT_TYPES_H
+#define CTAO_CRYPT_TYPES_H
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+
+#ifdef XMALLOC_USER
+ #include <stdlib.h> /* for size_t */
+#endif
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+
+#if defined(WORDS_BIGENDIAN) || (defined(__MWERKS__) && !defined(__INTEL__))
+ #define BIG_ENDIAN_ORDER
+#endif
+
+#ifndef BIG_ENDIAN_ORDER
+ #define LITTLE_ENDIAN_ORDER
+#endif
+
+#ifdef IPHONE
+ #define SIZEOF_LONG_LONG 8
+#endif
+
+#ifdef THREADX
+ #define SIZEOF_LONG_LONG 8
+#endif
+
+
+typedef unsigned char byte;
+typedef unsigned short word16;
+typedef unsigned int word32;
+
+#if defined(_MSC_VER) || defined(__BCPLUSPLUS__)
+ #define WORD64_AVAILABLE
+ #define WORD64_IS_DISTINCT_TYPE
+ typedef unsigned __int64 word64;
+#elif SIZEOF_LONG == 8
+ #define WORD64_AVAILABLE
+ typedef unsigned long word64;
+#elif SIZEOF_LONG_LONG == 8
+ #define WORD64_AVAILABLE
+ #define WORD64_IS_DISTINCT_TYPE
+ typedef unsigned long long word64;
+#else
+ #define MP_16BIT /* for mp_int, mp_word needs to be twice as big as
+ mp_digit, no 64 bit type so make mp_digit 16 bit */
+#endif
+
+
+/* These platforms have 64-bit CPU registers. */
+#if (defined(__alpha__) || defined(__ia64__) || defined(_ARCH_PPC64) || \
+ defined(__mips64) || defined(__x86_64__))
+ typedef word32 hword;
+ typedef word64 word;
+#else
+ typedef word16 hword;
+ typedef word32 word;
+ #ifdef WORD64_AVAILABLE
+ typedef word64 dword;
+ #endif
+#endif
+
+
+enum {
+ WORD_SIZE = sizeof(word),
+ BIT_SIZE = 8,
+ WORD_BITS = WORD_SIZE * BIT_SIZE
+};
+
+
+/* use inlining if compiler allows */
+#ifndef NO_INLINE
+ #ifdef _MSC_VER
+ #define INLINE __inline
+ #elif __GNUC__
+ #define INLINE inline
+ #elif THREADX
+ #define INLINE _Inline
+ #else
+ #define INLINE
+ #endif
+#else
+ #define INLINE
+#endif
+
+
+/* set up rotate style */
+#if defined(_MSC_VER) || defined(__BCPLUSPLUS__)
+ #define INTEL_INTRINSICS
+ #define FAST_ROTATE
+#elif defined(__MWERKS__) && TARGET_CPU_PPC
+ #define PPC_INTRINSICS
+ #define FAST_ROTATE
+#elif defined(__GNUC__) && defined(__i386__)
+ /* GCC does peephole optimizations which should result in using rotate
+ instructions */
+ #define FAST_ROTATE
+#endif
+
+
+/* idea to add global alloc override by Moisés Guimarães */
+/* default to libc stuff */
+/* XCALLOC not used by CyaSSL or either math lib */
+/* XREALLOC is used once in mormal math lib, not in fast math lib */
+/* XFREE on some embeded systems doesn't like free(0) so test */
+#ifndef XMALLOC_USER
+ #define XMALLOC(s, h) malloc(s)
+ #define XFREE(p, h) if (p) free(p)
+ #define XREALLOC(p, n, h) realloc(p, n)
+ #define XCALLOC(n, s, h) calloc(n, s)
+#else
+ /* prototypes for our heap functions */
+ extern void *XMALLOC(size_t n, void* heap);
+ extern void *XREALLOC(void *p, size_t n, void* heap);
+ extern void *XCALLOC(size_t n, size_t s, void* heap);
+ extern void XFREE(void *p, void* heap);
+#endif
+
+
+#ifdef __cplusplus
+ } /* extern "C" */
+#endif
+
+
+#endif /* CTAO_CRYPT_TYPES_H */
+
Added: trunk/bmx/hna.c
===================================================================
--- trunk/bmx/hna.c (rev 0)
+++ trunk/bmx/hna.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,445 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <asm/types.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+
+
+#include "bmx.h"
+#include "msg.h"
+#include "plugin.h"
+#include "hna.h"
+#include "route.h"
+
+AVL_TREE(global_uhna_tree, struct uhna4_node, key );
+AVL_TREE(local_uhna_tree, struct uhna4_node, key );
+
+/*
+struct uhna4_node *get_global_uhna_node(struct uhna4_key* key)
+{
+ return avl_find_item(&global_uhna_tree, key);
+}
+*/
+
+
+void set_uhna4_key(struct uhna4_key *key, uint8_t prefix_len, IP4_T glip4, uint32_t metric)
+{
+ memset( key, 0, sizeof(struct uhna4_key));
+ key->prefix_len = prefix_len;
+ key->glip4 = glip4;
+ key->metric_be = htonl(metric);
+
+}
+
+
+
+
+
+int create_description_tlv_ip4(uint8_t *data, uint16_t max_size)
+{
+ struct avl_node *it = NULL;
+ struct dev_node *dev = primary_if;
+ int item = 0;
+ struct description0_msg_ip4 *glip4 = (struct description0_msg_ip4*) data;
+
+ do {
+ if (item == 0 || (dev != primary_if && dev->announce)) {
+
+ if ((item+1) * sizeof (struct description0_msg_ip4) > max_size) {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "unable to announce %s %s due to limiting --%s=%d",
+ dev->name, dev->ip4_str, ARG_UDPD_SIZE, max_size);
+ break;
+ }
+
+ glip4[item++].ip4 = dev->ip4_addr;
+ }
+
+ } while ((dev = avl_iterate_item(&dev_ip4_tree, &it)));
+
+ return item * sizeof (struct description0_msg_ip4);
+}
+
+int create_description_tlv_hna4(uint8_t *data, uint16_t max_size)
+{
+ struct avl_node *it = NULL;
+ struct dev_node *dev;
+ struct uhna4_node *un;
+ int item = 0;
+ struct description0_msg_hna4 *uhna4 = (struct description0_msg_hna4*) data;
+
+ while ((un = avl_iterate_item(&local_uhna_tree, &it))) {
+
+ if (!un->key.metric_be && un->key.prefix_len==32 &&
+ (dev = avl_find_item(&dev_ip4_tree, &(un->key.glip4))) && dev->announce)
+ continue;
+
+ if (item * sizeof (struct description0_msg_hna4) > max_size) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "unable to announce %s/%d metric %d due to limiting --%s=%d",
+ ipStr(un->key.glip4), un->key.prefix_len, ntohl(un->key.metric_be),
+ ARG_UDPD_SIZE, max_size );
+ continue;
+ }
+
+ uhna4[item].ip4 = un->key.glip4;
+ uhna4[item].metric = un->key.metric_be;
+ uhna4[item].prefix_len = un->key.prefix_len;
+ item++;
+ }
+
+ return item * sizeof (struct description0_msg_hna4);
+}
+
+
+
+int process_description_tlv_hna4(struct orig_node *on, struct frame_header *tlv, IDM_T op, struct ctrl_node *cn )
+{
+ struct description0_msg_ip4 *glip4 = NULL;
+ struct description0_msg_hna4 *uhna4 = NULL;
+
+ assertion(-500357, (tlv->type == BMX_DSC_TLV_GLIP4 || tlv->type == BMX_DSC_TLV_UHNA4));
+
+ uint16_t msgs_size = ntohs(tlv->length) - sizeof (struct frame_header);
+ uint16_t msg_size, m, msgs;
+
+ if (tlv->type == BMX_DSC_TLV_GLIP4) {
+ glip4 = (struct description0_msg_ip4 *) tlv->data;
+ msg_size = sizeof (struct description0_msg_ip4);
+ } else {
+ uhna4 = (struct description0_msg_hna4 *) tlv->data;
+ msg_size = sizeof (struct description0_msg_hna4);
+ }
+
+ msgs = msgs_size / msg_size;
+
+ for (m = 0; m < msgs; m++) {
+ struct uhna4_key key;
+
+ if (glip4) {
+ set_uhna4_key(&key, 32, glip4[m].ip4, 0);
+ } else {
+ set_uhna4_key(&key, uhna4[m].prefix_len, uhna4[m].ip4, ntohl(uhna4[m].metric));
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s/%d metric %d",
+ tlv_op_str[op], glip4 ? "glip4:" : "uhna4:",
+ ipStr(key.glip4), key.prefix_len, ntohl(key.metric_be));
+
+ if (op == TLV_DEL_TEST_ADD) {
+
+ struct uhna4_node *un = avl_remove(&global_uhna_tree, &key, -300215);
+ assertion(-500358, (un && un->on == on));
+ debugFree( un, -300161 );
+ if (m == 0 && glip4) {
+ on->primary_ip4 = 0;
+ addr_to_str(0, on->primary_ip4_str);
+ }
+
+ } else if (op == TLV_TEST) {
+
+ if (avl_find(&global_uhna_tree, &key))
+ return TLVS_BLOCKED;
+
+ } else if (op == TLV_ADD) {
+
+ struct uhna4_node *un = debugMalloc( sizeof(struct uhna4_node),-300162 );
+ memset(un, 0, sizeof (struct uhna4_node));
+ memcpy(&un->key, &key, sizeof ( struct uhna4_key));
+ ASSERTION( -500359, (!avl_find(&global_uhna_tree, &key)));
+ un->on = on;
+ avl_insert(&global_uhna_tree, un, -300163);
+
+ if (m == 0 && glip4) {
+ on->primary_ip4 = key.glip4;
+ addr_to_str(on->primary_ip4, on->primary_ip4_str);
+ }
+
+ } else if ( op == TLV_DEBUG ) {
+
+ dbg_printf(cn, " %s %s/%d metric %d\n", glip4 ? "glip4:" : "uhna4:",
+ ipStr(key.glip4), key.prefix_len, ntohl(key.metric_be) );
+
+ } else {
+ assertion( -500369, (NO));
+ }
+ }
+
+ return TLVS_SUCCESS;
+}
+
+
+
+
+void configure_hna ( IDM_T del, struct uhna4_key* key, struct orig_node *on ) {
+
+ struct uhna4_node *un = avl_find_item( &global_uhna_tree, key );
+
+ paranoia( -500236, ((del && !un) || (!del && un)) );
+
+ // update uhna_tree:
+ if ( del ) {
+
+ paranoia(-500234, (on != un->on));
+ avl_remove(&global_uhna_tree, &un->key, -300212);
+ ASSERTION( -500233, (!avl_find( &global_uhna_tree, key)) ); // there should be only one element with this key
+
+ if ( !on)
+ avl_remove(&local_uhna_tree, &un->key, -300213);
+
+ } else {
+
+ un = debugMalloc( sizeof (struct uhna4_node), -300090 );
+ un->key = *key;
+ un->on = on;
+ avl_insert(&global_uhna_tree, un, -300149);
+
+ if (!on)
+ avl_insert(&local_uhna_tree, un, -300150);
+ }
+
+ if ( on ) {
+
+ // update network routes:
+ if ( del) {
+ configure_route(key->glip4, key->prefix_len, ntohl(key->metric_be),
+ 0, my_orig_node.primary_ip4,
+ 0, 0,
+ RT_TABLE_NETWORKS, RTN_UNICAST, DEL, TRACK_OTHER_HNA);
+ } else {
+ ASSERTION(-500239, (avl_find( &link_dev_tree, &on->router_key)));
+
+ configure_route(key->glip4, key->prefix_len, ntohl(key->metric_be),
+ on->router_key.llip4, my_orig_node.primary_ip4,
+ on->router_key.dev->index, on->router_key.dev->name,
+ RT_TABLE_NETWORKS, RTN_UNICAST, ADD, TRACK_OTHER_HNA);
+ }
+
+ } else {
+ // update my description:
+ update_my_description_adv();
+
+ // update throw routes:
+ configure_route(key->glip4, key->prefix_len, 0, 0, 0, 0, "unknown", RT_TABLE_HOSTS, RTN_THROW, del, TRACK_MY_HNA);
+ configure_route(key->glip4, key->prefix_len, 0, 0, 0, 0, "unknown", RT_TABLE_NETWORKS, RTN_THROW, del, TRACK_MY_HNA);
+ configure_route(key->glip4, key->prefix_len, 0, 0, 0, 0, "unknown", RT_TABLE_TUNNEL, RTN_THROW, del, TRACK_MY_HNA);
+ }
+
+
+ if ( del)
+ debugFree(un, -300089);
+
+}
+
+STATIC_FUNC
+int32_t opt_hna ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ uint32_t ip;
+ int32_t mask;
+ uint32_t metric = 0;
+ struct uhna4_key key;
+
+ char new[30];
+
+ if ( cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ dbgf( DBGL_CHANGES, DBGT_INFO, "diff %d cmd %s save %d opt %s patch %s",
+ patch->p_diff, opt_cmd2str[cmd], _save, opt->long_name, patch->p_val);
+
+
+ if ( patch->p_val[0] >= '0' && patch->p_val[0] <= '9' ) {
+
+ // the unnamed UHNA
+ dbgf(DBGL_CHANGES, DBGT_INFO, "unnamed UHNA diff %d cmd %s save %d opt %s patch %s",
+ patch->p_diff, opt_cmd2str[cmd], _save, opt->long_name, patch->p_val);
+
+ if ( str2netw( patch->p_val, &ip, '/', cn, &mask, 32 ) == FAILURE )
+ return FAILURE;
+
+ sprintf( new, "%s/%d", ipStr( validate_net_mask( ip, mask, 0 ) ), mask );
+ set_opt_parent_val( patch, new );
+
+ if ( cmd == OPT_ADJUST )
+ return SUCCESS;
+
+ } else {
+
+ // the named UHNA
+
+ if ( adj_patched_network( opt, patch, new, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+
+ if ( cmd == OPT_ADJUST )
+ return SUCCESS;
+
+ if ( patch->p_diff == NOP ) {
+
+ // change network and netmask parameters of an already configured and named HNA
+
+ char old[30];
+
+ // 1. check if announcing the new HNA would not block,
+ if ( check_apply_parent_option( ADD, OPT_CHECK, NO, opt, new, cn ) == FAILURE )
+ return FAILURE;
+
+ if ( get_tracked_network( opt, patch, old, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+
+ // 3. remove the old HNA and hope to not mess it up...
+ set_uhna4_key(&key, mask, ip, metric);
+
+ if ( cmd == OPT_APPLY )
+ configure_hna(DEL, &key, NULL);
+
+
+ }
+
+ // then continue with the new HNA
+ if ( str2netw( new , &ip, '/', cn, &mask, 32 ) == FAILURE )
+ return FAILURE;
+ }
+
+ set_uhna4_key(&key, mask, ip, metric);
+
+ struct uhna4_node *un;
+
+ if (patch->p_diff != DEL && (un = (avl_find_item(&global_uhna_tree, &key)))) {
+
+ dbg_cn( cn, DBGL_CHANGES, DBGT_ERR, "UHNA %s/%d metric %d already blocked by %s !",
+ ipStr(ip), mask, metric, (un->on ? un->on->primary_ip4_str : "myself"));
+
+ return FAILURE;
+ }
+
+ if ( cmd == OPT_APPLY )
+ configure_hna((patch->p_diff == DEL ? DEL : ADD), &key, NULL);
+
+
+
+ } else if ( cmd == OPT_UNREGISTER ) {
+
+ struct avl_node *an;
+
+ while ((an = global_uhna_tree.root))
+ configure_hna(DEL, (struct uhna4_key*) AVL_NODE_KEY( &global_uhna_tree, an), NULL);
+
+ }
+
+ return SUCCESS;
+
+}
+
+STATIC_FUNC
+int32_t opt_show_hnas ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+
+ if ( cmd == OPT_APPLY ) {
+
+ dbg_printf( cn, "unicast HNA metric Originator \n");
+
+ struct avl_node *an = NULL;
+ struct uhna4_node *un;
+ uint16_t hna_count = 0;
+
+ while ((un = (struct uhna4_node*) ((an = avl_iterate(&global_uhna_tree, an)) ? an->item : NULL))) {
+
+ paranoia(-500361, (un->on && !un->on->desc0));
+
+ dbg_printf(cn, "%15s/%-2d %10d %-15s %s \n",
+ ipStr(un->key.glip4), un->key.prefix_len, ntohl(un->key.metric_be),
+ un->on ? un->on->primary_ip4_str : "localhost",
+ un->on ? un->on->desc0->id.name : " ");
+
+ process_description_tlvs(un->on, NULL, TLV_DEBUG, cn);
+ hna_count++;
+ }
+
+ dbg_printf( cn, "\n" );
+ }
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+struct opt_type hna_options[]= {
+// ord parent long_name shrt Attributes *ival min max default *function
+
+ {ODI,0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nHost and Network Announcement (HNA) options:"},
+
+ {ODI,0,ARG_UHNA, 'u',5,A_PMN,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_hna,
+ ARG_PREFIX_FORM,"perform host-network announcement (HNA) for defined ip range"},
+
+ {ODI,ARG_UHNA,ARG_NETW, 'n',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_hna,
+ ARG_NETW_FORM, "specify network of announcement"},
+
+ {ODI,ARG_UHNA,ARG_MASK, 'm',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_hna,
+ ARG_MASK_FORM, "specify network prefix of announcement"},
+
+
+ {ODI,0,ARG_HNAS, 0, 5,A_PS0,A_USR,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_hnas,
+ 0, "show HNAs of other nodes\n"}
+
+};
+
+
+
+
+STATIC_FUNC
+void hna_cleanup( void ) {
+
+}
+
+
+STATIC_FUNC
+int32_t hna_init( void ) {
+
+ register_options_array( hna_options, sizeof( hna_options ) );
+
+ return SUCCESS;
+}
+
+
+
+struct plugin_v2 *hna_get_plugin_v2( void ) {
+
+ static struct plugin_v2 hna_plugin;
+ memset( &hna_plugin, 0, sizeof ( struct plugin_v2 ) );
+
+ hna_plugin.plugin_version = PLUGIN_VERSION_02;
+ hna_plugin.plugin_name = "bmx_hna_plugin";
+ hna_plugin.plugin_size = sizeof ( struct plugin_v2 );
+ hna_plugin.plugin_bmx_revision = REVISION_VERSION;
+ hna_plugin.plugin_bmx_version = SOURCE_VERSION;
+ hna_plugin.cb_init = hna_init;
+ hna_plugin.cb_cleanup = hna_cleanup;
+
+ return &hna_plugin;
+}
+
+
Added: trunk/bmx/hna.h
===================================================================
--- trunk/bmx/hna.h (rev 0)
+++ trunk/bmx/hna.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+
+#define ARG_UHNA "unicast_hna"
+#define ARG_HNAS "uhnas"
+
+struct uhna4_key {
+ uint8_t reserved;
+ uint8_t prefix_len;
+ IP4_T glip4;
+ uint32_t metric_be;
+};
+
+struct uhna4_node {
+ struct uhna4_key key;
+ struct orig_node *on;
+};
+
+extern struct avl_tree global_uhna_tree;
+extern struct avl_tree local_uhna_tree;
+
+struct plugin_v2 *hna_get_plugin_v2( void );
+
+void set_uhna4_key(struct uhna4_key *key, uint8_t prefix_len, IP4_T glip4, uint32_t metric);
+
+int create_description_tlv_ip4(uint8_t *data, uint16_t max_size);
+int create_description_tlv_hna4(uint8_t *data, uint16_t max_size);
+
+int process_description_tlv_hna4(struct orig_node *on, struct frame_header *tlv, IDM_T op, struct ctrl_node *cn );
+
+
+//struct uhna4_node *get_global_uhna_node( struct uhna4_key* key );
+
Added: trunk/bmx/iid.c
===================================================================
--- trunk/bmx/iid.c (rev 0)
+++ trunk/bmx/iid.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <string.h>
+#include <stdio.h>
+
+#include "bmx.h"
+#include "iid.h"
+
+struct iid_repos my_iid_repos = { 0,0,0,0,{NULL} };
+
+int8_t iid_extend_repos(struct iid_repos *rep)
+{
+ dbgf( DBGL_CHANGES, DBGT_INFO, "sizeof iid: %lu, tot_used %d arr_size %d ",
+ (rep == &my_iid_repos) ? sizeof (IID_NODE_T*) : sizeof (IID_T), rep->tot_used, rep->arr_size);
+
+ paranoia(-500217, (rep == &my_iid_repos && rep->tot_used != rep->arr_size));
+
+ if (rep->arr_size + IID_REPOS_SIZE_BLOCK >= IID_REPOS_SIZE_WARN) {
+
+ dbgf( DBGL_SYS, DBGT_WARN, "%d", rep->arr_size);
+
+ if (rep->arr_size + IID_REPOS_SIZE_BLOCK >= IID_REPOS_SIZE_MAX)
+ return FAILURE;
+ }
+
+ int field_size = (rep == &my_iid_repos) ? sizeof (IID_NODE_T*) : sizeof (struct iid_ref);
+
+ if (rep->arr_size) {
+
+ rep->arr.u8 = debugRealloc(rep->arr.u8, (rep->arr_size + IID_REPOS_SIZE_BLOCK) * field_size, -300035);
+
+ } else {
+
+ rep->arr.u8 = debugMalloc(IID_REPOS_SIZE_BLOCK * field_size, -300085);
+ rep->tot_used = IID_RSVD_MAX+1;
+ rep->min_free = IID_RSVD_MAX+1;
+ rep->max_free = IID_RSVD_MAX+1;
+ }
+
+ memset(&(rep->arr.u8[rep->arr_size * field_size]), 0, IID_REPOS_SIZE_BLOCK * field_size);
+
+ rep->arr_size += IID_REPOS_SIZE_BLOCK;
+
+ return SUCCESS;
+}
+
+
+void iid_purge_repos( struct iid_repos *rep )
+{
+
+ if (rep->arr.u8)
+ debugFree(rep->arr.u8, -300135);
+
+ memset(rep, 0, sizeof ( struct iid_repos));
+
+}
+
+void iid_free(struct iid_repos *rep, IID_T iid)
+{
+ int m = (rep == &my_iid_repos);
+
+ assertion(-500330, (iid > IID_RSVD_MAX));
+ assertion(-500228, (iid < rep->arr_size && iid < rep->max_free && rep->tot_used > IID_RSVD_MAX));
+ assertion(-500229, ((m ? (rep->arr.node[iid] != NULL) : (rep->arr.ref[iid].myIID4x) != 0)));
+
+ if (m) {
+ rep->arr.node[iid] = NULL;
+ } else {
+ rep->arr.ref[iid].myIID4x = 0;
+ rep->arr.ref[iid].referred_timestamp_sec = 0;
+ }
+
+ rep->min_free = MIN(rep->min_free, iid);
+
+ if (rep->max_free == iid + 1) {
+
+ IID_T i;
+
+ for (i = iid; i > IID_MIN_USED; i--) {
+
+ if (m ? (rep->arr.node[i - 1] != NULL) : (rep->arr.ref[i - 1].myIID4x) != 0)
+ break;
+ }
+
+ rep->max_free = i;
+ }
+
+ rep->tot_used--;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
+ m, iid, rep->tot_used, rep->min_free, rep->max_free);
+
+ if (rep->tot_used > 0 && rep->tot_used <= IID_MIN_USED) {
+
+ assertion(-500362, (rep->tot_used == IID_MIN_USED && rep->max_free == IID_MIN_USED && rep->min_free == IID_MIN_USED));
+
+ iid_purge_repos( rep );
+
+ }
+
+}
+
+
+
+IID_NODE_T* iid_get_node_by_myIID4x( IID_T myIID4x ) {
+
+ if ( my_iid_repos.max_free <= myIID4x )
+ return NULL;
+
+ IID_NODE_T *dhn = my_iid_repos.arr.node[myIID4x];
+
+ assertion(-500328, (!dhn || dhn->myIID4orig == myIID4x));
+
+ if (dhn) {
+
+ if (!dhn->on) {
+ dbgf(DBGL_CHANGES, DBGT_INFO, "myIID4x %d INVALIDATED %d sec ago",
+ myIID4x, (bmx_time - dhn->referred_timestamp) / 1000);
+ }
+
+ dhn->referred_timestamp = bmx_time;
+ }
+
+
+ return dhn;
+}
+
+
+IID_NODE_T* iid_get_node_by_neighIID4x( IID_NEIGH_T *nn, IID_T neighIID4x )
+{
+
+ if (!nn || nn->neighIID4x_repos.max_free <= neighIID4x)
+ return NULL;
+
+ struct iid_ref *ref = &(nn->neighIID4x_repos.arr.ref[neighIID4x]);
+
+
+ if (ref->myIID4x && ((((uint16_t) bmx_time_sec) - ref->referred_timestamp_sec) <=
+ ((MIN_DHASH_TO - (MIN_DHASH_TO / DHASH_TO_TOLERANCE_FK)) / 1000))) {
+
+ ref->referred_timestamp_sec = bmx_time_sec;
+
+ return iid_get_node_by_myIID4x(ref->myIID4x);
+ }
+
+ return NULL;
+}
+
+
+
+int8_t iid_set_neighIID4x(struct iid_repos *neigh_rep, IID_T neighIID4x, IID_T myIID4x)
+{
+ assertion(-500326, (neighIID4x > IID_RSVD_MAX));
+ assertion(-500327, (myIID4x > IID_RSVD_MAX));
+ assertion(-500384, (neigh_rep && neigh_rep != &my_iid_repos));
+
+ assertion(-500245, (my_iid_repos.max_free > myIID4x));
+
+ IID_NODE_T *dhn = my_iid_repos.arr.node[myIID4x];
+
+ assertion(-500485, (dhn && dhn->on));
+
+ dhn->referred_timestamp = bmx_time;
+
+ if (neigh_rep->max_free > neighIID4x) {
+
+ struct iid_ref *ref = &(neigh_rep->arr.ref[neighIID4x]);
+
+ if (ref->myIID4x > IID_RSVD_MAX) {
+
+ if (ref->myIID4x == myIID4x ||
+ (((uint16_t)(((uint16_t) bmx_time_sec) - ref->referred_timestamp_sec)) >=
+ ((MIN_DHASH_TO - (MIN_DHASH_TO / DHASH_TO_TOLERANCE_FK)) / 1000))) {
+
+ neigh_rep->arr.ref[neighIID4x].myIID4x = myIID4x;
+ neigh_rep->arr.ref[neighIID4x].referred_timestamp_sec = bmx_time_sec;
+ return SUCCESS;
+ }
+
+ dbgf(DBGL_SYS, DBGT_ERR, "neighIID4x %d for %s changed (at sec %d ) faster than allowed!!",
+ neighIID4x, dhn->on->id.name, ref->referred_timestamp_sec);
+
+ return FAILURE;
+ }
+
+ assertion(-500242, (ref->myIID4x == IID_RSVD_UNUSED));
+ }
+
+
+ while (neigh_rep->arr_size <= neighIID4x) {
+
+ if (neigh_rep->tot_used < neigh_rep->arr_size / IID_REPOS_USAGE_WARNING) {
+ dbgf(DBGL_SYS, DBGT_WARN, "IID_REPOS_USAGE_WARNING did %d sid %d arr_size %d used %d",
+ neighIID4x, myIID4x, neigh_rep->arr_size, neigh_rep->tot_used );
+ }
+
+ iid_extend_repos(neigh_rep);
+ }
+
+ assertion(-500243, ((neigh_rep->arr_size > neighIID4x &&
+ (neigh_rep->max_free <= neighIID4x || neigh_rep->arr.ref[neighIID4x].myIID4x == IID_RSVD_UNUSED))));
+
+ neigh_rep->tot_used++;
+ neigh_rep->max_free = MAX( neigh_rep->max_free, neighIID4x+1 );
+
+ IID_T min = neigh_rep->min_free;
+
+ if (min == neighIID4x) {
+ for (; min < neigh_rep->arr_size && neigh_rep->arr.ref[min].myIID4x; min++);
+ }
+
+ paranoia(-500244, (min > neigh_rep->max_free));
+
+ neigh_rep->min_free = min;
+
+ neigh_rep->arr.ref[neighIID4x].myIID4x = myIID4x;
+ neigh_rep->arr.ref[neighIID4x].referred_timestamp_sec = bmx_time_sec;
+
+ return SUCCESS;
+}
+
+void iid_free_neighIID4x_by_myIID4x( struct iid_repos *rep, IID_T myIID4x)
+{
+ assertion(-500282, (rep != &my_iid_repos));
+ assertion(-500328, (myIID4x > IID_RSVD_MAX));
+
+ IID_T p;
+
+ for (p = IID_RSVD_MAX + 1; p < rep->max_free && rep->arr.ref[p].myIID4x != myIID4x; p++);
+
+ if (p < rep->max_free && rep->arr.ref[p].myIID4x == myIID4x) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "removed stale rep->arr.sid[%d] = %d", p, myIID4x);
+
+ iid_free(rep, p);
+ }
+}
+
+IID_T iid_new_myIID4x(IID_NODE_T *dhn)
+{
+
+ paranoia( -500216, ( my_iid_repos.tot_used > my_iid_repos.arr_size ) );
+
+ while ( my_iid_repos.tot_used >= my_iid_repos.arr_size )
+ iid_extend_repos( &my_iid_repos );
+
+ IID_T mid = my_iid_repos.min_free;
+ IID_T pos = mid + 1;
+
+
+ my_iid_repos.tot_used++;
+ my_iid_repos.arr.node[mid] = dhn;
+
+ for (; pos < my_iid_repos.arr_size && (my_iid_repos.arr.node[pos]); pos++);
+
+ my_iid_repos.min_free = pos;
+ my_iid_repos.max_free = MAX(pos, my_iid_repos.max_free);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "mine %d, iid %d tot_used %d, min_free %d max_free %d",
+ 1, mid, my_iid_repos.tot_used, my_iid_repos.min_free, my_iid_repos.max_free);
+
+ dhn->referred_timestamp = bmx_time;
+
+ return mid;
+}
+
Added: trunk/bmx/iid.h
===================================================================
--- trunk/bmx/iid.h (rev 0)
+++ trunk/bmx/iid.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA
+ */
+
+#ifndef _IID_H
+#define _IID_H
+
+#define IID_T uint16_t
+
+#define IID_NEIGH_T struct neigh_node
+extern IID_NEIGH_T *unused1; // ensure knowledge of this type
+
+#define IID_NODE_T struct dhash_node
+extern IID_NODE_T *unused2; // ensure knowledge of this type
+
+#define IID_REPOS_SIZE_BLOCK 2
+
+#define IID_REPOS_SIZE_MAX ((IID_T)(-1))
+#define IID_REPOS_SIZE_WARN 1024
+#define IID_REPOS_USAGE_WARNING 10
+
+#define IID_RSVD_UNUSED 0
+#define IID_RSVD_4YOU 1
+#define IID_RSVD_MAX 1
+#define IID_MIN_USED 2
+
+
+struct iid_ref {
+ IID_T myIID4x;
+ uint16_t referred_timestamp_sec;
+};
+
+struct iid_repos {
+ IID_T arr_size; // the number of allocated array fields
+ IID_T min_free; // the first unused array field from the beginning of the array (might be outside of allocated space)
+ IID_T max_free; // the first unused array field after the last used field in the array (might be outside of allocated space)
+ IID_T tot_used; // the total number of used fields in the array
+ union {
+ uint8_t *u8;
+ IID_NODE_T **node;
+ struct iid_ref *ref;
+ } arr;
+};
+
+extern struct iid_repos my_iid_repos;
+
+
+
+int8_t iid_extend_repos( struct iid_repos *rep );
+
+void iid_purge_repos( struct iid_repos *rep );
+
+void iid_free(struct iid_repos *rep, IID_T iid);
+
+void iid_free_neighIID4x_by_myIID4x( struct iid_repos *rep, IID_T myIID4x);
+
+int8_t iid_set_neighIID4x(struct iid_repos *neigh_rep, IID_T neighIID4x, IID_T myIID4x);
+
+IID_T iid_new_myIID4x( IID_NODE_T *dhn );
+
+
+IID_NODE_T* iid_get_node_by_neighIID4x( IID_NEIGH_T *nn, IID_T neighIID4x );
+
+
+IID_NODE_T* iid_get_node_by_myIID4x( IID_T myIID4x );
+
+#endif
Added: trunk/bmx/lib/Makefile
===================================================================
--- trunk/bmx/lib/Makefile (rev 0)
+++ trunk/bmx/lib/Makefile 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,11 @@
+
+CFLAGS +=
+LDFLAGS +=
+
+PLUGINS = $(shell find -maxdepth 1 -type d | grep -e '^./bmx_' | sort)
+
+%:
+ for d in $(PLUGINS); do $(MAKE) CORE_CFLAGS='$(CORE_CFLAGS)' -C $$d $@ || echo compiling $$d failed; echo;echo; done
+ echo 2 flags: $(CFLAGS)
+
+
Added: trunk/bmx/lib/bmx_uci_config/Makefile
===================================================================
--- trunk/bmx/lib/bmx_uci_config/Makefile (rev 0)
+++ trunk/bmx/lib/bmx_uci_config/Makefile 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,39 @@
+
+CFLAGS += $(CORE_CFLAGS) -fpic -I../../
+LDFLAGS += -shared -luci
+#-Wl,-soname,bmx_config
+
+PLUGIN_NAME = bmx_uci_config
+
+SRC_C = uci_config.c
+SRC_H = uci_config.h
+OBJS= $(SRC_C:.c=.o)
+
+PLUGIN_FULLNAME = $(PLUGIN_NAME).so
+PLUGIN_SHORTNAME = $(PLUGIN_NAME).so
+
+LIBDIR = /usr/lib
+THISDIR = $(shell pwd )
+
+all: $(PLUGIN_FULLNAME) Makefile
+
+
+$(PLUGIN_FULLNAME): $(OBJS) Makefile
+ $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) $(OBJS) -o $(PLUGIN_FULLNAME)
+ ln -f -s $(THISDIR)/$(PLUGIN_FULLNAME) $(THISDIR)/../$(PLUGIN_FULLNAME)
+
+%.o: %.c %.h Makefile
+ $(CC) $(CFLAGS) $(EXTRA_CFLAGS) -c $< -o $@
+
+
+clean:
+ rm -f *.o *.so.$(PLUGIN_VER)
+
+
+install: all
+ mkdir -p $(LIBDIR)
+ install -D -m 755 $(PLUGIN_FULLNAME) $(LIBDIR)/$(PLUGIN_FULLNAME); /sbin/ldconfig -n $(LIBDIR)
+
+
+strip: all
+ strip $(PLUGIN_FULLNAME)
Added: trunk/bmx/lib/bmx_uci_config/uci_config.c
===================================================================
--- trunk/bmx/lib/bmx_uci_config/uci_config.c (rev 0)
+++ trunk/bmx/lib/bmx_uci_config/uci_config.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,923 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <strings.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <signal.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <uci.h>
+
+#include "../../bmx.h"
+#include "../../plugin.h"
+#include "uci_config.h"
+
+static char conf_path[MAX_PATH_SIZE] = "";
+static char *bmx_conf_name = NULL;
+
+static char *uci_err;
+
+static struct uci_context *bmx_ctx = NULL;
+static struct uci_ptr bmx_pptr;
+
+static struct uci_context *net_ctx = NULL;
+
+static struct opt_type tmp_conf_opt;
+
+
+static void signal_hup_handler( int32_t sig ) {
+
+ dbgf( DBGL_SYS, DBGT_INFO, "reloading config" );
+
+ struct ctrl_node *cn = create_ctrl_node( STDOUT_FILENO, NULL, YES/*we are root*/ );
+
+ if ( (apply_stream_opts( ARG_RELOAD_CONFIG, OPT_CHECK, NO/*no cfg by default*/, cn ) == FAILURE) ||
+ (apply_stream_opts( ARG_RELOAD_CONFIG, OPT_APPLY, NO/*no cfg by default*/, cn ) == FAILURE) )
+ {
+ close_ctrl_node( CTRL_CLOSE_STRAIGHT, cn );
+ dbg( DBGL_SYS, DBGT_ERR, "reloading config failed! FIX your config NOW!" );
+ return;
+ }
+
+ close_ctrl_node( CTRL_CLOSE_STRAIGHT, cn );
+
+ respect_opt_order( OPT_APPLY, 0, 99, NULL, NO/*load_cofig*/, OPT_POST, 0/*probably closed*/ );
+
+ cb_plugin_hooks( NULL, PLUGIN_CB_CONF );
+
+}
+
+
+
+STATIC_FUNC
+int8_t uci_reload_package( struct uci_context *ctx, struct uci_ptr *ptr, char* package ) {
+
+ uci_unload(ctx, ptr->p);
+
+ memset( ptr, 0, sizeof( struct uci_ptr ) );
+ ptr->package = package;
+
+ if ( uci_lookup_ptr( ctx, ptr, NULL, false) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf( DBGL_SYS, DBGT_ERR, "%s", uci_err );
+ return FAILURE;
+ }
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+struct uci_element *uci_lookup( struct uci_context *ctx, struct uci_ptr *ptr, char *name ) {
+
+ dbgf_all( DBGT_INFO, "%s", name );
+
+ if ( name )
+ memset( ptr, 0, sizeof( struct uci_ptr ) );
+
+ if ( uci_lookup_ptr( ctx, ptr, name, false) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf( DBGL_SYS, DBGT_ERR, "%s %s", name, uci_err );
+ return NULL;
+ }
+ struct uci_element *e = ptr->last;
+
+ if ( !( ptr->flags & UCI_LOOKUP_COMPLETE ) ) {
+ dbgf_all( DBGT_INFO, "%s %s %s %s is not configured",
+ name, ptr->package, ptr->section, ptr->option );
+ return NULL;
+ }
+
+ return e;
+}
+
+
+
+STATIC_FUNC
+int uci_save_option( struct uci_context *ctx, char *conf_name, char *sect_name, char *opt_name, char *opt_val, struct ctrl_node *cn ) {
+
+ dbgf_cn( cn, DBGL_CHANGES, DBGT_INFO, "%s.%s.%s=%s",
+ conf_name, sect_name, opt_name, opt_val );
+
+ struct uci_ptr ptr;
+ memset(&ptr, 0, sizeof(ptr));
+ ptr.package = conf_name;
+ ptr.section = sect_name;
+
+ if ( uci_lookup_ptr( ctx, &ptr, NULL, false ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_lookup_str( %s.%s ): %s",
+ conf_name, sect_name, uci_err );
+ return FAILURE;
+ }
+
+ ptr.option = opt_name;
+ ptr.value = opt_val;
+
+ if ( uci_set( ctx, &ptr ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_set( %s.%s.%s=%s ): %s",
+ conf_name, sect_name, opt_name, opt_val, uci_err );
+ return FAILURE;
+ }
+
+ if ( uci_save( ctx, ptr.p ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_save( %s.%s.%s=%s ): %s",
+ conf_name, sect_name, opt_name, opt_val, uci_err );
+ return FAILURE;
+ }
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+int uci_create_section( struct uci_context *ctx, char *conf_name, char *sect_name, char *opt_name, struct ctrl_node *cn ) {
+
+
+ struct uci_ptr ptr;
+
+ memset(&ptr, 0, sizeof(ptr));
+ ptr.package = conf_name;
+
+ if ( wordlen( sect_name ) )
+ ptr.section = sect_name;
+
+
+ if ( uci_lookup_ptr( ctx, &ptr, NULL, false ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "%s %s uci_lookup_str(): %s",
+ conf_name, opt_name, uci_err );
+ return FAILURE;
+ }
+
+ if ( uci_add_section( ctx, ptr.p, opt_name, &ptr.s ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "%s %s uci_add_section(): %s",
+ conf_name, opt_name, uci_err );
+ return FAILURE;
+ }
+
+ /*
+ if ( uci_save( ctx, ptr.p ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_fd( fd, DBGL_SYS, DBGT_ERR, "uci_save(): %s", uci_err );
+ return FAILURE;
+ }
+ */
+
+ if ( !wordlen( sect_name ) )
+ strcpy( sect_name, ptr.s->e.name );
+
+ dbgf_cn( cn, DBGL_CHANGES, DBGT_INFO, "%s.%s=%s",
+ conf_name, ptr.s->e.name, opt_name );
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+int uci_remove( struct uci_context *ctx, char *conf_name, char *sect_name, char *opt_name, struct ctrl_node *cn ) {
+
+ dbgf_cn( cn, DBGL_CHANGES, DBGT_INFO, "%s.%s %s", conf_name, sect_name, opt_name );
+
+ struct uci_ptr ptr;
+
+ memset(&ptr, 0, sizeof(ptr));
+ ptr.package = conf_name;
+ ptr.section = sect_name;
+
+ if ( uci_lookup_ptr( ctx, &ptr, NULL, false ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_lookup_str(): %s", uci_err );
+ return FAILURE;
+ }
+
+ ptr.option = opt_name;
+
+ if ( uci_delete( ctx, &ptr ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_delete(): %s", uci_err );
+ return FAILURE;
+ }
+
+ if ( uci_save( ctx, ptr.p ) != SUCCESS ) {
+ uci_get_errorstr( ctx, &uci_err, "" );
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "uci_save(): %s", uci_err );
+ return FAILURE;
+ }
+
+ // without doing this we get double free or corruption after config-reload or uci_remove()
+ uci_reload_package( ctx, &bmx_pptr, conf_name );
+
+ return SUCCESS;
+
+}
+
+
+
+STATIC_FUNC
+int uci_get_sect_name( uint8_t create, struct ctrl_node *cn, struct uci_context *ctx,
+ char *conf_name, char *sect_name, char *sect_type, char *opt_name, char *opt_val )
+{
+
+ struct uci_element *e;
+ struct uci_element *se;
+ int found=0;
+ struct uci_ptr ptr;
+
+ dbgf_all( DBGT_INFO, "%s %s %s.*.%s==%s",
+ create?"create":"get", sect_name, conf_name, opt_name, opt_val );
+
+ paranoia( -500020, ( !conf_name || !sect_type || !sect_name ) );
+
+ uint8_t named_section = wordlen(sect_name) ? YES : NO;
+
+
+ if ( !(e=uci_lookup( ctx, &ptr, conf_name )) )
+ return FAILURE;
+
+ if ( e->type != UCI_TYPE_PACKAGE )
+ return FAILURE;
+
+
+ uci_foreach_element( &(ptr.p->sections), se) {
+
+ struct uci_section *s = uci_to_section(se);
+ struct uci_ptr sptr;
+ char name[MAX_ARG_SIZE];
+
+ if ( strcmp( sect_type, s->type ) )
+ continue;
+
+ if ( opt_name ) {
+
+ sprintf( name, "%s.%s.%s", conf_name, s->e.name, opt_name );
+
+ if ( !(e=uci_lookup( ctx, &sptr, name )) )
+ continue;
+
+ if ( opt_val && !wordsEqual( sptr.o->v.string, opt_val ) )
+ continue;
+
+ }
+
+ if ( !found && !named_section )
+ strcpy( sect_name, s->e.name );
+
+ else if ( wordsEqual( sect_name, s->e.name ) )
+ return SUCCESS;
+
+ found++;
+ }
+
+
+ if ( found == 0 && create ) {
+
+ if ( named_section && uci_save_option( ctx, conf_name, sect_name, NULL, sect_type, cn ) != SUCCESS )
+ return FAILURE;
+
+ if ( !named_section && uci_create_section( ctx, conf_name, sect_name, sect_type, cn ) != SUCCESS )
+ return FAILURE;
+
+ if ( opt_name && opt_val ) {
+
+ if ( uci_save_option( ctx, conf_name, sect_name, opt_name, opt_val, cn ) == SUCCESS )
+ return SUCCESS;
+
+ return FAILURE;
+
+ } else {
+
+ return SUCCESS;
+ }
+
+
+ return FAILURE;
+
+ } else if ( found == 1 ) {
+
+ return SUCCESS;
+
+ } else {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "Found %d matching section with %s.*.%s==%s ! FIX your config NOW!",
+ found, conf_name, opt_name, opt_val );
+
+ return FAILURE;
+ }
+
+}
+
+
+STATIC_FUNC
+int bmx_derive_config ( char *reference, char *derivation, struct ctrl_node *cn ) {
+
+ struct uci_ptr sptr;
+ char name[MAX_ARG_SIZE];
+ struct uci_element *e;
+
+ wordCopy( name, reference + strlen( REFERENCE_KEY_WORD ) );
+
+ dbgf_all( DBGT_INFO, "going to lookup %s", name );
+
+ if ( !(e=uci_lookup( net_ctx, &sptr, name )) )
+ return FAILURE;
+
+ if ( sptr.o && wordlen( sptr.o->v.string ) && wordlen( sptr.o->v.string ) < MAX_ARG_SIZE )
+ wordCopy( derivation, sptr.o->v.string );
+ else
+ return FAILURE;
+
+ uci_unload(net_ctx, sptr.p);
+
+ return SUCCESS;
+}
+
+
+STATIC_FUNC
+int bmx_save_config ( uint8_t del, struct opt_type *opt, char *p_val, char *c_val, struct ctrl_node *cn ) {
+
+ dbgf( DBGL_CHANGES, DBGT_INFO, "%s p:%s c:%s", opt->long_name, p_val, c_val );
+
+ char sect_name[MAX_ARG_SIZE]="";
+
+ paranoia( -500102, !opt );
+
+ if ( !bmx_ctx || !bmx_conf_name || opt->cfg_t == A_ARG )
+ return SUCCESS;
+
+ if ( opt->opt_t == A_PS1 ) {
+
+ // for all general options like ogm_interval, dad_timeout, ...
+
+ if ( del ) {
+
+ return uci_remove( bmx_ctx, bmx_conf_name, DEF_SECT_NAME, opt->long_name, cn );
+
+ } else {
+
+ uci_get_sect_name( YES/*create*/, cn, bmx_ctx, bmx_conf_name, DEF_SECT_NAME, DEF_SECT_TYPE, NULL, NULL );
+ return uci_save_option( bmx_ctx, bmx_conf_name, DEF_SECT_NAME, opt->long_name, c_val, cn );
+ }
+
+ } else if ( opt->opt_t == A_PMN ) {
+
+ // all A_PMN-options are saved as sections
+ // some with only one argument like HNAs, throw-rule, plugin, service
+ // section->options are processed in the following block
+
+ if ( uci_get_sect_name( ( del ? NO : YES/*create*/ ),
+ cn, bmx_ctx,
+ bmx_conf_name, sect_name, opt->long_name,
+ opt->long_name, p_val ) == FAILURE )
+ {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "unknown sect_name %s for %s %s",
+ sect_name, opt->long_name, p_val );
+
+ if ( del )
+ return SUCCESS;
+
+ return FAILURE;
+ }
+
+ if ( del )
+ return uci_remove( bmx_ctx, bmx_conf_name, sect_name, NULL, cn );
+
+ else
+ return uci_save_option( bmx_ctx, bmx_conf_name, sect_name, opt->long_name, c_val, cn );
+
+
+ } else if ( opt->opt_t == A_CS1 && p_val ) {
+
+ // all A_CS1-child options like /ttl=20, /hide=1 from --dev eth0
+
+ if ( uci_get_sect_name( NO/*create*/, cn, bmx_ctx,
+ bmx_conf_name, sect_name, opt->d.parent_opt->long_name,
+ opt->d.parent_opt->long_name, p_val ) == FAILURE )
+ {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "unknown A_1 sect_name %s sn %s %s on %s %s",
+ sect_name, opt->d.parent_opt->long_name, p_val, opt->long_name, c_val );
+
+ if ( del )
+ return SUCCESS;
+
+ sect_name[0]=0;
+ if ( uci_get_sect_name( YES/*create*/, cn, bmx_ctx,
+ bmx_conf_name, sect_name, opt->d.parent_opt->long_name,
+ opt->d.parent_opt->long_name, p_val ) == FAILURE )
+ return FAILURE;
+
+ }
+
+ if ( del )
+ return uci_remove( bmx_ctx, bmx_conf_name, sect_name, opt->long_name, cn );
+
+ else
+ return uci_save_option( bmx_ctx, bmx_conf_name, sect_name, opt->long_name, c_val, cn );
+
+
+ } else {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "%20s %20s -- %20s %s",
+ opt->d.parent_opt?opt->d.parent_opt->long_name:"--", p_val, opt->long_name, c_val );
+
+ cleanup_all( -501004 );
+ }
+
+ return SUCCESS;
+}
+
+
+STATIC_FUNC
+int bmx_load_config ( uint8_t cmd, struct opt_type *opt, struct ctrl_node *cn ) {
+
+ char name[MAX_PATH_SIZE]="";
+ struct uci_ptr sptr, optr;
+
+ if ( !bmx_ctx || !bmx_conf_name )
+ return SUCCESS;
+
+ if ( !opt->long_name || opt->cfg_t == A_ARG )
+ return SUCCESS;
+
+ paranoia( -500138, ( cmd != OPT_CHECK && cmd != OPT_APPLY ) );
+
+
+ if ( opt->opt_t == A_PS1 ) {
+
+ sprintf( name, "%s.%s.%s", bmx_conf_name, DEF_SECT_NAME, opt->long_name );
+
+ dbgf_all( DBGT_INFO, "loading A_PS1-option: %s", name );
+
+ if ( !( uci_lookup( bmx_ctx, &optr, name ) ) ) {
+
+ if ( on_the_fly && //no need to reset a configuration during init
+ check_apply_parent_option( DEL, cmd, NO/*save*/, opt, 0, cn ) == FAILURE )
+ {
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "resetting A_PS1 %s.%s.%s to defaults failed",
+ bmx_conf_name, DEF_SECT_NAME, opt->long_name );
+
+ return FAILURE;
+ }
+
+ } else if ( !optr.o || !optr.o->v.string ) {
+
+ return FAILURE;
+
+ } else if ( check_apply_parent_option( ADD, cmd, NO/*save*/, opt, optr.o->v.string, cn ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "loading A_PS1 %s.%s.%s=%s failed",
+ bmx_conf_name, DEF_SECT_NAME, opt->long_name, optr.o->v.string );
+
+ return FAILURE;
+ }
+
+
+ } else if ( opt->opt_t == A_PMN ) {
+
+ // For A_M (multiple) and A_N (N-suboptons) we use a section)
+
+ dbgf_all( DBGT_INFO, "loading A_PMN-option: %s", opt->long_name );
+
+ struct uci_element *e;
+ struct uci_element *se;
+ struct opt_parent *p_tmp;
+
+ struct list_node *pos;
+
+ if ( !(e=uci_lookup( bmx_ctx, &sptr, bmx_conf_name )) )
+ return SUCCESS;
+
+ if ( e->type != UCI_TYPE_PACKAGE )
+ return SUCCESS;
+
+ // temporary cache all currently configured parents/sections
+ // so that we can later reset all of them which were not reloaded
+ del_opt_parent( &tmp_conf_opt, NULL );
+ list_for_each( pos, &(opt->d.parents_instance_list) ) {
+ p_tmp = list_entry( pos, struct opt_parent, list );
+
+ struct opt_parent *p_dup = add_opt_parent(&tmp_conf_opt);
+ set_opt_parent_val ( p_dup, p_tmp->p_val );
+ set_opt_parent_ref ( p_dup, p_tmp->p_ref );
+ }
+
+ uci_foreach_element( &(sptr.p->sections), se) {
+
+ struct uci_section *s = uci_to_section(se);
+
+ if ( strcmp( opt->long_name, s->type ) )
+ continue;
+
+ sprintf( name, "%s.%s.%s", bmx_conf_name, s->e.name, opt->long_name );
+
+ dbgf_all( DBGT_INFO, "looking up: %s", name );
+
+
+ if ( !(e=uci_lookup( bmx_ctx, &optr, name )) ) {
+
+ if ( cmd == OPT_APPLY ) {
+ dbgf_cn( cn, DBGL_SYS, DBGT_WARN,
+ "looking up %s.%s.%s failed",
+ bmx_conf_name, s->e.name, opt->long_name );
+ }
+
+ continue;
+ }
+
+ char config_sect_val[MAX_ARG_SIZE];
+ strcpy( config_sect_val, optr.o->v.string );
+
+
+ struct opt_parent *patch = add_opt_parent( &Patch_opt );
+
+ if ( call_option( ADD, OPT_PATCH, NO/*save*/, opt, patch, config_sect_val, cn ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "setting sect %s.%s.%s=%s failed",
+ bmx_conf_name, s->e.name, opt->long_name, config_sect_val );
+
+ del_opt_parent( &Patch_opt, patch );
+ return FAILURE;
+ }
+
+
+ list_for_each( pos, &opt->d.childs_type_list ) {
+
+ struct opt_type *opt_arg = (struct opt_type*)list_entry( pos, struct opt_data, list );
+
+ sprintf( name, "%s.%s.%s", bmx_conf_name, s->e.name, opt_arg->long_name );
+ dbgf_all( DBGT_INFO, "looking up: %s", name );
+
+ uint8_t del;
+ char config_sect_opt_val[MAX_ARG_SIZE];
+
+ if ( (e=uci_lookup( bmx_ctx, &optr, name )) ) {
+
+ strcpy( config_sect_opt_val, optr.o->v.string );
+ del = ADD;
+
+ } else {
+
+ if ( !on_the_fly )
+ continue; //no need to reset a configuration during init
+
+ config_sect_opt_val[0] = 0;
+ del = DEL;
+ }
+
+ if ( call_option( del, OPT_PATCH, NO/*save*/, opt_arg, patch, config_sect_opt_val, cn ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "setting opt %s %s %s.%s.%s=%s failed",
+ opt->long_name, config_sect_val,
+ bmx_conf_name, s->e.name, opt_arg->long_name, config_sect_opt_val );
+
+ del_opt_parent( &Patch_opt, patch );
+ return FAILURE;
+
+ } else {
+
+ dbgf_all( DBGT_INFO,
+ "patched opt %s %s %s.%s.%s=%s",
+ opt->long_name, config_sect_val,
+ bmx_conf_name, s->e.name, opt_arg->long_name, config_sect_opt_val );
+ }
+
+ }
+
+ if ( call_option( ADD, OPT_ADJUST, NO/*save*/, opt, patch, config_sect_val, cn ) == FAILURE ||
+ call_option( ADD, cmd, NO/*save*/, opt, patch, config_sect_val, cn ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR,
+ "configuring section %s.%s=%s failed",
+ bmx_conf_name, s->e.name, opt->long_name );
+
+ del_opt_parent( &Patch_opt, patch );
+ return FAILURE;
+ }
+
+ // remove all (re)loaded opts from the cached list. They dont have to be resetted later on
+ if ((p_tmp = get_opt_parent_ref(&tmp_conf_opt, config_sect_val)) ||
+ (p_tmp = get_opt_parent_val(&tmp_conf_opt, patch->p_val)))
+ del_opt_parent(&tmp_conf_opt, p_tmp);
+
+
+ del_opt_parent( &Patch_opt, patch );
+ }
+
+ // finally we have to reset all options which were configured previously but not reloaded
+ list_for_each( pos, &tmp_conf_opt.d.parents_instance_list ) {
+
+ p_tmp = list_entry( pos, struct opt_parent, list );
+
+ if ( wordsEqual( p_tmp->p_val, BMX_LIB_UCI_CONFIG ) ) {
+
+ dbg_mute( 40, DBGL_SYS, DBGT_WARN, "missing section %s with option %s %s in %s",
+ ARG_PLUGIN, ARG_PLUGIN, BMX_LIB_UCI_CONFIG, bmx_conf_name );
+
+ } else if ( check_apply_parent_option( DEL, cmd, NO, opt, p_tmp->p_val, cn ) == FAILURE ) {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "calling %s %s failed", opt->long_name, p_tmp->p_val );
+
+ return FAILURE;
+ }
+ }
+
+ } else {
+
+ dbgf_cn( cn, DBGL_SYS, DBGT_ERR, "opt: %s illegal implementation! %s", opt->long_name, ILLEGAL_STATE );
+
+ cleanup_all( -500137 );
+
+ }
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+int32_t opt_conf_reload ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ Load_config = 1;
+
+ if ( cmd == OPT_CHECK && bmx_ctx ) {
+
+ // without doing this we get double free or corruption after config-reload or uci_remove()
+ uci_reload_package( bmx_ctx, &bmx_pptr, bmx_conf_name );
+ }
+ }
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+int32_t opt_conf_file ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ char tmp_path[MAX_PATH_SIZE] = "";
+
+ if ( on_the_fly )
+ return SUCCESS;
+
+
+ if ( cmd == OPT_REGISTER ) {
+
+ sprintf( conf_path, "%s/%s", UCI_CONFDIR, DEF_CONF_NAME );
+ bmx_conf_name = strrchr( conf_path, '/') + 1;
+ *(strrchr( conf_path, '/'))=0;
+
+
+ } else if ( cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ if ( patch->p_diff == DEL )
+ return FAILURE;
+
+ char *f = patch->p_val;
+
+ if ( wordlen(f)+1 +strlen(UCI_CONFDIR)+1 >= MAX_PATH_SIZE )
+ return FAILURE;
+
+ if ( wordsEqual( f, ARG_NO_CONFIG_FILE ) ) {
+
+ if ( cmd == OPT_APPLY )
+ bmx_conf_name = NULL;
+
+ return SUCCESS;
+
+ } else if ( f[0] == '/' ) {
+
+ wordCopy( tmp_path, f );
+
+ char *tmp_name = strrchr( tmp_path, '/');
+
+ if ( !tmp_name || tmp_name == tmp_path ||
+ check_file( tmp_path, YES/*writable*/, NO/*executable*/ ) == FAILURE )
+ return FAILURE;
+
+ } else if ( strchr( f, '/') == NULL || strchr( f, '/') >= f+wordlen(f) ) {
+
+ snprintf( tmp_path, strlen(UCI_CONFDIR)+1+wordlen(f)+1, "%s/%s", UCI_CONFDIR, f );
+
+ if ( check_file( tmp_path, YES/*writable*/, NO/*executable*/ ) == FAILURE )
+ return FAILURE;
+
+
+ } else {
+
+ return FAILURE;
+ }
+
+ if ( cmd == OPT_APPLY ) {
+
+ strcpy( conf_path, tmp_path );
+ bmx_conf_name = strrchr( conf_path, '/') + 1;
+ *(strrchr( conf_path, '/'))=0;
+
+ }
+
+ return SUCCESS;
+
+
+ } else if ( cmd == OPT_SET_POST && bmx_conf_name ) {
+
+ sprintf( tmp_path, "%s/%s", conf_path, bmx_conf_name );
+
+ if ( check_file( tmp_path, YES/*writable*/, NO/*executable*/ ) == FAILURE )
+ return SUCCESS; //no config file used
+
+ bmx_ctx = uci_alloc_context();
+ uci_set_confdir( bmx_ctx, conf_path );
+
+ dbg( DBGL_CHANGES, DBGT_INFO,
+ "loading uci bmxd backend: file://%s/%s succeeded", conf_path, bmx_conf_name );
+
+ //initially lookup the bmx package so that we can save future changes
+ memset(&bmx_pptr, 0, sizeof(bmx_pptr));
+ bmx_pptr.package = bmx_conf_name;
+ uci_lookup_ptr( bmx_ctx, &bmx_pptr, NULL, false);
+
+ net_ctx = uci_alloc_context();
+ uci_set_confdir( net_ctx, conf_path );
+
+ load_config_cb = bmx_load_config;
+ save_config_cb = bmx_save_config;
+ derive_config = bmx_derive_config;
+
+ // we are already at OPT_SET_POST order>1 but
+ // we have nothing OPT_TESTed nor OPT_SET order=0 options, so load it now!
+ // order > 1 will be OPT_TEST and OPT_SET automatically via load_config_cb = bmx_load_config function
+ struct list_node *list_pos;
+
+ int8_t test = 1;
+ while ( test >= 0 && test <= 1 ) {
+
+ list_for_each( list_pos, &opt_list ) {
+
+ struct opt_type *on = (struct opt_type*)list_entry( list_pos, struct opt_data, list );
+
+ if ( (test && on->order != 1 ) || (!test && on->order == 0) ) {
+
+ if ( bmx_load_config( test?OPT_CHECK:OPT_APPLY, on, cn ) != SUCCESS ) {
+
+ dbgf_all( DBGT_ERR,
+ "bmx_load_config() %s %s failed",
+ test?"OPT_TEST":"OPT_SET",on->long_name );
+
+ return FAILURE;
+ }
+ }
+ }
+ test--;
+ }
+ }
+
+ signal( SIGHUP, signal_hup_handler );
+
+ return SUCCESS;
+}
+
+static uint8_t show_conf_general = YES;
+
+STATIC_FUNC
+int8_t show_conf ( struct ctrl_node *cn, void *data, struct opt_type *opt, struct opt_parent *p, struct opt_child *c ) {
+
+ if ( show_conf_general && !c && opt->opt_t == A_PS1 ) {
+
+ dbg_printf( cn, "\toption '%s' '%s'\n", opt->long_name, (p->p_ref ? p->p_ref : p->p_val) );
+
+ } else if ( !show_conf_general && !c && opt->opt_t == A_PMN ) {
+
+ dbg_printf( cn, "\nconfig '%s'\n", opt->long_name );
+ dbg_printf( cn, "\toption '%s' '%s'\n", opt->long_name, (p->p_ref ? p->p_ref : p->p_val) );
+
+ } else if ( !show_conf_general && c && c->c_opt->opt_t == A_CS1 ) {
+
+ dbg_printf( cn, "\toption '%s' '%s'\n", c->c_opt->long_name, (c->c_ref ? c->c_ref : c->c_val) );
+
+ }
+
+ return SUCCESS;
+}
+
+
+
+STATIC_FUNC
+int32_t opt_show_conf ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ dbg_printf( cn, "config '%s' '%s'\n", DEF_SECT_TYPE, DEF_SECT_NAME );
+
+ show_conf_general = YES;
+ func_for_each_opt( cn, NULL, "show_conf()", show_conf );
+ show_conf_general = NO;
+ func_for_each_opt( cn, NULL, "show_conf()", show_conf );
+
+ dbg_printf( cn, "\n" );
+
+ }
+
+ return SUCCESS;
+}
+
+static struct opt_type config_options[]= {
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ {ODI,0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nUCI config options:"},
+
+
+ {ODI,0,ARG_CONFIG_FILE, 'f',1,A_PS1,A_ADM,A_INI,A_ARG,A_ANY, 0, 0, 0, 0, opt_conf_file,
+ ARG_FILE_FORM, "use non-default config file. If defined, this must be the first given option.\n"
+ " use --" ARG_CONFIG_FILE "=" ARG_NO_CONFIG_FILE " or -f" ARG_NO_CONFIG_FILE " to disable"},
+
+ {ODI,0,ARG_RELOAD_CONFIG, 0, 1,A_PS0,A_ADM,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_conf_reload,
+ 0, "dynamically reload config file"},
+
+ {ODI,0,ARG_SHOW_CONFIG, 0, 5,A_PS0,A_ADM,A_DYN,A_ARG,A_ANY, 0, 0, 0, 0, opt_show_conf,
+ 0, "show current config as it could be saved to " ARG_CONFIG_FILE }
+};
+
+
+
+STATIC_FUNC
+void cleanup_conf( void ) {
+
+ del_opt_parent( &tmp_conf_opt, NULL );
+
+ load_config_cb = NULL;
+ save_config_cb = NULL;
+
+ if ( bmx_ctx )
+ uci_free_context( bmx_ctx );
+
+ if ( net_ctx )
+ uci_free_context( net_ctx );
+
+}
+
+STATIC_FUNC
+int32_t init_conf( void ) {
+
+ memset( &tmp_conf_opt, 0, sizeof( struct opt_type ) );
+ LIST_INIT_HEAD( tmp_conf_opt.d.childs_type_list, struct opt_data, list );
+ LIST_INIT_HEAD( tmp_conf_opt.d.parents_instance_list, struct opt_parent, list );
+
+ register_options_array( config_options, sizeof( config_options ) );
+
+ return SUCCESS;
+}
+
+
+
+struct plugin_v2* get_plugin_v2( void ) {
+
+ static struct plugin_v2 conf_plugin;
+
+ memset( &conf_plugin, 0, sizeof ( struct plugin_v2 ) );
+
+ conf_plugin.plugin_version = PLUGIN_VERSION_02;
+ conf_plugin.plugin_name = "bmx_uci_config_plugin";
+ conf_plugin.plugin_size = sizeof ( struct plugin_v2 );
+ conf_plugin.plugin_bmx_revision = REVISION_VERSION;
+ conf_plugin.plugin_bmx_version = SOURCE_VERSION;
+ conf_plugin.cb_init = init_conf;
+ conf_plugin.cb_cleanup = cleanup_conf;
+
+ return &conf_plugin;
+}
+
Added: trunk/bmx/lib/bmx_uci_config/uci_config.h
===================================================================
--- trunk/bmx/lib/bmx_uci_config/uci_config.h (rev 0)
+++ trunk/bmx/lib/bmx_uci_config/uci_config.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+#define DEF_CONF_NAME "bmx"
+#define DEF_SECT_NAME "general"
+#define DEF_SECT_TYPE "bmx"
+
+#define ARG_CONFIG_FILE "config_file"
+#define ARG_SAVE_CONFIG "save_config"
+#define ARG_SHOW_CONFIG "show_config"
+#define ARG_RELOAD_CONFIG "reload_config"
+
+#define ARG_NO_CONFIG_FILE "0"
\ No newline at end of file
Added: trunk/bmx/list.c
===================================================================
--- trunk/bmx/list.c (rev 0)
+++ trunk/bmx/list.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+/*
+ * This list implementation is originally based on the
+ * double-linked list implementaton from the linux-kernel
+ * which can be found in include/linux/list.h
+ *
+ * The following has been to better fit my needs:
+ * - items counter
+ * - plist handler (list-node structure with void* item pointer
+ * - single-linked list instead of double-linked list to save overhead
+ * - some functions for straight item access!
+ */
+
+#include "bmx.h"
+#include "list.h"
+
+/**
+ * list_iterate - return pointer to next node maintained in the list or NULL
+ * @head: list head of maintained nodes
+ * @node: a node maintained in the list or NULL
+ */
+void * list_iterate(struct list_head *head, void *node)
+{
+ struct list_node * ln;
+
+ if (head->prev == (ln = ((node ?
+ (struct list_node*) (((char*) node) + head->list_node_offset) :
+ (struct list_node*) head))->next)
+ )
+ return NULL;
+
+ return (((char*) ln) - head->list_node_offset);
+}
+
+
+
+/**
+ * list_add_head - add a new entry at the beginning of a list
+ * @head: list head to add it after
+ * @new: new entry to be added
+ */
+void list_add_head(struct list_head *head, struct list_node *new)
+{
+
+ new->next = head->next;
+ ((struct list_node *) head)->next = new;
+
+ if (head->prev == (struct list_node *) head)
+ head->prev = new;
+
+ head->items++;
+
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @head: list head to add it before
+ * @new: new entry to be added
+ */
+void list_add_tail(struct list_head *head, struct list_node *new )
+{
+ new->next = (struct list_node *) head;
+ head->prev->next = new;
+
+ head->prev = new;
+ head->items++;
+}
+
+
+void list_add_after(struct list_head *head, struct list_node *pos, struct list_node *new)
+{
+ new->next = pos->next;
+ pos->next = new;
+ head->items++;
+}
+
+/**
+ * list_del_next - deletes next entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
+ */
+void list_del_next(struct list_head *head, struct list_node *pos)
+{
+ struct list_node *entry = pos->next;
+
+ if (head->prev == entry)
+ head->prev = pos;
+
+ pos->next = entry->next;
+
+ head->items--;
+}
+
+void *list_rem_head(struct list_head *head)
+{
+ if (LIST_EMPTY(head))
+ return NULL;
+
+ struct list_node* entry = head->next;
+
+ list_del_next(head, (struct list_node*) head);
+
+ return ((char*) entry) -head->list_node_offset;
+}
+
+
+
+/**
+ * plist_get_next - return pointer to next node maintained in the list or NULL
+ * @head: list head of maintained nodes
+ * @@pnode: MBZ at beginning! pointing to current plist_node in list
+ */
+void * plist_iterate(struct list_head *head, struct plist_node **pln)
+{
+
+ if (head->prev == (struct list_node*)
+ (*pln = *pln ? (struct plist_node*) ((*pln)->list.next) : (struct plist_node*) (head->next)))
+ return NULL;
+
+ return (*pln)->item;
+
+/*
+ if (LIST_EMPTY(head))
+ return NULL;
+
+ if (*pln) {
+
+ if (head->prev == (struct list_node*) (*pln = (struct plist_node*) ((*pln)->list->next)))
+ return NULL;
+
+ } else {
+ *pln = (struct plist_node*) head->next;
+ }
+
+ return (*pln)->item;
+*/
+
+}
+
+
+
+static struct plist_node *plist_node_create(void *item)
+{
+ paranoia(-500266, (!item));
+ struct plist_node *plh = debugMalloc(sizeof ( struct plist_node), -300113);
+
+ plh->item = item;
+ return plh;
+}
+
+void plist_add_head(struct list_head *head, void *item)
+{
+ list_add_head(head, &((plist_node_create(item))->list));
+}
+
+void plist_add_tail(struct list_head *head, void *item)
+{
+ list_add_tail(head, &((plist_node_create(item))->list));
+}
+
+void * plist_rem_head(struct list_head *head)
+{
+ struct plist_node *pln = list_rem_head(head);
+
+ if ( !pln )
+ return NULL;
+
+ void *item = pln->item;
+
+ debugFree( pln, -300114 );
+
+ return item;
+}
Added: trunk/bmx/list.h
===================================================================
--- trunk/bmx/list.h (rev 0)
+++ trunk/bmx/list.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+/*
+ * This list implementation is originally based on the
+ * double-linked list implementaton from the linux-kernel
+ * which can be found in include/linux/list.h
+ *
+ * The following has been changed to better fit my needs and intuition:
+ * - items counter
+ * - plist handler (list-node structure with void* item pointer
+ * - single-linked list instead of double-linked list to save overhead
+ * - some functions for straight item access!
+ */
+
+
+#ifndef _LIST_H
+#define _LIST_H
+
+
+
+struct list_node {
+ struct list_node *next;
+};
+
+struct list_head {
+ struct list_node *next, *prev;
+ uint16_t items;
+ uint16_t list_node_offset;
+};
+
+struct plist_node {
+ struct list_node list;
+ void *item;
+};
+
+
+#define LIST_SIMPEL(lst, element_type, list_node_field) struct list_head lst = { \
+ (struct list_node *)&lst, (struct list_node *)&lst, \
+ 0, \
+ ((unsigned long)(&((element_type *)0)->list_node_field)) }
+
+#define LIST_INIT_HEAD(ptr, element_type, list_node_field) do { \
+ ptr.next = ptr.prev =(struct list_node *)&ptr; \
+ ptr.items = 0; \
+ ptr.list_node_offset = ((unsigned long)(&((element_type *)0)->list_node_field)); \
+} while (0)
+
+#define LIST_EMPTY(lst) ((lst)->next == (struct list_node *)(lst))
+
+
+#define list_get_first(head) ((void*)((LIST_EMPTY(head)) ? NULL : (((char*) (head)->next) - (head)->list_node_offset) ))
+#define list_get_last(head) ((void*)((LIST_EMPTY(head)) ? NULL : (((char*) (head)->prev) - (head)->list_node_offset) ))
+
+void * list_iterate( struct list_head *head, void *node );
+
+void list_add_head(struct list_head *head, struct list_node *new);
+void list_add_tail(struct list_head *head, struct list_node *new );
+void list_add_after(struct list_head *head, struct list_node *pos, struct list_node *new);
+void list_del_next(struct list_head *head, struct list_node *pos);
+void *list_rem_head(struct list_head *head);
+
+
+#define plist_get_first(head) (LIST_EMPTY(head) ? NULL : \
+ ((struct plist_node*)(((char*) (head)->next) - (head)->list_node_offset))->item )
+
+#define plist_get_last(head) (LIST_EMPTY(head) ? NULL : \
+ ((struct plist_node*)(((char*) (head)->prev) - (head)->list_node_offset))-item )
+
+void * plist_iterate(struct list_head *head, struct plist_node **pln);
+
+void plist_add_head(struct list_head *head, void *item);
+void plist_add_tail(struct list_head *head, void *item);
+void *plist_rem_head(struct list_head *head);
+
+
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr: the &struct list_head pointer.
+ * @type: the type of the struct this is embedded in.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) ( (type *)( (char *)(ptr) - (unsigned long)(&((type *)0)->member) ) )
+
+/**
+ * list_for_each - iterate over a list
+ * @pos: the &struct list_head to use as a loop counter.
+ * @head: the head for your list.
+ */
+#define list_for_each(pos, head) \
+ for (pos = (head)->next; pos != (struct list_node *)(head); pos = pos->next)
+
+#define list_for_each_item(pos, head, item, type, member) \
+ for (pos = (head)->next; \
+ pos != (struct list_node *)(head) && \
+ (item = ((type *)( (char *)(pos) - (unsigned long)(&((type *)0)->member) ) )); \
+ pos = pos->next)
+
+/**
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct list_head to use as a loop counter.
+ * @n: another &struct list_head to use as temporary storage
+ * @head: the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (struct list_node *)(head); \
+ pos = n, n = pos->next)
+
+
+#endif
Added: trunk/bmx/msg.c
===================================================================
--- trunk/bmx/msg.c (rev 0)
+++ trunk/bmx/msg.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,2291 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <unistd.h>
+#include <errno.h>
+
+
+//#include <sha.h>
+
+#include "bmx.h"
+#include "msg.h"
+#include "hna.h"
+#include "schedule.h"
+
+
+static Sha bmx_sha;
+
+AVL_TREE( description_cache_tree, struct description_cache_node, dhash );
+
+
+
+static int32_t max_udpd_size = DEF_UDPD_SIZE;
+
+static int32_t aggreg_interval = DEF_AGGREG_INTERVAL;
+
+int32_t my_ogm_interval = DEF_OGM_INTERVAL; /* orginator message interval in miliseconds */
+
+int32_t my_hello_interval = DEF_HELLO_INTERVAL;
+
+int32_t ogm_resend_attempts = DEF_OGM_RESEND_ATTEMPTS;
+
+int my_desc0_tlv_len = 0;
+
+IID_T myIID4me = IID_RSVD_UNUSED;
+
+
+LIST_SIMPEL( ogm_aggreg_list, struct ogm_aggreg_node, list );
+uint32_t ogm_aggreg_pending = 0;
+static SQN_T ogm_aggreg_sqn_max;
+
+
+char *tlv_op_str[] = {"TLV_DEL","TLV_TEST","TLV_ADD","TLV_DONE","TLV_DEBUG"};
+
+
+
+
+STATIC_FUNC int tx_msg_hello40_reply (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+STATIC_FUNC int tx_msg_helloX0_adv (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+STATIC_FUNC int tx_msg_description0_adv (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+
+STATIC_FUNC int tx_msg_dhash0_adv (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+
+STATIC_FUNC int tx_msg_dhash0_or_description0_request (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+STATIC_FUNC int tx_msg_ogm_ack (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+
+STATIC_FUNC int tx_frame_ogm0_advs (struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+
+
+STATIC_FUNC int rx_frame_hello40_replies (struct packet_buff *pb, struct frame_header *frame);
+STATIC_FUNC int rx_frame_helloX0_advs (struct packet_buff *pb, struct frame_header *frame);
+STATIC_FUNC int rx_frame_description0_advs (struct packet_buff *pb, struct frame_header *frame);
+
+STATIC_FUNC int rx_frame_dhash0_advs (struct packet_buff *pb, struct frame_header *frame);
+
+STATIC_FUNC int rx_frame_dhash0_or_description0_requests (struct packet_buff *pb, struct frame_header *frame);
+
+STATIC_FUNC int rx_frame_ogm0_advs (struct packet_buff *pb, struct frame_header *frame);
+STATIC_FUNC int rx_frame_ogm40_acks (struct packet_buff *pb, struct frame_header *frame);
+
+/***********************************************************
+ The core frame/message structures and handlers
+ ************************************************************/
+
+
+
+struct description_tlv_handler {
+ uint16_t reserved1;
+ uint16_t reserved2;
+ uint16_t min_msg_size;
+ uint16_t variable_msg_size;
+ char *name;
+ int (*create_tlv) (uint8_t *data, uint16_t max_size);
+ int (*process_tlv) (struct orig_node *on, struct frame_header *tlv, IDM_T op, struct ctrl_node *cn);
+};
+
+struct description_tlv_handler description0_tlv_handler[BMX_DSC_TLV_MAX] = {
+ {0, 0, sizeof (struct description0_msg_ip4), 0,
+ "desc0tlv_glip4", create_description_tlv_ip4, process_description_tlv_hna4}
+ ,
+ {0, 0, sizeof (struct description0_msg_hna4), 0,
+ "desc0tlv_uhna4", create_description_tlv_hna4, process_description_tlv_hna4}
+};
+
+
+
+struct pkt_frame_handler {
+ uint16_t reserved;
+ uint16_t tx_iterations;
+ uint16_t min_rtq;
+ uint16_t data_header_size;
+ uint16_t min_msg_size;
+ uint16_t fixed_msg_size;
+ uint32_t min_tx_interval;
+ char *name;
+ int (*tx_frm_creator) (struct tx_task_node * ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+/*
+ * tx_msg_creator()
+ * expects sufficient buff_size for non-variable_msg_size messages !!!
+ * returns x=sizeof(send msg), thus (x<=buff_size), if msg was successfully created
+ * returns (x > buff_size) if variable_msg_size could not be created due to lack of buff_size
+ * returns 0 if message MUST be send later
+ * returns FAILRUE if porblem occured and msg-meta data (tx_task_node) MUST be destroyed
+ */
+ int (*tx_msg_creator) (struct tx_task_node * ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size);
+ int (*rx_frm_receptor) (struct packet_buff *, struct frame_header *);
+};
+
+
+static struct pkt_frame_handler frame_handler[FRAME_TYPE_ARRSZ] = {
+ {0, 0, 0, 0, 0, 1, 0, NULL, NULL, NULL, NULL},
+ {0, 0, 0, 0, 0, 1, 0, NULL, NULL, NULL, NULL},
+
+ {0, 1, 0, 0, sizeof (struct msg_hello_adv), 1, 0,
+ "hey0_adv", NULL, tx_msg_helloX0_adv, rx_frame_helloX0_advs},
+
+ {0, 1, 0, 0, sizeof (struct msg_hello_reply), 1, 0,
+ "hey0_rep", NULL, tx_msg_hello40_reply, rx_frame_hello40_replies},
+ {0, 0, 0, 0, 0, 1, 0, NULL, NULL, NULL, NULL},
+
+ {0, 0, 1, 0, 0, 1, 0, NULL, NULL, NULL, NULL},
+ {0, 0, 1, 0, 0, 1, 0, NULL, NULL, NULL, NULL},
+
+ {0, 1, MIN_NBDISC_RTQ, 0, sizeof (struct msg_description_request), 1, DEF_TX_DESC0_REQ_TO, // receiverIID, receiverIP4
+ "desc0_req", NULL, tx_msg_dhash0_or_description0_request, rx_frame_dhash0_or_description0_requests},
+
+ {0, 1, MIN_NBDISC_RTQ, 0, sizeof (struct msg_description_adv), 0, DEF_TX_DESC0_ADV_TO, // myIID4x
+ "desc0_adv", NULL, tx_msg_description0_adv, rx_frame_description0_advs},
+
+ {0, 1, MIN_NBDISC_RTQ, 0, sizeof (struct msg_dhash_request), 1, DEF_TX_DHASH0_REQ_TO, // receiverIID, receiverIP4
+ "dhash0_req", NULL, tx_msg_dhash0_or_description0_request, rx_frame_dhash0_or_description0_requests},
+
+ {0, 1, MIN_NBDISC_RTQ, 0, sizeof (struct msg_dhash_adv), 1, DEF_TX_DHASH0_ADV_TO, // myIID4x
+ "dhash_adv", NULL, tx_msg_dhash0_adv, rx_frame_dhash0_advs},
+
+ {0, 1, 0, sizeof (struct hdr_ogm_adv), sizeof (struct msg_ogm_adv), 1, 0,
+ "ogm_adv", tx_frame_ogm0_advs, NULL, rx_frame_ogm0_advs},
+
+ {0, 2, 0, 0, sizeof (struct msg_ogm_ack), 1, 0,
+ "ogm_ack", NULL, tx_msg_ogm_ack, rx_frame_ogm40_acks},
+
+ {0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL}
+
+};
+
+
+
+
+STATIC_FUNC
+struct description * rem_cached_description(struct description_hash *dhash)
+{
+ struct description_cache_node *dcn;
+
+ if (!(dcn = avl_find_item(&description_cache_tree, dhash)))
+ return NULL;
+
+ struct description *desc0 = dcn->description;
+
+ avl_remove(&description_cache_tree, &dcn->dhash, -300206);
+ debugFree(dcn, -300108);
+
+ return desc0;
+}
+
+STATIC_FUNC
+struct description_cache_node *purge_cached_descriptions( IDM_T purge_all ) {
+
+ struct description_cache_node *dcn;
+ struct description_cache_node *dcn_min = NULL;
+ struct description_hash tmp_dhash;
+ memset( &tmp_dhash, 0, sizeof(struct description_hash));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s", purge_all ? "purge_all" : "only_expired");
+
+ paranoia( -500349, (!is_zero((char*)&tmp_dhash, BMX_HASH0_LEN)));
+
+ while ((dcn = avl_next_item(&description_cache_tree, &tmp_dhash))) {
+
+ memcpy(&tmp_dhash, &dcn->dhash, BMX_HASH0_LEN);
+
+ if (purge_all || ((uint32_t) (bmx_time - dcn->timestamp)) > DEF_DESC0_CACHE_TO) {
+
+ avl_remove(&description_cache_tree, &dcn->dhash, -300208);
+ debugFree(dcn->description, -300100);
+ debugFree(dcn, -300101);
+
+ } else {
+
+ if (!dcn_min || LESS_U32(dcn->timestamp, dcn_min->timestamp))
+ dcn_min = dcn;
+ }
+ }
+
+ return dcn_min;
+}
+
+STATIC_FUNC
+void cache_description(struct description *desc, struct description_hash *dhash)
+{
+ struct description_cache_node *dcn;
+
+ uint16_t desc_len = sizeof (struct description) + ntohs(desc->dsc_tlvs_len);
+
+ if ((dcn = avl_find_item(&description_cache_tree, dhash))) {
+ dcn->timestamp = bmx_time;
+ return;
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%8X..", dhash->h.u32[0]);
+
+
+ paranoia(-500261, (description_cache_tree.items > DEF_DESC0_CACHE_SIZE));
+
+ if ( description_cache_tree.items == DEF_DESC0_CACHE_SIZE ) {
+
+
+ struct description_cache_node *dcn_min = purge_cached_descriptions( NO );
+
+ dbgf(DBGL_SYS, DBGT_WARN, "desc0_cache_tree reached %d items! cleaned up %d items!",
+ DEF_DESC0_CACHE_SIZE, DEF_DESC0_CACHE_SIZE - description_cache_tree.items);
+
+ if (description_cache_tree.items == DEF_DESC0_CACHE_SIZE) {
+ avl_remove(&description_cache_tree, &dcn_min->dhash, -300209);
+ debugFree(dcn_min->description, -300102);
+ debugFree(dcn_min, -300103);
+ }
+ }
+
+ paranoia(-500273, (desc_len != sizeof ( struct description) + ntohs(desc->dsc_tlvs_len)));
+
+ dcn = debugMalloc(sizeof ( struct description_cache_node), -300104);
+ dcn->description = debugMalloc(desc_len, -300105);
+ memcpy(dcn->description, desc, desc_len);
+ memcpy( &dcn->dhash, dhash, BMX_HASH0_LEN );
+ dcn->timestamp = bmx_time;
+ avl_insert(&description_cache_tree, dcn, -300145);
+
+}
+
+void purge_tx_timestamp_tree(struct dev_node *dev, IDM_T purge_all)
+{
+ struct avl_node *an;
+ struct tx_timestamp_node *ttn = NULL;
+ struct tx_timestamp_key key;
+
+ memset(&key, 0, sizeof (struct tx_timestamp_key));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s", dev->name, purge_all ? "purge_all" : "only_expired");
+
+ while ((an = avl_next(&dev->tx_timestamp_tree, (ttn ? &ttn->key : &key)))) {
+
+ ttn = an->item;
+
+ if (purge_all || ((uint32_t) (bmx_time - ttn->timestamp)) >
+ (DEF_TX_TS_TREE_PURGE_FK * frame_handler[ttn->key.type].min_tx_interval)) {
+
+ memcpy( &key, &ttn->key, sizeof( struct tx_timestamp_key ) );
+
+ avl_remove( &dev->tx_timestamp_tree, &ttn->key, -300210 );
+ debugFree( ttn, -300127 );
+ ttn = NULL;
+ }
+ }
+}
+
+
+STATIC_FUNC
+struct tx_timestamp_node * tx_timestamp_add( struct dev_node *dev, struct tx_timestamp_key *key)
+{
+ ASSERTION( -500263, ( dev && !avl_find( &dev->tx_timestamp_tree, key ) ) );
+
+ if (dev->tx_timestamp_tree.items > DEF_TX_TS_TREE_SIZE) {
+
+ purge_tx_timestamp_tree(dev, NO);
+
+ if (dev->tx_timestamp_tree.items > DEF_TX_TS_TREE_SIZE) {
+ dbg_mute(20, DBGL_SYS, DBGT_WARN, "%s tx_ts_tree reached %d %s neighIID4x %u %s %u",
+ dev->name, dev->tx_timestamp_tree.items, frame_handler[key->type].name,
+ key->neighIID4x, ipStr(key->myIID4x_or_dest_ip4), key->myIID4x_or_dest_ip4);
+ }
+ }
+
+ struct tx_timestamp_node *ttn = debugMalloc(sizeof ( struct tx_timestamp_node), -300126);
+ memset(ttn, 0, sizeof ( struct tx_timestamp_node));
+ memcpy( &ttn->key, key, sizeof(struct tx_timestamp_key ) );
+ ttn->timestamp = bmx_time;
+ avl_insert(&dev->tx_timestamp_tree, ttn, -300146);
+
+ return ttn;
+}
+
+STATIC_FUNC
+IDM_T tx_task_obsolete( struct dev_node *dev, uint8_t frame_type, struct tx_task_node *tx_task )
+{
+ struct tx_timestamp_node *ttn = NULL;
+ struct tx_timestamp_key key;
+ struct dhash_node *dhn = NULL;
+
+ if (tx_task->myIID4x >= IID_MIN_USED && !((dhn = iid_get_node_by_myIID4x(tx_task->myIID4x)) && dhn->on)) {
+ goto tx_timestamped_deny;
+ }
+
+ if (!frame_handler[frame_type].min_tx_interval)
+ return NO;
+
+ memset(&key, 0, sizeof (struct tx_timestamp_key));
+
+ key.myIID4x_or_dest_ip4 = tx_task->myIID4x ? tx_task->myIID4x : tx_task->dst_ip4;
+ key.neighIID4x = tx_task->neighIID4x;
+ key.type = frame_type;
+
+ if (frame_handler[frame_type].min_tx_interval && (ttn = avl_find_item(&dev->tx_timestamp_tree, &key))) {
+
+ if (((uint32_t) (bmx_time - ttn->timestamp) < frame_handler[frame_type].min_tx_interval)) {
+
+ goto tx_timestamped_deny;
+ }
+
+ ttn->timestamp = bmx_time;
+ }
+
+ if (!ttn)
+ ttn = tx_timestamp_add(dev, &key);
+
+ return NO;
+
+
+tx_timestamped_deny:
+ dbgf(DBGL_CHANGES, DBGT_WARN,
+ "skipping %s %s myIId4x %d neighIID4x %d %s %s send just %d ms ago",
+ frame_handler[frame_type].name, dev->name,
+ tx_task->myIID4x, tx_task->neighIID4x, ipStr(tx_task->dst_ip4),
+ dhn ? dhn->on->id.name : "???",
+ ttn ? (int)(bmx_time - ttn->timestamp) : -1);
+
+ return YES;
+}
+
+
+
+
+STATIC_FUNC
+IDM_T validate_param(int32_t probe, int32_t min, int32_t max, char *name, struct opt_type *opt)
+{
+ if (opt) {
+ min = opt->imin;
+ max = opt->imax;
+ name = opt->long_name;
+ }
+
+ if ( probe < min || probe > max ) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "Illegal %s parameter value %d ( min %d max %d )",
+ name, probe, min, max);
+
+ return FAILURE;
+ }
+
+ return SUCCESS;
+}
+
+
+
+
+
+IDM_T process_description_tlvs(struct orig_node *on, struct description *desc_new, IDM_T op, struct ctrl_node *cn)
+{
+ struct description *desc;
+ IDM_T tlv_result;
+ uint16_t pos = 0, t = 0, pt = 0, size = 0, tlv_size = 0;
+ struct frame_header * tlv = NULL;
+
+ assertion(-500370, (op == TLV_DEL_TEST_ADD || op == TLV_DEBUG));
+
+ desc = on->desc0; //start with removing the old desc0_tlvs
+
+ do {
+ if (op == TLV_TEST || op == TLV_ADD)
+ desc = desc_new;
+
+ if (!desc || (op == TLV_DEL_TEST_ADD && on->blocked))
+ continue;
+
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s dsc_sqn %d size %d ",
+ tlv_op_str[op], desc->id.name, ntohs(desc->dsc_sqn), ntohs(desc->dsc_tlvs_len));
+
+
+ size = ntohs(desc->dsc_tlvs_len);
+ tlv = NULL;
+ pos = t = pt = 0;
+
+
+ assertion(-500274, (size <= MAX_DESC0_TLV_SIZE)); // checked in rx_frm_desc0_advs()
+
+ while (pos + sizeof ( struct frame_header) < size) {
+
+ tlv = (struct frame_header*) (((char*) desc) + sizeof (struct description) + pos);
+ tlv_size = ntohs(tlv->length);
+
+ if ((t = tlv->type) < pt ||
+ tlv_size < sizeof ( struct frame_header) ||
+ tlv_size + pos > size) {
+
+ dbgf(DBGL_SYS, DBGT_ERR,
+ "illegal sizes %d for type %s", tlv_size, description0_tlv_handler[t].name);
+ goto process_desc0_tlv_error;
+ }
+
+ dbgf(DBGL_ALL, DBGT_INFO,
+ "type %s size %d flags 0x%X", description0_tlv_handler[t].name, tlv_size, tlv->flags);
+
+
+ if (t >= BMX_DSC_TLV_ARRSZ || !(description0_tlv_handler[t].process_tlv)) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "unsupported type %d ! maybe you need an update?", t);
+
+ if (t >= BMX_DSC_TLV_ARRSZ)
+ goto process_desc0_tlv_error;
+
+ } else if (tlv_size - sizeof (struct frame_header) < description0_tlv_handler[t].min_msg_size) {
+
+ dbgf(DBGL_SYS, DBGT_ERR,
+ "too small size %d for type %s", tlv_size, description0_tlv_handler[t].name);
+ goto process_desc0_tlv_error;
+
+ } else if (!(description0_tlv_handler[t].variable_msg_size) &&
+ (tlv_size - sizeof (struct frame_header)) % description0_tlv_handler[t].min_msg_size) {
+
+ dbgf(DBGL_SYS, DBGT_ERR,
+ "nonmaching size %d for type %s", tlv_size, description0_tlv_handler[t].name);
+ goto process_desc0_tlv_error;
+
+ } else if ((tlv_result = (*(description0_tlv_handler[t].process_tlv)) (on, tlv, op, cn)) != TLVS_SUCCESS) {
+
+ assertion(-500356, (op == TLV_TEST));
+
+ dbgf(DBGL_SYS, DBGT_ERR,
+ "%s size %d %s", description0_tlv_handler[t].name, tlv_size,
+ tlv_result == TLVS_BLOCKED ? "BLOCKED" : "FAILURE");
+
+ if (tlv_result == TLVS_BLOCKED) {
+
+ on->blocked = YES;
+
+ if (!avl_find(&blocked_tree, &on->id))
+ avl_insert(&blocked_tree, on, -300165);
+
+ return TLVS_BLOCKED;
+ }
+
+ goto process_desc0_tlv_msg_error;
+ }
+
+ pt = t;
+ pos += tlv_size;
+ }
+
+ if (pos != size) {
+ dbgf(DBGL_SYS, DBGT_ERR, "nonmaching tlvs pos %d != size %d", pos, size );
+
+ goto process_desc0_tlv_error;
+ }
+
+ } while (++op < TLV_DONE);
+
+ if ( op == TLV_DONE ) {
+ on->blocked = NO;
+ avl_remove(&blocked_tree, &on->id, -300211);
+ }
+
+ return SUCCESS;
+
+
+process_desc0_tlv_msg_error:
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "rcvd problematic message");
+
+process_desc0_tlv_error:
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "rcvd problematic frame type %s last %s frm_size %d pos %d ",
+ description0_tlv_handler[t].name, description0_tlv_handler[pt].name, tlv_size, pos);
+
+ return TLVS_FAILURE;
+}
+
+//BMX3 (done)
+struct dhash_node * process_description(struct packet_buff *pb, struct description *desc, struct description_hash *dhash)
+{
+ assertion(-500262, (pb && pb->ln && desc));
+ assertion(-500381, (!avl_find( &dhash_tree, dhash )));
+
+ struct dhash_node *dhn;
+ struct orig_node *on = NULL;
+ int id_name_len;
+
+
+ dbgf( DBGL_CHANGES, DBGT_INFO, "via dev: %s NB %s:dhash %8X.. id.rand %jX",
+ pb->iif->name, pb->neigh_str, dhash->h.u32[0], desc->id.rand.u64[0]);
+
+ if (
+ (id_name_len = strlen(desc->id.name)) >= DESCRIPTION0_ID_NAME_LEN ||
+ !is_zero(&desc->id.name[id_name_len], DESCRIPTION0_ID_NAME_LEN - id_name_len) ||
+ validate_name(desc->id.name) == FAILURE) {
+
+ dbg(DBGL_SYS, DBGT_ERR, "illegal hostname .. %jX", desc->id.rand.u64[0]);
+ goto process_desc0_error;
+ }
+
+ if (
+ validate_param(ntohs(desc->ogm_sqn_range), MIN_OGM0_SQN_RANGE, MAX_OGM0_SQN_RANGE, ARG_OGM0_SQN_RANGE, NULL) ||
+ validate_param(desc->ogm_sqn_pq_bits, MIN_OGM0_PQ_BITS, MAX_OGM0_PQ_BITS, ARG_OGM0_PQ_BITS, NULL) ||
+ validate_param(ntohs(desc->path_ogi), 0, 0, NULL, get_option(0, 0, ARG_OGM_INTERVAL)) ||
+ validate_param(desc->ttl_max, 0, 0, NULL, get_option(0, 0, ARG_TTL)) ||
+ validate_param(ntohs(desc->path_window_size), 0, 0, NULL, get_option(0, 0, ARG_PWS)) ||
+ validate_param(ntohs(desc->path_lounge_size), 0, 0, NULL, get_option(0, 0, ARG_PATH_LOUNGE)) ||
+ validate_param(desc->path_hystere, 0, 0, NULL, get_option(0, 0, ARG_PATH_HYST)) ||
+// validate_param(dsc->hop_penalty, 0, 0, NULL, get_option(0, 0, ARG_HOP_PENALTY)) ||
+ validate_param(desc->late_penalty, 0, 0, NULL, get_option(0, 0, ARG_LATE_PENAL)) ||
+ validate_param(desc->asym_weight, 0, 0, NULL, get_option(0, 0, ARG_ASYM_WEIGHT)) ||
+// validate_param(dsc->sym_weight, 0, 0, NULL, get_option(0, 0, ARG_SYM_WEIGHT)) ||
+ 0
+ ) {
+
+ goto process_desc0_error;
+ }
+
+
+ if ((on = avl_find_item(&orig_tree, &desc->id))) {
+
+ assertion(-500383, (on->dhn));
+
+ if (((uint32_t) (bmx_time - on->dhn->referred_timestamp)) < (uint32_t) dad_to) {
+
+ if ( ((SQN_T)(ntohs(desc->dsc_sqn) - (on->desc0_sqn + 1))) > SQN_DAD_RANGE ) {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "DAD-Alert: new dsc_sqn %d not > old %d + 1",
+ ntohs(desc->dsc_sqn), on->desc0_sqn);
+
+ goto process_desc0_ignore;
+ }
+
+ if (LESS_SQN(ntohs(desc->ogm_sqn_min), (on->ogm_sqn_min + MAX_OGM0_SQN_RANGE))) {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "DAD-Alert: new ogm_sqn_min %d not > old %d + %d",
+ ntohs(desc->ogm_sqn_min), on->ogm_sqn_min, MAX_OGM0_SQN_RANGE);
+
+ goto process_desc0_ignore;
+ }
+ }
+
+
+ } else {
+ // create new orig:
+ on = debugMalloc( sizeof( struct orig_node ), -300128 );
+ memset( on, 0, sizeof( struct orig_node ) );
+ memcpy(&on->id, &desc->id, sizeof ( struct description_id));
+/*
+ on->id.rand.u32[0] = ntohl( desc->id.rand.u32[0] );
+ on->id.rand.u32[1] = ntohl( desc->id.rand.u32[1] );
+*/
+ AVL_INIT_TREE(on->router_tree, struct router_node, key );
+ avl_insert(&orig_tree, on, -300148);
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "rcvd new desc SQN %d (old %d) from %s via %s NB %s",
+ ntohs(desc->dsc_sqn), on->desc0_sqn, desc->id.name, pb->iif->name, pb->neigh_str);
+
+ if (process_description_tlvs(on, desc, TLV_DEL_TEST_ADD, NULL) == TLVS_FAILURE)
+ goto process_desc0_error;
+
+ // might result in TLVS_BLOCKED !!
+
+
+ on->updated_timestamp = bmx_time;
+ on->desc0_sqn = ntohs(desc->dsc_sqn);
+
+ on->ogm_sqn_min = ntohs(desc->ogm_sqn_min);
+ on->ogm_sqn_range = ntohs(desc->ogm_sqn_range);
+ on->ogm_sqn_pq_bits = desc->ogm_sqn_pq_bits;
+
+// on->ogm_sqn_mask = (MAX_SQN << on->ogm_sqn_pq_bits);
+// on->ogm_sqn_steps = (0x01 << on->ogm_sqn_pq_bits);
+
+
+ struct metric_algo test_algo;
+ memset(&test_algo, 0, sizeof (struct metric_algo));
+
+ test_algo.sqn_mask = (MAX_SQN << on->ogm_sqn_pq_bits);
+ test_algo.sqn_steps = (0x01 << on->ogm_sqn_pq_bits);
+ test_algo.regression = ntohs(desc->path_window_size) / test_algo.sqn_steps / 2;
+ test_algo.sqn_lounge = ntohs(desc->path_lounge_size);
+ test_algo.sqn_window = ntohs(desc->path_window_size);
+ test_algo.metric_max = PROBE_RANGE;
+
+
+ if ( validate_metric_algo( &test_algo, NULL ) == FAILURE )
+ goto process_desc0_error;
+
+ memcpy(&on->path_metric_algo, &test_algo, sizeof (struct metric_algo));
+
+ on->ogm_sqn_max_rcvd = on->ogm_sqn_aggregated = on->ogm_sqn_to_be_send = (on->ogm_sqn_min & on->path_metric_algo.sqn_mask);
+
+
+ // migrate current router_nodes->mr.clr position to new sqn_range:
+ struct router_node *rn;
+ struct avl_node *an;
+ for (an = NULL; (rn = avl_iterate_item(&on->router_tree, &an));)
+ rn->mr.clr = on->ogm_sqn_max_rcvd /*- on->path_metric_algo.sqn_steps*/;
+
+
+ if (on->desc0)
+ debugFree(on->desc0, -300111);
+
+ on->desc0 = desc;
+ desc = NULL;
+
+ struct neigh_node *dhn_neigh = NULL;
+
+ if (on->dhn) {
+ dhn_neigh = on->dhn->neigh;
+ on->dhn->neigh = NULL;
+ on->dhn->on = NULL;
+ invalidate_dhash_node(on->dhn);
+ }
+
+ on->dhn = dhn = create_dhash_node(dhash, on);
+
+ if ( dhn_neigh ) {
+ dhn_neigh->dhn = dhn;
+ dhn->neigh = dhn_neigh;
+ }
+
+ assertion(-500309, (dhn == avl_find_item(&dhash_tree, &dhn->dhash) && dhn->on == on));
+
+ assertion(-500310, (on == avl_find_item(&orig_tree, &on->desc0->id) && on->dhn == dhn));
+
+ return dhn;
+
+process_desc0_error:
+
+ if (on)
+ free_orig_node(on);
+
+ blacklist_neighbor(pb);
+
+process_desc0_ignore:
+
+ dbgf(DBGL_SYS, DBGT_WARN, "%jX rcvd via %s NB %s", desc ? desc->id.rand.u64[0] : 0, pb->iif->name, pb->neigh_str);
+
+ if (desc)
+ debugFree(desc, -300109);
+
+ return NULL;
+}
+
+IDM_T freed_tx_task_node(struct tx_task_node *ttn, int tx_creator_result, struct list_node *lprev)
+{
+
+ assertion( -500372, (ttn && (ttn)->dev ));
+
+ if (tx_creator_result != ((int) ((ttn)->frame_data_length_target))) {
+
+ dbgf(DBGL_CHANGES, DBGT_WARN, "msg %s to %s via %s mid4o %d send_data %d != target_data %d ",
+ frame_handler[(ttn)->frame_type].name,
+ ipStr((ttn)->dst_ip4),
+ (ttn)->dev->name,
+ (ttn)->myIID4x,
+ tx_creator_result,
+ (ttn)->frame_data_length_target);
+ }
+
+ if ((--((ttn)->tx_iterations)) == 0) {
+
+ (ttn)->dev->tx_frames_data_len_target -= (ttn)->frame_data_length_target;
+
+ if (lprev)
+ list_del_next(&((ttn)->dev->tx_tasks_list[(ttn)->frame_type]), lprev);
+ else
+ (ttn)->dev->my_tx_tasks[(ttn)->frame_type] = NULL;
+
+ debugFree((ttn), -300169);
+
+ return YES;
+ }
+
+ (ttn)->tx_timestamp = bmx_time;
+
+ return NO;
+}
+
+
+void schedule_tx_task(struct dev_node *dev_out, struct link_dev_node *lndev_out,
+ uint16_t frame_type, uint16_t frame_data_len, SQN_T sqn, IID_T myIID4x, IID_T neighIID4x)
+{
+ struct tx_task_node *ttn;
+ IP4_T dest_ip4 = lndev_out && lndev_out->link ? lndev_out->link->llip4 : 0;
+
+// struct link_node *ln_out = lndev_out ? lndev_out->link : NULL;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s %s sqn %d myIID4x %d neighIID4x %d",
+ frame_handler[frame_type].name, ipStr(dest_ip4), dev_out->name, sqn, myIID4x, neighIID4x);
+
+ if (frame_handler[ frame_type ].min_rtq > (lndev_out ? lndev_out->mr[SQR_RTQ].val : 0)) {
+ return;
+ }
+
+ assertion(-500380, (myIID4x != myIID4me)); // should have been translated to IID_RSVD_4YOU by calling function
+
+ assertion(-500433, (frame_handler[frame_type].tx_iterations));
+
+ if (myIID4x == IID_RSVD_4YOU) {
+
+ if ((ttn = dev_out->my_tx_tasks[frame_type])) {
+
+ dbgf(DBGL_SYS, DBGT_WARN, "my_tx_task for %s %s myIID4x %d neighIID4x %d dst %s NOT NULL",
+ frame_handler[frame_type].name, dev_out->name, myIID4x, neighIID4x, ipStr(dest_ip4));
+
+ assertion(-500442, (ttn->myIID4x == IID_RSVD_4YOU));
+
+ dev_out->tx_frames_data_len_target -= ttn->frame_data_length_target;
+
+ } else {
+ ttn = dev_out->my_tx_tasks[frame_type] = debugMalloc(sizeof ( struct tx_task_node), -300026);
+ }
+
+ } else {
+
+ ttn = debugMalloc(sizeof ( struct tx_task_node), -300026);
+ list_add_tail(&(dev_out->tx_tasks_list[frame_type]), &ttn->list);
+ }
+
+ ttn->sqn = sqn;
+ ttn->dst_ip4 = dest_ip4;
+ ttn->myIID4x = myIID4x;
+ ttn->neighIID4x = neighIID4x;
+ ttn->frame_type = frame_type;
+ ttn->tx_iterations = frame_handler[frame_type].tx_iterations;
+ ttn->tx_timestamp = bmx_time - 1;
+ ttn->dev = dev_out;
+
+ if (!frame_data_len && frame_handler[frame_type].fixed_msg_size && !frame_handler[frame_type].data_header_size) {
+
+ ttn->frame_data_length_target = frame_handler[ frame_type ].min_msg_size;
+
+ } else {
+
+ assertion( -500371, (frame_data_len));
+
+ ttn->frame_data_length_target = frame_data_len;
+ }
+
+ dev_out->tx_frames_data_len_target += ttn->frame_data_length_target;
+
+
+ uint16_t estimated_packet_len =
+ (sizeof (struct packet_header)) +
+ (sizeof (struct frame_header) * FRAME_TYPE_ARRSZ) +
+ (dev_out->tx_frames_data_len_target) +
+ (sizeof (struct msg_ogm_adv) * ogm_aggreg_pending);
+
+
+ if (estimated_packet_len > max_udpd_size) {
+ remove_task(tx_packet, dev_out);
+ register_task(1, tx_packet, dev_out);
+ }
+
+
+}
+
+
+
+
+void purge_dev_tx_list( struct dev_node *dev ) {
+ int i;
+
+ paranoia( -500203, !dev );
+
+ for (i = 0; i < FRAME_TYPE_ARRSZ; i++) {
+
+ struct tx_task_node * dtn;
+
+ while ((dtn=list_rem_head( &(dev->tx_tasks_list[i]) ) ))
+ debugFree(dtn, -300066);
+
+ if ((dtn = dev->my_tx_tasks[i])) {
+ debugFree(dtn, -300066);
+ dev->my_tx_tasks[i]=NULL;
+ }
+
+ }
+}
+
+STATIC_FUNC
+void create_ogm_aggregation(void)
+{
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " ");
+
+ uint32_t n = 0;
+
+ uint32_t target_aggregations = MIN(MAX_OGMS_PER_AGGREG,
+ ((ogm_aggreg_pending < ((DEF_OGMS_PER_AGGREG / 3)*4)) ? ogm_aggreg_pending : DEF_OGMS_PER_AGGREG));
+
+ struct msg_ogm_adv* ogm = debugMalloc(target_aggregations * sizeof (struct msg_ogm_adv), -300177);
+
+ static IID_T curr_iid = IID_MIN_USED;
+
+ if (curr_iid >= my_iid_repos.max_free)
+ curr_iid = IID_MIN_USED;
+
+ IID_T start_iid = curr_iid;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "pending %d target %d start %d",
+ ogm_aggreg_pending, target_aggregations, start_iid);
+
+ do {
+ IID_NODE_T *dhn = my_iid_repos.arr.node[curr_iid];
+ struct orig_node *on;
+ int warn = 0;
+
+ while (dhn && (on = dhn->on) &&
+ GREAT_SQN(on->ogm_sqn_to_be_send & on->path_metric_algo.sqn_mask, on->ogm_sqn_aggregated)) {
+
+ if (GREAT_SQN(on->ogm_sqn_to_be_send & on->path_metric_algo.sqn_mask,
+ on->ogm_sqn_aggregated + on->path_metric_algo.sqn_steps))
+ warn++;
+
+ dbgf(warn ? DBGL_CHANGES : DBGL_ALL, warn ? DBGT_WARN : DBGT_INFO, "%s %s %d < %d",
+ on->id.name, warn ? "delayed!" : "in-time",
+ on->ogm_sqn_aggregated, on->ogm_sqn_to_be_send);
+
+ on->ogm_sqn_aggregated = on->ogm_sqn_to_be_send & on->path_metric_algo.sqn_mask;
+
+ ogm[n].orig_sqn = htons(on->ogm_sqn_to_be_send);
+ ogm[n].transmitterIID4x = htons(dhn->myIID4orig);
+
+ if ((++n) == target_aggregations)
+ goto create_ogm_aggregation_done;
+ }
+
+ if ((++curr_iid) >= my_iid_repos.max_free)
+ curr_iid = IID_MIN_USED;
+
+ } while (curr_iid != start_iid);
+
+create_ogm_aggregation_done:
+
+ if (curr_iid == start_iid)
+ ogm_aggreg_pending = 0;
+ else
+ ogm_aggreg_pending -= n;
+
+ if (ogm_aggreg_pending) {
+ dbgf(DBGL_SYS, DBGT_WARN, "%d ogms left for immediate next aggregation", ogm_aggreg_pending);
+ }
+
+ if (!n) {
+ debugFree( ogm, -300219);
+ return;
+ }
+
+ struct ogm_aggreg_node *oan = debugMalloc(sizeof (struct ogm_aggreg_node), -300179);
+ oan->aggregated_ogms = n;
+ oan->ogm_advs = ogm;
+ oan->tx_attempts = 0;
+ oan->tx_timestamp = (bmx_time - DEF_OGM_RESEND_INTERVAL);
+ oan->sqn = ++ogm_aggreg_sqn_max;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "aggregation_sqn %d aggregated_ogms %d", oan->sqn, n);
+
+ list_add_tail(&ogm_aggreg_list, &oan->list);
+
+ struct avl_node *an = NULL;
+ struct neigh_node *nn;
+
+ while ((nn = avl_iterate_item(&neigh_tree, &an))) {
+
+ bit_set(nn->ogm_aggregations_acked, OGM_AGGREG_SQN_CACHE_RANGE, ogm_aggreg_sqn_max, 0);
+
+ }
+
+ return;
+}
+
+STATIC_FUNC
+struct link_dev_node **get_best_lndevs_by_criteria(struct ogm_aggreg_node *oan_criteria, struct dhash_node *dhn_criteria)
+{
+
+ static struct link_dev_node **lndev_arr = NULL;
+ static uint16_t lndev_arr_items = 0;
+ struct avl_node *an;
+ struct neigh_node *nn;
+ struct dev_node *dev;
+ uint16_t d = 0;
+
+ if (lndev_arr_items < dev_ip4_tree.items + 1) {
+
+ if (lndev_arr)
+ debugFree(lndev_arr, -300180);
+
+ lndev_arr_items = dev_ip4_tree.items + 1;
+ lndev_arr = debugMalloc((lndev_arr_items * sizeof (struct link_dev_node*)), -300182);
+ }
+
+ if ( oan_criteria || dhn_criteria ) {
+
+ if (oan_criteria) {
+ dbgf(DBGL_CHANGES, DBGT_INFO, "aggreg_sqn %d ", oan_criteria->sqn);
+ } else if (dhn_criteria) {
+ dbgf(DBGL_CHANGES, DBGT_INFO, "NOT %s ", dhn_criteria->on->id.name);
+ }
+
+ for (an = NULL; (dev = avl_iterate_item(&dev_ip4_tree, &an));)
+ dev->misc_flag = NO;
+
+
+ for (an = NULL; (nn = avl_iterate_item(&neigh_tree, &an));) {
+
+ if (oan_criteria &&
+ (bit_get(nn->ogm_aggregations_acked, OGM_AGGREG_SQN_CACHE_RANGE, oan_criteria->sqn) ||
+ nn->best_rtq->mr[SQR_RTQ].val <= MIN_OGM_ACK_RTQ) )
+ continue;
+
+ if (dhn_criteria && dhn_criteria->neigh == nn)
+ continue;
+
+ assertion(-500445, (nn->best_rtq));
+ assertion(-500446, (nn->best_rtq->key.dev));
+ assertion(-500447, (nn->best_rtq->key.dev->active));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " via %s to %s (redundant %d)",
+ nn->best_rtq->key.dev->name, nn->best_rtq->link->llip4_str,
+ nn->best_rtq->key.dev->misc_flag);
+
+ if (nn->best_rtq->key.dev->misc_flag == NO) {
+
+ lndev_arr[d++] = nn->best_rtq;
+
+ nn->best_rtq->key.dev->misc_flag = YES;
+ }
+
+ assertion(-500444, (d <= dev_ip4_tree.items));
+
+ }
+ }
+
+ lndev_arr[d] = NULL;
+
+ return lndev_arr;
+}
+
+STATIC_FUNC
+void schedule_and_purge_ogm_aggregations(struct dev_node *dev)
+{
+ static uint32_t timestamp = 0;
+
+ if (dev) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s max %d active aggregations %d pending ogms %d expiery in %d ms",
+ dev->name, ogm_aggreg_sqn_max, ogm_aggreg_list.items, ogm_aggreg_pending,
+ (DEF_OGM_AGGREG_INTERVAL - ((uint32_t) (bmx_time - timestamp))));
+
+ while (ogm_aggreg_pending && ((((uint32_t) bmx_time - timestamp)) >= DEF_OGM_AGGREG_INTERVAL)) {
+
+ struct ogm_aggreg_node *oan = list_get_first(&ogm_aggreg_list);
+
+ if (oan && ((SQN_T) ((ogm_aggreg_sqn_max + 1) - oan->sqn)) >= OGM_AGGREG_SQN_CACHE_RANGE) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "ogm_aggreg_list full min %d max %d items %d unaggregated %d",
+ oan->sqn, ogm_aggreg_sqn_max, ogm_aggreg_list.items, ogm_aggreg_pending);
+
+ debugFree(oan->ogm_advs, -300185);
+ debugFree(oan, -300186);
+ list_del_next(&ogm_aggreg_list, ((struct list_node*) & ogm_aggreg_list));
+ }
+
+ create_ogm_aggregation();
+
+ if (!ogm_aggreg_pending)
+ timestamp = bmx_time;
+ }
+ }
+
+#ifndef NO_PARANOIA
+ if (!ogm_aggreg_pending) {
+ IID_T i;
+ struct dhash_node *dhn;
+ for (i = IID_MIN_USED; i < my_iid_repos.max_free && (dhn = my_iid_repos.arr.node[i]); i++) {
+ struct orig_node * on = dhn->on;
+ assertion(-500473,
+ (!(on && GREAT_SQN(on->ogm_sqn_to_be_send & on->path_metric_algo.sqn_mask, on->ogm_sqn_aggregated))));
+ }
+ }
+#endif
+
+ struct list_node *lpos, *tpos, *lprev = (struct list_node*) & ogm_aggreg_list;
+
+ list_for_each_safe(lpos, tpos, &ogm_aggreg_list)
+ {
+ struct ogm_aggreg_node *oan = list_entry(lpos, struct ogm_aggreg_node, list);
+
+ if (dev == NULL/*purge_all*/ ||
+ ((((uint32_t) (bmx_time - oan->tx_timestamp)) > DEF_OGM_RESEND_INTERVAL) &&
+ oan->tx_attempts > ogm_resend_attempts)) {
+
+ list_del_next(&ogm_aggreg_list, lprev);
+ debugFree(oan->ogm_advs, -300183);
+ debugFree(oan, -300184);
+
+ continue;
+
+ } else if ((((uint32_t) (bmx_time - oan->tx_timestamp)) >= DEF_OGM_RESEND_INTERVAL) &&
+ oan->tx_attempts <= ogm_resend_attempts) {
+
+ struct link_dev_node **lndev_arr = get_best_lndevs_by_criteria(oan, NULL);
+ int d;
+
+ for (d = 0; (lndev_arr[d]); d++) {
+ schedule_tx_task((lndev_arr[d])->key.dev, NULL, FRAME_TYPE_OGM0_ADVS,
+ (sizeof (struct hdr_ogm_adv) + (oan->aggregated_ogms * sizeof (struct msg_ogm_adv))),
+ oan->sqn, 0, 0);
+ }
+
+ if (!lndev_arr[0])
+ oan->tx_attempts = ogm_resend_attempts;
+
+ oan->tx_timestamp = bmx_time;
+ oan->tx_attempts++;
+ }
+
+ lprev = lpos;
+ }
+}
+
+
+STATIC_FUNC
+int tx_msg_hello40_reply(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ struct msg_hello_reply *hey0_rep = (struct msg_hello_reply *) (tx_buff);
+
+ hey0_rep->receiver_ip4 = ttn->dst_ip4;
+ hey0_rep->hello_dev_sqn = htons(ttn->sqn);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "dev %s %s to %s SQN %d",// dest_sid: %d",
+ ttn->dev->name, ttn->dev->ip4_str, ipStr(ttn->dst_ip4), ttn->sqn/*, dtn->my_id_for_neigh*/);
+
+ return sizeof (struct msg_hello_reply);
+}
+
+
+
+STATIC_FUNC
+int tx_msg_helloX0_adv(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+
+ struct msg_hello_adv *hey0_adv = (struct msg_hello_adv *) (tx_buff);
+
+ hey0_adv->hello_dev_sqn = htons(++(ttn->dev->ogm_sqn));
+
+ struct avl_node *it;
+ struct link_dev_node *lndev;
+
+ for (it = NULL; (lndev = avl_iterate_item(&link_dev_tree, &it));) {
+ // we dont want to clean the sqr of other devs
+ // update_link_node(ln, ttn->dev, ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, SQR_RTQ, 0);
+ if (lndev->key.dev != ttn->dev)
+ continue;
+
+// update_lounged_metric(0, local_rtq_lounge, ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, &lndev->sqr[SQR_RTQ], local_lws);
+
+ update_metric(&lndev->mr[SQR_RTQ], &link_metric_algo[SQR_RTQ], ttn->dev->ogm_sqn, ttn->dev->ogm_sqn, 0);
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s %s SQN %d", ttn->dev->name, ttn->dev->ip4_str, ttn->dev->ogm_sqn);
+
+ return sizeof (struct msg_hello_adv);
+}
+
+STATIC_FUNC
+int tx_msg_dhash0_or_description0_request(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ assertion( -500366 , (sizeof ( struct msg_description_request) == sizeof( struct msg_dhash_request)));
+
+ struct msg_dhash_request *req = (struct msg_dhash_request *) (tx_buff);
+
+ req->receiver_ip4 = ttn->dst_ip4;
+ req->receiverIID4x = htons(ttn->neighIID4x);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s oif %s to %s requesting orig_did %d",
+ frame_handler[ttn->frame_type].name, ttn->dev->name, ipStr(ttn->dst_ip4), ttn->neighIID4x);
+
+ return sizeof ( struct msg_description_request);
+}
+
+
+STATIC_FUNC
+int tx_msg_description0_adv(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ struct dhash_node *dhn = NULL;
+ struct msg_description_adv *desc0_adv = (struct msg_description_adv *) tx_buff;
+ struct description *desc0;
+
+ dbgf_all(DBGT_INFO, "ttn->myIID4x %d", ttn->myIID4x);
+
+ if (ttn->myIID4x == IID_RSVD_4YOU) {
+
+ desc0_adv->transmitterIID4x = htons(myIID4me);
+ desc0 = my_orig_node.desc0;
+ *flags |= FRAME_FLAG_firstIsSender;
+
+ } else if ((dhn = iid_get_node_by_myIID4x(ttn->myIID4x)) && dhn->on) {
+
+ assertion(-500437, (dhn->on && dhn->on->desc0));
+
+ desc0_adv->transmitterIID4x = htons(ttn->myIID4x);
+ desc0 = dhn->on->desc0;
+
+ } else {
+
+ dbgf(DBGL_SYS, DBGT_WARN, "unknown myIID4x %d !", ttn->myIID4x);
+ return FAILURE;
+ }
+
+ uint16_t tlvs_len = ntohs(desc0->dsc_tlvs_len);
+
+ if (sizeof (struct msg_description_adv) + tlvs_len > buff_size)
+ return (buff_size + 1);
+
+ memcpy((char*) & desc0_adv->desc, (char*) desc0, sizeof (struct description) + tlvs_len);
+
+ return sizeof (struct msg_description_adv) + tlvs_len;
+}
+
+
+
+
+STATIC_FUNC
+int tx_msg_dhash0_adv(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ struct msg_dhash_adv *dhash0_adv = (struct msg_dhash_adv *) tx_buff;
+ struct dhash_node *dhn;
+
+ if (ttn->myIID4x == IID_RSVD_4YOU) {
+
+ dhash0_adv->transmitterIID4x = htons(myIID4me);
+ dhn = my_orig_node.dhn;
+ *flags |= FRAME_FLAG_firstIsSender;
+
+ } else if ((dhn = iid_get_node_by_myIID4x(ttn->myIID4x)) && dhn->on) {
+
+ assertion(-500259, (dhn->on && dhn->on->desc0));
+
+ dhash0_adv->transmitterIID4x = htons(ttn->myIID4x);
+
+ } else {
+
+ dbgf(DBGL_SYS, DBGT_WARN, "unknown myIID4x %d !", ttn->myIID4x);
+ return FAILURE;
+ }
+
+ memcpy((char*) & dhash0_adv->dhash, (char*) & dhn->dhash, sizeof ( struct description_hash));
+
+ return sizeof (struct msg_dhash_adv);
+}
+
+
+
+
+STATIC_FUNC
+int tx_frame_ogm0_advs(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ struct list_node *list_pos;
+
+ assertion(-500428, (ttn->frame_data_length_target <= buff_size));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " aggregation_sqn %d", ttn->sqn );
+
+ list_for_each( list_pos, &ogm_aggreg_list )
+ {
+ struct ogm_aggreg_node *oan = list_entry(list_pos, struct ogm_aggreg_node, list);
+
+ if ( oan->sqn == ttn->sqn ) {
+
+ ((struct hdr_ogm_adv*) tx_buff)->aggregation_sqn = htons(ttn->sqn);
+
+ memcpy(tx_buff + sizeof (struct hdr_ogm_adv),
+ oan->ogm_advs, oan->aggregated_ogms * sizeof (struct msg_ogm_adv));
+
+ assertion(-500429, (ttn->frame_data_length_target ==
+ (sizeof (struct hdr_ogm_adv) + oan->aggregated_ogms * sizeof (struct msg_ogm_adv))));
+
+ return ttn->frame_data_length_target;
+
+ }
+ }
+
+ return FAILURE;
+}
+
+
+STATIC_FUNC
+int tx_msg_ogm_ack(struct tx_task_node *ttn, uint8_t *flags, uint8_t *tx_buff, uint16_t buff_size)
+{
+ struct msg_ogm_ack *ack = (struct msg_ogm_ack *) tx_buff;
+
+ ack->receiver_ip4 = ttn->dst_ip4;
+ ack->aggregation_sqn = htons(ttn->sqn);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " aggreg_sqn %d to %s", ttn->sqn, ipStr(ttn->dst_ip4));
+
+ return sizeof (struct msg_ogm_ack);
+}
+
+
+STATIC_FUNC
+int rx_frame_ogm0_advs(struct packet_buff *pb, struct frame_header *frame)
+{
+ struct hdr_ogm_adv *hdr = (struct hdr_ogm_adv *) frame->data;
+ struct msg_ogm_adv *ogm = hdr->msg;
+ struct neigh_node *nn = pb->ln->neigh;
+
+ SQN_T aggregation_sqn = ntohs(hdr->aggregation_sqn);
+
+ uint16_t msgs = (frame->length - (sizeof (struct frame_header) + sizeof (struct hdr_ogm_adv))) /
+ sizeof (struct msg_ogm_adv);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " ");
+
+ if (!nn) {
+ dbgf(DBGL_CHANGES, DBGT_INFO, "via unknown neigh %s", pb->neigh_str );
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_REQS, 0, 0, 0, IID_RSVD_4YOU);
+ return frame->length;
+ }
+
+ schedule_tx_task(nn->best_rtq->key.dev, nn->best_rtq, FRAME_TYPE_OGM0_ACKS, 0, aggregation_sqn, 0, 0);
+
+ if ((SQN_T) (nn->ogm_aggregation_rcvd_max - aggregation_sqn) < OGM_AGGREG_SQN_CACHE_RANGE) {
+
+ if (bit_get(nn->ogm_aggregations_rcvd, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn)) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "already known ogm_aggregation_sqn %d from neigh %s",
+ aggregation_sqn, nn->dhn->on->id.name);
+
+ return frame->length;
+ }
+
+ if (((uint16_t) (nn->ogm_aggregation_rcvd_max - aggregation_sqn)) > OGM_AGGREG_SQN_CACHE_WARN) {
+
+ dbgf( DBGL_SYS, DBGT_WARN, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
+ pb->neigh_str, "OLD", aggregation_sqn, nn->ogm_aggregation_rcvd_max, msgs);
+ }
+
+ bit_set(nn->ogm_aggregations_rcvd, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn, 1);
+
+ } else {
+
+ if (((uint16_t) (aggregation_sqn - nn->ogm_aggregation_rcvd_max)) > OGM_AGGREG_SQN_CACHE_WARN) {
+
+ dbgf( DBGL_SYS, DBGT_WARN, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
+ pb->neigh_str, "LOST", aggregation_sqn, nn->ogm_aggregation_rcvd_max, msgs );
+ }
+
+ bit_clear(nn->ogm_aggregations_rcvd, OGM_AGGREG_SQN_CACHE_RANGE, nn->ogm_aggregation_rcvd_max + 1, aggregation_sqn);
+
+ bit_set(nn->ogm_aggregations_rcvd, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn, 1);
+ nn->ogm_aggregation_rcvd_max = aggregation_sqn;
+
+ }
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "neigh %s with unknown %s aggregation_sqn %d max %d ogms %d",
+ pb->neigh_str, "NEW", aggregation_sqn, nn->ogm_aggregation_rcvd_max, msgs);
+
+ uint16_t m;
+ for (m = 0; m < msgs; m++) {
+
+ IID_T neighIID4x = ntohs(ogm[m].transmitterIID4x);
+ SQN_T orig_sqn = ntohs(ogm[m].orig_sqn);
+
+ IID_NODE_T *dhn = iid_get_node_by_neighIID4x(nn, neighIID4x );
+ struct orig_node *on = NULL;
+
+ if ( dhn == my_orig_node.dhn )
+ continue;
+
+
+ if (dhn && (on = dhn->on) && ((SQN_T) (orig_sqn - on->ogm_sqn_min)) < on->ogm_sqn_range) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, " new orig_sqn %d / %d from %s neighIID4x %d via %s ",
+ orig_sqn, on->ogm_sqn_to_be_send, on->id.name, neighIID4x, pb->neigh_str);
+
+ update_orig_metrics(pb, on, orig_sqn);
+
+
+ } else {
+ dbgf(!dhn ? DBGL_CHANGES : DBGL_SYS, DBGT_WARN,
+ " %s orig_sqn %d or neighIID4x %d via %s orig %s sqn_min %d sqn_range %d",
+ !dhn ? "UNKNOWN" : on ? "EXCEEDED OGM_SQN RANGE" : "INVALIDATED",
+ orig_sqn, neighIID4x, pb->neigh_str, on ? on->id.name:"---",
+ on ? on->ogm_sqn_min : 0, on ? on->ogm_sqn_range : 0);
+
+ if (dhn && dhn->on)
+ invalidate_dhash_node(dhn);
+
+ schedule_tx_task(nn->best_rtq->key.dev, nn->best_rtq, FRAME_TYPE_DHS0_REQS, 0, 0, 0, neighIID4x);
+ }
+ }
+
+ return frame->length;
+}
+
+STATIC_FUNC
+int rx_frame_ogm40_acks(struct packet_buff *pb, struct frame_header *frame)
+{
+ struct msg_ogm_ack *ack = (struct msg_ogm_ack *) frame->data;
+ struct neigh_node *nn = pb->ln->neigh;
+
+ uint16_t msgs = (frame->length - (sizeof (struct frame_header))) / sizeof (struct msg_ogm_ack);
+
+ if (!nn) {
+ dbgf(DBGL_CHANGES, DBGT_WARN, "%s neigh %s", "unknown", pb->neigh_str);
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_REQS, 0, 0, 0, IID_RSVD_4YOU);
+ return frame->length;
+ }
+
+ uint16_t m;
+ for (m = 0; m < msgs; m++) {
+
+ if ( ack[m].receiver_ip4 != pb->iif->ip4_addr )
+ continue;
+
+ SQN_T aggregation_sqn = ntohs(ack[m].aggregation_sqn);
+
+ if (((uint32_t) (ogm_aggreg_sqn_max - aggregation_sqn) < OGM_AGGREG_SQN_CACHE_RANGE)) {
+
+ bit_set(pb->ln->neigh->ogm_aggregations_acked, OGM_AGGREG_SQN_CACHE_RANGE, aggregation_sqn, 1);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "neigh %s sqn %d <= sqn_max %d",
+ pb->neigh_str, aggregation_sqn, ogm_aggreg_sqn_max);
+
+
+ } else {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "neigh %s sqn %d <= sqn_max %d",
+ pb->neigh_str, aggregation_sqn, ogm_aggreg_sqn_max);
+
+ }
+ }
+ return frame->length;
+}
+
+
+STATIC_FUNC
+struct dhash_node *
+process_dhash_description_neighIID4x
+(struct packet_buff *pb, struct description_hash *dhash, struct description *dsc, IID_T neighIID4x, IDM_T is_sender)
+{
+ struct dhash_node *orig_dhn = NULL;
+ struct link_node *ln = pb->ln;
+ IDM_T invalid = NO;
+ struct description *cache = NULL;
+
+ if (avl_find(&dhash_invalid_tree, dhash)) {
+
+ invalid = YES;
+
+ } else if ((orig_dhn = avl_find_item(&dhash_tree, dhash))) {
+
+ if (ln->neigh) {
+
+ // this was just for testing eh??? assertion(-500375, (ln->neigh->dhn == orig_dhn));
+
+ if (orig_dhn == my_orig_node.dhn) {
+
+ dbgf(DBGL_CHANGES, DBGT_INFO,
+ "msg refers myself via %s neighIID4neigh %d neighIID4me %d",
+ pb->neigh_str, ln->neigh->neighIID4neigh, neighIID4x);
+
+ if (is_sender)
+ return FAILURE_POINTER;
+
+
+ } else if (orig_dhn == ln->neigh->dhn) {
+
+ if (!is_sender) {
+
+ dbgf(DBGL_SYS, DBGT_ERR, "%s via %s IS NOT sender (%d != %d)",
+ orig_dhn->on->id.name, pb->neigh_str,
+ ln->neigh->neighIID4neigh, neighIID4x);
+
+ return FAILURE_POINTER;
+
+ } else if((ln->neigh->neighIID4neigh != neighIID4x)) {
+
+ dbgf(DBGL_CHANGES, DBGT_WARN, "%s via %s first contact NOT VIA SENDER ??? %d != %d",
+ orig_dhn->on->id.name, pb->neigh_str,
+ ln->neigh->neighIID4neigh, neighIID4x);
+
+ }
+ }
+
+ if (is_sender)
+ update_neigh_node(ln, orig_dhn, neighIID4x);
+
+ else if (update_neighIID4x_repository(ln->neigh, neighIID4x, orig_dhn) == FAILURE)
+ return FAILURE_POINTER;
+
+
+ } else {
+
+ if (is_sender) {
+ update_neigh_node(ln, orig_dhn, neighIID4x);
+ } else {
+ //update_neigh_node(ln, dhn, IID_RSVD_UNUSED);
+ //update_neigh_iid_repos(ln->neigh, neighIID4x, dhn);
+ }
+ }
+
+ } else {
+
+ // its just the easiest to cache and remove because cache description is doing all the checks for us
+ if (dsc)
+ cache_description(dsc, dhash);
+
+ if (is_sender && (cache = rem_cached_description(dhash))) {
+
+ if ((orig_dhn = process_description(pb, cache, dhash))) {
+
+ update_neigh_node(ln, orig_dhn, neighIID4x);
+ }
+
+ } else if (ln->neigh && (cache = rem_cached_description(dhash))) {
+
+ orig_dhn = process_description(pb, cache, dhash);
+
+ if (orig_dhn && update_neighIID4x_repository(ln->neigh, neighIID4x, orig_dhn) == FAILURE)
+ return FAILURE_POINTER;
+
+ }
+ }
+
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "via dev: %s NB %s:dhash %8X.. %s neighIID4x %d is_sender %d %s",
+ pb->iif->name, pb->neigh_str, dhash->h.u32[0],
+ (dsc ? "DESCRIPTION" : (cache ? "CACHED_DESCRIPTION" : (orig_dhn?"KNOWN":"UNDESCRIBED"))),
+ neighIID4x, is_sender,
+ invalid ? "INVALIDATED" : (orig_dhn && orig_dhn->on ? orig_dhn->on->id.name : "---"));
+
+
+ return orig_dhn;
+}
+
+
+STATIC_FUNC
+int rx_frame_dhash0_advs(struct packet_buff *pb, struct frame_header *frame)
+{
+
+ assertion(-500373, (pb->ln && pb->lndev && pb->lndev->mr[SQR_RTQ].val >= MIN_NBDISC_RTQ));
+
+ int m, n = (frame->length - sizeof (struct frame_header)) / sizeof ( struct msg_dhash_adv);
+
+ for (m = 0; m < n; m++) {
+
+ struct msg_dhash_adv *msg = &(((struct msg_dhash_adv*) (frame->data))[m]);
+ IDM_T is_sender = (m == 0 && (frame->flags & FRAME_FLAG_firstIsSender));
+ IID_T neighIID4x = ntohs(msg->transmitterIID4x);
+ struct dhash_node *dhn;
+
+ if ( neighIID4x <= IID_RSVD_MAX )
+ return FAILURE;
+
+ dhn = process_dhash_description_neighIID4x(pb, &msg->dhash, NULL, neighIID4x, is_sender);
+
+ if (dhn == FAILURE_POINTER) {
+
+ return FAILURE;
+
+ } else if (!dhn) {
+
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DSC0_REQS, 0, 0, 0, neighIID4x);
+
+ }/* else if (dhn && is_sender && !pb->ln->neigh) {
+
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_REQS, 0, 0, 0, IID_RSVD_4YOU);
+ }*/
+
+ paranoia(-500488, (dhn && is_sender && !pb->ln->neigh));
+
+
+ }
+ return frame->length;
+}
+
+
+STATIC_FUNC
+int rx_frame_description0_advs(struct packet_buff *pb, struct frame_header *frame)
+{
+
+ uint16_t pos = sizeof ( struct frame_header);
+
+ struct description_hash dhash0;
+
+ while (pos + sizeof ( struct msg_description_adv) <= frame->length) {
+
+ IDM_T is_sender = (pos == sizeof ( struct frame_header) && (frame->flags & FRAME_FLAG_firstIsSender));
+ struct msg_description_adv *adv = ((struct msg_description_adv*) (((char*)frame)+pos));
+ struct description *desc0 = &adv->desc;
+ uint16_t tlvs_len = ntohs(desc0->dsc_tlvs_len);
+ IID_T neighIID4x = ntohs(adv->transmitterIID4x);
+ struct dhash_node *dhn;
+
+ if ( neighIID4x <= IID_RSVD_MAX )
+ return FAILURE;
+
+ if (tlvs_len > MAX_DESC0_TLV_SIZE ||
+ pos + sizeof ( struct msg_description_adv) + tlvs_len > frame->length) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "illegal pos %d + %lu tlvs_len %d > frm_size %d",
+ pos, sizeof ( struct msg_description_adv), tlvs_len, frame->length );
+
+ return FAILURE;
+ }
+
+ ShaUpdate(&bmx_sha, (byte*) desc0, (sizeof (struct description) + tlvs_len));
+ ShaFinal(&bmx_sha, (byte*)&dhash0);
+
+ dhn = process_dhash_description_neighIID4x(pb, &dhash0, desc0, neighIID4x, is_sender);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "rcvd %s desc0: %jX via %s NB %s",
+ dhn ? "accepted" : "denied", desc0->id.rand.u64[0], pb->iif->name, pb->neigh_str);
+
+
+ if (dhn == FAILURE_POINTER) {
+
+ return FAILURE;
+
+ } else if (dhn && dhn->on->updated_timestamp == bmx_time && pb->ln->neigh && DEF_UNSOLICITED_DESCRIPTIONS) {
+
+ struct link_dev_node **lndev_arr = get_best_lndevs_by_criteria(NULL, pb->ln->neigh->dhn);
+ int d;
+
+ uint16_t desc_len = sizeof ( struct msg_description_adv) + ntohs(dhn->on->desc0->dsc_tlvs_len);
+
+ for (d = 0; (lndev_arr[d]); d++)
+ schedule_tx_task(lndev_arr[d]->key.dev, lndev_arr[d], FRAME_TYPE_DSC0_ADVS, desc_len, 0, dhn->myIID4orig, 0);
+
+
+ }
+
+
+ paranoia(-500379, (dhn && is_sender && !pb->ln->neigh));
+
+ pos += sizeof ( struct msg_description_adv) + tlvs_len;
+ }
+
+ if (frame->length != pos)
+ return FAILURE;
+
+
+ return frame->length;
+}
+
+STATIC_FUNC
+int rx_frame_dhash0_or_description0_requests(struct packet_buff *pb, struct frame_header *frame)
+{
+ assertion( -500365 , (sizeof( struct msg_description_request ) == sizeof( struct msg_dhash_request)));
+
+ int m, n = (frame->length - sizeof (struct frame_header)) / sizeof ( struct msg_description_request);
+
+ uint8_t frame_type = frame->type;
+
+
+ for (m = 0; m < n; m++) {
+
+ struct msg_description_request *req = &(((struct msg_description_request*) (frame->data))[m]);
+ IID_T myIID4x = ntohs(req->receiverIID4x);
+ uint16_t desc0_len = 0;
+
+ dbg(DBGL_CHANGES, DBGT_INFO, "%s dest_llip4 %s myIID4x %d",
+ frame_handler[frame_type].name, ipStr(req->receiver_ip4), myIID4x);
+
+ if ( req->receiver_ip4 != pb->iif->ip4_addr ) // if I am not asked
+ continue;
+
+
+ if (myIID4x == IID_RSVD_4YOU || myIID4x == myIID4me) {
+
+ myIID4x = IID_RSVD_4YOU;
+
+ desc0_len = sizeof ( struct msg_description_adv) + my_desc0_tlv_len;
+
+ } else { // if I am asked for somebody else description
+
+ struct dhash_node *dhn = iid_get_node_by_myIID4x(myIID4x);
+
+ assertion(-500270, (!(dhn && dhn->on && !dhn->on->desc0)));
+
+ if (myIID4x <= IID_RSVD_MAX || !dhn || !dhn->on ||
+ ((uint32_t) (bmx_time - dhn->referred_timestamp)) > DEF_DESC0_REFERRED_TO) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "%s from %s via %s myIID4x %d requesting %s",
+ frame_handler[frame_type].name, pb->ln->llip4_str, pb->iif->name, myIID4x,
+ !dhn ? "UNKNOWN" : (dhn->on ? "OUTDATED" : "INVALID"));
+
+ continue;
+ }
+
+ assertion(-500251, (dhn && dhn->on && dhn->myIID4orig == myIID4x));
+ desc0_len = sizeof ( struct msg_description_adv) + ntohs(dhn->on->desc0->dsc_tlvs_len);
+ }
+
+
+ if ( frame_type == FRAME_TYPE_DSC0_REQS) {
+
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DSC0_ADVS, desc0_len, 0, myIID4x, 0);
+
+ } else {
+
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_ADVS, 0, 0, myIID4x, 0);
+ }
+ }
+
+ return frame->length;
+}
+
+STATIC_FUNC
+int rx_frame_hello40_replies(struct packet_buff *pb, struct frame_header *frame)
+{
+
+ int found = 0, m, n = (frame->length - sizeof (struct frame_header)) / sizeof ( struct msg_hello_reply);
+
+ for (m = 0; m < n; m++) {
+
+ struct msg_hello_reply *msg = &(((struct msg_hello_reply*) (frame->data))[m]);
+
+ SQN_T sqn = ntohs(msg->hello_dev_sqn);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "via NB %s dev %s %s to %s SQN %d",
+ pb->neigh_str, pb->iif->name, pb->iif->ip4_str, ipStr(msg->receiver_ip4), sqn);
+
+ if ( msg->receiver_ip4 != pb->iif->ip4_addr )
+ continue;
+
+
+ if ((SQN_T) (pb->iif->ogm_sqn - sqn) > (SQN_T) local_rtq_lounge) {
+
+ dbgf(DBGL_SYS, DBGT_INFO, "DAD-Alert invalid Link-Local SQN %d!=%d from %s via %s",
+ sqn, pb->iif->ogm_sqn, pb->neigh_str, pb->iif->name);
+
+ return FAILURE;
+ }
+
+ found++;
+
+ if( !pb->ln->neigh)
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_DHS0_REQS, 0, 0, 0, IID_RSVD_4YOU);
+
+ update_link_node(pb->ln, pb->iif, sqn, pb->iif->ogm_sqn, SQR_RTQ, PROBE_RANGE);
+
+ }
+
+ if (found > 1) {
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "rcvd %d %s messages in %d-bytes frame",
+ found, frame_handler[FRAME_TYPE_HI40_REPS].name, frame->length);
+ }
+
+ return frame->length;
+
+}
+
+
+
+STATIC_FUNC
+int rx_frame_helloX0_advs( struct packet_buff *pb, struct frame_header *frame )
+{
+
+ struct link_node *ln = pb->ln;
+
+ int m, n = (frame->length - sizeof (struct frame_header)) / sizeof ( struct msg_hello_adv);
+
+ if (frame->length != sizeof ( struct frame_header) + sizeof ( struct msg_hello_adv)) {
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "rcvd %d %s messages in %d-bytes frame",
+ n, frame_handler[FRAME_TYPE_HI40_ADVS].name, frame->length);
+ }
+
+ for (m = 0; m < n; m++) {
+
+ struct msg_hello_adv *msg = &(((struct msg_hello_adv*) (frame->data))[m]);
+
+ SQN_T sqn = ntohs(msg->hello_dev_sqn);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "NB %s via %s SQN %d ", pb->neigh_str, pb->iif->name, sqn);
+
+ // skip updateing link_node if this SQN is known but not new
+ if ((ln->rq_sqn_max || ln->rq_time_max) &&
+ ((SQN_T) (sqn - ln->rq_sqn_max) > SQN_DAD_RANGE) &&
+ ((uint32_t) (bmx_time - ln->rq_time_max) < (uint32_t) dad_to)) {
+
+ dbgf(DBGL_SYS, DBGT_INFO, "DAD-Alert NB %s via %s SQN %d rq_sqn_max %d",
+ pb->neigh_str, pb->iif->name, sqn, ln->rq_sqn_max);
+
+ return FAILURE;
+ }
+
+ schedule_tx_task(pb->iif, pb->lndev, FRAME_TYPE_HI40_REPS, 0, sqn, 0, 0);
+
+ update_link_node(ln, pb->iif, sqn, sqn, SQR_RQ, PROBE_RANGE);
+
+ }
+
+ return frame->length;
+}
+
+
+
+int rx_frames(struct packet_buff *pb, uint8_t* fdata, uint16_t fsize)
+{
+
+ uint16_t frm_pos = 0;
+ int t = 0, pt = 0;
+
+ struct frame_header *fhdr = NULL;
+ uint16_t flength = 0;
+
+ while (frm_pos + sizeof ( struct frame_header) < fsize) {
+
+ fhdr = (struct frame_header*) & (fdata[frm_pos]);
+ flength = fhdr->length = ntohs(fhdr->length);
+ int receptor_result;
+
+ if ((t = fhdr->type) < pt || flength < sizeof ( struct frame_header) || flength + frm_pos > fsize) {
+
+ goto rx_frames_frm_error;
+ }
+
+ struct pkt_frame_handler *fhdl = &frame_handler[t];
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "type %s size %d flags 0x%X",
+ fhdl->name, flength, fhdr->flags);
+
+
+ if (t > FRAME_TYPE_NOP || !(fhdl->rx_frm_receptor)) {
+
+ dbgf(DBGL_SYS, DBGT_WARN, "unsupported type %d ! maybe you need an update?", t);
+
+ if (t > FRAME_TYPE_NOP)
+ goto rx_frames_frm_error;
+
+ } else if (flength - sizeof (struct frame_header) < fhdl->data_header_size + fhdl->min_msg_size) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "too small size %d for type %s", flength, fhdl->name);
+ goto rx_frames_frm_error;
+
+ } else if (fhdl->fixed_msg_size &&
+ (flength - (sizeof (struct frame_header) + fhdl->data_header_size)) % fhdl->min_msg_size) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "nonmaching size %d for type %s", flength, fhdl->name);
+ goto rx_frames_frm_error;
+
+ } else if (fhdl->min_rtq && (!pb->lndev || pb->lndev->mr[SQR_RTQ].val < fhdl->min_rtq)) {
+
+ dbg_mute(60, DBGL_SYS, DBGT_WARN,
+ "non-sufficient bidirectional link %s - %s (rtq %d), skipping frame type %s",
+ pb->iif->ip4_str, pb->neigh_str,
+ pb->lndev ? pb->lndev->mr[SQR_RTQ].val : 0, fhdl->name);
+
+ } else if (flength != (receptor_result = (*(fhdl->rx_frm_receptor)) (pb, fhdr))) {
+
+ if (receptor_result == FAILURE)
+ blacklist_neighbor(pb);
+
+ goto rx_frames_msg_error;
+
+ }
+
+ pt = t;
+ frm_pos += flength;
+ }
+
+ if ( frm_pos != fsize )
+ goto rx_frames_frm_error;
+
+ return SUCCESS;
+
+rx_frames_msg_error:
+ dbgf(DBGL_SYS, DBGT_WARN, "rcvd problematic message");
+
+rx_frames_frm_error:
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "rcvd problematic frame type %s last %s frm_size %d pos %d ",
+ frame_handler[t].name, frame_handler[pt].name, flength, frm_pos);
+
+ return FAILURE;
+}
+
+
+
+
+STATIC_FUNC
+int8_t send_udp_packet( unsigned char *upd_data, int32_t udp_len, struct sockaddr_in *dst, int32_t send_sock ) {
+
+ int status;
+
+ dbgf_all( DBGT_INFO, "len %d", udp_len );
+
+ if ( send_sock == 0 )
+ return 0;
+
+ /*
+ static struct iovec iov;
+ iov.iov_base = udp_data;
+ iov.iov_len = udp_data_len;
+
+ static struct msghdr m = { 0, sizeof( struct sockaddr_in ), &iov, 1, NULL, 0, 0 };
+ m.msg_name = dst;
+
+ status = sendmsg( send_sock, &m, 0 );
+ */
+
+ status = sendto( send_sock, upd_data, udp_len, 0, (struct sockaddr *)dst, sizeof(struct sockaddr_in) );
+
+ if ( status < 0 ) {
+
+ if ( errno == 1 ) {
+
+ dbg_mute( 60, DBGL_SYS, DBGT_ERR,
+ "can't send udp packet: %s. Does your firewall allow outgoing packets on port %i ?",
+ strerror(errno), ntohs(dst->sin_port));
+
+ } else {
+
+ dbg_mute( 60, DBGL_SYS, DBGT_ERR, "can't send udp packet via fd %d: %s", send_sock, strerror(errno));
+
+ }
+
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+void tx_packet( void *dev_node )
+{
+ static unsigned char tx_buff[MAX_UDPD_SIZE+1];
+ struct dev_node *dev = dev_node;
+ struct packet_header *packet_hdr = (struct packet_header *) tx_buff;
+ memset( packet_hdr, 0, sizeof( tx_buff ));
+ uint16_t packet_size = sizeof( struct packet_header );
+ IDM_T packet_full = NO;
+
+ assertion( -500204, dev );
+ assertion( -500205, dev->active );
+
+ //remove_task( tx_packet, dev );
+ register_task(aggreg_interval - (1 + rand_num(aggreg_interval / 10)), tx_packet, dev);
+
+ schedule_and_purge_ogm_aggregations(dev);
+
+ uint16_t type = 0; // the currently processed frame_type
+
+ while (type <= FRAME_TYPE_NOP) {
+
+ uint16_t length = sizeof (struct frame_header);
+ uint8_t flags = 0;
+
+ int creator_result;
+ struct pkt_frame_handler *fhdl = &frame_handler[type];
+ struct tx_task_node *ttn;
+ IDM_T frame_full = NO;
+
+ assertion(-500351, (!(fhdl->tx_frm_creator && fhdl->tx_msg_creator)));
+
+ if ((ttn = dev->my_tx_tasks[type])) {
+
+ assertion(-500422, (!fhdl->data_header_size));
+ assertion(-500424, (fhdl->tx_msg_creator));
+ assertion(-500441, (ttn->myIID4x == IID_RSVD_4YOU));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s type %d=%s %s",
+ dev->name, type, fhdl->name, "from dev->my_tx_tasks");
+
+ if (tx_task_obsolete(dev, type, ttn)) {
+
+ creator_result = FAILURE;
+
+ } else if (packet_full ||
+ (fhdl->fixed_msg_size &&
+ packet_size + length + ttn->frame_data_length_target > (uint16_t) max_udpd_size)
+ ) {
+
+ creator_result = max_udpd_size + 1;
+
+ } else {
+
+ creator_result = (*(fhdl->tx_msg_creator))
+ (ttn, &flags, (tx_buff + packet_size + length),
+ (max_udpd_size - (packet_size + length)));
+
+ }
+
+ if (creator_result > (max_udpd_size - (packet_size + length))) {
+
+ assertion(-500431,
+ (packet_size > sizeof ( struct packet_header) ||
+ length > sizeof (struct frame_header)));
+
+ packet_full = YES;
+
+ } else if (creator_result) {
+
+ if (creator_result > 0)
+ length += creator_result;
+
+ freed_tx_task_node(ttn, creator_result, NULL);
+
+ }
+ }
+
+ struct list_node *lprev = (struct list_node*) &(dev->tx_tasks_list[type]);
+ struct list_node *lpos, *ltmp;
+
+ list_for_each_safe(lpos, ltmp, &(dev->tx_tasks_list[type]))
+ {
+ ttn = list_entry(lpos, struct tx_task_node, list);
+
+ assertion(-500440, (ttn->frame_type == type));
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s type %d=%s %s",
+ dev->name, type, fhdl->name, "from dev->tx_tasks_list");
+
+ if (ttn->tx_timestamp == bmx_time) {
+
+ // just send! send again later;
+ creator_result = 0;
+
+ } else if (tx_task_obsolete(dev, type, ttn)) {
+
+ creator_result = FAILURE;
+
+ } else if (packet_full ||
+ (fhdl->fixed_msg_size &&
+ packet_size + length + ttn->frame_data_length_target > (uint16_t) max_udpd_size)
+ ) {
+
+ creator_result = max_udpd_size + 1;
+
+ } else if (fhdl->tx_frm_creator) {
+
+ creator_result = ((*(fhdl->tx_frm_creator))
+ (ttn, &flags, (tx_buff + packet_size + length),
+ (max_udpd_size - (packet_size + length))));
+
+ frame_full = YES;
+
+ } else {
+
+ assertion(-500425, (fhdl->tx_msg_creator));
+ assertion(-500426, (!fhdl->data_header_size)); // to be implemented...
+
+ creator_result = (*(fhdl->tx_msg_creator))
+ (ttn, &flags, (tx_buff + packet_size + length),
+ (max_udpd_size - (packet_size + length)));
+
+ }
+
+ if (creator_result > (max_udpd_size - (packet_size + length))) {
+
+ assertion(-500430,
+ (packet_size > sizeof ( struct packet_header) ||
+ length > sizeof (struct frame_header)));
+
+ packet_full = YES;
+ break;
+
+ } else if (creator_result) {
+
+ if (creator_result > 0)
+ length += creator_result;
+
+ if (freed_tx_task_node(ttn, creator_result, lprev) == NO)
+ lprev = lpos;
+
+ if (frame_full)
+ break;
+
+ continue;
+
+ } else {
+ lprev = lpos;
+ }
+ }
+
+
+ if (length > sizeof (struct frame_header)) {
+
+ struct frame_header *frame_hdr = (struct frame_header *) (tx_buff + packet_size);
+ packet_size += length;
+
+ frame_hdr->type = type;
+ frame_hdr->length = htons(length);
+ frame_hdr->flags |= flags;
+
+ dbgf(DBGL_ALL, DBGT_INFO, "send frame type %s size %d", fhdl->name, length);
+ }
+
+
+ if (packet_full || (type == FRAME_TYPE_NOP && packet_size > sizeof ( struct packet_header))) {
+
+ assertion(-500208, (packet_size <= max_udpd_size));
+ assertion(-500412, (packet_size >= sizeof ( struct packet_header)));
+
+ packet_hdr->bmx_version = COMPAT_VERSION;
+ packet_hdr->bmx_capabilities = 0;
+ packet_hdr->pkt_length = htons(packet_size);
+ packet_hdr->pkt_dev_sqn = htons(++(dev->packet_sqn));
+
+ send_udp_packet(tx_buff, packet_size, &dev->ip4_netwbrc_addr, dev->unicast_sock);
+
+ dbgf(DBGL_ALL, DBGT_INFO, "send packet size %d via dev %s", packet_size, dev->name);
+
+ packet_size = sizeof ( struct packet_header);
+ packet_full = NO;
+ }
+
+ if (type == FRAME_TYPE_NOP ||
+ !dev->tx_tasks_list[type].items ||
+ ((struct tx_task_node*) (list_get_last(&(dev->tx_tasks_list[type]))))->tx_timestamp == bmx_time) {
+
+ CHECK_INTEGRITY();
+
+ type++;
+ }
+ }
+}
+
+
+
+void schedule_my_hello_message( void* dev_node ) {
+
+ struct dev_node * dev = dev_node;
+
+ paranoia( -500206, !dev );
+ paranoia( -500207, !dev->active );
+
+ register_task( my_hello_interval, schedule_my_hello_message, dev );
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "%s", dev->name);
+
+ if (!LIST_EMPTY(&(dev->tx_tasks_list[FRAME_TYPE_HI40_ADVS]))) {
+ dbgf( DBGL_SYS, DBGT_ERR, " ");
+ }
+
+ schedule_tx_task( dev, NULL, FRAME_TYPE_HI40_ADVS, 0, 0, 0, 0 );
+}
+
+
+void schedule_my_originator_message( void* unused )
+{
+ my_orig_node.ogm_sqn_to_be_send += my_orig_node.path_metric_algo.sqn_steps; //ogm_sqn_steps;
+ my_orig_node.dhn->referred_timestamp = bmx_time;
+
+ register_task(my_ogm_interval, schedule_my_originator_message, NULL);
+
+ if (((uint32_t) (my_orig_node.ogm_sqn_to_be_send + 1 - my_orig_node.ogm_sqn_min)) < my_orig_node.ogm_sqn_range) {
+
+ ogm_aggreg_pending++;
+ dbgf(DBGL_CHANGES, DBGT_INFO, "ogm_sqn %d", my_orig_node.ogm_sqn_to_be_send);
+
+ } else {
+
+ update_my_description_adv();
+
+ }
+}
+
+
+
+
+void update_my_description_adv(void)
+{
+ struct description_hash dhash;
+ struct description *dsc = my_orig_node.desc0;
+
+ if ( terminating() )
+ return;
+
+ // put obligatory stuff:
+ memset(dsc, 0, MAX_PKT_MSG_SIZE);
+
+ memcpy(&dsc->id, &my_orig_node.id, sizeof(struct description_id));
+/*
+ dsc->id.rand.u32[0] = htonl(my_orig_node.id.rand.u32[0]);
+ dsc->id.rand.u32[1] = htonl(my_orig_node.id.rand.u32[1]);
+*/
+
+
+ my_orig_node.ogm_sqn_pq_bits = DEF_OGM0_PQ_BITS;
+// my_orig_node.ogm_sqn_mask = (MAX_SQN << my_orig_node.ogm_sqn_pq_bits);
+// my_orig_node.ogm_sqn_steps = (0x01 << my_orig_node.ogm_sqn_pq_bits);
+
+ // add some randomness to the ogm_sqn_range, that not all nodes invalidate at the same time:
+ uint16_t random_range = ((DEF_OGM0_SQN_RANGE - (DEF_OGM0_SQN_RANGE/5)) > MIN_OGM0_SQN_RANGE) ?
+ DEF_OGM0_SQN_RANGE - rand_num(DEF_OGM0_SQN_RANGE/5) : DEF_OGM0_SQN_RANGE + rand_num(DEF_OGM0_SQN_RANGE/5);
+
+ my_orig_node.ogm_sqn_range = ((random_range + my_orig_node.path_metric_algo.sqn_steps - 1) & my_orig_node.path_metric_algo.sqn_mask);
+
+ my_orig_node.ogm_sqn_min = ((my_orig_node.ogm_sqn_min + MAX_OGM0_SQN_RANGE + (0x01 << MAX_OGM0_PQ_BITS)) & my_orig_node.path_metric_algo.sqn_mask);
+
+ my_orig_node.ogm_sqn_aggregated = my_orig_node.ogm_sqn_min;
+ my_orig_node.ogm_sqn_to_be_send = my_orig_node.ogm_sqn_min + my_orig_node.path_metric_algo.sqn_steps - 1;
+
+
+ dsc->path_window_size = htons(my_orig_node.path_metric_algo.sqn_window);
+ dsc->path_lounge_size = htons(my_orig_node.path_metric_algo.sqn_lounge);
+
+
+ dsc->ttl_max = my_ttl;
+ dsc->path_hystere = my_path_hystere;
+
+ dsc->hop_penalty = my_hop_penalty;
+ dsc->late_penalty = my_late_penalty;
+ dsc->asym_weight = asym_weight;
+ dsc->sym_weight = sym_weight;
+
+
+ dsc->ogm_sqn_pq_bits = my_orig_node.ogm_sqn_pq_bits;
+ dsc->ogm_sqn_min = htons(my_orig_node.ogm_sqn_min);
+ dsc->ogm_sqn_range = htons(my_orig_node.ogm_sqn_range);
+
+ dsc->dsc_sqn = htons(++(my_orig_node.desc0_sqn));
+
+
+ dsc->path_ogi = htons(my_ogm_interval);
+
+
+ // add all tlv options:
+ my_desc0_tlv_len = 0;
+ uint8_t tlvt;
+ for ( tlvt=0; tlvt < BMX_DSC_TLV_ARRSZ; tlvt++) {
+
+ struct frame_header *tlv = (struct frame_header*) (((char*) dsc) + sizeof (struct description) + my_desc0_tlv_len);
+
+ uint16_t rsvd = my_desc0_tlv_len + sizeof (struct frame_header);
+
+ if (rsvd <= MAX_DESC0_TLV_SIZE && (description0_tlv_handler[tlvt].create_tlv)) {
+
+ uint16_t msgs_size = (*(description0_tlv_handler[tlvt].create_tlv))
+ (tlv->data, MAX_DESC0_TLV_SIZE - rsvd);
+
+ if ( msgs_size ) {
+
+ assertion(-500355, (description0_tlv_handler[tlvt].variable_msg_size ||
+ msgs_size % description0_tlv_handler[tlvt].min_msg_size == 0));
+
+ tlv->type = tlvt;
+ tlv->length = htons(sizeof (struct frame_header) + msgs_size);
+
+ my_desc0_tlv_len += sizeof (struct frame_header) + msgs_size;
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "added %s size %d",
+ description0_tlv_handler[tlvt].name, msgs_size);
+
+ }
+
+ } else {
+ cleanup_all( -500352 );
+ }
+ }
+
+ dsc->dsc_tlvs_len = htons(my_desc0_tlv_len);
+
+ dbgf(DBGL_CHANGES, DBGT_INFO, "added tlv total of %d ", my_desc0_tlv_len);
+
+ // calculate hash: like shown in CTaoCrypt Usage Reference:
+ ShaUpdate(&bmx_sha, (byte*)dsc, (sizeof (struct description) + my_desc0_tlv_len));
+ ShaFinal(&bmx_sha, (byte*) &dhash);
+
+ if ( my_orig_node.dhn ) {
+ my_orig_node.dhn->on = NULL;
+ invalidate_dhash_node( my_orig_node.dhn );
+ }
+
+ my_orig_node.dhn = create_dhash_node(&dhash, &my_orig_node);
+
+ myIID4me = my_orig_node.dhn->myIID4orig;
+
+ if (DEF_UNSOLICITED_DESCRIPTIONS) {
+ uint16_t desc_len = sizeof ( struct msg_description_adv) + my_desc0_tlv_len;
+ struct link_dev_node **lndev_arr = get_best_lndevs_by_criteria(NULL, my_orig_node.dhn);
+ int d;
+
+ for (d = 0; (lndev_arr[d]); d++)
+ schedule_tx_task(lndev_arr[d]->key.dev, lndev_arr[d], FRAME_TYPE_DSC0_ADVS, desc_len, 0, IID_RSVD_4YOU, 0);
+ }
+
+/*
+ remove_task(schedule_my_originator_message, NULL);
+ register_task(1, schedule_my_originator_message, NULL);
+*/
+
+
+}
+
+
+
+static struct opt_type msg_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ {ODI, 0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nMessage options:"}
+,
+ {ODI, 0, ARG_UDPD_SIZE, 0, 5, A_PS1, A_ADM, A_DYI, A_CFA, A_ANY, &max_udpd_size, MIN_UDPD_SIZE, MAX_UDPD_SIZE, DEF_UDPD_SIZE, 0,
+ ARG_VALUE_FORM, "set preferred udp-data size for send packets"}
+,
+ {ODI, 0, ARG_AGGREG_INTERVAL, 0, 5, A_PS1, A_ADM, A_DYI, A_CFA, A_ANY, &aggreg_interval, MIN_AGGREG_INTERVAL,MAX_AGGREG_INTERVAL,DEF_AGGREG_INTERVAL,0,
+ ARG_VALUE_FORM, "set aggregation interval (SHOULD be smaller than the half of your and others OGM interval)"}
+,
+ {ODI, 0, ARG_OGM_RESEND_ATTEMPTS, 0, 5, A_PS1, A_ADM, A_DYI, A_CFA, A_ANY, &ogm_resend_attempts,MIN_OGM_RESEND_ATTEMPTS,MAX_OGM_RESEND_ATTEMPTS,DEF_OGM_RESEND_ATTEMPTS,0,
+ ARG_VALUE_FORM, "set maximum resend attempts for ogm aggregations"}
+,
+ {ODI, 0, ARG_HELLO_INTERVAL, 'O',5, A_PS1, A_ADM, A_DYI, A_CFA, A_ANY, &my_hello_interval,MIN_HELLO_INTERVAL, MAX_HELLO_INTERVAL, DEF_HELLO_INTERVAL, 0,
+ ARG_VALUE_FORM, "set interval in ms with which new originator message (OGM) are send"}
+,
+ {ODI, 0, ARG_OGM_INTERVAL, 'o',5, A_PS1, A_ADM, A_DYI, A_CFA, A_ANY, &my_ogm_interval, MIN_OGM_INTERVAL, MAX_OGM_INTERVAL, DEF_OGM_INTERVAL, opt_update_description,
+ ARG_VALUE_FORM, "set interval in ms with which new originator message (OGM) are send"}
+
+};
+
+
+void init_msg( void )
+{
+
+ paranoia( -500347, ( sizeof(struct description_hash) != BMX_HASH0_LEN));
+
+ ogm_aggreg_sqn_max = rand_num(MAX_SQN);
+
+ register_options_array( msg_options, sizeof( msg_options ) );
+
+ InitSha(&bmx_sha);
+
+ register_task(rand_num(RAND_INIT_DELAY), schedule_my_originator_message, NULL);
+
+}
+
+void cleanup_msg( void )
+{
+ schedule_and_purge_ogm_aggregations(NULL /*purge_all*/);
+
+ debugFree(get_best_lndevs_by_criteria(NULL, NULL), -300218);
+
+ purge_cached_descriptions(YES);
+
+}
Added: trunk/bmx/msg.h
===================================================================
--- trunk/bmx/msg.h (rev 0)
+++ trunk/bmx/msg.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,357 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <stdint.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <linux/if.h>
+
+
+#define MIN_UDPD_SIZE 256 //(6+4+(22+8)+32)+184=72+56=128
+#define DEF_UDPD_SIZE 512
+#define MAX_UDPD_SIZE 1400
+#define ARG_UDPD_SIZE "udp_data_size"
+
+
+#define MIN_AGGREG_INTERVAL 35
+#define MAX_AGGREG_INTERVAL 4000
+#define DEF_AGGREG_INTERVAL 500
+#define ARG_AGGREG_INTERVAL "aggregation_interval"
+
+#define ARG_HELLO_INTERVAL "hello_interval"
+#define DEF_HELLO_INTERVAL DEF_OGM_AGGREG_INTERVAL
+#define MIN_HELLO_INTERVAL 50
+#define MAX_HELLO_INTERVAL 10000
+extern int32_t my_hello_interval;
+
+
+#define ARG_OGM_INTERVAL "ogm_interval"
+#define DEF_OGM_INTERVAL 2000
+#define MIN_OGM_INTERVAL 200
+#define MAX_OGM_INTERVAL 60000
+extern int32_t my_ogm_interval;
+
+
+#define DEF_TX_TS_TREE_SIZE 100
+#define DEF_TX_TS_TREE_PURGE_FK 5
+
+
+
+#define MIN_OGM_AGGREG_INTERVAL ( MIN_OGM_INTERVAL/10 )
+#define MAX_OGM_AGGREG_INTERVAL ( DEF_OGM_INTERVAL/2 )
+#define DEF_OGM_AGGREG_INTERVAL ( DEF_OGM_INTERVAL/5 )
+
+#define MAX_OGM_RESEND_INTERVAL (MAX_AGGREG_INTERVAL * 2)
+#define DEF_OGM_RESEND_INTERVAL ((DEF_AGGREG_INTERVAL * 2) / 3)
+
+#define MIN_OGM_RESEND_ATTEMPTS 0
+#define MAX_OGM_RESEND_ATTEMPTS 5
+#define DEF_OGM_RESEND_ATTEMPTS 3
+#define ARG_OGM_RESEND_ATTEMPTS "ogm_resend_attempts"
+
+#define MIN_NBDISC_RTQ (PROBE_RANGE / 8)
+#define MIN_OGM_ACK_RTQ (PROBE_RANGE / 4)
+
+
+
+
+//TODO: set REQ_TO to 1 (in a non-packet-loss testenvironment this may be set to 1000 for testing)
+#define DEF_TX_DESC0_REQ_TO 1000
+#define DEF_TX_DESC0_ADV_TO 500
+#define DEF_TX_DHASH0_REQ_TO 1000
+#define DEF_TX_DHASH0_ADV_TO 500
+
+#define MIN_DESC0_REFERRED_TO 10000
+#define MAX_DESC0_REFERRED_TO 100000
+#define DEF_DESC0_REFERRED_TO 10000
+
+#define MAX_PKT_MSG_SIZE (MAX_UDPD_SIZE - sizeof(struct packet_header) - sizeof(struct frame_header))
+
+#define MAX_DESC0_TLV_SIZE (MAX_PKT_MSG_SIZE - sizeof(struct msg_description_adv) )
+
+
+
+struct packet_header
+{
+ uint8_t bmx_version;
+ uint8_t bmx_capabilities;
+ uint16_t pkt_length; // the relevant data size in bytes (including the bmx_header)
+ uint16_t pkt_dev_sqn;
+ uint8_t pkt_data[]; // encapulating packet data tlvs
+} __attribute__((packed));
+
+
+#define FRAME_TYPE_RESERVED0 0
+#define FRAME_TYPE_RESERVED1 1
+#define FRAME_TYPE_HI40_ADVS 2 // most-simple BMX-NG hello (nb-discovery) advertisements
+#define FRAME_TYPE_HI40_REPS 3 // most-simple BMX-NG hello (nb-discovery) replies
+#define FRAME_TYPE_HI60_REPS 4 //
+#define FRAME_TYPE_RESERVED4 5 // BMX_FRM_CRT0_REQS
+#define FRAME_TYPE_RESERVED5 6 // BMX_FRM_CRT0_ADV
+#define FRAME_TYPE_DSC0_REQS 7 // ...
+#define FRAME_TYPE_DSC0_ADVS 8 // descriptions are send as individual advertisement frames
+#define FRAME_TYPE_DHS0_REQS 9 // Hash-for-description-of-OG-ID requests
+#define FRAME_TYPE_DHS0_ADVS 10 // Hash-for-description-of-OG-ID advertisements
+#define FRAME_TYPE_OGM0_ADVS 11 // most simple BMX-NG (type 0) OGM advertisements
+#define FRAME_TYPE_OGM0_ACKS 12 // most simple BMX-NG (type 0) OGM advertisements
+#define FRAME_TYPE_NOP 13
+#define FRAME_TYPE_ARRSZ 14
+#define FRAME_TYPE_MAX 0xFF
+
+
+/*
+ * dhash0_adv or description0_adv specific frame flag
+ * firstIsSender flag is usefull to accelerate neighbor (and neighIID) discovery process
+ */
+
+#define FRAME_FLAG_firstIsSender 0x01 // first message references transmitter of packet containing this message
+#define FRAME_FLAGS_MAX 255
+
+
+struct frame_header {
+ uint8_t type; // frame type
+ uint8_t flags; // frame-type specific (8-bit) value containing flags or other data (e.g. sqn, mark,..)
+ uint16_t length; // lenght of frame including frame_header and variable data field
+ uint8_t data[]; // frame-type specific data consisting of 0-1 data headers and 0-n data messages
+} __attribute__((packed));
+
+
+struct msg_hello_adv {
+ SQN_T hello_dev_sqn;
+} __attribute__((packed));
+/*
+ * reception trigger:
+ * - update_link_nodes()
+ * - msg_hellp40_reply[]
+ *
+ */
+
+struct msg_hello_reply {
+ IP4_T receiver_ip4;
+ SQN_T hello_dev_sqn;
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - update_link_nodes()
+ * - (if NOT link->neigh->dhash->orig) msg_dhash0_request[ ... orig_did = IID_RSVD_4YOU ]
+ *
+ */
+
+
+/*
+struct hdr_dhash_request {
+ IP4_T receiver_ip4;
+} __attribute__((packed));
+*/
+struct msg_dhash_request {
+ IP4_T receiver_ip4; // dest_llip4;
+ IID_T receiverIID4x; //(orig_did) IID_RSVD_4YOU to ask for neighbours' dhash0
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - msg_dhash0_adv[ ]
+ *
+ */
+
+
+struct msg_dhash_adv {
+ IID_T transmitterIID4x; //orig_sid
+ struct description_hash dhash;
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - (if description is known AND is neighbor) creation of link <-> neigh <-> dhash <-> orig <-> description
+ * - (else if description is known ) creation of dhash <-> orig <-> description
+ * - (else) msg_description0_request[]
+ */
+
+
+struct msg_description_request {
+ IP4_T receiver_ip4;
+ IID_T receiverIID4x; //(orig_did) IID_RSVD_4YOU to ask for neighbours' description0
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - msg_description0_adv[]
+ *
+ */
+
+
+
+struct description {
+ struct description_id id;
+
+ uint16_t dsc_tlvs_len;
+ SQN_T dsc_sqn;
+
+ SQN_T ogm_sqn_min;
+ SQN_T ogm_sqn_range;
+ uint8_t ogm_sqn_pq_bits;
+ uint8_t dsc_rsvd;
+
+ uint16_t path_ogi;
+
+ uint16_t path_window_size;
+ uint16_t path_lounge_size;
+
+ uint8_t path_hystere;
+ uint8_t ttl_max;
+
+ uint8_t hop_penalty;
+ uint8_t late_penalty;
+ uint8_t asym_weight;
+ uint8_t sym_weight;
+
+ uint16_t rsvd_u16;
+ uint32_t reserved[2]; //ensure traditional message size
+
+// uint8_t tlv_frames[];
+} __attribute__((packed));
+
+
+#define MSG_DESCRIPTION0_ADV_UNHASHED_SIZE 6
+#define MSG_DESCRIPTION0_ADV_HASHED_SIZE (sizeof( struct description_id) + (8 * 4))
+#define MSG_DESCRIPTION0_ADV_SIZE (MSG_DESCRIPTION0_ADV_UNHASHED_SIZE + MSG_DESCRIPTION0_ADV_HASHED_SIZE)
+
+struct msg_description_adv {
+
+ // the unhashed part:
+ IID_T transmitterIID4x; // orig_sid
+ uint8_t ttl;
+ uint8_t reserved0;
+ uint16_t reserved1;
+
+ // the hashed pard:
+ struct description desc;
+
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - creation of dhash_node <-> description_node
+ *
+ */
+
+#define MAX_OGMS_PER_AGGREG ( MIN((FRAME_FLAGS_MAX-1),((MIN_UDPD_SIZE - (sizeof(struct packet_header) + sizeof(struct frame_header))) / sizeof(struct msg_ogm_adv))) )
+#define MIN_OGMS_PER_AGGREG ( MAX_OGMS_PER_AGGREG / 8 )
+#define DEF_OGMS_PER_AGGREG ( MAX_OGMS_PER_AGGREG / 2 )
+
+//struct msg_ogm0_adv;
+
+struct msg_ogm_adv {
+ IID_T transmitterIID4x; //orig_sid
+ SQN_T orig_sqn;
+} __attribute__((packed));
+
+struct hdr_ogm_adv {
+ SQN_T aggregation_sqn;
+ struct msg_ogm_adv msg[];
+} __attribute__((packed));
+
+/*
+ * reception triggers:
+ * - (if link <-> neigh <-... is known and orig_sid is NOT known) msg_dhash0_request[ ... orig_did = orig_sid ]
+ * - else update_orig(orig_sid, orig_sqn)
+ */
+
+struct msg_ogm_ack {
+// IID_T transmitterIID4receiver;
+ IP4_T receiver_ip4;
+ SQN_T aggregation_sqn;
+} __attribute__((packed));
+/*
+ * reception triggers:
+ * - (if link <-> neigh <-... is known and orig_sid is NOT known) msg_dhash0_request[ ... orig_did = orig_sid ]
+ * - else update_orig(orig_sid, orig_sqn)
+ */
+
+
+
+
+
+#define BMX_DSC_TLV_GLIP4 0x00
+#define BMX_DSC_TLV_UHNA4 0x01
+#define BMX_DSC_TLV_ARRSZ 0x02
+#define BMX_DSC_TLV_MAX 0xFF
+
+#define TLVS_SUCCESS SUCCESS
+#define TLVS_FAILURE FAILURE
+#define TLVS_BLOCKED 1
+
+enum {
+ TLV_DEL_TEST_ADD = 0,
+ TLV_TEST = 1,
+ TLV_ADD = 2,
+ TLV_DONE = 3,
+ TLV_DEBUG = 4
+};
+
+
+struct description0_msg_ip4 {
+ IP4_T ip4;
+} __attribute__((packed));
+
+struct description0_msg_hna4 {
+ uint8_t prefix_len;
+ uint8_t reserved;
+ IP4_T ip4;
+ uint32_t metric;
+} __attribute__((packed));
+
+
+
+
+
+
+struct description_cache_node {
+ struct description_hash dhash;
+ uint32_t timestamp;
+ struct description *description;
+};
+
+#define DEF_DESC0_CACHE_SIZE 3
+#define DEF_DESC0_CACHE_TO 100000
+
+#define DEF_UNSOLICITED_DESCRIPTIONS YES
+
+
+extern char *tlv_op_str[];
+
+extern uint32_t ogm_aggreg_pending;
+
+/***********************************************************
+ The core frame/message structures and handlers
+************************************************************/
+
+void update_my_description_adv( void );
+
+void purge_tx_timestamp_tree(struct dev_node *dev, IDM_T purge_all);
+void purge_dev_tx_list( struct dev_node *dev );
+
+void tx_packet( void* dev_node );
+
+int rx_frames(struct packet_buff *pb, uint8_t* fdata, uint16_t fsize);
+
+void schedule_my_hello_message( void* dev_node );
+
+IDM_T process_description_tlvs(struct orig_node *on, struct description *dsc_new, IDM_T op, struct ctrl_node *cn);
+
+void init_msg( void );
+
+void cleanup_msg( void );
+
+
Added: trunk/bmx/plugin.c
===================================================================
--- trunk/bmx/plugin.c (rev 0)
+++ trunk/bmx/plugin.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,569 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <dlfcn.h>
+
+#include "bmx.h"
+#include "msg.h"
+#include "plugin.h"
+#include "schedule.h"
+#include "hna.h"
+
+LIST_SIMPEL(cb_fd_list, struct cb_fd_node, list);
+static LIST_SIMPEL(cb_packet_list, struct cb_packet_node, list);
+static LIST_SIMPEL(cb_ogm_list, struct cb_ogm_node, list);
+static LIST_SIMPEL(plugin_list, struct plugin_node, list);
+
+
+int32_t plugin_data_registries[PLUGIN_DATA_SIZE];
+
+
+void cb_plugin_hooks( void* data, int32_t cb_id ) {
+
+ struct list_node *list_pos;
+ struct plugin_node *pn, *prev_pn = NULL;
+
+ list_for_each( list_pos, &plugin_list ) {
+
+ pn = list_entry( list_pos, struct plugin_node, list );
+
+ if ( prev_pn && prev_pn->plugin_v2 && prev_pn->plugin_v2->cb_plugin_handler[cb_id] )
+ (*(prev_pn->plugin_v2->cb_plugin_handler[cb_id])) ( data );
+
+ prev_pn = pn;
+ }
+
+ if ( prev_pn && prev_pn->plugin_v2 && prev_pn->plugin_v2->cb_plugin_handler[cb_id] )
+ (*(prev_pn->plugin_v2->cb_plugin_handler[cb_id])) (data);
+
+}
+
+
+
+STATIC_FUNC
+int32_t configure_thread_hook( int32_t cb_type, void (*cb_handler) (void), int8_t del, struct list_node *cb_list ) {
+
+ struct list_node *list_pos, *tmp_pos, *prev_pos = cb_list;
+ struct cb_node *cbn;
+
+ if ( !cb_type || !cb_handler ) {
+ cleanup_all( -500143 );
+ }
+
+ list_for_each_safe( list_pos, tmp_pos, cb_list ) {
+
+ cbn = list_entry( list_pos, struct cb_node, list );
+
+ if ( cb_type == cbn->cb_type && cb_handler == cbn->cb_handler ) {
+
+ if ( del ) {
+
+ list_del_next(((struct list_head*) cb_list), prev_pos);
+ debugFree( cbn, -300069 );
+ return SUCCESS;
+
+ } else {
+ cleanup_all( -500144 );
+ //dbgf( DBGL_SYS, DBGT_ERR, "cb_hook for cb_type %d and cb_handler already registered", cb_type );
+ //return FAILURE;
+ }
+
+ } else {
+
+ prev_pos = &cbn->list;
+
+ }
+
+ }
+
+ if ( del ) {
+
+ cleanup_all( -500145 );
+ return FAILURE;
+
+ } else {
+
+ cbn = debugMalloc( sizeof( struct cb_node), -300027 );
+ memset( cbn, 0, sizeof( struct cb_node) );
+
+ cbn->cb_type = cb_type;
+ cbn->cb_handler = cb_handler;
+ list_add_tail(((struct list_head*) cb_list), &cbn->list);
+
+ return SUCCESS;
+ }
+}
+
+
+
+int32_t set_fd_hook( int32_t fd, void (*cb_fd_handler) (int32_t fd), int8_t del ) {
+
+ int32_t ret = configure_thread_hook( fd, (void (*) (void)) cb_fd_handler, del, (struct list_node*)&cb_fd_list );
+
+ change_selects();
+ return ret;
+}
+
+
+
+
+int32_t set_packet_hook( int32_t packet_type, void (*cb_packet_handler) (struct packet_buff *), int8_t del ) {
+
+ return configure_thread_hook( packet_type, (void (*) (void)) cb_packet_handler, del, (struct list_node*)&cb_packet_list );
+}
+
+
+//notify interested plugins of rcvd packet...
+// THIS MAY CRASH when one plugin unregisteres two packet_hooks while being called with cb_packet_handler()
+// TODO: find solution to prevent this ???
+uint32_t cb_packet_hooks( int32_t packet_type, struct packet_buff *pb ) {
+
+ struct list_node *list_pos;
+ struct cb_packet_node *cpn, *prev_cpn = NULL;
+ int calls = 0;
+
+ list_for_each( list_pos, &cb_packet_list ) {
+
+ cpn = list_entry( list_pos, struct cb_packet_node, list );
+
+ if ( prev_cpn && prev_cpn->packet_type == packet_type ) {
+
+ (*(prev_cpn->cb_packet_handler)) (pb);
+
+ calls++;
+ }
+
+ prev_cpn = cpn;
+
+ }
+
+ if ( prev_cpn && prev_cpn->packet_type == packet_type )
+ (*(prev_cpn->cb_packet_handler)) (pb);
+
+ return calls;
+}
+
+
+int32_t set_ogm_hook( int32_t (*cb_ogm_handler) ( struct packet_buff *, uint16_t oCtx, struct router_node *old_router ), int8_t del ) {
+
+ return configure_thread_hook( 1, (void (*) (void)) cb_ogm_handler, del, (struct list_node*)&cb_ogm_list );
+}
+
+
+int32_t cb_ogm_hooks( struct packet_buff *pb, uint16_t oCtx, struct router_node *old_router ) {
+
+
+ struct list_node *list_pos;
+ struct cb_ogm_node *con, *prev_con = NULL;
+
+ list_for_each( list_pos, &cb_ogm_list ) {
+
+ con = list_entry( list_pos, struct cb_ogm_node, list );
+
+ if ( prev_con ) {
+
+ if ( ((*(prev_con->cb_ogm_handler)) (pb, oCtx, old_router)) == CB_OGM_REJECT ) {
+
+ return CB_OGM_REJECT;
+ }
+
+ }
+
+ prev_con = con;
+
+ }
+
+ if ( prev_con ) {
+
+ if ( ((*(prev_con->cb_ogm_handler)) (pb, oCtx, old_router)) == FAILURE ) {
+
+ return CB_OGM_REJECT;
+ }
+
+ }
+
+ return CB_OGM_ACCEPT;
+}
+
+
+#ifdef BMX2_TODO
+int32_t set_snd_ext_hook( uint16_t ext_type, int32_t (*cb_snd_ext_handler) ( unsigned char* ext_buff ), int8_t del ) {
+
+ static uint8_t initialized = NO;
+
+ if ( !initialized ) {
+ memset( &snd_ext_hooks[0], 0, sizeof( snd_ext_hooks ) );
+ initialized = YES;
+ }
+
+ if ( ext_type > EXT_TYPE_MAX )
+ return FAILURE;
+
+ if ( del && snd_ext_hooks[ext_type].cb_snd_ext_handler == cb_snd_ext_handler ) {
+
+ snd_ext_hooks[ext_type].cb_snd_ext_handler = NULL;
+ return SUCCESS;
+
+ } else if ( !del && snd_ext_hooks[ext_type].cb_snd_ext_handler == NULL ) {
+
+ snd_ext_hooks[ext_type].cb_snd_ext_handler = cb_snd_ext_handler;
+ return SUCCESS;
+ }
+
+ return FAILURE;
+}
+
+int32_t cb_snd_ext_hook( uint16_t ext_type, unsigned char* ext_buff ) {
+
+ if ( snd_ext_hooks[ext_type].cb_snd_ext_handler )
+ return ((*(snd_ext_hooks[ext_type].cb_snd_ext_handler))( ext_buff ));
+
+ else
+ return SUCCESS;
+
+}
+
+
+#endif
+
+
+int32_t reg_plugin_data( uint8_t data_type ) {
+
+ static int initialized = NO;
+
+ if ( !initialized ) {
+ memset( plugin_data_registries, 0, sizeof( plugin_data_registries ) );
+ initialized=YES;
+ }
+
+ if ( on_the_fly || data_type >= PLUGIN_DATA_SIZE )
+ return FAILURE;
+
+ // do NOT return the incremented value!
+ plugin_data_registries[data_type]++;
+
+ return (plugin_data_registries[data_type] - 1);
+}
+
+#ifdef WITHUNUSED
+void **get_plugin_data( void *data, uint8_t data_type, int32_t registry ) {
+
+ if ( data_type >= PLUGIN_DATA_SIZE || registry > plugin_data_registries[data_type] ) {
+ cleanup_all( -500145 );
+ //dbgf( DBGL_SYS, DBGT_ERR, "requested to deliver data for unknown registry !");
+ //return NULL;
+ }
+
+ if ( data_type == PLUGIN_DATA_ORIG )
+ return &(((struct orig_node*)data)->plugin_data[registry]);
+
+ return NULL;
+}
+#endif
+
+STATIC_FUNC
+int is_plugin_active( void *plugin ) {
+
+ struct list_node *list_pos;
+
+ list_for_each( list_pos, &plugin_list ) {
+
+ if ( ((struct plugin_node *) (list_entry( list_pos, struct plugin_node, list )))->plugin == plugin )
+ return YES;
+
+ }
+
+ return NO;
+}
+
+STATIC_FUNC
+int activate_plugin( void *p, int32_t version, void *dlhandle, const char *dl_name ) {
+
+ if ( p == NULL || version != PLUGIN_VERSION_02 )
+ return FAILURE;
+
+ if ( is_plugin_active( p ) )
+ return FAILURE;
+
+
+ if ( version == PLUGIN_VERSION_02 ) {
+
+ struct plugin_v2 *pv1 = (struct plugin_v2*)p;
+
+ if (pv1->plugin_size != sizeof ( struct plugin_v2) ||
+ strcmp(pv1->plugin_bmx_version, SOURCE_VERSION) ||
+ (pv1->plugin_bmx_revision != REVISION_VERSION)) {
+
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "plugin with unexpected size %d != %lu, version %s != %s, revision %d != %d",
+ pv1->plugin_size, sizeof ( struct plugin_v2),
+ pv1->plugin_bmx_version, SOURCE_VERSION,
+ pv1->plugin_bmx_revision, REVISION_VERSION
+ );
+
+ return FAILURE;
+ }
+
+
+ if ( pv1->cb_init == NULL || ((*( pv1->cb_init )) ()) == FAILURE ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "could not init plugin");
+ return FAILURE;
+ }
+
+ struct plugin_node *pn = debugMalloc( sizeof( struct plugin_node), -300028);
+ memset( pn, 0, sizeof( struct plugin_node) );
+
+ pn->version = PLUGIN_VERSION_02;
+ pn->plugin_v2 = pv1;
+ pn->plugin = p;
+ pn->dlhandle = dlhandle;
+
+ list_add_tail(&plugin_list, &pn->list);
+
+ dbgf_all( DBGT_INFO, "%s SUCCESS", pn->plugin_v2->plugin_name );
+
+ if ( dl_name ) {
+ pn->dlname = debugMalloc( strlen(dl_name)+1, -300029 );
+ strcpy( pn->dlname, dl_name );
+ }
+
+ return SUCCESS;
+
+ }
+
+ return FAILURE;
+
+}
+
+STATIC_FUNC
+void deactivate_plugin( void *p ) {
+
+ if ( !is_plugin_active( p ) ) {
+ cleanup_all( -500190 );
+ }
+
+ struct list_node *list_pos, *tmp_pos, *prev_pos = (struct list_node*)&plugin_list;
+
+ list_for_each_safe( list_pos, tmp_pos, &plugin_list ) {
+
+ struct plugin_node *pn = list_entry( list_pos, struct plugin_node, list );
+
+ if ( pn->plugin == p ) {
+
+ list_del_next(&plugin_list, prev_pos);
+
+ if ( pn->version != PLUGIN_VERSION_02 )
+ cleanup_all( -500098 );
+
+ dbg( DBGL_CHANGES, DBGT_INFO, "deactivating plugin %s", pn->plugin_v2->plugin_name );
+
+ if ( pn->plugin_v2->cb_cleanup )
+ (*( pn->plugin_v2->cb_cleanup )) ();
+
+
+ if ( pn->dlname)
+ debugFree( pn->dlname, -300070);
+
+ debugFree( pn, -300071);
+
+ } else {
+
+ prev_pos = &pn->list;
+
+ }
+
+ }
+
+}
+
+STATIC_FUNC
+int8_t activate_dyn_plugin( const char* name ) {
+
+ struct plugin_v2* (*get_plugin_v2) ( void ) = NULL;
+
+ void *dlhandle;
+ struct plugin_v2 *pv1;
+ char dl_path[1000];
+
+ char *My_libs = getenv(BMX_ENV_LIB_PATH);
+
+ if ( !name )
+ return FAILURE;
+
+ // dl_open sigfaults on some systems without reason.
+ // removing the dl files from BMX_DEF_LIB_PATH is a way to prevent calling dl_open.
+ // Therefore we restrict dl search to BMX_DEF_LIB_PATH and BMX_ENV_LIB_PATH and ensure that dl_open
+ // is only called if a file with the requested dl name could be found.
+
+ if ( My_libs )
+ sprintf( dl_path, "%s/%s", My_libs, name );
+ else
+ sprintf( dl_path, "%s/%s", BMX_DEF_LIB_PATH, name );
+
+
+ dbgf_all( DBGT_INFO, "trying to load dl %s", dl_path );
+
+ int dl_tried = 0;
+
+ if ( check_file( dl_path, NO, YES ) == SUCCESS &&
+ (dl_tried = 1) && (dlhandle = dlopen( dl_path, RTLD_NOW )) )
+ {
+
+ dbgf_all( DBGT_INFO, "succesfully loaded dynamic library %s", dl_path );
+
+ } else {
+
+ dbg( dl_tried ? DBGL_SYS : DBGL_CHANGES, dl_tried ? DBGT_ERR : DBGT_WARN,
+ "failed loading dl %s %s (maybe incompatible binary/lib versions?)",
+ dl_path, dl_tried?dlerror():"" );
+
+ return FAILURE;
+
+ }
+
+ dbgf_all( DBGT_INFO, "survived dlopen()!" );
+
+
+ typedef struct plugin_v2* (*sdl_init_function_type) ( void );
+
+ union {
+ sdl_init_function_type func;
+ void * obj;
+ } alias;
+
+ alias.obj = dlsym( dlhandle, "get_plugin_v2");
+
+ if ( !( get_plugin_v2 = alias.func ) ) {
+ dbgf( DBGL_SYS, DBGT_ERR, "dlsym( %s ) failed: %s", name, dlerror() );
+ return FAILURE;
+ }
+
+
+ if ( !(pv1 = get_plugin_v2()) ) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "get_plugin_v2( %s ) failed", name );
+ return FAILURE;
+
+ }
+
+ if ( is_plugin_active( pv1 ) )
+ return SUCCESS;
+
+
+ if ( activate_plugin( pv1, PLUGIN_VERSION_02, dlhandle, name ) == FAILURE ) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "activate_plugin( %s ) failed", dl_path );
+ return FAILURE;
+
+ }
+
+ dbg( DBGL_CHANGES, DBGT_INFO,
+ "loading and activating %s dl %s succeeded",
+ My_libs ? "customized" : "default", dl_path );
+
+ return SUCCESS;
+}
+
+STATIC_FUNC
+int32_t opt_plugin ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ dbgf_all( DBGT_INFO, "%s %d", opt_cmd2str[cmd], _save );
+
+ char tmp_name[MAX_PATH_SIZE] = "";
+
+
+ if ( cmd == OPT_CHECK ) {
+
+ dbgf_all( DBGT_INFO, "about to load dl %s", patch->p_val );
+
+ if ( wordlen(patch->p_val)+1 >= MAX_PATH_SIZE || patch->p_val[0] == '/' )
+ return FAILURE;
+
+ wordCopy( tmp_name, patch->p_val );
+
+ if ( get_opt_parent_val( opt, tmp_name ) )
+ return SUCCESS;
+
+ if ( activate_dyn_plugin( tmp_name ) == FAILURE )
+ return FAILURE;
+
+ }
+
+ return SUCCESS;
+}
+
+static struct opt_type plugin_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ //order> config-file order to be loaded by config file, order < ARG_CONNECT oder to appera first in help text
+ {ODI,0,ARG_PLUGIN, 0, 2,A_PMN,A_ADM,A_INI,A_CFA,A_ANY, 0, 0, 0, 0, opt_plugin,
+ ARG_FILE_FORM, "load plugin. "ARG_FILE_FORM" must be in LD_LIBRARY_PATH or " BMX_ENV_LIB_PATH
+ "\n path (e.g. --plugin bmx_howto_plugin.so )\n"}
+};
+
+
+void init_plugin( void ) {
+
+
+// set_snd_ext_hook( 0, NULL, YES ); //ensure correct initialization of extension hooks
+ reg_plugin_data( PLUGIN_DATA_SIZE );// ensure correct initialization of plugin_data
+
+ struct plugin_v2 *pv1;
+
+ pv1=NULL;
+
+ // first try loading config plugin, if succesfull, continue loading optinal plugins depending on config
+ activate_dyn_plugin( BMX_LIB_UCI_CONFIG );
+
+ register_options_array( plugin_options, sizeof( plugin_options ) );
+
+
+ if ( (pv1 = hna_get_plugin_v2()) != NULL )
+ activate_plugin( pv1, PLUGIN_VERSION_02, NULL, NULL );
+
+
+#ifdef BMX2_TODO
+#ifndef NOVIS
+ if ( (pv1 = vis_get_plugin_v1()) != NULL )
+ activate_plugin( pv1, PLUGIN_VERSION_02, NULL, NULL );
+#endif
+
+#ifndef NOTUNNEL
+ if ( (pv1 = tun_get_plugin_v1()) != NULL )
+ activate_plugin( pv1, PLUGIN_VERSION_02, NULL, NULL );
+#endif
+
+#ifndef NOSRV
+ if ( (pv1 = srv_get_plugin_v1()) != NULL )
+ activate_plugin( pv1, PLUGIN_VERSION_02, NULL, NULL );
+#endif
+
+#endif
+}
+
+void cleanup_plugin( void ) {
+
+ while ( !LIST_EMPTY( &plugin_list ) )
+ deactivate_plugin( ((struct plugin_node*)(list_entry( (&plugin_list)->next, struct plugin_node, list)))->plugin );
+
+}
Added: trunk/bmx/plugin.h
===================================================================
--- trunk/bmx/plugin.h (rev 0)
+++ trunk/bmx/plugin.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+#define PLUGIN_VERSION_02 0x02
+#define BMX_LIB_UCI_CONFIG "bmx_uci_config.so"
+
+#define ARG_PLUGIN "plugin"
+
+extern struct list_head cb_fd_list;
+
+
+
+enum {
+ PLUGIN_CB_CONF,
+ PLUGIN_CB_ORIG_CREATE,
+ PLUGIN_CB_ORIG_FLUSH,
+ PLUGIN_CB_ORIG_DESTROY,
+ PLUGIN_CB_TERM,
+ PLUGIN_CB_SIZE
+};
+
+struct plugin_v2 {
+ uint32_t plugin_version;
+ uint32_t plugin_size;
+ uint32_t plugin_bmx_revision;
+ char *plugin_bmx_version;
+ char *plugin_name;
+ int32_t (*cb_init) ( void );
+ void (*cb_cleanup) ( void );
+
+ //some more advanced (rarely called) callbacks hooks
+ void (*cb_plugin_handler[PLUGIN_CB_SIZE]) (void*);
+
+ //some other attributes
+ uint8_t link_flags;
+
+};
+
+
+
+struct plugin_node {
+ struct list_node list;
+ int32_t version;
+ void *plugin;
+ struct plugin_v2 *plugin_v2;
+ void *dlhandle;
+ char *dlname;
+};
+
+
+struct cb_ogm_node {
+ struct list_node list;
+ int32_t cb_type;
+ int32_t (*cb_ogm_handler) ( struct packet_buff *, uint16_t oCtx, struct router_node *old_router );
+};
+
+
+struct cb_fd_node {
+ struct list_node list;
+ int32_t fd;
+ void (*cb_fd_handler) (int32_t fd);
+};
+
+
+struct cb_packet_node {
+ struct list_node list;
+ int32_t packet_type;
+ void (*cb_packet_handler) (struct packet_buff *);
+};
+
+
+struct cb_node {
+ struct list_node list;
+ int32_t cb_type;
+ void (*cb_handler) ( void );
+};
+
+
+
+struct cb_snd_ext {
+ int32_t (*cb_snd_ext_handler) ( unsigned char* ext_buff );
+};
+
+
+// cb_fd_handler is called when fd received data
+// called function may remove itself
+int32_t set_fd_hook( int32_t fd, void (*cb_fd_handler) (int32_t fd), int8_t del );
+
+int32_t set_packet_hook( int32_t packet_type, void (*cb_packet_handler) (struct packet_buff *), int8_t del );
+
+#define CB_OGM_ACCEPT 0
+#define CB_OGM_REJECT -1
+
+/*
+enum cb_ogm_t {
+ CB_OGM_ACCEPT,
+ CB_OGM_REJECT
+};
+*/
+
+// only one cb_ogm_hook per plugin
+int32_t set_ogm_hook( int32_t (*cb_ogm_handler) ( struct packet_buff *, uint16_t oCtx, struct router_node *old_router ), int8_t del );
+
+//int32_t set_snd_ext_hook( uint16_t ext_type, int32_t (*cb_snd_ext_handler) ( unsigned char* ext_buff ), int8_t del );
+
+
+
+//for registering data hooks:
+
+enum {
+ PLUGIN_DATA_ORIG,
+ PLUGIN_DATA_SIZE
+};
+
+extern int32_t plugin_data_registries[PLUGIN_DATA_SIZE];
+
+
+int32_t reg_plugin_data( uint8_t data_type );
+
+#ifdef WITHUNUSED
+void **get_plugin_data( void *data, uint8_t data_type, int32_t registry );
+#endif
+
+
+
+
+/**************************************
+ *to be used by bmx sceleton...
+ */
+void init_plugin( void );
+void cleanup_plugin( void );
+
+
+//void cb_config_hooks( void );
+void cb_plugin_hooks( void* data, int32_t cb_id );
+
+//returns number of called packet hooks for this packet_type
+uint32_t cb_packet_hooks( int32_t packet_type, struct packet_buff *pb );
+
+//return value FAILURE means that ogm or extension header is inacceptible and must be dropped !
+int32_t cb_ogm_hooks( struct packet_buff *pb, uint16_t oCtx, struct router_node *old_router );
+
+int32_t cb_snd_ext_hook( uint16_t ext_type, unsigned char* ext_buff );
+
+// use void change_selects( void ) to trigger cb_fd_handler()
+
+
Added: trunk/bmx/route.c
===================================================================
--- trunk/bmx/route.c (rev 0)
+++ trunk/bmx/route.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,2218 @@
+/*
+ * Copyright (C) 2006 BATMAN/BMX contributors:
+ * Marek Lindner, Thomas Lopatic, Axel Neumann
+ * 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 <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <arpa/inet.h> /* inet_ntop() */
+#include <errno.h>
+#include <unistd.h> /* close() */
+#include <linux/if.h> /* ifr_if, ifr_tun */
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+
+//from linux/wireless.h
+#define SIOCGIWNAME 0x8B01 /* get name == wireless protocol */
+
+#include "bmx.h"
+#include "msg.h"
+#include "plugin.h"
+#include "schedule.h"
+#include "route.h"
+
+
+
+
+int32_t base_port = DEF_BASE_PORT;
+
+
+#define ARG_RT_TABLE "rt_table_offset"
+#define DEF_RT_TABLE 64
+#define MIN_RT_TABLE 0
+#define MAX_RT_TABLE 254
+#define RT_TABLE_HOSTS_OFFS 0
+#define RT_TABLE_NETS_OFFS 1
+#define RT_TABLE_TUNS_OFFS 2
+#define RT_TABLE_MAX_OFFS 2
+static int32_t Rt_table = DEF_RT_TABLE;
+
+
+#define ARG_RT_PRIO "prio_rules_offset"
+#define MIN_RT_PRIO 3
+#define MAX_RT_PRIO 32765
+#define DEF_RT_PRIO 6400
+#define RT_PRIO_HOSTS (Rt_prio + 0)
+#define RT_PRIO_NETWORKS (Rt_prio + 1)
+#define RT_PRIO_TUNNEL (Rt_prio + 2)
+static int32_t Rt_prio = DEF_RT_PRIO;
+
+
+
+#define ARG_PRIO_RULES "prio_rules"
+#define ARG_THROW_RULES "throw_rules"
+#define ARG_NO_POLICY_RT "no_policy_routing"
+#define ARG_PEDANTIC_CLEANUP "pedantic_cleanup"
+
+#define DEF_PRIO_RULES 1
+static int32_t prio_rules = DEF_PRIO_RULES;
+
+#define DEF_THROW_RULES 1
+static int32_t throw_rules = DEF_THROW_RULES;
+
+#define DEF_PEDANT_CLNUP NO
+static int32_t Pedantic_cleanup = DEF_PEDANT_CLNUP;
+
+#define DEF_LO_RULE 1
+static int32_t Lo_rule = DEF_LO_RULE;
+
+static uint8_t touched_systen_config = NO;
+
+static int nl_sk = -1;
+static int flush_sk = -1;
+
+static int rt_sock = 0;
+
+
+static int32_t forward_orig=-1, if_rp_filter_all_orig=-1, if_rp_filter_default_orig=-1, if_send_redirects_all_orig=-1, if_send_redirects_default_orig=-1;
+
+static LIST_SIMPEL( rules_list, struct rules_node, list );
+static LIST_SIMPEL( routes_list, struct routes_node, list );
+static LIST_SIMPEL( throw_list, struct throw_node, list );
+
+uint8_t if_conf_soft_changed = NO; // temporary enabled to trigger changed interface configuration
+uint8_t if_conf_hard_changed = NO; // temporary enabled to trigger changed interface configuration
+
+
+int Mtu_min = MAX_MTU;
+
+
+
+static struct {
+ struct nlmsghdr nlh;
+ struct rtmsg rtm;
+ char buff[ 256 ];
+} req;
+
+STATIC_FUNC
+void add_rtattr(int rta_type, char *data, int data_len)
+{
+
+ struct rtattr *rta = (struct rtattr *)(((char *) &req) + NLMSG_ALIGN(req.nlh.nlmsg_len));
+
+ req.nlh.nlmsg_len = NLMSG_ALIGN( req.nlh.nlmsg_len ) + RTA_LENGTH(data_len);
+
+ paranoia( -50173, (NLMSG_ALIGN( req.nlh.nlmsg_len ) > sizeof( req )) );
+ // if this fails then double req buff size !!
+
+ rta->rta_type = rta_type;
+ rta->rta_len = RTA_LENGTH(data_len);
+ memcpy( RTA_DATA(rta), data, data_len );
+}
+
+STATIC_FUNC
+char *rt2str( uint8_t t ) {
+ if ( t == RTN_UNICAST )
+ return "RTN_UNICAST";
+ else if ( t == RTN_THROW )
+ return "RTN_THROW ";
+
+ return "RTN_ILLEGAL";
+}
+
+
+STATIC_FUNC
+char *trackt2str( uint8_t t ) {
+ if ( t == TRACK_NO )
+ return "TRACK_NO";
+ else if ( t == TRACK_STANDARD )
+ return "TRACK_STANDARD";
+ else if ( t == TRACK_MY_HNA )
+ return "TRACK_MY_HNA";
+ else if ( t == TRACK_MY_HNA )
+ return "TRACK_MY_NET";
+ else if ( t == TRACK_MY_NET )
+ return "TRACK_MY_HNA";
+ else if ( t == TRACK_OTHER_HOST )
+ return "TRACK_OTHER_HOST";
+ else if ( t == TRACK_OTHER_HNA )
+ return "TRACK_OTHER_HNA";
+ else if ( t == TRACK_TUNNEL )
+
+ return "TRACK_TUNNEL";
+
+ return "TRACK_ILLEGAL";
+}
+
+
+
+STATIC_FUNC
+int open_netlink_socket( void ) {
+
+ int sock = 0;
+ if ( ( sock = socket( AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE ) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't create netlink socket for routing table manipulation: %s",
+ strerror(errno) );
+
+ return -1;
+
+ }
+
+
+ if ( fcntl( sock, F_SETFL, O_NONBLOCK) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't set netlink socket nonblocking : (%s)", strerror(errno));
+ close(sock);
+ return -1;
+ }
+
+ return sock;
+
+}
+
+
+STATIC_FUNC
+int rt_macro_to_table( int rt_macro ) {
+
+ dbgf_all( DBGT_INFO, "rt_macro %d", rt_macro );
+
+ if ( rt_macro == RT_TABLE_HOSTS )
+ return Rt_table + RT_TABLE_HOSTS_OFFS;
+
+ else if ( rt_macro == RT_TABLE_NETWORKS )
+ return Rt_table + RT_TABLE_NETS_OFFS;
+
+ else if ( rt_macro == RT_TABLE_TUNNEL )
+ return Rt_table + RT_TABLE_TUNS_OFFS;
+
+ else if ( rt_macro > MAX_RT_TABLE )
+ cleanup_all( -500170 );
+
+ else if ( rt_macro >= 0 )
+ return rt_macro;
+
+ cleanup_all( -500171 );
+
+ return 0;
+
+}
+
+STATIC_FUNC
+int8_t track_rule_and_proceed(uint32_t network, int16_t mask, uint32_t prio, int16_t rt_table, char* iif,
+ int16_t rule_type, int8_t del, int8_t track_t)
+{
+
+ struct list_node *list_pos, *tmp_pos, *first_found_pos=NULL, *first_found_prev=NULL;
+ struct list_node *prev_pos = (struct list_node*)&rules_list;
+ struct rules_node *first_found_rn=NULL;
+ uint32_t found_rns=0;
+
+ paranoia( -500176, ( !del && track_t == TRACK_NO ) );
+
+
+ list_for_each_safe( list_pos, tmp_pos, &rules_list ) {
+
+ struct rules_node *tmp_rn = list_entry( list_pos, struct rules_node, list );
+
+ if ( tmp_rn->network == network &&
+ tmp_rn->netmask == mask &&
+ tmp_rn->rt_table == rt_table &&
+ tmp_rn->prio == prio &&
+ tmp_rn->iif == iif &&
+ tmp_rn->rta_type == rule_type )
+ {
+
+ // the kernel-ip-stack does not care about my track_t when adding the same rule twice
+ // but found_rns is evaluated for this
+ if ( !first_found_rn && (tmp_rn->track_t == track_t || track_t == TRACK_NO) ) {
+ first_found_rn = tmp_rn;
+ first_found_pos = list_pos;
+ first_found_prev = prev_pos;
+ }
+
+ found_rns++;
+
+ }
+
+ prev_pos = &tmp_rn->list;
+
+ }
+
+ if ( (track_t == TRACK_NO) ||
+ ( del && !first_found_rn ) ||
+ ( del && found_rns != 1 ) ||
+ ( !del && found_rns > 0 ) )
+ {
+
+ dbg( (track_t == TRACK_NO || (del && !first_found_rn)) ? DBGL_SYS : DBGL_CHANGES,
+ (track_t == TRACK_NO || (del && !first_found_rn)) ? DBGT_ERR : DBGT_INFO,
+ " %s rule from %s/%d table %d prio %d iif %s type %d "
+ "%s exists %d tims with at least %d exact match",
+ del?"del":"add", ipStr(network), mask, rt_table, prio, iif, rule_type,
+ trackt2str(track_t), found_rns, (first_found_rn?1:0) );
+ }
+
+ if ( track_t == TRACK_NO )
+ return YES;
+
+ if ( del ) {
+
+ if ( first_found_rn ) {
+
+ list_del_next(&rules_list, first_found_prev);
+ debugFree(first_found_rn, -300072);
+
+ if (found_rns > 1)
+ return NO;
+
+ } else {
+ return NO;
+ }
+
+ } else {
+
+ struct rules_node *tmp_rn = debugMalloc( sizeof( struct rules_node ), -300030 );
+ memset( tmp_rn, 0, sizeof( struct rules_node ) );
+
+ tmp_rn->network = network;
+ tmp_rn->netmask = mask;
+ tmp_rn->rt_table = rt_table;
+ tmp_rn->prio = prio;
+ tmp_rn->iif = iif;
+ tmp_rn->rta_type = rule_type;
+ tmp_rn->track_t = track_t;
+
+ list_add_tail(&rules_list, &tmp_rn->list);
+
+ if ( found_rns > 0 )
+ return NO;
+
+ }
+
+ return YES;
+}
+
+
+STATIC_FUNC
+void configure_rule( uint32_t network, int16_t mask, int16_t rt_table_macro, uint32_t prio, char* iif,
+ int16_t rta_type, int8_t del, int8_t track_t)
+{
+
+ char buf[4096], str1[16];
+ struct sockaddr_nl nladdr;
+ struct msghdr msg;
+ struct nlmsghdr *nh;
+ struct iovec iov;
+ memset(&iov, 0, sizeof (struct iovec));
+ iov.iov_base = buf;
+ iov.iov_len = sizeof (buf);
+
+ uint16_t rt_table = rt_macro_to_table(rt_table_macro);
+
+ inet_ntop( AF_INET, &network, str1, sizeof (str1) );
+
+ if (track_rule_and_proceed(network, mask, prio, rt_table, iif, rta_type, del, track_t) == NO)
+ return;
+
+
+ dbg( DBGL_CHANGES, DBGT_INFO, "%s rule from %s/%d table %d prio %d iif %s type %d",
+ del?"del":"add", str1, mask, rt_table, prio, iif, rta_type );
+
+
+ memset( &nladdr, 0, sizeof(struct sockaddr_nl) );
+ memset( &req, 0, sizeof(req) );
+ memset( &msg, 0, sizeof(struct msghdr) );
+
+ nladdr.nl_family = AF_NETLINK;
+
+ req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ req.nlh.nlmsg_pid = My_pid;
+
+ req.rtm.rtm_family = AF_INET;
+ req.rtm.rtm_table = rt_table;
+
+ dbgf_all( DBGT_INFO, "%s ip rule pref %d iif %s %d %s/%d lookup table %d",
+ (del?"del":"add"), prio, iif, rta_type, str1, mask, rt_table );
+
+
+ if ( del ) {
+
+ req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
+ req.nlh.nlmsg_type = RTM_DELRULE;
+
+ req.rtm.rtm_scope = RT_SCOPE_NOWHERE;
+
+ } else {
+
+ req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE | NLM_F_EXCL;
+ req.nlh.nlmsg_type = RTM_NEWRULE;
+
+ req.rtm.rtm_scope = RT_SCOPE_UNIVERSE;
+ req.rtm.rtm_protocol = RTPROT_STATIC;
+ req.rtm.rtm_type = RTN_UNICAST;
+
+ }
+
+
+ if (rta_type == RTA_DST) {
+
+ req.rtm.rtm_dst_len = mask;
+ add_rtattr( rta_type, (char*)&network, sizeof(network) );
+
+ } else if ( rta_type == RTA_SRC ) {
+
+ req.rtm.rtm_src_len = mask;
+ add_rtattr( rta_type, (char*)&network, sizeof(network) );
+ }
+
+
+ if ( iif )
+ add_rtattr( RTA_IIF, iif, strlen(iif)+1 );
+
+
+ if ( prio )
+ add_rtattr( RTA_PRIORITY, (char*)&prio, sizeof(prio) );
+
+
+ if ( sendto( nl_sk, &req, req.nlh.nlmsg_len, 0, (struct sockaddr *)&nladdr, sizeof(struct sockaddr_nl) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "can't send message to kernel via netlink socket for routing rule manipulation: %s",
+ strerror(errno) );
+ return;
+
+ }
+
+
+ while ( 1 ) {
+
+ msg.msg_name = (void *)&nladdr;
+ msg.msg_namelen = sizeof(nladdr);
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+ msg.msg_flags = 0;
+
+ int32_t len = recvmsg( nl_sk, &msg, 0 );
+
+
+ if ( len < 0 ) {
+
+ if ( errno == EINTR ) {
+ dbgf( DBGL_SYS, DBGT_WARN, "(EINTR) %s", strerror(errno) );
+ continue;
+ }
+
+ if ( errno == EWOULDBLOCK || errno == EAGAIN ) {
+ //dbgf( DBGL_SYS, DBGT_WARN, "(EWOULDBLOCK || EAGAIN) %s", strerror(errno) );
+ break;
+ }
+
+ dbgf( DBGL_SYS, DBGT_ERR, "%s", strerror(errno) );
+
+ continue;
+
+ }
+
+ if ( len == 0 ) {
+ dbgf( DBGL_SYS, DBGT_ERR, "netlink EOF" );
+ }
+
+ nh = (struct nlmsghdr *)buf;
+
+ while ( NLMSG_OK(nh, (uint32_t)len) ) {
+
+ if ( nh->nlmsg_type == NLMSG_DONE )
+ return;
+
+ if ( ( nh->nlmsg_type == NLMSG_ERROR ) && ( ((struct nlmsgerr*)NLMSG_DATA(nh))->error != 0 ) ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "can't %s rule %s %s/%i iif %s table %d, prio %d: %s "
+ "(if busy: Help me! Howto avoid this ERROR message?)",
+ del ? "delete" : "add",
+ ( rta_type == RTA_DST ? "to" :
+ ( rta_type == RTA_SRC ? "from" :
+ ( rta_type == RTA_IIF ? "iif" : "???") ) ),
+ str1, mask, iif, rt_table, prio,
+ strerror(-((struct nlmsgerr*)NLMSG_DATA(nh))->error) );
+ }
+
+ nh = NLMSG_NEXT( nh, len );
+
+ }
+ }
+}
+
+STATIC_FUNC
+void flush_tracked_rules( int8_t track_type ) {
+
+ dbgf_all( DBGT_INFO, "%s", trackt2str(track_type) );
+
+ struct list_node *list_pos;
+ struct rules_node *rn, *p_rn=NULL;
+
+
+ list_for_each( list_pos, &rules_list ) {
+
+ rn = list_entry( list_pos, struct rules_node, list );
+
+ if ( p_rn )
+ configure_rule( p_rn->network, p_rn->netmask,
+ p_rn->rt_table, p_rn->prio, p_rn->iif, p_rn->rta_type, DEL, p_rn->track_t );
+
+ if ( track_type == rn->track_t || track_type == TRACK_NO )
+ p_rn = rn;
+ else
+ p_rn = NULL;
+
+ }
+
+ if ( p_rn )
+ configure_rule( p_rn->network, p_rn->netmask,
+ p_rn->rt_table, p_rn->prio, p_rn->iif, p_rn->rta_type, DEL, p_rn->track_t );
+
+}
+
+static void flush_tracked_routes( int8_t track_type ) {
+
+ dbgf_all( DBGT_INFO, "%s", trackt2str(track_type) );
+
+ struct list_node *list_pos;
+ struct routes_node *rn, *p_rn=NULL;
+
+
+ list_for_each( list_pos, &routes_list ) {
+
+ rn = list_entry( list_pos, struct routes_node, list );
+
+ if ( p_rn )
+ configure_route( p_rn->dest, p_rn->netmask, p_rn->metric, 0, 0, 0, 0,
+ p_rn->rt_table, p_rn->rta_type, DEL, p_rn->track_t );
+
+ if ( track_type == rn->track_t || track_type == TRACK_NO )
+ p_rn = rn;
+ else
+ p_rn = NULL;
+
+ }
+
+ if ( p_rn )
+ configure_route( p_rn->dest, p_rn->netmask, p_rn->metric, 0, 0, 0, 0,
+ p_rn->rt_table, p_rn->rta_type, DEL, p_rn->track_t );
+
+}
+
+static void flush_routes_rules( int8_t is_rule ) {
+
+ dbgf_all( DBGT_INFO, "is_rule %d", is_rule);
+
+ size_t len;
+ int rtl;
+ char buf[8192];
+ struct sockaddr_nl nladdr;
+ struct msghdr msg;
+ struct nlmsghdr *nh;
+ struct rtmsg *rtm;
+ struct {
+ struct nlmsghdr nlh;
+ struct rtmsg rtm;
+ } req;
+ struct rtattr *rtap;
+
+ struct iovec iov;
+
+ memset(&iov, 0, sizeof (struct iovec));
+ iov.iov_base = buf;
+ iov.iov_len = sizeof (buf);
+
+ memset( &nladdr, 0, sizeof(struct sockaddr_nl) );
+ memset( &req, 0, sizeof(req) );
+
+ nladdr.nl_family = AF_NETLINK;
+
+ req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ req.nlh.nlmsg_pid = My_pid;
+ req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req.nlh.nlmsg_type = ( is_rule ? RTM_GETRULE : RTM_GETROUTE );
+
+ req.rtm.rtm_family = AF_INET;
+ req.rtm.rtm_scope = RTN_UNICAST;
+
+ if ( sendto( flush_sk, &req, req.nlh.nlmsg_len, 0,
+ (struct sockaddr *)&nladdr, sizeof(struct sockaddr_nl) ) < 0 )
+ {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "can't send message to kernel via netlink socket for flushing the routing table: %s",
+ strerror(errno) );
+
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+ uint8_t nlm_f_multi = NO;
+
+ do {
+ memset(&msg, 0, sizeof(struct msghdr));
+ memset(&nladdr, 0, sizeof(struct sockaddr_nl));
+
+ nladdr.nl_family = AF_NETLINK;
+
+ msg.msg_name = (void *) & nladdr;
+ msg.msg_namelen = sizeof(nladdr);
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = NULL;
+
+ len = recvmsg(flush_sk, &msg, 0);
+ nh = (struct nlmsghdr *) buf;
+
+ dbgf_all(DBGT_INFO, "searching: %s NLMSG_OK: %d len: %zd",
+ is_rule ? "rules" : "routes", NLMSG_OK(nh, len), len);
+
+
+ while (NLMSG_OK(nh, len)) {
+
+ if ( nh->nlmsg_flags & NLM_F_MULTI )
+ nlm_f_multi = YES;
+
+ if (nh->nlmsg_type == NLMSG_DONE) {
+ dbgf_all( DBGT_INFO, "found NLMSG_DONE");
+ break;
+ }
+
+ if ((nh->nlmsg_type == NLMSG_ERROR) && (((struct nlmsgerr*) NLMSG_DATA(nh))->error != 0)) {
+
+ dbg(DBGL_SYS, DBGT_ERR, "can't flush %s: %s",
+ (is_rule ? "routing rules" : "routing table"),
+ strerror(-((struct nlmsgerr*) NLMSG_DATA(nh))->error));
+
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+ rtm = (struct rtmsg *) NLMSG_DATA(nh);
+ rtap = (struct rtattr *) RTM_RTA(rtm);
+ rtl = RTM_PAYLOAD(nh);
+
+ nh = NLMSG_NEXT(nh, len);
+
+ if ( /* rtm->rtm_table == 0 || */
+ rtm->rtm_table == Rt_table + RT_TABLE_NETS_OFFS ||
+ rtm->rtm_table == Rt_table + RT_TABLE_HOSTS_OFFS ||
+ rtm->rtm_table == Rt_table + RT_TABLE_TUNS_OFFS ) {
+
+ int8_t rule_type = RTA_UNSPEC;
+ uint32_t dest = 0;
+ uint32_t router = 0;
+ uint16_t mask = 0;
+ int32_t oif = 0;
+ uint32_t prio = 0;
+ char *iif = NULL;
+
+ while (RTA_OK(rtap, rtl)) {
+
+ dbgf_all( DBGT_INFO, "found rtm_table %d, rta_type %d rta_len %d",
+ rtm->rtm_table, rtap->rta_type, rtap->rta_len);
+
+
+ switch (rtap->rta_type) {
+
+ case RTA_DST:
+ dest = *((int32_t *) RTA_DATA(rtap));
+ mask = rtm->rtm_dst_len;
+ rule_type = RTA_DST;
+ break;
+
+ case RTA_SRC:
+ dest = *((int32_t *) RTA_DATA(rtap));
+ mask = rtm->rtm_src_len;
+ rule_type = RTA_SRC;
+ break;
+
+ case RTA_GATEWAY:
+ router = *((int32_t *) RTA_DATA(rtap));
+ break;
+
+ case RTA_OIF:
+ oif = *((int32_t *) RTA_DATA(rtap));
+ break;
+
+ case RTA_PRIORITY:
+ prio = *((uint32_t *) RTA_DATA(rtap));
+ break;
+
+ case RTA_IIF:
+ iif = ((char *) RTA_DATA(rtap));
+ break;
+
+ case 15: // FIXME: RTA_TABLE is not always available - not needed but avoid warning
+ break;
+
+ case RTA_PREFSRC: // rta_type 7 - not needed but avoid warning
+ break;
+
+ default:
+ dbg(DBGL_SYS, DBGT_ERR, "unknown rta type: %i", rtap->rta_type);
+ break;
+
+ }
+
+ rtap = RTA_NEXT(rtap, rtl);
+
+ }
+
+
+ if (is_rule) {
+
+ configure_rule( dest, mask, rtm->rtm_table, prio, iif, rule_type, DEL, TRACK_NO);
+
+
+ dbg(DBGL_SYS, DBGT_WARN, "flushing orphan rule type %d dest? %s/%d table %d prio %d",
+ rule_type, ipStr(dest), mask , rtm->rtm_table, prio);
+
+ } else {
+
+ configure_route(dest, mask, prio, router, 0, oif, "unknown", rtm->rtm_table, rtm->rtm_type, DEL, TRACK_NO);
+
+ dbg(DBGL_SYS, DBGT_WARN, "flushing orphan route to %s via %s type %d table %d",
+ ipStr(dest), ipStr(router), rtm->rtm_type, rtm->rtm_table);
+ }
+ }
+ }
+
+ } while ( !( nlm_f_multi == NO || ( ( NLMSG_OK(nh, len) && (nh->nlmsg_type == NLMSG_DONE) ) ) ) );
+
+}
+
+static void check_proc_sys( char *file, int32_t desired, int32_t *backup ) {
+
+ FILE *f;
+ int32_t state = 0;
+ char filename[MAX_PATH_SIZE];
+ int trash;
+
+
+ sprintf( filename, "/proc/sys/%s", file );
+
+ if((f = fopen(filename, "r" )) == NULL) {
+
+ dbgf( DBGL_SYS, DBGT_ERR, "can't open %s for reading! retry later..", filename );
+
+ if ( backup )
+ cleanup_all( CLEANUP_FAILURE );
+
+ return;
+ }
+
+ trash=fscanf(f, "%d", &state);
+ fclose(f);
+
+ if ( backup )
+ *backup = state;
+
+ // other routing protocols are probably not able to handle this therefore
+ // it is probably better to leave the routing configuration operational as it is!
+ if ( !backup && !Pedantic_cleanup && state != desired ) {
+
+ dbg_mute( 50, DBGL_SYS, DBGT_INFO,
+ "NOT restoring %s to NOT mess up other routing protocols. "
+ "Use --%s=1 to enforce proper cleanup",
+ file, ARG_PEDANTIC_CLEANUP );
+
+ return;
+ }
+
+
+ if ( state != desired ) {
+
+ touched_systen_config = YES;
+
+ dbg( DBGL_SYS, DBGT_INFO, "changing %s from %d to %d", filename, state, desired );
+
+ if((f = fopen(filename, "w" )) == NULL) {
+
+ dbgf( DBGL_SYS, DBGT_ERR,
+ "can't open %s for writing! retry later...", filename );
+ return;
+ }
+
+ fprintf(f, "%d", desired?1:0 );
+ fclose(f);
+
+ }
+}
+
+
+static void restore_kernel_config ( struct dev_node *dev_node ) {
+
+ if ( !touched_systen_config )
+ return;
+
+
+ if ( dev_node ) {
+
+ char filename[100];
+
+ if (dev_node->rp_filter_orig > -1) {
+ sprintf( filename, "net/ipv4/conf/%s/rp_filter", dev_node->name_phy);
+ check_proc_sys( filename, dev_node->rp_filter_orig, NULL );
+ }
+
+ dev_node->rp_filter_orig = -1;
+
+
+ if (dev_node->send_redirects_orig > -1) {
+ sprintf( filename, "net/ipv4/conf/%s/send_redirects", dev_node->name_phy);
+ check_proc_sys( filename, dev_node->send_redirects_orig, NULL );
+ }
+
+ dev_node->send_redirects_orig = -1;
+
+ } else {
+
+ if( if_rp_filter_all_orig != -1 )
+ check_proc_sys( "net/ipv4/conf/all/rp_filter", if_rp_filter_all_orig, NULL );
+
+ if_rp_filter_all_orig = -1;
+
+ if( if_rp_filter_default_orig != -1 )
+ check_proc_sys( "net/ipv4/conf/default/rp_filter", if_rp_filter_default_orig, NULL );
+
+ if_rp_filter_default_orig = -1;
+
+ if( if_send_redirects_all_orig != -1 )
+ check_proc_sys( "net/ipv4/conf/all/send_redirects", if_send_redirects_all_orig, NULL );
+
+ if_send_redirects_all_orig = -1;
+
+ if( if_send_redirects_default_orig != -1 )
+ check_proc_sys( "net/ipv4/conf/default/send_redirects", if_send_redirects_default_orig, NULL );
+
+ if_send_redirects_default_orig = -1;
+
+ if( forward_orig != -1 )
+ check_proc_sys( "net/ipv4/ip_forward", forward_orig, NULL );
+
+ forward_orig = -1;
+
+ }
+
+}
+
+
+static int8_t get_if_req( char* dev_name, struct ifreq *int_req, int siocgi_req ) {
+
+ memset( int_req, 0, sizeof (struct ifreq) );
+ strncpy( int_req->ifr_name, dev_name, IFNAMSIZ - 1 );
+
+ if ( ioctl( rt_sock, siocgi_req, int_req ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't get SIOCGI %d of interface %s: %s", siocgi_req, dev_name, strerror(errno) );
+ return FAILURE;
+ }
+
+ return SUCCESS;
+
+}
+
+static int8_t dev_validate( uint8_t set, struct dev_node *bif, char* dev_name, uint8_t reduced ) {
+
+ struct ifreq int_req;
+
+
+ if ( get_if_req( dev_name, &int_req, SIOCGIFADDR ) == FAILURE )
+ goto if_validate_failure;
+
+ if ( set ) {
+
+ bif->ip4_addr = ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr;
+ addr_to_str( bif->ip4_addr, bif->ip4_str );
+
+ } else if ( bif->ip4_addr != ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "IP address of %s: changed from %s to %s !",
+ dev_name, ipStr(bif->ip4_addr),
+ ipStr(((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr) );
+ goto if_validate_failure;
+ }
+
+ if ( !bif->ip4_addr ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "invalid IP address: %s %s", dev_name, ipStr(0));
+ goto if_validate_failure;
+ }
+
+
+ if ( get_if_req( dev_name, &int_req, SIOCGIFNETMASK ) == FAILURE )
+ goto if_validate_failure;
+
+ if ( set ) {
+
+ bif->ip4_netaddr = ( ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr & bif->ip4_addr );
+
+ } else if ( bif->ip4_netaddr != ( ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr & bif->ip4_addr ) ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "Net address of interface %s changed", dev_name );
+ goto if_validate_failure;
+ }
+
+ if ( set ) {
+
+ bif->ip4_netmask = ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr;
+ bif->ip4_prefix_length = bits_count( bif->ip4_netmask );
+
+ } else if ( bif->ip4_netmask != ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "Prefix length of interface %s changed from %d to %d",
+ dev_name, bif->ip4_prefix_length,
+ bits_count( ((struct sockaddr_in *)&int_req.ifr_addr)->sin_addr.s_addr ) );
+ goto if_validate_failure;
+ }
+
+ if ( !bif->ip4_prefix_length ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "Prefix length of IF %s must be > 0", dev_name );
+ goto if_validate_failure;
+ }
+
+
+ if ( reduced )
+ return SUCCESS;
+
+
+ if ( get_if_req( dev_name, &int_req, SIOCGIFINDEX ) == FAILURE )
+ goto if_validate_failure;
+
+ if ( set ) {
+
+ bif->index = int_req.ifr_ifindex;
+
+ } else if ( bif->index != int_req.ifr_ifindex ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "Interface index of %s %s: changed from %d to %d !",
+ dev_name, ipStr(bif->ip4_addr),
+ bif->index, int_req.ifr_ifindex );
+
+ }
+
+
+
+ if ( get_if_req( dev_name, &int_req, SIOCGIFBRDADDR ) == FAILURE )
+ goto if_validate_failure;
+
+ if ( set ) {
+
+ bif->ip4_broad = ((struct sockaddr_in *)&int_req.ifr_broadaddr)->sin_addr.s_addr;
+
+ } else if ( bif->ip4_broad != ((struct sockaddr_in *)&int_req.ifr_broadaddr)->sin_addr.s_addr ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "Broadcast address of %s changed", dev_name );
+ goto if_validate_failure;
+ }
+
+ if ( !bif->ip4_broad && bif->linklayer != VAL_DEV_LL_LO) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "invalid broadcast address: %s %s", dev_name, ipStr(0) );
+ goto if_validate_failure;
+ }
+
+
+
+
+ if ( get_if_req( dev_name, &int_req, SIOCGIFMTU ) == FAILURE )
+ goto if_validate_failure;
+
+ if ( set ) {
+
+ bif->ip4_mtu = int_req.ifr_mtu;
+
+ } else if ( bif->ip4_mtu != int_req.ifr_mtu ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, "MTU of interface %s changed from %d to %d",
+ dev_name, bif->ip4_mtu, int_req.ifr_mtu );
+ goto if_validate_failure;
+ }
+
+
+ return SUCCESS;
+
+if_validate_failure:
+
+ bif->ip4_addr = 0;
+ addr_to_str( 0, bif->ip4_str );
+ return FAILURE;
+}
+
+
+
+static char *get_ip4conf_buffer ( struct ifconf *ifc ) {
+
+ /* use netlink, netdevice and rtnetlink (7)
+ * to resolve ipv6 addresses. SIOCGIFCONF will only resolv ipv4 addresses !!!
+ */
+
+ char *buf;
+
+ int32_t len = 10 * sizeof(struct ifreq); /* initial buffer size guess (10 interfaces) */
+
+ while ( 1 ) {
+
+ buf = debugMalloc( len, -300031 );
+ memset( buf, 0, len);
+ memset( ifc, 0, sizeof( struct ifconf ));
+
+ ifc->ifc_len = len;
+ ifc->ifc_buf = buf;
+
+ if ( ioctl( rt_sock, SIOCGIFCONF, ifc ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't add interface rules (SIOCGIFCONF): %s", strerror(errno) );
+ //close( tmp_fd );
+ debugFree( buf, -300073);
+ return NULL;
+
+ } else {
+
+ if ( ifc->ifc_len < len )
+ break;
+
+ }
+
+ len += 10 * sizeof(struct ifreq);
+ debugFree( buf, -300074 );
+
+ }
+
+ return buf;
+}
+
+
+static int dev_up(char *name)
+{
+ struct ifreq int_req;
+
+ memset(&int_req, 0, sizeof (struct ifreq));
+ strncpy(int_req.ifr_name, name, IFNAMSIZ-1);
+
+ if (ioctl(rt_sock, SIOCGIFFLAGS, &int_req) < 0)
+ return 0;
+
+ if (!(int_req.ifr_flags & IFF_UP))
+ return 0;
+
+ if (ioctl(rt_sock, SIOCGIFADDR, &int_req) < 0)
+ return 0;
+
+ return 1;
+
+}
+
+
+
+
+static void dev_reconfigure_soft( struct dev_node *bif) {
+
+ if ( !bif->active ) {
+
+ dbg( DBGL_SYS, DBGT_INFO,
+ "skipping invalid IF %s ", bif->name );
+
+ } else if ( bif->linklayer == VAL_DEV_LL_LO ) {
+
+ dbg( DBGL_SYS, DBGT_INFO,
+ "enabled loopback %s %s %s/%d brc %s",
+ ARG_DEV, bif->name, ipStr(bif->ip4_addr), bif->ip4_prefix_length, ipStr(bif->ip4_broad) );
+
+ } else if ( bif->linklayer == VAL_DEV_LL_WLAN ) {
+
+ dbg( DBGL_SYS, DBGT_INFO,
+ "enabled wireless %s %s %s/%d brc %s (use %s /l=%d to optimize for ethernet)",
+ ARG_DEV, bif->name, ipStr(bif->ip4_addr), bif->ip4_prefix_length, ipStr(bif->ip4_broad), bif->name, VAL_DEV_LL_LAN );
+
+ bif->send_clones = wl_clones;
+
+ } else {
+
+ dbg( DBGL_SYS, DBGT_INFO,
+ "enabled ethernet %s %s %s/%d brc %s (use %s /l=%d to optimize for wireless)",
+ ARG_DEV, bif->name, ipStr(bif->ip4_addr), bif->ip4_prefix_length, ipStr(bif->ip4_broad), bif->name, VAL_DEV_LL_WLAN );
+
+ bif->send_clones = DEF_LAN_CLONES;
+
+ }
+
+
+ if ( bif == primary_if )
+ bif->announce = YES;
+ else
+ bif->announce = DEF_DEV_ANNOUNCE;
+
+
+ bif->antenna_diversity = 1;
+
+ if ( bif->send_clones_conf != -1 )
+ bif->send_clones = bif->send_clones_conf;
+
+ if ( bif->antenna_diversity_conf != -1 )
+ bif->antenna_diversity = bif->antenna_diversity_conf;
+
+ if ( bif->announce_conf != -1 )
+ bif->announce = bif->announce_conf;
+
+ bif->link_activity_timestamp = bmx_time;
+ bif->next_powersave_hardbeat = bmx_time;
+
+ bif->soft_conf_changed = NO;
+
+ update_my_description_adv();
+
+}
+
+static int8_t bind_to_iface( int32_t sock, char *dev ) {
+
+ errno=0;
+
+ if ( setsockopt( sock, SOL_SOCKET, SO_BINDTODEVICE, dev, strlen( dev ) + 1 ) < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "Cannot bind socket to device %s : %s", dev, strerror(errno));
+ return -1;
+ }
+
+ return 1;
+}
+
+
+
+static void dev_activate( struct dev_node *bif ) {
+
+ if ( dev_validate( YES/*set*/, bif, bif->name, NO/*reduced check*/ ) == FAILURE )
+ goto error;
+
+ if ( wordsEqual( "lo", bif->name_phy ) ) {
+
+ bif->linklayer = VAL_DEV_LL_LO;
+
+ } else if ( bif->linklayer_conf != -1 ) {
+
+ //FIXME: when this parameter is changed only if_reconfigure_soft is called
+ bif->linklayer = bif->linklayer_conf;
+
+ } else /* check if interface is a wireless interface */ {
+
+ struct ifreq int_req;
+ memset( &int_req, 0, sizeof (struct ifreq) );
+ strncpy( int_req.ifr_name, bif->name_phy, IFNAMSIZ - 1 );
+
+ bif->linklayer =
+ (ioctl( rt_sock, SIOCGIWNAME, &int_req ) < 0 ? VAL_DEV_LL_LAN : VAL_DEV_LL_WLAN);
+
+ }
+
+
+ if ( bif->linklayer != VAL_DEV_LL_LO && (bif->unicast_sock = socket( PF_INET, SOCK_DGRAM, 0 )) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't create send socket: %s", strerror(errno) );
+ goto error;
+ }
+
+ // the src address and port used for sending:
+ bif->ip4_unicast_addr.sin_addr.s_addr = bif->ip4_addr;
+ bif->ip4_unicast_addr.sin_family = AF_INET;
+ bif->ip4_unicast_addr.sin_port = htons(base_port);
+
+ // the dst address and port used for sending:
+ bif->ip4_netwbrc_addr.sin_addr.s_addr = bif->ip4_broad;
+ bif->ip4_netwbrc_addr.sin_family = AF_INET;
+ bif->ip4_netwbrc_addr.sin_port = htons(base_port);
+
+ Mtu_min = MIN ( Mtu_min, bif->ip4_mtu );
+
+ dbgf_all( DBGT_INFO, "searching minimum MTU, so fare: %d, current dev %s, mtu: %d",
+ Mtu_min, bif->name, bif->ip4_mtu );
+
+
+ if ( bif->linklayer == VAL_DEV_LL_LO ) {
+
+ if ( bif->ip4_prefix_length != 32 /*|| bif->if_addr != bif->if_broad*/ )
+ dbg_mute( 30, DBGL_SYS, DBGT_WARN, "netmask of loopback interface is %d but SHOULD BE 32",
+ bif->ip4_prefix_length );
+
+ } else {
+
+ int set_on = 1, sock_opts;
+
+ if ( setsockopt( bif->unicast_sock, SOL_SOCKET, SO_BROADCAST, &set_on, sizeof(set_on) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't enable broadcasts on unicast socket: %s", strerror(errno) );
+ goto error;
+ }
+
+ // bind send socket to interface name
+ if ( bind_to_iface( bif->unicast_sock, bif->name_phy ) < 0 )
+ goto error;
+
+ // bind send socket to address
+ if ( bind( bif->unicast_sock, (struct sockaddr *)&bif->ip4_unicast_addr, sizeof(struct sockaddr_in) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR, "can't bind unicast socket: %s", strerror(errno) );
+ goto error;
+ }
+
+ // make udp send socket non blocking
+ sock_opts = fcntl(bif->unicast_sock, F_GETFL, 0);
+ fcntl(bif->unicast_sock, F_SETFL, sock_opts | O_NONBLOCK);
+
+#ifdef SO_TIMESTAMP
+ if (setsockopt(bif->unicast_sock, SOL_SOCKET, SO_TIMESTAMP, &set_on, sizeof(set_on)))
+ dbg( DBGL_SYS, DBGT_WARN,
+ "No SO_TIMESTAMP support, despite being defined, falling back to SIOCGSTAMP");
+#else
+ dbg( DBGL_SYS, DBGT_WARN, "No SO_TIMESTAMP support, falling back to SIOCGSTAMP");
+#endif
+
+
+
+
+ // if the dst address used for sending is the full-broadcast address
+ // we'll also listen on the network-broadcast address
+
+ struct sockaddr_in if_netwbrc_addr;
+ memset( &if_netwbrc_addr, 0, sizeof( struct sockaddr_in ) );
+ if_netwbrc_addr.sin_family = AF_INET;
+ if_netwbrc_addr.sin_port = htons(base_port);
+ if ( bif->ip4_broad == 0xFFFFFFFF )
+ if_netwbrc_addr.sin_addr.s_addr = bif->ip4_netaddr | ~(bif->ip4_netmask);
+ else
+ if_netwbrc_addr.sin_addr.s_addr = bif->ip4_broad;
+
+
+ // get netwbrc recv socket
+ if ( ( bif->netwbrc_sock = socket( PF_INET, SOCK_DGRAM, 0 ) ) < 0 ) {
+
+ dbg( DBGL_CHANGES, DBGT_ERR, "can't create network-broadcast socket: %s", strerror(errno) );
+ goto error;
+ }
+
+ // bind recv socket to interface name
+ if ( bind_to_iface( bif->netwbrc_sock, bif->name_phy ) < 0 )
+ goto error;
+
+ // bind recv socket to address
+ if ( bind( bif->netwbrc_sock, (struct sockaddr *)&if_netwbrc_addr, sizeof(struct sockaddr_in) ) < 0 ) {
+
+ dbg( DBGL_CHANGES, DBGT_ERR, "can't bind network-broadcast socket: %s", strerror(errno));
+ goto error;
+ }
+
+
+
+ // we'll always listen on the full-broadcast address
+
+ struct sockaddr_in if_fullbrc_addr;
+ memset( &if_netwbrc_addr, 0, sizeof( struct sockaddr_in ) );
+ if_fullbrc_addr.sin_addr.s_addr = 0xFFFFFFFF;
+ if_fullbrc_addr.sin_family = AF_INET;
+ if_fullbrc_addr.sin_port = htons(base_port);
+
+ // get fullbrc recv socket
+ if ( ( bif->fullbrc_sock = socket( PF_INET, SOCK_DGRAM, 0 ) ) < 0 ) {
+
+ dbg( DBGL_CHANGES, DBGT_ERR, "can't create full-broadcast socket: %s", strerror(errno) );
+ goto error;
+ }
+
+ // bind recv socket to interface name
+ if ( bind_to_iface( bif->fullbrc_sock, bif->name_phy ) < 0 )
+ goto error;
+
+ // bind recv socket to address
+ if ( bind( bif->fullbrc_sock, (struct sockaddr *)&if_fullbrc_addr, sizeof(struct sockaddr_in) ) < 0 ) {
+
+ dbg( DBGL_CHANGES, DBGT_ERR, "can't bind full-broadcast socket: %s", strerror(errno));
+ goto error;
+ }
+
+ register_task( rand_num(RAND_INIT_DELAY), schedule_my_hello_message, bif );
+ register_task( rand_num(RAND_INIT_DELAY), tx_packet, bif );
+
+ }
+
+ check_kernel_config( bif );
+
+
+ if ( bif == primary_if ) {
+ my_orig_node.primary_ip4 = bif->ip4_addr;
+ addr_to_str(bif->ip4_addr, my_orig_node.primary_ip4_str);
+ }
+
+ bif->hard_conf_changed = NO;
+
+ bif->soft_conf_changed = YES;
+
+ bif->active = YES;
+
+ if (avl_find(&dev_ip4_tree, &bif->ip4_addr)) {
+ dbgf(DBGL_SYS, DBGT_ERR, "%s already in dev_tree_ip4!", bif->ip4_str);
+ } else {
+ avl_insert(&dev_ip4_tree, bif, -300151);
+ bif->ip4_tree_addr = bif->ip4_addr;
+ }
+
+ //reschedule if_reconfigure_soft( bif ) also called from check_interfaces()
+ // but should also be called here
+ // - before schedule_if_hello()
+ // - after if_active=YES
+ dev_reconfigure_soft( bif );
+
+
+ //activate selector for active interfaces
+ change_selects();
+
+ //trigger plugins interested in changed interface configuration
+ cb_plugin_hooks( NULL, PLUGIN_CB_CONF );
+
+ return;
+
+error:
+
+ dev_deactivate( bif );
+
+}
+
+static int8_t track_route_and_proceed( uint32_t dest, int16_t mask, uint32_t metric, uint32_t gw, uint32_t src, int32_t ifi, char *dev,
+ int16_t rt_table, int16_t rta_type, int8_t del, int8_t track_t )
+{
+
+ struct list_node *list_pos, *tmp_pos, *prev_pos = (struct list_node*)&routes_list;
+ struct list_node *first_found_pos=NULL, *first_found_prev=NULL;
+ struct routes_node *first_found_rn=NULL;
+ uint32_t found_rns=0;
+
+ paranoia(-500177, (!del && track_t == TRACK_NO));
+
+ list_for_each_safe( list_pos, tmp_pos, &routes_list ) {
+
+ struct routes_node *tmp_rn = list_entry( list_pos, struct routes_node, list );
+
+ if ( tmp_rn->dest == dest &&
+ tmp_rn->netmask == mask &&
+ tmp_rn->metric == metric &&
+ tmp_rn->rt_table == rt_table &&
+ tmp_rn->rta_type == rta_type)
+ {
+
+ // the kernel-ip-stack does not care about my track_t when adding the same route twice
+ // but found_rns is evaluated for this
+ if ( !first_found_rn && (tmp_rn->track_t == track_t || track_t == TRACK_NO ) ) {
+
+ first_found_rn = tmp_rn;
+ first_found_pos = list_pos;
+ first_found_prev = prev_pos;
+ }
+
+ found_rns++;
+
+ }
+
+ prev_pos = &tmp_rn->list;
+
+ }
+
+ if ( track_t == TRACK_NO ||
+ ( del && !first_found_rn ) ||
+ ( del && found_rns != 1 ) ||
+ ( !del && found_rns > 0 ) )
+ {
+ dbg( (track_t == TRACK_NO || (del && !first_found_rn)) ? DBGL_SYS : DBGL_ALL,
+ (track_t == TRACK_NO || (del && !first_found_rn)) ? DBGT_ERR : DBGT_INFO,
+ " %s route to %-15s via %-15s src %s dev %s table %d %s "
+ "%s has %d (%d exact) matches",
+ del?"del":"add", ipStr(dest), ipStr(gw), ipStr(src), dev, rt_table,
+ rt2str(rta_type), trackt2str(track_t), found_rns, (first_found_rn?1:0) );
+ }
+
+ if ( track_t == TRACK_NO )
+ return YES;
+
+
+ if ( del && !first_found_rn) {
+
+ dbgf_all( DBGT_WARN, "removing orphan route");
+ return NO;
+
+ } else if ( del && first_found_rn ) {
+
+ list_del_next(&routes_list, first_found_prev);
+ debugFree( first_found_rn, -300075 );
+
+ if ( found_rns > 1 )
+ return NO;
+
+
+ } else if ( !del ) {
+
+ struct routes_node *tmp_rn = debugMalloc( sizeof( struct routes_node ), -300032 );
+ memset( tmp_rn, 0, sizeof( struct routes_node ) );
+
+ tmp_rn->dest = dest;
+ tmp_rn->netmask = mask;
+ tmp_rn->metric = metric;
+ tmp_rn->rt_table = rt_table;
+ tmp_rn->rta_type = rta_type;
+ tmp_rn->track_t = track_t;
+
+ list_add_tail(&routes_list, &tmp_rn->list);
+
+ if ( found_rns > 0 )
+ return NO;
+
+ }
+
+ return YES;
+}
+
+
+
+void configure_route( uint32_t dest, int16_t mask, uint32_t metric, uint32_t gw, uint32_t src, int32_t ifi, char *dev,
+ int16_t rt_table_macro, int16_t rta_type, int8_t del, int8_t track_t )
+{
+
+ uint32_t my_router;
+ char buf[4096];
+ struct sockaddr_nl nladdr;
+
+ struct msghdr msg;
+ struct nlmsghdr *nh;
+
+ struct iovec iov;
+
+ memset(&iov, 0, sizeof (struct iovec));
+ iov.iov_base = buf;
+ iov.iov_len = sizeof (buf);
+
+ uint16_t rt_table = rt_macro_to_table(rt_table_macro);
+
+ dest = dest & htonl( 0xFFFFFFFF<<(32 - mask ) );
+
+ if ( ( !throw_rules ) && ( rta_type == RTN_THROW ) )
+ return;
+
+
+
+ if ( track_route_and_proceed(dest, mask, metric, gw, src, ifi, dev, rt_table, rta_type, del, track_t) == NO )
+ return;
+
+ if ( track_t != TRACK_OTHER_HOST )
+ dbg( DBGL_CHANGES, DBGT_INFO,
+ " %s route to %15s/%-2d table %d via %-15s dev %-10s ifi %2d %s %s",
+ del?"del":"add",
+ ipStr(dest), mask, rt_table, ipStr(gw), dev, ifi, rt2str(rta_type), trackt2str(track_t));
+
+
+ if ( gw == dest )
+ my_router = 0;
+
+ else
+ my_router = gw;
+
+
+ dbgf_all( DBGT_INFO, "%s %s to %s/%i via %s (table %i - %s src %s )",
+ del ? "del" : "add",
+ rt2str(rta_type), ipStr(dest), mask, ipStr(gw), rt_table, dev, ipStr(src));
+
+
+ memset( &nladdr, 0, sizeof(struct sockaddr_nl) );
+ memset( &req, 0, sizeof(req) );
+ memset( &msg, 0, sizeof(struct msghdr) );
+
+ nladdr.nl_family = AF_NETLINK;
+
+ req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ req.nlh.nlmsg_pid = My_pid;
+
+ req.rtm.rtm_family = AF_INET;
+ req.rtm.rtm_table = rt_table;
+ req.rtm.rtm_dst_len = mask;
+
+ if ( del ) {
+
+ req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
+ req.nlh.nlmsg_type = RTM_DELROUTE;
+ req.rtm.rtm_scope = RT_SCOPE_NOWHERE;
+
+ } else {
+
+ req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE | NLM_F_EXCL/* | NLM_F_REPLACE*/;
+ req.nlh.nlmsg_type = RTM_NEWROUTE;
+
+ if ( /* source != 0 && */ rta_type == RTN_UNICAST && my_router == 0 ) {
+ req.rtm.rtm_scope = RT_SCOPE_LINK;
+ } else {
+ req.rtm.rtm_scope = RT_SCOPE_UNIVERSE;
+ }
+
+ req.rtm.rtm_protocol = RTPROT_STATIC; // may be changed to some bmx specific value - see <linux/rtnetlink.h>
+ req.rtm.rtm_type = ( rta_type == RTN_THROW ? RTN_THROW : RTN_UNICAST );
+
+ }
+
+ add_rtattr( RTA_DST, (char*)&dest, sizeof(dest) );
+
+ if ( rta_type == RTN_UNICAST ) {
+
+ if ( my_router )
+ add_rtattr( RTA_GATEWAY, (char*)&my_router, sizeof(my_router) );
+
+ if ( ifi )
+ add_rtattr ( RTA_OIF, (char*)&ifi, sizeof(ifi) );
+
+ if ( src /* && my_router == 0 */)
+ add_rtattr( RTA_PREFSRC, (char*)&src, sizeof(src) );
+
+ if ( metric )
+ add_rtattr( RTA_PRIORITY, (char*)&metric, sizeof(metric) );
+
+ }
+
+ errno=0;
+
+ if ( sendto( nl_sk, &req, req.nlh.nlmsg_len, 0, (struct sockaddr *)&nladdr, sizeof(struct sockaddr_nl) ) < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_ERR,
+ "can't send message to kernel via netlink socket for routing table manipulation: %s",
+ strerror(errno) );
+
+ return;
+
+ }
+
+
+ while ( 1 ) {
+
+ msg.msg_name = (void *)&nladdr;
+ msg.msg_namelen = sizeof(nladdr);
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+ msg.msg_flags = 0;
+
+ errno=0;
+ int32_t len = recvmsg( nl_sk, &msg, 0 );
+
+
+ if ( len < 0 ) {
+
+ if ( errno == EINTR ) {
+
+ dbgf( DBGL_SYS, DBGT_WARN, "(EINTR) %s", strerror(errno) );
+
+ continue;
+ }
+
+ if ( errno == EWOULDBLOCK || errno == EAGAIN ) {
+ //dbgf( DBGL_CHANGES, DBGT_WARN, "(EWOULDBLOCK || EAGAIN) %s", strerror(errno) );
+ break;
+ }
+
+ dbgf( DBGL_SYS, DBGT_ERR, "%s", strerror(errno) );
+
+ continue;
+
+ }
+
+ if ( !len ) {
+ dbgf( DBGL_SYS, DBGT_ERR, "netlink EOF" );
+ }
+
+ nh = (struct nlmsghdr *)buf;
+
+ while ( NLMSG_OK(nh, (uint32_t)len) ) {
+
+ if ( nh->nlmsg_type == NLMSG_DONE )
+ return;
+
+ if ( ( nh->nlmsg_type == NLMSG_ERROR ) && ( ((struct nlmsgerr*)NLMSG_DATA(nh))->error != 0 ) )
+ {
+ dbg( DBGL_CHANGES, DBGT_WARN, "can't %s %s to %s/%i via %s (table %i): %s",
+ del ? "delete" : "add", rt2str(rta_type), ipStr(dest), mask, ipStr(gw), rt_table,
+ strerror(-((struct nlmsgerr*)NLMSG_DATA(nh))->error) );
+ }
+
+ nh = NLMSG_NEXT( nh, len );
+
+ }
+ }
+}
+
+
+
+
+
+
+int update_interface_rules( uint8_t cmd ) {
+
+
+ static uint8_t setup_tunnel = NO;
+ static uint8_t setup_networks = NO;
+
+ static uint64_t checksum = 0;
+
+ uint64_t old_checksum = checksum;
+ checksum = 0;
+
+ uint8_t if_count = 1;
+ char *buf, *buf_ptr;
+
+ struct ifreq *ifr;
+ struct ifconf ifc;
+
+
+ struct dev_node *dev_node;
+
+ struct list_node *throw_pos;
+ struct throw_node *throw_node;
+ uint32_t no_netmask;
+
+ if ( cmd != IF_RULE_CHK_IPS ) {
+
+ flush_tracked_routes( TRACK_MY_NET );
+ flush_tracked_rules( TRACK_MY_NET );
+
+ }
+
+ if ( cmd == IF_RULE_SET_TUNNEL ) {
+
+ setup_tunnel = YES;
+ return SUCCESS; //will be called again when bat0s' IP is set
+
+ } else if ( cmd == IF_RULE_CLR_TUNNEL ) {
+
+ setup_tunnel = NO;
+ return SUCCESS; //will be called again when bat0s' IP gets removed
+
+ } else if ( cmd == IF_RULE_SET_NETWORKS ) {
+
+ setup_networks = YES;
+
+ } else if ( cmd == IF_RULE_CLR_NETWORKS ) {
+
+ setup_networks = NO;
+
+ }
+
+ if ( !(buf = get_ip4conf_buffer( &ifc )) )
+ return FAILURE;
+
+ for ( buf_ptr = buf; buf_ptr < buf + ifc.ifc_len; ) {
+
+ struct dev_node bif;
+// memset( &bif, 0, sizeof(struct dev_node));
+
+ ifr = (struct ifreq *)buf_ptr;
+
+ buf_ptr += sizeof(struct ifreq);
+
+ /* ignore if not IPv4 interface */
+ if ( ifr->ifr_addr.sa_family != AF_INET )
+ continue;
+
+ if ( !dev_up( ifr->ifr_name ) )
+ continue;
+
+ if ( dev_validate( YES/*set*/, &bif, ifr->ifr_name, YES/*reduced check only*/ ) == FAILURE )
+ continue;
+
+ size_t i;
+ struct config_key {
+ uint32_t if_prefix_length;
+ uint32_t if_netaddr;
+ uint32_t if_addr;
+ } config_key;
+
+ memset( &config_key, 0, sizeof(struct config_key));
+ config_key.if_prefix_length = bif.ip4_prefix_length;
+ config_key.if_netaddr = bif.ip4_netaddr;
+ config_key.if_addr = bif.ip4_addr;
+
+ for (i = 0; i < sizeof( struct config_key); i++) {
+ checksum += ((unsigned char*)(&config_key))[i];
+ checksum += (checksum << 10);
+ checksum ^= (checksum >> 6);
+ }
+
+ dbgf_ext(DBGT_INFO, "%32ju %32ju %10s %15s %15s %2d ",
+ old_checksum, checksum,
+ ifr->ifr_name, ipStr(bif.ip4_addr), ipStr(bif.ip4_netaddr), bif.ip4_prefix_length);
+
+
+ if ( cmd == IF_RULE_CHK_IPS )
+ continue;
+
+
+ uint8_t add_this_rule = YES;
+
+ list_for_each(throw_pos, &throw_list) {
+
+ throw_node = list_entry(throw_pos, struct throw_node, list);
+
+ no_netmask = htonl( 0xFFFFFFFF<<(32 - throw_node->netmask ) );
+
+ if ( ((throw_node->addr & no_netmask) == (bif.ip4_netaddr & no_netmask)) )
+ add_this_rule = NO;
+
+ }
+
+
+ if( prio_rules && setup_tunnel == YES ) {
+
+ if ( !Lo_rule &&
+ (bif.ip4_netaddr & htonl( 0xFF000000 ) ) == ( htonl( 0x7F000000 /*127.0.0.0*/ ) ) )
+ add_this_rule = NO;
+
+
+ if ( add_this_rule ) {
+ configure_rule( bif.ip4_netaddr, bif.ip4_prefix_length,
+ RT_TABLE_TUNNEL, RT_PRIO_TUNNEL, 0, RTA_SRC, ADD, TRACK_MY_NET );
+ if_count++;
+ }
+
+ if ( Lo_rule && strncmp( ifr->ifr_name, "lo", strlen("lo") ) == 0 ) {
+
+ configure_rule( 0, 0, RT_TABLE_TUNNEL, RT_PRIO_TUNNEL, "lo", RTA_IIF, ADD, TRACK_MY_NET );
+ }
+
+ }
+
+ if( throw_rules && setup_tunnel == YES )
+ configure_route( bif.ip4_netaddr, bif.ip4_prefix_length, 0,
+ 0, 0, 0, ifr->ifr_name, RT_TABLE_TUNNEL, RTN_THROW, ADD, TRACK_MY_NET );
+
+
+ if ( !(dev_node = get_bif( ifr->ifr_name ) ) )
+ continue;
+
+
+ if( throw_rules && setup_networks == YES )
+ configure_route( bif.ip4_netaddr, bif.ip4_prefix_length, 0,
+ 0, 0, 0, ifr->ifr_name, RT_TABLE_NETWORKS, RTN_THROW, ADD, TRACK_MY_NET );
+
+
+ }
+
+
+ debugFree( buf, -300076 );
+
+
+ if ( cmd != IF_RULE_CHK_IPS ) {
+
+ list_for_each(throw_pos, &throw_list) {
+
+ throw_node = list_entry(throw_pos, struct throw_node, list);
+
+ configure_route( throw_node->addr, throw_node->netmask, 0,
+ 0, 0, 0, "unknown", RT_TABLE_HOSTS, RTN_THROW, ADD, TRACK_MY_NET );
+ configure_route( throw_node->addr, throw_node->netmask, 0,
+ 0, 0, 0, "unknown", RT_TABLE_NETWORKS, RTN_THROW, ADD, TRACK_MY_NET );
+ configure_route( throw_node->addr, throw_node->netmask, 0,
+ 0, 0, 0, "unknown", RT_TABLE_TUNNEL, RTN_THROW, ADD, TRACK_MY_NET );
+
+ }
+
+ }
+
+
+ if ( cmd == IF_RULE_CHK_IPS && (checksum != old_checksum) ) {
+ dbg( DBGL_CHANGES, DBGT_INFO,
+ "systems' IP configuration changed! Going to re-init interface rules...");
+ update_interface_rules( IF_RULE_UPD_ALL );
+ }
+
+
+ return SUCCESS;
+
+}
+
+
+
+
+// check for further traps: http://lwn.net/Articles/45386/
+void check_kernel_config( struct dev_node *dev_node ) {
+
+ if ( dev_node ) {
+
+ char filename[100];
+
+ sprintf( filename, "net/ipv4/conf/%s/rp_filter", dev_node->name_phy);
+ check_proc_sys( filename, 0, &dev_node->rp_filter_orig );
+
+ sprintf( filename, "net/ipv4/conf/%s/send_redirects", dev_node->name_phy);
+ check_proc_sys( filename, 0, &dev_node->send_redirects_orig );
+
+ } else {
+
+ check_proc_sys( "net/ipv4/conf/all/rp_filter", 0, &if_rp_filter_all_orig );
+ check_proc_sys( "net/ipv4/conf/default/rp_filter", 0, &if_rp_filter_default_orig );
+ check_proc_sys( "net/ipv4/conf/all/send_redirects", 0, &if_send_redirects_all_orig );
+ check_proc_sys( "net/ipv4/conf/default/send_redirects", 0, &if_send_redirects_default_orig );
+ check_proc_sys( "net/ipv4/ip_forward", 1, &forward_orig );
+
+ }
+}
+
+
+
+void dev_deactivate( struct dev_node *bif ) {
+
+ dbg_mute( 30, DBGL_SYS, DBGT_WARN, "deactivating IF %-10s %-15s", bif->name, ipStr(bif->ip4_addr) );
+
+
+ if ( bif->linklayer != VAL_DEV_LL_LO ) {
+
+ remove_task( tx_packet, bif );
+ remove_task( schedule_my_hello_message, bif );
+
+ purge_tx_timestamp_tree( bif, YES);
+ purge_dev_tx_list ( bif );
+
+ if (bif->unicast_sock != 0)
+ close(bif->unicast_sock);
+
+ bif->unicast_sock = 0;
+
+ if (bif->netwbrc_sock != 0)
+ close(bif->netwbrc_sock);
+
+ bif->netwbrc_sock = 0;
+
+ if (bif->fullbrc_sock != 0)
+ close(bif->fullbrc_sock);
+
+ bif->fullbrc_sock = 0;
+
+
+ }
+
+ if (!bif->ip4_tree_addr) {
+ dbgf(DBGL_SYS, DBGT_ERR, "no address given to remove in dev_tree_ip4!");
+ } else if (!avl_find(&dev_ip4_tree, &bif->ip4_tree_addr)) {
+ dbgf(DBGL_SYS, DBGT_ERR, "%s not in dev_tree_ip4!", ipStr(bif->ip4_tree_addr));
+ } else {
+ avl_remove(&dev_ip4_tree, &bif->ip4_tree_addr, -300192);
+ bif->ip4_tree_addr = 0;
+ }
+ bif->active = NO;
+
+
+ restore_kernel_config ( bif );
+
+ change_selects();
+
+ dbgf_all( DBGT_WARN, "Interface %s deactivated", bif->name );
+
+ if ( bif == primary_if && !terminating() ) {
+
+ purge_orig( NULL, NO);
+
+ dbg_mute( 30, DBGL_SYS, DBGT_WARN,
+ "You SHOULD always configure a loopback-alias interface for %s/32 to remain reachable under your primary IP!",
+ ipStr(bif->ip4_addr) );
+
+ } else {
+
+ purge_orig( bif, NO );
+ }
+
+ update_my_description_adv();
+}
+
+
+
+void dev_check() {
+
+ uint8_t cb_conf_hooks = NO;
+
+ dbgf_all( DBGT_INFO, " " );
+
+ remove_task( dev_check, NULL );
+
+ //Do we need this? There was an interface attribute which change is not catched by ifevent_sk ??
+ register_task( 5000, dev_check, NULL );
+
+ if ( !dev_name_tree.items ) {
+ dbg( DBGL_SYS, DBGT_ERR, "No interfaces specified");
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+
+ Mtu_min = MAX_MTU;
+
+ struct avl_node *it=NULL;
+ struct dev_node *bif;
+ while ((bif = avl_iterate_item(&dev_name_tree, &it))) {
+
+ if ((bif->active) && (!dev_up(bif->name))) {
+
+ dbg( DBGL_SYS, DBGT_WARN,
+ "detected inactive but used %sprimary interface: %s ! Deactivating now...",
+ (bif == primary_if ? "" : "non-" ), bif->name );
+
+ cb_conf_hooks = YES;
+ dev_deactivate( bif );
+
+
+ } else if ( bif->active && dev_up(bif->name) ) {
+
+ /* Interface properties might have changed */
+
+ if ( if_conf_hard_changed || bif->hard_conf_changed ||
+ dev_validate( NO/*set*/, bif, bif->name, NO/*reduced check*/ ) == FAILURE ) {
+
+ cb_conf_hooks = YES;
+ dev_deactivate( bif );
+
+ } else {
+
+ Mtu_min = MIN( Mtu_min, bif->ip4_mtu );
+
+ dbgf_all( DBGT_INFO,
+ "researching minimum MTU, so fare: %d, current dev %s, mtu: %d",
+ Mtu_min, bif->name, bif->ip4_mtu);
+ }
+
+ }
+
+ if (if_conf_soft_changed )
+ bif->soft_conf_changed = YES; // to be considered in if_activate()->if_reconfigure_soft()
+
+ if ( (!bif->active) && (dev_up(bif->name)) ) {
+
+ struct dev_node *tmp_bif = avl_find_item(&dev_ip4_tree, &bif->ip4_addr);
+
+ if (tmp_bif && !wordsEqual(tmp_bif->name, bif->name)) {
+
+ dbg_mute(40, DBGL_SYS, DBGT_ERR, "IF %-10s IP %-15s already used for IF %s",
+ bif->name, bif->ip4_str, tmp_bif->name);
+ break;
+
+ } else {
+
+ if ( on_the_fly )
+ dbg_mute( 50, DBGL_SYS, DBGT_INFO,
+ "detected valid but disabled dev: %s ! Activating now...", bif->name );
+
+ dev_activate( bif );
+ }
+ }
+
+ if ( /*bif->if_active &&*/ ( /*if_conf_soft_changed ||*/ bif->soft_conf_changed) ) {
+
+ if ( on_the_fly )
+ dbg( DBGL_CHANGES, DBGT_INFO, "%s soft interface configuration changed", bif->name );
+
+ dev_reconfigure_soft( bif );
+ }
+
+
+ if ( !on_the_fly && !bif->active ) {
+
+ if ( bif == primary_if ) {
+ dbg( DBGL_SYS, DBGT_ERR,
+ "at least primary interface %s MUST be operational at startup! "
+ "Use loopback (e.g. lo:bmx a.b.c.d/32 ) if nothing else is available!",
+ bif->name);
+
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+ dbg( DBGL_SYS, DBGT_WARN,
+ "not using interface %s (retrying later): interface not ready", bif->name);
+ }
+ }
+
+ if_conf_soft_changed = NO;
+ if_conf_hard_changed = NO;
+
+
+ if ( cb_conf_hooks )
+ cb_plugin_hooks( NULL, PLUGIN_CB_CONF );
+
+
+ if ( on_the_fly ) // opt_policy_rt() is responsible for this during init
+ update_interface_rules( IF_RULE_CHK_IPS );
+
+}
+
+
+
+
+
+static int32_t opt_policy_rt ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ if ( cmd == OPT_APPLY ) {
+
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_PRIO_RULES ), "0", cn );
+ check_apply_parent_option( ADD, OPT_APPLY, _save, get_option( 0, 0, ARG_THROW_RULES ), "0", cn );
+
+ } else if ( cmd == OPT_SET_POST && !on_the_fly ) {
+
+ // flush orphan routes must be before flushing rules, otherwise orphan routes are not found !
+ flush_routes_rules( 0 /* flush routes */);
+
+ /* add rule for hosts and announced interfaces and networks */
+ if ( prio_rules )
+ flush_routes_rules( 1 /* flush rules */);
+
+
+ } else if ( cmd == OPT_POST && !on_the_fly ) {
+
+ // add rule for hosts and announced interfaces and networks
+ if ( prio_rules ) {
+ configure_rule( 0, 0, RT_TABLE_HOSTS, RT_PRIO_HOSTS, 0, RTA_DST, ADD, TRACK_STANDARD );
+ configure_rule( 0, 0, RT_TABLE_NETWORKS, RT_PRIO_NETWORKS, 0, RTA_DST, ADD, TRACK_STANDARD );
+ }
+
+ // add rules and routes for interfaces
+ if ( update_interface_rules( IF_RULE_SET_NETWORKS ) < 0 )
+ cleanup_all( CLEANUP_FAILURE );
+
+ }
+
+ return SUCCESS;
+}
+
+
+static int32_t opt_throw ( uint8_t cmd, uint8_t _save, struct opt_type *opt, struct opt_parent *patch, struct ctrl_node *cn ) {
+
+ uint32_t ip;
+ int32_t mask;
+ char tmp[30];
+ struct throw_node *throw_node=NULL;
+ struct list_node *throw_tmp, *throw_pos;
+
+ if ( cmd == OPT_ADJUST || cmd == OPT_CHECK || cmd == OPT_APPLY ) {
+
+ if ( patch->p_val[0] >= '0' && patch->p_val[0] <= '9' ) {
+ // configure an unnamed throw-rule
+
+ if ( str2netw( patch->p_val, &ip, '/', cn, &mask, 32 ) == FAILURE )
+ return FAILURE;
+
+ sprintf( tmp, "%s/%d", ipStr( validate_net_mask( ip, mask, 0 ) ), mask );
+ set_opt_parent_val( patch, tmp );
+
+ } else {
+ // configure a named throw-rule
+
+ // just for adjust and check
+ if ( adj_patched_network( opt, patch, tmp, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+
+ if ( patch->p_diff == ADD ) {
+ if ( adj_patched_network( opt, patch, tmp, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+ } else {
+ // re-configure network and netmask parameters of an already configured and named throw-rule
+ if ( get_tracked_network( opt, patch, tmp, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+ }
+ }
+
+ struct list_node *prev_pos = (struct list_node *)&throw_list;
+ list_for_each_safe( throw_pos, throw_tmp, &throw_list ) {
+ throw_node = list_entry(throw_pos, struct throw_node, list);
+ if ( throw_node->addr == ip && throw_node->netmask == mask )
+ break;
+ prev_pos = &throw_node->list;
+ throw_node = NULL;
+ }
+
+ if ( cmd == OPT_ADJUST )
+ return SUCCESS;
+
+ if ( ( patch->p_diff != ADD && !throw_node ) || ( patch->p_diff == ADD && throw_node ) ) {
+ dbg_cn( cn, DBGL_SYS, DBGT_ERR, "%s %s does %s exist!",
+ ARG_THROW, tmp, patch->p_diff == ADD ? "already" : "not" );
+ return FAILURE;
+ }
+
+ if ( cmd == OPT_CHECK )
+ return SUCCESS;
+
+ if ( patch->p_diff == DEL || patch->p_diff == NOP ) {
+ list_del_next( &throw_list, prev_pos );
+ debugFree( throw_pos, -300077 );
+ }
+
+ if ( patch->p_diff == NOP ) {
+ // get new network again
+ if ( adj_patched_network( opt, patch, tmp, &ip, &mask, cn ) == FAILURE )
+ return FAILURE;
+ }
+
+ if ( patch->p_diff == ADD || patch->p_diff == NOP ) {
+
+ throw_node = debugMalloc( sizeof(struct throw_node), -300033 );
+ memset( throw_node, 0, sizeof(struct throw_node) );
+ list_add_tail( &throw_list, &throw_node->list );
+
+ throw_node->addr = ip;
+ throw_node->netmask = mask;
+ }
+
+
+ if ( on_the_fly ) {
+ /* add rules and routes for interfaces */
+ if ( update_interface_rules( IF_RULE_UPD_ALL ) < 0 )
+ cleanup_all( CLEANUP_FAILURE );
+ }
+
+ return SUCCESS;
+
+
+ } else if ( cmd == OPT_UNREGISTER ) {
+
+ while ((throw_node = list_rem_head(&throw_list)))
+ debugFree(throw_node, -300078);
+
+/*
+ list_for_each_safe( throw_pos, throw_tmp, &throw_list ) {
+
+ list_del_next( &throw_list, (struct list_node *)&throw_list );
+
+ debugFree( throw_pos, -300078 );
+ }
+*/
+ }
+
+ return SUCCESS;
+}
+
+
+
+
+static struct opt_type route_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+
+ {ODI,0,0, 0, 4,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nSystem and policy-routing options:"},
+
+ {ODI,0,ARG_BASE_PORT, 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &base_port, MIN_BASE_PORT, MAX_BASE_PORT, DEF_BASE_PORT, 0,
+ ARG_VALUE_FORM, "set udp ports"},
+
+ {ODI,0,ARG_RT_PRIO, 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &Rt_prio, MIN_RT_PRIO, MAX_RT_PRIO, DEF_RT_PRIO, 0,
+ ARG_VALUE_FORM, "set preferences for iproute2-style rules to rt_table (see: man ip)"},
+
+ {ODI,0,ARG_RT_TABLE, 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &Rt_table, MIN_RT_TABLE, MAX_RT_TABLE-RT_TABLE_MAX_OFFS, DEF_RT_TABLE, 0,
+ ARG_VALUE_FORM, "set bmx routing-table offset (iproute2 style, see: man ip)"},
+
+#ifndef LESS_OPTIONS
+ {ODI,0,ARG_THROW_RULES, 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &throw_rules, 0, 1, DEF_THROW_RULES,0,
+ ARG_VALUE_FORM, "disable/enable default throw rules"},
+
+ {ODI,0,ARG_PRIO_RULES, 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &prio_rules, 0, 1, DEF_PRIO_RULES, 0,
+ ARG_VALUE_FORM, "disable/enable default priority rules"},
+#endif
+ {ODI,0,ARG_NO_POLICY_RT, 'n',4,A_PS0,A_ADM,A_INI,A_ARG,A_ANY, 0, 0, 0, 0, opt_policy_rt,
+ 0, "disable policy routing (throw and priority rules)"},
+
+#ifndef LESS_OPTIONS
+
+ {ODI,0,"lo_rule", 0, 4,A_PS1,A_ADM,A_INI,A_CFA,A_ANY, &Lo_rule, 0, 1, DEF_LO_RULE, 0,
+ ARG_VALUE_FORM, "disable/enable autoconfiguration of lo rule"},
+#endif
+ {ODI,0,ARG_THROW, 0, 5,A_PMN,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_throw,
+ ARG_PREFIX_FORM, "do NOT route packets matching src or dst IP range(s) into gateway tunnel or announced networks"},
+
+ {ODI,ARG_THROW,ARG_NETW, 'n',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_throw,
+ ARG_NETW_FORM, "specify network of throw rule"},
+
+ {ODI,ARG_THROW,ARG_MASK, 'm',5,A_CS1,A_ADM,A_DYI,A_CFA,A_ANY, 0, 0, 0, 0, opt_throw,
+ ARG_MASK_FORM, "specify network of throw rule"}
+
+#ifndef LESS_OPTIONS
+ ,
+ {ODI,0,ARG_PEDANTIC_CLEANUP, 0, 5,A_PS1,A_ADM,A_DYI,A_CFA,A_ANY, &Pedantic_cleanup,0, 1, DEF_PEDANT_CLNUP,0,
+ ARG_VALUE_FORM, "disable/enable pedantic cleanup of system configuration (like ip_forward,..) \n"
+ " at program termination. Its generally safer to keep this disabled to not mess up \n"
+ " with other routing protocols"}
+#endif
+
+
+};
+
+
+
+void init_route( void ) {
+
+ if( ( nl_sk = open_netlink_socket()) <= 0 )
+ cleanup_all( -500067 );
+
+ if( ( flush_sk = open_netlink_socket()) <= 0 )
+ cleanup_all( -500067 );
+
+ errno=0;
+ if ( !rt_sock && (rt_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ dbgf( DBGL_SYS, DBGT_ERR, "can't create routing socket %s:", strerror(errno) );
+ cleanup_all( -500021 );
+ }
+
+ register_options_array( route_options, sizeof( route_options ) );
+
+}
+
+
+void cleanup_route( void ) {
+
+ flush_tracked_routes( TRACK_NO );
+ flush_tracked_rules( TRACK_NO );
+
+ // if ever started succesfully in daemon mode...
+ if ( on_the_fly ) {
+
+ // flush orphan routes (and do warning in case)
+ // must be before flushing rules, otherwise orphan routes are not found !
+ flush_routes_rules(0 /* flush route */ );
+
+ // flush orphan rules (and do warning in case)
+ if ( prio_rules )
+ flush_routes_rules(1 /* flush rule */);
+
+ }
+
+ restore_kernel_config( NULL );
+
+ if( nl_sk > 0 )
+ close( nl_sk );
+
+ if( flush_sk > 0 )
+ close( flush_sk );
+
+ if ( rt_sock )
+ close( rt_sock );
+
+ rt_sock = 0;
+}
+
+
Added: trunk/bmx/route.h
===================================================================
--- trunk/bmx/route.h (rev 0)
+++ trunk/bmx/route.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2006 BATMAN/BMX contributors:
+ * Thomas Lopatic, Marek Lindner, Axel Neumann
+ * 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
+ *
+ */
+
+#define DEV_LO "lo"
+#define DEV_UNKNOWN "unknown"
+#define MAX_MTU 1500
+
+
+extern int32_t base_port;
+#define ARG_BASE_PORT "base_port"
+#define DEF_BASE_PORT 4305
+#define MIN_BASE_PORT 1025
+#define MAX_BASE_PORT 60000
+
+
+
+
+/***
+ *
+ * Things you should leave as is unless your know what you are doing !
+ *
+ * RT_TABLE_INTERFACES routing table for announced (non-primary) interfaces IPs and other unique IP addresses
+ * RT_TABLE_HOSTS routing table for routes towards originators
+ * RT_TABLE_NETWORKS routing table for announced networks
+ * RT_TABLE_TUNNEL routing table for the tunnel towards the internet gateway
+ * RT_PRIO_DEFAULT standard priority for routing rules
+ * RT_PRIO_UNREACH standard priority for unreachable rules
+ * RT_PRIO_TUNNEL standard priority for tunnel routing rules
+ *
+ ***/
+
+#define RT_TABLE_INTERFACES -1
+#define RT_TABLE_HOSTS -2
+#define RT_TABLE_NETWORKS -3
+#define RT_TABLE_TUNNEL -4
+
+
+
+extern uint8_t if_conf_soft_changed; // temporary enabled to trigger changed interface configuration
+extern uint8_t if_conf_hard_changed; // temporary enabled to trigger changed interface configuration
+
+extern int Mtu_min;
+
+
+struct routes_node {
+ struct list_node list;
+ uint32_t dest;
+ uint16_t netmask;
+ uint16_t rt_table;
+ uint32_t metric;
+ int16_t rta_type;
+ int8_t track_t;
+};
+
+
+struct rules_node {
+ struct list_node list;
+ uint32_t prio;
+ char *iif;
+ uint32_t network;
+ int16_t netmask;
+ int16_t rt_table;
+ int16_t rta_type;
+ int8_t track_t;
+};
+
+
+
+//track types:
+enum {
+ TRACK_NO,
+ TRACK_STANDARD, //basic rules to interfaces, host, and networks routing tables
+ TRACK_MY_HNA,
+ TRACK_MY_NET,
+ TRACK_OTHER_HOST,
+ TRACK_OTHER_HNA,
+ TRACK_TUNNEL
+};
+
+void configure_route( uint32_t dest, int16_t mask, uint32_t metric, uint32_t gw, uint32_t src, int32_t ifi, char *dev,
+ int16_t rt_table_macro, int16_t rta_type, int8_t del, int8_t track_t );
+
+/***
+ *
+ * rule types: 0 = RTA_SRC, 1 = RTA_DST, 2 = RTA_IIF
+#define RTA_SRC 0
+#define RTA_DST 1
+#define RTA_IIF 2
+ *
+ ***/
+
+// void add_del_rule( uint32_t network, uint8_t netmask, int16_t rt_macro, uint32_t prio, char *iif, int8_t rule_type, int8_t del, int8_t track_t );
+
+enum {
+ IF_RULE_SET_TUNNEL,
+ IF_RULE_CLR_TUNNEL,
+ IF_RULE_SET_NETWORKS,
+ IF_RULE_CLR_NETWORKS,
+ IF_RULE_UPD_ALL,
+ IF_RULE_CHK_IPS
+};
+
+int update_interface_rules( uint8_t cmd );
+
+
+void check_kernel_config( struct dev_node *dev_node );
+
+//int8_t bind_to_iface( int32_t sock, char *dev );
+
+//int is_interface_up(char *dev);
+void dev_deactivate ( struct dev_node *dev_node );
+void dev_check ();
+
+void init_route( void );
+void cleanup_route( void );
+
Added: trunk/bmx/schedule.c
===================================================================
--- trunk/bmx/schedule.c (rev 0)
+++ trunk/bmx/schedule.c 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,661 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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 <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/if.h> /* ifr_if, ifr_tun */
+#include <linux/rtnetlink.h>
+
+
+#include "bmx.h"
+#include "msg.h"
+#include "plugin.h"
+#include "route.h"
+#include "schedule.h"
+
+#define OUT_SEQNO_OFFSET 1
+
+
+
+#ifndef NO_PARANOIA
+#define DEF_SIM_PARA NO
+static int32_t sim_paranoia = DEF_SIM_PARA;
+#endif
+
+
+static LIST_SIMPEL( task_list, struct task_node, list );
+
+static int32_t receive_max_sock = 0;
+static fd_set receive_wait_set;
+
+static uint16_t changed_readfds = 1;
+
+static int ifevent_sk = -1;
+
+#ifdef BMX2_TODO
+static struct ext_packet my_pip_extension_packet;
+#endif
+
+void change_selects( void ) {
+ changed_readfds++;
+}
+
+
+static void check_selects( void ) {
+
+ if( changed_readfds == 0 )
+ return;
+
+ struct list_node *list_pos;
+
+ dbgf_all( DBGT_INFO, "%d select fds changed... ", changed_readfds );
+
+ changed_readfds = 0;
+
+ FD_ZERO(&receive_wait_set);
+ receive_max_sock = 0;
+
+ receive_max_sock = ifevent_sk;
+ FD_SET(ifevent_sk, &receive_wait_set);
+
+ if ( receive_max_sock < unix_sock )
+ receive_max_sock = unix_sock;
+
+ FD_SET(unix_sock, &receive_wait_set);
+
+ list_for_each( list_pos, &ctrl_list ) {
+
+ struct ctrl_node *cn = list_entry( list_pos, struct ctrl_node, list );
+
+ if ( cn->fd > 0 && cn->fd != STDOUT_FILENO ) {
+
+ receive_max_sock = MAX( receive_max_sock, cn->fd);
+
+ FD_SET( cn->fd, &receive_wait_set );
+ }
+ }
+
+ struct avl_node *it=NULL;
+ struct dev_node *bif;
+ while ((bif = avl_iterate_item(&dev_ip4_tree, &it))) {
+
+ if ( bif->active && bif->linklayer != VAL_DEV_LL_LO ) {
+
+ receive_max_sock = MAX( receive_max_sock, bif->unicast_sock );
+
+ FD_SET(bif->unicast_sock, &receive_wait_set);
+
+ receive_max_sock = MAX( receive_max_sock, bif->netwbrc_sock );
+
+ FD_SET(bif->netwbrc_sock, &receive_wait_set);
+
+ if (bif->fullbrc_sock > 0) {
+
+ receive_max_sock = MAX( receive_max_sock, bif->fullbrc_sock );
+
+ FD_SET(bif->fullbrc_sock, &receive_wait_set);
+
+ }
+ }
+ }
+
+ list_for_each( list_pos, &cb_fd_list ) {
+
+ struct cb_fd_node *cdn = list_entry( list_pos, struct cb_fd_node, list );
+
+ receive_max_sock = MAX( receive_max_sock, cdn->fd );
+
+ FD_SET( cdn->fd, &receive_wait_set );
+
+ }
+
+}
+
+
+
+
+
+void register_task( uint32_t timeout, void (* task) (void *), void *data )
+{
+
+ assertion(-500475, (remove_task(task, data) == FAILURE));
+
+ struct list_node *list_pos, *prev_pos = (struct list_node *)&task_list;
+ struct task_node *tmp_tn = NULL;
+
+
+ //TODO: allocating and freeing tn and tn->data may be much faster when done by registerig function..
+ struct task_node *tn = debugMalloc( sizeof( struct task_node ), -300034 );
+ memset( tn, 0, sizeof(struct task_node) );
+
+ tn->expire = bmx_time + timeout;
+ tn->task = task;
+ tn->data = data;
+
+
+ list_for_each( list_pos, &task_list ) {
+
+ tmp_tn = list_entry( list_pos, struct task_node, list );
+
+ if ( GREAT_U32(tmp_tn->expire, tn->expire) ) {
+
+ list_add_after(&task_list, prev_pos, &tn->list);
+ break;
+
+ }
+
+ prev_pos = &tmp_tn->list;
+
+ }
+
+ if ( ( tmp_tn == NULL ) || ( LSEQ_U32(tmp_tn->expire, tn->expire) ))
+ list_add_tail(&task_list, &tn->list);
+
+}
+
+IDM_T remove_task( void (* task) (void *), void *data ) {
+
+ struct list_node *list_pos, *tmp_pos, *prev_pos = (struct list_node*)&task_list;
+ IDM_T ret = FAILURE;
+
+ list_for_each_safe( list_pos, tmp_pos, &task_list ) {
+
+ struct task_node *tn = list_entry( list_pos, struct task_node, list );
+
+ if ( tn->task == task && tn->data == data ) {
+
+ list_del_next(&task_list, prev_pos);
+
+ debugFree( tn, -300080 );
+#ifdef NO_PARANOIA
+ return SUCCESS;
+#else
+ assertion(-500474, (ret == FAILURE));
+ ret = SUCCESS;
+#endif
+
+ } else {
+
+ prev_pos = list_pos;
+ }
+ }
+
+ return ret;
+}
+
+
+uint32_t whats_next( void ) {
+
+ struct list_node *list_pos, *tmp_pos, *prev_pos = (struct list_node*)&task_list;
+
+ paranoia( -500175, sim_paranoia );
+
+ list_for_each_safe( list_pos, tmp_pos, &task_list ) {
+
+ struct task_node *tn = list_entry( list_pos, struct task_node, list );
+
+ if ( LSEQ_U32( tn->expire, bmx_time ) ) {
+
+
+ list_del_next( &task_list, prev_pos );
+
+ (*(tn->task)) (tn->data);
+
+ debugFree( tn, -300081 );
+
+ CHECK_INTEGRITY();
+
+ return 0;
+
+ } else {
+
+ return tn->expire - bmx_time;
+ }
+ }
+
+ return MAX_SELECT_TIMEOUT_MS;
+}
+
+
+static int open_ifevent_netlink_sk( void ) {
+
+ struct sockaddr_nl sa;
+ int32_t unix_opts;
+ memset (&sa, 0, sizeof(sa));
+ sa.nl_family = AF_NETLINK;
+ sa.nl_groups |= RTMGRP_IPV4_IFADDR;
+ sa.nl_groups |= RTMGRP_LINK; // (this can result in select storms with buggy wlan devices
+
+ if ( ( ifevent_sk = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE) ) < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "can't create af_netlink socket for reacting on if up/down events: %s",
+ strerror(errno) );
+ ifevent_sk = 0;
+ return -1;
+ }
+
+
+ unix_opts = fcntl( ifevent_sk, F_GETFL, 0 );
+ fcntl( ifevent_sk, F_SETFL, unix_opts | O_NONBLOCK );
+
+ if ( ( bind( ifevent_sk, (struct sockaddr*)&sa, sizeof(sa) ) ) < 0 ) {
+ dbg( DBGL_SYS, DBGT_ERR, "can't bind af_netlink socket for reacting on if up/down events: %s",
+ strerror(errno) );
+ ifevent_sk = 0;
+ return -1;
+ }
+
+ change_selects();
+
+ return ifevent_sk;
+}
+
+static void close_ifevent_netlink_sk( void ) {
+
+ if ( ifevent_sk > 0 )
+ close( ifevent_sk );
+
+ ifevent_sk = 0;
+}
+
+static void recv_ifevent_netlink_sk( void ) {
+ char buf[4096]; //test this with a very small value !!
+
+ struct sockaddr_nl sa;
+
+ struct iovec iov;
+
+ memset(&iov, 0, sizeof (struct iovec));
+
+ iov.iov_base = buf;
+ iov.iov_len = sizeof (buf);
+
+ struct msghdr msg; // = {(void *) & sa, sizeof (sa), &iov, 1, NULL, 0, 0};
+ memset( &msg, 0, sizeof( struct msghdr));
+ msg.msg_name = (void *)&sa;
+ msg.msg_namelen = sizeof(sa); /* Length of address data. */
+ msg.msg_iov = &iov; /* Vector of data to send/receive into. */
+ msg.msg_iovlen = 1; /* Number of elements in the vector. */
+
+ while( recvmsg (ifevent_sk, &msg, 0) > 0 );
+
+ //so fare I just want to consume the pending message...
+}
+
+
+
+
+
+
+
+
+
+void wait4Event( uint32_t timeout ) {
+
+ static struct packet_buff pb;
+
+ uint32_t last_get_time_result = 0;
+
+ static uint32_t addr_len = sizeof(struct sockaddr_in);
+
+ uint32_t return_time = bmx_time + timeout;
+ struct timeval tv;
+ struct list_node *list_pos;
+ int selected;
+ fd_set tmp_wait_set;
+
+
+loop4Event:
+
+ while ( GREAT_U32(return_time, bmx_time) ) {
+
+ check_selects();
+
+ memcpy( &tmp_wait_set, &receive_wait_set, sizeof(fd_set) );
+
+ tv.tv_sec = (return_time - bmx_time) / 1000;
+ tv.tv_usec = ( (return_time - bmx_time) % 1000 ) * 1000;
+
+ selected = select( receive_max_sock + 1, &tmp_wait_set, NULL, NULL, &tv );
+
+ upd_time( &(pb.tv_stamp) );
+
+ //omit debugging here since event could be a closed -d4 ctrl socket
+ //which should be removed before debugging
+ //dbgf_all( DBGT_INFO, "timeout %d", timeout );
+
+ if ( bmx_time < last_get_time_result ) {
+
+ last_get_time_result = bmx_time;
+ dbg( DBGL_SYS, DBGT_WARN, "detected Timeoverlap..." );
+
+ goto wait4Event_end;
+ }
+
+ last_get_time_result = bmx_time;
+
+ if ( selected < 0 ) {
+
+ dbg( DBGL_SYS, DBGT_WARN, //happens when receiving SIGHUP
+ "can't select! Waiting a moment! errno: %s", strerror(errno) );
+
+ wait_sec_msec( 0, 1 );
+ upd_time( NULL );
+
+ goto wait4Event_end;
+
+ }
+
+ if ( selected == 0 ) {
+
+ //Often select returns just a few milliseconds before being scheduled
+ if ( LESS_U32( return_time, (bmx_time + 10) ) ) {
+
+ //cheating time :-)
+ bmx_time = return_time;
+
+ goto wait4Event_end;
+ }
+
+ //if ( LESS_U32( return_time, bmx_time ) )
+ dbg_mute( 50, DBGL_CHANGES, DBGT_WARN,
+ "select() returned %d without reason!! return_time %d, curr_time %d",
+ selected, return_time, bmx_time );
+
+ goto loop4Event;
+ }
+
+ // check for changed interface status...
+ if ( FD_ISSET( ifevent_sk, &tmp_wait_set ) ) {
+
+ dbg_mute( 40, DBGL_CHANGES, DBGT_INFO,
+ "select() indicated changed interface status! Going to check interfaces!" );
+
+ recv_ifevent_netlink_sk( );
+
+ //do NOT delay checking of interfaces to not miss ifdown/up of interfaces !!
+ dev_check();
+
+ goto wait4Event_end;
+ }
+
+
+ // check for received packets...
+ struct avl_node *it = NULL;
+ while ((pb.iif = avl_iterate_item(&dev_ip4_tree, &it))) {
+
+ if ( pb.iif->linklayer == VAL_DEV_LL_LO )
+ continue;
+
+ if ( FD_ISSET( pb.iif->netwbrc_sock, &tmp_wait_set ) ) {
+
+ pb.unicast = NO;
+
+ errno=0;
+ pb.total_length = recvfrom( pb.iif->netwbrc_sock, pb.packet_in,
+ sizeof(pb.packet_in) - 1, 0,
+ (struct sockaddr *)&pb.addr, &addr_len );
+
+ if ( pb.total_length < 0 && ( errno == EWOULDBLOCK || errno == EAGAIN ) ) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "sock returned %d errno %d: %s",
+ pb.total_length, errno, strerror(errno) );
+
+ continue;
+ }
+
+ ioctl(pb.iif->netwbrc_sock, SIOCGSTAMP, &(pb.tv_stamp)) ;
+
+ rx_packet( &pb );
+
+ if ( --selected == 0 )
+ goto loop4Event;
+
+ }
+
+ if ( FD_ISSET( pb.iif->fullbrc_sock, &tmp_wait_set ) ) {
+
+ pb.unicast = NO;
+
+ errno=0;
+ pb.total_length = recvfrom( pb.iif->fullbrc_sock, pb.packet_in,
+ sizeof(pb.packet_in) - 1, 0,
+ (struct sockaddr *)&pb.addr, &addr_len );
+
+ if ( pb.total_length < 0 && ( errno == EWOULDBLOCK || errno == EAGAIN ) ) {
+
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "sock returned %d errno %d: %s",
+ pb.total_length, errno, strerror(errno) );
+
+ continue;
+ }
+
+ ioctl(pb.iif->fullbrc_sock, SIOCGSTAMP, &(pb.tv_stamp)) ;
+
+ rx_packet( &pb );
+
+ if ( --selected == 0 )
+ goto loop4Event;
+
+ }
+
+
+ if ( FD_ISSET( pb.iif->unicast_sock, &tmp_wait_set ) ) {
+
+ pb.unicast = YES;
+
+ struct msghdr msghdr;
+ struct iovec iovec;
+ char buf[4096];
+ struct cmsghdr *cp;
+ struct timeval *tv_stamp = NULL;
+
+ iovec.iov_base = pb.packet_in;
+ iovec.iov_len = sizeof(pb.packet_in) - 1;
+
+ msghdr.msg_name = (struct sockaddr *)&pb.addr;
+ msghdr.msg_namelen = addr_len;
+ msghdr.msg_iov = &iovec;
+ msghdr.msg_iovlen = 1;
+ msghdr.msg_control = buf;
+ msghdr.msg_controllen = sizeof( buf );
+ msghdr.msg_flags = 0;
+
+ errno=0;
+
+ pb.total_length = recvmsg( pb.iif->unicast_sock, &msghdr, MSG_DONTWAIT );
+
+ if ( pb.total_length < 0 && ( errno == EWOULDBLOCK || errno == EAGAIN ) ) {
+ dbgf(DBGL_SYS, DBGT_WARN,
+ "sock returned %d errno %d: %s",
+ pb.total_length, errno, strerror(errno) );
+ continue;
+ }
+
+#ifdef SO_TIMESTAMP
+ for (cp = CMSG_FIRSTHDR(&msghdr); cp; cp = CMSG_NXTHDR(&msghdr, cp)) {
+
+ if ( cp->cmsg_type == SO_TIMESTAMP &&
+ cp->cmsg_level == SOL_SOCKET &&
+ cp->cmsg_len >= CMSG_LEN(sizeof(struct timeval)) ) {
+
+ tv_stamp = (struct timeval*)CMSG_DATA(cp);
+ break;
+ }
+ }
+#endif
+ if ( tv_stamp == NULL )
+ ioctl( pb.iif->unicast_sock, SIOCGSTAMP, &(pb.tv_stamp) );
+ else
+ timercpy( tv_stamp, &(pb.tv_stamp) );
+
+ rx_packet( &pb );
+
+ if ( --selected == 0)
+ goto loop4Event;
+ //goto wait4Event_end;
+
+ }
+
+ }
+
+loop4ActivePlugins:
+
+ // check active plugins...
+ list_for_each( list_pos, &cb_fd_list ) {
+
+ struct cb_fd_node *cdn = list_entry( list_pos, struct cb_fd_node, list );
+
+ if ( FD_ISSET( cdn->fd, &tmp_wait_set ) ) {
+
+ FD_CLR( cdn->fd, &tmp_wait_set );
+
+ (*(cdn->cb_fd_handler)) (cdn->fd);
+
+ // list might have changed, due to unregistered handlers, reiterate NOW
+ //TBD: check if fd was really consumed !
+ if ( --selected == 0 )
+ goto loop4Event;
+ //goto wait4Event_end;
+
+ goto loop4ActivePlugins;
+ }
+
+ }
+
+
+ // check for new control clients...
+ if ( FD_ISSET( unix_sock, &tmp_wait_set ) ) {
+
+ dbgf_all( DBGT_INFO, "new control client..." );
+
+ accept_ctrl_node();
+
+ if ( --selected == 0 )
+ goto loop4Event;
+
+ //goto wait4Event_end;
+ }
+
+
+loop4ActiveClients:
+ // check for all connected control clients...
+ list_for_each( list_pos, &ctrl_list ) {
+
+ struct ctrl_node *client = list_entry( list_pos, struct ctrl_node, list );
+
+ if ( FD_ISSET( client->fd, &tmp_wait_set ) ) {
+
+ FD_CLR( client->fd, &tmp_wait_set );
+
+ //omit debugging here since event could be a closed -d4 ctrl socket
+ //which should be removed before debugging
+ //dbgf_all( DBGT_INFO, "got msg from control client");
+
+ handle_ctrl_node( client );
+
+ --selected;
+
+ // return straight because client might be removed and list might have changed.
+ goto loop4ActiveClients;
+ }
+
+ }
+
+
+
+ if ( selected )
+ dbg( DBGL_CHANGES, DBGT_WARN,
+ "select() returned with %d unhandled event(s)!! return_time %d, curr_time %d",
+ selected, return_time, bmx_time );
+
+ break;
+ }
+
+wait4Event_end:
+
+ dbgf_all( DBGT_INFO, "end of function");
+
+ return;
+}
+
+
+
+
+
+static struct opt_type schedule_options[]=
+{
+// ord parent long_name shrt Attributes *ival min max default *func,*syntax,*help
+
+ {ODI,0,0, 0, 5,0,0,0,0,0, 0, 0, 0, 0, 0,
+ 0, "\nScheduling options:"}
+
+#ifndef LESS_OPTIONS
+#ifndef NO_PARANOIA
+ ,{ODI,0,"simulate_cleanup", 0, 5,A_PS1,A_ADM,A_DYI,A_ARG,A_ANY, &sim_paranoia, NO, YES, DEF_SIM_PARA, 0,
+ ARG_VALUE_FORM, "simulate paranoia and cleanup_all for testing"}
+#endif
+#endif
+
+};
+
+
+
+void init_schedule( void ) {
+
+#ifdef BMX2_TODO
+ memset( &my_pip_extension_packet, 0, sizeof(struct ext_packet) );
+ my_pip_extension_packet.EXT_FIELD_MSG = YES;
+ my_pip_extension_packet.EXT_FIELD_TYPE = EXT_TYPE_64B_PIP;
+#endif
+ if ( open_ifevent_netlink_sk() < 0 )
+ cleanup_all( -500150 );
+
+ register_options_array( schedule_options, sizeof( schedule_options ) );
+}
+
+
+
+void cleanup_schedule( void ) {
+
+
+ struct task_node *tn;
+
+ while ( (tn = list_rem_head( &task_list )))
+ debugFree(tn, -300082);
+
+/*
+ struct list_node *list_pos_tmp, *list_pos;
+ list_for_each_safe( list_pos, list_pos_tmp, &task_list ) {
+
+ struct task_node *tn = list_entry( list_pos, struct task_node, list );
+
+ list_del_next( &task_list, (struct list_node *)&task_list );
+
+ debugFree(tn, -300082);
+ }
+*/
+
+ close_ifevent_netlink_sk();
+}
Added: trunk/bmx/schedule.h
===================================================================
--- trunk/bmx/schedule.h (rev 0)
+++ trunk/bmx/schedule.h 2010-06-03 20:07:47 UTC (rev 1683)
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2010 BMX contributors:
+ * Axel Neumann
+ * 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
+ */
+
+
+
+
+void init_schedule( void );
+void change_selects( void );
+void cleanup_schedule( void );
+void register_task( uint32_t timeout, void (* task) (void *), void *data );
+IDM_T remove_task(void (* task) (void *), void *data);
+uint32_t whats_next( void );
+void wait4Event( uint32_t timeout );
+
1
0