diff options
Diffstat (limited to 'src/transport/plugin_transport_wlan.c')
| -rw-r--r-- | src/transport/plugin_transport_wlan.c | 3201 |
1 files changed, 3201 insertions, 0 deletions
diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c new file mode 100644 index 0000000..08f9c58 --- /dev/null +++ b/src/transport/plugin_transport_wlan.c @@ -0,0 +1,3201 @@ +/* + This file is part of GNUnet + (C) 2010 2011 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + */ + +/** + * @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" + +/** + * DEBUG switch + */ +#define DEBUG_WLAN GNUNET_EXTRA_LOGGING + + +#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 + +/** + * scaling factor for restarting the helper + */ +#define HELPER_RESTART_SCALING_FACTOR 2 + +/** + * max size of fragment queue + */ +#define FRAGMENT_QUEUE_SIZE 10 +/** + * max messages in fragment queue per session/client + */ +#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 0x1f +#define WLAN_LLC_SSAP_FIELD 0x1f + + +#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ + +#define IEEE80211_FC0_VERSION_MASK 0x03 +#define IEEE80211_FC0_VERSION_SHIFT 0 +#define IEEE80211_FC0_VERSION_0 0x00 +#define IEEE80211_FC0_TYPE_MASK 0x0c +#define IEEE80211_FC0_TYPE_SHIFT 2 +#define IEEE80211_FC0_TYPE_MGT 0x00 +#define IEEE80211_FC0_TYPE_CTL 0x04 +#define IEEE80211_FC0_TYPE_DATA 0x08 + +GNUNET_NETWORK_STRUCT_BEGIN + +/* + * generic definitions for IEEE 802.11 frames + */ +struct ieee80211_frame +{ + u_int8_t i_fc[2]; + u_int8_t i_dur[2]; + u_int8_t i_addr1[IEEE80211_ADDR_LEN]; + u_int8_t i_addr2[IEEE80211_ADDR_LEN]; + u_int8_t i_addr3[IEEE80211_ADDR_LEN]; + u_int8_t i_seq[2]; + u_int8_t llc[4]; +} GNUNET_PACKED; +GNUNET_NETWORK_STRUCT_END + +/** + * Encapsulation of all of the state of the plugin. + */ +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-helper-transport-wlan process + */ + struct GNUNET_DISK_PipeHandle *server_stdout; + + /** + * stdout file handle for the gnunet-helper-transport-wlan process + */ + const struct GNUNET_DISK_FileHandle *server_stdout_handle; + + /** + * stdin pipe handle for the gnunet-helper-transport-wlan process + */ + struct GNUNET_DISK_PipeHandle *server_stdin; + + /** + * stdin file handle for the gnunet-helper-transport-wlan 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; + + /** + * Mode of operation for the helper, 0 = normal, 1 = first loopback, 2 = second loopback + */ + long long unsigned int testmode; + + /** + * The mac_address of the wlan card given to us by the helper. + */ + struct GNUNET_TRANSPORT_WLAN_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; + + /** + * saves the current state of the helper process + */ + int helper_is_running; +}; + +/** + * Struct to store data if file write did not accept the whole packet + */ +struct Finish_send +{ + /** + * pointer to the global plugin struct + */ + struct Plugin *plugin; + + /** + * head of the next part to send to the helper + */ + char *head_of_next_write; + + /** + * Start of the message to send, needed for free + */ + struct GNUNET_MessageHeader *msgstart; + + /** + * rest size to send + */ + ssize_t size; +}; + +/** + * Queue of sessions, for the general session queue and the pending session queue + */ +//TODO DOXIGEN +struct Sessionqueue +{ + struct Sessionqueue *next; + struct Sessionqueue *prev; + struct Session *content; +#if !HAVE_UNALIGNED_64_ACCESS + void *dummy; /* for alignment, see #1909 */ +#endif +}; + +/** + * Queue of fragmented messages, for the sending queue of the plugin + */ +//TODO DOXIGEN +struct FragmentMessage_queue +{ + struct FragmentMessage_queue *next; + struct FragmentMessage_queue *prev; + struct FragmentMessage *content; +}; + +/** + * Queue for the fragments received + */ +//TODO DOXIGEN +struct Receive_Fragment_Queue +{ + struct Receive_Fragment_Queue *next; + struct Receive_Fragment_Queue *prev; + uint16_t num; + const char *msg; + uint16_t size; + struct Radiotap_rx rxinfo; +}; + +//TODO DOXIGEN +struct MacEndpoint_id_fragment_triple +{ + struct MacEndpoint *endpoint; + uint32_t message_id; + struct FragmentMessage *fm; +}; + +//TODO DOXIGEN +struct Plugin_Session_pair +{ + struct Plugin *plugin; + struct Session *session; +}; + + +GNUNET_NETWORK_STRUCT_BEGIN + +/** + * Header for messages which need fragmentation + */ +struct WlanHeader +{ + + struct GNUNET_MessageHeader header; + + /** + * checksum/error correction + */ + uint32_t crc GNUNET_PACKED; + + /** + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) + */ + struct GNUNET_PeerIdentity target; + + /** + * Where the packet came from + */ + struct GNUNET_PeerIdentity source; + +// followed by payload + +}; +GNUNET_NETWORK_STRUCT_END + +/** + * 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 GNUNET_TRANSPORT_WLAN_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 GNUNET_TRANSPORT_WLAN_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 GNUNET_TRANSPORT_WLAN_MacAddress *addr); + +static void +finish_sending (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); + +/** + * Generates a nice hexdump of a memory area. + * + * \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 GNUNET_TRANSPORT_WLAN_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 GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + return queue; /* session found */ + queue = queue->next; + } + + if (create_new == GNUNET_YES) + { + return create_macendpoint (plugin, addr); + } + else + { + return NULL; + } + +} + +/** + * 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 GNUNET_TRANSPORT_WLAN_MacAddress *mac; + + if (addrlen != sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) + { + GNUNET_break (0); + return NULL; + } + mac = addr; + GNUNET_snprintf (ret, sizeof (ret), "%s Mac-Address %X:%X:%X:%X:%X:%X", + PROTOCOL_PREFIX, mac->mac[0], mac->mac[1], mac->mac[2], + mac->mac[3], mac->mac[4], mac->mac[5]); + + return ret; +} + +/** + * Function for the scheduler if a session times out + * @param cls pointer to the Sessionqueue + * @param tc pointer to the GNUNET_SCHEDULER_TaskContext + */ +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; + queue->content->target = *peer; + queue->content->last_activity = GNUNET_TIME_absolute_get (); + queue->content->timeout_task = + GNUNET_SCHEDULER_add_delayed (SESSION_TIMEOUT, &session_timeout, queue); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "New session %p with endpoint %p: %s\n", queue->content, + endpoint, wlan_plugin_address_to_string (NULL, + endpoint->addr.mac, + 6)); + return queue->content; +} + +/** + * Get session from address, create if no session exists + * + * @param plugin pointer to the plugin struct + * @param addr pointer to the mac address of the peer + * @param peer pointer to the peerid + * @return returns the session + */ +static struct Session * +get_session (struct Plugin *plugin, const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr, + const struct GNUNET_PeerIdentity *peer) +{ + struct MacEndpoint *mac; + + mac = get_macendpoint (plugin, addr, GNUNET_YES); + struct Session *session = search_session (plugin, mac, peer); + + if (session != NULL) + return session; + return create_session (plugin, mac, peer); +} + +/** + * Queue the session to send data + * checks if there is a message pending + * checks if this session is not allready in the queue + * @param plugin pointer to the plugin + * @param session pointer to the session to add + */ +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; + + //abort if helper is not running + if (plugin->helper_is_running == GNUNET_NO) + { + return; + } + + //cancel old task + if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task); + plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + } + + //check if some acks are in the queue + if (plugin->ack_send_queue_head != NULL) + { + next_send = GNUNET_TIME_UNIT_ZERO; + } + + //check if there are some fragments in the queue + else if (plugin->sending_messages_head != NULL) + { + next_send = GNUNET_TIME_UNIT_ZERO; + } + else + { + next_send = GNUNET_TIME_absolute_get_remaining (plugin->beacon_time); + } + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Next packet is send in: %u\n", next_send.rel_value); + if (next_send.rel_value == GNUNET_TIME_UNIT_ZERO.rel_value) + { + if (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK) + { + plugin->server_write_task = + GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, + plugin->server_stdin_handle, + &do_transmit, plugin); + } + } + else + { + if (plugin->server_write_delay_task == GNUNET_SCHEDULER_NO_TASK) + { + plugin->server_write_delay_task = + GNUNET_SCHEDULER_add_delayed (next_send, &delay_fragment_task, + plugin); + } + } +} + +/** + * Function to get the next queued Session, removes the session from the queue + * @param plugin pointer to the plugin struct + * @return pointer to the session found, returns NULL if there is now session in the queue + */ +static struct Session * +get_next_queue_session (struct Plugin *plugin) +{ + struct Session *session; + struct Sessionqueue *sessionqueue; + struct Sessionqueue *sessionqueue_alt; + struct PendingMessage *pm; + + sessionqueue = plugin->pending_Sessions_head; + + while (sessionqueue != NULL) + { + session = sessionqueue->content; + + GNUNET_assert (session != NULL); + pm = session->pending_message_head; + + if (pm == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "pending message is empty, should not happen. session %p\n", + session); + sessionqueue_alt = sessionqueue; + sessionqueue = sessionqueue->next; + plugin->pendingsessions--; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), + plugin->pendingsessions, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, + sessionqueue_alt); + + GNUNET_free (sessionqueue_alt); + continue; + + } + + //check for message timeout + if (GNUNET_TIME_absolute_get_remaining (pm->timeout).rel_value > 0) + { + //check if session has no message in the fragment queue + if ((session->mac->fragment_messages_out_count < + FRAGMENT_QUEUE_MESSAGES_OUT_PER_MACENDPOINT) && + (session->fragment_messages_out_count < + FRAGMENT_QUEUE_MESSAGES_OUT_PER_SESSION)) + { + plugin->pendingsessions--; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), + plugin->pendingsessions, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, + sessionqueue); + GNUNET_free (sessionqueue); + + return session; + } + else + { + sessionqueue = sessionqueue->next; + } + } + else + { + GNUNET_CONTAINER_DLL_remove (session->pending_message_head, + session->pending_message_tail, pm); + + //call the cont func that it did not work + if (pm->transmit_cont != NULL) + pm->transmit_cont (pm->transmit_cont_cls, &(session->target), + GNUNET_SYSERR); + GNUNET_free (pm->msg); + GNUNET_free (pm); + + if (session->pending_message_head == NULL) + { + sessionqueue_alt = sessionqueue; + sessionqueue = sessionqueue->next; + plugin->pendingsessions--; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), + plugin->pendingsessions, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, + sessionqueue_alt); + + GNUNET_free (sessionqueue_alt); + } + } + + } + return NULL; +} + +/** + * frees the space of a message in the fragment queue (send queue) + * @param plugin the plugin struct + * @param fm message to free + */ +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; + + 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_STATISTICS_set (plugin->env->stats, _("# wlan pending fragments"), + plugin->pending_Fragment_Messages, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (endpoint->sending_messages_head, + endpoint->sending_messages_tail, fm); + GNUNET_FRAGMENT_context_destroy (fm->fragcontext); + if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (fm->timeout_task); + fm->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + + GNUNET_free (fm); + + queue_session (plugin, session); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Free pending fragment messages %p, session %p\n", fm, + session); +} + +/** + * function to fill the radiotap header + * @param plugin pointer to the plugin struct + * @param endpoint pointer to the endpoint + * @param header pointer to the radiotap header + * @return GNUNET_YES at success + */ +static int +getRadiotapHeader (struct Plugin *plugin, struct MacEndpoint *endpoint, + struct Radiotap_Send *header) +{ + + if (endpoint != NULL) + { + header->rate = endpoint->rate; + header->tx_power = endpoint->tx_power; + header->antenna = endpoint->antenna; + } + 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 GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, struct Plugin *plugin, + unsigned int size) +{ + uint16_t *tmp16; + const int rate = 11000000; + + Header->i_fc[0] = IEEE80211_FC0_TYPE_DATA; + Header->i_fc[1] = 0x00; + memcpy (&Header->i_addr3, &mac_bssid_gnunet, sizeof (mac_bssid_gnunet)); + memcpy (&Header->i_addr2, plugin->mac_address.mac, + sizeof (plugin->mac_address)); + memcpy (&Header->i_addr1, to_mac_addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + + tmp16 = (uint16_t *) Header->i_dur; + *tmp16 = (uint16_t) GNUNET_htole16 ((size * 1000000) / rate + 290); + Header->llc[0] = WLAN_LLC_DSAP_FIELD; + Header->llc[1] = WLAN_LLC_SSAP_FIELD; + + return GNUNET_YES; +} + + +/** + * function to add a fragment of a message to send + * @param cls FragmentMessage this message belongs to + * @param hdr pointer to the start of the message + */ +static void +add_message_for_send (void *cls, const struct GNUNET_MessageHeader *hdr) +{ + + struct FragmentMessage *fm = cls; + struct FragmentMessage_queue *fmqueue; + + GNUNET_assert (cls != NULL); + GNUNET_assert (fm->frag == NULL); + struct MacEndpoint *endpoint = fm->session->mac; + struct Plugin *plugin = endpoint->plugin; + struct GNUNET_MessageHeader *msgheader; + struct GNUNET_MessageHeader *msgheader2; + uint16_t size; + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Adding fragment of message %p to send, session %p, endpoint %p, type %u\n", + fm, fm->session, endpoint, hdr->type); + size = + sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + + sizeof (struct ieee80211_frame) + ntohs (hdr->size); + fm->frag = GNUNET_malloc (size); + fm->size = size; + + msgheader = (struct GNUNET_MessageHeader *) fm->frag; + msgheader->size = htons (size); + msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); + + fm->radioHeader = (struct Radiotap_Send *) &msgheader[1]; + fm->ieeewlanheader = (struct ieee80211_frame *) &fm->radioHeader[1]; + msgheader2 = (struct GNUNET_MessageHeader *) &fm->ieeewlanheader[1]; + memcpy (msgheader2, hdr, ntohs (hdr->size)); + + fmqueue = GNUNET_malloc (sizeof (struct FragmentMessage_queue)); + fmqueue->content = fm; + + GNUNET_CONTAINER_DLL_insert_tail (plugin->sending_messages_head, + plugin->sending_messages_tail, fmqueue); + set_next_send (plugin); +} + + +/** + * We have been notified that gnunet-helper-transport-wlan has written something to stdout. + * Handle the output, then reschedule this function to be called again once + * more is available. + * + * @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) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + _ + ("Finished reading from gnunet-helper-transport-wlan stdout with code: %d\n"), + bytes); + 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-helper-transport-wlan process. + * + * @param plugin the transport plugin + * @return GNUNET_YES if process was started, GNUNET_SYSERR on error + */ +static int +wlan_transport_start_wlan_helper (struct Plugin *plugin) +{ + const char *filenamehw = "gnunet-helper-transport-wlan"; + const char *filenameloopback = "gnunet-helper-transport-wlan-dummy"; + char *absolute_filename = NULL; + + if (plugin->helper_is_running == GNUNET_YES) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan_transport_start_wlan_helper not needed, helper already running!"); + return GNUNET_YES; + } + + plugin->server_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); + if (plugin->server_stdout == NULL) + return GNUNET_SYSERR; + + plugin->server_stdin = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO); + if (plugin->server_stdin == NULL) + return GNUNET_SYSERR; + + if ((plugin->testmode == 1) || (plugin->testmode == 2)) + { + if (GNUNET_OS_check_helper_binary (filenameloopback) == GNUNET_YES) + { + absolute_filename = GNUNET_strdup (filenameloopback); + } + else + { + char cwd[FILENAME_MAX]; + + GNUNET_assert (getcwd (cwd, sizeof (cwd)) != NULL); + + GNUNET_asprintf (&absolute_filename, "%s%s%s", cwd, DIR_SEPARATOR_STR, + filenameloopback); + + if (GNUNET_DISK_file_test (filenameloopback) != GNUNET_YES) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "Helper `%s' not found! %i\n", absolute_filename); + GNUNET_break (0); + } + } + } + + /* Start the server process */ + + if (plugin->testmode == 0) + { + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Starting gnunet-helper-transport-wlan process cmd: %s %s %i\n", + filenamehw, plugin->interface, plugin->testmode); + if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_YES) + { + plugin->server_proc = + GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, + filenamehw, filenamehw, plugin->interface, + NULL); + } + else if (GNUNET_OS_check_helper_binary (filenamehw) == GNUNET_NO) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "gnunet-helper-transport-wlan is not suid, please change it or look at the doku\n"); + GNUNET_break (0); + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "gnunet-helper-transport-wlan not found, please look if it exists and is the $PATH variable!\n"); + GNUNET_break (0); + } + + } + else if (plugin->testmode == 1) + { + + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, + "Starting gnunet-helper-transport-wlan-dummy loopback 1 process cmd: %s %s %i\n", + absolute_filename, plugin->interface, plugin->testmode); + plugin->server_proc = + GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, + absolute_filename, absolute_filename, "1", + NULL); + if (plugin->server_proc == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "`%s' not found, please look if it exists and is in the $PATH variable!\n", + absolute_filename); + GNUNET_break (0); + } + } + else if (plugin->testmode == 2) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, + "Starting gnunet-helper-transport-wlan-dummy loopback 2 process cmd: %s %s %i\n", + absolute_filename, plugin->interface, plugin->testmode); + plugin->server_proc = + GNUNET_OS_start_process (GNUNET_NO, plugin->server_stdin, plugin->server_stdout, + absolute_filename, absolute_filename, "2", + NULL); + if (plugin->server_proc == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + "`%s' not found, please look if it exists and is in the $PATH variable!\n", + absolute_filename); + GNUNET_break (0); + } + } + if (absolute_filename != NULL) + GNUNET_free (absolute_filename); + if (plugin->server_proc == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Failed to start gnunet-helper-transport-wlan process\n"); + return GNUNET_SYSERR; + } + + + + /* Close the write end of the read pipe */ + GNUNET_DISK_pipe_close_end (plugin->server_stdout, + GNUNET_DISK_PIPE_END_WRITE); + + /* Close the read end of the write pipe */ + GNUNET_DISK_pipe_close_end (plugin->server_stdin, GNUNET_DISK_PIPE_END_READ); + + plugin->server_stdout_handle = + GNUNET_DISK_pipe_handle (plugin->server_stdout, + GNUNET_DISK_PIPE_END_READ); + plugin->server_stdin_handle = + GNUNET_DISK_pipe_handle (plugin->server_stdin, + GNUNET_DISK_PIPE_END_WRITE); + + GNUNET_assert (plugin->server_read_task == GNUNET_SCHEDULER_NO_TASK); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Adding server_read_task for the gnunet-helper-transport-wlan\n"); + plugin->server_read_task = + GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, + plugin->server_stdout_handle, + &wlan_plugin_helper_read, plugin); + + plugin->helper_is_running = GNUNET_YES; + return GNUNET_YES; +} + +/** + * Stops the gnunet-helper-transport-wlan process. + * + * @param plugin the transport plugin + * @return GNUNET_YES if process was started, GNUNET_SYSERR on error + */ +static int +wlan_transport_stop_wlan_helper (struct Plugin *plugin) +{ + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Stoping WLAN helper process\n"); + + if (plugin->helper_is_running == GNUNET_NO) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan_transport_stop_wlan_helper not needed, helper already stopped!"); + return GNUNET_YES; + } + + if (plugin->server_write_delay_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (plugin->server_write_delay_task); + plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + } + + if (plugin->server_write_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (plugin->server_write_task); + plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + } + + if (plugin->server_read_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (plugin->server_read_task); + plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; + } + + GNUNET_DISK_pipe_close (plugin->server_stdout); + GNUNET_DISK_pipe_close (plugin->server_stdin); + GNUNET_OS_process_kill (plugin->server_proc, SIGKILL); + GNUNET_OS_process_wait (plugin->server_proc); + GNUNET_OS_process_close (plugin->server_proc); + + plugin->helper_is_running = GNUNET_NO; + + return GNUNET_YES; +} + +/** + * function for delayed restart of the helper process + * @param cls Finish_send struct if message should be finished + * @param tc TaskContext + */ +static void +delay_restart_helper (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct Finish_send *finish = cls; + struct Plugin *plugin; + + plugin = finish->plugin; + + plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) + { + GNUNET_free_non_null (finish->msgstart); + GNUNET_free (finish); + return; + } + + wlan_transport_start_wlan_helper (plugin); + + if (finish->size != 0) + { + plugin->server_write_task = + GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, + plugin->server_stdin_handle, + &finish_sending, finish); + } + else + { + set_next_send (plugin); + GNUNET_free_non_null (finish->msgstart); + GNUNET_free (finish); + } + +} + +/** + * Function to restart the helper + * @param plugin pointer to the global plugin struct + * @param finish pointer to the Finish_send struct to finish + */ +static void +restart_helper (struct Plugin *plugin, struct Finish_send *finish) +{ + static struct GNUNET_TIME_Relative next_try = { 1000 }; + GNUNET_assert (finish != NULL); + + wlan_transport_stop_wlan_helper (plugin); + plugin->server_write_task = + GNUNET_SCHEDULER_add_delayed (next_try, &delay_restart_helper, finish); + GNUNET_TIME_relative_multiply (next_try, HELPER_RESTART_SCALING_FACTOR); + +} + +/** + * function to finish a sending if not all could have been writen befor + * @param cls pointer to the Finish_send struct + * @param tc TaskContext + */ +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->head_of_next_write, finish->size); + + if (bytes != finish->size) + { + if (bytes != GNUNET_SYSERR) + { + finish->head_of_next_write += bytes; + finish->size -= bytes; + plugin->server_write_task = + GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, + plugin->server_stdin_handle, + &finish_sending, finish); + } + else + { + restart_helper (plugin, finish); + } + } + else + { + GNUNET_free (finish->msgstart); + GNUNET_free (finish); + 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) +{ + uint16_t size; + ssize_t bytes; + uint16_t hello_size; + struct GNUNET_MessageHeader *msgheader; + struct ieee80211_frame *ieeewlanheader; + struct Radiotap_Send *radioHeader; + struct GNUNET_MessageHeader *msgheader2; + const struct GNUNET_MessageHeader *hello; + struct Finish_send *finish; + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Sending hello beacon\n"); + + GNUNET_assert (plugin != NULL); + + 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 helper. errno == %d, ERROR: %s\n"), + errno, strerror (errno)); + finish = GNUNET_malloc (sizeof (struct Finish_send)); + finish->plugin = plugin; + finish->head_of_next_write = NULL; + finish->size = 0; + finish->msgstart = NULL; + restart_helper (plugin, finish); + + set_next_beacon_time (plugin); + + } + else + { + GNUNET_assert (bytes == size); + set_next_beacon_time (plugin); + set_next_send (plugin); + } + GNUNET_free (msgheader); + + +} + +/** + * function to add an ack to send it for a received fragment + * @param cls MacEndpoint this ack belongs to + * @param msg_id id of the message + * @param hdr pointer to the hdr where the ack is stored + * + */ +static void +add_ack_for_send (void *cls, uint32_t msg_id, + const struct GNUNET_MessageHeader *hdr) +{ + + struct AckSendQueue *ack; + + GNUNET_assert (cls != NULL); + struct MacEndpoint *endpoint = cls; + struct Plugin *plugin = endpoint->plugin; + struct GNUNET_MessageHeader *msgheader; + struct GNUNET_MessageHeader *msgheader2; + uint16_t size; + + size = + sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + + sizeof (struct ieee80211_frame) + ntohs (hdr->size) + + sizeof (struct AckSendQueue); + + ack = GNUNET_malloc (size); + ack->message_id = msg_id; + ack->endpoint = endpoint; + + size = + sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_Send) + + sizeof (struct ieee80211_frame) + ntohs (hdr->size); + + msgheader = (struct GNUNET_MessageHeader *) &ack[1]; + ack->hdr = (struct GNUNET_MessageHeader *) &ack[1]; + msgheader->size = htons (size); + msgheader->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); + + ack->radioHeader = (struct Radiotap_Send *) &msgheader[1]; + ack->ieeewlanheader = (struct ieee80211_frame *) &(ack->radioHeader)[1]; + msgheader2 = (struct GNUNET_MessageHeader *) &(ack->ieeewlanheader)[1]; + memcpy (msgheader2, hdr, ntohs (hdr->size)); + + GNUNET_CONTAINER_DLL_insert_tail (plugin->ack_send_queue_head, + plugin->ack_send_queue_tail, ack); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Adding ack with message id %u to send, AckSendQueue %p, endpoint %p\n", + msg_id, ack, endpoint); + set_next_send (plugin); +} + +/** + * Function for the scheduler if a FragmentMessage times out + * @param cls pointer to the FragmentMessage + * @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++; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending fragments"), + plugin->pending_Fragment_Messages, GNUNET_NO); + + fm = GNUNET_malloc (sizeof (struct FragmentMessage)); + fm->session = session; + fm->timeout.abs_value = pm->timeout.abs_value; + fm->frag = NULL; + fm->fragcontext = + GNUNET_FRAGMENT_context_create (plugin->env->stats, WLAN_MTU, + &plugin->tracker, + GNUNET_TIME_UNIT_SECONDS, + &(pm->msg->header), + &add_message_for_send, fm); + fm->timeout_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining + (fm->timeout), fragmentmessage_timeout, + fm); + GNUNET_CONTAINER_DLL_insert_tail (session->mac->sending_messages_head, + session->mac->sending_messages_tail, + fm); + + if (pm->transmit_cont != NULL) + { + pid = session->target; + pm->transmit_cont (pm->transmit_cont_cls, &pid, GNUNET_OK); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "called pm->transmit_cont for %p\n", session); + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "no pm->transmit_cont for %p\n", session); + } + GNUNET_free (pm); + + if (session->pending_message_head != NULL) + { + //requeue session + queue_session (plugin, session); + } + + } + } + + //check if timeout changed + set_next_send (plugin); +} + +/** + * Function to send an ack, does not free the ack + * @param plugin pointer to the plugin + */ +static void +send_ack (struct Plugin *plugin) +{ + + ssize_t bytes; + struct AckSendQueue *ack; + struct Finish_send *finish; + + ack = plugin->ack_send_queue_head; + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Sending ack for message_id %u for mac endpoint %p, size %u\n", + ack->message_id, ack->endpoint, + ntohs (ack->hdr->size) - sizeof (struct Radiotap_Send)); + GNUNET_assert (plugin != NULL); + GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks send"), 1, + GNUNET_NO); + + getRadiotapHeader (plugin, ack->endpoint, ack->radioHeader); + getWlanHeader (ack->ieeewlanheader, &ack->endpoint->addr, plugin, + ntohs (ack->hdr->size)); + + 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 helper. errno == %d, ERROR: %s\n"), + errno, strerror (errno)); + finish = GNUNET_malloc (sizeof (struct Finish_send)); + finish->plugin = plugin; + finish->head_of_next_write = NULL; + finish->size = 0; + finish->msgstart = NULL; + restart_helper (plugin, finish); + } + else + { + GNUNET_assert (bytes == ntohs (ack->hdr->size)); + GNUNET_CONTAINER_DLL_remove (plugin->ack_send_queue_head, + plugin->ack_send_queue_tail, ack); + GNUNET_free (ack); + set_next_send (plugin); + } +} + +/** + * 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; + ssize_t bytes; + + if (plugin->ack_send_queue_head != NULL) + { + send_ack (plugin); + 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); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Sending GNUNET_MESSAGE_TYPE_WLAN_FRAGMENT for fragment message %p, size: %u\n", + fm, fm->size); + getRadiotapHeader (plugin, session->mac, fm->radioHeader); + getWlanHeader (fm->ieeewlanheader, &(fm->session->mac->addr), plugin, + fm->size); + + bytes = + GNUNET_DISK_file_write (plugin->server_stdin_handle, fm->frag, + fm->size); + + + if (bytes != fm->size) + { + finish = GNUNET_malloc (sizeof (struct Finish_send)); + finish->plugin = plugin; + finish->msgstart = (struct GNUNET_MessageHeader *) fm->frag; + GNUNET_assert (plugin->server_write_task == GNUNET_SCHEDULER_NO_TASK); + + if (bytes == GNUNET_SYSERR) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + _ + ("Error writing to wlan helper. errno == %d, ERROR: %s\n"), + errno, strerror (errno)); + + finish->head_of_next_write = fm->frag; + finish->size = fm->size; + restart_helper (plugin, finish); + } + else + { + finish->head_of_next_write = fm->frag + bytes; + finish->size = fm->size - bytes; + plugin->server_write_task = + GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, + plugin->server_stdin_handle, + &finish_sending, finish); + } + + fm->frag = NULL; + } + else + { + GNUNET_free (fm->frag); + fm->frag = NULL; + set_next_send (plugin); + } + GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext); + return; + } + +#if 1 + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "do_transmit did nothing, should not happen!\n"); +#endif + set_next_send (plugin); +} + +/** + * 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 */ + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan_plugin_address_suggested got good address, size %u!\n", + addrlen); + return GNUNET_OK; + } + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan_plugin_address_suggested got bad address, size %u!\n", + addrlen); + return GNUNET_SYSERR; +} + + +/** + * 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 struct Session * +wlan_plugin_get_session (void *cls, + const struct GNUNET_HELLO_Address *address) +{ + struct Plugin *plugin = cls; + struct Session * s = NULL; + + GNUNET_assert (plugin != NULL); + GNUNET_assert (address != NULL); + + if (GNUNET_OK == wlan_plugin_address_suggested (plugin, + address->address, + address->address_length)) + { + s = get_session (plugin, address->address, &address->peer); + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, PLUGIN_LOG_NAME, + _("Wlan Address len %d is wrong\n"), address->address_length); + return s; + } + + return s; +} + +/** + * Function that can be used by the transport service to transmit + * a message using the plugin. Note that in the case of a + * peer disconnecting, the continuation MUST be called + * prior to the disconnect notification itself. This function + * will be called with this peer's HELLO message to initiate + * a fresh connection to another peer. + * + * @param cls closure + * @param session which session must be used + * @param msgbuf the message to transmit + * @param msgbuf_size number of bytes in 'msgbuf' + * @param priority how important is the message (most plugins will + * ignore message priority and just FIFO) + * @param to how long to wait at most for the transmission (does not + * require plugins to discard the message after the timeout, + * just advisory for the desired delay; most plugins will ignore + * this as well) + * @param cont continuation to call once the message has + * been transmitted (or if the transport is ready + * for the next transmission call; or if the + * peer disconnected...); can be NULL + * @param cont_cls closure for cont + * @return number of bytes used (on the physical network, with overheads); + * -1 on hard errors (i.e. address invalid); 0 is a legal value + * and does NOT mean that the message was not transmitted (DV) + */ +static ssize_t +wlan_plugin_send (void *cls, + struct Session *session, + const char *msgbuf, size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative to, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) +{ + struct Plugin *plugin = cls; + struct PendingMessage *newmsg; + struct WlanHeader *wlanheader; + + GNUNET_assert (plugin != NULL); + GNUNET_assert (session != NULL); + GNUNET_assert (msgbuf_size > 0); + + //queue message: + + //queue message in session + //test if there is no other message in the "queue" + //FIXME: to many send requests + if (session->pending_message_head != NULL) + { + newmsg = session->pending_message_head; + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan_plugin_send: a pending message is already in the queue for this client\n remaining time to send this message is %u, queued fragment messages for this mac connection %u\n", + GNUNET_TIME_absolute_get_remaining (newmsg-> + timeout).rel_value, + session->mac->fragment_messages_out_count); + } + + newmsg = GNUNET_malloc (sizeof (struct PendingMessage)); + newmsg->msg = GNUNET_malloc (msgbuf_size + sizeof (struct WlanHeader)); + wlanheader = newmsg->msg; + //copy msg to buffer, not fragmented / segmented yet, but with message header + wlanheader->header.size = htons (msgbuf_size + sizeof (struct WlanHeader)); + wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA); + memcpy (&(wlanheader->target), &session->target, sizeof (struct GNUNET_PeerIdentity)); + memcpy (&(wlanheader->source), plugin->env->my_identity, + sizeof (struct GNUNET_PeerIdentity)); + wlanheader->crc = 0; + memcpy (&wlanheader[1], msgbuf, msgbuf_size); + wlanheader->crc = + htonl (GNUNET_CRYPTO_crc32_n + ((char *) wlanheader, msgbuf_size + sizeof (struct WlanHeader))); + + newmsg->transmit_cont = cont; + newmsg->transmit_cont_cls = cont_cls; + newmsg->timeout = GNUNET_TIME_relative_to_absolute (to); + + newmsg->timeout.abs_value = newmsg->timeout.abs_value - 500; + + newmsg->message_size = msgbuf_size + sizeof (struct WlanHeader); + + GNUNET_CONTAINER_DLL_insert_tail (session->pending_message_head, + session->pending_message_tail, newmsg); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "New message for %p with size (incl wlan header) %u added\n", + session, newmsg->message_size); +#if DEBUG_WLAN > 1 + hexdump (msgbuf, GNUNET_MIN (msgbuf_size, 256)); +#endif + //queue session + queue_session (plugin, session); + + check_fragment_queue (plugin); + //FIXME not the correct size + return msgbuf_size; +} + + +/** + * function to free a mac endpoint + * @param plugin pointer to the plugin struct + * @param endpoint pointer to the MacEndpoint to free + */ +static void +free_macendpoint (struct Plugin *plugin, struct MacEndpoint *endpoint) +{ + struct Sessionqueue *sessions; + struct Sessionqueue *sessions_next; + + GNUNET_assert (endpoint != NULL); + + sessions = endpoint->sessions_head; + while (sessions != NULL) + { + sessions_next = sessions->next; + free_session (plugin, sessions, GNUNET_NO); + sessions = sessions_next; + } + + GNUNET_CONTAINER_DLL_remove (plugin->mac_head, plugin->mac_tail, endpoint); + if (endpoint->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (endpoint->timeout_task); + endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + plugin->mac_count--; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), + plugin->mac_count, GNUNET_NO); + GNUNET_free (endpoint); + +} + +/** + * function to free a session + * @param plugin pointer to the plugin + * @param queue pointer to the sessionqueue element to free + * @param do_free_macendpoint if GNUNET_YES and mac endpoint would be empty, free mac endpoint + */ +static void +free_session (struct Plugin *plugin, struct Sessionqueue *queue, + int do_free_macendpoint) +{ + struct Sessionqueue *pendingsession; + struct Sessionqueue *pendingsession_tmp; + struct PendingMessage *pm; + struct MacEndpoint *endpoint; + struct FragmentMessage *fm; + struct FragmentMessage *fmnext; + int check = 0; + + GNUNET_assert (plugin != NULL); + GNUNET_assert (queue != NULL); + GNUNET_assert (queue->content != NULL); + + //session found + //is this session pending for send + pendingsession = plugin->pending_Sessions_head; + while (pendingsession != NULL) + { + pendingsession_tmp = pendingsession; + pendingsession = pendingsession->next; + GNUNET_assert (pendingsession_tmp->content != NULL); + if (pendingsession_tmp->content == queue->content) + { + plugin->pendingsessions--; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan pending sessions"), + plugin->pendingsessions, GNUNET_NO); + GNUNET_CONTAINER_DLL_remove (plugin->pending_Sessions_head, + plugin->pending_Sessions_tail, + pendingsession_tmp); + GNUNET_free (pendingsession_tmp); + + GNUNET_assert (check == 0); + check = 1; + } + } + + endpoint = queue->content->mac; + fm = endpoint->sending_messages_head; + while (fm != NULL) + { + fmnext = fm->next; + if (fm->session == queue->content) + { + free_fragment_message (plugin, fm); + } + fm = fmnext; + } + + // remove PendingMessage + pm = queue->content->pending_message_head; + while (pm != NULL) + { + GNUNET_CONTAINER_DLL_remove (queue->content->pending_message_head, + queue->content->pending_message_tail, pm); + GNUNET_free (pm->msg); + GNUNET_free (pm); + pm = queue->content->pending_message_head; + } + + GNUNET_CONTAINER_DLL_remove (endpoint->sessions_head, endpoint->sessions_tail, + queue); + //Check that no ohter session on this endpoint for this session exits + GNUNET_assert (search_session (plugin, endpoint, &queue->content->target) == + NULL); + if (endpoint->sessions_head == NULL && do_free_macendpoint == GNUNET_YES) + { + free_macendpoint (plugin, endpoint); + //check if no endpoint with the same address exists + GNUNET_assert (get_macendpoint (plugin, &endpoint->addr, GNUNET_NO) == + NULL); + } + + if (queue->content->timeout_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (queue->content->timeout_task); + queue->content->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free (queue); + + check_fragment_queue (plugin); +} + +/** + * Function that can be used to force the plugin to disconnect + * from the given peer and cancel all previous transmissions + * (and their continuation). + * + * @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 GNUNET_TRANSPORT_WLAN_MacAddress)) + { + /* invalid address (MAC addresses have 6 bytes) */ + //GNUNET_break (0); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_plugin_address_pretty_printer got size: %u, worng size!\n", + addrlen); + asc (asc_cls, NULL); + return; + } + input = (const unsigned char *) addr; + GNUNET_asprintf (&ret, + "Transport %s: %s Mac-Address %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", + type, PROTOCOL_PREFIX, input[0], input[1], input[2], + input[3], input[4], input[5]); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_plugin_address_pretty_printer got size: %u, nummeric %u, type %s; made string: %s\n", + addrlen, numeric, type, ret); + asc (asc_cls, ret); + //only one mac address per plugin + asc (asc_cls, NULL); +} + + + +/** + * handels the data after all fragments are put together + * @param cls macendpoint this messages belongs to + * @param hdr pointer to the data + */ +static void +wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr) +{ + struct MacEndpoint *endpoint = (struct MacEndpoint *) cls; + struct Plugin *plugin = endpoint->plugin; + struct WlanHeader *wlanheader; + struct Session *session; + + const struct GNUNET_MessageHeader *temp_hdr; + struct GNUNET_PeerIdentity tmpsource; + int crc; + + GNUNET_assert (plugin != NULL); + + if (ntohs (hdr->type) == GNUNET_MESSAGE_TYPE_WLAN_DATA) + { + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_data_message_handler got GNUNET_MESSAGE_TYPE_WLAN_DATA size: %u\n", + ntohs (hdr->size)); + + if (ntohs (hdr->size) < + sizeof (struct WlanHeader) + sizeof (struct GNUNET_MessageHeader)) + { + //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 (GNUNET_CRYPTO_crc32_n + ((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", + GNUNET_CRYPTO_crc32_n ((char *) wlanheader, + ntohs (wlanheader->header.size)), + crc); + hexdump ((void *) hdr, ntohs (hdr->size)); + return; + } + + //if not in session list + if (session == NULL) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "WLAN client not in session list: packet size = %u, inner size = %u, header size = %u\n", + ntohs (wlanheader->header.size), ntohs (temp_hdr->size), + sizeof (struct WlanHeader)); + //try if it is a hello message + if (ntohs (wlanheader->header.size) >= + ntohs (temp_hdr->size) + sizeof (struct WlanHeader)) + { + 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 + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "WLAN peer source id doesn't match packet peer source id: session %p\n", + session); + return; + } + + if (memcmp + (&wlanheader->target, plugin->env->my_identity, + sizeof (struct GNUNET_PeerIdentity)) != 0) + { + //wrong peer id + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "WLAN peer target id doesn't match our peer id: session %p\n", + session); + return; + } + + GNUNET_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_ATS_Information ats[2]; + + ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE); + ats[0].value = htonl (1); + ats[1].type = htonl (GNUNET_ATS_NETWORK_TYPE); + ats[1].value = htonl (GNUNET_ATS_NET_WLAN); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Calling plugin->env->receive for session %p; %s; size: %u\n", + session, wlan_plugin_address_to_string (NULL, + session->mac-> + addr.mac, 6), + htons (hdr->size)); + plugin->env->receive (plugin->env->cls, &(session->target), hdr, + (const struct GNUNET_ATS_Information *) &ats, 2, + session, (const char *) &session->mac->addr, + sizeof (session->mac->addr)); +} + +/** + * Function used for to process the data received from the wlan interface + * + * @param cls the plugin handle + * @param session_light pointer to the struct holding known informations + * @param hdr hdr of the GNUNET_MessageHeader + * @param rxinfo pointer to the radiotap informations got with this packet FIXME: give ATS for info + */ +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); + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_HELLO size: %u; %s\n", + ntohs (hdr->size), wlan_plugin_address_to_string (NULL, + session_light->addr. + mac, 6)); + if (session_light->macendpoint == NULL) + { + session_light->macendpoint = + get_macendpoint (plugin, &session_light->addr, GNUNET_YES); + } + + + if (GNUNET_HELLO_get_id + ((const struct GNUNET_HELLO_Message *) hdr, &tmpsource) == GNUNET_OK) + { + session_light->session = + search_session (plugin, session_light->macendpoint, &tmpsource); + if (session_light->session == NULL) + { + session_light->session = + create_session (plugin, session_light->macendpoint, &tmpsource); + } + GNUNET_STATISTICS_update (plugin->env->stats, + _("# wlan hello messages received"), 1, + GNUNET_NO); + plugin->env->receive (plugin->env->cls, &session_light->session->target, + hdr, NULL, 0, session_light->session, + (const char *) &session_light->session->mac->addr, + sizeof (session_light->session->mac->addr)); + } + else + { + 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); + } + + 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)); + 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) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Macendpoint does not exist for this GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; %s\n", + ntohs (hdr->size), wlan_plugin_address_to_string (NULL, + session_light->addr.mac, + 6)); + return; + } + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_data_helper got GNUNET_MESSAGE_TYPE_FRAGMENT_ACK size: %u; mac endpoint: %p; %s\n", + ntohs (hdr->size), session_light->macendpoint, + wlan_plugin_address_to_string (NULL, + session_light->addr.mac, + 6)); + fm = session_light->macendpoint->sending_messages_head; + while (fm != NULL) + { + fm2 = fm->next; + GNUNET_STATISTICS_update (plugin->env->stats, _("# wlan acks received"), + 1, GNUNET_NO); + int ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr); + + if (ret == GNUNET_OK) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Got last ack, finished fragment message %p\n", fm); + session_light->macendpoint->acks++; + fm->session->last_activity = GNUNET_TIME_absolute_get (); + session_light->macendpoint->last_activity = fm->session->last_activity; + free_fragment_message (plugin, fm); + check_fragment_queue (plugin); + return; + } + if (ret == GNUNET_NO) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Got ack for: %p\n", fm); + session_light->macendpoint->acks++; + return; + } + if (ret == GNUNET_SYSERR) + { + + } + + fm = fm2; + } + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "WLAN fragment not in fragment list\n"); + return; + + } + else + { + // TODO Wrong data? + GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, PLUGIN_LOG_NAME, + "WLAN packet inside the WLAN helper packet has not the right type: %u size: %u\n", + ntohs (hdr->type), ntohs (hdr->size)); + GNUNET_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 + */ +static 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 GNUNET_TRANSPORT_WLAN_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_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), + plugin->mac_count, GNUNET_NO); + GNUNET_CONTAINER_DLL_insert_tail (plugin->mac_head, plugin->mac_tail, newend); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "New Mac Endpoint %p: %s\n", newend, + wlan_plugin_address_to_string (NULL, newend->addr.mac, 6)); + return newend; +} + +/** + * 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: + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_process_helper got GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA size: %u\n", + ntohs (hdr->size)); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# wlan WLAN_HELPER_DATA received"), 1, + GNUNET_NO); + //call wlan_process_helper with the message inside, later with wlan: analyze signal + if (ntohs (hdr->size) < + sizeof (struct ieee80211_frame) + + 2 * sizeof (struct GNUNET_MessageHeader) + sizeof (struct Radiotap_rx)) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Size of packet is too small; size: %u min size: %u\n", + ntohs (hdr->size), + sizeof (struct ieee80211_frame) + + sizeof (struct GNUNET_MessageHeader)); + //GNUNET_break (0); + /* FIXME: restart SUID process */ + return; + } + + rxinfo = (struct Radiotap_rx *) &hdr[1]; + wlanIeeeHeader = (struct ieee80211_frame *) &rxinfo[1]; + + //process only if it is an broadcast or for this computer both with the gnunet bssid + + //check for bssid + if (memcmp + (&(wlanIeeeHeader->i_addr3), &mac_bssid_gnunet, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + { + //check for broadcast or mac + if ((memcmp + (&(wlanIeeeHeader->i_addr1), &bc_all_mac, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) || + (memcmp + (&(wlanIeeeHeader->i_addr1), &(plugin->mac_address), + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)) + { + //if packet is from us return + if ((memcmp + (&(wlanIeeeHeader->i_addr2), &(plugin->mac_address), + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0)) + { + return; + } + // process the inner data + + + datasize = + ntohs (hdr->size) - sizeof (struct ieee80211_frame) - + sizeof (struct GNUNET_MessageHeader) - sizeof (struct Radiotap_rx); + + session_light = GNUNET_malloc (sizeof (struct Session_light)); + memcpy (&session_light->addr, &(wlanIeeeHeader->i_addr2), + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + //session_light->session = search_session(plugin,session_light->addr); + GNUNET_STATISTICS_update (plugin->env->stats, + _("# wlan messages for this client received"), + 1, GNUNET_NO); + + pos = 0; + while (pos < datasize) + { + temp_hdr = (struct GNUNET_MessageHeader *) &wlanIeeeHeader[1] + pos; + if (ntohs (temp_hdr->size) <= datasize + pos) + { + GNUNET_STATISTICS_update (plugin->env->stats, + _ + ("# wlan messages inside WLAN_HELPER_DATA received"), + 1, GNUNET_NO); + wlan_data_helper (plugin, session_light, temp_hdr, rxinfo); + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Size of packet is too small; size: %u > size of packet: %u\n", + ntohs (temp_hdr->size), datasize + pos); + } + pos += ntohs (temp_hdr->size); + + } + + //clean up + GNUNET_free (session_light); + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_process_helper got wrong MAC: %s\n", + macprinter (wlanIeeeHeader->i_addr1)); + } + } + else + { + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_process_helper got wrong BSSID: %s\n", + macprinter (wlanIeeeHeader->i_addr2)); + } + break; + case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL: + //TODO more control messages + if (ntohs (hdr->size) != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)) + { + GNUNET_break (0); + /* FIXME: restart SUID process */ + return; + } + memcpy (&plugin->mac_address, &hdr[1], sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Received WLAN_HELPER_CONTROL message with transport of address %s\n", + wlan_plugin_address_to_string (cls, &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))); + plugin->env->notify_address (plugin->env->cls, GNUNET_YES, + &plugin->mac_address, + sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); + break; + default: + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "Func wlan_process_helper got unknown message with number %u, size %u\n", + ntohs (hdr->type), ntohs (hdr->size)); + +#if DEBUG_WLAN > 1 + hexdump (hdr, GNUNET_MIN (ntohs (hdr->size), 256)); +#endif + GNUNET_break (0); + return; + } +} + +/** + * 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; + + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "libgnunet_plugin_transport_wlan_done started\n"); + wlan_transport_stop_wlan_helper (plugin); + + GNUNET_assert (cls != NULL); + //free sessions + while (endpoint != NULL) + { + endpoint_next = endpoint->next; + free_macendpoint (plugin, endpoint); + endpoint = endpoint_next; + + } + + + 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; + + 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; + GNUNET_STATISTICS_set (plugin->env->stats, _("# wlan mac endpoints"), + plugin->mac_count, GNUNET_NO); + plugin->server_write_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_read_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_write_delay_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_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->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", &(plugin->testmode))) + plugin->testmode = 0; //default value + } + + if (GNUNET_CONFIGURATION_have_value (env->cfg, "transport-wlan", "INTERFACE")) + { + if (GNUNET_CONFIGURATION_get_value_string + (env->cfg, "transport-wlan", "INTERFACE", + &(plugin->interface)) != GNUNET_YES) + { + libgnunet_plugin_transport_wlan_done (api); + return NULL; + } + } + + //start the plugin + wlan_transport_start_wlan_helper (plugin); + set_next_beacon_time (plugin); + set_next_send (plugin); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, PLUGIN_LOG_NAME, + "wlan init finished\n"); + return api; +} + +/* end of plugin_transport_wlan.c */ |