Configure

   1 #! /usr/bin/env perl
   2 # -*- mode: perl; -*-
   3
   4 ##
   5 ##  Configure -- OpenSSL source tree configuration script
   6 ##  If editing this file, run this command before committing
   7 ##      make -f Makefile.in TABLE
   8 ##
   9
  10 require 5.000;
  11 use strict;
  12 use File::Basename;
  13 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
  14 use File::Path qw/mkpath/;
  15
  16 # see INSTALL for instructions.
  17
  18 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  19
  20 # Options:
  21 #
  22 # --config      add the given configuration file, which will be read after
  23 #               any "Configurations*" files that are found in the same
  24 #               directory as this script.
  25 # --prefix      prefix for the OpenSSL installation, which includes the
  26 #               directories bin, lib, include, share/man, share/doc/openssl
  27 #               This becomes the value of INSTALLTOP in Makefile
  28 #               (Default: /usr/local)
  29 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  30 #               If it's a relative directory, it will be added on the directory
  31 #               given with --prefix.
  32 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  33 #               (Default: PREFIX/ssl)
  34 #
  35 # --cross-compile-prefix Add specified prefix to binutils components.
  36 #
  37 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
  38 #               interfaces deprecated as of the specified OpenSSL version.
  39 #
  40 # no-hw-xxx     do not compile support for specific crypto hardware.
  41 #               Generic OpenSSL-style methods relating to this support
  42 #               are always compiled but return NULL if the hardware
  43 #               support isn't compiled.
  44 # no-hw         do not compile support for any crypto hardware.
  45 # [no-]threads  [don't] try to create a library that is suitable for
  46 #               multithreaded applications (default is "threads" if we
  47 #               know how to do it)
  48 # [no-]shared   [don't] try to create shared libraries when supported.
  49 # [no-]pic      [don't] try to build position independent code when supported.
  50 #               If disabled, it also disables shared and dynamic-engine.
  51 # no-asm        do not use assembler
  52 # no-dso        do not compile in any native shared-library methods. This
  53 #               will ensure that all methods just return NULL.
  54 # no-egd        do not compile support for the entropy-gathering daemon APIs
  55 # [no-]zlib     [don't] compile support for zlib compression.
  56 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  57 #               library and will be loaded in run-time by the OpenSSL library.
  58 # sctp          include SCTP support
  59 # 386           generate 80386 code
  60 # enable-weak-ssl-ciphers
  61 #               Enable weak ciphers that are disabled by default. This currently
  62 #               only includes RC4 based ciphers.
  63 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
  64 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  65 # -<xxx> +<xxx> compiler options are passed through
  66 #
  67 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
  68 #               provided to stack calls. Generates unique stack functions for
  69 #               each possible stack type.
  70 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
  71 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  72 # Following are set automatically by this script
  73 #
  74 # MD5_ASM       use some extra md5 assember,
  75 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
  76 # RMD160_ASM    use some extra ripemd160 assember,
  77 # SHA256_ASM    sha256_block is implemented in assembler
  78 # SHA512_ASM    sha512_block is implemented in assembler
  79 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
  80
  81 # Minimum warning options... any contributions to OpenSSL should at least get
  82 # past these.
  83
  84 my $gcc_devteam_warn = "-DPEDANTIC -DREF_DEBUG -DDEBUG_UNUSED -DBIO_DEBUG"
  85         . " -pedantic"
  86         . " -Wall"
  87         . " -Wno-long-long"
  88         . " -Wsign-compare"
  89         . " -Wmissing-prototypes"
  90         . " -Wshadow"
  91         . " -Wformat"
  92         . " -Wtype-limits"
  93         . " -Werror"
  94         ;
  95
  96 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
  97 # TODO(openssl-team): fix problems and investigate if (at least) the
  98 # following warnings can also be enabled:
  99 #       -Wswitch-enum
 100 #       -Wcast-align
 101 #       -Wunreachable-code
 102 #       -Wlanguage-extension-token -- no, we use asm()
 103 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
 104 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
 105 my $clang_devteam_warn = ""
 106         . " -Qunused-arguments"
 107         . " -Wextra"
 108         . " -Wno-unused-parameter"
 109         . " -Wno-missing-field-initializers"
 110         . " -Wno-language-extension-token"
 111         . " -Wno-extended-offsetof"
 112         . " -Wconditional-uninitialized"
 113         . " -Wincompatible-pointer-types-discards-qualifiers"
 114         . " -Wmissing-variable-declarations"
 115         ;
 116
 117 # This adds backtrace information to the memory leak info.  Is only used
 118 # when crypto-mdebug-backtrace is enabled.
 119 my $memleak_devteam_backtrace = "-rdynamic";
 120
 121 my $strict_warnings = 0;
 122
 123 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 124 # which would cover all BSD flavors. -pthread applies to them all,
 125 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 126 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 127 # which has to be accompanied by explicit -D_THREAD_SAFE and
 128 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 129 # seems to be sufficient?
 130 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 131
 132 #
 133 # API compability name to version number mapping.
 134 #
 135 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
 136 my $apitable = {
 137     "1.1.0" => "0x10100000L",
 138     "1.0.0" => "0x10000000L",
 139     "0.9.8" => "0x00908000L",
 140 };
 141
 142 our %table = ();
 143 our %config = ();
 144 our %withargs = ();
 145
 146 # Forward declarations ###############################################
 147
 148 # read_config(filename)
 149 #
 150 # Reads a configuration file and populates %table with the contents
 151 # (which the configuration file places in %targets).
 152 sub read_config;
 153
 154 # resolve_config(target)
 155 #
 156 # Resolves all the late evalutations, inheritances and so on for the
 157 # chosen target and any target it inherits from.
 158 sub resolve_config;
 159
 160
 161 # Information collection #############################################
 162
 163 # Unified build supports separate build dir
 164 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
 165 my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
 166 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
 167
 168 $config{sourcedir} = abs2rel($srcdir);
 169 $config{builddir} = abs2rel($blddir);
 170
 171 # Collect version numbers
 172 $config{version} = "unknown";
 173 $config{version_num} = "unknown";
 174 $config{shlib_version_number} = "unknown";
 175 $config{shlib_version_history} = "unknown";
 176
 177 collect_information(
 178     collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
 179     qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
 180     qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/      => sub { $config{version_num}=$1 },
 181     qr/SHLIB_VERSION_NUMBER *"([^"]+)"/      => sub { $config{shlib_version_number}=$1 },
 182     qr/SHLIB_VERSION_HISTORY *"([^"]*)"/     => sub { $config{shlib_version_history}=$1 }
 183     );
 184 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
 185
 186 ($config{major}, $config{minor})
 187     = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
 188 ($config{shlib_major}, $config{shlib_minor})
 189     = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
 190 die "erroneous version information in opensslv.h: ",
 191     "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
 192     if ($config{major} eq "" || $config{minor} eq ""
 193         || $config{shlib_major} eq "" ||  $config{shlib_minor} eq "");
 194
 195 # Collect target configurations
 196
 197 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
 198 foreach (sort glob($pattern) ) {
 199     &read_config($_);
 200 }
 201
 202
 203 print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
 204
 205 $config{perl};
 206 $config{prefix}="";
 207 $config{openssldir}="";
 208 $config{processor}="";
 209 $config{libdir}="";
 210 $config{cross_compile_prefix}="";
 211 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
 212 my $nofipscanistercheck=0;
 213 $config{baseaddr}="0xFB00000";
 214 my $auto_threads=1;    # enable threads automatically? true by default
 215 my $default_ranlib;
 216 $config{fips}=0;
 217
 218 # Top level directories to build
 219 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ];
 220 # crypto/ subdirectories to build
 221 $config{sdirs} = [
 222     "objects",
 223     "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305",
 224     "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
 225     "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
 226     "buffer", "bio", "stack", "lhash", "rand", "err",
 227     "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
 228     "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
 229     ];
 230
 231 # Known TLS and DTLS protocols
 232 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
 233 my @dtls = qw(dtls1 dtls1_2);
 234
 235 # Explicitelly known options that are possible to disable.  They can
 236 # be regexps, and will be used like this: /^no-${option}$/
 237 # For developers: keep it sorted alphabetically
 238
 239 my @disablables = (
 240     "aes",
 241     "asm",
 242     "async",
 243     "autoalginit",
 244     "autoerrinit",
 245     "bf",
 246     "camellia",
 247     "capieng",
 248     "cast",
 249     "chacha",
 250     "cmac",
 251     "cms",
 252     "comp",
 253     "crypto-mdebug",
 254     "crypto-mdebug-backtrace",
 255     "ct",
 256     "deprecated",
 257     "des",
 258     "dgram",
 259     "dh",
 260     "dsa",
 261     "dso",
 262     "dtls",
 263     "dynamic-engine",
 264     "ec",
 265     "ec2m",
 266     "ecdh",
 267     "ecdsa",
 268     "ec_nistp_64_gcc_128",
 269     "egd",
 270     "engine",
 271     "err",
 272     "filenames",
 273     "heartbeats",
 274     "hmac",
 275     "hw(-.+)?",
 276     "idea",
 277     "makedepend",
 278     "md2",
 279     "md4",
 280     "md5",
 281     "mdc2",
 282     "md[-_]ghost94",
 283     "multiblock",
 284     "nextprotoneg",
 285     "ocb",
 286     "ocsp",
 287     "pic",
 288     "poly1305",
 289     "posix-io",
 290     "psk",
 291     "rc2",
 292     "rc4",
 293     "rc5",
 294     "rdrand",
 295     "rfc3779",
 296     "rijndael",                 # Old AES name
 297     "ripemd",
 298     "rmd160",
 299     "rsa",
 300     "scrypt",
 301     "sct",
 302     "sctp",
 303     "seed",
 304     "sha",
 305     "shared",
 306     "sock",
 307     "srp",
 308     "srtp",
 309     "sse2",
 310     "ssl",
 311     "ssl-trace",
 312     "static-engine",
 313     "stdio",
 314     "threads",
 315     "tls",
 316     "ts",
 317     "ui",
 318     "unit-test",
 319     "whirlpool",
 320     "weak-ssl-ciphers",
 321     "zlib",
 322     "zlib-dynamic",
 323     );
 324 foreach my $proto ((@tls, @dtls))
 325         {
 326         push(@disablables, $proto);
 327         push(@disablables, "$proto-method");
 328         }
 329
 330 my @deprecated_disablables = (
 331     "ssl2",
 332     );
 333
 334 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 335
 336 our %disabled = ( # "what"         => "comment"
 337                   "ec_nistp_64_gcc_128" => "default",
 338                   "egd"                 => "default",
 339                   "md2"                 => "default",
 340                   "rc5"                 => "default",
 341                   "sctp"                => "default",
 342                   "shared"              => "default",
 343                   "ssl-trace"           => "default",
 344                   "ssl3"                => "default",
 345                   "ssl3-method"         => "default",
 346                   "static-engine"       => "default",
 347                   "unit-test"           => "default",
 348                   "weak-ssl-ciphers"    => "default",
 349                   "zlib"                => "default",
 350                   "zlib-dynamic"        => "default",
 351                   "crypto-mdebug"       => "default",
 352                   "heartbeats"          => "default",
 353                 );
 354
 355 # Note: => pair form used for aesthetics, not to truly make a hash table
 356 my @disable_cascades = (
 357     # "what"            => [ "cascade", ... ]
 358     sub { $config{processor} eq "386" }
 359                         => [ "sse2" ],
 360     "ssl"               => [ "ssl3" ],
 361     "ssl3-method"       => [ "ssl3" ],
 362     "zlib"              => [ "zlib-dynamic" ],
 363     "rijndael"          => [ "aes" ],
 364     "des"               => [ "mdc2" ],
 365     "ec"                => [ "ecdsa", "ecdh" ],
 366
 367     "dgram"             => [ "dtls" ],
 368     "dtls"              => [ @dtls ],
 369
 370     # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
 371     "md5"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
 372     "sha"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
 373
 374     # Additionally, SSL 3.0 requires either RSA or DSA+DH
 375     sub { $disabled{rsa}
 376           && ($disabled{dsa} || $disabled{dh}); }
 377                         => [ "ssl" ],
 378
 379     # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
 380     # or ECDSA + ECDH.  (D)TLS 1.2 has this requirement as well.
 381     # (XXX: We don't support PSK-only builds).
 382     sub { $disabled{rsa}
 383           && ($disabled{dsa} || $disabled{dh})
 384           && ($disabled{ecdsa} || $disabled{ecdh}); }
 385                         => [ "tls1", "tls1_1", "tls1_2",
 386                              "dtls1", "dtls1_2" ],
 387
 388     "tls"               => [ @tls ],
 389
 390     # SRP and HEARTBEATS require TLSEXT
 391     "tlsext"            => [ "srp", "heartbeats" ],
 392
 393     "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
 394
 395     # Without DSO, we can't load dynamic engines, so don't build them dynamic
 396     "dso"               => [ "dynamic-engine" ],
 397
 398     # Without position independent code, there can be no shared libraries or DSOs
 399     "pic"               => [ "shared", "dynamic-engine" ],
 400     );
 401
 402 # Avoid protocol support holes.  Also disable all versions below N, if version
 403 # N is disabled while N+1 is enabled.
 404 #
 405 my @list = (reverse @tls);
 406 while ((my $first, my $second) = (shift @list, shift @list)) {
 407     last unless @list;
 408     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 409                               => [ @list ] );
 410     unshift @list, $second;
 411 }
 412 my @list = (reverse @dtls);
 413 while ((my $first, my $second) = (shift @list, shift @list)) {
 414     last unless @list;
 415     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 416                               => [ @list ] );
 417     unshift @list, $second;
 418 }
 419
 420 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 421 # To remove something from %disabled, use "enable-foo".
 422 # For symmetry, "disable-foo" is a synonym for "no-foo".
 423
 424 my @generated_headers = (
 425     "include/openssl/opensslconf.h",
 426     "crypto/include/internal/bn_conf.h",
 427     "crypto/include/internal/dso_conf.h"
 428     );
 429
 430 my @generated_by_make_headers = (
 431     "crypto/buildinf.h"
 432     );
 433
 434
 435 my $no_sse2=0;
 436
 437 &usage if ($#ARGV < 0);
 438
 439 my $user_cflags="";
 440 my @user_defines=();
 441 $config{openssl_api_defines}=[];
 442 $config{openssl_algorithm_defines}=[];
 443 $config{openssl_thread_defines}=[];
 444 $config{openssl_sys_defines}=[];
 445 $config{openssl_other_defines}=[];
 446 my $libs="";
 447 my $target="";
 448 $config{options}="";
 449 $config{build_type} = "release";
 450
 451 my $classic = 0;
 452
 453 my @argvcopy=@ARGV;
 454
 455 if (grep /^reconf(igure)?$/, @argvcopy) {
 456     if (-f "./configdata.pm") {
 457         my $file = "./configdata.pm";
 458         unless (my $return = do $file) {
 459             die "couldn't parse $file: $@" if $@;
 460             die "couldn't do $file: $!"    unless defined $return;
 461             die "couldn't run $file"       unless $return;
 462         }
 463
 464         @argvcopy = defined($configdata::config{perlargv}) ?
 465             @{$configdata::config{perlargv}} : ();
 466         die "Incorrect data to reconfigure, please do a normal configuration\n"
 467             if (grep(/^reconf/,@argvcopy));
 468         $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
 469             if defined($configdata::config{cross_compile_prefix});
 470         $ENV{CROSS_COMPILE} = $configdata::config{cc}
 471             if defined($configdata::config{cc});
 472
 473         print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
 474         print "    CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
 475             if $ENV{CROSS_COMPILE};
 476         print "    CC = ",$ENV{CC},"\n" if $ENV{CC};
 477     } elsif (open IN, "<Makefile") {
 478         #
 479         # THIS SECTION IS TEMPORARY, it helps transitioning from Makefile
 480         # centered information gathering the reading configdata.pm
 481         #
 482         while (<IN>) {
 483             s|\R$||;
 484             if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
 485                 # Older form, we split the string and hope for the best
 486                 @argvcopy = split /\s+/, $_;
 487                 die "Incorrect data to reconfigure, please do a normal configuration\n"
 488                     if (grep(/^reconf/,@argvcopy));
 489             } elsif (/^CROSS_COMPILE=\s*(.*)/) {
 490                 $ENV{CROSS_COMPILE}=$1;
 491             } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
 492                 $ENV{CC}=$1;
 493             }
 494         }
 495         #
 496         # END OF TEMPORARY SECTION
 497         #
 498     } else {
 499         die "Insufficient data to reconfigure, please do a normal configuration\n";
 500     }
 501 }
 502
 503 $config{perlargv} = [ @argvcopy ];
 504
 505 my %unsupported_options = ();
 506 my %deprecated_options = ();
 507 foreach (@argvcopy)
 508         {
 509         # VMS is a case insensitive environment, and depending on settings
 510         # out of our control, we may receive options uppercased.  Let's
 511         # downcase at least the part before any equal sign.
 512         if ($^O eq "VMS")
 513                 {
 514                 s/^([^=]*)/lc($1)/e;
 515                 }
 516         s /^-no-/no-/; # some people just can't read the instructions
 517
 518         # rewrite some options in "enable-..." form
 519         s /^-?-?shared$/enable-shared/;
 520         s /^sctp$/enable-sctp/;
 521         s /^threads$/enable-threads/;
 522         s /^zlib$/enable-zlib/;
 523         s /^zlib-dynamic$/enable-zlib-dynamic/;
 524
 525         if (/^(no|disable|enable)-(.+)$/)
 526                 {
 527                 my $word = $2;
 528                 if (grep { $word =~ /^${_}$/ } @deprecated_disablables)
 529                         {
 530                         $deprecated_options{$_} = 1;
 531                         next;
 532                         }
 533                 elsif (!grep { $word =~ /^${_}$/ } @disablables)
 534                         {
 535                         $unsupported_options{$_} = 1;
 536                         next;
 537                         }
 538                 }
 539         if (/^no-(.+)$/ || /^disable-(.+)$/)
 540                 {
 541                 foreach my $proto ((@tls, @dtls))
 542                         {
 543                         if ($1 eq "$proto-method")
 544                                 {
 545                                 $disabled{"$proto"} = "option($proto-method)";
 546                                 last;
 547                                 }
 548                         }
 549                 if ($1 eq "dtls")
 550                         {
 551                         foreach my $proto (@dtls)
 552                                 {
 553                                 $disabled{$proto} = "option(dtls)";
 554                                 }
 555                         }
 556                 elsif ($1 eq "ssl")
 557                         {
 558                         # Last one of its kind
 559                         $disabled{"ssl3"} = "option(ssl)";
 560                         }
 561                 elsif ($1 eq "tls")
 562                         {
 563                         # XXX: Tests will fail if all SSL/TLS
 564                         # protocols are disabled.
 565                         foreach my $proto (@tls)
 566                                 {
 567                                 $disabled{$proto} = "option(tls)";
 568                                 }
 569                         }
 570                 elsif ($1 eq "static-engine")
 571                         {
 572                         delete $disabled{"dynamic-engine"};
 573                         }
 574                 elsif ($1 eq "dynamic-engine")
 575                         {
 576                         $disabled{"dynamic-engine"} = "option";
 577                         }
 578                 else
 579                         {
 580                         $disabled{$1} = "option";
 581                         }
 582                 # No longer an automatic choice
 583                 $auto_threads = 0 if ($1 eq "threads");
 584                 }
 585         elsif (/^enable-(.+)$/)
 586                 {
 587                 if ($1 eq "static-engine")
 588                         {
 589                         $disabled{"dynamic-engine"} = "option";
 590                         }
 591                 elsif ($1 eq "dynamic-engine")
 592                         {
 593                         delete $disabled{"dynamic-engine"};
 594                         }
 595                 elsif ($1 eq "zlib-dynamic")
 596                         {
 597                         delete $disabled{"zlib"};
 598                         }
 599                 my $algo = $1;
 600                 delete $disabled{$algo};
 601
 602                 # No longer an automatic choice
 603                 $auto_threads = 0 if ($1 eq "threads");
 604                 }
 605         elsif (/^--strict-warnings$/)
 606                 {
 607                 $strict_warnings = 1;
 608                 }
 609         elsif (/^--debug$/)
 610                 {
 611                 $config{build_type} = "debug";
 612                 }
 613         elsif (/^--release$/)
 614                 {
 615                 $config{build_type} = "release";
 616                 }
 617         elsif (/^386$/)
 618                 { $config{processor}=386; }
 619         elsif (/^fips$/)
 620                 {
 621                 $config{fips}=1;
 622                 }
 623         elsif (/^rsaref$/)
 624                 {
 625                 # No RSAref support any more since it's not needed.
 626                 # The check for the option is there so scripts aren't
 627                 # broken
 628                 }
 629         elsif (/^nofipscanistercheck$/)
 630                 {
 631                 $config{fips} = 1;
 632                 $nofipscanistercheck = 1;
 633                 }
 634         elsif (/^[-+]/)
 635                 {
 636                 if (/^--classic$/)
 637                         {
 638                         $classic=1;
 639                         }
 640                 elsif (/^--prefix=(.*)$/)
 641                         {
 642                         $config{prefix}=$1;
 643                         die "Directory given with --prefix MUST be absolute\n"
 644                                 unless file_name_is_absolute($config{prefix});
 645                         }
 646                 elsif (/^--api=(.*)$/)
 647                         {
 648                         $config{api}=$1;
 649                         }
 650                 elsif (/^--libdir=(.*)$/)
 651                         {
 652                         $config{libdir}=$1;
 653                         }
 654                 elsif (/^--openssldir=(.*)$/)
 655                         {
 656                         $config{openssldir}=$1;
 657                         }
 658                 elsif (/^--with-zlib-lib=(.*)$/)
 659                         {
 660                         $withargs{zlib_lib}=$1;
 661                         }
 662                 elsif (/^--with-zlib-include=(.*)$/)
 663                         {
 664                         $withargs{zlib_include}="-I$1";
 665                         }
 666                 elsif (/^--with-fipslibdir=(.*)$/)
 667                         {
 668                         $config{fipslibdir}="$1/";
 669                         }
 670                 elsif (/^--with-baseaddr=(.*)$/)
 671                         {
 672                         $config{baseaddr}="$1";
 673                         }
 674                 elsif (/^--cross-compile-prefix=(.*)$/)
 675                         {
 676                         $config{cross_compile_prefix}=$1;
 677                         }
 678                 elsif (/^--config=(.*)$/)
 679                         {
 680                         read_config $1;
 681                         }
 682                 elsif (/^-[lL](.*)$/ or /^-Wl,/)
 683                         {
 684                         $libs.=$_." ";
 685                         }
 686                 elsif (/^-D(.*)$/)
 687                         {
 688                         push @user_defines, $1;
 689                         }
 690                 else    # common if (/^[-+]/), just pass down...
 691                         {
 692                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 693                         $user_cflags.=" ".$_;
 694                         }
 695                 }
 696         else
 697                 {
 698                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
 699                 $target=$_;
 700                 }
 701         unless ($_ eq $target || /^no-/ || /^disable-/)
 702                 {
 703                 # "no-..." follows later after implied disactivations
 704                 # have been derived.  (Don't take this too seroiusly,
 705                 # we really only write OPTIONS to the Makefile out of
 706                 # nostalgia.)
 707
 708                 if ($config{options} eq "")
 709                         { $config{options} = $_; }
 710                 else
 711                         { $config{options} .= " ".$_; }
 712                 }
 713
 714         if (defined($config{api}) && !exists $apitable->{$config{api}}) {
 715                 die "***** Unsupported api compatibility level: $config{api}\n",
 716         }
 717
 718         if (keys %deprecated_options)
 719                 {
 720                 warn "***** Deprecated options: ",
 721                         join(", ", keys %deprecated_options), "\n";
 722                 }
 723         if (keys %unsupported_options)
 724                 {
 725                 die "***** Unsupported options: ",
 726                         join(", ", keys %unsupported_options), "\n";
 727                 }
 728         }
 729
 730 if ($config{fips})
 731         {
 732         delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
 733         }
 734 else
 735         {
 736         @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
 737         }
 738
 739 my @tocheckfor = (keys %disabled);
 740 while (@tocheckfor) {
 741     my %new_tocheckfor = ();
 742     my @cascade_copy = (@disable_cascades);
 743     while (@cascade_copy) {
 744         my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
 745         if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
 746             map {
 747                 $new_tocheckfor{$_} => 1; $disabled{$_} = "forced";
 748             } grep { !defined($disabled{$_}) } @$descendents;
 749         }
 750     }
 751     @tocheckfor = (keys %new_tocheckfor);
 752 }
 753
 754 if ($target eq "TABLE") {
 755     foreach (sort keys %table) {
 756         print_table_entry($_, "TABLE");
 757     }
 758     exit 0;
 759 }
 760
 761 if ($target eq "LIST") {
 762     foreach (sort keys %table) {
 763         print $_,"\n" unless $table{$_}->{template};
 764     }
 765     exit 0;
 766 }
 767
 768 if ($target eq "HASH") {
 769     print "%table = (\n";
 770     foreach (sort keys %table) {
 771         print_table_entry($_, "HASH");
 772     }
 773     exit 0;
 774 }
 775
 776 # Backward compatibility?
 777 if ($target =~ m/^CygWin32(-.*)$/) {
 778     $target = "Cygwin".$1;
 779 }
 780
 781 foreach (sort (keys %disabled))
 782         {
 783         $config{options} .= " no-$_";
 784
 785         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
 786
 787         if (/^dso$/)
 788                 { }
 789         elsif (/^threads$/)
 790                 { }
 791         elsif (/^shared$/)
 792                 { }
 793         elsif (/^pic$/)
 794                 { }
 795         elsif (/^zlib$/)
 796                 { }
 797         elsif (/^dynamic-engine$/)
 798                 { }
 799         elsif (/^makedepend$/)
 800                 { }
 801         elsif (/^zlib-dynamic$/)
 802                 { }
 803         elsif (/^sse2$/)
 804                 { $no_sse2 = 1; }
 805         elsif (/^engine$/)
 806                 {
 807                 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
 808                 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
 809                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
 810                 }
 811         else
 812                 {
 813                 my ($ALGO, $algo);
 814                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
 815
 816                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
 817                                 || /^autoalginit/ || /^autoerrinit/)
 818                         {
 819                         push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
 820                         print " OPENSSL_NO_$ALGO";
 821
 822                         if (/^err$/)    { push @user_defines, "OPENSSL_NO_ERR"; }
 823                         }
 824                 else
 825                         {
 826                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
 827
 828                         push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
 829                         print " OPENSSL_NO_$ALGO";
 830
 831                         # fix-up crypto/directory name(s)
 832                         $algo="whrlpool" if $algo eq "whirlpool";
 833                         $algo="ripemd" if $algo eq "rmd160";
 834                         @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
 835
 836                         print " (skip dir)";
 837                         }
 838                 }
 839
 840         print "\n";
 841         }
 842
 843 print "Configuring for $target\n";
 844
 845 # Support for legacy targets having a name starting with 'debug-'
 846 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
 847 if ($d) {
 848     $config{build_type} = "debug";
 849
 850     # If we do not find debug-foo in the table, the target is set to foo.
 851     if (!$table{$target}) {
 852         $target = $t;
 853     }
 854 }
 855 $config{target} = $target;
 856 my %target = resolve_config($target);
 857
 858 &usage if (!%target || $target{template});
 859
 860 %target = ( %{$table{DEFAULTS}}, %target );
 861
 862 $target{exe_extension}="";
 863 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
 864                                   || $config{target} =~ /^(?:Cygwin|mingw)/);
 865 $target{exe_extension}=".nlm" if ($config{target} =~ /netware/);
 866 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
 867
 868 ($target{shared_extension_simple}=$target{shared_extension})
 869     =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
 870 $target{dso_extension}=$target{shared_extension_simple};
 871 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
 872     if ($config{target} =~ /^(?:Cygwin|mingw)/);
 873
 874
 875 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
 876     if $config{cross_compile_prefix} eq "";
 877
 878 # Allow overriding the names of some tools.  USE WITH CARE
 879 $config{perl} =    $ENV{'PERL'}    || which("perl5") || which("perl") || "perl";
 880 $target{cc} =      $ENV{'CC'}      || $target{cc}      || "cc";
 881 $target{ranlib} =  $ENV{'RANLIB'}  || $target{ranlib}  || which("ranlib") || "true";
 882 $target{ar} =      $ENV{'AR'}      || $target{ar}      || "ar";
 883 $target{nm} =      $ENV{'NM'}      || $target{nm}      || "nm";
 884
 885 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
 886 # or release_ attributes.
 887 # Do it in such a way that no spurious space is appended (hence the grep).
 888 $config{defines} = [];
 889 $config{cflags} = "";
 890 $config{ex_libs} = "";
 891 $config{shared_ldflag} = "";
 892
 893 # Make sure build_scheme is consistent.
 894 $target{build_scheme} = [ $target{build_scheme} ]
 895     if ref($target{build_scheme}) ne "ARRAY";
 896
 897 ###### TO BE REMOVED WHEN CLASSIC BUILD IS REMOVED
 898 ######
 899 ###### If the user has chosen --classic, we give it to them.
 900 ###### If they try that with an out-of-source config, we complain.
 901 if ($target{build_scheme}->[0] eq "unified" && $classic) {
 902     die "Can't perform a classic build out of source tree\n"
 903         if $srcdir ne $blddir;
 904
 905     $target{build_scheme} = { unix    => [ "unixmake" ],
 906                               windows => [ "mk1mf", $target{build_scheme}->[2] ],
 907                               VMS     => undef } -> {$target{build_scheme}->[1]};
 908
 909     die "Classic mode unavailable on this platform\n"
 910         unless defined($target{build_scheme});
 911 }
 912
 913 my ($builder, $builder_platform, @builder_opts) =
 914     @{$target{build_scheme}};
 915
 916 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
 917         {
 918         $config{cflags} .= " -mno-cygwin";
 919         $config{shared_ldflag} .= " -mno-cygwin";
 920         }
 921
 922 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
 923         # minimally required architecture flags for assembly modules
 924         $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
 925         $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
 926 }
 927
 928 my $no_shared_warn=0;
 929 my $no_user_cflags=0;
 930 my $no_user_defines=0;
 931
 932 # The DSO code currently always implements all functions so that no
 933 # applications will have to worry about that from a compilation point
 934 # of view. However, the "method"s may return zero unless that platform
 935 # has support compiled in for them. Currently each method is enabled
 936 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
 937 # string entry into using the following logic;
 938 if (!$disabled{dso} && $target{dso_scheme} ne "")
 939         {
 940         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
 941         if ($target{dso_scheme} eq "DLFCN")
 942                 {
 943                 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
 944                 }
 945         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
 946                 {
 947                 unshift @{$config{defines}}, "DSO_DLFCN";
 948                 }
 949         else
 950                 {
 951                 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
 952                 }
 953         }
 954
 955 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
 956
 957 if ($disabled{asm})
 958         {
 959         if ($config{fips})
 960                 {
 961                 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
 962                 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
 963                 }
 964         }
 965
 966 # If threads aren't disabled, check how possible they are
 967 unless ($disabled{threads}) {
 968     if ($auto_threads) {
 969         # Enabled by default, disable it forcibly if unavailable
 970         if ($target{thread_scheme} eq "(unknown)") {
 971             $disabled{threads} = "unavailable";
 972         }
 973     } else {
 974         # The user chose to enable threads explicitely, let's see
 975         # if there's a chance that's possible
 976         if ($target{thread_scheme} eq "(unknown)") {
 977             # If the user asked for "threads" and we don't have internal
 978             # knowledge how to do it, [s]he is expected to provide any
 979             # system-dependent compiler options that are necessary.  We
 980             # can't truly check that the given options are correct, but
 981             # we expect the user to know what [s]He is doing.
 982             if ($no_user_cflags && $no_user_defines) {
 983                 die "You asked for multi-threading support, but didn't\n"
 984                     ,"provide any system-specific compiler options\n";
 985             }
 986         }
 987     }
 988 }
 989
 990 # If threads still aren't disabled, add a C macro to ensure the source
 991 # code knows about it.  Any other flag is taken care of by the configs.
 992 unless($disabled{threads}) {
 993     foreach (("defines", "openssl_thread_defines")) {
 994         push @{$config{$_}}, "OPENSSL_THREADS";
 995     }
 996 }
 997
 998 # With "deprecated" disable all deprecated features.
 999 if (defined($disabled{"deprecated"})) {
1000         $config{api} = $maxapi;
1001 }
1002
1003 if ($target{shared_target} eq "")
1004         {
1005         $no_shared_warn = 1
1006             if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
1007                 && !$config{fips});
1008         $disabled{shared} = "no-shared-target";
1009         $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1010             "no-shared-target";
1011         }
1012
1013 if ($disabled{"dynamic-engine"}) {
1014         push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1015         $config{dynamic_engines} = 0;
1016 } else {
1017         push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1018         $config{dynamic_engines} = 1;
1019 }
1020
1021 #
1022 # Platform fix-ups
1023 #
1024
1025 # This saves the build files from having to check
1026 if ($disabled{pic})
1027         {
1028         $target{shared_cflag} = $target{shared_ldflag} =
1029                 $target{shared_rcflag} = "";
1030         }
1031 else
1032         {
1033         push @{$config{defines}}, "OPENSSL_PIC";
1034         }
1035
1036 if ($target{sys_id} ne "")
1037         {
1038         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1039         }
1040
1041 unless ($disabled{asm}) {
1042     $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1043     $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1044
1045     # bn-586 is the only one implementing bn_*_part_words
1046     push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1047     push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1048
1049     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1050     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1051     push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1052
1053     if ($config{fips}) {
1054         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1055     }
1056
1057     if ($target{sha1_asm_src}) {
1058         push @{$config{defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1059         push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1060         push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1061     }
1062     if ($target{md5_asm_src}) {
1063         push @{$config{defines}}, "MD5_ASM";
1064     }
1065     $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1066     if ($target{rmd160_asm_src}) {
1067         push @{$config{defines}}, "RMD160_ASM";
1068     }
1069     if ($target{aes_asm_src}) {
1070         push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1071         # aes-ctr.fake is not a real file, only indication that assembler
1072         # module implements AES_ctr32_encrypt...
1073         push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1074         # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1075         push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1076         $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1077         push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1078         push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1079     }
1080     if ($target{wp_asm_src} =~ /mmx/) {
1081         if ($config{processor} eq "386") {
1082             $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1083         } elsif (!$disabled{"whirlpool"}) {
1084             push @{$config{defines}}, "WHIRLPOOL_ASM";
1085         }
1086     }
1087     if ($target{modes_asm_src} =~ /ghash-/) {
1088         push @{$config{defines}}, "GHASH_ASM";
1089     }
1090     if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1091         push @{$config{defines}}, "ECP_NISTZ256_ASM";
1092     }
1093     if ($target{poly1305_asm_src} ne "") {
1094         push @{$config{defines}}, "POLY1305_ASM";
1095     }
1096 }
1097
1098 my $ecc = $target{cc};
1099 if ($^O ne "VMS" && !$disabled{makedepend}) {
1100     # Is the compiler gcc or clang?  $ecc is used below to see if
1101     # error-checking can be turned on.
1102     my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1103     $config{makedepprog} = which('makedepend');
1104     open(PIPE, "$ccpcc --version 2>&1 | head -2 |");
1105     while ( <PIPE> ) {
1106         # Find the version number and save the major.
1107         m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
1108         # We know that GNU C version 3 and up as well as all clang
1109         # versions support dependency generation
1110         $config{makedepprog} = $ccpcc if /clang/ || (/gcc/ && $1 > 3);
1111         $ecc = "clang" if /clang/;
1112         $ecc = "gcc" if /gcc/;
1113     }
1114     close(PIPE);
1115
1116     $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1117 }
1118
1119
1120
1121 # Deal with bn_ops ###################################################
1122
1123 $config{bn_ll}                  =0;
1124 $config{export_var_as_fn}       =0;
1125 my $def_int="unsigned int";
1126 $config{rc4_int}                =$def_int;
1127 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1128
1129 my $count = 0;
1130 foreach (sort split(/\s+/,$target{bn_ops})) {
1131     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1132     $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1133     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1134     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1135     ($config{b64l},$config{b64},$config{b32})
1136         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1137     ($config{b64l},$config{b64},$config{b32})
1138         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1139     ($config{b64l},$config{b64},$config{b32})
1140         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1141 }
1142 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1143     if $count > 1;
1144
1145
1146 # Hack cflags for better warnings (dev option) #######################
1147
1148 # "Stringify" the C flags string.  This permits it to be made part of a string
1149 # and works as well on command lines.
1150 $config{cflags} =~ s/([\\\"])/\\\1/g;
1151
1152 if (defined($config{api})) {
1153     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1154     my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1155     push @{$config{defines}}, $apiflag;
1156 }
1157
1158 if ($strict_warnings)
1159         {
1160         my $wopt;
1161         die "ERROR --strict-warnings requires gcc or clang"
1162             unless $ecc eq 'gcc' || $ecc eq 'clang';
1163         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1164                 {
1165                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1166                 }
1167         if ($ecc eq "clang")
1168                 {
1169                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1170                         {
1171                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1172                         }
1173                 }
1174         }
1175
1176 unless ($disabled{"crypto-mdebug-backtrace"})
1177         {
1178         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1179                 {
1180                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1181                 }
1182         if ($target =~ /^BSD-/)
1183                 {
1184                 $config{ex_libs} .= " -lexecinfo";
1185                 }
1186         }
1187
1188 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1189 else                    { $no_user_cflags=1;  }
1190 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1191 else               { $no_user_defines=1;    }
1192
1193 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1194
1195 unless ($disabled{engine}) {
1196     $config{afalg}="";
1197     if ($target =~ m/^linux/) {
1198         my $minver = 4*10000 + 1*100 + 0;
1199         if ($config{cross_compile_prefix} eq "") {
1200             my $verstr = `uname -r`;
1201             my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1202             ($mi2) = $mi2 =~ /(\d+)/;
1203             my $ver = $ma*10000 + $mi1*100 + $mi2;
1204             if ($ver < $minver) {
1205                 $disabled{afalg} = "too-old-kernel";
1206             } else {
1207                 push @{$config{engdirs}}, "afalg";
1208             }
1209         }
1210     } else {
1211         $disabled{afalg}  = "not-linux";
1212     }
1213 }
1214
1215 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalg});
1216
1217 # If we use the unified build, collect information from build.info files
1218 my %unified_info = ();
1219
1220 if ($builder eq "unified") {
1221     # Store the name of the template file we will build the build file from
1222     # in %config.  This may be useful for the build file itself.
1223     my $build_file_template =
1224         catfile($srcdir, "Configurations",
1225                 $builder_platform."-".$target{build_file}.".tmpl");
1226     $build_file_template =
1227         catfile($srcdir, "Configurations", $target{build_file}.".tmpl")
1228         if (! -f $build_file_template);
1229     $config{build_file_template} = $build_file_template;
1230
1231     use lib catdir(dirname(__FILE__),"util");
1232     use with_fallback qw(Text::Template);
1233
1234     sub cleandir {
1235         my $base = shift;
1236         my $dir = shift;
1237         my $relativeto = shift || ".";
1238
1239         $dir = catdir($base,$dir) unless isabsolute($dir);
1240
1241         # Make sure the directories we're building in exists
1242         mkpath($dir);
1243
1244         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1245         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1246         return $res;
1247     }
1248
1249     sub cleanfile {
1250         my $base = shift;
1251         my $file = shift;
1252         my $relativeto = shift || ".";
1253
1254         $file = catfile($base,$file) unless isabsolute($file);
1255
1256         my $d = dirname($file);
1257         my $f = basename($file);
1258
1259         # Make sure the directories we're building in exists
1260         mkpath($d);
1261
1262         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1263         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1264         return $res;
1265     }
1266
1267     my @build_infos = ( [ ".", "build.info" ] );
1268     foreach (@{$config{dirs}}) {
1269         push @build_infos, [ $_, "build.info" ]
1270             if (-f catfile($srcdir, $_, "build.info"));
1271     }
1272     foreach (@{$config{sdirs}}) {
1273         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1274             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1275     }
1276     foreach (@{$config{engdirs}}) {
1277         push @build_infos, [ catdir("engines", $_), "build.info" ]
1278             if (-f catfile($srcdir, "engines", $_, "build.info"));
1279     }
1280
1281     $config{build_infos} = [ ];
1282
1283     foreach (@build_infos) {
1284         my $sourced = catdir($srcdir, $_->[0]);
1285         my $buildd = catdir($blddir, $_->[0]);
1286
1287         mkpath($buildd);
1288
1289         my $f = $_->[1];
1290         # The basic things we're trying to build
1291         my @programs = ();
1292         my @libraries = ();
1293         my @engines = ();
1294         my @scripts = ();
1295         my @extra = ();
1296         my @overrides = ();
1297         my @intermediates = ();
1298         my @rawlines = ();
1299
1300         my %ordinals = ();
1301         my %sources = ();
1302         my %includes = ();
1303         my %depends = ();
1304         my %renames = ();
1305         my %sharednames = ();
1306         my %generate = ();
1307
1308         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1309         my $template = Text::Template->new(TYPE => 'FILE',
1310                                            SOURCE => catfile($sourced, $f));
1311         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1312         my @text =
1313             split /^/m,
1314             $template->fill_in(HASH => { config => \%config,
1315                                          target => \%target,
1316                                          disabled => \%disabled,
1317                                          builddir => abs2rel($buildd, $blddir),
1318                                          sourcedir => abs2rel($sourced, $blddir),
1319                                          buildtop => abs2rel($blddir, $blddir),
1320                                          sourcetop => abs2rel($srcdir, $blddir) },
1321                                DELIMITERS => [ "{-", "-}" ]);
1322
1323         # The top item of this stack has the following values
1324         # -2 positive already run and we found ELSE (following ELSIF should fail)
1325         # -1 positive already run (skip until ENDIF)
1326         # 0 negatives so far (if we're at a condition, check it)
1327         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1328         # 2 positive ELSE (following ELSIF should fail)
1329         my @skip = ();
1330         collect_information(
1331             collect_from_array([ @text ],
1332                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1333                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1334             # Info we're looking for
1335             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1336             => sub { push @skip, !! $1; },
1337             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1338             => sub { die "ELSIF out of scope" if ! @skip;
1339                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1340                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1341                      $skip[$#skip] = !! $1
1342                          if $skip[$#skip] == 0; },
1343             qr/^\s*ELSE\s*$/
1344             => sub { die "ELSE out of scope" if ! @skip;
1345                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1346                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1347             qr/^\s*ENDIF\s*$/
1348             => sub { die "ENDIF out of scope" if ! @skip;
1349                      pop @skip; },
1350             qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
1351             => sub { push @programs, split(/\s+/, $1)
1352                          if !@skip || $skip[$#skip] > 0 },
1353             qr/^\s*LIBS\s*=\s*(.*)\s*$/
1354             => sub { push @libraries, split(/\s+/, $1)
1355                          if !@skip || $skip[$#skip] > 0 },
1356             qr/^\s*ENGINES\s*=\s*(.*)\s*$/
1357             => sub { push @engines, split(/\s+/, $1)
1358                          if !@skip || $skip[$#skip] > 0 },
1359             qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
1360             => sub { push @scripts, split(/\s+/, $1)
1361                          if !@skip || $skip[$#skip] > 0 },
1362             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1363             => sub { push @extra, split(/\s+/, $1)
1364                          if !@skip || $skip[$#skip] > 0 },
1365             qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1366             => sub { push @overrides, split(/\s+/, $1)
1367                          if !@skip || $skip[$#skip] > 0 },
1368
1369             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1370             => sub { push @{$ordinals{$1}}, split(/\s+/, $2)
1371                          if !@skip || $skip[$#skip] > 0 },
1372             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1373             => sub { push @{$sources{$1}}, split(/\s+/, $2)
1374                          if !@skip || $skip[$#skip] > 0 },
1375             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1376             => sub { push @{$includes{$1}}, split(/\s+/, $2)
1377                          if !@skip || $skip[$#skip] > 0 },
1378             qr/^\s*DEPEND\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1379             => sub { push @{$depends{$1}}, split(/\s+/, $2)
1380                          if !@skip || $skip[$#skip] > 0 },
1381             qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1382             => sub { push @{$generate{$1}}, $2
1383                          if !@skip || $skip[$#skip] > 0 },
1384             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1385             => sub { push @{$renames{$1}}, split(/\s+/, $2)
1386                          if !@skip || $skip[$#skip] > 0 },
1387             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1388             => sub { push @{$sharednames{$1}}, split(/\s+/, $2)
1389                          if !@skip || $skip[$#skip] > 0 },
1390             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1391             => sub {
1392                 my $lineiterator = shift;
1393                 my $target_kind = $1;
1394                 while (defined $lineiterator->()) {
1395                     s|\R$||;
1396                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1397                         die "ENDRAW doesn't match BEGINRAW"
1398                             if $1 ne $target_kind;
1399                         last;
1400                     }
1401                     next if @skip && $skip[$#skip] <= 0;
1402                     push @rawlines,  $_
1403                         if ($target_kind eq $target{build_file}
1404                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1405                 }
1406             },
1407             qr/^(?:#.*|\s*)$/ => sub { },
1408             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" }
1409             );
1410         die "runaway IF?" if (@skip);
1411
1412         foreach (keys %renames) {
1413             die "$_ renamed to more than one thing: "
1414                 ,join(" ", @{$renames{$_}}),"\n"
1415                 if scalar @{$renames{$_}} > 1;
1416             my $dest = cleanfile($buildd, $_, $blddir);
1417             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1418             die "$dest renamed to more than one thing: "
1419                 ,$unified_info{rename}->{$dest}, $to
1420                 unless !defined($unified_info{rename}->{$dest})
1421                 or $unified_info{rename}->{$dest} eq $to;
1422             $unified_info{rename}->{$dest} = $to;
1423         }
1424
1425         foreach (@programs) {
1426             my $program = cleanfile($buildd, $_, $blddir);
1427             if ($unified_info{rename}->{$program}) {
1428                 $program = $unified_info{rename}->{$program};
1429             }
1430             $unified_info{programs}->{$program} = 1;
1431         }
1432
1433         foreach (@libraries) {
1434             my $library = cleanfile($buildd, $_, $blddir);
1435             if ($unified_info{rename}->{$library}) {
1436                 $library = $unified_info{rename}->{$library};
1437             }
1438             $unified_info{libraries}->{$library} = 1;
1439         }
1440
1441         die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1442 ENGINES can only be used if configured with 'dynamic-engine'.
1443 This is usually a fault in a build.info file.
1444 EOF
1445         foreach (@engines) {
1446             my $library = cleanfile($buildd, $_, $blddir);
1447             if ($unified_info{rename}->{$library}) {
1448                 $library = $unified_info{rename}->{$library};
1449             }
1450             $unified_info{engines}->{$library} = 1;
1451         }
1452
1453         foreach (@scripts) {
1454             my $script = cleanfile($buildd, $_, $blddir);
1455             if ($unified_info{rename}->{$script}) {
1456                 $script = $unified_info{rename}->{$script};
1457             }
1458             $unified_info{scripts}->{$script} = 1;
1459         }
1460
1461         foreach (@extra) {
1462             my $extra = cleanfile($buildd, $_, $blddir);
1463             $unified_info{extra}->{$extra} = 1;
1464         }
1465
1466         foreach (@overrides) {
1467             my $override = cleanfile($buildd, $_, $blddir);
1468             $unified_info{overrides}->{$override} = 1;
1469         }
1470
1471         push @{$unified_info{rawlines}}, @rawlines;
1472
1473         unless ($disabled{shared}) {
1474             # Check sharednames.
1475             foreach (keys %sharednames) {
1476                 my $dest = cleanfile($buildd, $_, $blddir);
1477                 if ($unified_info{rename}->{$dest}) {
1478                     $dest = $unified_info{rename}->{$dest};
1479                 }
1480                 die "shared_name for $dest with multiple values: "
1481                     ,join(" ", @{$sharednames{$_}}),"\n"
1482                     if scalar @{$sharednames{$_}} > 1;
1483                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1484                 die "shared_name found for a library $dest that isn't defined\n"
1485                     unless $unified_info{libraries}->{$dest};
1486                 die "shared_name for $dest with multiple values: "
1487                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1488                     unless !defined($unified_info{sharednames}->{$dest})
1489                     or $unified_info{sharednames}->{$dest} eq $to;
1490                 $unified_info{sharednames}->{$dest} = $to;
1491             }
1492
1493             # Additionally, we set up sharednames for libraries that don't
1494             # have any, as themselves.
1495             foreach (keys %{$unified_info{libraries}}) {
1496                 if (!defined $unified_info{sharednames}->{$_}) {
1497                     $unified_info{sharednames}->{$_} = $_
1498                 }
1499             }
1500         }
1501
1502         foreach (keys %ordinals) {
1503             my $dest = $_;
1504             my $ddest = cleanfile($buildd, $_, $blddir);
1505             if ($unified_info{rename}->{$ddest}) {
1506                 $ddest = $unified_info{rename}->{$ddest};
1507             }
1508             foreach (@{$ordinals{$dest}}) {
1509                 my %known_ordinals =
1510                     (
1511                      crypto =>
1512                      cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1513                      ssl =>
1514                      cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1515                     );
1516                 my $o = $known_ordinals{$_};
1517                 die "Ordinals for $ddest defined more than once\n"
1518                     if $unified_info{ordinals}->{$ddest};
1519                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1520             }
1521         }
1522
1523         foreach (keys %sources) {
1524             my $dest = $_;
1525             my $ddest = cleanfile($buildd, $_, $blddir);
1526             if ($unified_info{rename}->{$ddest}) {
1527                 $ddest = $unified_info{rename}->{$ddest};
1528             }
1529             foreach (@{$sources{$dest}}) {
1530                 my $s = cleanfile($sourced, $_, $blddir);
1531
1532                 # If it isn't in the source tree, we assume it's generated
1533                 # in the build tree
1534                 if (! -f $s) {
1535                     $s = cleanfile($buildd, $_, $blddir);
1536                 }
1537                 # We recognise C and asm files
1538                 if ($s =~ /\.[csS]\b$/) {
1539                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1540                     $o = cleanfile($buildd, $o, $blddir);
1541                     $unified_info{sources}->{$ddest}->{$o} = 1;
1542                     $unified_info{sources}->{$o}->{$s} = 1;
1543                 } else {
1544                     $unified_info{sources}->{$ddest}->{$s} = 1;
1545                 }
1546             }
1547         }
1548
1549         foreach (keys %generate) {
1550             my $dest = $_;
1551             my $ddest = cleanfile($buildd, $_, $blddir);
1552             if ($unified_info{rename}->{$ddest}) {
1553                 $ddest = $unified_info{rename}->{$ddest};
1554             }
1555             die "more than one generator for $dest: "
1556                     ,join(" ", @{$generate{$_}}),"\n"
1557                     if scalar @{$generate{$_}} > 1;
1558             my @generator = split /\s+/, $generate{$dest}->[0];
1559             $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1560             $unified_info{generate}->{$ddest} = [ @generator ];
1561         }
1562
1563         foreach (keys %depends) {
1564             my $dest = $_;
1565             my $ddest = cleanfile($buildd, $_, $blddir);
1566             if ($unified_info{rename}->{$ddest}) {
1567                 $ddest = $unified_info{rename}->{$ddest};
1568             }
1569             foreach (@{$depends{$dest}}) {
1570                 my $d = cleanfile($sourced, $_, $blddir);
1571
1572                 # If we know it's generated, or assume it is because we can't
1573                 # find it in the source tree, we set file we depend on to be
1574                 # in the build tree rather than the source tree, and assume
1575                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1576                 # section or in the Makefile template.
1577                 if (! -f $d
1578                     || !(grep { $d eq $_ }
1579                          map { cleanfile($srcdir, $_, $blddir) }
1580                          (@generated_headers, @generated_by_make_headers))) {
1581                     $d = cleanfile($buildd, $_, $blddir);
1582                 }
1583                 # Take note if the file to depend on is being renamed
1584                 if ($unified_info{rename}->{$d}) {
1585                     $d = $unified_info{rename}->{$d};
1586                 }
1587                 $unified_info{depends}->{$ddest}->{$d} = 1;
1588                 # If we depend on a header file, let's make sure it
1589                 # can get included
1590                 if ($d =~ /\.h$/) {
1591                     my $i = dirname($d);
1592                     push @{$unified_info{includes}->{$ddest}}, $i
1593                         unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1594                 }
1595             }
1596         }
1597
1598         foreach (keys %includes) {
1599             my $dest = $_;
1600             my $ddest = cleanfile($buildd, $_, $blddir);
1601             if ($unified_info{rename}->{$ddest}) {
1602                 $ddest = $unified_info{rename}->{$ddest};
1603             }
1604             foreach (@{$includes{$dest}}) {
1605                 my $i = cleandir($sourced, $_, $blddir);
1606                 push @{$unified_info{includes}->{$ddest}}, $i
1607                     unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1608             }
1609         }
1610     }
1611
1612     ### Make unified_info a bit more efficient
1613     # One level structures
1614     foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1615         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1616     }
1617     # Two level structures
1618     foreach my $l1 (("sources", "ldadd", "depends")) {
1619         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1620             $unified_info{$l1}->{$l2} =
1621                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1622         }
1623     }
1624 }
1625
1626 # For the schemes that need it, we provide the old *_obj configs
1627 # from the *_asm_obj ones
1628 foreach (grep /_(asm|aux)_src$/, keys %target) {
1629     my $src = $_;
1630     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1631     ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1632 }
1633
1634 # Write down our configuration where it fits #########################
1635
1636 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1637 print OUT <<"EOF";
1638 package configdata;
1639
1640 use strict;
1641 use warnings;
1642
1643 use Exporter;
1644 #use vars qw(\@ISA \@EXPORT);
1645 our \@ISA = qw(Exporter);
1646 our \@EXPORT = qw(\%config \%target %disabled %withargs %unified_info);
1647
1648 EOF
1649 print OUT "our %config = (\n";
1650 foreach (sort keys %config) {
1651     if (ref($config{$_}) eq "ARRAY") {
1652         print OUT "  ", $_, " => [ ", join(", ",
1653                                            map { quotify("perl", $_) }
1654                                            @{$config{$_}}), " ],\n";
1655     } else {
1656         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1657     }
1658 }
1659 print OUT <<"EOF";
1660 );
1661
1662 EOF
1663 print OUT "our %target = (\n";
1664 foreach (sort keys %target) {
1665     if (ref($target{$_}) eq "ARRAY") {
1666         print OUT "  ", $_, " => [ ", join(", ",
1667                                            map { quotify("perl", $_) }
1668                                            @{$target{$_}}), " ],\n";
1669     } else {
1670         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1671     }
1672 }
1673 print OUT <<"EOF";
1674 );
1675
1676 EOF
1677 print OUT "our \%available_protocols = (\n";
1678 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1679 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1680 print OUT <<"EOF";
1681 );
1682
1683 EOF
1684 print OUT "our \%disabled = (\n";
1685 foreach (sort keys %disabled) {
1686     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1687 }
1688 print OUT <<"EOF";
1689 );
1690
1691 EOF
1692 print OUT "our %withargs = (\n";
1693 foreach (sort keys %withargs) {
1694     if (ref($withargs{$_}) eq "ARRAY") {
1695         print OUT "  ", $_, " => [ ", join(", ",
1696                                            map { quotify("perl", $_) }
1697                                            @{$withargs{$_}}), " ],\n";
1698     } else {
1699         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1700     }
1701 }
1702 print OUT <<"EOF";
1703 );
1704
1705 EOF
1706 if ($builder eq "unified") {
1707     my $recurse;
1708     $recurse = sub {
1709         my $indent = shift;
1710         foreach (@_) {
1711             if (ref $_ eq "ARRAY") {
1712                 print OUT " "x$indent, "[\n";
1713                 foreach (@$_) {
1714                     $recurse->($indent + 4, $_);
1715                 }
1716                 print OUT " "x$indent, "],\n";
1717             } elsif (ref $_ eq "HASH") {
1718                 my %h = %$_;
1719                 print OUT " "x$indent, "{\n";
1720                 foreach (sort keys %h) {
1721                     if (ref $h{$_} eq "") {
1722                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1723                     } else {
1724                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1725                         $recurse->($indent + 8, $h{$_});
1726                     }
1727                 }
1728                 print OUT " "x$indent, "},\n";
1729             } else {
1730                 print OUT " "x$indent, quotify("perl", $_), ",\n";
1731             }
1732         }
1733     };
1734     print OUT "our %unified_info = (\n";
1735     foreach (sort keys %unified_info) {
1736         if (ref $unified_info{$_} eq "") {
1737             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1738         } else {
1739             print OUT " "x4, quotify("perl", $_), " =>\n";
1740             $recurse->(8, $unified_info{$_});
1741         }
1742     }
1743     print OUT <<"EOF";
1744 );
1745
1746 EOF
1747 }
1748 print OUT "1;\n";
1749 close(OUT);
1750
1751
1752 print "IsMK1MF       =", ($builder eq "mk1mf" ? "yes" : "no"), "\n";
1753 print "CC            =$target{cc}\n";
1754 print "CFLAG         =$target{cflags} $config{cflags}\n";
1755 print "SHARED_CFLAG  =$target{shared_cflag}\n";
1756 print "DEFINES       =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
1757 print "LFLAG         =$target{lflags}\n";
1758 print "PLIB_LFLAG    =$target{plib_lflags}\n";
1759 print "EX_LIBS       =$target{ex_libs} $config{ex_libs}\n";
1760 print "APPS_OBJ      =$target{apps_obj}\n";
1761 print "CPUID_OBJ     =$target{cpuid_obj}\n";
1762 print "UPLINK_OBJ    =$target{uplink_obj}\n";
1763 print "BN_ASM        =$target{bn_obj}\n";
1764 print "EC_ASM        =$target{ec_obj}\n";
1765 print "DES_ENC       =$target{des_obj}\n";
1766 print "AES_ENC       =$target{aes_obj}\n";
1767 print "BF_ENC        =$target{bf_obj}\n";
1768 print "CAST_ENC      =$target{cast_obj}\n";
1769 print "RC4_ENC       =$target{rc4_obj}\n";
1770 print "RC5_ENC       =$target{rc5_obj}\n";
1771 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
1772 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
1773 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1774 print "CMLL_ENC      =$target{cmll_obj}\n";
1775 print "MODES_OBJ     =$target{modes_obj}\n";
1776 print "PADLOCK_OBJ   =$target{padlock_obj}\n";
1777 print "CHACHA_ENC    =$target{chacha_obj}\n";
1778 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
1779 print "PROCESSOR     =$config{processor}\n";
1780 print "RANLIB        =$target{ranlib}\n";
1781 print "ARFLAGS       =$target{arflags}\n";
1782 print "PERL          =$config{perl}\n";
1783 print "\n";
1784 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1785 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1786 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1787 print "BN_LLONG mode\n" if $config{bn_ll};
1788 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int;
1789
1790 for (@generated_headers) {
1791     mkpath(catdir($blddir, dirname($_)));
1792     run_dofile(catfile($blddir, $_),
1793                catfile($srcdir, $_.".in"));
1794 }
1795
1796 ###
1797 ### When the old "unixmake" scheme goes away, so does this function
1798 ###
1799 sub build_Makefile {
1800     run_dofile("Makefile","Makefile.in");
1801
1802     # Copy all Makefile.in to Makefile (except top-level)
1803     use File::Find;
1804     use IO::File;
1805     find(
1806         {
1807             preprocess => sub {
1808                 grep(!/^\./, @_);
1809             },
1810             wanted => sub {
1811                 return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1812                 my $in = IO::File->new($_, "r") or
1813                     die sprintf "Error reading Makefile.in in %s: !$\n",
1814                     $File::Find::dir;
1815                 my $out = IO::File->new("Makefile", "w") or
1816                     die sprintf "Error writing Makefile in %s: !$\n",
1817                     $File::Find::dir;
1818                 print $out "# Generated from $_, do not edit\n";
1819                 while (my $line = <$in>) { print $out $line }
1820                 $in->close() or
1821                     die sprintf "Error reading Makefile.in in %s: !$\n",
1822                     $File::Find::dir;
1823                 $out->close() or
1824                     die sprintf "Error writing Makefile in %s: !$\n",
1825                     $File::Find::dir;
1826             },
1827         },
1828         ".");
1829 }
1830
1831 my %builders = (
1832     unified => sub {
1833         run_dofile(catfile($blddir, $target{build_file}),
1834                    $config{build_file_template},
1835                    catfile($srcdir, "Configurations", "common.tmpl"));
1836     },
1837     unixmake => sub {
1838         build_Makefile();
1839
1840         run_dofile("util/domd", "util/domd.in");
1841         chmod 0755, "util/domd";
1842     },
1843     mk1mf => sub {
1844         my $platform = shift;
1845         # The only reason we do this is to have something to build MINFO from
1846         build_Makefile();
1847
1848         # create the ms/version32.rc file if needed
1849         if ($platform ne "netware") {
1850             my ($v1, $v2, $v3, $v4);
1851             if ($config{version_num} =~ /^0x([0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{1})L$/i) {
1852                 $v1=hex $1;
1853                 $v2=hex $2;
1854                 $v3=hex $3;
1855                 $v4=hex $4;
1856             }
1857             open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1858             print OUT <<"EOF";
1859 #include <winver.h>
1860
1861 LANGUAGE 0x09,0x01
1862
1863 1 VERSIONINFO
1864   FILEVERSION $v1,$v2,$v3,$v4
1865   PRODUCTVERSION $v1,$v2,$v3,$v4
1866   FILEFLAGSMASK 0x3fL
1867 #ifdef _DEBUG
1868   FILEFLAGS 0x01L
1869 #else
1870   FILEFLAGS 0x00L
1871 #endif
1872   FILEOS VOS__WINDOWS32
1873   FILETYPE VFT_DLL
1874   FILESUBTYPE 0x0L
1875 BEGIN
1876     BLOCK "StringFileInfo"
1877     BEGIN
1878         BLOCK "040904b0"
1879         BEGIN
1880             // Required:
1881             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1882             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1883             VALUE "FileVersion", "$config{version}\\0"
1884 #if defined(CRYPTO)
1885             VALUE "InternalName", "libcrypto32\\0"
1886             VALUE "OriginalFilename", "libcrypto32.dll\\0"
1887 #elif defined(SSL)
1888             VALUE "InternalName", "libssl32\\0"
1889             VALUE "OriginalFilename", "libssl32.dll\\0"
1890 #endif
1891             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1892             VALUE "ProductVersion", "$config{version}\\0"
1893             // Optional:
1894             //VALUE "Comments", "\\0"
1895             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1896             //VALUE "LegalTrademarks", "\\0"
1897             //VALUE "PrivateBuild", "\\0"
1898             //VALUE "SpecialBuild", "\\0"
1899         END
1900     END
1901     BLOCK "VarFileInfo"
1902     BEGIN
1903         VALUE "Translation", 0x409, 0x4b0
1904     END
1905 END
1906 EOF
1907             close(OUT);
1908         }
1909     },
1910     );
1911
1912 $builders{$builder}->($builder_platform, @builder_opts);
1913
1914 print <<"EOF";
1915
1916 Configured for $target.
1917 EOF
1918
1919 print <<"EOF" if ($disabled{threads} eq "unavailable");
1920
1921 The library could not be configured for supporting multi-threaded
1922 applications as the compiler options required on this system are not known.
1923 See file INSTALL for details if you need multi-threading.
1924 EOF
1925
1926 print <<"EOF" if ($no_shared_warn);
1927
1928 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1929 platform, so we will pretend you gave the option 'no-pic', which also disables
1930 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
1931 or position independent code, please let us know (but please first make sure
1932 you have tried with a current version of OpenSSL).
1933 EOF
1934
1935 exit(0);
1936
1937 ######################################################################
1938 #
1939 # Helpers and utility functions
1940 #
1941
1942 # Configuration file reading #########################################
1943
1944 # Helper function to implement conditional inheritance depending on the
1945 # value of $disabled{asm}.  Used in inherit_from values as follows:
1946 #
1947 #      inherit_from => [ "template", asm("asm_tmpl") ]
1948 #
1949 sub asm {
1950     my @x = @_;
1951     sub {
1952         $disabled{asm} ? () : @x;
1953     }
1954 }
1955
1956 our $add_called = 0;
1957 # Helper function to implement adding values to already existing configuration
1958 # values.  It handles elements that are ARRAYs, CODEs and scalars
1959 sub _add {
1960     my $separator = shift;
1961
1962     # If there's any ARRAY in the collection of values OR the separator
1963     # is undef, we will return an ARRAY of combined values, otherwise a
1964     # string of joined values with $separator as the separator.
1965     my $found_array = !defined($separator);
1966
1967     my @values =
1968         map {
1969             my $res = $_;
1970             while (ref($res) eq "CODE") {
1971                 $res = $res->();
1972             }
1973             if (defined($res)) {
1974                 if (ref($res) eq "ARRAY") {
1975                     $found_array = 1;
1976                     @$res;
1977                 } else {
1978                     $res;
1979                 }
1980             } else {
1981                 ();
1982             }
1983     } (@_);
1984
1985     $add_called = 1;
1986
1987     if ($found_array) {
1988         [ @values ];
1989     } else {
1990         join($separator, grep { defined($_) && $_ ne "" } @values);
1991     }
1992 }
1993 sub add_before {
1994     my $separator = " ";
1995     if (ref($_[$#_]) eq "HASH") {
1996         my $opts = pop;
1997         $separator = $opts->{separator};
1998     }
1999     my @x = @_;
2000     sub { _add($separator, @x, @_) };
2001 }
2002 sub add {
2003     my $separator = " ";
2004     if (ref($_[$#_]) eq "HASH") {
2005         my $opts = pop;
2006         $separator = $opts->{separator};
2007     }
2008     my @x = @_;
2009     sub { _add($separator, @_, @x) };
2010 }
2011
2012 # configuration reader, evaluates the input file as a perl script and expects
2013 # it to fill %targets with target configurations.  Those are then added to
2014 # %table.
2015 sub read_config {
2016     my $fname = shift;
2017     open(CONFFILE, "< $fname")
2018         or die "Can't open configuration file '$fname'!\n";
2019     my $x = $/;
2020     undef $/;
2021     my $content = <CONFFILE>;
2022     $/ = $x;
2023     close(CONFFILE);
2024     my %targets = ();
2025     {
2026         local %table = %::table;    # Protect %table from tampering
2027
2028         eval $content;
2029         warn $@ if $@;
2030     }
2031
2032     # For each target, check that it's configured with a hash table.
2033     foreach (keys %targets) {
2034         if (ref($targets{$_}) ne "HASH") {
2035             if (ref($targets{$_}) eq "") {
2036                 warn "Deprecated target configuration for $_, ignoring...\n";
2037             } else {
2038                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2039             }
2040             delete $targets{$_};
2041         }
2042     }
2043
2044     %table = (%table, %targets);
2045
2046 }
2047
2048 # configuration resolver.  Will only resolve all the lazy evalutation
2049 # codeblocks for the chozen target and all those it inherits from,
2050 # recursively
2051 sub resolve_config {
2052     my $target = shift;
2053     my @breadcrumbs = @_;
2054
2055     my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2056
2057     if (grep { $_ eq $target } @breadcrumbs) {
2058         die "inherit_from loop!  target backtrace:\n  "
2059             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2060     }
2061
2062     if (!defined($table{$target})) {
2063         warn "Warning! target $target doesn't exist!\n";
2064         return ();
2065     }
2066     # Recurse through all inheritances.  They will be resolved on the
2067     # fly, so when this operation is done, they will all just be a
2068     # bunch of attributes with string values.
2069     # What we get here, though, are keys with references to lists of
2070     # the combined values of them all.  We will deal with lists after
2071     # this stage is done.
2072     my %combined_inheritance = ();
2073     if ($table{$target}->{inherit_from}) {
2074         my @inherit_from =
2075             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2076         foreach (@inherit_from) {
2077             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2078
2079             # 'template' is a marker that's considered private to
2080             # the config that had it.
2081             delete $inherited_config{template};
2082
2083             map {
2084                 if (!$combined_inheritance{$_}) {
2085                     $combined_inheritance{$_} = [];
2086                 }
2087                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2088             } keys %inherited_config;
2089         }
2090     }
2091
2092     # We won't need inherit_from in this target any more, since we've
2093     # resolved all the inheritances that lead to this
2094     delete $table{$target}->{inherit_from};
2095
2096     # Now is the time to deal with those lists.  Here's the place to
2097     # decide what shall be done with those lists, all based on the
2098     # values of the target we're currently dealing with.
2099     # - If a value is a coderef, it will be executed with the list of
2100     #   inherited values as arguments.
2101     # - If the corresponding key doesn't have a value at all or is the
2102     #   emoty string, the inherited value list will be run through the
2103     #   default combiner (below), and the result becomes this target's
2104     #   value.
2105     # - Otherwise, this target's value is assumed to be a string that
2106     #   will simply override the inherited list of values.
2107     my $default_combiner = add();
2108
2109     my %all_keys =
2110         map { $_ => 1 } (keys %combined_inheritance,
2111                          keys %{$table{$target}});
2112
2113     sub process_values {
2114         my $object    = shift;
2115         my $inherited = shift;  # Always a [ list ]
2116         my $target    = shift;
2117         my $entry     = shift;
2118
2119         $add_called = 0;
2120
2121         while(ref($object) eq "CODE") {
2122             $object = $object->(@$inherited);
2123         }
2124         if (!defined($object)) {
2125             return ();
2126         }
2127         elsif (ref($object) eq "ARRAY") {
2128             local $add_called;  # To make sure recursive calls don't affect it
2129             return [ map { process_values($_, $inherited, $target, $entry) }
2130                      @$object ];
2131         } elsif (ref($object) eq "") {
2132             return $object;
2133         } else {
2134             die "cannot handle reference type ",ref($object)
2135                 ," found in target ",$target," -> ",$entry,"\n";
2136         }
2137     }
2138
2139     foreach (sort keys %all_keys) {
2140         my $previous = $combined_inheritance{$_};
2141
2142         # Current target doesn't have a value for the current key?
2143         # Assign it the default combiner, the rest of this loop body
2144         # will handle it just like any other coderef.
2145         if (!exists $table{$target}->{$_}) {
2146             $table{$target}->{$_} = $default_combiner;
2147         }
2148
2149         $table{$target}->{$_} = process_values($table{$target}->{$_},
2150                                                $combined_inheritance{$_},
2151                                                $target, $_);
2152         unless(defined($table{$target}->{$_})) {
2153             delete $table{$target}->{$_};
2154         }
2155         if ($extra_checks &&
2156             $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
2157             warn "$_ got replaced in $target\n";
2158         }
2159     }
2160
2161     # Finally done, return the result.
2162     return %{$table{$target}};
2163 }
2164
2165 sub usage
2166         {
2167         print STDERR $usage;
2168         print STDERR "\npick os/compiler from:\n";
2169         my $j=0;
2170         my $i;
2171         my $k=0;
2172         foreach $i (sort keys %table)
2173                 {
2174                 next if $table{$i}->{template};
2175                 next if $i =~ /^debug/;
2176                 $k += length($i) + 1;
2177                 if ($k > 78)
2178                         {
2179                         print STDERR "\n";
2180                         $k=length($i);
2181                         }
2182                 print STDERR $i . " ";
2183                 }
2184         foreach $i (sort keys %table)
2185                 {
2186                 next if $table{$i}->{template};
2187                 next if $i !~ /^debug/;
2188                 $k += length($i) + 1;
2189                 if ($k > 78)
2190                         {
2191                         print STDERR "\n";
2192                         $k=length($i);
2193                         }
2194                 print STDERR $i . " ";
2195                 }
2196         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2197         exit(1);
2198         }
2199
2200 sub run_dofile()
2201 {
2202     my $out = shift;
2203     my @templates = @_;
2204
2205     unlink $out || warn "Can't remove $out, $!"
2206         if -f $out;
2207     foreach (@templates) {
2208         die "Can't open $_, $!" unless -f $_;
2209     }
2210     my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2211     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2212     system($cmd);
2213     exit 1 if $? != 0;
2214     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2215 }
2216
2217 # Configuration printer ##############################################
2218
2219 sub print_table_entry
2220 {
2221     my $target = shift;
2222     my %target = resolve_config($target);
2223     my $type = shift;
2224
2225     # Don't print the templates
2226     return if $target{template};
2227
2228     my @sequence = (
2229         "sys_id",
2230         "cc",
2231         "cflags",
2232         "defines",
2233         "unistd",
2234         "ld",
2235         "lflags",
2236         "plib_lflags",
2237         "ex_libs",
2238         "bn_ops",
2239         "cpuid_obj",
2240         "bn_obj",
2241         "ec_obj",
2242         "des_obj",
2243         "aes_obj",
2244         "bf_obj",
2245         "md5_obj",
2246         "sha1_obj",
2247         "cast_obj",
2248         "rc4_obj",
2249         "rmd160_obj",
2250         "rc5_obj",
2251         "wp_obj",
2252         "cmll_obj",
2253         "modes_obj",
2254         "padlock_obj",
2255         "thread_scheme",
2256         "perlasm_scheme",
2257         "dso_scheme",
2258         "shared_target",
2259         "shared_cflag",
2260         "shared_ldflag",
2261         "shared_rcflag",
2262         "shared_extension",
2263         "shared_extension_simple",
2264         "shared_import_extension",
2265         "dso_extension",
2266         "obj_extension",
2267         "exe_extension",
2268         "ranlib",
2269         "ar",
2270         "arflags",
2271         "multilib",
2272         "build_scheme",
2273         );
2274
2275     if ($type eq "TABLE") {
2276         print "\n";
2277         print "*** $target\n";
2278         foreach (@sequence) {
2279             if (ref($target{$_}) eq "ARRAY") {
2280                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2281             } else {
2282                 printf "\$%-12s = %s\n", $_, $target{$_};
2283             }
2284         }
2285     } elsif ($type eq "HASH") {
2286         my $largest =
2287             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2288         print "    '$target' => {\n";
2289         foreach (@sequence) {
2290             if ($target{$_}) {
2291                 if (ref($target{$_}) eq "ARRAY") {
2292                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2293                 } else {
2294                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2295                 }
2296             }
2297         }
2298         print "    },\n";
2299     }
2300 }
2301
2302 # Utility routines ###################################################
2303
2304 # On VMS, if the given file is a logical name, File::Spec::Functions
2305 # will consider it an absolute path.  There are cases when we want a
2306 # purely syntactic check without checking the environment.
2307 sub isabsolute {
2308     my $file = shift;
2309
2310     # On non-platforms, we just use file_name_is_absolute().
2311     return file_name_is_absolute($file) unless $^O eq "VMS";
2312
2313     # If the file spec includes a device or a directpry spec,
2314     # file_name_is_absolute() is perfectly safe.
2315     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2316
2317     # Here, we know the given file spec isn't absolute
2318     return 0;
2319 }
2320
2321 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2322 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2323 # realpath() requires that at least all path components except the last is an
2324 # existing directory.  On VMS, the last component of the directory spec must
2325 # exist.
2326 sub absolutedir {
2327     my $dir = shift;
2328
2329     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2330     # will return the volume name for the device, no matter what.  Also,
2331     # it will return an incorrect directory spec if the argument is a
2332     # directory that doesn't exist.
2333     if ($^O eq "VMS") {
2334         return rel2abs($dir);
2335     }
2336
2337     # We use realpath() on Unix, since no other will properly clean out
2338     # a directory spec.
2339     use Cwd qw/realpath/;
2340
2341     return realpath($dir);
2342 }
2343
2344 sub which
2345         {
2346         my($name)=@_;
2347         my $path;
2348         foreach $path (split /:/, $ENV{PATH})
2349                 {
2350                 my $fullpath = "$path/$name$target{exe_extension}";
2351                 if (-f $fullpath and -x $fullpath)
2352                         {
2353                         return $fullpath
2354                             unless ($name eq "perl" and
2355                                     system("$fullpath -e " . '\'exit($]<5.0);\''));
2356                         }
2357                 }
2358         }
2359
2360 sub quotify {
2361     my %processors = (
2362         perl    => sub { my $x = shift;
2363                          $x =~ s/([\\\$\@"])/\\$1/g;
2364                          return '"'.$x.'"'; },
2365         );
2366     my $for = shift;
2367     my $processor =
2368         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2369
2370     map { $processor->($_); } @_;
2371 }
2372
2373 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2374 # $filename is a file name to read from
2375 # $line_concat_cond_re is a regexp detecting a line continuation ending
2376 # $line_concat is a CODEref that takes care of concatenating two lines
2377 sub collect_from_file {
2378     my $filename = shift;
2379     my $line_concat_cond_re = shift;
2380     my $line_concat = shift;
2381
2382     open my $fh, $filename || die "unable to read $filename: $!\n";
2383     return sub {
2384         my $saved_line = "";
2385         $_ = "";
2386         while (<$fh>) {
2387             s|\R$||;
2388             if (defined $line_concat) {
2389                 $_ = $line_concat->($saved_line, $_);
2390                 $saved_line = "";
2391             }
2392             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2393                 $saved_line = $_;
2394                 next;
2395             }
2396             return $_;
2397         }
2398         die "$filename ending with continuation line\n" if $_;
2399         close $fh;
2400         return undef;
2401     }
2402 }
2403
2404 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2405 # $array is an ARRAYref of lines
2406 # $line_concat_cond_re is a regexp detecting a line continuation ending
2407 # $line_concat is a CODEref that takes care of concatenating two lines
2408 sub collect_from_array {
2409     my $array = shift;
2410     my $line_concat_cond_re = shift;
2411     my $line_concat = shift;
2412     my @array = (@$array);
2413
2414     return sub {
2415         my $saved_line = "";
2416         $_ = "";
2417         while (defined($_ = shift @array)) {
2418             s|\R$||;
2419             if (defined $line_concat) {
2420                 $_ = $line_concat->($saved_line, $_);
2421                 $saved_line = "";
2422             }
2423             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2424                 $saved_line = $_;
2425                 next;
2426             }
2427             return $_;
2428         }
2429         die "input text ending with continuation line\n" if $_;
2430         return undef;
2431     }
2432 }
2433
2434 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2435 # $lineiterator is a CODEref that delivers one line at a time.
2436 # All following arguments are regex/CODEref pairs, where the regexp detects a
2437 # line and the CODEref does something with the result of the regexp.
2438 sub collect_information {
2439     my $lineiterator = shift;
2440     my %collectors = @_;
2441
2442     while(defined($_ = $lineiterator->())) {
2443         s|\R$||;
2444         my $found = 0;
2445         foreach my $re (keys %collectors) {
2446             if ($re ne "OTHERWISE" && /$re/) {
2447                 $collectors{$re}->($lineiterator);
2448                 $found = 1;
2449             };
2450         }
2451         if ($collectors{"OTHERWISE"}) {
2452             $collectors{"OTHERWISE"}->($lineiterator, $_)
2453                 unless $found || !defined $collectors{"OTHERWISE"};
2454         }
2455     }
2456 }