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