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