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

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.201 by root, Wed Apr 1 14:08:27 2009 UTC vs.
Revision 1.231 by root, Wed Jul 8 13:46:46 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - provide framework for multiple event loops 3AnyEvent - provide framework for multiple event loops
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Qt, POE - various supported event loops 5EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
6event loops.
6 7
7=head1 SYNOPSIS 8=head1 SYNOPSIS
8 9
9 use AnyEvent; 10 use AnyEvent;
10 11
12 # file descriptor readable
11 my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub { ... }); 13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
12 14
15 # one-shot or repeating timers
13 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
14 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
15 18
16 print AnyEvent->now; # prints current event loop time 19 print AnyEvent->now; # prints current event loop time
17 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time. 20 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
18 21
22 # POSIX signal
19 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... }); 23 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
20 24
25 # child process exit
21 my $w = AnyEvent->child (pid => $pid, cb => sub { 26 my $w = AnyEvent->child (pid => $pid, cb => sub {
22 my ($pid, $status) = @_; 27 my ($pid, $status) = @_;
23 ... 28 ...
24 }); 29 });
30
31 # called when event loop idle (if applicable)
32 my $w = AnyEvent->idle (cb => sub { ... });
25 33
26 my $w = AnyEvent->condvar; # stores whether a condition was flagged 34 my $w = AnyEvent->condvar; # stores whether a condition was flagged
27 $w->send; # wake up current and all future recv's 35 $w->send; # wake up current and all future recv's
28 $w->recv; # enters "main loop" till $condvar gets ->send 36 $w->recv; # enters "main loop" till $condvar gets ->send
29 # use a condvar in callback mode: 37 # use a condvar in callback mode:
… …
168=head2 I/O WATCHERS 176=head2 I/O WATCHERS
169 177
170You can create an I/O watcher by calling the C<< AnyEvent->io >> method 178You can create an I/O watcher by calling the C<< AnyEvent->io >> method
171with the following mandatory key-value pairs as arguments: 179with the following mandatory key-value pairs as arguments:
172 180
173C<fh> is the Perl I<file handle> (I<not> file descriptor) to watch 181C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch
174for events (AnyEvent might or might not keep a reference to this file 182for events (AnyEvent might or might not keep a reference to this file
175handle). Note that only file handles pointing to things for which 183handle). Note that only file handles pointing to things for which
176non-blocking operation makes sense are allowed. This includes sockets, 184non-blocking operation makes sense are allowed. This includes sockets,
177most character devices, pipes, fifos and so on, but not for example files 185most character devices, pipes, fifos and so on, but not for example files
178or block devices. 186or block devices.
… …
320In either case, if you care (and in most cases, you don't), then you 328In either case, if you care (and in most cases, you don't), then you
321can get whatever behaviour you want with any event loop, by taking the 329can get whatever behaviour you want with any event loop, by taking the
322difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into 330difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into
323account. 331account.
324 332
333=item AnyEvent->now_update
334
335Some event loops (such as L<EV> or L<AnyEvent::Impl::Perl>) cache
336the current time for each loop iteration (see the discussion of L<<
337AnyEvent->now >>, above).
338
339When a callback runs for a long time (or when the process sleeps), then
340this "current" time will differ substantially from the real time, which
341might affect timers and time-outs.
342
343When this is the case, you can call this method, which will update the
344event loop's idea of "current time".
345
346Note that updating the time I<might> cause some events to be handled.
347
325=back 348=back
326 349
327=head2 SIGNAL WATCHERS 350=head2 SIGNAL WATCHERS
328 351
329You can watch for signals using a signal watcher, C<signal> is the signal 352You can watch for signals using a signal watcher, C<signal> is the signal
… …
369 392
370There is a slight catch to child watchers, however: you usually start them 393There is a slight catch to child watchers, however: you usually start them
371I<after> the child process was created, and this means the process could 394I<after> the child process was created, and this means the process could
372have exited already (and no SIGCHLD will be sent anymore). 395have exited already (and no SIGCHLD will be sent anymore).
373 396
374Not all event models handle this correctly (POE doesn't), but even for 397Not all event models handle this correctly (neither POE nor IO::Async do,
398see their AnyEvent::Impl manpages for details), but even for event models
375event models that I<do> handle this correctly, they usually need to be 399that I<do> handle this correctly, they usually need to be loaded before
376loaded before the process exits (i.e. before you fork in the first place). 400the process exits (i.e. before you fork in the first place). AnyEvent's
401pure perl event loop handles all cases correctly regardless of when you
402start the watcher.
377 403
378This means you cannot create a child watcher as the very first thing in an 404This means you cannot create a child watcher as the very first
379AnyEvent program, you I<have> to create at least one watcher before you 405thing in an AnyEvent program, you I<have> to create at least one
380C<fork> the child (alternatively, you can call C<AnyEvent::detect>). 406watcher before you C<fork> the child (alternatively, you can call
407C<AnyEvent::detect>).
381 408
382Example: fork a process and wait for it 409Example: fork a process and wait for it
383 410
384 my $done = AnyEvent->condvar; 411 my $done = AnyEvent->condvar;
385 412
… …
395 ); 422 );
396 423
397 # do something else, then wait for process exit 424 # do something else, then wait for process exit
398 $done->recv; 425 $done->recv;
399 426
427=head2 IDLE WATCHERS
428
429Sometimes there is a need to do something, but it is not so important
430to do it instantly, but only when there is nothing better to do. This
431"nothing better to do" is usually defined to be "no other events need
432attention by the event loop".
433
434Idle watchers ideally get invoked when the event loop has nothing
435better to do, just before it would block the process to wait for new
436events. Instead of blocking, the idle watcher is invoked.
437
438Most event loops unfortunately do not really support idle watchers (only
439EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
440will simply call the callback "from time to time".
441
442Example: read lines from STDIN, but only process them when the
443program is otherwise idle:
444
445 my @lines; # read data
446 my $idle_w;
447 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
448 push @lines, scalar <STDIN>;
449
450 # start an idle watcher, if not already done
451 $idle_w ||= AnyEvent->idle (cb => sub {
452 # handle only one line, when there are lines left
453 if (my $line = shift @lines) {
454 print "handled when idle: $line";
455 } else {
456 # otherwise disable the idle watcher again
457 undef $idle_w;
458 }
459 });
460 });
461
400=head2 CONDITION VARIABLES 462=head2 CONDITION VARIABLES
401 463
402If you are familiar with some event loops you will know that all of them 464If you are familiar with some event loops you will know that all of them
403require you to run some blocking "loop", "run" or similar function that 465require you to run some blocking "loop", "run" or similar function that
404will actively watch for new events and call your callbacks. 466will actively watch for new events and call your callbacks.
… …
537 599
538=item $cv->begin ([group callback]) 600=item $cv->begin ([group callback])
539 601
540=item $cv->end 602=item $cv->end
541 603
542These two methods are EXPERIMENTAL and MIGHT CHANGE.
543
544These two methods can be used to combine many transactions/events into 604These two methods can be used to combine many transactions/events into
545one. For example, a function that pings many hosts in parallel might want 605one. For example, a function that pings many hosts in parallel might want
546to use a condition variable for the whole process. 606to use a condition variable for the whole process.
547 607
548Every call to C<< ->begin >> will increment a counter, and every call to 608Every call to C<< ->begin >> will increment a counter, and every call to
549C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end 609C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end
550>>, the (last) callback passed to C<begin> will be executed. That callback 610>>, the (last) callback passed to C<begin> will be executed. That callback
551is I<supposed> to call C<< ->send >>, but that is not required. If no 611is I<supposed> to call C<< ->send >>, but that is not required. If no
552callback was set, C<send> will be called without any arguments. 612callback was set, C<send> will be called without any arguments.
553 613
554Let's clarify this with the ping example: 614You can think of C<< $cv->send >> giving you an OR condition (one call
615sends), while C<< $cv->begin >> and C<< $cv->end >> giving you an AND
616condition (all C<begin> calls must be C<end>'ed before the condvar sends).
617
618Let's start with a simple example: you have two I/O watchers (for example,
619STDOUT and STDERR for a program), and you want to wait for both streams to
620close before activating a condvar:
621
622 my $cv = AnyEvent->condvar;
623
624 $cv->begin; # first watcher
625 my $w1 = AnyEvent->io (fh => $fh1, cb => sub {
626 defined sysread $fh1, my $buf, 4096
627 or $cv->end;
628 });
629
630 $cv->begin; # second watcher
631 my $w2 = AnyEvent->io (fh => $fh2, cb => sub {
632 defined sysread $fh2, my $buf, 4096
633 or $cv->end;
634 });
635
636 $cv->recv;
637
638This works because for every event source (EOF on file handle), there is
639one call to C<begin>, so the condvar waits for all calls to C<end> before
640sending.
641
642The ping example mentioned above is slightly more complicated, as the
643there are results to be passwd back, and the number of tasks that are
644begung can potentially be zero:
555 645
556 my $cv = AnyEvent->condvar; 646 my $cv = AnyEvent->condvar;
557 647
558 my %result; 648 my %result;
559 $cv->begin (sub { $cv->send (\%result) }); 649 $cv->begin (sub { $cv->send (\%result) });
… …
579loop, which serves two important purposes: first, it sets the callback 669loop, which serves two important purposes: first, it sets the callback
580to be called once the counter reaches C<0>, and second, it ensures that 670to be called once the counter reaches C<0>, and second, it ensures that
581C<send> is called even when C<no> hosts are being pinged (the loop 671C<send> is called even when C<no> hosts are being pinged (the loop
582doesn't execute once). 672doesn't execute once).
583 673
584This is the general pattern when you "fan out" into multiple subrequests: 674This is the general pattern when you "fan out" into multiple (but
585use an outer C<begin>/C<end> pair to set the callback and ensure C<end> 675potentially none) subrequests: use an outer C<begin>/C<end> pair to set
586is called at least once, and then, for each subrequest you start, call 676the callback and ensure C<end> is called at least once, and then, for each
587C<begin> and for each subrequest you finish, call C<end>. 677subrequest you start, call C<begin> and for each subrequest you finish,
678call C<end>.
588 679
589=back 680=back
590 681
591=head3 METHODS FOR CONSUMERS 682=head3 METHODS FOR CONSUMERS
592 683
… …
672 AnyEvent::Impl::Tk based on Tk, very bad choice. 763 AnyEvent::Impl::Tk based on Tk, very bad choice.
673 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs). 764 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
674 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 765 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
675 AnyEvent::Impl::POE based on POE, not generic enough for full support. 766 AnyEvent::Impl::POE based on POE, not generic enough for full support.
676 767
768 # warning, support for IO::Async is only partial, as it is too broken
769 # and limited toe ven support the AnyEvent API. See AnyEvent::Impl::Async.
770 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed (see its docs).
771
677There is no support for WxWidgets, as WxWidgets has no support for 772There is no support for WxWidgets, as WxWidgets has no support for
678watching file handles. However, you can use WxWidgets through the 773watching file handles. However, you can use WxWidgets through the
679POE Adaptor, as POE has a Wx backend that simply polls 20 times per 774POE Adaptor, as POE has a Wx backend that simply polls 20 times per
680second, which was considered to be too horrible to even consider for 775second, which was considered to be too horrible to even consider for
681AnyEvent. Likewise, other POE backends can be used by AnyEvent by using 776AnyEvent. Likewise, other POE backends can be used by AnyEvent by using
… …
773 868
774 869
775=head1 OTHER MODULES 870=head1 OTHER MODULES
776 871
777The following is a non-exhaustive list of additional modules that use 872The following is a non-exhaustive list of additional modules that use
778AnyEvent and can therefore be mixed easily with other AnyEvent modules 873AnyEvent as a client and can therefore be mixed easily with other AnyEvent
779in the same program. Some of the modules come with AnyEvent, some are 874modules and other event loops in the same program. Some of the modules
780available via CPAN. 875come with AnyEvent, most are available via CPAN.
781 876
782=over 4 877=over 4
783 878
784=item L<AnyEvent::Util> 879=item L<AnyEvent::Util>
785 880
… …
794 889
795=item L<AnyEvent::Handle> 890=item L<AnyEvent::Handle>
796 891
797Provide read and write buffers, manages watchers for reads and writes, 892Provide read and write buffers, manages watchers for reads and writes,
798supports raw and formatted I/O, I/O queued and fully transparent and 893supports raw and formatted I/O, I/O queued and fully transparent and
799non-blocking SSL/TLS. 894non-blocking SSL/TLS (via L<AnyEvent::TLS>.
800 895
801=item L<AnyEvent::DNS> 896=item L<AnyEvent::DNS>
802 897
803Provides rich asynchronous DNS resolver capabilities. 898Provides rich asynchronous DNS resolver capabilities.
804 899
… …
832 927
833=item L<AnyEvent::GPSD> 928=item L<AnyEvent::GPSD>
834 929
835A non-blocking interface to gpsd, a daemon delivering GPS information. 930A non-blocking interface to gpsd, a daemon delivering GPS information.
836 931
932=item L<AnyEvent::IRC>
933
934AnyEvent based IRC client module family (replacing the older Net::IRC3).
935
936=item L<AnyEvent::XMPP>
937
938AnyEvent based XMPP (Jabber protocol) module family (replacing the older
939Net::XMPP2>.
940
837=item L<AnyEvent::IGS> 941=item L<AnyEvent::IGS>
838 942
839A non-blocking interface to the Internet Go Server protocol (used by 943A non-blocking interface to the Internet Go Server protocol (used by
840L<App::IGS>). 944L<App::IGS>).
841 945
842=item L<AnyEvent::IRC>
843
844AnyEvent based IRC client module family (replacing the older Net::IRC3).
845
846=item L<Net::XMPP2>
847
848AnyEvent based XMPP (Jabber protocol) module family.
849
850=item L<Net::FCP> 946=item L<Net::FCP>
851 947
852AnyEvent-based implementation of the Freenet Client Protocol, birthplace 948AnyEvent-based implementation of the Freenet Client Protocol, birthplace
853of AnyEvent. 949of AnyEvent.
854 950
… …
858 954
859=item L<Coro> 955=item L<Coro>
860 956
861Has special support for AnyEvent via L<Coro::AnyEvent>. 957Has special support for AnyEvent via L<Coro::AnyEvent>.
862 958
863=item L<IO::Lambda>
864
865The lambda approach to I/O - don't ask, look there. Can use AnyEvent.
866
867=back 959=back
868 960
869=cut 961=cut
870 962
871package AnyEvent; 963package AnyEvent;
… …
873no warnings; 965no warnings;
874use strict qw(vars subs); 966use strict qw(vars subs);
875 967
876use Carp; 968use Carp;
877 969
878our $VERSION = 4.35; 970our $VERSION = 4.801;
879our $MODEL; 971our $MODEL;
880 972
881our $AUTOLOAD; 973our $AUTOLOAD;
882our @ISA; 974our @ISA;
883 975
884our @REGISTRY; 976our @REGISTRY;
885 977
886our $WIN32; 978our $WIN32;
887 979
888BEGIN { 980BEGIN {
889 my $win32 = ! ! ($^O =~ /mswin32/i); 981 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";
890 eval "sub WIN32(){ $win32 }"; 982 eval "sub TAINT(){ " . (${^TAINT}*1) . " }";
983
984 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
985 if ${^TAINT};
891} 986}
892 987
893our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1; 988our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
894 989
895our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 990our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
… …
913 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1008 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
914 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1009 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
915 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 1010 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
916 [Wx:: => AnyEvent::Impl::POE::], 1011 [Wx:: => AnyEvent::Impl::POE::],
917 [Prima:: => AnyEvent::Impl::POE::], 1012 [Prima:: => AnyEvent::Impl::POE::],
1013 # IO::Async is just too broken - we would need workaorunds for its
1014 # byzantine signal and broken child handling, among others.
1015 # IO::Async is rather hard to detect, as it doesn't have any
1016 # obvious default class.
1017# [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
1018# [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
1019# [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
918); 1020);
919 1021
920our %method = map +($_ => 1), qw(io timer time now signal child condvar one_event DESTROY); 1022our %method = map +($_ => 1),
1023 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
921 1024
922our @post_detect; 1025our @post_detect;
923 1026
924sub post_detect(&) { 1027sub post_detect(&) {
925 my ($cb) = @_; 1028 my ($cb) = @_;
… …
930 1 1033 1
931 } else { 1034 } else {
932 push @post_detect, $cb; 1035 push @post_detect, $cb;
933 1036
934 defined wantarray 1037 defined wantarray
935 ? bless \$cb, "AnyEvent::Util::PostDetect" 1038 ? bless \$cb, "AnyEvent::Util::postdetect"
936 : () 1039 : ()
937 } 1040 }
938} 1041}
939 1042
940sub AnyEvent::Util::PostDetect::DESTROY { 1043sub AnyEvent::Util::postdetect::DESTROY {
941 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1044 @post_detect = grep $_ != ${$_[0]}, @post_detect;
942} 1045}
943 1046
944sub detect() { 1047sub detect() {
945 unless ($MODEL) { 1048 unless ($MODEL) {
… …
982 last; 1085 last;
983 } 1086 }
984 } 1087 }
985 1088
986 $MODEL 1089 $MODEL
987 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib."; 1090 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
988 } 1091 }
989 } 1092 }
990 1093
991 push @{"$MODEL\::ISA"}, "AnyEvent::Base"; 1094 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
992 1095
… …
1013} 1116}
1014 1117
1015# utility function to dup a filehandle. this is used by many backends 1118# utility function to dup a filehandle. this is used by many backends
1016# to support binding more than one watcher per filehandle (they usually 1119# to support binding more than one watcher per filehandle (they usually
1017# allow only one watcher per fd, so we dup it to get a different one). 1120# allow only one watcher per fd, so we dup it to get a different one).
1018sub _dupfh($$$$) { 1121sub _dupfh($$;$$) {
1019 my ($poll, $fh, $r, $w) = @_; 1122 my ($poll, $fh, $r, $w) = @_;
1020 1123
1021 # cygwin requires the fh mode to be matching, unix doesn't 1124 # cygwin requires the fh mode to be matching, unix doesn't
1022 my ($rw, $mode) = $poll eq "r" ? ($r, "<") 1125 my ($rw, $mode) = $poll eq "r" ? ($r, "<") : ($w, ">");
1023 : $poll eq "w" ? ($w, ">")
1024 : Carp::croak "AnyEvent->io requires poll set to either 'r' or 'w'";
1025 1126
1026 open my $fh2, "$mode&" . fileno $fh 1127 open my $fh2, "$mode&", $fh
1027 or die "cannot dup() filehandle: $!"; 1128 or die "AnyEvent->io: cannot dup() filehandle in mode '$poll': $!,";
1028 1129
1029 # we assume CLOEXEC is already set by perl in all important cases 1130 # we assume CLOEXEC is already set by perl in all important cases
1030 1131
1031 ($fh2, $rw) 1132 ($fh2, $rw)
1032} 1133}
1033 1134
1034package AnyEvent::Base; 1135package AnyEvent::Base;
1035 1136
1036# default implementation for now and time 1137# default implementations for many methods
1037 1138
1038BEGIN { 1139BEGIN {
1039 if (eval "use Time::HiRes (); time (); 1") { 1140 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1040 *_time = \&Time::HiRes::time; 1141 *_time = \&Time::HiRes::time;
1041 # if (eval "use POSIX (); (POSIX::times())... 1142 # if (eval "use POSIX (); (POSIX::times())...
1042 } else { 1143 } else {
1043 *_time = sub { time }; # epic fail 1144 *_time = sub { time }; # epic fail
1044 } 1145 }
1045} 1146}
1046 1147
1047sub time { _time } 1148sub time { _time }
1048sub now { _time } 1149sub now { _time }
1150sub now_update { }
1049 1151
1050# default implementation for ->condvar 1152# default implementation for ->condvar
1051 1153
1052sub condvar { 1154sub condvar {
1053 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1155 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1054} 1156}
1055 1157
1056# default implementation for ->signal 1158# default implementation for ->signal
1057 1159
1058our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1160our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
… …
1082 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case 1184 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1083 } else { 1185 } else {
1084 pipe $SIGPIPE_R, $SIGPIPE_W; 1186 pipe $SIGPIPE_R, $SIGPIPE_W;
1085 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1187 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1086 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1188 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1189
1190 # not strictly required, as $^F is normally 2, but let's make sure...
1191 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1192 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1087 } 1193 }
1088 1194
1089 $SIGPIPE_R 1195 $SIGPIPE_R
1090 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1196 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1091 1197
1092 # not strictly required, as $^F is normally 2, but let's make sure...
1093 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1094 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1095
1096 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec); 1198 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1097 } 1199 }
1098 1200
1099 my $signal = uc $arg{signal} 1201 my $signal = uc $arg{signal}
1100 or Carp::croak "required option 'signal' is missing"; 1202 or Carp::croak "required option 'signal' is missing";
1101 1203
1102 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1204 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1103 $SIG{$signal} ||= sub { 1205 $SIG{$signal} ||= sub {
1206 local $!;
1104 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1207 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1105 undef $SIG_EV{$signal}; 1208 undef $SIG_EV{$signal};
1106 }; 1209 };
1107 1210
1108 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1211 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1109} 1212}
1110 1213
1111sub AnyEvent::Base::Signal::DESTROY { 1214sub AnyEvent::Base::signal::DESTROY {
1112 my ($signal, $cb) = @{$_[0]}; 1215 my ($signal, $cb) = @{$_[0]};
1113 1216
1114 delete $SIG_CB{$signal}{$cb}; 1217 delete $SIG_CB{$signal}{$cb};
1115 1218
1219 # delete doesn't work with older perls - they then
1220 # print weird messages, or just unconditionally exit
1221 # instead of getting the default action.
1116 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1222 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1117} 1223}
1118 1224
1119# default implementation for ->child 1225# default implementation for ->child
1120 1226
1121our %PID_CB; 1227our %PID_CB;
1122our $CHLD_W; 1228our $CHLD_W;
1123our $CHLD_DELAY_W; 1229our $CHLD_DELAY_W;
1124our $PID_IDLE;
1125our $WNOHANG; 1230our $WNOHANG;
1126 1231
1127sub _child_wait { 1232sub _sigchld {
1128 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1233 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1129 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1234 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1130 (values %{ $PID_CB{0} || {} }); 1235 (values %{ $PID_CB{0} || {} });
1131 } 1236 }
1132
1133 undef $PID_IDLE;
1134}
1135
1136sub _sigchld {
1137 # make sure we deliver these changes "synchronous" with the event loop.
1138 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1139 undef $CHLD_DELAY_W;
1140 &_child_wait;
1141 });
1142} 1237}
1143 1238
1144sub child { 1239sub child {
1145 my (undef, %arg) = @_; 1240 my (undef, %arg) = @_;
1146 1241
1147 defined (my $pid = $arg{pid} + 0) 1242 defined (my $pid = $arg{pid} + 0)
1148 or Carp::croak "required option 'pid' is missing"; 1243 or Carp::croak "required option 'pid' is missing";
1149 1244
1150 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1245 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1151 1246
1152 unless ($WNOHANG) {
1153 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1247 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1154 }
1155 1248
1156 unless ($CHLD_W) { 1249 unless ($CHLD_W) {
1157 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1250 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1158 # child could be a zombie already, so make at least one round 1251 # child could be a zombie already, so make at least one round
1159 &_sigchld; 1252 &_sigchld;
1160 } 1253 }
1161 1254
1162 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1255 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1163} 1256}
1164 1257
1165sub AnyEvent::Base::Child::DESTROY { 1258sub AnyEvent::Base::child::DESTROY {
1166 my ($pid, $cb) = @{$_[0]}; 1259 my ($pid, $cb) = @{$_[0]};
1167 1260
1168 delete $PID_CB{$pid}{$cb}; 1261 delete $PID_CB{$pid}{$cb};
1169 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1262 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1170 1263
1171 undef $CHLD_W unless keys %PID_CB; 1264 undef $CHLD_W unless keys %PID_CB;
1265}
1266
1267# idle emulation is done by simply using a timer, regardless
1268# of whether the process is idle or not, and not letting
1269# the callback use more than 50% of the time.
1270sub idle {
1271 my (undef, %arg) = @_;
1272
1273 my ($cb, $w, $rcb) = $arg{cb};
1274
1275 $rcb = sub {
1276 if ($cb) {
1277 $w = _time;
1278 &$cb;
1279 $w = _time - $w;
1280
1281 # never use more then 50% of the time for the idle watcher,
1282 # within some limits
1283 $w = 0.0001 if $w < 0.0001;
1284 $w = 5 if $w > 5;
1285
1286 $w = AnyEvent->timer (after => $w, cb => $rcb);
1287 } else {
1288 # clean up...
1289 undef $w;
1290 undef $rcb;
1291 }
1292 };
1293
1294 $w = AnyEvent->timer (after => 0.05, cb => $rcb);
1295
1296 bless \\$cb, "AnyEvent::Base::idle"
1297}
1298
1299sub AnyEvent::Base::idle::DESTROY {
1300 undef $${$_[0]};
1172} 1301}
1173 1302
1174package AnyEvent::CondVar; 1303package AnyEvent::CondVar;
1175 1304
1176our @ISA = AnyEvent::CondVar::Base::; 1305our @ISA = AnyEvent::CondVar::Base::;
… …
1250so on. 1379so on.
1251 1380
1252=head1 ENVIRONMENT VARIABLES 1381=head1 ENVIRONMENT VARIABLES
1253 1382
1254The following environment variables are used by this module or its 1383The following environment variables are used by this module or its
1255submodules: 1384submodules.
1385
1386Note that AnyEvent will remove I<all> environment variables starting with
1387C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
1388enabled.
1256 1389
1257=over 4 1390=over 4
1258 1391
1259=item C<PERL_ANYEVENT_VERBOSE> 1392=item C<PERL_ANYEVENT_VERBOSE>
1260 1393
… …
1272=item C<PERL_ANYEVENT_STRICT> 1405=item C<PERL_ANYEVENT_STRICT>
1273 1406
1274AnyEvent does not do much argument checking by default, as thorough 1407AnyEvent does not do much argument checking by default, as thorough
1275argument checking is very costly. Setting this variable to a true value 1408argument checking is very costly. Setting this variable to a true value
1276will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly 1409will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
1277check the arguments passed to most method calls. If it finds any problems 1410check the arguments passed to most method calls. If it finds any problems,
1278it will croak. 1411it will croak.
1279 1412
1280In other words, enables "strict" mode. 1413In other words, enables "strict" mode.
1281 1414
1282Unlike C<use strict>, it is definitely recommended ot keep it off in 1415Unlike C<use strict>, it is definitely recommended to keep it off in
1283production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while 1416production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while
1284developing programs can be very useful, however. 1417developing programs can be very useful, however.
1285 1418
1286=item C<PERL_ANYEVENT_MODEL> 1419=item C<PERL_ANYEVENT_MODEL>
1287 1420
… …
1332 1465
1333=item C<PERL_ANYEVENT_MAX_FORKS> 1466=item C<PERL_ANYEVENT_MAX_FORKS>
1334 1467
1335The maximum number of child processes that C<AnyEvent::Util::fork_call> 1468The maximum number of child processes that C<AnyEvent::Util::fork_call>
1336will create in parallel. 1469will create in parallel.
1470
1471=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
1472
1473The default value for the C<max_outstanding> parameter for the default DNS
1474resolver - this is the maximum number of parallel DNS requests that are
1475sent to the DNS server.
1476
1477=item C<PERL_ANYEVENT_RESOLV_CONF>
1478
1479The file to use instead of F</etc/resolv.conf> (or OS-specific
1480configuration) in the default resolver. When set to the empty string, no
1481default config will be used.
1482
1483=item C<PERL_ANYEVENT_CA_FILE>, C<PERL_ANYEVENT_CA_PATH>.
1484
1485When neither C<ca_file> nor C<ca_path> was specified during
1486L<AnyEvent::TLS> context creation, and either of these environment
1487variables exist, they will be used to specify CA certificate locations
1488instead of a system-dependent default.
1337 1489
1338=back 1490=back
1339 1491
1340=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE 1492=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1341 1493
… …
1586 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers 1738 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers
1587 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal 1739 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal
1588 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation 1740 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation
1589 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 1741 Event/Event 16000 517 32.20 31.80 0.81 Event native interface
1590 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 1742 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers
1743 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll
1744 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll
1591 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 1745 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour
1592 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 1746 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers
1593 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 1747 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event
1594 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select 1748 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select
1595 1749
… …
1624performance becomes really bad with lots of file descriptors (and few of 1778performance becomes really bad with lots of file descriptors (and few of
1625them active), of course, but this was not subject of this benchmark. 1779them active), of course, but this was not subject of this benchmark.
1626 1780
1627The C<Event> module has a relatively high setup and callback invocation 1781The C<Event> module has a relatively high setup and callback invocation
1628cost, but overall scores in on the third place. 1782cost, but overall scores in on the third place.
1783
1784C<IO::Async> performs admirably well, about on par with C<Event>, even
1785when using its pure perl backend.
1629 1786
1630C<Glib>'s memory usage is quite a bit higher, but it features a 1787C<Glib>'s memory usage is quite a bit higher, but it features a
1631faster callback invocation and overall ends up in the same class as 1788faster callback invocation and overall ends up in the same class as
1632C<Event>. However, Glib scales extremely badly, doubling the number of 1789C<Event>. However, Glib scales extremely badly, doubling the number of
1633watchers increases the processing time by more than a factor of four, 1790watchers increases the processing time by more than a factor of four,
… …
1711it to another server. This includes deleting the old timeout and creating 1868it to another server. This includes deleting the old timeout and creating
1712a new one that moves the timeout into the future. 1869a new one that moves the timeout into the future.
1713 1870
1714=head3 Results 1871=head3 Results
1715 1872
1716 name sockets create request 1873 name sockets create request
1717 EV 20000 69.01 11.16 1874 EV 20000 69.01 11.16
1718 Perl 20000 73.32 35.87 1875 Perl 20000 73.32 35.87
1876 IOAsync 20000 157.00 98.14 epoll
1877 IOAsync 20000 159.31 616.06 poll
1719 Event 20000 212.62 257.32 1878 Event 20000 212.62 257.32
1720 Glib 20000 651.16 1896.30 1879 Glib 20000 651.16 1896.30
1721 POE 20000 349.67 12317.24 uses POE::Loop::Event 1880 POE 20000 349.67 12317.24 uses POE::Loop::Event
1722 1881
1723=head3 Discussion 1882=head3 Discussion
1724 1883
1725This benchmark I<does> measure scalability and overall performance of the 1884This benchmark I<does> measure scalability and overall performance of the
1726particular event loop. 1885particular event loop.
… …
1728EV is again fastest. Since it is using epoll on my system, the setup time 1887EV is again fastest. Since it is using epoll on my system, the setup time
1729is relatively high, though. 1888is relatively high, though.
1730 1889
1731Perl surprisingly comes second. It is much faster than the C-based event 1890Perl surprisingly comes second. It is much faster than the C-based event
1732loops Event and Glib. 1891loops Event and Glib.
1892
1893IO::Async performs very well when using its epoll backend, and still quite
1894good compared to Glib when using its pure perl backend.
1733 1895
1734Event suffers from high setup time as well (look at its code and you will 1896Event suffers from high setup time as well (look at its code and you will
1735understand why). Callback invocation also has a high overhead compared to 1897understand why). Callback invocation also has a high overhead compared to
1736the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event 1898the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event
1737uses select or poll in basically all documented configurations. 1899uses select or poll in basically all documented configurations.
… …
1800=item * C-based event loops perform very well with small number of 1962=item * C-based event loops perform very well with small number of
1801watchers, as the management overhead dominates. 1963watchers, as the management overhead dominates.
1802 1964
1803=back 1965=back
1804 1966
1967=head2 THE IO::Lambda BENCHMARK
1968
1969Recently I was told about the benchmark in the IO::Lambda manpage, which
1970could be misinterpreted to make AnyEvent look bad. In fact, the benchmark
1971simply compares IO::Lambda with POE, and IO::Lambda looks better (which
1972shouldn't come as a surprise to anybody). As such, the benchmark is
1973fine, and mostly shows that the AnyEvent backend from IO::Lambda isn't
1974very optimal. But how would AnyEvent compare when used without the extra
1975baggage? To explore this, I wrote the equivalent benchmark for AnyEvent.
1976
1977The benchmark itself creates an echo-server, and then, for 500 times,
1978connects to the echo server, sends a line, waits for the reply, and then
1979creates the next connection. This is a rather bad benchmark, as it doesn't
1980test the efficiency of the framework or much non-blocking I/O, but it is a
1981benchmark nevertheless.
1982
1983 name runtime
1984 Lambda/select 0.330 sec
1985 + optimized 0.122 sec
1986 Lambda/AnyEvent 0.327 sec
1987 + optimized 0.138 sec
1988 Raw sockets/select 0.077 sec
1989 POE/select, components 0.662 sec
1990 POE/select, raw sockets 0.226 sec
1991 POE/select, optimized 0.404 sec
1992
1993 AnyEvent/select/nb 0.085 sec
1994 AnyEvent/EV/nb 0.068 sec
1995 +state machine 0.134 sec
1996
1997The benchmark is also a bit unfair (my fault): the IO::Lambda/POE
1998benchmarks actually make blocking connects and use 100% blocking I/O,
1999defeating the purpose of an event-based solution. All of the newly
2000written AnyEvent benchmarks use 100% non-blocking connects (using
2001AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
2002resolver), so AnyEvent is at a disadvantage here, as non-blocking connects
2003generally require a lot more bookkeeping and event handling than blocking
2004connects (which involve a single syscall only).
2005
2006The last AnyEvent benchmark additionally uses L<AnyEvent::Handle>, which
2007offers similar expressive power as POE and IO::Lambda, using conventional
2008Perl syntax. This means that both the echo server and the client are 100%
2009non-blocking, further placing it at a disadvantage.
2010
2011As you can see, the AnyEvent + EV combination even beats the
2012hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
2013backend easily beats IO::Lambda and POE.
2014
2015And even the 100% non-blocking version written using the high-level (and
2016slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a
2017large margin, even though it does all of DNS, tcp-connect and socket I/O
2018in a non-blocking way.
2019
2020The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and
2021F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
2022part of the IO::lambda distribution and were used without any changes.
2023
1805 2024
1806=head1 SIGNALS 2025=head1 SIGNALS
1807 2026
1808AnyEvent currently installs handlers for these signals: 2027AnyEvent currently installs handlers for these signals:
1809 2028
… …
1812=item SIGCHLD 2031=item SIGCHLD
1813 2032
1814A handler for C<SIGCHLD> is installed by AnyEvent's child watcher 2033A handler for C<SIGCHLD> is installed by AnyEvent's child watcher
1815emulation for event loops that do not support them natively. Also, some 2034emulation for event loops that do not support them natively. Also, some
1816event loops install a similar handler. 2035event loops install a similar handler.
2036
2037If, when AnyEvent is loaded, SIGCHLD is set to IGNORE, then AnyEvent will
2038reset it to default, to avoid losing child exit statuses.
1817 2039
1818=item SIGPIPE 2040=item SIGPIPE
1819 2041
1820A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef> 2042A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef>
1821when AnyEvent gets loaded. 2043when AnyEvent gets loaded.
… …
1833 2055
1834=back 2056=back
1835 2057
1836=cut 2058=cut
1837 2059
2060undef $SIG{CHLD}
2061 if $SIG{CHLD} eq 'IGNORE';
2062
1838$SIG{PIPE} = sub { } 2063$SIG{PIPE} = sub { }
1839 unless defined $SIG{PIPE}; 2064 unless defined $SIG{PIPE};
1840
1841 2065
1842=head1 FORK 2066=head1 FORK
1843 2067
1844Most event libraries are not fork-safe. The ones who are usually are 2068Most event libraries are not fork-safe. The ones who are usually are
1845because they rely on inefficient but fork-safe C<select> or C<poll> 2069because they rely on inefficient but fork-safe C<select> or C<poll>
… …
1866 use AnyEvent; 2090 use AnyEvent;
1867 2091
1868Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2092Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1869be used to probe what backend is used and gain other information (which is 2093be used to probe what backend is used and gain other information (which is
1870probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2094probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1871$ENV{PERL_ANYEGENT_STRICT}. 2095$ENV{PERL_ANYEVENT_STRICT}.
2096
2097Note that AnyEvent will remove I<all> environment variables starting with
2098C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
2099enabled.
1872 2100
1873 2101
1874=head1 BUGS 2102=head1 BUGS
1875 2103
1876Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 2104Perl 5.8 has numerous memleaks that sometimes hit this module and are hard
… …
1888L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>. 2116L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>.
1889 2117
1890Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>, 2118Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
1891L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>, 2119L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
1892L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>, 2120L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
1893L<AnyEvent::Impl::POE>. 2121L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>.
1894 2122
1895Non-blocking file handles, sockets, TCP clients and 2123Non-blocking file handles, sockets, TCP clients and
1896servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>. 2124servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
1897 2125
1898Asynchronous DNS: L<AnyEvent::DNS>. 2126Asynchronous DNS: L<AnyEvent::DNS>.
1899 2127
1900Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>, 2128Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>,
2129L<Coro::Event>,
1901 2130
1902Nontrivial usage examples: L<Net::FCP>, L<Net::XMPP2>, L<AnyEvent::DNS>. 2131Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::XMPP>,
2132L<AnyEvent::HTTP>.
1903 2133
1904 2134
1905=head1 AUTHOR 2135=head1 AUTHOR
1906 2136
1907 Marc Lehmann <schmorp@schmorp.de> 2137 Marc Lehmann <schmorp@schmorp.de>

Diff Legend

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