Branch data Line data Source code
1 : : /* GLib testing framework examples and tests
2 : : *
3 : : * Copyright (C) 2008-2011 Red Hat, Inc.
4 : : *
5 : : * SPDX-License-Identifier: LGPL-2.1-or-later
6 : : *
7 : : * This library is free software; you can redistribute it and/or
8 : : * modify it under the terms of the GNU Lesser General Public
9 : : * License as published by the Free Software Foundation; either
10 : : * version 2.1 of the License, or (at your option) any later version.
11 : : *
12 : : * This library is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : * Lesser General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU Lesser General
18 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 : : */
20 : :
21 : : #include <gio/gio.h>
22 : : #include <glib/gstdio.h>
23 : : #include "glib-private.h"
24 : :
25 : : #include <gio/gcredentialsprivate.h>
26 : : #include <gio/gunixconnection.h>
27 : :
28 : : #ifdef G_OS_UNIX
29 : : #include <errno.h>
30 : : #include <sys/wait.h>
31 : : #include <string.h>
32 : : #include <stdlib.h>
33 : : #include <gio/gnetworking.h>
34 : : #endif
35 : :
36 : : #ifdef G_OS_WIN32
37 : : #include "giowin32-afunix.h"
38 : : #include <io.h>
39 : : #endif
40 : :
41 : : #include "gnetworkingprivate.h"
42 : :
43 : : static gboolean ipv6_supported;
44 : :
45 : : typedef struct {
46 : : GSocket *server; /* (owned) (not nullable) */
47 : : GSocket *client; /* (owned) (nullable) */
48 : : GSocketFamily family;
49 : : GThread *thread; /* (owned) (not nullable) */
50 : : GMainLoop *loop; /* (owned) (nullable) */
51 : : GCancellable *cancellable; /* to shut down dgram echo server thread; (owned) (nullable) */
52 : : } IPTestData;
53 : :
54 : : static void
55 : 26 : ip_test_data_free (IPTestData *data)
56 : : {
57 : 26 : g_clear_object (&data->server);
58 : 26 : g_clear_object (&data->client);
59 : 26 : g_clear_pointer (&data->loop, g_main_loop_unref);
60 : 26 : g_clear_object (&data->cancellable);
61 : :
62 : 26 : g_slice_free (IPTestData, data);
63 : 26 : }
64 : :
65 : : static gpointer
66 : 6 : echo_server_dgram_thread (gpointer user_data)
67 : : {
68 : 6 : IPTestData *data = user_data;
69 : : GSocketAddress *sa;
70 : 6 : GCancellable *cancellable = data->cancellable;
71 : : GSocket *sock;
72 : 6 : GError *error = NULL;
73 : : gssize nread, nwrote;
74 : : gchar buf[128];
75 : :
76 : 6 : sock = data->server;
77 : :
78 : 23 : while (TRUE)
79 : : {
80 : 46 : nread = g_socket_receive_from (sock, &sa, buf, sizeof (buf), cancellable, &error);
81 : 46 : if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
82 : 6 : break;
83 : 40 : g_assert_no_error (error);
84 : 40 : g_assert_cmpint (nread, >=, 0);
85 : :
86 : 40 : nwrote = g_socket_send_to (sock, sa, buf, nread, cancellable, &error);
87 : 40 : if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
88 : 0 : break;
89 : 40 : g_assert_no_error (error);
90 : 40 : g_assert_cmpint (nwrote, ==, nread);
91 : :
92 : 40 : g_object_unref (sa);
93 : : }
94 : :
95 : 6 : g_clear_error (&error);
96 : :
97 : 6 : return NULL;
98 : : }
99 : :
100 : : static gpointer
101 : 14 : echo_server_thread (gpointer user_data)
102 : : {
103 : 14 : IPTestData *data = user_data;
104 : : GSocket *sock;
105 : 14 : GError *error = NULL;
106 : : gssize nread, nwrote;
107 : : gchar buf[128];
108 : :
109 : 14 : sock = g_socket_accept (data->server, NULL, &error);
110 : 14 : g_assert_no_error (error);
111 : :
112 : 16 : while (TRUE)
113 : : {
114 : 32 : nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
115 : 32 : g_assert_no_error (error);
116 : 32 : g_assert_cmpint (nread, >=, 0);
117 : :
118 : 32 : if (nread == 0)
119 : 14 : break;
120 : :
121 : 18 : nwrote = g_socket_send (sock, buf, nread, NULL, &error);
122 : 18 : g_assert_no_error (error);
123 : 18 : g_assert_cmpint (nwrote, ==, nread);
124 : : }
125 : :
126 : 14 : g_socket_close (sock, &error);
127 : 14 : g_assert_no_error (error);
128 : 14 : g_object_unref (sock);
129 : 14 : return NULL;
130 : : }
131 : :
132 : : static IPTestData *
133 : 24 : create_server_full (GSocketFamily family,
134 : : GSocketType socket_type,
135 : : GThreadFunc server_thread,
136 : : gboolean v4mapped,
137 : : GError **error)
138 : : {
139 : : IPTestData *data;
140 : : GSocket *server;
141 : : GSocketAddress *addr;
142 : : GInetAddress *iaddr;
143 : :
144 : 24 : data = g_slice_new0 (IPTestData);
145 : 24 : data->family = family;
146 : :
147 : 36 : data->server = server = g_socket_new (family,
148 : 12 : socket_type,
149 : : G_SOCKET_PROTOCOL_DEFAULT,
150 : 12 : error);
151 : 24 : if (server == NULL)
152 : 0 : goto error;
153 : :
154 : 24 : g_assert_cmpint (g_socket_get_family (server), ==, family);
155 : 24 : g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);
156 : 24 : g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
157 : : #ifdef G_OS_WIN32
158 : 12 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (server)));
159 : : #endif
160 : :
161 : 24 : g_socket_set_blocking (server, TRUE);
162 : :
163 : : #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
164 : 24 : if (v4mapped)
165 : : {
166 : 2 : g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);
167 : 2 : if (!g_socket_speaks_ipv4 (data->server))
168 : : {
169 : 0 : g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
170 : : "IPv6-only server cannot speak IPv4");
171 : 0 : goto error;
172 : : }
173 : 1 : }
174 : : #endif
175 : :
176 : 24 : if (v4mapped)
177 : 2 : iaddr = g_inet_address_new_any (family);
178 : : else
179 : 22 : iaddr = g_inet_address_new_loopback (family);
180 : 24 : addr = g_inet_socket_address_new (iaddr, 0);
181 : 24 : g_object_unref (iaddr);
182 : :
183 : 24 : g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
184 : 24 : if (!g_socket_bind (server, addr, TRUE, error))
185 : : {
186 : 0 : g_object_unref (addr);
187 : 0 : goto error;
188 : : }
189 : 24 : g_object_unref (addr);
190 : :
191 : 24 : addr = g_socket_get_local_address (server, error);
192 : 24 : if (addr == NULL)
193 : 0 : goto error;
194 : 24 : g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
195 : 24 : g_object_unref (addr);
196 : :
197 : 24 : if (socket_type == G_SOCKET_TYPE_STREAM)
198 : : {
199 : 18 : if (!g_socket_listen (server, error))
200 : 0 : goto error;
201 : 9 : }
202 : : else
203 : : {
204 : 6 : data->cancellable = g_cancellable_new ();
205 : : }
206 : :
207 : 24 : data->thread = g_thread_new ("server", server_thread, data);
208 : :
209 : 24 : return data;
210 : :
211 : 0 : error:
212 : 0 : ip_test_data_free (data);
213 : :
214 : 0 : return NULL;
215 : 12 : }
216 : :
217 : : static IPTestData *
218 : 18 : create_server (GSocketFamily family,
219 : : GThreadFunc server_thread,
220 : : gboolean v4mapped,
221 : : GError **error)
222 : : {
223 : 18 : return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped, error);
224 : : }
225 : :
226 : : static const gchar *testbuf = "0123456789abcdef";
227 : :
228 : : static gboolean
229 : 4 : test_ip_async_read_ready (GSocket *client,
230 : : GIOCondition cond,
231 : : gpointer user_data)
232 : : {
233 : 4 : IPTestData *data = user_data;
234 : 4 : GError *error = NULL;
235 : : gssize len;
236 : : gchar buf[128];
237 : :
238 : 4 : g_assert_cmpint (cond, ==, G_IO_IN);
239 : :
240 : 4 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
241 : 4 : g_assert_no_error (error);
242 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
243 : :
244 : 4 : g_assert_cmpstr (testbuf, ==, buf);
245 : :
246 : 4 : g_main_loop_quit (data->loop);
247 : :
248 : 4 : return FALSE;
249 : : }
250 : :
251 : : static gboolean
252 : 4 : test_ip_async_write_ready (GSocket *client,
253 : : GIOCondition cond,
254 : : gpointer user_data)
255 : : {
256 : 4 : IPTestData *data = user_data;
257 : 4 : GError *error = NULL;
258 : : GSource *source;
259 : : gssize len;
260 : :
261 : 4 : g_assert_cmpint (cond, ==, G_IO_OUT);
262 : :
263 : 4 : len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
264 : 4 : g_assert_no_error (error);
265 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
266 : :
267 : 4 : source = g_socket_create_source (client, G_IO_IN, NULL);
268 : 6 : g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
269 : 2 : data, NULL);
270 : 4 : g_source_attach (source, NULL);
271 : 4 : g_source_unref (source);
272 : :
273 : 4 : return FALSE;
274 : : }
275 : :
276 : : static gboolean
277 : 4 : test_ip_async_timed_out (GSocket *client,
278 : : GIOCondition cond,
279 : : gpointer user_data)
280 : : {
281 : 4 : IPTestData *data = user_data;
282 : 4 : GError *error = NULL;
283 : : GSource *source;
284 : : gssize len;
285 : : gchar buf[128];
286 : :
287 : 4 : if (data->family == G_SOCKET_FAMILY_IPV4)
288 : : {
289 : 2 : g_assert_cmpint (cond, ==, G_IO_IN);
290 : 2 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
291 : 2 : g_assert_cmpint (len, ==, -1);
292 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
293 : 2 : g_clear_error (&error);
294 : 1 : }
295 : :
296 : 4 : source = g_socket_create_source (client, G_IO_OUT, NULL);
297 : 6 : g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
298 : 2 : data, NULL);
299 : 4 : g_source_attach (source, NULL);
300 : 4 : g_source_unref (source);
301 : :
302 : 4 : return FALSE;
303 : : }
304 : :
305 : : static gboolean
306 : 4 : test_ip_async_connected (GSocket *client,
307 : : GIOCondition cond,
308 : : gpointer user_data)
309 : : {
310 : 4 : IPTestData *data = user_data;
311 : 4 : GError *error = NULL;
312 : : GSource *source;
313 : : gssize len;
314 : : gchar buf[128];
315 : :
316 : 4 : g_socket_check_connect_result (client, &error);
317 : 4 : g_assert_no_error (error);
318 : : /* We do this after the check_connect_result, since that will give a
319 : : * more useful assertion in case of error.
320 : : */
321 : 4 : g_assert_cmpint (cond, ==, G_IO_OUT);
322 : :
323 : 4 : g_assert_true (g_socket_is_connected (client));
324 : :
325 : : /* This adds 1 second to "make check", so let's just only do it once. */
326 : 4 : if (data->family == G_SOCKET_FAMILY_IPV4)
327 : : {
328 : 2 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
329 : 2 : g_assert_cmpint (len, ==, -1);
330 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
331 : 2 : g_clear_error (&error);
332 : :
333 : 2 : source = g_socket_create_source (client, G_IO_IN, NULL);
334 : 3 : g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
335 : 1 : data, NULL);
336 : 2 : g_source_attach (source, NULL);
337 : 2 : g_source_unref (source);
338 : 1 : }
339 : : else
340 : 2 : test_ip_async_timed_out (client, 0, data);
341 : :
342 : 4 : return FALSE;
343 : : }
344 : :
345 : : static gboolean
346 : 0 : idle_test_ip_async_connected (gpointer user_data)
347 : : {
348 : 0 : IPTestData *data = user_data;
349 : :
350 : 0 : return test_ip_async_connected (data->client, G_IO_OUT, data);
351 : : }
352 : :
353 : : static void
354 : 4 : test_ip_async (GSocketFamily family)
355 : : {
356 : : IPTestData *data;
357 : 4 : GError *error = NULL;
358 : : GSocket *client;
359 : : GSocketAddress *addr;
360 : : GSource *source;
361 : : gssize len;
362 : : gchar buf[128];
363 : :
364 : 4 : data = create_server (family, echo_server_thread, FALSE, &error);
365 : 4 : if (error != NULL)
366 : : {
367 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
368 : 0 : g_clear_error (&error);
369 : 0 : return;
370 : : }
371 : 4 : g_assert_nonnull (data);
372 : :
373 : 4 : addr = g_socket_get_local_address (data->server, &error);
374 : 4 : g_assert_no_error (error);
375 : :
376 : 4 : client = g_socket_new (family,
377 : : G_SOCKET_TYPE_STREAM,
378 : : G_SOCKET_PROTOCOL_DEFAULT,
379 : : &error);
380 : 4 : g_assert_no_error (error);
381 : 4 : data->client = client;
382 : :
383 : 4 : g_assert_cmpint (g_socket_get_family (client), ==, family);
384 : 4 : g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
385 : 4 : g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
386 : :
387 : 4 : g_socket_set_blocking (client, FALSE);
388 : 4 : g_socket_set_timeout (client, 1);
389 : :
390 : 4 : if (g_socket_connect (client, addr, NULL, &error))
391 : : {
392 : 0 : g_assert_no_error (error);
393 : 0 : g_idle_add (idle_test_ip_async_connected, data);
394 : 0 : }
395 : : else
396 : : {
397 : 4 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
398 : 4 : g_clear_error (&error);
399 : 4 : source = g_socket_create_source (client, G_IO_OUT, NULL);
400 : 6 : g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
401 : 2 : data, NULL);
402 : 4 : g_source_attach (source, NULL);
403 : 4 : g_source_unref (source);
404 : : }
405 : 4 : g_object_unref (addr);
406 : :
407 : 4 : data->loop = g_main_loop_new (NULL, TRUE);
408 : 4 : g_main_loop_run (data->loop);
409 : 4 : g_clear_pointer (&data->loop, g_main_loop_unref);
410 : :
411 : 4 : g_socket_shutdown (client, FALSE, TRUE, &error);
412 : 4 : g_assert_no_error (error);
413 : :
414 : 4 : g_thread_join (data->thread);
415 : :
416 : 4 : if (family == G_SOCKET_FAMILY_IPV4)
417 : : {
418 : : /* Test that reading on a remote-closed socket gets back 0 bytes. */
419 : 2 : len = g_socket_receive_with_blocking (client, buf, sizeof (buf),
420 : : TRUE, NULL, &error);
421 : 2 : g_assert_no_error (error);
422 : 2 : g_assert_cmpint (len, ==, 0);
423 : 1 : }
424 : : else
425 : : {
426 : : /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
427 : 2 : len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,
428 : : TRUE, NULL, &error);
429 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
430 : 2 : g_assert_cmpint (len, ==, -1);
431 : 2 : g_clear_error (&error);
432 : : }
433 : :
434 : 4 : g_socket_close (client, &error);
435 : 4 : g_assert_no_error (error);
436 : 4 : g_socket_close (data->server, &error);
437 : 4 : g_assert_no_error (error);
438 : :
439 : 4 : ip_test_data_free (data);
440 : 2 : }
441 : :
442 : : static void
443 : 2 : test_ipv4_async (void)
444 : : {
445 : 2 : test_ip_async (G_SOCKET_FAMILY_IPV4);
446 : 2 : }
447 : :
448 : : static void
449 : 2 : test_ipv6_async (void)
450 : : {
451 : 2 : if (!ipv6_supported)
452 : : {
453 : 0 : g_test_skip ("No support for IPv6");
454 : 0 : return;
455 : : }
456 : :
457 : 2 : test_ip_async (G_SOCKET_FAMILY_IPV6);
458 : 1 : }
459 : :
460 : : static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";
461 : :
462 : : static void
463 : 4 : test_ip_sync (GSocketFamily family)
464 : : {
465 : : IPTestData *data;
466 : 4 : GError *error = NULL;
467 : : GSocket *client;
468 : : GSocketAddress *addr;
469 : : gssize len;
470 : : gchar buf[128];
471 : :
472 : 4 : data = create_server (family, echo_server_thread, FALSE, &error);
473 : 4 : if (error != NULL)
474 : : {
475 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
476 : 0 : g_clear_error (&error);
477 : 0 : return;
478 : : }
479 : :
480 : 4 : addr = g_socket_get_local_address (data->server, &error);
481 : 4 : g_assert_no_error (error);
482 : :
483 : 4 : client = g_socket_new (family,
484 : : G_SOCKET_TYPE_STREAM,
485 : : G_SOCKET_PROTOCOL_DEFAULT,
486 : : &error);
487 : 4 : g_assert_no_error (error);
488 : :
489 : 4 : g_assert_cmpint (g_socket_get_family (client), ==, family);
490 : 4 : g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
491 : 4 : g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
492 : : #ifdef G_OS_WIN32
493 : 2 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (client)));
494 : : #endif
495 : 4 : g_socket_set_blocking (client, TRUE);
496 : 4 : g_socket_set_timeout (client, 1);
497 : :
498 : 4 : g_socket_connect (client, addr, NULL, &error);
499 : 4 : g_assert_no_error (error);
500 : 4 : g_assert_true (g_socket_is_connected (client));
501 : 4 : g_object_unref (addr);
502 : :
503 : : /* This adds 1 second to "make check", so let's just only do it once. */
504 : 4 : if (family == G_SOCKET_FAMILY_IPV4)
505 : : {
506 : 2 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
507 : 2 : g_assert_cmpint (len, ==, -1);
508 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
509 : 2 : g_clear_error (&error);
510 : 1 : }
511 : :
512 : 4 : len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
513 : 4 : g_assert_no_error (error);
514 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
515 : :
516 : 4 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
517 : 4 : g_assert_no_error (error);
518 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
519 : :
520 : 4 : g_assert_cmpstr (testbuf, ==, buf);
521 : :
522 : : {
523 : 4 : GOutputVector v[7] = { { NULL, 0 }, };
524 : :
525 : 4 : v[0].buffer = testbuf2 + 0;
526 : 4 : v[0].size = 3;
527 : 4 : v[1].buffer = testbuf2 + 3;
528 : 4 : v[1].size = 5;
529 : 4 : v[2].buffer = testbuf2 + 3 + 5;
530 : 4 : v[2].size = 0;
531 : 4 : v[3].buffer = testbuf2 + 3 + 5;
532 : 4 : v[3].size = 6;
533 : 4 : v[4].buffer = testbuf2 + 3 + 5 + 6;
534 : 4 : v[4].size = 2;
535 : 4 : v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
536 : 4 : v[5].size = 1;
537 : 4 : v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
538 : 4 : v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
539 : :
540 : 4 : len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
541 : 4 : g_assert_no_error (error);
542 : 4 : g_assert_cmpint (len, ==, strlen (testbuf2));
543 : :
544 : 4 : memset (buf, 0, sizeof (buf));
545 : 4 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
546 : 4 : g_assert_no_error (error);
547 : 4 : g_assert_cmpint (len, ==, strlen (testbuf2));
548 : 4 : g_assert_cmpstr (testbuf2, ==, buf);
549 : : }
550 : :
551 : 4 : g_socket_shutdown (client, FALSE, TRUE, &error);
552 : 4 : g_assert_no_error (error);
553 : :
554 : 4 : g_thread_join (data->thread);
555 : :
556 : 4 : if (family == G_SOCKET_FAMILY_IPV4)
557 : : {
558 : : /* Test that reading on a remote-closed socket gets back 0 bytes. */
559 : 2 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
560 : 2 : g_assert_no_error (error);
561 : 2 : g_assert_cmpint (len, ==, 0);
562 : 1 : }
563 : : else
564 : : {
565 : : /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
566 : 2 : len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
567 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
568 : 2 : g_assert_cmpint (len, ==, -1);
569 : 2 : g_clear_error (&error);
570 : : }
571 : :
572 : 4 : g_socket_close (client, &error);
573 : 4 : g_assert_no_error (error);
574 : 4 : g_socket_close (data->server, &error);
575 : 4 : g_assert_no_error (error);
576 : :
577 : 4 : g_object_unref (client);
578 : :
579 : 4 : ip_test_data_free (data);
580 : 2 : }
581 : :
582 : : static void
583 : 2 : test_ipv4_sync (void)
584 : : {
585 : 2 : test_ip_sync (G_SOCKET_FAMILY_IPV4);
586 : 2 : }
587 : :
588 : : static void
589 : 2 : test_ipv6_sync (void)
590 : : {
591 : 2 : if (!ipv6_supported)
592 : : {
593 : 0 : g_test_skip ("No support for IPv6");
594 : 0 : return;
595 : : }
596 : :
597 : 2 : test_ip_sync (G_SOCKET_FAMILY_IPV6);
598 : 1 : }
599 : :
600 : : static void
601 : 4 : test_ip_sync_dgram (GSocketFamily family)
602 : : {
603 : : IPTestData *data;
604 : 4 : GError *error = NULL;
605 : : GSocket *client;
606 : : GSocketAddress *dest_addr;
607 : : gssize len;
608 : : gchar buf[128];
609 : :
610 : 4 : data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
611 : : echo_server_dgram_thread, FALSE, &error);
612 : 4 : if (error != NULL)
613 : : {
614 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
615 : 0 : g_clear_error (&error);
616 : 0 : return;
617 : : }
618 : :
619 : 4 : dest_addr = g_socket_get_local_address (data->server, &error);
620 : 4 : g_assert_no_error (error);
621 : :
622 : 4 : client = g_socket_new (family,
623 : : G_SOCKET_TYPE_DATAGRAM,
624 : : G_SOCKET_PROTOCOL_DEFAULT,
625 : : &error);
626 : 4 : g_assert_no_error (error);
627 : :
628 : 4 : g_assert_cmpint (g_socket_get_family (client), ==, family);
629 : 4 : g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
630 : 4 : g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
631 : : #ifdef G_OS_WIN32
632 : 2 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (client)));
633 : : #endif
634 : :
635 : 4 : g_socket_set_blocking (client, TRUE);
636 : 4 : g_socket_set_timeout (client, 1);
637 : :
638 : 4 : len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
639 : 4 : g_assert_no_error (error);
640 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
641 : :
642 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
643 : 4 : g_assert_no_error (error);
644 : 4 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
645 : :
646 : 4 : g_assert_cmpstr (testbuf, ==, buf);
647 : :
648 : : {
649 : 4 : GOutputMessage m[3] = { { NULL, NULL, 0, 0, NULL, 0 }, };
650 : 4 : GInputMessage im[3] = { { NULL, NULL, 0, 0, 0, NULL, 0 }, };
651 : 4 : GOutputVector v[7] = { { NULL, 0 }, };
652 : 4 : GInputVector iv[7] = { { NULL, 0 }, };
653 : :
654 : 4 : v[0].buffer = testbuf2 + 0;
655 : 4 : v[0].size = 3;
656 : 4 : v[1].buffer = testbuf2 + 3;
657 : 4 : v[1].size = 5;
658 : 4 : v[2].buffer = testbuf2 + 3 + 5;
659 : 4 : v[2].size = 0;
660 : 4 : v[3].buffer = testbuf2 + 3 + 5;
661 : 4 : v[3].size = 6;
662 : 4 : v[4].buffer = testbuf2 + 3 + 5 + 6;
663 : 4 : v[4].size = 2;
664 : 4 : v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
665 : 4 : v[5].size = 1;
666 : 4 : v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
667 : 4 : v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
668 : :
669 : 4 : iv[0].buffer = buf + 0;
670 : 4 : iv[0].size = 3;
671 : 4 : iv[1].buffer = buf + 3;
672 : 4 : iv[1].size = 5;
673 : 4 : iv[2].buffer = buf + 3 + 5;
674 : 4 : iv[2].size = 0;
675 : 4 : iv[3].buffer = buf + 3 + 5;
676 : 4 : iv[3].size = 6;
677 : 4 : iv[4].buffer = buf + 3 + 5 + 6;
678 : 4 : iv[4].size = 2;
679 : 4 : iv[5].buffer = buf + 3 + 5 + 6 + 2;
680 : 4 : iv[5].size = 1;
681 : 4 : iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;
682 : 4 : iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);
683 : :
684 : 4 : len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
685 : 4 : g_assert_no_error (error);
686 : 4 : g_assert_cmpint (len, ==, strlen (testbuf2));
687 : :
688 : 4 : memset (buf, 0, sizeof (buf));
689 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
690 : 4 : g_assert_no_error (error);
691 : 4 : g_assert_cmpint (len, ==, strlen (testbuf2));
692 : 4 : g_assert_cmpstr (testbuf2, ==, buf);
693 : :
694 : 4 : m[0].vectors = &v[0];
695 : 4 : m[0].num_vectors = 1;
696 : 4 : m[0].address = dest_addr;
697 : 4 : m[1].vectors = &v[0];
698 : 4 : m[1].num_vectors = 6;
699 : 4 : m[1].address = dest_addr;
700 : 4 : m[2].vectors = &v[6];
701 : 4 : m[2].num_vectors = 1;
702 : 4 : m[2].address = dest_addr;
703 : :
704 : 4 : len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
705 : 4 : g_assert_no_error (error);
706 : 4 : g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
707 : 4 : g_assert_cmpint (m[0].bytes_sent, ==, 3);
708 : 4 : g_assert_cmpint (m[1].bytes_sent, ==, 17);
709 : 4 : g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
710 : :
711 : 4 : memset (buf, 0, sizeof (buf));
712 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
713 : 4 : g_assert_no_error (error);
714 : 4 : g_assert_cmpint (len, ==, 3);
715 : :
716 : 4 : memset (buf, 0, sizeof (buf));
717 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
718 : 4 : g_assert_no_error (error);
719 : : /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
720 : 4 : g_assert_cmpint (len, ==, 17);
721 : 6 : g_assert_cmpmem (testbuf2, 17, buf, 17);
722 : :
723 : 4 : memset (buf, 0, sizeof (buf));
724 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
725 : 4 : g_assert_no_error (error);
726 : 4 : g_assert_cmpint (len, ==, v[6].size);
727 : 4 : g_assert_cmpstr (buf, ==, v[6].buffer);
728 : :
729 : : /* reset since we're re-using the message structs */
730 : 4 : m[0].bytes_sent = 0;
731 : 4 : m[1].bytes_sent = 0;
732 : 4 : m[2].bytes_sent = 0;
733 : :
734 : : /* now try receiving multiple messages */
735 : 4 : len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
736 : 4 : g_assert_no_error (error);
737 : 4 : g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
738 : 4 : g_assert_cmpint (m[0].bytes_sent, ==, 3);
739 : 4 : g_assert_cmpint (m[1].bytes_sent, ==, 17);
740 : 4 : g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
741 : :
742 : 4 : im[0].vectors = &iv[0];
743 : 4 : im[0].num_vectors = 1;
744 : 4 : im[1].vectors = &iv[0];
745 : 4 : im[1].num_vectors = 6;
746 : 4 : im[2].vectors = &iv[6];
747 : 4 : im[2].num_vectors = 1;
748 : :
749 : 4 : memset (buf, 0, sizeof (buf));
750 : 4 : len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,
751 : : NULL, &error);
752 : 4 : g_assert_no_error (error);
753 : 4 : g_assert_cmpint (len, ==, G_N_ELEMENTS (im));
754 : :
755 : 4 : g_assert_cmpuint (im[0].bytes_received, ==, 3);
756 : : /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
757 : 4 : g_assert_cmpuint (im[1].bytes_received, ==, 17);
758 : 4 : g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);
759 : :
760 : : /* reset since we're re-using the message structs */
761 : 4 : m[0].bytes_sent = 0;
762 : 4 : m[1].bytes_sent = 0;
763 : 4 : m[2].bytes_sent = 0;
764 : :
765 : : /* now try to generate an early return by omitting the destination address on [1] */
766 : 4 : m[1].address = NULL;
767 : 4 : len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
768 : 4 : g_assert_no_error (error);
769 : 4 : g_assert_cmpint (len, ==, 1);
770 : :
771 : 4 : g_assert_cmpint (m[0].bytes_sent, ==, 3);
772 : 4 : g_assert_cmpint (m[1].bytes_sent, ==, 0);
773 : 4 : g_assert_cmpint (m[2].bytes_sent, ==, 0);
774 : :
775 : : /* reset since we're re-using the message structs */
776 : 4 : m[0].bytes_sent = 0;
777 : 4 : m[1].bytes_sent = 0;
778 : 4 : m[2].bytes_sent = 0;
779 : :
780 : : /* now try to generate an error by omitting all destination addresses */
781 : 4 : m[0].address = NULL;
782 : 4 : m[1].address = NULL;
783 : 4 : m[2].address = NULL;
784 : 4 : len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
785 : : /* This error code may vary between platforms and over time; it is not guaranteed API: */
786 : : #ifndef G_OS_WIN32
787 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_DESTINATION_UNSET);
788 : : #else
789 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_CONNECTED);
790 : : #endif
791 : 4 : g_clear_error (&error);
792 : 4 : g_assert_cmpint (len, ==, -1);
793 : :
794 : 4 : g_assert_cmpint (m[0].bytes_sent, ==, 0);
795 : 4 : g_assert_cmpint (m[1].bytes_sent, ==, 0);
796 : 4 : g_assert_cmpint (m[2].bytes_sent, ==, 0);
797 : :
798 : 4 : len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
799 : 4 : g_assert_cmpint (len, ==, 3);
800 : : }
801 : :
802 : 4 : g_cancellable_cancel (data->cancellable);
803 : :
804 : 4 : g_thread_join (data->thread);
805 : :
806 : 4 : g_socket_close (client, &error);
807 : 4 : g_assert_no_error (error);
808 : 4 : g_socket_close (data->server, &error);
809 : 4 : g_assert_no_error (error);
810 : :
811 : 4 : g_object_unref (client);
812 : 4 : g_object_unref (dest_addr);
813 : :
814 : 4 : ip_test_data_free (data);
815 : 2 : }
816 : :
817 : : static void
818 : 2 : test_ipv4_sync_dgram (void)
819 : : {
820 : 2 : test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
821 : 2 : }
822 : :
823 : : static void
824 : 2 : test_ipv6_sync_dgram (void)
825 : : {
826 : 2 : if (!ipv6_supported)
827 : : {
828 : 0 : g_test_skip ("No support for IPv6");
829 : 0 : return;
830 : : }
831 : :
832 : 2 : test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
833 : 1 : }
834 : :
835 : : static gpointer
836 : 4 : cancellable_thread_cb (gpointer data)
837 : : {
838 : 4 : GCancellable *cancellable = data;
839 : :
840 : 4 : g_usleep ((guint64) (0.1 * G_USEC_PER_SEC));
841 : 4 : g_cancellable_cancel (cancellable);
842 : 4 : g_object_unref (cancellable);
843 : :
844 : 4 : return NULL;
845 : : }
846 : :
847 : : static void
848 : 4 : test_ip_sync_dgram_timeouts (GSocketFamily family)
849 : : {
850 : 4 : GError *error = NULL;
851 : 4 : GSocket *client = NULL;
852 : 4 : GCancellable *cancellable = NULL;
853 : 4 : GThread *cancellable_thread = NULL;
854 : : gssize len;
855 : : #ifdef G_OS_WIN32
856 : : GInetAddress *iaddr;
857 : : GSocketAddress *addr;
858 : : #endif
859 : :
860 : 4 : client = g_socket_new (family,
861 : : G_SOCKET_TYPE_DATAGRAM,
862 : : G_SOCKET_PROTOCOL_DEFAULT,
863 : : &error);
864 : 4 : g_assert_no_error (error);
865 : :
866 : 4 : g_assert_cmpint (g_socket_get_family (client), ==, family);
867 : 4 : g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
868 : 4 : g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
869 : : #ifdef G_OS_WIN32
870 : 2 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (client)));
871 : : #endif
872 : :
873 : : #ifdef G_OS_WIN32
874 : : /* Winsock can't recv() on unbound udp socket */
875 : 2 : iaddr = g_inet_address_new_loopback (family);
876 : 2 : addr = g_inet_socket_address_new (iaddr, 0);
877 : 2 : g_object_unref (iaddr);
878 : 2 : g_socket_bind (client, addr, TRUE, &error);
879 : 2 : g_object_unref (addr);
880 : 2 : g_assert_no_error (error);
881 : : #endif
882 : :
883 : : /* No overall timeout: test the per-operation timeouts instead. */
884 : 4 : g_socket_set_timeout (client, 0);
885 : :
886 : 4 : cancellable = g_cancellable_new ();
887 : :
888 : : /* Check for timeouts when no server is running. */
889 : : {
890 : : gint64 start_time;
891 : 4 : GInputMessage im = { NULL, NULL, 0, 0, 0, NULL, 0 };
892 : 4 : GInputVector iv = { NULL, 0 };
893 : : guint8 buf[128];
894 : :
895 : 4 : iv.buffer = buf;
896 : 4 : iv.size = sizeof (buf);
897 : :
898 : 4 : im.vectors = &iv;
899 : 4 : im.num_vectors = 1;
900 : :
901 : 4 : memset (buf, 0, sizeof (buf));
902 : :
903 : : /* Try a non-blocking read. */
904 : 4 : g_socket_set_blocking (client, FALSE);
905 : 4 : len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
906 : : NULL, &error);
907 : 4 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
908 : 4 : g_assert_cmpint (len, ==, -1);
909 : 4 : g_clear_error (&error);
910 : :
911 : : /* Try a timeout read. Can’t really validate the time taken more than
912 : : * checking it’s positive. */
913 : 4 : g_socket_set_timeout (client, 1);
914 : 4 : g_socket_set_blocking (client, TRUE);
915 : 4 : start_time = g_get_monotonic_time ();
916 : 4 : len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
917 : : NULL, &error);
918 : 4 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
919 : 4 : g_assert_cmpint (len, ==, -1);
920 : 4 : g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
921 : 4 : g_clear_error (&error);
922 : :
923 : : /* Try a blocking read, cancelled from another thread. */
924 : 4 : g_socket_set_timeout (client, 0);
925 : 4 : cancellable_thread = g_thread_new ("cancellable",
926 : : cancellable_thread_cb,
927 : 2 : g_object_ref (cancellable));
928 : :
929 : 4 : start_time = g_get_monotonic_time ();
930 : 6 : len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
931 : 2 : cancellable, &error);
932 : 4 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
933 : 4 : g_assert_cmpint (len, ==, -1);
934 : 4 : g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
935 : 4 : g_clear_error (&error);
936 : :
937 : 4 : g_thread_join (cancellable_thread);
938 : : }
939 : :
940 : 4 : g_socket_close (client, &error);
941 : 4 : g_assert_no_error (error);
942 : :
943 : 4 : g_object_unref (client);
944 : 4 : g_object_unref (cancellable);
945 : 4 : }
946 : :
947 : : static void
948 : 2 : test_ipv4_sync_dgram_timeouts (void)
949 : : {
950 : 2 : test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
951 : 2 : }
952 : :
953 : : static void
954 : 2 : test_ipv6_sync_dgram_timeouts (void)
955 : : {
956 : 2 : if (!ipv6_supported)
957 : : {
958 : 0 : g_test_skip ("No support for IPv6");
959 : 0 : return;
960 : : }
961 : :
962 : 2 : test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
963 : 1 : }
964 : :
965 : : static gpointer
966 : 2 : graceful_server_thread (gpointer user_data)
967 : : {
968 : 2 : IPTestData *data = user_data;
969 : : GSocket *sock;
970 : 2 : GError *error = NULL;
971 : : gssize len;
972 : :
973 : 2 : sock = g_socket_accept (data->server, NULL, &error);
974 : 2 : g_assert_no_error (error);
975 : :
976 : 2 : len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
977 : 2 : g_assert_no_error (error);
978 : 2 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
979 : :
980 : 2 : return sock;
981 : : }
982 : :
983 : : static void
984 : 2 : test_close_graceful (void)
985 : : {
986 : 2 : GSocketFamily family = G_SOCKET_FAMILY_IPV4;
987 : : IPTestData *data;
988 : 2 : GError *error = NULL;
989 : : GSocket *client, *server;
990 : : GSocketAddress *addr;
991 : : gssize len;
992 : : gchar buf[128];
993 : :
994 : 2 : data = create_server (family, graceful_server_thread, FALSE, &error);
995 : 2 : if (error != NULL)
996 : : {
997 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
998 : 0 : g_clear_error (&error);
999 : 0 : return;
1000 : : }
1001 : :
1002 : 2 : addr = g_socket_get_local_address (data->server, &error);
1003 : 2 : g_assert_no_error (error);
1004 : :
1005 : 2 : client = g_socket_new (family,
1006 : : G_SOCKET_TYPE_STREAM,
1007 : : G_SOCKET_PROTOCOL_DEFAULT,
1008 : : &error);
1009 : 2 : g_assert_no_error (error);
1010 : :
1011 : 2 : g_assert_cmpint (g_socket_get_family (client), ==, family);
1012 : 2 : g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
1013 : 2 : g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
1014 : : #ifdef G_OS_WIN32
1015 : 1 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (client)));
1016 : : #endif
1017 : :
1018 : 2 : g_socket_set_blocking (client, TRUE);
1019 : 2 : g_socket_set_timeout (client, 1);
1020 : :
1021 : 2 : g_socket_connect (client, addr, NULL, &error);
1022 : 2 : g_assert_no_error (error);
1023 : 2 : g_assert_true (g_socket_is_connected (client));
1024 : 2 : g_object_unref (addr);
1025 : :
1026 : 2 : server = g_thread_join (data->thread);
1027 : :
1028 : : /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
1029 : 2 : g_socket_shutdown (server, FALSE, TRUE, &error);
1030 : 2 : g_assert_no_error (error);
1031 : :
1032 : : /* we must timeout */
1033 : 2 : g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
1034 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1035 : 2 : g_clear_error (&error);
1036 : :
1037 : : /* check that the remaining data is received */
1038 : 2 : len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
1039 : 2 : g_assert_no_error (error);
1040 : 2 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1041 : :
1042 : : /* and only then the connection is closed */
1043 : 2 : len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
1044 : 2 : g_assert_no_error (error);
1045 : 2 : g_assert_cmpint (len, ==, 0);
1046 : :
1047 : 2 : g_socket_close (server, &error);
1048 : 2 : g_assert_no_error (error);
1049 : :
1050 : 2 : g_socket_close (client, &error);
1051 : 2 : g_assert_no_error (error);
1052 : :
1053 : 2 : g_object_unref (server);
1054 : 2 : g_object_unref (client);
1055 : :
1056 : 2 : ip_test_data_free (data);
1057 : 1 : }
1058 : :
1059 : : #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1060 : : static gpointer
1061 : 2 : v4mapped_server_thread (gpointer user_data)
1062 : : {
1063 : 2 : IPTestData *data = user_data;
1064 : : GSocket *sock;
1065 : 2 : GError *error = NULL;
1066 : : GSocketAddress *addr;
1067 : :
1068 : 2 : sock = g_socket_accept (data->server, NULL, &error);
1069 : 2 : g_assert_no_error (error);
1070 : :
1071 : 2 : g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
1072 : :
1073 : 2 : addr = g_socket_get_local_address (sock, &error);
1074 : 2 : g_assert_no_error (error);
1075 : 2 : g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1076 : 2 : g_object_unref (addr);
1077 : :
1078 : 2 : addr = g_socket_get_remote_address (sock, &error);
1079 : 2 : g_assert_no_error (error);
1080 : 2 : g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1081 : 2 : g_object_unref (addr);
1082 : :
1083 : 2 : g_socket_close (sock, &error);
1084 : 2 : g_assert_no_error (error);
1085 : 2 : g_object_unref (sock);
1086 : 2 : return NULL;
1087 : : }
1088 : :
1089 : : static void
1090 : 2 : test_ipv6_v4mapped (void)
1091 : : {
1092 : : IPTestData *data;
1093 : 2 : GError *error = NULL;
1094 : : GSocket *client;
1095 : : GSocketAddress *addr, *v4addr;
1096 : : GInetAddress *iaddr;
1097 : :
1098 : 2 : if (!ipv6_supported)
1099 : : {
1100 : 0 : g_test_skip ("No support for IPv6");
1101 : 0 : return;
1102 : : }
1103 : :
1104 : 2 : data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE, &error);
1105 : 2 : if (error != NULL)
1106 : : {
1107 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
1108 : 0 : g_clear_error (&error);
1109 : 0 : return;
1110 : : }
1111 : :
1112 : 2 : client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1113 : : G_SOCKET_TYPE_STREAM,
1114 : : G_SOCKET_PROTOCOL_DEFAULT,
1115 : : &error);
1116 : 2 : g_assert_no_error (error);
1117 : :
1118 : 2 : g_socket_set_blocking (client, TRUE);
1119 : 2 : g_socket_set_timeout (client, 1);
1120 : :
1121 : 2 : addr = g_socket_get_local_address (data->server, &error);
1122 : 2 : g_assert_no_error (error);
1123 : 2 : iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1124 : 2 : v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1125 : 2 : g_object_unref (iaddr);
1126 : 2 : g_object_unref (addr);
1127 : :
1128 : 2 : g_socket_connect (client, v4addr, NULL, &error);
1129 : 2 : g_assert_no_error (error);
1130 : 2 : g_assert_true (g_socket_is_connected (client));
1131 : :
1132 : 2 : g_thread_join (data->thread);
1133 : :
1134 : 2 : g_socket_close (client, &error);
1135 : 2 : g_assert_no_error (error);
1136 : 2 : g_socket_close (data->server, &error);
1137 : 2 : g_assert_no_error (error);
1138 : :
1139 : 2 : g_object_unref (client);
1140 : 2 : g_object_unref (v4addr);
1141 : :
1142 : 2 : ip_test_data_free (data);
1143 : 1 : }
1144 : : #endif
1145 : :
1146 : : static void
1147 : 2 : test_timed_wait (void)
1148 : : {
1149 : : IPTestData *data;
1150 : 2 : GError *error = NULL;
1151 : : GSocket *client;
1152 : : GSocketAddress *addr;
1153 : : gint64 start_time;
1154 : : gint poll_duration;
1155 : :
1156 : 2 : if (!g_test_thorough ())
1157 : : {
1158 : 2 : g_test_skip ("Not running timing heavy test");
1159 : 2 : return;
1160 : : }
1161 : :
1162 : 0 : data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1163 : 0 : if (error != NULL)
1164 : : {
1165 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
1166 : 0 : g_clear_error (&error);
1167 : 0 : return;
1168 : : }
1169 : :
1170 : 0 : addr = g_socket_get_local_address (data->server, &error);
1171 : 0 : g_assert_no_error (error);
1172 : :
1173 : 0 : client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1174 : : G_SOCKET_TYPE_STREAM,
1175 : : G_SOCKET_PROTOCOL_DEFAULT,
1176 : : &error);
1177 : 0 : g_assert_no_error (error);
1178 : :
1179 : 0 : g_socket_set_blocking (client, TRUE);
1180 : 0 : g_socket_set_timeout (client, 1);
1181 : :
1182 : 0 : g_socket_connect (client, addr, NULL, &error);
1183 : 0 : g_assert_no_error (error);
1184 : 0 : g_object_unref (addr);
1185 : :
1186 : 0 : start_time = g_get_monotonic_time ();
1187 : 0 : g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1188 : : NULL, &error);
1189 : 0 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1190 : 0 : g_clear_error (&error);
1191 : 0 : poll_duration = g_get_monotonic_time () - start_time;
1192 : :
1193 : 0 : g_assert_cmpint (poll_duration, >=, 98000);
1194 : 0 : g_assert_cmpint (poll_duration, <, 112000);
1195 : :
1196 : 0 : g_socket_close (client, &error);
1197 : 0 : g_assert_no_error (error);
1198 : :
1199 : 0 : g_thread_join (data->thread);
1200 : :
1201 : 0 : g_socket_close (data->server, &error);
1202 : 0 : g_assert_no_error (error);
1203 : :
1204 : 0 : g_object_unref (client);
1205 : :
1206 : 0 : ip_test_data_free (data);
1207 : 1 : }
1208 : :
1209 : : static int
1210 : 2 : duplicate_socket_fd (int fd)
1211 : : {
1212 : : #ifdef G_OS_WIN32
1213 : : WSAPROTOCOL_INFO info;
1214 : :
1215 : 2 : if (WSADuplicateSocket ((SOCKET)fd,
1216 : 1 : GetCurrentProcessId (),
1217 : : &info))
1218 : : {
1219 : 0 : gchar *emsg = g_win32_error_message (WSAGetLastError ());
1220 : 0 : g_test_message ("Error duplicating socket: %s", emsg);
1221 : 0 : g_free (emsg);
1222 : 0 : return -1;
1223 : : }
1224 : :
1225 : 1 : return (int)WSASocket (FROM_PROTOCOL_INFO,
1226 : : FROM_PROTOCOL_INFO,
1227 : : FROM_PROTOCOL_INFO,
1228 : : &info, 0, 0);
1229 : : #else
1230 : 1 : return dup (fd);
1231 : : #endif
1232 : 1 : }
1233 : :
1234 : : static void
1235 : 2 : test_fd_reuse (void)
1236 : : {
1237 : : IPTestData *data;
1238 : 2 : GError *error = NULL;
1239 : : GSocket *client;
1240 : : GSocket *client2;
1241 : : GSocketAddress *addr;
1242 : : int fd;
1243 : : gssize len;
1244 : : gchar buf[128];
1245 : :
1246 : 2 : g_test_bug ("https://bugzilla.gnome.org/show_bug.cgi?id=741707");
1247 : :
1248 : 2 : data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1249 : 2 : if (error != NULL)
1250 : : {
1251 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
1252 : 0 : g_clear_error (&error);
1253 : 0 : return;
1254 : : }
1255 : :
1256 : 2 : addr = g_socket_get_local_address (data->server, &error);
1257 : 2 : g_assert_no_error (error);
1258 : :
1259 : 2 : client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1260 : : G_SOCKET_TYPE_STREAM,
1261 : : G_SOCKET_PROTOCOL_DEFAULT,
1262 : : &error);
1263 : 2 : g_assert_no_error (error);
1264 : :
1265 : 2 : g_socket_set_blocking (client, TRUE);
1266 : 2 : g_socket_set_timeout (client, 1);
1267 : :
1268 : 2 : g_socket_connect (client, addr, NULL, &error);
1269 : 2 : g_assert_no_error (error);
1270 : 2 : g_assert_true (g_socket_is_connected (client));
1271 : 2 : g_object_unref (addr);
1272 : :
1273 : : /* we have to dup otherwise the fd gets closed twice on unref */
1274 : 2 : fd = duplicate_socket_fd (g_socket_get_fd (client));
1275 : 2 : client2 = g_socket_new_from_fd (fd, &error);
1276 : 2 : g_assert_no_error (error);
1277 : :
1278 : 2 : g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1279 : 2 : g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1280 : 2 : g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1281 : : #ifdef G_OS_WIN32
1282 : 1 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (client)));
1283 : : #endif
1284 : :
1285 : 2 : len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1286 : 2 : g_assert_no_error (error);
1287 : 2 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1288 : :
1289 : 2 : len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1290 : 2 : g_assert_no_error (error);
1291 : 2 : g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1292 : :
1293 : 2 : g_assert_cmpstr (testbuf, ==, buf);
1294 : :
1295 : 2 : g_socket_shutdown (client, FALSE, TRUE, &error);
1296 : 2 : g_assert_no_error (error);
1297 : : /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1298 : : * on Linux, but return ENOTCONN on OS X.
1299 : : */
1300 : 2 : g_socket_shutdown (client2, FALSE, TRUE, NULL);
1301 : :
1302 : 2 : g_thread_join (data->thread);
1303 : :
1304 : 2 : g_socket_close (client, &error);
1305 : 2 : g_assert_no_error (error);
1306 : 2 : g_socket_close (client2, &error);
1307 : 2 : g_assert_no_error (error);
1308 : 2 : g_socket_close (data->server, &error);
1309 : 2 : g_assert_no_error (error);
1310 : :
1311 : 2 : g_assert_cmpint (g_socket_get_fd (client), ==, -1);
1312 : 2 : g_assert_cmpint (g_socket_get_fd (client2), ==, -1);
1313 : 2 : g_assert_cmpint (g_socket_get_fd (data->server), ==, -1);
1314 : :
1315 : 2 : g_object_unref (client);
1316 : 2 : g_object_unref (client2);
1317 : :
1318 : 2 : ip_test_data_free (data);
1319 : 1 : }
1320 : :
1321 : : static void
1322 : 2 : test_sockaddr (void)
1323 : : {
1324 : : struct sockaddr_in6 sin6, gsin6;
1325 : : GSocketAddress *saddr;
1326 : : GInetSocketAddress *isaddr;
1327 : : GInetAddress *iaddr;
1328 : 2 : GError *error = NULL;
1329 : :
1330 : 2 : memset (&sin6, 0, sizeof (sin6));
1331 : 2 : sin6.sin6_family = AF_INET6;
1332 : 2 : sin6.sin6_addr = in6addr_loopback;
1333 : 2 : sin6.sin6_port = g_htons (42);
1334 : 2 : sin6.sin6_scope_id = 17;
1335 : 2 : sin6.sin6_flowinfo = 1729;
1336 : :
1337 : 2 : saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1338 : 3 : g_assert_true (G_IS_INET_SOCKET_ADDRESS (saddr));
1339 : :
1340 : 2 : isaddr = G_INET_SOCKET_ADDRESS (saddr);
1341 : 2 : iaddr = g_inet_socket_address_get_address (isaddr);
1342 : 2 : g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1343 : 2 : g_assert_true (g_inet_address_get_is_loopback (iaddr));
1344 : :
1345 : 2 : g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1346 : 2 : g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1347 : 2 : g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1348 : :
1349 : 2 : g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1350 : 2 : g_assert_no_error (error);
1351 : :
1352 : 3 : g_assert_cmpmem (&sin6.sin6_addr, sizeof (struct in6_addr), &gsin6.sin6_addr, sizeof (struct in6_addr));
1353 : 2 : g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1354 : 2 : g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1355 : 2 : g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1356 : :
1357 : 2 : g_object_unref (saddr);
1358 : 2 : }
1359 : :
1360 : : static void
1361 : 4 : bind_win32_unixfd (int fd)
1362 : : {
1363 : : #ifdef G_OS_WIN32
1364 : : gsize len;
1365 : : int ret;
1366 : : struct sockaddr_un addr;
1367 : :
1368 : 2 : memset (&addr, 0, sizeof addr);
1369 : 2 : addr.sun_family = AF_UNIX;
1370 : 2 : len = g_snprintf (addr.sun_path, sizeof addr.sun_path, "%s" G_DIR_SEPARATOR_S "%d.sock", g_get_tmp_dir (), fd);
1371 : 2 : g_assert_cmpint (len, <=, sizeof addr.sun_path);
1372 : 2 : ret = bind (fd, (struct sockaddr *)&addr, sizeof addr);
1373 : 2 : g_assert_cmpint (ret, ==, 0);
1374 : 2 : g_remove (addr.sun_path);
1375 : : #endif
1376 : 4 : }
1377 : :
1378 : : static void
1379 : 2 : test_unix_from_fd (void)
1380 : : {
1381 : : gint fd;
1382 : : GError *error;
1383 : : GSocket *s;
1384 : :
1385 : 2 : fd = socket (AF_UNIX, SOCK_STREAM, 0);
1386 : : #ifdef G_OS_WIN32
1387 : 1 : if (fd == -1)
1388 : : {
1389 : 0 : g_test_skip ("AF_UNIX not supported on this Windows system.");
1390 : 0 : return;
1391 : : }
1392 : : #endif
1393 : 2 : g_assert_cmpint (fd, !=, -1);
1394 : :
1395 : 2 : bind_win32_unixfd (fd);
1396 : :
1397 : 2 : error = NULL;
1398 : 2 : s = g_socket_new_from_fd (fd, &error);
1399 : 2 : g_assert_no_error (error);
1400 : 2 : g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1401 : 2 : g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1402 : 2 : g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1403 : : #ifdef G_OS_WIN32
1404 : 1 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (s)));
1405 : : #endif
1406 : 2 : g_object_unref (s);
1407 : 2 : }
1408 : :
1409 : : static void
1410 : 2 : test_unix_connection (void)
1411 : : {
1412 : : gint fd;
1413 : : GError *error;
1414 : : GSocket *s;
1415 : : GSocketConnection *c;
1416 : :
1417 : 2 : fd = socket (AF_UNIX, SOCK_STREAM, 0);
1418 : : #ifdef G_OS_WIN32
1419 : 1 : if (fd == -1)
1420 : : {
1421 : 0 : g_test_skip ("AF_UNIX not supported on this Windows system.");
1422 : 0 : return;
1423 : : }
1424 : : #endif
1425 : 2 : g_assert_cmpint (fd, !=, -1);
1426 : :
1427 : 2 : bind_win32_unixfd (fd);
1428 : :
1429 : 2 : error = NULL;
1430 : 2 : s = g_socket_new_from_fd (fd, &error);
1431 : 2 : g_assert_no_error (error);
1432 : 2 : c = g_socket_connection_factory_create_connection (s);
1433 : 3 : g_assert_true (G_IS_UNIX_CONNECTION (c));
1434 : 2 : g_object_unref (c);
1435 : 2 : g_object_unref (s);
1436 : 2 : }
1437 : :
1438 : : #ifdef G_OS_UNIX
1439 : : static GSocketConnection *
1440 : 2 : create_connection_for_fd (int fd)
1441 : : {
1442 : 2 : GError *err = NULL;
1443 : : GSocket *socket;
1444 : : GSocketConnection *connection;
1445 : :
1446 : 2 : socket = g_socket_new_from_fd (fd, &err);
1447 : 2 : g_assert_no_error (err);
1448 : 2 : g_assert_true (G_IS_SOCKET (socket));
1449 : 2 : connection = g_socket_connection_factory_create_connection (socket);
1450 : 2 : g_assert_true (G_IS_UNIX_CONNECTION (connection));
1451 : 2 : g_object_unref (socket);
1452 : 2 : return connection;
1453 : : }
1454 : :
1455 : : #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1456 : :
1457 : : static void
1458 : 1 : test_unix_connection_ancillary_data (void)
1459 : : {
1460 : 1 : GError *err = NULL;
1461 : : gint pv[2], sv[3];
1462 : : gint status, fd, len;
1463 : : char buffer[1024];
1464 : : pid_t pid;
1465 : :
1466 : 1 : status = pipe (pv);
1467 : 1 : g_assert_cmpint (status, ==, 0);
1468 : :
1469 : 1 : status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1470 : 1 : g_assert_cmpint (status, ==, 0);
1471 : :
1472 : 1 : pid = fork ();
1473 : 2 : g_assert_cmpint (pid, >=, 0);
1474 : :
1475 : : /* Child: close its copy of the write end of the pipe, receive it
1476 : : * again from the parent over the socket, and write some text to it.
1477 : : *
1478 : : * Parent: send the write end of the pipe (still open for the
1479 : : * parent) over the socket, close it, and read some text from the
1480 : : * read end of the pipe.
1481 : : */
1482 : 2 : if (pid == 0)
1483 : : {
1484 : : GSocketConnection *connection;
1485 : :
1486 : 1 : close (sv[1]);
1487 : 1 : connection = create_connection_for_fd (sv[0]);
1488 : :
1489 : 1 : status = close (pv[1]);
1490 : 1 : g_assert_cmpint (status, ==, 0);
1491 : :
1492 : 1 : err = NULL;
1493 : 1 : fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1494 : : &err);
1495 : 1 : g_assert_no_error (err);
1496 : 1 : g_assert_cmpint (fd, >, -1);
1497 : 1 : g_object_unref (connection);
1498 : :
1499 : : do
1500 : 1 : len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1501 : 1 : while (len == -1 && errno == EINTR);
1502 : 1 : g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1503 : 1 : exit (0);
1504 : : }
1505 : : else
1506 : : {
1507 : : GSocketConnection *connection;
1508 : :
1509 : 1 : close (sv[0]);
1510 : 1 : connection = create_connection_for_fd (sv[1]);
1511 : :
1512 : 1 : err = NULL;
1513 : 1 : g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1514 : : &err);
1515 : 1 : g_assert_no_error (err);
1516 : 1 : g_object_unref (connection);
1517 : :
1518 : 1 : status = close (pv[1]);
1519 : 1 : g_assert_cmpint (status, ==, 0);
1520 : :
1521 : 1 : memset (buffer, 0xff, sizeof buffer);
1522 : : do
1523 : 1 : len = read (pv[0], buffer, sizeof buffer);
1524 : 1 : while (len == -1 && errno == EINTR);
1525 : :
1526 : 1 : g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1527 : 1 : g_assert_cmpstr (buffer, ==, TEST_DATA);
1528 : :
1529 : 1 : waitpid (pid, &status, 0);
1530 : 1 : g_assert_true (WIFEXITED (status));
1531 : 1 : g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1532 : : }
1533 : :
1534 : : /* TODO: add test for g_unix_connection_send_credentials() and
1535 : : * g_unix_connection_receive_credentials().
1536 : : */
1537 : 1 : }
1538 : : #endif
1539 : :
1540 : : #ifdef G_OS_WIN32
1541 : : static void
1542 : 1 : test_handle_not_socket (void)
1543 : : {
1544 : 1 : GError *err = NULL;
1545 : 1 : gchar *name = NULL;
1546 : : HANDLE hReadPipe, hWritePipe, h;
1547 : : int fd;
1548 : :
1549 : 1 : g_assert_true (CreatePipe (&hReadPipe, &hWritePipe, NULL, 2048));
1550 : 1 : g_assert_false (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) (hReadPipe));
1551 : 1 : g_assert_false (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) (hWritePipe));
1552 : 1 : CloseHandle (hReadPipe);
1553 : 1 : CloseHandle (hWritePipe);
1554 : :
1555 : 1 : h = (HANDLE) _get_osfhandle (1);
1556 : 1 : g_assert_false (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) (h));
1557 : :
1558 : 1 : fd = g_file_open_tmp (NULL, &name, &err);
1559 : 1 : g_assert_no_error (err);
1560 : 1 : h = (HANDLE) _get_osfhandle (fd);
1561 : 1 : g_assert_false (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) (h));
1562 : 1 : g_close (fd, &err);
1563 : 1 : g_assert_no_error (err);
1564 : 1 : g_unlink (name);
1565 : 1 : g_free (name);
1566 : 1 : }
1567 : : #endif
1568 : :
1569 : : static gboolean
1570 : 2 : postmortem_source_cb (GSocket *socket,
1571 : : GIOCondition condition,
1572 : : gpointer user_data)
1573 : : {
1574 : 2 : gboolean *been_here = user_data;
1575 : :
1576 : 2 : g_assert_cmpint (condition, ==, G_IO_NVAL);
1577 : :
1578 : 2 : *been_here = TRUE;
1579 : 2 : return FALSE;
1580 : : }
1581 : :
1582 : : static void
1583 : 2 : test_source_postmortem (void)
1584 : : {
1585 : : GMainContext *context;
1586 : : GSocket *socket;
1587 : : GSource *source;
1588 : 2 : GError *error = NULL;
1589 : 2 : gboolean callback_visited = FALSE;
1590 : :
1591 : 2 : socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
1592 : : #ifdef G_OS_WIN32
1593 : 1 : if (error)
1594 : : {
1595 : 0 : g_test_skip_printf ("AF_UNIX not supported on this Windows system: %s", error->message);
1596 : 0 : g_clear_error (&error);
1597 : 0 : return;
1598 : : }
1599 : : #endif
1600 : 2 : g_assert_no_error (error);
1601 : :
1602 : 2 : context = g_main_context_new ();
1603 : :
1604 : 2 : source = g_socket_create_source (socket, G_IO_IN, NULL);
1605 : 2 : g_source_set_callback (source, (GSourceFunc) postmortem_source_cb,
1606 : : &callback_visited, NULL);
1607 : 2 : g_source_attach (source, context);
1608 : 2 : g_source_unref (source);
1609 : :
1610 : 2 : g_socket_close (socket, &error);
1611 : 2 : g_assert_no_error (error);
1612 : 2 : g_object_unref (socket);
1613 : :
1614 : : /* Test that, after a socket is closed, its source callback should be called
1615 : : * exactly once. */
1616 : 2 : g_main_context_iteration (context, FALSE);
1617 : 2 : g_assert_true (callback_visited);
1618 : 2 : g_assert_false (g_main_context_pending (context));
1619 : :
1620 : 2 : g_main_context_unref (context);
1621 : 2 : }
1622 : :
1623 : : static void
1624 : 2 : test_reuse_tcp (void)
1625 : : {
1626 : : GSocket *sock1, *sock2;
1627 : 2 : GError *error = NULL;
1628 : : GInetAddress *iaddr;
1629 : : GSocketAddress *addr;
1630 : :
1631 : 2 : sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1632 : : G_SOCKET_TYPE_STREAM,
1633 : : G_SOCKET_PROTOCOL_DEFAULT,
1634 : : &error);
1635 : 2 : g_assert_no_error (error);
1636 : :
1637 : 2 : iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1638 : 2 : addr = g_inet_socket_address_new (iaddr, 0);
1639 : 2 : g_object_unref (iaddr);
1640 : 2 : g_socket_bind (sock1, addr, TRUE, &error);
1641 : 2 : g_object_unref (addr);
1642 : 2 : g_assert_no_error (error);
1643 : :
1644 : 2 : g_socket_listen (sock1, &error);
1645 : 2 : g_assert_no_error (error);
1646 : :
1647 : 2 : sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1648 : : G_SOCKET_TYPE_STREAM,
1649 : : G_SOCKET_PROTOCOL_DEFAULT,
1650 : : &error);
1651 : 2 : g_assert_no_error (error);
1652 : :
1653 : 2 : addr = g_socket_get_local_address (sock1, &error);
1654 : 2 : g_assert_no_error (error);
1655 : 2 : g_socket_bind (sock2, addr, TRUE, &error);
1656 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1657 : 2 : g_clear_error (&error);
1658 : 2 : g_object_unref (addr);
1659 : :
1660 : 2 : g_object_unref (sock1);
1661 : 2 : g_object_unref (sock2);
1662 : 2 : }
1663 : :
1664 : : static void
1665 : 2 : test_reuse_udp (void)
1666 : : {
1667 : : GSocket *sock1, *sock2;
1668 : 2 : GError *error = NULL;
1669 : : GInetAddress *iaddr;
1670 : : GSocketAddress *addr;
1671 : :
1672 : 2 : sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1673 : : G_SOCKET_TYPE_DATAGRAM,
1674 : : G_SOCKET_PROTOCOL_DEFAULT,
1675 : : &error);
1676 : 2 : g_assert_no_error (error);
1677 : :
1678 : 2 : iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1679 : 2 : addr = g_inet_socket_address_new (iaddr, 0);
1680 : 2 : g_object_unref (iaddr);
1681 : 2 : g_socket_bind (sock1, addr, TRUE, &error);
1682 : 2 : g_object_unref (addr);
1683 : 2 : g_assert_no_error (error);
1684 : :
1685 : 2 : sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1686 : : G_SOCKET_TYPE_DATAGRAM,
1687 : : G_SOCKET_PROTOCOL_DEFAULT,
1688 : : &error);
1689 : 2 : g_assert_no_error (error);
1690 : :
1691 : 2 : addr = g_socket_get_local_address (sock1, &error);
1692 : 2 : g_assert_no_error (error);
1693 : 2 : g_socket_bind (sock2, addr, TRUE, &error);
1694 : 2 : g_object_unref (addr);
1695 : 2 : g_assert_no_error (error);
1696 : :
1697 : 2 : g_object_unref (sock1);
1698 : 2 : g_object_unref (sock2);
1699 : 2 : }
1700 : :
1701 : : static void
1702 : 4 : test_get_available (gconstpointer user_data)
1703 : : {
1704 : 4 : GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1705 : 4 : GError *err = NULL;
1706 : : GSocket *listener, *server, *client;
1707 : : GInetAddress *addr;
1708 : : GSocketAddress *saddr, *boundaddr;
1709 : 4 : gchar data[] = "0123456789abcdef";
1710 : : gchar buf[34];
1711 : : gssize nread;
1712 : :
1713 : 4 : listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1714 : 2 : socket_type,
1715 : : G_SOCKET_PROTOCOL_DEFAULT,
1716 : : &err);
1717 : 4 : g_assert_no_error (err);
1718 : 6 : g_assert_true (G_IS_SOCKET (listener));
1719 : :
1720 : 4 : client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1721 : 2 : socket_type,
1722 : : G_SOCKET_PROTOCOL_DEFAULT,
1723 : : &err);
1724 : 4 : g_assert_no_error (err);
1725 : 6 : g_assert_true (G_IS_SOCKET (client));
1726 : :
1727 : 4 : if (socket_type == G_SOCKET_TYPE_STREAM)
1728 : : {
1729 : 2 : g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1730 : 2 : g_assert_no_error (err);
1731 : 1 : }
1732 : :
1733 : 4 : addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1734 : 4 : saddr = g_inet_socket_address_new (addr, 0);
1735 : :
1736 : 4 : g_socket_bind (listener, saddr, TRUE, &err);
1737 : 4 : g_assert_no_error (err);
1738 : 4 : g_object_unref (saddr);
1739 : 4 : g_object_unref (addr);
1740 : :
1741 : 4 : boundaddr = g_socket_get_local_address (listener, &err);
1742 : 4 : g_assert_no_error (err);
1743 : :
1744 : 4 : addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1745 : 4 : saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1746 : 4 : g_object_unref (addr);
1747 : 4 : g_object_unref (boundaddr);
1748 : :
1749 : 4 : if (socket_type == G_SOCKET_TYPE_STREAM)
1750 : : {
1751 : 2 : g_socket_listen (listener, &err);
1752 : 2 : g_assert_no_error (err);
1753 : 2 : g_socket_connect (client, saddr, NULL, &err);
1754 : 2 : g_assert_no_error (err);
1755 : :
1756 : 2 : server = g_socket_accept (listener, NULL, &err);
1757 : 2 : g_assert_no_error (err);
1758 : 2 : g_socket_set_blocking (server, FALSE);
1759 : 2 : g_object_unref (listener);
1760 : 1 : }
1761 : : else
1762 : 2 : server = listener;
1763 : :
1764 : 4 : g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1765 : 4 : g_assert_no_error (err);
1766 : :
1767 : 4 : while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1768 : : ;
1769 : 4 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1770 : :
1771 : 4 : g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1772 : 4 : g_assert_no_error (err);
1773 : :
1774 : : /* We need to wait until the data has actually been copied into the
1775 : : * server socket's buffers, but g_socket_condition_wait() won't help
1776 : : * here since the socket is definitely already readable. So there's
1777 : : * a race condition in checking its available bytes. In the TCP
1778 : : * case, we poll for a bit until the new data shows up. In the UDP
1779 : : * case, there's not much we can do, but at least the failure mode
1780 : : * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1781 : : */
1782 : 4 : if (socket_type == G_SOCKET_TYPE_STREAM)
1783 : : {
1784 : : int tries;
1785 : :
1786 : 2 : for (tries = 0; tries < 100; tries++)
1787 : : {
1788 : 2 : gssize res = g_socket_get_available_bytes (server);
1789 : 2 : if ((res == -1) || ((gsize) res > sizeof (data)))
1790 : 1 : break;
1791 : 0 : g_usleep (100000);
1792 : 0 : }
1793 : :
1794 : 2 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1795 : 1 : }
1796 : : else
1797 : : {
1798 : 2 : g_usleep (100000);
1799 : 2 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1800 : : }
1801 : :
1802 : 4 : g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1803 : 4 : nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1804 : 4 : g_assert_no_error (err);
1805 : :
1806 : 4 : if (socket_type == G_SOCKET_TYPE_STREAM)
1807 : : {
1808 : 2 : g_assert_cmpint (nread, ==, 2 * sizeof (data));
1809 : 2 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1810 : 1 : }
1811 : : else
1812 : : {
1813 : 2 : g_assert_cmpint (nread, ==, sizeof (data));
1814 : 2 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1815 : : }
1816 : :
1817 : 4 : nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1818 : 4 : if (socket_type == G_SOCKET_TYPE_STREAM)
1819 : : {
1820 : 2 : g_assert_cmpint (nread, ==, -1);
1821 : 2 : g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1822 : 2 : g_clear_error (&err);
1823 : 1 : }
1824 : : else
1825 : : {
1826 : 2 : g_assert_cmpint (nread, ==, sizeof (data));
1827 : 2 : g_assert_no_error (err);
1828 : : }
1829 : :
1830 : 4 : g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1831 : :
1832 : 4 : g_socket_close (server, &err);
1833 : 4 : g_assert_no_error (err);
1834 : :
1835 : 4 : g_object_unref (saddr);
1836 : 4 : g_object_unref (server);
1837 : 4 : g_object_unref (client);
1838 : 4 : }
1839 : :
1840 : : typedef struct {
1841 : : GInputStream *is;
1842 : : GOutputStream *os;
1843 : : const guint8 *write_data;
1844 : : guint8 *read_data;
1845 : : } TestReadWriteData;
1846 : :
1847 : : static gpointer
1848 : 2 : test_read_write_write_thread (gpointer user_data)
1849 : : {
1850 : 2 : TestReadWriteData *data = user_data;
1851 : : gsize bytes_written;
1852 : 2 : GError *error = NULL;
1853 : : gboolean res;
1854 : :
1855 : 2 : res = g_output_stream_write_all (data->os, data->write_data, 1024, &bytes_written, NULL, &error);
1856 : 2 : g_assert_true (res);
1857 : 2 : g_assert_no_error (error);
1858 : 2 : g_assert_cmpint (bytes_written, ==, 1024);
1859 : :
1860 : 2 : return NULL;
1861 : : }
1862 : :
1863 : : static gpointer
1864 : 4 : test_read_write_read_thread (gpointer user_data)
1865 : : {
1866 : 4 : TestReadWriteData *data = user_data;
1867 : : gsize bytes_read;
1868 : 4 : GError *error = NULL;
1869 : : gboolean res;
1870 : :
1871 : 4 : res = g_input_stream_read_all (data->is, data->read_data, 1024, &bytes_read, NULL, &error);
1872 : 4 : g_assert_true (res);
1873 : 4 : g_assert_no_error (error);
1874 : 4 : g_assert_cmpint (bytes_read, ==, 1024);
1875 : :
1876 : 4 : return NULL;
1877 : : }
1878 : :
1879 : : static gpointer
1880 : 2 : test_read_write_writev_thread (gpointer user_data)
1881 : : {
1882 : 2 : TestReadWriteData *data = user_data;
1883 : : gsize bytes_written;
1884 : 2 : GError *error = NULL;
1885 : : gboolean res;
1886 : : GOutputVector vectors[3];
1887 : :
1888 : 2 : vectors[0].buffer = data->write_data;
1889 : 2 : vectors[0].size = 256;
1890 : 2 : vectors[1].buffer = data->write_data + 256;
1891 : 2 : vectors[1].size = 256;
1892 : 2 : vectors[2].buffer = data->write_data + 512;
1893 : 2 : vectors[2].size = 512;
1894 : :
1895 : 2 : res = g_output_stream_writev_all (data->os, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1896 : 2 : g_assert_true (res);
1897 : 2 : g_assert_no_error (error);
1898 : 2 : g_assert_cmpint (bytes_written, ==, 1024);
1899 : :
1900 : 2 : return NULL;
1901 : : }
1902 : :
1903 : : /* test if normal read/write/writev via the GSocket*Streams works on TCP sockets */
1904 : : static void
1905 : 4 : test_read_write (gconstpointer user_data)
1906 : : {
1907 : 4 : gboolean writev = GPOINTER_TO_INT (user_data);
1908 : 4 : GError *err = NULL;
1909 : : GSocket *listener, *server, *client;
1910 : : GInetAddress *addr;
1911 : : GSocketAddress *saddr, *boundaddr;
1912 : : TestReadWriteData data;
1913 : : guint8 data_write[1024], data_read[1024];
1914 : : GSocketConnection *server_stream, *client_stream;
1915 : : GThread *write_thread, *read_thread;
1916 : : guint i;
1917 : :
1918 : 4 : listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1919 : : G_SOCKET_TYPE_STREAM,
1920 : : G_SOCKET_PROTOCOL_DEFAULT,
1921 : : &err);
1922 : 4 : g_assert_no_error (err);
1923 : 6 : g_assert_true (G_IS_SOCKET (listener));
1924 : :
1925 : 4 : client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1926 : : G_SOCKET_TYPE_STREAM,
1927 : : G_SOCKET_PROTOCOL_DEFAULT,
1928 : : &err);
1929 : 4 : g_assert_no_error (err);
1930 : 6 : g_assert_true (G_IS_SOCKET (client));
1931 : :
1932 : 4 : addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1933 : 4 : saddr = g_inet_socket_address_new (addr, 0);
1934 : :
1935 : 4 : g_socket_bind (listener, saddr, TRUE, &err);
1936 : 4 : g_assert_no_error (err);
1937 : 4 : g_object_unref (saddr);
1938 : 4 : g_object_unref (addr);
1939 : :
1940 : 4 : boundaddr = g_socket_get_local_address (listener, &err);
1941 : 4 : g_assert_no_error (err);
1942 : :
1943 : 4 : g_socket_listen (listener, &err);
1944 : 4 : g_assert_no_error (err);
1945 : :
1946 : 4 : addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1947 : 4 : saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1948 : 4 : g_object_unref (addr);
1949 : 4 : g_object_unref (boundaddr);
1950 : :
1951 : 4 : g_socket_connect (client, saddr, NULL, &err);
1952 : 4 : g_assert_no_error (err);
1953 : :
1954 : 4 : server = g_socket_accept (listener, NULL, &err);
1955 : 4 : g_assert_no_error (err);
1956 : 4 : g_socket_set_blocking (server, FALSE);
1957 : 4 : g_object_unref (listener);
1958 : :
1959 : 4 : server_stream = g_socket_connection_factory_create_connection (server);
1960 : 4 : g_assert_nonnull (server_stream);
1961 : 4 : client_stream = g_socket_connection_factory_create_connection (client);
1962 : 4 : g_assert_nonnull (client_stream);
1963 : :
1964 : 4100 : for (i = 0; i < sizeof (data_write); i++)
1965 : 4096 : data_write[i] = i;
1966 : :
1967 : 4 : data.is = g_io_stream_get_input_stream (G_IO_STREAM (server_stream));
1968 : 4 : data.os = g_io_stream_get_output_stream (G_IO_STREAM (client_stream));
1969 : 4 : data.read_data = data_read;
1970 : 4 : data.write_data = data_write;
1971 : :
1972 : 4 : if (writev)
1973 : 2 : write_thread = g_thread_new ("writer", test_read_write_writev_thread, &data);
1974 : : else
1975 : 2 : write_thread = g_thread_new ("writer", test_read_write_write_thread, &data);
1976 : 4 : read_thread = g_thread_new ("reader", test_read_write_read_thread, &data);
1977 : :
1978 : 4 : g_thread_join (write_thread);
1979 : 4 : g_thread_join (read_thread);
1980 : :
1981 : 6 : g_assert_cmpmem (data_write, sizeof data_write, data_read, sizeof data_read);
1982 : :
1983 : 4 : g_socket_close (server, &err);
1984 : 4 : g_assert_no_error (err);
1985 : :
1986 : 4 : g_object_unref (server_stream);
1987 : 4 : g_object_unref (client_stream);
1988 : :
1989 : 4 : g_object_unref (saddr);
1990 : 4 : g_object_unref (server);
1991 : 4 : g_object_unref (client);
1992 : 4 : }
1993 : :
1994 : : #ifdef SO_NOSIGPIPE
1995 : : static void
1996 : : test_nosigpipe (void)
1997 : : {
1998 : : GSocket *sock;
1999 : : GError *error = NULL;
2000 : : gint value;
2001 : :
2002 : : sock = g_socket_new (AF_INET,
2003 : : G_SOCKET_TYPE_STREAM,
2004 : : G_SOCKET_PROTOCOL_DEFAULT,
2005 : : &error);
2006 : : g_assert_no_error (error);
2007 : :
2008 : : g_socket_get_option (sock, SOL_SOCKET, SO_NOSIGPIPE, &value, &error);
2009 : : g_assert_no_error (error);
2010 : : g_assert_true (value);
2011 : :
2012 : : g_object_unref (sock);
2013 : : }
2014 : : #endif
2015 : :
2016 : : #if G_CREDENTIALS_SUPPORTED
2017 : : static gpointer client_setup_thread (gpointer user_data);
2018 : :
2019 : : static void
2020 : 2 : test_credentials_tcp_client (void)
2021 : : {
2022 : 2 : const GSocketFamily family = G_SOCKET_FAMILY_IPV4;
2023 : : IPTestData *data;
2024 : 2 : GError *error = NULL;
2025 : : GSocket *client;
2026 : : GSocketAddress *addr;
2027 : : GCredentials *creds;
2028 : :
2029 : 2 : data = create_server (family, echo_server_thread, FALSE, &error);
2030 : 2 : if (error != NULL)
2031 : : {
2032 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
2033 : 0 : g_clear_error (&error);
2034 : 0 : return;
2035 : : }
2036 : :
2037 : 2 : addr = g_socket_get_local_address (data->server, &error);
2038 : 2 : g_assert_no_error (error);
2039 : :
2040 : 2 : client = g_socket_new (family,
2041 : : G_SOCKET_TYPE_STREAM,
2042 : : G_SOCKET_PROTOCOL_DEFAULT,
2043 : : &error);
2044 : 2 : g_assert_no_error (error);
2045 : :
2046 : 2 : g_socket_set_blocking (client, TRUE);
2047 : 2 : g_socket_set_timeout (client, 1);
2048 : :
2049 : 2 : g_socket_connect (client, addr, NULL, &error);
2050 : 2 : g_assert_no_error (error);
2051 : 2 : g_object_unref (addr);
2052 : :
2053 : 2 : creds = g_socket_get_credentials (client, &error);
2054 : 2 : if (creds != NULL)
2055 : : {
2056 : 1 : gchar *str = g_credentials_to_string (creds);
2057 : 1 : g_test_message ("Supported on this OS: %s", str);
2058 : 1 : g_free (str);
2059 : 1 : g_clear_object (&creds);
2060 : 0 : }
2061 : : else
2062 : : {
2063 : 1 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
2064 : 1 : g_test_message ("Unsupported on this OS: %s", error->message);
2065 : 1 : g_clear_error (&error);
2066 : : }
2067 : :
2068 : 2 : g_socket_close (client, &error);
2069 : 2 : g_assert_no_error (error);
2070 : :
2071 : 2 : g_thread_join (data->thread);
2072 : :
2073 : 2 : g_socket_close (data->server, &error);
2074 : 2 : g_assert_no_error (error);
2075 : :
2076 : 2 : g_object_unref (client);
2077 : :
2078 : 2 : ip_test_data_free (data);
2079 : 1 : }
2080 : :
2081 : : static void
2082 : 2 : test_credentials_tcp_server (void)
2083 : : {
2084 : 2 : const GSocketFamily family = G_SOCKET_FAMILY_IPV4;
2085 : : IPTestData *data;
2086 : : GSocket *server;
2087 : 2 : GError *error = NULL;
2088 : 2 : GSocketAddress *addr = NULL;
2089 : 2 : GInetAddress *iaddr = NULL;
2090 : 2 : GSocket *sock = NULL;
2091 : : GCredentials *creds;
2092 : :
2093 : 2 : data = g_slice_new0 (IPTestData);
2094 : 2 : data->family = family;
2095 : 2 : data->server = server = g_socket_new (family,
2096 : : G_SOCKET_TYPE_STREAM,
2097 : : G_SOCKET_PROTOCOL_DEFAULT,
2098 : : &error);
2099 : 2 : if (error != NULL)
2100 : 0 : goto skip;
2101 : :
2102 : 2 : g_socket_set_blocking (server, TRUE);
2103 : :
2104 : 2 : iaddr = g_inet_address_new_loopback (family);
2105 : 2 : addr = g_inet_socket_address_new (iaddr, 0);
2106 : :
2107 : 2 : if (!g_socket_bind (server, addr, TRUE, &error))
2108 : 0 : goto skip;
2109 : :
2110 : 2 : if (!g_socket_listen (server, &error))
2111 : 0 : goto skip;
2112 : :
2113 : 2 : data->thread = g_thread_new ("client", client_setup_thread, data);
2114 : :
2115 : 2 : sock = g_socket_accept (server, NULL, &error);
2116 : 2 : g_assert_no_error (error);
2117 : :
2118 : 2 : creds = g_socket_get_credentials (sock, &error);
2119 : 2 : if (creds != NULL)
2120 : : {
2121 : 1 : gchar *str = g_credentials_to_string (creds);
2122 : 1 : g_test_message ("Supported on this OS: %s", str);
2123 : 1 : g_free (str);
2124 : 1 : g_clear_object (&creds);
2125 : 0 : }
2126 : : else
2127 : : {
2128 : 1 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
2129 : 1 : g_test_message ("Unsupported on this OS: %s", error->message);
2130 : 1 : g_clear_error (&error);
2131 : : }
2132 : :
2133 : 2 : goto beach;
2134 : :
2135 : 0 : skip:
2136 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
2137 : 0 : goto beach;
2138 : :
2139 : 1 : beach:
2140 : : {
2141 : 2 : g_clear_error (&error);
2142 : :
2143 : 2 : g_clear_object (&sock);
2144 : 2 : g_clear_object (&addr);
2145 : 2 : g_clear_object (&iaddr);
2146 : :
2147 : 2 : g_clear_pointer (&data->thread, g_thread_join);
2148 : :
2149 : 2 : ip_test_data_free (data);
2150 : : }
2151 : 2 : }
2152 : :
2153 : : static gpointer
2154 : 2 : client_setup_thread (gpointer user_data)
2155 : : {
2156 : 2 : IPTestData *data = user_data;
2157 : : GSocketAddress *addr;
2158 : : GSocket *client;
2159 : 2 : GError *error = NULL;
2160 : :
2161 : 2 : addr = g_socket_get_local_address (data->server, &error);
2162 : 2 : g_assert_no_error (error);
2163 : :
2164 : 2 : data->client = client = g_socket_new (data->family,
2165 : : G_SOCKET_TYPE_STREAM,
2166 : : G_SOCKET_PROTOCOL_DEFAULT,
2167 : : &error);
2168 : 2 : g_assert_no_error (error);
2169 : :
2170 : 2 : g_socket_set_blocking (client, TRUE);
2171 : 2 : g_socket_set_timeout (client, 1);
2172 : :
2173 : 2 : g_socket_connect (client, addr, NULL, &error);
2174 : 2 : g_assert_no_error (error);
2175 : :
2176 : 2 : g_object_unref (addr);
2177 : :
2178 : 2 : return NULL;
2179 : : }
2180 : :
2181 : : #ifdef G_OS_WIN32
2182 : : /*
2183 : : * _g_win32_socketpair:
2184 : : *
2185 : : * Create a pair of connected sockets, similar to POSIX/BSD socketpair().
2186 : : *
2187 : : * Windows does not (yet) provide a socketpair() function. However, since the
2188 : : * introduction of AF_UNIX sockets, it is possible to implement a fairly close
2189 : : * function.
2190 : : */
2191 : : static gint
2192 : 1 : _g_win32_socketpair (gint domain,
2193 : : gint type,
2194 : : gint protocol,
2195 : : gint sv[2])
2196 : : {
2197 : 1 : struct sockaddr_un addr = { 0, };
2198 : : socklen_t socklen;
2199 : 1 : SOCKET listener = INVALID_SOCKET;
2200 : 1 : SOCKET client = INVALID_SOCKET;
2201 : 1 : SOCKET server = INVALID_SOCKET;
2202 : 1 : gchar *path = NULL;
2203 : 1 : wchar_t *path_utf16 = NULL;
2204 : 1 : int tmpfd, rv = -1;
2205 : : u_long arg, br;
2206 : :
2207 : 1 : g_return_val_if_fail (sv != NULL, -1);
2208 : :
2209 : 1 : addr.sun_family = AF_UNIX;
2210 : 1 : socklen = sizeof (addr);
2211 : :
2212 : 1 : tmpfd = g_file_open_tmp (NULL, &path, NULL);
2213 : 1 : if (tmpfd == -1)
2214 : : {
2215 : 0 : WSASetLastError (WSAEACCES);
2216 : 0 : goto out;
2217 : : }
2218 : :
2219 : 1 : g_close (tmpfd, NULL);
2220 : :
2221 : 1 : if (strlen (path) >= sizeof (addr.sun_path))
2222 : : {
2223 : 0 : WSASetLastError (WSAEACCES);
2224 : 0 : goto out;
2225 : : }
2226 : :
2227 : 1 : strncpy (addr.sun_path, path, sizeof (addr.sun_path) - 1);
2228 : :
2229 : 1 : listener = socket (domain, type, protocol);
2230 : 1 : if (listener == INVALID_SOCKET)
2231 : 0 : goto out;
2232 : :
2233 : 1 : path_utf16 = g_utf8_to_utf16 (path, -1, NULL, NULL, NULL);
2234 : 1 : if (!path_utf16)
2235 : 0 : goto out;
2236 : :
2237 : 1 : if (DeleteFile (path_utf16) == 0)
2238 : : {
2239 : 0 : if (GetLastError () != ERROR_FILE_NOT_FOUND)
2240 : 0 : goto out;
2241 : 0 : }
2242 : :
2243 : 1 : if (bind (listener, (struct sockaddr *) &addr, socklen) == SOCKET_ERROR)
2244 : 0 : goto out;
2245 : :
2246 : 1 : if (listen (listener, 1) == SOCKET_ERROR)
2247 : 0 : goto out;
2248 : :
2249 : 1 : client = socket (domain, type, protocol);
2250 : 1 : if (client == INVALID_SOCKET)
2251 : 0 : goto out;
2252 : :
2253 : 1 : arg = 1;
2254 : 1 : if (ioctlsocket (client, FIONBIO, &arg) == SOCKET_ERROR)
2255 : 0 : goto out;
2256 : :
2257 : 1 : if (connect (client, (struct sockaddr *) &addr, socklen) == SOCKET_ERROR &&
2258 : 1 : WSAGetLastError () != WSAEWOULDBLOCK)
2259 : 0 : goto out;
2260 : :
2261 : 1 : server = accept (listener, NULL, NULL);
2262 : 1 : if (server == INVALID_SOCKET)
2263 : 0 : goto out;
2264 : :
2265 : 1 : arg = 0;
2266 : 1 : if (ioctlsocket (client, FIONBIO, &arg) == SOCKET_ERROR)
2267 : 0 : goto out;
2268 : :
2269 : 1 : if (WSAIoctl (server, SIO_AF_UNIX_GETPEERPID,
2270 : : NULL, 0U,
2271 : : &arg, sizeof (arg), &br,
2272 : 1 : NULL, NULL) == SOCKET_ERROR || arg != GetCurrentProcessId ())
2273 : : {
2274 : 0 : WSASetLastError (WSAEACCES);
2275 : 0 : goto out;
2276 : : }
2277 : :
2278 : 1 : sv[0] = server;
2279 : 1 : server = INVALID_SOCKET;
2280 : 1 : sv[1] = client;
2281 : 1 : client = INVALID_SOCKET;
2282 : 1 : rv = 0;
2283 : :
2284 : : out:
2285 : 1 : if (listener != INVALID_SOCKET)
2286 : 1 : closesocket (listener);
2287 : 1 : if (client != INVALID_SOCKET)
2288 : 0 : closesocket (client);
2289 : 1 : if (server != INVALID_SOCKET)
2290 : 0 : closesocket (server);
2291 : :
2292 : 1 : if (path_utf16)
2293 : 1 : DeleteFile (path_utf16);
2294 : :
2295 : 1 : g_free (path_utf16);
2296 : 1 : g_free (path);
2297 : 1 : return rv;
2298 : 1 : }
2299 : : #endif /* G_OS_WIN32 */
2300 : :
2301 : : static void
2302 : 2 : test_credentials_unix_socketpair (void)
2303 : : {
2304 : : gint fds[2];
2305 : : gint status;
2306 : : GSocket *sock[2];
2307 : 2 : GError *error = NULL;
2308 : : GCredentials *creds;
2309 : :
2310 : : #ifdef G_OS_WIN32
2311 : 1 : status = _g_win32_socketpair (PF_UNIX, SOCK_STREAM, 0, fds);
2312 : 1 : if (status != 0)
2313 : : {
2314 : 0 : g_test_skip ("AF_UNIX not supported on this Windows system.");
2315 : 0 : return;
2316 : : }
2317 : : #else
2318 : 1 : status = socketpair (PF_UNIX, SOCK_STREAM, 0, fds);
2319 : : #endif
2320 : 2 : g_assert_cmpint (status, ==, 0);
2321 : :
2322 : 2 : sock[0] = g_socket_new_from_fd (fds[0], &error);
2323 : 2 : g_assert_no_error (error);
2324 : 2 : sock[1] = g_socket_new_from_fd (fds[1], &error);
2325 : 2 : g_assert_no_error (error);
2326 : :
2327 : 2 : creds = g_socket_get_credentials (sock[0], &error);
2328 : 2 : if (creds != NULL)
2329 : : {
2330 : 2 : gchar *str = g_credentials_to_string (creds);
2331 : 2 : g_test_message ("Supported on this OS: %s", str);
2332 : 2 : g_free (str);
2333 : 2 : g_clear_object (&creds);
2334 : 1 : }
2335 : : else
2336 : : {
2337 : 0 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
2338 : 0 : g_test_message ("Unsupported on this OS: %s", error->message);
2339 : 0 : g_clear_error (&error);
2340 : : }
2341 : :
2342 : 2 : g_object_unref (sock[0]);
2343 : 2 : g_object_unref (sock[1]);
2344 : 2 : }
2345 : : #endif
2346 : :
2347 : : static void
2348 : 2 : test_receive_bytes (void)
2349 : : {
2350 : 2 : const GSocketFamily family = G_SOCKET_FAMILY_IPV4;
2351 : : IPTestData *data;
2352 : 2 : GError *error = NULL;
2353 : : GSocket *client;
2354 : : GSocketAddress *addr;
2355 : : gssize len;
2356 : 2 : GBytes *bytes = NULL;
2357 : : gint64 time_start;
2358 : 2 : GCancellable *cancellable = NULL;
2359 : :
2360 : 2 : g_test_summary ("Test basic functionality of g_socket_receive_bytes()");
2361 : :
2362 : 2 : data = create_server (family, echo_server_thread, FALSE, &error);
2363 : 2 : if (error != NULL)
2364 : : {
2365 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
2366 : 0 : g_clear_error (&error);
2367 : 0 : return;
2368 : : }
2369 : :
2370 : 2 : addr = g_socket_get_local_address (data->server, &error);
2371 : 2 : g_assert_no_error (error);
2372 : :
2373 : 2 : client = g_socket_new (family,
2374 : : G_SOCKET_TYPE_STREAM,
2375 : : G_SOCKET_PROTOCOL_DEFAULT,
2376 : : &error);
2377 : 2 : g_assert_no_error (error);
2378 : :
2379 : 2 : g_socket_set_blocking (client, TRUE);
2380 : 2 : g_socket_set_timeout (client, 10);
2381 : :
2382 : 2 : g_socket_connect (client, addr, NULL, &error);
2383 : 2 : g_assert_no_error (error);
2384 : 2 : g_object_unref (addr);
2385 : :
2386 : : /* Send something. */
2387 : 2 : len = g_socket_send (client, "hello", strlen ("hello"), NULL, &error);
2388 : 2 : g_assert_no_error (error);
2389 : 2 : g_assert_cmpint (len, ==, strlen ("hello"));
2390 : :
2391 : : /* And receive it back again. */
2392 : 2 : bytes = g_socket_receive_bytes (client, 5, -1, NULL, &error);
2393 : 2 : g_assert_no_error (error);
2394 : 2 : g_assert_nonnull (bytes);
2395 : 2 : g_assert_cmpuint (g_bytes_get_size (bytes), ==, 5);
2396 : 3 : g_assert_cmpmem (g_bytes_get_data (bytes, NULL), 5, "hello", 5);
2397 : 2 : g_bytes_unref (bytes);
2398 : :
2399 : : /* Try again with a receive buffer which is bigger than the sent bytes, to
2400 : : * test sub-buffer handling. */
2401 : 2 : len = g_socket_send (client, "hello", strlen ("hello"), NULL, &error);
2402 : 2 : g_assert_no_error (error);
2403 : 2 : g_assert_cmpint (len, ==, strlen ("hello"));
2404 : :
2405 : : /* And receive it back again. */
2406 : 2 : bytes = g_socket_receive_bytes (client, 500, -1, NULL, &error);
2407 : 2 : g_assert_no_error (error);
2408 : 2 : g_assert_nonnull (bytes);
2409 : 2 : g_assert_cmpuint (g_bytes_get_size (bytes), ==, 5);
2410 : 3 : g_assert_cmpmem (g_bytes_get_data (bytes, NULL), 5, "hello", 5);
2411 : 2 : g_bytes_unref (bytes);
2412 : :
2413 : : /* Try receiving when there’s nothing to receive, with a timeout. This should
2414 : : * be the per-operation timeout, not the socket’s overall timeout */
2415 : 2 : time_start = g_get_real_time ();
2416 : 2 : bytes = g_socket_receive_bytes (client, 500, 10, NULL, &error);
2417 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
2418 : 2 : g_assert_null (bytes);
2419 : 2 : g_assert_cmpint (g_get_real_time () - time_start, <, g_socket_get_timeout (client) * G_USEC_PER_SEC);
2420 : 2 : g_clear_error (&error);
2421 : :
2422 : : /* And try receiving when already cancelled. */
2423 : 2 : cancellable = g_cancellable_new ();
2424 : 2 : g_cancellable_cancel (cancellable);
2425 : 2 : bytes = g_socket_receive_bytes (client, 500, -1, cancellable, &error);
2426 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
2427 : 2 : g_assert_null (bytes);
2428 : 2 : g_clear_error (&error);
2429 : 2 : g_clear_object (&cancellable);
2430 : :
2431 : : /* Tidy up. */
2432 : 2 : g_socket_close (client, &error);
2433 : 2 : g_assert_no_error (error);
2434 : :
2435 : 2 : g_cancellable_cancel (data->cancellable);
2436 : 2 : g_thread_join (data->thread);
2437 : :
2438 : 2 : g_socket_close (data->server, &error);
2439 : 2 : g_assert_no_error (error);
2440 : :
2441 : 2 : g_object_unref (client);
2442 : :
2443 : 2 : ip_test_data_free (data);
2444 : 1 : }
2445 : :
2446 : : static void
2447 : 2 : test_receive_bytes_from (void)
2448 : : {
2449 : 2 : const GSocketFamily family = G_SOCKET_FAMILY_IPV4;
2450 : : IPTestData *data;
2451 : 2 : GError *error = NULL;
2452 : : GSocket *client;
2453 : 2 : GSocketAddress *dest_addr = NULL, *sender_addr = NULL;
2454 : : gssize len;
2455 : 2 : GBytes *bytes = NULL;
2456 : : gint64 time_start;
2457 : 2 : GCancellable *cancellable = NULL;
2458 : :
2459 : 2 : g_test_summary ("Test basic functionality of g_socket_receive_bytes_from()");
2460 : :
2461 : 2 : data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
2462 : : echo_server_dgram_thread, FALSE, &error);
2463 : 2 : if (error != NULL)
2464 : : {
2465 : 0 : g_test_skip_printf ("Failed to create server: %s", error->message);
2466 : 0 : g_clear_error (&error);
2467 : 0 : return;
2468 : : }
2469 : :
2470 : 2 : dest_addr = g_socket_get_local_address (data->server, &error);
2471 : 2 : g_assert_no_error (error);
2472 : :
2473 : 2 : client = g_socket_new (family,
2474 : : G_SOCKET_TYPE_DATAGRAM,
2475 : : G_SOCKET_PROTOCOL_DEFAULT,
2476 : : &error);
2477 : 2 : g_assert_no_error (error);
2478 : :
2479 : 2 : g_socket_set_blocking (client, TRUE);
2480 : 2 : g_socket_set_timeout (client, 10);
2481 : :
2482 : : /* Send something. */
2483 : 2 : len = g_socket_send_to (client, dest_addr, "hello", strlen ("hello"), NULL, &error);
2484 : 2 : g_assert_no_error (error);
2485 : 2 : g_assert_cmpint (len, ==, strlen ("hello"));
2486 : :
2487 : : /* And receive it back again. */
2488 : 2 : bytes = g_socket_receive_bytes_from (client, &sender_addr, 5, -1, NULL, &error);
2489 : 2 : g_assert_no_error (error);
2490 : 2 : g_assert_nonnull (bytes);
2491 : 2 : g_assert_cmpuint (g_bytes_get_size (bytes), ==, 5);
2492 : 3 : g_assert_cmpmem (g_bytes_get_data (bytes, NULL), 5, "hello", 5);
2493 : 2 : g_assert_nonnull (sender_addr);
2494 : 2 : g_clear_object (&sender_addr);
2495 : 2 : g_bytes_unref (bytes);
2496 : :
2497 : : /* Try again with a receive buffer which is bigger than the sent bytes, to
2498 : : * test sub-buffer handling. */
2499 : 2 : len = g_socket_send_to (client, dest_addr, "hello", strlen ("hello"), NULL, &error);
2500 : 2 : g_assert_no_error (error);
2501 : 2 : g_assert_cmpint (len, ==, strlen ("hello"));
2502 : :
2503 : : /* And receive it back again. */
2504 : 2 : bytes = g_socket_receive_bytes_from (client, NULL, 500, -1, NULL, &error);
2505 : 2 : g_assert_no_error (error);
2506 : 2 : g_assert_nonnull (bytes);
2507 : 2 : g_assert_cmpuint (g_bytes_get_size (bytes), ==, 5);
2508 : 3 : g_assert_cmpmem (g_bytes_get_data (bytes, NULL), 5, "hello", 5);
2509 : 2 : g_bytes_unref (bytes);
2510 : :
2511 : : /* Try receiving when there’s nothing to receive, with a timeout. This should
2512 : : * be the per-operation timeout, not the socket’s overall timeout */
2513 : 2 : time_start = g_get_real_time ();
2514 : 2 : bytes = g_socket_receive_bytes_from (client, &sender_addr, 500, 10, NULL, &error);
2515 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
2516 : 2 : g_assert_null (bytes);
2517 : 2 : g_assert_null (sender_addr);
2518 : 2 : g_assert_cmpint (g_get_real_time () - time_start, <, g_socket_get_timeout (client) * G_USEC_PER_SEC);
2519 : 2 : g_clear_error (&error);
2520 : :
2521 : : /* And try receiving when already cancelled. */
2522 : 2 : cancellable = g_cancellable_new ();
2523 : 2 : g_cancellable_cancel (cancellable);
2524 : 2 : bytes = g_socket_receive_bytes_from (client, &sender_addr, 500, -1, cancellable, &error);
2525 : 2 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
2526 : 2 : g_assert_null (bytes);
2527 : 2 : g_assert_null (sender_addr);
2528 : 2 : g_clear_error (&error);
2529 : 2 : g_clear_object (&cancellable);
2530 : :
2531 : : /* Tidy up. */
2532 : 2 : g_socket_close (client, &error);
2533 : 2 : g_assert_no_error (error);
2534 : :
2535 : 2 : g_cancellable_cancel (data->cancellable);
2536 : 2 : g_thread_join (data->thread);
2537 : :
2538 : 2 : g_socket_close (data->server, &error);
2539 : 2 : g_assert_no_error (error);
2540 : :
2541 : 2 : g_object_unref (dest_addr);
2542 : 2 : g_object_unref (client);
2543 : :
2544 : 2 : ip_test_data_free (data);
2545 : 1 : }
2546 : :
2547 : : static void
2548 : 2 : test_accept_cancelled (void)
2549 : : {
2550 : 2 : GSocket *socket = NULL;
2551 : 2 : GError *local_error = NULL;
2552 : 2 : GCancellable *cancellable = NULL;
2553 : 2 : GSocket *socket2 = NULL;
2554 : :
2555 : 2 : g_test_summary ("Calling g_socket_accept() with a cancelled cancellable "
2556 : : "should return immediately regardless of whether the socket "
2557 : : "is blocking");
2558 : :
2559 : 2 : socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
2560 : : G_SOCKET_TYPE_STREAM,
2561 : : G_SOCKET_PROTOCOL_DEFAULT,
2562 : : &local_error);
2563 : 2 : g_assert_no_error (local_error);
2564 : :
2565 : 2 : cancellable = g_cancellable_new ();
2566 : 2 : g_cancellable_cancel (cancellable);
2567 : :
2568 : 6 : for (unsigned int i = 0; i < 2; i++)
2569 : : {
2570 : 4 : g_socket_set_blocking (socket, i);
2571 : :
2572 : 4 : socket2 = g_socket_accept (socket, cancellable, &local_error);
2573 : 4 : g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
2574 : 4 : g_assert_null (socket2);
2575 : 4 : g_clear_error (&local_error);
2576 : 2 : }
2577 : :
2578 : 2 : g_clear_object (&cancellable);
2579 : 2 : g_clear_object (&socket);
2580 : 2 : }
2581 : :
2582 : : static void
2583 : 2 : test_connect_cancelled (void)
2584 : : {
2585 : 2 : GSocket *socket = NULL;
2586 : 2 : GError *local_error = NULL;
2587 : 2 : GCancellable *cancellable = NULL;
2588 : 2 : GInetAddress *inet_addr = NULL;
2589 : 2 : GSocketAddress *addr = NULL;
2590 : :
2591 : 2 : g_test_summary ("Calling g_socket_connect() with a cancelled cancellable "
2592 : : "should return immediately regardless of whether the socket "
2593 : : "is blocking");
2594 : :
2595 : 2 : socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
2596 : : G_SOCKET_TYPE_STREAM,
2597 : : G_SOCKET_PROTOCOL_DEFAULT,
2598 : : &local_error);
2599 : 2 : g_assert_no_error (local_error);
2600 : :
2601 : 2 : cancellable = g_cancellable_new ();
2602 : 2 : g_cancellable_cancel (cancellable);
2603 : :
2604 : 2 : inet_addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
2605 : 2 : addr = g_inet_socket_address_new (inet_addr, 0);
2606 : :
2607 : 6 : for (unsigned int i = 0; i < 2; i++)
2608 : : {
2609 : : gboolean retval;
2610 : :
2611 : 4 : g_socket_set_blocking (socket, i);
2612 : :
2613 : 4 : retval = g_socket_connect (socket, addr, cancellable, &local_error);
2614 : 4 : g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
2615 : 4 : g_assert_false (retval);
2616 : 4 : g_clear_error (&local_error);
2617 : 2 : }
2618 : :
2619 : 2 : g_clear_object (&addr);
2620 : 2 : g_clear_object (&inet_addr);
2621 : 2 : g_clear_object (&cancellable);
2622 : 2 : g_clear_object (&socket);
2623 : 2 : }
2624 : :
2625 : : #ifdef G_OS_UNIX
2626 : : #define H_TYPE_APP_MESSAGE (h_app_message_get_type ())
2627 : :
2628 : 2 : G_DECLARE_FINAL_TYPE (HAppMessage, h_app_message, H, APP_MESSAGE, GSocketControlMessage)
2629 : :
2630 : : struct _HAppMessage
2631 : : {
2632 : : GSocketControlMessage parent_instance;
2633 : :
2634 : : gint fds[2];
2635 : : };
2636 : :
2637 : 6 : G_DEFINE_TYPE (HAppMessage, h_app_message, G_TYPE_SOCKET_CONTROL_MESSAGE);
2638 : :
2639 : : static void
2640 : 2 : h_app_message_init (HAppMessage *message)
2641 : : {
2642 : 2 : }
2643 : :
2644 : : static gsize
2645 : 2 : h_app_message_get_size (GSocketControlMessage *message)
2646 : : {
2647 : 2 : return 2 * sizeof (gint);
2648 : : }
2649 : :
2650 : : static int
2651 : 1 : h_app_message_get_level (GSocketControlMessage *message)
2652 : : {
2653 : 1 : return SOL_SOCKET;
2654 : : }
2655 : :
2656 : : static int
2657 : 1 : h_app_message_get_msg_type (GSocketControlMessage *message)
2658 : : {
2659 : 1 : return SCM_RIGHTS;
2660 : : }
2661 : :
2662 : : static void
2663 : 1 : h_app_message_serialize (GSocketControlMessage *message, gpointer data)
2664 : : {
2665 : 1 : memcpy (data, H_APP_MESSAGE (message)->fds, 2 * sizeof (gint));
2666 : 1 : }
2667 : :
2668 : : static GSocketControlMessage *
2669 : 1 : h_app_message_deserialize (gint level, gint type, gsize size, gpointer data)
2670 : : {
2671 : : HAppMessage *message;
2672 : :
2673 : 1 : if (level != SOL_SOCKET || type != SCM_RIGHTS)
2674 : 0 : return NULL;
2675 : :
2676 : 1 : message = g_object_new (H_TYPE_APP_MESSAGE, NULL);
2677 : 1 : memcpy (message->fds, data, 2 * sizeof (gint));
2678 : :
2679 : 1 : return G_SOCKET_CONTROL_MESSAGE (message);
2680 : : }
2681 : :
2682 : : static void
2683 : 1 : h_app_message_class_init (HAppMessageClass *klass)
2684 : : {
2685 : 1 : GSocketControlMessageClass *scm_class = G_SOCKET_CONTROL_MESSAGE_CLASS (klass);
2686 : :
2687 : 1 : scm_class->get_size = h_app_message_get_size;
2688 : 1 : scm_class->get_level = h_app_message_get_level;
2689 : 1 : scm_class->get_type = h_app_message_get_msg_type;
2690 : 1 : scm_class->serialize = h_app_message_serialize;
2691 : 1 : scm_class->deserialize = h_app_message_deserialize;
2692 : 1 : }
2693 : :
2694 : : static void
2695 : 1 : test_socket_control_message_custom (void)
2696 : : {
2697 : : gint fds[2];
2698 : : int res;
2699 : : GSocket *sockets[2];
2700 : : HAppMessage *appmsg;
2701 : : GOutputVector ov;
2702 : : GInputVector iv;
2703 : : HAppMessage **mv;
2704 : : gint num_msg;
2705 : : char buffer[1];
2706 : : gssize s;
2707 : 1 : GError *err = NULL;
2708 : :
2709 : 1 : g_test_summary ("Tests that an application can create its own subclass "
2710 : : "of GSocketControlMessage and that the message can be sent and "
2711 : : "received using GSocket APIs");
2712 : :
2713 : 1 : res = socketpair (PF_UNIX, SOCK_STREAM, 0, fds);
2714 : 1 : g_assert_cmpint (res, ==, 0);
2715 : :
2716 : 1 : sockets[0] = g_socket_new_from_fd (fds[0], &err);
2717 : 1 : g_assert_no_error (err);
2718 : 1 : sockets[1] = g_socket_new_from_fd (fds[1], &err);
2719 : 1 : g_assert_no_error (err);
2720 : :
2721 : 1 : appmsg = g_object_new (H_TYPE_APP_MESSAGE, NULL);
2722 : 1 : memcpy (appmsg->fds, fds, sizeof (fds));
2723 : :
2724 : 1 : buffer[0] = 0xff;
2725 : 1 : ov.buffer = buffer;
2726 : 1 : ov.size = 1;
2727 : :
2728 : 1 : s = g_socket_send_message (sockets[0], NULL, &ov, 1, (GSocketControlMessage **) &appmsg, 1, 0, NULL, &err);
2729 : 1 : g_assert_no_error (err);
2730 : 1 : g_assert_cmpint (s, ==, 1);
2731 : :
2732 : 1 : iv.buffer = buffer;
2733 : 1 : iv.size = 1;
2734 : 1 : s = g_socket_receive_message (sockets[1], NULL, &iv, 1, (GSocketControlMessage ***) &mv, &num_msg, NULL, NULL, &err);
2735 : 1 : g_assert_no_error (err);
2736 : 1 : g_assert_cmpint (s, ==, 1);
2737 : 1 : g_assert_cmpint (num_msg, ==, 1);
2738 : 1 : g_assert_true (H_IS_APP_MESSAGE (mv[0]));
2739 : :
2740 : 1 : g_clear_object (&mv[0]);
2741 : 1 : g_clear_pointer (&mv, g_free);
2742 : :
2743 : 1 : g_clear_object (&appmsg);
2744 : 1 : g_clear_object (&sockets[0]);
2745 : 1 : g_clear_object (&sockets[1]);
2746 : 1 : }
2747 : : #endif
2748 : :
2749 : : static void
2750 : 2 : test_unbound_from_fd (void)
2751 : : {
2752 : 2 : GSocket *s = NULL;
2753 : 2 : GError *error = NULL;
2754 : : gint fd;
2755 : :
2756 : 2 : g_test_summary ("g_socket_new_from_fd() should succeed and return correct data "
2757 : : "regardless of the socket state");
2758 : :
2759 : 2 : fd = socket (AF_INET, SOCK_STREAM, 0);
2760 : 2 : g_assert_cmpint (fd, !=, -1);
2761 : :
2762 : 2 : s = g_socket_new_from_fd (fd, &error);
2763 : 2 : g_assert_no_error (error);
2764 : :
2765 : 2 : g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_IPV4);
2766 : 2 : g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
2767 : 2 : g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_TCP);
2768 : : #ifdef G_OS_WIN32
2769 : 1 : g_assert_true (GLIB_PRIVATE_CALL (g_win32_handle_is_socket) ((HANDLE)(gintptr) g_socket_get_fd (s)));
2770 : : #endif
2771 : :
2772 : 2 : g_clear_object (&s);
2773 : 2 : }
2774 : :
2775 : : int
2776 : 2 : main (int argc,
2777 : : char *argv[])
2778 : : {
2779 : : GSocket *sock;
2780 : 2 : GError *error = NULL;
2781 : :
2782 : 2 : g_test_init (&argc, &argv, NULL);
2783 : :
2784 : 2 : sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
2785 : : G_SOCKET_TYPE_STREAM,
2786 : : G_SOCKET_PROTOCOL_DEFAULT,
2787 : : &error);
2788 : 2 : if (sock != NULL)
2789 : : {
2790 : 2 : ipv6_supported = TRUE;
2791 : 2 : g_object_unref (sock);
2792 : 1 : }
2793 : : else
2794 : : {
2795 : 0 : g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
2796 : 0 : g_clear_error (&error);
2797 : : }
2798 : :
2799 : 2 : g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
2800 : 2 : g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
2801 : 2 : g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
2802 : 2 : g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
2803 : 2 : g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
2804 : 2 : g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
2805 : 2 : g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
2806 : 2 : g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
2807 : : #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
2808 : 2 : g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
2809 : : #endif
2810 : 2 : g_test_add_func ("/socket/close_graceful", test_close_graceful);
2811 : 2 : g_test_add_func ("/socket/timed_wait", test_timed_wait);
2812 : 2 : g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
2813 : 2 : g_test_add_func ("/socket/address", test_sockaddr);
2814 : 2 : g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
2815 : 2 : g_test_add_func ("/socket/unix-connection", test_unix_connection);
2816 : : #ifdef G_OS_UNIX
2817 : 1 : g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
2818 : : #endif
2819 : : #ifdef G_OS_WIN32
2820 : 1 : g_test_add_func ("/socket/win32-handle-not-socket", test_handle_not_socket);
2821 : : #endif
2822 : 2 : g_test_add_func ("/socket/source-postmortem", test_source_postmortem);
2823 : 2 : g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
2824 : 2 : g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
2825 : 2 : g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
2826 : : test_get_available);
2827 : 2 : g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
2828 : : test_get_available);
2829 : 2 : g_test_add_data_func ("/socket/read_write", GUINT_TO_POINTER (FALSE),
2830 : : test_read_write);
2831 : 2 : g_test_add_data_func ("/socket/read_writev", GUINT_TO_POINTER (TRUE),
2832 : : test_read_write);
2833 : : #ifdef SO_NOSIGPIPE
2834 : : g_test_add_func ("/socket/nosigpipe", test_nosigpipe);
2835 : : #endif
2836 : : #if G_CREDENTIALS_SUPPORTED
2837 : 2 : g_test_add_func ("/socket/credentials/tcp_client", test_credentials_tcp_client);
2838 : 2 : g_test_add_func ("/socket/credentials/tcp_server", test_credentials_tcp_server);
2839 : 2 : g_test_add_func ("/socket/credentials/unix_socketpair", test_credentials_unix_socketpair);
2840 : : #endif
2841 : 2 : g_test_add_func ("/socket/receive_bytes", test_receive_bytes);
2842 : 2 : g_test_add_func ("/socket/receive_bytes_from", test_receive_bytes_from);
2843 : :
2844 : 2 : g_test_add_func ("/socket/accept/cancelled", test_accept_cancelled);
2845 : 2 : g_test_add_func ("/socket/connect/cancelled", test_connect_cancelled);
2846 : : #ifdef G_OS_UNIX
2847 : 1 : g_test_add_func ("/socket/control-message/custom", test_socket_control_message_custom);
2848 : : #endif
2849 : 2 : g_test_add_func ("/socket/new_from_fd/unbound", test_unbound_from_fd);
2850 : :
2851 : 2 : return g_test_run();
2852 : : }
|
