gio/gsocketconnection.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright © 2008 Christian Kellner, Samuel Cormier-Iijima
   4  *           © 2008 codethink
   5  * Copyright © 2009 Red Hat, Inc
   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  * Authors: Christian Kellner <gicmo@gnome.org>
  21  *          Samuel Cormier-Iijima <sciyoshi@gmail.com>
  22  *          Ryan Lortie <desrt@desrt.ca>
  23  *          Alexander Larsson <alexl@redhat.com>
  24  */
  25
  26 #include "config.h"
  27
  28 #include "gsocketconnection.h"
  29
  30 #include "gsocketoutputstream.h"
  31 #include "gsocketinputstream.h"
  32 #include "gioprivate.h"
  33 #include <gio/giostream.h>
  34 #include <gio/gtask.h>
  35 #include "gunixconnection.h"
  36 #include "gtcpconnection.h"
  37 #include "glibintl.h"
  38
  39
  40 /**
  41  * SECTION:gsocketconnection
  42  * @short_description: A socket connection
  43  * @include: gio/gio.h
  44  * @see_also: #GIOStream, #GSocketClient, #GSocketListener
  45  *
  46  * #GSocketConnection is a #GIOStream for a connected socket. They
  47  * can be created either by #GSocketClient when connecting to a host,
  48  * or by #GSocketListener when accepting a new client.
  49  *
  50  * The type of the #GSocketConnection object returned from these calls
  51  * depends on the type of the underlying socket that is in use. For
  52  * instance, for a TCP/IP connection it will be a #GTcpConnection.
  53  *
  54  * Choosing what type of object to construct is done with the socket
  55  * connection factory, and it is possible for 3rd parties to register
  56  * custom socket connection types for specific combination of socket
  57  * family/type/protocol using g_socket_connection_factory_register_type().
  58  *
  59  * To close a #GSocketConnection, use g_io_stream_close(). Closing both
  60  * substreams of the #GIOStream separately will not close the underlying
  61  * #GSocket.
  62  *
  63  * Since: 2.22
  64  */
  65
  66 enum
  67 {
  68   PROP_NONE,
  69   PROP_SOCKET,
  70 };
  71
  72 struct _GSocketConnectionPrivate
  73 {
  74   GSocket       *socket;
  75   GInputStream  *input_stream;
  76   GOutputStream *output_stream;
  77
  78   GSocketAddress *cached_remote_address;
  79
  80   gboolean       in_dispose;
  81 };
  82
  83 static gboolean g_socket_connection_close         (GIOStream            *stream,
  84                                                    GCancellable         *cancellable,
  85                                                    GError              **error);
  86 static void     g_socket_connection_close_async   (GIOStream            *stream,
  87                                                    int                   io_priority,
  88                                                    GCancellable         *cancellable,
  89                                                    GAsyncReadyCallback   callback,
  90                                                    gpointer              user_data);
  91 static gboolean g_socket_connection_close_finish  (GIOStream            *stream,
  92                                                    GAsyncResult         *result,
  93                                                    GError              **error);
  94
  95 G_DEFINE_TYPE_WITH_PRIVATE (GSocketConnection, g_socket_connection, G_TYPE_IO_STREAM)
  96
  97 static GInputStream *
  98 g_socket_connection_get_input_stream (GIOStream *io_stream)
  99 {
 100   GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream);
 101
 102   if (connection->priv->input_stream == NULL)
 103     connection->priv->input_stream = (GInputStream *)
 104       _g_socket_input_stream_new (connection->priv->socket);
 105
 106   return connection->priv->input_stream;
 107 }
 108
 109 static GOutputStream *
 110 g_socket_connection_get_output_stream (GIOStream *io_stream)
 111 {
 112   GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream);
 113
 114   if (connection->priv->output_stream == NULL)
 115     connection->priv->output_stream = (GOutputStream *)
 116       _g_socket_output_stream_new (connection->priv->socket);
 117
 118   return connection->priv->output_stream;
 119 }
 120
 121 /**
 122  * g_socket_connection_is_connected:
 123  * @connection: a #GSocketConnection
 124  *
 125  * Checks if @connection is connected. This is equivalent to calling
 126  * g_socket_is_connected() on @connection's underlying #GSocket.
 127  *
 128  * Returns: whether @connection is connected
 129  *
 130  * Since: 2.32
 131  */
 132 gboolean
 133 g_socket_connection_is_connected (GSocketConnection  *connection)
 134 {
 135   return g_socket_is_connected (connection->priv->socket);
 136 }
 137
 138 /**
 139  * g_socket_connection_connect:
 140  * @connection: a #GSocketConnection
 141  * @address: a #GSocketAddress specifying the remote address.
 142  * @cancellable: (nullable): a %GCancellable or %NULL
 143  * @error: #GError for error reporting, or %NULL to ignore.
 144  *
 145  * Connect @connection to the specified remote address.
 146  *
 147  * Returns: %TRUE if the connection succeeded, %FALSE on error
 148  *
 149  * Since: 2.32
 150  */
 151 gboolean
 152 g_socket_connection_connect (GSocketConnection  *connection,
 153                              GSocketAddress     *address,
 154                              GCancellable       *cancellable,
 155                              GError            **error)
 156 {
 157   g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), FALSE);
 158   g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), FALSE);
 159
 160   return g_socket_connect (connection->priv->socket, address,
 161                            cancellable, error);
 162 }
 163
 164 static gboolean g_socket_connection_connect_callback (GSocket      *socket,
 165                                                       GIOCondition  condition,
 166                                                       gpointer      user_data);
 167
 168 /**
 169  * g_socket_connection_connect_async:
 170  * @connection: a #GSocketConnection
 171  * @address: a #GSocketAddress specifying the remote address.
 172  * @cancellable: (nullable): a %GCancellable or %NULL
 173  * @callback: (scope async): a #GAsyncReadyCallback
 174  * @user_data: (closure): user data for the callback
 175  *
 176  * Asynchronously connect @connection to the specified remote address.
 177  *
 178  * This clears the #GSocket:blocking flag on @connection's underlying
 179  * socket if it is currently set.
 180  *
 181  * Use g_socket_connection_connect_finish() to retrieve the result.
 182  *
 183  * Since: 2.32
 184  */
 185 void
 186 g_socket_connection_connect_async (GSocketConnection   *connection,
 187                                    GSocketAddress      *address,
 188                                    GCancellable        *cancellable,
 189                                    GAsyncReadyCallback  callback,
 190                                    gpointer             user_data)
 191 {
 192   GTask *task;
 193   GError *tmp_error = NULL;
 194
 195   g_return_if_fail (G_IS_SOCKET_CONNECTION (connection));
 196   g_return_if_fail (G_IS_SOCKET_ADDRESS (address));
 197
 198   task = g_task_new (connection, cancellable, callback, user_data);
 199   g_task_set_source_tag (task, g_socket_connection_connect_async);
 200
 201   g_socket_set_blocking (connection->priv->socket, FALSE);
 202
 203   if (g_socket_connect (connection->priv->socket, address,
 204                         cancellable, &tmp_error))
 205     {
 206       g_task_return_boolean (task, TRUE);
 207       g_object_unref (task);
 208     }
 209   else if (g_error_matches (tmp_error, G_IO_ERROR, G_IO_ERROR_PENDING))
 210     {
 211       GSource *source;
 212
 213       g_error_free (tmp_error);
 214       source = g_socket_create_source (connection->priv->socket,
 215                                        G_IO_OUT, cancellable);
 216       g_task_attach_source (task, source,
 217                             (GSourceFunc) g_socket_connection_connect_callback);
 218       g_source_unref (source);
 219     }
 220   else
 221     {
 222       g_task_return_error (task, tmp_error);
 223       g_object_unref (task);
 224     }
 225 }
 226
 227 static gboolean
 228 g_socket_connection_connect_callback (GSocket      *socket,
 229                                       GIOCondition  condition,
 230                                       gpointer      user_data)
 231 {
 232   GTask *task = user_data;
 233   GSocketConnection *connection = g_task_get_source_object (task);
 234   GError *error = NULL;
 235
 236   if (g_socket_check_connect_result (connection->priv->socket, &error))
 237     g_task_return_boolean (task, TRUE);
 238   else
 239     g_task_return_error (task, error);
 240
 241   g_object_unref (task);
 242   return FALSE;
 243 }
 244
 245 /**
 246  * g_socket_connection_connect_finish:
 247  * @connection: a #GSocketConnection
 248  * @result: the #GAsyncResult
 249  * @error: #GError for error reporting, or %NULL to ignore.
 250  *
 251  * Gets the result of a g_socket_connection_connect_async() call.
 252  *
 253  * Returns: %TRUE if the connection succeeded, %FALSE on error
 254  *
 255  * Since: 2.32
 256  */
 257 gboolean
 258 g_socket_connection_connect_finish (GSocketConnection  *connection,
 259                                     GAsyncResult       *result,
 260                                     GError            **error)
 261 {
 262   g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), FALSE);
 263   g_return_val_if_fail (g_task_is_valid (result, connection), FALSE);
 264
 265   return g_task_propagate_boolean (G_TASK (result), error);
 266 }
 267
 268 /**
 269  * g_socket_connection_get_socket:
 270  * @connection: a #GSocketConnection
 271  *
 272  * Gets the underlying #GSocket object of the connection.
 273  * This can be useful if you want to do something unusual on it
 274  * not supported by the #GSocketConnection APIs.
 275  *
 276  * Returns: (transfer none): a #GSocket or %NULL on error.
 277  *
 278  * Since: 2.22
 279  */
 280 GSocket *
 281 g_socket_connection_get_socket (GSocketConnection *connection)
 282 {
 283   g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), NULL);
 284
 285   return connection->priv->socket;
 286 }
 287
 288 /**
 289  * g_socket_connection_get_local_address:
 290  * @connection: a #GSocketConnection
 291  * @error: #GError for error reporting, or %NULL to ignore.
 292  *
 293  * Try to get the local address of a socket connection.
 294  *
 295  * Returns: (transfer full): a #GSocketAddress or %NULL on error.
 296  *     Free the returned object with g_object_unref().
 297  *
 298  * Since: 2.22
 299  */
 300 GSocketAddress *
 301 g_socket_connection_get_local_address (GSocketConnection  *connection,
 302                                        GError            **error)
 303 {
 304   return g_socket_get_local_address (connection->priv->socket, error);
 305 }
 306
 307 /**
 308  * g_socket_connection_get_remote_address:
 309  * @connection: a #GSocketConnection
 310  * @error: #GError for error reporting, or %NULL to ignore.
 311  *
 312  * Try to get the remote address of a socket connection.
 313  *
 314  * Since GLib 2.40, when used with g_socket_client_connect() or
 315  * g_socket_client_connect_async(), during emission of
 316  * %G_SOCKET_CLIENT_CONNECTING, this function will return the remote
 317  * address that will be used for the connection.  This allows
 318  * applications to print e.g. "Connecting to example.com
 319  * (10.42.77.3)...".
 320  *
 321  * Returns: (transfer full): a #GSocketAddress or %NULL on error.
 322  *     Free the returned object with g_object_unref().
 323  *
 324  * Since: 2.22
 325  */
 326 GSocketAddress *
 327 g_socket_connection_get_remote_address (GSocketConnection  *connection,
 328                                         GError            **error)
 329 {
 330   if (!g_socket_is_connected (connection->priv->socket))
 331     {
 332       return connection->priv->cached_remote_address ?
 333         g_object_ref (connection->priv->cached_remote_address) : NULL;
 334     }
 335   return g_socket_get_remote_address (connection->priv->socket, error);
 336 }
 337
 338 /* Private API allowing applications to retrieve the resolved address
 339  * now, before we start connecting.
 340  *
 341  * https://bugzilla.gnome.org/show_bug.cgi?id=712547
 342  */
 343 void
 344 g_socket_connection_set_cached_remote_address (GSocketConnection *connection,
 345                                                GSocketAddress    *address)
 346 {
 347   g_clear_object (&connection->priv->cached_remote_address);
 348   connection->priv->cached_remote_address = address ? g_object_ref (address) : NULL;
 349 }
 350
 351 static void
 352 g_socket_connection_get_property (GObject    *object,
 353                                   guint       prop_id,
 354                                   GValue     *value,
 355                                   GParamSpec *pspec)
 356 {
 357   GSocketConnection *connection = G_SOCKET_CONNECTION (object);
 358
 359   switch (prop_id)
 360     {
 361      case PROP_SOCKET:
 362       g_value_set_object (value, connection->priv->socket);
 363       break;
 364
 365      default:
 366       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 367     }
 368 }
 369
 370 static void
 371 g_socket_connection_set_property (GObject      *object,
 372                                   guint         prop_id,
 373                                   const GValue *value,
 374                                   GParamSpec   *pspec)
 375 {
 376   GSocketConnection *connection = G_SOCKET_CONNECTION (object);
 377
 378   switch (prop_id)
 379     {
 380      case PROP_SOCKET:
 381       connection->priv->socket = G_SOCKET (g_value_dup_object (value));
 382       break;
 383
 384      default:
 385       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 386     }
 387 }
 388
 389 static void
 390 g_socket_connection_constructed (GObject *object)
 391 {
 392 #ifndef G_DISABLE_ASSERT
 393   GSocketConnection *connection = G_SOCKET_CONNECTION (object);
 394 #endif
 395
 396   g_assert (connection->priv->socket != NULL);
 397 }
 398
 399 static void
 400 g_socket_connection_dispose (GObject *object)
 401 {
 402   GSocketConnection *connection = G_SOCKET_CONNECTION (object);
 403
 404   connection->priv->in_dispose = TRUE;
 405
 406   g_clear_object (&connection->priv->cached_remote_address);
 407
 408   G_OBJECT_CLASS (g_socket_connection_parent_class)
 409     ->dispose (object);
 410
 411   connection->priv->in_dispose = FALSE;
 412 }
 413
 414 static void
 415 g_socket_connection_finalize (GObject *object)
 416 {
 417   GSocketConnection *connection = G_SOCKET_CONNECTION (object);
 418
 419   if (connection->priv->input_stream)
 420     g_object_unref (connection->priv->input_stream);
 421
 422   if (connection->priv->output_stream)
 423     g_object_unref (connection->priv->output_stream);
 424
 425   g_object_unref (connection->priv->socket);
 426
 427   G_OBJECT_CLASS (g_socket_connection_parent_class)
 428     ->finalize (object);
 429 }
 430
 431 static void
 432 g_socket_connection_class_init (GSocketConnectionClass *klass)
 433 {
 434   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 435   GIOStreamClass *stream_class = G_IO_STREAM_CLASS (klass);
 436
 437   gobject_class->set_property = g_socket_connection_set_property;
 438   gobject_class->get_property = g_socket_connection_get_property;
 439   gobject_class->constructed = g_socket_connection_constructed;
 440   gobject_class->finalize = g_socket_connection_finalize;
 441   gobject_class->dispose = g_socket_connection_dispose;
 442
 443   stream_class->get_input_stream = g_socket_connection_get_input_stream;
 444   stream_class->get_output_stream = g_socket_connection_get_output_stream;
 445   stream_class->close_fn = g_socket_connection_close;
 446   stream_class->close_async = g_socket_connection_close_async;
 447   stream_class->close_finish = g_socket_connection_close_finish;
 448
 449   g_object_class_install_property (gobject_class,
 450                                    PROP_SOCKET,
 451                                    g_param_spec_object ("socket",
 452                                                         P_("Socket"),
 453                                                         P_("The underlying GSocket"),
 454                                                         G_TYPE_SOCKET,
 455                                                         G_PARAM_CONSTRUCT_ONLY |
 456                                                         G_PARAM_READWRITE |
 457                                                         G_PARAM_STATIC_STRINGS));
 458 }
 459
 460 static void
 461 g_socket_connection_init (GSocketConnection *connection)
 462 {
 463   connection->priv = g_socket_connection_get_instance_private (connection);
 464 }
 465
 466 static gboolean
 467 g_socket_connection_close (GIOStream     *stream,
 468                            GCancellable  *cancellable,
 469                            GError       **error)
 470 {
 471   GSocketConnection *connection = G_SOCKET_CONNECTION (stream);
 472
 473   if (connection->priv->output_stream)
 474     g_output_stream_close (connection->priv->output_stream,
 475                            cancellable, NULL);
 476   if (connection->priv->input_stream)
 477     g_input_stream_close (connection->priv->input_stream,
 478                           cancellable, NULL);
 479
 480   /* Don't close the underlying socket if this is being called
 481    * as part of dispose(); when destroying the GSocketConnection,
 482    * we only want to close the socket if we're holding the last
 483    * reference on it, and in that case it will close itself when
 484    * we unref it in finalize().
 485    */
 486   if (connection->priv->in_dispose)
 487     return TRUE;
 488
 489   return g_socket_close (connection->priv->socket, error);
 490 }
 491
 492
 493 static void
 494 g_socket_connection_close_async (GIOStream           *stream,
 495                                  int                  io_priority,
 496                                  GCancellable        *cancellable,
 497                                  GAsyncReadyCallback  callback,
 498                                  gpointer             user_data)
 499 {
 500   GTask *task;
 501   GIOStreamClass *class;
 502   GError *error;
 503
 504   class = G_IO_STREAM_GET_CLASS (stream);
 505
 506   task = g_task_new (stream, cancellable, callback, user_data);
 507   g_task_set_source_tag (task, g_socket_connection_close_async);
 508
 509   /* socket close is not blocked, just do it! */
 510   error = NULL;
 511   if (class->close_fn &&
 512       !class->close_fn (stream, cancellable, &error))
 513     g_task_return_error (task, error);
 514   else
 515     g_task_return_boolean (task, TRUE);
 516
 517   g_object_unref (task);
 518 }
 519
 520 static gboolean
 521 g_socket_connection_close_finish (GIOStream     *stream,
 522                                   GAsyncResult  *result,
 523                                   GError       **error)
 524 {
 525   return g_task_propagate_boolean (G_TASK (result), error);
 526 }
 527
 528 typedef struct {
 529   GSocketFamily socket_family;
 530   GSocketType socket_type;
 531   int protocol;
 532   GType implementation;
 533 } ConnectionFactory;
 534
 535 static guint
 536 connection_factory_hash (gconstpointer key)
 537 {
 538   const ConnectionFactory *factory = key;
 539   guint h;
 540
 541   h = factory->socket_family ^ (factory->socket_type << 4) ^ (factory->protocol << 8);
 542   /* This is likely to be small, so spread over whole
 543      hash space to get some distribution */
 544   h = h ^ (h << 8) ^ (h << 16) ^ (h << 24);
 545
 546   return h;
 547 }
 548
 549 static gboolean
 550 connection_factory_equal (gconstpointer _a,
 551                           gconstpointer _b)
 552 {
 553   const ConnectionFactory *a = _a;
 554   const ConnectionFactory *b = _b;
 555
 556   if (a->socket_family != b->socket_family)
 557     return FALSE;
 558
 559   if (a->socket_type != b->socket_type)
 560     return FALSE;
 561
 562   if (a->protocol != b->protocol)
 563     return FALSE;
 564
 565   return TRUE;
 566 }
 567
 568 static GHashTable *connection_factories = NULL;
 569 G_LOCK_DEFINE_STATIC(connection_factories);
 570
 571 /**
 572  * g_socket_connection_factory_register_type:
 573  * @g_type: a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION
 574  * @family: a #GSocketFamily
 575  * @type: a #GSocketType
 576  * @protocol: a protocol id
 577  *
 578  * Looks up the #GType to be used when creating socket connections on
 579  * sockets with the specified @family, @type and @protocol.
 580  *
 581  * If no type is registered, the #GSocketConnection base type is returned.
 582  *
 583  * Since: 2.22
 584  */
 585 void
 586 g_socket_connection_factory_register_type (GType         g_type,
 587                                            GSocketFamily family,
 588                                            GSocketType   type,
 589                                            gint          protocol)
 590 {
 591   ConnectionFactory *factory;
 592
 593   g_return_if_fail (g_type_is_a (g_type, G_TYPE_SOCKET_CONNECTION));
 594
 595   G_LOCK (connection_factories);
 596
 597   if (connection_factories == NULL)
 598     connection_factories = g_hash_table_new_full (connection_factory_hash,
 599                                                   connection_factory_equal,
 600                                                   (GDestroyNotify)g_free,
 601                                                   NULL);
 602
 603   factory = g_new0 (ConnectionFactory, 1);
 604   factory->socket_family = family;
 605   factory->socket_type = type;
 606   factory->protocol = protocol;
 607   factory->implementation = g_type;
 608
 609   g_hash_table_insert (connection_factories,
 610                        factory, factory);
 611
 612   G_UNLOCK (connection_factories);
 613 }
 614
 615 static void
 616 init_builtin_types (void)
 617 {
 618 #ifndef G_OS_WIN32
 619   g_type_ensure (G_TYPE_UNIX_CONNECTION);
 620 #endif
 621   g_type_ensure (G_TYPE_TCP_CONNECTION);
 622 }
 623
 624 /**
 625  * g_socket_connection_factory_lookup_type:
 626  * @family: a #GSocketFamily
 627  * @type: a #GSocketType
 628  * @protocol_id: a protocol id
 629  *
 630  * Looks up the #GType to be used when creating socket connections on
 631  * sockets with the specified @family, @type and @protocol_id.
 632  *
 633  * If no type is registered, the #GSocketConnection base type is returned.
 634  *
 635  * Returns: a #GType
 636  *
 637  * Since: 2.22
 638  */
 639 GType
 640 g_socket_connection_factory_lookup_type (GSocketFamily family,
 641                                          GSocketType   type,
 642                                          gint          protocol_id)
 643 {
 644   ConnectionFactory *factory, key;
 645   GType g_type;
 646
 647   init_builtin_types ();
 648
 649   G_LOCK (connection_factories);
 650
 651   g_type = G_TYPE_SOCKET_CONNECTION;
 652
 653   if (connection_factories)
 654     {
 655       key.socket_family = family;
 656       key.socket_type = type;
 657       key.protocol = protocol_id;
 658
 659       factory = g_hash_table_lookup (connection_factories, &key);
 660       if (factory)
 661         g_type = factory->implementation;
 662     }
 663
 664   G_UNLOCK (connection_factories);
 665
 666   return g_type;
 667 }
 668
 669 /**
 670  * g_socket_connection_factory_create_connection:
 671  * @socket: a #GSocket
 672  *
 673  * Creates a #GSocketConnection subclass of the right type for
 674  * @socket.
 675  *
 676  * Returns: (transfer full): a #GSocketConnection
 677  *
 678  * Since: 2.22
 679  */
 680 GSocketConnection *
 681 g_socket_connection_factory_create_connection (GSocket *socket)
 682 {
 683   GType type;
 684
 685   type = g_socket_connection_factory_lookup_type (g_socket_get_family (socket),
 686                                                   g_socket_get_socket_type (socket),
 687                                                   g_socket_get_protocol (socket));
 688   return g_object_new (type, "socket", socket, NULL);
 689 }