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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  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  * @defgroup DBusTransportSocket DBusTransport implementations for sockets
  33  * @ingroup  DBusInternals
  34  * @brief Implementation details of DBusTransport on sockets
  35  *
  36  * @{
  37  */
  38
  39 /**
  40  * Opaque object representing a socket file descriptor transport.
  41  */
  42 typedef struct DBusTransportSocket DBusTransportSocket;
  43
  44 /**
  45  * Implementation details of DBusTransportSocket. All members are private.
  46  */
  47 struct DBusTransportSocket
  48 {
  49   DBusTransport base;                   /**< Parent instance */
  50   int fd;                               /**< File descriptor. */
  51   DBusWatch *read_watch;                /**< Watch for readability. */
  52   DBusWatch *write_watch;               /**< Watch for writability. */
  53
  54   int max_bytes_read_per_iteration;     /**< To avoid blocking too long. */
  55   int max_bytes_written_per_iteration;  /**< To avoid blocking too long. */
  56
  57   int message_bytes_written;            /**< Number of bytes of current
  58                                          *   outgoing message that have
  59                                          *   been written.
  60                                          */
  61   DBusString encoded_outgoing;          /**< Encoded version of current
  62                                          *   outgoing message.
  63                                          */
  64   DBusString encoded_incoming;          /**< Encoded version of current
  65                                          *   incoming data.
  66                                          */
  67 };
  68
  69 static void
  70 free_watches (DBusTransport *transport)
  71 {
  72   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
  73
  74   _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME);
  75
  76   if (socket_transport->read_watch)
  77     {
  78       if (transport->connection)
  79         _dbus_connection_remove_watch_unlocked (transport->connection,
  80                                                 socket_transport->read_watch);
  81       _dbus_watch_invalidate (socket_transport->read_watch);
  82       _dbus_watch_unref (socket_transport->read_watch);
  83       socket_transport->read_watch = NULL;
  84     }
  85
  86   if (socket_transport->write_watch)
  87     {
  88       if (transport->connection)
  89         _dbus_connection_remove_watch_unlocked (transport->connection,
  90                                                 socket_transport->write_watch);
  91       _dbus_watch_invalidate (socket_transport->write_watch);
  92       _dbus_watch_unref (socket_transport->write_watch);
  93       socket_transport->write_watch = NULL;
  94     }
  95
  96   _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);
  97 }
  98
  99 static void
 100 socket_finalize (DBusTransport *transport)
 101 {
 102   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 103
 104   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 105
 106   free_watches (transport);
 107
 108   _dbus_string_free (&socket_transport->encoded_outgoing);
 109   _dbus_string_free (&socket_transport->encoded_incoming);
 110
 111   _dbus_transport_finalize_base (transport);
 112
 113   _dbus_assert (socket_transport->read_watch == NULL);
 114   _dbus_assert (socket_transport->write_watch == NULL);
 115
 116   dbus_free (transport);
 117 }
 118
 119 static void
 120 check_write_watch (DBusTransport *transport)
 121 {
 122   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 123   dbus_bool_t needed;
 124
 125   if (transport->connection == NULL)
 126     return;
 127
 128   if (transport->disconnected)
 129     {
 130       _dbus_assert (socket_transport->write_watch == NULL);
 131       return;
 132     }
 133
 134   _dbus_transport_ref (transport);
 135
 136   if (_dbus_transport_get_is_authenticated (transport))
 137     needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);
 138   else
 139     {
 140       if (transport->send_credentials_pending)
 141         needed = TRUE;
 142       else
 143         {
 144           DBusAuthState auth_state;
 145
 146           auth_state = _dbus_auth_do_work (transport->auth);
 147
 148           /* If we need memory we install the write watch just in case,
 149            * if there's no need for it, it will get de-installed
 150            * next time we try reading.
 151            */
 152           if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||
 153               auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
 154             needed = TRUE;
 155           else
 156             needed = FALSE;
 157         }
 158     }
 159
 160   _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",
 161                  needed, transport->connection, socket_transport->write_watch,
 162                  socket_transport->fd,
 163                  _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 164
 165   _dbus_connection_toggle_watch_unlocked (transport->connection,
 166                                           socket_transport->write_watch,
 167                                           needed);
 168
 169   _dbus_transport_unref (transport);
 170 }
 171
 172 static void
 173 check_read_watch (DBusTransport *transport)
 174 {
 175   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 176   dbus_bool_t need_read_watch;
 177
 178   _dbus_verbose ("%s: fd = %d\n",
 179                  _DBUS_FUNCTION_NAME, socket_transport->fd);
 180
 181   if (transport->connection == NULL)
 182     return;
 183
 184   if (transport->disconnected)
 185     {
 186       _dbus_assert (socket_transport->read_watch == NULL);
 187       return;
 188     }
 189
 190   _dbus_transport_ref (transport);
 191
 192   if (_dbus_transport_get_is_authenticated (transport))
 193     need_read_watch =
 194       (_dbus_counter_get_size_value (transport->live_messages) < transport->max_live_messages_size) &&
 195       (_dbus_counter_get_unix_fd_value (transport->live_messages) < transport->max_live_messages_unix_fds);
 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           /* Does fd passing even make sense with encoded data? */
 555           _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
 556
 557           if (_dbus_string_get_length (&socket_transport->encoded_outgoing) == 0)
 558             {
 559               if (!_dbus_auth_encode_data (transport->auth,
 560                                            header, &socket_transport->encoded_outgoing))
 561                 {
 562                   oom = TRUE;
 563                   goto out;
 564                 }
 565
 566               if (!_dbus_auth_encode_data (transport->auth,
 567                                            body, &socket_transport->encoded_outgoing))
 568                 {
 569                   _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 570                   oom = TRUE;
 571                   goto out;
 572                 }
 573             }
 574
 575           total_bytes_to_write = _dbus_string_get_length (&socket_transport->encoded_outgoing);
 576
 577 #if 0
 578           _dbus_verbose ("encoded message is %d bytes\n",
 579                          total_bytes_to_write);
 580 #endif
 581
 582           bytes_written =
 583             _dbus_write_socket (socket_transport->fd,
 584                                 &socket_transport->encoded_outgoing,
 585                                 socket_transport->message_bytes_written,
 586                                 total_bytes_to_write - socket_transport->message_bytes_written);
 587         }
 588       else
 589         {
 590           total_bytes_to_write = header_len + body_len;
 591
 592 #if 0
 593           _dbus_verbose ("message is %d bytes\n",
 594                          total_bytes_to_write);
 595 #endif
 596
 597 #ifdef HAVE_UNIX_FD_PASSING
 598           if (socket_transport->message_bytes_written <= 0 && DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
 599             {
 600               /* Send the fds along with the first byte of the message */
 601               const int *unix_fds;
 602               unsigned n;
 603
 604               _dbus_message_get_unix_fds(message, &unix_fds, &n);
 605
 606               bytes_written =
 607                 _dbus_write_socket_with_unix_fds_two (socket_transport->fd,
 608                                                       header,
 609                                                       socket_transport->message_bytes_written,
 610                                                       header_len - socket_transport->message_bytes_written,
 611                                                       body,
 612                                                       0, body_len,
 613                                                       unix_fds,
 614                                                       n);
 615
 616               if (bytes_written > 0 && n > 0)
 617                 _dbus_verbose("Wrote %i unix fds\n", n);
 618             }
 619           else
 620 #endif
 621             {
 622               if (socket_transport->message_bytes_written < header_len)
 623                 {
 624                   bytes_written =
 625                     _dbus_write_socket_two (socket_transport->fd,
 626                                             header,
 627                                             socket_transport->message_bytes_written,
 628                                             header_len - socket_transport->message_bytes_written,
 629                                             body,
 630                                             0, body_len);
 631                 }
 632               else
 633                 {
 634                   bytes_written =
 635                     _dbus_write_socket (socket_transport->fd,
 636                                         body,
 637                                         (socket_transport->message_bytes_written - header_len),
 638                                         body_len -
 639                                         (socket_transport->message_bytes_written - header_len));
 640                 }
 641             }
 642         }
 643
 644       if (bytes_written < 0)
 645         {
 646           /* EINTR already handled for us */
 647
 648           /* For some discussion of why we also ignore EPIPE here, see
 649            * http://lists.freedesktop.org/archives/dbus/2008-March/009526.html
 650            */
 651
 652           if (_dbus_get_is_errno_eagain_or_ewouldblock () || _dbus_get_is_errno_epipe ())
 653             goto out;
 654           else
 655             {
 656               _dbus_verbose ("Error writing to remote app: %s\n",
 657                              _dbus_strerror_from_errno ());
 658               do_io_error (transport);
 659               goto out;
 660             }
 661         }
 662       else
 663         {
 664           _dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
 665                          total_bytes_to_write);
 666
 667           total += bytes_written;
 668           socket_transport->message_bytes_written += bytes_written;
 669
 670           _dbus_assert (socket_transport->message_bytes_written <=
 671                         total_bytes_to_write);
 672
 673           if (socket_transport->message_bytes_written == total_bytes_to_write)
 674             {
 675               socket_transport->message_bytes_written = 0;
 676               _dbus_string_set_length (&socket_transport->encoded_outgoing, 0);
 677               _dbus_string_compact (&socket_transport->encoded_outgoing, 2048);
 678
 679               _dbus_connection_message_sent (transport->connection,
 680                                              message);
 681             }
 682         }
 683     }
 684
 685  out:
 686   if (oom)
 687     return FALSE;
 688   else
 689     return TRUE;
 690 }
 691
 692 /* returns false on out-of-memory */
 693 static dbus_bool_t
 694 do_reading (DBusTransport *transport)
 695 {
 696   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 697   DBusString *buffer;
 698   int bytes_read;
 699   int total;
 700   dbus_bool_t oom;
 701
 702   _dbus_verbose ("%s: fd = %d\n", _DBUS_FUNCTION_NAME,
 703                  socket_transport->fd);
 704
 705   /* No messages without authentication! */
 706   if (!_dbus_transport_get_is_authenticated (transport))
 707     return TRUE;
 708
 709   oom = FALSE;
 710
 711   total = 0;
 712
 713  again:
 714
 715   /* See if we've exceeded max messages and need to disable reading */
 716   check_read_watch (transport);
 717
 718   if (total > socket_transport->max_bytes_read_per_iteration)
 719     {
 720       _dbus_verbose ("%d bytes exceeds %d bytes read per iteration, returning\n",
 721                      total, socket_transport->max_bytes_read_per_iteration);
 722       goto out;
 723     }
 724
 725   _dbus_assert (socket_transport->read_watch != NULL ||
 726                 transport->disconnected);
 727
 728   if (transport->disconnected)
 729     goto out;
 730
 731   if (!dbus_watch_get_enabled (socket_transport->read_watch))
 732     return TRUE;
 733
 734   if (_dbus_auth_needs_decoding (transport->auth))
 735     {
 736       /* Does fd passing even make sense with encoded data? */
 737       _dbus_assert(!DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport));
 738
 739       if (_dbus_string_get_length (&socket_transport->encoded_incoming) > 0)
 740         bytes_read = _dbus_string_get_length (&socket_transport->encoded_incoming);
 741       else
 742         bytes_read = _dbus_read_socket (socket_transport->fd,
 743                                         &socket_transport->encoded_incoming,
 744                                         socket_transport->max_bytes_read_per_iteration);
 745
 746       _dbus_assert (_dbus_string_get_length (&socket_transport->encoded_incoming) ==
 747                     bytes_read);
 748
 749       if (bytes_read > 0)
 750         {
 751           int orig_len;
 752
 753           _dbus_message_loader_get_buffer (transport->loader,
 754                                            &buffer);
 755
 756           orig_len = _dbus_string_get_length (buffer);
 757
 758           if (!_dbus_auth_decode_data (transport->auth,
 759                                        &socket_transport->encoded_incoming,
 760                                        buffer))
 761             {
 762               _dbus_verbose ("Out of memory decoding incoming data\n");
 763               _dbus_message_loader_return_buffer (transport->loader,
 764                                               buffer,
 765                                               _dbus_string_get_length (buffer) - orig_len);
 766
 767               oom = TRUE;
 768               goto out;
 769             }
 770
 771           _dbus_message_loader_return_buffer (transport->loader,
 772                                               buffer,
 773                                               _dbus_string_get_length (buffer) - orig_len);
 774
 775           _dbus_string_set_length (&socket_transport->encoded_incoming, 0);
 776           _dbus_string_compact (&socket_transport->encoded_incoming, 2048);
 777         }
 778     }
 779   else
 780     {
 781       _dbus_message_loader_get_buffer (transport->loader,
 782                                        &buffer);
 783
 784 #ifdef HAVE_UNIX_FD_PASSING
 785       if (DBUS_TRANSPORT_CAN_SEND_UNIX_FD(transport))
 786         {
 787           int *fds, n_fds;
 788
 789           if (!_dbus_message_loader_get_unix_fds(transport->loader, &fds, &n_fds))
 790             {
 791               _dbus_verbose ("Out of memory reading file descriptors\n");
 792               _dbus_message_loader_return_buffer (transport->loader, buffer, 0);
 793               oom = TRUE;
 794               goto out;
 795             }
 796
 797           bytes_read = _dbus_read_socket_with_unix_fds(socket_transport->fd,
 798                                                        buffer,
 799                                                        socket_transport->max_bytes_read_per_iteration,
 800                                                        fds, &n_fds);
 801
 802           if (bytes_read >= 0 && n_fds > 0)
 803             _dbus_verbose("Read %i unix fds\n", n_fds);
 804
 805           _dbus_message_loader_return_unix_fds(transport->loader, fds, bytes_read < 0 ? 0 : n_fds);
 806         }
 807       else
 808 #endif
 809         {
 810           bytes_read = _dbus_read_socket (socket_transport->fd,
 811                                           buffer, socket_transport->max_bytes_read_per_iteration);
 812         }
 813
 814       _dbus_message_loader_return_buffer (transport->loader,
 815                                           buffer,
 816                                           bytes_read < 0 ? 0 : bytes_read);
 817     }
 818
 819   if (bytes_read < 0)
 820     {
 821       /* EINTR already handled for us */
 822
 823       if (_dbus_get_is_errno_enomem ())
 824         {
 825           _dbus_verbose ("Out of memory in read()/do_reading()\n");
 826           oom = TRUE;
 827           goto out;
 828         }
 829       else if (_dbus_get_is_errno_eagain_or_ewouldblock ())
 830         goto out;
 831       else
 832         {
 833           _dbus_verbose ("Error reading from remote app: %s\n",
 834                          _dbus_strerror_from_errno ());
 835           do_io_error (transport);
 836           goto out;
 837         }
 838     }
 839   else if (bytes_read == 0)
 840     {
 841       _dbus_verbose ("Disconnected from remote app\n");
 842       do_io_error (transport);
 843       goto out;
 844     }
 845   else
 846     {
 847       _dbus_verbose (" read %d bytes\n", bytes_read);
 848
 849       total += bytes_read;
 850
 851       if (!_dbus_transport_queue_messages (transport))
 852         {
 853           oom = TRUE;
 854           _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
 855           goto out;
 856         }
 857
 858       /* Try reading more data until we get EAGAIN and return, or
 859        * exceed max bytes per iteration.  If in blocking mode of
 860        * course we'll block instead of returning.
 861        */
 862       goto again;
 863     }
 864
 865  out:
 866   if (oom)
 867     return FALSE;
 868   else
 869     return TRUE;
 870 }
 871
 872 static dbus_bool_t
 873 unix_error_with_read_to_come (DBusTransport *itransport,
 874                               DBusWatch     *watch,
 875                               unsigned int   flags)
 876 {
 877   DBusTransportSocket *transport = (DBusTransportSocket *) itransport;
 878
 879   if (!(flags & DBUS_WATCH_HANGUP || flags & DBUS_WATCH_ERROR))
 880     return FALSE;
 881
 882   /* If we have a read watch enabled ...
 883      we -might have data incoming ... => handle the HANGUP there */
 884   if (watch != transport->read_watch &&
 885       _dbus_watch_get_enabled (transport->read_watch))
 886     return FALSE;
 887
 888   return TRUE;
 889 }
 890
 891 static dbus_bool_t
 892 socket_handle_watch (DBusTransport *transport,
 893                    DBusWatch     *watch,
 894                    unsigned int   flags)
 895 {
 896   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 897
 898   _dbus_assert (watch == socket_transport->read_watch ||
 899                 watch == socket_transport->write_watch);
 900   _dbus_assert (watch != NULL);
 901
 902   /* If we hit an error here on a write watch, don't disconnect the transport yet because data can
 903    * still be in the buffer and do_reading may need several iteration to read
 904    * it all (because of its max_bytes_read_per_iteration limit).
 905    */
 906   if (!(flags & DBUS_WATCH_READABLE) && unix_error_with_read_to_come (transport, watch, flags))
 907     {
 908       _dbus_verbose ("Hang up or error on watch\n");
 909       _dbus_transport_disconnect (transport);
 910       return TRUE;
 911     }
 912
 913   if (watch == socket_transport->read_watch &&
 914       (flags & DBUS_WATCH_READABLE))
 915     {
 916       dbus_bool_t auth_finished;
 917 #if 1
 918       _dbus_verbose ("handling read watch %p flags = %x\n",
 919                      watch, flags);
 920 #endif
 921       if (!do_authentication (transport, TRUE, FALSE, &auth_finished))
 922         return FALSE;
 923
 924       /* We don't want to do a read immediately following
 925        * a successful authentication.  This is so we
 926        * have a chance to propagate the authentication
 927        * state further up.  Specifically, we need to
 928        * process any pending data from the auth object.
 929        */
 930       if (!auth_finished)
 931         {
 932           if (!do_reading (transport))
 933             {
 934               _dbus_verbose ("no memory to read\n");
 935               return FALSE;
 936             }
 937         }
 938       else
 939         {
 940           _dbus_verbose ("Not reading anything since we just completed the authentication\n");
 941         }
 942     }
 943   else if (watch == socket_transport->write_watch &&
 944            (flags & DBUS_WATCH_WRITABLE))
 945     {
 946 #if 1
 947       _dbus_verbose ("handling write watch, have_outgoing_messages = %d\n",
 948                      _dbus_connection_has_messages_to_send_unlocked (transport->connection));
 949 #endif
 950       if (!do_authentication (transport, FALSE, TRUE, NULL))
 951         return FALSE;
 952
 953       if (!do_writing (transport))
 954         {
 955           _dbus_verbose ("no memory to write\n");
 956           return FALSE;
 957         }
 958
 959       /* See if we still need the write watch */
 960       check_write_watch (transport);
 961     }
 962 #ifdef DBUS_ENABLE_VERBOSE_MODE
 963   else
 964     {
 965       if (watch == socket_transport->read_watch)
 966         _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
 967                        flags);
 968       else if (watch == socket_transport->write_watch)
 969         _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
 970                        flags);
 971       else
 972         _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
 973                        watch, dbus_watch_get_socket (watch));
 974     }
 975 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 976
 977   return TRUE;
 978 }
 979
 980 static void
 981 socket_disconnect (DBusTransport *transport)
 982 {
 983   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 984
 985   _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
 986
 987   free_watches (transport);
 988
 989   _dbus_close_socket (socket_transport->fd, NULL);
 990   socket_transport->fd = -1;
 991 }
 992
 993 static dbus_bool_t
 994 socket_connection_set (DBusTransport *transport)
 995 {
 996   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
 997
 998   _dbus_watch_set_handler (socket_transport->write_watch,
 999                            _dbus_connection_handle_watch,
1000                            transport->connection, NULL);
1001
1002   _dbus_watch_set_handler (socket_transport->read_watch,
1003                            _dbus_connection_handle_watch,
1004                            transport->connection, NULL);
1005
1006   if (!_dbus_connection_add_watch_unlocked (transport->connection,
1007                                             socket_transport->write_watch))
1008     return FALSE;
1009
1010   if (!_dbus_connection_add_watch_unlocked (transport->connection,
1011                                             socket_transport->read_watch))
1012     {
1013       _dbus_connection_remove_watch_unlocked (transport->connection,
1014                                               socket_transport->write_watch);
1015       return FALSE;
1016     }
1017
1018   check_read_watch (transport);
1019   check_write_watch (transport);
1020
1021   return TRUE;
1022 }
1023
1024 /**
1025  * @todo We need to have a way to wake up the select sleep if
1026  * a new iteration request comes in with a flag (read/write) that
1027  * we're not currently serving. Otherwise a call that just reads
1028  * could block a write call forever (if there are no incoming
1029  * messages).
1030  */
1031 static  void
1032 socket_do_iteration (DBusTransport *transport,
1033                    unsigned int   flags,
1034                    int            timeout_milliseconds)
1035 {
1036   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1037   DBusPollFD poll_fd;
1038   int poll_res;
1039   int poll_timeout;
1040
1041   _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p fd = %d\n",
1042                  flags & DBUS_ITERATION_DO_READING ? "read" : "",
1043                  flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
1044                  timeout_milliseconds,
1045                  socket_transport->read_watch,
1046                  socket_transport->write_watch,
1047                  socket_transport->fd);
1048
1049   /* the passed in DO_READING/DO_WRITING flags indicate whether to
1050    * read/write messages, but regardless of those we may need to block
1051    * for reading/writing to do auth.  But if we do reading for auth,
1052    * we don't want to read any messages yet if not given DO_READING.
1053    */
1054
1055   poll_fd.fd = socket_transport->fd;
1056   poll_fd.events = 0;
1057
1058   if (_dbus_transport_get_is_authenticated (transport))
1059     {
1060       /* This is kind of a hack; if we have stuff to write, then try
1061        * to avoid the poll. This is probably about a 5% speedup on an
1062        * echo client/server.
1063        *
1064        * If both reading and writing were requested, we want to avoid this
1065        * since it could have funky effects:
1066        *   - both ends spinning waiting for the other one to read
1067        *     data so they can finish writing
1068        *   - prioritizing all writing ahead of reading
1069        */
1070       if ((flags & DBUS_ITERATION_DO_WRITING) &&
1071           !(flags & (DBUS_ITERATION_DO_READING | DBUS_ITERATION_BLOCK)) &&
1072           !transport->disconnected &&
1073           _dbus_connection_has_messages_to_send_unlocked (transport->connection))
1074         {
1075           do_writing (transport);
1076
1077           if (transport->disconnected ||
1078               !_dbus_connection_has_messages_to_send_unlocked (transport->connection))
1079             goto out;
1080         }
1081
1082       /* If we get here, we decided to do the poll() after all */
1083       _dbus_assert (socket_transport->read_watch);
1084       if (flags & DBUS_ITERATION_DO_READING)
1085         poll_fd.events |= _DBUS_POLLIN;
1086
1087       _dbus_assert (socket_transport->write_watch);
1088       if (flags & DBUS_ITERATION_DO_WRITING)
1089         poll_fd.events |= _DBUS_POLLOUT;
1090     }
1091   else
1092     {
1093       DBusAuthState auth_state;
1094
1095       auth_state = _dbus_auth_do_work (transport->auth);
1096
1097       if (transport->receive_credentials_pending ||
1098           auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
1099         poll_fd.events |= _DBUS_POLLIN;
1100
1101       if (transport->send_credentials_pending ||
1102           auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
1103         poll_fd.events |= _DBUS_POLLOUT;
1104     }
1105
1106   if (poll_fd.events)
1107     {
1108       if (flags & DBUS_ITERATION_BLOCK)
1109         poll_timeout = timeout_milliseconds;
1110       else
1111         poll_timeout = 0;
1112
1113       /* For blocking selects we drop the connection lock here
1114        * to avoid blocking out connection access during a potentially
1115        * indefinite blocking call. The io path is still protected
1116        * by the io_path_cond condvar, so we won't reenter this.
1117        */
1118       if (flags & DBUS_ITERATION_BLOCK)
1119         {
1120           _dbus_verbose ("unlock %s pre poll\n", _DBUS_FUNCTION_NAME);
1121           _dbus_connection_unlock (transport->connection);
1122         }
1123
1124     again:
1125       poll_res = _dbus_poll (&poll_fd, 1, poll_timeout);
1126
1127       if (poll_res < 0 && _dbus_get_is_errno_eintr ())
1128         goto again;
1129
1130       if (flags & DBUS_ITERATION_BLOCK)
1131         {
1132           _dbus_verbose ("lock %s post poll\n", _DBUS_FUNCTION_NAME);
1133           _dbus_connection_lock (transport->connection);
1134         }
1135
1136       if (poll_res >= 0)
1137         {
1138           if (poll_res == 0)
1139             poll_fd.revents = 0; /* some concern that posix does not guarantee this;
1140                                   * valgrind flags it as an error. though it probably
1141                                   * is guaranteed on linux at least.
1142                                   */
1143
1144           if (poll_fd.revents & _DBUS_POLLERR)
1145             do_io_error (transport);
1146           else
1147             {
1148               dbus_bool_t need_read = (poll_fd.revents & _DBUS_POLLIN) > 0;
1149               dbus_bool_t need_write = (poll_fd.revents & _DBUS_POLLOUT) > 0;
1150               dbus_bool_t authentication_completed;
1151
1152               _dbus_verbose ("in iteration, need_read=%d need_write=%d\n",
1153                              need_read, need_write);
1154               do_authentication (transport, need_read, need_write,
1155                                  &authentication_completed);
1156
1157               /* See comment in socket_handle_watch. */
1158               if (authentication_completed)
1159                 goto out;
1160
1161               if (need_read && (flags & DBUS_ITERATION_DO_READING))
1162                 do_reading (transport);
1163               if (need_write && (flags & DBUS_ITERATION_DO_WRITING))
1164                 do_writing (transport);
1165             }
1166         }
1167       else
1168         {
1169           _dbus_verbose ("Error from _dbus_poll(): %s\n",
1170                          _dbus_strerror_from_errno ());
1171         }
1172     }
1173
1174
1175  out:
1176   /* We need to install the write watch only if we did not
1177    * successfully write everything. Note we need to be careful that we
1178    * don't call check_write_watch *before* do_writing, since it's
1179    * inefficient to add the write watch, and we can avoid it most of
1180    * the time since we can write immediately.
1181    *
1182    * However, we MUST always call check_write_watch(); DBusConnection code
1183    * relies on the fact that running an iteration will notice that
1184    * messages are pending.
1185    */
1186   check_write_watch (transport);
1187
1188   _dbus_verbose (" ... leaving do_iteration()\n");
1189 }
1190
1191 static void
1192 socket_live_messages_changed (DBusTransport *transport)
1193 {
1194   /* See if we should look for incoming messages again */
1195   check_read_watch (transport);
1196 }
1197
1198
1199 static dbus_bool_t
1200 socket_get_socket_fd (DBusTransport *transport,
1201                       int           *fd_p)
1202 {
1203   DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
1204
1205   *fd_p = socket_transport->fd;
1206
1207   return TRUE;
1208 }
1209
1210 static const DBusTransportVTable socket_vtable = {
1211   socket_finalize,
1212   socket_handle_watch,
1213   socket_disconnect,
1214   socket_connection_set,
1215   socket_do_iteration,
1216   socket_live_messages_changed,
1217   socket_get_socket_fd
1218 };
1219
1220 /**
1221  * Creates a new transport for the given socket file descriptor.  The file
1222  * descriptor must be nonblocking (use _dbus_set_fd_nonblocking() to
1223  * make it so). This function is shared by various transports that
1224  * boil down to a full duplex file descriptor.
1225  *
1226  * @param fd the file descriptor.
1227  * @param server_guid non-#NULL if this transport is on the server side of a connection
1228  * @param address the transport's address
1229  * @returns the new transport, or #NULL if no memory.
1230  */
1231 DBusTransport*
1232 _dbus_transport_new_for_socket (int               fd,
1233                                 const DBusString *server_guid,
1234                                 const DBusString *address)
1235 {
1236   DBusTransportSocket *socket_transport;
1237
1238   socket_transport = dbus_new0 (DBusTransportSocket, 1);
1239   if (socket_transport == NULL)
1240     return NULL;
1241
1242   if (!_dbus_string_init (&socket_transport->encoded_outgoing))
1243     goto failed_0;
1244
1245   if (!_dbus_string_init (&socket_transport->encoded_incoming))
1246     goto failed_1;
1247
1248   socket_transport->write_watch = _dbus_watch_new (fd,
1249                                                  DBUS_WATCH_WRITABLE,
1250                                                  FALSE,
1251                                                  NULL, NULL, NULL);
1252   if (socket_transport->write_watch == NULL)
1253     goto failed_2;
1254
1255   socket_transport->read_watch = _dbus_watch_new (fd,
1256                                                 DBUS_WATCH_READABLE,
1257                                                 FALSE,
1258                                                 NULL, NULL, NULL);
1259   if (socket_transport->read_watch == NULL)
1260     goto failed_3;
1261
1262   if (!_dbus_transport_init_base (&socket_transport->base,
1263                                   &socket_vtable,
1264                                   server_guid, address))
1265     goto failed_4;
1266
1267 #ifdef HAVE_UNIX_FD_PASSING
1268   _dbus_auth_set_unix_fd_possible(socket_transport->base.auth, _dbus_socket_can_pass_unix_fd(fd));
1269 #endif
1270
1271   socket_transport->fd = fd;
1272   socket_transport->message_bytes_written = 0;
1273
1274   /* These values should probably be tunable or something. */
1275   socket_transport->max_bytes_read_per_iteration = 2048;
1276   socket_transport->max_bytes_written_per_iteration = 2048;
1277
1278   return (DBusTransport*) socket_transport;
1279
1280  failed_4:
1281   _dbus_watch_unref (socket_transport->read_watch);
1282  failed_3:
1283   _dbus_watch_unref (socket_transport->write_watch);
1284  failed_2:
1285   _dbus_string_free (&socket_transport->encoded_incoming);
1286  failed_1:
1287   _dbus_string_free (&socket_transport->encoded_outgoing);
1288  failed_0:
1289   dbus_free (socket_transport);
1290   return NULL;
1291 }
1292
1293 /**
1294  * Creates a new transport for the given hostname and port.
1295  * If host is NULL, it will default to localhost
1296  *
1297  * @param host the host to connect to
1298  * @param port the port to connect to
1299  * @param family the address family to connect to
1300  * @param path to nonce file
1301  * @param error location to store reason for failure.
1302  * @returns a new transport, or #NULL on failure.
1303  */
1304 DBusTransport*
1305 _dbus_transport_new_for_tcp_socket (const char     *host,
1306                                     const char     *port,
1307                                     const char     *family,
1308                                     const char     *noncefile,
1309                                     DBusError      *error)
1310 {
1311   int fd;
1312   DBusTransport *transport;
1313   DBusString address;
1314
1315   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1316
1317   if (!_dbus_string_init (&address))
1318     {
1319       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1320       return NULL;
1321     }
1322
1323   if (host == NULL)
1324     host = "localhost";
1325
1326   if (!_dbus_string_append (&address, noncefile ? "nonce-tcp:" : "tcp:"))
1327     goto error;
1328
1329   if (!_dbus_string_append (&address, "host=") ||
1330       !_dbus_string_append (&address, host))
1331     goto error;
1332
1333   if (!_dbus_string_append (&address, ",port=") ||
1334       !_dbus_string_append (&address, port))
1335     goto error;
1336
1337   if (family != NULL &&
1338       (!_dbus_string_append (&address, "family=") ||
1339        !_dbus_string_append (&address, family)))
1340     goto error;
1341
1342   if (noncefile != NULL &&
1343       (!_dbus_string_append (&address, "noncefile=") ||
1344        !_dbus_string_append (&address, noncefile)))
1345     goto error;
1346
1347   fd = _dbus_connect_tcp_socket_with_nonce (host, port, family, noncefile, error);
1348   if (fd < 0)
1349     {
1350       _DBUS_ASSERT_ERROR_IS_SET (error);
1351       _dbus_string_free (&address);
1352       return NULL;
1353     }
1354
1355   _dbus_verbose ("Successfully connected to tcp socket %s:%s\n",
1356                  host, port);
1357
1358   transport = _dbus_transport_new_for_socket (fd, NULL, &address);
1359   if (transport == NULL)
1360     {
1361       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1362       _dbus_close_socket (fd, NULL);
1363       _dbus_string_free (&address);
1364       fd = -1;
1365     }
1366
1367   _dbus_string_free (&address);
1368
1369   return transport;
1370
1371 error:
1372   _dbus_string_free (&address);
1373   dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1374   return NULL;
1375 }
1376
1377 /**
1378  * Opens a TCP socket transport.
1379  *
1380  * @param entry the address entry to try opening as a tcp transport.
1381  * @param transport_p return location for the opened transport
1382  * @param error error to be set
1383  * @returns result of the attempt
1384  */
1385 DBusTransportOpenResult
1386 _dbus_transport_open_socket(DBusAddressEntry  *entry,
1387                             DBusTransport    **transport_p,
1388                             DBusError         *error)
1389 {
1390   const char *method;
1391   dbus_bool_t isTcp;
1392   dbus_bool_t isNonceTcp;
1393
1394   method = dbus_address_entry_get_method (entry);
1395   _dbus_assert (method != NULL);
1396
1397   isTcp = strcmp (method, "tcp") == 0;
1398   isNonceTcp = strcmp (method, "nonce-tcp") == 0;
1399
1400   if (isTcp || isNonceTcp)
1401     {
1402       const char *host = dbus_address_entry_get_value (entry, "host");
1403       const char *port = dbus_address_entry_get_value (entry, "port");
1404       const char *family = dbus_address_entry_get_value (entry, "family");
1405       const char *noncefile = dbus_address_entry_get_value (entry, "noncefile");
1406
1407       if ((isNonceTcp == TRUE) != (noncefile != NULL)) {
1408           _dbus_set_bad_address (error, method, "noncefile", NULL);
1409           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1410       }
1411
1412       if (port == NULL)
1413         {
1414           _dbus_set_bad_address (error, method, "port", NULL);
1415           return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
1416         }
1417
1418       *transport_p = _dbus_transport_new_for_tcp_socket (host, port, family, noncefile, error);
1419       if (*transport_p == NULL)
1420         {
1421           //PENDING(kdab)
1422           //_DBUS_ASSERT_ERROR_IS_SET (error);
1423           return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
1424         }
1425       else
1426         {
1427           _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1428           return DBUS_TRANSPORT_OPEN_OK;
1429         }
1430     }
1431   else
1432     {
1433       _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1434       return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
1435     }
1436 }
1437
1438 /** @} */
1439