ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent/Handle.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.211 by root, Fri Dec 31 04:47:41 2010 UTC vs.
Revision 1.218 by root, Thu Feb 24 12:04:20 2011 UTC

… …
247many seconds pass without a successful read or write on the underlying 247many seconds pass without a successful read or write on the underlying
248file handle (or a call to C<timeout_reset>), the C<on_timeout> callback 248file handle (or a call to C<timeout_reset>), the C<on_timeout> callback
249will be invoked (and if that one is missing, a non-fatal C<ETIMEDOUT> 249will be invoked (and if that one is missing, a non-fatal C<ETIMEDOUT>
250error will be raised). 250error will be raised).
251 251
252There are three variants of the timeouts that work independently 252There are three variants of the timeouts that work independently of each
253of each other, for both read and write, just read, and just write: 253other, for both read and write (triggered when nothing was read I<OR>
254written), just read (triggered when nothing was read), and just write:
254C<timeout>, C<rtimeout> and C<wtimeout>, with corresponding callbacks 255C<timeout>, C<rtimeout> and C<wtimeout>, with corresponding callbacks
255C<on_timeout>, C<on_rtimeout> and C<on_wtimeout>, and reset functions 256C<on_timeout>, C<on_rtimeout> and C<on_wtimeout>, and reset functions
256C<timeout_reset>, C<rtimeout_reset>, and C<wtimeout_reset>. 257C<timeout_reset>, C<rtimeout_reset>, and C<wtimeout_reset>.
257 258
258Note that timeout processing is active even when you do not have 259Note that timeout processing is active even when you do not have any
259any outstanding read or write requests: If you plan to keep the connection 260outstanding read or write requests: If you plan to keep the connection
260idle then you should disable the timeout temporarily or ignore the timeout 261idle then you should disable the timeout temporarily or ignore the
261in the C<on_timeout> callback, in which case AnyEvent::Handle will simply 262timeout in the corresponding C<on_timeout> callback, in which case
262restart the timeout. 263AnyEvent::Handle will simply restart the timeout.
263 264
264Zero (the default) disables this timeout. 265Zero (the default) disables the corresponding timeout.
265 266
266=item on_timeout => $cb->($handle) 267=item on_timeout => $cb->($handle)
268
269=item on_rtimeout => $cb->($handle)
270
271=item on_wtimeout => $cb->($handle)
267 272
268Called whenever the inactivity timeout passes. If you return from this 273Called whenever the inactivity timeout passes. If you return from this
269callback, then the timeout will be reset as if some activity had happened, 274callback, then the timeout will be reset as if some activity had happened,
270so this condition is not fatal in any way. 275so this condition is not fatal in any way.
271 276
… …
536 }); 541 });
537 542
538 } else { 543 } else {
539 if ($self->{on_connect_error}) { 544 if ($self->{on_connect_error}) {
540 $self->{on_connect_error}($self, "$!"); 545 $self->{on_connect_error}($self, "$!");
541 $self->destroy; 546 $self->destroy if $self;
542 } else { 547 } else {
543 $self->_error ($!, 1); 548 $self->_error ($!, 1);
544 } 549 }
545 } 550 }
546 }, 551 },
… …
765 770
766sub rbuf_max { 771sub rbuf_max {
767 $_[0]{rbuf_max} = $_[1]; 772 $_[0]{rbuf_max} = $_[1];
768} 773}
769 774
770sub rbuf_max { 775sub wbuf_max {
771 $_[0]{wbuf_max} = $_[1]; 776 $_[0]{wbuf_max} = $_[1];
772} 777}
773 778
774############################################################################# 779#############################################################################
775 780
… …
778=item $handle->rtimeout ($seconds) 783=item $handle->rtimeout ($seconds)
779 784
780=item $handle->wtimeout ($seconds) 785=item $handle->wtimeout ($seconds)
781 786
782Configures (or disables) the inactivity timeout. 787Configures (or disables) the inactivity timeout.
788
789The timeout will be checked instantly, so this method might destroy the
790handle before it returns.
783 791
784=item $handle->timeout_reset 792=item $handle->timeout_reset
785 793
786=item $handle->rtimeout_reset 794=item $handle->rtimeout_reset
787 795
… …
1087before it was actually written. One way to do that is to replace your 1095before it was actually written. One way to do that is to replace your
1088C<on_drain> handler by a callback that shuts down the socket (and set 1096C<on_drain> handler by a callback that shuts down the socket (and set
1089C<low_water_mark> to C<0>). This method is a shorthand for just that, and 1097C<low_water_mark> to C<0>). This method is a shorthand for just that, and
1090replaces the C<on_drain> callback with: 1098replaces the C<on_drain> callback with:
1091 1099
1092 sub { shutdown $_[0]{fh}, 1 } # for push_shutdown 1100 sub { shutdown $_[0]{fh}, 1 }
1093 1101
1094This simply shuts down the write side and signals an EOF condition to the 1102This simply shuts down the write side and signals an EOF condition to the
1095the peer. 1103the peer.
1096 1104
1097You can rely on the normal read queue and C<on_eof> handling 1105You can rely on the normal read queue and C<on_eof> handling
… …
1616 sub { 1624 sub {
1617 # when we can use 5.10 we can use ".", but for 5.8 we use the re-pack method 1625 # when we can use 5.10 we can use ".", but for 5.8 we use the re-pack method
1618 defined (my $len = eval { unpack $format, $_[0]{rbuf} }) 1626 defined (my $len = eval { unpack $format, $_[0]{rbuf} })
1619 or return; 1627 or return;
1620 1628
1621 warn "len $len\n";#d#
1622 $format = length pack $format, $len; 1629 $format = length pack $format, $len;
1623 warn "len2 $format\n";#d#
1624 1630
1625 # bypass unshift if we already have the remaining chunk 1631 # bypass unshift if we already have the remaining chunk
1626 if ($format + $len <= length $_[0]{rbuf}) { 1632 if ($format + $len <= length $_[0]{rbuf}) {
1627 my $data = substr $_[0]{rbuf}, $format, $len; 1633 my $data = substr $_[0]{rbuf}, $format, $len;
1628 substr $_[0]{rbuf}, 0, $format + $len, ""; 1634 substr $_[0]{rbuf}, 0, $format + $len, "";
… …
1775Note that AnyEvent::Handle will automatically C<start_read> for you when 1781Note that AnyEvent::Handle will automatically C<start_read> for you when
1776you change the C<on_read> callback or push/unshift a read callback, and it 1782you change the C<on_read> callback or push/unshift a read callback, and it
1777will automatically C<stop_read> for you when neither C<on_read> is set nor 1783will automatically C<stop_read> for you when neither C<on_read> is set nor
1778there are any read requests in the queue. 1784there are any read requests in the queue.
1779 1785
1780These methods will have no effect when in TLS mode (as TLS doesn't support 1786In older versions of this module (<= 5.3), these methods had no effect,
1781half-duplex connections). 1787as TLS does not support half-duplex connections. In current versions they
1788work as expected, as this behaviour is required to avoid certain resource
1789attacks, where the program would be forced to read (and buffer) arbitrary
1790amounts of data before being able to send some data. The drawback is that
1791some readings of the the SSL/TLS specifications basically require this
1792attack to be working, as SSL/TLS implementations might stall sending data
1793during a rehandshake.
1794
1795As a guideline, during the initial handshake, you should not stop reading,
1796and as a client, it might cause problems, depending on your applciation.
1782 1797
1783=cut 1798=cut
1784 1799
1785sub stop_read { 1800sub stop_read {
1786 my ($self) = @_; 1801 my ($self) = @_;
1787 1802
1788 delete $self->{_rw} unless $self->{tls}; 1803 delete $self->{_rw};
1789} 1804}
1790 1805
1791sub start_read { 1806sub start_read {
1792 my ($self) = @_; 1807 my ($self) = @_;
1793 1808
… …
2043 if $self->{tls} > 0; 2058 if $self->{tls} > 0;
2044 2059
2045 delete @$self{qw(_rbio _wbio _tls_wbuf _on_starttls)}; 2060 delete @$self{qw(_rbio _wbio _tls_wbuf _on_starttls)};
2046} 2061}
2047 2062
2063=item $handle->resettls
2064
2065This rarely-used method simply resets and TLS state on the handle, usually
2066causing data loss.
2067
2068One case where it may be useful is when you want to skip over the data in
2069the stream but you are not interested in interpreting it, so data loss is
2070no concern.
2071
2072=cut
2073
2074*resettls = \&_freetls;
2075
2048sub DESTROY { 2076sub DESTROY {
2049 my ($self) = @_; 2077 my ($self) = @_;
2050 2078
2051 &_freetls; 2079 &_freetls;
2052 2080

Diff Legend

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