Configure

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