Changes between 0.9.5a and 0.9.6 [xx XXX 2000]
- *) Remove lots of duplicated code from the EVP library. For example *every*
- cipher init() function handles the 'iv' in the same way according to the
- cipher mode. They also all do nothing if the 'key' parameter is NULL and
- for CFB and OFB modes they zero ctx->num.
+ *) New function BN_mod_exp_mont_word for small bases (roughly 20%
+ faster than BN_mod_exp_mont even though it does not use
+ windowing).
+ [Bodo Moeller]
- Most of the routines have the same form and so can be declared in terms
- of macros.
+ *) CygWin32 support.
+ [John Jarvie <jjarvie@newsguy.com>]
- By shifting this to the top level EVP_CipherInit() it can be removed from
- all individual ciphers. If the cipher wants to handle IVs or keys
- differently it can set the EVP_CIPH_CUSTOM_IV or EVP_CIPH_ALWAYS_CALL_INIT
- flags.
- [Steve Henson]
+ *) The type-safe stack code has been rejigged. It is now only compiled
+ in when OpenSSL is configured with the DEBUG_SAFESTACK option and
+ by default all type-specific stack functions are "#define"d back to
+ standard stack functions. This results in more streamlined output
+ but retains the type-safety checking possibilities of the original
+ approach.
+ [Geoff Thorpe]
+
+ *) The STACK code has been cleaned up, and certain type declarations
+ that didn't make a lot of sense have been brought in line. This has
+ also involved a cleanup of sorts in safestack.h to more correctly
+ map type-safe stack functions onto their plain stack counterparts.
+ This work has also resulted in a variety of "const"ifications of
+ lots of the code, especially "_cmp" operations which should normally
+ be prototyped with "const" parameters anyway.
+ [Geoff Thorpe]
+
+ *) When generating bytes for the first time in md_rand.c, 'stir the pool'
+ by seeding with STATE_SIZE dummy bytes (with zero entropy count).
+ (The PRNG state consists of two parts, the large pool 'state' and 'md',
+ where all of 'md' is used each time the PRNG is used, but 'state'
+ is used only indexed by a cyclic counter. As entropy may not be
+ well distributed from the beginning, 'md' is important as a
+ chaining variable. However, the output function chains only half
+ of 'md', i.e. 80 bits. ssleay_rand_add, on the other hand, chains
+ all of 'md', and seeding with STATE_SIZE dummy bytes will result
+ in all of 'state' being rewritten, with the new values depending
+ on virtually all of 'md'. This overcomes the 80 bit limitation.)
+ [Bodo Moeller]
*) In ssl/s2_clnt.c and ssl/s3_clnt.c, call ERR_clear_error() when
the handshake is continued after ssl_verify_cert_chain();
can lead to 'unexplainable' connection aborts later.
[Bodo Moeller; problem tracked down by Lutz Jaenicke]
- *) EVP cipher enhancement. Add hooks for extra EVP features. This will allow
- various cipher parameters to be set in the EVP interface. Initially
- support added for variable key length ciphers via the
- EVP_CIPHER_CTX_set_key_length() function. Other cipher specific
- parameters will be added later via the new catchall 'ctrl' function.
+ *) Major EVP API cipher revision.
+ Add hooks for extra EVP features. This allows various cipher
+ parameters to be set in the EVP interface. Support added for variable
+ key length ciphers via the EVP_CIPHER_CTX_set_key_length() function and
+ setting of RC2 and RC5 parameters.
+
+ Modify EVP_OpenInit() and EVP_SealInit() to cope with variable key length
+ ciphers.
+
+ Remove lots of duplicated code from the EVP library. For example *every*
+ cipher init() function handles the 'iv' in the same way according to the
+ cipher mode. They also all do nothing if the 'key' parameter is NULL and
+ for CFB and OFB modes they zero ctx->num.
+
New functionality allows removal of S/MIME code RC2 hack.
- Still needs support in other library functions, and allow parameter
- setting for algorithms like RC2, RC5.
+ Most of the routines have the same form and so can be declared in terms
+ of macros.
+
+ By shifting this to the top level EVP_CipherInit() it can be removed from
+ all individual ciphers. If the cipher wants to handle IVs or keys
+ differently it can set the EVP_CIPH_CUSTOM_IV or EVP_CIPH_ALWAYS_CALL_INIT
+ flags.
Change lots of functions like EVP_EncryptUpdate() to now return a
value: although software versions of the algorithms cannot fail
# 386 generate 80386 code
# no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
# -<xxx> +<xxx> compiler options are passed through
-#
+#
+# DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
+# provided to stack calls. Generates unique stack functions for
+# each possible stack type.
# DES_PTR use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
# DES_RISC1 use different DES_ENCRYPT macro that helps reduce register
# dependancies but needs to more registers, good for RISC CPU's
# Our development configs
"purify", "purify gcc:-g -DPURIFY -Wall::(unknown):-lsocket -lnsl::::",
"debug", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -ggdb -g2 -Wformat -Wshadow -Wmissing-prototypes -Wmissing-declarations -Werror::(unknown):-lefence::::",
-"debug-ben", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown):::::",
-"debug-ben-debug", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -g3 -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown):::::",
+"debug-ben", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -DDEBUG_SAFESTACK -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown):::::",
+"debug-ben-debug", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -DDEBUG_SAFESTACK -g3 -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown):::::",
"debug-ben-strict", "gcc:-DBN_DEBUG -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DCONST_STRICT -O2 -Wall -Wshadow -Werror -Wpointer-arith -Wcast-qual -Wwrite-strings -pipe::(unknown):::::",
"debug-rse","cc:-DTERMIOS -DL_ENDIAN -pipe -O -g -ggdb3 -Wall::(unknown)::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}",
"debug-bodo", "gcc:-DBIO_PAIR_DEBUG -DL_ENDIAN -DREF_CHECK -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -g -m486 -pedantic -Wshadow -Wall::-D_REENTRANT::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}",
# Sunos configs, assuming sparc for the gcc one.
##"sunos-cc", "cc:-O4 -DNOPROTO -DNOCONST::(unknown)::DES_UNROLL:::",
-"sunos-gcc","gcc:-O3 -mv8 -Dssize_t=int::(unknown)::BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL DES_PTR DES_RISC1:::",
+"sunos-gcc","gcc:-O3 -mv8 -Dssize_t=int::(unknown):-liberty:BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL DES_PTR DES_RISC1:::",
#### IRIX 5.x configs
# -mips2 flag is added by ./config when appropriate.
# Only N32 and N64 ABIs are supported. If you need O32 ABI build, invoke
# './Configure irix-[g]cc' manually.
# -mips4 flag is added by ./config when appropriate.
-"irix-mips3-gcc","gcc:-mabi=n32 -mmips-as -O3 -DTERMIOS -DB_ENDIAN -DBN_DIV3W::(unknown)::MD2_CHAR RC4_INDEX RC4_CHAR RC4_CHUNK_LL DES_UNROLL DES_RISC2 DES_PTR BF_PTR SIXTY_FOUR_BIT:asm/mips3.o::",
-"irix-mips3-cc", "cc:-n32 -O2 -use_readonly_const -DTERMIOS -DB_ENDIAN -DBN_DIV3W::(unknown)::DES_PTR RC4_CHAR RC4_CHUNK_LL DES_RISC2 DES_UNROLL BF_PTR SIXTY_FOUR_BIT:asm/mips3.o::",
+"irix-mips3-gcc","gcc:-mabi=n32 -mmips-as -O3 -DTERMIOS -DB_ENDIAN -DBN_DIV3W::-D_SGI_MP_SOURCE::MD2_CHAR RC4_INDEX RC4_CHAR RC4_CHUNK_LL DES_UNROLL DES_RISC2 DES_PTR BF_PTR SIXTY_FOUR_BIT:asm/mips3.o::",
+"irix-mips3-cc", "cc:-n32 -O2 -use_readonly_const -DTERMIOS -DB_ENDIAN -DBN_DIV3W::-D_SGI_MP_SOURCE::DES_PTR RC4_CHAR RC4_CHUNK_LL DES_RISC2 DES_UNROLL BF_PTR SIXTY_FOUR_BIT:asm/mips3.o::",
# N64 ABI builds.
-"irix64-mips4-gcc","gcc:-mabi=64 -mips4 -mmips-as -O3 -DTERMIOS -DB_ENDIAN -DBN_DIV3W::(unknown)::RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG:asm/mips3.o::",
-"irix64-mips4-cc", "cc:-64 -mips4 -O2 -use_readonly_const -DTERMIOS -DB_ENDIAN -DBN_DIV3W::(unknown)::RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG:asm/mips3.o::",
+"irix64-mips4-gcc","gcc:-mabi=64 -mips4 -mmips-as -O3 -DTERMIOS -DB_ENDIAN -DBN_DIV3W::-D_SGI_MP_SOURCE::RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG:asm/mips3.o::",
+"irix64-mips4-cc", "cc:-64 -mips4 -O2 -use_readonly_const -DTERMIOS -DB_ENDIAN -DBN_DIV3W::-D_SGI_MP_SOURCE::RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG:asm/mips3.o::",
#### Unified HP-UX ANSI C configs.
# Special notes:
#
# <appro@fy.chalmers.se>
#
-"linux-alpha-gcc","gcc:-O3 -DL_ENDIAN -DTERMIO::(unknown)::SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_RISC1 DES_UNROLL:asm/alpha.o::",
-"linux-alpha+bwx-gcc","gcc:-O3 -DL_ENDIAN -DTERMIO::(unknown)::SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_RISC1 DES_UNROLL:asm/alpha.o::",
-"linux-alpha-ccc","ccc:-fast -readonly_strings -DL_ENDIAN -DTERMIO::(unknown)::SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL:asm/alpha.o::",
-"linux-alpha+bwx-ccc","ccc:-fast -readonly_strings -DL_ENDIAN -DTERMIO::(unknown)::SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL:asm/alpha.o::",
+"linux-alpha-gcc","gcc:-O3 -DL_ENDIAN -DTERMIO::-D_REENTRANT::SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_RISC1 DES_UNROLL:asm/alpha.o::",
+"linux-alpha+bwx-gcc","gcc:-O3 -DL_ENDIAN -DTERMIO::-D_REENTRANT::SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_RISC1 DES_UNROLL:asm/alpha.o::",
+"linux-alpha-ccc","ccc:-fast -readonly_strings -DL_ENDIAN -DTERMIO::-D_REENTRANT::SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL:asm/alpha.o::",
+"linux-alpha+bwx-ccc","ccc:-fast -readonly_strings -DL_ENDIAN -DTERMIO::-D_REENTRANT::SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL:asm/alpha.o::",
# assembler versions -- currently defunct:
##"OpenBSD-alpha","gcc:-DTERMIOS -O3 -fomit-frame-pointer::(unknown):SIXTY_FOUR_BIT_LONG DES_INT DES_PTR DES_RISC2:asm/alpha.o::",
"ncr-scde","cc:-O6 -Xa -Hoff=BEHAVED -686 -Hwide -Hiw::(unknown):-lsocket -lnsl:${x86_gcc_des} ${x86_gcc_opts}:::",
# Linux on ARM
-"linux-elf-arm","gcc:-DL_ENDIAN -DTERMIO -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::BN_LLONG::dlfcn",
+"linux-elf-arm","gcc:-DL_ENDIAN -DTERMIO -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::BN_LLONG::::::::::dlfcn",
# UnixWare 2.0
"unixware-2.0","cc:-O -DFILIO_H::(unknown):-lsocket -lnsl:${x86_gcc_des} ${x86_gcc_opts}:::",
"BC-32","bcc32:::::BN_LLONG DES_PTR RC4_INDEX:::",
"BC-16","bcc:::(unknown)::BN_LLONG DES_PTR RC4_INDEX SIXTEEN_BIT:::",
-# CygWin32
+# Mingw32
# (Note: the real CFLAGS for Windows builds are defined by util/mk1mf.pl
# and its library files in util/pl/*)
-"CygWin32", "gcc:-DTERMIOS -DL_ENDIAN -fomit-frame-pointer -O3 -m486 -Wall::::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:",
"Mingw32", "gcc:-DL_ENDIAN -fomit-frame-pointer -O3 -m486 -Wall::::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:",
+# CygWin32
+"CygWin32", "gcc:-DTERMIOS -DL_ENDIAN -fomit-frame-pointer -O3 -m486 -Wall::::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:",
+
# Ultrix from Bernhard Simon <simon@zid.tuwien.ac.at>
"ultrix-cc","cc:-std1 -O -Olimit 1000 -DL_ENDIAN::(unknown)::::::",
"ultrix-gcc","gcc:-O3 -DL_ENDIAN::(unknown)::::::",
);
my @WinTargets=qw(VC-NT VC-WIN32 VC-WIN16 VC-W31-16 VC-W31-32 VC-MSDOS BC-32
- BC-16 CygWin32 Mingw32);
+ BC-16 Mingw32);
my $prefix="";
my $openssldir="";
my $libs="";
my $target="";
my $options="";
+my $symlink=1;
foreach (@ARGV)
{
s /^-no-/no-/; # some people just can't read the instructions
{ $no_threads=1; }
elsif (/^threads$/)
{ $threads=1; }
+ elsif (/^no-symlinks$/)
+ { $symlink=0; }
elsif (/^no-(.+)$/)
{
my $algo=$1;
EOF
close(OUT);
} else {
- (system "make -f Makefile.ssl PERL=\'$perl\' links") == 0 or exit $?;
+ (system "make -f Makefile.ssl PERL=\'$perl\' links") == 0 or exit $?
+ if $symlink;
### (system 'make depend') == 0 or exit $? if $depflags ne "";
# Run "make depend" manually if you want to be able to delete
# the source code files of ciphers you left out.
* Why can't I make an SSL connection using a DSA certificate?
* How can I remove the passphrase on a private key?
* Why can't the OpenSSH configure script detect OpenSSL?
+* Why does the OpenSSL test fail with "bc: command not found"?
+* Why does the OpenSSL test fail with "bc: 1 no implemented"?
* Which is the current version of OpenSSL?
fi
LIBS="$LIBS -lcrypto"
----- snip:end -----
+
+
+* Why does the OpenSSL test fail with "bc: command not found"?
+
+You didn't install "bc", the Unix calculator. If you want to run the
+tests, get GNU bc from ftp://ftp.gnu.org or from your OS distributor.
+
+
+* Why does the OpenSSL test fail with "bc: 1 no implemented"?
+
+On some SCO installations or versions, bc has a bug that gets triggered when
+you run the test suite (using "make test"). The message returned is "bc:
+1 not implemented". The best way to deal with this is to find another
+implementation of bc and compile/install it. For example, GNU bc (see
+http://www.gnu.org/software/software.html for download instructions) can
+be safely used.
> cd out
> ..\ms\test
+ GNU C (CygWin32)
+ ---------------
+
+ CygWin32 provides a bash shell and GNU tools environment running on
+ NT 4.0, Windows 9x and Windows 2000. Consequently, a make of OpenSSL
+ with CygWin is closer to a GNU bash environment such as Linux rather
+ than other W32 makes that are based on a single makefile approach.
+ CygWin32 implements Posix/Unix calls through cygwin1.dll, and is
+ contrasted to Mingw32 which links dynamically to msvcrt.dll or
+ crtdll.dll.
+
+ To build OpenSSL using CygWin32:
+
+ * Install CygWin32 (see http://sourceware.cygnus.com/cygwin)
+
+ * Install Perl and ensure it is in the path
+
+ * Run the CygWin bash shell
+
+ * $ tar zxvf openssl-x.x.x.tar.gz
+ $ cd openssl-x.x.x
+ $ ./Configure no-threads CygWin32
+ [...]
+ $ make
+ [...]
+ $ make test
+ $ make install
+
+ This will create a default install in /usr/local/ssl.
+
+ CygWin32 Notes:
+
+ "make test" and normal file operations may fail in directories
+ mounted as text (i.e. mount -t c:\somewhere /home) due to CygWin
+ stripping of carriage returns. To avoid this ensure that a binary
+ mount is used, e.g. mount -b c:\somewhere /home.
+
+ As of version 1.1.1 CygWin32 is relatively unstable in its handling
+ of cr/lf issues. These make procedures succeeded with versions 1.1 and
+ the snapshot 20000524 (Slow!).
+
+ "bc" is not provided in the CygWin32 distribution. This causes a
+ non-fatal error in "make test" but is otherwise harmless. If
+ desired, GNU bc can be built with CygWin32 without change.
+
+
Troubleshooting
---------------
errors:
perl util/mkerr.pl -recurse -write
+stacks:
+ perl util/mkstack.pl -recurse
+
util/libeay.num::
perl util/mkdef.pl crypto update
(echo 'Output of `Configure TABLE'"':"; \
perl Configure TABLE) > TABLE
-update: depend errors util/libeay.num util/ssleay.num crypto/objects/obj_dat.h TABLE
+update: depend errors stacks util/libeay.num util/ssleay.num crypto/objects/obj_dat.h TABLE
tar:
@$(TAR) $(TARFLAGS) -cvf - \
$rc5_obj = asm/r586-elf.o
$dso_scheme = dlfcn
+*** linux-elf-arm
+$cc = gcc
+$cflags = -DL_ENDIAN -DTERMIO -O3 -fomit-frame-pointer -Wall
+$unistd =
+$thread_cflag = -D_REENTRANT
+$lflags =
+$bn_ops = BN_LLONG
+$bn_obj =
+$des_obj =
+$bf_obj =
+$md5_obj =
+$sha1_obj =
+$cast_obj =
+$rc4_obj =
+$rmd160_obj =
+$rc5_obj =
+$dso_scheme = dlfcn
+
*** linux-ia64
$cc = gcc
$cflags = -DL_ENDIAN -DTERMIO -O3 -fomit-frame-pointer -Wall
$(PROGRAM): progs.h $(E_OBJ) $(PROGRAM).o $(DLIBCRYPTO) $(DLIBSSL)
$(RM) $(PROGRAM)
$(CC) -o $(PROGRAM) $(CFLAGS) $(PROGRAM).o $(E_OBJ) $(PEX_LIBS) $(LIBSSL) $(LIBCRYPTO) $(EX_LIBS)
- @(cd ..; OPENSSL="`pwd`/apps/openssl"; export OPENSSL; $(PERL) tools/c_rehash certs)
+ -(cd ..; OPENSSL="`pwd`/apps/openssl"; export OPENSSL; $(PERL) tools/c_rehash certs)
progs.h: progs.pl
$(PERL) progs.pl $(E_EXE) >progs.h
*argv=NULL;
len=(unsigned int)stbuf.st_size;
- if (buf != NULL) Free(buf);
- buf=(char *)Malloc(len+1);
+ if (buf != NULL) OPENSSL_free(buf);
+ buf=(char *)OPENSSL_malloc(len+1);
if (buf == NULL) return(0);
len=fread(buf,1,len,fp);
i=0;
for (p=buf; *p; p++)
if (*p == '\n') i++;
- if (arg != NULL) Free(arg);
- arg=(char **)Malloc(sizeof(char *)*(i*2));
+ if (arg != NULL) OPENSSL_free(arg);
+ arg=(char **)OPENSSL_malloc(sizeof(char *)*(i*2));
*argv=arg;
num=0;
if (arg->count == 0)
{
arg->count=20;
- arg->data=(char **)Malloc(sizeof(char *)*arg->count);
+ arg->data=(char **)OPENSSL_malloc(sizeof(char *)*arg->count);
}
for (i=0; i<arg->count; i++)
arg->data[i]=NULL;
if (num >= arg->count)
{
arg->count+=20;
- arg->data=(char **)Realloc(arg->data,
+ arg->data=(char **)OPENSSL_realloc(arg->data,
sizeof(char *)*arg->count);
if (argc == 0) return(0);
}
argv++;
if ((osk=sk_new_null()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto end;
}
while (argc >= 1)
{
if ((f=BN_bn2hex(serial)) == NULL) goto err;
BIO_printf(bio_err,"next serial number is %s\n",f);
- Free(f);
+ OPENSSL_free(f);
}
if ((attribs=CONF_get_section(conf,policy)) == NULL)
if ((cert_sk=sk_X509_new_null()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
if (spkac_file != NULL)
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
if (outfile)
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
/* Ok, now we check the 'policy' stuff. */
if ((subject=X509_NAME_new()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
{
if (push != NULL)
X509_NAME_ENTRY_free(push);
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
row[DB_serial]=BN_bn2hex(serial);
if ((row[DB_name] == NULL) || (row[DB_serial] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
goto err;
/* We now just add it to the database */
- row[DB_type]=(char *)Malloc(2);
+ row[DB_type]=(char *)OPENSSL_malloc(2);
tm=X509_get_notAfter(ret);
- row[DB_exp_date]=(char *)Malloc(tm->length+1);
+ row[DB_exp_date]=(char *)OPENSSL_malloc(tm->length+1);
memcpy(row[DB_exp_date],tm->data,tm->length);
row[DB_exp_date][tm->length]='\0';
row[DB_rev_date]=NULL;
/* row[DB_serial] done already */
- row[DB_file]=(char *)Malloc(8);
+ row[DB_file]=(char *)OPENSSL_malloc(8);
/* row[DB_name] done already */
if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
(row[DB_file] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
strcpy(row[DB_file],"unknown");
row[DB_type][0]='V';
row[DB_type][1]='\0';
- if ((irow=(char **)Malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
+ if ((irow=(char **)OPENSSL_malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
ok=1;
err:
for (i=0; i<DB_NUMBER; i++)
- if (row[i] != NULL) Free(row[i]);
+ if (row[i] != NULL) OPENSSL_free(row[i]);
if (CAname != NULL)
X509_NAME_free(CAname);
BN_free(bn);
if ((row[DB_name] == NULL) || (row[DB_serial] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
/* We have to lookup by serial number because name lookup
BIO_printf(bio_err,"Adding Entry to DB for %s\n", row[DB_name]);
/* We now just add it to the database */
- row[DB_type]=(char *)Malloc(2);
+ row[DB_type]=(char *)OPENSSL_malloc(2);
tm=X509_get_notAfter(x509);
- row[DB_exp_date]=(char *)Malloc(tm->length+1);
+ row[DB_exp_date]=(char *)OPENSSL_malloc(tm->length+1);
memcpy(row[DB_exp_date],tm->data,tm->length);
row[DB_exp_date][tm->length]='\0';
row[DB_rev_date]=NULL;
/* row[DB_serial] done already */
- row[DB_file]=(char *)Malloc(8);
+ row[DB_file]=(char *)OPENSSL_malloc(8);
/* row[DB_name] done already */
if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
(row[DB_file] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
strcpy(row[DB_file],"unknown");
row[DB_type][0]='V';
row[DB_type][1]='\0';
- if ((irow=(char **)Malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
+ if ((irow=(char **)OPENSSL_malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
revtm=X509_gmtime_adj(revtm,0);
rrow[DB_type][0]='R';
rrow[DB_type][1]='\0';
- rrow[DB_rev_date]=(char *)Malloc(revtm->length+1);
+ rrow[DB_rev_date]=(char *)OPENSSL_malloc(revtm->length+1);
memcpy(rrow[DB_rev_date],revtm->data,revtm->length);
rrow[DB_rev_date][revtm->length]='\0';
ASN1_UTCTIME_free(revtm);
for (i=0; i<DB_NUMBER; i++)
{
if (row[i] != NULL)
- Free(row[i]);
+ OPENSSL_free(row[i]);
}
return(ok);
}
if (crl != NULL)
{
sk_X509_CRL_push(crl_stack,crl);
- crl=NULL; /* now part of p7 for Freeing */
+ crl=NULL; /* now part of p7 for OPENSSL_freeing */
}
if ((cert_stack=sk_X509_new(NULL)) == NULL) goto end;
ret=count;
end:
- /* never need to Free x */
+ /* never need to OPENSSL_free x */
if (in != NULL) BIO_free(in);
if (sk != NULL) sk_X509_INFO_free(sk);
return(ret);
apps_startup();
- if ((buf=(unsigned char *)Malloc(BUFSIZE)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
if (buf != NULL)
{
memset(buf,0,BUFSIZE);
- Free(buf);
+ OPENSSL_free(buf);
}
if (in != NULL) BIO_free(in);
if (bmd != NULL) BIO_free(bmd);
len=BN_num_bytes(dh->p);
bits=BN_num_bits(dh->p);
- data=(unsigned char *)Malloc(len);
+ data=(unsigned char *)OPENSSL_malloc(len);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
l=BN_bn2bin(dh->p,data);
printf("\tif ((dh->p == NULL) || (dh->g == NULL))\n");
printf("\t\treturn(NULL);\n");
printf("\treturn(dh);\n\t}\n");
- Free(data);
+ OPENSSL_free(data);
}
DSA *dsa;
BIO_printf(bio_err,"Generating DSA parameters, %d bit long prime\n",num);
- dsa = DSA_generate_parameters(num, NULL, 0, NULL, NULL, dh_cb, bio_err);
+ dsa = DSA_generate_parameters(num, NULL, 0, NULL, NULL, dh_cb, bio_err);
if (dsa == NULL)
{
ERR_print_errors(bio_err);
len=BN_num_bytes(dh->p);
bits=BN_num_bits(dh->p);
- data=(unsigned char *)Malloc(len);
+ data=(unsigned char *)OPENSSL_malloc(len);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
printf("#ifndef HEADER_DH_H\n"
if (dh->length)
printf("\tdh->length = %d;\n", dh->length);
printf("\treturn(dh);\n\t}\n");
- Free(data);
+ OPENSSL_free(data);
}
if(in != NULL) BIO_free(in);
if(out != NULL) BIO_free(out);
if(dsa != NULL) DSA_free(dsa);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#endif
bits_p=BN_num_bits(dsa->p);
bits_q=BN_num_bits(dsa->q);
bits_g=BN_num_bits(dsa->g);
- data=(unsigned char *)Malloc(len+20);
+ data=(unsigned char *)OPENSSL_malloc(len+20);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
l=BN_bn2bin(dsa->p,data);
if (verbose) BIO_printf(bio_err,"bufsize=%d\n",bsize);
}
- strbuf=Malloc(SIZE);
- buff=(unsigned char *)Malloc(EVP_ENCODE_LENGTH(bsize));
+ strbuf=OPENSSL_malloc(SIZE);
+ buff=(unsigned char *)OPENSSL_malloc(EVP_ENCODE_LENGTH(bsize));
if ((buff == NULL) || (strbuf == NULL))
{
- BIO_printf(bio_err,"Malloc failure %ld\n",(long)EVP_ENCODE_LENGTH(bsize));
+ BIO_printf(bio_err,"OPENSSL_malloc failure %ld\n",(long)EVP_ENCODE_LENGTH(bsize));
goto end;
}
}
end:
ERR_print_errors(bio_err);
- if (strbuf != NULL) Free(strbuf);
- if (buff != NULL) Free(buff);
+ if (strbuf != NULL) OPENSSL_free(strbuf);
+ if (buff != NULL) OPENSSL_free(buff);
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (benc != NULL) BIO_free(benc);
if (b64 != NULL) BIO_free(b64);
- if(pass) Free(pass);
+ if(pass) OPENSSL_free(pass);
EXIT(ret);
}
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (dsa != NULL) DSA_free(dsa);
- if(passout) Free(passout);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#endif
err:
if (rsa != NULL) RSA_free(rsa);
if (out != NULL) BIO_free(out);
- if(passout) Free(passout);
+ if(passout) OPENSSL_free(passout);
if (ret != 0)
ERR_print_errors(bio_err);
EXIT(ret);
config=NULL;
}
if (prog != NULL) lh_free(prog);
- if (arg.data != NULL) Free(arg.data);
+ if (arg.data != NULL) OPENSSL_free(arg.data);
ERR_remove_state(0);
EVP_cleanup();
passwd_malloc_size = pw_maxlen + 2;
/* longer than necessary so that we can warn about truncation */
- passwd = passwd_malloc = Malloc(passwd_malloc_size);
+ passwd = passwd_malloc = OPENSSL_malloc(passwd_malloc_size);
if (passwd_malloc == NULL)
goto err;
}
err:
ERR_print_errors(bio_err);
if (salt_malloc)
- Free(salt_malloc);
+ OPENSSL_free(salt_malloc);
if (passwd_malloc)
- Free(passwd_malloc);
+ OPENSSL_free(passwd_malloc);
if (in)
BIO_free(in);
if (out)
{
if (*salt_malloc_p == NULL)
{
- *salt_p = *salt_malloc_p = Malloc(3);
+ *salt_p = *salt_malloc_p = OPENSSL_malloc(3);
if (*salt_malloc_p == NULL)
goto err;
}
if (*salt_malloc_p == NULL)
{
- *salt_p = *salt_malloc_p = Malloc(9);
+ *salt_p = *salt_malloc_p = OPENSSL_malloc(9);
if (*salt_malloc_p == NULL)
goto err;
}
#endif
BIO_free(in);
BIO_free(out);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
value = uni2asc(av->value.bmpstring->data,
av->value.bmpstring->length);
BIO_printf(out, "%s\n", value);
- Free(value);
+ OPENSSL_free(value);
break;
case V_ASN1_OCTET_STRING:
PKCS8_PRIV_KEY_INFO_free (p8inf);
EVP_PKEY_free(pkey);
BIO_free(out);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
return (0);
}
EVP_PKEY_free(pkey);
BIO_free(out);
BIO_free(in);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
return (0);
}
EVP_PKEY_free(pkey);
X509_REQ_free(req);
X509_free(x509ss);
- if(passargin && passin) Free(passin);
- if(passargout && passout) Free(passout);
+ if(passargin && passin) OPENSSL_free(passin);
+ if(passargout && passout) OPENSSL_free(passout);
OBJ_cleanup();
#ifndef NO_DSA
if (dsa_params != NULL) DSA_free(dsa_params);
i=1;
size=i2d_Netscape_RSA(rsa,NULL,NULL);
- if ((p=(unsigned char *)Malloc(size)) == NULL)
+ if ((p=(unsigned char *)OPENSSL_malloc(size)) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto end;
}
pp=p;
i2d_Netscape_RSA(rsa,&p,NULL);
BIO_write(out,(char *)pp,size);
- Free(pp);
+ OPENSSL_free(pp);
}
#endif
else if (outformat == FORMAT_PEM) {
if(in != NULL) BIO_free(in);
if(out != NULL) BIO_free(out);
if(rsa != NULL) RSA_free(rsa);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#else /* !NO_RSA */
if (bio_err == NULL)
bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
- if ( ((cbuf=Malloc(BUFSIZZ)) == NULL) ||
- ((sbuf=Malloc(BUFSIZZ)) == NULL))
+ if ( ((cbuf=OPENSSL_malloc(BUFSIZZ)) == NULL) ||
+ ((sbuf=OPENSSL_malloc(BUFSIZZ)) == NULL))
{
BIO_printf(bio_err,"out of memory\n");
goto end;
tv.tv_usec = 0;
i=select(width,(void *)&readfds,(void *)&writefds,
NULL,&tv);
- if(!i && (!_kbhit() || !read_tty) ) continue;
+ if(!i && (!((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0))) || !read_tty) ) continue;
} else i=select(width,(void *)&readfds,(void *)&writefds,
NULL,NULL);
}
}
#ifdef WINDOWS
- else if (_kbhit())
+ else if ((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
#else
else if (FD_ISSET(fileno(stdin),&readfds))
#endif
if (con != NULL) SSL_free(con);
if (con2 != NULL) SSL_free(con2);
if (ctx != NULL) SSL_CTX_free(ctx);
- if (cbuf != NULL) { memset(cbuf,0,BUFSIZZ); Free(cbuf); }
- if (sbuf != NULL) { memset(sbuf,0,BUFSIZZ); Free(sbuf); }
+ if (cbuf != NULL) { memset(cbuf,0,BUFSIZZ); OPENSSL_free(cbuf); }
+ if (sbuf != NULL) { memset(sbuf,0,BUFSIZZ); OPENSSL_free(sbuf); }
if (bio_c_out != NULL)
{
BIO_free(bio_c_out);
{
EBCDIC_OUTBUFF *wbuf;
- wbuf = (EBCDIC_OUTBUFF *)Malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
+ wbuf = (EBCDIC_OUTBUFF *)OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
wbuf->alloced = 1024;
wbuf->buff[0] = '\0';
{
if (a == NULL) return(0);
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
num = num + num; /* double the size */
if (num < inl)
num = inl;
- Free(wbuf);
- wbuf=(EBCDIC_OUTBUFF *)Malloc(sizeof(EBCDIC_OUTBUFF) + num);
+ OPENSSL_free(wbuf);
+ wbuf=(EBCDIC_OUTBUFF *)OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
wbuf->alloced = num;
wbuf->buff[0] = '\0';
struct timeval tv;
#endif
- if ((buf=Malloc(bufsize)) == NULL)
+ if ((buf=OPENSSL_malloc(bufsize)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto err;
if (buf != NULL)
{
memset(buf,0,bufsize);
- Free(buf);
+ OPENSSL_free(buf);
}
if (ret >= 0)
BIO_printf(bio_s_out,"ACCEPT\n");
BIO *io,*ssl_bio,*sbio;
long total_bytes;
- buf=Malloc(bufsize);
+ buf=OPENSSL_malloc(bufsize);
if (buf == NULL) return(0);
io=BIO_new(BIO_f_buffer());
ssl_bio=BIO_new(BIO_f_ssl());
if (ret >= 0)
BIO_printf(bio_s_out,"ACCEPT\n");
- if (buf != NULL) Free(buf);
+ if (buf != NULL) OPENSSL_free(buf);
if (io != NULL) BIO_free_all(io);
/* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
return(ret);
return(0);
}
i=(*cb)(name,sock, context);
- if (name != NULL) Free(name);
+ if (name != NULL) OPENSSL_free(name);
SHUTDOWN2(sock);
if (i < 0)
{
}
else
{
- if ((*host=(char *)Malloc(strlen(h1->h_name)+1)) == NULL)
+ if ((*host=(char *)OPENSSL_malloc(strlen(h1->h_name)+1)) == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
return(0);
}
strcpy(*host,h1->h_name);
BIO_free(in);
BIO_free(indata);
BIO_free(out);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
return (ret);
}
rsa_key[i]=NULL;
#endif
- if ((buf=(unsigned char *)Malloc((int)BUFSIZE)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
#ifndef NO_DES
buf_as_des_cblock = (des_cblock *)buf;
#endif
- if ((buf2=(unsigned char *)Malloc((int)BUFSIZE)) == NULL)
+ if ((buf2=(unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
mret=0;
end:
ERR_print_errors(bio_err);
- if (buf != NULL) Free(buf);
- if (buf2 != NULL) Free(buf2);
+ if (buf != NULL) OPENSSL_free(buf);
+ if (buf2 != NULL) OPENSSL_free(buf2);
#ifndef NO_RSA
for (i=0; i<RSA_NUM; i++)
if (rsa_key[i] != NULL)
goto end;
}
BIO_printf(out, "SPKAC=%s\n", spkstr);
- Free(spkstr);
+ OPENSSL_free(spkstr);
ret = 0;
goto end;
}
BIO_free(out);
BIO_free(key);
EVP_PKEY_free(pkey);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
EXIT(ret);
}
BIO_printf(STDout,"/* issuer :%s */\n",buf);
z=i2d_X509(x,NULL);
- m=Malloc(z);
+ m=OPENSSL_malloc(z);
d=(unsigned char *)m;
z=i2d_X509_NAME(X509_get_subject_name(x),&d);
if (y%16 != 0) BIO_printf(STDout,"\n");
BIO_printf(STDout,"};\n");
- Free(m);
+ OPENSSL_free(m);
}
else if (text == i)
{
X509_REQ_free(rq);
sk_ASN1_OBJECT_pop_free(trust, ASN1_OBJECT_free);
sk_ASN1_OBJECT_pop_free(reject, ASN1_OBJECT_free);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
EXIT(ret);
}
EVP_PKEY_free(upkey);
X509_STORE_CTX_init(&xsc,ctx,x,NULL);
- buf=Malloc(EVP_PKEY_size(pkey)*2+
+ buf=OPENSSL_malloc(EVP_PKEY_size(pkey)*2+
((serialfile == NULL)
?(strlen(CAfile)+strlen(POSTFIX)+1)
:(strlen(serialfile)))+1);
X509_STORE_CTX_cleanup(&xsc);
if (!ret)
ERR_print_errors(bio_err);
- if (buf != NULL) Free(buf);
+ if (buf != NULL) OPENSSL_free(buf);
if (bs != NULL) ASN1_INTEGER_free(bs);
if (io != NULL) BIO_free(io);
if (serial != NULL) BN_free(serial);
sun4d) OUT="linux-sparcv8" ;;
*) OUT="linux-sparcv7" ;;
esac ;;
+ arm*-*-linux2) OUT="linux-elf-arm" ;;
*-*-linux2) OUT="linux-elf" ;;
*-*-linux1) OUT="linux-aout" ;;
sun4u*-sun-solaris2)
if (len-- > 1) /* using one because of the bits left byte */
{
- s=(unsigned char *)Malloc((int)len);
+ s=(unsigned char *)OPENSSL_malloc((int)len);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
s=NULL;
ret->length=(int)len;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->type=V_ASN1_BIT_STRING;
if (a != NULL) (*a)=ret;
{
if (!value) return(1); /* Don't need to set */
if (a->data == NULL)
- c=(unsigned char *)Malloc(w+1);
+ c=(unsigned char *)OPENSSL_malloc(w+1);
else
- c=(unsigned char *)Realloc(a->data,w+1);
+ c=(unsigned char *)OPENSSL_realloc(a->data,w+1);
if (c == NULL) return(0);
a->data=c;
a->length=w+1;
if (len != 0)
{
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
else
s=NULL;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->length=(int)len;
ret->data=s;
ret->type=tag;
{
if ((ret->length < len) || (ret->data == NULL))
{
- if (ret->data != NULL) Free(ret->data);
- s=(unsigned char *)Malloc((int)len + 1);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
+ s=(unsigned char *)OPENSSL_malloc((int)len + 1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
else
{
s=NULL;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
}
ret->length=(int)len;
if (!asn1_Finish(c)) goto err;
a->length=num;
- if (a->data != NULL) Free(a->data);
+ if (a->data != NULL) OPENSSL_free(a->data);
a->data=(unsigned char *)b.data;
if (os != NULL) ASN1_STRING_free(os);
return(1);
err:
ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE,c->error);
if (os != NULL) ASN1_STRING_free(os);
- if (b.data != NULL) Free(b.data);
+ if (b.data != NULL) OPENSSL_free(b.data);
return(0);
}
unsigned char *str,*p;
i=i2d(data,NULL);
- if ((str=(unsigned char *)Malloc(i)) == NULL) return(0);
+ if ((str=(unsigned char *)OPENSSL_malloc(i)) == NULL) return(0);
p=str;
i2d(data,&p);
EVP_DigestInit(&ctx,type);
EVP_DigestUpdate(&ctx,str,i);
EVP_DigestFinal(&ctx,md,len);
- Free(str);
+ OPENSSL_free(str);
return(1);
}
if (x == NULL) return(NULL);
i=(long)i2d(x,NULL);
- b=(unsigned char *)Malloc((unsigned int)i+10);
+ b=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (b == NULL)
{ ASN1err(ASN1_F_ASN1_DUP,ERR_R_MALLOC_FAILURE); return(NULL); }
p= b;
i=i2d(x,&p);
p= b;
ret=d2i(NULL,&p,i);
- Free(b);
+ OPENSSL_free(b);
return(ret);
}
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
p+=len;
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
if (a->length < (sizeof(long)+1))
{
if (a->data != NULL)
- Free(a->data);
- if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)
+ OPENSSL_free(a->data);
+ if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
memset((char *)a->data,0,sizeof(long)+1);
}
if (a->data == NULL)
else ret->type=V_ASN1_ENUMERATED;
j=BN_num_bits(bn);
len=((j == 0)?0:((j/8)+1));
- ret->data=(unsigned char *)Malloc(len+4);
+ ret->data=(unsigned char *)OPENSSL_malloc(len+4);
ret->length=BN_bn2bin(bn,ret->data);
return(ret);
err:
p=(char *)s->data;
if ((p == NULL) || (s->length < 16))
{
- p=Malloc(20);
+ p=OPENSSL_malloc(20);
if (p == NULL) return(NULL);
if (s->data != NULL)
- Free(s->data);
+ OPENSSL_free(s->data);
s->data=(unsigned char *)p;
}
M_ASN1_OCTET_STRING_free(a->header);
if (a->meth != NULL)
a->meth->destroy(a->data);
- Free(a);
+ OPENSSL_free(a);
}
int i,j=0,n,ret=1;
n=i2d(x,NULL);
- b=(char *)Malloc(n);
+ b=(char *)OPENSSL_malloc(n);
if (b == NULL)
{
ASN1err(ASN1_F_ASN1_I2D_BIO,ERR_R_MALLOC_FAILURE);
j+=i;
n-=i;
}
- Free(b);
+ OPENSSL_free(b);
return(ret);
}
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
memcpy(s,p,(int)len);
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
p+=len;
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
if (a->length < (sizeof(long)+1))
{
if (a->data != NULL)
- Free(a->data);
- if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)
+ OPENSSL_free(a->data);
+ if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
memset((char *)a->data,0,sizeof(long)+1);
}
if (a->data == NULL)
else ret->type=V_ASN1_INTEGER;
j=BN_num_bits(bn);
len=((j == 0)?0:((j/8)+1));
- ret->data=(unsigned char *)Malloc(len+4);
+ ret->data=(unsigned char *)OPENSSL_malloc(len+4);
ret->length=BN_bn2bin(bn,ret->data);
return(ret);
err:
dest = *out;
if(dest->data) {
dest->length = 0;
- Free(dest->data);
+ OPENSSL_free(dest->data);
dest->data = NULL;
}
dest->type = str_type;
cpyfunc = cpy_utf8;
break;
}
- if(!(p = Malloc(outlen + 1))) {
+ if(!(p = OPENSSL_malloc(outlen + 1))) {
ASN1_STRING_free(dest);
ASN1err(ASN1_F_ASN1_MBSTRING_COPY,ERR_R_MALLOC_FAILURE);
return -1;
value |= *p++;
len -= 2;
} else if(inform == MBSTRING_UNIV) {
- value = *p++ << 24;
- value |= *p++ << 16;
+ value = ((unsigned long)*p++) << 24;
+ value |= ((unsigned long)*p++) << 16;
value |= *p++ << 8;
value |= *p++;
len -= 4;
}
if ((ret->data == NULL) || (ret->length < len))
{
- if (ret->data != NULL) Free(ret->data);
- ret->data=(unsigned char *)Malloc(len ? (int)len : 1);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
+ ret->data=(unsigned char *)OPENSSL_malloc(len ? (int)len : 1);
ret->flags|=ASN1_OBJECT_FLAG_DYNAMIC_DATA;
if (ret->data == NULL)
{ i=ERR_R_MALLOC_FAILURE; goto err; }
{
ASN1_OBJECT *ret;
- ret=(ASN1_OBJECT *)Malloc(sizeof(ASN1_OBJECT));
+ ret=(ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
if (ret == NULL)
{
ASN1err(ASN1_F_ASN1_OBJECT_NEW,ERR_R_MALLOC_FAILURE);
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS)
{
#ifndef CONST_STRICT /* disable purely for compile-time strict const checking. Doing this on a "real" compile will cause memory leaks */
- if (a->sn != NULL) Free((void *)a->sn);
- if (a->ln != NULL) Free((void *)a->ln);
+ if (a->sn != NULL) OPENSSL_free((void *)a->sn);
+ if (a->ln != NULL) OPENSSL_free((void *)a->ln);
#endif
a->sn=a->ln=NULL;
}
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA)
{
- if (a->data != NULL) Free(a->data);
+ if (a->data != NULL) OPENSSL_free(a->data);
a->data=NULL;
a->length=0;
}
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
- Free(a);
+ OPENSSL_free(a);
}
ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
}
pStart = p; /* Catch the beg of Setblobs*/
- rgSetBlob = (MYBLOB *)Malloc( sk_num(a) * sizeof(MYBLOB)); /* In this array
+ rgSetBlob = (MYBLOB *)OPENSSL_malloc( sk_num(a) * sizeof(MYBLOB)); /* In this array
we will store the SET blobs */
for (i=0; i<sk_num(a); i++)
/* Now we have to sort the blobs. I am using a simple algo.
*Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/
qsort( rgSetBlob, sk_num(a), sizeof(MYBLOB), SetBlobCmp);
- pTempMem = Malloc(totSize);
+ pTempMem = OPENSSL_malloc(totSize);
/* Copy to temp mem */
p = pTempMem;
/* Copy back to user mem*/
memcpy(pStart, pTempMem, totSize);
- Free(pTempMem);
- Free(rgSetBlob);
+ OPENSSL_free(pTempMem);
+ OPENSSL_free(rgSetBlob);
return(r);
}
}
}
inl=i2d(data,NULL);
- buf_in=(unsigned char *)Malloc((unsigned int)inl);
+ buf_in=(unsigned char *)OPENSSL_malloc((unsigned int)inl);
outll=outl=EVP_PKEY_size(pkey);
- buf_out=(unsigned char *)Malloc((unsigned int)outl);
+ buf_out=(unsigned char *)OPENSSL_malloc((unsigned int)outl);
if ((buf_in == NULL) || (buf_out == NULL))
{
outl=0;
ASN1err(ASN1_F_ASN1_SIGN,ERR_R_EVP_LIB);
goto err;
}
- if (signature->data != NULL) Free(signature->data);
+ if (signature->data != NULL) OPENSSL_free(signature->data);
signature->data=buf_out;
buf_out=NULL;
signature->length=outl;
err:
memset(&ctx,0,sizeof(ctx));
if (buf_in != NULL)
- { memset((char *)buf_in,0,(unsigned int)inl); Free(buf_in); }
+ { memset((char *)buf_in,0,(unsigned int)inl); OPENSSL_free(buf_in); }
if (buf_out != NULL)
- { memset((char *)buf_out,0,outll); Free(buf_out); }
+ { memset((char *)buf_out,0,outll); OPENSSL_free(buf_out); }
return(outl);
}
static STACK_OF(ASN1_STRING_TABLE) *stable = NULL;
static void st_free(ASN1_STRING_TABLE *tbl);
-static int sk_table_cmp(ASN1_STRING_TABLE **a, ASN1_STRING_TABLE **b);
+static int sk_table_cmp(const ASN1_STRING_TABLE * const *a,
+ const ASN1_STRING_TABLE * const *b);
static int table_cmp(ASN1_STRING_TABLE *a, ASN1_STRING_TABLE *b);
{NID_dnQualifier, -1, -1, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK}
};
-static int sk_table_cmp(ASN1_STRING_TABLE **a, ASN1_STRING_TABLE **b)
+static int sk_table_cmp(const ASN1_STRING_TABLE * const *a,
+ const ASN1_STRING_TABLE * const *b)
{
return (*a)->nid - (*b)->nid;
}
return 0;
}
if(!(tmp = ASN1_STRING_TABLE_get(nid))) {
- tmp = Malloc(sizeof(ASN1_STRING_TABLE));
+ tmp = OPENSSL_malloc(sizeof(ASN1_STRING_TABLE));
if(!tmp) {
ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD,
ERR_R_MALLOC_FAILURE);
static void st_free(ASN1_STRING_TABLE *tbl)
{
- if(tbl->flags & STABLE_FLAGS_MALLOC) Free(tbl);
+ if(tbl->flags & STABLE_FLAGS_MALLOC) OPENSSL_free(tbl);
}
IMPLEMENT_STACK_OF(ASN1_STRING_TABLE)
{
if (a == NULL) return;
ASN1_TYPE_component_free(a);
- Free(a);
+ OPENSSL_free(a);
}
int ASN1_TYPE_get(ASN1_TYPE *a)
p=(char *)s->data;
if ((p == NULL) || (s->length < 14))
{
- p=Malloc(20);
+ p=OPENSSL_malloc(20);
if (p == NULL) return(NULL);
if (s->data != NULL)
- Free(s->data);
+ OPENSSL_free(s->data);
s->data=(unsigned char *)p;
}
}
#undef g2
- return mktime(&tm)-offset*60;
+ return mktime(&tm)-offset*60; /* FIXME: mktime assumes the current timezone
+ * instead of UTC, and unless we rewrite OpenSSL
+ * in Lisp we cannot locally change the timezone
+ * without possibly interfering with other parts
+ * of the program. timegm, which uses UTC, is
+ * non-standard.
+ * Also time_t is inappropriate for general
+ * UTC times because it may a 32 bit type. */
}
if( ((p[1] & 0xc0) != 0x80)
|| ((p[2] & 0xc0) != 0x80)
|| ((p[3] & 0xc0) != 0x80) ) return -3;
- value = (*p++ & 0x7) << 18;
+ value = ((unsigned long)(*p++ & 0x7)) << 18;
value |= (*p++ & 0x3f) << 12;
value |= (*p++ & 0x3f) << 6;
value |= *p++ & 0x3f;
|| ((p[2] & 0xc0) != 0x80)
|| ((p[3] & 0xc0) != 0x80)
|| ((p[4] & 0xc0) != 0x80) ) return -3;
- value = (*p++ & 0x3) << 24;
- value |= (*p++ & 0x3f) << 18;
- value |= (*p++ & 0x3f) << 12;
+ value = ((unsigned long)(*p++ & 0x3)) << 24;
+ value |= ((unsigned long)(*p++ & 0x3f)) << 18;
+ value |= ((unsigned long)(*p++ & 0x3f)) << 12;
value |= (*p++ & 0x3f) << 6;
value |= *p++ & 0x3f;
if(value < 0x200000) return -4;
|| ((p[3] & 0xc0) != 0x80)
|| ((p[4] & 0xc0) != 0x80)
|| ((p[5] & 0xc0) != 0x80) ) return -3;
- value = (*p++ & 0x1) << 30;
- value |= (*p++ & 0x3f) << 24;
- value |= (*p++ & 0x3f) << 18;
- value |= (*p++ & 0x3f) << 12;
+ value = ((unsigned long)(*p++ & 0x1)) << 30;
+ value |= ((unsigned long)(*p++ & 0x3f)) << 24;
+ value |= ((unsigned long)(*p++ & 0x3f)) << 18;
+ value |= ((unsigned long)(*p++ & 0x3f)) << 12;
value |= (*p++ & 0x3f) << 6;
value |= *p++ & 0x3f;
if(value < 0x4000000) return -4;
}
inl=i2d(data,NULL);
- buf_in=Malloc((unsigned int)inl);
+ buf_in=OPENSSL_malloc((unsigned int)inl);
if (buf_in == NULL)
{
ASN1err(ASN1_F_ASN1_VERIFY,ERR_R_MALLOC_FAILURE);
EVP_VerifyUpdate(&ctx,(unsigned char *)buf_in,inl);
memset(buf_in,0,(unsigned int)inl);
- Free(buf_in);
+ OPENSSL_free(buf_in);
if (EVP_VerifyFinal(&ctx,(unsigned char *)signature->data,
(unsigned int)signature->length,pkey) <= 0)
} ASN1_STRING_TABLE;
DECLARE_STACK_OF(ASN1_STRING_TABLE)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_ASN1_STRING_TABLE_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_ASN1_STRING_TABLE_new_null() sk_new_null()
+ #define sk_ASN1_STRING_TABLE_free(a) sk_free(a)
+ #define sk_ASN1_STRING_TABLE_num(a) sk_num(a)
+ #define sk_ASN1_STRING_TABLE_value(a,b) ((ASN1_STRING_TABLE *) \
+ sk_value((a),(b)))
+ #define sk_ASN1_STRING_TABLE_set(a,b,c) ((ASN1_STRING_TABLE *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_ASN1_STRING_TABLE_zero(a) sk_zero(a)
+ #define sk_ASN1_STRING_TABLE_push(a,b) sk_push((a),(char *)(b))
+ #define sk_ASN1_STRING_TABLE_unshift(a,b) sk_unshift((a),(b))
+ #define sk_ASN1_STRING_TABLE_find(a,b) sk_find((a), (char *)(b))
+ #define sk_ASN1_STRING_TABLE_delete(a,b) ((ASN1_STRING_TABLE *) \
+ sk_delete((a),(b)))
+ #define sk_ASN1_STRING_TABLE_delete_ptr(a,b) ((ASN1_STRING_TABLE *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_ASN1_STRING_TABLE_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_ASN1_STRING_TABLE_set_cmp_func(a,b) ((int (*) \
+ (const ASN1_STRING_TABLE * const *,const ASN1_STRING_TABLE * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_ASN1_STRING_TABLE_dup(a) sk_dup(a)
+ #define sk_ASN1_STRING_TABLE_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_ASN1_STRING_TABLE_shift(a) ((ASN1_STRING_TABLE *)sk_shift(a))
+ #define sk_ASN1_STRING_TABLE_pop(a) ((ASN1_STRING_TABLE *)sk_pop(a))
+ #define sk_ASN1_STRING_TABLE_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
/* size limits: this stuff is taken straight from RFC2459 */
typedef int ASN1_NULL;
DECLARE_STACK_OF(ASN1_INTEGER)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_ASN1_INTEGER_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_ASN1_INTEGER_new_null() sk_new_null()
+ #define sk_ASN1_INTEGER_free(a) sk_free(a)
+ #define sk_ASN1_INTEGER_num(a) sk_num(a)
+ #define sk_ASN1_INTEGER_value(a,b) ((ASN1_INTEGER *) \
+ sk_value((a),(b)))
+ #define sk_ASN1_INTEGER_set(a,b,c) ((ASN1_INTEGER *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_ASN1_INTEGER_zero(a) sk_zero(a)
+ #define sk_ASN1_INTEGER_push(a,b) sk_push((a),(char *)(b))
+ #define sk_ASN1_INTEGER_unshift(a,b) sk_unshift((a),(b))
+ #define sk_ASN1_INTEGER_find(a,b) sk_find((a), (char *)(b))
+ #define sk_ASN1_INTEGER_delete(a,b) ((ASN1_INTEGER *) \
+ sk_delete((a),(b)))
+ #define sk_ASN1_INTEGER_delete_ptr(a,b) ((ASN1_INTEGER *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_ASN1_INTEGER_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_ASN1_INTEGER_set_cmp_func(a,b) ((int (*) \
+ (const ASN1_INTEGER * const *,const ASN1_INTEGER * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_ASN1_INTEGER_dup(a) sk_dup(a)
+ #define sk_ASN1_INTEGER_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_ASN1_INTEGER_shift(a) ((ASN1_INTEGER *)sk_shift(a))
+ #define sk_ASN1_INTEGER_pop(a) ((ASN1_INTEGER *)sk_pop(a))
+ #define sk_ASN1_INTEGER_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(ASN1_INTEGER)
typedef struct asn1_type_st
} ASN1_TYPE;
DECLARE_STACK_OF(ASN1_TYPE)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_ASN1_TYPE_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_ASN1_TYPE_new_null() sk_new_null()
+ #define sk_ASN1_TYPE_free(a) sk_free(a)
+ #define sk_ASN1_TYPE_num(a) sk_num(a)
+ #define sk_ASN1_TYPE_value(a,b) ((ASN1_TYPE *) \
+ sk_value((a),(b)))
+ #define sk_ASN1_TYPE_set(a,b,c) ((ASN1_TYPE *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_ASN1_TYPE_zero(a) sk_zero(a)
+ #define sk_ASN1_TYPE_push(a,b) sk_push((a),(char *)(b))
+ #define sk_ASN1_TYPE_unshift(a,b) sk_unshift((a),(b))
+ #define sk_ASN1_TYPE_find(a,b) sk_find((a), (char *)(b))
+ #define sk_ASN1_TYPE_delete(a,b) ((ASN1_TYPE *) \
+ sk_delete((a),(b)))
+ #define sk_ASN1_TYPE_delete_ptr(a,b) ((ASN1_TYPE *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_ASN1_TYPE_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_ASN1_TYPE_set_cmp_func(a,b) ((int (*) \
+ (const ASN1_TYPE * const *,const ASN1_TYPE * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_ASN1_TYPE_dup(a) sk_dup(a)
+ #define sk_ASN1_TYPE_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_ASN1_TYPE_shift(a) ((ASN1_TYPE *)sk_shift(a))
+ #define sk_ASN1_TYPE_pop(a) ((ASN1_TYPE *)sk_pop(a))
+ #define sk_ASN1_TYPE_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(ASN1_TYPE)
typedef struct asn1_method_st
long length);
DECLARE_STACK_OF(ASN1_OBJECT)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_ASN1_OBJECT_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_ASN1_OBJECT_new_null() sk_new_null()
+ #define sk_ASN1_OBJECT_free(a) sk_free(a)
+ #define sk_ASN1_OBJECT_num(a) sk_num(a)
+ #define sk_ASN1_OBJECT_value(a,b) ((ASN1_OBJECT *) \
+ sk_value((a),(b)))
+ #define sk_ASN1_OBJECT_set(a,b,c) ((ASN1_OBJECT *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_ASN1_OBJECT_zero(a) sk_zero(a)
+ #define sk_ASN1_OBJECT_push(a,b) sk_push((a),(char *)(b))
+ #define sk_ASN1_OBJECT_unshift(a,b) sk_unshift((a),(b))
+ #define sk_ASN1_OBJECT_find(a,b) sk_find((a), (char *)(b))
+ #define sk_ASN1_OBJECT_delete(a,b) ((ASN1_OBJECT *) \
+ sk_delete((a),(b)))
+ #define sk_ASN1_OBJECT_delete_ptr(a,b) ((ASN1_OBJECT *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_ASN1_OBJECT_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_ASN1_OBJECT_set_cmp_func(a,b) ((int (*) \
+ (const ASN1_OBJECT * const *,const ASN1_OBJECT * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_ASN1_OBJECT_dup(a) sk_dup(a)
+ #define sk_ASN1_OBJECT_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_ASN1_OBJECT_shift(a) ((ASN1_OBJECT *)sk_shift(a))
+ #define sk_ASN1_OBJECT_pop(a) ((ASN1_OBJECT *)sk_pop(a))
+ #define sk_ASN1_OBJECT_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(ASN1_OBJECT)
ASN1_STRING * ASN1_STRING_new(void);
{
c=str->data;
if (c == NULL)
- str->data=Malloc(len+1);
+ str->data=OPENSSL_malloc(len+1);
else
- str->data=Realloc(c,len+1);
+ str->data=OPENSSL_realloc(c,len+1);
if (str->data == NULL)
{
{
ASN1_STRING *ret;
- ret=(ASN1_STRING *)Malloc(sizeof(ASN1_STRING));
+ ret=(ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
if (ret == NULL)
{
ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW,ERR_R_MALLOC_FAILURE);
void ASN1_STRING_free(ASN1_STRING *a)
{
if (a == NULL) return;
- if (a->data != NULL) Free(a->data);
- Free(a);
+ if (a->data != NULL) OPENSSL_free(a->data);
+ OPENSSL_free(a);
}
int ASN1_STRING_cmp(ASN1_STRING *a, ASN1_STRING *b)
/* New macros */
#define M_ASN1_New_Malloc(ret,type) \
- if ((ret=(type *)Malloc(sizeof(type))) == NULL) \
+ if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \
{ c.line=__LINE__; goto err2; }
#define M_ASN1_New(arg,func) \
}
/* Turn a STACK structures into an ASN1 encoded SEQUENCE OF structure in a
- * Malloc'ed buffer
+ * OPENSSL_malloc'ed buffer
*/
unsigned char *ASN1_seq_pack(STACK *safes, int (*i2d)(), unsigned char **buf,
ASN1err(ASN1_F_ASN1_SEQ_PACK,ASN1_R_ENCODE_ERROR);
return NULL;
}
- if (!(safe = Malloc (safelen))) {
+ if (!(safe = OPENSSL_malloc (safelen))) {
ASN1err(ASN1_F_ASN1_SEQ_PACK,ERR_R_MALLOC_FAILURE);
return NULL;
}
ASN1err(ASN1_F_ASN1_PACK_STRING,ASN1_R_ENCODE_ERROR);
return NULL;
}
- if (!(p = Malloc (octmp->length))) {
+ if (!(p = OPENSSL_malloc (octmp->length))) {
ASN1err(ASN1_F_ASN1_PACK_STRING,ERR_R_MALLOC_FAILURE);
return NULL;
}
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_STRING,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DHPARAMS,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
ret=t;
err:
if (num[2] != NULL) BN_free(num[2]);
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPARAMS,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
ret=t;
err:
*pp=p;
i2d_ASN1_INTEGER(&bs,&p);
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_RSAPUBLICKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
i2d_ASN1_INTEGER(&bs,&p);
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPUBLICKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
if(all) return(t);
else return(tot);
}
if (pkey->private_key->data != NULL)
- Free(pkey->private_key->data);
- if ((pkey->private_key->data=(unsigned char *)Malloc(l[0])) == NULL)
+ OPENSSL_free(pkey->private_key->data);
+ if ((pkey->private_key->data=(unsigned char *)OPENSSL_malloc(l[0])) == NULL)
{
ASN1err(ASN1_F_I2D_NETSCAPE_RSA,ERR_R_MALLOC_FAILURE);
goto err;
zz=pkey->private_key->data;
i2d_RSAPrivateKey(a,&zz);
- if ((os2.data=(unsigned char *)Malloc(os2.length)) == NULL)
+ if ((os2.data=(unsigned char *)OPENSSL_malloc(os2.length)) == NULL)
{
ASN1err(ASN1_F_I2D_NETSCAPE_RSA,ERR_R_MALLOC_FAILURE);
goto err;
i2d_ASN1_OCTET_STRING(&os2,&p);
ret=l[5];
err:
- if (os2.data != NULL) Free(os2.data);
+ if (os2.data != NULL) OPENSSL_free(os2.data);
if (alg != NULL) X509_ALGOR_free(alg);
if (pkey != NULL) NETSCAPE_PKEY_free(pkey);
r=r;
M_ASN1_INTEGER_free(a->version);
X509_ALGOR_free(a->algor);
M_ASN1_OCTET_STRING_free(a->private_key);
- Free(a);
+ OPENSSL_free(a);
}
#endif /* NO_RC4 */
ASN1_OBJECT_free(a->type);
if(a->certs)
sk_X509_pop_free(a->certs, X509_free);
- Free (a);
+ OPENSSL_free (a);
}
if(a==NULL) return;
M_ASN1_OCTET_STRING_free(a->salt);
M_ASN1_INTEGER_free (a->iter);
- Free (a);
+ OPENSSL_free (a);
}
/* Return an algorithm identifier for a PKCS#5 PBE algorithm */
if(iter <= 0) iter = PKCS5_DEFAULT_ITER;
ASN1_INTEGER_set (pbe->iter, iter);
if (!saltlen) saltlen = PKCS5_SALT_LEN;
- if (!(pbe->salt->data = Malloc (saltlen))) {
+ if (!(pbe->salt->data = OPENSSL_malloc (saltlen))) {
ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
return NULL;
}
if(a==NULL) return;
X509_ALGOR_free(a->keyfunc);
X509_ALGOR_free(a->encryption);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **pp)
M_ASN1_INTEGER_free(a->iter);
M_ASN1_INTEGER_free(a->keylength);
X509_ALGOR_free(a->prf);
- Free (a);
+ OPENSSL_free (a);
}
/* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm:
if(!(osalt = M_ASN1_OCTET_STRING_new())) goto merr;
if (!saltlen) saltlen = PKCS5_SALT_LEN;
- if (!(osalt->data = Malloc (saltlen))) goto merr;
+ if (!(osalt->data = OPENSSL_malloc (saltlen))) goto merr;
osalt->length = saltlen;
if (salt) memcpy (osalt->data, salt, saltlen);
else if (RAND_pseudo_bytes (osalt->data, saltlen) < 0) goto merr;
X509_ALGOR_free(a->md);
PKCS7_free(a->contents);
M_ASN1_OCTET_STRING_free(a->digest);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
M_ASN1_INTEGER_free(a->version);
PKCS7_ENC_CONTENT_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
ASN1_OBJECT_free(a->content_type);
X509_ALGOR_free(a->algorithm);
M_ASN1_OCTET_STRING_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_INTEGER_free(a->version);
sk_PKCS7_RECIP_INFO_pop_free(a->recipientinfo,PKCS7_RECIP_INFO_free);
PKCS7_ENC_CONTENT_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_NAME_free(a->issuer);
M_ASN1_INTEGER_free(a->serial);
- Free(a);
+ OPENSSL_free(a);
}
{
if ((*a)->asn1 != NULL)
{
- Free((*a)->asn1);
+ OPENSSL_free((*a)->asn1);
(*a)->asn1=NULL;
}
(*a)->length=0;
{
ASN1_OBJECT_free(a->type);
}
- Free(a);
+ OPENSSL_free(a);
}
void PKCS7_content_free(PKCS7 *a)
if(a == NULL)
return;
- if (a->asn1 != NULL) Free(a->asn1);
+ if (a->asn1 != NULL) OPENSSL_free(a->asn1);
if (a->d.ptr != NULL)
{
X509_ALGOR_free(a->key_enc_algor);
M_ASN1_OCTET_STRING_free(a->enc_key);
if (a->cert != NULL) X509_free(a->cert);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(PKCS7_RECIP_INFO)
sk_X509_pop_free(a->cert,X509_free);
sk_X509_CRL_pop_free(a->crl,X509_CRL_free);
sk_PKCS7_SIGNER_INFO_pop_free(a->signer_info,PKCS7_SIGNER_INFO_free);
- Free(a);
+ OPENSSL_free(a);
}
sk_X509_pop_free(a->cert,X509_free);
sk_X509_CRL_pop_free(a->crl,X509_CRL_free);
sk_PKCS7_SIGNER_INFO_pop_free(a->signer_info,PKCS7_SIGNER_INFO_free);
- Free(a);
+ OPENSSL_free(a);
}
sk_X509_ATTRIBUTE_pop_free(a->unauth_attr,X509_ATTRIBUTE_free);
if (a->pkey != NULL)
EVP_PKEY_free(a->pkey);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(PKCS7_SIGNER_INFO)
{
X509_KEY *ret=NULL;
- M_ASN1_New_Malloc(ret,X509_KEY);
+ M_ASN1_New_OPENSSL_malloc(ret,X509_KEY);
ret->references=1;
ret->type=NID
M_ASN1_New(ret->cert_info,X509_CINF_new);
X509_CINF_free(a->cert_info);
X509_ALGOR_free(a->sig_alg);
ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
0, a->pkey->value.octet_string->length);
ASN1_TYPE_free (a->pkey);
sk_X509_ATTRIBUTE_pop_free (a->attributes, X509_ATTRIBUTE_free);
- Free (a);
+ OPENSSL_free (a);
}
int i,ret=0;
i=RSA_size(x);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
RSAerr(RSA_F_RSA_PRINT,ERR_R_MALLOC_FAILURE);
if (!print(bp,"coefficient:",x->iqmp,m,off)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif /* NO_RSA */
i=BN_num_bytes(bn)*2;
else
i=256;
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
DSAerr(DSA_F_DSA_PRINT,ERR_R_MALLOC_FAILURE);
if ((x->g != NULL) && !print(bp,"G: ",x->g,m,off)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif /* !NO_DSA */
int reason=ERR_R_BUF_LIB,i,ret=0;
i=BN_num_bytes(x->p);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
err:
DHerr(DH_F_DHPARAMS_PRINT,reason);
}
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif
int reason=ERR_R_BUF_LIB,i,ret=0;
i=BN_num_bytes(x->p);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
if (!print(bp,"g:",x->g,m,4)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
DSAerr(DSA_F_DSAPARAMS_PRINT,reason);
return(ret);
}
ret=1;
err:
if (str != NULL) ASN1_STRING_free(str);
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
if (a == NULL) return;
ASN1_OBJECT_free(a->algorithm);
ASN1_TYPE_free(a->parameter);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(X509_ALGOR)
sk_ASN1_TYPE_pop_free(a->value.set,ASN1_TYPE_free);
else
ASN1_TYPE_free(a->value.single);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_BIT_STRING_free(a->issuerUID);
M_ASN1_BIT_STRING_free(a->subjectUID);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
#include <openssl/asn1_mac.h>
#include <openssl/x509.h>
-static int X509_REVOKED_cmp(X509_REVOKED **a,X509_REVOKED **b);
-static int X509_REVOKED_seq_cmp(X509_REVOKED **a,X509_REVOKED **b);
+static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
+ const X509_REVOKED * const *b);
+static int X509_REVOKED_seq_cmp(const X509_REVOKED * const *a,
+ const X509_REVOKED * const *b);
int i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
{
int v1=0;
long l=0;
- int (*old_cmp)(X509_REVOKED **,X509_REVOKED **);
+ int (*old_cmp)(const X509_REVOKED * const *,
+ const X509_REVOKED * const *);
M_ASN1_I2D_vars(a);
old_cmp=sk_X509_REVOKED_set_cmp_func(a->revoked,X509_REVOKED_seq_cmp);
M_ASN1_INTEGER_free(a->serialNumber);
M_ASN1_UTCTIME_free(a->revocationDate);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_CRL_INFO_free(X509_CRL_INFO *a)
M_ASN1_UTCTIME_free(a->nextUpdate);
sk_X509_REVOKED_pop_free(a->revoked,X509_REVOKED_free);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_CRL_free(X509_CRL *a)
X509_CRL_INFO_free(a->crl);
X509_ALGOR_free(a->sig_alg);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
-static int X509_REVOKED_cmp(X509_REVOKED **a, X509_REVOKED **b)
+static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
+ const X509_REVOKED * const *b)
{
return(ASN1_STRING_cmp(
(ASN1_STRING *)(*a)->serialNumber,
(ASN1_STRING *)(*b)->serialNumber));
}
-static int X509_REVOKED_seq_cmp(X509_REVOKED **a, X509_REVOKED **b)
+static int X509_REVOKED_seq_cmp(const X509_REVOKED * const *a,
+ const X509_REVOKED * const *b)
{
return((*a)->sequence-(*b)->sequence);
}
if (a == NULL) return;
ASN1_OBJECT_free(a->object);
M_ASN1_OCTET_STRING_free(a->value);
- Free(a);
+ OPENSSL_free(a);
}
{
X509_INFO *ret=NULL;
- ret=(X509_INFO *)Malloc(sizeof(X509_INFO));
+ ret=(X509_INFO *)OPENSSL_malloc(sizeof(X509_INFO));
if (ret == NULL)
{
ASN1err(ASN1_F_X509_INFO_NEW,ERR_R_MALLOC_FAILURE);
if (x->x509 != NULL) X509_free(x->x509);
if (x->crl != NULL) X509_CRL_free(x->crl);
if (x->x_pkey != NULL) X509_PKEY_free(x->x_pkey);
- if (x->enc_data != NULL) Free(x->enc_data);
- Free(x);
+ if (x->enc_data != NULL) OPENSSL_free(x->enc_data);
+ OPENSSL_free(x);
}
IMPLEMENT_STACK_OF(X509_INFO)
ASN1_CTX c;
M_ASN1_New_Malloc(ret,X509_NAME);
- if ((ret->entries=sk_X509_NAME_ENTRY_new(NULL)) == NULL)
+ if ((ret->entries=sk_X509_NAME_ENTRY_new_null()) == NULL)
{ c.line=__LINE__; goto err2; }
M_ASN1_New(ret->bytes,BUF_MEM_new);
ret->modified=1;
BUF_MEM_free(a->bytes);
sk_X509_NAME_ENTRY_pop_free(a->entries,X509_NAME_ENTRY_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
if (a == NULL) return;
ASN1_OBJECT_free(a->object);
M_ASN1_BIT_STRING_free(a->value);
- Free(a);
+ OPENSSL_free(a);
}
int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
if (x->enc_algor != NULL) X509_ALGOR_free(x->enc_algor);
if (x->enc_pkey != NULL) M_ASN1_OCTET_STRING_free(x->enc_pkey);
if (x->dec_pkey != NULL)EVP_PKEY_free(x->dec_pkey);
- if ((x->key_data != NULL) && (x->key_free)) Free(x->key_data);
- Free(x);
+ if ((x->key_data != NULL) && (x->key_free)) OPENSSL_free(x->key_data);
+ OPENSSL_free(x);
}
X509_ALGOR_free(a->algor);
M_ASN1_BIT_STRING_free(a->public_key);
if (a->pkey != NULL) EVP_PKEY_free(a->pkey);
- Free(a);
+ OPENSSL_free(a);
}
int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
dsa->write_params=0;
ASN1_TYPE_free(a->parameter);
i=i2d_DSAparams(dsa,NULL);
- p=(unsigned char *)Malloc(i);
+ p=(unsigned char *)OPENSSL_malloc(i);
pp=p;
i2d_DSAparams(dsa,&pp);
a->parameter=ASN1_TYPE_new();
a->parameter->type=V_ASN1_SEQUENCE;
a->parameter->value.sequence=ASN1_STRING_new();
ASN1_STRING_set(a->parameter->value.sequence,p,i);
- Free(p);
+ OPENSSL_free(p);
}
else
#endif
}
if ((i=i2d_PublicKey(pkey,NULL)) <= 0) goto err;
- if ((s=(unsigned char *)Malloc(i+1)) == NULL) goto err;
+ if ((s=(unsigned char *)OPENSSL_malloc(i+1)) == NULL) goto err;
p=s;
i2d_PublicKey(pkey,&p);
if (!M_ASN1_BIT_STRING_set(pk->public_key,s,i)) goto err;
pk->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
pk->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
- Free(s);
+ OPENSSL_free(s);
#if 0
CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
X509_NAME_free(a->subject);
X509_PUBKEY_free(a->pubkey);
sk_X509_ATTRIBUTE_pop_free(a->attributes,X509_ATTRIBUTE_free);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_X509_REQ(X509_REQ *a, unsigned char **pp)
X509_REQ_INFO_free(a->req_info);
X509_ALGOR_free(a->sig_alg);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_ALGOR_free(a->algor);
M_ASN1_OCTET_STRING_free(a->digest);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_PUBKEY_free(a->pubkey);
M_ASN1_IA5STRING_free(a->challenge);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **pp)
NETSCAPE_SPKAC_free(a->spkac);
X509_ALGOR_free(a->sig_algor);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
M_ASN1_TIME_free(a->notBefore);
M_ASN1_TIME_free(a->notAfter);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_D2I_get(ret->cert_info,d2i_X509_CINF);
M_ASN1_D2I_get(ret->sig_alg,d2i_X509_ALGOR);
M_ASN1_D2I_get(ret->signature,d2i_ASN1_BIT_STRING);
- if (ret->name != NULL) Free(ret->name);
+ if (ret->name != NULL) OPENSSL_free(ret->name);
ret->name=X509_NAME_oneline(ret->cert_info->subject,NULL,0);
M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
M_ASN1_BIT_STRING_free(a->signature);
X509_CERT_AUX_free(a->aux);
- if (a->name != NULL) Free(a->name);
- Free(a);
+ if (a->name != NULL) OPENSSL_free(a->name);
+ OPENSSL_free(a);
}
int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
ASN1_UTF8STRING_free(a->alias);
ASN1_OCTET_STRING_free(a->keyid);
sk_X509_ALGOR_pop_free(a->other, X509_ALGOR_free);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **pp)
{
BF_set_key(&key,n,key_test);
BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
- if (memcmp(out,&(key_out[n-1][0]),8) != 0)
+ /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
+ if (memcmp(out,&(key_out[i=n-1][0]),8) != 0)
{
printf("blowfish setkey error\n");
err=1;
if (*buffer == NULL) {
if (*maxlen == 0)
*maxlen = 1024;
- *buffer = Malloc(*maxlen);
+ *buffer = OPENSSL_malloc(*maxlen);
}
while (*currlen >= *maxlen) {
*maxlen += 1024;
- *buffer = Realloc(*buffer, *maxlen);
+ *buffer = OPENSSL_realloc(*buffer, *maxlen);
}
/* What to do if *buffer is NULL? */
assert(*buffer != NULL);
ret=BIO_write(bio, hugebuf, (int)retlen);
#ifdef USE_ALLOCATING_PRINT
- Free(hugebuf);
+ OPENSSL_free(hugebuf);
}
CRYPTO_pop_info();
#endif
int i,j;
MemCheck_off();
- ret=(struct hostent *)Malloc(sizeof(struct hostent));
+ ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
if (ret == NULL) return(NULL);
memset(ret,0,sizeof(struct hostent));
for (i=0; a->h_aliases[i] != NULL; i++)
;
i++;
- ret->h_aliases = (char **)Malloc(i*sizeof(char *));
+ ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
if (ret->h_aliases == NULL)
goto err;
memset(ret->h_aliases, 0, i*sizeof(char *));
for (i=0; a->h_addr_list[i] != NULL; i++)
;
i++;
- ret->h_addr_list=(char **)Malloc(i*sizeof(char *));
+ ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));
if (ret->h_addr_list == NULL)
goto err;
memset(ret->h_addr_list, 0, i*sizeof(char *));
j=strlen(a->h_name)+1;
- if ((ret->h_name=Malloc(j)) == NULL) goto err;
+ if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;
memcpy((char *)ret->h_name,a->h_name,j);
for (i=0; a->h_aliases[i] != NULL; i++)
{
j=strlen(a->h_aliases[i])+1;
- if ((ret->h_aliases[i]=Malloc(j)) == NULL) goto err;
+ if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;
memcpy(ret->h_aliases[i],a->h_aliases[i],j);
}
ret->h_length=a->h_length;
ret->h_addrtype=a->h_addrtype;
for (i=0; a->h_addr_list[i] != NULL; i++)
{
- if ((ret->h_addr_list[i]=Malloc(a->h_length)) == NULL)
+ if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
goto err;
memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
}
if (a->h_aliases != NULL)
{
for (i=0; a->h_aliases[i] != NULL; i++)
- Free(a->h_aliases[i]);
- Free(a->h_aliases);
+ OPENSSL_free(a->h_aliases[i]);
+ OPENSSL_free(a->h_aliases);
}
if (a->h_addr_list != NULL)
{
for (i=0; a->h_addr_list[i] != NULL; i++)
- Free(a->h_addr_list[i]);
- Free(a->h_addr_list);
+ OPENSSL_free(a->h_addr_list[i]);
+ OPENSSL_free(a->h_addr_list);
}
- if (a->h_name != NULL) Free(a->h_name);
- Free(a);
+ if (a->h_name != NULL) OPENSSL_free(a->h_name);
+ OPENSSL_free(a);
}
struct hostent *BIO_gethostbyname(const char *name)
}
ret=1;
err:
- if (str != NULL) Free(str);
+ if (str != NULL) OPENSSL_free(str);
if ((ret == 0) && (s != INVALID_SOCKET))
{
closesocket(s);
port=ntohs(from.sin_port);
if (*addr == NULL)
{
- if ((p=Malloc(24)) == NULL)
+ if ((p=OPENSSL_malloc(24)) == NULL)
{
BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
goto end;
{
BIO_F_BUFFER_CTX *ctx;
- ctx=(BIO_F_BUFFER_CTX *)Malloc(sizeof(BIO_F_BUFFER_CTX));
+ ctx=(BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX));
if (ctx == NULL) return(0);
- ctx->ibuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
- if (ctx->ibuf == NULL) { Free(ctx); return(0); }
- ctx->obuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
- if (ctx->obuf == NULL) { Free(ctx->ibuf); Free(ctx); return(0); }
+ ctx->ibuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->ibuf == NULL) { OPENSSL_free(ctx); return(0); }
+ ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->obuf == NULL) { OPENSSL_free(ctx->ibuf); OPENSSL_free(ctx); return(0); }
ctx->ibuf_size=DEFAULT_BUFFER_SIZE;
ctx->obuf_size=DEFAULT_BUFFER_SIZE;
ctx->ibuf_len=0;
if (a == NULL) return(0);
b=(BIO_F_BUFFER_CTX *)a->ptr;
- if (b->ibuf != NULL) Free(b->ibuf);
- if (b->obuf != NULL) Free(b->obuf);
- Free(a->ptr);
+ if (b->ibuf != NULL) OPENSSL_free(b->ibuf);
+ if (b->obuf != NULL) OPENSSL_free(b->obuf);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
case BIO_C_SET_BUFF_READ_DATA:
if (num > ctx->ibuf_size)
{
- p1=Malloc((int)num);
+ p1=OPENSSL_malloc((int)num);
if (p1 == NULL) goto malloc_error;
- if (ctx->ibuf != NULL) Free(ctx->ibuf);
+ if (ctx->ibuf != NULL) OPENSSL_free(ctx->ibuf);
ctx->ibuf=p1;
}
ctx->ibuf_off=0;
p2=ctx->obuf;
if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size))
{
- p1=(char *)Malloc((int)num);
+ p1=(char *)OPENSSL_malloc((int)num);
if (p1 == NULL) goto malloc_error;
}
if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size))
{
- p2=(char *)Malloc((int)num);
+ p2=(char *)OPENSSL_malloc((int)num);
if (p2 == NULL)
{
- if (p1 != ctx->ibuf) Free(p1);
+ if (p1 != ctx->ibuf) OPENSSL_free(p1);
goto malloc_error;
}
}
if (ctx->ibuf != p1)
{
- Free(ctx->ibuf);
+ OPENSSL_free(ctx->ibuf);
ctx->ibuf=p1;
ctx->ibuf_off=0;
ctx->ibuf_len=0;
}
if (ctx->obuf != p2)
{
- Free(ctx->obuf);
+ OPENSSL_free(ctx->obuf);
ctx->obuf=p2;
ctx->obuf_off=0;
ctx->obuf_len=0;
{
NBIO_TEST *nt;
- nt=(NBIO_TEST *)Malloc(sizeof(NBIO_TEST));
+ nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST));
nt->lrn= -1;
nt->lwn= -1;
bi->ptr=(char *)nt;
{
if (a == NULL) return(0);
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
#ifndef HEADER_BIO_H
#define HEADER_BIO_H
-#include <stdio.h>
-#include <stdlib.h>
+#ifndef NO_FP_API
+# include <stdio.h>
+#endif
+
#include <openssl/crypto.h>
#ifdef __cplusplus
};
DECLARE_STACK_OF(BIO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_BIO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_BIO_new_null() sk_new_null()
+ #define sk_BIO_free(a) sk_free(a)
+ #define sk_BIO_num(a) sk_num(a)
+ #define sk_BIO_value(a,b) ((BIO *) \
+ sk_value((a),(b)))
+ #define sk_BIO_set(a,b,c) ((BIO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_BIO_zero(a) sk_zero(a)
+ #define sk_BIO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_BIO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_BIO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_BIO_delete(a,b) ((BIO *) \
+ sk_delete((a),(b)))
+ #define sk_BIO_delete_ptr(a,b) ((BIO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_BIO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_BIO_set_cmp_func(a,b) ((int (*) \
+ (const BIO * const *,const BIO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_BIO_dup(a) sk_dup(a)
+ #define sk_BIO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_BIO_shift(a) ((BIO *)sk_shift(a))
+ #define sk_BIO_pop(a) ((BIO *)sk_pop(a))
+ #define sk_BIO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
typedef struct bio_f_buffer_ctx_struct
{
size_t BIO_ctrl_get_read_request(BIO *b);
int BIO_ctrl_reset_read_request(BIO *b);
-#ifdef NO_STDIO
-#define NO_FP_API
-#endif
-
-
/* These two aren't currently implemented */
/* int BIO_get_ex_num(BIO *bio); */
/* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */
unsigned long BIO_number_read(BIO *bio);
unsigned long BIO_number_written(BIO *bio);
+# ifndef NO_FP_API
# if defined(WIN16) && defined(_WINDLL)
BIO_METHOD *BIO_s_file_internal(void);
BIO *BIO_new_file_internal(char *filename, char *mode);
# define BIO_new_file_internal BIO_new_file
# define BIO_new_fp_internal BIO_s_file
# endif /* FP_API */
+# endif
BIO * BIO_new(BIO_METHOD *type);
int BIO_set(BIO *a,BIO_METHOD *type);
int BIO_free(BIO *a);
{
BIO *ret=NULL;
- ret=(BIO *)Malloc(sizeof(BIO));
+ ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
if (ret == NULL)
{
BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
}
if (!BIO_set(ret,method))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
return(ret);
if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
ret=a->method->destroy(a);
- Free(a);
+ OPENSSL_free(a);
return(1);
}
{
BIO_ACCEPT *ret;
- if ((ret=(BIO_ACCEPT *)Malloc(sizeof(BIO_ACCEPT))) == NULL)
+ if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL)
return(NULL);
memset(ret,0,sizeof(BIO_ACCEPT));
if(a == NULL)
return;
- if (a->param_addr != NULL) Free(a->param_addr);
- if (a->addr != NULL) Free(a->addr);
+ if (a->param_addr != NULL) OPENSSL_free(a->param_addr);
+ if (a->addr != NULL) OPENSSL_free(a->addr);
if (a->bio_chain != NULL) BIO_free(a->bio_chain);
- Free(a);
+ OPENSSL_free(a);
}
static void acpt_close_socket(BIO *bio)
{
b->init=1;
if (data->param_addr != NULL)
- Free(data->param_addr);
+ OPENSSL_free(data->param_addr);
data->param_addr=BUF_strdup(ptr);
}
else if (num == 1)
{
struct bio_bio_st *b;
- b = Malloc(sizeof *b);
+ b = OPENSSL_malloc(sizeof *b);
if (b == NULL)
return 0;
if (b->buf != NULL)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
}
- Free(b);
+ OPENSSL_free(b);
return 1;
}
{
if (b->buf)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
b->buf = NULL;
}
b->size = new_size;
if (b1->buf == NULL)
{
- b1->buf = Malloc(b1->size);
+ b1->buf = OPENSSL_malloc(b1->size);
if (b1->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
if (b2->buf == NULL)
{
- b2->buf = Malloc(b2->size);
+ b2->buf = OPENSSL_malloc(b2->size);
if (b2->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
break;
}
if (c->param_port != NULL)
- Free(c->param_port);
+ OPENSSL_free(c->param_port);
c->param_port=BUF_strdup(p);
}
}
{
BIO_CONNECT *ret;
- if ((ret=(BIO_CONNECT *)Malloc(sizeof(BIO_CONNECT))) == NULL)
+ if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL)
return(NULL);
ret->state=BIO_CONN_S_BEFORE;
ret->param_hostname=NULL;
return;
if (a->param_hostname != NULL)
- Free(a->param_hostname);
+ OPENSSL_free(a->param_hostname);
if (a->param_port != NULL)
- Free(a->param_port);
- Free(a);
+ OPENSSL_free(a->param_port);
+ OPENSSL_free(a);
}
BIO_METHOD *BIO_s_connect(void)
if (num == 0)
{
if (data->param_hostname != NULL)
- Free(data->param_hostname);
+ OPENSSL_free(data->param_hostname);
data->param_hostname=BUF_strdup(ptr);
}
else if (num == 1)
{
if (data->param_port != NULL)
- Free(data->param_port);
+ OPENSSL_free(data->param_port);
data->param_port=BUF_strdup(ptr);
}
else if (num == 2)
sprintf(buf,"%d.%d.%d.%d",
p[0],p[1],p[2],p[3]);
if (data->param_hostname != NULL)
- Free(data->param_hostname);
+ OPENSSL_free(data->param_hostname);
data->param_hostname=BUF_strdup(buf);
memcpy(&(data->ip[0]),ptr,4);
}
sprintf(buf,"%d",*(int *)ptr);
if (data->param_port != NULL)
- Free(data->param_port);
+ OPENSSL_free(data->param_port);
data->param_port=BUF_strdup(buf);
data->port= *(int *)ptr;
}
char* pp;
int priority;
- if((buf= (char *)Malloc(inl+ 1)) == NULL){
+ if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
return(0);
}
strncpy(buf, in, inl);
xsyslog(b, priority, pp);
- Free(buf);
+ OPENSSL_free(buf);
return(ret);
}
lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
/* we know there's an 8 byte header. That's documented */
- opcdef_p = (struct opcdef *) Malloc(8 + len);
+ opcdef_p = (struct opcdef *) OPENSSL_malloc(8 + len);
opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
opcdef_p->opc$l_ms_rqstid = 0;
sys$sndopr(opc_dsc, 0);
- Free(opcdef_p);
+ OPENSSL_free(opcdef_p);
}
static void xcloselog(BIO* bp)
bi->init=1;
bi->num=0;
bi->flags = 0;
- bi->ptr=Malloc(sizeof(struct rpc_ctx));
+ bi->ptr=OPENSSL_malloc(sizeof(struct rpc_ctx));
ctx = (struct rpc_ctx *) bi->ptr;
ctx->filled = 0;
ctx->pos = 0;
static int rtcp_free(BIO *a)
{
if (a == NULL) return(0);
- if ( a->ptr ) Free ( a->ptr );
+ if ( a->ptr ) OPENSSL_free ( a->ptr );
a->ptr = NULL;
return(1);
}
#ifndef HEADER_BN_H
#define HEADER_BN_H
-#ifndef WIN16
+#ifndef NO_FP_API
#include <stdio.h> /* FILE */
#endif
#include <openssl/opensslconf.h>
const BIGNUM *m,BN_CTX *ctx);
int BN_mod_exp_mont(BIGNUM *r, BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
int BN_mod_exp2_mont(BIGNUM *r, BIGNUM *a1, BIGNUM *p1,BIGNUM *a2,
BIGNUM *p2,BIGNUM *m,BN_CTX *ctx,BN_MONT_CTX *m_ctx);
int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p,
#define BN_F_BN_DIV 107
#define BN_F_BN_EXPAND2 108
#define BN_F_BN_MOD_EXP_MONT 109
+#define BN_F_BN_MOD_EXP_MONT_WORD 117
#define BN_F_BN_MOD_INVERSE 110
#define BN_F_BN_MOD_MUL_RECIPROCAL 111
#define BN_F_BN_MPI2BN 112
bn_check_top(Ai);
bn_check_top(mod);
- if ((ret=(BN_BLINDING *)Malloc(sizeof(BN_BLINDING))) == NULL)
+ if ((ret=(BN_BLINDING *)OPENSSL_malloc(sizeof(BN_BLINDING))) == NULL)
{
BNerr(BN_F_BN_BLINDING_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
if (r->A != NULL) BN_free(r->A );
if (r->Ai != NULL) BN_free(r->Ai);
- Free(r);
+ OPENSSL_free(r);
}
int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
{
BN_CTX *ret;
- ret=(BN_CTX *)Malloc(sizeof(BN_CTX));
+ ret=(BN_CTX *)OPENSSL_malloc(sizeof(BN_CTX));
if (ret == NULL)
{
BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
for (i=0; i < BN_CTX_NUM; i++)
BN_clear_free(&(ctx->bn[i]));
if (ctx->flags & BN_FLG_MALLOCED)
- Free(ctx);
+ OPENSSL_free(ctx);
}
void BN_CTX_start(BN_CTX *ctx)
{ERR_PACK(0,BN_F_BN_DIV,0), "BN_div"},
{ERR_PACK(0,BN_F_BN_EXPAND2,0), "bn_expand2"},
{ERR_PACK(0,BN_F_BN_MOD_EXP_MONT,0), "BN_mod_exp_mont"},
+{ERR_PACK(0,BN_F_BN_MOD_EXP_MONT_WORD,0), "BN_MOD_EXP_MONT_WORD"},
{ERR_PACK(0,BN_F_BN_MOD_INVERSE,0), "BN_mod_inverse"},
{ERR_PACK(0,BN_F_BN_MOD_MUL_RECIPROCAL,0), "BN_mod_mul_reciprocal"},
{ERR_PACK(0,BN_F_BN_MPI2BN,0), "BN_mpi2bn"},
# include <dlfcn.h>
#endif
+
#define TABLE_SIZE 16
/* slow but works */
return(r);
}
-#if 0
-/* this one works - simple but works */
-int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
- {
- int i,bits,ret=0;
- BIGNUM *v,*tmp;
-
- BN_CTX_start(ctx);
- v = BN_CTX_get(ctx);
- tmp = BN_CTX_get(ctx);
- if (v == NULL || tmp == NULL) goto err;
-
- if (BN_copy(v,a) == NULL) goto err;
- bits=BN_num_bits(p);
-
- if (BN_is_odd(p))
- { if (BN_copy(r,a) == NULL) goto err; }
- else { if (!BN_one(r)) goto err; }
-
- for (i=1; i<bits; i++)
- {
- if (!BN_sqr(tmp,v,ctx)) goto err;
- if (!BN_mod(v,tmp,m,ctx)) goto err;
- if (BN_is_bit_set(p,i))
- {
- if (!BN_mul(tmp,r,v,ctx)) goto err;
- if (!BN_mod(r,tmp,m,ctx)) goto err;
- }
- }
- ret=1;
-err:
- BN_CTX_end(ctx);
- return(ret);
- }
-
-#endif
/* this one works - simple but works */
int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
return(ret);
}
+
#ifdef ATALLA
/*
}
#endif /* def ATALLA */
+
int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
BN_CTX *ctx)
{
/* if ((m->d[m->top-1]&BN_TBIT) && BN_is_odd(m)) */
if (BN_is_odd(m))
- { ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL); }
+ {
+ if (a->top == 1)
+ {
+ BN_ULONG A = a->d[0];
+ ret=BN_mod_exp_mont_word(r,A,p,m,ctx,NULL);
+ }
+ else
+ ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL);
+ }
else
#endif
#ifdef RECP_MUL_MOD
return(ret);
}
-/* #ifdef RECP_MUL_MOD */
+
int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx)
{
BN_RECP_CTX_free(&recp);
return(ret);
}
-/* #endif */
-/* #ifdef MONT_MUL_MOD */
+
int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
{
/* If this is not done, things will break in the montgomery
* part */
-#if 1
if (in_mont != NULL)
mont=in_mont;
else
-#endif
{
if ((mont=BN_MONT_CTX_new()) == NULL) goto err;
if (!BN_MONT_CTX_set(mont,m,ctx)) goto err;
ts=1;
if (BN_ucmp(a,m) >= 0)
{
- BN_mod(&(val[0]),a,m,ctx);
+ if (!BN_mod(&(val[0]),a,m,ctx))
+ goto err;
aa= &(val[0]);
}
else
wstart=bits-1; /* The top bit of the window */
wend=0; /* The bottom bit of the window */
- if (!BN_to_montgomery(r,BN_value_one(),mont,ctx)) goto err;
+ if (!BN_to_montgomery(r,BN_value_one(),mont,ctx)) goto err;
for (;;)
{
if (BN_is_bit_set(p,wstart) == 0)
BN_clear_free(&(val[i]));
return(ret);
}
-/* #endif */
+
+int BN_mod_exp_mont_word(BIGNUM *rr, BN_ULONG a, const BIGNUM *p,
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
+/* if we had BN_mod_exp_mont_2, we could even use windowing in it */
+ {
+ int b, bits, ret=0;
+ BIGNUM *d, *r, *t;
+ BN_MONT_CTX *mont = NULL;
+
+ bn_check_top(p);
+ bn_check_top(m);
+
+ if (!(m->d[0] & 1))
+ {
+ BNerr(BN_F_BN_MOD_EXP_MONT_WORD,BN_R_CALLED_WITH_EVEN_MODULUS);
+ return(0);
+ }
+ bits = BN_num_bits(p);
+ if (bits == 0)
+ {
+ BN_one(rr);
+ return(1);
+ }
+ BN_CTX_start(ctx);
+ d = BN_CTX_get(ctx);
+ r = BN_CTX_get(ctx);
+ t = BN_CTX_get(ctx);
+ if (d == NULL || r == NULL || t == NULL) goto err;
+
+#ifdef ATALLA
+ if (!tried_atalla)
+ {
+ BN_set_word(t, a);
+ if (BN_mod_exp_word_atalla(rr, t, p, m))
+ return 1;
+ }
+/* If it fails, try the other methods */
+#endif
+
+ if (in_mont != NULL)
+ mont=in_mont;
+ else
+ {
+ if ((mont = BN_MONT_CTX_new()) == NULL) goto err;
+ if (!BN_MONT_CTX_set(mont, m, ctx)) goto err;
+ }
+
+ if (!BN_to_montgomery(r, BN_value_one(), mont, ctx)) goto err;
+ for (b = bits-1; b >= 0; b--)
+ {
+ if (BN_is_bit_set(p, b))
+ {
+ if (!BN_mul_word(r, a))
+ goto err;
+ if (BN_ucmp(r, m) >= 0)
+ {
+ if (!BN_mod(t, r, m, ctx))
+ goto err;
+ { BIGNUM *swap_tmp = r; r = t; t = swap_tmp; }
+ }
+ }
+
+ if (b > 0)
+ {
+ if (!BN_mod_mul_montgomery(r, r, r, mont, ctx))
+ goto err;
+ }
+ }
+ BN_from_montgomery(rr, r, mont, ctx);
+ ret = 1;
+err:
+ if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
+ BN_CTX_end(ctx);
+ return(ret);
+ }
+
/* The old fallback, simple version :-) */
int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
{
memset(a->d,0,a->max*sizeof(a->d[0]));
if (!(BN_get_flags(a,BN_FLG_STATIC_DATA)))
- Free(a->d);
+ OPENSSL_free(a->d);
}
i=BN_get_flags(a,BN_FLG_MALLOCED);
memset(a,0,sizeof(BIGNUM));
if (i)
- Free(a);
+ OPENSSL_free(a);
}
void BN_free(BIGNUM *a)
{
if (a == NULL) return;
if ((a->d != NULL) && !(BN_get_flags(a,BN_FLG_STATIC_DATA)))
- Free(a->d);
+ OPENSSL_free(a->d);
a->flags|=BN_FLG_FREE; /* REMOVE? */
if (a->flags & BN_FLG_MALLOCED)
- Free(a);
+ OPENSSL_free(a);
}
void BN_init(BIGNUM *a)
{
BIGNUM *ret;
- if ((ret=(BIGNUM *)Malloc(sizeof(BIGNUM))) == NULL)
+ if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
{
BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
BNerr(BN_F_BN_EXPAND2,BN_R_EXPAND_ON_STATIC_BIGNUM_DATA);
return(NULL);
}
- a=A=(BN_ULONG *)Malloc(sizeof(BN_ULONG)*(words+1));
+ a=A=(BN_ULONG *)OPENSSL_malloc(sizeof(BN_ULONG)*(words+1));
if (A == NULL)
{
BNerr(BN_F_BN_EXPAND2,ERR_R_MALLOC_FAILURE);
case 0: ; /* ultrix cc workaround, see above */
}
#endif
- Free(b->d);
+ OPENSSL_free(b->d);
}
b->d=a;
{
BN_MONT_CTX *ret;
- if ((ret=(BN_MONT_CTX *)Malloc(sizeof(BN_MONT_CTX))) == NULL)
+ if ((ret=(BN_MONT_CTX *)OPENSSL_malloc(sizeof(BN_MONT_CTX))) == NULL)
return(NULL);
BN_MONT_CTX_init(ret);
BN_free(&(mont->N));
BN_free(&(mont->Ni));
if (mont->flags & BN_FLG_MALLOCED)
- Free(mont);
+ OPENSSL_free(mont);
}
int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
static const char *Hex="0123456789ABCDEF";
-/* Must 'Free' the returned data */
+/* Must 'OPENSSL_free' the returned data */
char *BN_bn2hex(const BIGNUM *a)
{
int i,j,v,z=0;
char *buf;
char *p;
- buf=(char *)Malloc(a->top*BN_BYTES*2+2);
+ buf=(char *)OPENSSL_malloc(a->top*BN_BYTES*2+2);
if (buf == NULL)
{
BNerr(BN_F_BN_BN2HEX,ERR_R_MALLOC_FAILURE);
return(buf);
}
-/* Must 'Free' the returned data */
+/* Must 'OPENSSL_free' the returned data */
char *BN_bn2dec(const BIGNUM *a)
{
int i=0,num;
i=BN_num_bits(a)*3;
num=(i/10+i/1000+3)+1;
- bn_data=(BN_ULONG *)Malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
- buf=(char *)Malloc(num+3);
+ bn_data=(BN_ULONG *)OPENSSL_malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
+ buf=(char *)OPENSSL_malloc(num+3);
if ((buf == NULL) || (bn_data == NULL))
{
BNerr(BN_F_BN_BN2DEC,ERR_R_MALLOC_FAILURE);
}
}
err:
- if (bn_data != NULL) Free(bn_data);
+ if (bn_data != NULL) OPENSSL_free(bn_data);
if (t != NULL) BN_free(t);
return(buf);
}
bit=(bits-1)%8;
mask=0xff<<bit;
- buf=(unsigned char *)Malloc(bytes);
+ buf=(unsigned char *)OPENSSL_malloc(bytes);
if (buf == NULL)
{
BNerr(BN_F_BN_RAND,ERR_R_MALLOC_FAILURE);
if (buf != NULL)
{
memset(buf,0,bytes);
- Free(buf);
+ OPENSSL_free(buf);
}
return(ret);
}
{
BN_RECP_CTX *ret;
- if ((ret=(BN_RECP_CTX *)Malloc(sizeof(BN_RECP_CTX))) == NULL)
+ if ((ret=(BN_RECP_CTX *)OPENSSL_malloc(sizeof(BN_RECP_CTX))) == NULL)
return(NULL);
BN_RECP_CTX_init(ret);
BN_free(&(recp->N));
BN_free(&(recp->Nr));
if (recp->flags & BN_FLG_MALLOCED)
- Free(recp);
+ OPENSSL_free(recp);
}
int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *d, BN_CTX *ctx)
{
BUF_MEM *ret;
- ret=Malloc(sizeof(BUF_MEM));
+ ret=OPENSSL_malloc(sizeof(BUF_MEM));
if (ret == NULL)
{
BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
if (a->data != NULL)
{
memset(a->data,0,(unsigned int)a->max);
- Free(a->data);
+ OPENSSL_free(a->data);
}
- Free(a);
+ OPENSSL_free(a);
}
int BUF_MEM_grow(BUF_MEM *str, int len)
}
n=(len+3)/3*4;
if (str->data == NULL)
- ret=Malloc(n);
+ ret=OPENSSL_malloc(n);
else
- ret=Realloc(str->data,n);
+ ret=OPENSSL_realloc(str->data,n);
if (ret == NULL)
{
BUFerr(BUF_F_BUF_MEM_GROW,ERR_R_MALLOC_FAILURE);
if (str == NULL) return(NULL);
n=strlen(str);
- ret=Malloc(n+1);
+ ret=OPENSSL_malloc(n+1);
if (ret == NULL)
{
BUFerr(BUF_F_BUF_STRDUP,ERR_R_MALLOC_FAILURE);
#define S6 CAST_S_table6
#define S7 CAST_S_table7
-void CAST_set_key(CAST_KEY *key, int len, unsigned char *data)
+void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data)
{
CAST_LONG x[16];
CAST_LONG z[16];
} CAST_KEY;
-void CAST_set_key(CAST_KEY *key, int len, unsigned char *data);
+void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data);
void CAST_ecb_encrypt(const unsigned char *in,unsigned char *out,CAST_KEY *key,
int enc);
void CAST_encrypt(CAST_LONG *data,CAST_KEY *key);
{
COMP_CTX *ret;
- if ((ret=(COMP_CTX *)Malloc(sizeof(COMP_CTX))) == NULL)
+ if ((ret=(COMP_CTX *)OPENSSL_malloc(sizeof(COMP_CTX))) == NULL)
{
/* ZZZZZZZZZZZZZZZZ */
return(NULL);
ret->meth=meth;
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
#if 0
if (ctx->meth->finish != NULL)
ctx->meth->finish(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
} CONF_VALUE;
DECLARE_STACK_OF(CONF_VALUE)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_CONF_VALUE_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_CONF_VALUE_new_null() sk_new_null()
+ #define sk_CONF_VALUE_free(a) sk_free(a)
+ #define sk_CONF_VALUE_num(a) sk_num(a)
+ #define sk_CONF_VALUE_value(a,b) ((CONF_VALUE *) \
+ sk_value((a),(b)))
+ #define sk_CONF_VALUE_set(a,b,c) ((CONF_VALUE *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_CONF_VALUE_zero(a) sk_zero(a)
+ #define sk_CONF_VALUE_push(a,b) sk_push((a),(char *)(b))
+ #define sk_CONF_VALUE_unshift(a,b) sk_unshift((a),(b))
+ #define sk_CONF_VALUE_find(a,b) sk_find((a), (char *)(b))
+ #define sk_CONF_VALUE_delete(a,b) ((CONF_VALUE *) \
+ sk_delete((a),(b)))
+ #define sk_CONF_VALUE_delete_ptr(a,b) ((CONF_VALUE *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_CONF_VALUE_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_CONF_VALUE_set_cmp_func(a,b) ((int (*) \
+ (const CONF_VALUE * const *,const CONF_VALUE * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_CONF_VALUE_dup(a) sk_dup(a)
+ #define sk_CONF_VALUE_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_CONF_VALUE_shift(a) ((CONF_VALUE *)sk_shift(a))
+ #define sk_CONF_VALUE_pop(a) ((CONF_VALUE *)sk_pop(a))
+ #define sk_CONF_VALUE_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
struct conf_st;
typedef struct conf_st CONF;
if (v != NULL)
{
sk_CONF_VALUE_delete_ptr(ts,v);
- Free(v->name);
- Free(v->value);
- Free(v);
+ OPENSSL_free(v->name);
+ OPENSSL_free(v->value);
+ OPENSSL_free(v);
}
return 1;
}
{
if (conf == NULL || conf->data == NULL) return;
- conf->data->down_load=0; /* evil thing to make sure the 'Free()'
+ conf->data->down_load=0; /* evil thing to make sure the 'OPENSSL_free()'
* works as expected */
lh_doall_arg(conf->data,(void (*)())value_free_hash,conf->data);
for (i=sk_num(sk)-1; i>=0; i--)
{
vv=(CONF_VALUE *)sk_value(sk,i);
- Free(vv->value);
- Free(vv->name);
- Free(vv);
+ OPENSSL_free(vv->value);
+ OPENSSL_free(vv->name);
+ OPENSSL_free(vv);
}
if (sk != NULL) sk_free(sk);
- Free(a->section);
- Free(a);
+ OPENSSL_free(a->section);
+ OPENSSL_free(a);
}
static unsigned long hash(CONF_VALUE *v)
if ((sk=sk_new_null()) == NULL)
goto err;
- if ((v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))) == NULL)
+ if ((v=(CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))) == NULL)
goto err;
i=strlen(section)+1;
- if ((v->section=(char *)Malloc(i)) == NULL)
+ if ((v->section=(char *)OPENSSL_malloc(i)) == NULL)
goto err;
memcpy(v->section,section,i);
if (!ok)
{
if (sk != NULL) sk_free(sk);
- if (v != NULL) Free(v);
+ if (v != NULL) OPENSSL_free(v);
v=NULL;
}
return(v);
/* Part of the code in here was originally in conf.c, which is now removed */
#include <stdio.h>
+#include <string.h>
#include <openssl/stack.h>
#include <openssl/lhash.h>
#include <openssl/conf.h>
static int str_copy(CONF *conf,char *section,char **to, char *from);
static char *scan_quote(CONF *conf, char *p);
static char *scan_dquote(CONF *conf, char *p);
-#define scan_esc(p) (((IS_EOF((conf),(p)[1]))?(p+=1):(p+=2)))
+#define scan_esc(conf,p) (((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2)))
static CONF *def_create(CONF_METHOD *meth);
static int def_init_default(CONF *conf);
{
CONF *ret;
- ret = (CONF *)Malloc(sizeof(CONF) + sizeof(unsigned short *));
+ ret = (CONF *)OPENSSL_malloc(sizeof(CONF) + sizeof(unsigned short *));
if (ret)
if (meth->init(ret) == 0)
{
- Free(ret);
+ OPENSSL_free(ret);
ret = NULL;
}
return ret;
{
if (def_destroy_data(conf))
{
- Free(conf);
+ OPENSSL_free(conf);
return 1;
}
return 0;
goto err;
}
- section=(char *)Malloc(10);
+ section=(char *)OPENSSL_malloc(10);
if (section == NULL)
{
CONFerr(CONF_F_CONF_LOAD_BIO,ERR_R_MALLOC_FAILURE);
p++;
*p='\0';
- if (!(v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))))
+ if (!(v=(CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))))
{
CONFerr(CONF_F_CONF_LOAD_BIO,
ERR_R_MALLOC_FAILURE);
goto err;
}
if (psection == NULL) psection=section;
- v->name=(char *)Malloc(strlen(pname)+1);
+ v->name=(char *)OPENSSL_malloc(strlen(pname)+1);
v->value=NULL;
if (v->name == NULL)
{
if (vv != NULL)
{
sk_CONF_VALUE_delete_ptr(ts,vv);
- Free(vv->name);
- Free(vv->value);
- Free(vv);
+ OPENSSL_free(vv->name);
+ OPENSSL_free(vv->value);
+ OPENSSL_free(vv);
}
#endif
v=NULL;
}
}
if (buff != NULL) BUF_MEM_free(buff);
- if (section != NULL) Free(section);
+ if (section != NULL) OPENSSL_free(section);
return(1);
err:
if (buff != NULL) BUF_MEM_free(buff);
- if (section != NULL) Free(section);
+ if (section != NULL) OPENSSL_free(section);
if (line != NULL) *line=eline;
sprintf(btmp,"%ld",eline);
ERR_add_error_data(2,"line ",btmp);
if ((h != conf->data) && (conf->data != NULL)) CONF_free(conf->data);
if (v != NULL)
{
- if (v->name != NULL) Free(v->name);
- if (v->value != NULL) Free(v->value);
- if (v != NULL) Free(v);
+ if (v->name != NULL) OPENSSL_free(v->name);
+ if (v->value != NULL) OPENSSL_free(v->value);
+ if (v != NULL) OPENSSL_free(v);
}
return(0);
}
}
if (IS_ESC(conf,*p))
{
- p=scan_esc(p);
+ p=scan_esc(conf,p);
continue;
}
if (IS_EOF(conf,*p))
buf->data[to++]= *(from++);
}
buf->data[to]='\0';
- if (*pto != NULL) Free(*pto);
+ if (*pto != NULL) OPENSSL_free(*pto);
*pto=buf->data;
- Free(buf);
+ OPENSSL_free(buf);
return(1);
err:
if (buf != NULL) BUF_MEM_free(buf);
{
if (IS_ESC(conf,*p))
{
- p=scan_esc(p);
+ p=scan_esc(conf,p);
continue;
}
if (!IS_ALPHA_NUMERIC_PUNCT(conf,*p))
return(0);
i=sk_push(app_locks,str);
if (!i)
- Free(str);
+ OPENSSL_free(str);
else
i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
return(i);
} CRYPTO_EX_DATA_FUNCS;
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_CRYPTO_EX_DATA_FUNCS_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_CRYPTO_EX_DATA_FUNCS_new_null() sk_new_null()
+ #define sk_CRYPTO_EX_DATA_FUNCS_free(a) sk_free(a)
+ #define sk_CRYPTO_EX_DATA_FUNCS_num(a) sk_num(a)
+ #define sk_CRYPTO_EX_DATA_FUNCS_value(a,b) ((CRYPTO_EX_DATA_FUNCS *) \
+ sk_value((a),(b)))
+ #define sk_CRYPTO_EX_DATA_FUNCS_set(a,b,c) ((CRYPTO_EX_DATA_FUNCS *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_CRYPTO_EX_DATA_FUNCS_zero(a) sk_zero(a)
+ #define sk_CRYPTO_EX_DATA_FUNCS_push(a,b) sk_push((a),(char *)(b))
+ #define sk_CRYPTO_EX_DATA_FUNCS_unshift(a,b) sk_unshift((a),(b))
+ #define sk_CRYPTO_EX_DATA_FUNCS_find(a,b) sk_find((a), (char *)(b))
+ #define sk_CRYPTO_EX_DATA_FUNCS_delete(a,b) ((CRYPTO_EX_DATA_FUNCS *) \
+ sk_delete((a),(b)))
+ #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(a,b) ((CRYPTO_EX_DATA_FUNCS *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_CRYPTO_EX_DATA_FUNCS_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(a,b) ((int (*) \
+ (const CRYPTO_EX_DATA_FUNCS * const *,const CRYPTO_EX_DATA_FUNCS * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_CRYPTO_EX_DATA_FUNCS_dup(a) sk_dup(a)
+ #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_CRYPTO_EX_DATA_FUNCS_shift(a) ((CRYPTO_EX_DATA_FUNCS *)sk_shift(a))
+ #define sk_CRYPTO_EX_DATA_FUNCS_pop(a) ((CRYPTO_EX_DATA_FUNCS *)sk_pop(a))
+ #define sk_CRYPTO_EX_DATA_FUNCS_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
/* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
* entry.
#define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
#define is_MemCheck_on() CRYPTO_is_mem_check_on()
-#define Malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
-#define Realloc(addr,num) \
+#define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
+#define OPENSSL_realloc(addr,num) \
CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
-#define Remalloc(addr,num) \
+#define OPENSSL_remalloc(addr,num) \
CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
-#define FreeFunc CRYPTO_free
-#define Free(addr) CRYPTO_free(addr)
+#define OPENSSL_freeFunc CRYPTO_free
+#define OPENSSL_free(addr) CRYPTO_free(addr)
-#define Malloc_locked(num) CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
-#define Free_locked(addr) CRYPTO_free_locked(addr)
+#define OPENSSL_malloc_locked(num) \
+ CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
+#define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
/* Case insensiteve linking causes problems.... */
}
#endif
#endif
-
if (buf == NULL)
{
- if ( (( buf=Malloc(BUFSIZE+8)) == NULL) ||
- ((obuf=Malloc(BUFSIZE+8)) == NULL))
+ if ( (( buf=OPENSSL_malloc(BUFSIZE+8)) == NULL) ||
+ ((obuf=OPENSSL_malloc(BUFSIZE+8)) == NULL))
{
fputs("Not enough memory\n",stderr);
Exit=10;
#error <openssl/des.h> replaces <kerberos/des.h>.
#endif
-#include <stdio.h>
#include <openssl/opensslconf.h> /* DES_LONG */
#include <openssl/e_os2.h> /* OPENSSL_EXTERN */
if (tmpbuf == NULL)
{
- tmpbuf=Malloc(BSIZE);
+ tmpbuf=OPENSSL_malloc(BSIZE);
if (tmpbuf == NULL) return(-1);
}
if (net == NULL)
{
- net=Malloc(BSIZE);
+ net=OPENSSL_malloc(BSIZE);
if (net == NULL) return(-1);
}
if (unnet == NULL)
{
- unnet=Malloc(BSIZE);
+ unnet=OPENSSL_malloc(BSIZE);
if (unnet == NULL) return(-1);
}
/* left over data from last decrypt */
if (outbuf == NULL)
{
- outbuf=Malloc(BSIZE+HDRSIZE);
+ outbuf=OPENSSL_malloc(BSIZE+HDRSIZE);
if (outbuf == NULL) return(-1);
}
/* If we are sending less than 8 bytes, the same char will look
static int dh_bn_mod_exp(DH *dh, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx,
BN_MONT_CTX *m_ctx)
-{
- return BN_mod_exp_mont(r, a, p, m, ctx, m_ctx);
-}
+ {
+ if (a->top == 1)
+ {
+ BN_ULONG A = a->d[0];
+ return BN_mod_exp_mont_word(r,A,p,m,ctx,m_ctx);
+ }
+ else
+ return BN_mod_exp_mont(r,a,p,m,ctx,m_ctx);
+ }
+
static int dh_init(DH *dh)
-{
+ {
dh->flags |= DH_FLAG_CACHE_MONT_P;
return(1);
-}
+ }
static int dh_finish(DH *dh)
-{
+ {
if(dh->method_mont_p)
BN_MONT_CTX_free((BN_MONT_CTX *)dh->method_mont_p);
return(1);
-}
+ }
{
DH_METHOD *meth;
DH *ret;
- ret=(DH *)Malloc(sizeof(DH));
+ ret=(DH *)OPENSSL_malloc(sizeof(DH));
if (ret == NULL)
{
ret->flags=meth->flags;
if ((meth->init != NULL) && !meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->g != NULL) BN_clear_free(r->g);
if (r->q != NULL) BN_clear_free(r->q);
if (r->j != NULL) BN_clear_free(r->j);
- if (r->seed) Free(r->seed);
+ if (r->seed) OPENSSL_free(r->seed);
if (r->counter != NULL) BN_clear_free(r->counter);
if (r->pub_key != NULL) BN_clear_free(r->pub_key);
if (r->priv_key != NULL) BN_clear_free(r->priv_key);
- Free(r);
+ OPENSSL_free(r);
}
int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
BIO_puts(out,"\n");
alen=DH_size(a);
- abuf=(unsigned char *)Malloc(alen);
+ abuf=(unsigned char *)OPENSSL_malloc(alen);
aout=DH_compute_key(abuf,b->pub_key,a);
BIO_puts(out,"key1 =");
BIO_puts(out,"\n");
blen=DH_size(b);
- bbuf=(unsigned char *)Malloc(blen);
+ bbuf=(unsigned char *)OPENSSL_malloc(blen);
bout=DH_compute_key(bbuf,a->pub_key,b);
BIO_puts(out,"key2 =");
else
ret=0;
err:
- if (abuf != NULL) Free(abuf);
- if (bbuf != NULL) Free(bbuf);
+ if (abuf != NULL) OPENSSL_free(abuf);
+ if (bbuf != NULL) OPENSSL_free(bbuf);
if(b != NULL) DH_free(b);
if(a != NULL) DH_free(a);
BIO_free(out);
{
DSA_SIG *ret;
- ret = Malloc(sizeof(DSA_SIG));
+ ret = OPENSSL_malloc(sizeof(DSA_SIG));
if (ret == NULL)
{
DSAerr(DSA_F_DSA_SIG_NEW,ERR_R_MALLOC_FAILURE);
if (r == NULL) return;
if (r->r) BN_clear_free(r->r);
if (r->s) BN_clear_free(r->s);
- Free(r);
+ OPENSSL_free(r);
}
int i2d_DSA_SIG(DSA_SIG *v, unsigned char **pp)
ASN1_INTEGER rbs,sbs;
unsigned char *p;
- rbs.data=Malloc(BN_num_bits(v->r)/8+1);
+ rbs.data=OPENSSL_malloc(BN_num_bits(v->r)/8+1);
if (rbs.data == NULL)
{
DSAerr(DSA_F_I2D_DSA_SIG, ERR_R_MALLOC_FAILURE);
}
rbs.type=V_ASN1_INTEGER;
rbs.length=BN_bn2bin(v->r,rbs.data);
- sbs.data=Malloc(BN_num_bits(v->s)/8+1);
+ sbs.data=OPENSSL_malloc(BN_num_bits(v->s)/8+1);
if (sbs.data == NULL)
{
- Free(rbs.data);
+ OPENSSL_free(rbs.data);
DSAerr(DSA_F_I2D_DSA_SIG, ERR_R_MALLOC_FAILURE);
return(0);
}
i2d_ASN1_INTEGER(&sbs,&p);
}
t=ASN1_object_size(1,len,V_ASN1_SEQUENCE);
- Free(rbs.data);
- Free(sbs.data);
+ OPENSSL_free(rbs.data);
+ OPENSSL_free(sbs.data);
return(t);
}
DSA_METHOD *meth;
DSA *ret;
- ret=(DSA *)Malloc(sizeof(DSA));
+ ret=(DSA *)OPENSSL_malloc(sizeof(DSA));
if (ret == NULL)
{
DSAerr(DSA_F_DSA_NEW,ERR_R_MALLOC_FAILURE);
ret->flags=meth->flags;
if ((meth->init != NULL) && !meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->priv_key != NULL) BN_clear_free(r->priv_key);
if (r->kinv != NULL) BN_clear_free(r->kinv);
if (r->r != NULL) BN_clear_free(r->r);
- Free(r);
+ OPENSSL_free(r);
}
int DSA_size(DSA *r)
* to stealing the "best available" method. Will fallback
* to DSO_METH_null() in the worst case. */
default_DSO_meth = DSO_METHOD_openssl();
- ret = (DSO *)Malloc(sizeof(DSO));
+ ret = (DSO *)OPENSSL_malloc(sizeof(DSO));
if(ret == NULL)
{
DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
{
/* sk_new doesn't generate any errors so we do */
DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
- Free(ret);
+ OPENSSL_free(ret);
return(NULL);
}
if(meth == NULL)
ret->references = 1;
if((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
return(ret);
sk_free(dso->meth_data);
- Free(dso);
+ OPENSSL_free(dso);
return(1);
}
DSOerr(DSO_F_WIN32_LOAD,DSO_R_LOAD_FAILED);
return(0);
}
- p = (HINSTANCE *)Malloc(sizeof(HINSTANCE));
+ p = (HINSTANCE *)OPENSSL_malloc(sizeof(HINSTANCE));
if(p == NULL)
{
DSOerr(DSO_F_WIN32_LOAD,ERR_R_MALLOC_FAILURE);
- FreeLibrary(h);
+ OPENSSL_freeLibrary(h);
return(0);
}
*p = h;
if(!sk_push(dso->meth_data, (char *)p))
{
DSOerr(DSO_F_WIN32_LOAD,DSO_R_STACK_ERROR);
- FreeLibrary(h);
- Free(p);
+ OPENSSL_freeLibrary(h);
+ OPENSSL_free(p);
return(0);
}
return(1);
DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_NULL_HANDLE);
return(0);
}
- if(!FreeLibrary(p))
+ if(!OPENSSL_freeLibrary(p))
{
DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_UNLOAD_FAILED);
/* We should push the value back onto the stack in
return(0);
}
/* Cleanup */
- Free(p);
+ OPENSSL_free(p);
return(1);
}
static void build_SYS_str_reasons()
{
- /* Malloc cannot be used here, use static storage instead */
+ /* OPENSSL_malloc cannot be used here, use static storage instead */
static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON];
int i;
if (((p)->err_data[i] != NULL) && \
(p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
{ \
- Free((p)->err_data[i]); \
+ OPENSSL_free((p)->err_data[i]); \
(p)->err_data[i]=NULL; \
} \
(p)->err_data_flags[i]=0;
{
err_clear_data(s,i);
}
- Free(s);
+ OPENSSL_free(s);
}
void ERR_load_ERR_strings(void)
/* ret == the error state, if NULL, make a new one */
if (ret == NULL)
{
- ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
+ ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
if (ret == NULL) return(&fallback);
ret->pid=pid;
ret->top=0;
char *str,*p,*a;
s=64;
- str=Malloc(s+1);
+ str=OPENSSL_malloc(s+1);
if (str == NULL) return;
str[0]='\0';
if (n > s)
{
s=n+20;
- p=Realloc(str,s+1);
+ p=OPENSSL_realloc(str,s+1);
if (p == NULL)
{
- Free(str);
+ OPENSSL_free(str);
return;
}
else
#ifndef NO_FP_API
#include <stdio.h>
+#include <stdlib.h>
#endif
#ifdef __cplusplus
{
BIO_B64_CTX *ctx;
- ctx=(BIO_B64_CTX *)Malloc(sizeof(BIO_B64_CTX));
+ ctx=(BIO_B64_CTX *)OPENSSL_malloc(sizeof(BIO_B64_CTX));
if (ctx == NULL) return(0);
ctx->buf_len=0;
static int b64_free(BIO *a)
{
if (a == NULL) return(0);
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
BIO_ENC_CTX *ctx;
- ctx=(BIO_ENC_CTX *)Malloc(sizeof(BIO_ENC_CTX));
+ ctx=(BIO_ENC_CTX *)OPENSSL_malloc(sizeof(BIO_ENC_CTX));
EVP_CIPHER_CTX_init(&ctx->cipher);
if (ctx == NULL) return(0);
b=(BIO_ENC_CTX *)a->ptr;
EVP_CIPHER_CTX_cleanup(&(b->cipher));
memset(a->ptr,0,sizeof(BIO_ENC_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
EVP_MD_CTX *ctx;
- ctx=(EVP_MD_CTX *)Malloc(sizeof(EVP_MD_CTX));
+ ctx=(EVP_MD_CTX *)OPENSSL_malloc(sizeof(EVP_MD_CTX));
if (ctx == NULL) return(0);
bi->init=0;
static int md_free(BIO *a)
{
if (a == NULL) return(0);
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
BIO_OK_CTX *ctx;
- ctx=(BIO_OK_CTX *)Malloc(sizeof(BIO_OK_CTX));
+ ctx=(BIO_OK_CTX *)OPENSSL_malloc(sizeof(BIO_OK_CTX));
if (ctx == NULL) return(0);
ctx->buf_len=0;
{
if (a == NULL) return(0);
memset(a->ptr,0,sizeof(BIO_OK_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
#include "evp_locl.h"
#include <openssl/objects.h>
-static int bf_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int bf_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc);
IMPLEMENT_BLOCK_CIPHER(bf, bf_ks, BF, bf_ks, NID_bf, 8, 16, 8,
0, bf_init_key, NULL,
EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, NULL)
-static int bf_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int bf_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
BF_set_key(&(ctx->c.bf_ks),EVP_CIPHER_CTX_key_length(ctx),key);
return 1;
#include <openssl/objects.h>
#include "evp_locl.h"
-static int cast_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int cast_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
IMPLEMENT_BLOCK_CIPHER(cast5, cast_ks, CAST, cast_ks,
NID_cast5, 8, EVP_CAST5_KEY_SIZE, 8,
EVP_CIPH_VARIABLE_LENGTH, cast_init_key, NULL,
EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, NULL)
-static int cast_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int cast_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
CAST_set_key(&(ctx->c.cast_ks),EVP_CIPHER_CTX_key_length(ctx),key);
return 1;
#include <openssl/objects.h>
#include "evp_locl.h"
-static int des_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc);
/* Because of various casts and different names can't use IMPLEMENT_BLOCK_CIPHER */
-static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
BLOCK_CIPHER_ecb_loop()
des_ecb_encrypt((des_cblock *)(in + i), (des_cblock *)(out + i), ctx->c.des_ks, ctx->encrypt);
return 1;
}
-static int des_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
des_ofb64_encrypt(in, out, (long)inl, ctx->c.des_ks, (des_cblock *)ctx->iv, &ctx->num);
return 1;
}
-static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
- des_ncbc_encrypt(in, out, (long)inl, ctx->c.des_ks, (des_cblock *)ctx->iv, ctx->encrypt);
+ des_ncbc_encrypt(in, out, (long)inl, ctx->c.des_ks,
+ (des_cblock *)ctx->iv, ctx->encrypt);
return 1;
}
-static int des_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
- des_cfb64_encrypt(in, out, (long)inl, ctx->c.des_ks, (des_cblock *)ctx->iv, &ctx->num, ctx->encrypt);
+ des_cfb64_encrypt(in, out, (long)inl, ctx->c.des_ks,
+ (des_cblock *)ctx->iv, &ctx->num, ctx->encrypt);
return 1;
}
NULL)
-static int des_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
des_cblock *deskey = (des_cblock *)key;
#include <openssl/objects.h>
#include "evp_locl.h"
-static int des_ede_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
-static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
/* Because of various casts and different args can't use IMPLEMENT_BLOCK_CIPHER */
-static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
BLOCK_CIPHER_ecb_loop()
des_ecb3_encrypt((des_cblock *)(in + i), (des_cblock *)(out + i),
return 1;
}
-static int des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
des_ede3_ofb64_encrypt(in, out, (long)inl,
ctx->c.des_ede.ks1, ctx->c.des_ede.ks2, ctx->c.des_ede.ks3,
return 1;
}
-static int des_ede_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ede_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
des_ede3_cbc_encrypt(in, out, (long)inl,
ctx->c.des_ede.ks1, ctx->c.des_ede.ks2, ctx->c.des_ede.ks3,
return 1;
}
-static int des_ede_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int des_ede_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
des_ede3_cfb64_encrypt(in, out, (long)inl,
ctx->c.des_ede.ks1, ctx->c.des_ede.ks2, ctx->c.des_ede.ks3,
EVP_CIPHER_get_asn1_iv,
NULL)
-static int des_ede_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
des_cblock *deskey = (des_cblock *)key;
return 1;
}
-static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
des_cblock *deskey = (des_cblock *)key;
#include <openssl/objects.h>
#include "evp_locl.h"
-static int idea_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
/* NB idea_ecb_encrypt doesn't take an 'encrypt' argument so we treat it as a special
* case
*/
-static int idea_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl)
+static int idea_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl)
{
BLOCK_CIPHER_ecb_loop()
idea_ecb_encrypt(in + i, out + i, &ctx->c.idea_ks);
0, idea_init_key, NULL,
EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, NULL)
-static int idea_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
if(!enc) {
if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE) enc = 1;
#include <openssl/evp.h>
#include <openssl/objects.h>
-static int null_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int null_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
static int null_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl);
+ const unsigned char *in, unsigned int inl);
static EVP_CIPHER n_cipher=
{
NID_undef,
return(&n_cipher);
}
-static int null_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int null_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
memset(&(ctx->c),0,sizeof(ctx->c));
return 1;
}
static int null_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl)
+ const unsigned char *in, unsigned int inl)
{
if (in != out)
memcpy((char *)out,(char *)in,(int)inl);
#include <openssl/objects.h>
#include "evp_locl.h"
-static int rc2_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
-static int rc2_meth_to_magic(const EVP_CIPHER *e);
-static EVP_CIPHER *rc2_magic_to_meth(int i);
+static int rc2_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
+static int rc2_meth_to_magic(EVP_CIPHER_CTX *ctx);
+static int rc2_magic_to_meth(int i);
static int rc2_set_asn1_type_and_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
static int rc2_get_asn1_type_and_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+static int rc2_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr);
IMPLEMENT_BLOCK_CIPHER(rc2, rc2.ks, RC2, rc2, NID_rc2,
8,
EVP_RC2_KEY_SIZE, 8,
- EVP_CIPH_VARIABLE_LENGTH, rc2_init_key, NULL,
- rc2_set_asn1_type_and_iv, rc2_get_asn1_type_and_iv, NULL)
+ EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
+ rc2_init_key, NULL,
+ rc2_set_asn1_type_and_iv, rc2_get_asn1_type_and_iv,
+ rc2_ctrl)
#define RC2_40_MAGIC 0xa0
#define RC2_64_MAGIC 0x78
{
NID_rc2_64_cbc,
8,8 /* 64 bit */,8,
- EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH,
+ EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
rc2_init_key,
rc2_cbc_cipher,
NULL,
sizeof((((EVP_CIPHER_CTX *)NULL)->c.rc2)),
rc2_set_asn1_type_and_iv,
rc2_get_asn1_type_and_iv,
- NULL,
+ rc2_ctrl,
NULL
};
{
NID_rc2_40_cbc,
8,5 /* 40 bit */,8,
- EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH,
+ EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
rc2_init_key,
rc2_cbc_cipher,
NULL,
sizeof((((EVP_CIPHER_CTX *)NULL)->c.rc2)),
rc2_set_asn1_type_and_iv,
rc2_get_asn1_type_and_iv,
- NULL,
+ rc2_ctrl,
NULL
};
return(&r2_40_cbc_cipher);
}
-static int rc2_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int rc2_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
RC2_set_key(&(ctx->c.rc2.ks),EVP_CIPHER_CTX_key_length(ctx),
- key,EVP_CIPHER_key_length(ctx->cipher)*8);
+ key,ctx->c.rc2.key_bits);
return 1;
}
-static int rc2_meth_to_magic(const EVP_CIPHER *e)
+static int rc2_meth_to_magic(EVP_CIPHER_CTX *e)
{
int i;
- i=EVP_CIPHER_key_length(e);
- if (i == 16) return(RC2_128_MAGIC);
- else if (i == 8) return(RC2_64_MAGIC);
- else if (i == 5) return(RC2_40_MAGIC);
+ EVP_CIPHER_CTX_ctrl(e, EVP_CTRL_GET_RC2_KEY_BITS, 0, &i);
+ if (i == 128) return(RC2_128_MAGIC);
+ else if (i == 64) return(RC2_64_MAGIC);
+ else if (i == 40) return(RC2_40_MAGIC);
else return(0);
}
-static EVP_CIPHER *rc2_magic_to_meth(int i)
+static int rc2_magic_to_meth(int i)
{
- if (i == RC2_128_MAGIC) return(EVP_rc2_cbc());
- else if (i == RC2_64_MAGIC) return(EVP_rc2_64_cbc());
- else if (i == RC2_40_MAGIC) return(EVP_rc2_40_cbc());
+ if (i == RC2_128_MAGIC) return 128;
+ else if (i == RC2_64_MAGIC) return 64;
+ else if (i == RC2_40_MAGIC) return 40;
else
{
EVPerr(EVP_F_RC2_MAGIC_TO_METH,EVP_R_UNSUPPORTED_KEY_SIZE);
- return(NULL);
+ return(0);
}
}
{
long num=0;
int i=0,l;
- EVP_CIPHER *e;
+ int key_bits;
+ unsigned char iv[EVP_MAX_IV_LENGTH];
if (type != NULL)
{
l=EVP_CIPHER_CTX_iv_length(c);
- i=ASN1_TYPE_get_int_octetstring(type,&num,c->oiv,l);
+ i=ASN1_TYPE_get_int_octetstring(type,&num,iv,l);
if (i != l)
return(-1);
- else if (i > 0)
- memcpy(c->iv,c->oiv,l);
- e=rc2_magic_to_meth((int)num);
- if (e == NULL)
+ key_bits =rc2_magic_to_meth((int)num);
+ if (!key_bits)
return(-1);
- if (e != EVP_CIPHER_CTX_cipher(c))
- {
- EVP_CIPHER_CTX_cipher(c)=e;
- EVP_CIPHER_CTX_set_key_length(c, EVP_CIPHER_key_length(c));
- rc2_init_key(c,NULL,NULL,1);
- }
+ if(i > 0) EVP_CipherInit(c, NULL, NULL, iv, -1);
+ EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_RC2_KEY_BITS, key_bits, NULL);
+ EVP_CIPHER_CTX_set_key_length(c, key_bits / 8);
}
return(i);
}
if (type != NULL)
{
- num=rc2_meth_to_magic(EVP_CIPHER_CTX_cipher(c));
+ num=rc2_meth_to_magic(c);
j=EVP_CIPHER_CTX_iv_length(c);
i=ASN1_TYPE_set_int_octetstring(type,num,c->oiv,j);
}
return(i);
}
+static int rc2_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
+ {
+ switch(type) {
+
+ case EVP_CTRL_INIT:
+ c->c.rc2.key_bits = EVP_CIPHER_CTX_key_length(c) * 8;
+ return 1;
+
+ case EVP_CTRL_GET_RC2_KEY_BITS:
+ *(int *)ptr = c->c.rc2.key_bits;
+ return 1;
+
+
+ case EVP_CTRL_SET_RC2_KEY_BITS:
+ if(arg > 0) {
+ c->c.rc2.key_bits = arg;
+ return 1;
+ }
+ return 0;
+
+ default:
+ return -1;
+ }
+ }
+
#endif
#include <openssl/evp.h>
#include <openssl/objects.h>
-static int rc4_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
static int rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl);
+ const unsigned char *in, unsigned int inl);
static EVP_CIPHER r4_cipher=
{
NID_rc4,
return(&r4_40_cipher);
}
-static int rc4_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
memcpy(&(ctx->c.rc4.key[0]),key,EVP_CIPHER_CTX_key_length(ctx));
RC4_set_key(&(ctx->c.rc4.ks),EVP_CIPHER_CTX_key_length(ctx),
}
static int rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl)
+ const unsigned char *in, unsigned int inl)
{
RC4(&(ctx->c.rc4.ks),inl,in,out);
return 1;
#include <openssl/objects.h>
#include "evp_locl.h"
-static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
+static int rc5_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr);
IMPLEMENT_BLOCK_CIPHER(rc5_32_12_16, rc5.ks, RC5_32, rc5, NID_rc5,
8, EVP_RC5_32_12_16_KEY_SIZE, 8,
- 0, r_32_12_16_init_key, NULL,
- NULL, NULL, NULL)
+ EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
+ r_32_12_16_init_key, NULL,
+ NULL, NULL, rc5_ctrl)
-#if 0
-static int r_32_12_16_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl);
-static EVP_CIPHER rc5_32_12_16_cbc_cipher=
- {
- NID_rc5_cbc,
- 8,EVP_RC5_32_12_16_KEY_SIZE,8,
- EVP_CIPH_CBC_MODE,
- r_32_12_16_cbc_init_key,
- r_32_12_16_cbc_cipher,
- NULL,
- sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+
- sizeof((((EVP_CIPHER_CTX *)NULL)->c.rc5)),
- NULL,
- NULL,
- NULL
- };
-EVP_CIPHER *EVP_rc5_32_12_16_cbc(void)
- {
- return(&rc5_32_12_16_cbc_cipher);
- }
-#endif
-
-static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+
+static int rc5_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
{
- RC5_32_set_key(&(ctx->c.rc5.ks),EVP_RC5_32_12_16_KEY_SIZE,
- key,RC5_12_ROUNDS);
- return 1;
+ switch(type) {
+
+ case EVP_CTRL_INIT:
+ c->c.rc5.rounds = RC5_12_ROUNDS;
+ return 1;
+
+ case EVP_CTRL_GET_RC5_ROUNDS:
+ *(int *)ptr = c->c.rc5.rounds;
+ return 1;
+
+
+ case EVP_CTRL_SET_RC5_ROUNDS:
+ switch(arg) {
+ case RC5_8_ROUNDS:
+ case RC5_12_ROUNDS:
+ case RC5_16_ROUNDS:
+ c->c.rc5.rounds = arg;
+ return 1;
+
+ default:
+ EVPerr(EVP_F_RC5_CTRL, EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS);
+ return 0;
+ }
+
+ default:
+ return -1;
+ }
}
-#if 0
-static int r_32_12_16_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl)
+
+static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
- RC5_32_cbc_encrypt(
- in,out,(long)inl,
- &(ctx->c.rc5.ks),&(ctx->iv[0]),
- ctx->encrypt);
+ RC5_32_set_key(&(ctx->c.rc5.ks),EVP_CIPHER_CTX_key_length(ctx),
+ key,ctx->c.rc5.rounds);
return 1;
}
-#endif
#endif
#include <openssl/evp.h>
#include <openssl/objects.h>
-static int desx_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv,int enc);
+static int desx_cbc_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv,int enc);
static int desx_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl);
+ const unsigned char *in, unsigned int inl);
static EVP_CIPHER d_xcbc_cipher=
{
NID_desx_cbc,
return(&d_xcbc_cipher);
}
-static int desx_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
- unsigned char *iv, int enc)
+static int desx_cbc_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc)
{
des_cblock *deskey = (des_cblock *)key;
}
static int desx_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
- unsigned char *in, unsigned int inl)
+ const unsigned char *in, unsigned int inl)
{
des_xcbc_encrypt(in,out,inl,ctx->c.desx_cbc.ks,
(des_cblock *)&(ctx->iv[0]),
int key_len; /* Default value for variable length ciphers */
int iv_len;
unsigned long flags; /* Various flags */
- int (*init)(EVP_CIPHER_CTX *, unsigned char *, unsigned char *, int); /* init key */
- int (*do_cipher)(EVP_CIPHER_CTX *, unsigned char *, unsigned char *, unsigned int);/* encrypt/decrypt data */
+ int (*init)(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+ const unsigned char *iv, int enc); /* init key */
+ int (*do_cipher)(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ const unsigned char *in, unsigned int inl);/* encrypt/decrypt data */
int (*cleanup)(EVP_CIPHER_CTX *); /* cleanup ctx */
int ctx_size; /* how big the ctx needs to be */
int (*set_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Populate a ASN1_TYPE with parameters */
void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a);
int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a);
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
+int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
#ifdef HEADER_BIO_H
BIO_METHOD *BIO_f_md(void);
/* Function codes. */
#define EVP_F_D2I_PKEY 100
#define EVP_F_EVP_CIPHERINIT 123
+#define EVP_F_EVP_CIPHER_CTX_CTRL 124
#define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122
#define EVP_F_EVP_DECRYPTFINAL 101
#define EVP_F_EVP_MD_CTX_COPY 110
#define EVP_F_PKCS5_PBE_KEYIVGEN 117
#define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118
#define EVP_F_RC2_MAGIC_TO_METH 109
+#define EVP_F_RC5_CTRL 125
/* Reason codes. */
#define EVP_R_BAD_DECRYPT 100
#define EVP_R_BN_DECODE_ERROR 112
#define EVP_R_BN_PUBKEY_ERROR 113
#define EVP_R_CIPHER_PARAMETER_ERROR 122
+#define EVP_R_CTRL_NOT_IMPLEMENTED 132
+#define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133
#define EVP_R_DECODE_ERROR 114
#define EVP_R_DIFFERENT_KEY_TYPES 101
#define EVP_R_ENCODE_ERROR 115
#define EVP_R_EXPECTING_AN_RSA_KEY 127
#define EVP_R_EXPECTING_A_DH_KEY 128
#define EVP_R_EXPECTING_A_DSA_KEY 129
+#define EVP_R_INITIALIZATION_ERROR 134
#define EVP_R_INPUT_NOT_INITIALIZED 111
#define EVP_R_INVALID_KEY_LENGTH 130
#define EVP_R_IV_TOO_LARGE 102
#define EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE 117
#define EVP_R_PUBLIC_KEY_NOT_RSA 106
#define EVP_R_UNKNOWN_PBE_ALGORITHM 121
+#define EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS 135
#define EVP_R_UNSUPPORTED_CIPHER 107
#define EVP_R_UNSUPPORTED_KEYLENGTH 123
#define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124
int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
unsigned char *key, unsigned char *iv, int enc)
{
- if(enc) enc = 1;
+ if(enc && (enc != -1)) enc = 1;
if (cipher) {
ctx->cipher=cipher;
ctx->key_len = cipher->key_len;
+ if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
+ if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
+ EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR);
+ return 0;
+ }
+ }
} else if(!ctx->cipher) {
EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_NO_CIPHER_SET);
return 0;
if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;
}
- ctx->encrypt=enc;
+ if(enc != -1) ctx->encrypt=enc;
ctx->buf_len=0;
return 1;
}
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
{
+ if(c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH)
+ return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
if(c->key_len == keylen) return 1;
if((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH))
{
EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,EVP_R_INVALID_KEY_LENGTH);
return 0;
}
+
+int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
+{
+ int ret;
+ if(!ctx->cipher) {
+ EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
+ return 0;
+ }
+
+ if(!ctx->cipher->ctrl) {
+ EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
+ return 0;
+ }
+
+ ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
+ if(ret == -1) {
+ EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
+ return 0;
+ }
+ return ret;
+}
{
{ERR_PACK(0,EVP_F_D2I_PKEY,0), "D2I_PKEY"},
{ERR_PACK(0,EVP_F_EVP_CIPHERINIT,0), "EVP_CipherInit"},
+{ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_CTRL,0), "EVP_CIPHER_CTX_ctrl"},
{ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,0), "EVP_CIPHER_CTX_set_key_length"},
{ERR_PACK(0,EVP_F_EVP_DECRYPTFINAL,0), "EVP_DecryptFinal"},
{ERR_PACK(0,EVP_F_EVP_MD_CTX_COPY,0), "EVP_MD_CTX_copy"},
{ERR_PACK(0,EVP_F_PKCS5_PBE_KEYIVGEN,0), "PKCS5_PBE_keyivgen"},
{ERR_PACK(0,EVP_F_PKCS5_V2_PBE_KEYIVGEN,0), "PKCS5_v2_PBE_keyivgen"},
{ERR_PACK(0,EVP_F_RC2_MAGIC_TO_METH,0), "RC2_MAGIC_TO_METH"},
+{ERR_PACK(0,EVP_F_RC5_CTRL,0), "RC5_CTRL"},
{0,NULL}
};
{EVP_R_BN_DECODE_ERROR ,"bn decode error"},
{EVP_R_BN_PUBKEY_ERROR ,"bn pubkey error"},
{EVP_R_CIPHER_PARAMETER_ERROR ,"cipher parameter error"},
+{EVP_R_CTRL_NOT_IMPLEMENTED ,"ctrl not implemented"},
+{EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED ,"ctrl operation not implemented"},
{EVP_R_DECODE_ERROR ,"decode error"},
{EVP_R_DIFFERENT_KEY_TYPES ,"different key types"},
{EVP_R_ENCODE_ERROR ,"encode error"},
{EVP_R_EXPECTING_AN_RSA_KEY ,"expecting an rsa key"},
{EVP_R_EXPECTING_A_DH_KEY ,"expecting a dh key"},
{EVP_R_EXPECTING_A_DSA_KEY ,"expecting a dsa key"},
+{EVP_R_INITIALIZATION_ERROR ,"initialization error"},
{EVP_R_INPUT_NOT_INITIALIZED ,"input not initialized"},
{EVP_R_INVALID_KEY_LENGTH ,"invalid key length"},
{EVP_R_IV_TOO_LARGE ,"iv too large"},
{EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE ,"pkcs8 unknown broken type"},
{EVP_R_PUBLIC_KEY_NOT_RSA ,"public key not rsa"},
{EVP_R_UNKNOWN_PBE_ALGORITHM ,"unknown pbe algorithm"},
+{EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS ,"unsuported number of rounds"},
{EVP_R_UNSUPPORTED_CIPHER ,"unsupported cipher"},
{EVP_R_UNSUPPORTED_KEYLENGTH ,"unsupported keylength"},
{EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION,"unsupported key derivation function"},
for(i=0; i <= inl; i+=8) \
#define BLOCK_CIPHER_func_ecb(cname, cprefix, kname) \
-static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl) \
+static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
{\
BLOCK_CIPHER_ecb_loop() \
cprefix##_ecb_encrypt(in + i, out + i, &ctx->c.##kname, ctx->encrypt);\
}
#define BLOCK_CIPHER_func_ofb(cname, cprefix, kname) \
-static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl) \
+static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
{\
cprefix##_ofb64_encrypt(in, out, (long)inl, &ctx->c.##kname, ctx->iv, &ctx->num);\
return 1;\
}
#define BLOCK_CIPHER_func_cbc(cname, cprefix, kname) \
-static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl) \
+static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
{\
cprefix##_cbc_encrypt(in, out, (long)inl, &ctx->c.##kname, ctx->iv, ctx->encrypt);\
return 1;\
}
#define BLOCK_CIPHER_func_cfb(cname, cprefix, kname) \
-static int cname##_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, unsigned char *in, unsigned int inl) \
+static int cname##_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
{\
cprefix##_cfb64_encrypt(in, out, (long)inl, &ctx->c.##kname, ctx->iv, &ctx->num, ctx->encrypt);\
return 1;\
{
EVP_PBE_CTL *pbe_tmp;
if (!pbe_algs) pbe_algs = sk_new ((int (*)())pbe_cmp);
- if (!(pbe_tmp = (EVP_PBE_CTL*) Malloc (sizeof(EVP_PBE_CTL)))) {
+ if (!(pbe_tmp = (EVP_PBE_CTL*) OPENSSL_malloc (sizeof(EVP_PBE_CTL)))) {
EVPerr(EVP_F_EVP_PBE_ALG_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
void EVP_PBE_cleanup(void)
{
- sk_pop_free(pbe_algs, FreeFunc);
+ sk_pop_free(pbe_algs, OPENSSL_freeFunc);
pbe_algs = NULL;
}
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_dsa);
len = i2d_DSAparams (pkey->pkey.dsa, NULL);
- if (!(p = Malloc(len))) {
+ if (!(p = OPENSSL_malloc(len))) {
EVPerr(EVP_F_EVP_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
PKCS8_PRIV_KEY_INFO_free (p8);
return 0;
i2d_DSAparams (pkey->pkey.dsa, &q);
params = ASN1_STRING_new();
ASN1_STRING_set(params, p, len);
- Free(p);
+ OPENSSL_free(p);
/* Get private key into integer */
if (!(prkey = BN_to_ASN1_INTEGER (pkey->pkey.dsa->priv_key, NULL))) {
EVPerr(EVP_F_EVP_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
{
EVP_PKEY *ret;
- ret=(EVP_PKEY *)Malloc(sizeof(EVP_PKEY));
+ ret=(EVP_PKEY *)OPENSSL_malloc(sizeof(EVP_PKEY));
if (ret == NULL)
{
EVPerr(EVP_F_EVP_PKEY_NEW,ERR_R_MALLOC_FAILURE);
}
#endif
EVP_PKEY_free_it(x);
- Free(x);
+ OPENSSL_free(x);
}
static void EVP_PKEY_free_it(EVP_PKEY *x)
goto err;
}
+ if(type) {
+ EVP_CIPHER_CTX_init(ctx);
+ EVP_DecryptInit(ctx,type,NULL,NULL);
+ }
+
size=RSA_size(priv->pkey.rsa);
- key=(unsigned char *)Malloc(size+2);
+ key=(unsigned char *)OPENSSL_malloc(size+2);
if (key == NULL)
{
/* ERROR */
}
i=EVP_PKEY_decrypt(key,ek,ekl,priv);
- if (i != type->key_len)
+ if ((i <= 0) || !EVP_CIPHER_CTX_set_key_length(ctx, i))
{
/* ERROR */
goto err;
}
+ if(!EVP_DecryptInit(ctx,NULL,key,iv)) goto err;
- EVP_CIPHER_CTX_init(ctx);
- EVP_DecryptInit(ctx,type,key,iv);
ret=1;
err:
if (key != NULL) memset(key,0,size);
- Free(key);
+ OPENSSL_free(key);
return(ret);
}
int i;
if (npubk <= 0) return(0);
+ if(type) {
+ EVP_CIPHER_CTX_init(ctx);
+ EVP_EncryptInit(ctx,type,NULL,NULL);
+ }
if (RAND_bytes(key,EVP_MAX_KEY_LENGTH) <= 0)
return(0);
- if (type->iv_len > 0)
- RAND_pseudo_bytes(iv,type->iv_len);
+ if (EVP_CIPHER_CTX_iv_length(ctx))
+ RAND_pseudo_bytes(iv,EVP_CIPHER_CTX_iv_length(ctx));
- EVP_CIPHER_CTX_init(ctx);
- EVP_EncryptInit(ctx,type,key,iv);
+ if(!EVP_EncryptInit(ctx,NULL,key,iv)) return 0;
for (i=0; i<npubk; i++)
{
- ekl[i]=EVP_PKEY_encrypt(ek[i],key,EVP_CIPHER_key_length(type),
+ ekl[i]=EVP_PKEY_encrypt(ek[i],key,EVP_CIPHER_CTX_key_length(ctx),
pubk[i]);
if (ekl[i] <= 0) return(-1);
}
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
goto err;
}
- a=(CRYPTO_EX_DATA_FUNCS *)Malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
+ a=(CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
if (a == NULL)
{
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
if (!sk_CRYPTO_EX_DATA_FUNCS_push(*skp,NULL))
{
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
- Free(a);
+ OPENSSL_free(a);
goto err;
}
}
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
#include <openssl/idea.h>
#include "idea_lcl.h"
-void idea_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+void idea_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
IDEA_KEY_SCHEDULE *ks, unsigned char *iv, int encrypt)
{
register unsigned long tin0,tin1;
* 64bit block we have used is contained in *num;
*/
-void idea_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
- IDEA_KEY_SCHEDULE *schedule, unsigned char *ivec, int *num,
- int encrypt)
+void idea_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, IDEA_KEY_SCHEDULE *schedule,
+ unsigned char *ivec, int *num, int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
return("idea(short)");
}
-void idea_ecb_encrypt(unsigned char *in, unsigned char *out,
+void idea_ecb_encrypt(const unsigned char *in, unsigned char *out,
IDEA_KEY_SCHEDULE *ks)
{
unsigned long l0,l1,d[2];
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void idea_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
- IDEA_KEY_SCHEDULE *schedule, unsigned char *ivec, int *num)
+void idea_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, IDEA_KEY_SCHEDULE *schedule,
+ unsigned char *ivec, int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
#include "idea_lcl.h"
static IDEA_INT inverse(unsigned int xin);
-void idea_set_encrypt_key(unsigned char *key, IDEA_KEY_SCHEDULE *ks)
+void idea_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks)
{
int i;
register IDEA_INT *kt,*kf,r0,r1,r2;
} IDEA_KEY_SCHEDULE;
const char *idea_options(void);
-void idea_ecb_encrypt(unsigned char *in, unsigned char *out,
+void idea_ecb_encrypt(const unsigned char *in, unsigned char *out,
IDEA_KEY_SCHEDULE *ks);
-void idea_set_encrypt_key(unsigned char *key, IDEA_KEY_SCHEDULE *ks);
+void idea_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks);
void idea_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk);
-void idea_cbc_encrypt(unsigned char *in, unsigned char *out,
+void idea_cbc_encrypt(const unsigned char *in, unsigned char *out,
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv,int enc);
-void idea_cfb64_encrypt(unsigned char *in, unsigned char *out,
+void idea_cfb64_encrypt(const unsigned char *in, unsigned char *out,
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv,
int *num,int enc);
-void idea_ofb64_encrypt(unsigned char *in, unsigned char *out,
+void idea_ofb64_encrypt(const unsigned char *in, unsigned char *out,
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, int *num);
void idea_encrypt(unsigned long *in, IDEA_KEY_SCHEDULE *ks);
#ifdef __cplusplus
if (buf[0] == '\0') break;
buf[256]='\0';
i=strlen(buf);
- p=Malloc(i+1);
+ p=OPENSSL_malloc(i+1);
memcpy(p,buf,i+1);
lh_insert(conf,p);
}
LHASH *ret;
int i;
- if ((ret=(LHASH *)Malloc(sizeof(LHASH))) == NULL)
+ if ((ret=(LHASH *)OPENSSL_malloc(sizeof(LHASH))) == NULL)
goto err0;
- if ((ret->b=(LHASH_NODE **)Malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
+ if ((ret->b=(LHASH_NODE **)OPENSSL_malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
goto err1;
for (i=0; i<MIN_NODES; i++)
ret->b[i]=NULL;
ret->error=0;
return(ret);
err1:
- Free(ret);
+ OPENSSL_free(ret);
err0:
return(NULL);
}
while (n != NULL)
{
nn=n->next;
- Free(n);
+ OPENSSL_free(n);
n=nn;
}
}
- Free(lh->b);
- Free(lh);
+ OPENSSL_free(lh->b);
+ OPENSSL_free(lh);
}
void *lh_insert(LHASH *lh, void *data)
if (*rn == NULL)
{
- if ((nn=(LHASH_NODE *)Malloc(sizeof(LHASH_NODE))) == NULL)
+ if ((nn=(LHASH_NODE *)OPENSSL_malloc(sizeof(LHASH_NODE))) == NULL)
{
lh->error++;
return(NULL);
nn= *rn;
*rn=nn->next;
ret=nn->data;
- Free(nn);
+ OPENSSL_free(nn);
lh->num_delete++;
}
if ((lh->p) >= lh->pmax)
{
j=(int)lh->num_alloc_nodes*2;
- n=(LHASH_NODE **)Realloc(lh->b,
+ n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
(unsigned int)sizeof(LHASH_NODE *)*j);
if (n == NULL)
{
lh->b[lh->p+lh->pmax-1]=NULL; /* 24/07-92 - eay - weird but :-( */
if (lh->p == 0)
{
- n=(LHASH_NODE **)Realloc(lh->b,
+ n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
(unsigned int)(sizeof(LHASH_NODE *)*lh->pmax));
if (n == NULL)
{
void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
{
- if (a != NULL) Free(a);
- a=(char *)Malloc(num);
+ if (a != NULL) OPENSSL_free(a);
+ a=(char *)OPENSSL_malloc(num);
return(a);
}
ret->next = NULL;
if (next != NULL)
next->references--;
- Free(ret);
+ OPENSSL_free(ret);
}
}
}
{
MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
- if ((ami = (APP_INFO *)Malloc(sizeof(APP_INFO))) == NULL)
+ if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
{
ret=0;
goto err;
{
if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
{
- Free(ami);
+ OPENSSL_free(ami);
ret=0;
goto err;
}
if (is_MemCheck_on())
{
MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
- if ((m=(MEM *)Malloc(sizeof(MEM))) == NULL)
+ if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
{
- Free(addr);
+ OPENSSL_free(addr);
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
return;
}
{
if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
{
- Free(addr);
- Free(m);
+ OPENSSL_free(addr);
+ OPENSSL_free(m);
addr=NULL;
goto err;
}
{
mm->app_info->references--;
}
- Free(mm);
+ OPENSSL_free(mm);
}
err:
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
{
mp->app_info->references--;
}
- Free(mp);
+ OPENSSL_free(mp);
}
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
} NAME_FUNCS;
DECLARE_STACK_OF(NAME_FUNCS)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_NAME_FUNCS_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_NAME_FUNCS_new_null() sk_new_null()
+ #define sk_NAME_FUNCS_free(a) sk_free(a)
+ #define sk_NAME_FUNCS_num(a) sk_num(a)
+ #define sk_NAME_FUNCS_value(a,b) ((NAME_FUNCS *) \
+ sk_value((a),(b)))
+ #define sk_NAME_FUNCS_set(a,b,c) ((NAME_FUNCS *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_NAME_FUNCS_zero(a) sk_zero(a)
+ #define sk_NAME_FUNCS_push(a,b) sk_push((a),(char *)(b))
+ #define sk_NAME_FUNCS_unshift(a,b) sk_unshift((a),(b))
+ #define sk_NAME_FUNCS_find(a,b) sk_find((a), (char *)(b))
+ #define sk_NAME_FUNCS_delete(a,b) ((NAME_FUNCS *) \
+ sk_delete((a),(b)))
+ #define sk_NAME_FUNCS_delete_ptr(a,b) ((NAME_FUNCS *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_NAME_FUNCS_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_NAME_FUNCS_set_cmp_func(a,b) ((int (*) \
+ (const NAME_FUNCS * const *,const NAME_FUNCS * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_NAME_FUNCS_dup(a) sk_dup(a)
+ #define sk_NAME_FUNCS_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_NAME_FUNCS_shift(a) ((NAME_FUNCS *)sk_shift(a))
+ #define sk_NAME_FUNCS_pop(a) ((NAME_FUNCS *)sk_pop(a))
+ #define sk_NAME_FUNCS_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
IMPLEMENT_STACK_OF(NAME_FUNCS)
static STACK_OF(NAME_FUNCS) *name_funcs_stack;
for (i=sk_NAME_FUNCS_num(name_funcs_stack); i<names_type_num; i++)
{
MemCheck_off();
- name_funcs = Malloc(sizeof(NAME_FUNCS));
+ name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));
name_funcs->hash_func = lh_strhash;
name_funcs->cmp_func = (int (*)())strcmp;
name_funcs->free_func = 0; /* NULL is often declared to
alias=type&OBJ_NAME_ALIAS;
type&= ~OBJ_NAME_ALIAS;
- onp=(OBJ_NAME *)Malloc(sizeof(OBJ_NAME));
+ onp=(OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME));
if (onp == NULL)
{
/* ERROR */
sk_NAME_FUNCS_value(name_funcs_stack,ret->type)
->free_func(ret->name,ret->type,ret->data);
}
- Free(ret);
+ OPENSSL_free(ret);
}
else
{
sk_NAME_FUNCS_value(name_funcs_stack,ret->type)
->free_func(ret->name,ret->type,ret->data);
}
- Free(ret);
+ OPENSSL_free(ret);
return(1);
}
else
static void name_funcs_free(NAME_FUNCS *ptr)
{
- Free(ptr);
+ OPENSSL_free(ptr);
}
void OBJ_NAME_cleanup(int type)
{
if (--a->obj->nid == 0)
ASN1_OBJECT_free(a->obj);
- Free(a);
+ OPENSSL_free(a);
}
void OBJ_cleanup(void)
if (added == NULL)
if (!init_added()) return(0);
if ((o=OBJ_dup(obj)) == NULL) goto err;
- ao[ADDED_NID]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if ((o->length != 0) && (obj->data != NULL))
- ao[ADDED_DATA]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if (o->sn != NULL)
- ao[ADDED_SNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if (o->ln != NULL)
- ao[ADDED_LNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
for (i=ADDED_DATA; i<=ADDED_NID; i++)
{
aop=(ADDED_OBJ *)lh_insert(added,ao[i]);
/* memory leak, buit should not normally matter */
if (aop != NULL)
- Free(aop);
+ OPENSSL_free(aop);
}
}
o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
return(o->nid);
err:
for (i=ADDED_DATA; i<=ADDED_NID; i++)
- if (ao[i] != NULL) Free(ao[i]);
- if (o != NULL) Free(o);
+ if (ao[i] != NULL) OPENSSL_free(ao[i]);
+ if (o != NULL) OPENSSL_free(o);
return(NID_undef);
}
/* Work out total size */
j = ASN1_object_size(0,i,V_ASN1_OBJECT);
- if((buf=(unsigned char *)Malloc(j)) == NULL) return NULL;
+ if((buf=(unsigned char *)OPENSSL_malloc(j)) == NULL) return NULL;
p = buf;
/* Write out tag+length */
p=buf;
op=d2i_ASN1_OBJECT(NULL,&p,i);
- Free(buf);
+ OPENSSL_free(buf);
return op;
}
i=a2d_ASN1_OBJECT(NULL,0,oid,-1);
if (i <= 0) return(0);
- if ((buf=(unsigned char *)Malloc(i)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(i)) == NULL)
{
OBJerr(OBJ_F_OBJ_CREATE,OBJ_R_MALLOC_FAILURE);
return(0);
ok=OBJ_add_object(op);
err:
ASN1_OBJECT_free(op);
- Free(buf);
+ OPENSSL_free(buf);
return(ok);
}
OBJerr(OBJ_F_OBJ_DUP,ERR_R_ASN1_LIB);
return(NULL);
}
- r->data=Malloc(o->length);
+ r->data=OPENSSL_malloc(o->length);
if (r->data == NULL)
goto err;
memcpy(r->data,o->data,o->length);
if (o->ln != NULL)
{
i=strlen(o->ln)+1;
- r->ln=ln=Malloc(i);
+ r->ln=ln=OPENSSL_malloc(i);
if (r->ln == NULL) goto err;
memcpy(ln,o->ln,i);
}
char *s;
i=strlen(o->sn)+1;
- r->sn=s=Malloc(i);
+ r->sn=s=OPENSSL_malloc(i);
if (r->sn == NULL) goto err;
memcpy(s,o->sn,i);
}
OBJerr(OBJ_F_OBJ_DUP,ERR_R_MALLOC_FAILURE);
if (r != NULL)
{
- if (ln != NULL) Free(ln);
- if (r->data != NULL) Free(r->data);
- Free(r);
+ if (ln != NULL) OPENSSL_free(ln);
+ if (r->data != NULL) OPENSSL_free(r->data);
+ OPENSSL_free(r);
}
return(NULL);
}
else {
/* unknown */
}
- if (name != NULL) Free(name);
- if (header != NULL) Free(header);
- if (data != NULL) Free(data);
+ if (name != NULL) OPENSSL_free(name);
+ if (header != NULL) OPENSSL_free(header);
+ if (data != NULL) OPENSSL_free(data);
name=NULL;
header=NULL;
data=NULL;
ret=NULL;
}
- if (name != NULL) Free(name);
- if (header != NULL) Free(header);
- if (data != NULL) Free(data);
+ if (name != NULL) OPENSSL_free(name);
+ if (header != NULL) OPENSSL_free(header);
+ if (data != NULL) OPENSSL_free(data);
return(ret);
}
return(NULL);
}
if(check_pem(nm, name)) break;
- Free(nm);
- Free(header);
- Free(data);
+ OPENSSL_free(nm);
+ OPENSSL_free(header);
+ OPENSSL_free(data);
}
if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;
if (ret == NULL)
PEMerr(PEM_F_PEM_ASN1_READ_BIO,ERR_R_ASN1_LIB);
err:
- Free(nm);
- Free(header);
- Free(data);
+ OPENSSL_free(nm);
+ OPENSSL_free(header);
+ OPENSSL_free(data);
return(ret);
}
goto err;
}
/* dzise + 8 bytes are needed */
- data=(unsigned char *)Malloc((unsigned int)dsize+20);
+ data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);
if (data == NULL)
{
PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
memset((char *)&ctx,0,sizeof(ctx));
memset(buf,0,PEM_BUFSIZE);
memset(data,0,(unsigned int)dsize);
- Free(data);
+ OPENSSL_free(data);
return(ret);
}
goto err;
}
- buf=(unsigned char *)Malloc(PEM_BUFSIZE*8);
+ buf=(unsigned char *)OPENSSL_malloc(PEM_BUFSIZE*8);
if (buf == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
}
EVP_EncodeFinal(&ctx,buf,&outl);
if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
- Free(buf);
+ OPENSSL_free(buf);
if ( (BIO_write(bp,"-----END ",9) != 9) ||
(BIO_write(bp,name,nlen) != nlen) ||
(BIO_write(bp,"-----\n",6) != 6))
*header=headerB->data;
*data=(unsigned char *)dataB->data;
*len=bl;
- Free(nameB);
- Free(headerB);
- Free(dataB);
+ OPENSSL_free(nameB);
+ OPENSSL_free(headerB);
+ OPENSSL_free(dataB);
return(1);
err:
BUF_MEM_free(nameB);
j=RSA_size(pubk[i]->pkey.rsa);
if (j > max) max=j;
}
- s=(char *)Malloc(max*2);
+ s=(char *)OPENSSL_malloc(max*2);
if (s == NULL)
{
PEMerr(PEM_F_PEM_SEALINIT,ERR_R_MALLOC_FAILURE);
ret=npubk;
err:
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
memset(key,0,EVP_MAX_KEY_LENGTH);
return(ret);
}
}
i=RSA_size(priv->pkey.rsa);
if (i < 100) i=100;
- s=(unsigned char *)Malloc(i*2);
+ s=(unsigned char *)OPENSSL_malloc(i*2);
if (s == NULL)
{
PEMerr(PEM_F_PEM_SEALFINAL,ERR_R_MALLOC_FAILURE);
err:
memset((char *)&(ctx->md),0,sizeof(ctx->md));
memset((char *)&(ctx->cipher),0,sizeof(ctx->cipher));
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
return(ret);
}
#else /* !NO_RSA */
int i,ret=0;
unsigned int m_len;
- m=(unsigned char *)Malloc(EVP_PKEY_size(pkey)+2);
+ m=(unsigned char *)OPENSSL_malloc(EVP_PKEY_size(pkey)+2);
if (m == NULL)
{
PEMerr(PEM_F_PEM_SIGNFINAL,ERR_R_MALLOC_FAILURE);
ret=1;
err:
/* ctx has been zeroed by EVP_SignFinal() */
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
return 0;
}
ret = PKCS12_add_friendlyname_uni (bag, uniname, unilen);
- Free(uniname);
+ OPENSSL_free(uniname);
return ret;
}
ERR_R_MALLOC_FAILURE);
return 0;
}
- if (!(bmp->data = Malloc (namelen))) {
+ if (!(bmp->data = OPENSSL_malloc (namelen))) {
PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free (a->type);
- Free (a);
+ OPENSSL_free (a);
}
/* Encrypt/Decrypt a buffer based on password and algor, result in a
- * Malloc'ed buffer
+ * OPENSSL_malloc'ed buffer
*/
unsigned char * PKCS12_pbe_crypt (X509_ALGOR *algor, const char *pass,
return NULL;
}
- if(!(out = Malloc (inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
+ if(!(out = OPENSSL_malloc (inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_MALLOC_FAILURE);
return NULL;
}
EVP_CipherUpdate (&ctx, out, &i, in, inlen);
outlen = i;
if(!EVP_CipherFinal (&ctx, out + i, &i)) {
- Free (out);
+ OPENSSL_free (out);
PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,PKCS12_R_PKCS12_CIPHERFINAL_ERROR);
return NULL;
}
else ret = d2i(NULL, &p, outlen);
if (seq & 2) memset(out, 0, outlen);
if(!ret) PKCS12err(PKCS12_F_PKCS12_DECRYPT_D2I,PKCS12_R_DECODE_ERROR);
- Free (out);
+ OPENSSL_free (out);
return ret;
}
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,PKCS12_R_ENCODE_ERROR);
return NULL;
}
- if (!(in = Malloc (inlen))) {
+ if (!(in = OPENSSL_malloc (inlen))) {
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!PKCS12_pbe_crypt (algor, pass, passlen, in, inlen, &oct->data,
&oct->length, 1)) {
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,PKCS12_R_ENCRYPT_ERROR);
- Free(in);
+ OPENSSL_free(in);
return NULL;
}
- Free (in);
+ OPENSSL_free (in);
return oct;
}
id, iter, n, out, md_type);
if(unipass) {
memset(unipass, 0, uniplen); /* Clear password from memory */
- Free(unipass);
+ OPENSSL_free(unipass);
}
return ret;
}
#endif
v = EVP_MD_block_size (md_type);
u = EVP_MD_size (md_type);
- D = Malloc (v);
- Ai = Malloc (u);
- B = Malloc (v + 1);
+ D = OPENSSL_malloc (v);
+ Ai = OPENSSL_malloc (u);
+ B = OPENSSL_malloc (v + 1);
Slen = v * ((saltlen+v-1)/v);
if(passlen) Plen = v * ((passlen+v-1)/v);
else Plen = 0;
Ilen = Slen + Plen;
- I = Malloc (Ilen);
+ I = OPENSSL_malloc (Ilen);
Ij = BN_new();
Bpl1 = BN_new();
if (!D || !Ai || !B || !I || !Ij || !Bpl1) {
}
memcpy (out, Ai, min (n, u));
if (u >= n) {
- Free (Ai);
- Free (B);
- Free (D);
- Free (I);
+ OPENSSL_free (Ai);
+ OPENSSL_free (B);
+ OPENSSL_free (D);
+ OPENSSL_free (I);
BN_free (Ij);
BN_free (Bpl1);
#ifdef DEBUG_KEYGEN
M_ASN1_INTEGER_free(a->version);
PKCS12_MAC_DATA_free (a->mac);
PKCS7_free (a->authsafes);
- Free (a);
+ OPENSSL_free (a);
}
X509_SIG_free (a->dinfo);
M_ASN1_OCTET_STRING_free(a->salt);
M_ASN1_INTEGER_free(a->iter);
- Free (a);
+ OPENSSL_free (a);
}
}
if (!saltlen) saltlen = PKCS12_SALT_LEN;
p12->mac->salt->length = saltlen;
- if (!(p12->mac->salt->data = Malloc (saltlen))) {
+ if (!(p12->mac->salt->data = OPENSSL_malloc (saltlen))) {
PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free (a->type);
sk_X509_ATTRIBUTE_pop_free (a->attrib, X509_ATTRIBUTE_free);
- Free (a);
+ OPENSSL_free (a);
}
IMPLEMENT_STACK_OF(PKCS12_SAFEBAG)
int ulen, i;
unsigned char *unitmp;
ulen = strlen(asc)*2 + 2;
- if (!(unitmp = Malloc (ulen))) return NULL;
+ if (!(unitmp = OPENSSL_malloc (ulen))) return NULL;
for (i = 0; i < ulen; i+=2) {
unitmp[i] = 0;
unitmp[i + 1] = asc[i>>1];
/* If no terminating zero allow for one */
if (uni[unilen - 1]) asclen++;
uni++;
- if (!(asctmp = Malloc (asclen))) return NULL;
+ if (!(asctmp = OPENSSL_malloc (asclen))) return NULL;
for (i = 0; i < unilen; i+=2) asctmp[i>>1] = uni[i];
asctmp[asclen - 1] = 0;
return asctmp;
} PKCS12_SAFEBAG;
DECLARE_STACK_OF(PKCS12_SAFEBAG)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_PKCS12_SAFEBAG_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_PKCS12_SAFEBAG_new_null() sk_new_null()
+ #define sk_PKCS12_SAFEBAG_free(a) sk_free(a)
+ #define sk_PKCS12_SAFEBAG_num(a) sk_num(a)
+ #define sk_PKCS12_SAFEBAG_value(a,b) ((PKCS12_SAFEBAG *) \
+ sk_value((a),(b)))
+ #define sk_PKCS12_SAFEBAG_set(a,b,c) ((PKCS12_SAFEBAG *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_PKCS12_SAFEBAG_zero(a) sk_zero(a)
+ #define sk_PKCS12_SAFEBAG_push(a,b) sk_push((a),(char *)(b))
+ #define sk_PKCS12_SAFEBAG_unshift(a,b) sk_unshift((a),(b))
+ #define sk_PKCS12_SAFEBAG_find(a,b) sk_find((a), (char *)(b))
+ #define sk_PKCS12_SAFEBAG_delete(a,b) ((PKCS12_SAFEBAG *) \
+ sk_delete((a),(b)))
+ #define sk_PKCS12_SAFEBAG_delete_ptr(a,b) ((PKCS12_SAFEBAG *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_PKCS12_SAFEBAG_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_PKCS12_SAFEBAG_set_cmp_func(a,b) ((int (*) \
+ (const PKCS12_SAFEBAG * const *,const PKCS12_SAFEBAG * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_PKCS12_SAFEBAG_dup(a) sk_dup(a)
+ #define sk_PKCS12_SAFEBAG_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_PKCS12_SAFEBAG_shift(a) ((PKCS12_SAFEBAG *)sk_shift(a))
+ #define sk_PKCS12_SAFEBAG_pop(a) ((PKCS12_SAFEBAG *)sk_pop(a))
+ #define sk_PKCS12_SAFEBAG_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(PKCS12_SAFEBAG)
DECLARE_PKCS12_STACK_OF(PKCS12_SAFEBAG)
{
BIO_BER_CTX *ctx;
- ctx=(BIO_BER_CTX *)Malloc(sizeof(BIO_BER_CTX));
+ ctx=(BIO_BER_CTX *)OPENSSL_malloc(sizeof(BIO_BER_CTX));
if (ctx == NULL) return(0);
memset((char *)ctx,0,sizeof(BIO_BER_CTX));
if (a == NULL) return(0);
b=(BIO_BER_CTX *)a->ptr;
memset(a->ptr,0,sizeof(BIO_BER_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
len=i2d_ASN1_SET_OF_X509_ALGOR(cap,NULL,i2d_X509_ALGOR,
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL,
IS_SEQUENCE);
- if(!(pp=(unsigned char *)Malloc(len))) {
+ if(!(pp=(unsigned char *)OPENSSL_malloc(len))) {
PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
return 0;
}
PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
return 0;
}
- Free (pp);
+ OPENSSL_free (pp);
return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities,
V_ASN1_SEQUENCE, seq);
}
EVP_PKEY_free(pkey);
if (max < jj) max=jj;
}
- if ((tmp=(unsigned char *)Malloc(max)) == NULL)
+ if ((tmp=(unsigned char *)OPENSSL_malloc(max)) == NULL)
{
PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_MALLOC_FAILURE);
goto err;
if (jj <= 0)
{
PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_EVP_LIB);
- Free(tmp);
+ OPENSSL_free(tmp);
goto err;
}
M_ASN1_OCTET_STRING_set(ri->enc_key,tmp,jj);
}
- Free(tmp);
+ OPENSSL_free(tmp);
memset(key, 0, keylen);
if (out == NULL)
}
jj=EVP_PKEY_size(pkey);
- tmp=(unsigned char *)Malloc(jj+10);
+ tmp=(unsigned char *)OPENSSL_malloc(jj+10);
if (tmp == NULL)
{
PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_MALLOC_FAILURE);
out=NULL;
}
if (tmp != NULL)
- Free(tmp);
+ OPENSSL_free(tmp);
return(out);
}
x=i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,NULL,
i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
- pp=(unsigned char *)Malloc(x);
+ pp=(unsigned char *)OPENSSL_malloc(x);
p=pp;
i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,&p,
i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
EVP_SignUpdate(&ctx_tmp,pp,x);
- Free(pp);
+ OPENSSL_free(pp);
pp=NULL;
}
(unsigned char *)buf_mem->data,buf_mem->length);
#endif
}
- if (pp != NULL) Free(pp);
+ if (pp != NULL) OPENSSL_free(pp);
pp=NULL;
ret=1;
*/
i=i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,NULL,i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL, IS_SEQUENCE);
- pp=Malloc(i);
+ pp=OPENSSL_malloc(i);
p=pp;
i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,&p,i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL, IS_SEQUENCE);
EVP_VerifyUpdate(&mdc_tmp,pp,i);
- Free(pp);
+ OPENSSL_free(pp);
}
os=si->enc_digest;
char *param_value; /* Param value e.g. "sha1" */
} MIME_PARAM;
+DECLARE_STACK_OF(MIME_PARAM)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_MIME_PARAM_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_MIME_PARAM_new_null() sk_new_null()
+ #define sk_MIME_PARAM_free(a) sk_free(a)
+ #define sk_MIME_PARAM_num(a) sk_num(a)
+ #define sk_MIME_PARAM_value(a,b) ((MIME_PARAM *) \
+ sk_value((a),(b)))
+ #define sk_MIME_PARAM_set(a,b,c) ((MIME_PARAM *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_MIME_PARAM_zero(a) sk_zero(a)
+ #define sk_MIME_PARAM_push(a,b) sk_push((a),(char *)(b))
+ #define sk_MIME_PARAM_unshift(a,b) sk_unshift((a),(b))
+ #define sk_MIME_PARAM_find(a,b) sk_find((a), (char *)(b))
+ #define sk_MIME_PARAM_delete(a,b) ((MIME_PARAM *) \
+ sk_delete((a),(b)))
+ #define sk_MIME_PARAM_delete_ptr(a,b) ((MIME_PARAM *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_MIME_PARAM_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_MIME_PARAM_set_cmp_func(a,b) ((int (*) \
+ (const MIME_PARAM * const *,const MIME_PARAM * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_MIME_PARAM_dup(a) sk_dup(a)
+ #define sk_MIME_PARAM_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_MIME_PARAM_shift(a) ((MIME_PARAM *)sk_shift(a))
+ #define sk_MIME_PARAM_pop(a) ((MIME_PARAM *)sk_pop(a))
+ #define sk_MIME_PARAM_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
IMPLEMENT_STACK_OF(MIME_PARAM)
typedef struct {
STACK_OF(MIME_PARAM) *params; /* Zero or more parameters */
} MIME_HEADER;
+DECLARE_STACK_OF(MIME_HEADER)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_MIME_HEADER_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_MIME_HEADER_new_null() sk_new_null()
+ #define sk_MIME_HEADER_free(a) sk_free(a)
+ #define sk_MIME_HEADER_num(a) sk_num(a)
+ #define sk_MIME_HEADER_value(a,b) ((MIME_HEADER *) \
+ sk_value((a),(b)))
+ #define sk_MIME_HEADER_set(a,b,c) ((MIME_HEADER *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_MIME_HEADER_zero(a) sk_zero(a)
+ #define sk_MIME_HEADER_push(a,b) sk_push((a),(char *)(b))
+ #define sk_MIME_HEADER_unshift(a,b) sk_unshift((a),(b))
+ #define sk_MIME_HEADER_find(a,b) sk_find((a), (char *)(b))
+ #define sk_MIME_HEADER_delete(a,b) ((MIME_HEADER *) \
+ sk_delete((a),(b)))
+ #define sk_MIME_HEADER_delete_ptr(a,b) ((MIME_HEADER *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_MIME_HEADER_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_MIME_HEADER_set_cmp_func(a,b) ((int (*) \
+ (const MIME_HEADER * const *,const MIME_HEADER * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_MIME_HEADER_dup(a) sk_dup(a)
+ #define sk_MIME_HEADER_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_MIME_HEADER_shift(a) ((MIME_HEADER *)sk_shift(a))
+ #define sk_MIME_HEADER_pop(a) ((MIME_HEADER *)sk_pop(a))
+ #define sk_MIME_HEADER_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
IMPLEMENT_STACK_OF(MIME_HEADER)
static int B64_write_PKCS7(BIO *bio, PKCS7 *p7);
static MIME_HEADER *mime_hdr_new(char *name, char *value);
static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value);
static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio);
-static int mime_hdr_cmp(MIME_HEADER **a, MIME_HEADER **b);
-static int mime_param_cmp(MIME_PARAM **a, MIME_PARAM **b);
+static int mime_hdr_cmp(const MIME_HEADER * const *a,
+ const MIME_HEADER * const *b);
+static int mime_param_cmp(const MIME_PARAM * const *a,
+ const MIME_PARAM * const *b);
static void mime_param_free(MIME_PARAM *param);
static int mime_bound_check(char *line, int linelen, char *bound, int blen);
static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret);
}
}
} else tmpval = NULL;
- mhdr = (MIME_HEADER *) Malloc(sizeof(MIME_HEADER));
+ mhdr = (MIME_HEADER *) OPENSSL_malloc(sizeof(MIME_HEADER));
if(!mhdr) return NULL;
mhdr->name = tmpname;
mhdr->value = tmpval;
if(!tmpval) return 0;
} else tmpval = NULL;
/* Parameter values are case sensitive so leave as is */
- mparam = (MIME_PARAM *) Malloc(sizeof(MIME_PARAM));
+ mparam = (MIME_PARAM *) OPENSSL_malloc(sizeof(MIME_PARAM));
if(!mparam) return 0;
mparam->param_name = tmpname;
mparam->param_value = tmpval;
return 1;
}
-static int mime_hdr_cmp(MIME_HEADER **a, MIME_HEADER **b)
+static int mime_hdr_cmp(const MIME_HEADER * const *a,
+ const MIME_HEADER * const *b)
{
return(strcmp((*a)->name, (*b)->name));
}
-static int mime_param_cmp(MIME_PARAM **a, MIME_PARAM **b)
+static int mime_param_cmp(const MIME_PARAM * const *a,
+ const MIME_PARAM * const *b)
{
return(strcmp((*a)->param_name, (*b)->param_name));
}
static void mime_hdr_free(MIME_HEADER *hdr)
{
- if(hdr->name) Free(hdr->name);
- if(hdr->value) Free(hdr->value);
+ if(hdr->name) OPENSSL_free(hdr->name);
+ if(hdr->value) OPENSSL_free(hdr->value);
if(hdr->params) sk_MIME_PARAM_pop_free(hdr->params, mime_param_free);
- Free(hdr);
+ OPENSSL_free(hdr);
}
static void mime_param_free(MIME_PARAM *param)
{
- if(param->param_name) Free(param->param_name);
- if(param->param_value) Free(param->param_value);
- Free(param);
+ if(param->param_name) OPENSSL_free(param->param_name);
+ if(param->param_value) OPENSSL_free(param->param_value);
+ OPENSSL_free(param);
}
/* Check for a multipart boundary. Returns:
} PKCS7_SIGNER_INFO;
DECLARE_STACK_OF(PKCS7_SIGNER_INFO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_PKCS7_SIGNER_INFO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_PKCS7_SIGNER_INFO_new_null() sk_new_null()
+ #define sk_PKCS7_SIGNER_INFO_free(a) sk_free(a)
+ #define sk_PKCS7_SIGNER_INFO_num(a) sk_num(a)
+ #define sk_PKCS7_SIGNER_INFO_value(a,b) ((PKCS7_SIGNER_INFO *) \
+ sk_value((a),(b)))
+ #define sk_PKCS7_SIGNER_INFO_set(a,b,c) ((PKCS7_SIGNER_INFO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_PKCS7_SIGNER_INFO_zero(a) sk_zero(a)
+ #define sk_PKCS7_SIGNER_INFO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_PKCS7_SIGNER_INFO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_PKCS7_SIGNER_INFO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_PKCS7_SIGNER_INFO_delete(a,b) ((PKCS7_SIGNER_INFO *) \
+ sk_delete((a),(b)))
+ #define sk_PKCS7_SIGNER_INFO_delete_ptr(a,b) ((PKCS7_SIGNER_INFO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_PKCS7_SIGNER_INFO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_PKCS7_SIGNER_INFO_set_cmp_func(a,b) ((int (*) \
+ (const PKCS7_SIGNER_INFO * const *,const PKCS7_SIGNER_INFO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_PKCS7_SIGNER_INFO_dup(a) sk_dup(a)
+ #define sk_PKCS7_SIGNER_INFO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_PKCS7_SIGNER_INFO_shift(a) ((PKCS7_SIGNER_INFO *)sk_shift(a))
+ #define sk_PKCS7_SIGNER_INFO_pop(a) ((PKCS7_SIGNER_INFO *)sk_pop(a))
+ #define sk_PKCS7_SIGNER_INFO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO)
typedef struct pkcs7_recip_info_st
} PKCS7_RECIP_INFO;
DECLARE_STACK_OF(PKCS7_RECIP_INFO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_PKCS7_RECIP_INFO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_PKCS7_RECIP_INFO_new_null() sk_new_null()
+ #define sk_PKCS7_RECIP_INFO_free(a) sk_free(a)
+ #define sk_PKCS7_RECIP_INFO_num(a) sk_num(a)
+ #define sk_PKCS7_RECIP_INFO_value(a,b) ((PKCS7_RECIP_INFO *) \
+ sk_value((a),(b)))
+ #define sk_PKCS7_RECIP_INFO_set(a,b,c) ((PKCS7_RECIP_INFO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_PKCS7_RECIP_INFO_zero(a) sk_zero(a)
+ #define sk_PKCS7_RECIP_INFO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_PKCS7_RECIP_INFO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_PKCS7_RECIP_INFO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_PKCS7_RECIP_INFO_delete(a,b) ((PKCS7_RECIP_INFO *) \
+ sk_delete((a),(b)))
+ #define sk_PKCS7_RECIP_INFO_delete_ptr(a,b) ((PKCS7_RECIP_INFO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_PKCS7_RECIP_INFO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_PKCS7_RECIP_INFO_set_cmp_func(a,b) ((int (*) \
+ (const PKCS7_RECIP_INFO * const *,const PKCS7_RECIP_INFO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_PKCS7_RECIP_INFO_dup(a) sk_dup(a)
+ #define sk_PKCS7_RECIP_INFO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_PKCS7_RECIP_INFO_shift(a) ((PKCS7_RECIP_INFO *)sk_shift(a))
+ #define sk_PKCS7_RECIP_INFO_pop(a) ((PKCS7_RECIP_INFO *)sk_pop(a))
+ #define sk_PKCS7_RECIP_INFO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO)
typedef struct pkcs7_signed_st
} PKCS7;
DECLARE_STACK_OF(PKCS7)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_PKCS7_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_PKCS7_new_null() sk_new_null()
+ #define sk_PKCS7_free(a) sk_free(a)
+ #define sk_PKCS7_num(a) sk_num(a)
+ #define sk_PKCS7_value(a,b) ((PKCS7 *) \
+ sk_value((a),(b)))
+ #define sk_PKCS7_set(a,b,c) ((PKCS7 *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_PKCS7_zero(a) sk_zero(a)
+ #define sk_PKCS7_push(a,b) sk_push((a),(char *)(b))
+ #define sk_PKCS7_unshift(a,b) sk_unshift((a),(b))
+ #define sk_PKCS7_find(a,b) sk_find((a), (char *)(b))
+ #define sk_PKCS7_delete(a,b) ((PKCS7 *) \
+ sk_delete((a),(b)))
+ #define sk_PKCS7_delete_ptr(a,b) ((PKCS7 *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_PKCS7_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_PKCS7_set_cmp_func(a,b) ((int (*) \
+ (const PKCS7 * const *,const PKCS7 * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_PKCS7_dup(a) sk_dup(a)
+ #define sk_PKCS7_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_PKCS7_shift(a) ((PKCS7 *)sk_shift(a))
+ #define sk_PKCS7_pop(a) ((PKCS7 *)sk_pop(a))
+ #define sk_PKCS7_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(PKCS7)
DECLARE_PKCS12_STACK_OF(PKCS7)
APPS=
LIB=$(TOP)/libcrypto.a
-LIBSRC=md_rand.c randfile.c rand_lib.c rand_err.c rand_egd.c
-LIBOBJ=md_rand.o randfile.o rand_lib.o rand_err.o rand_egd.o
+LIBSRC=md_rand.c randfile.c rand_lib.c rand_err.c rand_egd.c rand_win.c
+LIBOBJ=md_rand.o randfile.o rand_lib.o rand_err.o rand_egd.o rand_win.o
SRC= $(LIBSRC)
*
*/
-#define ENTROPY_NEEDED 16 /* require 128 bits = 16 bytes of randomness */
+#define ENTROPY_NEEDED 20 /* require 160 bits = 20 bytes of randomness */
-#ifndef MD_RAND_DEBUG
+#ifdef MD_RAND_DEBUG
# ifndef NDEBUG
# define NDEBUG
# endif
ssleay_rand_add(buf, num, num);
}
-static void ssleay_rand_initialize(void)
+static void ssleay_rand_initialize(void) /* not exported in RAND_METHOD */
{
unsigned long l;
#ifndef GETPID_IS_MEANINGLESS
static int ssleay_rand_bytes(unsigned char *buf, int num)
{
+ static volatile int stirred_pool = 0;
int i,j,k,st_num,st_idx;
int ok;
long md_c[2];
#ifndef GETPID_IS_MEANINGLESS
pid_t curr_pid = getpid();
#endif
+ int do_stir_pool = 0;
#ifdef PREDICT
if (rand_predictable)
if (!initialized)
ssleay_rand_initialize();
+ if (!stirred_pool)
+ do_stir_pool = 1;
+
ok = (entropy >= ENTROPY_NEEDED);
if (!ok)
{
* Once we've had enough initial seeding we don't bother to
* adjust the entropy count, though, because we're not ambitious
* to provide *information-theoretic* randomness.
+ *
+ * NOTE: This approach fails if the program forks before
+ * we have enough entropy. Entropy should be collected
+ * in a separate input pool and be transferred to the
+ * output pool only when the entropy limit has been reached.
*/
entropy -= num;
if (entropy < 0)
entropy = 0;
}
+ if (do_stir_pool)
+ {
+ /* Our output function chains only half of 'md', so we better
+ * make sure that the required entropy gets 'evenly distributed'
+ * through 'state', our randomness pool. The input function
+ * (ssleay_rand_add) chains all of 'md', which makes it more
+ * suitable for this purpose.
+ */
+
+ int n = STATE_SIZE; /* so that the complete pool gets accessed */
+ while (n > 0)
+ {
+#if MD_DIGEST_LENGTH > 20
+# error "Please adjust DUMMY_SEED."
+#endif
+#define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */
+ /* Note that the seed does not matter, it's just that
+ * ssleay_rand_add expects to have something to hash. */
+ ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);
+ n -= MD_DIGEST_LENGTH;
+ }
+ if (ok)
+ stirred_pool = 1;
+ }
+
st_idx=state_index;
st_num=state_num;
md_c[0] = md_count[0];
return ret;
}
-
-#ifdef WINDOWS
-#include <windows.h>
-#include <openssl/rand.h>
-
-int RAND_event(UINT iMsg, WPARAM wParam, LPARAM lParam)
- {
- double add_entropy=0;
- SYSTEMTIME t;
-
- switch (iMsg)
- {
- case WM_KEYDOWN:
- {
- static WPARAM key;
- if (key != wParam)
- add_entropy = 0.05;
- key = wParam;
- }
- break;
- case WM_MOUSEMOVE:
- {
- static int lastx,lasty,lastdx,lastdy;
- int x,y,dx,dy;
-
- x=LOWORD(lParam);
- y=HIWORD(lParam);
- dx=lastx-x;
- dy=lasty-y;
- if (dx != 0 && dy != 0 && dx-lastdx != 0 && dy-lastdy != 0)
- add_entropy=.2;
- lastx=x, lasty=y;
- lastdx=dx, lastdy=dy;
- }
- break;
- }
-
- GetSystemTime(&t);
- RAND_add(&iMsg, sizeof(iMsg), add_entropy);
- RAND_add(&wParam, sizeof(wParam), 0);
- RAND_add(&lParam, sizeof(lParam), 0);
- RAND_add(&t, sizeof(t), 0);
-
- return (RAND_status());
- }
-
-/*****************************************************************************
- * Initialisation function for the SSL random generator. Takes the contents
- * of the screen as random seed.
- *
- * Created 960901 by Gertjan van Oosten, gertjan@West.NL, West Consulting B.V.
- *
- * Code adapted from
- * <URL:http://www.microsoft.com/kb/developr/win_dk/q97193.htm>;
- * the original copyright message is:
- *
- * (C) Copyright Microsoft Corp. 1993. All rights reserved.
- *
- * You have a royalty-free right to use, modify, reproduce and
- * distribute the Sample Files (and/or any modified version) in
- * any way you find useful, provided that you agree that
- * Microsoft has no warranty obligations or liability for any
- * Sample Application Files which are modified.
- */
-/*
- * I have modified the loading of bytes via RAND_seed() mechanism since
- * the original would have been very very CPU intensive since RAND_seed()
- * does an MD5 per 16 bytes of input. The cost to digest 16 bytes is the same
- * as that to digest 56 bytes. So under the old system, a screen of
- * 1024*768*256 would have been CPU cost of approximately 49,000 56 byte MD5
- * digests or digesting 2.7 mbytes. What I have put in place would
- * be 48 16k MD5 digests, or effectively 48*16+48 MD5 bytes or 816 kbytes
- * or about 3.5 times as much.
- * - eric
- */
-void RAND_screen(void)
-{
- HDC hScrDC; /* screen DC */
- HDC hMemDC; /* memory DC */
- HBITMAP hBitmap; /* handle for our bitmap */
- HBITMAP hOldBitmap; /* handle for previous bitmap */
- BITMAP bm; /* bitmap properties */
- unsigned int size; /* size of bitmap */
- char *bmbits; /* contents of bitmap */
- int w; /* screen width */
- int h; /* screen height */
- int y; /* y-coordinate of screen lines to grab */
- int n = 16; /* number of screen lines to grab at a time */
-
- /* Create a screen DC and a memory DC compatible to screen DC */
- hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
- hMemDC = CreateCompatibleDC(hScrDC);
-
- /* Get screen resolution */
- w = GetDeviceCaps(hScrDC, HORZRES);
- h = GetDeviceCaps(hScrDC, VERTRES);
-
- /* Create a bitmap compatible with the screen DC */
- hBitmap = CreateCompatibleBitmap(hScrDC, w, n);
-
- /* Select new bitmap into memory DC */
- hOldBitmap = SelectObject(hMemDC, hBitmap);
-
- /* Get bitmap properties */
- GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
- size = (unsigned int)bm.bmWidthBytes * bm.bmHeight * bm.bmPlanes;
-
- bmbits = Malloc(size);
- if (bmbits) {
- /* Now go through the whole screen, repeatedly grabbing n lines */
- for (y = 0; y < h-n; y += n)
- {
- unsigned char md[MD_DIGEST_LENGTH];
-
- /* Bitblt screen DC to memory DC */
- BitBlt(hMemDC, 0, 0, w, n, hScrDC, 0, y, SRCCOPY);
-
- /* Copy bitmap bits from memory DC to bmbits */
- GetBitmapBits(hBitmap, size, bmbits);
-
- /* Get the MD5 of the bitmap */
- MD(bmbits,size,md);
-
- /* Seed the random generator with the MD5 digest */
- RAND_seed(md, MD_DIGEST_LENGTH);
- }
-
- Free(bmbits);
- }
-
- /* Select old bitmap back into memory DC */
- hBitmap = SelectObject(hMemDC, hOldBitmap);
-
- /* Clean up */
- DeleteObject(hBitmap);
- DeleteDC(hMemDC);
- DeleteDC(hScrDC);
-}
-#endif
const char *RAND_file_name(char *file,int num);
int RAND_status(void);
int RAND_egd(const char *path);
+int RAND_egd_bytes(const char *path,int bytes);
void ERR_load_RAND_strings(void);
#ifdef __cplusplus
{
return(-1);
}
+
+int RAND_egd_bytes(const char *path,int bytes)
+ {
+ return(-1);
+ }
#else
#include <openssl/opensslconf.h>
#include OPENSSL_UNISTD
if (fd != -1) close(fd);
return(ret);
}
+
+int RAND_egd_bytes(const char *path,int bytes)
+ {
+ int ret = 0;
+ struct sockaddr_un addr;
+ int len, num;
+ int fd = -1;
+ unsigned char buf[255];
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ if (strlen(path) > sizeof(addr.sun_path))
+ return (-1);
+ strcpy(addr.sun_path,path);
+ len = offsetof(struct sockaddr_un, sun_path) + strlen(path);
+ fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (fd == -1) return (-1);
+ if (connect(fd, (struct sockaddr *)&addr, len) == -1) goto err;
+
+ while(bytes > 0)
+ {
+ buf[0] = 1;
+ buf[1] = bytes < 255 ? bytes : 255;
+ write(fd, buf, 2);
+ if (read(fd, buf, 1) != 1)
+ {
+ ret=-1;
+ goto err;
+ }
+ if(buf[0] == 0)
+ goto err;
+ num = read(fd, buf, buf[0]);
+ if (num < 1)
+ {
+ ret=-1;
+ goto err;
+ }
+ RAND_seed(buf, num);
+ if (RAND_status() != 1)
+ {
+ ret=-1;
+ goto err;
+ }
+ ret += num;
+ bytes-=num;
+ }
+ err:
+ if (fd != -1) close(fd);
+ return(ret);
+ }
+
+
#endif
{
char *tmpf;
- tmpf = Malloc(strlen(file) + 4); /* to add ";-1" and a nul */
+ tmpf = OPENSSL_malloc(strlen(file) + 4); /* to add ";-1" and a nul */
if (tmpf)
{
strcpy(tmpf, file);
} RC2_KEY;
-void RC2_set_key(RC2_KEY *key, int len, unsigned char *data,int bits);
-void RC2_ecb_encrypt(unsigned char *in,unsigned char *out,RC2_KEY *key,
- int enc);
+void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data,int bits);
+void RC2_ecb_encrypt(const unsigned char *in,unsigned char *out,RC2_KEY *key,
+ int enc);
void RC2_encrypt(unsigned long *data,RC2_KEY *key);
void RC2_decrypt(unsigned long *data,RC2_KEY *key);
-void RC2_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
RC2_KEY *ks, unsigned char *iv, int enc);
-void RC2_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC2_KEY *schedule, unsigned char *ivec, int *num, int enc);
-void RC2_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC2_KEY *schedule, unsigned char *ivec, int *num);
+void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC2_KEY *schedule, unsigned char *ivec,
+ int *num, int enc);
+void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC2_KEY *schedule, unsigned char *ivec,
+ int *num);
#ifdef __cplusplus
}
#include <openssl/rc2.h>
#include "rc2_locl.h"
-void RC2_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
RC2_KEY *ks, unsigned char *iv, int encrypt)
{
register unsigned long tin0,tin1;
* Date: 11 Feb 1996 06:45:03 GMT
*/
-void RC2_ecb_encrypt(unsigned char *in, unsigned char *out, RC2_KEY *ks,
- int encrypt)
+void RC2_ecb_encrypt(const unsigned char *in, unsigned char *out, RC2_KEY *ks,
+ int encrypt)
{
unsigned long l,d[2];
* BSAFE uses the 'retarded' version. What I previously shipped is
* the same as specifying 1024 for the 'bits' parameter. Bsafe uses
* a version where the bits parameter is the same as len*8 */
-void RC2_set_key(RC2_KEY *key, int len, unsigned char *data, int bits)
+void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, int bits)
{
int i,j;
unsigned char *k;
* 64bit block we have used is contained in *num;
*/
-void RC2_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC2_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
+void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC2_KEY *schedule, unsigned char *ivec,
+ int *num, int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void RC2_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC2_KEY *schedule, unsigned char *ivec, int *num)
+void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC2_KEY *schedule, unsigned char *ivec,
+ int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
} RC5_32_KEY;
-void RC5_32_set_key(RC5_32_KEY *key, int len, unsigned char *data,
+void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data,
int rounds);
-void RC5_32_ecb_encrypt(unsigned char *in,unsigned char *out,RC5_32_KEY *key,
+void RC5_32_ecb_encrypt(const unsigned char *in,unsigned char *out,RC5_32_KEY *key,
int enc);
void RC5_32_encrypt(unsigned long *data,RC5_32_KEY *key);
void RC5_32_decrypt(unsigned long *data,RC5_32_KEY *key);
-void RC5_32_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *ks, unsigned char *iv, int enc);
-void RC5_32_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *schedule, unsigned char *ivec, int *num, int enc);
-void RC5_32_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *schedule, unsigned char *ivec, int *num);
+void RC5_32_cbc_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *ks, unsigned char *iv,
+ int enc);
+void RC5_32_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *schedule,
+ unsigned char *ivec, int *num, int enc);
+void RC5_32_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *schedule,
+ unsigned char *ivec, int *num);
#ifdef __cplusplus
}
char *RC5_version="RC5" OPENSSL_VERSION_PTEXT;
-void RC5_32_ecb_encrypt(unsigned char *in, unsigned char *out, RC5_32_KEY *ks,
- int encrypt)
+void RC5_32_ecb_encrypt(const unsigned char *in, unsigned char *out,
+ RC5_32_KEY *ks, int encrypt)
{
unsigned long l,d[2];
#include <openssl/rc5.h>
#include "rc5_locl.h"
-void RC5_32_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *ks, unsigned char *iv, int encrypt)
+void RC5_32_cbc_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *ks, unsigned char *iv,
+ int encrypt)
{
register unsigned long tin0,tin1;
register unsigned long tout0,tout1,xor0,xor1;
#include <openssl/rc5.h>
#include "rc5_locl.h"
-void RC5_32_set_key(RC5_32_KEY *key, int len, unsigned char *data,
- int rounds)
+void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data,
+ int rounds)
{
RC5_32_INT L[64],l,ll,A,B,*S,k;
int i,j,m,c,t,ii,jj;
* 64bit block we have used is contained in *num;
*/
-void RC5_32_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
+void RC5_32_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *schedule,
+ unsigned char *ivec, int *num, int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void RC5_32_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
- RC5_32_KEY *schedule, unsigned char *ivec, int *num)
+void RC5_32_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, RC5_32_KEY *schedule,
+ unsigned char *ivec, int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
BN_init(&ret);
if ((ctx=BN_CTX_new()) == NULL) goto err;
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
if ((ctx=BN_CTX_new()) == NULL) goto err;
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
if (ctx == NULL) goto err;
num=BN_num_bytes(rsa->n);
- buf=(unsigned char *)Malloc(num);
+ buf=(unsigned char *)OPENSSL_malloc(num);
if (buf == NULL)
{
RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
* unsigned long can be larger */
for (i=0; i<sizeof(unsigned long)*8; i++)
{
- if (e_value & (1<<i))
+ if (e_value & (1UL<<i))
BN_set_bit(rsa->e,i);
}
#else
RSA_METHOD *meth;
RSA *ret;
- ret=(RSA *)Malloc(sizeof(RSA));
+ ret=(RSA *)OPENSSL_malloc(sizeof(RSA));
if (ret == NULL)
{
RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
ret->flags=meth->flags;
if ((meth->init != NULL) && !meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
if (r->iqmp != NULL) BN_clear_free(r->iqmp);
if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
- if (r->bignum_data != NULL) Free_locked(r->bignum_data);
- Free(r);
+ if (r->bignum_data != NULL) OPENSSL_free_locked(r->bignum_data);
+ OPENSSL_free(r);
}
int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
j=1;
for (i=0; i<6; i++)
j+= (*t[i])->top;
- if ((p=Malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
+ if ((p=OPENSSL_malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
{
RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
return(0);
return (0);
}
- dbmask = Malloc(emlen - SHA_DIGEST_LENGTH);
+ dbmask = OPENSSL_malloc(emlen - SHA_DIGEST_LENGTH);
if (dbmask == NULL)
{
RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
seed[i] ^= seedmask[i];
- Free(dbmask);
+ OPENSSL_free(dbmask);
return (1);
}
}
dblen = num - SHA_DIGEST_LENGTH;
- db = Malloc(dblen);
+ db = OPENSSL_malloc(dblen);
if (db == NULL)
{
RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
memcpy(to, db + i, mlen);
}
}
- Free(db);
+ OPENSSL_free(db);
return (mlen);
}
RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
return(0);
}
- s=(unsigned char *)Malloc((unsigned int)j+1);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)j+1);
if (s == NULL)
{
RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE);
*siglen=i;
memset(s,0,(unsigned int)j+1);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
return(0);
}
- s=(unsigned char *)Malloc((unsigned int)siglen);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)siglen);
if (s == NULL)
{
RSAerr(RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE);
err:
if (sig != NULL) M_ASN1_OCTET_STRING_free(sig);
memset(s,0,(unsigned int)siglen);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
return(0);
}
if(type != NID_md5_sha1) {
- s=(unsigned char *)Malloc((unsigned int)j+1);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)j+1);
if (s == NULL)
{
RSAerr(RSA_F_RSA_SIGN,ERR_R_MALLOC_FAILURE);
if(type != NID_md5_sha1) {
memset(s,0,(unsigned int)j+1);
- Free(s);
+ OPENSSL_free(s);
}
return(ret);
}
return ENGINE_get_RSA(rsa->engine)->rsa_verify(dtype,
m, m_len, sigbuf, siglen, rsa);
- s=(unsigned char *)Malloc((unsigned int)siglen);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)siglen);
if (s == NULL)
{
RSAerr(RSA_F_RSA_VERIFY,ERR_R_MALLOC_FAILURE);
err:
if (sig != NULL) X509_SIG_free(sig);
memset(s,0,(unsigned int)siglen);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
#include <openssl/stack.h>
+#ifdef DEBUG_SAFESTACK
+
#define STACK_OF(type) struct stack_st_##type
#define PREDECLARE_STACK_OF(type) STACK_OF(type);
{ \
STACK stack; \
}; \
-STACK_OF(type) *sk_##type##_new(int (*cmp)(type **,type **)); \
+STACK_OF(type) *sk_##type##_new(int (*cmp)(const type * const *, \
+ const type * const *)); \
STACK_OF(type) *sk_##type##_new_null(void); \
void sk_##type##_free(STACK_OF(type) *sk); \
int sk_##type##_num(const STACK_OF(type) *sk); \
int sk_##type##_unshift(STACK_OF(type) *sk,type *v); \
int sk_##type##_find(STACK_OF(type) *sk,type *v); \
type *sk_##type##_delete(STACK_OF(type) *sk,int n); \
-void sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v); \
+type *sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v); \
int sk_##type##_insert(STACK_OF(type) *sk,type *v,int n); \
int (*sk_##type##_set_cmp_func(STACK_OF(type) *sk, \
- int (*cmp)(type **,type **)))(type **,type **); \
+ int (*cmp)(const type * const *,const type * const *))) \
+ (const type * const *,const type * const *); \
STACK_OF(type) *sk_##type##_dup(STACK_OF(type) *sk); \
void sk_##type##_pop_free(STACK_OF(type) *sk,void (*func)(type *)); \
type *sk_##type##_shift(STACK_OF(type) *sk); \
void sk_##type##_sort(STACK_OF(type) *sk);
#define IMPLEMENT_STACK_OF(type) \
-STACK_OF(type) *sk_##type##_new(int (*cmp)(type **,type **)) \
- { return (STACK_OF(type) *)sk_new((int (*)())cmp); } \
+STACK_OF(type) *sk_##type##_new(int (*cmp)(const type * const *, \
+ const type * const *)) \
+ { return (STACK_OF(type) *)sk_new( \
+ (int (*)(const char * const *,const char * const *))cmp); } \
STACK_OF(type) *sk_##type##_new_null() \
{ return (STACK_OF(type) *)sk_new_null(); } \
void sk_##type##_free(STACK_OF(type) *sk) \
{ return sk_find((STACK *)sk,(char *)v); } \
type *sk_##type##_delete(STACK_OF(type) *sk,int n) \
{ return (type *)sk_delete((STACK *)sk,n); } \
-void sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v) \
- { sk_delete_ptr((STACK *)sk,(char *)v); } \
+type *sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v) \
+ { return (type *)sk_delete_ptr((STACK *)sk,(char *)v); } \
int sk_##type##_insert(STACK_OF(type) *sk,type *v,int n) \
{ return sk_insert((STACK *)sk,(char *)v,n); } \
int (*sk_##type##_set_cmp_func(STACK_OF(type) *sk, \
- int (*cmp)(type **,type **)))(type **,type **) \
- { return (int (*)(type **,type **))sk_set_cmp_func((STACK *)sk,(int(*)(const void *, const void *))cmp); } \
+ int (*cmp)(const type * const *,const type * const *))) \
+ (const type * const *,const type * const *) \
+ { return (int (*)(const type * const *,const type * const *))sk_set_cmp_func( \
+ (STACK *)sk, (int(*)(const char * const *, const char * const *))cmp); } \
STACK_OF(type) *sk_##type##_dup(STACK_OF(type) *sk) \
{ return (STACK_OF(type) *)sk_dup((STACK *)sk); } \
void sk_##type##_pop_free(STACK_OF(type) *sk,void (*func)(type *)) \
void sk_##type##_sort(STACK_OF(type) *sk) \
{ sk_sort((STACK *)sk); }
+#else
+
+#define STACK_OF(type) STACK
+#define PREDECLARE_STACK_OF(type) /* nada */
+#define DECLARE_STACK_OF(type) /* nada */
+#define IMPLEMENT_STACK_OF(type) /* nada */
+
+#endif
+
#endif /* ndef HEADER_SAFESTACK_H */
#include <errno.h>
-int (*sk_set_cmp_func(STACK *sk, int (*c)(const void *,const void *)))(const void *, const void *)
+int (*sk_set_cmp_func(STACK *sk, int (*c)(const char * const *,const char * const *)))
+ (const char * const *, const char * const *)
{
- int (*old)(const void *,const void *)=sk->comp;
+ int (*old)(const char * const *,const char * const *)=sk->comp;
if (sk->comp != c)
sk->sorted=0;
char **s;
if ((ret=sk_new(sk->comp)) == NULL) goto err;
- s=(char **)Realloc((char *)ret->data,
+ s=(char **)OPENSSL_realloc((char *)ret->data,
(unsigned int)sizeof(char *)*sk->num_alloc);
if (s == NULL) goto err;
ret->data=s;
return(NULL);
}
-STACK *sk_new(int (*c)(const void *, const void *))
+STACK *sk_new(int (*c)(const char * const *, const char * const *))
{
STACK *ret;
int i;
- if ((ret=(STACK *)Malloc(sizeof(STACK))) == NULL)
+ if ((ret=(STACK *)OPENSSL_malloc(sizeof(STACK))) == NULL)
goto err0;
- if ((ret->data=(char **)Malloc(sizeof(char *)*MIN_NODES)) == NULL)
+ if ((ret->data=(char **)OPENSSL_malloc(sizeof(char *)*MIN_NODES)) == NULL)
goto err1;
for (i=0; i<MIN_NODES; i++)
ret->data[i]=NULL;
ret->sorted=0;
return(ret);
err1:
- Free(ret);
+ OPENSSL_free(ret);
err0:
return(NULL);
}
if(st == NULL) return 0;
if (st->num_alloc <= st->num+1)
{
- s=(char **)Realloc((char *)st->data,
+ s=(char **)OPENSSL_realloc((char *)st->data,
(unsigned int)sizeof(char *)*st->num_alloc*2);
if (s == NULL)
return(0);
}
sk_sort(st);
if (data == NULL) return(-1);
- comp_func=st->comp;
+ /* This (and the "qsort" below) are the two places in OpenSSL
+ * where we need to convert from our standard (type **,type **)
+ * compare callback type to the (void *,void *) type required by
+ * bsearch. However, the "data" it is being called(back) with are
+ * not (type *) pointers, but the *pointers* to (type *) pointers,
+ * so we get our extra level of pointer dereferencing that way. */
+ comp_func=(int (*)(const void *,const void *))(st->comp);
r=(char **)bsearch(&data,(char *)st->data,
st->num,sizeof(char *), comp_func);
if (r == NULL) return(-1);
i=(int)(r-st->data);
for ( ; i>0; i--)
- if ((*st->comp)(&(st->data[i-1]),&data) < 0)
+ /* This needs a cast because the type being pointed to from
+ * the "&" expressions are (char *) rather than (const char *).
+ * For an explanation, read:
+ * http://www.eskimo.com/~scs/C-faq/q11.10.html :-) */
+ if ((*st->comp)((const char * const *)&(st->data[i-1]),
+ (const char * const *)&data) < 0)
break;
return(i);
}
void sk_free(STACK *st)
{
if (st == NULL) return;
- if (st->data != NULL) Free(st->data);
- Free(st);
+ if (st->data != NULL) OPENSSL_free(st->data);
+ OPENSSL_free(st);
}
-int sk_num(STACK *st)
+int sk_num(const STACK *st)
{
if(st == NULL) return -1;
return st->num;
}
-char *sk_value(STACK *st, int i)
+char *sk_value(const STACK *st, int i)
{
if(st == NULL) return NULL;
return st->data[i];
{
int (*comp_func)(const void *,const void *);
- comp_func=st->comp;
+ /* same comment as in sk_find ... previously st->comp was declared
+ * as a (void*,void*) callback type, but this made the population
+ * of the callback pointer illogical - our callbacks compare
+ * type** with type**, so we leave the casting until absolutely
+ * necessary (ie. "now"). */
+ comp_func=(int (*)(const void *,const void *))(st->comp);
qsort(st->data,st->num,sizeof(char *), comp_func);
st->sorted=1;
}
int sorted;
int num_alloc;
- int (*comp)(const void *, const void *);
+ int (*comp)(const char * const *, const char * const *);
} STACK;
-
-#define sk_new_null() sk_new(NULL)
+#define sk_new_null() sk_new((int (*)(const char * const *, \
+ const char * const *))NULL)
#define M_sk_num(sk) ((sk) ? (sk)->num:-1)
#define M_sk_value(sk,n) ((sk) ? (sk)->data[n] : NULL)
-int sk_num(STACK *);
-char *sk_value(STACK *, int);
+int sk_num(const STACK *);
+char *sk_value(const STACK *, int);
char *sk_set(STACK *, int, char *);
-STACK *sk_new(int (*cmp)(const void *, const void *));
+STACK *sk_new(int (*cmp)(const char * const *, const char * const *));
void sk_free(STACK *);
void sk_pop_free(STACK *st, void (*func)(void *));
int sk_insert(STACK *sk,char *data,int where);
char *sk_shift(STACK *st);
char *sk_pop(STACK *st);
void sk_zero(STACK *st);
-int (*sk_set_cmp_func(STACK *sk, int (*c)(const void *,const void *)))(const void *, const void *);
+int (*sk_set_cmp_func(STACK *sk, int (*c)(const char * const *,
+ const char * const *)))
+ (const char * const *, const char * const *);
STACK *sk_dup(STACK *st);
void sk_sort(STACK *st);
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
CRYPTO_set_locking_callback(NULL);
for (i=0; i<CRYPTO_num_locks(); i++)
CloseHandle(lock_cs[i]);
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void win32_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
mutex_destroy(&(lock_cs[i]));
fprintf(stderr,"%8ld:%s\n",lock_count[i],CRYPTO_get_lock_name(i));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
fprintf(stderr,"done cleanup\n");
arena=usinit(filename);
unlink(filename);
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(usema_t *));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=usnewsema(arena,1);
usdumpsema(lock_cs[i],stdout,buf);
usfreesema(lock_cs[i],arena);
}
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void irix_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
fprintf(stderr,"%8ld:%s\n",lock_count[i],
CRYPTO_get_lock_name(i));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
fprintf(stderr,"done cleanup\n");
}
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
CRYPTO_set_locking_callback(NULL);
for (i=0; i<CRYPTO_num_locks(); i++)
CloseHandle(lock_cs[i]);
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void win32_locking_callback(int mode, int type, char *file, int line)
int i;
#ifdef USE_MUTEX
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
#else
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(rwlock_t));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(rwlock_t));
#endif
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
rwlock_destroy(&(lock_cs[i]));
#endif
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
}
void solaris_locking_callback(int mode, int type, char *file, int line)
arena=usinit(filename);
unlink(filename);
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(usema_t *));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=usnewsema(arena,1);
usdumpsema(lock_cs[i],stdout,buf);
usfreesema(lock_cs[i],arena);
}
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void irix_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
{
pthread_mutex_destroy(&(lock_cs[i]));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
}
void pthreads_locking_callback(int mode, int type, char *file,
{
MS_TM *ret;
- ret=(MS_TM *)Malloc(sizeof(MS_TM));
+ ret=(MS_TM *)OPENSSL_malloc(sizeof(MS_TM));
if (ret == NULL)
return(NULL);
memset(ret,0,sizeof(MS_TM));
void ms_time_free(char *a)
{
if (a != NULL)
- Free(a);
+ OPENSSL_free(a);
}
void ms_time_get(char *a)
if ((buf=BUF_MEM_new()) == NULL) goto err;
if (!BUF_MEM_grow(buf,size)) goto err;
- if ((ret=(TXT_DB *)Malloc(sizeof(TXT_DB))) == NULL)
+ if ((ret=(TXT_DB *)OPENSSL_malloc(sizeof(TXT_DB))) == NULL)
goto err;
ret->num_fields=num;
ret->index=NULL;
ret->qual=NULL;
if ((ret->data=sk_new_null()) == NULL)
goto err;
- if ((ret->index=(LHASH **)Malloc(sizeof(LHASH *)*num)) == NULL)
+ if ((ret->index=(LHASH **)OPENSSL_malloc(sizeof(LHASH *)*num)) == NULL)
goto err;
- if ((ret->qual=(int (**)())Malloc(sizeof(int (**)())*num)) == NULL)
+ if ((ret->qual=(int (**)())OPENSSL_malloc(sizeof(int (**)())*num)) == NULL)
goto err;
for (i=0; i<num; i++)
{
else
{
buf->data[offset-1]='\0'; /* blat the '\n' */
- p=(char *)Malloc(add+offset);
+ p=(char *)OPENSSL_malloc(add+offset);
offset=0;
}
pp=(char **)p;
if (er)
{
#if !defined(NO_STDIO) && !defined(WIN16)
- if (er == 1) fprintf(stderr,"Malloc failure\n");
+ if (er == 1) fprintf(stderr,"OPENSSL_malloc failure\n");
#endif
if (ret->data != NULL) sk_free(ret->data);
- if (ret->index != NULL) Free(ret->index);
- if (ret->qual != NULL) Free(ret->qual);
- if (ret != NULL) Free(ret);
+ if (ret->index != NULL) OPENSSL_free(ret->index);
+ if (ret->qual != NULL) OPENSSL_free(ret->qual);
+ if (ret != NULL) OPENSSL_free(ret);
return(NULL);
}
else
{
for (i=db->num_fields-1; i>=0; i--)
if (db->index[i] != NULL) lh_free(db->index[i]);
- Free(db->index);
+ OPENSSL_free(db->index);
}
if (db->qual != NULL)
- Free(db->qual);
+ OPENSSL_free(db->qual);
if (db->data != NULL)
{
for (i=sk_num(db->data)-1; i>=0; i--)
if (max == NULL) /* new row */
{
for (n=0; n<db->num_fields; n++)
- if (p[n] != NULL) Free(p[n]);
+ if (p[n] != NULL) OPENSSL_free(p[n]);
}
else
{
{
if (((p[n] < (char *)p) || (p[n] > max))
&& (p[n] != NULL))
- Free(p[n]);
+ OPENSSL_free(p[n]);
}
}
- Free(sk_value(db->data,i));
+ OPENSSL_free(sk_value(db->data,i));
}
sk_free(db->data);
}
- Free(db);
+ OPENSSL_free(db);
}
{
BY_DIR *a;
- if ((a=(BY_DIR *)Malloc(sizeof(BY_DIR))) == NULL)
+ if ((a=(BY_DIR *)OPENSSL_malloc(sizeof(BY_DIR))) == NULL)
return(0);
if ((a->buffer=BUF_MEM_new()) == NULL)
{
- Free(a);
+ OPENSSL_free(a);
return(0);
}
a->num_dirs=0;
a=(BY_DIR *)lu->method_data;
for (i=0; i<a->num_dirs; i++)
- if (a->dirs[i] != NULL) Free(a->dirs[i]);
- if (a->dirs != NULL) Free(a->dirs);
- if (a->dirs_type != NULL) Free(a->dirs_type);
+ if (a->dirs[i] != NULL) OPENSSL_free(a->dirs[i]);
+ if (a->dirs != NULL) OPENSSL_free(a->dirs);
+ if (a->dirs_type != NULL) OPENSSL_free(a->dirs_type);
if (a->buffer != NULL) BUF_MEM_free(a->buffer);
- Free(a);
+ OPENSSL_free(a);
}
static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
if (ctx->num_dirs_alloced < (ctx->num_dirs+1))
{
ctx->num_dirs_alloced+=10;
- pp=(char **)Malloc(ctx->num_dirs_alloced*
+ pp=(char **)OPENSSL_malloc(ctx->num_dirs_alloced*
sizeof(char *));
- ip=(int *)Malloc(ctx->num_dirs_alloced*
+ ip=(int *)OPENSSL_malloc(ctx->num_dirs_alloced*
sizeof(int));
if ((pp == NULL) || (ip == NULL))
{
memcpy(ip,ctx->dirs_type,(ctx->num_dirs_alloced-10)*
sizeof(int));
if (ctx->dirs != NULL)
- Free(ctx->dirs);
+ OPENSSL_free(ctx->dirs);
if (ctx->dirs_type != NULL)
- Free(ctx->dirs_type);
+ OPENSSL_free(ctx->dirs_type);
ctx->dirs=pp;
ctx->dirs_type=ip;
}
ctx->dirs_type[ctx->num_dirs]=type;
- ctx->dirs[ctx->num_dirs]=(char *)Malloc((unsigned int)len+1);
+ ctx->dirs[ctx->num_dirs]=(char *)OPENSSL_malloc((unsigned int)len+1);
if (ctx->dirs[ctx->num_dirs] == NULL) return(0);
strncpy(ctx->dirs[ctx->num_dirs],ss,(unsigned int)len);
ctx->dirs[ctx->num_dirs][len]='\0';
} X509_ALGOR;
DECLARE_STACK_OF(X509_ALGOR)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_ALGOR_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_ALGOR_new_null() sk_new_null()
+ #define sk_X509_ALGOR_free(a) sk_free(a)
+ #define sk_X509_ALGOR_num(a) sk_num(a)
+ #define sk_X509_ALGOR_value(a,b) ((X509_ALGOR *) \
+ sk_value((a),(b)))
+ #define sk_X509_ALGOR_set(a,b,c) ((X509_ALGOR *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_ALGOR_zero(a) sk_zero(a)
+ #define sk_X509_ALGOR_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_ALGOR_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_ALGOR_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_ALGOR_delete(a,b) ((X509_ALGOR *) \
+ sk_delete((a),(b)))
+ #define sk_X509_ALGOR_delete_ptr(a,b) ((X509_ALGOR *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_ALGOR_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_ALGOR_set_cmp_func(a,b) ((int (*) \
+ (const X509_ALGOR * const *,const X509_ALGOR * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_ALGOR_dup(a) sk_dup(a)
+ #define sk_X509_ALGOR_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_ALGOR_shift(a) ((X509_ALGOR *)sk_shift(a))
+ #define sk_X509_ALGOR_pop(a) ((X509_ALGOR *)sk_pop(a))
+ #define sk_X509_ALGOR_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_ALGOR)
typedef struct X509_val_st
} X509_NAME_ENTRY;
DECLARE_STACK_OF(X509_NAME_ENTRY)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_NAME_ENTRY_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_NAME_ENTRY_new_null() sk_new_null()
+ #define sk_X509_NAME_ENTRY_free(a) sk_free(a)
+ #define sk_X509_NAME_ENTRY_num(a) sk_num(a)
+ #define sk_X509_NAME_ENTRY_value(a,b) ((X509_NAME_ENTRY *) \
+ sk_value((a),(b)))
+ #define sk_X509_NAME_ENTRY_set(a,b,c) ((X509_NAME_ENTRY *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_NAME_ENTRY_zero(a) sk_zero(a)
+ #define sk_X509_NAME_ENTRY_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_NAME_ENTRY_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_NAME_ENTRY_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_NAME_ENTRY_delete(a,b) ((X509_NAME_ENTRY *) \
+ sk_delete((a),(b)))
+ #define sk_X509_NAME_ENTRY_delete_ptr(a,b) ((X509_NAME_ENTRY *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_NAME_ENTRY_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_NAME_ENTRY_set_cmp_func(a,b) ((int (*) \
+ (const X509_NAME_ENTRY * const *,const X509_NAME_ENTRY * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_NAME_ENTRY_dup(a) sk_dup(a)
+ #define sk_X509_NAME_ENTRY_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_NAME_ENTRY_shift(a) ((X509_NAME_ENTRY *)sk_shift(a))
+ #define sk_X509_NAME_ENTRY_pop(a) ((X509_NAME_ENTRY *)sk_pop(a))
+ #define sk_X509_NAME_ENTRY_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_NAME_ENTRY)
/* we always keep X509_NAMEs in 2 forms. */
} X509_NAME;
DECLARE_STACK_OF(X509_NAME)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_NAME_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_NAME_new_null() sk_new_null()
+ #define sk_X509_NAME_free(a) sk_free(a)
+ #define sk_X509_NAME_num(a) sk_num(a)
+ #define sk_X509_NAME_value(a,b) ((X509_NAME *) \
+ sk_value((a),(b)))
+ #define sk_X509_NAME_set(a,b,c) ((X509_NAME *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_NAME_zero(a) sk_zero(a)
+ #define sk_X509_NAME_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_NAME_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_NAME_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_NAME_delete(a,b) ((X509_NAME *) \
+ sk_delete((a),(b)))
+ #define sk_X509_NAME_delete_ptr(a,b) ((X509_NAME *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_NAME_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_NAME_set_cmp_func(a,b) ((int (*) \
+ (const X509_NAME * const *,const X509_NAME * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_NAME_dup(a) sk_dup(a)
+ #define sk_X509_NAME_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_NAME_shift(a) ((X509_NAME *)sk_shift(a))
+ #define sk_X509_NAME_pop(a) ((X509_NAME *)sk_pop(a))
+ #define sk_X509_NAME_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
#define X509_EX_V_NETSCAPE_HACK 0x8000
#define X509_EX_V_INIT 0x0001
} X509_EXTENSION;
DECLARE_STACK_OF(X509_EXTENSION)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_EXTENSION_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_EXTENSION_new_null() sk_new_null()
+ #define sk_X509_EXTENSION_free(a) sk_free(a)
+ #define sk_X509_EXTENSION_num(a) sk_num(a)
+ #define sk_X509_EXTENSION_value(a,b) ((X509_EXTENSION *) \
+ sk_value((a),(b)))
+ #define sk_X509_EXTENSION_set(a,b,c) ((X509_EXTENSION *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_EXTENSION_zero(a) sk_zero(a)
+ #define sk_X509_EXTENSION_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_EXTENSION_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_EXTENSION_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_EXTENSION_delete(a,b) ((X509_EXTENSION *) \
+ sk_delete((a),(b)))
+ #define sk_X509_EXTENSION_delete_ptr(a,b) ((X509_EXTENSION *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_EXTENSION_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_EXTENSION_set_cmp_func(a,b) ((int (*) \
+ (const X509_EXTENSION * const *,const X509_EXTENSION * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_EXTENSION_dup(a) sk_dup(a)
+ #define sk_X509_EXTENSION_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_EXTENSION_shift(a) ((X509_EXTENSION *)sk_shift(a))
+ #define sk_X509_EXTENSION_pop(a) ((X509_EXTENSION *)sk_pop(a))
+ #define sk_X509_EXTENSION_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_EXTENSION)
/* a sequence of these are used */
} X509_ATTRIBUTE;
DECLARE_STACK_OF(X509_ATTRIBUTE)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_ATTRIBUTE_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_ATTRIBUTE_new_null() sk_new_null()
+ #define sk_X509_ATTRIBUTE_free(a) sk_free(a)
+ #define sk_X509_ATTRIBUTE_num(a) sk_num(a)
+ #define sk_X509_ATTRIBUTE_value(a,b) ((X509_ATTRIBUTE *) \
+ sk_value((a),(b)))
+ #define sk_X509_ATTRIBUTE_set(a,b,c) ((X509_ATTRIBUTE *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_ATTRIBUTE_zero(a) sk_zero(a)
+ #define sk_X509_ATTRIBUTE_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_ATTRIBUTE_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_ATTRIBUTE_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_ATTRIBUTE_delete(a,b) ((X509_ATTRIBUTE *) \
+ sk_delete((a),(b)))
+ #define sk_X509_ATTRIBUTE_delete_ptr(a,b) ((X509_ATTRIBUTE *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_ATTRIBUTE_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_ATTRIBUTE_set_cmp_func(a,b) ((int (*) \
+ (const X509_ATTRIBUTE * const *,const X509_ATTRIBUTE * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_ATTRIBUTE_dup(a) sk_dup(a)
+ #define sk_X509_ATTRIBUTE_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_ATTRIBUTE_shift(a) ((X509_ATTRIBUTE *)sk_shift(a))
+ #define sk_X509_ATTRIBUTE_pop(a) ((X509_ATTRIBUTE *)sk_pop(a))
+ #define sk_X509_ATTRIBUTE_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_ATTRIBUTE)
typedef struct X509_req_info_st
} X509;
DECLARE_STACK_OF(X509)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_new_null() sk_new_null()
+ #define sk_X509_free(a) sk_free(a)
+ #define sk_X509_num(a) sk_num(a)
+ #define sk_X509_value(a,b) ((X509 *) \
+ sk_value((a),(b)))
+ #define sk_X509_set(a,b,c) ((X509 *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_zero(a) sk_zero(a)
+ #define sk_X509_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_delete(a,b) ((X509 *) \
+ sk_delete((a),(b)))
+ #define sk_X509_delete_ptr(a,b) ((X509 *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_set_cmp_func(a,b) ((int (*) \
+ (const X509 * const *,const X509 * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_dup(a) sk_dup(a)
+ #define sk_X509_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_shift(a) ((X509 *)sk_shift(a))
+ #define sk_X509_pop(a) ((X509 *)sk_pop(a))
+ #define sk_X509_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509)
/* This is used for a table of trust checking functions */
} X509_TRUST;
DECLARE_STACK_OF(X509_TRUST)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_TRUST_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_TRUST_new_null() sk_new_null()
+ #define sk_X509_TRUST_free(a) sk_free(a)
+ #define sk_X509_TRUST_num(a) sk_num(a)
+ #define sk_X509_TRUST_value(a,b) ((X509_TRUST *) \
+ sk_value((a),(b)))
+ #define sk_X509_TRUST_set(a,b,c) ((X509_TRUST *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_TRUST_zero(a) sk_zero(a)
+ #define sk_X509_TRUST_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_TRUST_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_TRUST_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_TRUST_delete(a,b) ((X509_TRUST *) \
+ sk_delete((a),(b)))
+ #define sk_X509_TRUST_delete_ptr(a,b) ((X509_TRUST *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_TRUST_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_TRUST_set_cmp_func(a,b) ((int (*) \
+ (const X509_TRUST * const *,const X509_TRUST * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_TRUST_dup(a) sk_dup(a)
+ #define sk_X509_TRUST_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_TRUST_shift(a) ((X509_TRUST *)sk_shift(a))
+ #define sk_X509_TRUST_pop(a) ((X509_TRUST *)sk_pop(a))
+ #define sk_X509_TRUST_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
/* standard trust ids */
} X509_REVOKED;
DECLARE_STACK_OF(X509_REVOKED)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_REVOKED_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_REVOKED_new_null() sk_new_null()
+ #define sk_X509_REVOKED_free(a) sk_free(a)
+ #define sk_X509_REVOKED_num(a) sk_num(a)
+ #define sk_X509_REVOKED_value(a,b) ((X509_REVOKED *) \
+ sk_value((a),(b)))
+ #define sk_X509_REVOKED_set(a,b,c) ((X509_REVOKED *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_REVOKED_zero(a) sk_zero(a)
+ #define sk_X509_REVOKED_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_REVOKED_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_REVOKED_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_REVOKED_delete(a,b) ((X509_REVOKED *) \
+ sk_delete((a),(b)))
+ #define sk_X509_REVOKED_delete_ptr(a,b) ((X509_REVOKED *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_REVOKED_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_REVOKED_set_cmp_func(a,b) ((int (*) \
+ (const X509_REVOKED * const *,const X509_REVOKED * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_REVOKED_dup(a) sk_dup(a)
+ #define sk_X509_REVOKED_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_REVOKED_shift(a) ((X509_REVOKED *)sk_shift(a))
+ #define sk_X509_REVOKED_pop(a) ((X509_REVOKED *)sk_pop(a))
+ #define sk_X509_REVOKED_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_REVOKED)
typedef struct X509_crl_info_st
} X509_CRL;
DECLARE_STACK_OF(X509_CRL)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_CRL_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_CRL_new_null() sk_new_null()
+ #define sk_X509_CRL_free(a) sk_free(a)
+ #define sk_X509_CRL_num(a) sk_num(a)
+ #define sk_X509_CRL_value(a,b) ((X509_CRL *) \
+ sk_value((a),(b)))
+ #define sk_X509_CRL_set(a,b,c) ((X509_CRL *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_CRL_zero(a) sk_zero(a)
+ #define sk_X509_CRL_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_CRL_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_CRL_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_CRL_delete(a,b) ((X509_CRL *) \
+ sk_delete((a),(b)))
+ #define sk_X509_CRL_delete_ptr(a,b) ((X509_CRL *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_CRL_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_CRL_set_cmp_func(a,b) ((int (*) \
+ (const X509_CRL * const *,const X509_CRL * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_CRL_dup(a) sk_dup(a)
+ #define sk_X509_CRL_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_CRL_shift(a) ((X509_CRL *)sk_shift(a))
+ #define sk_X509_CRL_pop(a) ((X509_CRL *)sk_pop(a))
+ #define sk_X509_CRL_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(X509_CRL)
typedef struct private_key_st
} X509_INFO;
DECLARE_STACK_OF(X509_INFO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_INFO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_INFO_new_null() sk_new_null()
+ #define sk_X509_INFO_free(a) sk_free(a)
+ #define sk_X509_INFO_num(a) sk_num(a)
+ #define sk_X509_INFO_value(a,b) ((X509_INFO *) \
+ sk_value((a),(b)))
+ #define sk_X509_INFO_set(a,b,c) ((X509_INFO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_INFO_zero(a) sk_zero(a)
+ #define sk_X509_INFO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_INFO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_INFO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_INFO_delete(a,b) ((X509_INFO *) \
+ sk_delete((a),(b)))
+ #define sk_X509_INFO_delete_ptr(a,b) ((X509_INFO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_INFO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_INFO_set_cmp_func(a,b) ((int (*) \
+ (const X509_INFO * const *,const X509_INFO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_INFO_dup(a) sk_dup(a)
+ #define sk_X509_INFO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_INFO_shift(a) ((X509_INFO *)sk_shift(a))
+ #define sk_X509_INFO_pop(a) ((X509_INFO *)sk_pop(a))
+ #define sk_X509_INFO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
#endif
/* The next 2 structures and their 8 routines were sent to me by
int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
-int X509_digest(X509 *data,const EVP_MD *type,unsigned char *md,unsigned int *len);
-int X509_CRL_digest(X509_CRL *data,const EVP_MD *type,unsigned char *md,unsigned int *len);
-int X509_REQ_digest(X509_REQ *data,const EVP_MD *type,unsigned char *md,unsigned int *len);
-int X509_NAME_digest(X509_NAME *data,const EVP_MD *type,
- unsigned char *md,unsigned int *len);
+int X509_digest(const X509 *data,const EVP_MD *type,
+ unsigned char *md, unsigned int *len);
+int X509_CRL_digest(const X509_CRL *data,const EVP_MD *type,
+ unsigned char *md, unsigned int *len);
+int X509_REQ_digest(const X509_REQ *data,const EVP_MD *type,
+ unsigned char *md, unsigned int *len);
+int X509_NAME_digest(const X509_NAME *data,const EVP_MD *type,
+ unsigned char *md, unsigned int *len);
#endif
#ifndef NO_FP_API
int X509_check_private_key(X509 *x509,EVP_PKEY *pkey);
-int X509_issuer_and_serial_cmp(X509 *a, X509 *b);
+int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
unsigned long X509_issuer_and_serial_hash(X509 *a);
-int X509_issuer_name_cmp(X509 *a, X509 *b);
+int X509_issuer_name_cmp(const X509 *a, const X509 *b);
unsigned long X509_issuer_name_hash(X509 *a);
-int X509_subject_name_cmp(X509 *a,X509 *b);
+int X509_subject_name_cmp(const X509 *a, const X509 *b);
unsigned long X509_subject_name_hash(X509 *x);
-int X509_cmp (X509 *a, X509 *b);
-int X509_NAME_cmp (X509_NAME *a, X509_NAME *b);
+int X509_cmp(const X509 *a, const X509 *b);
+int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
unsigned long X509_NAME_hash(X509_NAME *x);
-int X509_CRL_cmp(X509_CRL *a,X509_CRL *b);
+int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
#ifndef NO_FP_API
int X509_print_fp(FILE *bp,X509 *x);
int X509_CRL_print_fp(FILE *bp,X509_CRL *x);
#include <openssl/x509.h>
#include <openssl/x509v3.h>
-int X509_issuer_and_serial_cmp(X509 *a, X509 *b)
+int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b)
{
int i;
X509_CINF *ai,*bi;
}
#endif
-int X509_issuer_name_cmp(X509 *a, X509 *b)
+int X509_issuer_name_cmp(const X509 *a, const X509 *b)
{
return(X509_NAME_cmp(a->cert_info->issuer,b->cert_info->issuer));
}
-int X509_subject_name_cmp(X509 *a, X509 *b)
+int X509_subject_name_cmp(const X509 *a, const X509 *b)
{
return(X509_NAME_cmp(a->cert_info->subject,b->cert_info->subject));
}
-int X509_CRL_cmp(X509_CRL *a, X509_CRL *b)
+int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b)
{
return(X509_NAME_cmp(a->crl->issuer,b->crl->issuer));
}
#ifndef NO_SHA
/* Compare two certificates: they must be identical for
- * this to work.
+ * this to work. NB: Although "cmp" operations are generally
+ * prototyped to take "const" arguments (eg. for use in
+ * STACKs), the way X509 handling is - these operations may
+ * involve ensuring the hashes are up-to-date and ensuring
+ * certain cert information is cached. So this is the point
+ * where the "depth-first" constification tree has to halt
+ * with an evil cast.
*/
-int X509_cmp(X509 *a, X509 *b)
+int X509_cmp(const X509 *a, const X509 *b)
{
/* ensure hash is valid */
- X509_check_purpose(a, -1, 0);
- X509_check_purpose(b, -1, 0);
+ X509_check_purpose((X509 *)a, -1, 0);
+ X509_check_purpose((X509 *)b, -1, 0);
return memcmp(a->sha1_hash, b->sha1_hash, SHA_DIGEST_LENGTH);
}
#endif
-int X509_NAME_cmp(X509_NAME *a, X509_NAME *b)
+int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b)
{
int i,j;
X509_NAME_ENTRY *na,*nb;
i=i2d_X509_NAME(x,NULL);
if (i > sizeof(str))
- p=Malloc(i);
+ p=OPENSSL_malloc(i);
else
p=str;
pp=p;
i2d_X509_NAME(x,&pp);
MD5((unsigned char *)p,i,&(md[0]));
- if (p != str) Free(p);
+ if (p != str) OPENSSL_free(p);
ret=( ((unsigned long)md[0] )|((unsigned long)md[1]<<8L)|
((unsigned long)md[2]<<16L)|((unsigned long)md[3]<<24L)
{
X509_LOOKUP *ret;
- ret=(X509_LOOKUP *)Malloc(sizeof(X509_LOOKUP));
+ ret=(X509_LOOKUP *)OPENSSL_malloc(sizeof(X509_LOOKUP));
if (ret == NULL) return(NULL);
ret->init=0;
ret->store_ctx=NULL;
if ((method->new_item != NULL) && !method->new_item(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
return(NULL);
}
return(ret);
if ( (ctx->method != NULL) &&
(ctx->method->free != NULL))
ctx->method->free(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
int X509_LOOKUP_init(X509_LOOKUP *ctx)
{
X509_STORE *ret;
- if ((ret=(X509_STORE *)Malloc(sizeof(X509_STORE))) == NULL)
+ if ((ret=(X509_STORE *)OPENSSL_malloc(sizeof(X509_STORE))) == NULL)
return(NULL);
ret->certs=lh_new(x509_object_hash,x509_object_cmp);
ret->cache=1;
else
abort();
- Free(a);
+ OPENSSL_free(a);
}
void X509_STORE_free(X509_STORE *vfy)
CRYPTO_free_ex_data(x509_store_meth,vfy,&vfy->ex_data);
lh_doall(vfy->certs,cleanup);
lh_free(vfy->certs);
- Free(vfy);
+ OPENSSL_free(vfy);
}
X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
X509_STORE_CTX *X509_STORE_CTX_new(void)
{
X509_STORE_CTX *ctx;
- ctx = (X509_STORE_CTX *)Malloc(sizeof(X509_STORE_CTX));
+ ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX));
if(ctx) memset(ctx, 0, sizeof(X509_STORE_CTX));
return ctx;
}
void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
{
X509_STORE_CTX_cleanup(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
if(b)
{
buf=b->data;
- Free(b);
+ OPENSSL_free(b);
}
strncpy(buf,"NO X509_NAME",len);
return buf;
if (b != NULL)
{
p=b->data;
- Free(b);
+ OPENSSL_free(b);
}
else
p=buf;
ri=ret->req_info;
ri->version->length=1;
- ri->version->data=(unsigned char *)Malloc(1);
+ ri->version->data=(unsigned char *)OPENSSL_malloc(1);
if (ri->version->data == NULL) goto err;
ri->version->data[0]=0; /* version == 0 */
/* Generate encoding of extensions */
len = i2d_ASN1_SET_OF_X509_EXTENSION(exts, NULL, i2d_X509_EXTENSION,
V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
- if(!(p = Malloc(len))) goto err;
+ if(!(p = OPENSSL_malloc(len))) goto err;
q = p;
i2d_ASN1_SET_OF_X509_EXTENSION(exts, &q, i2d_X509_EXTENSION,
V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
if(!sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr)) goto err;
return 1;
err:
- if(p) Free(p);
+ if(p) OPENSSL_free(p);
X509_ATTRIBUTE_free(attr);
ASN1_TYPE_free(at);
return 0;
#include <openssl/x509v3.h>
-static int tr_cmp(X509_TRUST **a, X509_TRUST **b);
+static int tr_cmp(const X509_TRUST * const *a,
+ const X509_TRUST * const *b);
static void trtable_free(X509_TRUST *p);
static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags);
static STACK_OF(X509_TRUST) *trtable = NULL;
-static int tr_cmp(X509_TRUST **a, X509_TRUST **b)
+static int tr_cmp(const X509_TRUST * const *a,
+ const X509_TRUST * const *b)
{
return (*a)->trust - (*b)->trust;
}
idx = X509_TRUST_get_by_id(id);
/* Need a new entry */
if(idx == -1) {
- if(!(trtmp = Malloc(sizeof(X509_TRUST)))) {
+ if(!(trtmp = OPENSSL_malloc(sizeof(X509_TRUST)))) {
X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
trtmp->flags = X509_TRUST_DYNAMIC;
} else trtmp = X509_TRUST_get0(idx);
- /* Free existing name if dynamic */
- if(trtmp->flags & X509_TRUST_DYNAMIC_NAME) Free(trtmp->name);
+ /* OPENSSL_free existing name if dynamic */
+ if(trtmp->flags & X509_TRUST_DYNAMIC_NAME) OPENSSL_free(trtmp->name);
/* dup supplied name */
if(!(trtmp->name = BUF_strdup(name))) {
X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
if (p->flags & X509_TRUST_DYNAMIC)
{
if (p->flags & X509_TRUST_DYNAMIC_NAME)
- Free(p->name);
- Free(p);
+ OPENSSL_free(p->name);
+ OPENSSL_free(p);
}
}
int ret=1;
if (x == NULL) return(0);
- obj=(X509_OBJECT *)Malloc(sizeof(X509_OBJECT));
+ obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
if (obj == NULL)
{
X509err(X509_F_X509_STORE_ADD_CERT,ERR_R_MALLOC_FAILURE);
{ /* oops, put it back */
lh_delete(ctx->certs,obj);
X509_OBJECT_free_contents(obj);
- Free(obj);
+ OPENSSL_free(obj);
lh_insert(ctx->certs,r);
X509err(X509_F_X509_STORE_ADD_CERT,X509_R_CERT_ALREADY_IN_HASH_TABLE);
ret=0;
int ret=1;
if (x == NULL) return(0);
- obj=(X509_OBJECT *)Malloc(sizeof(X509_OBJECT));
+ obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
if (obj == NULL)
{
X509err(X509_F_X509_STORE_ADD_CRL,ERR_R_MALLOC_FAILURE);
{ /* oops, put it back */
lh_delete(ctx->certs,obj);
X509_OBJECT_free_contents(obj);
- Free(obj);
+ OPENSSL_free(obj);
lh_insert(ctx->certs,r);
X509err(X509_F_X509_STORE_ADD_CRL,X509_R_CERT_ALREADY_IN_HASH_TABLE);
ret=0;
typedef struct x509_lookup_st X509_LOOKUP;
DECLARE_STACK_OF(X509_LOOKUP)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_LOOKUP_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_LOOKUP_new_null() sk_new_null()
+ #define sk_X509_LOOKUP_free(a) sk_free(a)
+ #define sk_X509_LOOKUP_num(a) sk_num(a)
+ #define sk_X509_LOOKUP_value(a,b) ((X509_LOOKUP *) \
+ sk_value((a),(b)))
+ #define sk_X509_LOOKUP_set(a,b,c) ((X509_LOOKUP *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_LOOKUP_zero(a) sk_zero(a)
+ #define sk_X509_LOOKUP_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_LOOKUP_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_LOOKUP_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_LOOKUP_delete(a,b) ((X509_LOOKUP *) \
+ sk_delete((a),(b)))
+ #define sk_X509_LOOKUP_delete_ptr(a,b) ((X509_LOOKUP *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_LOOKUP_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_LOOKUP_set_cmp_func(a,b) ((int (*) \
+ (const X509_LOOKUP * const *,const X509_LOOKUP * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_LOOKUP_dup(a) sk_dup(a)
+ #define sk_X509_LOOKUP_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_LOOKUP_shift(a) ((X509_LOOKUP *)sk_shift(a))
+ #define sk_X509_LOOKUP_pop(a) ((X509_LOOKUP *)sk_pop(a))
+ #define sk_X509_LOOKUP_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
/* This is a static that defines the function interface */
typedef struct x509_lookup_method_st
int spki_len;
NETSCAPE_SPKI *spki;
if(len <= 0) len = strlen(str);
- if (!(spki_der = Malloc(len + 1))) {
+ if (!(spki_der = OPENSSL_malloc(len + 1))) {
X509err(X509_F_NETSCAPE_SPKI_B64_DECODE, ERR_R_MALLOC_FAILURE);
return NULL;
}
if(spki_len < 0) {
X509err(X509_F_NETSCAPE_SPKI_B64_DECODE,
X509_R_BASE64_DECODE_ERROR);
- Free(spki_der);
+ OPENSSL_free(spki_der);
return NULL;
}
p = spki_der;
spki = d2i_NETSCAPE_SPKI(NULL, &p, spki_len);
- Free(spki_der);
+ OPENSSL_free(spki_der);
return spki;
}
char *b64_str;
int der_len;
der_len = i2d_NETSCAPE_SPKI(spki, NULL);
- der_spki = Malloc(der_len);
- b64_str = Malloc(der_len * 2);
+ der_spki = OPENSSL_malloc(der_len);
+ b64_str = OPENSSL_malloc(der_len * 2);
if(!der_spki || !b64_str) {
X509err(X509_F_NETSCAPE_SPKI_B64_ENCODE, ERR_R_MALLOC_FAILURE);
return NULL;
p = der_spki;
i2d_NETSCAPE_SPKI(spki, &p);
EVP_EncodeBlock((unsigned char *)b64_str, der_spki, der_len);
- Free(der_spki);
+ OPENSSL_free(der_spki);
return b64_str;
}
(char *(*)())d2i_X509_NAME_ENTRY,(char *)ne));
}
-int X509_digest(X509 *data, const EVP_MD *type, unsigned char *md,
+int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509,type,(char *)data,md,len));
}
-int X509_CRL_digest(X509_CRL *data, const EVP_MD *type, unsigned char *md,
+int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509_CRL,type,(char *)data,md,len));
}
-int X509_REQ_digest(X509_REQ *data, const EVP_MD *type, unsigned char *md,
+int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509_REQ,type,(char *)data,md,len));
}
-int X509_NAME_digest(X509_NAME *data, const EVP_MD *type, unsigned char *md,
+int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509_NAME,type,(char *)data,md,len));
M_ASN1_OCTET_STRING_free(a->keyid);
sk_GENERAL_NAME_pop_free(a->issuer, GENERAL_NAME_free);
M_ASN1_INTEGER_free (a->serial);
- Free (a);
+ OPENSSL_free (a);
}
static STACK_OF(CONF_VALUE) *i2v_AUTHORITY_KEYID(X509V3_EXT_METHOD *method,
if(akeyid->keyid) {
tmp = hex_to_string(akeyid->keyid->data, akeyid->keyid->length);
X509V3_add_value("keyid", tmp, &extlist);
- Free(tmp);
+ OPENSSL_free(tmp);
}
if(akeyid->issuer)
extlist = i2v_GENERAL_NAMES(NULL, akeyid->issuer, extlist);
tmp = hex_to_string(akeyid->serial->data,
akeyid->serial->length);
X509V3_add_value("serial", tmp, &extlist);
- Free(tmp);
+ OPENSSL_free(tmp);
}
return extlist;
}
{
if (a == NULL) return;
M_ASN1_INTEGER_free (a->pathlen);
- Free (a);
+ OPENSSL_free (a);
}
static STACK_OF(CONF_VALUE) *i2v_BASIC_CONSTRAINTS(X509V3_EXT_METHOD *method,
X509_EXTENSION *ext;
/* Convert internal representation to DER */
ext_len = method->i2d(ext_struc, NULL);
- if(!(ext_der = Malloc(ext_len))) goto merr;
+ if(!(ext_der = OPENSSL_malloc(ext_len))) goto merr;
p = ext_der;
method->i2d(ext_struc, &p);
if(!(ext_oct = M_ASN1_OCTET_STRING_new())) goto merr;
err:
ASN1_OBJECT_free(obj);
M_ASN1_OCTET_STRING_free(oct);
-if(ext_der) Free(ext_der);
+if(ext_der) OPENSSL_free(ext_der);
return extension;
}
if (a == NULL) return;
ASN1_OBJECT_free(a->policyid);
sk_POLICYQUALINFO_pop_free(a->qualifiers, POLICYQUALINFO_free);
- Free (a);
+ OPENSSL_free (a);
}
static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals,
if(i) BIO_puts(out, ", ");
tmp = i2s_ASN1_INTEGER(NULL, num);
BIO_puts(out, tmp);
- Free(tmp);
+ OPENSSL_free(tmp);
}
BIO_puts(out, "\n");
}
}
ASN1_OBJECT_free(a->pqualid);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_USERNOTICE(USERNOTICE *a, unsigned char **pp)
if (a == NULL) return;
NOTICEREF_free(a->noticeref);
M_DISPLAYTEXT_free(a->exptext);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_NOTICEREF(NOTICEREF *a, unsigned char **pp)
if (a == NULL) return;
M_DISPLAYTEXT_free(a->organization);
sk_ASN1_INTEGER_pop_free(a->noticenos, ASN1_STRING_free);
- Free (a);
+ OPENSSL_free (a);
}
IMPLEMENT_STACK_OF(POLICYQUALINFO)
DIST_POINT_NAME_free(a->distpoint);
M_ASN1_BIT_STRING_free(a->reasons);
sk_GENERAL_NAME_pop_free(a->CRLissuer, GENERAL_NAME_free);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **pp)
if (a == NULL) return;
sk_X509_NAME_ENTRY_pop_free(a->relativename, X509_NAME_ENTRY_free);
sk_GENERAL_NAME_pop_free(a->fullname, GENERAL_NAME_free);
- Free (a);
+ OPENSSL_free (a);
}
DIST_POINT_NAME *d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, unsigned char **pp,
break;
}
- Free (a);
+ OPENSSL_free (a);
}
/* Now the GeneralNames versions: a SEQUENCE OF GeneralName. These are needed as
if (a == NULL) return;
ASN1_OBJECT_free(a->type_id);
ASN1_TYPE_free(a->value);
- Free (a);
+ OPENSSL_free (a);
}
{
char *tmp;
if(!ia5 || !ia5->length) return NULL;
- tmp = Malloc(ia5->length + 1);
+ tmp = OPENSSL_malloc(ia5->length + 1);
memcpy(tmp, ia5->data, ia5->length);
tmp[ia5->length] = 0;
return tmp;
if(!ret) break;
vtmp = sk_CONF_VALUE_value(ret, i);
i2t_ASN1_OBJECT(objtmp, 80, desc->method);
- ntmp = Malloc(strlen(objtmp) + strlen(vtmp->name) + 5);
+ ntmp = OPENSSL_malloc(strlen(objtmp) + strlen(vtmp->name) + 5);
if(!ntmp) {
X509V3err(X509V3_F_I2V_AUTHORITY_INFO_ACCESS,
ERR_R_MALLOC_FAILURE);
strcpy(ntmp, objtmp);
strcat(ntmp, " - ");
strcat(ntmp, vtmp->name);
- Free(vtmp->name);
+ OPENSSL_free(vtmp->name);
vtmp->name = ntmp;
}
ctmp.value = cnf->value;
if(!(acc->location = v2i_GENERAL_NAME(method, ctx, &ctmp)))
goto err;
- if(!(objtmp = Malloc(objlen + 1))) {
+ if(!(objtmp = OPENSSL_malloc(objlen + 1))) {
X509V3err(X509V3_F_V2I_ACCESS_DESCRIPTION,ERR_R_MALLOC_FAILURE);
goto err;
}
if(!acc->method) {
X509V3err(X509V3_F_V2I_ACCESS_DESCRIPTION,X509V3_R_BAD_OBJECT);
ERR_add_error_data(2, "value=", objtmp);
- Free(objtmp);
+ OPENSSL_free(objtmp);
goto err;
}
- Free(objtmp);
+ OPENSSL_free(objtmp);
}
return ainfo;
if (a == NULL) return;
ASN1_OBJECT_free(a->method);
GENERAL_NAME_free(a->location);
- Free (a);
+ OPENSSL_free (a);
}
STACK_OF(ACCESS_DESCRIPTION) *AUTHORITY_INFO_ACCESS_new(void)
static STACK_OF(X509V3_EXT_METHOD) *ext_list = NULL;
-static int ext_cmp(X509V3_EXT_METHOD **a, X509V3_EXT_METHOD **b);
+static int ext_cmp(const X509V3_EXT_METHOD * const *a,
+ const X509V3_EXT_METHOD * const *b);
static void ext_list_free(X509V3_EXT_METHOD *ext);
int X509V3_EXT_add(X509V3_EXT_METHOD *ext)
return 1;
}
-static int ext_cmp(X509V3_EXT_METHOD **a, X509V3_EXT_METHOD **b)
+static int ext_cmp(const X509V3_EXT_METHOD * const *a,
+ const X509V3_EXT_METHOD * const *b)
{
return ((*a)->ext_nid - (*b)->ext_nid);
}
X509V3err(X509V3_F_X509V3_EXT_ADD_ALIAS,X509V3_R_EXTENSION_NOT_FOUND);
return 0;
}
- if(!(tmpext = (X509V3_EXT_METHOD *)Malloc(sizeof(X509V3_EXT_METHOD)))) {
+ if(!(tmpext = (X509V3_EXT_METHOD *)OPENSSL_malloc(sizeof(X509V3_EXT_METHOD)))) {
X509V3err(X509V3_F_X509V3_EXT_ADD_ALIAS,ERR_R_MALLOC_FAILURE);
return 0;
}
static void ext_list_free(X509V3_EXT_METHOD *ext)
{
- if(ext->ext_flags & X509V3_EXT_DYNAMIC) Free(ext);
+ if(ext->ext_flags & X509V3_EXT_DYNAMIC) OPENSSL_free(ext);
}
/* Legacy function: we don't need to add standard extensions
if (a == NULL) return;
M_ASN1_GENERALIZEDTIME_free(a->notBefore);
M_ASN1_GENERALIZEDTIME_free(a->notAfter);
- Free (a);
+ OPENSSL_free (a);
}
static int i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method,
err:
sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
- if(value) Free(value);
+ if(value) OPENSSL_free(value);
method->ext_free(ext_str);
return ok;
}
static void x509v3_cache_extensions(X509 *x);
-static int ca_check(X509 *x);
-static int check_ssl_ca(X509 *x);
-static int check_purpose_ssl_client(X509_PURPOSE *xp, X509 *x, int ca);
-static int check_purpose_ssl_server(X509_PURPOSE *xp, X509 *x, int ca);
-static int check_purpose_ns_ssl_server(X509_PURPOSE *xp, X509 *x, int ca);
-static int purpose_smime(X509 *x, int ca);
-static int check_purpose_smime_sign(X509_PURPOSE *xp, X509 *x, int ca);
-static int check_purpose_smime_encrypt(X509_PURPOSE *xp, X509 *x, int ca);
-static int check_purpose_crl_sign(X509_PURPOSE *xp, X509 *x, int ca);
-static int no_check(X509_PURPOSE *xp, X509 *x, int ca);
-
-static int xp_cmp(X509_PURPOSE **a, X509_PURPOSE **b);
+static int ca_check(const X509 *x);
+static int check_ssl_ca(const X509 *x);
+static int check_purpose_ssl_client(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int check_purpose_ssl_server(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int check_purpose_ns_ssl_server(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int purpose_smime(const X509 *x, int ca);
+static int check_purpose_smime_sign(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int check_purpose_smime_encrypt(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int check_purpose_crl_sign(const X509_PURPOSE *xp, const X509 *x, int ca);
+static int no_check(const X509_PURPOSE *xp, const X509 *x, int ca);
+
+static int xp_cmp(const X509_PURPOSE * const *a,
+ const X509_PURPOSE * const *b);
static void xptable_free(X509_PURPOSE *p);
static X509_PURPOSE xstandard[] = {
static STACK_OF(X509_PURPOSE) *xptable = NULL;
-static int xp_cmp(X509_PURPOSE **a, X509_PURPOSE **b)
+static int xp_cmp(const X509_PURPOSE * const *a,
+ const X509_PURPOSE * const *b)
{
return (*a)->purpose - (*b)->purpose;
}
+/* As much as I'd like to make X509_check_purpose use a "const" X509*
+ * I really can't because it does recalculate hashes and do other non-const
+ * things. */
int X509_check_purpose(X509 *x, int id, int ca)
{
int idx;
- X509_PURPOSE *pt;
+ const X509_PURPOSE *pt;
if(!(x->ex_flags & EXFLAG_SET)) {
CRYPTO_w_lock(CRYPTO_LOCK_X509);
x509v3_cache_extensions(x);
}
int X509_PURPOSE_add(int id, int trust, int flags,
- int (*ck)(X509_PURPOSE *, X509 *, int),
+ int (*ck)(const X509_PURPOSE *, const X509 *, int),
char *name, char *sname, void *arg)
{
int idx;
idx = X509_PURPOSE_get_by_id(id);
/* Need a new entry */
if(idx == -1) {
- if(!(ptmp = Malloc(sizeof(X509_PURPOSE)))) {
+ if(!(ptmp = OPENSSL_malloc(sizeof(X509_PURPOSE)))) {
X509V3err(X509V3_F_X509_PURPOSE_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
ptmp->flags = X509_PURPOSE_DYNAMIC;
} else ptmp = X509_PURPOSE_get0(idx);
- /* Free existing name if dynamic */
+ /* OPENSSL_free existing name if dynamic */
if(ptmp->flags & X509_PURPOSE_DYNAMIC_NAME) {
- Free(ptmp->name);
- Free(ptmp->sname);
+ OPENSSL_free(ptmp->name);
+ OPENSSL_free(ptmp->sname);
}
/* dup supplied name */
ptmp->name = BUF_strdup(name);
if (p->flags & X509_PURPOSE_DYNAMIC)
{
if (p->flags & X509_PURPOSE_DYNAMIC_NAME) {
- Free(p->name);
- Free(p->sname);
+ OPENSSL_free(p->name);
+ OPENSSL_free(p->sname);
}
- Free(p);
+ OPENSSL_free(p);
}
}
#define ns_reject(x, usage) \
(((x)->ex_flags & EXFLAG_NSCERT) && !((x)->ex_nscert & (usage)))
-static int ca_check(X509 *x)
+static int ca_check(const X509 *x)
{
/* keyUsage if present should allow cert signing */
if(ku_reject(x, KU_KEY_CERT_SIGN)) return 0;
}
/* Check SSL CA: common checks for SSL client and server */
-static int check_ssl_ca(X509 *x)
+static int check_ssl_ca(const X509 *x)
{
int ca_ret;
ca_ret = ca_check(x);
}
-static int check_purpose_ssl_client(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_ssl_client(const X509_PURPOSE *xp, const X509 *x, int ca)
{
if(xku_reject(x,XKU_SSL_CLIENT)) return 0;
if(ca) return check_ssl_ca(x);
return 1;
}
-static int check_purpose_ssl_server(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_ssl_server(const X509_PURPOSE *xp, const X509 *x, int ca)
{
if(xku_reject(x,XKU_SSL_SERVER|XKU_SGC)) return 0;
if(ca) return check_ssl_ca(x);
}
-static int check_purpose_ns_ssl_server(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_ns_ssl_server(const X509_PURPOSE *xp, const X509 *x, int ca)
{
int ret;
ret = check_purpose_ssl_server(xp, x, ca);
}
/* common S/MIME checks */
-static int purpose_smime(X509 *x, int ca)
+static int purpose_smime(const X509 *x, int ca)
{
if(xku_reject(x,XKU_SMIME)) return 0;
if(ca) {
return 1;
}
-static int check_purpose_smime_sign(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_smime_sign(const X509_PURPOSE *xp, const X509 *x, int ca)
{
int ret;
ret = purpose_smime(x, ca);
return ret;
}
-static int check_purpose_smime_encrypt(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_smime_encrypt(const X509_PURPOSE *xp, const X509 *x, int ca)
{
int ret;
ret = purpose_smime(x, ca);
return ret;
}
-static int check_purpose_crl_sign(X509_PURPOSE *xp, X509 *x, int ca)
+static int check_purpose_crl_sign(const X509_PURPOSE *xp, const X509 *x, int ca)
{
if(ca) {
int ca_ret;
return 1;
}
-static int no_check(X509_PURPOSE *xp, X509 *x, int ca)
+static int no_check(const X509_PURPOSE *xp, const X509 *x, int ca)
{
return 1;
}
if (a == NULL) return;
M_ASN1_INTEGER_free(a->version);
sk_SXNETID_pop_free(a->ids, SXNETID_free);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_SXNETID(SXNETID *a, unsigned char **pp)
if (a == NULL) return;
M_ASN1_INTEGER_free(a->zone);
M_ASN1_OCTET_STRING_free(a->user);
- Free (a);
+ OPENSSL_free (a);
}
static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out,
id = sk_SXNETID_value(sx->ids, i);
tmp = i2s_ASN1_INTEGER(NULL, id->zone);
BIO_printf(out, "\n%*sZone: %s, User: ", indent, "", tmp);
- Free(tmp);
+ OPENSSL_free(tmp);
M_ASN1_OCTET_STRING_print(out, id->user);
}
return 1;
char *tname = NULL, *tvalue = NULL;
if(name && !(tname = BUF_strdup(name))) goto err;
if(value && !(tvalue = BUF_strdup(value))) goto err;;
- if(!(vtmp = (CONF_VALUE *)Malloc(sizeof(CONF_VALUE)))) goto err;
+ if(!(vtmp = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE)))) goto err;
if(!*extlist && !(*extlist = sk_CONF_VALUE_new(NULL))) goto err;
vtmp->section = NULL;
vtmp->name = tname;
return 1;
err:
X509V3err(X509V3_F_X509V3_ADD_VALUE,ERR_R_MALLOC_FAILURE);
- if(vtmp) Free(vtmp);
- if(tname) Free(tname);
- if(tvalue) Free(tvalue);
+ if(vtmp) OPENSSL_free(vtmp);
+ if(tname) OPENSSL_free(tname);
+ if(tvalue) OPENSSL_free(tvalue);
return 0;
}
void X509V3_conf_free(CONF_VALUE *conf)
{
if(!conf) return;
- if(conf->name) Free(conf->name);
- if(conf->value) Free(conf->value);
- if(conf->section) Free(conf->section);
- Free(conf);
+ if(conf->name) OPENSSL_free(conf->name);
+ if(conf->value) OPENSSL_free(conf->value);
+ if(conf->section) OPENSSL_free(conf->section);
+ OPENSSL_free(conf);
}
int X509V3_add_value_bool(const char *name, int asn1_bool,
if(!aint) return 1;
if(!(strtmp = i2s_ASN1_INTEGER(NULL, aint))) return 0;
ret = X509V3_add_value(name, strtmp, extlist);
- Free(strtmp);
+ OPENSSL_free(strtmp);
return ret;
}
}
X509V3_add_value(ntmp, NULL, &values);
}
-Free(linebuf);
+OPENSSL_free(linebuf);
return values;
err:
-Free(linebuf);
+OPENSSL_free(linebuf);
sk_CONF_VALUE_pop_free(values, X509V3_conf_free);
return NULL;
/* hex string utilities */
-/* Given a buffer of length 'len' return a Malloc'ed string with its
+/* Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
* hex representation
*/
int i;
static char hexdig[] = "0123456789ABCDEF";
if(!buffer || !len) return NULL;
- if(!(tmp = Malloc(len * 3 + 1))) {
+ if(!(tmp = OPENSSL_malloc(len * 3 + 1))) {
X509V3err(X509V3_F_HEX_TO_STRING,ERR_R_MALLOC_FAILURE);
return NULL;
}
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_INVALID_NULL_ARGUMENT);
return NULL;
}
- if(!(hexbuf = Malloc(strlen(str) >> 1))) goto err;
+ if(!(hexbuf = OPENSSL_malloc(strlen(str) >> 1))) goto err;
for(p = (unsigned char *)str, q = hexbuf; *p;) {
ch = *p++;
if(ch == ':') continue;
cl = *p++;
if(!cl) {
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ODD_NUMBER_OF_DIGITS);
- Free(hexbuf);
+ OPENSSL_free(hexbuf);
return NULL;
}
if(isupper(ch)) ch = tolower(ch);
return hexbuf;
err:
- if(hexbuf) Free(hexbuf);
+ if(hexbuf) OPENSSL_free(hexbuf);
X509V3err(X509V3_F_STRING_TO_HEX,ERR_R_MALLOC_FAILURE);
return NULL;
badhex:
- Free(hexbuf);
+ OPENSSL_free(hexbuf);
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ILLEGAL_HEX_DIGIT);
return NULL;
typedef struct v3_ext_ctx X509V3_CTX;
DECLARE_STACK_OF(X509V3_EXT_METHOD)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509V3_EXT_METHOD_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509V3_EXT_METHOD_new_null() sk_new_null()
+ #define sk_X509V3_EXT_METHOD_free(a) sk_free(a)
+ #define sk_X509V3_EXT_METHOD_num(a) sk_num(a)
+ #define sk_X509V3_EXT_METHOD_value(a,b) ((X509V3_EXT_METHOD *) \
+ sk_value((a),(b)))
+ #define sk_X509V3_EXT_METHOD_set(a,b,c) ((X509V3_EXT_METHOD *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509V3_EXT_METHOD_zero(a) sk_zero(a)
+ #define sk_X509V3_EXT_METHOD_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509V3_EXT_METHOD_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509V3_EXT_METHOD_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509V3_EXT_METHOD_delete(a,b) ((X509V3_EXT_METHOD *) \
+ sk_delete((a),(b)))
+ #define sk_X509V3_EXT_METHOD_delete_ptr(a,b) ((X509V3_EXT_METHOD *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509V3_EXT_METHOD_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509V3_EXT_METHOD_set_cmp_func(a,b) ((int (*) \
+ (const X509V3_EXT_METHOD * const *,const X509V3_EXT_METHOD * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509V3_EXT_METHOD_dup(a) sk_dup(a)
+ #define sk_X509V3_EXT_METHOD_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509V3_EXT_METHOD_shift(a) ((X509V3_EXT_METHOD *)sk_shift(a))
+ #define sk_X509V3_EXT_METHOD_pop(a) ((X509V3_EXT_METHOD *)sk_pop(a))
+ #define sk_X509V3_EXT_METHOD_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
/* ext_flags values */
#define X509V3_EXT_DYNAMIC 0x1
} ACCESS_DESCRIPTION;
DECLARE_STACK_OF(GENERAL_NAME)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_GENERAL_NAME_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_GENERAL_NAME_new_null() sk_new_null()
+ #define sk_GENERAL_NAME_free(a) sk_free(a)
+ #define sk_GENERAL_NAME_num(a) sk_num(a)
+ #define sk_GENERAL_NAME_value(a,b) ((GENERAL_NAME *) \
+ sk_value((a),(b)))
+ #define sk_GENERAL_NAME_set(a,b,c) ((GENERAL_NAME *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_GENERAL_NAME_zero(a) sk_zero(a)
+ #define sk_GENERAL_NAME_push(a,b) sk_push((a),(char *)(b))
+ #define sk_GENERAL_NAME_unshift(a,b) sk_unshift((a),(b))
+ #define sk_GENERAL_NAME_find(a,b) sk_find((a), (char *)(b))
+ #define sk_GENERAL_NAME_delete(a,b) ((GENERAL_NAME *) \
+ sk_delete((a),(b)))
+ #define sk_GENERAL_NAME_delete_ptr(a,b) ((GENERAL_NAME *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_GENERAL_NAME_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_GENERAL_NAME_set_cmp_func(a,b) ((int (*) \
+ (const GENERAL_NAME * const *,const GENERAL_NAME * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_GENERAL_NAME_dup(a) sk_dup(a)
+ #define sk_GENERAL_NAME_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_GENERAL_NAME_shift(a) ((GENERAL_NAME *)sk_shift(a))
+ #define sk_GENERAL_NAME_pop(a) ((GENERAL_NAME *)sk_pop(a))
+ #define sk_GENERAL_NAME_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(GENERAL_NAME)
DECLARE_STACK_OF(ACCESS_DESCRIPTION)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_ACCESS_DESCRIPTION_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_ACCESS_DESCRIPTION_new_null() sk_new_null()
+ #define sk_ACCESS_DESCRIPTION_free(a) sk_free(a)
+ #define sk_ACCESS_DESCRIPTION_num(a) sk_num(a)
+ #define sk_ACCESS_DESCRIPTION_value(a,b) ((ACCESS_DESCRIPTION *) \
+ sk_value((a),(b)))
+ #define sk_ACCESS_DESCRIPTION_set(a,b,c) ((ACCESS_DESCRIPTION *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_ACCESS_DESCRIPTION_zero(a) sk_zero(a)
+ #define sk_ACCESS_DESCRIPTION_push(a,b) sk_push((a),(char *)(b))
+ #define sk_ACCESS_DESCRIPTION_unshift(a,b) sk_unshift((a),(b))
+ #define sk_ACCESS_DESCRIPTION_find(a,b) sk_find((a), (char *)(b))
+ #define sk_ACCESS_DESCRIPTION_delete(a,b) ((ACCESS_DESCRIPTION *) \
+ sk_delete((a),(b)))
+ #define sk_ACCESS_DESCRIPTION_delete_ptr(a,b) ((ACCESS_DESCRIPTION *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_ACCESS_DESCRIPTION_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_ACCESS_DESCRIPTION_set_cmp_func(a,b) ((int (*) \
+ (const ACCESS_DESCRIPTION * const *,const ACCESS_DESCRIPTION * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_ACCESS_DESCRIPTION_dup(a) sk_dup(a)
+ #define sk_ACCESS_DESCRIPTION_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_ACCESS_DESCRIPTION_shift(a) ((ACCESS_DESCRIPTION *)sk_shift(a))
+ #define sk_ACCESS_DESCRIPTION_pop(a) ((ACCESS_DESCRIPTION *)sk_pop(a))
+ #define sk_ACCESS_DESCRIPTION_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION)
typedef struct DIST_POINT_NAME_st {
} DIST_POINT;
DECLARE_STACK_OF(DIST_POINT)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_DIST_POINT_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_DIST_POINT_new_null() sk_new_null()
+ #define sk_DIST_POINT_free(a) sk_free(a)
+ #define sk_DIST_POINT_num(a) sk_num(a)
+ #define sk_DIST_POINT_value(a,b) ((DIST_POINT *) \
+ sk_value((a),(b)))
+ #define sk_DIST_POINT_set(a,b,c) ((DIST_POINT *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_DIST_POINT_zero(a) sk_zero(a)
+ #define sk_DIST_POINT_push(a,b) sk_push((a),(char *)(b))
+ #define sk_DIST_POINT_unshift(a,b) sk_unshift((a),(b))
+ #define sk_DIST_POINT_find(a,b) sk_find((a), (char *)(b))
+ #define sk_DIST_POINT_delete(a,b) ((DIST_POINT *) \
+ sk_delete((a),(b)))
+ #define sk_DIST_POINT_delete_ptr(a,b) ((DIST_POINT *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_DIST_POINT_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_DIST_POINT_set_cmp_func(a,b) ((int (*) \
+ (const DIST_POINT * const *,const DIST_POINT * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_DIST_POINT_dup(a) sk_dup(a)
+ #define sk_DIST_POINT_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_DIST_POINT_shift(a) ((DIST_POINT *)sk_shift(a))
+ #define sk_DIST_POINT_pop(a) ((DIST_POINT *)sk_pop(a))
+ #define sk_DIST_POINT_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(DIST_POINT)
typedef struct AUTHORITY_KEYID_st {
} SXNETID;
DECLARE_STACK_OF(SXNETID)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_SXNETID_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_SXNETID_new_null() sk_new_null()
+ #define sk_SXNETID_free(a) sk_free(a)
+ #define sk_SXNETID_num(a) sk_num(a)
+ #define sk_SXNETID_value(a,b) ((SXNETID *) \
+ sk_value((a),(b)))
+ #define sk_SXNETID_set(a,b,c) ((SXNETID *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_SXNETID_zero(a) sk_zero(a)
+ #define sk_SXNETID_push(a,b) sk_push((a),(char *)(b))
+ #define sk_SXNETID_unshift(a,b) sk_unshift((a),(b))
+ #define sk_SXNETID_find(a,b) sk_find((a), (char *)(b))
+ #define sk_SXNETID_delete(a,b) ((SXNETID *) \
+ sk_delete((a),(b)))
+ #define sk_SXNETID_delete_ptr(a,b) ((SXNETID *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_SXNETID_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_SXNETID_set_cmp_func(a,b) ((int (*) \
+ (const SXNETID * const *,const SXNETID * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_SXNETID_dup(a) sk_dup(a)
+ #define sk_SXNETID_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_SXNETID_shift(a) ((SXNETID *)sk_shift(a))
+ #define sk_SXNETID_pop(a) ((SXNETID *)sk_pop(a))
+ #define sk_SXNETID_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(SXNETID)
typedef struct SXNET_st {
} POLICYQUALINFO;
DECLARE_STACK_OF(POLICYQUALINFO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_POLICYQUALINFO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_POLICYQUALINFO_new_null() sk_new_null()
+ #define sk_POLICYQUALINFO_free(a) sk_free(a)
+ #define sk_POLICYQUALINFO_num(a) sk_num(a)
+ #define sk_POLICYQUALINFO_value(a,b) ((POLICYQUALINFO *) \
+ sk_value((a),(b)))
+ #define sk_POLICYQUALINFO_set(a,b,c) ((POLICYQUALINFO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_POLICYQUALINFO_zero(a) sk_zero(a)
+ #define sk_POLICYQUALINFO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_POLICYQUALINFO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_POLICYQUALINFO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_POLICYQUALINFO_delete(a,b) ((POLICYQUALINFO *) \
+ sk_delete((a),(b)))
+ #define sk_POLICYQUALINFO_delete_ptr(a,b) ((POLICYQUALINFO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_POLICYQUALINFO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_POLICYQUALINFO_set_cmp_func(a,b) ((int (*) \
+ (const POLICYQUALINFO * const *,const POLICYQUALINFO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_POLICYQUALINFO_dup(a) sk_dup(a)
+ #define sk_POLICYQUALINFO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_POLICYQUALINFO_shift(a) ((POLICYQUALINFO *)sk_shift(a))
+ #define sk_POLICYQUALINFO_pop(a) ((POLICYQUALINFO *)sk_pop(a))
+ #define sk_POLICYQUALINFO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(POLICYQUALINFO)
typedef struct POLICYINFO_st {
} POLICYINFO;
DECLARE_STACK_OF(POLICYINFO)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_POLICYINFO_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_POLICYINFO_new_null() sk_new_null()
+ #define sk_POLICYINFO_free(a) sk_free(a)
+ #define sk_POLICYINFO_num(a) sk_num(a)
+ #define sk_POLICYINFO_value(a,b) ((POLICYINFO *) \
+ sk_value((a),(b)))
+ #define sk_POLICYINFO_set(a,b,c) ((POLICYINFO *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_POLICYINFO_zero(a) sk_zero(a)
+ #define sk_POLICYINFO_push(a,b) sk_push((a),(char *)(b))
+ #define sk_POLICYINFO_unshift(a,b) sk_unshift((a),(b))
+ #define sk_POLICYINFO_find(a,b) sk_find((a), (char *)(b))
+ #define sk_POLICYINFO_delete(a,b) ((POLICYINFO *) \
+ sk_delete((a),(b)))
+ #define sk_POLICYINFO_delete_ptr(a,b) ((POLICYINFO *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_POLICYINFO_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_POLICYINFO_set_cmp_func(a,b) ((int (*) \
+ (const POLICYINFO * const *,const POLICYINFO * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_POLICYINFO_dup(a) sk_dup(a)
+ #define sk_POLICYINFO_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_POLICYINFO_shift(a) ((POLICYINFO *)sk_shift(a))
+ #define sk_POLICYINFO_pop(a) ((POLICYINFO *)sk_pop(a))
+ #define sk_POLICYINFO_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
DECLARE_ASN1_SET_OF(POLICYINFO)
#define X509V3_conf_err(val) ERR_add_error_data(6, "section:", val->section, \
int purpose;
int trust; /* Default trust ID */
int flags;
- int (*check_purpose)(struct x509_purpose_st *, X509 *, int);
+ int (*check_purpose)(const struct x509_purpose_st *,
+ const X509 *, int);
char *name;
char *sname;
void *usr_data;
#define X509_PURPOSE_MAX 7
DECLARE_STACK_OF(X509_PURPOSE)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_X509_PURPOSE_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_X509_PURPOSE_new_null() sk_new_null()
+ #define sk_X509_PURPOSE_free(a) sk_free(a)
+ #define sk_X509_PURPOSE_num(a) sk_num(a)
+ #define sk_X509_PURPOSE_value(a,b) ((X509_PURPOSE *) \
+ sk_value((a),(b)))
+ #define sk_X509_PURPOSE_set(a,b,c) ((X509_PURPOSE *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_X509_PURPOSE_zero(a) sk_zero(a)
+ #define sk_X509_PURPOSE_push(a,b) sk_push((a),(char *)(b))
+ #define sk_X509_PURPOSE_unshift(a,b) sk_unshift((a),(b))
+ #define sk_X509_PURPOSE_find(a,b) sk_find((a), (char *)(b))
+ #define sk_X509_PURPOSE_delete(a,b) ((X509_PURPOSE *) \
+ sk_delete((a),(b)))
+ #define sk_X509_PURPOSE_delete_ptr(a,b) ((X509_PURPOSE *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_X509_PURPOSE_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_X509_PURPOSE_set_cmp_func(a,b) ((int (*) \
+ (const X509_PURPOSE * const *,const X509_PURPOSE * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_X509_PURPOSE_dup(a) sk_dup(a)
+ #define sk_X509_PURPOSE_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_X509_PURPOSE_shift(a) ((X509_PURPOSE *)sk_shift(a))
+ #define sk_X509_PURPOSE_pop(a) ((X509_PURPOSE *)sk_pop(a))
+ #define sk_X509_PURPOSE_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
void ERR_load_X509V3_strings(void);
int i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **pp);
int X509_PURPOSE_get_by_sname(char *sname);
int X509_PURPOSE_get_by_id(int id);
int X509_PURPOSE_add(int id, int trust, int flags,
- int (*ck)(X509_PURPOSE *, X509 *, int),
+ int (*ck)(const X509_PURPOSE *, const X509 *, int),
char *name, char *sname, void *arg);
char *X509_PURPOSE_get0_name(X509_PURPOSE *xp);
char *X509_PURPOSE_get0_sname(X509_PURPOSE *xp);
if (verbose) BIO_printf(bio_err,"bufsize=%d\n",bsize);
}
- strbuf=Malloc(SIZE);
- buff=(unsigned char *)Malloc(EVP_ENCODE_LENGTH(bsize));
+ strbuf=OPENSSL_malloc(SIZE);
+ buff=(unsigned char *)OPENSSL_malloc(EVP_ENCODE_LENGTH(bsize));
if ((buff == NULL) || (strbuf == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"OPENSSL_malloc failure\n");
goto end;
}
BIO_printf(bio_err,"bytes written:%8ld\n",BIO_number_written(out));
}
end:
- if (strbuf != NULL) Free(strbuf);
- if (buff != NULL) Free(buff);
+ if (strbuf != NULL) OPENSSL_free(strbuf);
+ if (buff != NULL) OPENSSL_free(buff);
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (benc != NULL) BIO_free(benc);
Message Digest Calculation.
-=item L<B<dh>|dh(1)>
+=item B<dh>
-Diffie-Hellman Data Management.
+Diffie-Hellman Parameter Management.
+Obsoleted by L<B<dhparam>|dhparam(1)>.
=item L<B<dsa>|dsa(1)>
Error Number to Error String Conversion.
-=item L<B<gendh>|gendh(1)>
+=item L<B<dhparam>|dhparam(1)>
+
+Generation and Management of Diffie-Hellman Parameters.
+
+=item B<gendh>
Generation of Diffie-Hellman Parameters.
+Obsoleted by L<B<dhparam>|dhparam(1)>.
=item L<B<gendsa>|gendsa(1)>
days to certify the certificate for. The default is 30 days.
=item B<-extensions section>
+
=item B<-reqexts section>
these options specify alternative sections to include certificate
=back
B<flen> must be less than RSA_size(B<rsa>) - 11 for the PKCS #1 v1.5
-based padding modes, and less than RSA_size(B<rsa>) - 21 for
+based padding modes, and less than RSA_size(B<rsa>) - 41 for
RSA_PKCS1_OAEP_PADDING. The random number generator must be seeded
prior to calling RSA_public_encrypt().
# define MS_STATIC
#endif
-#if defined(_WIN32) && !defined(WIN32)
+#if defined(_WIN32) && !defined(WIN32) && !defined(__CYGWIN32__)
# define WIN32
#endif
-#if defined(WIN32) || defined(WIN16)
+#if (defined(WIN32) || defined(WIN16)) && !defined(__CYGWIN32__)
# ifndef WINDOWS
# define WINDOWS
# endif
#define clear_sys_error() errno=0
#endif
-#ifdef WINDOWS
+#if defined(WINDOWS) && !defined(__CYGWIN32__)
#define get_last_socket_error() WSAGetLastError()
#define clear_socket_error() WSASetLastError(0)
#define readsocket(s,b,n) recv((s),(b),(n),0)
# define NO_FP_API
#endif
-#if defined(WINDOWS) || defined(MSDOS)
+#if (defined(WINDOWS) || defined(MSDOS)) && !defined(__CYGWIN32__)
# ifndef S_IFDIR
# define S_IFDIR _S_IFDIR
#endif
#endif
-#if defined(sun) && !defined(__svr4__)
-#define memmove(s1,s2,b) bcopy((s2),(s1),(n))
-#define strtoul(s,e,b) ((unsigned long int)strtol((s),(e),(b)))
+#if defined(sun) && !defined(__svr4__) && !defined(__SVR4)
+#define memmove(s1,s2,n) bcopy((s2),(s1),(n))
#endif
/***********************************************/
{
BIO_SSL *bs;
- bs=(BIO_SSL *)Malloc(sizeof(BIO_SSL));
+ bs=(BIO_SSL *)OPENSSL_malloc(sizeof(BIO_SSL));
if (bs == NULL)
{
BIOerr(BIO_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
a->flags=0;
}
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
return(1);
}
if (n <= 0) return(n);
p=s->packet;
- if ((buf=Malloc(n)) == NULL)
+ if ((buf=OPENSSL_malloc(n)) == NULL)
{
SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
goto err;
}
s->init_num=0;
- if (buf != buf_space) Free(buf);
+ if (buf != buf_space) OPENSSL_free(buf);
s->first_packet=1;
return(SSL_accept(s));
err:
- if (buf != buf_space) Free(buf);
+ if (buf != buf_space) OPENSSL_free(buf);
return(-1);
}
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
rs= s->enc_read_ctx;
{
SSL2_STATE *s2;
- if ((s2=Malloc(sizeof *s2)) == NULL) goto err;
+ if ((s2=OPENSSL_malloc(sizeof *s2)) == NULL) goto err;
memset(s2,0,sizeof *s2);
- if ((s2->rbuf=Malloc(
+ if ((s2->rbuf=OPENSSL_malloc(
SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
- if ((s2->wbuf=Malloc(
+ if ((s2->wbuf=OPENSSL_malloc(
SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
s->s2=s2;
err:
if (s2 != NULL)
{
- if (s2->wbuf != NULL) Free(s2->wbuf);
- if (s2->rbuf != NULL) Free(s2->rbuf);
- Free(s2);
+ if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
+ if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
+ OPENSSL_free(s2);
}
return(0);
}
return;
s2=s->s2;
- if (s2->rbuf != NULL) Free(s2->rbuf);
- if (s2->wbuf != NULL) Free(s2->wbuf);
+ if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
+ if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
memset(s2,0,sizeof *s2);
- Free(s2);
+ OPENSSL_free(s2);
s->s2=NULL;
}
EVP_VerifyUpdate(&ctx,ccd,SSL2_MIN_CERT_CHALLENGE_LENGTH);
i=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,NULL);
- buf2=Malloc((unsigned int)i);
+ buf2=OPENSSL_malloc((unsigned int)i);
if (buf2 == NULL)
{
SSLerr(SSL_F_REQUEST_CERTIFICATE,ERR_R_MALLOC_FAILURE);
p2=buf2;
i=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,&p2);
EVP_VerifyUpdate(&ctx,buf2,(unsigned int)i);
- Free(buf2);
+ OPENSSL_free(buf2);
pkey=X509_get_pubkey(x509);
if (pkey == NULL) goto end;
extra=SSL3_RT_MAX_EXTRA;
else
extra=0;
- if ((p=Malloc(SSL3_RT_MAX_PACKET_SIZE+extra))
+ if ((p=OPENSSL_malloc(SSL3_RT_MAX_PACKET_SIZE+extra))
== NULL)
goto err;
s->s3->rbuf.buf=p;
if (s->s3->wbuf.buf == NULL)
{
- if ((p=Malloc(SSL3_RT_MAX_PACKET_SIZE))
+ if ((p=OPENSSL_malloc(SSL3_RT_MAX_PACKET_SIZE))
== NULL)
goto err;
s->s3->wbuf.buf=p;
static int ssl3_client_hello(SSL *s);
static int ssl3_get_server_hello(SSL *s);
static int ssl3_get_certificate_request(SSL *s);
-static int ca_dn_cmp(X509_NAME **a,X509_NAME **b);
+static int ca_dn_cmp(const X509_NAME * const *a,const X509_NAME * const *b);
static int ssl3_get_server_done(SSL *s);
static int ssl3_send_client_verify(SSL *s);
static int ssl3_send_client_certificate(SSL *s);
return(ret);
}
-static int ca_dn_cmp(X509_NAME **a, X509_NAME **b)
+static int ca_dn_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
{
return(X509_NAME_cmp(*a,*b));
}
{
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_read_ctx;
s->read_hash=m;
}
if (s->s3->rrec.comp == NULL)
s->s3->rrec.comp=(unsigned char *)
- Malloc(SSL3_RT_MAX_PLAIN_LENGTH);
+ OPENSSL_malloc(SSL3_RT_MAX_PLAIN_LENGTH);
if (s->s3->rrec.comp == NULL)
goto err;
}
{
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_write_ctx;
s->write_hash=m;
ssl3_cleanup_key_block(s);
- if ((p=Malloc(num)) == NULL)
+ if ((p=OPENSSL_malloc(num)) == NULL)
goto err;
s->s3->tmp.key_block_length=num;
{
memset(s->s3->tmp.key_block,0,
s->s3->tmp.key_block_length);
- Free(s->s3->tmp.key_block);
+ OPENSSL_free(s->s3->tmp.key_block);
s->s3->tmp.key_block=NULL;
}
s->s3->tmp.key_block_length=0;
{
SSL3_STATE *s3;
- if ((s3=Malloc(sizeof *s3)) == NULL) goto err;
+ if ((s3=OPENSSL_malloc(sizeof *s3)) == NULL) goto err;
memset(s3,0,sizeof *s3);
s->s3=s3;
ssl3_cleanup_key_block(s);
if (s->s3->rbuf.buf != NULL)
- Free(s->s3->rbuf.buf);
+ OPENSSL_free(s->s3->rbuf.buf);
if (s->s3->wbuf.buf != NULL)
- Free(s->s3->wbuf.buf);
+ OPENSSL_free(s->s3->wbuf.buf);
if (s->s3->rrec.comp != NULL)
- Free(s->s3->rrec.comp);
+ OPENSSL_free(s->s3->rrec.comp);
#ifndef NO_DH
if (s->s3->tmp.dh != NULL)
DH_free(s->s3->tmp.dh);
if (s->s3->tmp.ca_names != NULL)
sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
memset(s->s3,0,sizeof *s->s3);
- Free(s->s3);
+ OPENSSL_free(s->s3);
s->s3=NULL;
}
if (s->s3->rrec.comp != NULL)
{
- Free(s->s3->rrec.comp);
+ OPENSSL_free(s->s3->rrec.comp);
s->s3->rrec.comp=NULL;
}
#ifndef NO_DH
} SSL_CIPHER;
DECLARE_STACK_OF(SSL_CIPHER)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_SSL_CIPHER_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_SSL_CIPHER_new_null() sk_new_null()
+ #define sk_SSL_CIPHER_free(a) sk_free(a)
+ #define sk_SSL_CIPHER_num(a) sk_num(a)
+ #define sk_SSL_CIPHER_value(a,b) ((SSL_CIPHER *) \
+ sk_value((a),(b)))
+ #define sk_SSL_CIPHER_set(a,b,c) ((SSL_CIPHER *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_SSL_CIPHER_zero(a) sk_zero(a)
+ #define sk_SSL_CIPHER_push(a,b) sk_push((a),(char *)(b))
+ #define sk_SSL_CIPHER_unshift(a,b) sk_unshift((a),(b))
+ #define sk_SSL_CIPHER_find(a,b) sk_find((a), (char *)(b))
+ #define sk_SSL_CIPHER_delete(a,b) ((SSL_CIPHER *) \
+ sk_delete((a),(b)))
+ #define sk_SSL_CIPHER_delete_ptr(a,b) ((SSL_CIPHER *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_SSL_CIPHER_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_SSL_CIPHER_set_cmp_func(a,b) ((int (*) \
+ (const SSL_CIPHER * const *,const SSL_CIPHER * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_SSL_CIPHER_dup(a) sk_dup(a)
+ #define sk_SSL_CIPHER_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_SSL_CIPHER_shift(a) ((SSL_CIPHER *)sk_shift(a))
+ #define sk_SSL_CIPHER_pop(a) ((SSL_CIPHER *)sk_pop(a))
+ #define sk_SSL_CIPHER_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
typedef struct ssl_st SSL;
typedef struct ssl_ctx_st SSL_CTX;
} SSL_COMP;
DECLARE_STACK_OF(SSL_COMP)
+/* This block of defines is updated by a perl script, please do not touch! */
+#ifndef DEBUG_SAFESTACK
+ #define sk_SSL_COMP_new(a) sk_new((int (*) \
+ (const char * const *, const char * const *))(a))
+ #define sk_SSL_COMP_new_null() sk_new_null()
+ #define sk_SSL_COMP_free(a) sk_free(a)
+ #define sk_SSL_COMP_num(a) sk_num(a)
+ #define sk_SSL_COMP_value(a,b) ((SSL_COMP *) \
+ sk_value((a),(b)))
+ #define sk_SSL_COMP_set(a,b,c) ((SSL_COMP *) \
+ sk_set((a),(b),(char *)(c)))
+ #define sk_SSL_COMP_zero(a) sk_zero(a)
+ #define sk_SSL_COMP_push(a,b) sk_push((a),(char *)(b))
+ #define sk_SSL_COMP_unshift(a,b) sk_unshift((a),(b))
+ #define sk_SSL_COMP_find(a,b) sk_find((a), (char *)(b))
+ #define sk_SSL_COMP_delete(a,b) ((SSL_COMP *) \
+ sk_delete((a),(b)))
+ #define sk_SSL_COMP_delete_ptr(a,b) ((SSL_COMP *) \
+ sk_delete_ptr((a),(char *)(b)))
+ #define sk_SSL_COMP_insert(a,b,c) sk_insert((a),(char *)(b),(c))
+ #define sk_SSL_COMP_set_cmp_func(a,b) ((int (*) \
+ (const SSL_COMP * const *,const SSL_COMP * const *)) \
+ sk_set_cmp_func((a),(int (*) \
+ (const char * const *, const char * const *))(b)))
+ #define sk_SSL_COMP_dup(a) sk_dup(a)
+ #define sk_SSL_COMP_pop_free(a,b) sk_pop_free((a),(void (*)(void *))(b))
+ #define sk_SSL_COMP_shift(a) ((SSL_COMP *)sk_shift(a))
+ #define sk_SSL_COMP_pop(a) ((SSL_COMP *)sk_pop(a))
+ #define sk_SSL_COMP_sort(a) sk_sort(a)
+#endif /* !DEBUG_SAFESTACK */
+/* End of perl script block, you may now edit :-) */
struct ssl_ctx_st
{
/* Note that I cheat in the following 2 assignments. I know
* that if the ASN1_INTEGER passed to ASN1_INTEGER_set
- * is > sizeof(long)+1, the buffer will not be re-Malloc()ed.
+ * is > sizeof(long)+1, the buffer will not be re-OPENSSL_malloc()ed.
* This is a bit evil but makes things simple, no dynamic allocation
* to clean up :-) */
a.version.length=LSIZE2;
ai.data=NULL; ai.length=0;
M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
version=(int)ASN1_INTEGER_get(aip);
- if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+ if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
/* we don't care about the version right now :-) */
M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
ssl_version=(int)ASN1_INTEGER_get(aip);
ret->ssl_version=ssl_version;
- if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+ if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
os.data=NULL; os.length=0;
M_ASN1_D2I_get(osp,d2i_ASN1_OCTET_STRING);
else
ret->key_arg_length=os.length;
memcpy(ret->key_arg,os.data,ret->key_arg_length);
- if (os.data != NULL) Free(os.data);
+ if (os.data != NULL) OPENSSL_free(os.data);
ai.length=0;
M_ASN1_D2I_get_EXP_opt(aip,d2i_ASN1_INTEGER,1);
if (ai.data != NULL)
{
ret->time=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->time=time(NULL);
if (ai.data != NULL)
{
ret->timeout=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->timeout=3;
SSLerr(SSL_F_D2I_SSL_SESSION,SSL_R_BAD_LENGTH);
ret->sid_ctx_length=os.length;
memcpy(ret->sid_ctx,os.data,os.length);
- Free(os.data); os.data=NULL; os.length=0;
+ OPENSSL_free(os.data); os.data=NULL; os.length=0;
}
else
ret->sid_ctx_length=0;
if (ai.data != NULL)
{
ret->verify_result=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->verify_result=X509_V_OK;
{
CERT *ret;
- ret=(CERT *)Malloc(sizeof(CERT));
+ ret=(CERT *)OPENSSL_malloc(sizeof(CERT));
if (ret == NULL)
{
SSLerr(SSL_F_SSL_CERT_NEW,ERR_R_MALLOC_FAILURE);
CERT *ret;
int i;
- ret = (CERT *)Malloc(sizeof(CERT));
+ ret = (CERT *)OPENSSL_malloc(sizeof(CERT));
if (ret == NULL)
{
SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
EVP_PKEY_free(c->pkeys[i].publickey);
#endif
}
- Free(c);
+ OPENSSL_free(c);
}
int ssl_cert_inst(CERT **o)
{
SESS_CERT *ret;
- ret = Malloc(sizeof *ret);
+ ret = OPENSSL_malloc(sizeof *ret);
if (ret == NULL)
{
SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE);
DH_free(sc->peer_dh_tmp);
#endif
- Free(sc);
+ OPENSSL_free(sc);
}
int ssl_set_peer_cert_type(SESS_CERT *sc,int type)
return(add_client_CA(&(ctx->client_CA),x));
}
-static int xname_cmp(X509_NAME **a,X509_NAME **b)
+static int xname_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
{
return(X509_NAME_cmp(*a,*b));
}
X509 *x=NULL;
X509_NAME *xn=NULL;
int ret=1;
- int (*oldcmp)(X509_NAME **a, X509_NAME **b);
+ int (*oldcmp)(const X509_NAME * const *a, const X509_NAME * const *b);
oldcmp=sk_X509_NAME_set_cmp_func(stack,xname_cmp);
curr = curr->next;
}
- number_uses = Malloc((max_strength_bits + 1) * sizeof(int));
+ number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));
if (!number_uses)
{
SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT,ERR_R_MALLOC_FAILURE);
ssl_cipher_apply_rule(0, 0, 0, 0, CIPHER_ORD, i,
list, head_p, tail_p);
- Free(number_uses);
+ OPENSSL_free(number_uses);
return(1);
}
* it is used for allocation.
*/
num_of_ciphers = ssl_method->num_ciphers();
- list = (CIPHER_ORDER *)Malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
+ list = (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
if (list == NULL)
{
SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
ca_list =
- (SSL_CIPHER **)Malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);
+ (SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);
if (ca_list == NULL)
{
- Free(list);
+ OPENSSL_free(list);
SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
return(NULL); /* Failure */
}
ok = ssl_cipher_process_rulestr(rule_p, list, &head, &tail,
ca_list);
- Free(ca_list); /* Not needed anymore */
+ OPENSSL_free(ca_list); /* Not needed anymore */
if (!ok)
{ /* Rule processing failure */
- Free(list);
+ OPENSSL_free(list);
return(NULL);
}
/*
*/
if ((cipherstack = sk_SSL_CIPHER_new(NULL)) == NULL)
{
- Free(list);
+ OPENSSL_free(list);
return(NULL);
}
#endif
}
}
- Free(list); /* Not needed any longer */
+ OPENSSL_free(list); /* Not needed any longer */
/*
* The following passage is a little bit odd. If pointer variables
if (buf == NULL)
{
len=128;
- buf=Malloc(len);
- if (buf == NULL) return("Malloc Error");
+ buf=OPENSSL_malloc(len);
+ if (buf == NULL) return("OPENSSL_malloc Error");
}
else if (len < 128)
return("Buffer too small");
return(NULL);
}
-static int sk_comp_cmp(SSL_COMP **a,SSL_COMP **b)
+static int sk_comp_cmp(const SSL_COMP * const *a,
+ const SSL_COMP * const *b)
{
return((*a)->id-(*b)->id);
}
SSL_COMP *comp;
STACK_OF(SSL_COMP) *sk;
- comp=(SSL_COMP *)Malloc(sizeof(SSL_COMP));
+ comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
comp->id=id;
comp->method=cm;
if (ssl_comp_methods == NULL)
return(NULL);
}
- s=(SSL *)Malloc(sizeof(SSL));
+ s=(SSL *)OPENSSL_malloc(sizeof(SSL));
if (s == NULL) goto err;
memset(s,0,sizeof(SSL));
ssl_cert_free(s->cert);
if (s->ctx != NULL)
SSL_CTX_free(s->ctx); /* decrement reference count */
- Free(s);
+ OPENSSL_free(s);
}
SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
if (s->method != NULL) s->method->ssl_free(s);
- Free(s);
+ OPENSSL_free(s);
}
void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
}
}
-int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b)
+int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
{
long l;
return((l > 0)?1:-1);
}
-int ssl_cipher_ptr_id_cmp(SSL_CIPHER **ap,SSL_CIPHER **bp)
+int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
+ const SSL_CIPHER * const *bp)
{
long l;
SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
goto err;
}
- ret=(SSL_CTX *)Malloc(sizeof(SSL_CTX));
+ ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
if (ret == NULL)
goto err;
}
static void SSL_COMP_free(SSL_COMP *comp)
- { Free(comp); }
+ { OPENSSL_free(comp); }
void SSL_CTX_free(SSL_CTX *a)
{
sk_X509_pop_free(a->extra_certs,X509_free);
if (a->comp_methods != NULL)
sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
- Free(a);
+ OPENSSL_free(a);
}
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
if (s->enc_read_ctx != NULL)
{
EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
- Free(s->enc_read_ctx);
+ OPENSSL_free(s->enc_read_ctx);
s->enc_read_ctx=NULL;
}
if (s->enc_write_ctx != NULL)
{
EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
- Free(s->enc_write_ctx);
+ OPENSSL_free(s->enc_write_ctx);
s->enc_write_ctx=NULL;
}
if (s->expand != NULL)
int ssl_set_peer_cert_type(SESS_CERT *c, int type);
int ssl_get_new_session(SSL *s, int session);
int ssl_get_prev_session(SSL *s, unsigned char *session,int len);
-int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b);
-int ssl_cipher_ptr_id_cmp(SSL_CIPHER **ap,SSL_CIPHER **bp);
+int ssl_cipher_id_cmp(const SSL_CIPHER *a,const SSL_CIPHER *b);
+int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
+ const SSL_CIPHER * const *bp);
STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
STACK_OF(SSL_CIPHER) **skp);
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p);
{
SSL_SESSION *ss;
- ss=(SSL_SESSION *)Malloc(sizeof(SSL_SESSION));
+ ss=(SSL_SESSION *)OPENSSL_malloc(sizeof(SSL_SESSION));
if (ss == NULL)
{
SSLerr(SSL_F_SSL_SESSION_NEW,ERR_R_MALLOC_FAILURE);
#if 0 /* This is way too late. */
/* If a thread got the session, then 'swaped', and another got
- * it and then due to a time-out decided to 'Free' it we could
+ * it and then due to a time-out decided to 'OPENSSL_free' it we could
* be in trouble. So I'll increment it now, then double decrement
* later - am I speaking rubbish?. */
CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
if (ss->peer != NULL) X509_free(ss->peer);
if (ss->ciphers != NULL) sk_SSL_CIPHER_free(ss->ciphers);
memset(ss,0,sizeof(*ss));
- Free(ss);
+ OPENSSL_free(ss);
}
int SSL_set_session(SSL *s, SSL_SESSION *session)
ret=0;
err:
/* We have to set the BIO's to NULL otherwise they will be
- * Free()ed twice. Once when th s_ssl is SSL_free()ed and
+ * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
* again when c_ssl is SSL_free()ed.
* This is a hack required because s_ssl and c_ssl are sharing the same
* BIO structure and SSL_set_bio() and SSL_free() automatically
{
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_read_ctx;
s->read_hash=m;
}
if (s->s3->rrec.comp == NULL)
s->s3->rrec.comp=(unsigned char *)
- Malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
+ OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
if (s->s3->rrec.comp == NULL)
goto err;
}
{
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_write_ctx;
s->write_hash=m;
ssl3_cleanup_key_block(s);
- if ((p1=(unsigned char *)Malloc(num)) == NULL)
+ if ((p1=(unsigned char *)OPENSSL_malloc(num)) == NULL)
goto err;
- if ((p2=(unsigned char *)Malloc(num)) == NULL)
+ if ((p2=(unsigned char *)OPENSSL_malloc(num)) == NULL)
goto err;
s->s3->tmp.key_block_length=num;
#endif
tls1_generate_key_block(s,p1,p2,num);
memset(p2,0,num);
- Free(p2);
+ OPENSSL_free(p2);
#ifdef TLS_DEBUG
printf("\nkey block\n");
{ int z; for (z=0; z<num; z++) printf("%02X%c",p1[z],((z+1)%16)?' ':'\n'); }
d2i_DIRECTORYSTRING 1344
i2d_DISPLAYTEXT 1345
d2i_DISPLAYTEXT 1346
-sk_X509_NAME_new 1347
-sk_X509_NAME_new_null 1348
-sk_X509_NAME_free 1349
-sk_X509_NAME_num 1350
-sk_X509_NAME_value 1351
-sk_X509_NAME_set 1352
-sk_X509_NAME_zero 1353
-sk_X509_NAME_push 1354
-sk_X509_NAME_pop 1355
-sk_X509_NAME_find 1356
-sk_X509_NAME_delete 1357
-sk_X509_NAME_delete_ptr 1358
-sk_X509_NAME_set_cmp_func 1359
-sk_X509_NAME_dup 1360
-sk_X509_NAME_pop_free 1361
-sk_X509_NAME_shift 1362
-sk_X509_new 1363
-sk_X509_new_null 1364
-sk_X509_free 1365
-sk_X509_num 1366
-sk_X509_value 1367
-sk_X509_set 1368
-sk_X509_zero 1369
-sk_X509_push 1370
-sk_X509_pop 1371
-sk_X509_find 1372
-sk_X509_delete 1373
-sk_X509_delete_ptr 1374
-sk_X509_set_cmp_func 1375
-sk_X509_dup 1376
-sk_X509_pop_free 1377
-sk_X509_shift 1378
d2i_ASN1_SET_OF_X509 1379
i2d_ASN1_SET_OF_X509 1380
-sk_X509_ATTRIBUTE_new 1381
-sk_X509_ATTRIBUTE_new_null 1382
-sk_X509_ATTRIBUTE_free 1383
-sk_X509_ATTRIBUTE_num 1384
-sk_X509_ATTRIBUTE_value 1385
-sk_X509_ATTRIBUTE_set 1386
-sk_X509_ATTRIBUTE_zero 1387
-sk_X509_ATTRIBUTE_push 1388
-sk_X509_ATTRIBUTE_pop 1389
-sk_X509_ATTRIBUTE_find 1390
-sk_X509_ATTRIBUTE_delete 1391
-sk_X509_ATTRIBUTE_delete_ptr 1392
-sk_X509_ATTRIBUTE_set_cmp_func 1393
-sk_X509_ATTRIBUTE_dup 1394
-sk_X509_ATTRIBUTE_pop_free 1395
-sk_X509_ATTRIBUTE_shift 1396
i2d_PBKDF2PARAM 1397
PBKDF2PARAM_new 1398
d2i_PBKDF2PARAM 1399
PBE2PARAM_new 1402
d2i_PBE2PARAM 1403
PBE2PARAM_free 1404
-sk_GENERAL_NAME_new 1405
-sk_GENERAL_NAME_new_null 1406
-sk_GENERAL_NAME_free 1407
-sk_GENERAL_NAME_num 1408
-sk_GENERAL_NAME_value 1409
-sk_GENERAL_NAME_set 1410
-sk_GENERAL_NAME_zero 1411
-sk_GENERAL_NAME_push 1412
-sk_GENERAL_NAME_pop 1413
-sk_GENERAL_NAME_find 1414
-sk_GENERAL_NAME_delete 1415
-sk_GENERAL_NAME_delete_ptr 1416
-sk_GENERAL_NAME_set_cmp_func 1417
-sk_GENERAL_NAME_dup 1418
-sk_GENERAL_NAME_pop_free 1419
-sk_GENERAL_NAME_shift 1420
d2i_ASN1_SET_OF_GENERAL_NAME 1421
i2d_ASN1_SET_OF_GENERAL_NAME 1422
-sk_SXNETID_new 1423
-sk_SXNETID_new_null 1424
-sk_SXNETID_free 1425
-sk_SXNETID_num 1426
-sk_SXNETID_value 1427
-sk_SXNETID_set 1428
-sk_SXNETID_zero 1429
-sk_SXNETID_push 1430
-sk_SXNETID_pop 1431
-sk_SXNETID_find 1432
-sk_SXNETID_delete 1433
-sk_SXNETID_delete_ptr 1434
-sk_SXNETID_set_cmp_func 1435
-sk_SXNETID_dup 1436
-sk_SXNETID_pop_free 1437
-sk_SXNETID_shift 1438
d2i_ASN1_SET_OF_SXNETID 1439
i2d_ASN1_SET_OF_SXNETID 1440
-sk_POLICYQUALINFO_new 1441
-sk_POLICYQUALINFO_new_null 1442
-sk_POLICYQUALINFO_free 1443
-sk_POLICYQUALINFO_num 1444
-sk_POLICYQUALINFO_value 1445
-sk_POLICYQUALINFO_set 1446
-sk_POLICYQUALINFO_zero 1447
-sk_POLICYQUALINFO_push 1448
-sk_POLICYQUALINFO_pop 1449
-sk_POLICYQUALINFO_find 1450
-sk_POLICYQUALINFO_delete 1451
-sk_POLICYQUALINFO_delete_ptr 1452
-sk_POLICYQUALINFO_set_cmp_func 1453
-sk_POLICYQUALINFO_dup 1454
-sk_POLICYQUALINFO_pop_free 1455
-sk_POLICYQUALINFO_shift 1456
d2i_ASN1_SET_OF_POLICYQUALINFO 1457
i2d_ASN1_SET_OF_POLICYQUALINFO 1458
-sk_POLICYINFO_new 1459
-sk_POLICYINFO_new_null 1460
-sk_POLICYINFO_free 1461
-sk_POLICYINFO_num 1462
-sk_POLICYINFO_value 1463
-sk_POLICYINFO_set 1464
-sk_POLICYINFO_zero 1465
-sk_POLICYINFO_push 1466
-sk_POLICYINFO_pop 1467
-sk_POLICYINFO_find 1468
-sk_POLICYINFO_delete 1469
-sk_POLICYINFO_delete_ptr 1470
-sk_POLICYINFO_set_cmp_func 1471
-sk_POLICYINFO_dup 1472
-sk_POLICYINFO_pop_free 1473
-sk_POLICYINFO_shift 1474
d2i_ASN1_SET_OF_POLICYINFO 1475
i2d_ASN1_SET_OF_POLICYINFO 1476
SXNET_add_id_asc 1477
ERR_peek_error_line_data 1516
PKCS12_PBE_keyivgen 1517
X509_ALGOR_dup 1518
-sk_DIST_POINT_new 1519
-sk_DIST_POINT_new_null 1520
-sk_DIST_POINT_free 1521
-sk_DIST_POINT_num 1522
-sk_DIST_POINT_value 1523
-sk_DIST_POINT_set 1524
-sk_DIST_POINT_zero 1525
-sk_DIST_POINT_push 1526
-sk_DIST_POINT_pop 1527
-sk_DIST_POINT_find 1528
-sk_DIST_POINT_delete 1529
-sk_DIST_POINT_delete_ptr 1530
-sk_DIST_POINT_set_cmp_func 1531
-sk_DIST_POINT_dup 1532
-sk_DIST_POINT_pop_free 1533
-sk_DIST_POINT_shift 1534
d2i_ASN1_SET_OF_DIST_POINT 1535
i2d_ASN1_SET_OF_DIST_POINT 1536
i2d_CRL_DIST_POINTS 1537
DIST_POINT_NAME_free 1547
d2i_DIST_POINT_NAME 1548
X509V3_add_value_uchar 1549
-sk_X509_INFO_new 1550
-sk_X509_EXTENSION_new 1551
-sk_X509_NAME_ENTRY_unshift 1552
-sk_ASN1_TYPE_value 1553
-sk_X509_EXTENSION_find 1554
d2i_ASN1_SET_OF_X509_ATTRIBUTE 1555
-sk_ASN1_TYPE_pop 1556
-sk_X509_EXTENSION_set_cmp_func 1557
-sk_ASN1_TYPE_new_null 1558
-sk_X509_NAME_ENTRY_delete 1559
i2d_ASN1_SET_OF_ASN1_TYPE 1560
-sk_X509_NAME_ENTRY_dup 1561
-sk_X509_unshift 1562
-sk_X509_NAME_unshift 1563
-sk_ASN1_TYPE_num 1564
-sk_X509_EXTENSION_new_null 1565
-sk_X509_INFO_value 1566
d2i_ASN1_SET_OF_X509_EXTENSION 1567
-sk_X509_INFO_delete_ptr 1568
-sk_X509_NAME_ENTRY_new 1569
-sk_DIST_POINT_insert 1570
-sk_ASN1_TYPE_set_cmp_func 1571
-sk_X509_EXTENSION_value 1572
-sk_DIST_POINT_unshift 1573
d2i_ASN1_SET_OF_X509_NAME_ENTRY 1574
-sk_X509_INFO_pop 1575
-sk_X509_EXTENSION_pop 1576
-sk_X509_NAME_ENTRY_shift 1577
-sk_X509_INFO_num 1578
-sk_X509_EXTENSION_num 1579
-sk_X509_INFO_pop_free 1580
-sk_POLICYQUALINFO_unshift 1581
-sk_POLICYINFO_unshift 1582
-sk_X509_NAME_ENTRY_new_null 1583
-sk_X509_NAME_ENTRY_pop 1584
-sk_X509_ATTRIBUTE_unshift 1585
-sk_X509_NAME_ENTRY_num 1586
-sk_GENERAL_NAME_unshift 1587
-sk_X509_INFO_free 1588
d2i_ASN1_SET_OF_ASN1_TYPE 1589
-sk_X509_INFO_insert 1590
-sk_X509_NAME_ENTRY_value 1591
-sk_POLICYQUALINFO_insert 1592
-sk_ASN1_TYPE_set 1593
-sk_X509_EXTENSION_delete_ptr 1594
-sk_X509_INFO_unshift 1595
-sk_ASN1_TYPE_unshift 1596
-sk_ASN1_TYPE_free 1597
-sk_ASN1_TYPE_delete_ptr 1598
-sk_ASN1_TYPE_pop_free 1599
-sk_X509_EXTENSION_unshift 1600
-sk_X509_EXTENSION_pop_free 1601
-sk_X509_NAME_ENTRY_set_cmp_func 1602
-sk_ASN1_TYPE_insert 1603
-sk_X509_NAME_ENTRY_free 1604
-sk_SXNETID_insert 1605
-sk_X509_NAME_insert 1606
-sk_X509_insert 1607
-sk_X509_INFO_delete 1608
-sk_X509_INFO_set_cmp_func 1609
-sk_X509_ATTRIBUTE_insert 1610
-sk_X509_INFO_zero 1611
-sk_X509_INFO_set 1612
-sk_X509_EXTENSION_set 1613
-sk_X509_EXTENSION_free 1614
i2d_ASN1_SET_OF_X509_ATTRIBUTE 1615
-sk_SXNETID_unshift 1616
-sk_X509_INFO_push 1617
-sk_X509_EXTENSION_insert 1618
-sk_X509_INFO_new_null 1619
-sk_ASN1_TYPE_dup 1620
-sk_X509_INFO_find 1621
-sk_POLICYINFO_insert 1622
-sk_ASN1_TYPE_zero 1623
i2d_ASN1_SET_OF_X509_EXTENSION 1624
-sk_X509_NAME_ENTRY_set 1625
-sk_ASN1_TYPE_push 1626
-sk_X509_NAME_ENTRY_insert 1627
-sk_ASN1_TYPE_new 1628
-sk_GENERAL_NAME_insert 1629
-sk_ASN1_TYPE_shift 1630
-sk_ASN1_TYPE_delete 1631
-sk_X509_NAME_ENTRY_pop_free 1632
i2d_ASN1_SET_OF_X509_NAME_ENTRY 1633
-sk_X509_NAME_ENTRY_zero 1634
-sk_ASN1_TYPE_find 1635
-sk_X509_NAME_ENTRY_delete_ptr 1636
-sk_X509_NAME_ENTRY_push 1637
-sk_X509_EXTENSION_zero 1638
-sk_X509_INFO_shift 1639
-sk_X509_INFO_dup 1640
-sk_X509_EXTENSION_dup 1641
-sk_X509_EXTENSION_delete 1642
-sk_X509_EXTENSION_shift 1643
-sk_X509_EXTENSION_push 1644
-sk_X509_NAME_ENTRY_find 1645
X509V3_EXT_i2d 1646
X509V3_EXT_val_prn 1647
X509V3_EXT_add_list 1648
sk_value 1653
sk_num 1654
sk_set 1655
-sk_X509_REVOKED_set_cmp_func 1656
-sk_X509_REVOKED_unshift 1657
-sk_X509_REVOKED_dup 1658
-sk_X509_REVOKED_free 1659
-sk_X509_REVOKED_new 1660
i2d_ASN1_SET_OF_X509_REVOKED 1661
-sk_X509_REVOKED_shift 1662
-sk_X509_REVOKED_delete_ptr 1663
-sk_X509_REVOKED_pop_free 1664
-sk_X509_REVOKED_insert 1665
-sk_X509_REVOKED_zero 1666
-sk_X509_REVOKED_pop 1667
-sk_X509_REVOKED_value 1668
-sk_X509_REVOKED_num 1669
-sk_X509_REVOKED_push 1670
sk_sort 1671
-sk_X509_REVOKED_find 1672
-sk_X509_REVOKED_delete 1673
d2i_ASN1_SET_OF_X509_REVOKED 1674
-sk_X509_REVOKED_new_null 1675
-sk_X509_REVOKED_set 1676
-sk_X509_ALGOR_new 1677
-sk_X509_CRL_set_cmp_func 1678
-sk_X509_CRL_set 1679
-sk_X509_ALGOR_unshift 1680
-sk_X509_CRL_free 1681
i2d_ASN1_SET_OF_X509_ALGOR 1682
-sk_X509_ALGOR_pop 1683
-sk_X509_CRL_unshift 1684
i2d_ASN1_SET_OF_X509_CRL 1685
-sk_X509_ALGOR_num 1686
-sk_X509_CRL_insert 1687
-sk_X509_CRL_pop_free 1688
-sk_X509_CRL_delete_ptr 1689
-sk_X509_ALGOR_insert 1690
-sk_X509_CRL_dup 1691
-sk_X509_CRL_zero 1692
-sk_X509_CRL_new 1693
-sk_X509_CRL_push 1694
-sk_X509_ALGOR_new_null 1695
d2i_ASN1_SET_OF_X509_ALGOR 1696
-sk_X509_CRL_shift 1697
-sk_X509_CRL_find 1698
-sk_X509_CRL_delete 1699
-sk_X509_ALGOR_free 1700
-sk_X509_ALGOR_delete 1701
d2i_ASN1_SET_OF_X509_CRL 1702
-sk_X509_ALGOR_delete_ptr 1703
-sk_X509_CRL_pop 1704
-sk_X509_ALGOR_set 1705
-sk_X509_CRL_num 1706
-sk_X509_CRL_value 1707
-sk_X509_ALGOR_shift 1708
-sk_X509_ALGOR_zero 1709
-sk_X509_CRL_new_null 1710
-sk_X509_ALGOR_push 1711
-sk_X509_ALGOR_value 1712
-sk_X509_ALGOR_find 1713
-sk_X509_ALGOR_set_cmp_func 1714
-sk_X509_ALGOR_dup 1715
-sk_X509_ALGOR_pop_free 1716
-sk_PKCS7_SIGNER_INFO_new 1717
-sk_PKCS7_SIGNER_INFO_zero 1718
-sk_PKCS7_SIGNER_INFO_unshift 1719
-sk_PKCS7_RECIP_INFO_dup 1720
-sk_PKCS7_SIGNER_INFO_insert 1721
-sk_PKCS7_SIGNER_INFO_push 1722
i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO 1723
-sk_PKCS7_RECIP_INFO_new 1724
-sk_X509_LOOKUP_new_null 1725
-sk_PKCS7_SIGNER_INFO_find 1726
-sk_PKCS7_SIGNER_INFO_set_cmp_func 1727
-sk_X509_LOOKUP_zero 1728
-sk_PKCS7_RECIP_INFO_shift 1729
-sk_PKCS7_RECIP_INFO_new_null 1730
-sk_PKCS7_SIGNER_INFO_shift 1731
-sk_PKCS7_SIGNER_INFO_pop 1732
-sk_PKCS7_SIGNER_INFO_pop_free 1733
-sk_X509_LOOKUP_push 1734
-sk_X509_LOOKUP_dup 1735
-sk_PKCS7_SIGNER_INFO_num 1736
-sk_X509_LOOKUP_find 1737
i2d_ASN1_SET_OF_PKCS7_RECIP_INFO 1738
-sk_X509_LOOKUP_new 1739
-sk_PKCS7_SIGNER_INFO_delete 1740
-sk_PKCS7_RECIP_INFO_set_cmp_func 1741
-sk_PKCS7_SIGNER_INFO_delete_ptr 1742
-sk_PKCS7_RECIP_INFO_pop 1743
-sk_X509_LOOKUP_insert 1744
-sk_PKCS7_RECIP_INFO_value 1745
-sk_PKCS7_RECIP_INFO_num 1746
-sk_PKCS7_SIGNER_INFO_value 1747
d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO 1748
-sk_X509_LOOKUP_pop 1749
-sk_X509_LOOKUP_num 1750
-sk_X509_LOOKUP_delete 1751
-sk_PKCS7_RECIP_INFO_free 1752
d2i_ASN1_SET_OF_PKCS7_RECIP_INFO 1753
-sk_PKCS7_SIGNER_INFO_set 1754
-sk_X509_LOOKUP_pop_free 1755
-sk_X509_LOOKUP_shift 1756
-sk_X509_LOOKUP_unshift 1757
-sk_PKCS7_SIGNER_INFO_new_null 1758
-sk_PKCS7_RECIP_INFO_delete_ptr 1759
-sk_PKCS7_RECIP_INFO_pop_free 1760
-sk_PKCS7_RECIP_INFO_insert 1761
-sk_PKCS7_SIGNER_INFO_free 1762
-sk_PKCS7_RECIP_INFO_set 1763
-sk_PKCS7_RECIP_INFO_zero 1764
-sk_X509_LOOKUP_value 1765
-sk_PKCS7_RECIP_INFO_push 1766
-sk_PKCS7_RECIP_INFO_unshift 1767
-sk_X509_LOOKUP_set_cmp_func 1768
-sk_X509_LOOKUP_free 1769
-sk_PKCS7_SIGNER_INFO_dup 1770
-sk_X509_LOOKUP_delete_ptr 1771
-sk_X509_LOOKUP_set 1772
-sk_PKCS7_RECIP_INFO_find 1773
-sk_PKCS7_RECIP_INFO_delete 1774
PKCS5_PBE_add 1775
PEM_write_bio_PKCS8 1776
i2d_PKCS8_fp 1777
CRYPTO_num_locks 1804
CONF_load_bio 1805
CONF_load_fp 1806
-sk_CONF_VALUE_delete 1807
-sk_CONF_VALUE_pop 1808
-sk_CONF_VALUE_num 1809
-sk_CONF_VALUE_pop_free 1810
-sk_CONF_VALUE_free 1811
-sk_CONF_VALUE_shift 1812
-sk_CONF_VALUE_unshift 1813
-sk_CONF_VALUE_value 1814
-sk_CONF_VALUE_set 1815
-sk_CONF_VALUE_zero 1816
-sk_CONF_VALUE_push 1817
-sk_CONF_VALUE_delete_ptr 1818
-sk_CONF_VALUE_find 1819
-sk_CONF_VALUE_set_cmp_func 1820
-sk_CONF_VALUE_new_null 1821
-sk_CONF_VALUE_dup 1822
-sk_CONF_VALUE_insert 1823
-sk_CONF_VALUE_new 1824
-sk_ASN1_OBJECT_find 1825
-sk_ASN1_OBJECT_pop_free 1826
-sk_ASN1_OBJECT_dup 1827
-sk_ASN1_OBJECT_delete_ptr 1828
-sk_ASN1_OBJECT_new 1829
-sk_ASN1_OBJECT_unshift 1830
-sk_ASN1_OBJECT_delete 1831
-sk_ASN1_OBJECT_shift 1832
-sk_ASN1_OBJECT_pop 1833
-sk_ASN1_OBJECT_num 1834
-sk_ASN1_OBJECT_value 1835
-sk_ASN1_OBJECT_new_null 1836
i2d_ASN1_SET_OF_ASN1_OBJECT 1837
-sk_ASN1_OBJECT_free 1838
-sk_ASN1_OBJECT_set 1839
-sk_ASN1_OBJECT_set_cmp_func 1840
-sk_ASN1_OBJECT_zero 1841
-sk_ASN1_OBJECT_insert 1842
-sk_ASN1_OBJECT_push 1843
d2i_ASN1_SET_OF_ASN1_OBJECT 1844
PKCS7_signatureVerify 1845
RSA_set_method 1846
RSA_get_method 1847
+RSA_get_default_method 1848
sk_CONF_VALUE_sort 1849
sk_X509_REVOKED_sort 1850
sk_X509_ATTRIBUTE_sort 1851
X509_set_ex_data 1910
X509_reject_set_bit_asc 1911
X509_NAME_add_entry_by_txt 1912
-sk_X509_TRUST_pop 1913
X509_NAME_add_entry_by_NID 1914
X509_PURPOSE_get0 1915
-sk_ACCESS_DESCRIPTION_shift 1916
PEM_read_X509_AUX 1917
d2i_AUTHORITY_INFO_ACCESS 1918
-sk_X509_TRUST_set_cmp_func 1919
-sk_X509_TRUST_free 1920
PEM_write_PUBKEY 1921
-sk_X509_TRUST_num 1922
-sk_ACCESS_DESCRIPTION_delete 1923
-sk_ASN1_STRING_TABLE_value 1924
ACCESS_DESCRIPTION_new 1925
X509_CERT_AUX_free 1926
d2i_ACCESS_DESCRIPTION 1927
X509_trust_clear 1928
-sk_X509_PURPOSE_value 1929
-sk_X509_PURPOSE_zero 1930
X509_TRUST_add 1931
ASN1_VISIBLESTRING_new 1932
X509_alias_set1 1933
ASN1_UTF8STRING_new 1938
sk_ACCESS_DESCRIPTION_set 1939
sk_X509_PURPOSE_pop 1940
+DSA_get_default_method 1941
sk_X509_PURPOSE_push 1942
sk_X509_PURPOSE_delete 1943
sk_X509_PURPOSE_num 1944
i2d_ASN1_SET_OF_ACCESS_DESCRIPTION 1945
ASN1_T61STRING_free 1946
-sk_ACCESS_DESCRIPTION_free 1947
-sk_ASN1_STRING_TABLE_pop 1948
DSA_set_method 1949
X509_get_ex_data 1950
ASN1_STRING_type 1951
X509_PURPOSE_get_by_sname 1952
-sk_X509_PURPOSE_find 1953
ASN1_TIME_free 1954
ASN1_OCTET_STRING_cmp 1955
-sk_ACCESS_DESCRIPTION_value 1956
ASN1_BIT_STRING_new 1957
X509_get_ext_d2i 1958
PEM_read_bio_X509_AUX 1959
ASN1_STRING_set_default_mask_asc 1960
PEM_write_bio_RSA_PUBKEY 1961
-sk_ASN1_STRING_TABLE_num 1962
ASN1_INTEGER_cmp 1963
d2i_RSA_PUBKEY_fp 1964
-sk_ACCESS_DESCRIPTION_unshift 1965
-sk_ASN1_STRING_TABLE_delete_ptr 1966
X509_trust_set_bit_asc 1967
PEM_write_bio_DSA_PUBKEY 1968
X509_STORE_CTX_free 1969
X509_load_cert_crl_file 1972
ASN1_TIME_new 1973
i2d_RSA_PUBKEY 1974
-sk_X509_TRUST_pop_free 1975
X509_STORE_CTX_purpose_inherit 1976
PEM_read_RSA_PUBKEY 1977
-sk_X509_TRUST_zero 1978
-sk_ACCESS_DESCRIPTION_pop_free 1979
d2i_X509_AUX 1980
i2d_DSA_PUBKEY 1981
X509_CERT_AUX_print 1982
-sk_X509_PURPOSE_new_null 1983
PEM_read_DSA_PUBKEY 1984
i2d_RSA_PUBKEY_bio 1985
ASN1_BIT_STRING_num_asc 1986
i2d_PUBKEY 1987
ASN1_UTCTIME_free 1988
X509_PURPOSE_get_by_id 1990
-sk_X509_TRUST_push 1991
-sk_ASN1_STRING_TABLE_sort 1992
-sk_X509_PURPOSE_set_cmp_func 1993
ACCESS_DESCRIPTION_free 1994
PEM_read_bio_PUBKEY 1995
ASN1_STRING_set_by_NID 1996
X509_PURPOSE_get_id 1997
DISPLAYTEXT_free 1998
OTHERNAME_new 1999
-sk_X509_TRUST_find 2000
X509_CERT_AUX_new 2001
-sk_ACCESS_DESCRIPTION_dup 2002
-sk_ASN1_STRING_TABLE_pop_free 2003
-sk_ASN1_STRING_TABLE_unshift 2004
-sk_X509_TRUST_shift 2005
-sk_ACCESS_DESCRIPTION_zero 2006
X509_TRUST_cleanup 2007
X509_NAME_add_entry_by_OBJ 2008
X509_CRL_get_ext_d2i 2009
-sk_X509_TRUST_set 2010
X509_PURPOSE_get0_name 2011
PEM_read_PUBKEY 2012
-sk_ACCESS_DESCRIPTION_new 2013
i2d_DSA_PUBKEY_bio 2014
i2d_OTHERNAME 2015
ASN1_OCTET_STRING_free 2016
ASN1_BIT_STRING_set_asc 2017
-sk_ACCESS_DESCRIPTION_push 2018
X509_get_ex_new_index 2019
ASN1_STRING_TABLE_cleanup 2020
X509_TRUST_get_by_id 2021
X509V3_get_d2i 2026
ASN1_ENUMERATED_free 2027
i2d_X509_CERT_AUX 2028
-sk_ACCESS_DESCRIPTION_find 2029
X509_STORE_CTX_set_trust 2030
-sk_X509_PURPOSE_unshift 2031
ASN1_STRING_set_default_mask 2032
X509_STORE_CTX_new 2033
EVP_PKEY_get1_RSA 2034
-sk_X509_PURPOSE_set 2035
-sk_ASN1_STRING_TABLE_insert 2036
-sk_X509_PURPOSE_sort 2037
DIRECTORYSTRING_free 2038
PEM_write_X509_AUX 2039
ASN1_OCTET_STRING_set 2040
d2i_DSA_PUBKEY_fp 2041
-sk_ASN1_STRING_TABLE_free 2042
-sk_X509_TRUST_value 2043
d2i_RSA_PUBKEY 2044
-sk_ASN1_STRING_TABLE_set 2045
X509_TRUST_get0_name 2046
X509_TRUST_get0 2047
AUTHORITY_INFO_ACCESS_free 2048
X509_TRUST_get_flags 2056
ASN1_BMPSTRING_free 2057
ASN1_T61STRING_new 2058
-sk_X509_TRUST_unshift 2059
ASN1_UTCTIME_new 2060
-sk_ACCESS_DESCRIPTION_pop 2061
i2d_AUTHORITY_INFO_ACCESS 2062
EVP_PKEY_set1_RSA 2063
X509_STORE_CTX_set_purpose 2064
PEM_write_bio_X509_AUX 2066
X509_PURPOSE_get_count 2067
CRYPTO_add_info 2068
-sk_ACCESS_DESCRIPTION_num 2069
-sk_ASN1_STRING_TABLE_set_cmp_func 2070
X509_NAME_ENTRY_create_by_txt 2071
ASN1_STRING_get_default_mask 2072
-sk_X509_TRUST_dup 2073
X509_alias_get0 2074
ASN1_STRING_data 2075
-sk_X509_TRUST_insert 2076
i2d_ACCESS_DESCRIPTION 2077
X509_trust_set_bit 2078
-sk_X509_PURPOSE_delete_ptr 2079
ASN1_BIT_STRING_free 2080
PEM_read_bio_RSA_PUBKEY 2081
X509_add1_reject_object 2082
X509_check_trust 2083
-sk_X509_TRUST_new_null 2084
-sk_ACCESS_DESCRIPTION_new_null 2085
-sk_ACCESS_DESCRIPTION_delete_ptr 2086
-sk_X509_TRUST_sort 2087
PEM_read_bio_DSA_PUBKEY 2088
-sk_X509_TRUST_new 2089
X509_PURPOSE_add 2090
ASN1_STRING_TABLE_get 2091
ASN1_UTF8STRING_free 2092
d2i_DSA_PUBKEY_bio 2093
-sk_ASN1_STRING_TABLE_delete 2094
PEM_write_RSA_PUBKEY 2095
d2i_OTHERNAME 2096
-sk_ACCESS_DESCRIPTION_insert 2097
X509_reject_set_bit 2098
-sk_X509_TRUST_delete_ptr 2099
-sk_X509_PURPOSE_pop_free 2100
PEM_write_DSA_PUBKEY 2101
-sk_X509_PURPOSE_free 2102
-sk_X509_PURPOSE_dup 2103
-sk_ASN1_STRING_TABLE_zero 2104
X509_PURPOSE_get0_sname 2105
-sk_ASN1_STRING_TABLE_shift 2106
EVP_PKEY_set1_DH 2107
ASN1_OCTET_STRING_dup 2108
ASN1_BIT_STRING_set 2109
i2d_RSA_PUBKEY_fp 2113
ASN1_INTEGER_dup 2114
d2i_X509_CERT_AUX 2115
-sk_ASN1_STRING_TABLE_new_null 2116
PEM_write_bio_PUBKEY 2117
ASN1_VISIBLESTRING_free 2118
X509_PURPOSE_cleanup 2119
-sk_ASN1_STRING_TABLE_push 2120
-sk_ASN1_STRING_TABLE_dup 2121
-sk_X509_PURPOSE_shift 2122
ASN1_mbstring_ncopy 2123
-sk_X509_PURPOSE_new 2124
-sk_X509_PURPOSE_insert 2125
ASN1_GENERALIZEDTIME_new 2126
-sk_ACCESS_DESCRIPTION_sort 2127
EVP_PKEY_get1_DH 2128
-sk_ACCESS_DESCRIPTION_set_cmp_func 2129
ASN1_OCTET_STRING_new 2130
ASN1_INTEGER_new 2131
i2d_X509_AUX 2132
-sk_ASN1_STRING_TABLE_find 2133
ASN1_BIT_STRING_name_print 2134
X509_cmp 2135
ASN1_STRING_length_set 2136
DIRECTORYSTRING_new 2137
-sk_ASN1_STRING_TABLE_new 2138
-sk_X509_TRUST_delete 2139
X509_add1_trust_object 2140
PKCS12_newpass 2141
SMIME_write_PKCS7 2142
X509_REQ_add1_attr_by_txt 2217
X509_ATTRIBUTE_create_by_txt 2218
X509at_add1_attr_by_txt 2219
-sk_CRYPTO_EX_DATA_FUNCS_delete 2220
-sk_CRYPTO_EX_DATA_FUNCS_set 2221
-sk_CRYPTO_EX_DATA_FUNCS_unshift 2222
-sk_CRYPTO_EX_DATA_FUNCS_new_null 2223
-sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func 2224
-sk_CRYPTO_EX_DATA_FUNCS_sort 2225
-sk_CRYPTO_EX_DATA_FUNCS_dup 2226
-sk_CRYPTO_EX_DATA_FUNCS_shift 2227
-sk_CRYPTO_EX_DATA_FUNCS_value 2228
-sk_CRYPTO_EX_DATA_FUNCS_pop 2229
-sk_CRYPTO_EX_DATA_FUNCS_push 2230
-sk_CRYPTO_EX_DATA_FUNCS_find 2231
-sk_CRYPTO_EX_DATA_FUNCS_new 2232
-sk_CRYPTO_EX_DATA_FUNCS_free 2233
-sk_CRYPTO_EX_DATA_FUNCS_delete_ptr 2234
-sk_CRYPTO_EX_DATA_FUNCS_num 2235
-sk_CRYPTO_EX_DATA_FUNCS_pop_free 2236
-sk_CRYPTO_EX_DATA_FUNCS_insert 2237
-sk_CRYPTO_EX_DATA_FUNCS_zero 2238
BN_pseudo_rand 2239
BN_is_prime_fasttest 2240
BN_CTX_end 2241
ERR_error_string_n 2291
BIO_snprintf 2292
DSO_ctrl 2293
-sk_PKCS7_num 2294
-sk_PKCS12_SAFEBAG_set 2295
-sk_BIO_delete 2296
-sk_PKCS7_new_null 2297
-sk_BIO_delete_ptr 2298
-sk_ASN1_INTEGER_dup 2299
-sk_BIO_value 2300
-sk_PKCS7_delete_ptr 2301
-sk_X509V3_EXT_METHOD_pop 2302
-sk_PKCS12_SAFEBAG_new_null 2303
-sk_ASN1_INTEGER_delete 2304
-sk_BIO_sort 2305
-sk_ASN1_INTEGER_sort 2306
-sk_PKCS7_free 2307
-sk_PKCS12_SAFEBAG_dup 2308
-sk_X509V3_EXT_METHOD_sort 2309
-sk_X509V3_EXT_METHOD_pop_free 2310
-sk_X509V3_EXT_METHOD_shift 2311
-sk_ASN1_INTEGER_pop_free 2312
-sk_X509V3_EXT_METHOD_unshift 2313
-sk_ASN1_INTEGER_pop 2314
-sk_BIO_new_null 2315
-sk_PKCS7_set 2316
i2d_ASN1_SET_OF_ASN1_INTEGER 2317
-sk_PKCS12_SAFEBAG_push 2318
-sk_X509V3_EXT_METHOD_value 2319
i2d_ASN1_SET_OF_PKCS12_SAFEBAG 2320
-sk_PKCS7_zero 2321
-sk_ASN1_INTEGER_shift 2322
-sk_PKCS12_SAFEBAG_insert 2323
-sk_PKCS12_SAFEBAG_find 2324
-sk_PKCS12_SAFEBAG_unshift 2325
-sk_ASN1_INTEGER_unshift 2326
-sk_PKCS12_SAFEBAG_pop 2327
i2d_ASN1_SET_OF_PKCS7 2328
-sk_ASN1_INTEGER_delete_ptr 2329
-sk_PKCS7_dup 2330
-sk_BIO_new 2331
-sk_ASN1_INTEGER_value 2332
-sk_PKCS12_SAFEBAG_delete 2333
BIO_vfree 2334
-sk_X509V3_EXT_METHOD_new_null 2335
-sk_BIO_push 2336
-sk_ASN1_INTEGER_new_null 2337
-sk_PKCS12_SAFEBAG_set_cmp_func 2338
d2i_ASN1_SET_OF_ASN1_INTEGER 2339
-sk_ASN1_INTEGER_push 2340
d2i_ASN1_SET_OF_PKCS12_SAFEBAG 2341
-sk_BIO_find 2342
-sk_X509V3_EXT_METHOD_push 2343
-sk_BIO_set_cmp_func 2344
-sk_ASN1_INTEGER_find 2345
-sk_X509V3_EXT_METHOD_find 2346
-sk_PKCS12_SAFEBAG_delete_ptr 2347
-sk_X509V3_EXT_METHOD_new 2348
-sk_BIO_num 2349
ASN1_UTCTIME_get 2350
-sk_PKCS7_pop 2351
-sk_PKCS7_insert 2352
-sk_PKCS7_sort 2353
-sk_X509V3_EXT_METHOD_insert 2354
-sk_ASN1_INTEGER_new 2355
-sk_PKCS12_SAFEBAG_free 2356
-sk_X509V3_EXT_METHOD_num 2357
-sk_PKCS7_delete 2358
-sk_X509V3_EXT_METHOD_delete 2359
-sk_BIO_set 2360
-sk_PKCS12_SAFEBAG_new 2361
X509_REQ_digest 2362
-sk_ASN1_INTEGER_num 2363
-sk_PKCS7_set_cmp_func 2364
-sk_PKCS7_shift 2365
-sk_PKCS12_SAFEBAG_zero 2366
-sk_BIO_free 2367
-sk_ASN1_INTEGER_free 2368
-sk_X509V3_EXT_METHOD_set_cmp_func 2369
-sk_PKCS7_push 2370
-sk_X509V3_EXT_METHOD_free 2371
-sk_PKCS7_pop_free 2372
-sk_PKCS7_value 2373
-sk_X509V3_EXT_METHOD_delete_ptr 2374
-sk_X509V3_EXT_METHOD_set 2375
-sk_PKCS12_SAFEBAG_num 2376
-sk_PKCS7_find 2377
-sk_ASN1_INTEGER_set_cmp_func 2378
-sk_PKCS12_SAFEBAG_shift 2379
-sk_BIO_dup 2380
-sk_PKCS7_unshift 2381
-sk_PKCS12_SAFEBAG_pop_free 2382
-sk_BIO_zero 2383
-sk_PKCS7_new 2384
-sk_ASN1_INTEGER_zero 2385
-sk_BIO_unshift 2386
-sk_ASN1_INTEGER_set 2387
-sk_BIO_insert 2388
-sk_X509V3_EXT_METHOD_zero 2389
-sk_PKCS12_SAFEBAG_value 2390
X509_CRL_digest 2391
-sk_X509V3_EXT_METHOD_dup 2392
-sk_BIO_shift 2393
-sk_PKCS12_SAFEBAG_sort 2394
-sk_BIO_pop 2395
-sk_BIO_pop_free 2396
d2i_ASN1_SET_OF_PKCS7 2397
-sk_ASN1_INTEGER_insert 2398
-ERR_load_ENGINE_strings 2399
-ENGINE_set_DSA 2400
-ENGINE_get_default_RSA 2401
-ENGINE_init 2402
-RSA_set_default_openssl_method 2403
-ENGINE_finish 2404
-ENGINE_get_DH 2405
-ENGINE_get_last 2406
-ENGINE_get_RSA 2407
-ENGINE_get_RAND 2408
-ENGINE_get_default_BN_mod_exp_crt 2409
-ENGINE_remove 2410
-ENGINE_get_BN_mod_exp_crt 2411
-ENGINE_set_name 2412
-ENGINE_get_default_DSA 2413
-ENGINE_set_default_BN_mod_exp 2414
-ENGINE_set_default_RSA 2415
-ENGINE_get_default_RAND 2416
-ENGINE_get_default_BN_mod_exp 2417
-ENGINE_get_id 2418
-ENGINE_add 2419
-ENGINE_get_DSA 2420
-ENGINE_get_BN_mod_exp 2421
-ENGINE_set_DH 2422
-ENGINE_set_default_BN_mod_exp_crt 2423
-ENGINE_get_struct_size 2424
-ENGINE_set_default_DSA 2425
-ENGINE_get_name 2426
-ENGINE_get_prev 2427
-ENGINE_get_default_DH 2428
-ENGINE_set_default 2429
-ENGINE_by_id 2430
-ENGINE_get_first 2431
-RSA_get_default_openssl_method 2432
-ENGINE_set_RSA 2433
-ENGINE_set_default_RAND 2434
-ENGINE_set_BN_mod_exp 2435
-ENGINE_free 2436
-ENGINE_get_next 2437
-ENGINE_set_RAND 2438
-ENGINE_set_id 2439
-ENGINE_set_BN_mod_exp_crt 2440
-ENGINE_set_default_DH 2441
-ENGINE_new 2442
-DH_get_default_openssl_method 2443
-DH_set_default_openssl_method 2444
-DSA_get_default_openssl_method 2445
-DSA_set_default_openssl_method 2446
+EVP_CIPHER_CTX_set_key_length 2399
+EVP_CIPHER_CTX_ctrl 2400
my $W32=1;
my $NT=0;
# Set this to make typesafe STACK definitions appear in DEF
-my $safe_stack_def = 1;
+my $safe_stack_def = 0;
my $options="";
open(IN,"<Makefile.ssl") || die "unable to open Makefile.ssl!\n";
$do_update=1 if $_ eq "update";
$do_ctest=1 if $_ eq "ctest";
$rsaref=1 if $_ eq "rsaref";
+ $safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
if (/^no-rc2$/) { $no_rc2=1; }
elsif (/^no-rc4$/) { $no_rc4=1; }
foreach (split /;/, $def) {
s/^[\n\s]*//g;
s/[\n\s]*$//g;
+ next if(/#define/);
next if(/typedef\W/);
next if(/EVP_bf/ and $no_bf);
next if(/EVP_cast/ and $no_cast);
my $cc="cc";
my $cversion="??";
my $sep="-----------------------------------------------------------------------------\n";
+my $not_our_fault="\nPlease ask your system administrator/vendor for more information.\n[Problems with your operating system setup should not be reported\nto the OpenSSL project.]\n";
open(OUT,">$report") or die;
print "Checking compiler...\n";
if (open(TEST,">cctest.c")) {
- print TEST "#include <stdio.h>\nmain(){printf(\"Hello world\\n\");}\n";
+ print TEST "#include <stdio.h>\n#include <errno.h>\nmain(){printf(\"Hello world\\n\");}\n";
close(TEST);
system("$cc -o cctest cctest.c");
if (`./cctest` !~ /Hello world/) {
print OUT "Compiler doesn't work.\n";
+ print OUT $not_our_fault;
goto err;
}
system("ar r cctest.a /dev/null");
if (not -f "cctest.a") {
print OUT "Check your archive tool (ar).\n";
+ print OUT $not_our_fault;
goto err;
}
} else {
} else {
print OUT "Can't compile test program!\n";
}
+ print OUT $not_our_fault;
goto err;
}
} else {
goto err;
}
+if (`echo 4+1 | bc` != 5)
+{
+ print OUT "Can't run bc! Test skipped.\n";
+ print OUT $not_our_fault;
+ goto err;
+}
+
print "Running make test...\n";
if (system("make test 2>&1 | tee maketest.log") > 255)
{
SSL_set_tmp_dh_callback 187
SSL_add_dir_cert_subjects_to_stack 188
SSL_set_session_id_context 189
-sk_SSL_CIPHER_new 190
-sk_SSL_CIPHER_new_null 191
-sk_SSL_CIPHER_free 192
-sk_SSL_CIPHER_num 193
-sk_SSL_CIPHER_value 194
-sk_SSL_CIPHER_set 195
-sk_SSL_CIPHER_zero 196
-sk_SSL_CIPHER_push 197
-sk_SSL_CIPHER_pop 198
-sk_SSL_CIPHER_find 199
-sk_SSL_CIPHER_delete 200
-sk_SSL_CIPHER_delete_ptr 201
-sk_SSL_CIPHER_set_cmp_func 202
-sk_SSL_CIPHER_dup 203
-sk_SSL_CIPHER_pop_free 204
-sk_SSL_CIPHER_shift 205
-sk_SSL_COMP_new 206
-sk_SSL_COMP_new_null 207
-sk_SSL_COMP_free 208
-sk_SSL_COMP_num 209
-sk_SSL_COMP_value 210
-sk_SSL_COMP_set 211
-sk_SSL_COMP_zero 212
-sk_SSL_COMP_push 213
-sk_SSL_COMP_pop 214
-sk_SSL_COMP_find 215
-sk_SSL_COMP_delete 216
-sk_SSL_COMP_delete_ptr 217
-sk_SSL_COMP_set_cmp_func 218
-sk_SSL_COMP_dup 219
-sk_SSL_COMP_pop_free 220
-sk_SSL_COMP_shift 221
SSL_CTX_use_certificate_chain_file 222
-sk_SSL_COMP_insert 223
-sk_SSL_CIPHER_insert 224
SSL_CTX_set_verify_depth 225
SSL_set_verify_depth 226
-sk_SSL_CIPHER_unshift 227
SSL_CTX_get_verify_depth 228
SSL_get_verify_depth 229
-sk_SSL_COMP_unshift 230
SSL_CTX_set_session_id_context 231
SSL_CTX_set_cert_verify_callback 232
-sk_SSL_COMP_sort 233
-sk_SSL_CIPHER_sort 234
SSL_CTX_set_default_passwd_cb_userdata 235
SSL_set_purpose 236
SSL_CTX_set_trust 237
projects / oweals / openssl.git / commitdiff