Configure

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