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 "Cygwin" || $config{target} eq "DJGPP" || $config{target} =~ /^mingw/);
 814 $target{exe_extension}=".nlm" if ($config{target} =~ /netware/);
 815 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
 816
 817 ($target{shared_extension_simple}=$target{shared_extension})
 818     =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
 819 $target{dso_extension}=$target{shared_extension_simple};
 820 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
 821     if ($config{target} =~ /^(?:Cygwin|mingw)/);
 822
 823
 824 $default_ranlib = which("ranlib") || "true";
 825 $config{perl}   = $ENV{'PERL'} || which("perl5") || which("perl") || "perl";
 826 my $make        = $ENV{'MAKE'} || "make";
 827
 828 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
 829     if $config{cross_compile_prefix} eq "";
 830
 831 # Allow environment CC to override compiler...
 832 $target{cc} = $ENV{CC} || $target{cc};
 833
 834 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
 835 # or release_ attributes.
 836 # Do it in such a way that no spurious space is appended (hence the grep).
 837 $config{defines} = [ @{$target{defines}},
 838                      @{$target{$build_prefix."defines"}} ];
 839 $config{cflags} = join(" ",
 840                        grep { $_ ne "" } ($target{cflags},
 841                                           $target{$build_prefix."cflags"}));
 842 $config{lflags} = join(" ",
 843                        grep { $_ ne "" } ($target{lflags},
 844                                           $target{$build_prefix."lflags"}));
 845 $config{plib_lflags} = join(" ",
 846                             grep { $_  ne "" } ($target{plib_lflags},
 847                                                 $target{$build_prefix."plib_lflags"}));
 848 $config{ex_libs} = join(" ",
 849                         grep { $_  ne "" } ($target{ex_libs},
 850                                             $target{$build_prefix."ex_libs"}));
 851
 852 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} || $default_ranlib;
 853 $target{ar} = $ENV{'AR'} || "ar";
 854 $target{arflags} = "" if !defined($target{arflags});
 855 $target{nm} = "nm";
 856 # Make sure build_scheme is consistent.
 857 $target{build_scheme} = [ $target{build_scheme} ]
 858     if ref($target{build_scheme}) ne "ARRAY";
 859
 860 ###### TO BE REMOVED BEFORE FINAL RELEASE
 861 ######
 862 ###### If the user has chosen --unified, we give it to them.
 863 ###### The same happens if we detect that they try to build out-of-source.
 864 if ($target{build_file} eq "Makefile"
 865     && $target{build_scheme}->[0] eq "unixmake"
 866     && ($unified || $srcdir ne $blddir)) {
 867     $target{build_scheme} = [ "unified", "unix" ];
 868 }
 869
 870 my ($builder, $builder_platform, @builder_opts) =
 871     @{$target{build_scheme}};
 872
 873 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
 874         {
 875         $config{cflags} .= " -mno-cygwin";
 876         $target{shared_ldflag} .= " -mno-cygwin";
 877         }
 878
 879 if ($target =~ /linux.*-mips/ && !$no_asm && $user_cflags !~ /-m(ips|arch=)/) {
 880         # minimally required architecture flags for assembly modules
 881         $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
 882         $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
 883 }
 884
 885 my $no_shared_warn=0;
 886 my $no_user_cflags=0;
 887 my $no_user_defines=0;
 888
 889 # The DSO code currently always implements all functions so that no
 890 # applications will have to worry about that from a compilation point
 891 # of view. However, the "method"s may return zero unless that platform
 892 # has support compiled in for them. Currently each method is enabled
 893 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
 894 # string entry into using the following logic;
 895 if (!$no_dso && $target{dso_scheme} ne "")
 896         {
 897         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
 898         if ($target{dso_scheme} eq "DLFCN")
 899                 {
 900                 $config{defines} = [ "DSO_DLFCN", "HAVE_DLFCN_H",
 901                                      @{$config{defines}} ]
 902                 }
 903         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
 904                 {
 905                 $config{defines} = [ "DSO_DLFCN", @{$config{defines}} ]
 906                 }
 907         else
 908                 {
 909                 $config{defines} = [ "DSO_$target{dso_scheme}",
 910                                      @{$config{defines}} ]
 911                 }
 912         }
 913
 914 my $thread_cflags = "";
 915 my @thread_defines;
 916 if ($target{thread_cflag} ne "(unknown)" && !$no_threads)
 917         {
 918         # If we know how to do it, support threads by default.
 919         $threads = 1;
 920         }
 921 if ($target{thread_cflag} eq "(unknown)" && $threads)
 922         {
 923         # If the user asked for "threads", [s]he is also expected to
 924         # provide any system-dependent compiler options that are
 925         # necessary.
 926         if ($no_user_cflags && $no_user_defines)
 927                 {
 928                 print "You asked for multi-threading support, but didn't\n";
 929                 print "provide any system-specific compiler options\n";
 930                 exit(1);
 931                 }
 932         push @thread_defines, "OPENSSL_THREADS";
 933         }
 934 else
 935         {
 936         $thread_cflags=" $target{thread_cflag}";
 937         push @thread_defines, @{$target{thread_defines}}, "OPENSSL_THREADS";
 938         }
 939
 940 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
 941
 942 if ($no_asm)
 943         {
 944         @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}}
 945             if ($config{fips});
 946         }
 947
 948 if ($threads)
 949         {
 950         $config{cflags} = "$thread_cflags $config{cflags}" if $thread_cflags;
 951         push @{$config{defines}}, @thread_defines;
 952         push @{$config{openssl_thread_defines}}, @thread_defines;
 953         }
 954
 955 if ($zlib)
 956         {
 957         push @{$config{defines}}, "ZLIB";
 958         if (defined($disabled{"zlib-dynamic"}))
 959                 {
 960                 if (defined($withargs{zlib_lib}))
 961                         {
 962                         $config{ex_libs} .= " -L" . $withargs{zlib_lib} . " -lz";
 963                         }
 964                 else
 965                         {
 966                         $config{ex_libs} .= " -lz";
 967                         }
 968                 }
 969         else
 970                 {
 971                 push @{$config{defines}}, "ZLIB_SHARED";
 972                 }
 973         }
 974
 975 # With "deprecated" disable all deprecated features.
 976 if (defined($disabled{"deprecated"})) {
 977         $config{api} = $maxapi;
 978 }
 979
 980 if ($target{shared_target} eq "")
 981         {
 982         $no_shared_warn = 1 if !$config{no_shared} && !$config{fips};
 983         $config{no_shared} = 1;
 984         }
 985 if (!$config{no_shared})
 986         {
 987         if ($target{shared_cflag} ne "")
 988                 {
 989                 push @{$config{defines}}, "OPENSSL_PIC";
 990                 $config{cflags} = "$target{shared_cflag} $config{cflags}";
 991                 }
 992         }
 993
 994 if ($builder ne "mk1mf")
 995         {
 996         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
 997         if ($config{no_shared})
 998                 {
 999                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1000                 $config{options}.=" static-engine";
1001                 }
1002         else
1003                 {
1004                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1005                 $config{options}.=" no-static-engine";
1006                 }
1007         }
1008
1009 #
1010 # Platform fix-ups
1011 #
1012 if ($target{sys_id} ne "")
1013         {
1014         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1015         }
1016
1017 if ($target{ranlib} eq "")
1018         {
1019         $target{ranlib} = $default_ranlib;
1020         }
1021
1022 if (!$no_asm) {
1023     $target{cpuid_asm_src}=$table{BASE}->{cpuid_asm_src} if ($config{processor} eq "386");
1024     $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1025
1026     # bn-586 is the only one implementing bn_*_part_words
1027     push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1028     push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1029
1030     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1031     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1032     push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1033
1034     if ($config{fips}) {
1035         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1036     }
1037
1038     if ($target{sha1_asm_src}) {
1039         push @{$config{defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1040         push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1041         push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1042     }
1043     if ($target{md5_asm_src}) {
1044         push @{$config{defines}}, "MD5_ASM";
1045     }
1046     $target{cast_asm_src}=$table{BASE}->{cast_asm_src} if (!$config{no_shared}); # CAST assembler is not PIC
1047     if ($target{rmd160_asm_src}) {
1048         push @{$config{defines}}, "RMD160_ASM";
1049     }
1050     if ($target{aes_asm_src}) {
1051         push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1052         # aes-ctr.fake is not a real file, only indication that assembler
1053         # module implements AES_ctr32_encrypt...
1054         push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1055         # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1056         push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1057         $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1058         push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1059         push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1060     }
1061     if ($target{wp_asm_src} =~ /mmx/) {
1062         if ($config{processor} eq "386") {
1063             $target{wp_asm_src}=$table{BASE}->{wp_asm_src};
1064         } elsif (!$disabled{"whirlpool"}) {
1065             $config{cflags}.=" -DWHIRLPOOL_ASM";
1066         }
1067     }
1068     if ($target{modes_asm_src} =~ /ghash-/) {
1069         push @{$config{defines}}, "GHASH_ASM";
1070     }
1071     if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1072         push @{$config{defines}}, "ECP_NISTZ256_ASM";
1073     }
1074     if ($target{poly1305_asm_src} ne "") {
1075         push @{$config{defines}}, "POLY1305_ASM";
1076     }
1077 }
1078
1079 my $ecc = $target{cc};
1080 if ($^O ne "VMS") {
1081     # Is the compiler gcc or clang?  $ecc is used below to see if
1082     # error-checking can be turned on.
1083     my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1084     $config{makedepprog} = 'makedepend';
1085     open(PIPE, "$ccpcc --version 2>&1 | head -2 |");
1086     while ( <PIPE> ) {
1087         $config{makedepprog} = $ccpcc if /clang|gcc/;
1088         $ecc = "clang" if /clang/;
1089         $ecc = "gcc" if /gcc/;
1090     }
1091     close(PIPE);
1092 }
1093
1094
1095 # Deal with bn_ops ###################################################
1096
1097 $config{bn_ll}                  =0;
1098 $config{export_var_as_fn}       =0;
1099 my $def_int="unsigned int";
1100 $config{rc4_int}                =$def_int;
1101 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1102
1103 my $count = 0;
1104 foreach (sort split(/\s+/,$target{bn_ops})) {
1105     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1106     $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1107     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1108     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1109     ($config{b64l},$config{b64},$config{b32})
1110         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1111     ($config{b64l},$config{b64},$config{b32})
1112         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1113     ($config{b64l},$config{b64},$config{b32})
1114         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1115 }
1116 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1117     if $count > 1;
1118
1119
1120 # Hack cflags for better warnings (dev option) #######################
1121
1122 # "Stringify" the C flags string.  This permits it to be made part of a string
1123 # and works as well on command lines.
1124 $config{cflags} =~ s/([\\\"])/\\\1/g;
1125
1126 if (defined($config{api})) {
1127     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1128     my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1129     push @{$config{defines}}, $apiflag;
1130 }
1131
1132 if ($strict_warnings)
1133         {
1134         my $wopt;
1135         die "ERROR --strict-warnings requires gcc or clang"
1136             unless $ecc eq 'gcc' || $ecc eq 'clang';
1137         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1138                 {
1139                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1140                 }
1141         if ($ecc eq "clang")
1142                 {
1143                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1144                         {
1145                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1146                         }
1147                 }
1148         }
1149
1150 unless ($disabled{"crypto-mdebug-backtrace"})
1151         {
1152         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1153                 {
1154                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1155                 }
1156         if ($target =~ /^BSD-/)
1157                 {
1158                 $config{ex_libs} .= " -lexecinfo";
1159                 }
1160         }
1161
1162 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1163 else                    { $no_user_cflags=1;  }
1164 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1165 else               { $no_user_defines=1;    }
1166
1167 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1168
1169 # If we use the unified build, collect information from build.info files
1170 my %unified_info = ();
1171
1172 if ($builder eq "unified") {
1173     # Store the name of the template file we will build the build file from
1174     # in %config.  This may be useful for the build file itself.
1175     my $build_file_template =
1176         catfile($srcdir, "Configurations",
1177                 $builder_platform."-".$target{build_file}.".tmpl");
1178     $build_file_template =
1179         catfile($srcdir, "Configurations", $target{build_file}.".tmpl")
1180         if (! -f $build_file_template);
1181     $config{build_file_template} = $build_file_template;
1182
1183     use lib catdir(dirname(__FILE__),"util");
1184     use with_fallback qw(Text::Template);
1185
1186     sub cleandir {
1187         my $base = shift;
1188         my $dir = shift;
1189         my $relativeto = shift || ".";
1190
1191         $dir = catdir($base,$dir) unless isabsolute($dir);
1192
1193         # Make sure the directories we're building in exists
1194         mkpath($dir);
1195
1196         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1197         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1198         return $res;
1199     }
1200
1201     sub cleanfile {
1202         my $base = shift;
1203         my $file = shift;
1204         my $relativeto = shift || ".";
1205
1206         $file = catfile($base,$file) unless isabsolute($file);
1207
1208         my $d = dirname($file);
1209         my $f = basename($file);
1210
1211         # Make sure the directories we're building in exists
1212         mkpath($d);
1213
1214         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1215         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1216         return $res;
1217     }
1218
1219     my @build_infos = ( [ ".", "build.info" ] );
1220     foreach (@{$config{dirs}}) {
1221         push @build_infos, [ $_, "build.info" ]
1222             if (-f catfile($srcdir, $_, "build.info"));
1223     }
1224     foreach (@{$config{sdirs}}) {
1225         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1226             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1227     }
1228     foreach (@{$config{engdirs}}) {
1229         push @build_infos, [ catdir("engines", $_), "build.info" ]
1230             if (-f catfile($srcdir, "engines", $_, "build.info"));
1231     }
1232
1233     foreach (@build_infos) {
1234         my $sourced = catdir($srcdir, $_->[0]);
1235         my $buildd = catdir($blddir, $_->[0]);
1236
1237         mkpath($buildd);
1238
1239         my $f = $_->[1];
1240         # The basic things we're trying to build
1241         my @programs = ();
1242         my @libraries = ();
1243         my @engines = ();
1244         my @scripts = ();
1245         my @extra = ();
1246         my @intermediates = ();
1247         my @rawlines = ();
1248
1249         my %ordinals = ();
1250         my %sources = ();
1251         my %includes = ();
1252         my %depends = ();
1253         my %renames = ();
1254         my %sharednames = ();
1255
1256         my $template = Text::Template->new(TYPE => 'FILE',
1257                                            SOURCE => catfile($sourced, $f));
1258         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1259         my @text =
1260             split /^/m,
1261             $template->fill_in(HASH => { config => \%config,
1262                                          target => \%target,
1263                                          builddir => abs2rel($buildd, $blddir),
1264                                          sourcedir => abs2rel($sourced, $blddir),
1265                                          buildtop => abs2rel($blddir, $blddir),
1266                                          sourcetop => abs2rel($srcdir, $blddir) },
1267                                DELIMITERS => [ "{-", "-}" ]);
1268
1269         # The top item of this stack has the following values
1270         # -2 positive already run and we found ELSE (following ELSIF should fail)
1271         # -1 positive already run (skip until ENDIF)
1272         # 0 negatives so far (if we're at a condition, check it)
1273         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1274         # 2 positive ELSE (following ELSIF should fail)
1275         my @skip = ();
1276         collect_information(
1277             collect_from_array([ @text ],
1278                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1279                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1280             # Info we're looking for
1281             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1282             => sub { push @skip, !! $1; },
1283             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1284             => sub { die "ELSIF out of scope" if ! @skip;
1285                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1286                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1287                      $skip[$#skip] = !! $1
1288                          if $skip[$#skip] == 0; },
1289             qr/^\s*ELSE\s*$/
1290             => sub { die "ELSE out of scope" if ! @skip;
1291                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1292                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1293             qr/^\s*ENDIF\s*$/
1294             => sub { die "ENDIF out of scope" if ! @skip;
1295                      pop @skip; },
1296             qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
1297             => sub { push @programs, split(/\s+/, $1)
1298                          if !@skip || $skip[$#skip] > 0 },
1299             qr/^\s*LIBS\s*=\s*(.*)\s*$/
1300             => sub { push @libraries, split(/\s+/, $1)
1301                          if !@skip || $skip[$#skip] > 0 },
1302             qr/^\s*ENGINES\s*=\s*(.*)\s*$/
1303             => sub { push @engines, split(/\s+/, $1)
1304                          if !@skip || $skip[$#skip] > 0 },
1305             qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
1306             => sub { push @scripts, split(/\s+/, $1)
1307                          if !@skip || $skip[$#skip] > 0 },
1308             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1309             => sub { push @extra, split(/\s+/, $1)
1310                          if !@skip || $skip[$#skip] > 0 },
1311
1312             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1313             => sub { push @{$ordinals{$1}}, split(/\s+/, $2)
1314                          if !@skip || $skip[$#skip] > 0 },
1315             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1316             => sub { push @{$sources{$1}}, split(/\s+/, $2)
1317                          if !@skip || $skip[$#skip] > 0 },
1318             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1319             => sub { push @{$includes{$1}}, split(/\s+/, $2)
1320                          if !@skip || $skip[$#skip] > 0 },
1321             qr/^\s*DEPEND\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1322             => sub { push @{$depends{$1}}, split(/\s+/, $2)
1323                          if !@skip || $skip[$#skip] > 0 },
1324             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1325             => sub { push @{$renames{$1}}, split(/\s+/, $2)
1326                          if !@skip || $skip[$#skip] > 0 },
1327             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1328             => sub { push @{$sharednames{$1}}, split(/\s+/, $2)
1329                          if !@skip || $skip[$#skip] > 0 },
1330             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1331             => sub {
1332                 my $lineiterator = shift;
1333                 my $target_kind = $1;
1334                 while (defined $lineiterator->()) {
1335                     s|\R$||;
1336                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1337                         die "ENDRAW doesn't match BEGINRAW"
1338                             if $1 ne $target_kind;
1339                         last;
1340                     }
1341                     next if @skip && $skip[$#skip] <= 0;
1342                     push @rawlines,  $_
1343                         if ($target_kind eq $target{build_file}
1344                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1345                 }
1346             },
1347             qr/^(?:#.*|\s*)$/ => sub { },
1348             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" }
1349             );
1350         die "runaway IF?" if (@skip);
1351
1352         foreach (keys %renames) {
1353             die "$_ renamed to more than one thing: "
1354                 ,join(" ", @{$renames{$_}}),"\n"
1355                 if scalar @{$renames{$_}} > 1;
1356             my $dest = cleanfile($buildd, $_, $blddir);
1357             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1358             die "$dest renamed to more than one thing: "
1359                 ,$unified_info{rename}->{$dest}, $to
1360                 unless !defined($unified_info{rename}->{$dest})
1361                 or $unified_info{rename}->{$dest} eq $to;
1362             $unified_info{rename}->{$dest} = $to;
1363         }
1364
1365         foreach (@programs) {
1366             my $program = cleanfile($buildd, $_, $blddir);
1367             if ($unified_info{rename}->{$program}) {
1368                 $program = $unified_info{rename}->{$program};
1369             }
1370             $unified_info{programs}->{$program} = 1;
1371         }
1372
1373         foreach (@libraries) {
1374             my $library = cleanfile($buildd, $_, $blddir);
1375             if ($unified_info{rename}->{$library}) {
1376                 $library = $unified_info{rename}->{$library};
1377             }
1378             $unified_info{libraries}->{$library} = 1;
1379         }
1380
1381         die <<"EOF" if $config{no_shared} && scalar @engines;
1382 ENGINES can only be used if configured with 'shared'.
1383 This is usually a fault in a build.info file.
1384 EOF
1385         foreach (@engines) {
1386             my $library = cleanfile($buildd, $_, $blddir);
1387             if ($unified_info{rename}->{$library}) {
1388                 $library = $unified_info{rename}->{$library};
1389             }
1390             $unified_info{engines}->{$library} = 1;
1391         }
1392
1393         foreach (@scripts) {
1394             my $script = cleanfile($buildd, $_, $blddir);
1395             if ($unified_info{rename}->{$script}) {
1396                 $script = $unified_info{rename}->{$script};
1397             }
1398             $unified_info{scripts}->{$script} = 1;
1399         }
1400
1401         foreach (@extra) {
1402             my $extra = cleanfile($buildd, $_, $blddir);
1403             $unified_info{extra}->{$extra} = 1;
1404         }
1405
1406         push @{$unified_info{rawlines}}, @rawlines;
1407
1408         if (!$config{no_shared}) {
1409             # Check sharednames.
1410             foreach (keys %sharednames) {
1411                 my $dest = cleanfile($buildd, $_, $blddir);
1412                 if ($unified_info{rename}->{$dest}) {
1413                     $dest = $unified_info{rename}->{$dest};
1414                 }
1415                 die "shared_name for $dest with multiple values: "
1416                     ,join(" ", @{$sharednames{$_}}),"\n"
1417                     if scalar @{$sharednames{$_}} > 1;
1418                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1419                 die "shared_name found for a library $dest that isn't defined\n"
1420                     unless $unified_info{libraries}->{$dest};
1421                 die "shared_name for $dest with multiple values: "
1422                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1423                     unless !defined($unified_info{sharednames}->{$dest})
1424                     or $unified_info{sharednames}->{$dest} eq $to;
1425                 $unified_info{sharednames}->{$dest} = $to;
1426             }
1427
1428             # Additionally, we set up sharednames for libraries that don't
1429             # have any, as themselves.
1430             foreach (keys %{$unified_info{libraries}}) {
1431                 if (!defined $unified_info{sharednames}->{$_}) {
1432                     $unified_info{sharednames}->{$_} = $_
1433                 }
1434             }
1435         }
1436
1437         foreach (keys %ordinals) {
1438             my $dest = $_;
1439             my $ddest = cleanfile($buildd, $_, $blddir);
1440             if ($unified_info{rename}->{$ddest}) {
1441                 $ddest = $unified_info{rename}->{$ddest};
1442             }
1443             foreach (@{$ordinals{$dest}}) {
1444                 my %known_ordinals =
1445                     (
1446                      crypto =>
1447                      cleanfile($sourced, catfile("util", "libeay.num"), $blddir),
1448                      ssl =>
1449                      cleanfile($sourced, catfile("util", "ssleay.num"), $blddir)
1450                     );
1451                 my $o = $known_ordinals{$_};
1452                 die "Ordinals for $ddest defined more than once\n"
1453                     if $unified_info{ordinals}->{$ddest};
1454                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1455             }
1456         }
1457
1458         foreach (keys %sources) {
1459             my $dest = $_;
1460             my $ddest = cleanfile($buildd, $_, $blddir);
1461             if ($unified_info{rename}->{$ddest}) {
1462                 $ddest = $unified_info{rename}->{$ddest};
1463             }
1464             foreach (@{$sources{$dest}}) {
1465                 my $s = cleanfile($sourced, $_, $blddir);
1466
1467                 # If it isn't in the source tree, we assume it's generated
1468                 # in the build tree
1469                 if (! -f $s) {
1470                     $s = cleanfile($buildd, $_, $blddir);
1471                 }
1472                 # We recognise C and asm files
1473                 if ($s =~ /\.[csS]\b$/) {
1474                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1475                     $o = cleanfile($buildd, $o, $blddir);
1476                     $unified_info{sources}->{$ddest}->{$o} = 1;
1477                     $unified_info{sources}->{$o}->{$s} = 1;
1478                 } else {
1479                     $unified_info{sources}->{$ddest}->{$s} = 1;
1480                 }
1481             }
1482         }
1483
1484         foreach (keys %depends) {
1485             my $dest = $_;
1486             my $ddest = cleanfile($buildd, $_, $blddir);
1487             if ($unified_info{rename}->{$ddest}) {
1488                 $ddest = $unified_info{rename}->{$ddest};
1489             }
1490             foreach (@{$depends{$dest}}) {
1491                 my $d = cleanfile($sourced, $_, $blddir);
1492
1493                 # If we know it's generated, or assume it is because we can't
1494                 # find it in the source tree, we set file we depend on to be
1495                 # in the build tree rather than the source tree, and assume
1496                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1497                 # section or in the Makefile template.
1498                 if (! -f $d
1499                     || !(grep { $d eq $_ }
1500                          map { cleanfile($srcdir, $_, $blddir) }
1501                          (@generated_headers, @generated_by_make_headers))) {
1502                     $d = cleanfile($buildd, $_, $blddir);
1503                 }
1504                 # Take note if the file to depend on is being renamed
1505                 if ($unified_info{rename}->{$d}) {
1506                     $d = $unified_info{rename}->{$d};
1507                 }
1508                 $unified_info{depends}->{$ddest}->{$d} = 1;
1509                 # If we depend on a header file, let's make sure it
1510                 # can get included
1511                 if ($d =~ /\.h$/) {
1512                     my $i = dirname($d);
1513                     push @{$unified_info{includes}->{$ddest}}, $i
1514                         unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1515                 }
1516             }
1517         }
1518
1519         foreach (keys %includes) {
1520             my $dest = $_;
1521             my $ddest = cleanfile($buildd, $_, $blddir);
1522             if ($unified_info{rename}->{$ddest}) {
1523                 $ddest = $unified_info{rename}->{$ddest};
1524             }
1525             foreach (@{$includes{$dest}}) {
1526                 my $i = cleandir($sourced, $_, $blddir);
1527                 push @{$unified_info{includes}->{$ddest}}, $i
1528                     unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1529             }
1530         }
1531     }
1532
1533     ### Make unified_info a bit more efficient
1534     # One level structures
1535     foreach (("programs", "libraries", "engines", "scripts", "extra")) {
1536         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1537     }
1538     # Two level structures
1539     foreach my $l1 (("sources", "ldadd", "depends")) {
1540         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1541             $unified_info{$l1}->{$l2} =
1542                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1543         }
1544     }
1545 }
1546
1547 # For the schemes that need it, we provide the old *_obj configs
1548 # from the *_asm_obj ones
1549 foreach (grep /_(asm|aux)_src$/, keys %target) {
1550     my $src = $_;
1551     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1552     ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1553 }
1554
1555 # Write down our configuration where it fits #########################
1556
1557 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1558 print OUT <<"EOF";
1559 package configdata;
1560
1561 use strict;
1562 use warnings;
1563
1564 use Exporter;
1565 #use vars qw(\@ISA \@EXPORT);
1566 our \@ISA = qw(Exporter);
1567 our \@EXPORT = qw(\%config \%target %withargs %unified_info);
1568
1569 EOF
1570 print OUT "our %config = (\n";
1571 foreach (sort keys %config) {
1572     if (ref($config{$_}) eq "ARRAY") {
1573         print OUT "  ", $_, " => [ ", join(", ",
1574                                            map { quotify("perl", $_) }
1575                                            @{$config{$_}}), " ],\n";
1576     } else {
1577         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1578     }
1579 }
1580 print OUT <<"EOF";
1581 );
1582
1583 EOF
1584 print OUT "our %target = (\n";
1585 foreach (sort keys %target) {
1586     if (ref($target{$_}) eq "ARRAY") {
1587         print OUT "  ", $_, " => [ ", join(", ",
1588                                            map { quotify("perl", $_) }
1589                                            @{$target{$_}}), " ],\n";
1590     } else {
1591         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1592     }
1593 }
1594 print OUT <<"EOF";
1595 );
1596
1597 EOF
1598 print OUT "our \%available_protocols = (\n";
1599 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1600 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1601 print OUT <<"EOF";
1602 );
1603
1604 EOF
1605 print OUT "our \%disabled = (\n";
1606 foreach (sort keys %disabled) {
1607     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1608 }
1609 print OUT <<"EOF";
1610 );
1611
1612 EOF
1613 print OUT "our %withargs = (\n";
1614 foreach (sort keys %withargs) {
1615     if (ref($withargs{$_}) eq "ARRAY") {
1616         print OUT "  ", $_, " => [ ", join(", ",
1617                                            map { quotify("perl", $_) }
1618                                            @{$withargs{$_}}), " ],\n";
1619     } else {
1620         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1621     }
1622 }
1623 print OUT <<"EOF";
1624 );
1625
1626 EOF
1627 if ($builder eq "unified") {
1628     my $recurse;
1629     $recurse = sub {
1630         my $indent = shift;
1631         foreach (@_) {
1632             if (ref $_ eq "ARRAY") {
1633                 print OUT " "x$indent, "[\n";
1634                 foreach (@$_) {
1635                     $recurse->($indent + 4, $_);
1636                 }
1637                 print OUT " "x$indent, "],\n";
1638             } elsif (ref $_ eq "HASH") {
1639                 my %h = %$_;
1640                 print OUT " "x$indent, "{\n";
1641                 foreach (sort keys %h) {
1642                     if (ref $h{$_} eq "") {
1643                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1644                     } else {
1645                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1646                         $recurse->($indent + 8, $h{$_});
1647                     }
1648                 }
1649                 print OUT " "x$indent, "},\n";
1650             } else {
1651                 print OUT " "x$indent, quotify("perl", $_), ",\n";
1652             }
1653         }
1654     };
1655     print OUT "our %unified_info = (\n";
1656     foreach (sort keys %unified_info) {
1657         if (ref $unified_info{$_} eq "") {
1658             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1659         } else {
1660             print OUT " "x4, quotify("perl", $_), " =>\n";
1661             $recurse->(8, $unified_info{$_});
1662         }
1663     }
1664     print OUT <<"EOF";
1665 );
1666
1667 EOF
1668 }
1669 print OUT "1;\n";
1670 close(OUT);
1671
1672
1673 print "IsMK1MF       =", ($builder eq "mk1mf" ? "yes" : "no"), "\n";
1674 print "CC            =$target{cc}\n";
1675 print "CFLAG         =$config{cflags}\n";
1676 print "DEFINES       =",join(" ", @{$config{defines}}),"\n";
1677 print "LFLAG         =$config{lflags}\n";
1678 print "PLIB_LFLAG    =$config{plib_lflags}\n";
1679 print "EX_LIBS       =$config{ex_libs}\n";
1680 print "CPUID_OBJ     =$target{cpuid_obj}\n";
1681 print "BN_ASM        =$target{bn_obj}\n";
1682 print "EC_ASM        =$target{ec_obj}\n";
1683 print "DES_ENC       =$target{des_obj}\n";
1684 print "AES_ENC       =$target{aes_obj}\n";
1685 print "BF_ENC        =$target{bf_obj}\n";
1686 print "CAST_ENC      =$target{cast_obj}\n";
1687 print "RC4_ENC       =$target{rc4_obj}\n";
1688 print "RC5_ENC       =$target{rc5_obj}\n";
1689 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
1690 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
1691 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1692 print "CMLL_ENC      =$target{cmll_obj}\n";
1693 print "MODES_OBJ     =$target{modes_obj}\n";
1694 print "PADLOCK_OBJ   =$target{padlock_obj}\n";
1695 print "CHACHA_ENC    =$target{chacha_obj}\n";
1696 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
1697 print "PROCESSOR     =$config{processor}\n";
1698 print "RANLIB        =$target{ranlib}\n";
1699 print "ARFLAGS       =$target{arflags}\n";
1700 print "PERL          =$config{perl}\n";
1701 print "\n";
1702 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1703 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1704 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1705 print "BN_LLONG mode\n" if $config{bn_ll};
1706 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int;
1707
1708 for (@generated_headers) {
1709     mkpath(catdir($blddir, dirname($_)));
1710     run_dofile(catfile($blddir, $_),
1711                catfile($srcdir, $_.".in"));
1712 }
1713
1714 ###
1715 ### When the old "unixmake" scheme goes away, so does this function
1716 ###
1717 sub build_Makefile {
1718     run_dofile("Makefile","Makefile.in");
1719
1720     # Copy all Makefile.in to Makefile (except top-level)
1721     use File::Find;
1722     use IO::File;
1723     find(
1724         {
1725             preprocess => sub {
1726                 grep(!/^\./, @_);
1727             },
1728             wanted => sub {
1729                 return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1730                 my $in = IO::File->new($_, "r") or
1731                     die sprintf "Error reading Makefile.in in %s: !$\n",
1732                     $File::Find::dir;
1733                 my $out = IO::File->new("Makefile", "w") or
1734                     die sprintf "Error writing Makefile in %s: !$\n",
1735                     $File::Find::dir;
1736                 print $out "# Generated from $_, do not edit\n";
1737                 while (my $line = <$in>) { print $out $line }
1738                 $in->close() or
1739                     die sprintf "Error reading Makefile.in in %s: !$\n",
1740                     $File::Find::dir;
1741                 $out->close() or
1742                     die sprintf "Error writing Makefile in %s: !$\n",
1743                     $File::Find::dir;
1744             },
1745         },
1746         ".");
1747 }
1748
1749 my %builders = (
1750     unified => sub {
1751         run_dofile(catfile($blddir, $target{build_file}),
1752                    $config{build_file_template},
1753                    catfile($srcdir, "Configurations", "common.tmpl"));
1754     },
1755     unixmake => sub {
1756         build_Makefile();
1757
1758         run_dofile("util/domd", "util/domd.in");
1759         chmod 0755, "util/domd";
1760     },
1761     mk1mf => sub {
1762         my $platform = shift;
1763         # The only reason we do this is to have something to build MINFO from
1764         build_Makefile();
1765
1766         # create the ms/version32.rc file if needed
1767         if ($platform ne "netware") {
1768             my ($v1, $v2, $v3, $v4);
1769             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) {
1770                 $v1=hex $1;
1771                 $v2=hex $2;
1772                 $v3=hex $3;
1773                 $v4=hex $4;
1774             }
1775             open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1776             print OUT <<"EOF";
1777 #include <winver.h>
1778
1779 LANGUAGE 0x09,0x01
1780
1781 1 VERSIONINFO
1782   FILEVERSION $v1,$v2,$v3,$v4
1783   PRODUCTVERSION $v1,$v2,$v3,$v4
1784   FILEFLAGSMASK 0x3fL
1785 #ifdef _DEBUG
1786   FILEFLAGS 0x01L
1787 #else
1788   FILEFLAGS 0x00L
1789 #endif
1790   FILEOS VOS__WINDOWS32
1791   FILETYPE VFT_DLL
1792   FILESUBTYPE 0x0L
1793 BEGIN
1794     BLOCK "StringFileInfo"
1795     BEGIN
1796         BLOCK "040904b0"
1797         BEGIN
1798             // Required:
1799             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1800             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1801             VALUE "FileVersion", "$config{version}\\0"
1802 #if defined(CRYPTO)
1803             VALUE "InternalName", "libeay32\\0"
1804             VALUE "OriginalFilename", "libeay32.dll\\0"
1805 #elif defined(SSL)
1806             VALUE "InternalName", "ssleay32\\0"
1807             VALUE "OriginalFilename", "ssleay32.dll\\0"
1808 #endif
1809             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1810             VALUE "ProductVersion", "$config{version}\\0"
1811             // Optional:
1812             //VALUE "Comments", "\\0"
1813             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1814             //VALUE "LegalTrademarks", "\\0"
1815             //VALUE "PrivateBuild", "\\0"
1816             //VALUE "SpecialBuild", "\\0"
1817         END
1818     END
1819     BLOCK "VarFileInfo"
1820     BEGIN
1821         VALUE "Translation", 0x409, 0x4b0
1822     END
1823 END
1824 EOF
1825             close(OUT);
1826         }
1827     },
1828     );
1829
1830 $builders{$builder}->($builder_platform, @builder_opts);
1831
1832 print <<"EOF";
1833
1834 Configured for $target.
1835 EOF
1836
1837 print <<"EOF" if (!$no_threads && !$threads);
1838
1839 The library could not be configured for supporting multi-threaded
1840 applications as the compiler options required on this system are not known.
1841 See file INSTALL for details if you need multi-threading.
1842 EOF
1843
1844 print <<"EOF" if ($no_shared_warn);
1845
1846 You gave the option 'shared', which is not supported on this platform, so
1847 we will pretend you gave the option 'no-shared'.  If you know how to implement
1848 shared libraries, please let us know (but please first make sure you have
1849 tried with a current version of OpenSSL).
1850 EOF
1851
1852 ###### TO BE REMOVED BEFORE FINAL RELEASE
1853 ######
1854 ###### If the user hasn't chosen --unified, try to nudge them.
1855 if ($target{build_file} eq "Makefile"
1856     && $target{build_scheme}->[0] eq "unixmake"
1857     && !$unified) {
1858
1859     my $plausible_builddir =
1860         abs2rel(rel2abs("../_openssl-build_$target"),rel2abs("."));
1861     my $plausible_to_sourcedir =
1862         abs2rel(rel2abs("."),rel2abs("../_openssl-build_$target"));
1863     print <<"EOF";
1864
1865 ----------------------------------------------------------------------
1866 Please consider configuring with the flag --unified .
1867 It's to test out a new "unified" building system.
1868
1869 One cool feature is that you can have your build directory elsewhere,
1870 for example:
1871
1872     make clean          # Clean the current configuration away
1873     mkdir $plausible_builddir
1874     cd $plausible_builddir
1875     $plausible_to_sourcedir/config --unified
1876     make
1877     make test
1878
1879 Please report any problem you have.
1880 ----------------------------------------------------------------------
1881
1882 EOF
1883 }
1884
1885 exit(0);
1886
1887 ######################################################################
1888 #
1889 # Helpers and utility functions
1890 #
1891
1892 # Configuration file reading #########################################
1893
1894 # Helper function to implement conditional inheritance depending on the
1895 # value of $no_asm.  Used in inherit_from values as follows:
1896 #
1897 #      inherit_from => [ "template", asm("asm_tmpl") ]
1898 #
1899 sub asm {
1900     my @x = @_;
1901     sub {
1902         $no_asm ? () : @x;
1903     }
1904 }
1905
1906 # Helper function to implement adding values to already existing configuration
1907 # values.  It handles elements that are ARRAYs, CODEs and scalars
1908 sub _add {
1909     my $separator = shift;
1910
1911     # If there's any ARRAY in the collection of values OR the separator
1912     # is undef, we will return an ARRAY of combined values, otherwise a
1913     # string of joined values with $separator as the separator.
1914     my $found_array = !defined($separator);
1915
1916     my @values =
1917         map {
1918             if (ref($_) eq "ARRAY") {
1919                 $found_array = 1;
1920                 @$_;
1921             } else {
1922                 $_;
1923             }
1924     } (@_);
1925
1926     if ($found_array) {
1927         [ @values ];
1928     } else {
1929         join($separator, @values);
1930     }
1931 }
1932 sub add_before {
1933     my $separator = shift;
1934     my @x = @_;
1935     sub { _add($separator, @x, @_) };
1936 }
1937 sub add {
1938     my $separator = shift;
1939     my @x = @_;
1940     sub { _add($separator, @_, @x) };
1941 }
1942
1943 # configuration reader, evaluates the input file as a perl script and expects
1944 # it to fill %targets with target configurations.  Those are then added to
1945 # %table.
1946 sub read_config {
1947     my $fname = shift;
1948     open(CONFFILE, "< $fname")
1949         or die "Can't open configuration file '$fname'!\n";
1950     my $x = $/;
1951     undef $/;
1952     my $content = <CONFFILE>;
1953     $/ = $x;
1954     close(CONFFILE);
1955     my %targets = ();
1956     {
1957         local %table = %::table;    # Protect %table from tampering
1958
1959         eval $content;
1960         warn $@ if $@;
1961     }
1962
1963     # For each target, check that it's configured with a hash table.
1964     foreach (keys %targets) {
1965         if (ref($targets{$_}) ne "HASH") {
1966             if (ref($targets{$_}) eq "") {
1967                 warn "Deprecated target configuration for $_, ignoring...\n";
1968             } else {
1969                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
1970             }
1971             delete $targets{$_};
1972         }
1973     }
1974
1975     %table = (%table, %targets);
1976
1977 }
1978
1979 # configuration resolver.  Will only resolve all the lazy evalutation
1980 # codeblocks for the chozen target and all those it inherits from,
1981 # recursively
1982 sub resolve_config {
1983     my $target = shift;
1984     my @breadcrumbs = @_;
1985
1986     if (grep { $_ eq $target } @breadcrumbs) {
1987         die "inherit_from loop!  target backtrace:\n  "
1988             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
1989     }
1990
1991     if (!defined($table{$target})) {
1992         warn "Warning! target $target doesn't exist!\n";
1993         return ();
1994     }
1995     # Recurse through all inheritances.  They will be resolved on the
1996     # fly, so when this operation is done, they will all just be a
1997     # bunch of attributes with string values.
1998     # What we get here, though, are keys with references to lists of
1999     # the combined values of them all.  We will deal with lists after
2000     # this stage is done.
2001     my %combined_inheritance = ();
2002     if ($table{$target}->{inherit_from}) {
2003         my @inherit_from =
2004             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2005         foreach (@inherit_from) {
2006             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2007
2008             # 'template' is a marker that's considered private to
2009             # the config that had it.
2010             delete $inherited_config{template};
2011
2012             map {
2013                 if (!$combined_inheritance{$_}) {
2014                     $combined_inheritance{$_} = [];
2015                 }
2016                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2017             } keys %inherited_config;
2018         }
2019     }
2020
2021     # We won't need inherit_from in this target any more, since we've
2022     # resolved all the inheritances that lead to this
2023     delete $table{$target}->{inherit_from};
2024
2025     # Now is the time to deal with those lists.  Here's the place to
2026     # decide what shall be done with those lists, all based on the
2027     # values of the target we're currently dealing with.
2028     # - If a value is a coderef, it will be executed with the list of
2029     #   inherited values as arguments.
2030     # - If the corresponding key doesn't have a value at all or is the
2031     #   emoty string, the inherited value list will be run through the
2032     #   default combiner (below), and the result becomes this target's
2033     #   value.
2034     # - Otherwise, this target's value is assumed to be a string that
2035     #   will simply override the inherited list of values.
2036     my $default_combiner = add(" ");
2037
2038     my %all_keys =
2039         map { $_ => 1 } (keys %combined_inheritance,
2040                          keys %{$table{$target}});
2041     foreach (sort keys %all_keys) {
2042
2043         # Current target doesn't have a value for the current key?
2044         # Assign it the default combiner, the rest of this loop body
2045         # will handle it just like any other coderef.
2046         if (!exists $table{$target}->{$_}) {
2047             $table{$target}->{$_} = $default_combiner;
2048         }
2049
2050         my $valuetype = ref($table{$target}->{$_});
2051         if ($valuetype eq "CODE") {
2052             # CODE reference, execute it with the inherited values as
2053             # arguments.
2054             $table{$target}->{$_} =
2055                 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
2056         } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
2057             # ARRAY or Scalar, just leave it as is.
2058         } else {
2059             # Some other type of reference that we don't handle.
2060             # Better to abort at this point.
2061             die "cannot handle reference type $valuetype,"
2062                 ," found in target $target -> $_\n";
2063         }
2064     }
2065
2066     # Finally done, return the result.
2067     return %{$table{$target}};
2068 }
2069
2070 sub usage
2071         {
2072         print STDERR $usage;
2073         print STDERR "\npick os/compiler from:\n";
2074         my $j=0;
2075         my $i;
2076         my $k=0;
2077         foreach $i (sort keys %table)
2078                 {
2079                 next if $table{$i}->{template};
2080                 next if $i =~ /^debug/;
2081                 $k += length($i) + 1;
2082                 if ($k > 78)
2083                         {
2084                         print STDERR "\n";
2085                         $k=length($i);
2086                         }
2087                 print STDERR $i . " ";
2088                 }
2089         foreach $i (sort keys %table)
2090                 {
2091                 next if $table{$i}->{template};
2092                 next if $i !~ /^debug/;
2093                 $k += length($i) + 1;
2094                 if ($k > 78)
2095                         {
2096                         print STDERR "\n";
2097                         $k=length($i);
2098                         }
2099                 print STDERR $i . " ";
2100                 }
2101         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2102         exit(1);
2103         }
2104
2105 sub run_dofile()
2106 {
2107     my $out = shift;
2108     my @templates = @_;
2109
2110     unlink $out || warn "Can't remove $out, $!"
2111         if -f $out;
2112     foreach (@templates) {
2113         die "Can't open $_, $!" unless -f $_;
2114     }
2115     my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2116     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2117     system($cmd);
2118     exit 1 if $? != 0;
2119     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2120 }
2121
2122 # Configuration printer ##############################################
2123
2124 sub print_table_entry
2125 {
2126     my $target = shift;
2127     my %target = resolve_config($target);
2128     my $type = shift;
2129
2130     # Don't print the templates
2131     return if $target{template};
2132
2133     my @sequence = (
2134         "sys_id",
2135         "cc",
2136         "cflags",
2137         "defines",
2138         "debug_cflags",
2139         "debug_defines",
2140         "release_cflags",
2141         "release_defines",
2142         "thread_cflag",
2143         "unistd",
2144         "ld",
2145         "lflags",
2146         "plib_lflags",
2147         "ex_libs",
2148         "debug_lflags",
2149         "debug_plib_lflags",
2150         "debug_ex_libs",
2151         "release_lflags",
2152         "release_plib_lflags",
2153         "release_ex_libs",
2154         "bn_ops",
2155         "cpuid_obj",
2156         "bn_obj",
2157         "ec_obj",
2158         "des_obj",
2159         "aes_obj",
2160         "bf_obj",
2161         "md5_obj",
2162         "sha1_obj",
2163         "cast_obj",
2164         "rc4_obj",
2165         "rmd160_obj",
2166         "rc5_obj",
2167         "wp_obj",
2168         "cmll_obj",
2169         "modes_obj",
2170         "padlock_obj",
2171         "perlasm_scheme",
2172         "dso_scheme",
2173         "shared_target",
2174         "shared_cflag",
2175         "shared_ldflag",
2176         "shared_rcflag",
2177         "shared_extension",
2178         "shared_extension_simple",
2179         "shared_import_extension",
2180         "dso_extension",
2181         "obj_extension",
2182         "exe_extension",
2183         "ranlib",
2184         "ar",
2185         "arflags",
2186         "multilib",
2187         "build_scheme",
2188         );
2189
2190     if ($type eq "TABLE") {
2191         print "\n";
2192         print "*** $target\n";
2193         printf "\$%-12s = %s\n", $_, $target{$_} foreach (@sequence);
2194     } elsif ($type eq "HASH") {
2195         my $largest =
2196             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2197         print "    '$target' => {\n";
2198         foreach (@sequence) {
2199             if ($target{$_}) {
2200                 print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2201             }
2202         }
2203         print "    },\n";
2204     }
2205 }
2206
2207 # Utility routines ###################################################
2208
2209 # On VMS, if the given file is a logical name, File::Spec::Functions
2210 # will consider it an absolute path.  There are cases when we want a
2211 # purely syntactic check without checking the environment.
2212 sub isabsolute {
2213     my $file = shift;
2214
2215     # On non-platforms, we just use file_name_is_absolute().
2216     return file_name_is_absolute($file) unless $^O eq "VMS";
2217
2218     # If the file spec includes a device or a directpry spec,
2219     # file_name_is_absolute() is perfectly safe.
2220     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2221
2222     # Here, we know the given file spec isn't absolute
2223     return 0;
2224 }
2225
2226 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2227 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2228 # realpath() requires that at least all path components except the last is an
2229 # existing directory.  On VMS, the last component of the directory spec must
2230 # exist.
2231 sub absolutedir {
2232     my $dir = shift;
2233
2234     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2235     # will return the volume name for the device, no matter what.  Also,
2236     # it will return an incorrect directory spec if the argument is a
2237     # directory that doesn't exist.
2238     if ($^O eq "VMS") {
2239         return rel2abs($dir);
2240     }
2241
2242     # We use realpath() on Unix, since no other will properly clean out
2243     # a directory spec.
2244     use Cwd qw/realpath/;
2245
2246     return realpath($dir);
2247 }
2248
2249 sub which
2250         {
2251         my($name)=@_;
2252         my $path;
2253         foreach $path (split /:/, $ENV{PATH})
2254                 {
2255                 if (-f "$path/$name$target{exe_extension}" and -x _)
2256                         {
2257                         return "$path/$name$target{exe_extension}" unless ($name eq "perl" and
2258                          system("$path/$name$target{exe_extension} -e " . '\'exit($]<5.0);\''));
2259                         }
2260                 }
2261         }
2262
2263 sub quotify {
2264     my %processors = (
2265         perl    => sub { my $x = shift;
2266                          $x =~ s/([\\\$\@"])/\\$1/g;
2267                          return '"'.$x.'"'; },
2268         );
2269     my $for = shift;
2270     my $processor =
2271         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2272
2273     map { $processor->($_); } @_;
2274 }
2275
2276 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2277 # $filename is a file name to read from
2278 # $line_concat_cond_re is a regexp detecting a line continuation ending
2279 # $line_concat is a CODEref that takes care of concatenating two lines
2280 sub collect_from_file {
2281     my $filename = shift;
2282     my $line_concat_cond_re = shift;
2283     my $line_concat = shift;
2284
2285     open my $fh, $filename || die "unable to read $filename: $!\n";
2286     return sub {
2287         my $saved_line = "";
2288         $_ = "";
2289         while (<$fh>) {
2290             s|\R$||;
2291             if (defined $line_concat) {
2292                 $_ = $line_concat->($saved_line, $_);
2293                 $saved_line = "";
2294             }
2295             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2296                 $saved_line = $_;
2297                 next;
2298             }
2299             return $_;
2300         }
2301         die "$filename ending with continuation line\n" if $_;
2302         close $fh;
2303         return undef;
2304     }
2305 }
2306
2307 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2308 # $array is an ARRAYref of lines
2309 # $line_concat_cond_re is a regexp detecting a line continuation ending
2310 # $line_concat is a CODEref that takes care of concatenating two lines
2311 sub collect_from_array {
2312     my $array = shift;
2313     my $line_concat_cond_re = shift;
2314     my $line_concat = shift;
2315     my @array = (@$array);
2316
2317     return sub {
2318         my $saved_line = "";
2319         $_ = "";
2320         while (defined($_ = shift @array)) {
2321             s|\R$||;
2322             if (defined $line_concat) {
2323                 $_ = $line_concat->($saved_line, $_);
2324                 $saved_line = "";
2325             }
2326             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2327                 $saved_line = $_;
2328                 next;
2329             }
2330             return $_;
2331         }
2332         die "input text ending with continuation line\n" if $_;
2333         return undef;
2334     }
2335 }
2336
2337 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2338 # $lineiterator is a CODEref that delivers one line at a time.
2339 # All following arguments are regex/CODEref pairs, where the regexp detects a
2340 # line and the CODEref does something with the result of the regexp.
2341 sub collect_information {
2342     my $lineiterator = shift;
2343     my %collectors = @_;
2344
2345     while(defined($_ = $lineiterator->())) {
2346         s|\R$||;
2347         my $found = 0;
2348         foreach my $re (keys %collectors) {
2349             if ($re ne "OTHERWISE" && /$re/) {
2350                 $collectors{$re}->($lineiterator);
2351                 $found = 1;
2352             };
2353         }
2354         if ($collectors{"OTHERWISE"}) {
2355             $collectors{"OTHERWISE"}->($lineiterator, $_)
2356                 unless $found || !defined $collectors{"OTHERWISE"};
2357         }
2358     }
2359 }