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