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.111 by root, Wed Jan 21 06:01:29 2009 UTC vs.
Revision 1.139 by root, Sun Jul 5 23:39:48 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.452;
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
254peername verification (see C<verify_peername> 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.
259 283
260B<IMPORTANT:> since Net::SSLeay "objects" are really only integers, 284B<IMPORTANT:> since Net::SSLeay "objects" are really only integers,
261passing in the wrong integer will lead to certain crash. This most often 285passing in the wrong integer will lead to certain crash. This most often
262happens when one uses a stylish C<< tls => 1 >> and is surprised about the 286happens when one uses a stylish C<< tls => 1 >> and is surprised about the
263segmentation fault. 287segmentation fault.
264 288
265See 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.
266 290
267=item tls_ctx => $ssl_ctx 291=item tls_ctx => $anyevent_tls
268 292
269Use 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
270(unless a connection object was specified directly). If this parameter is 294(unless a connection object was specified directly). If this parameter is
271missing, 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.
272 300
273=item json => JSON or JSON::XS object 301=item json => JSON or JSON::XS object
274 302
275This 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.
276 304
… …
285 313
286=cut 314=cut
287 315
288sub new { 316sub new {
289 my $class = shift; 317 my $class = shift;
290
291 my $self = bless { @_ }, $class; 318 my $self = bless { @_ }, $class;
292 319
293 $self->{fh} or Carp::croak "mandatory argument fh is missing"; 320 $self->{fh} or Carp::croak "mandatory argument fh is missing";
294 321
295 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};
296 328
297 $self->starttls (delete $self->{tls}, delete $self->{tls_ctx}) 329 $self->starttls (delete $self->{tls}, delete $self->{tls_ctx})
298 if $self->{tls}; 330 if $self->{tls};
299 331
300 $self->{_activity} = AnyEvent->now;
301 $self->_timeout;
302
303 $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};
304 $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
305 333
306 $self->start_read 334 $self->start_read
307 if $self->{on_read}; 335 if $self->{on_read};
308 336
309 $self 337 $self->{fh} && $self
310} 338}
311 339
312sub _shutdown { 340sub _shutdown {
313 my ($self) = @_; 341 my ($self) = @_;
314 342
315 delete $self->{_tw}; 343 delete @$self{qw(_tw _rw _ww fh wbuf on_read _queue)};
316 delete $self->{_rw}; 344 $self->{_eof} = 1; # tell starttls et. al to stop trying
317 delete $self->{_ww};
318 delete $self->{fh};
319 345
320 &_freetls; 346 &_freetls;
321
322 delete $self->{on_read};
323 delete $self->{_queue};
324} 347}
325 348
326sub _error { 349sub _error {
327 my ($self, $errno, $fatal) = @_; 350 my ($self, $errno, $fatal, $message) = @_;
328 351
329 $self->_shutdown 352 $self->_shutdown
330 if $fatal; 353 if $fatal;
331 354
332 $! = $errno; 355 $! = $errno;
356 $message ||= "$!";
333 357
334 if ($self->{on_error}) { 358 if ($self->{on_error}) {
335 $self->{on_error}($self, $fatal); 359 $self->{on_error}($self, $fatal, $message);
336 } elsif ($self->{fh}) { 360 } elsif ($self->{fh}) {
337 Carp::croak "AnyEvent::Handle uncaught error: $!"; 361 Carp::croak "AnyEvent::Handle uncaught error: $message";
338 } 362 }
339} 363}
340 364
341=item $fh = $handle->fh 365=item $fh = $handle->fh
342 366
… …
654 678
655 pack "w/a*", Storable::nfreeze ($ref) 679 pack "w/a*", Storable::nfreeze ($ref)
656}; 680};
657 681
658=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}
659 704
660=item AnyEvent::Handle::register_write_type type => $coderef->($handle, @args) 705=item AnyEvent::Handle::register_write_type type => $coderef->($handle, @args)
661 706
662This 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>.
663Whenever 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
… …
767 ) { 812 ) {
768 $self->_error (&Errno::ENOSPC, 1), return; 813 $self->_error (&Errno::ENOSPC, 1), return;
769 } 814 }
770 815
771 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
772 my $len = length $self->{rbuf}; 821 my $len = length $self->{rbuf};
773 822
774 if (my $cb = shift @{ $self->{_queue} }) { 823 if (my $cb = shift @{ $self->{_queue} }) {
775 unless ($cb->($self)) { 824 unless ($cb->($self)) {
776 if ($self->{_eof}) { 825 if ($self->{_eof}) {
… …
837 886
838=item $handle->rbuf 887=item $handle->rbuf
839 888
840Returns the read buffer (as a modifiable lvalue). 889Returns the read buffer (as a modifiable lvalue).
841 890
842You can access the read buffer directly as the C<< ->{rbuf} >> member, if 891You can access the read buffer directly as the C<< ->{rbuf} >>
843you 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.
844 896
845NOTE: 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>,
846C<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
847automatically manage the read buffer. 899automatically manage the read buffer.
848 900
… …
1164=cut 1216=cut
1165 1217
1166register_read_type json => sub { 1218register_read_type json => sub {
1167 my ($self, $cb) = @_; 1219 my ($self, $cb) = @_;
1168 1220
1169 require JSON; 1221 my $json = $self->{json} ||=
1222 eval { require JSON::XS; JSON::XS->new->utf8 }
1223 || do { require JSON; JSON->new->utf8 };
1170 1224
1171 my $data; 1225 my $data;
1172 my $rbuf = \$self->{rbuf}; 1226 my $rbuf = \$self->{rbuf};
1173 1227
1174 my $json = $self->{json} ||= JSON->new->utf8;
1175
1176 sub { 1228 sub {
1177 eval {
1178 my $ref = $json->incr_parse ($self->{rbuf}); 1229 my $ref = eval { $json->incr_parse ($self->{rbuf}) };
1179 1230
1180 if ($ref) { 1231 if ($ref) {
1181 $self->{rbuf} = $json->incr_text; 1232 $self->{rbuf} = $json->incr_text;
1182 $json->incr_text = ""; 1233 $json->incr_text = "";
1183 $cb->($self, $ref); 1234 $cb->($self, $ref);
1184
1185 1
1186 } else {
1187 $self->{rbuf} = "";
1188 ()
1189 }
1190 1235
1191 1 1236 1
1192 } or do { 1237 } elsif ($@) {
1193 # error case 1238 # error case
1194 $json->incr_skip; 1239 $json->incr_skip;
1195 1240
1196 $self->{rbuf} = $json->incr_text; 1241 $self->{rbuf} = $json->incr_text;
1197 $json->incr_text = ""; 1242 $json->incr_text = "";
1198 1243
1199 $self->_error (&Errno::EBADMSG); 1244 $self->_error (&Errno::EBADMSG);
1245
1246 ()
1247 } else {
1248 $self->{rbuf} = "";
1249
1250 ()
1200 }; 1251 }
1201
1202 } 1252 }
1203}; 1253};
1204 1254
1205=item storable => $cb->($handle, $ref) 1255=item storable => $cb->($handle, $ref)
1206 1256
… …
1325 } 1375 }
1326 }); 1376 });
1327 } 1377 }
1328} 1378}
1329 1379
1380our $ERROR_SYSCALL;
1381our $ERROR_WANT_READ;
1382our $ERROR_ZERO_RETURN;
1383
1384sub _tls_error {
1385 my ($self, $err) = @_;
1386
1387 return $self->_error ($!, 1)
1388 if $err == Net::SSLeay::ERROR_SYSCALL ();
1389
1390 my $err =Net::SSLeay::ERR_error_string (Net::SSLeay::ERR_get_error ());
1391
1392 # reduce error string to look less scary
1393 $err =~ s/^error:[0-9a-fA-F]{8}:[^:]+:([^:]+):/\L$1: /;
1394
1395 $self->_error (&Errno::EPROTO, 1, $err);
1396}
1397
1330# poll the write BIO and send the data if applicable 1398# poll the write BIO and send the data if applicable
1399# also decode read data if possible
1400# this is basiclaly our TLS state machine
1401# more efficient implementations are possible with openssl,
1402# but not with the buggy and incomplete Net::SSLeay.
1331sub _dotls { 1403sub _dotls {
1332 my ($self) = @_; 1404 my ($self) = @_;
1333 1405
1334 my $tmp; 1406 my $tmp;
1335 1407
1336 if (length $self->{_tls_wbuf}) { 1408 if (length $self->{_tls_wbuf}) {
1337 while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) { 1409 while (($tmp = Net::SSLeay::write ($self->{tls}, $self->{_tls_wbuf})) > 0) {
1338 substr $self->{_tls_wbuf}, 0, $tmp, ""; 1410 substr $self->{_tls_wbuf}, 0, $tmp, "";
1339 } 1411 }
1412
1413 $tmp = Net::SSLeay::get_error ($self->{tls}, $tmp);
1414 return $self->_tls_error ($tmp)
1415 if $tmp != $ERROR_WANT_READ
1416 && ($tmp != $ERROR_SYSCALL || $!)
1417 && $tmp != $ERROR_ZERO_RETURN;
1340 } 1418 }
1341 1419
1342 while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) { 1420 while (defined ($tmp = Net::SSLeay::read ($self->{tls}))) {
1343 unless (length $tmp) { 1421 unless (length $tmp) {
1344 # let's treat SSL-eof as we treat normal EOF 1422 # let's treat SSL-eof as we treat normal EOF
1345 delete $self->{_rw}; 1423 delete $self->{_rw};
1346 $self->{_eof} = 1; 1424 $self->{_eof} = 1;
1347 &_freetls; 1425 &_freetls;
1348 } 1426 }
1349 1427
1350 $self->{rbuf} .= $tmp; 1428 $self->{_tls_rbuf} .= $tmp;
1351 $self->_drain_rbuf unless $self->{_in_drain}; 1429 $self->_drain_rbuf unless $self->{_in_drain};
1352 $self->{tls} or return; # tls session might have gone away in callback 1430 $self->{tls} or return; # tls session might have gone away in callback
1353 } 1431 }
1354 1432
1355 $tmp = Net::SSLeay::get_error ($self->{tls}, -1); 1433 $tmp = Net::SSLeay::get_error ($self->{tls}, -1);
1356
1357 if ($tmp != Net::SSLeay::ERROR_WANT_READ ()) {
1358 if ($tmp == Net::SSLeay::ERROR_SYSCALL ()) {
1359 return $self->_error ($!, 1); 1434 return $self->_tls_error ($tmp)
1360 } elsif ($tmp == Net::SSLeay::ERROR_SSL ()) { 1435 if $tmp != $ERROR_WANT_READ
1361 return $self->_error (&Errno::EIO, 1); 1436 && ($tmp != $ERROR_SYSCALL || $!)
1362 } 1437 && $tmp != $ERROR_ZERO_RETURN;
1363
1364 # all other errors are fine for our purposes
1365 }
1366 1438
1367 while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) { 1439 while (length ($tmp = Net::SSLeay::BIO_read ($self->{_wbio}))) {
1368 $self->{wbuf} .= $tmp; 1440 $self->{wbuf} .= $tmp;
1369 $self->_drain_wbuf; 1441 $self->_drain_wbuf;
1370 } 1442 }
… …
1377C<starttls>. 1449C<starttls>.
1378 1450
1379The first argument is the same as the C<tls> constructor argument (either 1451The first argument is the same as the C<tls> constructor argument (either
1380C<"connect">, C<"accept"> or an existing Net::SSLeay object). 1452C<"connect">, C<"accept"> or an existing Net::SSLeay object).
1381 1453
1382The second argument is the optional C<Net::SSLeay::CTX> object that is 1454The second argument is the optional C<AnyEvent::TLS> object that is used
1383used when AnyEvent::Handle has to create its own TLS connection object. 1455when AnyEvent::Handle has to create its own TLS connection object, or
1456a hash reference with C<< key => value >> pairs that will be used to
1457construct a new context.
1384 1458
1385The TLS connection object will end up in C<< $handle->{tls} >> after this 1459The TLS connection object will end up in C<< $handle->{tls} >>, the TLS
1386call and can be used or changed to your liking. Note that the handshake 1460context in C<< $handle->{tls_ctx} >> after this call and can be used or
1387might have already started when this function returns. 1461changed to your liking. Note that the handshake might have already started
1462when this function returns.
1388 1463
1389If it an error to start a TLS handshake more than once per 1464If it an error to start a TLS handshake more than once per
1390AnyEvent::Handle object (this is due to bugs in OpenSSL). 1465AnyEvent::Handle object (this is due to bugs in OpenSSL).
1391 1466
1392=cut 1467=cut
1393 1468
1469our %TLS_CACHE; #TODO not yet documented, should we?
1470
1394sub starttls { 1471sub starttls {
1395 my ($self, $ssl, $ctx) = @_; 1472 my ($self, $ssl, $ctx) = @_;
1396 1473
1397 require Net::SSLeay; 1474 require Net::SSLeay;
1398 1475
1399 Carp::croak "it is an error to call starttls more than once on an AnyEvent::Handle object" 1476 Carp::croak "it is an error to call starttls more than once on an AnyEvent::Handle object"
1400 if $self->{tls}; 1477 if $self->{tls};
1478
1479 $ERROR_SYSCALL = Net::SSLeay::ERROR_SYSCALL ();
1480 $ERROR_WANT_READ = Net::SSLeay::ERROR_WANT_READ ();
1481 $ERROR_ZERO_RETURN = Net::SSLeay::ERROR_ZERO_RETURN ();
1482
1483 $ctx ||= $self->{tls_ctx};
1484
1485 if ("HASH" eq ref $ctx) {
1486 require AnyEvent::TLS;
1487
1488 local $Carp::CarpLevel = 1; # skip ourselves when creating a new context
1489
1490 if ($ctx->{cache}) {
1491 my $key = $ctx+0;
1492 $ctx = $TLS_CACHE{$key} ||= new AnyEvent::TLS %$ctx;
1493 } else {
1494 $ctx = new AnyEvent::TLS %$ctx;
1495 }
1496 }
1401 1497
1402 if ($ssl eq "accept") { 1498 $self->{tls_ctx} = $ctx || TLS_CTX ();
1403 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ()); 1499 $self->{tls} = $ssl = $self->{tls_ctx}->_get_session ($ssl, $self, $self->{peername});
1404 Net::SSLeay::set_accept_state ($ssl);
1405 } elsif ($ssl eq "connect") {
1406 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
1407 Net::SSLeay::set_connect_state ($ssl);
1408 }
1409
1410 $self->{tls} = $ssl;
1411 1500
1412 # basically, this is deep magic (because SSL_read should have the same issues) 1501 # basically, this is deep magic (because SSL_read should have the same issues)
1413 # but the openssl maintainers basically said: "trust us, it just works". 1502 # but the openssl maintainers basically said: "trust us, it just works".
1414 # (unfortunately, we have to hardcode constants because the abysmally misdesigned 1503 # (unfortunately, we have to hardcode constants because the abysmally misdesigned
1415 # and mismaintained ssleay-module doesn't even offer them). 1504 # and mismaintained ssleay-module doesn't even offer them).
… …
1419 # 1508 #
1420 # note that we do not try to keep the length constant between writes as we are required to do. 1509 # note that we do not try to keep the length constant between writes as we are required to do.
1421 # we assume that most (but not all) of this insanity only applies to non-blocking cases, 1510 # we assume that most (but not all) of this insanity only applies to non-blocking cases,
1422 # and we drive openssl fully in blocking mode here. Or maybe we don't - openssl seems to 1511 # and we drive openssl fully in blocking mode here. Or maybe we don't - openssl seems to
1423 # have identity issues in that area. 1512 # have identity issues in that area.
1424 Net::SSLeay::CTX_set_mode ($self->{tls}, 1513# Net::SSLeay::CTX_set_mode ($ssl,
1425 (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1) 1514# (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
1426 | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2)); 1515# | (eval { local $SIG{__DIE__}; Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
1516 Net::SSLeay::CTX_set_mode ($ssl, 1|2);
1427 1517
1428 $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ()); 1518 $self->{_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
1429 $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ()); 1519 $self->{_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
1430 1520
1431 Net::SSLeay::set_bio ($ssl, $self->{_rbio}, $self->{_wbio}); 1521 Net::SSLeay::set_bio ($ssl, $self->{_rbio}, $self->{_wbio});
… …
1460sub _freetls { 1550sub _freetls {
1461 my ($self) = @_; 1551 my ($self) = @_;
1462 1552
1463 return unless $self->{tls}; 1553 return unless $self->{tls};
1464 1554
1465 Net::SSLeay::free (delete $self->{tls}); 1555 $self->{tls_ctx}->_put_session (delete $self->{tls});
1466 1556
1467 delete @$self{qw(_rbio _wbio _tls_wbuf)}; 1557 delete @$self{qw(_rbio _wbio _tls_wbuf)};
1468} 1558}
1469 1559
1470sub DESTROY { 1560sub DESTROY {
1471 my $self = shift; 1561 my ($self) = @_;
1472 1562
1473 &_freetls; 1563 &_freetls;
1474 1564
1475 my $linger = exists $self->{linger} ? $self->{linger} : 3600; 1565 my $linger = exists $self->{linger} ? $self->{linger} : 3600;
1476 1566
… …
1520 %$self = (); 1610 %$self = ();
1521} 1611}
1522 1612
1523=item AnyEvent::Handle::TLS_CTX 1613=item AnyEvent::Handle::TLS_CTX
1524 1614
1525This function creates and returns the Net::SSLeay::CTX object used by 1615This function creates and returns the AnyEvent::TLS object used by default
1526default for TLS mode. 1616for TLS mode.
1527 1617
1528The context is created like this: 1618The context is created by calling L<AnyEvent::TLS> without any arguments.
1529
1530 Net::SSLeay::load_error_strings;
1531 Net::SSLeay::SSLeay_add_ssl_algorithms;
1532 Net::SSLeay::randomize;
1533
1534 my $CTX = Net::SSLeay::CTX_new;
1535
1536 Net::SSLeay::CTX_set_options $CTX, Net::SSLeay::OP_ALL
1537 1619
1538=cut 1620=cut
1539 1621
1540our $TLS_CTX; 1622our $TLS_CTX;
1541 1623
1542sub TLS_CTX() { 1624sub TLS_CTX() {
1543 $TLS_CTX || do { 1625 $TLS_CTX ||= do {
1544 require Net::SSLeay; 1626 require AnyEvent::TLS;
1545 1627
1546 Net::SSLeay::load_error_strings (); 1628 new AnyEvent::TLS
1547 Net::SSLeay::SSLeay_add_ssl_algorithms ();
1548 Net::SSLeay::randomize ();
1549
1550 $TLS_CTX = Net::SSLeay::CTX_new ();
1551
1552 Net::SSLeay::CTX_set_options ($TLS_CTX, Net::SSLeay::OP_ALL ());
1553
1554 $TLS_CTX
1555 } 1629 }
1556} 1630}
1557 1631
1558=back 1632=back
1559 1633

Diff Legend

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