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.200 by root, Wed Apr 1 14:02:27 2009 UTC vs.
Revision 1.230 by root, Wed Jul 8 05:55:17 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.8;
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 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1093 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1094
1095 $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);
1096 } 1199 }
1097 1200
1098 my $signal = uc $arg{signal} 1201 my $signal = uc $arg{signal}
1099 or Carp::croak "required option 'signal' is missing"; 1202 or Carp::croak "required option 'signal' is missing";
1100 1203
1101 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1204 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1102 $SIG{$signal} ||= sub { 1205 $SIG{$signal} ||= sub {
1206 local $!;
1103 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1207 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1104 undef $SIG_EV{$signal}; 1208 undef $SIG_EV{$signal};
1105 }; 1209 };
1106 1210
1107 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1211 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1108} 1212}
1109 1213
1110sub AnyEvent::Base::Signal::DESTROY { 1214sub AnyEvent::Base::signal::DESTROY {
1111 my ($signal, $cb) = @{$_[0]}; 1215 my ($signal, $cb) = @{$_[0]};
1112 1216
1113 delete $SIG_CB{$signal}{$cb}; 1217 delete $SIG_CB{$signal}{$cb};
1114 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.
1115 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1222 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1116} 1223}
1117 1224
1118# default implementation for ->child 1225# default implementation for ->child
1119 1226
1120our %PID_CB; 1227our %PID_CB;
1121our $CHLD_W; 1228our $CHLD_W;
1122our $CHLD_DELAY_W; 1229our $CHLD_DELAY_W;
1123our $PID_IDLE;
1124our $WNOHANG; 1230our $WNOHANG;
1125 1231
1126sub _child_wait { 1232sub _sigchld {
1127 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1233 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1128 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1234 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1129 (values %{ $PID_CB{0} || {} }); 1235 (values %{ $PID_CB{0} || {} });
1130 } 1236 }
1131
1132 undef $PID_IDLE;
1133}
1134
1135sub _sigchld {
1136 # make sure we deliver these changes "synchronous" with the event loop.
1137 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1138 undef $CHLD_DELAY_W;
1139 &_child_wait;
1140 });
1141} 1237}
1142 1238
1143sub child { 1239sub child {
1144 my (undef, %arg) = @_; 1240 my (undef, %arg) = @_;
1145 1241
1146 defined (my $pid = $arg{pid} + 0) 1242 defined (my $pid = $arg{pid} + 0)
1147 or Carp::croak "required option 'pid' is missing"; 1243 or Carp::croak "required option 'pid' is missing";
1148 1244
1149 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1245 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1150 1246
1151 unless ($WNOHANG) {
1152 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1247 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1153 }
1154 1248
1155 unless ($CHLD_W) { 1249 unless ($CHLD_W) {
1156 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1250 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1157 # 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
1158 &_sigchld; 1252 &_sigchld;
1159 } 1253 }
1160 1254
1161 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1255 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1162} 1256}
1163 1257
1164sub AnyEvent::Base::Child::DESTROY { 1258sub AnyEvent::Base::child::DESTROY {
1165 my ($pid, $cb) = @{$_[0]}; 1259 my ($pid, $cb) = @{$_[0]};
1166 1260
1167 delete $PID_CB{$pid}{$cb}; 1261 delete $PID_CB{$pid}{$cb};
1168 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1262 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1169 1263
1170 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]};
1171} 1301}
1172 1302
1173package AnyEvent::CondVar; 1303package AnyEvent::CondVar;
1174 1304
1175our @ISA = AnyEvent::CondVar::Base::; 1305our @ISA = AnyEvent::CondVar::Base::;
… …
1249so on. 1379so on.
1250 1380
1251=head1 ENVIRONMENT VARIABLES 1381=head1 ENVIRONMENT VARIABLES
1252 1382
1253The following environment variables are used by this module or its 1383The following environment variables are used by this module or its
1254submodules: 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.
1255 1389
1256=over 4 1390=over 4
1257 1391
1258=item C<PERL_ANYEVENT_VERBOSE> 1392=item C<PERL_ANYEVENT_VERBOSE>
1259 1393
… …
1271=item C<PERL_ANYEVENT_STRICT> 1405=item C<PERL_ANYEVENT_STRICT>
1272 1406
1273AnyEvent does not do much argument checking by default, as thorough 1407AnyEvent does not do much argument checking by default, as thorough
1274argument checking is very costly. Setting this variable to a true value 1408argument checking is very costly. Setting this variable to a true value
1275will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly 1409will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
1276check 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,
1277it will croak. 1411it will croak.
1278 1412
1279In other words, enables "strict" mode. 1413In other words, enables "strict" mode.
1280 1414
1281Unlike 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
1282production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while 1416production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while
1283developing programs can be very useful, however. 1417developing programs can be very useful, however.
1284 1418
1285=item C<PERL_ANYEVENT_MODEL> 1419=item C<PERL_ANYEVENT_MODEL>
1286 1420
… …
1331 1465
1332=item C<PERL_ANYEVENT_MAX_FORKS> 1466=item C<PERL_ANYEVENT_MAX_FORKS>
1333 1467
1334The maximum number of child processes that C<AnyEvent::Util::fork_call> 1468The maximum number of child processes that C<AnyEvent::Util::fork_call>
1335will 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.
1336 1489
1337=back 1490=back
1338 1491
1339=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE 1492=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1340 1493
… …
1585 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
1586 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
1587 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
1588 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
1589 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
1590 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
1591 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
1592 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
1593 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
1594 1749
… …
1623performance becomes really bad with lots of file descriptors (and few of 1778performance becomes really bad with lots of file descriptors (and few of
1624them active), of course, but this was not subject of this benchmark. 1779them active), of course, but this was not subject of this benchmark.
1625 1780
1626The C<Event> module has a relatively high setup and callback invocation 1781The C<Event> module has a relatively high setup and callback invocation
1627cost, 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.
1628 1786
1629C<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
1630faster callback invocation and overall ends up in the same class as 1788faster callback invocation and overall ends up in the same class as
1631C<Event>. However, Glib scales extremely badly, doubling the number of 1789C<Event>. However, Glib scales extremely badly, doubling the number of
1632watchers increases the processing time by more than a factor of four, 1790watchers increases the processing time by more than a factor of four,
… …
1710it to another server. This includes deleting the old timeout and creating 1868it to another server. This includes deleting the old timeout and creating
1711a new one that moves the timeout into the future. 1869a new one that moves the timeout into the future.
1712 1870
1713=head3 Results 1871=head3 Results
1714 1872
1715 name sockets create request 1873 name sockets create request
1716 EV 20000 69.01 11.16 1874 EV 20000 69.01 11.16
1717 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
1718 Event 20000 212.62 257.32 1878 Event 20000 212.62 257.32
1719 Glib 20000 651.16 1896.30 1879 Glib 20000 651.16 1896.30
1720 POE 20000 349.67 12317.24 uses POE::Loop::Event 1880 POE 20000 349.67 12317.24 uses POE::Loop::Event
1721 1881
1722=head3 Discussion 1882=head3 Discussion
1723 1883
1724This benchmark I<does> measure scalability and overall performance of the 1884This benchmark I<does> measure scalability and overall performance of the
1725particular event loop. 1885particular event loop.
… …
1727EV 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
1728is relatively high, though. 1888is relatively high, though.
1729 1889
1730Perl 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
1731loops 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.
1732 1895
1733Event 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
1734understand why). Callback invocation also has a high overhead compared to 1897understand why). Callback invocation also has a high overhead compared to
1735the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event 1898the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event
1736uses select or poll in basically all documented configurations. 1899uses select or poll in basically all documented configurations.
… …
1799=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
1800watchers, as the management overhead dominates. 1963watchers, as the management overhead dominates.
1801 1964
1802=back 1965=back
1803 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
1804 2024
1805=head1 SIGNALS 2025=head1 SIGNALS
1806 2026
1807AnyEvent currently installs handlers for these signals: 2027AnyEvent currently installs handlers for these signals:
1808 2028
… …
1811=item SIGCHLD 2031=item SIGCHLD
1812 2032
1813A handler for C<SIGCHLD> is installed by AnyEvent's child watcher 2033A handler for C<SIGCHLD> is installed by AnyEvent's child watcher
1814emulation for event loops that do not support them natively. Also, some 2034emulation for event loops that do not support them natively. Also, some
1815event 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.
1816 2039
1817=item SIGPIPE 2040=item SIGPIPE
1818 2041
1819A 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>
1820when AnyEvent gets loaded. 2043when AnyEvent gets loaded.
… …
1832 2055
1833=back 2056=back
1834 2057
1835=cut 2058=cut
1836 2059
2060undef $SIG{CHLD}
2061 if $SIG{CHLD} eq 'IGNORE';
2062
1837$SIG{PIPE} = sub { } 2063$SIG{PIPE} = sub { }
1838 unless defined $SIG{PIPE}; 2064 unless defined $SIG{PIPE};
1839
1840 2065
1841=head1 FORK 2066=head1 FORK
1842 2067
1843Most 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
1844because 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>
… …
1865 use AnyEvent; 2090 use AnyEvent;
1866 2091
1867Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2092Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1868be 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
1869probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2094probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1870$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.
1871 2100
1872 2101
1873=head1 BUGS 2102=head1 BUGS
1874 2103
1875Perl 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
… …
1887L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>. 2116L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>.
1888 2117
1889Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>, 2118Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
1890L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>, 2119L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
1891L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>, 2120L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
1892L<AnyEvent::Impl::POE>. 2121L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>.
1893 2122
1894Non-blocking file handles, sockets, TCP clients and 2123Non-blocking file handles, sockets, TCP clients and
1895servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>. 2124servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
1896 2125
1897Asynchronous DNS: L<AnyEvent::DNS>. 2126Asynchronous DNS: L<AnyEvent::DNS>.
1898 2127
1899Coroutine 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>,
1900 2130
1901Nontrivial usage examples: L<Net::FCP>, L<Net::XMPP2>, L<AnyEvent::DNS>. 2131Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::XMPP>,
2132L<AnyEvent::HTTP>.
1902 2133
1903 2134
1904=head1 AUTHOR 2135=head1 AUTHOR
1905 2136
1906 Marc Lehmann <schmorp@schmorp.de> 2137 Marc Lehmann <schmorp@schmorp.de>

Diff Legend

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