Configure

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