/* 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. */ /** * @file transport/plugin_transport_wlan.c * @brief transport plugin for wlan * @author David Brodski */ //TODO split rx and tx structures for better handling #include "platform.h" #include "gnunet_hello_lib.h" #include "gnunet_protocols.h" #include "gnunet_util_lib.h" #include "gnunet_statistics_service.h" #include "gnunet_transport_service.h" #include "gnunet_transport_plugin.h" #include "plugin_transport_wlan.h" #include "gnunet_common.h" #include "gnunet_crypto_lib.h" #include "gnunet_fragmentation_lib.h" #include "gnunet_constants.h" //#include "wlan/ieee80211.h" //#include #include #define PROTOCOL_PREFIX "wlan" #define PLUGIN_LOG_NAME "wlan-plugin" /** * Max size of packet */ #define WLAN_MTU 1430 /** * time out of a session */ #define SESSION_TIMEOUT GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT /** * time out of a mac endpoint */ #define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2) /** * scaling factor for hello beacon */ #define HELLO_BEACON_SCALING_FACTOR 30 /** * max size of fragment queue */ #define FRAGMENT_QUEUE_SIZE 10 /** * max messages in fragment queue per session/client */ #define FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION 1 /** * max messages in fragment queue per MAC */ #define FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT 1 /** * max messages in in queue */ #define MESSAGES_IN_QUEUE_SIZE 10 /** * max messages in in queue per session/client */ #define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 1 /** * LLC fields for better compatibility */ #define WLAN_LLC_DSAP_FIELD 0xf #define WLAN_LLC_SSAP_FIELD 0xf /** * DEBUG switch */ #define DEBUG_wlan GNUNET_EXTRA_LOGGING #define DEBUG_wlan_retransmission GNUNET_EXTRA_LOGGING #define DEBUG_wlan_ip_udp_packets_on_air GNUNET_NO #define DEBUG_wlan_msg_dump GNUNET_EXTRA_LOGGING #define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ #define IEEE80211_FC0_VERSION_MASK 0x03 #define IEEE80211_FC0_VERSION_SHIFT 0 #define IEEE80211_FC0_VERSION_0 0x00 #define IEEE80211_FC0_TYPE_MASK 0x0c #define IEEE80211_FC0_TYPE_SHIFT 2 #define IEEE80211_FC0_TYPE_MGT 0x00 #define IEEE80211_FC0_TYPE_CTL 0x04 #define IEEE80211_FC0_TYPE_DATA 0x08 /* * Structure of an internet header, naked of options. */ struct iph { #if __BYTE_ORDER == __LITTLE_ENDIAN unsigned int ip_hl:4; /* header length */ unsigned int ip_v:4; /* version */ #endif #if __BYTE_ORDER == __BIG_ENDIAN unsigned int ip_v:4; /* version */ unsigned int ip_hl:4; /* header length */ #endif u_int8_t ip_tos; /* type of service */ u_short ip_len; /* total length */ u_short ip_id; /* identification */ u_short ip_off; /* fragment offset field */ #define IP_RF 0x8000 /* reserved fragment flag */ #define IP_DF 0x4000 /* dont fragment flag */ #define IP_MF 0x2000 /* more fragments flag */ #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */ u_int8_t ip_ttl; /* time to live */ u_int8_t ip_p; /* protocol */ u_short ip_sum; /* checksum */ struct in_addr ip_src, ip_dst; /* source and dest address */ }; struct udphdr { u_int16_t source; u_int16_t dest; u_int16_t len; u_int16_t check; }; /* * generic definitions for IEEE 802.11 frames */ struct ieee80211_frame { u_int8_t i_fc[2]; u_int8_t i_dur[2]; u_int8_t i_addr1[IEEE80211_ADDR_LEN]; u_int8_t i_addr2[IEEE80211_ADDR_LEN]; u_int8_t i_addr3[IEEE80211_ADDR_LEN]; u_int8_t i_seq[2]; u_int8_t llc[4]; #if DEBUG_wlan_ip_udp_packets_on_air > 1 struct iph ip; struct udphdr udp; #endif } GNUNET_PACKED; /** * Encapsulation of all of the state of the plugin. */ struct Plugin { /** * Our environment. */ struct GNUNET_TRANSPORT_PluginEnvironment *env; /** * List of open connections. head */ struct MacEndpoint *mac_head; /** * List of open connections. tail */ struct MacEndpoint *mac_tail; /** * Number of connections */ unsigned int mac_count; /** * encapsulation of data from the local wlan helper program */ struct GNUNET_SERVER_MessageStreamTokenizer *suid_tokenizer; /** * encapsulation of packets received from the wlan helper */ struct GNUNET_SERVER_MessageStreamTokenizer *data_tokenizer; /** * stdout pipe handle for the gnunet-wlan-helper process */ struct GNUNET_DISK_PipeHandle *server_stdout; /** * stdout file handle for the gnunet-wlan-helper process */ const struct GNUNET_DISK_FileHandle *server_stdout_handle; /** * stdin pipe handle for the gnunet-wlan-helper process */ struct GNUNET_DISK_PipeHandle *server_stdin; /** * stdin file handle for the gnunet-wlan-helper process */ const struct GNUNET_DISK_FileHandle *server_stdin_handle; /** * ID of the gnunet-wlan-server std read task */ GNUNET_SCHEDULER_TaskIdentifier server_read_task; /** * ID of the gnunet-wlan-server std read task */ GNUNET_SCHEDULER_TaskIdentifier server_write_task; /** * ID of the delay task for writing */ GNUNET_SCHEDULER_TaskIdentifier server_write_delay_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; /** * The mac_address of the wlan card given to us by the helper. */ struct MacAddress mac_address; /** * Sessions currently pending for transmission * to a peer, if any. */ struct Sessionqueue *pending_Sessions_head; /** * Sessions currently pending for transmission * to a peer (tail), if any. */ struct Sessionqueue *pending_Sessions_tail; /** * number of pending sessions */ unsigned int pendingsessions; /** * Messages in the sending queues */ int pending_Fragment_Messages; /** * 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" */ struct GNUNET_TIME_Absolute beacon_time; /** * queue to send acks for received fragments (head) */ struct AckSendQueue *ack_send_queue_head; /** * queue to send acks for received fragments (tail) */ struct AckSendQueue *ack_send_queue_tail; /** * Tracker for bandwidth limit */ struct GNUNET_BANDWIDTH_Tracker tracker; }; /** * 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 */ //TODO DOXIGEN struct FragmentMessage_queue { struct FragmentMessage_queue *next; struct FragmentMessage_queue *prev; struct FragmentMessage *content; }; /** * Queue for the fragments received */ //TODO DOXIGEN struct Receive_Fragment_Queue { struct Receive_Fragment_Queue *next; struct Receive_Fragment_Queue *prev; uint16_t num; const char *msg; uint16_t size; struct Radiotap_rx rxinfo; }; //TODO DOXIGEN struct MacEndpoint_id_fragment_triple { struct MacEndpoint *endpoint; uint32_t message_id; struct FragmentMessage *fm; }; //TODO DOXIGEN struct Plugin_Session_pair { struct Plugin *plugin; struct Session *session; }; /** * Information kept for each message that is yet to * be transmitted. */ struct PendingMessage { /** * dll next */ struct PendingMessage *next; /** * dll prev */ struct PendingMessage *prev; /** * The pending message */ struct WlanHeader *msg; /** * Size of the message */ size_t message_size; /** * Continuation function to call once the message * has been sent. Can be NULL if there is no * continuation to call. */ GNUNET_TRANSPORT_TransmitContinuation transmit_cont; /** * Cls for transmit_cont */ void *transmit_cont_cls; /** * Timeout value for the pending message. */ struct GNUNET_TIME_Absolute timeout; }; /** * Queue for acks to send for fragments recived */ struct AckSendQueue { /** * 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. */ uint32_t message_id; /** * msg to send */ struct GNUNET_MessageHeader *hdr; /** * pointer to the ieee wlan header */ struct ieee80211_frame *ieeewlanheader; /** * pointer to the radiotap header */ struct Radiotap_Send *radioHeader; }; /** * Session infos gathered from a messages */ struct Session_light { /** * the session this message belongs to */ struct Session *session; /** * peer mac address */ struct MacAddress addr; /** * mac endpoint */ struct MacEndpoint *macendpoint; }; /** * Session handle for connections. */ struct Session { /** * API requirement. */ struct SessionHeader header; /** * Message currently pending for transmission * to this peer, if any. head */ struct PendingMessage *pending_message_head; /** * Message currently pending for transmission * to this peer, if any. tail */ struct PendingMessage *pending_message_tail; /** * To whom are we talking to (set to our identity * if we are still waiting for the welcome message) */ struct GNUNET_PeerIdentity target; /** * Address of the other peer (either based on our 'connect' * call or on our 'accept' call). */ void *connect_addr; /** * Last activity on this connection. Used to select preferred * connection and timeout */ struct GNUNET_TIME_Absolute last_activity; /** * Timeout task. */ GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** * peer connection */ struct MacEndpoint *mac; /** * count of messages in the fragment out queue for this session */ int fragment_messages_out_count; }; /** * Struct to represent one network card connection */ struct MacEndpoint { /** * Pointer to the global plugin struct. */ struct Plugin *plugin; /** * Struct to hold the session reachable over this mac; head */ struct Sessionqueue *sessions_head; /** * Struct to hold the session reachable over this mac; tail */ struct Sessionqueue *sessions_tail; /** * Messages currently sending * to a peer, if any. */ struct FragmentMessage *sending_messages_head; /** * Messages currently sending * to a peer (tail), if any. */ struct FragmentMessage *sending_messages_tail; /** * dll next */ struct MacEndpoint *next; /** * dll prev */ struct MacEndpoint *prev; /** * peer mac address */ struct MacAddress addr; /** * Defrag context for this mac endpoint */ struct GNUNET_DEFRAGMENT_Context *defrag; /** * count of messages in the fragment out queue for this mac endpoint */ int fragment_messages_out_count; //TODO DOXIGEN uint8_t rate; uint16_t tx_power; uint8_t antenna; /** * Duplicates received */ int dups; /** * Fragments received */ int fragc; /** * Acks received */ int acks; /** * Last activity on this endpoint. Used to select preferred * connection. */ struct GNUNET_TIME_Absolute last_activity; /** * Timeout task. */ GNUNET_SCHEDULER_TaskIdentifier timeout_task; }; /** * Struct for Messages in the fragment queue */ struct FragmentMessage { /** * Session this message belongs to */ struct Session *session; /** * This is a doubly-linked list. */ struct FragmentMessage *next; /** * This is a doubly-linked list. */ struct FragmentMessage *prev; /** * Fragmentation context */ struct GNUNET_FRAGMENT_Context *fragcontext; /** * Timeout value for the message. */ struct GNUNET_TIME_Absolute timeout; /** * Timeout task. */ GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** * Fragment to send */ char *frag; /** * size of message */ size_t size; /** * pointer to the ieee wlan header */ struct ieee80211_frame *ieeewlanheader; /** * pointer to the radiotap header */ struct Radiotap_Send *radioHeader; }; 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. * * \param mem pointer to memory to dump * \param length how many bytes to dump */ static void hexdump (const void *mem, unsigned length) { char line[80]; char *src = (char *) mem; printf ("dumping %u bytes from %p\r\n" " 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF\r\n", length, src); unsigned i; int j; for (i = 0; i < length; i += 16, src += 16) { char *t = line; t += sprintf (t, "%04x: ", i); for (j = 0; j < 16; j++) { if (i + j < length) t += sprintf (t, "%02X", src[j] & 0xff); else t += sprintf (t, " "); t += sprintf (t, j % 2 ? " " : "-"); } t += sprintf (t, " "); for (j = 0; j < 16; j++) { if (i + j < length) { if (isprint ((unsigned char) src[j])) t += sprintf (t, "%c", src[j]); else t += sprintf (t, "."); } else { t += sprintf (t, " "); } } t += sprintf (t, "\r\n"); printf ("%s", line); } } /** * Function to find a MacEndpoint with a specific mac addr * @param plugin pointer to the plugin struct * @param addr pointer to the mac address * @param create_new GNUNET_YES if a new end point should be created * @return */ static struct MacEndpoint * get_macendpoint (struct Plugin *plugin, const struct MacAddress *addr, int create_new) { 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); } else { return NULL; } } /** * search for a session with the macendpoint and peer id * * @param plugin pointer to the plugin struct * @param endpoint pointer to the mac endpoint of the peer * @param peer pointer to the peerid * @return returns the session */ static struct Session * search_session (struct Plugin *plugin, const struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer) { GNUNET_assert (endpoint != NULL); struct Sessionqueue *queue = endpoint->sessions_head; while (queue != NULL) { GNUNET_assert (queue->content != NULL); if (memcmp (peer, &queue->content->target, sizeof (struct GNUNET_PeerIdentity)) == 0) return queue->content; /* session found */ queue = queue->next; } return NULL; } /** * Function called for a quick conversion of the binary address to * a numeric address. Note that the caller must not free the * address and that the next call to this function is allowed * to override the address again. * * @param cls closure * @param addr binary address * @param addrlen length of the address * @return string representing the same address */ static const char * wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) { static char ret[40]; const struct MacAddress *mac; if (addrlen != sizeof (struct MacAddress)) { GNUNET_break (0); return NULL; } mac = addr; GNUNET_snprintf (ret, sizeof (ret), "%s Mac-Address %X:%X:%X:%X:%X:%X", PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], mac->mac[3], mac->mac[4], mac->mac[5]); return ret; } /** * Function for the scheduler if a session times out * @param cls pointer to the Sessionqueue * @param tc pointer to the GNUNET_SCHEDULER_TaskContext */ static void session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct Sessionqueue *queue = cls; GNUNET_assert (queue != NULL); GNUNET_assert(queue->content != NULL); queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK; if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) { return; } if (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (queue->content->last_activity, SESSION_TIMEOUT)).rel_value == 0) { GNUNET_assert(queue->content->mac != NULL); GNUNET_assert(queue->content->mac->plugin != NULL); GNUNET_STATISTICS_update (queue->content->mac->plugin->env->stats, _("# wlan session timeouts"), 1, GNUNET_NO); free_session (queue->content->mac->plugin, queue, GNUNET_YES); } else { queue->content->timeout_task = GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue); } } /** * create a new session * * @param plugin pointer to the plugin struct * @param endpoint pointer to the mac endpoint of the peer * @param peer peer identity to use for this session * @return returns the session */ static struct Session * create_session (struct Plugin *plugin, struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer) { GNUNET_assert (endpoint != NULL); GNUNET_assert (plugin != NULL); GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan session created"), 1, GNUNET_NO); struct Sessionqueue *queue = GNUNET_malloc (sizeof (struct Sessionqueue) + sizeof (struct Session)); GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head, endpoint->sessions_tail, queue); queue->content = (struct Session *) &queue[1]; queue->content->mac = endpoint; 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; } /** * Get session from address, create if no session exists * * @param plugin pointer to the plugin struct * @param addr pointer to the mac address of the peer * @param peer pointer to the peerid * @return returns the session */ static struct Session * get_session (struct Plugin *plugin, const struct MacAddress *addr, const struct GNUNET_PeerIdentity *peer) { struct MacEndpoint *mac; mac = get_macendpoint (plugin, addr, GNUNET_YES); struct Session *session = search_session (plugin, mac, peer); if (session != NULL) return session; return create_session (plugin, mac, peer); } /** * Queue the session to send data * checks if there is a message pending * checks if this session is not allready in the queue * @param plugin pointer to the plugin * @param session pointer to the session to add */ static void queue_session (struct Plugin *plugin, struct Session *session) { struct Sessionqueue *queue = plugin->pending_Sessions_head; if (session->pending_message_head != NULL) { while (queue != NULL) { // content is never NULL GNUNET_assert (queue->content != NULL); // is session already in queue? if (session == queue->content) { return; } // try next queue = queue->next; } // Session is not in the queue queue = GNUNET_malloc (sizeof (struct Sessionqueue)); queue->content = session; //insert at the tail GNUNET_CONTAINER_DLL_insert_tail (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, queue); plugin->pendingsessions++; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); } } /** * Function to schedule the write task, executed after a delay * @param cls pointer to the plugin struct * @param tc GNUNET_SCHEDULER_TaskContext pointer */ static void delay_fragment_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { 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); } } /** * Function to calculate the time of the next periodic "hello-beacon" * @param plugin pointer to the plugin struct */ static void set_next_beacon_time (struct Plugin *const plugin) { //under 10 known peers: once a second if (plugin->mac_count < 10) { plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, HELLO_BEACON_SCALING_FACTOR)); } //under 30 known peers: every 10 seconds else if (plugin->mac_count < 30) { plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10 * HELLO_BEACON_SCALING_FACTOR)); } //over 30 known peers: once a minute else { plugin->beacon_time = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, HELLO_BEACON_SCALING_FACTOR)); } } /** * Function to set the timer for the next timeout of the fragment queue * @param plugin the handle to the plugin struct */ static void set_next_send (struct Plugin *const plugin) { struct GNUNET_TIME_Relative next_send; //cancel old task if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) { GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task); plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; } //check if some acks are in the queue if (plugin->ack_send_queue_head != NULL) { next_send = GNUNET_TIME_UNIT_ZERO; } //check if there are some fragments in the queue else if (plugin->sending_messages_head != NULL) { next_send = GNUNET_TIME_UNIT_ZERO; } else { next_send = GNUNET_TIME_absolute_get_remaining (plugin->beacon_time); } #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Next packet is send in: %u\n", next_send.rel_value); #endif if (next_send.rel_value == GNUNET_TIME_UNIT_ZERO.rel_value) { if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) { plugin->server_write_task = GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, &do_transmit, plugin); } } else { if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK) { plugin->server_write_delay_task = GNUNET_SCHEDULER_add_delayed (next_send, &delay_fragment_task, plugin); } } } /** * Function to get the next queued Session, removes the session from the queue * @param plugin pointer to the plugin struct * @return pointer to the session found, returns NULL if there is now session in the queue */ static struct Session * get_next_queue_session (struct Plugin *plugin) { struct Session *session; struct Sessionqueue *sessionqueue; struct Sessionqueue *sessionqueue_alt; struct PendingMessage *pm; sessionqueue = plugin->pending_Sessions_head; while (sessionqueue != NULL) { session = sessionqueue->content; GNUNET_assert (session != NULL); pm = session->pending_message_head; if (pm == NULL) { #if DEBUG_wlan GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, "pending message is empty, should not happen. session %p\n", session); #endif sessionqueue_alt = sessionqueue; sessionqueue = sessionqueue->next; plugin->pendingsessions--; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, sessionqueue_alt); GNUNET_free (sessionqueue_alt); continue; } //check for message timeout if (GNUNET_TIME_absolute_get_remaining (pm->timeout).rel_value > 0) { //check if session has no message in the fragment queue if ((session->mac->fragment_messages_out_count < FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT) && (session->fragment_messages_out_count < FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION)) { plugin->pendingsessions--; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, sessionqueue); GNUNET_free (sessionqueue); return session; } else { sessionqueue = sessionqueue->next; } } else { GNUNET_CONTAINER_DLL_remove (session->pending_message_head, session->pending_message_tail, pm); //call the cont func that it did not work if (pm->transmit_cont != NULL) pm->transmit_cont (pm->transmit_cont_cls, &(session->target), GNUNET_SYSERR); GNUNET_free (pm->msg); GNUNET_free (pm); if (session->pending_message_head == NULL) { sessionqueue_alt = sessionqueue; sessionqueue = sessionqueue->next; plugin->pendingsessions--; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, sessionqueue_alt); GNUNET_free (sessionqueue_alt); } } } return NULL; } /** * frees the space of a message in the fragment queue (send queue) * @param plugin the plugin struct * @param fm message to free */ static void free_fragment_message (struct Plugin *plugin, struct FragmentMessage *fm) { struct Session *session = fm->session; struct MacEndpoint *endpoint = session->mac; struct FragmentMessage_queue *fmq; struct FragmentMessage_queue *fmq_next; if (fm != NULL) { 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 } } /** * function to fill the radiotap header * @param plugin pointer to the plugin struct * @param endpoint pointer to the endpoint * @param header pointer to the radiotap header * @return GNUNET_YES at success */ static int getRadiotapHeader (struct Plugin *plugin, struct MacEndpoint *endpoint, struct Radiotap_Send *header) { if (endpoint != NULL) { header->rate = endpoint->rate; header->tx_power = endpoint->tx_power; header->antenna = endpoint->antenna; } else { header->rate = 255; header->tx_power = 0; header->antenna = 0; } return GNUNET_YES; } /** * function to generate the wlan hardware header for one packet * @param Header address to write the header to * @param to_mac_addr address of the recipient * @param plugin pointer to the plugin struct * @param size size of the whole packet, needed to calculate the time to send the packet * @return GNUNET_YES if there was no error */ static int getWlanHeader (struct ieee80211_frame *Header, const struct MacAddress *to_mac_addr, struct Plugin *plugin, unsigned int size) { uint16_t *tmp16; const int rate = 11000000; Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA; Header->i_fc[1] = 0x00; memcpy (&Header->i_addr3, &mac_bssid, 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); Header->llc[0] = WLAN_LLC_DSAP_FIELD; Header->llc[1] = WLAN_LLC_SSAP_FIELD; #if DEBUG_wlan_ip_udp_packets_on_air > 1 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->udp.len = htons (size - sizeof (struct ieee80211_frame)); #endif return GNUNET_YES; } /** * 32bit CRC * * @param msgbuf pointer tor the data * @param msgbuf_size size of the data * * @return 32bit crc value */ uint32_t getcrc32 (const char *msgbuf, size_t msgbuf_size) { return GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size);; } /** * 16bit CRC * * @param msgbuf pointer tor the data * @param msgbuf_size size of the data * * @return 16bit crc value */ uint16_t getcrc16 (const char *msgbuf, size_t msgbuf_size) { //TODO calc some crc return 0; } /** * function to 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 > 1 GNUNET_loHELLO_BEACON_SCALING_FACTORg_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Adding fragment of message %p to send, session %p, endpoint %p, type %u\n", fm, fm->session, endpoint, hdr->type); #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 hello beacon * @param plugin pointer to the plugin struct */ static void send_hello_beacon (struct Plugin *plugin) { #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 hello_size; struct GNUNET_MessageHeader *msgheader; struct ieee80211_frame *ieeewlanheader; struct Radiotap_Send *radioHeader; struct GNUNET_MessageHeader *msgheader2; const struct GNUNET_MessageHeader *hello; GNUNET_assert (plugin != NULL); GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan hello beacons send"), 1, GNUNET_NO); hello = plugin->env->get_our_hello (); hello_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello); GNUNET_assert (sizeof (struct WlanHeader) + hello_size <= WLAN_MTU); size = sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + sizeof (struct ieee80211_frame) + hello_size; msgheader = GNUNET_malloc (size); msgheader->size = htons (size); msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); radioHeader = (struct Radiotap_Send *) &msgheader[1]; getRadiotapHeader (plugin, NULL, radioHeader); ieeewlanheader = (struct ieee80211_frame *) &radioHeader[1]; getWlanHeader (ieeewlanheader, &bc_all_mac, plugin, size); msgheader2 = (struct GNUNET_MessageHeader *) &ieeewlanheader[1]; /*msgheader2->size = htons (GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello) + sizeof (struct GNUNET_MessageHeader)); msgheader2->type = htons (GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT);*/ memcpy (msgheader2, hello, hello_size); bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, msgheader, size); if (bytes == GNUNET_SYSERR) { GNUNET_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); 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 > 1 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) { session = get_next_queue_session (plugin); if (session != NULL) { pm = session->pending_message_head; GNUNET_assert (pm != NULL); GNUNET_CONTAINER_DLL_remove (session->pending_message_head, session->pending_message_tail, pm); session->mac->fragment_messages_out_count++; session->fragment_messages_out_count++; plugin->pending_Fragment_Messages++; 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); } } } //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 GNUNET_assert (plugin != NULL); GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks send"), 1, GNUNET_NO); getRadiotapHeader (plugin, ack->endpoint, ack->radioHeader); getWlanHeader (ack->ieeewlanheader, &ack->endpoint->addr, plugin, ntohs (ack->hdr->size)); bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, ack->hdr, ntohs (ack->hdr->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); 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_free (finish->msgstart); GNUNET_free (finish); return; } bytes = GNUNET_DISK_file_write (plugin->server_stdin_handle, finish->msgheader, finish->size); GNUNET_assert (bytes != GNUNET_SYSERR); if (bytes != finish->size) { finish->msgheader = finish->msgheader + bytes; finish->size = finish->size - bytes; plugin->server_write_task = GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, &finish_sending, finish); } else { GNUNET_free (finish->msgstart); GNUNET_free (finish); set_next_send (plugin); } } /** * 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; GNUNET_assert (plugin != NULL); plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) return; struct Session *session; struct FragmentMessage *fm; struct Finish_send *finish; struct FragmentMessage_queue *fmq; struct AckSendQueue *ack; ssize_t bytes; if (plugin->ack_send_queue_head != NULL) { ack = plugin->ack_send_queue_head; GNUNET_CONTAINER_DLL_remove (plugin->ack_send_queue_head, plugin->ack_send_queue_tail, ack); send_ack (plugin, ack); GNUNET_free (ack); return; } //test if a "hello-beacon" has to be send if (GNUNET_TIME_absolute_get_remaining (plugin->beacon_time).rel_value == 0) { send_hello_beacon (plugin); return; } if (plugin->sending_messages_head != NULL) { GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan fragments send"), 1, GNUNET_NO); fmq = plugin->sending_messages_head; fm = fmq->content; GNUNET_CONTAINER_DLL_remove (plugin->sending_messages_head, plugin->sending_messages_tail, fmq); GNUNET_free (fmq); session = fm->session; GNUNET_assert (session != NULL); #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)); //TODO START NEW WLAN HELPER /* * alle sessions beenden * neu starten (alle 5 sec) * alles bis dahin ablehnen */ } //GNUNET_assert (bytes != GNUNET_SYSERR); if (bytes != fm->size) { finish = GNUNET_malloc (sizeof (struct Finish_send)); finish->plugin = plugin; finish->msgheader = fm->frag + bytes; finish->size = fm->size - bytes; finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag; GNUNET_assert (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); plugin->server_write_task = GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, plugin->server_stdin_handle, &finish_sending, finish); fm->frag = NULL; } else { GNUNET_free (fm->frag); fm->frag = NULL; set_next_send (plugin); } GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); return; } GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, "do_transmit did nothing, should not happen!\n"); } /** * Another peer has suggested an address for this * peer and transport plugin. Check that this could be a valid * address. If so, consider adding it to the list * of addresses. * * @param cls closure * @param addr pointer to the address * @param addrlen length of addr * @return GNUNET_OK if this is a plausible address for this peer * and transport */ static int wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) { //struct Plugin *plugin = cls; /* check if the address is plausible; if so, * add it to our list! */ GNUNET_assert (cls != NULL); //FIXME mitm is not checked //Mac Address has 6 bytes if (addrlen == 6) { /* TODO check for bad addresses like multicast, broadcast, etc */ #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "wlan_plugin_address_suggested got good address, size %u!\n", addrlen); #endif return GNUNET_OK; } #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "wlan_plugin_address_suggested got bad address, size %u!\n", addrlen); #endif 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; GNUNET_assert (plugin != NULL); //check if msglen > 0 GNUNET_assert (msgbuf_size > 0); //get session if needed if (session == NULL) { if (wlan_plugin_address_suggested (plugin, addr, addrlen) == GNUNET_OK) { session = get_session (plugin, addr, target); } else { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, _("Wlan Address len %d is wrong\n"), addrlen); return -1; } } GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan messages queued"), 1, GNUNET_NO); //queue message: //queue message in session //test if there is no other message in the "queue" //FIXME: to many send requests if (session->pending_message_head != NULL) { newmsg = session->pending_message_head; GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n", GNUNET_TIME_absolute_get_remaining (newmsg-> timeout).rel_value, session->mac->fragment_messages_out_count); } newmsg = GNUNET_malloc (sizeof (struct PendingMessage)); newmsg->msg = GNUNET_malloc (msgbuf_size + sizeof (struct WlanHeader)); wlanheader = newmsg->msg; //copy msg to buffer, not fragmented / segmented yet, but with message header 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 #if DEBUG_wlan_msg_dump > 1 hexdump (msgbuf, GNUNET_MIN (msgbuf_size, 256)); #endif //queue session queue_session (plugin, session); check_fragment_queue (plugin); //FIXME not the correct size return msgbuf_size; } /** * function to free a mac endpoint * @param plugin pointer to the plugin struct * @param endpoint pointer to the MacEndpoint to free */ static void free_macendpoint (struct Plugin *plugin, struct MacEndpoint *endpoint) { struct Sessionqueue *sessions; struct Sessionqueue *sessions_next; GNUNET_assert (endpoint != NULL); sessions = endpoint->sessions_head; while (sessions != NULL) { sessions_next = sessions->next; free_session (plugin, sessions, GNUNET_NO); sessions = sessions_next; } GNUNET_CONTAINER_DLL_remove (plugin->mac_head, plugin->mac_tail, endpoint); if (endpoint->timeout_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (endpoint->timeout_task); GNUNET_free (endpoint); } /** * function to free a session * @param plugin pointer to the plugin * @param queue pointer to the sessionqueue element to free * @param free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint */ static void free_session (struct Plugin *plugin, struct Sessionqueue *queue, int do_free_macendpoint) { struct Sessionqueue *pendingsession; struct Sessionqueue *pendingsession_tmp; struct PendingMessage *pm; struct MacEndpoint *endpoint; struct FragmentMessage *fm; struct FragmentMessage *fmnext; int check = 0; GNUNET_assert (plugin != NULL); GNUNET_assert (queue != NULL); GNUNET_assert (queue->content != NULL); //session found //is this session pending for send pendingsession = plugin->pending_Sessions_head; while (pendingsession != NULL) { pendingsession_tmp = pendingsession; pendingsession = pendingsession->next; GNUNET_assert (pendingsession_tmp->content != NULL); if (pendingsession_tmp->content == queue->content) { plugin->pendingsessions--; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, plugin->pending_Sessions_tail, pendingsession_tmp); GNUNET_free (pendingsession_tmp); GNUNET_assert (check == 0); check = 1; } } endpoint = queue->content->mac; fm = endpoint->sending_messages_head; while (fm != NULL) { fmnext = fm->next; if (fm->session == queue->content) { free_fragment_message (plugin, fm); } fm = fmnext; } // remove PendingMessage pm = queue->content->pending_message_head; while (pm != NULL) { GNUNET_CONTAINER_DLL_remove (queue->content->pending_message_head, queue->content->pending_message_tail, pm); GNUNET_free (pm->msg); GNUNET_free (pm); pm = queue->content->pending_message_head; } GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, endpoint->sessions_tail, queue); //Check that no ohter session on this endpoint for this session exits GNUNET_assert(search_session(plugin, endpoint, &queue->content->target) == NULL); if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES) { free_macendpoint (plugin, endpoint); //check if no endpoint with the same address exists GNUNET_assert(get_macendpoint(plugin, &endpoint->addr, GNUNET_NO) == NULL); } if (queue->content->timeout_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (queue->content->timeout_task); GNUNET_free (queue); check_fragment_queue (plugin); } /** * Function that can be used to force the plugin to disconnect * from the given peer and cancel all previous transmissions * (and their continuation). * * @param cls closure * @param target peer from which to disconnect */ static void wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { struct Plugin *plugin = cls; struct Sessionqueue *queue; 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; } } /** * Convert the transports address to a nice, human-readable * format. * * @param cls closure * @param type name of the transport that generated the address * @param addr one of the addresses of the host, NULL for the last address * the specific address format depends on the transport * @param addrlen length of the address * @param numeric should (IP) addresses be displayed in numeric form? * @param timeout after how long should we give up? * @param asc function to call on each string * @param asc_cls closure for asc */ static void wlan_plugin_address_pretty_printer (void *cls, const char *type, const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls) { char *ret; const unsigned char *input; //GNUNET_assert(cls !=NULL); if (addrlen != sizeof(struct MacAddress)) { /* invalid address (MAC addresses have 6 bytes) */ //GNUNET_break (0); #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Func wlan_plugin_address_pretty_printer got size: %u, worng size!\n", addrlen); #endif asc(asc_cls, NULL); return; } input = (const unsigned char *) addr; GNUNET_asprintf (&ret, "Transport %s: %s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X",type, PROTOCOL_PREFIX, input[0], input[1], input[2], input[3], input[4], input[5]); #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Func wlan_plugin_address_pretty_printer got size: %u, nummeric %u, type %s; made string: %s\n", addrlen, numeric, type, ret); #endif asc ( asc_cls, ret); //only one mac address per plugin asc ( asc_cls, NULL); } /** * handels the data after all fragments are put together * @param cls macendpoint this messages belongs to * @param hdr pointer to the data */ static void wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr) { struct MacEndpoint *endpoint = (struct MacEndpoint *) cls; struct Plugin *plugin = endpoint->plugin; struct WlanHeader *wlanheader; struct Session *session; const struct GNUNET_MessageHeader *temp_hdr; struct GNUNET_PeerIdentity tmpsource; int crc; GNUNET_assert (plugin != NULL); if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) { #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; } GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan whole messages received"), 1, GNUNET_NO); wlanheader = (struct WlanHeader *) hdr; session = search_session (plugin, endpoint, &wlanheader->source); temp_hdr = (const struct GNUNET_MessageHeader *) &wlanheader[1]; crc = ntohl (wlanheader->crc); wlanheader->crc = 0; if (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: %u\n", ntohs (hdr->size)); return; } } /** * 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; distance.type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); distance.value = htonl (1); #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, 1, session, (const char *) &session->mac->addr, sizeof (session->mac->addr)); } /** * Function used for to process the data received from the wlan interface * * @param cls the plugin handle * @param session_light pointer to the struct holding known informations * @param hdr hdr of the GNUNET_MessageHeader * @param rxinfo pointer to the radiotap informations got with this packet */ 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; struct GNUNET_PeerIdentity tmpsource; GNUNET_assert(plugin != NULL); //ADVERTISEMENT if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_HELLO) { //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_HELLO 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_YES); } if (GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource) == GNUNET_OK) { session_light->session = search_session (plugin, session_light->macendpoint, &tmpsource); if (session_light->session == NULL) { session_light->session = create_session (plugin, session_light->macendpoint, &tmpsource); } GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan hello messages received"), 1, GNUNET_NO); plugin->env->receive(plugin->env->cls,&session_light->session->target,hdr, NULL, 0, session_light->session, (const char *) &session_light->session->mac->addr, sizeof (session_light->session->mac->addr)); } else { GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME, "WLAN client not in session list and hello message is not okay\n"); return; } } //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 GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan fragments received"), 1, GNUNET_NO); int ret = GNUNET_DEFRAGMENT_process_fragment (session_light->macendpoint->defrag, hdr); if (ret == GNUNET_NO) { session_light->macendpoint->dups++; } else if (ret == GNUNET_OK) { 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; GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks received"), 1, GNUNET_NO); int ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); if (ret == GNUNET_OK) { #if DEBUG_wlan_retransmission > 1 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 > 1 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 > 1 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 } /** * Function to print mac addresses nice * * @param pointer to 6 byte with the mac address * @return pointer to the chars which hold the print out */ const char * macprinter (const u_int8_t * mac) { static char macstr[20]; GNUNET_snprintf (macstr, sizeof (macstr), "%X:%X:%X:%X:%X:%X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); return macstr; } /** * Function 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 (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (endpoint->last_activity, MACENDPOINT_TIMEOUT)).rel_value == 0) { GNUNET_assert(endpoint->plugin != NULL); GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# wlan mac endpoints timeouts"), 1, GNUNET_NO); free_macendpoint (endpoint->plugin, endpoint); } else { endpoint->timeout_task = GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, endpoint); } } /** * 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)); GNUNET_assert(plugin != NULL); GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan mac endpoints created"), 1, GNUNET_NO); newend->addr = *addr; newend->plugin = plugin; newend->addr = *addr; newend->fragment_messages_out_count = 0; newend->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats, WLAN_MTU, MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, newend, &wlan_data_message_handler, &add_ack_for_send); newend->last_activity = GNUNET_TIME_absolute_get (); newend->timeout_task = GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout, newend); 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 * * @param cls the plugin handle * @param client client that send the data (not used) * @param hdr header of the GNUNET_MessageHeader */ static void wlan_process_helper (void *cls, void *client, const struct GNUNET_MessageHeader *hdr) { 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; GNUNET_assert(plugin != NULL); 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 GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan WLAN_HELPER_DATA received"), 1, GNUNET_NO); //call wlan_process_helper with the message inside, later with wlan: analyze signal if (ntohs (hdr->size) < sizeof (struct ieee80211_frame) + 2*sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_rx)) { #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)) { //if packet is from us return if ((memcmp (&(wlanIeeeHeader->i_addr2), &(plugin->mac_address), sizeof (struct MacAddress)) == 0)){ return; } // process the inner data datasize = ntohs (hdr->size) - sizeof (struct ieee80211_frame) - sizeof (struct GNUNET_MessageHeader) - sizeof (struct Radiotap_rx); session_light = GNUNET_malloc (sizeof (struct Session_light)); memcpy (&session_light->addr, &(wlanIeeeHeader->i_addr2), sizeof (struct MacAddress)); //session_light->session = search_session(plugin,session_light->addr); GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan messaged for this client received"), 1, GNUNET_NO); pos = 0; while (pos < datasize) { temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] + pos; if (ntohs(temp_hdr->size) <= datasize + pos) { GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan messaged inside WLAN_HELPER_DATA received"), 1, GNUNET_NO); wlan_data_helper (plugin, session_light, temp_hdr, rxinfo); } else { #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Size of packet is too small; size: %u > size of packet: %u\n", ntohs(temp_hdr->size),datasize + pos); #endif } 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 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 DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "Func wlan_process_helper got unknown message with number %u, size %u\n", ntohs (hdr->type), ntohs (hdr->size)); #endif #if DEBUG_wlan_msg_dump > 1 hexdump (hdr, GNUNET_MIN (ntohs (hdr->size), 256)); #endif 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) 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 if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_YES) { plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin, plugin->server_stdout, filenamehw, filenamehw, plugin->interface, NULL); } else if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_NO) { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, "gnunet-transport-wlan-helper is not suid, please change it or look at the doku\n"); GNUNET_break (0); } else { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, "gnunet-transport-wlan-helper not found, please look if it exists and is the $PATH variable!\n"); GNUNET_break (0); } } 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 if (GNUNET_OS_check_helper_binary (filenameloopback) != GNUNET_SYSERR) { plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin, plugin->server_stdout, filenameloopback, filenameloopback, "1", NULL); } else { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, "gnunet-transport-wlan-helper-dummy not found, please look if it exists and is the $PATH variable!\n"); GNUNET_break (0); } } 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 if (GNUNET_OS_check_helper_binary (filenameloopback) != GNUNET_SYSERR) { plugin->server_proc = GNUNET_OS_start_process (plugin->server_stdin, plugin->server_stdout, filenameloopback, filenameloopback, "2", NULL); } else { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, "gnunet-transport-wlan-helper-dummy not found, please look if it exists and is in the $PATH variable!\n"); GNUNET_break (0); } } 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; } /** * 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. * * @param cls closure, the 'struct GNUNET_TRANSPORT_PluginEnvironment*' * @return the 'struct GNUNET_TRANSPORT_PluginFunctions*' or NULL on error */ void * libgnunet_plugin_transport_wlan_init (void *cls) { //struct GNUNET_SERVICE_Context *service; struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; struct GNUNET_TRANSPORT_PluginFunctions *api; struct Plugin *plugin; static unsigned long long testmode = 0; GNUNET_assert (cls != NULL); plugin = GNUNET_malloc (sizeof (struct Plugin)); plugin->env = env; plugin->pendingsessions = 0; GNUNET_STATISTICS_set(plugin->env->stats, _("# wlan pending sessions"), plugin->pendingsessions, GNUNET_NO); 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)); api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); api->cls = plugin; api->send = &wlan_plugin_send; 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 wlan_transport_start_wlan_helper (plugin, testmode); set_next_beacon_time (plugin); set_next_send(plugin); #if DEBUG_wlan GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, "wlan init finished\n"); #endif return api; } /* end of plugin_transport_wlan.c */