Configure

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