/*
This file is part of GNUnet.
- (C) 2009 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2014 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.
+ 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, 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
*/
/**
#include "gnunet_crypto_lib.h"
#include "gnunet_time_lib.h"
-#include "gnunet_transport_service.h"
#include "gnunet_constants.h"
#define DEBUG_TRANSPORT GNUNET_EXTRA_LOGGING
-#define DEBUG_TRANSPORT_TIMEOUT GNUNET_EXTRA_LOGGING
-
-#define DEBUG_TRANSPORT_DISCONNECT GNUNET_EXTRA_LOGGING
-
-#define DEBUG_TRANSPORT_API GNUNET_EXTRA_LOGGING
/**
* For how long do we allow unused bandwidth
* from the past to carry over into the future? (in seconds)
*/
-#define MAX_BANDWIDTH_CARRY_S GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY
+#define MAX_BANDWIDTH_CARRY_S GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY_S
/**
* How often do we (at most) do a full quota
*/
#define MIN_QUOTA_REFRESH_TIME 2000
+/**
+ * What's the maximum number of sockets transport uses for validation and
+ * neighbors
+ */
+#define DEFAULT_MAX_FDS 256
+
/**
* Maximum frequency for re-evaluating latencies for all transport addresses.
*/
*/
#define CONNECTED_LATENCY_EVALUATION_MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
+/**
+ * Similiar to GNUNET_TRANSPORT_NotifyDisconnect but in and out quotas are
+ * included here. These values are not required outside transport_api
+ *
+ * @param cls closure
+ * @param peer the peer that connected
+ * @param bandwidth_in inbound bandwidth in NBO
+ * @param bandwidth_out outbound bandwidth in NBO
+ *
+ */
+typedef void
+(*NotifyConnect) (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out);
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
/**
* Message from the transport service to the library
* asking to check if both processes agree about this
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_START
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_START
*/
struct GNUNET_MessageHeader header;
/**
- * Should the 'self' field be checked?
+ * 0: no options
+ * 1: The @e self field should be checked
+ * 2: this client is interested in payload traffic
*/
- uint32_t do_check;
+ uint32_t options;
/**
* Identity we think we have. If it does not match, the
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
*/
struct GNUNET_MessageHeader header;
/**
- * Number of ATS key-value pairs that follow this struct
- * (excluding the 0-terminator).
+ * Current outbound quota for this peer
*/
- uint32_t ats_count GNUNET_PACKED;
+ struct GNUNET_BANDWIDTH_Value32NBO quota_out;
/**
* Identity of the new neighbour.
*/
struct GNUNET_PeerIdentity id;
-
- /**
- * First of the ATS information blocks (we must have at least
- * one due to the 0-termination requirement).
- */
- struct GNUNET_ATS_Information ats;
};
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
*/
struct GNUNET_MessageHeader header;
};
-/**
- * Message type for sending a request connect message
- * to the transport service. Must be done before transport
- * api will allow messages to be queued/sent to transport
- * service for transmission to a peer.
- */
-struct TransportRequestConnectMessage
-{
- /**
- * Message header
- */
- struct GNUNET_MessageHeader header;
-
- /**
- * For alignment.
- */
- uint32_t reserved;
-
- /**
- * Identity of the peer we would like to connect to.
- */
- struct GNUNET_PeerIdentity peer;
-};
/**
* Message used to set a particular bandwidth quota. Sent TO the
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_NEIGHBOUR_INFO
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA
*/
struct GNUNET_MessageHeader header;
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
*/
struct GNUNET_MessageHeader header;
- /**
- * Number of ATS key-value pairs that follow this struct
- * (excluding the 0-terminator).
- */
- uint32_t ats_count GNUNET_PACKED;
-
/**
* Which peer sent the message?
*/
struct GNUNET_PeerIdentity peer;
- /**
- * First of the ATS information blocks (we must have at least
- * one due to the 0-termination requirement).
- */
- struct GNUNET_ATS_Information ats;
};
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
*/
struct GNUNET_MessageHeader header;
/**
- * GNUNET_OK if the transmission succeeded,
- * GNUNET_SYSERR if it failed (i.e. network disconnect);
+ * #GNUNET_OK if the transmission succeeded,
+ * #GNUNET_SYSERR if it failed (i.e. network disconnect);
* in either case, it is now OK for this client to
* send us another message for the given peer.
*/
- uint32_t success GNUNET_PACKED;
+ uint16_t success GNUNET_PACKED;
/**
- * Latency estimate.
+ * Size of message sent
*/
- struct GNUNET_TIME_RelativeNBO latency;
+ uint16_t bytes_msg GNUNET_PACKED;
+
+ /**
+ * Size of message sent over wire
+ * Includes plugin and protocol specific overhead
+ */
+ uint32_t bytes_physical GNUNET_PACKED;
/**
* Which peer can send more now?
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
*/
struct GNUNET_MessageHeader header;
/**
- * Message priority.
+ * Always zero.
*/
- uint32_t priority GNUNET_PACKED;
+ uint32_t reserved GNUNET_PACKED;
/**
* Allowed delay.
};
+
+
+#if !(defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION)||defined(GNUNET_TRANSPORT_CORE_VERSION))
+
+
+/**
+ * Message used to notify the transport API about an address to string
+ * conversion. Message is followed by the string with the humand-readable
+ * address. For each lookup, multiple results may be returned. The
+ * last message must have a @e res of #GNUNET_OK and an @e addr_len
+ * of zero.
+ */
+struct AddressToStringResultMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * #GNUNET_OK if the conversion succeeded,
+ * #GNUNET_SYSERR if it failed
+ */
+ uint32_t res GNUNET_PACKED;
+
+ /**
+ * Length of the following string, zero if @e is #GNUNET_SYSERR
+ */
+ uint32_t addr_len GNUNET_PACKED;
+};
+
+
/**
* Message from the library to the transport service
* asking for converting a transport address to a
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING
*/
struct GNUNET_MessageHeader header;
* Should the conversion use numeric IP addresses (otherwise
* a reverse DNS lookup is OK -- if applicable).
*/
- int32_t numeric_only GNUNET_PACKED;
+ int16_t numeric_only GNUNET_PACKED;
/**
- * timeout to give up.
+ * Length of the (binary) address in bytes, in big-endian.
*/
- struct GNUNET_TIME_RelativeNBO timeout;
+ uint16_t addrlen GNUNET_PACKED;
/**
- * Length of the (binary) address in bytes, in big-endian.
+ * timeout to give up (for DNS resolution timeout mostly)
*/
- uint32_t addrlen GNUNET_PACKED;
+ struct GNUNET_TIME_RelativeNBO timeout;
- /* followed by 'addrlen' bytes of the actual address, then
+ /* followed by @e addrlen bytes of the actual address, then
* followed by the 0-terminated name of the transport */
};
/**
- * Message from the library to the transport service
- * asking for human readable addresses known for a peer.
+ * Message from the transport service to the library containing information
+ * about a peer. Information contained are:
+ * - current address used to communicate with this peer
+ * - state
+ * - state timeout
+ *
+ * Memory layout:
+ * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
*/
-struct PeerAddressLookupMessage
+struct ValidationIterateResponseMessage
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PEER_ADDRESS_LOOKUP
+ * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE
*/
struct GNUNET_MessageHeader header;
uint32_t reserved;
/**
- * timeout to give up. FIXME: remove in the future.
+ * Peer identity
*/
- struct GNUNET_TIME_RelativeNBO timeout;
+ struct GNUNET_PeerIdentity peer;
+
+ /**
+ * Local info about the address
+ */
+ uint32_t local_address_info GNUNET_PACKED;
+
+ /**
+ * Address length
+ */
+ uint32_t addrlen GNUNET_PACKED;
+
+ /**
+ * Length of the plugin name
+ */
+ uint32_t pluginlen GNUNET_PACKED;
+
+ /**
+ * State
+ */
+ uint32_t state GNUNET_PACKED;
+
+ /**
+ * At what time did we successfully validate the address last.
+ * Will be NEVER if the address failed validation.
+ */
+ struct GNUNET_TIME_AbsoluteNBO last_validation;
+
+ /**
+ * Until when is the address believed to be valid.
+ * Will be ZERO if the address is not belived to be valid.
+ */
+ struct GNUNET_TIME_AbsoluteNBO valid_until;
+
+ /**
+ * When will we next try to validate the address (typically
+ * done before @e valid_until happens).
+ */
+ struct GNUNET_TIME_AbsoluteNBO next_validation;
+};
+
+
+/**
+ * Message from the library to the transport service
+ * asking for binary addresses known for a peer.
+ */
+struct ValidationMonitorMessage
+{
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * One shot call or continous replies?
+ */
+ uint32_t one_shot GNUNET_PACKED;
/**
* The identity of the peer to look up.
*/
struct GNUNET_PeerIdentity peer;
+
};
* Message from the library to the transport service
* asking for binary addresses known for a peer.
*/
-struct AddressIterateMessage
+struct PeerMonitorMessage
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST
*/
struct GNUNET_MessageHeader header;
/**
- * For alignment.
+ * One shot call or continous replies?
*/
- uint32_t reserved;
+ uint32_t one_shot GNUNET_PACKED;
/**
- * timeout to give up. FIXME: remove in the future
+ * The identity of the peer to look up.
*/
- struct GNUNET_TIME_AbsoluteNBO timeout;
+ struct GNUNET_PeerIdentity peer;
+
};
+
/**
* Message from the library to the transport service
- * asking for human readable addresses known for a peer.
+ * asking for binary addresses known for a peer.
*/
-struct AddressIterateResponseMessage
+struct TrafficMetricMessage
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Always zero.
+ */
+ uint32_t reserved GNUNET_PACKED;
+
+ /**
+ * The identity of the peer to look up.
+ */
+ struct GNUNET_PeerIdentity peer;
+
+ /**
+ * Fake properties to generate.
+ */
+ struct GNUNET_ATS_PropertiesNBO properties;
+
+ /**
+ * Fake delay to add on inbound traffic.
+ */
+ struct GNUNET_TIME_RelativeNBO delay_in;
+
+ /**
+ * Fake delay to add on outbound traffic.
+ */
+ struct GNUNET_TIME_RelativeNBO delay_out;
+};
+
+
+/**
+ * Message from the transport service to the library containing information
+ * about a peer. Information contained are:
+ * - current address used to communicate with this peer
+ * - state
+ * - state timeout
+ *
+ * Memory layout:
+ * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
+ */
+struct PeerIterateResponseMessage
+{
+ /**
+ * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE
*/
struct GNUNET_MessageHeader header;
struct GNUNET_PeerIdentity peer;
/**
- * address length
+ * Timeout for the state this peer is in
+ */
+ struct GNUNET_TIME_AbsoluteNBO state_timeout;
+
+ /**
+ * Local info about the address
+ */
+ uint32_t local_address_info GNUNET_PACKED;
+
+ /**
+ * State this peer is in as an `enum GNUNET_TRANSPORT_PeerState`
+ */
+ uint32_t state GNUNET_PACKED;
+
+ /**
+ * Address length
*/
uint32_t addrlen GNUNET_PACKED;
/**
- * length of the plugin name
+ * Length of the plugin name
*/
uint32_t pluginlen GNUNET_PACKED;
+
};
{
/**
- * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY or
- * GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY.
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY or
+ * #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY.
*/
struct GNUNET_MessageHeader header;
/**
- * 0 for the query, GNUNET_OK (allowed) or GNUNET_SYSERR (disallowed)
+ * 0 for the query, #GNUNET_OK (allowed) or #GNUNET_SYSERR (disallowed)
* for the response.
*/
uint32_t is_allowed GNUNET_PACKED;
};
+/**
+ * Transport-level connection status update.
+ */
+struct TransportPluginMonitorMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * An `enum GNUNET_TRANSPORT_SessionState` in NBO.
+ */
+ uint16_t session_state GNUNET_PACKED;
+
+ /**
+ * #GNUNET_YES if this is an inbound connection,
+ * #GNUNET_NO if this is an outbound connection,
+ * #GNUNET_SYSERR if connections of this plugin
+ * are so fundamentally bidirectional
+ * that they have no 'initiator'
+ * Value given in NBO.
+ */
+ int16_t is_inbound GNUNET_PACKED;
+
+ /**
+ * Number of messages waiting transmission.
+ */
+ uint32_t msgs_pending GNUNET_PACKED;
+
+ /**
+ * Number of bytes waiting for transmission.
+ */
+ uint32_t bytes_pending GNUNET_PACKED;
+
+ /**
+ * When will this transport plugin session time out?
+ */
+ struct GNUNET_TIME_AbsoluteNBO timeout;
+
+ /**
+ * Until how long is this plugin currently blocked from reading?
+ */
+ struct GNUNET_TIME_AbsoluteNBO delay;
+
+ /**
+ * Which peer is this connection for?
+ */
+ struct GNUNET_PeerIdentity peer;
+
+ /**
+ * Unique identifier for the session.
+ */
+ uint64_t session_id;
+
+ /**
+ * Length of the plugin name in bytes, including 0-termination.
+ */
+ uint16_t plugin_name_len GNUNET_PACKED;
+
+ /**
+ * Length of the plugin address in bytes.
+ */
+ uint16_t plugin_address_len GNUNET_PACKED;
+
+ /* followed by 0-terminated plugin name and
+ @e plugin_address_len bytes of plugin address */
+
+};
+
+#else
+
+/* *********************** TNG messages ***************** */
+
+/**
+ * Communicator goes online. Note which addresses it can
+ * work with.
+ */
+struct GNUNET_TRANSPORT_CommunicatorAvailableMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * NBO encoding of `enum GNUNET_TRANSPORT_CommunicatorCharacteristics`
+ */
+ uint32_t cc;
+
+ /* Followed by the address prefix of the communicator */
+};
+
+
+/**
+ * Add address to the list.
+ */
+struct GNUNET_TRANSPORT_AddAddressMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Address identifier (used during deletion).
+ */
+ uint32_t aid GNUNET_PACKED;
+
+ /**
+ * When does the address expire?
+ */
+ struct GNUNET_TIME_RelativeNBO expiration;
+
+ /**
+ * An `enum GNUNET_NetworkType` in NBO.
+ */
+ uint32_t nt;
+
+ /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Remove address from the list.
+ */
+struct GNUNET_TRANSPORT_DelAddressMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Address identifier.
+ */
+ uint32_t aid GNUNET_PACKED;
+
+};
+
+
+/**
+ * Inform transport about an incoming message.
+ */
+struct GNUNET_TRANSPORT_IncomingMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Do we use flow control or not?
+ */
+ uint32_t fc_on GNUNET_PACKED;
+
+ /**
+ * 64-bit number to identify the matching ACK.
+ */
+ uint64_t fc_id GNUNET_PACKED;
+
+ /**
+ * Sender identifier.
+ */
+ struct GNUNET_PeerIdentity sender;
+
+ /* followed by the message */
+};
+
+
+/**
+ * Transport informs us about being done with an incoming message.
+ * (only sent if fc_on was set).
+ */
+struct GNUNET_TRANSPORT_IncomingMessageAck
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Reserved (0)
+ */
+ uint32_t reserved GNUNET_PACKED;
+
+ /**
+ * Which message is being ACKed?
+ */
+ uint64_t fc_id GNUNET_PACKED;
+
+ /**
+ * Sender identifier of the original message.
+ */
+ struct GNUNET_PeerIdentity sender;
+
+};
+
+
+/**
+ * Add queue to the transport
+ */
+struct GNUNET_TRANSPORT_AddQueueMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Queue identifier (used to identify the queue).
+ */
+ uint32_t qid GNUNET_PACKED;
+
+ /**
+ * Receiver that can be addressed via the queue.
+ */
+ struct GNUNET_PeerIdentity receiver;
+
+ /**
+ * An `enum GNUNET_NetworkType` in NBO.
+ */
+ uint32_t nt;
+
+ /**
+ * Maximum transmission unit, in NBO. UINT32_MAX for unlimited.
+ */
+ uint32_t mtu;
+
+ /**
+ * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
+ */
+ uint32_t cs;
+
+ /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Remove queue, it is no longer available.
+ */
+struct GNUNET_TRANSPORT_DelQueueMessage
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Address identifier.
+ */
+ uint32_t qid GNUNET_PACKED;
+
+ /**
+ * Receiver that can be addressed via the queue.
+ */
+ struct GNUNET_PeerIdentity receiver;
+
+};
+
+
+/**
+ * Transport tells communicator that it wants a new queue.
+ */
+struct GNUNET_TRANSPORT_CreateQueue
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Unique ID for the request.
+ */
+ uint32_t request_id GNUNET_PACKED;
+
+ /**
+ * Receiver that can be addressed via the queue.
+ */
+ struct GNUNET_PeerIdentity receiver;
+
+ /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Communicator tells transport how queue creation went down.
+ */
+struct GNUNET_TRANSPORT_CreateQueueResponse
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK or #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Unique ID for the request.
+ */
+ uint32_t request_id GNUNET_PACKED;
+};
+
+
+/**
+ * Inform communicator about transport's desire to send a message.
+ */
+struct GNUNET_TRANSPORT_SendMessageTo
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Which queue should we use?
+ */
+ uint32_t qid GNUNET_PACKED;
+
+ /**
+ * Message ID, used for flow control.
+ */
+ uint64_t mid GNUNET_PACKED;
+
+ /**
+ * Receiver identifier.
+ */
+ struct GNUNET_PeerIdentity receiver;
+
+ /* followed by the message */
+};
+
+
+/**
+ * Inform transport that message was sent.
+ */
+struct GNUNET_TRANSPORT_SendMessageToAck
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Success (#GNUNET_OK), failure (#GNUNET_SYSERR).
+ */
+ uint32_t status GNUNET_PACKED;
+
+ /**
+ * Message ID of the original message.
+ */
+ uint64_t mid GNUNET_PACKED;
+
+ /**
+ * Receiver identifier.
+ */
+ struct GNUNET_PeerIdentity receiver;
+
+};
+
+
+/**
+ * Message from communicator to transport service asking for
+ * transmission of a backchannel message with the given peer @e pid
+ * and communicator.
+ */
+struct GNUNET_TRANSPORT_CommunicatorBackchannel
+{
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Always zero, for alignment.
+ */
+ uint32_t reserved;
+
+ /**
+ * Target peer.
+ */
+ struct GNUNET_PeerIdentity pid;
+
+ /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
+ message to the communicator */
+
+ /* Followed by the 0-terminated string specifying the desired
+ communicator at the target (@e pid) peer */
+};
+
+
+/**
+ * Message from transport to communicator passing along a backchannel
+ * message from the given peer @e pid.
+ */
+struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming
+{
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Always zero, for alignment.
+ */
+ uint32_t reserved;
+
+ /**
+ * Origin peer.
+ */
+ struct GNUNET_PeerIdentity pid;
+
+ /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
+ message to the communicator */
+
+};
+
+
+
+/**
+ * Request to start monitoring.
+ */
+struct GNUNET_TRANSPORT_MonitorStart
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * #GNUNET_YES for one-shot montoring, #GNUNET_NO for continuous monitoring.
+ */
+ uint32_t one_shot;
+
+ /**
+ * Target identifier to monitor, all zeros for "all peers".
+ */
+ struct GNUNET_PeerIdentity peer;
+
+};
+
+
+/**
+ * Monitoring data.
+ */
+struct GNUNET_TRANSPORT_MonitorData
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Network type (an `enum GNUNET_NetworkType` in NBO).
+ */
+ uint32_t nt GNUNET_PACKED;
+
+ /**
+ * Target identifier.
+ */
+ struct GNUNET_PeerIdentity peer;
+
+ /**
+ * @deprecated To be discussed if we keep these...
+ */
+ struct GNUNET_TIME_AbsoluteNBO last_validation;
+ struct GNUNET_TIME_AbsoluteNBO valid_until;
+ struct GNUNET_TIME_AbsoluteNBO next_validation;
+
+ /**
+ * Current round-trip time estimate.
+ */
+ struct GNUNET_TIME_RelativeNBO rtt;
+
+ /**
+ * Connection status (in NBO).
+ */
+ uint32_t cs GNUNET_PACKED;
+
+ /**
+ * Messages pending (in NBO).
+ */
+ uint32_t num_msg_pending GNUNET_PACKED;
+
+ /**
+ * Bytes pending (in NBO).
+ */
+ uint32_t num_bytes_pending GNUNET_PACKED;
+
+ /* Followed by 0-terminated address of the peer */
+
+};
+
+
+/**
+ * Request to verify address.
+ */
+struct GNUNET_TRANSPORT_AddressToVerify
+{
+
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY.
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Reserved. 0.
+ */
+ uint32_t reserved;
+
+ /**
+ * Peer the address is from.
+ */
+ struct GNUNET_PeerIdentity peer;
+
+ /* followed by variable-size raw address */
+};
+
+
+#endif
+
+GNUNET_NETWORK_STRUCT_END
+
/* end of transport.h */
#endif
projects / oweals / gnunet.git / blobdiff