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