Configure

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