aboutsummaryrefslogtreecommitdiff
path: root/src/transport
diff options
context:
space:
mode:
Diffstat (limited to 'src/transport')
-rw-r--r--src/transport/test_transport_api_manipulation_cfg.c212
-rw-r--r--src/transport/test_transport_api_manipulation_recv_tcp.c216
-rw-r--r--src/transport/test_transport_api_manipulation_send_tcp.c81
-rw-r--r--src/transport/transport-testing.h2
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
57static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; 51static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
58 52
59static struct GNUNET_TRANSPORT_TransmitHandle *th;
60
61static struct GNUNET_SCHEDULER_Task *send_task;
62
63static struct GNUNET_TIME_Absolute start_request; 53static struct GNUNET_TIME_Absolute start_request;
64 54
65static struct GNUNET_TIME_Absolute start_response; 55static struct GNUNET_TIME_Absolute start_response;
66 56
67 57
68static void 58static void
69custom_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
84static size_t
85notify_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
123static void
124sendtask_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 &notify_request_ready,
145 ccc->p[1]);
146}
147
148
149static size_t
150notify_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
188static void
189sendtask_response_task (void *cls) 59sendtask_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 &notify_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
283static void
284notify_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
299int 154int
300main (int argc, char *argv[]) 155main (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 = &notify_receive, 165 .rec = &notify_receive,
306 .nc = &GNUNET_TRANSPORT_TESTING_log_connect, 166 .nc = &GNUNET_TRANSPORT_TESTING_log_connect,
307 .nd = &notify_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
49static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; 40static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
50 41
51static struct GNUNET_TRANSPORT_TransmitHandle *th;
52
53static struct GNUNET_SCHEDULER_Task *send_task;
54
55static int messages_recv; 42static int messages_recv;
56 43
57static struct GNUNET_TIME_Absolute start_normal; 44static struct GNUNET_TIME_Absolute start_normal;
@@ -64,26 +51,46 @@ static struct GNUNET_TIME_Relative dur_delayed;
64 51
65 52
66static void 53static void
67custom_shutdown (void *cls) 54do_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
62static void
63sendtask (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
82static void 93static void
83sendtask (void *cls);
84
85
86static void
87notify_receive (void *cls, 94notify_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",
166static size_t 138 messages_recv,
167notify_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
206static void
207sendtask (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 &notify_ready,
234 ccc->p[0]);
235}
236
237
238static void
239notify_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
254int 159int
255main (int argc, char *argv[]) 160main (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 = &notify_receive, 166 .rec = &notify_receive,
261 .nc = &GNUNET_TRANSPORT_TESTING_log_connect, 167 .nc = &GNUNET_TRANSPORT_TESTING_log_connect,
262 .nd = &notify_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
42static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; 39static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
43 40
44static int messages_recv; 41static int messages_recv;
@@ -52,24 +49,27 @@ static struct GNUNET_TIME_Absolute start_delayed;
52static struct GNUNET_TIME_Relative dur_delayed; 49static struct GNUNET_TIME_Relative dur_delayed;
53 50
54 51
55static size_t 52static void
56get_size (unsigned int cnt_down) 53do_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
62static void 61static void
63sendtask (void *cls) 62sendtask (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
809struct GNUNET_TRANSPORT_TESTING_TestMessage 809struct 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