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
echo_server_dgram_thread(gpointer user_data)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
echo_server_thread(gpointer user_data)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 *
create_server_full(GSocketFamily family,GSocketType socket_type,GThreadFunc server_thread,gboolean v4mapped,GError ** error)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 *
create_server(GSocketFamily family,GThreadFunc server_thread,gboolean v4mapped,GError ** error)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
test_ip_async_read_ready(GSocket * client,GIOCondition cond,gpointer user_data)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
test_ip_async_write_ready(GSocket * client,GIOCondition cond,gpointer user_data)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
test_ip_async_timed_out(GSocket * client,GIOCondition cond,gpointer user_data)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
test_ip_async_connected(GSocket * client,GIOCondition cond,gpointer user_data)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
idle_test_ip_async_connected(gpointer user_data)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
test_ip_async(GSocketFamily family)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
test_ipv4_async(void)419 test_ipv4_async (void)
420 {
421 test_ip_async (G_SOCKET_FAMILY_IPV4);
422 }
423
424 static void
test_ipv6_async(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
test_ip_sync(GSocketFamily family)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
test_ipv4_sync(void)560 test_ipv4_sync (void)
561 {
562 test_ip_sync (G_SOCKET_FAMILY_IPV4);
563 }
564
565 static void
test_ipv6_sync(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
test_ip_sync_dgram(GSocketFamily family)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 /* This error code may vary between platforms and over time; it is not guaranteed API: */
761 #ifndef G_OS_WIN32
762 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
763 #else
764 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_CONNECTED);
765 #endif
766 g_clear_error (&error);
767 g_assert_cmpint (len, ==, -1);
768
769 g_assert_cmpint (m[0].bytes_sent, ==, 0);
770 g_assert_cmpint (m[1].bytes_sent, ==, 0);
771 g_assert_cmpint (m[2].bytes_sent, ==, 0);
772
773 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
774 g_assert_cmpint (len, ==, 3);
775 }
776
777 g_cancellable_cancel (data->cancellable);
778
779 g_thread_join (data->thread);
780
781 g_socket_close (client, &error);
782 g_assert_no_error (error);
783 g_socket_close (data->server, &error);
784 g_assert_no_error (error);
785
786 g_object_unref (data->server);
787 g_object_unref (data->cancellable);
788 g_object_unref (client);
789 g_object_unref (dest_addr);
790
791 g_slice_free (IPTestData, data);
792 }
793
794 static void
test_ipv4_sync_dgram(void)795 test_ipv4_sync_dgram (void)
796 {
797 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
798 }
799
800 static void
test_ipv6_sync_dgram(void)801 test_ipv6_sync_dgram (void)
802 {
803 if (!ipv6_supported)
804 {
805 g_test_skip ("No support for IPv6");
806 return;
807 }
808
809 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
810 }
811
812 static gpointer
cancellable_thread_cb(gpointer data)813 cancellable_thread_cb (gpointer data)
814 {
815 GCancellable *cancellable = data;
816
817 g_usleep (0.1 * G_USEC_PER_SEC);
818 g_cancellable_cancel (cancellable);
819 g_object_unref (cancellable);
820
821 return NULL;
822 }
823
824 static void
test_ip_sync_dgram_timeouts(GSocketFamily family)825 test_ip_sync_dgram_timeouts (GSocketFamily family)
826 {
827 GError *error = NULL;
828 GSocket *client = NULL;
829 GCancellable *cancellable = NULL;
830 GThread *cancellable_thread = NULL;
831 gssize len;
832 #ifdef G_OS_WIN32
833 GInetAddress *iaddr;
834 GSocketAddress *addr;
835 #endif
836
837 client = g_socket_new (family,
838 G_SOCKET_TYPE_DATAGRAM,
839 G_SOCKET_PROTOCOL_DEFAULT,
840 &error);
841 g_assert_no_error (error);
842
843 g_assert_cmpint (g_socket_get_family (client), ==, family);
844 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
845 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
846
847 #ifdef G_OS_WIN32
848 /* Winsock can't recv() on unbound udp socket */
849 iaddr = g_inet_address_new_loopback (family);
850 addr = g_inet_socket_address_new (iaddr, 0);
851 g_object_unref (iaddr);
852 g_socket_bind (client, addr, TRUE, &error);
853 g_object_unref (addr);
854 g_assert_no_error (error);
855 #endif
856
857 /* No overall timeout: test the per-operation timeouts instead. */
858 g_socket_set_timeout (client, 0);
859
860 cancellable = g_cancellable_new ();
861
862 /* Check for timeouts when no server is running. */
863 {
864 gint64 start_time;
865 GInputMessage im = { NULL, };
866 GInputVector iv = { NULL, };
867 guint8 buf[128];
868
869 iv.buffer = buf;
870 iv.size = sizeof (buf);
871
872 im.vectors = &iv;
873 im.num_vectors = 1;
874
875 memset (buf, 0, sizeof (buf));
876
877 /* Try a non-blocking read. */
878 g_socket_set_blocking (client, FALSE);
879 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
880 NULL, &error);
881 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
882 g_assert_cmpint (len, ==, -1);
883 g_clear_error (&error);
884
885 /* Try a timeout read. Can’t really validate the time taken more than
886 * checking it’s positive. */
887 g_socket_set_timeout (client, 1);
888 g_socket_set_blocking (client, TRUE);
889 start_time = g_get_monotonic_time ();
890 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
891 NULL, &error);
892 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
893 g_assert_cmpint (len, ==, -1);
894 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
895 g_clear_error (&error);
896
897 /* Try a blocking read, cancelled from another thread. */
898 g_socket_set_timeout (client, 0);
899 cancellable_thread = g_thread_new ("cancellable",
900 cancellable_thread_cb,
901 g_object_ref (cancellable));
902
903 start_time = g_get_monotonic_time ();
904 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
905 cancellable, &error);
906 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
907 g_assert_cmpint (len, ==, -1);
908 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
909 g_clear_error (&error);
910
911 g_thread_join (cancellable_thread);
912 }
913
914 g_socket_close (client, &error);
915 g_assert_no_error (error);
916
917 g_object_unref (client);
918 g_object_unref (cancellable);
919 }
920
921 static void
test_ipv4_sync_dgram_timeouts(void)922 test_ipv4_sync_dgram_timeouts (void)
923 {
924 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
925 }
926
927 static void
test_ipv6_sync_dgram_timeouts(void)928 test_ipv6_sync_dgram_timeouts (void)
929 {
930 if (!ipv6_supported)
931 {
932 g_test_skip ("No support for IPv6");
933 return;
934 }
935
936 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
937 }
938
939 static gpointer
graceful_server_thread(gpointer user_data)940 graceful_server_thread (gpointer user_data)
941 {
942 IPTestData *data = user_data;
943 GSocket *sock;
944 GError *error = NULL;
945 gssize len;
946
947 sock = g_socket_accept (data->server, NULL, &error);
948 g_assert_no_error (error);
949
950 len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
951 g_assert_no_error (error);
952 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
953
954 return sock;
955 }
956
957 static void
test_close_graceful(void)958 test_close_graceful (void)
959 {
960 GSocketFamily family = G_SOCKET_FAMILY_IPV4;
961 IPTestData *data;
962 GError *error = NULL;
963 GSocket *client, *server;
964 GSocketAddress *addr;
965 gssize len;
966 gchar buf[128];
967
968 data = create_server (family, graceful_server_thread, FALSE, &error);
969 if (error != NULL)
970 {
971 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
972 g_test_skip (message);
973 g_free (message);
974 g_clear_error (&error);
975 return;
976 }
977
978 addr = g_socket_get_local_address (data->server, &error);
979 g_assert_no_error (error);
980
981 client = g_socket_new (family,
982 G_SOCKET_TYPE_STREAM,
983 G_SOCKET_PROTOCOL_DEFAULT,
984 &error);
985 g_assert_no_error (error);
986
987 g_assert_cmpint (g_socket_get_family (client), ==, family);
988 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
989 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
990
991 g_socket_set_blocking (client, TRUE);
992 g_socket_set_timeout (client, 1);
993
994 g_socket_connect (client, addr, NULL, &error);
995 g_assert_no_error (error);
996 g_assert (g_socket_is_connected (client));
997 g_object_unref (addr);
998
999 server = g_thread_join (data->thread);
1000
1001 /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
1002 g_socket_shutdown (server, FALSE, TRUE, &error);
1003 g_assert_no_error (error);
1004
1005 /* we must timeout */
1006 g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
1007 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1008 g_clear_error (&error);
1009
1010 /* check that the remaining data is received */
1011 len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
1012 g_assert_no_error (error);
1013 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1014
1015 /* and only then the connection is closed */
1016 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
1017 g_assert_no_error (error);
1018 g_assert_cmpint (len, ==, 0);
1019
1020 g_socket_close (server, &error);
1021 g_assert_no_error (error);
1022
1023 g_socket_close (client, &error);
1024 g_assert_no_error (error);
1025
1026 g_object_unref (server);
1027 g_object_unref (data->server);
1028 g_object_unref (client);
1029
1030 g_slice_free (IPTestData, data);
1031 }
1032
1033 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1034 static gpointer
v4mapped_server_thread(gpointer user_data)1035 v4mapped_server_thread (gpointer user_data)
1036 {
1037 IPTestData *data = user_data;
1038 GSocket *sock;
1039 GError *error = NULL;
1040 GSocketAddress *addr;
1041
1042 sock = g_socket_accept (data->server, NULL, &error);
1043 g_assert_no_error (error);
1044
1045 g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
1046
1047 addr = g_socket_get_local_address (sock, &error);
1048 g_assert_no_error (error);
1049 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1050 g_object_unref (addr);
1051
1052 addr = g_socket_get_remote_address (sock, &error);
1053 g_assert_no_error (error);
1054 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1055 g_object_unref (addr);
1056
1057 g_socket_close (sock, &error);
1058 g_assert_no_error (error);
1059 g_object_unref (sock);
1060 return NULL;
1061 }
1062
1063 static void
test_ipv6_v4mapped(void)1064 test_ipv6_v4mapped (void)
1065 {
1066 IPTestData *data;
1067 GError *error = NULL;
1068 GSocket *client;
1069 GSocketAddress *addr, *v4addr;
1070 GInetAddress *iaddr;
1071
1072 if (!ipv6_supported)
1073 {
1074 g_test_skip ("No support for IPv6");
1075 return;
1076 }
1077
1078 data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE, &error);
1079 if (error != NULL)
1080 {
1081 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1082 g_test_skip (message);
1083 g_free (message);
1084 g_clear_error (&error);
1085 return;
1086 }
1087
1088 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1089 G_SOCKET_TYPE_STREAM,
1090 G_SOCKET_PROTOCOL_DEFAULT,
1091 &error);
1092 g_assert_no_error (error);
1093
1094 g_socket_set_blocking (client, TRUE);
1095 g_socket_set_timeout (client, 1);
1096
1097 addr = g_socket_get_local_address (data->server, &error);
1098 g_assert_no_error (error);
1099 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1100 v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1101 g_object_unref (iaddr);
1102 g_object_unref (addr);
1103
1104 g_socket_connect (client, v4addr, NULL, &error);
1105 g_assert_no_error (error);
1106 g_assert (g_socket_is_connected (client));
1107
1108 g_thread_join (data->thread);
1109
1110 g_socket_close (client, &error);
1111 g_assert_no_error (error);
1112 g_socket_close (data->server, &error);
1113 g_assert_no_error (error);
1114
1115 g_object_unref (data->server);
1116 g_object_unref (client);
1117 g_object_unref (v4addr);
1118
1119 g_slice_free (IPTestData, data);
1120 }
1121 #endif
1122
1123 static void
test_timed_wait(void)1124 test_timed_wait (void)
1125 {
1126 IPTestData *data;
1127 GError *error = NULL;
1128 GSocket *client;
1129 GSocketAddress *addr;
1130 gint64 start_time;
1131 gint poll_duration;
1132
1133 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1134 if (error != NULL)
1135 {
1136 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1137 g_test_skip (message);
1138 g_free (message);
1139 g_clear_error (&error);
1140 return;
1141 }
1142
1143 addr = g_socket_get_local_address (data->server, &error);
1144 g_assert_no_error (error);
1145
1146 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1147 G_SOCKET_TYPE_STREAM,
1148 G_SOCKET_PROTOCOL_DEFAULT,
1149 &error);
1150 g_assert_no_error (error);
1151
1152 g_socket_set_blocking (client, TRUE);
1153 g_socket_set_timeout (client, 1);
1154
1155 g_socket_connect (client, addr, NULL, &error);
1156 g_assert_no_error (error);
1157 g_object_unref (addr);
1158
1159 start_time = g_get_monotonic_time ();
1160 g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1161 NULL, &error);
1162 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1163 g_clear_error (&error);
1164 poll_duration = g_get_monotonic_time () - start_time;
1165
1166 g_assert_cmpint (poll_duration, >=, 98000);
1167 g_assert_cmpint (poll_duration, <, 112000);
1168
1169 g_socket_close (client, &error);
1170 g_assert_no_error (error);
1171
1172 g_thread_join (data->thread);
1173
1174 g_socket_close (data->server, &error);
1175 g_assert_no_error (error);
1176
1177 g_object_unref (data->server);
1178 g_object_unref (client);
1179
1180 g_slice_free (IPTestData, data);
1181 }
1182
1183 static int
duplicate_fd(int fd)1184 duplicate_fd (int fd)
1185 {
1186 #ifdef G_OS_WIN32
1187 HANDLE newfd;
1188
1189 if (!DuplicateHandle (GetCurrentProcess (),
1190 (HANDLE)fd,
1191 GetCurrentProcess (),
1192 &newfd,
1193 0,
1194 FALSE,
1195 DUPLICATE_SAME_ACCESS))
1196 {
1197 return -1;
1198 }
1199
1200 return (int)newfd;
1201 #else
1202 return dup (fd);
1203 #endif
1204 }
1205
1206 static void
test_fd_reuse(void)1207 test_fd_reuse (void)
1208 {
1209 IPTestData *data;
1210 GError *error = NULL;
1211 GSocket *client;
1212 GSocket *client2;
1213 GSocketAddress *addr;
1214 int fd;
1215 gssize len;
1216 gchar buf[128];
1217
1218 g_test_bug ("741707");
1219
1220 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1221 if (error != NULL)
1222 {
1223 gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1224 g_test_skip (message);
1225 g_free (message);
1226 g_clear_error (&error);
1227 return;
1228 }
1229
1230 addr = g_socket_get_local_address (data->server, &error);
1231 g_assert_no_error (error);
1232
1233 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1234 G_SOCKET_TYPE_STREAM,
1235 G_SOCKET_PROTOCOL_DEFAULT,
1236 &error);
1237 g_assert_no_error (error);
1238
1239 g_socket_set_blocking (client, TRUE);
1240 g_socket_set_timeout (client, 1);
1241
1242 g_socket_connect (client, addr, NULL, &error);
1243 g_assert_no_error (error);
1244 g_assert (g_socket_is_connected (client));
1245 g_object_unref (addr);
1246
1247 /* we have to dup otherwise the fd gets closed twice on unref */
1248 fd = duplicate_fd (g_socket_get_fd (client));
1249 client2 = g_socket_new_from_fd (fd, &error);
1250 g_assert_no_error (error);
1251
1252 g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1253 g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1254 g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1255
1256 len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1257 g_assert_no_error (error);
1258 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1259
1260 len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1261 g_assert_no_error (error);
1262 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1263
1264 g_assert_cmpstr (testbuf, ==, buf);
1265
1266 g_socket_shutdown (client, FALSE, TRUE, &error);
1267 g_assert_no_error (error);
1268 /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1269 * on Linux, but return ENOTCONN on OS X.
1270 */
1271 g_socket_shutdown (client2, FALSE, TRUE, NULL);
1272
1273 g_thread_join (data->thread);
1274
1275 g_socket_close (client, &error);
1276 g_assert_no_error (error);
1277 g_socket_close (client2, &error);
1278 g_assert_no_error (error);
1279 g_socket_close (data->server, &error);
1280 g_assert_no_error (error);
1281
1282 g_assert_cmpint (g_socket_get_fd (client), ==, -1);
1283 g_assert_cmpint (g_socket_get_fd (client2), ==, -1);
1284 g_assert_cmpint (g_socket_get_fd (data->server), ==, -1);
1285
1286 g_object_unref (data->server);
1287 g_object_unref (client);
1288 g_object_unref (client2);
1289
1290 g_slice_free (IPTestData, data);
1291 }
1292
1293 static void
test_sockaddr(void)1294 test_sockaddr (void)
1295 {
1296 struct sockaddr_in6 sin6, gsin6;
1297 GSocketAddress *saddr;
1298 GInetSocketAddress *isaddr;
1299 GInetAddress *iaddr;
1300 GError *error = NULL;
1301
1302 memset (&sin6, 0, sizeof (sin6));
1303 sin6.sin6_family = AF_INET6;
1304 sin6.sin6_addr = in6addr_loopback;
1305 sin6.sin6_port = g_htons (42);
1306 sin6.sin6_scope_id = 17;
1307 sin6.sin6_flowinfo = 1729;
1308
1309 saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1310 g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
1311
1312 isaddr = G_INET_SOCKET_ADDRESS (saddr);
1313 iaddr = g_inet_socket_address_get_address (isaddr);
1314 g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1315 g_assert (g_inet_address_get_is_loopback (iaddr));
1316
1317 g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1318 g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1319 g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1320
1321 g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1322 g_assert_no_error (error);
1323
1324 g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
1325 g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1326 g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1327 g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1328
1329 g_object_unref (saddr);
1330 }
1331
1332 #ifdef G_OS_UNIX
1333 static void
test_unix_from_fd(void)1334 test_unix_from_fd (void)
1335 {
1336 gint fd;
1337 GError *error;
1338 GSocket *s;
1339
1340 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1341 g_assert_cmpint (fd, !=, -1);
1342
1343 error = NULL;
1344 s = g_socket_new_from_fd (fd, &error);
1345 g_assert_no_error (error);
1346 g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1347 g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1348 g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1349 g_object_unref (s);
1350 }
1351
1352 static void
test_unix_connection(void)1353 test_unix_connection (void)
1354 {
1355 gint fd;
1356 GError *error;
1357 GSocket *s;
1358 GSocketConnection *c;
1359
1360 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1361 g_assert_cmpint (fd, !=, -1);
1362
1363 error = NULL;
1364 s = g_socket_new_from_fd (fd, &error);
1365 g_assert_no_error (error);
1366 c = g_socket_connection_factory_create_connection (s);
1367 g_assert (G_IS_UNIX_CONNECTION (c));
1368 g_object_unref (c);
1369 g_object_unref (s);
1370 }
1371
1372 static GSocketConnection *
create_connection_for_fd(int fd)1373 create_connection_for_fd (int fd)
1374 {
1375 GError *err = NULL;
1376 GSocket *socket;
1377 GSocketConnection *connection;
1378
1379 socket = g_socket_new_from_fd (fd, &err);
1380 g_assert_no_error (err);
1381 g_assert (G_IS_SOCKET (socket));
1382 connection = g_socket_connection_factory_create_connection (socket);
1383 g_assert (G_IS_UNIX_CONNECTION (connection));
1384 g_object_unref (socket);
1385 return connection;
1386 }
1387
1388 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1389
1390 static void
test_unix_connection_ancillary_data(void)1391 test_unix_connection_ancillary_data (void)
1392 {
1393 GError *err = NULL;
1394 gint pv[2], sv[3];
1395 gint status, fd, len;
1396 char buffer[1024];
1397 pid_t pid;
1398
1399 status = pipe (pv);
1400 g_assert_cmpint (status, ==, 0);
1401
1402 status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1403 g_assert_cmpint (status, ==, 0);
1404
1405 pid = fork ();
1406 g_assert_cmpint (pid, >=, 0);
1407
1408 /* Child: close its copy of the write end of the pipe, receive it
1409 * again from the parent over the socket, and write some text to it.
1410 *
1411 * Parent: send the write end of the pipe (still open for the
1412 * parent) over the socket, close it, and read some text from the
1413 * read end of the pipe.
1414 */
1415 if (pid == 0)
1416 {
1417 GSocketConnection *connection;
1418
1419 close (sv[1]);
1420 connection = create_connection_for_fd (sv[0]);
1421
1422 status = close (pv[1]);
1423 g_assert_cmpint (status, ==, 0);
1424
1425 err = NULL;
1426 fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1427 &err);
1428 g_assert_no_error (err);
1429 g_assert_cmpint (fd, >, -1);
1430 g_object_unref (connection);
1431
1432 do
1433 len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1434 while (len == -1 && errno == EINTR);
1435 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1436 exit (0);
1437 }
1438 else
1439 {
1440 GSocketConnection *connection;
1441
1442 close (sv[0]);
1443 connection = create_connection_for_fd (sv[1]);
1444
1445 err = NULL;
1446 g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1447 &err);
1448 g_assert_no_error (err);
1449 g_object_unref (connection);
1450
1451 status = close (pv[1]);
1452 g_assert_cmpint (status, ==, 0);
1453
1454 memset (buffer, 0xff, sizeof buffer);
1455 do
1456 len = read (pv[0], buffer, sizeof buffer);
1457 while (len == -1 && errno == EINTR);
1458
1459 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1460 g_assert_cmpstr (buffer, ==, TEST_DATA);
1461
1462 waitpid (pid, &status, 0);
1463 g_assert (WIFEXITED (status));
1464 g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1465 }
1466
1467 /* TODO: add test for g_unix_connection_send_credentials() and
1468 * g_unix_connection_receive_credentials().
1469 */
1470 }
1471
1472 static gboolean
postmortem_source_cb(GSocket * socket,GIOCondition condition,gpointer user_data)1473 postmortem_source_cb (GSocket *socket,
1474 GIOCondition condition,
1475 gpointer user_data)
1476 {
1477 gboolean *been_here = user_data;
1478
1479 g_assert_cmpint (condition, ==, G_IO_NVAL);
1480
1481 *been_here = TRUE;
1482 return FALSE;
1483 }
1484
1485 static void
test_source_postmortem(void)1486 test_source_postmortem (void)
1487 {
1488 GMainContext *context;
1489 GSocket *socket;
1490 GSource *source;
1491 GError *error = NULL;
1492 gboolean callback_visited = FALSE;
1493
1494 socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
1495 g_assert_no_error (error);
1496
1497 context = g_main_context_new ();
1498
1499 source = g_socket_create_source (socket, G_IO_IN, NULL);
1500 g_source_set_callback (source, (GSourceFunc) postmortem_source_cb,
1501 &callback_visited, NULL);
1502 g_source_attach (source, context);
1503 g_source_unref (source);
1504
1505 g_socket_close (socket, &error);
1506 g_assert_no_error (error);
1507 g_object_unref (socket);
1508
1509 /* Test that, after a socket is closed, its source callback should be called
1510 * exactly once. */
1511 g_main_context_iteration (context, FALSE);
1512 g_assert (callback_visited);
1513 g_assert (!g_main_context_pending (context));
1514
1515 g_main_context_unref (context);
1516 }
1517
1518 #endif /* G_OS_UNIX */
1519
1520 static void
test_reuse_tcp(void)1521 test_reuse_tcp (void)
1522 {
1523 GSocket *sock1, *sock2;
1524 GError *error = NULL;
1525 GInetAddress *iaddr;
1526 GSocketAddress *addr;
1527
1528 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1529 G_SOCKET_TYPE_STREAM,
1530 G_SOCKET_PROTOCOL_DEFAULT,
1531 &error);
1532 g_assert_no_error (error);
1533
1534 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1535 addr = g_inet_socket_address_new (iaddr, 0);
1536 g_object_unref (iaddr);
1537 g_socket_bind (sock1, addr, TRUE, &error);
1538 g_object_unref (addr);
1539 g_assert_no_error (error);
1540
1541 g_socket_listen (sock1, &error);
1542 g_assert_no_error (error);
1543
1544 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1545 G_SOCKET_TYPE_STREAM,
1546 G_SOCKET_PROTOCOL_DEFAULT,
1547 &error);
1548 g_assert_no_error (error);
1549
1550 addr = g_socket_get_local_address (sock1, &error);
1551 g_assert_no_error (error);
1552 g_socket_bind (sock2, addr, TRUE, &error);
1553 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1554 g_clear_error (&error);
1555 g_object_unref (addr);
1556
1557 g_object_unref (sock1);
1558 g_object_unref (sock2);
1559 }
1560
1561 static void
test_reuse_udp(void)1562 test_reuse_udp (void)
1563 {
1564 GSocket *sock1, *sock2;
1565 GError *error = NULL;
1566 GInetAddress *iaddr;
1567 GSocketAddress *addr;
1568
1569 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1570 G_SOCKET_TYPE_DATAGRAM,
1571 G_SOCKET_PROTOCOL_DEFAULT,
1572 &error);
1573 g_assert_no_error (error);
1574
1575 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1576 addr = g_inet_socket_address_new (iaddr, 0);
1577 g_object_unref (iaddr);
1578 g_socket_bind (sock1, addr, TRUE, &error);
1579 g_object_unref (addr);
1580 g_assert_no_error (error);
1581
1582 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1583 G_SOCKET_TYPE_DATAGRAM,
1584 G_SOCKET_PROTOCOL_DEFAULT,
1585 &error);
1586 g_assert_no_error (error);
1587
1588 addr = g_socket_get_local_address (sock1, &error);
1589 g_assert_no_error (error);
1590 g_socket_bind (sock2, addr, TRUE, &error);
1591 g_object_unref (addr);
1592 g_assert_no_error (error);
1593
1594 g_object_unref (sock1);
1595 g_object_unref (sock2);
1596 }
1597
1598 static void
test_get_available(gconstpointer user_data)1599 test_get_available (gconstpointer user_data)
1600 {
1601 GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1602 GError *err = NULL;
1603 GSocket *listener, *server, *client;
1604 GInetAddress *addr;
1605 GSocketAddress *saddr, *boundaddr;
1606 gchar data[] = "0123456789abcdef";
1607 gchar buf[34];
1608 gssize nread;
1609
1610 listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1611 socket_type,
1612 G_SOCKET_PROTOCOL_DEFAULT,
1613 &err);
1614 g_assert_no_error (err);
1615 g_assert (G_IS_SOCKET (listener));
1616
1617 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1618 socket_type,
1619 G_SOCKET_PROTOCOL_DEFAULT,
1620 &err);
1621 g_assert_no_error (err);
1622 g_assert (G_IS_SOCKET (client));
1623
1624 if (socket_type == G_SOCKET_TYPE_STREAM)
1625 {
1626 g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1627 g_assert_no_error (err);
1628 }
1629
1630 addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1631 saddr = g_inet_socket_address_new (addr, 0);
1632
1633 g_socket_bind (listener, saddr, TRUE, &err);
1634 g_assert_no_error (err);
1635 g_object_unref (saddr);
1636 g_object_unref (addr);
1637
1638 boundaddr = g_socket_get_local_address (listener, &err);
1639 g_assert_no_error (err);
1640
1641 addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1642 saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1643 g_object_unref (addr);
1644 g_object_unref (boundaddr);
1645
1646 if (socket_type == G_SOCKET_TYPE_STREAM)
1647 {
1648 g_socket_listen (listener, &err);
1649 g_assert_no_error (err);
1650 g_socket_connect (client, saddr, NULL, &err);
1651 g_assert_no_error (err);
1652
1653 server = g_socket_accept (listener, NULL, &err);
1654 g_assert_no_error (err);
1655 g_socket_set_blocking (server, FALSE);
1656 g_object_unref (listener);
1657 }
1658 else
1659 server = listener;
1660
1661 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1662 g_assert_no_error (err);
1663
1664 while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1665 ;
1666 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1667
1668 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1669 g_assert_no_error (err);
1670
1671 /* We need to wait until the data has actually been copied into the
1672 * server socket's buffers, but g_socket_condition_wait() won't help
1673 * here since the socket is definitely already readable. So there's
1674 * a race condition in checking its available bytes. In the TCP
1675 * case, we poll for a bit until the new data shows up. In the UDP
1676 * case, there's not much we can do, but at least the failure mode
1677 * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1678 */
1679 if (socket_type == G_SOCKET_TYPE_STREAM)
1680 {
1681 int tries;
1682
1683 for (tries = 0; tries < 100; tries++)
1684 {
1685 if (g_socket_get_available_bytes (server) > sizeof (data))
1686 break;
1687 g_usleep (100000);
1688 }
1689
1690 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1691 }
1692 else
1693 {
1694 g_usleep (100000);
1695 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1696 }
1697
1698 g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1699 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1700 g_assert_no_error (err);
1701
1702 if (socket_type == G_SOCKET_TYPE_STREAM)
1703 {
1704 g_assert_cmpint (nread, ==, 2 * sizeof (data));
1705 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1706 }
1707 else
1708 {
1709 g_assert_cmpint (nread, ==, sizeof (data));
1710 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1711 }
1712
1713 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1714 if (socket_type == G_SOCKET_TYPE_STREAM)
1715 {
1716 g_assert_cmpint (nread, ==, -1);
1717 g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1718 g_clear_error (&err);
1719 }
1720 else
1721 {
1722 g_assert_cmpint (nread, ==, sizeof (data));
1723 g_assert_no_error (err);
1724 }
1725
1726 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1727
1728 g_socket_close (server, &err);
1729 g_assert_no_error (err);
1730
1731 g_object_unref (saddr);
1732 g_object_unref (server);
1733 g_object_unref (client);
1734 }
1735
1736 typedef struct {
1737 GInputStream *is;
1738 GOutputStream *os;
1739 const guint8 *write_data;
1740 guint8 *read_data;
1741 } TestReadWriteData;
1742
1743 static gpointer
test_read_write_write_thread(gpointer user_data)1744 test_read_write_write_thread (gpointer user_data)
1745 {
1746 TestReadWriteData *data = user_data;
1747 gsize bytes_written;
1748 GError *error = NULL;
1749 gboolean res;
1750
1751 res = g_output_stream_write_all (data->os, data->write_data, 1024, &bytes_written, NULL, &error);
1752 g_assert_true (res);
1753 g_assert_no_error (error);
1754 g_assert_cmpint (bytes_written, ==, 1024);
1755
1756 return NULL;
1757 }
1758
1759 static gpointer
test_read_write_read_thread(gpointer user_data)1760 test_read_write_read_thread (gpointer user_data)
1761 {
1762 TestReadWriteData *data = user_data;
1763 gsize bytes_read;
1764 GError *error = NULL;
1765 gboolean res;
1766
1767 res = g_input_stream_read_all (data->is, data->read_data, 1024, &bytes_read, NULL, &error);
1768 g_assert_true (res);
1769 g_assert_no_error (error);
1770 g_assert_cmpint (bytes_read, ==, 1024);
1771
1772 return NULL;
1773 }
1774
1775 static gpointer
test_read_write_writev_thread(gpointer user_data)1776 test_read_write_writev_thread (gpointer user_data)
1777 {
1778 TestReadWriteData *data = user_data;
1779 gsize bytes_written;
1780 GError *error = NULL;
1781 gboolean res;
1782 GOutputVector vectors[3];
1783
1784 vectors[0].buffer = data->write_data;
1785 vectors[0].size = 256;
1786 vectors[1].buffer = data->write_data + 256;
1787 vectors[1].size = 256;
1788 vectors[2].buffer = data->write_data + 512;
1789 vectors[2].size = 512;
1790
1791 res = g_output_stream_writev_all (data->os, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1792 g_assert_true (res);
1793 g_assert_no_error (error);
1794 g_assert_cmpint (bytes_written, ==, 1024);
1795
1796 return NULL;
1797 }
1798
1799 /* test if normal read/write/writev via the GSocket*Streams works on TCP sockets */
1800 static void
test_read_write(gconstpointer user_data)1801 test_read_write (gconstpointer user_data)
1802 {
1803 gboolean writev = GPOINTER_TO_INT (user_data);
1804 GError *err = NULL;
1805 GSocket *listener, *server, *client;
1806 GInetAddress *addr;
1807 GSocketAddress *saddr, *boundaddr;
1808 TestReadWriteData data;
1809 guint8 data_write[1024], data_read[1024];
1810 GSocketConnection *server_stream, *client_stream;
1811 GThread *write_thread, *read_thread;
1812 guint i;
1813
1814 listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1815 G_SOCKET_TYPE_STREAM,
1816 G_SOCKET_PROTOCOL_DEFAULT,
1817 &err);
1818 g_assert_no_error (err);
1819 g_assert (G_IS_SOCKET (listener));
1820
1821 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1822 G_SOCKET_TYPE_STREAM,
1823 G_SOCKET_PROTOCOL_DEFAULT,
1824 &err);
1825 g_assert_no_error (err);
1826 g_assert (G_IS_SOCKET (client));
1827
1828 addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1829 saddr = g_inet_socket_address_new (addr, 0);
1830
1831 g_socket_bind (listener, saddr, TRUE, &err);
1832 g_assert_no_error (err);
1833 g_object_unref (saddr);
1834 g_object_unref (addr);
1835
1836 boundaddr = g_socket_get_local_address (listener, &err);
1837 g_assert_no_error (err);
1838
1839 g_socket_listen (listener, &err);
1840 g_assert_no_error (err);
1841
1842 addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1843 saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1844 g_object_unref (addr);
1845 g_object_unref (boundaddr);
1846
1847 g_socket_connect (client, saddr, NULL, &err);
1848 g_assert_no_error (err);
1849
1850 server = g_socket_accept (listener, NULL, &err);
1851 g_assert_no_error (err);
1852 g_socket_set_blocking (server, FALSE);
1853 g_object_unref (listener);
1854
1855 server_stream = g_socket_connection_factory_create_connection (server);
1856 g_assert_nonnull (server_stream);
1857 client_stream = g_socket_connection_factory_create_connection (client);
1858 g_assert_nonnull (client_stream);
1859
1860 for (i = 0; i < sizeof (data_write); i++)
1861 data_write[i] = i;
1862
1863 data.is = g_io_stream_get_input_stream (G_IO_STREAM (server_stream));
1864 data.os = g_io_stream_get_output_stream (G_IO_STREAM (client_stream));
1865 data.read_data = data_read;
1866 data.write_data = data_write;
1867
1868 if (writev)
1869 write_thread = g_thread_new ("writer", test_read_write_writev_thread, &data);
1870 else
1871 write_thread = g_thread_new ("writer", test_read_write_write_thread, &data);
1872 read_thread = g_thread_new ("reader", test_read_write_read_thread, &data);
1873
1874 g_thread_join (write_thread);
1875 g_thread_join (read_thread);
1876
1877 g_assert_cmpmem (data_write, sizeof data_write, data_read, sizeof data_read);
1878
1879 g_socket_close (server, &err);
1880 g_assert_no_error (err);
1881
1882 g_object_unref (server_stream);
1883 g_object_unref (client_stream);
1884
1885 g_object_unref (saddr);
1886 g_object_unref (server);
1887 g_object_unref (client);
1888 }
1889
1890 int
main(int argc,char * argv[])1891 main (int argc,
1892 char *argv[])
1893 {
1894 GSocket *sock;
1895 GError *error = NULL;
1896
1897 g_test_init (&argc, &argv, NULL);
1898 g_test_bug_base ("https://bugzilla.gnome.org/");
1899
1900 sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1901 G_SOCKET_TYPE_STREAM,
1902 G_SOCKET_PROTOCOL_DEFAULT,
1903 &error);
1904 if (sock != NULL)
1905 {
1906 ipv6_supported = TRUE;
1907 g_object_unref (sock);
1908 }
1909 else
1910 {
1911 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1912 g_clear_error (&error);
1913 }
1914
1915 g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1916 g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1917 g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1918 g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1919 g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1920 g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
1921 g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1922 g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
1923 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1924 g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1925 #endif
1926 g_test_add_func ("/socket/close_graceful", test_close_graceful);
1927 g_test_add_func ("/socket/timed_wait", test_timed_wait);
1928 g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
1929 g_test_add_func ("/socket/address", test_sockaddr);
1930 #ifdef G_OS_UNIX
1931 g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1932 g_test_add_func ("/socket/unix-connection", test_unix_connection);
1933 g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1934 g_test_add_func ("/socket/source-postmortem", test_source_postmortem);
1935 #endif
1936 g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1937 g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1938 g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1939 test_get_available);
1940 g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1941 test_get_available);
1942 g_test_add_data_func ("/socket/read_write", GUINT_TO_POINTER (FALSE),
1943 test_read_write);
1944 g_test_add_data_func ("/socket/read_writev", GUINT_TO_POINTER (TRUE),
1945 test_read_write);
1946
1947 return g_test_run();
1948 }
1949
1950