Configure

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