libsoup/soup-socket.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * soup-socket.c: Socket networking code.
   4  *
   5  * Copyright (C) 2000-2003, Ximian, Inc.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include <config.h>
  10 #endif
  11
  12 #include <stdio.h>
  13 #include <errno.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18
  19 #include "soup-socket.h"
  20 #include "soup-address.h"
  21 #include "soup-filter-input-stream.h"
  22 #include "soup-marshal.h"
  23 #include "soup-misc.h"
  24 #include "soup-misc-private.h"
  25
  26 /**
  27  * SECTION:soup-socket
  28  * @short_description: A network socket
  29  *
  30  * #SoupSocket is libsoup's TCP socket type. While it is primarily
  31  * intended for internal use, #SoupSocket<!-- -->s are exposed in the
  32  * API in various places, and some of their methods (eg,
  33  * soup_socket_get_remote_address()) may be useful to applications.
  34  **/
  35
  36 G_DEFINE_TYPE (SoupSocket, soup_socket, G_TYPE_OBJECT)
  37
  38 enum {
  39         READABLE,
  40         WRITABLE,
  41         DISCONNECTED,
  42         NEW_CONNECTION,
  43         EVENT,
  44         LAST_SIGNAL
  45 };
  46
  47 static guint signals[LAST_SIGNAL] = { 0 };
  48
  49 enum {
  50         PROP_0,
  51
  52         PROP_LOCAL_ADDRESS,
  53         PROP_REMOTE_ADDRESS,
  54         PROP_NON_BLOCKING,
  55         PROP_IS_SERVER,
  56         PROP_SSL_CREDENTIALS,
  57         PROP_SSL_STRICT,
  58         PROP_SSL_FALLBACK,
  59         PROP_ASYNC_CONTEXT,
  60         PROP_USE_THREAD_CONTEXT,
  61         PROP_TIMEOUT,
  62         PROP_TRUSTED_CERTIFICATE,
  63         PROP_CLEAN_DISPOSE,
  64         PROP_TLS_CERTIFICATE,
  65         PROP_TLS_ERRORS,
  66
  67         LAST_PROP
  68 };
  69
  70 typedef struct {
  71         SoupAddress *local_addr, *remote_addr;
  72         GIOStream *conn;
  73         GSocket *gsock;
  74         GInputStream *istream;
  75         GOutputStream *ostream;
  76         GTlsCertificateFlags tls_errors;
  77
  78         guint non_blocking:1;
  79         guint is_server:1;
  80         guint ssl:1;
  81         guint ssl_strict:1;
  82         guint ssl_fallback:1;
  83         guint clean_dispose:1;
  84         guint use_thread_context:1;
  85         gpointer ssl_creds;
  86
  87         GMainContext   *async_context;
  88         GSource        *watch_src;
  89         GSource        *read_src, *write_src;
  90
  91         GMutex iolock, addrlock;
  92         guint timeout;
  93
  94         GCancellable *connect_cancel;
  95 } SoupSocketPrivate;
  96 #define SOUP_SOCKET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOCKET, SoupSocketPrivate))
  97
  98 static void set_property (GObject *object, guint prop_id,
  99                           const GValue *value, GParamSpec *pspec);
 100 static void get_property (GObject *object, guint prop_id,
 101                           GValue *value, GParamSpec *pspec);
 102
 103 static void soup_socket_peer_certificate_changed (GObject *conn,
 104                                                   GParamSpec *pspec,
 105                                                   gpointer user_data);
 106
 107 static void
 108 soup_socket_init (SoupSocket *sock)
 109 {
 110         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 111
 112         priv->non_blocking = TRUE;
 113         g_mutex_init (&priv->addrlock);
 114         g_mutex_init (&priv->iolock);
 115 }
 116
 117 static void
 118 disconnect_internal (SoupSocket *sock, gboolean close)
 119 {
 120         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 121
 122         if (priv->gsock) {
 123                 if (close)
 124                         g_socket_close (priv->gsock, NULL);
 125                 g_object_unref (priv->gsock);
 126                 priv->gsock = NULL;
 127         }
 128         if (priv->conn) {
 129                 if (G_IS_TLS_CONNECTION (priv->conn))
 130                         g_signal_handlers_disconnect_by_func (priv->conn, soup_socket_peer_certificate_changed, sock);
 131                 g_clear_object (&priv->conn);
 132                 g_clear_object (&priv->istream);
 133                 g_clear_object (&priv->ostream);
 134         }
 135
 136         if (priv->read_src) {
 137                 g_source_destroy (priv->read_src);
 138                 priv->read_src = NULL;
 139         }
 140         if (priv->write_src) {
 141                 g_source_destroy (priv->write_src);
 142                 priv->write_src = NULL;
 143         }
 144 }
 145
 146 static void
 147 finalize (GObject *object)
 148 {
 149         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 150
 151         if (priv->connect_cancel) {
 152                 if (priv->clean_dispose)
 153                         g_warning ("Disposing socket %p during connect", object);
 154                 g_object_unref (priv->connect_cancel);
 155         }
 156         if (priv->conn) {
 157                 if (priv->clean_dispose)
 158                         g_warning ("Disposing socket %p while still connected", object);
 159                 disconnect_internal (SOUP_SOCKET (object), TRUE);
 160         }
 161
 162         g_clear_object (&priv->istream);
 163         g_clear_object (&priv->ostream);
 164
 165         if (priv->local_addr)
 166                 g_object_unref (priv->local_addr);
 167         if (priv->remote_addr)
 168                 g_object_unref (priv->remote_addr);
 169
 170         if (priv->watch_src) {
 171                 if (priv->clean_dispose && !priv->is_server)
 172                         g_warning ("Disposing socket %p during async op", object);
 173                 g_source_destroy (priv->watch_src);
 174         }
 175         if (priv->async_context)
 176                 g_main_context_unref (priv->async_context);
 177
 178         g_mutex_clear (&priv->addrlock);
 179         g_mutex_clear (&priv->iolock);
 180
 181         G_OBJECT_CLASS (soup_socket_parent_class)->finalize (object);
 182 }
 183
 184 static void
 185 soup_socket_class_init (SoupSocketClass *socket_class)
 186 {
 187         GObjectClass *object_class = G_OBJECT_CLASS (socket_class);
 188
 189         g_type_class_add_private (socket_class, sizeof (SoupSocketPrivate));
 190
 191         /* virtual method override */
 192         object_class->finalize = finalize;
 193         object_class->set_property = set_property;
 194         object_class->get_property = get_property;
 195
 196         /* signals */
 197
 198         /**
 199          * SoupSocket::readable:
 200          * @sock: the socket
 201          *
 202          * Emitted when an async socket is readable. See
 203          * soup_socket_read(), soup_socket_read_until() and
 204          * #SoupSocket:non-blocking.
 205          **/
 206         signals[READABLE] =
 207                 g_signal_new ("readable",
 208                               G_OBJECT_CLASS_TYPE (object_class),
 209                               G_SIGNAL_RUN_LAST,
 210                               G_STRUCT_OFFSET (SoupSocketClass, readable),
 211                               NULL, NULL,
 212                               _soup_marshal_NONE__NONE,
 213                               G_TYPE_NONE, 0);
 214
 215         /**
 216          * SoupSocket::writable:
 217          * @sock: the socket
 218          *
 219          * Emitted when an async socket is writable. See
 220          * soup_socket_write() and #SoupSocket:non-blocking.
 221          **/
 222         signals[WRITABLE] =
 223                 g_signal_new ("writable",
 224                               G_OBJECT_CLASS_TYPE (object_class),
 225                               G_SIGNAL_RUN_LAST,
 226                               G_STRUCT_OFFSET (SoupSocketClass, writable),
 227                               NULL, NULL,
 228                               _soup_marshal_NONE__NONE,
 229                               G_TYPE_NONE, 0);
 230
 231         /**
 232          * SoupSocket::disconnected:
 233          * @sock: the socket
 234          *
 235          * Emitted when the socket is disconnected, for whatever
 236          * reason.
 237          **/
 238         signals[DISCONNECTED] =
 239                 g_signal_new ("disconnected",
 240                               G_OBJECT_CLASS_TYPE (object_class),
 241                               G_SIGNAL_RUN_LAST,
 242                               G_STRUCT_OFFSET (SoupSocketClass, disconnected),
 243                               NULL, NULL,
 244                               _soup_marshal_NONE__NONE,
 245                               G_TYPE_NONE, 0);
 246
 247         /**
 248          * SoupSocket::new-connection:
 249          * @sock: the socket
 250          * @new: the new socket
 251          *
 252          * Emitted when a listening socket (set up with
 253          * soup_socket_listen()) receives a new connection.
 254          *
 255          * You must ref the @new if you want to keep it; otherwise it
 256          * will be destroyed after the signal is emitted.
 257          **/
 258         signals[NEW_CONNECTION] =
 259                 g_signal_new ("new_connection",
 260                               G_OBJECT_CLASS_TYPE (object_class),
 261                               G_SIGNAL_RUN_FIRST,
 262                               G_STRUCT_OFFSET (SoupSocketClass, new_connection),
 263                               NULL, NULL,
 264                               _soup_marshal_NONE__OBJECT,
 265                               G_TYPE_NONE, 1,
 266                               SOUP_TYPE_SOCKET);
 267         /**
 268          * SoupSocket::event:
 269          * @sock: the socket
 270          * @event: the event that occurred
 271          * @connection: the current connection state
 272          *
 273          * Emitted when a network-related event occurs. See
 274          * #GSocketClient::event for more details.
 275          *
 276          * Since: 2.38
 277          **/
 278         signals[EVENT] =
 279                 g_signal_new ("event",
 280                               G_OBJECT_CLASS_TYPE (object_class),
 281                               G_SIGNAL_RUN_LAST,
 282                               0,
 283                               NULL, NULL,
 284                               NULL,
 285                               G_TYPE_NONE, 2,
 286                               G_TYPE_SOCKET_CLIENT_EVENT,
 287                               G_TYPE_IO_STREAM);
 288
 289
 290         /* properties */
 291         /**
 292          * SOUP_SOCKET_LOCAL_ADDRESS:
 293          *
 294          * Alias for the #SoupSocket:local-address property. (Address
 295          * of local end of socket.)
 296          **/
 297         g_object_class_install_property (
 298                 object_class, PROP_LOCAL_ADDRESS,
 299                 g_param_spec_object (SOUP_SOCKET_LOCAL_ADDRESS,
 300                                      "Local address",
 301                                      "Address of local end of socket",
 302                                      SOUP_TYPE_ADDRESS,
 303                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 304         /**
 305          * SOUP_SOCKET_REMOTE_ADDRESS:
 306          *
 307          * Alias for the #SoupSocket:remote-address property. (Address
 308          * of remote end of socket.)
 309          **/
 310         g_object_class_install_property (
 311                 object_class, PROP_REMOTE_ADDRESS,
 312                 g_param_spec_object (SOUP_SOCKET_REMOTE_ADDRESS,
 313                                      "Remote address",
 314                                      "Address of remote end of socket",
 315                                      SOUP_TYPE_ADDRESS,
 316                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 317         /**
 318          * SoupSocket:non-blocking:
 319          *
 320          * Whether or not the socket uses non-blocking I/O.
 321          *
 322          * #SoupSocket's I/O methods are designed around the idea of
 323          * using a single codepath for both synchronous and
 324          * asynchronous I/O. If you want to read off a #SoupSocket,
 325          * the "correct" way to do it is to call soup_socket_read() or
 326          * soup_socket_read_until() repeatedly until you have read
 327          * everything you want. If it returns %SOUP_SOCKET_WOULD_BLOCK
 328          * at any point, stop reading and wait for it to emit the
 329          * #SoupSocket::readable signal. Then go back to the
 330          * reading-as-much-as-you-can loop. Likewise, for writing to a
 331          * #SoupSocket, you should call soup_socket_write() either
 332          * until you have written everything, or it returns
 333          * %SOUP_SOCKET_WOULD_BLOCK (in which case you wait for
 334          * #SoupSocket::writable and then go back into the loop).
 335          *
 336          * Code written this way will work correctly with both
 337          * blocking and non-blocking sockets; blocking sockets will
 338          * simply never return %SOUP_SOCKET_WOULD_BLOCK, and so the
 339          * code that handles that case just won't get used for them.
 340          **/
 341         /**
 342          * SOUP_SOCKET_FLAG_NONBLOCKING:
 343          *
 344          * Alias for the #SoupSocket:non-blocking property. (Whether
 345          * or not the socket uses non-blocking I/O.)
 346          **/
 347         g_object_class_install_property (
 348                 object_class, PROP_NON_BLOCKING,
 349                 g_param_spec_boolean (SOUP_SOCKET_FLAG_NONBLOCKING,
 350                                       "Non-blocking",
 351                                       "Whether or not the socket uses non-blocking I/O",
 352                                       TRUE,
 353                                       G_PARAM_READWRITE));
 354         /**
 355          * SOUP_SOCKET_IS_SERVER:
 356          *
 357          * Alias for the #SoupSocket:is-server property. (Whether or
 358          * not the socket is a server socket.)
 359          **/
 360         g_object_class_install_property (
 361                 object_class, PROP_IS_SERVER,
 362                 g_param_spec_boolean (SOUP_SOCKET_IS_SERVER,
 363                                       "Server",
 364                                       "Whether or not the socket is a server socket",
 365                                       FALSE,
 366                                       G_PARAM_READABLE));
 367         /**
 368          * SOUP_SOCKET_SSL_CREDENTIALS:
 369          *
 370          * Alias for the #SoupSocket:ssl-creds property.
 371          * (SSL credential information.)
 372          **/
 373         /* For historical reasons, there's only a single property
 374          * here, which is a GTlsDatabase for client sockets, and
 375          * a GTlsCertificate for server sockets. Whee!
 376          */
 377         g_object_class_install_property (
 378                 object_class, PROP_SSL_CREDENTIALS,
 379                 g_param_spec_pointer (SOUP_SOCKET_SSL_CREDENTIALS,
 380                                       "SSL credentials",
 381                                       "SSL credential information, passed from the session to the SSL implementation",
 382                                       G_PARAM_READWRITE));
 383         /**
 384          * SOUP_SOCKET_SSL_STRICT:
 385          *
 386          * Alias for the #SoupSocket:ssl-strict property.
 387          **/
 388         g_object_class_install_property (
 389                 object_class, PROP_SSL_STRICT,
 390                 g_param_spec_boolean (SOUP_SOCKET_SSL_STRICT,
 391                                       "Strictly validate SSL certificates",
 392                                       "Whether certificate errors should be considered a connection error",
 393                                       TRUE,
 394                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 395         /**
 396          * SOUP_SOCKET_SSL_FALLBACK:
 397          *
 398          * Alias for the #SoupSocket:ssl-fallback property.
 399          **/
 400         g_object_class_install_property (
 401                 object_class, PROP_SSL_FALLBACK,
 402                 g_param_spec_boolean (SOUP_SOCKET_SSL_FALLBACK,
 403                                       "SSLv3 fallback",
 404                                       "Use SSLv3 instead of TLS (client-side only)",
 405                                       FALSE,
 406                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 407         /**
 408          * SOUP_SOCKET_TRUSTED_CERTIFICATE:
 409          *
 410          * Alias for the #SoupSocket:trusted-certificate
 411          * property.
 412          **/
 413         g_object_class_install_property (
 414                 object_class, PROP_TRUSTED_CERTIFICATE,
 415                 g_param_spec_boolean (SOUP_SOCKET_TRUSTED_CERTIFICATE,
 416                                      "Trusted Certificate",
 417                                      "Whether the server certificate is trusted, if this is an SSL socket",
 418                                      FALSE,
 419                                      G_PARAM_READABLE));
 420         /**
 421          * SOUP_SOCKET_ASYNC_CONTEXT:
 422          *
 423          * Alias for the #SoupSocket:async-context property. (The
 424          * socket's #GMainContext.)
 425          **/
 426         g_object_class_install_property (
 427                 object_class, PROP_ASYNC_CONTEXT,
 428                 g_param_spec_pointer (SOUP_SOCKET_ASYNC_CONTEXT,
 429                                       "Async GMainContext",
 430                                       "The GMainContext to dispatch this socket's async I/O in",
 431                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 432
 433         /**
 434          * SOUP_SOCKET_USE_THREAD_CONTEXT:
 435          *
 436          * Alias for the #SoupSocket:use-thread-context property. (Use
 437          * g_main_context_get_thread_default())
 438          *
 439          * Since: 2.36.1
 440          */
 441         /**
 442          * SoupSocket:use-thread-context:
 443          *
 444          * Use g_main_context_get_thread_default().
 445          *
 446          * Since: 2.36.1
 447          */
 448         g_object_class_install_property (
 449                 object_class, PROP_USE_THREAD_CONTEXT,
 450                 g_param_spec_boolean (SOUP_SOCKET_USE_THREAD_CONTEXT,
 451                                       "Use thread context",
 452                                       "Use g_main_context_get_thread_default",
 453                                       FALSE,
 454                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 455
 456         /**
 457          * SOUP_SOCKET_TIMEOUT:
 458          *
 459          * Alias for the #SoupSocket:timeout property. (The timeout
 460          * in seconds for blocking socket I/O operations.)
 461          **/
 462         g_object_class_install_property (
 463                 object_class, PROP_TIMEOUT,
 464                 g_param_spec_uint (SOUP_SOCKET_TIMEOUT,
 465                                    "Timeout value",
 466                                    "Value in seconds to timeout a blocking I/O",
 467                                    0, G_MAXUINT, 0,
 468                                    G_PARAM_READWRITE));
 469
 470         g_object_class_install_property (
 471                 object_class, PROP_CLEAN_DISPOSE,
 472                 g_param_spec_boolean ("clean-dispose",
 473                                       "Clean dispose",
 474                                       "Warn on unclean dispose",
 475                                       FALSE,
 476                                       G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 477         /**
 478          * SOUP_SOCKET_TLS_CERTIFICATE:
 479          *
 480          * Alias for the #SoupSocket:tls-certificate
 481          * property. Note that this property's value is only useful
 482          * if the socket is for a TLS connection, and only reliable
 483          * after some data has been transferred to or from it.
 484          *
 485          * Since: 2.34
 486          **/
 487         g_object_class_install_property (
 488                 object_class, PROP_TLS_CERTIFICATE,
 489                 g_param_spec_object (SOUP_SOCKET_TLS_CERTIFICATE,
 490                                      "TLS certificate",
 491                                      "The peer's TLS certificate",
 492                                      G_TYPE_TLS_CERTIFICATE,
 493                                      G_PARAM_READABLE));
 494         /**
 495          * SOUP_SOCKET_TLS_ERRORS:
 496          *
 497          * Alias for the #SoupSocket:tls-errors
 498          * property. Note that this property's value is only useful
 499          * if the socket is for a TLS connection, and only reliable
 500          * after some data has been transferred to or from it.
 501          *
 502          * Since: 2.34
 503          **/
 504         g_object_class_install_property (
 505                 object_class, PROP_TLS_ERRORS,
 506                 g_param_spec_flags (SOUP_SOCKET_TLS_ERRORS,
 507                                     "TLS errors",
 508                                     "Errors with the peer's TLS certificate",
 509                                     G_TYPE_TLS_CERTIFICATE_FLAGS, 0,
 510                                     G_PARAM_READABLE));
 511 }
 512
 513
 514 static void
 515 finish_socket_setup (SoupSocketPrivate *priv)
 516 {
 517         if (!priv->gsock)
 518                 return;
 519
 520         if (!priv->conn)
 521                 priv->conn = (GIOStream *)g_socket_connection_factory_create_connection (priv->gsock);
 522         if (!priv->istream)
 523                 priv->istream = soup_filter_input_stream_new (g_io_stream_get_input_stream (priv->conn));
 524         if (!priv->ostream)
 525                 priv->ostream = g_object_ref (g_io_stream_get_output_stream (priv->conn));
 526
 527         g_socket_set_timeout (priv->gsock, priv->timeout);
 528 }
 529
 530 static void
 531 set_property (GObject *object, guint prop_id,
 532               const GValue *value, GParamSpec *pspec)
 533 {
 534         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 535
 536         switch (prop_id) {
 537         case PROP_LOCAL_ADDRESS:
 538                 priv->local_addr = (SoupAddress *)g_value_dup_object (value);
 539                 break;
 540         case PROP_REMOTE_ADDRESS:
 541                 priv->remote_addr = (SoupAddress *)g_value_dup_object (value);
 542                 break;
 543         case PROP_NON_BLOCKING:
 544                 priv->non_blocking = g_value_get_boolean (value);
 545                 break;
 546         case PROP_SSL_CREDENTIALS:
 547                 priv->ssl_creds = g_value_get_pointer (value);
 548                 break;
 549         case PROP_SSL_STRICT:
 550                 priv->ssl_strict = g_value_get_boolean (value);
 551                 break;
 552         case PROP_SSL_FALLBACK:
 553                 priv->ssl_fallback = g_value_get_boolean (value);
 554                 break;
 555         case PROP_ASYNC_CONTEXT:
 556                 priv->async_context = g_value_get_pointer (value);
 557                 if (priv->async_context)
 558                         g_main_context_ref (priv->async_context);
 559                 break;
 560         case PROP_USE_THREAD_CONTEXT:
 561                 priv->use_thread_context = g_value_get_boolean (value);
 562                 break;
 563         case PROP_TIMEOUT:
 564                 priv->timeout = g_value_get_uint (value);
 565                 if (priv->conn)
 566                         g_socket_set_timeout (priv->gsock, priv->timeout);
 567                 break;
 568         case PROP_CLEAN_DISPOSE:
 569                 priv->clean_dispose = g_value_get_boolean (value);
 570                 break;
 571         default:
 572                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 573                 break;
 574         }
 575 }
 576
 577 static void
 578 get_property (GObject *object, guint prop_id,
 579               GValue *value, GParamSpec *pspec)
 580 {
 581         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 582
 583         switch (prop_id) {
 584         case PROP_LOCAL_ADDRESS:
 585                 g_value_set_object (value, soup_socket_get_local_address (SOUP_SOCKET (object)));
 586                 break;
 587         case PROP_REMOTE_ADDRESS:
 588                 g_value_set_object (value, soup_socket_get_remote_address (SOUP_SOCKET (object)));
 589                 break;
 590         case PROP_NON_BLOCKING:
 591                 g_value_set_boolean (value, priv->non_blocking);
 592                 break;
 593         case PROP_IS_SERVER:
 594                 g_value_set_boolean (value, priv->is_server);
 595                 break;
 596         case PROP_SSL_CREDENTIALS:
 597                 g_value_set_pointer (value, priv->ssl_creds);
 598                 break;
 599         case PROP_SSL_STRICT:
 600                 g_value_set_boolean (value, priv->ssl_strict);
 601                 break;
 602         case PROP_SSL_FALLBACK:
 603                 g_value_set_boolean (value, priv->ssl_fallback);
 604                 break;
 605         case PROP_TRUSTED_CERTIFICATE:
 606                 g_value_set_boolean (value, priv->tls_errors == 0);
 607                 break;
 608         case PROP_ASYNC_CONTEXT:
 609                 g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);
 610                 break;
 611         case PROP_USE_THREAD_CONTEXT:
 612                 g_value_set_boolean (value, priv->use_thread_context);
 613                 break;
 614         case PROP_TIMEOUT:
 615                 g_value_set_uint (value, priv->timeout);
 616                 break;
 617         case PROP_TLS_CERTIFICATE:
 618                 if (G_IS_TLS_CONNECTION (priv->conn))
 619                         g_value_set_object (value, g_tls_connection_get_peer_certificate (G_TLS_CONNECTION (priv->conn)));
 620                 else
 621                         g_value_set_object (value, NULL);
 622                 break;
 623         case PROP_TLS_ERRORS:
 624                 g_value_set_flags (value, priv->tls_errors);
 625                 break;
 626         default:
 627                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 628                 break;
 629         }
 630 }
 631
 632
 633 /**
 634  * soup_socket_new:
 635  * @optname1: name of first property to set (or %NULL)
 636  * @...: value of @optname1, followed by additional property/value pairs
 637  *
 638  * Creates a new (disconnected) socket
 639  *
 640  * Return value: the new socket
 641  **/
 642 SoupSocket *
 643 soup_socket_new (const char *optname1, ...)
 644 {
 645         SoupSocket *sock;
 646         va_list ap;
 647
 648         va_start (ap, optname1);
 649         sock = (SoupSocket *)g_object_new_valist (SOUP_TYPE_SOCKET,
 650                                                   optname1, ap);
 651         va_end (ap);
 652
 653         return sock;
 654 }
 655
 656 static void
 657 proxy_socket_client_event (GSocketClient       *client,
 658                            GSocketClientEvent   event,
 659                            GSocketConnectable  *connectable,
 660                            GIOStream           *connection,
 661                            gpointer             user_data)
 662 {
 663         SoupSocket *sock = user_data;
 664
 665         g_signal_emit (sock, signals[EVENT], 0,
 666                        event, connection);
 667 }
 668
 669 static guint
 670 socket_connected (SoupSocket *sock, GSocketConnection *conn, GError *error)
 671 {
 672         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 673
 674         if (priv->connect_cancel) {
 675                 GCancellable *cancellable = priv->connect_cancel;
 676
 677                 g_object_unref (priv->connect_cancel);
 678                 priv->connect_cancel = NULL;
 679                 if (g_cancellable_is_cancelled (cancellable))
 680                         return SOUP_STATUS_CANCELLED;
 681         }
 682
 683         if (error) {
 684                 if (error->domain == G_RESOLVER_ERROR) {
 685                         g_error_free (error);
 686                         return SOUP_STATUS_CANT_RESOLVE;
 687                 } else {
 688                         g_error_free (error);
 689                         return SOUP_STATUS_CANT_CONNECT;
 690                 }
 691         }
 692
 693         priv->conn = (GIOStream *)conn;
 694         priv->gsock = g_object_ref (g_socket_connection_get_socket (conn));
 695         finish_socket_setup (priv);
 696
 697         return SOUP_STATUS_OK;
 698 }
 699
 700 /**
 701  * SoupSocketCallback:
 702  * @sock: the #SoupSocket
 703  * @status: an HTTP status code indicating success or failure
 704  * @user_data: the data passed to soup_socket_connect_async()
 705  *
 706  * The callback function passed to soup_socket_connect_async().
 707  **/
 708
 709 typedef struct {
 710         SoupSocket *sock;
 711         SoupSocketCallback callback;
 712         gpointer user_data;
 713 } SoupSocketAsyncConnectData;
 714
 715 static void
 716 async_connected (GObject *client, GAsyncResult *result, gpointer data)
 717 {
 718         SoupSocketAsyncConnectData *sacd = data;
 719         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sacd->sock);
 720         GError *error = NULL;
 721         GSocketConnection *conn;
 722         guint status;
 723
 724         if (priv->async_context && !priv->use_thread_context)
 725                 g_main_context_pop_thread_default (priv->async_context);
 726
 727         conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client),
 728                                                result, &error);
 729         status = socket_connected (sacd->sock, conn, error);
 730
 731         sacd->callback (sacd->sock, status, sacd->user_data);
 732         g_object_unref (sacd->sock);
 733         g_slice_free (SoupSocketAsyncConnectData, sacd);
 734 }
 735
 736 /**
 737  * soup_socket_connect_async:
 738  * @sock: a client #SoupSocket (which must not already be connected)
 739  * @cancellable: a #GCancellable, or %NULL
 740  * @callback: (scope async): callback to call after connecting
 741  * @user_data: data to pass to @callback
 742  *
 743  * Begins asynchronously connecting to @sock's remote address. The
 744  * socket will call @callback when it succeeds or fails (but not
 745  * before returning from this function).
 746  *
 747  * If @cancellable is non-%NULL, it can be used to cancel the
 748  * connection. @callback will still be invoked in this case, with a
 749  * status of %SOUP_STATUS_CANCELLED.
 750  **/
 751 void
 752 soup_socket_connect_async (SoupSocket *sock, GCancellable *cancellable,
 753                            SoupSocketCallback callback, gpointer user_data)
 754 {
 755         SoupSocketPrivate *priv;
 756         SoupSocketAsyncConnectData *sacd;
 757         GSocketClient *client;
 758
 759         g_return_if_fail (SOUP_IS_SOCKET (sock));
 760         priv = SOUP_SOCKET_GET_PRIVATE (sock);
 761         g_return_if_fail (priv->remote_addr != NULL);
 762
 763         sacd = g_slice_new0 (SoupSocketAsyncConnectData);
 764         sacd->sock = g_object_ref (sock);
 765         sacd->callback = callback;
 766         sacd->user_data = user_data;
 767
 768         priv->connect_cancel = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
 769
 770         if (priv->async_context && !priv->use_thread_context)
 771                 g_main_context_push_thread_default (priv->async_context);
 772
 773         client = g_socket_client_new ();
 774         g_signal_connect (client, "event",
 775                           G_CALLBACK (proxy_socket_client_event), sock);
 776         if (priv->timeout)
 777                 g_socket_client_set_timeout (client, priv->timeout);
 778         g_socket_client_connect_async (client,
 779                                        G_SOCKET_CONNECTABLE (priv->remote_addr),
 780                                        priv->connect_cancel,
 781                                        async_connected, sacd);
 782         g_object_unref (client);
 783 }
 784
 785 /**
 786  * soup_socket_connect_sync:
 787  * @sock: a client #SoupSocket (which must not already be connected)
 788  * @cancellable: a #GCancellable, or %NULL
 789  *
 790  * Attempt to synchronously connect @sock to its remote address.
 791  *
 792  * If @cancellable is non-%NULL, it can be used to cancel the
 793  * connection, in which case soup_socket_connect_sync() will return
 794  * %SOUP_STATUS_CANCELLED.
 795  *
 796  * Return value: a success or failure code.
 797  **/
 798 guint
 799 soup_socket_connect_sync (SoupSocket *sock, GCancellable *cancellable)
 800 {
 801         SoupSocketPrivate *priv;
 802         GSocketClient *client;
 803         GSocketConnection *conn;
 804         GError *error = NULL;
 805
 806         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED);
 807         priv = SOUP_SOCKET_GET_PRIVATE (sock);
 808         g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
 809         g_return_val_if_fail (priv->gsock == NULL, SOUP_STATUS_MALFORMED);
 810         g_return_val_if_fail (priv->remote_addr != NULL, SOUP_STATUS_MALFORMED);
 811
 812         if (cancellable)
 813                 g_object_ref (cancellable);
 814         else
 815                 cancellable = g_cancellable_new ();
 816         priv->connect_cancel = cancellable;
 817
 818         client = g_socket_client_new ();
 819         g_signal_connect (client, "event",
 820                           G_CALLBACK (proxy_socket_client_event), sock);
 821         if (priv->timeout)
 822                 g_socket_client_set_timeout (client, priv->timeout);
 823         conn = g_socket_client_connect (client,
 824                                         G_SOCKET_CONNECTABLE (priv->remote_addr),
 825                                         priv->connect_cancel, &error);
 826         g_object_unref (client);
 827
 828         return socket_connected (sock, conn, error);
 829 }
 830
 831 int
 832 soup_socket_get_fd (SoupSocket *sock)
 833 {
 834         g_return_val_if_fail (SOUP_IS_SOCKET (sock), -1);
 835
 836         return g_socket_get_fd (SOUP_SOCKET_GET_PRIVATE (sock)->gsock);
 837 }
 838
 839 GSocket *
 840 soup_socket_get_gsocket (SoupSocket *sock)
 841 {
 842         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 843
 844         return SOUP_SOCKET_GET_PRIVATE (sock)->gsock;
 845 }
 846
 847 GIOStream *
 848 soup_socket_get_iostream (SoupSocket *sock)
 849 {
 850         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 851
 852         return SOUP_SOCKET_GET_PRIVATE (sock)->conn;
 853 }
 854
 855 static GSource *
 856 soup_socket_create_watch (SoupSocketPrivate *priv, GIOCondition cond,
 857                           GPollableSourceFunc callback, gpointer user_data,
 858                           GCancellable *cancellable)
 859 {
 860         GSource *watch;
 861         GMainContext *async_context;
 862
 863         if (cond == G_IO_IN)
 864                 watch = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (priv->istream), cancellable);
 865         else
 866                 watch = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM (priv->ostream), cancellable);
 867         g_source_set_callback (watch, (GSourceFunc)callback, user_data, NULL);
 868
 869         if (priv->use_thread_context)
 870                 async_context = g_main_context_get_thread_default ();
 871         else
 872                 async_context = priv->async_context;
 873
 874         g_source_attach (watch, async_context);
 875         g_source_unref (watch);
 876
 877         return watch;
 878 }
 879
 880 static gboolean
 881 listen_watch (GObject *pollable, gpointer data)
 882 {
 883         SoupSocket *sock = data, *new;
 884         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock), *new_priv;
 885         GSocket *new_gsock;
 886
 887         new_gsock = g_socket_accept (priv->gsock, NULL, NULL);
 888         if (!new_gsock)
 889                 return FALSE;
 890
 891         new = g_object_new (SOUP_TYPE_SOCKET, NULL);
 892         new_priv = SOUP_SOCKET_GET_PRIVATE (new);
 893         new_priv->gsock = new_gsock;
 894         if (priv->async_context)
 895                 new_priv->async_context = g_main_context_ref (priv->async_context);
 896         new_priv->use_thread_context = priv->use_thread_context;
 897         new_priv->non_blocking = priv->non_blocking;
 898         new_priv->is_server = TRUE;
 899         new_priv->ssl = priv->ssl;
 900         if (priv->ssl_creds)
 901                 new_priv->ssl_creds = priv->ssl_creds;
 902         finish_socket_setup (new_priv);
 903
 904         if (new_priv->ssl_creds) {
 905                 if (!soup_socket_start_proxy_ssl (new, NULL, NULL)) {
 906                         g_object_unref (new);
 907                         return TRUE;
 908                 }
 909         }
 910
 911         g_signal_emit (sock, signals[NEW_CONNECTION], 0, new);
 912         g_object_unref (new);
 913
 914         return TRUE;
 915 }
 916
 917 /**
 918  * soup_socket_listen:
 919  * @sock: a server #SoupSocket (which must not already be connected or
 920  * listening)
 921  *
 922  * Makes @sock start listening on its local address. When connections
 923  * come in, @sock will emit #SoupSocket::new_connection.
 924  *
 925  * Return value: whether or not @sock is now listening.
 926  **/
 927 gboolean
 928 soup_socket_listen (SoupSocket *sock)
 929
 930 {
 931         SoupSocketPrivate *priv;
 932         GSocketAddress *addr;
 933
 934         g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
 935         priv = SOUP_SOCKET_GET_PRIVATE (sock);
 936         g_return_val_if_fail (priv->gsock == NULL, FALSE);
 937         g_return_val_if_fail (priv->local_addr != NULL, FALSE);
 938
 939         priv->is_server = TRUE;
 940
 941         /* @local_addr may have its port set to 0. So we intentionally
 942          * don't store it in priv->local_addr, so that if the
 943          * caller calls soup_socket_get_local_address() later, we'll
 944          * have to make a new addr by calling getsockname(), which
 945          * will have the right port number.
 946          */
 947         addr = soup_address_get_gsockaddr (priv->local_addr);
 948         g_return_val_if_fail (addr != NULL, FALSE);
 949
 950         priv->gsock = g_socket_new (g_socket_address_get_family (addr),
 951                                     G_SOCKET_TYPE_STREAM,
 952                                     G_SOCKET_PROTOCOL_DEFAULT,
 953                                     NULL);
 954         if (!priv->gsock)
 955                 goto cant_listen;
 956         finish_socket_setup (priv);
 957
 958         /* Bind */
 959         if (!g_socket_bind (priv->gsock, addr, TRUE, NULL))
 960                 goto cant_listen;
 961         /* Force local_addr to be re-resolved now */
 962         g_object_unref (priv->local_addr);
 963         priv->local_addr = NULL;
 964
 965         /* Listen */
 966         if (!g_socket_listen (priv->gsock, NULL))
 967                 goto cant_listen;
 968
 969         priv->watch_src = soup_socket_create_watch (priv, G_IO_IN,
 970                                                     listen_watch, sock,
 971                                                     NULL);
 972         g_object_unref (addr);
 973         return TRUE;
 974
 975  cant_listen:
 976         if (priv->conn)
 977                 disconnect_internal (sock, TRUE);
 978         g_object_unref (addr);
 979
 980         return FALSE;
 981 }
 982
 983 static void
 984 soup_socket_peer_certificate_changed (GObject *conn, GParamSpec *pspec,
 985                                       gpointer sock)
 986 {
 987         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 988
 989         priv->tls_errors = g_tls_connection_get_peer_certificate_errors (G_TLS_CONNECTION (priv->conn));
 990
 991         g_object_notify (sock, "tls-certificate");
 992         g_object_notify (sock, "tls-errors");
 993 }
 994
 995 static gboolean
 996 soup_socket_accept_certificate (GTlsConnection *conn, GTlsCertificate *cert,
 997                                 GTlsCertificateFlags errors, gpointer sock)
 998 {
 999         return TRUE;
1000 }
1001
1002 /**
1003  * soup_socket_start_ssl:
1004  * @sock: the socket
1005  * @cancellable: a #GCancellable
1006  *
1007  * Starts using SSL on @socket.
1008  *
1009  * Return value: success or failure
1010  **/
1011 gboolean
1012 soup_socket_start_ssl (SoupSocket *sock, GCancellable *cancellable)
1013 {
1014         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1015
1016         return soup_socket_start_proxy_ssl (sock, soup_address_get_name (priv->remote_addr), cancellable);
1017 }
1018
1019 /**
1020  * soup_socket_start_proxy_ssl:
1021  * @sock: the socket
1022  * @ssl_host: hostname of the SSL server
1023  * @cancellable: a #GCancellable
1024  *
1025  * Starts using SSL on @socket, expecting to find a host named
1026  * @ssl_host.
1027  *
1028  * Return value: success or failure
1029  **/
1030 gboolean
1031 soup_socket_start_proxy_ssl (SoupSocket *sock, const char *ssl_host,
1032                              GCancellable *cancellable)
1033 {
1034         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1035         GTlsBackend *backend = g_tls_backend_get_default ();
1036
1037         if (G_IS_TLS_CONNECTION (priv->conn))
1038                 return TRUE;
1039
1040         if (g_cancellable_is_cancelled (cancellable))
1041                 return FALSE;
1042
1043         priv->ssl = TRUE;
1044
1045         if (!priv->is_server) {
1046                 GTlsClientConnection *conn;
1047                 GSocketConnectable *identity;
1048
1049                 identity = g_network_address_new (ssl_host, 0);
1050                 conn = g_initable_new (g_tls_backend_get_client_connection_type (backend),
1051                                        NULL, NULL,
1052                                        "base-io-stream", priv->conn,
1053                                        "server-identity", identity,
1054                                        "database", priv->ssl_creds,
1055                                        "require-close-notify", FALSE,
1056                                        "use-ssl3", priv->ssl_fallback,
1057                                        NULL);
1058                 g_object_unref (identity);
1059
1060                 if (!conn)
1061                         return FALSE;
1062
1063                 g_object_unref (priv->conn);
1064                 priv->conn = G_IO_STREAM (conn);
1065
1066                 if (!priv->ssl_strict) {
1067                         g_signal_connect (conn, "accept-certificate",
1068                                           G_CALLBACK (soup_socket_accept_certificate),
1069                                           sock);
1070                 }
1071         } else {
1072                 GTlsServerConnection *conn;
1073
1074                 conn = g_initable_new (g_tls_backend_get_server_connection_type (backend),
1075                                        NULL, NULL,
1076                                        "base-io-stream", priv->conn,
1077                                        "certificate", priv->ssl_creds,
1078                                        "use-system-certdb", FALSE,
1079                                        "require-close-notify", FALSE,
1080                                        NULL);
1081                 if (!conn)
1082                         return FALSE;
1083
1084                 g_object_unref (priv->conn);
1085                 priv->conn = G_IO_STREAM (conn);
1086         }
1087
1088         g_signal_connect (priv->conn, "notify::peer-certificate",
1089                           G_CALLBACK (soup_socket_peer_certificate_changed), sock);
1090
1091         if (priv->istream)
1092                 g_object_unref (priv->istream);
1093         if (priv->ostream)
1094                 g_object_unref (priv->ostream);
1095
1096         priv->istream = soup_filter_input_stream_new (g_io_stream_get_input_stream (priv->conn));
1097         priv->ostream = g_object_ref (g_io_stream_get_output_stream (priv->conn));
1098         return TRUE;
1099 }
1100
1101 guint
1102 soup_socket_handshake_sync (SoupSocket    *sock,
1103                             GCancellable  *cancellable)
1104 {
1105         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1106         GError *error = NULL;
1107
1108         priv->ssl = TRUE;
1109         if (g_tls_connection_handshake (G_TLS_CONNECTION (priv->conn),
1110                                         cancellable, &error))
1111                 return SOUP_STATUS_OK;
1112         else if (!priv->ssl_fallback &&
1113                  g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_NOT_TLS)) {
1114                 g_error_free (error);
1115                 return SOUP_STATUS_TLS_FAILED;
1116         } else {
1117                 g_error_free (error);
1118                 return SOUP_STATUS_SSL_FAILED;
1119         }
1120 }
1121
1122 static void
1123 handshake_async_ready (GObject *source, GAsyncResult *result, gpointer user_data)
1124 {
1125         SoupSocketAsyncConnectData *data = user_data;
1126         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (data->sock);
1127         GError *error = NULL;
1128         guint status;
1129
1130         if (priv->async_context && !priv->use_thread_context)
1131                 g_main_context_pop_thread_default (priv->async_context);
1132
1133         if (g_tls_connection_handshake_finish (G_TLS_CONNECTION (source),
1134                                                result, &error))
1135                 status = SOUP_STATUS_OK;
1136         else if (!priv->ssl_fallback &&
1137                  g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_NOT_TLS))
1138                 status = SOUP_STATUS_TLS_FAILED;
1139         else
1140                 status = SOUP_STATUS_SSL_FAILED;
1141         g_clear_error (&error);
1142
1143         data->callback (data->sock, status, data->user_data);
1144         g_object_unref (data->sock);
1145         g_slice_free (SoupSocketAsyncConnectData, data);
1146 }
1147
1148 void
1149 soup_socket_handshake_async (SoupSocket         *sock,
1150                              GCancellable       *cancellable,
1151                              SoupSocketCallback  callback,
1152                              gpointer            user_data)
1153 {
1154         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1155         SoupSocketAsyncConnectData *data;
1156
1157         priv->ssl = TRUE;
1158
1159         data = g_slice_new (SoupSocketAsyncConnectData);
1160         data->sock = g_object_ref (sock);
1161         data->callback = callback;
1162         data->user_data = user_data;
1163
1164         if (priv->async_context && !priv->use_thread_context)
1165                 g_main_context_push_thread_default (priv->async_context);
1166         g_tls_connection_handshake_async (G_TLS_CONNECTION (priv->conn),
1167                                           G_PRIORITY_DEFAULT,
1168                                           cancellable, handshake_async_ready,
1169                                           data);
1170 }
1171
1172 /**
1173  * soup_socket_is_ssl:
1174  * @sock: a #SoupSocket
1175  *
1176  * Tests if @sock is doing (or has attempted to do) SSL.
1177  *
1178  * Return value: %TRUE if @sock has SSL credentials set
1179  **/
1180 gboolean
1181 soup_socket_is_ssl (SoupSocket *sock)
1182 {
1183         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1184
1185         return priv->ssl;
1186 }
1187
1188 /**
1189  * soup_socket_disconnect:
1190  * @sock: a #SoupSocket
1191  *
1192  * Disconnects @sock. Any further read or write attempts on it will
1193  * fail.
1194  **/
1195 void
1196 soup_socket_disconnect (SoupSocket *sock)
1197 {
1198         SoupSocketPrivate *priv;
1199         gboolean already_disconnected = FALSE;
1200
1201         g_return_if_fail (SOUP_IS_SOCKET (sock));
1202         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1203
1204         if (priv->connect_cancel) {
1205                 disconnect_internal (sock, FALSE);
1206                 g_cancellable_cancel (priv->connect_cancel);
1207                 return;
1208         } else if (g_mutex_trylock (&priv->iolock)) {
1209                 if (priv->conn)
1210                         disconnect_internal (sock, TRUE);
1211                 else
1212                         already_disconnected = TRUE;
1213                 g_mutex_unlock (&priv->iolock);
1214         } else {
1215                 /* Another thread is currently doing IO, so
1216                  * we can't close the socket. So just shutdown
1217                  * the file descriptor to force the I/O to fail.
1218                  * (It will actually be closed when the socket
1219                  * is destroyed.)
1220                  */
1221                 g_socket_shutdown (priv->gsock, TRUE, TRUE, NULL);
1222         }
1223
1224         if (already_disconnected)
1225                 return;
1226
1227         /* Keep ref around signals in case the object is unreferenced
1228          * in a handler
1229          */
1230         g_object_ref (sock);
1231
1232         /* Give all readers a chance to notice the connection close */
1233         g_signal_emit (sock, signals[READABLE], 0);
1234
1235         /* FIXME: can't disconnect until all data is read */
1236
1237         /* Then let everyone know we're disconnected */
1238         g_signal_emit (sock, signals[DISCONNECTED], 0);
1239
1240         g_object_unref (sock);
1241 }
1242
1243 /**
1244  * soup_socket_is_connected:
1245  * @sock: a #SoupSocket
1246  *
1247  * Tests if @sock is connected to another host
1248  *
1249  * Return value: %TRUE or %FALSE.
1250  **/
1251 gboolean
1252 soup_socket_is_connected (SoupSocket *sock)
1253 {
1254         SoupSocketPrivate *priv;
1255
1256         g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
1257         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1258
1259         return priv->conn != NULL;
1260 }
1261
1262 /**
1263  * soup_socket_get_local_address:
1264  * @sock: a #SoupSocket
1265  *
1266  * Returns the #SoupAddress corresponding to the local end of @sock.
1267  *
1268  * Return value: (transfer none): the #SoupAddress
1269  **/
1270 SoupAddress *
1271 soup_socket_get_local_address (SoupSocket *sock)
1272 {
1273         SoupSocketPrivate *priv;
1274
1275         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
1276         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1277
1278         g_mutex_lock (&priv->addrlock);
1279         if (!priv->local_addr) {
1280                 GSocketAddress *addr;
1281                 struct sockaddr_storage sa;
1282                 gssize sa_len;
1283
1284                 addr = g_socket_get_local_address (priv->gsock, NULL);
1285                 sa_len = g_socket_address_get_native_size (addr);
1286                 g_socket_address_to_native (addr, &sa, sa_len, NULL);
1287                 priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
1288                 g_object_unref (addr);
1289         }
1290         g_mutex_unlock (&priv->addrlock);
1291
1292         return priv->local_addr;
1293 }
1294
1295 /**
1296  * soup_socket_get_remote_address:
1297  * @sock: a #SoupSocket
1298  *
1299  * Returns the #SoupAddress corresponding to the remote end of @sock.
1300  *
1301  * Return value: (transfer none): the #SoupAddress
1302  **/
1303 SoupAddress *
1304 soup_socket_get_remote_address (SoupSocket *sock)
1305 {
1306         SoupSocketPrivate *priv;
1307
1308         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
1309         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1310
1311         g_mutex_lock (&priv->addrlock);
1312         if (!priv->remote_addr) {
1313                 GSocketAddress *addr;
1314                 struct sockaddr_storage sa;
1315                 gssize sa_len;
1316
1317                 addr = g_socket_get_remote_address (priv->gsock, NULL);
1318                 sa_len = g_socket_address_get_native_size (addr);
1319                 g_socket_address_to_native (addr, &sa, sa_len, NULL);
1320                 priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
1321                 g_object_unref (addr);
1322         }
1323         g_mutex_unlock (&priv->addrlock);
1324
1325         return priv->remote_addr;
1326 }
1327
1328
1329 static gboolean
1330 socket_read_watch (GObject *pollable, gpointer user_data)
1331 {
1332         SoupSocket *sock = user_data;
1333         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1334
1335         priv->read_src = NULL;
1336         g_signal_emit (sock, signals[READABLE], 0);
1337         return FALSE;
1338 }
1339
1340 static SoupSocketIOStatus
1341 translate_read_status (SoupSocket *sock, GCancellable *cancellable,
1342                        gssize my_nread, gsize *nread,
1343                        GError *my_err, GError **error)
1344 {
1345         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1346
1347         if (my_nread > 0) {
1348                 g_assert_no_error (my_err);
1349                 *nread = my_nread;
1350                 return SOUP_SOCKET_OK;
1351         } else if (my_nread == 0) {
1352                 g_assert_no_error (my_err);
1353                 *nread = my_nread;
1354                 return SOUP_SOCKET_EOF;
1355         } else if (g_error_matches (my_err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
1356                 g_clear_error (&my_err);
1357                 if (!priv->read_src) {
1358                         priv->read_src =
1359                                 soup_socket_create_watch (priv, G_IO_IN,
1360                                                           socket_read_watch, sock,
1361                                                           cancellable);
1362                 }
1363                 return SOUP_SOCKET_WOULD_BLOCK;
1364         }
1365
1366         g_propagate_error (error, my_err);
1367         return SOUP_SOCKET_ERROR;
1368 }
1369
1370 /**
1371  * SoupSocketIOStatus:
1372  * @SOUP_SOCKET_OK: Success
1373  * @SOUP_SOCKET_WOULD_BLOCK: Cannot read/write any more at this time
1374  * @SOUP_SOCKET_EOF: End of file
1375  * @SOUP_SOCKET_ERROR: Other error
1376  *
1377  * Return value from the #SoupSocket IO methods.
1378  **/
1379
1380 /**
1381  * soup_socket_read:
1382  * @sock: the socket
1383  * @buffer: buffer to read into
1384  * @len: size of @buffer in bytes
1385  * @nread: (out): on return, the number of bytes read into @buffer
1386  * @cancellable: a #GCancellable, or %NULL
1387  * @error: error pointer
1388  *
1389  * Attempts to read up to @len bytes from @sock into @buffer. If some
1390  * data is successfully read, soup_socket_read() will return
1391  * %SOUP_SOCKET_OK, and *@nread will contain the number of bytes
1392  * actually read (which may be less than @len).
1393  *
1394  * If @sock is non-blocking, and no data is available, the return
1395  * value will be %SOUP_SOCKET_WOULD_BLOCK. In this case, the caller
1396  * can connect to the #SoupSocket::readable signal to know when there
1397  * is more data to read. (NB: You MUST read all available data off the
1398  * socket first. #SoupSocket::readable is only emitted after
1399  * soup_socket_read() returns %SOUP_SOCKET_WOULD_BLOCK, and it is only
1400  * emitted once. See the documentation for #SoupSocket:non-blocking.)
1401  *
1402  * Return value: a #SoupSocketIOStatus, as described above (or
1403  * %SOUP_SOCKET_EOF if the socket is no longer connected, or
1404  * %SOUP_SOCKET_ERROR on any other error, in which case @error will
1405  * also be set).
1406  **/
1407 SoupSocketIOStatus
1408 soup_socket_read (SoupSocket *sock, gpointer buffer, gsize len,
1409                   gsize *nread, GCancellable *cancellable, GError **error)
1410 {
1411         SoupSocketPrivate *priv;
1412         SoupSocketIOStatus status;
1413         gssize my_nread;
1414         GError *my_err = NULL;
1415
1416         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
1417         g_return_val_if_fail (nread != NULL, SOUP_SOCKET_ERROR);
1418
1419         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1420
1421         g_mutex_lock (&priv->iolock);
1422
1423         if (!priv->istream) {
1424                 status = SOUP_SOCKET_EOF;
1425                 goto out;
1426         }
1427
1428         if (!priv->non_blocking) {
1429                 my_nread = g_input_stream_read (priv->istream, buffer, len,
1430                                                 cancellable, &my_err);
1431         } else {
1432                 my_nread = g_pollable_input_stream_read_nonblocking (G_POLLABLE_INPUT_STREAM (priv->istream),
1433                                                                      buffer, len,
1434                                                                      cancellable, &my_err);
1435         }
1436         status = translate_read_status (sock, cancellable,
1437                                         my_nread, nread, my_err, error);
1438
1439 out:
1440         g_mutex_unlock (&priv->iolock);
1441
1442         return status;
1443 }
1444
1445 /**
1446  * soup_socket_read_until:
1447  * @sock: the socket
1448  * @buffer: buffer to read into
1449  * @len: size of @buffer in bytes
1450  * @boundary: boundary to read until
1451  * @boundary_len: length of @boundary in bytes
1452  * @nread: (out): on return, the number of bytes read into @buffer
1453  * @got_boundary: on return, whether or not the data in @buffer
1454  * ends with the boundary string
1455  * @cancellable: a #GCancellable, or %NULL
1456  * @error: error pointer
1457  *
1458  * Like soup_socket_read(), but reads no further than the first
1459  * occurrence of @boundary. (If the boundary is found, it will be
1460  * included in the returned data, and *@got_boundary will be set to
1461  * %TRUE.) Any data after the boundary will returned in future reads.
1462  *
1463  * soup_socket_read_until() will almost always return fewer than @len
1464  * bytes: if the boundary is found, then it will only return the bytes
1465  * up until the end of the boundary, and if the boundary is not found,
1466  * then it will leave the last <literal>(boundary_len - 1)</literal>
1467  * bytes in its internal buffer, in case they form the start of the
1468  * boundary string. Thus, @len normally needs to be at least 1 byte
1469  * longer than @boundary_len if you want to make any progress at all.
1470  *
1471  * Return value: as for soup_socket_read()
1472  **/
1473 SoupSocketIOStatus
1474 soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len,
1475                         gconstpointer boundary, gsize boundary_len,
1476                         gsize *nread, gboolean *got_boundary,
1477                         GCancellable *cancellable, GError **error)
1478 {
1479         SoupSocketPrivate *priv;
1480         SoupSocketIOStatus status;
1481         gssize my_nread;
1482         GError *my_err = NULL;
1483
1484         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
1485         g_return_val_if_fail (nread != NULL, SOUP_SOCKET_ERROR);
1486         g_return_val_if_fail (len >= boundary_len, SOUP_SOCKET_ERROR);
1487
1488         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1489
1490         g_mutex_lock (&priv->iolock);
1491
1492         *got_boundary = FALSE;
1493
1494         if (!priv->istream)
1495                 status = SOUP_SOCKET_EOF;
1496         else {
1497                 my_nread = soup_filter_input_stream_read_until (
1498                         SOUP_FILTER_INPUT_STREAM (priv->istream),
1499                         buffer, len, boundary, boundary_len,
1500                         !priv->non_blocking,
1501                         got_boundary, cancellable, &my_err);
1502                 status = translate_read_status (sock, cancellable,
1503                                                 my_nread, nread, my_err, error);
1504         }
1505
1506         g_mutex_unlock (&priv->iolock);
1507         return status;
1508 }
1509
1510 static gboolean
1511 socket_write_watch (GObject *pollable, gpointer user_data)
1512 {
1513         SoupSocket *sock = user_data;
1514         SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
1515
1516         priv->write_src = NULL;
1517         g_signal_emit (sock, signals[WRITABLE], 0);
1518         return FALSE;
1519 }
1520
1521 /**
1522  * soup_socket_write:
1523  * @sock: the socket
1524  * @buffer: data to write
1525  * @len: size of @buffer, in bytes
1526  * @nwrote: (out): on return, number of bytes written
1527  * @cancellable: a #GCancellable, or %NULL
1528  * @error: error pointer
1529  *
1530  * Attempts to write @len bytes from @buffer to @sock. If some data is
1531  * successfully written, the return status will be %SOUP_SOCKET_OK,
1532  * and *@nwrote will contain the number of bytes actually written
1533  * (which may be less than @len).
1534  *
1535  * If @sock is non-blocking, and no data could be written right away,
1536  * the return value will be %SOUP_SOCKET_WOULD_BLOCK. In this case,
1537  * the caller can connect to the #SoupSocket::writable signal to know
1538  * when more data can be written. (NB: #SoupSocket::writable is only
1539  * emitted after soup_socket_write() returns %SOUP_SOCKET_WOULD_BLOCK,
1540  * and it is only emitted once. See the documentation for
1541  * #SoupSocket:non-blocking.)
1542  *
1543  * Return value: a #SoupSocketIOStatus, as described above (or
1544  * %SOUP_SOCKET_EOF or %SOUP_SOCKET_ERROR. @error will be set if the
1545  * return value is %SOUP_SOCKET_ERROR.)
1546  **/
1547 SoupSocketIOStatus
1548 soup_socket_write (SoupSocket *sock, gconstpointer buffer,
1549                    gsize len, gsize *nwrote,
1550                    GCancellable *cancellable, GError **error)
1551 {
1552         SoupSocketPrivate *priv;
1553         GError *my_err = NULL;
1554         gssize my_nwrote;
1555
1556         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
1557         g_return_val_if_fail (nwrote != NULL, SOUP_SOCKET_ERROR);
1558
1559         priv = SOUP_SOCKET_GET_PRIVATE (sock);
1560
1561         g_mutex_lock (&priv->iolock);
1562
1563         if (!priv->conn) {
1564                 g_mutex_unlock (&priv->iolock);
1565                 return SOUP_SOCKET_EOF;
1566         }
1567         if (priv->write_src) {
1568                 g_mutex_unlock (&priv->iolock);
1569                 return SOUP_SOCKET_WOULD_BLOCK;
1570         }
1571
1572         if (!priv->non_blocking) {
1573                 my_nwrote = g_output_stream_write (priv->ostream,
1574                                                    buffer, len,
1575                                                    cancellable, &my_err);
1576         } else {
1577                 my_nwrote = g_pollable_output_stream_write_nonblocking (
1578                         G_POLLABLE_OUTPUT_STREAM (priv->ostream),
1579                         buffer, len, cancellable, &my_err);
1580         }
1581
1582         if (my_nwrote > 0) {
1583                 g_mutex_unlock (&priv->iolock);
1584                 g_clear_error (&my_err);
1585                 *nwrote = my_nwrote;
1586                 return SOUP_SOCKET_OK;
1587         }
1588
1589         if (g_error_matches (my_err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
1590                 g_mutex_unlock (&priv->iolock);
1591                 g_clear_error (&my_err);
1592
1593                 priv->write_src =
1594                         soup_socket_create_watch (priv,
1595                                                   G_IO_OUT,
1596                                                   socket_write_watch, sock, cancellable);
1597                 return SOUP_SOCKET_WOULD_BLOCK;
1598         }
1599
1600         g_mutex_unlock (&priv->iolock);
1601         g_propagate_error (error, my_err);
1602         return SOUP_SOCKET_ERROR;
1603 }