mirror of https://github.com/openssl/openssl.git
159 lines
3.8 KiB
C
159 lines
3.8 KiB
C
/*
|
|
* 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"
|
|
#include "tu_local.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, "r")))
|
|
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;
|
|
}
|