diff options
author | t3sserakt <t3ss@posteo.de> | 2022-03-17 14:28:40 +0100 |
---|---|---|
committer | t3sserakt <t3ss@posteo.de> | 2022-03-17 14:28:40 +0100 |
commit | 95a1edacccd9b3bf769a144a12d41946d0ac25dc (patch) | |
tree | b84608361cd836d29649f076589dd42943d1301f | |
parent | 16c9959d9b395b179446ee4a2cb70f3563c4fb20 (diff) | |
download | gnunet-95a1edacccd9b3bf769a144a12d41946d0ac25dc.tar.gz gnunet-95a1edacccd9b3bf769a144a12d41946d0ac25dc.zip |
- Trying to exchange iptables with nft, first shot failed.
- Fixed small bug in UDP communicator.
- Fixed bug in DV circle test case
- Introduced a default value to wait for a reliability ack.
- Introduced a FC retransmission threshold together with a retransmission count.
- Introduced a original size value for TransportDVBoxMessage
- Checking if we have the root pending messge, when removing the pending message from virtual link.
- Added delay value to schedule_transmit_on_queue to wait for retransmitting.
- Checking for confirmed virtual link, before routing.
- Allow unconfirmed queues or DV routes when doing dv encapsulation for control traffic.
- Changed check_vl_transmission to also check window size for DV next hop peer.
- Fixed fragment box handling to also handle reliability boxed message which needed to be fragmented.
- Fixed completing a message which was not only fragmented but also DV boxed.
- Added logic to notify core about a new virtual link using distance vector without having validated next neighbour.
- Added logic to create a virtual link to handle flow control messages.
- fixed several smaller bugs in fragmentation logic.
- Changed logic for adding the next_attempt value of PendingMessage.
-rwxr-xr-x | contrib/netjail/netjail_core.sh | 5 | ||||
-rwxr-xr-x | contrib/netjail/netjail_start.sh | 4 | ||||
-rw-r--r-- | src/transport/Makefile.am | 2 | ||||
-rw-r--r-- | src/transport/gnunet-communicator-udp.c | 29 | ||||
-rw-r--r-- | src/transport/gnunet-service-tng.c | 699 | ||||
-rw-r--r-- | src/transport/test_transport_distance_vector_circle_topo.conf | 2 | ||||
-rw-r--r-- | src/transport/test_transport_plugin_cmd_simple_send_dv.c | 79 | ||||
-rw-r--r-- | src/transport/transport_api_cmd_start_peer.c | 2 | ||||
-rw-r--r-- | src/util/mq.c | 11 |
9 files changed, 581 insertions, 252 deletions
diff --git a/contrib/netjail/netjail_core.sh b/contrib/netjail/netjail_core.sh index ed363cf35..da784fa5e 100755 --- a/contrib/netjail/netjail_core.sh +++ b/contrib/netjail/netjail_core.sh | |||
@@ -188,7 +188,10 @@ netjail_node_add_nat() { | |||
188 | local ADDRESS=$2 | 188 | local ADDRESS=$2 |
189 | local MASK=$3 | 189 | local MASK=$3 |
190 | 190 | ||
191 | ip netns exec $NODE iptables -t nat -A POSTROUTING -s "$ADDRESS/$MASK" -j MASQUERADE | 191 | ip netns exec $NODE nft add table nat |
192 | ip netns exec $NODE nft add chain nat postrouting { type nat hook postrouting priority 0 \; } | ||
193 | ip netns exec $NODE nft add rule ip nat postrouting ip saddr "$ADDRESS/$MASK" counter masquerade | ||
194 | # ip netns exec $NODE iptables -t nat -A POSTROUTING -s "$ADDRESS/$MASK" -j MASQUERADE | ||
192 | } | 195 | } |
193 | 196 | ||
194 | netjail_node_add_default() { | 197 | netjail_node_add_default() { |
diff --git a/contrib/netjail/netjail_start.sh b/contrib/netjail/netjail_start.sh index f7c417c27..e2d5fd634 100755 --- a/contrib/netjail/netjail_start.sh +++ b/contrib/netjail/netjail_start.sh | |||
@@ -77,11 +77,15 @@ for N in $(seq $GLOBAL_N); do | |||
77 | 77 | ||
78 | if [ "1" == "${R_TCP[$N]}" ] | 78 | if [ "1" == "${R_TCP[$N]}" ] |
79 | then | 79 | then |
80 | #ip netns exec ${ROUTERS[$N]} nft add rule ip nat prerouting ip daddr $GLOBAL_GROUP.$N tcp dport 60002 counter dnat to $LOCAL_GROUP.1 | ||
81 | #ip netns exec ${ROUTERS[$N]} nft add rule ip filter FORWARD ip daddr $LOCAL_GROUP.1 ct state new,related,established counter accept | ||
80 | ip netns exec ${ROUTERS[$N]} iptables -t nat -A PREROUTING -p tcp -d $GLOBAL_GROUP.$N --dport 60002 -j DNAT --to $LOCAL_GROUP.1 | 82 | ip netns exec ${ROUTERS[$N]} iptables -t nat -A PREROUTING -p tcp -d $GLOBAL_GROUP.$N --dport 60002 -j DNAT --to $LOCAL_GROUP.1 |
81 | ip netns exec ${ROUTERS[$N]} iptables -A FORWARD -d $LOCAL_GROUP.1 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT | 83 | ip netns exec ${ROUTERS[$N]} iptables -A FORWARD -d $LOCAL_GROUP.1 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT |
82 | fi | 84 | fi |
83 | if [ "1" == "${R_UDP[$N]}" ] | 85 | if [ "1" == "${R_UDP[$N]}" ] |
84 | then | 86 | then |
87 | #ip netns exec ${ROUTERS[$N]} nft add rule ip nat prerouting ip daddr $GLOBAL_GROUP.$N udp dport $PORT counter dnat to $LOCAL_GROUP.1 | ||
88 | #ip netns exec ${ROUTERS[$N]} nft add rule ip filter FORWARD ip daddr $LOCAL_GROUP.1 ct state new,related,established counter accept | ||
85 | ip netns exec ${ROUTERS[$N]} iptables -t nat -A PREROUTING -p udp -d $GLOBAL_GROUP.$N --dport $PORT -j DNAT --to $LOCAL_GROUP.1 | 89 | ip netns exec ${ROUTERS[$N]} iptables -t nat -A PREROUTING -p udp -d $GLOBAL_GROUP.$N --dport $PORT -j DNAT --to $LOCAL_GROUP.1 |
86 | ip netns exec ${ROUTERS[$N]} iptables -A FORWARD -d $LOCAL_GROUP.1 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT | 90 | ip netns exec ${ROUTERS[$N]} iptables -A FORWARD -d $LOCAL_GROUP.1 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT |
87 | fi | 91 | fi |
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am index 5d6fb8421..ec00bc917 100644 --- a/src/transport/Makefile.am +++ b/src/transport/Makefile.am | |||
@@ -778,7 +778,7 @@ check_SCRIPTS= \ | |||
778 | test_transport_simple_send.sh \ | 778 | test_transport_simple_send.sh \ |
779 | test_transport_simple_send_broadcast.sh \ | 779 | test_transport_simple_send_broadcast.sh \ |
780 | test_transport_udp_backchannel.sh \ | 780 | test_transport_udp_backchannel.sh \ |
781 | # test_transport_simple_send_dv_circle.sh | 781 | test_transport_simple_send_dv_circle.sh |
782 | # test_transport_simple_send_dv_inverse.sh | 782 | # test_transport_simple_send_dv_inverse.sh |
783 | 783 | ||
784 | test_transport_start_with_config_SOURCES = \ | 784 | test_transport_start_with_config_SOURCES = \ |
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c index b6edff485..70848ff79 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/transport/gnunet-communicator-udp.c | |||
@@ -1273,7 +1273,7 @@ pass_plaintext_to_core (struct SenderAddress *sender, | |||
1273 | const struct GNUNET_MessageHeader *hdr = plaintext; | 1273 | const struct GNUNET_MessageHeader *hdr = plaintext; |
1274 | const char *pos = plaintext; | 1274 | const char *pos = plaintext; |
1275 | 1275 | ||
1276 | while (ntohs (hdr->size) < plaintext_len) | 1276 | while (ntohs (hdr->size) <= plaintext_len) |
1277 | { | 1277 | { |
1278 | GNUNET_STATISTICS_update (stats, | 1278 | GNUNET_STATISTICS_update (stats, |
1279 | "# bytes given to core", | 1279 | "# bytes given to core", |
@@ -1722,6 +1722,12 @@ try_handle_plaintext (struct SenderAddress *sender, | |||
1722 | const struct UDPAck *ack = (const struct UDPAck *) buf; | 1722 | const struct UDPAck *ack = (const struct UDPAck *) buf; |
1723 | uint16_t type; | 1723 | uint16_t type; |
1724 | 1724 | ||
1725 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1726 | "try_handle_plaintext of size %u (%u %u) and type %u\n", | ||
1727 | buf_size, | ||
1728 | ntohs (hdr->size), | ||
1729 | sizeof(*hdr), | ||
1730 | ntohs (hdr->type)); | ||
1725 | if (sizeof(*hdr) > buf_size) | 1731 | if (sizeof(*hdr) > buf_size) |
1726 | return; /* not even a header */ | 1732 | return; /* not even a header */ |
1727 | if (ntohs (hdr->size) > buf_size) | 1733 | if (ntohs (hdr->size) > buf_size) |
@@ -2202,7 +2208,8 @@ verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, | |||
2202 | { | 2208 | { |
2203 | struct UdpHandshakeSignature uhs; | 2209 | struct UdpHandshakeSignature uhs; |
2204 | 2210 | ||
2205 | uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE); | 2211 | uhs.purpose.purpose = htonl ( |
2212 | GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE); | ||
2206 | uhs.purpose.size = htonl (sizeof(uhs)); | 2213 | uhs.purpose.size = htonl (sizeof(uhs)); |
2207 | uhs.sender = uc->sender; | 2214 | uhs.sender = uc->sender; |
2208 | uhs.receiver = my_identity; | 2215 | uhs.receiver = my_identity; |
@@ -2350,7 +2357,8 @@ sock_read (void *cls) | |||
2350 | "received UDPBroadcast from %s\n", | 2357 | "received UDPBroadcast from %s\n", |
2351 | GNUNET_a2s ((const struct sockaddr *) addr_verify, salen)); | 2358 | GNUNET_a2s ((const struct sockaddr *) addr_verify, salen)); |
2352 | ub = (const struct UDPBroadcast *) buf; | 2359 | ub = (const struct UDPBroadcast *) buf; |
2353 | uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST); | 2360 | uhs.purpose.purpose = htonl ( |
2361 | GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST); | ||
2354 | uhs.purpose.size = htonl (sizeof(uhs)); | 2362 | uhs.purpose.size = htonl (sizeof(uhs)); |
2355 | uhs.sender = ub->sender; | 2363 | uhs.sender = ub->sender; |
2356 | sender = ub->sender; | 2364 | sender = ub->sender; |
@@ -2366,10 +2374,11 @@ sock_read (void *cls) | |||
2366 | GNUNET_i2s (&sender)); | 2374 | GNUNET_i2s (&sender)); |
2367 | GNUNET_CRYPTO_hash ((struct sockaddr *) addr_verify, salen, &uhs.h_address); | 2375 | GNUNET_CRYPTO_hash ((struct sockaddr *) addr_verify, salen, &uhs.h_address); |
2368 | if (GNUNET_OK == | 2376 | if (GNUNET_OK == |
2369 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST, | 2377 | GNUNET_CRYPTO_eddsa_verify ( |
2370 | &uhs, | 2378 | GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST, |
2371 | &ub->sender_sig, | 2379 | &uhs, |
2372 | &ub->sender.public_key)) | 2380 | &ub->sender_sig, |
2381 | &ub->sender.public_key)) | ||
2373 | { | 2382 | { |
2374 | char *addr_s; | 2383 | char *addr_s; |
2375 | enum GNUNET_NetworkType nt; | 2384 | enum GNUNET_NetworkType nt; |
@@ -2699,7 +2708,8 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq, | |||
2699 | uc.sender = my_identity; | 2708 | uc.sender = my_identity; |
2700 | uc.monotonic_time = | 2709 | uc.monotonic_time = |
2701 | GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); | 2710 | GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); |
2702 | uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE); | 2711 | uhs.purpose.purpose = htonl ( |
2712 | GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE); | ||
2703 | uhs.purpose.size = htonl (sizeof(uhs)); | 2713 | uhs.purpose.size = htonl (sizeof(uhs)); |
2704 | uhs.sender = my_identity; | 2714 | uhs.sender = my_identity; |
2705 | uhs.receiver = receiver->target; | 2715 | uhs.receiver = receiver->target; |
@@ -3644,7 +3654,8 @@ iface_proc (void *cls, | |||
3644 | bi->salen = addrlen; | 3654 | bi->salen = addrlen; |
3645 | bi->found = GNUNET_YES; | 3655 | bi->found = GNUNET_YES; |
3646 | bi->bcm.sender = my_identity; | 3656 | bi->bcm.sender = my_identity; |
3647 | ubs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST); | 3657 | ubs.purpose.purpose = htonl ( |
3658 | GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST); | ||
3648 | ubs.purpose.size = htonl (sizeof(ubs)); | 3659 | ubs.purpose.size = htonl (sizeof(ubs)); |
3649 | ubs.sender = my_identity; | 3660 | ubs.sender = my_identity; |
3650 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3661 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c index 56a854a70..0427bd229 100644 --- a/src/transport/gnunet-service-tng.c +++ b/src/transport/gnunet-service-tng.c | |||
@@ -82,6 +82,11 @@ | |||
82 | #include "transport.h" | 82 | #include "transport.h" |
83 | 83 | ||
84 | /** | 84 | /** |
85 | * Maximum number of FC retransmissions for a runing retransmission task. | ||
86 | */ | ||
87 | #define MAX_FC_RETRANSMIT_COUNT 1000 | ||
88 | |||
89 | /** | ||
85 | * Maximum number of messages we acknowledge together in one | 90 | * Maximum number of messages we acknowledge together in one |
86 | * cumulative ACK. Larger values may save a bit of bandwidth. | 91 | * cumulative ACK. Larger values may save a bit of bandwidth. |
87 | */ | 92 | */ |
@@ -186,6 +191,12 @@ | |||
186 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) | 191 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) |
187 | 192 | ||
188 | /** | 193 | /** |
194 | * Default value for how long we wait for reliability ack. | ||
195 | */ | ||
196 | #define DEFAULT_ACK_WAIT_DURATION \ | ||
197 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) | ||
198 | |||
199 | /** | ||
189 | * We only consider queues as "quality" connections when | 200 | * We only consider queues as "quality" connections when |
190 | * suppressing the generation of DV initiation messages if | 201 | * suppressing the generation of DV initiation messages if |
191 | * the latency of the queue is below this threshold. | 202 | * the latency of the queue is below this threshold. |
@@ -781,6 +792,16 @@ struct TransportDVBoxMessage | |||
781 | */ | 792 | */ |
782 | struct GNUNET_HashCode hmac; | 793 | struct GNUNET_HashCode hmac; |
783 | 794 | ||
795 | /** | ||
796 | * Size this msg had initially. This is needed to calculate the hmac at the target. | ||
797 | * The header size can not be used for that, because the box size is getting smaller at each hop. | ||
798 | */ | ||
799 | /** | ||
800 | * The length of the struct (in bytes, including the length field itself), | ||
801 | * in big-endian format. | ||
802 | */ | ||
803 | uint16_t orig_size GNUNET_PACKED; | ||
804 | |||
784 | /* Followed by @e num_hops `struct GNUNET_PeerIdentity` values; | 805 | /* Followed by @e num_hops `struct GNUNET_PeerIdentity` values; |
785 | excluding the @e origin and the current peer, the last must be | 806 | excluding the @e origin and the current peer, the last must be |
786 | the ultimate target; if @e num_hops is zero, the receiver of this | 807 | the ultimate target; if @e num_hops is zero, the receiver of this |
@@ -1342,6 +1363,17 @@ struct VirtualLink | |||
1342 | struct GNUNET_SCHEDULER_Task *fc_retransmit_task; | 1363 | struct GNUNET_SCHEDULER_Task *fc_retransmit_task; |
1343 | 1364 | ||
1344 | /** | 1365 | /** |
1366 | * Number of FC retransmissions for this running task. | ||
1367 | */ | ||
1368 | unsigned int fc_retransmit_count; | ||
1369 | |||
1370 | /** | ||
1371 | * Is this VirtualLink confirmed. | ||
1372 | * A unconfirmed VirtualLink might exist, if we got a FC from that target. | ||
1373 | */ | ||
1374 | unsigned int confirmed; | ||
1375 | |||
1376 | /** | ||
1345 | * Neighbour used by this virtual link, NULL if @e dv is used. | 1377 | * Neighbour used by this virtual link, NULL if @e dv is used. |
1346 | */ | 1378 | */ |
1347 | struct Neighbour *n; | 1379 | struct Neighbour *n; |
@@ -2845,8 +2877,8 @@ free_pending_acknowledgement (struct PendingAcknowledgement *pa) | |||
2845 | struct PendingMessage *pm = pa->pm; | 2877 | struct PendingMessage *pm = pa->pm; |
2846 | struct DistanceVectorHop *dvh = pa->dvh; | 2878 | struct DistanceVectorHop *dvh = pa->dvh; |
2847 | 2879 | ||
2848 | GNUNET_CONTAINER_MDLL_remove (pa, pa_head, pa_tail, pa); | 2880 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2849 | pa_count--; | 2881 | "free_pending_acknowledgement\n"); |
2850 | if (NULL != q) | 2882 | if (NULL != q) |
2851 | { | 2883 | { |
2852 | GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa); | 2884 | GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa); |
@@ -2854,6 +2886,17 @@ free_pending_acknowledgement (struct PendingAcknowledgement *pa) | |||
2854 | } | 2886 | } |
2855 | if (NULL != pm) | 2887 | if (NULL != pm) |
2856 | { | 2888 | { |
2889 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2890 | "remove pa from message\n"); | ||
2891 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2892 | "remove pa from message %llu\n", | ||
2893 | pm->logging_uuid); | ||
2894 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2895 | "remove pa from message %u\n", | ||
2896 | pm->pmt); | ||
2897 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2898 | "remove pa from message %s\n", | ||
2899 | GNUNET_uuid2s (&pa->ack_uuid.value)); | ||
2857 | GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); | 2900 | GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); |
2858 | pa->pm = NULL; | 2901 | pa->pm = NULL; |
2859 | } | 2902 | } |
@@ -2920,8 +2963,11 @@ free_pending_message (struct PendingMessage *pm) | |||
2920 | tc->details.core.pending_msg_tail, | 2963 | tc->details.core.pending_msg_tail, |
2921 | pm); | 2964 | pm); |
2922 | } | 2965 | } |
2923 | if (NULL != vl) | 2966 | if ((NULL != vl) && (NULL == pm->frag_parent)) |
2924 | { | 2967 | { |
2968 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2969 | "Removing pm %lu\n", | ||
2970 | pm->logging_uuid); | ||
2925 | GNUNET_CONTAINER_MDLL_remove (vl, | 2971 | GNUNET_CONTAINER_MDLL_remove (vl, |
2926 | vl->pending_msg_head, | 2972 | vl->pending_msg_head, |
2927 | vl->pending_msg_tail, | 2973 | vl->pending_msg_tail, |
@@ -2929,6 +2975,18 @@ free_pending_message (struct PendingMessage *pm) | |||
2929 | } | 2975 | } |
2930 | while (NULL != (pa = pm->pa_head)) | 2976 | while (NULL != (pa = pm->pa_head)) |
2931 | { | 2977 | { |
2978 | if (NULL == pa) | ||
2979 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2980 | "free pending pa null\n"); | ||
2981 | if (NULL == pm->pa_tail) | ||
2982 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2983 | "free pending pa_tail null\n"); | ||
2984 | if (NULL == pa->prev_pa) | ||
2985 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2986 | "free pending pa prev null\n"); | ||
2987 | if (NULL == pa->next_pa) | ||
2988 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2989 | "free pending pa next null\n"); | ||
2932 | GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); | 2990 | GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); |
2933 | pa->pm = NULL; | 2991 | pa->pm = NULL; |
2934 | } | 2992 | } |
@@ -2944,6 +3002,9 @@ free_pending_message (struct PendingMessage *pm) | |||
2944 | free_fragment_tree (pm->bpm); | 3002 | free_fragment_tree (pm->bpm); |
2945 | GNUNET_free (pm->bpm); | 3003 | GNUNET_free (pm->bpm); |
2946 | } | 3004 | } |
3005 | if (NULL == pm) | ||
3006 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3007 | "free pending pm null\n"); | ||
2947 | GNUNET_free (pm); | 3008 | GNUNET_free (pm); |
2948 | } | 3009 | } |
2949 | 3010 | ||
@@ -3028,6 +3089,9 @@ free_virtual_link (struct VirtualLink *vl) | |||
3028 | struct PendingMessage *pm; | 3089 | struct PendingMessage *pm; |
3029 | struct CoreSentContext *csc; | 3090 | struct CoreSentContext *csc; |
3030 | 3091 | ||
3092 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3093 | "free virtual link\n"); | ||
3094 | |||
3031 | if (NULL != vl->reassembly_map) | 3095 | if (NULL != vl->reassembly_map) |
3032 | { | 3096 | { |
3033 | GNUNET_CONTAINER_multihashmap32_iterate (vl->reassembly_map, | 3097 | GNUNET_CONTAINER_multihashmap32_iterate (vl->reassembly_map, |
@@ -3084,6 +3148,8 @@ free_validation_state (struct ValidationState *vs) | |||
3084 | vs->hn = NULL; | 3148 | vs->hn = NULL; |
3085 | if (NULL != vs->sc) | 3149 | if (NULL != vs->sc) |
3086 | { | 3150 | { |
3151 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3152 | "store cancel\n"); | ||
3087 | GNUNET_PEERSTORE_store_cancel (vs->sc); | 3153 | GNUNET_PEERSTORE_store_cancel (vs->sc); |
3088 | vs->sc = NULL; | 3154 | vs->sc = NULL; |
3089 | } | 3155 | } |
@@ -3392,6 +3458,8 @@ free_neighbour (struct Neighbour *neighbour) | |||
3392 | } | 3458 | } |
3393 | if (NULL != neighbour->sc) | 3459 | if (NULL != neighbour->sc) |
3394 | { | 3460 | { |
3461 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3462 | "store cancel\n"); | ||
3395 | GNUNET_PEERSTORE_store_cancel (neighbour->sc); | 3463 | GNUNET_PEERSTORE_store_cancel (neighbour->sc); |
3396 | neighbour->sc = NULL; | 3464 | neighbour->sc = NULL; |
3397 | } | 3465 | } |
@@ -3503,7 +3571,8 @@ check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head) | |||
3503 | * @param p task priority to use, if @a queue is scheduled | 3571 | * @param p task priority to use, if @a queue is scheduled |
3504 | */ | 3572 | */ |
3505 | static void | 3573 | static void |
3506 | schedule_transmit_on_queue (struct Queue *queue, | 3574 | schedule_transmit_on_queue (struct GNUNET_TIME_Relative delay, |
3575 | struct Queue *queue, | ||
3507 | enum GNUNET_SCHEDULER_Priority p) | 3576 | enum GNUNET_SCHEDULER_Priority p) |
3508 | { | 3577 | { |
3509 | if (check_for_queue_with_higher_prio (queue, | 3578 | if (check_for_queue_with_higher_prio (queue, |
@@ -3552,7 +3621,8 @@ schedule_transmit_on_queue (struct Queue *queue, | |||
3552 | if (NULL != queue->transmit_task) | 3621 | if (NULL != queue->transmit_task) |
3553 | GNUNET_SCHEDULER_cancel (queue->transmit_task); | 3622 | GNUNET_SCHEDULER_cancel (queue->transmit_task); |
3554 | queue->transmit_task = | 3623 | queue->transmit_task = |
3555 | GNUNET_SCHEDULER_add_with_priority (p, &transmit_on_queue, queue); | 3624 | GNUNET_SCHEDULER_add_delayed_with_priority (delay, p, &transmit_on_queue, |
3625 | queue); | ||
3556 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3626 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
3557 | "Considering transmission on queue `%s' to %s\n", | 3627 | "Considering transmission on queue `%s' to %s\n", |
3558 | queue->address, | 3628 | queue->address, |
@@ -3677,13 +3747,15 @@ free_queue (struct Queue *queue) | |||
3677 | GNUNET_NO); | 3747 | GNUNET_NO); |
3678 | for (struct Queue *s = tc->details.communicator.queue_head; NULL != s; | 3748 | for (struct Queue *s = tc->details.communicator.queue_head; NULL != s; |
3679 | s = s->next_client) | 3749 | s = s->next_client) |
3680 | schedule_transmit_on_queue (s, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 3750 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
3751 | s, | ||
3752 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
3681 | } | 3753 | } |
3682 | notify_monitors (&neighbour->pid, queue->address, queue->nt, &me); | 3754 | notify_monitors (&neighbour->pid, queue->address, queue->nt, &me); |
3683 | GNUNET_free (queue); | 3755 | GNUNET_free (queue); |
3684 | 3756 | ||
3685 | vl = lookup_virtual_link (&neighbour->pid); | 3757 | vl = lookup_virtual_link (&neighbour->pid); |
3686 | if ((NULL != vl) && (neighbour == vl->n)) | 3758 | if ((NULL != vl) && (GNUNET_YES == vl->confirmed) && (neighbour == vl->n)) |
3687 | { | 3759 | { |
3688 | GNUNET_SCHEDULER_cancel (vl->visibility_task); | 3760 | GNUNET_SCHEDULER_cancel (vl->visibility_task); |
3689 | check_link_down (vl); | 3761 | check_link_down (vl); |
@@ -3710,6 +3782,8 @@ free_address_list_entry (struct AddressListEntry *ale) | |||
3710 | ale); | 3782 | ale); |
3711 | if (NULL != ale->sc) | 3783 | if (NULL != ale->sc) |
3712 | { | 3784 | { |
3785 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3786 | "store cancel\n"); | ||
3713 | GNUNET_PEERSTORE_store_cancel (ale->sc); | 3787 | GNUNET_PEERSTORE_store_cancel (ale->sc); |
3714 | ale->sc = NULL; | 3788 | ale->sc = NULL; |
3715 | } | 3789 | } |
@@ -3954,6 +4028,8 @@ client_send_response (struct PendingMessage *pm) | |||
3954 | struct TransportClient *tc = pm->client; | 4028 | struct TransportClient *tc = pm->client; |
3955 | struct VirtualLink *vl = pm->vl; | 4029 | struct VirtualLink *vl = pm->vl; |
3956 | 4030 | ||
4031 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4032 | "client send response\n"); | ||
3957 | if (NULL != tc) | 4033 | if (NULL != tc) |
3958 | { | 4034 | { |
3959 | struct GNUNET_MQ_Envelope *env; | 4035 | struct GNUNET_MQ_Envelope *env; |
@@ -4127,7 +4203,7 @@ handle_client_recv_ok (void *cls, const struct RecvOkMessage *rom) | |||
4127 | return; | 4203 | return; |
4128 | } | 4204 | } |
4129 | vl = lookup_virtual_link (&rom->peer); | 4205 | vl = lookup_virtual_link (&rom->peer); |
4130 | if (NULL == vl) | 4206 | if ((NULL == vl) || (GNUNET_NO == vl->confirmed)) |
4131 | { | 4207 | { |
4132 | GNUNET_STATISTICS_update (GST_stats, | 4208 | GNUNET_STATISTICS_update (GST_stats, |
4133 | "# RECV_OK dropped: virtual link unknown", | 4209 | "# RECV_OK dropped: virtual link unknown", |
@@ -4323,6 +4399,12 @@ queue_send_msg (struct Queue *queue, | |||
4323 | queue->idle = GNUNET_NO; | 4399 | queue->idle = GNUNET_NO; |
4324 | if (0 == queue->q_capacity) | 4400 | if (0 == queue->q_capacity) |
4325 | queue->idle = GNUNET_NO; | 4401 | queue->idle = GNUNET_NO; |
4402 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4403 | "Sending message of type %u (%u) and size %u with MQ %p\n", | ||
4404 | ntohs (((const struct GNUNET_MessageHeader *) payload)->type), | ||
4405 | ntohs (smt->header.size), | ||
4406 | payload_size, | ||
4407 | queue->tc->mq); | ||
4326 | GNUNET_MQ_send (queue->tc->mq, env); | 4408 | GNUNET_MQ_send (queue->tc->mq, env); |
4327 | } | 4409 | } |
4328 | } | 4410 | } |
@@ -4684,6 +4766,7 @@ encapsulate_for_dv (struct DistanceVector *dv, | |||
4684 | struct GNUNET_PeerIdentity *dhops; | 4766 | struct GNUNET_PeerIdentity *dhops; |
4685 | 4767 | ||
4686 | box_hdr.header.size = htons (sizeof(buf)); | 4768 | box_hdr.header.size = htons (sizeof(buf)); |
4769 | box_hdr.orig_size = htons (sizeof(buf)); | ||
4687 | box_hdr.num_hops = htons (num_hops); | 4770 | box_hdr.num_hops = htons (num_hops); |
4688 | memcpy (buf, &box_hdr, sizeof(box_hdr)); | 4771 | memcpy (buf, &box_hdr, sizeof(box_hdr)); |
4689 | dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)]; | 4772 | dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)]; |
@@ -4741,7 +4824,7 @@ send_dv_to_neighbour (void *cls, | |||
4741 | enum RouteMessageOptions options) | 4824 | enum RouteMessageOptions options) |
4742 | { | 4825 | { |
4743 | (void) cls; | 4826 | (void) cls; |
4744 | (void) route_via_neighbour (next_hop, hdr, options); | 4827 | (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED); |
4745 | } | 4828 | } |
4746 | 4829 | ||
4747 | 4830 | ||
@@ -4776,7 +4859,7 @@ route_control_message_without_fc (struct VirtualLink *vl, | |||
4776 | 4859 | ||
4777 | // TODO Do this elsewhere. vl should be given as parameter to method. | 4860 | // TODO Do this elsewhere. vl should be given as parameter to method. |
4778 | // vl = lookup_virtual_link (target); | 4861 | // vl = lookup_virtual_link (target); |
4779 | GNUNET_assert (NULL != vl); | 4862 | GNUNET_assert (NULL != vl && GNUNET_YES == vl->confirmed); |
4780 | if (NULL == vl) | 4863 | if (NULL == vl) |
4781 | return GNUNET_TIME_UNIT_FOREVER_REL; | 4864 | return GNUNET_TIME_UNIT_FOREVER_REL; |
4782 | n = vl->n; | 4865 | n = vl->n; |
@@ -4916,7 +4999,7 @@ consider_sending_fc (void *cls) | |||
4916 | fc.outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used); | 4999 | fc.outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used); |
4917 | fc.outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size); | 5000 | fc.outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size); |
4918 | fc.sender_time = GNUNET_TIME_absolute_hton (monotime); | 5001 | fc.sender_time = GNUNET_TIME_absolute_hton (monotime); |
4919 | rtt = route_control_message_without_fc (vl, &fc.header, RMO_NONE); | 5002 | rtt = route_control_message_without_fc (vl, &fc.header, RMO_DV_ALLOWED); |
4920 | if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us) | 5003 | if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us) |
4921 | { | 5004 | { |
4922 | rtt = GNUNET_TIME_UNIT_SECONDS; | 5005 | rtt = GNUNET_TIME_UNIT_SECONDS; |
@@ -4933,8 +5016,14 @@ consider_sending_fc (void *cls) | |||
4933 | } | 5016 | } |
4934 | if (NULL != vl->fc_retransmit_task) | 5017 | if (NULL != vl->fc_retransmit_task) |
4935 | GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); | 5018 | GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); |
5019 | if (MAX_FC_RETRANSMIT_COUNT == vl->fc_retransmit_count) | ||
5020 | { | ||
5021 | rtt = GNUNET_TIME_UNIT_MINUTES; | ||
5022 | vl->fc_retransmit_count = 0; | ||
5023 | } | ||
4936 | vl->fc_retransmit_task = | 5024 | vl->fc_retransmit_task = |
4937 | GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl); | 5025 | GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl); |
5026 | vl->fc_retransmit_count++; | ||
4938 | } | 5027 | } |
4939 | 5028 | ||
4940 | 5029 | ||
@@ -4960,14 +5049,20 @@ check_vl_transmission (struct VirtualLink *vl) | |||
4960 | struct Neighbour *n = vl->n; | 5049 | struct Neighbour *n = vl->n; |
4961 | struct DistanceVector *dv = vl->dv; | 5050 | struct DistanceVector *dv = vl->dv; |
4962 | struct GNUNET_TIME_Absolute now; | 5051 | struct GNUNET_TIME_Absolute now; |
5052 | struct VirtualLink *vl_next_hop; | ||
4963 | int elig; | 5053 | int elig; |
4964 | 5054 | ||
5055 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5056 | "check_vl_transmission to target %s\n", | ||
5057 | GNUNET_i2s (&vl->target)); | ||
4965 | /* Check that we have an eligible pending message! | 5058 | /* Check that we have an eligible pending message! |
4966 | (cheaper than having #transmit_on_queue() find out!) */ | 5059 | (cheaper than having #transmit_on_queue() find out!) */ |
4967 | elig = GNUNET_NO; | 5060 | elig = GNUNET_NO; |
4968 | for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm; | 5061 | for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm; |
4969 | pm = pm->next_vl) | 5062 | pm = pm->next_vl) |
4970 | { | 5063 | { |
5064 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5065 | "check_vl_transmission loop\n"); | ||
4971 | if (NULL != pm->qe) | 5066 | if (NULL != pm->qe) |
4972 | continue; /* not eligible, is in a queue! */ | 5067 | continue; /* not eligible, is in a queue! */ |
4973 | if (pm->bytes_msg + vl->outbound_fc_window_size_used > | 5068 | if (pm->bytes_msg + vl->outbound_fc_window_size_used > |
@@ -4983,62 +5078,96 @@ check_vl_transmission (struct VirtualLink *vl) | |||
4983 | consider_sending_fc (vl); | 5078 | consider_sending_fc (vl); |
4984 | return; /* We have a message, but flow control says "nope" */ | 5079 | return; /* We have a message, but flow control says "nope" */ |
4985 | } | 5080 | } |
4986 | elig = GNUNET_YES; | ||
4987 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 5081 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
4988 | "Eligible message %lu of size %llu to %s: %llu/%llu\n", | 5082 | "Target window on VL %s not stalled. Scheduling transmission on queue\n", |
4989 | pm->logging_uuid, | 5083 | GNUNET_i2s (&vl->target)); |
4990 | pm->bytes_msg, | 5084 | /* Notify queues at direct neighbours that we are interested */ |
4991 | GNUNET_i2s (&vl->target), | 5085 | now = GNUNET_TIME_absolute_get (); |
4992 | (unsigned long long) vl->outbound_fc_window_size, | 5086 | if (NULL != n) |
4993 | (unsigned long long) (pm->bytes_msg | ||
4994 | + vl->outbound_fc_window_size_used)); | ||
4995 | break; | ||
4996 | } | ||
4997 | if (GNUNET_NO == elig) | ||
4998 | return; | ||
4999 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5000 | "Not stalled. Scheduling transmission on queue\n"); | ||
5001 | /* Notify queues at direct neighbours that we are interested */ | ||
5002 | now = GNUNET_TIME_absolute_get (); | ||
5003 | if (NULL != n) | ||
5004 | { | ||
5005 | for (struct Queue *queue = n->queue_head; NULL != queue; | ||
5006 | queue = queue->next_neighbour) | ||
5007 | { | ||
5008 | if ((GNUNET_YES == queue->idle) && | ||
5009 | (queue->validated_until.abs_value_us > now.abs_value_us)) | ||
5010 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
5011 | else | ||
5012 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5013 | "Neighbour Queue QID: %u (%u) busy or invalid\n", | ||
5014 | queue->qid, | ||
5015 | queue->idle); | ||
5016 | } | ||
5017 | } | ||
5018 | /* Notify queues via DV that we are interested */ | ||
5019 | if (NULL != dv) | ||
5020 | { | ||
5021 | /* Do DV with lower scheduler priority, which effectively means that | ||
5022 | IF a neighbour exists and is available, we prefer it. */ | ||
5023 | for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; | ||
5024 | pos = pos->next_dv) | ||
5025 | { | 5087 | { |
5026 | struct Neighbour *nh = pos->next_hop; | 5088 | for (struct Queue *queue = n->queue_head; NULL != queue; |
5027 | |||
5028 | if (pos->path_valid_until.abs_value_us <= now.abs_value_us) | ||
5029 | continue; /* skip this one: path not validated */ | ||
5030 | for (struct Queue *queue = nh->queue_head; NULL != queue; | ||
5031 | queue = queue->next_neighbour) | 5089 | queue = queue->next_neighbour) |
5090 | { | ||
5032 | if ((GNUNET_YES == queue->idle) && | 5091 | if ((GNUNET_YES == queue->idle) && |
5033 | (queue->validated_until.abs_value_us > now.abs_value_us)) | 5092 | (queue->validated_until.abs_value_us > now.abs_value_us)) |
5034 | schedule_transmit_on_queue (queue, | 5093 | { |
5035 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND); | 5094 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
5095 | "Direct neighbour %s not stalled\n", | ||
5096 | GNUNET_i2s (&n->pid)); | ||
5097 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, | ||
5098 | queue, | ||
5099 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
5100 | elig = GNUNET_YES; | ||
5101 | } | ||
5036 | else | 5102 | else |
5037 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 5103 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
5038 | "DV Queue QID: %u (%u) busy or invalid\n", | 5104 | "Neighbour Queue QID: %u (%u) busy or invalid\n", |
5039 | queue->qid, | 5105 | queue->qid, |
5040 | queue->idle); | 5106 | queue->idle); |
5107 | } | ||
5041 | } | 5108 | } |
5109 | /* Notify queues via DV that we are interested */ | ||
5110 | if (NULL != dv) | ||
5111 | { | ||
5112 | /* Do DV with lower scheduler priority, which effectively means that | ||
5113 | IF a neighbour exists and is available, we prefer it. */ | ||
5114 | for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; | ||
5115 | pos = pos->next_dv) | ||
5116 | { | ||
5117 | struct Neighbour *nh = pos->next_hop; | ||
5118 | |||
5119 | |||
5120 | if (pos->path_valid_until.abs_value_us <= now.abs_value_us) | ||
5121 | continue; /* skip this one: path not validated */ | ||
5122 | else | ||
5123 | { | ||
5124 | vl_next_hop = lookup_virtual_link (&nh->pid); | ||
5125 | if (pm->bytes_msg + vl_next_hop->outbound_fc_window_size_used > | ||
5126 | vl_next_hop->outbound_fc_window_size) | ||
5127 | { | ||
5128 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5129 | "Stalled message %lu transmission on next hop %s due to flow control: %llu < %llu\n", | ||
5130 | pm->logging_uuid, | ||
5131 | GNUNET_i2s (&vl_next_hop->target), | ||
5132 | (unsigned long | ||
5133 | long) vl_next_hop->outbound_fc_window_size, | ||
5134 | (unsigned long long) (pm->bytes_msg | ||
5135 | + vl_next_hop-> | ||
5136 | outbound_fc_window_size_used)); | ||
5137 | consider_sending_fc (vl_next_hop); | ||
5138 | continue; /* We have a message, but flow control says "nope" for the first hop of this path */ | ||
5139 | } | ||
5140 | for (struct Queue *queue = nh->queue_head; NULL != queue; | ||
5141 | queue = queue->next_neighbour) | ||
5142 | if ((GNUNET_YES == queue->idle) && | ||
5143 | (queue->validated_until.abs_value_us > now.abs_value_us)) | ||
5144 | { | ||
5145 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5146 | "Next hop neighbour %s not stalled\n", | ||
5147 | GNUNET_i2s (&nh->pid)); | ||
5148 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, | ||
5149 | queue, | ||
5150 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND); | ||
5151 | elig = GNUNET_YES; | ||
5152 | } | ||
5153 | else | ||
5154 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5155 | "DV Queue QID: %u (%u) busy or invalid\n", | ||
5156 | queue->qid, | ||
5157 | queue->idle); | ||
5158 | } | ||
5159 | } | ||
5160 | } | ||
5161 | if (GNUNET_YES == elig) | ||
5162 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5163 | "Eligible message %lu of size %llu to %s: %llu/%llu\n", | ||
5164 | pm->logging_uuid, | ||
5165 | pm->bytes_msg, | ||
5166 | GNUNET_i2s (&vl->target), | ||
5167 | (unsigned long long) vl->outbound_fc_window_size, | ||
5168 | (unsigned long long) (pm->bytes_msg | ||
5169 | + vl->outbound_fc_window_size_used)); | ||
5170 | break; | ||
5042 | } | 5171 | } |
5043 | } | 5172 | } |
5044 | 5173 | ||
@@ -5064,7 +5193,7 @@ handle_client_send (void *cls, const struct OutboundMessage *obm) | |||
5064 | bytes_msg = ntohs (obmm->size); | 5193 | bytes_msg = ntohs (obmm->size); |
5065 | pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority); | 5194 | pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority); |
5066 | vl = lookup_virtual_link (&obm->peer); | 5195 | vl = lookup_virtual_link (&obm->peer); |
5067 | if (NULL == vl) | 5196 | if ((NULL == vl) || (GNUNET_NO == vl->confirmed)) |
5068 | { | 5197 | { |
5069 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 5198 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
5070 | "Don't have %s as a neighbour (anymore).\n", | 5199 | "Don't have %s as a neighbour (anymore).\n", |
@@ -5154,7 +5283,7 @@ handle_communicator_backchannel ( | |||
5154 | strlen (is) + 1); | 5283 | strlen (is) + 1); |
5155 | // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED); | 5284 | // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED); |
5156 | vl = lookup_virtual_link (&cb->pid); | 5285 | vl = lookup_virtual_link (&cb->pid); |
5157 | if (NULL != vl) | 5286 | if ((NULL != vl) && (GNUNET_YES == vl->confirmed)) |
5158 | { | 5287 | { |
5159 | route_control_message_without_fc (vl, &be->header, RMO_DV_ALLOWED); | 5288 | route_control_message_without_fc (vl, &be->header, RMO_DV_ALLOWED); |
5160 | } | 5289 | } |
@@ -5428,7 +5557,7 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5428 | return; | 5557 | return; |
5429 | } | 5558 | } |
5430 | vl = lookup_virtual_link (&cmc->im.sender); | 5559 | vl = lookup_virtual_link (&cmc->im.sender); |
5431 | if (NULL == vl) | 5560 | if ((NULL == vl) || (GNUNET_NO == vl->confirmed)) |
5432 | { | 5561 | { |
5433 | /* FIXME: sender is giving us messages for CORE but we don't have | 5562 | /* FIXME: sender is giving us messages for CORE but we don't have |
5434 | the link up yet! I *suspect* this can happen right now (i.e. | 5563 | the link up yet! I *suspect* this can happen right now (i.e. |
@@ -5624,7 +5753,7 @@ transmit_cummulative_ack_cb (void *cls) | |||
5624 | &ack->header, | 5753 | &ack->header, |
5625 | RMO_DV_ALLOWED);*/ | 5754 | RMO_DV_ALLOWED);*/ |
5626 | vl = lookup_virtual_link (&ac->target); | 5755 | vl = lookup_virtual_link (&ac->target); |
5627 | if (NULL != vl) | 5756 | if ((NULL != vl) && (GNUNET_YES == vl->confirmed)) |
5628 | { | 5757 | { |
5629 | route_control_message_without_fc ( | 5758 | route_control_message_without_fc ( |
5630 | vl, | 5759 | vl, |
@@ -5765,7 +5894,7 @@ handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) | |||
5765 | struct FindByMessageUuidContext fc; | 5894 | struct FindByMessageUuidContext fc; |
5766 | 5895 | ||
5767 | vl = lookup_virtual_link (&cmc->im.sender); | 5896 | vl = lookup_virtual_link (&cmc->im.sender); |
5768 | if (NULL == vl) | 5897 | if ((NULL == vl) || (GNUNET_NO == vl->confirmed)) |
5769 | { | 5898 | { |
5770 | struct GNUNET_SERVICE_Client *client = cmc->tc->client; | 5899 | struct GNUNET_SERVICE_Client *client = cmc->tc->client; |
5771 | 5900 | ||
@@ -5794,6 +5923,7 @@ handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) | |||
5794 | fb->msg_uuid.uuid, | 5923 | fb->msg_uuid.uuid, |
5795 | &find_by_message_uuid, | 5924 | &find_by_message_uuid, |
5796 | &fc); | 5925 | &fc); |
5926 | fsize = ntohs (fb->header.size) - sizeof(*fb); | ||
5797 | if (NULL == (rc = fc.rc)) | 5927 | if (NULL == (rc = fc.rc)) |
5798 | { | 5928 | { |
5799 | rc = GNUNET_malloc (sizeof(*rc) + msize /* reassembly payload buffer */ | 5929 | rc = GNUNET_malloc (sizeof(*rc) + msize /* reassembly payload buffer */ |
@@ -5815,11 +5945,16 @@ handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) | |||
5815 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | 5945 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); |
5816 | target = (char *) &rc[1]; | 5946 | target = (char *) &rc[1]; |
5817 | rc->bitfield = (uint8_t *) (target + rc->msg_size); | 5947 | rc->bitfield = (uint8_t *) (target + rc->msg_size); |
5818 | rc->msg_missing = rc->msg_size; | 5948 | if (fsize != rc->msg_size) |
5949 | rc->msg_missing = rc->msg_size; | ||
5950 | else | ||
5951 | rc->msg_missing = 0; | ||
5819 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 5952 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
5820 | "Received fragment at offset %u/%u from %s for NEW message %u\n", | 5953 | "Received fragment with size %u at offset %u/%u %u bytes missing from %s for NEW message %u\n", |
5954 | fsize, | ||
5821 | ntohs (fb->frag_off), | 5955 | ntohs (fb->frag_off), |
5822 | msize, | 5956 | msize, |
5957 | rc->msg_missing, | ||
5823 | GNUNET_i2s (&cmc->im.sender), | 5958 | GNUNET_i2s (&cmc->im.sender), |
5824 | (unsigned int) fb->msg_uuid.uuid); | 5959 | (unsigned int) fb->msg_uuid.uuid); |
5825 | } | 5960 | } |
@@ -5841,7 +5976,6 @@ handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) | |||
5841 | } | 5976 | } |
5842 | 5977 | ||
5843 | /* reassemble */ | 5978 | /* reassemble */ |
5844 | fsize = ntohs (fb->header.size) - sizeof(*fb); | ||
5845 | if (0 == fsize) | 5979 | if (0 == fsize) |
5846 | { | 5980 | { |
5847 | GNUNET_break (0); | 5981 | GNUNET_break (0); |
@@ -5918,6 +6052,16 @@ check_reliability_box (void *cls, | |||
5918 | const struct TransportReliabilityBoxMessage *rb) | 6052 | const struct TransportReliabilityBoxMessage *rb) |
5919 | { | 6053 | { |
5920 | (void) cls; | 6054 | (void) cls; |
6055 | const struct GNUNET_MessageHeader *inbox = (const struct | ||
6056 | GNUNET_MessageHeader *) &rb[1]; | ||
6057 | |||
6058 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6059 | "check_send_msg with size %u: inner msg type %u and size %u (%u %u)\n", | ||
6060 | ntohs (rb->header.size), | ||
6061 | ntohs (inbox->type), | ||
6062 | ntohs (inbox->size), | ||
6063 | sizeof (struct TransportReliabilityBoxMessage), | ||
6064 | sizeof (struct GNUNET_MessageHeader)); | ||
5921 | GNUNET_MQ_check_boxed_message (rb); | 6065 | GNUNET_MQ_check_boxed_message (rb); |
5922 | return GNUNET_YES; | 6066 | return GNUNET_YES; |
5923 | } | 6067 | } |
@@ -6060,6 +6204,10 @@ completed_pending_message (struct PendingMessage *pm) | |||
6060 | { | 6204 | { |
6061 | struct PendingMessage *pos; | 6205 | struct PendingMessage *pos; |
6062 | 6206 | ||
6207 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6208 | "Complete transmission of message %llu %u\n", | ||
6209 | pm->logging_uuid, | ||
6210 | pm->pmt); | ||
6063 | switch (pm->pmt) | 6211 | switch (pm->pmt) |
6064 | { | 6212 | { |
6065 | case PMT_CORE: | 6213 | case PMT_CORE: |
@@ -6069,7 +6217,7 @@ completed_pending_message (struct PendingMessage *pm) | |||
6069 | return; | 6217 | return; |
6070 | 6218 | ||
6071 | case PMT_FRAGMENT_BOX: | 6219 | case PMT_FRAGMENT_BOX: |
6072 | /* Fragment sent over reliabile channel */ | 6220 | /* Fragment sent over reliable channel */ |
6073 | free_fragment_tree (pm); | 6221 | free_fragment_tree (pm); |
6074 | pos = pm->frag_parent; | 6222 | pos = pm->frag_parent; |
6075 | GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); | 6223 | GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); |
@@ -6080,11 +6228,17 @@ completed_pending_message (struct PendingMessage *pm) | |||
6080 | { | 6228 | { |
6081 | pm = pos; | 6229 | pm = pos; |
6082 | pos = pm->frag_parent; | 6230 | pos = pm->frag_parent; |
6231 | if (PMT_DV_BOX == pm->pmt) | ||
6232 | { | ||
6233 | GNUNET_free (pm); | ||
6234 | client_send_response (pos); | ||
6235 | return; | ||
6236 | } | ||
6083 | GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); | 6237 | GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); |
6084 | GNUNET_free (pm); | 6238 | GNUNET_free (pm); |
6085 | } | 6239 | } |
6086 | 6240 | ||
6087 | /* Was this the last applicable fragmment? */ | 6241 | /* Was this the last applicable fragment? */ |
6088 | if ((NULL == pos->head_frag) && (NULL == pos->frag_parent) && | 6242 | if ((NULL == pos->head_frag) && (NULL == pos->frag_parent) && |
6089 | (pos->frag_off == pos->bytes_msg)) | 6243 | (pos->frag_off == pos->bytes_msg)) |
6090 | client_send_response (pos); | 6244 | client_send_response (pos); |
@@ -6293,6 +6447,7 @@ handle_backchannel_encapsulation ( | |||
6293 | target_communicator); | 6447 | target_communicator); |
6294 | GNUNET_STATISTICS_update (GST_stats, stastr, 1, GNUNET_NO); | 6448 | GNUNET_STATISTICS_update (GST_stats, stastr, 1, GNUNET_NO); |
6295 | GNUNET_free (stastr); | 6449 | GNUNET_free (stastr); |
6450 | finish_cmc_handling (cmc); | ||
6296 | return; | 6451 | return; |
6297 | } | 6452 | } |
6298 | /* Finally, deliver backchannel message to communicator */ | 6453 | /* Finally, deliver backchannel message to communicator */ |
@@ -6309,6 +6464,7 @@ handle_backchannel_encapsulation ( | |||
6309 | cbi->pid = cmc->im.sender; | 6464 | cbi->pid = cmc->im.sender; |
6310 | memcpy (&cbi[1], inbox, isize); | 6465 | memcpy (&cbi[1], inbox, isize); |
6311 | GNUNET_MQ_send (tc->mq, env); | 6466 | GNUNET_MQ_send (tc->mq, env); |
6467 | finish_cmc_handling (cmc); | ||
6312 | } | 6468 | } |
6313 | 6469 | ||
6314 | 6470 | ||
@@ -6359,39 +6515,54 @@ activate_core_visible_dv_path (struct DistanceVectorHop *hop) | |||
6359 | struct VirtualLink *vl; | 6515 | struct VirtualLink *vl; |
6360 | 6516 | ||
6361 | vl = lookup_virtual_link (&dv->target); | 6517 | vl = lookup_virtual_link (&dv->target); |
6362 | if (NULL != vl) | 6518 | if (NULL == vl) |
6363 | { | 6519 | { |
6364 | /* Link was already up, remember dv is also now available and we are done */ | ||
6365 | vl->dv = dv; | ||
6366 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 6520 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
6367 | "Virtual link to %s could now also use DV!\n", | 6521 | "Creating new virtual link to %s using DV!\n", |
6368 | GNUNET_i2s (&dv->target)); | 6522 | GNUNET_i2s (&dv->target)); |
6369 | return; | 6523 | vl = GNUNET_new (struct VirtualLink); |
6524 | vl->confirmed = GNUNET_YES; | ||
6525 | vl->message_uuid_ctr = | ||
6526 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); | ||
6527 | vl->target = dv->target; | ||
6528 | vl->core_recv_window = RECV_WINDOW_SIZE; | ||
6529 | vl->available_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
6530 | vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
6531 | GNUNET_break (GNUNET_YES == | ||
6532 | GNUNET_CONTAINER_multipeermap_put ( | ||
6533 | links, | ||
6534 | &vl->target, | ||
6535 | vl, | ||
6536 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
6537 | vl->dv = dv; | ||
6538 | dv->vl = vl; | ||
6539 | vl->visibility_task = | ||
6540 | GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl); | ||
6541 | consider_sending_fc (vl); | ||
6542 | /* We lacked a confirmed connection to the target | ||
6543 | before, so tell CORE about it (finally!) */ | ||
6544 | cores_send_connect_info (&dv->target); | ||
6545 | } | ||
6546 | else | ||
6547 | { | ||
6548 | /* Link was already up, remember dv is also now available and we are done */ | ||
6549 | vl->dv = dv; | ||
6550 | dv->vl = vl; | ||
6551 | if (GNUNET_NO == vl->confirmed) | ||
6552 | { | ||
6553 | vl->confirmed = GNUNET_YES; | ||
6554 | vl->visibility_task = | ||
6555 | GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl); | ||
6556 | consider_sending_fc (vl); | ||
6557 | /* We lacked a confirmed connection to the target | ||
6558 | before, so tell CORE about it (finally!) */ | ||
6559 | cores_send_connect_info (&dv->target); | ||
6560 | } | ||
6561 | else | ||
6562 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6563 | "Virtual link to %s could now also use DV!\n", | ||
6564 | GNUNET_i2s (&dv->target)); | ||
6370 | } | 6565 | } |
6371 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6372 | "Creating new virtual link to %s using DV!\n", | ||
6373 | GNUNET_i2s (&dv->target)); | ||
6374 | vl = GNUNET_new (struct VirtualLink); | ||
6375 | vl->message_uuid_ctr = | ||
6376 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); | ||
6377 | vl->target = dv->target; | ||
6378 | vl->dv = dv; | ||
6379 | dv->vl = vl; | ||
6380 | vl->core_recv_window = RECV_WINDOW_SIZE; | ||
6381 | vl->available_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
6382 | vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
6383 | vl->visibility_task = | ||
6384 | GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl); | ||
6385 | GNUNET_break (GNUNET_YES == | ||
6386 | GNUNET_CONTAINER_multipeermap_put ( | ||
6387 | links, | ||
6388 | &vl->target, | ||
6389 | vl, | ||
6390 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
6391 | consider_sending_fc (vl); | ||
6392 | /* We lacked a confirmed connection to the target | ||
6393 | before, so tell CORE about it (finally!) */ | ||
6394 | cores_send_connect_info (&dv->target); | ||
6395 | } | 6566 | } |
6396 | 6567 | ||
6397 | 6568 | ||
@@ -6530,8 +6701,10 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path, | |||
6530 | return GNUNET_NO; | 6701 | return GNUNET_NO; |
6531 | } | 6702 | } |
6532 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 6703 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
6533 | "Refreshed known path to %s, forwarding further\n", | 6704 | "Refreshed known path to %s valid until %s, forwarding further\n", |
6534 | GNUNET_i2s (&dv->target)); | 6705 | GNUNET_i2s (&dv->target), |
6706 | GNUNET_STRINGS_absolute_time_to_string ( | ||
6707 | pos->path_valid_until)); | ||
6535 | return GNUNET_YES; | 6708 | return GNUNET_YES; |
6536 | } | 6709 | } |
6537 | } | 6710 | } |
@@ -6548,8 +6721,9 @@ learn_dv_path (const struct GNUNET_PeerIdentity *path, | |||
6548 | } | 6721 | } |
6549 | /* create new DV path entry */ | 6722 | /* create new DV path entry */ |
6550 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 6723 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
6551 | "Discovered new DV path to %s\n", | 6724 | "Discovered new DV path to %s valid until %s\n", |
6552 | GNUNET_i2s (&dv->target)); | 6725 | GNUNET_i2s (&dv->target), |
6726 | GNUNET_STRINGS_absolute_time_to_string (path_valid_until)); | ||
6553 | hop = GNUNET_malloc (sizeof(struct DistanceVectorHop) | 6727 | hop = GNUNET_malloc (sizeof(struct DistanceVectorHop) |
6554 | + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3)); | 6728 | + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3)); |
6555 | hop->next_hop = next_hop; | 6729 | hop->next_hop = next_hop; |
@@ -6680,7 +6854,7 @@ forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop, | |||
6680 | &fwd->header, | 6854 | &fwd->header, |
6681 | RMO_UNCONFIRMED_ALLOWED);*/ | 6855 | RMO_UNCONFIRMED_ALLOWED);*/ |
6682 | vl = lookup_virtual_link (next_hop); | 6856 | vl = lookup_virtual_link (next_hop); |
6683 | if (NULL != vl) | 6857 | if ((NULL != vl) && (GNUNET_YES == vl->confirmed)) |
6684 | { | 6858 | { |
6685 | route_control_message_without_fc (vl, | 6859 | route_control_message_without_fc (vl, |
6686 | &fwd->header, | 6860 | &fwd->header, |
@@ -6977,13 +7151,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
6977 | struct GNUNET_TIME_Absolute in_time; | 7151 | struct GNUNET_TIME_Absolute in_time; |
6978 | struct Neighbour *n; | 7152 | struct Neighbour *n; |
6979 | 7153 | ||
6980 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6981 | "handle dv learn message from %s\n", | ||
6982 | GNUNET_i2s (&dvl->initiator)); | ||
6983 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
6984 | "handle dv learn message sender %s\n", | ||
6985 | GNUNET_i2s (&cmc->im.sender)); | ||
6986 | |||
6987 | nhops = ntohs (dvl->num_hops); /* 0 = sender is initiator */ | 7154 | nhops = ntohs (dvl->num_hops); /* 0 = sender is initiator */ |
6988 | bi_history = ntohs (dvl->bidirectional); | 7155 | bi_history = ntohs (dvl->bidirectional); |
6989 | hops = (const struct DVPathEntryP *) &dvl[1]; | 7156 | hops = (const struct DVPathEntryP *) &dvl[1]; |
@@ -7017,10 +7184,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7017 | cc); // FIXME: add bi-directional flag to cc? | 7184 | cc); // FIXME: add bi-directional flag to cc? |
7018 | in_time = GNUNET_TIME_absolute_get (); | 7185 | in_time = GNUNET_TIME_absolute_get (); |
7019 | 7186 | ||
7020 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7021 | "2 handle dv learn message from %s\n", | ||
7022 | GNUNET_i2s (&dvl->initiator)); | ||
7023 | |||
7024 | /* continue communicator here, everything else can happen asynchronous! */ | 7187 | /* continue communicator here, everything else can happen asynchronous! */ |
7025 | finish_cmc_handling (cmc); | 7188 | finish_cmc_handling (cmc); |
7026 | 7189 | ||
@@ -7055,7 +7218,11 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7055 | if (GNUNET_YES == n->dv_monotime_available) | 7218 | if (GNUNET_YES == n->dv_monotime_available) |
7056 | { | 7219 | { |
7057 | if (NULL != n->sc) | 7220 | if (NULL != n->sc) |
7221 | { | ||
7222 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7223 | "store cancel\n"); | ||
7058 | GNUNET_PEERSTORE_store_cancel (n->sc); | 7224 | GNUNET_PEERSTORE_store_cancel (n->sc); |
7225 | } | ||
7059 | n->sc = | 7226 | n->sc = |
7060 | GNUNET_PEERSTORE_store (peerstore, | 7227 | GNUNET_PEERSTORE_store (peerstore, |
7061 | "transport", | 7228 | "transport", |
@@ -7069,9 +7236,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7069 | n); | 7236 | n); |
7070 | } | 7237 | } |
7071 | } | 7238 | } |
7072 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7073 | "3 handle dv learn message from %s\n", | ||
7074 | GNUNET_i2s (&dvl->initiator)); | ||
7075 | /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!, | 7239 | /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!, |
7076 | If signature verification load too high, implement random drop strategy */ | 7240 | If signature verification load too high, implement random drop strategy */ |
7077 | for (unsigned int i = 0; i < nhops; i++) | 7241 | for (unsigned int i = 0; i < nhops; i++) |
@@ -7110,9 +7274,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7110 | return; | 7274 | return; |
7111 | } | 7275 | } |
7112 | } | 7276 | } |
7113 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7114 | "4 handle dv learn message from %s\n", | ||
7115 | GNUNET_i2s (&dvl->initiator)); | ||
7116 | if (GNUNET_EXTRA_LOGGING > 0) | 7277 | if (GNUNET_EXTRA_LOGGING > 0) |
7117 | { | 7278 | { |
7118 | char *path; | 7279 | char *path; |
@@ -7137,9 +7298,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7137 | GNUNET_i2s (&GST_my_identity)); | 7298 | GNUNET_i2s (&GST_my_identity)); |
7138 | GNUNET_free (path); | 7299 | GNUNET_free (path); |
7139 | } | 7300 | } |
7140 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7141 | "5 handle dv learn message from %s\n", | ||
7142 | GNUNET_i2s (&dvl->initiator)); | ||
7143 | do_fwd = GNUNET_YES; | 7301 | do_fwd = GNUNET_YES; |
7144 | if (0 == GNUNET_memcmp (&GST_my_identity, &dvl->initiator)) | 7302 | if (0 == GNUNET_memcmp (&GST_my_identity, &dvl->initiator)) |
7145 | { | 7303 | { |
@@ -7147,6 +7305,7 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7147 | struct GNUNET_TIME_Relative host_latency_sum; | 7305 | struct GNUNET_TIME_Relative host_latency_sum; |
7148 | struct GNUNET_TIME_Relative latency; | 7306 | struct GNUNET_TIME_Relative latency; |
7149 | struct GNUNET_TIME_Relative network_latency; | 7307 | struct GNUNET_TIME_Relative network_latency; |
7308 | struct GNUNET_TIME_Absolute now; | ||
7150 | 7309 | ||
7151 | /* We initiated this, learn the forward path! */ | 7310 | /* We initiated this, learn the forward path! */ |
7152 | path[0] = GST_my_identity; | 7311 | path[0] = GST_my_identity; |
@@ -7155,7 +7314,11 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7155 | 7314 | ||
7156 | // Need also something to lookup initiation time | 7315 | // Need also something to lookup initiation time |
7157 | // to compute RTT! -> add RTT argument here? | 7316 | // to compute RTT! -> add RTT argument here? |
7158 | latency = GNUNET_TIME_UNIT_FOREVER_REL; // FIXME: initialize properly | 7317 | now = GNUNET_TIME_absolute_get (); |
7318 | latency = GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh ( | ||
7319 | dvl->monotonic_time)); | ||
7320 | GNUNET_assert (latency.rel_value_us >= host_latency_sum.rel_value_us); | ||
7321 | // latency = GNUNET_TIME_UNIT_FOREVER_REL; // FIXME: initialize properly | ||
7159 | // (based on dvl->challenge, we can identify time of origin!) | 7322 | // (based on dvl->challenge, we can identify time of origin!) |
7160 | 7323 | ||
7161 | network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum); | 7324 | network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum); |
@@ -7184,9 +7347,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7184 | do_fwd = GNUNET_NO; | 7347 | do_fwd = GNUNET_NO; |
7185 | return; | 7348 | return; |
7186 | } | 7349 | } |
7187 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7188 | "6 handle dv learn message from %s\n", | ||
7189 | GNUNET_i2s (&dvl->initiator)); | ||
7190 | if (bi_hop) | 7350 | if (bi_hop) |
7191 | { | 7351 | { |
7192 | /* last hop was bi-directional, we could learn something here! */ | 7352 | /* last hop was bi-directional, we could learn something here! */ |
@@ -7243,9 +7403,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7243 | } | 7403 | } |
7244 | } | 7404 | } |
7245 | } | 7405 | } |
7246 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7247 | "7 handle dv learn message from %s\n", | ||
7248 | GNUNET_i2s (&dvl->initiator)); | ||
7249 | if (MAX_DV_HOPS_ALLOWED == nhops) | 7406 | if (MAX_DV_HOPS_ALLOWED == nhops) |
7250 | { | 7407 | { |
7251 | /* At limit, we're out of here! */ | 7408 | /* At limit, we're out of here! */ |
@@ -7305,9 +7462,6 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl) | |||
7305 | &dv_neighbour_transmission, | 7462 | &dv_neighbour_transmission, |
7306 | &nsc); | 7463 | &nsc); |
7307 | } | 7464 | } |
7308 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7309 | "9 handle dv learn message from %s\n", | ||
7310 | GNUNET_i2s (&dvl->initiator)); | ||
7311 | } | 7465 | } |
7312 | 7466 | ||
7313 | 7467 | ||
@@ -7374,10 +7528,17 @@ forward_dv_box (struct Neighbour *next_hop, | |||
7374 | char msg_buf[msg_size] GNUNET_ALIGN; | 7528 | char msg_buf[msg_size] GNUNET_ALIGN; |
7375 | struct GNUNET_PeerIdentity *dhops; | 7529 | struct GNUNET_PeerIdentity *dhops; |
7376 | 7530 | ||
7531 | if (GNUNET_NO == ntohs (hdr->without_fc)) | ||
7532 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7533 | "forward dv box without fc\n"); | ||
7534 | if (NULL == vl) | ||
7535 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7536 | "forward dv box vl null\n"); | ||
7377 | GNUNET_assert (GNUNET_YES == ntohs (hdr->without_fc) || NULL != vl); | 7537 | GNUNET_assert (GNUNET_YES == ntohs (hdr->without_fc) || NULL != vl); |
7378 | 7538 | ||
7379 | hdr->num_hops = htons (num_hops); | 7539 | hdr->num_hops = htons (num_hops); |
7380 | hdr->total_hops = htons (total_hops); | 7540 | hdr->total_hops = htons (total_hops); |
7541 | hdr->header.size = htons (msg_size); | ||
7381 | memcpy (msg_buf, hdr, sizeof(*hdr)); | 7542 | memcpy (msg_buf, hdr, sizeof(*hdr)); |
7382 | dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct | 7543 | dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct |
7383 | TransportDVBoxMessage)]; | 7544 | TransportDVBoxMessage)]; |
@@ -7387,7 +7548,8 @@ forward_dv_box (struct Neighbour *next_hop, | |||
7387 | if (GNUNET_YES == ntohs (hdr->without_fc)) | 7548 | if (GNUNET_YES == ntohs (hdr->without_fc)) |
7388 | { | 7549 | { |
7389 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 7550 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
7390 | "Forwarding control message in DV Box to next hop %s (%u/%u) \n", | 7551 | "Forwarding control message (payload size %u) in DV Box to next hop %s (%u/%u) \n", |
7552 | enc_payload_size, | ||
7391 | GNUNET_i2s (&next_hop->pid), | 7553 | GNUNET_i2s (&next_hop->pid), |
7392 | (unsigned int) num_hops, | 7554 | (unsigned int) num_hops, |
7393 | (unsigned int) total_hops); | 7555 | (unsigned int) total_hops); |
@@ -7444,6 +7606,8 @@ free_backtalker (struct Backtalker *b) | |||
7444 | } | 7606 | } |
7445 | if (NULL != b->sc) | 7607 | if (NULL != b->sc) |
7446 | { | 7608 | { |
7609 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7610 | "store cancel\n"); | ||
7447 | GNUNET_PEERSTORE_store_cancel (b->sc); | 7611 | GNUNET_PEERSTORE_store_cancel (b->sc); |
7448 | b->sc = NULL; | 7612 | b->sc = NULL; |
7449 | } | 7613 | } |
@@ -7486,6 +7650,8 @@ backtalker_timeout_cb (void *cls) | |||
7486 | { | 7650 | { |
7487 | struct Backtalker *b = cls; | 7651 | struct Backtalker *b = cls; |
7488 | 7652 | ||
7653 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7654 | "backtalker timeout.\n"); | ||
7489 | b->task = NULL; | 7655 | b->task = NULL; |
7490 | if (0 != GNUNET_TIME_absolute_get_remaining (b->timeout).rel_value_us) | 7656 | if (0 != GNUNET_TIME_absolute_get_remaining (b->timeout).rel_value_us) |
7491 | { | 7657 | { |
@@ -7589,6 +7755,8 @@ update_backtalker_monotime (struct Backtalker *b) | |||
7589 | 7755 | ||
7590 | if (NULL != b->sc) | 7756 | if (NULL != b->sc) |
7591 | { | 7757 | { |
7758 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
7759 | "store cancel\n"); | ||
7592 | GNUNET_PEERSTORE_store_cancel (b->sc); | 7760 | GNUNET_PEERSTORE_store_cancel (b->sc); |
7593 | b->sc = NULL; | 7761 | b->sc = NULL; |
7594 | } | 7762 | } |
@@ -7714,8 +7882,8 @@ handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb) | |||
7714 | 7882 | ||
7715 | dh_key_derive_eph_pub (&dvb->ephemeral_key, &dvb->iv, key); | 7883 | dh_key_derive_eph_pub (&dvb->ephemeral_key, &dvb->iv, key); |
7716 | hdr = (const char *) &dvb[1]; | 7884 | hdr = (const char *) &dvb[1]; |
7717 | hdr_len = ntohs (dvb->header.size) - sizeof(*dvb) - sizeof(struct | 7885 | hdr_len = ntohs (dvb->orig_size) - sizeof(*dvb) - sizeof(struct |
7718 | GNUNET_PeerIdentity) | 7886 | GNUNET_PeerIdentity) |
7719 | * ntohs (dvb->total_hops); | 7887 | * ntohs (dvb->total_hops); |
7720 | 7888 | ||
7721 | dv_hmac (key, &hmac, hdr, hdr_len); | 7889 | dv_hmac (key, &hmac, hdr, hdr_len); |
@@ -8112,7 +8280,7 @@ handle_validation_challenge ( | |||
8112 | } | 8280 | } |
8113 | sender = cmc->im.sender; | 8281 | sender = cmc->im.sender; |
8114 | vl = lookup_virtual_link (&sender); | 8282 | vl = lookup_virtual_link (&sender); |
8115 | if (NULL != vl) | 8283 | if ((NULL != vl) && (GNUNET_YES == vl->confirmed)) |
8116 | { | 8284 | { |
8117 | // route_control_message_without_fc (&cmc->im.sender, | 8285 | // route_control_message_without_fc (&cmc->im.sender, |
8118 | route_control_message_without_fc (vl, | 8286 | route_control_message_without_fc (vl, |
@@ -8380,46 +8548,63 @@ handle_validation_response ( | |||
8380 | q->pd.aged_rtt = vs->validation_rtt; | 8548 | q->pd.aged_rtt = vs->validation_rtt; |
8381 | n = q->neighbour; | 8549 | n = q->neighbour; |
8382 | vl = lookup_virtual_link (&vs->pid); | 8550 | vl = lookup_virtual_link (&vs->pid); |
8383 | if (NULL != vl) | 8551 | if (NULL == vl) |
8552 | { | ||
8553 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
8554 | "Creating new virtual link to %s using direct neighbour!\n", | ||
8555 | GNUNET_i2s (&vs->pid)); | ||
8556 | vl = GNUNET_new (struct VirtualLink); | ||
8557 | vl->confirmed = GNUNET_YES; | ||
8558 | vl->message_uuid_ctr = | ||
8559 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); | ||
8560 | vl->target = n->pid; | ||
8561 | vl->core_recv_window = RECV_WINDOW_SIZE; | ||
8562 | vl->available_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8563 | vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8564 | GNUNET_break (GNUNET_YES == | ||
8565 | GNUNET_CONTAINER_multipeermap_put ( | ||
8566 | links, | ||
8567 | &vl->target, | ||
8568 | vl, | ||
8569 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
8570 | vl->n = n; | ||
8571 | n->vl = vl; | ||
8572 | q->idle = GNUNET_YES; | ||
8573 | vl->visibility_task = | ||
8574 | GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl); | ||
8575 | consider_sending_fc (vl); | ||
8576 | /* We lacked a confirmed connection to the target | ||
8577 | before, so tell CORE about it (finally!) */ | ||
8578 | cores_send_connect_info (&n->pid); | ||
8579 | } | ||
8580 | else | ||
8384 | { | 8581 | { |
8385 | /* Link was already up, remember n is also now available and we are done */ | 8582 | /* Link was already up, remember n is also now available and we are done */ |
8386 | if (NULL == vl->n) | 8583 | if (NULL == vl->n) |
8387 | { | 8584 | { |
8388 | vl->n = n; | 8585 | vl->n = n; |
8389 | n->vl = vl; | 8586 | n->vl = vl; |
8390 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 8587 | if (GNUNET_YES == vl->confirmed) |
8391 | "Virtual link to %s could now also direct neighbour!\n", | 8588 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8392 | GNUNET_i2s (&vs->pid)); | 8589 | "Virtual link to %s could now also direct neighbour!\n", |
8590 | GNUNET_i2s (&vs->pid)); | ||
8393 | } | 8591 | } |
8394 | else | 8592 | else |
8395 | { | 8593 | { |
8396 | GNUNET_assert (n == vl->n); | 8594 | GNUNET_assert (n == vl->n); |
8397 | } | 8595 | } |
8398 | return; | 8596 | if (GNUNET_NO == vl->confirmed) |
8597 | { | ||
8598 | vl->confirmed = GNUNET_YES; | ||
8599 | q->idle = GNUNET_YES; | ||
8600 | vl->visibility_task = | ||
8601 | GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl); | ||
8602 | consider_sending_fc (vl); | ||
8603 | /* We lacked a confirmed connection to the target | ||
8604 | before, so tell CORE about it (finally!) */ | ||
8605 | cores_send_connect_info (&n->pid); | ||
8606 | } | ||
8399 | } | 8607 | } |
8400 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
8401 | "Creating new virtual link to %s using direct neighbour!\n", | ||
8402 | GNUNET_i2s (&vs->pid)); | ||
8403 | vl = GNUNET_new (struct VirtualLink); | ||
8404 | vl->target = n->pid; | ||
8405 | vl->n = n; | ||
8406 | n->vl = vl; | ||
8407 | q->idle = GNUNET_YES; | ||
8408 | vl->core_recv_window = RECV_WINDOW_SIZE; | ||
8409 | vl->available_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8410 | vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8411 | vl->visibility_task = | ||
8412 | GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl); | ||
8413 | GNUNET_break (GNUNET_YES == | ||
8414 | GNUNET_CONTAINER_multipeermap_put ( | ||
8415 | links, | ||
8416 | &vl->target, | ||
8417 | vl, | ||
8418 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
8419 | consider_sending_fc (vl); | ||
8420 | /* We lacked a confirmed connection to the target | ||
8421 | before, so tell CORE about it (finally!) */ | ||
8422 | cores_send_connect_info (&n->pid); | ||
8423 | } | 8608 | } |
8424 | 8609 | ||
8425 | 8610 | ||
@@ -8462,6 +8647,7 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc) | |||
8462 | struct GNUNET_TIME_Absolute st; | 8647 | struct GNUNET_TIME_Absolute st; |
8463 | uint64_t os; | 8648 | uint64_t os; |
8464 | uint64_t wnd; | 8649 | uint64_t wnd; |
8650 | uint32_t random; | ||
8465 | 8651 | ||
8466 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 8652 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8467 | "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender)); | 8653 | "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender)); |
@@ -8469,13 +8655,22 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc) | |||
8469 | if (NULL == vl) | 8655 | if (NULL == vl) |
8470 | { | 8656 | { |
8471 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 8657 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8472 | "FC dropped: VL unknown\n"); | 8658 | "No virtual link for FC creating new unconfirmed virtual link to %s!\n", |
8473 | GNUNET_STATISTICS_update (GST_stats, | 8659 | GNUNET_i2s (&cmc->im.sender)); |
8474 | "# FC dropped: Virtual link unknown", | 8660 | vl = GNUNET_new (struct VirtualLink); |
8475 | 1, | 8661 | vl->confirmed = GNUNET_NO; |
8476 | GNUNET_NO); | 8662 | vl->message_uuid_ctr = |
8477 | finish_cmc_handling (cmc); | 8663 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); |
8478 | return; | 8664 | vl->target = cmc->im.sender; |
8665 | vl->core_recv_window = RECV_WINDOW_SIZE; | ||
8666 | vl->available_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8667 | vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE; | ||
8668 | GNUNET_break (GNUNET_YES == | ||
8669 | GNUNET_CONTAINER_multipeermap_put ( | ||
8670 | links, | ||
8671 | &vl->target, | ||
8672 | vl, | ||
8673 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
8479 | } | 8674 | } |
8480 | st = GNUNET_TIME_absolute_ntoh (fc->sender_time); | 8675 | st = GNUNET_TIME_absolute_ntoh (fc->sender_time); |
8481 | if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us) | 8676 | if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us) |
@@ -8509,15 +8704,20 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc) | |||
8509 | (unsigned long long) vl->outbound_fc_window_size, | 8704 | (unsigned long long) vl->outbound_fc_window_size, |
8510 | (long long) vl->incoming_fc_window_size_loss); | 8705 | (long long) vl->incoming_fc_window_size_loss); |
8511 | wnd = GNUNET_ntohll (fc->outbound_window_size); | 8706 | wnd = GNUNET_ntohll (fc->outbound_window_size); |
8512 | if ((wnd < vl->incoming_fc_window_size) || | 8707 | random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
8513 | (vl->last_outbound_window_size_received != wnd) || | 8708 | UINT32_MAX); |
8514 | (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX) | 8709 | if ((GNUNET_YES == vl->confirmed) && ((wnd < vl->incoming_fc_window_size) || |
8515 | % FC_NO_CHANGE_REPLY_PROBABILITY)) | 8710 | (vl->last_outbound_window_size_received |
8711 | != wnd) || | ||
8712 | (0 == random | ||
8713 | % FC_NO_CHANGE_REPLY_PROBABILITY))) | ||
8516 | { | 8714 | { |
8517 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 8715 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8518 | "Consider re-sending our FC message, as clearly the other peer's idea of the window is not up-to-date (%llu vs %llu)\n", | 8716 | "Consider re-sending our FC message, as clearly the other peer's idea of the window is not up-to-date (%llu vs %llu) or %llu last received differs, or random reply %lu\n", |
8519 | (unsigned long long) wnd, | 8717 | (unsigned long long) wnd, |
8520 | (unsigned long long) vl->incoming_fc_window_size); | 8718 | (unsigned long long) vl->incoming_fc_window_size, |
8719 | (unsigned long long) vl->last_outbound_window_size_received, | ||
8720 | random % FC_NO_CHANGE_REPLY_PROBABILITY); | ||
8521 | consider_sending_fc (vl); | 8721 | consider_sending_fc (vl); |
8522 | } | 8722 | } |
8523 | if ((wnd == vl->incoming_fc_window_size) && | 8723 | if ((wnd == vl->incoming_fc_window_size) && |
@@ -8530,6 +8730,7 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc) | |||
8530 | (unsigned long long) wnd); | 8730 | (unsigned long long) wnd); |
8531 | GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); | 8731 | GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); |
8532 | vl->fc_retransmit_task = NULL; | 8732 | vl->fc_retransmit_task = NULL; |
8733 | vl->fc_retransmit_count = 0; | ||
8533 | } | 8734 | } |
8534 | vl->last_outbound_window_size_received = wnd; | 8735 | vl->last_outbound_window_size_received = wnd; |
8535 | /* FC window likely increased, check transmission possibilities! */ | 8736 | /* FC window likely increased, check transmission possibilities! */ |
@@ -8729,7 +8930,6 @@ fragment_message (struct Queue *queue, | |||
8729 | pm->bytes_msg, | 8930 | pm->bytes_msg, |
8730 | GNUNET_i2s (&pm->vl->target), | 8931 | GNUNET_i2s (&pm->vl->target), |
8731 | (unsigned int) mtu); | 8932 | (unsigned int) mtu); |
8732 | pa = prepare_pending_acknowledgement (queue, dvh, pm); | ||
8733 | 8933 | ||
8734 | /* This invariant is established in #handle_add_queue_message() */ | 8934 | /* This invariant is established in #handle_add_queue_message() */ |
8735 | GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage)); | 8935 | GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage)); |
@@ -8745,7 +8945,7 @@ fragment_message (struct Queue *queue, | |||
8745 | ff = ff->head_frag; /* descent into fragmented fragments */ | 8945 | ff = ff->head_frag; /* descent into fragmented fragments */ |
8746 | } | 8946 | } |
8747 | 8947 | ||
8748 | if (((ff->bytes_msg > mtu) || (pm == ff)) && (pm->frag_off < pm->bytes_msg)) | 8948 | if (((ff->bytes_msg > mtu) || (pm == ff)) && (ff->frag_off < ff->bytes_msg)) |
8749 | { | 8949 | { |
8750 | /* Did not yet calculate all fragments, calculate next fragment */ | 8950 | /* Did not yet calculate all fragments, calculate next fragment */ |
8751 | struct PendingMessage *frag; | 8951 | struct PendingMessage *frag; |
@@ -8783,13 +8983,15 @@ fragment_message (struct Queue *queue, | |||
8783 | tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT); | 8983 | tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT); |
8784 | tfb.header.size = | 8984 | tfb.header.size = |
8785 | htons (sizeof(struct TransportFragmentBoxMessage) + fragsize); | 8985 | htons (sizeof(struct TransportFragmentBoxMessage) + fragsize); |
8986 | pa = prepare_pending_acknowledgement (queue, dvh, frag); | ||
8786 | tfb.ack_uuid = pa->ack_uuid; | 8987 | tfb.ack_uuid = pa->ack_uuid; |
8787 | tfb.msg_uuid = pm->msg_uuid; | 8988 | tfb.msg_uuid = pm->msg_uuid; |
8788 | tfb.frag_off = htons (ff->frag_off + xoff); | 8989 | tfb.frag_off = htons (ff->frag_off + xoff); |
8789 | tfb.msg_size = htons (pm->bytes_msg); | 8990 | tfb.msg_size = htons (pm->bytes_msg); |
8790 | memcpy (msg, &tfb, sizeof(tfb)); | 8991 | memcpy (msg, &tfb, sizeof(tfb)); |
8791 | memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize); | 8992 | memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize); |
8792 | GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag, ff->tail_frag, frag); | 8993 | GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag, |
8994 | ff->tail_frag, frag); | ||
8793 | ff->frag_off += fragsize; | 8995 | ff->frag_off += fragsize; |
8794 | ff = frag; | 8996 | ff = frag; |
8795 | } | 8997 | } |
@@ -8803,6 +9005,7 @@ fragment_message (struct Queue *queue, | |||
8803 | ff->frag_parent->head_frag, | 9005 | ff->frag_parent->head_frag, |
8804 | ff->frag_parent->tail_frag, | 9006 | ff->frag_parent->tail_frag, |
8805 | ff); | 9007 | ff); |
9008 | |||
8806 | return ff; | 9009 | return ff; |
8807 | } | 9010 | } |
8808 | 9011 | ||
@@ -8829,7 +9032,7 @@ reliability_box_message (struct Queue *queue, | |||
8829 | struct PendingMessage *bpm; | 9032 | struct PendingMessage *bpm; |
8830 | char *msg; | 9033 | char *msg; |
8831 | 9034 | ||
8832 | if (PMT_CORE != pm->pmt) | 9035 | if ((PMT_CORE != pm->pmt) && (PMT_DV_BOX != pm->pmt)) |
8833 | return pm; /* already fragmented or reliability boxed, or control message: | 9036 | return pm; /* already fragmented or reliability boxed, or control message: |
8834 | do nothing */ | 9037 | do nothing */ |
8835 | if (NULL != pm->bpm) | 9038 | if (NULL != pm->bpm) |
@@ -8842,11 +9045,7 @@ reliability_box_message (struct Queue *queue, | |||
8842 | client_send_response (pm); | 9045 | client_send_response (pm); |
8843 | return NULL; | 9046 | return NULL; |
8844 | } | 9047 | } |
8845 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 9048 | |
8846 | "Preparing reliability box for message <%llu> to %s on queue %s\n", | ||
8847 | pm->logging_uuid, | ||
8848 | GNUNET_i2s (&pm->vl->target), | ||
8849 | queue->address); | ||
8850 | pa = prepare_pending_acknowledgement (queue, dvh, pm); | 9049 | pa = prepare_pending_acknowledgement (queue, dvh, pm); |
8851 | 9050 | ||
8852 | bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox) | 9051 | bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox) |
@@ -8869,6 +9068,13 @@ reliability_box_message (struct Queue *queue, | |||
8869 | memcpy (msg, &rbox, sizeof(rbox)); | 9068 | memcpy (msg, &rbox, sizeof(rbox)); |
8870 | memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg); | 9069 | memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg); |
8871 | pm->bpm = bpm; | 9070 | pm->bpm = bpm; |
9071 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9072 | "Preparing reliability box for message <%llu> of size %lu (%lu) to %s on queue %s\n", | ||
9073 | pm->logging_uuid, | ||
9074 | pm->bytes_msg, | ||
9075 | ntohs (((const struct GNUNET_MessageHeader *) &pm[1])->size), | ||
9076 | GNUNET_i2s (&pm->vl->target), | ||
9077 | queue->address); | ||
8872 | return bpm; | 9078 | return bpm; |
8873 | } | 9079 | } |
8874 | 9080 | ||
@@ -8911,6 +9117,7 @@ update_pm_next_attempt (struct PendingMessage *pm, | |||
8911 | { | 9117 | { |
8912 | struct VirtualLink *vl = pm->vl; | 9118 | struct VirtualLink *vl = pm->vl; |
8913 | 9119 | ||
9120 | // TODO Do we really need a next_attempt value for PendingMessage other than the root Pending Message? | ||
8914 | pm->next_attempt = next_attempt; | 9121 | pm->next_attempt = next_attempt; |
8915 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 9122 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8916 | "Next attempt for message <%llu> set to %s\n", | 9123 | "Next attempt for message <%llu> set to %s\n", |
@@ -8921,9 +9128,17 @@ update_pm_next_attempt (struct PendingMessage *pm, | |||
8921 | { | 9128 | { |
8922 | reorder_root_pm (pm, next_attempt); | 9129 | reorder_root_pm (pm, next_attempt); |
8923 | } | 9130 | } |
8924 | else if ((PMT_RELIABILITY_BOX == pm->pmt)||(PMT_DV_BOX == pm->pmt)) | 9131 | else if ((PMT_RELIABILITY_BOX == pm->pmt) || (PMT_DV_BOX == pm->pmt)) |
8925 | { | 9132 | { |
8926 | reorder_root_pm (pm->frag_parent, next_attempt); | 9133 | struct PendingMessage *root = pm->frag_parent; |
9134 | |||
9135 | while (NULL != root->frag_parent) | ||
9136 | root = root->frag_parent; | ||
9137 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9138 | "Next attempt for root message <%llu> set to %s\n", | ||
9139 | root->logging_uuid); | ||
9140 | root->next_attempt = next_attempt; | ||
9141 | reorder_root_pm (root, next_attempt); | ||
8927 | } | 9142 | } |
8928 | else | 9143 | else |
8929 | { | 9144 | { |
@@ -8988,6 +9203,16 @@ struct PendingMessageScoreContext | |||
8988 | * Did we have to reliability box? | 9203 | * Did we have to reliability box? |
8989 | */ | 9204 | */ |
8990 | int relb; | 9205 | int relb; |
9206 | |||
9207 | /** | ||
9208 | * There are pending messages, but it was to early to send one of them. | ||
9209 | */ | ||
9210 | int to_early; | ||
9211 | |||
9212 | /** | ||
9213 | * When will we try to transmit the message again for which it was to early to retry. | ||
9214 | */ | ||
9215 | struct GNUNET_TIME_Relative to_early_retry_delay; | ||
8991 | }; | 9216 | }; |
8992 | 9217 | ||
8993 | 9218 | ||
@@ -9020,14 +9245,32 @@ select_best_pending_from_link (struct PendingMessageScoreContext *sc, | |||
9020 | int relb; | 9245 | int relb; |
9021 | 9246 | ||
9022 | if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt)) | 9247 | if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt)) |
9248 | { | ||
9249 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9250 | "DV messages must not be DV-routed to next hop!\n"); | ||
9023 | continue; /* DV messages must not be DV-routed to next hop! */ | 9251 | continue; /* DV messages must not be DV-routed to next hop! */ |
9252 | } | ||
9024 | if (pos->next_attempt.abs_value_us > now.abs_value_us) | 9253 | if (pos->next_attempt.abs_value_us > now.abs_value_us) |
9254 | { | ||
9255 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9256 | "too early for all messages, they are sorted by next_attempt\n"); | ||
9257 | sc->to_early = GNUNET_YES; | ||
9258 | |||
9025 | break; /* too early for all messages, they are sorted by next_attempt */ | 9259 | break; /* too early for all messages, they are sorted by next_attempt */ |
9260 | } | ||
9261 | sc->to_early = GNUNET_NO; | ||
9026 | if (NULL != pos->qe) | 9262 | if (NULL != pos->qe) |
9263 | { | ||
9264 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9265 | "not eligible\n"); | ||
9027 | continue; /* not eligible */ | 9266 | continue; /* not eligible */ |
9267 | } | ||
9028 | sc->consideration_counter++; | 9268 | sc->consideration_counter++; |
9029 | /* determine if we have to fragment, if so add fragmentation | 9269 | /* determine if we have to fragment, if so add fragmentation |
9030 | overhead! */ | 9270 | overhead! */ |
9271 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9272 | "check %u for sc->best\n", | ||
9273 | pos->logging_uuid); | ||
9031 | frag = GNUNET_NO; | 9274 | frag = GNUNET_NO; |
9032 | if (((0 != queue->mtu) && | 9275 | if (((0 != queue->mtu) && |
9033 | (pos->bytes_msg + real_overhead > queue->mtu)) || | 9276 | (pos->bytes_msg + real_overhead > queue->mtu)) || |
@@ -9038,6 +9281,10 @@ select_best_pending_from_link (struct PendingMessageScoreContext *sc, | |||
9038 | respect that even if MTU is UINT16_MAX for | 9281 | respect that even if MTU is UINT16_MAX for |
9039 | this queue */)) | 9282 | this queue */)) |
9040 | { | 9283 | { |
9284 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9285 | "fragment msg with size %u, realoverhead is %u\n", | ||
9286 | pos->bytes_msg, | ||
9287 | real_overhead); | ||
9041 | frag = GNUNET_YES; | 9288 | frag = GNUNET_YES; |
9042 | if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc) | 9289 | if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc) |
9043 | { | 9290 | { |
@@ -9064,7 +9311,10 @@ select_best_pending_from_link (struct PendingMessageScoreContext *sc, | |||
9064 | { | 9311 | { |
9065 | relb = GNUNET_YES; | 9312 | relb = GNUNET_YES; |
9066 | } | 9313 | } |
9067 | 9314 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |
9315 | "Create reliability box of msg with size %u, realoverhead is %u\n", | ||
9316 | pos->bytes_msg, | ||
9317 | real_overhead); | ||
9068 | } | 9318 | } |
9069 | 9319 | ||
9070 | /* Finally, compare to existing 'best' in sc to see if this 'pos' pending | 9320 | /* Finally, compare to existing 'best' in sc to see if this 'pos' pending |
@@ -9107,7 +9357,13 @@ select_best_pending_from_link (struct PendingMessageScoreContext *sc, | |||
9107 | pm_score -= queue->mtu - (real_overhead + pos->bytes_msg); | 9357 | pm_score -= queue->mtu - (real_overhead + pos->bytes_msg); |
9108 | } | 9358 | } |
9109 | if (sc_score + time_delta > pm_score) | 9359 | if (sc_score + time_delta > pm_score) |
9360 | { | ||
9361 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9362 | "sc_score of %u larger, keep sc->best %u\n", | ||
9363 | pos->logging_uuid, | ||
9364 | sc->best->logging_uuid); | ||
9110 | continue; /* sc_score larger, keep sc->best */ | 9365 | continue; /* sc_score larger, keep sc->best */ |
9366 | } | ||
9111 | } | 9367 | } |
9112 | sc->best = pos; | 9368 | sc->best = pos; |
9113 | sc->dvh = dvh; | 9369 | sc->dvh = dvh; |
@@ -9216,6 +9472,10 @@ transmit_on_queue (void *cls) | |||
9216 | "No pending messages, queue `%s' to %s now idle\n", | 9472 | "No pending messages, queue `%s' to %s now idle\n", |
9217 | queue->address, | 9473 | queue->address, |
9218 | GNUNET_i2s (&n->pid)); | 9474 | GNUNET_i2s (&n->pid)); |
9475 | if (GNUNET_YES == sc.to_early) | ||
9476 | schedule_transmit_on_queue (sc.to_early_retry_delay, | ||
9477 | queue, | ||
9478 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9219 | queue->idle = GNUNET_YES; | 9479 | queue->idle = GNUNET_YES; |
9220 | return; | 9480 | return; |
9221 | } | 9481 | } |
@@ -9226,9 +9486,17 @@ transmit_on_queue (void *cls) | |||
9226 | pm = sc.best; | 9486 | pm = sc.best; |
9227 | if (NULL != sc.dvh) | 9487 | if (NULL != sc.dvh) |
9228 | { | 9488 | { |
9489 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9490 | "Is this %u a DV box?\n", | ||
9491 | pm->pmt); | ||
9229 | GNUNET_assert (PMT_DV_BOX != pm->pmt); | 9492 | GNUNET_assert (PMT_DV_BOX != pm->pmt); |
9230 | if (NULL != sc.best->bpm) | 9493 | if (NULL != sc.best->bpm) |
9231 | { | 9494 | { |
9495 | const struct DVPathEntryP *hops_old; | ||
9496 | const struct DVPathEntryP *hops_selected; | ||
9497 | |||
9498 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9499 | "Discard old box\n"); | ||
9232 | /* We did this boxing before, but possibly for a different path! | 9500 | /* We did this boxing before, but possibly for a different path! |
9233 | Discard old DV box! OPTIMIZE-ME: we might want to check if | 9501 | Discard old DV box! OPTIMIZE-ME: we might want to check if |
9234 | it is the same and then not re-build the message... */ | 9502 | it is the same and then not re-build the message... */ |
@@ -9246,6 +9514,13 @@ transmit_on_queue (void *cls) | |||
9246 | RMO_NONE, | 9514 | RMO_NONE, |
9247 | GNUNET_NO); | 9515 | GNUNET_NO); |
9248 | GNUNET_assert (NULL != sc.best->bpm); | 9516 | GNUNET_assert (NULL != sc.best->bpm); |
9517 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9518 | "%u %u %u %u %u\n", | ||
9519 | sizeof(struct GNUNET_PeerIdentity), | ||
9520 | sizeof(struct TransportDVBoxMessage), | ||
9521 | sizeof(struct TransportDVBoxPayloadP), | ||
9522 | sizeof(struct TransportFragmentBoxMessage), | ||
9523 | ((const struct GNUNET_MessageHeader *) &sc.best[1])->size); | ||
9249 | pm = sc.best->bpm; | 9524 | pm = sc.best->bpm; |
9250 | } | 9525 | } |
9251 | if (GNUNET_YES == sc.frag) | 9526 | if (GNUNET_YES == sc.frag) |
@@ -9258,7 +9533,9 @@ transmit_on_queue (void *cls) | |||
9258 | queue->address, | 9533 | queue->address, |
9259 | GNUNET_i2s (&n->pid), | 9534 | GNUNET_i2s (&n->pid), |
9260 | sc.best->logging_uuid); | 9535 | sc.best->logging_uuid); |
9261 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9536 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9537 | queue, | ||
9538 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9262 | return; | 9539 | return; |
9263 | } | 9540 | } |
9264 | } | 9541 | } |
@@ -9274,7 +9551,9 @@ transmit_on_queue (void *cls) | |||
9274 | queue->address, | 9551 | queue->address, |
9275 | GNUNET_i2s (&n->pid), | 9552 | GNUNET_i2s (&n->pid), |
9276 | sc.best->logging_uuid); | 9553 | sc.best->logging_uuid); |
9277 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9554 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9555 | queue, | ||
9556 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9278 | return; | 9557 | return; |
9279 | } | 9558 | } |
9280 | } | 9559 | } |
@@ -9323,6 +9602,8 @@ transmit_on_queue (void *cls) | |||
9323 | } | 9602 | } |
9324 | else | 9603 | else |
9325 | { | 9604 | { |
9605 | struct GNUNET_TIME_Relative wait_duration; | ||
9606 | |||
9326 | /* Message not finished, waiting for acknowledgement. | 9607 | /* Message not finished, waiting for acknowledgement. |
9327 | Update time by which we might retransmit 's' based on queue | 9608 | Update time by which we might retransmit 's' based on queue |
9328 | characteristics (i.e. RTT); it takes one RTT for the message to | 9609 | characteristics (i.e. RTT); it takes one RTT for the message to |
@@ -9333,18 +9614,33 @@ transmit_on_queue (void *cls) | |||
9333 | OPTIMIZE: Note that in the future this heuristic should likely | 9614 | OPTIMIZE: Note that in the future this heuristic should likely |
9334 | be improved further (measure RTT stability, consider message | 9615 | be improved further (measure RTT stability, consider message |
9335 | urgency and size when delaying ACKs, etc.) */ | 9616 | urgency and size when delaying ACKs, etc.) */ |
9617 | |||
9618 | if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != | ||
9619 | queue->pd.aged_rtt.rel_value_us) | ||
9620 | wait_duration = queue->pd.aged_rtt; | ||
9621 | else | ||
9622 | wait_duration = DEFAULT_ACK_WAIT_DURATION; | ||
9623 | struct GNUNET_TIME_Absolute next = GNUNET_TIME_relative_to_absolute ( | ||
9624 | GNUNET_TIME_relative_multiply ( | ||
9625 | wait_duration, 4)); | ||
9626 | struct GNUNET_TIME_Relative plus = GNUNET_TIME_relative_multiply ( | ||
9627 | wait_duration, 4); | ||
9336 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 9628 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
9337 | "Waiting %s for ACK\n", | 9629 | "Waiting %s (%llu) for ACK until %llu\n", |
9338 | GNUNET_STRINGS_relative_time_to_string ( | 9630 | GNUNET_STRINGS_relative_time_to_string ( |
9339 | GNUNET_TIME_relative_multiply ( | 9631 | GNUNET_TIME_relative_multiply ( |
9340 | queue->pd.aged_rtt, 4), GNUNET_NO)); | 9632 | queue->pd.aged_rtt, 4), GNUNET_NO), |
9633 | plus, | ||
9634 | next); | ||
9341 | update_pm_next_attempt (pm, | 9635 | update_pm_next_attempt (pm, |
9342 | GNUNET_TIME_relative_to_absolute ( | 9636 | GNUNET_TIME_relative_to_absolute ( |
9343 | GNUNET_TIME_relative_multiply (queue->pd.aged_rtt, | 9637 | GNUNET_TIME_relative_multiply (wait_duration, |
9344 | 4))); | 9638 | 4))); |
9345 | } | 9639 | } |
9346 | /* finally, re-schedule queue transmission task itself */ | 9640 | /* finally, re-schedule queue transmission task itself */ |
9347 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9641 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9642 | queue, | ||
9643 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9348 | } | 9644 | } |
9349 | 9645 | ||
9350 | 9646 | ||
@@ -9476,7 +9772,9 @@ handle_send_message_ack (void *cls, | |||
9476 | NULL != queue; | 9772 | NULL != queue; |
9477 | queue = queue->next_client) | 9773 | queue = queue->next_client) |
9478 | { | 9774 | { |
9479 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9775 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9776 | queue, | ||
9777 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9480 | } | 9778 | } |
9481 | } | 9779 | } |
9482 | else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length) | 9780 | else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length) |
@@ -9486,7 +9784,9 @@ handle_send_message_ack (void *cls, | |||
9486 | "# Transmission throttled due to queue queue limit", | 9784 | "# Transmission throttled due to queue queue limit", |
9487 | -1, | 9785 | -1, |
9488 | GNUNET_NO); | 9786 | GNUNET_NO); |
9489 | schedule_transmit_on_queue (qe->queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9787 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9788 | qe->queue, | ||
9789 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9490 | } | 9790 | } |
9491 | else if (1 == qe->queue->q_capacity) | 9791 | else if (1 == qe->queue->q_capacity) |
9492 | { | 9792 | { |
@@ -9500,7 +9800,9 @@ handle_send_message_ack (void *cls, | |||
9500 | "# Transmission throttled due to message queue capacity", | 9800 | "# Transmission throttled due to message queue capacity", |
9501 | -1, | 9801 | -1, |
9502 | GNUNET_NO); | 9802 | GNUNET_NO); |
9503 | schedule_transmit_on_queue (qe->queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9803 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
9804 | qe->queue, | ||
9805 | GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9504 | } | 9806 | } |
9505 | 9807 | ||
9506 | if (NULL != (pm = qe->pm)) | 9808 | if (NULL != (pm = qe->pm)) |
@@ -10090,7 +10392,8 @@ handle_add_queue_message (void *cls, | |||
10090 | &check_validation_request_pending, | 10392 | &check_validation_request_pending, |
10091 | queue); | 10393 | queue); |
10092 | /* look for traffic for this queue */ | 10394 | /* look for traffic for this queue */ |
10093 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 10395 | schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO, |
10396 | queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
10094 | /* might be our first queue, try launching DV learning */ | 10397 | /* might be our first queue, try launching DV learning */ |
10095 | if (NULL == dvlearn_task) | 10398 | if (NULL == dvlearn_task) |
10096 | dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL); | 10399 | dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL); |
diff --git a/src/transport/test_transport_distance_vector_circle_topo.conf b/src/transport/test_transport_distance_vector_circle_topo.conf index ce26bf923..210179291 100644 --- a/src/transport/test_transport_distance_vector_circle_topo.conf +++ b/src/transport/test_transport_distance_vector_circle_topo.conf | |||
@@ -2,7 +2,7 @@ M:1 | |||
2 | N:3 | 2 | N:3 |
3 | X:0 | 3 | X:0 |
4 | AC:1 | 4 | AC:1 |
5 | B:1 | 5 | B:0 |
6 | T:libgnunet_test_transport_plugin_cmd_simple_send_dv | 6 | T:libgnunet_test_transport_plugin_cmd_simple_send_dv |
7 | R:1|{tcp_port:0}|{udp_port:1} | 7 | R:1|{tcp_port:0}|{udp_port:1} |
8 | R:2|{tcp_port:0}|{udp_port:1} | 8 | R:2|{tcp_port:0}|{udp_port:1} |
diff --git a/src/transport/test_transport_plugin_cmd_simple_send_dv.c b/src/transport/test_transport_plugin_cmd_simple_send_dv.c index 167120e2b..f1f168102 100644 --- a/src/transport/test_transport_plugin_cmd_simple_send_dv.c +++ b/src/transport/test_transport_plugin_cmd_simple_send_dv.c | |||
@@ -65,12 +65,12 @@ struct TestState | |||
65 | */ | 65 | */ |
66 | struct GNUNET_TESTING_NetjailTopology *topology; | 66 | struct GNUNET_TESTING_NetjailTopology *topology; |
67 | 67 | ||
68 | /** | 68 | }; |
69 | |||
70 | /** | ||
69 | * The number of messages received. | 71 | * The number of messages received. |
70 | */ | 72 | */ |
71 | unsigned int number_received; | 73 | static unsigned int number_received; |
72 | |||
73 | }; | ||
74 | 74 | ||
75 | static struct GNUNET_TESTING_Command block_send; | 75 | static struct GNUNET_TESTING_Command block_send; |
76 | 76 | ||
@@ -105,52 +105,61 @@ static void | |||
105 | handle_test (void *cls, | 105 | handle_test (void *cls, |
106 | const struct GNUNET_TRANSPORT_TESTING_TestMessage *message) | 106 | const struct GNUNET_TRANSPORT_TESTING_TestMessage *message) |
107 | { | 107 | { |
108 | struct TestState *ts = cls; | 108 | struct GNUNET_PeerIdentity *peer = cls; |
109 | const struct GNUNET_TESTING_AsyncContext *ac_block; | 109 | const struct GNUNET_TESTING_AsyncContext *ac_block; |
110 | const struct GNUNET_TESTING_AsyncContext *ac_start; | 110 | const struct GNUNET_TESTING_AsyncContext *ac_start; |
111 | const struct GNUNET_TESTING_Command *cmd; | 111 | const struct GNUNET_TESTING_Command *cmd; |
112 | const struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map; | 112 | const struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map; |
113 | unsigned int connected; | 113 | unsigned int connected; |
114 | struct BlockState *bs; | 114 | struct BlockState *bs; |
115 | struct GNUNET_TRANSPORT_CoreHandle *ch; | ||
116 | const struct StartPeerState *sps; | ||
115 | 117 | ||
116 | 118 | ||
117 | 119 | GNUNET_TRANSPORT_get_trait_state (&start_peer, | |
120 | &sps); | ||
121 | ch = sps->th; | ||
118 | GNUNET_TRANSPORT_get_trait_connected_peers_map (&start_peer, | 122 | GNUNET_TRANSPORT_get_trait_connected_peers_map (&start_peer, |
119 | &connected_peers_map); | 123 | &connected_peers_map); |
120 | 124 | ||
121 | connected = GNUNET_CONTAINER_multishortmap_size ( | 125 | if (NULL != connected_peers_map) |
122 | connected_peers_map); | 126 | { |
127 | connected = GNUNET_CONTAINER_multishortmap_size ( | ||
128 | connected_peers_map); | ||
123 | 129 | ||
124 | ts->number_received++; | 130 | number_received++; |
125 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 131 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
126 | "Received %u test message(s) from %u connected peer(s)\n", | 132 | "Received %u test message(s) from %s, %u connected peer(s)\n", |
127 | ts->number_received, | 133 | number_received, |
128 | connected); | 134 | GNUNET_i2s (peer), |
135 | connected); | ||
129 | 136 | ||
130 | GNUNET_TESTING_get_trait_async_context (&block_receive, | 137 | GNUNET_TESTING_get_trait_async_context (&block_receive, |
131 | &ac_block); | 138 | &ac_block); |
132 | 139 | ||
133 | if ( connected == ts->number_received) | 140 | if ( connected == number_received) |
134 | { | ||
135 | if (NULL != ac_block->is) | ||
136 | { | 141 | { |
137 | GNUNET_assert (NULL != ac_block); | 142 | if (NULL != ac_block->is) |
138 | if (NULL == ac_block->cont) | 143 | { |
139 | GNUNET_TESTING_async_fail ((struct | 144 | GNUNET_assert (NULL != ac_block); |
140 | GNUNET_TESTING_AsyncContext *) ac_block); | 145 | if (NULL == ac_block->cont) |
141 | else | 146 | GNUNET_TESTING_async_fail ((struct |
142 | GNUNET_TESTING_async_finish ((struct | ||
143 | GNUNET_TESTING_AsyncContext *) ac_block); | 147 | GNUNET_TESTING_AsyncContext *) ac_block); |
144 | } | 148 | else |
145 | else | 149 | GNUNET_TESTING_async_finish ((struct |
146 | { | 150 | GNUNET_TESTING_AsyncContext *) ac_block); |
147 | GNUNET_TESTING_get_trait_block_state ( | 151 | } |
148 | &block_receive, | 152 | else |
149 | (const struct BlockState **) &bs); | 153 | { |
150 | bs->asynchronous_finish = GNUNET_YES; | 154 | GNUNET_TESTING_get_trait_block_state ( |
151 | } | 155 | &block_receive, |
156 | (const struct BlockState **) &bs); | ||
157 | bs->asynchronous_finish = GNUNET_YES; | ||
158 | } | ||
152 | 159 | ||
160 | } | ||
153 | } | 161 | } |
162 | GNUNET_TRANSPORT_core_receive_continue (ch, peer); | ||
154 | } | 163 | } |
155 | 164 | ||
156 | 165 | ||
@@ -284,10 +293,6 @@ start_testcase (TESTING_CMD_HELPER_write_cb write_message, char *router_ip, | |||
284 | GNUNET_MQ_handler_end () | 293 | GNUNET_MQ_handler_end () |
285 | }; | 294 | }; |
286 | 295 | ||
287 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
288 | "number_received %u\n", | ||
289 | ts->number_received); | ||
290 | |||
291 | if (GNUNET_YES == *read_file) | 296 | if (GNUNET_YES == *read_file) |
292 | { | 297 | { |
293 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 298 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
@@ -347,7 +352,7 @@ start_testcase (TESTING_CMD_HELPER_write_cb write_message, char *router_ip, | |||
347 | handlers, | 352 | handlers, |
348 | ts->cfgname, | 353 | ts->cfgname, |
349 | notify_connect, | 354 | notify_connect, |
350 | GNUNET_YES); | 355 | GNUNET_NO); |
351 | struct GNUNET_TESTING_Command commands[] = { | 356 | struct GNUNET_TESTING_Command commands[] = { |
352 | GNUNET_TESTING_cmd_system_create ("system-create", | 357 | GNUNET_TESTING_cmd_system_create ("system-create", |
353 | ts->testdir), | 358 | ts->testdir), |
diff --git a/src/transport/transport_api_cmd_start_peer.c b/src/transport/transport_api_cmd_start_peer.c index e305e24e1..7448eff5a 100644 --- a/src/transport/transport_api_cmd_start_peer.c +++ b/src/transport/transport_api_cmd_start_peer.c | |||
@@ -124,7 +124,7 @@ notify_connect (void *cls, | |||
124 | struct GNUNET_HashCode hc; | 124 | struct GNUNET_HashCode hc; |
125 | struct GNUNET_CRYPTO_EddsaPublicKey public_key = peer->public_key; | 125 | struct GNUNET_CRYPTO_EddsaPublicKey public_key = peer->public_key; |
126 | 126 | ||
127 | void *ret = sps->handlers; | 127 | void *ret = (struct GNUNET_PeerIdentity *) peer; |
128 | 128 | ||
129 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 129 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
130 | "This Peer %s \n", | 130 | "This Peer %s \n", |
diff --git a/src/util/mq.c b/src/util/mq.c index b09837459..40ac97bbe 100644 --- a/src/util/mq.c +++ b/src/util/mq.c | |||
@@ -273,7 +273,7 @@ GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers, | |||
273 | break; | 273 | break; |
274 | } | 274 | } |
275 | } | 275 | } |
276 | done: | 276 | done: |
277 | if (GNUNET_NO == handled) | 277 | if (GNUNET_NO == handled) |
278 | { | 278 | { |
279 | LOG (GNUNET_ERROR_TYPE_INFO, | 279 | LOG (GNUNET_ERROR_TYPE_INFO, |
@@ -384,8 +384,9 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, | |||
384 | mq->current_envelope = ev; | 384 | mq->current_envelope = ev; |
385 | 385 | ||
386 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 386 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
387 | "sending message of type %u, queue empty (MQ: %p)\n", | 387 | "sending message of type %u and size %u, queue empty (MQ: %p)\n", |
388 | ntohs (ev->mh->type), | 388 | ntohs (ev->mh->type), |
389 | ntohs (ev->mh->size), | ||
389 | mq); | 390 | mq); |
390 | 391 | ||
391 | mq->send_impl (mq, | 392 | mq->send_impl (mq, |
@@ -479,8 +480,10 @@ impl_send_continue (void *cls) | |||
479 | mq->current_envelope); | 480 | mq->current_envelope); |
480 | 481 | ||
481 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 482 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
482 | "sending message of type %u from queue\n", | 483 | "sending message of type %u and size %u from queue (MQ: %p)\n", |
483 | ntohs (mq->current_envelope->mh->type)); | 484 | ntohs (mq->current_envelope->mh->type), |
485 | ntohs (mq->current_envelope->mh->size), | ||
486 | mq); | ||
484 | 487 | ||
485 | mq->send_impl (mq, | 488 | mq->send_impl (mq, |
486 | mq->current_envelope->mh, | 489 | mq->current_envelope->mh, |