diff options
Diffstat (limited to 'src/transport')
-rw-r--r-- | src/transport/test_transport_api_manipulation_cfg.c | 212 | ||||
-rw-r--r-- | src/transport/test_transport_api_manipulation_recv_tcp.c | 216 | ||||
-rw-r--r-- | src/transport/test_transport_api_manipulation_send_tcp.c | 81 | ||||
-rw-r--r-- | src/transport/transport-testing.h | 2 |
4 files changed, 134 insertions, 377 deletions
diff --git a/src/transport/test_transport_api_manipulation_cfg.c b/src/transport/test_transport_api_manipulation_cfg.c index 19823e0b3..84824ad8b 100644 --- a/src/transport/test_transport_api_manipulation_cfg.c +++ b/src/transport/test_transport_api_manipulation_cfg.c | |||
@@ -20,7 +20,7 @@ | |||
20 | /** | 20 | /** |
21 | * @file transport/test_transport_api_manipulation_cfg.c | 21 | * @file transport/test_transport_api_manipulation_cfg.c |
22 | * @brief base test case for transport traffic manipulation implementation | 22 | * @brief base test case for transport traffic manipulation implementation |
23 | * based onf cfg | 23 | * based on cfg |
24 | * | 24 | * |
25 | * Peer 1 has inbound and outbound delay of 100ms | 25 | * Peer 1 has inbound and outbound delay of 100ms |
26 | * Peer 2 has no inbound and outbound delay | 26 | * Peer 2 has no inbound and outbound delay |
@@ -37,15 +37,9 @@ | |||
37 | */ | 37 | */ |
38 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) | 38 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) |
39 | 39 | ||
40 | /** | ||
41 | * How long until we give up on transmitting the message? | ||
42 | */ | ||
43 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | ||
44 | 40 | ||
45 | #define TEST_MESSAGE_SIZE 2600 | 41 | #define TEST_MESSAGE_SIZE 2600 |
46 | 42 | ||
47 | #define TEST_REQUEST_MESSAGE_TYPE 12345 | ||
48 | |||
49 | #define TEST_RESPONSE_MESSAGE_TYPE 12346 | 43 | #define TEST_RESPONSE_MESSAGE_TYPE 12346 |
50 | 44 | ||
51 | /** | 45 | /** |
@@ -56,157 +50,31 @@ | |||
56 | 50 | ||
57 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; | 51 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; |
58 | 52 | ||
59 | static struct GNUNET_TRANSPORT_TransmitHandle *th; | ||
60 | |||
61 | static struct GNUNET_SCHEDULER_Task *send_task; | ||
62 | |||
63 | static struct GNUNET_TIME_Absolute start_request; | 53 | static struct GNUNET_TIME_Absolute start_request; |
64 | 54 | ||
65 | static struct GNUNET_TIME_Absolute start_response; | 55 | static struct GNUNET_TIME_Absolute start_response; |
66 | 56 | ||
67 | 57 | ||
68 | static void | 58 | static void |
69 | custom_shutdown (void *cls) | ||
70 | { | ||
71 | if (NULL != th) | ||
72 | { | ||
73 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
74 | th = NULL; | ||
75 | } | ||
76 | if (NULL != send_task) | ||
77 | { | ||
78 | GNUNET_SCHEDULER_cancel (send_task); | ||
79 | send_task = NULL; | ||
80 | } | ||
81 | } | ||
82 | |||
83 | |||
84 | static size_t | ||
85 | notify_request_ready (void *cls, size_t size, void *buf) | ||
86 | { | ||
87 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
88 | struct GNUNET_MessageHeader *hdr; | ||
89 | |||
90 | th = NULL; | ||
91 | if (NULL == buf) | ||
92 | { | ||
93 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
94 | "Timeout occurred while waiting for transmit_ready\n"); | ||
95 | GNUNET_SCHEDULER_shutdown (); | ||
96 | ccc->global_ret = 42; | ||
97 | return 0; | ||
98 | } | ||
99 | |||
100 | GNUNET_assert (size >= TEST_MESSAGE_SIZE); | ||
101 | memset (buf, '\0', TEST_MESSAGE_SIZE); | ||
102 | hdr = buf; | ||
103 | hdr->size = htons (TEST_MESSAGE_SIZE); | ||
104 | hdr->type = htons (TEST_REQUEST_MESSAGE_TYPE); | ||
105 | |||
106 | { | ||
107 | char *ps = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); | ||
108 | |||
109 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
110 | "Sending request message from peer %u (`%4s') with type %u and size %u bytes to peer %u (`%4s')\n", | ||
111 | ccc->p[0]->no, ps, | ||
112 | ntohs (hdr->type), | ||
113 | ntohs (hdr->size), | ||
114 | p->no, | ||
115 | GNUNET_i2s (&p->id)); | ||
116 | GNUNET_free (ps); | ||
117 | } | ||
118 | |||
119 | return TEST_MESSAGE_SIZE; | ||
120 | } | ||
121 | |||
122 | |||
123 | static void | ||
124 | sendtask_request_task (void *cls) | ||
125 | { | ||
126 | send_task = NULL; | ||
127 | { | ||
128 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&ccc->p[1]->id)); | ||
129 | |||
130 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
131 | "Sending message from peer %u (`%s') -> peer %u (`%s') !\n", | ||
132 | ccc->p[0]->no, | ||
133 | GNUNET_i2s (&ccc->p[0]->id), | ||
134 | ccc->p[1]->no, | ||
135 | receiver_s); | ||
136 | GNUNET_free (receiver_s); | ||
137 | } | ||
138 | |||
139 | start_request = GNUNET_TIME_absolute_get(); | ||
140 | th = GNUNET_TRANSPORT_notify_transmit_ready (ccc->p[0]->th, | ||
141 | &ccc->p[1]->id, | ||
142 | TEST_MESSAGE_SIZE, | ||
143 | TIMEOUT_TRANSMIT, | ||
144 | ¬ify_request_ready, | ||
145 | ccc->p[1]); | ||
146 | } | ||
147 | |||
148 | |||
149 | static size_t | ||
150 | notify_response_ready (void *cls, size_t size, void *buf) | ||
151 | { | ||
152 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
153 | struct GNUNET_MessageHeader *hdr; | ||
154 | |||
155 | th = NULL; | ||
156 | if (NULL == buf) | ||
157 | { | ||
158 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
159 | "Timeout occurred while waiting for transmit_ready\n"); | ||
160 | GNUNET_SCHEDULER_shutdown (); | ||
161 | ccc->global_ret = 42; | ||
162 | return 0; | ||
163 | } | ||
164 | |||
165 | GNUNET_assert (size >= TEST_MESSAGE_SIZE); | ||
166 | memset (buf, '\0', TEST_MESSAGE_SIZE); | ||
167 | hdr = buf; | ||
168 | hdr->size = htons (TEST_MESSAGE_SIZE); | ||
169 | hdr->type = htons (TEST_RESPONSE_MESSAGE_TYPE); | ||
170 | |||
171 | { | ||
172 | char *ps = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); | ||
173 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
174 | "Sending response message from peer %u (`%4s') with type %u and size %u bytes to peer %u (`%4s')\n", | ||
175 | ccc->p[0]->no, | ||
176 | ps, | ||
177 | ntohs (hdr->type), | ||
178 | ntohs (hdr->size), | ||
179 | p->no, | ||
180 | GNUNET_i2s (&p->id)); | ||
181 | GNUNET_free (ps); | ||
182 | } | ||
183 | |||
184 | return TEST_MESSAGE_SIZE; | ||
185 | } | ||
186 | |||
187 | |||
188 | static void | ||
189 | sendtask_response_task (void *cls) | 59 | sendtask_response_task (void *cls) |
190 | { | 60 | { |
191 | send_task = NULL; | 61 | int ret; |
62 | |||
63 | start_response = GNUNET_TIME_absolute_get(); | ||
64 | ret = GNUNET_TRANSPORT_TESTING_send (ccc->p[1], | ||
65 | ccc->p[0], | ||
66 | TEST_RESPONSE_MESSAGE_TYPE, | ||
67 | TEST_MESSAGE_SIZE, | ||
68 | 1, | ||
69 | NULL, | ||
70 | NULL); | ||
71 | if (GNUNET_NO == ret) | ||
192 | { | 72 | { |
193 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); | 73 | GNUNET_break (0); |
194 | 74 | GNUNET_SCHEDULER_shutdown (); | |
195 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 75 | return; |
196 | "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n", | ||
197 | ccc->p[1]->no, | ||
198 | GNUNET_i2s (&ccc->p[1]->id), | ||
199 | ccc->p[0]->no, | ||
200 | receiver_s); | ||
201 | GNUNET_free (receiver_s); | ||
202 | } | 76 | } |
203 | start_response = GNUNET_TIME_absolute_get(); | 77 | GNUNET_assert (GNUNET_SYSERR != ret); |
204 | th = GNUNET_TRANSPORT_notify_transmit_ready (ccc->p[1]->th, | ||
205 | &ccc->p[0]->id, | ||
206 | TEST_MESSAGE_SIZE, | ||
207 | TIMEOUT_TRANSMIT, | ||
208 | ¬ify_response_ready, | ||
209 | ccc->p[0]); | ||
210 | } | 78 | } |
211 | 79 | ||
212 | 80 | ||
@@ -232,14 +100,16 @@ notify_receive (void *cls, | |||
232 | } | 100 | } |
233 | 101 | ||
234 | switch (ntohs (message->type)) { | 102 | switch (ntohs (message->type)) { |
235 | case TEST_REQUEST_MESSAGE_TYPE: | 103 | case GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE: |
236 | duration = GNUNET_TIME_absolute_get_difference(start_request, | 104 | duration = GNUNET_TIME_absolute_get_difference (start_request, |
237 | GNUNET_TIME_absolute_get()); | 105 | GNUNET_TIME_absolute_get()); |
238 | if (duration.rel_value_us >= TEST_DELAY) | 106 | if (duration.rel_value_us >= TEST_DELAY) |
107 | { | ||
239 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 108 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
240 | "Request message was delayed for %s\n", | 109 | "Request message was delayed for %s\n", |
241 | GNUNET_STRINGS_relative_time_to_string (duration, | 110 | GNUNET_STRINGS_relative_time_to_string (duration, |
242 | GNUNET_YES)); | 111 | GNUNET_YES)); |
112 | } | ||
243 | else | 113 | else |
244 | { | 114 | { |
245 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 115 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
@@ -250,17 +120,20 @@ notify_receive (void *cls, | |||
250 | GNUNET_SCHEDULER_shutdown (); | 120 | GNUNET_SCHEDULER_shutdown (); |
251 | } | 121 | } |
252 | /* Send response */ | 122 | /* Send response */ |
253 | send_task = GNUNET_SCHEDULER_add_now (&sendtask_response_task, | 123 | GNUNET_SCHEDULER_add_now (&sendtask_response_task, |
254 | NULL); | 124 | NULL); |
255 | return; | 125 | return; |
256 | case TEST_RESPONSE_MESSAGE_TYPE: | 126 | case TEST_RESPONSE_MESSAGE_TYPE: |
257 | duration = GNUNET_TIME_absolute_get_difference(start_response, | 127 | duration = GNUNET_TIME_absolute_get_difference(start_response, |
258 | GNUNET_TIME_absolute_get()); | 128 | GNUNET_TIME_absolute_get()); |
259 | if (duration.rel_value_us >= TEST_DELAY) | 129 | if (duration.rel_value_us >= TEST_DELAY) |
130 | { | ||
260 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 131 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
261 | "Response message was delayed for %s\n", | 132 | "Response message was delayed for %s\n", |
262 | GNUNET_STRINGS_relative_time_to_string (duration, | 133 | GNUNET_STRINGS_relative_time_to_string (duration, |
263 | GNUNET_YES)); | 134 | GNUNET_YES)); |
135 | ccc->global_ret = GNUNET_OK; | ||
136 | } | ||
264 | else | 137 | else |
265 | { | 138 | { |
266 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 139 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
@@ -268,48 +141,35 @@ notify_receive (void *cls, | |||
268 | GNUNET_STRINGS_relative_time_to_string (duration, | 141 | GNUNET_STRINGS_relative_time_to_string (duration, |
269 | GNUNET_YES)); | 142 | GNUNET_YES)); |
270 | ccc->global_ret = GNUNET_SYSERR; | 143 | ccc->global_ret = GNUNET_SYSERR; |
271 | GNUNET_SCHEDULER_shutdown (); | ||
272 | break; | ||
273 | } | 144 | } |
274 | ccc->global_ret = GNUNET_OK; | ||
275 | GNUNET_SCHEDULER_shutdown (); | 145 | GNUNET_SCHEDULER_shutdown (); |
276 | break; | 146 | break; |
277 | default: | 147 | default: |
148 | GNUNET_break (0); | ||
278 | break; | 149 | break; |
279 | } | 150 | } |
280 | } | 151 | } |
281 | 152 | ||
282 | 153 | ||
283 | static void | ||
284 | notify_disconnect (void *cls, | ||
285 | struct GNUNET_TRANSPORT_TESTING_PeerContext *me, | ||
286 | const struct GNUNET_PeerIdentity *other) | ||
287 | { | ||
288 | GNUNET_TRANSPORT_TESTING_log_disconnect (cls, | ||
289 | me, | ||
290 | other); | ||
291 | if (NULL != th) | ||
292 | { | ||
293 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
294 | th = NULL; | ||
295 | } | ||
296 | } | ||
297 | |||
298 | |||
299 | int | 154 | int |
300 | main (int argc, char *argv[]) | 155 | main (int argc, |
156 | char *argv[]) | ||
301 | { | 157 | { |
158 | struct GNUNET_TRANSPORT_TESTING_SendClosure sc = { | ||
159 | .num_messages = 1 | ||
160 | }; | ||
302 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { | 161 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { |
303 | .connect_continuation = &sendtask_request_task, | 162 | .connect_continuation = &GNUNET_TRANSPORT_TESTING_large_send, |
163 | .connect_continuation_cls = &sc, | ||
304 | .config_file = "test_transport_api_data.conf", | 164 | .config_file = "test_transport_api_data.conf", |
305 | .rec = ¬ify_receive, | 165 | .rec = ¬ify_receive, |
306 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, | 166 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, |
307 | .nd = ¬ify_disconnect, | 167 | .nd = &GNUNET_TRANSPORT_TESTING_log_disconnect, |
308 | .shutdown_task = &custom_shutdown, | ||
309 | .timeout = TIMEOUT | 168 | .timeout = TIMEOUT |
310 | }; | 169 | }; |
311 | 170 | ||
312 | ccc = &my_ccc; | 171 | ccc = &my_ccc; |
172 | sc.ccc = ccc; | ||
313 | if (GNUNET_OK != | 173 | if (GNUNET_OK != |
314 | GNUNET_TRANSPORT_TESTING_main (2, | 174 | GNUNET_TRANSPORT_TESTING_main (2, |
315 | &GNUNET_TRANSPORT_TESTING_connect_check, | 175 | &GNUNET_TRANSPORT_TESTING_connect_check, |
diff --git a/src/transport/test_transport_api_manipulation_recv_tcp.c b/src/transport/test_transport_api_manipulation_recv_tcp.c index 023d5a714..e902aed62 100644 --- a/src/transport/test_transport_api_manipulation_recv_tcp.c +++ b/src/transport/test_transport_api_manipulation_recv_tcp.c | |||
@@ -36,22 +36,9 @@ | |||
36 | */ | 36 | */ |
37 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) | 37 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) |
38 | 38 | ||
39 | /** | ||
40 | * How long until we give up on transmitting the message? | ||
41 | */ | ||
42 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | ||
43 | |||
44 | #define TEST_MESSAGE_SIZE 2600 | ||
45 | |||
46 | #define TEST_MESSAGE_TYPE 12345 | ||
47 | |||
48 | 39 | ||
49 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; | 40 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; |
50 | 41 | ||
51 | static struct GNUNET_TRANSPORT_TransmitHandle *th; | ||
52 | |||
53 | static struct GNUNET_SCHEDULER_Task *send_task; | ||
54 | |||
55 | static int messages_recv; | 42 | static int messages_recv; |
56 | 43 | ||
57 | static struct GNUNET_TIME_Absolute start_normal; | 44 | static struct GNUNET_TIME_Absolute start_normal; |
@@ -64,26 +51,46 @@ static struct GNUNET_TIME_Relative dur_delayed; | |||
64 | 51 | ||
65 | 52 | ||
66 | static void | 53 | static void |
67 | custom_shutdown (void *cls) | 54 | do_free (void *cls) |
68 | { | 55 | { |
69 | if (NULL != th) | 56 | struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls; |
57 | |||
58 | GNUNET_free (sc); | ||
59 | } | ||
60 | |||
61 | |||
62 | static void | ||
63 | sendtask (void *cls) | ||
64 | { | ||
65 | struct GNUNET_TRANSPORT_TESTING_SendClosure *sc; | ||
66 | struct GNUNET_ATS_Properties prop; | ||
67 | struct GNUNET_TIME_Relative delay; | ||
68 | |||
69 | sc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_SendClosure); | ||
70 | sc->num_messages = 1; | ||
71 | sc->ccc = ccc; | ||
72 | sc->cont = &do_free; | ||
73 | sc->cont_cls = sc; | ||
74 | if (0 == messages_recv) | ||
70 | { | 75 | { |
71 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | 76 | start_normal = GNUNET_TIME_absolute_get(); |
72 | th = NULL; | ||
73 | } | 77 | } |
74 | if (NULL != send_task) | 78 | if (0 < messages_recv) |
75 | { | 79 | { |
76 | GNUNET_SCHEDULER_cancel (send_task); | 80 | memset (&prop, 0, sizeof (prop)); |
77 | send_task = NULL; | 81 | delay = GNUNET_TIME_UNIT_SECONDS; |
82 | GNUNET_TRANSPORT_set_traffic_metric (ccc->p[1]->th, | ||
83 | &ccc->p[0]->id, | ||
84 | &prop, | ||
85 | delay, | ||
86 | GNUNET_TIME_UNIT_ZERO); | ||
87 | start_delayed = GNUNET_TIME_absolute_get(); | ||
78 | } | 88 | } |
89 | GNUNET_TRANSPORT_TESTING_large_send (sc); | ||
79 | } | 90 | } |
80 | 91 | ||
81 | 92 | ||
82 | static void | 93 | static void |
83 | sendtask (void *cls); | ||
84 | |||
85 | |||
86 | static void | ||
87 | notify_receive (void *cls, | 94 | notify_receive (void *cls, |
88 | struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, | 95 | struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, |
89 | const struct GNUNET_PeerIdentity *sender, | 96 | const struct GNUNET_PeerIdentity *sender, |
@@ -101,13 +108,8 @@ notify_receive (void *cls, | |||
101 | GNUNET_i2s (sender)); | 108 | GNUNET_i2s (sender)); |
102 | GNUNET_free (ps); | 109 | GNUNET_free (ps); |
103 | } | 110 | } |
104 | if ((TEST_MESSAGE_TYPE == ntohs (message->type)) && | 111 | if ( (GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE != ntohs (message->type)) || |
105 | (TEST_MESSAGE_SIZE == ntohs (message->size))) | 112 | (GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE != ntohs (message->size)) ) |
106 | { | ||
107 | if (GNUNET_NO == ccc->global_ret) | ||
108 | ccc->global_ret = GNUNET_OK; | ||
109 | } | ||
110 | else | ||
111 | { | 113 | { |
112 | GNUNET_break (0); | 114 | GNUNET_break (0); |
113 | ccc->global_ret = GNUNET_SYSERR; | 115 | ccc->global_ret = GNUNET_SYSERR; |
@@ -118,150 +120,54 @@ notify_receive (void *cls, | |||
118 | if (messages_recv <= 1) | 120 | if (messages_recv <= 1) |
119 | { | 121 | { |
120 | /* Received non-delayed message */ | 122 | /* Received non-delayed message */ |
121 | dur_normal = GNUNET_TIME_absolute_get_duration(start_normal); | 123 | dur_normal = GNUNET_TIME_absolute_get_duration (start_normal); |
122 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 124 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
123 | "Received non-delayed message %u after %s\n", | 125 | "Received non-delayed message %u after %s\n", |
124 | messages_recv, | 126 | messages_recv, |
125 | GNUNET_STRINGS_relative_time_to_string (dur_normal, | 127 | GNUNET_STRINGS_relative_time_to_string (dur_normal, |
126 | GNUNET_YES)); | 128 | GNUNET_YES)); |
127 | 129 | GNUNET_SCHEDULER_add_now (&sendtask, | |
128 | struct GNUNET_ATS_Properties prop; | 130 | NULL); |
129 | struct GNUNET_TIME_Relative delay; | 131 | messages_recv++; |
130 | 132 | return; | |
131 | delay.rel_value_us = 1000 * 1000LL; | ||
132 | memset (&prop, 0, sizeof (prop)); | ||
133 | prop.distance = 10; | ||
134 | GNUNET_TRANSPORT_set_traffic_metric (ccc->p[0]->th, | ||
135 | &ccc->p[1]->id, | ||
136 | &prop, | ||
137 | delay, | ||
138 | GNUNET_TIME_UNIT_ZERO); | ||
139 | send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL); | ||
140 | } | ||
141 | if (2 == messages_recv) | ||
142 | { | ||
143 | /* Received manipulated message */ | ||
144 | dur_delayed = GNUNET_TIME_absolute_get_duration(start_delayed); | ||
145 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
146 | "Received delayed message %u after %s\n", | ||
147 | messages_recv, | ||
148 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, | ||
149 | GNUNET_YES)); | ||
150 | if (dur_delayed.rel_value_us < GNUNET_TIME_UNIT_SECONDS.rel_value_us) | ||
151 | { | ||
152 | GNUNET_break (0); | ||
153 | ccc->global_ret = GNUNET_SYSERR; | ||
154 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
155 | "Delayed message was not delayed correctly: took only %s\n", | ||
156 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, | ||
157 | GNUNET_YES)); | ||
158 | } | ||
159 | /* shutdown */ | ||
160 | GNUNET_SCHEDULER_shutdown (); | ||
161 | } | 133 | } |
162 | messages_recv++; | 134 | /* Received manipulated message */ |
163 | } | 135 | dur_delayed = GNUNET_TIME_absolute_get_duration(start_delayed); |
164 | 136 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |
165 | 137 | "Received delayed message %u after %s\n", | |
166 | static size_t | 138 | messages_recv, |
167 | notify_ready (void *cls, size_t size, void *buf) | 139 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, |
168 | { | 140 | GNUNET_YES)); |
169 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | 141 | if (dur_delayed.rel_value_us < GNUNET_TIME_UNIT_SECONDS.rel_value_us) |
170 | struct GNUNET_MessageHeader *hdr; | ||
171 | |||
172 | th = NULL; | ||
173 | if (NULL == buf) | ||
174 | { | 142 | { |
143 | GNUNET_break (0); | ||
144 | ccc->global_ret = GNUNET_SYSERR; | ||
175 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 145 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
176 | "Timeout occurred while waiting for transmit_ready\n"); | 146 | "Delayed message was not delayed correctly: took only %s\n", |
177 | GNUNET_SCHEDULER_shutdown (); | 147 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, |
178 | ccc->global_ret = 42; | 148 | GNUNET_YES)); |
179 | return 0; | ||
180 | } | ||
181 | |||
182 | GNUNET_assert (size >= TEST_MESSAGE_SIZE); | ||
183 | memset (buf, '\0', TEST_MESSAGE_SIZE); | ||
184 | hdr = buf; | ||
185 | hdr->size = htons (TEST_MESSAGE_SIZE); | ||
186 | hdr->type = htons (TEST_MESSAGE_TYPE); | ||
187 | |||
188 | { | ||
189 | char *ps = GNUNET_strdup (GNUNET_i2s (&ccc->p[1]->id)); | ||
190 | |||
191 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
192 | "Peer %u (`%s') sending message with type %u and size %u bytes to peer %u (`%s')\n", | ||
193 | ccc->p[1]->no, | ||
194 | ps, | ||
195 | ntohs (hdr->type), | ||
196 | ntohs (hdr->size), | ||
197 | p->no, | ||
198 | GNUNET_i2s (&p->id)); | ||
199 | GNUNET_free (ps); | ||
200 | } | ||
201 | |||
202 | return TEST_MESSAGE_SIZE; | ||
203 | } | ||
204 | |||
205 | |||
206 | static void | ||
207 | sendtask (void *cls) | ||
208 | { | ||
209 | if (NULL == send_task) | ||
210 | ccc->global_ret = GNUNET_NO; /* first call! */ | ||
211 | send_task = NULL; | ||
212 | { | ||
213 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); | ||
214 | |||
215 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
216 | "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n", | ||
217 | ccc->p[1]->no, GNUNET_i2s (&ccc->p[1]->id), ccc->p[0]->no, receiver_s); | ||
218 | GNUNET_free (receiver_s); | ||
219 | } | ||
220 | if (0 == messages_recv) | ||
221 | { | ||
222 | start_normal = GNUNET_TIME_absolute_get(); | ||
223 | } | ||
224 | if (1 == messages_recv) | ||
225 | { | ||
226 | start_delayed = GNUNET_TIME_absolute_get(); | ||
227 | } | 149 | } |
228 | 150 | else | |
229 | th = GNUNET_TRANSPORT_notify_transmit_ready (ccc->p[1]->th, | 151 | { |
230 | &ccc->p[0]->id, | 152 | ccc->global_ret = GNUNET_OK; |
231 | TEST_MESSAGE_SIZE, | ||
232 | TIMEOUT_TRANSMIT, | ||
233 | ¬ify_ready, | ||
234 | ccc->p[0]); | ||
235 | } | ||
236 | |||
237 | |||
238 | static void | ||
239 | notify_disconnect (void *cls, | ||
240 | struct GNUNET_TRANSPORT_TESTING_PeerContext *me, | ||
241 | const struct GNUNET_PeerIdentity *other) | ||
242 | { | ||
243 | GNUNET_TRANSPORT_TESTING_log_disconnect (cls, | ||
244 | me, | ||
245 | other); | ||
246 | if (NULL != th) | ||
247 | { | ||
248 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
249 | th = NULL; | ||
250 | } | 153 | } |
154 | /* shutdown */ | ||
155 | GNUNET_SCHEDULER_shutdown (); | ||
251 | } | 156 | } |
252 | 157 | ||
253 | 158 | ||
254 | int | 159 | int |
255 | main (int argc, char *argv[]) | 160 | main (int argc, |
161 | char *argv[]) | ||
256 | { | 162 | { |
257 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { | 163 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { |
258 | .connect_continuation = &sendtask, | 164 | .connect_continuation = &sendtask, |
259 | .config_file = "test_transport_api_data.conf", | 165 | .config_file = "test_transport_api_data.conf", |
260 | .rec = ¬ify_receive, | 166 | .rec = ¬ify_receive, |
261 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, | 167 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, |
262 | .nd = ¬ify_disconnect, | 168 | .nd = &GNUNET_TRANSPORT_TESTING_log_disconnect, |
263 | .shutdown_task = &custom_shutdown, | 169 | .timeout = TIMEOUT, |
264 | .timeout = TIMEOUT | 170 | .global_ret = GNUNET_NO |
265 | }; | 171 | }; |
266 | 172 | ||
267 | ccc = &my_ccc; | 173 | ccc = &my_ccc; |
diff --git a/src/transport/test_transport_api_manipulation_send_tcp.c b/src/transport/test_transport_api_manipulation_send_tcp.c index 7e73f0b9c..95a6b5140 100644 --- a/src/transport/test_transport_api_manipulation_send_tcp.c +++ b/src/transport/test_transport_api_manipulation_send_tcp.c | |||
@@ -36,9 +36,6 @@ | |||
36 | */ | 36 | */ |
37 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 37 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) |
38 | 38 | ||
39 | #define TEST_MESSAGE_SIZE 2600 | ||
40 | |||
41 | |||
42 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; | 39 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; |
43 | 40 | ||
44 | static int messages_recv; | 41 | static int messages_recv; |
@@ -52,24 +49,27 @@ static struct GNUNET_TIME_Absolute start_delayed; | |||
52 | static struct GNUNET_TIME_Relative dur_delayed; | 49 | static struct GNUNET_TIME_Relative dur_delayed; |
53 | 50 | ||
54 | 51 | ||
55 | static size_t | 52 | static void |
56 | get_size (unsigned int cnt_down) | 53 | do_free (void *cls) |
57 | { | 54 | { |
58 | return TEST_MESSAGE_SIZE; | 55 | struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls; |
56 | |||
57 | GNUNET_free (sc); | ||
59 | } | 58 | } |
60 | 59 | ||
61 | 60 | ||
62 | static void | 61 | static void |
63 | sendtask (void *cls) | 62 | sendtask (void *cls) |
64 | { | 63 | { |
64 | struct GNUNET_TRANSPORT_TESTING_SendClosure *sc; | ||
65 | struct GNUNET_TIME_Relative delay; | 65 | struct GNUNET_TIME_Relative delay; |
66 | struct GNUNET_ATS_Properties prop; | 66 | struct GNUNET_ATS_Properties prop; |
67 | struct GNUNET_TRANSPORT_TESTING_SendClosure sc = { | ||
68 | .num_messages = 1, | ||
69 | .get_size_cb = &get_size, | ||
70 | .ccc = ccc | ||
71 | }; | ||
72 | 67 | ||
68 | sc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_SendClosure); | ||
69 | sc->num_messages = 1; | ||
70 | sc->ccc = ccc; | ||
71 | sc->cont = &do_free; | ||
72 | sc->cont_cls = sc; | ||
73 | if (0 == messages_recv) | 73 | if (0 == messages_recv) |
74 | { | 74 | { |
75 | start_normal = GNUNET_TIME_absolute_get (); | 75 | start_normal = GNUNET_TIME_absolute_get (); |
@@ -78,20 +78,14 @@ sendtask (void *cls) | |||
78 | { | 78 | { |
79 | memset (&prop, 0, sizeof (prop)); | 79 | memset (&prop, 0, sizeof (prop)); |
80 | delay = GNUNET_TIME_UNIT_SECONDS; | 80 | delay = GNUNET_TIME_UNIT_SECONDS; |
81 | GNUNET_TRANSPORT_set_traffic_metric (ccc->p[1]->th, | ||
82 | &ccc->p[0]->id, | ||
83 | &prop, | ||
84 | GNUNET_TIME_UNIT_ZERO, | ||
85 | delay); | ||
86 | prop.distance = 10; | ||
87 | GNUNET_TRANSPORT_set_traffic_metric (ccc->p[0]->th, | 81 | GNUNET_TRANSPORT_set_traffic_metric (ccc->p[0]->th, |
88 | &ccc->p[1]->id, | 82 | &ccc->p[1]->id, |
89 | &prop, | 83 | &prop, |
90 | delay, | 84 | GNUNET_TIME_UNIT_ZERO, |
91 | delay); | 85 | delay); |
92 | start_delayed = GNUNET_TIME_absolute_get(); | 86 | start_delayed = GNUNET_TIME_absolute_get(); |
93 | } | 87 | } |
94 | GNUNET_TRANSPORT_TESTING_simple_send (&sc); | 88 | GNUNET_TRANSPORT_TESTING_large_send (sc); |
95 | } | 89 | } |
96 | 90 | ||
97 | 91 | ||
@@ -114,13 +108,8 @@ notify_receive (void *cls, | |||
114 | GNUNET_free (ps); | 108 | GNUNET_free (ps); |
115 | } | 109 | } |
116 | 110 | ||
117 | if ( (GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE == ntohs (message->type)) && | 111 | if ( (GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE != ntohs (message->type)) || |
118 | (TEST_MESSAGE_SIZE == ntohs (message->size)) ) | 112 | (GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE != ntohs (message->size)) ) |
119 | { | ||
120 | if (GNUNET_NO == ccc->global_ret) | ||
121 | ccc->global_ret = GNUNET_OK; | ||
122 | } | ||
123 | else | ||
124 | { | 113 | { |
125 | GNUNET_break (0); | 114 | GNUNET_break (0); |
126 | ccc->global_ret = GNUNET_SYSERR; | 115 | ccc->global_ret = GNUNET_SYSERR; |
@@ -139,28 +128,30 @@ notify_receive (void *cls, | |||
139 | GNUNET_YES)); | 128 | GNUNET_YES)); |
140 | GNUNET_SCHEDULER_add_now (&sendtask, | 129 | GNUNET_SCHEDULER_add_now (&sendtask, |
141 | NULL); | 130 | NULL); |
131 | messages_recv++; | ||
132 | return; | ||
142 | } | 133 | } |
143 | if (1 == messages_recv) | 134 | /* Received manipulated message */ |
135 | dur_delayed = GNUNET_TIME_absolute_get_duration(start_delayed); | ||
136 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
137 | "Received delayed message %u after %s\n", | ||
138 | messages_recv, | ||
139 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, | ||
140 | GNUNET_YES)); | ||
141 | if (dur_delayed.rel_value_us < GNUNET_TIME_UNIT_SECONDS.rel_value_us) | ||
144 | { | 142 | { |
145 | /* Received manipulated message */ | 143 | GNUNET_break (0); |
146 | dur_delayed = GNUNET_TIME_absolute_get_duration(start_delayed); | 144 | ccc->global_ret = GNUNET_SYSERR; |
147 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 145 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
148 | "Received delayed message %u after %s\n", | 146 | "Delayed message was not delayed correctly: took only %s\n", |
149 | messages_recv, | 147 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, |
150 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, | 148 | GNUNET_YES)); |
151 | GNUNET_YES)); | 149 | } |
152 | if (dur_delayed.rel_value_us < GNUNET_TIME_UNIT_SECONDS.rel_value_us) | 150 | else |
153 | { | 151 | { |
154 | GNUNET_break (0); | 152 | ccc->global_ret = GNUNET_OK; |
155 | ccc->global_ret = GNUNET_SYSERR; | ||
156 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
157 | "Delayed message was not delayed correctly: took only %s\n", | ||
158 | GNUNET_STRINGS_relative_time_to_string (dur_delayed, | ||
159 | GNUNET_YES)); | ||
160 | } | ||
161 | GNUNET_SCHEDULER_shutdown (); | ||
162 | } | 153 | } |
163 | messages_recv++; | 154 | GNUNET_SCHEDULER_shutdown (); |
164 | } | 155 | } |
165 | 156 | ||
166 | 157 | ||
diff --git a/src/transport/transport-testing.h b/src/transport/transport-testing.h index dc26950cb..bfed64b70 100644 --- a/src/transport/transport-testing.h +++ b/src/transport/transport-testing.h | |||
@@ -809,7 +809,7 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
809 | struct GNUNET_TRANSPORT_TESTING_TestMessage | 809 | struct GNUNET_TRANSPORT_TESTING_TestMessage |
810 | { | 810 | { |
811 | /** | 811 | /** |
812 | * Type is #GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE. | 812 | * Type is (usually) #GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE. |
813 | */ | 813 | */ |
814 | struct GNUNET_MessageHeader header; | 814 | struct GNUNET_MessageHeader header; |
815 | 815 | ||