* @brief transport plugin for wlan
* @author David Brodski
* @author Christian Grothoff
- *
- * TODO:
- * - HELPER-continuation may be called after fragment times out (-> use after free, see FIXME)
*/
#include "platform.h"
#include "gnunet_hello_lib.h"
#include "gnunet_fragmentation_lib.h"
#include "gnunet_constants.h"
-#define PROTOCOL_PREFIX "wlan"
-
#define LOG(kind,...) GNUNET_log_from (kind, "transport-wlan",__VA_ARGS__)
+#define PLUGIN_NAME "wlan"
+
/**
* Max size of packet (that we give to the WLAN driver for transmission)
*/
multiple messages! */
};
+
+
+struct WlanAddress
+{
+ uint32_t options GNUNET_PACKED;
+
+ struct GNUNET_TRANSPORT_WLAN_MacAddress mac;
+};
+
+
GNUNET_NETWORK_STRUCT_END
*/
struct Session
{
+ /**
+ * To whom are we talking to (set to our identity
+ * if we are still waiting for the welcome message)
+ */
+ struct GNUNET_PeerIdentity target;
/**
* API requirement (must be first).
*/
struct PendingMessage *pending_message_tail;
- /**
- * To whom are we talking to (set to our identity
- * if we are still waiting for the welcome message)
- */
- struct GNUNET_PeerIdentity target;
-
/**
* When should this session time out?
*/
*/
GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ int inbound;
+
};
*/
void *cont_cls;
+ /**
+ * Size of original message
+ */
+ size_t size_payload;
+
+ /**
+ * Number of bytes used to transmit message
+ */
+ size_t size_on_wire;
+
};
/**
* peer mac address
*/
- struct GNUNET_TRANSPORT_WLAN_MacAddress addr;
+ struct WlanAddress addr;
+
+ /**
+ * Inbound or outbound session
+ */
+ int inbound;
+
+ /**
+ * Message delay for fragmentation context
+ */
+ struct GNUNET_TIME_Relative msg_delay;
+
+ /**
+ * ACK delay for fragmentation context
+ */
+ struct GNUNET_TIME_Relative ack_delay;
/**
* Desired transmission power for this MAC
*/
int have_mac;
+ /**
+ * Options for addresses
+ */
+ uint32_t options;
};
struct MacEndpoint *endpoint;
};
+/**
+ * Function called for a quick conversion of the binary address to
+ * a numeric address. Note that the caller must not free the
+ * address and that the next call to this function is allowed
+ * to override the address again.
+ *
+ * @param cls closure
+ * @param addr binary address
+ * @param addrlen length of the address
+ * @return string representing the same address
+ */
+static const char *
+wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen);
/**
* Print MAC addresses nicely.
{
static char macstr[20];
- GNUNET_snprintf (macstr, sizeof (macstr), "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", mac->mac[0], mac->mac[1],
+ 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;
}
/**
* Generate the WLAN hardware header for one packet
*
+ * @param plugin the plugin handle
* @param header address to write the header to
* @param to_mac_addr address of the recipient
* @param size size of the whole packet, needed to calculate the time to send the packet
size_t size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
char buf[size];
+ if (NULL == endpoint)
+ {
+ GNUNET_break (0);
+ return;
+ }
+
if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
GNUNET_break (0);
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr,
+ &endpoint->addr.mac,
size);
memcpy (&radio_header[1], hdr, msize);
if (NULL !=
session->timeout_task = GNUNET_SCHEDULER_NO_TASK;
timeout = GNUNET_TIME_absolute_get_remaining (session->timeout);
- if (0 == timeout.rel_value)
+ if (0 == timeout.rel_value_us)
{
free_session (session);
return;
}
+
/**
- * Create a new session
+ * Lookup a new session
*
* @param endpoint pointer to the mac endpoint of the peer
* @param peer peer identity to use for this session
- * @return returns the session
+ * @return returns the session or NULL
*/
static struct Session *
-create_session (struct MacEndpoint *endpoint,
- const struct GNUNET_PeerIdentity *peer)
+lookup_session (struct MacEndpoint *endpoint,
+ const struct GNUNET_PeerIdentity *peer,
+ int inbound)
{
struct Session *session;
for (session = endpoint->sessions_head; NULL != session; session = session->next)
- if (0 == memcmp (peer, &session->target,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (peer, &session->target, sizeof (struct GNUNET_PeerIdentity)) &&
+ (session->inbound == inbound))
{
session->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
return session;
}
+ return NULL;
+}
+
+/**
+ * Create a new session
+ *
+ * @param endpoint pointer to the mac endpoint of the peer
+ * @param peer peer identity to use for this session
+ * @return returns the session or NULL
+ */
+static struct Session *
+create_session (struct MacEndpoint *endpoint,
+ const struct GNUNET_PeerIdentity *peer, int inbound)
+{
+ struct Session *session;
+
GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), 1,
GNUNET_NO);
session = GNUNET_malloc (sizeof (struct Session));
GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head,
endpoint->sessions_tail,
session);
+ session->inbound = inbound;
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);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Created new session for peer `%s' with endpoint %s\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Created new %s session %p for peer `%s' with endpoint %s\n",
+ (GNUNET_YES == inbound) ? "inbound" : "outbound",
+ session,
GNUNET_i2s (peer),
- mac_to_string (&endpoint->addr));
+ mac_to_string (&endpoint->addr.mac));
+
return session;
}
+/**
+ * Look up a session for a peer and create a new session if none is found
+ *
+ * @param endpoint pointer to the mac endpoint of the peer
+ * @param peer peer identity to use for this session
+ * @return returns the session
+ */
+static struct Session *
+get_session (struct MacEndpoint *endpoint,
+ const struct GNUNET_PeerIdentity *peer,
+ int inbound)
+{
+ struct Session *session;
+ if (NULL != (session = lookup_session (endpoint, peer, inbound)))
+ return session;
+ return create_session (endpoint, peer, inbound);
+}
+
+
/**
* Function called once we have successfully given the fragment
* message to the SUID helper process and we are thus ready for
{
struct FragmentMessage *fm = cls;
+
fm->sh = NULL;
GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext);
}
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;
{
get_radiotap_header (endpoint, radio_header, size);
get_wlan_header (endpoint->plugin,
&radio_header->frame,
- &endpoint->addr,
+ &endpoint->addr.mac,
size);
memcpy (&radio_header[1], hdr, msize);
GNUNET_assert (NULL == fm->sh);
&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, _("# WLAN message fragments sent"),
1, GNUNET_NO);
else
GNUNET_FRAGMENT_context_transmission_done (fm->fragcontext);
+ GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
+ "# bytes currently in WLAN buffers",
+ -msize, GNUNET_NO);
+ GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
+ "# bytes transmitted via WLAN",
+ msize, GNUNET_NO);
}
}
GNUNET_HELPER_send_cancel (fm->sh);
fm->sh = NULL;
}
- GNUNET_FRAGMENT_context_destroy (fm->fragcontext);
+ GNUNET_FRAGMENT_context_destroy (fm->fragcontext,
+ &endpoint->msg_delay,
+ &endpoint->ack_delay);
if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (fm->timeout_task);
fm->timeout_task = GNUNET_SCHEDULER_NO_TASK;
if (NULL != fm->cont)
{
- fm->cont (fm->cont_cls, &fm->target, GNUNET_SYSERR);
+ fm->cont (fm->cont_cls, &fm->target, GNUNET_SYSERR, fm->size_payload, fm->size_on_wire);
fm->cont = NULL;
}
free_fragment_message (fm);
* @param timeout how long can the message wait?
* @param target peer that should receive the message
* @param msg message to transmit
+ * @param payload_size bytes of payload
* @param cont continuation to call once the message has
* been transmitted (or if the transport is ready
* for the next transmission call; or if the
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)
{
fm = GNUNET_malloc (sizeof (struct FragmentMessage));
fm->macendpoint = endpoint;
fm->target = *target;
+ fm->size_payload = payload_size;
+ fm->size_on_wire = 0;
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->fragcontext =
GNUNET_FRAGMENT_context_create (plugin->env->stats, WLAN_MTU,
&plugin->tracker,
- GNUNET_TIME_UNIT_SECONDS,
+ endpoint->msg_delay,
+ endpoint->ack_delay,
msg,
&transmit_fragment, fm);
fm->timeout_task =
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 (GNUNET_SCHEDULER_NO_TASK != endpoint->timeout_task)
{
endpoint->timeout_task = GNUNET_SCHEDULER_NO_TASK;
timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout);
- if (0 == timeout.rel_value)
+ if (0 == timeout.rel_value_us)
{
free_macendpoint (endpoint);
return;
*/
static struct MacEndpoint *
create_macendpoint (struct Plugin *plugin,
- const struct GNUNET_TRANSPORT_WLAN_MacAddress *addr)
+ const struct WlanAddress *addr)
{
struct MacEndpoint *pos;
for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
- if (0 == memcmp (addr, &pos->addr, sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)))
+ if (0 == memcmp (addr, &pos->addr, sizeof (struct WlanAddress)))
return pos;
pos = GNUNET_malloc (sizeof (struct MacEndpoint));
pos->addr = *addr;
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,
1, GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"New MAC endpoint `%s'\n",
- mac_to_string (addr));
+ wlan_plugin_address_to_string(NULL, addr, sizeof (struct WlanAddress)));
return pos;
}
+/**
+ * Function obtain the network type for a session
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param session the session
+ * @return the network type in HBO or GNUNET_SYSERR
+ */
+static enum GNUNET_ATS_Network_Type
+wlan_get_network (void *cls,
+ struct Session *session)
+{
+ GNUNET_assert (NULL != session);
+ return GNUNET_ATS_NET_WLAN;
+}
+
+
/**
* Creates a new outbound session the transport service will use to send data to the
* peer
if (NULL == address)
return NULL;
- if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != address->address_length)
+ 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),
- mac_to_string (address->address));
+ wlan_plugin_address_to_string(NULL, address->address, address->address_length));
endpoint = create_macendpoint (plugin, address->address);
- return create_session (endpoint, &address->peer);
+ return get_session (endpoint, &address->peer, GNUNET_NO);
}
wlanheader->target = session->target;
wlanheader->crc = htonl (GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size));
memcpy (&wlanheader[1], msgbuf, msgbuf_size);
+
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# bytes currently in WLAN buffers",
+ msgbuf_size, GNUNET_NO);
+
send_with_fragmentation (session->mac,
to,
&session->target,
&wlanheader->header,
+ msgbuf_size,
cont, cont_cls);
return size;
}
* @param client pointer to the session this message belongs to
* @param hdr start of the message
*/
-static void
+static int
process_data (void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
struct MacAndSession *mas = client;
struct MacAndSession xmas;
-#define NUM_ATS 2
- struct GNUNET_ATS_Information ats[NUM_ATS]; /* FIXME: do better here */
+ struct GNUNET_ATS_Information ats;
struct FragmentMessage *fm;
struct GNUNET_PeerIdentity tmpsource;
const struct WlanHeader *wlanheader;
int ret;
uint16_t msize;
- ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
- ats[0].value = htonl (1);
- ats[1].type = htonl (GNUNET_ATS_NETWORK_TYPE);
- ats[1].value = htonl (GNUNET_ATS_NET_WLAN);
+ ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
+ ats.value = htonl (GNUNET_ATS_NET_WLAN);
msize = ntohs (hdr->size);
+
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ "# bytes received via WLAN",
+ msize, GNUNET_NO);
+
switch (ntohs (hdr->type))
{
case GNUNET_MESSAGE_TYPE_HELLO:
GNUNET_break_op (0);
break;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
(unsigned int) msize,
GNUNET_i2s (&tmpsource),
- mac_to_string (&mas->endpoint->addr));
+ wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof (struct WlanAddress)));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# HELLO messages received via WLAN"), 1,
plugin->env->receive (plugin->env->cls,
&tmpsource,
hdr,
- ats, NUM_ATS,
mas->session,
(mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ (mas->endpoint == NULL) ? 0 : sizeof (struct WlanAddress));
+ plugin->env->update_address_metrics (plugin->env->cls,
+ &tmpsource,
+ (mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr,
+ (mas->endpoint == NULL) ? 0 : sizeof (struct WlanAddress),
+ mas->session,
+ &ats, 1);
break;
case GNUNET_MESSAGE_TYPE_FRAGMENT:
if (NULL == mas->endpoint)
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Processing %u bytes of FRAGMENT from MAC %s\n",
(unsigned int) msize,
- mac_to_string (&mas->endpoint->addr));
+ wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof (struct WlanAddress)));
GNUNET_STATISTICS_update (plugin->env->stats,
_("# fragments received via WLAN"), 1, GNUNET_NO);
(void) GNUNET_DEFRAGMENT_process_fragment (mas->endpoint->defrag,
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got last ACK, finished message transmission to `%s' (%p)\n",
- mac_to_string (&mas->endpoint->addr),
+ wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof (struct WlanAddress)),
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->cont (fm->cont_cls, &fm->target, GNUNET_OK, fm->size_payload, fm->size_on_wire);
fm->cont = NULL;
}
free_fragment_message (fm);
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got an ACK, message transmission to `%s' not yet finished\n",
- mac_to_string (&mas->endpoint->addr));
+ wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof (struct WlanAddress)));
break;
}
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"ACK not matched against any active fragmentation with MAC `%s'\n",
- mac_to_string (&mas->endpoint->addr));
+ wlan_plugin_address_to_string (NULL, &mas->endpoint->addr, sizeof (struct WlanAddress)));
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA:
if (NULL == mas->endpoint)
break;
}
xmas.endpoint = mas->endpoint;
- xmas.session = create_session (mas->endpoint, &wlanheader->sender);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Processing %u bytes of WLAN DATA from peer `%s'\n",
+ if (NULL == (xmas.session = lookup_session (mas->endpoint, &wlanheader->sender, GNUNET_YES)))
+ {
+ xmas.session = create_session (mas->endpoint, &wlanheader->sender, GNUNET_YES);
+ plugin->env->session_start (NULL, &wlanheader->sender,
+ PLUGIN_NAME, NULL, 0, xmas.session, NULL, 0);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Notifying transport about peer `%s''s new inbound session %p \n",
+ GNUNET_i2s (&wlanheader->sender), xmas.session);
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Processing %u bytes of WLAN DATA from peer `%s'\n",
(unsigned int) msize,
GNUNET_i2s (&wlanheader->sender));
(void) GNUNET_SERVER_mst_receive (plugin->wlan_header_payload_tokenizer,
plugin->env->receive (plugin->env->cls,
&mas->session->target,
hdr,
- ats, NUM_ATS,
mas->session,
(mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr,
- (mas->endpoint == NULL) ? 0 : sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ (mas->endpoint == NULL) ? 0 : sizeof (struct WlanAddress));
+ plugin->env->update_address_metrics (plugin->env->cls,
+ &mas->session->target,
+ (mas->endpoint == NULL) ? NULL : (const char *) &mas->endpoint->addr,
+ (mas->endpoint == NULL) ? 0 : sizeof (struct WlanAddress),
+ mas->session,
+ &ats, 1);
break;
}
+ return GNUNET_OK;
}
-#undef NUM_ATS
/**
* @param client client that send the data (not used)
* @param hdr header of the GNUNET_MessageHeader
*/
-static void
+static int
handle_helper_message (void *cls, void *client,
const struct GNUNET_MessageHeader *hdr)
{
struct Plugin *plugin = cls;
const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *cm;
+ struct WlanAddress wa;
struct MacAndSession mas;
uint16_t msize;
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);
plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
- &plugin->mac_address,
- sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ &wa,
+ sizeof (wa),
+ "wlan");
}
plugin->mac_address = cm->mac;
plugin->have_mac = GNUNET_YES;
+ memset (&wa, 0, sizeof (struct WlanAddress));
+ wa.mac = plugin->mac_address;
+ wa.options = htonl(plugin->options);
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,
- &plugin->mac_address,
- sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress));
+ &wa,
+ sizeof (struct WlanAddress),
+ "wlan");
break;
case GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER:
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));
- mas.endpoint = create_macendpoint (plugin, &rxinfo->frame.addr2);
+ 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,
ntohs (hdr->type), ntohs (hdr->size));
break;
}
+ return GNUNET_OK;
}
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 GNUNET_TRANSPORT_WLAN_MacAddress))
+ if (addrlen != sizeof (struct WlanAddress))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
mac_to_string (addr));
return GNUNET_NO; /* don't know my MAC */
}
- if (0 != memcmp (addr,
+ if (0 != memcmp (&wa->mac,
&plugin->mac_address,
- addrlen))
+ sizeof (wa->mac)))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Rejecting MAC `%s': not my MAC!\n",
static const char *
wlan_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
{
- static char ret[40];
const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac;
+ static char macstr[36];
- if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen)
+ if (sizeof (struct WlanAddress) != addrlen)
{
GNUNET_break (0);
return NULL;
}
- mac = addr;
- GNUNET_snprintf (ret, sizeof (ret), "%s MAC address %s",
- PROTOCOL_PREFIX,
- mac_to_string (mac));
- return ret;
+ 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;
}
GNUNET_TRANSPORT_AddressStringCallback asc,
void *asc_cls)
{
- const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac;
char *ret;
- if (sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress) != addrlen)
+ if (sizeof (struct WlanAddress) != addrlen)
{
/* invalid address */
LOG (GNUNET_ERROR_TYPE_WARNING,
asc (asc_cls, NULL);
return;
}
- mac = addr;
- GNUNET_asprintf (&ret,
- "%s MAC address %s",
- PROTOCOL_PREFIX,
- mac_to_string (mac));
+ ret = GNUNET_strdup (wlan_plugin_address_to_string(NULL, addr, addrlen));
asc (asc_cls, ret);
GNUNET_free (ret);
asc (asc_cls, NULL);
void *
libgnunet_plugin_transport_wlan_done (void *cls)
{
+ struct WlanAddress wa;
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
struct MacEndpoint *endpoint;
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;
+ plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
+ &wa,
+ sizeof (struct WlanAddress),
+ "wlan");
+ plugin->have_mac = GNUNET_NO;
+ }
+
if (GNUNET_SCHEDULER_NO_TASK != plugin->beacon_task)
{
GNUNET_SCHEDULER_cancel (plugin->beacon_task);
}
if (NULL != plugin->suid_helper)
{
- GNUNET_HELPER_stop (plugin->suid_helper);
+ GNUNET_HELPER_stop (plugin->suid_helper, GNUNET_NO);
plugin->suid_helper = NULL;
}
endpoint_next = plugin->mac_head;
}
+/**
+ * Function called to convert a string address to
+ * a binary address.
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param addr string address
+ * @param addrlen length of the address
+ * @param buf location to store the buffer
+ * @param added location to store the number of bytes in the buffer.
+ * If the function returns GNUNET_SYSERR, its contents are undefined.
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+static int
+wlan_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) || (addrlen == 0))
+ {
+ 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_malloc (sizeof (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;
+}
+
+
/**
* Entry point for the plugin.
*
struct Plugin *plugin;
char *interface;
unsigned long long testmode;
+ char *binary;
/* check for 'special' mode */
if (NULL == env->receive)
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 = NULL; // FIXME!
+ api->string_to_address = &wlan_string_to_address;
return api;
}
GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-wlan",
"TESTMODE", &testmode)) ||
(testmode > 2) ) )
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Invalid configuration option `%s' in section `%s'\n"),
- "TESTMODE",
- "transport-wlan");
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "transport-wlan", "TESTMODE");
return NULL;
}
+ binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-transport-wlan");
if ( (0 == testmode) &&
- (GNUNET_YES != GNUNET_OS_check_helper_binary ("gnunet-helper-transport-wlan")) )
+ (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"),
"gnunet-helper-transport-wlan");
+ GNUNET_free (binary);
return NULL;
}
+ GNUNET_free (binary);
if (GNUNET_YES !=
GNUNET_CONFIGURATION_get_value_string
(env->cfg, "transport-wlan", "INTERFACE",
&interface))
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Missing configuration option `%s' in section `%s'\n"),
- "INTERFACE",
- "transport-wlan");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "transport-wlan", "INTERFACE");
return NULL;
}
plugin->helper_payload_tokenizer = GNUNET_SERVER_mst_create (&process_data, plugin);
plugin->beacon_task = GNUNET_SCHEDULER_add_now (&send_hello_beacon,
plugin);
- switch (testmode)
+
+ plugin->options = 0;
+
+ /* some compilers do not like switch on 'long long'... */
+ switch ((unsigned int) testmode)
{
case 0: /* normal */
plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan";
plugin->helper_argv[1] = interface;
plugin->helper_argv[2] = NULL;
- plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan",
+ plugin->suid_helper = GNUNET_HELPER_start (GNUNET_NO,
+ "gnunet-helper-transport-wlan",
plugin->helper_argv,
&handle_helper_message,
+ NULL,
plugin);
break;
case 1: /* testmode, peer 1 */
plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy";
plugin->helper_argv[1] = (char *) "1";
plugin->helper_argv[2] = NULL;
- plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy",
+ plugin->suid_helper = GNUNET_HELPER_start (GNUNET_NO,
+ "gnunet-helper-transport-wlan-dummy",
plugin->helper_argv,
&handle_helper_message,
+ NULL,
plugin);
break;
case 2: /* testmode, peer 2 */
plugin->helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy";
plugin->helper_argv[1] = (char *) "2";
plugin->helper_argv[2] = NULL;
- plugin->suid_helper = GNUNET_HELPER_start ("gnunet-helper-transport-wlan-dummy",
+ plugin->suid_helper = GNUNET_HELPER_start (GNUNET_NO,
+ "gnunet-helper-transport-wlan-dummy",
plugin->helper_argv,
&handle_helper_message,
+ NULL,
plugin);
break;
default:
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_string_to_address;
+ api->get_network = &wlan_get_network;
return api;
}
projects / oweals / gnunet.git / blobdiff