[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated (6fc8b0b7f -> f308b735e)
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated (6fc8b0b7f -> f308b735e) |
|
Date: |
Thu, 18 Apr 2019 18:44:20 +0200 |
This is an automated email from the git hooks/post-receive script.
grothoff pushed a change to branch master
in repository gnunet.
from 6fc8b0b7f Merge branch 'master' of gnunet.org:gnunet
new 54682762c fix #5688 packed warnings
new 6ea190f42 add clang-format to emacs configuration (still requires
clang-format to be installed globally first)
new 03da5328a apply clang format to gnunet-service-tng.c
new f308b735e implement route_via_neighbour()
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.dir-locals.el | 3 +
.gitignore | 1 +
bootstrap | 3 +
src/include/gnunet_tun_lib.h | 174 +--
src/transport/gnunet-service-tng.c | 2172 ++++++++++++++++--------------------
5 files changed, 1054 insertions(+), 1299 deletions(-)
diff --git a/.dir-locals.el b/.dir-locals.el
index 687863811..29999b944 100644
--- a/.dir-locals.el
+++ b/.dir-locals.el
@@ -1,5 +1,8 @@
;; Per-directory local variables for GNU Emacs 23 and later.
+((c-mode
+ (eval add-hook 'before-save-hook #'clang-format-buffer nil t)))
+
((nil
. ((fill-column . 78)
(tab-width . 4)
diff --git a/.gitignore b/.gitignore
index 31cfa5897..e898f41f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@
*.swp
*.trs
*.kdev4
+.clang-format
.deps/
.libs/
.svn/
diff --git a/bootstrap b/bootstrap
index 9d9d97b1d..c87f375ea 100755
--- a/bootstrap
+++ b/bootstrap
@@ -3,6 +3,9 @@
echo "Removing folder 'libltdl'..."
rm -rf libltdl
+# Install clang format symlink (if possible)
+ln -s contrib/conf/editors/clang-format .clang-format &> /dev/null
+
echo "checking for libtoolize / libtool... "
# This is more portable than `which' but comes with
diff --git a/src/include/gnunet_tun_lib.h b/src/include/gnunet_tun_lib.h
index 11c43e8b7..c01e641c1 100644
--- a/src/include/gnunet_tun_lib.h
+++ b/src/include/gnunet_tun_lib.h
@@ -11,7 +11,7 @@
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 Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -23,10 +23,12 @@
* @author Christian Grothoff
*
* @file
- * Standard TCP/IP network structs and IP checksum calculations for TUN
interaction
+ * Standard TCP/IP network structs and IP checksum calculations for TUN
+ * interaction
*
* @defgroup tun TUN library
- * Standard TCP/IP network structs and IP checksum calculations for TUN
interaction
+ * Standard TCP/IP network structs and IP checksum calculations for TUN
+ * interaction
* @{
*/
#ifndef GNUNET_TUN_LIB_H
@@ -96,13 +98,13 @@ struct GNUNET_TUN_Layer2PacketHeader
struct GNUNET_TUN_IPv4Header
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
- unsigned int header_length:4 GNUNET_PACKED;
- unsigned int version:4 GNUNET_PACKED;
+ unsigned int header_length : 4 GNUNET_PACKED;
+ unsigned int version : 4 GNUNET_PACKED;
#elif __BYTE_ORDER == __BIG_ENDIAN
- unsigned int version:4 GNUNET_PACKED;
- unsigned int header_length:4 GNUNET_PACKED;
+ unsigned int version : 4 GNUNET_PACKED;
+ unsigned int header_length : 4 GNUNET_PACKED;
#else
- #error byteorder undefined
+#error byteorder undefined
#endif
uint8_t diff_serv;
@@ -116,9 +118,9 @@ struct GNUNET_TUN_IPv4Header
*/
uint16_t identification GNUNET_PACKED;
- unsigned int flags:3 GNUNET_PACKED;
+ unsigned int flags : 3 GNUNET_PACKED;
- unsigned int fragmentation_offset:13 GNUNET_PACKED;
+ unsigned int fragmentation_offset : 13 GNUNET_PACKED;
/**
* How many more hops can this packet be forwarded?
@@ -138,12 +140,12 @@ struct GNUNET_TUN_IPv4Header
/**
* Origin of the packet.
*/
- struct in_addr source_address GNUNET_PACKED;
+ struct in_addr source_address;
/**
* Destination of the packet.
*/
- struct in_addr destination_address GNUNET_PACKED;
+ struct in_addr destination_address;
} GNUNET_GCC_STRUCT_LAYOUT;
@@ -153,16 +155,16 @@ struct GNUNET_TUN_IPv4Header
struct GNUNET_TUN_IPv6Header
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
- unsigned int traffic_class_h:4 GNUNET_PACKED;
- unsigned int version:4 GNUNET_PACKED;
- unsigned int traffic_class_l:4 GNUNET_PACKED;
- unsigned int flow_label:20 GNUNET_PACKED;
+ unsigned int traffic_class_h : 4 GNUNET_PACKED;
+ unsigned int version : 4 GNUNET_PACKED;
+ unsigned int traffic_class_l : 4 GNUNET_PACKED;
+ unsigned int flow_label : 20 GNUNET_PACKED;
#elif __BYTE_ORDER == __BIG_ENDIAN
- unsigned int version:4 GNUNET_PACKED;
- unsigned int traffic_class:8 GNUNET_PACKED;
- unsigned int flow_label:20 GNUNET_PACKED;
+ unsigned int version : 4 GNUNET_PACKED;
+ unsigned int traffic_class : 8 GNUNET_PACKED;
+ unsigned int flow_label : 20 GNUNET_PACKED;
#else
- #error byteorder undefined
+#error byteorder undefined
#endif
/**
* Length of the payload, excluding this header.
@@ -246,7 +248,7 @@ struct GNUNET_TUN_TcpHeader
*/
unsigned int reserved : 4 GNUNET_PACKED;
#else
- #error byteorder undefined
+#error byteorder undefined
#endif
/**
@@ -298,7 +300,6 @@ struct GNUNET_TUN_UdpHeader
};
-
/**
* A few common DNS classes (ok, only one is common, but I list a
* couple more to make it clear what we're talking about here).
@@ -341,12 +342,12 @@ struct GNUNET_TUN_DnsFlags
/**
* Set to 1 if recursion is desired (client -> server)
*/
- unsigned int recursion_desired : 1 GNUNET_PACKED;
+ unsigned int recursion_desired : 1 GNUNET_PACKED;
/**
* Set to 1 if message is truncated
*/
- unsigned int message_truncated : 1 GNUNET_PACKED;
+ unsigned int message_truncated : 1 GNUNET_PACKED;
/**
* Set to 1 if this is an authoritative answer
@@ -356,48 +357,48 @@ struct GNUNET_TUN_DnsFlags
/**
* See GNUNET_TUN_DNS_OPCODE_ defines.
*/
- unsigned int opcode : 4 GNUNET_PACKED;
+ unsigned int opcode : 4 GNUNET_PACKED;
/**
* query:0, response:1
*/
- unsigned int query_or_response : 1 GNUNET_PACKED;
+ unsigned int query_or_response : 1 GNUNET_PACKED;
/**
* See GNUNET_TUN_DNS_RETURN_CODE_ defines.
*/
- unsigned int return_code : 4 GNUNET_PACKED;
+ unsigned int return_code : 4 GNUNET_PACKED;
/**
* See RFC 4035.
*/
- unsigned int checking_disabled : 1 GNUNET_PACKED;
+ unsigned int checking_disabled : 1 GNUNET_PACKED;
/**
* Response has been cryptographically verified, RFC 4035.
*/
- unsigned int authenticated_data : 1 GNUNET_PACKED;
+ unsigned int authenticated_data : 1 GNUNET_PACKED;
/**
* Always zero.
*/
- unsigned int zero : 1 GNUNET_PACKED;
+ unsigned int zero : 1 GNUNET_PACKED;
/**
* Set to 1 if recursion is available (server -> client)
*/
- unsigned int recursion_available : 1 GNUNET_PACKED;
+ unsigned int recursion_available : 1 GNUNET_PACKED;
#elif __BYTE_ORDER == __BIG_ENDIAN
/**
* query:0, response:1
*/
- unsigned int query_or_response : 1 GNUNET_PACKED;
+ unsigned int query_or_response : 1 GNUNET_PACKED;
/**
* See GNUNET_TUN_DNS_OPCODE_ defines.
*/
- unsigned int opcode : 4 GNUNET_PACKED;
+ unsigned int opcode : 4 GNUNET_PACKED;
/**
* Set to 1 if this is an authoritative answer
@@ -407,46 +408,45 @@ struct GNUNET_TUN_DnsFlags
/**
* Set to 1 if message is truncated
*/
- unsigned int message_truncated : 1 GNUNET_PACKED;
+ unsigned int message_truncated : 1 GNUNET_PACKED;
/**
* Set to 1 if recursion is desired (client -> server)
*/
- unsigned int recursion_desired : 1 GNUNET_PACKED;
+ unsigned int recursion_desired : 1 GNUNET_PACKED;
/**
* Set to 1 if recursion is available (server -> client)
*/
- unsigned int recursion_available : 1 GNUNET_PACKED;
+ unsigned int recursion_available : 1 GNUNET_PACKED;
/**
* Always zero.
*/
- unsigned int zero : 1 GNUNET_PACKED;
+ unsigned int zero : 1 GNUNET_PACKED;
/**
* Response has been cryptographically verified, RFC 4035.
*/
- unsigned int authenticated_data : 1 GNUNET_PACKED;
+ unsigned int authenticated_data : 1 GNUNET_PACKED;
/**
* See RFC 4035.
*/
- unsigned int checking_disabled : 1 GNUNET_PACKED;
+ unsigned int checking_disabled : 1 GNUNET_PACKED;
/**
* See GNUNET_TUN_DNS_RETURN_CODE_ defines.
*/
- unsigned int return_code : 4 GNUNET_PACKED;
+ unsigned int return_code : 4 GNUNET_PACKED;
#else
- #error byteorder undefined
+#error byteorder undefined
#endif
} GNUNET_GCC_STRUCT_LAYOUT;
-
/**
* DNS header.
*/
@@ -683,21 +683,21 @@ struct GNUNET_TUN_DnsRecordLine
};
-#define GNUNET_TUN_ICMPTYPE_ECHO_REPLY 0
-#define GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE 3
-#define GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH 4
-#define GNUNET_TUN_ICMPTYPE_REDIRECT_MESSAGE 5
-#define GNUNET_TUN_ICMPTYPE_ECHO_REQUEST 8
-#define GNUNET_TUN_ICMPTYPE_ROUTER_ADVERTISEMENT 9
-#define GNUNET_TUN_ICMPTYPE_ROUTER_SOLICITATION 10
-#define GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED 11
+#define GNUNET_TUN_ICMPTYPE_ECHO_REPLY 0
+#define GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE 3
+#define GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH 4
+#define GNUNET_TUN_ICMPTYPE_REDIRECT_MESSAGE 5
+#define GNUNET_TUN_ICMPTYPE_ECHO_REQUEST 8
+#define GNUNET_TUN_ICMPTYPE_ROUTER_ADVERTISEMENT 9
+#define GNUNET_TUN_ICMPTYPE_ROUTER_SOLICITATION 10
+#define GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED 11
-#define GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE 1
-#define GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG 2
-#define GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED 3
-#define GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM 4
-#define GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST 128
-#define GNUNET_TUN_ICMPTYPE6_ECHO_REPLY 129
+#define GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE 1
+#define GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG 2
+#define GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED 3
+#define GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM 4
+#define GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST 128
+#define GNUNET_TUN_ICMPTYPE6_ECHO_REPLY 129
/**
@@ -716,8 +716,8 @@ struct GNUNET_TUN_IcmpHeader
*/
struct
{
- uint16_t identifier GNUNET_PACKED;
- uint16_t sequence_number GNUNET_PACKED;
+ uint16_t identifier GNUNET_PACKED;
+ uint16_t sequence_number GNUNET_PACKED;
} echo;
/**
@@ -727,13 +727,14 @@ struct GNUNET_TUN_IcmpHeader
{
uint16_t empty GNUNET_PACKED;
uint16_t next_hop_mtu GNUNET_PACKED;
- /* followed by original IP header + first 8 bytes of original IP
datagram */
+ /* followed by original IP header + first 8 bytes of original IP datagram
+ */
} destination_unreachable;
/**
* ICMP Redirect
*/
- struct in_addr redirect_gateway_address GNUNET_PACKED;
+ struct in_addr redirect_gateway_address;
/**
* MTU for packets that are too big (IPv6).
@@ -741,7 +742,6 @@ struct GNUNET_TUN_IcmpHeader
uint32_t packet_too_big_mtu GNUNET_PACKED;
} quench;
-
};
@@ -753,16 +753,17 @@ GNUNET_NETWORK_STRUCT_END
*
* @param ip header to initialize
* @param protocol protocol to use (i.e. IPPROTO_UDP)
- * @param payload_length number of bytes of payload that follow (excluding
IPv4 header)
+ * @param payload_length number of bytes of payload that follow (excluding IPv4
+ * header)
* @param src source IP address to use
* @param dst destination IP address to use
*/
void
GNUNET_TUN_initialize_ipv4_header (struct GNUNET_TUN_IPv4Header *ip,
- uint8_t protocol,
- uint16_t payload_length,
- const struct in_addr *src,
- const struct in_addr *dst);
+ uint8_t protocol,
+ uint16_t payload_length,
+ const struct in_addr *src,
+ const struct in_addr *dst);
/**
@@ -770,16 +771,17 @@ GNUNET_TUN_initialize_ipv4_header (struct
GNUNET_TUN_IPv4Header *ip,
*
* @param ip header to initialize
* @param protocol protocol to use (i.e. IPPROTO_UDP)
- * @param payload_length number of bytes of payload that follow (excluding
IPv4 header)
+ * @param payload_length number of bytes of payload that follow (excluding IPv4
+ * header)
* @param src source IP address to use
* @param dst destination IP address to use
*/
void
GNUNET_TUN_initialize_ipv6_header (struct GNUNET_TUN_IPv6Header *ip,
- uint8_t protocol,
- uint16_t payload_length,
- const struct in6_addr *src,
- const struct in6_addr *dst);
+ uint8_t protocol,
+ uint16_t payload_length,
+ const struct in6_addr *src,
+ const struct in6_addr *dst);
/**
* Calculate IPv4 TCP checksum.
@@ -791,9 +793,9 @@ GNUNET_TUN_initialize_ipv6_header (struct
GNUNET_TUN_IPv6Header *ip,
*/
void
GNUNET_TUN_calculate_tcp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
- struct GNUNET_TUN_TcpHeader *tcp,
- const void *payload,
- uint16_t payload_length);
+ struct GNUNET_TUN_TcpHeader *tcp,
+ const void *payload,
+ uint16_t payload_length);
/**
* Calculate IPv6 TCP checksum.
@@ -805,9 +807,9 @@ GNUNET_TUN_calculate_tcp4_checksum (const struct
GNUNET_TUN_IPv4Header *ip,
*/
void
GNUNET_TUN_calculate_tcp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
- struct GNUNET_TUN_TcpHeader *tcp,
- const void *payload,
- uint16_t payload_length);
+ struct GNUNET_TUN_TcpHeader *tcp,
+ const void *payload,
+ uint16_t payload_length);
/**
* Calculate IPv4 UDP checksum.
@@ -819,9 +821,9 @@ GNUNET_TUN_calculate_tcp6_checksum (const struct
GNUNET_TUN_IPv6Header *ip,
*/
void
GNUNET_TUN_calculate_udp4_checksum (const struct GNUNET_TUN_IPv4Header *ip,
- struct GNUNET_TUN_UdpHeader *udp,
- const void *payload,
- uint16_t payload_length);
+ struct GNUNET_TUN_UdpHeader *udp,
+ const void *payload,
+ uint16_t payload_length);
/**
@@ -834,9 +836,9 @@ GNUNET_TUN_calculate_udp4_checksum (const struct
GNUNET_TUN_IPv4Header *ip,
*/
void
GNUNET_TUN_calculate_udp6_checksum (const struct GNUNET_TUN_IPv6Header *ip,
- struct GNUNET_TUN_UdpHeader *udp,
- const void *payload,
- uint16_t payload_length);
+ struct GNUNET_TUN_UdpHeader *udp,
+ const void *payload,
+ uint16_t payload_length);
/**
@@ -848,8 +850,8 @@ GNUNET_TUN_calculate_udp6_checksum (const struct
GNUNET_TUN_IPv6Header *ip,
*/
void
GNUNET_TUN_calculate_icmp_checksum (struct GNUNET_TUN_IcmpHeader *icmp,
- const void *payload,
- uint16_t payload_length);
+ const void *payload,
+ uint16_t payload_length);
/**
@@ -949,4 +951,4 @@ GNUNET_TUN_compute_service_cadet_port (const struct
GNUNET_HashCode *desc,
#endif
-/** @} */ /* end of group */
+/** @} */ /* end of group */
diff --git a/src/transport/gnunet-service-tng.c
b/src/transport/gnunet-service-tng.c
index 27c97860e..bca03574d 100644
--- a/src/transport/gnunet-service-tng.c
+++ b/src/transport/gnunet-service-tng.c
@@ -156,47 +156,55 @@
* of seconds we log a warning. Note: this is for testing,
* the value chosen here might be too aggressively low!
*/
-#define DELAY_WARN_THRESHOLD GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 5)
+#define DELAY_WARN_THRESHOLD \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
/**
* We only consider queues as "quality" connections when
* suppressing the generation of DV initiation messages if
* the latency of the queue is below this threshold.
*/
-#define DV_QUALITY_RTT_THRESHOLD GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 1)
+#define DV_QUALITY_RTT_THRESHOLD \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
/**
* How long do we consider a DV path valid if we see no
* further updates on it? Note: the value chosen here might be too low!
*/
-#define DV_PATH_VALIDITY_TIMEOUT GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5)
+#define DV_PATH_VALIDITY_TIMEOUT \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
/**
* How long before paths expire would we like to (re)discover DV paths? Should
* be below #DV_PATH_VALIDITY_TIMEOUT.
*/
-#define DV_PATH_DISCOVERY_FREQUENCY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 4)
+#define DV_PATH_DISCOVERY_FREQUENCY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
/**
* How long are ephemeral keys valid?
*/
-#define EPHEMERAL_VALIDITY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_HOURS, 4)
+#define EPHEMERAL_VALIDITY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
/**
* How long do we keep partially reassembled messages around before giving up?
*/
-#define REASSEMBLY_EXPIRATION GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 4)
+#define REASSEMBLY_EXPIRATION \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
/**
* What is the fastest rate at which we send challenges *if* we keep learning
* an address (gossip, DHT, etc.)?
*/
-#define FAST_VALIDATION_CHALLENGE_FREQ GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 1)
+#define FAST_VALIDATION_CHALLENGE_FREQ \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
/**
* What is the slowest rate at which we send challenges?
*/
-#define MAX_VALIDATION_CHALLENGE_FREQ GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_DAYS, 1)
+#define MAX_VALIDATION_CHALLENGE_FREQ \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)
/**
* What is the non-randomized base frequency at which we
@@ -213,11 +221,13 @@
/**
* When do we forget an invalid address for sure?
*/
-#define MAX_ADDRESS_VALID_UNTIL GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MONTHS, 1)
+#define MAX_ADDRESS_VALID_UNTIL \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)
/**
* How long do we consider an address valid if we just checked?
*/
-#define ADDRESS_VALIDATION_LIFETIME GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_HOURS, 4)
+#define ADDRESS_VALIDATION_LIFETIME \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
/**
* What is the maximum frequency at which we do address validation?
@@ -337,7 +347,6 @@ struct EphemeralConfirmation
* to encrypt the payload.
*/
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
-
};
@@ -392,7 +401,6 @@ struct TransportBackchannelRequestPayload
/* Followed by a 0-termianted string specifying the name of
the communicator which is to receive the message */
-
};
@@ -491,7 +499,6 @@ struct TransportFragmentBox
* Total size of the message that is being fragmented.
*/
uint16_t msg_size GNUNET_PACKED;
-
};
@@ -585,7 +592,6 @@ struct DvInitPS
* Challenge value used by the initiator to re-identify the path.
*/
struct GNUNET_ShortHashCode challenge;
-
};
@@ -626,7 +632,6 @@ struct DvHopPS
* Challenge value used by the initiator to re-identify the path.
*/
struct GNUNET_ShortHashCode challenge;
-
};
@@ -646,7 +651,6 @@ struct DVPathEntryP
* #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP
*/
struct GNUNET_CRYPTO_EddsaSignature hop_sig;
-
};
@@ -712,7 +716,6 @@ struct TransportDVLearn
/* Followed by @e num_hops `struct DVPathEntryP` values,
excluding the initiator of the DV trace; the last entry is the
current sender; the current peer must not be included. */
-
};
@@ -817,7 +820,6 @@ struct TransportValidationPS
* Challenge signed by the receiving peer.
*/
struct GNUNET_ShortHashCode challenge;
-
};
@@ -863,7 +865,6 @@ struct TransportValidationResponse
};
-
GNUNET_NETWORK_STRUCT_END
@@ -925,7 +926,6 @@ struct LearnLaunchEntry
* determine freshness of paths learned via this operation.
*/
struct GNUNET_TIME_Absolute launch_time;
-
};
@@ -1050,8 +1050,9 @@ struct DistanceVectorHop
struct GNUNET_TIME_Absolute freshness;
/**
- * How many hops in total to the `target` (excluding @e next_hop and
`target` itself),
- * thus 0 still means a distance of 2 hops (to @e next_hop and then to
`target`)?
+ * How many hops in total to the `target` (excluding @e next_hop and `target`
+ * itself), thus 0 still means a distance of 2 hops (to @e next_hop and then
+ * to `target`)?
*/
unsigned int distance;
};
@@ -1353,7 +1354,8 @@ struct ReassemblyContext
*/
uint16_t msg_missing;
- /* Followed by @e msg_size bytes of the (partially) defragmented original
message */
+ /* Followed by @e msg_size bytes of the (partially) defragmented original
+ * message */
/* Followed by @e bitfield data */
};
@@ -1480,7 +1482,6 @@ struct PeerRequest
* How much bandwidth would this @e tc like to see?
*/
struct GNUNET_BANDWIDTH_Value32NBO bw;
-
};
@@ -1567,17 +1568,20 @@ struct PendingMessage
struct PendingMessage *prev_client;
/**
- * Kept in a MDLL of messages from this @a cpm (if @e pmt is
#PMT_FRAGMENT_BOx)
+ * Kept in a MDLL of messages from this @a cpm (if @e pmt is
+ * #PMT_FRAGMENT_BOx)
*/
struct PendingMessage *next_frag;
/**
- * Kept in a MDLL of messages from this @a cpm (if @e pmt is
#PMT_FRAGMENT_BOX)
+ * Kept in a MDLL of messages from this @a cpm (if @e pmt is
+ * #PMT_FRAGMENT_BOX)
*/
struct PendingMessage *prev_frag;
/**
- * This message, reliability boxed. Only possibly available if @e pmt is
#PMT_CORE.
+ * This message, reliability boxed. Only possibly available if @e pmt is
+ * #PMT_CORE.
*/
struct PendingMessage *bpm;
@@ -1702,7 +1706,6 @@ struct AddressListEntry
* Network type offered by this address.
*/
enum GNUNET_NetworkType nt;
-
};
@@ -1743,7 +1746,8 @@ struct TransportClient
/**
* Information for @e type #CT_CORE.
*/
- struct {
+ struct
+ {
/**
* Head of list of messages pending for this client, sorted by
@@ -1761,7 +1765,8 @@ struct TransportClient
/**
* Information for @e type #CT_MONITOR.
*/
- struct {
+ struct
+ {
/**
* Peer identity to monitor the addresses of.
@@ -1781,7 +1786,8 @@ struct TransportClient
/**
* Information for @e type #CT_COMMUNICATOR.
*/
- struct {
+ struct
+ {
/**
* If @e type is #CT_COMMUNICATOR, this communicator
* supports communicating using these addresses.
@@ -1799,12 +1805,14 @@ struct TransportClient
struct Queue *queue_tail;
/**
- * Head of list of the addresses of this peer offered by this
communicator.
+ * Head of list of the addresses of this peer offered by this
+ * communicator.
*/
struct AddressListEntry *addr_head;
/**
- * Tail of list of the addresses of this peer offered by this
communicator.
+ * Tail of list of the addresses of this peer offered by this
+ * communicator.
*/
struct AddressListEntry *addr_tail;
@@ -1825,7 +1833,8 @@ struct TransportClient
/**
* Information for @e type #CT_APPLICATION
*/
- struct {
+ struct
+ {
/**
* Map of requests for peers the given client application would like to
@@ -1836,7 +1845,6 @@ struct TransportClient
} application;
} details;
-
};
@@ -1940,7 +1948,6 @@ struct ValidationState
* the respective queue to become available for transmission.
*/
int awaiting_queue;
-
};
@@ -2058,9 +2065,7 @@ static struct GNUNET_SCHEDULER_Task *validation_task;
static void
free_ephemeral (struct EphemeralCacheEntry *ece)
{
- GNUNET_CONTAINER_multipeermap_remove (ephemeral_map,
- &ece->target,
- ece);
+ GNUNET_CONTAINER_multipeermap_remove (ephemeral_map, &ece->target, ece);
GNUNET_CONTAINER_heap_remove_node (ece->hn);
GNUNET_free (ece);
}
@@ -2074,9 +2079,7 @@ free_ephemeral (struct EphemeralCacheEntry *ece)
static void
free_validation_state (struct ValidationState *vs)
{
- GNUNET_CONTAINER_multipeermap_remove (validation_map,
- &vs->pid,
- vs);
+ GNUNET_CONTAINER_multipeermap_remove (validation_map, &vs->pid, vs);
GNUNET_CONTAINER_heap_remove_node (vs->hn);
vs->hn = NULL;
if (NULL != vs->sc)
@@ -2098,8 +2101,7 @@ free_validation_state (struct ValidationState *vs)
static struct Neighbour *
lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
{
- return GNUNET_CONTAINER_multipeermap_get (neighbours,
- pid);
+ return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
}
@@ -2134,8 +2136,6 @@ struct MonitorEvent
* Bytes pending.
*/
uint32_t num_bytes_pending;
-
-
};
@@ -2153,14 +2153,8 @@ free_distance_vector_hop (struct DistanceVectorHop *dvh)
struct Neighbour *n = dvh->next_hop;
struct DistanceVector *dv = dvh->dv;
- GNUNET_CONTAINER_MDLL_remove (neighbour,
- n->dv_head,
- n->dv_tail,
- dvh);
- GNUNET_CONTAINER_MDLL_remove (dv,
- dv->dv_head,
- dv->dv_tail,
- dvh);
+ GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
+ GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh);
GNUNET_free (dvh);
}
@@ -2180,10 +2174,9 @@ free_dv_route (struct DistanceVector *dv)
free_distance_vector_hop (dvh);
if (NULL == dv->dv_head)
{
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (dv_routes,
- &dv->target,
- dv));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (dv_routes, &dv->target, dv));
if (NULL != dv->timeout_task)
GNUNET_SCHEDULER_cancel (dv->timeout_task);
GNUNET_free (dv);
@@ -2227,11 +2220,8 @@ notify_monitor (struct TransportClient *tc,
md->cs = htonl ((uint32_t) me->cs);
md->num_msg_pending = htonl (me->num_msg_pending);
md->num_bytes_pending = htonl (me->num_bytes_pending);
- memcpy (&md[1],
- address,
- addr_len);
- GNUNET_MQ_send (tc->mq,
- env);
+ memcpy (&md[1], address, addr_len);
+ GNUNET_MQ_send (tc->mq, env);
}
@@ -2250,23 +2240,16 @@ notify_monitors (const struct GNUNET_PeerIdentity *peer,
enum GNUNET_NetworkType nt,
const struct MonitorEvent *me)
{
- for (struct TransportClient *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 (tc->details.monitor.one_shot)
continue;
- if ( (0 != GNUNET_is_zero (&tc->details.monitor.peer)) &&
- (0 != GNUNET_memcmp (&tc->details.monitor.peer,
- peer)) )
+ if ((0 != GNUNET_is_zero (&tc->details.monitor.peer)) &&
+ (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
continue;
- notify_monitor (tc,
- peer,
- address,
- nt,
- me);
+ notify_monitor (tc, peer, address, nt, me);
}
}
@@ -2291,12 +2274,8 @@ client_connect_cb (void *cls,
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;
}
@@ -2311,8 +2290,7 @@ free_reassembly_context (struct ReassemblyContext *rc)
{
struct Neighbour *n = rc->neighbour;
- GNUNET_assert (rc ==
- GNUNET_CONTAINER_heap_remove_node (rc->hn));
+ GNUNET_assert (rc == GNUNET_CONTAINER_heap_remove_node (rc->hn));
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multishortmap_remove (n->reassembly_map,
&rc->msg_uuid,
@@ -2335,15 +2313,17 @@ reassembly_cleanup_task (void *cls)
n->reassembly_timeout_task = NULL;
while (NULL != (rc = GNUNET_CONTAINER_heap_peek (n->reassembly_heap)))
{
- if (0 == GNUNET_TIME_absolute_get_remaining
(rc->reassembly_timeout).rel_value_us)
+ if (0 == GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout)
+ .rel_value_us)
{
free_reassembly_context (rc);
continue;
}
GNUNET_assert (NULL == n->reassembly_timeout_task);
- n->reassembly_timeout_task = GNUNET_SCHEDULER_add_at
(rc->reassembly_timeout,
-
&reassembly_cleanup_task,
- n);
+ n->reassembly_timeout_task =
+ GNUNET_SCHEDULER_add_at (rc->reassembly_timeout,
+ &reassembly_cleanup_task,
+ n);
return;
}
}
@@ -2363,9 +2343,9 @@ free_reassembly_cb (void *cls,
void *value)
{
struct ReassemblyContext *rc = value;
+
(void) cls;
(void) key;
-
free_reassembly_context (rc);
return GNUNET_OK;
}
@@ -2428,12 +2408,10 @@ core_send_connect_info (struct TransportClient *tc,
struct ConnectInfoMessage *cim;
GNUNET_assert (CT_CORE == tc->type);
- env = GNUNET_MQ_msg (cim,
- GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
+ env = GNUNET_MQ_msg (cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
cim->quota_out = quota_out;
cim->id = *pid;
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
}
@@ -2447,15 +2425,11 @@ static void
cores_send_connect_info (const struct GNUNET_PeerIdentity *pid,
struct GNUNET_BANDWIDTH_Value32NBO quota_out)
{
- for (struct TransportClient *tc = clients_head;
- NULL != tc;
- tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
if (CT_CORE != tc->type)
continue;
- core_send_connect_info (tc,
- pid,
- quota_out);
+ core_send_connect_info (tc, pid, quota_out);
}
}
@@ -2468,20 +2442,16 @@ cores_send_connect_info (const struct
GNUNET_PeerIdentity *pid,
static void
cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
{
- for (struct TransportClient *tc = clients_head;
- NULL != tc;
- tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
struct GNUNET_MQ_Envelope *env;
struct DisconnectInfoMessage *dim;
if (CT_CORE != tc->type)
continue;
- env = GNUNET_MQ_msg (dim,
- GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
+ env = GNUNET_MQ_msg (dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
dim->peer = *pid;
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
}
}
@@ -2519,10 +2489,11 @@ schedule_transmit_on_queue (struct Queue *queue)
if (queue->tc->details.communicator.total_queue_length >=
COMMUNICATOR_TOTAL_QUEUE_LIMIT)
{
- GNUNET_STATISTICS_update (GST_stats,
- "# Transmission throttled due to communicator
queue limit",
- 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (
+ GST_stats,
+ "# Transmission throttled due to communicator queue limit",
+ 1,
+ GNUNET_NO);
return;
}
if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
@@ -2534,32 +2505,27 @@ schedule_transmit_on_queue (struct Queue *queue)
return;
}
- wsize = (0 == queue->mtu)
- ? pm->bytes_msg /* FIXME: add overheads? */
- : queue->mtu;
- out_delay = GNUNET_BANDWIDTH_tracker_get_delay (&queue->tracker_out,
- wsize);
- out_delay = GNUNET_TIME_relative_max (GNUNET_TIME_absolute_get_remaining
(pm->next_attempt),
+ wsize = (0 == queue->mtu) ? pm->bytes_msg /* FIXME: add overheads? */
+ : queue->mtu;
+ out_delay = GNUNET_BANDWIDTH_tracker_get_delay (&queue->tracker_out, wsize);
+ out_delay = GNUNET_TIME_relative_max (GNUNET_TIME_absolute_get_remaining (
+ pm->next_attempt),
out_delay);
if (0 == out_delay.rel_value_us)
return; /* we should run immediately! */
/* queue has changed since we were scheduled, reschedule again */
- queue->transmit_task
- = GNUNET_SCHEDULER_add_delayed (out_delay,
- &transmit_on_queue,
- queue);
+ queue->transmit_task =
+ GNUNET_SCHEDULER_add_delayed (out_delay, &transmit_on_queue, queue);
if (out_delay.rel_value_us > DELAY_WARN_THRESHOLD.rel_value_us)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Next transmission on queue `%s' in %s (high delay)\n",
queue->address,
- GNUNET_STRINGS_relative_time_to_string (out_delay,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (out_delay,
GNUNET_YES));
else
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Next transmission on queue `%s' in %s\n",
queue->address,
- GNUNET_STRINGS_relative_time_to_string (out_delay,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (out_delay,
GNUNET_YES));
}
@@ -2583,10 +2549,8 @@ free_queue (struct Queue *queue)
{
struct Neighbour *neighbour = queue->neighbour;
struct TransportClient *tc = queue->tc;
- struct MonitorEvent me = {
- .cs = GNUNET_TRANSPORT_CS_DOWN,
- .rtt = GNUNET_TIME_UNIT_FOREVER_REL
- };
+ struct MonitorEvent me = {.cs = GNUNET_TRANSPORT_CS_DOWN,
+ .rtt = GNUNET_TIME_UNIT_FOREVER_REL};
struct QueueEntry *qe;
int maxxed;
@@ -2608,40 +2572,36 @@ free_queue (struct Queue *queue)
tc->details.communicator.queue_head,
tc->details.communicator.queue_tail,
queue);
- maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT >=
tc->details.communicator.total_queue_length);
+ maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT >=
+ tc->details.communicator.total_queue_length);
while (NULL != (qe = queue->queue_head))
{
- GNUNET_CONTAINER_DLL_remove (queue->queue_head,
- queue->queue_tail,
- qe);
+ GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
queue->queue_length--;
tc->details.communicator.total_queue_length--;
GNUNET_free (qe);
}
GNUNET_assert (0 == queue->queue_length);
- if ( (maxxed) &&
- (COMMUNICATOR_TOTAL_QUEUE_LIMIT <
tc->details.communicator.total_queue_length) )
+ if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT <
+ tc->details.communicator.total_queue_length))
{
/* Communicator dropped below threshold, resume all queues */
- GNUNET_STATISTICS_update (GST_stats,
- "# Transmission throttled due to communicator
queue limit",
- -1,
- GNUNET_NO);
- for (struct Queue *s = tc->details.communicator.queue_head;
- NULL != s;
+ GNUNET_STATISTICS_update (
+ GST_stats,
+ "# Transmission throttled due to communicator queue limit",
+ -1,
+ GNUNET_NO);
+ for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
s = s->next_client)
schedule_transmit_on_queue (s);
}
- notify_monitors (&neighbour->pid,
- queue->address,
- queue->nt,
- &me);
+ notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
GNUNET_BANDWIDTH_tracker_notification_stop (&queue->tracker_in);
GNUNET_BANDWIDTH_tracker_notification_stop (&queue->tracker_out);
GNUNET_free (queue);
update_neighbour_core_visibility (neighbour);
- cores_send_disconnect_info (&neighbour->pid);
+ cores_send_disconnect_info (&neighbour->pid);
if (NULL == neighbour->queue_head)
{
@@ -2694,10 +2654,11 @@ stop_peer_request (void *cls,
struct PeerRequest *pr = value;
GNUNET_PEERSTORE_watch_cancel (pr->wc);
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove
(tc->details.application.requests,
- pid,
- pr));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
+ pid,
+ pr));
GNUNET_free (pr);
return GNUNET_OK;
@@ -2723,41 +2684,37 @@ client_disconnect_cb (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client %p disconnected, cleaning up.\n",
tc);
- 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:
- {
- struct PendingMessage *pm;
+ case CT_CORE: {
+ struct PendingMessage *pm;
- while (NULL != (pm = tc->details.core.pending_msg_head))
- {
- GNUNET_CONTAINER_MDLL_remove (client,
- tc->details.core.pending_msg_head,
- tc->details.core.pending_msg_tail,
- pm);
- pm->client = NULL;
- }
- }
- break;
- case CT_MONITOR:
- break;
- case CT_COMMUNICATOR:
+ while (NULL != (pm = tc->details.core.pending_msg_head))
{
- struct Queue *q;
- struct AddressListEntry *ale;
-
- while (NULL != (q = tc->details.communicator.queue_head))
- free_queue (q);
- while (NULL != (ale = tc->details.communicator.addr_head))
- free_address_list_entry (ale);
- GNUNET_free (tc->details.communicator.address_prefix);
+ GNUNET_CONTAINER_MDLL_remove (client,
+ tc->details.core.pending_msg_head,
+ tc->details.core.pending_msg_tail,
+ pm);
+ pm->client = NULL;
}
+ }
+ break;
+ case CT_MONITOR:
break;
+ case CT_COMMUNICATOR: {
+ struct Queue *q;
+ struct AddressListEntry *ale;
+
+ while (NULL != (q = tc->details.communicator.queue_head))
+ free_queue (q);
+ while (NULL != (ale = tc->details.communicator.addr_head))
+ free_address_list_entry (ale);
+ GNUNET_free (tc->details.communicator.address_prefix);
+ }
+ break;
case CT_APPLICATION:
GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
&stop_peer_request,
@@ -2786,9 +2743,7 @@ notify_client_connect_info (void *cls,
struct TransportClient *tc = cls;
struct Neighbour *neighbour = value;
- core_send_connect_info (tc,
- pid,
- neighbour->quota_out);
+ core_send_connect_info (tc, pid, neighbour->quota_out);
return GNUNET_OK;
}
@@ -2802,17 +2757,14 @@ notify_client_connect_info (void *cls,
* @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;
uint32_t options;
options = ntohl (start->options);
- if ( (0 != (1 & options)) &&
- (0 !=
- GNUNET_memcmp (&start->self,
- &GST_my_identity)) )
+ if ((0 != (1 & options)) &&
+ (0 != GNUNET_memcmp (&start->self, &GST_my_identity)))
{
/* client thinks this is a different peer, reject */
GNUNET_break (0);
@@ -2840,8 +2792,7 @@ handle_client_start (void *cls,
* @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)
{
struct TransportClient *tc = cls;
uint16_t size;
@@ -2881,10 +2832,7 @@ free_fragment_tree (struct PendingMessage *root)
while (NULL != (frag = root->head_frag))
{
free_fragment_tree (frag);
- GNUNET_CONTAINER_MDLL_remove (frag,
- root->head_frag,
- root->tail_frag,
- frag);
+ GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag,
frag);
GNUNET_free (frag);
}
}
@@ -2944,14 +2892,12 @@ client_send_response (struct PendingMessage *pm,
if (NULL != tc)
{
- env = GNUNET_MQ_msg (som,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
+ env = GNUNET_MQ_msg (som, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
som->success = htonl ((uint32_t) success);
som->bytes_msg = htons (pm->bytes_msg);
som->bytes_physical = htonl (bytes_physical);
som->peer = target->pid;
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
}
free_pending_message (pm);
}
@@ -2974,9 +2920,7 @@ check_queue_timeouts (void *cls)
n->timeout_task = NULL;
earliest_timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
now = GNUNET_TIME_absolute_get ();
- for (struct PendingMessage *pos = n->pending_msg_head;
- NULL != pos;
- pos = pm)
+ for (struct PendingMessage *pos = n->pending_msg_head; NULL != pos; pos = pm)
{
pm = pos->next_neighbour;
if (pos->timeout.abs_value_us <= now.abs_value_us)
@@ -2985,19 +2929,16 @@ check_queue_timeouts (void *cls)
"# messages dropped (timeout before
confirmation)",
1,
GNUNET_NO);
- client_send_response (pm,
- GNUNET_NO,
- 0);
+ client_send_response (pm, GNUNET_NO, 0);
continue;
}
- earliest_timeout = GNUNET_TIME_absolute_min (earliest_timeout,
- pos->timeout);
+ earliest_timeout =
+ GNUNET_TIME_absolute_min (earliest_timeout, pos->timeout);
}
n->earliest_timeout = earliest_timeout;
if (NULL != n->pending_msg_head)
- n->timeout_task = GNUNET_SCHEDULER_add_at (earliest_timeout,
- &check_queue_timeouts,
- n);
+ n->timeout_task =
+ GNUNET_SCHEDULER_add_at (earliest_timeout, &check_queue_timeouts, n);
}
@@ -3008,8 +2949,7 @@ check_queue_timeouts (void *cls)
* @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)
{
struct TransportClient *tc = cls;
struct PendingMessage *pm;
@@ -3031,14 +2971,12 @@ handle_client_send (void *cls,
struct GNUNET_MQ_Envelope *env;
struct SendOkMessage *som;
- env = GNUNET_MQ_msg (som,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
+ env = GNUNET_MQ_msg (som, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
som->success = htonl (GNUNET_SYSERR);
som->bytes_msg = htonl (bytes_msg);
som->bytes_physical = htonl (0);
som->peer = obm->peer;
- GNUNET_MQ_send (tc->mq,
- env);
+ GNUNET_MQ_send (tc->mq, env);
GNUNET_SERVICE_client_continue (tc->client);
GNUNET_STATISTICS_update (GST_stats,
"# messages dropped (neighbour unknown)",
@@ -3051,10 +2989,9 @@ handle_client_send (void *cls,
pm->client = tc;
pm->target = target;
pm->bytes_msg = bytes_msg;
- pm->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh
(obm->timeout));
- memcpy (&pm[1],
- &obm[1],
- bytes_msg);
+ pm->timeout =
+ GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh
(obm->timeout));
+ memcpy (&pm[1], &obm[1], bytes_msg);
GNUNET_CONTAINER_MDLL_insert (neighbour,
target->pending_msg_head,
target->pending_msg_tail,
@@ -3068,21 +3005,19 @@ handle_client_send (void *cls,
target->earliest_timeout.abs_value_us = pm->timeout.abs_value_us;
if (NULL != target->timeout_task)
GNUNET_SCHEDULER_cancel (target->timeout_task);
- target->timeout_task
- = GNUNET_SCHEDULER_add_at (target->earliest_timeout,
- &check_queue_timeouts,
- target);
+ target->timeout_task = GNUNET_SCHEDULER_add_at (target->earliest_timeout,
+ &check_queue_timeouts,
+ target);
}
if (! was_empty)
return; /* all queues must already be busy */
- for (struct Queue *queue = target->queue_head;
- NULL != queue;
+ for (struct Queue *queue = target->queue_head; NULL != queue;
queue = queue->next_neighbour)
{
/* try transmission on any queue that is idle */
if (NULL == queue->transmit_task)
- queue->transmit_task = GNUNET_SCHEDULER_add_now (&transmit_on_queue,
- queue);
+ queue->transmit_task =
+ GNUNET_SCHEDULER_add_now (&transmit_on_queue, queue);
}
}
@@ -3094,8 +3029,9 @@ handle_client_send (void *cls,
* @param cam the send message that was sent
*/
static int
-check_communicator_available (void *cls,
- const struct
GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
+check_communicator_available (
+ void *cls,
+ const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
{
struct TransportClient *tc = cls;
uint16_t size;
@@ -3121,8 +3057,9 @@ check_communicator_available (void *cls,
* @param cam the send message that was sent
*/
static void
-handle_communicator_available (void *cls,
- const struct
GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
+handle_communicator_available (
+ void *cls,
+ const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
{
struct TransportClient *tc = cls;
uint16_t size;
@@ -3130,10 +3067,10 @@ handle_communicator_available (void *cls,
size = ntohs (cam->header.size) - sizeof (*cam);
if (0 == size)
return; /* receive-only communicator */
- tc->details.communicator.address_prefix
- = GNUNET_strdup ((const char *) &cam[1]);
- tc->details.communicator.cc
- = (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc);
+ tc->details.communicator.address_prefix =
+ GNUNET_strdup ((const char *) &cam[1]);
+ tc->details.communicator.cc =
+ (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -3146,8 +3083,9 @@ handle_communicator_available (void *cls,
* @return #GNUNET_OK if message is well-formed
*/
static int
-check_communicator_backchannel (void *cls,
- const struct
GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
+check_communicator_backchannel (
+ void *cls,
+ const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
{
const struct GNUNET_MessageHeader *inbox;
const char *is;
@@ -3158,7 +3096,7 @@ check_communicator_backchannel (void *cls,
msize = ntohs (cb->header.size) - sizeof (*cb);
if (UINT16_MAX - msize >
sizeof (struct TransportBackchannelEncapsulationMessage) +
- sizeof (struct TransportBackchannelRequestPayload) )
+ sizeof (struct TransportBackchannelRequestPayload))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -3174,7 +3112,7 @@ check_communicator_backchannel (void *cls,
is += isize;
msize -= isize;
GNUNET_assert (msize > 0);
- if ('\0' != is[msize-1])
+ if ('\0' != is[msize - 1])
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -3197,7 +3135,8 @@ expire_ephemerals (void *cls)
ephemeral_task = NULL;
while (NULL != (ece = GNUNET_CONTAINER_heap_peek (ephemeral_heap)))
{
- if (0 == GNUNET_TIME_absolute_get_remaining
(ece->ephemeral_validity).rel_value_us)
+ if (0 == GNUNET_TIME_absolute_get_remaining (ece->ephemeral_validity)
+ .rel_value_us)
{
free_ephemeral (ece);
continue;
@@ -3230,10 +3169,10 @@ lookup_ephemeral (const struct GNUNET_PeerIdentity *pid,
struct EphemeralCacheEntry *ece;
struct EphemeralConfirmation ec;
- ece = GNUNET_CONTAINER_multipeermap_get (ephemeral_map,
- pid);
- if ( (NULL != ece) &&
- (0 == GNUNET_TIME_absolute_get_remaining
(ece->ephemeral_validity).rel_value_us) )
+ ece = GNUNET_CONTAINER_multipeermap_get (ephemeral_map, pid);
+ if ((NULL != ece) &&
+ (0 == GNUNET_TIME_absolute_get_remaining (ece->ephemeral_validity)
+ .rel_value_us))
{
free_ephemeral (ece);
ece = NULL;
@@ -3242,28 +3181,29 @@ lookup_ephemeral (const struct GNUNET_PeerIdentity *pid,
{
ece = GNUNET_new (struct EphemeralCacheEntry);
ece->target = *pid;
- ece->ephemeral_validity = GNUNET_TIME_absolute_add
(GNUNET_TIME_absolute_get_monotonic (GST_cfg),
- EPHEMERAL_VALIDITY);
+ ece->ephemeral_validity =
+ GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get_monotonic (GST_cfg),
+ EPHEMERAL_VALIDITY);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_ecdhe_key_create2 (&ece->private_key));
- GNUNET_CRYPTO_ecdhe_key_get_public (&ece->private_key,
- &ece->ephemeral_key);
+ GNUNET_CRYPTO_ecdhe_key_get_public (&ece->private_key,
&ece->ephemeral_key);
ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
ec.purpose.size = htonl (sizeof (ec));
ec.target = *pid;
ec.ephemeral_key = ece->ephemeral_key;
+ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+ &ec.purpose,
+ &ece->sender_sig));
+ ece->hn =
+ GNUNET_CONTAINER_heap_insert (ephemeral_heap,
+ ece,
+ ece->ephemeral_validity.abs_value_us);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
- &ec.purpose,
- &ece->sender_sig));
- ece->hn = GNUNET_CONTAINER_heap_insert (ephemeral_heap,
- ece,
-
ece->ephemeral_validity.abs_value_us);
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (ephemeral_map,
- &ece->target,
- ece,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ ephemeral_map,
+ &ece->target,
+ ece,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
if (NULL == ephemeral_task)
ephemeral_task = GNUNET_SCHEDULER_add_at (ece->ephemeral_validity,
&expire_ephemerals,
@@ -3301,9 +3241,7 @@ queue_send_msg (struct Queue *queue,
smt->qid = queue->qid;
smt->mid = queue->mid_gen;
smt->receiver = n->pid;
- memcpy (&smt[1],
- payload,
- payload_size);
+ memcpy (&smt[1], payload, payload_size);
{
/* Pass the env to the communicator of queue for transmission. */
struct QueueEntry *qe;
@@ -3313,14 +3251,11 @@ queue_send_msg (struct Queue *queue,
qe->queue = queue;
// qe->pm = pm; // FIXME: not so easy, reference management on 'free(s)'!
// (also, note that pm may be NULL!)
- GNUNET_CONTAINER_DLL_insert (queue->queue_head,
- queue->queue_tail,
- qe);
+ GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
queue->queue_length++;
queue->tc->details.communicator.total_queue_length++;
- GNUNET_MQ_send (queue->tc->mq,
- env);
+ GNUNET_MQ_send (queue->tc->mq, env);
}
}
@@ -3329,7 +3264,8 @@ queue_send_msg (struct Queue *queue,
* Which transmission options are allowable for transmission?
* Interpreted bit-wise!
*/
-enum RouteMessageOptions {
+enum RouteMessageOptions
+{
/**
* Only confirmed, non-DV direct neighbours.
*/
@@ -3373,8 +3309,58 @@ route_via_neighbour (const struct Neighbour *n,
const struct GNUNET_MessageHeader *hdr,
enum RouteMessageOptions options)
{
- // FIXME: pick on or two 'random' queue (under constraints of options)
- // Then add wrapper and enqueue message!
+ struct GNUNET_TIME_Absolute now;
+ unsigned int candidates;
+ unsigned int sel1;
+ unsigned int sel2;
+
+ /* Pick one or two 'random' queues from n (under constraints of options) */
+ now = GNUNET_TIME_absolute_get ();
+ /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
+ weight in the future; weight could be assigned by observed
+ bandwidth (note: not sure if we should do this for this type
+ of control traffic though). */
+ candidates = 0;
+ for (struct Queue *pos = n->queue_head; NULL != pos;
+ pos = pos->next_neighbour)
+ {
+ /* Count the queue with the visibility task in all cases, as
+ otherwise we may end up with no queues just because the
+ time for the visibility task just expired but the scheduler
+ just ran this task first */
+ if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) ||
+ (pos->validated_until.abs_value_us > now.abs_value_us) ||
+ (NULL != pos->visibility_task))
+ candidates++;
+ }
+ if (0 == candidates)
+ {
+ /* Given that we above check for pos->visibility task,
+ this should be strictly impossible. */
+ GNUNET_break (0);
+ return;
+ }
+ sel1 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates);
+ if (0 == (options & RMO_REDUNDANT))
+ sel2 = candidates; /* picks none! */
+ else
+ sel2 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates);
+ candidates = 0;
+ for (struct Queue *pos = n->queue_head; NULL != pos;
+ pos = pos->next_neighbour)
+ {
+ /* Count the queue with the visibility task in all cases, as
+ otherwise we may end up with no queues just because the
+ time for the visibility task just expired but the scheduler
+ just ran this task first */
+ if ((pos->validated_until.abs_value_us > now.abs_value_us) ||
+ (NULL != pos->visibility_task))
+ {
+ if ((sel1 == candidates) || (sel2 == candidates))
+ queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
+ candidates++;
+ }
+ }
}
@@ -3414,25 +3400,20 @@ route_message (const struct GNUNET_PeerIdentity *target,
struct Neighbour *n;
struct DistanceVector *dv;
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- target);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, target);
dv = (0 != (options & RMO_DV_ALLOWED))
- ? GNUNET_CONTAINER_multipeermap_get (dv_routes,
- target)
- : NULL;
+ ? GNUNET_CONTAINER_multipeermap_get (dv_routes, target)
+ : NULL;
if (0 == (options & RMO_UNCONFIRMED_ALLOWED))
{
/* if confirmed is required, and we do not have anything
confirmed, drop respective options */
- if ( (NULL != n) &&
- (GNUNET_NO == n->core_visible) )
+ if ((NULL != n) && (GNUNET_NO == n->core_visible))
n = NULL;
- if ( (NULL != dv) &&
- (GNUNET_NO == dv->core_visible) )
+ if ((NULL != dv) && (GNUNET_NO == dv->core_visible))
dv = NULL;
}
- if ( (NULL == n) &&
- (NULL == dv) )
+ if ((NULL == n) && (NULL == dv))
{
GNUNET_STATISTICS_update (GST_stats,
"# Messages dropped in routing: no acceptable
method",
@@ -3443,30 +3424,23 @@ route_message (const struct GNUNET_PeerIdentity *target,
}
/* If both dv and n are possible and we must choose:
flip a coin for the choice between the two; for now 50/50 */
- if ( (NULL != n) &&
- (NULL != dv) &&
- (0 == (options & RMO_REDUNDANT)) )
+ if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
{
if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2))
n = NULL;
else
dv = NULL;
}
- if ( (NULL != n) &&
- (NULL != dv) )
+ if ((NULL != n) && (NULL != dv))
options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
enough for redunancy, so clear the flag. */
if (NULL != n)
{
- route_via_neighbour (n,
- hdr,
- options);
+ route_via_neighbour (n, hdr, options);
}
if (NULL != dv)
{
- route_via_dv (dv,
- hdr,
- options);
+ route_via_dv (dv, hdr, options);
}
GNUNET_free (hdr);
}
@@ -3485,7 +3459,8 @@ struct BackchannelKeyState
/**
* Actual key material.
*/
- struct {
+ struct
+ {
/**
* Key used for HMAC calculations (via #GNUNET_CRYPTO_hmac()).
@@ -3495,12 +3470,12 @@ struct BackchannelKeyState
/**
* Symmetric key to use for encryption.
*/
- char aes_key[256/8];
+ char aes_key[256 / 8];
/**
* Counter value to use during setup.
*/
- char aes_ctr[128/8];
+ char aes_ctr[128 / 8];
} material;
};
@@ -3544,20 +3519,18 @@ bc_setup_key_state_from_km (const struct
GNUNET_HashCode *km,
* @param key[out] set to the key material
*/
static void
-dh_key_derive_eph_pid (const struct GNUNET_CRYPTO_EcdhePrivateKey
*priv_ephemeral,
- const struct GNUNET_PeerIdentity *target,
- const struct GNUNET_ShortHashCode *iv,
- struct BackchannelKeyState *key)
+dh_key_derive_eph_pid (
+ const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ephemeral,
+ const struct GNUNET_PeerIdentity *target,
+ const struct GNUNET_ShortHashCode *iv,
+ struct BackchannelKeyState *key)
{
struct GNUNET_HashCode km;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CRYPTO_ecdh_eddsa (priv_ephemeral,
- &target->public_key,
- &km));
- bc_setup_key_state_from_km (&km,
- iv,
- key);
+ GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_ecdh_eddsa (priv_ephemeral,
+ &target->public_key,
+ &km));
+ bc_setup_key_state_from_km (&km, iv, key);
}
@@ -3577,13 +3550,10 @@ dh_key_derive_eph_pub (const struct
GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral,
{
struct GNUNET_HashCode km;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CRYPTO_eddsa_ecdh (GST_my_private_key,
- pub_ephemeral,
- &km));
- bc_setup_key_state_from_km (&km,
- iv,
- key);
+ GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_eddsa_ecdh (GST_my_private_key,
+ pub_ephemeral,
+ &km));
+ bc_setup_key_state_from_km (&km, iv, key);
}
@@ -3602,10 +3572,7 @@ bc_hmac (const struct BackchannelKeyState *key,
const void *data,
size_t data_size)
{
- GNUNET_CRYPTO_hmac (&key->material.hmac_key,
- data,
- data_size,
- hmac);
+ GNUNET_CRYPTO_hmac (&key->material.hmac_key, data, data_size, hmac);
}
@@ -3625,11 +3592,7 @@ bc_encrypt (struct BackchannelKeyState *key,
size_t in_size)
{
GNUNET_assert (0 ==
- gcry_cipher_encrypt (key->cipher,
- dst,
- in_size,
- in,
- in_size));
+ gcry_cipher_encrypt (key->cipher, dst, in_size, in, in_size));
}
@@ -3648,12 +3611,8 @@ bc_decrypt (struct BackchannelKeyState *key,
const void *ciph,
size_t out_size)
{
- GNUNET_assert (0 ==
- gcry_cipher_decrypt (key->cipher,
- out,
- out_size,
- ciph,
- out_size));
+ GNUNET_assert (
+ 0 == gcry_cipher_decrypt (key->cipher, out, out_size, ciph, out_size));
}
@@ -3666,8 +3625,7 @@ static void
bc_key_clean (struct BackchannelKeyState *key)
{
gcry_cipher_close (key->cipher);
- GNUNET_CRYPTO_zero_keys (&key->material,
- sizeof (key->material));
+ GNUNET_CRYPTO_zero_keys (&key->material, sizeof (key->material));
}
@@ -3678,8 +3636,9 @@ bc_key_clean (struct BackchannelKeyState *key)
* @param cb the send message that was sent
*/
static void
-handle_communicator_backchannel (void *cls,
- const struct
GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
+handle_communicator_backchannel (
+ void *cls,
+ const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
{
struct TransportClient *tc = cls;
struct GNUNET_CRYPTO_EcdhePrivateKey private_key;
@@ -3691,9 +3650,11 @@ handle_communicator_backchannel (void *cls,
uint16_t msize;
/* encapsulate and encrypt message */
- msize = ntohs (cb->header.size) - sizeof (*cb) + sizeof (struct
TransportBackchannelRequestPayload);
+ msize = ntohs (cb->header.size) - sizeof (*cb) +
+ sizeof (struct TransportBackchannelRequestPayload);
enc = GNUNET_malloc (sizeof (*enc) + msize);
- enc->header.type = htons
(GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION);
+ enc->header.type =
+ htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION);
enc->header.size = htons (sizeof (*enc) + msize);
enc->target = cb->pid;
lookup_ephemeral (&cb->pid,
@@ -3704,17 +3665,12 @@ handle_communicator_backchannel (void *cls,
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
&enc->iv,
sizeof (enc->iv));
- dh_key_derive_eph_pid (&private_key,
- &cb->pid,
- &enc->iv,
- &key);
+ dh_key_derive_eph_pid (&private_key, &cb->pid, &enc->iv, &key);
ppay.ephemeral_validity = GNUNET_TIME_absolute_hton (ephemeral_validity);
- ppay.monotonic_time = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_get_monotonic (GST_cfg));
+ ppay.monotonic_time =
+ GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (GST_cfg));
mpos = (char *) &enc[1];
- bc_encrypt (&key,
- &ppay,
- mpos,
- sizeof (ppay));
+ bc_encrypt (&key, &ppay, mpos, sizeof (ppay));
bc_encrypt (&key,
&cb[1],
&mpos[sizeof (ppay)],
@@ -3724,9 +3680,7 @@ handle_communicator_backchannel (void *cls,
mpos,
sizeof (ppay) + ntohs (cb->header.size) - sizeof (*cb));
bc_key_clean (&key);
- route_message (&cb->pid,
- &enc->header,
- RMO_DV_ALLOWED);
+ route_message (&cb->pid, &enc->header, RMO_DV_ALLOWED);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -3770,8 +3724,7 @@ store_pi (void *cls);
* @param success #GNUNET_YES if peerstore was successful
*/
static void
-peerstore_store_own_cb (void *cls,
- int success)
+peerstore_store_own_cb (void *cls, int success)
{
struct AddressListEntry *ale = cls;
@@ -3782,10 +3735,11 @@ peerstore_store_own_cb (void *cls,
ale->address);
/* refresh period is 1/4 of expiration time, that should be plenty
without being excessive. */
- ale->st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide
(ale->expiration,
- 4ULL),
- &store_pi,
- ale);
+ ale->st =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (ale->expiration,
+ 4ULL),
+ &store_pi,
+ ale);
}
@@ -3826,9 +3780,8 @@ store_pi (void *cls)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to store our address `%s' with peerstore\n",
ale->address);
- ale->st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
- &store_pi,
- ale);
+ ale->st =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &store_pi, ale);
}
}
@@ -3854,14 +3807,11 @@ handle_add_address (void *cls,
ale->expiration = GNUNET_TIME_relative_ntoh (aam->expiration);
ale->aid = aam->aid;
ale->nt = (enum GNUNET_NetworkType) ntohl (aam->nt);
- memcpy (&ale[1],
- &aam[1],
- slen);
+ memcpy (&ale[1], &aam[1], slen);
GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
tc->details.communicator.addr_tail,
ale);
- ale->st = GNUNET_SCHEDULER_add_now (&store_pi,
- ale);
+ ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -3949,13 +3899,11 @@ finish_cmc_handling (struct CommunicatorMessageContext
*cmc)
struct GNUNET_MQ_Envelope *env;
struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
- env = GNUNET_MQ_msg (ack,
- GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
+ env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
ack->reserved = htonl (0);
ack->fc_id = cmc->im.fc_id;
ack->sender = cmc->im.sender;
- GNUNET_MQ_send (cmc->tc->mq,
- env);
+ GNUNET_MQ_send (cmc->tc->mq, env);
}
GNUNET_SERVICE_client_continue (cmc->tc->client);
GNUNET_free (cmc);
@@ -3966,18 +3914,18 @@ finish_cmc_handling (struct CommunicatorMessageContext
*cmc)
* Communicator gave us an unencapsulated message to pass as-is to
* CORE. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param mh the message that was received
*/
static void
-handle_raw_message (void *cls,
- const struct GNUNET_MessageHeader *mh)
+handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
{
struct CommunicatorMessageContext *cmc = cls;
uint16_t size = ntohs (mh->size);
- if ( (size > UINT16_MAX - sizeof (struct InboundMessage)) ||
- (size < sizeof (struct GNUNET_MessageHeader)) )
+ if ((size > UINT16_MAX - sizeof (struct InboundMessage)) ||
+ (size < sizeof (struct GNUNET_MessageHeader)))
{
struct GNUNET_SERVICE_Client *client = cmc->tc->client;
@@ -3987,24 +3935,17 @@ handle_raw_message (void *cls,
return;
}
/* Forward to all CORE clients */
- for (struct TransportClient *tc = clients_head;
- NULL != tc;
- tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
struct GNUNET_MQ_Envelope *env;
struct InboundMessage *im;
if (CT_CORE != tc->type)
continue;
- env = GNUNET_MQ_msg_extra (im,
- size,
- GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
+ env = GNUNET_MQ_msg_extra (im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
im->peer = cmc->im.sender;
- memcpy (&im[1],
- mh,
- size);
- GNUNET_MQ_send (tc->mq,
- env);
+ memcpy (&im[1], mh, size);
+ GNUNET_MQ_send (tc->mq, env);
}
/* FIXME: consider doing this _only_ once the message
was drained from the CORE MQs to extend flow control to CORE!
@@ -4021,8 +3962,7 @@ handle_raw_message (void *cls,
* @return #GNUNET_YES if message is well-formed
*/
static int
-check_fragment_box (void *cls,
- const struct TransportFragmentBox *fb)
+check_fragment_box (void *cls, const struct TransportFragmentBox *fb)
{
uint16_t size = ntohs (fb->header.size);
uint16_t bsize = size - sizeof (*fb);
@@ -4064,14 +4004,12 @@ send_fragment_ack (struct ReassemblyContext *rc)
ack->msg_uuid = rc->msg_uuid;
ack->avg_ack_delay = GNUNET_TIME_relative_hton (rc->avg_ack_delay);
if (0 == rc->msg_missing)
- ack->reassembly_timeout
- = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL); /* signal
completion */
+ ack->reassembly_timeout = GNUNET_TIME_relative_hton (
+ GNUNET_TIME_UNIT_FOREVER_REL); /* signal completion */
else
- ack->reassembly_timeout
- = GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining
(rc->reassembly_timeout));
- route_message (&rc->neighbour->pid,
- &ack->header,
- RMO_DV_ALLOWED);
+ ack->reassembly_timeout = GNUNET_TIME_relative_hton (
+ GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout));
+ route_message (&rc->neighbour->pid, &ack->header, RMO_DV_ALLOWED);
rc->avg_ack_delay = GNUNET_TIME_UNIT_ZERO;
rc->num_acks = 0;
rc->extra_acks = 0LLU;
@@ -4081,12 +4019,12 @@ send_fragment_ack (struct ReassemblyContext *rc)
/**
* Communicator gave us a fragment. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param fb the message that was received
*/
static void
-handle_fragment_box (void *cls,
- const struct TransportFragmentBox *fb)
+handle_fragment_box (void *cls, const struct TransportFragmentBox *fb)
{
struct CommunicatorMessageContext *cmc = cls;
struct Neighbour *n;
@@ -4100,8 +4038,7 @@ handle_fragment_box (void *cls,
struct GNUNET_TIME_Relative cdelay;
int ack_now;
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- &cmc->im.sender);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, &cmc->im.sender);
if (NULL == n)
{
struct GNUNET_SERVICE_Client *client = cmc->tc->client;
@@ -4113,34 +4050,35 @@ handle_fragment_box (void *cls,
}
if (NULL == n->reassembly_map)
{
- n->reassembly_map = GNUNET_CONTAINER_multishortmap_create (8,
- GNUNET_YES);
- n->reassembly_heap = GNUNET_CONTAINER_heap_create
(GNUNET_CONTAINER_HEAP_ORDER_MIN);
- n->reassembly_timeout_task = GNUNET_SCHEDULER_add_delayed
(REASSEMBLY_EXPIRATION,
-
&reassembly_cleanup_task,
- n);
+ n->reassembly_map = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_YES);
+ n->reassembly_heap =
+ GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ n->reassembly_timeout_task =
+ GNUNET_SCHEDULER_add_delayed (REASSEMBLY_EXPIRATION,
+ &reassembly_cleanup_task,
+ n);
}
msize = ntohs (fb->msg_size);
- rc = GNUNET_CONTAINER_multishortmap_get (n->reassembly_map,
- &fb->msg_uuid);
+ rc = GNUNET_CONTAINER_multishortmap_get (n->reassembly_map, &fb->msg_uuid);
if (NULL == rc)
{
- rc = GNUNET_malloc (sizeof (*rc) +
- msize + /* reassembly payload buffer */
- (msize + 7) / 8 * sizeof (uint8_t) /* bitfield */);
+ rc = GNUNET_malloc (sizeof (*rc) + msize + /* reassembly payload buffer */
+ (msize + 7) / 8 * sizeof (uint8_t) /* bitfield */);
rc->msg_uuid = fb->msg_uuid;
rc->neighbour = n;
rc->msg_size = msize;
- rc->reassembly_timeout = GNUNET_TIME_relative_to_absolute
(REASSEMBLY_EXPIRATION);
+ rc->reassembly_timeout =
+ GNUNET_TIME_relative_to_absolute (REASSEMBLY_EXPIRATION);
rc->last_frag = GNUNET_TIME_absolute_get ();
rc->hn = GNUNET_CONTAINER_heap_insert (n->reassembly_heap,
rc,
rc->reassembly_timeout.abs_value_us);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multishortmap_put (n->reassembly_map,
- &rc->msg_uuid,
- rc,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multishortmap_put (
+ n->reassembly_map,
+ &rc->msg_uuid,
+ rc,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
target = (char *) &rc[1];
rc->bitfield = (uint8_t *) (target + rc->msg_size);
rc->msg_missing = rc->msg_size;
@@ -4159,11 +4097,9 @@ handle_fragment_box (void *cls,
/* reassemble */
fsize = ntohs (fb->header.size) - sizeof (*fb);
frag_off = ntohs (fb->frag_off);
- memcpy (&target[frag_off],
- &fb[1],
- fsize);
+ memcpy (&target[frag_off], &fb[1], fsize);
/* update bitfield and msg_missing */
- for (unsigned int i=frag_off;i<frag_off+fsize;i++)
+ for (unsigned int i = frag_off; i < frag_off + fsize; i++)
{
if (0 == (rc->bitfield[i / 8] & (1 << (i % 8))))
{
@@ -4175,11 +4111,9 @@ handle_fragment_box (void *cls,
/* Compute cummulative ACK */
frag_uuid = ntohl (fb->frag_uuid);
cdelay = GNUNET_TIME_absolute_get_duration (rc->last_frag);
- cdelay = GNUNET_TIME_relative_multiply (cdelay,
- rc->num_acks);
+ cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->num_acks);
rc->last_frag = GNUNET_TIME_absolute_get ();
- rc->avg_ack_delay = GNUNET_TIME_relative_add (rc->avg_ack_delay,
- cdelay);
+ rc->avg_ack_delay = GNUNET_TIME_relative_add (rc->avg_ack_delay, cdelay);
ack_now = GNUNET_NO;
if (0 == rc->num_acks)
{
@@ -4188,12 +4122,11 @@ handle_fragment_box (void *cls,
rc->extra_acks = 0LLU;
rc->num_acks = 1;
}
- else if ( (frag_uuid >= rc->frag_uuid) &&
- (frag_uuid <= rc->frag_uuid + 64) )
+ else if ((frag_uuid >= rc->frag_uuid) && (frag_uuid <= rc->frag_uuid + 64))
{
/* case two: ack fits after existing min UUID */
- if ( (frag_uuid == rc->frag_uuid) ||
- (0 != (rc->extra_acks & (1LLU << (frag_uuid - rc->frag_uuid - 1)))) )
+ if ((frag_uuid == rc->frag_uuid) ||
+ (0 != (rc->extra_acks & (1LLU << (frag_uuid - rc->frag_uuid - 1)))))
{
/* duplicate fragment, ack now! */
ack_now = GNUNET_YES;
@@ -4204,11 +4137,12 @@ handle_fragment_box (void *cls,
rc->num_acks++;
}
}
- else if ( (rc->frag_uuid > frag_uuid) &&
- ( ( (rc->frag_uuid == frag_uuid + 64) &&
- (0 == rc->extra_acks) ) ||
- ( (rc->frag_uuid < frag_uuid + 64) &&
- (rc->extra_acks == (rc->extra_acks & ~ ((1LLU << (64 -
(rc->frag_uuid - frag_uuid))) - 1LLU))) ) ) )
+ else if ((rc->frag_uuid > frag_uuid) &&
+ (((rc->frag_uuid == frag_uuid + 64) && (0 == rc->extra_acks)) ||
+ ((rc->frag_uuid < frag_uuid + 64) &&
+ (rc->extra_acks ==
+ (rc->extra_acks &
+ ~((1LLU << (64 - (rc->frag_uuid - frag_uuid))) - 1LLU))))))
{
/* can fit ack by shifting extra acks and starting at
frag_uid, test above esured that the bits we will
@@ -4218,7 +4152,8 @@ handle_fragment_box (void *cls,
rc->frag_uuid = frag_uuid;
rc->num_acks++;
}
- if (65 == rc->num_acks) /* FIXME: maybe use smaller threshold? This is very
aggressive. */
+ if (65 == rc->num_acks) /* FIXME: maybe use smaller threshold? This is very
+ aggressive. */
ack_now = GNUNET_YES; /* maximum acks received */
// FIXME: possibly also ACK based on RTT (but for that we'd need to
// determine the queue used for the ACK first!)
@@ -4242,8 +4177,7 @@ handle_fragment_box (void *cls,
}
/* successful reassembly */
send_fragment_ack (rc);
- demultiplex_with_cmc (cmc,
- msg);
+ demultiplex_with_cmc (cmc, msg);
/* FIXME: really free here? Might be bad if fragments are still
en-route and we forget that we finished this reassembly immediately!
-> keep around until timeout?
@@ -4271,21 +4205,17 @@ check_ack_against_pm (struct PendingMessage *pm,
uint64_t xtra = GNUNET_ntohll (fa->extra_acks);
match = GNUNET_NO;
- for (struct PendingMessage *frag = pm->head_frag;
- NULL != frag;
- frag = nxt)
+ for (struct PendingMessage *frag = pm->head_frag; NULL != frag; frag = nxt)
{
- const struct TransportFragmentBox *tfb
- = (const struct TransportFragmentBox *) &pm[1];
+ const struct TransportFragmentBox *tfb =
+ (const struct TransportFragmentBox *) &pm[1];
uint32_t fu = ntohl (tfb->frag_uuid);
GNUNET_assert (PMT_FRAGMENT_BOX == frag->pmt);
nxt = frag->next_frag;
/* Check for exact match or match in the 'xtra' bitmask */
- if ( (fu == fs) ||
- ( (fu > fs) &&
- (fu <= fs + 64) &&
- (0 != (1LLU << (fu - fs - 1) & xtra)) ) )
+ if ((fu == fs) ||
+ ((fu > fs) && (fu <= fs + 64) && (0 != (1LLU << (fu - fs - 1) &
xtra))))
{
match = GNUNET_YES;
free_fragment_tree (frag);
@@ -4298,19 +4228,18 @@ check_ack_against_pm (struct PendingMessage *pm,
/**
* Communicator gave us a fragment acknowledgement. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param fa the message that was received
*/
static void
-handle_fragment_ack (void *cls,
- const struct TransportFragmentAckMessage *fa)
+handle_fragment_ack (void *cls, const struct TransportFragmentAckMessage *fa)
{
struct CommunicatorMessageContext *cmc = cls;
struct Neighbour *n;
int matched;
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- &cmc->im.sender);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, &cmc->im.sender);
if (NULL == n)
{
struct GNUNET_SERVICE_Client *client = cmc->tc->client;
@@ -4322,21 +4251,16 @@ handle_fragment_ack (void *cls,
}
/* FIXME-OPTIMIZE: maybe use another hash map here? */
matched = GNUNET_NO;
- for (struct PendingMessage *pm = n->pending_msg_head;
- NULL != pm;
+ for (struct PendingMessage *pm = n->pending_msg_head; NULL != pm;
pm = pm->prev_neighbour)
{
- if (0 !=
- GNUNET_memcmp (&fa->msg_uuid,
- &pm->msg_uuid))
+ if (0 != GNUNET_memcmp (&fa->msg_uuid, &pm->msg_uuid))
continue;
matched = GNUNET_YES;
- if (GNUNET_YES ==
- check_ack_against_pm (pm,
- fa))
+ if (GNUNET_YES == check_ack_against_pm (pm, fa))
{
- struct GNUNET_TIME_Relative avg_ack_delay
- = GNUNET_TIME_relative_ntoh (fa->avg_ack_delay);
+ struct GNUNET_TIME_Relative avg_ack_delay =
+ GNUNET_TIME_relative_ntoh (fa->avg_ack_delay);
// FIXME: update RTT and other reliability data!
// ISSUE: we don't know which of n's queues the message(s)
// took (and in fact the different messages might have gone
@@ -4365,9 +4289,10 @@ handle_fragment_ack (void *cls,
}
else
{
- struct GNUNET_TIME_Relative reassembly_timeout
- = GNUNET_TIME_relative_ntoh (fa->reassembly_timeout);
- // OPTIMIZE-FIXME: adjust retransmission strategy based on
reassembly_timeout!
+ struct GNUNET_TIME_Relative reassembly_timeout =
+ GNUNET_TIME_relative_ntoh (fa->reassembly_timeout);
+ // OPTIMIZE-FIXME: adjust retransmission strategy based on
+ // reassembly_timeout!
(void) reassembly_timeout;
}
break;
@@ -4391,8 +4316,7 @@ handle_fragment_ack (void *cls,
* @return #GNUNET_YES if message is well-formed
*/
static int
-check_reliability_box (void *cls,
- const struct TransportReliabilityBox *rb)
+check_reliability_box (void *cls, const struct TransportReliabilityBox *rb)
{
GNUNET_MQ_check_boxed_message (rb);
return GNUNET_YES;
@@ -4402,15 +4326,16 @@ check_reliability_box (void *cls,
/**
* Communicator gave us a reliability box. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param rb the message that was received
*/
static void
-handle_reliability_box (void *cls,
- const struct TransportReliabilityBox *rb)
+handle_reliability_box (void *cls, const struct TransportReliabilityBox *rb)
{
struct CommunicatorMessageContext *cmc = cls;
- const struct GNUNET_MessageHeader *inbox = (const struct
GNUNET_MessageHeader *) &rb[1];
+ const struct GNUNET_MessageHeader *inbox =
+ (const struct GNUNET_MessageHeader *) &rb[1];
if (0 == ntohl (rb->ack_countdown))
{
@@ -4418,28 +4343,23 @@ handle_reliability_box (void *cls,
/* FIXME: implement cummulative ACKs and ack_countdown,
then setting the avg_ack_delay field below: */
- ack = GNUNET_malloc (sizeof (*ack) +
- sizeof (struct GNUNET_ShortHashCode));
+ ack = GNUNET_malloc (sizeof (*ack) + sizeof (struct GNUNET_ShortHashCode));
ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK);
- ack->header.size = htons (sizeof (*ack) +
- sizeof (struct GNUNET_ShortHashCode));
- memcpy (&ack[1],
- &rb->msg_uuid,
- sizeof (struct GNUNET_ShortHashCode));
- route_message (&cmc->im.sender,
- &ack->header,
- RMO_DV_ALLOWED);
+ ack->header.size =
+ htons (sizeof (*ack) + sizeof (struct GNUNET_ShortHashCode));
+ memcpy (&ack[1], &rb->msg_uuid, sizeof (struct GNUNET_ShortHashCode));
+ route_message (&cmc->im.sender, &ack->header, RMO_DV_ALLOWED);
}
/* continue with inner message */
- demultiplex_with_cmc (cmc,
- inbox);
+ demultiplex_with_cmc (cmc, inbox);
}
/**
* Communicator gave us a reliability ack. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param ra the message that was received
*/
static void
@@ -4453,8 +4373,7 @@ handle_reliability_ack (void *cls,
struct PendingMessage *nxt;
int matched;
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- &cmc->im.sender);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, &cmc->im.sender);
if (NULL == n)
{
struct GNUNET_SERVICE_Client *client = cmc->tc->client;
@@ -4464,25 +4383,21 @@ handle_reliability_ack (void *cls,
GNUNET_SERVICE_client_drop (client);
return;
}
- n_acks = (ntohs (ra->header.size) - sizeof (*ra))
- / sizeof (struct GNUNET_ShortHashCode);
+ n_acks = (ntohs (ra->header.size) - sizeof (*ra)) /
+ sizeof (struct GNUNET_ShortHashCode);
msg_uuids = (const struct GNUNET_ShortHashCode *) &ra[1];
/* FIXME-OPTIMIZE: maybe use another hash map here? */
matched = GNUNET_NO;
- for (struct PendingMessage *pm = n->pending_msg_head;
- NULL != pm;
- pm = nxt)
+ for (struct PendingMessage *pm = n->pending_msg_head; NULL != pm; pm = nxt)
{
int in_list;
nxt = pm->next_neighbour;
in_list = GNUNET_NO;
- for (unsigned int i=0;i<n_acks;i++)
+ for (unsigned int i = 0; i < n_acks; i++)
{
- if (0 !=
- GNUNET_memcmp (&msg_uuids[i],
- &pm->msg_uuid))
+ if (0 != GNUNET_memcmp (&msg_uuids[i], &pm->msg_uuid))
continue;
in_list = GNUNET_YES;
break;
@@ -4495,8 +4410,8 @@ handle_reliability_ack (void *cls,
free_pending_message (pm);
{
- struct GNUNET_TIME_Relative avg_ack_delay
- = GNUNET_TIME_relative_ntoh (ra->avg_ack_delay);
+ struct GNUNET_TIME_Relative avg_ack_delay =
+ GNUNET_TIME_relative_ntoh (ra->avg_ack_delay);
// FIXME: update RTT and other reliability data!
// ISSUE: we don't know which of n's queues the message(s)
// took (and in fact the different messages might have gone
@@ -4528,15 +4443,16 @@ handle_reliability_ack (void *cls,
* @return #GNUNET_YES if message is well-formed
*/
static int
-check_backchannel_encapsulation (void *cls,
- const struct
TransportBackchannelEncapsulationMessage *be)
+check_backchannel_encapsulation (
+ void *cls,
+ const struct TransportBackchannelEncapsulationMessage *be)
{
uint16_t size = ntohs (be->header.size);
(void) cls;
- if (size - sizeof (*be) <
- sizeof (struct TransportBackchannelRequestPayload) +
- sizeof (struct GNUNET_MessageHeader) )
+ if ((size - sizeof (*be)) <
+ (sizeof (struct TransportBackchannelRequestPayload) +
+ sizeof (struct GNUNET_MessageHeader)))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
@@ -4550,12 +4466,14 @@ check_backchannel_encapsulation (void *cls,
* (We are not the origin of the backchannel here, the communicator simply
* received a backchannel message and we are expected to forward it.)
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param be the message that was received
*/
static void
-handle_backchannel_encapsulation (void *cls,
- const struct
TransportBackchannelEncapsulationMessage *be)
+handle_backchannel_encapsulation (
+ void *cls,
+ const struct TransportBackchannelEncapsulationMessage *be)
{
struct CommunicatorMessageContext *cmc = cls;
struct BackchannelKeyState key;
@@ -4563,8 +4481,7 @@ handle_backchannel_encapsulation (void *cls,
const char *hdr;
size_t hdr_len;
- if (0 != GNUNET_memcmp (&be->target,
- &GST_my_identity))
+ if (0 != GNUNET_memcmp (&be->target, &GST_my_identity))
{
/* not for me, try to route to target */
/* FIXME: someone needs to update be->distance! */
@@ -4576,18 +4493,11 @@ handle_backchannel_encapsulation (void *cls,
finish_cmc_handling (cmc);
return;
}
- dh_key_derive_eph_pub (&be->ephemeral_key,
- &be->iv,
- &key);
+ dh_key_derive_eph_pub (&be->ephemeral_key, &be->iv, &key);
hdr = (const char *) &be[1];
hdr_len = ntohs (be->header.size) - sizeof (*be);
- bc_hmac (&key,
- &hmac,
- hdr,
- hdr_len);
- if (0 !=
- GNUNET_memcmp (&hmac,
- &be->hmac))
+ bc_hmac (&key, &hmac, hdr, hdr_len);
+ if (0 != GNUNET_memcmp (&hmac, &be->hmac))
{
/* HMAC missmatch, disard! */
GNUNET_break_op (0);
@@ -4599,15 +4509,10 @@ handle_backchannel_encapsulation (void *cls,
struct TransportBackchannelRequestPayload ppay;
char body[hdr_len - sizeof (ppay)];
- GNUNET_assert (hdr_len >= sizeof (ppay) + sizeof (struct
GNUNET_MessageHeader));
- bc_decrypt (&key,
- &ppay,
- hdr,
- sizeof (ppay));
- bc_decrypt (&key,
- &body,
- &hdr[sizeof (ppay)],
- hdr_len - sizeof (ppay));
+ GNUNET_assert (hdr_len >=
+ sizeof (ppay) + sizeof (struct GNUNET_MessageHeader));
+ bc_decrypt (&key, &ppay, hdr, sizeof (ppay));
+ bc_decrypt (&key, &body, &hdr[sizeof (ppay)], hdr_len - sizeof (ppay));
bc_key_clean (&key);
// FIXME: verify signatures in ppay!
// => check if ephemeral key is known & valid, if not
@@ -4649,9 +4554,8 @@ path_cleanup_cb (void *cls)
free_dv_route (dv);
return;
}
- dv->timeout_task = GNUNET_SCHEDULER_add_at (pos->timeout,
- &path_cleanup_cb,
- dv);
+ dv->timeout_task =
+ GNUNET_SCHEDULER_add_at (pos->timeout, &path_cleanup_cb, dv);
}
@@ -4670,8 +4574,8 @@ path_cleanup_cb (void *cls)
* and then path contains a valid path from us to
`path[path_len-1]`
* path[1] should be a direct neighbour (we should check!)
* @param path_len number of entries on the @a path, at least three!
- * @param network_latency how long does the message take from us to
`path[path_len-1]`?
- * set to "forever" if unknown
+ * @param network_latency how long does the message take from us to
+ * `path[path_len-1]`? set to "forever" if unknown
* @return #GNUNET_YES on success,
* #GNUNET_NO if we have better path(s) to the target
* #GNUNET_SYSERR if the path is useless and/or invalid
@@ -4694,29 +4598,23 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
GNUNET_break (0);
return GNUNET_SYSERR;
}
- GNUNET_assert (0 ==
- GNUNET_memcmp (&GST_my_identity,
- &path[0]));
- next_hop = GNUNET_CONTAINER_multipeermap_get (neighbours,
- &path[1]);
+ GNUNET_assert (0 == GNUNET_memcmp (&GST_my_identity, &path[0]));
+ next_hop = GNUNET_CONTAINER_multipeermap_get (neighbours, &path[1]);
if (NULL == next_hop)
{
/* next hop must be a neighbour, otherwise this whole thing is useless! */
GNUNET_break (0);
return GNUNET_SYSERR;
}
- for (unsigned int i=2;i<path_len;i++)
- if (NULL !=
- GNUNET_CONTAINER_multipeermap_get (neighbours,
- &path[i]))
+ for (unsigned int i = 2; i < path_len; i++)
+ if (NULL != GNUNET_CONTAINER_multipeermap_get (neighbours, &path[i]))
{
/* Useless path, we have a direct connection to some hop
in the middle of the path, so this one doesn't even
seem terribly useful for redundancy */
return GNUNET_SYSERR;
}
- dv = GNUNET_CONTAINER_multipeermap_get (dv_routes,
- &path[path_len - 1]);
+ dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &path[path_len - 1]);
if (NULL == dv)
{
dv = GNUNET_new (struct DistanceVector);
@@ -4725,15 +4623,15 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
&path_cleanup_cb,
dv);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (dv_routes,
- &dv->target,
- dv,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ dv_routes,
+ &dv->target,
+ dv,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
}
/* Check if we have this path already! */
shorter_distance = 0;
- for (struct DistanceVectorHop *pos = dv->dv_head;
- NULL != pos;
+ for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
pos = pos->next_dv)
{
if (pos->distance < path_len - 2)
@@ -4741,16 +4639,13 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
/* Note that the distances in 'pos' excludes us (path[0]) and
the next_hop (path[1]), so we need to subtract two
and check next_hop explicitly */
- if ( (pos->distance == path_len - 2) &&
- (pos->next_hop == next_hop) )
+ if ((pos->distance == path_len - 2) && (pos->next_hop == next_hop))
{
int match = GNUNET_YES;
- for (unsigned int i=0;i<pos->distance;i++)
+ for (unsigned int i = 0; i < pos->distance; i++)
{
- if (0 !=
- GNUNET_memcmp (&pos->path[i],
- &path[i+2]))
+ if (0 != GNUNET_memcmp (&pos->path[i], &path[i + 2]))
{
match = GNUNET_NO;
break;
@@ -4766,19 +4661,14 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
1,
GNUNET_NO);
last_timeout = GNUNET_TIME_absolute_get_remaining (pos->timeout);
- pos->timeout
- = GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
- GNUNET_CONTAINER_MDLL_remove (dv,
- dv->dv_head,
- dv->dv_tail,
- pos);
- GNUNET_CONTAINER_MDLL_insert (dv,
- dv->dv_head,
- dv->dv_tail,
- pos);
+ pos->timeout =
+ GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
+ GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, pos);
+ GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, pos);
if (last_timeout.rel_value_us <
GNUNET_TIME_relative_subtract (DV_PATH_VALIDITY_TIMEOUT,
-
DV_PATH_DISCOVERY_FREQUENCY).rel_value_us)
+ DV_PATH_DISCOVERY_FREQUENCY)
+ .rel_value_us)
{
/* Some peer send DV learn messages too often, we are learning
the same path faster than it would be useful; do not forward! */
@@ -4806,10 +4696,7 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
sizeof (struct GNUNET_PeerIdentity) * (path_len - 2));
hop->timeout = GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
hop->distance = path_len - 2;
- GNUNET_CONTAINER_MDLL_insert (dv,
- dv->dv_head,
- dv->dv_tail,
- hop);
+ GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, hop);
GNUNET_CONTAINER_MDLL_insert (neighbour,
next_hop->dv_head,
next_hop->dv_tail,
@@ -4826,8 +4713,7 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path,
* @return #GNUNET_YES if message is well-formed
*/
static int
-check_dv_learn (void *cls,
- const struct TransportDVLearn *dvl)
+check_dv_learn (void *cls, const struct TransportDVLearn *dvl)
{
uint16_t size = ntohs (dvl->header.size);
uint16_t num_hops = ntohs (dvl->num_hops);
@@ -4844,16 +4730,14 @@ check_dv_learn (void *cls,
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- for (unsigned int i=0;i<num_hops;i++)
+ for (unsigned int i = 0; i < num_hops; i++)
{
- if (0 == GNUNET_memcmp (&dvl->initiator,
- &hops[i].hop))
+ if (0 == GNUNET_memcmp (&dvl->initiator, &hops[i].hop))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- if (0 == GNUNET_memcmp (&GST_my_identity,
- &hops[i].hop))
+ if (0 == GNUNET_memcmp (&GST_my_identity, &hops[i].hop))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
@@ -4871,7 +4755,8 @@ check_dv_learn (void *cls,
* @param bi_history bitmask specifying hops on path that were bidirectional
* @param nhops length of the @a hops array
* @param hops path the message traversed so far
- * @param in_time when did we receive the message, used to calculate network
delay
+ * @param in_time when did we receive the message, used to calculate network
+ * delay
*/
static void
forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop,
@@ -4895,33 +4780,29 @@ forward_dv_learn (const struct GNUNET_PeerIdentity
*next_hop,
fwd->num_hops = htons (nhops + 1);
fwd->bidirectional = htons (bi_history);
nnd = GNUNET_TIME_relative_add (GNUNET_TIME_absolute_get_duration (in_time),
- GNUNET_TIME_relative_ntoh
(msg->non_network_delay));
+ GNUNET_TIME_relative_ntoh (
+ msg->non_network_delay));
fwd->non_network_delay = GNUNET_TIME_relative_hton (nnd);
fwd->init_sig = msg->init_sig;
fwd->initiator = msg->initiator;
fwd->challenge = msg->challenge;
dhops = (struct DVPathEntryP *) &fwd[1];
- GNUNET_memcpy (dhops,
- hops,
- sizeof (struct DVPathEntryP) * nhops);
+ GNUNET_memcpy (dhops, hops, sizeof (struct DVPathEntryP) * nhops);
dhops[nhops].hop = GST_my_identity;
{
- struct DvHopPS dhp = {
- .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
- .purpose.size = htonl (sizeof (dhp)),
- .pred = dhops[nhops-1].hop,
- .succ = *next_hop,
- .challenge = msg->challenge
- };
+ struct DvHopPS dhp = {.purpose.purpose =
+ htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
+ .purpose.size = htonl (sizeof (dhp)),
+ .pred = dhops[nhops - 1].hop,
+ .succ = *next_hop,
+ .challenge = msg->challenge};
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
&dhp.purpose,
&dhops[nhops].hop_sig));
}
- route_message (next_hop,
- &fwd->header,
- RMO_UNCONFIRMED_ALLOWED);
+ route_message (next_hop, &fwd->header, RMO_UNCONFIRMED_ALLOWED);
}
@@ -4934,21 +4815,22 @@ forward_dv_learn (const struct GNUNET_PeerIdentity
*next_hop,
* @return #GNUNET_OK if the signature is valid
*/
static int
-validate_dv_initiator_signature (const struct GNUNET_PeerIdentity *init,
- const struct GNUNET_ShortHashCode *challenge,
- const struct GNUNET_CRYPTO_EddsaSignature
*init_sig)
-{
- struct DvInitPS ip = {
- .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
- .purpose.size = htonl (sizeof (ip)),
- .challenge = *challenge
- };
-
- if (GNUNET_OK !=
- GNUNET_CRYPTO_eddsa_verify
(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR,
- &ip.purpose,
- init_sig,
- &init->public_key))
+validate_dv_initiator_signature (
+ const struct GNUNET_PeerIdentity *init,
+ const struct GNUNET_ShortHashCode *challenge,
+ const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
+{
+ struct DvInitPS ip = {.purpose.purpose = htonl (
+ GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
+ .purpose.size = htonl (sizeof (ip)),
+ .challenge = *challenge};
+
+ if (
+ GNUNET_OK !=
+ GNUNET_CRYPTO_eddsa_verify
(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR,
+ &ip.purpose,
+ init_sig,
+ &init->public_key))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
@@ -4960,12 +4842,12 @@ validate_dv_initiator_signature (const struct
GNUNET_PeerIdentity *init,
/**
* Communicator gave us a DV learn message. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param dvl the message that was received
*/
static void
-handle_dv_learn (void *cls,
- const struct TransportDVLearn *dvl)
+handle_dv_learn (void *cls, const struct TransportDVLearn *dvl)
{
struct CommunicatorMessageContext *cmc = cls;
enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
@@ -4983,8 +4865,7 @@ handle_dv_learn (void *cls,
if (0 == nhops)
{
/* sanity check */
- if (0 != GNUNET_memcmp (&dvl->initiator,
- &cmc->im.sender))
+ if (0 != GNUNET_memcmp (&dvl->initiator, &cmc->im.sender))
{
GNUNET_break (0);
finish_cmc_handling (cmc);
@@ -4994,8 +4875,7 @@ handle_dv_learn (void *cls,
else
{
/* sanity check */
- if (0 != GNUNET_memcmp (&hops[nhops - 1].hop,
- &cmc->im.sender))
+ if (0 != GNUNET_memcmp (&hops[nhops - 1].hop, &cmc->im.sender))
{
GNUNET_break (0);
finish_cmc_handling (cmc);
@@ -5005,7 +4885,8 @@ handle_dv_learn (void *cls,
GNUNET_assert (CT_COMMUNICATOR == cmc->tc->type);
cc = cmc->tc->details.communicator.cc;
- bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE == cc); // FIXME: add bi-directional
flag to cc?
+ bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE ==
+ cc); // FIXME: add bi-directional flag to cc?
in_time = GNUNET_TIME_absolute_get ();
/* continue communicator here, everything else can happen asynchronous! */
@@ -5013,20 +4894,19 @@ handle_dv_learn (void *cls,
/* OPTIMIZE-FIXME: Technically, we only need to bother checking
the initiator signature if we send the message back to the initiator... */
- if (GNUNET_OK !=
- validate_dv_initiator_signature (&dvl->initiator,
- &dvl->challenge,
- &dvl->init_sig))
+ if (GNUNET_OK != validate_dv_initiator_signature (&dvl->initiator,
+ &dvl->challenge,
+ &dvl->init_sig))
{
GNUNET_break_op (0);
return;
}
// FIXME: asynchronously (!) verify hop-by-hop signatures!
- // => if signature verification load too high, implement random drop
strategy!?
+ // => if signature verification load too high, implement random drop
+ // strategy!?
do_fwd = GNUNET_YES;
- if (0 == GNUNET_memcmp (&GST_my_identity,
- &dvl->initiator))
+ if (0 == GNUNET_memcmp (&GST_my_identity, &dvl->initiator))
{
struct GNUNET_PeerIdentity path[nhops + 1];
struct GNUNET_TIME_Relative host_latency_sum;
@@ -5043,27 +4923,22 @@ handle_dv_learn (void *cls,
latency = GNUNET_TIME_UNIT_FOREVER_REL; // FIXME: initialize properly
// (based on dvl->challenge, we can identify time of origin!)
- network_latency = GNUNET_TIME_relative_subtract (latency,
- host_latency_sum);
+ network_latency = GNUNET_TIME_relative_subtract (latency,
host_latency_sum);
/* assumption: latency on all links is the same */
- network_latency = GNUNET_TIME_relative_divide (network_latency,
- nhops);
+ network_latency = GNUNET_TIME_relative_divide (network_latency, nhops);
- for (unsigned int i=2;i<=nhops;i++)
+ for (unsigned int i = 2; i <= nhops; i++)
{
struct GNUNET_TIME_Relative ilat;
/* assumption: linear latency increase per hop */
- ilat = GNUNET_TIME_relative_multiply (network_latency,
- i);
- path[i] = hops[i-1].hop;
+ ilat = GNUNET_TIME_relative_multiply (network_latency, i);
+ path[i] = hops[i - 1].hop;
// FIXME: mark ALL of these as *confirmed* (with what timeout?)
// -- and schedule a job for the confirmation to time out! --
// and possibly do #cores_send_connect_info() if
// the respective neighbour is NOT confirmed yet!
- learn_dv_path (path,
- i,
- ilat);
+ learn_dv_path (path, i, ilat);
}
/* as we initiated, do not forward again (would be circular!) */
do_fwd = GNUNET_NO;
@@ -5076,7 +4951,7 @@ handle_dv_learn (void *cls,
path[0] = GST_my_identity;
path[1] = hops[nhops - 1].hop; /* direct neighbour == predecessor! */
- for (unsigned int i=0;i<nhops;i++)
+ for (unsigned int i = 0; i < nhops; i++)
{
int iret;
@@ -5091,9 +4966,7 @@ handle_dv_learn (void *cls,
path[i + 2] = hops[nhops - i - 2].hop;
}
- iret = learn_dv_path (path,
- i + 2,
- GNUNET_TIME_UNIT_FOREVER_REL);
+ iret = learn_dv_path (path, i + 2, GNUNET_TIME_UNIT_FOREVER_REL);
if (GNUNET_SYSERR == iret)
{
/* path invalid or too long to be interesting for US, thus should also
@@ -5107,8 +4980,7 @@ handle_dv_learn (void *cls,
do_fwd = GNUNET_NO;
break;
}
- if ( (GNUNET_NO == iret) &&
- (nhops == i + 1) )
+ if ((GNUNET_NO == iret) && (nhops == i + 1))
{
/* we have better paths, and this is the longest target,
so there cannot be anything interesting later */
@@ -5132,27 +5004,20 @@ handle_dv_learn (void *cls,
/* Forward to initiator, if path non-trivial and possible */
bi_history = (bi_history << 1) | (bi_hop ? 1 : 0);
did_initiator = GNUNET_NO;
- if ( (1 < nhops) &&
- (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains (neighbours,
- &dvl->initiator)) )
+ if ((1 < nhops) &&
+ (GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_contains (neighbours, &dvl->initiator)))
{
/* send back to origin! */
- forward_dv_learn (&dvl->initiator,
- dvl,
- bi_history,
- nhops,
- hops,
- in_time);
+ forward_dv_learn (&dvl->initiator, dvl, bi_history, nhops, hops, in_time);
did_initiator = GNUNET_YES;
}
/* We forward under two conditions: either we still learned something
ourselves (do_fwd), or the path was darn short and thus the initiator is
likely to still be very interested in this (and we did NOT already
send it back to the initiator) */
- if ( (do_fwd) ||
- ( (nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
- (GNUNET_NO == did_initiator) ) )
+ if ((do_fwd) || ((nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
+ (GNUNET_NO == did_initiator)))
{
/* FIXME: loop over all neighbours, pick those with low
queues AND that are not yet on the path; possibly
@@ -5177,38 +5042,39 @@ handle_dv_learn (void *cls,
* @return #GNUNET_YES if message is well-formed
*/
static int
-check_dv_box (void *cls,
- const struct TransportDVBox *dvb)
+check_dv_box (void *cls, const struct TransportDVBox *dvb)
{
uint16_t size = ntohs (dvb->header.size);
uint16_t num_hops = ntohs (dvb->num_hops);
- const struct GNUNET_PeerIdentity *hops = (const struct GNUNET_PeerIdentity
*) &dvb[1];
- const struct GNUNET_MessageHeader *inbox = (const struct
GNUNET_MessageHeader *) &hops[num_hops];
+ const struct GNUNET_PeerIdentity *hops =
+ (const struct GNUNET_PeerIdentity *) &dvb[1];
+ const struct GNUNET_MessageHeader *inbox =
+ (const struct GNUNET_MessageHeader *) &hops[num_hops];
uint16_t isize;
uint16_t itype;
(void) cls;
- if (size < sizeof (*dvb) + num_hops * sizeof (struct GNUNET_PeerIdentity) +
sizeof (struct GNUNET_MessageHeader))
+ if (size < sizeof (*dvb) + num_hops * sizeof (struct GNUNET_PeerIdentity) +
+ sizeof (struct GNUNET_MessageHeader))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
isize = ntohs (inbox->size);
- if (size != sizeof (*dvb) + num_hops * sizeof (struct GNUNET_PeerIdentity) +
isize)
+ if (size !=
+ sizeof (*dvb) + num_hops * sizeof (struct GNUNET_PeerIdentity) + isize)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
itype = ntohs (inbox->type);
- if ( (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX == itype) ||
- (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN == itype) )
+ if ((GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX == itype) ||
+ (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN == itype))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- if (0 ==
- GNUNET_memcmp (&dvb->origin,
- &GST_my_identity))
+ if (0 == GNUNET_memcmp (&dvb->origin, &GST_my_identity))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
@@ -5241,74 +5107,66 @@ forward_dv_box (struct Neighbour *next_hop,
struct TransportDVBox *dvb;
struct GNUNET_PeerIdentity *dhops;
- GNUNET_assert (UINT16_MAX <
- sizeof (struct TransportDVBox) +
- sizeof (struct GNUNET_PeerIdentity) * num_hops +
- payload_size);
+ GNUNET_assert (UINT16_MAX < sizeof (struct TransportDVBox) +
+ sizeof (struct GNUNET_PeerIdentity) * num_hops
+
+ payload_size);
dvb = GNUNET_malloc (sizeof (struct TransportDVBox) +
sizeof (struct GNUNET_PeerIdentity) * num_hops +
payload_size);
- dvb->header.size = htons (sizeof (struct TransportDVBox) +
- sizeof (struct GNUNET_PeerIdentity) * num_hops +
- payload_size);
+ dvb->header.size =
+ htons (sizeof (struct TransportDVBox) +
+ sizeof (struct GNUNET_PeerIdentity) * num_hops + payload_size);
dvb->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
dvb->total_hops = htons (total_hops);
dvb->num_hops = htons (num_hops);
dvb->origin = *origin;
dhops = (struct GNUNET_PeerIdentity *) &dvb[1];
- memcpy (dhops,
- hops,
- num_hops * sizeof (struct GNUNET_PeerIdentity));
- memcpy (&dhops[num_hops],
- payload,
- payload_size);
- route_message (&next_hop->pid,
- &dvb->header,
- RMO_NONE);
+ memcpy (dhops, hops, num_hops * sizeof (struct GNUNET_PeerIdentity));
+ memcpy (&dhops[num_hops], payload, payload_size);
+ route_message (&next_hop->pid, &dvb->header, RMO_NONE);
}
/**
* Communicator gave us a DV box. Process the request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param dvb the message that was received
*/
static void
-handle_dv_box (void *cls,
- const struct TransportDVBox *dvb)
+handle_dv_box (void *cls, const struct TransportDVBox *dvb)
{
struct CommunicatorMessageContext *cmc = cls;
uint16_t size = ntohs (dvb->header.size) - sizeof (*dvb);
uint16_t num_hops = ntohs (dvb->num_hops);
- const struct GNUNET_PeerIdentity *hops = (const struct GNUNET_PeerIdentity
*) &dvb[1];
- const struct GNUNET_MessageHeader *inbox = (const struct
GNUNET_MessageHeader *) &hops[num_hops];
+ const struct GNUNET_PeerIdentity *hops =
+ (const struct GNUNET_PeerIdentity *) &dvb[1];
+ const struct GNUNET_MessageHeader *inbox =
+ (const struct GNUNET_MessageHeader *) &hops[num_hops];
if (num_hops > 0)
{
/* We're trying from the end of the hops array, as we may be
able to find a shortcut unknown to the origin that way */
- for (int i=num_hops-1;i>=0;i--)
+ for (int i = num_hops - 1; i >= 0; i--)
{
struct Neighbour *n;
- if (0 ==
- GNUNET_memcmp (&hops[i],
- &GST_my_identity))
+ if (0 == GNUNET_memcmp (&hops[i], &GST_my_identity))
{
GNUNET_break_op (0);
finish_cmc_handling (cmc);
return;
}
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- &hops[i]);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, &hops[i]);
if (NULL == n)
continue;
forward_dv_box (n,
ntohs (dvb->total_hops) + 1,
num_hops - i - 1, /* number of hops left */
&dvb->origin,
- &hops[i+1], /* remaining hops */
+ &hops[i + 1], /* remaining hops */
(const void *) &dvb[1],
size);
finish_cmc_handling (cmc);
@@ -5325,8 +5183,7 @@ handle_dv_box (void *cls,
/* We are the target. Unbox and handle message. */
cmc->im.sender = dvb->origin;
cmc->total_hops = ntohs (dvb->total_hops);
- demultiplex_with_cmc (cmc,
- inbox);
+ demultiplex_with_cmc (cmc, inbox);
}
@@ -5354,9 +5211,11 @@ check_incoming_msg (void *cls,
/**
- * Communicator gave us a transport address validation challenge. Process the
request.
+ * Communicator gave us a transport address validation challenge. Process the
+ * request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param tvc the message that was received
*/
static void
@@ -5374,24 +5233,23 @@ handle_validation_challenge (void *cls,
return;
}
tvr = GNUNET_new (struct TransportValidationResponse);
- tvr->header.type = htons
(GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE);
+ tvr->header.type =
+ htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE);
tvr->header.size = htons (sizeof (*tvr));
tvr->challenge = tvc->challenge;
tvr->origin_time = tvc->sender_time;
tvr->validity_duration = cmc->im.expected_address_validity;
{
/* create signature */
- struct TransportValidationPS tvp = {
- .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
- .purpose.size = htonl (sizeof (tvp)),
- .validity_duration = tvr->validity_duration,
- .challenge = tvc->challenge
- };
+ struct TransportValidationPS tvp =
+ {.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
+ .purpose.size = htonl (sizeof (tvp)),
+ .validity_duration = tvr->validity_duration,
+ .challenge = tvc->challenge};
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
- &tvp.purpose,
- &tvr->signature));
+ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+ &tvp.purpose,
+ &tvr->signature));
}
route_message (&cmc->im.sender,
&tvr->header,
@@ -5435,8 +5293,7 @@ check_known_challenge (void *cls,
struct ValidationState *vs = value;
(void) pid;
- if (0 != GNUNET_memcmp (&vs->challenge,
- ckac->challenge))
+ if (0 != GNUNET_memcmp (&vs->challenge, ckac->challenge))
return GNUNET_OK;
ckac->vs = vs;
return GNUNET_NO;
@@ -5451,8 +5308,7 @@ check_known_challenge (void *cls,
* @param success #GNUNET_YES on success
*/
static void
-peerstore_store_validation_cb (void *cls,
- int success)
+peerstore_store_validation_cb (void *cls, int success)
{
struct ValidationState *vs = cls;
@@ -5492,25 +5348,22 @@ update_next_challenge_time (struct ValidationState *vs,
return; /* be lazy */
vs->next_challenge = new_time;
if (NULL == vs->hn)
- vs->hn = GNUNET_CONTAINER_heap_insert (validation_heap,
- vs,
- new_time.abs_value_us);
+ vs->hn =
+ GNUNET_CONTAINER_heap_insert (validation_heap, vs,
new_time.abs_value_us);
else
- GNUNET_CONTAINER_heap_update_cost (vs->hn,
- new_time.abs_value_us);
- if ( (vs != GNUNET_CONTAINER_heap_peek (validation_heap)) &&
- (NULL != validation_task) )
+ GNUNET_CONTAINER_heap_update_cost (vs->hn, new_time.abs_value_us);
+ if ((vs != GNUNET_CONTAINER_heap_peek (validation_heap)) &&
+ (NULL != validation_task))
return;
if (NULL != validation_task)
GNUNET_SCHEDULER_cancel (validation_task);
/* randomize a bit */
- delta.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-
MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
- new_time = GNUNET_TIME_absolute_add (new_time,
- delta);
- validation_task = GNUNET_SCHEDULER_add_at (new_time,
- &validation_start_cb,
- NULL);
+ delta.rel_value_us =
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
+ new_time = GNUNET_TIME_absolute_add (new_time, delta);
+ validation_task =
+ GNUNET_SCHEDULER_add_at (new_time, &validation_start_cb, NULL);
}
@@ -5522,21 +5375,17 @@ update_next_challenge_time (struct ValidationState *vs,
* @return NULL if no such queue exists
*/
static struct Queue *
-find_queue (const struct GNUNET_PeerIdentity *pid,
- const char *address)
+find_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
{
struct Neighbour *n;
- n = GNUNET_CONTAINER_multipeermap_get (neighbours,
- pid);
+ n = GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
if (NULL == n)
return NULL;
- for (struct Queue *pos = n->queue_head;
- NULL != pos;
+ for (struct Queue *pos = n->queue_head; NULL != pos;
pos = pos->next_neighbour)
{
- if (0 == strcmp (pos->address,
- address))
+ if (0 == strcmp (pos->address, address))
return pos;
}
return NULL;
@@ -5559,10 +5408,9 @@ core_queue_visibility_check (void *cls)
q->visibility_task = NULL;
if (0 != GNUNET_TIME_absolute_get_remaining
(q->validated_until).rel_value_us)
{
- q->visibility_task
- = GNUNET_SCHEDULER_add_at (q->validated_until,
- &core_queue_visibility_check,
- q);
+ q->visibility_task = GNUNET_SCHEDULER_add_at (q->validated_until,
+ &core_queue_visibility_check,
+ q);
return;
}
update_neighbour_core_visibility (q->neighbour);
@@ -5586,17 +5434,16 @@ update_neighbour_core_visibility (struct Neighbour *n)
GNUNET_assert (GNUNET_YES == n->core_visible);
/* Check if _any_ queue of this neighbour is still valid, if so, schedule
the #core_queue_visibility_check() task for that queue */
- for (struct Queue *q = n->queue_head;
- NULL != q;
- q = q->next_neighbour)
+ for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
{
- if (0 != GNUNET_TIME_absolute_get_remaining
(q->validated_until).rel_value_us)
+ if (0 !=
+ GNUNET_TIME_absolute_get_remaining (q->validated_until).rel_value_us)
{
/* found a valid queue, use this one */
- q->visibility_task
- = GNUNET_SCHEDULER_add_at (q->validated_until,
- &core_queue_visibility_check,
- q);
+ q->visibility_task =
+ GNUNET_SCHEDULER_add_at (q->validated_until,
+ &core_queue_visibility_check,
+ q);
return;
}
}
@@ -5605,8 +5452,7 @@ update_neighbour_core_visibility (struct Neighbour *n)
/* Check if _any_ DV route to this neighbour is currently
valid, if so, do NOT tell core about the loss of direct
connectivity (DV still counts!) */
- dv = GNUNET_CONTAINER_multipeermap_get (dv_routes,
- &n->pid);
+ dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &n->pid);
if (GNUNET_YES == dv->core_visible)
return;
/* Nothing works anymore, need to tell CORE about the loss of
@@ -5616,9 +5462,11 @@ update_neighbour_core_visibility (struct Neighbour *n)
/**
- * Communicator gave us a transport address validation response. Process the
request.
+ * Communicator gave us a transport address validation response. Process the
+ * request.
*
- * @param cls a `struct CommunicatorMessageContext` (must call
#finish_cmc_handling() when done)
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
* @param tvr the message that was received
*/
static void
@@ -5627,10 +5475,8 @@ handle_validation_response (void *cls,
{
struct CommunicatorMessageContext *cmc = cls;
struct ValidationState *vs;
- struct CheckKnownChallengeContext ckac = {
- .challenge = &tvr->challenge,
- .vs = NULL
- };
+ struct CheckKnownChallengeContext ckac = {.challenge = &tvr->challenge,
+ .vs = NULL};
struct GNUNET_TIME_Absolute origin_time;
struct Queue *q;
struct DistanceVector *dv;
@@ -5654,8 +5500,8 @@ handle_validation_response (void *cls,
/* sanity check on origin time */
origin_time = GNUNET_TIME_absolute_ntoh (tvr->origin_time);
- if ( (origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
- (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us) )
+ if ((origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
+ (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us))
{
GNUNET_break_op (0);
finish_cmc_handling (cmc);
@@ -5664,18 +5510,18 @@ handle_validation_response (void *cls,
{
/* check signature */
- struct TransportValidationPS tvp = {
- .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
- .purpose.size = htonl (sizeof (tvp)),
- .validity_duration = tvr->validity_duration,
- .challenge = tvr->challenge
- };
-
- if (GNUNET_OK !=
- GNUNET_CRYPTO_eddsa_verify
(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE,
- &tvp.purpose,
- &tvr->signature,
- &cmc->im.sender.public_key))
+ struct TransportValidationPS tvp =
+ {.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
+ .purpose.size = htonl (sizeof (tvp)),
+ .validity_duration = tvr->validity_duration,
+ .challenge = tvr->challenge};
+
+ if (
+ GNUNET_OK !=
+ GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE,
+ &tvp.purpose,
+ &tvr->signature,
+ &cmc->im.sender.public_key))
{
GNUNET_break_op (0);
finish_cmc_handling (cmc);
@@ -5685,23 +5531,26 @@ handle_validation_response (void *cls,
/* validity is capped by our willingness to keep track of the
validation entry and the maximum the other peer allows */
- vs->valid_until
- = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_min
(GNUNET_TIME_relative_ntoh (tvr->validity_duration),
-
MAX_ADDRESS_VALID_UNTIL));
- vs->validated_until
- = GNUNET_TIME_absolute_min (vs->valid_until,
- GNUNET_TIME_relative_to_absolute
(ADDRESS_VALIDATION_LIFETIME));
+ vs->valid_until = GNUNET_TIME_relative_to_absolute (
+ GNUNET_TIME_relative_min (GNUNET_TIME_relative_ntoh (
+ tvr->validity_duration),
+ MAX_ADDRESS_VALID_UNTIL));
+ vs->validated_until =
+ GNUNET_TIME_absolute_min (vs->valid_until,
+ GNUNET_TIME_relative_to_absolute (
+ ADDRESS_VALIDATION_LIFETIME));
vs->validation_rtt = GNUNET_TIME_absolute_get_duration (origin_time);
vs->challenge_backoff = GNUNET_TIME_UNIT_ZERO;
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
&vs->challenge,
sizeof (vs->challenge));
- vs->first_challenge_use = GNUNET_TIME_absolute_subtract (vs->validated_until,
-
GNUNET_TIME_relative_multiply (vs->validation_rtt,
-
VALIDATION_RTT_BUFFER_FACTOR));
- vs->last_challenge_use = GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet
used */
- update_next_challenge_time (vs,
- vs->first_challenge_use);
+ vs->first_challenge_use = GNUNET_TIME_absolute_subtract (
+ vs->validated_until,
+ GNUNET_TIME_relative_multiply (vs->validation_rtt,
+ VALIDATION_RTT_BUFFER_FACTOR));
+ vs->last_challenge_use =
+ GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet used */
+ update_next_challenge_time (vs, vs->first_challenge_use);
vs->sc = GNUNET_PEERSTORE_store (peerstore,
"transport",
&cmc->im.sender,
@@ -5716,8 +5565,7 @@ handle_validation_response (void *cls,
/* Finally, we now possibly have a confirmed (!) working queue,
update queue status (if queue still is around) */
- q = find_queue (&vs->pid,
- vs->address);
+ q = find_queue (&vs->pid, vs->address);
if (NULL == q)
{
GNUNET_STATISTICS_update (GST_stats,
@@ -5731,20 +5579,17 @@ handle_validation_response (void *cls,
if (GNUNET_NO != q->neighbour->core_visible)
return; /* nothing changed, we are done here */
q->neighbour->core_visible = GNUNET_YES;
- q->visibility_task
- = GNUNET_SCHEDULER_add_at (q->validated_until,
- &core_queue_visibility_check,
- q);
+ q->visibility_task = GNUNET_SCHEDULER_add_at (q->validated_until,
+ &core_queue_visibility_check,
+ q);
/* Check if _any_ DV route to this neighbour is
currently valid, if so, do NOT tell core anything! */
- dv = GNUNET_CONTAINER_multipeermap_get (dv_routes,
- &q->neighbour->pid);
+ dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &q->neighbour->pid);
if (GNUNET_YES == dv->core_visible)
return; /* nothing changed, done */
/* We lacked a confirmed connection to the neighbour
before, so tell CORE about it (finally!) */
- cores_send_connect_info (&q->neighbour->pid,
- GNUNET_BANDWIDTH_ZERO);
+ cores_send_connect_info (&q->neighbour->pid, GNUNET_BANDWIDTH_ZERO);
}
@@ -5758,12 +5603,12 @@ handle_incoming_msg (void *cls,
const struct GNUNET_TRANSPORT_IncomingMessage *im)
{
struct TransportClient *tc = cls;
- struct CommunicatorMessageContext *cmc = GNUNET_new (struct
CommunicatorMessageContext);
+ struct CommunicatorMessageContext *cmc =
+ GNUNET_new (struct CommunicatorMessageContext);
cmc->tc = tc;
cmc->im = *im;
- demultiplex_with_cmc (cmc,
- (const struct GNUNET_MessageHeader *) &im[1]);
+ demultiplex_with_cmc (cmc, (const struct GNUNET_MessageHeader *) &im[1]);
}
@@ -5778,49 +5623,49 @@ static void
demultiplex_with_cmc (struct CommunicatorMessageContext *cmc,
const struct GNUNET_MessageHeader *msg)
{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (fragment_box,
- GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
- struct TransportFragmentBox,
- &cmc),
- GNUNET_MQ_hd_fixed_size (fragment_ack,
- GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT_ACK,
- struct TransportFragmentAckMessage,
- &cmc),
- GNUNET_MQ_hd_var_size (reliability_box,
- GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
- struct TransportReliabilityBox,
- &cmc),
- GNUNET_MQ_hd_fixed_size (reliability_ack,
- GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
- struct TransportReliabilityAckMessage,
- &cmc),
- GNUNET_MQ_hd_var_size (backchannel_encapsulation,
-
GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
- struct TransportBackchannelEncapsulationMessage,
- &cmc),
- GNUNET_MQ_hd_var_size (dv_learn,
- GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
- struct TransportDVLearn,
- &cmc),
- GNUNET_MQ_hd_var_size (dv_box,
- GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
- struct TransportDVBox,
- &cmc),
- GNUNET_MQ_hd_fixed_size (validation_challenge,
-
GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
- struct TransportValidationChallenge,
- &cmc),
- GNUNET_MQ_hd_fixed_size (validation_response,
-
GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
- struct TransportValidationResponse,
- &cmc),
- GNUNET_MQ_handler_end()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_var_size (fragment_box,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
+ struct TransportFragmentBox,
+ &cmc),
+ GNUNET_MQ_hd_fixed_size (fragment_ack,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT_ACK,
+ struct TransportFragmentAckMessage,
+ &cmc),
+ GNUNET_MQ_hd_var_size (reliability_box,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
+ struct TransportReliabilityBox,
+ &cmc),
+ GNUNET_MQ_hd_fixed_size (reliability_ack,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
+ struct TransportReliabilityAckMessage,
+ &cmc),
+ GNUNET_MQ_hd_var_size (backchannel_encapsulation,
+
GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
+ struct TransportBackchannelEncapsulationMessage,
+ &cmc),
+ GNUNET_MQ_hd_var_size (dv_learn,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
+ struct TransportDVLearn,
+ &cmc),
+ GNUNET_MQ_hd_var_size (dv_box,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
+ struct TransportDVBox,
+ &cmc),
+ GNUNET_MQ_hd_fixed_size (
+ validation_challenge,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
+ struct TransportValidationChallenge,
+ &cmc),
+ GNUNET_MQ_hd_fixed_size (
+ validation_response,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
+ struct TransportValidationResponse,
+ &cmc),
+ GNUNET_MQ_handler_end ()};
int ret;
- ret = GNUNET_MQ_handle_message (handlers,
- msg);
+ ret = GNUNET_MQ_handle_message (handlers, msg);
if (GNUNET_SYSERR == ret)
{
GNUNET_break (0);
@@ -5831,8 +5676,7 @@ demultiplex_with_cmc (struct CommunicatorMessageContext
*cmc,
if (GNUNET_NO == ret)
{
/* unencapsulated 'raw' message */
- handle_raw_message (&cmc,
- msg);
+ handle_raw_message (&cmc, msg);
}
}
@@ -5873,8 +5717,7 @@ tracker_update_in_cb (void *cls)
unsigned int rsize;
rsize = (0 == queue->mtu) ? IN_PACKET_SIZE_WITHOUT_MTU : queue->mtu;
- in_delay = GNUNET_BANDWIDTH_tracker_get_delay (&queue->tracker_in,
- rsize);
+ in_delay = GNUNET_BANDWIDTH_tracker_get_delay (&queue->tracker_in, rsize);
// FIXME: how exactly do we do inbound flow control?
}
@@ -5907,8 +5750,7 @@ set_pending_message_uuid (struct PendingMessage *pm)
* @return new message to transmit
*/
static struct PendingMessage *
-fragment_message (struct PendingMessage *pm,
- uint16_t mtu)
+fragment_message (struct PendingMessage *pm, uint16_t mtu)
{
struct PendingMessage *ff;
@@ -5918,19 +5760,16 @@ fragment_message (struct PendingMessage *pm,
GNUNET_assert (mtu > sizeof (struct TransportFragmentBox));
/* select fragment for transmission, descending the tree if it has
- been expanded until we are at a leaf or at a fragment that is small
enough */
+ been expanded until we are at a leaf or at a fragment that is small enough
+ */
ff = pm;
- while ( ( (ff->bytes_msg > mtu) ||
- (pm == ff) ) &&
- (ff->frag_off == ff->bytes_msg) &&
- (NULL != ff->head_frag) )
+ while (((ff->bytes_msg > mtu) || (pm == ff)) &&
+ (ff->frag_off == ff->bytes_msg) && (NULL != ff->head_frag))
{
ff = ff->head_frag; /* descent into fragmented fragments */
}
- if ( ( (ff->bytes_msg > mtu) ||
- (pm == ff) ) &&
- (pm->frag_off < pm->bytes_msg) )
+ if (((ff->bytes_msg > mtu) || (pm == ff)) && (pm->frag_off < pm->bytes_msg))
{
/* Did not yet calculate all fragments, calculate next fragment */
struct PendingMessage *frag;
@@ -5954,11 +5793,9 @@ fragment_message (struct PendingMessage *pm,
xoff = ntohs (tfbo->frag_off);
}
fragmax = mtu - sizeof (struct TransportFragmentBox);
- fragsize = GNUNET_MIN (msize - ff->frag_off,
- fragmax);
+ fragsize = GNUNET_MIN (msize - ff->frag_off, fragmax);
frag = GNUNET_malloc (sizeof (struct PendingMessage) +
- sizeof (struct TransportFragmentBox) +
- fragsize);
+ sizeof (struct TransportFragmentBox) + fragsize);
frag->target = pm->target;
frag->frag_parent = ff;
frag->timeout = pm->timeout;
@@ -5966,35 +5803,27 @@ fragment_message (struct PendingMessage *pm,
frag->pmt = PMT_FRAGMENT_BOX;
msg = (char *) &frag[1];
tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT);
- tfb.header.size = htons (sizeof (struct TransportFragmentBox) +
- fragsize);
+ tfb.header.size = htons (sizeof (struct TransportFragmentBox) + fragsize);
tfb.frag_uuid = htonl (pm->frag_uuidgen++);
tfb.msg_uuid = pm->msg_uuid;
tfb.frag_off = htons (ff->frag_off + xoff);
tfb.msg_size = htons (pm->bytes_msg);
- memcpy (msg,
- &tfb,
- sizeof (tfb));
- memcpy (&msg[sizeof (tfb)],
- &orig[ff->frag_off],
- fragsize);
- GNUNET_CONTAINER_MDLL_insert (frag,
- ff->head_frag,
- ff->tail_frag,
- frag);
+ memcpy (msg, &tfb, sizeof (tfb));
+ memcpy (&msg[sizeof (tfb)], &orig[ff->frag_off], fragsize);
+ GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag, ff->tail_frag, frag);
ff->frag_off += fragsize;
ff = frag;
}
/* Move head to the tail and return it */
GNUNET_CONTAINER_MDLL_remove (frag,
- ff->frag_parent->head_frag,
- ff->frag_parent->tail_frag,
- ff);
+ ff->frag_parent->head_frag,
+ ff->frag_parent->tail_frag,
+ ff);
GNUNET_CONTAINER_MDLL_insert_tail (frag,
- ff->frag_parent->head_frag,
- ff->frag_parent->tail_frag,
- ff);
+ ff->frag_parent->head_frag,
+ ff->frag_parent->tail_frag,
+ ff);
return ff;
}
@@ -6017,7 +5846,8 @@ reliability_box_message (struct PendingMessage *pm)
char *msg;
if (PMT_CORE != pm->pmt)
- return pm; /* already fragmented or reliability boxed, or control
message: do nothing */
+ return pm; /* already fragmented or reliability boxed, or control message:
+ do nothing */
if (NULL != pm->bpm)
return pm->bpm; /* already computed earlier: do nothing */
GNUNET_assert (NULL == pm->head_frag);
@@ -6025,20 +5855,14 @@ reliability_box_message (struct PendingMessage *pm)
{
/* failed hard */
GNUNET_break (0);
- client_send_response (pm,
- GNUNET_NO,
- 0);
+ client_send_response (pm, GNUNET_NO, 0);
return NULL;
}
- bpm = GNUNET_malloc (sizeof (struct PendingMessage) +
- sizeof (rbox) +
+ bpm = GNUNET_malloc (sizeof (struct PendingMessage) + sizeof (rbox) +
pm->bytes_msg);
bpm->target = pm->target;
bpm->frag_parent = pm;
- GNUNET_CONTAINER_MDLL_insert (frag,
- pm->head_frag,
- pm->tail_frag,
- bpm);
+ GNUNET_CONTAINER_MDLL_insert (frag, pm->head_frag, pm->tail_frag, bpm);
bpm->timeout = pm->timeout;
bpm->pmt = PMT_RELIABILITY_BOX;
bpm->bytes_msg = pm->bytes_msg + sizeof (rbox);
@@ -6048,12 +5872,8 @@ reliability_box_message (struct PendingMessage *pm)
rbox.ack_countdown = htonl (0); // FIXME: implement ACK countdown support
rbox.msg_uuid = pm->msg_uuid;
msg = (char *) &bpm[1];
- memcpy (msg,
- &rbox,
- sizeof (rbox));
- memcpy (&msg[sizeof (rbox)],
- &pm[1],
- pm->bytes_msg);
+ memcpy (msg, &rbox, sizeof (rbox));
+ memcpy (&msg[sizeof (rbox)], &pm[1], pm->bytes_msg);
pm->bpm = bpm;
return bpm;
}
@@ -6097,8 +5917,9 @@ transmit_on_queue (void *cls)
this queue */) )
s = fragment_message (s,
(0 == queue->mtu)
- ? UINT16_MAX - sizeof (struct
GNUNET_TRANSPORT_SendMessageTo)
- : queue->mtu);
+ ? UINT16_MAX -
+ sizeof (struct GNUNET_TRANSPORT_SendMessageTo)
+ : queue->mtu);
if (NULL == s)
{
/* Fragmentation failed, try next message... */
@@ -6115,56 +5936,45 @@ transmit_on_queue (void *cls)
}
/* Pass 's' for transission to the communicator */
- queue_send_msg (queue,
- s,
- &s[1],
- s->bytes_msg);
+ queue_send_msg (queue, s, &s[1], s->bytes_msg);
// FIXME: do something similar to the logic below
// in defragmentation / reliability ACK handling!
/* Check if this transmission somehow conclusively finished handing 'pm'
even without any explicit ACKs */
- if ( (PMT_CORE == s->pmt) &&
- (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc) )
+ if ((PMT_CORE == s->pmt) &&
+ (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
{
/* Full message sent, and over reliabile channel */
- client_send_response (pm,
- GNUNET_YES,
- pm->bytes_msg);
+ client_send_response (pm, GNUNET_YES, pm->bytes_msg);
}
- else if ( (GNUNET_TRANSPORT_CC_RELIABLE ==
queue->tc->details.communicator.cc) &&
- (PMT_FRAGMENT_BOX == s->pmt) )
+ else if ((GNUNET_TRANSPORT_CC_RELIABLE ==
+ queue->tc->details.communicator.cc) &&
+ (PMT_FRAGMENT_BOX == s->pmt))
{
struct PendingMessage *pos;
/* Fragment sent over reliabile channel */
free_fragment_tree (s);
pos = s->frag_parent;
- GNUNET_CONTAINER_MDLL_remove (frag,
- pos->head_frag,
- pos->tail_frag,
- s);
+ GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, s);
GNUNET_free (s);
/* check if subtree is done */
- while ( (NULL == pos->head_frag) &&
- (pos->frag_off == pos->bytes_msg) &&
- (pos != pm) )
+ while ((NULL == pos->head_frag) && (pos->frag_off == pos->bytes_msg) &&
+ (pos != pm))
{
s = pos;
pos = s->frag_parent;
- GNUNET_CONTAINER_MDLL_remove (frag,
- pos->head_frag,
- pos->tail_frag,
- s);
+ GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, s);
GNUNET_free (s);
}
/* Was this the last applicable fragmment? */
- if ( (NULL == pm->head_frag) &&
- (pm->frag_off == pm->bytes_msg) )
- client_send_response (pm,
- GNUNET_YES,
- pm->bytes_msg /* FIXME: calculate and add
overheads! */);
+ if ((NULL == pm->head_frag) && (pm->frag_off == pm->bytes_msg))
+ client_send_response (
+ pm,
+ GNUNET_YES,
+ pm->bytes_msg /* FIXME: calculate and add overheads! */);
}
else if (PMT_CORE != pm->pmt)
{
@@ -6182,9 +5992,8 @@ transmit_on_queue (void *cls)
retransmitting. Note that in the future this heuristic should
likely be improved further (measure RTT stability, consider
message urgency and size when delaying ACKs, etc.) */
- s->next_attempt = GNUNET_TIME_relative_to_absolute
- (GNUNET_TIME_relative_multiply (queue->rtt,
- 4));
+ s->next_attempt = GNUNET_TIME_relative_to_absolute (
+ GNUNET_TIME_relative_multiply (queue->rtt, 4));
if (s == pm)
{
struct PendingMessage *pos;
@@ -6195,8 +6004,8 @@ transmit_on_queue (void *cls)
neighbour->pending_msg_tail,
pm);
pos = neighbour->pending_msg_tail;
- while ( (NULL != pos) &&
- (pm->next_attempt.abs_value_us > pos->next_attempt.abs_value_us) )
+ while ((NULL != pos) &&
+ (pm->next_attempt.abs_value_us > pos->next_attempt.abs_value_us))
pos = pos->prev_neighbour;
GNUNET_CONTAINER_MDLL_insert_after (neighbour,
neighbour->pending_msg_head,
@@ -6210,13 +6019,10 @@ transmit_on_queue (void *cls)
struct PendingMessage *fp = s->frag_parent;
struct PendingMessage *pos;
- GNUNET_CONTAINER_MDLL_remove (frag,
- fp->head_frag,
- fp->tail_frag,
- s);
+ GNUNET_CONTAINER_MDLL_remove (frag, fp->head_frag, fp->tail_frag, s);
pos = fp->tail_frag;
- while ( (NULL != pos) &&
- (s->next_attempt.abs_value_us > pos->next_attempt.abs_value_us) )
+ while ((NULL != pos) &&
+ (s->next_attempt.abs_value_us > pos->next_attempt.abs_value_us))
pos = pos->prev_frag;
GNUNET_CONTAINER_MDLL_insert_after (frag,
fp->head_frag,
@@ -6246,8 +6052,8 @@ tracker_update_out_cb (void *cls)
if (NULL == n->pending_msg_head)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Bandwidth allocation updated for empty transmission queue
`%s'\n",
- queue->address);
+ "Bandwidth allocation updated for empty transmission queue
`%s'\n",
+ queue->address);
return; /* no message pending, nothing to do here! */
}
GNUNET_SCHEDULER_cancel (queue->transmit_task);
@@ -6279,7 +6085,6 @@ tracker_excess_out_cb (void *cls)
}
-
/**
* Bandwidth tracker informs us that excessive inbound bandwidth was allocated
* which is not being used.
@@ -6317,15 +6122,13 @@ handle_del_queue_message (void *cls,
GNUNET_SERVICE_client_drop (tc->client);
return;
}
- for (struct Queue *queue = tc->details.communicator.queue_head;
- NULL != queue;
+ for (struct Queue *queue = tc->details.communicator.queue_head; NULL !=
queue;
queue = queue->next_client)
{
struct Neighbour *neighbour = queue->neighbour;
- if ( (dqm->qid != queue->qid) ||
- (0 != GNUNET_memcmp (&dqm->receiver,
- &neighbour->pid)) )
+ if ((dqm->qid != queue->qid) ||
+ (0 != GNUNET_memcmp (&dqm->receiver, &neighbour->pid)))
continue;
free_queue (queue);
GNUNET_SERVICE_client_continue (tc->client);
@@ -6358,15 +6161,12 @@ handle_send_message_ack (void *cls,
/* find our queue entry matching the ACK */
qe = NULL;
- for (struct Queue *queue = tc->details.communicator.queue_head;
- NULL != queue;
+ for (struct Queue *queue = tc->details.communicator.queue_head; NULL !=
queue;
queue = queue->next_client)
{
- if (0 != GNUNET_memcmp (&queue->neighbour->pid,
- &sma->receiver))
+ if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
continue;
- for (struct QueueEntry *qep = queue->queue_head;
- NULL != qep;
+ for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
qep = qep->next)
{
if (qep->mid != sma->mid)
@@ -6391,13 +6191,15 @@ handle_send_message_ack (void *cls,
GNUNET_SERVICE_client_continue (tc->client);
/* if applicable, resume transmissions that waited on ACK */
- if (COMMUNICATOR_TOTAL_QUEUE_LIMIT - 1 ==
tc->details.communicator.total_queue_length)
+ if (COMMUNICATOR_TOTAL_QUEUE_LIMIT - 1 ==
+ tc->details.communicator.total_queue_length)
{
/* Communicator dropped below threshold, resume all queues */
- GNUNET_STATISTICS_update (GST_stats,
- "# Transmission throttled due to communicator
queue limit",
- -1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (
+ GST_stats,
+ "# Transmission throttled due to communicator queue limit",
+ -1,
+ GNUNET_NO);
for (struct Queue *queue = tc->details.communicator.queue_head;
NULL != queue;
queue = queue->next_client)
@@ -6440,22 +6242,15 @@ notify_client_queues (void *cls,
struct Neighbour *neighbour = value;
GNUNET_assert (CT_MONITOR == tc->type);
- for (struct Queue *q = neighbour->queue_head;
- NULL != q;
+ for (struct Queue *q = neighbour->queue_head; NULL != q;
q = q->next_neighbour)
{
- struct MonitorEvent me = {
- .rtt = q->rtt,
- .cs = q->cs,
- .num_msg_pending = q->num_msg_pending,
- .num_bytes_pending = q->num_bytes_pending
- };
+ struct MonitorEvent me = {.rtt = q->rtt,
+ .cs = q->cs,
+ .num_msg_pending = q->num_msg_pending,
+ .num_bytes_pending = q->num_bytes_pending};
- notify_monitor (tc,
- pid,
- q->address,
- q->nt,
- &me);
+ notify_monitor (tc, pid, q->address, q->nt, &me);
}
return GNUNET_OK;
}
@@ -6482,9 +6277,7 @@ handle_monitor_start (void *cls,
tc->type = CT_MONITOR;
tc->details.monitor.peer = start->peer;
tc->details.monitor.one_shot = ntohl (start->one_shot);
- GNUNET_CONTAINER_multipeermap_iterate (neighbours,
- ¬ify_client_queues,
- tc);
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, ¬ify_client_queues,
tc);
GNUNET_SERVICE_client_mark_monitor (tc->client);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -6500,19 +6293,17 @@ handle_monitor_start (void *cls,
static struct TransportClient *
lookup_communicator (const char *prefix)
{
- for (struct TransportClient *tc = clients_head;
- NULL != tc;
- tc = tc->next)
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
{
if (CT_COMMUNICATOR != tc->type)
continue;
- if (0 == strcmp (prefix,
- tc->details.communicator.address_prefix))
+ if (0 == strcmp (prefix, tc->details.communicator.address_prefix))
return tc;
}
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Somone suggested use of communicator for `%s', but we do not
have such a communicator!\n",
- prefix);
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ "Somone suggested use of communicator for `%s', but we do not have such a
communicator!\n",
+ prefix);
return NULL;
}
@@ -6525,8 +6316,7 @@ lookup_communicator (const char *prefix)
* @param address the address to try
*/
static void
-suggest_to_connect (const struct GNUNET_PeerIdentity *pid,
- const char *address)
+suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address)
{
static uint32_t idgen;
struct TransportClient *tc;
@@ -6557,16 +6347,12 @@ suggest_to_connect (const struct GNUNET_PeerIdentity
*pid,
prefix,
address);
alen = strlen (address) + 1;
- env = GNUNET_MQ_msg_extra (cqm,
- alen,
- GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
+ env =
+ GNUNET_MQ_msg_extra (cqm, alen,
GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
cqm->request_id = htonl (idgen++);
cqm->receiver = *pid;
- memcpy (&cqm[1],
- address,
- alen);
- GNUNET_MQ_send (tc->mq,
- env);
+ memcpy (&cqm[1], address, alen);
+ GNUNET_MQ_send (tc->mq, env);
}
@@ -6578,21 +6364,18 @@ suggest_to_connect (const struct GNUNET_PeerIdentity
*pid,
* @param vs state to derive validation challenge from
*/
static void
-validation_transmit_on_queue (struct Queue *q,
- struct ValidationState *vs)
+validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs)
{
struct TransportValidationChallenge tvc;
vs->last_challenge_use = GNUNET_TIME_absolute_get ();
- tvc.header.type = htons
(GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE);
+ tvc.header.type =
+ htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE);
tvc.header.size = htons (sizeof (tvc));
tvc.reserved = htonl (0);
tvc.challenge = vs->challenge;
tvc.sender_time = GNUNET_TIME_absolute_hton (vs->last_challenge_use);
- queue_send_msg (q,
- NULL,
- &tvc,
- sizeof (tvc));
+ queue_send_msg (q, NULL, &tvc, sizeof (tvc));
}
@@ -6611,8 +6394,9 @@ validation_start_cb (void *cls)
validation_task = NULL;
vs = GNUNET_CONTAINER_heap_peek (validation_heap);
/* drop validations past their expiration */
- while ( (NULL != vs) &&
- (0 == GNUNET_TIME_absolute_get_remaining
(vs->valid_until).rel_value_us) )
+ while (
+ (NULL != vs) &&
+ (0 == GNUNET_TIME_absolute_get_remaining (vs->valid_until).rel_value_us))
{
free_validation_state (vs);
vs = GNUNET_CONTAINER_heap_peek (validation_heap);
@@ -6620,22 +6404,21 @@ validation_start_cb (void *cls)
if (NULL == vs)
return; /* woopsie, no more addresses known, should only
happen if we're really a lonely peer */
- q = find_queue (&vs->pid,
- vs->address);
+ q = find_queue (&vs->pid, vs->address);
if (NULL == q)
{
vs->awaiting_queue = GNUNET_YES;
- suggest_to_connect (&vs->pid,
- vs->address);
+ suggest_to_connect (&vs->pid, vs->address);
}
else
- validation_transmit_on_queue (q,
- vs);
+ validation_transmit_on_queue (q, vs);
/* Finally, reschedule next attempt */
- vs->challenge_backoff = GNUNET_TIME_randomized_backoff
(vs->challenge_backoff,
-
MAX_VALIDATION_CHALLENGE_FREQ);
+ vs->challenge_backoff =
+ GNUNET_TIME_randomized_backoff (vs->challenge_backoff,
+ MAX_VALIDATION_CHALLENGE_FREQ);
update_next_challenge_time (vs,
- GNUNET_TIME_relative_to_absolute
(vs->challenge_backoff));
+ GNUNET_TIME_relative_to_absolute (
+ vs->challenge_backoff));
}
@@ -6664,7 +6447,6 @@ struct QueueQualityContext
* k-th queue in @e q.
*/
unsigned int k;
-
};
@@ -6690,9 +6472,7 @@ check_connection_quality (void *cls,
(void) pid;
do_inc = GNUNET_NO;
- for (struct Queue *q = n->queue_head;
- NULL != q;
- q = q->next_neighbour)
+ for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
{
if (0 != q->distance)
continue; /* DV does not count */
@@ -6730,8 +6510,7 @@ start_dv_learn (void *cls)
(void) cls;
dvlearn_task = NULL;
- if (0 ==
- GNUNET_CONTAINER_multipeermap_size (neighbours))
+ if (0 == GNUNET_CONTAINER_multipeermap_size (neighbours))
return; /* lost all connectivity, cannot do learning */
qqc.quality_count = 0;
qqc.num_queues = 0;
@@ -6745,11 +6524,8 @@ start_dv_learn (void *cls)
/* scale our retries by how far we are above the threshold */
factor = qqc.quality_count / DV_LEARN_QUALITY_THRESHOLD;
- delay = GNUNET_TIME_relative_multiply (DV_LEARN_BASE_FREQUENCY,
- factor);
- dvlearn_task = GNUNET_SCHEDULER_add_delayed (delay,
- &start_dv_learn,
- NULL);
+ delay = GNUNET_TIME_relative_multiply (DV_LEARN_BASE_FREQUENCY, factor);
+ dvlearn_task = GNUNET_SCHEDULER_add_delayed (delay, &start_dv_learn, NULL);
return;
}
/* remove old entries in #dvlearn_map if it has grown too big */
@@ -6761,9 +6537,7 @@ start_dv_learn (void *cls)
GNUNET_CONTAINER_multishortmap_remove (dvlearn_map,
&lle->challenge,
lle));
- GNUNET_CONTAINER_DLL_remove (lle_head,
- lle_tail,
- lle);
+ GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
GNUNET_free (lle);
}
/* setup data structure for learning */
@@ -6771,37 +6545,33 @@ start_dv_learn (void *cls)
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
&lle->challenge,
sizeof (lle->challenge));
- GNUNET_CONTAINER_DLL_insert (lle_head,
- lle_tail,
- lle);
+ GNUNET_CONTAINER_DLL_insert (lle_head, lle_tail, lle);
GNUNET_break (GNUNET_YES ==
- GNUNET_CONTAINER_multishortmap_put (dvlearn_map,
- &lle->challenge,
- lle,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multishortmap_put (
+ dvlearn_map,
+ &lle->challenge,
+ lle,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
dvl.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
dvl.header.size = htons (sizeof (dvl));
dvl.num_hops = htons (0);
dvl.bidirectional = htons (0);
dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
{
- struct DvInitPS dvip = {
- .purpose.purpose = htonl
(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
- .purpose.size = htonl (sizeof (dvip)),
- .challenge = lle->challenge
- };
+ struct DvInitPS dvip = {.purpose.purpose = htonl (
+ GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
+ .purpose.size = htonl (sizeof (dvip)),
+ .challenge = lle->challenge};
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
- &dvip.purpose,
- &dvl.init_sig));
+ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+ &dvip.purpose,
+ &dvl.init_sig));
}
dvl.initiator = GST_my_identity;
dvl.challenge = lle->challenge;
qqc.quality_count = 0;
- qqc.k = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- qqc.num_queues);
+ qqc.k = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
qqc.num_queues);
qqc.num_queues = 0;
qqc.q = NULL;
GNUNET_CONTAINER_multipeermap_iterate (neighbours,
@@ -6812,16 +6582,13 @@ start_dv_learn (void *cls)
/* Do this as close to transmission time as possible! */
lle->launch_time = GNUNET_TIME_absolute_get ();
- queue_send_msg (qqc.q,
- NULL,
- &dvl,
- sizeof (dvl));
+ queue_send_msg (qqc.q, NULL, &dvl, sizeof (dvl));
/* reschedule this job, randomizing the time it runs (but no
actual backoff!) */
- dvlearn_task
- = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_randomize
(DV_LEARN_BASE_FREQUENCY),
- &start_dv_learn,
- NULL);
+ dvlearn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_randomize (
+ DV_LEARN_BASE_FREQUENCY),
+ &start_dv_learn,
+ NULL);
}
@@ -6843,13 +6610,11 @@ check_validation_request_pending (void *cls,
struct ValidationState *vs = value;
(void) pid;
- if ( (GNUNET_YES == vs->awaiting_queue) &&
- (0 == strcmp (vs->address,
- q->address)) )
+ if ((GNUNET_YES == vs->awaiting_queue) &&
+ (0 == strcmp (vs->address, q->address)))
{
vs->awaiting_queue = GNUNET_NO;
- validation_transmit_on_queue (q,
- vs);
+ validation_transmit_on_queue (q, vs);
return GNUNET_NO;
}
return GNUNET_OK;
@@ -6887,10 +6652,11 @@ handle_add_queue_message (void *cls,
neighbour->earliest_timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
neighbour->pid = aqm->receiver;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (neighbours,
- &neighbour->pid,
- neighbour,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ neighbours,
+ &neighbour->pid,
+ neighbour,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
}
addr_len = ntohs (aqm->header.size) - sizeof (*aqm);
addr = (const char *) &aqm[1];
@@ -6918,20 +6684,12 @@ handle_add_queue_message (void *cls,
GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY_S,
&tracker_excess_out_cb,
queue);
- memcpy (&queue[1],
- addr,
- addr_len);
+ memcpy (&queue[1], addr, addr_len);
/* notify monitors about new queue */
{
- struct MonitorEvent me = {
- .rtt = queue->rtt,
- .cs = queue->cs
- };
+ struct MonitorEvent me = {.rtt = queue->rtt, .cs = queue->cs};
- notify_monitors (&neighbour->pid,
- queue->address,
- queue->nt,
- &me);
+ notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
}
GNUNET_CONTAINER_MDLL_insert (neighbour,
neighbour->queue_head,
@@ -6942,14 +6700,14 @@ handle_add_queue_message (void *cls,
tc->details.communicator.queue_tail,
queue);
/* check if valdiations are waiting for the queue */
- (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
- &aqm->receiver,
-
&check_validation_request_pending,
- queue);
+ (void)
+ GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
+ &aqm->receiver,
+
&check_validation_request_pending,
+ queue);
/* might be our first queue, try launching DV learning */
if (NULL == dvlearn_task)
- dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn,
- NULL);
+ dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -6986,15 +6744,16 @@ handle_queue_create_ok (void *cls,
/**
* Communicator tells us that our request to create a queue failed. This
usually
- * indicates that the provided address is simply invalid or that the
communicator's
- * resources are exhausted.
+ * indicates that the provided address is simply invalid or that the
+ * communicator's resources are exhausted.
*
* @param cls the `struct TransportClient`
* @param cqr failure message
*/
static void
-handle_queue_create_fail (void *cls,
- const struct GNUNET_TRANSPORT_CreateQueueResponse
*cqr)
+handle_queue_create_fail (
+ void *cls,
+ const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
{
struct TransportClient *tc = cls;
@@ -7016,14 +6775,14 @@ handle_queue_create_fail (void *cls,
/**
- * We have received a `struct ExpressPreferenceMessage` from an application
client.
+ * We have received a `struct ExpressPreferenceMessage` from an application
+ * client.
*
* @param cls handle to the client
* @param msg the start message
*/
static void
-handle_suggest_cancel (void *cls,
- const struct ExpressPreferenceMessage *msg)
+handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
{
struct TransportClient *tc = cls;
struct PeerRequest *pr;
@@ -7042,9 +6801,7 @@ handle_suggest_cancel (void *cls,
GNUNET_SERVICE_client_drop (tc->client);
return;
}
- (void) stop_peer_request (tc,
- &pr->pid,
- pr);
+ (void) stop_peer_request (tc, &pr->pid, pr);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -7058,8 +6815,9 @@ handle_suggest_cancel (void *cls,
* @return #GNUNET_OK
*/
static int
-check_address_consider_verify (void *cls,
- const struct GNUNET_TRANSPORT_AddressToVerify
*hdr)
+check_address_consider_verify (
+ void *cls,
+ const struct GNUNET_TRANSPORT_AddressToVerify *hdr)
{
(void) cls;
(void) hdr;
@@ -7102,8 +6860,7 @@ check_known_address (void *cls,
struct ValidationState *vs = value;
(void) pid;
- if (0 != strcmp (vs->address,
- ckac->address))
+ if (0 != strcmp (vs->address, ckac->address))
return GNUNET_OK;
ckac->vs = vs;
return GNUNET_NO;
@@ -7124,10 +6881,7 @@ start_address_validation (const struct
GNUNET_PeerIdentity *pid,
{
struct GNUNET_TIME_Absolute now;
struct ValidationState *vs;
- struct CheckKnownAddressContext ckac = {
- .address = address,
- .vs = NULL
- };
+ struct CheckKnownAddressContext ckac = {.address = address, .vs = NULL};
if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
return; /* expired */
@@ -7137,19 +6891,22 @@ start_address_validation (const struct
GNUNET_PeerIdentity *pid,
&ckac);
if (NULL != (vs = ckac.vs))
{
- /* if 'vs' is not currently valid, we need to speed up retrying the
validation */
+ /* if 'vs' is not currently valid, we need to speed up retrying the
+ * validation */
if (vs->validated_until.abs_value_us < vs->next_challenge.abs_value_us)
{
/* reduce backoff as we got a fresh advertisement */
- vs->challenge_backoff = GNUNET_TIME_relative_min
(FAST_VALIDATION_CHALLENGE_FREQ,
-
GNUNET_TIME_relative_divide (vs->challenge_backoff,
-
2));
+ vs->challenge_backoff =
+ GNUNET_TIME_relative_min (FAST_VALIDATION_CHALLENGE_FREQ,
+ GNUNET_TIME_relative_divide
(vs->challenge_backoff,
+ 2));
update_next_challenge_time (vs,
- GNUNET_TIME_relative_to_absolute
(vs->challenge_backoff));
+ GNUNET_TIME_relative_to_absolute (
+ vs->challenge_backoff));
}
return;
}
- now = GNUNET_TIME_absolute_get();
+ now = GNUNET_TIME_absolute_get ();
vs = GNUNET_new (struct ValidationState);
vs->pid = *pid;
vs->valid_until = expiration;
@@ -7160,12 +6917,12 @@ start_address_validation (const struct
GNUNET_PeerIdentity *pid,
sizeof (vs->challenge));
vs->address = GNUNET_strdup (address);
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (validation_map,
- &vs->pid,
- vs,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- update_next_challenge_time (vs,
- now);
+ GNUNET_CONTAINER_multipeermap_put (
+ validation_map,
+ &vs->pid,
+ vs,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ update_next_challenge_time (vs, now);
}
@@ -7192,8 +6949,7 @@ handle_hello (void *cls,
return;
}
val = record->value;
- if ( (0 == record->value_size) ||
- ('\0' != val[record->value_size - 1]) )
+ if ((0 == record->value_size) || ('\0' != val[record->value_size - 1]))
{
GNUNET_break (0);
return;
@@ -7205,14 +6961,14 @@ handle_hello (void *cls,
/**
- * We have received a `struct ExpressPreferenceMessage` from an application
client.
+ * We have received a `struct ExpressPreferenceMessage` from an application
+ * client.
*
* @param cls handle to the client
* @param msg the start message
*/
static void
-handle_suggest (void *cls,
- const struct ExpressPreferenceMessage *msg)
+handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
{
struct TransportClient *tc = cls;
struct PeerRequest *pr;
@@ -7220,9 +6976,8 @@ handle_suggest (void *cls,
if (CT_NONE == tc->type)
{
tc->type = CT_APPLICATION;
- tc->details.application.requests
- = GNUNET_CONTAINER_multipeermap_create (16,
- GNUNET_YES);
+ tc->details.application.requests =
+ GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
}
if (CT_APPLICATION != tc->type)
{
@@ -7240,11 +6995,11 @@ handle_suggest (void *cls,
pr->pid = msg->peer;
pr->bw = msg->bw;
pr->pk = (enum GNUNET_MQ_PreferenceKind) ntohl (msg->pk);
- if (GNUNET_YES !=
- GNUNET_CONTAINER_multipeermap_put (tc->details.application.requests,
- &pr->pid,
- pr,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_put (
+ tc->details.application.requests,
+ &pr->pid,
+ pr,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_break (0);
GNUNET_free (pr);
@@ -7270,8 +7025,9 @@ handle_suggest (void *cls,
* signature in the body, see #GNUNET_HELLO_extract_address()
*/
static void
-handle_address_consider_verify (void *cls,
- const struct GNUNET_TRANSPORT_AddressToVerify
*hdr)
+handle_address_consider_verify (
+ void *cls,
+ const struct GNUNET_TRANSPORT_AddressToVerify *hdr)
{
struct TransportClient *tc = cls;
char *address;
@@ -7282,19 +7038,18 @@ handle_address_consider_verify (void *cls,
// OPTIMIZE-FIXME: checking that we know this address already should
// be done BEFORE checking the signature => HELLO API change!
// OPTIMIZE-FIXME: pre-check: rate-limit signature verification /
validation?!
- address = GNUNET_HELLO_extract_address (&hdr[1],
- ntohs (hdr->header.size) - sizeof
(*hdr),
- &hdr->peer,
- &nt,
- &expiration);
+ address =
+ GNUNET_HELLO_extract_address (&hdr[1],
+ ntohs (hdr->header.size) - sizeof (*hdr),
+ &hdr->peer,
+ &nt,
+ &expiration);
if (NULL == address)
{
GNUNET_break_op (0);
return;
}
- start_address_validation (&hdr->peer,
- address,
- expiration);
+ start_address_validation (&hdr->peer, address, expiration);
GNUNET_free (address);
GNUNET_SERVICE_client_continue (tc->client);
}
@@ -7446,19 +7201,15 @@ do_shutdown (void *cls)
GNUNET_SCHEDULER_cancel (ephemeral_task);
ephemeral_task = NULL;
}
- GNUNET_CONTAINER_multipeermap_iterate (neighbours,
- &free_neighbour_cb,
- NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, &free_neighbour_cb, NULL);
if (NULL != peerstore)
{
- GNUNET_PEERSTORE_disconnect (peerstore,
- GNUNET_NO);
+ GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
peerstore = NULL;
}
if (NULL != GST_stats)
{
- GNUNET_STATISTICS_destroy (GST_stats,
- GNUNET_NO);
+ GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
GST_stats = NULL;
}
if (NULL != GST_my_private_key)
@@ -7475,18 +7226,14 @@ do_shutdown (void *cls)
validation_map = NULL;
while (NULL != (lle = lle_head))
{
- GNUNET_CONTAINER_DLL_remove (lle_head,
- lle_tail,
- lle);
+ GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
GNUNET_free (lle);
}
GNUNET_CONTAINER_multishortmap_destroy (dvlearn_map);
dvlearn_map = NULL;
GNUNET_CONTAINER_heap_destroy (validation_heap);
validation_heap = NULL;
- GNUNET_CONTAINER_multipeermap_iterate (dv_routes,
- &free_dv_routes_cb,
- NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (dv_routes, &free_dv_routes_cb, NULL);
GNUNET_CONTAINER_multipeermap_destroy (dv_routes);
dv_routes = NULL;
GNUNET_CONTAINER_multipeermap_iterate (ephemeral_map,
@@ -7515,35 +7262,34 @@ run (void *cls,
(void) service;
/* setup globals */
GST_cfg = c;
- neighbours = GNUNET_CONTAINER_multipeermap_create (1024,
- GNUNET_YES);
- dv_routes = GNUNET_CONTAINER_multipeermap_create (1024,
- GNUNET_YES);
- ephemeral_map = GNUNET_CONTAINER_multipeermap_create (32,
- GNUNET_YES);
- ephemeral_heap = GNUNET_CONTAINER_heap_create
(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ neighbours = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+ dv_routes = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+ ephemeral_map = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
+ ephemeral_heap =
+ GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
dvlearn_map = GNUNET_CONTAINER_multishortmap_create (2 *
MAX_DV_LEARN_PENDING,
GNUNET_YES);
- validation_map = GNUNET_CONTAINER_multipeermap_create (1024,
- GNUNET_YES);
- validation_heap = GNUNET_CONTAINER_heap_create
(GNUNET_CONTAINER_HEAP_ORDER_MIN);
- GST_my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration
(GST_cfg);
+ validation_map = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+ validation_heap =
+ GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ GST_my_private_key =
+ GNUNET_CRYPTO_eddsa_key_create_from_configuration (GST_cfg);
if (NULL == GST_my_private_key)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Transport service is lacking key configuration settings.
Exiting.\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_ERROR,
+ _ (
+ "Transport service is lacking key configuration settings.
Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
&GST_my_identity.public_key);
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "My identity is `%s'\n",
- GNUNET_i2s_full (&GST_my_identity));
- GST_stats = GNUNET_STATISTICS_create ("transport",
- GST_cfg);
- GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
- NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "My identity is `%s'\n",
+ GNUNET_i2s_full (&GST_my_identity));
+ GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
+ GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
if (NULL == peerstore)
{
@@ -7557,86 +7303,86 @@ run (void *cls,
/**
* Define "main" method using service macro.
*/
-GNUNET_SERVICE_MAIN
-("transport",
- GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- /* communication with applications */
- GNUNET_MQ_hd_fixed_size (suggest,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST,
- struct ExpressPreferenceMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (suggest_cancel,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL,
- struct ExpressPreferenceMessage,
- NULL),
- GNUNET_MQ_hd_var_size (request_hello_validation,
- GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION,
- struct RequestHelloValidationMessage,
- NULL),
- /* communication with core */
- GNUNET_MQ_hd_fixed_size (client_start,
- GNUNET_MESSAGE_TYPE_TRANSPORT_START,
- struct StartMessage,
- NULL),
- GNUNET_MQ_hd_var_size (client_send,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
- struct OutboundMessage,
- NULL),
- /* communication with communicators */
- GNUNET_MQ_hd_var_size (communicator_available,
- GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR,
- struct GNUNET_TRANSPORT_CommunicatorAvailableMessage,
- NULL),
- GNUNET_MQ_hd_var_size (communicator_backchannel,
- GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL,
- struct GNUNET_TRANSPORT_CommunicatorBackchannel,
- NULL),
- GNUNET_MQ_hd_var_size (add_address,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS,
- struct GNUNET_TRANSPORT_AddAddressMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (del_address,
- GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS,
- struct GNUNET_TRANSPORT_DelAddressMessage,
- NULL),
- GNUNET_MQ_hd_var_size (incoming_msg,
- GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG,
- struct GNUNET_TRANSPORT_IncomingMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (queue_create_ok,
- GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK,
- struct GNUNET_TRANSPORT_CreateQueueResponse,
- NULL),
- GNUNET_MQ_hd_fixed_size (queue_create_fail,
- GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL,
- struct GNUNET_TRANSPORT_CreateQueueResponse,
- NULL),
- GNUNET_MQ_hd_var_size (add_queue_message,
- GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP,
- struct GNUNET_TRANSPORT_AddQueueMessage,
- NULL),
- GNUNET_MQ_hd_var_size (address_consider_verify,
- GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY,
- struct GNUNET_TRANSPORT_AddressToVerify,
- NULL),
- GNUNET_MQ_hd_fixed_size (del_queue_message,
- GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN,
- struct GNUNET_TRANSPORT_DelQueueMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (send_message_ack,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
- struct GNUNET_TRANSPORT_SendMessageToAck,
- NULL),
- /* communication with monitors */
- GNUNET_MQ_hd_fixed_size (monitor_start,
- GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START,
- struct GNUNET_TRANSPORT_MonitorStart,
- NULL),
- GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN (
+ "transport",
+ GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ /* communication with applications */
+ GNUNET_MQ_hd_fixed_size (suggest,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST,
+ struct ExpressPreferenceMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (suggest_cancel,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL,
+ struct ExpressPreferenceMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (request_hello_validation,
+
GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION,
+ struct RequestHelloValidationMessage,
+ NULL),
+ /* communication with core */
+ GNUNET_MQ_hd_fixed_size (client_start,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_START,
+ struct StartMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_send,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
+ struct OutboundMessage,
+ NULL),
+ /* communication with communicators */
+ GNUNET_MQ_hd_var_size (communicator_available,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR,
+ struct GNUNET_TRANSPORT_CommunicatorAvailableMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (communicator_backchannel,
+
GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL,
+ struct GNUNET_TRANSPORT_CommunicatorBackchannel,
+ NULL),
+ GNUNET_MQ_hd_var_size (add_address,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS,
+ struct GNUNET_TRANSPORT_AddAddressMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (del_address,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS,
+ struct GNUNET_TRANSPORT_DelAddressMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (incoming_msg,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG,
+ struct GNUNET_TRANSPORT_IncomingMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (queue_create_ok,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK,
+ struct GNUNET_TRANSPORT_CreateQueueResponse,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (queue_create_fail,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL,
+ struct GNUNET_TRANSPORT_CreateQueueResponse,
+ NULL),
+ GNUNET_MQ_hd_var_size (add_queue_message,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP,
+ struct GNUNET_TRANSPORT_AddQueueMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (address_consider_verify,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY,
+ struct GNUNET_TRANSPORT_AddressToVerify,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (del_queue_message,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN,
+ struct GNUNET_TRANSPORT_DelQueueMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (send_message_ack,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
+ struct GNUNET_TRANSPORT_SendMessageToAck,
+ NULL),
+ /* communication with monitors */
+ GNUNET_MQ_hd_fixed_size (monitor_start,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START,
+ struct GNUNET_TRANSPORT_MonitorStart,
+ NULL),
+ GNUNET_MQ_handler_end ());
/* end of file gnunet-service-transport.c */
--
To stop receiving notification emails like this one, please contact
address@hidden
- [GNUnet-SVN] [gnunet] branch master updated (6fc8b0b7f -> f308b735e),
gnunet <=