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