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
 646               _dbus_connection_message_sent (transport->connection,
 647                                              message);
 648             }
 649         }
 650     }
 651
 652  out:
 653   if (oom)
 654     return FALSE;
 655   else
 656     return TRUE;
 657 }
 658
 659 /* returns false on out-of-memory */
 660 static dbus_bool_t
 661 do_reading (DBusTransport *transport)
 662 {
 663   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 664   DBusString *buffer;
 665   int bytes_read;
 666   int total;
 667   dbus_bool_t oom;
 668
 669   _dbus_verbose ("%s: fd = %d\n", _DBUS_FUNCTION_NAME,
 670                  socket_transport->fd);
 671
 672   /* No messages without authentication! */
 673   if (!_dbus_transport_get_is_authenticated (transport))
 674     return TRUE;
 675
 676   oom = FALSE;
 677
 678   total = 0;
 679
 680  again:
 681
 682   /* See if we've exceeded max messages and need to disable reading */
 683   check_read_watch (transport);
 684
 685   if (total > socket_transport->max_bytes_read_per_iteration)
 686     {
 687       _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
 688                      total, socket_transport->max_bytes_read_per_iteration);
 689       goto out;
 690     }
 691
 692   _dbus_assert (socket_transport->read_watch != NULL ||
 693                 transport->disconnected);
 694
 695   if (transport->disconnected)
 696     goto out;
 697
 698   if (!dbus_watch_get_enabled (socket_transport->read_watch))
 699     return TRUE;
 700
 701   if (_dbus_auth_needs_decoding (transport->auth))
 702     {
 703       if (_dbus_string_get_length (&socket_transport->encoded_incoming) > 0)
 704         bytes_read = _dbus_string_get_length (&socket_transport->encoded_incoming);
 705       else
 706         bytes_read = _dbus_read_socket (socket_transport->fd,
 707                                         &socket_transport->encoded_incoming,
 708                                         socket_transport->max_bytes_read_per_iteration);
 709
 710       _dbus_assert (_dbus_string_get_length (&socket_transport->encoded_incoming) ==
 711                     bytes_read);
 712
 713       if (bytes_read > 0)
 714         {
 715           int orig_len;
 716
 717           _dbus_message_loader_get_buffer (transport->loader,
 718                                            &buffer);
 719
 720           orig_len = _dbus_string_get_length (buffer);
 721
 722           if (!_dbus_auth_decode_data (transport->auth,
 723                                        &socket_transport->encoded_incoming,
 724                                        buffer))
 725             {
 726               _dbus_verbose ("Out of memory decoding incoming data\n");
 727               oom = TRUE;
 728               goto out;
 729             }
 730
 731           _dbus_message_loader_return_buffer (transport->loader,
 732                                               buffer,
 733                                               _dbus_string_get_length (buffer) - orig_len);
 734
 735           _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
 736         }
 737     }
 738   else
 739     {
 740       _dbus_message_loader_get_buffer (transport->loader,
 741                                        &buffer);
 742
 743       bytes_read = _dbus_read_socket (socket_transport->fd,
 744                                       buffer, socket_transport->max_bytes_read_per_iteration);
 745
 746       _dbus_message_loader_return_buffer (transport->loader,
 747                                           buffer,
 748                                           bytes_read < 0 ? 0 : bytes_read);
 749     }
 750
 751   if (bytes_read < 0)
 752     {
 753       /* EINTR already handled for us */
 754
 755       if (_dbus_get_is_errno_enomem ())
 756         {
 757           _dbus_verbose ("Out of memory in read()/do_reading()\n");
 758           oom = TRUE;
 759           goto out;
 760         }
 761       else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 762         goto out;
 763       else
 764         {
 765           _dbus_verbose ("Error reading from remote app: %s\n",
 766                          _dbus_strerror_from_errno ());
 767           do_io_error (transport);
 768           goto out;
 769         }
 770     }
 771   else if (bytes_read == 0)
 772     {
 773       _dbus_verbose ("Disconnected from remote app\n");
 774       do_io_error (transport);
 775       goto out;
 776     }
 777   else
 778     {
 779       _dbus_verbose (" read %d bytes\n", bytes_read);
 780
 781       total += bytes_read;
 782
 783       if (!_dbus_transport_queue_messages (transport))
 784         {
 785           oom = TRUE;
 786           _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
 787           goto out;
 788         }
 789
 790       /* Try reading more data until we get EAGAIN and return, or
 791        * exceed max bytes per iteration.  If in blocking mode of
 792        * course we'll block instead of returning.
 793        */
 794       goto again;
 795     }
 796
 797  out:
 798   if (oom)
 799     return FALSE;
 800   else
 801     return TRUE;
 802 }
 803
 804 static dbus_bool_t
 805 socket_handle_watch (DBusTransport *transport,
 806                    DBusWatch     *watch,
 807                    unsigned int   flags)
 808 {
 809   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 810
 811   _dbus_assert (watch == socket_transport->read_watch ||
 812                 watch == socket_transport->write_watch);
 813   _dbus_assert (watch != NULL);
 814
 815   /* Disconnect in case of an error.  In case of hangup do not
 816    * disconnect the transport because data can still be in the buffer
 817    * and do_reading may need several iteration to read it all (because
 818    * of its max_bytes_read_per_iteration limit).  The condition where
 819    * flags == HANGUP (without READABLE) probably never happen in fact.
 820    */
 821   if ((flags & DBUS_WATCH_ERROR) ||
 822       ((flags & DBUS_WATCH_HANGUP) && !(flags & DBUS_WATCH_READABLE)))
 823     {
 824       _dbus_verbose ("Hang up or error on watch\n");
 825       _dbus_transport_disconnect (transport);
 826       return TRUE;
 827     }
 828
 829   if (watch == socket_transport->read_watch &&
 830       (flags & DBUS_WATCH_READABLE))
 831     {
 832       dbus_bool_t auth_finished;
 833 #if 1
 834       _dbus_verbose ("handling read watch %p flags = %x\n",
 835                      watch, flags);
 836 #endif
 837       if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
 838         return FALSE;
 839
 840       /* We don't want to do a read immediately following
 841        * a successful authentication.  This is so we
 842        * have a chance to propagate the authentication
 843        * state further up.  Specifically, we need to
 844        * process any pending data from the auth object.
 845        */
 846       if (!auth_finished)
 847         {
 848           if (!do_reading (transport))
 849             {
 850               _dbus_verbose ("no memory to read\n");
 851               return FALSE;
 852             }
 853         }
 854       else
 855         {
 856           _dbus_verbose ("Not reading anything since we just completed the authentication\n");
 857         }
 858     }
 859   else if (watch == socket_transport->write_watch &&
 860            (flags & DBUS_WATCH_WRITABLE))
 861     {
 862 #if 1
 863       _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
 864                      _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 865 #endif
 866       if (!do_authentication (transport, FALSE, TRUE, NULL))
 867         return FALSE;
 868
 869       if (!do_writing (transport))
 870         {
 871           _dbus_verbose ("no memory to write\n");
 872           return FALSE;
 873         }
 874
 875       /* See if we still need the write watch */
 876       check_write_watch (transport);
 877     }
 878 #ifdef DBUS_ENABLE_VERBOSE_MODE
 879   else
 880     {
 881       if (watch == socket_transport->read_watch)
 882         _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
 883                        flags);
 884       else if (watch == socket_transport->write_watch)
 885         _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
 886                        flags);
 887       else
 888         _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
 889                        watch, dbus_watch_get_socket (watch));
 890     }
 891 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 892
 893   return TRUE;
 894 }
 895
 896 static void
 897 socket_disconnect (DBusTransport *transport)
 898 {
 899   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 900
 901   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 902
 903   free_watches (transport);
 904
 905   _dbus_close_socket (socket_transport->fd, NULL);
 906   socket_transport->fd = -1;
 907 }
 908
 909 static dbus_bool_t
 910 socket_connection_set (DBusTransport *transport)
 911 {
 912   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 913
 914   _dbus_watch_set_handler (socket_transport->write_watch,
 915                            _dbus_connection_handle_watch,
 916                            transport->connection, NULL);
 917
 918   _dbus_watch_set_handler (socket_transport->read_watch,
 919                            _dbus_connection_handle_watch,
 920                            transport->connection, NULL);
 921
 922   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 923                                             socket_transport->write_watch))
 924     return FALSE;
 925
 926   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 927                                             socket_transport->read_watch))
 928     {
 929       _dbus_connection_remove_watch_unlocked (transport->connection,
 930                                               socket_transport->write_watch);
 931       return FALSE;
 932     }
 933
 934   check_read_watch (transport);
 935   check_write_watch (transport);
 936
 937   return TRUE;
 938 }
 939
 940 /**
 941  * @todo We need to have a way to wake up the select sleep if
 942  * a new iteration request comes in with a flag (read/write) that
 943  * we're not currently serving. Otherwise a call that just reads
 944  * could block a write call forever (if there are no incoming
 945  * messages).
 946  */
 947 static  void
 948 socket_do_iteration (DBusTransport *transport,
 949                    unsigned int   flags,
 950                    int            timeout_milliseconds)
 951 {
 952   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 953   DBusPollFD poll_fd;
 954   int poll_res;
 955   int poll_timeout;
 956
 957   _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
 958                  flags & DBUS_ITERATION_DO_READING ? "read" : "",
 959                  flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
 960                  timeout_milliseconds,
 961                  socket_transport->read_watch,
 962                  socket_transport->write_watch,
 963                  socket_transport->fd);
 964
 965   /* the passed in DO_READING/DO_WRITING flags indicate whether to
 966    * read/write messages, but regardless of those we may need to block
 967    * for reading/writing to do auth.  But if we do reading for auth,
 968    * we don't want to read any messages yet if not given DO_READING.
 969    */
 970
 971   poll_fd.fd = socket_transport->fd;
 972   poll_fd.events = 0;
 973
 974   if (_dbus_transport_get_is_authenticated (transport))
 975     {
 976       /* This is kind of a hack; if we have stuff to write, then try
 977        * to avoid the poll. This is probably about a 5% speedup on an
 978        * echo client/server.
 979        *
 980        * If both reading and writing were requested, we want to avoid this
 981        * since it could have funky effects:
 982        *   - both ends spinning waiting for the other one to read
 983        *     data so they can finish writing
 984        *   - prioritizing all writing ahead of reading
 985        */
 986       if ((flags & DBUS_ITERATION_DO_WRITING) &&
 987           !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
 988           !transport->disconnected &&
 989           _dbus_connection_has_messages_to_send_unlocked (transport->connection))
 990         {
 991           do_writing (transport);
 992
 993           if (transport->disconnected ||
 994               !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
 995             goto out;
 996         }
 997
 998       /* If we get here, we decided to do the poll() after all */
 999       _dbus_assert (socket_transport->read_watch);
1000       if (flags & DBUS_ITERATION_DO_READING)
1001         poll_fd.events |= _DBUS_POLLIN;
1002
1003       _dbus_assert (socket_transport->write_watch);
1004       if (flags & DBUS_ITERATION_DO_WRITING)
1005         poll_fd.events |= _DBUS_POLLOUT;
1006     }
1007   else
1008     {
1009       DBusAuthState auth_state;
1010
1011       auth_state = _dbus_auth_do_work (transport->auth);
1012
1013       if (transport->receive_credentials_pending ||
1014           auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1015         poll_fd.events |= _DBUS_POLLIN;
1016
1017       if (transport->send_credentials_pending ||
1018           auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1019         poll_fd.events |= _DBUS_POLLOUT;
1020     }
1021
1022   if (poll_fd.events)
1023     {
1024       if (flags & DBUS_ITERATION_BLOCK)
1025         poll_timeout = timeout_milliseconds;
1026       else
1027         poll_timeout = 0;
1028
1029       /* For blocking selects we drop the connection lock here
1030        * to avoid blocking out connection access during a potentially
1031        * indefinite blocking call. The io path is still protected
1032        * by the io_path_cond condvar, so we won't reenter this.
1033        */
1034       if (flags & DBUS_ITERATION_BLOCK)
1035         {
1036           _dbus_verbose ("unlock %s pre poll\n", _DBUS_FUNCTION_NAME);
1037           _dbus_connection_unlock (transport->connection);
1038         }
1039
1040     again:
1041       poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1042
1043       if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1044         goto again;
1045
1046       if (flags & DBUS_ITERATION_BLOCK)
1047         {
1048           _dbus_verbose ("lock %s post poll\n", _DBUS_FUNCTION_NAME);
1049           _dbus_connection_lock (transport->connection);
1050         }
1051
1052       if (poll_res >= 0)
1053         {
1054           if (poll_res == 0)
1055             poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1056                                   * valgrind flags it as an error. though it probably
1057                                   * is guaranteed on linux at least.
1058                                   */
1059
1060           if (poll_fd.revents & _DBUS_POLLERR)
1061             do_io_error (transport);
1062           else
1063             {
1064               dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1065               dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1066               dbus_bool_t authentication_completed;
1067
1068               _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1069                              need_read, need_write);
1070               do_authentication (transport, need_read, need_write,
1071                                  &authentication_completed);
1072
1073               /* See comment in socket_handle_watch. */
1074               if (authentication_completed)
1075                 goto out;
1076
1077               if (need_read && (flags & DBUS_ITERATION_DO_READING))
1078                 do_reading (transport);
1079               if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1080                 do_writing (transport);
1081             }
1082         }
1083       else
1084         {
1085           _dbus_verbose ("Error from _dbus_poll(): %s\n",
1086                          _dbus_strerror_from_errno ());
1087         }
1088     }
1089
1090
1091  out:
1092   /* We need to install the write watch only if we did not
1093    * successfully write everything. Note we need to be careful that we
1094    * don't call check_write_watch *before* do_writing, since it's
1095    * inefficient to add the write watch, and we can avoid it most of
1096    * the time since we can write immediately.
1097    *
1098    * However, we MUST always call check_write_watch(); DBusConnection code
1099    * relies on the fact that running an iteration will notice that
1100    * messages are pending.
1101    */
1102   check_write_watch (transport);
1103
1104   _dbus_verbose (" ... leaving do_iteration()\n");
1105 }
1106
1107 static void
1108 socket_live_messages_changed (DBusTransport *transport)
1109 {
1110   /* See if we should look for incoming messages again */
1111   check_read_watch (transport);
1112 }
1113
1114
1115 static dbus_bool_t
1116 socket_get_socket_fd (DBusTransport *transport,
1117                       int           *fd_p)
1118 {
1119   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1120
1121   *fd_p = socket_transport->fd;
1122
1123   return TRUE;
1124 }
1125
1126 static const DBusTransportVTable socket_vtable = {
1127   socket_finalize,
1128   socket_handle_watch,
1129   socket_disconnect,
1130   socket_connection_set,
1131   socket_do_iteration,
1132   socket_live_messages_changed,
1133   socket_get_socket_fd
1134 };
1135
1136 /**
1137  * Creates a new transport for the given socket file descriptor.  The file
1138  * descriptor must be nonblocking (use _dbus_set_fd_nonblocking() to
1139  * make it so). This function is shared by various transports that
1140  * boil down to a full duplex file descriptor.
1141  *
1142  * @param fd the file descriptor.
1143  * @param server_guid non-#NULL if this transport is on the server side of a connection
1144  * @param address the transport's address
1145  * @returns the new transport, or #NULL if no memory.
1146  */
1147 DBusTransport*
1148 _dbus_transport_new_for_socket (int               fd,
1149                                 const DBusString *server_guid,
1150                                 const DBusString *address)
1151 {
1152   DBusTransportSocket *socket_transport;
1153
1154   socket_transport = dbus_new0 (DBusTransportSocket, 1);
1155   if (socket_transport == NULL)
1156     return NULL;
1157
1158   if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1159     goto failed_0;
1160
1161   if (!_dbus_string_init (&socket_transport->encoded_incoming))
1162     goto failed_1;
1163
1164   socket_transport->write_watch = _dbus_watch_new (fd,
1165                                                  DBUS_WATCH_WRITABLE,
1166                                                  FALSE,
1167                                                  NULL, NULL, NULL);
1168   if (socket_transport->write_watch == NULL)
1169     goto failed_2;
1170
1171   socket_transport->read_watch = _dbus_watch_new (fd,
1172                                                 DBUS_WATCH_READABLE,
1173                                                 FALSE,
1174                                                 NULL, NULL, NULL);
1175   if (socket_transport->read_watch == NULL)
1176     goto failed_3;
1177
1178   if (!_dbus_transport_init_base (&socket_transport->base,
1179                                   &socket_vtable,
1180                                   server_guid, address))
1181     goto failed_4;
1182
1183   socket_transport->fd = fd;
1184   socket_transport->message_bytes_written = 0;
1185
1186   /* These values should probably be tunable or something. */
1187   socket_transport->max_bytes_read_per_iteration = 2048;
1188   socket_transport->max_bytes_written_per_iteration = 2048;
1189
1190   return (DBusTransport*) socket_transport;
1191
1192  failed_4:
1193   _dbus_watch_unref (socket_transport->read_watch);
1194  failed_3:
1195   _dbus_watch_unref (socket_transport->write_watch);
1196  failed_2:
1197   _dbus_string_free (&socket_transport->encoded_incoming);
1198  failed_1:
1199   _dbus_string_free (&socket_transport->encoded_outgoing);
1200  failed_0:
1201   dbus_free (socket_transport);
1202   return NULL;
1203 }
1204
1205 /**
1206  * Creates a new transport for the given hostname and port.
1207  * If host is NULL, it will default to localhost
1208  *
1209  * @param host the host to connect to
1210  * @param port the port to connect to
1211  * @param family the address family to connect to
1212  * @param error location to store reason for failure.
1213  * @returns a new transport, or #NULL on failure.
1214  */
1215 DBusTransport*
1216 _dbus_transport_new_for_tcp_socket (const char     *host,
1217                                     const char     *port,
1218                                     const char     *family,
1219                                     DBusError      *error)
1220 {
1221   int fd;
1222   DBusTransport *transport;
1223   DBusString address;
1224
1225   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1226
1227   if (!_dbus_string_init (&address))
1228     {
1229       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1230       return NULL;
1231     }
1232
1233   if (host == NULL)
1234     host = "localhost";
1235
1236   if (!_dbus_string_append (&address, "tcp:"))
1237     goto error;
1238
1239   if (!_dbus_string_append (&address, "host=") ||
1240       !_dbus_string_append (&address, host))
1241     goto error;
1242
1243   if (!_dbus_string_append (&address, ",port=") ||
1244       !_dbus_string_append (&address, port))
1245     goto error;
1246
1247   if (family != NULL &&
1248       (!_dbus_string_append (&address, "family=") ||
1249        !_dbus_string_append (&address, family)))
1250     goto error;
1251
1252   fd = _dbus_connect_tcp_socket (host, port, family, error);
1253   if (fd < 0)
1254     {
1255       _DBUS_ASSERT_ERROR_IS_SET (error);
1256       _dbus_string_free (&address);
1257       return NULL;
1258     }
1259
1260   _dbus_fd_set_close_on_exec (fd);
1261
1262   _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1263                  host, port);
1264
1265   transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1266   if (transport == NULL)
1267     {
1268       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1269       _dbus_close_socket (fd, NULL);
1270       _dbus_string_free (&address);
1271       fd = -1;
1272     }
1273
1274   _dbus_string_free (&address);
1275
1276   return transport;
1277
1278 error:
1279   _dbus_string_free (&address);
1280   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1281   return NULL;
1282 }
1283
1284 /**
1285  * Opens a TCP socket transport.
1286  *
1287  * @param entry the address entry to try opening as a tcp transport.
1288  * @param transport_p return location for the opened transport
1289  * @param error error to be set
1290  * @returns result of the attempt
1291  */
1292 DBusTransportOpenResult
1293 _dbus_transport_open_socket(DBusAddressEntry  *entry,
1294                             DBusTransport    **transport_p,
1295                             DBusError         *error)
1296 {
1297   const char *method;
1298
1299   method = dbus_address_entry_get_method (entry);
1300   _dbus_assert (method != NULL);
1301
1302   if (strcmp (method, "tcp") == 0)
1303     {
1304       const char *host = dbus_address_entry_get_value (entry, "host");
1305       const char *port = dbus_address_entry_get_value (entry, "port");
1306       const char *family = dbus_address_entry_get_value (entry, "family");
1307
1308       if (port == NULL)
1309         {
1310           _dbus_set_bad_address (error, "tcp", "port", NULL);
1311           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1312         }
1313
1314       *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, error);
1315       if (*transport_p == NULL)
1316         {
1317           _DBUS_ASSERT_ERROR_IS_SET (error);
1318           return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1319         }
1320       else
1321         {
1322           _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1323           return DBUS_TRANSPORT_OPEN_OK;
1324         }
1325     }
1326   else
1327     {
1328       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1329       return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
1330     }
1331 }
1332
1333 /** @} */
1334