Configure

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