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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.102 by root, Wed Oct 29 14:32:02 2008 UTC vs.
Revision 1.132 by elmex, Thu Jul 2 22:25:13 2009 UTC

 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 =cut
-our $VERSION = 4.3;
+our $VERSION = 4.45;
 =head1 SYNOPSIS
    use AnyEvent;
    use AnyEvent::Handle;
    my $handle =
       AnyEvent::Handle->new (
          fh => \*STDIN,
          on_eof => sub {
-            $cv->broadcast;
+            $cv->send;
          },
       );
    # send some request line
    $handle->push_write ("getinfo\015\012");
 =head1 METHODS
 =over 4
-=item B<new (%args)>
+=item $handle = B<new> AnyEvent::TLS fh => $filehandle, key => value...
-The constructor supports these arguments (all as key => value pairs).
+The constructor supports these arguments (all as C<< key => value >> pairs).
 =over 4
 =item fh => $filehandle [MANDATORY]
 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.
+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
 calling the C<on_eof> callback. If no progress can be made, then a fatal
 error will be raised (with C<$!> set to C<EPIPE>).
 This will not work for partial TLS data that could not be encoded
 yet. This data will be lost. Calling the C<stoptls> method in time might
 help.
+=item common_name => $string
+The common name used by some verification methods (most notably SSL/TLS)
+associated with this connection. Usually this is the remote hostname used
+to connect, but can be almost anything.
 =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
 established and will transparently encrypt/decrypt data afterwards.
 mode.
 You can also provide your own TLS connection object, but you have
 to make sure that you call either C<Net::SSLeay::set_connect_state>
 or C<Net::SSLeay::set_accept_state> on it before you pass it to
-AnyEvent::Handle.
+AnyEvent::Handle. Also, this module will take ownership of this connection
+object.
+At some future point, AnyEvent::Handle might switch to another TLS
+implementation, then the option to use your own session object will go
+away.
+B<IMPORTANT:> since Net::SSLeay "objects" are really only integers,
+passing in the wrong integer will lead to certain crash. This most often
+happens when one uses a stylish C<< tls => 1 >> and is surprised about the
+segmentation fault.
 See the C<< ->starttls >> method for when need to start TLS negotiation later.
-=item tls_ctx => $ssl_ctx
+=item tls_ctx => $anyevent_tls
-Use the given C<Net::SSLeay::CTX> object to create the new TLS connection
+Use the given C<AnyEvent::TLS> object to create the new TLS connection
 (unless a connection object was specified directly). If this parameter is
 missing, then AnyEvent::Handle will use C<AnyEvent::Handle::TLS_CTX>.
+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 json => JSON or JSON::XS object
 This is the json coder object used by the C<json> read and write types.
 =cut
 sub new {
    my $class = shift;
    my $self = bless { @_ }, $class;
    $self->{fh} or Carp::croak "mandatory argument fh is missing";
    AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
+   $self->{_activity} = AnyEvent->now;
+   $self->_timeout;
+   $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
    $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};
-   $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
    $self->start_read
       if $self->{on_read};
-   $self
+   $self->{fh} && $self
 }
 sub _shutdown {
    my ($self) = @_;
-   delete $self->{_tw};
+   delete @$self{qw(_tw _rw _ww fh wbuf on_read _queue)};
-   delete $self->{_rw};
+   $self->{_eof} = 1; # tell starttls et. al to stop trying
-   delete $self->{_ww};
-   delete $self->{fh};
    &_freetls;
-   delete $self->{on_read};
-   delete $self->{_queue};
 }
 sub _error {
    my ($self, $errno, $fatal) = @_;
 }
 =item $handle->autocork ($boolean)
 Enables or disables the current autocork behaviour (see C<autocork>
-constructor argument).
+constructor argument). Changes will only take effect on the next write.
 =cut
+sub autocork {
+   $_[0]{autocork} = $_[1];
+}
 =item $handle->no_delay ($boolean)
 Enables or disables the C<no_delay> setting (see constructor argument of
 the same name for details).
    ) {
       $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} if exists $self->{_tls_rbuf};
       my $len = length $self->{rbuf};
       if (my $cb = shift @{ $self->{_queue} }) {
          unless ($cb->($self)) {
             if ($self->{_eof}) {
 =item $handle->rbuf
 Returns the read buffer (as a modifiable lvalue).
-You can access the read buffer directly as the C<< ->{rbuf} >> member, if
+You can access the read buffer directly as the C<< ->{rbuf} >>
-you want.
+member, if you want. However, the only operation allowed on the
+read buffer (apart from looking at it) is removing data from its
+beginning. Otherwise modifying or appending to it is not allowed and will
+lead to hard-to-track-down bugs.
 NOTE: The read buffer should only be used or modified if the C<on_read>,
 C<push_read> or C<unshift_read> methods are used. The other read methods
 automatically manage the read buffer.
    }
 };
 =item json => $cb->($handle, $hash_or_arrayref)
-Reads a JSON object or array, decodes it and passes it to the callback.
+Reads a JSON object or array, decodes it and passes it to the
+callback. When a parse error occurs, an C<EBADMSG> error will be raised.
 If a C<json> object was passed to the constructor, then that will be used
 for the final decode, otherwise it will create a JSON coder expecting UTF-8.
 This read type uses the incremental parser available with JSON version
    my $rbuf = \$self->{rbuf};
    my $json = $self->{json} ||= JSON->new->utf8;
    sub {
-      my $ref = $json->incr_parse ($self->{rbuf});
+      my $ref = eval { $json->incr_parse ($self->{rbuf}) };
       if ($ref) {
          $self->{rbuf} = $json->incr_text;
          $json->incr_text = "";
          $cb->($self, $ref);
          1
+      } elsif ($@) {
+         # error case
+         $json->incr_skip;
+         $self->{rbuf} = $json->incr_text;
+         $json->incr_text = "";
+         $self->_error (&Errno::EBADMSG);
+         ()
       } else {
          $self->{rbuf} = "";
          ()
       }
    }
 };
          delete $self->{_rw};
          $self->{_eof} = 1;
          &_freetls;
       }
-      $self->{rbuf} .= $tmp;
+      $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);
    if ($tmp != Net::SSLeay::ERROR_WANT_READ ()) {
       if ($tmp == Net::SSLeay::ERROR_SYSCALL ()) {
          return $self->_error ($!, 1);
-      } elsif ($tmp == Net::SSLeay::ERROR_SSL ())  {
+      } elsif ($tmp == Net::SSLeay::ERROR_SSL ()) {
          return $self->_error (&Errno::EIO, 1);
       }
       # all other errors are fine for our purposes
    }
 C<starttls>.
 The first argument is the same as the C<tls> constructor argument (either
 C<"connect">, C<"accept"> or an existing Net::SSLeay object).
-The second argument is the optional C<Net::SSLeay::CTX> object that is
+The second argument is the optional C<AnyEvent::TLS> object that is used
-used when AnyEvent::Handle has to create its own TLS connection object.
+when AnyEvent::Handle has to create its own TLS connection object, or
+a hash reference with C<< key => value >> pairs that will be used to
+construct a new context.
-The TLS connection object will end up in C<< $handle->{tls} >> after this
+The TLS connection object will end up in C<< $handle->{tls} >>, the TLS
-call and can be used or changed to your liking. Note that the handshake
+context in C<< $handle->{tls_ctx} >> after this call and can be used or
-might have already started when this function returns.
+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
    require Net::SSLeay;
    Carp::croak "it is an error to call starttls more than once on an AnyEvent::Handle object"
       if $self->{tls};
+   $ctx ||= $self->{tls_ctx};
+   if ("HASH" eq ref $ctx) {
+      require AnyEvent::TLS;
+      local $Carp::CarpLevel = 1; # skip ourselves when creating a new context
+      $ctx = new AnyEvent::TLS %$ctx;
+   }
-   if ($ssl eq "accept") {
+   $self->{tls_ctx} = $ctx || TLS_CTX ();
-      $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
+   $self->{tls}     = $ssl = $self->{tls_ctx}->_get_session ($ssl, $self);
-      Net::SSLeay::set_accept_state ($ssl);
-   } elsif ($ssl eq "connect") {
-      $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
-      Net::SSLeay::set_connect_state ($ssl);
-   }
-   $self->{tls} = $ssl;
    # basically, this is deep magic (because SSL_read should have the same issues)
    # but the openssl maintainers basically said: "trust us, it just works".
    # (unfortunately, we have to hardcode constants because the abysmally misdesigned
    # and mismaintained ssleay-module doesn't even offer them).
    #
    # 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. Or maybe we don't - openssl seems to
    # have identity issues in that area.
-   Net::SSLeay::CTX_set_mode ($self->{tls},
+#   Net::SSLeay::CTX_set_mode ($ssl,
-      (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
+#      (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
-      | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
+#      | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
+   Net::SSLeay::CTX_set_mode ($ssl, 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::set_bio ($ssl, $self->{_rbio}, $self->{_wbio});
 sub _freetls {
    my ($self) = @_;
    return unless $self->{tls};
-   Net::SSLeay::free (delete $self->{tls});
+   $self->{tls_ctx}->_put_session (delete $self->{tls});
    delete @$self{qw(_rbio _wbio _tls_wbuf)};
 }
 sub DESTROY {
-   my $self = shift;
+   my ($self) = @_;
    &_freetls;
    my $linger = exists $self->{linger} ? $self->{linger} : 3600;
    %$self = ();
 }
 =item AnyEvent::Handle::TLS_CTX
-This function creates and returns the Net::SSLeay::CTX object used by
+This function creates and returns the AnyEvent::TLS object used by default
-default for TLS mode.
+for TLS mode.
-The context is created like this:
+The context is created by calling L<AnyEvent::TLS> without any arguments.
-   Net::SSLeay::load_error_strings;
-   Net::SSLeay::SSLeay_add_ssl_algorithms;
-   Net::SSLeay::randomize;
-   my $CTX = Net::SSLeay::CTX_new;
-   Net::SSLeay::CTX_set_options $CTX, Net::SSLeay::OP_ALL
 =cut
 our $TLS_CTX;
 sub TLS_CTX() {
-   $TLS_CTX || do {
+   $TLS_CTX ||= do {
-      require Net::SSLeay;
+      require AnyEvent::TLS;
-      Net::SSLeay::load_error_strings ();
+      new AnyEvent::TLS
-      Net::SSLeay::SSLeay_add_ssl_algorithms ();
-      Net::SSLeay::randomize ();
-      $TLS_CTX = Net::SSLeay::CTX_new ();
-      Net::SSLeay::CTX_set_options ($TLS_CTX, Net::SSLeay::OP_ALL ());
-      $TLS_CTX
    }
 }
 =back

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.102 by root, Wed Oct 29 14:32:02 2008 UTC vs. Revision 1.132 by elmex, Thu Jul 2 22:25:13 2009 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.102 by root, Wed Oct 29 14:32:02 2008 UTC vs.
Revision 1.132 by elmex, Thu Jul 2 22:25:13 2009 UTC