plugin_transport_wlan.c

Go to the documentation of this file.

/*
   This file is part of GNUnet
   Copyright (C) 2010-2014 GNUnet e.V.

   GNUnet is free software: you can redistribute it and/or modify it
   under the terms of the GNU Affero General Public License as published
   by the Free Software Foundation, either version 3 of the License,
   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
   Affero General Public License for more details.

   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_plugin.h"
#include "plugin_transport_wlan.h"
#include "gnunet_fragmentation_lib.h"
#include "gnunet_constants.h"


#if BUILD_WLAN
/* begin case wlan */
#define PLUGIN_NAME "wlan"
#define CONFIG_NAME "transport-wlan"
#define HELPER_NAME "gnunet-helper-transport-wlan"
#define DUMMY_HELPER_NAME "gnunet-helper-transport-wlan-dummy"
#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_wlan_init
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_wlan_done
#define LOG(kind, ...) GNUNET_log_from(kind, "transport-wlan", __VA_ARGS__)


#define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2)

#define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2)


/* end case wlan */
#elif BUILD_BLUETOOTH
/* begin case bluetooth */

#define PLUGIN_NAME "bluetooth"
#define CONFIG_NAME "transport-bluetooth"
#define HELPER_NAME "gnunet-helper-transport-bluetooth"
/* yes, this is correct, we use the same dummy driver as 'wlan' */
#define DUMMY_HELPER_NAME "gnunet-helper-transport-wlan-dummy"
#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_bluetooth_init
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_bluetooth_done
#define LOG(kind, ...) GNUNET_log_from(kind, "transport-bluetooth", __VA_ARGS__)

#define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 60)


#define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)

/* end case bluetooth */
#else
#error need to build wlan or bluetooth
#endif



typedef int
(*GNUNET_SERVER_MessageTokenizerCallback) (void *cls,
                                           void *client,
                                           const struct GNUNET_MessageHeader *message);


/* Include legacy message stream tokenizer that was removed from util (for now) */
#include "tcp_server_mst_legacy.c"


#define WLAN_MTU 1430


#if BUILD_WLAN
static const enum GNUNET_NetworkType scope = GNUNET_NT_WLAN;
#else
static const enum GNUNET_NetworkType scope = GNUNET_NT_BT;
#endif


#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 2

#define WLAN_LLC_DSAP_FIELD 0x1f
#define WLAN_LLC_SSAP_FIELD 0x1f


GNUNET_NETWORK_STRUCT_BEGIN
struct WlanHeader {
  struct GNUNET_MessageHeader header;

  uint32_t crc GNUNET_PACKED;

  struct GNUNET_PeerIdentity sender;

  struct GNUNET_PeerIdentity target;

  /* followed by payload, possibly including
     multiple messages! */
};


struct WlanAddress {
  uint32_t options GNUNET_PACKED;

  struct GNUNET_TRANSPORT_WLAN_MacAddress mac;
};


GNUNET_NETWORK_STRUCT_END


struct PendingMessage {
  struct PendingMessage *next;

  struct PendingMessage *prev;

  struct WlanHeader *msg;

  GNUNET_TRANSPORT_TransmitContinuation transmit_cont;

  void *transmit_cont_cls;

  struct GNUNET_SCHEDULER_Task * timeout_task;
};


struct GNUNET_ATS_Session {
  struct GNUNET_PeerIdentity target;

  struct GNUNET_ATS_Session *next;

  struct GNUNET_ATS_Session *prev;

  struct MacEndpoint *mac;

  struct GNUNET_HELLO_Address *address;

  struct GNUNET_TIME_Absolute timeout;

  struct GNUNET_SCHEDULER_Task * timeout_task;
};


struct FragmentMessage {
  struct FragmentMessage *next;

  struct FragmentMessage *prev;

  struct MacEndpoint *macendpoint;

  struct GNUNET_FRAGMENT_Context *fragcontext;

  struct GNUNET_HELPER_SendHandle *sh;

  struct GNUNET_PeerIdentity target;

  struct GNUNET_TIME_Absolute timeout;

  struct GNUNET_SCHEDULER_Task * timeout_task;

  GNUNET_TRANSPORT_TransmitContinuation cont;

  struct GNUNET_MessageHeader *msg;

  void *cont_cls;

  size_t size_payload;

  size_t size_on_wire;
};


struct MacEndpoint {
  struct MacEndpoint *next;

  struct MacEndpoint *prev;

  struct Plugin *plugin;

  struct GNUNET_ATS_Session *sessions_head;

  struct GNUNET_ATS_Session *sessions_tail;

  struct FragmentMessage *sending_messages_head;

  struct FragmentMessage *sending_messages_tail;

  struct GNUNET_DEFRAGMENT_Context *defrag;

  struct GNUNET_TIME_Absolute timeout;

  struct GNUNET_SCHEDULER_Task * timeout_task;

  unsigned int fragment_messages_out_count;

  struct WlanAddress wlan_addr;

  struct GNUNET_TIME_Relative msg_delay;

  struct GNUNET_TIME_Relative ack_delay;

  uint16_t tx_power;

  uint8_t rate;

  uint8_t antenna;
};


struct Plugin {
  struct GNUNET_TRANSPORT_PluginEnvironment *env;

  struct GNUNET_HELPER_Handle *suid_helper;

  GNUNET_TRANSPORT_SessionInfoCallback sic;

  void *sic_cls;

  char *helper_argv[3];

  char *wlan_interface;

  struct GNUNET_SERVER_MessageStreamTokenizer *fragment_data_tokenizer;

  struct GNUNET_SERVER_MessageStreamTokenizer *helper_payload_tokenizer;

  struct GNUNET_SERVER_MessageStreamTokenizer *wlan_header_payload_tokenizer;

  struct MacEndpoint *mac_head;

  struct MacEndpoint *mac_tail;

  struct GNUNET_SCHEDULER_Task *beacon_task;

  struct GNUNET_BANDWIDTH_Tracker tracker;

  struct GNUNET_TRANSPORT_WLAN_MacAddress mac_address;

  int have_mac;

  unsigned int mac_count;

  uint32_t options;
};


struct MacAndSession {
  struct GNUNET_ATS_Session *session;

  struct MacEndpoint *endpoint;
};


static const char *
mac_to_string(const struct GNUNET_TRANSPORT_WLAN_MacAddress * mac)
{
  static char macstr[20];

  GNUNET_snprintf(macstr,
                  sizeof(macstr),
                  "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
                  mac->mac[0], mac->mac[1],
                  mac->mac[2], mac->mac[3],
                  mac->mac[4], mac->mac[5]);
  return macstr;
}


static const char *
wlan_plugin_address_to_string(void *cls,
                              const void *addr,
                              size_t addrlen)
{
  const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac;
  static char macstr[36];

  if (sizeof(struct WlanAddress) != addrlen)
    {
      GNUNET_break(0);
      return NULL;
    }
  mac = &((struct WlanAddress *)addr)->mac;
  GNUNET_snprintf(macstr,
                  sizeof(macstr),
                  "%s.%u.%s",
                  PLUGIN_NAME,
                  ntohl(((struct WlanAddress *)addr)->options),
                  mac_to_string(mac));
  return macstr;
}


static void
notify_session_monitor(struct Plugin *plugin,
                       struct GNUNET_ATS_Session *session,
                       enum GNUNET_TRANSPORT_SessionState state)
{
  struct GNUNET_TRANSPORT_SessionInfo info;

  if (NULL == plugin->sic)
    return;
  memset(&info, 0, sizeof(info));
  info.state = state;
  info.is_inbound = GNUNET_SYSERR; /* hard to say */
  info.num_msg_pending = 0; /* we queue per MAC, not per peer */
  info.num_bytes_pending = 0; /* we queue per MAC, not per peer */
  info.receive_delay = GNUNET_TIME_UNIT_ZERO_ABS; /* not supported by WLAN */
  info.session_timeout = session->timeout;
  info.address = session->address;
  plugin->sic(plugin->sic_cls,
              session,
              &info);
}


static void
get_radiotap_header(struct MacEndpoint *endpoint,
                    struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header,
                    uint16_t size)
{
  header->header.type = ntohs(GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER);
  header->header.size = ntohs(size);
  if (NULL != endpoint)
    {
      header->rate = endpoint->rate;
      header->tx_power = endpoint->tx_power;
      header->antenna = endpoint->antenna;
    }
  else
    {
      header->rate = 255;
      header->tx_power = 0;
      header->antenna = 0;
    }
}


static void
get_wlan_header(struct Plugin *plugin,
                struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *header,
                const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr,
                unsigned int size)
{
  const int rate = 11000000;

  header->frame_control = htons(IEEE80211_FC0_TYPE_DATA);
  header->addr1 = *to_mac_addr;
  header->addr2 = plugin->mac_address;
  header->addr3 = mac_bssid_gnunet;
  header->duration = GNUNET_htole16((size * 1000000) / rate + 290);
  header->sequence_control = 0; // FIXME?
  header->llc[0] = WLAN_LLC_DSAP_FIELD;
  header->llc[1] = WLAN_LLC_SSAP_FIELD;
  header->llc[2] = 0;  // FIXME?
  header->llc[3] = 0;  // FIXME?
}


static void
send_ack(void *cls,
         uint32_t msg_id,
         const struct GNUNET_MessageHeader *hdr)
{
  struct MacEndpoint *endpoint = cls;
  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage* radio_header;
  uint16_t msize = ntohs(hdr->size);
  size_t size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
  char buf[size];

  if (NULL == endpoint)
    {
      GNUNET_break(0);
      return;
    }
  if (size >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Sending ACK to %s\n",
      mac_to_string(&endpoint->wlan_addr.mac));
  radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *)buf;
  get_radiotap_header(endpoint, radio_header, size);
  get_wlan_header(endpoint->plugin,
                  &radio_header->frame,
                  &endpoint->wlan_addr.mac,
                  sizeof(endpoint->wlan_addr.mac));
  GNUNET_memcpy(&radio_header[1], hdr, msize);
  if (NULL !=
      GNUNET_HELPER_send(endpoint->plugin->suid_helper,
                         &radio_header->header,
                         GNUNET_NO /* dropping ACKs is bad */,
                         NULL, NULL))
    GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                             _("# ACKs sent"),
                             1, GNUNET_NO);
}


static void
wlan_data_message_handler(void *cls,
                          const struct GNUNET_MessageHeader *hdr)
{
  struct MacEndpoint *endpoint = cls;
  struct Plugin *plugin = endpoint->plugin;
  struct MacAndSession mas;

  GNUNET_STATISTICS_update(plugin->env->stats,
                           _("# Messages defragmented"),
                           1,
                           GNUNET_NO);
  mas.session = NULL;
  mas.endpoint = endpoint;
  (void)GNUNET_SERVER_mst_receive(plugin->fragment_data_tokenizer,
                                  &mas,
                                  (const char *)hdr,
                                  ntohs(hdr->size),
                                  GNUNET_YES, GNUNET_NO);
}


static int
wlan_plugin_disconnect_session(void *cls,
                               struct GNUNET_ATS_Session *session)
{
  struct MacEndpoint *endpoint = session->mac;
  struct Plugin *plugin = endpoint->plugin;

  plugin->env->session_end(plugin->env->cls,
                           session->address,
                           session);
  notify_session_monitor(plugin,
                         session,
                         GNUNET_TRANSPORT_SS_DONE);
  GNUNET_CONTAINER_DLL_remove(endpoint->sessions_head,
                              endpoint->sessions_tail,
                              session);
  if (session->timeout_task != NULL)
    {
      GNUNET_SCHEDULER_cancel(session->timeout_task);
      session->timeout_task = NULL;
    }
  GNUNET_STATISTICS_update(plugin->env->stats,
                           _("# Sessions allocated"),
                           -1,
                           GNUNET_NO);
  GNUNET_HELLO_address_free(session->address);
  GNUNET_free(session);
  return GNUNET_OK;
}


static unsigned int
wlan_plugin_query_keepalive_factor(void *cls)
{
  return 3;
}


static void
session_timeout(void *cls)
{
  struct GNUNET_ATS_Session *session = cls;
  struct GNUNET_TIME_Relative left;

  session->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining(session->timeout);
  if (0 != left.rel_value_us)
    {
      session->timeout_task =
        GNUNET_SCHEDULER_add_delayed(left,
                                     &session_timeout,
                                     session);
      return;
    }
  wlan_plugin_disconnect_session(session->mac->plugin,
                                 session);
}



static struct GNUNET_ATS_Session *
lookup_session(struct MacEndpoint *endpoint,
               const struct GNUNET_PeerIdentity *peer)
{
  struct GNUNET_ATS_Session *session;

  for (session = endpoint->sessions_head; NULL != session; session = session->next)
    if (0 == memcmp(peer, &session->target, sizeof(struct GNUNET_PeerIdentity)))
      return session;
  return NULL;
}


static struct GNUNET_ATS_Session *
create_session(struct MacEndpoint *endpoint,
               const struct GNUNET_PeerIdentity *peer)
{
  struct GNUNET_ATS_Session *session;

  GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                           _("# Sessions allocated"),
                           1,
                           GNUNET_NO);
  session = GNUNET_new(struct GNUNET_ATS_Session);
  GNUNET_CONTAINER_DLL_insert_tail(endpoint->sessions_head,
                                   endpoint->sessions_tail,
                                   session);
  session->address = GNUNET_HELLO_address_allocate(peer,
                                                   PLUGIN_NAME,
                                                   &endpoint->wlan_addr,
                                                   sizeof(endpoint->wlan_addr),
                                                   GNUNET_HELLO_ADDRESS_INFO_NONE);
  session->mac = endpoint;
  session->target = *peer;
  session->timeout = GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  session->timeout_task =
    GNUNET_SCHEDULER_add_delayed(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout,
                                 session);
  notify_session_monitor(endpoint->plugin,
                         session,
                         GNUNET_TRANSPORT_SS_INIT);
  notify_session_monitor(endpoint->plugin,
                         session,
                         GNUNET_TRANSPORT_SS_UP);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Created new session %p for peer `%s' with endpoint %s\n",
      session,
      GNUNET_i2s(peer),
      mac_to_string(&endpoint->wlan_addr.mac));

  return session;
}


static struct GNUNET_ATS_Session *
get_session(struct MacEndpoint *endpoint,
            const struct GNUNET_PeerIdentity *peer)
{
  struct GNUNET_ATS_Session *session;

  if (NULL != (session = lookup_session(endpoint, peer)))
    return session;
  return create_session(endpoint, peer);
}


static void
fragment_transmission_done(void *cls,
                           int result)
{
  struct FragmentMessage *fm = cls;

  fm->sh = NULL;
  GNUNET_FRAGMENT_context_transmission_done(fm->fragcontext);
}


static void
transmit_fragment(void *cls,
                  const struct GNUNET_MessageHeader *hdr)
{
  struct FragmentMessage *fm = cls;
  struct MacEndpoint *endpoint = fm->macendpoint;
  size_t size;
  uint16_t msize;

  if (NULL == endpoint)
    {
      GNUNET_break(0);
      return;
    }
  msize = ntohs(hdr->size);
  size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
  {
    char buf[size];
    struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radio_header;

    radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *)buf;
    get_radiotap_header(endpoint, radio_header, size);
    LOG(GNUNET_ERROR_TYPE_DEBUG,
        "Sending %u bytes of data to MAC `%s'\n",
        (unsigned int)msize,
        mac_to_string(&endpoint->wlan_addr.mac));

    get_wlan_header(endpoint->plugin,
                    &radio_header->frame,
                    &endpoint->wlan_addr.mac,
                    sizeof(endpoint->wlan_addr.mac));
    GNUNET_memcpy(&radio_header[1], hdr, msize);
    GNUNET_assert(NULL == fm->sh);
    fm->sh = GNUNET_HELPER_send(endpoint->plugin->suid_helper,
                                &radio_header->header,
                                GNUNET_NO,
                                &fragment_transmission_done, fm);
    fm->size_on_wire += size;
    if (NULL != fm->sh)
      {
        GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                                 _("# message fragments sent"),
                                 1,
                                 GNUNET_NO);
      }
    else
      {
        GNUNET_FRAGMENT_context_transmission_done(fm->fragcontext);
      }
    GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                             "# bytes currently in buffers",
                             -msize, GNUNET_NO);
    GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                             "# bytes transmitted",
                             msize, GNUNET_NO);
  }
}


static void
free_fragment_message(struct FragmentMessage *fm)
{
  struct MacEndpoint *endpoint = fm->macendpoint;

  GNUNET_STATISTICS_update(endpoint->plugin->env->stats,
                           _("# messages pending (with fragmentation)"),
                           -1, GNUNET_NO);
  GNUNET_CONTAINER_DLL_remove(endpoint->sending_messages_head,
                              endpoint->sending_messages_tail,
                              fm);
  if (NULL != fm->sh)
    {
      GNUNET_HELPER_send_cancel(fm->sh);
      fm->sh = NULL;
    }
  if (NULL != fm->msg)
    {
      GNUNET_free(fm->msg);
      fm->msg = NULL;
    }
  if (NULL != fm->fragcontext)
    {
      GNUNET_FRAGMENT_context_destroy(fm->fragcontext,
                                      &endpoint->msg_delay,
                                      &endpoint->ack_delay);
      fm->fragcontext = NULL;
    }
  if (NULL != fm->timeout_task)
    {
      GNUNET_SCHEDULER_cancel(fm->timeout_task);
      fm->timeout_task = NULL;
    }
  GNUNET_free(fm);
}


static void
fragmentmessage_timeout(void *cls)
{
  struct FragmentMessage *fm = cls;

  fm->timeout_task = NULL;
  if (NULL != fm->cont)
    {
      fm->cont(fm->cont_cls,
               &fm->target,
               GNUNET_SYSERR,
               fm->size_payload,
               fm->size_on_wire);
      fm->cont = NULL;
    }
  free_fragment_message(fm);
}


static void
send_with_fragmentation(struct MacEndpoint *endpoint,
                        struct GNUNET_TIME_Relative timeout,
                        const struct GNUNET_PeerIdentity *target,
                        const struct GNUNET_MessageHeader *msg,
                        size_t payload_size,
                        GNUNET_TRANSPORT_TransmitContinuation cont,
                        void *cont_cls)

{
  struct FragmentMessage *fm;
  struct Plugin *plugin;

  plugin = endpoint->plugin;
  fm = GNUNET_new(struct FragmentMessage);
  fm->macendpoint = endpoint;
  fm->target = *target;
  fm->size_payload = payload_size;
  fm->timeout = GNUNET_TIME_relative_to_absolute(timeout);
  fm->cont = cont;
  fm->cont_cls = cont_cls;
  /* 1 MBit/s typical data rate, 1430 byte fragments => ~100 ms per message */
  fm->timeout_task =
    GNUNET_SCHEDULER_add_delayed(timeout,
                                 &fragmentmessage_timeout,
                                 fm);
  if (GNUNET_YES == plugin->have_mac)
    {
      fm->fragcontext =
        GNUNET_FRAGMENT_context_create(plugin->env->stats,
                                       WLAN_MTU,
                                       &plugin->tracker,
                                       fm->macendpoint->msg_delay,
                                       fm->macendpoint->ack_delay,
                                       msg,
                                       &transmit_fragment, fm);
    }
  else
    {
      fm->msg = GNUNET_copy_message(msg);
    }
  GNUNET_CONTAINER_DLL_insert_tail(endpoint->sending_messages_head,
                                   endpoint->sending_messages_tail,
                                   fm);
}


static void
free_macendpoint(struct MacEndpoint *endpoint)
{
  struct Plugin *plugin = endpoint->plugin;
  struct FragmentMessage *fm;
  struct GNUNET_ATS_Session *session;

  GNUNET_STATISTICS_update(plugin->env->stats,
                           _("# MAC endpoints allocated"),
                           -1,
                           GNUNET_NO);
  while (NULL != (session = endpoint->sessions_head))
    wlan_plugin_disconnect_session(plugin,
                                   session);
  while (NULL != (fm = endpoint->sending_messages_head))
    free_fragment_message(fm);
  GNUNET_CONTAINER_DLL_remove(plugin->mac_head,
                              plugin->mac_tail,
                              endpoint);

  if (NULL != endpoint->defrag)
    {
      GNUNET_DEFRAGMENT_context_destroy(endpoint->defrag);
      endpoint->defrag = NULL;
    }

  plugin->mac_count--;
  if (NULL != endpoint->timeout_task)
    {
      GNUNET_SCHEDULER_cancel(endpoint->timeout_task);
      endpoint->timeout_task = NULL;
    }
  GNUNET_free(endpoint);
}


static void
macendpoint_timeout(void *cls)
{
  struct MacEndpoint *endpoint = cls;
  struct GNUNET_TIME_Relative timeout;

  endpoint->timeout_task = NULL;
  timeout = GNUNET_TIME_absolute_get_remaining(endpoint->timeout);
  if (0 == timeout.rel_value_us)
    {
      free_macendpoint(endpoint);
      return;
    }
  endpoint->timeout_task =
    GNUNET_SCHEDULER_add_delayed(timeout,
                                 &macendpoint_timeout,
                                 endpoint);
}


static struct MacEndpoint *
create_macendpoint(struct Plugin *plugin,
                   struct WlanAddress *mac)
{
  struct MacEndpoint *pos;

  for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
    if (0 == memcmp(mac, &pos->wlan_addr, sizeof(pos->wlan_addr)))
      return pos;
  pos = GNUNET_new(struct MacEndpoint);
  pos->wlan_addr = (*mac);
  pos->plugin = plugin;
  pos->defrag =
    GNUNET_DEFRAGMENT_context_create(plugin->env->stats,
                                     WLAN_MTU,
                                     MESSAGES_IN_DEFRAG_QUEUE_PER_MAC,
                                     pos,
                                     &wlan_data_message_handler,
                                     &send_ack);

  pos->msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
  pos->ack_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100);
  pos->timeout = GNUNET_TIME_relative_to_absolute(MACENDPOINT_TIMEOUT);
  pos->timeout_task =
    GNUNET_SCHEDULER_add_delayed(MACENDPOINT_TIMEOUT, &macendpoint_timeout,
                                 pos);
  GNUNET_CONTAINER_DLL_insert(plugin->mac_head,
                              plugin->mac_tail,
                              pos);
  plugin->mac_count++;
  GNUNET_STATISTICS_update(plugin->env->stats,
                           _("# MAC endpoints allocated"),
                           1, GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "New MAC endpoint `%s'\n",
      wlan_plugin_address_to_string(NULL,
                                    &pos->wlan_addr,
                                    sizeof(struct WlanAddress)));
  return pos;
}


static enum GNUNET_NetworkType
wlan_plugin_get_network(void *cls,
                        struct GNUNET_ATS_Session *session)
{
#if BUILD_WLAN
  return GNUNET_NT_WLAN;
#else
  return GNUNET_NT_BT;
#endif
}


static enum GNUNET_NetworkType
wlan_plugin_get_network_for_address(void *cls,
                                    const struct GNUNET_HELLO_Address *address)
{
#if BUILD_WLAN
  return GNUNET_NT_WLAN;
#else
  return GNUNET_NT_BT;
#endif
}


static struct GNUNET_ATS_Session *
wlan_plugin_get_session(void *cls,
                        const struct GNUNET_HELLO_Address *address)
{
  struct Plugin *plugin = cls;
  struct MacEndpoint *endpoint;

  if (NULL == address)
    return NULL;
  if (sizeof(struct WlanAddress) != address->address_length)
    {
      GNUNET_break(0);
      return NULL;
    }
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Service asked to create session for peer `%s' with MAC `%s'\n",
      GNUNET_i2s(&address->peer),
      wlan_plugin_address_to_string(NULL,
                                    address->address,
                                    address->address_length));
  endpoint = create_macendpoint(plugin,
                                (struct WlanAddress *)address->address);
  return get_session(endpoint, &address->peer);
}


static void
wlan_plugin_disconnect_peer(void *cls,
                            const struct GNUNET_PeerIdentity *target)
{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session;
  struct MacEndpoint *endpoint;

  for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next)
    for (session = endpoint->sessions_head; NULL != session; session = session->next)
      if (0 == memcmp(target, &session->target,
                      sizeof(struct GNUNET_PeerIdentity)))
        {
          wlan_plugin_disconnect_session(plugin, session);
          break; /* inner-loop only (in case peer has another MAC as well!) */
        }
}


static ssize_t
wlan_plugin_send(void *cls,
                 struct GNUNET_ATS_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 WlanHeader *wlanheader;
  size_t size = msgbuf_size + sizeof(struct WlanHeader);
  char buf[size] GNUNET_ALIGN;

  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Transmitting %u bytes of payload to peer `%s' (starting with %u byte message of type %u)\n",
      msgbuf_size,
      GNUNET_i2s(&session->target),
      (unsigned int)ntohs(((struct GNUNET_MessageHeader*)msgbuf)->size),
      (unsigned int)ntohs(((struct GNUNET_MessageHeader*)msgbuf)->type));
  wlanheader = (struct WlanHeader *)buf;
  wlanheader->header.size = htons(msgbuf_size + sizeof(struct WlanHeader));
  wlanheader->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA);
  wlanheader->sender = *plugin->env->my_identity;
  wlanheader->target = session->target;
  wlanheader->crc = htonl(GNUNET_CRYPTO_crc32_n(msgbuf, msgbuf_size));
  GNUNET_memcpy(&wlanheader[1],
                msgbuf,
                msgbuf_size);
  GNUNET_STATISTICS_update(plugin->env->stats,
                           "# bytes currently in buffers",
                           msgbuf_size,
                           GNUNET_NO);
  send_with_fragmentation(session->mac,
                          to,
                          &session->target,
                          &wlanheader->header,
                          msgbuf_size,
                          cont, cont_cls);
  return size;
}


static int
process_data(void *cls,
             void *client,
             const struct GNUNET_MessageHeader *hdr)
{
  struct Plugin *plugin = cls;
  struct GNUNET_HELLO_Address *address;
  struct MacAndSession *mas = client;
  struct FragmentMessage *fm;
  struct GNUNET_PeerIdentity tmpsource;
  const struct WlanHeader *wlanheader;
  int ret;
  uint16_t msize;

  msize = ntohs(hdr->size);

  GNUNET_STATISTICS_update(plugin->env->stats,
                           "# bytes received",
                           msize, GNUNET_NO);

  switch (ntohs(hdr->type))
    {
    case GNUNET_MESSAGE_TYPE_HELLO:

      if (GNUNET_OK !=
          GNUNET_HELLO_get_id((const struct GNUNET_HELLO_Message *)hdr,
                              &tmpsource))
        {
          GNUNET_break_op(0);
          break;
        }
      if (NULL == mas->endpoint)
        {
          GNUNET_break(0);
          break;
        }

      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
          (unsigned int)msize,
          GNUNET_i2s(&tmpsource),
          wlan_plugin_address_to_string(NULL,
                                        &mas->endpoint->wlan_addr,
                                        sizeof(mas->endpoint->wlan_addr)));

      GNUNET_STATISTICS_update(plugin->env->stats,
                               _("# HELLO messages received"), 1,
                               GNUNET_NO);
      address = GNUNET_HELLO_address_allocate(&tmpsource,
                                              PLUGIN_NAME,
                                              &mas->endpoint->wlan_addr,
                                              sizeof(mas->endpoint->wlan_addr),
                                              GNUNET_HELLO_ADDRESS_INFO_NONE);
      mas->session = lookup_session(mas->endpoint,
                                    &tmpsource);
      if (NULL == mas->session)
        {
          mas->session = create_session(mas->endpoint,
                                        &tmpsource);
          plugin->env->session_start(plugin->env->cls,
                                     address,
                                     mas->session,
                                     scope);
        }
      plugin->env->receive(plugin->env->cls,
                           address,
                           mas->session,
                           hdr);
      GNUNET_HELLO_address_free(address);
      break;

    case GNUNET_MESSAGE_TYPE_FRAGMENT:
      if (NULL == mas->endpoint)
        {
          GNUNET_break(0);
          break;
        }
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Processing %u bytes of FRAGMENT from MAC %s\n",
          (unsigned int)msize,
          wlan_plugin_address_to_string(NULL,
                                        &mas->endpoint->wlan_addr,
                                        sizeof(mas->endpoint->wlan_addr)));
      GNUNET_STATISTICS_update(plugin->env->stats,
                               _("# fragments received"),
                               1,
                               GNUNET_NO);
      (void)GNUNET_DEFRAGMENT_process_fragment(mas->endpoint->defrag,
                                               hdr);
      break;

    case GNUNET_MESSAGE_TYPE_FRAGMENT_ACK:
      if (NULL == mas->endpoint)
        {
          GNUNET_break(0);
          break;
        }
      GNUNET_STATISTICS_update(plugin->env->stats,
                               _("# ACKs received"),
                               1, GNUNET_NO);
      for (fm = mas->endpoint->sending_messages_head; NULL != fm; fm = fm->next)
        {
          ret = GNUNET_FRAGMENT_process_ack(fm->fragcontext, hdr);
          if (GNUNET_OK == ret)
            {
              LOG(GNUNET_ERROR_TYPE_DEBUG,
                  "Got last ACK, finished message transmission to `%s' (%p)\n",
                  wlan_plugin_address_to_string(NULL,
                                                &mas->endpoint->wlan_addr,
                                                sizeof(mas->endpoint->wlan_addr)),
                  fm);
              mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute(MACENDPOINT_TIMEOUT);
              if (NULL != fm->cont)
                {
                  fm->cont(fm->cont_cls,
                           &fm->target,
                           GNUNET_OK,
                           fm->size_payload,
                           fm->size_on_wire);
                  fm->cont = NULL;
                }
              free_fragment_message(fm);
              break;
            }
          if (GNUNET_NO == ret)
            {
              LOG(GNUNET_ERROR_TYPE_DEBUG,
                  "Got an ACK, message transmission to `%s' not yet finished\n",
                  wlan_plugin_address_to_string(NULL,
                                                &mas->endpoint->wlan_addr,
                                                sizeof(mas->endpoint->wlan_addr)));
              break;
            }
        }
      if (NULL == fm)
        LOG(GNUNET_ERROR_TYPE_DEBUG,
            "ACK not matched against any active fragmentation with MAC `%s'\n",
            wlan_plugin_address_to_string(NULL,
                                          &mas->endpoint->wlan_addr,
                                          sizeof(mas->endpoint->wlan_addr)));
      break;

    case GNUNET_MESSAGE_TYPE_WLAN_DATA:
      if (NULL == mas->endpoint)
        {
          GNUNET_break(0);
          break;
        }
      if (msize < sizeof(struct WlanHeader))
        {
          GNUNET_break(0);
          break;
        }
      wlanheader = (const struct WlanHeader *)hdr;
      if (0 != memcmp(&wlanheader->target,
                      plugin->env->my_identity,
                      sizeof(struct GNUNET_PeerIdentity)))
        {
          LOG(GNUNET_ERROR_TYPE_DEBUG,
              "Data for `%s', not for me, ignoring\n",
              GNUNET_i2s(&wlanheader->target));
          break;
        }
      if (ntohl(wlanheader->crc) !=
          GNUNET_CRYPTO_crc32_n(&wlanheader[1],
                                msize - sizeof(struct WlanHeader)))
        {
          GNUNET_STATISTICS_update(plugin->env->stats,
                                   _("# DATA messages discarded due to CRC32 error"),
                                   1,
                                   GNUNET_NO);
          break;
        }
      mas->session = lookup_session(mas->endpoint,
                                    &wlanheader->sender);
      if (NULL == mas->session)
        {
          mas->session = create_session(mas->endpoint,
                                        &wlanheader->sender);
          address = GNUNET_HELLO_address_allocate(&wlanheader->sender,
                                                  PLUGIN_NAME,
                                                  &mas->endpoint->wlan_addr,
                                                  sizeof(struct WlanAddress),
                                                  GNUNET_HELLO_ADDRESS_INFO_NONE);
          plugin->env->session_start(plugin->env->cls,
                                     address,
                                     mas->session,
                                     scope);
          LOG(GNUNET_ERROR_TYPE_DEBUG,
              "Notifying transport about peer `%s''s new session %p \n",
              GNUNET_i2s(&wlanheader->sender),
              mas->session);
          GNUNET_HELLO_address_free(address);
        }
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Processing %u bytes of DATA from peer `%s'\n",
          (unsigned int)msize,
          GNUNET_i2s(&wlanheader->sender));
      mas->session->timeout = GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
      (void)GNUNET_SERVER_mst_receive(plugin->wlan_header_payload_tokenizer,
                                      mas,
                                      (const char *)&wlanheader[1],
                                      msize - sizeof(struct WlanHeader),
                                      GNUNET_YES,
                                      GNUNET_NO);
      break;

    default:
      if (NULL == mas->endpoint)
        {
          GNUNET_break(0);
          break;
        }
      if (NULL == mas->session)
        {
          GNUNET_break(0);
          break;
        }
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Received packet with %u bytes of type %u from peer %s\n",
          (unsigned int)msize,
          (unsigned int)ntohs(hdr->type),
          GNUNET_i2s(&mas->session->target));
      plugin->env->receive(plugin->env->cls,
                           mas->session->address,
                           mas->session,
                           hdr);
      break;
    }
  return GNUNET_OK;
}


static void
send_hello_beacon(void *cls)
{
  struct Plugin *plugin = cls;
  uint16_t size;
  uint16_t hello_size;
  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radioHeader;
  const struct GNUNET_MessageHeader *hello;

  hello = plugin->env->get_our_hello();
  if (NULL != hello)
    {
      hello_size = GNUNET_HELLO_size((struct GNUNET_HELLO_Message *)hello);
      GNUNET_assert(sizeof(struct WlanHeader) + hello_size <= WLAN_MTU);
      size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + hello_size;
      {
        char buf[size] GNUNET_ALIGN;

        LOG(GNUNET_ERROR_TYPE_DEBUG,
            "Sending %u byte HELLO beacon\n",
            (unsigned int)size);
        radioHeader = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage*)buf;
        get_radiotap_header(NULL, radioHeader, size);
        LOG(GNUNET_ERROR_TYPE_DEBUG,
            "Broadcasting %u bytes of data to MAC `%s'\n",
            (unsigned int)size,
            mac_to_string(&bc_all_mac));
        get_wlan_header(plugin, &radioHeader->frame, &bc_all_mac, size);
        GNUNET_memcpy(&radioHeader[1], hello, hello_size);
        if (NULL !=
            GNUNET_HELPER_send(plugin->suid_helper,
                               &radioHeader->header,
                               GNUNET_YES /* can drop */,
                               NULL, NULL))
          GNUNET_STATISTICS_update(plugin->env->stats,
                                   _("# HELLO beacons sent"),
                                   1, GNUNET_NO);
      }
    }
  plugin->beacon_task =
    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
                                   (HELLO_BEACON_SCALING_FACTOR,
                                   plugin->mac_count + 1),
                                 &send_hello_beacon,
                                 plugin);
}


static int
handle_helper_message(void *cls,
                      const struct GNUNET_MessageHeader *hdr)
{
  struct Plugin *plugin = cls;
  struct GNUNET_HELLO_Address *my_address;
  const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
  const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm;
  struct WlanAddress wa;
  struct MacAndSession mas;
  uint16_t msize;
  struct FragmentMessage *fm;
  struct MacEndpoint *endpoint;

  msize = ntohs(hdr->size);
  switch (ntohs(hdr->type))
    {
    case GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL:
      if (msize != sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage))
        {
          GNUNET_break(0);
          break;
        }
      cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *)hdr;
      if (GNUNET_YES == plugin->have_mac)
        {
          if (0 == memcmp(&plugin->mac_address,
                          &cm->mac,
                          sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
            break; /* no change */
          /* remove old address */
          memset(&wa, 0, sizeof(struct WlanAddress));
          wa.mac = plugin->mac_address;
          wa.options = htonl(plugin->options);
          my_address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
                                                     PLUGIN_NAME,
                                                     &wa, sizeof(wa),
                                                     GNUNET_HELLO_ADDRESS_INFO_NONE);
          plugin->env->notify_address(plugin->env->cls,
                                      GNUNET_NO,
                                      my_address);
          GNUNET_HELLO_address_free(my_address);
          plugin->mac_address = cm->mac;
        }
      else
        {
          plugin->mac_address = cm->mac;
          plugin->have_mac = GNUNET_YES;
          for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next)
            {
              for (fm = endpoint->sending_messages_head; NULL != fm; fm = fm->next)
                {
                  if (NULL != fm->fragcontext)
                    {
                      GNUNET_break(0); /* should not happen */
                      continue;
                    }
                  fm->fragcontext =
                    GNUNET_FRAGMENT_context_create(plugin->env->stats,
                                                   WLAN_MTU,
                                                   &plugin->tracker,
                                                   fm->macendpoint->msg_delay,
                                                   fm->macendpoint->ack_delay,
                                                   fm->msg,
                                                   &transmit_fragment, fm);
                  GNUNET_free(fm->msg);
                  fm->msg = NULL;
                }
            }
          GNUNET_break(NULL == plugin->beacon_task);
          plugin->beacon_task = GNUNET_SCHEDULER_add_now(&send_hello_beacon,
                                                         plugin);
        }

      memset(&wa, 0, sizeof(struct WlanAddress));
      wa.mac = plugin->mac_address;
      wa.options = htonl(plugin->options);
      my_address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
                                                 PLUGIN_NAME,
                                                 &wa, sizeof(wa),
                                                 GNUNET_HELLO_ADDRESS_INFO_NONE);

      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer `%s'\n",
          mac_to_string(&cm->mac),
          GNUNET_i2s(plugin->env->my_identity));
      plugin->env->notify_address(plugin->env->cls,
                                  GNUNET_YES,
                                  my_address);
      GNUNET_HELLO_address_free(my_address);
      break;

    case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER:
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Got data message from helper with %u bytes\n",
          msize);
      GNUNET_STATISTICS_update(plugin->env->stats,
                               _("# DATA messages received"), 1,
                               GNUNET_NO);
      if (msize < sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage))
        {
          LOG(GNUNET_ERROR_TYPE_DEBUG,
              "Size of packet is too small (%u bytes < %u)\n",
              msize, sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage));
          break;
        }
      rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *)hdr;

      /* check if message is actually for us */
      if (0 != memcmp(&rxinfo->frame.addr3, &mac_bssid_gnunet,
                      sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
        {
          /* Not the GNUnet BSSID */
          break;
        }
      if ((0 != memcmp(&rxinfo->frame.addr1, &bc_all_mac,
                       sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress))) &&
          (0 != memcmp(&rxinfo->frame.addr1, &plugin->mac_address,
                       sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress))))
        {
          /* Neither broadcast nor specifically for us */
          break;
        }
      if (0 == memcmp(&rxinfo->frame.addr2, &plugin->mac_address,
                      sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
        {
          /* packet is FROM us, thus not FOR us */
          break;
        }

      GNUNET_STATISTICS_update(plugin->env->stats,
                               _("# DATA messages processed"),
                               1, GNUNET_NO);
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Receiving %u bytes of data from MAC `%s'\n",
          (unsigned int)(msize - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
          mac_to_string(&rxinfo->frame.addr2));
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Receiving %u bytes of data to MAC `%s'\n",
          (unsigned int)(msize - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
          mac_to_string(&rxinfo->frame.addr1));
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Receiving %u bytes of data with BSSID MAC `%s'\n",
          (unsigned int)(msize - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
          mac_to_string(&rxinfo->frame.addr3));
      wa.mac = rxinfo->frame.addr2;
      wa.options = htonl(0);
      mas.endpoint = create_macendpoint(plugin, &wa);
      mas.session = NULL;
      (void)GNUNET_SERVER_mst_receive(plugin->helper_payload_tokenizer,
                                      &mas,
                                      (const char*)&rxinfo[1],
                                      msize - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage),
                                      GNUNET_YES, GNUNET_NO);
      break;

    default:
      GNUNET_break(0);
      LOG(GNUNET_ERROR_TYPE_ERROR,
          "Unexpected message of type %u (%u bytes)",
          ntohs(hdr->type),
          ntohs(hdr->size));
      break;
    }
  return GNUNET_OK;
}


static int
wlan_plugin_address_suggested(void *cls,
                              const void *addr,
                              size_t addrlen)
{
  struct Plugin *plugin = cls;
  struct WlanAddress *wa = (struct WlanAddress *)addr;

  if (addrlen != sizeof(struct WlanAddress))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  if (GNUNET_YES != plugin->have_mac)
    {
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Rejecting MAC `%s': I don't know my MAC!\n",
          mac_to_string(addr));
      return GNUNET_NO; /* don't know my MAC */
    }
  if (0 != memcmp(&wa->mac,
                  &plugin->mac_address,
                  sizeof(wa->mac)))
    {
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Rejecting MAC `%s': not my MAC!\n",
          mac_to_string(addr));
      return GNUNET_NO; /* not my MAC */
    }
  return GNUNET_OK;
}


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)
{
  const char *ret;

  if (sizeof(struct WlanAddress) == addrlen)
    ret = wlan_plugin_address_to_string(NULL,
                                        addr,
                                        addrlen);
  else
    ret = NULL;
  asc(asc_cls,
      ret,
      (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
  asc(asc_cls, NULL, GNUNET_OK);
}


void *
LIBGNUNET_PLUGIN_TRANSPORT_DONE(void *cls)
{
  struct WlanAddress wa;
  struct GNUNET_HELLO_Address *address;
  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
  struct MacEndpoint *endpoint;
  struct MacEndpoint *endpoint_next;

  if (NULL == plugin)
    {
      GNUNET_free(api);
      return NULL;
    }
  if (GNUNET_YES == plugin->have_mac)
    {
      memset(&wa, 0, sizeof(wa));
      wa.options = htonl(plugin->options);
      wa.mac = plugin->mac_address;
      address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
                                              PLUGIN_NAME,
                                              &wa, sizeof(struct WlanAddress),
                                              GNUNET_HELLO_ADDRESS_INFO_NONE);

      plugin->env->notify_address(plugin->env->cls,
                                  GNUNET_NO,
                                  address);
      plugin->have_mac = GNUNET_NO;
      GNUNET_HELLO_address_free(address);
    }

  if (NULL != plugin->beacon_task)
    {
      GNUNET_SCHEDULER_cancel(plugin->beacon_task);
      plugin->beacon_task = NULL;
    }
  if (NULL != plugin->suid_helper)
    {
      GNUNET_HELPER_stop(plugin->suid_helper,
                         GNUNET_NO);
      plugin->suid_helper = NULL;
    }
  endpoint_next = plugin->mac_head;
  while (NULL != (endpoint = endpoint_next))
    {
      endpoint_next = endpoint->next;
      free_macendpoint(endpoint);
    }
  if (NULL != plugin->fragment_data_tokenizer)
    {
      GNUNET_SERVER_mst_destroy(plugin->fragment_data_tokenizer);
      plugin->fragment_data_tokenizer = NULL;
    }
  if (NULL != plugin->wlan_header_payload_tokenizer)
    {
      GNUNET_SERVER_mst_destroy(plugin->wlan_header_payload_tokenizer);
      plugin->wlan_header_payload_tokenizer = NULL;
    }
  if (NULL != plugin->helper_payload_tokenizer)
    {
      GNUNET_SERVER_mst_destroy(plugin->helper_payload_tokenizer);
      plugin->helper_payload_tokenizer = NULL;
    }
  GNUNET_free_non_null(plugin->wlan_interface);
  GNUNET_free(plugin);
  GNUNET_free(api);
  return NULL;
}


static int
wlan_plugin_string_to_address(void *cls,
                              const char *addr,
                              uint16_t addrlen,
                              void **buf,
                              size_t *added)
{
  struct WlanAddress *wa;
  unsigned int a[6];
  unsigned int i;
  char plugin[5];
  uint32_t options;

  if ((NULL == addr) || (0 == addrlen))
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  if ('\0' != addr[addrlen - 1])
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  if (strlen(addr) != addrlen - 1)
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }

  if (8 != sscanf(addr,
                  "%4s.%u.%X:%X:%X:%X:%X:%X",
                  plugin, &options,
                  &a[0], &a[1], &a[2],
                  &a[3], &a[4], &a[5]))
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  wa = GNUNET_new(struct WlanAddress);
  for (i = 0; i < 6; i++)
    wa->mac.mac[i] = a[i];
  wa->options = htonl(0);
  *buf = wa;
  *added = sizeof(struct WlanAddress);
  return GNUNET_OK;
}


static void
wlan_plugin_setup_monitor(void *cls,
                          GNUNET_TRANSPORT_SessionInfoCallback sic,
                          void *sic_cls)
{
  struct Plugin *plugin = cls;
  struct MacEndpoint *mac;
  struct GNUNET_ATS_Session *session;

  plugin->sic = sic;
  plugin->sic_cls = sic_cls;
  if (NULL != sic)
    {
      for (mac = plugin->mac_head; NULL != mac; mac = mac->next)
        for (session = mac->sessions_head; NULL != session; session = session->next)
          {
            notify_session_monitor(plugin,
                                   session,
                                   GNUNET_TRANSPORT_SS_INIT);
            notify_session_monitor(plugin,
                                   session,
                                   GNUNET_TRANSPORT_SS_UP);
          }
      sic(sic_cls, NULL, NULL);
    }
}



static void
wlan_plugin_update_session_timeout(void *cls,
                                   const struct GNUNET_PeerIdentity *peer,
                                   struct GNUNET_ATS_Session *session)
{
  GNUNET_assert(NULL != session->timeout_task);
  session->timeout = GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}


static void
wlan_plugin_update_inbound_delay(void *cls,
                                 const struct GNUNET_PeerIdentity *peer,
                                 struct GNUNET_ATS_Session *session,
                                 struct GNUNET_TIME_Relative delay)
{
  /* does nothing, as inbound delay is not supported by WLAN */
}


void *
LIBGNUNET_PLUGIN_TRANSPORT_INIT(void *cls)
{
  struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
  struct GNUNET_TRANSPORT_PluginFunctions *api;
  struct Plugin *plugin;
  char *wlan_interface;
  unsigned long long testmode;
  char *binary;

  /* check for 'special' mode */
  if (NULL == env->receive)
    {
      /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
         initialze the plugin or the API */
      api = GNUNET_new(struct GNUNET_TRANSPORT_PluginFunctions);
      api->cls = NULL;
      api->address_pretty_printer = &wlan_plugin_address_pretty_printer;
      api->address_to_string = &wlan_plugin_address_to_string;
      api->string_to_address = &wlan_plugin_string_to_address;
      return api;
    }

  testmode = 0;
  /* check configuration */
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_have_value(env->cfg,
                                       CONFIG_NAME,
                                       "TESTMODE")) &&
      ((GNUNET_SYSERR ==
        GNUNET_CONFIGURATION_get_value_number(env->cfg,
                                              CONFIG_NAME,
                                              "TESTMODE",
                                              &testmode)) ||
       (testmode > 2)))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
                                CONFIG_NAME,
                                "TESTMODE");
      return NULL;
    }
  binary = GNUNET_OS_get_libexec_binary_path(HELPER_NAME);
  if ((0 == testmode) &&
      (GNUNET_YES !=
       GNUNET_OS_check_helper_binary(binary,
                                     GNUNET_YES,
                                     NULL)))
    {
      LOG(GNUNET_ERROR_TYPE_ERROR,
          _("Helper binary `%s' not SUID, cannot run WLAN transport\n"),
          HELPER_NAME);
      GNUNET_free(binary);
      return NULL;
    }
  GNUNET_free(binary);
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_string(env->cfg,
                                            CONFIG_NAME,
                                            "INTERFACE",
                                            &wlan_interface))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
                                CONFIG_NAME,
                                "INTERFACE");
      return NULL;
    }

  plugin = GNUNET_new(struct Plugin);
  plugin->wlan_interface = wlan_interface;
  plugin->env = env;
  GNUNET_STATISTICS_set(plugin->env->stats,
                        _("# sessions allocated"),
                        0, GNUNET_NO);
  GNUNET_STATISTICS_set(plugin->env->stats,
                        _("# MAC endpoints allocated"),
                        0, 0);
  GNUNET_BANDWIDTH_tracker_init(&plugin->tracker, NULL, NULL,
                                GNUNET_BANDWIDTH_value_init(100 * 1024 *
                                                            1024 / 8),
                                100);
  plugin->fragment_data_tokenizer = GNUNET_SERVER_mst_create(&process_data,
                                                             plugin);
  plugin->wlan_header_payload_tokenizer = GNUNET_SERVER_mst_create(&process_data,
                                                                   plugin);
  plugin->helper_payload_tokenizer = GNUNET_SERVER_mst_create(&process_data,
                                                              plugin);

  plugin->options = 0;

  /* some compilers do not like switch on 'long long'... */
  switch ((unsigned int)testmode)
    {
    case 0: /* normal */
      plugin->helper_argv[0] = (char *)HELPER_NAME;
      plugin->helper_argv[1] = wlan_interface;
      plugin->helper_argv[2] = NULL;
      plugin->suid_helper = GNUNET_HELPER_start(GNUNET_NO,
                                                HELPER_NAME,
                                                plugin->helper_argv,
                                                &handle_helper_message,
                                                NULL,
                                                plugin);
      break;

    case 1: /* testmode, peer 1 */
      plugin->helper_argv[0] = (char *)DUMMY_HELPER_NAME;
      plugin->helper_argv[1] = (char *)"1";
      plugin->helper_argv[2] = NULL;
      plugin->suid_helper = GNUNET_HELPER_start(GNUNET_NO,
                                                DUMMY_HELPER_NAME,
                                                plugin->helper_argv,
                                                &handle_helper_message,
                                                NULL,
                                                plugin);
      break;

    case 2: /* testmode, peer 2 */
      plugin->helper_argv[0] = (char *)DUMMY_HELPER_NAME;
      plugin->helper_argv[1] = (char *)"2";
      plugin->helper_argv[2] = NULL;
      plugin->suid_helper = GNUNET_HELPER_start(GNUNET_NO,
                                                DUMMY_HELPER_NAME,
                                                plugin->helper_argv,
                                                &handle_helper_message,
                                                NULL,
                                                plugin);
      break;

    default:
      GNUNET_assert(0);
    }

  api = GNUNET_new(struct GNUNET_TRANSPORT_PluginFunctions);
  api->cls = plugin;
  api->send = &wlan_plugin_send;
  api->get_session = &wlan_plugin_get_session;
  api->disconnect_peer = &wlan_plugin_disconnect_peer;
  api->disconnect_session = &wlan_plugin_disconnect_session;
  api->query_keepalive_factor = &wlan_plugin_query_keepalive_factor;
  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;
  api->string_to_address = &wlan_plugin_string_to_address;
  api->get_network = &wlan_plugin_get_network;
  api->get_network_for_address = &wlan_plugin_get_network_for_address;
  api->update_session_timeout = &wlan_plugin_update_session_timeout;
  api->update_inbound_delay = &wlan_plugin_update_inbound_delay;
  api->setup_monitor = &wlan_plugin_setup_monitor;
  return api;
}


/* end of plugin_transport_wlan.c */