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