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