Codebase list libapache2-mod-perl2 / 9861476
Imported Upstream version 2.0.9~rc1 Niko Tyni 9 years ago
128 changed file(s) with 4751 addition(s) and 2374 deletion(s). Raw diff Collapse all Expand all
+5
-0
Apache-Reload/Changes less more
44 =head1 CHANGES
55
66 =over 1
7
8 =item 0.13 May 09, 2015
9
10 Fix reload.t. Reported in CPAN RT#96656.
11 [Steve Hay]
712
813 =item 0.12 March 31, 2012
914
+34
-3
Apache-Reload/Makefile.PL less more
00 use strict;
11
2 use lib qw(lib);
23 use Config;
34
45 my %prereqs = ();
2122
2223 my $HAS_APACHE_TEST = check_for_apache_test();
2324
25 my $VERSION;
26 set_version();
27
2428 my %common_opts = (
29 VERSION => $VERSION,
2530 PREREQ_PM => \%prereqs,
31 dist => {
32 COMPRESS => 'gzip -9f', SUFFIX => 'gz',
33 PREOP => 'find $(DISTVNAME) -type d -print|xargs chmod 0755 && ' .
34 'find $(DISTVNAME) -type f -print|xargs chmod 0644',
35 TO_UNIX => 'find $(DISTVNAME) -type f -print|xargs dos2unix'
36 },
2637 clean => { FILES => 't/TEST' },
2738 );
2839
29 if ($mp_gen == 1) {
40 ### MAINTAINER_BUILDING_RELEASE is hack
41 ### for the Release Manager's use only.
42 ### We will set it so that the resulting
43 ### distribution will be called Apache-Reload-\d+.tar.gz
44 ### and NOT Apache2-Reload-\d+.tar.gz
45 ### This is for historical reasons and consistency
46 if ($mp_gen == 1 || $ENV{MAINTAINER_BUILDING_RELEASE}) {
3047 require ExtUtils::MakeMaker;
3148 ExtUtils::MakeMaker::WriteMakefile(
3249 %common_opts,
33 VERSION_FROM => "lib/Apache/Reload.pm",
3450 NAME => "Apache::Reload",
3551 ABSTRACT_FROM => 'lib/Apache/Reload.pm',
3652 );
4056 require ModPerl::MM;
4157 ModPerl::MM::WriteMakefile(
4258 %common_opts,
43 VERSION_FROM => "lib/Apache2/Reload.pm",
4459 NAME => "Apache2::Reload",
4560 ABSTRACT_FROM => 'lib/Apache2/Reload.pm',
4661 );
6681 Apache::TestRunPerl->generate_script();
6782
6883 return 1;
84 }
85
86 sub set_version {
87 require Apache::Reload;
88 $VERSION = $Apache::Reload::VERSION;
89
90 my $fh = Symbol::gensym();
91 open $fh, 'Changes' or die "Can't open Changes: $!";
92 while (<$fh>) {
93 if(/^=item.*-(dev|rc\d+)/) {
94 $VERSION .= "-$1";
95 last;
96 }
97 last if /^=item/;
98 }
99 close $fh;
69100 }
70101
71102 # If a specific generation was passed as an argument,
+11
-29
Apache-Reload/RELEASE less more
11
22 0. Ask the PMC to verify that you have the appropriate CPAN permissions
33 on dev@perl.
4
5 make sure your public key is in the KEYS file in the mod_perl docs.
6 you should only need to do this if this is your first time playing
7 Release Manager
8
9 $ cd mod_perl-docs
10 $ grep $USER src/dist/KEYS
11
12 note that the KEYS file itself contains all the instructions you
13 need on how to add your key. if you need further help on gpg
14 (like how to create a key in the first place) you can look here
15
16 http://people.apache.org/~geoff/gpghowto.html
17
18 Copy the KEYS file into place:
19 % scp KEYS www.apache.org:/www/www.apache.org/dist/perl/KEYS
204
215 If this is your first release, ask someone with APML karma on PAUSE
226 to verify you have the appropriate permissions. Likely someone on
248
259 a. login into https://pause.perl.org
2610 b. menu click: Select Mailinglist/Action
27 c. choose APML and share_perms and click go
28 d. click 3.3 Make somebody else co-maintainer
11 c. choose APML and Change Permissions and click go
12 d. click 3.1 Make somebody else co-maintainer
2913 e. choose the modules to give the perms to
3014 type the username of the new co-maintainer
3115 f. if you happen to know that packages were added this release,
3923 as possible.
4024
4125 a. edit ./Changes:
42 - find lib -type f -name "*.pm" | \
43 xargs perl -pi -e 's,0.12-dev,0.12-rc1,g'
44 - perl -pi -e 's,0.12-dev,0.12-rc1,g' Changes
45
46 - don't commit these (see dev@ archives)
26 - change -dev to -rc\d+ starting with -rc1
4727
4828 b. nuke any preinstalled Apache-Reload libs and run 'make test'
4929
6040 o dev/perl.apache.org
6141 o modperl/perl.apache.org
6242
63 Subject: [RELEASE CANDIDATE] Apache-Reload 0.12 RC\d+
43 Subject: [RELEASE CANDIDATE] Apache-Reload 0.13 RC\d+
6444
6545 (or maybe longer to give most people a chance to catch up). no need
6646 to tag this package
7151 package to be released
7252
7353 a. edit ./Changes
74 - remove -rc\d+ (from lib/Apache/Reload.pm and lib/Apache2/Reload.pm also)
54 - remove -rc\d+
7555 - add release date
7656
7757 b. rerun:
9575 5. Announce the package
9676
9777 a. post ... to the modperl, announce lists
98 Subject: [ANNOUNCE] Apache-Reload 0.12
78 Subject: [ANNOUNCE] Apache-Reload 0.13
9979 include
10080 - MD5 sig (as it comes from CPAN upload announce).
10181 - the latest Changes
10282
10383 6. Prepare for the next cycle
10484
105 a. increment version in lib/Apache/Reload.pm
85 a. increment version in lib/Apache/Reload.pm and lib/Apache2/Reload.pm also
10686
10787 b. edit ./Changes:
10888 - start a new item with incremented version + '-dev'
10989
110 =item 0.13-dev
90 =item 0.14-dev
11191
11292 c. bump up version numbers in this file to make it easier to do the
11393 next release.
11494
11595 $ perl -pi -e 's/(\d+)\.(\d+)/join(".", $1, $2+1)/eg' RELEASE
11696
97 (undo the change to the PAUSE menu item number in item 0d. above)
98
11799 d. commit Changes
118 % svn ci -m "start 0.12-dev cycle" Changes RELEASE \
100 % svn ci -m "start 0.13-dev cycle" Changes RELEASE \
119101 lib/Apache/Reload.pm lib/Apache2/Reload.pm
+1
-1
Apache-Reload/lib/Apache/Reload.pm less more
1616
1717 use strict;
1818
19 $Apache::Reload::VERSION = '0.12';
19 $Apache::Reload::VERSION = '0.13';
2020
2121 use vars qw(%INCS %Stat $TouchTime %UndefFields %Ignore);
2222
+1
-1
Apache-Reload/lib/Apache2/Reload.pm less more
1717 use strict;
1818 use warnings FATAL => 'all';
1919
20 our $VERSION = '0.12';
20 our $VERSION = '0.13';
2121
2222 use Apache2::Const -compile => qw(OK);
2323
+0
-3
Apache-Reload/t/conf/extra.conf.in less more
0 PerlSwitches -I@ServerRoot@/../../Apache-Test/lib \
1 -I@ServerRoot@/../../blib/lib \
2 -I@ServerRoot@/../../blib/arch
+1
-1
Apache-Reload/t/lib/Apache2/TestReload.pm less more
1414 sub handler {
1515 my $r = shift;
1616 $pass++;
17 if ($r->args eq 'last') {
17 if (defined $r->args and $r->args eq 'last') {
1818 Apache2::Reload->unregister_module($package);
1919 ModPerl::Util::unload_package($package);
2020 $pass = 0;
+0
-21
Apache-Test/Apache-TestItSelf/Apache-TestMe/Changes less more
0 =head1 NAME
1
2 Changes - Apache::TestMe changes logfile
3
4 =head1 Changes
5
6 =over 4
7
8 =item 0.01
9
10 new test basic/vhost.t which introduces a vhost entry in .pm. also
11 added a dummy vhost entry in t/conf/extra.conf.in, the setup needed by
12 t/minmaxclients.t from Apache-TestItSelf [Stas]
13
14 write a basic mod_perl test: basic/hello.t [Stas]
15
16 starting the config test suite used by Apache::TestItSelf [Stas]
17
18 =back
19
20 =cut
+0
-221
Apache-Test/Apache-TestItSelf/Apache-TestMe/Makefile.PL less more
0 use 5.005;
1
2 use lib qw(../../lib); # Apache-Test/lib
3
4 use Apache::TestMM qw(test clean);
5 use Apache::TestMM ();
6 use Apache::TestReport;
7
8 use ExtUtils::MakeMaker ();
9
10 my $mp_gen = satisfy_mp_generation();
11 warn "Goind to build against mod_perl/$mod_perl::VERSION Perl/$]\n";
12
13 Apache::TestMM::filter_args();
14
15 my @scripts = qw(t/TEST);
16 for (@scripts) {
17 Apache::TestMM::generate_script($_);
18 }
19 Apache::TestReport->generate_script;
20
21 my @clean_files = (@scripts, qw(t/REPORT));
22
23
24 my %common_opts = (
25 NAME => 'Apache-TestMe',
26 VERSION => '0.01',
27 clean => {
28 FILES => "@clean_files",
29 },
30 );
31
32 if ($mp_gen == 1) {
33 require ExtUtils::MakeMaker;
34 ExtUtils::MakeMaker::WriteMakefile(
35 %common_opts,
36 );
37
38 }
39 else {
40 require ModPerl::MM;
41 ModPerl::MM::WriteMakefile(
42 %common_opts,
43 );
44 }
45 # If a specific generation was passed as an argument,
46 # if satisfied
47 # return the same generation
48 # else
49 # die
50 # else @ARGV and %ENV will be checked for specific orders
51 # if the specification will be found
52 # if satisfied
53 # return the specified generation
54 # else
55 # die
56 # else if any mp generation is found
57 # return it
58 # else
59 # die
60
61 sub satisfy_mp_generation {
62 my $wanted = shift || wanted_mp_generation();
63
64 unless ($wanted == 1 || $wanted == 2) {
65 die "don't know anything about mod_perl generation: $wanted\n" .
66 "currently supporting only generations 1 and 2";
67 }
68
69 my $selected = 0;
70
71 if ($wanted == 1) {
72 require_mod_perl();
73 if ($mod_perl::VERSION >= 1.99) {
74 # so we don't pick 2.0 version if 1.0 is wanted
75 die "You don't seem to have mod_perl 1.0 installed";
76 }
77 $selected = 1;
78 }
79 elsif ($wanted == 2) {
80 #warn "Looking for mod_perl 2.0";
81 require_mod_perl2();
82 if ($mod_perl::VERSION < 1.99) {
83 die "You don't seem to have mod_perl 2.0 installed";
84 }
85 $selected = 2;
86 }
87 else {
88 $selected = eval { require_mod_perl2() or require_mod_perl() };
89 warn "Using $mod_perl::VERSION\n";
90 }
91
92 return $selected;
93 }
94
95 sub require_mod_perl {
96 eval { require mod_perl };
97 die "Can't find mod_perl installed\nThe error was: $@" if $@;
98 1;
99 }
100
101 sub require_mod_perl2 {
102 eval { require mod_perl2 };
103 die "Can't find mod_perl installed\nThe error was: $@" if $@;
104 2;
105 }
106
107
108 # the function looks at %ENV and Makefile.PL option to figure out
109 # whether a specific mod_perl generation was requested.
110 # It uses the following logic:
111 # via options:
112 # perl Makefile.PL MOD_PERL=2
113 # or via %ENV:
114 # env MOD_PERL=1 perl Makefile.PL
115 #
116 # return value is:
117 # 1 or 2 if the specification was found (mp 1 and mp 2 respectively)
118 # 0 otherwise
119 sub wanted_mp_generation {
120
121 # check if we have a command line specification
122 # flag: 0: unknown, 1: mp1, 2: mp2
123 my $flag = 0;
124 my @pass;
125 while (@ARGV) {
126 my $key = shift @ARGV;
127 if ($key =~ /^MOD_PERL=(\d)$/) {
128 $flag = $1;
129 }
130 else {
131 push @pass, $key;
132 }
133 }
134 @ARGV = @pass;
135
136 # check %ENV
137 my $env = exists $ENV{MOD_PERL} ? $ENV{MOD_PERL} : 0;
138
139 # check for contradicting requirements
140 if ($env && $flag && $flag != $env) {
141 die <<EOF;
142 Can\'t decide which mod_perl version should be used, since you have
143 supplied contradicting requirements:
144 enviroment variable MOD_PERL=$env
145 Makefile.PL option MOD_PERL=$flag
146 EOF
147 }
148
149 my $wanted = 0;
150 $wanted = 2 if $env == 2 || $flag == 2;
151 $wanted = 1 if $env == 1 || $flag == 1;
152
153 unless ($wanted) {
154 # if still unknown try to require mod_perl.pm
155 eval { require mod_perl2 or require mod_perl };
156 unless ($@) {
157 $wanted = $mod_perl::VERSION >= 1.99 ? 2 : 1;
158 }
159 }
160
161 return $wanted;
162 }
163
164
165 # the function looks at %ENV and Makefile.PL option to figure out
166 # whether a specific mod_perl generation was requested.
167 # It uses the following logic:
168 # via options:
169 # perl Makefile.PL MOD_PERL=2
170 # or via %ENV:
171 # env MOD_PERL=1 perl Makefile.PL
172 #
173 # return value is:
174 # 1 or 2 if the specification was found (mp 1 and mp 2 respectively)
175 # 0 otherwise
176 sub wanted_mp_generation {
177
178 # check if we have a command line specification
179 # flag: 0: unknown, 1: mp1, 2: mp2
180 my $flag = 0;
181 my @pass;
182 while (@ARGV) {
183 my $key = shift @ARGV;
184 if ($key =~ /^MOD_PERL=(\d)$/) {
185 $flag = $1;
186 }
187 else {
188 push @pass, $key;
189 }
190 }
191 @ARGV = @pass;
192
193 # check %ENV
194 my $env = exists $ENV{MOD_PERL} ? $ENV{MOD_PERL} : 0;
195
196 # check for contradicting requirements
197 if ($env && $flag && $flag != $env) {
198 die <<EOF;
199 Can\'t decide which mod_perl version should be used, since you have
200 supplied contradicting requirements:
201 enviroment variable MOD_PERL=$env
202 Makefile.PL option MOD_PERL=$flag
203 EOF
204 }
205
206 my $wanted = 0;
207 $wanted = 2 if $env == 2 || $flag == 2;
208 $wanted = 1 if $env == 1 || $flag == 1;
209
210 unless ($wanted) {
211 # if still unknown try to require mod_perl.pm
212 eval { require mod_perl2 or require mod_perl };
213 unless ($@) {
214 $wanted = $mod_perl::VERSION >= 1.99 ? 2 : 1;
215 }
216 }
217
218 return $wanted;
219 }
220
+0
-5
Apache-Test/Apache-TestItSelf/Apache-TestMe/README less more
0 This package contains an Apache-Test test suite used by
1 Apache-TestItSelf. We use a dedicated test suite, so we can re-create
2 cases which normally won't fit into the core Apache-Test test suite.
3 This is the test suite that should be run from Apache-TestTestItSelf
4 as explained in Apache-TestItSelf/README
+0
-37
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/TEST.PL less more
0 use strict;
1
2 use FindBin;
3 # test against the A-T source lib for easier dev
4 use lib "$FindBin::Bin/../../../lib";
5
6 use lib qw(lib ../lib);
7
8 use warnings FATAL => 'all';
9
10 use Apache::TestRunPerl ();
11
12 package MyTest;
13
14 use vars qw(@ISA);
15 @ISA = qw(Apache::TestRunPerl);
16
17 sub new_test_config {
18 my $self = shift;
19
20 #$self->{conf_opts}->{authname} = 'gold club';
21
22 return $self->SUPER::new_test_config;
23 }
24
25 sub bug_report {
26 my $self = shift;
27
28 print <<EOI;
29 +-----------------------------------------------------+
30 | To report problems please refer to the SUPPORT file |
31 +-----------------------------------------------------+
32 EOI
33 }
34
35 MyTest->new->run(@ARGV);
36
+0
-20
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/basic/hello.t less more
0 use strict;
1 use warnings FATAL => 'all';
2
3 use Apache::Test;
4 use Apache::TestRequest;
5 use Apache::TestUtil;
6
7 plan tests => 3, have_lwp;
8
9 my $response = GET '/TestBasic__Hello';
10
11 ok t_cmp $response->code, 200, '/handler returned HTTP_OK';
12
13 ok t_cmp $response->header('Content-Type'), 'text/plain',
14 '/handler set proper Content-Type';
15
16 chomp(my $content = $response->content);
17
18 ok t_cmp $content, 'Hello', '/handler returned proper content';
19
+0
-7
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/basic/vhost.t less more
0 use Apache::TestUtil;
1 use Apache::TestRequest 'GET_BODY_ASSERT';
2
3 my $module = 'TestBasic::Vhost';
4 my $url = Apache::TestRequest::module2url($module);
5 t_debug("connecting to $url");
6 print GET_BODY_ASSERT $url;
+0
-16
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/conf/extra.conf.in less more
0 # this vhost entry is needed to check that when t/TEST -maxclients 1
1 # or similar is called after t/TEST -conf was run, and extra.conf
2 # includes a vhost entry and httpd.conf includes an autogenerated
3 # vhost entry from some .pm file, we used to have a collision, since
4 # extra.conf wasn't reparsed and the same port was getting assigned to
5 # more than one vhost entry, preventing server startup:
6 #
7 #default_ VirtualHost overlap on port 8530, the first has precedence
8 #(98)Address already in use: make_sock: could not bind to address
9 #0.0.0.0:8530 no listening sockets available, shutting down
10 #
11 # XXX: for now using a dummy vhost entry. later if needed to put a
12 # real vhost entry in ths file, the dummy one can be removed
13 #
14 <VirtualHost foo_bar_tar>
15 </VirtualHost>
+0
-2
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/conf/modperl_extra.pl less more
0
1 1;
+0
-19
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/response/TestBasic/Hello.pm less more
0 package TestBasic::Hello;
1
2 use Apache2::RequestRec ();
3 use Apache2::RequestIO ();
4 use Apache2::Const -compile => qw(OK);
5
6 # XXX: adjust the test that it'll work under mp1 as well
7
8 sub handler {
9
10 my $r = shift;
11
12 $r->content_type('text/plain');
13 $r->print('Hello');
14
15 return Apache2::OK;
16 }
17
18 1;
+0
-28
Apache-Test/Apache-TestItSelf/Apache-TestMe/t/response/TestBasic/Vhost.pm less more
0 package TestBasic::Vhost;
1
2 use Apache2::Const -compile => qw(OK);
3 use Apache::Test;
4
5 # XXX: adjust the test that it'll work under mp1 as well
6
7 sub handler {
8
9 my $r = shift;
10
11 plan $r, tests => 1;
12
13 ok 1;
14
15 return Apache2::OK;
16 }
17
18 1;
19 __END__
20 <NoAutoConfig>
21 <VirtualHost TestBasic::Vhost>
22 <Location /TestBasic__Vhost>
23 SetHandler modperl
24 PerlResponseHandler TestBasic::Vhost
25 </Location>
26 </VirtualHost>
27 </NoAutoConfig>
+0
-27
Apache-Test/Apache-TestItSelf/Changes less more
0 =head1 NAME
1
2 Changes - Apache::TestItSelf changes logfile
3
4 =head1 Changes
5
6 =over 4
7
8 =item 0.01
9
10 Fix Makefile.PL to make sure that MakeMaker won't descend into
11 Apache-TestMe. NORECURS doesn't work in older MM versions, so use the
12 DIR attr as a workaround [Stas]
13
14 new test: minmaxclients.t: testing a bug with vhosts reproducable by
15 t/TEST -conf followed by t/TEST -maxclients 1 [Stas]
16
17 new test: interactive.t: the interactive config [Stas]
18
19 new test: httpd_arg.t: passing -httpd argument to 'perl Makefile.PL'
20 and to 't/TEST' [Stas]
21
22 starting the config test suite [Stas]
23
24 =back
25
26 =cut
+0
-40
Apache-Test/Apache-TestItSelf/Makefile.PL less more
0 use 5.005;
1
2 use lib qw(../lib); # Apache-Test/lib
3 use Apache::Test5005compat;
4
5 use strict;
6 use warnings;
7
8 use ExtUtils::MakeMaker;
9
10 use Apache::TestMM ();
11
12 Apache::TestMM::generate_script('t/TEST');
13
14 my @clean_files =
15 qw(t/TEST
16 Makefile.old
17 );
18
19 my %prereq = (
20 # needed to be able to use one perl version to drive the test
21 # suite, but a different version from the tests themselves
22 'Test::Harness' => '2.44',
23 );
24
25 WriteMakefile(
26 NAME => 'Apache::TestItSelf',
27 PREREQ_PM => \%prereq,
28 VERSION => "0.01",
29 NORECURS => 1, # don't descend into Apache-TestMe
30 DIR => [], # NORECURS is broken in older MM
31 dist => {
32 COMPRESS => 'gzip -9f', SUFFIX=>'gz',
33 },
34 clean => {
35 FILES => "@clean_files",
36 },
37 );
38
39
+0
-73
Apache-Test/Apache-TestItSelf/README less more
0 This test suite tests various Apache-Test setups (i.e. whether the
1 configuration works correctly), something that can't be tested with
2 the normal run-time test suite.
3
4 1) first of all move into Apache-TestItSelf
5
6 % chdir Apache-TestItSelf
7
8
9
10 2) now choose which test suite to run again, to test whether some
11 changes in A-T break its config, run 2a. But if the config testing
12 coverage is not complete, try other test suites and then try to
13 re-create this problem in 2a.
14
15 You will need to adjust config files under sample/ to reflect the
16 location of your preinstalled httpd and mod_perl files.
17
18 a. Apache-Test config test suite
19
20 % t/TEST -config sample/testitself_conf_apache_test_core.pl
21
22 this runs against the test suite under:
23
24 Apache-Test/Apache-TestItSelf/Apache-TestMe/t
25
26 it's the same as calling:
27
28 % t/TEST -base ~/apache.org/Apache-Test/Apache-TestItSelf/Apache-TestMe \
29 -config sample/testitself_conf_apache_test_core.pl
30
31
32
33 b. Apache-Test
34
35 assuming that Apache-Test is checked out under
36 ~/apache.org/Apache-Test, the following will run the tests against the
37 Apache-Test test suite
38
39 % t/TEST -base ~/apache.org/Apache-Test \
40 -config sample/testitself_conf_apache_test_core.pl
41
42
43
44 c. modperl-2.0
45
46 assuming that modperl-2.0 is checked out under
47 ~/apache.org/modperl-2.0, the following will run the tests against the
48 modperl-2.0 test suite
49
50 % t/TEST -base ~/apache.org/modperl-2.0 \
51 -config sample/testitself_conf_mp2_core.pl t/httpd_arg.t t/interactive.t
52
53
54
55 d. 3rd party modules ###
56
57 assuming that Apache-VMonitor-2.0 is checked out under
58 ~/work/modules/Apache-VMonitor-2.0, the following will run the tests
59 against the Apache-VMonitor-2.0 test suite. of course any other 3rd
60 party module should do.
61
62
63 % t/TEST -base ~/work/modules/Apache-VMonitor-2.0 \
64 -config sample/testitself_conf_mp2_modules.pl
65
66
67 -----------------------------
68
69 DEBUGGING:
70
71 env IPCRUNDEBUG=data t/TEST t/interactive.t
72 (for more options see IPC::Run / IPC::Run3 manpages)
+0
-160
Apache-Test/Apache-TestItSelf/lib/MyTest/Util.pm less more
0 package MyTest::Util;
1
2 use strict;
3 use warnings FATAL => 'all';
4
5 use Apache::TestConfig;
6 use Apache::TestTrace;
7
8 use Exporter ();
9 use IPC::Run3 ();
10 use Cwd;
11
12 use vars qw(@ISA @EXPORT @EXPORT_OK);
13 @ISA = qw(Exporter);
14 @EXPORT = ();
15 @EXPORT_OK = qw(myrun3 go_in go_out work_dir dump_stds check_eval
16 test_configs);
17
18 sub myrun3 {
19 my $cmd = shift;
20 my $out = '';
21 my $err = '';
22
23 my $ok = IPC::Run3::run3($cmd, \undef, \$out, \$err);
24 die "IPC::Run3 failed to run $cmd" unless $ok;
25
26 dump_stds($cmd, '', $out, $err) if $?;
27
28 return ($out, $err);
29 }
30
31 sub go_in {
32 my $orig_dir = cwd();
33 my $dir = $ENV{APACHE_TESTITSELF_BASE_DIR} || '';
34 debug "chdir $dir";
35 chdir $dir or die "failed to chdir to $dir: $!";
36 return $orig_dir;
37 }
38
39 sub go_out {
40 my $dir = shift;
41 debug "chdir $dir";
42 chdir $dir or die "failed to chdir to $dir: $!";
43 }
44
45 # the base dir from which the A-T tests are supposed to be run
46 # we might not be there
47 sub work_dir { $ENV{APACHE_TESTITSELF_BASE_DIR} }
48
49 sub dump_stds {
50 my($cmd, $in, $out, $err) = @_;
51 $cmd = 'unknown' unless length $cmd;
52 $in = '' unless length $in;
53 $out = '' unless length $out;
54 $err = '' unless length $err;
55
56 if ($cmd) {
57 $cmd =~ s/\n$//;
58 $cmd =~ s/^/# /gm;
59 print STDERR "\n\n#== CMD ===\n$cmd\n#=============";
60 }
61 if ($in) {
62 $in =~ s/\n$//;
63 $in =~ s/^/# /gm;
64 print STDERR "\n### STDIN ###\n$in\n##############\n\n\n";
65 }
66 if ($out) {
67 $out =~ s/\n$//;
68 $out =~ s/^/# /gm;
69 print STDERR "\n### STDOUT ###\n$out\n##############\n\n\n";
70 }
71 if ($err) {
72 $err =~ s/\n$//;
73 $err =~ s/^/# /gm;
74 print STDERR "\n### STDERR ###\n$err\n##############\n\n\n";
75 }
76 }
77
78 # if $@ is set dumps the $out and $err streams and dies
79 # otherwise resets the $out and $err streams if $reset_std is true
80 sub check_eval {
81 my($cmd, $out, $err, $reset_std, $msg) = @_;
82 $msg ||= "unknown";
83 if ($@) {
84 dump_stds($cmd, '', $out, $err);
85 die "$@\nError: $msg\n";
86 }
87 # reset the streams in caller
88 ($_[1], $_[2]) = ("", "") if $reset_std;
89 }
90
91 # this function returns an array of configs (hashes) coming from
92 # -config-file command line option
93 sub test_configs {
94 my $config_file = $ENV{APACHE_TESTITSELF_CONFIG_FILE} || '';
95
96 # reset
97 %Apache::TestItSelf::Config = ();
98 @Apache::TestItSelf::Configs = ();
99
100 require $config_file;
101 unless (@Apache::TestItSelf::Configs) {
102 error "can't find test configs in '$config_file'";
103 exit 1;
104 }
105
106 my %global = %Apache::TestItSelf::Config;
107
108 # merge the global config with instance configs
109 my @configs = map { { %global, %$_ } } @Apache::TestItSelf::Configs;
110
111 return @configs;
112 }
113
114
115 1;
116
117 __END__
118
119 =head1 NAME
120
121 MyTest::Util -- helper functions
122
123 =head1 Config files format
124
125 the -config-file command line option specifies which file contains the
126 configurations to run with.
127
128 META: expand
129
130 %Apache::TestItSelf::Config = (
131 perl_exec => "/home/$ENV{USER}/perl/5.8.5-ithread/bin/perl5.8.5",
132 mp_gen => '2.0',
133 httpd_gen => '2.0',
134 httpd_version => 'Apache/2.0.55',
135 timeout => 200,
136 makepl_arg => 'MOD_PERL=2 -libmodperl mod_perl-5.8.5-ithread.so',
137 );
138
139 my $path = "/home/$ENV{USER}/httpd";
140
141 @Apache::TestItSelf::Configs = (
142 {
143 apxs_exec => "$path/prefork/bin/apxs",
144 httpd_exec => "$path/prefork/bin/httpd",
145 httpd_mpm => "prefork",
146 test_verbose => 0,
147 },
148 {
149 apxs_exec => "$path/worker/bin/apxs",
150 httpd_exec => "$path/worker/bin/httpd",
151 httpd_mpm => "worker",
152 test_verbose => 1,
153 },
154 );
155 1;
156
157
158 =cut
159
+0
-44
Apache-Test/Apache-TestItSelf/sample/testitself_conf_apache_test_core.pl less more
0 # This is a config file for testing Apache-Test
1
2 use strict;
3 use warnings FATAL => 'all';
4
5 my $base = "/home/$ENV{USER}";
6
7 my $perl_base = "$base/perl";
8 my $perl_ver = "5.8.8-ithread";
9 my $PERL = "$perl_base/$perl_ver/bin/perl$perl_ver";
10
11 my $httpd_base = "$base/httpd";
12 my $httpd_gen = '2.0';
13 my $httpd_ver = 'Apache/2.2.3';
14 my @mpms = (qw(prefork worker));
15
16 my $mp_gen = 2.0;
17 my $mod_perl_so = "mod_perl-$perl_ver.so";
18
19 %Apache::TestItSelf::Config = (
20 repos_type => 'apache_test_core',
21 perl_exec => $PERL,
22 mp_gen => $mp_gen,
23 httpd_gen => $httpd_gen,
24 httpd_version => $httpd_ver,
25 timeout => 200,
26 test_verbose => 0,
27 );
28
29 @Apache::TestItSelf::Configs = ();
30 foreach my $mpm (@mpms) {
31 push @Apache::TestItSelf::Configs,
32 {
33 apxs_exec => "$httpd_base/$mpm/bin/apxs",
34 httpd_exec => "$httpd_base/$mpm/bin/httpd",
35 httpd_conf => "$httpd_base/$mpm/conf/httpd.conf",
36 httpd_mpm => $mpm,
37 makepl_arg => "MOD_PERL=2 -libmodperl $httpd_base/$mpm/modules/$mod_perl_so",
38 };
39 }
40
41 1;
42
43
+0
-43
Apache-Test/Apache-TestItSelf/sample/testitself_conf_mp2_core.pl less more
0 # This is a config file for testing modperl 2.0 core
1
2 use strict;
3 use warnings FATAL => 'all';
4
5 my $base = "/home/$ENV{USER}";
6
7 my $perl_base = "$base/perl";
8 my $perl_ver = "5.8.8-ithread";
9 my $PERL = "$perl_base/$perl_ver/bin/perl$perl_ver";
10
11 my $httpd_base = "$base/httpd/svn";
12 my $httpd_gen = '2.0';
13 my $httpd_ver = 'Apache/2.2.3';
14 my @mpms = (qw(prefork worker));
15
16 my $mp_gen = 2.0;
17 my $mod_perl_so = "mod_perl-$perl_ver.so";
18 my $common_makepl_arg = "MP_MAINTAINER=1";
19
20 %Apache::TestItSelf::Config = (
21 repos_type => 'mp2_core',
22 perl_exec => $PERL,
23 mp_gen => $mp_gen,
24 httpd_gen => $httpd_gen,
25 httpd_version => $httpd_ver,,
26 timeout => 900, # make test may take a long time
27 test_verbose => 0,
28 );
29
30 @Apache::TestItSelf::Configs = ();
31 foreach my $mpm (@mpms) {
32 push @Apache::TestItSelf::Configs,
33 {
34 apxs_exec => "$httpd_base/$mpm/bin/apxs",
35 httpd_exec => "$httpd_base/$mpm/bin/httpd",
36 httpd_conf => "$httpd_base/$mpm/conf/httpd.conf",
37 httpd_mpm => $mpm,
38 makepl_arg => "MP_APXS=$httpd_base/$mpm/bin/apxs $common_makepl_arg",
39 };
40 }
41
42 1;
+0
-43
Apache-Test/Apache-TestItSelf/sample/testitself_conf_mp2_modules.pl less more
0 # This is a config file for testing modperl 2.0 Apache:: 3rd party modules
1
2 use strict;
3 use warnings FATAL => 'all';
4
5 my $base = "/home/$ENV{USER}";
6
7 my $perl_base = "$base/perl";
8 my $perl_ver = "5.8.8-ithread";
9 my $PERL = "$perl_base/$perl_ver/bin/perl$perl_ver";
10
11 my $httpd_base = "$base/httpd/svn";
12 my $httpd_gen = '2.0';
13 my $httpd_ver = 'Apache/2.2.3';
14 my @mpms = (qw(prefork worker));
15
16 my $mp_gen = 2.0;
17 my $mod_perl_so = "mod_perl-$perl_ver.so";
18
19 %Apache::TestItSelf::Config = (
20 repos_type => 'mp2_cpan_modules',
21 perl_exec => $PERL,
22 mp_gen => $mp_gen,
23 httpd_gen => $httpd_gen,
24 httpd_version => $httpd_ver,
25 timeout => 200,
26 test_verbose => 0,
27 );
28
29
30 @Apache::TestItSelf::Configs = ();
31 foreach my $mpm (@mpms) {
32 push @Apache::TestItSelf::Configs,
33 {
34 apxs_exec => "$httpd_base/$mpm/bin/apxs",
35 httpd_exec => "$httpd_base/$mpm/bin/httpd",
36 httpd_conf => "$httpd_base/$mpm/conf/httpd.conf",
37 httpd_mpm => $mpm,
38 makepl_arg => "MOD_PERL=2 -libmodperl $httpd_base/$mpm/modules/$mod_perl_so",
39 };
40 }
41
42 1;
+0
-123
Apache-Test/Apache-TestItSelf/t/TEST.PL less more
0 use strict;
1
2 use lib qw(../../lib ../lib ./lib);
3
4 use strict;
5 use warnings FATAL => 'all';
6
7 use Test::Harness;
8 use FindBin;
9 use File::Spec::Functions qw(catdir);
10 use Apache::TestTrace;
11 use Cwd qw(cwd);
12
13 use Getopt::Long qw(GetOptions);
14
15 my %usage = (
16 'base-dir' => 'which dir to run the tests in (default: Apache-TestMe)',
17 'config-file' => 'which config file to use',
18 'help' => 'display this message',
19 'trace=T' => 'change tracing default to: warning, notice, ' .
20 'info, debug, ...',
21 'verbose[=1]' => 'verbose output',
22 );
23
24 my @flag_opts = qw(verbose help);
25 my @string_opts = qw(config-file base-dir trace);
26
27 my %opts;
28 # grab from @ARGV only the options that we expect
29 GetOptions(\%opts, @flag_opts, (map "$_=s", @string_opts));
30
31 # t/TEST -v -base /home/$ENV{USER}/apache.org/Apache-Test \
32 # -config /home/$ENV{USER}/.apache-test/apache_test_config.pm
33 #
34
35 $Test::Harness::verbose = 1 if $opts{verbose};
36
37 opt_help() if $opts{help};
38 opt_help() unless $opts{'config-file'};
39
40 if ($opts{'base-dir'}) {
41 unless (-d $opts{'base-dir'}) {
42 error "can't find $opts{'base-dir'}";
43 opt_help();
44 }
45 }
46 else {
47 my $dir = catdir $FindBin::Bin, qw(.. Apache-TestMe);
48 # get rid of relative paths
49 die "can't find the default dir $dir" unless -d $dir;
50 my $from = cwd();
51 chdir $dir or die "can't chdir to $dir: $!";
52 $dir = cwd();
53 chdir $from or die "can't chdir to $from: $!";
54 $opts{'base-dir'} = $dir;
55 }
56
57
58 unless (-r $opts{'config-file'}) {
59 error "can't read $opts{'config-file'}";
60 opt_help();
61 }
62
63 if ($opts{trace}) {
64 my %levels = map {$_ => 1} @Apache::TestTrace::Levels;
65 if (exists $levels{ $opts{trace} }) {
66 $Apache::TestTrace::Level = $opts{trace};
67 # propogate the override for the server-side.
68 # -trace overrides any previous APACHE_TEST_TRACE_LEVEL settings
69 $ENV{APACHE_TEST_TRACE_LEVEL} = $opts{trace};
70 }
71 else {
72 error "unknown trace level: $opts{trace}",
73 "valid levels are: @Apache::TestTrace::Levels";
74 opt_help();
75 }
76 }
77
78 # forward the data to the sub-processes run by Test::Harness
79 $ENV{APACHE_TESTITSELF_CONFIG_FILE} = $opts{'config-file'};
80 $ENV{APACHE_TESTITSELF_BASE_DIR} = $opts{'base-dir'};
81
82 run_my_tests();
83
84 sub run_my_tests {
85
86 my $base = "t";
87 unless (-d $base) {
88 # try to move into the top-level directory
89 chdir ".." or die "Can't chdir: $!";
90 }
91
92 my @tests;
93 if (@ARGV) {
94 for (@ARGV) {
95 if (-d $_) {
96 push @tests, <$_/*.t>;
97 } else {
98 $_ .= ".t" unless /\.t$/;
99 push @tests, $_;
100 }
101 }
102 } else {
103 chdir $base;
104 @tests = sort (<*.t>);
105 chdir "..";
106 @tests = map { "$base/$_" } @tests;
107 }
108
109 runtests @tests;
110 }
111
112 sub opt_help {
113 print <<EOM;
114 usage: TEST [options ...]
115 where options include:
116 EOM
117
118 for (sort keys %usage){
119 printf " -%-13s %s\n", $_, $usage{$_};
120 }
121 exit;
122 }
+0
-117
Apache-Test/Apache-TestItSelf/t/httpd_arg.t less more
0 #
1 # basic testing with -httpd argument passed explicitly (to
2 # Makefile.PL, to t/TEST, etc.)
3 #
4
5 # XXX: -apxs should be really the same test but passing -apxs instead
6 # of -httpd, so consider to just run both in this test
7
8 use strict;
9 use warnings FATAL => 'all';
10
11 use Test::More;
12 use MyTest::Util qw(myrun3 go_in go_out test_configs);
13 use Apache::TestConfig ();
14
15 my @configs = test_configs();
16 my $tests_per_config = 18;
17 plan tests => $tests_per_config * @configs;
18
19 my $orig_dir = go_in();
20
21 for my $c (@configs) {
22 Apache::TestConfig::custom_config_nuke();
23 $ENV{APACHE_TEST_NO_STICKY_PREFERENCES} = 1;
24 makefile_pl_plus_httpd_arg($c);
25
26 # this one will have custom config, but it shouldn't interrupt
27 # with the explicit one
28 # XXX: useless at the moment, since the previously stored custom
29 # config and the explicit config both point to the same config
30 $ENV{APACHE_TEST_NO_STICKY_PREFERENCES} = 0;
31 makefile_pl_plus_httpd_arg($c);
32
33 Apache::TestConfig::custom_config_nuke();
34 t_TEST_plus_httpd_arg($c);
35 }
36
37 go_out($orig_dir);
38
39 # 6 tests
40 # explicit Makefile.PL -httpd argument
41 sub makefile_pl_plus_httpd_arg {
42 my $c = shift;
43
44 my($cmd, $out, $err);
45
46 # clean and ignore the results
47 $cmd = "make clean";
48 ($out, $err) = myrun3($cmd);
49
50 my $makepl_arg = $c->{makepl_arg} || '';
51 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg " .
52 "-httpd $c->{httpd_exec} -httpd_conf $c->{httpd_conf}";
53 ($out, $err) = myrun3($cmd);
54 unlike $err, qr/\[ error\]/, $cmd;
55
56 $cmd = "make";
57 ($out, $err) = myrun3($cmd);
58 is $err, "", $cmd;
59
60 my $test_verbose = $c->{test_verbose} ? "TEST_VERBOSE=1" : "";
61 $cmd = "make test $test_verbose";
62 ($out, $err) = myrun3($cmd);
63 like $out, qr/using $c->{httpd_version} \($c->{httpd_mpm} MPM\)/, $cmd;
64 like $out, qr/All tests successful/, $cmd;
65 unlike $err, qr/\[ error\]/, $cmd;
66
67 # test that httpd is found in t/REPORT (if exists)
68 SKIP: {
69 $cmd = "t/REPORT";
70 skip "$cmd doesn't exist", 1 unless -e $cmd;
71
72 ($out, $err) = myrun3($cmd);
73 like $out, qr/Server version: $c->{httpd_version}/, $cmd;
74 }
75 }
76
77 # explicit t/TEST -httpd argument
78 sub t_TEST_plus_httpd_arg {
79 my $c = shift;
80
81 my($cmd, $out, $err);
82
83 # clean and ignore the results
84 $cmd = "make clean";
85 ($out, $err) = myrun3($cmd);
86
87 my $makepl_arg = $c->{makepl_arg} || '';
88 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg";
89 ($out, $err) = myrun3($cmd);
90 unlike $err, qr/\[ error\]/, $cmd;
91
92 $cmd = "make";
93 ($out, $err) = myrun3($cmd);
94 is $err, "", $cmd;
95
96 my $test_verbose = $c->{test_verbose} ? "-v " : "";
97 $cmd = "t/TEST -httpd $c->{httpd_exec} $test_verbose";
98 ($out, $err) = myrun3($cmd);
99 like $out,
100 qr/using $c->{httpd_version} \($c->{httpd_mpm} MPM\)/,
101 $cmd;
102 like $out, qr/All tests successful/, $cmd;
103 unlike $err, qr/\[ error\]/, $cmd;
104
105 # test that httpd is found in t/REPORT (if exists)
106 SKIP: {
107 $cmd = "t/REPORT";
108 skip "$cmd doesn't exist", 1 unless -e $cmd;
109
110 ($out, $err) = myrun3($cmd);
111 like $out, qr/Server version: $c->{httpd_version}/, $cmd;
112 }
113 }
114
115 __END__
116
+0
-158
Apache-Test/Apache-TestItSelf/t/interactive.t less more
0 #
1 # interactive testing (when A-T) can't figure out the configuration
2 #
3
4 use Test::More;
5
6 use strict;
7 use warnings FATAL => 'all';
8
9 use IPC::Run qw(start pump finish timeout);
10 use Cwd qw(cwd);
11 use File::Spec::Functions qw(catfile);
12
13 use MyTest::Util qw(myrun3 go_in go_out work_dir check_eval
14 test_configs);
15
16 use Apache::TestConfig ();
17 use Apache::TestTrace;
18
19 # in this test we don't want any cached preconfiguration to kick in
20 # A-T is aware of this env var and won't load neither custom config, nor
21 # Apache/Build.pm from mod_perl2.
22 local $ENV{APACHE_TEST_INTERACTIVE_CONFIG_TEST} = 1;
23
24 my @configs = test_configs();
25 if ($configs[0]{repos_type} eq 'mp2_core') {
26 plan skip_all => "modperl2 doesn't run interactive config";
27 }
28 else {
29 my $tests_per_config = 11;
30 plan tests => $tests_per_config * @configs + 1;
31 }
32
33 my $orig_dir = go_in();
34
35 my $cwd = cwd();
36 my $expected_work_dir = work_dir();
37 is $cwd, $expected_work_dir, "working in $expected_work_dir";
38
39 debug "cwd: $cwd";
40
41 for my $c (@configs) {
42
43 # install the sticky custom config
44 install($c);
45
46 # interactive config doesn't work with this var on
47 $ENV{APACHE_TEST_NO_STICKY_PREFERENCES} = 0;
48 basic($c);
49 }
50
51 go_out($orig_dir);
52
53 # 4 tests
54 sub install {
55 my $c = shift;
56
57 my($cmd, $out, $err);
58
59 $cmd = "make clean";
60 ($out, $err) = myrun3($cmd);
61 # ignore the results
62
63 my $makepl_arg = $c->{makepl_arg} || '';
64 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg " .
65 "-httpd $c->{httpd_exec} -apxs $c->{apxs_exec}";
66 ($out, $err) = myrun3($cmd);
67 my $makefile = catfile $expected_work_dir, "Makefile";
68 is -e $makefile, 1, "generated $makefile";
69 unlike $err, qr/\[ error\]/, "checking for errors";
70
71 $cmd = "make";
72 ($out, $err) = myrun3($cmd);
73 is $err, "", $cmd;
74
75 $cmd = "make install";
76 ($out, $err) = myrun3($cmd);
77 unlike $err, qr/\[ error\]/, $cmd;
78 }
79
80 # 7 tests
81 sub basic {
82 my $c = shift;
83
84 my($cmd, $out, $err);
85
86 # clean and ignore the results
87 $cmd = "make clean";
88 ($out, $err) = myrun3($cmd);
89
90 my $makepl_arg = $c->{makepl_arg} || '';
91 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg";
92 ($out, $err) = myrun3($cmd);
93 unlike $err, qr/\[ error\]/, $cmd;
94
95 $cmd = "make";
96 ($out, $err) = myrun3($cmd);
97 is $err, "", $cmd;
98
99 {
100 my $in;
101 my $expected = '';
102 my @cmd = qw(make test);
103 push @cmd, "TEST_VERBOSE=1" if $c->{test_verbose};
104 $cmd = join " ", @cmd;
105
106 # bypass the -t STDIN checks to still ensure the interactive
107 # config prompts
108 $ENV{APACHE_TEST_INTERACTIVE_PROMPT_OK} = 1;
109
110 $in = '';
111 $out = '';
112 $err = '';
113 my $h = start \@cmd, \$in, \$out, \$err, timeout($c->{timeout});
114
115 # here the expect fails if the interactive config doesn't kick
116 # in, but for example somehow figures out the needed
117 # information (httpd/apxs) and runs the test suite normally
118 $expected = "Please provide a full path to 'httpd' executable";
119 eval { $h->pump until $out =~ /$expected/gc };
120 my $reset_std = 1;
121 check_eval($cmd, $out, $err, $reset_std,
122 "interactive config wasn't invoked");
123
124 $in .= "$c->{httpd_exec}\n" ;
125 $expected = "Please provide a full path to .*? 'apxs' executable";
126 eval { $h->pump until $out =~ /$expected/gc };
127 $reset_std = 1;
128 check_eval($cmd, $out, $err, $reset_std,
129 "interactive config had a problem");
130
131 $in .= "$c->{apxs_exec}\n" ;
132 eval { $h->finish };
133 $reset_std = 0; # needed for later sub-tests
134 check_eval($cmd, $out, $err, $reset_std,
135 "failed to finish $cmd");
136 like $out, qr/using $c->{httpd_version} \($c->{httpd_mpm} MPM\)/,
137 "$cmd: using $c->{httpd_version} \($c->{httpd_mpm} MPM";
138 like $out, qr/All tests successful/, "$cmd: All tests successful";
139 unlike $err, qr/\[ error\]/, "$cmd: no error messages";
140 }
141
142 $cmd = "make install";
143 ($out, $err) = myrun3($cmd);
144 unlike $err, qr/\[ error\]/, $cmd;
145
146 # test that httpd is found in t/REPORT (if exists)
147 SKIP: {
148 $cmd = "t/REPORT";
149 skip "$cmd doesn't exist", 1 unless -e $cmd;
150
151 ($out, $err) = myrun3($cmd);
152 like $out, qr/Server version: $c->{httpd_version}/, $cmd;
153 }
154 }
155
156 __END__
157
+0
-101
Apache-Test/Apache-TestItSelf/t/minmaxclients.t less more
0 #
1 # -minclients / -maxclients argument passed explicitly (to
2 # Makefile.PL, to t/TEST, etc.)
3 #
4
5 use strict;
6 use warnings FATAL => 'all';
7
8 use Test::More;
9 use MyTest::Util qw(myrun3 go_in go_out test_configs);
10 use Apache::TestConfig ();
11
12 my @configs = test_configs();
13 my $tests_per_config = 18;
14 plan tests => $tests_per_config * @configs;
15
16 my $orig_dir = go_in();
17
18 # min/maxclients of 10 should work for pretty much any test suite, so
19 # for now hardcoded the number in this test
20 my $clients = 10;
21 for my $c (@configs) {
22 for my $opt_name (qw(minclients maxclients)) {
23 my $opt = "-$opt_name $clients";
24 makefile_pl_plus_opt($c, $opt);
25 t_TEST_plus_opt($c, $opt);
26 }
27 }
28
29 go_out($orig_dir);
30
31 # 4 sub tests
32 # explicit Makefile.PL -(mix|max)clients
33 sub makefile_pl_plus_opt {
34 my $c = shift;
35 my $opt = shift;
36
37 my($cmd, $out, $err);
38
39 # clean and ignore the results
40 $cmd = "make clean";
41 ($out, $err) = myrun3($cmd);
42
43 my $makepl_arg = $c->{makepl_arg} || '';
44 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg $opt " .
45 "-httpd $c->{httpd_exec} -httpd_conf $c->{httpd_conf}";
46 ($out, $err) = myrun3($cmd);
47 unlike $err, qr/\[ error\]/, $cmd;
48
49 $cmd = "make";
50 ($out, $err) = myrun3($cmd);
51 is $err, "", $cmd;
52
53 my $test_verbose = $c->{test_verbose} ? "TEST_VERBOSE=1" : "";
54 $cmd = "make test $test_verbose";
55 ($out, $err) = myrun3($cmd);
56 like $out, qr/All tests successful/, $cmd;
57 unlike $err, qr/\[ error\]/, $cmd;
58 }
59
60 # 5 tests
61 # explicit t/TEST -(mix|max)clients
62 sub t_TEST_plus_opt {
63 my $c = shift;
64 my $opt = shift;
65
66 my($cmd, $out, $err);
67
68 # clean and ignore the results
69 $cmd = "make clean";
70 ($out, $err) = myrun3($cmd);
71
72 my $makepl_arg = $c->{makepl_arg} || '';
73 $cmd = "$c->{perl_exec} Makefile.PL $makepl_arg";
74 ($out, $err) = myrun3($cmd);
75 unlike $err, qr/\[ error\]/, $cmd;
76
77 $cmd = "make";
78 ($out, $err) = myrun3($cmd);
79 is $err, "", $cmd;
80
81 # the bug was:
82 # t/TEST -conf
83 # t/TEST -maxclients 1
84 #default_ VirtualHost overlap on port 8530, the first has precedence
85 #(98)Address already in use: make_sock: could not bind to address
86 #0.0.0.0:8530 no listening sockets available, shutting down
87
88 my $test_verbose = $c->{test_verbose} ? "-v " : "";
89 $cmd = "t/TEST -httpd $c->{httpd_exec} $test_verbose -conf";
90 ($out, $err) = myrun3($cmd);
91 unlike $err, qr/\[ error\]/, $cmd;
92
93 $cmd = "t/TEST -httpd $c->{httpd_exec} $test_verbose $opt";
94 ($out, $err) = myrun3($cmd);
95 like $out, qr/All tests successful/, $cmd;
96 unlike $err, qr/\[ error\]/, $cmd;
97 }
98
99 __END__
100
+7
-0
Apache-Test/Changes less more
44 =head1 CHANGES
55
66 =over 3
7
8 =item 1.39 Apr 21 2015
9
10 Test scripts can now test if perl has a fork() implementation available by
11 using the Apache::Test::need_fork() function. [Steve Hay]
12
13 CPAN RT#87620: Add -D APACHE2_4 to identify httpd-2.4. [Michael Schout]
714
815 =item 1.38 Aug 6 2012
916
+0
-72
Apache-Test/MANIFEST less more
0 Changes
1 CONTRIBUTORS
2 LICENSE
3 MANIFEST
4 META.yml
5 Makefile.PL
6 README
7 INSTALL
8 SUPPORT
9 ToDo
10 lib/Apache/Test.pm
11 lib/Apache/Test5005compat.pm
12 lib/Apache/TestBuild.pm
13 lib/Apache/TestClient.pm
14 lib/Apache/TestCommon.pm
15 lib/Apache/TestCommonPost.pm
16 lib/Apache/TestConfig.pm
17 lib/Apache/TestConfigC.pm
18 lib/Apache/TestConfigParse.pm
19 lib/Apache/TestConfigParrot.pm
20 lib/Apache/TestConfigPerl.pm
21 lib/Apache/TestConfigPHP.pm
22 lib/Apache/TestHandler.pm
23 lib/Apache/TestHarness.pm
24 lib/Apache/TestHarnessPHP.pm
25 lib/Apache/TestMB.pm
26 lib/Apache/TestMM.pm
27 lib/Apache/TestPerlDB.pm
28 lib/Apache/TestReport.pm
29 lib/Apache/TestReportPerl.pm
30 lib/Apache/TestRequest.pm
31 lib/Apache/TestRun.pm
32 lib/Apache/TestRunParrot.pm
33 lib/Apache/TestRunPerl.pm
34 lib/Apache/TestRunPHP.pm
35 lib/Apache/TestSSLCA.pm
36 lib/Apache/TestServer.pm
37 lib/Apache/TestSmoke.pm
38 lib/Apache/TestSmokePerl.pm
39 lib/Apache/TestSort.pm
40 lib/Apache/TestTrace.pm
41 lib/Apache/TestUtil.pm
42 lib/Bundle/ApacheTest.pm
43 t/alltest/01bang.t
44 t/alltest/all.t
45 t/alltest2/01bang.t
46 t/alltest2/all.t
47 t/bad_coding.t
48 t/cgi-bin/cookies.pl.PL
49 t/cgi-bin/next_available_port.pl.PL
50 t/conf/extra.conf.in
51 t/conf/modperl_extra.pl.in
52 t/cookies.t
53 t/import.t
54 t/log_watch.t
55 t/more/01testpm.t
56 t/more/02testmore.t
57 t/more/03testpm.t
58 t/more/04testmore.t
59 t/more/all.t
60 t/next_available_port.t
61 t/ping.t
62 t/redirect.t
63 t/request.t
64 t/response/TestMore/testmorepm.pm
65 t/response/TestMore/testpm.pm
66 t/sok.t
67 t/TEST.PL
68
69
70 META.yml Module meta-data (added by MakeMaker)
71
+0
-18
Apache-Test/META.yml less more
0 name: Apache-Test
1 version_from: lib/Apache/Test.pm
2 installdirs: site
3
4 requires:
5 Cwd: 2.06
6 File::Spec: 0.8
7
8 distribution_type: module
9
10 no_index:
11 package:
12 - HTTP::Request::Common
13 - warnings
14 - TestMore::testmorepm
15 - TestMore::testpm
16 directory:
17 - Apache-TestItSelf
+13
-7
Apache-Test/Makefile.PL less more
8585 NO_META => $no_meta,
8686 dist => {
8787 COMPRESS => 'gzip -9f', SUFFIX => 'gz',
88 PREOP => 'find $(DISTVNAME) -type d -print|xargs chmod 0755 && ' .
89 'find $(DISTVNAME) -type f -print|xargs chmod 0644',
90 TO_UNIX => 'find $(DISTVNAME) -type f -print|xargs dos2unix'
8891 },
8992 clean => {
9093 FILES => "@clean_files",
97100
98101 sub check_prereqs {
99102 my %fail = ();
100 for (keys %prereq) {
103 for (sort keys %prereq) {
101104 unless (chk_version($_, $prereq{$_})) {
102105 $fail{$_} = $prereq{$_};
103106 }
104107 }
105108 if (%fail) {
106109 error "\nThe following Apache-Test dependencies aren't satisfied:",
107 map { "\t$_: $fail{$_}" } keys %fail;
110 map { "\t$_: $fail{$_}" } sort keys %fail;
108111 error "Install those from http://search.cpan.org and try again";
109112 exit 0;
110113 }
123126
124127 my $vstr = ${"${pkg}::VERSION"} ? "found v" . ${"${pkg}::VERSION"}
125128 : "not found";
126 my $vnum = ${"${pkg}::VERSION"} || 0;
129 my $vnum = eval(${"${pkg}::VERSION"}) || 0;
127130
128131 print $vnum >= $wanted ? "ok\n" : " " . $vstr . "\n";
129132
145148 close $fh;
146149 }
147150
151 sub add_dep {
152 my($string, $targ, $add) = @_;
153 $$string =~ s/($targ\s+::)/$1 $add/;
154 }
155
156 no warnings 'redefine';
148157 sub MY::postamble {
149158 my $self = shift;
150159
159168 return $string;
160169 }
161170
162 sub add_dep {
163 my($string, $targ, $add) = @_;
164 $$string =~ s/($targ\s+::)/$1 $add/;
165 }
171
166172
167173 sub MY::test {
168174 my $self = shift;
+4
-4
Apache-Test/RELEASE less more
3434 (or maybe longer to give most people a chance to catch up). no need
3535 to tag this package
3636
37 Subject: [RELEASE CANDIDATE] Apache-Test-1.38 RC\d+
37 Subject: [RELEASE CANDIDATE] Apache-Test-1.39 RC\d+
3838
3939 a. if problems are detected during stage 2, repeat stages 1 and 2.
4040
6666 5. Announce the package
6767
6868 a. post ... to the modperl, announce lists
69 Subject: [ANNOUNCE] Apache-Test 1.38
69 Subject: [ANNOUNCE] Apache-Test 1.39
7070 include
7171 - MD5 sig (as it comes from CPAN upload announce).
7272 - the latest Changes
7878 b. edit ./Changes:
7979 - start a new item with incremented version + '-dev'
8080
81 =item 1.39-dev
81 =item 1.40-dev
8282
8383 c. bump up version numbers in this file to make it easier to do the
8484 next release.
8686 $ perl -pi -e 's/(\d+)\.(\d+)/join(".", $1, $2+1)/eg' RELEASE
8787
8888 d. commit Changes
89 % svn ci -m "start 1.39-dev cycle" Changes RELEASE lib/Apache/Test.pm
89 % svn ci -m "start 1.40-dev cycle" Changes RELEASE lib/Apache/Test.pm
+22
-2
Apache-Test/lib/Apache/Test.pm less more
3636
3737 use vars qw(@ISA @EXPORT %EXPORT_TAGS $VERSION %SubTests @SkipReasons);
3838
39 $VERSION = '1.38';
39 $VERSION = '1.39';
4040
4141 my @need = qw(need_lwp need_http11 need_cgi need_access need_auth
4242 need_module need_apache need_min_apache_version
4343 need_apache_version need_perl need_min_perl_version
44 need_min_module_version need_threads need_apache_mpm
44 need_min_module_version need_threads need_fork need_apache_mpm
4545 need_php need_php4 need_ssl need_imagemap need_cache_disk);
4646
4747 my @have = map { (my $need = $_) =~ s/need/have/; $need } @need;
593593 return $status;
594594 }
595595
596 sub need_fork {
597 my $have_fork = $Config{d_fork} ||
598 $Config{d_pseudofork} ||
599 (($^O eq 'MSWin32' || $^O eq 'NetWare') &&
600 $Config{useithreads} &&
601 $Config{ccflags} =~ /-DPERL_IMPLICIT_SYS/);
602
603 if (!$have_fork) {
604 push @SkipReasons, 'The fork function is unimplemented';
605 return 0;
606 }
607 else {
608 return 1;
609 }
610 }
611
596612 sub under_construction {
597613 push @SkipReasons, "This test is under construction";
598614 return 0;
898914
899915 requires Perl 5.8.1 or higher.
900916
917 =item need_fork
918
919 Requires the perl built-in function C<fork> to be implemented.
920
901921 =item need_module
902922
903923 plan tests => 5, need_module 'CGI';
+5
-5
Apache-Test/lib/Apache/TestConfig.pm less more
152152 sub passenv_makestr {
153153 my @vars;
154154
155 for (keys %passenv) {
155 for (sort keys %passenv) {
156156 push @vars, "$_=\$($_)";
157157 }
158158
375375 # not sure what else could go wrong but we can't continue
376376 die "something is wrong, mod_perl 2.0 build should have " .
377377 "supplied all the needed information to run the tests. " .
378 "Please post lib/Apache/BuildConfig.pm along with the " .
378 "Please post lib/Apache2/BuildConfig.pm along with the " .
379379 "bug report";
380380 }
381381
11231123 $self->cmodules_clean;
11241124 $self->sslca_clean;
11251125
1126 for (keys %{ $self->{clean}->{files} }) {
1126 for (sort keys %{ $self->{clean}->{files} }) {
11271127 if (-e $_) {
11281128 debug "unlink $_";
11291129 unlink $_;
16191619 # but wasn't included in the system-wide httpd.conf
16201620
16211621 print $out "<IfModule mod_alias.c>\n";
1622 for (keys %aliases) {
1622 for (sort keys %aliases) {
16231623 next unless $vars->{$aliases{$_}};
16241624 print $out " Alias /getfiles-$_ $vars->{$aliases{$_}}\n";
16251625 }
16711671 # last run and thus avoid the reconfiguration?
16721672 {
16731673 my $passenv = passenv();
1674 if (my @env_vars = grep { $ENV{$_} } keys %$passenv) {
1674 if (my @env_vars = sort grep { $ENV{$_} } keys %$passenv) {
16751675 push @reasons, "environment variables (@env_vars) are set";
16761676 }
16771677 }
+3
-2
Apache-Test/lib/Apache/TestSSLCA.pm less more
9999 };
100100
101101 #generate DSA versions of the server certs/keys
102 while (my($key, $val) = each %$cert_dn) {
102 for my $key (keys %$cert_dn) {
103103 next unless $key =~ /^server/;
104 my $val = $$cert_dn{$key};
104105 my $name = join '_', $key, 'dsa';
105106 $cert_dn->{$name} = { %$val }; #copy
106107 $cert_dn->{$name}->{OU} =~ s/rsa/dsa/;
240241
241242 default_days = 365 # how long to certify for
242243 default_crl_days = 365 # how long before next CRL
243 default_md = md5 # which md to use.
244 default_md = sha1 # which md to use.
244245 preserve = no # keep passed DN ordering
245246
246247 [ policy_anything ]
+17
-1
Apache-Test/lib/Apache/TestServer.pm less more
8484 $self->{rev} = 0; # unknown
8585 }
8686
87 ($self->{revminor}) = $self->{version} =~ m|/\d\.(\d)|;
88
89 if ($self->{revminor}) {
90 debug "Matched Apache revminor $self->{version} $self->{revminor}";
91 }
92 else {
93 $self->{revminor} = 0;
94 }
95
8796 $self;
8897 }
8998
125134
126135 sub dversion {
127136 my $self = shift;
128 "-D APACHE$self->{rev}";
137
138 my $dv = "-D APACHE$self->{rev}";
139
140 if ($self->{rev} == 2 and $self->{revminor} == 4) {
141 $dv .= " -D APACHE2_4";
142 }
143
144 return $dv;
129145 }
130146
131147 sub config_defines {
+1
-1
Apache-Test/lib/Apache/TestUtil.pm less more
5151 $Apache::TestUtil::DEBUG_OUTPUT = \*STDOUT;
5252
5353 # 5.005's Data::Dumper has problems to dump certain datastructures
54 use constant HAS_DUMPER => eval { $] >= 5.6 && require Data::Dumper; };
54 use constant HAS_DUMPER => eval { $] >= 5.006 && require Data::Dumper; };
5555 use constant INDENT => 4;
5656
5757 {
+1
-1
Apache-Test/t/log_watch_for_broken_lines.t less more
66 use Apache::TestUtil qw/t_start_file_watch t_file_watch_for
77 t_cmp t_catfile t_append_file/;
88
9 plan tests => 5;
9 plan tests => 5, need_fork;
1010
1111 my $fn=t_catfile(Apache::Test::vars->{t_logs}, 'watch');
1212 unlink $fn;
+6
-6
Apache-Test/t/sok.t less more
6767 sok {1};
6868 }
6969 Test::ok $output=~/^ok 1$/m &&
70 $output=~/^ok 2 # skip skipping this subtest$/m &&
70 $output=~/^ok 2 # skip skipping this subtest$/mi &&
7171 $output=~/^ok 3$/m;
7272
7373 {
8585 sok {1};
8686 }
8787 Test::ok $output=~/^ok 1$/m &&
88 $output=~/^ok 2 # skip skipping this subtest$/m &&
88 $output=~/^ok 2 # skip skipping this subtest$/mi &&
8989 $output=~/^ok 3$/m;
9090
9191 {
143143 sok {1};
144144 }
145145 Test::ok $output=~/^ok 1$/m &&
146 $output=~/^ok 2 # skip skipping this subtest$/m &&
147 $output=~/^ok 3 # skip skipping this subtest$/m &&
146 $output=~/^ok 2 # skip skipping this subtest$/mi &&
147 $output=~/^ok 3 # skip skipping this subtest$/mi &&
148148 $output=~/^ok 4$/m;
149149
150150 {
162162 sok {1};
163163 }
164164 Test::ok $output=~/^ok 1$/m &&
165 $output=~/^ok 2 # skip skipping this subtest$/m &&
166 $output=~/^ok 3 # skip skipping this subtest$/m &&
165 $output=~/^ok 2 # skip skipping this subtest$/mi &&
166 $output=~/^ok 3 # skip skipping this subtest$/mi &&
167167 $output=~/^ok 4$/m;
+7
-1
Changes less more
99
1010 =over 3
1111
12 =item 2.0.9-dev
12 =item 2.0.9-rc1
13
14 Add support for Apache httpd-2.4.x. [Torsten Foertsch, Jan Kaluza,
15 Steve Hay, Gozer]
16
17 Don't call modperl_threaded_mpm() et al. from XS code. Fixes Debian Bug
18 #765174. [Niko Tyni <ntyni@debian.org>]
1319
1420 Make sure modperl_interp_select uses r->server rather than the passed s
1521 parameter to find the interpreter pool to pull an interpreter from. This
+1064
-0
MANIFEST less more
0 Apache-Reload/Changes
1 Apache-Reload/LICENSE
2 Apache-Reload/MANIFEST
3 Apache-Reload/Makefile.PL
4 Apache-Reload/NOTICE
5 Apache-Reload/README
6 Apache-Reload/RELEASE
7 Apache-Reload/lib/Apache/Reload.pm
8 Apache-Reload/lib/Apache2/Reload.pm
9 Apache-Reload/t/all.t
10 Apache-Reload/t/conf/extra.last.conf.in
11 Apache-Reload/t/lib/Apache/TestReload.pm
12 Apache-Reload/t/lib/Apache2/TestReload.pm
13 Apache-Reload/t/reload.t
14 Apache-SizeLimit/Changes
15 Apache-SizeLimit/INSTALL
16 Apache-SizeLimit/LICENSE
17 Apache-SizeLimit/MANIFEST
18 Apache-SizeLimit/MANIFEST.SKIP
19 Apache-SizeLimit/Makefile.PL
20 Apache-SizeLimit/README
21 Apache-SizeLimit/RELEASE
22 Apache-SizeLimit/lib/Apache/SizeLimit.pm
23 Apache-SizeLimit/lib/Apache/SizeLimit/Core.pm
24 Apache-SizeLimit/lib/Apache2/SizeLimit.pm
25 Apache-SizeLimit/t/apache/all.t
26 Apache-SizeLimit/t/apache/check_n_requests2.t
27 Apache-SizeLimit/t/apache/zzz_check_n_requests.t
28 Apache-SizeLimit/t/apache2/all.t
29 Apache-SizeLimit/t/apache2/check_n_requests2.t
30 Apache-SizeLimit/t/apache2/zzz_check_n_requests.t
31 Apache-SizeLimit/t/conf/modperl_extra.pl.in
32 Apache-SizeLimit/t/pod.t
33 Apache-SizeLimit/t/response/TestApache/basic.pm
34 Apache-SizeLimit/t/response/TestApache/check_n_requests2.pm
35 Apache-SizeLimit/t/response/TestApache/deprecated.pm
36 Apache-SizeLimit/t/response/TestApache/zzz_check_n_requests.pm
37 Apache-SizeLimit/t/response/TestApache2/basic.pm
38 Apache-SizeLimit/t/response/TestApache2/check_n_requests2.pm
39 Apache-SizeLimit/t/response/TestApache2/deprecated.pm
40 Apache-SizeLimit/t/response/TestApache2/zzz_check_n_requests.pm
41 Apache-Test/CONTRIBUTORS
42 Apache-Test/Changes
43 Apache-Test/INSTALL
44 Apache-Test/LICENSE
45 Apache-Test/Makefile.PL
46 Apache-Test/README
47 Apache-Test/RELEASE
48 Apache-Test/SUPPORT
49 Apache-Test/ToDo
50 Apache-Test/lib/Apache/Test.pm
51 Apache-Test/lib/Apache/Test5005compat.pm
52 Apache-Test/lib/Apache/TestBuild.pm
53 Apache-Test/lib/Apache/TestClient.pm
54 Apache-Test/lib/Apache/TestCommon.pm
55 Apache-Test/lib/Apache/TestCommonPost.pm
56 Apache-Test/lib/Apache/TestConfig.pm
57 Apache-Test/lib/Apache/TestConfigC.pm
58 Apache-Test/lib/Apache/TestConfigPHP.pm
59 Apache-Test/lib/Apache/TestConfigParrot.pm
60 Apache-Test/lib/Apache/TestConfigParse.pm
61 Apache-Test/lib/Apache/TestConfigPerl.pm
62 Apache-Test/lib/Apache/TestHandler.pm
63 Apache-Test/lib/Apache/TestHarness.pm
64 Apache-Test/lib/Apache/TestHarnessPHP.pm
65 Apache-Test/lib/Apache/TestMB.pm
66 Apache-Test/lib/Apache/TestMM.pm
67 Apache-Test/lib/Apache/TestPerlDB.pm
68 Apache-Test/lib/Apache/TestReport.pm
69 Apache-Test/lib/Apache/TestReportPerl.pm
70 Apache-Test/lib/Apache/TestRequest.pm
71 Apache-Test/lib/Apache/TestRun.pm
72 Apache-Test/lib/Apache/TestRunPHP.pm
73 Apache-Test/lib/Apache/TestRunParrot.pm
74 Apache-Test/lib/Apache/TestRunPerl.pm
75 Apache-Test/lib/Apache/TestSSLCA.pm
76 Apache-Test/lib/Apache/TestServer.pm
77 Apache-Test/lib/Apache/TestSmoke.pm
78 Apache-Test/lib/Apache/TestSmokePerl.pm
79 Apache-Test/lib/Apache/TestSort.pm
80 Apache-Test/lib/Apache/TestTrace.pm
81 Apache-Test/lib/Apache/TestUtil.pm
82 Apache-Test/lib/Bundle/ApacheTest.pm
83 Apache-Test/t/TEST.PL
84 Apache-Test/t/alltest/01bang.t
85 Apache-Test/t/alltest/all.t
86 Apache-Test/t/alltest2/01bang.t
87 Apache-Test/t/alltest2/all.t
88 Apache-Test/t/bad_coding.t
89 Apache-Test/t/cgi-bin/cookies.pl.PL
90 Apache-Test/t/cgi-bin/next_available_port.pl.PL
91 Apache-Test/t/conf/extra.conf.in
92 Apache-Test/t/conf/modperl_extra.pl.in
93 Apache-Test/t/cookies.t
94 Apache-Test/t/import.t
95 Apache-Test/t/log_watch.t
96 Apache-Test/t/log_watch_for_broken_lines.t
97 Apache-Test/t/more/01testpm.t
98 Apache-Test/t/more/02testmore.t
99 Apache-Test/t/more/03testpm.t
100 Apache-Test/t/more/04testmore.t
101 Apache-Test/t/more/all.t
102 Apache-Test/t/next_available_port.t
103 Apache-Test/t/ping.t
104 Apache-Test/t/redirect.t
105 Apache-Test/t/request.t
106 Apache-Test/t/response/TestMore/testmorepm.pm
107 Apache-Test/t/response/TestMore/testpm.pm
108 Apache-Test/t/sok.t
109 BRANCHING
110 Changes
111 INSTALL
112 LICENSE
113 MANIFEST
114 META.yml
115 Makefile.PL
116 ModPerl-Registry/MANIFEST
117 ModPerl-Registry/Makefile.PL
118 ModPerl-Registry/README
119 ModPerl-Registry/TODO
120 ModPerl-Registry/lib/ModPerl/PerlRun.pm
121 ModPerl-Registry/lib/ModPerl/PerlRunPrefork.pm
122 ModPerl-Registry/lib/ModPerl/Registry.pm
123 ModPerl-Registry/lib/ModPerl/RegistryBB.pm
124 ModPerl-Registry/lib/ModPerl/RegistryCooker.pm
125 ModPerl-Registry/lib/ModPerl/RegistryLoader.pm
126 ModPerl-Registry/lib/ModPerl/RegistryPrefork.pm
127 ModPerl-Registry/t/206.t
128 ModPerl-Registry/t/304.t
129 ModPerl-Registry/t/404-filename-with-newline.t
130 ModPerl-Registry/t/404.t
131 ModPerl-Registry/t/500.t
132 ModPerl-Registry/t/TEST.PL
133 ModPerl-Registry/t/bad_scripts.t
134 ModPerl-Registry/t/basic.t
135 ModPerl-Registry/t/bin_resp.t
136 ModPerl-Registry/t/cgi-bin/206.pl
137 ModPerl-Registry/t/cgi-bin/304.pl
138 ModPerl-Registry/t/cgi-bin/404.pl
139 ModPerl-Registry/t/cgi-bin/basic.pl
140 ModPerl-Registry/t/cgi-bin/bin_resp_start_0.pl
141 ModPerl-Registry/t/cgi-bin/cgi.pl
142 ModPerl-Registry/t/cgi-bin/closure.pl
143 ModPerl-Registry/t/cgi-bin/content_type.pl
144 ModPerl-Registry/t/cgi-bin/env.pl
145 ModPerl-Registry/t/cgi-bin/env_val.pl
146 ModPerl-Registry/t/cgi-bin/exit.pl
147 ModPerl-Registry/t/cgi-bin/flush.pl
148 ModPerl-Registry/t/cgi-bin/ithreads_io_n_tie.pl
149 ModPerl-Registry/t/cgi-bin/local-conf.pl
150 ModPerl-Registry/t/cgi-bin/missing_headers.pl
151 ModPerl-Registry/t/cgi-bin/not_executable.pl
152 ModPerl-Registry/t/cgi-bin/nph-foo.pl
153 ModPerl-Registry/t/cgi-bin/perlrun_decl.pm
154 ModPerl-Registry/t/cgi-bin/perlrun_extload.pl
155 ModPerl-Registry/t/cgi-bin/perlrun_nondecl.pl
156 ModPerl-Registry/t/cgi-bin/prefork.pl
157 ModPerl-Registry/t/cgi-bin/r_inherited.pl
158 ModPerl-Registry/t/cgi-bin/redirect-cookie.pl
159 ModPerl-Registry/t/cgi-bin/redirect.pl
160 ModPerl-Registry/t/cgi-bin/require.pl
161 ModPerl-Registry/t/cgi-bin/runtime_error.pl
162 ModPerl-Registry/t/cgi-bin/runtime_error_n_status_change.pl
163 ModPerl-Registry/t/cgi-bin/runtime_error_plus_body.pl
164 ModPerl-Registry/t/cgi-bin/send_headers.html
165 ModPerl-Registry/t/cgi-bin/special_blocks.pl
166 ModPerl-Registry/t/cgi-bin/status_change.pl
167 ModPerl-Registry/t/cgi-bin/syntax_error.pl
168 ModPerl-Registry/t/cgi-bin/use_error.pl
169 ModPerl-Registry/t/cgi.t
170 ModPerl-Registry/t/closure.t
171 ModPerl-Registry/t/conf/extra.conf.in
172 ModPerl-Registry/t/conf/modperl_extra_startup.pl
173 ModPerl-Registry/t/dirindex.t
174 ModPerl-Registry/t/fatalstobrowser.t
175 ModPerl-Registry/t/flush.t
176 ModPerl-Registry/t/ithreads.t
177 ModPerl-Registry/t/nph.t
178 ModPerl-Registry/t/perlrun_extload.t
179 ModPerl-Registry/t/prefork.t
180 ModPerl-Registry/t/redirect.t
181 ModPerl-Registry/t/regex.t
182 ModPerl-Registry/t/rewrite_env.t
183 ModPerl-Registry/t/special_blocks.t
184 NOTICE
185 README
186 README-SVN
187 RELEASE
188 STATUS
189 SVN-MOVE
190 bin/mp2bug
191 build/config.pl
192 build/make_etags
193 build/make_rpm_spec
194 build/source_scan.pl
195 build/win32_fetch_apxs
196 build/xs_generate.pl
197 docs/TODO
198 docs/api/APR.pod
199 docs/api/APR/Base64.pod
200 docs/api/APR/Brigade.pod
201 docs/api/APR/Bucket.pod
202 docs/api/APR/BucketAlloc.pod
203 docs/api/APR/BucketType.pod
204 docs/api/APR/Const.pod
205 docs/api/APR/Date.pod
206 docs/api/APR/Error.pod
207 docs/api/APR/Finfo.pod
208 docs/api/APR/IpSubnet.pod
209 docs/api/APR/OS.pod
210 docs/api/APR/PerlIO.pod
211 docs/api/APR/Pool.pod
212 docs/api/APR/SockAddr.pod
213 docs/api/APR/Socket.pod
214 docs/api/APR/Status.pod
215 docs/api/APR/String.pod
216 docs/api/APR/Table.pod
217 docs/api/APR/ThreadMutex.pod
218 docs/api/APR/ThreadRWLock.pod
219 docs/api/APR/URI.pod
220 docs/api/APR/UUID.pod
221 docs/api/APR/Util.pod
222 docs/api/AUTOGENERATION
223 docs/api/Apache2/Access.pod
224 docs/api/Apache2/CmdParms.pod
225 docs/api/Apache2/Command.pod
226 docs/api/Apache2/Connection.pod
227 docs/api/Apache2/ConnectionUtil.pod
228 docs/api/Apache2/Const.pod
229 docs/api/Apache2/Directive.pod
230 docs/api/Apache2/Filter.pod
231 docs/api/Apache2/FilterRec.pod
232 docs/api/Apache2/HookRun.pod
233 docs/api/Apache2/Log.pod
234 docs/api/Apache2/MPM.pod
235 docs/api/Apache2/Module.pod
236 docs/api/Apache2/PerlSections.pod
237 docs/api/Apache2/Process.pod
238 docs/api/Apache2/Reload.pod
239 docs/api/Apache2/RequestIO.pod
240 docs/api/Apache2/RequestRec.pod
241 docs/api/Apache2/RequestUtil.pod
242 docs/api/Apache2/Resource.pod
243 docs/api/Apache2/Response.pod
244 docs/api/Apache2/ServerRec.pod
245 docs/api/Apache2/ServerUtil.pod
246 docs/api/Apache2/SizeLimit.pod
247 docs/api/Apache2/Status.pod
248 docs/api/Apache2/SubProcess.pod
249 docs/api/Apache2/SubRequest.pod
250 docs/api/Apache2/URI.pod
251 docs/api/Apache2/Util.pod
252 docs/api/Apache2/compat.pod
253 docs/api/Apache2/porting.pod
254 docs/api/ModPerl/BuildMM.pod
255 docs/api/ModPerl/Const.pod
256 docs/api/ModPerl/Global.pod
257 docs/api/ModPerl/MM.pod
258 docs/api/ModPerl/MethodLookup.pod
259 docs/api/ModPerl/PerlRun.pod
260 docs/api/ModPerl/PerlRunPrefork.pod
261 docs/api/ModPerl/Registry.pod
262 docs/api/ModPerl/RegistryBB.pod
263 docs/api/ModPerl/RegistryCooker.pod
264 docs/api/ModPerl/RegistryLoader.pod
265 docs/api/ModPerl/RegistryPrefork.pod
266 docs/api/ModPerl/Util.pod
267 docs/api/README
268 docs/api/config.cfg
269 docs/api/index_bot.html
270 docs/config.cfg
271 docs/devel/Changes.pod
272 docs/devel/config.cfg
273 docs/devel/core/apache_integration.pod
274 docs/devel/core/coding_style.pod
275 docs/devel/core/explained.pod
276 docs/devel/core/mod_perl_specific.pod
277 docs/devel/core/mpms.pod
278 docs/devel/debug/c.pod
279 docs/devel/debug/code/.debug-inline
280 docs/devel/debug/code/.debug-modperl-init
281 docs/devel/debug/code/.debug-modperl-register
282 docs/devel/debug/code/.debug-modperl-xs
283 docs/devel/debug/perl.pod
284 docs/devel/help/help.pod
285 docs/devel/performance/size_matters.pod
286 docs/devel/performance/speed_matters.pod
287 docs/devel/porting/porting.pod
288 docs/index_top.html
289 docs/os/config.cfg
290 docs/os/win32/Changes.pod
291 docs/os/win32/config.cfg
292 docs/os/win32/config.pod
293 docs/os/win32/distinstall
294 docs/os/win32/faq.pod
295 docs/os/win32/install.pod
296 docs/os/win32/mpinstall
297 docs/rename.pod
298 docs/user/Changes.pod
299 docs/user/coding/coding.pod
300 docs/user/coding/cooking.pod
301 docs/user/config.cfg
302 docs/user/config/config.pod
303 docs/user/config/custom.pod
304 docs/user/design/design.pod
305 docs/user/handlers/bucket_brigades.dia
306 docs/user/handlers/bucket_brigades.gif
307 docs/user/handlers/bucket_brigades.png
308 docs/user/handlers/connection_cycle.gif
309 docs/user/handlers/connection_cycle.png
310 docs/user/handlers/connection_cycle_all.dia
311 docs/user/handlers/connection_cycle_all.png
312 docs/user/handlers/connection_cycle_pre.dia
313 docs/user/handlers/connection_cycle_pre.png
314 docs/user/handlers/connection_cycle_process.dia
315 docs/user/handlers/connection_cycle_process.png
316 docs/user/handlers/connection_cycle_time.dia
317 docs/user/handlers/connection_cycle_time.gif
318 docs/user/handlers/connection_cycle_time.png
319 docs/user/handlers/filter_life_camera.jpg
320 docs/user/handlers/filter_life_cigarrette.jpg
321 docs/user/handlers/filter_life_coffee.jpg
322 docs/user/handlers/filter_life_goggles.jpg
323 docs/user/handlers/filter_life_mask.jpg
324 docs/user/handlers/filter_life_player.jpg
325 docs/user/handlers/filter_life_shower.jpg
326 docs/user/handlers/filter_logic.dia
327 docs/user/handlers/filter_logic.gif
328 docs/user/handlers/filter_logic.png
329 docs/user/handlers/filters.pod
330 docs/user/handlers/general.pod
331 docs/user/handlers/http.pod
332 docs/user/handlers/http_cycle.gif
333 docs/user/handlers/http_cycle.png
334 docs/user/handlers/http_cycle1.gif
335 docs/user/handlers/http_cycle1.png
336 docs/user/handlers/http_cycle_access.dia
337 docs/user/handlers/http_cycle_access.gif
338 docs/user/handlers/http_cycle_access.png
339 docs/user/handlers/http_cycle_all.dia
340 docs/user/handlers/http_cycle_all.gif
341 docs/user/handlers/http_cycle_all.png
342 docs/user/handlers/http_cycle_authen.dia
343 docs/user/handlers/http_cycle_authen.gif
344 docs/user/handlers/http_cycle_authen.png
345 docs/user/handlers/http_cycle_authz.dia
346 docs/user/handlers/http_cycle_authz.gif
347 docs/user/handlers/http_cycle_authz.png
348 docs/user/handlers/http_cycle_cleanup.dia
349 docs/user/handlers/http_cycle_cleanup.gif
350 docs/user/handlers/http_cycle_cleanup.png
351 docs/user/handlers/http_cycle_conn_filters.dia
352 docs/user/handlers/http_cycle_conn_filters.gif
353 docs/user/handlers/http_cycle_conn_filters.png
354 docs/user/handlers/http_cycle_fixup.dia
355 docs/user/handlers/http_cycle_fixup.gif
356 docs/user/handlers/http_cycle_fixup.png
357 docs/user/handlers/http_cycle_header_parser.dia
358 docs/user/handlers/http_cycle_header_parser.gif
359 docs/user/handlers/http_cycle_header_parser.png
360 docs/user/handlers/http_cycle_http_filters.dia
361 docs/user/handlers/http_cycle_http_filters.gif
362 docs/user/handlers/http_cycle_http_filters.png
363 docs/user/handlers/http_cycle_init.dia
364 docs/user/handlers/http_cycle_init.gif
365 docs/user/handlers/http_cycle_init.png
366 docs/user/handlers/http_cycle_log.dia
367 docs/user/handlers/http_cycle_log.gif
368 docs/user/handlers/http_cycle_log.png
369 docs/user/handlers/http_cycle_map_to_storage.dia
370 docs/user/handlers/http_cycle_map_to_storage.gif
371 docs/user/handlers/http_cycle_map_to_storage.png
372 docs/user/handlers/http_cycle_post_read_request.dia
373 docs/user/handlers/http_cycle_post_read_request.gif
374 docs/user/handlers/http_cycle_post_read_request.png
375 docs/user/handlers/http_cycle_response.dia
376 docs/user/handlers/http_cycle_response.gif
377 docs/user/handlers/http_cycle_response.png
378 docs/user/handlers/http_cycle_trans.dia
379 docs/user/handlers/http_cycle_trans.gif
380 docs/user/handlers/http_cycle_trans.png
381 docs/user/handlers/http_cycle_type.dia
382 docs/user/handlers/http_cycle_type.gif
383 docs/user/handlers/http_cycle_type.png
384 docs/user/handlers/in_filter_stream.dia
385 docs/user/handlers/in_filter_stream.gif
386 docs/user/handlers/in_filter_stream.png
387 docs/user/handlers/intro.pod
388 docs/user/handlers/out.gif
389 docs/user/handlers/out_filter_stream.dia
390 docs/user/handlers/out_filter_stream.gif
391 docs/user/handlers/out_filter_stream.png
392 docs/user/handlers/practical_mod_perl_comp.gif
393 docs/user/handlers/protocols.pod
394 docs/user/handlers/server.pod
395 docs/user/handlers/server_life_cycle.dia
396 docs/user/handlers/server_life_cycle.gif
397 docs/user/handlers/server_life_cycle.png
398 docs/user/handlers/tmlogo_color.gif
399 docs/user/help/help.pod
400 docs/user/install/install.pod
401 docs/user/intro/overview.pod
402 docs/user/intro/start_fast.pod
403 docs/user/performance/mpm.pod
404 docs/user/performance/prevent.pod
405 docs/user/porting/code/apache_mp3_2.diff
406 docs/user/porting/code/apache_mp3_7.diff
407 docs/user/porting/code/apache_mp3_9.diff
408 docs/user/porting/compat.pod
409 docs/user/porting/porting.pod
410 docs/user/troubleshooting/troubleshooting.pod
411 lib/APR/XSLoader.pm
412 lib/Apache2/Build.pm
413 lib/Apache2/ParseSource.pm
414 lib/Apache2/PerlSections.pm
415 lib/Apache2/PerlSections/Dump.pm
416 lib/Apache2/Resource.pm
417 lib/Apache2/SourceTables.pm
418 lib/Apache2/Status.pm
419 lib/Apache2/XSLoader.pm
420 lib/Apache2/compat.pm
421 lib/Apache2/porting.pm
422 lib/Bundle/Apache2.pm
423 lib/ModPerl/BuildMM.pm
424 lib/ModPerl/BuildOptions.pm
425 lib/ModPerl/CScan.pm
426 lib/ModPerl/Code.pm
427 lib/ModPerl/Config.pm
428 lib/ModPerl/DummyVersions.pm
429 lib/ModPerl/FunctionMap.pm
430 lib/ModPerl/MM.pm
431 lib/ModPerl/Manifest.pm
432 lib/ModPerl/MapUtil.pm
433 lib/ModPerl/MethodLookup.pm
434 lib/ModPerl/ParseSource.pm
435 lib/ModPerl/StructureMap.pm
436 lib/ModPerl/TestReport.pm
437 lib/ModPerl/TestRun.pm
438 lib/ModPerl/TypeMap.pm
439 lib/ModPerl/WrapXS.pm
440 lib/mod_perl2.pm
441 mod_perl.spec
442 src/modules/perl/mod_perl.c
443 src/modules/perl/mod_perl.h
444 src/modules/perl/modperl_apache_compat.c
445 src/modules/perl/modperl_apache_compat.h
446 src/modules/perl/modperl_apache_includes.h
447 src/modules/perl/modperl_apr_compat.h
448 src/modules/perl/modperl_apr_includes.h
449 src/modules/perl/modperl_bucket.c
450 src/modules/perl/modperl_bucket.h
451 src/modules/perl/modperl_callback.c
452 src/modules/perl/modperl_callback.h
453 src/modules/perl/modperl_cgi.c
454 src/modules/perl/modperl_cgi.h
455 src/modules/perl/modperl_cmd.c
456 src/modules/perl/modperl_cmd.h
457 src/modules/perl/modperl_common_debug.c
458 src/modules/perl/modperl_common_debug.h
459 src/modules/perl/modperl_common_includes.h
460 src/modules/perl/modperl_common_log.c
461 src/modules/perl/modperl_common_log.h
462 src/modules/perl/modperl_common_types.h
463 src/modules/perl/modperl_common_util.c
464 src/modules/perl/modperl_common_util.h
465 src/modules/perl/modperl_config.c
466 src/modules/perl/modperl_config.h
467 src/modules/perl/modperl_const.c
468 src/modules/perl/modperl_const.h
469 src/modules/perl/modperl_debug.c
470 src/modules/perl/modperl_debug.h
471 src/modules/perl/modperl_env.c
472 src/modules/perl/modperl_env.h
473 src/modules/perl/modperl_error.c
474 src/modules/perl/modperl_error.h
475 src/modules/perl/modperl_filter.c
476 src/modules/perl/modperl_filter.h
477 src/modules/perl/modperl_global.c
478 src/modules/perl/modperl_global.h
479 src/modules/perl/modperl_gtop.c
480 src/modules/perl/modperl_gtop.h
481 src/modules/perl/modperl_handler.c
482 src/modules/perl/modperl_handler.h
483 src/modules/perl/modperl_interp.c
484 src/modules/perl/modperl_interp.h
485 src/modules/perl/modperl_io.c
486 src/modules/perl/modperl_io.h
487 src/modules/perl/modperl_io_apache.c
488 src/modules/perl/modperl_io_apache.h
489 src/modules/perl/modperl_log.c
490 src/modules/perl/modperl_log.h
491 src/modules/perl/modperl_mgv.c
492 src/modules/perl/modperl_mgv.h
493 src/modules/perl/modperl_module.c
494 src/modules/perl/modperl_module.h
495 src/modules/perl/modperl_options.c
496 src/modules/perl/modperl_options.h
497 src/modules/perl/modperl_pcw.c
498 src/modules/perl/modperl_pcw.h
499 src/modules/perl/modperl_perl.c
500 src/modules/perl/modperl_perl.h
501 src/modules/perl/modperl_perl_global.c
502 src/modules/perl/modperl_perl_global.h
503 src/modules/perl/modperl_perl_includes.h
504 src/modules/perl/modperl_perl_pp.c
505 src/modules/perl/modperl_perl_pp.h
506 src/modules/perl/modperl_perl_unembed.h
507 src/modules/perl/modperl_svptr_table.c
508 src/modules/perl/modperl_svptr_table.h
509 src/modules/perl/modperl_sys.c
510 src/modules/perl/modperl_sys.h
511 src/modules/perl/modperl_time.h
512 src/modules/perl/modperl_tipool.c
513 src/modules/perl/modperl_tipool.h
514 src/modules/perl/modperl_types.h
515 src/modules/perl/modperl_util.c
516 src/modules/perl/modperl_util.h
517 t/apache/add_config.t
518 t/apache/cgihandler.t
519 t/apache/constants.t
520 t/apache/content_length_header.t
521 t/apache/discard_rbody.t
522 t/apache/post.t
523 t/apache/read.t
524 t/apache/read2.t
525 t/apache/read3.t
526 t/apache/read4.t
527 t/apache/scanhdrs.t
528 t/apache/scanhdrs2.t
529 t/apache/send_cgi_header.t
530 t/api/access2.t
531 t/api/access2_24.t
532 t/api/add_config.t
533 t/api/content_encoding.t
534 t/api/custom_response.t
535 t/api/err_headers_out.t
536 t/api/in_out_filters.t
537 t/api/internal_redirect.t
538 t/api/internal_redirect_handler.t
539 t/api/lookup_misc.t
540 t/api/lookup_uri.t
541 t/api/request_rec.t
542 t/api/rflush.t
543 t/api/sendfile.t
544 t/api/slurp_filename.t
545 t/api/status.t
546 t/apr-ext/base64.t
547 t/apr-ext/brigade.t
548 t/apr-ext/bucket.t
549 t/apr-ext/date.t
550 t/apr-ext/error.t
551 t/apr-ext/finfo.t
552 t/apr-ext/os.t
553 t/apr-ext/pool.t
554 t/apr-ext/status.t
555 t/apr-ext/string.t
556 t/apr-ext/table.t
557 t/apr-ext/threadmutex.t
558 t/apr-ext/threadrwlock.t
559 t/apr-ext/uri.t
560 t/apr-ext/util.t
561 t/apr-ext/uuid.t
562 t/apr/constants.t
563 t/apr/pool_lifetime.t
564 t/compat/conn_authen.t
565 t/compat/request_body.t
566 t/compat/send_fd.t
567 t/conf/extra.conf.in
568 t/conf/extra.last.conf.in
569 t/conf/modperl_extra.pl
570 t/conf/post_config_startup.pl
571 t/directive/perl.t
572 t/directive/perlcleanuphandler.t
573 t/directive/perlloadmodule2.t
574 t/directive/perlloadmodule3.t
575 t/directive/perlloadmodule4.t
576 t/directive/perlloadmodule5.t
577 t/directive/perlloadmodule6.t
578 t/directive/perlmodule.t
579 t/directive/perlrequire.t
580 t/directive/setupenv.t
581 t/error/runtime.t
582 t/error/syntax.t
583 t/filter/TestFilter/both_str_con_add.pm
584 t/filter/TestFilter/both_str_native_remove.pm
585 t/filter/TestFilter/both_str_req_add.pm
586 t/filter/TestFilter/both_str_req_mix.pm
587 t/filter/TestFilter/both_str_req_proxy.pm
588 t/filter/TestFilter/in_autoload.pm
589 t/filter/TestFilter/in_bbs_body.pm
590 t/filter/TestFilter/in_bbs_consume.pm
591 t/filter/TestFilter/in_bbs_inject_header.pm
592 t/filter/TestFilter/in_bbs_msg.pm
593 t/filter/TestFilter/in_bbs_underrun.pm
594 t/filter/TestFilter/in_error.pm
595 t/filter/TestFilter/in_init_basic.pm
596 t/filter/TestFilter/in_str_bin_data.pm
597 t/filter/TestFilter/in_str_consume.pm
598 t/filter/TestFilter/in_str_declined.pm
599 t/filter/TestFilter/in_str_declined_read.pm
600 t/filter/TestFilter/in_str_lc.pm
601 t/filter/TestFilter/in_str_msg.pm
602 t/filter/TestFilter/in_str_sandwich.pm
603 t/filter/TestFilter/out_bbs_basic.pm
604 t/filter/TestFilter/out_bbs_ctx.pm
605 t/filter/TestFilter/out_bbs_filebucket.pm
606 t/filter/TestFilter/out_init_basic.pm
607 t/filter/TestFilter/out_str_api.pm
608 t/filter/TestFilter/out_str_buffer.pm
609 t/filter/TestFilter/out_str_ctx.pm
610 t/filter/TestFilter/out_str_declined.pm
611 t/filter/TestFilter/out_str_eval.pm
612 t/filter/TestFilter/out_str_lc.pm
613 t/filter/TestFilter/out_str_remove.pm
614 t/filter/TestFilter/out_str_req_eos.pm
615 t/filter/TestFilter/out_str_req_mix.pm
616 t/filter/TestFilter/out_str_reverse.pm
617 t/filter/TestFilter/out_str_subreq_default.pm
618 t/filter/TestFilter/out_str_subreq_modperl.pm
619 t/filter/TestFilter/with_subrequest.pm
620 t/filter/both_str_con_add.t
621 t/filter/both_str_native_remove.t
622 t/filter/both_str_req_add.t
623 t/filter/both_str_req_mix.t
624 t/filter/both_str_req_proxy.t
625 t/filter/in_autoload.t
626 t/filter/in_bbs_body.t
627 t/filter/in_bbs_consume.t
628 t/filter/in_bbs_inject_header.t
629 t/filter/in_bbs_msg.t
630 t/filter/in_bbs_underrun.t
631 t/filter/in_error.t
632 t/filter/in_init_basic.t
633 t/filter/in_str_bin_data.t
634 t/filter/in_str_consume.t
635 t/filter/in_str_declined.t
636 t/filter/in_str_declined_read.t
637 t/filter/in_str_lc.t
638 t/filter/in_str_msg.t
639 t/filter/in_str_sandwich.t
640 t/filter/out_apache.t
641 t/filter/out_bbs_ctx.t
642 t/filter/out_bbs_filebucket.t
643 t/filter/out_init_basic.t
644 t/filter/out_str_buffer.t
645 t/filter/out_str_ctx.t
646 t/filter/out_str_declined.t
647 t/filter/out_str_lc.t
648 t/filter/out_str_remove.t
649 t/filter/out_str_req_eos.t
650 t/filter/out_str_req_mix.t
651 t/filter/out_str_reverse.t
652 t/filter/out_str_subreq_default.t
653 t/filter/out_str_subreq_modperl.t
654 t/filter/with_subrequest.t
655 t/hooks/TestHooks/access.pm
656 t/hooks/TestHooks/authen_basic.pm
657 t/hooks/TestHooks/authen_digest.pm
658 t/hooks/TestHooks/authz.pm
659 t/hooks/TestHooks/cleanup.pm
660 t/hooks/TestHooks/cleanup2.pm
661 t/hooks/TestHooks/error.pm
662 t/hooks/TestHooks/fixup.pm
663 t/hooks/TestHooks/headerparser.pm
664 t/hooks/TestHooks/hookrun.pm
665 t/hooks/TestHooks/init.pm
666 t/hooks/TestHooks/inlined_handlers.pm
667 t/hooks/TestHooks/push_handlers.pm
668 t/hooks/TestHooks/push_handlers_anon.pm
669 t/hooks/TestHooks/push_handlers_blessed.pm
670 t/hooks/TestHooks/push_handlers_same_phase.pm
671 t/hooks/TestHooks/set_handlers.pm
672 t/hooks/TestHooks/stacked_handlers.pm
673 t/hooks/TestHooks/stacked_handlers2.pm
674 t/hooks/TestHooks/startup.pm
675 t/hooks/TestHooks/trans.pm
676 t/hooks/access.t
677 t/hooks/authen_basic.t
678 t/hooks/authen_digest.t
679 t/hooks/authz.t
680 t/hooks/cleanup.t
681 t/hooks/cleanup2.t
682 t/hooks/error.t
683 t/hooks/hookrun.t
684 t/hooks/init.t
685 t/hooks/inlined_handlers.t
686 t/hooks/push_handlers.t
687 t/hooks/push_handlers_anon.t
688 t/hooks/stacked_handlers.t
689 t/hooks/stacked_handlers2.t
690 t/hooks/startup.t
691 t/hooks/trans.t
692 t/htdocs/TestAPI__add_config/htaccess
693 t/htdocs/api/auth-groups
694 t/htdocs/api/auth-users
695 t/htdocs/api/custom_response.txt
696 t/htdocs/api/slurp.pl
697 t/htdocs/filter/reverse.txt
698 t/htdocs/filter/subrequest.txt
699 t/htdocs/includes-registry/cgipm.pl
700 t/htdocs/includes-registry/test.pl
701 t/htdocs/includes-registry/test.spl
702 t/htdocs/includes/clear.shtml
703 t/htdocs/includes/footer.shtml
704 t/htdocs/includes/header.shtml
705 t/htdocs/includes/test.shtml
706 t/htdocs/merge3/htaccess
707 t/htdocs/modperl/setupenv2/config_require.pl
708 t/htdocs/modperl/setupenv2/module.pm
709 t/htdocs/modperl/setupenv2/post_config_require.pl
710 t/htdocs/modperl/setupenv2/require.pl
711 t/htdocs/perlio/MoonRise.jpeg
712 t/htdocs/perlio/redrum.txt
713 t/htdocs/protocols/basic-auth
714 t/htdocs/vhost/post_config.pl
715 t/htdocs/vhost/startup.pl
716 t/lib/TestAPRlib/base64.pm
717 t/lib/TestAPRlib/brigade.pm
718 t/lib/TestAPRlib/bucket.pm
719 t/lib/TestAPRlib/date.pm
720 t/lib/TestAPRlib/error.pm
721 t/lib/TestAPRlib/finfo.pm
722 t/lib/TestAPRlib/os.pm
723 t/lib/TestAPRlib/pool.pm
724 t/lib/TestAPRlib/status.pm
725 t/lib/TestAPRlib/string.pm
726 t/lib/TestAPRlib/table.pm
727 t/lib/TestAPRlib/threadmutex.pm
728 t/lib/TestAPRlib/threadrwlock.pm
729 t/lib/TestAPRlib/uri.pm
730 t/lib/TestAPRlib/util.pm
731 t/lib/TestAPRlib/uuid.pm
732 t/lib/TestCommon/FilterDebug.pm
733 t/lib/TestCommon/Handlers.pm
734 t/lib/TestCommon/LogDiff.pm
735 t/lib/TestCommon/MemoryLeak.pm
736 t/lib/TestCommon/SameInterp.pm
737 t/lib/TestCommon/TiePerlSection.pm
738 t/lib/TestCommon/Utils.pm
739 t/lib/TestExit/FromPerlModule.pm
740 t/modperl/cookie.t
741 t/modperl/cookie2.t
742 t/modperl/exit.t
743 t/modperl/getc.t
744 t/modperl/local_env.t
745 t/modperl/merge.t
746 t/modperl/merge2.t
747 t/modperl/merge3.t
748 t/modperl/perl_options.t
749 t/modperl/perl_options2.t
750 t/modperl/pnotes.t
751 t/modperl/pnotes2.t
752 t/modperl/post_utf8.t
753 t/modperl/print_utf8.t
754 t/modperl/print_utf8_2.t
755 t/modperl/readline.t
756 t/modperl/request_rec_perlio_api.t
757 t/modperl/setupenv.t
758 t/modperl/setupenv2.t
759 t/modperl/status.t
760 t/modules/apache_resource.t
761 t/modules/apache_status.t
762 t/modules/cgi.t
763 t/modules/cgi2.t
764 t/modules/cgipost.t
765 t/modules/cgipost2.t
766 t/modules/cgiupload.t
767 t/modules/cgiupload2.t
768 t/modules/include.t
769 t/modules/include2.t
770 t/modules/include_subreq.t
771 t/modules/proxy.t
772 t/perl/hash_attack.t
773 t/preconnection/TestPreConnection/note.pm
774 t/preconnection/note.t
775 t/protocol/TestProtocol/echo_bbs.pm
776 t/protocol/TestProtocol/echo_bbs2.pm
777 t/protocol/TestProtocol/echo_block.pm
778 t/protocol/TestProtocol/echo_filter.pm
779 t/protocol/TestProtocol/echo_nonblock.pm
780 t/protocol/TestProtocol/echo_timeout.pm
781 t/protocol/TestProtocol/pseudo_http.pm
782 t/protocol/echo_bbs.t
783 t/protocol/echo_bbs2.t
784 t/protocol/echo_block.t
785 t/protocol/echo_filter.t
786 t/protocol/echo_nonblock.t
787 t/protocol/echo_timeout.t
788 t/protocol/pseudo_http.t
789 t/response/TestAPI/access.pm
790 t/response/TestAPI/access2.pm
791 t/response/TestAPI/access2_24.pm
792 t/response/TestAPI/add_config.pm
793 t/response/TestAPI/aplog.pm
794 t/response/TestAPI/command.pm
795 t/response/TestAPI/conn_rec.pm
796 t/response/TestAPI/conn_util.pm
797 t/response/TestAPI/content_encoding.pm
798 t/response/TestAPI/custom_response.pm
799 t/response/TestAPI/err_headers_out.pm
800 t/response/TestAPI/in_out_filters.pm
801 t/response/TestAPI/internal_redirect.pm
802 t/response/TestAPI/internal_redirect_handler.pm
803 t/response/TestAPI/lookup_misc.pm
804 t/response/TestAPI/lookup_uri.pm
805 t/response/TestAPI/lookup_uri2.pm
806 t/response/TestAPI/module.pm
807 t/response/TestAPI/process.pm
808 t/response/TestAPI/query.pm
809 t/response/TestAPI/request_rec.pm
810 t/response/TestAPI/request_subclass.pm
811 t/response/TestAPI/request_util.pm
812 t/response/TestAPI/response.pm
813 t/response/TestAPI/rflush.pm
814 t/response/TestAPI/sendfile.pm
815 t/response/TestAPI/server_const.pm
816 t/response/TestAPI/server_rec.pm
817 t/response/TestAPI/server_util.pm
818 t/response/TestAPI/show.pm
819 t/response/TestAPI/slurp_filename.pm
820 t/response/TestAPI/status.pm
821 t/response/TestAPI/sub_request.pm
822 t/response/TestAPI/uri.pm
823 t/response/TestAPR/base64.pm
824 t/response/TestAPR/brigade.pm
825 t/response/TestAPR/bucket.pm
826 t/response/TestAPR/date.pm
827 t/response/TestAPR/finfo.pm
828 t/response/TestAPR/flatten.pm
829 t/response/TestAPR/ipsubnet.pm
830 t/response/TestAPR/os.pm
831 t/response/TestAPR/perlio.pm
832 t/response/TestAPR/pool.pm
833 t/response/TestAPR/pool_lifetime.pm
834 t/response/TestAPR/sockaddr.pm
835 t/response/TestAPR/socket.pm
836 t/response/TestAPR/status.pm
837 t/response/TestAPR/string.pm
838 t/response/TestAPR/table.pm
839 t/response/TestAPR/threadmutex.pm
840 t/response/TestAPR/threadrwlock.pm
841 t/response/TestAPR/uri.pm
842 t/response/TestAPR/util.pm
843 t/response/TestAPR/uuid.pm
844 t/response/TestApache/cgihandler.pm
845 t/response/TestApache/conftree.pm
846 t/response/TestApache/content_length_header.pm
847 t/response/TestApache/daemon.pm
848 t/response/TestApache/discard_rbody.pm
849 t/response/TestApache/post.pm
850 t/response/TestApache/read.pm
851 t/response/TestApache/read2.pm
852 t/response/TestApache/read3.pm
853 t/response/TestApache/read4.pm
854 t/response/TestApache/scanhdrs.pm
855 t/response/TestApache/scanhdrs2.pm
856 t/response/TestApache/send_cgi_header.pm
857 t/response/TestApache/subprocess.pm
858 t/response/TestApache/util.pm
859 t/response/TestApache/write.pm
860 t/response/TestCompat/apache.pm
861 t/response/TestCompat/apache_file.pm
862 t/response/TestCompat/apache_module.pm
863 t/response/TestCompat/apache_table.pm
864 t/response/TestCompat/apache_uri.pm
865 t/response/TestCompat/apache_util.pm
866 t/response/TestCompat/conn_authen.pm
867 t/response/TestCompat/conn_rec.pm
868 t/response/TestCompat/request.pm
869 t/response/TestCompat/request_body.pm
870 t/response/TestCompat/send_fd.pm
871 t/response/TestDirective/cmdparms.pm
872 t/response/TestDirective/env.pm
873 t/response/TestDirective/perlcleanuphandler.pm
874 t/response/TestDirective/perldo.pm
875 t/response/TestDirective/perlloadmodule.pm
876 t/response/TestDirective/perlloadmodule2.pm
877 t/response/TestDirective/perlloadmodule3.pm
878 t/response/TestDirective/perlloadmodule4.pm
879 t/response/TestDirective/perlloadmodule5.pm
880 t/response/TestDirective/perlloadmodule6.pm
881 t/response/TestDirective/perlloadmodule7.pm
882 t/response/TestDirective/perlmodule.pm
883 t/response/TestDirective/perlrequire.pm
884 t/response/TestDirective/pod.pm
885 t/response/TestDirective/setupenv.pm
886 t/response/TestError/api.pm
887 t/response/TestError/runtime.pm
888 t/response/TestError/syntax.pm
889 t/response/TestModperl/cookie.pm
890 t/response/TestModperl/cookie2.pm
891 t/response/TestModperl/current_callback.pm
892 t/response/TestModperl/dir_config.pm
893 t/response/TestModperl/endav.pm
894 t/response/TestModperl/env.pm
895 t/response/TestModperl/exit.pm
896 t/response/TestModperl/getc.pm
897 t/response/TestModperl/interpreter.pm
898 t/response/TestModperl/io_nested_with_closed_stds.pm
899 t/response/TestModperl/io_with_closed_stds.pm
900 t/response/TestModperl/local_env.pm
901 t/response/TestModperl/merge.pm
902 t/response/TestModperl/method.pm
903 t/response/TestModperl/methodname.pm
904 t/response/TestModperl/methodobj.pm
905 t/response/TestModperl/perl.pm
906 t/response/TestModperl/perl_options.pm
907 t/response/TestModperl/perl_options2.pm
908 t/response/TestModperl/pnotes.pm
909 t/response/TestModperl/pnotes2.pm
910 t/response/TestModperl/post_utf8.pm
911 t/response/TestModperl/print.pm
912 t/response/TestModperl/print_utf8.pm
913 t/response/TestModperl/print_utf8_2.pm
914 t/response/TestModperl/printf.pm
915 t/response/TestModperl/readline.pm
916 t/response/TestModperl/request_rec_perlio_api.pm
917 t/response/TestModperl/request_rec_tie_api.pm
918 t/response/TestModperl/setauth.pm
919 t/response/TestModperl/setupenv.pm
920 t/response/TestModperl/setupenv2.pm
921 t/response/TestModperl/status.pm
922 t/response/TestModperl/stdfd.pm
923 t/response/TestModperl/stdfd2.pm
924 t/response/TestModperl/subenv.pm
925 t/response/TestModperl/taint.pm
926 t/response/TestModperl/util.pm
927 t/response/TestModules/cgi.pm
928 t/response/TestModules/cgi2.pm
929 t/response/TestModules/cgipost.pm
930 t/response/TestModules/cgipost2.pm
931 t/response/TestModules/cgiupload.pm
932 t/response/TestModules/cgiupload2.pm
933 t/response/TestModules/include_subreq.pm
934 t/response/TestModules/proxy.pm
935 t/response/TestPerl/api.pm
936 t/response/TestPerl/hash_attack.pm
937 t/response/TestPerl/signals.pm
938 t/response/TestUser/rewrite.pm
939 t/response/TestVhost/config.pm
940 t/response/TestVhost/log.pm
941 t/user/README
942 t/user/rewrite.t
943 t/vhost/config.t
944 t/vhost/log.t
945 todo/2.0.6
946 todo/README
947 todo/api_status
948 todo/bugs_apr_ext
949 todo/bugs_build
950 todo/bugs_mp
951 todo/bugs_registry
952 todo/design_notes
953 todo/docs
954 todo/features_deprecated
955 todo/features_maybe
956 todo/features_missing
957 todo/features_new
958 todo/features_optimization
959 todo/features_registry
960 todo/release
961 todo/tests_issues
962 todo/tests_wanted
963 util/apr_arg_check.pl
964 util/apr_pool_check.pl
965 util/cvsize.pl
966 util/getdiff.pl
967 util/methodlookup_check.pl
968 util/perl_bloat.pl
969 util/sizeof.pl
970 util/source_stats.pl
971 util/xs_check.pl
972 xs/APR/APR/APR.pm
973 xs/APR/APR/APR.xs
974 xs/APR/APR/Makefile.PL
975 xs/APR/APR/apr-test
976 xs/APR/Base64/APR__Base64.h
977 xs/APR/Brigade/APR__Brigade.h
978 xs/APR/Bucket/APR__Bucket.h
979 xs/APR/BucketAlloc/APR__BucketAlloc.h
980 xs/APR/Const/Const.pm
981 xs/APR/Const/Const.xs
982 xs/APR/Const/Makefile.PL
983 xs/APR/Error/APR__Error.h
984 xs/APR/Error/Error_pm
985 xs/APR/Finfo/APR__Finfo.h
986 xs/APR/IpSubnet/APR__IpSubnet.h
987 xs/APR/Lock/APR__Lock.h
988 xs/APR/Makefile.PL
989 xs/APR/OS/APR__OS.h
990 xs/APR/PerlIO/Makefile.PL
991 xs/APR/PerlIO/PerlIO.pm
992 xs/APR/PerlIO/PerlIO.xs
993 xs/APR/PerlIO/modperl_apr_perlio.c
994 xs/APR/PerlIO/modperl_apr_perlio.h
995 xs/APR/Pool/APR__Pool.h
996 xs/APR/SockAddr/APR__SockAddr.h
997 xs/APR/Socket/APR__Socket.h
998 xs/APR/Status/APR__Status.h
999 xs/APR/String/APR__String.h
1000 xs/APR/Table/APR__Table.h
1001 xs/APR/ThreadMutex/APR__ThreadMutex.h
1002 xs/APR/ThreadRWLock/APR__ThreadRWLock.h
1003 xs/APR/URI/APR__URI.h
1004 xs/APR/UUID/APR__UUID.h
1005 xs/APR/Util/APR__Util.h
1006 xs/APR/aprext/Makefile.PL
1007 xs/APR/aprext/modperl_dummy.c
1008 xs/Apache2/Access/Apache2__Access.h
1009 xs/Apache2/CmdParms/Apache2__CmdParms.h
1010 xs/Apache2/Command/Apache2__Command.h
1011 xs/Apache2/Connection/Apache2__Connection.h
1012 xs/Apache2/ConnectionUtil/Apache2__ConnectionUtil.h
1013 xs/Apache2/Const/Const.pm
1014 xs/Apache2/Const/Const.xs
1015 xs/Apache2/Const/Makefile.PL
1016 xs/Apache2/Directive/Apache2__Directive.h
1017 xs/Apache2/Filter/Apache2__Filter.h
1018 xs/Apache2/Log/Apache2__Log.h
1019 xs/Apache2/MPM/Apache2__MPM.h
1020 xs/Apache2/Makefile.PL
1021 xs/Apache2/Module/Apache2__Module.h
1022 xs/Apache2/RequestIO/Apache2__RequestIO.h
1023 xs/Apache2/RequestRec/Apache2__RequestRec.h
1024 xs/Apache2/RequestUtil/Apache2__RequestUtil.h
1025 xs/Apache2/Response/Apache2__Response.h
1026 xs/Apache2/ServerRec/Apache2__ServerRec.h
1027 xs/Apache2/ServerRec/ServerRec_pm
1028 xs/Apache2/ServerUtil/Apache2__ServerUtil.h
1029 xs/Apache2/SubProcess/Apache2__SubProcess.h
1030 xs/Apache2/SubProcess/SubProcess_pm
1031 xs/Apache2/SubRequest/Apache2__SubRequest.h
1032 xs/Apache2/URI/Apache2__URI.h
1033 xs/Apache2/Util/Apache2__Util.h
1034 xs/Makefile.PL
1035 xs/ModPerl/Const/Const.pm
1036 xs/ModPerl/Const/Const.xs
1037 xs/ModPerl/Const/Makefile.PL
1038 xs/ModPerl/Global/ModPerl__Global.h
1039 xs/ModPerl/Interpreter/ModPerl__Interpreter.h
1040 xs/ModPerl/Makefile.PL
1041 xs/ModPerl/Util/ModPerl__Util.h
1042 xs/ModPerl/Util/Util_pm
1043 xs/maps/apache2_functions.map
1044 xs/maps/apache2_structures.map
1045 xs/maps/apache2_types.map
1046 xs/maps/apr_functions.map
1047 xs/maps/apr_structures.map
1048 xs/maps/apr_types.map
1049 xs/maps/modperl_functions.map
1050 xs/maps/modperl_structures.map
1051 xs/maps/modperl_types.map
1052 xs/modperl_xs_util.h
1053 xs/tables/current/APR/FunctionTable.pm
1054 xs/tables/current/Apache2/ConstantsTable.pm
1055 xs/tables/current/Apache2/FunctionTable.pm
1056 xs/tables/current/Apache2/StructureTable.pm
1057 xs/tables/current/ModPerl/FunctionTable.pm
1058 xs/tables/current24/APR/FunctionTable.pm
1059 xs/tables/current24/Apache2/ConstantsTable.pm
1060 xs/tables/current24/Apache2/FunctionTable.pm
1061 xs/tables/current24/Apache2/StructureTable.pm
1062 xs/tables/current24/ModPerl/FunctionTable.pm
1063 xs/typemap
+1
-2
META.yml less more
00 name: mod_perl
1 version_from: lib/mod_perl2.pm
2 version: 2.0.8
1 version: 2.0.9-rc1
32 installdirs: site
43 distribution_type: module
54 no_index:
+14
-17
Makefile.PL less more
9292 dist => {
9393 DIST_DEFAULT => 'mydist',
9494 COMPRESS => 'gzip -9f', SUFFIX=>'gz',
95 PREOP => 'find $(DISTVNAME) -type d -print|xargs chmod 0755 && ' .
96 'find $(DISTVNAME) -type f -print|xargs chmod 0644',
97 TO_UNIX => 'find $(DISTVNAME) -type f -print|xargs dos2unix'
9598 },
9699 );
97100
226229 : MIN_HTTPD_VERSION_DYNAMIC;
227230
228231 if ($build->{MP_APXS}) {
229 debug "Using APXS => $build->{MP_APXS}";
232 print "Using APXS => $build->{MP_APXS}\n";
230233 }
231234 elsif ($build->{MP_AP_PREFIX}) {
232235 if (my $reason = $build->ap_prefix_invalid) {
233236 error "invalid MP_AP_PREFIX: $reason";
234237 exit 1;
235238 }
236 debug "Using Apache prefix => $build->{MP_AP_PREFIX}";
239 print "Using Apache prefix => $build->{MP_AP_PREFIX}\n";
237240 }
238241 else {
239242 unless ($build->{MP_USE_STATIC}) {
488491
489492 open my $fh, 'Changes';
490493 while (<$fh>) {
491 if (/^=item\s+\Q$VERSION\E-(\w+)/) {
492 $VERSION .= "$1";
494 if (/^=item\s+\Q$VERSION\E-(dev|rc\d+)/) {
495 $VERSION .= "-$1";
493496 last;
494497 }
495498 last if /^=item/;
872875
873876 my $string = $self->ModPerl::BuildMM::MY::postamble;
874877
875 if (WIN32) {
878 if (!WIN32) {
876879 $string .= <<'EOF';
877 mydist : Apache-Test/META.yml manifest tardist
878
879 EOF
880 }
881 else {
882 $string .= <<'EOF';
883 mydist : Apache-Test/META.yml mod_perl.spec manifest tardist
884
885880 rpm: dist
886881 @[ -d $(PWD)/rpm ] || mkdir $(PWD)/rpm
887882 rpmbuild -ta --define "_rpmdir $(PWD)/rpm" \
890885 @mv $(PWD)/rpm/*/*.rpm $(PWD)/rpm/
891886 @rm -rf $(PWD)/rpm/*/
892887
888 EOF
889 }
890
891 $string .= <<'EOF';
892 mydist : Apache-Test/META.yml mod_perl.spec manifest tardist
893
893894 mod_perl.spec: build/make_rpm_spec
894895 $(PERL) build/make_rpm_spec
895896
896 EOF
897 }
898
899 $string .= <<'EOF';
900897 Apache-Test/META.yml:
901898 cd Apache-Test && make metafile
902899
+1
-1
ModPerl-Registry/Makefile.PL less more
1313
1414 # prerequisites
1515 my %require = (
16 "Apache::Test" => "", # any version will do?
16 "Apache::Test" => "0", # any version will do?
1717 );
1818
1919 my @scripts = qw(t/TEST t/SMOKE);
+0
-0
ModPerl-Registry/t/cgi-bin/206.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/304.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/404.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/basic.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/bin_resp_start_0.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/cgi.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/closure.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/content_type.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/env.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/env_val.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/exit.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/flush.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/ithreads_io_n_tie.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/missing_headers.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/nph-foo.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/perlrun_extload.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/prefork.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/r_inherited.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/redirect-cookie.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/redirect.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/require.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/runtime_error.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/runtime_error_n_status_change.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/runtime_error_plus_body.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/send_headers.html less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/special_blocks.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/status_change.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/syntax_error.pl less more
(No changes)
+0
-0
ModPerl-Registry/t/cgi-bin/use_error.pl less more
(No changes)
+11
-2
README less more
22 *** Prerequisites ***
33
44 Apache:
5 Dynamic mod_perl (DSO): Apache 2.0.47 - 2.2.22.
6 Static mod_perl: Apache 2.0.51 - 2.2.22.
5 Dynamic mod_perl (DSO): Apache 2.0.47 - 2.4.12.
6 Static mod_perl: Apache 2.0.51 - 2.4.12.
77
88 Newer Apache versions may work with this version of mod_perl. If
99 not, the svn version likely will, which can be obtained from:
2525
2626 mod_perl is currently considered stable.
2727
28 Four test scripts are currently known to fail with Apache 2.4.x on Windows:
29
30 t/protocol/echo_block.t (Fails tests 2-3)
31 t/protocol/echo_nonblock.t (Fails test 2)
32 t/protocol/echo_timeout.t (Fails tests 2-5)
33 t/protocol/pseudo_http.t (Fails tests 3-8 and 11-13)
34
35 In addition, t/modules/proxy.t currently fails with both Apache 2.2.x and
36 2.4.x on Windows.
2837
2938 *** Documentation ***
3039
+10
-8
RELEASE less more
2121
2222 a. login into https://pause.perl.org
2323 b. menu click: Select Mailinglist/Action
24 c. choose APML and share_perms and click go
24 c. choose APML and Change Permissions and click go
2525 d. click 3.1 Make somebody else co-maintainer
2626 e. choose the modules to give the perms to
2727 type the username of the new co-maintainer
215215
216216 a. increment version in lib/mod_perl2.pm
217217
218 b. edit ./Changes:
218 b. increment version in META.yml
219
220 c. edit ./Changes:
219221 - start a new item with incremented version + '-dev'
220222
221223 =item 2.0.10-dev
222224
223 c. add a release entry in STATUS
224
225 d. update this file versions to make it easy to copy-n-paste things
225 d. add a release entry in STATUS
226
227 e. update this file versions to make it easy to copy-n-paste things
226228 on the next release:
227229
228230 $ perl -pi -e 's/(\d+)([._])(\d+)(\2)(\d+)/join($2, $1, $3, $5+1)/eg' RELEASE
229231
230 e. commit the changed files
231
232 % svn ci -m "start 2.0.9-dev cycle" Changes lib/mod_perl2.pm \
232 f. commit the changed files
233
234 % svn ci -m "start 2.0.9-dev cycle" Changes META.yml lib/mod_perl2.pm \
233235 STATUS RELEASE
234236
235237 10. Old Versions
+1
-1
STATUS less more
00 mod_perl 2.0 STATUS: -*-text-*-
1 Last modified at [$Date: 2013-04-18 05:21:34 +0300 (Thu, 18 Apr 2013) $]
1 Last modified at [$Date: 2013-04-18 03:21:34 +0100 (Thu, 18 Apr 2013) $]
22
33 Release:
44 --------
+0
-0
bin/mp2bug less more
(No changes)
+0
-0
build/make_rpm_spec less more
(No changes)
+0
-0
build/win32_fetch_apxs less more
(No changes)
+22
-14
lib/Apache2/Build.pm less more
142142 defined $prefix && -d $prefix && -e "$prefix/CHANGES";
143143 }
144144
145 # try to find the apxs utility, set $apxs to the path if found,
145 # try to find the apxs utility, set $self->{MP_APXS} to the path if found,
146146 # otherwise to ''
147 my $apxs; # undef so we know we haven't tried to set it yet
148147 sub find_apxs_util {
149148 my $self = shift;
150149
151 $apxs = ''; # not found
150 if (not defined $self->{MP_APXS}) {
151 $self->{MP_APXS} = ''; # not found
152 }
153
152154 my @trys = ($Apache2::Build::APXS,
153155 $self->{MP_APXS},
154156 $ENV{MP_APXS});
178180 next unless ($apxs_try = $_);
179181 chomp $apxs_try;
180182 if (-x $apxs_try) {
181 $apxs = $apxs_try;
183 $self->{MP_APXS} = $apxs_try;
182184 last;
183185 }
184186 }
208210 sub apxs {
209211 my $self = shift;
210212
211 $self->find_apxs_util() unless defined $apxs;
213 $self->find_apxs_util() unless defined $self->{MP_APXS};
212214
213215 my $is_query = (@_ == 2) && ($_[0] eq '-q');
214216
222224 }
223225 }
224226
225 unless ($apxs) {
227 unless ($self->{MP_APXS}) {
226228 my $prefix = $self->{MP_AP_PREFIX} || "";
227229 return '' unless -d $prefix and $is_query;
228230 my $val = $apxs_query{$_[1]};
230232 }
231233
232234 my $devnull = devnull();
233 my $val = qx($apxs @_ 2>$devnull);
235 my $val = qx($self->{MP_APXS} @_ 2>$devnull);
234236 chomp $val if defined $val;
235237
236238 unless ($val) {
237239 # do we have an error or is it just an empty value?
238 my $error = qx($apxs @_ 2>&1);
240 my $error = qx($self->{MP_APXS} @_ 2>&1);
239241 chomp $error if defined $error;
240242 if ($error) {
241 error "'$apxs @_' failed:";
243 error "'$self->{MP_APXS} @_' failed:";
242244 error $error;
243245 }
244246 else {
614616 # Solaris, so we need apr flags living in apxs' EXTRA_CPPFLAGS
615617 my $extra_cppflags = $self->apxs_extra_cppflags;
616618 $ccopts .= " " . $extra_cppflags;
619
620 # Make sure the evil AP_DEBUG is not defined when building mod_perl
621 $ccopts =~ s/ ?-DAP_DEBUG\b//;
617622
618623 $ccopts;
619624 }
917922 my $self = bless {
918923 cwd => Cwd::fastcwd(),
919924 MP_LIBNAME => 'mod_perl',
925 MP_APXS => undef, # so we know we haven't tried to set it yet
920926 @_,
921927 }, $class;
922928
937943
938944 sub clean_files {
939945 my $self = shift;
940 [map { $self->default_file($_) } keys %default_files];
946 [sort map { $self->default_file($_) } keys %default_files];
941947 }
942948
943949 sub default_file {
15231529 my @files;
15241530 my @xs_targ;
15251531
1526 while (my ($name, $xs) = each %{ $self->{XS} }) {
1532 foreach my $name (sort keys %{ $self->{XS} }) {
1533 my $xs = $self->{XS}->{$name};
15271534 #Foo/Bar.xs => Foo_Bar.c
15281535 (my $c = $xs) =~ s:.*?WrapXS/::;
15291536 $c =~ s:/:_:g;
15671574 my %perl_config_pm_alias_values = reverse %perl_config_pm_alias;
15681575 my @perl_config_pm_alias_values = keys %perl_config_pm_alias_values;
15691576
1570 my @perl_config_pm = (@perl_config_pm_alias_values, qw(cc cpprun
1577 my @perl_config_pm = sort(@perl_config_pm_alias_values, qw(cc cpprun
15711578 rm ranlib lib_ext obj_ext cccdlflags lddlflags optimize));
15721579
15731580 sub mm_replace {
18821889 #XXX short-term compat for Apache::TestConfigPerl
18831890 $libs{shared} = $libs{dso};
18841891
1885 while (my ($type, $lib) = each %libs) {
1892 foreach my $type (sort keys %libs) {
1893 my $lib = $libs{$type};
18861894 print $fh $self->canon_make_attr("lib_$type", $libs{$type});
18871895 }
18881896
19361944 }
19371945
19381946 my @libs;
1939 for my $type (map { uc } keys %libs) {
1947 for my $type (sort map { uc } keys %libs) {
19401948 next unless $self->{"MP_USE_$type"};
19411949 # on win32 mod_perl.lib must come after mod_perl.so
19421950 $type eq 'STATIC'
+2
-1
lib/ModPerl/BuildMM.pm less more
256256 }
257257 }
258258
259 while (my ($pm, $blib) = each %pms) {
259 foreach my $pm (sort keys %pms) {
260 my $blib = $pms{$pm};
260261 $pm =~ s|/\./|/|g; # clean the path
261262 $blib =~ s|/\./|/|g; # clean the path
262263 my @segm = splitdir $blib;
+28
-25
lib/ModPerl/BuildOptions.pm less more
2020
2121 use Apache2::Build ();
2222 use Apache::TestTrace;
23 use Config ();
2324 my $param_qr = qr([\s=]+);
2425
2526 use constant VERBOSE => 1;
2829 use File::Spec;
2930
3031 sub init {
31 my ($self, $build) = @_;
32 my ($class, $build) = @_;
3233
3334 #@ARGV should override what's in .makepl_args.mod_perl2
3435 #but @ARGV might also override the default MP_OPTS_FILE
6667 $build->{MP_COMPAT_1X} = 1
6768 unless exists $build->{MP_COMPAT_1X} && !$build->{MP_COMPAT_1X};
6869
69 # make a last ditch effort to find apxs in $ENV{PATH}
70 # try to find apxs
7071 if (!$build->{MP_AP_PREFIX} && !$build->{MP_APXS}) {
71
72 my @paths = split(/:/, $ENV{PATH});
73 my $potential_apxs;
74 while (!$potential_apxs) {
75
76 last if scalar(@paths) == 0; # don't loop endlessly
77 $potential_apxs = File::Spec->catfile(shift @paths, 'apxs');
78 if (-e $potential_apxs && -x $potential_apxs) {
79
80 $build->{MP_APXS} = $potential_apxs;
81 print "MP_APXS unspecified, using $potential_apxs\n\n";
82 } else {
83 undef $potential_apxs;
72 $build->find_apxs_util();
73
74 # make a last ditch effort to find apxs in $ENV{PATH}
75 if (!$build->{MP_APXS}) {
76 my @paths = split(/$Config::Config{path_sep}/, $ENV{PATH});
77 my $potential_apxs;
78 while (!$potential_apxs) {
79 last if scalar(@paths) == 0; # don't loop endlessly
80 $potential_apxs = File::Spec->catfile(shift @paths, 'apxs');
81 $potential_apxs .= '.bat' if Apache2::Build::WIN32();
82 if (-e $potential_apxs && -x $potential_apxs) {
83 $build->{MP_APXS} = $potential_apxs;
84 } else {
85 undef $potential_apxs;
86 }
8487 }
8588 }
8689 }
8790 }
8891
8992 sub parse {
90 my ($self, $lines, $opts) = @_;
93 my ($build, $lines, $opts) = @_;
9194
9295 $opts = VERBOSE|UNKNOWN_FATAL unless defined $opts;
9396 my $table = table();
148151 }
149152
150153 if ($table->{$key}->{append}){
151 $self->{$key} = join " ", grep $_, $self->{$key}, $val;
154 $build->{$key} = join " ", grep $_, $build->{$key}, $val;
152155 }
153156 else {
154 $self->{$key} = $val;
157 $build->{$key} = $val;
155158 }
156159
157160 print " $key = $val\n" if $opts & VERBOSE;
165168 }
166169
167170 sub parse_file {
168 my $self = shift;
171 my $build = shift;
169172
170173 my $fh;
171174 my @dirs = qw(./ ../ ./. ../.);
172175 push @dirs, "$ENV{HOME}/." if exists $ENV{HOME};
173176 my @files = map { $_ . 'makepl_args.mod_perl2' } @dirs;
174 unshift @files, $self->{MP_OPTIONS_FILE} if $self->{MP_OPTIONS_FILE};
177 unshift @files, $build->{MP_OPTIONS_FILE} if $build->{MP_OPTIONS_FILE};
175178
176179 for my $file (@files) {
177180 if (open $fh, $file) {
178 $self->{MP_OPTIONS_FILE} = $file;
181 $build->{MP_OPTIONS_FILE} = $file;
179182 last;
180183 }
181184 $fh = undef;
183186
184187 return unless $fh;
185188
186 print "Reading Makefile.PL args from $self->{MP_OPTIONS_FILE}\n";
187 my $unknowns = parse($self, [<$fh>]);
189 print "Reading Makefile.PL args from $build->{MP_OPTIONS_FILE}\n";
190 my $unknowns = parse($build, [<$fh>]);
188191 push @ARGV, @$unknowns if $unknowns;
189192
190193 close $fh;
191194 }
192195
193196 sub parse_argv {
194 my $self = shift;
197 my $build = shift;
195198 return unless @ARGV;
196199
197200 my @args = @ARGV;
198201 @ARGV = ();
199202
200203 print "Reading Makefile.PL args from \@ARGV\n";
201 my $unknowns = parse($self, \@args);
204 my $unknowns = parse($build, \@args);
202205 push @ARGV, @$unknowns if $unknowns;
203206 }
204207
+30
-19
lib/ModPerl/Code.pm less more
134134 }
135135
136136 #XXX: allow disabling of PerDir hooks on a PerDir basis
137 my @hook_flags = (map { canon_uc($_) } keys %hooks);
137 my @hook_flags = sort(map { canon_uc($_) } keys %hooks);
138138 my @ithread_opts = qw(CLONE PARENT);
139139 my %flags = (
140140 Srv => ['NONE', @ithread_opts, qw(ENABLE AUTOLOAD MERGE_HANDLERS),
171171 sub handler_desc {
172172 my ($self, $h_add, $c_add) = @_;
173173 local $" = ",\n";
174 while (my ($class, $h) = each %{ $self->{handler_index_desc} }) {
174 foreach my $class (sort keys %{ $self->{handler_index_desc} }) {
175 my $h = $self->{handler_index_desc}->{$class};
175176 my $func = canon_func('handler', 'desc', $class);
176177 my $array = join '_', 'MP', $func;
177178 my $proto = "const char *$func(int idx)";
197198
198199 my $type = 1;
199200
200 while (my ($class, $handlers) = each %{ $self->{handlers} }) {
201 foreach my $class (sort keys %{ $self->{handlers} }) {
202 my $handlers = $self->{handlers}->{$class};
201203 my $i = 0;
202204 my $n = @$handlers;
203205 my $handler_type = canon_define('HANDLER_TYPE', $class);
225227
226228 my @register_hooks;
227229
228 while (my ($class, $prototype) = each %{ $self->{hook_proto} }) {
230 foreach my $class (sort keys %{ $self->{hook_proto} }) {
231 my $prototype = $self->{hook_proto}->{$class};
229232 my $callback = canon_func('callback', $class);
230233 my $return = $prototype->{ret} eq 'void' ? '' : 'return';
231234 my $i = -1;
293296 switch (*name) {
294297 EOF
295298
296 while (my ($class, $handlers) = each %{ $self->{handlers} }) {
299 foreach my $class (sort keys %{ $self->{handlers} }) {
300 my $handlers = $self->{handlers}->{$class};
297301 my $i = 0;
298302
299303 for my $name (@$handlers) {
339343
340344 my @cmd_entries;
341345
342 while (my ($class, $handlers) = each %{ $self->{handlers} }) {
346 foreach my $class (sort keys %{ $self->{handlers} }) {
347 my $handlers = $self->{handlers}->{$class};
343348 my $prototype = $self->{directive_proto}->{$class};
344349 my $i = 0;
345350
400405
401406 print $h_fh "\n#define MP_SYS_$dlsrc 1\n";
402407
403 while (my ($class, $opts) = each %{ $self->{flags} }) {
408 foreach my $class (sort keys %{ $self->{flags} }) {
409 my $opts = $self->{flags}->{$class};
404410 my @lookup = ();
405411 my %lookup = ();
406412 my $lookup_proto = "";
448454 my $indent1 = " " x 4;
449455 my $indent2 = " " x 8;
450456 my %switch = ();
451 for (keys %lookup) {
457 for (sort keys %lookup) {
452458 if (/^(\w)/) {
453459 my $gap = " " x ($max_len - length $_);
454460 push @{ $switch{$1} },
457463 }
458464
459465 push @lookup, '', $indent1 . "switch (*str) {";
460 for (keys %switch) {
466 for (sort keys %switch) {
461467 push @lookup, $indent1 . " case '$_':";
462468 push @lookup, map { $indent2 . $_ } @{ $switch{$_} };
463469 }
743749
744750 sub postamble {
745751 my $self = shift;
746 for my $name (keys %{ $self->{fh} }) {
752 for my $name (sort keys %{ $self->{fh} }) {
747753 next unless my $av = $self->{postamble}->{$name};
748754 print { $self->fh($name) } @$av;
749755 }
790796 @ExtUtils::Embed::Extensions = grep{$_} @ExtUtils::Embed::Extensions;
791797
792798 #create bootstrap method for static xs modules
793 my $static_xs = [keys %{ $build->{XS} }];
799 my $static_xs = [sort keys %{ $build->{XS} }];
794800 ExtUtils::Embed::xsinit($xsinit, 1, $static_xs);
795801
796802 #$self->generate_constants_pod();
930936 sub generate_constants_lookup {
931937 my ($h_fh, $c_fh) = @_;
932938
933 while (my ($class, $groups) = each %$Apache2::ConstantsTable) {
934 my $constants = [map { @$_ } values %$groups];
939 foreach my $class (sort keys %$Apache2::ConstantsTable) {
940 my $groups = $Apache2::ConstantsTable->{$class};
941 my $constants = [sort map { @$_ } values %$groups];
935942
936943 constants_lookup_code($h_fh, $c_fh, $constants, $class);
937944 }
940947 sub generate_constants_group_lookup {
941948 my ($h_fh, $c_fh) = @_;
942949
943 while (my ($class, $groups) = each %$Apache2::ConstantsTable) {
950 foreach my $class (sort keys %$Apache2::ConstantsTable) {
951 my $groups = $Apache2::ConstantsTable->{$class};
944952 constants_group_lookup_code($h_fh, $c_fh, $class, $groups);
945953 }
946954 }
951959 my @code;
952960
953961 $class = canon_lc(lc $class);
954 while (my ($group, $constants) = each %$groups) {
962 foreach my $group (sort keys %$groups) {
963 my $constants = $groups->{$group};
955964 push @tags, $group;
956965 my $name = join '_', 'MP_constants', $class, $group;
957966 print $c_fh "\nstatic const char *$name [] = { \n",
10071016
10081017 require File::Path;
10091018 my $file = "Const.pod";
1010 for my $class (keys %data) {
1019 for my $class (sort keys %data) {
10111020 my $path = catdir "tmp", $class;
10121021 File::Path::mkpath($path, 0, 0755);
10131022 my $filepath = catfile $path, $file;
10501059 sub generate_constants_lookup_doc {
10511060 my ($data) = @_;
10521061
1053 while (my ($class, $groups) = each %$Apache2::ConstantsTable) {
1054 my $constants = [map { @$_ } values %$groups];
1062 foreach my $class (sort keys %$Apache2::ConstantsTable) {
1063 my $groups = $Apache2::ConstantsTable->{$class};
1064 my $constants = [sort map { @$_ } values %$groups];
10551065
10561066 constants_lookup_code_doc($constants, $class, $data);
10571067 }
10601070 sub generate_constants_group_lookup_doc {
10611071 my ($data) = @_;
10621072
1063 while (my ($class, $groups) = each %$Apache2::ConstantsTable) {
1073 foreach my $class (sort keys %$Apache2::ConstantsTable) {
1074 my $groups = $Apache2::ConstantsTable->{$class};
10641075 constants_group_lookup_code_doc($class, $groups, $data);
10651076 }
10661077 }
+171
-0
lib/ModPerl/DummyVersions.pm less more
0 #
1 # /*
2 # * *********** WARNING **************
3 # * This file generated by ModPerl::WrapXS/0.01
4 # * Any changes made here will be lost
5 # * ***********************************
6 # * 01: lib/ModPerl/Code.pm:716
7 # * 02: lib/ModPerl/WrapXS.pm:1138
8 # * 03: lib/ModPerl/WrapXS.pm:1190
9 # * 04: Makefile.PL:435
10 # * 05: Makefile.PL:333
11 # * 06: Makefile.PL:59
12 # */
13 #
14
15 package APR::Base64;
16 $APR::Base64::VERSION = 0.009000;
17
18 package APR::Brigade;
19 $APR::Brigade::VERSION = 0.009000;
20
21 package APR::Bucket;
22 $APR::Bucket::VERSION = 0.009000;
23
24 package APR::BucketAlloc;
25 $APR::BucketAlloc::VERSION = 0.009000;
26
27 package APR::BucketType;
28 $APR::BucketType::VERSION = 0.009000;
29
30 package APR::Date;
31 $APR::Date::VERSION = 0.009000;
32
33 package APR::Error;
34 $APR::Error::VERSION = 0.009000;
35
36 package APR::Finfo;
37 $APR::Finfo::VERSION = 0.009000;
38
39 package APR::IpSubnet;
40 $APR::IpSubnet::VERSION = 0.009000;
41
42 package APR::OS;
43 $APR::OS::VERSION = 0.009000;
44
45 package APR::Pool;
46 $APR::Pool::VERSION = 0.009000;
47
48 package APR::SockAddr;
49 $APR::SockAddr::VERSION = 0.009000;
50
51 package APR::Socket;
52 $APR::Socket::VERSION = 0.009000;
53
54 package APR::Status;
55 $APR::Status::VERSION = 0.009000;
56
57 package APR::String;
58 $APR::String::VERSION = 0.009000;
59
60 package APR::Table;
61 $APR::Table::VERSION = 0.009000;
62
63 package APR::ThreadMutex;
64 $APR::ThreadMutex::VERSION = 0.009000;
65
66 package APR::ThreadRWLock;
67 $APR::ThreadRWLock::VERSION = 0.009000;
68
69 package APR::URI;
70 $APR::URI::VERSION = 0.009000;
71
72 package APR::UUID;
73 $APR::UUID::VERSION = 0.009000;
74
75 package APR::Util;
76 $APR::Util::VERSION = 0.009000;
77
78 package Apache2::Access;
79 $Apache2::Access::VERSION = 2.000009;
80
81 package Apache2::CmdParms;
82 $Apache2::CmdParms::VERSION = 2.000009;
83
84 package Apache2::Command;
85 $Apache2::Command::VERSION = 2.000009;
86
87 package Apache2::Connection;
88 $Apache2::Connection::VERSION = 2.000009;
89
90 package Apache2::ConnectionUtil;
91 $Apache2::ConnectionUtil::VERSION = 2.000009;
92
93 package Apache2::Directive;
94 $Apache2::Directive::VERSION = 2.000009;
95
96 package Apache2::Filter;
97 $Apache2::Filter::VERSION = 2.000009;
98
99 package Apache2::FilterRec;
100 $Apache2::FilterRec::VERSION = 2.000009;
101
102 package Apache2::HookRun;
103 $Apache2::HookRun::VERSION = 2.000009;
104
105 package Apache2::Log;
106 $Apache2::Log::VERSION = 2.000009;
107
108 package Apache2::MPM;
109 $Apache2::MPM::VERSION = 2.000009;
110
111 package Apache2::Module;
112 $Apache2::Module::VERSION = 2.000009;
113
114 package Apache2::Process;
115 $Apache2::Process::VERSION = 2.000009;
116
117 package Apache2::Provider;
118 $Apache2::Provider::VERSION = 2.000009;
119
120 package Apache2::RequestIO;
121 $Apache2::RequestIO::VERSION = 2.000009;
122
123 package Apache2::RequestRec;
124 $Apache2::RequestRec::VERSION = 2.000009;
125
126 package Apache2::RequestUtil;
127 $Apache2::RequestUtil::VERSION = 2.000009;
128
129 package Apache2::Response;
130 $Apache2::Response::VERSION = 2.000009;
131
132 package Apache2::ServerRec;
133 $Apache2::ServerRec::VERSION = 2.000009;
134
135 package Apache2::ServerUtil;
136 $Apache2::ServerUtil::VERSION = 2.000009;
137
138 package Apache2::SubProcess;
139 $Apache2::SubProcess::VERSION = 2.000009;
140
141 package Apache2::SubRequest;
142 $Apache2::SubRequest::VERSION = 2.000009;
143
144 package Apache2::URI;
145 $Apache2::URI::VERSION = 2.000009;
146
147 package Apache2::Util;
148 $Apache2::Util::VERSION = 2.000009;
149
150 package ModPerl::Global;
151 $ModPerl::Global::VERSION = 2.000009;
152
153 package ModPerl::InterpPool;
154 $ModPerl::InterpPool::VERSION = 2.000009;
155
156 package ModPerl::Interpreter;
157 $ModPerl::Interpreter::VERSION = 2.000009;
158
159 package ModPerl::MethodLookup;
160 $ModPerl::MethodLookup::VERSION = 2.000009;
161
162 package ModPerl::TiPool;
163 $ModPerl::TiPool::VERSION = 2.000009;
164
165 package ModPerl::TiPoolConfig;
166 $ModPerl::TiPoolConfig::VERSION = 2.000009;
167
168 package ModPerl::Util;
169 $ModPerl::Util::VERSION = 2.000009;
170
+5
-1
lib/ModPerl/Manifest.pm less more
4646 if ($line =~ /(?:\d+)\s+(?:\d+)\s+(?:\w+)\s+(.*)\s*/) {
4747 my $file = $1;
4848 if (-e $file && ! -d $file) {
49 push @files, $1 if -e $1;
49 $file =~ s{\\}{/}g;
50 push @files, $file;
5051 }
5152 }
5253 }
110111 t/response/TestPerl/ithreads.pm
111112 t/response/TestPerl/ithreads_args.pm
112113 t/response/TestPerl/ithreads_eval.pm
114 # broken/out-dated
115 t/perl/ithreads3.t
116 t/response/TestPerl/ithreads3.pm
113117 # incomplete
114118 t/apr-ext/perlio
115119 # PAUSE breaks if a dist has more than one META.yml. the top-level
+1
-1
lib/ModPerl/MapUtil.pm less more
4545
4646 sub function_table {
4747 return $function_table if @$function_table;
48 my $build = Apache2::Build->new(init => 1);
48 my $build = Apache2::Build->new();
4949 my $httpd_version = $build->httpd_version;
5050 if ($httpd_version lt '2.4.0' || ! -d "xs/tables/current24") {
5151 push @INC, "xs/tables/current";
+3035
-0
lib/ModPerl/MethodLookup.pm less more
0 #
1 # /*
2 # * *********** WARNING **************
3 # * This file generated by ModPerl::WrapXS/0.01
4 # * Any changes made here will be lost
5 # * ***********************************
6 # * 01: lib/ModPerl/Code.pm:716
7 # * 02: lib/ModPerl/WrapXS.pm:765
8 # * 03: lib/ModPerl/WrapXS.pm:1189
9 # * 04: Makefile.PL:435
10 # * 05: Makefile.PL:333
11 # * 06: Makefile.PL:59
12 # */
13 #
14
15 package ModPerl::MethodLookup;
16
17 use strict;
18 use warnings;
19
20 my $methods = {
21 'BINMODE' => [
22 [
23 'Apache2::RequestIO',
24 'Apache2::RequestRec'
25 ]
26 ],
27 'CLEAR' => [
28 [
29 'APR::Table',
30 'APR::Table'
31 ]
32 ],
33 'CLOSE' => [
34 [
35 'Apache2::RequestIO',
36 'Apache2::RequestRec'
37 ]
38 ],
39 'DELETE' => [
40 [
41 'APR::Table',
42 'APR::Table'
43 ]
44 ],
45 'DESTROY' => [
46 [
47 'APR::Pool',
48 'APR::Pool'
49 ],
50 [
51 'APR::ThreadMutex',
52 'APR::ThreadMutex'
53 ],
54 [
55 'APR::ThreadRWLock',
56 'APR::ThreadRWLock'
57 ],
58 [
59 'Apache2::SubRequest',
60 'Apache2::SubRequest'
61 ]
62 ],
63 'EXISTS' => [
64 [
65 'APR::Table',
66 'APR::Table'
67 ]
68 ],
69 'FETCH' => [
70 [
71 'APR::Table',
72 'APR::Table'
73 ]
74 ],
75 'FILENO' => [
76 [
77 'Apache2::RequestIO',
78 'Apache2::RequestRec'
79 ]
80 ],
81 'FIRSTKEY' => [
82 [
83 'APR::Table',
84 'APR::Table'
85 ]
86 ],
87 'GETC' => [
88 [
89 'Apache2::RequestIO',
90 'Apache2::RequestRec'
91 ]
92 ],
93 'LOG_MARK' => [
94 [
95 'Apache2::Log',
96 undef
97 ]
98 ],
99 'MODIFY_CODE_ATTRIBUTES' => [
100 [
101 'Apache2::Filter',
102 undef
103 ]
104 ],
105 'NEXTKEY' => [
106 [
107 'APR::Table',
108 'APR::Table'
109 ]
110 ],
111 'OPEN' => [
112 [
113 'Apache2::RequestIO',
114 'Apache2::RequestRec'
115 ]
116 ],
117 'PRINT' => [
118 [
119 'Apache2::Filter',
120 'Apache2::Filter'
121 ],
122 [
123 'Apache2::RequestIO',
124 'Apache2::RequestRec'
125 ]
126 ],
127 'PRINTF' => [
128 [
129 'Apache2::RequestIO',
130 'Apache2::RequestRec'
131 ]
132 ],
133 'READ' => [
134 [
135 'Apache2::RequestIO',
136 'Apache2::RequestRec'
137 ]
138 ],
139 'STORE' => [
140 [
141 'APR::Table',
142 'APR::Table'
143 ]
144 ],
145 'TIEHANDLE' => [
146 [
147 'Apache2::Filter',
148 'Apache2::Filter'
149 ],
150 [
151 'Apache2::RequestIO',
152 'Apache2::RequestRec'
153 ]
154 ],
155 'UNTIE' => [
156 [
157 'Apache2::RequestIO',
158 'Apache2::RequestRec'
159 ]
160 ],
161 'WRITE' => [
162 [
163 'Apache2::RequestIO',
164 'Apache2::RequestRec'
165 ]
166 ],
167 'aborted' => [
168 [
169 'Apache2::Connection',
170 'Apache2::Connection'
171 ]
172 ],
173 'add' => [
174 [
175 'APR::Table',
176 'APR::Table'
177 ],
178 [
179 'Apache2::Module',
180 'Apache2::Module'
181 ]
182 ],
183 'add_config' => [
184 [
185 'Apache2::CmdParms',
186 'Apache2::CmdParms'
187 ],
188 [
189 'Apache2::RequestUtil',
190 'Apache2::RequestRec'
191 ],
192 [
193 'Apache2::ServerUtil',
194 'Apache2::ServerRec'
195 ]
196 ],
197 'add_input_filter' => [
198 [
199 'Apache2::Filter',
200 'Apache2::Connection'
201 ],
202 [
203 'Apache2::Filter',
204 'Apache2::RequestRec'
205 ]
206 ],
207 'add_output_filter' => [
208 [
209 'Apache2::Filter',
210 'Apache2::Connection'
211 ],
212 [
213 'Apache2::Filter',
214 'Apache2::RequestRec'
215 ]
216 ],
217 'add_version_component' => [
218 [
219 'Apache2::ServerUtil',
220 'Apache2::ServerRec'
221 ]
222 ],
223 'addrs' => [
224 [
225 'Apache2::ServerRec',
226 'Apache2::ServerRec'
227 ]
228 ],
229 'alert' => [
230 [
231 'Apache2::Log',
232 undef
233 ]
234 ],
235 'allow_methods' => [
236 [
237 'Apache2::Access',
238 'Apache2::RequestRec'
239 ]
240 ],
241 'allow_options' => [
242 [
243 'Apache2::Access',
244 'Apache2::RequestRec'
245 ]
246 ],
247 'allow_override_opts' => [
248 [
249 'Apache2::Access',
250 'Apache2::RequestRec'
251 ]
252 ],
253 'allow_overrides' => [
254 [
255 'Apache2::Access',
256 'Apache2::RequestRec'
257 ]
258 ],
259 'allowed' => [
260 [
261 'Apache2::RequestRec',
262 'Apache2::RequestRec'
263 ]
264 ],
265 'allowed_methods' => [
266 [
267 'Apache2::RequestRec',
268 'Apache2::RequestRec'
269 ]
270 ],
271 'allowed_xmethods' => [
272 [
273 'Apache2::RequestRec',
274 'Apache2::RequestRec'
275 ]
276 ],
277 'ap_api_major_version' => [
278 [
279 'Apache2::Module',
280 'Apache2::Module'
281 ]
282 ],
283 'ap_api_minor_version' => [
284 [
285 'Apache2::Module',
286 'Apache2::Module'
287 ]
288 ],
289 'ap_auth_type' => [
290 [
291 'Apache2::RequestRec',
292 'Apache2::RequestRec'
293 ]
294 ],
295 'args' => [
296 [
297 'Apache2::Directive',
298 'Apache2::Directive'
299 ],
300 [
301 'Apache2::RequestRec',
302 'Apache2::RequestRec'
303 ]
304 ],
305 'args_how' => [
306 [
307 'Apache2::Command',
308 'Apache2::Command'
309 ]
310 ],
311 'as_hash' => [
312 [
313 'Apache2::Directive',
314 'Apache2::Directive'
315 ]
316 ],
317 'as_string' => [
318 [
319 'Apache2::Directive',
320 'Apache2::Directive'
321 ],
322 [
323 'Apache2::RequestUtil',
324 'Apache2::RequestRec'
325 ]
326 ],
327 'assbackwards' => [
328 [
329 'Apache2::RequestRec',
330 'Apache2::RequestRec'
331 ]
332 ],
333 'atime' => [
334 [
335 'APR::Finfo',
336 'APR::Finfo'
337 ]
338 ],
339 'auth_name' => [
340 [
341 'Apache2::Access',
342 'Apache2::RequestRec'
343 ]
344 ],
345 'auth_type' => [
346 [
347 'Apache2::Access',
348 'Apache2::RequestRec'
349 ]
350 ],
351 'base_server' => [
352 [
353 'Apache2::Connection',
354 'Apache2::Connection'
355 ]
356 ],
357 'bind' => [
358 [
359 'APR::Socket',
360 'APR::Socket'
361 ]
362 ],
363 'bucket_alloc' => [
364 [
365 'APR::Brigade',
366 'APR::Brigade'
367 ],
368 [
369 'Apache2::Connection',
370 'Apache2::Connection'
371 ]
372 ],
373 'bytes_sent' => [
374 [
375 'Apache2::RequestRec',
376 'Apache2::RequestRec'
377 ]
378 ],
379 'c' => [
380 [
381 'Apache2::Filter',
382 'Apache2::Filter'
383 ]
384 ],
385 'cfg' => [
386 [
387 'ModPerl::TiPool',
388 'ModPerl::TiPool'
389 ]
390 ],
391 'check_cmd_context' => [
392 [
393 'Apache2::CmdParms',
394 'Apache2::CmdParms'
395 ]
396 ],
397 'child_terminate' => [
398 [
399 'Apache2::RequestUtil',
400 'Apache2::RequestRec'
401 ]
402 ],
403 'cleanup' => [
404 [
405 'APR::Brigade',
406 'APR::Brigade'
407 ]
408 ],
409 'cleanup_for_exec' => [
410 [
411 'APR::Pool',
412 'APR::Pool'
413 ]
414 ],
415 'cleanup_register' => [
416 [
417 'APR::Pool',
418 'APR::Pool'
419 ]
420 ],
421 'clear' => [
422 [
423 'APR::Pool',
424 'APR::Pool'
425 ],
426 [
427 'APR::Table',
428 'APR::Table'
429 ]
430 ],
431 'client_addr' => [
432 [
433 'Apache2::Connection',
434 'Apache2::Connection'
435 ]
436 ],
437 'client_ip' => [
438 [
439 'Apache2::Connection',
440 'Apache2::Connection'
441 ]
442 ],
443 'client_socket' => [
444 [
445 'Apache2::Connection',
446 'Apache2::Connection'
447 ]
448 ],
449 'close' => [
450 [
451 'APR::Socket',
452 'APR::Socket'
453 ]
454 ],
455 'cmd' => [
456 [
457 'Apache2::CmdParms',
458 'Apache2::CmdParms'
459 ]
460 ],
461 'cmds' => [
462 [
463 'Apache2::Module',
464 'Apache2::Module'
465 ]
466 ],
467 'compress' => [
468 [
469 'APR::Table',
470 'APR::Table'
471 ]
472 ],
473 'concat' => [
474 [
475 'APR::Brigade',
476 'APR::Brigade'
477 ]
478 ],
479 'conftree' => [
480 [
481 'Apache2::Directive',
482 'Apache2::Directive'
483 ]
484 ],
485 'conn_config' => [
486 [
487 'Apache2::Connection',
488 'Apache2::Connection'
489 ]
490 ],
491 'connect' => [
492 [
493 'APR::Socket',
494 'APR::Socket'
495 ]
496 ],
497 'connection' => [
498 [
499 'Apache2::RequestRec',
500 'Apache2::RequestRec'
501 ]
502 ],
503 'construct_server' => [
504 [
505 'Apache2::URI',
506 'Apache2::RequestRec'
507 ]
508 ],
509 'construct_url' => [
510 [
511 'Apache2::URI',
512 'Apache2::RequestRec'
513 ]
514 ],
515 'content_encoding' => [
516 [
517 'Apache2::RequestRec',
518 'Apache2::RequestRec'
519 ]
520 ],
521 'content_languages' => [
522 [
523 'Apache2::RequestRec',
524 'Apache2::RequestRec'
525 ]
526 ],
527 'content_type' => [
528 [
529 'Apache2::RequestRec',
530 'Apache2::RequestRec'
531 ]
532 ],
533 'context' => [
534 [
535 'Apache2::CmdParms',
536 'Apache2::CmdParms'
537 ],
538 [
539 'Apache2::ServerRec',
540 'Apache2::ServerRec'
541 ]
542 ],
543 'copy' => [
544 [
545 'APR::Table',
546 'APR::Table'
547 ]
548 ],
549 'crit' => [
550 [
551 'Apache2::Log',
552 undef
553 ]
554 ],
555 'csize' => [
556 [
557 'APR::Finfo',
558 'APR::Finfo'
559 ]
560 ],
561 'ctime' => [
562 [
563 'APR::Finfo',
564 'APR::Finfo'
565 ]
566 ],
567 'ctx' => [
568 [
569 'Apache2::Filter',
570 'Apache2::Filter'
571 ]
572 ],
573 'current' => [
574 [
575 'ModPerl::Interpreter',
576 'ModPerl::Interpreter'
577 ]
578 ],
579 'current_callback' => [
580 [
581 'ModPerl::Util',
582 'ModPerl::Util'
583 ]
584 ],
585 'current_perl_id' => [
586 [
587 'ModPerl::Util',
588 'ModPerl::Util'
589 ]
590 ],
591 'current_thread_id' => [
592 [
593 'APR::OS',
594 'APR::OS'
595 ]
596 ],
597 'custom_response' => [
598 [
599 'Apache2::Response',
600 'Apache2::RequestRec'
601 ]
602 ],
603 'data' => [
604 [
605 'APR::Bucket',
606 'APR::Bucket'
607 ]
608 ],
609 'debug' => [
610 [
611 'Apache2::Log',
612 undef
613 ]
614 ],
615 'decode' => [
616 [
617 'APR::Base64',
618 undef
619 ]
620 ],
621 'delete' => [
622 [
623 'APR::Bucket',
624 'APR::Bucket'
625 ]
626 ],
627 'destroy' => [
628 [
629 'APR::Brigade',
630 'APR::Brigade'
631 ],
632 [
633 'APR::Bucket',
634 'APR::Bucket'
635 ],
636 [
637 'APR::BucketAlloc',
638 'APR::BucketAlloc'
639 ],
640 [
641 'APR::Pool',
642 'APR::Pool'
643 ]
644 ],
645 'device' => [
646 [
647 'APR::Finfo',
648 'APR::Finfo'
649 ]
650 ],
651 'die' => [
652 [
653 'Apache2::HookRun',
654 'Apache2::RequestRec'
655 ]
656 ],
657 'dir_config' => [
658 [
659 'Apache2::RequestUtil',
660 'Apache2::RequestRec'
661 ],
662 [
663 'Apache2::ServerUtil',
664 'Apache2::ServerRec'
665 ]
666 ],
667 'directive' => [
668 [
669 'Apache2::CmdParms',
670 'Apache2::CmdParms'
671 ],
672 [
673 'Apache2::Directive',
674 'Apache2::Directive'
675 ]
676 ],
677 'discard_request_body' => [
678 [
679 'Apache2::RequestIO',
680 'Apache2::RequestRec'
681 ]
682 ],
683 'do' => [
684 [
685 'APR::Table',
686 'APR::Table'
687 ]
688 ],
689 'document_root' => [
690 [
691 'Apache2::RequestUtil',
692 'Apache2::RequestRec'
693 ]
694 ],
695 'emerg' => [
696 [
697 'Apache2::Log',
698 undef
699 ]
700 ],
701 'encode' => [
702 [
703 'APR::Base64',
704 undef
705 ]
706 ],
707 'encode_len' => [
708 [
709 'APR::Base64',
710 'APR::Base64'
711 ]
712 ],
713 'eos_create' => [
714 [
715 'APR::Bucket',
716 'APR::Bucket'
717 ]
718 ],
719 'equal' => [
720 [
721 'APR::SockAddr',
722 'APR::SockAddr'
723 ]
724 ],
725 'err_headers_out' => [
726 [
727 'Apache2::RequestRec',
728 'Apache2::RequestRec'
729 ]
730 ],
731 'errmsg' => [
732 [
733 'Apache2::Command',
734 'Apache2::Command'
735 ]
736 ],
737 'error' => [
738 [
739 'Apache2::Log',
740 undef
741 ]
742 ],
743 'error_fname' => [
744 [
745 'Apache2::ServerRec',
746 'Apache2::ServerRec'
747 ]
748 ],
749 'error_log2stderr' => [
750 [
751 'Apache2::ServerUtil',
752 'Apache2::ServerRec'
753 ]
754 ],
755 'escape_path' => [
756 [
757 'Apache2::Util',
758 'Apache2::Util'
759 ]
760 ],
761 'exists_config_define' => [
762 [
763 'Apache2::ServerUtil',
764 'Apache2::ServerUtil'
765 ]
766 ],
767 'fflush' => [
768 [
769 'Apache2::Filter',
770 'Apache2::Filter'
771 ]
772 ],
773 'filename' => [
774 [
775 'Apache2::Directive',
776 'Apache2::Directive'
777 ],
778 [
779 'Apache2::RequestRec',
780 'Apache2::RequestRec'
781 ]
782 ],
783 'filepath_name_get' => [
784 [
785 'APR::Util',
786 'APR::Util'
787 ]
788 ],
789 'filetype' => [
790 [
791 'APR::Finfo',
792 'APR::Finfo'
793 ]
794 ],
795 'filter_flush' => [
796 [
797 'Apache2::Filter',
798 'APR::Brigade'
799 ]
800 ],
801 'find_linked_module' => [
802 [
803 'Apache2::Module',
804 'Apache2::Module'
805 ]
806 ],
807 'finfo' => [
808 [
809 'Apache2::RequestRec',
810 'Apache2::RequestRec'
811 ]
812 ],
813 'first' => [
814 [
815 'APR::Brigade',
816 'APR::Brigade'
817 ]
818 ],
819 'first_child' => [
820 [
821 'Apache2::Directive',
822 'Apache2::Directive'
823 ]
824 ],
825 'flatten' => [
826 [
827 'APR::Brigade',
828 'APR::Brigade'
829 ]
830 ],
831 'flush_create' => [
832 [
833 'APR::Bucket',
834 'APR::Bucket'
835 ]
836 ],
837 'fname' => [
838 [
839 'APR::Finfo',
840 'APR::Finfo'
841 ]
842 ],
843 'format' => [
844 [
845 'APR::UUID',
846 undef
847 ]
848 ],
849 'format_size' => [
850 [
851 'APR::String',
852 'APR::String'
853 ]
854 ],
855 'fragment' => [
856 [
857 'APR::URI',
858 'APR::URI'
859 ]
860 ],
861 'frec' => [
862 [
863 'Apache2::Filter',
864 'Apache2::Filter'
865 ]
866 ],
867 'get' => [
868 [
869 'APR::Table',
870 undef
871 ]
872 ],
873 'get_basic_auth_pw' => [
874 [
875 'Apache2::Access',
876 undef
877 ]
878 ],
879 'get_brigade' => [
880 [
881 'Apache2::Filter',
882 'Apache2::Filter'
883 ]
884 ],
885 'get_client_block' => [
886 [
887 'Apache2::RequestIO',
888 'Apache2::RequestRec'
889 ]
890 ],
891 'get_config' => [
892 [
893 'Apache2::Module',
894 'Apache2::Module'
895 ]
896 ],
897 'get_handlers' => [
898 [
899 'Apache2::RequestUtil',
900 'Apache2::RequestRec'
901 ],
902 [
903 'Apache2::ServerUtil',
904 'Apache2::ServerRec'
905 ]
906 ],
907 'get_limit_req_body' => [
908 [
909 'Apache2::RequestUtil',
910 'Apache2::RequestRec'
911 ]
912 ],
913 'get_remote_host' => [
914 [
915 'Apache2::Connection',
916 'Apache2::Connection'
917 ]
918 ],
919 'get_remote_logname' => [
920 [
921 'Apache2::Access',
922 'Apache2::RequestRec'
923 ]
924 ],
925 'get_server_banner' => [
926 [
927 'Apache2::ServerUtil',
928 'Apache2::ServerUtil'
929 ]
930 ],
931 'get_server_description' => [
932 [
933 'Apache2::ServerUtil',
934 'Apache2::ServerUtil'
935 ]
936 ],
937 'get_server_name' => [
938 [
939 'Apache2::RequestUtil',
940 'Apache2::RequestRec'
941 ]
942 ],
943 'get_server_port' => [
944 [
945 'Apache2::RequestUtil',
946 'Apache2::RequestRec'
947 ]
948 ],
949 'get_server_version' => [
950 [
951 'Apache2::ServerUtil',
952 'Apache2::ServerUtil'
953 ]
954 ],
955 'get_status_line' => [
956 [
957 'Apache2::RequestUtil',
958 'Apache2::RequestUtil'
959 ]
960 ],
961 'group' => [
962 [
963 'APR::Finfo',
964 'APR::Finfo'
965 ]
966 ],
967 'group_id' => [
968 [
969 'Apache2::ServerUtil',
970 'Apache2::ServerUtil'
971 ]
972 ],
973 'handler' => [
974 [
975 'Apache2::RequestRec',
976 'Apache2::RequestRec'
977 ]
978 ],
979 'header_only' => [
980 [
981 'Apache2::RequestRec',
982 'Apache2::RequestRec'
983 ]
984 ],
985 'headers_in' => [
986 [
987 'Apache2::RequestRec',
988 'Apache2::RequestRec'
989 ]
990 ],
991 'headers_out' => [
992 [
993 'Apache2::RequestRec',
994 'Apache2::RequestRec'
995 ]
996 ],
997 'hostinfo' => [
998 [
999 'APR::URI',
1000 'APR::URI'
1001 ]
1002 ],
1003 'hostname' => [
1004 [
1005 'APR::URI',
1006 'APR::URI'
1007 ],
1008 [
1009 'Apache2::RequestRec',
1010 'Apache2::RequestRec'
1011 ]
1012 ],
1013 'ht_time' => [
1014 [
1015 'Apache2::Util',
1016 'Apache2::Util'
1017 ]
1018 ],
1019 'id' => [
1020 [
1021 'Apache2::Connection',
1022 'Apache2::Connection'
1023 ]
1024 ],
1025 'in_use' => [
1026 [
1027 'ModPerl::TiPool',
1028 'ModPerl::TiPool'
1029 ]
1030 ],
1031 'info' => [
1032 [
1033 'Apache2::CmdParms',
1034 'Apache2::CmdParms'
1035 ],
1036 [
1037 'Apache2::Log',
1038 undef
1039 ]
1040 ],
1041 'inode' => [
1042 [
1043 'APR::Finfo',
1044 'APR::Finfo'
1045 ]
1046 ],
1047 'input_filters' => [
1048 [
1049 'Apache2::Connection',
1050 'Apache2::Connection'
1051 ],
1052 [
1053 'Apache2::RequestRec',
1054 'Apache2::RequestRec'
1055 ]
1056 ],
1057 'insert_after' => [
1058 [
1059 'APR::Bucket',
1060 'APR::Bucket'
1061 ]
1062 ],
1063 'insert_before' => [
1064 [
1065 'APR::Bucket',
1066 'APR::Bucket'
1067 ]
1068 ],
1069 'insert_head' => [
1070 [
1071 'APR::Brigade',
1072 'APR::Brigade'
1073 ]
1074 ],
1075 'insert_tail' => [
1076 [
1077 'APR::Brigade',
1078 'APR::Brigade'
1079 ]
1080 ],
1081 'internal_fast_redirect' => [
1082 [
1083 'Apache2::SubRequest',
1084 'Apache2::RequestRec'
1085 ]
1086 ],
1087 'internal_redirect' => [
1088 [
1089 'Apache2::SubRequest',
1090 'Apache2::RequestRec'
1091 ]
1092 ],
1093 'internal_redirect_handler' => [
1094 [
1095 'Apache2::SubRequest',
1096 'Apache2::RequestRec'
1097 ]
1098 ],
1099 'invoke_handler' => [
1100 [
1101 'Apache2::HookRun',
1102 'Apache2::RequestRec'
1103 ]
1104 ],
1105 'ip_get' => [
1106 [
1107 'APR::SockAddr',
1108 'APR::SockAddr'
1109 ]
1110 ],
1111 'is_EACCES' => [
1112 [
1113 'APR::Status',
1114 'APR::Status'
1115 ]
1116 ],
1117 'is_EAGAIN' => [
1118 [
1119 'APR::Status',
1120 'APR::Status'
1121 ]
1122 ],
1123 'is_ECONNABORTED' => [
1124 [
1125 'APR::Status',
1126 'APR::Status'
1127 ]
1128 ],
1129 'is_ECONNRESET' => [
1130 [
1131 'APR::Status',
1132 'APR::Status'
1133 ]
1134 ],
1135 'is_ENOENT' => [
1136 [
1137 'APR::Status',
1138 'APR::Status'
1139 ]
1140 ],
1141 'is_EOF' => [
1142 [
1143 'APR::Status',
1144 'APR::Status'
1145 ]
1146 ],
1147 'is_TIMEUP' => [
1148 [
1149 'APR::Status',
1150 'APR::Status'
1151 ]
1152 ],
1153 'is_ancestor' => [
1154 [
1155 'APR::Pool',
1156 'APR::Pool'
1157 ]
1158 ],
1159 'is_empty' => [
1160 [
1161 'APR::Brigade',
1162 'APR::Brigade'
1163 ]
1164 ],
1165 'is_eos' => [
1166 [
1167 'APR::Bucket',
1168 'APR::Bucket'
1169 ]
1170 ],
1171 'is_flush' => [
1172 [
1173 'APR::Bucket',
1174 'APR::Bucket'
1175 ]
1176 ],
1177 'is_initial_req' => [
1178 [
1179 'Apache2::RequestUtil',
1180 'Apache2::RequestRec'
1181 ]
1182 ],
1183 'is_perl_option_enabled' => [
1184 [
1185 'Apache2::RequestUtil',
1186 'Apache2::RequestRec'
1187 ],
1188 [
1189 'Apache2::ServerUtil',
1190 'Apache2::ServerRec'
1191 ]
1192 ],
1193 'is_virtual' => [
1194 [
1195 'Apache2::ServerRec',
1196 'Apache2::ServerRec'
1197 ]
1198 ],
1199 'keep_alive' => [
1200 [
1201 'Apache2::ServerRec',
1202 'Apache2::ServerRec'
1203 ]
1204 ],
1205 'keep_alive_max' => [
1206 [
1207 'Apache2::ServerRec',
1208 'Apache2::ServerRec'
1209 ]
1210 ],
1211 'keep_alive_timeout' => [
1212 [
1213 'Apache2::ServerRec',
1214 'Apache2::ServerRec'
1215 ]
1216 ],
1217 'keepalive' => [
1218 [
1219 'Apache2::Connection',
1220 'Apache2::Connection'
1221 ]
1222 ],
1223 'keepalives' => [
1224 [
1225 'Apache2::Connection',
1226 'Apache2::Connection'
1227 ]
1228 ],
1229 'last' => [
1230 [
1231 'APR::Brigade',
1232 'APR::Brigade'
1233 ]
1234 ],
1235 'length' => [
1236 [
1237 'APR::Brigade',
1238 'APR::Brigade'
1239 ],
1240 [
1241 'APR::Bucket',
1242 'APR::Bucket'
1243 ]
1244 ],
1245 'limit_req_fields' => [
1246 [
1247 'Apache2::ServerRec',
1248 'Apache2::ServerRec'
1249 ]
1250 ],
1251 'limit_req_fieldsize' => [
1252 [
1253 'Apache2::ServerRec',
1254 'Apache2::ServerRec'
1255 ]
1256 ],
1257 'limit_req_line' => [
1258 [
1259 'Apache2::ServerRec',
1260 'Apache2::ServerRec'
1261 ]
1262 ],
1263 'line_num' => [
1264 [
1265 'Apache2::Directive',
1266 'Apache2::Directive'
1267 ]
1268 ],
1269 'listen' => [
1270 [
1271 'APR::Socket',
1272 'APR::Socket'
1273 ]
1274 ],
1275 'loaded' => [
1276 [
1277 'Apache2::Module',
1278 'Apache2::Module'
1279 ]
1280 ],
1281 'local_addr' => [
1282 [
1283 'Apache2::Connection',
1284 'Apache2::Connection'
1285 ]
1286 ],
1287 'local_host' => [
1288 [
1289 'Apache2::Connection',
1290 'Apache2::Connection'
1291 ]
1292 ],
1293 'local_ip' => [
1294 [
1295 'Apache2::Connection',
1296 'Apache2::Connection'
1297 ]
1298 ],
1299 'location' => [
1300 [
1301 'Apache2::RequestUtil',
1302 'Apache2::RequestRec'
1303 ]
1304 ],
1305 'location_merge' => [
1306 [
1307 'Apache2::RequestUtil',
1308 'Apache2::RequestRec'
1309 ]
1310 ],
1311 'lock' => [
1312 [
1313 'APR::ThreadMutex',
1314 'APR::ThreadMutex'
1315 ]
1316 ],
1317 'log' => [
1318 [
1319 'Apache2::Log',
1320 'Apache2::RequestRec'
1321 ],
1322 [
1323 'Apache2::Log',
1324 'Apache2::ServerRec'
1325 ]
1326 ],
1327 'log_error' => [
1328 [
1329 'Apache2::Log',
1330 undef
1331 ],
1332 [
1333 'Apache2::Log',
1334 undef
1335 ]
1336 ],
1337 'log_id' => [
1338 [
1339 'Apache2::Connection',
1340 'Apache2::Connection'
1341 ]
1342 ],
1343 'log_pid' => [
1344 [
1345 'Apache2::Log',
1346 'Apache2::Log'
1347 ]
1348 ],
1349 'log_reason' => [
1350 [
1351 'Apache2::Log',
1352 'Apache2::RequestRec'
1353 ]
1354 ],
1355 'log_rerror' => [
1356 [
1357 'Apache2::Log',
1358 undef
1359 ]
1360 ],
1361 'log_serror' => [
1362 [
1363 'Apache2::Log',
1364 undef
1365 ]
1366 ],
1367 'loglevel' => [
1368 [
1369 'Apache2::ServerUtil',
1370 'Apache2::ServerRec'
1371 ]
1372 ],
1373 'lookup' => [
1374 [
1375 'Apache2::Directive',
1376 undef
1377 ]
1378 ],
1379 'lookup_defaults' => [
1380 [
1381 'Apache2::ServerRec',
1382 'Apache2::ServerRec'
1383 ]
1384 ],
1385 'lookup_dirent' => [
1386 [
1387 'Apache2::SubRequest',
1388 'Apache2::RequestRec'
1389 ]
1390 ],
1391 'lookup_file' => [
1392 [
1393 'Apache2::SubRequest',
1394 'Apache2::RequestRec'
1395 ]
1396 ],
1397 'lookup_method_uri' => [
1398 [
1399 'Apache2::SubRequest',
1400 'Apache2::RequestRec'
1401 ]
1402 ],
1403 'lookup_uri' => [
1404 [
1405 'Apache2::SubRequest',
1406 'Apache2::RequestRec'
1407 ]
1408 ],
1409 'main' => [
1410 [
1411 'Apache2::RequestRec',
1412 'Apache2::RequestRec'
1413 ]
1414 ],
1415 'make' => [
1416 [
1417 'APR::Table',
1418 'APR::Table'
1419 ]
1420 ],
1421 'make_etag' => [
1422 [
1423 'Apache2::Response',
1424 'Apache2::RequestRec'
1425 ]
1426 ],
1427 'max' => [
1428 [
1429 'ModPerl::TiPoolConfig',
1430 'ModPerl::TiPoolConfig'
1431 ]
1432 ],
1433 'max_requests' => [
1434 [
1435 'ModPerl::TiPoolConfig',
1436 'ModPerl::TiPoolConfig'
1437 ]
1438 ],
1439 'max_spare' => [
1440 [
1441 'ModPerl::TiPoolConfig',
1442 'ModPerl::TiPoolConfig'
1443 ]
1444 ],
1445 'meets_conditions' => [
1446 [
1447 'Apache2::Response',
1448 'Apache2::RequestRec'
1449 ]
1450 ],
1451 'merge' => [
1452 [
1453 'APR::Table',
1454 'APR::Table'
1455 ]
1456 ],
1457 'method' => [
1458 [
1459 'Apache2::RequestRec',
1460 'Apache2::RequestRec'
1461 ]
1462 ],
1463 'method_is_limited' => [
1464 [
1465 'Apache2::CmdParms',
1466 'Apache2::CmdParms'
1467 ]
1468 ],
1469 'method_number' => [
1470 [
1471 'Apache2::RequestRec',
1472 'Apache2::RequestRec'
1473 ]
1474 ],
1475 'method_register' => [
1476 [
1477 'Apache2::ServerUtil',
1478 'Apache2::ServerRec'
1479 ]
1480 ],
1481 'min_spare' => [
1482 [
1483 'ModPerl::TiPoolConfig',
1484 'ModPerl::TiPoolConfig'
1485 ]
1486 ],
1487 'mip' => [
1488 [
1489 'ModPerl::Interpreter',
1490 'ModPerl::Interpreter'
1491 ]
1492 ],
1493 'module_config' => [
1494 [
1495 'Apache2::ServerRec',
1496 'Apache2::ServerRec'
1497 ]
1498 ],
1499 'module_index' => [
1500 [
1501 'Apache2::Module',
1502 'Apache2::Module'
1503 ]
1504 ],
1505 'mtime' => [
1506 [
1507 'APR::Finfo',
1508 'APR::Finfo'
1509 ],
1510 [
1511 'Apache2::RequestRec',
1512 'Apache2::RequestRec'
1513 ]
1514 ],
1515 'name' => [
1516 [
1517 'APR::BucketType',
1518 'APR::BucketType'
1519 ],
1520 [
1521 'APR::Finfo',
1522 'APR::Finfo'
1523 ],
1524 [
1525 'Apache2::Command',
1526 'Apache2::Command'
1527 ],
1528 [
1529 'Apache2::FilterRec',
1530 'Apache2::FilterRec'
1531 ],
1532 [
1533 'Apache2::Module',
1534 'Apache2::Module'
1535 ]
1536 ],
1537 'names' => [
1538 [
1539 'Apache2::ServerRec',
1540 'Apache2::ServerRec'
1541 ]
1542 ],
1543 'new' => [
1544 [
1545 'APR::Brigade',
1546 'APR::Brigade'
1547 ],
1548 [
1549 'APR::Bucket',
1550 'APR::Bucket'
1551 ],
1552 [
1553 'APR::BucketAlloc',
1554 'APR::BucketAlloc'
1555 ],
1556 [
1557 'APR::IpSubnet',
1558 'APR::IpSubnet'
1559 ],
1560 [
1561 'APR::Pool',
1562 'APR::Pool'
1563 ],
1564 [
1565 'APR::ThreadMutex',
1566 'APR::ThreadMutex'
1567 ],
1568 [
1569 'APR::ThreadRWLock',
1570 'APR::ThreadRWLock'
1571 ],
1572 [
1573 'APR::UUID',
1574 'APR::UUID'
1575 ],
1576 [
1577 'Apache2::RequestUtil',
1578 'Apache2::RequestRec'
1579 ]
1580 ],
1581 'next' => [
1582 [
1583 'APR::Brigade',
1584 'APR::Brigade'
1585 ],
1586 [
1587 'Apache2::Command',
1588 'Apache2::Command'
1589 ],
1590 [
1591 'Apache2::Directive',
1592 'Apache2::Directive'
1593 ],
1594 [
1595 'Apache2::Filter',
1596 'Apache2::Filter'
1597 ],
1598 [
1599 'Apache2::Module',
1600 'Apache2::Module'
1601 ],
1602 [
1603 'Apache2::RequestRec',
1604 'Apache2::RequestRec'
1605 ],
1606 [
1607 'Apache2::ServerRec',
1608 'Apache2::ServerRec'
1609 ]
1610 ],
1611 'nlink' => [
1612 [
1613 'APR::Finfo',
1614 'APR::Finfo'
1615 ]
1616 ],
1617 'no_cache' => [
1618 [
1619 'Apache2::RequestUtil',
1620 'Apache2::RequestRec'
1621 ]
1622 ],
1623 'no_local_copy' => [
1624 [
1625 'Apache2::RequestRec',
1626 'Apache2::RequestRec'
1627 ]
1628 ],
1629 'note_auth_failure' => [
1630 [
1631 'Apache2::Access',
1632 'Apache2::RequestRec'
1633 ]
1634 ],
1635 'note_basic_auth_failure' => [
1636 [
1637 'Apache2::Access',
1638 'Apache2::RequestRec'
1639 ]
1640 ],
1641 'note_digest_auth_failure' => [
1642 [
1643 'Apache2::Access',
1644 'Apache2::RequestRec'
1645 ]
1646 ],
1647 'notes' => [
1648 [
1649 'Apache2::Connection',
1650 'Apache2::Connection'
1651 ],
1652 [
1653 'Apache2::RequestRec',
1654 'Apache2::RequestRec'
1655 ]
1656 ],
1657 'notice' => [
1658 [
1659 'Apache2::Log',
1660 undef
1661 ]
1662 ],
1663 'num_requests' => [
1664 [
1665 'ModPerl::Interpreter',
1666 'ModPerl::Interpreter'
1667 ]
1668 ],
1669 'opt_get' => [
1670 [
1671 'APR::Socket',
1672 'APR::Socket'
1673 ]
1674 ],
1675 'opt_set' => [
1676 [
1677 'APR::Socket',
1678 'APR::Socket'
1679 ]
1680 ],
1681 'output_filters' => [
1682 [
1683 'Apache2::Connection',
1684 'Apache2::Connection'
1685 ],
1686 [
1687 'Apache2::RequestRec',
1688 'Apache2::RequestRec'
1689 ]
1690 ],
1691 'overlap' => [
1692 [
1693 'APR::Table',
1694 'APR::Table'
1695 ]
1696 ],
1697 'overlay' => [
1698 [
1699 'APR::Table',
1700 'APR::Table'
1701 ]
1702 ],
1703 'override' => [
1704 [
1705 'Apache2::CmdParms',
1706 'Apache2::CmdParms'
1707 ]
1708 ],
1709 'override_opts' => [
1710 [
1711 'Apache2::CmdParms',
1712 'Apache2::CmdParms'
1713 ]
1714 ],
1715 'parent' => [
1716 [
1717 'Apache2::Directive',
1718 'Apache2::Directive'
1719 ],
1720 [
1721 'ModPerl::InterpPool',
1722 'ModPerl::InterpPool'
1723 ]
1724 ],
1725 'parent_get' => [
1726 [
1727 'APR::Pool',
1728 'APR::Pool'
1729 ]
1730 ],
1731 'parse' => [
1732 [
1733 'APR::URI',
1734 'APR::URI'
1735 ],
1736 [
1737 'APR::UUID',
1738 'APR::UUID'
1739 ]
1740 ],
1741 'parse_http' => [
1742 [
1743 'APR::Date',
1744 'APR::Date'
1745 ]
1746 ],
1747 'parse_rfc' => [
1748 [
1749 'APR::Date',
1750 'APR::Date'
1751 ]
1752 ],
1753 'parse_uri' => [
1754 [
1755 'Apache2::URI',
1756 'Apache2::RequestRec'
1757 ]
1758 ],
1759 'parsed_uri' => [
1760 [
1761 'Apache2::URI',
1762 'Apache2::RequestRec'
1763 ]
1764 ],
1765 'pass_brigade' => [
1766 [
1767 'Apache2::Filter',
1768 'Apache2::Filter'
1769 ]
1770 ],
1771 'password' => [
1772 [
1773 'APR::URI',
1774 'APR::URI'
1775 ]
1776 ],
1777 'password_get' => [
1778 [
1779 'APR::Util',
1780 'APR::Util'
1781 ]
1782 ],
1783 'password_validate' => [
1784 [
1785 'APR::Util',
1786 'APR::Util'
1787 ]
1788 ],
1789 'path' => [
1790 [
1791 'APR::URI',
1792 'APR::URI'
1793 ],
1794 [
1795 'Apache2::CmdParms',
1796 'Apache2::CmdParms'
1797 ],
1798 [
1799 'Apache2::ServerRec',
1800 'Apache2::ServerRec'
1801 ]
1802 ],
1803 'path_info' => [
1804 [
1805 'Apache2::RequestRec',
1806 'Apache2::RequestRec'
1807 ]
1808 ],
1809 'pconf' => [
1810 [
1811 'Apache2::Process',
1812 'Apache2::Process'
1813 ]
1814 ],
1815 'per_dir_config' => [
1816 [
1817 'Apache2::RequestRec',
1818 'Apache2::RequestRec'
1819 ]
1820 ],
1821 'perl' => [
1822 [
1823 'ModPerl::Interpreter',
1824 'ModPerl::Interpreter'
1825 ]
1826 ],
1827 'pnotes' => [
1828 [
1829 'Apache2::ConnectionUtil',
1830 'Apache2::Connection'
1831 ],
1832 [
1833 'Apache2::RequestUtil',
1834 'Apache2::RequestRec'
1835 ]
1836 ],
1837 'pnotes_kill' => [
1838 [
1839 'Apache2::ConnectionUtil',
1840 'Apache2::Connection'
1841 ],
1842 [
1843 'Apache2::RequestUtil',
1844 'Apache2::RequestRec'
1845 ]
1846 ],
1847 'poll' => [
1848 [
1849 'APR::Socket',
1850 'APR::Socket'
1851 ]
1852 ],
1853 'pool' => [
1854 [
1855 'APR::Brigade',
1856 'APR::Brigade'
1857 ],
1858 [
1859 'Apache2::CmdParms',
1860 'Apache2::CmdParms'
1861 ],
1862 [
1863 'Apache2::Connection',
1864 'Apache2::Connection'
1865 ],
1866 [
1867 'Apache2::Process',
1868 'Apache2::Process'
1869 ],
1870 [
1871 'Apache2::RequestRec',
1872 'Apache2::RequestRec'
1873 ]
1874 ],
1875 'pool_get' => [
1876 [
1877 'APR::ThreadMutex',
1878 'APR::ThreadMutex'
1879 ],
1880 [
1881 'APR::ThreadRWLock',
1882 'APR::ThreadRWLock'
1883 ]
1884 ],
1885 'port' => [
1886 [
1887 'APR::SockAddr',
1888 'APR::SockAddr'
1889 ],
1890 [
1891 'APR::URI',
1892 'APR::URI'
1893 ],
1894 [
1895 'Apache2::ServerRec',
1896 'Apache2::ServerRec'
1897 ]
1898 ],
1899 'port_of_scheme' => [
1900 [
1901 'APR::URI',
1902 'APR::URI'
1903 ]
1904 ],
1905 'prev' => [
1906 [
1907 'APR::Brigade',
1908 'APR::Brigade'
1909 ],
1910 [
1911 'Apache2::RequestRec',
1912 'Apache2::RequestRec'
1913 ]
1914 ],
1915 'print' => [
1916 [
1917 'Apache2::Filter',
1918 'Apache2::Filter'
1919 ],
1920 [
1921 'Apache2::RequestIO',
1922 'Apache2::RequestRec'
1923 ]
1924 ],
1925 'printf' => [
1926 [
1927 'Apache2::RequestIO',
1928 'Apache2::RequestRec'
1929 ]
1930 ],
1931 'process' => [
1932 [
1933 'Apache2::ServerRec',
1934 'Apache2::ServerRec'
1935 ]
1936 ],
1937 'protection' => [
1938 [
1939 'APR::Finfo',
1940 'APR::Finfo'
1941 ]
1942 ],
1943 'proto_input_filters' => [
1944 [
1945 'Apache2::RequestRec',
1946 'Apache2::RequestRec'
1947 ]
1948 ],
1949 'proto_num' => [
1950 [
1951 'Apache2::RequestRec',
1952 'Apache2::RequestRec'
1953 ]
1954 ],
1955 'proto_output_filters' => [
1956 [
1957 'Apache2::RequestRec',
1958 'Apache2::RequestRec'
1959 ]
1960 ],
1961 'protocol' => [
1962 [
1963 'Apache2::RequestRec',
1964 'Apache2::RequestRec'
1965 ]
1966 ],
1967 'proxyreq' => [
1968 [
1969 'Apache2::RequestRec',
1970 'Apache2::RequestRec'
1971 ]
1972 ],
1973 'psignature' => [
1974 [
1975 'Apache2::RequestUtil',
1976 'Apache2::RequestRec'
1977 ]
1978 ],
1979 'push_handlers' => [
1980 [
1981 'Apache2::RequestUtil',
1982 'Apache2::RequestRec'
1983 ],
1984 [
1985 'Apache2::ServerUtil',
1986 'Apache2::ServerRec'
1987 ]
1988 ],
1989 'puts' => [
1990 [
1991 'Apache2::RequestIO',
1992 'Apache2::RequestRec'
1993 ]
1994 ],
1995 'query' => [
1996 [
1997 'APR::URI',
1998 'APR::URI'
1999 ],
2000 [
2001 'Apache2::MPM',
2002 'Apache2::MPM'
2003 ]
2004 ],
2005 'r' => [
2006 [
2007 'Apache2::Filter',
2008 'Apache2::Filter'
2009 ]
2010 ],
2011 'rationalize_mtime' => [
2012 [
2013 'Apache2::Response',
2014 'Apache2::RequestRec'
2015 ]
2016 ],
2017 'rdlock' => [
2018 [
2019 'APR::ThreadRWLock',
2020 'APR::ThreadRWLock'
2021 ]
2022 ],
2023 'read' => [
2024 [
2025 'APR::Bucket',
2026 'APR::Bucket'
2027 ],
2028 [
2029 'Apache2::Filter',
2030 'Apache2::Filter'
2031 ],
2032 [
2033 'Apache2::RequestIO',
2034 'Apache2::RequestRec'
2035 ]
2036 ],
2037 'recv' => [
2038 [
2039 'APR::Socket',
2040 'APR::Socket'
2041 ]
2042 ],
2043 'recvfrom' => [
2044 [
2045 'APR::Socket',
2046 'APR::Socket'
2047 ]
2048 ],
2049 'refcnt' => [
2050 [
2051 'ModPerl::Interpreter',
2052 'ModPerl::Interpreter'
2053 ]
2054 ],
2055 'register_auth_provider' => [
2056 [
2057 'Apache2::RequestUtil',
2058 'Apache2::RequestUtil'
2059 ]
2060 ],
2061 'register_provider' => [
2062 [
2063 'Apache2::Provider',
2064 'Apache2::Provider'
2065 ]
2066 ],
2067 'remote_host' => [
2068 [
2069 'Apache2::Connection',
2070 'Apache2::Connection'
2071 ]
2072 ],
2073 'remove' => [
2074 [
2075 'APR::Bucket',
2076 'APR::Bucket'
2077 ],
2078 [
2079 'Apache2::Filter',
2080 'Apache2::Filter'
2081 ]
2082 ],
2083 'remove_loaded_module' => [
2084 [
2085 'Apache2::Module',
2086 'Apache2::Module'
2087 ]
2088 ],
2089 'req_override' => [
2090 [
2091 'Apache2::Command',
2092 'Apache2::Command'
2093 ]
2094 ],
2095 'request' => [
2096 [
2097 'Apache2::RequestUtil',
2098 'Apache2::RequestUtil'
2099 ]
2100 ],
2101 'request_config' => [
2102 [
2103 'Apache2::RequestRec',
2104 'Apache2::RequestRec'
2105 ]
2106 ],
2107 'request_time' => [
2108 [
2109 'Apache2::RequestRec',
2110 'Apache2::RequestRec'
2111 ]
2112 ],
2113 'restart_count' => [
2114 [
2115 'Apache2::ServerUtil',
2116 'Apache2::ServerUtil'
2117 ]
2118 ],
2119 'rflush' => [
2120 [
2121 'Apache2::RequestIO',
2122 'Apache2::RequestRec'
2123 ]
2124 ],
2125 'rpath' => [
2126 [
2127 'APR::URI',
2128 'APR::URI'
2129 ]
2130 ],
2131 'run' => [
2132 [
2133 'Apache2::SubRequest',
2134 'Apache2::SubRequest'
2135 ]
2136 ],
2137 'run_access_checker' => [
2138 [
2139 'Apache2::HookRun',
2140 'Apache2::RequestRec'
2141 ]
2142 ],
2143 'run_auth_checker' => [
2144 [
2145 'Apache2::HookRun',
2146 'Apache2::RequestRec'
2147 ]
2148 ],
2149 'run_check_user_id' => [
2150 [
2151 'Apache2::HookRun',
2152 'Apache2::RequestRec'
2153 ]
2154 ],
2155 'run_fixups' => [
2156 [
2157 'Apache2::HookRun',
2158 'Apache2::RequestRec'
2159 ]
2160 ],
2161 'run_handler' => [
2162 [
2163 'Apache2::HookRun',
2164 'Apache2::RequestRec'
2165 ]
2166 ],
2167 'run_header_parser' => [
2168 [
2169 'Apache2::HookRun',
2170 'Apache2::RequestRec'
2171 ]
2172 ],
2173 'run_log_transaction' => [
2174 [
2175 'Apache2::HookRun',
2176 'Apache2::RequestRec'
2177 ]
2178 ],
2179 'run_map_to_storage' => [
2180 [
2181 'Apache2::HookRun',
2182 'Apache2::RequestRec'
2183 ]
2184 ],
2185 'run_post_read_request' => [
2186 [
2187 'Apache2::HookRun',
2188 'Apache2::RequestRec'
2189 ]
2190 ],
2191 'run_translate_name' => [
2192 [
2193 'Apache2::HookRun',
2194 'Apache2::RequestRec'
2195 ]
2196 ],
2197 'run_type_checker' => [
2198 [
2199 'Apache2::HookRun',
2200 'Apache2::RequestRec'
2201 ]
2202 ],
2203 'satisfies' => [
2204 [
2205 'Apache2::Access',
2206 'Apache2::RequestRec'
2207 ]
2208 ],
2209 'sbh' => [
2210 [
2211 'Apache2::Connection',
2212 'Apache2::Connection'
2213 ]
2214 ],
2215 'scheme' => [
2216 [
2217 'APR::URI',
2218 'APR::URI'
2219 ]
2220 ],
2221 'seen_eos' => [
2222 [
2223 'Apache2::Filter',
2224 'Apache2::Filter'
2225 ]
2226 ],
2227 'send' => [
2228 [
2229 'APR::Socket',
2230 'APR::Socket'
2231 ]
2232 ],
2233 'send_cgi_header' => [
2234 [
2235 'Apache2::Response',
2236 'Apache2::RequestRec'
2237 ]
2238 ],
2239 'send_error_response' => [
2240 [
2241 'Apache2::Response',
2242 'Apache2::RequestRec'
2243 ]
2244 ],
2245 'send_mmap' => [
2246 [
2247 'Apache2::Response',
2248 'Apache2::RequestRec'
2249 ]
2250 ],
2251 'sendfile' => [
2252 [
2253 'Apache2::RequestIO',
2254 'Apache2::RequestRec'
2255 ]
2256 ],
2257 'sendto' => [
2258 [
2259 'APR::Socket',
2260 'APR::Socket'
2261 ]
2262 ],
2263 'server' => [
2264 [
2265 'Apache2::CmdParms',
2266 'Apache2::CmdParms'
2267 ],
2268 [
2269 'Apache2::RequestRec',
2270 'Apache2::RequestRec'
2271 ],
2272 [
2273 'Apache2::ServerUtil',
2274 'Apache2::ServerUtil'
2275 ],
2276 [
2277 'ModPerl::InterpPool',
2278 'ModPerl::InterpPool'
2279 ]
2280 ],
2281 'server_admin' => [
2282 [
2283 'Apache2::ServerRec',
2284 'Apache2::ServerRec'
2285 ]
2286 ],
2287 'server_hostname' => [
2288 [
2289 'Apache2::ServerRec',
2290 'Apache2::ServerRec'
2291 ]
2292 ],
2293 'server_root_relative' => [
2294 [
2295 'Apache2::ServerUtil',
2296 'Apache2::ServerUtil'
2297 ]
2298 ],
2299 'server_scheme' => [
2300 [
2301 'Apache2::ServerRec',
2302 'Apache2::ServerRec'
2303 ]
2304 ],
2305 'server_shutdown_cleanup_register' => [
2306 [
2307 'Apache2::ServerUtil',
2308 'Apache2::ServerUtil'
2309 ]
2310 ],
2311 'set' => [
2312 [
2313 'APR::Table',
2314 'APR::Table'
2315 ]
2316 ],
2317 'set_basic_credentials' => [
2318 [
2319 'Apache2::RequestUtil',
2320 'Apache2::RequestRec'
2321 ]
2322 ],
2323 'set_content_length' => [
2324 [
2325 'Apache2::Response',
2326 'Apache2::RequestRec'
2327 ]
2328 ],
2329 'set_etag' => [
2330 [
2331 'Apache2::Response',
2332 'Apache2::RequestRec'
2333 ]
2334 ],
2335 'set_handlers' => [
2336 [
2337 'Apache2::RequestUtil',
2338 'Apache2::RequestRec'
2339 ],
2340 [
2341 'Apache2::ServerUtil',
2342 'Apache2::ServerRec'
2343 ]
2344 ],
2345 'set_keepalive' => [
2346 [
2347 'Apache2::Response',
2348 'Apache2::RequestRec'
2349 ]
2350 ],
2351 'set_last_modified' => [
2352 [
2353 'Apache2::Response',
2354 'Apache2::RequestRec'
2355 ]
2356 ],
2357 'setaside' => [
2358 [
2359 'APR::Bucket',
2360 'APR::Bucket'
2361 ]
2362 ],
2363 'setup_client_block' => [
2364 [
2365 'Apache2::RequestIO',
2366 'Apache2::RequestRec'
2367 ]
2368 ],
2369 'short_name' => [
2370 [
2371 'Apache2::Process',
2372 'Apache2::Process'
2373 ]
2374 ],
2375 'should_client_block' => [
2376 [
2377 'Apache2::RequestIO',
2378 'Apache2::RequestRec'
2379 ]
2380 ],
2381 'size' => [
2382 [
2383 'APR::Finfo',
2384 'APR::Finfo'
2385 ],
2386 [
2387 'ModPerl::TiPool',
2388 'ModPerl::TiPool'
2389 ]
2390 ],
2391 'slurp_filename' => [
2392 [
2393 'Apache2::RequestUtil',
2394 'Apache2::RequestRec'
2395 ]
2396 ],
2397 'some_auth_required' => [
2398 [
2399 'Apache2::Access',
2400 'Apache2::RequestRec'
2401 ]
2402 ],
2403 'spawn_proc_prog' => [
2404 [
2405 'Apache2::SubProcess',
2406 undef
2407 ]
2408 ],
2409 'special_list_call' => [
2410 [
2411 'ModPerl::Global',
2412 'ModPerl::Global'
2413 ]
2414 ],
2415 'special_list_clear' => [
2416 [
2417 'ModPerl::Global',
2418 'ModPerl::Global'
2419 ]
2420 ],
2421 'special_list_register' => [
2422 [
2423 'ModPerl::Global',
2424 'ModPerl::Global'
2425 ]
2426 ],
2427 'split' => [
2428 [
2429 'APR::Brigade',
2430 'APR::Brigade'
2431 ]
2432 ],
2433 'start' => [
2434 [
2435 'APR::Bucket',
2436 'APR::Bucket'
2437 ],
2438 [
2439 'ModPerl::TiPoolConfig',
2440 'ModPerl::TiPoolConfig'
2441 ]
2442 ],
2443 'stat' => [
2444 [
2445 'APR::Finfo',
2446 'APR::Finfo'
2447 ]
2448 ],
2449 'status' => [
2450 [
2451 'Apache2::RequestRec',
2452 'Apache2::RequestRec'
2453 ]
2454 ],
2455 'status_line' => [
2456 [
2457 'Apache2::RequestRec',
2458 'Apache2::RequestRec'
2459 ]
2460 ],
2461 'strerror' => [
2462 [
2463 'APR::Error',
2464 'APR::Error'
2465 ]
2466 ],
2467 'subprocess_env' => [
2468 [
2469 'Apache2::RequestRec',
2470 'Apache2::RequestRec'
2471 ]
2472 ],
2473 'tag' => [
2474 [
2475 'APR::Pool',
2476 'APR::Pool'
2477 ]
2478 ],
2479 'temp_pool' => [
2480 [
2481 'Apache2::CmdParms',
2482 'Apache2::CmdParms'
2483 ]
2484 ],
2485 'test' => [
2486 [
2487 'APR::IpSubnet',
2488 'APR::IpSubnet'
2489 ]
2490 ],
2491 'the_request' => [
2492 [
2493 'Apache2::RequestRec',
2494 'Apache2::RequestRec'
2495 ]
2496 ],
2497 'timeout' => [
2498 [
2499 'Apache2::ServerRec',
2500 'Apache2::ServerRec'
2501 ]
2502 ],
2503 'timeout_get' => [
2504 [
2505 'APR::Socket',
2506 'APR::Socket'
2507 ]
2508 ],
2509 'timeout_set' => [
2510 [
2511 'APR::Socket',
2512 'APR::Socket'
2513 ]
2514 ],
2515 'tipool' => [
2516 [
2517 'ModPerl::InterpPool',
2518 'ModPerl::InterpPool'
2519 ]
2520 ],
2521 'top_module' => [
2522 [
2523 'Apache2::Module',
2524 'Apache2::Module'
2525 ]
2526 ],
2527 'trylock' => [
2528 [
2529 'APR::ThreadMutex',
2530 'APR::ThreadMutex'
2531 ]
2532 ],
2533 'tryrdlock' => [
2534 [
2535 'APR::ThreadRWLock',
2536 'APR::ThreadRWLock'
2537 ]
2538 ],
2539 'trywrlock' => [
2540 [
2541 'APR::ThreadRWLock',
2542 'APR::ThreadRWLock'
2543 ]
2544 ],
2545 'type' => [
2546 [
2547 'APR::Bucket',
2548 'APR::Bucket'
2549 ]
2550 ],
2551 'unescape_url' => [
2552 [
2553 'Apache2::URI',
2554 'Apache2::URI'
2555 ]
2556 ],
2557 'unload_package_xs' => [
2558 [
2559 'ModPerl::Util',
2560 'ModPerl::Util'
2561 ]
2562 ],
2563 'unlock' => [
2564 [
2565 'APR::ThreadMutex',
2566 'APR::ThreadMutex'
2567 ],
2568 [
2569 'APR::ThreadRWLock',
2570 'APR::ThreadRWLock'
2571 ]
2572 ],
2573 'unparse' => [
2574 [
2575 'APR::URI',
2576 'APR::URI'
2577 ]
2578 ],
2579 'unparsed_uri' => [
2580 [
2581 'Apache2::RequestRec',
2582 'Apache2::RequestRec'
2583 ]
2584 ],
2585 'unset' => [
2586 [
2587 'APR::Table',
2588 'APR::Table'
2589 ]
2590 ],
2591 'untaint' => [
2592 [
2593 'ModPerl::Util',
2594 'ModPerl::Util'
2595 ]
2596 ],
2597 'update_mtime' => [
2598 [
2599 'Apache2::Response',
2600 'Apache2::RequestRec'
2601 ]
2602 ],
2603 'uri' => [
2604 [
2605 'Apache2::RequestRec',
2606 'Apache2::RequestRec'
2607 ]
2608 ],
2609 'used_path_info' => [
2610 [
2611 'Apache2::RequestRec',
2612 'Apache2::RequestRec'
2613 ]
2614 ],
2615 'user' => [
2616 [
2617 'APR::Finfo',
2618 'APR::Finfo'
2619 ],
2620 [
2621 'APR::URI',
2622 'APR::URI'
2623 ],
2624 [
2625 'Apache2::RequestRec',
2626 'Apache2::RequestRec'
2627 ]
2628 ],
2629 'user_id' => [
2630 [
2631 'Apache2::ServerUtil',
2632 'Apache2::ServerUtil'
2633 ]
2634 ],
2635 'useragent_addr' => [
2636 [
2637 'Apache2::RequestRec',
2638 'Apache2::RequestRec'
2639 ]
2640 ],
2641 'useragent_ip' => [
2642 [
2643 'Apache2::RequestRec',
2644 'Apache2::RequestRec'
2645 ]
2646 ],
2647 'valid' => [
2648 [
2649 'APR::Finfo',
2650 'APR::Finfo'
2651 ]
2652 ],
2653 'warn' => [
2654 [
2655 'Apache2::Log',
2656 undef
2657 ],
2658 [
2659 'Apache2::Log',
2660 undef
2661 ],
2662 [
2663 'Apache2::Log',
2664 undef
2665 ]
2666 ],
2667 'wild_names' => [
2668 [
2669 'Apache2::ServerRec',
2670 'Apache2::ServerRec'
2671 ]
2672 ],
2673 'write' => [
2674 [
2675 'Apache2::RequestIO',
2676 'Apache2::RequestRec'
2677 ]
2678 ],
2679 'wrlock' => [
2680 [
2681 'APR::ThreadRWLock',
2682 'APR::ThreadRWLock'
2683 ]
2684 ]
2685 };
2686
2687
2688 use base qw(Exporter);
2689 use mod_perl2;
2690
2691 our @EXPORT = qw(print_method print_module print_object);
2692 our $VERSION = $mod_perl2::VERSION;
2693 use constant MODULE => 0;
2694 use constant OBJECT => 1;
2695
2696 my $modules;
2697 my $objects;
2698
2699 sub _get_modules {
2700 for my $method (sort keys %$methods) {
2701 for my $item ( @{ $methods->{$method} }) {
2702 push @{ $modules->{$item->[MODULE]} }, [$method, $item->[OBJECT]];
2703 }
2704 }
2705 }
2706
2707 sub _get_objects {
2708 for my $method (sort keys %$methods) {
2709 for my $item ( @{ $methods->{$method} }) {
2710 next unless defined $item->[OBJECT];
2711 push @{ $objects->{$item->[OBJECT]} }, [$method, $item->[MODULE]];
2712 }
2713 }
2714 }
2715
2716 # if there is only one replacement method in 2.0 API we can
2717 # automatically lookup it, up however if there are more than one
2718 # (e.g. new()), we need to use a fully qualified value here
2719 # of course the same if the package is not a mod_perl one.
2720 #
2721 # the first field represents the replacement method or undef if none
2722 # exists, the second field is for extra comments (e.g. when there is
2723 # no replacement method)
2724 my $methods_compat = {
2725 # Apache2::
2726 gensym => ['Symbol::gensym',
2727 'or use "open my $fh, $file"'],
2728 module => ['Apache2::Module::loaded',
2729 ''],
2730 define => ['exists_config_define',
2731 ''],
2732 httpd_conf => ['add_config',
2733 ''],
2734 SERVER_VERSION => ['get_server_version',
2735 ''],
2736 can_stack_handlers=> [undef,
2737 'there is no more need for that method in mp2'],
2738
2739 # Apache2::RequestRec
2740 soft_timeout => [undef,
2741 'there is no more need for that method in mp2'],
2742 hard_timeout => [undef,
2743 'there is no more need for that method in mp2'],
2744 kill_timeout => [undef,
2745 'there is no more need for that method in mp2'],
2746 reset_timeout => [undef,
2747 'there is no more need for that method in mp2'],
2748 cleanup_for_exec => [undef,
2749 'there is no more need for that method in mp2'],
2750 send_http_header => ['content_type',
2751 ''],
2752 header_in => ['headers_in',
2753 'this method works in mod_perl 1.0 too'],
2754 header_out => ['headers_out',
2755 'this method works in mod_perl 1.0 too'],
2756 err_header_out => ['err_headers_out',
2757 'this method works in mod_perl 1.0 too'],
2758 register_cleanup => ['cleanup_register',
2759 ''],
2760 post_connection => ['cleanup_register',
2761 ''],
2762 content => [undef, # XXX: Apache2::Request::what?
2763 'use CGI.pm or Apache2::Request instead'],
2764 clear_rgy_endav => ['special_list_clear',
2765 ''],
2766 stash_rgy_endav => [undef,
2767 ''],
2768 run_rgy_endav => ['special_list_call',
2769 'this method is no longer needed'],
2770 seqno => [undef,
2771 'internal to mod_perl 1.0'],
2772 chdir_file => [undef, # XXX: to be resolved
2773 'temporary unavailable till the issue with chdir' .
2774 ' in the threaded env is resolved'],
2775 log_reason => ['log_error',
2776 'not in the Apache 2.0 API'],
2777 READLINE => [undef, # XXX: to be resolved
2778 ''],
2779 send_fd_length => [undef,
2780 'not in the Apache 2.0 API'],
2781 send_fd => ['sendfile',
2782 'requires an offset argument'],
2783 is_main => ['main',
2784 'not in the Apache 2.0 API'],
2785 cgi_var => ['subprocess_env',
2786 'subprocess_env can be used with mod_perl 1.0'],
2787 cgi_env => ['subprocess_env',
2788 'subprocess_env can be used with mod_perl 1.0'],
2789 each_byterange => [undef,
2790 'now handled internally by ap_byterange_filter'],
2791 set_byterange => [undef,
2792 'now handled internally by ap_byterange_filter'],
2793
2794 # Apache::File
2795 open => [undef,
2796 ''],
2797 close => [undef, # XXX: also defined in APR::Socket
2798 ''],
2799 tmpfile => [undef,
2800 'not in the Apache 2.0 API, ' .
2801 'use File::Temp instead'],
2802
2803 # Apache::Util
2804 size_string => ['format_size',
2805 ''],
2806 escape_uri => ['unescape_path',
2807 ''],
2808 escape_url => ['escape_path',
2809 'and requires a pool object'],
2810 unescape_uri => ['unescape_url',
2811 ''],
2812 unescape_url_info => [undef,
2813 'use CGI::Util::unescape() instead'],
2814 escape_html => [undef, # XXX: will be ap_escape_html
2815 'ap_escape_html now requires a pool object'],
2816 parsedate => ['parse_http',
2817 ''],
2818 validate_password => ['password_validate',
2819 ''],
2820
2821 # Apache::Table
2822 #new => ['make',
2823 # ''], # XXX: there are other 'new' methods
2824
2825 # Apache::Connection
2826 auth_type => ['ap_auth_type',
2827 'now resides in the request object'],
2828 };
2829
2830 sub avail_methods_compat {
2831 return keys %$methods_compat;
2832 }
2833
2834 sub avail_methods {
2835 return keys %$methods;
2836 }
2837
2838 sub avail_modules {
2839 my %modules = ();
2840 for my $method (keys %$methods) {
2841 for my $item ( @{ $methods->{$method} }) {
2842 $modules{$item->[MODULE]}++;
2843 }
2844 }
2845 return keys %modules;
2846 }
2847
2848 sub preload_all_modules {
2849 _get_modules() unless $modules;
2850 eval "require $_" for sort keys %$modules;
2851 }
2852
2853 sub _print_func {
2854 my $func = shift;
2855 my @args = @_ ? @_ : @ARGV;
2856 no strict 'refs';
2857 print( ($func->($_))[0]) for @args;
2858 }
2859
2860 sub print_module { _print_func('lookup_module', @_) }
2861 sub print_object { _print_func('lookup_object', @_) }
2862
2863 sub print_method {
2864 my @args = @_ ? @_ : @ARGV;
2865 while (@args) {
2866 my $method = shift @args;
2867 my $object = (@args &&
2868 (ref($args[0]) || $args[0] =~ /^(Apache2|ModPerl|APR)/))
2869 ? shift @args
2870 : undef;
2871 print( (lookup_method($method, $object))[0]);
2872 }
2873 }
2874
2875 sub sep { return '-' x (shift() + 20) . "\n" }
2876
2877 # what modules contain the passed method.
2878 # an optional object or a reference to it can be passed to help
2879 # resolve situations where there is more than one module containing
2880 # the same method. Inheritance is supported.
2881 sub lookup_method {
2882 my ($method, $object) = @_;
2883
2884 unless (defined $method) {
2885 my $hint = "No 'method' argument was passed\n";
2886 return ($hint);
2887 }
2888
2889 # strip the package name for the fully qualified method
2890 $method =~ s/.+:://;
2891
2892 if (exists $methods_compat->{$method}) {
2893 my ($replacement, $comment) = @{$methods_compat->{$method}};
2894 my $hint = "'$method' is not a part of the mod_perl 2.0 API\n";
2895 $comment = length $comment ? " $comment\n" : "";
2896
2897 # some removed methods have no replacement
2898 return $hint . "$comment" unless defined $replacement;
2899
2900 $hint .= "use '$replacement' instead. $comment";
2901
2902 # if fully qualified don't look up its container
2903 return $hint if $replacement =~ /::/;
2904
2905 my ($modules_hint, @modules) = lookup_method($replacement, $object);
2906 return $hint . $modules_hint;
2907 }
2908 elsif (!exists $methods->{$method}) {
2909 my $hint = "Don't know anything about method '$method'\n";
2910 return ($hint);
2911 }
2912
2913 my @items = @{ $methods->{$method} };
2914 if (@items == 1) {
2915 my $module = $items[0]->[MODULE];
2916 my $hint = "To use method '$method' add:\n" . "\tuse $module ();\n";
2917 # we should really check that the method matches the object if
2918 # any was passed, but it may not always work
2919 return ($hint, $module);
2920 }
2921 else {
2922 if (defined $object) {
2923 my $class = ref $object || $object;
2924 for my $item (@items) {
2925 # real class or inheritance
2926 if ($class eq $item->[OBJECT] or
2927 (ref($object) && $object->isa($item->[OBJECT]))) {
2928 my $module = $item->[MODULE];
2929 my $hint = "To use method '$method' add:\n" .
2930 "\tuse $module ();\n";
2931 return ($hint, $module);
2932 }
2933 }
2934 # fall-through
2935 local $" = ", ";
2936 my @modules = map $_->[MODULE], @items;
2937 my $hint = "Several modules (@modules) contain method '$method' " .
2938 "but none of them matches class '$class';\n";
2939 return ($hint);
2940
2941 }
2942 else {
2943 my %modules = map { $_->[MODULE] => 1 } @items;
2944 # remove dups if any (e.g. $s->add_input_filter and
2945 # $r->add_input_filter are loaded by the same Apache2::Filter)
2946 my @modules = sort keys %modules;
2947 my $hint;
2948 if (@modules == 1) {
2949 $hint = "To use method '$method' add:\n\tuse $modules[0] ();\n";
2950 return ($hint, $modules[0]);
2951 }
2952 else {
2953 $hint = "There is more than one class with method '$method'\n" .
2954 "try one of:\n" . join '', map {"\tuse $_ ();\n"} @modules;
2955 return ($hint, @modules);
2956 }
2957 }
2958 }
2959 }
2960
2961 # what methods are contained in the passed module name
2962 sub lookup_module {
2963 my ($module) = shift;
2964
2965 unless (defined $module) {
2966 my $hint = "no 'module' argument was passed\n";
2967 return ($hint);
2968 }
2969
2970 _get_modules() unless $modules;
2971
2972 unless (exists $modules->{$module}) {
2973 my $hint = "don't know anything about module '$module'\n";
2974 return ($hint);
2975 }
2976
2977 my @methods;
2978 my $max_len = 6;
2979 for ( @{ $modules->{$module} } ) {
2980 $max_len = length $_->[0] if length $_->[0] > $max_len;
2981 push @methods, $_->[0];
2982 }
2983
2984 my $format = "%-${max_len}s %s\n";
2985 my $banner = sprintf($format, "Method", "Invoked on object type");
2986 my $hint = join '',
2987 ("\nModule '$module' contains the following XS methods:\n\n",
2988 $banner, sep(length($banner)),
2989 map( { sprintf $format, $_->[0], $_->[1]||'???'}
2990 @{ $modules->{$module} }),
2991 sep(length($banner)));
2992
2993 return ($hint, @methods);
2994 }
2995
2996 # what methods can be invoked on the passed object (or its reference)
2997 sub lookup_object {
2998 my ($object) = shift;
2999
3000 unless (defined $object) {
3001 my $hint = "no 'object' argument was passed\n";
3002 return ($hint);
3003 }
3004
3005 _get_objects() unless $objects;
3006
3007 # a real object was passed?
3008 $object = ref $object || $object;
3009
3010 unless (exists $objects->{$object}) {
3011 my $hint = "don't know anything about objects of type '$object'\n";
3012 return ($hint);
3013 }
3014
3015 my @methods;
3016 my $max_len = 6;
3017 for ( @{ $objects->{$object} } ) {
3018 $max_len = length $_->[0] if length $_->[0] > $max_len;
3019 push @methods, $_->[0];
3020 }
3021
3022 my $format = "%-${max_len}s %s\n";
3023 my $banner = sprintf($format, "Method", "Module");
3024 my $hint = join '',
3025 ("\nObjects of type '$object' can invoke the following XS methods:\n\n",
3026 $banner, sep(length($banner)),
3027 map({ sprintf $format, $_->[0], $_->[1]} @{ $objects->{$object} }),
3028 sep(length($banner)));
3029
3030 return ($hint, @methods);
3031
3032 }
3033
3034 1;
+12
-8
lib/ModPerl/WrapXS.pm less more
7373 my $self = shift;
7474 my $typemap = $self->typemap;
7575
76 for my $entry (@{ $self->function_list() }) {
76 for my $entry (sort { $a->{name} cmp $b->{name} } @{ $self->function_list() }) {
7777 my $func = $typemap->map_function($entry);
7878 #print "FAILED to map $entry->{name}\n" unless $func;
7979 next unless $func;
507507 my $str = "";
508508
509509 if (my $isa = $self->typemap->{function_map}->{isa}->{$module}) {
510 while (my ($sub, $base) = each %$isa) {
510 foreach my $sub (sort keys %$isa) {
511 my $base = $isa->{$sub};
511512 #XXX cannot set isa in the BOOT: section because XSLoader local-ises
512513 #ISA during bootstrap
513514 # $str .= qq{ av_push(get_av("$sub\::ISA", TRUE),
712713 my $self = shift;
713714
714715 my %map = ();
715 while (my ($module, $functions) = each %{ $self->{XS} }) {
716 foreach my $module (sort keys %{ $self->{XS} }) {
717 my $functions = $self->{XS}->{$module};
716718 my $last_prefix = "";
717719 for my $func (@$functions) {
718720 my $class = $func->{class};
936938
937939 sub preload_all_modules {
938940 _get_modules() unless $modules;
939 eval "require $_" for keys %$modules;
941 eval "require $_" for sort keys %$modules;
940942 }
941943
942944 sub _print_func {
10321034 my %modules = map { $_->[MODULE] => 1 } @items;
10331035 # remove dups if any (e.g. $s->add_input_filter and
10341036 # $r->add_input_filter are loaded by the same Apache2::Filter)
1035 my @modules = keys %modules;
1037 my @modules = sort keys %modules;
10361038 my $hint;
10371039 if (@modules == 1) {
10381040 $hint = "To use method '$method' add:\n\tuse $modules[0] ();\n";
11451147
11461148 require mod_perl2;
11471149 $len += length '$::VERSION';
1148 for (@modules) {
1150 for (sort @modules) {
11491151 my $ver = module_version($_);
11501152 printf $fh "package %s;\n%-${len}s = %s;\n\n",
11511153 $_, '$'.$_."::VERSION", $ver;
11721174 $self->write_export_file('exp') if Apache2::Build::AIX;
11731175 $self->write_export_file('def') if Apache2::Build::WIN32;
11741176
1175 while (my ($module, $functions) = each %{ $self->{XS} }) {
1177 foreach my $module (sort keys %{ $self->{XS} }) {
1178 my $functions = $self->{XS}->{$module};
11761179 # my ($root, $sub) = split '::', $module;
11771180 # if (-e "$self->{XS_DIR}/$root/$sub/$sub.xs") {
11781181 # $module = join '::', $root, "Wrap$sub";
13021305 my $header = \&{"export_file_header_$ext"};
13031306 my $format = \&{"export_file_format_$ext"};
13041307
1305 while (my ($key, $table) = each %files) {
1308 foreach my $key (sort keys %files) {
1309 my $table = $files{$key};
13061310 my $handles = $self->open_export_files($key, $ext);
13071311
13081312 my %seen; #only write header once if this is a single file
+86
-0
mod_perl.spec less more
0 %define _version 2.0.9
1 %define _release
2 %define _source http://apache.org/dist/perl/mod_perl-2.0.9-rc1.tar.gz
3 %define _dirname mod_perl-2.0.9-rc1
4 %define _httpd_min_ver 2.0.47
5 %define _perl_min_ver 5.6.1
6 Name: mod_perl
7 Version: %{_version}
8 Release: %{_release}
9 Summary: An embedded Perl interpreter for the Apache Web server
10 Group: System Environment/Daemons
11 License: Apache License, Version 2.0
12 Packager: mod_perl Development Team <dev@perl.apache.org>
13 URL: http://perl.apache.org/
14 Source: %{_source}
15 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
16 Requires: httpd >= %{_httpd_min_ver}
17 BuildRequires: perl >= %{_perl_min_ver}
18 BuildRequires: httpd-devel >= %{_httpd_min_ver}
19 BuildRequires: apr-devel, apr-util-devel
20
21 %description
22 Mod_perl incorporates a Perl interpreter into the Apache web server,
23 so that the Apache web server can directly execute Perl code.
24 Mod_perl links the Perl runtime library into the Apache web server and
25 provides an object-oriented Perl interface for Apache's C language
26 API. The end result is a quicker CGI script turnaround process, since
27 no external Perl interpreter has to be started.
28
29 Install mod_perl if you're installing the Apache web server and you'd
30 like for it to directly incorporate a Perl interpreter.
31
32 %package devel
33 Summary: Files needed for building XS modules that use mod_perl
34 Group: Development/Libraries
35 Requires: mod_perl = %{version}-%{release}, httpd-devel
36
37 %description devel
38 The mod_perl-devel package contains the files needed for building XS
39 modules that use mod_perl.
40
41 %prep
42 %setup -q -n %{_dirname}
43
44 %build
45 CFLAGS="$RPM_OPT_FLAGS" %{__perl} Makefile.PL </dev/null \
46 PREFIX=$RPM_BUILD_ROOT/usr \
47 INSTALLDIRS=vendor \
48 MP_APXS=%{_sbindir}/apxs
49 make %{?_smp_mflags} OPTIMIZE="$RPM_OPT_FLAGS"
50
51 %install
52 rm -rf $RPM_BUILD_ROOT
53 install -d -m 755 $RPM_BUILD_ROOT%{_libdir}/httpd/modules
54 make install \
55 MODPERL_AP_LIBEXECDIR=$RPM_BUILD_ROOT%{_libdir}/httpd/modules \
56 MODPERL_AP_INCLUDEDIR=$RPM_BUILD_ROOT%{_includedir}/httpd
57
58 # Remove the temporary files.
59 find $RPM_BUILD_ROOT -type f -name .packlist -exec rm -f {} ';'
60 find $RPM_BUILD_ROOT -type f -name perllocal.pod -exec rm -f {} ';'
61 find $RPM_BUILD_ROOT -type f -name '*.bs' -a -size 0 -exec rm -f {} ';'
62 find $RPM_BUILD_ROOT -type d -depth -exec rmdir {} 2>/dev/null ';'
63
64 %clean
65 rm -rf $RPM_BUILD_ROOT
66
67 %files
68 %defattr(-,root,root,-)
69 %doc Changes LICENSE README* STATUS SVN-MOVE docs/
70 %{_bindir}/*
71 %{_libdir}/httpd/modules/mod_perl.so
72 %{perl_vendorarch}/auto/*
73 %{perl_vendorarch}/Apache/
74 %{perl_vendorarch}/Apache2/
75 %{perl_vendorarch}/Bundle/
76 %{perl_vendorarch}/APR/
77 %{perl_vendorarch}/ModPerl/
78 %{perl_vendorarch}/*.pm
79 %{_mandir}/man?/*
80
81 %files devel
82 %defattr(-,root,root,-)
83 %{_includedir}/httpd/*
84
85 %changelog
+0
-16
patches/c-scan.pat less more
0 --- Scan.pm~ Thu Mar 23 06:14:18 2000
1 +++ Scan.pm Sun Jan 7 11:56:04 2001
2 @@ -400,7 +400,12 @@
3 } else {
4 $vars = parse_vars($chunk);
5 }
6 - push @$struct, @$vars;
7 + if ($vars) {
8 + push @$struct, @$vars;
9 + }
10 + else {
11 + warn "unable to parse chunk: `$chunk'" if $C::Scan::Warn;
12 + }
13 }
14 $structs->{$structname} = $struct;
15 $structname;
+0
-46
patches/link-hack.pat less more
0 Index: src/build/program.mk
1 ===================================================================
2 RCS file: /home/cvs/apache-2.0/src/build/program.mk,v
3 retrieving revision 1.3
4 diff -u -u -r1.3 program.mk
5 --- src/build/program.mk 2000/03/31 07:02:31 1.3
6 +++ src/build/program.mk 2000/04/16 23:43:14
7 @@ -54,7 +54,10 @@
8 # The build environment was provided by Sascha Schumann.
9 #
10
11 +MP_SRC = ../../modperl-2.0/src/modules/perl
12 +MP_LDADD = $(MP_SRC)/libmodperl.a `$(MP_SRC)/ldopts`
13 +
14 PROGRAM_OBJECTS = $(PROGRAM_SOURCES:.c=.lo)
15
16 $(PROGRAM_NAME): $(PROGRAM_DEPENDENCIES) $(PROGRAM_OBJECTS)
17 - $(LINK) $(PROGRAM_LDFLAGS) $(PROGRAM_OBJECTS) $(PROGRAM_LDADD)
18 + $(LINK) $(PROGRAM_LDFLAGS) $(PROGRAM_OBJECTS) $(PROGRAM_LDADD) $(MP_LDADD)
19
20 --- src/modules.c~ Wed Apr 12 20:00:23 2000
21 +++ src/modules.c Wed Apr 12 20:10:16 2000
22 @@ -26,6 +26,7 @@
23 extern module auth_module;
24 extern module setenvif_module;
25 extern module echo_module;
26 +extern module perl_module;
27
28 /*
29 * Modules which implicitly form the
30 @@ -54,6 +55,7 @@
31 &auth_module,
32 &setenvif_module,
33 &echo_module,
34 + &perl_module,
35 NULL
36 };
37
38 @@ -84,6 +86,7 @@
39 &auth_module,
40 &setenvif_module,
41 &echo_module,
42 + &perl_module,
43 NULL
44 };
45
+2
-0
src/modules/perl/modperl_common_log.c less more
5252 http://apr.apache.org/docs/apr/1.4/group__apr__lib.html#gad2cd3594aeaafd45931d1034965f48c1
5353 */
5454
55 #ifndef MP_IN_XS
5556 /* PERL_GET_CONTEXT yields nonsense until the first interpreter is
5657 * created. Hence the modperl_is_running() question. */
5758 if (modperl_threaded_mpm()) {
7677 apr_file_printf(logfile, "[pid=%lu] ", (unsigned long)getpid());
7778 #endif
7879 }
80 #endif
7981
8082 if (func && *func) {
8183 apr_file_printf(logfile, "%s: ", func);
+11
-4
src/modules/perl/modperl_interp.c less more
272272 modperl_interp_t *interp = (modperl_interp_t *)data;
273273 modperl_interp_pool_t *mip = interp->mip;
274274
275 MP_ASSERT(interp && MpInterpIN_USE(interp));
275 MP_ASSERT(interp && MpInterpIN_USE(interp) && interp->refcnt > 0);
276276 MP_TRACE_i(MP_FUNC, "unselect(interp=%pp): refcnt=%d",
277277 interp, interp->refcnt);
278278
279 if (interp->refcnt > 1) {
280 --interp->refcnt;
279 --interp->refcnt;
280
281 if (interp->refcnt > 0) {
281282 MP_TRACE_i(MP_FUNC, "interp=0x%lx, refcnt=%d -- interp still in use",
282283 (unsigned long)interp, interp->refcnt);
284 return APR_SUCCESS;
285 }
286
287 if (!MpInterpIN_USE(interp)){
288 MP_TRACE_i(MP_FUNC, "interp=0x%pp, refcnt=%d -- interp already not in use",
289 interp, interp->refcnt);
283290 return APR_SUCCESS;
284291 }
285292
452459 interp = modperl_interp_get(s);
453460 MP_TRACE_i(MP_FUNC, " --> got %pp (perl=%pp)", interp, interp->perl);
454461 ++interp->num_requests; /* should only get here once per request */
455 interp->refcnt = 0;
462 interp->refcnt = 1;
456463
457464 /* set context (THX) for this thread */
458465 PERL_SET_CONTEXT(interp->perl);
+2
-0
src/modules/perl/modperl_interp.h less more
6262 aTHX = interp->perl; \
6363 } \
6464 else { \
65 aTHX = NULL; \
6566 MP_TRACE_i(MP_FUNC, " --> failed"); \
6667 } \
6768 NOOP
7980 aTHX = interp->perl; \
8081 } \
8182 else { \
83 aTHX = NULL; \
8284 MP_TRACE_i(MP_FUNC, " --> failed"); \
8385 } \
8486 NOOP
+1
-1
src/modules/perl/modperl_perl_includes.h less more
7878 /* avoiding -Wall warning */
7979
8080 #undef dNOOP
81 #define dNOOP extern int __attribute__ ((unused)) Perl___notused
81 #define dNOOP extern int __attribute__ ((unused)) Perl___notused___modperl
8282
8383 #ifndef G_METHOD
8484 # define G_METHOD 64
+1
-1
src/modules/perl/modperl_util.c less more
889889 U16 *modperl_code_attrs(pTHX_ CV *cv) {
890890 MAGIC *mg;
891891
892 if (!SvMAGICAL(cv)) {
892 if (!(SvMAGICAL(cv) && (mg = mg_find((SV*)cv, PERL_MAGIC_ext)))) {
893893 sv_magic((SV*)cv, (SV *)NULL, PERL_MAGIC_ext, NULL, -1);
894894 }
895895
+2
-1
t/api/access2.t less more
77
88 if (!have_min_apache_version("2.4.0")) {
99
10 plan tests => 6, need need_lwp, need_auth, need_access, 'HTML::HeadParser';
10 plan tests => 6, need need_lwp, need_auth, need_access, 'mod_version.c',
11 'HTML::HeadParser';
1112
1213 my $location = "/TestAPI__access2";
1314
+2
-1
t/api/access2_24.t less more
66
77 if (have_min_apache_version("2.4.0")) {
88
9 plan tests => 6, need need_lwp, need_auth, need_access, 'HTML::HeadParser';
9 plan tests => 6, need need_lwp, need_auth, need_access, 'mod_version.c',
10 'HTML::HeadParser';
1011
1112 my $location = "/TestAPI__access2";
1213
+0
-242
t/apr-ext/perlio.t less more
0 #!perl -T
1 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
2
3 use strict;
4 use warnings FATAL => 'all';
5
6 # XXX: this is pretty much the same test as
7 # t/response/TestAPR/perlio.pm, but used outside mod_perl
8 # consider avoiding the code duplication.
9
10 use Apache::Test;
11 use Apache::TestUtil;
12 use Apache2::Build ();
13
14 use Fcntl ();
15 use File::Spec::Functions qw(catfile);
16
17 #XXX: APR::LARGE_FILES_CONFLICT constant?
18 #XXX: you can set to zero if largefile support is not enabled in Perl
19 use constant LARGE_FILES_CONFLICT => 1;
20
21 my $build = Apache2::Build->build_config;
22
23 # XXX: only when apr-config is found APR will be linked against
24 # libapr/libaprutil, probably need a more intuitive method for this
25 # prerequisite
26 # also need to check whether we build against the source tree, in
27 # which case we APR.so won't be linked against libapr/libaprutil
28 my $has_apr_config = $build->{apr_config_path} &&
29 !$build->httpd_is_source_tree;
30
31 my $has_perlio_layers = 0;
32 if ($has_apr_config) {
33 require APR;
34 require APR::PerlIO;
35 $has_perlio_layers = 1 if APR::PerlIO::PERLIO_LAYERS_ARE_ENABLED();
36 }
37
38 my $tests = 12;
39 my $lfs_tests = 3;
40
41 $tests += $lfs_tests unless LARGE_FILES_CONFLICT;
42 require APR; require APR::PerlIO;
43 plan tests => $tests,
44 need {"this build couldn't find apr-config" => $has_apr_config,
45 "this build doesn't support PerlIO layers" => $has_perlio_layers,
46 };
47
48 require APR::Pool;
49
50 my $pool = APR::Pool->new();
51
52 my $vars = Apache::Test::config()->{vars};
53 my $dir = catfile $vars->{documentroot}, "perlio-ext";
54
55 t_mkdir($dir);
56
57 my $sep = "-- sep --\n";
58 my @lines = ("This is a test: $$\n", "test line --sep two\n");
59
60 my $expected = $lines[0];
61 my $expected_all = join $sep, @lines;
62
63 # write file
64 my $file = catfile $dir, "test";
65 t_debug "open file $file for writing";
66 my $foo = "bar";
67 open my $fh, ">:APR", $file, $pool
68 or die "Cannot open $file for writing: $!";
69 ok ref($fh) eq 'GLOB';
70
71 t_debug "write to a file:\n$expected\n";
72 print $fh $expected_all;
73 close $fh;
74
75 # open() failure test
76 {
77 # workaround for locale setups where the error message may be
78 # in a different language
79 open my $fh, "perlio_this_file_cannot_exist";
80 my $errno_string = "$!";
81
82 # non-existent file
83 my $file = "/this/file/does/not/exist";
84 if (open my $fh, "<:APR", $file, $pool) {
85 t_debug "must not be able to open $file!";
86 ok 0;
87 close $fh;
88 } else {
89 ok t_cmp("$!",
90 $errno_string,
91 "expected failure");
92 }
93 }
94
95 # seek/tell() tests
96 unless (LARGE_FILES_CONFLICT) {
97 open my $fh, "<:APR", $file, $pool
98 or die "Cannot open $file for reading: $!";
99
100 # read the whole file so we can test the buffer flushed
101 # correctly on seek.
102 my $dummy = join '', <$fh>;
103
104 # Fcntl::SEEK_SET()
105 my $pos = 3; # rewinds after reading 6 chars above
106 seek $fh, $pos, Fcntl::SEEK_SET();
107 my $got = tell($fh);
108 ok t_cmp($got,
109 $pos,
110 "seek/tell the file Fcntl::SEEK_SET");
111
112 # Fcntl::SEEK_CUR()
113 my $step = 10;
114 $pos = tell($fh) + $step;
115 seek $fh, $step, Fcntl::SEEK_CUR();
116 $got = tell($fh);
117 ok t_cmp($got,
118 $pos,
119 "seek/tell the file Fcntl::SEEK_CUR");
120
121 # Fcntl::SEEK_END()
122 $pos = -s $file;
123 seek $fh, 0, Fcntl::SEEK_END();
124 $got = tell($fh);
125 ok t_cmp($got,
126 $pos,
127 "seek/tell the file Fcntl::SEEK_END");
128
129 close $fh;
130 }
131
132 # read() tests
133 {
134 open my $fh, "<:APR", $file, $pool
135 or die "Cannot open $file for reading: $!";
136
137 # basic open test
138 ok ref($fh) eq 'GLOB';
139
140 # basic single line read
141 ok t_cmp(scalar(<$fh>),
142 $expected,
143 "single line read");
144
145 # slurp mode
146 seek $fh, 0, Fcntl::SEEK_SET(); # rewind to the start
147 local $/;
148 ok t_cmp(scalar(<$fh>),
149 $expected_all,
150 "slurp file");
151
152 # test ungetc (a long sep requires read ahead)
153 seek $fh, 0, Fcntl::SEEK_SET(); # rewind to the start
154 local $/ = $sep;
155 my @got_lines = <$fh>;
156 my @expect = ($lines[0] . $sep, $lines[1]);
157 ok t_cmp(\@got_lines,
158 \@expect,
159 "custom complex input record sep read");
160
161 close $fh;
162 }
163
164
165 # eof() tests
166 {
167 open my $fh, "<:APR", $file, $pool
168 or die "Cannot open $file for reading: $!";
169
170 ok t_cmp(0,
171 int eof($fh), # returns false, not 0
172 "not end of file");
173 # go to the end and read so eof will return 1
174 seek $fh, 0, Fcntl::SEEK_END();
175 my $received = <$fh>;
176
177 t_debug($received);
178
179 ok t_cmp(eof($fh),
180 1,
181 "end of file");
182 close $fh;
183 }
184
185 # dup() test
186 {
187 open my $fh, "<:APR", $file, $pool
188 or die "Cannot open $file for reading: $!";
189
190 open my $dup_fh, "<&:APR", $fh
191 or die "Cannot dup $file for reading: $!";
192 close $fh;
193 ok ref($dup_fh) eq 'GLOB';
194
195 my $received = <$dup_fh>;
196
197 close $dup_fh;
198 ok t_cmp($received,
199 $expected,
200 "read/write a dupped file");
201 }
202
203 # unbuffered write
204 {
205 open my $wfh, ">:APR", $file, $pool
206 or die "Cannot open $file for writing: $!";
207 open my $rfh, "<:APR", $file, $pool
208 or die "Cannot open $file for reading: $!";
209
210 my $expected = "This is an un buffering write test";
211 # unbuffer
212 my $oldfh = select($wfh); $| = 1; select($oldfh);
213 print $wfh $expected; # must be flushed to disk immediately
214
215 ok t_cmp(scalar(<$rfh>),
216 $expected,
217 "file unbuffered write");
218
219 # buffer up
220 $oldfh = select($wfh); $| = 0; select($oldfh);
221 print $wfh $expected; # should be buffered up and not flushed
222
223 ok t_cmp(scalar(<$rfh>),
224 undef,
225 "file buffered write");
226
227 close $wfh;
228 close $rfh;
229
230 }
231
232
233 # XXX: need tests
234 # - for stdin/out/err as they are handled specially
235
236 # XXX: tmpfile is missing:
237 # consider to use 5.8's syntax:
238 # open $fh, "+>", undef;
239
240 # cleanup: t_mkdir will remove the whole tree including the file
241
+1
-1
t/hooks/authen_digest.t less more
55 use Apache::TestRequest;
66 use Apache::TestUtil;
77
8 plan tests => 7, need need_lwp, need_auth, 'HTML::HeadParser';
8 plan tests => 7, need need_lwp, 'auth_digest', 'HTML::HeadParser';
99
1010 my $location = '/TestHooks__authen_digest';
1111
+0
-0
t/htdocs/includes-registry/cgipm.pl less more
(No changes)
+0
-0
t/htdocs/includes-registry/test.pl less more
(No changes)
+0
-0
t/htdocs/includes-registry/test.spl less more
(No changes)
+0
-17
t/perl/ithreads.t less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 # perl/ithreads2 is a similar test but is running from within a
2 # virtual host with its own perl interpreter pool (+Parent)
3
4 use Config;
5
6 use Apache::Test;
7 use Apache::TestRequest 'GET_BODY_ASSERT';
8
9 # perl < 5.6.0 fails to compile code with 'shared' attributes, so we must skip
10 # it here.
11 unless ($] >= 5.008001 && $Config{useithreads}) {
12 plan tests => 1, need
13 {"perl 5.8.1 or higher w/ithreads enabled is required" => 0};
14 }
15
16 print GET_BODY_ASSERT "/TestPerl__ithreads";
+0
-26
t/perl/ithreads2.t less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 # perl/ithreads is a similar test but is running from the global perl
2 # interpreter pool. whereas this test is running against a
3 # virtual host with its own perl interpreter pool (+Parent)
4
5 use strict;
6 use warnings FATAL => 'all';
7
8 use Config;
9
10 use Apache::Test;
11 use Apache::TestUtil;
12 use Apache::TestRequest 'GET_BODY_ASSERT';
13
14 # perl < 5.6.0 fails to compile code with 'shared' attributes, so we must skip
15 # it here.
16 unless ($] >= 5.008001 && $Config{useithreads}) {
17 plan tests => 1, need
18 {"perl 5.8.1 or higher w/ithreads enabled is required" => 0};
19 }
20
21 my $module = 'TestPerl::ithreads';
22 my $url = Apache::TestRequest::module2url($module);
23
24 t_debug("connecting to $url");
25 print GET_BODY_ASSERT $url;
+0
-36
t/perl/ithreads3.t less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 use strict;
2 use warnings FATAL => 'all';
3
4 use Apache::Test;
5 use Apache::TestUtil;
6 use Apache::TestRequest 'GET_BODY';
7
8 plan tests => 6, need_apache_mpm('worker') && need_perl('ithreads');
9
10 my $module = 'TestPerl::ithreads3';
11
12 sub u {Apache::TestRequest::module2url($module, {path=>$_[0]})}
13 sub t {
14 my $rc;
15 eval {
16 local $SIG{ALRM}=sub {die "Timeout\n"};
17 alarm 2;
18 eval {
19 $rc=GET_BODY u(shift);
20 };
21 alarm 0;
22 };
23 alarm 0;
24 return $rc;
25 }
26
27 t_debug("connecting to ".u(''));
28 ok t_cmp t('/perl-script?1'), 2, 'perl-script 1';
29 ok t_cmp t('/modperl?1'), 2, 'modperl 1';
30
31 ok t_cmp t('/perl-script?2'), 5, 'perl-script 2';
32 ok t_cmp t('/modperl?2'), 5, 'modperl 2';
33
34 ok t_cmp t('/perl-script?3'), 3, 'perl-script 3';
35 ok t_cmp t('/modperl?3'), 3, 'modperl 3';
+0
-47
t/protocol/TestProtocol/eliza.pm less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 package TestProtocol::eliza;
2
3 use strict;
4 use warnings FATAL => 'all';
5
6 use Apache2::Connection ();
7 use APR::Socket ();
8
9 require Chatbot::Eliza;
10
11 use Apache2::Const -compile => 'OK';
12 use APR::Const -compile => 'SO_NONBLOCK';
13
14 use constant BUFF_LEN => 1024;
15
16 my $mybot = new Chatbot::Eliza;
17
18 sub handler {
19 my Apache2::Connection $c = shift;
20 my APR::Socket $socket = $c->client_socket;
21
22 # starting from Apache 2.0.49 several platforms require you to set
23 # the socket to a blocking IO mode
24 my $nonblocking = $socket->opt_get(APR::Const::SO_NONBLOCK);
25 if ($nonblocking) {
26 $socket->opt_set(APR::Const::SO_NONBLOCK, 0);
27
28 # test that we really *are* in the blocking mode
29 !$socket->opt_get(APR::Const::SO_NONBLOCK)
30 or die "failed to set blocking mode";
31 }
32
33 my $last = 0;
34 while ($socket->recv(my $buff, BUFF_LEN)) {
35 # \r is sent instead of \n if the client is talking over telnet
36 $buff =~ s/[\r\n]*$//;
37 $last++ if $buff eq "Good bye, Eliza";
38 $buff = $mybot->transform( $buff ) . "\n";
39 $socket->send($buff);
40 last if $last;
41 }
42
43 Apache2::Const::OK;
44 }
45
46 1;
+0
-34
t/protocol/eliza.t less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 use strict;
2 use warnings FATAL => 'all';
3
4 use Apache::Test;
5 use Apache::TestUtil;
6 use Apache::TestRequest ();
7
8 my @test_strings = ('Hello Eliza',
9 'How are you?',
10 'Why do I have core dumped?',
11 'I feel like writing some tests today, what about you?',
12 'Good bye, Eliza');
13
14 plan tests => 2 + @test_strings, need_module 'Chatbot::Eliza';
15
16 my $socket = Apache::TestRequest::vhost_socket('TestProtocol::eliza');
17
18 ok $socket;
19
20 for (@test_strings) {
21 print $socket "$_\n";
22 chomp(my $reply = <$socket> || '');
23 t_debug "send: $_";
24 t_debug "recv: $reply";
25 ok $reply;
26 }
27
28 # at this point 'Good bye, Eliza' should abort the connection.
29 my $string = 'Eliza should not hear this';
30 print $socket "$string\n";
31 chomp(my $reply = <$socket> || '');
32 t_debug "Eliza shouldn't respond anymore";
33 ok !$reply;
+0
-2
t/response/TestAPI/access2.pm less more
4444
4545 sub handler {
4646 my $r = shift;
47 print 'xxxxx\n';
4847 die '$r->some_auth_required failed' unless $r->some_auth_required;
49
5048
5149 my $satisfies = $r->satisfies;
5250 die "wanted satisfies=" . Apache2::Const::SATISFY_ALL . ", got $satisfies"
+0
-103
t/response/TestPerl/ithreads.pm less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 package TestPerl::ithreads;
2
3 use strict;
4 use warnings FATAL => 'all';
5
6 use Apache::Test;
7 use Apache::TestUtil;
8 use Apache::TestTrace;
9
10 use Apache2::Const -compile => 'OK';
11
12 # XXX: at this moment ithreads can be used only with 5.8.1. However
13 # once ithreads will be available on CPAN, we will need to change the
14 # check for perl 5.8.0 and this certain version of ithreads (here and
15 # in t/conf/post_config_startup.pl
16
17 sub handler {
18 my $r = shift;
19
20 plan $r, tests => 4, need
21 need_threads,
22 {"perl >= 5.8.1 is required (this is $])" => ($] >= 5.008001)};
23
24 # threads must have been preloaded at the server startup for this
25 # test (this is done at t/conf/post_config_startup.pl)
26 require threads;
27 threads->import();
28
29 # sky: the more modules are loaded, the slower new ithreads start
30 # because more things need to be cloned
31 debug '%INC size: ' . scalar(keys %INC) . "\n";
32
33 {
34 my $tid = threads->self->tid;
35 debug "1st TID is $tid" if defined $tid;
36 ok defined $tid;
37 }
38
39 {
40 my $thr = threads->new(sub {
41 my $tid = threads->self->tid;
42 debug "2nd TID is $tid" if defined $tid;
43 return 2;
44 });
45 ok t_cmp($thr->join, 2, "thread callback returned value");
46 }
47
48 {
49 require threads::shared;
50 my $counter_priv = 1;
51 my $counter_shar : shared = 1;
52
53 my $thr = threads->new(sub {
54 my $tid = threads->self->tid;
55 debug "2nd TID is $tid" if defined $tid;
56 $counter_priv += $counter_priv for 1..10;
57 {
58 lock $counter_shar;
59 $counter_shar += $counter_shar for 1..10;
60 }
61 });
62
63 $counter_priv += $counter_priv for 1..10;
64 {
65 lock $counter_shar;
66 $counter_shar += $counter_shar for 1..10;
67 }
68
69 $thr->join;
70 ok t_cmp($counter_shar, 2**20, "shared counter");
71 ok t_cmp($counter_priv, 2**10, "private counter");
72 }
73
74 Apache2::Const::OK;
75 }
76
77 1;
78
79 __END__
80 # APACHE_TEST_CONFIG_ORDER 941
81
82 <VirtualHost TestPerl::ithreads>
83
84 <IfDefine PERL_USEITHREADS>
85 # a new interpreter pool
86 PerlOptions +Parent
87 PerlInterpStart 1
88 PerlInterpMax 1
89 PerlInterpMinSpare 1
90 PerlInterpMaxSpare 1
91 </IfDefine>
92
93 # use test system's @INC
94 PerlSwitches -I@serverroot@
95 PerlRequire "conf/modperl_inc.pl"
96
97 <Location /TestPerl__ithreads>
98 SetHandler modperl
99 PerlResponseHandler TestPerl::ithreads
100 </Location>
101
102 </VirtualHost>
+0
-109
t/response/TestPerl/ithreads3.pm less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 package TestPerl::ithreads3;
2
3 use strict;
4 use warnings FATAL => 'all';
5
6 use Apache2::RequestRec;
7 use Apache2::RequestIO;
8 use Apache2::RequestUtil;
9 use APR::Pool;
10 use Apache2::Const -compile => 'OK', 'DECLINED';
11
12 # XXX: These tests rely on the assumption that the virtual host is not
13 # otherwise accessed. In this case the same interpreter is chosen
14 # for each phase. The $counter counts them.
15 # Of course if only 1 interp is configured it must be hit each time.
16
17 my $counter=0;
18
19 sub response {
20 my $r=shift;
21 $r->content_type('text/plain');
22 $r->print($counter);
23 return Apache2::Const::OK;
24 }
25
26 sub count { $counter++; return Apache2::Const::DECLINED; }
27
28 sub clear_pool {
29 delete $_[0]->pnotes->{my_pool};
30 return Apache2::Const::DECLINED;
31 }
32
33 sub trans {
34 my $r=shift;
35 my $test=$r->args;
36 $counter=0;
37 if( $test eq '1' ) {
38 # this is to check for a bug in modperl_response_handler versus
39 # modperl_response_handler_cgi. The former used to allocate an
40 # extra interpreter for its work. In both cases $counter should be
41 # 2 in the response phase
42 $r->push_handlers( PerlMapToStorageHandler=>__PACKAGE__.'::count' );
43 $r->push_handlers( PerlFixupHandler=>__PACKAGE__.'::count' );
44 }
45 elsif( $test eq '2' ) {
46 # now add an extra PerlCleanupHandler. It is run each time the
47 # interp is released. So it is run after Trans, MapToStorage and
48 # Fixup. In the response phase $counter should be 5. After Response
49 # it is run again but that is after.
50 # This used to eat up all interpreters because modperl_interp_unselect
51 # calls modperl_config_request_cleanup that allocates a new interp
52 # to handle the cleanup. When this interp is then unselected
53 # modperl_interp_unselect gets called again but the cleanup handler is
54 # still installed. So the cycle starts again until all interpreters
55 # are in use or the stack runs out. Then the thread is locked infinitely
56 # or a segfault appears.
57 $r->push_handlers( PerlMapToStorageHandler=>__PACKAGE__.'::count' );
58 $r->push_handlers( PerlFixupHandler=>__PACKAGE__.'::count' );
59 $r->push_handlers( PerlCleanupHandler=>__PACKAGE__.'::count' );
60 }
61 elsif( $test eq '3' ) {
62 # a subpool adds an extra reference to the interp. So it is preserved
63 # and bound to the request until the pool is destroyed. So the cleanup
64 # handler is run only once after Fixup. Hence the counter is 3.
65 $r->push_handlers( PerlMapToStorageHandler=>__PACKAGE__.'::count' );
66 $r->push_handlers( PerlFixupHandler=>__PACKAGE__.'::count' );
67 $r->push_handlers( PerlCleanupHandler=>__PACKAGE__.'::count' );
68 $r->pnotes->{my_pool}=$r->pool->new;
69 $r->push_handlers( PerlFixupHandler=>__PACKAGE__.'::clear_pool' );
70 }
71 return Apache2::Const::DECLINED;
72 }
73
74 1;
75
76 __END__
77 # APACHE_TEST_CONFIG_ORDER 942
78
79 <VirtualHost TestPerl::ithreads3>
80
81 <IfDefine PERL_USEITHREADS>
82 # a new interpreter pool
83 PerlOptions +Parent
84 PerlInterpStart 3
85 PerlInterpMax 3
86 PerlInterpMinSpare 1
87 PerlInterpMaxSpare 3
88 PerlInterpScope handler
89 </IfDefine>
90
91 # use test system's @INC
92 PerlSwitches -I@serverroot@
93 PerlRequire "conf/modperl_inc.pl"
94 PerlModule TestPerl::ithreads3
95
96 <Location /modperl>
97 SetHandler modperl
98 PerlResponseHandler TestPerl::ithreads3::response
99 </Location>
100
101 <Location /perl-script>
102 SetHandler perl-script
103 PerlResponseHandler TestPerl::ithreads3::response
104 </Location>
105
106 PerlTransHandler TestPerl::ithreads3::trans
107
108 </VirtualHost>
+0
-33
t/response/TestPerl/ithreads_args.pm less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 package TestPerl::ithreads_args;
2
3 # reproducing a bug in perl ithreads: [perl #34342]
4 # https://rt.perl.org/rt3/Ticket/Display.html?id=34342
5 #
6 # here an unshifted $r (i.e. as it leaves @_ populated causes a scalar
7 # leak in the thread).
8
9 use Devel::Peek;
10 use Apache::Test;
11
12 sub handler { # XXX: unshifted $_[0] leaks scalar
13 #Dump $_[0];
14 #my $r = shift; # shift removes the leak
15 my $r = $_[0];
16 #Dump $r; # here PADBUSY,PADMY prevent the ithread from cloning it
17
18 plan $r, tests => 1, need
19 need_threads,
20 {"perl >= 5.8.1 is required (this is $])" => ($] >= 5.008001)};
21
22 require threads;
23
24 warn "\n*** The following leak is expected (perl bug #34342) ***\n";
25 threads->new(sub {})->join;
26
27 ok 1;
28
29 return 0;
30 }
31
32 1;
+0
-51
t/response/TestPerl/ithreads_eval.pm less more
0 # please insert nothing before this line: -*- mode: cperl; cperl-indent-level: 4; cperl-continued-statement-offset: 4; indent-tabs-mode: nil -*-
1 package TestPerl::ithreads_eval;
2
3 # reproducing a bug in perl ithreads: [perl #34341]
4 # https://rt.perl.org/rt3/Ticket/Display.html?id=34341
5 #
6 # $thr->join triggers the following leak:
7 # - due to to local $0, (its second MAGIC's MG_OBJ,
8 # you can see it in the output of Dump $0). This leak was first
9 # spotted in the RegistryCooker.pm which localizes $0
10
11 use strict;
12 use warnings FATAL => 'all';
13
14 use Apache::Test;
15 use Apache::TestUtil;
16
17 use Devel::Peek;
18
19 use Apache2::Const -compile => 'OK';
20
21 sub handler {
22 my $r = shift;
23
24 plan $r, tests => 1, need
25 need_threads,
26 {"perl >= 5.8.1 is required (this is $])" => ($] >= 5.008001)};
27
28 require threads;
29
30 eval <<'EOI';
31 sub mytest {
32 local $0 = 'mememe'; # <== XXX: leaks scalar
33 my $thr;
34 $thr = threads->new(\&mythread);
35 $thr->join; # <== XXX: triggers scalar leak
36 }
37 sub mythread {
38 #Dump $0;
39 }
40 EOI
41
42 warn "\n*** The following leak is expected (perl bug #34341) ***\n";
43 mytest();
44
45 ok 1;
46
47 return Apache2::Const::OK;
48 }
49
50 1;
+0
-0
util/apr_arg_check.pl less more
(No changes)
+0
-0
util/apr_pool_check.pl less more
(No changes)
+0
-0
util/cvsize.pl less more
(No changes)
+0
-0
util/getdiff.pl less more
(No changes)
+0
-0
util/methodlookup_check.pl less more
(No changes)
+0
-0
util/perl_bloat.pl less more
(No changes)
+0
-0
util/source_stats.pl less more
(No changes)
+1
-1
xs/APR/APR/Makefile.PL less more
102102
103103 $string .= join '', map {
104104 "$_: $src{$_}\n\t\$(CP) $src{$_} .\n";
105 } keys %src;
105 } sort keys %src;
106106
107107 return $string;
108108 }
+1
-1
xs/APR/aprext/Makefile.PL less more
5050
5151 $string .= join '', map {
5252 "$_: $src{$_}\n\t\$(CP) $src{$_} .\n";
53 } keys %src;
53 } sort keys %src;
5454
5555 # BSD make needs an empty target, even if the target is specified in .PHONY
5656 $string .= "\ndynamic ::\n";
+36
-36
xs/APR/aprext/modperl_dummy.c less more
0 /* Licensed to the Apache Software Foundation (ASF) under one or more
1 * contributor license agreements. See the NOTICE file distributed with
2 * this work for additional information regarding copyright ownership.
3 * The ASF licenses this file to You under the Apache License, Version 2.0
4 * (the "License"); you may not use this file except in compliance with
5 * the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "mod_perl.h"
17
18 /* FIXME: These functions are called from modperl_trace() in libaprext.lib
19 * but are normally defined in mod_perl.c which can't be included.
20 */
21
22 int modperl_is_running(void)
23 {
24 return 0;
25 }
26
27 int modperl_threads_started(void)
28 {
29 return 0;
30 }
31
32 int modperl_threaded_mpm(void)
33 {
34 return 0;
35 }
0 /* Licensed to the Apache Software Foundation (ASF) under one or more
1 * contributor license agreements. See the NOTICE file distributed with
2 * this work for additional information regarding copyright ownership.
3 * The ASF licenses this file to You under the Apache License, Version 2.0
4 * (the "License"); you may not use this file except in compliance with
5 * the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "mod_perl.h"
17
18 /* FIXME: These functions are called from modperl_trace() in libaprext.lib
19 * but are normally defined in mod_perl.c which can't be included.
20 */
21
22 int modperl_is_running(void)
23 {
24 return 0;
25 }
26
27 int modperl_threads_started(void)
28 {
29 return 0;
30 }
31
32 int modperl_threaded_mpm(void)
33 {
34 return 0;
35 }
+1
-1
xs/ModPerl/Const/Makefile.PL less more
2525
2626 $string .= join '', map {
2727 "$_: $src{$_}\n\t\$(CP) $src{$_} .\n";
28 } keys %src;
28 } sort keys %src;
2929
3030 return $string;
3131 }
+1
-1
xs/maps/apache2_functions.map less more
181181 ? ($1*1000+$2)*1000+$3 \
182182 : die "Cannot get httpd version"; \
183183 } > 2003000
184 mpxs_Apache2__ServerRec_loglevel | | server_rec *:s, loglevel=NULL
184 mpxs_Apache2__ServerRec_loglevel | | server_rec *:s, loglevel=0
185185 #_end_
186186
187187 MODULE=Apache2::ServerUtil PACKAGE=Apache2::ServerUtil
+18
-0
xs/tables/current/ModPerl/FunctionTable.pm less more
81298129 },
81308130 {
81318131 'return_type' => 'SV *',
8132 'name' => 'mpxs_apr_thread_rwlock_create',
8133 'args' => [
8134 {
8135 'type' => 'PerlInterpreter *',
8136 'name' => 'my_perl'
8137 },
8138 {
8139 'type' => 'SV *',
8140 'name' => 'classname'
8141 },
8142 {
8143 'type' => 'SV *',
8144 'name' => 'p_sv'
8145 }
8146 ]
8147 },
8148 {
8149 'return_type' => 'SV *',
81328150 'name' => 'mpxs_apr_uri_parse',
81338151 'args' => [
81348152 {
+38
-0
xs/tables/current24/ModPerl/FunctionTable.pm less more
45054505 ]
45064506 },
45074507 {
4508 'return_type' => 'void',
4509 'name' => 'modperl_pnotes_kill',
4510 'args' => [
4511 {
4512 'type' => 'void *',
4513 'name' => 'cl_data'
4514 }
4515 ]
4516 },
4517 {
45084518 'return_type' => 'int',
45094519 'name' => 'modperl_post_config_handler',
45104520 'args' => [
64356445 ]
64366446 },
64376447 {
6448 'return_type' => 'void',
6449 'name' => 'mpxs_Apache2__Connection_pnotes_kill',
6450 'args' => [
6451 {
6452 'type' => 'PerlInterpreter*',
6453 'name' => 'my_perl'
6454 },
6455 {
6456 'type' => 'conn_rec *',
6457 'name' => 'c'
6458 }
6459 ]
6460 },
6461 {
64386462 'return_type' => 'SV *',
64396463 'name' => 'mpxs_Apache2__Directive_as_hash',
64406464 'attr' => [
73097333 }
73107334 ]
73117335 },
7336 {
7337 'return_type' => 'void',
7338 'name' => 'mpxs_Apache2__RequestRec_pnotes_kill',
7339 'args' => [
7340 {
7341 'type' => 'PerlInterpreter*',
7342 'name' => 'my_perl'
7343 },
7344 {
7345 'type' => 'request_rec *',
7346 'name' => 'r'
7347 }
7348 ]
7349 },
73127350 {
73137351 'return_type' => 'SV *',
73147352 'name' => 'mpxs_Apache2__RequestRec_print',