/* GLib testing framework examples and tests

 *

 * Copyright (C) 2008-2011 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include <gio/gio.h>

#ifdef G_OS_UNIX

#include <errno.h>

#include <sys/wait.h>

#include <string.h>

#include <stdlib.h>

#include <gio/gnetworking.h>

#include <gio/gunixconnection.h>

#endif

#include "gnetworkingprivate.h"

static gboolean ipv6_supported;

typedef struct {

  GSocket *server;

  GSocket *client;

  GSocketFamily family;

  GThread *thread;

  GMainLoop *loop;

  GCancellable *cancellable; /* to shut down dgram echo server thread */

} IPTestData;

static gpointer

echo_server_dgram_thread (gpointer user_data)

{

  IPTestData *data = user_data;

  GSocketAddress *sa;

  GCancellable *cancellable = data->cancellable;

  GSocket *sock;

  GError *error = NULL;

  gssize nread, nwrote;

  gchar buf[128];

  sock = data->server;

  while (TRUE)

    {

      nread = g_socket_receive_from (sock, &sa, buf, sizeof (buf), cancellable, &error);

      if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

        break;

      g_assert_no_error (error);

      g_assert_cmpint (nread, >=, 0);

      nwrote = g_socket_send_to (sock, sa, buf, nread, cancellable, &error);

      if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

        break;

      g_assert_no_error (error);

      g_assert_cmpint (nwrote, ==, nread);

      g_object_unref (sa);

    }

  g_clear_error (&error);

  return NULL;

}

static gpointer

echo_server_thread (gpointer user_data)

{

  IPTestData *data = user_data;

  GSocket *sock;

  GError *error = NULL;

  gssize nread, nwrote;

  gchar buf[128];

  sock = g_socket_accept (data->server, NULL, &error);

  g_assert_no_error (error);

  while (TRUE)

    {

      nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);

      g_assert_no_error (error);

      g_assert_cmpint (nread, >=, 0);

      if (nread == 0)

	break;

      nwrote = g_socket_send (sock, buf, nread, NULL, &error);

      g_assert_no_error (error);

      g_assert_cmpint (nwrote, ==, nread);

    }

  g_socket_close (sock, &error);

  g_assert_no_error (error);

  g_object_unref (sock);

  return NULL;

}

static IPTestData *

create_server_full (GSocketFamily family,

		    GSocketType   socket_type,

		    GThreadFunc   server_thread,

		    gboolean      v4mapped)

{

  IPTestData *data;

  GSocket *server;

  GError *error = NULL;

  GSocketAddress *addr;

  GInetAddress *iaddr;

  data = g_slice_new (IPTestData);

  data->family = family;

  data->server = server = g_socket_new (family,

					socket_type,

					G_SOCKET_PROTOCOL_DEFAULT,

					&error);

  g_assert_no_error (error);

  g_assert_cmpint (g_socket_get_family (server), ==, family);

  g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);

  g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_set_blocking (server, TRUE);

#if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)

  if (v4mapped)

    {

      g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);

      if (! g_socket_speaks_ipv4 (data->server))

        {

          g_object_unref (data->server);

          g_slice_free (IPTestData, data);

          return NULL;

        }

    }

#endif

  if (v4mapped)

    iaddr = g_inet_address_new_any (family);

  else

    iaddr = g_inet_address_new_loopback (family);

  addr = g_inet_socket_address_new (iaddr, 0);

  g_object_unref (iaddr);

  g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);

  g_socket_bind (server, addr, TRUE, &error);

  g_assert_no_error (error);

  g_object_unref (addr);

  addr = g_socket_get_local_address (server, &error);

  g_assert_no_error (error);

  g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);

  g_object_unref (addr);

  if (socket_type == G_SOCKET_TYPE_STREAM)

    {

      g_socket_listen (server, &error);

      g_assert_no_error (error);

    }

  else

    {

      data->cancellable = g_cancellable_new ();

    }

  data->thread = g_thread_new ("server", server_thread, data);

  return data;

}

static IPTestData *

create_server (GSocketFamily family,

	       GThreadFunc   server_thread,

	       gboolean      v4mapped)

{

  return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped);

}

static const gchar *testbuf = "0123456789abcdef";

static gboolean

test_ip_async_read_ready (GSocket      *client,

			  GIOCondition  cond,

			  gpointer      user_data)

{

  IPTestData *data = user_data;

  GError *error = NULL;

  gssize len;

  gchar buf[128];

  g_assert_cmpint (cond, ==, G_IO_IN);

  len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  g_assert_cmpstr (testbuf, ==, buf);

  g_main_loop_quit (data->loop);

  return FALSE;

}

static gboolean

test_ip_async_write_ready (GSocket      *client,

			   GIOCondition  cond,

			   gpointer      user_data)

{

  IPTestData *data = user_data;

  GError *error = NULL;

  GSource *source;

  gssize len;

  g_assert_cmpint (cond, ==, G_IO_OUT);

  len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  source = g_socket_create_source (client, G_IO_IN, NULL);

  g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,

			 data, NULL);

  g_source_attach (source, NULL);

  g_source_unref (source);

  return FALSE;

}

static gboolean

test_ip_async_timed_out (GSocket      *client,

			 GIOCondition  cond,

			 gpointer      user_data)

{

  IPTestData *data = user_data;

  GError *error = NULL;

  GSource *source;

  gssize len;

  gchar buf[128];

  if (data->family == G_SOCKET_FAMILY_IPV4)

    {

      g_assert_cmpint (cond, ==, G_IO_IN);

      len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

      g_assert_cmpint (len, ==, -1);

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);

      g_clear_error (&error);

    }

  source = g_socket_create_source (client, G_IO_OUT, NULL);

  g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,

			 data, NULL);

  g_source_attach (source, NULL);

  g_source_unref (source);

  return FALSE;

}

static gboolean

test_ip_async_connected (GSocket      *client,

			 GIOCondition  cond,

			 gpointer      user_data)

{

  IPTestData *data = user_data;

  GError *error = NULL;

  GSource *source;

  gssize len;

  gchar buf[128];

  g_socket_check_connect_result (client, &error);

  g_assert_no_error (error);

  /* We do this after the check_connect_result, since that will give a

   * more useful assertion in case of error.

   */

  g_assert_cmpint (cond, ==, G_IO_OUT);

  g_assert (g_socket_is_connected (client));

  /* This adds 1 second to "make check", so let's just only do it once. */

  if (data->family == G_SOCKET_FAMILY_IPV4)

    {

      len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

      g_assert_cmpint (len, ==, -1);

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);

      g_clear_error (&error);

      source = g_socket_create_source (client, G_IO_IN, NULL);

      g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,

			     data, NULL);

      g_source_attach (source, NULL);

      g_source_unref (source);

    }

  else

    test_ip_async_timed_out (client, 0, data);

  return FALSE;

}

static gboolean

idle_test_ip_async_connected (gpointer user_data)

{

  IPTestData *data = user_data;

  return test_ip_async_connected (data->client, G_IO_OUT, data);

}

static void

test_ip_async (GSocketFamily family)

{

  IPTestData *data;

  GError *error = NULL;

  GSocket *client;

  GSocketAddress *addr;

  GSource *source;

  gssize len;

  gchar buf[128];

  data = create_server (family, echo_server_thread, FALSE);

  addr = g_socket_get_local_address (data->server, &error);

  g_assert_no_error (error);

  client = g_socket_new (family,

			 G_SOCKET_TYPE_STREAM,

			 G_SOCKET_PROTOCOL_DEFAULT,

			 &error);

  g_assert_no_error (error);

  data->client = client;

  g_assert_cmpint (g_socket_get_family (client), ==, family);

  g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);

  g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_set_blocking (client, FALSE);

  g_socket_set_timeout (client, 1);

  if (g_socket_connect (client, addr, NULL, &error))

    {

      g_assert_no_error (error);

      g_idle_add (idle_test_ip_async_connected, data);

    }

  else

    {

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);

      g_clear_error (&error);

      source = g_socket_create_source (client, G_IO_OUT, NULL);

      g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,

			     data, NULL);

      g_source_attach (source, NULL);

      g_source_unref (source);

    }

  g_object_unref (addr);

  data->loop = g_main_loop_new (NULL, TRUE);

  g_main_loop_run (data->loop);

  g_main_loop_unref (data->loop);

  g_socket_shutdown (client, FALSE, TRUE, &error);

  g_assert_no_error (error);

  g_thread_join (data->thread);

  if (family == G_SOCKET_FAMILY_IPV4)

    {

      /* Test that reading on a remote-closed socket gets back 0 bytes. */

      len = g_socket_receive_with_blocking (client, buf, sizeof (buf),

					    TRUE, NULL, &error);

      g_assert_no_error (error);

      g_assert_cmpint (len, ==, 0);

    }

  else

    {

      /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */

      len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,

					 TRUE, NULL, &error);

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);

      g_assert_cmpint (len, ==, -1);

      g_clear_error (&error);

    }

  g_socket_close (client, &error);

  g_assert_no_error (error);

  g_socket_close (data->server, &error);

  g_assert_no_error (error);

  g_object_unref (data->server);

  g_object_unref (client);

  g_slice_free (IPTestData, data);

}

static void

test_ipv4_async (void)

{

  test_ip_async (G_SOCKET_FAMILY_IPV4);

}

static void

test_ipv6_async (void)

{

  if (!ipv6_supported)

    {

      g_test_skip ("No support for IPv6");

      return;

    }

  test_ip_async (G_SOCKET_FAMILY_IPV6);

}

static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";

static void

test_ip_sync (GSocketFamily family)

{

  IPTestData *data;

  GError *error = NULL;

  GSocket *client;

  GSocketAddress *addr;

  gssize len;

  gchar buf[128];

  data = create_server (family, echo_server_thread, FALSE);

  addr = g_socket_get_local_address (data->server, &error);

  g_assert_no_error (error);

  client = g_socket_new (family,

			 G_SOCKET_TYPE_STREAM,

			 G_SOCKET_PROTOCOL_DEFAULT,

			 &error);

  g_assert_no_error (error);

  g_assert_cmpint (g_socket_get_family (client), ==, family);

  g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);

  g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_set_blocking (client, TRUE);

  g_socket_set_timeout (client, 1);

  g_socket_connect (client, addr, NULL, &error);

  g_assert_no_error (error);

  g_assert (g_socket_is_connected (client));

  g_object_unref (addr);

  /* This adds 1 second to "make check", so let's just only do it once. */

  if (family == G_SOCKET_FAMILY_IPV4)

    {

      len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

      g_assert_cmpint (len, ==, -1);

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);

      g_clear_error (&error);

    }

  len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  g_assert_cmpstr (testbuf, ==, buf);

  {

    GOutputVector v[7] = { { NULL, }, };

    v[0].buffer = testbuf2 + 0;

    v[0].size = 3;

    v[1].buffer = testbuf2 + 3;

    v[1].size = 5;

    v[2].buffer = testbuf2 + 3 + 5;

    v[2].size = 0;

    v[3].buffer = testbuf2 + 3 + 5;

    v[3].size = 6;

    v[4].buffer = testbuf2 + 3 + 5 + 6;

    v[4].size = 2;

    v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;

    v[5].size = 1;

    v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;

    v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);

    len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, strlen (testbuf2));

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, strlen (testbuf2));

    g_assert_cmpstr (testbuf2, ==, buf);

  }

  g_socket_shutdown (client, FALSE, TRUE, &error);

  g_assert_no_error (error);

  g_thread_join (data->thread);

  if (family == G_SOCKET_FAMILY_IPV4)

    {

      /* Test that reading on a remote-closed socket gets back 0 bytes. */

      len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);

      g_assert_no_error (error);

      g_assert_cmpint (len, ==, 0);

    }

  else

    {

      /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */

      len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);

      g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);

      g_assert_cmpint (len, ==, -1);

      g_clear_error (&error);

    }

  g_socket_close (client, &error);

  g_assert_no_error (error);

  g_socket_close (data->server, &error);

  g_assert_no_error (error);

  g_object_unref (data->server);

  g_object_unref (client);

  g_slice_free (IPTestData, data);

}

static void

test_ipv4_sync (void)

{

  test_ip_sync (G_SOCKET_FAMILY_IPV4);

}

static void

test_ipv6_sync (void)

{

  if (!ipv6_supported)

    {

      g_test_skip ("No support for IPv6");

      return;

    }

  test_ip_sync (G_SOCKET_FAMILY_IPV6);

}

static void

test_ip_sync_dgram (GSocketFamily family)

{

  IPTestData *data;

  GError *error = NULL;

  GSocket *client;

  GSocketAddress *dest_addr;

  gssize len;

  gchar buf[128];

  data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,

                             echo_server_dgram_thread, FALSE);

  dest_addr = g_socket_get_local_address (data->server, &error);

  client = g_socket_new (family,

			 G_SOCKET_TYPE_DATAGRAM,

			 G_SOCKET_PROTOCOL_DEFAULT,

			 &error);

  g_assert_no_error (error);

  g_assert_cmpint (g_socket_get_family (client), ==, family);

  g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);

  g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_set_blocking (client, TRUE);

  g_socket_set_timeout (client, 1);

  len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

  g_assert_no_error (error);

  g_assert_cmpint (len, ==, strlen (testbuf) + 1);

  g_assert_cmpstr (testbuf, ==, buf);

  {

    GOutputMessage m[3] = { { NULL, }, };

    GInputMessage im[3] = { { NULL, }, };

    GOutputVector v[7] = { { NULL, }, };

    GInputVector iv[7] = { { NULL, }, };

    v[0].buffer = testbuf2 + 0;

    v[0].size = 3;

    v[1].buffer = testbuf2 + 3;

    v[1].size = 5;

    v[2].buffer = testbuf2 + 3 + 5;

    v[2].size = 0;

    v[3].buffer = testbuf2 + 3 + 5;

    v[3].size = 6;

    v[4].buffer = testbuf2 + 3 + 5 + 6;

    v[4].size = 2;

    v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;

    v[5].size = 1;

    v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;

    v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);

    iv[0].buffer = buf + 0;

    iv[0].size = 3;

    iv[1].buffer = buf + 3;

    iv[1].size = 5;

    iv[2].buffer = buf + 3 + 5;

    iv[2].size = 0;

    iv[3].buffer = buf + 3 + 5;

    iv[3].size = 6;

    iv[4].buffer = buf + 3 + 5 + 6;

    iv[4].size = 2;

    iv[5].buffer = buf + 3 + 5 + 6 + 2;

    iv[5].size = 1;

    iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;

    iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);

    len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, strlen (testbuf2));

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, strlen (testbuf2));

    g_assert_cmpstr (testbuf2, ==, buf);

    m[0].vectors = &v[0];

    m[0].num_vectors = 1;

    m[0].address = dest_addr;

    m[1].vectors = &v[0];

    m[1].num_vectors = 6;

    m[1].address = dest_addr;

    m[2].vectors = &v[6];

    m[2].num_vectors = 1;

    m[2].address = dest_addr;

    len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, G_N_ELEMENTS (m));

    g_assert_cmpint (m[0].bytes_sent, ==, 3);

    g_assert_cmpint (m[1].bytes_sent, ==, 17);

    g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, 3);

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

    g_assert_no_error (error);

    /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */

    g_assert_cmpint (len, ==, 17);

    g_assert (memcmp (testbuf2, buf, 17) == 0);

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, v[6].size);

    g_assert_cmpstr (buf, ==, v[6].buffer);

    /* reset since we're re-using the message structs */

    m[0].bytes_sent = 0;

    m[1].bytes_sent = 0;

    m[2].bytes_sent = 0;

    /* now try receiving multiple messages */

    len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, G_N_ELEMENTS (m));

    g_assert_cmpint (m[0].bytes_sent, ==, 3);

    g_assert_cmpint (m[1].bytes_sent, ==, 17);

    g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);

    im[0].vectors = &iv[0];

    im[0].num_vectors = 1;

    im[1].vectors = &iv[0];

    im[1].num_vectors = 6;

    im[2].vectors = &iv[6];

    im[2].num_vectors = 1;

    memset (buf, 0, sizeof (buf));

    len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,

                                     NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, G_N_ELEMENTS (im));

    g_assert_cmpuint (im[0].bytes_received, ==, 3);

    /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */

    g_assert_cmpuint (im[1].bytes_received, ==, 17);

    g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);

    /* reset since we're re-using the message structs */

    m[0].bytes_sent = 0;

    m[1].bytes_sent = 0;

    m[2].bytes_sent = 0;

    /* now try to generate an early return by omitting the destination address on [1] */

    m[1].address = NULL;

    len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);

    g_assert_no_error (error);

    g_assert_cmpint (len, ==, 1);

    g_assert_cmpint (m[0].bytes_sent, ==, 3);

    g_assert_cmpint (m[1].bytes_sent, ==, 0);

    g_assert_cmpint (m[2].bytes_sent, ==, 0);

    /* reset since we're re-using the message structs */

    m[0].bytes_sent = 0;

    m[1].bytes_sent = 0;

    m[2].bytes_sent = 0;

    /* now try to generate an error by omitting all destination addresses */

    m[0].address = NULL;

    m[1].address = NULL;

    m[2].address = NULL;

    len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);

    g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);

    g_clear_error (&error);

    g_assert_cmpint (len, ==, -1);

    g_assert_cmpint (m[0].bytes_sent, ==, 0);

    g_assert_cmpint (m[1].bytes_sent, ==, 0);

    g_assert_cmpint (m[2].bytes_sent, ==, 0);

    len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);

    g_assert_cmpint (len, ==, 3);

  }

  g_cancellable_cancel (data->cancellable);

  g_thread_join (data->thread);

  g_socket_close (client, &error);

  g_assert_no_error (error);

  g_socket_close (data->server, &error);

  g_assert_no_error (error);

  g_object_unref (data->server);

  g_object_unref (data->cancellable);

  g_object_unref (client);

  g_object_unref (dest_addr);

  g_slice_free (IPTestData, data);

}

static void

test_ipv4_sync_dgram (void)

{

  test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);

}

static void

test_ipv6_sync_dgram (void)

{

  if (!ipv6_supported)

    {

      g_test_skip ("No support for IPv6");

      return;

    }

  test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);

}

static gpointer

cancellable_thread_cb (gpointer data)

{

  GCancellable *cancellable = data;

  g_usleep (0.1 * G_USEC_PER_SEC);

  g_cancellable_cancel (cancellable);

  g_object_unref (cancellable);

  return NULL;

}

static void

test_ip_sync_dgram_timeouts (GSocketFamily family)

{

  GError *error = NULL;

  GSocket *client = NULL;

  GCancellable *cancellable = NULL;

  GThread *cancellable_thread = NULL;

  gssize len;

  client = g_socket_new (family,

                         G_SOCKET_TYPE_DATAGRAM,

                         G_SOCKET_PROTOCOL_DEFAULT,

                         &error);

  g_assert_no_error (error);

  g_assert_cmpint (g_socket_get_family (client), ==, family);

  g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);

  g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);

  /* No overall timeout: test the per-operation timeouts instead. */

  g_socket_set_timeout (client, 0);

  cancellable = g_cancellable_new ();

  /* Check for timeouts when no server is running. */

  {

    gint64 start_time;

    GInputMessage im = { NULL, };

    GInputVector iv = { NULL, };

    guint8 buf[128];

    iv.buffer = buf;

    iv.size = sizeof (buf);

    im.vectors = &iv;

    im.num_vectors = 1;

    memset (buf, 0, sizeof (buf));

    /* Try a non-blocking read. */

    g_socket_set_blocking (client, FALSE);

    len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,

                                     NULL, &error);

    g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);

    g_assert_cmpint (len, ==, -1);

    g_clear_error (&error);

    /* Try a timeout read. Can’t really validate the time taken more than

     * checking it’s positive. */

    g_socket_set_timeout (client, 1);

    g_socket_set_blocking (client, TRUE);

    start_time = g_get_monotonic_time ();

    len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,

                                     NULL, &error);

    g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);

    g_assert_cmpint (len, ==, -1);

    g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);

    g_clear_error (&error);

    /* Try a blocking read, cancelled from another thread. */

    g_socket_set_timeout (client, 0);

    cancellable_thread = g_thread_new ("cancellable",

                                       cancellable_thread_cb,

                                       g_object_ref (cancellable));

    start_time = g_get_monotonic_time ();

    len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,

                                     cancellable, &error);

    g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);

    g_assert_cmpint (len, ==, -1);

    g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);

    g_clear_error (&error);

    g_thread_join (cancellable_thread);

  }

  g_socket_close (client, &error);

  g_assert_no_error (error);

  g_object_unref (client);

  g_object_unref (cancellable);

}

static void

test_ipv4_sync_dgram_timeouts (void)

{

  test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);

}

static void

test_ipv6_sync_dgram_timeouts (void)

{

  if (!ipv6_supported)

    {

      g_test_skip ("No support for IPv6");

      return;