--- AnyEvent/lib/AnyEvent/Handle.pm	2008/10/23 19:03:30	1.101
+++ AnyEvent/lib/AnyEvent/Handle.pm	2009/06/30 22:42:33	1.131
@@ -16,7 +16,7 @@
 
 =cut
 
-our $VERSION = 4.3;
+our $VERSION = 4.45;
 
 =head1 SYNOPSIS
 
@@ -29,7 +29,7 @@
       AnyEvent::Handle->new (
          fh => \*STDIN,
          on_eof => sub {
-            $cv->broadcast;
+            $cv->send;
          },
       );
 
@@ -65,9 +65,9 @@
 
 =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
 
@@ -129,7 +129,9 @@
 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
@@ -237,6 +239,12 @@
 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
@@ -255,16 +263,30 @@
 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.
@@ -282,40 +304,35 @@
 
 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->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->starttls (delete $self->{tls}, delete $self->{tls_ctx})
+      if $self->{tls};
+
+   $self->on_drain (delete $self->{on_drain}) if exists $self->{on_drain};
+
    $self->start_read
       if $self->{on_read};
 
-   $self
+   $self->{fh} && $self
 }
 
 sub _shutdown {
    my ($self) = @_;
 
-   delete $self->{_tw};
-   delete $self->{_rw};
-   delete $self->{_ww};
-   delete $self->{fh};
+   delete @$self{qw(_tw _rw _ww fh rbuf wbuf on_read _queue)};
+   $self->{_eof} = 1; # tell starttls et. al to stop trying
 
    &_freetls;
-
-   delete $self->{on_read};
-   delete $self->{_queue};
 }
 
 sub _error {
@@ -376,10 +393,14 @@
 =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
@@ -760,6 +781,10 @@
    }
 
    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} }) {
@@ -830,8 +855,11 @@
 
 Returns the read buffer (as a modifiable lvalue).
 
-You can access the read buffer directly as the C<< ->{rbuf} >> member, if
-you want.
+You can access the read buffer directly as the C<< ->{rbuf} >>
+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
@@ -1137,7 +1165,8 @@
 
 =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.
@@ -1164,7 +1193,7 @@
    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;
@@ -1172,8 +1201,19 @@
          $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} = "";
+
          ()
       }
    }
@@ -1324,7 +1364,7 @@
          &_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
    }
@@ -1334,7 +1374,7 @@
    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);
       }
 
@@ -1356,12 +1396,15 @@
 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
-used when AnyEvent::Handle has to create its own TLS connection object.
-
-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.
+The second argument is the optional C<AnyEvent::TLS> object that is used
+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} >>, the TLS
+context in C<< $handle->{tls_ctx} >> 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).
@@ -1373,18 +1416,20 @@
 
    require Net::SSLeay;
 
-   Carp::croak "it is an error to call starttls more than once on an Anyevent::Handle object"
+   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 ());
-      Net::SSLeay::set_connect_state ($ssl);
-   }
 
-   $self->{tls} = $ssl;
+   $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;
+   }
+   
+   $self->{tls_ctx} = $ctx || TLS_CTX ();
+   $self->{tls}     = $ssl = $self->{tls_ctx}->_get_session ($ssl, $self);
 
    # basically, this is deep magic (because SSL_read should have the same issues)
    # but the openssl maintainers basically said: "trust us, it just works".
@@ -1398,9 +1443,10 @@
    # 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},
-      (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
-      | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
+#   Net::SSLeay::CTX_set_mode ($ssl,
+#      (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
+#      | (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 ());
@@ -1439,13 +1485,13 @@
 
    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;
 
@@ -1499,36 +1545,20 @@
 
 =item AnyEvent::Handle::TLS_CTX
 
-This function creates and returns the Net::SSLeay::CTX object used by
-default for TLS mode.
-
-The context is created like this:
+This function creates and returns the AnyEvent::TLS object used by default
+for TLS mode.
 
-   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
+The context is created by calling L<AnyEvent::TLS> without any arguments.
 
 =cut
 
 our $TLS_CTX;
 
 sub TLS_CTX() {
-   $TLS_CTX || do {
-      require Net::SSLeay;
-
-      Net::SSLeay::load_error_strings ();
-      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 ||= do {
+      require AnyEvent::TLS;
 
-      $TLS_CTX
+      new AnyEvent::TLS
    }
 }