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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.92 by root, Wed Oct 1 08:52:06 2008 UTC vs.
Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC

 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};
    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};
 =cut
 sub starttls {
    my ($self, $ssl, $ctx) = @_;
+   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") {
    # 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 {
-      $_[0]{_tls_wbuf} .= ${$_[1]};
-      &_dotls;
-   };
-   $self->{filter_r} = sub {
-      Net::SSLeay::BIO_write ($_[0]{_rbio}, ${$_[1]});
-      &_dotls;
-   };
-   &_dotls; # need to trigger the initial negotiation exchange
+   &_dotls; # need to trigger the initial handshake
+   $self->start_read; # make sure we actually do read
 }
 =item $handle->stoptls
 Shuts down the SSL connection - this makes a proper EOF handshake by
 sub stoptls {
    my ($self) = @_;
    if ($self->{tls}) {
-      Net::SSLeay::shutdown $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 :/
    return unless $self->{tls};
    Net::SSLeay::free (delete $self->{tls});
-   delete @$self{qw(_rbio filter_w _wbio filter_r)};
+   delete @$self{qw(_rbio _wbio _tls_wbuf)};
 }
 sub DESTROY {
    my $self = shift;

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.92 by root, Wed Oct 1 08:52:06 2008 UTC vs. Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.92 by root, Wed Oct 1 08:52:06 2008 UTC vs.
Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC