if (NULL == endpoint)
{
- GNUNET_break (0);
- return;
+ GNUNET_break (0);
+ return;
}
if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
/**
* Free a session
*
+ * @param cls our `struct Plugin`.
* @param session the session free
*/
-static void
-free_session (struct Session *session)
+static int
+wlan_plugin_disconnect_session (void *cls,
+ struct Session *session)
{
struct MacEndpoint *endpoint = session->mac;
struct PendingMessage *pm;
GNUNET_SCHEDULER_cancel (session->timeout_task);
session->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), -1,
+ GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
+ _("# WLAN sessions allocated"), -1,
GNUNET_NO);
GNUNET_free (session);
+ return GNUNET_OK;
+}
+
+
+/**
+ * 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.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @return keepalive factor
+ */
+static unsigned int
+wlan_plugin_query_keepalive_factor (void *cls)
+{
+ return 3;
}
static void
session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct Session * session = cls;
+ struct Session *session = cls;
struct GNUNET_TIME_Relative timeout;
session->timeout_task = GNUNET_SCHEDULER_NO_TASK;
timeout = GNUNET_TIME_absolute_get_remaining (session->timeout);
if (0 == timeout.rel_value_us)
{
- free_session (session);
+ wlan_plugin_disconnect_session (session->mac->plugin,
+ session);
return;
}
session->timeout_task =
*
* @param endpoint pointer to the mac endpoint of the peer
* @param peer peer identity to use for this session
+ * @param inbound inbound session?
* @return returns the session or NULL
*/
static struct Session *
*
* @param endpoint pointer to the mac endpoint of the peer
* @param peer peer identity to use for this session
+ * @param inbound inbound session?
* @return returns the session or NULL
*/
static struct Session *
GNUNET_STATISTICS_update (endpoint->plugin->env->stats, _("# WLAN sessions allocated"), 1,
GNUNET_NO);
- session = GNUNET_malloc (sizeof (struct Session));
+ session = GNUNET_new (struct Session);
GNUNET_CONTAINER_DLL_insert_tail (endpoint->sessions_head,
endpoint->sessions_tail,
session);
*
* @param endpoint pointer to the mac endpoint of the peer
* @param peer peer identity to use for this session
+ * @param inbound inbound session?
* @return returns the session
*/
static struct Session *
* the next fragment.
*
* @param cls the 'struct FragmentMessage'
- * @param result result of the operation (GNUNET_OK on success, GNUNET_NO if the helper died, GNUNET_SYSERR
+ * @param result result of the operation (#GNUNET_OK on success, #GNUNET_NO if the helper died, #GNUNET_SYSERR
* if the helper was stopped)
*/
static void
fm->sh = NULL;
}
GNUNET_FRAGMENT_context_destroy (fm->fragcontext,
- &endpoint->msg_delay,
- &endpoint->ack_delay);
+ &endpoint->msg_delay,
+ &endpoint->ack_delay);
if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (fm->timeout_task);
static void
send_with_fragmentation (struct MacEndpoint *endpoint,
struct GNUNET_TIME_Relative timeout,
- const struct GNUNET_PeerIdentity *target,
+ const struct GNUNET_PeerIdentity *target,
const struct GNUNET_MessageHeader *msg,
size_t payload_size,
GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
struct Plugin *plugin;
plugin = endpoint->plugin;
- fm = GNUNET_malloc (sizeof (struct FragmentMessage));
+ fm = GNUNET_new (struct FragmentMessage);
fm->macendpoint = endpoint;
fm->target = *target;
fm->size_payload = payload_size;
GNUNET_STATISTICS_update (plugin->env->stats,
_("# WLAN MAC endpoints allocated"), -1, GNUNET_NO);
while (NULL != (session = endpoint->sessions_head))
- free_session (session);
+ wlan_plugin_disconnect_session (plugin,
+ session);
while (NULL != (fm = endpoint->sending_messages_head))
free_fragment_message (fm);
GNUNET_CONTAINER_DLL_remove (plugin->mac_head,
for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
if (0 == memcmp (addr, &pos->addr, sizeof (struct WlanAddress)))
return pos;
- pos = GNUNET_malloc (sizeof (struct MacEndpoint));
+ pos = GNUNET_new (struct MacEndpoint);
pos->addr = *addr;
pos->plugin = plugin;
pos->defrag =
* @param target peer from which to disconnect
*/
static void
-wlan_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
+wlan_plugin_disconnect_peer (void *cls,
+ const struct GNUNET_PeerIdentity *target)
{
struct Plugin *plugin = cls;
struct Session *session;
if (0 == memcmp (target, &session->target,
sizeof (struct GNUNET_PeerIdentity)))
{
- free_session (session);
+ wlan_plugin_disconnect_session (plugin, session);
break; /* inner-loop only (in case peer has another MAC as well!) */
}
}
break;
}
xmas.endpoint = mas->endpoint;
- if (NULL == (xmas.session = lookup_session (mas->endpoint, &wlanheader->sender, GNUNET_YES)))
+ 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);
+ xmas.session = create_session (mas->endpoint, &wlanheader->sender, GNUNET_YES);
+ plugin->env->session_start (NULL, &wlanheader->sender,
+ PLUGIN_NAME, &mas->endpoint->addr,
+ sizeof (struct WlanAddress), 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);
+ "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",
GNUNET_break (0);
return GNUNET_SYSERR;
}
- wa = GNUNET_malloc (sizeof (struct WlanAddress));
+ wa = GNUNET_new (struct WlanAddress);
for (i=0;i<6;i++)
wa->mac.mac[i] = a[i];
wa->options = htonl (0);
}
+static void
+wlan_plugin_update_session_timeout (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ struct Session *session)
+{
+ if (session->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ GNUNET_SCHEDULER_cancel (session->timeout_task);
+
+ session->timeout_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, &session_timeout, session);
+}
+
/**
* Entry point for the plugin.
*
{
/* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
initialze the plugin or the API */
- api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
+ 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;
return NULL;
}
- plugin = GNUNET_malloc (sizeof (struct Plugin));
+ plugin = GNUNET_new (struct Plugin);
plugin->interface = interface;
plugin->env = env;
GNUNET_STATISTICS_set (plugin->env->stats, _("# WLAN sessions allocated"),
GNUNET_assert (0);
}
- api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
+ api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
api->cls = plugin;
api->send = &wlan_plugin_send;
api->get_session = &wlan_plugin_get_session;
- api->disconnect = &wlan_plugin_disconnect;
+ api->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_string_to_address;
api->get_network = &wlan_get_network;
+ api->update_session_timeout = &wlan_plugin_update_session_timeout;
return api;
}
projects / oweals / gnunet.git / blobdiff