B.A.T.M.A.N June 2014

b.a.t.m.a.n@lists.open-mesh.org

34 participants
53 discussions

[B.A.T.M.A.N.] [PATCHv2] batctl: tcpdump - parse TVLV containers
by Antonio Quartulli 19 Jul '14

19 Jul '14

From: Antonio Quartulli <antonio(a)open-mesh.com> OGMs and unicast TVLV packets carry TVLV containers as payload. With this patch such containers are now parsed and the relevant information is printed to screen. Moreover, the parts of code that have been touched by this patch have also been re-arranged a bit from the style point of view. Signed-off-by: Antonio Quartulli <antonio(a)open-mesh.com> --- changes since v1: - remove all the style changes - make tvlv_len of type ssize_t in dump_batman_iv_ogm() main.h | 7 +++ tcpdump.c | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- tcpdump.h | 1 + 3 files changed, 173 insertions(+), 5 deletions(-) diff --git a/main.h b/main.h index 2557c56..dbf7912 100644 --- a/main.h +++ b/main.h @@ -49,4 +49,11 @@ extern char module_ver_path[]; +#ifndef VLAN_VID_MASK +#define VLAN_VID_MASK 0xfff +#endif + +#define BATADV_PRINT_VID(vid) (vid & BATADV_VLAN_HAS_TAG ? \ + (int)(vid & VLAN_VID_MASK) : -1) + #endif diff --git a/tcpdump.c b/tcpdump.c index e84617e..59b46d6 100644 --- a/tcpdump.c +++ b/tcpdump.c @@ -62,8 +62,7 @@ if ((size_t)(buff_len) < (check_len)) { \ return; \ } -static unsigned short dump_level_all = DUMP_TYPE_BATOGM | DUMP_TYPE_BATICMP | DUMP_TYPE_BATUCAST | - DUMP_TYPE_BATBCAST | DUMP_TYPE_BATFRAG | DUMP_TYPE_NONBAT; +static unsigned short dump_level_all = DUMP_TYPE_BATOGM | DUMP_TYPE_BATICMP | DUMP_TYPE_BATUCAST | DUMP_TYPE_BATBCAST | DUMP_TYPE_BATUTVLV | DUMP_TYPE_BATFRAG | DUMP_TYPE_NONBAT; static unsigned short dump_level; static void parse_eth_hdr(unsigned char *packet_buff, ssize_t buff_len, int read_opt, int time_printed); @@ -83,6 +82,7 @@ static void tcpdump_usage(void) fprintf(stderr, " \t\t%3d - batman unicast packets\n", DUMP_TYPE_BATUCAST); fprintf(stderr, " \t\t%3d - batman broadcast packets\n", DUMP_TYPE_BATBCAST); fprintf(stderr, " \t\t%3d - batman fragmented packets\n", DUMP_TYPE_BATFRAG); + fprintf(stderr, " \t\t%3d - batman unicast tvlv packets\n", DUMP_TYPE_BATUTVLV); fprintf(stderr, " \t\t%3d - non batman packets\n", DUMP_TYPE_NONBAT); fprintf(stderr, " \t\t%3d - batman ogm & non batman packets\n", DUMP_TYPE_BATOGM | DUMP_TYPE_NONBAT); } @@ -99,6 +99,138 @@ static int print_time(void) return 1; } +static void batctl_tvlv_parse_gw_v1(void *buff, + ssize_t (buff_len)__attribute__((unused))) +{ + struct batadv_tvlv_gateway_data *tvlv = buff; + uint32_t down, up; + + down = ntohl(tvlv->bandwidth_down); + up = ntohl(tvlv->bandwidth_up); + + printf("\tTVLV GWv1: down %d.%.1dMbps, up %d.%1dMbps\n", + down / 10, down % 10, up / 10, up % 10); +} + +static void batctl_tvlv_parse_dat_v1(void (*buff)__attribute__((unused)), + ssize_t (buff_len)__attribute__((unused))) +{ + printf("\tTVLV DATv1: enabled\n"); +} + +static void batctl_tvlv_parse_nc_v1(void (*buff)__attribute__((unused)), + ssize_t (buff_len)__attribute__((unused))) +{ + printf("\tTVLV NCv1: enabled\n"); +} + +static void batctl_tvlv_parse_tt_v1(void *buff, + ssize_t (buff_len)__attribute__((unused))) +{ + struct batadv_tvlv_tt_data *tvlv = buff; + struct batadv_tvlv_tt_vlan_data *vlan; + int i, num_vlan, num_entry; + const char *type; + + if (tvlv->flags & BATADV_TT_OGM_DIFF) + type = "OGM DIFF"; + else if (tvlv->flags & BATADV_TT_REQUEST) + type = "TT REQUEST"; + else if (tvlv->flags & BATADV_TT_RESPONSE) + type = "TT RESPONSE"; + else + type = "UNKNOWN"; + + num_vlan = ntohs(tvlv->num_vlan); + buff_len -= sizeof(*tvlv) + sizeof(*vlan) * num_vlan; + num_entry = buff_len / sizeof(struct batadv_tvlv_tt_change); + + printf("\tTVLV TTv1: %s [%c] ttvn=%hhu vlan_num=%hu entry_num=%hu\n", + type, tvlv->flags & BATADV_TT_FULL_TABLE ? 'F' : '.', + tvlv->ttvn, num_vlan, num_entry); + + vlan = (struct batadv_tvlv_tt_vlan_data *)(tvlv + 1); + for (i = 0; i < num_vlan; i++) { + printf("\t\tVLAN ID %hd, crc %#.8x\n", + BATADV_PRINT_VID(ntohs(vlan->vid)), + ntohl(vlan->crc)); + vlan++; + } +} + +static void batctl_tvlv_parse_roam_v1(void *buff, + ssize_t (buff_len)__attribute__((unused))) +{ + struct batadv_tvlv_roam_adv *tvlv = buff; + + printf("\tTVLV ROAMv1: client %s, VLAN ID %d\n", + get_name_by_macaddr((struct ether_addr *)tvlv->client, NO_FLAGS), + BATADV_PRINT_VID(ntohs(tvlv->vid))); +} + +typedef void (*batctl_tvlv_parser_t)(void *buff, ssize_t buff_len); + +/* location [i][j] contains the parsing function for TVLV of type 'i' and + * version 'j + 1' + */ +batctl_tvlv_parser_t tvlv_parsers[][1] = { + [BATADV_TVLV_GW][0] = batctl_tvlv_parse_gw_v1, + [BATADV_TVLV_DAT][0] = batctl_tvlv_parse_dat_v1, + [BATADV_TVLV_NC][0] = batctl_tvlv_parse_nc_v1, + [BATADV_TVLV_TT][0] = batctl_tvlv_parse_tt_v1, + [BATADV_TVLV_ROAM][0] = batctl_tvlv_parse_roam_v1, +}; + +static void dump_batman_ucast_tvlv(unsigned char *packet_buff, ssize_t buff_len, + int read_opt, int time_printed) +{ + struct batadv_unicast_tvlv_packet *tvlv_packet; + struct batadv_tvlv_hdr *tvlv_hdr; + struct ether_header *ether_header; + struct ether_addr *src, *dst; + batctl_tvlv_parser_t parser; + ssize_t check_len, tvlv_len, len; + uint8_t *ptr; + + check_len = (size_t)buff_len - sizeof(struct ether_header); + + LEN_CHECK(check_len, sizeof(*tvlv_packet), "BAT TVLV"); + check_len -= sizeof(*tvlv_packet); + + ether_header = (struct ether_header *)packet_buff; + tvlv_packet = (struct batadv_unicast_tvlv_packet *)(ether_header + 1); + + LEN_CHECK(check_len, (size_t)ntohs(tvlv_packet->tvlv_len), + "BAT TVLV (containers)"); + + if (!time_printed) + time_printed = print_time(); + + src = (struct ether_addr *)tvlv_packet->src; + printf("BAT %s > ", get_name_by_macaddr(src, read_opt)); + + dst = (struct ether_addr *)tvlv_packet->dst; + tvlv_len = ntohs(tvlv_packet->tvlv_len); + printf("%s: TVLV, len %zu, tvlv_len %zu, ttl %hhu\n", + get_name_by_macaddr(dst, read_opt), + buff_len - sizeof(struct ether_header), tvlv_len, + tvlv_packet->ttl); + + ptr = (uint8_t *)(tvlv_packet + 1); + + while (tvlv_len > 0) { + tvlv_hdr = (struct batadv_tvlv_hdr *)ptr; + len = ntohs(tvlv_hdr->len); + + parser = tvlv_parsers[tvlv_hdr->type][tvlv_hdr->version - 1]; + parser(tvlv_hdr + 1, len); + + /* go to the next container */ + ptr = (uint8_t *)(tvlv_hdr + 1) + len; + tvlv_len -= sizeof(*tvlv_hdr) + len; + } +} + static int dump_bla2_claim(struct ether_header *eth_hdr, struct ether_arp *arphdr, int read_opt) { @@ -482,8 +614,13 @@ static void dump_batman_iv_ogm(unsigned char *packet_buff, ssize_t buff_len, int { struct ether_header *ether_header; struct batadv_ogm_packet *batman_ogm_packet; + struct batadv_tvlv_hdr *tvlv_hdr; + ssize_t tvlv_len, len, check_len; + batctl_tvlv_parser_t parser; + uint8_t *ptr; - LEN_CHECK((size_t)buff_len - sizeof(struct ether_header), sizeof(struct batadv_ogm_packet), "BAT IV OGM"); + check_len = (size_t)buff_len - sizeof(struct ether_header); + LEN_CHECK(check_len, sizeof(struct batadv_ogm_packet), "BAT IV OGM"); ether_header = (struct ether_header *)packet_buff; batman_ogm_packet = (struct batadv_ogm_packet *)(packet_buff + sizeof(struct ether_header)); @@ -494,14 +631,32 @@ static void dump_batman_iv_ogm(unsigned char *packet_buff, ssize_t buff_len, int printf("BAT %s: ", get_name_by_macaddr((struct ether_addr *)batman_ogm_packet->orig, read_opt)); - printf("OGM IV via neigh %s, seq %u, tq %3d, ttl %2d, v %d, flags [%c%c%c], length %zu\n", + tvlv_len = ntohs(batman_ogm_packet->tvlv_len); + printf("OGM IV via neigh %s, seq %u, tq %3d, ttl %2d, v %d, flags [%c%c%c], length %zu, tvlv_len %zu\n", get_name_by_macaddr((struct ether_addr *)ether_header->ether_shost, read_opt), ntohl(batman_ogm_packet->seqno), batman_ogm_packet->tq, batman_ogm_packet->ttl, batman_ogm_packet->version, (batman_ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP ? 'N' : '.'), (batman_ogm_packet->flags & BATADV_DIRECTLINK ? 'D' : '.'), (batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP ? 'F' : '.'), - (size_t)buff_len - sizeof(struct ether_header)); + check_len, tvlv_len); + + check_len -= sizeof(struct batadv_ogm_packet); + LEN_CHECK(check_len, tvlv_len, "BAT OGM TVLV (containers)"); + + ptr = (uint8_t *)(batman_ogm_packet + 1); + + while (tvlv_len > 0) { + tvlv_hdr = (struct batadv_tvlv_hdr *)ptr; + len = ntohs(tvlv_hdr->len); + + parser = tvlv_parsers[tvlv_hdr->type][tvlv_hdr->version - 1]; + parser(tvlv_hdr + 1, len); + + /* go to the next container */ + ptr = (uint8_t *)(tvlv_hdr + 1) + len; + tvlv_len -= sizeof(*tvlv_hdr) + len; + } } static void dump_batman_icmp(unsigned char *packet_buff, ssize_t buff_len, int read_opt, int time_printed) @@ -683,6 +838,11 @@ static void parse_eth_hdr(unsigned char *packet_buff, ssize_t buff_len, int read case BATADV_UNICAST_4ADDR: if (dump_level & DUMP_TYPE_BATUCAST) dump_batman_4addr(packet_buff, buff_len, read_opt, time_printed); + case BATADV_UNICAST_TVLV: + if ((dump_level & DUMP_TYPE_BATUCAST) || + (dump_level & DUMP_TYPE_BATUTVLV)) + dump_batman_ucast_tvlv(packet_buff, buff_len, + read_opt, time_printed); break; default: fprintf(stderr, "Warning - packet contains unknown batman packet type: 0x%02x\n", batman_ogm_packet->packet_type); diff --git a/tcpdump.h b/tcpdump.h index cfb1c69..5d936f2 100644 --- a/tcpdump.h +++ b/tcpdump.h @@ -41,6 +41,7 @@ #define DUMP_TYPE_BATICMP 2 #define DUMP_TYPE_BATUCAST 4 #define DUMP_TYPE_BATBCAST 8 +#define DUMP_TYPE_BATUTVLV 16 #define DUMP_TYPE_BATFRAG 32 #define DUMP_TYPE_NONBAT 128 -- 1.8.5.5

2 1

[B.A.T.M.A.N.] [PATCH 2/2] batman-adv: Init and use batman interface with correc netns.
by Daniel Ehlers 14 Jul '14

14 Jul '14

Enables us to use batman-adv inside of network namespaces. Unfortunately it does not enable us to use multiple batX interfaces in different namespaces. This limitation results from using debugfs and its unawareness of namespaces. Signed-off-by: Daniel Ehlers <danielehlers(a)mindeye.net> --- hard-interface.c | 10 ++++++---- hard-interface.h | 2 +- soft-interface.c | 8 ++++++-- soft-interface.h | 2 +- sysfs.c | 4 +++- translation-table.c | 4 +++- 6 files changed, 20 insertions(+), 10 deletions(-) diff --git a/hard-interface.c b/hard-interface.c index b851cc5..c3497de 100644 --- a/hard-interface.c +++ b/hard-interface.c @@ -31,6 +31,7 @@ #include <linux/if_arp.h> #include <linux/if_ether.h> +#include <net/net_namespace.h> void batadv_hardif_free_rcu(struct rcu_head *rcu) { @@ -76,6 +77,7 @@ out: static bool batadv_is_on_batman_iface(const struct net_device *net_dev) { struct net_device *parent_dev; + struct net *net = dev_net(net_dev); bool ret; /* check if this is a batman-adv mesh interface */ @@ -87,7 +89,7 @@ static bool batadv_is_on_batman_iface(const struct net_device *net_dev) return false; /* recurse over the parent device */ - parent_dev = __dev_get_by_index(&init_net, net_dev->iflink); + parent_dev = __dev_get_by_index(net, net_dev->iflink); /* if we got a NULL parent_dev there is something broken.. */ if (WARN(!parent_dev, "Cannot find parent device")) return false; @@ -365,7 +367,7 @@ static int batadv_master_del_slave(struct batadv_hard_iface *slave, } int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, - const char *iface_name) + struct net *net, const char *iface_name) { struct batadv_priv *bat_priv; struct net_device *soft_iface, *master; @@ -379,10 +381,10 @@ int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, if (!atomic_inc_not_zero(&hard_iface->refcount)) goto out; - soft_iface = dev_get_by_name(&init_net, iface_name); + soft_iface = dev_get_by_name(net, iface_name); if (!soft_iface) { - soft_iface = batadv_softif_create(iface_name); + soft_iface = batadv_softif_create(net, iface_name); if (!soft_iface) { ret = -ENOMEM; diff --git a/hard-interface.h b/hard-interface.h index 1918cd5..00ba971 100644 --- a/hard-interface.h +++ b/hard-interface.h @@ -44,7 +44,7 @@ bool batadv_is_wifi_iface(int ifindex); struct batadv_hard_iface* batadv_hardif_get_by_netdev(const struct net_device *net_dev); int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, - const char *iface_name); + struct net *net, const char *iface_name); void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface, enum batadv_hard_if_cleanup autodel); void batadv_hardif_remove_interfaces(void); diff --git a/soft-interface.c b/soft-interface.c index dcaf02b..79c7243 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -35,6 +35,7 @@ #include "multicast.h" #include "bridge_loop_avoidance.h" #include "network-coding.h" +#include <net/net_namespace.h> static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd); @@ -822,13 +823,14 @@ static int batadv_softif_slave_add(struct net_device *dev, struct net_device *slave_dev) { struct batadv_hard_iface *hard_iface; + struct net *net = dev_net(dev); int ret = -EINVAL; hard_iface = batadv_hardif_get_by_netdev(slave_dev); if (!hard_iface || hard_iface->soft_iface != NULL) goto out; - ret = batadv_hardif_enable_interface(hard_iface, dev->name); + ret = batadv_hardif_enable_interface(hard_iface, net, dev->name); out: if (hard_iface) @@ -927,7 +929,7 @@ static void batadv_softif_init_early(struct net_device *dev) memset(priv, 0, sizeof(*priv)); } -struct net_device *batadv_softif_create(const char *name) +struct net_device *batadv_softif_create(struct net *net, const char *name) { struct net_device *soft_iface; int ret; @@ -937,6 +939,8 @@ struct net_device *batadv_softif_create(const char *name) if (!soft_iface) return NULL; + dev_net_set(soft_iface, net); + soft_iface->rtnl_link_ops = &batadv_link_ops; ret = register_netdevice(soft_iface); diff --git a/soft-interface.h b/soft-interface.h index dbab22f..c213c80 100644 --- a/soft-interface.h +++ b/soft-interface.h @@ -22,7 +22,7 @@ int batadv_skb_head_push(struct sk_buff *skb, unsigned int len); void batadv_interface_rx(struct net_device *soft_iface, struct sk_buff *skb, struct batadv_hard_iface *recv_if, int hdr_size, struct batadv_orig_node *orig_node); -struct net_device *batadv_softif_create(const char *name); +struct net_device *batadv_softif_create(struct net *net, const char *name); void batadv_softif_destroy_sysfs(struct net_device *soft_iface); int batadv_softif_is_valid(const struct net_device *net_dev); extern struct rtnl_link_ops batadv_link_ops; diff --git a/sysfs.c b/sysfs.c index fc47baa..cbd5534 100644 --- a/sysfs.c +++ b/sysfs.c @@ -25,6 +25,7 @@ #include "soft-interface.h" #include "gateway_common.h" #include "gateway_client.h" +#include <net/net_namespace.h> static struct net_device *batadv_kobj_to_netdev(struct kobject *obj) { @@ -754,6 +755,7 @@ static ssize_t batadv_store_mesh_iface(struct kobject *kobj, size_t count) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); + struct net *net = dev_net(net_dev); struct batadv_hard_iface *hard_iface; int status_tmp = -1; int ret = count; @@ -797,7 +799,7 @@ static ssize_t batadv_store_mesh_iface(struct kobject *kobj, batadv_hardif_disable_interface(hard_iface, BATADV_IF_CLEANUP_AUTO); - ret = batadv_hardif_enable_interface(hard_iface, buff); + ret = batadv_hardif_enable_interface(hard_iface, net, buff); unlock: rtnl_unlock(); diff --git a/translation-table.c b/translation-table.c index 5f59e7f..08d7e7d 100644 --- a/translation-table.c +++ b/translation-table.c @@ -27,6 +27,7 @@ #include "multicast.h" #include <linux/crc32c.h> +#include <net/net_namespace.h> /* hash class keys */ static struct lock_class_key batadv_tt_local_hash_lock_class_key; @@ -513,6 +514,7 @@ bool batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, struct batadv_tt_global_entry *tt_global = NULL; struct batadv_softif_vlan *vlan; struct net_device *in_dev = NULL; + struct net *net = dev_net(soft_iface); struct hlist_head *head; struct batadv_tt_orig_list_entry *orig_entry; int hash_added, table_size, packet_size_max; @@ -521,7 +523,7 @@ bool batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, uint32_t match_mark; if (ifindex != BATADV_NULL_IFINDEX) - in_dev = dev_get_by_index(&init_net, ifindex); + in_dev = dev_get_by_index(net, ifindex); tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid); -- 1.9.2

4 5

[B.A.T.M.A.N.] [PATCH] batman-adv: Use kasprintf
by Himangi Saraogi 08 Jul '14

08 Jul '14

kasprintf combines kmalloc and sprintf, and takes care of the size calculation itself. The semantic patch that makes this change is as follows: // <smpl> @@ expression a,flag; expression list args; statement S; @@ a = - \(kmalloc\|kzalloc\)(...,flag) + kasprintf(flag,args) <... when != a if (a == NULL || ...) S ...> - sprintf(a,args); // </smpl> Signed-off-by: Himangi Saraogi <himangi774(a)gmail.com> Acked-by: Julia Lawall <julia.lawall(a)lip6.fr> --- net/batman-adv/sysfs.c | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/net/batman-adv/sysfs.c b/net/batman-adv/sysfs.c index fc47baa..f40cb04 100644 --- a/net/batman-adv/sysfs.c +++ b/net/batman-adv/sysfs.c @@ -900,32 +900,24 @@ int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type, bat_kobj = &bat_priv->soft_iface->dev.kobj; - uevent_env[0] = kmalloc(strlen(BATADV_UEV_TYPE_VAR) + - strlen(batadv_uev_type_str[type]) + 1, - GFP_ATOMIC); + uevent_env[0] = kasprintf(GFP_ATOMIC, + "%s%s", BATADV_UEV_TYPE_VAR, + batadv_uev_type_str[type]); if (!uevent_env[0]) goto out; - sprintf(uevent_env[0], "%s%s", BATADV_UEV_TYPE_VAR, - batadv_uev_type_str[type]); - - uevent_env[1] = kmalloc(strlen(BATADV_UEV_ACTION_VAR) + - strlen(batadv_uev_action_str[action]) + 1, - GFP_ATOMIC); + uevent_env[1] = kasprintf(GFP_ATOMIC, + "%s%s", BATADV_UEV_ACTION_VAR, + batadv_uev_action_str[action]); if (!uevent_env[1]) goto out; - sprintf(uevent_env[1], "%s%s", BATADV_UEV_ACTION_VAR, - batadv_uev_action_str[action]); - /* If the event is DEL, ignore the data field */ if (action != BATADV_UEV_DEL) { - uevent_env[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR) + - strlen(data) + 1, GFP_ATOMIC); + uevent_env[2] = kasprintf(GFP_ATOMIC, + "%s%s", BATADV_UEV_DATA_VAR, data); if (!uevent_env[2]) goto out; - - sprintf(uevent_env[2], "%s%s", BATADV_UEV_DATA_VAR, data); } ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env); -- 1.9.1

5 5

[B.A.T.M.A.N.] Fwd: Re: increasing BATADV_FRAG_MAX_FRAGMENTS
by Christof Schulze 02 Jul '14

02 Jul '14

Dirk is not on this list, so I am forwarding the information of ihs experiment. ---------- Forwarded Message ---------- Hi, Marek! Please forward this as appropriate. Am 30.06.2014 um 08:08 schrieb Marek Lindner <mareklindner(a)neomailbox.ch>: > > During an experiment it was found, that > > BATADV_FRAG_MAX_FRAGMENTS=16 allows ~72 clients to be connected to > > one single access point. > would you mind sharing some details regarding the experiments you > performed ? The reason for this question is that there is no 72 > client limit we know of (unless fragmentation was disabled). I put a freifunk router with batman.adv in a room with 300 conference participants (with about 2 WLAN clients p.p.) as an emergency network access means for a failing venue network. The batman client statistic showed a very untypical hard clip at 72/74 batman clients and new wlan clients seem to time-out without any network traffic like this: Thu Jun 26 15:33:44 2014 kern.warn kernel: [15577.090000] net_ratelimit: 1121 callbacks suppressed At the same time, I'm seeing a lot of these: Thu Jun 26 15:31:54 2014 daemon.info hostapd: wlan0-1: STA b4:f0:ab:9b:b0:94 IEEE 802.11: associated (aid 7) Thu Jun 26 15:32:54 2014 daemon.info hostapd: wlan0-1: STA b4:f0:ab:9b:b0:94 IEEE 802.11: disassociated Thu Jun 26 15:32:55 2014 daemon.info hostapd: wlan0-1: STA b4:f0:ab:9b:b0:94 IEEE 802.11: deauthenticated due to inactivity (timer DEAUTH/REMOVE) There is no hostapd client limit configured and otherwise (as I understand it), clients would be have been rejected and not time-out without access to the DHCP-Server (only accessible via batman). Unfortunately, that setup is no longer available for more testing. Any ideas? Dirk -- () ascii ribbon campaign - against html e-mail /\ against proprietary attachments

3 3

Re: [B.A.T.M.A.N.] Need a recommendation for a USB wifi dongle that is known to work with batman.
by Daniel 01 Jul '14

01 Jul '14

hi On Jun 30, 2014 11:45 PM, cmsv <cmsv(a)wirelesspt.net> wrote: > > Tp-Link TL-WN 722 N works but has nothing to do with batman-adv. The > support comes from openwrt or whatever linux distro one wants to use. ...with up to 7 ad-hoc peers or ap clients associated and no more, due to firmware limitations of the ath9k_htc chipset... and yes, this applies to all ath9k_htc-based dongles. sorry to name a chipset and not a product name, but i got no idea what products are available in the markets around you. i'd go with something containing rt2800usb if it really got to be usb wifi (which generally should be avoided imho). performance is not great, but at least it works. > > On 06/30/2014 05:17 PM, david.moffatt(a)nokia.com wrote: > > > > HI all, > > > > If anyone is using batman with a USB wifi dongle could you post the name > > of the dongle you are using? > > If it required a special driver or firmware please let me know where you > > got it. > > Also please give dongles names not chipsets as it is hard to know what > > chipset is in what dongles. > > > > ‹Thank in advance. > > > > David. > > > >

2 1

Re: [B.A.T.M.A.N.] Need a recommendation for a USB wifi dongle that is known to work with batman.
by david.moffatt＠nokia.com 30 Jun '14

30 Jun '14

HI all, If anyone is using batman with a USB wifi dongle could you post the name of the dongle you are using? If it required a special driver or firmware please let me know where you got it. Also please give dongles names not chipsets as it is hard to know what chipset is in what dongles. ‹Thank in advance. David.

2 1

[B.A.T.M.A.N.] increasing BATADV_FRAG_MAX_FRAGMENTS
by Christof Schulze 30 Jun '14

30 Jun '14

Hello world, During an experiment it was found, that BATADV_FRAG_MAX_FRAGMENTS=16 allows ~72 clients to be connected to one single access point. This parameter is defined in batman-adv/main.h [1] What negative side-effects should I expect when doubling that value at compile-time? Christof [1] http://lxr.free-electrons.com/source/net/batman-adv/main.h#L149 -- () ascii ribbon campaign - against html e-mail /\ against proprietary attachments

2 1

[B.A.T.M.A.N.] [PATCH 1/7] batmand: Import hash table version from alfred
by Sven Eckelmann 29 Jun '14

29 Jun '14

All new functionality, cleanup and similar things to the hash implementation were done in alfred. So import the newest version to keep it in sync. Signed-off-by: Sven Eckelmann <sven(a)narfation.org> --- hash.c | 88 +++++++++++++++++++++++++++++++++++++++++------------------------- hash.h | 69 ++++++++++++++++++++++++++++++--------------------- 2 files changed, 96 insertions(+), 61 deletions(-) diff --git a/hash.c b/hash.c index 2a9f557..7271b89 100644 --- a/hash.c +++ b/hash.c @@ -20,11 +20,11 @@ */ -#include <stdio.h> /* NULL */ #include "hash.h" +#include <stdlib.h> +#include <stdio.h> #include "allocate.h" - /* clears the hash */ void hash_init(struct hashtable_t *hash) { @@ -70,9 +70,17 @@ void hash_destroy(struct hashtable_t *hash) debugFree(hash, 1303); } +/* free hash_it_t pointer when stopping hash_iterate early */ +void hash_iterate_free(struct hash_it_t *iter_in) +{ + debugFree(iter_in, 1304); +} + /* iterate though the hash. first element is selected with iter_in NULL. - * use the returned iterator to access the elements until hash_it_t returns NULL. */ -struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_in) + * use the returned iterator to access the elements until hash_it_t returns + * NULL. */ +struct hash_it_t *hash_iterate(struct hashtable_t *hash, + struct hash_it_t *iter_in) { struct hash_it_t *iter; @@ -81,14 +89,17 @@ struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_ iter->index = -1; iter->bucket = NULL; iter->prev_bucket = NULL; - } else - iter= iter_in; + } else { + iter = iter_in; + } - /* sanity checks first (if our bucket got deleted in the last iteration): */ + /* sanity checks first (if our bucket got deleted in the last + * iteration): */ if (iter->bucket != NULL) { if (iter->first_bucket != NULL) { - /* we're on the first element and it got removed after the last iteration. */ + /* we're on the first element and it got removed after + * the last iteration. */ if ((*iter->first_bucket) != iter->bucket) { /* there are still other elements in the list */ @@ -105,9 +116,10 @@ struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_ } else if (iter->prev_bucket != NULL) { - /* we're not on the first element, and the bucket got removed after the last iteration. - * the last bucket's next pointer is not pointing to our actual bucket anymore. - * select the next. */ + /* we're not on the first element, and the bucket got + * removed after the last iteration. The last bucket's + * next pointer is not pointing to our actual bucket + * anymore. Select the next. */ if (iter->prev_bucket->next != iter->bucket) iter->bucket = iter->prev_bucket; @@ -124,7 +136,8 @@ struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_ return iter; } } - /* if not returned yet, we've reached the last one on the index and have to search forward */ + /* if not returned yet, we've reached the last one on the index and + * have to search forward */ iter->index++; /* go through the entries of the hash table */ @@ -142,12 +155,13 @@ struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_ } /* nothing to iterate over anymore */ - debugFree(iter, 1304); + hash_iterate_free(iter); return NULL; } /* allocates and clears the hash */ -struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_choose_cb choose) +struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, + hashdata_choose_cb choose) { struct hashtable_t *hash; @@ -155,8 +169,8 @@ struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_cho if (!hash) return NULL; - hash->size= size; - hash->table= debugMalloc(sizeof(struct element_t *) * size, 303); + hash->size = size; + hash->table = debugMalloc(sizeof(struct element_t *)*size, 303); if (!hash->table) { debugFree(hash, 1305); @@ -183,11 +197,11 @@ int hash_add(struct hashtable_t *hash, void *data) return -1; prev_bucket = bucket; - bucket= bucket->next; + bucket = bucket->next; } /* found the tail of the list, add new element */ - bucket = debugMalloc(sizeof(struct element_t),304); + bucket = debugMalloc(sizeof(struct element_t), 304); if (!bucket) return -1; @@ -197,17 +211,17 @@ int hash_add(struct hashtable_t *hash, void *data) bucket->next = NULL; /* and link it */ - if (prev_bucket == NULL) { + if (prev_bucket == NULL) hash->table[index] = bucket; - } else { + else prev_bucket->next = bucket; - } hash->elements++; return 0; } -/* finds data, based on the key in keydata. returns the found data on success, or NULL on error */ +/* finds data, based on the key in keydata. returns the found data on success, + * or NULL on error */ void *hash_find(struct hashtable_t *hash, void *keydata) { int index; @@ -226,20 +240,21 @@ void *hash_find(struct hashtable_t *hash, void *keydata) return NULL; } -/* remove bucket (this might be used in hash_iterate() if you already found the bucket - * you want to delete and don't need the overhead to find it again with hash_remove(). - * But usually, you don't want to use this function, as it fiddles with hash-internals. */ +/* remove bucket (this might be used in hash_iterate() if you already found + * the bucket you want to delete and don't need the overhead to find it again + * with hash_remove(). But usually, you don't want to use this function, as it + * fiddles with hash-internals. */ void *hash_remove_bucket(struct hashtable_t *hash, struct hash_it_t *hash_it_t) { void *data_save; - data_save = hash_it_t->bucket->data; /* save the pointer to the data */ + /* save the pointer to the data */ + data_save = hash_it_t->bucket->data; - if (hash_it_t->prev_bucket != NULL) { + if (hash_it_t->prev_bucket != NULL) hash_it_t->prev_bucket->next = hash_it_t->bucket->next; - } else if (hash_it_t->first_bucket != NULL) { + else if (hash_it_t->first_bucket != NULL) (*hash_it_t->first_bucket) = hash_it_t->bucket->next; - } debugFree(hash_it_t->bucket, 1306); @@ -261,7 +276,12 @@ void *hash_remove(struct hashtable_t *hash, void *data) while (hash_it_t.bucket != NULL) { if (hash->compare(hash_it_t.bucket->data, data)) { - hash_it_t.first_bucket = (hash_it_t.bucket == hash->table[hash_it_t.index] ? &hash->table[ hash_it_t.index ] : NULL); + int bucket_same; + bucket_same = (hash_it_t.bucket == + hash->table[hash_it_t.index]); + hash_it_t.first_bucket = (bucket_same ? + &hash->table[hash_it_t.index] : + NULL); return hash_remove_bucket(hash, &hash_it_t); } @@ -272,7 +292,8 @@ void *hash_remove(struct hashtable_t *hash, void *data) return NULL; } -/* resize the hash, returns the pointer to the new hash or NULL on error. removes the old hash on success. */ +/* resize the hash, returns the pointer to the new hash or NULL on error. + * removes the old hash on success. */ struct hashtable_t *hash_resize(struct hashtable_t *hash, int size) { struct hashtable_t *new_hash; @@ -292,8 +313,9 @@ struct hashtable_t *hash_resize(struct hashtable_t *hash, int size) bucket = bucket->next; } } - - hash_delete(hash, NULL); /* remove hash and eventual overflow buckets but not the content itself. */ + /* remove hash and eventual overflow buckets but not the + * content itself. */ + hash_delete(hash, NULL); return new_hash; } diff --git a/hash.h b/hash.h index 66d7162..1682eb8 100644 --- a/hash.h +++ b/hash.h @@ -28,8 +28,8 @@ typedef int (*hashdata_choose_cb)(void *, int); typedef void (*hashdata_free_cb)(void *); struct element_t { - void *data; /* pointer to the data */ - struct element_t *next; /* overflow bucket pointer */ + void *data; /* pointer to the data */ + struct element_t *next; /* overflow bucket pointer */ }; struct hash_it_t { @@ -40,56 +40,69 @@ struct hash_it_t { }; struct hashtable_t { - struct element_t **table; /* the hashtable itself, with the buckets */ - int elements; /* number of elements registered */ - int size; /* size of hashtable */ - hashdata_compare_cb compare; /* callback to a compare function. - * should compare 2 element datas for their keys, - * return 0 if same and not 0 if not same */ - hashdata_choose_cb choose; /* the hashfunction, should return an index based - * on the key in the data of the first argument - * and the size the second */ + struct element_t **table; /* the hashtable itself, with the + * buckets */ + int elements; /* number of elements registered */ + int size; /* size of hashtable */ + hashdata_compare_cb compare; /* callback to a compare function. + * should compare 2 element datas for + * their keys, return 0 if same and not + * 0 if not same */ + hashdata_choose_cb choose; /* the hashfunction, should return an + * index based on the key in the data + * of the first argument and the size + * the second */ }; /* clears the hash */ -void hash_init(struct hashtable_t *hash); +void hash_init(struct hashtable_t *hash); /* allocates and clears the hash */ -struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_choose_cb choose); +struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, + hashdata_choose_cb choose); -/* remove bucket (this might be used in hash_iterate() if you already found the bucket - * you want to delete and don't need the overhead to find it again with hash_remove(). - * But usually, you don't want to use this function, as it fiddles with hash-internals. */ -void *hash_remove_bucket(struct hashtable_t *hash, struct hash_it_t *hash_it_t); +/* remove bucket (this might be used in hash_iterate() if you already found + * the bucket you want to delete and don't need the overhead to find it again + * with hash_remove(). But usually, you don't want to use this function, as it + * fiddles with hash-internals. */ +void *hash_remove_bucket(struct hashtable_t *hash, + struct hash_it_t *hash_it_t); /* remove the hash structure. if hashdata_free_cb != NULL, * this function will be called to remove the elements inside of the hash. * if you don't remove the elements, memory might be leaked. */ -void hash_delete(struct hashtable_t *hash, hashdata_free_cb free_cb); +void hash_delete(struct hashtable_t *hash, hashdata_free_cb free_cb); /* free only the hashtable and the hash itself. */ -void hash_destroy(struct hashtable_t *hash); +void hash_destroy(struct hashtable_t *hash); /* adds data to the hashtable. returns 0 on success, -1 on error */ -int hash_add(struct hashtable_t *hash, void *data); +int hash_add(struct hashtable_t *hash, void *data); /* removes data from hash, if found. returns pointer do data on success, * so you can remove the used structure yourself, or NULL on error . * data could be the structure you use with just the key filled, * we just need the key for comparing. */ -void *hash_remove(struct hashtable_t *hash, void *data); +void *hash_remove(struct hashtable_t *hash, void *data); -/* finds data, based on the key in keydata. returns the found data on success, or NULL on error */ -void *hash_find(struct hashtable_t *hash, void *keydata); +/* finds data, based on the key in keydata. returns the found data on success, + * or NULL on error */ +void *hash_find(struct hashtable_t *hash, void *keydata); -/* resize the hash, returns the pointer to the new hash or NULL on error. removes the old hash on success */ -struct hashtable_t *hash_resize(struct hashtable_t *hash, int size); +/* resize the hash, returns the pointer to the new hash or NULL on error. + * removes the old hash on success */ +struct hashtable_t *hash_resize(struct hashtable_t *hash, int size); /* print the hash table for debugging */ -void hash_debug( struct hashtable_t *hash); +void hash_debug(struct hashtable_t *hash); /* iterate though the hash. first element is selected with iter_in NULL. - * use the returned iterator to access the elements until hash_it_t returns NULL. */ -struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_in); + * use the returned iterator to access the elements until hash_it_t + * returns NULL. */ +struct hash_it_t *hash_iterate(struct hashtable_t *hash, + struct hash_it_t *iter_in); + +/* free hash_it_t pointer when stopping hash_iterate early */ +void hash_iterate_free(struct hash_it_t *iter_in); #endif -- 2.0.0

2 7

[B.A.T.M.A.N.] [PATCHv2 1/2] alfred-gpsd: Calculate size of global buffer and not of a single char
by Sven Eckelmann 27 Jun '14

27 Jun '14

The global buffer is 65536 bytes in size and not only 1 byte. This statement evaluated to a negative value which was casted to an unsigned value (aka... very large value). This is a regression was introduced in 71dbc00fd879f1e592b07d8397f724fb3f69ac64 ("alfred: Use strncpy instead of strcpy for string"). Signed-off-by: Sven Eckelmann <sven(a)narfation.org> --- v2: Fixed prefix of the commit subject gpsd/alfred-gpsd.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gpsd/alfred-gpsd.c b/gpsd/alfred-gpsd.c index 84a0ded..d6cdfd6 100644 --- a/gpsd/alfred-gpsd.c +++ b/gpsd/alfred-gpsd.c @@ -301,7 +301,7 @@ static void gpsd_read_gpsd(struct globals *globals) size_t cnt; bool eol = false; char buf[4096]; - const size_t tpv_size = sizeof(*globals->buf) - + const size_t tpv_size = sizeof(globals->buf) - sizeof(*globals->push) - sizeof(struct alfred_data) - sizeof(*globals->gpsd_data); @@ -450,7 +450,7 @@ static int gpsd_server(struct globals *globals) int max_fd, ret; const size_t overhead = sizeof(*globals->push) + sizeof(struct alfred_data); - const size_t tpv_size = sizeof(*globals->buf) - + const size_t tpv_size = sizeof(globals->buf) - sizeof(*globals->push) - sizeof(struct alfred_data) - sizeof(*globals->gpsd_data); -- 2.0.0

3 3

Re: [B.A.T.M.A.N.] [PATCHv2 net-next 2/4] bridge: adhere to querier election mechanism specified by RFCs
by Linus Lüssing 27 Jun '14

27 Jun '14

Hi Ajith, On Mon, Jun 23, 2014 at 07:58:21AM +0530, Ajith Adapa wrote: > Hi Luessing, > > As per RFC 4541, snooping switches send query with source address as > 0.0.0.0 since port in a L2 switch doesn't have ip-address configured. Hm, I'm not quite sure whether this is true. Do you have a section/paragraph in RFC4541 which says that? To me, it seems that 0.0.0.0/:: should only be used when the topology changes, on links becoming active (the RFC uses the example of STP). As a performance optimization but not as the source address for General Queries. In section 2.1.1 1) b) says: "The 0.0.0.0 address represents a special case where the switch is proxying IGMP Queries for faster network convergence, but is not itself the Querier." In section 2.1.1 4) it says: "If the switch is not the Querier, it should use the 'all-zeros' IP Source Address in these proxy queries (even though some hosts may elect to not process queries with a 0.0.0.0 IP Source Address)." (which seems to imply that if a switch is the selected Querier, that it should use something other than the 'all-zeros' IP Source Address?) Also, section 2.1.1 4) says: "[...] even though some hosts may elect to not process queries with a 0.0.0.0 IP Source Address" Which seems to indicate that 0.0.0.0 might be a bad choice to get reliable IGMP Reports and might only make sense for performance optimizations (at least for IPv4 - for IPv6 it doesn't make sense to me to send General Queries with '::' source address at all since '::' is ignored by hosts per RFC). (*) > > With current changes linux bridge will always select a querier who sends a > query message with 0.0.0.0. Right ? > > + if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.u.ip4)) > + goto update; Yes. Which is what the querier election mechanism in the RFCs for IGMPv2/IGMPv3 (RFC2236/RFC3376) specifies, I think. (**) > > Currently linux bridge sends a query message with source address as > 0.0.0.0. Right ? For IPv4, this is currently the default, yes. (there's a sysfs switch to change that, if desired) (***) > > What should be the expected behaviour ? Hm, good question. Regarding (***): After rereading RFC4541 a few more times, I think (*) would be the right choice: The bridge code should probably be changed to always use an available, non-zero IPv4 source address for General Queries. If none is available it, doesn't make sense to me to become the selected Querier at all (should be changed for IPv6, too: Currently it refrains from sending Query messages then, but thinks a valid querier were in the network, enabling the multicast snooping of the bridge). Regarding (**): Now that you're mentioning that, you're right, my change isn't quite straightforward in that regard, a few lines earlier there is: > + if (!br->ip4_querier.addr.u.ip4) > + goto update; So it would select the all-zeros Querier if it receives such messages. But would happily switch to a non-all-zeros Querier as well if receiving such messages... And now, this baffles me, section 2.1.1 4) again: "When such proxy queries are received, they must not be included in the Querier election process." If we were following that, a snooping switch and a true multicast router could potentially have an argument about which becomes the selected IGMP querier? (for IPv6/MLD this dilemma should not exist, I think) I'm currently unsure, whether we should follow RFC2236(IGMPv2)+RFC3376(IGMPv3) or the informational (!) RFC4541. Or am I overlooking something? What do others think? Cheers, Linus

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

B.A.T.M.A.N June 2014