Configure

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