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.12 by elmex, Thu May 15 09:03:43 2008 UTC vs.
Revision 1.28 by root, Sat May 24 22:27:11 2008 UTC

… …
10use Fcntl (); 10use Fcntl ();
11use Errno qw/EAGAIN EINTR/; 11use Errno qw/EAGAIN EINTR/;
12 12
13=head1 NAME 13=head1 NAME
14 14
15AnyEvent::Handle - non-blocking I/O on filehandles via AnyEvent 15AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
16 16
17=cut 17This module is experimental.
18 18
19=cut
20
19our $VERSION = '0.02'; 21our $VERSION = '0.04';
20 22
21=head1 SYNOPSIS 23=head1 SYNOPSIS
22 24
23 use AnyEvent; 25 use AnyEvent;
24 use AnyEvent::Handle; 26 use AnyEvent::Handle;
… …
43 $cv->wait; 45 $cv->wait;
44 46
45=head1 DESCRIPTION 47=head1 DESCRIPTION
46 48
47This module is a helper module to make it easier to do event-based I/O on 49This module is a helper module to make it easier to do event-based I/O on
48filehandles (and sockets, see L<AnyEvent::Socket> for an easy way to make 50filehandles. For utility functions for doing non-blocking connects and accepts
49non-blocking resolves and connects). 51on sockets see L<AnyEvent::Util>.
50 52
51In the following, when the documentation refers to of "bytes" then this 53In the following, when the documentation refers to of "bytes" then this
52means characters. As sysread and syswrite are used for all I/O, their 54means characters. As sysread and syswrite are used for all I/O, their
53treatment of characters applies to this module as well. 55treatment of characters applies to this module as well.
54 56
… …
70The filehandle this L<AnyEvent::Handle> object will operate on. 72The filehandle this L<AnyEvent::Handle> object will operate on.
71 73
72NOTE: The filehandle will be set to non-blocking (using 74NOTE: The filehandle will be set to non-blocking (using
73AnyEvent::Util::fh_nonblocking). 75AnyEvent::Util::fh_nonblocking).
74 76
75=item on_eof => $cb->($self) [MANDATORY] 77=item on_eof => $cb->($self)
76 78
77Set the callback to be called on EOF. 79Set the callback to be called on EOF.
78 80
81While not mandatory, it is highly recommended to set an eof callback,
82otherwise you might end up with a closed socket while you are still
83waiting for data.
84
79=item on_error => $cb->($self) 85=item on_error => $cb->($self)
80 86
81This is the fatal error callback, that is called when, well, a fatal error 87This is the fatal error callback, that is called when, well, a fatal error
82ocurs, such as not being able to resolve the hostname, failure to connect 88occurs, such as not being able to resolve the hostname, failure to connect
83or a read error. 89or a read error.
84 90
85The object will not be in a usable state when this callback has been 91The object will not be in a usable state when this callback has been
86called. 92called.
87 93
… …
96 102
97This sets the default read callback, which is called when data arrives 103This sets the default read callback, which is called when data arrives
98and no read request is in the queue. 104and no read request is in the queue.
99 105
100To access (and remove data from) the read buffer, use the C<< ->rbuf >> 106To access (and remove data from) the read buffer, use the C<< ->rbuf >>
101method or acces sthe C<$self->{rbuf}> member directly. 107method or access the C<$self->{rbuf}> member directly.
102 108
103When an EOF condition is detected then AnyEvent::Handle will first try to 109When an EOF condition is detected then AnyEvent::Handle will first try to
104feed all the remaining data to the queued callbacks and C<on_read> before 110feed all the remaining data to the queued callbacks and C<on_read> before
105calling the C<on_eof> callback. If no progress can be made, then a fatal 111calling the C<on_eof> callback. If no progress can be made, then a fatal
106error will be raised (with C<$!> set to C<EPIPE>). 112error will be raised (with C<$!> set to C<EPIPE>).
… …
133 139
134Sets the amount of bytes (default: C<0>) that make up an "empty" write 140Sets the amount of bytes (default: C<0>) that make up an "empty" write
135buffer: If the write reaches this size or gets even samller it is 141buffer: If the write reaches this size or gets even samller it is
136considered empty. 142considered empty.
137 143
144=item tls => "accept" | "connect" | Net::SSLeay::SSL object
145
146When this parameter is given, it enables TLS (SSL) mode, that means it
147will start making tls handshake and will transparently encrypt/decrypt
148data.
149
150TLS mode requires Net::SSLeay to be installed (it will be loaded
151automatically when you try to create a TLS handle).
152
153For the TLS server side, use C<accept>, and for the TLS client side of a
154connection, use C<connect> mode.
155
156You can also provide your own TLS connection object, but you have
157to make sure that you call either C<Net::SSLeay::set_connect_state>
158or C<Net::SSLeay::set_accept_state> on it before you pass it to
159AnyEvent::Handle.
160
161See the C<starttls> method if you need to start TLs negotiation later.
162
163=item tls_ctx => $ssl_ctx
164
165Use the given Net::SSLeay::CTX object to create the new TLS connection
166(unless a connection object was specified directly). If this parameter is
167missing, then AnyEvent::Handle will use C<AnyEvent::Handle::TLS_CTX>.
168
138=back 169=back
139 170
140=cut 171=cut
172
173our (%RH, %WH);
174
175sub register_read_type($$) {
176 $RH{$_[0]} = $_[1];
177}
178
179sub register_write_type($$) {
180 $WH{$_[0]} = $_[1];
181}
141 182
142sub new { 183sub new {
143 my $class = shift; 184 my $class = shift;
144 185
145 my $self = bless { @_ }, $class; 186 my $self = bless { @_ }, $class;
146 187
147 $self->{fh} or Carp::croak "mandatory argument fh is missing"; 188 $self->{fh} or Carp::croak "mandatory argument fh is missing";
148 189
149 AnyEvent::Util::fh_nonblocking $self->{fh}, 1; 190 AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
150 191
151 $self->on_eof ((delete $self->{on_eof} ) or Carp::croak "mandatory argument on_eof is missing"); 192 if ($self->{tls}) {
193 require Net::SSLeay;
194 $self->starttls (delete $self->{tls}, delete $self->{tls_ctx});
195 }
152 196
197 $self->on_eof (delete $self->{on_eof} ) if $self->{on_eof};
153 $self->on_error (delete $self->{on_error}) if $self->{on_error}; 198 $self->on_error (delete $self->{on_error}) if $self->{on_error};
154 $self->on_drain (delete $self->{on_drain}) if $self->{on_drain}; 199 $self->on_drain (delete $self->{on_drain}) if $self->{on_drain};
155 $self->on_read (delete $self->{on_read} ) if $self->{on_read}; 200 $self->on_read (delete $self->{on_read} ) if $self->{on_read};
156 201
157 $self->start_read; 202 $self->start_read;
… …
182 } 227 }
183} 228}
184 229
185=item $fh = $handle->fh 230=item $fh = $handle->fh
186 231
187This method returns the filehandle of the L<AnyEvent::Handle> object. 232This method returns the file handle of the L<AnyEvent::Handle> object.
188 233
189=cut 234=cut
190 235
191sub fh { $_[0]->{fh} } 236sub fh { $_[0]->{fh} }
192 237
… …
220for reading. 265for reading.
221 266
222The write queue is very simple: you can add data to its end, and 267The write queue is very simple: you can add data to its end, and
223AnyEvent::Handle will automatically try to get rid of it for you. 268AnyEvent::Handle will automatically try to get rid of it for you.
224 269
225When data could be writtena nd the write buffer is shorter then the low 270When data could be written and the write buffer is shorter then the low
226water mark, the C<on_drain> callback will be invoked. 271water mark, the C<on_drain> callback will be invoked.
227 272
228=over 4 273=over 4
229 274
230=item $handle->on_drain ($cb) 275=item $handle->on_drain ($cb)
… …
249want (only limited by the available memory), as C<AnyEvent::Handle> 294want (only limited by the available memory), as C<AnyEvent::Handle>
250buffers it independently of the kernel. 295buffers it independently of the kernel.
251 296
252=cut 297=cut
253 298
254sub push_write { 299sub _drain_wbuf {
255 my ($self, $data) = @_; 300 my ($self) = @_;
256
257 $self->{wbuf} .= $data;
258 301
259 unless ($self->{ww}) { 302 unless ($self->{ww}) {
260 Scalar::Util::weaken $self; 303 Scalar::Util::weaken $self;
261 my $cb = sub { 304 my $cb = sub {
262 my $len = syswrite $self->{fh}, $self->{wbuf}; 305 my $len = syswrite $self->{fh}, $self->{wbuf};
263 306
264 if ($len > 0) { 307 if ($len > 0) {
265 substr $self->{wbuf}, 0, $len, ""; 308 substr $self->{wbuf}, 0, $len, "";
266
267 309
268 $self->{on_drain}($self) 310 $self->{on_drain}($self)
269 if $self->{low_water_mark} >= length $self->{wbuf} 311 if $self->{low_water_mark} >= length $self->{wbuf}
270 && $self->{on_drain}; 312 && $self->{on_drain};
271 313
… …
277 319
278 $self->{ww} = AnyEvent->io (fh => $self->{fh}, poll => "w", cb => $cb); 320 $self->{ww} = AnyEvent->io (fh => $self->{fh}, poll => "w", cb => $cb);
279 321
280 $cb->($self); 322 $cb->($self);
281 }; 323 };
324}
325
326sub push_write {
327 my $self = shift;
328
329 if ($self->{filter_w}) {
330 $self->{filter_w}->($self, \$_[0]);
331 } else {
332 $self->{wbuf} .= $_[0];
333 $self->_drain_wbuf;
334 }
282} 335}
283 336
284############################################################################# 337#############################################################################
285 338
286=back 339=back
… …
361 414
362=cut 415=cut
363 416
364sub _drain_rbuf { 417sub _drain_rbuf {
365 my ($self) = @_; 418 my ($self) = @_;
419
420 if (
421 defined $self->{rbuf_max}
422 && $self->{rbuf_max} < length $self->{rbuf}
423 ) {
424 $! = &Errno::ENOSPC; return $self->error;
425 }
366 426
367 return if $self->{in_drain}; 427 return if $self->{in_drain};
368 local $self->{in_drain} = 1; 428 local $self->{in_drain} = 1;
369 429
370 while (my $len = length $self->{rbuf}) { 430 while (my $len = length $self->{rbuf}) {
… …
398 } 458 }
399 } 459 }
400 460
401 if ($self->{eof}) { 461 if ($self->{eof}) {
402 $self->_shutdown; 462 $self->_shutdown;
403 $self->{on_eof}($self); 463 $self->{on_eof}($self)
464 if $self->{on_eof};
404 } 465 }
405} 466}
406 467
407=item $handle->on_read ($cb) 468=item $handle->on_read ($cb)
408 469
… …
442Append the given callback to the end of the queue (C<push_read>) or 503Append the given callback to the end of the queue (C<push_read>) or
443prepend it (C<unshift_read>). 504prepend it (C<unshift_read>).
444 505
445The callback is called each time some additional read data arrives. 506The callback is called each time some additional read data arrives.
446 507
447It must check wether enough data is in the read buffer already. 508It must check whether enough data is in the read buffer already.
448 509
449If not enough data is available, it must return the empty list or a false 510If not enough data is available, it must return the empty list or a false
450value, in which case it will be called repeatedly until enough data is 511value, in which case it will be called repeatedly until enough data is
451available (or an error condition is detected). 512available (or an error condition is detected).
452 513
… …
455true, it will be removed from the queue. 516true, it will be removed from the queue.
456 517
457=cut 518=cut
458 519
459sub push_read { 520sub push_read {
460 my ($self, $cb) = @_; 521 my $self = shift;
522 my $cb = pop;
523
524 if (@_) {
525 my $type = shift;
526
527 $cb = ($RH{$type} or Carp::croak "unsupported type passed to AnyEvent::Handle::push_read")
528 ->($self, $cb, @_);
529 }
461 530
462 push @{ $self->{queue} }, $cb; 531 push @{ $self->{queue} }, $cb;
463 $self->_drain_rbuf; 532 $self->_drain_rbuf;
464} 533}
465 534
466sub unshift_read { 535sub unshift_read {
467 my ($self, $cb) = @_; 536 my $self = shift;
537 my $cb = pop;
468 538
539 if (@_) {
540 my $type = shift;
541
542 $cb = ($RH{$type} or Carp::croak "unsupported type passed to AnyEvent::Handle::unshift_read")
543 ->($self, $cb, @_);
544 }
545
546
469 push @{ $self->{queue} }, $cb; 547 unshift @{ $self->{queue} }, $cb;
470 $self->_drain_rbuf; 548 $self->_drain_rbuf;
471} 549}
472 550
473=item $handle->push_read_chunk ($len, $cb->($self, $data)) 551=item $handle->push_read (type => @args, $cb)
474 552
475=item $handle->unshift_read_chunk ($len, $cb->($self, $data)) 553=item $handle->unshift_read (type => @args, $cb)
476 554
477Append the given callback to the end of the queue (C<push_read_chunk>) or 555Instead of providing a callback that parses the data itself you can chose
478prepend it (C<unshift_read_chunk>). 556between a number of predefined parsing formats, for chunks of data, lines
557etc.
479 558
480The callback will be called only once C<$len> bytes have been read, and 559The types currently supported are:
481these C<$len> bytes will be passed to the callback.
482 560
483=cut 561=over 4
484 562
485sub _read_chunk($$) { 563=item chunk => $octets, $cb->($self, $data)
564
565Invoke the callback only once C<$octets> bytes have been read. Pass the
566data read to the callback. The callback will never be called with less
567data.
568
569Example: read 2 bytes.
570
571 $handle->push_read (chunk => 2, sub {
572 warn "yay ", unpack "H*", $_[1];
573 });
574
575=cut
576
577register_read_type chunk => sub {
486 my ($self, $len, $cb) = @_; 578 my ($self, $cb, $len) = @_;
487 579
488 sub { 580 sub {
489 $len <= length $_[0]{rbuf} or return; 581 $len <= length $_[0]{rbuf} or return;
490 $cb->($_[0], substr $_[0]{rbuf}, 0, $len, ""); 582 $cb->($_[0], substr $_[0]{rbuf}, 0, $len, "");
491 1 583 1
492 } 584 }
493} 585};
494 586
587# compatibility with older API
495sub push_read_chunk { 588sub push_read_chunk {
496 $_[0]->push_read (&_read_chunk); 589 $_[0]->push_read (chunk => $_[1], $_[2]);
497} 590}
498
499 591
500sub unshift_read_chunk { 592sub unshift_read_chunk {
501 $_[0]->unshift_read (&_read_chunk); 593 $_[0]->unshift_read (chunk => $_[1], $_[2]);
502} 594}
503 595
504=item $handle->push_read_line ([$eol, ]$cb->($self, $line, $eol)) 596=item line => [$eol, ]$cb->($self, $line, $eol)
505
506=item $handle->unshift_read_line ([$eol, ]$cb->($self, $line, $eol))
507
508Append the given callback to the end of the queue (C<push_read_line>) or
509prepend it (C<unshift_read_line>).
510 597
511The callback will be called only once a full line (including the end of 598The callback will be called only once a full line (including the end of
512line marker, C<$eol>) has been read. This line (excluding the end of line 599line marker, C<$eol>) has been read. This line (excluding the end of line
513marker) will be passed to the callback as second argument (C<$line>), and 600marker) will be passed to the callback as second argument (C<$line>), and
514the end of line marker as the third argument (C<$eol>). 601the end of line marker as the third argument (C<$eol>).
… …
525Partial lines at the end of the stream will never be returned, as they are 612Partial lines at the end of the stream will never be returned, as they are
526not marked by the end of line marker. 613not marked by the end of line marker.
527 614
528=cut 615=cut
529 616
530sub _read_line($$) { 617register_read_type line => sub {
531 my $self = shift; 618 my ($self, $cb, $eol) = @_;
532 my $cb = pop;
533 my $eol = @_ ? shift : qr|(\015?\012)|;
534 my $pos;
535 619
620 $eol = qr|(\015?\012)| if @_ < 3;
536 $eol = qr|(\Q$eol\E)| unless ref $eol; 621 $eol = quotemeta $eol unless ref $eol;
537 $eol = qr|^(.*?)($eol)|; 622 $eol = qr|^(.*?)($eol)|s;
538 623
539 sub { 624 sub {
540 $_[0]{rbuf} =~ s/$eol// or return; 625 $_[0]{rbuf} =~ s/$eol// or return;
541 626
542 $cb->($_[0], $1, $2); 627 $cb->($_[0], $1, $2);
543 1 628 1
544 } 629 }
545} 630};
546 631
632# compatibility with older API
547sub push_read_line { 633sub push_read_line {
548 $_[0]->push_read (&_read_line); 634 my $self = shift;
635 $self->push_read (line => @_);
549} 636}
550 637
551sub unshift_read_line { 638sub unshift_read_line {
552 $_[0]->unshift_read (&_read_line); 639 my $self = shift;
640 $self->unshift_read (line => @_);
553} 641}
642
643=back
554 644
555=item $handle->stop_read 645=item $handle->stop_read
556 646
557=item $handle->start_read 647=item $handle->start_read
558 648
559In rare cases you actually do not want to read anything form the 649In rare cases you actually do not want to read anything from the
560socket. In this case you can call C<stop_read>. Neither C<on_read> no 650socket. In this case you can call C<stop_read>. Neither C<on_read> no
561any queued callbacks will be executed then. To start readign again, call 651any queued callbacks will be executed then. To start reading again, call
562C<start_read>. 652C<start_read>.
563 653
564=cut 654=cut
565 655
566sub stop_read { 656sub stop_read {
… …
574 664
575 unless ($self->{rw} || $self->{eof}) { 665 unless ($self->{rw} || $self->{eof}) {
576 Scalar::Util::weaken $self; 666 Scalar::Util::weaken $self;
577 667
578 $self->{rw} = AnyEvent->io (fh => $self->{fh}, poll => "r", cb => sub { 668 $self->{rw} = AnyEvent->io (fh => $self->{fh}, poll => "r", cb => sub {
669 my $rbuf = $self->{filter_r} ? \my $buf : \$self->{rbuf};
579 my $len = sysread $self->{fh}, $self->{rbuf}, $self->{read_size} || 8192, length $self->{rbuf}; 670 my $len = sysread $self->{fh}, $$rbuf, $self->{read_size} || 8192, length $$rbuf;
580 671
581 if ($len > 0) { 672 if ($len > 0) {
582 if (defined $self->{rbuf_max}) { 673 $self->{filter_r}
583 if ($self->{rbuf_max} < length $self->{rbuf}) { 674 ? $self->{filter_r}->($self, $rbuf)
584 $! = &Errno::ENOSPC; return $self->error; 675 : $self->_drain_rbuf;
585 }
586 }
587 676
588 } elsif (defined $len) { 677 } elsif (defined $len) {
678 delete $self->{rw};
589 $self->{eof} = 1; 679 $self->{eof} = 1;
590 delete $self->{rw}; 680 $self->_drain_rbuf;
591 681
592 } elsif ($! != EAGAIN && $! != EINTR) { 682 } elsif ($! != EAGAIN && $! != EINTR) {
593 return $self->error; 683 return $self->error;
594 } 684 }
595
596 $self->_drain_rbuf;
597 }); 685 });
598 } 686 }
599} 687}
600 688
689sub _dotls {
690 my ($self) = @_;
691
692 if (length $self->{tls_wbuf}) {
693 while ((my $len = Net::SSLeay::write ($self->{tls}, $self->{tls_wbuf})) > 0) {
694 substr $self->{tls_wbuf}, 0, $len, "";
695 }
696 }
697
698 if (defined (my $buf = Net::SSLeay::BIO_read ($self->{tls_wbio}))) {
699 $self->{wbuf} .= $buf;
700 $self->_drain_wbuf;
701 }
702
703 while (defined (my $buf = Net::SSLeay::read ($self->{tls}))) {
704 $self->{rbuf} .= $buf;
705 $self->_drain_rbuf;
706 }
707
708 my $err = Net::SSLeay::get_error ($self->{tls}, -1);
709
710 if ($err!= Net::SSLeay::ERROR_WANT_READ ()) {
711 if ($err == Net::SSLeay::ERROR_SYSCALL ()) {
712 $self->error;
713 } elsif ($err == Net::SSLeay::ERROR_SSL ()) {
714 $! = &Errno::EIO;
715 $self->error;
716 }
717
718 # all others are fine for our purposes
719 }
720}
721
722=item $handle->starttls ($tls[, $tls_ctx])
723
724Instead of starting TLS negotiation immediately when the AnyEvent::Handle
725object is created, you can also do that at a later time by calling
726C<starttls>.
727
728The first argument is the same as the C<tls> constructor argument (either
729C<"connect">, C<"accept"> or an existing Net::SSLeay object).
730
731The second argument is the optional C<Net::SSLeay::CTX> object that is
732used when AnyEvent::Handle has to create its own TLS connection object.
733
734=cut
735
736# TODO: maybe document...
737sub starttls {
738 my ($self, $ssl, $ctx) = @_;
739
740 $self->stoptls;
741
742 if ($ssl eq "accept") {
743 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
744 Net::SSLeay::set_accept_state ($ssl);
745 } elsif ($ssl eq "connect") {
746 $ssl = Net::SSLeay::new ($ctx || TLS_CTX ());
747 Net::SSLeay::set_connect_state ($ssl);
748 }
749
750 $self->{tls} = $ssl;
751
752 # basically, this is deep magic (because SSL_read should have the same issues)
753 # but the openssl maintainers basically said: "trust us, it just works".
754 # (unfortunately, we have to hardcode constants because the abysmally misdesigned
755 # and mismaintained ssleay-module doesn't even offer them).
756 # http://www.mail-archive.com/openssl-dev@openssl.org/msg22420.html
757 Net::SSLeay::CTX_set_mode ($self->{tls},
758 (eval { Net::SSLeay::MODE_ENABLE_PARTIAL_WRITE () } || 1)
759 | (eval { Net::SSLeay::MODE_ACCEPT_MOVING_WRITE_BUFFER () } || 2));
760
761 $self->{tls_rbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
762 $self->{tls_wbio} = Net::SSLeay::BIO_new (Net::SSLeay::BIO_s_mem ());
763
764 Net::SSLeay::set_bio ($ssl, $self->{tls_rbio}, $self->{tls_wbio});
765
766 $self->{filter_w} = sub {
767 $_[0]{tls_wbuf} .= ${$_[1]};
768 &_dotls;
769 };
770 $self->{filter_r} = sub {
771 Net::SSLeay::BIO_write ($_[0]{tls_rbio}, ${$_[1]});
772 &_dotls;
773 };
774}
775
776=item $handle->stoptls
777
778Destroys the SSL connection, if any. Partial read or write data will be
779lost.
780
781=cut
782
783sub stoptls {
784 my ($self) = @_;
785
786 Net::SSLeay::free (delete $self->{tls}) if $self->{tls};
787 delete $self->{tls_rbio};
788 delete $self->{tls_wbio};
789 delete $self->{tls_wbuf};
790 delete $self->{filter_r};
791 delete $self->{filter_w};
792}
793
794sub DESTROY {
795 my $self = shift;
796
797 $self->stoptls;
798}
799
800=item AnyEvent::Handle::TLS_CTX
801
802This function creates and returns the Net::SSLeay::CTX object used by
803default for TLS mode.
804
805The context is created like this:
806
807 Net::SSLeay::load_error_strings;
808 Net::SSLeay::SSLeay_add_ssl_algorithms;
809 Net::SSLeay::randomize;
810
811 my $CTX = Net::SSLeay::CTX_new;
812
813 Net::SSLeay::CTX_set_options $CTX, Net::SSLeay::OP_ALL
814
815=cut
816
817our $TLS_CTX;
818
819sub TLS_CTX() {
820 $TLS_CTX || do {
821 require Net::SSLeay;
822
823 Net::SSLeay::load_error_strings ();
824 Net::SSLeay::SSLeay_add_ssl_algorithms ();
825 Net::SSLeay::randomize ();
826
827 $TLS_CTX = Net::SSLeay::CTX_new ();
828
829 Net::SSLeay::CTX_set_options ($TLS_CTX, Net::SSLeay::OP_ALL ());
830
831 $TLS_CTX
832 }
833}
834
601=back 835=back
602 836
603=head1 AUTHOR 837=head1 AUTHOR
604 838
605Robin Redeker C<< <elmex at ta-sa.org> >>, Marc Lehmann <schmorp@schmorp.de>. 839Robin Redeker C<< <elmex at ta-sa.org> >>, Marc Lehmann <schmorp@schmorp.de>.

Diff Legend

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