?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch '976-disable-assert-checks' into 'master'
[glib.git] / gio / tests / socket.c
blob9b3adb4e4ea72b33e2408917fc605bd780300d90
1 /* GLib testing framework examples and tests
2 *
3 * Copyright (C) 2008-2011 Red Hat, Inc.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include <gio/gio.h>
20
21 #ifdef G_OS_UNIX
22 #include <errno.h>
23 #include <sys/wait.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include <gio/gnetworking.h>
27 #include <gio/gunixconnection.h>
28 #endif
29
30 #include "gnetworkingprivate.h"
31
32 static gboolean ipv6_supported;
33
34 typedef struct {
35 GSocket *server;
36 GSocket *client;
37 GSocketFamily family;
38 GThread *thread;
39 GMainLoop *loop;
40 GCancellable *cancellable; /* to shut down dgram echo server thread */
41 } IPTestData;
42
43 static gpointer
44 echo_server_dgram_thread (gpointer user_data)
45 {
46 IPTestData *data = user_data;
47 GSocketAddress *sa;
48 GCancellable *cancellable = data->cancellable;
49 GSocket *sock;
50 GError *error = NULL;
51 gssize nread, nwrote;
52 gchar buf[128];
53
54 sock = data->server;
55
56 while (TRUE)
57 {
58 nread = g_socket_receive_from (sock, &sa, buf, sizeof (buf), cancellable, &error);
59 if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
60 break;
61 g_assert_no_error (error);
62 g_assert_cmpint (nread, >=, 0);
63
64 nwrote = g_socket_send_to (sock, sa, buf, nread, cancellable, &error);
65 if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
66 break;
67 g_assert_no_error (error);
68 g_assert_cmpint (nwrote, ==, nread);
69
70 g_object_unref (sa);
71 }
72
73 g_clear_error (&error);
74
75 return NULL;
76 }
77
78 static gpointer
79 echo_server_thread (gpointer user_data)
80 {
81 IPTestData *data = user_data;
82 GSocket *sock;
83 GError *error = NULL;
84 gssize nread, nwrote;
85 gchar buf[128];
86
87 sock = g_socket_accept (data->server, NULL, &error);
88 g_assert_no_error (error);
89
90 while (TRUE)
91 {
92 nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
93 g_assert_no_error (error);
94 g_assert_cmpint (nread, >=, 0);
95
96 if (nread == 0)
97 break;
98
99 nwrote = g_socket_send (sock, buf, nread, NULL, &error);
100 g_assert_no_error (error);
101 g_assert_cmpint (nwrote, ==, nread);
102 }
103
104 g_socket_close (sock, &error);
105 g_assert_no_error (error);
106 g_object_unref (sock);
107 return NULL;
108 }
109
110 static IPTestData *
111 create_server_full (GSocketFamily family,
112 GSocketType socket_type,
113 GThreadFunc server_thread,
114 gboolean v4mapped,
115 GError **error)
116 {
117 IPTestData *data;
118 GSocket *server;
119 GSocketAddress *addr;
120 GInetAddress *iaddr;
121
122 data = g_slice_new (IPTestData);
123 data->family = family;
124
125 data->server = server = g_socket_new (family,
126 socket_type,
127 G_SOCKET_PROTOCOL_DEFAULT,
128 error);
129 if (server == NULL)
130 goto error;
131
132 g_assert_cmpint (g_socket_get_family (server), ==, family);
133 g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);
134 g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
135
136 g_socket_set_blocking (server, TRUE);
137
138 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
139 if (v4mapped)
140 {
141 g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);
142 if (!g_socket_speaks_ipv4 (data->server))
143 goto error;
144 }
145 #endif
146
147 if (v4mapped)
148 iaddr = g_inet_address_new_any (family);
149 else
150 iaddr = g_inet_address_new_loopback (family);
151 addr = g_inet_socket_address_new (iaddr, 0);
152 g_object_unref (iaddr);
153
154 g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
155 if (!g_socket_bind (server, addr, TRUE, error))
156 {
157 g_object_unref (addr);
158 goto error;
159 }
160 g_object_unref (addr);
161
162 addr = g_socket_get_local_address (server, error);
163 if (addr == NULL)
164 goto error;
165 g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
166 g_object_unref (addr);
167
168 if (socket_type == G_SOCKET_TYPE_STREAM)
169 {
170 if (!g_socket_listen (server, error))
171 goto error;
172 }
173 else
174 {
175 data->cancellable = g_cancellable_new ();
176 }
177
178 data->thread = g_thread_new ("server", server_thread, data);
179
180 return data;
181
182 error:
183 g_clear_object (&data->server);
184 g_slice_free (IPTestData, data);
185
186 return NULL;
187 }
188
189 static IPTestData *
190 create_server (GSocketFamily family,
191 GThreadFunc server_thread,
192 gboolean v4mapped,
193 GError **error)
194 {
195 return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped, error);
196 }
197
198 static const gchar *testbuf = "0123456789abcdef";
199
200 static gboolean
201 test_ip_async_read_ready (GSocket *client,
202 GIOCondition cond,
203 gpointer user_data)
204 {
205 IPTestData *data = user_data;
206 GError *error = NULL;
207 gssize len;
208 gchar buf[128];
209
210 g_assert_cmpint (cond, ==, G_IO_IN);
211
212 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
213 g_assert_no_error (error);
214 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
215
216 g_assert_cmpstr (testbuf, ==, buf);
217
218 g_main_loop_quit (data->loop);
219
220 return FALSE;
221 }
222
223 static gboolean
224 test_ip_async_write_ready (GSocket *client,
225 GIOCondition cond,
226 gpointer user_data)
227 {
228 IPTestData *data = user_data;
229 GError *error = NULL;
230 GSource *source;
231 gssize len;
232
233 g_assert_cmpint (cond, ==, G_IO_OUT);
234
235 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
236 g_assert_no_error (error);
237 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
238
239 source = g_socket_create_source (client, G_IO_IN, NULL);
240 g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
241 data, NULL);
242 g_source_attach (source, NULL);
243 g_source_unref (source);
244
245 return FALSE;
246 }
247
248 static gboolean
249 test_ip_async_timed_out (GSocket *client,
250 GIOCondition cond,
251 gpointer user_data)
252 {
253 IPTestData *data = user_data;
254 GError *error = NULL;
255 GSource *source;
256 gssize len;
257 gchar buf[128];
258
259 if (data->family == G_SOCKET_FAMILY_IPV4)
260 {
261 g_assert_cmpint (cond, ==, G_IO_IN);
262 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
263 g_assert_cmpint (len, ==, -1);
264 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
265 g_clear_error (&error);
266 }
267
268 source = g_socket_create_source (client, G_IO_OUT, NULL);
269 g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
270 data, NULL);
271 g_source_attach (source, NULL);
272 g_source_unref (source);
273
274 return FALSE;
275 }
276
277 static gboolean
278 test_ip_async_connected (GSocket *client,
279 GIOCondition cond,
280 gpointer user_data)
281 {
282 IPTestData *data = user_data;
283 GError *error = NULL;
284 GSource *source;
285 gssize len;
286 gchar buf[128];
287
288 g_socket_check_connect_result (client, &error);
289 g_assert_no_error (error);
290 /* We do this after the check_connect_result, since that will give a
291 * more useful assertion in case of error.
292 */
293 g_assert_cmpint (cond, ==, G_IO_OUT);
294
295 g_assert (g_socket_is_connected (client));
296
297 /* This adds 1 second to "make check", so let's just only do it once. */
298 if (data->family == G_SOCKET_FAMILY_IPV4)
299 {
300 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
301 g_assert_cmpint (len, ==, -1);
302 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
303 g_clear_error (&error);
304
305 source = g_socket_create_source (client, G_IO_IN, NULL);
306 g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
307 data, NULL);
308 g_source_attach (source, NULL);
309 g_source_unref (source);
310 }
311 else
312 test_ip_async_timed_out (client, 0, data);
313
314 return FALSE;
315 }
316
317 static gboolean
318 idle_test_ip_async_connected (gpointer user_data)
319 {
320 IPTestData *data = user_data;
321
322 return test_ip_async_connected (data->client, G_IO_OUT, data);
323 }
324
325 static void
326 test_ip_async (GSocketFamily family)
327 {
328 IPTestData *data;
329 GError *error = NULL;
330 GSocket *client;
331 GSocketAddress *addr;
332 GSource *source;
333 gssize len;
334 gchar buf[128];
335
336 data = create_server (family, echo_server_thread, FALSE, &error);
337 if (error != NULL)
338 {
339 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
340 g_test_skip (message);
341 g_free (message);
342 g_clear_error (&error);
343 return;
344 }
345
346 addr = g_socket_get_local_address (data->server, &error);
347 g_assert_no_error (error);
348
349 client = g_socket_new (family,
350 G_SOCKET_TYPE_STREAM,
351 G_SOCKET_PROTOCOL_DEFAULT,
352 &error);
353 g_assert_no_error (error);
354 data->client = client;
355
356 g_assert_cmpint (g_socket_get_family (client), ==, family);
357 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
358 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
359
360 g_socket_set_blocking (client, FALSE);
361 g_socket_set_timeout (client, 1);
362
363 if (g_socket_connect (client, addr, NULL, &error))
364 {
365 g_assert_no_error (error);
366 g_idle_add (idle_test_ip_async_connected, data);
367 }
368 else
369 {
370 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
371 g_clear_error (&error);
372 source = g_socket_create_source (client, G_IO_OUT, NULL);
373 g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
374 data, NULL);
375 g_source_attach (source, NULL);
376 g_source_unref (source);
377 }
378 g_object_unref (addr);
379
380 data->loop = g_main_loop_new (NULL, TRUE);
381 g_main_loop_run (data->loop);
382 g_main_loop_unref (data->loop);
383
384 g_socket_shutdown (client, FALSE, TRUE, &error);
385 g_assert_no_error (error);
386
387 g_thread_join (data->thread);
388
389 if (family == G_SOCKET_FAMILY_IPV4)
390 {
391 /* Test that reading on a remote-closed socket gets back 0 bytes. */
392 len = g_socket_receive_with_blocking (client, buf, sizeof (buf),
393 TRUE, NULL, &error);
394 g_assert_no_error (error);
395 g_assert_cmpint (len, ==, 0);
396 }
397 else
398 {
399 /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
400 len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,
401 TRUE, NULL, &error);
402 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
403 g_assert_cmpint (len, ==, -1);
404 g_clear_error (&error);
405 }
406
407 g_socket_close (client, &error);
408 g_assert_no_error (error);
409 g_socket_close (data->server, &error);
410 g_assert_no_error (error);
411
412 g_object_unref (data->server);
413 g_object_unref (client);
414
415 g_slice_free (IPTestData, data);
416 }
417
418 static void
419 test_ipv4_async (void)
420 {
421 test_ip_async (G_SOCKET_FAMILY_IPV4);
422 }
423
424 static void
425 test_ipv6_async (void)
426 {
427 if (!ipv6_supported)
428 {
429 g_test_skip ("No support for IPv6");
430 return;
431 }
432
433 test_ip_async (G_SOCKET_FAMILY_IPV6);
434 }
435
436 static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";
437
438 static void
439 test_ip_sync (GSocketFamily family)
440 {
441 IPTestData *data;
442 GError *error = NULL;
443 GSocket *client;
444 GSocketAddress *addr;
445 gssize len;
446 gchar buf[128];
447
448 data = create_server (family, echo_server_thread, FALSE, &error);
449 if (error != NULL)
450 {
451 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
452 g_test_skip (message);
453 g_free (message);
454 g_clear_error (&error);
455 return;
456 }
457
458 addr = g_socket_get_local_address (data->server, &error);
459 g_assert_no_error (error);
460
461 client = g_socket_new (family,
462 G_SOCKET_TYPE_STREAM,
463 G_SOCKET_PROTOCOL_DEFAULT,
464 &error);
465 g_assert_no_error (error);
466
467 g_assert_cmpint (g_socket_get_family (client), ==, family);
468 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
469 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
470
471 g_socket_set_blocking (client, TRUE);
472 g_socket_set_timeout (client, 1);
473
474 g_socket_connect (client, addr, NULL, &error);
475 g_assert_no_error (error);
476 g_assert (g_socket_is_connected (client));
477 g_object_unref (addr);
478
479 /* This adds 1 second to "make check", so let's just only do it once. */
480 if (family == G_SOCKET_FAMILY_IPV4)
481 {
482 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
483 g_assert_cmpint (len, ==, -1);
484 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
485 g_clear_error (&error);
486 }
487
488 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
489 g_assert_no_error (error);
490 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
491
492 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
493 g_assert_no_error (error);
494 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
495
496 g_assert_cmpstr (testbuf, ==, buf);
497
498 {
499 GOutputVector v[7] = { { NULL, }, };
500
501 v[0].buffer = testbuf2 + 0;
502 v[0].size = 3;
503 v[1].buffer = testbuf2 + 3;
504 v[1].size = 5;
505 v[2].buffer = testbuf2 + 3 + 5;
506 v[2].size = 0;
507 v[3].buffer = testbuf2 + 3 + 5;
508 v[3].size = 6;
509 v[4].buffer = testbuf2 + 3 + 5 + 6;
510 v[4].size = 2;
511 v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
512 v[5].size = 1;
513 v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
514 v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
515
516 len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
517 g_assert_no_error (error);
518 g_assert_cmpint (len, ==, strlen (testbuf2));
519
520 memset (buf, 0, sizeof (buf));
521 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
522 g_assert_no_error (error);
523 g_assert_cmpint (len, ==, strlen (testbuf2));
524 g_assert_cmpstr (testbuf2, ==, buf);
525 }
526
527 g_socket_shutdown (client, FALSE, TRUE, &error);
528 g_assert_no_error (error);
529
530 g_thread_join (data->thread);
531
532 if (family == G_SOCKET_FAMILY_IPV4)
533 {
534 /* Test that reading on a remote-closed socket gets back 0 bytes. */
535 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
536 g_assert_no_error (error);
537 g_assert_cmpint (len, ==, 0);
538 }
539 else
540 {
541 /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
542 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
543 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
544 g_assert_cmpint (len, ==, -1);
545 g_clear_error (&error);
546 }
547
548 g_socket_close (client, &error);
549 g_assert_no_error (error);
550 g_socket_close (data->server, &error);
551 g_assert_no_error (error);
552
553 g_object_unref (data->server);
554 g_object_unref (client);
555
556 g_slice_free (IPTestData, data);
557 }
558
559 static void
560 test_ipv4_sync (void)
561 {
562 test_ip_sync (G_SOCKET_FAMILY_IPV4);
563 }
564
565 static void
566 test_ipv6_sync (void)
567 {
568 if (!ipv6_supported)
569 {
570 g_test_skip ("No support for IPv6");
571 return;
572 }
573
574 test_ip_sync (G_SOCKET_FAMILY_IPV6);
575 }
576
577 static void
578 test_ip_sync_dgram (GSocketFamily family)
579 {
580 IPTestData *data;
581 GError *error = NULL;
582 GSocket *client;
583 GSocketAddress *dest_addr;
584 gssize len;
585 gchar buf[128];
586
587 data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
588 echo_server_dgram_thread, FALSE, &error);
589 if (error != NULL)
590 {
591 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
592 g_test_skip (message);
593 g_free (message);
594 g_clear_error (&error);
595 return;
596 }
597
598 dest_addr = g_socket_get_local_address (data->server, &error);
599
600 client = g_socket_new (family,
601 G_SOCKET_TYPE_DATAGRAM,
602 G_SOCKET_PROTOCOL_DEFAULT,
603 &error);
604 g_assert_no_error (error);
605
606 g_assert_cmpint (g_socket_get_family (client), ==, family);
607 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
608 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
609
610 g_socket_set_blocking (client, TRUE);
611 g_socket_set_timeout (client, 1);
612
613 len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
614 g_assert_no_error (error);
615 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
616
617 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
618 g_assert_no_error (error);
619 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
620
621 g_assert_cmpstr (testbuf, ==, buf);
622
623 {
624 GOutputMessage m[3] = { { NULL, }, };
625 GInputMessage im[3] = { { NULL, }, };
626 GOutputVector v[7] = { { NULL, }, };
627 GInputVector iv[7] = { { NULL, }, };
628
629 v[0].buffer = testbuf2 + 0;
630 v[0].size = 3;
631 v[1].buffer = testbuf2 + 3;
632 v[1].size = 5;
633 v[2].buffer = testbuf2 + 3 + 5;
634 v[2].size = 0;
635 v[3].buffer = testbuf2 + 3 + 5;
636 v[3].size = 6;
637 v[4].buffer = testbuf2 + 3 + 5 + 6;
638 v[4].size = 2;
639 v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
640 v[5].size = 1;
641 v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
642 v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
643
644 iv[0].buffer = buf + 0;
645 iv[0].size = 3;
646 iv[1].buffer = buf + 3;
647 iv[1].size = 5;
648 iv[2].buffer = buf + 3 + 5;
649 iv[2].size = 0;
650 iv[3].buffer = buf + 3 + 5;
651 iv[3].size = 6;
652 iv[4].buffer = buf + 3 + 5 + 6;
653 iv[4].size = 2;
654 iv[5].buffer = buf + 3 + 5 + 6 + 2;
655 iv[5].size = 1;
656 iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;
657 iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);
658
659 len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
660 g_assert_no_error (error);
661 g_assert_cmpint (len, ==, strlen (testbuf2));
662
663 memset (buf, 0, sizeof (buf));
664 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
665 g_assert_no_error (error);
666 g_assert_cmpint (len, ==, strlen (testbuf2));
667 g_assert_cmpstr (testbuf2, ==, buf);
668
669 m[0].vectors = &v[0];
670 m[0].num_vectors = 1;
671 m[0].address = dest_addr;
672 m[1].vectors = &v[0];
673 m[1].num_vectors = 6;
674 m[1].address = dest_addr;
675 m[2].vectors = &v[6];
676 m[2].num_vectors = 1;
677 m[2].address = dest_addr;
678
679 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
680 g_assert_no_error (error);
681 g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
682 g_assert_cmpint (m[0].bytes_sent, ==, 3);
683 g_assert_cmpint (m[1].bytes_sent, ==, 17);
684 g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
685
686 memset (buf, 0, sizeof (buf));
687 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
688 g_assert_no_error (error);
689 g_assert_cmpint (len, ==, 3);
690
691 memset (buf, 0, sizeof (buf));
692 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
693 g_assert_no_error (error);
694 /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
695 g_assert_cmpint (len, ==, 17);
696 g_assert (memcmp (testbuf2, buf, 17) == 0);
697
698 memset (buf, 0, sizeof (buf));
699 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
700 g_assert_no_error (error);
701 g_assert_cmpint (len, ==, v[6].size);
702 g_assert_cmpstr (buf, ==, v[6].buffer);
703
704 /* reset since we're re-using the message structs */
705 m[0].bytes_sent = 0;
706 m[1].bytes_sent = 0;
707 m[2].bytes_sent = 0;
708
709 /* now try receiving multiple messages */
710 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
711 g_assert_no_error (error);
712 g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
713 g_assert_cmpint (m[0].bytes_sent, ==, 3);
714 g_assert_cmpint (m[1].bytes_sent, ==, 17);
715 g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
716
717 im[0].vectors = &iv[0];
718 im[0].num_vectors = 1;
719 im[1].vectors = &iv[0];
720 im[1].num_vectors = 6;
721 im[2].vectors = &iv[6];
722 im[2].num_vectors = 1;
723
724 memset (buf, 0, sizeof (buf));
725 len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,
726 NULL, &error);
727 g_assert_no_error (error);
728 g_assert_cmpint (len, ==, G_N_ELEMENTS (im));
729
730 g_assert_cmpuint (im[0].bytes_received, ==, 3);
731 /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
732 g_assert_cmpuint (im[1].bytes_received, ==, 17);
733 g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);
734
735 /* reset since we're re-using the message structs */
736 m[0].bytes_sent = 0;
737 m[1].bytes_sent = 0;
738 m[2].bytes_sent = 0;
739
740 /* now try to generate an early return by omitting the destination address on [1] */
741 m[1].address = NULL;
742 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
743 g_assert_no_error (error);
744 g_assert_cmpint (len, ==, 1);
745
746 g_assert_cmpint (m[0].bytes_sent, ==, 3);
747 g_assert_cmpint (m[1].bytes_sent, ==, 0);
748 g_assert_cmpint (m[2].bytes_sent, ==, 0);
749
750 /* reset since we're re-using the message structs */
751 m[0].bytes_sent = 0;
752 m[1].bytes_sent = 0;
753 m[2].bytes_sent = 0;
754
755 /* now try to generate an error by omitting all destination addresses */
756 m[0].address = NULL;
757 m[1].address = NULL;
758 m[2].address = NULL;
759 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
760 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
761 g_clear_error (&error);
762 g_assert_cmpint (len, ==, -1);
763
764 g_assert_cmpint (m[0].bytes_sent, ==, 0);
765 g_assert_cmpint (m[1].bytes_sent, ==, 0);
766 g_assert_cmpint (m[2].bytes_sent, ==, 0);
767
768 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
769 g_assert_cmpint (len, ==, 3);
770 }
771
772 g_cancellable_cancel (data->cancellable);
773
774 g_thread_join (data->thread);
775
776 g_socket_close (client, &error);
777 g_assert_no_error (error);
778 g_socket_close (data->server, &error);
779 g_assert_no_error (error);
780
781 g_object_unref (data->server);
782 g_object_unref (data->cancellable);
783 g_object_unref (client);
784 g_object_unref (dest_addr);
785
786 g_slice_free (IPTestData, data);
787 }
788
789 static void
790 test_ipv4_sync_dgram (void)
791 {
792 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
793 }
794
795 static void
796 test_ipv6_sync_dgram (void)
797 {
798 if (!ipv6_supported)
799 {
800 g_test_skip ("No support for IPv6");
801 return;
802 }
803
804 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
805 }
806
807 static gpointer
808 cancellable_thread_cb (gpointer data)
809 {
810 GCancellable *cancellable = data;
811
812 g_usleep (0.1 * G_USEC_PER_SEC);
813 g_cancellable_cancel (cancellable);
814 g_object_unref (cancellable);
815
816 return NULL;
817 }
818
819 static void
820 test_ip_sync_dgram_timeouts (GSocketFamily family)
821 {
822 GError *error = NULL;
823 GSocket *client = NULL;
824 GCancellable *cancellable = NULL;
825 GThread *cancellable_thread = NULL;
826 gssize len;
827
828 client = g_socket_new (family,
829 G_SOCKET_TYPE_DATAGRAM,
830 G_SOCKET_PROTOCOL_DEFAULT,
831 &error);
832 g_assert_no_error (error);
833
834 g_assert_cmpint (g_socket_get_family (client), ==, family);
835 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
836 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
837
838 /* No overall timeout: test the per-operation timeouts instead. */
839 g_socket_set_timeout (client, 0);
840
841 cancellable = g_cancellable_new ();
842
843 /* Check for timeouts when no server is running. */
844 {
845 gint64 start_time;
846 GInputMessage im = { NULL, };
847 GInputVector iv = { NULL, };
848 guint8 buf[128];
849
850 iv.buffer = buf;
851 iv.size = sizeof (buf);
852
853 im.vectors = &iv;
854 im.num_vectors = 1;
855
856 memset (buf, 0, sizeof (buf));
857
858 /* Try a non-blocking read. */
859 g_socket_set_blocking (client, FALSE);
860 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
861 NULL, &error);
862 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
863 g_assert_cmpint (len, ==, -1);
864 g_clear_error (&error);
865
866 /* Try a timeout read. Can’t really validate the time taken more than
867 * checking it’s positive. */
868 g_socket_set_timeout (client, 1);
869 g_socket_set_blocking (client, TRUE);
870 start_time = g_get_monotonic_time ();
871 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
872 NULL, &error);
873 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
874 g_assert_cmpint (len, ==, -1);
875 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
876 g_clear_error (&error);
877
878 /* Try a blocking read, cancelled from another thread. */
879 g_socket_set_timeout (client, 0);
880 cancellable_thread = g_thread_new ("cancellable",
881 cancellable_thread_cb,
882 g_object_ref (cancellable));
883
884 start_time = g_get_monotonic_time ();
885 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
886 cancellable, &error);
887 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
888 g_assert_cmpint (len, ==, -1);
889 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
890 g_clear_error (&error);
891
892 g_thread_join (cancellable_thread);
893 }
894
895 g_socket_close (client, &error);
896 g_assert_no_error (error);
897
898 g_object_unref (client);
899 g_object_unref (cancellable);
900 }
901
902 static void
903 test_ipv4_sync_dgram_timeouts (void)
904 {
905 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
906 }
907
908 static void
909 test_ipv6_sync_dgram_timeouts (void)
910 {
911 if (!ipv6_supported)
912 {
913 g_test_skip ("No support for IPv6");
914 return;
915 }
916
917 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
918 }
919
920 static gpointer
921 graceful_server_thread (gpointer user_data)
922 {
923 IPTestData *data = user_data;
924 GSocket *sock;
925 GError *error = NULL;
926 gssize len;
927
928 sock = g_socket_accept (data->server, NULL, &error);
929 g_assert_no_error (error);
930
931 len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
932 g_assert_no_error (error);
933 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
934
935 return sock;
936 }
937
938 static void
939 test_close_graceful (void)
940 {
941 GSocketFamily family = G_SOCKET_FAMILY_IPV4;
942 IPTestData *data;
943 GError *error = NULL;
944 GSocket *client, *server;
945 GSocketAddress *addr;
946 gssize len;
947 gchar buf[128];
948
949 data = create_server (family, graceful_server_thread, FALSE, &error);
950 if (error != NULL)
951 {
952 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
953 g_test_skip (message);
954 g_free (message);
955 g_clear_error (&error);
956 return;
957 }
958
959 addr = g_socket_get_local_address (data->server, &error);
960 g_assert_no_error (error);
961
962 client = g_socket_new (family,
963 G_SOCKET_TYPE_STREAM,
964 G_SOCKET_PROTOCOL_DEFAULT,
965 &error);
966 g_assert_no_error (error);
967
968 g_assert_cmpint (g_socket_get_family (client), ==, family);
969 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
970 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
971
972 g_socket_set_blocking (client, TRUE);
973 g_socket_set_timeout (client, 1);
974
975 g_socket_connect (client, addr, NULL, &error);
976 g_assert_no_error (error);
977 g_assert (g_socket_is_connected (client));
978 g_object_unref (addr);
979
980 server = g_thread_join (data->thread);
981
982 /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
983 g_socket_shutdown (server, FALSE, TRUE, &error);
984 g_assert_no_error (error);
985
986 /* we must timeout */
987 g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
988 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
989 g_clear_error (&error);
990
991 /* check that the remaining data is received */
992 len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
993 g_assert_no_error (error);
994 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
995
996 /* and only then the connection is closed */
997 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
998 g_assert_no_error (error);
999 g_assert_cmpint (len, ==, 0);
1000
1001 g_socket_close (server, &error);
1002 g_assert_no_error (error);
1003
1004 g_socket_close (client, &error);
1005 g_assert_no_error (error);
1006
1007 g_object_unref (server);
1008 g_object_unref (data->server);
1009 g_object_unref (client);
1010
1011 g_slice_free (IPTestData, data);
1012 }
1013
1014 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1015 static gpointer
1016 v4mapped_server_thread (gpointer user_data)
1017 {
1018 IPTestData *data = user_data;
1019 GSocket *sock;
1020 GError *error = NULL;
1021 GSocketAddress *addr;
1022
1023 sock = g_socket_accept (data->server, NULL, &error);
1024 g_assert_no_error (error);
1025
1026 g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
1027
1028 addr = g_socket_get_local_address (sock, &error);
1029 g_assert_no_error (error);
1030 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1031 g_object_unref (addr);
1032
1033 addr = g_socket_get_remote_address (sock, &error);
1034 g_assert_no_error (error);
1035 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1036 g_object_unref (addr);
1037
1038 g_socket_close (sock, &error);
1039 g_assert_no_error (error);
1040 g_object_unref (sock);
1041 return NULL;
1042 }
1043
1044 static void
1045 test_ipv6_v4mapped (void)
1046 {
1047 IPTestData *data;
1048 GError *error = NULL;
1049 GSocket *client;
1050 GSocketAddress *addr, *v4addr;
1051 GInetAddress *iaddr;
1052
1053 if (!ipv6_supported)
1054 {
1055 g_test_skip ("No support for IPv6");
1056 return;
1057 }
1058
1059 data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE, &error);
1060 if (error != NULL)
1061 {
1062 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1063 g_test_skip (message);
1064 g_free (message);
1065 g_clear_error (&error);
1066 return;
1067 }
1068
1069 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1070 G_SOCKET_TYPE_STREAM,
1071 G_SOCKET_PROTOCOL_DEFAULT,
1072 &error);
1073 g_assert_no_error (error);
1074
1075 g_socket_set_blocking (client, TRUE);
1076 g_socket_set_timeout (client, 1);
1077
1078 addr = g_socket_get_local_address (data->server, &error);
1079 g_assert_no_error (error);
1080 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1081 v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1082 g_object_unref (iaddr);
1083 g_object_unref (addr);
1084
1085 g_socket_connect (client, v4addr, NULL, &error);
1086 g_assert_no_error (error);
1087 g_assert (g_socket_is_connected (client));
1088
1089 g_thread_join (data->thread);
1090
1091 g_socket_close (client, &error);
1092 g_assert_no_error (error);
1093 g_socket_close (data->server, &error);
1094 g_assert_no_error (error);
1095
1096 g_object_unref (data->server);
1097 g_object_unref (client);
1098 g_object_unref (v4addr);
1099
1100 g_slice_free (IPTestData, data);
1101 }
1102 #endif
1103
1104 static void
1105 test_timed_wait (void)
1106 {
1107 IPTestData *data;
1108 GError *error = NULL;
1109 GSocket *client;
1110 GSocketAddress *addr;
1111 gint64 start_time;
1112 gint poll_duration;
1113
1114 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1115 if (error != NULL)
1116 {
1117 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1118 g_test_skip (message);
1119 g_free (message);
1120 g_clear_error (&error);
1121 return;
1122 }
1123
1124 addr = g_socket_get_local_address (data->server, &error);
1125 g_assert_no_error (error);
1126
1127 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1128 G_SOCKET_TYPE_STREAM,
1129 G_SOCKET_PROTOCOL_DEFAULT,
1130 &error);
1131 g_assert_no_error (error);
1132
1133 g_socket_set_blocking (client, TRUE);
1134 g_socket_set_timeout (client, 1);
1135
1136 g_socket_connect (client, addr, NULL, &error);
1137 g_assert_no_error (error);
1138 g_object_unref (addr);
1139
1140 start_time = g_get_monotonic_time ();
1141 g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1142 NULL, &error);
1143 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1144 g_clear_error (&error);
1145 poll_duration = g_get_monotonic_time () - start_time;
1146
1147 g_assert_cmpint (poll_duration, >=, 98000);
1148 g_assert_cmpint (poll_duration, <, 112000);
1149
1150 g_socket_close (client, &error);
1151 g_assert_no_error (error);
1152
1153 g_thread_join (data->thread);
1154
1155 g_socket_close (data->server, &error);
1156 g_assert_no_error (error);
1157
1158 g_object_unref (data->server);
1159 g_object_unref (client);
1160
1161 g_slice_free (IPTestData, data);
1162 }
1163
1164 static int
1165 duplicate_fd (int fd)
1166 {
1167 #ifdef G_OS_WIN32
1168 HANDLE newfd;
1169
1170 if (!DuplicateHandle (GetCurrentProcess (),
1171 (HANDLE)fd,
1172 GetCurrentProcess (),
1173 &newfd,
1174 0,
1175 FALSE,
1176 DUPLICATE_SAME_ACCESS))
1177 {
1178 return -1;
1179 }
1180
1181 return (int)newfd;
1182 #else
1183 return dup (fd);
1184 #endif
1185 }
1186
1187 static void
1188 test_fd_reuse (void)
1189 {
1190 IPTestData *data;
1191 GError *error = NULL;
1192 GSocket *client;
1193 GSocket *client2;
1194 GSocketAddress *addr;
1195 int fd;
1196 gssize len;
1197 gchar buf[128];
1198
1199 g_test_bug ("741707");
1200
1201 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1202 if (error != NULL)
1203 {
1204 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1205 g_test_skip (message);
1206 g_free (message);
1207 g_clear_error (&error);
1208 return;
1209 }
1210
1211 addr = g_socket_get_local_address (data->server, &error);
1212 g_assert_no_error (error);
1213
1214 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1215 G_SOCKET_TYPE_STREAM,
1216 G_SOCKET_PROTOCOL_DEFAULT,
1217 &error);
1218 g_assert_no_error (error);
1219
1220 g_socket_set_blocking (client, TRUE);
1221 g_socket_set_timeout (client, 1);
1222
1223 g_socket_connect (client, addr, NULL, &error);
1224 g_assert_no_error (error);
1225 g_assert (g_socket_is_connected (client));
1226 g_object_unref (addr);
1227
1228 /* we have to dup otherwise the fd gets closed twice on unref */
1229 fd = duplicate_fd (g_socket_get_fd (client));
1230 client2 = g_socket_new_from_fd (fd, &error);
1231 g_assert_no_error (error);
1232
1233 g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1234 g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1235 g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1236
1237 len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1238 g_assert_no_error (error);
1239 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1240
1241 len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1242 g_assert_no_error (error);
1243 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1244
1245 g_assert_cmpstr (testbuf, ==, buf);
1246
1247 g_socket_shutdown (client, FALSE, TRUE, &error);
1248 g_assert_no_error (error);
1249 /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1250 * on Linux, but return ENOTCONN on OS X.
1251 */
1252 g_socket_shutdown (client2, FALSE, TRUE, NULL);
1253
1254 g_thread_join (data->thread);
1255
1256 g_socket_close (client, &error);
1257 g_assert_no_error (error);
1258 g_socket_close (client2, &error);
1259 g_assert_no_error (error);
1260 g_socket_close (data->server, &error);
1261 g_assert_no_error (error);
1262
1263 g_assert_cmpint (g_socket_get_fd (client), ==, -1);
1264 g_assert_cmpint (g_socket_get_fd (client2), ==, -1);
1265 g_assert_cmpint (g_socket_get_fd (data->server), ==, -1);
1266
1267 g_object_unref (data->server);
1268 g_object_unref (client);
1269 g_object_unref (client2);
1270
1271 g_slice_free (IPTestData, data);
1272 }
1273
1274 static void
1275 test_sockaddr (void)
1276 {
1277 struct sockaddr_in6 sin6, gsin6;
1278 GSocketAddress *saddr;
1279 GInetSocketAddress *isaddr;
1280 GInetAddress *iaddr;
1281 GError *error = NULL;
1282
1283 memset (&sin6, 0, sizeof (sin6));
1284 sin6.sin6_family = AF_INET6;
1285 sin6.sin6_addr = in6addr_loopback;
1286 sin6.sin6_port = g_htons (42);
1287 sin6.sin6_scope_id = 17;
1288 sin6.sin6_flowinfo = 1729;
1289
1290 saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1291 g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
1292
1293 isaddr = G_INET_SOCKET_ADDRESS (saddr);
1294 iaddr = g_inet_socket_address_get_address (isaddr);
1295 g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1296 g_assert (g_inet_address_get_is_loopback (iaddr));
1297
1298 g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1299 g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1300 g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1301
1302 g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1303 g_assert_no_error (error);
1304
1305 g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
1306 g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1307 g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1308 g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1309
1310 g_object_unref (saddr);
1311 }
1312
1313 #ifdef G_OS_UNIX
1314 static void
1315 test_unix_from_fd (void)
1316 {
1317 gint fd;
1318 GError *error;
1319 GSocket *s;
1320
1321 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1322 g_assert_cmpint (fd, !=, -1);
1323
1324 error = NULL;
1325 s = g_socket_new_from_fd (fd, &error);
1326 g_assert_no_error (error);
1327 g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1328 g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1329 g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1330 g_object_unref (s);
1331 }
1332
1333 static void
1334 test_unix_connection (void)
1335 {
1336 gint fd;
1337 GError *error;
1338 GSocket *s;
1339 GSocketConnection *c;
1340
1341 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1342 g_assert_cmpint (fd, !=, -1);
1343
1344 error = NULL;
1345 s = g_socket_new_from_fd (fd, &error);
1346 g_assert_no_error (error);
1347 c = g_socket_connection_factory_create_connection (s);
1348 g_assert (G_IS_UNIX_CONNECTION (c));
1349 g_object_unref (c);
1350 g_object_unref (s);
1351 }
1352
1353 static GSocketConnection *
1354 create_connection_for_fd (int fd)
1355 {
1356 GError *err = NULL;
1357 GSocket *socket;
1358 GSocketConnection *connection;
1359
1360 socket = g_socket_new_from_fd (fd, &err);
1361 g_assert_no_error (err);
1362 g_assert (G_IS_SOCKET (socket));
1363 connection = g_socket_connection_factory_create_connection (socket);
1364 g_assert (G_IS_UNIX_CONNECTION (connection));
1365 g_object_unref (socket);
1366 return connection;
1367 }
1368
1369 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1370
1371 static void
1372 test_unix_connection_ancillary_data (void)
1373 {
1374 GError *err = NULL;
1375 gint pv[2], sv[3];
1376 gint status, fd, len;
1377 char buffer[1024];
1378 pid_t pid;
1379
1380 status = pipe (pv);
1381 g_assert_cmpint (status, ==, 0);
1382
1383 status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1384 g_assert_cmpint (status, ==, 0);
1385
1386 pid = fork ();
1387 g_assert_cmpint (pid, >=, 0);
1388
1389 /* Child: close its copy of the write end of the pipe, receive it
1390 * again from the parent over the socket, and write some text to it.
1391 *
1392 * Parent: send the write end of the pipe (still open for the
1393 * parent) over the socket, close it, and read some text from the
1394 * read end of the pipe.
1395 */
1396 if (pid == 0)
1397 {
1398 GSocketConnection *connection;
1399
1400 close (sv[1]);
1401 connection = create_connection_for_fd (sv[0]);
1402
1403 status = close (pv[1]);
1404 g_assert_cmpint (status, ==, 0);
1405
1406 err = NULL;
1407 fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1408 &err);
1409 g_assert_no_error (err);
1410 g_assert_cmpint (fd, >, -1);
1411 g_object_unref (connection);
1412
1413 do
1414 len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1415 while (len == -1 && errno == EINTR);
1416 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1417 exit (0);
1418 }
1419 else
1420 {
1421 GSocketConnection *connection;
1422
1423 close (sv[0]);
1424 connection = create_connection_for_fd (sv[1]);
1425
1426 err = NULL;
1427 g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1428 &err);
1429 g_assert_no_error (err);
1430 g_object_unref (connection);
1431
1432 status = close (pv[1]);
1433 g_assert_cmpint (status, ==, 0);
1434
1435 memset (buffer, 0xff, sizeof buffer);
1436 do
1437 len = read (pv[0], buffer, sizeof buffer);
1438 while (len == -1 && errno == EINTR);
1439
1440 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1441 g_assert_cmpstr (buffer, ==, TEST_DATA);
1442
1443 waitpid (pid, &status, 0);
1444 g_assert (WIFEXITED (status));
1445 g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1446 }
1447
1448 /* TODO: add test for g_unix_connection_send_credentials() and
1449 * g_unix_connection_receive_credentials().
1450 */
1451 }
1452
1453 static gboolean
1454 postmortem_source_cb (GSocket *socket,
1455 GIOCondition condition,
1456 gpointer user_data)
1457 {
1458 gboolean *been_here = user_data;
1459
1460 g_assert_cmpint (condition, ==, G_IO_NVAL);
1461
1462 *been_here = TRUE;
1463 return FALSE;
1464 }
1465
1466 static void
1467 test_source_postmortem (void)
1468 {
1469 GMainContext *context;
1470 GSocket *socket;
1471 GSource *source;
1472 GError *error = NULL;
1473 gboolean callback_visited = FALSE;
1474
1475 socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
1476 g_assert_no_error (error);
1477
1478 context = g_main_context_new ();
1479
1480 source = g_socket_create_source (socket, G_IO_IN, NULL);
1481 g_source_set_callback (source, (GSourceFunc) postmortem_source_cb,
1482 &callback_visited, NULL);
1483 g_source_attach (source, context);
1484 g_source_unref (source);
1485
1486 g_socket_close (socket, &error);
1487 g_assert_no_error (error);
1488 g_object_unref (socket);
1489
1490 /* Test that, after a socket is closed, its source callback should be called
1491 * exactly once. */
1492 g_main_context_iteration (context, FALSE);
1493 g_assert (callback_visited);
1494 g_assert (!g_main_context_pending (context));
1495
1496 g_main_context_unref (context);
1497 }
1498
1499 #endif /* G_OS_UNIX */
1500
1501 static void
1502 test_reuse_tcp (void)
1503 {
1504 GSocket *sock1, *sock2;
1505 GError *error = NULL;
1506 GInetAddress *iaddr;
1507 GSocketAddress *addr;
1508
1509 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1510 G_SOCKET_TYPE_STREAM,
1511 G_SOCKET_PROTOCOL_DEFAULT,
1512 &error);
1513 g_assert_no_error (error);
1514
1515 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1516 addr = g_inet_socket_address_new (iaddr, 0);
1517 g_object_unref (iaddr);
1518 g_socket_bind (sock1, addr, TRUE, &error);
1519 g_object_unref (addr);
1520 g_assert_no_error (error);
1521
1522 g_socket_listen (sock1, &error);
1523 g_assert_no_error (error);
1524
1525 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1526 G_SOCKET_TYPE_STREAM,
1527 G_SOCKET_PROTOCOL_DEFAULT,
1528 &error);
1529 g_assert_no_error (error);
1530
1531 addr = g_socket_get_local_address (sock1, &error);
1532 g_assert_no_error (error);
1533 g_socket_bind (sock2, addr, TRUE, &error);
1534 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1535 g_clear_error (&error);
1536 g_object_unref (addr);
1537
1538 g_object_unref (sock1);
1539 g_object_unref (sock2);
1540 }
1541
1542 static void
1543 test_reuse_udp (void)
1544 {
1545 GSocket *sock1, *sock2;
1546 GError *error = NULL;
1547 GInetAddress *iaddr;
1548 GSocketAddress *addr;
1549
1550 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1551 G_SOCKET_TYPE_DATAGRAM,
1552 G_SOCKET_PROTOCOL_DEFAULT,
1553 &error);
1554 g_assert_no_error (error);
1555
1556 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1557 addr = g_inet_socket_address_new (iaddr, 0);
1558 g_object_unref (iaddr);
1559 g_socket_bind (sock1, addr, TRUE, &error);
1560 g_object_unref (addr);
1561 g_assert_no_error (error);
1562
1563 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1564 G_SOCKET_TYPE_DATAGRAM,
1565 G_SOCKET_PROTOCOL_DEFAULT,
1566 &error);
1567 g_assert_no_error (error);
1568
1569 addr = g_socket_get_local_address (sock1, &error);
1570 g_assert_no_error (error);
1571 g_socket_bind (sock2, addr, TRUE, &error);
1572 g_object_unref (addr);
1573 g_assert_no_error (error);
1574
1575 g_object_unref (sock1);
1576 g_object_unref (sock2);
1577 }
1578
1579 static void
1580 test_get_available (gconstpointer user_data)
1581 {
1582 GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1583 GError *err = NULL;
1584 GSocket *listener, *server, *client;
1585 GInetAddress *addr;
1586 GSocketAddress *saddr;
1587 gchar data[] = "0123456789abcdef";
1588 gchar buf[34];
1589 gssize nread;
1590
1591 listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1592 socket_type,
1593 G_SOCKET_PROTOCOL_DEFAULT,
1594 &err);
1595 g_assert_no_error (err);
1596 g_assert (G_IS_SOCKET (listener));
1597
1598 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1599 socket_type,
1600 G_SOCKET_PROTOCOL_DEFAULT,
1601 &err);
1602 g_assert_no_error (err);
1603 g_assert (G_IS_SOCKET (client));
1604
1605 if (socket_type == G_SOCKET_TYPE_STREAM)
1606 {
1607 g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1608 g_assert_no_error (err);
1609 }
1610
1611 addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1612 saddr = g_inet_socket_address_new (addr, 0);
1613
1614 g_socket_bind (listener, saddr, TRUE, &err);
1615 g_assert_no_error (err);
1616 g_object_unref (saddr);
1617 g_object_unref (addr);
1618
1619 saddr = g_socket_get_local_address (listener, &err);
1620 g_assert_no_error (err);
1621
1622 if (socket_type == G_SOCKET_TYPE_STREAM)
1623 {
1624 g_socket_listen (listener, &err);
1625 g_assert_no_error (err);
1626 g_socket_connect (client, saddr, NULL, &err);
1627 g_assert_no_error (err);
1628
1629 server = g_socket_accept (listener, NULL, &err);
1630 g_assert_no_error (err);
1631 g_socket_set_blocking (server, FALSE);
1632 g_object_unref (listener);
1633 }
1634 else
1635 server = listener;
1636
1637 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1638 g_assert_no_error (err);
1639
1640 while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1641 ;
1642 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1643
1644 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1645 g_assert_no_error (err);
1646
1647 /* We need to wait until the data has actually been copied into the
1648 * server socket's buffers, but g_socket_condition_wait() won't help
1649 * here since the socket is definitely already readable. So there's
1650 * a race condition in checking its available bytes. In the TCP
1651 * case, we poll for a bit until the new data shows up. In the UDP
1652 * case, there's not much we can do, but at least the failure mode
1653 * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1654 */
1655 if (socket_type == G_SOCKET_TYPE_STREAM)
1656 {
1657 int tries;
1658
1659 for (tries = 0; tries < 100; tries++)
1660 {
1661 if (g_socket_get_available_bytes (server) > sizeof (data))
1662 break;
1663 g_usleep (100000);
1664 }
1665
1666 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1667 }
1668 else
1669 {
1670 g_usleep (100000);
1671 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1672 }
1673
1674 g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1675 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1676 g_assert_no_error (err);
1677
1678 if (socket_type == G_SOCKET_TYPE_STREAM)
1679 {
1680 g_assert_cmpint (nread, ==, 2 * sizeof (data));
1681 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1682 }
1683 else
1684 {
1685 g_assert_cmpint (nread, ==, sizeof (data));
1686 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1687 }
1688
1689 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1690 if (socket_type == G_SOCKET_TYPE_STREAM)
1691 {
1692 g_assert_cmpint (nread, ==, -1);
1693 g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1694 g_clear_error (&err);
1695 }
1696 else
1697 {
1698 g_assert_cmpint (nread, ==, sizeof (data));
1699 g_assert_no_error (err);
1700 }
1701
1702 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1703
1704 g_socket_close (server, &err);
1705 g_assert_no_error (err);
1706
1707 g_object_unref (saddr);
1708 g_object_unref (server);
1709 g_object_unref (client);
1710 }
1711
1712 int
1713 main (int argc,
1714 char *argv[])
1715 {
1716 GSocket *sock;
1717 GError *error = NULL;
1718
1719 g_test_init (&argc, &argv, NULL);
1720 g_test_bug_base ("https://bugzilla.gnome.org/");
1721
1722 sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1723 G_SOCKET_TYPE_STREAM,
1724 G_SOCKET_PROTOCOL_DEFAULT,
1725 &error);
1726 if (sock != NULL)
1727 {
1728 ipv6_supported = TRUE;
1729 g_object_unref (sock);
1730 }
1731 else
1732 {
1733 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1734 g_clear_error (&error);
1735 }
1736
1737 g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1738 g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1739 g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1740 g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1741 g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1742 g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
1743 g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1744 g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
1745 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1746 g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1747 #endif
1748 g_test_add_func ("/socket/close_graceful", test_close_graceful);
1749 g_test_add_func ("/socket/timed_wait", test_timed_wait);
1750 g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
1751 g_test_add_func ("/socket/address", test_sockaddr);
1752 #ifdef G_OS_UNIX
1753 g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1754 g_test_add_func ("/socket/unix-connection", test_unix_connection);
1755 g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1756 g_test_add_func ("/socket/source-postmortem", test_source_postmortem);
1757 #endif
1758 g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1759 g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1760 g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1761 test_get_available);
1762 g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1763 test_get_available);
1764
1765 return g_test_run();
1766 }
1767
glib mirror