[thirdparty/openssl.git] / test / errtest.c

/*
 * Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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 <string.h>
#include <openssl/opensslconf.h>
#include <openssl/err.h>
#include <openssl/macros.h>

#include "testutil.h"

#if defined(OPENSSL_SYS_WINDOWS)
# include <windows.h>
#else
# include <errno.h>
#endif

#ifndef OPENSSL_NO_DEPRECATED_3_0
# define IS_HEX(ch) ((ch >= '0' && ch <='9') || (ch >= 'A' && ch <='F'))

static int test_print_error_format(void)
{
    /* Variables used to construct an error line */
    char *lib;
    const char *func = OPENSSL_FUNC;
    char *reason;
# ifdef OPENSSL_NO_ERR
    char reasonbuf[255];
# endif
# ifndef OPENSSL_NO_FILENAMES
    const char *file = OPENSSL_FILE;
    const int line = OPENSSL_LINE;
# else
    const char *file = "";
    const int line = 0;
# endif
    /* The format for OpenSSL error lines */
    const char *expected_format = ":error:%08lX:%s:%s:%s:%s:%d";
    /*-
     *                                          ^^ ^^ ^^ ^^ ^^
     * "library" name --------------------------++ || || || ||
     * function name ------------------------------++ || || ||
     * reason string (system error string) -----------++ || ||
     * file name ----------------------------------------++ ||
     * line number -----------------------------------------++
     */
    char expected[512];

    char *out = NULL, *p = NULL;
    int ret = 0, len;
    BIO *bio = NULL;
    const int syserr = EPERM;
    unsigned long errorcode;
    unsigned long reasoncode;

    /*
     * We set a mark here so we can clear the system error that we generate
     * with ERR_PUT_error().  That is, after all, just a simulation to verify
     * ERR_print_errors() output, not a real error.
     */
    ERR_set_mark();

    ERR_PUT_error(ERR_LIB_SYS, 0, syserr, file, line);
    errorcode = ERR_peek_error();
    reasoncode = ERR_GET_REASON(errorcode);

    if (!TEST_int_eq(reasoncode, syserr)) {
        ERR_pop_to_mark();
        goto err;
    }

# if !defined(OPENSSL_NO_ERR)
#  if defined(OPENSSL_NO_AUTOERRINIT)
    lib = "lib(2)";
#  else
    lib = "system library";
#  endif
    reason = strerror(syserr);
# else
    lib = "lib(2)";
    BIO_snprintf(reasonbuf, sizeof(reasonbuf), "reason(%lu)", reasoncode);
    reason = reasonbuf;
# endif

    BIO_snprintf(expected, sizeof(expected), expected_format,
                 errorcode, lib, func, reason, file, line);

    if (!TEST_ptr(bio = BIO_new(BIO_s_mem())))
        goto err;

    ERR_print_errors(bio);

    if (!TEST_int_gt(len = BIO_get_mem_data(bio, &out), 0))
        goto err;
    /* Skip over the variable thread id at the start of the string */
    for (p = out; *p != ':' && *p != 0; ++p) {
        if (!TEST_true(IS_HEX(*p)))
            goto err;
    }
    if (!TEST_true(*p != 0)
        || !TEST_strn_eq(expected, p, strlen(expected)))
        goto err;

    ret = 1;
err:
    BIO_free(bio);
    return ret;
}
#endif

/* Test that querying the error queue preserves the OS error. */
static int preserves_system_error(void)
{
#if defined(OPENSSL_SYS_WINDOWS)
    SetLastError(ERROR_INVALID_FUNCTION);
    ERR_get_error();
    return TEST_int_eq(GetLastError(), ERROR_INVALID_FUNCTION);
#else
    errno = EINVAL;
    ERR_get_error();
    return TEST_int_eq(errno, EINVAL);
#endif
}

/* Test that calls to ERR_add_error_[v]data append */
static int vdata_appends(void)
{
    const char *data;

    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    ERR_add_error_data(1, "hello ");
    ERR_add_error_data(1, "world");
    ERR_peek_error_data(&data, NULL);
    return TEST_str_eq(data, "hello world");
}

static int raised_error(void)
{
    const char *f, *data;
    int l;
    unsigned long e;

    /*
     * When OPENSSL_NO_ERR or OPENSSL_NO_FILENAMES, no file name or line
     * number is saved, so no point checking them.
     */
#if !defined(OPENSSL_NO_FILENAMES) && !defined(OPENSSL_NO_ERR)
    const char *file;
    int line;

    file = __FILE__;
    line = __LINE__ + 2; /* The error is generated on the ERR_raise_data line */
#endif
    ERR_raise_data(ERR_LIB_NONE, ERR_R_INTERNAL_ERROR,
                   "calling exit()");
    if (!TEST_ulong_ne(e = ERR_get_error_all(&f, &l, NULL, &data, NULL), 0)
            || !TEST_int_eq(ERR_GET_REASON(e), ERR_R_INTERNAL_ERROR)
#if !defined(OPENSSL_NO_FILENAMES) && !defined(OPENSSL_NO_ERR)
            || !TEST_int_eq(l, line)
            || !TEST_str_eq(f, file)
#endif
            || !TEST_str_eq(data, "calling exit()"))
        return 0;
    return 1;
}

static int test_marks(void)
{
    unsigned long mallocfail, shouldnot;

    /* Set an initial error */
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    mallocfail = ERR_peek_last_error();
    if (!TEST_ulong_gt(mallocfail, 0))
        return 0;

    /* Setting and clearing a mark should not affect the error */
    if (!TEST_true(ERR_set_mark())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error())
            || !TEST_true(ERR_set_mark())
            || !TEST_true(ERR_clear_last_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
        return 0;

    /* Test popping errors */
    if (!TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
    if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
        return 0;

    /* Nested marks should also work */
    if (!TEST_true(ERR_set_mark())
            || !TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
    if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
        return 0;

    if (!TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
    shouldnot = ERR_peek_last_error();
    if (!TEST_ulong_ne(mallocfail, shouldnot)
            || !TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
    if (!TEST_ulong_ne(shouldnot, ERR_peek_last_error())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(shouldnot, ERR_peek_last_error())
            || !TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
        return 0;

    /* Setting and clearing a mark should not affect the errors on the stack */
    if (!TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
    if (!TEST_true(ERR_clear_last_mark())
            || !TEST_ulong_eq(shouldnot, ERR_peek_last_error()))
        return 0;

    /*
     * Popping where no mark has been set should pop everything - but return
     * a failure result
     */
    if (!TEST_false(ERR_pop_to_mark())
            || !TEST_ulong_eq(0, ERR_peek_last_error()))
        return 0;

    /* Clearing where there is no mark should fail */
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    if (!TEST_false(ERR_clear_last_mark())
                /* "get" the last error to remove it */
            || !TEST_ulong_eq(mallocfail, ERR_get_error())
            || !TEST_ulong_eq(0, ERR_peek_last_error()))
        return 0;

    /*
     * Setting a mark where there are no errors in the stack should fail.
     * NOTE: This is somewhat surprising behaviour but is historically how this
     * function behaves. In practice we typically set marks without first
     * checking whether there is anything on the stack - but we also don't
     * tend to check the success of this function. It turns out to work anyway
     * because although setting a mark with no errors fails, a subsequent call
     * to ERR_pop_to_mark() or ERR_clear_last_mark() will do the right thing
     * anyway (even though they will report a failure result).
     */
    if (!TEST_false(ERR_set_mark()))
        return 0;

    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    if (!TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

    /* Should be able to "pop" past 2 errors */
    if (!TEST_true(ERR_pop_to_mark())
            || !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
        return 0;

    if (!TEST_true(ERR_set_mark()))
        return 0;
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
    ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

    /* Should be able to "clear" past 2 errors */
    if (!TEST_true(ERR_clear_last_mark())
            || !TEST_ulong_eq(shouldnot, ERR_peek_last_error()))
        return 0;

    /* Clear remaining errors from last test */
    ERR_clear_error();

    return 1;
}

static int test_clear_error(void)
{
    int flags = -1;
    const char *data = NULL;
    int res = 0;

    /* Raise an error with data and clear it */
    ERR_raise_data(0, 0, "hello %s", "world");
    ERR_peek_error_data(&data, &flags);
    if (!TEST_str_eq(data, "hello world")
            || !TEST_int_eq(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
        goto err;
    ERR_clear_error();

    /* Raise a new error without data */
    ERR_raise(0, 0);
    ERR_peek_error_data(&data, &flags);
    if (!TEST_str_eq(data, "")
            || !TEST_int_eq(flags, ERR_TXT_MALLOCED))
        goto err;
    ERR_clear_error();

    /* Raise a new error with data */
    ERR_raise_data(0, 0, "goodbye %s world", "cruel");
    ERR_peek_error_data(&data, &flags);
    if (!TEST_str_eq(data, "goodbye cruel world")
            || !TEST_int_eq(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
        goto err;
    ERR_clear_error();

    /*
     * Raise a new error without data to check that the malloced storage
     * is freed properly
     */
    ERR_raise(0, 0);
    ERR_peek_error_data(&data, &flags);
    if (!TEST_str_eq(data, "")
            || !TEST_int_eq(flags, ERR_TXT_MALLOCED))
        goto err;
    ERR_clear_error();

    res = 1;
 err:
     ERR_clear_error();
    return res;
}

/*
 * Test saving and restoring error state.
 * Test 0: Save using OSSL_ERR_STATE_save()
 * Test 1: Save using OSSL_ERR_STATE_save_to_mark()
 */
static int test_save_restore(int idx)
{
    ERR_STATE *es;
    int res = 0, i, flags = -1;
    unsigned long mallocfail, interr;
    static const char testdata[] = "test data";
    const char *data = NULL;

    if (!TEST_ptr(es = OSSL_ERR_STATE_new()))
        goto err;

    ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
    mallocfail = ERR_peek_last_error();
    if (!TEST_ulong_gt(mallocfail, 0))
        goto err;

    if (idx == 1 && !TEST_int_eq(ERR_set_mark(), 1))
        goto err;

    ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR, testdata);
    interr = ERR_peek_last_error();
    if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error()))
        goto err;

    if (idx == 0) {
        OSSL_ERR_STATE_save(es);

        if (!TEST_ulong_eq(ERR_peek_last_error(), 0))
            goto err;
    } else {
        OSSL_ERR_STATE_save_to_mark(es);

        if (!TEST_ulong_ne(ERR_peek_last_error(), 0))
            goto err;
    }

    for (i = 0; i < 2; i++) {
        OSSL_ERR_STATE_restore(es);

        if (!TEST_ulong_eq(ERR_peek_last_error(), interr))
            goto err;
        ERR_peek_last_error_data(&data, &flags);
        if (!TEST_str_eq(data, testdata)
                || !TEST_int_eq(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
            goto err;

        /* restore again to duplicate the entries */
        OSSL_ERR_STATE_restore(es);

        /* verify them all */
        if (idx == 0 || i == 0) {
            if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
                                                 &data, &flags), mallocfail)
                || !TEST_int_ne(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
                goto err;
        }

        if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
                                             &data, &flags), interr)
            || !TEST_str_eq(data, testdata)
            || !TEST_int_eq(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
            goto err;

        if (idx == 0) {
            if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
                                                 &data, &flags), mallocfail)
                || !TEST_int_ne(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
                goto err;
        }

        if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
                                             &data, &flags), interr)
            || !TEST_str_eq(data, testdata)
            || !TEST_int_eq(flags, ERR_TXT_STRING | ERR_TXT_MALLOCED))
            goto err;

        if (!TEST_ulong_eq(ERR_get_error(), 0))
            goto err;
    }

    res = 1;
 err:
    OSSL_ERR_STATE_free(es);
    return res;
}

int setup_tests(void)
{
    ADD_TEST(preserves_system_error);
    ADD_TEST(vdata_appends);
    ADD_TEST(raised_error);
#ifndef OPENSSL_NO_DEPRECATED_3_0
    ADD_TEST(test_print_error_format);
#endif
    ADD_TEST(test_marks);
    ADD_ALL_TESTS(test_save_restore, 2);
    ADD_TEST(test_clear_error);
    return 1;
}
Commit	Line	Data
2de108df	1	/*
da1c088f	2	* Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved.
2de108df	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
2de108df DB	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
f32af93c	10	#include <string.h>
2de108df DB	11	#include <openssl/opensslconf.h>
2de108df DB	12	#include <openssl/err.h>
3d518d3d	13	#include <openssl/macros.h>
2de108df DB	14
	15	#include "testutil.h"
	16
	17	#if defined(OPENSSL_SYS_WINDOWS)
	18	# include <windows.h>
	19	#else
	20	# include <errno.h>
	21	#endif
	22
f32af93c SL	23	#ifndef OPENSSL_NO_DEPRECATED_3_0
	24	# define IS_HEX(ch) ((ch >= '0' && ch <='9') \|\| (ch >= 'A' && ch <='F'))
	25
	26	static int test_print_error_format(void)
	27	{
17b7f896	28	/* Variables used to construct an error line */
abcca507	29	char *lib;
17b7f896	30	const char *func = OPENSSL_FUNC;
abcca507 RL	31	char *reason;
	32	# ifdef OPENSSL_NO_ERR
	33	char reasonbuf[255];
	34	# endif
f32af93c	35	# ifndef OPENSSL_NO_FILENAMES
17b7f896 RL	36	const char *file = OPENSSL_FILE;
17b7f896 RL	37	const int line = OPENSSL_LINE;
f32af93c	38	# else
17b7f896 RL	39	const char *file = "";
17b7f896 RL	40	const int line = 0;
f32af93c	41	# endif
17b7f896	42	/* The format for OpenSSL error lines */
abcca507	43	const char *expected_format = ":error:%08lX:%s:%s:%s:%s:%d";
17b7f896	44	/*-
abcca507 RL	45	* ^^ ^^ ^^ ^^ ^^
	46	* "library" name --------------------------++ \|\| \|\| \|\| \|\|
	47	* function name ------------------------------++ \|\| \|\| \|\|
	48	* reason string (system error string) -----------++ \|\| \|\|
	49	* file name ----------------------------------------++ \|\|
	50	* line number -----------------------------------------++
17b7f896 RL	51	*/
	52	char expected[512];
	53
f32af93c SL	54	char out = NULL, p = NULL;
	55	int ret = 0, len;
	56	BIO *bio = NULL;
17b7f896	57	const int syserr = EPERM;
abcca507 RL	58	unsigned long errorcode;
abcca507 RL	59	unsigned long reasoncode;
17b7f896 RL	60
	61	/*
	62	* We set a mark here so we can clear the system error that we generate
	63	* with ERR_PUT_error(). That is, after all, just a simulation to verify
	64	* ERR_print_errors() output, not a real error.
	65	*/
	66	ERR_set_mark();
f32af93c	67
17b7f896	68	ERR_PUT_error(ERR_LIB_SYS, 0, syserr, file, line);
abcca507 RL	69	errorcode = ERR_peek_error();
abcca507 RL	70	reasoncode = ERR_GET_REASON(errorcode);
17b7f896 RL	71
	72	if (!TEST_int_eq(reasoncode, syserr)) {
	73	ERR_pop_to_mark();
	74	goto err;
	75	}
	76
582043da P	77	# if !defined(OPENSSL_NO_ERR)
	78	# if defined(OPENSSL_NO_AUTOERRINIT)
	79	lib = "lib(2)";
	80	# else
abcca507	81	lib = "system library";
582043da	82	# endif
abcca507 RL	83	reason = strerror(syserr);
	84	# else
	85	lib = "lib(2)";
	86	BIO_snprintf(reasonbuf, sizeof(reasonbuf), "reason(%lu)", reasoncode);
	87	reason = reasonbuf;
	88	# endif
	89
17b7f896	90	BIO_snprintf(expected, sizeof(expected), expected_format,
abcca507	91	errorcode, lib, func, reason, file, line);
3d518d3d	92
f32af93c	93	if (!TEST_ptr(bio = BIO_new(BIO_s_mem())))
17b7f896	94	goto err;
f32af93c	95
f32af93c SL	96	ERR_print_errors(bio);
	97
	98	if (!TEST_int_gt(len = BIO_get_mem_data(bio, &out), 0))
	99	goto err;
	100	/* Skip over the variable thread id at the start of the string */
	101	for (p = out; p != ':' && p != 0; ++p) {
	102	if (!TEST_true(IS_HEX(*p)))
	103	goto err;
	104	}
	105	if (!TEST_true(*p != 0)
	106	\|\| !TEST_strn_eq(expected, p, strlen(expected)))
	107	goto err;
	108
	109	ret = 1;
	110	err:
	111	BIO_free(bio);
	112	return ret;
	113	}
	114	#endif
	115
2de108df DB	116	/* Test that querying the error queue preserves the OS error. */
	117	static int preserves_system_error(void)
	118	{
	119	#if defined(OPENSSL_SYS_WINDOWS)
	120	SetLastError(ERROR_INVALID_FUNCTION);
	121	ERR_get_error();
	122	return TEST_int_eq(GetLastError(), ERROR_INVALID_FUNCTION);
	123	#else
	124	errno = EINVAL;
	125	ERR_get_error();
	126	return TEST_int_eq(errno, EINVAL);
	127	#endif
	128	}
	129
8908d18c RS	130	/* Test that calls to ERR_add_error_[v]data append */
	131	static int vdata_appends(void)
	132	{
	133	const char *data;
	134
9311d0c4	135	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
8908d18c RS	136	ERR_add_error_data(1, "hello ");
8908d18c RS	137	ERR_add_error_data(1, "world");
b13342e9	138	ERR_peek_error_data(&data, NULL);
8908d18c RS	139	return TEST_str_eq(data, "hello world");
	140	}
	141
8648a50a	142	static int raised_error(void)
56c3a135	143	{
b9a75806	144	const char f, data;
56c3a135 RS	145	int l;
56c3a135 RS	146	unsigned long e;
8648a50a RL	147
	148	/*
	149	* When OPENSSL_NO_ERR or OPENSSL_NO_FILENAMES, no file name or line
	150	* number is saved, so no point checking them.
	151	*/
	152	#if !defined(OPENSSL_NO_FILENAMES) && !defined(OPENSSL_NO_ERR)
b9a75806 MC	153	const char *file;
b9a75806 MC	154	int line;
56c3a135	155
add8c8e9	156	file = __FILE__;
b9a75806 MC	157	line = __LINE__ + 2; /* The error is generated on the ERR_raise_data line */
b9a75806 MC	158	#endif
17b7f896	159	ERR_raise_data(ERR_LIB_NONE, ERR_R_INTERNAL_ERROR,
ff988500	160	"calling exit()");
b13342e9	161	if (!TEST_ulong_ne(e = ERR_get_error_all(&f, &l, NULL, &data, NULL), 0)
56c3a135	162	\|\| !TEST_int_eq(ERR_GET_REASON(e), ERR_R_INTERNAL_ERROR)
8648a50a	163	#if !defined(OPENSSL_NO_FILENAMES) && !defined(OPENSSL_NO_ERR)
56c3a135 RS	164	\|\| !TEST_int_eq(l, line)
56c3a135 RS	165	\|\| !TEST_str_eq(f, file)
b9a75806	166	#endif
ff988500	167	\|\| !TEST_str_eq(data, "calling exit()"))
56c3a135 RS	168	return 0;
	169	return 1;
	170	}
	171
c34063d7 MC	172	static int test_marks(void)
	173	{
	174	unsigned long mallocfail, shouldnot;
	175
	176	/* Set an initial error */
	177	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
	178	mallocfail = ERR_peek_last_error();
	179	if (!TEST_ulong_gt(mallocfail, 0))
	180	return 0;
	181
	182	/* Setting and clearing a mark should not affect the error */
	183	if (!TEST_true(ERR_set_mark())
	184	\|\| !TEST_true(ERR_pop_to_mark())
	185	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error())
	186	\|\| !TEST_true(ERR_set_mark())
	187	\|\| !TEST_true(ERR_clear_last_mark())
	188	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
	189	return 0;
	190
	191	/* Test popping errors */
	192	if (!TEST_true(ERR_set_mark()))
	193	return 0;
	194	ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
	195	if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error())
	196	\|\| !TEST_true(ERR_pop_to_mark())
	197	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
	198	return 0;
	199
	200	/* Nested marks should also work */
	201	if (!TEST_true(ERR_set_mark())
	202	\|\| !TEST_true(ERR_set_mark()))
	203	return 0;
	204	ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
	205	if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error())
	206	\|\| !TEST_true(ERR_pop_to_mark())
	207	\|\| !TEST_true(ERR_pop_to_mark())
	208	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
	209	return 0;
	210
	211	if (!TEST_true(ERR_set_mark()))
	212	return 0;
	213	ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	214	shouldnot = ERR_peek_last_error();
	215	if (!TEST_ulong_ne(mallocfail, shouldnot)
	216	\|\| !TEST_true(ERR_set_mark()))
	217	return 0;
	218	ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
	219	if (!TEST_ulong_ne(shouldnot, ERR_peek_last_error())
	220	\|\| !TEST_true(ERR_pop_to_mark())
	221	\|\| !TEST_ulong_eq(shouldnot, ERR_peek_last_error())
	222	\|\| !TEST_true(ERR_pop_to_mark())
	223	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
	224	return 0;
	225
	226	/* Setting and clearing a mark should not affect the errors on the stack */
	227	if (!TEST_true(ERR_set_mark()))
	228	return 0;
	229	ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	230	if (!TEST_true(ERR_clear_last_mark())
	231	\|\| !TEST_ulong_eq(shouldnot, ERR_peek_last_error()))
	232	return 0;
	233
	234	/*
	235	* Popping where no mark has been set should pop everything - but return
236	* a failure result
237	*/
238	if (!TEST_false(ERR_pop_to_mark())
239	\|\| !TEST_ulong_eq(0, ERR_peek_last_error()))
240	return 0;
241
242	/* Clearing where there is no mark should fail */
243	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
244	if (!TEST_false(ERR_clear_last_mark())
245	/* "get" the last error to remove it */
246	\|\| !TEST_ulong_eq(mallocfail, ERR_get_error())
247	\|\| !TEST_ulong_eq(0, ERR_peek_last_error()))
248	return 0;
249
250	/*
251	* Setting a mark where there are no errors in the stack should fail.
252	* NOTE: This is somewhat surprising behaviour but is historically how this
253	* function behaves. In practice we typically set marks without first
254	* checking whether there is anything on the stack - but we also don't
255	* tend to check the success of this function. It turns out to work anyway
256	* because although setting a mark with no errors fails, a subsequent call
257	* to ERR_pop_to_mark() or ERR_clear_last_mark() will do the right thing
258	* anyway (even though they will report a failure result).
259	*/
260	if (!TEST_false(ERR_set_mark()))
261	return 0;
262
263	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
264	if (!TEST_true(ERR_set_mark()))
265	return 0;
266	ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
267	ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
268
269	/* Should be able to "pop" past 2 errors */
270	if (!TEST_true(ERR_pop_to_mark())
271	\|\| !TEST_ulong_eq(mallocfail, ERR_peek_last_error()))
272	return 0;
273
274	if (!TEST_true(ERR_set_mark()))
275	return 0;
276	ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
277	ERR_raise(ERR_LIB_CRYPTO, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
278
279	/* Should be able to "clear" past 2 errors */
280	if (!TEST_true(ERR_clear_last_mark())
281	\|\| !TEST_ulong_eq(shouldnot, ERR_peek_last_error()))
282	return 0;
283
284	/* Clear remaining errors from last test */
285	ERR_clear_error();
286
287	return 1;
288	}
289
5a9dbfc5 P	290	static int test_clear_error(void)
	291	{
	292	int flags = -1;
	293	const char *data = NULL;
	294	int res = 0;
	295
	296	/* Raise an error with data and clear it */
	297	ERR_raise_data(0, 0, "hello %s", "world");
	298	ERR_peek_error_data(&data, &flags);
	299	if (!TEST_str_eq(data, "hello world")
	300	\|\| !TEST_int_eq(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	301	goto err;
	302	ERR_clear_error();
	303
	304	/* Raise a new error without data */
	305	ERR_raise(0, 0);
	306	ERR_peek_error_data(&data, &flags);
	307	if (!TEST_str_eq(data, "")
	308	\|\| !TEST_int_eq(flags, ERR_TXT_MALLOCED))
	309	goto err;
	310	ERR_clear_error();
	311
	312	/* Raise a new error with data */
	313	ERR_raise_data(0, 0, "goodbye %s world", "cruel");
	314	ERR_peek_error_data(&data, &flags);
	315	if (!TEST_str_eq(data, "goodbye cruel world")
	316	\|\| !TEST_int_eq(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	317	goto err;
	318	ERR_clear_error();
	319
	320	/*
	321	* Raise a new error without data to check that the malloced storage
	322	* is freed properly
	323	*/
	324	ERR_raise(0, 0);
	325	ERR_peek_error_data(&data, &flags);
	326	if (!TEST_str_eq(data, "")
	327	\|\| !TEST_int_eq(flags, ERR_TXT_MALLOCED))
	328	goto err;
	329	ERR_clear_error();
	330
	331	res = 1;
	332	err:
	333	ERR_clear_error();
	334	return res;
	335	}
	336
d3bb8fe7 MC	337	/*
	338	* Test saving and restoring error state.
	339	* Test 0: Save using OSSL_ERR_STATE_save()
	340	* Test 1: Save using OSSL_ERR_STATE_save_to_mark()
	341	*/
	342	static int test_save_restore(int idx)
ff0de163 TM	343	{
	344	ERR_STATE *es;
	345	int res = 0, i, flags = -1;
	346	unsigned long mallocfail, interr;
	347	static const char testdata[] = "test data";
	348	const char *data = NULL;
	349
	350	if (!TEST_ptr(es = OSSL_ERR_STATE_new()))
	351	goto err;
	352
	353	ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
	354	mallocfail = ERR_peek_last_error();
	355	if (!TEST_ulong_gt(mallocfail, 0))
	356	goto err;
	357
d3bb8fe7 MC	358	if (idx == 1 && !TEST_int_eq(ERR_set_mark(), 1))
	359	goto err;
	360
ff0de163 TM	361	ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR, testdata);
	362	interr = ERR_peek_last_error();
	363	if (!TEST_ulong_ne(mallocfail, ERR_peek_last_error()))
	364	goto err;
	365
d3bb8fe7 MC	366	if (idx == 0) {
d3bb8fe7 MC	367	OSSL_ERR_STATE_save(es);
ff0de163	368
d3bb8fe7 MC	369	if (!TEST_ulong_eq(ERR_peek_last_error(), 0))
	370	goto err;
	371	} else {
	372	OSSL_ERR_STATE_save_to_mark(es);
	373
	374	if (!TEST_ulong_ne(ERR_peek_last_error(), 0))
	375	goto err;
	376	}
ff0de163 TM	377
	378	for (i = 0; i < 2; i++) {
	379	OSSL_ERR_STATE_restore(es);
	380
	381	if (!TEST_ulong_eq(ERR_peek_last_error(), interr))
	382	goto err;
	383	ERR_peek_last_error_data(&data, &flags);
	384	if (!TEST_str_eq(data, testdata)
	385	\|\| !TEST_int_eq(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	386	goto err;
	387
	388	/* restore again to duplicate the entries */
	389	OSSL_ERR_STATE_restore(es);
	390
	391	/* verify them all */
d3bb8fe7 MC	392	if (idx == 0 \|\| i == 0) {
	393	if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
	394	&data, &flags), mallocfail)
	395	\|\| !TEST_int_ne(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	396	goto err;
	397	}
ff0de163 TM	398
	399	if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
	400	&data, &flags), interr)
	401	\|\| !TEST_str_eq(data, testdata)
	402	\|\| !TEST_int_eq(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	403	goto err;
	404
d3bb8fe7 MC	405	if (idx == 0) {
	406	if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
	407	&data, &flags), mallocfail)
	408	\|\| !TEST_int_ne(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	409	goto err;
	410	}
ff0de163 TM	411
	412	if (!TEST_ulong_eq(ERR_get_error_all(NULL, NULL, NULL,
	413	&data, &flags), interr)
	414	\|\| !TEST_str_eq(data, testdata)
	415	\|\| !TEST_int_eq(flags, ERR_TXT_STRING \| ERR_TXT_MALLOCED))
	416	goto err;
	417
	418	if (!TEST_ulong_eq(ERR_get_error(), 0))
	419	goto err;
	420	}
	421
	422	res = 1;
	423	err:
	424	OSSL_ERR_STATE_free(es);
	425	return res;
	426	}
	427
2de108df DB	428	int setup_tests(void)
	429	{
	430	ADD_TEST(preserves_system_error);
8908d18c	431	ADD_TEST(vdata_appends);
8648a50a	432	ADD_TEST(raised_error);
f32af93c SL	433	#ifndef OPENSSL_NO_DEPRECATED_3_0
	434	ADD_TEST(test_print_error_format);
	435	#endif
c34063d7	436	ADD_TEST(test_marks);
d3bb8fe7	437	ADD_ALL_TESTS(test_save_restore, 2);
5a9dbfc5	438	ADD_TEST(test_clear_error);
2de108df DB	439	return 1;
2de108df DB	440	}