aboutsummaryrefslogtreecommitdiff
path: root/src/stream/test_stream_local.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/stream/test_stream_local.c')
-rw-r--r--src/stream/test_stream_local.c245
1 files changed, 118 insertions, 127 deletions
diff --git a/src/stream/test_stream_local.c b/src/stream/test_stream_local.c
index 32e3bf2e4..27271faff 100644
--- a/src/stream/test_stream_local.c
+++ b/src/stream/test_stream_local.c
@@ -25,7 +25,6 @@
25 */ 25 */
26 26
27#include <string.h> 27#include <string.h>
28#include <sys/socket.h> /* For SHUT_RD, SHUT_WR */
29 28
30#include "platform.h" 29#include "platform.h"
31#include "gnunet_util_lib.h" 30#include "gnunet_util_lib.h"
@@ -34,39 +33,52 @@
34 33
35#define VERBOSE 1 34#define VERBOSE 1
36 35
36/**
37 * Structure for holding peer's sockets and IO Handles
38 */
39struct PeerData
40{
41 /**
42 * Peer's stream socket
43 */
44 struct GNUNET_STREAM_Socket *socket;
45
46 /**
47 * Peer's io handle
48 */
49 struct GNUNET_STREAM_IOHandle *io_handle;
50
51 /**
52 * Bytes the peer has written
53 */
54 unsigned int bytes_wrote;
55
56 /**
57 * Byte the peer has read
58 */
59 unsigned int bytes_read;
60};
61
37static struct GNUNET_OS_Process *arm_pid; 62static struct GNUNET_OS_Process *arm_pid;
38static struct GNUNET_STREAM_Socket *peer1_socket; 63static struct PeerData peer1;
64static struct PeerData peer2;
39static struct GNUNET_STREAM_ListenSocket *peer2_listen_socket; 65static struct GNUNET_STREAM_ListenSocket *peer2_listen_socket;
40static struct GNUNET_STREAM_Socket *peer2_socket;
41 66
42static GNUNET_SCHEDULER_TaskIdentifier abort_task; 67static GNUNET_SCHEDULER_TaskIdentifier abort_task;
43static GNUNET_SCHEDULER_TaskIdentifier test_task; 68static GNUNET_SCHEDULER_TaskIdentifier test_task;
44static GNUNET_SCHEDULER_TaskIdentifier read_task; 69static GNUNET_SCHEDULER_TaskIdentifier read_task;
45 70
46static GNUNET_STREAM_IOHandle *peer1_IOHandle;
47static GNUNET_STREAM_IOHandle *peer2_IOHandle;
48
49static char *data = "ABCD"; 71static char *data = "ABCD";
50static unsigned int data_pointer;
51static unsigned int read_pointer;
52static int result; 72static int result;
53 73
54static int peer1_write_pass;
55static int peer2_read_pass;
56static int peer1_half_closed_write_pass;
57static int peer2_half_closed_read_pass;
58static int peer1_write_shutdown_pass;
59static int peer1_read_shutdown_pass;
60
61
62/** 74/**
63 * Shutdown nicely 75 * Shutdown nicely
64 */ 76 */
65static void 77static void
66do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 78do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
67{ 79{
68 GNUNET_STREAM_close (peer1_socket); 80 GNUNET_STREAM_close (peer1.socket);
69 GNUNET_STREAM_close (peer2_socket); 81 GNUNET_STREAM_close (peer2.socket);
70 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: shutdown\n"); 82 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: shutdown\n");
71 if (0 != abort_task) 83 if (0 != abort_task)
72 { 84 {
@@ -116,52 +128,37 @@ void write_completion (void *cls,
116 enum GNUNET_STREAM_Status status, 128 enum GNUNET_STREAM_Status status,
117 size_t size) 129 size_t size)
118{ 130{
131 struct PeerData *peer;
132
133 peer = (struct PeerData *) cls;
134 GNUNET_assert (GNUNET_STREAM_OK == status);
135 GNUNET_assert (size < strlen (data));
136 peer->bytes_wrote += size;
119 137
120 if (peer1_write_shutdown_pass) /* Called for peer2's write operation */ 138 if (peer->bytes_wrote < strlen(data)) /* Have more data to send */
121 { 139 {
122 /* peer1 has shutdown reading */ 140 peer->io_handle = GNUNET_STREAM_write (peer->socket,
123 GNUNET_assert (GNUNET_STREAM_SHUTDOWN == status); 141 (void *) data,
124 GNUNET_assert (0 == size); 142 strlen(data) - peer->bytes_wrote,
125 peer1_read_shutdown_pass = 1; 143 GNUNET_TIME_relative_multiply
126 144 (GNUNET_TIME_UNIT_SECONDS, 5),
127 GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 145 &write_completion,
146 cls);
147 GNUNET_assert (NULL != peer->io_handle);
128 } 148 }
129 GNUNET_assert (GNUNET_STREAM_OK == status); 149 else
130 if (data_pointer + size != strlen(data)) /* Have more data to send */
131 { 150 {
132 data_pointer += size; 151 if (&peer1 == peer) /* Peer1 has finished writing; should read now */
133 peer1_IOHandle = GNUNET_STREAM_write (peer1_socket, 152 {
134 (void *) data, 153 peer->io_handle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *)
135 strlen(data) - data_pointer, 154 peer->socket,
136 GNUNET_TIME_relative_multiply 155 GNUNET_TIME_relative_multiply
137 (GNUNET_TIME_UNIT_SECONDS, 5), 156 (GNUNET_TIME_UNIT_SECONDS, 5),
138 &write_completion, 157 &input_processor,
139 NULL); 158 cls);
140 GNUNET_assert (NULL != peer1_IOHandle); 159 GNUNET_assert (NULL!=peer->io_handle);
160 }
141 } 161 }
142 else{
143 peer1_write_pass = 1;
144 /* If we are here and peer2_read_pass == 1 => we have send the data twice */
145 if (peer2_read_pass) peer1_half_closed_write_pass = 1;
146
147 if (! peer1_half_closed_write_pass)
148 {
149 GNUNET_STREAM_shutdown (peer1_socket, SHUT_RD);
150 /* Half closed write */
151 data_pointer = 0;
152 peer1_IOHandle = GNUNET_STREAM_write (peer1_socket,
153 (void *) data,
154 strlen(data),
155 GNUNET_TIME_relative_multiply
156 (GNUNET_TIME_UNIT_SECONDS, 5),
157 &write_completion,
158 NULL);
159 }
160 else
161 {
162 GNUNET_STREAM_shutdown (peer1_socket, SHUT_WR);
163 }
164 }
165} 162}
166 163
167 164
@@ -173,20 +170,22 @@ void write_completion (void *cls,
173 */ 170 */
174static void 171static void
175stream_open_cb (void *cls, 172stream_open_cb (void *cls,
176 struct GNUNET_STREAM_Socket 173 struct GNUNET_STREAM_Socket *socket)
177 *socket)
178{ 174{
179 data_pointer = 0; 175 struct PeerData *peer;
180 GNUNET_assert (socket == peer1_socket); 176
181 peer1_IOHandle = GNUNET_STREAM_write (socket, /* socket */ 177 peer = (struct PeerData *) cls;
182 (void *) data, /* data */ 178 peer->bytes_wrote = 0;
183 strlen(data), 179 GNUNET_assert (socket == peer1.socket);
184 GNUNET_TIME_relative_multiply 180 GNUNET_assert (socket == peer->socket);
185 (GNUNET_TIME_UNIT_SECONDS, 5), 181 peer->io_handle = GNUNET_STREAM_write (peer->socket, /* socket */
186 &write_completion, 182 (void *) data, /* data */
187 NULL); 183 strlen(data),
188 GNUNET_assert (NULL != peer1_IOHandle); 184 GNUNET_TIME_relative_multiply
189 185 (GNUNET_TIME_UNIT_SECONDS, 5),
186 &write_completion,
187 cls);
188 GNUNET_assert (NULL != peer->io_handle);
190} 189}
191 190
192 191
@@ -206,76 +205,67 @@ input_processor (void *cls,
206 const void *input_data, 205 const void *input_data,
207 size_t size) 206 size_t size)
208{ 207{
208 struct PeerData *peer;
209 209
210 if (peer2_half_closed_read_pass) 210 peer = (struct PeerData *) cls;
211 {
212 GNUNET_assert (GNUNET_STREAM_SHUTDOWN == status);
213 GNUNET_assert (0 == size);
214 peer1_write_shutdown_pass = 1;
215 /* Now this should result in STREAM_SHUTDOWN */
216 peer2_IOHandle = GNUNET_STREAM_write (peer2_socket,
217 (void *) data,
218 strlen(data),
219 GNUNET_TIME_relative_multiply
220 (GNUNET_TIME_UNIT_SECONDS, 5),
221 &write_completion,
222 (void *) peer2_socket);
223
224 return 0;
225 }
226 211
227 GNUNET_assert (GNUNET_STERAM_OK == status); 212 GNUNET_assert (GNUNET_STERAM_OK == status);
228 GNUNET_assert (size < strlen (data)); 213 GNUNET_assert (size < strlen (data));
229 GNUNET_assert (strncmp ((const char *) data, 214 GNUNET_assert (strncmp ((const char *) data + peer->bytes_read,
230 (const char *) input_data, 215 (const char *) input_data,
231 size)); 216 size));
232 read_pointer += size; 217 peer->bytes_read += size;
233 218
234 if (read_pointer < strlen (data)) 219 if (peer->bytes_read < strlen (data))
235 { 220 {
236 peer2_IOHandle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *) cls, 221 peer->io_handle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *)
237 GNUNET_TIME_relative_multiply 222 peer->socket,
238 (GNUNET_TIME_UNIT_SECONDS, 5), 223 GNUNET_TIME_relative_multiply
239 &input_processor, 224 (GNUNET_TIME_UNIT_SECONDS, 5),
240 NULL); 225 &input_processor,
241 GNUNET_assert (NULL != peer2_IOHandle); 226 cls);
227 GNUNET_assert (NULL != peer->io_handle);
242 } 228 }
243 else { 229 else
244 /* If we are here and peer2_read_pass => we have finished reading twice */ 230 {
245 if (peer1_write_pass && peer2_read_pass) peer2_half_closed_read_pass = 1; 231 if (&peer2 == peer) /* Peer2 has completed reading; should write */
246 if (peer1_write_pass) peer2_read_pass = 1; 232 {
247 233 peer->bytes_wrote = 0;
248 /* Half closed read */ 234 peer->io_handle = GNUNET_STREAM_write ((struct GNUNET_STREAM_Socket *)
249 read_pointer = 0; 235 peer->socket,
250 peer2_IOHandle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *) cls, 236 (void *) data,
251 GNUNET_TIME_relative_multiply 237 strlen(data),
252 (GNUNET_TIME_UNIT_SECONDS, 5), 238 GNUNET_TIME_relative_multiply
253 &input_processor, 239 (GNUNET_TIME_UNIT_SECONDS, 5),
254 NULL); 240 &write_completion,
255 241 cls);
256 242 }
257 } 243 else /* Peer1 has completed reading. End of tests */
258 244 {
245 GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
246 }
247 }
259 return size; 248 return size;
260} 249}
261 250
262 251
263/** 252/**
264 * Scheduler call back; to be executed when a new stream is connected 253 * Scheduler call back; to be executed when a new stream is connected
254 * Called from listen connect for peer2
265 */ 255 */
266static void 256static void
267stream_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 257stream_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
268{ 258{
269 read_task = GNUNET_SCHEDULER_NO_TASK; 259 read_task = GNUNET_SCHEDULER_NO_TASK;
270 GNUNET_assert (NULL != cls); 260 GNUNET_assert (NULL != cls);
271 read_pointer = 0; 261 peer2.bytes_read = 0;
272 GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */ 262 GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */
273 peer2_IOHandle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *) cls, 263 peer2.io_handle = GNUNET_STREAM_read ((struct GNUNET_STREAM_Socket *) cls,
274 GNUNET_TIME_relative_multiply 264 GNUNET_TIME_relative_multiply
275 (GNUNET_TIME_UNIT_SECONDS, 5), 265 (GNUNET_TIME_UNIT_SECONDS, 5),
276 &input_processor, 266 &input_processor,
277 NULL); 267 (void *) &peer2);
278 GNUNET_assert (NULL != peer2_IOHandle); 268 GNUNET_assert (NULL != peer2.io_handle);
279} 269}
280 270
281 271
@@ -296,9 +286,9 @@ stream_listen_cb (void *cls,
296{ 286{
297 GNUNET_assert (NULL != socket); 287 GNUNET_assert (NULL != socket);
298 GNUNET_assert (NULL == initiator); /* Local peer=NULL? */ 288 GNUNET_assert (NULL == initiator); /* Local peer=NULL? */
299 GNUNET_assert (socket != peer1_socket); 289 GNUNET_assert (socket != peer1.socket);
300 290
301 peer2_socket = socket; 291 peer2.socket = socket;
302 read_task = GNUNET_SCHEDULER_add_now (&stream_read, (void *) socket); 292 read_task = GNUNET_SCHEDULER_add_now (&stream_read, (void *) socket);
303 return GNUNET_OK; 293 return GNUNET_OK;
304} 294}
@@ -313,10 +303,11 @@ test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
313 test_task = GNUNET_SCHEDULER_NO_TASK; 303 test_task = GNUNET_SCHEDULER_NO_TASK;
314 304
315 /* Connect to stream library */ 305 /* Connect to stream library */
316 peer1_socket = GNUNET_STREAM_open (NULL, /* Null for local peer? */ 306 peer1.socket = GNUNET_STREAM_open (NULL, /* Null for local peer? */
317 10, /* App port */ 307 10, /* App port */
318 open_cb); 308 &stream_open_cb,
319 GNUNET_assert (NULL != peer1_socket); 309 (void *) &peer1);
310 GNUNET_assert (NULL != peer1.socket);
320 peer2_listen_socket = GNUNET_STREAM_listen (10 /* App port */ 311 peer2_listen_socket = GNUNET_STREAM_listen (10 /* App port */
321 &stream_listen_cb, 312 &stream_listen_cb,
322 NULL); 313 NULL);
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-14 00:47:26 +0000