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