2 This file is part of GNUnet.
3 Copyright (C) 2009-2014 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file transport/transport.h
23 * @brief common internal definitions for transport service
24 * @author Christian Grothoff
29 #include "gnunet_crypto_lib.h"
30 #include "gnunet_time_lib.h"
31 #include "gnunet_constants.h"
33 #define DEBUG_TRANSPORT GNUNET_EXTRA_LOGGING
37 * For how long do we allow unused bandwidth
38 * from the past to carry over into the future? (in seconds)
40 #define MAX_BANDWIDTH_CARRY_S GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY_S
43 * How often do we (at most) do a full quota
44 * recalculation? (in ms)
46 #define MIN_QUOTA_REFRESH_TIME 2000
49 * What's the maximum number of sockets transport uses for validation and
52 #define DEFAULT_MAX_FDS 256
55 * Maximum frequency for re-evaluating latencies for all transport addresses.
57 #define LATENCY_EVALUATION_MAX_DELAY \
58 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
61 * Maximum frequency for re-evaluating latencies for connected addresses.
63 #define CONNECTED_LATENCY_EVALUATION_MAX_DELAY \
64 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
67 * Similiar to GNUNET_TRANSPORT_NotifyDisconnect but in and out quotas are
68 * included here. These values are not required outside transport_api
71 * @param peer the peer that connected
72 * @param bandwidth_in inbound bandwidth in NBO
73 * @param bandwidth_out outbound bandwidth in NBO
76 typedef void (*NotifyConnect) (
78 const struct GNUNET_PeerIdentity *peer,
79 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
80 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out);
83 GNUNET_NETWORK_STRUCT_BEGIN
87 * Message from the transport service to the library
88 * asking to check if both processes agree about this
94 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_START
96 struct GNUNET_MessageHeader header;
100 * 1: The @e self field should be checked
101 * 2: this client is interested in payload traffic
106 * Identity we think we have. If it does not match, the
107 * receiver should print out an error message and disconnect.
109 struct GNUNET_PeerIdentity self;
114 * Message from the transport service to the library
115 * informing about neighbors.
117 struct ConnectInfoMessage
120 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
122 struct GNUNET_MessageHeader header;
124 #if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
125 defined(GNUNET_TRANSPORT_CORE_VERSION))
128 * Always zero, for alignment.
130 uint32_t reserved GNUNET_PACKED;
133 * Current outbound quota for this peer
135 struct GNUNET_BANDWIDTH_Value32NBO quota_out;
139 * Identity of the new neighbour.
141 struct GNUNET_PeerIdentity id;
146 * Message from the transport service to the library
147 * informing about disconnects.
149 struct DisconnectInfoMessage
152 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
154 struct GNUNET_MessageHeader header;
157 * Reserved, always zero.
159 uint32_t reserved GNUNET_PACKED;
162 * Who got disconnected?
164 struct GNUNET_PeerIdentity peer;
169 * Message used to set a particular bandwidth quota. Sent TO the
170 * service to set an incoming quota, sent FROM the service to update
173 * NOTE: no longer used in TNG!
175 struct QuotaSetMessage
178 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA
180 struct GNUNET_MessageHeader header;
185 struct GNUNET_BANDWIDTH_Value32NBO quota;
188 * About which peer are we talking here?
190 struct GNUNET_PeerIdentity peer;
195 * Message used to notify the transport API about a message
196 * received from the network. The actual message follows.
198 struct InboundMessage
201 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
203 struct GNUNET_MessageHeader header;
206 * Which peer sent the message?
208 struct GNUNET_PeerIdentity peer;
213 * Message used to notify the transport API that it can
214 * send another message to the transport service.
219 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
221 struct GNUNET_MessageHeader header;
223 #if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
224 defined(GNUNET_TRANSPORT_CORE_VERSION))
226 uint32_t reserved GNUNET_PACKED;
229 * #GNUNET_OK if the transmission succeeded,
230 * #GNUNET_SYSERR if it failed (i.e. network disconnect);
231 * in either case, it is now OK for this client to
232 * send us another message for the given peer.
234 uint16_t success GNUNET_PACKED;
237 * Size of message sent
239 uint16_t bytes_msg GNUNET_PACKED;
242 * Size of message sent over wire.
243 * Includes plugin and protocol specific overheads.
245 uint32_t bytes_physical GNUNET_PACKED;
249 * Which peer can send more now?
251 struct GNUNET_PeerIdentity peer;
256 * Message used to notify the transport API that it can
257 * send another message to the transport service.
258 * (Used to implement flow control.)
263 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK
265 struct GNUNET_MessageHeader header;
268 * Number of messages by which to increase the window, greater or
271 uint32_t increase_window_delta GNUNET_PACKED;
274 * Which peer can CORE handle more from now?
276 struct GNUNET_PeerIdentity peer;
281 * Message used to notify the transport service about a message
282 * to be transmitted to another peer. The actual message follows.
284 struct OutboundMessage
287 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
289 struct GNUNET_MessageHeader header;
292 * An `enum GNUNET_MQ_PriorityPreferences` in NBO.
294 uint32_t priority GNUNET_PACKED;
296 #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
297 defined(GNUNET_TRANSPORT_CORE_VERSION))
302 struct GNUNET_TIME_RelativeNBO timeout;
306 * Which peer should receive the message?
308 struct GNUNET_PeerIdentity peer;
312 #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
313 defined(GNUNET_TRANSPORT_CORE_VERSION))
317 * Message used to notify the transport API about an address to string
318 * conversion. Message is followed by the string with the humand-readable
319 * address. For each lookup, multiple results may be returned. The
320 * last message must have a @e res of #GNUNET_OK and an @e addr_len
323 struct AddressToStringResultMessage
326 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY
328 struct GNUNET_MessageHeader header;
331 * #GNUNET_OK if the conversion succeeded,
332 * #GNUNET_SYSERR if it failed
334 uint32_t res GNUNET_PACKED;
337 * Length of the following string, zero if @e is #GNUNET_SYSERR
339 uint32_t addr_len GNUNET_PACKED;
344 * Message from the library to the transport service
345 * asking for converting a transport address to a
346 * human-readable UTF-8 string.
348 struct AddressLookupMessage
351 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING
353 struct GNUNET_MessageHeader header;
356 * Should the conversion use numeric IP addresses (otherwise
357 * a reverse DNS lookup is OK -- if applicable).
359 int16_t numeric_only GNUNET_PACKED;
362 * Length of the (binary) address in bytes, in big-endian.
364 uint16_t addrlen GNUNET_PACKED;
367 * timeout to give up (for DNS resolution timeout mostly)
369 struct GNUNET_TIME_RelativeNBO timeout;
371 /* followed by @e addrlen bytes of the actual address, then
372 * followed by the 0-terminated name of the transport */
377 * Message from the transport service to the library containing information
378 * about a peer. Information contained are:
379 * - current address used to communicate with this peer
384 * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
386 struct ValidationIterateResponseMessage
389 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE
391 struct GNUNET_MessageHeader header;
401 struct GNUNET_PeerIdentity peer;
404 * Local info about the address
406 uint32_t local_address_info GNUNET_PACKED;
411 uint32_t addrlen GNUNET_PACKED;
414 * Length of the plugin name
416 uint32_t pluginlen GNUNET_PACKED;
421 uint32_t state GNUNET_PACKED;
424 * At what time did we successfully validate the address last.
425 * Will be NEVER if the address failed validation.
427 struct GNUNET_TIME_AbsoluteNBO last_validation;
430 * Until when is the address believed to be valid.
431 * Will be ZERO if the address is not belived to be valid.
433 struct GNUNET_TIME_AbsoluteNBO valid_until;
436 * When will we next try to validate the address (typically
437 * done before @e valid_until happens).
439 struct GNUNET_TIME_AbsoluteNBO next_validation;
444 * Message from the library to the transport service
445 * asking for binary addresses known for a peer.
447 struct ValidationMonitorMessage
450 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST
452 struct GNUNET_MessageHeader header;
455 * One shot call or continous replies?
457 uint32_t one_shot GNUNET_PACKED;
460 * The identity of the peer to look up.
462 struct GNUNET_PeerIdentity peer;
467 * Message from the library to the transport service
468 * asking for binary addresses known for a peer.
470 struct PeerMonitorMessage
473 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST
475 struct GNUNET_MessageHeader header;
478 * One shot call or continous replies?
480 uint32_t one_shot GNUNET_PACKED;
483 * The identity of the peer to look up.
485 struct GNUNET_PeerIdentity peer;
490 * Message from the library to the transport service
491 * asking for binary addresses known for a peer.
493 struct TrafficMetricMessage
496 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC
498 struct GNUNET_MessageHeader header;
503 uint32_t reserved GNUNET_PACKED;
506 * The identity of the peer to look up.
508 struct GNUNET_PeerIdentity peer;
511 * Fake properties to generate.
513 struct GNUNET_ATS_PropertiesNBO properties;
516 * Fake delay to add on inbound traffic.
518 struct GNUNET_TIME_RelativeNBO delay_in;
521 * Fake delay to add on outbound traffic.
523 struct GNUNET_TIME_RelativeNBO delay_out;
528 * Message from the transport service to the library containing information
529 * about a peer. Information contained are:
530 * - current address used to communicate with this peer
535 * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
537 struct PeerIterateResponseMessage
540 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE
542 struct GNUNET_MessageHeader header;
552 struct GNUNET_PeerIdentity peer;
555 * Timeout for the state this peer is in
557 struct GNUNET_TIME_AbsoluteNBO state_timeout;
560 * Local info about the address
562 uint32_t local_address_info GNUNET_PACKED;
565 * State this peer is in as an `enum GNUNET_TRANSPORT_PeerState`
567 uint32_t state GNUNET_PACKED;
572 uint32_t addrlen GNUNET_PACKED;
575 * Length of the plugin name
577 uint32_t pluginlen GNUNET_PACKED;
582 * Change in blacklisting (either request or notification,
583 * depending on which direction it is going).
585 struct BlacklistMessage
588 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY or
589 * #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY.
591 struct GNUNET_MessageHeader header;
594 * 0 for the query, #GNUNET_OK (allowed) or #GNUNET_SYSERR (disallowed)
597 uint32_t is_allowed GNUNET_PACKED;
600 * Which peer is being blacklisted or queried?
602 struct GNUNET_PeerIdentity peer;
607 * Transport-level connection status update.
609 struct TransportPluginMonitorMessage
612 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT.
614 struct GNUNET_MessageHeader header;
617 * An `enum GNUNET_TRANSPORT_SessionState` in NBO.
619 uint16_t session_state GNUNET_PACKED;
622 * #GNUNET_YES if this is an inbound connection,
623 * #GNUNET_NO if this is an outbound connection,
624 * #GNUNET_SYSERR if connections of this plugin
625 * are so fundamentally bidirectional
626 * that they have no 'initiator'
627 * Value given in NBO.
629 int16_t is_inbound GNUNET_PACKED;
632 * Number of messages waiting transmission.
634 uint32_t msgs_pending GNUNET_PACKED;
637 * Number of bytes waiting for transmission.
639 uint32_t bytes_pending GNUNET_PACKED;
642 * When will this transport plugin session time out?
644 struct GNUNET_TIME_AbsoluteNBO timeout;
647 * Until how long is this plugin currently blocked from reading?
649 struct GNUNET_TIME_AbsoluteNBO delay;
652 * Which peer is this connection for?
654 struct GNUNET_PeerIdentity peer;
657 * Unique identifier for the session.
662 * Length of the plugin name in bytes, including 0-termination.
664 uint16_t plugin_name_len GNUNET_PACKED;
667 * Length of the plugin address in bytes.
669 uint16_t plugin_address_len GNUNET_PACKED;
671 /* followed by 0-terminated plugin name and
672 @e plugin_address_len bytes of plugin address */
677 /* *********************** TNG messages ***************** */
680 * Communicator goes online. Note which addresses it can
683 struct GNUNET_TRANSPORT_CommunicatorAvailableMessage
686 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR.
688 struct GNUNET_MessageHeader header;
691 * NBO encoding of `enum GNUNET_TRANSPORT_CommunicatorCharacteristics`
695 /* Followed by the address prefix of the communicator */
700 * Add address to the list.
702 struct GNUNET_TRANSPORT_AddAddressMessage
705 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS.
707 struct GNUNET_MessageHeader header;
710 * Address identifier (used during deletion).
712 uint32_t aid GNUNET_PACKED;
715 * When does the address expire?
717 struct GNUNET_TIME_RelativeNBO expiration;
720 * An `enum GNUNET_NetworkType` in NBO.
724 /* followed by UTF-8 encoded, 0-terminated human-readable address */
729 * Remove address from the list.
731 struct GNUNET_TRANSPORT_DelAddressMessage
734 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS.
736 struct GNUNET_MessageHeader header;
739 * Address identifier.
741 uint32_t aid GNUNET_PACKED;
746 * Inform transport about an incoming message.
748 struct GNUNET_TRANSPORT_IncomingMessage
751 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG.
753 struct GNUNET_MessageHeader header;
756 * Do we use flow control or not?
758 uint32_t fc_on GNUNET_PACKED;
761 * 64-bit number to identify the matching ACK.
763 uint64_t fc_id GNUNET_PACKED;
766 * How long does the communicator believe the address on which
767 * the message was received to remain valid?
769 struct GNUNET_TIME_RelativeNBO expected_address_validity;
774 struct GNUNET_PeerIdentity sender;
776 /* followed by the message */
781 * Transport informs us about being done with an incoming message.
782 * (only sent if fc_on was set).
784 struct GNUNET_TRANSPORT_IncomingMessageAck
787 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK.
789 struct GNUNET_MessageHeader header;
794 uint32_t reserved GNUNET_PACKED;
797 * Which message is being ACKed?
799 uint64_t fc_id GNUNET_PACKED;
802 * Sender identifier of the original message.
804 struct GNUNET_PeerIdentity sender;
809 * Add queue to the transport
811 struct GNUNET_TRANSPORT_AddQueueMessage
814 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
816 struct GNUNET_MessageHeader header;
819 * Queue identifier (used to identify the queue).
821 uint32_t qid GNUNET_PACKED;
824 * Receiver that can be addressed via the queue.
826 struct GNUNET_PeerIdentity receiver;
829 * An `enum GNUNET_NetworkType` in NBO.
834 * Maximum transmission unit, in NBO. UINT32_MAX for unlimited.
839 * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
843 /* followed by UTF-8 encoded, 0-terminated human-readable address */
848 * Remove queue, it is no longer available.
850 struct GNUNET_TRANSPORT_DelQueueMessage
853 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN.
855 struct GNUNET_MessageHeader header;
858 * Address identifier.
860 uint32_t qid GNUNET_PACKED;
863 * Receiver that can be addressed via the queue.
865 struct GNUNET_PeerIdentity receiver;
870 * Transport tells communicator that it wants a new queue.
872 struct GNUNET_TRANSPORT_CreateQueue
875 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE.
877 struct GNUNET_MessageHeader header;
880 * Unique ID for the request.
882 uint32_t request_id GNUNET_PACKED;
885 * Receiver that can be addressed via the queue.
887 struct GNUNET_PeerIdentity receiver;
889 /* followed by UTF-8 encoded, 0-terminated human-readable address */
894 * Communicator tells transport how queue creation went down.
896 struct GNUNET_TRANSPORT_CreateQueueResponse
899 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK or
900 * #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL.
902 struct GNUNET_MessageHeader header;
905 * Unique ID for the request.
907 uint32_t request_id GNUNET_PACKED;
912 * Inform communicator about transport's desire to send a message.
914 struct GNUNET_TRANSPORT_SendMessageTo
917 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG.
919 struct GNUNET_MessageHeader header;
922 * Which queue should we use?
924 uint32_t qid GNUNET_PACKED;
927 * Message ID, used for flow control.
929 uint64_t mid GNUNET_PACKED;
932 * Receiver identifier.
934 struct GNUNET_PeerIdentity receiver;
936 /* followed by the message */
941 * Inform transport that message was sent.
943 struct GNUNET_TRANSPORT_SendMessageToAck
946 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK.
948 struct GNUNET_MessageHeader header;
951 * Success (#GNUNET_OK), failure (#GNUNET_SYSERR).
953 uint32_t status GNUNET_PACKED;
956 * Message ID of the original message.
958 uint64_t mid GNUNET_PACKED;
961 * Receiver identifier.
963 struct GNUNET_PeerIdentity receiver;
968 * Message from communicator to transport service asking for
969 * transmission of a backchannel message with the given peer @e pid
972 struct GNUNET_TRANSPORT_CommunicatorBackchannel
975 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
977 struct GNUNET_MessageHeader header;
980 * Always zero, for alignment.
987 struct GNUNET_PeerIdentity pid;
989 /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
990 message to the communicator */
992 /* Followed by the 0-terminated string specifying the desired
993 communicator at the target (@e pid) peer */
998 * Message from transport to communicator passing along a backchannel
999 * message from the given peer @e pid.
1001 struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming
1005 * #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
1007 struct GNUNET_MessageHeader header;
1010 * Always zero, for alignment.
1017 struct GNUNET_PeerIdentity pid;
1019 /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
1020 message to the communicator */
1025 * Request to start monitoring.
1027 struct GNUNET_TRANSPORT_MonitorStart
1030 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START.
1032 struct GNUNET_MessageHeader header;
1035 * #GNUNET_YES for one-shot montoring, #GNUNET_NO for continuous monitoring.
1040 * Target identifier to monitor, all zeros for "all peers".
1042 struct GNUNET_PeerIdentity peer;
1049 struct GNUNET_TRANSPORT_MonitorData
1052 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA.
1054 struct GNUNET_MessageHeader header;
1057 * Network type (an `enum GNUNET_NetworkType` in NBO).
1059 uint32_t nt GNUNET_PACKED;
1062 * Target identifier.
1064 struct GNUNET_PeerIdentity peer;
1067 * @deprecated To be discussed if we keep these...
1069 struct GNUNET_TIME_AbsoluteNBO last_validation;
1070 struct GNUNET_TIME_AbsoluteNBO valid_until;
1071 struct GNUNET_TIME_AbsoluteNBO next_validation;
1074 * Current round-trip time estimate.
1076 struct GNUNET_TIME_RelativeNBO rtt;
1079 * Connection status (in NBO).
1081 uint32_t cs GNUNET_PACKED;
1084 * Messages pending (in NBO).
1086 uint32_t num_msg_pending GNUNET_PACKED;
1089 * Bytes pending (in NBO).
1091 uint32_t num_bytes_pending GNUNET_PACKED;
1093 /* Followed by 0-terminated address of the peer */
1098 * Request to verify address.
1100 struct GNUNET_TRANSPORT_AddressToVerify
1103 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY.
1105 struct GNUNET_MessageHeader header;
1113 * Peer the address is from.
1115 struct GNUNET_PeerIdentity peer;
1117 /* followed by variable-size raw address */
1122 * Application client to TRANSPORT service: we would like to have
1123 * address suggestions for this peer.
1125 struct ExpressPreferenceMessage
1128 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST or
1129 * #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL to stop
1132 struct GNUNET_MessageHeader header;
1135 * What type of performance preference does the client have?
1136 * A `enum GNUNET_MQ_PreferenceKind` in NBO.
1138 uint32_t pk GNUNET_PACKED;
1141 * Peer to get address suggestions for.
1143 struct GNUNET_PeerIdentity peer;
1146 * How much bandwidth in bytes/second does the application expect?
1148 struct GNUNET_BANDWIDTH_Value32NBO bw;
1153 * We got an address of another peer, TRANSPORT service
1154 * should validate it. There is no response.
1156 struct RequestHelloValidationMessage
1159 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION.
1161 struct GNUNET_MessageHeader header;
1164 * What type of network does the other peer claim this is?
1165 * A `enum GNUNET_NetworkType` in NBO.
1167 uint32_t nt GNUNET_PACKED;
1170 * Peer to the address is presumably for.
1172 struct GNUNET_PeerIdentity peer;
1174 /* followed by 0-terminated address to validate */
1179 GNUNET_NETWORK_STRUCT_END
1181 /* end of transport.h */