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