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