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;
  14
  15 # see INSTALL for instructions.
  16
  17 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [experimental-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  18
  19 # Options:
  20 #
  21 # --config      add the given configuration file, which will be read after
  22 #               any "Configurations*" files that are found in the same
  23 #               directory as this script.
  24 # --prefix      prefix for the OpenSSL installation, which includes the
  25 #               directories bin, lib, include, share/man, share/doc/openssl
  26 #               This becomes the value of INSTALLTOP in Makefile
  27 #               (Default: /usr/local)
  28 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  29 #               If it's a relative directory, it will be added on the directory
  30 #               given with --prefix.
  31 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  32 #               (Default: PREFIX/ssl)
  33 #
  34 # --install_prefix  Additional prefix for package builders (empty by
  35 #               default).  This needn't be set in advance, you can
  36 #               just as well use "make INSTALL_PREFIX=/whatever install".
  37 #
  38 # --cross-compile-prefix Add specified prefix to binutils components.
  39 #
  40 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
  41 #               interfaces deprecated as of the specified OpenSSL version.
  42 #
  43 # no-hw-xxx     do not compile support for specific crypto hardware.
  44 #               Generic OpenSSL-style methods relating to this support
  45 #               are always compiled but return NULL if the hardware
  46 #               support isn't compiled.
  47 # no-hw         do not compile support for any crypto hardware.
  48 # [no-]threads  [don't] try to create a library that is suitable for
  49 #               multithreaded applications (default is "threads" if we
  50 #               know how to do it)
  51 # [no-]shared   [don't] try to create shared libraries when supported.
  52 # no-asm        do not use assembler
  53 # no-dso        do not compile in any native shared-library methods. This
  54 #               will ensure that all methods just return NULL.
  55 # no-egd        do not compile support for the entropy-gathering daemon APIs
  56 # [no-]zlib     [don't] compile support for zlib compression.
  57 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  58 #               library and will be loaded in run-time by the OpenSSL library.
  59 # sctp          include SCTP support
  60 # 386           generate 80386 code
  61 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
  62 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  63 # -<xxx> +<xxx> compiler options are passed through
  64 #
  65 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
  66 #               provided to stack calls. Generates unique stack functions for
  67 #               each possible stack type.
  68 # DES_PTR       use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
  69 # DES_RISC1     use different DES_ENCRYPT macro that helps reduce register
  70 #               dependancies but needs to more registers, good for RISC CPU's
  71 # DES_RISC2     A different RISC variant.
  72 # DES_UNROLL    unroll the inner DES loop, sometimes helps, somtimes hinders.
  73 # DES_INT       use 'int' instead of 'long' for DES_LONG in crypto/des/des.h
  74 #               This is used on the DEC Alpha where long is 8 bytes
  75 #               and int is 4
  76 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
  77 # MD2_CHAR      use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h
  78 # MD2_LONG      use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h
  79 # IDEA_SHORT    use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h
  80 # IDEA_LONG     use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h
  81 # RC2_SHORT     use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
  82 # RC2_LONG      use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
  83 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  84 # RC4_LONG      use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  85 # RC4_INDEX     define RC4_INDEX in crypto/rc4/rc4_locl.h.  This turns on
  86 #               array lookups instead of pointer use.
  87 # RC4_CHUNK     enables code that handles data aligned at long (natural CPU
  88 #               word) boundary.
  89 # RC4_CHUNK_LL  enables code that handles data aligned at long long boundary
  90 #               (intended for 64-bit CPUs running 32-bit OS).
  91 # BF_PTR        use 'pointer arithmatic' for Blowfish (unsafe on Alpha).
  92 # BF_PTR2       intel specific version (generic version is more efficient).
  93 #
  94 # Following are set automatically by this script
  95 #
  96 # MD5_ASM       use some extra md5 assember,
  97 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
  98 # RMD160_ASM    use some extra ripemd160 assember,
  99 # SHA256_ASM    sha256_block is implemented in assembler
 100 # SHA512_ASM    sha512_block is implemented in assembler
 101 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
 102
 103 # Minimum warning options... any contributions to OpenSSL should at least get
 104 # past these.
 105
 106 my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Wtype-limits -Werror -DREF_CHECK -DDEBUG_UNUSED";
 107
 108 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
 109 # TODO(openssl-team): fix problems and investigate if (at least) the
 110 # following warnings can also be enabled:
 111 # -Wswitch-enum, -Wunused-macros, -Wmissing-field-initializers,
 112 # -Wcast-align,
 113 # -Wunreachable-code -Wunused-parameter -Wlanguage-extension-token
 114 # -Wextended-offsetof
 115 my $clang_devteam_warn = "-Wno-unused-parameter -Wno-missing-field-initializers -Wno-language-extension-token -Wno-extended-offsetof -Wconditional-uninitialized -Qunused-arguments -Wincompatible-pointer-types-discards-qualifiers -Wmissing-variable-declarations";
 116
 117 # Warn that "make depend" should be run?
 118 my $warn_make_depend = 0;
 119
 120 # These are used in addition to $gcc_devteam_warn unless this is a mingw build.
 121 # This adds backtrace information to the memory leak info.
 122 my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE";
 123
 124
 125 my $strict_warnings = 0;
 126
 127 my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL";
 128
 129 # MD2_CHAR slags pentium pros
 130 my $x86_gcc_opts="RC4_INDEX MD2_INT";
 131
 132 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 133 # which would cover all BSD flavors. -pthread applies to them all,
 134 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 135 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 136 # which has to be accompanied by explicit -D_THREAD_SAFE and
 137 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 138 # seems to be sufficient?
 139 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 140
 141 #
 142 # API compability name to version number mapping.
 143 #
 144 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
 145 my $apitable = {
 146     "1.1.0" => "0x10100000L",
 147     "1.0.0" => "0x10000000L",
 148     "0.9.8" => "0x00908000L",
 149 };
 150
 151 my $base_target = "BASE";   # The template that all other inherit from
 152 our %table = ();
 153 our %config = ();
 154
 155 # Forward declarations ###############################################
 156
 157 # read_config(filename)
 158 #
 159 # Reads a configuration file and populates %table with the contents
 160 # (which the configuration file places in %targets).
 161 sub read_config;
 162
 163 # resolve_config(target)
 164 #
 165 # Resolves all the late evalutations, inheritances and so on for the
 166 # chosen target and any target it inherits from.
 167 sub resolve_config;
 168
 169
 170 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
 171 my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf");
 172 foreach (sort glob($pattern) ) {
 173     &read_config($_);
 174 }
 175
 176
 177 $config{perl};
 178 $config{prefix}="";
 179 $config{openssldir}="";
 180 $config{processor}="";
 181 my $libdir="";
 182 my $exe_ext="";
 183 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
 184 my $cross_compile_prefix="";
 185 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
 186 my $nofipscanistercheck=0;
 187 my $baseaddr="0xFB00000";
 188 my $no_threads=0;
 189 my $threads=0;
 190 my $no_shared=0; # but "no-shared" is default
 191 my $zlib=1;      # but "no-zlib" is default
 192 my $no_rfc3779=0;
 193 my $no_asm=0;
 194 my $no_dso=0;
 195 my @skip=();
 196 my $Makefile="Makefile";
 197 my $default_ranlib;
 198 my $fips=0;
 199
 200 # Known TLS and DTLS protocols
 201 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
 202 my @dtls = qw(dtls1 dtls1_2);
 203
 204 # Explicitelly known options that are possible to disable.  They can
 205 # be regexps, and will be used like this: /^no-${option}$/
 206 # For developers: keep it sorted alphabetically
 207
 208 my @disablables = (
 209     "aes",
 210     "asm",
 211     "bf",
 212     "camellia",
 213     "capieng",
 214     "cast",
 215     "chacha",
 216     "cmac",
 217     "cms",
 218     "comp",
 219     "crypto-mdebug",
 220     "ct",
 221     "deprecated",
 222     "des",
 223     "dgram",
 224     "dh",
 225     "dsa",
 226     "dso",
 227     "dtls",
 228     "dynamic[-_]engine",
 229     "ec",
 230     "ec2m",
 231     "ecdh",
 232     "ecdsa",
 233     "ec_nistp_64_gcc_128",
 234     "engine",
 235     "err",                      # Really???
 236     "gost",
 237     "heartbeats",
 238     "hmac",
 239     "hw(-.+)?",
 240     "idea",
 241     "jpake",
 242     "locking",                  # Really???
 243     "md2",
 244     "md4",
 245     "md5",
 246     "mdc2",
 247     "md[-_]ghost94",
 248     "nextprotoneg",
 249     "ocb",
 250     "ocsp",
 251     "poly1305",
 252     "posix-io",
 253     "psk",
 254     "rc2",
 255     "rc4",
 256     "rc5",
 257     "rdrand",
 258     "rfc3779",
 259     "rijndael",                 # Old AES name
 260     "rmd160",
 261     "rsa",
 262     "scrypt",
 263     "sct",
 264     "sctp",
 265     "seed",
 266     "sha",
 267     "shared",
 268     "sock",
 269     "srp",
 270     "srtp",
 271     "sse2",
 272     "ssl",
 273     "ssl-trace",
 274     "static-engine",
 275     "stdio",
 276     "store",
 277     "threads",
 278     "tls",
 279     "unit-test",
 280     "whirlpool",
 281     "zlib",
 282     "zlib-dynamic",
 283     );
 284 foreach my $proto ((@tls, @dtls))
 285         {
 286         push(@disablables, $proto);
 287         push(@disablables, "$proto-method");
 288         }
 289
 290 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 291
 292 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
 293                  "ec_nistp_64_gcc_128" => "default",
 294                  "egd"            => "default",
 295                  "jpake"          => "experimental",
 296                  "md2"            => "default",
 297                  "rc5"            => "default",
 298                  "sctp"           => "default",
 299                  "shared"         => "default",
 300                  "ssl-trace"      => "default",
 301                  "store"          => "experimental",
 302                  "unit-test"      => "default",
 303                  "zlib"           => "default",
 304                  "zlib-dynamic"   => "default",
 305                  "crypto-mdebug"  => "default",
 306                );
 307 my @experimental = ();
 308
 309 # Note: => pair form used for aesthetics, not to truly make a hash table
 310 my @disable_cascades = (
 311     # "what"            => [ "cascade", ... ]
 312     sub { $config{processor} eq "386" }
 313                         => [ "sse2" ],
 314     "ssl"               => [ "ssl3" ],
 315     "ssl3-method"       => [ "ssl3" ],
 316     "zlib"              => [ "zlib-dynamic" ],
 317     "rijndael"          => [ "aes" ],
 318     "des"               => [ "mdc2" ],
 319     "ec"                => [ "ecdsa", "ecdh", "gost" ],
 320     "dsa"               => [ "gost" ],
 321     "dh"                => [ "gost" ],
 322     "psk"               => [ "jpake" ],
 323
 324     "dgram"             => [ "dtls" ],
 325     "dtls"              => [ @dtls ],
 326
 327     # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
 328     "md5"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
 329     "sha"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
 330
 331     # Additionally, SSL 3.0 requires either RSA or DSA+DH
 332     sub { $disabled{rsa}
 333           && ($disabled{dsa} || $disabled{dh}); }
 334                         => [ "ssl" ],
 335
 336     # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
 337     # or ECDSA + ECDH.  (D)TLS 1.2 has this requirement as well.
 338     # (XXX: We don't support PSK-only builds).
 339     sub { $disabled{rsa}
 340           && ($disabled{dsa} || $disabled{dh})
 341           && ($disabled{ecdsa} || $disabled{ecdh}); }
 342                         => [ "tls1", "tls1_1", "tls1_2",
 343                              "dtls1", "dtls1_2" ],
 344
 345     "tls"               => [ @tls ],
 346
 347     # SRP and HEARTBEATS require TLSEXT
 348     "tlsext"            => [ "srp", "heartbeats" ],
 349     );
 350
 351 # Avoid protocol support holes.  Also disable all versions below N, if version
 352 # N is disabled while N+1 is enabled.
 353 #
 354 my @list = (reverse @tls);
 355 while ((my $first, my $second) = (shift @list, shift @list)) {
 356     last unless @list;
 357     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 358                               => [ @list ] );
 359     unshift @list, $second;
 360 }
 361 my @list = (reverse @dtls);
 362 while ((my $first, my $second) = (shift @list, shift @list)) {
 363     last unless @list;
 364     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 365                               => [ @list ] );
 366     unshift @list, $second;
 367 }
 368
 369 # Construct the string of what $depflags should look like with the defaults
 370 # from %disabled above.  (we need this to see if we should advise the user
 371 # to run "make depend"):
 372 my $default_depflags = " ".join(" ",
 373     map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; }
 374     grep { $disabled{$_} !~ /\(no-depflags\)$/ }
 375     sort keys %disabled);
 376
 377 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 378 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
 379 # For symmetry, "disable-foo" is a synonym for "no-foo".
 380
 381 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
 382 # We will collect such requests in @experimental.
 383 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
 384
 385
 386 my $no_sse2=0;
 387
 388 &usage if ($#ARGV < 0);
 389
 390 my $flags="";
 391 my $depflags="";
 392 $config{openssl_experimental_defines}=[];
 393 $config{openssl_api_defines}=[];
 394 $config{openssl_algorithm_defines}=[];
 395 $config{openssl_thread_defines}=[];
 396 $config{openssl_sys_defines}=[];
 397 $config{openssl_other_defines}=[];
 398 my $libs="";
 399 my $target="";
 400 $config{options}="";
 401 my $api;
 402 my $make_depend=0;
 403 my %withargs=();
 404 my $build_prefix = "release_";
 405
 406 my @argvcopy=@ARGV;
 407
 408 if (grep /^reconf(igure)?$/, @argvcopy) {
 409     if (open IN, "<$Makefile") {
 410         while (<IN>) {
 411             chomp;
 412             if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
 413                 my $line = $1;
 414                 if ($line =~ /^\s*\(/) {
 415                     # New form perl expression saved in Makefile, eval it
 416                     @argvcopy = eval $line;
 417                 } else {
 418                     # Older form, we split the string and hope for the best
 419                     @argvcopy = split /\s+/, $line;
 420                 }
 421                 die "Incorrect data to reconfigure, please do a normal configuration\n"
 422                     if (grep(/^reconf/,@argvcopy));
 423             } elsif (/^CROSS_COMPILE=\s*(.*)/) {
 424                 $ENV{CROSS_COMPILE}=$1;
 425             } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
 426                 $ENV{CC}=$1;
 427             }
 428         }
 429         print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
 430         print "    CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
 431             if $ENV{CROSS_COMPILE};
 432         print "    CC = ",$ENV{CC},"\n" if $ENV{CC};
 433         close IN;
 434     } else {
 435         die "Insufficient data to reconfigure, please do a normal configuration\n";
 436     }
 437 }
 438
 439
 440 my %unsupported_options = ();
 441 foreach (@argvcopy)
 442         {
 443         s /^-no-/no-/; # some people just can't read the instructions
 444
 445         # rewrite some options in "enable-..." form
 446         s /^-?-?shared$/enable-shared/;
 447         s /^sctp$/enable-sctp/;
 448         s /^threads$/enable-threads/;
 449         s /^zlib$/enable-zlib/;
 450         s /^zlib-dynamic$/enable-zlib-dynamic/;
 451
 452         if (/^(no|disable|enable|experimental)-(.+)$/)
 453                 {
 454                 my $word = $2;
 455                 if (!grep { $word =~ /^${_}$/ } @disablables)
 456                         {
 457                         $unsupported_options{$_} = 1;
 458                         next;
 459                         }
 460                 }
 461         if (/^no-(.+)$/ || /^disable-(.+)$/)
 462                 {
 463                 if (!($disabled{$1} eq "experimental"))
 464                         {
 465                         foreach my $proto ((@tls, @dtls))
 466                                 {
 467                                 if ($1 eq "$proto-method")
 468                                         {
 469                                         $disabled{"$proto"} = "option($proto-method)";
 470                                         last;
 471                                         }
 472                                 }
 473                         if ($1 eq "dtls")
 474                                 {
 475                                 foreach my $proto (@dtls)
 476                                         {
 477                                         $disabled{$proto} = "option(dtls)";
 478                                         }
 479                                 }
 480                         elsif ($1 eq "ssl")
 481                                 {
 482                                 # Last one of its kind
 483                                 $disabled{"ssl3"} = "option(ssl)";
 484                                 }
 485                         elsif ($1 eq "tls")
 486                                 {
 487                                 # XXX: Tests will fail if all SSL/TLS
 488                                 # protocols are disabled.
 489                                 foreach my $proto (@tls)
 490                                         {
 491                                         $disabled{$proto} = "option(tls)";
 492                                         }
 493                                 }
 494                         else
 495                                 {
 496                                 $disabled{$1} = "option";
 497                                 }
 498                         }
 499                 }
 500         elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
 501                 {
 502                 my $algo = $1;
 503                 if ($disabled{$algo} eq "experimental")
 504                         {
 505                         die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
 506                                 unless (/^experimental-/);
 507                         push @experimental, $algo;
 508                         }
 509                 delete $disabled{$algo};
 510
 511                 $threads = 1 if ($algo eq "threads");
 512                 }
 513         elsif (/^--strict-warnings$/)
 514                 {
 515                 $strict_warnings = 1;
 516                 }
 517         elsif (/^--debug$/)
 518                 {
 519                 $build_prefix = "debug_";
 520                 }
 521         elsif (/^--release$/)
 522                 {
 523                 $build_prefix = "release_";
 524                 }
 525         elsif (/^386$/)
 526                 { $config{processor}=386; }
 527         elsif (/^fips$/)
 528                 {
 529                 $fips=1;
 530                 }
 531         elsif (/^rsaref$/)
 532                 {
 533                 # No RSAref support any more since it's not needed.
 534                 # The check for the option is there so scripts aren't
 535                 # broken
 536                 }
 537         elsif (/^nofipscanistercheck$/)
 538                 {
 539                 $fips = 1;
 540                 $nofipscanistercheck = 1;
 541                 }
 542         elsif (/^[-+]/)
 543                 {
 544                 if (/^--prefix=(.*)$/)
 545                         {
 546                         $config{prefix}=$1;
 547                         }
 548                 elsif (/^--api=(.*)$/)
 549                         {
 550                         $api=$1;
 551                         }
 552                 elsif (/^--libdir=(.*)$/)
 553                         {
 554                         $libdir=$1;
 555                         }
 556                 elsif (/^--openssldir=(.*)$/)
 557                         {
 558                         $config{openssldir}=$1;
 559                         }
 560                 elsif (/^--install.prefix=(.*)$/)
 561                         {
 562                         $install_prefix=$1;
 563                         }
 564                 elsif (/^--with-zlib-lib=(.*)$/)
 565                         {
 566                         $withargs{"zlib-lib"}=$1;
 567                         }
 568                 elsif (/^--with-zlib-include=(.*)$/)
 569                         {
 570                         $withargs{"zlib-include"}="-I$1";
 571                         }
 572                 elsif (/^--with-fipslibdir=(.*)$/)
 573                         {
 574                         $fipslibdir="$1/";
 575                         }
 576                 elsif (/^--with-baseaddr=(.*)$/)
 577                         {
 578                         $baseaddr="$1";
 579                         }
 580                 elsif (/^--cross-compile-prefix=(.*)$/)
 581                         {
 582                         $cross_compile_prefix=$1;
 583                         }
 584                 elsif (/^--config=(.*)$/)
 585                         {
 586                         read_config $1;
 587                         }
 588                 elsif (/^-[lL](.*)$/ or /^-Wl,/)
 589                         {
 590                         $libs.=$_." ";
 591                         }
 592                 else    # common if (/^[-+]/), just pass down...
 593                         {
 594                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 595                         $flags.=$_." ";
 596                         }
 597                 }
 598         elsif ($_ =~ /^([^:]+):(.+)$/)
 599                 {
 600                 eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
 601                 $target=$1;
 602                 }
 603         else
 604                 {
 605                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
 606                 $target=$_;
 607                 }
 608         unless ($_ eq $target || /^no-/ || /^disable-/)
 609                 {
 610                 # "no-..." follows later after implied disactivations
 611                 # have been derived.  (Don't take this too seroiusly,
 612                 # we really only write OPTIONS to the Makefile out of
 613                 # nostalgia.)
 614
 615                 if ($config{options} eq "")
 616                         { $config{options} = $_; }
 617                 else
 618                         { $config{options} .= " ".$_; }
 619                 }
 620
 621         if (defined($api) && !exists $apitable->{$api}) {
 622                 die "***** Unsupported api compatibility level: $api\n",
 623         }
 624
 625         if (keys %unsupported_options)
 626                 {
 627                 die "***** Unsupported options: ",
 628                         join(", ", keys %unsupported_options), "\n";
 629                 }
 630         }
 631
 632 if ($fips)
 633         {
 634         delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
 635         }
 636
 637 my @tocheckfor = (keys %disabled);
 638 while (@tocheckfor) {
 639     my %new_tocheckfor = ();
 640     my @cascade_copy = (@disable_cascades);
 641     while (@cascade_copy) {
 642         my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
 643         if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
 644             map {
 645                 $new_tocheckfor{$_} => 1; $disabled{$_} = "forced";
 646             } grep { !defined($disabled{$_}) } @$descendents;
 647         }
 648     }
 649     @tocheckfor = (keys %new_tocheckfor);
 650 }
 651
 652 if ($target eq "TABLE") {
 653     foreach (sort keys %table) {
 654         print_table_entry($_, "TABLE");
 655     }
 656     exit 0;
 657 }
 658
 659 if ($target eq "LIST") {
 660     foreach (sort keys %table) {
 661         print $_,"\n" unless $table{$_}->{template};
 662     }
 663     exit 0;
 664 }
 665
 666 if ($target eq "HASH") {
 667     print "%table = (\n";
 668     foreach (sort keys %table) {
 669         print_table_entry($_, "HASH");
 670     }
 671     exit 0;
 672 }
 673
 674 # Backward compatibility?
 675 if ($target =~ m/^CygWin32(-.*)$/) {
 676     $target = "Cygwin".$1;
 677 }
 678
 679 foreach (sort (keys %disabled))
 680         {
 681         $config{options} .= " no-$_";
 682
 683         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
 684
 685         if (/^dso$/)
 686                 { $no_dso = 1; }
 687         elsif (/^threads$/)
 688                 { $no_threads = 1; }
 689         elsif (/^shared$/)
 690                 { $no_shared = 1; }
 691         elsif (/^zlib$/)
 692                 { $zlib = 0; }
 693         elsif (/^static-engine$/)
 694                 { }
 695         elsif (/^zlib-dynamic$/)
 696                 { }
 697         elsif (/^sse2$/)
 698                 { $no_sse2 = 1; }
 699         else
 700                 {
 701                 my ($ALGO, $algo);
 702                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
 703
 704                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
 705                         {
 706                         push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
 707                         print " OPENSSL_NO_$ALGO";
 708
 709                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
 710                         elsif (/^asm$/) { $no_asm = 1; }
 711                         }
 712                 else
 713                         {
 714                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
 715
 716                         push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
 717                         print " OPENSSL_NO_$ALGO";
 718
 719                         push @skip, $algo;
 720                         # fix-up crypto/directory name(s)
 721                         $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
 722                         $skip[$#skip]="ripemd" if $algo eq "rmd160";
 723
 724                         print " (skip dir)";
 725
 726                         $depflags .= " -DOPENSSL_NO_$ALGO";
 727                         }
 728                 }
 729
 730         print "\n";
 731         }
 732
 733 my $exp_cflags = "";
 734
 735 foreach (sort @experimental)
 736         {
 737         my $ALGO;
 738         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
 739
 740         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
 741         push @{$config{openssl_experimental_defines}}, "OPENSSL_NO_$ALGO";
 742         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
 743         }
 744
 745 print "Configuring for $target\n";
 746
 747 # Support for legacy targets having a name starting with 'debug-'
 748 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
 749 if ($d) {
 750     $build_prefix = "debug_";
 751
 752     # If we do not find debug-foo in the table, the target is set to foo.
 753     if (!$table{$target}) {
 754         $target = $t;
 755     }
 756 }
 757 $config{target} = $target;
 758 delete $table{$base_target}->{template}; # or the next test will fail.
 759 my %target = ( %{$table{$base_target}}, resolve_config($target) );
 760
 761 &usage if (!%target || $target{template});
 762
 763 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
 764 $exe_ext=".nlm" if ($target =~ /netware/);
 765 $exe_ext=".pm"  if ($target =~ /vos/);
 766
 767 $default_ranlib = which("ranlib") || "true";
 768 $config{perl}   = $ENV{'PERL'} || which("perl5") || which("perl") || "perl";
 769 my $make        = $ENV{'MAKE'} || "make";
 770
 771 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
 772
 773 $config{prefix} = "/usr/local" if !$config{prefix};
 774 $config{openssldir} = "ssl" if !$config{openssldir};
 775 $config{openssldir} = catdir($config{prefix}, $config{openssldir})
 776     unless file_name_is_absolute($config{openssldir});
 777
 778 # Allow environment CC to override compiler...
 779 $target{cc} = $ENV{CC} || $target{cc};
 780
 781 # For cflags and lflags, add the debug_ or release_ attributes
 782 # Do it in such a way that no spurious space is appended (hence the grep).
 783 my $cflags = join(" ",
 784                   grep { $_ } ($target{cflags},
 785                                $target{$build_prefix."cflags"}));
 786 my $lflags = join(" ",
 787                   grep { $_ } ($target{lflags},
 788                                $target{$build_prefix."lflags"}));
 789
 790 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} || $default_ranlib;
 791 $target{ar} = $ENV{'AR'} || "ar";
 792 # Make sure build_scheme is consistent.
 793 $target{build_scheme} = [ $target{build_scheme} ]
 794     if ref($target{build_scheme}) ne "ARRAY";
 795
 796 # if $config{prefix}/lib$target{multilib} is not an existing directory, then
 797 # assume that it's not searched by linker automatically, in
 798 # which case adding $target{multilib} suffix causes more grief than
 799 # we're ready to tolerate, so don't...
 800 $target{multilib}="" if !-d "$config{prefix}/lib$target{multilib}";
 801
 802 $libdir="lib$target{multilib}" if $libdir eq "";
 803 $config{enginesdir}=$config{prefix} . "/" . $libdir  . "/engines";
 804
 805 $cflags = "$cflags$exp_cflags";
 806
 807 # '%' in $lflags is used to split flags to "pre-" and post-flags
 808 my ($prelflags,$postlflags)=split('%',$lflags);
 809 if (defined($postlflags))       { $lflags=$postlflags;  }
 810 else                            { $lflags=$prelflags; undef $prelflags; }
 811
 812 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/\-mno\-cygwin/m)
 813         {
 814         $cflags =~ s/\-mno\-cygwin\s*//;
 815         $target{shared_ldflag} =~ s/\-mno\-cygwin\s*//;
 816         }
 817
 818 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
 819         # minimally required architecture flags for assembly modules
 820         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
 821         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
 822 }
 823
 824 my $no_shared_warn=0;
 825 my $no_user_cflags=0;
 826
 827 if ($flags ne "")       { $cflags="$flags$cflags"; }
 828 else                    { $no_user_cflags=1;       }
 829
 830 # The DSO code currently always implements all functions so that no
 831 # applications will have to worry about that from a compilation point
 832 # of view. However, the "method"s may return zero unless that platform
 833 # has support compiled in for them. Currently each method is enabled
 834 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
 835 # string entry into using the following logic;
 836 my $dso_cflags;
 837 if (!$no_dso && $target{dso_scheme} ne "")
 838         {
 839         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
 840         if ($target{dso_scheme} eq "DLFCN")
 841                 {
 842                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
 843                 }
 844         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
 845                 {
 846                 $dso_cflags = "-DDSO_DLFCN";
 847                 }
 848         else
 849                 {
 850                 $dso_cflags = "-DDSO_$target{dso_scheme}";
 851                 }
 852         $cflags = "$dso_cflags $cflags";
 853         }
 854
 855 my $thread_cflags;
 856 my @thread_defines;
 857 if ($target{thread_cflag} ne "(unknown)" && !$no_threads)
 858         {
 859         # If we know how to do it, support threads by default.
 860         $threads = 1;
 861         }
 862 if ($target{thread_cflag} eq "(unknown)" && $threads)
 863         {
 864         # If the user asked for "threads", [s]he is also expected to
 865         # provide any system-dependent compiler options that are
 866         # necessary.
 867         if ($no_user_cflags)
 868                 {
 869                 print "You asked for multi-threading support, but didn't\n";
 870                 print "provide any system-specific compiler options\n";
 871                 exit(1);
 872                 }
 873         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
 874         push @thread_defines, "OPENSSL_THREADS";
 875         }
 876 else
 877         {
 878         $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag} $cflags";
 879         push @thread_defines, "OPENSSL_THREADS";
 880 #       my $def;
 881 #       foreach $def (split ' ',$target{thread_cflag})
 882 #               {
 883 #               if ($def =~ s/^-D// && $def !~ /^_/)
 884 #                       {
 885 #                       push @thread_defines, "$def";
 886 #                       }
 887 #               }
 888         }
 889
 890 $lflags="$libs$lflags" if ($libs ne "");
 891
 892 if ($no_asm)
 893         {
 894         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
 895         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
 896         }
 897
 898 if ($threads)
 899         {
 900         $cflags=$thread_cflags;
 901         push @{$config{openssl_thread_defines}}, @thread_defines;
 902         }
 903
 904 if ($zlib)
 905         {
 906         $cflags = "-DZLIB $cflags";
 907         if (defined($disabled{"zlib-dynamic"}))
 908                 {
 909                 if (defined($withargs{"zlib-lib"}))
 910                         {
 911                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
 912                         }
 913                 else
 914                         {
 915                         $lflags = "$lflags -lz";
 916                         }
 917                 }
 918         else
 919                 {
 920                 $cflags = "-DZLIB_SHARED $cflags";
 921                 }
 922         }
 923
 924 # With "deprecated" disable all deprecated features.
 925 if (defined($disabled{"deprecated"})) {
 926         $api = $maxapi;
 927 }
 928
 929 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.in
 930 my $shared_mark = "";
 931 if ($target{shared_target} eq "")
 932         {
 933         $no_shared_warn = 1 if !$no_shared && !$fips;
 934         $no_shared = 1;
 935         }
 936 if (!$no_shared)
 937         {
 938         if ($target{shared_cflag} ne "")
 939                 {
 940                 $cflags = "$target{shared_cflag} -DOPENSSL_PIC $cflags";
 941                 }
 942         }
 943
 944 if ($target{build_scheme}->[0] ne "mk1mf")
 945         {
 946         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
 947         if ($no_shared)
 948                 {
 949                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
 950                 $config{options}.=" static-engine";
 951                 }
 952         else
 953                 {
 954                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE";
 955                 $config{options}.=" no-static-engine";
 956                 }
 957         }
 958
 959 #
 960 # Platform fix-ups
 961 #
 962 if ($target =~ /\-icc$/)        # Intel C compiler
 963         {
 964         my $iccver=0;
 965         if (open(FD,"$target{cc} -V 2>&1 |"))
 966                 {
 967                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
 968                 close(FD);
 969                 }
 970         if ($iccver>=8)
 971                 {
 972                 $cflags=~s/\-KPIC/-fPIC/;
 973                 # Eliminate unnecessary dependency from libirc.a. This is
 974                 # essential for shared library support, as otherwise
 975                 # apps/openssl can end up in endless loop upon startup...
 976                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
 977                 }
 978         if ($iccver>=9)
 979                 {
 980                 $lflags.=" -i-static";
 981                 $lflags=~s/\-no_cpprt/-no-cpprt/;
 982                 }
 983         if ($iccver>=10)
 984                 {
 985                 $lflags=~s/\-i\-static/-static-intel/;
 986                 }
 987         if ($iccver>=11)
 988                 {
 989                 $cflags.=" -no-intel-extensions";       # disable Cilk
 990                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
 991                 }
 992         }
 993
 994 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
 995 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
 996 # .so objects. Apparently application RPATH is not global and does
 997 # not apply to .so linked with other .so. Problem manifests itself
 998 # when libssl.so fails to load libcrypto.so. One can argue that we
 999 # should engrave this into Makefile.shared rules or into BSD-* config
1000 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1001 # linker only when --prefix is not /usr.
1002 if ($target =~ /^BSD\-/)
1003         {
1004         $target{shared_ldflag}.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($config{prefix} !~ m|^/usr[/]*$|);
1005         }
1006
1007 if ($target{sys_id} ne "")
1008         {
1009         #$cflags="-DOPENSSL_SYS_$target{sys_id} $cflags";
1010         push @{$config{openssl_sys_defines}}="OPENSSL_SYS_$target{sys_id}";
1011         }
1012
1013 if ($target{ranlib} eq "")
1014         {
1015         $target{ranlib} = $default_ranlib;
1016         }
1017
1018 if (!$no_asm) {
1019     $target{cpuid_obj}=$table{BASE}->{cpuid_obj} if ($config{processor} eq "386");
1020     $target{cpuid_obj}.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1021
1022     $target{bn_obj} =~ s/\w+-gf2m.o// if (defined($disabled{ec2m}));
1023
1024     # bn-586 is the only one implementing bn_*_part_words
1025     $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_obj} =~ /bn-586/);
1026     $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_obj} =~ /86/);
1027
1028     $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_obj} =~ /-mont/);
1029     $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_obj} =~ /-mont5/);
1030     $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_obj} =~ /-gf2m/);
1031
1032     if ($fips) {
1033         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1034     }
1035
1036     if ($target{sha1_obj} =~ /\.o$/) {
1037         $cflags.=" -DSHA1_ASM"   if ($target{sha1_obj} =~ /sx86/ || $target{sha1_obj} =~ /sha1/);
1038         $cflags.=" -DSHA256_ASM" if ($target{sha1_obj} =~ /sha256/);
1039         $cflags.=" -DSHA512_ASM" if ($target{sha1_obj} =~ /sha512/);
1040         if ($target{sha1_obj} =~ /sse2/) {
1041             if ($no_sse2) {
1042                 $target{sha1_obj} =~ s/\S*sse2\S+//;
1043             } elsif ($cflags !~ /OPENSSL_IA32_SSE2/) {
1044                 $cflags.=" -DOPENSSL_IA32_SSE2";
1045             }
1046         }
1047     }
1048     if ($target{md5_obj} =~ /\.o$/) {
1049         $cflags.=" -DMD5_ASM";
1050     }
1051     $target{cast_obj}=$table{BASE}->{cast_obj} if (!$no_shared); # CAST assembler is not PIC
1052     if ($target{rmd160_obj} =~ /\.o$/) {
1053         $cflags.=" -DRMD160_ASM";
1054     }
1055     if ($target{aes_obj} =~ /\.o$/) {
1056         $cflags.=" -DAES_ASM" if ($target{aes_obj} =~ m/\baes\-/);;
1057         # aes-ctr.o is not a real file, only indication that assembler
1058         # module implements AES_ctr32_encrypt...
1059         $cflags.=" -DAES_CTR_ASM" if ($target{aes_obj} =~ s/\s*aes\-ctr\.o//);
1060         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1061         $cflags.=" -DAES_XTS_ASM" if ($target{aes_obj} =~ s/\s*aes\-xts\.o//);
1062         $target{aes_obj} =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1063         $cflags.=" -DVPAES_ASM" if ($target{aes_obj} =~ m/vpaes/);
1064         $cflags.=" -DBSAES_ASM" if ($target{aes_obj} =~ m/bsaes/);
1065     }
1066     if ($target{wp_obj} =~ /mmx/ && $config{processor} eq "386") {
1067         $target{wp_obj}=$table{BASE}->{wp_obj};
1068     } elsif (!$disabled{"whirlpool"}) {
1069         $cflags.=" -DWHIRLPOOL_ASM";
1070     }
1071     if ($target{modes_obj} =~ /ghash\-/) {
1072         $cflags.=" -DGHASH_ASM";
1073     }
1074     if ($target{ec_obj} =~ /ecp_nistz256/) {
1075         $cflags.=" -DECP_NISTZ256_ASM";
1076     }
1077     if ($target{poly1305_obj} =~ /\.o$/) {
1078         $cflags.=" -DPOLY1305_ASM";
1079     }
1080 }
1081
1082
1083 # Deal with bn_ops ###################################################
1084
1085 $config{des_ptr}                =0;
1086 $config{des_risc1}              =0;
1087 $config{des_risc2}              =0;
1088 $config{des_unroll}             =0;
1089 $config{bn_ll}                  =0;
1090 $config{rc4_idx}                =0;
1091 $config{bf_ptr}                 =0;
1092 $config{export_var_as_fn}       =0;
1093 my $def_int="unsigned int";
1094 $config{rc4_int}                =$def_int;
1095 $config{rc4_chunk}              ="";
1096 $config{md2_int}                =$def_int;
1097 $config{idea_int}               =$def_int;
1098 $config{rc2_int}                =$def_int;
1099 ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})=(0,0,1,0,0);
1100
1101 $config{des_int} = "unsigned long";
1102
1103 foreach (sort split(/\s+/,$target{bn_ops})) {
1104     $config{des_ptr}=1                          if /DES_PTR/;
1105     $config{des_risc1}=1                        if /DES_RISC1/;
1106     $config{des_risc2}=1                        if /DES_RISC2/;
1107     $config{des_unroll}=1                       if /DES_UNROLL/;
1108     $config{des_int}="unsigned int"             if /DES_INT/;
1109     $config{bn_ll}=1                            if /BN_LLONG/;
1110     $config{rc4_int}="unsigned char"            if /RC4_CHAR/;
1111     $config{rc4_int}="unsigned long"            if /RC4_LONG/;
1112     $config{rc4_idx}=1                          if /RC4_INDEX/;
1113     $config{rc4_chunk}="unsigned long"          if /RC4_CHUNK/;
1114     $config{rc4_chunk}="unsigned long long"     if /RC4_CHUNK_LL/;
1115     $config{md2_int}="unsigned char"            if /MD2_CHAR/;
1116     $config{md2_int}="unsigned long"            if /MD2_LONG/;
1117     $config{idea_int}="unsigned char"           if /IDEA_CHAR/;
1118     $config{idea_int}="unsigned long"           if /IDEA_LONG/;
1119     $config{rc2_int}="unsigned char"            if /RC2_CHAR/;
1120     $config{rc2_int}="unsigned long"            if /RC2_LONG/;
1121     $config{bf_ptr}=1                           if $_ eq "BF_PTR";
1122     $config{bf_ptr}=2                           if $_ eq "BF_PTR2";
1123     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1124         =(0,1,0,0,0)                            if /SIXTY_FOUR_BIT/;
1125     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1126         =(1,0,0,0,0)                            if /SIXTY_FOUR_BIT_LONG/;
1127     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1128         =(0,0,1,0,0)                            if /THIRTY_TWO_BIT/;
1129     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1130         =(0,0,0,1,0)                            if /SIXTEEN_BIT/;
1131     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1132         =(0,0,0,0,1)                            if /EIGHT_BIT/;
1133     $config{export_var_as_fn}=1                 if /EXPORT_VAR_AS_FN/;
1134 }
1135
1136
1137 # Hack cflags for better warnings (dev option) #######################
1138
1139 # "Stringify" the C flags string.  This permits it to be made part of a string
1140 # and works as well on command lines.
1141 $cflags =~ s/([\\\"])/\\\1/g;
1142
1143 $config{version} = "unknown";
1144 $config{version_num} = "unknown";
1145 $config{major} = "unknown";
1146 $config{minor} = "unknown";
1147 $config{shlib_version_number} = "unknown";
1148 $config{shlib_version_history} = "unknown";
1149 $config{shlib_major} = "unknown";
1150 $config{shlib_minor} = "unknown";
1151
1152 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1153 while (<IN>)
1154         {
1155         $config{version}=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1156         $config{version_num}=$1 if /OPENSSL.VERSION.NUMBER.*(0x\S+)/;
1157         $config{shlib_version_number}=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1158         $config{shlib_version_history}=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1159         }
1160 close(IN);
1161 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
1162
1163 if ($config{version} =~ /(^[0-9]*)\.([0-9\.]*)/)
1164         {
1165         $config{major}=$1;
1166         $config{minor}=$2;
1167         }
1168
1169 if ($config{shlib_version_number} =~ /(^[0-9]*)\.([0-9\.]*)/)
1170         {
1171         $config{shlib_major}=$1;
1172         $config{shlib_minor}=$2;
1173         }
1174
1175 if (defined($api)) {
1176     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$api} ];
1177     my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$api});
1178     $default_depflags .= " $apiflag";
1179     $cflags .= " $apiflag";
1180 }
1181
1182 my $ecc = $target{cc};
1183 $ecc = "clang" if `$target{cc} --version 2>&1` =~ /clang/;
1184
1185 if ($strict_warnings)
1186         {
1187         my $wopt;
1188         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1189         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1190                 {
1191                 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1192                 }
1193         if ($ecc eq "clang")
1194                 {
1195                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1196                         {
1197                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1198                         }
1199                 }
1200         if ($target !~ /^mingw/)
1201                 {
1202                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1203                         {
1204                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1205                         }
1206                 if ($target =~ /^BSD-/)
1207                         {
1208                         $lflags .= " -lexecinfo";
1209                         }
1210                 }
1211         }
1212
1213 # Write down our configuration where it fits #########################
1214
1215 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1216 print OUT <<"EOF";
1217 package configdata;
1218
1219 use strict;
1220 use warnings;
1221
1222 use Exporter;
1223 #use vars qw(\@ISA \@EXPORT);
1224 our \@ISA = qw(Exporter);
1225 our \@EXPORT = qw(\%config \%target);
1226
1227 EOF
1228 print OUT "our %config = (\n";
1229 foreach (sort keys %config) {
1230     if (ref($config{$_}) eq "ARRAY") {
1231         print OUT "  ", $_, " => [ ", join(", ",
1232                                            map { quotify("perl", $_) }
1233                                            @{$config{$_}}), " ],\n";
1234     } else {
1235         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1236     }
1237 }
1238 print OUT <<"EOF";
1239 );
1240
1241 EOF
1242 print OUT "our %target = (\n";
1243 foreach (sort keys %target) {
1244     if (ref($target{$_}) eq "ARRAY") {
1245         print OUT "  ", $_, " => [ ", join(", ",
1246                                            map { quotify("perl", $_) }
1247                                            @{$target{$_}}), " ],\n";
1248     } else {
1249         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1250     }
1251 }
1252 print OUT <<"EOF";
1253 );
1254
1255 1;
1256 EOF
1257 close(OUT);
1258
1259 open(IN,"<Makefile.in") || die "unable to read Makefile.in: $!\n";
1260 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1261 print OUT "### Generated automatically from Makefile.in by Configure.\n\n";
1262 my $sdirs=0;
1263
1264 while (<IN>)
1265         {
1266         chomp;
1267         $sdirs = 1 if /^SDIRS=/;
1268         if ($sdirs) {
1269                 my $dir;
1270                 foreach $dir (@skip) {
1271                         s/(\s)$dir /$1/;
1272                         s/\s$dir$//;
1273                         }
1274                 }
1275         $sdirs = 0 unless /\\$/;
1276         s/fips // if (/^DIRS=/ && !$fips);
1277         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1278         s/^VERSION=.*/VERSION=$config{version}/;
1279         s/^MAJOR=.*/MAJOR=$config{major}/;
1280         s/^MINOR=.*/MINOR=$config{minor}/;
1281         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$config{shlib_version_number}/;
1282         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$config{shlib_version_history}/;
1283         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$config{shlib_major}/;
1284         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$config{shlib_minor}/;
1285         s/^SHLIB_EXT=.*/SHLIB_EXT=$target{shared_extension}/;
1286         s/^INSTALLTOP=.*$/INSTALLTOP=$config{prefix}/;
1287         s/^MULTILIB=.*$/MULTILIB=$target{multilib}/;
1288         s/^OPENSSLDIR=.*$/OPENSSLDIR=$config{openssldir}/;
1289         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1290         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1291         s/^PLATFORM=.*$/PLATFORM=$target/;
1292         s/^OPTIONS=.*$/OPTIONS=$config{options}/;
1293         my $argvstring = "(".join(", ", map { quotify("perl", $_) } @argvcopy).")";
1294         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1295         if ($cross_compile_prefix)
1296                 {
1297                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$target{cc}/;
1298                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1299                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1300                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1301                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$target{cc}/ if $target{cc} eq "gcc";
1302                 }
1303         else    {
1304                 s/^CC=.*$/CC= $target{cc}/;
1305                 s/^AR=\s*ar/AR= $target{ar}/;
1306                 s/^RANLIB=.*/RANLIB= $target{ranlib}/;
1307                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $target{cc}/ if $ecc eq "gcc" || $ecc eq "clang";
1308                 }
1309         s/^CFLAG=.*$/CFLAG= $cflags/;
1310         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1311         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1312         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1313         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1314         s/^CPUID_OBJ=.*$/CPUID_OBJ= $target{cpuid_obj}/;
1315         s/^BN_ASM=.*$/BN_ASM= $target{bn_obj}/;
1316         s/^EC_ASM=.*$/EC_ASM= $target{ec_obj}/;
1317         s/^DES_ENC=.*$/DES_ENC= $target{des_obj}/;
1318         s/^AES_ENC=.*$/AES_ENC= $target{aes_obj}/;
1319         s/^BF_ENC=.*$/BF_ENC= $target{bf_obj}/;
1320         s/^CAST_ENC=.*$/CAST_ENC= $target{cast_obj}/;
1321         s/^RC4_ENC=.*$/RC4_ENC= $target{rc4_obj}/;
1322         s/^RC5_ENC=.*$/RC5_ENC= $target{rc5_obj}/;
1323         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $target{md5_obj}/;
1324         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $target{sha1_obj}/;
1325         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $target{rmd160_obj}/;
1326         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $target{wp_obj}/;
1327         s/^CMLL_ENC=.*$/CMLL_ENC= $target{cmll_obj}/;
1328         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $target{modes_obj}/;
1329         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $target{engines_obj}/;
1330         s/^CHACHA_ENC=.*$/CHACHA_ENC= $target{chacha_obj}/;
1331         s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $target{poly1305_obj}/;
1332         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $target{perlasm_scheme}/;
1333         s/^PROCESSOR=.*/PROCESSOR= $config{processor}/;
1334         s/^ARFLAGS=.*/ARFLAGS= $target{arflags}/;
1335         s/^PERL=.*/PERL= $config{perl}/;
1336         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1337         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1338         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1339         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1340         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1341         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1342         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1343         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$target{shared_target}/;
1344         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1345         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1346         if ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.s([ol])\.[^\.]*$/)
1347                 {
1348                 my $sotmp = $1;
1349                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1350                 }
1351         elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.[^\.]*\.dylib$/)
1352                 {
1353                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1354                 }
1355         elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1356                 {
1357                 my $sotmp = $1;
1358                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1359                 }
1360         elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1361                 {
1362                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1363                 }
1364         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$target{shared_ldflag}/;
1365         print OUT $_."\n";
1366         }
1367 close(IN);
1368 close(OUT);
1369 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1370
1371 print "IsMK1MF       =", ($target{build_scheme}->[0] eq "mk1mf" ? "yes" : "no"), "\n";
1372 print "CC            =$target{cc}\n";
1373 print "CFLAG         =$cflags\n";
1374 print "EX_LIBS       =$lflags\n";
1375 print "CPUID_OBJ     =$target{cpuid_obj}\n";
1376 print "BN_ASM        =$target{bn_obj}\n";
1377 print "EC_ASM        =$target{ec_obj}\n";
1378 print "DES_ENC       =$target{des_obj}\n";
1379 print "AES_ENC       =$target{aes_obj}\n";
1380 print "BF_ENC        =$target{bf_obj}\n";
1381 print "CAST_ENC      =$target{cast_obj}\n";
1382 print "RC4_ENC       =$target{rc4_obj}\n";
1383 print "RC5_ENC       =$target{rc5_obj}\n";
1384 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
1385 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
1386 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1387 print "CMLL_ENC      =$target{cmll_obj}\n";
1388 print "MODES_OBJ     =$target{modes_obj}\n";
1389 print "ENGINES_OBJ   =$target{engines_obj}\n";
1390 print "CHACHA_ENC    =$target{chacha_obj}\n";
1391 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
1392 print "PROCESSOR     =$config{processor}\n";
1393 print "RANLIB        =$target{ranlib}\n";
1394 print "ARFLAGS       =$target{arflags}\n";
1395 print "PERL          =$config{perl}\n";
1396
1397 system("$config{perl} -I. -Mconfigdata util/dofile.pl < crypto/opensslconf.h.in > include/openssl/opensslconf.h.new");
1398 exit 1 if $? != 0;
1399 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
1400
1401
1402 # Fix the date
1403
1404 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1405 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1406 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1407 print "SIXTEEN_BIT mode\n" if $config{b16};
1408 print "EIGHT_BIT mode\n" if $config{b8};
1409 print "DES_PTR used\n" if $config{des_ptr};
1410 print "DES_RISC1 used\n" if $config{des_risc1};
1411 print "DES_RISC2 used\n" if $config{des_risc2};
1412 print "DES_UNROLL used\n" if $config{des_unroll};
1413 print "DES_INT used\n" if $config{des_int} =~ / int$/;
1414 print "BN_LLONG mode\n" if $config{bn_ll};
1415 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int;
1416 print "RC4_INDEX mode\n" if $config{rc4_idx};
1417 print "RC4_CHUNK is undefined\n" unless $config{rc4_chunk};
1418 print "RC4_CHUNK is $config{rc4_chunk}\n" if $config{rc4_chunk};
1419 print "MD2 uses $config{md2_int}\n" if $config{md2_int} != $def_int;
1420 print "IDEA uses $config{idea_int}\n" if $config{idea_int} != $def_int;
1421 print "RC2 uses $config{rc2_int}\n" if $config{rc2_int} != $def_int;
1422 print "BF_PTR used\n" if $config{bf_ptr} == 1;
1423 print "BF_PTR2 used\n" if $config{bf_ptr} == 2;
1424
1425 # Copy all Makefile.in to Makefile (except top-level)
1426 use File::Find;
1427 use IO::File;
1428 find(sub {
1429         return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1430         my $in = IO::File->new($_, "r") or
1431             die sprintf "Error reading Makefile.in in %s: !$\n",
1432                 $File::Find::dir;
1433         my $out = IO::File->new("Makefile", "w") or
1434             die sprintf "Error writing Makefile in %s: !$\n",
1435                 $File::Find::dir;
1436         print $out "# Generated from $_, do not edit\n";
1437         while (my $line = <$in>) { print $out $line }
1438         $in->close() or
1439             die sprintf "Error reading Makefile.in in %s: !$\n",
1440                 $File::Find::dir;
1441         $out->close() or
1442             die sprintf "Error writing Makefile in %s: !$\n",
1443                 $File::Find::dir;
1444     }, ".");
1445
1446 my %builders = (
1447     unixmake => sub {
1448         my $make_command = "$make PERL=\'$config{perl}\'";
1449         my $make_targets = "";
1450         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
1451         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1452             if $make_targets ne "";
1453         if ($depflags ne $default_depflags && !$make_depend) {
1454             $warn_make_depend++;
1455         }
1456     },
1457     mk1mf => sub {
1458         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
1459         printf OUT <<"EOF";
1460 #ifndef MK1MF_BUILD
1461   /* auto-generated by Configure for crypto/cversion.c:
1462    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1463    * Windows builds (and other mk1mf builds) compile cversion.c with
1464    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1465   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1466 #endif
1467 EOF
1468         close(OUT);
1469
1470         # create the ms/version32.rc file if needed
1471         if (! grep /^netware/, @{$target{build_scheme}}) {
1472             my ($v1, $v2, $v3, $v4);
1473             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) {
1474                 $v1=hex $1;
1475                 $v2=hex $2;
1476                 $v3=hex $3;
1477                 $v4=hex $4;
1478             }
1479             open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1480             print OUT <<"EOF";
1481 #include <winver.h>
1482
1483 LANGUAGE 0x09,0x01
1484
1485 1 VERSIONINFO
1486   FILEVERSION $v1,$v2,$v3,$v4
1487   PRODUCTVERSION $v1,$v2,$v3,$v4
1488   FILEFLAGSMASK 0x3fL
1489 #ifdef _DEBUG
1490   FILEFLAGS 0x01L
1491 #else
1492   FILEFLAGS 0x00L
1493 #endif
1494   FILEOS VOS__WINDOWS32
1495   FILETYPE VFT_DLL
1496   FILESUBTYPE 0x0L
1497 BEGIN
1498     BLOCK "StringFileInfo"
1499     BEGIN
1500         BLOCK "040904b0"
1501         BEGIN
1502             // Required:
1503             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1504             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1505             VALUE "FileVersion", "$config{version}\\0"
1506 #if defined(CRYPTO)
1507             VALUE "InternalName", "libeay32\\0"
1508             VALUE "OriginalFilename", "libeay32.dll\\0"
1509 #elif defined(SSL)
1510             VALUE "InternalName", "ssleay32\\0"
1511             VALUE "OriginalFilename", "ssleay32.dll\\0"
1512 #endif
1513             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1514             VALUE "ProductVersion", "$config{version}\\0"
1515             // Optional:
1516             //VALUE "Comments", "\\0"
1517             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1518             //VALUE "LegalTrademarks", "\\0"
1519             //VALUE "PrivateBuild", "\\0"
1520             //VALUE "SpecialBuild", "\\0"
1521         END
1522     END
1523     BLOCK "VarFileInfo"
1524     BEGIN
1525         VALUE "Translation", 0x409, 0x4b0
1526     END
1527 END
1528 EOF
1529             close(OUT);
1530         }
1531     },
1532     );
1533
1534 my ($builder, @builder_opts) = @{$target{build_scheme}};
1535 $builders{$builder}->(@builder_opts);
1536
1537 print <<"EOF";
1538
1539 Configured for $target.
1540 EOF
1541
1542 print <<"EOF" if (!$no_threads && !$threads);
1543
1544 The library could not be configured for supporting multi-threaded
1545 applications as the compiler options required on this system are not known.
1546 See file INSTALL for details if you need multi-threading.
1547 EOF
1548
1549 print <<"EOF" if ($no_shared_warn);
1550
1551 You gave the option 'shared', which is not supported on this platform, so
1552 we will pretend you gave the option 'no-shared'.  If you know how to implement
1553 shared libraries, please let us know (but please first make sure you have
1554 tried with a current version of OpenSSL).
1555 EOF
1556
1557 print <<"EOF" if ($warn_make_depend);
1558
1559 *** Because of configuration changes, you MUST do the following before
1560 *** building:
1561
1562         make depend
1563 EOF
1564
1565 exit(0);
1566
1567 ######################################################################
1568 #
1569 # Helpers and utility functions
1570 #
1571
1572 # Configuration file reading #########################################
1573
1574 # Helper function to implement conditional inheritance depending on the
1575 # value of $no_asm.  Used in inherit_from values as follows:
1576 #
1577 #      inherit_from => [ "template", asm("asm_tmpl") ]
1578 #
1579 sub asm {
1580     my @x = @_;
1581     sub {
1582         $no_asm ? () : @x;
1583     }
1584 }
1585
1586 # Helper function to implement adding values to already existing configuration
1587 # values.  It handles elements that are ARRAYs, CODEs and scalars
1588 sub _add {
1589     my $separator = shift;
1590
1591     # If there's any ARRAY in the collection of values, we will return
1592     # an ARRAY of combined values, otherwise a string of joined values
1593     # with $separator as the separator.
1594     my $found_array = 0;
1595
1596     my @values =
1597         map {
1598             if (ref($_) eq "ARRAY") {
1599                 $found_array = 1;
1600                 @$_;
1601             } else {
1602                 $_;
1603             }
1604     } (@_);
1605
1606     if ($found_array) {
1607         [ @values ];
1608     } else {
1609         join($separator, @values);
1610     }
1611 }
1612 sub add_before {
1613     my $separator = shift;
1614     my @x = @_;
1615     sub { _add($separator, @x, @_) };
1616 }
1617 sub add {
1618     my $separator = shift;
1619     my @x = @_;
1620     sub { _add($separator, @_, @x) };
1621 }
1622
1623 # configuration reader, evaluates the input file as a perl script and expects
1624 # it to fill %targets with target configurations.  Those are then added to
1625 # %table.
1626 sub read_config {
1627     my $fname = shift;
1628     open(CONFFILE, "< $fname")
1629         or die "Can't open configuration file '$fname'!\n";
1630     my $x = $/;
1631     undef $/;
1632     my $content = <CONFFILE>;
1633     $/ = $x;
1634     close(CONFFILE);
1635     my %targets = ();
1636     {
1637         local %table = %::table;    # Protect %table from tampering
1638
1639         eval $content;
1640         warn $@ if $@;
1641     }
1642
1643     # For each target, check that it's configured with a hash table.
1644     foreach (keys %targets) {
1645         if (ref($targets{$_}) ne "HASH") {
1646             if (ref($targets{$_}) eq "") {
1647                 warn "Deprecated target configuration for $_, ignoring...\n";
1648             } else {
1649                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
1650             }
1651             delete $targets{$_};
1652         }
1653     }
1654
1655     %table = (%table, %targets);
1656
1657 }
1658
1659 # configuration resolver.  Will only resolve all the lazy evalutation
1660 # codeblocks for the chozen target and all those it inherits from,
1661 # recursively
1662 sub resolve_config {
1663     my $target = shift;
1664     my @breadcrumbs = @_;
1665
1666     if (grep { $_ eq $target } @breadcrumbs) {
1667         die "inherit_from loop!  target backtrace:\n  "
1668             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
1669     }
1670
1671     if (!defined($table{$target})) {
1672         warn "Warning! target $target doesn't exist!\n";
1673         return ();
1674     }
1675     # Recurse through all inheritances.  They will be resolved on the
1676     # fly, so when this operation is done, they will all just be a
1677     # bunch of attributes with string values.
1678     # What we get here, though, are keys with references to lists of
1679     # the combined values of them all.  We will deal with lists after
1680     # this stage is done.
1681     my %combined_inheritance = ();
1682     if ($table{$target}->{inherit_from}) {
1683         my @inherit_from =
1684             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
1685         foreach (@inherit_from) {
1686             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
1687
1688             # 'template' is a marker that's considered private to
1689             # the config that had it.
1690             delete $inherited_config{template};
1691
1692             map {
1693                 if (!$combined_inheritance{$_}) {
1694                     $combined_inheritance{$_} = [];
1695                 }
1696                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
1697             } keys %inherited_config;
1698         }
1699     }
1700
1701     # We won't need inherit_from in this target any more, since we've
1702     # resolved all the inheritances that lead to this
1703     delete $table{$target}->{inherit_from};
1704
1705     # Now is the time to deal with those lists.  Here's the place to
1706     # decide what shall be done with those lists, all based on the
1707     # values of the target we're currently dealing with.
1708     # - If a value is a coderef, it will be executed with the list of
1709     #   inherited values as arguments.
1710     # - If the corresponding key doesn't have a value at all or is the
1711     #   emoty string, the inherited value list will be run through the
1712     #   default combiner (below), and the result becomes this target's
1713     #   value.
1714     # - Otherwise, this target's value is assumed to be a string that
1715     #   will simply override the inherited list of values.
1716     my $default_combiner = add(" ");
1717
1718     my %all_keys =
1719         map { $_ => 1 } (keys %combined_inheritance,
1720                          keys %{$table{$target}});
1721     foreach (sort keys %all_keys) {
1722
1723         # Current target doesn't have a value for the current key?
1724         # Assign it the default combiner, the rest of this loop body
1725         # will handle it just like any other coderef.
1726         if (!exists $table{$target}->{$_}) {
1727             $table{$target}->{$_} = $default_combiner;
1728         }
1729
1730         my $valuetype = ref($table{$target}->{$_});
1731         if ($valuetype eq "CODE") {
1732             # CODE reference, execute it with the inherited values as
1733             # arguments.
1734             $table{$target}->{$_} =
1735                 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
1736         } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
1737             # ARRAY or Scalar, just leave it as is.
1738         } else {
1739             # Some other type of reference that we don't handle.
1740             # Better to abort at this point.
1741             die "cannot handle reference type $valuetype,"
1742                 ," found in target $target -> $_\n";
1743         }
1744     }
1745
1746     # Finally done, return the result.
1747     return %{$table{$target}};
1748 }
1749
1750 sub usage
1751         {
1752         print STDERR $usage;
1753         print STDERR "\npick os/compiler from:\n";
1754         my $j=0;
1755         my $i;
1756         my $k=0;
1757         foreach $i (sort keys %table)
1758                 {
1759                 next if $table{$i}->{template};
1760                 next if $i =~ /^debug/;
1761                 $k += length($i) + 1;
1762                 if ($k > 78)
1763                         {
1764                         print STDERR "\n";
1765                         $k=length($i);
1766                         }
1767                 print STDERR $i . " ";
1768                 }
1769         foreach $i (sort keys %table)
1770                 {
1771                 next if $table{$i}->{template};
1772                 next if $i !~ /^debug/;
1773                 $k += length($i) + 1;
1774                 if ($k > 78)
1775                         {
1776                         print STDERR "\n";
1777                         $k=length($i);
1778                         }
1779                 print STDERR $i . " ";
1780                 }
1781         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
1782         exit(1);
1783         }
1784
1785 # Configuration printer ##############################################
1786
1787 sub print_table_entry
1788 {
1789     my $target = shift;
1790     my %target = resolve_config($target);
1791     my $type = shift;
1792
1793     # Don't print the templates
1794     return if $target{template};
1795
1796     my @sequence = (
1797         "cc",
1798         "cflags",
1799         "debug_cflags",
1800         "release_cflags",
1801         "unistd",
1802         "thread_cflag",
1803         "sys_id",
1804         "lflags",
1805         "debug_lflags",
1806         "release_lflags",
1807         "bn_ops",
1808         "cpuid_obj",
1809         "bn_obj",
1810         "ec_obj",
1811         "des_obj",
1812         "aes_obj",
1813         "bf_obj",
1814         "md5_obj",
1815         "sha1_obj",
1816         "cast_obj",
1817         "rc4_obj",
1818         "rmd160_obj",
1819         "rc5_obj",
1820         "wp_obj",
1821         "cmll_obj",
1822         "modes_obj",
1823         "engines_obj",
1824         "perlasm_scheme",
1825         "dso_scheme",
1826         "shared_target",
1827         "shared_cflag",
1828         "shared_ldflag",
1829         "shared_extension",
1830         "ranlib",
1831         "arflags",
1832         "multilib",
1833         );
1834
1835     if ($type eq "TABLE") {
1836         print "\n";
1837         print "*** $target\n";
1838         printf "\$%-12s = %s\n", $_, $target{$_} foreach (@sequence);
1839     } elsif ($type eq "HASH") {
1840         my $largest =
1841             length((sort { length($a) <=> length($b) } @sequence)[-1]);
1842         print "    '$target' => {\n";
1843         foreach (@sequence) {
1844             if ($target{$_}) {
1845                 print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
1846             }
1847         }
1848         print "    },\n";
1849     }
1850 }
1851
1852 # Utility routines ###################################################
1853
1854 sub which
1855         {
1856         my($name)=@_;
1857         my $path;
1858         foreach $path (split /:/, $ENV{PATH})
1859                 {
1860                 if (-f "$path/$name$exe_ext" and -x _)
1861                         {
1862                         return "$path/$name$exe_ext" unless ($name eq "perl" and
1863                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
1864                         }
1865                 }
1866         }
1867
1868 sub print_table_entry
1869         {
1870         my $target = shift;
1871         my %target = resolve_config($target);
1872         my $type = shift;
1873
1874         # Don't print the templates
1875         return if $target{template};
1876
1877         if ($type eq "TABLE") {
1878             print <<"EOF"
1879
1880 *** $target
1881 \$cc           = $target{cc}
1882 \$cflags       = $target{cflags}
1883 \$debug_cflags   = $target{debug_cflags}
1884 \$release_cflags = $target{release_cflags}
1885 \$unistd       = $target{unistd}
1886 \$thread_cflag = $target{thread_cflag}
1887 \$sys_id       = $target{sys_id}
1888 \$lflags       = $target{lflags}
1889 \$debug_lflags   = $target{debug_lflags}
1890 \$release_lflags = $target{release_lflags}
1891 \$bn_ops       = $target{bn_ops}
1892 \$cpuid_obj    = $target{cpuid_obj}
1893 \$bn_obj       = $target{bn_obj}
1894 \$ec_obj       = $target{ec_obj}
1895 \$des_obj      = $target{des_obj}
1896 \$aes_obj      = $target{aes_obj}
1897 \$bf_obj       = $target{bf_obj}
1898 \$md5_obj      = $target{md5_obj}
1899 \$sha1_obj     = $target{sha1_obj}
1900 \$cast_obj     = $target{cast_obj}
1901 \$rc4_obj      = $target{rc4_obj}
1902 \$rmd160_obj   = $target{rmd160_obj}
1903 \$rc5_obj      = $target{rc5_obj}
1904 \$wp_obj       = $target{wp_obj}
1905 \$cmll_obj     = $target{cmll_obj}
1906 \$modes_obj    = $target{modes_obj}
1907 \$engines_obj  = $target{engines_obj}
1908 \$chacha_obj   = $target{chacha_obj}
1909 \$poly1305_obj = $target{poly1305_obj}
1910 \$perlasm_scheme = $target{perlasm_scheme}
1911 \$dso_scheme   = $target{dso_scheme}
1912 \$shared_target= $target{shared_target}
1913 \$shared_cflag = $target{shared_cflag}
1914 \$shared_ldflag = $target{shared_ldflag}
1915 \$shared_extension = $target{shared_extension}
1916 \$ranlib       = $target{ranlib}
1917 \$arflags      = $target{arflags}
1918 \$multilib     = $target{multilib}
1919 EOF
1920         } elsif ($type eq "HASH") {
1921             my @sequence = (
1922                 "cc",
1923                 "cflags",
1924                 "debug_cflags",
1925                 "release_cflags",
1926                 "unistd",
1927                 "thread_cflag",
1928                 "sys_id",
1929                 "lflags",
1930                 "debug_lflags",
1931                 "release_lflags",
1932                 "bn_ops",
1933                 "cpuid_obj",
1934                 "bn_obj",
1935                 "ec_obj",
1936                 "des_obj",
1937                 "aes_obj",
1938                 "bf_obj",
1939                 "md5_obj",
1940                 "sha1_obj",
1941                 "cast_obj",
1942                 "rc4_obj",
1943                 "rmd160_obj",
1944                 "rc5_obj",
1945                 "wp_obj",
1946                 "cmll_obj",
1947                 "modes_obj",
1948                 "engines_obj",
1949                 "chacha_obj",
1950                 "poly1305_obj",
1951                 "perlasm_scheme",
1952                 "dso_scheme",
1953                 "shared_target",
1954                 "shared_cflag",
1955                 "shared_ldflag",
1956                 "shared_extension",
1957                 "ranlib",
1958                 "arflags",
1959                 "multilib",
1960                 );
1961             my $largest =
1962                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
1963             print "    '$target' => {\n";
1964             foreach (@sequence) {
1965                 if ($target{$_}) {
1966                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
1967                 }
1968             }
1969             print "    },\n";
1970         }
1971         }
1972
1973 sub quotify {
1974     my %processors = (
1975         perl    => sub { my $x = shift;
1976                          $x =~ s/([\\\$\@"])/\\$1/g;
1977                          return '"'.$x.'"'; },
1978         );
1979     my $for = shift;
1980     my $processor =
1981         defined($processors{$for}) ? $processors{$for} : sub { shift; };
1982
1983     map { $processor->($_); } @_;
1984 }