Add BIO_push() and BIO_set_next() regress coverage

This tests for the behavior changes in bio_lib.c r1.40 and r1.41 and
makes sure that BIO_push() and BIO_set_next() act on two chains in the
expected and now documented way.

1 files changed, 367 insertions, 1 deletions

diff --git a/src/regress/lib/libcrypto/bio/biotest.c b/src/regress/lib/libcrypto/bio/biotest.c
index 55daea78fc..7d56448bfa 100644
--- a/src/regress/lib/libcrypto/bio/biotest.c
+++ b/src/regress/lib/libcrypto/bio/biotest.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: biotest.c,v 1.10 2022/12/03 09:53:47 tb Exp $ */
+/*      $OpenBSD: biotest.c,v 1.11 2022/12/08 11:32:27 tb Exp $ */
 /*
  * Copyright (c) 2014, 2022 Joel Sing <jsing@openbsd.org>
  * Copyright (c) 2022 Theo Buehler <tb@openbsd.org>
@@ -598,6 +598,370 @@ do_bio_chain_pop_test(void)
         return failed;
 }
 
+/*
+ * Link two linear chains of BIOs, A[], B[] of length N_CHAIN_BIOS together
+ * using either BIO_push(A[i], B[j]) or BIO_set_next(A[i], B[j]).
+ *
+ * BIO_push() first walks the chain A[] to its end and then appends the tail
+ * of chain B[] starting at B[j]. If j > 0, we get two chains
+ *
+ *     A[0] -- ... -- A[N_CHAIN_BIOS - 1] -- B[j] -- ... -- B[N_CHAIN_BIOS - 1]
+ *
+ *     B[0] -- ... -- B[j-1]
+ *     --- oldhead -->|
+ *
+ * of lengths N_CHAIN_BIOS + N_CHAIN_BIOS - j and j, respectively.
+ * If j == 0, the second chain (oldhead) is empty. One quirk of BIO_push() is
+ * that the outcome of BIO_push(A[i], B[j]) apart from the return value is
+ * independent of i.
+ *
+ * Prior to bio_lib.c r1.41, BIO_push() would keep * BIO_next(B[j-1]) == B[j]
+ * for 0 < j < N_CHAIN_BIOS, and at the same time for all j the inconsistent
+ * BIO_prev(B[j]) == A[N_CHAIN_BIOS - 1].
+ *
+ * The result for BIO_set_next() is different: three chains are created.
+ *
+ *                                 |--- oldtail -->
+ *     ... -- A[i-1] -- A[i] -- A[i+1] -- ...
+ *                         \
+ *                          \  new link created by BIO_set_next()
+ *     --- oldhead -->|      \
+ *          ... -- B[j-1] -- B[j] -- B[j+1] -- ...
+ *
+ * After creating a new link, the new chain has length i + 1 + N_CHAIN_BIOS - j,
+ * oldtail has length N_CHAIN_BIOS - i - 1 and oldhead has length j.
+ *
+ * Prior to bio_lib.c r1.40, BIO_set_next() results in BIO_next(B[j-1]) == B[j],
+ * B[j-1] == BIO_prev(B[j]), A[i] == BIO_prev(A[i+1]) and, in addition,
+ * BIO_next(A[i]) == B[j], thus leaving A[] and B[] in an inconsistent state.
+ *
+ * XXX: Should check that the callback is called on BIO_push() as expected.
+ */
+
+static int
+do_bio_link_chains_at(size_t i, size_t j, int use_bio_push)
+{
+        BIO *A[N_CHAIN_BIOS], *B[N_CHAIN_BIOS];
+        BIO *oldhead_start, *oldhead_end, *oldtail_start, *oldtail_end;
+        BIO *prev, *next;
+        size_t k, length, new_chain_length, oldhead_length, oldtail_length;
+        int failed = 1;
+
+        memset(A, 0, sizeof(A));
+        memset(B, 0, sizeof(A));
+
+        /* Create two linear chains of BIOs. */
+        prev = NULL;
+        for (k = 0; k < N_CHAIN_BIOS; k++) {
+                if ((A[k] = BIO_new(BIO_s_null())) == NULL)
+                        errx(1, "BIO_new");
+                if ((prev = BIO_push(prev, A[k])) == NULL)
+                        errx(1, "BIO_push");
+        }
+        prev = NULL;
+        for (k = 0; k < N_CHAIN_BIOS; k++) {
+                if ((B[k] = BIO_new(BIO_s_null())) == NULL)
+                        errx(1, "BIO_new");
+                if ((prev = BIO_push(prev, B[k])) == NULL)
+                        errx(1, "BIO_push");
+        }
+
+        /*
+         * Set our expectations. ... it's complicated.
+         */
+
+        oldhead_length = j;
+        oldhead_start = B[0];
+        oldhead_end = BIO_prev(B[j]);
+
+        /*
+         * Adjust for edge case where we push B[0] or set next to B[0].
+         * The oldhead chain is then empty.
+         */
+
+        if (j == 0) {
+                if (oldhead_end != NULL) {
+                        fprintf(stderr, "%s: oldhead(B) not empty at start\n",
+                            __func__);
+                        goto err;
+                }
+
+                oldhead_length = 0;
+                oldhead_start = NULL;
+        }
+
+        if (use_bio_push) {
+                new_chain_length = N_CHAIN_BIOS + N_CHAIN_BIOS - j;
+
+                /* oldtail doesn't exist in the BIO_push() case. */
+                oldtail_start = NULL;
+                oldtail_end = NULL;
+                oldtail_length = 0;
+        } else {
+                new_chain_length = i + 1 + N_CHAIN_BIOS - j;
+
+                oldtail_start = BIO_next(A[i]);
+                oldtail_end = A[N_CHAIN_BIOS - 1];
+                oldtail_length = N_CHAIN_BIOS - i - 1;
+
+                /*
+                 * In case we push onto (or set next at) the end of A[],
+                 * the oldtail chain is empty.
+                 */
+                if (i == N_CHAIN_BIOS - 1) {
+                        if (oldtail_start != NULL) {
+                                fprintf(stderr,
+                                    "%s: oldtail(A) not empty at end\n",
+                                    __func__);
+                                goto err;
+                        }
+
+                        oldtail_end = NULL;
+                        oldtail_length = 0;
+                }
+        }
+
+        /*
+         * Now actually push or set next.
+         */
+
+        if (use_bio_push) {
+                if (BIO_push(A[i], B[j]) != A[i]) {
+                        fprintf(stderr,
+                            "%s: BIO_push(A[%zu], B[%zu]) != A[%zu]\n",
+                            __func__, i, j, i);
+                        goto err;
+                }
+        } else {
+                BIO_set_next(A[i], B[j]);
+        }
+
+        /*
+         * Walk the new chain starting at A[0] forward. Check that we reach
+         * B[N_CHAIN_BIOS - 1] and that the new chain's length is as expected.
+         */
+
+        next = A[0];
+        length = 0;
+        do {
+                prev = next;
+                next = BIO_next(prev);
+                length++;
+        } while (next != NULL);
+
+        if (prev != B[N_CHAIN_BIOS - 1]) {
+                fprintf(stderr,
+                    "%s(%zu, %zu, %d): new chain doesn't end in end of B\n",
+                    __func__, i, j, use_bio_push);
+                goto err;
+        }
+
+        if (length != new_chain_length) {
+                fprintf(stderr, "%s(%zu, %zu, %d) unexpected new chain length"
+                    " (walking forward). want %zu, got %zu\n",
+                    __func__, i, j, use_bio_push, new_chain_length, length);
+                goto err;
+        }
+
+        /*
+         * Walk the new chain ending in B[N_CHAIN_BIOS - 1] backward.
+         * Check that we reach A[0] and that its length is what we expect.
+         */
+
+        prev = B[N_CHAIN_BIOS - 1];
+        length = 0;
+        do {
+                next = prev;
+                prev = BIO_prev(next);
+                length++;
+        } while (prev != NULL);
+
+        if (next != A[0]) {
+                fprintf(stderr,
+                    "%s(%zu, %zu, %d): new chain doesn't start at start of A\n",
+                    __func__, i, j, use_bio_push);
+                goto err;
+        }
+
+        if (length != new_chain_length) {
+                fprintf(stderr, "%s(%zu, %zu, %d) unexpected new chain length"
+                    " (walking backward). want %zu, got %zu\n",
+                    __func__, i, j, use_bio_push, new_chain_length, length);
+                goto err;
+        }
+
+        if (oldhead_start != NULL) {
+
+                /*
+                 * Walk the old head forward and check its length.
+                 */
+
+                next = oldhead_start;
+                length = 0;
+                do {
+                        prev = next;
+                        next = BIO_next(prev);
+                        length++;
+                } while (next != NULL);
+
+                if (prev != oldhead_end) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d): unexpected old head end\n",
+                            __func__, i, j, use_bio_push);
+                        goto err;
+                }
+
+                if (length != oldhead_length) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d) unexpected old head length"
+                            " (walking forward). want %zu, got %zu\n",
+                            __func__, i, j, use_bio_push,
+                            oldhead_length, length);
+                        goto err;
+                }
+
+                /*
+                 * Walk the old head backward and check its length.
+                 */
+
+                prev = oldhead_end;
+                length = 0;
+                do {
+                        next = prev;
+                        prev = BIO_prev(next);
+                        length++;
+                } while (prev != NULL);
+
+                if (next != oldhead_start) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d): unexpected old head start\n",
+                            __func__, i, j, use_bio_push);
+                        goto err;
+                }
+
+                if (length != oldhead_length) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d) unexpected old head length"
+                            " (walking backward). want %zu, got %zu\n",
+                            __func__, i, j, use_bio_push,
+                            oldhead_length, length);
+                        goto err;
+                }
+        }
+
+        if (oldtail_start != NULL) {
+
+                /*
+                 * Walk the old tail forward and check its length.
+                 */
+
+                next = oldtail_start;
+                length = 0;
+                do {
+                        prev = next;
+                        next = BIO_next(prev);
+                        length++;
+                } while (next != NULL);
+
+                if (prev != oldtail_end) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d): unexpected old tail end\n",
+                            __func__, i, j, use_bio_push);
+                        goto err;
+                }
+
+                if (length != oldtail_length) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d) unexpected old tail length"
+                            " (walking forward). want %zu, got %zu\n",
+                            __func__, i, j, use_bio_push,
+                            oldtail_length, length);
+                        goto err;
+                }
+
+                /*
+                 * Walk the old tail backward and check its length.
+                 */
+
+                prev = oldtail_end;
+                length = 0;
+                do {
+                        next = prev;
+                        prev = BIO_prev(next);
+                        length++;
+                } while (prev != NULL);
+
+                if (next != oldtail_start) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d): unexpected old tail start\n",
+                            __func__, i, j, use_bio_push);
+                        goto err;
+                }
+
+                if (length != oldtail_length) {
+                        fprintf(stderr,
+                            "%s(%zu, %zu, %d) unexpected old tail length"
+                            " (walking backward). want %zu, got %zu\n",
+                            __func__, i, j, use_bio_push,
+                            oldtail_length, length);
+                        goto err;
+                }
+        }
+
+        /*
+         * All sanity checks passed. We can now free the our chains
+         * with the BIO API without risk of leaks or double frees.
+         */
+
+        BIO_free_all(A[0]);
+        BIO_free_all(oldhead_start);
+        BIO_free_all(oldtail_start);
+
+        memset(A, 0, sizeof(A));
+        memset(B, 0, sizeof(B));
+
+        failed = 0;
+
+ err:
+        for (i = 0; i < N_CHAIN_BIOS; i++)
+                BIO_free(A[i]);
+        for (i = 0; i < N_CHAIN_BIOS; i++)
+                BIO_free(B[i]);
+
+        return failed;
+}
+
+static int
+do_bio_link_chains(int use_bio_push)
+{
+        size_t i, j;
+        int failure = 0;
+
+        for (i = 0; i < N_CHAIN_BIOS; i++) {
+                for (j = 0; j < N_CHAIN_BIOS; j++) {
+                        failure |= do_bio_link_chains_at(i, j, use_bio_push);
+                }
+        }
+
+        return failure;
+}
+
+static int
+do_bio_push_link_test(void)
+{
+        int use_bio_push = 1;
+
+        return do_bio_link_chains(use_bio_push);
+}
+
+static int
+do_bio_set_next_link_test(void)
+{
+        int use_bio_push = 0;
+
+        return do_bio_link_chains(use_bio_push);
+}
+
 int
 main(int argc, char **argv)
 {
@@ -607,6 +971,8 @@ main(int argc, char **argv)
         ret |= do_bio_get_port_tests();
         ret |= do_bio_mem_tests();
         ret |= do_bio_chain_pop_test();
+        ret |= do_bio_push_link_test();
+        ret |= do_bio_set_next_link_test();
 
         return (ret);
 }