vcs.maemo.org Git - monky/blob - src/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 = DBUS_ERROR_INIT;
 342
 343   _dbus_verbose ("exchange_credentials: do_reading = %d, do_writing = %d\n",
 344                   do_reading, do_writing);
 345
 346   if (do_writing && transport->send_credentials_pending)
 347     {
 348       if (_dbus_send_credentials_socket (socket_transport->fd,
 349                                          &error))
 350         {
 351           transport->send_credentials_pending = FALSE;
 352         }
 353       else
 354         {
 355           _dbus_verbose ("Failed to write credentials: %s\n", error.message);
 356           dbus_error_free (&error);
 357           do_io_error (transport);
 358         }
 359     }
 360
 361   if (do_reading && transport->receive_credentials_pending)
 362     {
 363       /* FIXME this can fail due to IO error _or_ OOM, broken
 364        * (somewhat tricky to fix since the OOM error can be set after
 365        * we already read the credentials byte, so basically we need to
 366        * separate reading the byte and storing it in the
 367        * transport->credentials). Does not really matter for now
 368        * because storing in credentials never actually fails on unix.
 369        */
 370       if (_dbus_read_credentials_socket (socket_transport->fd,
 371                                          transport->credentials,
 372                                          &error))
 373         {
 374           transport->receive_credentials_pending = FALSE;
 375         }
 376       else
 377         {
 378           _dbus_verbose ("Failed to read credentials %s\n", error.message);
 379           dbus_error_free (&error);
 380           do_io_error (transport);
 381         }
 382     }
 383
 384   if (!(transport->send_credentials_pending ||
 385         transport->receive_credentials_pending))
 386     {
 387       if (!_dbus_auth_set_credentials (transport->auth,
 388                                        transport->credentials))
 389         return FALSE;
 390     }
 391
 392   return TRUE;
 393 }
 394
 395 static dbus_bool_t
 396 do_authentication (DBusTransport *transport,
 397                    dbus_bool_t    do_reading,
 398                    dbus_bool_t    do_writing,
 399                    dbus_bool_t   *auth_completed)
 400 {
 401   dbus_bool_t oom;
 402   dbus_bool_t orig_auth_state;
 403
 404   oom = FALSE;
 405
 406   orig_auth_state = _dbus_transport_get_is_authenticated (transport);
 407
 408   /* This is essential to avoid the check_write_watch() at the end,
 409    * we don't want to add a write watch in do_iteration before
 410    * we try writing and get EAGAIN
 411    */
 412   if (orig_auth_state)
 413     {
 414       if (auth_completed)
 415         *auth_completed = FALSE;
 416       return TRUE;
 417     }
 418
 419   _dbus_transport_ref (transport);
 420
 421   while (!_dbus_transport_get_is_authenticated (transport) &&
 422          _dbus_transport_get_is_connected (transport))
 423     {
 424       if (!exchange_credentials (transport, do_reading, do_writing))
 425         {
 426           /* OOM */
 427           oom = TRUE;
 428           goto out;
 429         }
 430
 431       if (transport->send_credentials_pending ||
 432           transport->receive_credentials_pending)
 433         {
 434           _dbus_verbose ("send_credentials_pending = %d receive_credentials_pending = %d\n",
 435                          transport->send_credentials_pending,
 436                          transport->receive_credentials_pending);
 437           goto out;
 438         }
 439
 440 #define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")
 441       switch (_dbus_auth_do_work (transport->auth))
 442         {
 443         case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
 444           _dbus_verbose (" %s auth state: waiting for input\n",
 445                          TRANSPORT_SIDE (transport));
 446           if (!do_reading || !read_data_into_auth (transport, &oom))
 447             goto out;
 448           break;
 449
 450         case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
 451           _dbus_verbose (" %s auth state: waiting for memory\n",
 452                          TRANSPORT_SIDE (transport));
 453           oom = TRUE;
 454           goto out;
 455           break;
 456
 457         case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
 458           _dbus_verbose (" %s auth state: bytes to send\n",
 459                          TRANSPORT_SIDE (transport));
 460           if (!do_writing || !write_data_from_auth (transport))
 461             goto out;
 462           break;
 463
 464         case DBUS_AUTH_STATE_NEED_DISCONNECT:
 465           _dbus_verbose (" %s auth state: need to disconnect\n",
 466                          TRANSPORT_SIDE (transport));
 467           do_io_error (transport);
 468           break;
 469
 470         case DBUS_AUTH_STATE_AUTHENTICATED:
 471           _dbus_verbose (" %s auth state: authenticated\n",
 472                          TRANSPORT_SIDE (transport));
 473           break;
 474         }
 475     }
 476
 477  out:
 478   if (auth_completed)
 479     *auth_completed = (orig_auth_state != _dbus_transport_get_is_authenticated (transport));
 480
 481   check_read_watch (transport);
 482   check_write_watch (transport);
 483   _dbus_transport_unref (transport);
 484
 485   if (oom)
 486     return FALSE;
 487   else
 488     return TRUE;
 489 }
 490
 491 /* returns false on oom */
 492 static dbus_bool_t
 493 do_writing (DBusTransport *transport)
 494 {
 495   int total;
 496   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 497   dbus_bool_t oom;
 498
 499   /* No messages without authentication! */
 500   if (!_dbus_transport_get_is_authenticated (transport))
 501     {
 502       _dbus_verbose ("Not authenticated, not writing anything\n");
 503       return TRUE;
 504     }
 505
 506   if (transport->disconnected)
 507     {
 508       _dbus_verbose ("Not connected, not writing anything\n");
 509       return TRUE;
 510     }
 511
 512 #if 1
 513   _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",
 514                  _dbus_connection_has_messages_to_send_unlocked (transport->connection),
 515                  socket_transport->fd);
 516 #endif
 517
 518   oom = FALSE;
 519   total = 0;
 520
 521   while (!transport->disconnected &&
 522          _dbus_connection_has_messages_to_send_unlocked (transport->connection))
 523     {
 524       int bytes_written;
 525       DBusMessage *message;
 526       const DBusString *header;
 527       const DBusString *body;
 528       int header_len, body_len;
 529       int total_bytes_to_write;
 530
 531       if (total > socket_transport->max_bytes_written_per_iteration)
 532         {
 533           _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",
 534                          total, socket_transport->max_bytes_written_per_iteration);
 535           goto out;
 536         }
 537
 538       message = _dbus_connection_get_message_to_send (transport->connection);
 539       _dbus_assert (message != NULL);
 540       dbus_message_lock (message);
 541
 542 #if 0
 543       _dbus_verbose ("writing message %p\n", message);
 544 #endif
 545
 546       _dbus_message_get_network_data (message,
 547                                       &header, &body);
 548
 549       header_len = _dbus_string_get_length (header);
 550       body_len = _dbus_string_get_length (body);
 551
 552       if (_dbus_auth_needs_encoding (transport->auth))
 553         {
 554           if (_dbus_string_get_length (&socket_transport->encoded_outgoing) == 0)
 555             {
 556               if (!_dbus_auth_encode_data (transport->auth,
 557                                            header, &socket_transport->encoded_outgoing))
 558                 {
 559                   oom = TRUE;
 560                   goto out;
 561                 }
 562
 563               if (!_dbus_auth_encode_data (transport->auth,
 564                                            body, &socket_transport->encoded_outgoing))
 565                 {
 566                   _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 567                   oom = TRUE;
 568                   goto out;
 569                 }
 570             }
 571
 572           total_bytes_to_write = _dbus_string_get_length (&socket_transport->encoded_outgoing);
 573
 574 #if 0
 575           _dbus_verbose ("encoded message is %d bytes\n",
 576                          total_bytes_to_write);
 577 #endif
 578
 579           bytes_written =
 580             _dbus_write_socket (socket_transport->fd,
 581                                 &socket_transport->encoded_outgoing,
 582                                 socket_transport->message_bytes_written,
 583                                 total_bytes_to_write - socket_transport->message_bytes_written);
 584         }
 585       else
 586         {
 587           total_bytes_to_write = header_len + body_len;
 588
 589 #if 0
 590           _dbus_verbose ("message is %d bytes\n",
 591                          total_bytes_to_write);
 592 #endif
 593
 594           if (socket_transport->message_bytes_written < header_len)
 595             {
 596               bytes_written =
 597                 _dbus_write_socket_two (socket_transport->fd,
 598                                         header,
 599                                         socket_transport->message_bytes_written,
 600                                         header_len - socket_transport->message_bytes_written,
 601                                         body,
 602                                         0, body_len);
 603             }
 604           else
 605             {
 606               bytes_written =
 607                 _dbus_write_socket (socket_transport->fd,
 608                                     body,
 609                                     (socket_transport->message_bytes_written - header_len),
 610                                     body_len -
 611                                     (socket_transport->message_bytes_written - header_len));
 612             }
 613         }
 614
 615       if (bytes_written < 0)
 616         {
 617           /* EINTR already handled for us */
 618
 619           if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 620             goto out;
 621           else
 622             {
 623               _dbus_verbose ("Error writing to remote app: %s\n",
 624                              _dbus_strerror_from_errno ());
 625               do_io_error (transport);
 626               goto out;
 627             }
 628         }
 629       else
 630         {
 631           _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
 632                          total_bytes_to_write);
 633
 634           total += bytes_written;
 635           socket_transport->message_bytes_written += bytes_written;
 636
 637           _dbus_assert (socket_transport->message_bytes_written <=
 638                         total_bytes_to_write);
 639
 640           if (socket_transport->message_bytes_written == total_bytes_to_write)
 641             {
 642               socket_transport->message_bytes_written = 0;
 643               _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 644               _dbus_string_compact (&socket_transport->encoded_outgoing, 2048);
 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               _dbus_message_loader_return_buffer (transport->loader,
 728                                               buffer,
 729                                               _dbus_string_get_length (buffer) - orig_len);
 730
 731               oom = TRUE;
 732               goto out;
 733             }
 734
 735           _dbus_message_loader_return_buffer (transport->loader,
 736                                               buffer,
 737                                               _dbus_string_get_length (buffer) - orig_len);
 738
 739           _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
 740           _dbus_string_compact (&socket_transport->encoded_incoming, 2048);
 741         }
 742     }
 743   else
 744     {
 745       _dbus_message_loader_get_buffer (transport->loader,
 746                                        &buffer);
 747
 748       bytes_read = _dbus_read_socket (socket_transport->fd,
 749                                       buffer, socket_transport->max_bytes_read_per_iteration);
 750
 751       _dbus_message_loader_return_buffer (transport->loader,
 752                                           buffer,
 753                                           bytes_read < 0 ? 0 : bytes_read);
 754     }
 755
 756   if (bytes_read < 0)
 757     {
 758       /* EINTR already handled for us */
 759
 760       if (_dbus_get_is_errno_enomem ())
 761         {
 762           _dbus_verbose ("Out of memory in read()/do_reading()\n");
 763           oom = TRUE;
 764           goto out;
 765         }
 766       else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 767         goto out;
 768       else
 769         {
 770           _dbus_verbose ("Error reading from remote app: %s\n",
 771                          _dbus_strerror_from_errno ());
 772           do_io_error (transport);
 773           goto out;
 774         }
 775     }
 776   else if (bytes_read == 0)
 777     {
 778       _dbus_verbose ("Disconnected from remote app\n");
 779       do_io_error (transport);
 780       goto out;
 781     }
 782   else
 783     {
 784       _dbus_verbose (" read %d bytes\n", bytes_read);
 785
 786       total += bytes_read;
 787
 788       if (!_dbus_transport_queue_messages (transport))
 789         {
 790           oom = TRUE;
 791           _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
 792           goto out;
 793         }
 794
 795       /* Try reading more data until we get EAGAIN and return, or
 796        * exceed max bytes per iteration.  If in blocking mode of
 797        * course we'll block instead of returning.
 798        */
 799       goto again;
 800     }
 801
 802  out:
 803   if (oom)
 804     return FALSE;
 805   else
 806     return TRUE;
 807 }
 808
 809 static dbus_bool_t
 810 socket_handle_watch (DBusTransport *transport,
 811                    DBusWatch     *watch,
 812                    unsigned int   flags)
 813 {
 814   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 815
 816   _dbus_assert (watch == socket_transport->read_watch ||
 817                 watch == socket_transport->write_watch);
 818   _dbus_assert (watch != NULL);
 819
 820   /* Disconnect in case of an error.  In case of hangup do not
 821    * disconnect the transport because data can still be in the buffer
 822    * and do_reading may need several iteration to read it all (because
 823    * of its max_bytes_read_per_iteration limit).  The condition where
 824    * flags == HANGUP (without READABLE) probably never happen in fact.
 825    */
 826   if ((flags & DBUS_WATCH_ERROR) ||
 827       ((flags & DBUS_WATCH_HANGUP) && !(flags & DBUS_WATCH_READABLE)))
 828     {
 829       _dbus_verbose ("Hang up or error on watch\n");
 830       _dbus_transport_disconnect (transport);
 831       return TRUE;
 832     }
 833
 834   if (watch == socket_transport->read_watch &&
 835       (flags & DBUS_WATCH_READABLE))
 836     {
 837       dbus_bool_t auth_finished;
 838 #if 1
 839       _dbus_verbose ("handling read watch %p flags = %x\n",
 840                      watch, flags);
 841 #endif
 842       if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
 843         return FALSE;
 844
 845       /* We don't want to do a read immediately following
 846        * a successful authentication.  This is so we
 847        * have a chance to propagate the authentication
 848        * state further up.  Specifically, we need to
 849        * process any pending data from the auth object.
 850        */
 851       if (!auth_finished)
 852         {
 853           if (!do_reading (transport))
 854             {
 855               _dbus_verbose ("no memory to read\n");
 856               return FALSE;
 857             }
 858         }
 859       else
 860         {
 861           _dbus_verbose ("Not reading anything since we just completed the authentication\n");
 862         }
 863     }
 864   else if (watch == socket_transport->write_watch &&
 865            (flags & DBUS_WATCH_WRITABLE))
 866     {
 867 #if 1
 868       _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
 869                      _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 870 #endif
 871       if (!do_authentication (transport, FALSE, TRUE, NULL))
 872         return FALSE;
 873
 874       if (!do_writing (transport))
 875         {
 876           _dbus_verbose ("no memory to write\n");
 877           return FALSE;
 878         }
 879
 880       /* See if we still need the write watch */
 881       check_write_watch (transport);
 882     }
 883 #ifdef DBUS_ENABLE_VERBOSE_MODE
 884   else
 885     {
 886       if (watch == socket_transport->read_watch)
 887         _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
 888                        flags);
 889       else if (watch == socket_transport->write_watch)
 890         _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
 891                        flags);
 892       else
 893         _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
 894                        watch, dbus_watch_get_socket (watch));
 895     }
 896 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 897
 898   return TRUE;
 899 }
 900
 901 static void
 902 socket_disconnect (DBusTransport *transport)
 903 {
 904   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 905
 906   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 907
 908   free_watches (transport);
 909
 910   _dbus_close_socket (socket_transport->fd, NULL);
 911   socket_transport->fd = -1;
 912 }
 913
 914 static dbus_bool_t
 915 socket_connection_set (DBusTransport *transport)
 916 {
 917   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 918
 919   _dbus_watch_set_handler (socket_transport->write_watch,
 920                            _dbus_connection_handle_watch,
 921                            transport->connection, NULL);
 922
 923   _dbus_watch_set_handler (socket_transport->read_watch,
 924                            _dbus_connection_handle_watch,
 925                            transport->connection, NULL);
 926
 927   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 928                                             socket_transport->write_watch))
 929     return FALSE;
 930
 931   if (!_dbus_connection_add_watch_unlocked (transport->connection,
 932                                             socket_transport->read_watch))
 933     {
 934       _dbus_connection_remove_watch_unlocked (transport->connection,
 935                                               socket_transport->write_watch);
 936       return FALSE;
 937     }
 938
 939   check_read_watch (transport);
 940   check_write_watch (transport);
 941
 942   return TRUE;
 943 }
 944
 945 /**
 946  * @todo We need to have a way to wake up the select sleep if
 947  * a new iteration request comes in with a flag (read/write) that
 948  * we're not currently serving. Otherwise a call that just reads
 949  * could block a write call forever (if there are no incoming
 950  * messages).
 951  */
 952 static  void
 953 socket_do_iteration (DBusTransport *transport,
 954                    unsigned int   flags,
 955                    int            timeout_milliseconds)
 956 {
 957   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 958   DBusPollFD poll_fd;
 959   int poll_res;
 960   int poll_timeout;
 961
 962   _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
 963                  flags & DBUS_ITERATION_DO_READING ? "read" : "",
 964                  flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
 965                  timeout_milliseconds,
 966                  socket_transport->read_watch,
 967                  socket_transport->write_watch,
 968                  socket_transport->fd);
 969
 970   /* the passed in DO_READING/DO_WRITING flags indicate whether to
 971    * read/write messages, but regardless of those we may need to block
 972    * for reading/writing to do auth.  But if we do reading for auth,
 973    * we don't want to read any messages yet if not given DO_READING.
 974    */
 975
 976   poll_fd.fd = socket_transport->fd;
 977   poll_fd.events = 0;
 978
 979   if (_dbus_transport_get_is_authenticated (transport))
 980     {
 981       /* This is kind of a hack; if we have stuff to write, then try
 982        * to avoid the poll. This is probably about a 5% speedup on an
 983        * echo client/server.
 984        *
 985        * If both reading and writing were requested, we want to avoid this
 986        * since it could have funky effects:
 987        *   - both ends spinning waiting for the other one to read
 988        *     data so they can finish writing
 989        *   - prioritizing all writing ahead of reading
 990        */
 991       if ((flags & DBUS_ITERATION_DO_WRITING) &&
 992           !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
 993           !transport->disconnected &&
 994           _dbus_connection_has_messages_to_send_unlocked (transport->connection))
 995         {
 996           do_writing (transport);
 997
 998           if (transport->disconnected ||
 999               !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
1000             goto out;
1001         }
1002
1003       /* If we get here, we decided to do the poll() after all */
1004       _dbus_assert (socket_transport->read_watch);
1005       if (flags & DBUS_ITERATION_DO_READING)
1006         poll_fd.events |= _DBUS_POLLIN;
1007
1008       _dbus_assert (socket_transport->write_watch);
1009       if (flags & DBUS_ITERATION_DO_WRITING)
1010         poll_fd.events |= _DBUS_POLLOUT;
1011     }
1012   else
1013     {
1014       DBusAuthState auth_state;
1015
1016       auth_state = _dbus_auth_do_work (transport->auth);
1017
1018       if (transport->receive_credentials_pending ||
1019           auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1020         poll_fd.events |= _DBUS_POLLIN;
1021
1022       if (transport->send_credentials_pending ||
1023           auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1024         poll_fd.events |= _DBUS_POLLOUT;
1025     }
1026
1027   if (poll_fd.events)
1028     {
1029       if (flags & DBUS_ITERATION_BLOCK)
1030         poll_timeout = timeout_milliseconds;
1031       else
1032         poll_timeout = 0;
1033
1034       /* For blocking selects we drop the connection lock here
1035        * to avoid blocking out connection access during a potentially
1036        * indefinite blocking call. The io path is still protected
1037        * by the io_path_cond condvar, so we won't reenter this.
1038        */
1039       if (flags & DBUS_ITERATION_BLOCK)
1040         {
1041           _dbus_verbose ("unlock %s pre poll\n", _DBUS_FUNCTION_NAME);
1042           _dbus_connection_unlock (transport->connection);
1043         }
1044
1045     again:
1046       poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1047
1048       if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1049         goto again;
1050
1051       if (flags & DBUS_ITERATION_BLOCK)
1052         {
1053           _dbus_verbose ("lock %s post poll\n", _DBUS_FUNCTION_NAME);
1054           _dbus_connection_lock (transport->connection);
1055         }
1056
1057       if (poll_res >= 0)
1058         {
1059           if (poll_res == 0)
1060             poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1061                                   * valgrind flags it as an error. though it probably
1062                                   * is guaranteed on linux at least.
1063                                   */
1064
1065           if (poll_fd.revents & _DBUS_POLLERR)
1066             do_io_error (transport);
1067           else
1068             {
1069               dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1070               dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1071               dbus_bool_t authentication_completed;
1072
1073               _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1074                              need_read, need_write);
1075               do_authentication (transport, need_read, need_write,
1076                                  &authentication_completed);
1077
1078               /* See comment in socket_handle_watch. */
1079               if (authentication_completed)
1080                 goto out;
1081
1082               if (need_read && (flags & DBUS_ITERATION_DO_READING))
1083                 do_reading (transport);
1084               if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1085                 do_writing (transport);
1086             }
1087         }
1088       else
1089         {
1090           _dbus_verbose ("Error from _dbus_poll(): %s\n",
1091                          _dbus_strerror_from_errno ());
1092         }
1093     }
1094
1095
1096  out:
1097   /* We need to install the write watch only if we did not
1098    * successfully write everything. Note we need to be careful that we
1099    * don't call check_write_watch *before* do_writing, since it's
1100    * inefficient to add the write watch, and we can avoid it most of
1101    * the time since we can write immediately.
1102    *
1103    * However, we MUST always call check_write_watch(); DBusConnection code
1104    * relies on the fact that running an iteration will notice that
1105    * messages are pending.
1106    */
1107   check_write_watch (transport);
1108
1109   _dbus_verbose (" ... leaving do_iteration()\n");
1110 }
1111
1112 static void
1113 socket_live_messages_changed (DBusTransport *transport)
1114 {
1115   /* See if we should look for incoming messages again */
1116   check_read_watch (transport);
1117 }
1118
1119
1120 static dbus_bool_t
1121 socket_get_socket_fd (DBusTransport *transport,
1122                       int           *fd_p)
1123 {
1124   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1125
1126   *fd_p = socket_transport->fd;
1127
1128   return TRUE;
1129 }
1130
1131 static const DBusTransportVTable socket_vtable = {
1132   socket_finalize,
1133   socket_handle_watch,
1134   socket_disconnect,
1135   socket_connection_set,
1136   socket_do_iteration,
1137   socket_live_messages_changed,
1138   socket_get_socket_fd
1139 };
1140
1141 /**
1142  * Creates a new transport for the given socket file descriptor.  The file
1143  * descriptor must be nonblocking (use _dbus_set_fd_nonblocking() to
1144  * make it so). This function is shared by various transports that
1145  * boil down to a full duplex file descriptor.
1146  *
1147  * @param fd the file descriptor.
1148  * @param server_guid non-#NULL if this transport is on the server side of a connection
1149  * @param address the transport's address
1150  * @returns the new transport, or #NULL if no memory.
1151  */
1152 DBusTransport*
1153 _dbus_transport_new_for_socket (int               fd,
1154                                 const DBusString *server_guid,
1155                                 const DBusString *address)
1156 {
1157   DBusTransportSocket *socket_transport;
1158
1159   socket_transport = dbus_new0 (DBusTransportSocket, 1);
1160   if (socket_transport == NULL)
1161     return NULL;
1162
1163   if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1164     goto failed_0;
1165
1166   if (!_dbus_string_init (&socket_transport->encoded_incoming))
1167     goto failed_1;
1168
1169   socket_transport->write_watch = _dbus_watch_new (fd,
1170                                                  DBUS_WATCH_WRITABLE,
1171                                                  FALSE,
1172                                                  NULL, NULL, NULL);
1173   if (socket_transport->write_watch == NULL)
1174     goto failed_2;
1175
1176   socket_transport->read_watch = _dbus_watch_new (fd,
1177                                                 DBUS_WATCH_READABLE,
1178                                                 FALSE,
1179                                                 NULL, NULL, NULL);
1180   if (socket_transport->read_watch == NULL)
1181     goto failed_3;
1182
1183   if (!_dbus_transport_init_base (&socket_transport->base,
1184                                   &socket_vtable,
1185                                   server_guid, address))
1186     goto failed_4;
1187
1188   socket_transport->fd = fd;
1189   socket_transport->message_bytes_written = 0;
1190
1191   /* These values should probably be tunable or something. */
1192   socket_transport->max_bytes_read_per_iteration = 2048;
1193   socket_transport->max_bytes_written_per_iteration = 2048;
1194
1195   return (DBusTransport*) socket_transport;
1196
1197  failed_4:
1198   _dbus_watch_unref (socket_transport->read_watch);
1199  failed_3:
1200   _dbus_watch_unref (socket_transport->write_watch);
1201  failed_2:
1202   _dbus_string_free (&socket_transport->encoded_incoming);
1203  failed_1:
1204   _dbus_string_free (&socket_transport->encoded_outgoing);
1205  failed_0:
1206   dbus_free (socket_transport);
1207   return NULL;
1208 }
1209
1210 /**
1211  * Creates a new transport for the given hostname and port.
1212  * If host is NULL, it will default to localhost
1213  *
1214  * @param host the host to connect to
1215  * @param port the port to connect to
1216  * @param family the address family to connect to
1217  * @param error location to store reason for failure.
1218  * @returns a new transport, or #NULL on failure.
1219  */
1220 DBusTransport*
1221 _dbus_transport_new_for_tcp_socket (const char     *host,
1222                                     const char     *port,
1223                                     const char     *family,
1224                                     DBusError      *error)
1225 {
1226   int fd;
1227   DBusTransport *transport;
1228   DBusString address;
1229
1230   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1231
1232   if (!_dbus_string_init (&address))
1233     {
1234       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1235       return NULL;
1236     }
1237
1238   if (host == NULL)
1239     host = "localhost";
1240
1241   if (!_dbus_string_append (&address, "tcp:"))
1242     goto error;
1243
1244   if (!_dbus_string_append (&address, "host=") ||
1245       !_dbus_string_append (&address, host))
1246     goto error;
1247
1248   if (!_dbus_string_append (&address, ",port=") ||
1249       !_dbus_string_append (&address, port))
1250     goto error;
1251
1252   if (family != NULL &&
1253       (!_dbus_string_append (&address, "family=") ||
1254        !_dbus_string_append (&address, family)))
1255     goto error;
1256
1257   fd = _dbus_connect_tcp_socket (host, port, family, error);
1258   if (fd < 0)
1259     {
1260       _DBUS_ASSERT_ERROR_IS_SET (error);
1261       _dbus_string_free (&address);
1262       return NULL;
1263     }
1264
1265   _dbus_fd_set_close_on_exec (fd);
1266
1267   _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1268                  host, port);
1269
1270   transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1271   if (transport == NULL)
1272     {
1273       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1274       _dbus_close_socket (fd, NULL);
1275       _dbus_string_free (&address);
1276       fd = -1;
1277     }
1278
1279   _dbus_string_free (&address);
1280
1281   return transport;
1282
1283 error:
1284   _dbus_string_free (&address);
1285   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1286   return NULL;
1287 }
1288
1289 /**
1290  * Opens a TCP socket transport.
1291  *
1292  * @param entry the address entry to try opening as a tcp transport.
1293  * @param transport_p return location for the opened transport
1294  * @param error error to be set
1295  * @returns result of the attempt
1296  */
1297 DBusTransportOpenResult
1298 _dbus_transport_open_socket(DBusAddressEntry  *entry,
1299                             DBusTransport    **transport_p,
1300                             DBusError         *error)
1301 {
1302   const char *method;
1303
1304   method = dbus_address_entry_get_method (entry);
1305   _dbus_assert (method != NULL);
1306
1307   if (strcmp (method, "tcp") == 0)
1308     {
1309       const char *host = dbus_address_entry_get_value (entry, "host");
1310       const char *port = dbus_address_entry_get_value (entry, "port");
1311       const char *family = dbus_address_entry_get_value (entry, "family");
1312
1313       if (port == NULL)
1314         {
1315           _dbus_set_bad_address (error, "tcp", "port", NULL);
1316           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1317         }
1318
1319       *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, error);
1320       if (*transport_p == NULL)
1321         {
1322           _DBUS_ASSERT_ERROR_IS_SET (error);
1323           return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1324         }
1325       else
1326         {
1327           _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1328           return DBUS_TRANSPORT_OPEN_OK;
1329         }
1330     }
1331   else
1332     {
1333       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1334       return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
1335     }
1336 }
1337
1338 /** @} */
1339