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