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