X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftransport%2Fplugin_transport_wlan.c;h=51c6d3053d8cd499715711c44d3f2a519651bd4f;hb=fc49f1b524fce53459692ddffe05474876e4969c;hp=a2e9bbe60cd78aad44091ea3436b3a8fc555f22b;hpb=71e79d72a1da156a1bde9b3346e40f7a7f547f26;p=oweals%2Fgnunet.git diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c index a2e9bbe60..51c6d3053 100644 --- a/src/transport/plugin_transport_wlan.c +++ b/src/transport/plugin_transport_wlan.c @@ -34,7 +34,9 @@ #include "plugin_transport_wlan.h" #include "gnunet_common.h" #include "gnunet_crypto_lib.h" -#include "wlan/ieee80211.h" +#include "gnunet_fragmentation_lib.h" +//#include "wlan/ieee80211.h" +//#include #include @@ -43,28 +45,55 @@ /** * Max size of packet from helper */ -#define WLAN_MTU 3000 +#define WLAN_MTU 1450 /** * Time until retransmission of a fragment in ms */ #define FRAGMENT_TIMEOUT GNUNET_TIME_UNIT_SECONDS +/** + * max size of fragment queue + */ #define FRAGMENT_QUEUE_SIZE 10 +/** + * max messages in fragment queue per session/client + */ #define FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION 1 +/** + * max messages in fragment queue per MAC + */ +#define FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT 1 + +/** + * time until message in in queue + */ #define MESSAGE_IN_TIMEOUT GNUNET_TIME_UNIT_SECONDS +/** + * max messages in in queue + */ #define MESSAGES_IN_QUEUE_SIZE 10 -#define MESSAGES_IN_QUEUE_PER_SESSION 1 - +/** + * max messages in in queue per session/client + */ +#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 1 +/** + * scaling factor for hello beacon + */ #define HALLO_BEACON_SCALING_FACTOR 900 -#define DEBUG_wlan GNUNET_YES +#define DEBUG_wlan GNUNET_NO +#define DEBUG_wlan_retransmission GNUNET_NO +#define DEBUG_wlan_ip_udp_packets_on_air GNUNET_NO #define MESSAGE_LENGHT_UNKNOWN -1 //#define NO_MESSAGE_OR_MESSAGE_FINISHED -2 - +/** + * size of log for recently used incomming messages id + */ +#define MESSAGE_ID_BACKLOG_SIZE 5 /** * After how long do we expire an address that we * learned from another peer if it is not reconfirmed @@ -72,6 +101,69 @@ */ #define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6) +#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ + +#define IEEE80211_FC0_VERSION_MASK 0x03 +#define IEEE80211_FC0_VERSION_SHIFT 0 +#define IEEE80211_FC0_VERSION_0 0x00 +#define IEEE80211_FC0_TYPE_MASK 0x0c +#define IEEE80211_FC0_TYPE_SHIFT 2 +#define IEEE80211_FC0_TYPE_MGT 0x00 +#define IEEE80211_FC0_TYPE_CTL 0x04 +#define IEEE80211_FC0_TYPE_DATA 0x08 + +/* + * Structure of an internet header, naked of options. + */ +struct iph +{ +#if __BYTE_ORDER == __LITTLE_ENDIAN + unsigned int ip_hl :4; /* header length */ + unsigned int ip_v :4; /* version */ +#endif +#if __BYTE_ORDER == __BIG_ENDIAN + unsigned int ip_v:4; /* version */ + unsigned int ip_hl:4; /* header length */ +#endif + u_int8_t ip_tos; /* type of service */ + u_short ip_len; /* total length */ + u_short ip_id; /* identification */ + u_short ip_off; /* fragment offset field */ +#define IP_RF 0x8000 /* reserved fragment flag */ +#define IP_DF 0x4000 /* dont fragment flag */ +#define IP_MF 0x2000 /* more fragments flag */ +#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */ + u_int8_t ip_ttl; /* time to live */ + u_int8_t ip_p; /* protocol */ + u_short ip_sum; /* checksum */ + struct in_addr ip_src, ip_dst; /* source and dest address */ +}; + +struct udphdr +{ + u_int16_t source; + u_int16_t dest; + u_int16_t len; + u_int16_t check; +}; + +/* + * generic definitions for IEEE 802.11 frames + */ +struct ieee80211_frame +{ + u_int8_t i_fc[2]; + u_int8_t i_dur[2]; + u_int8_t i_addr1[IEEE80211_ADDR_LEN]; + u_int8_t i_addr2[IEEE80211_ADDR_LEN]; + u_int8_t i_addr3[IEEE80211_ADDR_LEN]; + u_int8_t i_seq[2]; +#if DEBUG_wlan_ip_udp_packets_on_air +u_int8_t llc[4]; +struct iph ip; +struct udphdr udp; +#endif +}GNUNET_PACKED; /** * Initial handshake message for a session. */ @@ -100,31 +192,28 @@ struct Plugin struct GNUNET_TRANSPORT_PluginEnvironment *env; /** - * List of open sessions. head + * List of open connections. head */ - struct Sessionqueue *sessions; + struct MacEndpoint * mac_head; /** - * List of open sessions. tail + * List of open connections. tail */ - struct Sessionqueue *sessions_tail; + struct MacEndpoint * mac_tail; /** - * Number of sessions + * Number of connections */ - - int session_count; + unsigned int mac_count; /** * encapsulation of data from the local wlan helper program */ - struct GNUNET_SERVER_MessageStreamTokenizer * suid_tokenizer; /** - * encapsulation of packets received + * encapsulation of packets received from the wlan helper */ - struct GNUNET_SERVER_MessageStreamTokenizer * data_tokenizer; /** @@ -179,13 +268,13 @@ struct Plugin /** * Sessions currently pending for transmission - * to this peer, if any. + * to a peer, if any. */ - struct Sessionqueue * pending_Sessions; + struct Sessionqueue * pending_Sessions_head; /** * Sessions currently pending for transmission - * to this peer (tail), if any. + * to a peer (tail), if any. */ struct Sessionqueue * pending_Sessions_tail; @@ -195,59 +284,37 @@ struct Plugin unsigned int pendingsessions; /** - * Messages in the fragmentation queue, head - */ - - struct FragmentMessage * pending_Fragment_Messages_head; - - /** - * Messages in the fragmentation queue, tail - */ - - struct FragmentMessage * pending_Fragment_Messages_tail; - - /** - * number of pending fragment message - */ - - unsigned int pending_fragment_messages; - - /** - * Messages in the in Queue, head + * Messages in the sending queues */ - - struct Receive_Message_Queue * receive_messages_head; + int pending_Fragment_Messages; /** - * Messages in the in Queue, tail + * messages ready for send, head */ - - struct Receive_Message_Queue * receive_messages_teil; - + struct FragmentMessage_queue * sending_messages_head; /** - * number of messages in the in queue + * messages ready for send, tail */ - - unsigned int pending_receive_messages; - + struct FragmentMessage_queue * sending_messages_tail; /** * time of the next "hello-beacon" */ - struct GNUNET_TIME_Absolute beacon_time; /** * queue to send acks for received fragments (head) */ - struct AckSendQueue * ack_send_queue_head; /** * queue to send acks for received fragments (tail) */ - struct AckSendQueue * ack_send_queue_tail; + /** + * Tracker for bandwidth limit + */ + struct GNUNET_BANDWIDTH_Tracker tracker; }; /** @@ -264,7 +331,7 @@ struct Finish_send /** * Queue of sessions, for the general session queue and the pending session queue */ - +//TODO DOXIGEN struct Sessionqueue { struct Sessionqueue * next; @@ -273,9 +340,20 @@ struct Sessionqueue }; /** - * Queue for the fragments received + * Queue of fragmented messages, for the sending queue of the plugin */ +//TODO DOXIGEN +struct FragmentMessage_queue +{ + struct FragmentMessage_queue * next; + struct FragmentMessage_queue * prev; + struct FragmentMessage * content; +}; +/** + * Queue for the fragments received + */ +//TODO DOXIGEN struct Receive_Fragment_Queue { struct Receive_Fragment_Queue * next; @@ -286,57 +364,19 @@ struct Receive_Fragment_Queue struct Radiotap_rx rxinfo; }; -/** - * Queue for the fragments received - */ - -struct Receive_Message_Queue +//TODO DOXIGEN +struct MacEndpoint_id_fragment_triple { - struct Receive_Message_Queue * next; - - struct Receive_Message_Queue * prev; - - /** - * current number for message incoming, to distinguish between the messages - */ - uint32_t message_id_in; - - /** - * size of the message received, - * MESSAGE_LENGHT_UNKNOWN means that the size is not known, - * NO_MESSAGE_OR_MESSAGE_FINISHED means no message received - */ - - int rec_size; - - /** - * Sorted queue with the fragments received; head - */ - - struct Receive_Fragment_Queue * frag_head; - - /** - * Sorted queue with the fragments received; tail - */ - - struct Receive_Fragment_Queue * frag_tail; - - /** - * Session this fragment belongs to - */ + struct MacEndpoint * endpoint; + uint32_t message_id; + struct FragmentMessage * fm; +}; +//TODO DOXIGEN +struct Plugin_Session_pair +{ + struct Plugin * plugin; struct Session * session; - - /** - * Timeout value for the pending message. - */ - struct GNUNET_TIME_Absolute timeout; - - /** - * Bitfield of received fragments - */ - - uint64_t received_fragments; }; /** @@ -345,11 +385,19 @@ struct Receive_Message_Queue */ struct PendingMessage { + /** + * dll next + */ + struct PendingMessage * next; + /** + * dll prev + */ + struct PendingMessage * prev; /** * The pending message */ - char *msg; + struct WlanHeader *msg; /** * Size of the message @@ -378,24 +426,38 @@ struct PendingMessage /** * Queue for acks to send for fragments recived */ -//TODO comments struct AckSendQueue { + /** + * next ack in the ack send queue + */ struct AckSendQueue * next; + /** + * previous ack in the ack send queue + */ struct AckSendQueue * prev; - - struct Session * session; + /** + * pointer to the session this ack belongs to + */ + struct MacEndpoint * endpoint; /** * ID of message, to distinguish between the messages, picked randomly. */ uint32_t message_id; /** - * Bit field for received fragments + * msg to send */ - uint64_t fragments_field; - + struct GNUNET_MessageHeader * hdr; + /** + * pointer to the ieee wlan header + */ + struct ieee80211_frame * ieeewlanheader; + /** + * pointer to the radiotap header + */ + struct Radiotap_Send * radioHeader; }; /** @@ -411,7 +473,12 @@ struct Session_light /** * peer mac address */ - uint8_t addr[6]; + struct MacAddress addr; + + /** + * mac endpoint + */ + struct MacEndpoint * macendpoint; }; /** @@ -425,22 +492,17 @@ struct Session */ struct SessionHeader header; - /** - * Pointer to the global plugin struct. - */ - struct Plugin *plugin; - /** * Message currently pending for transmission - * to this peer, if any. + * to this peer, if any. head */ - struct PendingMessage *pending_message; + struct PendingMessage * pending_message_head; /** * Message currently pending for transmission - * to this peer, if any. + * to this peer, if any. tail */ - struct PendingMessage *pending_message2; + struct PendingMessage * pending_message_tail; /** * To whom are we talking to (set to our identity @@ -448,11 +510,6 @@ struct Session */ struct GNUNET_PeerIdentity target; - /** - * peer mac address - */ - char addr[6]; - /** * Address of the other peer (either based on our 'connect' * call or on our 'accept' call). @@ -465,23 +522,91 @@ struct Session */ struct GNUNET_TIME_Absolute last_activity; + /** + * peer connection + */ + struct MacEndpoint * mac; + /** * count of messages in the fragment out queue for this session */ int fragment_messages_out_count; +}; + +/** + * Struct to represent one network card connection + */ +struct MacEndpoint +{ + /** + * Pointer to the global plugin struct. + */ + struct Plugin *plugin; + /** + * Struct to hold the session reachable over this mac; head + */ + struct Sessionqueue * sessions_head; + /** + * Struct to hold the session reachable over this mac; tail + */ + struct Sessionqueue * sessions_tail; + /** + * Messages currently sending + * to a peer, if any. + */ + struct FragmentMessage * sending_messages_head; + + /** + * Messages currently sending + * to a peer (tail), if any. + */ + struct FragmentMessage * sending_messages_tail; + /** + * dll next + */ + struct MacEndpoint *next; + /** + * dll prev + */ + struct MacEndpoint *prev; + + /** + * peer mac address + */ + struct MacAddress addr; + + /** + * Defrag context for this mac endpoint + */ + struct GNUNET_DEFRAGMENT_Context * defrag; + /** - * count of messages in the fragment in queue for this session + * count of messages in the fragment out queue for this mac endpoint */ - int fragment_messages_in_count; + int fragment_messages_out_count; //TODO DOXIGEN uint8_t rate; uint16_t tx_power; uint8_t antenna; + /** + * Duplicates received + */ + int dups; + + /** + * Fragments received + */ + int fragc; + + /** + * Acks received + */ + int acks; }; /** @@ -490,6 +615,7 @@ struct Session struct FragmentMessage { + /** * Session this message belongs to */ @@ -506,349 +632,278 @@ struct FragmentMessage */ struct FragmentMessage *prev; - /** - * The pending message - */ - char *msg; - /** * Timeout value for the pending message. */ struct GNUNET_TIME_Absolute timeout; /** - * Timeout value for the pending fragments. - * Stores the time when the next msg fragment ack has to be received - */ - struct GNUNET_TIME_Absolute next_ack; - - /** - * bitfield with all acks received for this message - */ - uint64_t ack_bitfield; - - /** - * Size of the message + * Fragmentation context */ - size_t message_size; + struct GNUNET_FRAGMENT_Context * fragcontext; /** - * pos / next fragment number in the message, for fragmentation/segmentation, - * some acks can be missing but there is still time + * Fragment to send */ - uint32_t message_pos; + char * frag; /** - * current number for message outgoing, to distinguish between the messages + * size of message */ - uint32_t message_id_out; -}; - -/** - * Header for messages which need fragmentation - */ -struct FragmentationAckHeader -{ - - struct GNUNET_MessageHeader header; + size_t size; /** - * ID of message, to distinguish between the messages, picked randomly. + * pointer to the ieee wlan header */ - uint32_t message_id GNUNET_PACKED; - + struct ieee80211_frame * ieeewlanheader; /** - * Offset or number of this fragment, for fragmentation/segmentation (design choice, TBD) + * pointer to the radiotap header */ - uint64_t fragment_field GNUNET_PACKED; - + struct Radiotap_Send * radioHeader; }; -int -getRadiotapHeader(struct Plugin * plugin, struct Session * session, - struct Radiotap_Send * Header); - -int -getWlanHeader(struct ieee80211_frame * Header, const char * to_mac_addr, - struct Plugin * plugin); - -static int -wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen); - -uint16_t -getcrc16(const char *msgbuf, size_t msgbuf_size); - static void do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); - -static void -check_fragment_queue(struct Plugin * plugin); - -uint32_t -getcrc32(const char *msgbuf, size_t msgbuf_size); - static void -free_receive_message(struct Plugin* plugin, - struct Receive_Message_Queue * rx_message); +free_session(struct Plugin * plugin, struct Sessionqueue * queue, + int do_free_macendpoint); +static struct MacEndpoint * +create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr); -struct Receive_Message_Queue * -get_receive_message_from_session(struct Plugin * plugin, - struct Session * session); - -static void -wlan_data_helper(void *cls, struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr, const struct Radiotap_rx * rxinfo); - -static void -wlan_process_helper(void *cls, void *client, - const struct GNUNET_MessageHeader *hdr); - -static void -finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); +/** + * Generates a nice hexdump of a memory area. + * + * \param mem pointer to memory to dump + * \param length how many bytes to dump + */ +void +hexdump(void *mem, unsigned length) +{ + char line[80]; + char *src = (char*) mem; -static void -wlan_data_massage_handler(struct Plugin * plugin, - struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr); + printf( + "dumping %u bytes from %p\r\n" + " 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF\r\n", + length, src); + unsigned i; + int j; -static const char * -wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen); + for (i = 0; i < length; i += 16, src += 16) + { + char *t = line; -struct Receive_Message_Queue * -get_receive_message(struct Plugin * plugin, struct Session * session, - uint32_t message_id); + t += sprintf(t, "%04x: ", i); + for (j = 0; j < 16; j++) + { + if (i + j < length) + t += sprintf(t, "%02X", src[j] & 0xff); + else + t += sprintf(t, " "); + t += sprintf(t, j % 2 ? " " : "-"); + } -static uint64_t -htonll(uint64_t input) -{ - return input; -} + t += sprintf(t, " "); + for (j = 0; j < 16; j++) + { + if (i + j < length) + { + if (isprint((unsigned char)src[j])) + t += sprintf(t, "%c", src[j]); + else + t += sprintf(t, "."); + } + else + { + t += sprintf(t, " "); + } + } -static uint64_t -ntohll(uint64_t input) -{ - return input; + t += sprintf(t, "\r\n"); + printf("%s", line); + } } /** - * Sets a bit active in the bitArray. Increment bit-specific - * usage counter on disk only if below 4bit max (==15). - * - * @param bitArray memory area to set the bit in - * @param bitIdx which bit to set + * Function to find a MacEndpoint with a specific mac addr + * @param plugin pointer to the plugin struct + * @param addr pointer to the mac address + * @param create_new GNUNET_YES if a new end point should be created + * @return */ -static void -setBit(char *bitArray, unsigned int bitIdx) +static struct MacEndpoint * +get_macendpoint(struct Plugin *plugin, const struct MacAddress *addr, + int create_new) { - size_t arraySlot; - unsigned int targetBit; + struct MacEndpoint * queue = plugin->mac_head; + while (queue != NULL) + { + GNUNET_assert (queue->sessions_head != NULL); + if (memcmp(addr, &queue->addr, sizeof(struct MacAddress)) == 0) + return queue; /* session found */ + queue = queue->next; + } - arraySlot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - bitArray[arraySlot] |= targetBit; -} + if (create_new == GNUNET_YES) + { + return create_macendpoint(plugin, addr); + } + else + { + return NULL; + } +} /** - * Clears a bit from bitArray. Bit is cleared from the array - * only if the respective usage counter on the disk hits/is zero. + * search for a session with the addr and peer id * - * @param bitArray memory area to set the bit in - * @param bitIdx which bit to unset + * @param plugin pointer to the plugin struct + * @param addr pointer to the mac address of the peer + * @param peer pointer to the peerid + * @return returns the session */ -/*static void - clearBit(char *bitArray, unsigned int bitIdx) - { - size_t slot; - unsigned int targetBit; - - slot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - bitArray[slot] = bitArray[slot] & (~targetBit); - }*/ - -/** - * Checks if a bit is active in the bitArray - * - * @param bitArray memory area to set the bit in - * @param bitIdx which bit to test - * @return GNUNET_YES if the bit is set, GNUNET_NO if not. - */ -static int -testBit(char *bitArray, unsigned int bitIdx) -{ - size_t slot; - unsigned int targetBit; - - slot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - if (bitArray[slot] & targetBit) - return GNUNET_YES; - else - return GNUNET_NO; -} - -/** - * get the next message number, at the moment just a random one - * @return returns the next valid message-number for sending packets - */ -uint32_t -get_next_message_id() +static struct Session * +search_session(struct Plugin *plugin, const struct MacEndpoint * endpoint, + const struct GNUNET_PeerIdentity * peer) { - return GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); -} + GNUNET_assert(endpoint != NULL); + struct Sessionqueue * queue = endpoint->sessions_head; -/** - * start next message number generator - * (not necessary at the moment) - */ -void -start_next_message_id() -{ - //GNUNET_CRYPTO_random_init; + while (queue != NULL) + { + GNUNET_assert (queue->content != NULL); + if (memcmp(peer, &queue->content->target, + sizeof(struct GNUNET_PeerIdentity)) == 0) + return queue->content; /* session found */ + queue = queue->next; + } + return NULL; } /** - * search for a session with the addr + * Function called for a quick conversion of the binary address to + * a numeric address. Note that the caller must not free the + * address and that the next call to this function is allowed + * to override the address again. * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer - * @return returns the session + * @param cls closure + * @param addr binary address + * @param addrlen length of the address + * @return string representing the same address */ - -static struct Session * -search_session(struct Plugin *plugin, const uint8_t * addr) +static const char* +wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen) { - struct Sessionqueue * queue = plugin->sessions; - struct Sessionqueue * lastitem = NULL; + static char ret[40]; + const struct MacAddress *mac; - //just look at all the session for the needed one - while (queue != NULL) + if (addrlen != sizeof(struct MacAddress)) { - // content is never NULL - GNUNET_assert (queue->content != NULL); - char * addr2 = queue->content->addr; - if (memcmp(addr, addr2, 6) == 0) - { - //sesion found - return queue->content; - } - // try next - lastitem = queue; - queue = queue->next; + GNUNET_break (0); + return NULL; } - return NULL; + mac = addr; + GNUNET_snprintf(ret, sizeof(ret), "%s Mac-Address %X:%X:%X:%X:%X:%X", + PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], mac->mac[3], + mac->mac[4], mac->mac[5]); + return ret; } /** * create a new session * * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer + * @param addr pointer to the mac endpoint of the peer * @return returns the session */ static struct Session * -create_session(struct Plugin *plugin, const uint8_t * addr) +create_session(struct Plugin *plugin, struct MacEndpoint * endpoint, + const struct GNUNET_PeerIdentity * peer) { + GNUNET_assert(endpoint != NULL); struct Sessionqueue * queue = GNUNET_malloc (sizeof (struct Sessionqueue)); - GNUNET_CONTAINER_DLL_insert_tail(plugin->sessions, plugin->sessions_tail, queue); + GNUNET_CONTAINER_DLL_insert_tail(endpoint->sessions_head, endpoint->sessions_tail, queue); queue->content = GNUNET_malloc (sizeof (struct Session)); - queue->content->plugin = plugin; - memcpy(queue->content->addr, addr, 6); - queue->content->fragment_messages_out_count = 0; - queue->content->fragment_messages_in_count = 0; - - plugin->session_count++; + queue->content->mac = endpoint; + memcpy(&(queue->content->target), peer, sizeof(struct GNUNET_PeerIdentity)); #if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New session %p with %s\n", - queue->content, wlan_plugin_address_to_string(NULL, addr, 6)); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New session %p with endpoint %p: %s\n", + queue->content, endpoint, + wlan_plugin_address_to_string(NULL, endpoint->addr.mac, 6)); #endif return queue->content; } /** - * get Session from address, create if no session exists + * Get session from address, create if no session exists * * @param plugin pointer to the plugin struct * @param addr pointer to the mac address of the peer + * @param peer pointer to the peerid * @return returns the session */ -//TODO add other possibilities to find the right session (are there other?) static struct Session * -get_Session(struct Plugin *plugin, const uint8_t * addr) +get_session(struct Plugin *plugin, const struct MacAddress *addr, + const struct GNUNET_PeerIdentity * peer) { - struct Session * session = search_session(plugin, addr); + struct MacEndpoint * mac; + mac = get_macendpoint(plugin, addr, GNUNET_YES); + struct Session * session = search_session(plugin, mac, peer); + if (session != NULL) - { - return session; - } - // new session - return create_session(plugin, addr); - - /* -- not needed, layer above already has it-- - //queue welcome message for new sessions, not realy needed - //struct WelcomeMessage welcome; - struct PendingMessage *pm; - pm = GNUNET_malloc (sizeof (struct PendingMessage)); - pm->msg = GNUNET_malloc(GNUNET_HELLO_size(* (plugin->env->our_hello))); - pm->message_size = GNUNET_HELLO_size(* (plugin->env->our_hello)); - //welcome.header.size = htons (GNUNET_HELLO_size(* (plugin->env->our_hello))); - //welcome.header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT); - //welcome.clientIdentity = *plugin->env->my_identity; - memcpy ( (pm->msg), * plugin->env->our_hello, GNUNET_HELLO_size(* (plugin->env->our_hello))); - pm->timeout = GNUNET_TIME_UNIT_FOREVER_ABS; - queue->content->pending_message = pm; - plugin->pendingsessions ++; - GNUNET_CONTAINER_DLL_insert_tail(plugin->pending_Sessions, plugin->pending_Sessions_tail, queue); - - check_fragment_queue(plugin); - */ + return session; + return create_session(plugin, mac, peer); } /** * Queue the session to send data + * checks if there is a message pending + * checks if this session is not allready in the queue + * @param plugin pointer to the plugin + * @param session pointer to the session to add */ -//TODO doxigen static void -queue_Session(struct Plugin *plugin, struct Session * session) +queue_session(struct Plugin *plugin, struct Session * session) { - struct Sessionqueue * queue = plugin->pending_Sessions; - struct Sessionqueue * lastitem = NULL; + struct Sessionqueue * queue = plugin->pending_Sessions_head; - while (queue != NULL) + if (session->pending_message_head != NULL) { - // content is never NULL - GNUNET_assert (queue->content != NULL); - // is session already in queue? - if (session == queue->content) + while (queue != NULL) { - return; + // content is never NULL + GNUNET_assert (queue->content != NULL); + // is session already in queue? + if (session == queue->content) + { + return; + } + // try next + queue = queue->next; } - // try next - lastitem = queue; - queue = queue->next; - } - // Session is not in the queue + // Session is not in the queue - queue = GNUNET_malloc (sizeof (struct Sessionqueue)); - queue->content = session; + queue = GNUNET_malloc (sizeof (struct Sessionqueue)); + queue->content = session; - //insert at the tail - GNUNET_CONTAINER_DLL_insert_after (plugin->pending_Sessions, - plugin->pending_Sessions_tail, - plugin->pending_Sessions_tail, queue); - plugin->pendingsessions++; + //insert at the tail + GNUNET_CONTAINER_DLL_insert_tail(plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, queue); + plugin->pendingsessions++; + } } -//TODO doxigen /** * Function to schedule the write task, executed after a delay + * @param cls pointer to the plugin struct + * @param tc GNUNET_SCHEDULER_TaskContext pointer */ static void delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) @@ -856,7 +911,7 @@ delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) struct Plugin * plugin = cls; plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) return; // GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg @@ -868,63 +923,48 @@ delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) } } -//TODO doxigen /** * Function to calculate the time of the next periodic "hello-beacon" + * @param plugin pointer to the plugin struct */ + static void set_next_beacon_time(struct Plugin * const plugin) { //under 10 known peers: once a second - if (plugin->session_count < 10) + if (plugin->mac_count < 10) { plugin->beacon_time = GNUNET_TIME_absolute_add( - GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_multiply( - GNUNET_TIME_UNIT_SECONDS, HALLO_BEACON_SCALING_FACTOR)); + GNUNET_TIME_absolute_get(), + GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, + HALLO_BEACON_SCALING_FACTOR)); } //under 30 known peers: every 10 seconds - else if (plugin->session_count < 30) + else if (plugin->mac_count < 30) { plugin->beacon_time = GNUNET_TIME_absolute_add( - GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_multiply( - GNUNET_TIME_UNIT_SECONDS, 10 * HALLO_BEACON_SCALING_FACTOR)); + GNUNET_TIME_absolute_get(), + GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, + 10 * HALLO_BEACON_SCALING_FACTOR)); } //over 30 known peers: once a minute else { plugin->beacon_time = GNUNET_TIME_absolute_add( - GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_multiply( - GNUNET_TIME_UNIT_MINUTES, HALLO_BEACON_SCALING_FACTOR)); + GNUNET_TIME_absolute_get(), + GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, + HALLO_BEACON_SCALING_FACTOR)); } } -//TODO doxigen -struct GNUNET_TIME_Relative -get_next_frag_timeout(struct FragmentMessage * fm) -{ - return GNUNET_TIME_relative_min(GNUNET_TIME_absolute_get_remaining( - fm->next_ack), GNUNET_TIME_absolute_get_remaining(fm->timeout)); -} - -//TODO doxigen -/** - * Function to get the timeout value for acks for this session - */ - -struct GNUNET_TIME_Relative -get_ack_timeout(struct FragmentMessage * fm) -{ - return FRAGMENT_TIMEOUT; -} - /** * Function to set the timer for the next timeout of the fragment queue * @param plugin the handle to the plugin struct */ + static void -check_next_fragment_timeout(struct Plugin * const plugin) +set_next_send(struct Plugin * const plugin) { - struct FragmentMessage * fm; struct GNUNET_TIME_Relative next_send; //cancel old task @@ -933,66 +973,92 @@ check_next_fragment_timeout(struct Plugin * const plugin) GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task); plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; } - fm = plugin->pending_Fragment_Messages_head; - - GNUNET_assert(plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK); //check if some acks are in the queue if (plugin->ack_send_queue_head != NULL) { next_send = GNUNET_TIME_UNIT_ZERO; } + //check if there are some fragments in the queue + else if (plugin->sending_messages_head != NULL) + { + next_send = GNUNET_TIME_UNIT_ZERO; + } else { next_send = GNUNET_TIME_absolute_get_remaining(plugin->beacon_time); - if (fm != NULL) + } + +#if DEBUG_wlan + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Next packet is send in: %u\n", + next_send.rel_value); + +#endif + + if (next_send.rel_value == GNUNET_TIME_UNIT_ZERO.rel_value) + { + if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) + { + plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( + GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, + &do_transmit, plugin); + } + } + else + { + if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK) { - next_send = GNUNET_TIME_relative_min(next_send, - get_next_frag_timeout(fm)); + plugin->server_write_delay_task = GNUNET_SCHEDULER_add_delayed( + next_send, &delay_fragment_task, plugin); } } - plugin->server_write_delay_task = GNUNET_SCHEDULER_add_delayed(next_send, - &delay_fragment_task, plugin); } -//TODO doxigen /** * Function to get the next queued Session, removes the session from the queue + * @param plugin pointer to the plugin struct + * @return pointer to the session found, returns NULL if there is now session in the queue */ - static struct Session * -get_next_queue_Session(struct Plugin * plugin) +get_next_queue_session(struct Plugin * plugin) { struct Session * session; struct Sessionqueue * sessionqueue; struct Sessionqueue * sessionqueue_alt; struct PendingMessage * pm; - sessionqueue = plugin->pending_Sessions; + sessionqueue = plugin->pending_Sessions_head; + while (sessionqueue != NULL) { session = sessionqueue->content; - pm = session->pending_message; + GNUNET_assert(session != NULL); + pm = session->pending_message_head; + +#if DEBUG_wlan if (pm == NULL) { -#if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "pending message is empty, should not happen. session %p\n", session); -#endif } +#endif + GNUNET_assert(pm != NULL); //check for message timeout if (GNUNET_TIME_absolute_get_remaining(pm->timeout).rel_value > 0) { //check if session has no message in the fragment queue - if (session->fragment_messages_out_count - < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION) + if ((session->mac->fragment_messages_out_count + < FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT) + && (session->fragment_messages_out_count + < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION)) { plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions, + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, sessionqueue); GNUNET_free(sessionqueue); @@ -1005,9 +1071,7 @@ get_next_queue_Session(struct Plugin * plugin) } else { - - session->pending_message = session->pending_message2; - session->pending_message2 = NULL; + GNUNET_CONTAINER_DLL_remove(session->pending_message_head, session->pending_message_tail, pm); //call the cont func that it did not work if (pm->transmit_cont != NULL) @@ -1016,55 +1080,22 @@ get_next_queue_Session(struct Plugin * plugin) GNUNET_free(pm->msg); GNUNET_free(pm); - if (session->pending_message == NULL) + if (session->pending_message_head == NULL) { sessionqueue_alt = sessionqueue; sessionqueue = sessionqueue->next; plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions, + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, sessionqueue_alt); GNUNET_free(sessionqueue_alt); } - } } return NULL; } -/** - * Function to sort the message into the message fragment queue - * @param plugin the plugin struct - * @param fm message to sort into the queue - */ -static void -sort_fragment_into_queue(struct Plugin * plugin, struct FragmentMessage * fm) -{ - struct FragmentMessage * fm2; - //sort into the list at the right position - - fm2 = plugin->pending_Fragment_Messages_head; - - while (fm2 != NULL) - { - if (GNUNET_TIME_absolute_get_difference(fm2->next_ack, fm->next_ack).rel_value - == 0) - { - GNUNET_CONTAINER_DLL_insert_before(plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail,fm2,fm); - return; - } - else - { - fm2 = fm2->next; - } - } - - GNUNET_CONTAINER_DLL_insert_tail(plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail,fm); -} - /** * frees the space of a message in the fragment queue (send queue) * @param plugin the plugin struct @@ -1073,160 +1104,212 @@ sort_fragment_into_queue(struct Plugin * plugin, struct FragmentMessage * fm) static void free_fragment_message(struct Plugin * plugin, struct FragmentMessage * fm) { + struct Session * session = fm->session; + struct MacEndpoint * endpoint = session->mac; + struct FragmentMessage_queue * fmq; + struct FragmentMessage_queue * fmq_next; + if (fm != NULL) { - (fm->session->fragment_messages_out_count)--; - GNUNET_free_non_null(fm->msg); - GNUNET_CONTAINER_DLL_remove (plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail, fm); + fmq = plugin->sending_messages_head; + while (fmq != NULL) + { + fmq_next = fmq->next; + if (fmq->content == fm) + { + GNUNET_CONTAINER_DLL_remove(plugin->sending_messages_head,plugin->sending_messages_tail, fmq); + GNUNET_free(fmq); + } + fmq = fmq_next; + } + + (session->mac->fragment_messages_out_count)--; + session->fragment_messages_out_count--; + plugin->pending_Fragment_Messages--; + GNUNET_CONTAINER_DLL_remove(endpoint->sending_messages_head,endpoint->sending_messages_tail, fm); + GNUNET_FRAGMENT_context_destroy(fm->fragcontext); GNUNET_free(fm); - plugin->pending_fragment_messages--; + queue_session(plugin, session); #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "free pending fragment messages, pending messages remaining %u\n", - plugin->pending_fragment_messages); + "Free pending fragment messages %p, session %p\n", fm, session); #endif } } /** - * Function to check if there is some space in the fragment queue - * inserts a message if space is available - * @param plugin the plugin struct + * function to fill the radiotap header + * @param plugin pointer to the plugin struct + * @param endpoint pointer to the endpoint + * @param header pointer to the radiotap header + * @return GNUNET_YES at success */ - -static void -check_fragment_queue(struct Plugin * plugin) +static int +getRadiotapHeader(struct Plugin * plugin, struct MacEndpoint * endpoint, + struct Radiotap_Send * header) { - struct Session * session; - struct FragmentMessage * fm; - struct GNUNET_PeerIdentity pid; - - struct PendingMessage * pm; - if (plugin->pending_fragment_messages < FRAGMENT_QUEUE_SIZE) + if (endpoint != NULL) { - session = get_next_queue_Session(plugin); - if (session != NULL) - { - pm = session->pending_message; - session->pending_message = NULL; - session->fragment_messages_out_count++; - GNUNET_assert(pm != NULL); + header->rate = endpoint->rate; + header->tx_power = endpoint->tx_power; + header->antenna = endpoint->antenna; + } + else + { + header->rate = 255; + header->tx_power = 0; + header->antenna = 0; + } - fm = GNUNET_malloc(sizeof(struct FragmentMessage)); - fm->message_size = pm->message_size; - fm->msg = pm->msg; - fm->session = session; - fm->timeout.abs_value = pm->timeout.abs_value; - fm->message_pos = 0; - fm->next_ack = GNUNET_TIME_absolute_get(); - fm->message_id_out = get_next_message_id(); - fm->ack_bitfield = 0; + return GNUNET_YES; +} - sort_fragment_into_queue(plugin, fm); - plugin->pending_fragment_messages++; +/** + * function to generate the wlan hardware header for one packet + * @param Header address to write the header to + * @param to_mac_addr address of the recipient + * @param plugin pointer to the plugin struct + * @return GNUNET_YES if there was no error + */ +static int +getWlanHeader(struct ieee80211_frame * Header, + const struct MacAddress * to_mac_addr, struct Plugin * plugin, + unsigned int size) +{ + uint16_t * tmp16; + const int rate = 11000000; - if (pm->transmit_cont != NULL) - { - pid = session->target; - pm->transmit_cont(pm->transmit_cont_cls, &pid, GNUNET_OK); -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "called pm->transmit_cont for %p\n", session); -#endif - } - else - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "no pm->transmit_cont for %p\n", session); -#endif - } - GNUNET_free(pm); + Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA; + Header->i_fc[1] = 0x00; + memcpy(&Header->i_addr3, &mac_bssid, sizeof(mac_bssid)); + memcpy(&Header->i_addr2, plugin->mac_address.mac, sizeof(plugin->mac_address)); + memcpy(&Header->i_addr1, to_mac_addr, sizeof(struct MacAddress)); + + tmp16 = (uint16_t*) Header->i_dur; + *tmp16 = (uint16_t) htole16((size * 1000000) / rate + 290); + +#if DEBUG_wlan_ip_udp_packets_on_air + uint crc = 0; + uint16_t * x; + int count; + Header->ip.ip_dst.s_addr = *((uint32_t*) &to_mac_addr->mac[2]); + Header->ip.ip_src.s_addr = *((uint32_t*) &plugin->mac_address.mac[2]); + Header->ip.ip_v = 4; + Header->ip.ip_hl = 5; + Header->ip.ip_p = 17; + Header->ip.ip_ttl = 1; + Header->ip.ip_len = htons(size + 8); + Header->ip.ip_sum = 0; + x =(uint16_t *) &Header->ip; + count = sizeof(struct iph); + while (count > 1) + { + /* This is the inner loop */ + crc += (unsigned short) * x++; + count -= 2; + } + /* Add left-over byte, if any */ + if( count > 0 ) + crc += * (unsigned char *) x; + crc = (crc & 0xffff) + (crc >> 16); + Header->ip.ip_sum = htons(~ (unsigned short) crc); + Header->llc[0] = 6; + Header->llc[1] = 6; + Header->udp.len = htons(size - sizeof(struct ieee80211_frame)); - if (session->pending_message2 != NULL) - { - session->pending_message = session->pending_message2; - session->pending_message2 = NULL; - //requeue session - queue_Session(plugin, session); - } +#endif - //check if timeout changed - check_next_fragment_timeout(plugin); - } - } + return GNUNET_YES; } /** - * Funktion to check if all fragments where send and the acks received - * frees the space if finished - * @param plugin the plugin struct - * @param fm the message to check + * 32bit CRC + * + * @param msgbuf pointer tor the data + * @param msgbuf_size size of the data + * + * @return 32bit crc value */ -static void -check_finished_fragment(struct Plugin * plugin, struct FragmentMessage * fm) -{ - //maxack = size of message / max packet size, eg 12 / 5 = 2 start at 0 so ack numbers are 0,1,2 - unsigned int maxack = 63 - ((fm->message_size - 1) / (WLAN_MTU - - sizeof(struct FragmentationHeader))); - uint64_t tmpfield = UINT64_MAX; - tmpfield = tmpfield >> maxack; - - //#if DEBUG_wlan - if (maxack != 63) - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Test bitfields %X and %X, maxack is %u, fm size %u\n", - fm->ack_bitfield, tmpfield, maxack, fm->message_size); - //#endif - - if (fm->ack_bitfield == tmpfield) - { - free_fragment_message(plugin, fm); +uint32_t +getcrc32(const char *msgbuf, size_t msgbuf_size) +{ -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Finished sending and got all acks for a fragmented message\n"); -#endif + return GNUNET_CRYPTO_crc32_n(msgbuf, msgbuf_size);; +} - check_next_fragment_timeout(plugin); - check_fragment_queue(plugin); +/** + * 16bit CRC + * + * @param msgbuf pointer tor the data + * @param msgbuf_size size of the data + * + * @return 16bit crc value + */ - } +uint16_t +getcrc16(const char *msgbuf, size_t msgbuf_size) +{ + //TODO calc some crc + return 0; } /** - * Function to set the next fragment number - * @param fm use this FragmentMessage + * function to add a fragment of a message to send + * @param cls FragmentMessage this message belongs to + * @param hdr pointer to the start of the message */ void -set_next_message_fragment_pos(struct FragmentMessage * fm) +add_message_for_send(void *cls, const struct GNUNET_MessageHeader *hdr) { - //check if retransmit is needed - if (GNUNET_TIME_absolute_get_remaining(fm->next_ack).rel_value == 0) - { + struct FragmentMessage * fm = cls; + struct FragmentMessage_queue * fmqueue; + + GNUNET_assert(cls != NULL); + GNUNET_assert(fm->frag == NULL); + struct MacEndpoint * endpoint = fm->session->mac; + struct Plugin * plugin = endpoint->plugin; + struct GNUNET_MessageHeader * msgheader; + struct GNUNET_MessageHeader * msgheader2; + uint16_t size; - // be positive and try again later :-D - fm->next_ack = GNUNET_TIME_relative_to_absolute(get_ack_timeout(fm)); - // find first missing fragment +#if DEBUG_wlan_retransmission + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Adding fragment of message %p to send, session %p, endpoint %p\n", fm, + fm->session, endpoint); +#endif - fm->message_pos = 0; - } + size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) + + sizeof(struct ieee80211_frame) + ntohs(hdr->size); + fm->frag = GNUNET_malloc(size); + fm->size = size; - //test if ack 0 (or X) was already received - while (testBit((char*) &fm->ack_bitfield, fm->message_pos) == GNUNET_YES) - { - fm->message_pos++; - } + msgheader = (struct GNUNET_MessageHeader *) fm->frag; + msgheader->size = htons(size); + msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); + + fm->radioHeader = (struct Radiotap_Send*) &msgheader[1]; + fm->ieeewlanheader = (struct ieee80211_frame*) &fm->radioHeader[1]; + msgheader2 = (struct GNUNET_MessageHeader*) &fm->ieeewlanheader[1]; + memcpy(msgheader2, hdr, ntohs(hdr->size)); + fmqueue = GNUNET_malloc(sizeof(struct FragmentMessage_queue)); + fmqueue->content = fm; + + GNUNET_CONTAINER_DLL_insert_tail(plugin->sending_messages_head, + plugin->sending_messages_tail, fmqueue); + set_next_send(plugin); } -void +/** + * function to send a hallo beacon + * @param plugin pointer to the plugin struct + */ +static void send_hello_beacon(struct Plugin * plugin) { @@ -1234,18 +1317,19 @@ send_hello_beacon(struct Plugin * plugin) GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending hello beacon\n"); #endif - uint16_t size = 0; + uint16_t size; ssize_t bytes; - struct GNUNET_MessageHeader * msgheader = NULL; - struct ieee80211_frame * ieeewlanheader = NULL; - struct Radiotap_Send * radioHeader = NULL; - struct GNUNET_MessageHeader * msgheader2 = NULL; - - GNUNET_assert(sizeof(struct WlanHeader) + GNUNET_HELLO_size( - *(plugin->env->our_hello)) <= WLAN_MTU); + uint16_t hallo_size; + struct GNUNET_MessageHeader * msgheader; + struct ieee80211_frame * ieeewlanheader; + struct Radiotap_Send * radioHeader; + struct GNUNET_MessageHeader * msgheader2; + + hallo_size = GNUNET_HELLO_size(*(plugin->env->our_hello)); + GNUNET_assert(sizeof(struct WlanHeader) + hallo_size <= WLAN_MTU); size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) + sizeof(struct ieee80211_frame) + sizeof(struct GNUNET_MessageHeader) - + GNUNET_HELLO_size(*(plugin->env->our_hello)); + + hallo_size; msgheader = GNUNET_malloc(size); msgheader->size = htons(size); @@ -1254,15 +1338,15 @@ send_hello_beacon(struct Plugin * plugin) radioHeader = (struct Radiotap_Send*) &msgheader[1]; getRadiotapHeader(plugin, NULL, radioHeader); ieeewlanheader = (struct ieee80211_frame*) &radioHeader[1]; - getWlanHeader(ieeewlanheader, bc_all_mac, plugin); + getWlanHeader(ieeewlanheader, &bc_all_mac, plugin, size); msgheader2 = (struct GNUNET_MessageHeader*) &ieeewlanheader[1]; - msgheader2->size = htons(GNUNET_HELLO_size(*(plugin->env->our_hello)) - + sizeof(struct GNUNET_MessageHeader)); + msgheader2->size = htons( + GNUNET_HELLO_size(*(plugin->env->our_hello)) + + sizeof(struct GNUNET_MessageHeader)); msgheader2->type = htons(GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT); - memcpy(&msgheader2[1], *plugin->env->our_hello, GNUNET_HELLO_size( - *(plugin->env->our_hello))); + memcpy(&msgheader2[1], *plugin->env->our_hello, hallo_size); bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, msgheader, size); @@ -1278,285 +1362,195 @@ send_hello_beacon(struct Plugin * plugin) GNUNET_free(msgheader); set_next_beacon_time(plugin); - check_next_fragment_timeout(plugin); + set_next_send(plugin); } +/** + * function to add an ack to send it for a received fragment + * @param cls MacEndpoint this ack belongs to + * @param msg_id id of the message + * @param hdr pointer to the hdr where the ack is stored + * + */ + static void -send_ack(struct Plugin * plugin, struct AckSendQueue * ack) +add_ack_for_send(void *cls, uint32_t msg_id, + const struct GNUNET_MessageHeader *hdr) { - uint16_t size = 0; - ssize_t bytes; - struct GNUNET_MessageHeader * msgheader = NULL; - struct ieee80211_frame * ieeewlanheader = NULL; - struct Radiotap_Send * radioHeader = NULL; - struct FragmentationAckHeader * msgheader2 = NULL; + struct AckSendQueue * ack; - GNUNET_assert(sizeof(struct FragmentationAckHeader) <= WLAN_MTU); + GNUNET_assert(cls != NULL); + struct MacEndpoint * endpoint = cls; + struct Plugin * plugin = endpoint->plugin; + struct GNUNET_MessageHeader * msgheader; + struct GNUNET_MessageHeader * msgheader2; + uint16_t size; -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending ack for message_id %u with fragment field %u\n", - ack->message_id, ack->fragments_field); -#endif + size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) + + sizeof(struct ieee80211_frame) + ntohs(hdr->size) + + sizeof(struct AckSendQueue); + + ack = GNUNET_malloc(size); + ack->message_id = msg_id; + ack->endpoint = endpoint; size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) - + sizeof(struct ieee80211_frame) + sizeof(struct FragmentationAckHeader); - msgheader = GNUNET_malloc(size); + + sizeof(struct ieee80211_frame) + ntohs(hdr->size); + + msgheader = (struct GNUNET_MessageHeader *) &ack[1]; + ack->hdr = (struct GNUNET_MessageHeader *) &ack[1]; msgheader->size = htons(size); msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); - radioHeader = (struct Radiotap_Send*) &msgheader[1]; - getRadiotapHeader(plugin, ack->session, radioHeader); - ieeewlanheader = (struct ieee80211_frame*) &radioHeader[1]; - getWlanHeader(ieeewlanheader, ack->session->addr, plugin); + ack->radioHeader = (struct Radiotap_Send*) &msgheader[1]; + ack->ieeewlanheader = (struct ieee80211_frame*) &(ack->radioHeader)[1]; + msgheader2 = (struct GNUNET_MessageHeader*) &(ack->ieeewlanheader)[1]; + memcpy(msgheader2, hdr, ntohs(hdr->size)); - msgheader2 = (struct FragmentationAckHeader*) &ieeewlanheader[1]; - msgheader2->header.size = htons(sizeof(struct FragmentationAckHeader)); - msgheader2->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT_ACK); - msgheader2->message_id = htonl(ack->message_id); - msgheader2->fragment_field = htonll(ack->fragments_field); + GNUNET_CONTAINER_DLL_insert_tail(plugin->ack_send_queue_head, + plugin->ack_send_queue_tail, ack); - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, msgheader, size); - if (bytes == GNUNET_SYSERR) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), - errno, strerror(errno)); +#if DEBUG_wlan_retransmission + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Adding ack with message id %u to send, AckSendQueue %p, endpoint %p\n", + msg_id, ack, endpoint); +#endif - } - GNUNET_assert(bytes != GNUNET_SYSERR); - GNUNET_assert(bytes == size); - GNUNET_free(msgheader); - check_next_fragment_timeout(plugin); + set_next_send(plugin); } /** - * Function called when wlan helper is ready to get some data - * - * @param cls closure - * @param tc GNUNET_SCHEDULER_TaskContext + * Function to check if there is some space in the fragment queue + * inserts a message if space is available + * @param plugin the plugin struct */ static void -do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +check_fragment_queue(struct Plugin * plugin) { + struct Session * session; + struct FragmentMessage * fm; + struct GNUNET_PeerIdentity pid; - struct Plugin * plugin = cls; - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) - return; - - struct Session * session = NULL; - struct FragmentMessage * fm = NULL; - struct ieee80211_frame * ieeewlanheader = NULL; - struct Radiotap_Send * radioHeader = NULL; - struct GNUNET_MessageHeader * msgheader = NULL; - - struct FragmentationHeader fragheader; - struct FragmentationHeader * fragheaderptr = NULL; - struct Finish_send * finish = NULL; - struct AckSendQueue * ack; - uint16_t size = 0; - ssize_t bytes; - const char * copystart = NULL; - uint16_t copysize = 0; - uint copyoffset = 0; - - if (plugin->ack_send_queue_head != NULL) - { - ack = plugin->ack_send_queue_head; - GNUNET_CONTAINER_DLL_remove(plugin->ack_send_queue_head, - plugin->ack_send_queue_tail, ack); - send_ack(plugin, ack); - GNUNET_free(ack); - return; - } - - //test if a "hello-beacon" has to be send - if (GNUNET_TIME_absolute_get_remaining(plugin->beacon_time).rel_value == 0) - { - send_hello_beacon(plugin); - - return; - - } + struct PendingMessage * pm; - fm = plugin->pending_Fragment_Messages_head; - if (fm != NULL) + if (plugin->pending_Fragment_Messages < FRAGMENT_QUEUE_SIZE) { - session = fm->session; - GNUNET_assert(session != NULL); - - // test if message timed out - if (GNUNET_TIME_absolute_get_remaining(fm->timeout).rel_value == 0) - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "message timeout\n"); -#endif - - check_fragment_queue(plugin); - free_fragment_message(plugin, fm); - - } - else + session = get_next_queue_session(plugin); + if (session != NULL) { + pm = session->pending_message_head; + GNUNET_CONTAINER_DLL_remove(session->pending_message_head, session->pending_message_tail, pm); + session->mac->fragment_messages_out_count++; + session->fragment_messages_out_count++; + plugin->pending_Fragment_Messages++; + GNUNET_assert(pm != NULL); - //if (fm->message_size > WLAN_MTU) - // { - size += sizeof(struct FragmentationHeader); - - set_next_message_fragment_pos(fm); - - copyoffset = (WLAN_MTU - sizeof(struct FragmentationHeader)) - * fm->message_pos; + fm = GNUNET_malloc(sizeof(struct FragmentMessage)); + fm->session = session; + fm->timeout.abs_value = pm->timeout.abs_value; + fm->frag = NULL; + fm->fragcontext = GNUNET_FRAGMENT_context_create(plugin->env->stats, + WLAN_MTU, &plugin->tracker, GNUNET_TIME_UNIT_SECONDS, + &(pm->msg->header), &add_message_for_send, + fm); + GNUNET_CONTAINER_DLL_insert_tail(session->mac->sending_messages_head,session->mac->sending_messages_tail,fm); + if (pm->transmit_cont != NULL) + { + pid = session->target; + pm->transmit_cont(pm->transmit_cont_cls, &pid, GNUNET_OK); #if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT with message_id %u with fragment number %i, size: %u, offset %u, time until timeout %u\n", - fm->message_id_out, fm->message_pos, copysize - + sizeof(struct FragmentationHeader), copyoffset, - GNUNET_TIME_absolute_get_remaining(fm->timeout)); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "called pm->transmit_cont for %p\n", session); #endif - - fragheader.fragment_off_or_num = htons(fm->message_pos); - fragheader.message_id = htonl(fm->message_id_out); - copystart = fm->msg + copyoffset; - copysize = GNUNET_MIN(fm->message_size - copyoffset, - WLAN_MTU - sizeof(struct FragmentationHeader)); - - if (copyoffset >= fm->message_size) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - "offset in message for fragment too large, offset %u, size %u, max size %u, copysize %u, message_pos %u,\n", - copyoffset, fm->message_size, WLAN_MTU - - sizeof(struct FragmentationHeader), copysize, - fm->message_pos); } - GNUNET_assert(copyoffset < fm->message_size); - //FIXME remove later - GNUNET_assert(copystart < fm->msg + fm->message_size); - - fragheader.header.size = htons(copysize - + sizeof(struct FragmentationHeader)); - fragheader.header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT); - - /* } - else - { - // there is no need to split - copystart = fm->msg; - copysize = fm->message_size; - }*/ - - size += copysize; - size += sizeof(struct Radiotap_Send) + sizeof(struct ieee80211_frame) - + sizeof(struct GNUNET_MessageHeader); - msgheader = GNUNET_malloc(size); - msgheader->size = htons(size); - msgheader->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); - - radioHeader = (struct Radiotap_Send*) &msgheader[1]; - getRadiotapHeader(plugin, session, radioHeader); - - ieeewlanheader = (struct ieee80211_frame *) &radioHeader[1]; - getWlanHeader(ieeewlanheader, fm->session->addr, plugin); - - //could be faster if content is just send and not copyed before - //fragmentheader is needed - //if (fm->message_size > WLAN_MTU) - // { - fragheader.message_crc = htons(getcrc16(copystart, copysize)); - memcpy(&ieeewlanheader[1], &fragheader, - sizeof(struct FragmentationHeader)); - fragheaderptr = (struct FragmentationHeader *) &ieeewlanheader[1]; - memcpy(&fragheaderptr[1], copystart, copysize); - /* } - else - { - memcpy(&ieeewlanheader[1], copystart, copysize); - }*/ - - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, - msgheader, size); - if (bytes == GNUNET_SYSERR) + else { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), - errno, strerror(errno)); - +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "no pm->transmit_cont for %p\n", session); +#endif } - GNUNET_assert(bytes != GNUNET_SYSERR); + GNUNET_free(pm); - if (bytes != size) + if (session->pending_message_head != NULL) { - finish = GNUNET_malloc(sizeof( struct Finish_send)); - finish->plugin = plugin; - finish->msgheader = (char *) msgheader + bytes; - finish->size = size - bytes; - finish->msgstart = msgheader; - - GNUNET_assert(plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); + //requeue session + queue_session(plugin, session); + } - plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, - &finish_sending, finish); + } + } - } - else - { - GNUNET_assert(bytes == size); + //check if timeout changed + set_next_send(plugin); +} - GNUNET_free(msgheader); - check_next_fragment_timeout(plugin); - } +/** + * Function to send an ack, does not free the ack + * @param plugin pointer to the plugin + * @param ack pointer to the ack to send + */ +static void +send_ack(struct Plugin * plugin, struct AckSendQueue * ack) +{ - //check if this was the last fragment of this message, if true then queue at the end of the list - if (copysize + copyoffset >= fm->message_size) - { - GNUNET_assert(copysize + copyoffset == fm->message_size); + ssize_t bytes; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail, fm); +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending ack for message_id %u for mac endpoint %p, size %u\n", + ack->message_id, ack->endpoint, + ntohs(ack->hdr->size) - sizeof(struct Radiotap_Send)); +#endif - GNUNET_CONTAINER_DLL_insert_tail(plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail, fm); - // if fragments have opimized timeouts - //sort_fragment_into_queue(plugin,fm); + getRadiotapHeader(plugin, ack->endpoint, ack->radioHeader); + getWlanHeader(ack->ieeewlanheader, &ack->endpoint->addr, plugin, + ntohs(ack->hdr->size)); - } + bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, ack->hdr, + ntohs(ack->hdr->size)); + if (bytes == GNUNET_SYSERR) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), + errno, strerror(errno)); - } - return; } - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "do_transmit did nothing, should not happen!\n"); + GNUNET_assert(bytes != GNUNET_SYSERR); + GNUNET_assert(bytes == ntohs(ack->hdr->size)); + set_next_send(plugin); } +/** + * function to finish a sending if not all could have been writen befor + * @param cls pointer to the Finish_send struct + * @param tc TaskContext + */ static void finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct Finish_send * finish; + struct Finish_send * finish = cls; struct Plugin * plugin; ssize_t bytes; - finish = cls; plugin = finish->plugin; - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) + { + GNUNET_free (finish->msgstart); + GNUNET_free (finish); + return; + } bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, finish->msgheader, finish->size); - GNUNET_assert(bytes != GNUNET_SYSERR); + GNUNET_assert (bytes != GNUNET_SYSERR); - GNUNET_assert(plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); if (bytes != finish->size) { - finish->msgheader = finish->msgheader + bytes; finish->size = finish->size - bytes; plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( @@ -1567,83 +1561,140 @@ finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { GNUNET_free(finish->msgstart); GNUNET_free(finish); - check_next_fragment_timeout(plugin); + set_next_send(plugin); } - } -int -getRadiotapHeader(struct Plugin * plugin, struct Session * session, - struct Radiotap_Send * header) +/** + * Function called when wlan helper is ready to get some data + * + * @param cls closure + * @param tc GNUNET_SCHEDULER_TaskContext + */ +static void +do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { + struct Plugin * plugin = cls; - if (session != NULL) + plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) + return; + + struct Session * session; + struct FragmentMessage * fm; + struct Finish_send * finish; + struct FragmentMessage_queue * fmq; + struct AckSendQueue * ack; + ssize_t bytes; + + if (plugin->ack_send_queue_head != NULL) { - header->rate = session->rate; - header->tx_power = session->tx_power; - header->antenna = session->antenna; + ack = plugin->ack_send_queue_head; + GNUNET_CONTAINER_DLL_remove(plugin->ack_send_queue_head, + plugin->ack_send_queue_tail, ack); + send_ack(plugin, ack); + GNUNET_free(ack); + return; } - else + + //test if a "hello-beacon" has to be send + if (GNUNET_TIME_absolute_get_remaining(plugin->beacon_time).rel_value == 0) { - header->rate = 255; - header->tx_power = 0; - header->antenna = 0; + send_hello_beacon(plugin); + return; } - return GNUNET_YES; -} -; + if (plugin->sending_messages_head != NULL) + { + fmq = plugin->sending_messages_head; + fm = fmq->content; + GNUNET_CONTAINER_DLL_remove(plugin->sending_messages_head,plugin->sending_messages_tail,fmq); + GNUNET_free(fmq); -/** - * function to generate the wlan hardware header for one packet - * @param Header address to write the header to - * @param to_mac_addr address of the recipient - * @param plugin pointer to the plugin struct - * @return GNUNET_YES if there was no error - */ + session = fm->session; + GNUNET_assert(session != NULL); -int -getWlanHeader(struct ieee80211_frame * Header, const char * const to_mac_addr, - struct Plugin * plugin) -{ - Header->i_fc[0] = 0x80; - Header->i_fc[1] = 0x00; - memcpy(&Header->i_addr3, mac_bssid, sizeof(mac_bssid)); - memcpy(&Header->i_addr2, plugin->mac_address.mac, sizeof(plugin->mac_address)); - memcpy(&Header->i_addr1, to_mac_addr, sizeof(plugin->mac_address)); - return GNUNET_YES; -} +#if DEBUG_wlan + GNUNET_log( + GNUNET_ERROR_TYPE_DEBUG, + "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT for fragment message %p, size: %u\n", + fm, fm->size); +#endif -/** - * 32bit CRC - * - * @param msgbuf pointer tor the data - * @param msgbuf_size size of the data - * - * @return 32bit crc value - */ + getRadiotapHeader(plugin, session->mac, fm->radioHeader); + getWlanHeader(fm->ieeewlanheader, &(fm->session->mac->addr), plugin, + fm->size); -uint32_t -getcrc32(const char *msgbuf, size_t msgbuf_size) -{ - //TODO calc some crc - return 0; + bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, fm->frag, + fm->size); + if (bytes == GNUNET_SYSERR) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), + errno, strerror(errno)); + + } + GNUNET_assert(bytes != GNUNET_SYSERR); + + if (bytes != fm->size) + { + finish = GNUNET_malloc(sizeof( struct Finish_send)); + finish->plugin = plugin; + finish->msgheader = fm->frag + bytes; + finish->size = fm->size - bytes; + finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag; + + GNUNET_assert(plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); + + plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( + GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, + &finish_sending, finish); + fm->frag = NULL; + } + else + { + GNUNET_free(fm->frag); + fm->frag = NULL; + set_next_send(plugin); + } + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); + return; + } + + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "do_transmit did nothing, should not happen!\n"); } /** - * 16bit CRC - * - * @param msgbuf pointer tor the data - * @param msgbuf_size size of the data + * Another peer has suggested an address for this + * peer and transport plugin. Check that this could be a valid + * address. If so, consider adding it to the list + * of addresses. * - * @return 16bit crc value + * @param cls closure + * @param addr pointer to the address + * @param addrlen length of addr + * @return GNUNET_OK if this is a plausible address for this peer + * and transport */ +static int +wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen) +{ + //struct Plugin *plugin = cls; + + /* check if the address is plausible; if so, + add it to our list! */ + + GNUNET_assert(cls !=NULL); + //FIXME mitm is not checked + //Mac Address has 6 bytes + if (addrlen == 6) + { + /* TODO check for bad addresses like multicast, broadcast, etc */ + return GNUNET_OK; + } -uint16_t -getcrc16(const char *msgbuf, size_t msgbuf_size) -{ - //TODO calc some crc - return 0; + return GNUNET_SYSERR; } /** @@ -1655,7 +1706,7 @@ getcrc16(const char *msgbuf, size_t msgbuf_size) * @param priority how important is the message * @param msgbuf the message to transmit * @param msgbuf_size number of bytes in 'msgbuf' - * @param timeout when should we time out + * @param timeout when should we time out * @param session which session must be used (or NULL for "any") * @param addr the address to use (can be NULL if the plugin * is "on its own" (i.e. re-use existing TCP connection)) @@ -1680,8 +1731,8 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { struct Plugin * plugin = cls; - struct PendingMessage * newmsg = NULL; - struct WlanHeader * wlanheader = NULL; + struct PendingMessage * newmsg; + struct WlanHeader * wlanheader; //check if msglen > 0 GNUNET_assert(msgbuf_size > 0); @@ -1691,7 +1742,7 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, { if (wlan_plugin_address_suggested(plugin, addr, addrlen) == GNUNET_OK) { - session = get_Session(plugin, addr); + session = get_session(plugin, addr, target); } else { @@ -1701,46 +1752,37 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, } } - //TODO target "problem" not solved - //if (session->target != NULL){ - // GNUNET_assert(session->target == *target); - //} else { - session->target = *target; - //} - - //queue message: //queue message in session //test if there is no other message in the "queue" //FIXME: to many send requests - //GNUNET_assert (session->pending_message == NULL); - if (session->pending_message != NULL) + if (session->pending_message_head != NULL) { - newmsg = session->pending_message; + newmsg = session->pending_message_head; GNUNET_log( GNUNET_ERROR_TYPE_ERROR, - "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages %u\n", + "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n", GNUNET_TIME_absolute_get_remaining(newmsg->timeout).rel_value, - session->fragment_messages_out_count); - if (session->pending_message2 != NULL) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - "wlan_plugin_send: two pending messages are already in the queue for this client\n"); - return -1; - } + session->mac->fragment_messages_out_count); } newmsg = GNUNET_malloc(sizeof(struct PendingMessage)); - (newmsg->msg) = GNUNET_malloc(msgbuf_size + sizeof(struct WlanHeader)); - wlanheader = (struct WlanHeader *) newmsg->msg; + newmsg->msg = GNUNET_malloc(msgbuf_size + sizeof(struct WlanHeader)); + wlanheader = newmsg->msg; //copy msg to buffer, not fragmented / segmented yet, but with message header wlanheader->header.size = htons(msgbuf_size + sizeof(struct WlanHeader)); wlanheader->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA); memcpy(&(wlanheader->target), target, sizeof(struct GNUNET_PeerIdentity)); - wlanheader->crc = htonl(getcrc32(msgbuf, msgbuf_size)); + memcpy(&(wlanheader->source), plugin->env->my_identity, + sizeof(struct GNUNET_PeerIdentity)); + wlanheader->crc = 0; memcpy(&wlanheader[1], msgbuf, msgbuf_size); + wlanheader->crc = htonl( + getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader))); + //GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Wlan message Header crc: %u, %u\n",getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)), wlanheader->crc); + //hexdump(newmsg->msg, msgbuf_size + sizeof(struct WlanHeader)); + newmsg->transmit_cont = cont; newmsg->transmit_cont_cls = cont_cls; newmsg->timeout = GNUNET_TIME_relative_to_absolute(timeout); @@ -1749,14 +1791,7 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, newmsg->message_size = msgbuf_size + sizeof(struct WlanHeader); - if (session->pending_message == NULL) - { - session->pending_message = newmsg; - } - else - { - session->pending_message2 = newmsg; - } + GNUNET_CONTAINER_DLL_insert_tail(session->pending_message_head, session->pending_message_tail, newmsg); #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, @@ -1765,7 +1800,7 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, #endif //queue session - queue_Session(plugin, session); + queue_session(plugin, session); check_fragment_queue(plugin); //FIXME not the correct size @@ -1774,45 +1809,104 @@ wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, } /** - * function to get the first message in the fragement queue (out) of a session - * @param session pointer to the session - * @return pointer to the struct FragmentMessage + * function to free a mac endpoint + * @param plugin pointer to the plugin struct + * @param endpoin pointer to the MacEndpoint to free */ -static struct FragmentMessage * -get_fragment_message_from_session(struct Session * session) +static void +free_macendpoint(struct Plugin * plugin, struct MacEndpoint * endpoin) { - struct FragmentMessage * fm = session->plugin->pending_Fragment_Messages_head; - while (fm != NULL) + struct Sessionqueue * sessions; + struct Sessionqueue * sessions_next; + GNUNET_assert(endpoin != NULL); + + sessions = endpoin->sessions_head; + while (sessions != NULL) { - if (fm->session == session) - { - return fm; - } - fm = fm->next; + sessions_next = sessions->next; + free_session(plugin, sessions, GNUNET_NO); + sessions = sessions_next; } - return NULL; + + GNUNET_CONTAINER_DLL_remove(plugin->mac_head,plugin->mac_tail,endpoin); + GNUNET_free(endpoin); + } /** - * function to get the message in the fragement queue (out) of a session with a specific id - * @param session pointer to the session - * @param message_id id of the message - * @return pointer to the struct FragmentMessage - */ -static struct FragmentMessage * -get_fragment_message_from_session_and_id(struct Session * session, - uint32_t message_id) + * function to free a session + * @param plugin pointer to the plugin + * @param queue pointer to the sessionqueue element to free + * @param free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint + */ +static void +free_session(struct Plugin * plugin, struct Sessionqueue * queue, + int do_free_macendpoint) { - struct FragmentMessage * fm = session->plugin->pending_Fragment_Messages_head; + struct Sessionqueue * pendingsession; + struct Sessionqueue * pendingsession_tmp; + struct PendingMessage * pm; + struct MacEndpoint * endpoint; + struct FragmentMessage * fm; + struct FragmentMessage * fmnext; + int check = 0; + + GNUNET_assert(queue != NULL); + GNUNET_assert(queue->content != NULL); + + //session found + //is this session pending for send + pendingsession = plugin->pending_Sessions_head; + while (pendingsession != NULL) + { + pendingsession_tmp = pendingsession->next; + if (pendingsession->content == queue->content) + { + plugin->pendingsessions--; + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, + pendingsession); + GNUNET_free(pendingsession); + + GNUNET_assert (check == 0); + check = 1; + } + pendingsession = pendingsession_tmp; + } + + endpoint = queue->content->mac; + fm = endpoint->sending_messages_head; while (fm != NULL) { - if ((fm->session == session) && (fm->message_id_out == message_id)) + fmnext = fm->next; + if (fm->session == queue->content) { - return fm; + free_fragment_message(plugin, fm); } - fm = fm->next; + fm = fmnext; } - return NULL; + + // remove PendingMessage + pm = queue->content->pending_message_head; + while (pm != NULL) + { + GNUNET_CONTAINER_DLL_remove(queue->content->pending_message_head,queue->content->pending_message_tail,pm); + GNUNET_free(pm->msg); + GNUNET_free(pm); + pm = queue->content->pending_message_head; + } + + GNUNET_CONTAINER_DLL_remove(endpoint->sessions_head , + endpoint->sessions_tail, + queue); + + if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES) + { + free_macendpoint(plugin, endpoint); + } + GNUNET_free(queue->content); + GNUNET_free(queue); + check_fragment_queue(plugin); } /** @@ -1827,71 +1921,29 @@ static void wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) { struct Plugin *plugin = cls; - struct Sessionqueue * queue = plugin->sessions; - struct Sessionqueue * pendingsession = plugin->pending_Sessions; - struct PendingMessage * pm = NULL; - struct FragmentMessage * fm; - struct Receive_Message_Queue * receive_queue; - + struct Sessionqueue * queue; + struct Sessionqueue * queue_next; + struct MacEndpoint * endpoint = plugin->mac_head; + struct MacEndpoint * endpoint_next; // just look at all the session for the needed one - while (queue != NULL) + while (endpoint != NULL) { - // content is never NULL - GNUNET_assert (queue->content != NULL); - if (memcmp(target, &(queue->content->target), - sizeof(struct GNUNET_PeerIdentity)) == 0) + queue = endpoint->sessions_head; + endpoint_next = endpoint->next; + while (queue != NULL) { - //session found - //is this session pending for send - while (pendingsession != NULL) - { - if (pendingsession->content == queue->content) - { - plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions, - plugin->pending_Sessions_tail, pendingsession); - GNUNET_free(pendingsession); - break; - } - pendingsession = pendingsession->next; - } - - //is something of this session in the fragment queue? - fm = get_fragment_message_from_session(queue->content); - while (fm != NULL) + // content is never NULL + GNUNET_assert (queue->content != NULL); + queue_next = queue->next; + if (memcmp(target, &(queue->content->target), + sizeof(struct GNUNET_PeerIdentity)) == 0) { - free_fragment_message(plugin, fm); - fm = get_fragment_message_from_session(queue->content); - } - check_next_fragment_timeout(plugin); - - //dispose all received fragments - receive_queue = get_receive_message_from_session(plugin, - queue->content); - while (receive_queue != NULL) - { - free_receive_message(plugin, receive_queue); - receive_queue = get_receive_message_from_session(plugin, - queue->content); + free_session(plugin, queue, GNUNET_YES); } - - // remove PendingMessage - pm = queue->content->pending_message; - if (pm != NULL) - { - GNUNET_free_non_null(pm->msg); - GNUNET_free(pm); - } - - GNUNET_free(queue->content); - GNUNET_CONTAINER_DLL_remove(plugin->sessions, plugin->sessions_tail, queue); - GNUNET_free(queue); - plugin->session_count--; - - return; + // try next + queue = queue_next; } - // try next - queue = queue->next; + endpoint = endpoint_next; } } @@ -1904,325 +1956,32 @@ wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) * @param addr one of the addresses of the host, NULL for the last address * the specific address format depends on the transport * @param addrlen length of the address - * @param numeric should (IP) addresses be displayed in numeric form? - * @param timeout after how long should we give up? - * @param asc function to call on each string - * @param asc_cls closure for asc - */ -static void -wlan_plugin_address_pretty_printer(void *cls, const char *type, - const void *addr, size_t addrlen, int numeric, - struct GNUNET_TIME_Relative timeout, - GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls) -{ - char ret[92]; - const unsigned char * input; - - //GNUNET_assert(cls !=NULL); - if (addrlen != 6) - { - /* invalid address (MAC addresses have 6 bytes) */ - GNUNET_break (0); - asc(asc_cls, NULL); - return; - } - input = (const unsigned char*) addr; - GNUNET_snprintf(ret, sizeof(ret), - "%s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", PROTOCOL_PREFIX, - input[0], input[1], input[2], input[3], input[4], input[5]); - asc(asc_cls, ret); -} - -/** - * Another peer has suggested an address for this - * peer and transport plugin. Check that this could be a valid - * address. If so, consider adding it to the list - * of addresses. - * - * @param cls closure - * @param addr pointer to the address - * @param addrlen length of addr - * @return GNUNET_OK if this is a plausible address for this peer - * and transport - */ - -static int -wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen) -{ - //struct Plugin *plugin = cls; - - /* check if the address is plausible; if so, - add it to our list! */ - - GNUNET_assert(cls !=NULL); - //FIXME mitm is not checked - //Mac Address has 6 bytes - if (addrlen == 6) - { - /* TODO check for bad addresses like multicast, broadcast, etc */ - return GNUNET_OK; - } - - return GNUNET_SYSERR; -} - -/** - * Function called for a quick conversion of the binary address to - * a numeric address. Note that the caller must not free the - * address and that the next call to this function is allowed - * to override the address again. - * - * @param cls closure - * @param addr binary address - * @param addrlen length of the address - * @return string representing the same address - */ -static const char* -wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen) -{ - static char ret[40]; - const struct MacAddress *mac; - - if (addrlen != sizeof(struct MacAddress)) - { - GNUNET_break (0); - return NULL; - } - mac = addr; - GNUNET_snprintf(ret, sizeof(ret), "%s Mac-Address %X:%X:%X:%X:%X:%X", - PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], mac->mac[3], - mac->mac[4], mac->mac[5]); - return ret; -} - -/** - * function to check if bitfield is representation of fragments of the message - * @param rec_message message to check - */ - -void -check_message_fragment_bitfield(struct Receive_Message_Queue * rec_message) -{ - uint64_t checkfragments = 0; - struct Receive_Fragment_Queue * rec_queue = rec_message->frag_head; - - while (rec_queue != NULL) - { - setBit((char*) &checkfragments, rec_queue->num); - rec_queue = rec_queue->next; - - } - GNUNET_assert(checkfragments == rec_message->received_fragments); -} - -/** - * Function to test if fragment number already exists in the fragments received - * - * @param rec_message message this fragment belongs to - * @param fh Fragmentheader of the fragment - * @return GNUNET_YES if fragment exists already, GNUNET_NO if it does not exists in the queue of the session - */ - -static const int -is_double_msg(struct Receive_Message_Queue * rec_message, - struct FragmentationHeader * fh) -{ - //test if bitfield is okay -#if DEBUG_wlan - check_message_fragment_bitfield(rec_message); -#endif - - return testBit((char *) &rec_message->received_fragments, ntohs( - fh->fragment_off_or_num)); - -} - -/** - * Function to insert a fragment in a queue of a message - * @param session session the fragment belongs to - * @param rec_queue fragment to add - */ - -static void -insert_fragment_in_queue(struct Receive_Message_Queue * rec_message, - struct Receive_Fragment_Queue * rec_queue) -{ - GNUNET_assert(rec_message != NULL); - GNUNET_assert(rec_queue != NULL); - - struct Receive_Fragment_Queue * rec_queue2 = rec_message->frag_head; - struct WlanHeader * wlanheader = NULL; - - //this is the first fragment of the message (fragment id 0) - if (rec_queue->num == 0) - { - wlanheader = (struct WlanHeader *) rec_queue->msg; - rec_message->rec_size = ntohs(wlanheader->header.size); - } - - //sort into list - while (rec_queue2 != NULL) - { - if (rec_queue2->num > rec_queue->num) - { - //next element number is grater than the current num - GNUNET_CONTAINER_DLL_insert_before(rec_message->frag_head, rec_message->frag_tail, rec_queue2, rec_queue); - setBit((char *) &rec_message->received_fragments, rec_queue->num); - return; - } - rec_queue = rec_queue->next; - } - //no element has a grater number - GNUNET_CONTAINER_DLL_insert_tail(rec_message->frag_head, rec_message->frag_tail, rec_queue); - - setBit((char *) &rec_message->received_fragments, rec_queue->num); -} - -/** - * Function to dispose the fragments received for a message and the message - * @param plugin pointer to the plugin struct - * @param rec_message pointer to the struct holding the message which should be freed - */ - -static void -free_receive_message(struct Plugin* plugin, - struct Receive_Message_Queue * rx_message) -{ - GNUNET_assert(rx_message !=NULL); - struct Receive_Fragment_Queue * rec_queue = rx_message->frag_head; - struct Receive_Fragment_Queue * rec_queue2; - - while (rec_queue != NULL) - { - rec_queue2 = rec_queue; - rec_queue = rec_queue->next; - GNUNET_free(rec_queue2); - } - - GNUNET_CONTAINER_DLL_remove(plugin->receive_messages_head,plugin->receive_messages_teil, rx_message); - - GNUNET_assert(plugin->pending_receive_messages > 0); - GNUNET_assert(rx_message->session->fragment_messages_in_count > 0); - - plugin->pending_receive_messages--; - rx_message->session->fragment_messages_in_count--; - GNUNET_free(rx_message); -} - -/** - * Function to check if all fragments of a message have been received - * @param plugin the plugin handle - * @param session_light information of the message sender - * @param session session the message belongs to - * @param rec_message pointer to the message that should be checked - */ - -static void -check_rec_finished_msg(struct Plugin* plugin, - struct Session_light * session_light, struct Session * session, - struct Receive_Message_Queue * rx_message) -{ - GNUNET_assert(rx_message !=NULL); - - struct Receive_Fragment_Queue * rx_frag = rx_message->frag_head; - int packetsize = rx_message->rec_size; - int sum = 0; - int aktnum = 0; - uint64_t bitfield = 0; - char * msg; - - //check if first fragment is present - if (packetsize == MESSAGE_LENGHT_UNKNOWN) - { - return; - } - // test if message has at least the size of the WlanHeader and a GNUNET_MessageHeader - else if (packetsize < sizeof(struct WlanHeader) - + sizeof(struct GNUNET_MessageHeader)) - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Message not big enough\n"); -#endif - free_receive_message(plugin, rx_message); - return; - } - -#if DEBUG_wlan - check_message_fragment_bitfield(rx_message); -#endif - - if (rx_message->frag_tail->num == ffsl(rx_message->received_fragments)) - { - bitfield = ~bitfield; - bitfield = bitfield << (63 - ffsl(rx_message->received_fragments)); - if (rx_message->received_fragments == bitfield) - { - - while (rx_frag != NULL) - { - sum += rx_frag->size; - rx_frag = rx_frag->next; - } - //sum should always be smaller or equal of - GNUNET_assert(sum <= packetsize); - if (sum == packetsize) - { - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "check_rec_finished_msg: A message for %p is complete\n", - session); -#endif - - //TODO use mst - //copy fragments together - msg = GNUNET_malloc(packetsize); - rx_frag = rx_message->frag_head; - aktnum = 0; - while (rx_frag != NULL) - { - //TODO SAVE SOME COPY OPS AND CHECK CRC WITHOUT COPY - memcpy(msg + aktnum, rx_frag->msg, rx_frag->size); - aktnum += rx_frag->size; - rx_frag = rx_frag->next; - } - - free_receive_message(plugin, rx_message); - //call wlan_process_helper to process the message - wlan_data_massage_handler(plugin, session_light, - (struct GNUNET_MessageHeader*) msg); - //wlan_data_helper (plugin, session_light, (struct GNUNET_MessageHeader*) msg); - - GNUNET_free(msg); - } - } - } -} - + * @param numeric should (IP) addresses be displayed in numeric form? + * @param timeout after how long should we give up? + * @param asc function to call on each string + * @param asc_cls closure for asc + */ static void -process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr) +wlan_plugin_address_pretty_printer(void *cls, const char *type, + const void *addr, size_t addrlen, int numeric, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls) { + char ret[92]; + const unsigned char * input; - GNUNET_assert(client != NULL); - GNUNET_assert(cls != NULL); - struct Session * session = (struct Session *) client; - struct Plugin * plugin = (struct Plugin *) cls; - - struct GNUNET_TRANSPORT_ATS_Information distance[2]; - distance[0].type = htonl(GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); - distance[0].value = htonl(1); - distance[1].type = htonl(GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); - distance[1].value = htonl(0); - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Calling plugin->env->receive for session %p; %s\n", session, - wlan_plugin_address_to_string(NULL, session->addr, 6)); -#endif - - plugin->env->receive(plugin->env->cls, &(session->target), hdr, - (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2, session, - session->addr, sizeof(session->addr)); + //GNUNET_assert(cls !=NULL); + if (addrlen != 6) + { + /* invalid address (MAC addresses have 6 bytes) */GNUNET_break (0); + asc(asc_cls, NULL); + return; + } + input = (const unsigned char*) addr; + GNUNET_snprintf(ret, sizeof(ret), + "%s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", PROTOCOL_PREFIX, + input[0], input[1], input[2], input[3], input[4], input[5]); + asc(asc_cls, ret); } /** @@ -2232,15 +1991,16 @@ process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr) * @param hdr pointer to the data */ static void -wlan_data_massage_handler(struct Plugin * plugin, - struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr) +wlan_data_message_handler(void *cls, const struct GNUNET_MessageHeader *hdr) { - struct WlanHeader * wlanheader = NULL; - struct Session * session = NULL; - const char * tempmsg = NULL; - const struct GNUNET_MessageHeader * temp_hdr = NULL; - struct GNUNET_PeerIdentity tmptarget; + struct MacEndpoint * endpoint = (struct MacEndpoint *) cls; + struct Plugin * plugin = endpoint->plugin; + struct WlanHeader * wlanheader; + struct Session * session; + //const char * tempmsg; + const struct GNUNET_MessageHeader * temp_hdr; + struct GNUNET_PeerIdentity tmpsource; + int crc; if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) { @@ -2248,7 +2008,7 @@ wlan_data_massage_handler(struct Plugin * plugin, #if DEBUG_wlan GNUNET_log( GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_data_massage_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n", + "Func wlan_data_message_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n", ntohs(hdr->size)); #endif @@ -2259,23 +2019,22 @@ wlan_data_massage_handler(struct Plugin * plugin, return; } - GNUNET_assert(session_light != NULL); - if (session_light->session == NULL) - { - session_light->session = search_session(plugin, session_light->addr); - } - session = session_light->session; wlanheader = (struct WlanHeader *) hdr; - tempmsg = (char*) &wlanheader[1]; - temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1]; + session = search_session(plugin, endpoint, &wlanheader->source); - if (getcrc32(tempmsg, ntohs(wlanheader->header.size)) != ntohl( - wlanheader->crc)) + //tempmsg = (char*) &wlanheader[1]; + temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1]; + crc = ntohl(wlanheader->crc); + wlanheader->crc = 0; + if (getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)) != crc) { //wrong crc, dispose message GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Wlan message Header crc was wrong\n"); + "Wlan message header crc was wrong: %u != %u\n", + getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)), + crc); + hexdump((void *) hdr, ntohs(hdr->size)); return; } @@ -2297,17 +2056,14 @@ wlan_data_massage_handler(struct Plugin * plugin, { if (GNUNET_HELLO_get_id( (const struct GNUNET_HELLO_Message *) temp_hdr, - &tmptarget) == GNUNET_OK) + &tmpsource) == GNUNET_OK) { - session = create_session(plugin, session_light->addr); - session_light->session = session; - memcpy(&session->target, &tmptarget, - sizeof(struct GNUNET_PeerIdentity)); + session = create_session(plugin, endpoint, &tmpsource); } else { GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "WLAN client not in session list and hello message not okay\n"); + "WLAN client not in session list and hello message is not okay\n"); return; } @@ -2332,6 +2088,30 @@ wlan_data_massage_handler(struct Plugin * plugin, //"receive" the message + if (memcmp(&wlanheader->source, &session->target, + sizeof(struct GNUNET_PeerIdentity)) != 0) + { + //wrong peer id +#if DEBUG_wlan + GNUNET_log( + GNUNET_ERROR_TYPE_DEBUG, + "WLAN peer source id doesn't match packet peer source id: session %p\n", + session); +#endif + return; + } + + if (memcmp(&wlanheader->target, plugin->env->my_identity, + sizeof(struct GNUNET_PeerIdentity)) != 0) + { + //wrong peer id +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "WLAN peer target id doesn't match our peer id: session %p\n", + session); +#endif + return; + } GNUNET_SERVER_mst_receive(plugin->data_tokenizer, session, (const char *) temp_hdr, @@ -2342,183 +2122,37 @@ wlan_data_massage_handler(struct Plugin * plugin, else { GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "wlan_data_massage_handler got wrong message type\n"); + "wlan_data_message_handler got wrong message type\n"); return; } } -/** - * function to add an ack to send it for a received fragment - * @param plugin pointer to the global plugin structure - * @param session pointer to the session this ack belongs to - * @param bitfield bitfield to send - * @param fh pointer to the fragmentation header which we would like to acknolage - */ - -void -add_ack_for_send(struct Plugin * plugin, struct Session * session, - uint64_t bitfield, struct FragmentationHeader * fh) -{ - struct AckSendQueue * ack; - - GNUNET_assert(plugin != NULL); - GNUNET_assert(session != NULL); - GNUNET_assert(fh != NULL); - - ack = GNUNET_malloc(sizeof(struct AckSendQueue)); - ack->fragments_field = bitfield; - ack->message_id = ntohl(fh->message_id); - ack->session = session; - - GNUNET_CONTAINER_DLL_insert_tail(plugin->ack_send_queue_head, - plugin->ack_send_queue_tail, ack); - -} - -/** - * function to get the receive message from the message id and the session - * @param plugin pointer to the plugin struct - * @param session session this fragment belongs to - * @param message_id id of the message - */ - -struct Receive_Message_Queue * -get_receive_message(struct Plugin * plugin, struct Session * session, - uint32_t message_id) -{ - struct Receive_Message_Queue * rec_message = plugin->receive_messages_head; - while (rec_message != NULL) - { - if ((rec_message->message_id_in == message_id) && (rec_message->session - == session)) - { - return rec_message; - } - rec_message = rec_message->next; - } - return NULL; -} - -/** - * function to get the receive message of a session - * @param plugin pointer to the plugin struct - * @param session session this fragment belongs to - */ - -struct Receive_Message_Queue * -get_receive_message_from_session(struct Plugin * plugin, - struct Session * session) -{ - struct Receive_Message_Queue * rec_message = plugin->receive_messages_head; - while (rec_message != NULL) - { - if (rec_message->session == session) - { - return rec_message; - } - rec_message = rec_message->next; - } - return NULL; -} - -/** - * function to insert a received fragment into the right fragment queue of the right message - * @param plugin pointer to the plugin struct - * @param session_light pointer to the session_light struct of this message - * @param session session this fragment belongs to - * @param fh pointer to the header of the fragment - * @return new fragment bitfield for the message - */ - -uint64_t -insert_fragment_in_in_message_queue(struct Plugin * plugin, - struct Session_light * session_light, struct Session * session, - struct FragmentationHeader * fh, const struct Radiotap_rx * rxinfo) +//TODO DOXIGEN +static void +process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr) { - struct Receive_Fragment_Queue * rx_frag = NULL; - struct Receive_Message_Queue * rx_message; - const char * tempmsg = (char*) &fh[1]; - uint64_t retval = 0; - - //TODO fragments do not timeout - //check if message_id is right or it is a new msg - GNUNET_assert(fh != NULL); - - rx_message = get_receive_message(plugin, session, ntohs(fh->message_id)); - - if (rx_message == NULL) - { - if (session->fragment_messages_in_count < MESSAGES_IN_QUEUE_PER_SESSION) - { - //new message incoming - rx_message = GNUNET_malloc(sizeof (struct Receive_Message_Queue)); - rx_message->message_id_in = ntohs(fh->message_id); - rx_message->rec_size = MESSAGE_LENGHT_UNKNOWN; - rx_message->session = session; - rx_message->timeout = GNUNET_TIME_absolute_add( - GNUNET_TIME_absolute_get(), MESSAGE_IN_TIMEOUT); - rx_message->received_fragments = 0; - - GNUNET_CONTAINER_DLL_insert(plugin->receive_messages_head, plugin->receive_messages_teil, rx_message); - - session->fragment_messages_in_count++; - plugin->pending_receive_messages++; - -#if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "New fragmented message started: message id %u, messages in for this session %u, messages in %u\n", - rx_message->message_id_in, session->fragment_messages_in_count, - plugin->pending_receive_messages); -#endif - } - else - { - - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - "WLAN fragment message_id and session message_id do not exist, max MESSAGES_IN_QUEUE_PER_SESSION reached\n"); - setBit((char *) &retval, ntohs(fh->fragment_off_or_num)); - return retval; - } - } - - if (is_double_msg(rx_message, fh) != GNUNET_YES) - { + GNUNET_assert(client != NULL); + GNUNET_assert(cls != NULL); + struct Session * session = (struct Session *) client; + struct Plugin * plugin = (struct Plugin *) cls; - //report size - rx_frag = GNUNET_malloc(sizeof (struct Receive_Fragment_Queue) + - ntohs(fh->header.size) - sizeof(struct FragmentationHeader)); - rx_frag->size = ntohs(fh->header.size) - - sizeof(struct FragmentationHeader); - rx_frag->num = ntohs(fh->fragment_off_or_num); - rx_frag->msg = (char*) &(rx_frag[1]); - //copy msg to buffer - memcpy((char *) rx_frag->msg, tempmsg, rx_frag->size); - memcpy((char *) &(rx_frag->rxinfo), rxinfo, sizeof(rxinfo)); - insert_fragment_in_queue(rx_message, rx_frag); - //save bitfield - retval = rx_message->received_fragments; + struct GNUNET_TRANSPORT_ATS_Information distance[2]; + distance[0].type = htonl(GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); + distance[0].value = htonl(1); + distance[1].type = htonl(GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); + distance[1].value = htonl(0); #if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "New fragment: size %u, fragsize %u, message id %u, bitfield %X, session %u\n", - rx_message->rec_size, rx_frag->size, rx_message->received_fragments, - rx_message->message_id_in, session); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Calling plugin->env->receive for session %p; %s; size: %u\n", session, + wlan_plugin_address_to_string(NULL, session->mac->addr.mac, 6), + htons(hdr->size)); #endif - check_rec_finished_msg(plugin, session_light, session, rx_message); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "WLAN fragment is a clone\n"); - retval = rx_message->received_fragments; - - } - return retval; - + plugin->env->receive(plugin->env->cls, &(session->target), hdr, + (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2, session, + (const char*) &session->mac->addr, sizeof(session->mac->addr)); } /** @@ -2533,15 +2167,8 @@ wlan_data_helper(void *cls, struct Session_light * session_light, const struct GNUNET_MessageHeader * hdr, const struct Radiotap_rx * rxinfo) { struct Plugin *plugin = cls; - struct Session * session = NULL; - - struct FragmentationHeader * fh = NULL; - struct FragmentationAckHeader * fah = NULL; - struct FragmentMessage * fm = NULL; - - const char * tempmsg = NULL; - - uint64_t fragment_bitfield = 0; + struct FragmentMessage * fm; + struct FragmentMessage * fm2; //ADVERTISEMENT if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT) @@ -2555,13 +2182,14 @@ wlan_data_helper(void *cls, struct Session_light * session_light, GNUNET_log( GNUNET_ERROR_TYPE_DEBUG, "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT size: %u; %s\n", - ntohs(hdr->size), wlan_plugin_address_to_string(NULL, - session_light->addr, 6)); + ntohs(hdr->size), + wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6)); #endif - if (session_light->session == NULL) + if (session_light->macendpoint == NULL) { - session_light->session = get_Session(plugin, session_light->addr); + session_light->macendpoint = get_macendpoint(plugin, + &session_light->addr, GNUNET_NO); } GNUNET_assert(GNUNET_HELLO_get_id( (const struct GNUNET_HELLO_Message *) &hdr[1], @@ -2570,106 +2198,116 @@ wlan_data_helper(void *cls, struct Session_light * session_light, } //FRAGMENT - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT) + + else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT) { GNUNET_assert(session_light != NULL); - if (session_light->session == NULL) + if (session_light->macendpoint == NULL) { - session_light->session = search_session(plugin, session_light->addr); + session_light->macendpoint = get_macendpoint(plugin, + &session_light->addr, GNUNET_YES); } - session = session_light->session; - - fh = (struct FragmentationHeader *) hdr; - tempmsg = (char*) &fh[1]; #if DEBUG_wlan GNUNET_log( GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT with message_id %u with fragment number %i, size: %u; %s\n", - ntohl(fh->message_id), ntohs(fh->fragment_off_or_num), ntohs( - hdr->size), wlan_plugin_address_to_string(NULL, - session_light->addr, 6)); + "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT with size: %u; mac endpoint %p: %s\n", + ntohs(hdr->size), session_light->macendpoint, + wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6)); #endif - if (getcrc16(tempmsg, ntohs(fh->header.size)) != ntohs(fh->message_crc)) - { - //wrong crc, dispose message - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "WLAN fragment crc was wrong\n"); - return; - } - - //if in the session list - if (session != NULL) + int ret = GNUNET_DEFRAGMENT_process_fragment( + session_light->macendpoint->defrag, hdr); + if (ret == GNUNET_NO) { - fragment_bitfield = insert_fragment_in_in_message_queue(plugin, - session_light, session, fh, rxinfo); + session_light->macendpoint->dups++; } - else + else if (ret == GNUNET_OK) { - // new session - GNUNET_log( - GNUNET_ERROR_TYPE_INFO, - "WLAN client not in session list, fragment num %u, message id %u\n", - ntohs(fh->fragment_off_or_num), ntohs(fh->message_id)); - wlan_data_massage_handler(plugin, session_light, - (struct GNUNET_MessageHeader *) tempmsg); - session = session_light->session; - //test if a session was created - if (session == NULL) - { - return; - } - setBit((char *) &fragment_bitfield, ntohs(fh->fragment_off_or_num)); + session_light->macendpoint->fragc++; } - - add_ack_for_send(plugin, session, fragment_bitfield, fh); - check_next_fragment_timeout(plugin); + set_next_send(plugin); } //ACK - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT_ACK) + + else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT_ACK) { + GNUNET_assert(session_light != NULL); + if (session_light->macendpoint == NULL) + { + session_light->macendpoint = get_macendpoint(plugin, + &session_light->addr, GNUNET_NO); + } + + if (session_light->macendpoint == NULL) + { +#if DEBUG_wlan + GNUNET_log( + GNUNET_ERROR_TYPE_DEBUG, + "Macendpoint does not exist for this GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; %s\n", + ntohs(hdr->size), + wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6)); +#endif + return; + } #if DEBUG_wlan GNUNET_log( GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT_ACK size: %u; %s\n", - ntohs(hdr->size), wlan_plugin_address_to_string(NULL, - session_light->addr, 6)); + "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; mac endpoint: %p; %s\n", + ntohs(hdr->size), session_light->macendpoint, + wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6)); #endif - - GNUNET_assert(session_light != NULL); - if (session_light->session == NULL) - { - session_light->session = search_session(plugin, session_light->addr); - GNUNET_assert(session_light->session != NULL); - } - session = session_light->session; - fah = (struct FragmentationAckHeader *) hdr; - fm = get_fragment_message_from_session_and_id(session, ntohl( - fah->message_id)); - if (fm != NULL) + fm = session_light->macendpoint->sending_messages_head; + while (fm != NULL) { + fm2 = fm->next; + int ret = GNUNET_FRAGMENT_process_ack(fm->fragcontext, hdr); + if (ret == GNUNET_OK) + { +#if DEBUG_wlan_retransmission + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Got last ack, finished fragment message %p\n", fm); +#endif + session_light->macendpoint->acks++; + free_fragment_message(plugin, fm); + check_fragment_queue(plugin); + return; + } + if (ret == GNUNET_NO) + { +#if DEBUG_wlan_retransmission + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got ack for: %p\n", fm); +#endif + session_light->macendpoint->acks++; + return; + } + if (ret == GNUNET_SYSERR) + { - fm->ack_bitfield = fm->ack_bitfield | ntohll(fah->fragment_field); - check_finished_fragment(plugin, fm); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "WLAN fragment not in fragment list with id %u of ack\n", ntohl( - fah->message_id)); - return; + } + + fm = fm2; } +#if DEBUG_wlan_retransmission + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "WLAN fragment not in fragment list\n"); +#endif + return; + } else { // TODO Wrong data? - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "WLAN packet inside the WLAN helper packet has not the right type\n"); + GNUNET_log( + GNUNET_ERROR_TYPE_INFO, + "WLAN packet inside the WLAN helper packet has not the right type: %u size: %u\n", + ntohs(hdr->type), ntohs(hdr->size)); + GNUNET_break(0); return; } @@ -2680,6 +2318,7 @@ wlan_data_helper(void *cls, struct Session_light * session_light, } +//TODO DOXIGEN const char * macprinter(const u_int8_t * mac) { @@ -2690,6 +2329,33 @@ macprinter(const u_int8_t * mac) return macstr; } +/** + * function to create an macendpoint + * @param plugin pointer to the plugin struct + * @param addr pointer to the macaddress + * @return returns a macendpoint + */ +static struct MacEndpoint * +create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr) +{ + struct MacEndpoint * newend = GNUNET_malloc(sizeof (struct MacEndpoint)); + newend->addr = *addr; + newend->plugin = plugin; + newend->addr = *addr; + newend->fragment_messages_out_count = 0; + newend->defrag = GNUNET_DEFRAGMENT_context_create(plugin->env->stats, + WLAN_MTU, MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, newend, + &wlan_data_message_handler, &add_ack_for_send); + + plugin->mac_count++; + GNUNET_CONTAINER_DLL_insert_tail(plugin->mac_head, plugin->mac_tail, newend); +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New Mac Endpoint %p: %s\n", newend, + wlan_plugin_address_to_string(NULL, newend->addr.mac, 6)); +#endif + return newend; +} + /** * Function used for to process the data from the suid process * @@ -2708,7 +2374,7 @@ wlan_process_helper(void *cls, void *client, const struct GNUNET_MessageHeader * temp_hdr = NULL; int datasize = 0; - int pos = 0; + int pos; switch (ntohs(hdr->type)) { @@ -2724,7 +2390,15 @@ wlan_process_helper(void *cls, void *client, if (ntohs(hdr->size) < sizeof(struct ieee80211_frame) + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx)) { - GNUNET_break (0); +#if DEBUG_wlan + GNUNET_log( + GNUNET_ERROR_TYPE_DEBUG, + "Size of packet is too small; size: %u min size: %u\n", + ntohs(hdr->size), + sizeof(struct ieee80211_frame) + + sizeof(struct GNUNET_MessageHeader)); +#endif + //GNUNET_break (0); /* FIXME: restart SUID process */ return; } @@ -2734,11 +2408,11 @@ wlan_process_helper(void *cls, void *client, //process only if it is an broadcast or for this computer both with the gnunet bssid //check for bssid - if (memcmp(&(wlanIeeeHeader->i_addr3), mac_bssid, sizeof(struct MacAddress)) - == 0) + if (memcmp(&(wlanIeeeHeader->i_addr3), &mac_bssid, + sizeof(struct MacAddress)) == 0) { //check for broadcast or mac - if (memcmp(&(wlanIeeeHeader->i_addr1), bc_all_mac, + if (memcmp(&(wlanIeeeHeader->i_addr1), &bc_all_mac, sizeof(struct MacAddress) == 0) || memcmp( &(wlanIeeeHeader->i_addr1), &(plugin->mac_address), sizeof(struct MacAddress)) == 0) @@ -2748,15 +2422,15 @@ wlan_process_helper(void *cls, void *client, datasize = ntohs(hdr->size) - sizeof(struct ieee80211_frame) - - sizeof(struct GNUNET_MessageHeader); + - sizeof(struct GNUNET_MessageHeader) + - sizeof(struct Radiotap_rx); session_light = GNUNET_malloc(sizeof(struct Session_light)); - memcpy(session_light->addr, &(wlanIeeeHeader->i_addr2), + memcpy(&session_light->addr, &(wlanIeeeHeader->i_addr2), sizeof(struct MacAddress)); //session_light->session = search_session(plugin,session_light->addr); pos = 0; - temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1]; while (pos < datasize) { temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] @@ -2774,8 +2448,8 @@ wlan_process_helper(void *cls, void *client, { #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_process_helper got wrong MAC: %s\n", macprinter( - wlanIeeeHeader->i_addr1)); + "Func wlan_process_helper got wrong MAC: %s\n", + macprinter(wlanIeeeHeader->i_addr1)); #endif } } @@ -2783,8 +2457,8 @@ wlan_process_helper(void *cls, void *client, { #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_process_helper got wrong BSSID: %s\n", macprinter( - wlanIeeeHeader->i_addr2)); + "Func wlan_process_helper got wrong BSSID: %s\n", + macprinter(wlanIeeeHeader->i_addr2)); #endif } break; @@ -2798,15 +2472,15 @@ wlan_process_helper(void *cls, void *client, return; } memcpy(&plugin->mac_address, &hdr[1], sizeof(struct MacAddress)); -#if DEBUG_WLAN - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, +#if DEBUG_wlan + GNUNET_log( + GNUNET_ERROR_TYPE_DEBUG, "Received WLAN_HELPER_CONTROL message with transport of address %s\n", - wlan_plugin_address_to_string (cls, - &plugin->mac_address, - sizeof (struct MacAddress))); + wlan_plugin_address_to_string(cls, &plugin->mac_address, + sizeof(struct MacAddress))); #endif - plugin->env->notify_address(plugin->env->cls, "wlan", &plugin->mac_address, - sizeof(struct MacAddress), GNUNET_TIME_UNIT_FOREVER_REL); + plugin->env->notify_address(plugin->env->cls, GNUNET_YES, + &plugin->mac_address, sizeof(struct MacAddress)); break; default: GNUNET_break (0); @@ -2829,13 +2503,7 @@ wlan_plugin_helper_read(void *cls, struct Plugin *plugin = cls; plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - /* - #if DEBUG_wlan - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Start reading from STDIN\n"); - #endif - */ - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) return; char mybuf[WLAN_MTU + sizeof(struct GNUNET_MessageHeader)]; @@ -2871,7 +2539,8 @@ wlan_plugin_helper_read(void *cls, static int wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode) { - const char * filename = "gnunet-transport-wlan-helper"; + const char * filenamehw = "gnunet-transport-wlan-helper"; + const char * filenameloopback = "gnunet-transport-wlan-helper-dummy"; plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_NO, GNUNET_YES); if (plugin->server_stdout == NULL) return GNUNET_SYSERR; @@ -2880,16 +2549,43 @@ wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode) if (plugin->server_stdin == NULL) return GNUNET_SYSERR; + /* Start the server process */ + + if (testmode == 0) + { + #if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filename, - plugin->interface, testmode); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filenamehw, + plugin->interface, testmode); +#endif + + plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, + plugin->server_stdout, filenamehw, filenamehw, plugin->interface, + NULL); + } + else if (testmode == 1) + { + +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Starting gnunet-wlan-helper loopback 1 process cmd: %s %s %i\n", + filenameloopback, plugin->interface, testmode); #endif - /* Start the server process */ - plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, - plugin->server_stdout, filename, filename, plugin->interface, ((testmode - == 1) ? "1" : (testmode == 2) ? "2" : "0"), NULL); + plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, + plugin->server_stdout, filenameloopback, filenameloopback, "1", NULL); + } + else if (testmode == 2) + { +#if DEBUG_wlan + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Starting gnunet-wlan-helper loopback 2 process cmd: %s %s %i\n", + filenameloopback, plugin->interface, testmode); +#endif + plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, + plugin->server_stdout, filenameloopback, filenameloopback, "2", NULL); + } if (plugin->server_proc == NULL) { #if DEBUG_wlan @@ -2917,8 +2613,6 @@ wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode) "Adding server_read_task for the wlan-helper\n"); #endif - sleep(2); - plugin->server_read_task = GNUNET_SCHEDULER_add_read_file( GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle, &wlan_plugin_helper_read, plugin); @@ -2937,13 +2631,43 @@ libgnunet_plugin_transport_wlan_done(void *cls) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; struct Plugin *plugin = api->cls; + struct MacEndpoint * endpoint = plugin->mac_head; + struct MacEndpoint * endpoint_next; #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "libgnunet_plugin_transport_wlan_done started\n"); #endif - GNUNET_assert(cls !=NULL); + GNUNET_DISK_pipe_close(plugin->server_stdout); + GNUNET_DISK_pipe_close(plugin->server_stdin); + GNUNET_OS_process_kill(plugin->server_proc, 9); + GNUNET_OS_process_close(plugin->server_proc); + + GNUNET_assert (cls !=NULL); + //free sessions + while (endpoint != NULL) + { + endpoint_next = endpoint->next; + free_macendpoint(plugin, endpoint); + endpoint = endpoint_next; + + } + if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task); + plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + } + if (plugin->server_write_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel(plugin->server_write_task); + plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + } + if (plugin->server_read_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel(plugin->server_read_task); + plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; + } if (plugin->suid_tokenizer != NULL) GNUNET_SERVER_mst_destroy(plugin->suid_tokenizer); @@ -2977,10 +2701,12 @@ libgnunet_plugin_transport_wlan_init(void *cls) plugin = GNUNET_malloc (sizeof (struct Plugin)); plugin->env = env; plugin->pendingsessions = 0; - plugin->session_count = 0; + plugin->mac_count = 0; plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_BANDWIDTH_tracker_init(&plugin->tracker, + GNUNET_BANDWIDTH_value_init(100 * 1024 * 1024 / 8), 100); plugin->suid_tokenizer = GNUNET_SERVER_mst_create(&wlan_process_helper, plugin); @@ -2988,7 +2714,7 @@ libgnunet_plugin_transport_wlan_init(void *cls) plugin->data_tokenizer = GNUNET_SERVER_mst_create(&process_data, plugin); //plugin->sessions = GNUNET_malloc (sizeof (struct Sessionqueue)); - //plugin->pending_Sessions = GNUNET_malloc (sizeof (struct Sessionqueue)); + //plugin->pending_Sessions_head = GNUNET_malloc (sizeof (struct Sessionqueue)); api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); api->cls = plugin; @@ -2997,7 +2723,6 @@ libgnunet_plugin_transport_wlan_init(void *cls) api->address_pretty_printer = &wlan_plugin_address_pretty_printer; api->check_address = &wlan_plugin_address_suggested; api->address_to_string = &wlan_plugin_address_to_string; - //read config if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "TESTMODE")) @@ -3022,8 +2747,6 @@ libgnunet_plugin_transport_wlan_init(void *cls) wlan_transport_start_wlan_helper(plugin, testmode); - start_next_message_id(); - #if DEBUG_wlan GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "wlan init finished\n"); #endif