GSocket: fix g_socket_bind() allow_reuse semantics
[platform/upstream/glib.git] / gio / tests / socket.c
1 /* GLib testing framework examples and tests
2  *
3  * Copyright (C) 2008-2011 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  */
20
21 #include <gio/gio.h>
22
23 #ifdef G_OS_UNIX
24 #include <errno.h>
25 #include <sys/wait.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <gio/gnetworking.h>
29 #include <gio/gunixconnection.h>
30 #endif
31
32 #include "gnetworkingprivate.h"
33
34 typedef struct {
35   GSocket *server;
36   GSocket *client;
37   GSocketFamily family;
38   GThread *thread;
39   GMainLoop *loop;
40 } IPTestData;
41
42 static gpointer
43 echo_server_thread (gpointer user_data)
44 {
45   IPTestData *data = user_data;
46   GSocket *sock;
47   GError *error = NULL;
48   gssize nread, nwrote;
49   gchar buf[128];
50
51   sock = g_socket_accept (data->server, NULL, &error);
52   g_assert_no_error (error);
53
54   while (TRUE)
55     {
56       nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
57       g_assert_no_error (error);
58       g_assert_cmpint (nread, >=, 0);
59
60       if (nread == 0)
61         break;
62
63       nwrote = g_socket_send (sock, buf, nread, NULL, &error);
64       g_assert_no_error (error);
65       g_assert_cmpint (nwrote, ==, nread);
66     }
67
68   g_socket_close (sock, &error);
69   g_assert_no_error (error);
70   g_object_unref (sock);
71   return NULL;
72 }
73
74 static IPTestData *
75 create_server (GSocketFamily family,
76                GThreadFunc   server_thread,
77                gboolean      v4mapped)
78 {
79   IPTestData *data;
80   GSocket *server;
81   GError *error = NULL;
82   GSocketAddress *addr;
83   GInetAddress *iaddr;
84
85   data = g_slice_new (IPTestData);
86   data->family = family;
87
88   data->server = server = g_socket_new (family,
89                                         G_SOCKET_TYPE_STREAM,
90                                         G_SOCKET_PROTOCOL_DEFAULT,
91                                         &error);
92   g_assert_no_error (error);
93
94   g_assert_cmpint (g_socket_get_family (server), ==, family);
95   g_assert_cmpint (g_socket_get_socket_type (server), ==, G_SOCKET_TYPE_STREAM);
96   g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
97
98   g_socket_set_blocking (server, TRUE);
99
100 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
101   if (v4mapped)
102     {
103       int fd, v6_only;
104
105       fd = g_socket_get_fd (server);
106       v6_only = 0;
107       setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &v6_only, sizeof (v6_only));
108       if (! g_socket_speaks_ipv4 (data->server))
109         {
110           g_object_unref (data->server);
111           g_slice_free (IPTestData, data);
112           return NULL;
113         }
114     }
115 #endif
116
117   if (v4mapped)
118     iaddr = g_inet_address_new_any (family);
119   else
120     iaddr = g_inet_address_new_loopback (family);
121   addr = g_inet_socket_address_new (iaddr, 0);
122   g_object_unref (iaddr);
123
124   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
125   g_socket_bind (server, addr, TRUE, &error);
126   g_assert_no_error (error);
127   g_object_unref (addr);
128
129   addr = g_socket_get_local_address (server, &error);
130   g_assert_no_error (error);
131   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
132   g_object_unref (addr);
133
134   g_socket_listen (server, &error);
135   g_assert_no_error (error);
136
137   data->thread = g_thread_new ("server", server_thread, data);
138
139   return data;
140 }
141
142 static const gchar *testbuf = "0123456789abcdef";
143
144 static gboolean
145 test_ip_async_read_ready (GSocket      *client,
146                           GIOCondition  cond,
147                           gpointer      user_data)
148 {
149   IPTestData *data = user_data;
150   GError *error = NULL;
151   gssize len;
152   gchar buf[128];
153
154   g_assert_cmpint (cond, ==, G_IO_IN);
155
156   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
157   g_assert_no_error (error);
158   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
159
160   g_assert_cmpstr (testbuf, ==, buf);
161
162   g_main_loop_quit (data->loop);
163
164   return FALSE;
165 }
166
167 static gboolean
168 test_ip_async_write_ready (GSocket      *client,
169                            GIOCondition  cond,
170                            gpointer      user_data)
171 {
172   IPTestData *data = user_data;
173   GError *error = NULL;
174   GSource *source;
175   gssize len;
176
177   g_assert_cmpint (cond, ==, G_IO_OUT);
178
179   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
180   g_assert_no_error (error);
181   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
182
183   source = g_socket_create_source (client, G_IO_IN, NULL);
184   g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
185                          data, NULL);
186   g_source_attach (source, NULL);
187   g_source_unref (source);
188
189   return FALSE;
190 }
191
192 static gboolean
193 test_ip_async_timed_out (GSocket      *client,
194                          GIOCondition  cond,
195                          gpointer      user_data)
196 {
197   IPTestData *data = user_data;
198   GError *error = NULL;
199   GSource *source;
200   gssize len;
201   gchar buf[128];
202
203   if (data->family == G_SOCKET_FAMILY_IPV4)
204     {
205       g_assert_cmpint (cond, ==, G_IO_IN);
206       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
207       g_assert_cmpint (len, ==, -1);
208       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
209       g_clear_error (&error);
210     }
211
212   source = g_socket_create_source (client, G_IO_OUT, NULL);
213   g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
214                          data, NULL);
215   g_source_attach (source, NULL);
216   g_source_unref (source);
217
218   return FALSE;
219 }
220
221 static gboolean
222 test_ip_async_connected (GSocket      *client,
223                          GIOCondition  cond,
224                          gpointer      user_data)
225 {
226   IPTestData *data = user_data;
227   GError *error = NULL;
228   GSource *source;
229   gssize len;
230   gchar buf[128];
231
232   g_socket_check_connect_result (client, &error);
233   g_assert_no_error (error);
234   /* We do this after the check_connect_result, since that will give a
235    * more useful assertion in case of error.
236    */
237   g_assert_cmpint (cond, ==, G_IO_OUT);
238
239   g_assert (g_socket_is_connected (client));
240
241   /* This adds 1 second to "make check", so let's just only do it once. */
242   if (data->family == G_SOCKET_FAMILY_IPV4)
243     {
244       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
245       g_assert_cmpint (len, ==, -1);
246       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
247       g_clear_error (&error);
248
249       source = g_socket_create_source (client, G_IO_IN, NULL);
250       g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
251                              data, NULL);
252       g_source_attach (source, NULL);
253       g_source_unref (source);
254     }
255   else
256     test_ip_async_timed_out (client, 0, data);
257
258   return FALSE;
259 }
260
261 static gboolean
262 idle_test_ip_async_connected (gpointer user_data)
263 {
264   IPTestData *data = user_data;
265
266   return test_ip_async_connected (data->client, G_IO_OUT, data);
267 }
268
269 static void
270 test_ip_async (GSocketFamily family)
271 {
272   IPTestData *data;
273   GError *error = NULL;
274   GSocket *client;
275   GSocketAddress *addr;
276   GSource *source;
277   gssize len;
278   gchar buf[128];
279
280   data = create_server (family, echo_server_thread, FALSE);
281   addr = g_socket_get_local_address (data->server, &error);
282
283   client = g_socket_new (family,
284                          G_SOCKET_TYPE_STREAM,
285                          G_SOCKET_PROTOCOL_DEFAULT,
286                          &error);
287   g_assert_no_error (error);
288   data->client = client;
289
290   g_assert_cmpint (g_socket_get_family (client), ==, family);
291   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
292   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
293
294   g_socket_set_blocking (client, FALSE);
295   g_socket_set_timeout (client, 1);
296
297   if (g_socket_connect (client, addr, NULL, &error))
298     {
299       g_assert_no_error (error);
300       g_idle_add (idle_test_ip_async_connected, data);
301     }
302   else
303     {
304       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
305       g_clear_error (&error);
306       source = g_socket_create_source (client, G_IO_OUT, NULL);
307       g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
308                              data, NULL);
309       g_source_attach (source, NULL);
310       g_source_unref (source);
311     }
312   g_object_unref (addr);
313
314   data->loop = g_main_loop_new (NULL, TRUE);
315   g_main_loop_run (data->loop);
316   g_main_loop_unref (data->loop);
317
318   g_socket_shutdown (client, FALSE, TRUE, &error);
319   g_assert_no_error (error);
320
321   g_thread_join (data->thread);
322
323   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
324   g_assert_no_error (error);
325   g_assert_cmpint (len, ==, 0);
326
327   g_socket_close (client, &error);
328   g_assert_no_error (error);
329   g_socket_close (data->server, &error);
330   g_assert_no_error (error);
331
332   g_object_unref (data->server);
333   g_object_unref (client);
334
335   g_slice_free (IPTestData, data);
336 }
337
338 static void
339 test_ipv4_async (void)
340 {
341   test_ip_async (G_SOCKET_FAMILY_IPV4);
342 }
343
344 static void
345 test_ipv6_async (void)
346 {
347   test_ip_async (G_SOCKET_FAMILY_IPV6);
348 }
349
350 static void
351 test_ip_sync (GSocketFamily family)
352 {
353   IPTestData *data;
354   GError *error = NULL;
355   GSocket *client;
356   GSocketAddress *addr;
357   gssize len;
358   gchar buf[128];
359
360   data = create_server (family, echo_server_thread, FALSE);
361   addr = g_socket_get_local_address (data->server, &error);
362
363   client = g_socket_new (family,
364                          G_SOCKET_TYPE_STREAM,
365                          G_SOCKET_PROTOCOL_DEFAULT,
366                          &error);
367   g_assert_no_error (error);
368
369   g_assert_cmpint (g_socket_get_family (client), ==, family);
370   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
371   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
372
373   g_socket_set_blocking (client, TRUE);
374   g_socket_set_timeout (client, 1);
375
376   g_socket_connect (client, addr, NULL, &error);
377   g_assert_no_error (error);
378   g_assert (g_socket_is_connected (client));
379   g_object_unref (addr);
380
381   /* This adds 1 second to "make check", so let's just only do it once. */
382   if (family == G_SOCKET_FAMILY_IPV4)
383     {
384       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
385       g_assert_cmpint (len, ==, -1);
386       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
387       g_clear_error (&error);
388     }
389
390   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
391   g_assert_no_error (error);
392   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
393   
394   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
395   g_assert_no_error (error);
396   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
397
398   g_assert_cmpstr (testbuf, ==, buf);
399
400   g_socket_shutdown (client, FALSE, TRUE, &error);
401   g_assert_no_error (error);
402
403   g_thread_join (data->thread);
404
405   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
406   g_assert_no_error (error);
407   g_assert_cmpint (len, ==, 0);
408
409   g_socket_close (client, &error);
410   g_assert_no_error (error);
411   g_socket_close (data->server, &error);
412   g_assert_no_error (error);
413
414   g_object_unref (data->server);
415   g_object_unref (client);
416
417   g_slice_free (IPTestData, data);
418 }
419
420 static void
421 test_ipv4_sync (void)
422 {
423   test_ip_sync (G_SOCKET_FAMILY_IPV4);
424 }
425
426 static void
427 test_ipv6_sync (void)
428 {
429   test_ip_sync (G_SOCKET_FAMILY_IPV6);
430 }
431
432 static gpointer
433 graceful_server_thread (gpointer user_data)
434 {
435   IPTestData *data = user_data;
436   GSocket *sock;
437   GError *error = NULL;
438   gssize len;
439
440   sock = g_socket_accept (data->server, NULL, &error);
441   g_assert_no_error (error);
442
443   len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
444   g_assert_no_error (error);
445   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
446
447   return sock;
448 }
449
450 static void
451 test_close_graceful (void)
452 {
453   GSocketFamily family = G_SOCKET_FAMILY_IPV4;
454   IPTestData *data;
455   GError *error = NULL;
456   GSocket *client, *server;
457   GSocketAddress *addr;
458   gssize len;
459   gchar buf[128];
460
461   data = create_server (family, graceful_server_thread, FALSE);
462   addr = g_socket_get_local_address (data->server, &error);
463
464   client = g_socket_new (family,
465                          G_SOCKET_TYPE_STREAM,
466                          G_SOCKET_PROTOCOL_DEFAULT,
467                          &error);
468   g_assert_no_error (error);
469
470   g_assert_cmpint (g_socket_get_family (client), ==, family);
471   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
472   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
473
474   g_socket_set_blocking (client, TRUE);
475   g_socket_set_timeout (client, 1);
476
477   g_socket_connect (client, addr, NULL, &error);
478   g_assert_no_error (error);
479   g_assert (g_socket_is_connected (client));
480   g_object_unref (addr);
481
482   server = g_thread_join (data->thread);
483
484   /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
485   g_socket_shutdown (server, FALSE, TRUE, &error);
486   g_assert_no_error (error);
487
488   /* we must timeout */
489   g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
490   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
491   g_clear_error (&error);
492
493   /* check that the remaining data is received */
494   len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
495   g_assert_no_error (error);
496   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
497
498   /* and only then the connection is closed */
499   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
500   g_assert_no_error (error);
501   g_assert_cmpint (len, ==, 0);
502
503   g_socket_close (server, &error);
504   g_assert_no_error (error);
505
506   g_socket_close (client, &error);
507   g_assert_no_error (error);
508
509   g_object_unref (server);
510   g_object_unref (data->server);
511   g_object_unref (client);
512
513   g_slice_free (IPTestData, data);
514 }
515
516 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
517 static gpointer
518 v4mapped_server_thread (gpointer user_data)
519 {
520   IPTestData *data = user_data;
521   GSocket *sock;
522   GError *error = NULL;
523   GSocketAddress *addr;
524
525   sock = g_socket_accept (data->server, NULL, &error);
526   g_assert_no_error (error);
527
528   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
529
530   addr = g_socket_get_local_address (sock, &error);
531   g_assert_no_error (error);
532   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
533   g_object_unref (addr);
534
535   addr = g_socket_get_remote_address (sock, &error);
536   g_assert_no_error (error);
537   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
538   g_object_unref (addr);
539
540   g_socket_close (sock, &error);
541   g_assert_no_error (error);
542   g_object_unref (sock);
543   return NULL;
544 }
545
546 static void
547 test_ipv6_v4mapped (void)
548 {
549   IPTestData *data;
550   GError *error = NULL;
551   GSocket *client;
552   GSocketAddress *addr, *v4addr;
553   GInetAddress *iaddr;
554
555   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
556
557   if (data == NULL)
558     {
559       g_test_message ("Test not run: not supported by the OS");
560       return;
561     }
562
563   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
564                          G_SOCKET_TYPE_STREAM,
565                          G_SOCKET_PROTOCOL_DEFAULT,
566                          &error);
567   g_assert_no_error (error);
568
569   g_socket_set_blocking (client, TRUE);
570   g_socket_set_timeout (client, 1);
571
572   addr = g_socket_get_local_address (data->server, &error);
573   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
574   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
575   g_object_unref (iaddr);
576   g_object_unref (addr);
577
578   g_socket_connect (client, v4addr, NULL, &error);
579   g_assert_no_error (error);
580   g_assert (g_socket_is_connected (client));
581
582   g_thread_join (data->thread);
583
584   g_socket_close (client, &error);
585   g_assert_no_error (error);
586   g_socket_close (data->server, &error);
587   g_assert_no_error (error);
588
589   g_object_unref (data->server);
590   g_object_unref (client);
591   g_object_unref (v4addr);
592
593   g_slice_free (IPTestData, data);
594 }
595 #endif
596
597 static void
598 test_timed_wait (void)
599 {
600   IPTestData *data;
601   GError *error = NULL;
602   GSocket *client;
603   GSocketAddress *addr;
604   gint64 start_time;
605   gint poll_duration;
606
607   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
608   addr = g_socket_get_local_address (data->server, &error);
609
610   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
611                          G_SOCKET_TYPE_STREAM,
612                          G_SOCKET_PROTOCOL_DEFAULT,
613                          &error);
614   g_assert_no_error (error);
615
616   g_socket_set_blocking (client, TRUE);
617   g_socket_set_timeout (client, 1);
618
619   g_socket_connect (client, addr, NULL, &error);
620   g_assert_no_error (error);
621   g_object_unref (addr);
622
623   start_time = g_get_monotonic_time ();
624   g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
625                                  NULL, &error);
626   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
627   g_clear_error (&error);
628   poll_duration = g_get_monotonic_time () - start_time;
629
630   g_assert_cmpint (poll_duration, >=, 98000);
631   g_assert_cmpint (poll_duration, <, 112000);
632
633   g_socket_close (client, &error);
634   g_assert_no_error (error);
635
636   g_thread_join (data->thread);
637
638   g_socket_close (data->server, &error);
639   g_assert_no_error (error);
640
641   g_object_unref (data->server);
642   g_object_unref (client);
643
644   g_slice_free (IPTestData, data);
645 }
646
647 static void
648 test_sockaddr (void)
649 {
650   struct sockaddr_in6 sin6, gsin6;
651   GSocketAddress *saddr;
652   GInetSocketAddress *isaddr;
653   GInetAddress *iaddr;
654   GError *error = NULL;
655
656   memset (&sin6, 0, sizeof (sin6));
657   sin6.sin6_family = AF_INET6;
658   sin6.sin6_addr = in6addr_loopback;
659   sin6.sin6_port = g_htons (42);
660   sin6.sin6_scope_id = 17;
661   sin6.sin6_flowinfo = 1729;
662
663   saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
664   g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
665
666   isaddr = G_INET_SOCKET_ADDRESS (saddr);
667   iaddr = g_inet_socket_address_get_address (isaddr);
668   g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
669   g_assert (g_inet_address_get_is_loopback (iaddr));
670
671   g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
672   g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
673   g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
674
675   g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
676   g_assert_no_error (error);
677
678   g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
679   g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
680   g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
681   g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
682
683   g_object_unref (saddr);
684 }
685
686 #ifdef G_OS_UNIX
687 static void
688 test_unix_from_fd (void)
689 {
690   gint fd;
691   GError *error;
692   GSocket *s;
693
694   fd = socket (AF_UNIX, SOCK_STREAM, 0);
695   g_assert_cmpint (fd, !=, -1);
696
697   error = NULL;
698   s = g_socket_new_from_fd (fd, &error);
699   g_assert_no_error (error);
700   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
701   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
702   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
703   g_object_unref (s);
704 }
705
706 static void
707 test_unix_connection (void)
708 {
709   gint fd;
710   GError *error;
711   GSocket *s;
712   GSocketConnection *c;
713
714   fd = socket (AF_UNIX, SOCK_STREAM, 0);
715   g_assert_cmpint (fd, !=, -1);
716
717   error = NULL;
718   s = g_socket_new_from_fd (fd, &error);
719   g_assert_no_error (error);
720   c = g_socket_connection_factory_create_connection (s);
721   g_assert (G_IS_UNIX_CONNECTION (c));
722   g_object_unref (c);
723   g_object_unref (s);
724 }
725
726 static GSocketConnection *
727 create_connection_for_fd (int fd)
728 {
729   GError *err = NULL;
730   GSocket *socket;
731   GSocketConnection *connection;
732
733   socket = g_socket_new_from_fd (fd, &err);
734   g_assert_no_error (err);
735   g_assert (G_IS_SOCKET (socket));
736   connection = g_socket_connection_factory_create_connection (socket);
737   g_assert (G_IS_UNIX_CONNECTION (connection));
738   g_object_unref (socket);
739   return connection;
740 }
741
742 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
743
744 static void
745 test_unix_connection_ancillary_data (void)
746 {
747   GError *err = NULL;
748   gint pv[2], sv[3];
749   gint status, fd, len;
750   char buffer[1024];
751   pid_t pid;
752
753   status = pipe (pv);
754   g_assert_cmpint (status, ==, 0);
755
756   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
757   g_assert_cmpint (status, ==, 0);
758
759   pid = fork ();
760   g_assert_cmpint (pid, >=, 0);
761
762   /* Child: close its copy of the write end of the pipe, receive it
763    * again from the parent over the socket, and write some text to it.
764    *
765    * Parent: send the write end of the pipe (still open for the
766    * parent) over the socket, close it, and read some text from the
767    * read end of the pipe.
768    */
769   if (pid == 0)
770     {
771       GSocketConnection *connection;
772
773       close (sv[1]);
774       connection = create_connection_for_fd (sv[0]);
775
776       status = close (pv[1]);
777       g_assert_cmpint (status, ==, 0);
778
779       err = NULL;
780       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
781                                          &err);
782       g_assert_no_error (err);
783       g_assert_cmpint (fd, >, -1);
784       g_object_unref (connection);
785
786       do
787         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
788       while (len == -1 && errno == EINTR);
789       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
790       exit (0);
791     }
792   else
793     {
794       GSocketConnection *connection;
795
796       close (sv[0]);
797       connection = create_connection_for_fd (sv[1]);
798
799       err = NULL;
800       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
801                                  &err);
802       g_assert_no_error (err);
803       g_object_unref (connection);
804
805       status = close (pv[1]);
806       g_assert_cmpint (status, ==, 0);
807
808       memset (buffer, 0xff, sizeof buffer);
809       do
810         len = read (pv[0], buffer, sizeof buffer);
811       while (len == -1 && errno == EINTR);
812
813       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
814       g_assert_cmpstr (buffer, ==, TEST_DATA);
815
816       waitpid (pid, &status, 0);
817       g_assert (WIFEXITED (status));
818       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
819     }
820
821   /* TODO: add test for g_unix_connection_send_credentials() and
822    * g_unix_connection_receive_credentials().
823    */
824 }
825 #endif /* G_OS_UNIX */
826
827 static void
828 test_reuse_tcp (void)
829 {
830   GSocket *sock1, *sock2;
831   GError *error = NULL;
832   GInetAddress *iaddr;
833   GSocketAddress *addr;
834
835   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
836                         G_SOCKET_TYPE_STREAM,
837                         G_SOCKET_PROTOCOL_DEFAULT,
838                         &error);
839   g_assert_no_error (error);
840
841   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
842   addr = g_inet_socket_address_new (iaddr, 0);
843   g_object_unref (iaddr);
844   g_socket_bind (sock1, addr, TRUE, &error);
845   g_object_unref (addr);
846   g_assert_no_error (error);
847
848   g_socket_listen (sock1, &error);
849   g_assert_no_error (error);
850
851   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
852                         G_SOCKET_TYPE_STREAM,
853                         G_SOCKET_PROTOCOL_DEFAULT,
854                         &error);
855   g_assert_no_error (error);
856
857   addr = g_socket_get_local_address (sock1, &error);
858   g_assert_no_error (error);
859   g_socket_bind (sock2, addr, TRUE, &error);
860   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
861   g_object_unref (addr);
862
863   g_object_unref (sock1);
864   g_object_unref (sock2);
865 }
866
867 static void
868 test_reuse_udp (void)
869 {
870   GSocket *sock1, *sock2;
871   GError *error = NULL;
872   GInetAddress *iaddr;
873   GSocketAddress *addr;
874
875   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
876                         G_SOCKET_TYPE_DATAGRAM,
877                         G_SOCKET_PROTOCOL_DEFAULT,
878                         &error);
879   g_assert_no_error (error);
880
881   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
882   addr = g_inet_socket_address_new (iaddr, 0);
883   g_object_unref (iaddr);
884   g_socket_bind (sock1, addr, TRUE, &error);
885   g_object_unref (addr);
886   g_assert_no_error (error);
887
888   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
889                         G_SOCKET_TYPE_DATAGRAM,
890                         G_SOCKET_PROTOCOL_DEFAULT,
891                         &error);
892   g_assert_no_error (error);
893
894   addr = g_socket_get_local_address (sock1, &error);
895   g_assert_no_error (error);
896   g_socket_bind (sock2, addr, TRUE, &error);
897   g_object_unref (addr);
898   g_assert_no_error (error);
899
900   g_object_unref (sock1);
901   g_object_unref (sock2);
902 }
903
904 int
905 main (int   argc,
906       char *argv[])
907 {
908   g_test_init (&argc, &argv, NULL);
909
910   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
911   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
912   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
913   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
914 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
915   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
916 #endif
917   g_test_add_func ("/socket/close_graceful", test_close_graceful);
918   g_test_add_func ("/socket/timed_wait", test_timed_wait);
919   g_test_add_func ("/socket/address", test_sockaddr);
920 #ifdef G_OS_UNIX
921   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
922   g_test_add_func ("/socket/unix-connection", test_unix_connection);
923   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
924 #endif
925   g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
926   g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
927
928   return g_test_run();
929 }
930