granicus.if.org Git - apache/blob - support/apxs.in

   1 #!@perlbin@ -w
   2 #
   3 # Licensed to the Apache Software Foundation (ASF) under one or more
   4 # contributor license agreements.  See the NOTICE file distributed with
   5 # this work for additional information regarding copyright ownership.
   6 # The ASF licenses this file to You under the Apache License, Version 2.0
   7 # (the "License"); you may not use this file except in compliance with
   8 # the License.  You may obtain a copy of the License at
   9 #
  10 #     http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS,
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 require 5.004;
  19 use strict;
  20 package apxs;
  21
  22 ##
  23 ##  Configuration
  24 ##
  25
  26 my %config_vars = ();
  27
  28 my $installbuilddir = "@exp_installbuilddir@";
  29 get_config_vars("$installbuilddir/config_vars.mk",\%config_vars);
  30
  31 # read the configuration variables once
  32
  33 my $prefix         = get_vars("prefix");
  34 my $CFG_PREFIX     = $prefix;
  35 my $exec_prefix    = get_vars("exec_prefix");
  36 my $datadir        = get_vars("datadir");
  37 my $localstatedir  = get_vars("localstatedir");
  38 my $CFG_TARGET     = get_vars("progname");
  39 my $CFG_SYSCONFDIR = get_vars("sysconfdir");
  40 my $CFG_CFLAGS     = join ' ', map { get_vars($_) }
  41   qw(SHLTCFLAGS CFLAGS NOTEST_CPPFLAGS EXTRA_CPPFLAGS EXTRA_CFLAGS);
  42 my $CFG_LDFLAGS    = join ' ', map { get_vars($_) }
  43   qw(LDFLAGS NOTEST_LDFLAGS SH_LDFLAGS);
  44 my $includedir     = get_vars("includedir");
  45 my $CFG_INCLUDEDIR = eval qq("$includedir");
  46 my $CFG_CC         = get_vars("CC");
  47 my $libexecdir     = get_vars("libexecdir");
  48 my $CFG_LIBEXECDIR = eval qq("$libexecdir");
  49 my $sbindir        = get_vars("sbindir");
  50 my $CFG_SBINDIR    = eval qq("$sbindir");
  51 my $ltflags        = $ENV{'LTFLAGS'};
  52 $ltflags or $ltflags = "--silent";
  53
  54 my %internal_vars = map {$_ => 1}
  55     qw(TARGET CC CFLAGS CFLAGS_SHLIB LD_SHLIB LDFLAGS_SHLIB LIBS_SHLIB
  56        PREFIX SBINDIR INCLUDEDIR LIBEXECDIR SYSCONFDIR);
  57
  58 ##
  59 ##  parse argument line
  60 ##
  61
  62 #   defaults for parameters
  63 my $opt_n = '';
  64 my $opt_g = '';
  65 my $opt_c = 0;
  66 my $opt_o = '';
  67 my @opt_D = ();
  68 my @opt_I = ();
  69 my @opt_L = ();
  70 my @opt_l = ();
  71 my @opt_W = ();
  72 my @opt_S = ();
  73 my $opt_e = 0;
  74 my $opt_i = 0;
  75 my $opt_a = 0;
  76 my $opt_A = 0;
  77 my $opt_q = 0;
  78 my $opt_h = 0;
  79 my $opt_p = 0;
  80 my $opt_v = 0;
  81
  82 #   this subroutine is derived from Perl's getopts.pl with the enhancement of
  83 #   the "+" metacharacter at the format string to allow a list to be built by
  84 #   subsequent occurrences of the same option.
  85 sub Getopts {
  86     my ($argumentative, @ARGV) = @_;
  87     my $errs = 0;
  88     local $_;
  89
  90     my @args = split / */, $argumentative;
  91     while (@ARGV && ($_ = $ARGV[0]) =~ /^-(.)(.*)/) {
  92         my ($first, $rest) = ($1,$2);
  93         if ($_ =~ m|^--$|) {
  94             shift @ARGV;
  95             last;
  96         }
  97         my $pos = index($argumentative,$first);
  98         if ($pos >= 0) {
  99             if ($pos < $#args && $args[$pos+1] eq ':') {
 100                 shift @ARGV;
 101                 if ($rest eq '') {
 102                     unless (@ARGV) {
 103                         error("Incomplete option: $first (needs an argument)");
 104                         $errs++;
 105                     }
 106                     $rest = shift(@ARGV);
 107                 }
 108                 eval "\$opt_$first = \$rest;";
 109             }
 110             elsif ($pos < $#args && $args[$pos+1] eq '+') {
 111                 shift @ARGV;
 112                 if ($rest eq '') {
 113                     unless (@ARGV) {
 114                         error("Incomplete option: $first (needs an argument)");
 115                         $errs++;
 116                     }
 117                     $rest = shift(@ARGV);
 118                 }
 119                 eval "push(\@opt_$first, \$rest);";
 120             }
 121             else {
 122                 eval "\$opt_$first = 1";
 123                 if ($rest eq '') {
 124                     shift(@ARGV);
 125                 }
 126                 else {
 127                     $ARGV[0] = "-$rest";
 128                 }
 129             }
 130         }
 131         else {
 132             error("Unknown option: $first");
 133             $errs++;
 134             if ($rest ne '') {
 135                 $ARGV[0] = "-$rest";
 136             }
 137             else {
 138                 shift(@ARGV);
 139             }
 140         }
 141     }
 142     return ($errs == 0, @ARGV);
 143 }
 144
 145 sub usage {
 146     print STDERR "Usage: apxs -g [-S <var>=<val>] -n <modname>\n";
 147     print STDERR "       apxs -q [-v] [-S <var>=<val>] [<query> ...]\n";
 148     print STDERR "       apxs -c [-S <var>=<val>] [-o <dsofile>] [-D <name>[=<value>]]\n";
 149     print STDERR "               [-I <incdir>] [-L <libdir>] [-l <libname>] [-Wc,<flags>]\n";
 150     print STDERR "               [-Wl,<flags>] [-p] <files> ...\n";
 151     print STDERR "       apxs -i [-S <var>=<val>] [-a] [-A] [-n <modname>] <dsofile> ...\n";
 152     print STDERR "       apxs -e [-S <var>=<val>] [-a] [-A] [-n <modname>] <dsofile> ...\n";
 153     exit(1);
 154 }
 155
 156 #   option handling
 157 my $rc;
 158 ($rc, @ARGV) = &Getopts("qn:gco:I+D+L+l+W+S+eiaApv", @ARGV);
 159 &usage if ($rc == 0);
 160 &usage if ($#ARGV == -1 and not $opt_g and not $opt_q);
 161 &usage if (not $opt_q and not ($opt_g and $opt_n) and not $opt_i and not $opt_c and not $opt_e);
 162
 163 #   argument handling
 164 my @args = @ARGV;
 165 my $name = 'unknown';
 166 $name = $opt_n if ($opt_n ne '');
 167
 168 if (@opt_S) {
 169     my ($opt_S);
 170     foreach $opt_S (@opt_S) {
 171         if ($opt_S =~ m/^([^=]+)=(.*)$/) {
 172             my ($var) = $1;
 173             my ($val) = $2;
 174             my $oldval = eval "\$CFG_$var";
 175
 176             unless ($var and $oldval) {
 177                 print STDERR "apxs:Error: no config variable $var\n";
 178                 &usage;
 179             }
 180
 181             eval "\$CFG_${var}=\"${val}\"";
 182         } else {
 183             print STDERR "apxs:Error: malformatted -S option\n";
 184             &usage;
 185         }
 186     }
 187 }
 188
 189 ##
 190 ##  Initial shared object support check
 191 ##
 192 unless ("@MOD_SO_ENABLED@" eq "yes") {
 193     error("Sorry, no shared object support for Apache");
 194     error("available under your platform. Make sure");
 195     error("the Apache module mod_so is compiled into");
 196     error("the server binary.");
 197     exit 1;
 198 }
 199
 200 sub get_config_vars{
 201     my ($file, $rh_config) = @_;
 202
 203     open IN, $file or die "cannot open $file: $!";
 204     while (<IN>){
 205         if (/^\s*(.*?)\s*=\s*(.*)$/){
 206             $rh_config->{$1} = $2;
 207         }
 208     }
 209     close IN;
 210 }
 211
 212 sub get_vars {
 213     my $result = '';
 214     my $ok = 0;
 215     my $arg;
 216     foreach $arg (@_) {
 217         if (exists $config_vars{$arg} or exists $config_vars{lc $arg}) {
 218             my $val = exists $config_vars{$arg}
 219                 ? $config_vars{$arg}
 220                 : $config_vars{lc $arg};
 221             $val =~ s/[()]//g;
 222             $result .= eval "qq($val)" if defined $val;
 223             $result .= ";;";
 224             $ok = 1;
 225         }
 226         if (not $ok) {
 227             if (exists $internal_vars{$arg} or exists $internal_vars{lc $arg}) {
 228                 my $val = exists $internal_vars{$arg} ? $arg : lc $arg;
 229                 $val = eval "\$CFG_$val";
 230                 $result .= eval "qq($val)" if defined $val;
 231                 $result .= ";;";
 232                 $ok = 1;
 233             }
 234             if (not $ok) {
 235                 error("Invalid query string `$arg'");
 236                 exit(1);
 237             }
 238         }
 239     }
 240     $result =~ s|;;$||;
 241     return $result;
 242 }
 243
 244 ##
 245 ##  Operation
 246 ##
 247
 248 #   helper function for executing a list of
 249 #   system command with return code checks
 250 sub execute_cmds {
 251     my (@cmds) = @_;
 252     my ($cmd, $rc);
 253
 254     foreach $cmd (@cmds) {
 255         notice($cmd);
 256         $rc = system $cmd;
 257         if ($rc) {
 258             error(sprintf "Command failed with rc=%d\n", $rc << 8);
 259             exit 1 ;
 260         }
 261     }
 262 }
 263
 264 if ($opt_g) {
 265     ##
 266     ##  SAMPLE MODULE SOURCE GENERATION
 267     ##
 268
 269     if (-d $name) {
 270         error("Directory `$name' already exists. Remove first");
 271         exit(1);
 272     }
 273
 274     my $data = join('', <DATA>);
 275     $data =~ s|%NAME%|$name|sg;
 276     $data =~ s|%TARGET%|$CFG_TARGET|sg;
 277     $data =~ s|%PREFIX%|$prefix|sg;
 278     $data =~ s|%INSTALLBUILDDIR%|$installbuilddir|sg;
 279
 280     my ($mkf, $mods, $src) = ($data =~ m|^(.+)-=#=-\n(.+)-=#=-\n(.+)|s);
 281
 282     notice("Creating [DIR]  $name");
 283     system("mkdir $name");
 284     notice("Creating [FILE] $name/Makefile");
 285     open(FP, ">${name}/Makefile") || die;
 286     print FP $mkf;
 287     close(FP);
 288     notice("Creating [FILE] $name/modules.mk");
 289     open(FP, ">${name}/modules.mk") || die;
 290     print FP $mods;
 291     close(FP);
 292     notice("Creating [FILE] $name/mod_$name.c");
 293     open(FP, ">${name}/mod_${name}.c") || die;
 294     print FP $src;
 295     close(FP);
 296     notice("Creating [FILE] $name/.deps");
 297     system("touch ${name}/.deps");
 298
 299     exit(0);
 300 }
 301
 302
 303 if ($opt_q) {
 304     ##
 305     ##  QUERY INFORMATION
 306     ##
 307     my $result;
 308     if ($#args >= 0) {
 309         $result = get_vars(@args);
 310         print "$result\n";
 311     } else {
 312         # -q without var name prints all variables and their values
 313
 314         # Additional -v pretty-prints output
 315         if ($opt_v) {
 316             # Variable names in alphabetic order
 317             my @vars = sort {uc($a) cmp uc($b)} keys %config_vars;
 318
 319             # Make the left column as wide as the longest variable name
 320             my $width = 0;
 321             foreach (@vars) {
 322                 my $l = length $_;
 323                 $width = $l unless ($l <= $width);
 324             }
 325
 326             foreach (@vars) {
 327                 printf "%-${width}s = %s\n", $_, $config_vars{$_};
 328             }
 329         } else {
 330             # Unprettified name=value list
 331             foreach (keys %config_vars) {
 332                 print "$_=$config_vars{$_}\n";
 333             }
 334         }
 335     }
 336 }
 337
 338 my $apr_config = get_vars("APR_CONFIG");
 339
 340 if (! -x "$apr_config") {
 341     error("$apr_config not found!");
 342     exit(1);
 343 }
 344
 345 my $apr_major_version = (split /\./, `$apr_config --version`)[0];
 346
 347 my $apu_config = "";
 348 if ($apr_major_version < 2) {
 349     $apu_config = get_vars("APU_CONFIG");
 350
 351     if (! -x "$apu_config") {
 352         error("$apu_config not found!");
 353         exit(1);
 354     }
 355 }
 356
 357 my $libtool = `$apr_config --apr-libtool`;
 358 chomp($libtool);
 359
 360 my $apr_includedir = `$apr_config --includes`;
 361 chomp($apr_includedir);
 362 my $apu_includedir = "";
 363 if ($apr_major_version < 2) {
 364     $apu_includedir = `$apu_config --includes`;
 365     chomp($apu_includedir);
 366 }
 367
 368 if ($opt_c) {
 369     ##
 370     ##  SHARED OBJECT COMPILATION
 371     ##
 372
 373     #   split files into sources and objects
 374     my @srcs = ();
 375     my @objs = ();
 376     my $f;
 377     foreach $f (@args) {
 378         if ($f =~ m|\.c$|) {
 379             push(@srcs, $f);
 380         }
 381         else {
 382             push(@objs, $f);
 383         }
 384     }
 385
 386     #   determine output file
 387     my $dso_file;
 388     if ($opt_o eq '') {
 389         if ($#srcs > -1) {
 390             $dso_file = $srcs[0];
 391             $dso_file =~ s|\.[^.]+$|.la|;
 392         }
 393         elsif ($#objs > -1) {
 394             $dso_file = $objs[0];
 395             $dso_file =~ s|\.[^.]+$|.la|;
 396         }
 397         else {
 398             $dso_file = "mod_unknown.la";
 399         }
 400     }
 401     else {
 402         $dso_file = $opt_o;
 403         $dso_file =~ s|\.[^.]+$|.la|;
 404     }
 405
 406     #   create compilation commands
 407     my @cmds = ();
 408     my $opt = '';
 409     my ($opt_Wc, $opt_I, $opt_D);
 410     foreach $opt_Wc (@opt_W) {
 411         $opt .= "$1 " if ($opt_Wc =~ m|^\s*c,(.*)$|);
 412     }
 413     foreach $opt_I (@opt_I) {
 414         $opt .= "-I$opt_I ";
 415     }
 416     foreach $opt_D (@opt_D) {
 417         $opt .= "-D$opt_D ";
 418     }
 419     my $cflags = "$CFG_CFLAGS";
 420     my $s;
 421     my $mod;
 422     foreach $s (@srcs) {
 423         my $slo = $s;
 424         $slo =~ s|\.c$|.slo|;
 425         my $lo = $s;
 426         $lo =~ s|\.c$|.lo|;
 427         my $la = $s;
 428         $la =~ s|\.c$|.la|;
 429         my $o = $s;
 430         $o =~ s|\.c$|.o|;
 431         push(@cmds, "$libtool $ltflags --mode=compile $CFG_CC $cflags -I$CFG_INCLUDEDIR $apr_includedir $apu_includedir $opt -c -o $lo $s && touch $slo");
 432         unshift(@objs, $lo);
 433     }
 434
 435     #   create link command
 436     my $o;
 437     my $lo;
 438     foreach $o (@objs) {
 439         $lo .= " $o";
 440     }
 441     my ($opt_Wl, $opt_L, $opt_l);
 442     $opt = '';
 443     foreach $opt_Wl (@opt_W) {
 444         $opt .= "$1 " if ($opt_Wl =~ m|^\s*l,(.*)$|);
 445     }
 446     foreach $opt_L (@opt_L) {
 447         $opt .= " -L$opt_L";
 448     }
 449     foreach $opt_l (@opt_l) {
 450         $opt .= " -l$opt_l";
 451     }
 452
 453     my $ldflags = "$CFG_LDFLAGS";
 454     if ($opt_p == 1) {
 455
 456         my $apr_libs=`$apr_config --cflags --ldflags --link-libtool --libs`;
 457         chomp($apr_libs);
 458         my $apu_libs="";
 459         if ($apr_major_version < 2) {
 460             $apu_libs=`$apu_config --ldflags --link-libtool --libs`;
 461             chomp($apu_libs);
 462         }
 463
 464         $opt .= " ".$apu_libs." ".$apr_libs;
 465     }
 466     else {
 467         my $apr_ldflags=`$apr_config --ldflags`;
 468         chomp($apr_ldflags);
 469         $opt .= " -rpath $CFG_LIBEXECDIR -module -avoid-version $apr_ldflags";
 470     }
 471
 472     push(@cmds, "$libtool $ltflags --mode=link $CFG_CC $ldflags -o $dso_file $opt $lo");
 473
 474     #   execute the commands
 475     &execute_cmds(@cmds);
 476
 477     #   allow one-step compilation and installation
 478     if ($opt_i or $opt_e) {
 479         @args = ( $dso_file );
 480     }
 481 }
 482
 483 if ($opt_i or $opt_e) {
 484     ##
 485     ##  SHARED OBJECT INSTALLATION
 486     ##
 487
 488     #   determine installation commands
 489     #   and corresponding LoadModule directive
 490     my @lmd = ();
 491     my @cmds = ();
 492     my $f;
 493     foreach $f (@args) {
 494         #  ack all potential gcc, hp/ux, win32+os2+aix and os/x extensions
 495         if ($f !~ m#(\.so$|\.la$|\.sl$|\.dll$|\.dylib$|)#) {
 496             error("file $f is not a shared object");
 497             exit(1);
 498         }
 499         my $t = $f;
 500         $t =~ s|^.+/([^/]+)$|$1|;
 501         #  use .so unambigiously for installed shared library modules
 502         $t =~ s|\.[^./\\]+$|\.so|;
 503         if ($opt_i) {
 504             push(@cmds, "$installbuilddir/instdso.sh SH_LIBTOOL='" .
 505                  "$libtool' $f $CFG_LIBEXECDIR");
 506             push(@cmds, "chmod 755 $CFG_LIBEXECDIR/$t");
 507         }
 508
 509         #   determine module symbolname and filename
 510         my $filename = '';
 511         if ($name eq 'unknown') {
 512             $name = '';
 513             my $base = $f;
 514             $base =~ s|\.[^.]+$||;
 515             if (-f "$base.c") {
 516                 open(FP, "<$base.c");
 517                 my $content = join('', <FP>);
 518                 close(FP);
 519                 if ($content =~ m|.*AP_DECLARE_MODULE\s*\(\s*([a-zA-Z0-9_]+)\s*\)\s*=.*|s || $content =~ m|.*module\s+(?:AP_MODULE_DECLARE_DATA\s+)?([a-zA-Z0-9_]+)_module\s*=\s*.*|s) {
 520                     $name = "$1";
 521                     $filename = "$base.c";
 522                     $filename =~ s|^[^/]+/||;
 523                 }
 524             }
 525             if ($name eq '') {
 526                 if ($base =~ m|.*mod_([a-zA-Z0-9_]+)\..+|) {
 527                     $name = "$1";
 528                     $filename = $base;
 529                     $filename =~ s|^[^/]+/||;
 530                 }
 531             }
 532             if ($name eq '') {
 533                 error("Sorry, cannot determine bootstrap symbol name");
 534                 error("Please specify one with option `-n'");
 535                 exit(1);
 536             }
 537         }
 538         if ($filename eq '') {
 539             $filename = "mod_${name}.c";
 540         }
 541         my $dir = $CFG_LIBEXECDIR;
 542         $dir =~ s|^$CFG_PREFIX/?||;
 543         $dir =~ s|(.)$|$1/|;
 544         $t =~ s|\.la$|.so|;
 545         push(@lmd, sprintf("LoadModule %-18s %s", "${name}_module", "$dir$t"));
 546     }
 547
 548     #   execute the commands
 549     &execute_cmds(@cmds);
 550
 551     #   activate module via LoadModule/AddModule directive
 552     if ($opt_a or $opt_A) {
 553         if (not -f "$CFG_SYSCONFDIR/$CFG_TARGET.conf") {
 554             error("Config file $CFG_SYSCONFDIR/$CFG_TARGET.conf not found");
 555             exit(1);
 556         }
 557
 558         open(FP, "<$CFG_SYSCONFDIR/$CFG_TARGET.conf") || die;
 559         my $content = join('', <FP>);
 560         close(FP);
 561
 562         if ($content !~ m|\n#?\s*LoadModule\s+|) {
 563             error("Activation failed for custom $CFG_SYSCONFDIR/$CFG_TARGET.conf file.");
 564             error("At least one `LoadModule' directive already has to exist.");
 565             exit(1);
 566         }
 567
 568         my $lmd;
 569         my $c = '';
 570         $c = '#' if ($opt_A);
 571         foreach $lmd (@lmd) {
 572             my $what = $opt_A ? "preparing" : "activating";
 573             my $lmd_re = $lmd;
 574             $lmd_re =~ s/\s+/\\s+/g;
 575
 576             if ($content !~ m|\n#?\s*$lmd_re|) {
 577                 # check for open <containers>, so that the new LoadModule
 578                 # directive always appears *outside* of an <container>.
 579
 580                 my $before = ($content =~ m|^(.*\n)#?\s*LoadModule\s+[^\n]+\n|s)[0];
 581
 582                 # the '()=' trick forces list context and the scalar
 583                 # assignment counts the number of list members (aka number
 584                 # of matches) then
 585                 my $cntopen = () = ($before =~ m|^\s*<[^/].*$|mg);
 586                 my $cntclose = () = ($before =~ m|^\s*</.*$|mg);
 587
 588                 if ($cntopen == $cntclose) {
 589                     # fine. Last LoadModule is contextless.
 590                     $content =~ s|^(.*\n#?\s*LoadModule\s+[^\n]+\n)|$1$c$lmd\n|s;
 591                 }
 592                 elsif ($cntopen < $cntclose) {
 593                     error('Configuration file is not valid. There are sections'
 594                           . ' closed before opened.');
 595                     exit(1);
 596                 }
 597                 else {
 598                     # put our cmd after the section containing the last
 599                     # LoadModule.
 600                     my $found =
 601                     $content =~ s!\A (               # string and capture start
 602                                   (?:(?:
 603                                     ^\s*             # start of conf line with a
 604                                     (?:[^<]|<[^/])   # directive which does not
 605                                                      # start with '</'
 606
 607                                     .*(?:$)\n        # rest of the line.
 608                                                      # the '$' is in parentheses
 609                                                      # to avoid misinterpreting
 610                                                      # the string "$\" as
 611                                                      # perl variable.
 612
 613                                     )*               # catch as much as possible
 614                                                      # of such lines. (including
 615                                                      # zero)
 616
 617                                     ^\s*</.*(?:$)\n? # after the above, we
 618                                                      # expect a config line with
 619                                                      # a closing container (</)
 620
 621                                   ) {$cntopen}       # the whole pattern (bunch
 622                                                      # of lines that end up with
 623                                                      # a closing directive) must
 624                                                      # be repeated $cntopen
 625                                                      # times. That's it.
 626                                                      # Simple, eh? ;-)
 627
 628                                   )                  # capture end
 629                                  !$1$c$lmd\n!mx;
 630
 631                     unless ($found) {
 632                         error('Configuration file is not valid. There are '
 633                               . 'sections opened and not closed.');
 634                         exit(1);
 635                     }
 636                 }
 637             } else {
 638                 # replace already existing LoadModule line
 639                 $content =~ s|^(.*\n)#?\s*$lmd_re[^\n]*\n|$1$c$lmd\n|s;
 640             }
 641             $lmd =~ m|LoadModule\s+(.+?)_module.*|;
 642             notice("[$what module `$1' in $CFG_SYSCONFDIR/$CFG_TARGET.conf]");
 643         }
 644         if (@lmd) {
 645             if (open(FP, ">$CFG_SYSCONFDIR/$CFG_TARGET.conf.new")) {
 646                 print FP $content;
 647                 close(FP);
 648                 system("cp $CFG_SYSCONFDIR/$CFG_TARGET.conf $CFG_SYSCONFDIR/$CFG_TARGET.conf.bak && " .
 649                        "cp $CFG_SYSCONFDIR/$CFG_TARGET.conf.new $CFG_SYSCONFDIR/$CFG_TARGET.conf && " .
 650                        "rm $CFG_SYSCONFDIR/$CFG_TARGET.conf.new");
 651             } else {
 652                 notice("unable to open configuration file");
 653             }
 654         }
 655     }
 656 }
 657
 658 sub error{
 659     print STDERR "apxs:Error: $_[0].\n";
 660 }
 661
 662 sub notice{
 663     print STDERR "$_[0]\n";
 664 }
 665
 666 ##EOF##
 667 __DATA__
 668 ##
 669 ##  Makefile -- Build procedure for sample %NAME% Apache module
 670 ##  Autogenerated via ``apxs -n %NAME% -g''.
 671 ##
 672
 673 builddir=.
 674 top_srcdir=%PREFIX%
 675 top_builddir=%PREFIX%
 676 include %INSTALLBUILDDIR%/special.mk
 677
 678 #   the used tools
 679 APACHECTL=apachectl
 680
 681 #   additional defines, includes and libraries
 682 #DEFS=-Dmy_define=my_value
 683 #INCLUDES=-Imy/include/dir
 684 #LIBS=-Lmy/lib/dir -lmylib
 685
 686 #   the default target
 687 all: local-shared-build
 688
 689 #   install the shared object file into Apache
 690 install: install-modules-yes
 691
 692 #   cleanup
 693 clean:
 694         -rm -f mod_%NAME%.o mod_%NAME%.lo mod_%NAME%.slo mod_%NAME%.la
 695
 696 #   simple test
 697 test: reload
 698         lynx -mime_header http://localhost/%NAME%
 699
 700 #   install and activate shared object by reloading Apache to
 701 #   force a reload of the shared object file
 702 reload: install restart
 703
 704 #   the general Apache start/restart/stop
 705 #   procedures
 706 start:
 707         $(APACHECTL) start
 708 restart:
 709         $(APACHECTL) restart
 710 stop:
 711         $(APACHECTL) stop
 712
 713 -=#=-
 714 mod_%NAME%.la: mod_%NAME%.slo
 715         $(SH_LINK) -rpath $(libexecdir) -module -avoid-version  mod_%NAME%.lo
 716 DISTCLEAN_TARGETS = modules.mk
 717 shared =  mod_%NAME%.la
 718 -=#=-
 719 /*
 720 **  mod_%NAME%.c -- Apache sample %NAME% module
 721 **  [Autogenerated via ``apxs -n %NAME% -g'']
 722 **
 723 **  To play with this sample module first compile it into a
 724 **  DSO file and install it into Apache's modules directory
 725 **  by running:
 726 **
 727 **    $ apxs -c -i mod_%NAME%.c
 728 **
 729 **  Then activate it in Apache's %TARGET%.conf file for instance
 730 **  for the URL /%NAME% in as follows:
 731 **
 732 **    #   %TARGET%.conf
 733 **    LoadModule %NAME%_module modules/mod_%NAME%.so
 734 **    <Location /%NAME%>
 735 **    SetHandler %NAME%
 736 **    </Location>
 737 **
 738 **  Then after restarting Apache via
 739 **
 740 **    $ apachectl restart
 741 **
 742 **  you immediately can request the URL /%NAME% and watch for the
 743 **  output of this module. This can be achieved for instance via:
 744 **
 745 **    $ lynx -mime_header http://localhost/%NAME%
 746 **
 747 **  The output should be similar to the following one:
 748 **
 749 **    HTTP/1.1 200 OK
 750 **    Date: Tue, 31 Mar 1998 14:42:22 GMT
 751 **    Server: Apache/1.3.4 (Unix)
 752 **    Connection: close
 753 **    Content-Type: text/html
 754 **
 755 **    The sample page from mod_%NAME%.c
 756 */
 757
 758 #include "httpd.h"
 759 #include "http_config.h"
 760 #include "http_protocol.h"
 761 #include "ap_config.h"
 762
 763 /* The sample content handler */
 764 static int %NAME%_handler(request_rec *r)
 765 {
 766     if (strcmp(r->handler, "%NAME%")) {
 767         return DECLINED;
 768     }
 769     r->content_type = "text/html";
 770
 771     if (!r->header_only)
 772         ap_rputs("The sample page from mod_%NAME%.c\n", r);
 773     return OK;
 774 }
 775
 776 static void %NAME%_register_hooks(apr_pool_t *p)
 777 {
 778     ap_hook_handler(%NAME%_handler, NULL, NULL, APR_HOOK_MIDDLE);
 779 }
 780
 781 /* Dispatch list for API hooks */
 782 module AP_MODULE_DECLARE_DATA %NAME%_module = {
 783     STANDARD20_MODULE_STUFF,
 784     NULL,                  /* create per-dir    config structures */
 785     NULL,                  /* merge  per-dir    config structures */
 786     NULL,                  /* create per-server config structures */
 787     NULL,                  /* merge  per-server config structures */
 788     NULL,                  /* table of config file commands       */
 789     %NAME%_register_hooks  /* register hooks                      */
 790 };
 791