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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.134 by root, Fri Jul 3 00:09:04 2009 UTC vs.
Revision 1.142 by root, Mon Jul 6 20:24:47 2009 UTC

 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 =cut
-our $VERSION = 4.45;
+our $VERSION = 4.452;
 =head1 SYNOPSIS
    use AnyEvent;
    use AnyEvent::Handle;
 and no read request is in the queue (unlike read queue callbacks, this
 callback will only be called when at least one octet of data is in the
 read buffer).
 To access (and remove data from) the read buffer, use the C<< ->rbuf >>
-method or access the C<$handle->{rbuf}> member directly. Note that you
+method or access the C<< $handle->{rbuf} >> member directly. Note that you
 must not enlarge or modify the read buffer, you can only remove data at
 the beginning from it.
 When an EOF condition is detected then AnyEvent::Handle will first try to
 feed all the remaining data to the queued callbacks and C<on_read> before
 A string used to identify the remote site - usually the DNS hostname
 (I<not> IDN!) used to create the connection, rarely the IP address.
 Apart from being useful in error messages, this string is also used in TLS
-common name verification (see C<verify_cn> in L<AnyEvent::TLS>).
+peername verification (see C<verify_peername> in L<AnyEvent::TLS>).
 =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
 Instead of an object, you can also specify a hash reference with C<< key
 => value >> pairs. Those will be passed to L<AnyEvent::TLS> to create a
 new TLS context object.
+=item on_starttls => $cb->($handle, $success)
+This callback will be invoked when the TLS/SSL handshake has finished. If
+C<$success> is true, then the TLS handshake succeeded, otherwise it failed
+(C<on_stoptls> will not be called in this case).
+The session in C<< $handle->{tls} >> can still be examined in this
+callback, even when the handshake was not successful.
+=item on_stoptls => $cb->($handle)
+When a SSLv3/TLS shutdown/close notify/EOF is detected and this callback is
+set, then it will be invoked after freeing the TLS session. If it is not,
+then a TLS shutdown condition will be treated like a normal EOF condition
+on the handle.
+The session in C<< $handle->{tls} >> can still be examined in this
+callback.
+This callback will only be called on TLS shutdowns, not when the
+underlying handle signals EOF.
 =item json => JSON or JSON::XS object
 This is the json coder object used by the C<json> read and write types.
 If you don't supply it, then AnyEvent::Handle will create and use a
    eval {
       local $SIG{__DIE__};
       setsockopt $_[0]{fh}, &Socket::IPPROTO_TCP, &Socket::TCP_NODELAY, int $_[1];
    };
+}
+=item $handle->on_starttls ($cb)
+Replace the current C<on_starttls> callback (see the C<on_starttls> constructor argument).
+=cut
+sub on_starttls {
+   $_[0]{on_starttls} = $_[1];
+}
+=item $handle->on_stoptls ($cb)
+Replace the current C<on_stoptls> callback (see the C<on_stoptls> constructor argument).
+=cut
+sub on_starttls {
+   $_[0]{on_stoptls} = $_[1];
 }
 #############################################################################
 =item $handle->timeout ($seconds)
 =item $handle->push_shutdown
 Sometimes you know you want to close the socket after writing your data
 before it was actually written. One way to do that is to replace your
-C<on_drain> handler by a callback that shuts down the socket. This method
+C<on_drain> handler by a callback that shuts down the socket (and set
-is a shorthand for just that, and replaces the C<on_drain> callback with:
+C<low_water_mark> to C<0>). This method is a shorthand for just that, and
+replaces the C<on_drain> callback with:
    sub { shutdown $_[0]{fh}, 1 }    # for push_shutdown
 This simply shuts down the write side and signals an EOF condition to the
 the peer.
 afterwards. This is the cleanest way to close a connection.
 =cut
 sub push_shutdown {
+   my ($self) = @_;
+   delete $self->{low_water_mark};
-   $_[0]->{on_drain} = sub { shutdown $_[0]{fh}, 1 };
+   $self->on_drain (sub { shutdown $_[0]{fh}, 1 });
 }
 =item AnyEvent::Handle::register_write_type type => $coderef->($handle, @args)
 This function (not method) lets you add your own types to C<push_write>.
    if ($self->{_eof}) {
       if ($self->{on_eof}) {
          $self->{on_eof}($self)
       } else {
-         $self->_error (0, 1);
+         $self->_error (0, 1, "Unexpected end-of-file");
       }
    }
    # may need to restart read watcher
    unless ($self->{_rw}) {
 =cut
 register_read_type json => sub {
    my ($self, $cb) = @_;
-   require JSON;
+   my $json = $self->{json} ||=
+      eval { require JSON::XS; JSON::XS->new->utf8 }
+         || do { require JSON; JSON->new->utf8 };
    my $data;
    my $rbuf = \$self->{rbuf};
-   my $json = $self->{json} ||= JSON->new->utf8;
    sub {
       my $ref = eval { $json->incr_parse ($self->{rbuf}) };
       if ($ref) {
    }
 }
 our $ERROR_SYSCALL;
 our $ERROR_WANT_READ;
-our $ERROR_ZERO_RETURN;
 sub _tls_error {
    my ($self, $err) = @_;
-      warn "$err,$!\n";#d#
    return $self->_error ($!, 1)
       if $err == Net::SSLeay::ERROR_SYSCALL ();
+   my $err =Net::SSLeay::ERR_error_string (Net::SSLeay::ERR_get_error ());
+   # reduce error string to look less scary
+   $err =~ s/^error:[0-9a-fA-F]{8}:[^:]+:([^:]+):/\L$1: /;
-   $self->_error (&Errno::EPROTO, 1,
+   $self->_error (&Errno::EPROTO, 1, $err);
-                  Net::SSLeay::ERR_error_string (Net::SSLeay::ERR_get_error ()));
 }
 # poll the write BIO and send the data if applicable
 # also decode read data if possible
 # this is basiclaly our TLS state machine
       }
       $tmp = Net::SSLeay::get_error ($self->{tls}, $tmp);
       return $self->_tls_error ($tmp)
          if $tmp != $ERROR_WANT_READ
-            && ($tmp != $ERROR_SYSCALL || $!)
+            && ($tmp != $ERROR_SYSCALL || $!);
-            && $tmp != $ERROR_ZERO_RETURN;
    }
    while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) {
       unless (length $tmp) {
-         # let's treat SSL-eof as we treat normal EOF
-         delete $self->{_rw};
-         $self->{_eof} = 1;
          &_freetls;
+         if ($self->{on_stoptls}) {
+            $self->{on_stoptls}($self);
+            return;
+         } else {
+            # let's treat SSL-eof as we treat normal EOF
+            delete $self->{_rw};
+            $self->{_eof} = 1;
+         }
       }
       $self->{_tls_rbuf} .= $tmp;
       $self->_drain_rbuf unless $self->{_in_drain};
       $self->{tls} or return; # tls session might have gone away in callback
    }
    $tmp = Net::SSLeay::get_error ($self->{tls}, -1);
    return $self->_tls_error ($tmp)
       if $tmp != $ERROR_WANT_READ
-         && ($tmp != $ERROR_SYSCALL || $!)
+         && ($tmp != $ERROR_SYSCALL || $!);
-         && $tmp != $ERROR_ZERO_RETURN;
    while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) {
       $self->{wbuf} .= $tmp;
       $self->_drain_wbuf;
    }
+   $self->{_on_starttls}
+      and Net::SSLeay::state ($self->{tls}) == Net::SSLeay::ST_OK ()
+      and (delete $self->{_on_starttls})->($self, 1);
 }
 =item $handle->starttls ($tls[, $tls_ctx])
 Instead of starting TLS negotiation immediately when the AnyEvent::Handle
 If it an error to start a TLS handshake more than once per
 AnyEvent::Handle object (this is due to bugs in OpenSSL).
 =cut
+our %TLS_CACHE; #TODO not yet documented, should we?
 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};
-   $ERROR_SYSCALL     = Net::SSLeay::ERROR_SYSCALL     ();
+   $ERROR_SYSCALL   = Net::SSLeay::ERROR_SYSCALL     ();
-   $ERROR_WANT_READ   = Net::SSLeay::ERROR_WANT_READ   ();
+   $ERROR_WANT_READ = Net::SSLeay::ERROR_WANT_READ   ();
-   $ERROR_ZERO_RETURN = Net::SSLeay::ERROR_ZERO_RETURN ();
    $ctx ||= $self->{tls_ctx};
    if ("HASH" eq ref $ctx) {
       require AnyEvent::TLS;
       local $Carp::CarpLevel = 1; # skip ourselves when creating a new context
+      if ($ctx->{cache}) {
+         my $key = $ctx+0;
+         $ctx = $TLS_CACHE{$key} ||= new AnyEvent::TLS %$ctx;
+      } else {
-      $ctx = new AnyEvent::TLS %$ctx;
+         $ctx = new AnyEvent::TLS %$ctx;
+      }
    }
    $self->{tls_ctx} = $ctx || TLS_CTX ();
    $self->{tls}     = $ssl = $self->{tls_ctx}->_get_session ($ssl, $self, $self->{peername});
    $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->{_on_starttls} = sub { $_[0]{on_starttls}(@_) }
+      if exists $self->{on_starttls};
    &_dotls; # need to trigger the initial handshake
    $self->start_read; # make sure we actually do read
 }
 =item $handle->stoptls
    if ($self->{tls}) {
       Net::SSLeay::shutdown ($self->{tls});
       &_dotls;
-      # we don't give a shit. no, we do, but we can't. no...
+#      # we don't give a shit. no, we do, but we can't. no...#d#
-      # we, we... have to use openssl :/
+#      # we, we... have to use openssl :/#d#
-      &_freetls;
+#      &_freetls;#d#
    }
 }
 sub _freetls {
    my ($self) = @_;
    return unless $self->{tls};
+   $self->{_on_starttls}
+      and (delete $self->{_on_starttls})->($self, undef);
    $self->{tls_ctx}->_put_session (delete $self->{tls});
    delete @$self{qw(_rbio _wbio _tls_wbuf)};
 }
 }
 =item $handle->destroy
 Shuts down the handle object as much as possible - this call ensures that
-no further callbacks will be invoked and resources will be freed as much
+no further callbacks will be invoked and as many resources as possible
-as possible. You must not call any methods on the object afterwards.
+will be freed. You must not call any methods on the object afterwards.
 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

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.134 by root, Fri Jul 3 00:09:04 2009 UTC vs. Revision 1.142 by root, Mon Jul 6 20:24:47 2009 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.134 by root, Fri Jul 3 00:09:04 2009 UTC vs.
Revision 1.142 by root, Mon Jul 6 20:24:47 2009 UTC