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