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