+ 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)
+{
+
+#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;
+ struct Finish_send *finish;
+
+ 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));
+ 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);
+
+#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++;
+ 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);
+#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
+ */
+static void
+send_ack (struct Plugin *plugin)
+{
+
+ ssize_t bytes;
+ struct AckSendQueue *ack;
+ struct Finish_send *finish;
+
+ ack = plugin->ack_send_queue_head;
+
+
+#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));
+ 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);
+
+#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 != 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 healper. 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;
+ }
+
+ GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, PLUGIN_LOG_NAME,
+ "do_transmit did nothing, should not happen!\n");
+}