Configure

   1 #! /usr/bin/env perl
   2 # -*- mode: perl; -*-
   3
   4 ##
   5 ##  Configure -- OpenSSL source tree configuration script
   6 ##  If editing this file, run this command before committing
   7 ##      make -f Makefile.in TABLE
   8 ##
   9
  10 require 5.000;
  11 use strict;
  12 use File::Basename;
  13 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
  14 use File::Path qw/mkpath/;
  15
  16 # see INSTALL for instructions.
  17
  18 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  19
  20 # Options:
  21 #
  22 # --config      add the given configuration file, which will be read after
  23 #               any "Configurations*" files that are found in the same
  24 #               directory as this script.
  25 # --prefix      prefix for the OpenSSL installation, which includes the
  26 #               directories bin, lib, include, share/man, share/doc/openssl
  27 #               This becomes the value of INSTALLTOP in Makefile
  28 #               (Default: /usr/local)
  29 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  30 #               If it's a relative directory, it will be added on the directory
  31 #               given with --prefix.
  32 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  33 #               (Default: PREFIX/ssl)
  34 #
  35 # --cross-compile-prefix Add specified prefix to binutils components.
  36 #
  37 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
  38 #               interfaces deprecated as of the specified OpenSSL version.
  39 #
  40 # no-hw-xxx     do not compile support for specific crypto hardware.
  41 #               Generic OpenSSL-style methods relating to this support
  42 #               are always compiled but return NULL if the hardware
  43 #               support isn't compiled.
  44 # no-hw         do not compile support for any crypto hardware.
  45 # [no-]threads  [don't] try to create a library that is suitable for
  46 #               multithreaded applications (default is "threads" if we
  47 #               know how to do it)
  48 # [no-]shared   [don't] try to create shared libraries when supported.
  49 # [no-]pic      [don't] try to build position independent code when supported.
  50 #               If disabled, it also disables shared and dynamic-engine.
  51 # no-asm        do not use assembler
  52 # no-dso        do not compile in any native shared-library methods. This
  53 #               will ensure that all methods just return NULL.
  54 # no-egd        do not compile support for the entropy-gathering daemon APIs
  55 # [no-]zlib     [don't] compile support for zlib compression.
  56 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  57 #               library and will be loaded in run-time by the OpenSSL library.
  58 # sctp          include SCTP support
  59 # 386           generate 80386 code
  60 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
  61 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  62 # -<xxx> +<xxx> compiler options are passed through
  63 #
  64 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
  65 #               provided to stack calls. Generates unique stack functions for
  66 #               each possible stack type.
  67 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
  68 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  69 # Following are set automatically by this script
  70 #
  71 # MD5_ASM       use some extra md5 assember,
  72 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
  73 # RMD160_ASM    use some extra ripemd160 assember,
  74 # SHA256_ASM    sha256_block is implemented in assembler
  75 # SHA512_ASM    sha512_block is implemented in assembler
  76 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
  77
  78 # Minimum warning options... any contributions to OpenSSL should at least get
  79 # past these.
  80
  81 my $gcc_devteam_warn = "-DPEDANTIC -DREF_DEBUG -DDEBUG_UNUSED -DBIO_DEBUG"
  82         . " -pedantic"
  83         . " -Wall"
  84         . " -Wno-long-long"
  85         . " -Wsign-compare"
  86         . " -Wmissing-prototypes"
  87         . " -Wshadow"
  88         . " -Wformat"
  89         . " -Wtype-limits"
  90         . " -Werror"
  91         ;
  92
  93 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
  94 # TODO(openssl-team): fix problems and investigate if (at least) the
  95 # following warnings can also be enabled:
  96 #       -Wswitch-enum
  97 #       -Wcast-align
  98 #       -Wunreachable-code
  99 #       -Wlanguage-extension-token -- no, we use asm()
 100 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
 101 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
 102 my $clang_devteam_warn = ""
 103         . " -Qunused-arguments"
 104         . " -Wextra"
 105         . " -Wno-unused-parameter"
 106         . " -Wno-missing-field-initializers"
 107         . " -Wno-language-extension-token"
 108         . " -Wno-extended-offsetof"
 109         . " -Wconditional-uninitialized"
 110         . " -Wincompatible-pointer-types-discards-qualifiers"
 111         . " -Wmissing-variable-declarations"
 112         ;
 113
 114 # This adds backtrace information to the memory leak info.  Is only used
 115 # when crypto-mdebug-backtrace is enabled.
 116 my $memleak_devteam_backtrace = "-rdynamic";
 117
 118 my $strict_warnings = 0;
 119
 120 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 121 # which would cover all BSD flavors. -pthread applies to them all,
 122 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 123 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 124 # which has to be accompanied by explicit -D_THREAD_SAFE and
 125 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 126 # seems to be sufficient?
 127 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 128
 129 #
 130 # API compability name to version number mapping.
 131 #
 132 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
 133 my $apitable = {
 134     "1.1.0" => "0x10100000L",
 135     "1.0.0" => "0x10000000L",
 136     "0.9.8" => "0x00908000L",
 137 };
 138
 139 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-/ || /^async$/
 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 else
1046         {
1047         push @{$config{defines}}, "OPENSSL_PIC";
1048         }
1049
1050 if ($target{sys_id} ne "")
1051         {
1052         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1053         }
1054
1055 if ($target{ranlib} eq "")
1056         {
1057         $target{ranlib} = $default_ranlib;
1058         }
1059
1060 unless ($disabled{asm}) {
1061     $target{cpuid_asm_src}=$table{BASE}->{cpuid_asm_src} if ($config{processor} eq "386");
1062     $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1063
1064     # bn-586 is the only one implementing bn_*_part_words
1065     push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1066     push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1067
1068     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1069     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1070     push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1071
1072     if ($config{fips}) {
1073         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1074     }
1075
1076     if ($target{sha1_asm_src}) {
1077         push @{$config{defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1078         push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1079         push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1080     }
1081     if ($target{md5_asm_src}) {
1082         push @{$config{defines}}, "MD5_ASM";
1083     }
1084     $target{cast_asm_src}=$table{BASE}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1085     if ($target{rmd160_asm_src}) {
1086         push @{$config{defines}}, "RMD160_ASM";
1087     }
1088     if ($target{aes_asm_src}) {
1089         push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1090         # aes-ctr.fake is not a real file, only indication that assembler
1091         # module implements AES_ctr32_encrypt...
1092         push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1093         # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1094         push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1095         $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1096         push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1097         push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1098     }
1099     if ($target{wp_asm_src} =~ /mmx/) {
1100         if ($config{processor} eq "386") {
1101             $target{wp_asm_src}=$table{BASE}->{wp_asm_src};
1102         } elsif (!$disabled{"whirlpool"}) {
1103             $config{cflags}.=" -DWHIRLPOOL_ASM";
1104         }
1105     }
1106     if ($target{modes_asm_src} =~ /ghash-/) {
1107         push @{$config{defines}}, "GHASH_ASM";
1108     }
1109     if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1110         push @{$config{defines}}, "ECP_NISTZ256_ASM";
1111     }
1112     if ($target{poly1305_asm_src} ne "") {
1113         push @{$config{defines}}, "POLY1305_ASM";
1114     }
1115 }
1116
1117 my $ecc = $target{cc};
1118 if ($^O ne "VMS") {
1119     # Is the compiler gcc or clang?  $ecc is used below to see if
1120     # error-checking can be turned on.
1121     my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1122     $config{makedepprog} = 'makedepend';
1123     open(PIPE, "$ccpcc --version 2>&1 | head -2 |");
1124     while ( <PIPE> ) {
1125         $config{makedepprog} = $ccpcc if /clang|gcc/;
1126         $ecc = "clang" if /clang/;
1127         $ecc = "gcc" if /gcc/;
1128     }
1129     close(PIPE);
1130 }
1131
1132
1133 # Deal with bn_ops ###################################################
1134
1135 $config{bn_ll}                  =0;
1136 $config{export_var_as_fn}       =0;
1137 my $def_int="unsigned int";
1138 $config{rc4_int}                =$def_int;
1139 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1140
1141 my $count = 0;
1142 foreach (sort split(/\s+/,$target{bn_ops})) {
1143     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1144     $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1145     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1146     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1147     ($config{b64l},$config{b64},$config{b32})
1148         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1149     ($config{b64l},$config{b64},$config{b32})
1150         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1151     ($config{b64l},$config{b64},$config{b32})
1152         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1153 }
1154 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1155     if $count > 1;
1156
1157
1158 # Hack cflags for better warnings (dev option) #######################
1159
1160 # "Stringify" the C flags string.  This permits it to be made part of a string
1161 # and works as well on command lines.
1162 $config{cflags} =~ s/([\\\"])/\\\1/g;
1163
1164 if (defined($config{api})) {
1165     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1166     my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1167     push @{$config{defines}}, $apiflag;
1168 }
1169
1170 if ($strict_warnings)
1171         {
1172         my $wopt;
1173         die "ERROR --strict-warnings requires gcc or clang"
1174             unless $ecc eq 'gcc' || $ecc eq 'clang';
1175         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1176                 {
1177                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1178                 }
1179         if ($ecc eq "clang")
1180                 {
1181                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1182                         {
1183                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1184                         }
1185                 }
1186         }
1187
1188 unless ($disabled{"crypto-mdebug-backtrace"})
1189         {
1190         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1191                 {
1192                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1193                 }
1194         if ($target =~ /^BSD-/)
1195                 {
1196                 $config{ex_libs} .= " -lexecinfo";
1197                 }
1198         }
1199
1200 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1201 else                    { $no_user_cflags=1;  }
1202 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1203 else               { $no_user_defines=1;    }
1204
1205 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1206
1207 # If we use the unified build, collect information from build.info files
1208 my %unified_info = ();
1209
1210 if ($builder eq "unified") {
1211     # Store the name of the template file we will build the build file from
1212     # in %config.  This may be useful for the build file itself.
1213     my $build_file_template =
1214         catfile($srcdir, "Configurations",
1215                 $builder_platform."-".$target{build_file}.".tmpl");
1216     $build_file_template =
1217         catfile($srcdir, "Configurations", $target{build_file}.".tmpl")
1218         if (! -f $build_file_template);
1219     $config{build_file_template} = $build_file_template;
1220
1221     use lib catdir(dirname(__FILE__),"util");
1222     use with_fallback qw(Text::Template);
1223
1224     sub cleandir {
1225         my $base = shift;
1226         my $dir = shift;
1227         my $relativeto = shift || ".";
1228
1229         $dir = catdir($base,$dir) unless isabsolute($dir);
1230
1231         # Make sure the directories we're building in exists
1232         mkpath($dir);
1233
1234         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1235         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1236         return $res;
1237     }
1238
1239     sub cleanfile {
1240         my $base = shift;
1241         my $file = shift;
1242         my $relativeto = shift || ".";
1243
1244         $file = catfile($base,$file) unless isabsolute($file);
1245
1246         my $d = dirname($file);
1247         my $f = basename($file);
1248
1249         # Make sure the directories we're building in exists
1250         mkpath($d);
1251
1252         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1253         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1254         return $res;
1255     }
1256
1257     my @build_infos = ( [ ".", "build.info" ] );
1258     foreach (@{$config{dirs}}) {
1259         push @build_infos, [ $_, "build.info" ]
1260             if (-f catfile($srcdir, $_, "build.info"));
1261     }
1262     foreach (@{$config{sdirs}}) {
1263         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1264             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1265     }
1266     foreach (@{$config{engdirs}}) {
1267         push @build_infos, [ catdir("engines", $_), "build.info" ]
1268             if (-f catfile($srcdir, "engines", $_, "build.info"));
1269     }
1270
1271     foreach (@build_infos) {
1272         my $sourced = catdir($srcdir, $_->[0]);
1273         my $buildd = catdir($blddir, $_->[0]);
1274
1275         mkpath($buildd);
1276
1277         my $f = $_->[1];
1278         # The basic things we're trying to build
1279         my @programs = ();
1280         my @libraries = ();
1281         my @engines = ();
1282         my @scripts = ();
1283         my @extra = ();
1284         my @intermediates = ();
1285         my @rawlines = ();
1286
1287         my %ordinals = ();
1288         my %sources = ();
1289         my %includes = ();
1290         my %depends = ();
1291         my %renames = ();
1292         my %sharednames = ();
1293
1294         my $template = Text::Template->new(TYPE => 'FILE',
1295                                            SOURCE => catfile($sourced, $f));
1296         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1297         my @text =
1298             split /^/m,
1299             $template->fill_in(HASH => { config => \%config,
1300                                          target => \%target,
1301                                          disabled => \%disabled,
1302                                          builddir => abs2rel($buildd, $blddir),
1303                                          sourcedir => abs2rel($sourced, $blddir),
1304                                          buildtop => abs2rel($blddir, $blddir),
1305                                          sourcetop => abs2rel($srcdir, $blddir) },
1306                                DELIMITERS => [ "{-", "-}" ]);
1307
1308         # The top item of this stack has the following values
1309         # -2 positive already run and we found ELSE (following ELSIF should fail)
1310         # -1 positive already run (skip until ENDIF)
1311         # 0 negatives so far (if we're at a condition, check it)
1312         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1313         # 2 positive ELSE (following ELSIF should fail)
1314         my @skip = ();
1315         collect_information(
1316             collect_from_array([ @text ],
1317                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1318                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1319             # Info we're looking for
1320             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1321             => sub { push @skip, !! $1; },
1322             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1323             => sub { die "ELSIF out of scope" if ! @skip;
1324                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1325                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1326                      $skip[$#skip] = !! $1
1327                          if $skip[$#skip] == 0; },
1328             qr/^\s*ELSE\s*$/
1329             => sub { die "ELSE out of scope" if ! @skip;
1330                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1331                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1332             qr/^\s*ENDIF\s*$/
1333             => sub { die "ENDIF out of scope" if ! @skip;
1334                      pop @skip; },
1335             qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
1336             => sub { push @programs, split(/\s+/, $1)
1337                          if !@skip || $skip[$#skip] > 0 },
1338             qr/^\s*LIBS\s*=\s*(.*)\s*$/
1339             => sub { push @libraries, split(/\s+/, $1)
1340                          if !@skip || $skip[$#skip] > 0 },
1341             qr/^\s*ENGINES\s*=\s*(.*)\s*$/
1342             => sub { push @engines, split(/\s+/, $1)
1343                          if !@skip || $skip[$#skip] > 0 },
1344             qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
1345             => sub { push @scripts, split(/\s+/, $1)
1346                          if !@skip || $skip[$#skip] > 0 },
1347             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1348             => sub { push @extra, split(/\s+/, $1)
1349                          if !@skip || $skip[$#skip] > 0 },
1350
1351             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1352             => sub { push @{$ordinals{$1}}, split(/\s+/, $2)
1353                          if !@skip || $skip[$#skip] > 0 },
1354             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1355             => sub { push @{$sources{$1}}, split(/\s+/, $2)
1356                          if !@skip || $skip[$#skip] > 0 },
1357             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1358             => sub { push @{$includes{$1}}, split(/\s+/, $2)
1359                          if !@skip || $skip[$#skip] > 0 },
1360             qr/^\s*DEPEND\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1361             => sub { push @{$depends{$1}}, split(/\s+/, $2)
1362                          if !@skip || $skip[$#skip] > 0 },
1363             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1364             => sub { push @{$renames{$1}}, split(/\s+/, $2)
1365                          if !@skip || $skip[$#skip] > 0 },
1366             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1367             => sub { push @{$sharednames{$1}}, split(/\s+/, $2)
1368                          if !@skip || $skip[$#skip] > 0 },
1369             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1370             => sub {
1371                 my $lineiterator = shift;
1372                 my $target_kind = $1;
1373                 while (defined $lineiterator->()) {
1374                     s|\R$||;
1375                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1376                         die "ENDRAW doesn't match BEGINRAW"
1377                             if $1 ne $target_kind;
1378                         last;
1379                     }
1380                     next if @skip && $skip[$#skip] <= 0;
1381                     push @rawlines,  $_
1382                         if ($target_kind eq $target{build_file}
1383                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1384                 }
1385             },
1386             qr/^(?:#.*|\s*)$/ => sub { },
1387             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" }
1388             );
1389         die "runaway IF?" if (@skip);
1390
1391         foreach (keys %renames) {
1392             die "$_ renamed to more than one thing: "
1393                 ,join(" ", @{$renames{$_}}),"\n"
1394                 if scalar @{$renames{$_}} > 1;
1395             my $dest = cleanfile($buildd, $_, $blddir);
1396             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1397             die "$dest renamed to more than one thing: "
1398                 ,$unified_info{rename}->{$dest}, $to
1399                 unless !defined($unified_info{rename}->{$dest})
1400                 or $unified_info{rename}->{$dest} eq $to;
1401             $unified_info{rename}->{$dest} = $to;
1402         }
1403
1404         foreach (@programs) {
1405             my $program = cleanfile($buildd, $_, $blddir);
1406             if ($unified_info{rename}->{$program}) {
1407                 $program = $unified_info{rename}->{$program};
1408             }
1409             $unified_info{programs}->{$program} = 1;
1410         }
1411
1412         foreach (@libraries) {
1413             my $library = cleanfile($buildd, $_, $blddir);
1414             if ($unified_info{rename}->{$library}) {
1415                 $library = $unified_info{rename}->{$library};
1416             }
1417             $unified_info{libraries}->{$library} = 1;
1418         }
1419
1420         die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1421 ENGINES can only be used if configured with 'dynamic-engine'.
1422 This is usually a fault in a build.info file.
1423 EOF
1424         foreach (@engines) {
1425             my $library = cleanfile($buildd, $_, $blddir);
1426             if ($unified_info{rename}->{$library}) {
1427                 $library = $unified_info{rename}->{$library};
1428             }
1429             $unified_info{engines}->{$library} = 1;
1430         }
1431
1432         foreach (@scripts) {
1433             my $script = cleanfile($buildd, $_, $blddir);
1434             if ($unified_info{rename}->{$script}) {
1435                 $script = $unified_info{rename}->{$script};
1436             }
1437             $unified_info{scripts}->{$script} = 1;
1438         }
1439
1440         foreach (@extra) {
1441             my $extra = cleanfile($buildd, $_, $blddir);
1442             $unified_info{extra}->{$extra} = 1;
1443         }
1444
1445         push @{$unified_info{rawlines}}, @rawlines;
1446
1447         unless ($disabled{shared}) {
1448             # Check sharednames.
1449             foreach (keys %sharednames) {
1450                 my $dest = cleanfile($buildd, $_, $blddir);
1451                 if ($unified_info{rename}->{$dest}) {
1452                     $dest = $unified_info{rename}->{$dest};
1453                 }
1454                 die "shared_name for $dest with multiple values: "
1455                     ,join(" ", @{$sharednames{$_}}),"\n"
1456                     if scalar @{$sharednames{$_}} > 1;
1457                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1458                 die "shared_name found for a library $dest that isn't defined\n"
1459                     unless $unified_info{libraries}->{$dest};
1460                 die "shared_name for $dest with multiple values: "
1461                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1462                     unless !defined($unified_info{sharednames}->{$dest})
1463                     or $unified_info{sharednames}->{$dest} eq $to;
1464                 $unified_info{sharednames}->{$dest} = $to;
1465             }
1466
1467             # Additionally, we set up sharednames for libraries that don't
1468             # have any, as themselves.
1469             foreach (keys %{$unified_info{libraries}}) {
1470                 if (!defined $unified_info{sharednames}->{$_}) {
1471                     $unified_info{sharednames}->{$_} = $_
1472                 }
1473             }
1474         }
1475
1476         foreach (keys %ordinals) {
1477             my $dest = $_;
1478             my $ddest = cleanfile($buildd, $_, $blddir);
1479             if ($unified_info{rename}->{$ddest}) {
1480                 $ddest = $unified_info{rename}->{$ddest};
1481             }
1482             foreach (@{$ordinals{$dest}}) {
1483                 my %known_ordinals =
1484                     (
1485                      crypto =>
1486                      cleanfile($sourced, catfile("util", "libeay.num"), $blddir),
1487                      ssl =>
1488                      cleanfile($sourced, catfile("util", "ssleay.num"), $blddir)
1489                     );
1490                 my $o = $known_ordinals{$_};
1491                 die "Ordinals for $ddest defined more than once\n"
1492                     if $unified_info{ordinals}->{$ddest};
1493                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1494             }
1495         }
1496
1497         foreach (keys %sources) {
1498             my $dest = $_;
1499             my $ddest = cleanfile($buildd, $_, $blddir);
1500             if ($unified_info{rename}->{$ddest}) {
1501                 $ddest = $unified_info{rename}->{$ddest};
1502             }
1503             foreach (@{$sources{$dest}}) {
1504                 my $s = cleanfile($sourced, $_, $blddir);
1505
1506                 # If it isn't in the source tree, we assume it's generated
1507                 # in the build tree
1508                 if (! -f $s) {
1509                     $s = cleanfile($buildd, $_, $blddir);
1510                 }
1511                 # We recognise C and asm files
1512                 if ($s =~ /\.[csS]\b$/) {
1513                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1514                     $o = cleanfile($buildd, $o, $blddir);
1515                     $unified_info{sources}->{$ddest}->{$o} = 1;
1516                     $unified_info{sources}->{$o}->{$s} = 1;
1517                 } else {
1518                     $unified_info{sources}->{$ddest}->{$s} = 1;
1519                 }
1520             }
1521         }
1522
1523         foreach (keys %depends) {
1524             my $dest = $_;
1525             my $ddest = cleanfile($buildd, $_, $blddir);
1526             if ($unified_info{rename}->{$ddest}) {
1527                 $ddest = $unified_info{rename}->{$ddest};
1528             }
1529             foreach (@{$depends{$dest}}) {
1530                 my $d = cleanfile($sourced, $_, $blddir);
1531
1532                 # If we know it's generated, or assume it is because we can't
1533                 # find it in the source tree, we set file we depend on to be
1534                 # in the build tree rather than the source tree, and assume
1535                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1536                 # section or in the Makefile template.
1537                 if (! -f $d
1538                     || !(grep { $d eq $_ }
1539                          map { cleanfile($srcdir, $_, $blddir) }
1540                          (@generated_headers, @generated_by_make_headers))) {
1541                     $d = cleanfile($buildd, $_, $blddir);
1542                 }
1543                 # Take note if the file to depend on is being renamed
1544                 if ($unified_info{rename}->{$d}) {
1545                     $d = $unified_info{rename}->{$d};
1546                 }
1547                 $unified_info{depends}->{$ddest}->{$d} = 1;
1548                 # If we depend on a header file, let's make sure it
1549                 # can get included
1550                 if ($d =~ /\.h$/) {
1551                     my $i = dirname($d);
1552                     push @{$unified_info{includes}->{$ddest}}, $i
1553                         unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1554                 }
1555             }
1556         }
1557
1558         foreach (keys %includes) {
1559             my $dest = $_;
1560             my $ddest = cleanfile($buildd, $_, $blddir);
1561             if ($unified_info{rename}->{$ddest}) {
1562                 $ddest = $unified_info{rename}->{$ddest};
1563             }
1564             foreach (@{$includes{$dest}}) {
1565                 my $i = cleandir($sourced, $_, $blddir);
1566                 push @{$unified_info{includes}->{$ddest}}, $i
1567                     unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1568             }
1569         }
1570     }
1571
1572     ### Make unified_info a bit more efficient
1573     # One level structures
1574     foreach (("programs", "libraries", "engines", "scripts", "extra")) {
1575         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1576     }
1577     # Two level structures
1578     foreach my $l1 (("sources", "ldadd", "depends")) {
1579         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1580             $unified_info{$l1}->{$l2} =
1581                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1582         }
1583     }
1584 }
1585
1586 # For the schemes that need it, we provide the old *_obj configs
1587 # from the *_asm_obj ones
1588 foreach (grep /_(asm|aux)_src$/, keys %target) {
1589     my $src = $_;
1590     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1591     ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1592 }
1593
1594 # Write down our configuration where it fits #########################
1595
1596 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1597 print OUT <<"EOF";
1598 package configdata;
1599
1600 use strict;
1601 use warnings;
1602
1603 use Exporter;
1604 #use vars qw(\@ISA \@EXPORT);
1605 our \@ISA = qw(Exporter);
1606 our \@EXPORT = qw(\%config \%target %disabled %withargs %unified_info);
1607
1608 EOF
1609 print OUT "our %config = (\n";
1610 foreach (sort keys %config) {
1611     if (ref($config{$_}) eq "ARRAY") {
1612         print OUT "  ", $_, " => [ ", join(", ",
1613                                            map { quotify("perl", $_) }
1614                                            @{$config{$_}}), " ],\n";
1615     } else {
1616         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1617     }
1618 }
1619 print OUT <<"EOF";
1620 );
1621
1622 EOF
1623 print OUT "our %target = (\n";
1624 foreach (sort keys %target) {
1625     if (ref($target{$_}) eq "ARRAY") {
1626         print OUT "  ", $_, " => [ ", join(", ",
1627                                            map { quotify("perl", $_) }
1628                                            @{$target{$_}}), " ],\n";
1629     } else {
1630         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1631     }
1632 }
1633 print OUT <<"EOF";
1634 );
1635
1636 EOF
1637 print OUT "our \%available_protocols = (\n";
1638 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1639 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1640 print OUT <<"EOF";
1641 );
1642
1643 EOF
1644 print OUT "our \%disabled = (\n";
1645 foreach (sort keys %disabled) {
1646     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1647 }
1648 print OUT <<"EOF";
1649 );
1650
1651 EOF
1652 print OUT "our %withargs = (\n";
1653 foreach (sort keys %withargs) {
1654     if (ref($withargs{$_}) eq "ARRAY") {
1655         print OUT "  ", $_, " => [ ", join(", ",
1656                                            map { quotify("perl", $_) }
1657                                            @{$withargs{$_}}), " ],\n";
1658     } else {
1659         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1660     }
1661 }
1662 print OUT <<"EOF";
1663 );
1664
1665 EOF
1666 if ($builder eq "unified") {
1667     my $recurse;
1668     $recurse = sub {
1669         my $indent = shift;
1670         foreach (@_) {
1671             if (ref $_ eq "ARRAY") {
1672                 print OUT " "x$indent, "[\n";
1673                 foreach (@$_) {
1674                     $recurse->($indent + 4, $_);
1675                 }
1676                 print OUT " "x$indent, "],\n";
1677             } elsif (ref $_ eq "HASH") {
1678                 my %h = %$_;
1679                 print OUT " "x$indent, "{\n";
1680                 foreach (sort keys %h) {
1681                     if (ref $h{$_} eq "") {
1682                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1683                     } else {
1684                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1685                         $recurse->($indent + 8, $h{$_});
1686                     }
1687                 }
1688                 print OUT " "x$indent, "},\n";
1689             } else {
1690                 print OUT " "x$indent, quotify("perl", $_), ",\n";
1691             }
1692         }
1693     };
1694     print OUT "our %unified_info = (\n";
1695     foreach (sort keys %unified_info) {
1696         if (ref $unified_info{$_} eq "") {
1697             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1698         } else {
1699             print OUT " "x4, quotify("perl", $_), " =>\n";
1700             $recurse->(8, $unified_info{$_});
1701         }
1702     }
1703     print OUT <<"EOF";
1704 );
1705
1706 EOF
1707 }
1708 print OUT "1;\n";
1709 close(OUT);
1710
1711
1712 print "IsMK1MF       =", ($builder eq "mk1mf" ? "yes" : "no"), "\n";
1713 print "CC            =$target{cc}\n";
1714 print "CFLAG         =$config{cflags}\n";
1715 print "DEFINES       =",join(" ", @{$config{defines}}),"\n";
1716 print "LFLAG         =$config{lflags}\n";
1717 print "PLIB_LFLAG    =$config{plib_lflags}\n";
1718 print "EX_LIBS       =$config{ex_libs}\n";
1719 print "CPUID_OBJ     =$target{cpuid_obj}\n";
1720 print "BN_ASM        =$target{bn_obj}\n";
1721 print "EC_ASM        =$target{ec_obj}\n";
1722 print "DES_ENC       =$target{des_obj}\n";
1723 print "AES_ENC       =$target{aes_obj}\n";
1724 print "BF_ENC        =$target{bf_obj}\n";
1725 print "CAST_ENC      =$target{cast_obj}\n";
1726 print "RC4_ENC       =$target{rc4_obj}\n";
1727 print "RC5_ENC       =$target{rc5_obj}\n";
1728 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
1729 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
1730 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1731 print "CMLL_ENC      =$target{cmll_obj}\n";
1732 print "MODES_OBJ     =$target{modes_obj}\n";
1733 print "PADLOCK_OBJ   =$target{padlock_obj}\n";
1734 print "CHACHA_ENC    =$target{chacha_obj}\n";
1735 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
1736 print "PROCESSOR     =$config{processor}\n";
1737 print "RANLIB        =$target{ranlib}\n";
1738 print "ARFLAGS       =$target{arflags}\n";
1739 print "PERL          =$config{perl}\n";
1740 print "\n";
1741 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1742 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1743 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1744 print "BN_LLONG mode\n" if $config{bn_ll};
1745 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int;
1746
1747 for (@generated_headers) {
1748     mkpath(catdir($blddir, dirname($_)));
1749     run_dofile(catfile($blddir, $_),
1750                catfile($srcdir, $_.".in"));
1751 }
1752
1753 ###
1754 ### When the old "unixmake" scheme goes away, so does this function
1755 ###
1756 sub build_Makefile {
1757     run_dofile("Makefile","Makefile.in");
1758
1759     # Copy all Makefile.in to Makefile (except top-level)
1760     use File::Find;
1761     use IO::File;
1762     find(
1763         {
1764             preprocess => sub {
1765                 grep(!/^\./, @_);
1766             },
1767             wanted => sub {
1768                 return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1769                 my $in = IO::File->new($_, "r") or
1770                     die sprintf "Error reading Makefile.in in %s: !$\n",
1771                     $File::Find::dir;
1772                 my $out = IO::File->new("Makefile", "w") or
1773                     die sprintf "Error writing Makefile in %s: !$\n",
1774                     $File::Find::dir;
1775                 print $out "# Generated from $_, do not edit\n";
1776                 while (my $line = <$in>) { print $out $line }
1777                 $in->close() or
1778                     die sprintf "Error reading Makefile.in in %s: !$\n",
1779                     $File::Find::dir;
1780                 $out->close() or
1781                     die sprintf "Error writing Makefile in %s: !$\n",
1782                     $File::Find::dir;
1783             },
1784         },
1785         ".");
1786 }
1787
1788 my %builders = (
1789     unified => sub {
1790         run_dofile(catfile($blddir, $target{build_file}),
1791                    $config{build_file_template},
1792                    catfile($srcdir, "Configurations", "common.tmpl"));
1793     },
1794     unixmake => sub {
1795         build_Makefile();
1796
1797         run_dofile("util/domd", "util/domd.in");
1798         chmod 0755, "util/domd";
1799     },
1800     mk1mf => sub {
1801         my $platform = shift;
1802         # The only reason we do this is to have something to build MINFO from
1803         build_Makefile();
1804
1805         # create the ms/version32.rc file if needed
1806         if ($platform ne "netware") {
1807             my ($v1, $v2, $v3, $v4);
1808             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) {
1809                 $v1=hex $1;
1810                 $v2=hex $2;
1811                 $v3=hex $3;
1812                 $v4=hex $4;
1813             }
1814             open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1815             print OUT <<"EOF";
1816 #include <winver.h>
1817
1818 LANGUAGE 0x09,0x01
1819
1820 1 VERSIONINFO
1821   FILEVERSION $v1,$v2,$v3,$v4
1822   PRODUCTVERSION $v1,$v2,$v3,$v4
1823   FILEFLAGSMASK 0x3fL
1824 #ifdef _DEBUG
1825   FILEFLAGS 0x01L
1826 #else
1827   FILEFLAGS 0x00L
1828 #endif
1829   FILEOS VOS__WINDOWS32
1830   FILETYPE VFT_DLL
1831   FILESUBTYPE 0x0L
1832 BEGIN
1833     BLOCK "StringFileInfo"
1834     BEGIN
1835         BLOCK "040904b0"
1836         BEGIN
1837             // Required:
1838             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1839             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1840             VALUE "FileVersion", "$config{version}\\0"
1841 #if defined(CRYPTO)
1842             VALUE "InternalName", "libeay32\\0"
1843             VALUE "OriginalFilename", "libeay32.dll\\0"
1844 #elif defined(SSL)
1845             VALUE "InternalName", "ssleay32\\0"
1846             VALUE "OriginalFilename", "ssleay32.dll\\0"
1847 #endif
1848             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1849             VALUE "ProductVersion", "$config{version}\\0"
1850             // Optional:
1851             //VALUE "Comments", "\\0"
1852             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1853             //VALUE "LegalTrademarks", "\\0"
1854             //VALUE "PrivateBuild", "\\0"
1855             //VALUE "SpecialBuild", "\\0"
1856         END
1857     END
1858     BLOCK "VarFileInfo"
1859     BEGIN
1860         VALUE "Translation", 0x409, 0x4b0
1861     END
1862 END
1863 EOF
1864             close(OUT);
1865         }
1866     },
1867     );
1868
1869 $builders{$builder}->($builder_platform, @builder_opts);
1870
1871 print <<"EOF";
1872
1873 Configured for $target.
1874 EOF
1875
1876 print <<"EOF" if (!$disabled{threads} && !$threads);
1877
1878 The library could not be configured for supporting multi-threaded
1879 applications as the compiler options required on this system are not known.
1880 See file INSTALL for details if you need multi-threading.
1881 EOF
1882
1883 print <<"EOF" if ($no_shared_warn);
1884
1885 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1886 platform, so we will pretend you gave the option 'no-pic', which also disables
1887 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
1888 or position independent code, please let us know (but please first make sure
1889 you have tried with a current version of OpenSSL).
1890 EOF
1891
1892 ###### TO BE REMOVED BEFORE FINAL RELEASE
1893 ######
1894 ###### If the user hasn't chosen --unified, try to nudge them.
1895 if ($target{build_file} eq "Makefile"
1896     && $target{build_scheme}->[0] eq "unixmake"
1897     && !$unified) {
1898
1899     my $plausible_builddir =
1900         abs2rel(rel2abs("../_openssl-build_$target"),rel2abs("."));
1901     my $plausible_to_sourcedir =
1902         abs2rel(rel2abs("."),rel2abs("../_openssl-build_$target"));
1903     print <<"EOF";
1904
1905 ----------------------------------------------------------------------
1906 Please consider configuring with the flag --unified .
1907 It's to test out a new "unified" building system.
1908
1909 One cool feature is that you can have your build directory elsewhere,
1910 for example:
1911
1912     make clean          # Clean the current configuration away
1913     mkdir $plausible_builddir
1914     cd $plausible_builddir
1915     $plausible_to_sourcedir/config --unified
1916     make
1917     make test
1918
1919 Please report any problem you have.
1920 ----------------------------------------------------------------------
1921
1922 EOF
1923 }
1924
1925 exit(0);
1926
1927 ######################################################################
1928 #
1929 # Helpers and utility functions
1930 #
1931
1932 # Configuration file reading #########################################
1933
1934 # Helper function to implement conditional inheritance depending on the
1935 # value of $disabled{asm}.  Used in inherit_from values as follows:
1936 #
1937 #      inherit_from => [ "template", asm("asm_tmpl") ]
1938 #
1939 sub asm {
1940     my @x = @_;
1941     sub {
1942         $disabled{asm} ? () : @x;
1943     }
1944 }
1945
1946 # Helper function to implement adding values to already existing configuration
1947 # values.  It handles elements that are ARRAYs, CODEs and scalars
1948 sub _add {
1949     my $separator = shift;
1950
1951     # If there's any ARRAY in the collection of values OR the separator
1952     # is undef, we will return an ARRAY of combined values, otherwise a
1953     # string of joined values with $separator as the separator.
1954     my $found_array = !defined($separator);
1955
1956     my @values =
1957         map {
1958             if (ref($_) eq "ARRAY") {
1959                 $found_array = 1;
1960                 @$_;
1961             } else {
1962                 $_;
1963             }
1964     } (@_);
1965
1966     if ($found_array) {
1967         [ @values ];
1968     } else {
1969         join($separator, @values);
1970     }
1971 }
1972 sub add_before {
1973     my $separator = " ";
1974     if (ref($_[$#_]) eq "HASH") {
1975         my $opts = pop;
1976         $separator = $opts->{separator};
1977     }
1978     my @x = @_;
1979     sub { _add($separator, @x, @_) };
1980 }
1981 sub add {
1982     my $separator = " ";
1983     if (ref($_[$#_]) eq "HASH") {
1984         my $opts = pop;
1985         $separator = $opts->{separator};
1986     }
1987     my @x = @_;
1988     sub { _add($separator, @_, @x) };
1989 }
1990
1991 # configuration reader, evaluates the input file as a perl script and expects
1992 # it to fill %targets with target configurations.  Those are then added to
1993 # %table.
1994 sub read_config {
1995     my $fname = shift;
1996     open(CONFFILE, "< $fname")
1997         or die "Can't open configuration file '$fname'!\n";
1998     my $x = $/;
1999     undef $/;
2000     my $content = <CONFFILE>;
2001     $/ = $x;
2002     close(CONFFILE);
2003     my %targets = ();
2004     {
2005         local %table = %::table;    # Protect %table from tampering
2006
2007         eval $content;
2008         warn $@ if $@;
2009     }
2010
2011     # For each target, check that it's configured with a hash table.
2012     foreach (keys %targets) {
2013         if (ref($targets{$_}) ne "HASH") {
2014             if (ref($targets{$_}) eq "") {
2015                 warn "Deprecated target configuration for $_, ignoring...\n";
2016             } else {
2017                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2018             }
2019             delete $targets{$_};
2020         }
2021     }
2022
2023     %table = (%table, %targets);
2024
2025 }
2026
2027 # configuration resolver.  Will only resolve all the lazy evalutation
2028 # codeblocks for the chozen target and all those it inherits from,
2029 # recursively
2030 sub resolve_config {
2031     my $target = shift;
2032     my @breadcrumbs = @_;
2033
2034     if (grep { $_ eq $target } @breadcrumbs) {
2035         die "inherit_from loop!  target backtrace:\n  "
2036             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2037     }
2038
2039     if (!defined($table{$target})) {
2040         warn "Warning! target $target doesn't exist!\n";
2041         return ();
2042     }
2043     # Recurse through all inheritances.  They will be resolved on the
2044     # fly, so when this operation is done, they will all just be a
2045     # bunch of attributes with string values.
2046     # What we get here, though, are keys with references to lists of
2047     # the combined values of them all.  We will deal with lists after
2048     # this stage is done.
2049     my %combined_inheritance = ();
2050     if ($table{$target}->{inherit_from}) {
2051         my @inherit_from =
2052             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2053         foreach (@inherit_from) {
2054             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2055
2056             # 'template' is a marker that's considered private to
2057             # the config that had it.
2058             delete $inherited_config{template};
2059
2060             map {
2061                 if (!$combined_inheritance{$_}) {
2062                     $combined_inheritance{$_} = [];
2063                 }
2064                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2065             } keys %inherited_config;
2066         }
2067     }
2068
2069     # We won't need inherit_from in this target any more, since we've
2070     # resolved all the inheritances that lead to this
2071     delete $table{$target}->{inherit_from};
2072
2073     # Now is the time to deal with those lists.  Here's the place to
2074     # decide what shall be done with those lists, all based on the
2075     # values of the target we're currently dealing with.
2076     # - If a value is a coderef, it will be executed with the list of
2077     #   inherited values as arguments.
2078     # - If the corresponding key doesn't have a value at all or is the
2079     #   emoty string, the inherited value list will be run through the
2080     #   default combiner (below), and the result becomes this target's
2081     #   value.
2082     # - Otherwise, this target's value is assumed to be a string that
2083     #   will simply override the inherited list of values.
2084     my $default_combiner = add();
2085
2086     my %all_keys =
2087         map { $_ => 1 } (keys %combined_inheritance,
2088                          keys %{$table{$target}});
2089     foreach (sort keys %all_keys) {
2090
2091         # Current target doesn't have a value for the current key?
2092         # Assign it the default combiner, the rest of this loop body
2093         # will handle it just like any other coderef.
2094         if (!exists $table{$target}->{$_}) {
2095             $table{$target}->{$_} = $default_combiner;
2096         }
2097
2098         my $valuetype = ref($table{$target}->{$_});
2099         if ($valuetype eq "CODE") {
2100             # CODE reference, execute it with the inherited values as
2101             # arguments.
2102             $table{$target}->{$_} =
2103                 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
2104         } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
2105             # ARRAY or Scalar, just leave it as is.
2106         } else {
2107             # Some other type of reference that we don't handle.
2108             # Better to abort at this point.
2109             die "cannot handle reference type $valuetype,"
2110                 ," found in target $target -> $_\n";
2111         }
2112     }
2113
2114     # Finally done, return the result.
2115     return %{$table{$target}};
2116 }
2117
2118 sub usage
2119         {
2120         print STDERR $usage;
2121         print STDERR "\npick os/compiler from:\n";
2122         my $j=0;
2123         my $i;
2124         my $k=0;
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         foreach $i (sort keys %table)
2138                 {
2139                 next if $table{$i}->{template};
2140                 next if $i !~ /^debug/;
2141                 $k += length($i) + 1;
2142                 if ($k > 78)
2143                         {
2144                         print STDERR "\n";
2145                         $k=length($i);
2146                         }
2147                 print STDERR $i . " ";
2148                 }
2149         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2150         exit(1);
2151         }
2152
2153 sub run_dofile()
2154 {
2155     my $out = shift;
2156     my @templates = @_;
2157
2158     unlink $out || warn "Can't remove $out, $!"
2159         if -f $out;
2160     foreach (@templates) {
2161         die "Can't open $_, $!" unless -f $_;
2162     }
2163     my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2164     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2165     system($cmd);
2166     exit 1 if $? != 0;
2167     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2168 }
2169
2170 # Configuration printer ##############################################
2171
2172 sub print_table_entry
2173 {
2174     my $target = shift;
2175     my %target = resolve_config($target);
2176     my $type = shift;
2177
2178     # Don't print the templates
2179     return if $target{template};
2180
2181     my @sequence = (
2182         "sys_id",
2183         "cc",
2184         "cflags",
2185         "defines",
2186         "debug_cflags",
2187         "debug_defines",
2188         "release_cflags",
2189         "release_defines",
2190         "thread_cflag",
2191         "unistd",
2192         "ld",
2193         "lflags",
2194         "plib_lflags",
2195         "ex_libs",
2196         "debug_lflags",
2197         "debug_plib_lflags",
2198         "debug_ex_libs",
2199         "release_lflags",
2200         "release_plib_lflags",
2201         "release_ex_libs",
2202         "bn_ops",
2203         "cpuid_obj",
2204         "bn_obj",
2205         "ec_obj",
2206         "des_obj",
2207         "aes_obj",
2208         "bf_obj",
2209         "md5_obj",
2210         "sha1_obj",
2211         "cast_obj",
2212         "rc4_obj",
2213         "rmd160_obj",
2214         "rc5_obj",
2215         "wp_obj",
2216         "cmll_obj",
2217         "modes_obj",
2218         "padlock_obj",
2219         "perlasm_scheme",
2220         "dso_scheme",
2221         "shared_target",
2222         "shared_cflag",
2223         "shared_ldflag",
2224         "shared_rcflag",
2225         "shared_extension",
2226         "shared_extension_simple",
2227         "shared_import_extension",
2228         "dso_extension",
2229         "obj_extension",
2230         "exe_extension",
2231         "ranlib",
2232         "ar",
2233         "arflags",
2234         "multilib",
2235         "build_scheme",
2236         );
2237
2238     if ($type eq "TABLE") {
2239         print "\n";
2240         print "*** $target\n";
2241         foreach (@sequence) {
2242             if (ref($target{$_}) eq "ARRAY") {
2243                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2244             } else {
2245                 printf "\$%-12s = %s\n", $_, $target{$_};
2246             }
2247         }
2248     } elsif ($type eq "HASH") {
2249         my $largest =
2250             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2251         print "    '$target' => {\n";
2252         foreach (@sequence) {
2253             if ($target{$_}) {
2254                 if (ref($target{$_}) eq "ARRAY") {
2255                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2256                 } else {
2257                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2258                 }
2259             }
2260         }
2261         print "    },\n";
2262     }
2263 }
2264
2265 # Utility routines ###################################################
2266
2267 # On VMS, if the given file is a logical name, File::Spec::Functions
2268 # will consider it an absolute path.  There are cases when we want a
2269 # purely syntactic check without checking the environment.
2270 sub isabsolute {
2271     my $file = shift;
2272
2273     # On non-platforms, we just use file_name_is_absolute().
2274     return file_name_is_absolute($file) unless $^O eq "VMS";
2275
2276     # If the file spec includes a device or a directpry spec,
2277     # file_name_is_absolute() is perfectly safe.
2278     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2279
2280     # Here, we know the given file spec isn't absolute
2281     return 0;
2282 }
2283
2284 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2285 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2286 # realpath() requires that at least all path components except the last is an
2287 # existing directory.  On VMS, the last component of the directory spec must
2288 # exist.
2289 sub absolutedir {
2290     my $dir = shift;
2291
2292     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2293     # will return the volume name for the device, no matter what.  Also,
2294     # it will return an incorrect directory spec if the argument is a
2295     # directory that doesn't exist.
2296     if ($^O eq "VMS") {
2297         return rel2abs($dir);
2298     }
2299
2300     # We use realpath() on Unix, since no other will properly clean out
2301     # a directory spec.
2302     use Cwd qw/realpath/;
2303
2304     return realpath($dir);
2305 }
2306
2307 sub which
2308         {
2309         my($name)=@_;
2310         my $path;
2311         foreach $path (split /:/, $ENV{PATH})
2312                 {
2313                 if (-f "$path/$name$target{exe_extension}" and -x _)
2314                         {
2315                         return "$path/$name$target{exe_extension}" unless ($name eq "perl" and
2316                          system("$path/$name$target{exe_extension} -e " . '\'exit($]<5.0);\''));
2317                         }
2318                 }
2319         }
2320
2321 sub quotify {
2322     my %processors = (
2323         perl    => sub { my $x = shift;
2324                          $x =~ s/([\\\$\@"])/\\$1/g;
2325                          return '"'.$x.'"'; },
2326         );
2327     my $for = shift;
2328     my $processor =
2329         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2330
2331     map { $processor->($_); } @_;
2332 }
2333
2334 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2335 # $filename is a file name to read from
2336 # $line_concat_cond_re is a regexp detecting a line continuation ending
2337 # $line_concat is a CODEref that takes care of concatenating two lines
2338 sub collect_from_file {
2339     my $filename = shift;
2340     my $line_concat_cond_re = shift;
2341     my $line_concat = shift;
2342
2343     open my $fh, $filename || die "unable to read $filename: $!\n";
2344     return sub {
2345         my $saved_line = "";
2346         $_ = "";
2347         while (<$fh>) {
2348             s|\R$||;
2349             if (defined $line_concat) {
2350                 $_ = $line_concat->($saved_line, $_);
2351                 $saved_line = "";
2352             }
2353             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2354                 $saved_line = $_;
2355                 next;
2356             }
2357             return $_;
2358         }
2359         die "$filename ending with continuation line\n" if $_;
2360         close $fh;
2361         return undef;
2362     }
2363 }
2364
2365 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2366 # $array is an ARRAYref of lines
2367 # $line_concat_cond_re is a regexp detecting a line continuation ending
2368 # $line_concat is a CODEref that takes care of concatenating two lines
2369 sub collect_from_array {
2370     my $array = shift;
2371     my $line_concat_cond_re = shift;
2372     my $line_concat = shift;
2373     my @array = (@$array);
2374
2375     return sub {
2376         my $saved_line = "";
2377         $_ = "";
2378         while (defined($_ = shift @array)) {
2379             s|\R$||;
2380             if (defined $line_concat) {
2381                 $_ = $line_concat->($saved_line, $_);
2382                 $saved_line = "";
2383             }
2384             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2385                 $saved_line = $_;
2386                 next;
2387             }
2388             return $_;
2389         }
2390         die "input text ending with continuation line\n" if $_;
2391         return undef;
2392     }
2393 }
2394
2395 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2396 # $lineiterator is a CODEref that delivers one line at a time.
2397 # All following arguments are regex/CODEref pairs, where the regexp detects a
2398 # line and the CODEref does something with the result of the regexp.
2399 sub collect_information {
2400     my $lineiterator = shift;
2401     my %collectors = @_;
2402
2403     while(defined($_ = $lineiterator->())) {
2404         s|\R$||;
2405         my $found = 0;
2406         foreach my $re (keys %collectors) {
2407             if ($re ne "OTHERWISE" && /$re/) {
2408                 $collectors{$re}->($lineiterator);
2409                 $found = 1;
2410             };
2411         }
2412         if ($collectors{"OTHERWISE"}) {
2413             $collectors{"OTHERWISE"}->($lineiterator, $_)
2414                 unless $found || !defined $collectors{"OTHERWISE"};
2415         }
2416     }
2417 }