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.96 by root, Thu Oct 2 08:10:27 2008 UTC vs.
Revision 1.99 by root, Thu Oct 23 02:41:00 2008 UTC

… …
59treatment of characters applies to this module as well. 59treatment of characters applies to this module as well.
60 60
61All callbacks will be invoked with the handle object as their first 61All callbacks will be invoked with the handle object as their first
62argument. 62argument.
63 63
64=head2 SIGPIPE is not handled by this module
65
66SIGPIPE is not handled by this module, so one of the practical
67requirements of using it is to ignore SIGPIPE (C<$SIG{PIPE} =
68'IGNORE'>). At least, this is highly recommend in a networked program: If
69you use AnyEvent::Handle in a filter program (like sort), exiting on
70SIGPIPE is probably the right thing to do.
71
72=head1 METHODS 64=head1 METHODS
73 65
74=over 4 66=over 4
75 67
76=item B<new (%args)> 68=item B<new (%args)>
… …
550 ->($self, @_); 542 ->($self, @_);
551 } 543 }
552 544
553 if ($self->{tls}) { 545 if ($self->{tls}) {
554 $self->{_tls_wbuf} .= $_[0]; 546 $self->{_tls_wbuf} .= $_[0];
547
555 &_dotls ($self); 548 &_dotls ($self);
556 } else { 549 } else {
557 $self->{wbuf} .= $_[0]; 550 $self->{wbuf} .= $_[0];
558 $self->_drain_wbuf; 551 $self->_drain_wbuf;
559 } 552 }
… …
1291 if ($len > 0) { 1284 if ($len > 0) {
1292 $self->{_activity} = AnyEvent->now; 1285 $self->{_activity} = AnyEvent->now;
1293 1286
1294 if ($self->{tls}) { 1287 if ($self->{tls}) {
1295 Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf); 1288 Net::SSLeay::BIO_write ($self->{_rbio}, $$rbuf);
1289
1296 &_dotls ($self); 1290 &_dotls ($self);
1297 } else { 1291 } else {
1298 $self->_drain_rbuf unless $self->{_in_drain}; 1292 $self->_drain_rbuf unless $self->{_in_drain};
1299 } 1293 }
1300 1294
… …
1308 } 1302 }
1309 }); 1303 });
1310 } 1304 }
1311} 1305}
1312 1306
1307# poll the write BIO and send the data if applicable
1313sub _dotls { 1308sub _dotls {
1314 my ($self) = @_; 1309 my ($self) = @_;
1315 1310
1316 my $buf; 1311 my $tmp;
1317 1312
1318 if (length $self->{_tls_wbuf}) { 1313 if (length $self->{_tls_wbuf}) {
1319 while ((my $len = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) { 1314 while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
1320 substr $self->{_tls_wbuf}, 0, $len, ""; 1315 substr $self->{_tls_wbuf}, 0, $tmp, "";
1321 } 1316 }
1322 } 1317 }
1323 1318
1324 while (defined ($buf = Net::SSLeay::read ($self->{tls}))) { 1319 while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) {
1325 unless (length $buf) { 1320 unless (length $tmp) {
1326 # let's treat SSL-eof as we treat normal EOF 1321 # let's treat SSL-eof as we treat normal EOF
1327 delete $self->{_rw}; 1322 delete $self->{_rw};
1328 $self->{_eof} = 1; 1323 $self->{_eof} = 1;
1329 &_freetls; 1324 &_freetls;
1330 } 1325 }
1331 1326
1332 $self->{rbuf} .= $buf; 1327 $self->{rbuf} .= $tmp;
1333 $self->_drain_rbuf unless $self->{_in_drain}; 1328 $self->_drain_rbuf unless $self->{_in_drain};
1334 $self->{tls} or return; # tls session might have gone away in callback 1329 $self->{tls} or return; # tls session might have gone away in callback
1335 } 1330 }
1336 1331
1337 my $err = Net::SSLeay::get_error ($self->{tls}, -1); 1332 $tmp = Net::SSLeay::get_error ($self->{tls}, -1);
1338 1333
1339 if ($err!= Net::SSLeay::ERROR_WANT_READ ()) { 1334 if ($tmp != Net::SSLeay::ERROR_WANT_READ ()) {
1340 if ($err == Net::SSLeay::ERROR_SYSCALL ()) { 1335 if ($tmp == Net::SSLeay::ERROR_SYSCALL ()) {
1341 return $self->_error ($!, 1); 1336 return $self->_error ($!, 1);
1342 } elsif ($err == Net::SSLeay::ERROR_SSL ()) { 1337 } elsif ($tmp == Net::SSLeay::ERROR_SSL ()) {
1343 return $self->_error (&Errno::EIO, 1); 1338 return $self->_error (&Errno::EIO, 1);
1344 } 1339 }
1345 1340
1346 # all others are fine for our purposes 1341 # all other errors are fine for our purposes
1347 } 1342 }
1348 1343
1349 while (length ($buf = Net::SSLeay::BIO_read ($self->{_wbio}))) { 1344 while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) {
1350 $self->{wbuf} .= $buf; 1345 $self->{wbuf} .= $tmp;
1351 $self->_drain_wbuf; 1346 $self->_drain_wbuf;
1352 } 1347 }
1353} 1348}
1354 1349
1355=item $handle->starttls ($tls[, $tls_ctx]) 1350=item $handle->starttls ($tls[, $tls_ctx])
… …
1475 @linger = (); 1470 @linger = ();
1476 }); 1471 });
1477 } 1472 }
1478} 1473}
1479 1474
1475=item $handle->destroy
1476
1477Shut's down the handle object as much as possible - this call ensures that
1478no further callbacks will be invoked and resources will be freed as much
1479as possible. You must not call any methods on the object afterwards.
1480
1481The handle might still linger in the background and write out remaining
1482data, as specified by the C<linger> option, however.
1483
1484=cut
1485
1486sub destroy {
1487 my ($self) = @_;
1488
1489 $self->DESTROY;
1490 %$self = ();
1491}
1492
1480=item AnyEvent::Handle::TLS_CTX 1493=item AnyEvent::Handle::TLS_CTX
1481 1494
1482This function creates and returns the Net::SSLeay::CTX object used by 1495This function creates and returns the Net::SSLeay::CTX object used by
1483default for TLS mode. 1496default for TLS mode.
1484 1497
… …
1555 $handle->on_drain (sub { 1568 $handle->on_drain (sub {
1556 warn "all data submitted to the kernel\n"; 1569 warn "all data submitted to the kernel\n";
1557 undef $handle; 1570 undef $handle;
1558 }); 1571 });
1559 1572
1573=item I get different callback invocations in TLS mode/Why can't I pause
1574reading?
1575
1576Unlike, say, TCP, TLS conenctions do not consist of two independent
1577communication channels, one for each direction. Or put differently. the
1578read and write directions are not independent of each other: you cannot
1579write data unless you are also prepared to read, and vice versa.
1580
1581This can mean than, in TLS mode, you might get C<on_error> or C<on_eof>
1582callback invocations when you are not expecting any read data - the reason
1583is that AnyEvent::Handle always reads in TLS mode.
1584
1585During the connection, you have to make sure that you always have a
1586non-empty read-queue, or an C<on_read> watcher. At the end of the
1587connection (or when you no longer want to use it) you can call the
1588C<destroy> method.
1589
1560=back 1590=back
1561 1591
1562 1592
1563=head1 SUBCLASSING AnyEvent::Handle 1593=head1 SUBCLASSING AnyEvent::Handle
1564 1594

Diff Legend

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