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 @skip=();
 782 my $Makefile="Makefile";
 783 my $des_locl="crypto/des/des_locl.h";
 784 my $des ="include/openssl/des.h";
 785 my $bn  ="include/openssl/bn.h";
 786 my $md2 ="include/openssl/md2.h";
 787 my $rc4 ="include/openssl/rc4.h";
 788 my $rc4_locl="crypto/rc4/rc4_locl.h";
 789 my $idea        ="include/openssl/idea.h";
 790 my $rc2 ="include/openssl/rc2.h";
 791 my $bf  ="crypto/bf/bf_locl.h";
 792 my $bn_asm      ="bn_asm.o";
 793 my $des_enc="des_enc.o fcrypt_b.o";
 794 my $aes_enc="aes_core.o aes_cbc.o";
 795 my $bf_enc      ="bf_enc.o";
 796 my $cast_enc="c_enc.o";
 797 my $rc4_enc="rc4_enc.o rc4_skey.o";
 798 my $rc5_enc="rc5_enc.o";
 799 my $cmll_enc="camellia.o cmll_misc.o cmll_cbc.o";
 800 my $chacha_enc="chacha_enc.o";
 801 my $processor="";
 802 my $default_ranlib;
 803 my $perl;
 804 my $fips=0;
 805
 806 # Explicitelly known options that are possible to disable.  They can
 807 # be regexps, and will be used like this: /^no-${option}$/
 808 # For developers: keep it sorted alphabetically
 809
 810 my @disablables = (
 811     "aes",
 812     "asm",
 813     "bf",
 814     "camellia",
 815     "capieng",
 816     "cast",
 817     "chacha",
 818     "cmac",
 819     "cms",
 820     "comp",
 821     "ct",
 822     "deprecated",
 823     "des",
 824     "dgram",
 825     "dh",
 826     "dsa",
 827     "dso",
 828     "dtls",
 829     "dynamic[-_]engine",
 830     "ec",
 831     "ec2m",
 832     "ec_nistp_64_gcc_128",
 833     "engine",
 834     "err",                      # Really???
 835     "gost",
 836     "heartbeats",
 837     "hmac",
 838     "hw(-.+)?",
 839     "idea",
 840     "jpake",
 841     "locking",                  # Really???
 842     "md2",
 843     "md4",
 844     "md5",
 845     "mdc2",
 846     "md[-_]ghost94",
 847     "nextprotoneg",
 848     "ocb",
 849     "ocsp",
 850     "poly1305",
 851     "posix-io",
 852     "psk",
 853     "rc2",
 854     "rc4",
 855     "rc5",
 856     "rdrand",
 857     "rfc3779",
 858     "rijndael",                 # Old AES name
 859     "rmd160",
 860     "rsa",
 861     "scrypt",
 862     "sct",
 863     "sctp",
 864     "seed",
 865     "sha",
 866     "shared",
 867     "sock",
 868     "srp",
 869     "srtp",
 870     "sse2",
 871     "ssl",
 872     "ssl3",
 873     "ssl3-method",
 874     "ssl-trace",
 875     "static-engine",
 876     "stdio",
 877     "store",
 878     "threads",
 879     "tls",
 880     "tls1",
 881     "unit-test",
 882     "whirlpool",
 883     "zlib",
 884     "zlib-dynamic",
 885     );
 886
 887 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 888
 889 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
 890                  "deprecated" => "default",
 891                  "ec_nistp_64_gcc_128" => "default",
 892                  "jpake"          => "experimental",
 893                  "md2"            => "default",
 894                  "rc5"            => "default",
 895                  "sctp"       => "default",
 896                  "shared"         => "default",
 897                  "ssl-trace"      => "default",
 898                  "store"          => "experimental",
 899                  "unit-test"      => "default",
 900                  "zlib"           => "default",
 901                  "zlib-dynamic"   => "default"
 902                );
 903 my @experimental = ();
 904
 905 # This is what $depflags will look like with the above defaults
 906 # (we need this to see if we should advise the user to run "make depend"):
 907 my $default_depflags = " -DOPENSSL_NO_DEPRECATED -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_SCTP -DOPENSSL_NO_SSL_TRACE -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST";
 908
 909 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 910 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
 911 # For symmetry, "disable-foo" is a synonym for "no-foo".
 912
 913 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
 914 # We will collect such requests in @experimental.
 915 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
 916
 917
 918 my $no_sse2=0;
 919
 920 &usage if ($#ARGV < 0);
 921
 922 my $flags;
 923 my $depflags;
 924 my $openssl_experimental_defines;
 925 my $openssl_algorithm_defines;
 926 my $openssl_thread_defines;
 927 my $openssl_sys_defines="";
 928 my $openssl_other_defines;
 929 my $libs;
 930 my $target;
 931 my $options;
 932 my $make_depend=0;
 933 my %withargs=();
 934 my $build_prefix = "release_";
 935
 936 my @argvcopy=@ARGV;
 937 my $argvstring="";
 938 my $argv_unprocessed=1;
 939
 940 while($argv_unprocessed)
 941         {
 942         $flags="";
 943         $depflags="";
 944         $openssl_experimental_defines="";
 945         $openssl_algorithm_defines="";
 946         $openssl_thread_defines="";
 947         $openssl_sys_defines="";
 948         $openssl_other_defines="";
 949         $libs="";
 950         $target="";
 951         $options="";
 952
 953         $argv_unprocessed=0;
 954         $argvstring=join(' ',@argvcopy);
 955
 956 PROCESS_ARGS:
 957         {
 958         my %unsupported_options = ();
 959         foreach (@argvcopy)
 960                 {
 961                 s /^-no-/no-/; # some people just can't read the instructions
 962
 963                 # rewrite some options in "enable-..." form
 964                 s /^-?-?shared$/enable-shared/;
 965                 s /^sctp$/enable-sctp/;
 966                 s /^threads$/enable-threads/;
 967                 s /^zlib$/enable-zlib/;
 968                 s /^zlib-dynamic$/enable-zlib-dynamic/;
 969
 970                 if (/^(no|disable|enable|experimental)-(.+)$/)
 971                         {
 972                         my $word = $2;
 973                         if (!grep { $word =~ /^${_}$/ } @disablables)
 974                                 {
 975                                 $unsupported_options{$_} = 1;
 976                                 next;
 977                                 }
 978                         }
 979                 if (/^no-(.+)$/ || /^disable-(.+)$/)
 980                         {
 981                         if (!($disabled{$1} eq "experimental"))
 982                                 {
 983                                 if ($1 eq "ssl")
 984                                         {
 985                                         $disabled{"ssl3"} = "option(ssl)";
 986                                         }
 987                                 elsif ($1 eq "tls")
 988                                         {
 989                                         $disabled{"tls1"} = "option(tls)"
 990                                         }
 991                                 elsif ($1 eq "ssl3-method")
 992                                         {
 993                                         $disabled{"ssl3-method"} = "option(ssl)";
 994                                         $disabled{"ssl3"} = "option(ssl)";
 995                                         }
 996                                 else
 997                                         {
 998                                         $disabled{$1} = "option";
 999                                         }
1000                                 }
1001                         }
1002                 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
1003                         {
1004                         my $algo = $1;
1005                         if ($disabled{$algo} eq "experimental")
1006                                 {
1007                                 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
1008                                         unless (/^experimental-/);
1009                                 push @experimental, $algo;
1010                                 }
1011                         delete $disabled{$algo};
1012
1013                         $threads = 1 if ($algo eq "threads");
1014                         }
1015                 elsif (/^--test-sanity$/)
1016                         {
1017                         exit(&test_sanity());
1018                         }
1019                 elsif (/^--strict-warnings$/)
1020                         {
1021                         $strict_warnings = 1;
1022                         }
1023                 elsif (/^--debug$/)
1024                         {
1025                         $build_prefix = "debug_";
1026                         }
1027                 elsif (/^--release$/)
1028                         {
1029                         $build_prefix = "release_";
1030                         }
1031                 elsif (/^reconfigure/ || /^reconf/)
1032                         {
1033                         if (open(IN,"<$Makefile"))
1034                                 {
1035                                 my $config_args_found=0;
1036                                 while (<IN>)
1037                                         {
1038                                         chomp;
1039                                         if (/^CONFIGURE_ARGS=(.*)/)
1040                                                 {
1041                                                 $argvstring=$1;
1042                                                 @argvcopy=split(' ',$argvstring);
1043                                                 die "Incorrect data to reconfigure, please do a normal configuration\n"
1044                                                         if (grep(/^reconf/,@argvcopy));
1045                                                 print "Reconfiguring with: $argvstring\n";
1046                                                 $argv_unprocessed=1;
1047                                                 $config_args_found=1;
1048                                                 }
1049                                         elsif (/^CROSS_COMPILE=\s*(.*)/)
1050                                                 {
1051                                                 $ENV{CROSS_COMPILE}=$1;
1052                                                 }
1053                                         elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)/)
1054                                                 {
1055                                                 $ENV{CC}=$1;
1056                                                 }
1057                                         }
1058                                 close(IN);
1059                                 last PROCESS_ARGS if ($config_args_found);
1060                                 }
1061                         die "Insufficient data to reconfigure, please do a normal configuration\n";
1062                         }
1063                 elsif (/^386$/)
1064                         { $processor=386; }
1065                 elsif (/^fips$/)
1066                         {
1067                         $fips=1;
1068                         }
1069                 elsif (/^rsaref$/)
1070                         {
1071                         # No RSAref support any more since it's not needed.
1072                         # The check for the option is there so scripts aren't
1073                         # broken
1074                         }
1075                 elsif (/^nofipscanistercheck$/)
1076                         {
1077                         $fips = 1;
1078                         $nofipscanistercheck = 1;
1079                         }
1080                 elsif (/^[-+]/)
1081                         {
1082                         if (/^--prefix=(.*)$/)
1083                                 {
1084                                 $prefix=$1;
1085                                 }
1086                         elsif (/^--libdir=(.*)$/)
1087                                 {
1088                                 $libdir=$1;
1089                                 }
1090                         elsif (/^--openssldir=(.*)$/)
1091                                 {
1092                                 $openssldir=$1;
1093                                 }
1094                         elsif (/^--install.prefix=(.*)$/)
1095                                 {
1096                                 $install_prefix=$1;
1097                                 }
1098                         elsif (/^--with-zlib-lib=(.*)$/)
1099                                 {
1100                                 $withargs{"zlib-lib"}=$1;
1101                                 }
1102                         elsif (/^--with-zlib-include=(.*)$/)
1103                                 {
1104                                 $withargs{"zlib-include"}="-I$1";
1105                                 }
1106                         elsif (/^--with-fipslibdir=(.*)$/)
1107                                 {
1108                                 $fipslibdir="$1/";
1109                                 }
1110                         elsif (/^--with-baseaddr=(.*)$/)
1111                                 {
1112                                 $baseaddr="$1";
1113                                 }
1114                         elsif (/^--cross-compile-prefix=(.*)$/)
1115                                 {
1116                                 $cross_compile_prefix=$1;
1117                                 }
1118                         elsif (/^--config=(.*)$/)
1119                                 {
1120                                 read_config $1;
1121                                 }
1122                         elsif (/^-[lL](.*)$/ or /^-Wl,/)
1123                                 {
1124                                 $libs.=$_." ";
1125                                 }
1126                         else    # common if (/^[-+]/), just pass down...
1127                                 {
1128                                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1129                                 $flags.=$_." ";
1130                                 }
1131                         }
1132                 elsif ($_ =~ /^([^:]+):(.+)$/)
1133                         {
1134                         eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
1135                         $target=$1;
1136                         }
1137                 else
1138                         {
1139                         die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1140                         $target=$_;
1141                         }
1142
1143                 unless ($_ eq $target || /^no-/ || /^disable-/)
1144                         {
1145                         # "no-..." follows later after implied disactivations
1146                         # have been derived.  (Don't take this too seroiusly,
1147                         # we really only write OPTIONS to the Makefile out of
1148                         # nostalgia.)
1149
1150                         if ($options eq "")
1151                                 { $options = $_; }
1152                         else
1153                                 { $options .= " ".$_; }
1154                         }
1155                 }
1156
1157         if (keys %unsupported_options)
1158                 {
1159                 die "***** Unsupported options: ",
1160                         join(", ", keys %unsupported_options), "\n";
1161                 }
1162         }
1163         }
1164
1165
1166 if ($processor eq "386")
1167         {
1168         $disabled{"sse2"} = "forced";
1169         }
1170
1171 if (!defined($disabled{"zlib-dynamic"}))
1172         {
1173         # "zlib-dynamic" was specifically enabled, so enable "zlib"
1174         delete $disabled{"zlib"};
1175         }
1176
1177 if (defined($disabled{"rijndael"}))
1178         {
1179         $disabled{"aes"} = "forced";
1180         }
1181 if (defined($disabled{"des"}))
1182         {
1183         $disabled{"mdc2"} = "forced";
1184         }
1185 if (defined($disabled{"ec"}))
1186         {
1187         $disabled{"ecdsa"} = "forced";
1188         $disabled{"ecdh"} = "forced";
1189         }
1190
1191 # SSL 3.0 and TLS requires MD5 and SHA and either RSA or DSA+DH
1192 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
1193     || (defined($disabled{"rsa"})
1194         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))))
1195         {
1196         $disabled{"ssl3"} = "forced";
1197         $disabled{"tls1"} = "forced";
1198         }
1199
1200
1201 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
1202     || defined($disabled{"dh"}) || defined($disabled{"stdio"}))
1203         {
1204         $disabled{"gost"} = "forced";
1205         }
1206
1207
1208 if ($target eq "TABLE") {
1209         foreach $target (sort keys %table) {
1210                 print_table_entry($target, "TABLE");
1211         }
1212         exit 0;
1213 }
1214
1215 if ($target eq "LIST") {
1216         foreach (sort keys %table) {
1217                 print;
1218                 print "\n";
1219         }
1220         exit 0;
1221 }
1222
1223 if ($target eq "HASH") {
1224         print "%table = (\n";
1225         foreach (sort keys %table) {
1226                 print_table_entry($_, "HASH");
1227         }
1228         exit 0;
1229 }
1230
1231 if ($target =~ m/^CygWin32(-.*)$/) {
1232         $target = "Cygwin".$1;
1233 }
1234
1235 print "Configuring for $target\n";
1236
1237 # Support for legacy targets having a name starting with 'debug-'
1238 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1239 if ($d) {
1240     $build_prefix = "debug_";
1241
1242     # If we do not find debug-foo in the table, the target is set to foo,
1243     # but only if the foo target has a noon-empty debug_cflags or debug_lflags
1244     # attribute.
1245     if (!$table{$target} && ($table{$t}->{debug_cflags}
1246                              || $table{$t}->{debug_lflags})) {
1247         $target = $t;
1248     }
1249 }
1250
1251 &usage if (!defined($table{$target})
1252            || $table{$target}->{template}
1253            || ($build_prefix eq "debug_"
1254                && $target !~ /^debug-/
1255                && !($table{$target}->{debug_cflags}
1256                     || $table{$target}->{debug_lflags})));
1257
1258 if ($fips)
1259         {
1260         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
1261         }
1262
1263 foreach (sort (keys %disabled))
1264         {
1265         $options .= " no-$_";
1266
1267         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
1268
1269         if (/^dso$/)
1270                 { $no_dso = 1; }
1271         elsif (/^threads$/)
1272                 { $no_threads = 1; }
1273         elsif (/^shared$/)
1274                 { $no_shared = 1; }
1275         elsif (/^zlib$/)
1276                 { $zlib = 0; }
1277         elsif (/^static-engine$/)
1278                 { }
1279         elsif (/^zlib-dynamic$/)
1280                 { }
1281         elsif (/^sse2$/)
1282                 { $no_sse2 = 1; }
1283         else
1284                 {
1285                 my ($ALGO, $algo);
1286                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
1287
1288                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
1289                         {
1290                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
1291                         print " OPENSSL_NO_$ALGO";
1292
1293                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
1294                         elsif (/^asm$/) { $no_asm = 1; }
1295                         }
1296                 else
1297                         {
1298                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
1299
1300                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
1301                         print " OPENSSL_NO_$ALGO";
1302
1303                         push @skip, $algo;
1304                         # fix-up crypto/directory name(s)
1305                         $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
1306                         $skip[$#skip]="ripemd" if $algo eq "rmd160";
1307
1308                         print " (skip dir)";
1309
1310                         $depflags .= " -DOPENSSL_NO_$ALGO";
1311                         }
1312                 }
1313
1314         print "\n";
1315         }
1316
1317 my $exp_cflags = "";
1318
1319 foreach (sort @experimental)
1320         {
1321         my $ALGO;
1322         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
1323
1324         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
1325         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
1326         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
1327         }
1328
1329 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
1330
1331 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
1332 $exe_ext=".nlm" if ($target =~ /netware/);
1333 $exe_ext=".pm"  if ($target =~ /vos/);
1334 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
1335 $prefix=$openssldir if $prefix eq "";
1336
1337 $default_ranlib= &which("ranlib") or $default_ranlib="true";
1338 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
1339   or $perl="perl";
1340 my $make = $ENV{'MAKE'} || "make";
1341
1342 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
1343
1344 chop $openssldir if $openssldir =~ /\/$/;
1345 chop $prefix if $prefix =~ /.\/$/;
1346
1347 $openssldir=$prefix . "/ssl" if $openssldir eq "";
1348 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
1349
1350
1351 print "IsMK1MF=$IsMK1MF\n";
1352
1353 # Allow environment CC to override compiler...
1354 my $cc = $ENV{CC} || $table{$target}->{cc};
1355
1356 # For cflags and lflags, add the debug_ or release_ attributes
1357 # Do it in such a way that no spurious space is appended (hence the grep).
1358 my $cflags = join(" ",
1359                   grep { $_ } ($table{$target}->{cflags},
1360                                $table{$target}->{$build_prefix."cflags"}));
1361 my $lflags = join(" ",
1362                   grep { $_ } ($table{$target}->{lflags},
1363                                $table{$target}->{$build_prefix."lflags"}));
1364
1365 my $unistd = $table{$target}->{unistd};
1366 my $thread_cflag = $table{$target}->{thread_cflag};
1367 my $sys_id = $table{$target}->{sys_id};
1368 my $bn_ops = $table{$target}->{bn_ops};
1369 my $cpuid_obj = $table{$target}->{cpuid_obj};
1370 my $bn_obj = $table{$target}->{bn_obj};
1371 my $ec_obj = $table{$target}->{ec_obj};
1372 my $des_obj = $table{$target}->{des_obj};
1373 my $aes_obj = $table{$target}->{aes_obj};
1374 my $bf_obj = $table{$target}->{bf_obj};
1375 my $md5_obj = $table{$target}->{md5_obj};
1376 my $sha1_obj = $table{$target}->{sha1_obj};
1377 my $cast_obj = $table{$target}->{cast_obj};
1378 my $rc4_obj = $table{$target}->{rc4_obj};
1379 my $rmd160_obj = $table{$target}->{rmd160_obj};
1380 my $rc5_obj = $table{$target}->{rc5_obj};
1381 my $wp_obj = $table{$target}->{wp_obj};
1382 my $cmll_obj = $table{$target}->{cmll_obj};
1383 my $modes_obj = $table{$target}->{modes_obj};
1384 my $engines_obj = $table{$target}->{engines_obj};
1385 my $chacha_obj = $table{$target}->{chacha_obj};
1386 my $poly1305_obj = $table{$target}->{poly1305_obj};
1387 my $perlasm_scheme = $table{$target}->{perlasm_scheme};
1388 my $dso_scheme = $table{$target}->{dso_scheme};
1389 my $shared_target = $table{$target}->{shared_target};
1390 my $shared_cflag = $table{$target}->{shared_cflag};
1391 my $shared_ldflag = $table{$target}->{shared_ldflag};
1392 my $shared_extension = $table{$target}->{shared_extension};
1393 my $ranlib = $ENV{'RANLIB'} || $table{$target}->{ranlib};
1394 my $ar = $ENV{'AR'} || "ar";
1395 my $arflags = $table{$target}->{arflags};
1396 my $multilib = $table{$target}->{multilib};
1397
1398 # if $prefix/lib$multilib is not an existing directory, then
1399 # assume that it's not searched by linker automatically, in
1400 # which case adding $multilib suffix causes more grief than
1401 # we're ready to tolerate, so don't...
1402 $multilib="" if !-d "$prefix/lib$multilib";
1403
1404 $libdir="lib$multilib" if $libdir eq "";
1405
1406 $cflags = "$cflags$exp_cflags";
1407
1408 # '%' in $lflags is used to split flags to "pre-" and post-flags
1409 my ($prelflags,$postlflags)=split('%',$lflags);
1410 if (defined($postlflags))       { $lflags=$postlflags;  }
1411 else                            { $lflags=$prelflags; undef $prelflags; }
1412
1413 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
1414         {
1415         $cflags =~ s/\-mno\-cygwin\s*//;
1416         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
1417         }
1418
1419 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
1420         # minimally required architecture flags for assembly modules
1421         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
1422         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
1423 }
1424
1425 my $no_shared_warn=0;
1426 my $no_user_cflags=0;
1427
1428 if ($flags ne "")       { $cflags="$flags$cflags"; }
1429 else                    { $no_user_cflags=1;       }
1430
1431 # The DSO code currently always implements all functions so that no
1432 # applications will have to worry about that from a compilation point
1433 # of view. However, the "method"s may return zero unless that platform
1434 # has support compiled in for them. Currently each method is enabled
1435 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1436 # string entry into using the following logic;
1437 my $dso_cflags;
1438 if (!$no_dso && $dso_scheme ne "")
1439         {
1440         $dso_scheme =~ tr/[a-z]/[A-Z]/;
1441         if ($dso_scheme eq "DLFCN")
1442                 {
1443                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
1444                 }
1445         elsif ($dso_scheme eq "DLFCN_NO_H")
1446                 {
1447                 $dso_cflags = "-DDSO_DLFCN";
1448                 }
1449         else
1450                 {
1451                 $dso_cflags = "-DDSO_$dso_scheme";
1452                 }
1453         $cflags = "$dso_cflags $cflags";
1454         }
1455
1456 my $thread_cflags;
1457 my $thread_defines;
1458 if ($thread_cflag ne "(unknown)" && !$no_threads)
1459         {
1460         # If we know how to do it, support threads by default.
1461         $threads = 1;
1462         }
1463 if ($thread_cflag eq "(unknown)" && $threads)
1464         {
1465         # If the user asked for "threads", [s]he is also expected to
1466         # provide any system-dependent compiler options that are
1467         # necessary.
1468         if ($no_user_cflags)
1469                 {
1470                 print "You asked for multi-threading support, but didn't\n";
1471                 print "provide any system-specific compiler options\n";
1472                 exit(1);
1473                 }
1474         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
1475         $thread_defines .= "#define OPENSSL_THREADS\n";
1476         }
1477 else
1478         {
1479         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
1480         $thread_defines .= "#define OPENSSL_THREADS\n";
1481 #       my $def;
1482 #       foreach $def (split ' ',$thread_cflag)
1483 #               {
1484 #               if ($def =~ s/^-D// && $def !~ /^_/)
1485 #                       {
1486 #                       $thread_defines .= "#define $def\n";
1487 #                       }
1488 #               }
1489         }
1490
1491 $lflags="$libs$lflags" if ($libs ne "");
1492
1493 if ($no_asm)
1494         {
1495         $cpuid_obj=$bn_obj=$ec_obj=
1496         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
1497         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj=
1498         $chacha_obj=$poly1305_obj="";
1499         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
1500         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
1501         }
1502 elsif (defined($disabled{ec2m}))
1503         {
1504         $bn_obj =~ s/\w+-gf2m.o//;
1505         }
1506
1507 if (!$no_shared)
1508         {
1509         $cast_obj="";   # CAST assembler is not PIC
1510         }
1511
1512 if ($threads)
1513         {
1514         $cflags=$thread_cflags;
1515         $openssl_thread_defines .= $thread_defines;
1516         }
1517
1518 if ($zlib)
1519         {
1520         $cflags = "-DZLIB $cflags";
1521         if (defined($disabled{"zlib-dynamic"}))
1522                 {
1523                 if (defined($withargs{"zlib-lib"}))
1524                         {
1525                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
1526                         }
1527                 else
1528                         {
1529                         $lflags = "$lflags -lz";
1530                         }
1531                 }
1532         else
1533                 {
1534                 $cflags = "-DZLIB_SHARED $cflags";
1535                 }
1536         }
1537
1538 #Build the library with OPENSSL_USE_DEPRECATED if deprecation is not disabled
1539 if(!defined($disabled{"deprecated"}))
1540         {
1541         $cflags = "-DOPENSSL_USE_DEPRECATED $cflags";
1542         }
1543
1544 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.org
1545 my $shared_mark = "";
1546 if ($shared_target eq "")
1547         {
1548         $no_shared_warn = 1 if !$no_shared && !$fips;
1549         $no_shared = 1;
1550         }
1551 if (!$no_shared)
1552         {
1553         if ($shared_cflag ne "")
1554                 {
1555                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
1556                 }
1557         }
1558
1559 if (!$IsMK1MF)
1560         {
1561         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1562         if ($no_shared)
1563                 {
1564                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
1565                 $options.=" static-engine";
1566                 }
1567         else
1568                 {
1569                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
1570                 $options.=" no-static-engine";
1571                 }
1572         }
1573
1574 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1575
1576 #
1577 # Platform fix-ups
1578 #
1579 if ($target =~ /\-icc$/)        # Intel C compiler
1580         {
1581         my $iccver=0;
1582         if (open(FD,"$cc -V 2>&1 |"))
1583                 {
1584                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1585                 close(FD);
1586                 }
1587         if ($iccver>=8)
1588                 {
1589                 $cflags=~s/\-KPIC/-fPIC/;
1590                 # Eliminate unnecessary dependency from libirc.a. This is
1591                 # essential for shared library support, as otherwise
1592                 # apps/openssl can end up in endless loop upon startup...
1593                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1594                 }
1595         if ($iccver>=9)
1596                 {
1597                 $lflags.=" -i-static";
1598                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1599                 }
1600         if ($iccver>=10)
1601                 {
1602                 $lflags=~s/\-i\-static/-static-intel/;
1603                 }
1604         if ($iccver>=11)
1605                 {
1606                 $cflags.=" -no-intel-extensions";       # disable Cilk
1607                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1608                 }
1609         }
1610
1611 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1612 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1613 # .so objects. Apparently application RPATH is not global and does
1614 # not apply to .so linked with other .so. Problem manifests itself
1615 # when libssl.so fails to load libcrypto.so. One can argue that we
1616 # should engrave this into Makefile.shared rules or into BSD-* config
1617 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1618 # linker only when --prefix is not /usr.
1619 if ($target =~ /^BSD\-/)
1620         {
1621         $shared_ldflag.=" -Wl,-rpath,\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1622         }
1623
1624 if ($sys_id ne "")
1625         {
1626         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1627         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1628         }
1629
1630 if ($ranlib eq "")
1631         {
1632         $ranlib = $default_ranlib;
1633         }
1634
1635 #my ($bn1)=split(/\s+/,$bn_obj);
1636 #$bn1 = "" unless defined $bn1;
1637 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1638 #$bn_obj="$bn1";
1639
1640 $cpuid_obj="" if ($processor eq "386");
1641
1642 $bn_obj = $bn_asm unless $bn_obj ne "";
1643 # bn-586 is the only one implementing bn_*_part_words
1644 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1645 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1646
1647 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1648 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1649 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1650
1651 if ($fips)
1652         {
1653         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1654         }
1655
1656 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1657 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1658 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1659 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1660 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1661 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1662 if ($sha1_obj =~ /\.o$/)
1663         {
1664 #       $sha1_obj=$sha1_enc;
1665         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1666         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1667         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1668         if ($sha1_obj =~ /sse2/)
1669             {   if ($no_sse2)
1670                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1671                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1672                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1673             }
1674         }
1675 if ($md5_obj =~ /\.o$/)
1676         {
1677 #       $md5_obj=$md5_enc;
1678         $cflags.=" -DMD5_ASM";
1679         }
1680 if ($rmd160_obj =~ /\.o$/)
1681         {
1682 #       $rmd160_obj=$rmd160_enc;
1683         $cflags.=" -DRMD160_ASM";
1684         }
1685 if ($aes_obj =~ /\.o$/)
1686         {
1687         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1688         # aes-ctr.o is not a real file, only indication that assembler
1689         # module implements AES_ctr32_encrypt...
1690         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1691         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1692         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1693         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1694         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1695         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1696         }
1697 else    {
1698         $aes_obj=$aes_enc;
1699         }
1700 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1701 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1702         {
1703         $cflags.=" -DWHIRLPOOL_ASM";
1704         }
1705 else    {
1706         $wp_obj="wp_block.o";
1707         }
1708 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1709 if ($modes_obj =~ /ghash\-/)
1710         {
1711         $cflags.=" -DGHASH_ASM";
1712         }
1713 if ($ec_obj =~ /ecp_nistz256/)
1714         {
1715         $cflags.=" -DECP_NISTZ256_ASM";
1716         }
1717 $chacha_obj=$chacha_enc unless ($chacha_obj =~ /\.o$/);
1718 if ($poly1305_obj =~ /\.o$/)
1719         {
1720         $cflags.=" -DPOLY1305_ASM";
1721         }
1722
1723 # "Stringify" the C flags string.  This permits it to be made part of a string
1724 # and works as well on command lines.
1725 $cflags =~ s/([\\\"])/\\\1/g;
1726
1727 my $version = "unknown";
1728 my $version_num = "unknown";
1729 my $major = "unknown";
1730 my $minor = "unknown";
1731 my $shlib_version_number = "unknown";
1732 my $shlib_version_history = "unknown";
1733 my $shlib_major = "unknown";
1734 my $shlib_minor = "unknown";
1735
1736 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1737 while (<IN>)
1738         {
1739         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1740         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*0x(\S+)/;
1741         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1742         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1743         }
1744 close(IN);
1745 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1746
1747 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1748         {
1749         $major=$1;
1750         $minor=$2;
1751         }
1752
1753 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1754         {
1755         $shlib_major=$1;
1756         $shlib_minor=$2;
1757         }
1758
1759 my $ecc = $cc;
1760 $ecc = "clang" if `$cc --version 2>&1` =~ /clang/;
1761
1762 if ($strict_warnings)
1763         {
1764         my $wopt;
1765         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1766         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1767                 {
1768                 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1769                 }
1770         if ($ecc eq "clang")
1771                 {
1772                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1773                         {
1774                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1775                         }
1776                 }
1777         if ($target !~ /^mingw/)
1778                 {
1779                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1780                         {
1781                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1782                         }
1783                 if ($target =~ /^BSD-/)
1784                         {
1785                         $lflags .= " -lexecinfo";
1786                         }
1787                 }
1788         }
1789
1790 open(IN,"<Makefile.org") || die "unable to read Makefile.org:$!\n";
1791 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1792 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1793 print OUT "### Generated automatically from Makefile.org by Configure.\n\n";
1794 my $sdirs=0;
1795
1796 while (<IN>)
1797         {
1798         chomp;
1799         $sdirs = 1 if /^SDIRS=/;
1800         if ($sdirs) {
1801                 my $dir;
1802                 foreach $dir (@skip) {
1803                         s/(\s)$dir /$1/;
1804                         s/\s$dir$//;
1805                         }
1806                 }
1807         $sdirs = 0 unless /\\$/;
1808         s/fips // if (/^DIRS=/ && !$fips);
1809         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1810         s/ccgost// if (/^ENGDIRS=/ && $disabled{"gost"});
1811         s/^VERSION=.*/VERSION=$version/;
1812         s/^MAJOR=.*/MAJOR=$major/;
1813         s/^MINOR=.*/MINOR=$minor/;
1814         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1815         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1816         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1817         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1818         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1819         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1820         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1821         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1822         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1823         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1824         s/^PLATFORM=.*$/PLATFORM=$target/;
1825         s/^OPTIONS=.*$/OPTIONS=$options/;
1826         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1827         if ($cross_compile_prefix)
1828                 {
1829                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1830                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1831                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1832                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1833                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1834                 }
1835         else    {
1836                 s/^CC=.*$/CC= $cc/;
1837                 s/^AR=\s*ar/AR= $ar/;
1838                 s/^RANLIB=.*/RANLIB= $ranlib/;
1839                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $ecc eq "gcc" || $ecc eq "clang";
1840                 }
1841         s/^CFLAG=.*$/CFLAG= $cflags/;
1842         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1843         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1844         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1845         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1846         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1847         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1848         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1849         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1850         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1851         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1852         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1853         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1854         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1855         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1856         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1857         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1858         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1859         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1860         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1861         s/^CHACHA_ENC=.*$/CHACHA_ENC= $chacha_obj/;
1862         s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $poly1305_obj/;
1863         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1864         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1865         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1866         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1867         s/^PERL=.*/PERL= $perl/;
1868         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1869         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1870         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1871         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1872         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1873         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1874         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1875         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1876         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1877         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1878         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1879                 {
1880                 my $sotmp = $1;
1881                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1882                 }
1883         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1884                 {
1885                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1886                 }
1887         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1888                 {
1889                 my $sotmp = $1;
1890                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1891                 }
1892         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1893                 {
1894                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1895                 }
1896         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1897         print OUT $_."\n";
1898         }
1899 close(IN);
1900 close(OUT);
1901 rename($Makefile,"$Makefile.bak") || die "unable to rename $Makefile\n" if -e $Makefile;
1902 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1903
1904 print "CC            =$cc\n";
1905 print "CFLAG         =$cflags\n";
1906 print "EX_LIBS       =$lflags\n";
1907 print "CPUID_OBJ     =$cpuid_obj\n";
1908 print "BN_ASM        =$bn_obj\n";
1909 print "EC_ASM        =$ec_obj\n";
1910 print "DES_ENC       =$des_obj\n";
1911 print "AES_ENC       =$aes_obj\n";
1912 print "BF_ENC        =$bf_obj\n";
1913 print "CAST_ENC      =$cast_obj\n";
1914 print "RC4_ENC       =$rc4_obj\n";
1915 print "RC5_ENC       =$rc5_obj\n";
1916 print "MD5_OBJ_ASM   =$md5_obj\n";
1917 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1918 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1919 print "CMLL_ENC      =$cmll_obj\n";
1920 print "MODES_OBJ     =$modes_obj\n";
1921 print "ENGINES_OBJ   =$engines_obj\n";
1922 print "CHACHA_ENC    =$chacha_obj\n";
1923 print "POLY1305_OBJ  =$poly1305_obj\n";
1924 print "PROCESSOR     =$processor\n";
1925 print "RANLIB        =$ranlib\n";
1926 print "ARFLAGS       =$arflags\n";
1927 print "PERL          =$perl\n";
1928
1929 my $des_ptr=0;
1930 my $des_risc1=0;
1931 my $des_risc2=0;
1932 my $des_unroll=0;
1933 my $bn_ll=0;
1934 my $def_int=2;
1935 my $rc4_int=$def_int;
1936 my $md2_int=$def_int;
1937 my $idea_int=$def_int;
1938 my $rc2_int=$def_int;
1939 my $rc4_idx=0;
1940 my $rc4_chunk=0;
1941 my $bf_ptr=0;
1942 my @type=("char","short","int","long");
1943 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1944 my $export_var_as_fn=0;
1945
1946 my $des_int;
1947
1948 foreach (sort split(/\s+/,$bn_ops))
1949         {
1950         $des_ptr=1 if /DES_PTR/;
1951         $des_risc1=1 if /DES_RISC1/;
1952         $des_risc2=1 if /DES_RISC2/;
1953         $des_unroll=1 if /DES_UNROLL/;
1954         $des_int=1 if /DES_INT/;
1955         $bn_ll=1 if /BN_LLONG/;
1956         $rc4_int=0 if /RC4_CHAR/;
1957         $rc4_int=3 if /RC4_LONG/;
1958         $rc4_idx=1 if /RC4_INDEX/;
1959         $rc4_chunk=1 if /RC4_CHUNK/;
1960         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1961         $md2_int=0 if /MD2_CHAR/;
1962         $md2_int=3 if /MD2_LONG/;
1963         $idea_int=1 if /IDEA_SHORT/;
1964         $idea_int=3 if /IDEA_LONG/;
1965         $rc2_int=1 if /RC2_SHORT/;
1966         $rc2_int=3 if /RC2_LONG/;
1967         $bf_ptr=1 if $_ eq "BF_PTR";
1968         $bf_ptr=2 if $_ eq "BF_PTR2";
1969         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1970         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1971         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1972         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1973         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1974         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1975         }
1976
1977 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1978 unlink("include/openssl/opensslconf.h.new") || die "unable to remove old include/openssl/opensslconf.h.new:$!\n" if -e "include/openssl/opensslconf.h.new";
1979 open(OUT,'>include/openssl/opensslconf.h.new') || die "unable to create include/openssl/opensslconf.h.new:$!\n";
1980 print OUT "/* opensslconf.h */\n";
1981 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1982
1983 print OUT "#ifdef  __cplusplus\n";
1984 print OUT "extern \"C\" {\n";
1985 print OUT "#endif\n";
1986 print OUT "/* OpenSSL was configured with the following options: */\n";
1987 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1988 $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;
1989 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1990 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1991 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1992 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1993 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1994 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1995 print OUT $openssl_sys_defines;
1996 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1997 print OUT $openssl_experimental_defines;
1998 print OUT "\n";
1999 print OUT $openssl_algorithm_defines;
2000 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
2001 print OUT $openssl_thread_defines;
2002 print OUT $openssl_other_defines,"\n";
2003
2004 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
2005 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
2006 print OUT "   who haven't had the time to do the appropriate changes in their\n";
2007 print OUT "   applications.  */\n";
2008 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
2009 print OUT $openssl_algorithm_defines_trans;
2010 print OUT "#endif\n\n";
2011
2012 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
2013
2014 while (<IN>)
2015         {
2016         if      (/^#define\s+OPENSSLDIR/)
2017                 {
2018                 my $foo = $openssldir;
2019                 $foo =~ s/\\/\\\\/g;
2020                 print OUT "#define OPENSSLDIR \"$foo\"\n";
2021                 }
2022         elsif   (/^#define\s+ENGINESDIR/)
2023                 {
2024                 my $foo = "$prefix/$libdir/engines";
2025                 $foo =~ s/\\/\\\\/g;
2026                 print OUT "#define ENGINESDIR \"$foo\"\n";
2027                 }
2028         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
2029                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
2030                         if $export_var_as_fn;
2031                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
2032                         ($export_var_as_fn)?"define":"undef"; }
2033         elsif   (/^#define\s+OPENSSL_UNISTD/)
2034                 {
2035                 $unistd = "<unistd.h>" if $unistd eq "";
2036                 print OUT "#define OPENSSL_UNISTD $unistd\n";
2037                 }
2038         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
2039                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
2040         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
2041                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
2042         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
2043                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
2044         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
2045                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
2046         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
2047                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
2048         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
2049                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
2050         elsif   (/^\#define\s+DES_LONG\s+.*/)
2051                 { printf OUT "#define DES_LONG unsigned %s\n",
2052                         ($des_int)?'int':'long'; }
2053         elsif   (/^\#(define|undef)\s+DES_PTR/)
2054                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
2055         elsif   (/^\#(define|undef)\s+DES_RISC1/)
2056                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
2057         elsif   (/^\#(define|undef)\s+DES_RISC2/)
2058                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
2059         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
2060                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
2061         elsif   (/^#define\s+RC4_INT\s/)
2062                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
2063         elsif   (/^#undef\s+RC4_CHUNK/)
2064                 {
2065                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
2066                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
2067                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
2068                 }
2069         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
2070                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
2071         elsif (/^#(define|undef)\s+I386_ONLY/)
2072                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
2073                         "define":"undef"; }
2074         elsif   (/^#define\s+MD2_INT\s/)
2075                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
2076         elsif   (/^#define\s+IDEA_INT\s/)
2077                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
2078         elsif   (/^#define\s+RC2_INT\s/)
2079                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
2080         elsif (/^#(define|undef)\s+BF_PTR/)
2081                 {
2082                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
2083                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
2084                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
2085                 }
2086         else
2087                 { print OUT $_; }
2088         }
2089 close(IN);
2090 print OUT "#ifdef  __cplusplus\n";
2091 print OUT "}\n";
2092 print OUT "#endif\n";
2093 close(OUT);
2094 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";
2095 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
2096
2097
2098 # Fix the date
2099
2100 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
2101 print "SIXTY_FOUR_BIT mode\n" if $b64;
2102 print "THIRTY_TWO_BIT mode\n" if $b32;
2103 print "SIXTEEN_BIT mode\n" if $b16;
2104 print "EIGHT_BIT mode\n" if $b8;
2105 print "DES_PTR used\n" if $des_ptr;
2106 print "DES_RISC1 used\n" if $des_risc1;
2107 print "DES_RISC2 used\n" if $des_risc2;
2108 print "DES_UNROLL used\n" if $des_unroll;
2109 print "DES_INT used\n" if $des_int;
2110 print "BN_LLONG mode\n" if $bn_ll;
2111 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
2112 print "RC4_INDEX mode\n" if $rc4_idx;
2113 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
2114 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
2115 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
2116 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
2117 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
2118 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
2119 print "BF_PTR used\n" if $bf_ptr == 1;
2120 print "BF_PTR2 used\n" if $bf_ptr == 2;
2121
2122 {
2123     my $perlguess = $perl =~ m@^/@ ? $perl : '/usr/local/bin/perl';
2124
2125     &dofile("tools/c_rehash",$perlguess,
2126             '^#!/'              => '#!%s',
2127             '^my \$dir;$'       => 'my $dir = "' . $openssldir . '";',
2128             '^my \$prefix;$'    => 'my $prefix = "' . $prefix . '";');
2129     &dofile("apps/CA.pl",$perl,
2130             '^#!/'              => '#!%s');
2131 }
2132 if($IsMK1MF) {
2133         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
2134         printf OUT <<EOF;
2135 #ifndef MK1MF_BUILD
2136   /* auto-generated by Configure for crypto/cversion.c:
2137    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
2138    * Windows builds (and other mk1mf builds) compile cversion.c with
2139    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
2140   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
2141 #endif
2142 EOF
2143         close(OUT);
2144 } else {
2145         my $make_command = "$make PERL=\'$perl\'";
2146         my $make_targets = "";
2147         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
2148         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
2149                 if $make_targets ne "";
2150         if ($depflags ne $default_depflags && !$make_depend) {
2151                 print <<EOF;
2152
2153 Since you've disabled or enabled at least one algorithm, you need to do
2154 the following before building:
2155
2156         make depend
2157 EOF
2158         }
2159 }
2160
2161 # create the ms/version32.rc file if needed
2162 if ($IsMK1MF && ($target !~ /^netware/)) {
2163         my ($v1, $v2, $v3, $v4);
2164         if ($version_num =~ /(^[0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i) {
2165                 $v1=hex $1;
2166                 $v2=hex $2;
2167                 $v3=hex $3;
2168                 $v4=hex $4;
2169         }
2170         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
2171         print OUT <<EOF;
2172 #include <winver.h>
2173
2174 LANGUAGE 0x09,0x01
2175
2176 1 VERSIONINFO
2177   FILEVERSION $v1,$v2,$v3,$v4
2178   PRODUCTVERSION $v1,$v2,$v3,$v4
2179   FILEFLAGSMASK 0x3fL
2180 #ifdef _DEBUG
2181   FILEFLAGS 0x01L
2182 #else
2183   FILEFLAGS 0x00L
2184 #endif
2185   FILEOS VOS__WINDOWS32
2186   FILETYPE VFT_DLL
2187   FILESUBTYPE 0x0L
2188 BEGIN
2189     BLOCK "StringFileInfo"
2190     BEGIN
2191         BLOCK "040904b0"
2192         BEGIN
2193             // Required:
2194             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
2195             VALUE "FileDescription", "OpenSSL Shared Library\\0"
2196             VALUE "FileVersion", "$version\\0"
2197 #if defined(CRYPTO)
2198             VALUE "InternalName", "libeay32\\0"
2199             VALUE "OriginalFilename", "libeay32.dll\\0"
2200 #elif defined(SSL)
2201             VALUE "InternalName", "ssleay32\\0"
2202             VALUE "OriginalFilename", "ssleay32.dll\\0"
2203 #endif
2204             VALUE "ProductName", "The OpenSSL Toolkit\\0"
2205             VALUE "ProductVersion", "$version\\0"
2206             // Optional:
2207             //VALUE "Comments", "\\0"
2208             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
2209             //VALUE "LegalTrademarks", "\\0"
2210             //VALUE "PrivateBuild", "\\0"
2211             //VALUE "SpecialBuild", "\\0"
2212         END
2213     END
2214     BLOCK "VarFileInfo"
2215     BEGIN
2216         VALUE "Translation", 0x409, 0x4b0
2217     END
2218 END
2219 EOF
2220         close(OUT);
2221   }
2222
2223 print <<EOF;
2224
2225 Configured for $target.
2226 EOF
2227
2228 print <<\EOF if (!$no_threads && !$threads);
2229
2230 The library could not be configured for supporting multi-threaded
2231 applications as the compiler options required on this system are not known.
2232 See file INSTALL for details if you need multi-threading.
2233 EOF
2234
2235 print <<\EOF if ($no_shared_warn);
2236
2237 You gave the option 'shared'.  Normally, that would give you shared libraries.
2238 Unfortunately, the OpenSSL configuration doesn't include shared library support
2239 for this platform yet, so it will pretend you gave the option 'no-shared'.  If
2240 you can inform the developpers (openssl-dev\@openssl.org) how to support shared
2241 libraries on this platform, they will at least look at it and try their best
2242 (but please first make sure you have tried with a current version of OpenSSL).
2243 EOF
2244
2245 exit(0);
2246
2247 sub usage
2248         {
2249         print STDERR $usage;
2250         print STDERR "\npick os/compiler from:\n";
2251         my $j=0;
2252         my $i;
2253         my $k=0;
2254         foreach $i (sort keys %table)
2255                 {
2256                 next if $i =~ /^debug/;
2257                 $k += length($i) + 1;
2258                 if ($k > 78)
2259                         {
2260                         print STDERR "\n";
2261                         $k=length($i);
2262                         }
2263                 print STDERR $i . " ";
2264                 }
2265         foreach $i (sort keys %table)
2266                 {
2267                 next if $i !~ /^debug/;
2268                 $k += length($i) + 1;
2269                 if ($k > 78)
2270                         {
2271                         print STDERR "\n";
2272                         $k=length($i);
2273                         }
2274                 print STDERR $i . " ";
2275                 }
2276         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2277         exit(1);
2278         }
2279
2280 sub which
2281         {
2282         my($name)=@_;
2283         my $path;
2284         foreach $path (split /:/, $ENV{PATH})
2285                 {
2286                 if (-f "$path/$name$exe_ext" and -x _)
2287                         {
2288                         return "$path/$name$exe_ext" unless ($name eq "perl" and
2289                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
2290                         }
2291                 }
2292         }
2293
2294 sub dofile
2295         {
2296         my $f; my $p; my %m; my @a; my $k; my $ff;
2297         ($f,$p,%m)=@_;
2298
2299         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
2300         @a=<IN>;
2301         close(IN);
2302         foreach $k (keys %m)
2303                 {
2304                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
2305                 }
2306         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
2307         print OUT @a;
2308         close(OUT);
2309         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
2310         rename("$f.new",$f) || die "unable to rename $f.new\n";
2311         }
2312
2313 sub print_table_entry
2314         {
2315         my $target = shift;
2316         my $type = shift;
2317
2318         # Don't print the templates
2319         return if $table{$target}->{template};
2320
2321         if ($type eq "TABLE") {
2322             print <<EOF
2323
2324 *** $target
2325 \$cc           = $table{$target}->{cc}
2326 \$cflags       = $table{$target}->{cflags}
2327 \$debug_cflags   = $table{$target}->{debug_cflags}
2328 \$release_cflags = $table{$target}->{release_cflags}
2329 \$unistd       = $table{$target}->{unistd}
2330 \$thread_cflag = $table{$target}->{thread_cflag}
2331 \$sys_id       = $table{$target}->{sys_id}
2332 \$lflags       = $table{$target}->{lflags}
2333 \$debug_lflags   = $table{$target}->{debug_lflags}
2334 \$release_lflags = $table{$target}->{release_lflags}
2335 \$bn_ops       = $table{$target}->{bn_ops}
2336 \$cpuid_obj    = $table{$target}->{cpuid_obj}
2337 \$bn_obj       = $table{$target}->{bn_obj}
2338 \$ec_obj       = $table{$target}->{ec_obj}
2339 \$des_obj      = $table{$target}->{des_obj}
2340 \$aes_obj      = $table{$target}->{aes_obj}
2341 \$bf_obj       = $table{$target}->{bf_obj}
2342 \$md5_obj      = $table{$target}->{md5_obj}
2343 \$sha1_obj     = $table{$target}->{sha1_obj}
2344 \$cast_obj     = $table{$target}->{cast_obj}
2345 \$rc4_obj      = $table{$target}->{rc4_obj}
2346 \$rmd160_obj   = $table{$target}->{rmd160_obj}
2347 \$rc5_obj      = $table{$target}->{rc5_obj}
2348 \$wp_obj       = $table{$target}->{wp_obj}
2349 \$cmll_obj     = $table{$target}->{cmll_obj}
2350 \$modes_obj    = $table{$target}->{modes_obj}
2351 \$engines_obj  = $table{$target}->{engines_obj}
2352 \$chacha_obj   = $table{$target}->{chacha_obj}
2353 \$poly1305_obj = $table{$target}->{poly1305_obj}
2354 \$perlasm_scheme = $table{$target}->{perlasm_scheme}
2355 \$dso_scheme   = $table{$target}->{dso_scheme}
2356 \$shared_target= $table{$target}->{shared_target}
2357 \$shared_cflag = $table{$target}->{shared_cflag}
2358 \$shared_ldflag = $table{$target}->{shared_ldflag}
2359 \$shared_extension = $table{$target}->{shared_extension}
2360 \$ranlib       = $table{$target}->{ranlib}
2361 \$arflags      = $table{$target}->{arflags}
2362 \$multilib     = $table{$target}->{multilib}
2363 EOF
2364         } elsif ($type eq "HASH") {
2365             my @sequence = (
2366                 "cc",
2367                 "cflags",
2368                 "debug_cflags",
2369                 "release_cflags",
2370                 "unistd",
2371                 "thread_cflag",
2372                 "sys_id",
2373                 "lflags",
2374                 "debug_lflags",
2375                 "release_lflags",
2376                 "bn_ops",
2377                 "cpuid_obj",
2378                 "bn_obj",
2379                 "ec_obj",
2380                 "des_obj",
2381                 "aes_obj",
2382                 "bf_obj",
2383                 "md5_obj",
2384                 "sha1_obj",
2385                 "cast_obj",
2386                 "rc4_obj",
2387                 "rmd160_obj",
2388                 "rc5_obj",
2389                 "wp_obj",
2390                 "cmll_obj",
2391                 "modes_obj",
2392                 "engines_obj",
2393                 "chacha_obj",
2394                 "poly1305_obj",
2395                 "perlasm_scheme",
2396                 "dso_scheme",
2397                 "shared_target",
2398                 "shared_cflag",
2399                 "shared_ldflag",
2400                 "shared_extension",
2401                 "ranlib",
2402                 "arflags",
2403                 "multilib",
2404                 );
2405             my $largest =
2406                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2407             print "    '$target' => {\n";
2408             foreach (@sequence) {
2409                 if ($table{$target}->{$_}) {
2410                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$table{$target}->{$_},"',\n";
2411                 }
2412             }
2413             print "    },\n";
2414         }
2415         }
2416
2417 sub test_sanity
2418         {
2419         my $errorcnt = 0;
2420
2421         print STDERR "=" x 70, "\n";
2422         print STDERR "=== SANITY TESTING!\n";
2423         print STDERR "=== No configuration will be done, all other arguments will be ignored!\n";
2424         print STDERR "=" x 70, "\n";
2425
2426         foreach $target (sort keys %table)
2427                 {
2428                 my $pre_dso_scheme = "perlasm_scheme";
2429                 my $dso_scheme = "dso_scheme";
2430                 my $post_dso_scheme = "shared_target";
2431
2432
2433                 if ($table{$target}->{$pre_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2434                         {
2435                         $errorcnt++;
2436                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2437                         print STDERR "              in the previous field\n";
2438                         }
2439                 elsif ($table{$target}->{$post_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2440                         {
2441                         $errorcnt++;
2442                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2443                         print STDERR "              in the following field\n";
2444                         }
2445                 elsif ($table{$target}->{$dso_scheme} !~ /^(beos|dl|dlfcn|win32|vms|)$/)
2446                         {
2447                         $errorcnt++;
2448                         print STDERR "SANITY ERROR: '$target' has the dso_scheme field = ",$table{$target}->{$dso_scheme},"\n";
2449                         print STDERR "              valid values are 'beos', 'dl', 'dlfcn', 'win32' and 'vms'\n";
2450                         }
2451                 }
2452         print STDERR "No sanity errors detected!\n" if $errorcnt == 0;
2453         return $errorcnt;
2454         }