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.108 by root, Tue Jan 6 20:08:05 2009 UTC vs.
Revision 1.134 by root, Fri Jul 3 00:09:04 2009 UTC

… …
14 14
15AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent 15AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
16 16
17=cut 17=cut
18 18
19our $VERSION = 4.331; 19our $VERSION = 4.45;
20 20
21=head1 SYNOPSIS 21=head1 SYNOPSIS
22 22
23 use AnyEvent; 23 use AnyEvent;
24 use AnyEvent::Handle; 24 use AnyEvent::Handle;
… …
63 63
64=head1 METHODS 64=head1 METHODS
65 65
66=over 4 66=over 4
67 67
68=item B<new (%args)> 68=item $handle = B<new> AnyEvent::TLS fh => $filehandle, key => value...
69 69
70The constructor supports these arguments (all as key => value pairs). 70The constructor supports these arguments (all as C<< key => value >> pairs).
71 71
72=over 4 72=over 4
73 73
74=item fh => $filehandle [MANDATORY] 74=item fh => $filehandle [MANDATORY]
75 75
… …
95waiting for data. 95waiting for data.
96 96
97If an EOF condition has been detected but no C<on_eof> callback has been 97If an EOF condition has been detected but no C<on_eof> callback has been
98set, then a fatal error will be raised with C<$!> set to <0>. 98set, then a fatal error will be raised with C<$!> set to <0>.
99 99
100=item on_error => $cb->($handle, $fatal) 100=item on_error => $cb->($handle, $fatal, $message)
101 101
102This is the error callback, which is called when, well, some error 102This is the error callback, which is called when, well, some error
103occured, such as not being able to resolve the hostname, failure to 103occured, such as not being able to resolve the hostname, failure to
104connect or a read error. 104connect or a read error.
105 105
… …
107fatal errors the handle object will be shut down and will not be usable 107fatal errors the handle object will be shut down and will not be usable
108(but you are free to look at the current C<< ->rbuf >>). Examples of fatal 108(but you are free to look at the current C<< ->rbuf >>). Examples of fatal
109errors are an EOF condition with active (but unsatisifable) read watchers 109errors are an EOF condition with active (but unsatisifable) read watchers
110(C<EPIPE>) or I/O errors. 110(C<EPIPE>) or I/O errors.
111 111
112AnyEvent::Handle tries to find an appropriate error code for you to check
113against, but in some cases (TLS errors), this does not work well. It is
114recommended to always output the C<$message> argument in human-readable
115error messages (it's usually the same as C<"$!">).
116
112Non-fatal errors can be retried by simply returning, but it is recommended 117Non-fatal errors can be retried by simply returning, but it is recommended
113to simply ignore this parameter and instead abondon the handle object 118to simply ignore this parameter and instead abondon the handle object
114when this callback is invoked. Examples of non-fatal errors are timeouts 119when this callback is invoked. Examples of non-fatal errors are timeouts
115C<ETIMEDOUT>) or badly-formatted data (C<EBADMSG>). 120C<ETIMEDOUT>) or badly-formatted data (C<EBADMSG>).
116 121
117On callback entrance, the value of C<$!> contains the operating system 122On callback entrance, the value of C<$!> contains the operating system
118error (or C<ENOSPC>, C<EPIPE>, C<ETIMEDOUT> or C<EBADMSG>). 123error code (or C<ENOSPC>, C<EPIPE>, C<ETIMEDOUT>, C<EBADMSG> or
124C<EPROTO>).
119 125
120While not mandatory, it is I<highly> recommended to set this callback, as 126While not mandatory, it is I<highly> recommended to set this callback, as
121you will not be notified of errors otherwise. The default simply calls 127you will not be notified of errors otherwise. The default simply calls
122C<croak>. 128C<croak>.
123 129
… …
127and no read request is in the queue (unlike read queue callbacks, this 133and no read request is in the queue (unlike read queue callbacks, this
128callback will only be called when at least one octet of data is in the 134callback will only be called when at least one octet of data is in the
129read buffer). 135read buffer).
130 136
131To access (and remove data from) the read buffer, use the C<< ->rbuf >> 137To access (and remove data from) the read buffer, use the C<< ->rbuf >>
132method or access the C<$handle->{rbuf}> member directly. 138method or access the C<$handle->{rbuf}> member directly. Note that you
139must not enlarge or modify the read buffer, you can only remove data at
140the beginning from it.
133 141
134When an EOF condition is detected then AnyEvent::Handle will first try to 142When an EOF condition is detected then AnyEvent::Handle will first try to
135feed all the remaining data to the queued callbacks and C<on_read> before 143feed all the remaining data to the queued callbacks and C<on_read> before
136calling the C<on_eof> callback. If no progress can be made, then a fatal 144calling the C<on_eof> callback. If no progress can be made, then a fatal
137error will be raised (with C<$!> set to C<EPIPE>). 145error will be raised (with C<$!> set to C<EPIPE>).
… …
235 243
236This will not work for partial TLS data that could not be encoded 244This will not work for partial TLS data that could not be encoded
237yet. This data will be lost. Calling the C<stoptls> method in time might 245yet. This data will be lost. Calling the C<stoptls> method in time might
238help. 246help.
239 247
248=item peername => $string
249
250A string used to identify the remote site - usually the DNS hostname
251(I<not> IDN!) used to create the connection, rarely the IP address.
252
253Apart from being useful in error messages, this string is also used in TLS
254common name verification (see C<verify_cn> in L<AnyEvent::TLS>).
255
240=item tls => "accept" | "connect" | Net::SSLeay::SSL object 256=item tls => "accept" | "connect" | Net::SSLeay::SSL object
241 257
242When this parameter is given, it enables TLS (SSL) mode, that means 258When this parameter is given, it enables TLS (SSL) mode, that means
243AnyEvent will start a TLS handshake as soon as the conenction has been 259AnyEvent will start a TLS handshake as soon as the conenction has been
244established and will transparently encrypt/decrypt data afterwards. 260established and will transparently encrypt/decrypt data afterwards.
261
262All TLS protocol errors will be signalled as C<EPROTO>, with an
263appropriate error message.
245 264
246TLS mode requires Net::SSLeay to be installed (it will be loaded 265TLS mode requires Net::SSLeay to be installed (it will be loaded
247automatically when you try to create a TLS handle): this module doesn't 266automatically when you try to create a TLS handle): this module doesn't
248have a dependency on that module, so if your module requires it, you have 267have a dependency on that module, so if your module requires it, you have
249to add the dependency yourself. 268to add the dependency yourself.
… …
253mode. 272mode.
254 273
255You can also provide your own TLS connection object, but you have 274You can also provide your own TLS connection object, but you have
256to make sure that you call either C<Net::SSLeay::set_connect_state> 275to make sure that you call either C<Net::SSLeay::set_connect_state>
257or C<Net::SSLeay::set_accept_state> on it before you pass it to 276or C<Net::SSLeay::set_accept_state> on it before you pass it to
258AnyEvent::Handle. 277AnyEvent::Handle. Also, this module will take ownership of this connection
278object.
279
280At some future point, AnyEvent::Handle might switch to another TLS
281implementation, then the option to use your own session object will go
282away.
283
284B<IMPORTANT:> since Net::SSLeay "objects" are really only integers,
285passing in the wrong integer will lead to certain crash. This most often
286happens when one uses a stylish C<< tls => 1 >> and is surprised about the
287segmentation fault.
259 288
260See the C<< ->starttls >> method for when need to start TLS negotiation later. 289See the C<< ->starttls >> method for when need to start TLS negotiation later.
261 290
262=item tls_ctx => $ssl_ctx 291=item tls_ctx => $anyevent_tls
263 292
264Use the given C<Net::SSLeay::CTX> object to create the new TLS connection 293Use the given C<AnyEvent::TLS> object to create the new TLS connection
265(unless a connection object was specified directly). If this parameter is 294(unless a connection object was specified directly). If this parameter is
266missing, then AnyEvent::Handle will use C<AnyEvent::Handle::TLS_CTX>. 295missing, then AnyEvent::Handle will use C<AnyEvent::Handle::TLS_CTX>.
296
297Instead of an object, you can also specify a hash reference with C<< key
298=> value >> pairs. Those will be passed to L<AnyEvent::TLS> to create a
299new TLS context object.
267 300
268=item json => JSON or JSON::XS object 301=item json => JSON or JSON::XS object
269 302
270This is the json coder object used by the C<json> read and write types. 303This is the json coder object used by the C<json> read and write types.
271 304
… …
280 313
281=cut 314=cut
282 315
283sub new { 316sub new {
284 my $class = shift; 317 my $class = shift;
285
286 my $self = bless { @_ }, $class; 318 my $self = bless { @_ }, $class;
287 319
288 $self->{fh} or Carp::croak "mandatory argument fh is missing"; 320 $self->{fh} or Carp::croak "mandatory argument fh is missing";
289 321
290 AnyEvent::Util::fh_nonblocking $self->{fh}, 1; 322 AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
323
324 $self->{_activity} = AnyEvent->now;
325 $self->_timeout;
326
327 $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
291 328
292 $self->starttls (delete $self->{tls}, delete $self->{tls_ctx}) 329 $self->starttls (delete $self->{tls}, delete $self->{tls_ctx})
293 if $self->{tls}; 330 if $self->{tls};
294 331
295 $self->{_activity} = AnyEvent->now;
296 $self->_timeout;
297
298 $self->on_drain (delete $self->{on_drain}) if exists $self->{on_drain}; 332 $self->on_drain (delete $self->{on_drain}) if exists $self->{on_drain};
299 $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
300 333
301 $self->start_read 334 $self->start_read
302 if $self->{on_read}; 335 if $self->{on_read};
303 336
304 $self 337 $self->{fh} && $self
305} 338}
306 339
307sub _shutdown { 340sub _shutdown {
308 my ($self) = @_; 341 my ($self) = @_;
309 342
310 delete $self->{_tw}; 343 delete @$self{qw(_tw _rw _ww fh wbuf on_read _queue)};
311 delete $self->{_rw}; 344 $self->{_eof} = 1; # tell starttls et. al to stop trying
312 delete $self->{_ww};
313 delete $self->{fh};
314 345
315 &_freetls; 346 &_freetls;
316
317 delete $self->{on_read};
318 delete $self->{_queue};
319} 347}
320 348
321sub _error { 349sub _error {
322 my ($self, $errno, $fatal) = @_; 350 my ($self, $errno, $fatal, $message) = @_;
323 351
324 $self->_shutdown 352 $self->_shutdown
325 if $fatal; 353 if $fatal;
326 354
327 $! = $errno; 355 $! = $errno;
356 $message ||= "$!";
328 357
329 if ($self->{on_error}) { 358 if ($self->{on_error}) {
330 $self->{on_error}($self, $fatal); 359 $self->{on_error}($self, $fatal, $message);
331 } elsif ($self->{fh}) { 360 } elsif ($self->{fh}) {
332 Carp::croak "AnyEvent::Handle uncaught error: $!"; 361 Carp::croak "AnyEvent::Handle uncaught error: $message";
333 } 362 }
334} 363}
335 364
336=item $fh = $handle->fh 365=item $fh = $handle->fh
337 366
… …
649 678
650 pack "w/a*", Storable::nfreeze ($ref) 679 pack "w/a*", Storable::nfreeze ($ref)
651}; 680};
652 681
653=back 682=back
683
684=item $handle->push_shutdown
685
686Sometimes you know you want to close the socket after writing your data
687before it was actually written. One way to do that is to replace your
688C<on_drain> handler by a callback that shuts down the socket. This method
689is a shorthand for just that, and replaces the C<on_drain> callback with:
690
691 sub { shutdown $_[0]{fh}, 1 } # for push_shutdown
692
693This simply shuts down the write side and signals an EOF condition to the
694the peer.
695
696You can rely on the normal read queue and C<on_eof> handling
697afterwards. This is the cleanest way to close a connection.
698
699=cut
700
701sub push_shutdown {
702 $_[0]->{on_drain} = sub { shutdown $_[0]{fh}, 1 };
703}
654 704
655=item AnyEvent::Handle::register_write_type type => $coderef->($handle, @args) 705=item AnyEvent::Handle::register_write_type type => $coderef->($handle, @args)
656 706
657This function (not method) lets you add your own types to C<push_write>. 707This function (not method) lets you add your own types to C<push_write>.
658Whenever the given C<type> is used, C<push_write> will invoke the code 708Whenever the given C<type> is used, C<push_write> will invoke the code
… …
762 ) { 812 ) {
763 $self->_error (&Errno::ENOSPC, 1), return; 813 $self->_error (&Errno::ENOSPC, 1), return;
764 } 814 }
765 815
766 while () { 816 while () {
817 # we need to use a separate tls read buffer, as we must not receive data while
818 # we are draining the buffer, and this can only happen with TLS.
819 $self->{rbuf} .= delete $self->{_tls_rbuf} if exists $self->{_tls_rbuf};
820
767 my $len = length $self->{rbuf}; 821 my $len = length $self->{rbuf};
768 822
769 if (my $cb = shift @{ $self->{_queue} }) { 823 if (my $cb = shift @{ $self->{_queue} }) {
770 unless ($cb->($self)) { 824 unless ($cb->($self)) {
771 if ($self->{_eof}) { 825 if ($self->{_eof}) {
… …
832 886
833=item $handle->rbuf 887=item $handle->rbuf
834 888
835Returns the read buffer (as a modifiable lvalue). 889Returns the read buffer (as a modifiable lvalue).
836 890
837You can access the read buffer directly as the C<< ->{rbuf} >> member, if 891You can access the read buffer directly as the C<< ->{rbuf} >>
838you want. 892member, if you want. However, the only operation allowed on the
893read buffer (apart from looking at it) is removing data from its
894beginning. Otherwise modifying or appending to it is not allowed and will
895lead to hard-to-track-down bugs.
839 896
840NOTE: The read buffer should only be used or modified if the C<on_read>, 897NOTE: The read buffer should only be used or modified if the C<on_read>,
841C<push_read> or C<unshift_read> methods are used. The other read methods 898C<push_read> or C<unshift_read> methods are used. The other read methods
842automatically manage the read buffer. 899automatically manage the read buffer.
843 900
… …
1139 } 1196 }
1140}; 1197};
1141 1198
1142=item json => $cb->($handle, $hash_or_arrayref) 1199=item json => $cb->($handle, $hash_or_arrayref)
1143 1200
1144Reads a JSON object or array, decodes it and passes it to the callback. 1201Reads a JSON object or array, decodes it and passes it to the
1202callback. When a parse error occurs, an C<EBADMSG> error will be raised.
1145 1203
1146If a C<json> object was passed to the constructor, then that will be used 1204If a C<json> object was passed to the constructor, then that will be used
1147for the final decode, otherwise it will create a JSON coder expecting UTF-8. 1205for the final decode, otherwise it will create a JSON coder expecting UTF-8.
1148 1206
1149This read type uses the incremental parser available with JSON version 1207This read type uses the incremental parser available with JSON version
… …
1166 my $rbuf = \$self->{rbuf}; 1224 my $rbuf = \$self->{rbuf};
1167 1225
1168 my $json = $self->{json} ||= JSON->new->utf8; 1226 my $json = $self->{json} ||= JSON->new->utf8;
1169 1227
1170 sub { 1228 sub {
1171 my $ref = $json->incr_parse ($self->{rbuf}); 1229 my $ref = eval { $json->incr_parse ($self->{rbuf}) };
1172 1230
1173 if ($ref) { 1231 if ($ref) {
1174 $self->{rbuf} = $json->incr_text; 1232 $self->{rbuf} = $json->incr_text;
1175 $json->incr_text = ""; 1233 $json->incr_text = "";
1176 $cb->($self, $ref); 1234 $cb->($self, $ref);
1177 1235
1178 1 1236 1
1237 } elsif ($@) {
1238 # error case
1239 $json->incr_skip;
1240
1241 $self->{rbuf} = $json->incr_text;
1242 $json->incr_text = "";
1243
1244 $self->_error (&Errno::EBADMSG);
1245
1246 ()
1179 } else { 1247 } else {
1180 $self->{rbuf} = ""; 1248 $self->{rbuf} = "";
1249
1181 () 1250 ()
1182 } 1251 }
1183 } 1252 }
1184}; 1253};
1185 1254
… …
1306 } 1375 }
1307 }); 1376 });
1308 } 1377 }
1309} 1378}
1310 1379
1380our $ERROR_SYSCALL;
1381our $ERROR_WANT_READ;
1382our $ERROR_ZERO_RETURN;
1383
1384sub _tls_error {
1385 my ($self, $err) = @_;
1386 warn "$err,$!\n";#d#
1387
1388 return $self->_error ($!, 1)
1389 if $err == Net::SSLeay::ERROR_SYSCALL ();
1390
1391 $self->_error (&Errno::EPROTO, 1,
1392 Net::SSLeay::ERR_error_string (Net::SSLeay::ERR_get_error ()));
1393}
1394
1311# poll the write BIO and send the data if applicable 1395# poll the write BIO and send the data if applicable
1396# also decode read data if possible
1397# this is basiclaly our TLS state machine
1398# more efficient implementations are possible with openssl,
1399# but not with the buggy and incomplete Net::SSLeay.
1312sub _dotls { 1400sub _dotls {
1313 my ($self) = @_; 1401 my ($self) = @_;
1314 1402
1315 my $tmp; 1403 my $tmp;
1316 1404
1317 if (length $self->{_tls_wbuf}) { 1405 if (length $self->{_tls_wbuf}) {
1318 while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) { 1406 while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
1319 substr $self->{_tls_wbuf}, 0, $tmp, ""; 1407 substr $self->{_tls_wbuf}, 0, $tmp, "";
1320 } 1408 }
1409
1410 $tmp = Net::SSLeay::get_error ($self->{tls}, $tmp);
1411 return $self->_tls_error ($tmp)
1412 if $tmp != $ERROR_WANT_READ
1413 && ($tmp != $ERROR_SYSCALL || $!)
1414 && $tmp != $ERROR_ZERO_RETURN;
1321 } 1415 }
1322 1416
1323 while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) { 1417 while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) {
1324 unless (length $tmp) { 1418 unless (length $tmp) {
1325 # let's treat SSL-eof as we treat normal EOF 1419 # let's treat SSL-eof as we treat normal EOF
1326 delete $self->{_rw}; 1420 delete $self->{_rw};
1327 $self->{_eof} = 1; 1421 $self->{_eof} = 1;
1328 &_freetls; 1422 &_freetls;
1329 } 1423 }
1330 1424
1331 $self->{rbuf} .= $tmp; 1425 $self->{_tls_rbuf} .= $tmp;
1332 $self->_drain_rbuf unless $self->{_in_drain}; 1426 $self->_drain_rbuf unless $self->{_in_drain};
1333 $self->{tls} or return; # tls session might have gone away in callback 1427 $self->{tls} or return; # tls session might have gone away in callback
1334 } 1428 }
1335 1429
1336 $tmp = Net::SSLeay::get_error ($self->{tls}, -1); 1430 $tmp = Net::SSLeay::get_error ($self->{tls}, -1);
1337
1338 if ($tmp != Net::SSLeay::ERROR_WANT_READ ()) {
1339 if ($tmp == Net::SSLeay::ERROR_SYSCALL ()) {
1340 return $self->_error ($!, 1); 1431 return $self->_tls_error ($tmp)
1341 } elsif ($tmp == Net::SSLeay::ERROR_SSL ()) { 1432 if $tmp != $ERROR_WANT_READ
1342 return $self->_error (&Errno::EIO, 1); 1433 && ($tmp != $ERROR_SYSCALL || $!)
1343 } 1434 && $tmp != $ERROR_ZERO_RETURN;
1344
1345 # all other errors are fine for our purposes
1346 }
1347 1435
1348 while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) { 1436 while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) {
1349 $self->{wbuf} .= $tmp; 1437 $self->{wbuf} .= $tmp;
1350 $self->_drain_wbuf; 1438 $self->_drain_wbuf;
1351 } 1439 }
… …
1358C<starttls>. 1446C<starttls>.
1359 1447
1360The first argument is the same as the C<tls> constructor argument (either 1448The first argument is the same as the C<tls> constructor argument (either
1361C<"connect">, C<"accept"> or an existing Net::SSLeay object). 1449C<"connect">, C<"accept"> or an existing Net::SSLeay object).
1362 1450
1363The second argument is the optional C<Net::SSLeay::CTX> object that is 1451The second argument is the optional C<AnyEvent::TLS> object that is used
1364used when AnyEvent::Handle has to create its own TLS connection object. 1452when AnyEvent::Handle has to create its own TLS connection object, or
1453a hash reference with C<< key => value >> pairs that will be used to
1454construct a new context.
1365 1455
1366The TLS connection object will end up in C<< $handle->{tls} >> after this 1456The TLS connection object will end up in C<< $handle->{tls} >>, the TLS
1367call and can be used or changed to your liking. Note that the handshake 1457context in C<< $handle->{tls_ctx} >> after this call and can be used or
1368might have already started when this function returns. 1458changed to your liking. Note that the handshake might have already started
1459when this function returns.
1369 1460
1370If it an error to start a TLS handshake more than once per 1461If it an error to start a TLS handshake more than once per
1371AnyEvent::Handle object (this is due to bugs in OpenSSL). 1462AnyEvent::Handle object (this is due to bugs in OpenSSL).
1372 1463
1373=cut 1464=cut
… …
1377 1468
1378 require Net::SSLeay; 1469 require Net::SSLeay;
1379 1470
1380 Carp::croak "it is an error to call starttls more than once on an AnyEvent::Handle object" 1471 Carp::croak "it is an error to call starttls more than once on an AnyEvent::Handle object"
1381 if $self->{tls}; 1472 if $self->{tls};
1473
1474 $ERROR_SYSCALL = Net::SSLeay::ERROR_SYSCALL ();
1475 $ERROR_WANT_READ = Net::SSLeay::ERROR_WANT_READ ();
1476 $ERROR_ZERO_RETURN = Net::SSLeay::ERROR_ZERO_RETURN ();
1477
1478 $ctx ||= $self->{tls_ctx};
1479
1480 if ("HASH" eq ref $ctx) {
1481 require AnyEvent::TLS;
1482
1483 local $Carp::CarpLevel = 1; # skip ourselves when creating a new context
1484 $ctx = new AnyEvent::TLS %$ctx;
1485 }
1382 1486
1383 if ($ssl eq "accept") { 1487 $self->{tls_ctx} = $ctx || TLS_CTX ();
1384 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ()); 1488 $self->{tls} = $ssl = $self->{tls_ctx}->_get_session ($ssl, $self, $self->{peername});
1385 Net::SSLeay::set_accept_state ($ssl);
1386 } elsif ($ssl eq "connect") {
1387 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
1388 Net::SSLeay::set_connect_state ($ssl);
1389 }
1390
1391 $self->{tls} = $ssl;
1392 1489
1393 # basically, this is deep magic (because SSL_read should have the same issues) 1490 # basically, this is deep magic (because SSL_read should have the same issues)
1394 # but the openssl maintainers basically said: "trust us, it just works". 1491 # but the openssl maintainers basically said: "trust us, it just works".
1395 # (unfortunately, we have to hardcode constants because the abysmally misdesigned 1492 # (unfortunately, we have to hardcode constants because the abysmally misdesigned
1396 # and mismaintained ssleay-module doesn't even offer them). 1493 # and mismaintained ssleay-module doesn't even offer them).
… …
1400 # 1497 #
1401 # note that we do not try to keep the length constant between writes as we are required to do. 1498 # note that we do not try to keep the length constant between writes as we are required to do.
1402 # we assume that most (but not all) of this insanity only applies to non-blocking cases, 1499 # we assume that most (but not all) of this insanity only applies to non-blocking cases,
1403 # and we drive openssl fully in blocking mode here. Or maybe we don't - openssl seems to 1500 # and we drive openssl fully in blocking mode here. Or maybe we don't - openssl seems to
1404 # have identity issues in that area. 1501 # have identity issues in that area.
1405 Net::SSLeay::CTX_set_mode ($self->{tls}, 1502# Net::SSLeay::CTX_set_mode ($ssl,
1406 (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1) 1503# (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
1407 | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2)); 1504# | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
1505 Net::SSLeay::CTX_set_mode ($ssl, 1|2);
1408 1506
1409 $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ()); 1507 $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
1410 $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ()); 1508 $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
1411 1509
1412 Net::SSLeay::set_bio ($ssl, $self->{_rbio}, $self->{_wbio}); 1510 Net::SSLeay::set_bio ($ssl, $self->{_rbio}, $self->{_wbio});
… …
1441sub _freetls { 1539sub _freetls {
1442 my ($self) = @_; 1540 my ($self) = @_;
1443 1541
1444 return unless $self->{tls}; 1542 return unless $self->{tls};
1445 1543
1446 Net::SSLeay::free (delete $self->{tls}); 1544 $self->{tls_ctx}->_put_session (delete $self->{tls});
1447 1545
1448 delete @$self{qw(_rbio _wbio _tls_wbuf)}; 1546 delete @$self{qw(_rbio _wbio _tls_wbuf)};
1449} 1547}
1450 1548
1451sub DESTROY { 1549sub DESTROY {
1452 my $self = shift; 1550 my ($self) = @_;
1453 1551
1454 &_freetls; 1552 &_freetls;
1455 1553
1456 my $linger = exists $self->{linger} ? $self->{linger} : 3600; 1554 my $linger = exists $self->{linger} ? $self->{linger} : 3600;
1457 1555
… …
1501 %$self = (); 1599 %$self = ();
1502} 1600}
1503 1601
1504=item AnyEvent::Handle::TLS_CTX 1602=item AnyEvent::Handle::TLS_CTX
1505 1603
1506This function creates and returns the Net::SSLeay::CTX object used by 1604This function creates and returns the AnyEvent::TLS object used by default
1507default for TLS mode. 1605for TLS mode.
1508 1606
1509The context is created like this: 1607The context is created by calling L<AnyEvent::TLS> without any arguments.
1510
1511 Net::SSLeay::load_error_strings;
1512 Net::SSLeay::SSLeay_add_ssl_algorithms;
1513 Net::SSLeay::randomize;
1514
1515 my $CTX = Net::SSLeay::CTX_new;
1516
1517 Net::SSLeay::CTX_set_options $CTX, Net::SSLeay::OP_ALL
1518 1608
1519=cut 1609=cut
1520 1610
1521our $TLS_CTX; 1611our $TLS_CTX;
1522 1612
1523sub TLS_CTX() { 1613sub TLS_CTX() {
1524 $TLS_CTX || do { 1614 $TLS_CTX ||= do {
1525 require Net::SSLeay; 1615 require AnyEvent::TLS;
1526 1616
1527 Net::SSLeay::load_error_strings (); 1617 new AnyEvent::TLS
1528 Net::SSLeay::SSLeay_add_ssl_algorithms ();
1529 Net::SSLeay::randomize ();
1530
1531 $TLS_CTX = Net::SSLeay::CTX_new ();
1532
1533 Net::SSLeay::CTX_set_options ($TLS_CTX, Net::SSLeay::OP_ALL ());
1534
1535 $TLS_CTX
1536 } 1618 }
1537} 1619}
1538 1620
1539=back 1621=back
1540 1622

Diff Legend

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