X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fplugin_transport_wlan.c;h=c2565a4a8fb9f198de1c3343266d03008b54525a;hb=56389a7d277b05c9c2968b7ebd529a12f8be15eb;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..c2565a4a8 100644 --- a/src/transport/plugin_transport_wlan.c +++ b/src/transport/plugin_transport_wlan.c @@ -1,29 +1,29 @@ /* - This file is part of GNUnet - (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. - */ + This file is part of GNUnet + (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ /** * @file transport/plugin_transport_wlan.c * @brief transport plugin for wlan * @author David Brodski + * @author Christian Grothoff */ - #include "platform.h" #include "gnunet_hello_lib.h" #include "gnunet_protocols.h" @@ -34,2661 +34,1220 @@ #include "plugin_transport_wlan.h" #include "gnunet_common.h" #include "gnunet_crypto_lib.h" -#include "wlan/ieee80211.h" - -#include +#include "gnunet_fragmentation_lib.h" +#include "gnunet_constants.h" -#define PROTOCOL_PREFIX "wlan" +#define LOG(kind,...) GNUNET_log_from (kind, "transport-wlan",__VA_ARGS__) /** - * Max size of packet from helper + * Max size of packet (that we give to the WLAN driver for transmission) */ -#define WLAN_MTU 3000 +#define WLAN_MTU 1430 /** - * Time until retransmission of a fragment in ms + * time out of a mac endpoint */ -#define FRAGMENT_TIMEOUT GNUNET_TIME_UNIT_SECONDS - -#define FRAGMENT_QUEUE_SIZE 10 -#define FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION 1 - -#define MESSAGE_IN_TIMEOUT GNUNET_TIME_UNIT_SECONDS - -#define MESSAGES_IN_QUEUE_SIZE 10 -#define MESSAGES_IN_QUEUE_PER_SESSION 1 - -#define HALLO_BEACON_SCALING_FACTOR 900 - -#define DEBUG_wlan GNUNET_YES - -#define MESSAGE_LENGHT_UNKNOWN -1 -//#define NO_MESSAGE_OR_MESSAGE_FINISHED -2 +#define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2) /** - * After how long do we expire an address that we - * learned from another peer if it is not reconfirmed - * by anyone? + * We reduce the frequence of HELLO beacons in relation to + * the number of MAC addresses currently visible to us. + * This is the multiplication factor. */ -#define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6) +#define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2) /** - * Initial handshake message for a session. + * Maximum number of messages in defragmentation queue per MAC */ -struct WelcomeMessage -{ - /** - * Type is GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME. - */ - struct GNUNET_MessageHeader header; +#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 2 - /** - * Identit*mac_y of the node connecting (TCP client) - */ - struct GNUNET_PeerIdentity clientIdentity; +/** + * Link layer control fields for better compatibility + * (i.e. GNUnet over WLAN is not IP-over-WLAN). + */ +#define WLAN_LLC_DSAP_FIELD 0x1f +#define WLAN_LLC_SSAP_FIELD 0x1f -}; +GNUNET_NETWORK_STRUCT_BEGIN /** - * Encapsulation of all of the state of the plugin. + * Header for messages which need fragmentation. This is the format of + * a message we obtain AFTER defragmentation. We then need to check + * the CRC and then tokenize the payload and pass it to the + * 'receive' callback. */ -struct Plugin +struct WlanHeader { - /** - * Our environment. - */ - struct GNUNET_TRANSPORT_PluginEnvironment *env; /** - * List of open sessions. head + * Message type is GNUNET_MESSAGE_TYPE_WLAN_DATA. */ - struct Sessionqueue *sessions; + struct GNUNET_MessageHeader header; /** - * List of open sessions. tail + * CRC32 checksum (only over the payload), in NBO. */ - struct Sessionqueue *sessions_tail; + uint32_t crc GNUNET_PACKED; /** - * Number of sessions + * Sender of the message. */ - - int session_count; + struct GNUNET_PeerIdentity sender; /** - * encapsulation of data from the local wlan helper program + * Target of the message. */ + struct GNUNET_PeerIdentity target; - struct GNUNET_SERVER_MessageStreamTokenizer * suid_tokenizer; - - /** - * encapsulation of packets received - */ + /* followed by payload, possibly including + multiple messages! */ - struct GNUNET_SERVER_MessageStreamTokenizer * data_tokenizer; +}; +GNUNET_NETWORK_STRUCT_END - /** - * stdout pipe handle for the gnunet-wlan-helper process - */ - struct GNUNET_DISK_PipeHandle *server_stdout; +/** + * Information kept for each message that is yet to be fragmented and + * transmitted. + */ +struct PendingMessage +{ /** - * stdout file handle for the gnunet-wlan-helper process + * next entry in the DLL */ - const struct GNUNET_DISK_FileHandle *server_stdout_handle; + struct PendingMessage *next; /** - * stdin pipe handle for the gnunet-wlan-helper process + * previous entry in the DLL */ - struct GNUNET_DISK_PipeHandle *server_stdin; + struct PendingMessage *prev; /** - * stdin file handle for the gnunet-wlan-helper process + * The pending message */ - const struct GNUNET_DISK_FileHandle *server_stdin_handle; + struct WlanHeader *msg; /** - * ID of the gnunet-wlan-server std read task + * Continuation function to call once the message + * has been sent. Can be NULL if there is no + * continuation to call. */ - GNUNET_SCHEDULER_TaskIdentifier server_read_task; + GNUNET_TRANSPORT_TransmitContinuation transmit_cont; /** - * ID of the gnunet-wlan-server std read task + * Cls for transmit_cont */ - GNUNET_SCHEDULER_TaskIdentifier server_write_task; + void *transmit_cont_cls; /** - * ID of the delay task for writing + * Timeout task (for this message). */ - GNUNET_SCHEDULER_TaskIdentifier server_write_delay_task; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; - /** - * The process id of the wlan process - */ - struct GNUNET_OS_Process *server_proc; +}; - /** - * The interface of the wlan card given to us by the user. - */ - char *interface; +/** + * Session handle for connections with other peers. + */ +struct Session +{ /** - * The mac_address of the wlan card given to us by the helper. + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) */ - struct MacAddress mac_address; + struct GNUNET_PeerIdentity target; /** - * Sessions currently pending for transmission - * to this peer, if any. + * API requirement (must be first). */ - struct Sessionqueue * pending_Sessions; + struct SessionHeader header; /** - * Sessions currently pending for transmission - * to this peer (tail), if any. + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - struct Sessionqueue * pending_Sessions_tail; + struct Session *next; /** - * number of pending sessions + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - unsigned int pendingsessions; + struct Session *prev; /** - * Messages in the fragmentation queue, head + * MAC endpoint with the address of this peer. */ - - struct FragmentMessage * pending_Fragment_Messages_head; + struct MacEndpoint *mac; /** - * Messages in the fragmentation queue, tail + * Head of messages currently pending for transmission to this peer. */ - - struct FragmentMessage * pending_Fragment_Messages_tail; + struct PendingMessage *pending_message_head; /** - * number of pending fragment message + * Tail of messages currently pending for transmission to this peer. */ - - unsigned int pending_fragment_messages; + struct PendingMessage *pending_message_tail; /** - * Messages in the in Queue, head + * When should this session time out? */ - - struct Receive_Message_Queue * receive_messages_head; + struct GNUNET_TIME_Absolute timeout; /** - * Messages in the in Queue, tail + * Timeout task (for the session). */ + GNUNET_SCHEDULER_TaskIdentifier timeout_task; - struct Receive_Message_Queue * receive_messages_teil; +}; - /** - * number of messages in the in queue - */ - unsigned int pending_receive_messages; +/** + * Struct for messages that are being fragmented in a MAC's transmission queue. + */ +struct FragmentMessage +{ /** - * time of the next "hello-beacon" + * This is a doubly-linked list. */ - - struct GNUNET_TIME_Absolute beacon_time; + struct FragmentMessage *next; /** - * queue to send acks for received fragments (head) + * This is a doubly-linked list. */ - - struct AckSendQueue * ack_send_queue_head; + struct FragmentMessage *prev; /** - * queue to send acks for received fragments (tail) + * MAC endpoint this message belongs to */ - - struct AckSendQueue * ack_send_queue_tail; - -}; - -/** - * Struct to store data if file write did not accept the whole packet - */ -struct Finish_send -{ - struct Plugin * plugin; - char * msgheader; - struct GNUNET_MessageHeader * msgstart; - ssize_t size; -}; - -/** - * Queue of sessions, for the general session queue and the pending session queue - */ - -struct Sessionqueue -{ - struct Sessionqueue * next; - struct Sessionqueue * prev; - struct Session * content; -}; - -/** - * Queue for the fragments received - */ - -struct Receive_Fragment_Queue -{ - struct Receive_Fragment_Queue * next; - struct Receive_Fragment_Queue * prev; - uint16_t num; - const char * msg; - uint16_t size; - struct Radiotap_rx rxinfo; -}; - -/** - * Queue for the fragments received - */ - -struct Receive_Message_Queue -{ - struct Receive_Message_Queue * next; - - struct Receive_Message_Queue * prev; + struct MacEndpoint *macendpoint; /** - * current number for message incoming, to distinguish between the messages + * Fragmentation context */ - uint32_t message_id_in; + struct GNUNET_FRAGMENT_Context *fragcontext; /** - * size of the message received, - * MESSAGE_LENGHT_UNKNOWN means that the size is not known, - * NO_MESSAGE_OR_MESSAGE_FINISHED means no message received + * Transmission handle to helper (to cancel if the frag context + * is destroyed early for some reason). */ - - int rec_size; + struct GNUNET_HELPER_SendHandle *sh; /** - * Sorted queue with the fragments received; head + * Intended recipient. */ - - struct Receive_Fragment_Queue * frag_head; + struct GNUNET_PeerIdentity target; /** - * Sorted queue with the fragments received; tail + * Timeout value for the message. */ - - struct Receive_Fragment_Queue * frag_tail; + struct GNUNET_TIME_Absolute timeout; /** - * Session this fragment belongs to + * Timeout task. */ - - struct Session * session; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** - * Timeout value for the pending message. + * Continuation to call when we're done with this message. */ - struct GNUNET_TIME_Absolute timeout; + GNUNET_TRANSPORT_TransmitContinuation cont; /** - * Bitfield of received fragments + * Closure for 'cont' */ + void *cont_cls; - uint64_t received_fragments; }; + /** - * Information kept for each message that is yet to - * be transmitted. + * Struct to represent one network card connection */ -struct PendingMessage +struct MacEndpoint { /** - * The pending message + * We keep all MACs in a DLL in the plugin. */ - char *msg; + struct MacEndpoint *next; /** - * Size of the message + * We keep all MACs in a DLL in the plugin. */ - size_t message_size; + struct MacEndpoint *prev; /** - * Continuation function to call once the message - * has been sent. Can be NULL if there is no - * continuation to call. + * Pointer to the global plugin struct. */ - GNUNET_TRANSPORT_TransmitContinuation transmit_cont; + struct Plugin *plugin; /** - * Cls for transmit_cont + * Head of sessions that use this MAC. */ - void * transmit_cont_cls; + struct Session *sessions_head; /** - * Timeout value for the pending message. + * Tail of sessions that use this MAC. */ - struct GNUNET_TIME_Absolute timeout; - -}; - -/** - * Queue for acks to send for fragments recived - */ -//TODO comments -struct AckSendQueue -{ - - struct AckSendQueue * next; - struct AckSendQueue * prev; + struct Session *sessions_tail; - struct Session * session; /** - * ID of message, to distinguish between the messages, picked randomly. + * Head of messages we are currently sending to this MAC. */ - uint32_t message_id; + struct FragmentMessage *sending_messages_head; /** - * Bit field for received fragments + * Tail of messages we are currently sending to this MAC. */ - uint64_t fragments_field; - -}; - -/** - * Session infos gathered from a messages - */ + struct FragmentMessage *sending_messages_tail; -struct Session_light -{ /** - * the session this message belongs to + * Defrag context for this MAC */ - struct Session * session; + struct GNUNET_DEFRAGMENT_Context *defrag; + /** - * peer mac address + * When should this endpoint time out? */ - uint8_t addr[6]; -}; - -/** - * Session handle for connections. - */ -struct Session -{ + struct GNUNET_TIME_Absolute timeout; /** - * API requirement. + * Timeout task. */ - struct SessionHeader header; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** - * Pointer to the global plugin struct. + * count of messages in the fragment out queue for this mac endpoint */ - struct Plugin *plugin; + unsigned int fragment_messages_out_count; /** - * Message currently pending for transmission - * to this peer, if any. + * peer mac address */ - struct PendingMessage *pending_message; + struct GNUNET_TRANSPORT_WLAN_MacAddress addr; /** - * Message currently pending for transmission - * to this peer, if any. + * Desired transmission power for this MAC */ - struct PendingMessage *pending_message2; + uint16_t tx_power; /** - * To whom are we talking to (set to our identity - * if we are still waiting for the welcome message) + * Desired transmission rate for this MAC */ - struct GNUNET_PeerIdentity target; + uint8_t rate; /** - * peer mac address + * Antenna we should use for this MAC */ - char addr[6]; + uint8_t antenna; + +}; + +/** + * Encapsulation of all of the state of the plugin. + */ +struct Plugin +{ /** - * Address of the other peer (either based on our 'connect' - * call or on our 'accept' call). + * Our environment. */ - void *connect_addr; + struct GNUNET_TRANSPORT_PluginEnvironment *env; /** - * Last activity on this connection. Used to select preferred - * connection. - */ - struct GNUNET_TIME_Absolute last_activity; + * Handle to helper process for priviledged operations. + */ + struct GNUNET_HELPER_Handle *suid_helper; /** - * count of messages in the fragment out queue for this session + * ARGV-vector for the helper (all helpers take only the binary + * name, one actual argument, plus the NULL terminator for 'argv'). */ - - int fragment_messages_out_count; + char * helper_argv[3]; /** - * count of messages in the fragment in queue for this session + * The interface of the wlan card given to us by the user. */ + char *interface; - int fragment_messages_in_count; - - //TODO DOXIGEN - uint8_t rate; - uint16_t tx_power; - uint8_t antenna; - -}; - -/** - * Struct for Messages in the fragment queue - */ - -struct FragmentMessage -{ /** - * Session this message belongs to + * Tokenizer for demultiplexing of data packets resulting from defragmentation. */ - - struct Session *session; + struct GNUNET_SERVER_MessageStreamTokenizer *fragment_data_tokenizer; /** - * This is a doubly-linked list. + * Tokenizer for demultiplexing of data packets received from the suid helper */ - struct FragmentMessage *next; + struct GNUNET_SERVER_MessageStreamTokenizer *helper_payload_tokenizer; /** - * This is a doubly-linked list. + * Tokenizer for demultiplexing of data packets that follow the WLAN Header */ - struct FragmentMessage *prev; + struct GNUNET_SERVER_MessageStreamTokenizer *wlan_header_payload_tokenizer; /** - * The pending message + * Head of list of open connections. */ - char *msg; + struct MacEndpoint *mac_head; /** - * Timeout value for the pending message. + * Tail of list of open connections. */ - struct GNUNET_TIME_Absolute timeout; + struct MacEndpoint *mac_tail; /** - * Timeout value for the pending fragments. - * Stores the time when the next msg fragment ack has to be received + * Number of connections */ - struct GNUNET_TIME_Absolute next_ack; + unsigned int mac_count; /** - * bitfield with all acks received for this message + * Task that periodically sends a HELLO beacon via the helper. */ - uint64_t ack_bitfield; + GNUNET_SCHEDULER_TaskIdentifier beacon_task; /** - * Size of the message + * Tracker for bandwidth limit */ - size_t message_size; + struct GNUNET_BANDWIDTH_Tracker tracker; /** - * pos / next fragment number in the message, for fragmentation/segmentation, - * some acks can be missing but there is still time + * The mac_address of the wlan card given to us by the helper. */ - uint32_t message_pos; + struct GNUNET_TRANSPORT_WLAN_MacAddress mac_address; /** - * current number for message outgoing, to distinguish between the messages + * Have we received a control message with our MAC address yet? */ - uint32_t message_id_out; + int have_mac; + + }; + /** - * Header for messages which need fragmentation + * Information associated with a message. Can contain + * the session or the MAC endpoint associated with the + * message (or both). */ -struct FragmentationAckHeader +struct MacAndSession { - - struct GNUNET_MessageHeader header; - /** - * ID of message, to distinguish between the messages, picked randomly. + * NULL if the identity of the other peer is not known. */ - uint32_t message_id GNUNET_PACKED; + struct Session *session; /** - * Offset or number of this fragment, for fragmentation/segmentation (design choice, TBD) + * MAC address of the other peer, NULL if not known. */ - uint64_t fragment_field GNUNET_PACKED; - + struct MacEndpoint *endpoint; }; -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); +/** + * Print MAC addresses nicely. + * + * @param mac the mac address + * @return string to a static buffer with the human-readable mac, will be overwritten during the next call to this function + */ +static const char * +mac_to_string (const struct GNUNET_TRANSPORT_WLAN_MacAddress * mac) +{ + static char macstr[20]; -static void -check_fragment_queue(struct Plugin * plugin); + GNUNET_snprintf (macstr, sizeof (macstr), "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", mac->mac[0], mac->mac[1], + mac->mac[2], mac->mac[3], mac->mac[4], mac->mac[5]); + return macstr; +} -uint32_t -getcrc32(const char *msgbuf, size_t msgbuf_size); +/** + * Fill the radiotap header + * + * @param endpoint pointer to the endpoint, can be NULL + * @param header pointer to the radiotap header + * @param size total message size + */ static void -free_receive_message(struct Plugin* plugin, - struct Receive_Message_Queue * rx_message); - -struct Receive_Message_Queue * -get_receive_message_from_session(struct Plugin * plugin, - struct Session * session); +get_radiotap_header (struct MacEndpoint *endpoint, + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, + uint16_t size) +{ + header->header.type = ntohs (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER); + header->header.size = ntohs (size); + if (NULL != endpoint) + { + 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; + } +} -static void -wlan_data_helper(void *cls, struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr, const struct Radiotap_rx * rxinfo); +/** + * Generate the WLAN hardware header for one packet + * + * @param plugin the plugin handle + * @param header address to write the header to + * @param to_mac_addr address of the recipient + * @param size size of the whole packet, needed to calculate the time to send the packet + */ static void -wlan_process_helper(void *cls, void *client, - const struct GNUNET_MessageHeader *hdr); +get_wlan_header (struct Plugin *plugin, + struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *header, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, + unsigned int size) +{ + const int rate = 11000000; + + header->frame_control = htons (IEEE80211_FC0_TYPE_DATA); + header->addr1 = *to_mac_addr; + header->addr2 = plugin->mac_address; + header->addr3 = mac_bssid_gnunet; + header->duration = GNUNET_htole16 ((size * 1000000) / rate + 290); + header->sequence_control = 0; // FIXME? + header->llc[0] = WLAN_LLC_DSAP_FIELD; + header->llc[1] = WLAN_LLC_SSAP_FIELD; + header->llc[2] = 0; // FIXME? + header->llc[3] = 0; // FIXME? +} -static void -finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); +/** + * Send an ACK for a fragment we received. + * + * @param cls the 'struct MacEndpoint' the ACK must be sent to + * @param msg_id id of the message + * @param hdr pointer to the hdr where the ack is stored + */ static void -wlan_data_massage_handler(struct Plugin * plugin, - struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr); - -static const char * -wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen); - -struct Receive_Message_Queue * -get_receive_message(struct Plugin * plugin, struct Session * session, - uint32_t message_id); - -static uint64_t -htonll(uint64_t input) +send_ack (void *cls, uint32_t msg_id, + const struct GNUNET_MessageHeader *hdr) { - return input; -} + struct MacEndpoint *endpoint = cls; + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage* radio_header; + uint16_t msize = ntohs (hdr->size); + size_t size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize; + char buf[size]; -static uint64_t -ntohll(uint64_t input) -{ - return input; + if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE) + { + GNUNET_break (0); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending ACK to helper\n"); + radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf; + get_radiotap_header (endpoint, radio_header, size); + get_wlan_header (endpoint->plugin, + &radio_header->frame, + &endpoint->addr, + size); + memcpy (&radio_header[1], hdr, msize); + if (NULL != + GNUNET_HELPER_send (endpoint->plugin->suid_helper, + &radio_header->header, + GNUNET_NO /* dropping ACKs is bad */, + NULL, NULL)) + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN ACKs sent"), + 1, GNUNET_NO); } + /** - * Sets a bit active in the bitArray. Increment bit-specific - * usage counter on disk only if below 4bit max (==15). + * Handles the data after all fragments are put together * - * @param bitArray memory area to set the bit in - * @param bitIdx which bit to set + * @param cls macendpoint this messages belongs to + * @param hdr pointer to the data */ static void -setBit(char *bitArray, unsigned int bitIdx) -{ - size_t arraySlot; - unsigned int targetBit; - - arraySlot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - bitArray[arraySlot] |= targetBit; +wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr) +{ + struct MacEndpoint *endpoint = cls; + struct Plugin *plugin = endpoint->plugin; + struct MacAndSession mas; + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN messages defragmented"), 1, + GNUNET_NO); + mas.session = NULL; + mas.endpoint = endpoint; + (void) GNUNET_SERVER_mst_receive (plugin->fragment_data_tokenizer, + &mas, + (const char *) hdr, + ntohs (hdr->size), + GNUNET_YES, GNUNET_NO); } + /** - * Clears a bit from bitArray. Bit is cleared from the array - * only if the respective usage counter on the disk hits/is zero. + * Free a session * - * @param bitArray memory area to set the bit in - * @param bitIdx which bit to unset + * @param session the session free */ -/*static void - clearBit(char *bitArray, unsigned int bitIdx) - { - size_t slot; - unsigned int targetBit; +static void +free_session (struct Session *session) +{ + struct MacEndpoint *endpoint = session->mac; + struct PendingMessage *pm; + + endpoint->plugin->env->session_end (endpoint->plugin->env->cls, + &session->target, + session); + while (NULL != (pm = session->pending_message_head)) + { + GNUNET_CONTAINER_DLL_remove (session->pending_message_head, + session->pending_message_tail, pm); + if (GNUNET_SCHEDULER_NO_TASK != pm->timeout_task) + { + GNUNET_SCHEDULER_cancel (pm->timeout_task); + pm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (pm->msg); + GNUNET_free (pm); + } + GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, + endpoint->sessions_tail, + session); + if (session->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (session->timeout_task); + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), -1, + GNUNET_NO); + GNUNET_free (session); +} - slot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - bitArray[slot] = bitArray[slot] & (~targetBit); - }*/ /** - * Checks if a bit is active in the bitArray + * A session is timing out. Clean up. * - * @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. + * @param cls pointer to the Session + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ -static int -testBit(char *bitArray, unsigned int bitIdx) +static void +session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - size_t slot; - unsigned int targetBit; + struct Session * session = cls; + struct GNUNET_TIME_Relative timeout; - slot = bitIdx / 8; - targetBit = (1L << (bitIdx % 8)); - if (bitArray[slot] & targetBit) - return GNUNET_YES; - else - return GNUNET_NO; + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (session->timeout); + if (0 == timeout.rel_value) + { + free_session (session); + return; + } + session->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &session_timeout, session); } + /** - * get the next message number, at the moment just a random one - * @return returns the next valid message-number for sending packets + * Create a new session + * + * @param endpoint pointer to the mac endpoint of the peer + * @param peer peer identity to use for this session + * @return returns the session */ -uint32_t -get_next_message_id() -{ - return GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); -} - -/** - * start next message number generator - * (not necessary at the moment) - */ -void -start_next_message_id() -{ - //GNUNET_CRYPTO_random_init; -} - -/** - * search for a session with the addr - * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer - * @return returns the session - */ - -static struct Session * -search_session(struct Plugin *plugin, const uint8_t * addr) -{ - struct Sessionqueue * queue = plugin->sessions; - struct Sessionqueue * lastitem = NULL; - - //just look at all the session for the needed one - while (queue != NULL) - { - // 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; - } - return NULL; -} - -/** - * create a new session - * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer - * @return returns the session - */ - static struct Session * -create_session(struct Plugin *plugin, const uint8_t * addr) +create_session (struct MacEndpoint *endpoint, + const struct GNUNET_PeerIdentity *peer) { - struct Sessionqueue * queue = GNUNET_malloc (sizeof (struct Sessionqueue)); - - GNUNET_CONTAINER_DLL_insert_tail(plugin->sessions, plugin->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++; - -#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)); -#endif - - return queue->content; -} + struct Session *session; -/** - * 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 - * @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) -{ - struct Session * session = search_session(plugin, addr); - if (session != NULL) + for (session = endpoint->sessions_head; NULL != session; session = session->next) + if (0 == memcmp (peer, &session->target, + sizeof (struct GNUNET_PeerIdentity))) { + session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); 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); - */ + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), 1, + GNUNET_NO); + session = GNUNET_malloc (sizeof (struct Session)); + GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head, + endpoint->sessions_tail, + session); + session->mac = endpoint; + session->target = *peer; + session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + session->timeout_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout, session); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Created new session for peer `%s' with endpoint %s\n", + GNUNET_i2s (peer), + mac_to_string (&endpoint->addr)); + return session; } -/** - * Queue the session to send data - */ -//TODO doxigen -static void -queue_Session(struct Plugin *plugin, struct Session * session) -{ - struct Sessionqueue * queue = plugin->pending_Sessions; - struct Sessionqueue * lastitem = NULL; - - while (queue != NULL) - { - // content is never NULL - GNUNET_assert (queue->content != NULL); - // is session already in queue? - if (session == queue->content) - { - return; - } - // try next - lastitem = queue; - queue = queue->next; - } - - // Session is not in the queue - - 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++; - -} -//TODO doxigen /** - * Function to schedule the write task, executed after a delay + * Function called once we have successfully given the fragment + * message to the SUID helper process and we are thus ready for + * the next fragment. + * + * @param cls the 'struct FragmentMessage' + * @param result result of the operation (GNUNET_OK on success, GNUNET_NO if the helper died, GNUNET_SYSERR + * if the helper was stopped) */ static void -delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +fragment_transmission_done (void *cls, + int result) { - struct Plugin * plugin = cls; - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) - return; + struct FragmentMessage *fm = cls; - // GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg - 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); - } + fm->sh = NULL; + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); } -//TODO doxigen -/** - * Function to calculate the time of the next periodic "hello-beacon" - */ -static void -set_next_beacon_time(struct Plugin * const plugin) -{ - //under 10 known peers: once a second - if (plugin->session_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)); - } - //under 30 known peers: every 10 seconds - else if (plugin->session_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)); - } - //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)); - } -} -//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 + * Transmit a fragment of a message. + * + * @param cls 'struct FragmentMessage' this fragment message belongs to + * @param hdr pointer to the start of the fragment message */ static void -check_next_fragment_timeout(struct Plugin * const plugin) -{ - struct FragmentMessage * fm; - struct GNUNET_TIME_Relative next_send; - - //cancel old task - 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; - } - 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 - { - next_send = GNUNET_TIME_absolute_get_remaining(plugin->beacon_time); - if (fm != NULL) - { - 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); +transmit_fragment (void *cls, + const struct GNUNET_MessageHeader *hdr) +{ + struct FragmentMessage *fm = cls; + struct MacEndpoint *endpoint = fm->macendpoint; + size_t size; + uint16_t msize; + + msize = ntohs (hdr->size); + size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize; + { + char buf[size]; + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radio_header; + + radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf; + get_radiotap_header (endpoint, radio_header, size); + get_wlan_header (endpoint->plugin, + &radio_header->frame, + &endpoint->addr, + size); + memcpy (&radio_header[1], hdr, msize); + GNUNET_assert (NULL == fm->sh); + fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper, + &radio_header->header, + GNUNET_NO, + &fragment_transmission_done, fm); + if (NULL != fm->sh) + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN message fragments sent"), + 1, GNUNET_NO); + else + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); + } } -//TODO doxigen -/** - * Function to get the next queued Session, removes the session from the queue - */ - -static struct Session * -get_next_queue_Session(struct Plugin * plugin) -{ - struct Session * session; - struct Sessionqueue * sessionqueue; - struct Sessionqueue * sessionqueue_alt; - struct PendingMessage * pm; - sessionqueue = plugin->pending_Sessions; - while (sessionqueue != NULL) - { - session = sessionqueue->content; - - pm = session->pending_message; - if (pm == NULL) - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "pending message is empty, should not happen. session %p\n", - session); -#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) - { - plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions, - plugin->pending_Sessions_tail, sessionqueue); - GNUNET_free(sessionqueue); - - return session; - } - else - { - sessionqueue = sessionqueue->next; - } - } - else - { - - session->pending_message = session->pending_message2; - session->pending_message2 = NULL; - - //call the cont func that it did not work - if (pm->transmit_cont != NULL) - pm->transmit_cont(pm->transmit_cont_cls, &(session->target), - GNUNET_SYSERR); - GNUNET_free(pm->msg); - GNUNET_free(pm); - - if (session->pending_message == NULL) - { - sessionqueue_alt = sessionqueue; - sessionqueue = sessionqueue->next; - plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions, - 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 + * Frees the space of a message in the fragment queue (send queue) + * * @param fm message to free */ static void -free_fragment_message(struct Plugin * plugin, struct FragmentMessage * fm) -{ - 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); - GNUNET_free(fm); - plugin->pending_fragment_messages--; - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "free pending fragment messages, pending messages remaining %u\n", - plugin->pending_fragment_messages); -#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 - */ - -static void -check_fragment_queue(struct Plugin * plugin) -{ - struct Session * session; - struct FragmentMessage * fm; - struct GNUNET_PeerIdentity pid; - - struct PendingMessage * pm; - - if (plugin->pending_fragment_messages < FRAGMENT_QUEUE_SIZE) - { - 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); - - 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; - - sort_fragment_into_queue(plugin, fm); - plugin->pending_fragment_messages++; - - 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); - - if (session->pending_message2 != NULL) - { - session->pending_message = session->pending_message2; - session->pending_message2 = NULL; - //requeue session - queue_Session(plugin, session); - } - - //check if timeout changed - check_next_fragment_timeout(plugin); - } - } -} - -/** - * 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 - */ -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); - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Finished sending and got all acks for a fragmented message\n"); -#endif - - check_next_fragment_timeout(plugin); - check_fragment_queue(plugin); - - } -} - -/** - * Function to set the next fragment number - * @param fm use this FragmentMessage - */ - -void -set_next_message_fragment_pos(struct FragmentMessage * fm) -{ - - //check if retransmit is needed - if (GNUNET_TIME_absolute_get_remaining(fm->next_ack).rel_value == 0) - { - - // be positive and try again later :-D - fm->next_ack = GNUNET_TIME_relative_to_absolute(get_ack_timeout(fm)); - // find first missing fragment - - fm->message_pos = 0; - } - - //test if ack 0 (or X) was already received - while (testBit((char*) &fm->ack_bitfield, fm->message_pos) == GNUNET_YES) - { - fm->message_pos++; - } - -} - -void -send_hello_beacon(struct Plugin * plugin) -{ - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending hello beacon\n"); -#endif - - uint16_t size = 0; - 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); - size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) - + sizeof(struct ieee80211_frame) + sizeof(struct GNUNET_MessageHeader) - + GNUNET_HELLO_size(*(plugin->env->our_hello)); - - 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, NULL, radioHeader); - ieeewlanheader = (struct ieee80211_frame*) &radioHeader[1]; - getWlanHeader(ieeewlanheader, bc_all_mac, plugin); - - msgheader2 = (struct GNUNET_MessageHeader*) &ieeewlanheader[1]; - 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))); - - 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)); - - } - GNUNET_assert(bytes != GNUNET_SYSERR); - GNUNET_assert(bytes == size); - GNUNET_free(msgheader); - - set_next_beacon_time(plugin); - check_next_fragment_timeout(plugin); +free_fragment_message (struct FragmentMessage *fm) +{ + struct MacEndpoint *endpoint = fm->macendpoint; + + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN messages pending (with fragmentation)"), + -1, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (endpoint->sending_messages_head, + endpoint->sending_messages_tail, fm); + if (NULL != fm->sh) + { + GNUNET_HELPER_send_cancel (fm->sh); + fm->sh = NULL; + } + GNUNET_FRAGMENT_context_destroy (fm->fragcontext); + if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (fm->timeout_task); + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (fm); } -static void -send_ack(struct Plugin * plugin, struct AckSendQueue * ack) -{ - - 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; - - GNUNET_assert(sizeof(struct FragmentationAckHeader) <= WLAN_MTU); - -#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) + sizeof(struct FragmentationAckHeader); - 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, ack->session, radioHeader); - ieeewlanheader = (struct ieee80211_frame*) &radioHeader[1]; - getWlanHeader(ieeewlanheader, ack->session->addr, plugin); - - 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); - - 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)); - - } - GNUNET_assert(bytes != GNUNET_SYSERR); - GNUNET_assert(bytes == size); - GNUNET_free(msgheader); - check_next_fragment_timeout(plugin); -} /** - * Function called when wlan helper is ready to get some data + * A FragmentMessage has timed out. Remove it. * - * @param cls closure - * @param tc GNUNET_SCHEDULER_TaskContext + * @param cls pointer to the 'struct FragmentMessage' + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ - -static void -do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - - 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; - - } - - fm = plugin->pending_Fragment_Messages_head; - if (fm != NULL) - { - 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 - { - - //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; - -#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)); -#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) - { - 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 != size) - { - 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); - - 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); - - GNUNET_free(msgheader); - check_next_fragment_timeout(plugin); - } - - //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); - - GNUNET_CONTAINER_DLL_remove (plugin->pending_Fragment_Messages_head, - plugin->pending_Fragment_Messages_tail, fm); - - 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); - - } - - } - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "do_transmit did nothing, should not happen!\n"); -} - static void -finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct Finish_send * finish; - struct Plugin * plugin; - ssize_t bytes; - - finish = cls; - plugin = finish->plugin; - - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, - finish->msgheader, finish->size); - 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( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, - &finish_sending, finish); - } - else - { - GNUNET_free(finish->msgstart); - GNUNET_free(finish); - check_next_fragment_timeout(plugin); - } - +fragmentmessage_timeout (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct FragmentMessage *fm = cls; + + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + if (NULL != fm->cont) + { + fm->cont (fm->cont_cls, &fm->target, GNUNET_SYSERR); + fm->cont = NULL; + } + free_fragment_message (fm); } -int -getRadiotapHeader(struct Plugin * plugin, struct Session * session, - struct Radiotap_Send * header) -{ - - if (session != NULL) - { - header->rate = session->rate; - header->tx_power = session->tx_power; - header->antenna = session->antenna; - } - else - { - header->rate = 255; - header->tx_power = 0; - header->antenna = 0; - } - - return GNUNET_YES; -} -; - -/** - * 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 - */ - -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; -} - -/** - * 32bit CRC - * - * @param msgbuf pointer tor the data - * @param msgbuf_size size of the data - * - * @return 32bit crc value - */ - -uint32_t -getcrc32(const char *msgbuf, size_t msgbuf_size) -{ - //TODO calc some crc - return 0; -} - -/** - * 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 that can be used by the transport service to transmit - * a message using the plugin. + * Transmit a message to the given destination with fragmentation. * - * @param cls closure - * @param target who should receive this message - * @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 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)) - * @param addrlen length of the address in bytes - * @param force_address GNUNET_YES if the plugin MUST use the given address, - * otherwise the plugin may use other addresses or - * existing connections (if available) + * @param endpoint desired destination + * @param timeout how long can the message wait? + * @param target peer that should receive the message + * @param msg message to transmit * @param cont continuation to call once the message has * been transmitted (or if the transport is ready * for the next transmission call; or if the - * peer disconnected...) + * peer disconnected...); can be NULL * @param cont_cls closure for cont - * @return number of bytes used (on the physical network, with overheads); - * -1 on hard errors (i.e. address invalid); 0 is a legal value - * and does NOT mean that the message was not transmitted (DV) - */ -static ssize_t -wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, - const char *msgbuf, size_t msgbuf_size, unsigned int priority, - struct GNUNET_TIME_Relative timeout, struct Session *session, - const void *addr, size_t addrlen, int force_address, - GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) -{ - struct Plugin * plugin = cls; - struct PendingMessage * newmsg = NULL; - struct WlanHeader * wlanheader = NULL; - - //check if msglen > 0 - GNUNET_assert(msgbuf_size > 0); - - //get session if needed - if (session == NULL) - { - if (wlan_plugin_address_suggested(plugin, addr, addrlen) == GNUNET_OK) - { - session = get_Session(plugin, addr); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Wlan Address len %d is wrong\n"), addrlen); - return -1; - } - } - - //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) - { - newmsg = session->pending_message; - 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", - 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; - } - } - - newmsg = GNUNET_malloc(sizeof(struct PendingMessage)); - (newmsg->msg) = GNUNET_malloc(msgbuf_size + sizeof(struct WlanHeader)); - wlanheader = (struct 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[1], msgbuf, msgbuf_size); - newmsg->transmit_cont = cont; - newmsg->transmit_cont_cls = cont_cls; - newmsg->timeout = GNUNET_TIME_relative_to_absolute(timeout); - - newmsg->timeout.abs_value = newmsg->timeout.abs_value - 500; - - newmsg->message_size = msgbuf_size + sizeof(struct WlanHeader); - - if (session->pending_message == NULL) - { - session->pending_message = newmsg; - } - else - { - session->pending_message2 = newmsg; - } - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "New message for %p with size (incl wlan header) %u added\n", session, - newmsg->message_size); -#endif - - //queue session - queue_Session(plugin, session); - - check_fragment_queue(plugin); - //FIXME not the correct size - return msgbuf_size; - -} - -/** - * 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 - */ -static struct FragmentMessage * -get_fragment_message_from_session(struct Session * session) -{ - struct FragmentMessage * fm = session->plugin->pending_Fragment_Messages_head; - while (fm != NULL) - { - if (fm->session == session) - { - return fm; - } - fm = fm->next; - } - return NULL; -} - -/** - * 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) -{ - struct FragmentMessage * fm = session->plugin->pending_Fragment_Messages_head; - while (fm != NULL) - { - if ((fm->session == session) && (fm->message_id_out == message_id)) - { - return fm; - } - fm = fm->next; - } - return NULL; -} - -/** - * Function that can be used to force the plugin to disconnect - * from the given peer and cancel all previous transmissions - * (and their continuation). - * - * @param cls closure - * @param target peer from which to disconnect */ 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; - - // just look at all the session for the needed one - while (queue != NULL) - { - // content is never NULL - GNUNET_assert (queue->content != NULL); - if (memcmp(target, &(queue->content->target), - sizeof(struct GNUNET_PeerIdentity)) == 0) - { - //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) - { - 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); - } - - // 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; - } -} - -/** - * Convert the transports address to a nice, human-readable - * format. - * - * @param cls closure - * @param type name of the transport that generated the address - * @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; +send_with_fragmentation (struct MacEndpoint *endpoint, + struct GNUNET_TIME_Relative timeout, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) - 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; + struct FragmentMessage *fm; + struct Plugin *plugin; - } - GNUNET_assert(checkfragments == rec_message->received_fragments); + plugin = endpoint->plugin; + fm = GNUNET_malloc (sizeof (struct FragmentMessage)); + fm->macendpoint = endpoint; + fm->target = *target; + fm->timeout = GNUNET_TIME_relative_to_absolute (timeout); + fm->cont = cont; + fm->cont_cls = cont_cls; + fm->fragcontext = + GNUNET_FRAGMENT_context_create (plugin->env->stats, WLAN_MTU, + &plugin->tracker, + GNUNET_TIME_UNIT_SECONDS, + msg, + &transmit_fragment, fm); + fm->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, + &fragmentmessage_timeout, fm); + GNUNET_CONTAINER_DLL_insert_tail (endpoint->sending_messages_head, + endpoint->sending_messages_tail, + fm); } -/** - * 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 + * Free a MAC endpoint. + * + * @param endpoint pointer to the MacEndpoint to free */ - static void -insert_fragment_in_queue(struct Receive_Message_Queue * rec_message, - struct Receive_Fragment_Queue * rec_queue) +free_macendpoint (struct MacEndpoint *endpoint) { - 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); + struct Plugin *plugin = endpoint->plugin; + struct FragmentMessage *fm; + struct Session *session; - setBit((char *) &rec_message->received_fragments, rec_queue->num); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN MAC endpoints allocated"), -1, GNUNET_NO); + while (NULL != (session = endpoint->sessions_head)) + free_session (session); + while (NULL != (fm = endpoint->sending_messages_head)) + free_fragment_message (fm); + GNUNET_CONTAINER_DLL_remove (plugin->mac_head, + plugin->mac_tail, + endpoint); + + if (NULL != endpoint->defrag) + { + GNUNET_DEFRAGMENT_context_destroy(endpoint->defrag); + endpoint->defrag = NULL; + } + + plugin->mac_count--; + if (GNUNET_SCHEDULER_NO_TASK != endpoint->timeout_task) + { + GNUNET_SCHEDULER_cancel (endpoint->timeout_task); + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (endpoint); } -/** - * 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 + * A MAC endpoint is timing out. Clean up. + * + * @param cls pointer to the MacEndpoint + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ - static void -check_rec_finished_msg(struct Plugin* plugin, - struct Session_light * session_light, struct Session * session, - struct Receive_Message_Queue * rx_message) +macendpoint_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - 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; - } + struct MacEndpoint *endpoint = cls; + struct GNUNET_TIME_Relative timeout; -#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); - } - } - } + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout); + if (0 == timeout.rel_value) + { + free_macendpoint (endpoint); + return; + } + endpoint->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &macendpoint_timeout, + endpoint); } -static void -process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr) -{ - - 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)); -} /** - * handels the data after all fragments are put together - * @param plugin - * @param session_light - * @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) -{ - struct WlanHeader * wlanheader = NULL; - struct Session * session = NULL; - const char * tempmsg = NULL; - const struct GNUNET_MessageHeader * temp_hdr = NULL; - struct GNUNET_PeerIdentity tmptarget; - - if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) - { - -#if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_data_massage_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n", - ntohs(hdr->size)); -#endif - - if (ntohs(hdr->size) < sizeof(struct WlanHeader) - + sizeof(struct GNUNET_MessageHeader)) - { - //packet not big enought - 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]; - - if (getcrc32(tempmsg, ntohs(wlanheader->header.size)) != ntohl( - wlanheader->crc)) - { - //wrong crc, dispose message - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Wlan message Header crc was wrong\n"); - return; - } - - //if not in session list - if (session == NULL) - { -#if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "WLAN client not in session list: packet size = %u, inner size = %u, header size = %u\n", - ntohs(wlanheader->header.size), ntohs(temp_hdr->size), - sizeof(struct WlanHeader)); -#endif - //try if it is a hello message - if (ntohs(wlanheader->header.size) >= ntohs(temp_hdr->size) - + sizeof(struct WlanHeader)) - { - if (ntohs(temp_hdr->type) == GNUNET_MESSAGE_TYPE_HELLO) - { - if (GNUNET_HELLO_get_id( - (const struct GNUNET_HELLO_Message *) temp_hdr, - &tmptarget) == GNUNET_OK) - { - session = create_session(plugin, session_light->addr); - session_light->session = session; - memcpy(&session->target, &tmptarget, - sizeof(struct GNUNET_PeerIdentity)); - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "WLAN client not in session list and hello message not okay\n"); - return; - } - - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "WLAN client not in session list and not a hello message\n"); - return; - } - } - else - { - GNUNET_log( - GNUNET_ERROR_TYPE_WARNING, - "WLAN client not in session list and message size in does not fit\npacket size = %u, inner size = %u, header size = %u\n", - ntohs(wlanheader->header.size), ntohs(temp_hdr->size), - sizeof(struct WlanHeader)); - return; - } - } - - //"receive" the message - - - GNUNET_SERVER_mst_receive(plugin->data_tokenizer, session, - (const char *) temp_hdr, - ntohs(hdr->size) - sizeof(struct WlanHeader), GNUNET_YES, GNUNET_NO); - - return; - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "wlan_data_massage_handler got wrong message type\n"); - return; - } + * Find (or create) a MacEndpoint with a specific MAC address + * + * @param plugin pointer to the plugin struct + * @param addr the MAC address of the endpoint + * @return handle to our data structure for this MAC + */ +static struct MacEndpoint * +create_macendpoint (struct Plugin *plugin, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr) +{ + struct MacEndpoint *pos; + + for (pos = plugin->mac_head; NULL != pos; pos = pos->next) + if (0 == memcmp (addr, &pos->addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + return pos; + pos = GNUNET_malloc (sizeof (struct MacEndpoint)); + pos->addr = *addr; + pos->plugin = plugin; + pos->defrag = + GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU, + MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, + pos, + &wlan_data_message_handler, + &send_ack); + pos->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT); + pos->timeout_task = + GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, + pos); + GNUNET_CONTAINER_DLL_insert (plugin->mac_head, plugin->mac_tail, pos); + plugin->mac_count++; + GNUNET_STATISTICS_update (plugin->env->stats, _("# WLAN MAC endpoints allocated"), + 1, GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "New MAC endpoint `%s'\n", + mac_to_string (addr)); + return pos; } + /** - * 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 + * Creates a new outbound session the transport service will use to send data to the + * peer + * + * @param cls the plugin + * @param address the address + * @return the session or NULL of max connections exceeded */ - -void -add_ack_for_send(struct Plugin * plugin, struct Session * session, - uint64_t bitfield, struct FragmentationHeader * fh) +static struct Session * +wlan_plugin_get_session (void *cls, + const struct GNUNET_HELLO_Address *address) { - 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); + struct Plugin *plugin = cls; + struct MacEndpoint *endpoint; + if (NULL == address) + return NULL; + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != address->address_length) + { + GNUNET_break (0); + return NULL; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Service asked to create session for peer `%s' with MAC `%s'\n", + GNUNET_i2s (&address->peer), + mac_to_string (address->address)); + endpoint = create_macendpoint (plugin, address->address); + return create_session (endpoint, &address->peer); } + /** - * 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 + * Function that can be used to force the plugin to disconnect + * from the given peer and cancel all previous transmissions + * (and their continuation). + * + * @param cls closure + * @param target peer from which to disconnect */ - -struct Receive_Message_Queue * -get_receive_message(struct Plugin * plugin, struct Session * session, - uint32_t message_id) +static void +wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { - 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; + struct Plugin *plugin = cls; + struct Session *session; + struct MacEndpoint *endpoint; + + for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next) + for (session = endpoint->sessions_head; NULL != session; session = session->next) + if (0 == memcmp (target, &session->target, + sizeof (struct GNUNET_PeerIdentity))) + { + free_session (session); + break; /* inner-loop only (in case peer has another MAC as well!) */ + } } + /** - * function to get the receive message of a session - * @param plugin pointer to the plugin struct - * @param session session this fragment belongs to + * Function that can be used by the transport service to transmit + * a message using the plugin. Note that in the case of a + * peer disconnecting, the continuation MUST be called + * prior to the disconnect notification itself. This function + * will be called with this peer's HELLO message to initiate + * a fresh connection to another peer. + * + * @param cls closure + * @param session which session must be used + * @param msgbuf the message to transmit + * @param msgbuf_size number of bytes in 'msgbuf' + * @param priority how important is the message (most plugins will + * ignore message priority and just FIFO) + * @param to how long to wait at most for the transmission (does not + * require plugins to discard the message after the timeout, + * just advisory for the desired delay; most plugins will ignore + * this as well) + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...); can be NULL + * @param cont_cls closure for cont + * @return number of bytes used (on the physical network, with overheads); + * -1 on hard errors (i.e. address invalid); 0 is a legal value + * and does NOT mean that the message was not transmitted (DV) */ - -struct Receive_Message_Queue * -get_receive_message_from_session(struct Plugin * plugin, - struct Session * session) +static ssize_t +wlan_plugin_send (void *cls, + struct Session *session, + const char *msgbuf, size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative to, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { - 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; + struct Plugin *plugin = cls; + struct WlanHeader *wlanheader; + size_t size = msgbuf_size + sizeof (struct WlanHeader); + char buf[size] GNUNET_ALIGN; + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting %u bytes of payload to peer `%s' (starting with %u byte message of type %u)\n", + msgbuf_size, + GNUNET_i2s (&session->target), + (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->size), + (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->type)); + wlanheader = (struct WlanHeader *) buf; + wlanheader->header.size = htons (msgbuf_size + sizeof (struct WlanHeader)); + wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA); + wlanheader->sender = *plugin->env->my_identity; + wlanheader->target = session->target; + wlanheader->crc = htonl (GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size)); + memcpy (&wlanheader[1], msgbuf, msgbuf_size); + send_with_fragmentation (session->mac, + to, + &session->target, + &wlanheader->header, + cont, cont_cls); + return size; } + /** - * 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 + * We have received data from the WLAN via some session. Process depending + * on the message type (HELLO, DATA, FRAGMENTATION or FRAGMENTATION-ACK). + * + * @param cls pointer to the plugin + * @param client pointer to the session this message belongs to + * @param hdr start of 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) +static int +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) + struct Plugin *plugin = cls; + struct MacAndSession *mas = client; + struct MacAndSession xmas; +#define NUM_ATS 2 + struct GNUNET_ATS_Information ats[NUM_ATS]; /* FIXME: do better here */ + struct FragmentMessage *fm; + struct GNUNET_PeerIdentity tmpsource; + const struct WlanHeader *wlanheader; + int ret; + uint16_t msize; + + ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE); + ats[0].value = htonl (1); + ats[1].type = htonl (GNUNET_ATS_NETWORK_TYPE); + ats[1].value = htonl (GNUNET_ATS_NET_WLAN); + msize = ntohs (hdr->size); + switch (ntohs (hdr->type)) + { + case GNUNET_MESSAGE_TYPE_HELLO: + if (GNUNET_OK != + GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource)) { - 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; - } + GNUNET_break_op (0); + break; } - - if (is_double_msg(rx_message, fh) != GNUNET_YES) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing %u bytes of HELLO from peer `%s' at MAC %s\n", + (unsigned int) msize, + GNUNET_i2s (&tmpsource), + mac_to_string (&mas->endpoint->addr)); + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# HELLO messages received via WLAN"), 1, + GNUNET_NO); + plugin->env->receive (plugin->env->cls, + &tmpsource, + hdr, + ats, NUM_ATS, + mas->session, + (mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr, + (mas->endpoint == NULL) ? 0 : sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + break; + case GNUNET_MESSAGE_TYPE_FRAGMENT: + if (NULL == mas->endpoint) { - - //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; - -#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); -#endif - - check_rec_finished_msg(plugin, session_light, session, rx_message); + GNUNET_break (0); + break; } - else + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing %u bytes of FRAGMENT from MAC %s\n", + (unsigned int) msize, + mac_to_string (&mas->endpoint->addr)); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# fragments received via WLAN"), 1, GNUNET_NO); + (void) GNUNET_DEFRAGMENT_process_fragment (mas->endpoint->defrag, + hdr); + break; + case GNUNET_MESSAGE_TYPE_FRAGMENT_ACK: + if (NULL == mas->endpoint) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "WLAN fragment is a clone\n"); - retval = rx_message->received_fragments; - + GNUNET_break (0); + break; } - return retval; - -} - -/** - * Function used for to process the data received from the wlan interface - * - * @param cls the plugin handle - * @param session_light FIXME: document - * @param hdr hdr of the GNUNET_MessageHeader - */ -static void -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; - - //ADVERTISEMENT - if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT) + GNUNET_STATISTICS_update (plugin->env->stats, _("# ACKs received via WLAN"), + 1, GNUNET_NO); + for (fm = mas->endpoint->sending_messages_head; NULL != fm; fm = fm->next) { - - //TODO better DOS protection, error handling - //TODO test first than create session - GNUNET_assert(session_light != NULL); - -#if DEBUG_wlan - 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)); -#endif - - if (session_light->session == NULL) - { - session_light->session = get_Session(plugin, session_light->addr); - } - GNUNET_assert(GNUNET_HELLO_get_id( - (const struct GNUNET_HELLO_Message *) &hdr[1], - &(session_light->session->target) ) != GNUNET_SYSERR); - + ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); + if (GNUNET_OK == ret) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got last ACK, finished message transmission to `%s' (%p)\n", + mac_to_string (&mas->endpoint->addr), + fm); + mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT); + if (NULL != fm->cont) + { + fm->cont (fm->cont_cls, &fm->target, GNUNET_OK); + fm->cont = NULL; + } + free_fragment_message (fm); + break; + } + if (GNUNET_NO == ret) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got an ACK, message transmission to `%s' not yet finished\n", + mac_to_string (&mas->endpoint->addr)); + break; + } } - - //FRAGMENT - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "ACK not matched against any active fragmentation with MAC `%s'\n", + mac_to_string (&mas->endpoint->addr)); + break; + case GNUNET_MESSAGE_TYPE_WLAN_DATA: + if (NULL == mas->endpoint) { - - GNUNET_assert(session_light != NULL); - if (session_light->session == NULL) - { - session_light->session = search_session(plugin, session_light->addr); - } - 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)); -#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) - { - fragment_bitfield = insert_fragment_in_in_message_queue(plugin, - session_light, session, fh, rxinfo); - } - else - { - // 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)); - } - - add_ack_for_send(plugin, session, fragment_bitfield, fh); - check_next_fragment_timeout(plugin); - + GNUNET_break (0); + break; } - - //ACK - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT_ACK) + if (msize < sizeof (struct WlanHeader)) { - -#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)); -#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->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; - } - + GNUNET_break (0); + break; + } + wlanheader = (const struct WlanHeader *) hdr; + if (0 != memcmp (&wlanheader->target, + plugin->env->my_identity, + sizeof (struct GNUNET_PeerIdentity))) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "WLAN data for `%s', not for me, ignoring\n", + GNUNET_i2s (&wlanheader->target)); + break; } - else + if (ntohl (wlanheader->crc) != + GNUNET_CRYPTO_crc32_n (&wlanheader[1], msize - sizeof (struct WlanHeader))) { - // TODO Wrong data? - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "WLAN packet inside the WLAN helper packet has not the right type\n"); - return; + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN DATA messages discarded due to CRC32 error"), 1, + GNUNET_NO); + break; } - -#if 0 - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Helper finished\n"); -#endif - + xmas.endpoint = mas->endpoint; + xmas.session = create_session (mas->endpoint, &wlanheader->sender); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing %u bytes of WLAN DATA from peer `%s'\n", + (unsigned int) msize, + GNUNET_i2s (&wlanheader->sender)); + (void) GNUNET_SERVER_mst_receive (plugin->wlan_header_payload_tokenizer, + &xmas, + (const char *) &wlanheader[1], + msize - sizeof (struct WlanHeader), + GNUNET_YES, GNUNET_NO); + break; + default: + if (NULL == mas->endpoint) + { + GNUNET_break (0); + break; + } + if (NULL == mas->session) + { + GNUNET_break (0); + break; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received packet with %u bytes of type %u from peer %s\n", + (unsigned int) msize, + (unsigned int) ntohs (hdr->type), + GNUNET_i2s (&mas->session->target)); + plugin->env->receive (plugin->env->cls, + &mas->session->target, + hdr, + ats, NUM_ATS, + mas->session, + (mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr, + (mas->endpoint == NULL) ? 0 : sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + break; + } + return GNUNET_OK; } +#undef NUM_ATS -const char * -macprinter(const u_int8_t * mac) -{ - static char macstr[20]; - - GNUNET_snprintf(macstr, sizeof(macstr), "%X:%X:%X:%X:%X:%X", mac[0], mac[1], - mac[2], mac[3], mac[4], mac[5]); - return macstr; -} /** * Function used for to process the data from the suid process @@ -2697,266 +1256,376 @@ macprinter(const u_int8_t * mac) * @param client client that send the data (not used) * @param hdr header of the GNUNET_MessageHeader */ -static void -wlan_process_helper(void *cls, void *client, - const struct GNUNET_MessageHeader *hdr) +static int +handle_helper_message (void *cls, void *client, + const struct GNUNET_MessageHeader *hdr) { struct Plugin *plugin = cls; - struct ieee80211_frame * wlanIeeeHeader = NULL; - struct Session_light * session_light = NULL; - struct Radiotap_rx * rxinfo; - const struct GNUNET_MessageHeader * temp_hdr = NULL; - - int datasize = 0; - int pos = 0; - - switch (ntohs(hdr->type)) + const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo; + const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm; + struct MacAndSession mas; + uint16_t msize; + + msize = ntohs (hdr->size); + switch (ntohs (hdr->type)) + { + case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: + if (msize != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)) { - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA: -#if DEBUG_wlan - GNUNET_log( - GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_process_helper got GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA size: %u\n", - ntohs(hdr->size)); -#endif - - //call wlan_process_helper with the message inside, later with wlan: analyze signal - if (ntohs(hdr->size) < sizeof(struct ieee80211_frame) - + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx)) - { - GNUNET_break (0); - /* FIXME: restart SUID process */ - return; - } - rxinfo = (struct Radiotap_rx *) &hdr[1]; - wlanIeeeHeader = (struct ieee80211_frame *) &rxinfo[1]; - - //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) - { - //check for broadcast or mac - if (memcmp(&(wlanIeeeHeader->i_addr1), bc_all_mac, - sizeof(struct MacAddress) == 0) || memcmp( - &(wlanIeeeHeader->i_addr1), &(plugin->mac_address), - sizeof(struct MacAddress)) == 0) - { - - // process the inner data - - - datasize = ntohs(hdr->size) - sizeof(struct ieee80211_frame) - - sizeof(struct GNUNET_MessageHeader); - - session_light = GNUNET_malloc(sizeof(struct Session_light)); - 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] - + pos; - - wlan_data_helper(plugin, session_light, temp_hdr, rxinfo); - pos += ntohs(temp_hdr->size); - - } - - //clean up - GNUNET_free(session_light); - } - else - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_process_helper got wrong MAC: %s\n", macprinter( - wlanIeeeHeader->i_addr1)); -#endif - } - } - else - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Func wlan_process_helper got wrong BSSID: %s\n", macprinter( - wlanIeeeHeader->i_addr2)); -#endif - } + GNUNET_break (0); + break; + } + cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *) hdr; + if (GNUNET_YES == plugin->have_mac) + { + if (0 == memcmp (&plugin->mac_address, + &cm->mac, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + break; /* no change */ + /* remove old address */ + plugin->env->notify_address (plugin->env->cls, GNUNET_NO, + &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + } + plugin->mac_address = cm->mac; + plugin->have_mac = GNUNET_YES; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer `%s'\n", + mac_to_string (&cm->mac), + GNUNET_i2s (plugin->env->my_identity)); + plugin->env->notify_address (plugin->env->cls, GNUNET_YES, + &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); break; - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: - //TODO more control messages - //TODO use struct wlan_helper_control - if (ntohs(hdr->size) != sizeof(struct Wlan_Helper_Control_Message)) - { - GNUNET_break (0); - /* FIXME: restart SUID process */ - return; - } - memcpy(&plugin->mac_address, &hdr[1], sizeof(struct MacAddress)); -#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))); -#endif - plugin->env->notify_address(plugin->env->cls, "wlan", &plugin->mac_address, - sizeof(struct MacAddress), GNUNET_TIME_UNIT_FOREVER_REL); + case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER: + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got data message from helper with %u bytes\n", + msize); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# DATA messages received via WLAN"), 1, + GNUNET_NO); + if (msize < sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)) + { + GNUNET_break (0); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Size of packet is too small (%u bytes)\n", + msize); + break; + } + rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr; + + /* check if message is actually for us */ + if (0 != memcmp (&rxinfo->frame.addr3, &mac_bssid_gnunet, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + { + /* Not the GNUnet BSSID */ + break; + } + if ( (0 != memcmp (&rxinfo->frame.addr1, &bc_all_mac, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) && + (0 != memcmp (&rxinfo->frame.addr1, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) ) + { + /* Neither broadcast nor specifically for us */ + break; + } + if (0 == memcmp (&rxinfo->frame.addr2, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + { + /* packet is FROM us, thus not FOR us */ + break; + } + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN DATA messages processed"), + 1, GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Receiving %u bytes of data from MAC `%s'\n", + (unsigned int) (msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)), + mac_to_string (&rxinfo->frame.addr2)); + mas.endpoint = create_macendpoint (plugin, &rxinfo->frame.addr2); + mas.session = NULL; + (void) GNUNET_SERVER_mst_receive (plugin->helper_payload_tokenizer, + &mas, + (const char*) &rxinfo[1], + msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage), + GNUNET_YES, GNUNET_NO); break; default: GNUNET_break (0); - return; - } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Unexpected message of type %u (%u bytes)", + ntohs (hdr->type), ntohs (hdr->size)); + break; + } + return GNUNET_OK; } + + /** - * We have been notified that wlan-helper has written something to stdout. - * Handle the output, then reschedule this function to be called again once - * more is available. + * Task to (periodically) send a HELLO beacon * - * @param cls the plugin handle - * @param tc the scheduling context + * @param cls pointer to the plugin struct + * @param tc scheduler context */ static void -wlan_plugin_helper_read(void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +send_hello_beacon (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { 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) - return; - - char mybuf[WLAN_MTU + sizeof(struct GNUNET_MessageHeader)]; - ssize_t bytes; - - bytes = GNUNET_DISK_file_read(plugin->server_stdout_handle, mybuf, - sizeof(mybuf)); - if (bytes <= 0) - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - _("Finished reading from wlan-helper stdout with code: %d\n"), - bytes); -#endif - return; - } - GNUNET_SERVER_mst_receive(plugin->suid_tokenizer, NULL, mybuf, bytes, - GNUNET_NO, GNUNET_NO); + uint16_t size; + uint16_t hello_size; + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radioHeader; + const struct GNUNET_MessageHeader *hello; + + hello = plugin->env->get_our_hello (); + hello_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello); + GNUNET_assert (sizeof (struct WlanHeader) + hello_size <= WLAN_MTU); + size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + hello_size; + { + char buf[size] GNUNET_ALIGN; + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending %u byte HELLO beacon\n", + (unsigned int) size); + radioHeader = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage*) buf; + get_radiotap_header (NULL, radioHeader, size); + get_wlan_header (plugin, &radioHeader->frame, &bc_all_mac, size); + memcpy (&radioHeader[1], hello, hello_size); + if (NULL != + GNUNET_HELPER_send (plugin->suid_helper, + &radioHeader->header, + GNUNET_YES /* can drop */, + NULL, NULL)) + GNUNET_STATISTICS_update (plugin->env->stats, _("# HELLO beacons sent via WLAN"), + 1, GNUNET_NO); + } + plugin->beacon_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (HELLO_BEACON_SCALING_FACTOR, + plugin->mac_count + 1), + &send_hello_beacon, + plugin); - GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK); - plugin->server_read_task = GNUNET_SCHEDULER_add_read_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle, - &wlan_plugin_helper_read, plugin); } + /** - * Start the gnunet-wlan-helper process. + * 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 plugin the transport plugin - * @param testmode should we use the dummy driver for testing? - * @return GNUNET_YES if process was started, GNUNET_SYSERR on error + * @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_transport_start_wlan_helper(struct Plugin *plugin, int testmode) +wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) { - const char * filename = "gnunet-transport-wlan-helper"; - plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_NO, GNUNET_YES); - if (plugin->server_stdout == NULL) - return GNUNET_SYSERR; + struct Plugin *plugin = cls; - plugin->server_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO); - if (plugin->server_stdin == NULL) + if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) + { + GNUNET_break_op (0); return GNUNET_SYSERR; + } + if (GNUNET_YES != plugin->have_mac) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Rejecting MAC `%s': I don't know my MAC!\n", + mac_to_string (addr)); + return GNUNET_NO; /* don't know my MAC */ + } + if (0 != memcmp (addr, + &plugin->mac_address, + addrlen)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Rejecting MAC `%s': not my MAC!\n", + mac_to_string (addr)); + return GNUNET_NO; /* not my MAC */ + } + return GNUNET_OK; +} -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filename, - 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); - if (plugin->server_proc == NULL) - { -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Failed to start gnunet-wlan-helper process\n"); -#endif - return GNUNET_SYSERR; - } - - /* Close the write end of the read pipe */ - GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE); - - /* Close the read end of the write pipe */ - GNUNET_DISK_pipe_close_end(plugin->server_stdin, GNUNET_DISK_PIPE_END_READ); - - plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, - GNUNET_DISK_PIPE_END_READ); - plugin->server_stdin_handle = GNUNET_DISK_pipe_handle(plugin->server_stdin, - GNUNET_DISK_PIPE_END_WRITE); - - GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK); -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Adding server_read_task for the wlan-helper\n"); -#endif +/** + * 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) +{ + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; - sleep(2); + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) + { + GNUNET_break (0); + return NULL; + } + mac = addr; + return GNUNET_strdup (mac_to_string (mac)); +} - plugin->server_read_task = GNUNET_SCHEDULER_add_read_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle, - &wlan_plugin_helper_read, plugin); - return GNUNET_YES; +/** + * Convert the transports address to a nice, human-readable format. + * + * @param cls closure + * @param type name of the transport that generated the address + * @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) +{ + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + char *ret; + + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) + { + /* invalid address */ + LOG (GNUNET_ERROR_TYPE_WARNING, + _("WLAN address with invalid size encountered\n")); + asc (asc_cls, NULL); + return; + } + mac = addr; + ret = GNUNET_strdup (mac_to_string (mac)); + asc (asc_cls, ret); + GNUNET_free (ret); + asc (asc_cls, NULL); } + /** - * Exit point from the plugin. + * Exit point from the plugin. + * * @param cls pointer to the api struct */ - -//FIXME cleanup void * -libgnunet_plugin_transport_wlan_done(void *cls) +libgnunet_plugin_transport_wlan_done (void *cls) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; struct Plugin *plugin = api->cls; - -#if DEBUG_wlan - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "libgnunet_plugin_transport_wlan_done started\n"); -#endif - - GNUNET_assert(cls !=NULL); - - if (plugin->suid_tokenizer != NULL) - GNUNET_SERVER_mst_destroy(plugin->suid_tokenizer); - - if (plugin->data_tokenizer != NULL) - GNUNET_SERVER_mst_destroy(plugin->data_tokenizer); - - GNUNET_free_non_null(plugin->interface); + struct MacEndpoint *endpoint; + struct MacEndpoint *endpoint_next; + + if (NULL == plugin) + { + GNUNET_free (api); + return NULL; + } + if (GNUNET_SCHEDULER_NO_TASK != plugin->beacon_task) + { + GNUNET_SCHEDULER_cancel (plugin->beacon_task); + plugin->beacon_task = GNUNET_SCHEDULER_NO_TASK; + } + if (NULL != plugin->suid_helper) + { + GNUNET_HELPER_stop (plugin->suid_helper); + plugin->suid_helper = NULL; + } + endpoint_next = plugin->mac_head; + while (NULL != (endpoint = endpoint_next)) + { + endpoint_next = endpoint->next; + free_macendpoint (endpoint); + } + if (NULL != plugin->fragment_data_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->fragment_data_tokenizer); + plugin->fragment_data_tokenizer = NULL; + } + if (NULL != plugin->wlan_header_payload_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->wlan_header_payload_tokenizer); + plugin->wlan_header_payload_tokenizer = NULL; + } + if (NULL != plugin->helper_payload_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->helper_payload_tokenizer); + plugin->helper_payload_tokenizer = NULL; + } + GNUNET_free_non_null (plugin->interface); GNUNET_free (plugin); GNUNET_free (api); return NULL; } + +/** + * Function called to convert a string address to + * a binary address. + * + * @param cls closure ('struct Plugin*') + * @param addr string address + * @param addrlen length of the address + * @param buf location to store the buffer + * @param added location to store the number of bytes in the buffer. + * If the function returns GNUNET_SYSERR, its contents are undefined. + * @return GNUNET_OK on success, GNUNET_SYSERR on failure + */ +static int +wlan_string_to_address (void *cls, const char *addr, uint16_t addrlen, + void **buf, size_t *added) +{ + struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + unsigned int a[6]; + unsigned int i; + + if ((NULL == addr) || (addrlen == 0)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + if ('\0' != addr[addrlen - 1]) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + if (strlen (addr) != addrlen - 1) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + if (6 != SSCANF (addr, + "%X:%X:%X:%X:%X:%X", + &a[0], &a[1], &a[2], &a[3], &a[4], &a[5])) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + mac = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + for (i=0;i<6;i++) + mac->mac[i] = a[i]; + *buf = mac; + *added = sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress); + return GNUNET_OK; +} + + /** * Entry point for the plugin. * @@ -2964,71 +1633,121 @@ libgnunet_plugin_transport_wlan_done(void *cls) * @return the 'struct GNUNET_TRANSPORT_PluginFunctions*' or NULL on error */ void * -libgnunet_plugin_transport_wlan_init(void *cls) +libgnunet_plugin_transport_wlan_init (void *cls) { - //struct GNUNET_SERVICE_Context *service; struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; struct GNUNET_TRANSPORT_PluginFunctions *api; struct Plugin *plugin; - static unsigned long long testmode = 0; - - GNUNET_assert(cls !=NULL); + char *interface; + unsigned long long testmode; + + /* check for 'special' mode */ + if (NULL == env->receive) + { + /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully + initialze the plugin or the API */ + api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); + api->cls = NULL; + api->address_pretty_printer = &wlan_plugin_address_pretty_printer; + api->address_to_string = &wlan_plugin_address_to_string; + api->string_to_address = &wlan_string_to_address; + return api; + } + + testmode = 0; + /* check configuration */ + if ( (GNUNET_YES == + GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "TESTMODE")) && + ( (GNUNET_SYSERR == + GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-wlan", + "TESTMODE", &testmode)) || + (testmode > 2) ) ) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Invalid configuration option `%s' in section `%s'\n"), + "TESTMODE", + "transport-wlan"); + return NULL; + } + if ( (0 == testmode) && + (GNUNET_YES != GNUNET_OS_check_helper_binary ("gnunet-helper-transport-wlan")) ) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Helper binary `%s' not SUID, cannot run WLAN transport\n"), + "gnunet-helper-transport-wlan"); + return NULL; + } + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_string + (env->cfg, "transport-wlan", "INTERFACE", + &interface)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Missing configuration option `%s' in section `%s'\n"), + "INTERFACE", + "transport-wlan"); + return NULL; + } plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin->interface = interface; plugin->env = env; - plugin->pendingsessions = 0; - plugin->session_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; - - plugin->suid_tokenizer = GNUNET_SERVER_mst_create(&wlan_process_helper, - plugin); - - 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)); + GNUNET_STATISTICS_set (plugin->env->stats, _("# WLAN sessions allocated"), + 0, GNUNET_NO); + GNUNET_STATISTICS_set (plugin->env->stats, _("# WLAN MAC endpoints allocated"), + 0, 0); + GNUNET_BANDWIDTH_tracker_init (&plugin->tracker, + GNUNET_BANDWIDTH_value_init (100 * 1024 * + 1024 / 8), 100); + plugin->fragment_data_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->wlan_header_payload_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->helper_payload_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->beacon_task = GNUNET_SCHEDULER_add_now (&send_hello_beacon, + plugin); + switch (testmode) + { + case 0: /* normal */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan"; + plugin->helper_argv[1] = interface; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + case 1: /* testmode, peer 1 */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy"; + plugin->helper_argv[1] = (char *) "1"; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + case 2: /* testmode, peer 2 */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy"; + plugin->helper_argv[1] = (char *) "2"; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + default: + GNUNET_assert (0); + } api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); api->cls = plugin; api->send = &wlan_plugin_send; + api->get_session = &wlan_plugin_get_session; api->disconnect = &wlan_plugin_disconnect; 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")) - { - if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(env->cfg, - "transport-wlan", "TESTMODE", &testmode)) - testmode = 0; //default value - } - - if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "INTERFACE")) - { - if (GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-wlan", - "INTERFACE", &(plugin->interface)) != GNUNET_YES) - { - libgnunet_plugin_transport_wlan_done(api); - return NULL; - } - } - - //start the plugin - set_next_beacon_time(plugin); - - 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 - + api->string_to_address = &wlan_string_to_address; return api; } + /* end of plugin_transport_wlan.c */