diff options
Diffstat (limited to 'src/transport/plugin_transport_wlan.c')
| -rw-r--r-- | src/transport/plugin_transport_wlan.c | 3727 |
1 files changed, 1140 insertions, 2587 deletions
diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c index 08f9c58..aed4b22 100644 --- a/src/transport/plugin_transport_wlan.c +++ b/src/transport/plugin_transport_wlan.c @@ -1,31 +1,29 @@ /* - This file is part of GNUnet - (C) 2010 2011 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 */ - -//TODO split rx and tx structures for better handling - #include "platform.h" #include "gnunet_hello_lib.h" #include "gnunet_protocols.h" @@ -39,1808 +37,756 @@ #include "gnunet_fragmentation_lib.h" #include "gnunet_constants.h" -/** - * DEBUG switch - */ -#define DEBUG_WLAN GNUNET_EXTRA_LOGGING - - -#define PROTOCOL_PREFIX "wlan" - -#define PLUGIN_LOG_NAME "wlan-plugin" +#define LOG(kind,...) GNUNET_log_from (kind, "transport-wlan",__VA_ARGS__) /** - * Max size of packet + * Max size of packet (that we give to the WLAN driver for transmission) */ #define WLAN_MTU 1430 /** - * time out of a session - */ -#define SESSION_TIMEOUT GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT - -/** * time out of a mac endpoint */ #define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2) /** - * scaling factor for hello beacon - */ -#define HELLO_BEACON_SCALING_FACTOR 30 - -/** - * scaling factor for restarting the helper - */ -#define HELPER_RESTART_SCALING_FACTOR 2 - -/** - * max size of fragment queue - */ -#define FRAGMENT_QUEUE_SIZE 10 -/** - * max messages in fragment queue per session/client + * 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 FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION 1 +#define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2) /** - * max messages in fragment queue per MAC + * Maximum number of messages in defragmentation queue per MAC */ -#define FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT 1 +#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 2 /** - * max messages in in queue - */ -#define MESSAGES_IN_QUEUE_SIZE 10 -/** - * max messages in in queue per session/client - */ -#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 1 - -/** - * LLC fields for better compatibility + * 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 -#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ - -#define IEEE80211_FC0_VERSION_MASK 0x03 -#define IEEE80211_FC0_VERSION_SHIFT 0 -#define IEEE80211_FC0_VERSION_0 0x00 -#define IEEE80211_FC0_TYPE_MASK 0x0c -#define IEEE80211_FC0_TYPE_SHIFT 2 -#define IEEE80211_FC0_TYPE_MGT 0x00 -#define IEEE80211_FC0_TYPE_CTL 0x04 -#define IEEE80211_FC0_TYPE_DATA 0x08 - GNUNET_NETWORK_STRUCT_BEGIN - -/* - * generic definitions for IEEE 802.11 frames - */ -struct ieee80211_frame -{ - u_int8_t i_fc[2]; - u_int8_t i_dur[2]; - u_int8_t i_addr1[IEEE80211_ADDR_LEN]; - u_int8_t i_addr2[IEEE80211_ADDR_LEN]; - u_int8_t i_addr3[IEEE80211_ADDR_LEN]; - u_int8_t i_seq[2]; - u_int8_t llc[4]; -} GNUNET_PACKED; -GNUNET_NETWORK_STRUCT_END - /** - * 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 connections. head - */ - struct MacEndpoint *mac_head; - - /** - * List of open connections. tail - */ - struct MacEndpoint *mac_tail; - - /** - * Number of connections - */ - unsigned int mac_count; - - /** - * encapsulation of data from the local wlan helper program - */ - struct GNUNET_SERVER_MessageStreamTokenizer *suid_tokenizer; /** - * encapsulation of packets received from the wlan helper + * Message type is GNUNET_MESSAGE_TYPE_WLAN_DATA. */ - struct GNUNET_SERVER_MessageStreamTokenizer *data_tokenizer; + struct GNUNET_MessageHeader header; /** - * stdout pipe handle for the gnunet-helper-transport-wlan process + * CRC32 checksum (only over the payload), in NBO. */ - struct GNUNET_DISK_PipeHandle *server_stdout; + uint32_t crc GNUNET_PACKED; /** - * stdout file handle for the gnunet-helper-transport-wlan process + * Sender of the message. */ - const struct GNUNET_DISK_FileHandle *server_stdout_handle; + struct GNUNET_PeerIdentity sender; /** - * stdin pipe handle for the gnunet-helper-transport-wlan process + * Target of the message. */ - struct GNUNET_DISK_PipeHandle *server_stdin; + struct GNUNET_PeerIdentity target; - /** - * stdin file handle for the gnunet-helper-transport-wlan process - */ - const struct GNUNET_DISK_FileHandle *server_stdin_handle; + /* followed by payload, possibly including + multiple messages! */ - /** - * ID of the gnunet-wlan-server std read task - */ - GNUNET_SCHEDULER_TaskIdentifier server_read_task; +}; +GNUNET_NETWORK_STRUCT_END - /** - * ID of the gnunet-wlan-server std read task - */ - GNUNET_SCHEDULER_TaskIdentifier server_write_task; +/** + * Information kept for each message that is yet to be fragmented and + * transmitted. + */ +struct PendingMessage +{ /** - * ID of the delay task for writing + * next entry in the DLL */ - GNUNET_SCHEDULER_TaskIdentifier server_write_delay_task; + struct PendingMessage *next; /** - * The process id of the wlan process + * previous entry in the DLL */ - struct GNUNET_OS_Process *server_proc; + struct PendingMessage *prev; /** - * The interface of the wlan card given to us by the user. + * The pending message */ - char *interface; + struct WlanHeader *msg; /** - * Mode of operation for the helper, 0 = normal, 1 = first loopback, 2 = second loopback + * Continuation function to call once the message + * has been sent. Can be NULL if there is no + * continuation to call. */ - long long unsigned int testmode; + GNUNET_TRANSPORT_TransmitContinuation transmit_cont; /** - * The mac_address of the wlan card given to us by the helper. + * Cls for transmit_cont */ - struct GNUNET_TRANSPORT_WLAN_MacAddress mac_address; + void *transmit_cont_cls; /** - * Sessions currently pending for transmission - * to a peer, if any. + * Timeout task (for this message). */ - struct Sessionqueue *pending_Sessions_head; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; - /** - * Sessions currently pending for transmission - * to a peer (tail), if any. - */ - struct Sessionqueue *pending_Sessions_tail; +}; - /** - * number of pending sessions - */ - unsigned int pendingsessions; - /** - * Messages in the sending queues - */ - int pending_Fragment_Messages; +/** + * Session handle for connections with other peers. + */ +struct Session +{ /** - * messages ready for send, head - */ - struct FragmentMessage_queue *sending_messages_head; - /** - * messages ready for send, tail - */ - struct FragmentMessage_queue *sending_messages_tail; - /** - * time of the next "hello-beacon" + * API requirement (must be first). */ - struct GNUNET_TIME_Absolute beacon_time; + struct SessionHeader header; /** - * queue to send acks for received fragments (head) + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - struct AckSendQueue *ack_send_queue_head; + struct Session *next; /** - * queue to send acks for received fragments (tail) + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - struct AckSendQueue *ack_send_queue_tail; + struct Session *prev; /** - * Tracker for bandwidth limit + * MAC endpoint with the address of this peer. */ - struct GNUNET_BANDWIDTH_Tracker tracker; + struct MacEndpoint *mac; /** - * saves the current state of the helper process + * Head of messages currently pending for transmission to this peer. */ - int helper_is_running; -}; + struct PendingMessage *pending_message_head; -/** - * Struct to store data if file write did not accept the whole packet - */ -struct Finish_send -{ /** - * pointer to the global plugin struct + * Tail of messages currently pending for transmission to this peer. */ - struct Plugin *plugin; + struct PendingMessage *pending_message_tail; /** - * head of the next part to send to the helper + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) */ - char *head_of_next_write; + struct GNUNET_PeerIdentity target; /** - * Start of the message to send, needed for free + * When should this session time out? */ - struct GNUNET_MessageHeader *msgstart; + struct GNUNET_TIME_Absolute timeout; /** - * rest size to send + * Timeout task (for the session). */ - ssize_t size; -}; - -/** - * Queue of sessions, for the general session queue and the pending session queue - */ -//TODO DOXIGEN -struct Sessionqueue -{ - struct Sessionqueue *next; - struct Sessionqueue *prev; - struct Session *content; -#if !HAVE_UNALIGNED_64_ACCESS - void *dummy; /* for alignment, see #1909 */ -#endif -}; - -/** - * Queue of fragmented messages, for the sending queue of the plugin - */ -//TODO DOXIGEN -struct FragmentMessage_queue -{ - struct FragmentMessage_queue *next; - struct FragmentMessage_queue *prev; - struct FragmentMessage *content; -}; - -/** - * Queue for the fragments received - */ -//TODO DOXIGEN -struct Receive_Fragment_Queue -{ - struct Receive_Fragment_Queue *next; - struct Receive_Fragment_Queue *prev; - uint16_t num; - const char *msg; - uint16_t size; - struct Radiotap_rx rxinfo; -}; - -//TODO DOXIGEN -struct MacEndpoint_id_fragment_triple -{ - struct MacEndpoint *endpoint; - uint32_t message_id; - struct FragmentMessage *fm; -}; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; -//TODO DOXIGEN -struct Plugin_Session_pair -{ - struct Plugin *plugin; - struct Session *session; }; -GNUNET_NETWORK_STRUCT_BEGIN - /** - * Header for messages which need fragmentation + * Struct for messages that are being fragmented in a MAC's transmission queue. */ -struct WlanHeader +struct FragmentMessage { - struct GNUNET_MessageHeader header; - /** - * checksum/error correction + * This is a doubly-linked list. */ - uint32_t crc GNUNET_PACKED; + struct FragmentMessage *next; /** - * To whom are we talking to (set to our identity - * if we are still waiting for the welcome message) + * This is a doubly-linked list. */ - struct GNUNET_PeerIdentity target; + struct FragmentMessage *prev; /** - * Where the packet came from + * MAC endpoint this message belongs to */ - struct GNUNET_PeerIdentity source; - -// followed by payload - -}; -GNUNET_NETWORK_STRUCT_END + struct MacEndpoint *macendpoint; -/** - * Information kept for each message that is yet to - * be transmitted. - */ -struct PendingMessage -{ /** - * dll next + * Fragmentation context */ - struct PendingMessage *next; + struct GNUNET_FRAGMENT_Context *fragcontext; + /** - * dll prev + * Transmission handle to helper (to cancel if the frag context + * is destroyed early for some reason). */ - struct PendingMessage *prev; + struct GNUNET_HELPER_SendHandle *sh; /** - * The pending message + * Intended recipient. */ - struct WlanHeader *msg; + struct GNUNET_PeerIdentity target; /** - * Size of the message + * Timeout value for the message. */ - size_t message_size; + struct GNUNET_TIME_Absolute timeout; /** - * Continuation function to call once the message - * has been sent. Can be NULL if there is no - * continuation to call. + * Timeout task. */ - GNUNET_TRANSPORT_TransmitContinuation transmit_cont; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** - * Cls for transmit_cont + * Continuation to call when we're done with this message. */ - void *transmit_cont_cls; + GNUNET_TRANSPORT_TransmitContinuation cont; /** - * Timeout value for the pending message. + * Closure for 'cont' */ - struct GNUNET_TIME_Absolute timeout; + void *cont_cls; }; + /** - * Queue for acks to send for fragments recived + * Struct to represent one network card connection */ -struct AckSendQueue +struct MacEndpoint { /** - * next ack in the ack send queue + * We keep all MACs in a DLL in the plugin. */ - struct AckSendQueue *next; - /** - * previous ack in the ack send queue - */ - struct AckSendQueue *prev; - /** - * pointer to the session this ack belongs to - */ - struct MacEndpoint *endpoint; - /** - * ID of message, to distinguish between the messages, picked randomly. - */ - uint32_t message_id; + struct MacEndpoint *next; /** - * msg to send + * We keep all MACs in a DLL in the plugin. */ - struct GNUNET_MessageHeader *hdr; - /** - * pointer to the ieee wlan header - */ - struct ieee80211_frame *ieeewlanheader; + struct MacEndpoint *prev; + /** - * pointer to the radiotap header + * Pointer to the global plugin struct. */ - struct Radiotap_Send *radioHeader; -}; + struct Plugin *plugin; -/** - * Session infos gathered from a messages - */ -struct Session_light -{ /** - * the session this message belongs to + * Head of sessions that use this MAC. */ - struct Session *session; + struct Session *sessions_head; + /** - * peer mac address + * Tail of sessions that use this MAC. */ - struct GNUNET_TRANSPORT_WLAN_MacAddress addr; + struct Session *sessions_tail; /** - * mac endpoint + * Head of messages we are currently sending to this MAC. */ - struct MacEndpoint *macendpoint; -}; - -/** - * Session handle for connections. - */ -struct Session -{ + struct FragmentMessage *sending_messages_head; /** - * API requirement. + * Tail of messages we are currently sending to this MAC. */ - struct SessionHeader header; + struct FragmentMessage *sending_messages_tail; /** - * Message currently pending for transmission - * to this peer, if any. head + * Defrag context for this MAC */ - struct PendingMessage *pending_message_head; + struct GNUNET_DEFRAGMENT_Context *defrag; /** - * Message currently pending for transmission - * to this peer, if any. tail + * When should this endpoint time out? */ - struct PendingMessage *pending_message_tail; + struct GNUNET_TIME_Absolute timeout; /** - * To whom are we talking to (set to our identity - * if we are still waiting for the welcome message) + * Timeout task. */ - struct GNUNET_PeerIdentity target; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** - * Address of the other peer (either based on our 'connect' - * call or on our 'accept' call). + * count of messages in the fragment out queue for this mac endpoint */ - void *connect_addr; + unsigned int fragment_messages_out_count; /** - * Last activity on this connection. Used to select preferred - * connection and timeout + * peer mac address */ - struct GNUNET_TIME_Absolute last_activity; + struct GNUNET_TRANSPORT_WLAN_MacAddress addr; /** - * Timeout task. + * Desired transmission power for this MAC */ - GNUNET_SCHEDULER_TaskIdentifier timeout_task; + uint16_t tx_power; /** - * peer connection + * Desired transmission rate for this MAC */ - struct MacEndpoint *mac; + uint8_t rate; /** - * count of messages in the fragment out queue for this session + * Antenna we should use for this MAC */ - - int fragment_messages_out_count; + uint8_t antenna; }; + /** - * Struct to represent one network card connection + * Encapsulation of all of the state of the plugin. */ -struct MacEndpoint +struct Plugin { /** - * Pointer to the global plugin struct. - */ - struct Plugin *plugin; - /** - * Struct to hold the session reachable over this mac; head - */ - struct Sessionqueue *sessions_head; - /** - * Struct to hold the session reachable over this mac; tail - */ - struct Sessionqueue *sessions_tail; - /** - * Messages currently sending - * to a peer, if any. + * Our environment. */ - struct FragmentMessage *sending_messages_head; + struct GNUNET_TRANSPORT_PluginEnvironment *env; /** - * Messages currently sending - * to a peer (tail), if any. - */ - struct FragmentMessage *sending_messages_tail; - /** - * dll next - */ - struct MacEndpoint *next; - /** - * dll prev - */ - struct MacEndpoint *prev; + * Handle to helper process for priviledged operations. + */ + struct GNUNET_HELPER_Handle *suid_helper; /** - * peer mac address + * ARGV-vector for the helper (all helpers take only the binary + * name, one actual argument, plus the NULL terminator for 'argv'). */ - struct GNUNET_TRANSPORT_WLAN_MacAddress addr; + char * helper_argv[3]; /** - * Defrag context for this mac endpoint + * The interface of the wlan card given to us by the user. */ - struct GNUNET_DEFRAGMENT_Context *defrag; + char *interface; /** - * count of messages in the fragment out queue for this mac endpoint + * Tokenizer for demultiplexing of data packets resulting from defragmentation. */ - - int fragment_messages_out_count; - - //TODO DOXIGEN - uint8_t rate; - uint16_t tx_power; - uint8_t antenna; + struct GNUNET_SERVER_MessageStreamTokenizer *fragment_data_tokenizer; /** - * Duplicates received + * Tokenizer for demultiplexing of data packets received from the suid helper */ - int dups; + struct GNUNET_SERVER_MessageStreamTokenizer *helper_payload_tokenizer; /** - * Fragments received + * Tokenizer for demultiplexing of data packets that follow the WLAN Header */ - int fragc; + struct GNUNET_SERVER_MessageStreamTokenizer *wlan_header_payload_tokenizer; /** - * Acks received + * Head of list of open connections. */ - int acks; + struct MacEndpoint *mac_head; /** - * Last activity on this endpoint. Used to select preferred - * connection. + * Tail of list of open connections. */ - struct GNUNET_TIME_Absolute last_activity; + struct MacEndpoint *mac_tail; /** - * Timeout task. + * Number of connections */ - GNUNET_SCHEDULER_TaskIdentifier timeout_task; -}; - -/** - * Struct for Messages in the fragment queue - */ -struct FragmentMessage -{ + unsigned int mac_count; /** - * Session this message belongs to + * Task that periodically sends a HELLO beacon via the helper. */ - struct Session *session; + GNUNET_SCHEDULER_TaskIdentifier beacon_task; /** - * This is a doubly-linked list. + * Tracker for bandwidth limit */ - struct FragmentMessage *next; + struct GNUNET_BANDWIDTH_Tracker tracker; /** - * This is a doubly-linked list. + * The mac_address of the wlan card given to us by the helper. */ - struct FragmentMessage *prev; + struct GNUNET_TRANSPORT_WLAN_MacAddress mac_address; /** - * Fragmentation context + * Have we received a control message with our MAC address yet? */ - struct GNUNET_FRAGMENT_Context *fragcontext; + int have_mac; - /** - * Timeout value for the message. - */ - struct GNUNET_TIME_Absolute timeout; - /** - * Timeout task. - */ - GNUNET_SCHEDULER_TaskIdentifier timeout_task; +}; - /** - * Fragment to send - */ - char *frag; +/** + * Information associated with a message. Can contain + * the session or the MAC endpoint associated with the + * message (or both). + */ +struct MacAndSession +{ /** - * size of message + * NULL if the identity of the other peer is not known. */ - size_t size; + struct Session *session; /** - * pointer to the ieee wlan header + * MAC address of the other peer, NULL if not known. */ - struct ieee80211_frame *ieeewlanheader; - /** - * pointer to the radiotap header - */ - struct Radiotap_Send *radioHeader; + struct MacEndpoint *endpoint; }; -static void -do_transmit (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); - -static void -free_session (struct Plugin *plugin, struct Sessionqueue *queue, - int do_free_macendpoint); - -static struct MacEndpoint * -create_macendpoint (struct Plugin *plugin, const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr); - -static void -finish_sending (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); /** - * Generates a nice hexdump of a memory area. + * Print MAC addresses nicely. * - * \param mem pointer to memory to dump - * \param length how many bytes to dump - */ -static void -hexdump (const void *mem, unsigned length) -{ - char line[80]; - char *src = (char *) mem; - - printf ("dumping %u bytes from %p\r\n" - " 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF\r\n", - length, src); - unsigned i; - int j; - - for (i = 0; i < length; i += 16, src += 16) - { - char *t = line; - - t += sprintf (t, "%04x: ", i); - for (j = 0; j < 16; j++) - { - if (i + j < length) - t += sprintf (t, "%02X", src[j] & 0xff); - else - t += sprintf (t, " "); - - t += sprintf (t, (j % 2) ? " " : "-"); - } - - t += sprintf (t, " "); - for (j = 0; j < 16; j++) - { - if (i + j < length) - { - if (isprint ((unsigned char) src[j])) - t += sprintf (t, "%c", src[j]); - else - t += sprintf (t, "."); - } - else - { - t += sprintf (t, " "); - } - } - - t += sprintf (t, "\r\n"); - printf ("%s", line); - } -} - -/** - * Function to find a MacEndpoint with a specific mac addr - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address - * @param create_new GNUNET_YES if a new end point should be created - * @return + * @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 struct MacEndpoint * -get_macendpoint (struct Plugin *plugin, const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr, - int create_new) +static const char * +mac_to_string (const struct GNUNET_TRANSPORT_WLAN_MacAddress * mac) { - struct MacEndpoint *queue = plugin->mac_head; - - while (queue != NULL) - { - //GNUNET_assert (queue->sessions_head != NULL); - if (memcmp (addr, &queue->addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) - return queue; /* session found */ - queue = queue->next; - } - - if (create_new == GNUNET_YES) - { - return create_macendpoint (plugin, addr); - } - else - { - return NULL; - } + static char macstr[20]; + 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; } -/** - * search for a session with the macendpoint and peer id - * - * @param plugin pointer to the plugin struct - * @param endpoint pointer to the mac endpoint of the peer - * @param peer pointer to the peerid - * @return returns the session - */ -static struct Session * -search_session (struct Plugin *plugin, const struct MacEndpoint *endpoint, - const struct GNUNET_PeerIdentity *peer) -{ - GNUNET_assert (endpoint != NULL); - struct Sessionqueue *queue = endpoint->sessions_head; - - while (queue != NULL) - { - GNUNET_assert (queue->content != NULL); - if (memcmp - (peer, &queue->content->target, - sizeof (struct GNUNET_PeerIdentity)) == 0) - return queue->content; /* session found */ - queue = queue->next; - } - return NULL; -} /** - * 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. + * Fill the radiotap header * - * @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 GNUNET_TRANSPORT_WLAN_MacAddress *mac; - - if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_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 for the scheduler if a session times out - * @param cls pointer to the Sessionqueue - * @param tc pointer to the GNUNET_SCHEDULER_TaskContext + * @param endpoint pointer to the endpoint, can be NULL + * @param header pointer to the radiotap header + * @param size total message size */ static void -session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +get_radiotap_header (struct MacEndpoint *endpoint, + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, + uint16_t size) { - struct Sessionqueue *queue = cls; - - GNUNET_assert (queue != NULL); - GNUNET_assert (queue->content != NULL); - queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) + header->header.type = ntohs (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER); + header->header.size = ntohs (size); + if (NULL != endpoint) { - return; - } - if (GNUNET_TIME_absolute_get_remaining - (GNUNET_TIME_absolute_add - (queue->content->last_activity, SESSION_TIMEOUT)).rel_value == 0) - { - - GNUNET_assert (queue->content->mac != NULL); - GNUNET_assert (queue->content->mac->plugin != NULL); - GNUNET_STATISTICS_update (queue->content->mac->plugin->env->stats, - _("# wlan session timeouts"), 1, GNUNET_NO); - free_session (queue->content->mac->plugin, queue, GNUNET_YES); + header->rate = endpoint->rate; + header->tx_power = endpoint->tx_power; + header->antenna = endpoint->antenna; } else { - queue->content->timeout_task = - GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue); + header->rate = 255; + header->tx_power = 0; + header->antenna = 0; } } -/** - * create a new session - * - * @param plugin pointer to the plugin struct - * @param endpoint pointer to the mac endpoint of the peer - * @param peer peer identity to use for this session - * @return returns the session - */ -static struct Session * -create_session (struct Plugin *plugin, struct MacEndpoint *endpoint, - const struct GNUNET_PeerIdentity *peer) -{ - GNUNET_assert (endpoint != NULL); - GNUNET_assert (plugin != NULL); - GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan session created"), 1, - GNUNET_NO); - struct Sessionqueue *queue = - GNUNET_malloc (sizeof (struct Sessionqueue) + sizeof (struct Session)); - - GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head, - endpoint->sessions_tail, queue); - - queue->content = (struct Session *) &queue[1]; - queue->content->mac = endpoint; - queue->content->target = *peer; - queue->content->last_activity = GNUNET_TIME_absolute_get (); - queue->content->timeout_task = - GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "New session %p with endpoint %p: %s\n", queue->content, - endpoint, wlan_plugin_address_to_string (NULL, - endpoint->addr.mac, - 6)); - return queue->content; -} /** - * Get session from address, create if no session exists + * Generate the WLAN hardware header for one packet * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer - * @param peer pointer to the peerid - * @return returns the session - */ -static struct Session * -get_session (struct Plugin *plugin, const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr, - const struct GNUNET_PeerIdentity *peer) -{ - struct MacEndpoint *mac; - - mac = get_macendpoint (plugin, addr, GNUNET_YES); - struct Session *session = search_session (plugin, mac, peer); - - if (session != NULL) - return session; - return create_session (plugin, mac, peer); -} - -/** - * Queue the session to send data - * checks if there is a message pending - * checks if this session is not allready in the queue - * @param plugin pointer to the plugin - * @param session pointer to the session to add + * @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 -queue_session (struct Plugin *plugin, struct Session *session) +get_wlan_header (struct Plugin *plugin, + struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *header, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, + unsigned int size) { - struct Sessionqueue *queue = plugin->pending_Sessions_head; - - if (session->pending_message_head != 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 - 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_tail (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, queue); - plugin->pendingsessions++; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - } + 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? } + /** - * Function to schedule the write task, executed after a delay - * @param cls pointer to the plugin struct - * @param tc GNUNET_SCHEDULER_TaskContext pointer + * 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 -delay_fragment_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +send_ack (void *cls, uint32_t msg_id, + const struct GNUNET_MessageHeader *hdr) { - struct Plugin *plugin = cls; - - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; + 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]; - // GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg - if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) + if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE) { - plugin->server_write_task = - GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdin_handle, - &do_transmit, plugin); + 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); } -/** - * Function to calculate the time of the next periodic "hello-beacon" - * @param plugin pointer to the plugin struct - */ -static void -set_next_beacon_time (struct Plugin *const plugin) -{ - //under 10 known peers: once a second - if (plugin->mac_count < 10) - { - plugin->beacon_time = - GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - HELLO_BEACON_SCALING_FACTOR)); - } - //under 30 known peers: every 10 seconds - else if (plugin->mac_count < 30) - { - plugin->beacon_time = - GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, - 10 * HELLO_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, - HELLO_BEACON_SCALING_FACTOR)); - } -} /** - * Function to set the timer for the next timeout of the fragment queue - * @param plugin the handle to the plugin struct + * Handles the data after all fragments are put together + * + * @param cls macendpoint this messages belongs to + * @param hdr pointer to the data */ static void -set_next_send (struct Plugin *const plugin) +wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr) { - struct GNUNET_TIME_Relative next_send; - - //abort if helper is not running - if (plugin->helper_is_running == GNUNET_NO) - { - return; - } - - //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; - } - - //check if some acks are in the queue - if (plugin->ack_send_queue_head != NULL) - { - next_send = GNUNET_TIME_UNIT_ZERO; - } - - //check if there are some fragments in the queue - else if (plugin->sending_messages_head != NULL) - { - next_send = GNUNET_TIME_UNIT_ZERO; - } - else - { - next_send = GNUNET_TIME_absolute_get_remaining (plugin->beacon_time); - } + struct MacEndpoint *endpoint = cls; + struct Plugin *plugin = endpoint->plugin; + struct MacAndSession mas; - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Next packet is send in: %u\n", next_send.rel_value); - if (next_send.rel_value == GNUNET_TIME_UNIT_ZERO.rel_value) - { - if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) - { - plugin->server_write_task = - GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdin_handle, - &do_transmit, plugin); - } - } - else - { - if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK) - { - plugin->server_write_delay_task = - GNUNET_SCHEDULER_add_delayed (next_send, &delay_fragment_task, - plugin); - } - } + 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); } -/** - * Function to get the next queued Session, removes the session from the queue - * @param plugin pointer to the plugin struct - * @return pointer to the session found, returns NULL if there is now session in the queue - */ -static struct Session * -get_next_queue_session (struct Plugin *plugin) -{ - struct Session *session; - struct Sessionqueue *sessionqueue; - struct Sessionqueue *sessionqueue_alt; - struct PendingMessage *pm; - - sessionqueue = plugin->pending_Sessions_head; - - while (sessionqueue != NULL) - { - session = sessionqueue->content; - - GNUNET_assert (session != NULL); - pm = session->pending_message_head; - - if (pm == NULL) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "pending message is empty, should not happen. session %p\n", - session); - sessionqueue_alt = sessionqueue; - sessionqueue = sessionqueue->next; - plugin->pendingsessions--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, - sessionqueue_alt); - - GNUNET_free (sessionqueue_alt); - continue; - - } - - //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->mac->fragment_messages_out_count < - FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT) && - (session->fragment_messages_out_count < - FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION)) - { - plugin->pendingsessions--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, - sessionqueue); - GNUNET_free (sessionqueue); - - return session; - } - else - { - sessionqueue = sessionqueue->next; - } - } - else - { - GNUNET_CONTAINER_DLL_remove (session->pending_message_head, - session->pending_message_tail, pm); - - //call the cont func that it did not work - if (pm->transmit_cont != NULL) - pm->transmit_cont (pm->transmit_cont_cls, &(session->target), - GNUNET_SYSERR); - GNUNET_free (pm->msg); - GNUNET_free (pm); - - if (session->pending_message_head == NULL) - { - sessionqueue_alt = sessionqueue; - sessionqueue = sessionqueue->next; - plugin->pendingsessions--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, - sessionqueue_alt); - - GNUNET_free (sessionqueue_alt); - } - } - - } - return NULL; -} /** - * frees the space of a message in the fragment queue (send queue) - * @param plugin the plugin struct - * @param fm message to free + * Free a session + * + * @param session the session free */ static void -free_fragment_message (struct Plugin *plugin, struct FragmentMessage *fm) +free_session (struct Session *session) { - struct Session *session = fm->session; struct MacEndpoint *endpoint = session->mac; - struct FragmentMessage_queue *fmq; - struct FragmentMessage_queue *fmq_next; - - fmq = plugin->sending_messages_head; - while (fmq != NULL) - { - fmq_next = fmq->next; - if (fmq->content == fm) + 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_CONTAINER_DLL_remove (plugin->sending_messages_head, - plugin->sending_messages_tail, fmq); - GNUNET_free (fmq); + GNUNET_SCHEDULER_cancel (pm->timeout_task); + pm->timeout_task = GNUNET_SCHEDULER_NO_TASK; } - fmq = fmq_next; - } - - (session->mac->fragment_messages_out_count)--; - session->fragment_messages_out_count--; - plugin->pending_Fragment_Messages--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending fragments"), - plugin->pending_Fragment_Messages, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (endpoint->sending_messages_head, - endpoint->sending_messages_tail, fm); - 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); - - queue_session (plugin, session); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Free pending fragment messages %p, session %p\n", fm, - session); -} - -/** - * function to fill the radiotap header - * @param plugin pointer to the plugin struct - * @param endpoint pointer to the endpoint - * @param header pointer to the radiotap header - * @return GNUNET_YES at success - */ -static int -getRadiotapHeader (struct Plugin *plugin, struct MacEndpoint *endpoint, - struct Radiotap_Send *header) -{ - - if (endpoint != NULL) - { - header->rate = endpoint->rate; - header->tx_power = endpoint->tx_power; - header->antenna = endpoint->antenna; + GNUNET_free (pm->msg); + GNUNET_free (pm); } - else + GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, + endpoint->sessions_tail, + session); + if (session->timeout_task != GNUNET_SCHEDULER_NO_TASK) { - header->rate = 255; - header->tx_power = 0; - header->antenna = 0; + GNUNET_SCHEDULER_cancel (session->timeout_task); + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; } - - 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 - * @param size size of the whole packet, needed to calculate the time to send the packet - * @return GNUNET_YES if there was no error - */ -static int -getWlanHeader (struct ieee80211_frame *Header, - const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, struct Plugin *plugin, - unsigned int size) -{ - uint16_t *tmp16; - const int rate = 11000000; - - Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA; - Header->i_fc[1] = 0x00; - memcpy (&Header->i_addr3, &mac_bssid_gnunet, sizeof (mac_bssid_gnunet)); - memcpy (&Header->i_addr2, plugin->mac_address.mac, - sizeof (plugin->mac_address)); - memcpy (&Header->i_addr1, to_mac_addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); - - tmp16 = (uint16_t *) Header->i_dur; - *tmp16 = (uint16_t) GNUNET_htole16 ((size * 1000000) / rate + 290); - Header->llc[0] = WLAN_LLC_DSAP_FIELD; - Header->llc[1] = WLAN_LLC_SSAP_FIELD; - - return GNUNET_YES; -} - - -/** - * function to add a fragment of a message to send - * @param cls FragmentMessage this message belongs to - * @param hdr pointer to the start of the message - */ -static void -add_message_for_send (void *cls, const struct GNUNET_MessageHeader *hdr) -{ - - struct FragmentMessage *fm = cls; - struct FragmentMessage_queue *fmqueue; - - GNUNET_assert (cls != NULL); - GNUNET_assert (fm->frag == NULL); - struct MacEndpoint *endpoint = fm->session->mac; - struct Plugin *plugin = endpoint->plugin; - struct GNUNET_MessageHeader *msgheader; - struct GNUNET_MessageHeader *msgheader2; - uint16_t size; - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Adding fragment of message %p to send, session %p, endpoint %p, type %u\n", - fm, fm->session, endpoint, hdr->type); - size = - sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + - sizeof (struct ieee80211_frame) + ntohs (hdr->size); - fm->frag = GNUNET_malloc (size); - fm->size = size; - - msgheader = (struct GNUNET_MessageHeader *) fm->frag; - msgheader->size = htons (size); - msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); - - fm->radioHeader = (struct Radiotap_Send *) &msgheader[1]; - fm->ieeewlanheader = (struct ieee80211_frame *) &fm->radioHeader[1]; - msgheader2 = (struct GNUNET_MessageHeader *) &fm->ieeewlanheader[1]; - memcpy (msgheader2, hdr, ntohs (hdr->size)); - - fmqueue = GNUNET_malloc (sizeof (struct FragmentMessage_queue)); - fmqueue->content = fm; - - GNUNET_CONTAINER_DLL_insert_tail (plugin->sending_messages_head, - plugin->sending_messages_tail, fmqueue); - set_next_send (plugin); + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), -1, + GNUNET_NO); + GNUNET_free (session); } /** - * We have been notified that gnunet-helper-transport-wlan has written something to stdout. - * Handle the output, then reschedule this function to be called again once - * more is available. + * A session is timing out. Clean up. * - * @param cls the plugin handle - * @param tc the scheduling context + * @param cls pointer to the Session + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ static void -wlan_plugin_helper_read (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct Plugin *plugin = cls; - - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; + struct Session * session = cls; + struct GNUNET_TIME_Relative timeout; - if (0 != (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) + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (session->timeout); + if (0 == timeout.rel_value) { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - _ - ("Finished reading from gnunet-helper-transport-wlan stdout with code: %d\n"), - bytes); + free_session (session); return; } - GNUNET_SERVER_mst_receive (plugin->suid_tokenizer, NULL, mybuf, bytes, - GNUNET_NO, GNUNET_NO); - - 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); + session->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &session_timeout, session); } + /** - * Start the gnunet-helper-transport-wlan process. + * Create a new session * - * @param plugin the transport plugin - * @return GNUNET_YES if process was started, GNUNET_SYSERR on error + * @param endpoint pointer to the mac endpoint of the peer + * @param peer peer identity to use for this session + * @return returns the session */ -static int -wlan_transport_start_wlan_helper (struct Plugin *plugin) +static struct Session * +create_session (struct MacEndpoint *endpoint, + const struct GNUNET_PeerIdentity *peer) { - const char *filenamehw = "gnunet-helper-transport-wlan"; - const char *filenameloopback = "gnunet-helper-transport-wlan-dummy"; - char *absolute_filename = NULL; - - if (plugin->helper_is_running == GNUNET_YES) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan_transport_start_wlan_helper not needed, helper already running!"); - return GNUNET_YES; - } - - plugin->server_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); - if (plugin->server_stdout == NULL) - return GNUNET_SYSERR; - - plugin->server_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO); - if (plugin->server_stdin == NULL) - return GNUNET_SYSERR; - - if ((plugin->testmode == 1) || (plugin->testmode == 2)) - { - if (GNUNET_OS_check_helper_binary (filenameloopback) == GNUNET_YES) - { - absolute_filename = GNUNET_strdup (filenameloopback); - } - else - { - char cwd[FILENAME_MAX]; - - GNUNET_assert (getcwd (cwd, sizeof (cwd)) != NULL); - - GNUNET_asprintf (&absolute_filename, "%s%s%s", cwd, DIR_SEPARATOR_STR, - filenameloopback); - - if (GNUNET_DISK_file_test (filenameloopback) != GNUNET_YES) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "Helper `%s' not found! %i\n", absolute_filename); - GNUNET_break (0); - } - } - } - - /* Start the server process */ - - if (plugin->testmode == 0) - { - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Starting gnunet-helper-transport-wlan process cmd: %s %s %i\n", - filenamehw, plugin->interface, plugin->testmode); - if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_YES) - { - plugin->server_proc = - GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, - filenamehw, filenamehw, plugin->interface, - NULL); - } - else if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_NO) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "gnunet-helper-transport-wlan is not suid, please change it or look at the doku\n"); - GNUNET_break (0); - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "gnunet-helper-transport-wlan not found, please look if it exists and is the $PATH variable!\n"); - GNUNET_break (0); - } - - } - else if (plugin->testmode == 1) - { + struct Session *session; - GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, - "Starting gnunet-helper-transport-wlan-dummy loopback 1 process cmd: %s %s %i\n", - absolute_filename, plugin->interface, plugin->testmode); - plugin->server_proc = - GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, - absolute_filename, absolute_filename, "1", - NULL); - if (plugin->server_proc == NULL) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "`%s' not found, please look if it exists and is in the $PATH variable!\n", - absolute_filename); - GNUNET_break (0); - } - } - else if (plugin->testmode == 2) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, - "Starting gnunet-helper-transport-wlan-dummy loopback 2 process cmd: %s %s %i\n", - absolute_filename, plugin->interface, plugin->testmode); - plugin->server_proc = - GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, - absolute_filename, absolute_filename, "2", - NULL); - if (plugin->server_proc == NULL) + for (session = endpoint->sessions_head; NULL != session; session = session->next) + if (0 == memcmp (peer, &session->target, + sizeof (struct GNUNET_PeerIdentity))) { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "`%s' not found, please look if it exists and is in the $PATH variable!\n", - absolute_filename); - GNUNET_break (0); + session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + return session; } - } - if (absolute_filename != NULL) - GNUNET_free (absolute_filename); - if (plugin->server_proc == NULL) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Failed to start gnunet-helper-transport-wlan process\n"); - 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); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Adding server_read_task for the gnunet-helper-transport-wlan\n"); - plugin->server_read_task = - GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdout_handle, - &wlan_plugin_helper_read, plugin); - - plugin->helper_is_running = GNUNET_YES; - return GNUNET_YES; + 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; } -/** - * Stops the gnunet-helper-transport-wlan process. - * - * @param plugin the transport plugin - * @return GNUNET_YES if process was started, GNUNET_SYSERR on error - */ -static int -wlan_transport_stop_wlan_helper (struct Plugin *plugin) -{ - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Stoping WLAN helper process\n"); - - if (plugin->helper_is_running == GNUNET_NO) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan_transport_stop_wlan_helper not needed, helper already stopped!"); - return GNUNET_YES; - } - - if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task); - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - } - - if (plugin->server_write_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (plugin->server_write_task); - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - } - - if (plugin->server_read_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (plugin->server_read_task); - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - } - - GNUNET_DISK_pipe_close (plugin->server_stdout); - GNUNET_DISK_pipe_close (plugin->server_stdin); - GNUNET_OS_process_kill (plugin->server_proc, SIGKILL); - GNUNET_OS_process_wait (plugin->server_proc); - GNUNET_OS_process_close (plugin->server_proc); - - plugin->helper_is_running = GNUNET_NO; - - return GNUNET_YES; -} /** - * function for delayed restart of the helper process - * @param cls Finish_send struct if message should be finished - * @param tc TaskContext + * 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_restart_helper (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +fragment_transmission_done (void *cls, + int result) { - struct Finish_send *finish = cls; - struct Plugin *plugin; - - plugin = finish->plugin; - - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) - { - GNUNET_free_non_null (finish->msgstart); - GNUNET_free (finish); - return; - } - - wlan_transport_start_wlan_helper (plugin); - - if (finish->size != 0) - { - plugin->server_write_task = - GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdin_handle, - &finish_sending, finish); - } - else - { - set_next_send (plugin); - GNUNET_free_non_null (finish->msgstart); - GNUNET_free (finish); - } + struct FragmentMessage *fm = cls; + fm->sh = NULL; + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); } -/** - * Function to restart the helper - * @param plugin pointer to the global plugin struct - * @param finish pointer to the Finish_send struct to finish - */ -static void -restart_helper (struct Plugin *plugin, struct Finish_send *finish) -{ - static struct GNUNET_TIME_Relative next_try = { 1000 }; - GNUNET_assert (finish != NULL); - - wlan_transport_stop_wlan_helper (plugin); - plugin->server_write_task = - GNUNET_SCHEDULER_add_delayed (next_try, &delay_restart_helper, finish); - GNUNET_TIME_relative_multiply (next_try, HELPER_RESTART_SCALING_FACTOR); - -} /** - * function to finish a sending if not all could have been writen befor - * @param cls pointer to the Finish_send struct - * @param tc TaskContext + * 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 -finish_sending (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +transmit_fragment (void *cls, + const struct GNUNET_MessageHeader *hdr) { - struct Finish_send *finish = cls; - struct Plugin *plugin; - ssize_t bytes; - - plugin = finish->plugin; - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - - if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) - { - GNUNET_free (finish->msgstart); - GNUNET_free (finish); - return; - } - bytes = - GNUNET_DISK_file_write (plugin->server_stdin_handle, - finish->head_of_next_write, finish->size); - - if (bytes != finish->size) - { - if (bytes != GNUNET_SYSERR) - { - finish->head_of_next_write += bytes; - finish->size -= bytes; - plugin->server_write_task = - GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdin_handle, - &finish_sending, finish); - } + 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 - { - restart_helper (plugin, finish); - } - } - else - { - GNUNET_free (finish->msgstart); - GNUNET_free (finish); - set_next_send (plugin); + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); } } + /** - * function to send a hello beacon - * @param plugin pointer to the plugin struct + * Frees the space of a message in the fragment queue (send queue) + * + * @param fm message to free */ static void -send_hello_beacon (struct Plugin *plugin) +free_fragment_message (struct FragmentMessage *fm) { - uint16_t size; - ssize_t bytes; - uint16_t hello_size; - struct GNUNET_MessageHeader *msgheader; - struct ieee80211_frame *ieeewlanheader; - struct Radiotap_Send *radioHeader; - struct GNUNET_MessageHeader *msgheader2; - const struct GNUNET_MessageHeader *hello; - struct Finish_send *finish; - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Sending hello beacon\n"); - - GNUNET_assert (plugin != NULL); + struct MacEndpoint *endpoint = fm->macendpoint; - GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan hello beacons send"), - 1, GNUNET_NO); - - 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_MessageHeader) + sizeof (struct Radiotap_Send) + - sizeof (struct ieee80211_frame) + hello_size; - - 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, size); - - msgheader2 = (struct GNUNET_MessageHeader *) &ieeewlanheader[1]; - /*msgheader2->size = - * htons (GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello) + - * sizeof (struct GNUNET_MessageHeader)); - * - * msgheader2->type = htons (GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT); */ - memcpy (msgheader2, hello, hello_size); - - bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, msgheader, size); - - if (bytes == GNUNET_SYSERR) + 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_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _ - ("Error writing to wlan helper. errno == %d, ERROR: %s\n"), - errno, strerror (errno)); - finish = GNUNET_malloc (sizeof (struct Finish_send)); - finish->plugin = plugin; - finish->head_of_next_write = NULL; - finish->size = 0; - finish->msgstart = NULL; - restart_helper (plugin, finish); - - set_next_beacon_time (plugin); - + GNUNET_HELPER_send_cancel (fm->sh); + fm->sh = NULL; } - else + GNUNET_FRAGMENT_context_destroy (fm->fragcontext); + if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK) { - GNUNET_assert (bytes == size); - set_next_beacon_time (plugin); - set_next_send (plugin); + GNUNET_SCHEDULER_cancel (fm->timeout_task); + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; } - GNUNET_free (msgheader); - - + GNUNET_free (fm); } -/** - * function to add an ack to send it for a received fragment - * @param cls MacEndpoint this ack belongs to - * @param msg_id id of the message - * @param hdr pointer to the hdr where the ack is stored - * - */ -static void -add_ack_for_send (void *cls, uint32_t msg_id, - const struct GNUNET_MessageHeader *hdr) -{ - - struct AckSendQueue *ack; - - GNUNET_assert (cls != NULL); - struct MacEndpoint *endpoint = cls; - struct Plugin *plugin = endpoint->plugin; - struct GNUNET_MessageHeader *msgheader; - struct GNUNET_MessageHeader *msgheader2; - uint16_t size; - - size = - sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + - sizeof (struct ieee80211_frame) + ntohs (hdr->size) + - sizeof (struct AckSendQueue); - - ack = GNUNET_malloc (size); - ack->message_id = msg_id; - ack->endpoint = endpoint; - - size = - sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + - sizeof (struct ieee80211_frame) + ntohs (hdr->size); - - msgheader = (struct GNUNET_MessageHeader *) &ack[1]; - ack->hdr = (struct GNUNET_MessageHeader *) &ack[1]; - msgheader->size = htons (size); - msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); - - ack->radioHeader = (struct Radiotap_Send *) &msgheader[1]; - ack->ieeewlanheader = (struct ieee80211_frame *) &(ack->radioHeader)[1]; - msgheader2 = (struct GNUNET_MessageHeader *) &(ack->ieeewlanheader)[1]; - memcpy (msgheader2, hdr, ntohs (hdr->size)); - - GNUNET_CONTAINER_DLL_insert_tail (plugin->ack_send_queue_head, - plugin->ack_send_queue_tail, ack); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Adding ack with message id %u to send, AckSendQueue %p, endpoint %p\n", - msg_id, ack, endpoint); - set_next_send (plugin); -} /** - * Function for the scheduler if a FragmentMessage times out - * @param cls pointer to the FragmentMessage + * A FragmentMessage has timed out. Remove it. + * + * @param cls pointer to the 'struct FragmentMessage' * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ static void @@ -1849,284 +795,162 @@ fragmentmessage_timeout (void *cls, { struct FragmentMessage *fm = cls; - GNUNET_assert (fm != NULL); fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) + if (NULL != fm->cont) { - return; + fm->cont (fm->cont_cls, &fm->target, GNUNET_SYSERR); + fm->cont = NULL; } - free_fragment_message (fm->session->mac->plugin, fm); + free_fragment_message (fm); } + /** - * Function to check if there is some space in the fragment queue - * inserts a message if space is available - * @param plugin the plugin struct + * Transmit a message to the given destination with fragmentation. + * + * @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...); can be NULL + * @param cont_cls closure for cont */ - static void -check_fragment_queue (struct Plugin *plugin) +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) + { - 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_head; - GNUNET_assert (pm != NULL); - GNUNET_CONTAINER_DLL_remove (session->pending_message_head, - session->pending_message_tail, pm); - session->mac->fragment_messages_out_count++; - session->fragment_messages_out_count++; - plugin->pending_Fragment_Messages++; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending fragments"), - plugin->pending_Fragment_Messages, GNUNET_NO); - - fm = GNUNET_malloc (sizeof (struct FragmentMessage)); - fm->session = session; - fm->timeout.abs_value = pm->timeout.abs_value; - fm->frag = NULL; - fm->fragcontext = - GNUNET_FRAGMENT_context_create (plugin->env->stats, WLAN_MTU, - &plugin->tracker, - GNUNET_TIME_UNIT_SECONDS, - &(pm->msg->header), - &add_message_for_send, fm); - fm->timeout_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining - (fm->timeout), fragmentmessage_timeout, - fm); - GNUNET_CONTAINER_DLL_insert_tail (session->mac->sending_messages_head, - session->mac->sending_messages_tail, - fm); - - if (pm->transmit_cont != NULL) - { - pid = session->target; - pm->transmit_cont (pm->transmit_cont_cls, &pid, GNUNET_OK); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "called pm->transmit_cont for %p\n", session); - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "no pm->transmit_cont for %p\n", session); - } - GNUNET_free (pm); - - if (session->pending_message_head != NULL) - { - //requeue session - queue_session (plugin, session); - } - - } - } + struct Plugin *plugin; - //check if timeout changed - set_next_send (plugin); + 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 send an ack, does not free the ack - * @param plugin pointer to the plugin + * Free a MAC endpoint. + * + * @param endpoint pointer to the MacEndpoint to free */ static void -send_ack (struct Plugin *plugin) +free_macendpoint (struct MacEndpoint *endpoint) { + struct Plugin *plugin = endpoint->plugin; + struct FragmentMessage *fm; + struct Session *session; - ssize_t bytes; - struct AckSendQueue *ack; - struct Finish_send *finish; - - ack = plugin->ack_send_queue_head; - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Sending ack for message_id %u for mac endpoint %p, size %u\n", - ack->message_id, ack->endpoint, - ntohs (ack->hdr->size) - sizeof (struct Radiotap_Send)); - GNUNET_assert (plugin != NULL); - GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks send"), 1, - GNUNET_NO); - - getRadiotapHeader (plugin, ack->endpoint, ack->radioHeader); - getWlanHeader (ack->ieeewlanheader, &ack->endpoint->addr, plugin, - ntohs (ack->hdr->size)); + 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); - bytes = - GNUNET_DISK_file_write (plugin->server_stdin_handle, ack->hdr, - ntohs (ack->hdr->size)); - if (bytes == GNUNET_SYSERR) + if (NULL != endpoint->defrag) { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _ - ("Error writing to wlan helper. errno == %d, ERROR: %s\n"), - errno, strerror (errno)); - finish = GNUNET_malloc (sizeof (struct Finish_send)); - finish->plugin = plugin; - finish->head_of_next_write = NULL; - finish->size = 0; - finish->msgstart = NULL; - restart_helper (plugin, finish); + GNUNET_DEFRAGMENT_context_destroy(endpoint->defrag); + endpoint->defrag = NULL; } - else + + plugin->mac_count--; + if (GNUNET_SCHEDULER_NO_TASK != endpoint->timeout_task) { - GNUNET_assert (bytes == ntohs (ack->hdr->size)); - GNUNET_CONTAINER_DLL_remove (plugin->ack_send_queue_head, - plugin->ack_send_queue_tail, ack); - GNUNET_free (ack); - set_next_send (plugin); + GNUNET_SCHEDULER_cancel (endpoint->timeout_task); + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; } + GNUNET_free (endpoint); } + /** - * Function called when wlan helper is ready to get some data + * A MAC endpoint is timing out. Clean up. * - * @param cls closure - * @param tc GNUNET_SCHEDULER_TaskContext + * @param cls pointer to the MacEndpoint + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ static void -do_transmit (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +macendpoint_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct Plugin *plugin = cls; - - GNUNET_assert (plugin != NULL); - - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; - - struct Session *session; - struct FragmentMessage *fm; - struct Finish_send *finish; - struct FragmentMessage_queue *fmq; - ssize_t bytes; - - if (plugin->ack_send_queue_head != NULL) - { - send_ack (plugin); - return; - } + struct MacEndpoint *endpoint = cls; + struct GNUNET_TIME_Relative timeout; - //test if a "hello-beacon" has to be send - if (GNUNET_TIME_absolute_get_remaining (plugin->beacon_time).rel_value == 0) + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout); + if (0 == timeout.rel_value) { - send_hello_beacon (plugin); + free_macendpoint (endpoint); return; } - - if (plugin->sending_messages_head != NULL) - { - GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan fragments send"), 1, - GNUNET_NO); - - fmq = plugin->sending_messages_head; - fm = fmq->content; - GNUNET_CONTAINER_DLL_remove (plugin->sending_messages_head, - plugin->sending_messages_tail, fmq); - GNUNET_free (fmq); - - session = fm->session; - GNUNET_assert (session != NULL); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT for fragment message %p, size: %u\n", - fm, fm->size); - getRadiotapHeader (plugin, session->mac, fm->radioHeader); - getWlanHeader (fm->ieeewlanheader, &(fm->session->mac->addr), plugin, - fm->size); - - bytes = - GNUNET_DISK_file_write (plugin->server_stdin_handle, fm->frag, - fm->size); - - - if (bytes != fm->size) - { - finish = GNUNET_malloc (sizeof (struct Finish_send)); - finish->plugin = plugin; - finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag; - GNUNET_assert (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); - - if (bytes == GNUNET_SYSERR) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _ - ("Error writing to wlan helper. errno == %d, ERROR: %s\n"), - errno, strerror (errno)); - - finish->head_of_next_write = fm->frag; - finish->size = fm->size; - restart_helper (plugin, finish); - } - else - { - finish->head_of_next_write = fm->frag + bytes; - finish->size = fm->size - bytes; - plugin->server_write_task = - GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, - plugin->server_stdin_handle, - &finish_sending, finish); - } - - fm->frag = NULL; - } - else - { - GNUNET_free (fm->frag); - fm->frag = NULL; - set_next_send (plugin); - } - GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); - return; - } - -#if 1 - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "do_transmit did nothing, should not happen!\n"); -#endif - set_next_send (plugin); + endpoint->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &macendpoint_timeout, + endpoint); } + /** - * 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. + * Find (or create) a MacEndpoint with a specific MAC address * - * @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 + * @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 int -wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) +static struct MacEndpoint * +create_macendpoint (struct Plugin *plugin, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr) { - //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 */ - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan_plugin_address_suggested got good address, size %u!\n", - addrlen); - return GNUNET_OK; - } - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan_plugin_address_suggested got bad address, size %u!\n", - addrlen); - return GNUNET_SYSERR; + 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; } @@ -2138,33 +962,55 @@ wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) * @param address the address * @return the session or NULL of max connections exceeded */ - static struct Session * wlan_plugin_get_session (void *cls, - const struct GNUNET_HELLO_Address *address) + const struct GNUNET_HELLO_Address *address) { struct Plugin *plugin = cls; - struct Session * s = NULL; - - GNUNET_assert (plugin != NULL); - GNUNET_assert (address != NULL); + struct MacEndpoint *endpoint; - if (GNUNET_OK == wlan_plugin_address_suggested (plugin, - address->address, - address->address_length)) - { - s = get_session (plugin, address->address, &address->peer); - } - else + if (NULL == address) + return NULL; + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != address->address_length) { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _("Wlan Address len %d is wrong\n"), address->address_length); - return s; + 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 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 Session *session; + struct MacEndpoint *endpoint; - return s; + 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 that can be used by the transport service to transmit * a message using the plugin. Note that in the case of a @@ -2201,925 +1047,586 @@ wlan_plugin_send (void *cls, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { struct Plugin *plugin = cls; - struct PendingMessage *newmsg; struct WlanHeader *wlanheader; - - GNUNET_assert (plugin != NULL); - GNUNET_assert (session != NULL); - GNUNET_assert (msgbuf_size > 0); - - //queue message: - - //queue message in session - //test if there is no other message in the "queue" - //FIXME: to many send requests - if (session->pending_message_head != NULL) - { - newmsg = session->pending_message_head; - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n", - GNUNET_TIME_absolute_get_remaining (newmsg-> - timeout).rel_value, - session->mac->fragment_messages_out_count); - } - - newmsg = GNUNET_malloc (sizeof (struct PendingMessage)); - newmsg->msg = GNUNET_malloc (msgbuf_size + sizeof (struct WlanHeader)); - wlanheader = newmsg->msg; - //copy msg to buffer, not fragmented / segmented yet, but with message header + 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); - memcpy (&(wlanheader->target), &session->target, sizeof (struct GNUNET_PeerIdentity)); - memcpy (&(wlanheader->source), plugin->env->my_identity, - sizeof (struct GNUNET_PeerIdentity)); - wlanheader->crc = 0; + 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); - wlanheader->crc = - htonl (GNUNET_CRYPTO_crc32_n - ((char *) wlanheader, msgbuf_size + sizeof (struct WlanHeader))); - - newmsg->transmit_cont = cont; - newmsg->transmit_cont_cls = cont_cls; - newmsg->timeout = GNUNET_TIME_relative_to_absolute (to); - - newmsg->timeout.abs_value = newmsg->timeout.abs_value - 500; - - newmsg->message_size = msgbuf_size + sizeof (struct WlanHeader); - - GNUNET_CONTAINER_DLL_insert_tail (session->pending_message_head, - session->pending_message_tail, newmsg); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "New message for %p with size (incl wlan header) %u added\n", - session, newmsg->message_size); -#if DEBUG_WLAN > 1 - hexdump (msgbuf, GNUNET_MIN (msgbuf_size, 256)); -#endif - //queue session - queue_session (plugin, session); - - check_fragment_queue (plugin); - //FIXME not the correct size - return msgbuf_size; + send_with_fragmentation (session->mac, + to, + &session->target, + &wlanheader->header, + cont, cont_cls); + return size; } /** - * function to free a mac endpoint - * @param plugin pointer to the plugin struct - * @param endpoint pointer to the MacEndpoint to free - */ -static void -free_macendpoint (struct Plugin *plugin, struct MacEndpoint *endpoint) -{ - struct Sessionqueue *sessions; - struct Sessionqueue *sessions_next; - - GNUNET_assert (endpoint != NULL); - - sessions = endpoint->sessions_head; - while (sessions != NULL) - { - sessions_next = sessions->next; - free_session (plugin, sessions, GNUNET_NO); - sessions = sessions_next; - } - - GNUNET_CONTAINER_DLL_remove (plugin->mac_head, plugin->mac_tail, endpoint); - if (endpoint->timeout_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (endpoint->timeout_task); - endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; - } - plugin->mac_count--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), - plugin->mac_count, GNUNET_NO); - GNUNET_free (endpoint); - -} - -/** - * function to free a session - * @param plugin pointer to the plugin - * @param queue pointer to the sessionqueue element to free - * @param do_free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint - */ -static void -free_session (struct Plugin *plugin, struct Sessionqueue *queue, - int do_free_macendpoint) -{ - struct Sessionqueue *pendingsession; - struct Sessionqueue *pendingsession_tmp; - struct PendingMessage *pm; - struct MacEndpoint *endpoint; - struct FragmentMessage *fm; - struct FragmentMessage *fmnext; - int check = 0; - - GNUNET_assert (plugin != NULL); - GNUNET_assert (queue != NULL); - GNUNET_assert (queue->content != NULL); - - //session found - //is this session pending for send - pendingsession = plugin->pending_Sessions_head; - while (pendingsession != NULL) - { - pendingsession_tmp = pendingsession; - pendingsession = pendingsession->next; - GNUNET_assert (pendingsession_tmp->content != NULL); - if (pendingsession_tmp->content == queue->content) - { - plugin->pendingsessions--; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, - pendingsession_tmp); - GNUNET_free (pendingsession_tmp); - - GNUNET_assert (check == 0); - check = 1; - } - } - - endpoint = queue->content->mac; - fm = endpoint->sending_messages_head; - while (fm != NULL) - { - fmnext = fm->next; - if (fm->session == queue->content) - { - free_fragment_message (plugin, fm); - } - fm = fmnext; - } - - // remove PendingMessage - pm = queue->content->pending_message_head; - while (pm != NULL) - { - GNUNET_CONTAINER_DLL_remove (queue->content->pending_message_head, - queue->content->pending_message_tail, pm); - GNUNET_free (pm->msg); - GNUNET_free (pm); - pm = queue->content->pending_message_head; - } - - GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, endpoint->sessions_tail, - queue); - //Check that no ohter session on this endpoint for this session exits - GNUNET_assert (search_session (plugin, endpoint, &queue->content->target) == - NULL); - if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES) - { - free_macendpoint (plugin, endpoint); - //check if no endpoint with the same address exists - GNUNET_assert (get_macendpoint (plugin, &endpoint->addr, GNUNET_NO) == - NULL); - } - - if (queue->content->timeout_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (queue->content->timeout_task); - queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK; - } - GNUNET_free (queue); - - check_fragment_queue (plugin); -} - -/** - * Function that can be used to force the plugin to disconnect - * from the given peer and cancel all previous transmissions - * (and their continuation). + * We have received data from the WLAN via some session. Process depending + * on the message type (HELLO, DATA, FRAGMENTATION or FRAGMENTATION-ACK). * - * @param cls closure - * @param target peer from which to disconnect + * @param cls pointer to the plugin + * @param client pointer to the session this message belongs to + * @param hdr start of the message */ -static void -wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) +static int +process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr) { struct Plugin *plugin = cls; - struct Sessionqueue *queue; - struct Sessionqueue *queue_next; - struct MacEndpoint *endpoint = plugin->mac_head; - struct MacEndpoint *endpoint_next; + 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; - // just look at all the session for the needed one - while (endpoint != NULL) + 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)) { - queue = endpoint->sessions_head; - endpoint_next = endpoint->next; - while (queue != NULL) + case GNUNET_MESSAGE_TYPE_HELLO: + if (GNUNET_OK != + GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource)) { - // content is never NULL - GNUNET_assert (queue->content != NULL); - queue_next = queue->next; - if (memcmp - (target, &(queue->content->target), - sizeof (struct GNUNET_PeerIdentity)) == 0) - { - free_session (plugin, queue, GNUNET_YES); - } - // try next - queue = queue_next; + GNUNET_break_op (0); + break; } - endpoint = endpoint_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; - const unsigned char *input; + 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_assert(cls !=NULL); - if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) - { - /* invalid address (MAC addresses have 6 bytes) */ - //GNUNET_break (0); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_plugin_address_pretty_printer got size: %u, worng size!\n", - addrlen); - asc (asc_cls, NULL); - return; - } - input = (const unsigned char *) addr; - GNUNET_asprintf (&ret, - "Transport %s: %s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", - type, PROTOCOL_PREFIX, input[0], input[1], input[2], - input[3], input[4], input[5]); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_plugin_address_pretty_printer got size: %u, nummeric %u, type %s; made string: %s\n", - addrlen, numeric, type, ret); - asc (asc_cls, ret); - //only one mac address per plugin - asc (asc_cls, NULL); -} - - - -/** - * handels the data after all fragments are put together - * @param cls macendpoint this messages belongs to - * @param hdr pointer to the data - */ -static void -wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr) -{ - struct MacEndpoint *endpoint = (struct MacEndpoint *) cls; - struct Plugin *plugin = endpoint->plugin; - struct WlanHeader *wlanheader; - struct Session *session; - - const struct GNUNET_MessageHeader *temp_hdr; - struct GNUNET_PeerIdentity tmpsource; - int crc; - - GNUNET_assert (plugin != NULL); - - if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) - { - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_data_message_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n", - ntohs (hdr->size)); - - if (ntohs (hdr->size) < - sizeof (struct WlanHeader) + sizeof (struct GNUNET_MessageHeader)) + 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) { - //packet not big enought - return; + GNUNET_break (0); + break; } - + 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, - _("# wlan whole messages received"), 1, - GNUNET_NO); - wlanheader = (struct WlanHeader *) hdr; - - session = search_session (plugin, endpoint, &wlanheader->source); - - temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1]; - crc = ntohl (wlanheader->crc); - wlanheader->crc = 0; - if (GNUNET_CRYPTO_crc32_n - ((char *) wlanheader, ntohs (wlanheader->header.size)) != crc) + _("# 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) { - //wrong crc, dispose message - GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, - "Wlan message header crc was wrong: %u != %u\n", - GNUNET_CRYPTO_crc32_n ((char *) wlanheader, - ntohs (wlanheader->header.size)), - crc); - hexdump ((void *) hdr, ntohs (hdr->size)); - return; + GNUNET_break (0); + break; } - - //if not in session list - if (session == NULL) + 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) { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "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)); - //try if it is a hello message - if (ntohs (wlanheader->header.size) >= - ntohs (temp_hdr->size) + sizeof (struct WlanHeader)) + ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); + if (GNUNET_OK == ret) { - if (ntohs (temp_hdr->type) == GNUNET_MESSAGE_TYPE_HELLO) - { - if (GNUNET_HELLO_get_id - ((const struct GNUNET_HELLO_Message *) temp_hdr, - &tmpsource) == GNUNET_OK) - { - session = create_session (plugin, endpoint, &tmpsource); - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "WLAN client not in session list and hello message is not okay\n"); - return; - } - - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "WLAN client not in session list and not a hello message\n"); - return; - } + 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; } - else + if (GNUNET_NO == ret) { - GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "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; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got an ACK, message transmission to `%s' not yet finished\n", + mac_to_string (&mas->endpoint->addr)); + break; } } - - //"receive" the message - - if (memcmp - (&wlanheader->source, &session->target, - sizeof (struct GNUNET_PeerIdentity)) != 0) + 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) { - //wrong peer id - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "WLAN peer source id doesn't match packet peer source id: session %p\n", - session); - return; + GNUNET_break (0); + break; } - - if (memcmp - (&wlanheader->target, plugin->env->my_identity, - sizeof (struct GNUNET_PeerIdentity)) != 0) + if (msize < sizeof (struct WlanHeader)) { - //wrong peer id - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "WLAN peer target id doesn't match our peer id: session %p\n", - session); - 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; } - - 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_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "wlan_data_message_handler got wrong message type: %u\n", - ntohs (hdr->size)); - return; + if (ntohl (wlanheader->crc) != + GNUNET_CRYPTO_crc32_n (&wlanheader[1], msize - sizeof (struct WlanHeader))) + { + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN DATA messages discarded due to CRC32 error"), 1, + GNUNET_NO); + break; + } + 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 -/** - * function to process the a message, give it to the higher layer - * @param cls pointer to the plugin - * @param client pointer to the session this message belongs to - * @param hdr start of the message - */ -//TODO ATS informations -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_ATS_Information ats[2]; - - 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); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Calling plugin->env->receive for session %p; %s; size: %u\n", - session, wlan_plugin_address_to_string (NULL, - session->mac-> - addr.mac, 6), - htons (hdr->size)); - plugin->env->receive (plugin->env->cls, &(session->target), hdr, - (const struct GNUNET_ATS_Information *) &ats, 2, - session, (const char *) &session->mac->addr, - sizeof (session->mac->addr)); -} /** - * Function used for to process the data received from the wlan interface + * Function used for to process the data from the suid process * * @param cls the plugin handle - * @param session_light pointer to the struct holding known informations - * @param hdr hdr of the GNUNET_MessageHeader - * @param rxinfo pointer to the radiotap informations got with this packet FIXME: give ATS for info + * @param client client that send the data (not used) + * @param hdr header 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) +static int +handle_helper_message (void *cls, void *client, + const struct GNUNET_MessageHeader *hdr) { struct Plugin *plugin = cls; - struct FragmentMessage *fm; - struct FragmentMessage *fm2; - struct GNUNET_PeerIdentity tmpsource; + const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo; + const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm; + struct MacAndSession mas; + uint16_t msize; - GNUNET_assert (plugin != NULL); - - //ADVERTISEMENT - if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_HELLO) + msize = ntohs (hdr->size); + switch (ntohs (hdr->type)) { - - //TODO better DOS protection, error handling - //TODO test first than create session - GNUNET_assert (session_light != NULL); - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_HELLO size: %u; %s\n", - ntohs (hdr->size), wlan_plugin_address_to_string (NULL, - session_light->addr. - mac, 6)); - if (session_light->macendpoint == NULL) - { - session_light->macendpoint = - get_macendpoint (plugin, &session_light->addr, GNUNET_YES); - } - - - if (GNUNET_HELLO_get_id - ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource) == GNUNET_OK) - { - session_light->session = - search_session (plugin, session_light->macendpoint, &tmpsource); - if (session_light->session == NULL) - { - session_light->session = - create_session (plugin, session_light->macendpoint, &tmpsource); - } - GNUNET_STATISTICS_update (plugin->env->stats, - _("# wlan hello messages received"), 1, - GNUNET_NO); - plugin->env->receive (plugin->env->cls, &session_light->session->target, - hdr, NULL, 0, session_light->session, - (const char *) &session_light->session->mac->addr, - sizeof (session_light->session->mac->addr)); - } - else + case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: + if (msize != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)) { - GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "WLAN client not in session list and hello message is not okay\n"); - return; + GNUNET_break (0); + break; } - } - - //FRAGMENT - - else if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT) - { - - GNUNET_assert (session_light != NULL); - if (session_light->macendpoint == NULL) + cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *) hdr; + if (GNUNET_YES == plugin->have_mac) { - session_light->macendpoint = - get_macendpoint (plugin, &session_light->addr, GNUNET_YES); + 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)); } - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT with size: %u; mac endpoint %p: %s\n", - ntohs (hdr->size), session_light->macendpoint, - wlan_plugin_address_to_string (NULL, - session_light->addr.mac, - 6)); + 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_DATA_FROM_HELPER: + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got data message from helper with %u bytes\n", + msize); GNUNET_STATISTICS_update (plugin->env->stats, - _("# wlan fragments received"), 1, GNUNET_NO); - int ret = - GNUNET_DEFRAGMENT_process_fragment (session_light->macendpoint->defrag, - hdr); - - if (ret == GNUNET_NO) - { - session_light->macendpoint->dups++; - } - else if (ret == GNUNET_OK) + _("# DATA messages received via WLAN"), 1, + GNUNET_NO); + if (msize < sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)) { - session_light->macendpoint->fragc++; + GNUNET_break (0); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Size of packet is too small (%u bytes)\n", + msize); + break; } - set_next_send (plugin); - - } + rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr; - //ACK - - else if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT_ACK) - { - GNUNET_assert (session_light != NULL); - if (session_light->macendpoint == NULL) + /* check if message is actually for us */ + if (0 != memcmp (&rxinfo->frame.addr3, &mac_bssid_gnunet, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) { - session_light->macendpoint = - get_macendpoint (plugin, &session_light->addr, GNUNET_NO); + /* Not the GNUnet BSSID */ + break; } - - if (session_light->macendpoint == NULL) + 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))) ) { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Macendpoint does not exist for this GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; %s\n", - ntohs (hdr->size), wlan_plugin_address_to_string (NULL, - session_light->addr.mac, - 6)); - return; + /* Neither broadcast nor specifically for us */ + break; } - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; mac endpoint: %p; %s\n", - ntohs (hdr->size), session_light->macendpoint, - wlan_plugin_address_to_string (NULL, - session_light->addr.mac, - 6)); - fm = session_light->macendpoint->sending_messages_head; - while (fm != NULL) + if (0 == memcmp (&rxinfo->frame.addr2, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) { - fm2 = fm->next; - GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks received"), - 1, GNUNET_NO); - int ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); - - if (ret == GNUNET_OK) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Got last ack, finished fragment message %p\n", fm); - session_light->macendpoint->acks++; - fm->session->last_activity = GNUNET_TIME_absolute_get (); - session_light->macendpoint->last_activity = fm->session->last_activity; - free_fragment_message (plugin, fm); - check_fragment_queue (plugin); - return; - } - if (ret == GNUNET_NO) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Got ack for: %p\n", fm); - session_light->macendpoint->acks++; - return; - } - if (ret == GNUNET_SYSERR) - { - - } - - fm = fm2; + /* packet is FROM us, thus not FOR us */ + break; } - - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "WLAN fragment not in fragment list\n"); - return; - - } - else - { - // TODO Wrong data? - GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, - "WLAN packet inside the WLAN helper packet has not the right type: %u size: %u\n", - ntohs (hdr->type), ntohs (hdr->size)); + + 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; +} -#if 0 - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Helper finished\n"); -#endif -} /** - * Function to print mac addresses nice * - * @param pointer to 6 byte with the mac address - * @return pointer to the chars which hold the print out + * Task to (periodically) send a HELLO beacon + * + * @param cls pointer to the plugin struct + * @param tc scheduler context */ -static const char * -macprinter (const u_int8_t * mac) +static void +send_hello_beacon (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - static char macstr[20]; + struct Plugin *plugin = cls; + 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_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 for the scheduler if a mac endpoint times out - * @param cls pointer to the MacEndpoint - * @param tc pointer to the GNUNET_SCHEDULER_TaskContext + * 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 void -macendpoint_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +static int +wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) { - struct MacEndpoint *endpoint = cls; + struct Plugin *plugin = cls; - GNUNET_assert (endpoint != NULL); - endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) - { - return; + if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; } - if (GNUNET_TIME_absolute_get_remaining - (GNUNET_TIME_absolute_add - (endpoint->last_activity, MACENDPOINT_TIMEOUT)).rel_value == 0) + if (GNUNET_YES != plugin->have_mac) { - GNUNET_assert (endpoint->plugin != NULL); - GNUNET_STATISTICS_update (endpoint->plugin->env->stats, - _("# wlan mac endpoints timeouts"), 1, GNUNET_NO); - free_macendpoint (endpoint->plugin, endpoint); + 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 */ } - else + if (0 != memcmp (addr, + &plugin->mac_address, + addrlen)) { - endpoint->timeout_task = - GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, - endpoint); + 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; } + /** - * function to create an macendpoint - * @param plugin pointer to the plugin struct - * @param addr pointer to the macaddress - * @return returns a macendpoint + * 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 struct MacEndpoint * -create_macendpoint (struct Plugin *plugin, const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr) +static const char * +wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) { - struct MacEndpoint *newend = GNUNET_malloc (sizeof (struct MacEndpoint)); - - GNUNET_assert (plugin != NULL); - GNUNET_STATISTICS_update (plugin->env->stats, - _("# wlan mac endpoints created"), 1, GNUNET_NO); - newend->addr = *addr; - newend->plugin = plugin; - newend->addr = *addr; - newend->fragment_messages_out_count = 0; - newend->defrag = - GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU, - MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, - newend, &wlan_data_message_handler, - &add_ack_for_send); - newend->last_activity = GNUNET_TIME_absolute_get (); - newend->timeout_task = - GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, - newend); + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; - plugin->mac_count++; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), - plugin->mac_count, GNUNET_NO); - GNUNET_CONTAINER_DLL_insert_tail (plugin->mac_head, plugin->mac_tail, newend); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "New Mac Endpoint %p: %s\n", newend, - wlan_plugin_address_to_string (NULL, newend->addr.mac, 6)); - return newend; + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) + { + GNUNET_break (0); + return NULL; + } + mac = addr; + return GNUNET_strdup (mac_to_string (mac)); } + /** - * Function used for to process the data from the suid process + * Convert the transports address to a nice, human-readable format. * - * @param cls the plugin handle - * @param client client that send the data (not used) - * @param hdr header of the GNUNET_MessageHeader + * @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_process_helper (void *cls, void *client, - const struct GNUNET_MessageHeader *hdr) +wlan_plugin_address_pretty_printer (void *cls, const char *type, + const void *addr, size_t addrlen, + int numeric, + struct GNUNET_TIME_Relative timeout, + GNUNET_TRANSPORT_AddressStringCallback asc, + void *asc_cls) { - 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; + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + char *ret; - GNUNET_assert (plugin != NULL); - switch (ntohs (hdr->type)) + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) { - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA: - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA size: %u\n", - ntohs (hdr->size)); - GNUNET_STATISTICS_update (plugin->env->stats, - _("# wlan WLAN_HELPER_DATA received"), 1, - GNUNET_NO); - //call wlan_process_helper with the message inside, later with wlan: analyze signal - if (ntohs (hdr->size) < - sizeof (struct ieee80211_frame) + - 2 * sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_rx)) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Size of packet is too small; size: %u min size: %u\n", - ntohs (hdr->size), - sizeof (struct ieee80211_frame) + - sizeof (struct GNUNET_MessageHeader)); - //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_gnunet, - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) - { - //check for broadcast or mac - if ((memcmp - (&(wlanIeeeHeader->i_addr1), &bc_all_mac, - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) || - (memcmp - (&(wlanIeeeHeader->i_addr1), &(plugin->mac_address), - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)) - { - //if packet is from us return - if ((memcmp - (&(wlanIeeeHeader->i_addr2), &(plugin->mac_address), - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)) - { - return; - } - // process the inner data - - - datasize = - ntohs (hdr->size) - sizeof (struct ieee80211_frame) - - sizeof (struct GNUNET_MessageHeader) - sizeof (struct Radiotap_rx); - - session_light = GNUNET_malloc (sizeof (struct Session_light)); - memcpy (&session_light->addr, &(wlanIeeeHeader->i_addr2), - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); - //session_light->session = search_session(plugin,session_light->addr); - GNUNET_STATISTICS_update (plugin->env->stats, - _("# wlan messages for this client received"), - 1, GNUNET_NO); - - pos = 0; - while (pos < datasize) - { - temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] + pos; - if (ntohs (temp_hdr->size) <= datasize + pos) - { - GNUNET_STATISTICS_update (plugin->env->stats, - _ - ("# wlan messages inside WLAN_HELPER_DATA received"), - 1, GNUNET_NO); - wlan_data_helper (plugin, session_light, temp_hdr, rxinfo); - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Size of packet is too small; size: %u > size of packet: %u\n", - ntohs (temp_hdr->size), datasize + pos); - } - pos += ntohs (temp_hdr->size); - - } - - //clean up - GNUNET_free (session_light); - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got wrong MAC: %s\n", - macprinter (wlanIeeeHeader->i_addr1)); - } - } - else - { - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got wrong BSSID: %s\n", - macprinter (wlanIeeeHeader->i_addr2)); - } - break; - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: - //TODO more control messages - if (ntohs (hdr->size) != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)) - { - GNUNET_break (0); - /* FIXME: restart SUID process */ - return; - } - memcpy (&plugin->mac_address, &hdr[1], sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Received WLAN_HELPER_CONTROL message with transport of address %s\n", - wlan_plugin_address_to_string (cls, &plugin->mac_address, - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))); - plugin->env->notify_address (plugin->env->cls, GNUNET_YES, - &plugin->mac_address, - sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); - break; - default: - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got unknown message with number %u, size %u\n", - ntohs (hdr->type), ntohs (hdr->size)); - -#if DEBUG_WLAN > 1 - hexdump (hdr, GNUNET_MIN (ntohs (hdr->size), 256)); -#endif - GNUNET_break (0); + /* 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) { struct GNUNET_TRANSPORT_PluginFunctions *api = cls; struct Plugin *plugin = api->cls; - struct MacEndpoint *endpoint = plugin->mac_head; + struct MacEndpoint *endpoint; struct MacEndpoint *endpoint_next; - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "libgnunet_plugin_transport_wlan_done started\n"); - wlan_transport_stop_wlan_helper (plugin); - - GNUNET_assert (cls != NULL); - //free sessions - while (endpoint != NULL) + 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 (plugin, endpoint); - endpoint = 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; } - - - 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); 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. * @@ -3129,35 +1636,107 @@ libgnunet_plugin_transport_wlan_done (void *cls) void * 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; - - 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; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), - plugin->pendingsessions, GNUNET_NO); - plugin->mac_count = 0; - GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), - plugin->mac_count, GNUNET_NO); - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_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->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_head = GNUNET_malloc (sizeof (struct Sessionqueue)); + 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; @@ -3167,35 +1746,9 @@ libgnunet_plugin_transport_wlan_init (void *cls) api->address_pretty_printer = &wlan_plugin_address_pretty_printer; api->check_address = &wlan_plugin_address_suggested; api->address_to_string = &wlan_plugin_address_to_string; - - //read config - - if (GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "TESTMODE")) - { - if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-wlan", - "TESTMODE", &(plugin->testmode))) - plugin->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 - wlan_transport_start_wlan_helper (plugin); - set_next_beacon_time (plugin); - set_next_send (plugin); - GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "wlan init finished\n"); + api->string_to_address = &wlan_string_to_address; return api; } + /* end of plugin_transport_wlan.c */ |