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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC vs.
Revision 1.97 by root, Thu Oct 2 11:07:59 2008 UTC

            ->($self, @_);
    }
    if ($self->{tls}) {
       $self->{_tls_wbuf} .= $_[0];
       &_dotls ($self);
    } else {
       $self->{wbuf} .= $_[0];
       $self->_drain_wbuf;
    }
 =cut
 register_write_type netstring => sub {
    my ($self, $string) = @_;
-   sprintf "%d:%s,", (length $string), $string
+   (length $string) . ":$string,"
 };
 =item packstring => $format, $data
 An octet string prefixed with an encoded length. The encoding C<$format>
 An octet string prefixed with an encoded length. The encoding C<$format>
 uses the same format as a Perl C<pack> format, but must specify a single
 integer only (only one of C<cCsSlLqQiInNvVjJw> is allowed, plus an
 optional C<!>, C<< < >> or C<< > >> modifier).
-DNS over TCP uses a prefix of C<n>, EPP uses a prefix of C<N>.
+For example, DNS over TCP uses a prefix of C<n> (2 octet network order),
+EPP uses a prefix of C<N> (4 octtes).
 Example: read a block of data prefixed by its length in BER-encoded
 format (very efficient).
    $handle->push_read (packstring => "w", sub {
          if ($len > 0) {
             $self->{_activity} = AnyEvent->now;
             if ($self->{tls}) {
                Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf);
                &_dotls ($self);
             } else {
                $self->_drain_rbuf unless $self->{_in_drain};
             }
          }
       });
    }
 }
+# poll the write BIO and send the data if applicable
 sub _dotls {
    my ($self) = @_;
-   my $buf;
+   my $tmp;
    if (length $self->{_tls_wbuf}) {
-      while ((my $len = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
+      while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
-         substr $self->{_tls_wbuf}, 0, $len, "";
+         substr $self->{_tls_wbuf}, 0, $tmp, "";
       }
    }
-   while (defined ($buf = Net::SSLeay::read ($self->{tls}))) {
+   while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) {
-      unless (length $buf) {
+      unless (length $tmp) {
          # let's treat SSL-eof as we treat normal EOF
          delete $self->{_rw};
          $self->{_eof} = 1;
          &_freetls;
       }
-      $self->{rbuf} .= $buf;
+      $self->{rbuf} .= $tmp;
       $self->_drain_rbuf unless $self->{_in_drain};
       $self->{tls} or return; # tls session might have gone away in callback
    }
-   my $err = Net::SSLeay::get_error ($self->{tls}, -1);
+   $tmp = Net::SSLeay::get_error ($self->{tls}, -1);
-   if ($err!= Net::SSLeay::ERROR_WANT_READ ()) {
+   if ($tmp != Net::SSLeay::ERROR_WANT_READ ()) {
-      if ($err == Net::SSLeay::ERROR_SYSCALL ()) {
+      if ($tmp == Net::SSLeay::ERROR_SYSCALL ()) {
          return $self->_error ($!, 1);
-      } elsif ($err == Net::SSLeay::ERROR_SSL ())  {
+      } elsif ($tmp == Net::SSLeay::ERROR_SSL ())  {
          return $self->_error (&Errno::EIO, 1);
       }
-      # all others are fine for our purposes
+      # all other errors are fine for our purposes
    }
-   if (length ($buf = Net::SSLeay::BIO_read ($self->{_wbio}))) {
+   while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) {
-      $self->{wbuf} .= $buf;
+      $self->{wbuf} .= $tmp;
       $self->_drain_wbuf;
    }
 }
 =item $handle->starttls ($tls[, $tls_ctx])
    }
 }
 =back
+=head1 NONFREQUENTLY ASKED QUESTIONS
+=over 4
+=item How do I read data until the other side closes the connection?
+If you just want to read your data into a perl scalar, the easiest way
+to achieve this is by setting an C<on_read> callback that does nothing,
+clearing the C<on_eof> callback and in the C<on_error> callback, the data
+will be in C<$_[0]{rbuf}>:
+   $handle->on_read (sub { });
+   $handle->on_eof (undef);
+   $handle->on_error (sub {
+      my $data = delete $_[0]{rbuf};
+      undef $handle;
+   });
+The reason to use C<on_error> is that TCP connections, due to latencies
+and packets loss, might get closed quite violently with an error, when in
+fact, all data has been received.
+It is usually better to use acknowledgements when transfering data,
+to make sure the other side hasn't just died and you got the data
+intact. This is also one reason why so many internet protocols have an
+explicit QUIT command.
+=item I don't want to destroy the handle too early - how do I wait until
+all data has been written?
+After writing your last bits of data, set the C<on_drain> callback
+and destroy the handle in there - with the default setting of
+C<low_water_mark> this will be called precisely when all data has been
+written to the socket:
+   $handle->push_write (...);
+   $handle->on_drain (sub {
+      warn "all data submitted to the kernel\n";
+      undef $handle;
+   });
+=back
 =head1 SUBCLASSING AnyEvent::Handle
 In many cases, you might want to subclass AnyEvent::Handle.
 To make this easier, a given version of AnyEvent::Handle uses these

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC vs. Revision 1.97 by root, Thu Oct 2 11:07:59 2008 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.94 by root, Wed Oct 1 15:50:33 2008 UTC vs.
Revision 1.97 by root, Thu Oct 2 11:07:59 2008 UTC