mirror of
https://github.com/openssl/openssl.git
synced 2024-11-27 05:21:51 +08:00
Use common STANZA for bn and exp tests
Standardize file:line messages Reduce buff size; move to end of STANZA Add some Title entries (with blank line after) Add Title to some BN test files. Reviewed-by: Andy Polyakov <appro@openssl.org> (Merged from https://github.com/openssl/openssl/pull/3608)
This commit is contained in:
Rich Salz
parent
71dd3b6464
commit
ae269dd8b7
@ -5,12 +5,11 @@
|
||||
# in the file LICENSE in the source distribution or at
|
||||
# https://www.openssl.org/source/license.html
|
||||
|
||||
# Modulus tests.
|
||||
|
||||
# ModMul tests.
|
||||
#
|
||||
# These test vectors satisfy A * B = ModMul (mod M) and 0 <= ModMul < M.
|
||||
|
||||
Title = ModMul tests
|
||||
|
||||
|
||||
ModMul = ae2ca2ce7addaee2e2b7752e286b2bb6a58b51cfbed5c924f00398e59ec36fe6341cd83da43a33a12410f45f6228079c4aeb3912be87e2e81fa1799151bfa0fea29873097475b2c3efa312145d0bf7e51b2a7c9bc961a4f4dcf0c883ff90b919b87c21099fba40257645be31f95a3a277
|
||||
A = 6b18497fed9befdf22a01d988d34213f6687d8a96e86c188dea4172e7c6095a0d18d3c86c0f5a1af9c6e3aaeb6baac2a510930b3ed06ec78ec2e12b
|
||||
B = 1a058d99397db0d209f01212dd4023ae01b15da04fe62d1f76f21622b2695558c67d706c535ca7f19b36f8ef2d508ffd6cf6fcf25e5
|
||||
@ -2012,10 +2011,10 @@ B = 8bdfa8fe5ef3b2ad02bc63c4d
|
||||
M = 84daecf412b8c50ad6dfdb546c3eb783dcc6f32003eda914bb
|
||||
|
||||
|
||||
# ModExp tests.
|
||||
#
|
||||
# These test vectors satisfy A ^ E = ModExp (mod M) and 0 <= ModExp < M.
|
||||
|
||||
Title = ModExp tests
|
||||
|
||||
# Regression test for carry propagation bug in sqr8x_reduction.
|
||||
ModExp = 19324b647d967d644b3219
|
||||
A = 050505050505
|
||||
@ -2476,11 +2475,11 @@ E = d7e6df5d755284929b986cd9b61c9c2c8843f24c711fbdbae1a468edcae15940094372557072
|
||||
M = e4e784aa1fa88625a43ba0185a153a929663920be7fe674a4d33c943d3b898cff051482e7050a070cede53be5e89f31515772c7aea637576f99f82708f89d9e244f6ad3a24a02cbe5c0ff7bcf2dad5491f53db7c3f2698a7c41b44f086652f17bb05fe4c5c0a92433c34086b49d7e1825b28bab6c5a9bd0bc95b53d659afa0d7
|
||||
|
||||
|
||||
# ModSqrt tests.
|
||||
#
|
||||
# These test vectors satisfy (ModSqrt * ModSqrt) mod P = A mod P with P a prime.
|
||||
# ModSqrt is in [0, (P-1)/2].
|
||||
|
||||
Title = ModSqrt
|
||||
|
||||
ModSqrt = 1
|
||||
A = 1
|
||||
P = 2
|
||||
|
||||
@ -5,10 +5,10 @@
|
||||
# in the file LICENSE in the source distribution or at
|
||||
# https://www.openssl.org/source/license.html
|
||||
|
||||
# Square tests.
|
||||
#
|
||||
# These test vectors satisfy A^2 = Square.
|
||||
|
||||
Title = Square tests.
|
||||
|
||||
# Regression test for a BN_sqr overflow bug.
|
||||
Square = 4000000000000000800000000000000240000000000000000000000000000001fffffffffffffff8000000000000000400000000000000000000000000000000
|
||||
A = 80000000000000008000000000000001fffffffffffffffe0000000000000000
|
||||
@ -318,10 +318,10 @@ Square = eea8028b26e0df090504d54da714a6f5f2695202e53cff479c78aedd47a8dc676243ec5
|
||||
A = -3dcb44be1e54c5a5d7db48055ca9afa1ebe2ae648aa6e16ac497502a7deee09ffa124720fad0ab163ce8b3ea6a90f110ea52b67dbc424d0cf1e8c9726dfd9e45bebcefaa5cd5706edeed27896525f31c6bbea3d67ee97badefabf3e2532470b66e3ae3100f66ddf50cf02fc3a8e3f44c304251d3b6a7ca3a6e4bd5d16a41bd97a4
|
||||
|
||||
|
||||
# Product tests.
|
||||
#
|
||||
# These test vectors satisfy A * B = Product.
|
||||
|
||||
Title = Product tests
|
||||
|
||||
Product = 5befab3320f8f90542f3120235abd926aac3805a19e343f690
|
||||
A = b057af553afb120db6b7764f8
|
||||
B = 857734c4c27a1d17f7cf59dee
|
||||
|
||||
@ -5,10 +5,10 @@
|
||||
# in the file LICENSE in the source distribution or at
|
||||
# https://www.openssl.org/source/license.html
|
||||
|
||||
# LShift1 tests.
|
||||
#
|
||||
# These test vectors satisfy A * 2 = LShift1
|
||||
|
||||
Title = Lshift1 tests
|
||||
|
||||
LShift1 = 0
|
||||
A = 0
|
||||
|
||||
@ -1213,10 +1213,10 @@ LShift1 = -ab4e80e4b56556d99108eb3cb35f17d1ae83da33b4138619070000000000000000000
|
||||
A = -55a740725ab2ab6cc884759e59af8be8d741ed19da09c30c838000000000000000000000000
|
||||
|
||||
|
||||
# LShift tests
|
||||
#
|
||||
# These test vectors satisfy A * 2^N = LShift.
|
||||
|
||||
Title = LShift tests
|
||||
|
||||
LShift = 18c9e860855d594dcb06d00b7d1933608ba906d85fa2d92c9e0
|
||||
A = c64f43042aeaca6e5836805be8c99b045d4836c2fd16c964f0
|
||||
N = 1
|
||||
@ -2018,10 +2018,10 @@ A = e8e7c5ae65d7333de82bcbfdd7cea60ffb11e600aa3088ec8e
|
||||
N = 64
|
||||
|
||||
|
||||
# RShift tests
|
||||
#
|
||||
# These test vectors satisfy A / 2^N = RShift, rounding towards zero.
|
||||
|
||||
Title = RShift tests
|
||||
|
||||
Rshift = 0
|
||||
A = -1
|
||||
N = 1
|
||||
|
||||
131
test/bntest.c
131
test/bntest.c
@ -35,26 +35,12 @@ BIGNUM *bn_expand2(BIGNUM *b, int words);
|
||||
BIGNUM *bn_expand2(BIGNUM *b, int words) { return NULL; }
|
||||
#include "../crypto/bn/bn_lcl.h"
|
||||
|
||||
#define MAXPAIRS 20
|
||||
|
||||
/*
|
||||
* Things in boring, not in openssl. TODO we should add them.
|
||||
*/
|
||||
#define HAVE_BN_PADDED 0
|
||||
#define HAVE_BN_SQRT 0
|
||||
|
||||
typedef struct pair_st {
|
||||
char *key;
|
||||
char *value;
|
||||
} PAIR;
|
||||
|
||||
typedef struct stanza_st {
|
||||
int curr; /* Current line in file */
|
||||
int start; /* Line where test starts */
|
||||
int numpairs;
|
||||
PAIR pairs[MAXPAIRS];
|
||||
} STANZA;
|
||||
|
||||
typedef struct filetest_st {
|
||||
const char *name;
|
||||
int (*func)(STANZA *s);
|
||||
@ -68,7 +54,6 @@ typedef struct mpitest_st {
|
||||
|
||||
static const int NUM0 = 100; /* number of tests */
|
||||
static const int NUM1 = 50; /* additional tests for some functions */
|
||||
static BIO *fp;
|
||||
static BN_CTX *ctx;
|
||||
|
||||
/*
|
||||
@ -113,7 +98,7 @@ static BIGNUM *getBN(STANZA *s, const char *attribute)
|
||||
BIGNUM *ret = NULL;
|
||||
|
||||
if ((hex = findattr(s, attribute)) == NULL) {
|
||||
TEST_error("Can't find %s in test at line %d", attribute, s->start);
|
||||
TEST_error("%s:%d: Can't find %s", s->test_file, s->start, attribute);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -1986,85 +1971,6 @@ err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Delete leading and trailing spaces from a string */
|
||||
static char *strip_spaces(char *p)
|
||||
{
|
||||
char *q;
|
||||
|
||||
/* Skip over leading spaces */
|
||||
while (*p && isspace(*p))
|
||||
p++;
|
||||
if (!*p)
|
||||
return NULL;
|
||||
|
||||
for (q = p + strlen(p) - 1; q != p && isspace(*q); )
|
||||
*q-- = '\0';
|
||||
return *p ? p : NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read next test stanza; return 1 if found, 0 on EOF or error.
|
||||
*/
|
||||
static int readstanza(STANZA *s)
|
||||
{
|
||||
PAIR *pp = s->pairs;
|
||||
char *p, *equals, *key, *value;
|
||||
char buff[1024];
|
||||
|
||||
while (BIO_gets(fp, buff, sizeof(buff))) {
|
||||
s->curr++;
|
||||
if (!TEST_ptr(p = strchr(buff, '\n'))) {
|
||||
TEST_info("Line %d too long", s->curr);
|
||||
return 0;
|
||||
}
|
||||
*p = '\0';
|
||||
|
||||
/* Blank line marks end of tests. */
|
||||
if (buff[0] == '\0')
|
||||
break;
|
||||
|
||||
/* Lines starting with a pound sign are ignored. */
|
||||
if (buff[0] == '#')
|
||||
continue;
|
||||
|
||||
if (!TEST_ptr(equals = strchr(buff, '='))) {
|
||||
TEST_info("Missing = at line %d\n", s->curr);
|
||||
return 0;
|
||||
}
|
||||
*equals++ = '\0';
|
||||
if (s->numpairs == 0)
|
||||
s->start = s->curr;
|
||||
|
||||
if (!TEST_ptr(key = strip_spaces(buff))
|
||||
|| !TEST_ptr(value = strip_spaces(equals))
|
||||
|| !TEST_int_lt(s->numpairs++, MAXPAIRS)
|
||||
|| !TEST_ptr(pp->key = OPENSSL_strdup(key))
|
||||
|| !TEST_ptr(pp->value = OPENSSL_strdup(value)))
|
||||
return 0;
|
||||
pp++;
|
||||
}
|
||||
|
||||
/* If we read anything, return ok. */
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void clearstanza(STANZA *s)
|
||||
{
|
||||
PAIR *pp = s->pairs;
|
||||
int i = s->numpairs;
|
||||
int start = s->start;
|
||||
int curr = s->curr;
|
||||
|
||||
for ( ; --i >= 0; pp++) {
|
||||
OPENSSL_free(pp->key);
|
||||
OPENSSL_free(pp->value);
|
||||
}
|
||||
memset(s, 0, sizeof(*s));
|
||||
s->curr = curr;
|
||||
s->start = start;
|
||||
}
|
||||
|
||||
static int file_test_run(STANZA *s)
|
||||
{
|
||||
static const FILETEST filetests[] = {
|
||||
@ -2086,13 +1992,14 @@ static int file_test_run(STANZA *s)
|
||||
for ( ; --numtests >= 0; tp++) {
|
||||
if (findattr(s, tp->name) != NULL) {
|
||||
if (!tp->func(s)) {
|
||||
TEST_info("Failed %s test at %d", tp->name, s->start);
|
||||
TEST_info("%s:%d: Failed %s test",
|
||||
s->test_file, s->start, tp->name);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
TEST_info("Unknown test at %d", s->start);
|
||||
TEST_info("%s:%d: Unknown test", s->test_file, s->start);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2100,26 +2007,30 @@ static char * const *testfiles;
|
||||
|
||||
static int run_file_tests(int i)
|
||||
{
|
||||
STANZA s;
|
||||
int errcnt = 0;
|
||||
STANZA *s = NULL;
|
||||
int c;
|
||||
|
||||
if (!TEST_ptr(fp = BIO_new_file(testfiles[i], "rb")))
|
||||
if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
|
||||
return 0;
|
||||
if (!test_start_file(s, testfiles[i])) {
|
||||
OPENSSL_free(s);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read test file. */
|
||||
set_test_title(testfiles[i]);
|
||||
memset(&s, 0, sizeof(s));
|
||||
while (!BIO_eof(fp) && readstanza(&s)) {
|
||||
if (s.numpairs == 0)
|
||||
while (!BIO_eof(s->fp) && test_readstanza(s)) {
|
||||
if (s->numpairs == 0)
|
||||
continue;
|
||||
if (!file_test_run(&s)) {
|
||||
errcnt++;
|
||||
if (!file_test_run(s))
|
||||
s->errors++;
|
||||
s->numtests++;
|
||||
test_clearstanza(s);
|
||||
}
|
||||
clearstanza(&s);
|
||||
}
|
||||
BIO_free(fp);
|
||||
test_end_file(s);
|
||||
c = s->errors;
|
||||
OPENSSL_free(s);
|
||||
|
||||
return errcnt == 0;
|
||||
return c == 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
IF[{- !$disabled{tests} -}]
|
||||
LIBS_NO_INST=libtestutil.a
|
||||
SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \
|
||||
testutil/driver.c testutil/tests.c testutil/cb.c \
|
||||
testutil/driver.c testutil/tests.c testutil/cb.c testutil/stanza.c \
|
||||
{- rebase_files("../apps", $target{apps_aux_src}) -} \
|
||||
testutil/test_main.c testutil/main.c
|
||||
INCLUDE[libtestutil.a]=.. ../include
|
||||
|
||||
353
test/evp_test.c
353
test/evp_test.c
@ -28,15 +28,9 @@ typedef struct evp_test_method_st EVP_TEST_METHOD;
|
||||
* Structure holding test information
|
||||
*/
|
||||
typedef struct evp_test_st {
|
||||
BIO *in; /* file being read */
|
||||
int line; /* current line being processed */
|
||||
int start_line; /* start line of current test */
|
||||
int ntests; /* Number of tests */
|
||||
int errors; /* Error count */
|
||||
STANZA s; /* Common test stanza */
|
||||
char *name;
|
||||
int skip; /* Current test should be skipped */
|
||||
int nskip; /* Number of tests skipped */
|
||||
char buf[10240]; /* Input buffer */
|
||||
BIO *key; /* temp memory BIO for reading in keys */
|
||||
const EVP_TEST_METHOD *meth; /* method for this test */
|
||||
const char *err, *aux_err; /* Error string for test */
|
||||
char *expected_err; /* Expected error value of test */
|
||||
@ -80,8 +74,6 @@ static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
|
||||
|
||||
static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
|
||||
|
||||
static const char *current_test_file = "???";
|
||||
|
||||
/*
|
||||
* Structure used to hold a list of blocks of memory to test
|
||||
* calls to "update" like functions.
|
||||
@ -2110,6 +2102,7 @@ static const EVP_TEST_METHOD *find_test(const char *name)
|
||||
|
||||
static void clear_test(EVP_TEST *t)
|
||||
{
|
||||
test_clearstanza(&t->s);
|
||||
ERR_clear_error();
|
||||
if (t->data != NULL) {
|
||||
if (t->meth != NULL)
|
||||
@ -2123,6 +2116,7 @@ static void clear_test(EVP_TEST *t)
|
||||
t->func = NULL;
|
||||
OPENSSL_free(t->reason);
|
||||
t->reason = NULL;
|
||||
|
||||
/* Text literal. */
|
||||
t->err = NULL;
|
||||
t->skip = 0;
|
||||
@ -2142,25 +2136,23 @@ static int check_test_error(EVP_TEST *t)
|
||||
return 1;
|
||||
if (t->err != NULL && t->expected_err == NULL) {
|
||||
if (t->aux_err != NULL) {
|
||||
TEST_info("Above error from the test at %s:%d "
|
||||
"(%s) unexpected error %s",
|
||||
current_test_file, t->start_line, t->aux_err, t->err);
|
||||
TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
|
||||
t->s.test_file, t->s.start, t->aux_err, t->err);
|
||||
} else {
|
||||
TEST_info("Above error from the test at %s:%d "
|
||||
"unexpected error %s",
|
||||
current_test_file, t->start_line, t->err);
|
||||
TEST_info("%s:%d: Source of above error; unexpected error %s",
|
||||
t->s.test_file, t->s.start, t->err);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (t->err == NULL && t->expected_err != NULL) {
|
||||
TEST_info("Test line %d: succeeded but was expecting %s",
|
||||
t->start_line, t->expected_err);
|
||||
TEST_info("%s:%d: Succeeded but was expecting %s",
|
||||
t->s.test_file, t->s.start, t->expected_err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (strcmp(t->err, t->expected_err) != 0) {
|
||||
TEST_info("Test line %d: expecting %s got %s",
|
||||
t->start_line, t->expected_err, t->err);
|
||||
TEST_info("%s:%d: Expected %s got %s",
|
||||
t->s.test_file, t->s.start, t->expected_err, t->err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2168,32 +2160,32 @@ static int check_test_error(EVP_TEST *t)
|
||||
return 1;
|
||||
|
||||
if (t->func == NULL || t->reason == NULL) {
|
||||
TEST_info("Test line %d: missing function or reason code",
|
||||
t->start_line);
|
||||
TEST_info("%s:%d: Test is missing function or reason code",
|
||||
t->s.test_file, t->s.start);
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = ERR_peek_error();
|
||||
if (err == 0) {
|
||||
TEST_info("Test line %d, expected error \"%s:%s\" not set",
|
||||
t->start_line, t->func, t->reason);
|
||||
TEST_info("%s:%d: Expected error \"%s:%s\" not set",
|
||||
t->s.test_file, t->s.start, t->func, t->reason);
|
||||
return 0;
|
||||
}
|
||||
|
||||
func = ERR_func_error_string(err);
|
||||
reason = ERR_reason_error_string(err);
|
||||
if (func == NULL && reason == NULL) {
|
||||
TEST_info("Test line %d: expected error \"%s:%s\","
|
||||
" no strings available. Skipping...\n",
|
||||
t->start_line, t->func, t->reason);
|
||||
TEST_info("%s:%d: Expected error \"%s:%s\", no strings available."
|
||||
" Assuming ok.",
|
||||
t->s.test_file, t->s.start, t->func, t->reason);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
|
||||
return 1;
|
||||
|
||||
TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"",
|
||||
t->start_line, t->func, t->reason, func, reason);
|
||||
TEST_info("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
|
||||
t->s.test_file, t->s.start, t->func, t->reason, func, reason);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -2205,18 +2197,19 @@ static int run_test(EVP_TEST *t)
|
||||
{
|
||||
if (t->meth == NULL)
|
||||
return 1;
|
||||
t->ntests++;
|
||||
t->s.numtests++;
|
||||
if (t->skip) {
|
||||
t->nskip++;
|
||||
t->s.numskip++;
|
||||
} else {
|
||||
/* run the test */
|
||||
if (t->err == NULL && t->meth->run_test(t) != 1) {
|
||||
TEST_info("Line %d error %s", t->start_line, t->meth->name);
|
||||
TEST_info("%s:%d %s error",
|
||||
t->s.test_file, t->s.start, t->meth->name);
|
||||
return 0;
|
||||
}
|
||||
if (!check_test_error(t)) {
|
||||
test_openssl_errors();
|
||||
t->errors++;
|
||||
t->s.errors++;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2248,90 +2241,6 @@ static void free_key_list(KEY_LIST *lst)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read a line, remove the newline, return EOF or first char.
|
||||
* Comment lines are treated like empty lines.
|
||||
*/
|
||||
static int read_line(EVP_TEST *t)
|
||||
{
|
||||
char *p;
|
||||
|
||||
if (!BIO_gets(t->in, t->buf, sizeof(t->buf)))
|
||||
return EOF;
|
||||
t->line++;
|
||||
if ((p = strchr(t->buf, '\n')) != NULL)
|
||||
*p = '\0';
|
||||
if (t->buf[0] == '#')
|
||||
t->buf[0] = '\0';
|
||||
return t->buf[0];
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip leading spaces and remove trailing spaces from string.
|
||||
*/
|
||||
static char *strip_spaces(char *pval)
|
||||
{
|
||||
char *p, *start;
|
||||
|
||||
for (start = pval; isspace(*start); )
|
||||
start++;
|
||||
if (*start == '\0')
|
||||
return start;
|
||||
|
||||
for (p = start + strlen(start); --p >= start && isspace(*p); )
|
||||
*p = '\0';
|
||||
return start;
|
||||
}
|
||||
|
||||
/*
|
||||
* Split line into 'key = value'; return 1 if okay, 0 on error.
|
||||
*/
|
||||
static int split_line(EVP_TEST *t, char **keyword, char **value)
|
||||
{
|
||||
char *p;
|
||||
|
||||
/* Look for = sign */
|
||||
if ((p = strchr(t->buf, '=')) == NULL) {
|
||||
TEST_error("Line %d: Missing '=' in test file", t->line);
|
||||
return 0;
|
||||
}
|
||||
*p++ = '\0';
|
||||
*keyword = strip_spaces(t->buf);
|
||||
*value = strip_spaces(p);
|
||||
if (**keyword == '\0') {
|
||||
TEST_error("Line %d: Missing key; malformed input line", t->line);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a PEM block. Return 1 if okay, 0 on error.
|
||||
*/
|
||||
static int read_key(EVP_TEST *t)
|
||||
{
|
||||
char tmpbuf[128];
|
||||
|
||||
if (t->key == NULL) {
|
||||
if (!TEST_ptr(t->key = BIO_new(BIO_s_mem())))
|
||||
return 0;
|
||||
} else if (!TEST_int_gt(BIO_reset(t->key), 0)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read to PEM end line and place content in memory BIO */
|
||||
while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) {
|
||||
t->line++;
|
||||
if (!TEST_int_gt(BIO_puts(t->key, tmpbuf), 0))
|
||||
return 0;
|
||||
if (strncmp(tmpbuf, "-----END", 8) == 0)
|
||||
return 1;
|
||||
}
|
||||
TEST_error("Can't find key end");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Is the key type an unsupported algorithm?
|
||||
*/
|
||||
@ -2360,54 +2269,52 @@ static int key_unsupported()
|
||||
}
|
||||
|
||||
/*
|
||||
* Read, parse, and execute one test. Return EOF; 0 if failure, 1 if okay.
|
||||
* NULL out the value from |pp| but return it. This "steals" a pointer.
|
||||
*/
|
||||
static int read_stanza(EVP_TEST *t)
|
||||
static char *take_value(PAIR *pp)
|
||||
{
|
||||
int c;
|
||||
char *keyword, *value;
|
||||
KEY_LIST **klist, *key;
|
||||
char *p = pp->value;
|
||||
|
||||
pp->value = NULL;
|
||||
return p;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read and parse one test. Return 0 if failure, 1 if okay.
|
||||
*/
|
||||
static int parse(EVP_TEST *t)
|
||||
{
|
||||
KEY_LIST *key, **klist;
|
||||
EVP_PKEY *pkey;
|
||||
PAIR *pp;
|
||||
int i;
|
||||
|
||||
clear_test(t);
|
||||
top:
|
||||
/* Find the first line of a stanza. */
|
||||
for ( ; ; ) {
|
||||
c = read_line(t);
|
||||
if (c == EOF)
|
||||
do {
|
||||
if (BIO_eof(t->s.fp))
|
||||
return EOF;
|
||||
if (c == '\0')
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
if (!split_line(t, &keyword, &value))
|
||||
clear_test(t);
|
||||
if (!test_readstanza(&t->s))
|
||||
return 0;
|
||||
} while (t->s.numpairs == 0);
|
||||
pp = &t->s.pairs[0];
|
||||
|
||||
/* Handle a few special cases here. */
|
||||
if (strcmp(keyword, "Title") == 0) {
|
||||
TEST_info("Starting \"%s\" tests", value);
|
||||
goto top;
|
||||
}
|
||||
|
||||
/* Are we adding a key? */
|
||||
klist = NULL;
|
||||
pkey = NULL;
|
||||
if (strcmp(keyword, "PrivateKey") == 0) {
|
||||
if (!read_key(t))
|
||||
return 0;
|
||||
pkey = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
|
||||
if (strcmp(pp->key, "PrivateKey") == 0) {
|
||||
pkey = PEM_read_bio_PrivateKey(t->s.key, NULL, 0, NULL);
|
||||
if (pkey == NULL && !key_unsupported()) {
|
||||
TEST_info("Can't read private key %s", value);
|
||||
TEST_info("Can't read private key %s", pp->value);
|
||||
ERR_print_errors_fp(stderr);
|
||||
return 0;
|
||||
}
|
||||
klist = &private_keys;
|
||||
}
|
||||
else if (strcmp(keyword, "PublicKey") == 0) {
|
||||
if (!read_key(t))
|
||||
return 0;
|
||||
pkey = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
|
||||
else if (strcmp(pp->key, "PublicKey") == 0) {
|
||||
pkey = PEM_read_bio_PUBKEY(t->s.key, NULL, 0, NULL);
|
||||
if (pkey == NULL && !key_unsupported()) {
|
||||
TEST_info("Can't read public key %s", value);
|
||||
TEST_info("Can't read public key %s", pp->value);
|
||||
ERR_print_errors_fp(stderr);
|
||||
return 0;
|
||||
}
|
||||
@ -2416,135 +2323,105 @@ top:
|
||||
|
||||
/* If we have a key add to list */
|
||||
if (klist != NULL) {
|
||||
if (find_key(NULL, value, *klist)) {
|
||||
TEST_info("Duplicate key %s", value);
|
||||
if (find_key(NULL, pp->value, *klist)) {
|
||||
TEST_info("Duplicate key %s", pp->value);
|
||||
return 0;
|
||||
}
|
||||
if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
|
||||
|| !TEST_ptr(key->name = OPENSSL_strdup(value)))
|
||||
if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
|
||||
return 0;
|
||||
key->name = take_value(pp);
|
||||
key->key = pkey;
|
||||
key->next = *klist;
|
||||
*klist = key;
|
||||
|
||||
/* Go back and start a new stanza. */
|
||||
if (t->s.numpairs != 1)
|
||||
TEST_info("Line %d: missing blank line\n", t->s.curr);
|
||||
goto top;
|
||||
}
|
||||
|
||||
/* Start of a new text. Look it up. */
|
||||
if (!TEST_ptr(t->meth = find_test(keyword)))
|
||||
goto skiptoend;
|
||||
t->start_line = t->line;
|
||||
if (!t->meth->init(t, value)) {
|
||||
TEST_error("unknown %s: %s\n", keyword, value);
|
||||
goto skiptoend;
|
||||
/* Find the test, based on first keyword. */
|
||||
if (!TEST_ptr(t->meth = find_test(pp->key)))
|
||||
return 0;
|
||||
if (!t->meth->init(t, pp->value)) {
|
||||
TEST_error("unknown %s: %s\n", pp->key, pp->value);
|
||||
return 0;
|
||||
}
|
||||
if (t->skip == 1) {
|
||||
/* TEST_info("skipping %s %s", keyword, value); */
|
||||
goto skiptoend;
|
||||
/* TEST_info("skipping %s %s", pp->key, pp->value); */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read rest of stanza. */
|
||||
for ( ; ; ) {
|
||||
c = read_line(t);
|
||||
if (c == EOF)
|
||||
return c;
|
||||
if (c == '\0')
|
||||
break;
|
||||
if (!split_line(t, &keyword, &value))
|
||||
goto skiptoend;
|
||||
if (strcmp(keyword, "Result") == 0) {
|
||||
for (pp++, i = 1; i < t->s.numpairs; pp++, i++) {
|
||||
if (strcmp(pp->key, "Result") == 0) {
|
||||
if (t->expected_err != NULL) {
|
||||
TEST_info("Line %d: multiple result lines", t->line);
|
||||
goto skiptoend;
|
||||
TEST_info("Line %d: multiple result lines", t->s.curr);
|
||||
return 0;
|
||||
}
|
||||
if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
|
||||
goto skiptoend;
|
||||
} else if (strcmp(keyword, "Function") == 0) {
|
||||
t->expected_err = take_value(pp);
|
||||
} else if (strcmp(pp->key, "Function") == 0) {
|
||||
if (t->func != NULL) {
|
||||
TEST_info("Line %d: multiple function lines\n", t->line);
|
||||
goto skiptoend;
|
||||
TEST_info("Line %d: multiple function lines\n", t->s.curr);
|
||||
return 0;
|
||||
}
|
||||
if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
|
||||
goto skiptoend;
|
||||
} else if (strcmp(keyword, "Reason") == 0) {
|
||||
t->func = take_value(pp);
|
||||
} else if (strcmp(pp->key, "Reason") == 0) {
|
||||
if (t->reason != NULL) {
|
||||
TEST_info("Line %d: multiple reason lines", t->line);
|
||||
goto skiptoend;
|
||||
TEST_info("Line %d: multiple reason lines", t->s.curr);
|
||||
return 0;
|
||||
}
|
||||
if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
|
||||
goto skiptoend;
|
||||
t->reason = take_value(pp);
|
||||
} else {
|
||||
/* Must be test specific line: try to parse it */
|
||||
int rv = t->meth->parse(t, keyword, value);
|
||||
int rv = t->meth->parse(t, pp->key, pp->value);
|
||||
|
||||
if (rv == 0) {
|
||||
TEST_info("Line %d: unknown keyword %s", t->line, keyword);
|
||||
goto skiptoend;
|
||||
TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
|
||||
return 0;
|
||||
}
|
||||
if (rv < 0) {
|
||||
TEST_info("Line %d: error processing keyword %s\n",
|
||||
t->line, keyword);
|
||||
goto skiptoend;
|
||||
t->s.curr, pp->key);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
||||
skiptoend:
|
||||
/* Read to end of stanza and return failure */
|
||||
for ( ; ; ) {
|
||||
c = read_line(t);
|
||||
if (c == EOF)
|
||||
return EOF;
|
||||
if (c == '\0')
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_test_file(const char *testfile)
|
||||
{
|
||||
BIO *in;
|
||||
EVP_TEST t;
|
||||
int c;
|
||||
|
||||
set_test_title(testfile);
|
||||
current_test_file = testfile;
|
||||
if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
|
||||
return 0;
|
||||
memset(&t, 0, sizeof(t));
|
||||
t.in = in;
|
||||
|
||||
TEST_info("Reading %s", testfile);
|
||||
for ( ; ; ) {
|
||||
c = read_stanza(&t);
|
||||
if (t.skip)
|
||||
continue;
|
||||
if (c == 0 || !run_test(&t)) {
|
||||
t.errors++;
|
||||
break;
|
||||
}
|
||||
if (c == EOF)
|
||||
break;
|
||||
}
|
||||
clear_test(&t);
|
||||
|
||||
TEST_info("Completed %d tests with %d errors and %d skipped",
|
||||
t.ntests, t.errors, t.nskip);
|
||||
free_key_list(public_keys);
|
||||
free_key_list(private_keys);
|
||||
BIO_free(t.key);
|
||||
BIO_free(in);
|
||||
return t.errors == 0;
|
||||
}
|
||||
|
||||
static char * const *testfiles;
|
||||
|
||||
static int run_file_tests(int i)
|
||||
{
|
||||
return do_test_file(testfiles[i]);
|
||||
EVP_TEST *t;
|
||||
int c;
|
||||
|
||||
if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
|
||||
return 0;
|
||||
if (!test_start_file(&t->s, testfiles[i])) {
|
||||
OPENSSL_free(t);
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (!BIO_eof(t->s.fp)) {
|
||||
c = parse(t);
|
||||
if (t->skip)
|
||||
continue;
|
||||
if (c == 0 || !run_test(t)) {
|
||||
t->s.errors++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
test_end_file(&t->s);
|
||||
clear_test(t);
|
||||
|
||||
free_key_list(public_keys);
|
||||
free_key_list(private_keys);
|
||||
BIO_free(t->s.key);
|
||||
c = t->s.errors;
|
||||
OPENSSL_free(t);
|
||||
return c == 0;
|
||||
}
|
||||
|
||||
int test_main(int argc, char *argv[])
|
||||
|
||||
@ -1178,6 +1178,7 @@ Operation = DECRYPT
|
||||
Result = CIPHERFINAL_ERROR
|
||||
|
||||
Title = AES XTS test vectors from IEEE Std 1619-2007
|
||||
|
||||
Cipher = aes-128-xts
|
||||
Key = 0000000000000000000000000000000000000000000000000000000000000000
|
||||
IV = 00000000000000000000000000000000
|
||||
|
||||
@ -708,6 +708,7 @@ PrivateKey=Alice-25519
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VuBCIEIHcHbQpzGKV9PBbBclGyZkXfTC+H68CZKrF3+6UduSwq
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PublicKey=Alice-25519-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VuAyEAhSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo=
|
||||
@ -719,6 +720,7 @@ PrivateKey=Bob-25519
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VuBCIEIF2rCH5iSopLeeF/i4OADuZvO7EpJhi2/Rwviyf/iODr
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PublicKey=Bob-25519-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VuAyEA3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08=
|
||||
@ -747,9 +749,9 @@ Function = EVP_PKEY_verify_init
|
||||
Reason = operation not supported for this keytype
|
||||
|
||||
|
||||
Title = RSA PSS/OAEP (from RSASecurity FTP)
|
||||
# Additional RSA-PSS and RSA-OAEP tests converted from
|
||||
# ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
|
||||
Title = RSA PSS/OAEP (from RSASecurity FTP)
|
||||
|
||||
PublicKey=RSA-PSS-1
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
@ -5811,7 +5813,6 @@ SharedSecret=A7927098655F1F9976FA50A9D566865DC530331846381C87256BAF3226244B76D36
|
||||
# 456068d3f8aad8ac62a03d19ed3173f00ad51f42b51aeab4753c20f30c01cf23 #
|
||||
Title = ECDH KATs (from NIST SP800-56A co-factor ECDH KATs
|
||||
|
||||
|
||||
PrivateKey=KAS-ECC-CDH_P-192_C0
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBjxfT/qNnt000CFHKQn
|
||||
@ -17327,18 +17328,22 @@ PrivateKey=ED25519-1
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VwBCIEIJ1hsZ3v/VpguoRK9JLsLMREScVpezJpGXA7rAMcrn9g
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PrivateKey=ED25519-2
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VwBCIEIEzNCJso/5banbbDRuwRTg9bijGfNaumJNqM9u1PuKb7
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PrivateKey=ED25519-3
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VwBCIEIMWqjfQ/n4N77bdELzHct7Fm04U1B28JS4XOOi4LRFj3
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PrivateKey=ED25519-4
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VwBCIEIPXldnzxUzGVF2MPImh2uGyBYMxYO8ATdExr8lX1zA7l
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PrivateKey=ED25519-5
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MC4CAQAwBQYDK2VwBCIEIIM/5iQJI3udYux3WHUgkR6adZzsHRl1W32pAbltyj1C
|
||||
@ -17348,18 +17353,22 @@ PublicKey=ED25519-1-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VwAyEA11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PublicKey=ED25519-2-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VwAyEAPUAXw+hDiVqStwqnTRt+vJyYLM8uxJaMwM1V8Sr0Zgw=
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PublicKey=ED25519-3-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VwAyEA/FHNjmIYoaONpH7QAjDwWAgW7RO6MwOsXeuRFUiQgCU=
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PublicKey=ED25519-4-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VwAyEAJ4EX/BRMcjQPZ9DyMW6Dhs7/vyskKMnFH+98WX8dQm4=
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PublicKey=ED25519-5-PUBLIC
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MCowBQYDK2VwAyEA7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8=
|
||||
|
||||
@ -402,4 +402,48 @@ void test_openssl_errors(void);
|
||||
extern BIO *bio_out;
|
||||
extern BIO *bio_err;
|
||||
|
||||
/*
|
||||
* Utilities to parse a test file.
|
||||
*/
|
||||
#define TESTMAXPAIRS 20
|
||||
|
||||
typedef struct pair_st {
|
||||
char *key;
|
||||
char *value;
|
||||
} PAIR;
|
||||
|
||||
typedef struct stanza_st {
|
||||
const char *test_file; /* Input file name */
|
||||
BIO *fp; /* Input file */
|
||||
int curr; /* Current line in file */
|
||||
int start; /* Line where test starts */
|
||||
int errors; /* Error count */
|
||||
int numtests; /* Number of tests */
|
||||
int numskip; /* Number of skipped tests */
|
||||
int numpairs;
|
||||
PAIR pairs[TESTMAXPAIRS];
|
||||
BIO *key; /* temp memory BIO for reading in keys */
|
||||
char buff[4096]; /* Input buffer for a single key/value */
|
||||
} STANZA;
|
||||
|
||||
/*
|
||||
* Prepare to start reading the file |testfile| as input.
|
||||
*/
|
||||
int test_start_file(STANZA *s, const char *testfile);
|
||||
int test_end_file(STANZA *s);
|
||||
|
||||
/*
|
||||
* Read a stanza from the test file. A stanza consists of a block
|
||||
* of lines of the form
|
||||
* key = value
|
||||
* The block is terminated by EOF or a blank line.
|
||||
* Return 1 if found, 0 on EOF or error.
|
||||
*/
|
||||
int test_readstanza(STANZA *s);
|
||||
|
||||
/*
|
||||
* Clear a stanza, release all allocated memory.
|
||||
*/
|
||||
void test_clearstanza(STANZA *s);
|
||||
|
||||
#endif /* HEADER_TESTUTIL_H */
|
||||
|
||||
157
test/testutil/stanza.c
Normal file
157
test/testutil/stanza.c
Normal file
@ -0,0 +1,157 @@
|
||||
/*
|
||||
* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "e_os.h"
|
||||
#include "../testutil.h"
|
||||
|
||||
int test_start_file(STANZA *s, const char *testfile)
|
||||
{
|
||||
TEST_info("Reading %s", testfile);
|
||||
set_test_title(testfile);
|
||||
memset(s, 0, sizeof(*s));
|
||||
if (!TEST_ptr(s->fp = BIO_new_file(testfile, "rb")))
|
||||
return 0;
|
||||
s->test_file = testfile;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_end_file(STANZA *s)
|
||||
{
|
||||
TEST_info("Completed %d tests with %d errors and %d skipped",
|
||||
s->numtests, s->errors, s->numskip);
|
||||
BIO_free(s->fp);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a PEM block. Return 1 if okay, 0 on error.
|
||||
*/
|
||||
static int read_key(STANZA *s)
|
||||
{
|
||||
char tmpbuf[128];
|
||||
|
||||
if (s->key == NULL) {
|
||||
if (!TEST_ptr(s->key = BIO_new(BIO_s_mem())))
|
||||
return 0;
|
||||
} else if (!TEST_int_gt(BIO_reset(s->key), 0)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read to PEM end line and place content in memory BIO */
|
||||
while (BIO_gets(s->fp, tmpbuf, sizeof(tmpbuf))) {
|
||||
s->curr++;
|
||||
if (!TEST_int_gt(BIO_puts(s->key, tmpbuf), 0))
|
||||
return 0;
|
||||
if (strncmp(tmpbuf, "-----END", 8) == 0)
|
||||
return 1;
|
||||
}
|
||||
TEST_error("Can't find key end");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Delete leading and trailing spaces from a string
|
||||
*/
|
||||
static char *strip_spaces(char *p)
|
||||
{
|
||||
char *q;
|
||||
|
||||
/* Skip over leading spaces */
|
||||
while (*p && isspace(*p))
|
||||
p++;
|
||||
if (!*p)
|
||||
return NULL;
|
||||
|
||||
for (q = p + strlen(p) - 1; q != p && isspace(*q); )
|
||||
*q-- = '\0';
|
||||
return *p ? p : NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read next test stanza; return 1 if found, 0 on EOF or error.
|
||||
*/
|
||||
int test_readstanza(STANZA *s)
|
||||
{
|
||||
PAIR *pp = s->pairs;
|
||||
char *p, *equals, *key, *value;
|
||||
|
||||
for (s->numpairs = 0; BIO_gets(s->fp, s->buff, sizeof(s->buff)); ) {
|
||||
s->curr++;
|
||||
if (!TEST_ptr(p = strchr(s->buff, '\n'))) {
|
||||
TEST_info("Line %d too long", s->curr);
|
||||
return 0;
|
||||
}
|
||||
*p = '\0';
|
||||
|
||||
/* Blank line marks end of tests. */
|
||||
if (s->buff[0] == '\0')
|
||||
break;
|
||||
|
||||
/* Lines starting with a pound sign are ignored. */
|
||||
if (s->buff[0] == '#')
|
||||
continue;
|
||||
|
||||
/* Parse into key=value */
|
||||
if (!TEST_ptr(equals = strchr(s->buff, '='))) {
|
||||
TEST_info("Missing = at line %d\n", s->curr);
|
||||
return 0;
|
||||
}
|
||||
*equals++ = '\0';
|
||||
if (!TEST_ptr(key = strip_spaces(s->buff))) {
|
||||
TEST_info("Empty field at line %d\n", s->curr);
|
||||
return 0;
|
||||
}
|
||||
if ((value = strip_spaces(equals)) == NULL)
|
||||
value = "";
|
||||
|
||||
if (strcmp(key, "Title") == 0) {
|
||||
TEST_info("Starting \"%s\" tests at line %d", value, s->curr);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (s->numpairs == 0)
|
||||
s->start = s->curr;
|
||||
|
||||
if (strcmp(key, "PrivateKey") == 0) {
|
||||
if (!read_key(s))
|
||||
return 0;
|
||||
}
|
||||
if (strcmp(key, "PublicKey") == 0) {
|
||||
if (!read_key(s))
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!TEST_int_lt(s->numpairs++, TESTMAXPAIRS)
|
||||
|| !TEST_ptr(pp->key = OPENSSL_strdup(key))
|
||||
|| !TEST_ptr(pp->value = OPENSSL_strdup(value)))
|
||||
return 0;
|
||||
pp++;
|
||||
}
|
||||
|
||||
/* If we read anything, return ok. */
|
||||
return 1;
|
||||
}
|
||||
|
||||
void test_clearstanza(STANZA *s)
|
||||
{
|
||||
PAIR *pp = s->pairs;
|
||||
int i = s->numpairs;
|
||||
|
||||
for ( ; --i >= 0; pp++) {
|
||||
OPENSSL_free(pp->key);
|
||||
OPENSSL_free(pp->value);
|
||||
}
|
||||
s->numpairs = 0;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user