dbus/dbus-transport-socket.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-transport-socket.c  Socket subclasses of DBusTransport
   3  *
   4  * Copyright (C) 2002, 2003, 2004, 2006  Red Hat Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include "dbus-internals.h"
  25 #include "dbus-connection-internal.h"
  26 #include "dbus-transport-socket.h"
  27 #include "dbus-transport-protected.h"
  28 #include "dbus-watch.h"
  29 #include "dbus-credentials.h"
  30
  31
  32 /**
  33  * @defgroup DBusTransportSocket DBusTransport implementations for sockets
  34  * @ingroup  DBusInternals
  35  * @brief Implementation details of DBusTransport on sockets
  36  *
  37  * @{
  38  */
  39
  40 /**
  41  * Opaque object representing a socket file descriptor transport.
  42  */
  43 typedef struct DBusTransportSocket DBusTransportSocket;
  44
  45 /**
  46  * Implementation details of DBusTransportSocket. All members are private.
  47  */
  48 struct DBusTransportSocket
  49 {
  50   DBusTransport base;                   /**< Parent instance */
  51   int fd;                               /**< File descriptor. */
  52   DBusWatch *read_watch;                /**< Watch for readability. */
  53   DBusWatch *write_watch;               /**< Watch for writability. */
  54
  55   int max_bytes_read_per_iteration;     /**< To avoid blocking too long. */
  56   int max_bytes_written_per_iteration;  /**< To avoid blocking too long. */
  57
  58   int message_bytes_written;            /**< Number of bytes of current
  59                                          *   outgoing message that have
  60                                          *   been written.
  61                                          */
  62   DBusString encoded_outgoing;          /**< Encoded version of current
  63                                          *   outgoing message.
  64                                          */
  65   DBusString encoded_incoming;          /**< Encoded version of current
  66                                          *   incoming data.
  67                                          */
  68 };
  69
  70 static void
  71 free_watches (DBusTransport *transport)
  72 {
  73   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
  74
  75   _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME);
  76
  77   if (socket_transport->read_watch)
  78     {
  79       if (transport->connection)
  80         _dbus_connection_remove_watch_unlocked (transport->connection,
  81                                                 socket_transport->read_watch);
  82       _dbus_watch_invalidate (socket_transport->read_watch);
  83       _dbus_watch_unref (socket_transport->read_watch);
  84       socket_transport->read_watch = NULL;
  85     }
  86
  87   if (socket_transport->write_watch)
  88     {
  89       if (transport->connection)
  90         _dbus_connection_remove_watch_unlocked (transport->connection,
  91                                                 socket_transport->write_watch);
  92       _dbus_watch_invalidate (socket_transport->write_watch);
  93       _dbus_watch_unref (socket_transport->write_watch);
  94       socket_transport->write_watch = NULL;
  95     }
  96
  97   _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);
  98 }
  99
 100 static void
 101 socket_finalize (DBusTransport *transport)
 102 {
 103   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 104
 105   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 106
 107   free_watches (transport);
 108
 109   _dbus_string_free (&socket_transport->encoded_outgoing);
 110   _dbus_string_free (&socket_transport->encoded_incoming);
 111
 112   _dbus_transport_finalize_base (transport);
 113
 114   _dbus_assert (socket_transport->read_watch == NULL);
 115   _dbus_assert (socket_transport->write_watch == NULL);
 116
 117   dbus_free (transport);
 118 }
 119
 120 static void
 121 check_write_watch (DBusTransport *transport)
 122 {
 123   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 124   dbus_bool_t needed;
 125
 126   if (transport->connection == NULL)
 127     return;
 128
 129   if (transport->disconnected)
 130     {
 131       _dbus_assert (socket_transport->write_watch == NULL);
 132       return;
 133     }
 134
 135   _dbus_transport_ref (transport);
 136
 137   if (_dbus_transport_get_is_authenticated (transport))
 138     needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);
 139   else
 140     {
 141       if (transport->send_credentials_pending)
 142         needed = TRUE;
 143       else
 144         {
 145           DBusAuthState auth_state;
 146
 147           auth_state = _dbus_auth_do_work (transport->auth);
 148
 149           /* If we need memory we install the write watch just in case,
 150            * if there's no need for it, it will get de-installed
 151            * next time we try reading.
 152            */
 153           if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||
 154               auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
 155             needed = TRUE;
 156           else
 157             needed = FALSE;
 158         }
 159     }
 160
 161   _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",
 162                  needed, transport->connection, socket_transport->write_watch,
 163                  socket_transport->fd,
 164                  _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 165
 166   _dbus_connection_toggle_watch_unlocked (transport->connection,
 167                                           socket_transport->write_watch,
 168                                           needed);
 169
 170   _dbus_transport_unref (transport);
 171 }
 172
 173 static void
 174 check_read_watch (DBusTransport *transport)
 175 {
 176   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 177   dbus_bool_t need_read_watch;
 178
 179   _dbus_verbose ("%s: fd = %d\n",
 180                  _DBUS_FUNCTION_NAME, socket_transport->fd);
 181
 182   if (transport->connection == NULL)
 183     return;
 184
 185   if (transport->disconnected)
 186     {
 187       _dbus_assert (socket_transport->read_watch == NULL);
 188       return;
 189     }
 190
 191   _dbus_transport_ref (transport);
 192
 193   if (_dbus_transport_get_is_authenticated (transport))
 194     need_read_watch =
 195       _dbus_counter_get_value (transport->live_messages_size) < transport->max_live_messages_size;
 196   else
 197     {
 198       if (transport->receive_credentials_pending)
 199         need_read_watch = TRUE;
 200       else
 201         {
 202           /* The reason to disable need_read_watch when not WAITING_FOR_INPUT
 203            * is to avoid spinning on the file descriptor when we're waiting
 204            * to write or for some other part of the auth process
 205            */
 206           DBusAuthState auth_state;
 207
 208           auth_state = _dbus_auth_do_work (transport->auth);
 209
 210           /* If we need memory we install the read watch just in case,
 211            * if there's no need for it, it will get de-installed
 212            * next time we try reading. If we're authenticated we
 213            * install it since we normally have it installed while
 214            * authenticated.
 215            */
 216           if (auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT ||
 217               auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY ||
 218               auth_state == DBUS_AUTH_STATE_AUTHENTICATED)
 219             need_read_watch = TRUE;
 220           else
 221             need_read_watch = FALSE;
 222         }
 223     }
 224
 225   _dbus_verbose ("  setting read watch enabled = %d\n", need_read_watch);
 226   _dbus_connection_toggle_watch_unlocked (transport->connection,
 227                                           socket_transport->read_watch,
 228                                           need_read_watch);
 229
 230   _dbus_transport_unref (transport);
 231 }
 232
 233 static void
 234 do_io_error (DBusTransport *transport)
 235 {
 236   _dbus_transport_ref (transport);
 237   _dbus_transport_disconnect (transport);
 238   _dbus_transport_unref (transport);
 239 }
 240
 241 /* return value is whether we successfully read any new data. */
 242 static dbus_bool_t
 243 read_data_into_auth (DBusTransport *transport,
 244                      dbus_bool_t   *oom)
 245 {
 246   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 247   DBusString *buffer;
 248   int bytes_read;
 249
 250   *oom = FALSE;
 251
 252   _dbus_auth_get_buffer (transport->auth, &buffer);
 253
 254   bytes_read = _dbus_read_socket (socket_transport->fd,
 255                                   buffer, socket_transport->max_bytes_read_per_iteration);
 256
 257   _dbus_auth_return_buffer (transport->auth, buffer,
 258                             bytes_read > 0 ? bytes_read : 0);
 259
 260   if (bytes_read > 0)
 261     {
 262       _dbus_verbose (" read %d bytes in auth phase\n", bytes_read);
 263
 264       return TRUE;
 265     }
 266   else if (bytes_read < 0)
 267     {
 268       /* EINTR already handled for us */
 269
 270       if (_dbus_get_is_errno_enomem ())
 271         {
 272           *oom = TRUE;
 273         }
 274       else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 275         ; /* do nothing, just return FALSE below */
 276       else
 277         {
 278           _dbus_verbose ("Error reading from remote app: %s\n",
 279                          _dbus_strerror_from_errno ());
 280           do_io_error (transport);
 281         }
 282
 283       return FALSE;
 284     }
 285   else
 286     {
 287       _dbus_assert (bytes_read == 0);
 288
 289       _dbus_verbose ("Disconnected from remote app\n");
 290       do_io_error (transport);
 291
 292       return FALSE;
 293     }
 294 }
 295
 296 /* Return value is whether we successfully wrote any bytes */
 297 static dbus_bool_t
 298 write_data_from_auth (DBusTransport *transport)
 299 {
 300   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 301   int bytes_written;
 302   const DBusString *buffer;
 303
 304   if (!_dbus_auth_get_bytes_to_send (transport->auth,
 305                                      &buffer))
 306     return FALSE;
 307
 308   bytes_written = _dbus_write_socket (socket_transport->fd,
 309                                       buffer,
 310                                       0, _dbus_string_get_length (buffer));
 311
 312   if (bytes_written > 0)
 313     {
 314       _dbus_auth_bytes_sent (transport->auth, bytes_written);
 315       return TRUE;
 316     }
 317   else if (bytes_written < 0)
 318     {
 319       /* EINTR already handled for us */
 320
 321       if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 322         ;
 323       else
 324         {
 325           _dbus_verbose ("Error writing to remote app: %s\n",
 326                          _dbus_strerror_from_errno ());
 327           do_io_error (transport);
 328         }
 329     }
 330
 331   return FALSE;
 332 }
 333
 334 /* FALSE on OOM */
 335 static dbus_bool_t
 336 exchange_credentials (DBusTransport *transport,
 337                       dbus_bool_t    do_reading,
 338                       dbus_bool_t    do_writing)
 339 {
 340   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 341   DBusError error;
 342
 343   _dbus_verbose ("exchange_credentials: do_reading = %d, do_writing = %d\n",
 344                   do_reading, do_writing);
 345
 346   dbus_error_init (&error);
 347   if (do_writing && transport->send_credentials_pending)
 348     {
 349       if (_dbus_send_credentials_socket (socket_transport->fd,
 350                                          &error))
 351         {
 352           transport->send_credentials_pending = FALSE;
 353         }
 354       else
 355         {
 356           _dbus_verbose ("Failed to write credentials: %s\n", error.message);
 357           dbus_error_free (&error);
 358           do_io_error (transport);
 359         }
 360     }
 361
 362   if (do_reading && transport->receive_credentials_pending)
 363     {
 364       /* FIXME this can fail due to IO error _or_ OOM, broken
 365        * (somewhat tricky to fix since the OOM error can be set after
 366        * we already read the credentials byte, so basically we need to
 367        * separate reading the byte and storing it in the
 368        * transport->credentials). Does not really matter for now
 369        * because storing in credentials never actually fails on unix.
 370        */
 371       if (_dbus_read_credentials_socket (socket_transport->fd,
 372                                          transport->credentials,
 373                                          &error))
 374         {
 375           transport->receive_credentials_pending = FALSE;
 376         }
 377       else
 378         {
 379           _dbus_verbose ("Failed to read credentials %s\n", error.message);
 380           dbus_error_free (&error);
 381           do_io_error (transport);
 382         }
 383     }
 384
 385   if (!(transport->send_credentials_pending ||
 386         transport->receive_credentials_pending))
 387     {
 388       if (!_dbus_auth_set_credentials (transport->auth,
 389                                        transport->credentials))
 390         return FALSE;
 391     }
 392
 393   return TRUE;
 394 }
 395
 396 static dbus_bool_t
 397 do_authentication (DBusTransport *transport,
 398                    dbus_bool_t    do_reading,
 399                    dbus_bool_t    do_writing,
 400                    dbus_bool_t   *auth_completed)
 401 {
 402   dbus_bool_t oom;
 403   dbus_bool_t orig_auth_state;
 404
 405   oom = FALSE;
 406
 407   orig_auth_state = _dbus_transport_get_is_authenticated (transport);
 408
 409   /* This is essential to avoid the check_write_watch() at the end,
 410    * we don't want to add a write watch in do_iteration before
 411    * we try writing and get EAGAIN
 412    */
 413   if (orig_auth_state)
 414     {
 415       if (auth_completed)
 416         *auth_completed = FALSE;
 417       return TRUE;
 418     }
 419
 420   _dbus_transport_ref (transport);
 421
 422   while (!_dbus_transport_get_is_authenticated (transport) &&
 423          _dbus_transport_get_is_connected (transport))
 424     {
 425       if (!exchange_credentials (transport, do_reading, do_writing))
 426         {
 427           /* OOM */
 428           oom = TRUE;
 429           goto out;
 430         }
 431
 432       if (transport->send_credentials_pending ||
 433           transport->receive_credentials_pending)
 434         {
 435           _dbus_verbose ("send_credentials_pending = %d receive_credentials_pending = %d\n",
 436                          transport->send_credentials_pending,
 437                          transport->receive_credentials_pending);
 438           goto out;
 439         }
 440
 441 #define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")
 442       switch (_dbus_auth_do_work (transport->auth))
 443         {
 444         case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
 445           _dbus_verbose (" %s auth state: waiting for input\n",
 446                          TRANSPORT_SIDE (transport));
 447           if (!do_reading || !read_data_into_auth (transport, &oom))
 448             goto out;
 449           break;
 450
 451         case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
 452           _dbus_verbose (" %s auth state: waiting for memory\n",
 453                          TRANSPORT_SIDE (transport));
 454           oom = TRUE;
 455           goto out;
 456           break;
 457
 458         case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
 459           _dbus_verbose (" %s auth state: bytes to send\n",
 460                          TRANSPORT_SIDE (transport));
 461           if (!do_writing || !write_data_from_auth (transport))
 462             goto out;
 463           break;
 464
 465         case DBUS_AUTH_STATE_NEED_DISCONNECT:
 466           _dbus_verbose (" %s auth state: need to disconnect\n",
 467                          TRANSPORT_SIDE (transport));
 468           do_io_error (transport);
 469           break;
 470
 471         case DBUS_AUTH_STATE_AUTHENTICATED:
 472           _dbus_verbose (" %s auth state: authenticated\n",
 473                          TRANSPORT_SIDE (transport));
 474           break;
 475         }
 476     }
 477
 478  out:
 479   if (auth_completed)
 480     *auth_completed = (orig_auth_state != _dbus_transport_get_is_authenticated (transport));
 481
 482   check_read_watch (transport);
 483   check_write_watch (transport);
 484   _dbus_transport_unref (transport);
 485
 486   if (oom)
 487     return FALSE;
 488   else
 489     return TRUE;
 490 }
 491
 492 /* returns false on oom */
 493 static dbus_bool_t
 494 do_writing (DBusTransport *transport)
 495 {
 496   int total;
 497   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 498   dbus_bool_t oom;
 499
 500   /* No messages without authentication! */
 501   if (!_dbus_transport_get_is_authenticated (transport))
 502     {
 503       _dbus_verbose ("Not authenticated, not writing anything\n");
 504       return TRUE;
 505     }
 506
 507   if (transport->disconnected)
 508     {
 509       _dbus_verbose ("Not connected, not writing anything\n");
 510       return TRUE;
 511     }
 512
 513 #if 1
 514   _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",
 515                  _dbus_connection_has_messages_to_send_unlocked (transport->connection),
 516                  socket_transport->fd);
 517 #endif
 518
 519   oom = FALSE;
 520   total = 0;
 521
 522   while (!transport->disconnected &&
 523          _dbus_connection_has_messages_to_send_unlocked (transport->connection))
 524     {
 525       int bytes_written;
 526       DBusMessage *message;
 527       const DBusString *header;
 528       const DBusString *body;
 529       int header_len, body_len;
 530       int total_bytes_to_write;
 531
 532       if (total > socket_transport->max_bytes_written_per_iteration)
 533         {
 534           _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",
 535                          total, socket_transport->max_bytes_written_per_iteration);
 536           goto out;
 537         }
 538
 539       message = _dbus_connection_get_message_to_send (transport->connection);
 540       _dbus_assert (message != NULL);
 541       _dbus_message_lock (message);
 542
 543 #if 0
 544       _dbus_verbose ("writing message %p\n", message);
 545 #endif
 546
 547       _dbus_message_get_network_data (message,
 548                                       &header, &body);
 549
 550       header_len = _dbus_string_get_length (header);
 551       body_len = _dbus_string_get_length (body);
 552
 553       if (_dbus_auth_needs_encoding (transport->auth))
 554         {
 555           if (_dbus_string_get_length (&socket_transport->encoded_outgoing) == 0)
 556             {
 557               if (!_dbus_auth_encode_data (transport->auth,
 558                                            header, &socket_transport->encoded_outgoing))
 559                 {
 560                   oom = TRUE;
 561                   goto out;
 562                 }
 563
 564               if (!_dbus_auth_encode_data (transport->auth,
 565                                            body, &socket_transport->encoded_outgoing))
 566                 {
 567                   _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 568                   oom = TRUE;
 569                   goto out;
 570                 }
 571             }
 572
 573           total_bytes_to_write = _dbus_string_get_length (&socket_transport->encoded_outgoing);
 574
 575 #if 0
 576           _dbus_verbose ("encoded message is %d bytes\n",
 577                          total_bytes_to_write);
 578 #endif
 579
 580           bytes_written =
 581             _dbus_write_socket (socket_transport->fd,
 582                                 &socket_transport->encoded_outgoing,
 583                                 socket_transport->message_bytes_written,
 584                                 total_bytes_to_write - socket_transport->message_bytes_written);
 585         }
 586       else
 587         {
 588           total_bytes_to_write = header_len + body_len;
 589
 590 #if 0
 591           _dbus_verbose ("message is %d bytes\n",
 592                          total_bytes_to_write);
 593 #endif
 594
 595           if (socket_transport->message_bytes_written < header_len)
 596             {
 597               bytes_written =
 598                 _dbus_write_socket_two (socket_transport->fd,
 599                                         header,
 600                                         socket_transport->message_bytes_written,
 601                                         header_len - socket_transport->message_bytes_written,
 602                                         body,
 603                                         0, body_len);
 604             }
 605           else
 606             {
 607               bytes_written =
 608                 _dbus_write_socket (socket_transport->fd,
 609                                     body,
 610                                     (socket_transport->message_bytes_written - header_len),
 611                                     body_len -
 612                                     (socket_transport->message_bytes_written - header_len));
 613             }
 614         }
 615
 616       if (bytes_written < 0)
 617         {
 618           /* EINTR already handled for us */
 619
 620           if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 621             goto out;
 622           else
 623             {
 624               _dbus_verbose ("Error writing to remote app: %s\n",
 625                              _dbus_strerror_from_errno ());
 626               do_io_error (transport);
 627               goto out;
 628             }
 629         }
 630       else
 631         {
 632           _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
 633                          total_bytes_to_write);
 634
 635           total += bytes_written;
 636           socket_transport->message_bytes_written += bytes_written;
 637
 638           _dbus_assert (socket_transport->message_bytes_written <=
 639                         total_bytes_to_write);
 640
 641           if (socket_transport->message_bytes_written == total_bytes_to_write)
 642             {
 643               socket_transport->message_bytes_written = 0;
 644               _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 645               _dbus_string_compact (&socket_transport->encoded_outgoing, 2048);
 646
 647               _dbus_connection_message_sent (transport->connection,
 648                                              message);
 649             }
 650         }
 651     }
 652
 653  out:
 654   if (oom)
 655     return FALSE;
 656   else
 657     return TRUE;
 658 }
 659
 660 /* returns false on out-of-memory */
 661 static dbus_bool_t
 662 do_reading (DBusTransport *transport)
 663 {
 664   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 665   DBusString *buffer;
 666   int bytes_read;
 667   int total;
 668   dbus_bool_t oom;
 669
 670   _dbus_verbose ("%s: fd = %d\n", _DBUS_FUNCTION_NAME,
 671                  socket_transport->fd);
 672
 673   /* No messages without authentication! */
 674   if (!_dbus_transport_get_is_authenticated (transport))
 675     return TRUE;
 676
 677   oom = FALSE;
 678
 679   total = 0;
 680
 681  again:
 682
 683   /* See if we've exceeded max messages and need to disable reading */
 684   check_read_watch (transport);
 685
 686   if (total > socket_transport->max_bytes_read_per_iteration)
 687     {
 688       _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
 689                      total, socket_transport->max_bytes_read_per_iteration);
 690       goto out;
 691     }
 692
 693   _dbus_assert (socket_transport->read_watch != NULL ||
 694                 transport->disconnected);
 695
 696   if (transport->disconnected)
 697     goto out;
 698
 699   if (!dbus_watch_get_enabled (socket_transport->read_watch))
 700     return TRUE;
 701
 702   if (_dbus_auth_needs_decoding (transport->auth))
 703     {
 704       if (_dbus_string_get_length (&socket_transport->encoded_incoming) > 0)
 705         bytes_read = _dbus_string_get_length (&socket_transport->encoded_incoming);
 706       else
 707         bytes_read = _dbus_read_socket (socket_transport->fd,
 708                                         &socket_transport->encoded_incoming,
 709                                         socket_transport->max_bytes_read_per_iteration);
 710
 711       _dbus_assert (_dbus_string_get_length (&socket_transport->encoded_incoming) ==
 712                     bytes_read);
 713
 714       if (bytes_read > 0)
 715         {
 716           int orig_len;
 717
 718           _dbus_message_loader_get_buffer (transport->loader,
 719                                            &buffer);
 720
 721           orig_len = _dbus_string_get_length (buffer);
 722
 723           if (!_dbus_auth_decode_data (transport->auth,
 724                                        &socket_transport->encoded_incoming,
 725                                        buffer))
 726             {
 727               _dbus_verbose ("Out of memory decoding incoming data\n");
 728               oom = TRUE;
 729               goto out;
 730             }
 731
 732           _dbus_message_loader_return_buffer (transport->loader,
 733                                               buffer,
 734                                               _dbus_string_get_length (buffer) - orig_len);
 735
 736           _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
 737           _dbus_string_compact (&socket_transport->encoded_incoming, 2048);
 738         }
 739     }
 740   else
 741     {
 742       _dbus_message_loader_get_buffer (transport->loader,
 743                                        &buffer);
 744
 745       bytes_read = _dbus_read_socket (socket_transport->fd,
 746                                       buffer, socket_transport->max_bytes_read_per_iteration);
 747
 748       _dbus_message_loader_return_buffer (transport->loader,
 749                                           buffer,
 750                                           bytes_read < 0 ? 0 : bytes_read);
 751     }
 752
 753   if (bytes_read < 0)
 754     {
 755       /* EINTR already handled for us */
 756
 757       if (_dbus_get_is_errno_enomem ())
 758         {
 759           _dbus_verbose ("Out of memory in read()/do_reading()\n");
 760           oom = TRUE;
 761           goto out;
 762         }
 763       else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 764         goto out;
 765       else
 766         {
 767           _dbus_verbose ("Error reading from remote app: %s\n",
 768                          _dbus_strerror_from_errno ());
 769           do_io_error (transport);
 770           goto out;
 771         }
 772     }
 773   else if (bytes_read == 0)
 774     {
 775       _dbus_verbose ("Disconnected from remote app\n");
 776       do_io_error (transport);
 777       goto out;
 778     }
 779   else
 780     {
 781       _dbus_verbose (" read %d bytes\n", bytes_read);
 782
 783       total += bytes_read;
 784
 785       if (!_dbus_transport_queue_messages (transport))
 786         {
 787           oom = TRUE;
 788           _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
 789           goto out;
 790         }
 791
 792       /* Try reading more data until we get EAGAIN and return, or
 793        * exceed max bytes per iteration.  If in blocking mode of
 794        * course we'll block instead of returning.
 795        */
 796       goto again;
 797     }
 798
 799  out:
 800   if (oom)
 801     return FALSE;
 802   else
 803     return TRUE;
 804 }
 805
 806 static dbus_bool_t
 807 socket_handle_watch (DBusTransport *transport,
 808                    DBusWatch     *watch,
 809                    unsigned int   flags)
 810 {
 811   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 812
 813   _dbus_assert (watch == socket_transport->read_watch ||
 814                 watch == socket_transport->write_watch);
 815   _dbus_assert (watch != NULL);
 816
 817   /* Disconnect in case of an error.  In case of hangup do not
 818    * disconnect the transport because data can still be in the buffer
 819    * and do_reading may need several iteration to read it all (because
 820    * of its max_bytes_read_per_iteration limit).  The condition where
 821    * flags == HANGUP (without READABLE) probably never happen in fact.
 822    */
 823   if ((flags & DBUS_WATCH_ERROR) ||
 824       ((flags & DBUS_WATCH_HANGUP) && !(flags & DBUS_WATCH_READABLE)))
 825     {
 826       _dbus_verbose ("Hang up or error on watch\n");
 827       _dbus_transport_disconnect (transport);
 828       return TRUE;
 829     }
 830
 831   if (watch == socket_transport->read_watch &&
 832       (flags & DBUS_WATCH_READABLE))
 833     {
 834       dbus_bool_t auth_finished;
 835 #if 1
 836       _dbus_verbose ("handling read watch %p flags = %x\n",
 837                      watch, flags);
 838 #endif
 839       if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
 840         return FALSE;
 841
 842       /* We don't want to do a read immediately following
 843        * a successful authentication.  This is so we
 844        * have a chance to propagate the authentication
 845        * state further up.  Specifically, we need to
 846        * process any pending data from the auth object.
 847        */
 848       if (!auth_finished)
 849         {
 850           if (!do_reading (transport))
 851             {
 852               _dbus_verbose ("no memory to read\n");
 853               return FALSE;
 854             }
 855         }
 856       else
 857         {
 858           _dbus_verbose ("Not reading anything since we just completed the authentication\n");
 859         }
 860     }
 861   else if (watch == socket_transport->write_watch &&
 862            (flags & DBUS_WATCH_WRITABLE))
 863     {
 864 #if 1
 865       _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
 866                      _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 867 #endif
 868       if (!do_authentication (transport, FALSE, TRUE, NULL))
 869         return FALSE;
 870
 871       if (!do_writing (transport))
 872         {
 873           _dbus_verbose ("no memory to write\n");
 874           return FALSE;
 875         }
 876
 877       /* See if we still need the write watch */
 878       check_write_watch (transport);
 879     }
 880 #ifdef DBUS_ENABLE_VERBOSE_MODE
 881   else
 882     {
 883       if (watch == socket_transport->read_watch)
 884         _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
 885                        flags);
 886       else if (watch == socket_transport->write_watch)
 887         _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
 888                        flags);
 889       else
 890         _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
 891                        watch, dbus_watch_get_socket (watch));
 892     }
 893 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 894
 895   return TRUE;
 896 }
 897
 898 static void
 899 socket_disconnect (DBusTransport *transport)
 900 {
 901   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 902
 903   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 904
 905   free_watches (transport);
 906
 907   _dbus_close_socket (socket_transport->fd, NULL);
 908   socket_transport->fd = -1;
 909 }
 910
 911 static dbus_bool_t
 912 socket_connection_set (DBusTransport *transport)
 913 {
 914   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 915
 916   _dbus_watch_set_handler (socket_transport->write_watch,
 917                            _dbus_connection_handle_watch,
 918                            transport->connection, NULL);
 919
 920   _dbus_watch_set_handler (socket_transport->read_watch,
 921                            _dbus_connection_handle_watch,
 922                            transport->connection, NULL);
 923
 924   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 925                                             socket_transport->write_watch))
 926     return FALSE;
 927
 928   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 929                                             socket_transport->read_watch))
 930     {
 931       _dbus_connection_remove_watch_unlocked (transport->connection,
 932                                               socket_transport->write_watch);
 933       return FALSE;
 934     }
 935
 936   check_read_watch (transport);
 937   check_write_watch (transport);
 938
 939   return TRUE;
 940 }
 941
 942 /**
 943  * @todo We need to have a way to wake up the select sleep if
 944  * a new iteration request comes in with a flag (read/write) that
 945  * we're not currently serving. Otherwise a call that just reads
 946  * could block a write call forever (if there are no incoming
 947  * messages).
 948  */
 949 static  void
 950 socket_do_iteration (DBusTransport *transport,
 951                    unsigned int   flags,
 952                    int            timeout_milliseconds)
 953 {
 954   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 955   DBusPollFD poll_fd;
 956   int poll_res;
 957   int poll_timeout;
 958
 959   _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
 960                  flags & DBUS_ITERATION_DO_READING ? "read" : "",
 961                  flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
 962                  timeout_milliseconds,
 963                  socket_transport->read_watch,
 964                  socket_transport->write_watch,
 965                  socket_transport->fd);
 966
 967   /* the passed in DO_READING/DO_WRITING flags indicate whether to
 968    * read/write messages, but regardless of those we may need to block
 969    * for reading/writing to do auth.  But if we do reading for auth,
 970    * we don't want to read any messages yet if not given DO_READING.
 971    */
 972
 973   poll_fd.fd = socket_transport->fd;
 974   poll_fd.events = 0;
 975
 976   if (_dbus_transport_get_is_authenticated (transport))
 977     {
 978       /* This is kind of a hack; if we have stuff to write, then try
 979        * to avoid the poll. This is probably about a 5% speedup on an
 980        * echo client/server.
 981        *
 982        * If both reading and writing were requested, we want to avoid this
 983        * since it could have funky effects:
 984        *   - both ends spinning waiting for the other one to read
 985        *     data so they can finish writing
 986        *   - prioritizing all writing ahead of reading
 987        */
 988       if ((flags & DBUS_ITERATION_DO_WRITING) &&
 989           !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
 990           !transport->disconnected &&
 991           _dbus_connection_has_messages_to_send_unlocked (transport->connection))
 992         {
 993           do_writing (transport);
 994
 995           if (transport->disconnected ||
 996               !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
 997             goto out;
 998         }
 999
1000       /* If we get here, we decided to do the poll() after all */
1001       _dbus_assert (socket_transport->read_watch);
1002       if (flags & DBUS_ITERATION_DO_READING)
1003         poll_fd.events |= _DBUS_POLLIN;
1004
1005       _dbus_assert (socket_transport->write_watch);
1006       if (flags & DBUS_ITERATION_DO_WRITING)
1007         poll_fd.events |= _DBUS_POLLOUT;
1008     }
1009   else
1010     {
1011       DBusAuthState auth_state;
1012
1013       auth_state = _dbus_auth_do_work (transport->auth);
1014
1015       if (transport->receive_credentials_pending ||
1016           auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1017         poll_fd.events |= _DBUS_POLLIN;
1018
1019       if (transport->send_credentials_pending ||
1020           auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1021         poll_fd.events |= _DBUS_POLLOUT;
1022     }
1023
1024   if (poll_fd.events)
1025     {
1026       if (flags & DBUS_ITERATION_BLOCK)
1027         poll_timeout = timeout_milliseconds;
1028       else
1029         poll_timeout = 0;
1030
1031       /* For blocking selects we drop the connection lock here
1032        * to avoid blocking out connection access during a potentially
1033        * indefinite blocking call. The io path is still protected
1034        * by the io_path_cond condvar, so we won't reenter this.
1035        */
1036       if (flags & DBUS_ITERATION_BLOCK)
1037         {
1038           _dbus_verbose ("unlock %s pre poll\n", _DBUS_FUNCTION_NAME);
1039           _dbus_connection_unlock (transport->connection);
1040         }
1041
1042     again:
1043       poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1044
1045       if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1046         goto again;
1047
1048       if (flags & DBUS_ITERATION_BLOCK)
1049         {
1050           _dbus_verbose ("lock %s post poll\n", _DBUS_FUNCTION_NAME);
1051           _dbus_connection_lock (transport->connection);
1052         }
1053
1054       if (poll_res >= 0)
1055         {
1056           if (poll_res == 0)
1057             poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1058                                   * valgrind flags it as an error. though it probably
1059                                   * is guaranteed on linux at least.
1060                                   */
1061
1062           if (poll_fd.revents & _DBUS_POLLERR)
1063             do_io_error (transport);
1064           else
1065             {
1066               dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1067               dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1068               dbus_bool_t authentication_completed;
1069
1070               _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1071                              need_read, need_write);
1072               do_authentication (transport, need_read, need_write,
1073                                  &authentication_completed);
1074
1075               /* See comment in socket_handle_watch. */
1076               if (authentication_completed)
1077                 goto out;
1078
1079               if (need_read && (flags & DBUS_ITERATION_DO_READING))
1080                 do_reading (transport);
1081               if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1082                 do_writing (transport);
1083             }
1084         }
1085       else
1086         {
1087           _dbus_verbose ("Error from _dbus_poll(): %s\n",
1088                          _dbus_strerror_from_errno ());
1089         }
1090     }
1091
1092
1093  out:
1094   /* We need to install the write watch only if we did not
1095    * successfully write everything. Note we need to be careful that we
1096    * don't call check_write_watch *before* do_writing, since it's
1097    * inefficient to add the write watch, and we can avoid it most of
1098    * the time since we can write immediately.
1099    *
1100    * However, we MUST always call check_write_watch(); DBusConnection code
1101    * relies on the fact that running an iteration will notice that
1102    * messages are pending.
1103    */
1104   check_write_watch (transport);
1105
1106   _dbus_verbose (" ... leaving do_iteration()\n");
1107 }
1108
1109 static void
1110 socket_live_messages_changed (DBusTransport *transport)
1111 {
1112   /* See if we should look for incoming messages again */
1113   check_read_watch (transport);
1114 }
1115
1116
1117 static dbus_bool_t
1118 socket_get_socket_fd (DBusTransport *transport,
1119                       int           *fd_p)
1120 {
1121   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1122
1123   *fd_p = socket_transport->fd;
1124
1125   return TRUE;
1126 }
1127
1128 static const DBusTransportVTable socket_vtable = {
1129   socket_finalize,
1130   socket_handle_watch,
1131   socket_disconnect,
1132   socket_connection_set,
1133   socket_do_iteration,
1134   socket_live_messages_changed,
1135   socket_get_socket_fd
1136 };
1137
1138 /**
1139  * Creates a new transport for the given socket file descriptor.  The file
1140  * descriptor must be nonblocking (use _dbus_set_fd_nonblocking() to
1141  * make it so). This function is shared by various transports that
1142  * boil down to a full duplex file descriptor.
1143  *
1144  * @param fd the file descriptor.
1145  * @param server_guid non-#NULL if this transport is on the server side of a connection
1146  * @param address the transport's address
1147  * @returns the new transport, or #NULL if no memory.
1148  */
1149 DBusTransport*
1150 _dbus_transport_new_for_socket (int               fd,
1151                                 const DBusString *server_guid,
1152                                 const DBusString *address)
1153 {
1154   DBusTransportSocket *socket_transport;
1155
1156   socket_transport = dbus_new0 (DBusTransportSocket, 1);
1157   if (socket_transport == NULL)
1158     return NULL;
1159
1160   if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1161     goto failed_0;
1162
1163   if (!_dbus_string_init (&socket_transport->encoded_incoming))
1164     goto failed_1;
1165
1166   socket_transport->write_watch = _dbus_watch_new (fd,
1167                                                  DBUS_WATCH_WRITABLE,
1168                                                  FALSE,
1169                                                  NULL, NULL, NULL);
1170   if (socket_transport->write_watch == NULL)
1171     goto failed_2;
1172
1173   socket_transport->read_watch = _dbus_watch_new (fd,
1174                                                 DBUS_WATCH_READABLE,
1175                                                 FALSE,
1176                                                 NULL, NULL, NULL);
1177   if (socket_transport->read_watch == NULL)
1178     goto failed_3;
1179
1180   if (!_dbus_transport_init_base (&socket_transport->base,
1181                                   &socket_vtable,
1182                                   server_guid, address))
1183     goto failed_4;
1184
1185   socket_transport->fd = fd;
1186   socket_transport->message_bytes_written = 0;
1187
1188   /* These values should probably be tunable or something. */
1189   socket_transport->max_bytes_read_per_iteration = 2048;
1190   socket_transport->max_bytes_written_per_iteration = 2048;
1191
1192   return (DBusTransport*) socket_transport;
1193
1194  failed_4:
1195   _dbus_watch_unref (socket_transport->read_watch);
1196  failed_3:
1197   _dbus_watch_unref (socket_transport->write_watch);
1198  failed_2:
1199   _dbus_string_free (&socket_transport->encoded_incoming);
1200  failed_1:
1201   _dbus_string_free (&socket_transport->encoded_outgoing);
1202  failed_0:
1203   dbus_free (socket_transport);
1204   return NULL;
1205 }
1206
1207 /**
1208  * Creates a new transport for the given hostname and port.
1209  * If host is NULL, it will default to localhost
1210  *
1211  * @param host the host to connect to
1212  * @param port the port to connect to
1213  * @param family the address family to connect to
1214  * @param error location to store reason for failure.
1215  * @returns a new transport, or #NULL on failure.
1216  */
1217 DBusTransport*
1218 _dbus_transport_new_for_tcp_socket (const char     *host,
1219                                     const char     *port,
1220                                     const char     *family,
1221                                     DBusError      *error)
1222 {
1223   int fd;
1224   DBusTransport *transport;
1225   DBusString address;
1226
1227   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1228
1229   if (!_dbus_string_init (&address))
1230     {
1231       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1232       return NULL;
1233     }
1234
1235   if (host == NULL)
1236     host = "localhost";
1237
1238   if (!_dbus_string_append (&address, "tcp:"))
1239     goto error;
1240
1241   if (!_dbus_string_append (&address, "host=") ||
1242       !_dbus_string_append (&address, host))
1243     goto error;
1244
1245   if (!_dbus_string_append (&address, ",port=") ||
1246       !_dbus_string_append (&address, port))
1247     goto error;
1248
1249   if (family != NULL &&
1250       (!_dbus_string_append (&address, "family=") ||
1251        !_dbus_string_append (&address, family)))
1252     goto error;
1253
1254   fd = _dbus_connect_tcp_socket (host, port, family, error);
1255   if (fd < 0)
1256     {
1257       _DBUS_ASSERT_ERROR_IS_SET (error);
1258       _dbus_string_free (&address);
1259       return NULL;
1260     }
1261
1262   _dbus_fd_set_close_on_exec (fd);
1263
1264   _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1265                  host, port);
1266
1267   transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1268   if (transport == NULL)
1269     {
1270       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1271       _dbus_close_socket (fd, NULL);
1272       _dbus_string_free (&address);
1273       fd = -1;
1274     }
1275
1276   _dbus_string_free (&address);
1277
1278   return transport;
1279
1280 error:
1281   _dbus_string_free (&address);
1282   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1283   return NULL;
1284 }
1285
1286 /**
1287  * Opens a TCP socket transport.
1288  *
1289  * @param entry the address entry to try opening as a tcp transport.
1290  * @param transport_p return location for the opened transport
1291  * @param error error to be set
1292  * @returns result of the attempt
1293  */
1294 DBusTransportOpenResult
1295 _dbus_transport_open_socket(DBusAddressEntry  *entry,
1296                             DBusTransport    **transport_p,
1297                             DBusError         *error)
1298 {
1299   const char *method;
1300
1301   method = dbus_address_entry_get_method (entry);
1302   _dbus_assert (method != NULL);
1303
1304   if (strcmp (method, "tcp") == 0)
1305     {
1306       const char *host = dbus_address_entry_get_value (entry, "host");
1307       const char *port = dbus_address_entry_get_value (entry, "port");
1308       const char *family = dbus_address_entry_get_value (entry, "family");
1309
1310       if (port == NULL)
1311         {
1312           _dbus_set_bad_address (error, "tcp", "port", NULL);
1313           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1314         }
1315
1316       *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, error);
1317       if (*transport_p == NULL)
1318         {
1319           _DBUS_ASSERT_ERROR_IS_SET (error);
1320           return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1321         }
1322       else
1323         {
1324           _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1325           return DBUS_TRANSPORT_OPEN_OK;
1326         }
1327     }
1328   else
1329     {
1330       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1331       return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
1332     }
1333 }
1334
1335 /** @} */
1336