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