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 <errno.h>
  13 #include <fcntl.h>
  14 #include <signal.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17
  18 #include "soup-address.h"
  19 #include "soup-socket.h"
  20 #include "soup-marshal.h"
  21 #include "soup-misc.h"
  22 #include "soup-ssl.h"
  23
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <netinet/in.h>
  27 #include <netinet/tcp.h>
  28
  29 #define PARENT_TYPE G_TYPE_OBJECT
  30 static GObjectClass *parent_class;
  31
  32 enum {
  33         CONNECT_RESULT,
  34         READABLE,
  35         WRITABLE,
  36         DISCONNECTED,
  37         NEW_CONNECTION,
  38         LAST_SIGNAL
  39 };
  40
  41 static guint signals[LAST_SIGNAL] = { 0 };
  42
  43 enum {
  44         PROP_0,
  45
  46         PROP_NON_BLOCKING,
  47         PROP_NODELAY,
  48         PROP_REUSEADDR,
  49         PROP_IS_SERVER,
  50         PROP_SSL_CREDENTIALS,
  51
  52         LAST_PROP
  53 };
  54
  55 struct SoupSocketPrivate {
  56         int sockfd;
  57         SoupAddress *local_addr, *remote_addr;
  58         GIOChannel *iochannel;
  59
  60         guint non_blocking:1;
  61         guint nodelay:1;
  62         guint reuseaddr:1;
  63         guint is_server:1;
  64         gpointer ssl_creds;
  65
  66         guint           watch;
  67         guint           read_tag, write_tag, error_tag;
  68         GByteArray     *read_buf;
  69 };
  70
  71 #ifdef HAVE_IPV6
  72 #define soup_sockaddr_max sockaddr_in6
  73 #else
  74 #define soup_sockaddr_max sockaddr_in
  75 #endif
  76
  77 static void set_property (GObject *object, guint prop_id,
  78                           const GValue *value, GParamSpec *pspec);
  79 static void get_property (GObject *object, guint prop_id,
  80                           GValue *value, GParamSpec *pspec);
  81
  82 static void
  83 init (GObject *object)
  84 {
  85         SoupSocket *sock = SOUP_SOCKET (object);
  86
  87         sock->priv = g_new0 (SoupSocketPrivate, 1);
  88         sock->priv->sockfd = -1;
  89         sock->priv->non_blocking = sock->priv->nodelay = TRUE;
  90         sock->priv->reuseaddr = TRUE;
  91 }
  92
  93 static gboolean
  94 disconnect_internal (SoupSocket *sock)
  95 {
  96         GIOChannel *iochannel;
  97
  98         /* If we close the socket from one thread while
  99          * reading/writing from another, it's possible that the other
 100          * thread will get an I/O error and try to close the socket
 101          * while we're still in this function. So we clear
 102          * sock->priv->iochannel early to make sure that the other
 103          * thread's attempt to close the socket becomes a no-op.
 104          */
 105         iochannel = sock->priv->iochannel;
 106         sock->priv->iochannel = NULL;
 107         if (iochannel == NULL)
 108                 return FALSE;
 109
 110         g_io_channel_unref (iochannel);
 111
 112         if (sock->priv->read_tag) {
 113                 g_source_remove (sock->priv->read_tag);
 114                 sock->priv->read_tag = 0;
 115         }
 116         if (sock->priv->write_tag) {
 117                 g_source_remove (sock->priv->write_tag);
 118                 sock->priv->write_tag = 0;
 119         }
 120         if (sock->priv->error_tag) {
 121                 g_source_remove (sock->priv->error_tag);
 122                 sock->priv->error_tag = 0;
 123         }
 124
 125         return TRUE;
 126 }
 127
 128 static void
 129 finalize (GObject *object)
 130 {
 131         SoupSocket *sock = SOUP_SOCKET (object);
 132
 133         if (sock->priv->iochannel)
 134                 disconnect_internal (sock);
 135
 136         if (sock->priv->local_addr)
 137                 g_object_unref (sock->priv->local_addr);
 138         if (sock->priv->remote_addr)
 139                 g_object_unref (sock->priv->remote_addr);
 140
 141         if (sock->priv->watch)
 142                 g_source_remove (sock->priv->watch);
 143
 144         g_free (sock->priv);
 145
 146         G_OBJECT_CLASS (parent_class)->finalize (object);
 147 }
 148
 149 static void
 150 class_init (GObjectClass *object_class)
 151 {
 152         parent_class = g_type_class_ref (PARENT_TYPE);
 153
 154         /* virtual method override */
 155         object_class->finalize = finalize;
 156         object_class->set_property = set_property;
 157         object_class->get_property = get_property;
 158
 159         /* signals */
 160         signals[CONNECT_RESULT] =
 161                 g_signal_new ("connect_result",
 162                               G_OBJECT_CLASS_TYPE (object_class),
 163                               G_SIGNAL_RUN_FIRST,
 164                               G_STRUCT_OFFSET (SoupSocketClass, connect_result),
 165                               NULL, NULL,
 166                               soup_marshal_NONE__INT,
 167                               G_TYPE_NONE, 1,
 168                               G_TYPE_INT);
 169         signals[READABLE] =
 170                 g_signal_new ("readable",
 171                               G_OBJECT_CLASS_TYPE (object_class),
 172                               G_SIGNAL_RUN_LAST,
 173                               G_STRUCT_OFFSET (SoupSocketClass, readable),
 174                               NULL, NULL,
 175                               soup_marshal_NONE__NONE,
 176                               G_TYPE_NONE, 0);
 177         signals[WRITABLE] =
 178                 g_signal_new ("writable",
 179                               G_OBJECT_CLASS_TYPE (object_class),
 180                               G_SIGNAL_RUN_LAST,
 181                               G_STRUCT_OFFSET (SoupSocketClass, writable),
 182                               NULL, NULL,
 183                               soup_marshal_NONE__NONE,
 184                               G_TYPE_NONE, 0);
 185         signals[DISCONNECTED] =
 186                 g_signal_new ("disconnected",
 187                               G_OBJECT_CLASS_TYPE (object_class),
 188                               G_SIGNAL_RUN_LAST,
 189                               G_STRUCT_OFFSET (SoupSocketClass, disconnected),
 190                               NULL, NULL,
 191                               soup_marshal_NONE__NONE,
 192                               G_TYPE_NONE, 0);
 193         signals[NEW_CONNECTION] =
 194                 g_signal_new ("new_connection",
 195                               G_OBJECT_CLASS_TYPE (object_class),
 196                               G_SIGNAL_RUN_FIRST,
 197                               G_STRUCT_OFFSET (SoupSocketClass, new_connection),
 198                               NULL, NULL,
 199                               soup_marshal_NONE__OBJECT,
 200                               G_TYPE_NONE, 1,
 201                               SOUP_TYPE_SOCKET);
 202
 203         /* properties */
 204         g_object_class_install_property (
 205                 object_class, PROP_NON_BLOCKING,
 206                 g_param_spec_boolean (SOUP_SOCKET_FLAG_NONBLOCKING,
 207                                       "Non-blocking",
 208                                       "Whether or not the socket uses non-blocking I/O",
 209                                       TRUE,
 210                                       G_PARAM_READWRITE));
 211         g_object_class_install_property (
 212                 object_class, PROP_NODELAY,
 213                 g_param_spec_boolean (SOUP_SOCKET_FLAG_NODELAY,
 214                                       "NODELAY",
 215                                       "Whether or not the socket uses TCP NODELAY",
 216                                       TRUE,
 217                                       G_PARAM_READWRITE));
 218         g_object_class_install_property (
 219                 object_class, PROP_REUSEADDR,
 220                 g_param_spec_boolean (SOUP_SOCKET_FLAG_REUSEADDR,
 221                                       "REUSEADDR",
 222                                       "Whether or not the socket uses the TCP REUSEADDR flag",
 223                                       TRUE,
 224                                       G_PARAM_READWRITE));
 225         g_object_class_install_property (
 226                 object_class, PROP_IS_SERVER,
 227                 g_param_spec_boolean (SOUP_SOCKET_IS_SERVER,
 228                                       "Server",
 229                                       "Whether or not the socket is a server socket",
 230                                       FALSE,
 231                                       G_PARAM_READABLE));
 232         g_object_class_install_property (
 233                 object_class, PROP_SSL_CREDENTIALS,
 234                 g_param_spec_pointer (SOUP_SOCKET_SSL_CREDENTIALS,
 235                                       "SSL credentials",
 236                                       "SSL credential information, passed from the session to the SSL implementation",
 237                                       G_PARAM_READWRITE));
 238 }
 239
 240 SOUP_MAKE_TYPE (soup_socket, SoupSocket, class_init, init, PARENT_TYPE)
 241
 242
 243 static void
 244 update_fdflags (SoupSocket *sock)
 245 {
 246         int flags, opt;
 247
 248         if (!sock->priv->sockfd)
 249                 return;
 250
 251         flags = fcntl (sock->priv->sockfd, F_GETFL, 0);
 252         if (flags != -1) {
 253                 if (sock->priv->non_blocking)
 254                         flags |= O_NONBLOCK;
 255                 else
 256                         flags &= ~O_NONBLOCK;
 257                 fcntl (sock->priv->sockfd, F_SETFL, flags);
 258         }
 259
 260         opt = (sock->priv->nodelay != 0);
 261         setsockopt (sock->priv->sockfd, IPPROTO_TCP,
 262                     TCP_NODELAY, &opt, sizeof (opt));
 263
 264         opt = (sock->priv->reuseaddr != 0);
 265         setsockopt (sock->priv->sockfd, SOL_SOCKET,
 266                     SO_REUSEADDR, &opt, sizeof (opt));
 267 }
 268
 269 static void
 270 set_property (GObject *object, guint prop_id,
 271               const GValue *value, GParamSpec *pspec)
 272 {
 273         SoupSocket *sock = SOUP_SOCKET (object);
 274
 275         switch (prop_id) {
 276         case PROP_NON_BLOCKING:
 277                 sock->priv->non_blocking = g_value_get_boolean (value);
 278                 update_fdflags (sock);
 279                 break;
 280         case PROP_NODELAY:
 281                 sock->priv->nodelay = g_value_get_boolean (value);
 282                 update_fdflags (sock);
 283                 break;
 284         case PROP_REUSEADDR:
 285                 sock->priv->reuseaddr = g_value_get_boolean (value);
 286                 update_fdflags (sock);
 287                 break;
 288         case PROP_SSL_CREDENTIALS:
 289                 sock->priv->ssl_creds = g_value_get_pointer (value);
 290                 break;
 291         default:
 292                 break;
 293         }
 294 }
 295
 296 static void
 297 get_property (GObject *object, guint prop_id,
 298               GValue *value, GParamSpec *pspec)
 299 {
 300         SoupSocket *sock = SOUP_SOCKET (object);
 301
 302         switch (prop_id) {
 303         case PROP_NON_BLOCKING:
 304                 g_value_set_boolean (value, sock->priv->non_blocking);
 305                 break;
 306         case PROP_NODELAY:
 307                 g_value_set_boolean (value, sock->priv->nodelay);
 308                 break;
 309         case PROP_REUSEADDR:
 310                 g_value_set_boolean (value, sock->priv->reuseaddr);
 311                 break;
 312         case PROP_IS_SERVER:
 313                 g_value_set_boolean (value, sock->priv->is_server);
 314                 break;
 315         case PROP_SSL_CREDENTIALS:
 316                 g_value_set_pointer (value, sock->priv->ssl_creds);
 317                 break;
 318         default:
 319                 break;
 320         }
 321 }
 322
 323
 324 /**
 325  * soup_socket_new:
 326  * @optname1: name of first property to set (or %NULL)
 327  * @...: value of @optname1, followed by additional property/value pairs
 328  *
 329  * Return value: a new (disconnected) socket
 330  **/
 331 SoupSocket *
 332 soup_socket_new (const char *optname1, ...)
 333 {
 334         SoupSocket *sock;
 335         va_list ap;
 336
 337         va_start (ap, optname1);
 338         sock = (SoupSocket *)g_object_new_valist (SOUP_TYPE_SOCKET,
 339                                                   optname1, ap);
 340         va_end (ap);
 341
 342         return sock;
 343 }
 344
 345 static GIOChannel *
 346 get_iochannel (SoupSocket *sock)
 347 {
 348         if (!sock->priv->iochannel) {
 349                 sock->priv->iochannel =
 350                         g_io_channel_unix_new (sock->priv->sockfd);
 351                 g_io_channel_set_close_on_unref (sock->priv->iochannel, TRUE);
 352                 g_io_channel_set_encoding (sock->priv->iochannel, NULL, NULL);
 353                 g_io_channel_set_buffered (sock->priv->iochannel, FALSE);
 354         }
 355         return sock->priv->iochannel;
 356 }
 357
 358 static gboolean
 359 idle_connect_result (gpointer user_data)
 360 {
 361         SoupSocket *sock = user_data;
 362
 363         sock->priv->watch = 0;
 364
 365         g_signal_emit (sock, signals[CONNECT_RESULT], 0,
 366                        sock->priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT);
 367         return FALSE;
 368 }
 369
 370 static gboolean
 371 connect_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data)
 372 {
 373         SoupSocket *sock = data;
 374         int error = 0;
 375         int len = sizeof (error);
 376
 377         /* Remove the watch now in case we don't return immediately */
 378         g_source_remove (sock->priv->watch);
 379         sock->priv->watch = 0;
 380
 381         if (condition & ~(G_IO_IN | G_IO_OUT))
 382                 goto cant_connect;
 383
 384         if (getsockopt (sock->priv->sockfd, SOL_SOCKET, SO_ERROR,
 385                         &error, &len) != 0)
 386                 goto cant_connect;
 387         if (error)
 388                 goto cant_connect;
 389
 390         return idle_connect_result (sock);
 391
 392  cant_connect:
 393         g_signal_emit (sock, signals[CONNECT_RESULT], 0, SOUP_STATUS_CANT_CONNECT);
 394         return FALSE;
 395 }
 396
 397 static void
 398 got_address (SoupAddress *addr, guint status, gpointer user_data)
 399 {
 400         SoupSocket *sock = user_data;
 401
 402         if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 403                 g_signal_emit (sock, signals[CONNECT_RESULT], 0, status);
 404                 g_object_unref (sock);
 405                 return;
 406         }
 407
 408         soup_socket_connect (sock, sock->priv->remote_addr);
 409         /* soup_socket_connect re-reffed addr */
 410         g_object_unref (addr);
 411
 412         g_object_unref (sock);
 413 }
 414
 415 /**
 416  * soup_socket_connect:
 417  * @sock: a client #SoupSocket (which must not already be connected)
 418  * @remote_addr: address to connect to
 419  *
 420  * If %SOUP_SOCKET_FLAG_NONBLOCKING has been set on the socket, this
 421  * begins asynchronously connecting to the given address. The socket
 422  * will emit %connect_result when it succeeds or fails (but not before
 423  * returning from this function).
 424  *
 425  * If %SOUP_SOCKET_FLAG_NONBLOCKING has not been set, this will
 426  * attempt to synchronously connect.
 427  *
 428  * Return value: %SOUP_STATUS_CONTINUE if connecting asynchronously,
 429  * otherwise a success or failure code.
 430  **/
 431 guint
 432 soup_socket_connect (SoupSocket *sock, SoupAddress *remote_addr)
 433 {
 434         struct sockaddr *sa;
 435         int len, status;
 436
 437         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED);
 438         g_return_val_if_fail (!sock->priv->is_server, SOUP_STATUS_MALFORMED);
 439         g_return_val_if_fail (sock->priv->sockfd == -1, SOUP_STATUS_MALFORMED);
 440         g_return_val_if_fail (SOUP_IS_ADDRESS (remote_addr), SOUP_STATUS_MALFORMED);
 441
 442         sock->priv->remote_addr = g_object_ref (remote_addr);
 443         if (!sock->priv->non_blocking) {
 444                 status = soup_address_resolve_sync (remote_addr);
 445                 if (!SOUP_STATUS_IS_SUCCESSFUL (status))
 446                         return status;
 447         }
 448
 449         sa = soup_address_get_sockaddr (sock->priv->remote_addr, &len);
 450         if (!sa) {
 451                 if (!sock->priv->non_blocking)
 452                         return SOUP_STATUS_CANT_RESOLVE;
 453
 454                 g_object_ref (sock);
 455                 soup_address_resolve_async (remote_addr, got_address, sock);
 456                 return SOUP_STATUS_CONTINUE;
 457         }
 458
 459         sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
 460         if (sock->priv->sockfd == -1) {
 461                 g_free (sa);
 462                 goto done;
 463         }
 464         update_fdflags (sock);
 465
 466         status = connect (sock->priv->sockfd, sa, len);
 467         g_free (sa);
 468
 469         if (status == -1) {
 470                 if (errno == EINPROGRESS) {
 471                         /* Wait for connect to succeed or fail */
 472                         sock->priv->watch =
 473                                 g_io_add_watch (get_iochannel (sock),
 474                                                 G_IO_IN | G_IO_OUT |
 475                                                 G_IO_PRI | G_IO_ERR |
 476                                                 G_IO_HUP | G_IO_NVAL,
 477                                                 connect_watch, sock);
 478                         return SOUP_STATUS_CONTINUE;
 479                 } else {
 480                         close (sock->priv->sockfd);
 481                         sock->priv->sockfd = -1;
 482                 }
 483         }
 484
 485  done:
 486         if (sock->priv->non_blocking) {
 487                 sock->priv->watch = g_idle_add (idle_connect_result, sock);
 488                 return SOUP_STATUS_CONTINUE;
 489         } else if (sock->priv->sockfd == -1)
 490                 return SOUP_STATUS_CANT_CONNECT;
 491         else {
 492                 get_iochannel (sock);
 493                 return SOUP_STATUS_OK;
 494         }
 495 }
 496
 497 static gboolean
 498 listen_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data)
 499 {
 500         SoupSocket *sock = data, *new;
 501         struct soup_sockaddr_max sa;
 502         int sa_len, sockfd;
 503
 504         if (condition & (G_IO_HUP | G_IO_ERR)) {
 505                 g_source_remove (sock->priv->watch);
 506                 sock->priv->watch = 0;
 507                 return FALSE;
 508         }
 509
 510         sa_len = sizeof (sa);
 511         sockfd = accept (sock->priv->sockfd, (struct sockaddr *)&sa, &sa_len);
 512         if (sockfd == -1)
 513                 return TRUE;
 514
 515         new = g_object_new (SOUP_TYPE_SOCKET, NULL);
 516         new->priv->sockfd = sockfd;
 517         new->priv->non_blocking = sock->priv->non_blocking;
 518         new->priv->nodelay = sock->priv->nodelay;
 519         new->priv->is_server = TRUE;
 520         new->priv->ssl_creds = sock->priv->ssl_creds;
 521         update_fdflags (new);
 522
 523         new->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
 524
 525         if (new->priv->ssl_creds) {
 526                 if (!soup_socket_start_ssl (new)) {
 527                         g_object_unref (new);
 528                         return TRUE;
 529                 }
 530         } else
 531                 get_iochannel (new);
 532
 533         g_signal_emit (sock, signals[NEW_CONNECTION], 0, new);
 534         g_object_unref (new);
 535
 536         return TRUE;
 537 }
 538
 539 /**
 540  * soup_socket_listen:
 541  * @sock: a server #SoupSocket (which must not already be connected or
 542  * listening)
 543  * @local_addr: Local address to bind to.
 544  *
 545  * Makes @sock start listening on the given interface and port. When
 546  * connections come in, @sock will emit %new_connection.
 547  *
 548  * Return value: whether or not @sock is now listening.
 549  **/
 550 gboolean
 551 soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr)
 552 {
 553         struct sockaddr *sa;
 554         int sa_len;
 555
 556         g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
 557         g_return_val_if_fail (sock->priv->is_server, FALSE);
 558         g_return_val_if_fail (sock->priv->sockfd == -1, FALSE);
 559         g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), FALSE);
 560
 561         /* @local_addr may have its port set to 0. So we intentionally
 562          * don't store it in sock->priv->local_addr, so that if the
 563          * caller calls soup_socket_get_local_address() later, we'll
 564          * have to make a new addr by calling getsockname(), which
 565          * will have the right port number.
 566          */
 567         sa = soup_address_get_sockaddr (local_addr, &sa_len);
 568         g_return_val_if_fail (sa != NULL, FALSE);
 569
 570         sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
 571         if (sock->priv->sockfd < 0)
 572                 goto cant_listen;
 573         update_fdflags (sock);
 574
 575         /* Bind */
 576         if (bind (sock->priv->sockfd, sa, sa_len) != 0)
 577                 goto cant_listen;
 578
 579         /* Listen */
 580         if (listen (sock->priv->sockfd, 10) != 0)
 581                 goto cant_listen;
 582
 583         sock->priv->watch = g_io_add_watch (get_iochannel (sock),
 584                                             G_IO_IN | G_IO_ERR | G_IO_HUP,
 585                                             listen_watch, sock);
 586         return TRUE;
 587
 588  cant_listen:
 589         if (sock->priv->sockfd != -1) {
 590                 close (sock->priv->sockfd);
 591                 sock->priv->sockfd = -1;
 592         }
 593         if (sa)
 594                 g_free (sa);
 595         return FALSE;
 596 }
 597
 598 /**
 599  * soup_socket_start_ssl:
 600  * @sock: the socket
 601  *
 602  * Starts using SSL on @socket.
 603  *
 604  * Return value: success or failure
 605  **/
 606 gboolean
 607 soup_socket_start_ssl (SoupSocket *sock)
 608 {
 609         GIOChannel *ssl_chan;
 610
 611         get_iochannel (sock);
 612         ssl_chan = soup_ssl_wrap_iochannel (
 613                 sock->priv->iochannel, sock->priv->is_server ?
 614                 SOUP_SSL_TYPE_SERVER : SOUP_SSL_TYPE_CLIENT,
 615                 soup_address_get_name (sock->priv->remote_addr),
 616                 sock->priv->ssl_creds);
 617
 618         if (!ssl_chan)
 619                 return FALSE;
 620
 621         sock->priv->iochannel = ssl_chan;
 622         return TRUE;
 623 }
 624
 625
 626 /**
 627  * soup_socket_client_new_async:
 628  * @hostname: remote machine to connect to
 629  * @port: remote port to connect to
 630  * @ssl_creds: SSL credentials structure, or %NULL if not SSL
 631  * @callback: callback to call when the socket is connected
 632  * @user_data: data for @callback
 633  *
 634  * Creates a connection to @hostname and @port. @callback will be
 635  * called when the connection completes (or fails).
 636  *
 637  * Return value: the new socket (not yet ready for use).
 638  **/
 639 SoupSocket *
 640 soup_socket_client_new_async (const char *hostname, guint port,
 641                               gpointer ssl_creds,
 642                               SoupSocketCallback callback, gpointer user_data)
 643 {
 644         SoupSocket *sock;
 645
 646         g_return_val_if_fail (hostname != NULL, NULL);
 647
 648         sock = g_object_new (SOUP_TYPE_SOCKET,
 649                              SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds,
 650                              NULL);
 651         soup_socket_connect (sock, soup_address_new (hostname, port));
 652
 653         if (callback) {
 654                 soup_signal_connect_once (sock, "connect_result",
 655                                           G_CALLBACK (callback), user_data);
 656         }
 657         return sock;
 658 }
 659
 660 /**
 661  * soup_socket_client_new_sync:
 662  * @hostname: remote machine to connect to
 663  * @port: remote port to connect to
 664  * @ssl_creds: SSL credentials structure, or %NULL if not SSL
 665  * @status_ret: pointer to return the soup status in
 666  *
 667  * Creates a connection to @hostname and @port. If @status_ret is not
 668  * %NULL, it will contain a status code on return.
 669  *
 670  * Return value: the new socket, or %NULL if it could not connect.
 671  **/
 672 SoupSocket *
 673 soup_socket_client_new_sync (const char *hostname, guint port,
 674                              gpointer ssl_creds, guint *status_ret)
 675 {
 676         SoupSocket *sock;
 677         guint status;
 678
 679         g_return_val_if_fail (hostname != NULL, NULL);
 680
 681         sock = g_object_new (SOUP_TYPE_SOCKET,
 682                              SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds,
 683                              NULL);
 684         sock->priv->non_blocking = FALSE;
 685         status = soup_socket_connect (sock, soup_address_new (hostname, port));
 686
 687         if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 688                 g_object_unref (sock);
 689                 sock = NULL;
 690         }
 691
 692         if (status_ret)
 693                 *status_ret = status;
 694         return sock;
 695 }
 696
 697 /**
 698  * soup_socket_server_new:
 699  * @local_addr: Local address to bind to. (Use soup_address_any_new() to
 700  * accept connections on any local address)
 701  * @ssl_creds: SSL credentials, or %NULL if this is not an SSL server
 702  * @callback: Callback to call when a client connects
 703  * @user_data: data to pass to @callback.
 704  *
 705  * Create and open a new #SoupSocket listening on the specified
 706  * address. @callback will be called each time a client connects,
 707  * with a new #SoupSocket.
 708  *
 709  * Returns: a new #SoupSocket, or NULL if there was a failure.
 710  **/
 711 SoupSocket *
 712 soup_socket_server_new (SoupAddress *local_addr, gpointer ssl_creds,
 713                         SoupSocketListenerCallback callback,
 714                         gpointer user_data)
 715 {
 716         SoupSocket *sock;
 717
 718         g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), NULL);
 719
 720         sock = g_object_new (SOUP_TYPE_SOCKET,
 721                              SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds,
 722                              NULL);
 723         sock->priv->is_server = TRUE;
 724         if (!soup_socket_listen (sock, local_addr)) {
 725                 g_object_unref (sock);
 726                 return NULL;
 727         }
 728
 729         if (callback) {
 730                 g_signal_connect (sock, "new_connection",
 731                                   G_CALLBACK (callback), user_data);
 732         }
 733
 734         return sock;
 735 }
 736
 737
 738 void
 739 soup_socket_disconnect (SoupSocket *sock)
 740 {
 741         g_return_if_fail (SOUP_IS_SOCKET (sock));
 742
 743         if (!disconnect_internal (sock))
 744                 return;
 745
 746         /* Give all readers a chance to notice the connection close */
 747         g_signal_emit (sock, signals[READABLE], 0);
 748
 749         /* FIXME: can't disconnect until all data is read */
 750
 751         /* Then let everyone know we're disconnected */
 752         g_signal_emit (sock, signals[DISCONNECTED], 0);
 753 }
 754
 755 gboolean
 756 soup_socket_is_connected (SoupSocket *sock)
 757 {
 758         g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
 759
 760         return sock->priv->iochannel != NULL;
 761 }
 762
 763
 764 SoupAddress *
 765 soup_socket_get_local_address (SoupSocket *sock)
 766 {
 767         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 768
 769         if (!sock->priv->local_addr) {
 770                 struct soup_sockaddr_max bound_sa;
 771                 int sa_len;
 772
 773                 sa_len = sizeof (bound_sa);
 774                 getsockname (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
 775                 sock->priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
 776         }
 777
 778         return sock->priv->local_addr;
 779 }
 780
 781 SoupAddress *
 782 soup_socket_get_remote_address (SoupSocket *sock)
 783 {
 784         g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 785
 786         if (!sock->priv->local_addr) {
 787                 struct soup_sockaddr_max bound_sa;
 788                 int sa_len;
 789
 790                 sa_len = sizeof (bound_sa);
 791                 getpeername (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
 792                 sock->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
 793         }
 794
 795         return sock->priv->remote_addr;
 796 }
 797
 798
 799
 800
 801 static gboolean
 802 socket_read_watch (GIOChannel *chan, GIOCondition cond, gpointer user_data)
 803 {
 804         SoupSocket *sock = user_data;
 805
 806         sock->priv->read_tag = 0;
 807         g_signal_emit (sock, signals[READABLE], 0);
 808
 809         return FALSE;
 810 }
 811
 812 static SoupSocketIOStatus
 813 read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 814 {
 815         GIOStatus status;
 816
 817         if (!sock->priv->iochannel)
 818                 return SOUP_SOCKET_EOF;
 819
 820         status = g_io_channel_read_chars (sock->priv->iochannel,
 821                                           buffer, len, nread, NULL);
 822         switch (status) {
 823         case G_IO_STATUS_NORMAL:
 824         case G_IO_STATUS_AGAIN:
 825                 if (*nread > 0)
 826                         return SOUP_SOCKET_OK;
 827
 828                 if (!sock->priv->read_tag) {
 829                         sock->priv->read_tag =
 830                                 g_io_add_watch (sock->priv->iochannel, G_IO_IN,
 831                                                 socket_read_watch, sock);
 832                 }
 833                 return SOUP_SOCKET_WOULD_BLOCK;
 834
 835         case G_IO_STATUS_EOF:
 836                 return SOUP_SOCKET_EOF;
 837
 838         default:
 839                 return SOUP_SOCKET_ERROR;
 840         }
 841 }
 842
 843 static SoupSocketIOStatus
 844 read_from_buf (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 845 {
 846         GByteArray *read_buf = sock->priv->read_buf;
 847
 848         *nread = MIN (read_buf->len, len);
 849         memcpy (buffer, read_buf->data, *nread);
 850
 851         if (*nread == read_buf->len) {
 852                 g_byte_array_free (read_buf, TRUE);
 853                 sock->priv->read_buf = NULL;
 854         } else {
 855                 memcpy (read_buf->data, read_buf->data + *nread,
 856                         read_buf->len - *nread);
 857                 g_byte_array_set_size (read_buf, read_buf->len - *nread);
 858         }
 859
 860         return SOUP_SOCKET_OK;
 861 }
 862
 863 /**
 864  * soup_socket_read:
 865  * @sock: the socket
 866  * @buffer: buffer to read into
 867  * @len: size of @buffer in bytes
 868  * @nread: on return, the number of bytes read into @buffer
 869  *
 870  * Attempts to read up to @len bytes from @sock into @buffer. If some
 871  * data is successfully read, soup_socket_read() will return
 872  * %SOUP_SOCKET_OK, and *@nread will contain the number of bytes
 873  * actually read.
 874  *
 875  * If @sock is non-blocking, and no data is available, the return
 876  * value will be %SOUP_SOCKET_WOULD_BLOCK. In this case, the caller
 877  * can connect to the %readable signal to know when there is more data
 878  * to read. (NB: You MUST read all available data off the socket
 879  * first. The %readable signal will only be emitted after
 880  * soup_socket_read() has returned %SOUP_SOCKET_WOULD_BLOCK.)
 881  *
 882  * Return value: a #SoupSocketIOStatus, as described above (or
 883  * %SOUP_SOCKET_EOF if the socket is no longer connected, or
 884  * %SOUP_SOCKET_ERROR on any other error).
 885  **/
 886 SoupSocketIOStatus
 887 soup_socket_read (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 888 {
 889         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
 890
 891         if (sock->priv->read_buf)
 892                 return read_from_buf (sock, buffer, len, nread);
 893         else
 894                 return read_from_network (sock, buffer, len, nread);
 895 }
 896
 897 /**
 898  * soup_socket_read_until:
 899  * @sock: the socket
 900  * @buffer: buffer to read into
 901  * @len: size of @buffer in bytes
 902  * @boundary: boundary to read until
 903  * @boundary_len: length of @boundary in bytes
 904  * @nread: on return, the number of bytes read into @buffer
 905  * @got_boundary: on return, whether or not the data in @buffer
 906  * ends with the boundary string
 907  *
 908  * Like soup_socket_read(), but reads no further than the first
 909  * occurrence of @boundary. (If the boundary is found, it will be
 910  * included in the returned data, and *@got_boundary will be set to
 911  * %TRUE.) Any data after the boundary will returned in future reads.
 912  *
 913  * Return value: as for soup_socket_read()
 914  **/
 915 SoupSocketIOStatus
 916 soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len,
 917                         gconstpointer boundary, gsize boundary_len,
 918                         gsize *nread, gboolean *got_boundary)
 919 {
 920         SoupSocketIOStatus status;
 921         GByteArray *read_buf;
 922         guint match_len, prev_len;
 923         guint8 *p, *end;
 924
 925         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
 926         g_return_val_if_fail (len >= boundary_len, SOUP_SOCKET_ERROR);
 927
 928         *got_boundary = FALSE;
 929
 930         if (!sock->priv->read_buf)
 931                 sock->priv->read_buf = g_byte_array_new ();
 932         read_buf = sock->priv->read_buf;
 933
 934         if (read_buf->len < boundary_len) {
 935                 prev_len = read_buf->len;
 936                 g_byte_array_set_size (read_buf, len);
 937                 status = read_from_network (sock,
 938                                             read_buf->data + prev_len,
 939                                             len - prev_len, nread);
 940                 read_buf->len = prev_len + *nread;
 941
 942                 if (status != SOUP_SOCKET_OK)
 943                         return status;
 944         }
 945
 946         /* Scan for the boundary */
 947         end = read_buf->data + read_buf->len;
 948         for (p = read_buf->data; p <= end - boundary_len; p++) {
 949                 if (!memcmp (p, boundary, boundary_len)) {
 950                         p += boundary_len;
 951                         *got_boundary = TRUE;
 952                         break;
 953                 }
 954         }
 955
 956         /* Return everything up to 'p' (which is either just after the
 957          * boundary, or @boundary_len - 1 bytes before the end of the
 958          * buffer).
 959          */
 960         match_len = p - read_buf->data;
 961         return read_from_buf (sock, buffer, MIN (len, match_len), nread);
 962 }
 963
 964 static gboolean
 965 socket_write_watch (GIOChannel *chan, GIOCondition condition, gpointer user_data)
 966 {
 967         SoupSocket *sock = user_data;
 968
 969         sock->priv->write_tag = 0;
 970         g_signal_emit (sock, signals[WRITABLE], 0);
 971
 972         return FALSE;
 973 }
 974
 975 /**
 976  * soup_socket_write:
 977  * @sock: the socket
 978  * @buffer: data to write
 979  * @len: size of @buffer, in bytes
 980  * @nwrote: on return, number of bytes written
 981  *
 982  * Attempts to write @len bytes from @buffer to @sock. If some data is
 983  * successfully written, the resturn status will be
 984  * %SOUP_SOCKET_SUCCESS, and *@nwrote will contain the number of bytes
 985  * actually written.
 986  *
 987  * If @sock is non-blocking, and no data could be written right away,
 988  * the return value will be %SOUP_SOCKET_WOULD_BLOCK. In this case,
 989  * the caller can connect to the %writable signal to know when more
 990  * data can be written. (NB: %writable is only emitted after a
 991  * %SOUP_SOCKET_WOULD_BLOCK.)
 992  *
 993  * Return value: a #SoupSocketIOStatus, as described above (or
 994  * %SOUP_SOCKET_EOF or %SOUP_SOCKET_ERROR).
 995  **/
 996 SoupSocketIOStatus
 997 soup_socket_write (SoupSocket *sock, gconstpointer buffer,
 998                    gsize len, gsize *nwrote)
 999 {
1000         GIOStatus status;
1001         gpointer pipe_handler;
1002
1003         g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
1004
1005         if (!sock->priv->iochannel)
1006                 return SOUP_SOCKET_EOF;
1007         if (sock->priv->write_tag)
1008                 return SOUP_SOCKET_WOULD_BLOCK;
1009
1010         pipe_handler = signal (SIGPIPE, SIG_IGN);
1011         status = g_io_channel_write_chars (sock->priv->iochannel,
1012                                            buffer, len, nwrote, NULL);
1013         signal (SIGPIPE, pipe_handler);
1014         if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN)
1015                 return SOUP_SOCKET_ERROR;
1016
1017         if (*nwrote)
1018                 return SOUP_SOCKET_OK;
1019
1020         sock->priv->write_tag =
1021                 g_io_add_watch (sock->priv->iochannel, G_IO_OUT,
1022                                 socket_write_watch, sock);
1023         return SOUP_SOCKET_WOULD_BLOCK;
1024 }