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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.163 by root, Mon Jul 27 22:08:52 2009 UTC vs.
Revision 1.175 by root, Sat Aug 8 22:20:43 2009 UTC

 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 =cut
-our $VERSION = 4.87;
+our $VERSION = 4.91;
 =head1 SYNOPSIS
    use AnyEvent;
    use AnyEvent::Handle;
 sub _start {
    my ($self) = @_;
    AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
-   $self->{_activity} = AnyEvent->now;
+   $self->{_activity} = AE::now;
    $self->_timeout;
    $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
    $self->starttls (delete $self->{tls}, delete $self->{tls_ctx})
 sub on_starttls {
    $_[0]{on_stoptls} = $_[1];
 }
+=item $handle->rbuf_max ($max_octets)
+Configures the C<rbuf_max> setting (C<undef> disables it).
+=cut
+sub rbuf_max {
+   $_[0]{rbuf_max} = $_[1];
+}
 #############################################################################
 =item $handle->timeout ($seconds)
 Configures (or disables) the inactivity timeout.
 sub timeout {
    my ($self, $timeout) = @_;
    $self->{timeout} = $timeout;
+   delete $self->{_tw};
    $self->_timeout;
 }
 # reset the timeout watcher, as neccessary
 # also check for time-outs
 sub _timeout {
    my ($self) = @_;
    if ($self->{timeout} && $self->{fh}) {
-      my $NOW = AnyEvent->now;
+      my $NOW = AE::now;
       # when would the timeout trigger?
       my $after = $self->{_activity} + $self->{timeout} - $NOW;
       # now or in the past already?
       }
       Scalar::Util::weaken $self;
       return unless $self; # ->error could have destroyed $self
-      $self->{_tw} ||= AnyEvent->timer (after => $after, cb => sub {
+      $self->{_tw} ||= AE::timer $after, 0, sub {
          delete $self->{_tw};
          $self->_timeout;
-      });
+      };
    } else {
       delete $self->{_tw};
    }
 }
          my $len = syswrite $self->{fh}, $self->{wbuf};
          if (defined $len) {
             substr $self->{wbuf}, 0, $len, "";
-            $self->{_activity} = AnyEvent->now;
+            $self->{_activity} = AE::now;
             $self->{on_drain}($self)
                if $self->{low_water_mark} >= (length $self->{wbuf}) + (length $self->{_tls_wbuf})
                   && $self->{on_drain};
       # try to write data immediately
       $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};
    };
 }
 our %WH;
 sub _drain_rbuf {
    my ($self) = @_;
    # avoid recursion
-   return if exists $self->{_skip_drain_rbuf};
+   return if $self->{_skip_drain_rbuf};
    local $self->{_skip_drain_rbuf} = 1;
-   if (
-      defined $self->{rbuf_max}
-      && $self->{rbuf_max} < length $self->{rbuf}
-   ) {
-      $self->_error (Errno::ENOSPC, 1), return;
-   }
    while () {
       # we need to use a separate tls read buffer, as we must not receive data while
       # we are draining the buffer, and this can only happen with TLS.
       $self->{rbuf} .= delete $self->{_tls_rbuf}
       $self->{on_eof}
          ? $self->{on_eof}($self)
          : $self->_error (0, 1, "Unexpected end-of-file");
       return;
+   }
+   if (
+      defined $self->{rbuf_max}
+      && $self->{rbuf_max} < length $self->{rbuf}
+   ) {
+      $self->_error (Errno::ENOSPC, 1), return;
    }
    # may need to restart read watcher
    unless ($self->{_rw}) {
       $self->start_read
    my ($self) = @_;
    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} = AE::now;
             if ($self->{tls}) {
                Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf);
                &_dotls ($self);
             $self->_drain_rbuf;
          } elsif ($! != EAGAIN && $! != EINTR && $! != WSAEWOULDBLOCK) {
             return $self->_error ($!, 1);
          }
-      });
+      };
    }
 }
 our $ERROR_SYSCALL;
 our $ERROR_WANT_READ;
    Net::SSLeay::CTX_set_mode ($tls, 1|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::BIO_write ($self->{_rbio}, delete $self->{rbuf});
    Net::SSLeay::set_bio ($tls, $self->{_rbio}, $self->{_wbio});
    $self->{_on_starttls} = sub { $_[0]{on_starttls}(@_) }
       if $self->{on_starttls};
    my ($self) = @_;
    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)};
 }
 sub DESTROY {
       my $fh   = delete $self->{fh};
       my $wbuf = delete $self->{wbuf};
       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) {
             substr $wbuf, 0, $len, "";
          } else {
             @linger = (); # end
          }
-      });
+      };
-      push @linger, AnyEvent->timer (after => $linger, cb => sub {
+      push @linger, AE::timer $linger, 0, sub {
          @linger = ();
-      });
+      };
    }
 }
 =item $handle->destroy
 Shuts down the handle object as much as possible - this call ensures that
 no further callbacks will be invoked and as many resources as possible
-will be freed. You must not call any methods on the object afterwards.
+will be freed. Any method you will call on the handle object after
+destroying it in this way will be silently ignored (and it will return the
+empty list).
 Normally, you can just "forget" any references to an AnyEvent::Handle
 object and it will simply shut down. This works in fatal error and EOF
 callbacks, as well as code outside. It does I<NOT> work in a read or write
 callback, so when you want to destroy the AnyEvent::Handle object from
 sub destroy {
    my ($self) = @_;
    $self->DESTROY;
    %$self = ();
+   bless $self, "AnyEvent::Handle::destroyed";
+}
+sub AnyEvent::Handle::destroyed::AUTOLOAD {
+   #nop
 }
 =item AnyEvent::Handle::TLS_CTX
 This function creates and returns the AnyEvent::TLS object used by default

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.163 by root, Mon Jul 27 22:08:52 2009 UTC vs. Revision 1.175 by root, Sat Aug 8 22:20:43 2009 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.163 by root, Mon Jul 27 22:08:52 2009 UTC vs.
Revision 1.175 by root, Sat Aug 8 22:20:43 2009 UTC