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
95 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_START
97 struct GNUNET_MessageHeader header;
101 * 1: The @e self field should be checked
102 * 2: this client is interested in payload traffic
107 * Identity we think we have. If it does not match, the
108 * receiver should print out an error message and disconnect.
110 struct GNUNET_PeerIdentity self;
115 * Message from the transport service to the library
116 * informing about neighbors.
118 struct ConnectInfoMessage
122 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
124 struct GNUNET_MessageHeader header;
126 #if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
127 defined(GNUNET_TRANSPORT_CORE_VERSION))
130 * Always zero, for alignment.
132 uint32_t reserved GNUNET_PACKED;
137 * Current outbound quota for this peer
139 struct GNUNET_BANDWIDTH_Value32NBO quota_out;
143 * Identity of the new neighbour.
145 struct GNUNET_PeerIdentity id;
150 * Message from the transport service to the library
151 * informing about disconnects.
153 struct DisconnectInfoMessage
157 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
159 struct GNUNET_MessageHeader header;
162 * Reserved, always zero.
164 uint32_t reserved GNUNET_PACKED;
167 * Who got disconnected?
169 struct GNUNET_PeerIdentity peer;
174 * Message used to set a particular bandwidth quota. Sent TO the
175 * service to set an incoming quota, sent FROM the service to update
178 * NOTE: no longer used in TNG!
180 struct QuotaSetMessage
184 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA
186 struct GNUNET_MessageHeader header;
191 struct GNUNET_BANDWIDTH_Value32NBO quota;
194 * About which peer are we talking here?
196 struct GNUNET_PeerIdentity peer;
201 * Message used to notify the transport API about a message
202 * received from the network. The actual message follows.
204 struct InboundMessage
208 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
210 struct GNUNET_MessageHeader header;
213 * Which peer sent the message?
215 struct GNUNET_PeerIdentity peer;
220 * Message used to notify the transport API that it can
221 * send another message to the transport service.
227 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
229 struct GNUNET_MessageHeader header;
231 #if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
232 defined(GNUNET_TRANSPORT_CORE_VERSION))
234 uint32_t reserved GNUNET_PACKED;
239 * #GNUNET_OK if the transmission succeeded,
240 * #GNUNET_SYSERR if it failed (i.e. network disconnect);
241 * in either case, it is now OK for this client to
242 * send us another message for the given peer.
244 uint16_t success GNUNET_PACKED;
247 * Size of message sent
249 uint16_t bytes_msg GNUNET_PACKED;
252 * Size of message sent over wire.
253 * Includes plugin and protocol specific overheads.
255 uint32_t bytes_physical GNUNET_PACKED;
260 * Which peer can send more now?
262 struct GNUNET_PeerIdentity peer;
267 * Message used to notify the transport API that it can
268 * send another message to the transport service.
269 * (Used to implement flow control.)
275 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK
277 struct GNUNET_MessageHeader header;
280 * Number of messages by which to increase the window, greater or
283 uint32_t increase_window_delta GNUNET_PACKED;
286 * Which peer can CORE handle more from now?
288 struct GNUNET_PeerIdentity peer;
293 * Message used to notify the transport service about a message
294 * to be transmitted to another peer. The actual message follows.
296 struct OutboundMessage
300 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
302 struct GNUNET_MessageHeader header;
307 uint32_t reserved GNUNET_PACKED;
309 #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
310 defined(GNUNET_TRANSPORT_CORE_VERSION))
315 struct GNUNET_TIME_RelativeNBO timeout;
319 * Which peer should receive the message?
321 struct GNUNET_PeerIdentity peer;
325 #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
326 defined(GNUNET_TRANSPORT_CORE_VERSION))
330 * Message used to notify the transport API about an address to string
331 * conversion. Message is followed by the string with the humand-readable
332 * address. For each lookup, multiple results may be returned. The
333 * last message must have a @e res of #GNUNET_OK and an @e addr_len
336 struct AddressToStringResultMessage
340 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY
342 struct GNUNET_MessageHeader header;
345 * #GNUNET_OK if the conversion succeeded,
346 * #GNUNET_SYSERR if it failed
348 uint32_t res GNUNET_PACKED;
351 * Length of the following string, zero if @e is #GNUNET_SYSERR
353 uint32_t addr_len GNUNET_PACKED;
358 * Message from the library to the transport service
359 * asking for converting a transport address to a
360 * human-readable UTF-8 string.
362 struct AddressLookupMessage
366 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING
368 struct GNUNET_MessageHeader header;
371 * Should the conversion use numeric IP addresses (otherwise
372 * a reverse DNS lookup is OK -- if applicable).
374 int16_t numeric_only GNUNET_PACKED;
377 * Length of the (binary) address in bytes, in big-endian.
379 uint16_t addrlen GNUNET_PACKED;
382 * timeout to give up (for DNS resolution timeout mostly)
384 struct GNUNET_TIME_RelativeNBO timeout;
386 /* followed by @e addrlen bytes of the actual address, then
387 * followed by the 0-terminated name of the transport */
392 * Message from the transport service to the library containing information
393 * about a peer. Information contained are:
394 * - current address used to communicate with this peer
399 * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
401 struct ValidationIterateResponseMessage
404 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE
406 struct GNUNET_MessageHeader header;
416 struct GNUNET_PeerIdentity peer;
419 * Local info about the address
421 uint32_t local_address_info GNUNET_PACKED;
426 uint32_t addrlen GNUNET_PACKED;
429 * Length of the plugin name
431 uint32_t pluginlen GNUNET_PACKED;
436 uint32_t state GNUNET_PACKED;
439 * At what time did we successfully validate the address last.
440 * Will be NEVER if the address failed validation.
442 struct GNUNET_TIME_AbsoluteNBO last_validation;
445 * Until when is the address believed to be valid.
446 * Will be ZERO if the address is not belived to be valid.
448 struct GNUNET_TIME_AbsoluteNBO valid_until;
451 * When will we next try to validate the address (typically
452 * done before @e valid_until happens).
454 struct GNUNET_TIME_AbsoluteNBO next_validation;
459 * Message from the library to the transport service
460 * asking for binary addresses known for a peer.
462 struct ValidationMonitorMessage
465 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST
467 struct GNUNET_MessageHeader header;
470 * One shot call or continous replies?
472 uint32_t one_shot GNUNET_PACKED;
475 * The identity of the peer to look up.
477 struct GNUNET_PeerIdentity peer;
482 * Message from the library to the transport service
483 * asking for binary addresses known for a peer.
485 struct PeerMonitorMessage
488 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST
490 struct GNUNET_MessageHeader header;
493 * One shot call or continous replies?
495 uint32_t one_shot GNUNET_PACKED;
498 * The identity of the peer to look up.
500 struct GNUNET_PeerIdentity peer;
505 * Message from the library to the transport service
506 * asking for binary addresses known for a peer.
508 struct TrafficMetricMessage
511 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC
513 struct GNUNET_MessageHeader header;
518 uint32_t reserved GNUNET_PACKED;
521 * The identity of the peer to look up.
523 struct GNUNET_PeerIdentity peer;
526 * Fake properties to generate.
528 struct GNUNET_ATS_PropertiesNBO properties;
531 * Fake delay to add on inbound traffic.
533 struct GNUNET_TIME_RelativeNBO delay_in;
536 * Fake delay to add on outbound traffic.
538 struct GNUNET_TIME_RelativeNBO delay_out;
543 * Message from the transport service to the library containing information
544 * about a peer. Information contained are:
545 * - current address used to communicate with this peer
550 * [AddressIterateResponseMessage][address[addrlen]][transportname[pluginlen]]
552 struct PeerIterateResponseMessage
555 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE
557 struct GNUNET_MessageHeader header;
567 struct GNUNET_PeerIdentity peer;
570 * Timeout for the state this peer is in
572 struct GNUNET_TIME_AbsoluteNBO state_timeout;
575 * Local info about the address
577 uint32_t local_address_info GNUNET_PACKED;
580 * State this peer is in as an `enum GNUNET_TRANSPORT_PeerState`
582 uint32_t state GNUNET_PACKED;
587 uint32_t addrlen GNUNET_PACKED;
590 * Length of the plugin name
592 uint32_t pluginlen GNUNET_PACKED;
597 * Change in blacklisting (either request or notification,
598 * depending on which direction it is going).
600 struct BlacklistMessage
604 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY or
605 * #GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY.
607 struct GNUNET_MessageHeader header;
610 * 0 for the query, #GNUNET_OK (allowed) or #GNUNET_SYSERR (disallowed)
613 uint32_t is_allowed GNUNET_PACKED;
616 * Which peer is being blacklisted or queried?
618 struct GNUNET_PeerIdentity peer;
623 * Transport-level connection status update.
625 struct TransportPluginMonitorMessage
629 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT.
631 struct GNUNET_MessageHeader header;
634 * An `enum GNUNET_TRANSPORT_SessionState` in NBO.
636 uint16_t session_state GNUNET_PACKED;
639 * #GNUNET_YES if this is an inbound connection,
640 * #GNUNET_NO if this is an outbound connection,
641 * #GNUNET_SYSERR if connections of this plugin
642 * are so fundamentally bidirectional
643 * that they have no 'initiator'
644 * Value given in NBO.
646 int16_t is_inbound GNUNET_PACKED;
649 * Number of messages waiting transmission.
651 uint32_t msgs_pending GNUNET_PACKED;
654 * Number of bytes waiting for transmission.
656 uint32_t bytes_pending GNUNET_PACKED;
659 * When will this transport plugin session time out?
661 struct GNUNET_TIME_AbsoluteNBO timeout;
664 * Until how long is this plugin currently blocked from reading?
666 struct GNUNET_TIME_AbsoluteNBO delay;
669 * Which peer is this connection for?
671 struct GNUNET_PeerIdentity peer;
674 * Unique identifier for the session.
679 * Length of the plugin name in bytes, including 0-termination.
681 uint16_t plugin_name_len GNUNET_PACKED;
684 * Length of the plugin address in bytes.
686 uint16_t plugin_address_len GNUNET_PACKED;
688 /* followed by 0-terminated plugin name and
689 @e plugin_address_len bytes of plugin address */
694 /* *********************** TNG messages ***************** */
697 * Communicator goes online. Note which addresses it can
700 struct GNUNET_TRANSPORT_CommunicatorAvailableMessage
704 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR.
706 struct GNUNET_MessageHeader header;
709 * NBO encoding of `enum GNUNET_TRANSPORT_CommunicatorCharacteristics`
713 /* Followed by the address prefix of the communicator */
718 * Add address to the list.
720 struct GNUNET_TRANSPORT_AddAddressMessage
724 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS.
726 struct GNUNET_MessageHeader header;
729 * Address identifier (used during deletion).
731 uint32_t aid GNUNET_PACKED;
734 * When does the address expire?
736 struct GNUNET_TIME_RelativeNBO expiration;
739 * An `enum GNUNET_NetworkType` in NBO.
743 /* followed by UTF-8 encoded, 0-terminated human-readable address */
748 * Remove address from the list.
750 struct GNUNET_TRANSPORT_DelAddressMessage
754 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS.
756 struct GNUNET_MessageHeader header;
759 * Address identifier.
761 uint32_t aid GNUNET_PACKED;
766 * Inform transport about an incoming message.
768 struct GNUNET_TRANSPORT_IncomingMessage
772 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG.
774 struct GNUNET_MessageHeader header;
777 * Do we use flow control or not?
779 uint32_t fc_on GNUNET_PACKED;
782 * 64-bit number to identify the matching ACK.
784 uint64_t fc_id GNUNET_PACKED;
787 * How long does the communicator believe the address on which
788 * the message was received to remain valid?
790 struct GNUNET_TIME_RelativeNBO expected_address_validity;
795 struct GNUNET_PeerIdentity sender;
797 /* followed by the message */
802 * Transport informs us about being done with an incoming message.
803 * (only sent if fc_on was set).
805 struct GNUNET_TRANSPORT_IncomingMessageAck
809 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK.
811 struct GNUNET_MessageHeader header;
816 uint32_t reserved GNUNET_PACKED;
819 * Which message is being ACKed?
821 uint64_t fc_id GNUNET_PACKED;
824 * Sender identifier of the original message.
826 struct GNUNET_PeerIdentity sender;
831 * Add queue to the transport
833 struct GNUNET_TRANSPORT_AddQueueMessage
837 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
839 struct GNUNET_MessageHeader header;
842 * Queue identifier (used to identify the queue).
844 uint32_t qid GNUNET_PACKED;
847 * Receiver that can be addressed via the queue.
849 struct GNUNET_PeerIdentity receiver;
852 * An `enum GNUNET_NetworkType` in NBO.
857 * Maximum transmission unit, in NBO. UINT32_MAX for unlimited.
862 * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
866 /* followed by UTF-8 encoded, 0-terminated human-readable address */
871 * Remove queue, it is no longer available.
873 struct GNUNET_TRANSPORT_DelQueueMessage
877 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN.
879 struct GNUNET_MessageHeader header;
882 * Address identifier.
884 uint32_t qid GNUNET_PACKED;
887 * Receiver that can be addressed via the queue.
889 struct GNUNET_PeerIdentity receiver;
894 * Transport tells communicator that it wants a new queue.
896 struct GNUNET_TRANSPORT_CreateQueue
900 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE.
902 struct GNUNET_MessageHeader header;
905 * Unique ID for the request.
907 uint32_t request_id GNUNET_PACKED;
910 * Receiver that can be addressed via the queue.
912 struct GNUNET_PeerIdentity receiver;
914 /* followed by UTF-8 encoded, 0-terminated human-readable address */
919 * Communicator tells transport how queue creation went down.
921 struct GNUNET_TRANSPORT_CreateQueueResponse
925 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK or
926 * #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL.
928 struct GNUNET_MessageHeader header;
931 * Unique ID for the request.
933 uint32_t request_id GNUNET_PACKED;
938 * Inform communicator about transport's desire to send a message.
940 struct GNUNET_TRANSPORT_SendMessageTo
944 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG.
946 struct GNUNET_MessageHeader header;
949 * Which queue should we use?
951 uint32_t qid GNUNET_PACKED;
954 * Message ID, used for flow control.
956 uint64_t mid GNUNET_PACKED;
959 * Receiver identifier.
961 struct GNUNET_PeerIdentity receiver;
963 /* followed by the message */
968 * Inform transport that message was sent.
970 struct GNUNET_TRANSPORT_SendMessageToAck
974 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK.
976 struct GNUNET_MessageHeader header;
979 * Success (#GNUNET_OK), failure (#GNUNET_SYSERR).
981 uint32_t status GNUNET_PACKED;
984 * Message ID of the original message.
986 uint64_t mid GNUNET_PACKED;
989 * Receiver identifier.
991 struct GNUNET_PeerIdentity receiver;
996 * Message from communicator to transport service asking for
997 * transmission of a backchannel message with the given peer @e pid
1000 struct GNUNET_TRANSPORT_CommunicatorBackchannel
1003 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
1005 struct GNUNET_MessageHeader header;
1008 * Always zero, for alignment.
1015 struct GNUNET_PeerIdentity pid;
1017 /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
1018 message to the communicator */
1020 /* Followed by the 0-terminated string specifying the desired
1021 communicator at the target (@e pid) peer */
1026 * Message from transport to communicator passing along a backchannel
1027 * message from the given peer @e pid.
1029 struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming
1033 * #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
1035 struct GNUNET_MessageHeader header;
1038 * Always zero, for alignment.
1045 struct GNUNET_PeerIdentity pid;
1047 /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
1048 message to the communicator */
1053 * Request to start monitoring.
1055 struct GNUNET_TRANSPORT_MonitorStart
1059 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START.
1061 struct GNUNET_MessageHeader header;
1064 * #GNUNET_YES for one-shot montoring, #GNUNET_NO for continuous monitoring.
1069 * Target identifier to monitor, all zeros for "all peers".
1071 struct GNUNET_PeerIdentity peer;
1078 struct GNUNET_TRANSPORT_MonitorData
1082 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA.
1084 struct GNUNET_MessageHeader header;
1087 * Network type (an `enum GNUNET_NetworkType` in NBO).
1089 uint32_t nt GNUNET_PACKED;
1092 * Target identifier.
1094 struct GNUNET_PeerIdentity peer;
1097 * @deprecated To be discussed if we keep these...
1099 struct GNUNET_TIME_AbsoluteNBO last_validation;
1100 struct GNUNET_TIME_AbsoluteNBO valid_until;
1101 struct GNUNET_TIME_AbsoluteNBO next_validation;
1104 * Current round-trip time estimate.
1106 struct GNUNET_TIME_RelativeNBO rtt;
1109 * Connection status (in NBO).
1111 uint32_t cs GNUNET_PACKED;
1114 * Messages pending (in NBO).
1116 uint32_t num_msg_pending GNUNET_PACKED;
1119 * Bytes pending (in NBO).
1121 uint32_t num_bytes_pending GNUNET_PACKED;
1123 /* Followed by 0-terminated address of the peer */
1128 * Request to verify address.
1130 struct GNUNET_TRANSPORT_AddressToVerify
1134 * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY.
1136 struct GNUNET_MessageHeader header;
1144 * Peer the address is from.
1146 struct GNUNET_PeerIdentity peer;
1148 /* followed by variable-size raw address */
1153 * Application client to TRANSPORT service: we would like to have
1154 * address suggestions for this peer.
1156 struct ExpressPreferenceMessage
1159 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST or
1160 * #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL to stop
1163 struct GNUNET_MessageHeader header;
1166 * What type of performance preference does the client have?
1167 * A `enum GNUNET_MQ_PreferenceKind` in NBO.
1169 uint32_t pk GNUNET_PACKED;
1172 * Peer to get address suggestions for.
1174 struct GNUNET_PeerIdentity peer;
1177 * How much bandwidth in bytes/second does the application expect?
1179 struct GNUNET_BANDWIDTH_Value32NBO bw;
1184 * We got an address of another peer, TRANSPORT service
1185 * should validate it. There is no response.
1187 struct RequestHelloValidationMessage
1191 * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION.
1193 struct GNUNET_MessageHeader header;
1196 * What type of network does the other peer claim this is?
1197 * A `enum GNUNET_NetworkType` in NBO.
1199 uint32_t nt GNUNET_PACKED;
1202 * Peer to the address is presumably for.
1204 struct GNUNET_PeerIdentity peer;
1207 * When does the address expire?
1209 struct GNUNET_TIME_AbsoluteNBO expiration;
1211 /* followed by 0-terminated address to validate */
1216 GNUNET_NETWORK_STRUCT_END
1218 /* end of transport.h */