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