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