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