X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fplugin_transport_wlan.c;h=c2565a4a8fb9f198de1c3343266d03008b54525a;hb=56389a7d277b05c9c2968b7ebd529a12f8be15eb;hp=2f32b53c2803ce17a7845e1692eb9cf27f0581c4;hpb=b766cf70853e0732c0785648acd74c6958fea5a7;p=oweals%2Fgnunet.git diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c index 2f32b53c2..c2565a4a8 100644 --- a/src/transport/plugin_transport_wlan.c +++ b/src/transport/plugin_transport_wlan.c @@ -1,29 +1,29 @@ /* - This file is part of GNUnet - (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. - */ + This file is part of GNUnet + (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ /** * @file transport/plugin_transport_wlan.c * @brief transport plugin for wlan * @author David Brodski + * @author Christian Grothoff */ - #include "platform.h" #include "gnunet_hello_lib.h" #include "gnunet_protocols.h" @@ -35,1971 +35,1452 @@ #include "gnunet_common.h" #include "gnunet_crypto_lib.h" #include "gnunet_fragmentation_lib.h" -//#include "wlan/ieee80211.h" -//#include - -#include - -#define PROTOCOL_PREFIX "wlan" - -#define PLUGIN_LOG_NAME "wlan-plugin" +#include "gnunet_constants.h" -/** - * Max size of packet - */ -#define WLAN_MTU 1450 +#define LOG(kind,...) GNUNET_log_from (kind, "transport-wlan",__VA_ARGS__) /** - * time out of a session + * Max size of packet (that we give to the WLAN driver for transmission) */ -#define SESSION_TIMEOUT GNUNET_TIME_UNIT_MINUTES +#define WLAN_MTU 1430 /** * time out of a mac endpoint */ -#define MACENDPOINT_TIMEOUT GNUNET_TIME_UNIT_MINUTES - -/** - * scaling factor for hello beacon - */ -#define HALLO_BEACON_SCALING_FACTOR 900 +#define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 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 + * Link layer control fields for better compatibility + * (i.e. GNUnet over WLAN is not IP-over-WLAN). */ -#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 1 +#define WLAN_LLC_DSAP_FIELD 0x1f +#define WLAN_LLC_SSAP_FIELD 0x1f +GNUNET_NETWORK_STRUCT_BEGIN /** - * DEBUG switch - */ -#define DEBUG_wlan GNUNET_NO -#define DEBUG_wlan_retransmission GNUNET_NO -#define DEBUG_wlan_ip_udp_packets_on_air GNUNET_NO - - -#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ - -#define IEEE80211_FC0_VERSION_MASK 0x03 -#define IEEE80211_FC0_VERSION_SHIFT 0 -#define IEEE80211_FC0_VERSION_0 0x00 -#define IEEE80211_FC0_TYPE_MASK 0x0c -#define IEEE80211_FC0_TYPE_SHIFT 2 -#define IEEE80211_FC0_TYPE_MGT 0x00 -#define IEEE80211_FC0_TYPE_CTL 0x04 -#define IEEE80211_FC0_TYPE_DATA 0x08 - -/* - * Structure of an internet header, naked of options. - */ -struct iph -{ -#if __BYTE_ORDER == __LITTLE_ENDIAN - unsigned int ip_hl :4; /* header length */ - unsigned int ip_v :4; /* version */ -#endif -#if __BYTE_ORDER == __BIG_ENDIAN - unsigned int ip_v:4; /* version */ - unsigned int ip_hl:4; /* header length */ -#endif - u_int8_t ip_tos; /* type of service */ - u_short ip_len; /* total length */ - u_short ip_id; /* identification */ - u_short ip_off; /* fragment offset field */ -#define IP_RF 0x8000 /* reserved fragment flag */ -#define IP_DF 0x4000 /* dont fragment flag */ -#define IP_MF 0x2000 /* more fragments flag */ -#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */ - u_int8_t ip_ttl; /* time to live */ - u_int8_t ip_p; /* protocol */ - u_short ip_sum; /* checksum */ - struct in_addr ip_src, ip_dst; /* source and dest address */ -}; - -struct udphdr -{ - u_int16_t source; - u_int16_t dest; - u_int16_t len; - u_int16_t check; -}; - -/* - * generic definitions for IEEE 802.11 frames + * 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 ieee80211_frame +struct WlanHeader { - u_int8_t i_fc[2]; - u_int8_t i_dur[2]; - u_int8_t i_addr1[IEEE80211_ADDR_LEN]; - u_int8_t i_addr2[IEEE80211_ADDR_LEN]; - u_int8_t i_addr3[IEEE80211_ADDR_LEN]; - u_int8_t i_seq[2]; -#if DEBUG_wlan_ip_udp_packets_on_air -u_int8_t llc[4]; -struct iph ip; -struct udphdr udp; -#endif -}GNUNET_PACKED; -/** - * Encapsulation of all of the state of the plugin. - */ -struct Plugin -{ /** - * Our environment. + * Message type is GNUNET_MESSAGE_TYPE_WLAN_DATA. */ - struct GNUNET_TRANSPORT_PluginEnvironment *env; + struct GNUNET_MessageHeader header; /** - * List of open connections. head + * CRC32 checksum (only over the payload), in NBO. */ - struct MacEndpoint * mac_head; + uint32_t crc GNUNET_PACKED; /** - * List of open connections. tail + * Sender of the message. */ - struct MacEndpoint * mac_tail; + struct GNUNET_PeerIdentity sender; /** - * Number of connections + * Target of the message. */ - unsigned int mac_count; + struct GNUNET_PeerIdentity target; - /** - * encapsulation of data from the local wlan helper program - */ - struct GNUNET_SERVER_MessageStreamTokenizer * suid_tokenizer; + /* followed by payload, possibly including + multiple messages! */ - /** - * encapsulation of packets received from the wlan helper - */ - struct GNUNET_SERVER_MessageStreamTokenizer * data_tokenizer; +}; +GNUNET_NETWORK_STRUCT_END - /** - * stdout pipe handle for the gnunet-wlan-helper process - */ - struct GNUNET_DISK_PipeHandle *server_stdout; +/** + * Information kept for each message that is yet to be fragmented and + * transmitted. + */ +struct PendingMessage +{ /** - * stdout file handle for the gnunet-wlan-helper process + * next entry in the DLL */ - const struct GNUNET_DISK_FileHandle *server_stdout_handle; + struct PendingMessage *next; /** - * stdin pipe handle for the gnunet-wlan-helper process + * previous entry in the DLL */ - struct GNUNET_DISK_PipeHandle *server_stdin; + struct PendingMessage *prev; /** - * stdin file handle for the gnunet-wlan-helper process + * The pending message */ - const struct GNUNET_DISK_FileHandle *server_stdin_handle; + struct WlanHeader *msg; /** - * ID of the gnunet-wlan-server std read task + * Continuation function to call once the message + * has been sent. Can be NULL if there is no + * continuation to call. */ - GNUNET_SCHEDULER_TaskIdentifier server_read_task; + GNUNET_TRANSPORT_TransmitContinuation transmit_cont; /** - * ID of the gnunet-wlan-server std read task + * Cls for transmit_cont */ - GNUNET_SCHEDULER_TaskIdentifier server_write_task; + void *transmit_cont_cls; /** - * ID of the delay task for writing + * Timeout task (for this message). */ - GNUNET_SCHEDULER_TaskIdentifier server_write_delay_task; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; - /** - * The process id of the wlan process - */ - struct GNUNET_OS_Process *server_proc; +}; - /** - * The interface of the wlan card given to us by the user. - */ - char *interface; +/** + * Session handle for connections with other peers. + */ +struct Session +{ /** - * The mac_address of the wlan card given to us by the helper. + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) */ - struct MacAddress mac_address; + struct GNUNET_PeerIdentity target; /** - * Sessions currently pending for transmission - * to a peer, if any. + * API requirement (must be first). */ - struct Sessionqueue * pending_Sessions_head; + struct SessionHeader header; /** - * Sessions currently pending for transmission - * to a peer (tail), if any. + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - struct Sessionqueue * pending_Sessions_tail; + struct Session *next; /** - * number of pending sessions + * We keep all sessions in a DLL at their respective + * 'struct MACEndpoint'. */ - unsigned int pendingsessions; + struct Session *prev; /** - * Messages in the sending queues + * MAC endpoint with the address of this peer. */ - int pending_Fragment_Messages; + struct MacEndpoint *mac; /** - * 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" + * Head of messages currently pending for transmission to this peer. */ - struct GNUNET_TIME_Absolute beacon_time; + struct PendingMessage *pending_message_head; /** - * queue to send acks for received fragments (head) + * Tail of messages currently pending for transmission to this peer. */ - struct AckSendQueue * ack_send_queue_head; + struct PendingMessage *pending_message_tail; /** - * queue to send acks for received fragments (tail) + * When should this session time out? */ - struct AckSendQueue * ack_send_queue_tail; + struct GNUNET_TIME_Absolute timeout; /** - * Tracker for bandwidth limit + * Timeout task (for the session). */ - struct GNUNET_BANDWIDTH_Tracker tracker; -}; + GNUNET_SCHEDULER_TaskIdentifier timeout_task; -/** - * Struct to store data if file write did not accept the whole packet - */ -struct Finish_send -{ - struct Plugin * plugin; - char * msgheader; - struct GNUNET_MessageHeader * msgstart; - ssize_t size; }; -/** - * Queue of sessions, for the general session queue and the pending session queue - */ -//TODO DOXIGEN -struct Sessionqueue -{ - struct Sessionqueue * next; - struct Sessionqueue * prev; - struct Session * content; -}; /** - * Queue of fragmented messages, for the sending queue of the plugin + * Struct for messages that are being fragmented in a MAC's transmission queue. */ -//TODO DOXIGEN -struct FragmentMessage_queue +struct FragmentMessage { - 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; -}; + /** + * This is a doubly-linked list. + */ + struct FragmentMessage *next; -//TODO DOXIGEN -struct MacEndpoint_id_fragment_triple -{ - struct MacEndpoint * endpoint; - uint32_t message_id; - struct FragmentMessage * fm; -}; + /** + * This is a doubly-linked list. + */ + struct FragmentMessage *prev; -//TODO DOXIGEN -struct Plugin_Session_pair -{ - struct Plugin * plugin; - struct Session * session; -}; + /** + * MAC endpoint this message belongs to + */ + 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 - */ - 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. + * We keep all MACs in a DLL in the plugin. */ - uint32_t message_id; + struct MacEndpoint *next; /** - * msg to send - */ - struct GNUNET_MessageHeader * hdr; - /** - * pointer to the ieee wlan header + * We keep all MACs in a DLL in the plugin. */ - struct ieee80211_frame * ieeewlanheader; + struct MacEndpoint *prev; + /** - * pointer to the radiotap header + * Pointer to the global plugin struct. */ - struct Radiotap_Send * radioHeader; -}; - -/** - * Session infos gathered from a messages - */ + struct Plugin *plugin; -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 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 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 MacAddress *addr); /** - * 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 + * @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 */ -void -hexdump(void *mem, unsigned length) +static const char * +mac_to_string (const struct GNUNET_TRANSPORT_WLAN_MacAddress * mac) { - 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; + static char macstr[20]; - 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); - } + 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; } + /** - * 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 + * Fill the radiotap header + * + * @param endpoint pointer to the endpoint, can be NULL + * @param header pointer to the radiotap header + * @param size total message size */ -static struct MacEndpoint * -get_macendpoint(struct Plugin *plugin, const struct MacAddress *addr, - int create_new) +static void +get_radiotap_header (struct MacEndpoint *endpoint, + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, + uint16_t size) { - struct MacEndpoint * queue = plugin->mac_head; - while (queue != NULL) - { - GNUNET_assert (queue->sessions_head != NULL); - if (memcmp(addr, &queue->addr, sizeof(struct MacAddress)) == 0) - return queue; /* session found */ - queue = queue->next; - } - - if (create_new == GNUNET_YES) - { - return create_macendpoint(plugin, addr); - } + header->header.type = ntohs (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER); + header->header.size = ntohs (size); + if (NULL != endpoint) + { + header->rate = endpoint->rate; + header->tx_power = endpoint->tx_power; + header->antenna = endpoint->antenna; + } else - { - return NULL; - } - + { + header->rate = 255; + header->tx_power = 0; + header->antenna = 0; + } } + + /** - * search for a session with the addr and peer id + * 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 + * @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 struct Session * -search_session(struct Plugin *plugin, const struct MacEndpoint * endpoint, - const struct GNUNET_PeerIdentity * peer) +static void +get_wlan_header (struct Plugin *plugin, + struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *header, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, + unsigned int size) { - GNUNET_assert(endpoint != NULL); - struct Sessionqueue * queue = endpoint->sessions_head; + const int rate = 11000000; - 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; + 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 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. + * Send an ACK for a fragment we received. * - * @param cls closure - * @param addr binary address - * @param addrlen length of the address - * @return string representing the same address + * @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 const char* -wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen) +static void +send_ack (void *cls, uint32_t msg_id, + const struct GNUNET_MessageHeader *hdr) { - static char ret[40]; - const struct MacAddress *mac; + 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]; + + if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE) + { + GNUNET_break (0); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending ACK to helper\n"); + radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf; + get_radiotap_header (endpoint, radio_header, size); + get_wlan_header (endpoint->plugin, + &radio_header->frame, + &endpoint->addr, + size); + memcpy (&radio_header[1], hdr, msize); + if (NULL != + GNUNET_HELPER_send (endpoint->plugin->suid_helper, + &radio_header->header, + GNUNET_NO /* dropping ACKs is bad */, + NULL, NULL)) + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN ACKs sent"), + 1, GNUNET_NO); +} - if (addrlen != sizeof(struct MacAddress)) - { - GNUNET_break (0); - return NULL; - } - mac = addr; - GNUNET_snprintf(ret, sizeof(ret), "%s Mac-Address %X:%X:%X:%X:%X:%X", - PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], mac->mac[3], - mac->mac[4], mac->mac[5]); - return ret; + +/** + * Handles 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 = cls; + struct Plugin *plugin = endpoint->plugin; + struct MacAndSession mas; + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN messages defragmented"), 1, + GNUNET_NO); + mas.session = NULL; + mas.endpoint = endpoint; + (void) GNUNET_SERVER_mst_receive (plugin->fragment_data_tokenizer, + &mas, + (const char *) hdr, + ntohs (hdr->size), + GNUNET_YES, GNUNET_NO); } + /** - * Function for the scheduler if a session times out - * @param cls pointer to the Sessionqueue - * @param tc pointer to the GNUNET_SCHEDULER_TaskContext + * Free a session + * + * @param session the session free */ static void -session_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc){ - struct Sessionqueue * queue = cls; - GNUNET_assert(queue != NULL); - queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){ - return; - } - if (GNUNET_TIME_absolute_get_remaining( - GNUNET_TIME_absolute_add(queue->content->last_activity, SESSION_TIMEOUT)).rel_value - == 0) - { - free_session(queue->content->mac->plugin,queue,GNUNET_YES); - } - else +free_session (struct Session *session) +{ + struct MacEndpoint *endpoint = session->mac; + struct PendingMessage *pm; + + endpoint->plugin->env->session_end (endpoint->plugin->env->cls, + &session->target, + session); + while (NULL != (pm = session->pending_message_head)) + { + GNUNET_CONTAINER_DLL_remove (session->pending_message_head, + session->pending_message_tail, pm); + if (GNUNET_SCHEDULER_NO_TASK != pm->timeout_task) { - queue->content->timeout_task = GNUNET_SCHEDULER_add_delayed(SESSION_TIMEOUT, - &session_timeout, queue); + GNUNET_SCHEDULER_cancel (pm->timeout_task); + pm->timeout_task = GNUNET_SCHEDULER_NO_TASK; } + GNUNET_free (pm->msg); + GNUNET_free (pm); + } + GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, + endpoint->sessions_tail, + session); + if (session->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (session->timeout_task); + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), -1, + GNUNET_NO); + GNUNET_free (session); } + /** - * create a new session + * A session is timing out. Clean up. * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac endpoint of the peer - * @return returns the session + * @param cls pointer to the Session + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ - -static struct Session * -create_session(struct Plugin *plugin, struct MacEndpoint * endpoint, - const struct GNUNET_PeerIdentity * peer) +static void +session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - GNUNET_assert(endpoint != NULL); - 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; - memcpy(&(queue->content->target), peer, sizeof(struct GNUNET_PeerIdentity)); - queue->content->last_activity = GNUNET_TIME_absolute_get(); - queue->content->timeout_task = GNUNET_SCHEDULER_add_delayed(SESSION_TIMEOUT,&session_timeout, queue); - -#if DEBUG_wlan - 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)); -#endif - - return queue->content; + struct Session * session = cls; + struct GNUNET_TIME_Relative timeout; + + session->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (session->timeout); + if (0 == timeout.rel_value) + { + free_session (session); + return; + } + session->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &session_timeout, session); } + /** - * Get session from address, create if no session exists + * Create a new session * - * @param plugin pointer to the plugin struct - * @param addr pointer to the mac address of the peer - * @param peer pointer to the peerid + * @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 * -get_session(struct Plugin *plugin, const struct MacAddress *addr, - const struct GNUNET_PeerIdentity * peer) +create_session (struct MacEndpoint *endpoint, + const struct GNUNET_PeerIdentity *peer) { - struct MacEndpoint * mac; - mac = get_macendpoint(plugin, addr, GNUNET_YES); - struct Session * session = search_session(plugin, mac, peer); + struct Session *session; - if (session != NULL) - return session; - return create_session(plugin, mac, peer); + for (session = endpoint->sessions_head; NULL != session; session = session->next) + if (0 == memcmp (peer, &session->target, + sizeof (struct GNUNET_PeerIdentity))) + { + session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + return session; + } + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), 1, + GNUNET_NO); + session = GNUNET_malloc (sizeof (struct Session)); + GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head, + endpoint->sessions_tail, + session); + session->mac = endpoint; + session->target = *peer; + session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + session->timeout_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout, session); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Created new session for peer `%s' with endpoint %s\n", + GNUNET_i2s (peer), + mac_to_string (&endpoint->addr)); + return session; } + /** - * Queue the session to send data - * 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 + * 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 -queue_session(struct Plugin *plugin, struct Session * session) +fragment_transmission_done (void *cls, + int result) { - 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++; - } + struct FragmentMessage *fm = cls; + fm->sh = NULL; + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); } + /** - * Function to schedule the write task, executed after a delay - * @param cls pointer to the plugin struct - * @param tc GNUNET_SCHEDULER_TaskContext pointer + * 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 -delay_fragment_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +transmit_fragment (void *cls, + 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; - - // GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg - if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) - { - plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, - &do_transmit, plugin); - } + struct FragmentMessage *fm = cls; + struct MacEndpoint *endpoint = fm->macendpoint; + size_t size; + uint16_t msize; + + msize = ntohs (hdr->size); + size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize; + { + char buf[size]; + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radio_header; + + radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf; + get_radiotap_header (endpoint, radio_header, size); + get_wlan_header (endpoint->plugin, + &radio_header->frame, + &endpoint->addr, + size); + memcpy (&radio_header[1], hdr, msize); + GNUNET_assert (NULL == fm->sh); + fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper, + &radio_header->header, + GNUNET_NO, + &fragment_transmission_done, fm); + if (NULL != fm->sh) + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN message fragments sent"), + 1, GNUNET_NO); + else + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); + } } + /** - * Function to calculate the time of the next periodic "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 -set_next_beacon_time(struct Plugin * const plugin) +free_fragment_message (struct FragmentMessage *fm) { - //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, - HALLO_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 * HALLO_BEACON_SCALING_FACTOR)); - } - //over 30 known peers: once a minute - else - { - plugin->beacon_time = GNUNET_TIME_absolute_add( - GNUNET_TIME_absolute_get(), - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, - HALLO_BEACON_SCALING_FACTOR)); - } + struct MacEndpoint *endpoint = fm->macendpoint; + + GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN messages pending (with fragmentation)"), + -1, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (endpoint->sending_messages_head, + endpoint->sending_messages_tail, fm); + if (NULL != fm->sh) + { + GNUNET_HELPER_send_cancel (fm->sh); + fm->sh = NULL; + } + GNUNET_FRAGMENT_context_destroy (fm->fragcontext); + if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (fm->timeout_task); + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (fm); } + /** - * Function to set the timer for the next timeout of the fragment queue - * @param plugin the handle to the plugin struct + * A FragmentMessage has timed out. Remove it. + * + * @param cls pointer to the 'struct FragmentMessage' + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ - static void -set_next_send(struct Plugin * const plugin) +fragmentmessage_timeout (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct GNUNET_TIME_Relative next_send; + struct FragmentMessage *fm = cls; - //cancel old task - if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task); - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - } + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + if (NULL != fm->cont) + { + fm->cont (fm->cont_cls, &fm->target, GNUNET_SYSERR); + fm->cont = NULL; + } + free_fragment_message (fm); +} - //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); - } +/** + * 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 +send_with_fragmentation (struct MacEndpoint *endpoint, + struct GNUNET_TIME_Relative timeout, + const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *msg, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Next packet is send in: %u\n", - next_send.rel_value); -#endif +{ + struct FragmentMessage *fm; + struct Plugin *plugin; - 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); - } - } + 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 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 + * Free a MAC endpoint. + * + * @param endpoint pointer to the MacEndpoint to free */ -static struct Session * -get_next_queue_session(struct Plugin * plugin) +static void +free_macendpoint (struct MacEndpoint *endpoint) { - struct Session * session; - struct Sessionqueue * sessionqueue; - struct Sessionqueue * sessionqueue_alt; - struct PendingMessage * pm; - sessionqueue = plugin->pending_Sessions_head; + struct Plugin *plugin = endpoint->plugin; + struct FragmentMessage *fm; + struct Session *session; - while (sessionqueue != NULL) - { - session = sessionqueue->content; - - GNUNET_assert(session != NULL); - pm = session->pending_message_head; - -#if DEBUG_wlan - if (pm == NULL) - { - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - "pending message is empty, should not happen. session %p\n", - session); - } -#endif - - GNUNET_assert(pm != NULL); - - //check for message timeout - if (GNUNET_TIME_absolute_get_remaining(pm->timeout).rel_value > 0) - { - //check if session has no message in the fragment queue - if ((session->mac->fragment_messages_out_count - < FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT) - && (session->fragment_messages_out_count - < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION)) - { - plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_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_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, sessionqueue_alt); - - GNUNET_free(sessionqueue_alt); - } - } + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN MAC endpoints allocated"), -1, GNUNET_NO); + while (NULL != (session = endpoint->sessions_head)) + free_session (session); + while (NULL != (fm = endpoint->sending_messages_head)) + free_fragment_message (fm); + GNUNET_CONTAINER_DLL_remove (plugin->mac_head, + plugin->mac_tail, + endpoint); + + if (NULL != endpoint->defrag) + { + GNUNET_DEFRAGMENT_context_destroy(endpoint->defrag); + endpoint->defrag = NULL; + } - } - return NULL; + plugin->mac_count--; + if (GNUNET_SCHEDULER_NO_TASK != endpoint->timeout_task) + { + GNUNET_SCHEDULER_cancel (endpoint->timeout_task); + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (endpoint); } + /** - * frees the space of a message in the fragment queue (send queue) - * @param plugin the plugin struct - * @param fm message to free + * A MAC endpoint is timing out. Clean up. + * + * @param cls pointer to the MacEndpoint + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ static void -free_fragment_message(struct Plugin * plugin, struct FragmentMessage * fm) +macendpoint_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct Session * session = fm->session; - struct MacEndpoint * endpoint = session->mac; - struct FragmentMessage_queue * fmq; - struct FragmentMessage_queue * fmq_next; + struct MacEndpoint *endpoint = cls; + struct GNUNET_TIME_Relative timeout; - if (fm != NULL) - { - fmq = plugin->sending_messages_head; - while (fmq != NULL) - { - fmq_next = fmq->next; - if (fmq->content == fm) - { - GNUNET_CONTAINER_DLL_remove(plugin->sending_messages_head,plugin->sending_messages_tail, fmq); - GNUNET_free(fmq); - } - fmq = fmq_next; - } - - (session->mac->fragment_messages_out_count)--; - session->fragment_messages_out_count--; - plugin->pending_Fragment_Messages--; - GNUNET_CONTAINER_DLL_remove(endpoint->sending_messages_head,endpoint->sending_messages_tail, fm); - GNUNET_FRAGMENT_context_destroy(fm->fragcontext); - if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(fm->timeout_task); - GNUNET_free(fm); - - queue_session(plugin, session); -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Free pending fragment messages %p, session %p\n", fm, session); -#endif - } + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout); + if (0 == timeout.rel_value) + { + free_macendpoint (endpoint); + return; + } + endpoint->timeout_task = + GNUNET_SCHEDULER_add_delayed (timeout, &macendpoint_timeout, + endpoint); } + /** - * function to fill the radiotap header + * Find (or create) a MacEndpoint with a specific MAC address + * * @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 + * @param addr the MAC address of the endpoint + * @return handle to our data structure for this MAC */ -static int -getRadiotapHeader(struct Plugin * plugin, struct MacEndpoint * endpoint, - struct Radiotap_Send * header) +static struct MacEndpoint * +create_macendpoint (struct Plugin *plugin, + const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr) { - - if (endpoint != NULL) - { - header->rate = endpoint->rate; - header->tx_power = endpoint->tx_power; - header->antenna = endpoint->antenna; - } - else - { - header->rate = 255; - header->tx_power = 0; - header->antenna = 0; - } - - return GNUNET_YES; + struct MacEndpoint *pos; + + for (pos = plugin->mac_head; NULL != pos; pos = pos->next) + if (0 == memcmp (addr, &pos->addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + return pos; + pos = GNUNET_malloc (sizeof (struct MacEndpoint)); + pos->addr = *addr; + pos->plugin = plugin; + pos->defrag = + GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU, + MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, + pos, + &wlan_data_message_handler, + &send_ack); + pos->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT); + pos->timeout_task = + GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, + pos); + GNUNET_CONTAINER_DLL_insert (plugin->mac_head, plugin->mac_tail, pos); + plugin->mac_count++; + GNUNET_STATISTICS_update (plugin->env->stats, _("# WLAN MAC endpoints allocated"), + 1, GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "New MAC endpoint `%s'\n", + mac_to_string (addr)); + return pos; } + /** - * function to generate the wlan hardware header for one packet - * @param Header address to write the header to - * @param to_mac_addr address of the recipient - * @param plugin pointer to the plugin struct - * @return GNUNET_YES if there was no error + * Creates a new outbound session the transport service will use to send data to the + * peer + * + * @param cls the plugin + * @param address the address + * @return the session or NULL of max connections exceeded */ -static int -getWlanHeader(struct ieee80211_frame * Header, - const struct MacAddress * to_mac_addr, struct Plugin * plugin, - unsigned int size) +static struct Session * +wlan_plugin_get_session (void *cls, + const struct GNUNET_HELLO_Address *address) { - uint16_t * tmp16; - const int rate = 11000000; + struct Plugin *plugin = cls; + struct MacEndpoint *endpoint; - Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA; - Header->i_fc[1] = 0x00; - memcpy(&Header->i_addr3, &mac_bssid, sizeof(mac_bssid)); - memcpy(&Header->i_addr2, plugin->mac_address.mac, sizeof(plugin->mac_address)); - memcpy(&Header->i_addr1, to_mac_addr, sizeof(struct MacAddress)); - - tmp16 = (uint16_t*) Header->i_dur; - *tmp16 = (uint16_t) htole16((size * 1000000) / rate + 290); - -#if DEBUG_wlan_ip_udp_packets_on_air - uint crc = 0; - uint16_t * x; - int count; - Header->ip.ip_dst.s_addr = *((uint32_t*) &to_mac_addr->mac[2]); - Header->ip.ip_src.s_addr = *((uint32_t*) &plugin->mac_address.mac[2]); - Header->ip.ip_v = 4; - Header->ip.ip_hl = 5; - Header->ip.ip_p = 17; - Header->ip.ip_ttl = 1; - Header->ip.ip_len = htons(size + 8); - Header->ip.ip_sum = 0; - x =(uint16_t *) &Header->ip; - count = sizeof(struct iph); - while (count > 1) - { - /* This is the inner loop */ - crc += (unsigned short) * x++; - count -= 2; - } - /* Add left-over byte, if any */ - if( count > 0 ) - crc += * (unsigned char *) x; - crc = (crc & 0xffff) + (crc >> 16); - Header->ip.ip_sum = htons(~ (unsigned short) crc); - Header->llc[0] = 6; - Header->llc[1] = 6; - Header->udp.len = htons(size - sizeof(struct ieee80211_frame)); - -#endif - - return GNUNET_YES; + if (NULL == address) + return NULL; + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != address->address_length) + { + GNUNET_break (0); + return NULL; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Service asked to create session for peer `%s' with MAC `%s'\n", + GNUNET_i2s (&address->peer), + mac_to_string (address->address)); + endpoint = create_macendpoint (plugin, address->address); + return create_session (endpoint, &address->peer); } + /** - * 32bit CRC - * - * @param msgbuf pointer tor the data - * @param msgbuf_size size of the data + * Function that can be used to force the plugin to disconnect + * from the given peer and cancel all previous transmissions + * (and their continuation). * - * @return 32bit crc value + * @param cls closure + * @param target peer from which to disconnect */ - -uint32_t -getcrc32(const char *msgbuf, size_t msgbuf_size) +static void +wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { + struct Plugin *plugin = cls; + struct Session *session; + struct MacEndpoint *endpoint; - return GNUNET_CRYPTO_crc32_n(msgbuf, msgbuf_size);; + 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!) */ + } } + /** - * 16bit CRC - * - * @param msgbuf pointer tor the data - * @param msgbuf_size size of the data + * Function that can be used by the transport service to transmit + * a message using the plugin. Note that in the case of a + * peer disconnecting, the continuation MUST be called + * prior to the disconnect notification itself. This function + * will be called with this peer's HELLO message to initiate + * a fresh connection to another peer. * - * @return 16bit crc value + * @param cls closure + * @param session which session must be used + * @param msgbuf the message to transmit + * @param msgbuf_size number of bytes in 'msgbuf' + * @param priority how important is the message (most plugins will + * ignore message priority and just FIFO) + * @param to how long to wait at most for the transmission (does not + * require plugins to discard the message after the timeout, + * just advisory for the desired delay; most plugins will ignore + * this as well) + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...); can be NULL + * @param cont_cls closure for cont + * @return number of bytes used (on the physical network, with overheads); + * -1 on hard errors (i.e. address invalid); 0 is a legal value + * and does NOT mean that the message was not transmitted (DV) */ - -uint16_t -getcrc16(const char *msgbuf, size_t msgbuf_size) +static ssize_t +wlan_plugin_send (void *cls, + struct Session *session, + const char *msgbuf, size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative to, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { - //TODO calc some crc - return 0; + struct Plugin *plugin = cls; + struct WlanHeader *wlanheader; + size_t size = msgbuf_size + sizeof (struct WlanHeader); + char buf[size] GNUNET_ALIGN; + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Transmitting %u bytes of payload to peer `%s' (starting with %u byte message of type %u)\n", + msgbuf_size, + GNUNET_i2s (&session->target), + (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->size), + (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->type)); + wlanheader = (struct WlanHeader *) buf; + wlanheader->header.size = htons (msgbuf_size + sizeof (struct WlanHeader)); + wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA); + wlanheader->sender = *plugin->env->my_identity; + wlanheader->target = session->target; + wlanheader->crc = htonl (GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size)); + memcpy (&wlanheader[1], msgbuf, msgbuf_size); + send_with_fragmentation (session->mac, + to, + &session->target, + &wlanheader->header, + cont, cont_cls); + return size; } -/** - * function to add a fragment of a message to send - * @param cls FragmentMessage this message belongs to - * @param hdr pointer to the start of the message - */ - -void -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; - -#if DEBUG_wlan_retransmission - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Adding fragment of message %p to send, session %p, endpoint %p\n", fm, - fm->session, endpoint); -#endif - - 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); -} /** - * function to send a hallo beacon - * @param plugin pointer to the plugin struct + * We have received data from the WLAN via some session. Process depending + * on the message type (HELLO, DATA, FRAGMENTATION or FRAGMENTATION-ACK). + * + * @param cls pointer to the plugin + * @param client pointer to the session this message belongs to + * @param hdr start of the message */ -static void -send_hello_beacon(struct Plugin * plugin) +static int +process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr) { - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Sending hello beacon\n"); -#endif - - uint16_t size; - ssize_t bytes; - uint16_t hallo_size; - struct GNUNET_MessageHeader * msgheader; - struct ieee80211_frame * ieeewlanheader; - struct Radiotap_Send * radioHeader; - struct GNUNET_MessageHeader * msgheader2; - const struct GNUNET_MessageHeader *hello; - - hello = plugin->env->get_our_hello (); - hallo_size = GNUNET_HELLO_size(hello); - GNUNET_assert(sizeof(struct WlanHeader) + hallo_size <= WLAN_MTU); - size = sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_Send) - + sizeof(struct ieee80211_frame) + sizeof(struct GNUNET_MessageHeader) - + hallo_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(hello) - + sizeof(struct GNUNET_MessageHeader)); - - msgheader2->type = htons(GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT); - memcpy(&msgheader2[1], hello, hallo_size); - - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, msgheader, size); - - if (bytes == GNUNET_SYSERR) + struct Plugin *plugin = cls; + struct MacAndSession *mas = client; + struct MacAndSession xmas; +#define NUM_ATS 2 + struct GNUNET_ATS_Information ats[NUM_ATS]; /* FIXME: do better here */ + struct FragmentMessage *fm; + struct GNUNET_PeerIdentity tmpsource; + const struct WlanHeader *wlanheader; + int ret; + uint16_t msize; + + ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE); + ats[0].value = htonl (1); + ats[1].type = htonl (GNUNET_ATS_NETWORK_TYPE); + ats[1].value = htonl (GNUNET_ATS_NET_WLAN); + msize = ntohs (hdr->size); + switch (ntohs (hdr->type)) + { + case GNUNET_MESSAGE_TYPE_HELLO: + if (GNUNET_OK != + GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource)) { - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), - errno, strerror(errno)); - + GNUNET_break_op (0); + break; } - GNUNET_assert(bytes != GNUNET_SYSERR); - GNUNET_assert(bytes == size); - GNUNET_free(msgheader); - - set_next_beacon_time(plugin); - set_next_send(plugin); -} - -/** - * function to add an ack to send it for a received fragment - * @param cls MacEndpoint this ack belongs to - * @param msg_id id of the message - * @param hdr pointer to the hdr where the ack is stored - * - */ - -static void -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); - -#if DEBUG_wlan_retransmission - 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); -#endif - - set_next_send(plugin); -} - -/** - * Function for the scheduler if a FragmentMessage times out - * @param cls pointer to the FragmentMessage - * @param tc pointer to the GNUNET_SCHEDULER_TaskContext - */ -static void -fragmentmessage_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc){ - struct FragmentMessage * fm = cls; - GNUNET_assert(fm != NULL); - fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){ - return; - } - free_fragment_message(fm->session->mac->plugin,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 - */ - -static void -check_fragment_queue(struct Plugin * plugin) -{ - struct Session * session; - struct FragmentMessage * fm; - struct GNUNET_PeerIdentity pid; - - struct PendingMessage * pm; - - if (plugin->pending_Fragment_Messages < FRAGMENT_QUEUE_SIZE) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing %u bytes of HELLO from peer `%s' at MAC %s\n", + (unsigned int) msize, + GNUNET_i2s (&tmpsource), + mac_to_string (&mas->endpoint->addr)); + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# HELLO messages received via WLAN"), 1, + GNUNET_NO); + plugin->env->receive (plugin->env->cls, + &tmpsource, + hdr, + ats, NUM_ATS, + mas->session, + (mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr, + (mas->endpoint == NULL) ? 0 : sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + break; + case GNUNET_MESSAGE_TYPE_FRAGMENT: + if (NULL == mas->endpoint) { - session = get_next_queue_session(plugin); - if (session != NULL) - { - pm = session->pending_message_head; - GNUNET_CONTAINER_DLL_remove(session->pending_message_head, session->pending_message_tail, pm); - session->mac->fragment_messages_out_count++; - session->fragment_messages_out_count++; - plugin->pending_Fragment_Messages++; - GNUNET_assert(pm != NULL); - - 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); -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "called pm->transmit_cont for %p\n", session); -#endif - } - else - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "no pm->transmit_cont for %p\n", session); -#endif - } - GNUNET_free(pm); - - if (session->pending_message_head != NULL) - { - //requeue session - queue_session(plugin, session); - } - - } + GNUNET_break (0); + break; } - - //check if timeout changed - set_next_send(plugin); -} - -/** - * Function to send an ack, does not free the ack - * @param plugin pointer to the plugin - * @param ack pointer to the ack to send - */ -static void -send_ack(struct Plugin * plugin, struct AckSendQueue * ack) -{ - - ssize_t bytes; - -#if DEBUG_wlan - 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)); -#endif - - getRadiotapHeader(plugin, ack->endpoint, ack->radioHeader); - getWlanHeader(ack->ieeewlanheader, &ack->endpoint->addr, plugin, - ntohs(ack->hdr->size)); - - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, ack->hdr, - ntohs(ack->hdr->size)); - if (bytes == GNUNET_SYSERR) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing %u bytes of FRAGMENT from MAC %s\n", + (unsigned int) msize, + mac_to_string (&mas->endpoint->addr)); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# fragments received via WLAN"), 1, GNUNET_NO); + (void) GNUNET_DEFRAGMENT_process_fragment (mas->endpoint->defrag, + hdr); + break; + case GNUNET_MESSAGE_TYPE_FRAGMENT_ACK: + if (NULL == mas->endpoint) { - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), - errno, strerror(errno)); - + GNUNET_break (0); + break; } - GNUNET_assert(bytes != GNUNET_SYSERR); - GNUNET_assert(bytes == ntohs(ack->hdr->size)); - set_next_send(plugin); -} - -/** - * function to finish a sending if not all could have been writen befor - * @param cls pointer to the Finish_send struct - * @param tc TaskContext - */ -static void -finish_sending(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct Finish_send * finish = 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_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_free (finish->msgstart); - GNUNET_free (finish); - return; + ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); + if (GNUNET_OK == ret) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got last ACK, finished message transmission to `%s' (%p)\n", + mac_to_string (&mas->endpoint->addr), + fm); + mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT); + if (NULL != fm->cont) + { + fm->cont (fm->cont_cls, &fm->target, GNUNET_OK); + fm->cont = NULL; + } + free_fragment_message (fm); + break; + } + if (GNUNET_NO == ret) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got an ACK, message transmission to `%s' not yet finished\n", + mac_to_string (&mas->endpoint->addr)); + break; + } } - bytes = GNUNET_DISK_file_write(plugin->server_stdin_handle, - finish->msgheader, finish->size); - GNUNET_assert (bytes != GNUNET_SYSERR); - - if (bytes != finish->size) + 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) { - finish->msgheader = finish->msgheader + bytes; - finish->size = finish->size - bytes; - plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, - &finish_sending, finish); + GNUNET_break (0); + break; } - else + if (msize < sizeof (struct WlanHeader)) { - GNUNET_free(finish->msgstart); - GNUNET_free(finish); - set_next_send(plugin); + 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; } -} - -/** - * Function called when wlan helper is ready to get some data - * - * @param cls closure - * @param tc GNUNET_SCHEDULER_TaskContext - */ -static void -do_transmit(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct Plugin * plugin = cls; - - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; - - struct Session * session; - struct FragmentMessage * fm; - struct Finish_send * finish; - struct FragmentMessage_queue * fmq; - struct AckSendQueue * ack; - ssize_t bytes; - - if (plugin->ack_send_queue_head != NULL) + if (ntohl (wlanheader->crc) != + GNUNET_CRYPTO_crc32_n (&wlanheader[1], msize - sizeof (struct WlanHeader))) { - ack = plugin->ack_send_queue_head; - GNUNET_CONTAINER_DLL_remove(plugin->ack_send_queue_head, - plugin->ack_send_queue_tail, ack); - send_ack(plugin, ack); - GNUNET_free(ack); - return; + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN DATA messages discarded due to CRC32 error"), 1, + GNUNET_NO); + break; } - - //test if a "hello-beacon" has to be send - if (GNUNET_TIME_absolute_get_remaining(plugin->beacon_time).rel_value == 0) + 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) { - send_hello_beacon(plugin); - return; + GNUNET_break (0); + break; } - - if (plugin->sending_messages_head != NULL) + if (NULL == mas->session) { - 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); - -#if DEBUG_wlan - 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); -#endif - - 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 == GNUNET_SYSERR) - { - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _("Error writing to wlan healper. errno == %d, ERROR: %s\n"), - errno, strerror(errno)); - - } - GNUNET_assert(bytes != GNUNET_SYSERR); - - if (bytes != fm->size) - { - finish = GNUNET_malloc(sizeof( struct Finish_send)); - finish->plugin = plugin; - finish->msgheader = fm->frag + bytes; - finish->size = fm->size - bytes; - finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag; - - GNUNET_assert(plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); - - plugin->server_write_task = GNUNET_SCHEDULER_add_write_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, - &finish_sending, finish); - fm->frag = NULL; - } - else - { - GNUNET_free(fm->frag); - fm->frag = NULL; - set_next_send(plugin); - } - GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); - return; + GNUNET_break (0); + break; } - - GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, - "do_transmit did nothing, should not happen!\n"); + 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 + /** - * 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. + * Function used for to process the data from the suid process * - * @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 cls the plugin handle + * @param client client that send the data (not used) + * @param hdr header of the GNUNET_MessageHeader */ static int -wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen) +handle_helper_message (void *cls, void *client, + const struct GNUNET_MessageHeader *hdr) { - //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) + struct Plugin *plugin = cls; + const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo; + const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm; + struct MacAndSession mas; + uint16_t msize; + + msize = ntohs (hdr->size); + switch (ntohs (hdr->type)) + { + case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: + if (msize != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)) { - /* TODO check for bad addresses like multicast, broadcast, etc */ - return GNUNET_OK; + GNUNET_break (0); + break; } - - return GNUNET_SYSERR; -} - -/** - * Function that can be used by the transport service to transmit - * a message using the plugin. - * - * @param cls closure - * @param target who should receive this message - * @param priority how important is the message - * @param msgbuf the message to transmit - * @param msgbuf_size number of bytes in 'msgbuf' - * @param timeout when should we time out - * @param session which session must be used (or NULL for "any") - * @param addr the address to use (can be NULL if the plugin - * is "on its own" (i.e. re-use existing TCP connection)) - * @param addrlen length of the address in bytes - * @param force_address GNUNET_YES if the plugin MUST use the given address, - * otherwise the plugin may use other addresses or - * existing connections (if available) - * @param 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...) - * @param cont_cls closure for cont - * @return number of bytes used (on the physical network, with overheads); - * -1 on hard errors (i.e. address invalid); 0 is a legal value - * and does NOT mean that the message was not transmitted (DV) - */ -static ssize_t -wlan_plugin_send(void *cls, const struct GNUNET_PeerIdentity * target, - const char *msgbuf, size_t msgbuf_size, unsigned int priority, - struct GNUNET_TIME_Relative timeout, struct Session *session, - const void *addr, size_t addrlen, int force_address, - GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) -{ - struct Plugin * plugin = cls; - struct PendingMessage * newmsg; - struct WlanHeader * wlanheader; - - //check if msglen > 0 - GNUNET_assert(msgbuf_size > 0); - - //get session if needed - if (session == NULL) + cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *) hdr; + if (GNUNET_YES == plugin->have_mac) { - if (wlan_plugin_address_suggested(plugin, addr, addrlen) == GNUNET_OK) - { - session = get_session(plugin, addr, target); - } - else - { - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, - _("Wlan Address len %d is wrong\n"), addrlen); - return -1; - } + if (0 == memcmp (&plugin->mac_address, + &cm->mac, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + break; /* no change */ + /* remove old address */ + plugin->env->notify_address (plugin->env->cls, GNUNET_NO, + &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); } + plugin->mac_address = cm->mac; + plugin->have_mac = GNUNET_YES; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer `%s'\n", + mac_to_string (&cm->mac), + GNUNET_i2s (plugin->env->my_identity)); + plugin->env->notify_address (plugin->env->cls, GNUNET_YES, + &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + break; + case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER: + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got data message from helper with %u bytes\n", + msize); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# DATA messages received via WLAN"), 1, + GNUNET_NO); + if (msize < sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)) + { + GNUNET_break (0); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Size of packet is too small (%u bytes)\n", + msize); + break; + } + rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr; - //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) + /* check if message is actually for us */ + if (0 != memcmp (&rxinfo->frame.addr3, &mac_bssid_gnunet, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + { + /* Not the GNUnet BSSID */ + break; + } + if ( (0 != memcmp (&rxinfo->frame.addr1, &bc_all_mac, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) && + (0 != memcmp (&rxinfo->frame.addr1, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) ) { - newmsg = session->pending_message_head; - GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, 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); + /* Neither broadcast nor specifically for us */ + break; } + if (0 == memcmp (&rxinfo->frame.addr2, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) + { + /* packet is FROM us, thus not FOR us */ + break; + } + + GNUNET_STATISTICS_update (plugin->env->stats, + _("# WLAN DATA messages processed"), + 1, GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Receiving %u bytes of data from MAC `%s'\n", + (unsigned int) (msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)), + mac_to_string (&rxinfo->frame.addr2)); + mas.endpoint = create_macendpoint (plugin, &rxinfo->frame.addr2); + mas.session = NULL; + (void) GNUNET_SERVER_mst_receive (plugin->helper_payload_tokenizer, + &mas, + (const char*) &rxinfo[1], + msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage), + GNUNET_YES, GNUNET_NO); + break; + default: + GNUNET_break (0); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Unexpected message of type %u (%u bytes)", + ntohs (hdr->type), ntohs (hdr->size)); + break; + } + return GNUNET_OK; +} - 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 - wlanheader->header.size = htons(msgbuf_size + sizeof(struct WlanHeader)); - wlanheader->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA); - memcpy(&(wlanheader->target), target, sizeof(struct GNUNET_PeerIdentity)); - memcpy(&(wlanheader->source), plugin->env->my_identity, - sizeof(struct GNUNET_PeerIdentity)); - wlanheader->crc = 0; - memcpy(&wlanheader[1], msgbuf, msgbuf_size); - wlanheader->crc = htonl( - getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader))); - //GNUNET_log_from(GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, "Wlan message Header crc: %u, %u\n",getcrc32((char*) wlanheader, msgbuf_size + sizeof(struct WlanHeader)), wlanheader->crc); - //hexdump(newmsg->msg, msgbuf_size + sizeof(struct WlanHeader)); - - newmsg->transmit_cont = cont; - newmsg->transmit_cont_cls = cont_cls; - newmsg->timeout = GNUNET_TIME_relative_to_absolute(timeout); - - 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); - -#if DEBUG_wlan - 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); -#endif - - //queue session - queue_session(plugin, session); - - check_fragment_queue(plugin); - //FIXME not the correct size - return msgbuf_size; -} /** - * function to free a mac endpoint - * @param plugin pointer to the plugin struct - * @param endpoin pointer to the MacEndpoint to free + * Task to (periodically) send a HELLO beacon + * + * @param cls pointer to the plugin struct + * @param tc scheduler context */ static void -free_macendpoint(struct Plugin * plugin, struct MacEndpoint * endpoint) +send_hello_beacon (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - 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; - } + struct Plugin *plugin = cls; + uint16_t size; + uint16_t hello_size; + struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radioHeader; + const struct GNUNET_MessageHeader *hello; - 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); - GNUNET_free(endpoint); + 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); } + /** - * function to free a session - * @param plugin pointer to the plugin - * @param queue pointer to the sessionqueue element to free - * @param free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint + * 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 -free_session(struct Plugin * plugin, struct Sessionqueue * queue, - int do_free_macendpoint) +static int +wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) { - struct Sessionqueue * pendingsession; - struct Sessionqueue * pendingsession_tmp; - struct PendingMessage * pm; - struct MacEndpoint * endpoint; - struct FragmentMessage * fm; - struct FragmentMessage * fmnext; - int check = 0; - - GNUNET_assert(queue != NULL); - GNUNET_assert(queue->content != NULL); - - //session found - //is this session pending for send - pendingsession = plugin->pending_Sessions_head; - while (pendingsession != NULL) - { - pendingsession_tmp = pendingsession->next; - if (pendingsession->content == queue->content) - { - plugin->pendingsessions--; - GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, - plugin->pending_Sessions_tail, - pendingsession); - GNUNET_free(pendingsession); - - GNUNET_assert (check == 0); - check = 1; - } - pendingsession = pendingsession_tmp; - } - - endpoint = queue->content->mac; - fm = endpoint->sending_messages_head; - while (fm != NULL) - { - 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); - - if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES) - { - free_macendpoint(plugin, endpoint); - } + struct Plugin *plugin = cls; - if (queue->content->timeout_task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(queue->content->timeout_task); - GNUNET_free(queue); - check_fragment_queue(plugin); + if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + if (GNUNET_YES != plugin->have_mac) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Rejecting MAC `%s': I don't know my MAC!\n", + mac_to_string (addr)); + return GNUNET_NO; /* don't know my MAC */ + } + if (0 != memcmp (addr, + &plugin->mac_address, + addrlen)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Rejecting MAC `%s': not my MAC!\n", + mac_to_string (addr)); + return GNUNET_NO; /* not my MAC */ + } + return GNUNET_OK; } + /** - * Function that can be used to force the plugin to disconnect - * from the given peer and cancel all previous transmissions - * (and their continuation). + * 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 target peer from which to disconnect + * @param addr binary address + * @param addrlen length of the address + * @return string representing the same address */ -static void -wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) +static const char * +wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) { - struct Plugin *plugin = cls; - struct Sessionqueue * queue; - struct Sessionqueue * queue_next; - struct MacEndpoint * endpoint = plugin->mac_head; - struct MacEndpoint * endpoint_next; - // just look at all the session for the needed one - while (endpoint != NULL) - { - queue = endpoint->sessions_head; - endpoint_next = endpoint->next; - while (queue != NULL) - { - // content is never NULL - GNUNET_assert (queue->content != NULL); - queue_next = queue->next; - if (memcmp(target, &(queue->content->target), - sizeof(struct GNUNET_PeerIdentity)) == 0) - { - free_session(plugin, queue, GNUNET_YES); - } - // try next - queue = queue_next; - } - endpoint = endpoint_next; - } + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) + { + GNUNET_break (0); + return NULL; + } + mac = addr; + return GNUNET_strdup (mac_to_string (mac)); } + /** - * Convert the transports address to a nice, human-readable - * format. + * Convert the transports address to a nice, human-readable format. * * @param cls closure * @param type name of the transport that generated the address @@ -2012,750 +1493,138 @@ wlan_plugin_disconnect(void *cls, const struct GNUNET_PeerIdentity *target) * @param asc_cls closure for asc */ static void -wlan_plugin_address_pretty_printer(void *cls, const char *type, - const void *addr, size_t addrlen, int numeric, - struct GNUNET_TIME_Relative timeout, - GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls) -{ - char ret[92]; - const unsigned char * input; - - //GNUNET_assert(cls !=NULL); - if (addrlen != 6) - { - /* invalid address (MAC addresses have 6 bytes) */GNUNET_break (0); - asc(asc_cls, NULL); - return; - } - input = (const unsigned char*) addr; - GNUNET_snprintf(ret, sizeof(ret), - "%s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", PROTOCOL_PREFIX, - input[0], input[1], input[2], input[3], input[4], input[5]); - asc(asc_cls, ret); -} - -/** - * handels the data after all fragments are put together - * @param plugin - * @param session_light - * @param hdr pointer to the data - */ -static void -wlan_data_message_handler(void *cls, 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 MacEndpoint * endpoint = (struct MacEndpoint *) cls; - struct Plugin * plugin = endpoint->plugin; - struct WlanHeader * wlanheader; - struct Session * session; - //const char * tempmsg; - const struct GNUNET_MessageHeader * temp_hdr; - struct GNUNET_PeerIdentity tmpsource; - int crc; - - if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) - { - -#if DEBUG_wlan - 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)); -#endif - - if (ntohs(hdr->size) < sizeof(struct WlanHeader) - + sizeof(struct GNUNET_MessageHeader)) - { - //packet not big enought - return; - } - - wlanheader = (struct WlanHeader *) hdr; - - session = search_session(plugin, endpoint, &wlanheader->source); - - //tempmsg = (char*) &wlanheader[1]; - temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1]; - crc = ntohl(wlanheader->crc); - wlanheader->crc = 0; - if (getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)) != crc) - { - //wrong crc, dispose message - GNUNET_log_from(GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, - "Wlan message header crc was wrong: %u != %u\n", - getcrc32((char *) wlanheader, ntohs(wlanheader->header.size)), - crc); - hexdump((void *) hdr, ntohs(hdr->size)); - return; - } - - //if not in session list - if (session == NULL) - { -#if DEBUG_wlan - 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)); -#endif - //try if it is a hello message - if (ntohs(wlanheader->header.size) >= ntohs(temp_hdr->size) - + sizeof(struct WlanHeader)) - { - if (ntohs(temp_hdr->type) == GNUNET_MESSAGE_TYPE_HELLO) - { - if (GNUNET_HELLO_get_id( - (const struct GNUNET_HELLO_Message *) temp_hdr, - &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; - } - } - else - { - 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; - } - } - - //"receive" the message - - if (memcmp(&wlanheader->source, &session->target, - sizeof(struct GNUNET_PeerIdentity)) != 0) - { - //wrong peer id -#if DEBUG_wlan - 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); -#endif - return; - } - - if (memcmp(&wlanheader->target, plugin->env->my_identity, - sizeof(struct GNUNET_PeerIdentity)) != 0) - { - //wrong peer id -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "WLAN peer target id doesn't match our peer id: session %p\n", - session); -#endif - return; - } - - GNUNET_SERVER_mst_receive(plugin->data_tokenizer, session, - (const char *) temp_hdr, - 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\n"); - return; - } + const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + char *ret; + + if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen) + { + /* invalid address */ + LOG (GNUNET_ERROR_TYPE_WARNING, + _("WLAN address with invalid size encountered\n")); + asc (asc_cls, NULL); + return; + } + mac = addr; + ret = GNUNET_strdup (mac_to_string (mac)); + asc (asc_cls, ret); + GNUNET_free (ret); + asc (asc_cls, NULL); } -/** - * 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_TRANSPORT_ATS_Information distance[2]; - distance[0].type = htonl(GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); - distance[0].value = htonl(1); - distance[1].type = htonl(GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); - distance[1].value = htonl(0); - -#if DEBUG_wlan - GNUNET_log_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)); -#endif - - plugin->env->receive(plugin->env->cls, &(session->target), hdr, - (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2, session, - (const char*) &session->mac->addr, sizeof(session->mac->addr)); -} /** - * Function used for to process the data received from the wlan interface + * Exit point from the plugin. * - * @param cls the plugin handle - * @param session_light FIXME: document - * @param hdr hdr of the GNUNET_MessageHeader + * @param cls pointer to the api struct */ -static void -wlan_data_helper(void *cls, struct Session_light * session_light, - const struct GNUNET_MessageHeader * hdr, const struct Radiotap_rx * rxinfo) -{ - struct Plugin *plugin = cls; - struct FragmentMessage * fm; - struct FragmentMessage * fm2; - - //ADVERTISEMENT - if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT) - { - - //TODO better DOS protection, error handling - //TODO test first than create session - GNUNET_assert(session_light != NULL); - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT size: %u; %s\n", - ntohs(hdr->size), - wlan_plugin_address_to_string(NULL, session_light->addr.mac, 6)); -#endif - - if (session_light->macendpoint == NULL) - { - session_light->macendpoint = get_macendpoint(plugin, - &session_light->addr, GNUNET_NO); - } - GNUNET_assert(GNUNET_HELLO_get_id( - (const struct GNUNET_HELLO_Message *) &hdr[1], - &(session_light->session->target) ) != GNUNET_SYSERR); - - } - - //FRAGMENT - - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT) - { - - GNUNET_assert(session_light != NULL); - if (session_light->macendpoint == NULL) - { - session_light->macendpoint = get_macendpoint(plugin, - &session_light->addr, GNUNET_YES); - } - -#if DEBUG_wlan - 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)); -#endif - - int ret = GNUNET_DEFRAGMENT_process_fragment( - session_light->macendpoint->defrag, hdr); - if (ret == GNUNET_NO) - { - session_light->macendpoint->dups++; - } - else if (ret == GNUNET_OK) - { - session_light->macendpoint->fragc++; - } - set_next_send(plugin); - - } - - //ACK - - else if (ntohs(hdr->type) == GNUNET_MESSAGE_TYPE_FRAGMENT_ACK) - { - GNUNET_assert(session_light != NULL); - if (session_light->macendpoint == NULL) - { - session_light->macendpoint = get_macendpoint(plugin, - &session_light->addr, GNUNET_NO); - } - - if (session_light->macendpoint == NULL) - { -#if DEBUG_wlan - GNUNET_log_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)); -#endif - return; - } - -#if DEBUG_wlan - 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)); -#endif - fm = session_light->macendpoint->sending_messages_head; - while (fm != NULL) - { - fm2 = fm->next; - int ret = GNUNET_FRAGMENT_process_ack(fm->fragcontext, hdr); - if (ret == GNUNET_OK) - { -#if DEBUG_wlan_retransmission - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Got last ack, finished fragment message %p\n", fm); -#endif - 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) - { -#if DEBUG_wlan_retransmission - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Got ack for: %p\n", fm); -#endif - session_light->macendpoint->acks++; - return; - } - if (ret == GNUNET_SYSERR) - { - - } - - fm = fm2; - } - -#if DEBUG_wlan_retransmission - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "WLAN fragment not in fragment list\n"); -#endif - 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_break(0); - return; - } - -#if 0 - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Helper finished\n"); -#endif - -} - -//TODO DOXIGEN -const char * -macprinter(const u_int8_t * mac) +void * +libgnunet_plugin_transport_wlan_done (void *cls) { - static char macstr[20]; - - GNUNET_snprintf(macstr, sizeof(macstr), "%X:%X:%X:%X:%X:%X", mac[0], mac[1], - mac[2], mac[3], mac[4], mac[5]); - return macstr; -} + struct GNUNET_TRANSPORT_PluginFunctions *api = cls; + struct Plugin *plugin = api->cls; + struct MacEndpoint *endpoint; + struct MacEndpoint *endpoint_next; -/** - * Function for the scheduler if a mac endpoint times out - * @param cls pointer to the MacEndpoint - * @param tc pointer to the GNUNET_SCHEDULER_TaskContext - */ -static void -macendpoint_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc){ - struct MacEndpoint * endpoint = cls; - GNUNET_assert(endpoint != NULL); - endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; - if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN){ - return; + if (NULL == plugin) + { + GNUNET_free (api); + return NULL; } - if (GNUNET_TIME_absolute_get_remaining( - GNUNET_TIME_absolute_add(endpoint->last_activity, MACENDPOINT_TIMEOUT)).rel_value - == 0) - { - free_macendpoint(endpoint->plugin,endpoint); - } - else - { - endpoint->timeout_task = GNUNET_SCHEDULER_add_delayed(MACENDPOINT_TIMEOUT, - &macendpoint_timeout, endpoint); - } + if (GNUNET_SCHEDULER_NO_TASK != plugin->beacon_task) + { + GNUNET_SCHEDULER_cancel (plugin->beacon_task); + plugin->beacon_task = GNUNET_SCHEDULER_NO_TASK; + } + if (NULL != plugin->suid_helper) + { + GNUNET_HELPER_stop (plugin->suid_helper); + plugin->suid_helper = NULL; + } + endpoint_next = plugin->mac_head; + while (NULL != (endpoint = endpoint_next)) + { + endpoint_next = endpoint->next; + free_macendpoint (endpoint); + } + if (NULL != plugin->fragment_data_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->fragment_data_tokenizer); + plugin->fragment_data_tokenizer = NULL; + } + if (NULL != plugin->wlan_header_payload_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->wlan_header_payload_tokenizer); + plugin->wlan_header_payload_tokenizer = NULL; + } + if (NULL != plugin->helper_payload_tokenizer) + { + GNUNET_SERVER_mst_destroy (plugin->helper_payload_tokenizer); + plugin->helper_payload_tokenizer = NULL; + } + GNUNET_free_non_null (plugin->interface); + GNUNET_free (plugin); + GNUNET_free (api); + return NULL; } -/** - * function to create an macendpoint - * @param plugin pointer to the plugin struct - * @param addr pointer to the macaddress - * @return returns a macendpoint - */ -static struct MacEndpoint * -create_macendpoint(struct Plugin *plugin, const struct MacAddress *addr) -{ - struct MacEndpoint * newend = GNUNET_malloc(sizeof (struct MacEndpoint)); - newend->addr = *addr; - newend->plugin = plugin; - newend->addr = *addr; - newend->fragment_messages_out_count = 0; - newend->defrag = GNUNET_DEFRAGMENT_context_create(plugin->env->stats, - WLAN_MTU, MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, newend, - &wlan_data_message_handler, &add_ack_for_send); - newend->last_activity = GNUNET_TIME_absolute_get(); - newend->timeout_task = GNUNET_SCHEDULER_add_delayed(MACENDPOINT_TIMEOUT, - &macendpoint_timeout, newend); - - plugin->mac_count++; - GNUNET_CONTAINER_DLL_insert_tail(plugin->mac_head, plugin->mac_tail, newend); -#if DEBUG_wlan - 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)); -#endif - return newend; -} /** - * Function used for to process the data from the suid process + * Function called to convert a string address to + * a binary address. * - * @param cls the plugin handle - * @param client client that send the data (not used) - * @param hdr header of the GNUNET_MessageHeader + * @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 void -wlan_process_helper(void *cls, void *client, - const struct GNUNET_MessageHeader *hdr) +static int +wlan_string_to_address (void *cls, const char *addr, uint16_t addrlen, + void **buf, size_t *added) { - 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; + struct GNUNET_TRANSPORT_WLAN_MacAddress *mac; + unsigned int a[6]; + unsigned int i; - switch (ntohs(hdr->type)) - { - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA: -#if DEBUG_wlan - 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)); -#endif - - //call wlan_process_helper with the message inside, later with wlan: analyze signal - if (ntohs(hdr->size) < sizeof(struct ieee80211_frame) - + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx)) - { -#if DEBUG_wlan - 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)); -#endif - //GNUNET_break (0); - /* FIXME: restart SUID process */ - return; - } - rxinfo = (struct Radiotap_rx *) &hdr[1]; - wlanIeeeHeader = (struct ieee80211_frame *) &rxinfo[1]; - - //process only if it is an broadcast or for this computer both with the gnunet bssid - - //check for bssid - if (memcmp(&(wlanIeeeHeader->i_addr3), &mac_bssid, - sizeof(struct MacAddress)) == 0) - { - //check for broadcast or mac - if (memcmp(&(wlanIeeeHeader->i_addr1), &bc_all_mac, - sizeof(struct MacAddress) == 0) || memcmp( - &(wlanIeeeHeader->i_addr1), &(plugin->mac_address), - sizeof(struct MacAddress)) == 0) - { - - // process the inner data - - - datasize = ntohs(hdr->size) - sizeof(struct ieee80211_frame) - - sizeof(struct GNUNET_MessageHeader) - - sizeof(struct Radiotap_rx); - - session_light = GNUNET_malloc(sizeof(struct Session_light)); - memcpy(&session_light->addr, &(wlanIeeeHeader->i_addr2), - sizeof(struct MacAddress)); - //session_light->session = search_session(plugin,session_light->addr); - - pos = 0; - while (pos < datasize) - { - temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] - + pos; - - wlan_data_helper(plugin, session_light, temp_hdr, rxinfo); - pos += ntohs(temp_hdr->size); - - } - - //clean up - GNUNET_free(session_light); - } - else - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got wrong MAC: %s\n", - macprinter(wlanIeeeHeader->i_addr1)); -#endif - } - } - else - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Func wlan_process_helper got wrong BSSID: %s\n", - macprinter(wlanIeeeHeader->i_addr2)); -#endif - } - break; - case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: - //TODO more control messages - //TODO use struct wlan_helper_control - if (ntohs(hdr->size) != sizeof(struct Wlan_Helper_Control_Message)) - { - GNUNET_break (0); - /* FIXME: restart SUID process */ - return; - } - memcpy(&plugin->mac_address, &hdr[1], sizeof(struct MacAddress)); -#if DEBUG_wlan - GNUNET_log_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 MacAddress))); -#endif - plugin->env->notify_address(plugin->env->cls, GNUNET_YES, - &plugin->mac_address, sizeof(struct MacAddress)); - break; - default: + if ((NULL == addr) || (addrlen == 0)) + { GNUNET_break (0); - return; - } -} - -/** - * We have been notified that wlan-helper has written something to stdout. - * Handle the output, then reschedule this function to be called again once - * more is available. - * - * @param cls the plugin handle - * @param tc the scheduling context - */ -static void -wlan_plugin_helper_read(void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct Plugin *plugin = cls; - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - - 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) - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - _("Finished reading from wlan-helper stdout with code: %d\n"), - bytes); -#endif - return; - } - GNUNET_SERVER_mst_receive(plugin->suid_tokenizer, NULL, mybuf, bytes, - GNUNET_NO, GNUNET_NO); - - GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK); - plugin->server_read_task = GNUNET_SCHEDULER_add_read_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle, - &wlan_plugin_helper_read, plugin); -} - -/** - * Start the gnunet-wlan-helper process. - * - * @param plugin the transport plugin - * @param testmode should we use the dummy driver for testing? - * @return GNUNET_YES if process was started, GNUNET_SYSERR on error - */ -static int -wlan_transport_start_wlan_helper(struct Plugin *plugin, int testmode) -{ - const char * filenamehw = "gnunet-transport-wlan-helper"; - const char * filenameloopback = "gnunet-transport-wlan-helper-dummy"; - plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_NO, GNUNET_YES); - if (plugin->server_stdout == NULL) return GNUNET_SYSERR; - - plugin->server_stdin = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO); - if (plugin->server_stdin == NULL) + } + if ('\0' != addr[addrlen - 1]) + { + GNUNET_break (0); return GNUNET_SYSERR; - - /* Start the server process */ - - if (testmode == 0) - { - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Starting gnunet-wlan-helper process cmd: %s %s %i\n", filenamehw, - plugin->interface, testmode); -#endif - - plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, - plugin->server_stdout, filenamehw, filenamehw, plugin->interface, - NULL); - } - else if (testmode == 1) - { - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Starting gnunet-wlan-helper loopback 1 process cmd: %s %s %i\n", - filenameloopback, plugin->interface, testmode); -#endif - - plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, - plugin->server_stdout, filenameloopback, filenameloopback, "1", NULL); - } - else if (testmode == 2) - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Starting gnunet-wlan-helper loopback 2 process cmd: %s %s %i\n", - filenameloopback, plugin->interface, testmode); -#endif - plugin->server_proc = GNUNET_OS_start_process(plugin->server_stdin, - plugin->server_stdout, filenameloopback, filenameloopback, "2", NULL); - } - if (plugin->server_proc == NULL) - { -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Failed to start gnunet-wlan-helper process\n"); -#endif - return GNUNET_SYSERR; - } - - /* Close the write end of the read pipe */ - GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE); - - /* Close the read end of the write pipe */ - GNUNET_DISK_pipe_close_end(plugin->server_stdin, GNUNET_DISK_PIPE_END_READ); - - plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, - GNUNET_DISK_PIPE_END_READ); - plugin->server_stdin_handle = GNUNET_DISK_pipe_handle(plugin->server_stdin, - GNUNET_DISK_PIPE_END_WRITE); - - GNUNET_assert(plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK); - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "Adding server_read_task for the wlan-helper\n"); -#endif - - plugin->server_read_task = GNUNET_SCHEDULER_add_read_file( - GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdout_handle, - &wlan_plugin_helper_read, plugin); - - return GNUNET_YES; + } + 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; } -/** - * 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_next; - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, - "libgnunet_plugin_transport_wlan_done started\n"); -#endif - - GNUNET_DISK_pipe_close(plugin->server_stdout); - GNUNET_DISK_pipe_close(plugin->server_stdin); - GNUNET_OS_process_kill(plugin->server_proc, 9); - GNUNET_OS_process_close(plugin->server_proc); - - GNUNET_assert (cls !=NULL); - //free sessions - while (endpoint != NULL) - { - endpoint_next = endpoint->next; - free_macendpoint(plugin, endpoint); - endpoint = endpoint_next; - - } - if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(plugin->server_write_delay_task); - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - } - if (plugin->server_write_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(plugin->server_write_task); - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - } - if (plugin->server_read_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(plugin->server_read_task); - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - } - - if (plugin->suid_tokenizer != NULL) - GNUNET_SERVER_mst_destroy(plugin->suid_tokenizer); - - 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; -} /** * Entry point for the plugin. @@ -2764,70 +1633,121 @@ libgnunet_plugin_transport_wlan_done(void *cls) * @return the 'struct GNUNET_TRANSPORT_PluginFunctions*' or NULL on error */ void * -libgnunet_plugin_transport_wlan_init(void *cls) +libgnunet_plugin_transport_wlan_init (void *cls) { - //struct GNUNET_SERVICE_Context *service; struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; struct GNUNET_TRANSPORT_PluginFunctions *api; struct Plugin *plugin; - static unsigned long long testmode = 0; + 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; + } - GNUNET_assert(cls !=NULL); + testmode = 0; + /* check configuration */ + if ( (GNUNET_YES == + GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "TESTMODE")) && + ( (GNUNET_SYSERR == + GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-wlan", + "TESTMODE", &testmode)) || + (testmode > 2) ) ) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Invalid configuration option `%s' in section `%s'\n"), + "TESTMODE", + "transport-wlan"); + return NULL; + } + if ( (0 == testmode) && + (GNUNET_YES != GNUNET_OS_check_helper_binary ("gnunet-helper-transport-wlan")) ) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Helper binary `%s' not SUID, cannot run WLAN transport\n"), + "gnunet-helper-transport-wlan"); + return NULL; + } + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_string + (env->cfg, "transport-wlan", "INTERFACE", + &interface)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Missing configuration option `%s' in section `%s'\n"), + "INTERFACE", + "transport-wlan"); + return NULL; + } plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin->interface = interface; plugin->env = env; - plugin->pendingsessions = 0; - plugin->mac_count = 0; - plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; - plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; - plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_BANDWIDTH_tracker_init(&plugin->tracker, - GNUNET_BANDWIDTH_value_init(100 * 1024 * 1024 / 8), 100); - - plugin->suid_tokenizer = GNUNET_SERVER_mst_create(&wlan_process_helper, - plugin); - - 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)); + GNUNET_STATISTICS_set (plugin->env->stats, _("# WLAN sessions allocated"), + 0, GNUNET_NO); + GNUNET_STATISTICS_set (plugin->env->stats, _("# WLAN MAC endpoints allocated"), + 0, 0); + GNUNET_BANDWIDTH_tracker_init (&plugin->tracker, + GNUNET_BANDWIDTH_value_init (100 * 1024 * + 1024 / 8), 100); + plugin->fragment_data_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->wlan_header_payload_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->helper_payload_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin); + plugin->beacon_task = GNUNET_SCHEDULER_add_now (&send_hello_beacon, + plugin); + switch (testmode) + { + case 0: /* normal */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan"; + plugin->helper_argv[1] = interface; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + case 1: /* testmode, peer 1 */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy"; + plugin->helper_argv[1] = (char *) "1"; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + case 2: /* testmode, peer 2 */ + plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy"; + plugin->helper_argv[1] = (char *) "2"; + plugin->helper_argv[2] = NULL; + plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy", + plugin->helper_argv, + &handle_helper_message, + plugin); + break; + default: + GNUNET_assert (0); + } api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); api->cls = plugin; api->send = &wlan_plugin_send; + api->get_session = &wlan_plugin_get_session; api->disconnect = &wlan_plugin_disconnect; api->address_pretty_printer = &wlan_plugin_address_pretty_printer; api->check_address = &wlan_plugin_address_suggested; api->address_to_string = &wlan_plugin_address_to_string; - //read config - - if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "TESTMODE")) - { - if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(env->cfg, - "transport-wlan", "TESTMODE", &testmode)) - testmode = 0; //default value - } - - if (GNUNET_CONFIGURATION_have_value(env->cfg, "transport-wlan", "INTERFACE")) - { - if (GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-wlan", - "INTERFACE", &(plugin->interface)) != GNUNET_YES) - { - libgnunet_plugin_transport_wlan_done(api); - return NULL; - } - } - - //start the plugin - set_next_beacon_time(plugin); - - wlan_transport_start_wlan_helper(plugin, testmode); - -#if DEBUG_wlan - GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "wlan init finished\n"); -#endif - + api->string_to_address = &wlan_string_to_address; return api; } + /* end of plugin_transport_wlan.c */