[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent/Handle.pm

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.90 by root, Mon Sep 29 02:08:57 2008 UTC vs.
Revision 1.95 by root, Thu Oct 2 06:42:39 2008 UTC

 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 =cut
-our $VERSION = 4.234;
+our $VERSION = 4.3;
 =head1 SYNOPSIS
    use AnyEvent;
    use AnyEvent::Handle;
 write data and will install a watcher that will write this data to the
 socket. No errors will be reported (this mostly matches how the operating
 system treats outstanding data at socket close time).
 This will not work for partial TLS data that could not be encoded
-yet. This data will be lost.
+yet. This data will be lost. Calling the C<stoptls> method in time might
+help.
 =item tls => "accept" | "connect" | Net::SSLeay::SSL object
 When this parameter is given, it enables TLS (SSL) mode, that means
 AnyEvent will start a TLS handshake as soon as the conenction has been
 texts.
 Note that you are responsible to depend on the JSON module if you want to
 use this functionality, as AnyEvent does not have a dependency itself.
-=item filter_r => $cb
-=item filter_w => $cb
-These exist, but are undocumented at this time. (They are used internally
-by the TLS code).
 =back
 =cut
 sub new {
    $self->{fh} or Carp::croak "mandatory argument fh is missing";
    AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
-   if ($self->{tls}) {
-      require Net::SSLeay;
-      $self->starttls (delete $self->{tls}, delete $self->{tls_ctx});
+   $self->starttls (delete $self->{tls}, delete $self->{tls_ctx})
-   }
+      if $self->{tls};
    $self->{_activity} = AnyEvent->now;
    $self->_timeout;
    $self->on_drain (delete $self->{on_drain}) if exists $self->{on_drain};
    delete $self->{_tw};
    delete $self->{_rw};
    delete $self->{_ww};
    delete $self->{fh};
-   $self->stoptls;
+   &_freetls;
    delete $self->{on_read};
    delete $self->{_queue};
 }
    my ($self, $cb) = @_;
    $self->{on_drain} = $cb;
    $cb->($self)
-      if $cb && $self->{low_water_mark} >= length $self->{wbuf};
+      if $cb && $self->{low_water_mark} >= (length $self->{wbuf}) + (length $self->{_tls_wbuf});
 }
 =item $handle->push_write ($data)
 Queues the given scalar to be written. You can push as much data as you
             substr $self->{wbuf}, 0, $len, "";
             $self->{_activity} = AnyEvent->now;
             $self->{on_drain}($self)
-               if $self->{low_water_mark} >= length $self->{wbuf}
+               if $self->{low_water_mark} >= (length $self->{wbuf}) + (length $self->{_tls_wbuf})
                   && $self->{on_drain};
             delete $self->{_ww} unless length $self->{wbuf};
          } elsif ($! != EAGAIN && $! != EINTR && $! != WSAEWOULDBLOCK) {
             $self->_error ($!, 1);
       @_ = ($WH{$type} or Carp::croak "unsupported type passed to AnyEvent::Handle::push_write")
            ->($self, @_);
    }
-   if ($self->{filter_w}) {
+   if ($self->{tls}) {
-      $self->{filter_w}($self, \$_[0]);
+      $self->{_tls_wbuf} .= $_[0];
+      &_dotls ($self);
    } else {
       $self->{wbuf} .= $_[0];
       $self->_drain_wbuf;
    }
 }
             last; # more data might arrive
          }
       } else {
          # read side becomes idle
-         delete $self->{_rw};
+         delete $self->{_rw} unless $self->{tls};
          last;
       }
    }
    if ($self->{_eof}) {
 Note that AnyEvent::Handle will automatically C<start_read> for you when
 you change the C<on_read> callback or push/unshift a read callback, and it
 will automatically C<stop_read> for you when neither C<on_read> is set nor
 there are any read requests in the queue.
+These methods will have no effect when in TLS mode (as TLS doesn't support
+half-duplex connections).
 =cut
 sub stop_read {
    my ($self) = @_;
-   delete $self->{_rw};
+   delete $self->{_rw} unless $self->{tls};
 }
 sub start_read {
    my ($self) = @_;
    unless ($self->{_rw} || $self->{_eof}) {
       Scalar::Util::weaken $self;
       $self->{_rw} = AnyEvent->io (fh => $self->{fh}, poll => "r", cb => sub {
-         my $rbuf = $self->{filter_r} ? \my $buf : \$self->{rbuf};
+         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->{filter_r}
+            if ($self->{tls}) {
-               ? $self->{filter_r}($self, $rbuf)
+               Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf);
-               : $self->{_in_drain} || $self->_drain_rbuf;
+               &_dotls ($self);
+            } else {
+               $self->_drain_rbuf unless $self->{_in_drain};
+            }
          } elsif (defined $len) {
             delete $self->{_rw};
             $self->{_eof} = 1;
             $self->_drain_rbuf unless $self->{_in_drain};
       while ((my $len = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
          substr $self->{_tls_wbuf}, 0, $len, "";
       }
    }
-   if (length ($buf = Net::SSLeay::BIO_read ($self->{_wbio}))) {
-      $self->{wbuf} .= $buf;
-      $self->_drain_wbuf;
-   }
    while (defined ($buf = Net::SSLeay::read ($self->{tls}))) {
-      if (length $buf) {
+      unless (length $buf) {
-         $self->{rbuf} .= $buf;
-         $self->_drain_rbuf unless $self->{_in_drain};
-      } else {
          # let's treat SSL-eof as we treat normal EOF
+         delete $self->{_rw};
          $self->{_eof} = 1;
-         $self->_shutdown;
+         &_freetls;
-         return;
       }
+      $self->{rbuf} .= $buf;
+      $self->_drain_rbuf unless $self->{_in_drain};
+      $self->{tls} or return; # tls session might have gone away in callback
    }
    my $err = Net::SSLeay::get_error ($self->{tls}, -1);
    if ($err!= Net::SSLeay::ERROR_WANT_READ ()) {
          return $self->_error (&Errno::EIO, 1);
       }
       # all others are fine for our purposes
    }
+   if (length ($buf = Net::SSLeay::BIO_read ($self->{_wbio}))) {
+      $self->{wbuf} .= $buf;
+      $self->_drain_wbuf;
+   }
 }
 =item $handle->starttls ($tls[, $tls_ctx])
 Instead of starting TLS negotiation immediately when the AnyEvent::Handle
 The TLS connection object will end up in C<< $handle->{tls} >> after this
 call and can be used or changed to your liking. Note that the handshake
 might have already started when this function returns.
+If it an error to start a TLS handshake more than once per
+AnyEvent::Handle object (this is due to bugs in OpenSSL).
 =cut
 sub starttls {
    my ($self, $ssl, $ctx) = @_;
-   $self->stoptls;
+   require Net::SSLeay;
+   Carp::croak "it is an error to call starttls more than once on an Anyevent::Handle object"
+      if $self->{tls};
    if ($ssl eq "accept") {
       $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
       Net::SSLeay::set_accept_state ($ssl);
    } elsif ($ssl eq "connect") {
       $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
    # and mismaintained ssleay-module doesn't even offer them).
    # http://www.mail-archive.com/openssl-dev@openssl.org/msg22420.html
    #
    # in short: this is a mess.
    #
-   # note that we do not try to kepe the length constant between writes as we are required to do.
+   # note that we do not try to keep the length constant between writes as we are required to do.
    # we assume that most (but not all) of this insanity only applies to non-blocking cases,
-   # and we drive openssl fully in blocking mode here.
+   # and we drive openssl fully in blocking mode here. Or maybe we don't - openssl seems to
+   # have identity issues in that area.
    Net::SSLeay::CTX_set_mode ($self->{tls},
       (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
       | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
    $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
    $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
    Net::SSLeay::set_bio ($ssl, $self->{_rbio}, $self->{_wbio});
-   $self->{filter_w} = sub {
+   &_dotls; # need to trigger the initial handshake
-      $_[0]{_tls_wbuf} .= ${$_[1]};
+   $self->start_read; # make sure we actually do read
-      &_dotls;
-   };
-   $self->{filter_r} = sub {
-      Net::SSLeay::BIO_write ($_[0]{_rbio}, ${$_[1]});
-      &_dotls;
-   };
 }
 =item $handle->stoptls
-Destroys the SSL connection, if any. Partial read or write data will be
+Shuts down the SSL connection - this makes a proper EOF handshake by
-lost.
+sending a close notify to the other side, but since OpenSSL doesn't
+support non-blocking shut downs, it is not possible to re-use the stream
+afterwards.
 =cut
 sub stoptls {
    my ($self) = @_;
+   if ($self->{tls}) {
+      Net::SSLeay::shutdown ($self->{tls});
+      &_dotls;
+      # we don't give a shit. no, we do, but we can't. no...
+      # we, we... have to use openssl :/
+      &_freetls;
+   }
+}
+sub _freetls {
+   my ($self) = @_;
+   return unless $self->{tls};
-   Net::SSLeay::free (delete $self->{tls}) if $self->{tls};
+   Net::SSLeay::free (delete $self->{tls});
-   delete $self->{_rbio};
+   delete @$self{qw(_rbio _wbio _tls_wbuf)};
-   delete $self->{_wbio};
-   delete $self->{_tls_wbuf};
-   delete $self->{filter_r};
-   delete $self->{filter_w};
 }
 sub DESTROY {
    my $self = shift;
-   $self->stoptls;
+   &_freetls;
    my $linger = exists $self->{linger} ? $self->{linger} : 3600;
    if ($linger && length $self->{wbuf}) {
       my $fh   = delete $self->{fh};
    }
 }
 =back
+=head1 NONFREQUENTLY ASKED QUESTIONS
+=over 4
+=item How do I read data until the other side closes the connection?
+If you just want to read your data into a perl scalar, the easiest way to achieve this is
+by setting an C<on_read> callback that does nothing, clearing the C<on_eof> callback
+and in the C<on_error> callback, the data will be in C<$_[0]{rbuf}>:
+   $handle->on_read (sub { });
+   $handle->on_eof (undef);
+   $handle->on_error (sub {
+      my $data = delete $_[0]{rbuf};
+      undef $handle;
+   });
+The reason to use C<on_error> is that TCP connections, due to latencies
+and packets loss, might get closed quite violently with an error, when in
+fact, all data has been received.
+It is usually better to use acknowledgements when transfering data,
+to make sure the other side hasn't just died and you got the data
+intact. This is also one reason why so many internet protocols have an
+explicit QUIT command.
+=item I don't want to destroy the handle too early - how do I wait until all data has been sent?
+After writing your last bits of data, set the C<on_drain> callback
+and destroy the handle in there - with the default setting of
+C<low_water_mark> this will be called precisely when all data has been
+written to the socket:
+   $handle->push_write (...);
+   $handle->on_drain (sub {
+      warn "all data submitted to the kernel\n";
+      undef $handle;
+   });
+=back
 =head1 SUBCLASSING AnyEvent::Handle
 In many cases, you might want to subclass AnyEvent::Handle.
 To make this easier, a given version of AnyEvent::Handle uses these

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.90 by root, Mon Sep 29 02:08:57 2008 UTC vs. Revision 1.95 by root, Thu Oct 2 06:42:39 2008 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.90 by root, Mon Sep 29 02:08:57 2008 UTC vs.
Revision 1.95 by root, Thu Oct 2 06:42:39 2008 UTC