Author: simon Date: 2009-11-08 01:15:11 +0000 (Sun, 08 Nov 2009) New Revision: 1475
Added: tags/batctl-0.2/ tags/batctl-0.2/hash.c tags/batctl-0.2/hash.h tags/batctl-0.2/list-batman.c tags/batctl-0.2/list-batman.h tags/batctl-0.2/packet.h Removed: tags/batctl-0.2/hash.c tags/batctl-0.2/hash.h tags/batctl-0.2/list-batman.c tags/batctl-0.2/list-batman.h tags/batctl-0.2/packet.h Log: tag batctl-0.2
Property changes on: tags/batctl-0.2 ___________________________________________________________________ Added: svn:mergeinfo +
Deleted: tags/batctl-0.2/hash.c =================================================================== --- trunk/batctl/hash.c 2009-11-08 01:12:51 UTC (rev 1473) +++ tags/batctl-0.2/hash.c 2009-11-08 01:15:11 UTC (rev 1475) @@ -1 +0,0 @@ -link ../batman/hash.c \ No newline at end of file
Copied: tags/batctl-0.2/hash.c (from rev 1473, trunk/batman/hash.c) =================================================================== --- tags/batctl-0.2/hash.c (rev 0) +++ tags/batctl-0.2/hash.c 2009-11-08 01:15:11 UTC (rev 1475) @@ -0,0 +1,319 @@ +/* + * Copyright (C) 2006-2009 B.A.T.M.A.N. contributors: + * + * Simon Wunderlich, 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> /* NULL */ +#include "hash.h" +#include "allocate.h" + + +/* clears the hash */ +void hash_init(struct hashtable_t *hash) +{ + int i; + + hash->elements = 0; + + for (i = 0; i < hash->size; i++) + hash->table[i] = NULL; +} + +/* 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) +{ + struct element_t *bucket, *last_bucket; + int i; + + for (i = 0; i < hash->size; i++) { + + bucket = hash->table[i]; + while (bucket != NULL) { + + if (free_cb != NULL) + free_cb(bucket->data); + + last_bucket = bucket; + bucket = bucket->next; + debugFree(last_bucket, 1301); + + } + + } + + hash_destroy(hash); +} + +/* free only the hashtable and the hash itself. */ +void hash_destroy(struct hashtable_t *hash) +{ + debugFree(hash->table, 1302); + debugFree(hash, 1303); +} + +/* 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) +{ + struct hash_it_t *iter; + + if (iter_in == NULL) { + iter = debugMalloc(sizeof(struct hash_it_t), 301); + iter->index = -1; + iter->bucket = NULL; + iter->prev_bucket = NULL; + } else + iter= iter_in; + + /* 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. */ + if ((*iter->first_bucket) != iter->bucket) { + + /* there are still other elements in the list */ + if ((*iter->first_bucket) != NULL) { + iter->prev_bucket = NULL; + iter->bucket = (*iter->first_bucket); + iter->first_bucket = &hash->table[iter->index]; + return iter; + } else { + iter->bucket = NULL; + } + + } + + } 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. */ + if (iter->prev_bucket->next != iter->bucket) + iter->bucket = iter->prev_bucket; + + } + + } + + /* now as we are sane, select the next one if there is some */ + if (iter->bucket != NULL) { + if (iter->bucket->next != NULL) { + iter->prev_bucket = iter->bucket; + iter->bucket = iter->bucket->next; + iter->first_bucket = NULL; + return iter; + } + } + /* 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 */ + while (iter->index < hash->size) { + + if ((hash->table[iter->index]) == NULL) { + iter->index++; + continue; + } + + iter->prev_bucket = NULL; + iter->bucket = hash->table[iter->index]; + iter->first_bucket = &hash->table[iter->index]; + return iter; /* if this table entry is not null, return it */ + } + + /* nothing to iterate over anymore */ + debugFree(iter, 1304); + 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; + + hash = debugMalloc(sizeof(struct hashtable_t), 302); + if (!hash) + return NULL; + + hash->size= size; + hash->table= debugMalloc(sizeof(struct element_t *) * size, 303); + + if (!hash->table) { + debugFree(hash, 1305); + return NULL; + } + + hash_init(hash); + hash->compare = compare; + hash->choose = choose; + return hash; +} + +/* adds data to the hashtable. returns 0 on success, -1 on error */ +int hash_add(struct hashtable_t *hash, void *data) +{ + int index; + struct element_t *bucket, *prev_bucket = NULL; + + index = hash->choose(data, hash->size); + bucket = hash->table[index]; + + while (bucket != NULL) { + if (hash->compare(bucket->data, data)) + return -1; + + prev_bucket = bucket; + bucket= bucket->next; + } + + /* found the tail of the list, add new element */ + bucket = debugMalloc(sizeof(struct element_t),304); + + if (!bucket) + return -1; + + /* init the new bucket */ + bucket->data = data; + bucket->next = NULL; + + /* and link it */ + if (prev_bucket == NULL) { + hash->table[index] = bucket; + } 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 */ +void *hash_find(struct hashtable_t *hash, void *keydata) +{ + int index; + struct element_t *bucket; + + index = hash->choose(keydata , hash->size); + bucket = hash->table[index]; + + while (bucket != NULL) { + if (hash->compare(bucket->data, keydata)) + return bucket->data; + + bucket = bucket->next; + } + + 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. */ +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 */ + + 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) { + (*hash_it_t->first_bucket) = hash_it_t->bucket->next; + } + + debugFree(hash_it_t->bucket, 1306); + + hash->elements--; + return data_save; +} + +/* 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) +{ + struct hash_it_t hash_it_t; + + hash_it_t.index = hash->choose(data, hash->size); + hash_it_t.bucket = hash->table[hash_it_t.index]; + hash_it_t.prev_bucket = NULL; + + 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); + return hash_remove_bucket(hash, &hash_it_t); + } + + hash_it_t.prev_bucket = hash_it_t.bucket; + hash_it_t.bucket = hash_it_t.bucket->next; + } + + return NULL; +} + +/* 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; + struct element_t *bucket; + int i; + + /* initialize a new hash with the new size */ + new_hash = hash_new(size, hash->compare, hash->choose); + if (!new_hash) + return NULL; + + /* copy the elements */ + for (i = 0; i < hash->size; i++) { + bucket = hash->table[i]; + while (bucket != NULL) { + hash_add(new_hash, bucket->data); + bucket = bucket->next; + } + } + + hash_delete(hash, NULL); /* remove hash and eventual overflow buckets but not the content itself. */ + return new_hash; +} + +/* print the hash table for debugging */ +/* void hash_debug(struct hashtable_t *hash) { + int i; + struct element_t *bucket; + + for (i = 0; i < hash->size; i++) { + printf("[%d] ", i); + bucket = hash->table[i]; + + while (bucket) { + printf("-> [%10p] ", (void *)bucket); + bucket = bucket->next; + } + + printf("\n"); + + } + printf("\n"); +}*/ +
Property changes on: tags/batctl-0.2/hash.c ___________________________________________________________________ Added: svn:mergeinfo +
Deleted: tags/batctl-0.2/hash.h =================================================================== --- trunk/batctl/hash.h 2009-11-08 01:12:51 UTC (rev 1473) +++ tags/batctl-0.2/hash.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -1 +0,0 @@ -link ../batman/hash.h \ No newline at end of file
Copied: tags/batctl-0.2/hash.h (from rev 1473, trunk/batman/hash.h) =================================================================== --- tags/batctl-0.2/hash.h (rev 0) +++ tags/batctl-0.2/hash.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2006-2009 B.A.T.M.A.N. contributors: + * + * Simon Wunderlich, 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 _BATMAN_HASH_H +#define _BATMAN_HASH_H + + + +typedef int (*hashdata_compare_cb)(void *, void *); +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 */ +}; + +struct hash_it_t { + int index; + struct element_t *bucket; + struct element_t *prev_bucket; + struct element_t **first_bucket; +}; + +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 */ +}; + +/* clears the 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); + +/* 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); + +/* free only the hashtable and the hash itself. */ +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); + +/* 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); + +/* 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); + +/* print the hash table for debugging */ +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); + +#endif
Property changes on: tags/batctl-0.2/hash.h ___________________________________________________________________ Added: svn:mergeinfo +
Deleted: tags/batctl-0.2/list-batman.c =================================================================== --- trunk/batctl/list-batman.c 2009-11-08 01:12:51 UTC (rev 1473) +++ tags/batctl-0.2/list-batman.c 2009-11-08 01:15:11 UTC (rev 1475) @@ -1 +0,0 @@ -link ../batman/list-batman.c \ No newline at end of file
Copied: tags/batctl-0.2/list-batman.c (from rev 1473, trunk/batman/list-batman.c) =================================================================== --- tags/batctl-0.2/list-batman.c (rev 0) +++ tags/batctl-0.2/list-batman.c 2009-11-08 01:15:11 UTC (rev 1475) @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2006-2009 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 "list-batman.h" + + + +/* + * Insert a new entry between two known consecutive entries. + * + * This is only for internal list manipulation where we know + * the next entries already! + */ +static void __list_add( struct list_head *new, struct list_head *prev, struct list_head *next ) { + + new->next = next; + prev->next = new; + +} + +/** + * list_add - add a new entry + * @new: new entry to be added + * @head: list head to add it after + * + * Insert a new entry after the specified head. + * This is good for implementing stacks. + */ +void list_add( struct list_head *new, struct list_head_first *head ) { + + __list_add( new, (struct list_head *)head, head->next ); + + if ( head->prev == (struct list_head *)head ) + head->prev = new; + +} + +/** + * list_add_tail - add a new entry + * @new: new entry to be added + * @head: list head to add it before + * + * Insert a new entry before the specified head. + * This is useful for implementing queues. + */ +void list_add_tail( struct list_head *new, struct list_head_first *head ) { + + __list_add( new, head->prev, (struct list_head *)head ); + + head->prev = new; + +} + +void list_add_before( struct list_head *prev_node, struct list_head *next_node, struct list_head *new_node ) { + + prev_node->next = new_node; + new_node->next = next_node; + +} + + + +/* + * Delete a list entry by making the next entries + * point to each other. + * + * This is only for internal list manipulation where we know + * the next entries already! + */ +static void __list_del( struct list_head *prev, struct list_head *next ) { + + prev->next = next; + +} + +/** + * list_del - deletes 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( struct list_head *prev_entry, struct list_head *entry, struct list_head_first *head ) { + + if ( head->prev == entry ) + head->prev = prev_entry; + + __list_del( prev_entry, entry->next ); + + entry->next = (void *) 0; + +} + + + +/** + * list_empty - tests whether a list is empty + * @head: the list to test. + */ +int list_empty( struct list_head_first *head ) { + + return head->next == (struct list_head *)head; + +} +
Property changes on: tags/batctl-0.2/list-batman.c ___________________________________________________________________ Added: svn:mergeinfo +
Deleted: tags/batctl-0.2/list-batman.h =================================================================== --- trunk/batctl/list-batman.h 2009-11-08 01:12:51 UTC (rev 1473) +++ tags/batctl-0.2/list-batman.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -1 +0,0 @@ -link ../batman/list-batman.h \ No newline at end of file
Copied: tags/batctl-0.2/list-batman.h (from rev 1473, trunk/batman/list-batman.h) =================================================================== --- tags/batctl-0.2/list-batman.h (rev 0) +++ tags/batctl-0.2/list-batman.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2006-2009 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 <stddef.h> /* offsetof() */ + +#ifndef _LINUX_LIST_H +#define _LINUX_LIST_H + +/* + * XXX: Resolve conflict between this file and <sys/queue.h> on BSD systems. + */ +#ifdef LIST_HEAD +#undef LIST_HEAD +#endif + +/* + * Simple linked list implementation. + * + * Some of the internal functions ("__xxx") are useful when + * manipulating whole lists rather than single entries, as + * sometimes we already know the next entries and we can + * generate better code by using them directly rather than + * using the generic single-entry routines. + */ + +struct list_head { + struct list_head *next; +}; + +struct list_head_first { + struct list_head *next, *prev; +}; + + +void list_add( struct list_head *new, struct list_head_first *head ); +void list_add_tail( struct list_head *new, struct list_head_first *head ); +void list_add_before( struct list_head *prev_node, struct list_head *next_node, struct list_head *new_node ); +void list_del( struct list_head *prev_entry, struct list_head *entry, struct list_head_first *head ); +int list_empty( struct list_head_first *head ); + + + +#define INIT_LIST_HEAD(ptr) do { \ + (ptr)->next = (ptr); \ +} while (0) + +#define INIT_LIST_HEAD_FIRST(ptr) \ + ptr.next = (struct list_head *)&ptr; ptr.prev = (struct list_head *)&ptr; \ + + +/** + * 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_head *)(head); \ + 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_head *)(head); \ + pos = n, n = pos->next) + +/** + * list_for_each_entry - iterate over list of given type + * @pos: the type * to use as a loop counter. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry(pos, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member); \ + &pos->member != (struct list_head *)(head); \ + pos = list_entry(pos->member.next, typeof(*pos), member)) + +/** + * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry + * @pos: the type * to use as a loop counter. + * @n: another type * to use as temporary storage + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_safe(pos, n, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member), \ + n = list_entry(pos->member.next, typeof(*pos), member); \ + &pos->member != (struct list_head *)(head); \ + pos = n, n = list_entry(n->member.next, typeof(*n), member)) + + +#endif
Property changes on: tags/batctl-0.2/list-batman.h ___________________________________________________________________ Added: svn:mergeinfo +
Deleted: tags/batctl-0.2/packet.h =================================================================== --- trunk/batctl/packet.h 2009-11-08 01:12:51 UTC (rev 1473) +++ tags/batctl-0.2/packet.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -1 +0,0 @@ -link ../batman-adv-kernelland/packet.h \ No newline at end of file
Copied: tags/batctl-0.2/packet.h (from rev 1473, trunk/batman-adv-kernelland/packet.h) =================================================================== --- tags/batctl-0.2/packet.h (rev 0) +++ tags/batctl-0.2/packet.h 2009-11-08 01:15:11 UTC (rev 1475) @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2007-2009 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 + * + */ + +#define ETH_P_BATMAN 0x4305 /* unofficial/not registered Ethertype */ + +#define BAT_PACKET 0x01 +#define BAT_ICMP 0x02 +#define BAT_UNICAST 0x03 +#define BAT_BCAST 0x04 +#define BAT_VIS 0x05 + +/* this file is included by batctl which needs these defines */ +#define COMPAT_VERSION 8 +#define DIRECTLINK 0x40 +#define VIS_SERVER 0x20 + +/* ICMP message types */ +#define ECHO_REPLY 0 +#define DESTINATION_UNREACHABLE 3 +#define ECHO_REQUEST 8 +#define TTL_EXCEEDED 11 +#define PARAMETER_PROBLEM 12 + +/* vis defines */ +#define VIS_TYPE_SERVER_SYNC 0 +#define VIS_TYPE_CLIENT_UPDATE 1 + +struct batman_packet { + uint8_t packet_type; + uint8_t version; /* batman version field */ + uint8_t flags; /* 0x40: DIRECTLINK flag, 0x20 VIS_SERVER flag... */ + uint8_t tq; + uint16_t seqno; + uint8_t orig[6]; + uint8_t prev_sender[6]; + uint8_t ttl; + uint8_t num_hna; +} __attribute__((packed)); + +#define BAT_PACKET_LEN sizeof(struct batman_packet) + +struct icmp_packet { + uint8_t packet_type; + uint8_t version; /* batman version field */ + uint8_t msg_type; /* see ICMP message types above */ + uint8_t ttl; + uint8_t dst[6]; + uint8_t orig[6]; + uint16_t seqno; + uint8_t uid; +} __attribute__((packed)); + +struct unicast_packet { + uint8_t packet_type; + uint8_t version; /* batman version field */ + uint8_t dest[6]; + uint8_t ttl; +} __attribute__((packed)); + +struct bcast_packet { + uint8_t packet_type; + uint8_t version; /* batman version field */ + uint8_t orig[6]; + uint16_t seqno; +} __attribute__((packed)); + +struct vis_packet { + uint8_t packet_type; + uint8_t version; /* batman version field */ + uint8_t vis_type; /* which type of vis-participant sent this? */ + uint8_t seqno; /* sequence number */ + uint8_t entries; /* number of entries behind this struct */ + uint8_t ttl; /* TTL */ + uint8_t vis_orig[6]; /* originator that informs about its + * neighbours */ + uint8_t target_orig[6]; /* who should receive this packet */ + uint8_t sender_orig[6]; /* who sent or rebroadcasted this packet */ +} __attribute__((packed));