Configure

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