/*
- This file is part of GNUnet.
- Copyright (C) 2010-2016 GNUnet e.V.
+ This file is part of GNUnet.
+ Copyright (C) 2010-2016 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* @file transport/gnunet-service-transport.c
* How many messages can we have pending for a given client process
* before we start to drop incoming messages? We typically should
* have only one client and so this would be the primary buffer for
- * messages, so the number should be chosen rather generously.
+ * messages, so the number should be chosen rather generously.
*
* The expectation here is that most of the time the queue is large
* enough so that a drop is virtually never required. Note that
/**
* It is a blacklist, query about allowed connections.
*/
- CT_BLACKLIST = 3
+ CT_BLACKLIST = 3,
+
+ /**
+ * CORE client without any handlers.
+ */
+ CT_CORE_NO_HANDLERS = 4
};
*/
struct TransportClient
{
-
/**
* This is a doubly-linked list.
*/
*/
enum ClientType type;
- union {
-
+ union
+ {
/**
* Peer identity to monitor the addresses of.
* Zero to monitor all neighbours. Valid if
/**
* Additional details if @e type is CT_BLACKLIST.
*/
- struct {
-
+ struct
+ {
/**
* Blacklist check that we're currently performing (or NULL
* if we're performing one that has been cancelled).
* #GNUNET_YES if we have to call receive_done for this client
*/
int call_receive_done;
-
} blacklist;
-
} details;
-
};
-
/**
* Context we use when performing a blacklist check.
*/
struct GST_BlacklistCheck
{
-
/**
* This is a linked list.
*/
* Current task performing the check.
*/
struct GNUNET_SCHEDULER_Task *task;
-
};
/**
* Client that made the request.
*/
- struct TransportClient* tc;
+ struct TransportClient *tc;
};
*/
struct SendTransmitContinuationContext
{
-
/**
* Client that made the request.
*/
/**
* Interface scanner determines our LAN address range(s).
*/
-struct GNUNET_ATS_InterfaceScanner *GST_is;
-
+struct GNUNET_NT_InterfaceScanner *GST_is;
/**
* Queue the given message for transmission to the given client
{
struct GNUNET_MQ_Envelope *env;
- if ( (GNUNET_MQ_get_length (tc->mq) >= MAX_PENDING) &&
- (GNUNET_YES == may_drop) )
+ if ((GNUNET_MQ_get_length (tc->mq) >= MAX_PENDING) &&
+ (GNUNET_YES == may_drop))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Dropping message of type %u and size %u, have %u/%u messages pending\n",
- ntohs (msg->type),
- ntohs (msg->size),
- GNUNET_MQ_get_length (tc->mq),
- MAX_PENDING);
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Dropping message of type %u and size %u, have %u/%u messages pending\n",
+ ntohs (msg->type),
+ ntohs (msg->size),
+ GNUNET_MQ_get_length (tc->mq),
+ MAX_PENDING);
GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# messages dropped due to slow client"), 1,
+ gettext_noop (
+ "# messages dropped due to slow client"),
+ 1,
GNUNET_NO);
return;
}
env = GNUNET_MQ_msg_copy (msg);
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
}
*/
static void *
client_connect_cb (void *cls,
- struct GNUNET_SERVICE_Client *client,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
{
struct TransportClient *tc;
tc = GNUNET_new (struct TransportClient);
tc->client = client;
tc->mq = mq;
- GNUNET_CONTAINER_DLL_insert (clients_head,
- clients_tail,
- tc);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client %p connected\n",
- tc);
+ GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc);
return tc;
}
* @return #GNUNET_OK (continue to iterate)
*/
static int
-mark_match_down (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+mark_match_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
{
struct TransportClient *tc = cls;
struct SendTransmitContinuationContext *stcc = value;
*/
static void
client_disconnect_cb (void *cls,
- struct GNUNET_SERVICE_Client *client,
- void *app_ctx)
+ struct GNUNET_SERVICE_Client *client,
+ void *app_ctx)
{
struct TransportClient *tc = app_ctx;
struct GST_BlacklistCheck *bc;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client %p disconnected, cleaning up.\n",
tc);
- GNUNET_CONTAINER_multipeermap_iterate (active_stccs,
- &mark_match_down,
- tc);
- for (struct AddressToStringContext *cur = a2s_head;
- NULL != cur;
+ GNUNET_CONTAINER_multipeermap_iterate (active_stccs, &mark_match_down, tc);
+ for (struct AddressToStringContext *cur = a2s_head; NULL != cur;
cur = cur->next)
{
if (cur->tc == tc)
cur->tc = NULL;
}
- GNUNET_CONTAINER_DLL_remove (clients_head,
- clients_tail,
- tc);
+ GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
switch (tc->type)
{
case CT_NONE:
break;
+
case CT_CORE:
break;
+
case CT_MONITOR:
break;
+
case CT_BLACKLIST:
for (bc = bc_head; NULL != bc; bc = bc->next)
{
continue;
bc->bl_pos = tc->next;
if (NULL == bc->task)
- bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
- bc);
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
}
break;
+
+ case CT_CORE_NO_HANDLERS:
+ break;
}
GNUNET_free (tc);
}
if (GNUNET_NO == GST_neighbours_test_connected (peer))
return;
- cim.header.size = htons (sizeof (struct ConnectInfoMessage));
+ cim.header.size = htons (sizeof(struct ConnectInfoMessage));
cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
cim.id = *peer;
- cim.quota_in = bandwidth_in;
cim.quota_out = bandwidth_out;
- unicast (tc,
- &cim.header,
- GNUNET_NO);
+ unicast (tc, &cim.header, GNUNET_NO);
}
/**
* Initialize a normal client. We got a start message from this
- * client, add him to the list of clients for broadcasting of inbound
+ * client, add it to the list of clients for broadcasting of inbound
* messages.
*
* @param cls the client
* @param start the start message that was sent
*/
static void
-handle_client_start (void *cls,
- const struct StartMessage *start)
+handle_client_start (void *cls, const struct StartMessage *start)
{
struct TransportClient *tc = cls;
const struct GNUNET_MessageHeader *hello;
uint32_t options;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client %p sent START\n",
- tc);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p sent START\n", tc);
options = ntohl (start->options);
if ((0 != (1 & options)) &&
- (0 !=
- memcmp (&start->self,
- &GST_my_identity,
- sizeof (struct GNUNET_PeerIdentity))))
+ (0 != memcmp (&start->self,
+ &GST_my_identity,
+ sizeof(struct GNUNET_PeerIdentity))))
{
/* client thinks this is a different peer, reject */
GNUNET_break (0);
}
if (0 != (2 & options))
tc->type = CT_CORE;
+ else
+ tc->type = CT_CORE_NO_HANDLERS;
hello = GST_hello_get ();
if (NULL != hello)
- unicast (tc,
- hello,
- GNUNET_NO);
- GST_neighbours_iterate (¬ify_client_about_neighbour,
- tc);
+ unicast (tc, hello, GNUNET_NO);
+ GST_neighbours_iterate (¬ify_client_about_neighbour, tc);
GNUNET_SERVICE_client_continue (tc->client);
}
* @param message the HELLO message
*/
static int
-check_client_hello (void *cls,
- const struct GNUNET_MessageHeader *message)
+check_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
{
return GNUNET_OK; /* FIXME: check here? */
}
* @param message the HELLO message
*/
static void
-handle_client_hello (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
{
struct TransportClient *tc = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Received HELLO message\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received HELLO message\n");
GST_validation_handle_hello (message);
GNUNET_SERVICE_client_continue (tc->client);
}
if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"It took us %s to send %u/%u bytes to %s (%d, %s)\n",
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
(unsigned int) bytes_payload,
(unsigned int) bytes_on_wire,
GNUNET_i2s (&stcc->target),
else
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"It took us %s to send %u/%u bytes to %s (%d, %s)\n",
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
(unsigned int) bytes_payload,
(unsigned int) bytes_on_wire,
GNUNET_i2s (&stcc->target),
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending SEND_OK for transmission request %llu\n",
stcc->uuid);
- send_ok_msg.header.size = htons (sizeof (send_ok_msg));
+ send_ok_msg.header.size = htons (sizeof(send_ok_msg));
send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
send_ok_msg.bytes_msg = htonl (bytes_payload);
send_ok_msg.bytes_physical = htonl (bytes_on_wire);
send_ok_msg.success = htonl (success);
send_ok_msg.peer = stcc->target;
- unicast (stcc->tc,
- &send_ok_msg.header,
- GNUNET_NO);
- }
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_remove (active_stccs,
- &stcc->target,
- stcc));
+ unicast (stcc->tc, &send_ok_msg.header, GNUNET_NO);
+ }
+ GNUNET_assert (
+ GNUNET_OK ==
+ GNUNET_CONTAINER_multipeermap_remove (active_stccs, &stcc->target, stcc));
GNUNET_free (stcc);
}
* @param obm the send message that was sent
*/
static int
-check_client_send (void *cls,
- const struct OutboundMessage *obm)
+check_client_send (void *cls, const struct OutboundMessage *obm)
{
uint16_t size;
const struct GNUNET_MessageHeader *obmm;
- size = ntohs (obm->header.size) - sizeof (struct OutboundMessage);
- if (size < sizeof (struct GNUNET_MessageHeader))
+ size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
+ if (size < sizeof(struct GNUNET_MessageHeader))
{
GNUNET_break (0);
return GNUNET_SYSERR;
* @param obm the send message that was sent
*/
static void
-handle_client_send (void *cls,
- const struct OutboundMessage *obm)
+handle_client_send (void *cls, const struct OutboundMessage *obm)
{
static unsigned long long uuid_gen;
struct TransportClient *tc = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Could not send message to peer `%s': not connected\n",
GNUNET_i2s (&obm->peer));
- GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# bytes payload dropped (other peer was not connected)"),
- ntohs (obmm->size),
- GNUNET_NO);
+ GNUNET_STATISTICS_update (
+ GST_stats,
+ gettext_noop ("# bytes payload dropped (other peer was not connected)"),
+ ntohs (obmm->size),
+ GNUNET_NO);
GNUNET_SERVICE_client_continue (tc->client);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received SEND request %llu for `%s' and first message of type %u and total size %u\n",
- uuid_gen,
- GNUNET_i2s (&obm->peer),
- ntohs (obmm->type),
- ntohs (obmm->size));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Received SEND request %llu for `%s' and first message of type %u and total size %u\n",
+ uuid_gen,
+ GNUNET_i2s (&obm->peer),
+ ntohs (obmm->type),
+ ntohs (obmm->size));
GNUNET_SERVICE_client_continue (tc->client);
stcc = GNUNET_new (struct SendTransmitContinuationContext);
stcc->tc = tc;
stcc->send_time = GNUNET_TIME_absolute_get ();
stcc->uuid = uuid_gen++;
- (void) GNUNET_CONTAINER_multipeermap_put (active_stccs,
- &stcc->target,
- stcc,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+ (void) GNUNET_CONTAINER_multipeermap_put (
+ active_stccs,
+ &stcc->target,
+ stcc,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
GST_manipulation_send (&obm->peer,
obmm,
ntohs (obmm->size),
* never #GNUNET_NO
*/
static void
-transmit_address_to_client (void *cls,
- const char *buf,
- int res)
+transmit_address_to_client (void *cls, const char *buf, int res)
{
struct AddressToStringContext *actx = cls;
struct GNUNET_MQ_Envelope *env;
struct AddressToStringResultMessage *atsm;
size_t slen;
- GNUNET_assert ( (GNUNET_OK == res) ||
- (GNUNET_SYSERR == res) );
+ GNUNET_assert ((GNUNET_OK == res) || (GNUNET_SYSERR == res));
if (NULL == actx->tc)
return;
if (NULL == buf)
{
env = GNUNET_MQ_msg (atsm,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
if (GNUNET_OK == res)
{
/* this was the last call, transmit */
atsm->res = htonl (GNUNET_OK);
atsm->addr_len = htonl (0);
- GNUNET_MQ_send (actx->tc->mq,
- env);
- GNUNET_CONTAINER_DLL_remove (a2s_head,
- a2s_tail,
- actx);
+ GNUNET_MQ_send (actx->tc->mq, env);
+ GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, actx);
GNUNET_free (actx);
return;
}
/* address conversion failed, but there will be more callbacks */
atsm->res = htonl (GNUNET_SYSERR);
atsm->addr_len = htonl (0);
- GNUNET_MQ_send (actx->tc->mq,
- env);
+ GNUNET_MQ_send (actx->tc->mq, env);
return;
}
}
GNUNET_assert (GNUNET_OK == res);
/* succesful conversion, append*/
slen = strlen (buf) + 1;
- env = GNUNET_MQ_msg_extra (atsm,
- slen,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
+ env =
+ GNUNET_MQ_msg_extra (atsm,
+ slen,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
atsm->res = htonl (GNUNET_YES);
atsm->addr_len = htonl (slen);
- GNUNET_memcpy (&atsm[1],
- buf,
- slen);
- GNUNET_MQ_send (actx->tc->mq,
- env);
+ GNUNET_memcpy (&atsm[1], buf, slen);
+ GNUNET_MQ_send (actx->tc->mq, env);
}
*/
static int
check_client_address_to_string (void *cls,
- const struct AddressLookupMessage *alum)
+ const struct AddressLookupMessage *alum)
{
const char *plugin_name;
const char *address;
size = ntohs (alum->header.size);
address_len = ntohs (alum->addrlen);
- if (size <= sizeof (struct AddressLookupMessage) + address_len)
+ if (size <= sizeof(struct AddressLookupMessage) + address_len)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
address = (const char *) &alum[1];
plugin_name = (const char *) &address[address_len];
- if ('\0' != plugin_name[size - sizeof (struct AddressLookupMessage) - address_len - 1])
+ if ('\0' != plugin_name[size - sizeof(struct AddressLookupMessage)
+ - address_len - 1])
{
GNUNET_break (0);
return GNUNET_SYSERR;
*/
static void
handle_client_address_to_string (void *cls,
- const struct AddressLookupMessage *alum)
+ const struct AddressLookupMessage *alum)
{
struct TransportClient *tc = cls;
struct GNUNET_TRANSPORT_PluginFunctions *papi;
"Failed to find plugin `%s'\n",
plugin_name);
env = GNUNET_MQ_msg (atsm,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
atsm->res = htonl (GNUNET_SYSERR);
atsm->addr_len = htonl (0);
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
env = GNUNET_MQ_msg (atsm,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY);
atsm->res = htonl (GNUNET_OK);
atsm->addr_len = htonl (0);
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
return;
}
actx = GNUNET_new (struct AddressToStringContext);
actx->tc = tc;
- GNUNET_CONTAINER_DLL_insert (a2s_head,
- a2s_tail,
- actx);
+ GNUNET_CONTAINER_DLL_insert (a2s_head, a2s_tail, actx);
GNUNET_SERVICE_client_disable_continue_warning (tc->client);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Pretty-printing address of %u bytes using plugin `%s'\n",
papi->address_pretty_printer (papi->cls,
plugin_name,
address,
- address_len,
+ address_len,
numeric,
rtimeout,
&transmit_address_to_client,
* @return composed message
*/
static struct PeerIterateResponseMessage *
-compose_address_iterate_response_message (const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address)
+compose_address_iterate_response_message (
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address)
{
struct PeerIterateResponseMessage *msg;
size_t size;
tlen = 0;
alen = 0;
}
- size = (sizeof (struct PeerIterateResponseMessage) + alen + tlen);
+ size = (sizeof(struct PeerIterateResponseMessage) + alen + tlen);
msg = GNUNET_malloc (size);
msg->header.size = htons (size);
- msg->header.type
- = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
+ msg->header.type =
+ htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
msg->reserved = htonl (0);
msg->peer = *peer;
msg->addrlen = htonl (alen);
if (NULL != address)
{
- msg->local_address_info = htonl((uint32_t) address->local_info);
+ msg->local_address_info = htonl ((uint32_t) address->local_info);
addr = (char *) &msg[1];
- GNUNET_memcpy (addr,
- address->address,
- alen);
- GNUNET_memcpy (&addr[alen],
- address->transport_name,
- tlen);
+ GNUNET_memcpy (addr, address->address, alen);
+ GNUNET_memcpy (&addr[alen], address->transport_name, tlen);
}
return msg;
}
struct GNUNET_MQ_Envelope *env;
struct PeerIterateResponseMessage *msg;
- if ( (GNUNET_YES != pc->all) &&
- (0 != memcmp (peer,
- &pc->id,
- sizeof (pc->id))) )
+ if ((GNUNET_YES != pc->all) && (0 != memcmp (peer, &pc->id, sizeof(pc->id))))
return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending information about `%s' using address `%s' in state `%s'\n",
- GNUNET_i2s(peer),
+ GNUNET_i2s (peer),
(NULL != address) ? GST_plugins_a2s (address) : "<none>",
GNUNET_TRANSPORT_ps2s (state));
- msg = compose_address_iterate_response_message (peer,
- address);
+ msg = compose_address_iterate_response_message (peer, address);
msg->state = htonl (state);
- msg->state_timeout = GNUNET_TIME_absolute_hton(state_timeout);
+ msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
env = GNUNET_MQ_msg_copy (&msg->header);
GNUNET_free (msg);
- GNUNET_MQ_send (pc->tc->mq,
- env);
+ GNUNET_MQ_send (pc->tc->mq, env);
}
* @param msg the peer address information request
*/
static void
-handle_client_monitor_peers (void *cls,
- const struct PeerMonitorMessage *msg)
+handle_client_monitor_peers (void *cls, const struct PeerMonitorMessage *msg)
{
struct TransportClient *tc = cls;
struct IterationContext pc;
/* Send initial list */
pc.tc = tc;
- if (0 == memcmp (&msg->peer,
- &all_zeros,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
{
/* iterate over all neighbours */
pc.all = GNUNET_YES;
pc.all = GNUNET_NO;
pc.id = msg->peer;
}
- GST_neighbours_iterate (&send_peer_information,
- &pc);
+ GST_neighbours_iterate (&send_peer_information, &pc);
if (GNUNET_YES != ntohl (msg->one_shot))
{
tc->details.monitor_peer = msg->peer;
tc->type = CT_MONITOR;
- if (0 != memcmp (&msg->peer,
- &all_zeros,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 !=
+ memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client %p started monitoring of the peer `%s'\n",
- tc,
- GNUNET_i2s (&msg->peer));
+ "Client %p started monitoring of the peer `%s'\n",
+ tc,
+ GNUNET_i2s (&msg->peer));
else
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client %p started monitoring all peers\n",
- tc);
+ "Client %p started monitoring all peers\n",
+ tc);
}
else
{
struct GNUNET_MessageHeader *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END);
- GNUNET_MQ_send (tc->mq,
- env);
+ env =
+ GNUNET_MQ_msg (msg,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END);
+ GNUNET_MQ_send (tc->mq, env);
}
}
*/
static void
plugin_session_info_cb (void *cls,
- struct GNUNET_ATS_Session *session,
- const struct GNUNET_TRANSPORT_SessionInfo *info)
+ struct GNUNET_ATS_Session *session,
+ const struct GNUNET_TRANSPORT_SessionInfo *info)
{
struct GNUNET_MQ_Envelope *env;
struct TransportPluginMonitorMessage *msg;
if (0 == GNUNET_notification_context_get_size (plugin_nc))
{
- GST_plugins_monitor_subscribe (NULL,
- NULL);
+ GST_plugins_monitor_subscribe (NULL, NULL);
return;
}
- if ( (NULL == info) &&
- (NULL == session) )
+ if ((NULL == info) && (NULL == session))
{
/* end of initial iteration */
if (NULL != sync_client)
{
- env = GNUNET_MQ_msg (sync,
- GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC);
- GNUNET_MQ_send (sync_client->mq,
- env);
+ env =
+ GNUNET_MQ_msg (sync, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC);
+ GNUNET_MQ_send (sync_client->mq, env);
sync_client = NULL;
}
return;
info->address->transport_name);
slen = strlen (info->address->transport_name) + 1;
alen = info->address->address_length;
- size = sizeof (struct TransportPluginMonitorMessage) + slen + alen;
+ size = sizeof(struct TransportPluginMonitorMessage) + slen + alen;
if (size > UINT16_MAX)
{
GNUNET_break (0);
msg->plugin_name_len = htons (slen);
msg->plugin_address_len = htons (alen);
name = (char *) &msg[1];
- GNUNET_memcpy (name,
- info->address->transport_name,
- slen);
+ GNUNET_memcpy (name, info->address->transport_name, slen);
addr = &name[slen];
- GNUNET_memcpy (addr,
- info->address->address,
- alen);
+ GNUNET_memcpy (addr, info->address->address, alen);
if (NULL != sync_client)
{
struct GNUNET_MQ_Envelope *env;
env = GNUNET_MQ_msg_copy (&msg->header);
- GNUNET_MQ_send (sync_client->mq,
- env);
+ GNUNET_MQ_send (sync_client->mq, env);
}
else
{
- GNUNET_notification_context_broadcast (plugin_nc,
- &msg->header,
- GNUNET_NO);
+ GNUNET_notification_context_broadcast (plugin_nc, &msg->header, GNUNET_NO);
}
GNUNET_free (msg);
}
*/
static void
handle_client_monitor_plugins (void *cls,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct TransportClient *tc = cls;
GNUNET_SERVICE_client_mark_monitor (tc->client);
GNUNET_SERVICE_client_disable_continue_warning (tc->client);
- GNUNET_notification_context_add (plugin_nc,
- tc->mq);
+ GNUNET_notification_context_add (plugin_nc, tc->mq);
GNUNET_assert (NULL == sync_client);
sync_client = tc;
- GST_plugins_monitor_subscribe (&plugin_session_info_cb,
- NULL);
+ GST_plugins_monitor_subscribe (&plugin_session_info_cb, NULL);
}
* @param may_drop #GNUNET_YES if the message can be dropped / is payload
*/
void
-GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
- int may_drop)
+GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop)
{
- struct TransportClient *tc;
int done;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
(unsigned int) ntohs (msg->type),
(unsigned int) ntohs (msg->size));
done = GNUNET_NO;
- for (tc = clients_head; NULL != tc; tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
- if ( (GNUNET_YES == may_drop) &&
- (CT_CORE != tc->type) )
- continue; /* skip, this client does not care about payload */
- unicast (tc,
- msg,
- may_drop);
+ if (CT_NONE == tc->type)
+ continue; /* client not yet ready */
+ if ((GNUNET_YES == may_drop) && (CT_CORE != tc->type))
+ continue; /* skip, this client does not care about payload */
+ unicast (tc, msg, may_drop);
done = GNUNET_YES;
}
if (GNUNET_NO == done)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Message of type %u not delivered, is CORE service up?\n",
- ntohs (msg->type));
+ "Message of type %u not delivered, is CORE service up?\n",
+ ntohs (msg->type));
}
* @param state_timeout the time out for the state
*/
void
-GST_clients_broadcast_peer_notification (const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout)
+GST_clients_broadcast_peer_notification (
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout)
{
struct GNUNET_MQ_Envelope *env;
struct PeerIterateResponseMessage *msg;
- struct TransportClient *tc;
- msg = compose_address_iterate_response_message (peer,
- address);
+ msg = compose_address_iterate_response_message (peer, address);
msg->state = htonl (state);
msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
- for (tc = clients_head; NULL != tc; tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
if (CT_MONITOR != tc->type)
continue;
if ((0 == memcmp (&tc->details.monitor_peer,
- &all_zeros,
- sizeof (struct GNUNET_PeerIdentity))) ||
+ &all_zeros,
+ sizeof(struct GNUNET_PeerIdentity))) ||
(0 == memcmp (&tc->details.monitor_peer,
- peer,
- sizeof (struct GNUNET_PeerIdentity))))
+ peer,
+ sizeof(struct GNUNET_PeerIdentity))))
{
env = GNUNET_MQ_msg_copy (&msg->header);
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
}
}
GNUNET_free (msg);
* @return #GNUNET_OK (continue to iterate)
*/
static int
-mark_peer_down (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+mark_peer_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
{
struct SendTransmitContinuationContext *stcc = value;
disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
disconnect_msg.reserved = htonl (0);
disconnect_msg.peer = *peer;
- GST_clients_broadcast (&disconnect_msg.header,
- GNUNET_NO);
-
+ GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO);
}
static void
transmit_our_hello (void *cls,
const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
const struct GNUNET_MessageHeader *hello = cls;
- if (0 ==
- memcmp (peer,
- &GST_my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (peer, &GST_my_identity, sizeof(struct GNUNET_PeerIdentity)))
return; /* not to ourselves */
if (GNUNET_NO == GST_neighbours_test_connected (peer))
return;
GST_neighbours_send (peer,
- hello,
- ntohs (hello->size),
- hello_expiration,
+ hello,
+ ntohs (hello->size),
+ hello_expiration,
NULL,
- NULL);
+ NULL);
}
* @param hello new HELLO
*/
static void
-process_hello_update (void *cls,
- const struct GNUNET_MessageHeader *hello)
+process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Broadcasting HELLO to clients\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to clients\n");
GST_clients_broadcast (hello, GNUNET_NO);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Broadcasting HELLO to neighbours\n");
- GST_neighbours_iterate (&transmit_our_hello,
- (void *) hello);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to neighbours\n");
+ GST_neighbours_iterate (&transmit_our_hello, (void *) hello);
}
do_forward = GNUNET_SYSERR;
ret = GST_neighbours_calculate_receive_delay (&address->peer,
- msg_size,
- &do_forward);
+ msg_size,
+ &do_forward);
if (! GST_neighbours_test_connected (&address->peer))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
(unsigned int) msg_size,
ntohs (message->type),
GNUNET_i2s (&address->peer));
- GNUNET_STATISTICS_update (GST_stats, gettext_noop
- ("# bytes payload discarded due to not connected peer"),
- msg_size,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (
+ GST_stats,
+ gettext_noop ("# bytes payload discarded due to not connected peer"),
+ msg_size,
+ GNUNET_NO);
return ret;
}
im->header.size = htons (size);
im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
im->peer = address->peer;
- GNUNET_memcpy (&im[1],
- message,
- ntohs (message->size));
- GST_clients_broadcast (&im->header,
- GNUNET_YES);
+ GNUNET_memcpy (&im[1], message, ntohs (message->size));
+ GST_clients_broadcast (&im->header, GNUNET_YES);
return ret;
}
struct GNUNET_ATS_SessionKiller *sk = cls;
sk->task = NULL;
- GNUNET_CONTAINER_DLL_remove (sk_head,
- sk_tail,
- sk);
- sk->plugin->disconnect_session (sk->plugin->cls,
- sk->session);
- GNUNET_free(sk);
+ GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
+ sk->plugin->disconnect_session (sk->plugin->cls, sk->session);
+ GNUNET_free (sk);
}
* @param session session to termiante
*/
static void
-kill_session (const char *plugin_name,
- struct GNUNET_ATS_Session *session)
+kill_session (const char *plugin_name, struct GNUNET_ATS_Session *session)
{
struct GNUNET_TRANSPORT_PluginFunctions *plugin;
struct GNUNET_ATS_SessionKiller *sk;
plugin = GST_plugins_find (plugin_name);
if (NULL == plugin)
{
- GNUNET_break(0);
+ GNUNET_break (0);
return;
}
/* need to issue disconnect asynchronously */
sk = GNUNET_new (struct GNUNET_ATS_SessionKiller);
sk->session = session;
sk->plugin = plugin;
- sk->task = GNUNET_SCHEDULER_add_now (&kill_session_task,
- sk);
- GNUNET_CONTAINER_DLL_insert (sk_head,
- sk_tail,
- sk);
+ sk->task = GNUNET_SCHEDULER_add_now (&kill_session_task, sk);
+ GNUNET_CONTAINER_DLL_insert (sk_head, sk_tail, sk);
}
static void
connect_bl_check_cont (void *cls,
const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct GNUNET_ATS_Session *session,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_ATS_Session *session,
int result)
{
struct GNUNET_MessageHeader *msg = cls;
"Received SYN message from peer `%s' at `%s'\n",
GNUNET_i2s (peer),
GST_plugins_a2s (address));
- if (GNUNET_OK !=
- GST_neighbours_handle_session_syn (msg,
- peer))
+ if (GNUNET_OK != GST_neighbours_handle_session_syn (msg, peer))
{
- GST_blacklist_abort_matching (address,
- session);
- kill_session (address->transport_name,
- session);
+ GST_blacklist_abort_matching (address, session);
+ kill_session (address->transport_name, session);
}
GNUNET_free (msg);
return;
return; /* check was aborted, session destroyed */
/* Blacklist denies to speak to this peer */
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Discarding SYN message from `%s' due to denied blacklist check\n",
- GNUNET_i2s (peer));
- kill_session (address->transport_name,
- session);
+ "Discarding SYN message from `%s' due to denied blacklist check\n",
+ GNUNET_i2s (peer));
+ kill_session (address->transport_name, session);
}
gettext_noop ("# bytes total received"),
ntohs (message->size),
GNUNET_NO);
- GST_neighbours_notify_data_recv (address,
- message);
+ GST_neighbours_notify_data_recv (address, message);
switch (type)
{
case GNUNET_MESSAGE_TYPE_HELLO_LEGACY:
/* Legacy HELLO message, discard */
return ret;
+
case GNUNET_MESSAGE_TYPE_HELLO:
if (GNUNET_OK != GST_validation_handle_hello (message))
{
GNUNET_break_op (0);
- GST_blacklist_abort_matching (address,
- session);
+ GST_blacklist_abort_matching (address, session);
}
return ret;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Processing PING from `%s'\n",
GST_plugins_a2s (address));
if (GNUNET_OK !=
- GST_validation_handle_ping (&address->peer,
- message,
- address,
- session))
+ GST_validation_handle_ping (&address->peer, message, address, session))
{
- GST_blacklist_abort_matching (address,
- session);
- kill_session (plugin_name,
- session);
+ GST_blacklist_abort_matching (address, session);
+ kill_session (plugin_name, session);
}
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Processing PONG from `%s'\n",
- GST_plugins_a2s (address));
- if (GNUNET_OK !=
- GST_validation_handle_pong (&address->peer,
- message))
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Processing PONG from `%s'\n",
+ GST_plugins_a2s (address));
+ if (GNUNET_OK != GST_validation_handle_pong (&address->peer, message))
{
GNUNET_break_op (0);
- GST_blacklist_abort_matching (address,
- session);
+ GST_blacklist_abort_matching (address, session);
kill_session (plugin_name, session);
}
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN:
/* Do blacklist check if communication with this peer is allowed */
(void) GST_blacklist_test_allowed (&address->peer,
- NULL,
- &connect_bl_check_cont,
- GNUNET_copy_message (message),
- address,
- session);
+ NULL,
+ &connect_bl_check_cont,
+ GNUNET_copy_message (message),
+ address,
+ session);
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK:
if (GNUNET_OK !=
- GST_neighbours_handle_session_syn_ack (message,
- address,
- session))
+ GST_neighbours_handle_session_syn_ack (message, address, session))
{
GST_blacklist_abort_matching (address, session);
kill_session (plugin_name, session);
}
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK:
if (GNUNET_OK !=
- GST_neighbours_handle_session_ack (message,
- address,
- session))
+ GST_neighbours_handle_session_ack (message, address, session))
{
- GNUNET_break_op(0);
+ GNUNET_break_op (0);
GST_blacklist_abort_matching (address, session);
kill_session (plugin_name, session);
}
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT:
- GST_neighbours_handle_disconnect_message (&address->peer,
- message);
+ GST_neighbours_handle_disconnect_message (&address->peer, message);
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA:
- GST_neighbours_handle_quota_message (&address->peer,
- message);
+ GST_neighbours_handle_quota_message (&address->peer, message);
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE:
- GST_neighbours_keepalive (&address->peer,
- message);
+ GST_neighbours_keepalive (&address->peer, message);
break;
+
case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE:
- GST_neighbours_keepalive_response (&address->peer,
- message);
+ GST_neighbours_keepalive_response (&address->peer, message);
break;
+
default:
/* should be payload */
GNUNET_STATISTICS_update (GST_stats,
gettext_noop ("# bytes payload received"),
ntohs (message->size),
GNUNET_NO);
- ret = process_payload (address,
- session,
- message);
+ ret = process_payload (address, session, message);
break;
}
- end:
+end:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Allowing receive from peer %s to continue in %s\n",
GNUNET_i2s (&address->peer),
- GNUNET_STRINGS_relative_time_to_string (ret,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
return ret;
}
* @param address the address to add or remove
*/
static void
-plugin_env_address_change_notification (void *cls,
- int add_remove,
- const struct GNUNET_HELLO_Address *address)
+plugin_env_address_change_notification (
+ void *cls,
+ int add_remove,
+ const struct GNUNET_HELLO_Address *address)
{
static int addresses = 0;
if (GNUNET_YES == add_remove)
{
- addresses ++;
- GNUNET_STATISTICS_update (GST_stats,
- "# transport addresses",
- 1,
- GNUNET_NO);
+ addresses++;
+ GNUNET_STATISTICS_update (GST_stats, "# transport addresses", 1, GNUNET_NO);
}
else if (GNUNET_NO == add_remove)
{
}
else
{
- addresses --;
+ addresses--;
GNUNET_STATISTICS_update (GST_stats,
"# transport addresses",
-1,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Transport now has %u addresses to communicate\n",
addresses);
- GST_hello_modify_addresses (add_remove,
- address);
+ GST_hello_modify_addresses (add_remove, address);
}
}
GNUNET_assert (strlen (address->transport_name) > 0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Notification from plugin about terminated session %p from peer `%s' address `%s'\n",
- session,
- GNUNET_i2s (&address->peer),
- GST_plugins_a2s (address));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Notification from plugin about terminated session %p from peer `%s' address `%s'\n",
+ session,
+ GNUNET_i2s (&address->peer),
+ GST_plugins_a2s (address));
- GST_neighbours_session_terminated (&address->peer,
- session);
- GST_ats_del_session (address,
- session);
- GST_blacklist_abort_matching (address,
- session);
+ GST_neighbours_session_terminated (&address->peer, session);
+ GST_ats_del_session (address, session);
+ GST_blacklist_abort_matching (address, session);
for (sk = sk_head; NULL != sk; sk = sk->next)
{
if (sk->session == session)
{
- GNUNET_CONTAINER_DLL_remove (sk_head,
- sk_tail,
- sk);
+ GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
GNUNET_SCHEDULER_cancel (sk->task);
- GNUNET_free(sk);
+ GNUNET_free (sk);
break;
}
}
* @param result the result
*/
static void
-plugin_env_session_start_bl_check_cont (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct GNUNET_ATS_Session *session,
- int result)
+plugin_env_session_start_bl_check_cont (
+ void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_ATS_Session *session,
+ int result)
{
if (GNUNET_OK != result)
{
- kill_session (address->transport_name,
- session);
+ kill_session (address->transport_name, session);
return;
}
if (GNUNET_YES !=
GNUNET_HELLO_address_check_option (address,
- GNUNET_HELLO_ADDRESS_INFO_INBOUND))
+ GNUNET_HELLO_ADDRESS_INFO_INBOUND))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Informing verifier about inbound session's address `%s'\n",
plugin_env_session_start (void *cls,
const struct GNUNET_HELLO_Address *address,
struct GNUNET_ATS_Session *session,
- enum GNUNET_ATS_Network_Type scope)
+ enum GNUNET_NetworkType scope)
{
struct GNUNET_ATS_Properties prop;
if (NULL == address)
{
- GNUNET_break(0);
+ GNUNET_break (0);
return;
}
if (NULL == session)
{
- GNUNET_break(0);
+ GNUNET_break (0);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Notification from plugin `%s' about new session from peer `%s' address `%s'\n",
- address->transport_name,
- GNUNET_i2s (&address->peer),
- GST_plugins_a2s (address));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_INFO,
+ "Notification from plugin `%s' about new session from peer `%s' address `%s'\n",
+ address->transport_name,
+ GNUNET_i2s (&address->peer),
+ GST_plugins_a2s (address));
if (GNUNET_YES ==
GNUNET_HELLO_address_check_option (address,
GNUNET_HELLO_ADDRESS_INFO_INBOUND))
for example for UNIX, we have symmetric connections and thus we
may not know the address yet; add if necessary! */
/* FIXME: maybe change API here so we just pass scope? */
- memset (&prop,
- 0,
- sizeof (prop));
- GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != scope);
+ memset (&prop, 0, sizeof(prop));
+ GNUNET_break (GNUNET_NT_UNSPECIFIED != scope);
prop.scope = scope;
- GST_ats_add_inbound_address (address,
- session,
- &prop);
+ GST_ats_add_inbound_address (address, session, &prop);
}
/* Do blacklist check if communication with this peer is allowed */
(void) GST_blacklist_test_allowed (&address->peer,
- address->transport_name,
- &plugin_env_session_start_bl_check_cont,
- NULL,
- address,
- session);
+ address->transport_name,
+ &plugin_env_session_start_bl_check_cont,
+ NULL,
+ address,
+ session);
}
* @param address address to use (for peer given in address)
* @param session session to use (if available)
* @param bandwidth_out assigned outbound bandwidth for the connection in NBO,
- * 0 to disconnect from peer
+ * 0 to disconnect from peer
* @param bandwidth_in assigned inbound bandwidth for the connection in NBO,
- * 0 to disconnect from peer
+ * 0 to disconnect from peer
* @param ats ATS information
* @param ats_count number of @a ats elements
*/
static void
confirm_or_drop_neighbour (void *cls,
const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct GNUNET_ATS_Session *session,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_ATS_Session *session,
int allowed)
{
if (GNUNET_OK == allowed)
- return; /* we're done */
+ return; /* we're done */
GNUNET_STATISTICS_update (GST_stats,
gettext_noop ("# disconnects due to blacklist"),
- 1,
+ 1,
GNUNET_NO);
GST_neighbours_force_disconnect (peer);
}
static void
test_connection_ok (void *cls,
const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- enum GNUNET_TRANSPORT_PeerState state,
- struct GNUNET_TIME_Absolute state_timeout,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
+ const struct GNUNET_HELLO_Address *address,
+ enum GNUNET_TRANSPORT_PeerState state,
+ struct GNUNET_TIME_Absolute state_timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
struct TestConnectionContext *tcc = cls;
struct GST_BlacklistCheck *bc;
bc = GNUNET_new (struct GST_BlacklistCheck);
- GNUNET_CONTAINER_DLL_insert (bc_head,
- bc_tail,
- bc);
+ GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
bc->peer = *peer;
bc->address = GNUNET_HELLO_address_copy (address);
bc->cont = &confirm_or_drop_neighbour;
{
/* all would wait for the same client, no need to
* create more than just the first task right now */
- bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
- bc);
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
tcc->first = GNUNET_NO;
}
}
/**
* Initialize a blacklisting client. We got a blacklist-init
- * message from this client, add him to the list of clients
+ * message from this client, add it to the list of clients
* to query for blacklisting.
*
* @param cls the client
*/
static void
handle_client_blacklist_init (void *cls,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct TransportClient *tc = cls;
struct TestConnectionContext tcc;
GNUNET_SERVICE_client_mark_monitor (tc->client);
tc->type = CT_BLACKLIST;
tc->details.blacklist.call_receive_done = GNUNET_YES;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "New blacklist client %p\n",
- tc);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New blacklist client %p\n", tc);
/* confirm that all existing connections are OK! */
tcc.tc = tc;
tcc.first = GNUNET_YES;
- GST_neighbours_iterate (&test_connection_ok,
- &tcc);
+ GST_neighbours_iterate (&test_connection_ok, &tcc);
}
*/
static int
free_blacklist_entry (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
char *be = value;
* @param message containing information
*/
static void
-handle_client_set_metric (void *cls,
- const struct TrafficMetricMessage *tm)
+handle_client_set_metric (void *cls, const struct TrafficMetricMessage *tm)
{
struct TransportClient *tc = cls;
GST_ats = NULL;
GNUNET_ATS_connectivity_done (GST_ats_connect);
GST_ats_connect = NULL;
- GNUNET_ATS_scanner_done (GST_is);
+ GNUNET_NT_scanner_done (GST_is);
GST_is = NULL;
while (NULL != (cur = a2s_head))
{
- GNUNET_CONTAINER_DLL_remove (a2s_head,
- a2s_tail,
- cur);
+ GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, cur);
GNUNET_free (cur);
}
if (NULL != plugin_nc)
if (NULL != blacklist)
{
GNUNET_CONTAINER_multipeermap_iterate (blacklist,
- &free_blacklist_entry,
- NULL);
+ &free_blacklist_entry,
+ NULL);
GNUNET_CONTAINER_multipeermap_destroy (blacklist);
blacklist = NULL;
}
"No other blacklist clients active, will allow neighbour `%s'\n",
GNUNET_i2s (&bc->peer));
- bc->cont (bc->cont_cls,
- &bc->peer,
- bc->address,
- bc->session,
- GNUNET_OK);
+ bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_OK);
GST_blacklist_test_cancel (bc);
return;
}
- if ( (NULL != tc->details.blacklist.bc) ||
- (GNUNET_NO != tc->details.blacklist.waiting_for_reply) )
- return; /* someone else busy with this client */
+ if ((NULL != tc->details.blacklist.bc) ||
+ (GNUNET_NO != tc->details.blacklist.waiting_for_reply))
+ return; /* someone else busy with this client */
tc->details.blacklist.bc = bc;
- env = GNUNET_MQ_msg (bm,
- GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
+ env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
bm->is_allowed = htonl (0);
bm->peer = bc->peer;
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
if (GNUNET_YES == tc->details.blacklist.call_receive_done)
{
tc->details.blacklist.call_receive_done = GNUNET_NO;
* @param msg the blacklist-reply message that was sent
*/
static void
-handle_client_blacklist_reply (void *cls,
- const struct BlacklistMessage *msg)
+handle_client_blacklist_reply (void *cls, const struct BlacklistMessage *msg)
{
struct TransportClient *tc = cls;
struct GST_BlacklistCheck *bc;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Blacklist check failed, peer not allowed\n");
/* For the duration of the continuation, make the ongoing
- check invisible (to avoid double-cancellation); then
- add it back again so we can re-use GST_blacklist_test_cancel() */
- GNUNET_CONTAINER_DLL_remove (bc_head,
- bc_tail,
- bc);
- bc->cont (bc->cont_cls,
- &bc->peer,
- bc->address,
- bc->session,
- GNUNET_NO);
- GNUNET_CONTAINER_DLL_insert (bc_head,
- bc_tail,
- bc);
+ check invisible (to avoid double-cancellation); then
+ add it back again so we can re-use GST_blacklist_test_cancel() */
+ GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
+ bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_NO);
+ GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
GST_blacklist_test_cancel (bc);
tc->details.blacklist.call_receive_done = GNUNET_NO;
GNUNET_SERVICE_client_continue (tc->client);
tc->details.blacklist.call_receive_done = GNUNET_NO;
GNUNET_SERVICE_client_continue (tc->client);
bc->bl_pos = tc->next;
- bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
- bc);
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
}
}
/* check if any other blacklist checks are waiting for this blacklister */
for (bc = bc_head; bc != NULL; bc = bc->next)
- if ( (bc->bl_pos == tc) &&
- (NULL == bc->task) )
+ if ((bc->bl_pos == tc) && (NULL == bc->task))
{
- bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
- bc);
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
break;
}
}
if (NULL != transport_name)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Adding peer `%s' with plugin `%s' to blacklist\n",
- GNUNET_i2s (peer),
- transport_name);
+ "Adding peer `%s' with plugin `%s' to blacklist\n",
+ GNUNET_i2s (peer),
+ transport_name);
transport = GNUNET_strdup (transport_name);
}
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Adding peer `%s' with all plugins to blacklist\n",
- GNUNET_i2s (peer));
+ "Adding peer `%s' with all plugins to blacklist\n",
+ GNUNET_i2s (peer));
if (NULL == blacklist)
blacklist =
GNUNET_CONTAINER_multipeermap_create (TRANSPORT_BLACKLIST_HT_SIZE,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_CONTAINER_multipeermap_put (blacklist,
- peer,
+ peer,
transport,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}
*/
void
GST_blacklist_abort_matching (const struct GNUNET_HELLO_Address *address,
- struct GNUNET_ATS_Session *session)
+ struct GNUNET_ATS_Session *session)
{
struct GST_BlacklistCheck *bc;
struct GST_BlacklistCheck *n;
while (NULL != (bc = n))
{
n = bc->next;
- if ( (bc->session == session) &&
- (0 == GNUNET_HELLO_address_cmp (bc->address,
- address)) )
+ if ((bc->session == session) &&
+ (0 == GNUNET_HELLO_address_cmp (bc->address, address)))
{
bc->cont (bc->cont_cls,
- &bc->peer,
- bc->address,
- bc->session,
- GNUNET_SYSERR);
+ &bc->peer,
+ bc->address,
+ bc->session,
+ GNUNET_SYSERR);
GST_blacklist_test_cancel (bc);
}
}
* @return #GNUNET_OK if the entry does not match, #GNUNET_NO if it matches
*/
static int
-test_blacklisted (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+test_blacklisted (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
{
const char *transport_name = cls;
char *be = value;
* If (NULL != transport_name) we look for a transport specific entry:
* if (transport_name == be) forbidden
*
- */
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Comparing BL request for peer `%4s':`%s' with BL entry: `%s'\n",
- GNUNET_i2s (key),
- (NULL == transport_name) ? "unspecified" : transport_name,
- (NULL == be) ? "all plugins" : be);
+ */GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Comparing BL request for peer `%4s':`%s' with BL entry: `%s'\n",
+ GNUNET_i2s (key),
+ (NULL == transport_name) ? "unspecified" : transport_name,
+ (NULL == be) ? "all plugins" : be);
/* all plugins for this peer were blacklisted: disallow */
if (NULL == value)
return GNUNET_NO;
/* blacklist check for specific transport */
- if ( (NULL != transport_name) &&
- (NULL != value) )
+ if ((NULL != transport_name) && (NULL != value))
{
- if (0 == strcmp (transport_name,
- be))
- return GNUNET_NO; /* plugin is blacklisted! */
+ if (0 == strcmp (transport_name, be))
+ return GNUNET_NO; /* plugin is blacklisted! */
}
return GNUNET_OK;
}
const char *transport_name,
GST_BlacklistTestContinuation cont,
void *cont_cls,
- const struct GNUNET_HELLO_Address *address,
- struct GNUNET_ATS_Session *session)
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_ATS_Session *session)
{
struct GST_BlacklistCheck *bc;
struct TransportClient *tc;
* If iteration is aborted, we found a matching blacklist entry */
if ((NULL != blacklist) &&
(GNUNET_SYSERR ==
- GNUNET_CONTAINER_multipeermap_get_multiple (blacklist, peer,
+ GNUNET_CONTAINER_multipeermap_get_multiple (blacklist,
+ peer,
&test_blacklisted,
(void *) transport_name)))
{
GNUNET_STATISTICS_update (GST_stats,
gettext_noop ("# disconnects due to blacklist"),
1,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Disallowing connection to peer `%s' on transport %s\n"),
- GNUNET_i2s (peer),
+ _ ("Disallowing connection to peer `%s' on transport %s\n"),
+ GNUNET_i2s (peer),
(NULL != transport_name) ? transport_name : "unspecified");
if (NULL != cont)
- cont (cont_cls,
- peer,
- address,
- session,
- GNUNET_NO);
+ cont (cont_cls, peer, address, session, GNUNET_NO);
return NULL;
}
{
/* no blacklist clients, approve instantly */
if (NULL != cont)
- cont (cont_cls,
- peer,
- address,
- session,
- GNUNET_OK);
+ cont (cont_cls, peer, address, session, GNUNET_OK);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Allowing connection to peer `%s' %s\n",
- GNUNET_i2s (peer),
+ GNUNET_i2s (peer),
(NULL != transport_name) ? transport_name : "");
return NULL;
}
/* need to query blacklist clients */
bc = GNUNET_new (struct GST_BlacklistCheck);
- GNUNET_CONTAINER_DLL_insert (bc_head,
- bc_tail,
- bc);
+ GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
bc->peer = *peer;
bc->address = GNUNET_HELLO_address_copy (address);
bc->session = session;
bc->cont = cont;
bc->cont_cls = cont_cls;
bc->bl_pos = tc;
- bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
- bc);
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
return bc;
}
void
GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc)
{
- GNUNET_CONTAINER_DLL_remove (bc_head,
- bc_tail,
- bc);
+ GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
if (NULL != bc->bl_pos)
{
- if ( (CT_BLACKLIST == bc->bl_pos->type) &&
- (bc->bl_pos->details.blacklist.bc == bc) )
+ if ((CT_BLACKLIST == bc->bl_pos->type) &&
+ (bc->bl_pos->details.blacklist.bc == bc))
{
/* we're at the head of the queue, remove us! */
bc->bl_pos->details.blacklist.bc = NULL;
static void
blacklist_cfg_iter (void *cls,
const char *section,
- const char *option,
- const char *value)
+ const char *option,
+ const char *value)
{
unsigned int *res = cls;
struct GNUNET_PeerIdentity peer;
&peer.public_key))
return;
- if ((NULL == value) || (0 == strcmp(value, "")))
+ if ((NULL == value) || (0 == strcmp (value, "")))
{
/* Blacklist whole peer */
GST_blacklist_add_peer (&peer, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Adding blacklisting entry for peer `%s'\n"),
+ _ ("Adding blacklisting entry for peer `%s'\n"),
GNUNET_i2s (&peer));
}
else
{
plugs = GNUNET_strdup (value);
for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Adding blacklisting entry for peer `%s':`%s'\n"),
- GNUNET_i2s (&peer), pos);
- GST_blacklist_add_peer (&peer, pos);
- }
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _ ("Adding blacklisting entry for peer `%s':`%s'\n"),
+ GNUNET_i2s (&peer),
+ pos);
+ GST_blacklist_add_peer (&peer, pos);
+ }
GNUNET_free (plugs);
}
(*res)++;
*/
static void
read_blacklist_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *my_id)
+ const struct GNUNET_PeerIdentity *my_id)
{
char cfg_sect[512];
unsigned int res = 0;
GNUNET_snprintf (cfg_sect,
- sizeof (cfg_sect),
- "transport-blacklist-%s",
- GNUNET_i2s_full (my_id));
+ sizeof(cfg_sect),
+ "transport-blacklist-%s",
+ GNUNET_i2s_full (my_id));
GNUNET_CONFIGURATION_iterate_section_values (cfg,
cfg_sect,
&blacklist_cfg_iter,
/* setup globals */
GST_cfg = c;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (c,
- "PEER",
- "PRIVATE_KEY",
- &keyfile))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- _("Transport service is lacking key configuration settings. Exiting.\n"));
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
+ "PEER",
+ "PRIVATE_KEY",
+ &keyfile))
+ {
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_ERROR,
+ _ (
+ "Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (c,
- "transport",
- "HELLO_EXPIRATION",
- &hello_expiration))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (c,
+ "transport",
+ "HELLO_EXPIRATION",
+ &hello_expiration))
{
hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
}
&GST_my_identity.public_key);
GNUNET_assert (NULL != GST_my_private_key);
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "My identity is `%s'\n",
- GNUNET_i2s_full (&GST_my_identity));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "My identity is `%s'\n",
+ GNUNET_i2s_full (&GST_my_identity));
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
if (NULL == GST_peerinfo)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not access PEERINFO service. Exiting.\n"));
+ _ ("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
{
struct rlimit r_file;
- if (0 == getrlimit (RLIMIT_NOFILE,
- &r_file))
+ if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
{
max_fd_rlimit = r_file.rlim_cur;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Maximum number of open files was: %u/%u\n",
- (unsigned int) r_file.rlim_cur,
- (unsigned int) r_file.rlim_max);
+ "Maximum number of open files was: %u/%u\n",
+ (unsigned int) r_file.rlim_cur,
+ (unsigned int) r_file.rlim_max);
}
- max_fd_rlimit = (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
+ max_fd_rlimit =
+ (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
}
#endif
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (GST_cfg,
- "transport",
- "MAX_FD",
- &max_fd_cfg))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (GST_cfg,
+ "transport",
+ "MAX_FD",
+ &max_fd_cfg))
max_fd_cfg = max_fd_rlimit;
if (max_fd_cfg > max_fd_rlimit)
(max_fd / 3),
(max_fd / 3) * 2);
- friend_only = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
- "topology",
- "FRIENDS-ONLY");
+ friend_only =
+ GNUNET_CONFIGURATION_get_value_yesno (GST_cfg, "topology", "FRIENDS-ONLY");
if (GNUNET_SYSERR == friend_only)
friend_only = GNUNET_NO; /* According to topology defaults */
/* start subsystems */
- read_blacklist_configuration (GST_cfg,
- &GST_my_identity);
- GST_is = GNUNET_ATS_scanner_init ();
+ /* Disable DSTJ peer */
+ {
+ struct GNUNET_PeerIdentity dstj;
+ const char *ds = "DSTJBRRKZ8TBW3FGK6B0M5QXWT9WYNZ45H5MCV4HY7ST64Q8T9F0";
+
+ GNUNET_assert (
+ GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_public_key_from_string (ds,
+ strlen (ds),
+ &dstj.public_key));
+ GST_blacklist_add_peer (&dstj, NULL);
+ }
+ read_blacklist_configuration (GST_cfg, &GST_my_identity);
+ GST_is = GNUNET_NT_scanner_init ();
GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
- GST_ats = GNUNET_ATS_scheduling_init (GST_cfg,
- &ats_request_address_change,
- NULL);
+ GST_ats =
+ GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
GST_ats_init ();
GST_manipulation_init ();
GST_plugins_load (&GST_manipulation_recv,
&plugin_env_address_change_notification,
&plugin_env_session_start,
&plugin_env_session_end);
- GST_hello_start (friend_only,
- &process_hello_update,
- NULL);
+ GST_hello_start (friend_only, &process_hello_update, NULL);
GST_neighbours_start ((max_fd / 3) * 2);
- active_stccs = GNUNET_CONTAINER_multipeermap_create (128,
- GNUNET_YES);
+ active_stccs = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
plugin_nc = GNUNET_notification_context_create (0);
GST_validation_start ((max_fd / 3));
}
/**
* Define "main" method using service macro.
*/
-GNUNET_SERVICE_MAIN
-("transport",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_fixed_size (client_start,
- GNUNET_MESSAGE_TYPE_TRANSPORT_START,
- struct StartMessage,
- NULL),
- GNUNET_MQ_hd_var_size (client_hello,
- GNUNET_MESSAGE_TYPE_HELLO,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_var_size (client_send,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
- struct OutboundMessage,
- NULL),
- GNUNET_MQ_hd_var_size (client_address_to_string,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING,
- struct AddressLookupMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_monitor_peers,
- GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST,
- struct PeerMonitorMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_blacklist_init,
- GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_blacklist_reply,
- GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY,
- struct BlacklistMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_set_metric,
- GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC,
- struct TrafficMetricMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_monitor_plugins,
- GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN (
+ "transport",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_fixed_size (client_start,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_START,
+ struct StartMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_hello,
+ GNUNET_MESSAGE_TYPE_HELLO,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_send,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
+ struct OutboundMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_address_to_string,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING,
+ struct AddressLookupMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_monitor_peers,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST,
+ struct PeerMonitorMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_blacklist_init,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_blacklist_reply,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY,
+ struct BlacklistMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_set_metric,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC,
+ struct TrafficMetricMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_monitor_plugins,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_handler_end ());
/* end of file gnunet-service-transport.c */
projects / oweals / gnunet.git / blobdiff