--- AnyEvent/lib/AnyEvent/Handle.pm	2009/08/01 09:14:54	1.170
+++ AnyEvent/lib/AnyEvent/Handle.pm	2009/08/11 01:15:17	1.178
@@ -1,20 +1,7 @@
-package AnyEvent::Handle;
-
-use Scalar::Util ();
-use Carp ();
-use Errno qw(EAGAIN EINTR);
-
-use AnyEvent (); BEGIN { AnyEvent::common_sense }
-use AnyEvent::Util qw(WSAEWOULDBLOCK);
-
 =head1 NAME
 
 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 
-=cut
-
-our $VERSION = 4.9;
-
 =head1 SYNOPSIS
 
    use AnyEvent;
@@ -61,6 +48,20 @@
 All callbacks will be invoked with the handle object as their first
 argument.
 
+=cut
+
+package AnyEvent::Handle;
+
+use Scalar::Util ();
+use List::Util ();
+use Carp ();
+use Errno qw(EAGAIN EINTR);
+
+use AnyEvent (); BEGIN { AnyEvent::common_sense }
+use AnyEvent::Util qw(WSAEWOULDBLOCK);
+
+our $VERSION = $AnyEvent::VERSION;
+
 =head1 METHODS
 
 =over 4
@@ -218,10 +219,21 @@
 
 =item timeout => $fractional_seconds
 
-If non-zero, then this enables an "inactivity" timeout: whenever this many
-seconds pass without a successful read or write on the underlying file
-handle, the C<on_timeout> callback will be invoked (and if that one is
-missing, a non-fatal C<ETIMEDOUT> error will be raised).
+=item rtimeout => $fractional_seconds
+
+=item wtimeout => $fractional_seconds
+
+If non-zero, then these enables an "inactivity" timeout: whenever this
+many seconds pass without a successful read or write on the underlying
+file handle (or a call to C<timeout_reset>), the C<on_timeout> callback
+will be invoked (and if that one is missing, a non-fatal C<ETIMEDOUT>
+error will be raised).
+
+There are three variants of the timeouts that work fully independent
+of each other, for both read and write, just read, and just write:
+C<timeout>, C<rtimeout> and C<wtimeout>, with corresponding callbacks
+C<on_timeout>, C<on_rtimeout> and C<on_wtimeout>, and reset functions
+C<timeout_reset>, C<rtimeout_reset>, and C<wtimeout_reset>.
 
 Note that timeout processing is also active when you currently do not have
 any outstanding read or write requests: If you plan to keep the connection
@@ -440,7 +452,7 @@
 
                      $self->{on_connect}
                         and $self->{on_connect}($self, $host, $port, sub {
-                               delete @$self{qw(fh _tw _ww _rw _eof _queue rbuf _wbuf tls _tls_rbuf _tls_wbuf)};
+                               delete @$self{qw(fh _tw _rtw _wtw _ww _rw _eof _queue rbuf _wbuf tls _tls_rbuf _tls_wbuf)};
                                $self->{_skip_drain_rbuf} = 1;
                                &$retry;
                             });
@@ -476,8 +488,13 @@
 
    AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
 
-   $self->{_activity} = AnyEvent->now;
-   $self->_timeout;
+   $self->{_activity}  =
+   $self->{_ractivity} =
+   $self->{_wactivity} = AE::now;
+
+   $self->timeout  (delete $self->{timeout} ) if $self->{timeout};
+   $self->rtimeout (delete $self->{rtimeout}) if $self->{rtimeout};
+   $self->wtimeout (delete $self->{wtimeout}) if $self->{wtimeout};
 
    $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
 
@@ -492,15 +509,6 @@
    $self->_drain_wbuf;
 }
 
-#sub _shutdown {
-#   my ($self) = @_;
-#
-#   delete @$self{qw(_tw _rw _ww fh wbuf on_read _queue)};
-#   $self->{_eof} = 1; # tell starttls et. al to stop trying
-#
-#   &_freetls;
-#}
-
 sub _error {
    my ($self, $errno, $fatal, $message) = @_;
 
@@ -546,15 +554,17 @@
 
 =item $handle->on_timeout ($cb)
 
-Replace the current C<on_timeout> callback, or disables the callback (but
-not the timeout) if C<$cb> = C<undef>. See the C<timeout> constructor
-argument and method.
+=item $handle->on_rtimeout ($cb)
+
+=item $handle->on_wtimeout ($cb)
+
+Replace the current C<on_timeout>, C<on_rtimeout> or C<on_wtimeout>
+callback, or disables the callback (but not the timeout) if C<$cb> =
+C<undef>. See the C<timeout> constructor argument and method.
 
 =cut
 
-sub on_timeout {
-   $_[0]{on_timeout} = $_[1];
-}
+# see below
 
 =item $handle->autocork ($boolean)
 
@@ -618,54 +628,85 @@
 
 =item $handle->timeout ($seconds)
 
+=item $handle->rtimeout ($seconds)
+
+=item $handle->wtimeout ($seconds)
+
 Configures (or disables) the inactivity timeout.
 
+=item $handle->timeout_reset
+
+=item $handle->rtimeout_reset
+
+=item $handle->wtimeout_reset
+
+Reset the activity timeout, as if data was received or sent.
+
+These methods are cheap to call.
+
 =cut
 
-sub timeout {
-   my ($self, $timeout) = @_;
+for my $dir ("", "r", "w") {
+   my $timeout    = "${dir}timeout";
+   my $tw         = "_${dir}tw";
+   my $on_timeout = "on_${dir}timeout";
+   my $activity   = "_${dir}activity";
+   my $cb;
 
-   $self->{timeout} = $timeout;
-   $self->_timeout;
-}
+   *$on_timeout = sub {
+      $_[0]{$on_timeout} = $_[1];
+   };
 
-# reset the timeout watcher, as neccessary
-# also check for time-outs
-sub _timeout {
-   my ($self) = @_;
+   *$timeout = sub {
+      my ($self, $new_value) = @_;
 
-   if ($self->{timeout} && $self->{fh}) {
-      my $NOW = AnyEvent->now;
+      $self->{$timeout} = $new_value;
+      delete $self->{$tw}; &$cb;
+   };
 
-      # when would the timeout trigger?
-      my $after = $self->{_activity} + $self->{timeout} - $NOW;
+   *{"${dir}timeout_reset"} = sub {
+      $_[0]{$activity} = AE::now;
+   };
 
-      # now or in the past already?
-      if ($after <= 0) {
-         $self->{_activity} = $NOW;
+   # main workhorse:
+   # reset the timeout watcher, as neccessary
+   # also check for time-outs
+   $cb = sub {
+      my ($self) = @_;
+
+      if ($self->{$timeout} && $self->{fh}) {
+         my $NOW = AE::now;
+
+         # when would the timeout trigger?
+         my $after = $self->{$activity} + $self->{$timeout} - $NOW;
+
+         # now or in the past already?
+         if ($after <= 0) {
+            $self->{$activity} = $NOW;
 
-         if ($self->{on_timeout}) {
-            $self->{on_timeout}($self);
-         } else {
-            $self->_error (Errno::ETIMEDOUT);
-         }
+            if ($self->{$on_timeout}) {
+               $self->{$on_timeout}($self);
+            } else {
+               $self->_error (Errno::ETIMEDOUT);
+            }
 
-         # callback could have changed timeout value, optimise
-         return unless $self->{timeout};
+            # callback could have changed timeout value, optimise
+            return unless $self->{$timeout};
 
-         # calculate new after
-         $after = $self->{timeout};
-      }
+            # calculate new after
+            $after = $self->{$timeout};
+         }
 
-      Scalar::Util::weaken $self;
-      return unless $self; # ->error could have destroyed $self
+         Scalar::Util::weaken $self;
+         return unless $self; # ->error could have destroyed $self
 
-      $self->{_tw} ||= AnyEvent->timer (after => $after, cb => sub {
-         delete $self->{_tw};
-         $self->_timeout;
-      });
-   } else {
-      delete $self->{_tw};
+         $self->{$tw} ||= AE::timer $after, 0, sub {
+            delete $self->{$tw};
+            $cb->($self);
+         };
+      } else {
+         delete $self->{$tw};
+      }
    }
 }
 
@@ -723,7 +764,7 @@
          if (defined $len) {
             substr $self->{wbuf}, 0, $len, "";
 
-            $self->{_activity} = AnyEvent->now;
+            $self->{_activity} = $self->{_wactivity} = AE::now;
 
             $self->{on_drain}($self)
                if $self->{low_water_mark} >= (length $self->{wbuf}) + (length $self->{_tls_wbuf})
@@ -739,7 +780,7 @@
       $cb->() unless $self->{autocork};
 
       # if still data left in wbuf, we need to poll
-      $self->{_ww} = AnyEvent->io (fh => $self->{fh}, poll => "w", cb => $cb)
+      $self->{_ww} = AE::io $self->{fh}, 1, $cb
          if length $self->{wbuf};
    };
 }
@@ -1541,12 +1582,12 @@
    unless ($self->{_rw} || $self->{_eof}) {
       Scalar::Util::weaken $self;
 
-      $self->{_rw} = AnyEvent->io (fh => $self->{fh}, poll => "r", cb => sub {
+      $self->{_rw} = AE::io $self->{fh}, 0, sub {
          my $rbuf = \($self->{tls} ? my $buf : $self->{rbuf});
          my $len = sysread $self->{fh}, $$rbuf, $self->{read_size} || 8192, length $$rbuf;
 
          if ($len > 0) {
-            $self->{_activity} = AnyEvent->now;
+            $self->{_activity} = $self->{_ractivity} = AE::now;
 
             if ($self->{tls}) {
                Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf);
@@ -1564,7 +1605,7 @@
          } elsif ($! != EAGAIN && $! != EINTR && $! != WSAEWOULDBLOCK) {
             return $self->_error ($!, 1);
          }
-      });
+      };
    }
 }
 
@@ -1734,6 +1775,8 @@
    $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
    $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
 
+   Net::SSLeay::BIO_write ($self->{_rbio}, delete $self->{rbuf});
+
    Net::SSLeay::set_bio ($tls, $self->{_rbio}, $self->{_wbio});
 
    $self->{_on_starttls} = sub { $_[0]{on_starttls}(@_) }
@@ -1772,7 +1815,7 @@
    return unless $self->{tls};
 
    $self->{tls_ctx}->_put_session (delete $self->{tls})
-      if ref $self->{tls};
+      if $self->{tls} > 0;
    
    delete @$self{qw(_rbio _wbio _tls_wbuf _on_starttls)};
 }
@@ -1790,7 +1833,7 @@
 
       my @linger;
 
-      push @linger, AnyEvent->io (fh => $fh, poll => "w", cb => sub {
+      push @linger, AE::io $fh, 1, sub {
          my $len = syswrite $fh, $wbuf, length $wbuf;
 
          if ($len > 0) {
@@ -1798,10 +1841,10 @@
          } else {
             @linger = (); # end
          }
-      });
-      push @linger, AnyEvent->timer (after => $linger, cb => sub {
+      };
+      push @linger, AE::timer $linger, 0, sub {
          @linger = ();
-      });
+      };
    }
 }