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 if (defined($disabled{"dgram"}))
1201         {
1202         $disabled{"dtls"} = "forced";
1203         }
1204
1205 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
1206     || defined($disabled{"dh"}) || defined($disabled{"stdio"}))
1207         {
1208         $disabled{"gost"} = "forced";
1209         }
1210
1211
1212 if ($target eq "TABLE") {
1213         foreach $target (sort keys %table) {
1214                 print_table_entry($target, "TABLE");
1215         }
1216         exit 0;
1217 }
1218
1219 if ($target eq "LIST") {
1220         foreach (sort keys %table) {
1221                 print;
1222                 print "\n";
1223         }
1224         exit 0;
1225 }
1226
1227 if ($target eq "HASH") {
1228         print "%table = (\n";
1229         foreach (sort keys %table) {
1230                 print_table_entry($_, "HASH");
1231         }
1232         exit 0;
1233 }
1234
1235 if ($target =~ m/^CygWin32(-.*)$/) {
1236         $target = "Cygwin".$1;
1237 }
1238
1239 print "Configuring for $target\n";
1240
1241 # Support for legacy targets having a name starting with 'debug-'
1242 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1243 if ($d) {
1244     $build_prefix = "debug_";
1245
1246     # If we do not find debug-foo in the table, the target is set to foo,
1247     # but only if the foo target has a noon-empty debug_cflags or debug_lflags
1248     # attribute.
1249     if (!$table{$target} && ($table{$t}->{debug_cflags}
1250                              || $table{$t}->{debug_lflags})) {
1251         $target = $t;
1252     }
1253 }
1254
1255 &usage if (!defined($table{$target})
1256            || $table{$target}->{template}
1257            || ($build_prefix eq "debug_"
1258                && $target !~ /^debug-/
1259                && !($table{$target}->{debug_cflags}
1260                     || $table{$target}->{debug_lflags})));
1261
1262 if ($fips)
1263         {
1264         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
1265         }
1266
1267 foreach (sort (keys %disabled))
1268         {
1269         $options .= " no-$_";
1270
1271         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
1272
1273         if (/^dso$/)
1274                 { $no_dso = 1; }
1275         elsif (/^threads$/)
1276                 { $no_threads = 1; }
1277         elsif (/^shared$/)
1278                 { $no_shared = 1; }
1279         elsif (/^zlib$/)
1280                 { $zlib = 0; }
1281         elsif (/^static-engine$/)
1282                 { }
1283         elsif (/^zlib-dynamic$/)
1284                 { }
1285         elsif (/^sse2$/)
1286                 { $no_sse2 = 1; }
1287         else
1288                 {
1289                 my ($ALGO, $algo);
1290                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
1291
1292                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
1293                         {
1294                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
1295                         print " OPENSSL_NO_$ALGO";
1296
1297                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
1298                         elsif (/^asm$/) { $no_asm = 1; }
1299                         }
1300                 else
1301                         {
1302                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
1303
1304                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
1305                         print " OPENSSL_NO_$ALGO";
1306
1307                         push @skip, $algo;
1308                         # fix-up crypto/directory name(s)
1309                         $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
1310                         $skip[$#skip]="ripemd" if $algo eq "rmd160";
1311
1312                         print " (skip dir)";
1313
1314                         $depflags .= " -DOPENSSL_NO_$ALGO";
1315                         }
1316                 }
1317
1318         print "\n";
1319         }
1320
1321 my $exp_cflags = "";
1322
1323 foreach (sort @experimental)
1324         {
1325         my $ALGO;
1326         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
1327
1328         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
1329         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
1330         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
1331         }
1332
1333 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
1334
1335 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
1336 $exe_ext=".nlm" if ($target =~ /netware/);
1337 $exe_ext=".pm"  if ($target =~ /vos/);
1338 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
1339 $prefix=$openssldir if $prefix eq "";
1340
1341 $default_ranlib= &which("ranlib") or $default_ranlib="true";
1342 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
1343   or $perl="perl";
1344 my $make = $ENV{'MAKE'} || "make";
1345
1346 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
1347
1348 chop $openssldir if $openssldir =~ /\/$/;
1349 chop $prefix if $prefix =~ /.\/$/;
1350
1351 $openssldir=$prefix . "/ssl" if $openssldir eq "";
1352 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
1353
1354
1355 print "IsMK1MF=$IsMK1MF\n";
1356
1357 # Allow environment CC to override compiler...
1358 my $cc = $ENV{CC} || $table{$target}->{cc};
1359
1360 # For cflags and lflags, add the debug_ or release_ attributes
1361 # Do it in such a way that no spurious space is appended (hence the grep).
1362 my $cflags = join(" ",
1363                   grep { $_ } ($table{$target}->{cflags},
1364                                $table{$target}->{$build_prefix."cflags"}));
1365 my $lflags = join(" ",
1366                   grep { $_ } ($table{$target}->{lflags},
1367                                $table{$target}->{$build_prefix."lflags"}));
1368
1369 my $unistd = $table{$target}->{unistd};
1370 my $thread_cflag = $table{$target}->{thread_cflag};
1371 my $sys_id = $table{$target}->{sys_id};
1372 my $bn_ops = $table{$target}->{bn_ops};
1373 my $cpuid_obj = $table{$target}->{cpuid_obj};
1374 my $bn_obj = $table{$target}->{bn_obj};
1375 my $ec_obj = $table{$target}->{ec_obj};
1376 my $des_obj = $table{$target}->{des_obj};
1377 my $aes_obj = $table{$target}->{aes_obj};
1378 my $bf_obj = $table{$target}->{bf_obj};
1379 my $md5_obj = $table{$target}->{md5_obj};
1380 my $sha1_obj = $table{$target}->{sha1_obj};
1381 my $cast_obj = $table{$target}->{cast_obj};
1382 my $rc4_obj = $table{$target}->{rc4_obj};
1383 my $rmd160_obj = $table{$target}->{rmd160_obj};
1384 my $rc5_obj = $table{$target}->{rc5_obj};
1385 my $wp_obj = $table{$target}->{wp_obj};
1386 my $cmll_obj = $table{$target}->{cmll_obj};
1387 my $modes_obj = $table{$target}->{modes_obj};
1388 my $engines_obj = $table{$target}->{engines_obj};
1389 my $chacha_obj = $table{$target}->{chacha_obj};
1390 my $poly1305_obj = $table{$target}->{poly1305_obj};
1391 my $perlasm_scheme = $table{$target}->{perlasm_scheme};
1392 my $dso_scheme = $table{$target}->{dso_scheme};
1393 my $shared_target = $table{$target}->{shared_target};
1394 my $shared_cflag = $table{$target}->{shared_cflag};
1395 my $shared_ldflag = $table{$target}->{shared_ldflag};
1396 my $shared_extension = $table{$target}->{shared_extension};
1397 my $ranlib = $ENV{'RANLIB'} || $table{$target}->{ranlib};
1398 my $ar = $ENV{'AR'} || "ar";
1399 my $arflags = $table{$target}->{arflags};
1400 my $multilib = $table{$target}->{multilib};
1401
1402 # if $prefix/lib$multilib is not an existing directory, then
1403 # assume that it's not searched by linker automatically, in
1404 # which case adding $multilib suffix causes more grief than
1405 # we're ready to tolerate, so don't...
1406 $multilib="" if !-d "$prefix/lib$multilib";
1407
1408 $libdir="lib$multilib" if $libdir eq "";
1409
1410 $cflags = "$cflags$exp_cflags";
1411
1412 # '%' in $lflags is used to split flags to "pre-" and post-flags
1413 my ($prelflags,$postlflags)=split('%',$lflags);
1414 if (defined($postlflags))       { $lflags=$postlflags;  }
1415 else                            { $lflags=$prelflags; undef $prelflags; }
1416
1417 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
1418         {
1419         $cflags =~ s/\-mno\-cygwin\s*//;
1420         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
1421         }
1422
1423 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
1424         # minimally required architecture flags for assembly modules
1425         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
1426         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
1427 }
1428
1429 my $no_shared_warn=0;
1430 my $no_user_cflags=0;
1431
1432 if ($flags ne "")       { $cflags="$flags$cflags"; }
1433 else                    { $no_user_cflags=1;       }
1434
1435 # The DSO code currently always implements all functions so that no
1436 # applications will have to worry about that from a compilation point
1437 # of view. However, the "method"s may return zero unless that platform
1438 # has support compiled in for them. Currently each method is enabled
1439 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1440 # string entry into using the following logic;
1441 my $dso_cflags;
1442 if (!$no_dso && $dso_scheme ne "")
1443         {
1444         $dso_scheme =~ tr/[a-z]/[A-Z]/;
1445         if ($dso_scheme eq "DLFCN")
1446                 {
1447                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
1448                 }
1449         elsif ($dso_scheme eq "DLFCN_NO_H")
1450                 {
1451                 $dso_cflags = "-DDSO_DLFCN";
1452                 }
1453         else
1454                 {
1455                 $dso_cflags = "-DDSO_$dso_scheme";
1456                 }
1457         $cflags = "$dso_cflags $cflags";
1458         }
1459
1460 my $thread_cflags;
1461 my $thread_defines;
1462 if ($thread_cflag ne "(unknown)" && !$no_threads)
1463         {
1464         # If we know how to do it, support threads by default.
1465         $threads = 1;
1466         }
1467 if ($thread_cflag eq "(unknown)" && $threads)
1468         {
1469         # If the user asked for "threads", [s]he is also expected to
1470         # provide any system-dependent compiler options that are
1471         # necessary.
1472         if ($no_user_cflags)
1473                 {
1474                 print "You asked for multi-threading support, but didn't\n";
1475                 print "provide any system-specific compiler options\n";
1476                 exit(1);
1477                 }
1478         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
1479         $thread_defines .= "#define OPENSSL_THREADS\n";
1480         }
1481 else
1482         {
1483         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
1484         $thread_defines .= "#define OPENSSL_THREADS\n";
1485 #       my $def;
1486 #       foreach $def (split ' ',$thread_cflag)
1487 #               {
1488 #               if ($def =~ s/^-D// && $def !~ /^_/)
1489 #                       {
1490 #                       $thread_defines .= "#define $def\n";
1491 #                       }
1492 #               }
1493         }
1494
1495 $lflags="$libs$lflags" if ($libs ne "");
1496
1497 if ($no_asm)
1498         {
1499         $cpuid_obj=$bn_obj=$ec_obj=
1500         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
1501         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj=
1502         $chacha_obj=$poly1305_obj="";
1503         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
1504         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
1505         }
1506 elsif (defined($disabled{ec2m}))
1507         {
1508         $bn_obj =~ s/\w+-gf2m.o//;
1509         }
1510
1511 if (!$no_shared)
1512         {
1513         $cast_obj="";   # CAST assembler is not PIC
1514         }
1515
1516 if ($threads)
1517         {
1518         $cflags=$thread_cflags;
1519         $openssl_thread_defines .= $thread_defines;
1520         }
1521
1522 if ($zlib)
1523         {
1524         $cflags = "-DZLIB $cflags";
1525         if (defined($disabled{"zlib-dynamic"}))
1526                 {
1527                 if (defined($withargs{"zlib-lib"}))
1528                         {
1529                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
1530                         }
1531                 else
1532                         {
1533                         $lflags = "$lflags -lz";
1534                         }
1535                 }
1536         else
1537                 {
1538                 $cflags = "-DZLIB_SHARED $cflags";
1539                 }
1540         }
1541
1542 #Build the library with OPENSSL_USE_DEPRECATED if deprecation is not disabled
1543 if(!defined($disabled{"deprecated"}))
1544         {
1545         $cflags = "-DOPENSSL_USE_DEPRECATED $cflags";
1546         }
1547
1548 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.org
1549 my $shared_mark = "";
1550 if ($shared_target eq "")
1551         {
1552         $no_shared_warn = 1 if !$no_shared && !$fips;
1553         $no_shared = 1;
1554         }
1555 if (!$no_shared)
1556         {
1557         if ($shared_cflag ne "")
1558                 {
1559                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
1560                 }
1561         }
1562
1563 if (!$IsMK1MF)
1564         {
1565         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1566         if ($no_shared)
1567                 {
1568                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
1569                 $options.=" static-engine";
1570                 }
1571         else
1572                 {
1573                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
1574                 $options.=" no-static-engine";
1575                 }
1576         }
1577
1578 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1579
1580 #
1581 # Platform fix-ups
1582 #
1583 if ($target =~ /\-icc$/)        # Intel C compiler
1584         {
1585         my $iccver=0;
1586         if (open(FD,"$cc -V 2>&1 |"))
1587                 {
1588                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1589                 close(FD);
1590                 }
1591         if ($iccver>=8)
1592                 {
1593                 $cflags=~s/\-KPIC/-fPIC/;
1594                 # Eliminate unnecessary dependency from libirc.a. This is
1595                 # essential for shared library support, as otherwise
1596                 # apps/openssl can end up in endless loop upon startup...
1597                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1598                 }
1599         if ($iccver>=9)
1600                 {
1601                 $lflags.=" -i-static";
1602                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1603                 }
1604         if ($iccver>=10)
1605                 {
1606                 $lflags=~s/\-i\-static/-static-intel/;
1607                 }
1608         if ($iccver>=11)
1609                 {
1610                 $cflags.=" -no-intel-extensions";       # disable Cilk
1611                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1612                 }
1613         }
1614
1615 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1616 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1617 # .so objects. Apparently application RPATH is not global and does
1618 # not apply to .so linked with other .so. Problem manifests itself
1619 # when libssl.so fails to load libcrypto.so. One can argue that we
1620 # should engrave this into Makefile.shared rules or into BSD-* config
1621 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1622 # linker only when --prefix is not /usr.
1623 if ($target =~ /^BSD\-/)
1624         {
1625         $shared_ldflag.=" -Wl,-rpath,\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1626         }
1627
1628 if ($sys_id ne "")
1629         {
1630         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1631         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1632         }
1633
1634 if ($ranlib eq "")
1635         {
1636         $ranlib = $default_ranlib;
1637         }
1638
1639 #my ($bn1)=split(/\s+/,$bn_obj);
1640 #$bn1 = "" unless defined $bn1;
1641 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1642 #$bn_obj="$bn1";
1643
1644 $cpuid_obj="" if ($processor eq "386");
1645
1646 $bn_obj = $bn_asm unless $bn_obj ne "";
1647 # bn-586 is the only one implementing bn_*_part_words
1648 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1649 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1650
1651 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1652 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1653 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1654
1655 if ($fips)
1656         {
1657         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1658         }
1659
1660 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1661 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1662 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1663 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1664 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1665 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1666 if ($sha1_obj =~ /\.o$/)
1667         {
1668 #       $sha1_obj=$sha1_enc;
1669         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1670         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1671         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1672         if ($sha1_obj =~ /sse2/)
1673             {   if ($no_sse2)
1674                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1675                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1676                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1677             }
1678         }
1679 if ($md5_obj =~ /\.o$/)
1680         {
1681 #       $md5_obj=$md5_enc;
1682         $cflags.=" -DMD5_ASM";
1683         }
1684 if ($rmd160_obj =~ /\.o$/)
1685         {
1686 #       $rmd160_obj=$rmd160_enc;
1687         $cflags.=" -DRMD160_ASM";
1688         }
1689 if ($aes_obj =~ /\.o$/)
1690         {
1691         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1692         # aes-ctr.o is not a real file, only indication that assembler
1693         # module implements AES_ctr32_encrypt...
1694         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1695         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1696         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1697         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1698         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1699         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1700         }
1701 else    {
1702         $aes_obj=$aes_enc;
1703         }
1704 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1705 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1706         {
1707         $cflags.=" -DWHIRLPOOL_ASM";
1708         }
1709 else    {
1710         $wp_obj="wp_block.o";
1711         }
1712 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1713 if ($modes_obj =~ /ghash\-/)
1714         {
1715         $cflags.=" -DGHASH_ASM";
1716         }
1717 if ($ec_obj =~ /ecp_nistz256/)
1718         {
1719         $cflags.=" -DECP_NISTZ256_ASM";
1720         }
1721 $chacha_obj=$chacha_enc unless ($chacha_obj =~ /\.o$/);
1722 if ($poly1305_obj =~ /\.o$/)
1723         {
1724         $cflags.=" -DPOLY1305_ASM";
1725         }
1726
1727 # "Stringify" the C flags string.  This permits it to be made part of a string
1728 # and works as well on command lines.
1729 $cflags =~ s/([\\\"])/\\\1/g;
1730
1731 my $version = "unknown";
1732 my $version_num = "unknown";
1733 my $major = "unknown";
1734 my $minor = "unknown";
1735 my $shlib_version_number = "unknown";
1736 my $shlib_version_history = "unknown";
1737 my $shlib_major = "unknown";
1738 my $shlib_minor = "unknown";
1739
1740 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1741 while (<IN>)
1742         {
1743         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1744         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*0x(\S+)/;
1745         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1746         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1747         }
1748 close(IN);
1749 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1750
1751 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1752         {
1753         $major=$1;
1754         $minor=$2;
1755         }
1756
1757 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1758         {
1759         $shlib_major=$1;
1760         $shlib_minor=$2;
1761         }
1762
1763 my $ecc = $cc;
1764 $ecc = "clang" if `$cc --version 2>&1` =~ /clang/;
1765
1766 if ($strict_warnings)
1767         {
1768         my $wopt;
1769         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1770         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1771                 {
1772                 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1773                 }
1774         if ($ecc eq "clang")
1775                 {
1776                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1777                         {
1778                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1779                         }
1780                 }
1781         if ($target !~ /^mingw/)
1782                 {
1783                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1784                         {
1785                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1786                         }
1787                 if ($target =~ /^BSD-/)
1788                         {
1789                         $lflags .= " -lexecinfo";
1790                         }
1791                 }
1792         }
1793
1794 open(IN,"<Makefile.org") || die "unable to read Makefile.org:$!\n";
1795 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1796 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1797 print OUT "### Generated automatically from Makefile.org by Configure.\n\n";
1798 my $sdirs=0;
1799
1800 while (<IN>)
1801         {
1802         chomp;
1803         $sdirs = 1 if /^SDIRS=/;
1804         if ($sdirs) {
1805                 my $dir;
1806                 foreach $dir (@skip) {
1807                         s/(\s)$dir /$1/;
1808                         s/\s$dir$//;
1809                         }
1810                 }
1811         $sdirs = 0 unless /\\$/;
1812         s/fips // if (/^DIRS=/ && !$fips);
1813         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1814         s/ccgost// if (/^ENGDIRS=/ && $disabled{"gost"});
1815         s/^VERSION=.*/VERSION=$version/;
1816         s/^MAJOR=.*/MAJOR=$major/;
1817         s/^MINOR=.*/MINOR=$minor/;
1818         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1819         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1820         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1821         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1822         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1823         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1824         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1825         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1826         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1827         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1828         s/^PLATFORM=.*$/PLATFORM=$target/;
1829         s/^OPTIONS=.*$/OPTIONS=$options/;
1830         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1831         if ($cross_compile_prefix)
1832                 {
1833                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1834                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1835                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1836                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1837                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1838                 }
1839         else    {
1840                 s/^CC=.*$/CC= $cc/;
1841                 s/^AR=\s*ar/AR= $ar/;
1842                 s/^RANLIB=.*/RANLIB= $ranlib/;
1843                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $ecc eq "gcc" || $ecc eq "clang";
1844                 }
1845         s/^CFLAG=.*$/CFLAG= $cflags/;
1846         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1847         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1848         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1849         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1850         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1851         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1852         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1853         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1854         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1855         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1856         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1857         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1858         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1859         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1860         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1861         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1862         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1863         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1864         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1865         s/^CHACHA_ENC=.*$/CHACHA_ENC= $chacha_obj/;
1866         s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $poly1305_obj/;
1867         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1868         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1869         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1870         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1871         s/^PERL=.*/PERL= $perl/;
1872         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1873         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1874         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1875         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1876         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1877         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1878         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1879         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1880         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1881         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1882         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1883                 {
1884                 my $sotmp = $1;
1885                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1886                 }
1887         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1888                 {
1889                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1890                 }
1891         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1892                 {
1893                 my $sotmp = $1;
1894                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1895                 }
1896         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1897                 {
1898                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1899                 }
1900         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1901         print OUT $_."\n";
1902         }
1903 close(IN);
1904 close(OUT);
1905 rename($Makefile,"$Makefile.bak") || die "unable to rename $Makefile\n" if -e $Makefile;
1906 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1907
1908 print "CC            =$cc\n";
1909 print "CFLAG         =$cflags\n";
1910 print "EX_LIBS       =$lflags\n";
1911 print "CPUID_OBJ     =$cpuid_obj\n";
1912 print "BN_ASM        =$bn_obj\n";
1913 print "EC_ASM        =$ec_obj\n";
1914 print "DES_ENC       =$des_obj\n";
1915 print "AES_ENC       =$aes_obj\n";
1916 print "BF_ENC        =$bf_obj\n";
1917 print "CAST_ENC      =$cast_obj\n";
1918 print "RC4_ENC       =$rc4_obj\n";
1919 print "RC5_ENC       =$rc5_obj\n";
1920 print "MD5_OBJ_ASM   =$md5_obj\n";
1921 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1922 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1923 print "CMLL_ENC      =$cmll_obj\n";
1924 print "MODES_OBJ     =$modes_obj\n";
1925 print "ENGINES_OBJ   =$engines_obj\n";
1926 print "CHACHA_ENC    =$chacha_obj\n";
1927 print "POLY1305_OBJ  =$poly1305_obj\n";
1928 print "PROCESSOR     =$processor\n";
1929 print "RANLIB        =$ranlib\n";
1930 print "ARFLAGS       =$arflags\n";
1931 print "PERL          =$perl\n";
1932
1933 my $des_ptr=0;
1934 my $des_risc1=0;
1935 my $des_risc2=0;
1936 my $des_unroll=0;
1937 my $bn_ll=0;
1938 my $def_int=2;
1939 my $rc4_int=$def_int;
1940 my $md2_int=$def_int;
1941 my $idea_int=$def_int;
1942 my $rc2_int=$def_int;
1943 my $rc4_idx=0;
1944 my $rc4_chunk=0;
1945 my $bf_ptr=0;
1946 my @type=("char","short","int","long");
1947 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1948 my $export_var_as_fn=0;
1949
1950 my $des_int;
1951
1952 foreach (sort split(/\s+/,$bn_ops))
1953         {
1954         $des_ptr=1 if /DES_PTR/;
1955         $des_risc1=1 if /DES_RISC1/;
1956         $des_risc2=1 if /DES_RISC2/;
1957         $des_unroll=1 if /DES_UNROLL/;
1958         $des_int=1 if /DES_INT/;
1959         $bn_ll=1 if /BN_LLONG/;
1960         $rc4_int=0 if /RC4_CHAR/;
1961         $rc4_int=3 if /RC4_LONG/;
1962         $rc4_idx=1 if /RC4_INDEX/;
1963         $rc4_chunk=1 if /RC4_CHUNK/;
1964         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1965         $md2_int=0 if /MD2_CHAR/;
1966         $md2_int=3 if /MD2_LONG/;
1967         $idea_int=1 if /IDEA_SHORT/;
1968         $idea_int=3 if /IDEA_LONG/;
1969         $rc2_int=1 if /RC2_SHORT/;
1970         $rc2_int=3 if /RC2_LONG/;
1971         $bf_ptr=1 if $_ eq "BF_PTR";
1972         $bf_ptr=2 if $_ eq "BF_PTR2";
1973         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1974         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1975         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1976         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1977         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1978         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1979         }
1980
1981 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1982 unlink("include/openssl/opensslconf.h.new") || die "unable to remove old include/openssl/opensslconf.h.new:$!\n" if -e "include/openssl/opensslconf.h.new";
1983 open(OUT,'>include/openssl/opensslconf.h.new') || die "unable to create include/openssl/opensslconf.h.new:$!\n";
1984 print OUT "/* opensslconf.h */\n";
1985 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1986
1987 print OUT "#ifdef  __cplusplus\n";
1988 print OUT "extern \"C\" {\n";
1989 print OUT "#endif\n";
1990 print OUT "/* OpenSSL was configured with the following options: */\n";
1991 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1992 $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;
1993 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1994 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1995 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1996 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1997 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1998 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1999 print OUT $openssl_sys_defines;
2000 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
2001 print OUT $openssl_experimental_defines;
2002 print OUT "\n";
2003 print OUT $openssl_algorithm_defines;
2004 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
2005 print OUT $openssl_thread_defines;
2006 print OUT $openssl_other_defines,"\n";
2007
2008 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
2009 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
2010 print OUT "   who haven't had the time to do the appropriate changes in their\n";
2011 print OUT "   applications.  */\n";
2012 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
2013 print OUT $openssl_algorithm_defines_trans;
2014 print OUT "#endif\n\n";
2015
2016 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
2017
2018 while (<IN>)
2019         {
2020         if      (/^#define\s+OPENSSLDIR/)
2021                 {
2022                 my $foo = $openssldir;
2023                 $foo =~ s/\\/\\\\/g;
2024                 print OUT "#define OPENSSLDIR \"$foo\"\n";
2025                 }
2026         elsif   (/^#define\s+ENGINESDIR/)
2027                 {
2028                 my $foo = "$prefix/$libdir/engines";
2029                 $foo =~ s/\\/\\\\/g;
2030                 print OUT "#define ENGINESDIR \"$foo\"\n";
2031                 }
2032         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
2033                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
2034                         if $export_var_as_fn;
2035                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
2036                         ($export_var_as_fn)?"define":"undef"; }
2037         elsif   (/^#define\s+OPENSSL_UNISTD/)
2038                 {
2039                 $unistd = "<unistd.h>" if $unistd eq "";
2040                 print OUT "#define OPENSSL_UNISTD $unistd\n";
2041                 }
2042         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
2043                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
2044         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
2045                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
2046         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
2047                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
2048         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
2049                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
2050         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
2051                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
2052         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
2053                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
2054         elsif   (/^\#define\s+DES_LONG\s+.*/)
2055                 { printf OUT "#define DES_LONG unsigned %s\n",
2056                         ($des_int)?'int':'long'; }
2057         elsif   (/^\#(define|undef)\s+DES_PTR/)
2058                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
2059         elsif   (/^\#(define|undef)\s+DES_RISC1/)
2060                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
2061         elsif   (/^\#(define|undef)\s+DES_RISC2/)
2062                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
2063         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
2064                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
2065         elsif   (/^#define\s+RC4_INT\s/)
2066                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
2067         elsif   (/^#undef\s+RC4_CHUNK/)
2068                 {
2069                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
2070                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
2071                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
2072                 }
2073         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
2074                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
2075         elsif (/^#(define|undef)\s+I386_ONLY/)
2076                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
2077                         "define":"undef"; }
2078         elsif   (/^#define\s+MD2_INT\s/)
2079                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
2080         elsif   (/^#define\s+IDEA_INT\s/)
2081                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
2082         elsif   (/^#define\s+RC2_INT\s/)
2083                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
2084         elsif (/^#(define|undef)\s+BF_PTR/)
2085                 {
2086                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
2087                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
2088                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
2089                 }
2090         else
2091                 { print OUT $_; }
2092         }
2093 close(IN);
2094 print OUT "#ifdef  __cplusplus\n";
2095 print OUT "}\n";
2096 print OUT "#endif\n";
2097 close(OUT);
2098 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";
2099 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
2100
2101
2102 # Fix the date
2103
2104 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
2105 print "SIXTY_FOUR_BIT mode\n" if $b64;
2106 print "THIRTY_TWO_BIT mode\n" if $b32;
2107 print "SIXTEEN_BIT mode\n" if $b16;
2108 print "EIGHT_BIT mode\n" if $b8;
2109 print "DES_PTR used\n" if $des_ptr;
2110 print "DES_RISC1 used\n" if $des_risc1;
2111 print "DES_RISC2 used\n" if $des_risc2;
2112 print "DES_UNROLL used\n" if $des_unroll;
2113 print "DES_INT used\n" if $des_int;
2114 print "BN_LLONG mode\n" if $bn_ll;
2115 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
2116 print "RC4_INDEX mode\n" if $rc4_idx;
2117 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
2118 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
2119 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
2120 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
2121 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
2122 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
2123 print "BF_PTR used\n" if $bf_ptr == 1;
2124 print "BF_PTR2 used\n" if $bf_ptr == 2;
2125
2126 {
2127     my $perlguess = $perl =~ m@^/@ ? $perl : '/usr/local/bin/perl';
2128
2129     &dofile("tools/c_rehash",$perlguess,
2130             '^#!/'              => '#!%s',
2131             '^my \$dir;$'       => 'my $dir = "' . $openssldir . '";',
2132             '^my \$prefix;$'    => 'my $prefix = "' . $prefix . '";');
2133     &dofile("apps/CA.pl",$perl,
2134             '^#!/'              => '#!%s');
2135 }
2136 if($IsMK1MF) {
2137         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
2138         printf OUT <<EOF;
2139 #ifndef MK1MF_BUILD
2140   /* auto-generated by Configure for crypto/cversion.c:
2141    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
2142    * Windows builds (and other mk1mf builds) compile cversion.c with
2143    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
2144   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
2145 #endif
2146 EOF
2147         close(OUT);
2148 } else {
2149         my $make_command = "$make PERL=\'$perl\'";
2150         my $make_targets = "";
2151         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
2152         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
2153                 if $make_targets ne "";
2154         if ($depflags ne $default_depflags && !$make_depend) {
2155                 print <<EOF;
2156
2157 Since you've disabled or enabled at least one algorithm, you need to do
2158 the following before building:
2159
2160         make depend
2161 EOF
2162         }
2163 }
2164
2165 # create the ms/version32.rc file if needed
2166 if ($IsMK1MF && ($target !~ /^netware/)) {
2167         my ($v1, $v2, $v3, $v4);
2168         if ($version_num =~ /(^[0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i) {
2169                 $v1=hex $1;
2170                 $v2=hex $2;
2171                 $v3=hex $3;
2172                 $v4=hex $4;
2173         }
2174         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
2175         print OUT <<EOF;
2176 #include <winver.h>
2177
2178 LANGUAGE 0x09,0x01
2179
2180 1 VERSIONINFO
2181   FILEVERSION $v1,$v2,$v3,$v4
2182   PRODUCTVERSION $v1,$v2,$v3,$v4
2183   FILEFLAGSMASK 0x3fL
2184 #ifdef _DEBUG
2185   FILEFLAGS 0x01L
2186 #else
2187   FILEFLAGS 0x00L
2188 #endif
2189   FILEOS VOS__WINDOWS32
2190   FILETYPE VFT_DLL
2191   FILESUBTYPE 0x0L
2192 BEGIN
2193     BLOCK "StringFileInfo"
2194     BEGIN
2195         BLOCK "040904b0"
2196         BEGIN
2197             // Required:
2198             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
2199             VALUE "FileDescription", "OpenSSL Shared Library\\0"
2200             VALUE "FileVersion", "$version\\0"
2201 #if defined(CRYPTO)
2202             VALUE "InternalName", "libeay32\\0"
2203             VALUE "OriginalFilename", "libeay32.dll\\0"
2204 #elif defined(SSL)
2205             VALUE "InternalName", "ssleay32\\0"
2206             VALUE "OriginalFilename", "ssleay32.dll\\0"
2207 #endif
2208             VALUE "ProductName", "The OpenSSL Toolkit\\0"
2209             VALUE "ProductVersion", "$version\\0"
2210             // Optional:
2211             //VALUE "Comments", "\\0"
2212             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
2213             //VALUE "LegalTrademarks", "\\0"
2214             //VALUE "PrivateBuild", "\\0"
2215             //VALUE "SpecialBuild", "\\0"
2216         END
2217     END
2218     BLOCK "VarFileInfo"
2219     BEGIN
2220         VALUE "Translation", 0x409, 0x4b0
2221     END
2222 END
2223 EOF
2224         close(OUT);
2225   }
2226
2227 print <<EOF;
2228
2229 Configured for $target.
2230 EOF
2231
2232 print <<\EOF if (!$no_threads && !$threads);
2233
2234 The library could not be configured for supporting multi-threaded
2235 applications as the compiler options required on this system are not known.
2236 See file INSTALL for details if you need multi-threading.
2237 EOF
2238
2239 print <<\EOF if ($no_shared_warn);
2240
2241 You gave the option 'shared'.  Normally, that would give you shared libraries.
2242 Unfortunately, the OpenSSL configuration doesn't include shared library support
2243 for this platform yet, so it will pretend you gave the option 'no-shared'.  If
2244 you can inform the developpers (openssl-dev\@openssl.org) how to support shared
2245 libraries on this platform, they will at least look at it and try their best
2246 (but please first make sure you have tried with a current version of OpenSSL).
2247 EOF
2248
2249 exit(0);
2250
2251 sub usage
2252         {
2253         print STDERR $usage;
2254         print STDERR "\npick os/compiler from:\n";
2255         my $j=0;
2256         my $i;
2257         my $k=0;
2258         foreach $i (sort keys %table)
2259                 {
2260                 next if $i =~ /^debug/;
2261                 $k += length($i) + 1;
2262                 if ($k > 78)
2263                         {
2264                         print STDERR "\n";
2265                         $k=length($i);
2266                         }
2267                 print STDERR $i . " ";
2268                 }
2269         foreach $i (sort keys %table)
2270                 {
2271                 next if $i !~ /^debug/;
2272                 $k += length($i) + 1;
2273                 if ($k > 78)
2274                         {
2275                         print STDERR "\n";
2276                         $k=length($i);
2277                         }
2278                 print STDERR $i . " ";
2279                 }
2280         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2281         exit(1);
2282         }
2283
2284 sub which
2285         {
2286         my($name)=@_;
2287         my $path;
2288         foreach $path (split /:/, $ENV{PATH})
2289                 {
2290                 if (-f "$path/$name$exe_ext" and -x _)
2291                         {
2292                         return "$path/$name$exe_ext" unless ($name eq "perl" and
2293                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
2294                         }
2295                 }
2296         }
2297
2298 sub dofile
2299         {
2300         my $f; my $p; my %m; my @a; my $k; my $ff;
2301         ($f,$p,%m)=@_;
2302
2303         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
2304         @a=<IN>;
2305         close(IN);
2306         foreach $k (keys %m)
2307                 {
2308                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
2309                 }
2310         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
2311         print OUT @a;
2312         close(OUT);
2313         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
2314         rename("$f.new",$f) || die "unable to rename $f.new\n";
2315         }
2316
2317 sub print_table_entry
2318         {
2319         my $target = shift;
2320         my $type = shift;
2321
2322         # Don't print the templates
2323         return if $table{$target}->{template};
2324
2325         if ($type eq "TABLE") {
2326             print <<EOF
2327
2328 *** $target
2329 \$cc           = $table{$target}->{cc}
2330 \$cflags       = $table{$target}->{cflags}
2331 \$debug_cflags   = $table{$target}->{debug_cflags}
2332 \$release_cflags = $table{$target}->{release_cflags}
2333 \$unistd       = $table{$target}->{unistd}
2334 \$thread_cflag = $table{$target}->{thread_cflag}
2335 \$sys_id       = $table{$target}->{sys_id}
2336 \$lflags       = $table{$target}->{lflags}
2337 \$debug_lflags   = $table{$target}->{debug_lflags}
2338 \$release_lflags = $table{$target}->{release_lflags}
2339 \$bn_ops       = $table{$target}->{bn_ops}
2340 \$cpuid_obj    = $table{$target}->{cpuid_obj}
2341 \$bn_obj       = $table{$target}->{bn_obj}
2342 \$ec_obj       = $table{$target}->{ec_obj}
2343 \$des_obj      = $table{$target}->{des_obj}
2344 \$aes_obj      = $table{$target}->{aes_obj}
2345 \$bf_obj       = $table{$target}->{bf_obj}
2346 \$md5_obj      = $table{$target}->{md5_obj}
2347 \$sha1_obj     = $table{$target}->{sha1_obj}
2348 \$cast_obj     = $table{$target}->{cast_obj}
2349 \$rc4_obj      = $table{$target}->{rc4_obj}
2350 \$rmd160_obj   = $table{$target}->{rmd160_obj}
2351 \$rc5_obj      = $table{$target}->{rc5_obj}
2352 \$wp_obj       = $table{$target}->{wp_obj}
2353 \$cmll_obj     = $table{$target}->{cmll_obj}
2354 \$modes_obj    = $table{$target}->{modes_obj}
2355 \$engines_obj  = $table{$target}->{engines_obj}
2356 \$chacha_obj   = $table{$target}->{chacha_obj}
2357 \$poly1305_obj = $table{$target}->{poly1305_obj}
2358 \$perlasm_scheme = $table{$target}->{perlasm_scheme}
2359 \$dso_scheme   = $table{$target}->{dso_scheme}
2360 \$shared_target= $table{$target}->{shared_target}
2361 \$shared_cflag = $table{$target}->{shared_cflag}
2362 \$shared_ldflag = $table{$target}->{shared_ldflag}
2363 \$shared_extension = $table{$target}->{shared_extension}
2364 \$ranlib       = $table{$target}->{ranlib}
2365 \$arflags      = $table{$target}->{arflags}
2366 \$multilib     = $table{$target}->{multilib}
2367 EOF
2368         } elsif ($type eq "HASH") {
2369             my @sequence = (
2370                 "cc",
2371                 "cflags",
2372                 "debug_cflags",
2373                 "release_cflags",
2374                 "unistd",
2375                 "thread_cflag",
2376                 "sys_id",
2377                 "lflags",
2378                 "debug_lflags",
2379                 "release_lflags",
2380                 "bn_ops",
2381                 "cpuid_obj",
2382                 "bn_obj",
2383                 "ec_obj",
2384                 "des_obj",
2385                 "aes_obj",
2386                 "bf_obj",
2387                 "md5_obj",
2388                 "sha1_obj",
2389                 "cast_obj",
2390                 "rc4_obj",
2391                 "rmd160_obj",
2392                 "rc5_obj",
2393                 "wp_obj",
2394                 "cmll_obj",
2395                 "modes_obj",
2396                 "engines_obj",
2397                 "chacha_obj",
2398                 "poly1305_obj",
2399                 "perlasm_scheme",
2400                 "dso_scheme",
2401                 "shared_target",
2402                 "shared_cflag",
2403                 "shared_ldflag",
2404                 "shared_extension",
2405                 "ranlib",
2406                 "arflags",
2407                 "multilib",
2408                 );
2409             my $largest =
2410                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2411             print "    '$target' => {\n";
2412             foreach (@sequence) {
2413                 if ($table{$target}->{$_}) {
2414                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$table{$target}->{$_},"',\n";
2415                 }
2416             }
2417             print "    },\n";
2418         }
2419         }
2420
2421 sub test_sanity
2422         {
2423         my $errorcnt = 0;
2424
2425         print STDERR "=" x 70, "\n";
2426         print STDERR "=== SANITY TESTING!\n";
2427         print STDERR "=== No configuration will be done, all other arguments will be ignored!\n";
2428         print STDERR "=" x 70, "\n";
2429
2430         foreach $target (sort keys %table)
2431                 {
2432                 my $pre_dso_scheme = "perlasm_scheme";
2433                 my $dso_scheme = "dso_scheme";
2434                 my $post_dso_scheme = "shared_target";
2435
2436
2437                 if ($table{$target}->{$pre_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2438                         {
2439                         $errorcnt++;
2440                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2441                         print STDERR "              in the previous field\n";
2442                         }
2443                 elsif ($table{$target}->{$post_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2444                         {
2445                         $errorcnt++;
2446                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2447                         print STDERR "              in the following field\n";
2448                         }
2449                 elsif ($table{$target}->{$dso_scheme} !~ /^(beos|dl|dlfcn|win32|vms|)$/)
2450                         {
2451                         $errorcnt++;
2452                         print STDERR "SANITY ERROR: '$target' has the dso_scheme field = ",$table{$target}->{$dso_scheme},"\n";
2453                         print STDERR "              valid values are 'beos', 'dl', 'dlfcn', 'win32' and 'vms'\n";
2454                         }
2455                 }
2456         print STDERR "No sanity errors detected!\n" if $errorcnt == 0;
2457         return $errorcnt;
2458         }