plugin_transport_wlan.c File Reference

transport plugin for wlan and/or bluetooth More...

#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"
#include "tcp_server_mst_legacy.c"

Include dependency graph for plugin_transport_wlan.c:

Go to the source code of this file.

Data Structures
struct	WlanHeader
	Header for messages which need fragmentation. More...
struct	WlanAddress
	Address format for WLAN. More...
struct	PendingMessage
	List containing all messages that are yet to be send. More...
struct	GNUNET_ATS_Session
	Session handle for connections. More...
struct	FragmentMessage
	Struct for messages that are being fragmented in a MAC's transmission queue. More...
struct	MacEndpoint
	Struct to represent one network card connection. More...
struct	Plugin
	Handle for a plugin. More...
struct	MacAndSession
	Information associated with a message. More...

Macros
#define	WLAN_MTU   1430
	Max size of packet (that we give to the WLAN driver for transmission) More...
#define	MESSAGES_IN_DEFRAG_QUEUE_PER_MAC   2
	Maximum number of messages in defragmentation queue per MAC. More...
#define	WLAN_LLC_DSAP_FIELD   0x1f
	Link layer control fields for better compatibility (i.e. More...
#define	WLAN_LLC_SSAP_FIELD   0x1f

Typedefs
typedef int(*	GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer. More...

Functions
static const char *	mac_to_string (const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac)
	Print MAC addresses nicely. More...
static const char *	wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
	Function called for a quick conversion of the binary address to a numeric address. More...
static void	notify_session_monitor (struct Plugin *plugin, struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state)
	If a session monitor is attached, notify it about the new session state. More...
static void	get_radiotap_header (struct MacEndpoint *endpoint, struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, uint16_t size)
	Fill the radiotap header. More...
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)
	Generate the WLAN hardware header for one packet. More...
static void	send_ack (void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
	Send an ACK for a fragment we received. More...
static void	wlan_data_message_handler (void *cls, const struct GNUNET_MessageHeader *hdr)
	Handles the data after all fragments are put together. More...
static int	wlan_plugin_disconnect_session (void *cls, struct GNUNET_ATS_Session *session)
	Free a session. More...
static unsigned int	wlan_plugin_query_keepalive_factor (void *cls)
	Function that is called to get the keepalive factor. More...
static void	session_timeout (void *cls)
	A session is timing out. More...
static struct GNUNET_ATS_Session *	lookup_session (struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
	Lookup a new session. More...
static struct GNUNET_ATS_Session *	create_session (struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
	Create a new session. More...
static struct GNUNET_ATS_Session *	get_session (struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
	Look up a session for a peer and create a new session if none is found. More...
static void	fragment_transmission_done (void *cls, int result)
	Function called once we have successfully given the fragment message to the SUID helper process and we are thus ready for the next fragment. More...
static void	transmit_fragment (void *cls, const struct GNUNET_MessageHeader *hdr)
	Transmit a fragment of a message. More...
static void	free_fragment_message (struct FragmentMessage *fm)
	Frees the space of a message in the fragment queue (send queue) More...
static void	fragmentmessage_timeout (void *cls)
	A FragmentMessage has timed out. More...
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)
	Transmit a message to the given destination with fragmentation. More...
static void	free_macendpoint (struct MacEndpoint *endpoint)
	Free a MAC endpoint. More...
static void	macendpoint_timeout (void *cls)
	A MAC endpoint is timing out. More...
static struct MacEndpoint *	create_macendpoint (struct Plugin *plugin, struct WlanAddress *mac)
	Find (or create) a MacEndpoint with a specific MAC address. More...
static enum GNUNET_NetworkType	wlan_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
	Function obtain the network type for a session. More...
static enum GNUNET_NetworkType	wlan_plugin_get_network_for_address (void *cls, const struct GNUNET_HELLO_Address *address)
	Function obtain the network type for an address. More...
static struct GNUNET_ATS_Session *	wlan_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
	Creates a new outbound session the transport service will use to send data to the peer. More...
static void	wlan_plugin_disconnect_peer (void *cls, const struct GNUNET_PeerIdentity *target)
	Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuation). More...
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)
	Function that can be used by the transport service to transmit a message using the plugin. More...
static int	process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
	We have received data from the WLAN via some session. More...
static void	send_hello_beacon (void *cls)
	Task to (periodically) send a HELLO beacon. More...
static int	handle_helper_message (void *cls, const struct GNUNET_MessageHeader *hdr)
	Function used for to process the data from the suid process. More...
static int	wlan_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
	Another peer has suggested an address for this peer and transport plugin. More...
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)
	Convert the transports address to a nice, human-readable format. More...
void *	LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
	Exit point from the plugin. More...
static int	wlan_plugin_string_to_address (void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
	Function called to convert a string address to a binary address. More...
static void	wlan_plugin_setup_monitor (void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
	Begin monitoring sessions of a plugin. More...
static void	wlan_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
	Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated. More...
static void	wlan_plugin_update_inbound_delay (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay)
	Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value. More...
void *	LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
	Entry point for the plugin. More...

Variables
static enum GNUNET_NetworkType	scope = GNUNET_NT_BT
	Which network scope do we belong to? More...

Detailed Description

transport plugin for wlan and/or bluetooth

Author

David Brodski

Christian Grothoff

BUILD_WLAN or BUILD_BLUETOOTH must be defined such that the respective variant of this code is compiled.

Definition in file plugin_transport_wlan.c.

Macro Definition Documentation

WLAN_MTU

#define WLAN_MTU   1430

Max size of packet (that we give to the WLAN driver for transmission)

Definition at line 131 of file plugin_transport_wlan.c.

MESSAGES_IN_DEFRAG_QUEUE_PER_MAC

#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC   2

Maximum number of messages in defragmentation queue per MAC.

Definition at line 147 of file plugin_transport_wlan.c.

WLAN_LLC_DSAP_FIELD

#define WLAN_LLC_DSAP_FIELD   0x1f

Link layer control fields for better compatibility (i.e.

GNUnet over WLAN is not IP-over-WLAN).

Definition at line 153 of file plugin_transport_wlan.c.

WLAN_LLC_SSAP_FIELD

#define WLAN_LLC_SSAP_FIELD   0x1f

Definition at line 154 of file plugin_transport_wlan.c.

Typedef Documentation

GNUNET_SERVER_MessageTokenizerCallback

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

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call GNUNET_SERVER_mst_destroy from within the scope of this callback.

Parameters

cls	closure
client	identification of the client
message	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 117 of file plugin_transport_wlan.c.

Function Documentation

mac_to_string()

static const char* mac_to_string ( const struct GNUNET_TRANSPORT_WLAN_MacAddress *  mac )

static

Print MAC addresses nicely.

Parameters

mac	the mac address

Returns

string to a static buffer with the human-readable mac, will be overwritten during the next call to this function

Definition at line 584 of file plugin_transport_wlan.c.

{
  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;
}

References GNUNET_snprintf(), and GNUNET_TRANSPORT_WLAN_MacAddress::mac.

Referenced by create_session(), handle_helper_message(), send_ack(), send_hello_beacon(), transmit_fragment(), wlan_plugin_address_suggested(), and wlan_plugin_address_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

wlan_plugin_address_to_string()

static const char* wlan_plugin_address_to_string ( void *  cls, const void *  addr, size_t  addrlen  )

static

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.

Parameters

cls	closure
addr	binary address
addrlen	length of the address

Returns

string representing the same address

Definition at line 610 of file plugin_transport_wlan.c.

{
  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;
}

References GNUNET_break, GNUNET_snprintf(), WlanAddress::mac, GNUNET_TRANSPORT_WLAN_MacAddress::mac, mac_to_string(), options, and PLUGIN_NAME.

Referenced by create_macendpoint(), process_data(), wlan_plugin_address_pretty_printer(), and wlan_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_session_monitor()

static void notify_session_monitor ( struct Plugin *  plugin, struct GNUNET_ATS_Session *  session, enum GNUNET_TRANSPORT_SessionState  state  )

static

If a session monitor is attached, notify it about the new session state.

Parameters

plugin	our plugin
session	session that changed state
state	new state of the session

Definition at line 642 of file plugin_transport_wlan.c.

{
  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);
}

References GNUNET_ATS_Session::address, GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, info, plugin, state, and GNUNET_ATS_Session::timeout.

Referenced by create_session(), wlan_plugin_disconnect_session(), and wlan_plugin_setup_monitor().

Here is the caller graph for this function:

get_radiotap_header()

static void get_radiotap_header ( struct MacEndpoint *  endpoint, struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *  header, uint16_t  size  )

static

Fill the radiotap header.

Parameters

endpoint	pointer to the endpoint, can be NULL
header	pointer to the radiotap header
size	total message size

Definition at line 672 of file plugin_transport_wlan.c.

{
  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;
  }
}

References MacEndpoint::antenna, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::antenna, GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::header, MacEndpoint::rate, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::rate, GNUNET_MessageHeader::size, size, MacEndpoint::tx_power, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::tx_power, and GNUNET_MessageHeader::type.

Referenced by send_ack(), send_hello_beacon(), and transmit_fragment().

Here is the caller graph for this function:

get_wlan_header()

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  )

static

Generate the WLAN hardware header for one packet.

Parameters

plugin	the plugin handle
header	address to write the header to
to_mac_addr	address of the recipient
size	size of the whole packet, needed to calculate the time to send the packet

Definition at line 702 of file plugin_transport_wlan.c.

{
  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?
}

References GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr1, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr2, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr3, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::duration, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::frame_control, GNUNET_htole16, IEEE80211_FC0_TYPE_DATA, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::llc, mac_bssid_gnunet, plugin, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::sequence_control, size, WLAN_LLC_DSAP_FIELD, and WLAN_LLC_SSAP_FIELD.

Referenced by send_ack(), send_hello_beacon(), and transmit_fragment().

Here is the caller graph for this function:

send_ack()

static void send_ack ( void *  cls, uint32_t  msg_id, const struct GNUNET_MessageHeader *  hdr  )

static

Send an ACK for a fragment we received.

Parameters

cls	the struct MacEndpoint * the ACK must be sent to
msg_id	id of the message
hdr	pointer to the hdr where the ack is stored

Definition at line 730 of file plugin_transport_wlan.c.

{
  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);
}

References _, buf, Plugin::env, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::frame, get_radiotap_header(), get_wlan_header(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::header, LOG, WlanAddress::mac, mac_to_string(), MacEndpoint::plugin, GNUNET_MessageHeader::size, size, Plugin::suid_helper, and MacEndpoint::wlan_addr.

Referenced by create_macendpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

wlan_data_message_handler()

static void wlan_data_message_handler ( void *  cls, const struct GNUNET_MessageHeader *  hdr  )

static

Handles the data after all fragments are put together.

Parameters

cls	macendpoint this messages belongs to
hdr	pointer to the data

Definition at line 779 of file plugin_transport_wlan.c.

{
  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);
}

References _, MacAndSession::endpoint, GNUNET_NO, GNUNET_SERVER_mst_receive(), GNUNET_STATISTICS_update(), GNUNET_YES, plugin, MacEndpoint::plugin, MacAndSession::session, and GNUNET_MessageHeader::size.

Referenced by create_macendpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

wlan_plugin_disconnect_session()

static int wlan_plugin_disconnect_session ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Free a session.

Parameters

cls	our struct Plugin.
session	the session free

Definition at line 807 of file plugin_transport_wlan.c.

{
  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;
}

References _, GNUNET_ATS_Session::address, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_SS_DONE, GNUNET_ATS_Session::mac, notify_session_monitor(), plugin, MacEndpoint::plugin, MacEndpoint::sessions_head, MacEndpoint::sessions_tail, and GNUNET_ATS_Session::timeout_task.

Referenced by free_macendpoint(), session_timeout(), and wlan_plugin_disconnect_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

wlan_plugin_query_keepalive_factor()

static unsigned int wlan_plugin_query_keepalive_factor ( void *  cls )

static

Function that is called to get the keepalive factor.

GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to calculate the interval between keepalive packets.

Parameters

cls	closure with the struct Plugin

Returns

keepalive factor

Definition at line 846 of file plugin_transport_wlan.c.

{
  return 3;
}

session_timeout()

static void session_timeout ( void *  cls )

static

A session is timing out.

Clean up.

Parameters

cls	pointer to the Session

Definition at line 858 of file plugin_transport_wlan.c.

{
  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);
}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_remaining(), GNUNET_ATS_Session::mac, MacEndpoint::plugin, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and wlan_plugin_disconnect_session().

Referenced by create_session().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_session()

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

static

Lookup a new session.

Parameters

endpoint	pointer to the mac endpoint of the peer
peer	peer identity to use for this session

Returns

returns the session or NULL

Definition at line 886 of file plugin_transport_wlan.c.

{
  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;
}

References GNUNET_ATS_Session::next, peer, MacEndpoint::sessions_head, and GNUNET_ATS_Session::target.

Referenced by get_session(), and process_data().

Here is the caller graph for this function:

create_session()

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

static

Create a new session.

Parameters

endpoint	pointer to the mac endpoint of the peer
peer	peer identity to use for this session

Returns

returns the session or NULL

Definition at line 908 of file plugin_transport_wlan.c.

{
  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;
}

References _, GNUNET_ATS_Session::address, Plugin::env, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, LOG, WlanAddress::mac, GNUNET_ATS_Session::mac, mac_to_string(), notify_session_monitor(), peer, MacEndpoint::plugin, PLUGIN_NAME, session_timeout(), MacEndpoint::sessions_head, MacEndpoint::sessions_tail, GNUNET_ATS_Session::target, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and MacEndpoint::wlan_addr.

Referenced by get_session(), and process_data().

Here is the call graph for this function:

Here is the caller graph for this function:

get_session()

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

static

Look up a session for a peer and create a new session if none is found.

Parameters

endpoint	pointer to the mac endpoint of the peer
peer	peer identity to use for this session

Returns

returns the session

Definition at line 958 of file plugin_transport_wlan.c.

{
  struct GNUNET_ATS_Session *session;
 
  if (NULL != (session = lookup_session (endpoint, peer)))
    return session;
  return create_session (endpoint, peer);
}

References create_session(), lookup_session(), and peer.

Referenced by wlan_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

fragment_transmission_done()

static void fragment_transmission_done ( void *  cls, int  result  )

static

Function called once we have successfully given the fragment message to the SUID helper process and we are thus ready for the next fragment.

Parameters

cls	the struct FragmentMessage *
result	result of the operation (GNUNET_OK on success, GNUNET_NO if the helper died, GNUNET_SYSERR if the helper was stopped)

Definition at line 980 of file plugin_transport_wlan.c.

{
  struct FragmentMessage *fm = cls;
 
  fm->sh = NULL;
  GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext);
}

References FragmentMessage::fragcontext, GNUNET_FRAGMENT_context_transmission_done(), and FragmentMessage::sh.

Referenced by transmit_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_fragment()

static void transmit_fragment ( void *  cls, const struct GNUNET_MessageHeader *  hdr  )

static

Transmit a fragment of a message.

Parameters

cls	struct FragmentMessage * this fragment message belongs to
hdr	pointer to the start of the fragment message

Definition at line 997 of file plugin_transport_wlan.c.

{
  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);
  }
}

References _, buf, Plugin::env, FragmentMessage::fragcontext, fragment_transmission_done(), GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::frame, get_radiotap_header(), get_wlan_header(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FRAGMENT_context_transmission_done(), GNUNET_HELPER_send(), GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::header, LOG, WlanAddress::mac, mac_to_string(), FragmentMessage::macendpoint, MacEndpoint::plugin, FragmentMessage::sh, GNUNET_MessageHeader::size, size, FragmentMessage::size_on_wire, Plugin::suid_helper, and MacEndpoint::wlan_addr.

Referenced by handle_helper_message(), and send_with_fragmentation().

Here is the call graph for this function:

Here is the caller graph for this function:

free_fragment_message()

static void free_fragment_message ( struct FragmentMessage *  fm )

static

Frees the space of a message in the fragment queue (send queue)

Parameters

fm	message to free

Definition at line 1061 of file plugin_transport_wlan.c.

{
  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);
}

References _, MacEndpoint::ack_delay, Plugin::env, FragmentMessage::fragcontext, GNUNET_CONTAINER_DLL_remove, GNUNET_FRAGMENT_context_destroy(), GNUNET_free, GNUNET_HELPER_send_cancel(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), FragmentMessage::macendpoint, FragmentMessage::msg, MacEndpoint::msg_delay, MacEndpoint::plugin, MacEndpoint::sending_messages_head, MacEndpoint::sending_messages_tail, FragmentMessage::sh, and FragmentMessage::timeout_task.

Referenced by fragmentmessage_timeout(), free_macendpoint(), and process_data().

Here is the call graph for this function:

Here is the caller graph for this function:

fragmentmessage_timeout()

static void fragmentmessage_timeout ( void *  cls )

static

A FragmentMessage has timed out.

Remove it.

Parameters

cls	pointer to the 'struct FragmentMessage'

Definition at line 1103 of file plugin_transport_wlan.c.

{
  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);
}

References FragmentMessage::cont, FragmentMessage::cont_cls, free_fragment_message(), GNUNET_SYSERR, FragmentMessage::size_on_wire, FragmentMessage::size_payload, FragmentMessage::target, and FragmentMessage::timeout_task.

Referenced by send_with_fragmentation().

Here is the call graph for this function:

Here is the caller graph for this function:

send_with_fragmentation()

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  )

static

Transmit a message to the given destination with fragmentation.

Parameters

endpoint	desired destination
timeout	how long can the message wait?
target	peer that should receive the message
msg	message to transmit
payload_size	bytes of payload
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
cont_cls	closure for cont

Definition at line 1136 of file plugin_transport_wlan.c.

{
  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);
}

References MacEndpoint::ack_delay, FragmentMessage::cont, FragmentMessage::cont_cls, FragmentMessage::fragcontext, fragmentmessage_timeout(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_copy_message(), GNUNET_FRAGMENT_context_create(), GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, FragmentMessage::macendpoint, msg, FragmentMessage::msg, MacEndpoint::msg_delay, plugin, MacEndpoint::plugin, MacEndpoint::sending_messages_head, MacEndpoint::sending_messages_tail, FragmentMessage::size_payload, FragmentMessage::target, timeout, FragmentMessage::timeout, FragmentMessage::timeout_task, transmit_fragment(), and WLAN_MTU.

Referenced by wlan_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

free_macendpoint()

static void free_macendpoint ( struct MacEndpoint *  endpoint )

static

Free a MAC endpoint.

Parameters

endpoint

pointer to the MacEndpoint to free

Definition at line 1188 of file plugin_transport_wlan.c.

{
  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);
}

References _, MacEndpoint::defrag, free_fragment_message(), GNUNET_CONTAINER_DLL_remove, GNUNET_DEFRAGMENT_context_destroy(), GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), plugin, MacEndpoint::plugin, MacEndpoint::sending_messages_head, MacEndpoint::sessions_head, MacEndpoint::timeout_task, and wlan_plugin_disconnect_session().

Referenced by LIBGNUNET_PLUGIN_TRANSPORT_DONE(), and macendpoint_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

macendpoint_timeout()

static void macendpoint_timeout ( void *  cls )

static

A MAC endpoint is timing out.

Clean up.

Parameters

cls	pointer to the struct MacEndpoint *

Definition at line 1229 of file plugin_transport_wlan.c.

{
  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);
}

References free_macendpoint(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_Relative::rel_value_us, timeout, MacEndpoint::timeout, and MacEndpoint::timeout_task.

Referenced by create_macendpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

create_macendpoint()

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

static

Find (or create) a MacEndpoint with a specific MAC address.

Parameters

plugin	pointer to the plugin struct
mac	the MAC address of the endpoint

Returns

handle to our data structure for this MAC

Definition at line 1256 of file plugin_transport_wlan.c.

{
  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;
}

References _, MacEndpoint::ack_delay, MacEndpoint::defrag, GNUNET_CONTAINER_DLL_insert, GNUNET_DEFRAGMENT_context_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_MILLISECONDS, LOG, macendpoint_timeout(), MESSAGES_IN_DEFRAG_QUEUE_PER_MAC, MacEndpoint::msg_delay, MacEndpoint::next, plugin, MacEndpoint::plugin, send_ack(), MacEndpoint::timeout, MacEndpoint::timeout_task, MacEndpoint::wlan_addr, wlan_data_message_handler(), WLAN_MTU, and wlan_plugin_address_to_string().

Referenced by handle_helper_message(), and wlan_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

wlan_plugin_get_network()

static enum GNUNET_NetworkType wlan_plugin_get_network ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Function obtain the network type for a session.

Parameters

cls	closure (struct Plugin*)
session	the session

Returns

the network type in HBO or GNUNET_SYSERR

Definition at line 1256 of file plugin_transport_wlan.c.

{
#if BUILD_WLAN
  return GNUNET_NT_WLAN;
#else
  return GNUNET_NT_BT;
#endif
}

wlan_plugin_get_network_for_address()

static enum GNUNET_NetworkType wlan_plugin_get_network_for_address ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Function obtain the network type for an address.

Parameters

cls	closure (struct Plugin *)
address	the address

Returns

the network type

Definition at line 1256 of file plugin_transport_wlan.c.

{
#if BUILD_WLAN
  return GNUNET_NT_WLAN;
#else
  return GNUNET_NT_BT;
#endif
}

wlan_plugin_get_session()

static struct GNUNET_ATS_Session* wlan_plugin_get_session ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Creates a new outbound session the transport service will use to send data to the peer.

Parameters

cls	the struct Plugin *
address	the address

Returns

the session or NULL of max connections exceeded

Definition at line 1345 of file plugin_transport_wlan.c.

{
  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);
}

References address, create_macendpoint(), get_session(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, plugin, and wlan_plugin_address_to_string().

Here is the call graph for this function:

wlan_plugin_disconnect_peer()

static void wlan_plugin_disconnect_peer ( void *  cls, const struct GNUNET_PeerIdentity *  target  )

static

Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuation).

Parameters

cls	closure
target	peer from which to disconnect

Definition at line 1379 of file plugin_transport_wlan.c.

{
  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!) */
      }
}

References GNUNET_ATS_Session::next, MacEndpoint::next, plugin, MacEndpoint::sessions_head, GNUNET_ATS_Session::target, and wlan_plugin_disconnect_session().

Here is the call graph for this function:

wlan_plugin_send()

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  )

static

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.

Parameters

cls	closure
session	which session must be used
msgbuf	the message to transmit
msgbuf_size	number of bytes in msgbuf
priority	how important is the message (most plugins will ignore message priority and just FIFO)
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)
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
cont_cls	closure for cont

Returns

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)

Definition at line 1426 of file plugin_transport_wlan.c.

{
  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 %llu bytes of payload to peer `%s' (starting with %u byte message of type %u)\n",
       (unsigned long long) 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;
}

References buf, WlanHeader::crc, GNUNET_ALIGN, GNUNET_CRYPTO_crc32_n(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_WLAN_DATA, GNUNET_NO, GNUNET_STATISTICS_update(), WlanHeader::header, LOG, GNUNET_ATS_Session::mac, plugin, send_with_fragmentation(), WlanHeader::sender, GNUNET_MessageHeader::size, size, GNUNET_ATS_Session::target, WlanHeader::target, GNUNET_MessageHeader::type, and type.

Here is the call graph for this function:

process_data()

static int process_data ( void *  cls, void *  client, const struct GNUNET_MessageHeader *  hdr  )

static

We have received data from the WLAN via some session.

Process depending on the message type (HELLO, DATA, FRAGMENTATION or FRAGMENTATION-ACK).

Parameters

cls	pointer to the plugin
client	pointer to the session this message belongs to
hdr	start of the message

Definition at line 1476 of file plugin_transport_wlan.c.

{
  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;
}

References _, address, GNUNET_ATS_Session::address, FragmentMessage::cont, FragmentMessage::cont_cls, WlanHeader::crc, create_session(), MacEndpoint::defrag, MacAndSession::endpoint, FragmentMessage::fragcontext, free_fragment_message(), GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CRYPTO_crc32_n(), GNUNET_DEFRAGMENT_process_fragment(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_FRAGMENT_process_ack(), GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_MESSAGE_TYPE_FRAGMENT, GNUNET_MESSAGE_TYPE_FRAGMENT_ACK, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_MESSAGE_TYPE_WLAN_DATA, GNUNET_NO, GNUNET_OK, GNUNET_SERVER_mst_receive(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, LOG, lookup_session(), FragmentMessage::next, plugin, PLUGIN_NAME, ret, scope, WlanHeader::sender, MacEndpoint::sending_messages_head, MacAndSession::session, GNUNET_MessageHeader::size, FragmentMessage::size_on_wire, FragmentMessage::size_payload, GNUNET_ATS_Session::target, WlanHeader::target, FragmentMessage::target, GNUNET_ATS_Session::timeout, MacEndpoint::timeout, GNUNET_MessageHeader::type, MacEndpoint::wlan_addr, and wlan_plugin_address_to_string().

Here is the call graph for this function:

send_hello_beacon()

static void send_hello_beacon ( void *  cls )

static

Task to (periodically) send a HELLO beacon.

Parameters

cls	pointer to the plugin struct

Definition at line 1717 of file plugin_transport_wlan.c.

{
  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);
}

References _, bc_all_mac, buf, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::frame, get_radiotap_header(), get_wlan_header(), GNUNET_ALIGN, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_size(), GNUNET_HELPER_send(), GNUNET_memcpy, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_multiply(), GNUNET_YES, GNUNET_TRANSPORT_WLAN_RadiotapSendMessage::header, LOG, mac_to_string(), plugin, size, and WLAN_MTU.

Referenced by handle_helper_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_helper_message()

static int handle_helper_message ( void *  cls, const struct GNUNET_MessageHeader *  hdr  )

static

Function used for to process the data from the suid process.

Parameters

cls	the plugin handle
hdr	header of the GNUNET_MessageHeader

Definition at line 1772 of file plugin_transport_wlan.c.

{
  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 (%llu bytes < %llu)\n",
           (unsigned long long) msize,
           (unsigned long long) 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;
}

References _, MacEndpoint::ack_delay, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr1, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr2, GNUNET_TRANSPORT_WLAN_Ieee80211Frame::addr3, bc_all_mac, create_macendpoint(), MacAndSession::endpoint, FragmentMessage::fragcontext, GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage::frame, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_FRAGMENT_context_create(), GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER, GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SERVER_mst_receive(), GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_TRANSPORT_WLAN_HelperControlMessage::hdr, LOG, WlanAddress::mac, GNUNET_TRANSPORT_WLAN_HelperControlMessage::mac, mac_bssid_gnunet, mac_to_string(), FragmentMessage::macendpoint, FragmentMessage::msg, MacEndpoint::msg_delay, FragmentMessage::next, MacEndpoint::next, WlanAddress::options, plugin, PLUGIN_NAME, send_hello_beacon(), MacEndpoint::sending_messages_head, MacAndSession::session, GNUNET_MessageHeader::size, transmit_fragment(), GNUNET_MessageHeader::type, and WLAN_MTU.

Here is the call graph for this function:

wlan_plugin_address_suggested()

static int wlan_plugin_address_suggested ( void *  cls, const void *  addr, size_t  addrlen  )

static

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.

Parameters

cls	closure
addr	pointer to the address
addrlen	length of addr

Returns

GNUNET_OK if this is a plausible address for this peer and transport

Definition at line 1958 of file plugin_transport_wlan.c.

{
  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;
}

References GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, LOG, WlanAddress::mac, mac_to_string(), and plugin.

Here is the call graph for this function:

wlan_plugin_address_pretty_printer()

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  )

static

Convert the transports address to a nice, human-readable format.

Parameters

cls	closure
type	name of the transport that generated the address
addr	one of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlen	length of the address
numeric	should (IP) addresses be displayed in numeric form?
timeout	after how long should we give up?
asc	function to call on each string
asc_cls	closure for asc

Definition at line 2004 of file plugin_transport_wlan.c.

{
  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);
}

References GNUNET_OK, GNUNET_SYSERR, ret, and wlan_plugin_address_to_string().

Here is the call graph for this function:

LIBGNUNET_PLUGIN_TRANSPORT_DONE()

void* LIBGNUNET_PLUGIN_TRANSPORT_DONE

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	pointer to the api struct

Definition at line 2034 of file plugin_transport_wlan.c.

{
  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 (plugin->wlan_interface);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References address, Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::cls, free_macendpoint(), GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_HELPER_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_mst_destroy(), GNUNET_YES, WlanAddress::mac, MacEndpoint::next, WlanAddress::options, plugin, and PLUGIN_NAME.

Here is the call graph for this function:

wlan_plugin_string_to_address()

static int wlan_plugin_string_to_address ( void *  cls, const char *  addr, uint16_t  addrlen, void **  buf, size_t *  added  )

static

Function called to convert a string address to a binary address.

Parameters

cls	closure (struct Plugin *)
addr	string address
addrlen	length of the address
buf	location to store the buffer
added	location to store the number of bytes in the buffer. If the function returns GNUNET_SYSERR, its contents are undefined.

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2117 of file plugin_transport_wlan.c.

{
  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;
}

References buf, GNUNET_break, GNUNET_new, GNUNET_OK, GNUNET_SYSERR, WlanAddress::mac, GNUNET_TRANSPORT_WLAN_MacAddress::mac, options, WlanAddress::options, and plugin.

wlan_plugin_setup_monitor()

static void wlan_plugin_setup_monitor ( void *  cls, GNUNET_TRANSPORT_SessionInfoCallback  sic, void *  sic_cls  )

static

Begin monitoring sessions of a plugin.

There can only be one active monitor per plugin (i.e. if there are multiple monitors, the transport service needs to multiplex the generated events over all of them).

Parameters

cls	closure of the plugin
sic	callback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_cls	closure for sic

Definition at line 2177 of file plugin_transport_wlan.c.

{
  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);
  }
}

References GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, GNUNET_ATS_Session::mac, GNUNET_ATS_Session::next, MacEndpoint::next, notify_session_monitor(), plugin, and MacEndpoint::sessions_head.

Here is the call graph for this function:

wlan_plugin_update_session_timeout()

static void wlan_plugin_update_session_timeout ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session  )

static

Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated

Definition at line 2215 of file plugin_transport_wlan.c.

{
  GNUNET_assert (NULL != session->timeout_task);
  session->timeout = GNUNET_TIME_relative_to_absolute (
    GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Here is the call graph for this function:

wlan_plugin_update_inbound_delay()

static void wlan_plugin_update_inbound_delay ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session, struct GNUNET_TIME_Relative  delay  )

static

Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated
delay	new delay to use for receiving

Definition at line 2236 of file plugin_transport_wlan.c.

{
  /* does nothing, as inbound delay is not supported by WLAN */
}

LIBGNUNET_PLUGIN_TRANSPORT_INIT()

void* LIBGNUNET_PLUGIN_TRANSPORT_INIT

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	closure, the struct GNUNET_TRANSPORT_PluginEnvironment *

Returns

the struct GNUNET_TRANSPORT_PluginFunctions * or NULL on error

Definition at line 2252 of file plugin_transport_wlan.c.

{
  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
       initialize 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;
}

Variable Documentation

scope

enum GNUNET_NetworkType scope = GNUNET_NT_BT

static

Which network scope do we belong to?

Definition at line 117 of file plugin_transport_wlan.c.

Referenced by create_session(), GAS_plugin_notify_feedback(), GNUNET_ATS_performance_give_feedback(), plugin_env_session_start(), process_data(), server_lookup_connection(), and setup_job_headers().