unit_test_bio.c

Go to the documentation of this file.

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
/**
 * $Id: 0ede88e8267d5cdd479c4a9d37acb24be94dabbb $
 *
 * @file unit_test_bio.c
 * @brief TLS server test framework, using the TLS bio
 *
 * This program loads the "tls" protocol and reads two top-level sections
 * from unit_test_tls.conf.  The "tls" section supplies the TLS server
 * context, and takes exactly the items that a TLS configuration takes
 * anywhere else in the server.  The "unit_test_tls" section supplies what
 * steers the test program itself, which is the address of the listening TCP
 * socket and whether a client certificate is required.
 *
 * One connection is accepted, and the TLS handshake for that connection is
 * run to completion.
 *
 * This program is unit_test_tls.c reworked to use the TLS bio in
 * src/lib/bio/tls.c.  The program opens the sockets as fd bios, and the
 * TLS bio runs everything else for a connection: the connect, the handshake,
 * the IO, and the policies.  The program supplies the request, the
 * interpreter, and two callbacks, `connected` and `failed`.  The section is
 * still called "unit_test_tls", so the configuration files of unit_test_tls
 * work here too.  Setting `drop_datagram` is an error, as the TLS bio does
 * not offer a place to drop a datagram.
 *
 * The handshake runs on a persistent asynchronous interpreter, the same way
 * radiusd runs one.  A persistent interpreter keeps the handshake state
 * across the several rounds of a single connection.
 *
 * The "virtual_server" item in the "tls" section names a virtual server.
 * That virtual server supplies the "verify certificate", "load session",
 * "store session" and "clear session" sections which the handshake calls.
 *
 * To run the test, start unit_test_tls with the test configuration, then
 * connect to the listening socket:
 *
 * @code
 * ./scripts/bin/unit_test_tls -d src/tests/tls -X
 *
 * openssl s_client -connect 127.0.0.1:2083 \
 *         -cert raddb/certs/rsa/client.pem \
 *         -key raddb/certs/rsa/client.key -pass pass:whatever \
 *         -CAfile raddb/certs/rsa/ca.pem
 * @endcode
 *
 * src/tests/tls/unit_test_tls.conf documents every configuration item.
 *
 * @copyright 2025 The FreeRADIUS server project
 */
RCSID("$Id: 0ede88e8267d5cdd479c4a9d37acb24be94dabbb $")
 
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
 
#include <freeradius-devel/io/listen.h>
#include <freeradius-devel/io/thread.h>
 
#include <freeradius-devel/tls/base.h>
#include <freeradius-devel/tls/dtls.h>
#include <freeradius-devel/tls/strerror.h>
#include <freeradius-devel/tls/version.h>
#include <freeradius-devel/tls/connection.h>
#include <freeradius-devel/bio/base.h>
#include <freeradius-devel/bio/fd.h>
#include <freeradius-devel/bio/tls.h>
#include <freeradius-devel/util/misc.h>
 
#include <freeradius-devel/unlang/base.h>
#include <freeradius-devel/unlang/function.h>
#include <freeradius-devel/unlang/interpret.h>
 
#include <freeradius-devel/util/socket.h>
 
#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
 
#ifdef HAVE_GETOPT_H
#  include <getopt.h>
#endif
 
#include <sys/wait.h>
 
#define EXIT_WITH_FAILURE \
do { \
        ret = EXIT_FAILURE; \
        goto cleanup; \
} while (0)
 
char const *radiusd_version = RADIUSD_VERSION_BUILD("unit_test_bio");
 
static fr_dict_t const *dict_freeradius;
static fr_dict_t const *dict_tls;
 
extern fr_dict_autoload_t unit_test_bio_dict[];
fr_dict_autoload_t unit_test_bio_dict[] = {
        { .out = &dict_freeradius, .proto = "freeradius" },
        { .out = &dict_tls, .proto = "tls" },
        DICT_AUTOLOAD_TERMINATOR
};
 
/** The "unit_test_tls" section
 *
 * The items at the top level steer the test program and do not configure
 * TLS.  The TLS configuration for each role is a subsection.
 * `fr_tls_server_config` and `fr_tls_client_config` parse the subsections,
 * so each subsection takes exactly the items that a `tls { ... }` section
 * takes anywhere else in the server.
 */
/** One transport's socket, named by `transport` in the configuration
 *
 */
typedef struct {
        fr_ipaddr_t     ipaddr;                         //!< Address of the listening socket.
        uint16_t        port;                           //!< Port of the listening socket.
} unit_test_bio_socket_t;
 
typedef struct {
        char const      *transport;                     //!< "tcp" or "udp", naming the subsection below
                                                        ///< which holds the socket.
        int             socket_type;                    //!< SOCK_STREAM or SOCK_DGRAM, from `transport`.
 
        unit_test_bio_socket_t  tcp;                    //!< The `tcp { ... }` subsection.
        unit_test_bio_socket_t  udp;                    //!< The `udp { ... }` subsection.
 
        fr_ipaddr_t     ipaddr;                         //!< Address of the listening socket, copied from
                                                        ///< whichever subsection `transport` named.
        uint16_t        port;                           //!< Port of the listening socket, and the default
                                                        ///< port for -s.
        uint32_t        drop_datagram;                  //!< Drop this datagram rather than sending it,
                                                        ///< counting from one.  Zero drops nothing.
        bool            require_client_certificate;     //!< Whether the client has to present a certificate.
 
        fr_tls_conf_t   *server;                        //!< The `server { ... }` subsection.
        fr_tls_conf_t   *client;                        //!< The `client { ... }` subsection, used with `-s`.
} unit_test_bio_conf_t;
 
/** The socket items, parsed once per transport subsection
 *
 */
static const conf_parser_t unit_test_bio_socket_config[] = {
        { FR_CONF_OFFSET_TYPE_FLAGS("ipaddr", FR_TYPE_COMBO_IP_ADDR, 0, unit_test_bio_socket_t, ipaddr) },
        { FR_CONF_OFFSET_TYPE_FLAGS("ipv4addr", FR_TYPE_IPV4_ADDR, 0, unit_test_bio_socket_t, ipaddr) },
        { FR_CONF_OFFSET_TYPE_FLAGS("ipv6addr", FR_TYPE_IPV6_ADDR, 0, unit_test_bio_socket_t, ipaddr) },
 
        { FR_CONF_OFFSET("port", unit_test_bio_socket_t, port) },
 
        CONF_PARSER_TERMINATOR
};
 
static const conf_parser_t unit_test_bio_config[] = {
        /*
         *      `transport` names a subsection, the way a listener's
         *      `transport` does, see common_transport_parse() in
         *      src/lib/bio/fd_config.c.  The socket items live in that
         *      subsection rather than here, so that a configuration which
         *      names one transport cannot carry another one's settings.
         */
        { FR_CONF_OFFSET("transport", unit_test_bio_conf_t, transport), .dflt = "tcp" },
 
        { FR_CONF_OFFSET_SUBSECTION("tcp", CONF_FLAG_OK_MISSING, unit_test_bio_conf_t, tcp,
                                    unit_test_bio_socket_config) },
        { FR_CONF_OFFSET_SUBSECTION("udp", CONF_FLAG_OK_MISSING, unit_test_bio_conf_t, udp,
                                    unit_test_bio_socket_config) },
 
        /*
         *      Lose a datagram on purpose, so that a test can see the
         *      retransmission which recovers from it.  Zero loses nothing.
         */
        { FR_CONF_OFFSET("drop_datagram", unit_test_bio_conf_t, drop_datagram) },
 
        { FR_CONF_OFFSET("require_client_certificate", unit_test_bio_conf_t, require_client_certificate),
          .dflt = "no" },
 
        /*
         *      A test file may hold only the role that the test runs, so
         *      either subsection may be missing.
         */
        { FR_CONF_SUBSECTION_ALLOC("server", CONF_FLAG_OK_MISSING, unit_test_bio_conf_t, server, fr_tls_server_config),
          .subcs_type = "fr_tls_conf_t" },
        { FR_CONF_SUBSECTION_ALLOC("client", CONF_FLAG_OK_MISSING, unit_test_bio_conf_t, client, fr_tls_client_config),
          .subcs_type = "fr_tls_conf_t" },
 
        CONF_PARSER_TERMINATOR
};
 
/** State of the test program
 *
 * The interpreter and the runnable heap live for the whole of the connection.
 * A TLS handshake takes several rounds, and each round may yield while a
 * virtual server section runs.  The interpreter and the runnable heap
 * therefore cannot be allocated once per round.
 */
typedef struct {
        fr_event_list_t         *el;                    //!< Event list everything runs on.
        unlang_interpret_t      *intp;                  //!< Interpreter for the connection.
        fr_heap_t               *runnable;              //!< Requests the interpreter has marked runnable.
        int                     yielded;                //!< How many requests are currently yielded.
 
        unit_test_bio_conf_t    conf;                   //!< Parsed "unit_test_tls" section.
        SSL_CTX                 *ssl_ctx;               //!< Context built from the "tls" section.
 
        fr_bio_t                *listen_bio;            //!< Listening fd bio.
        fr_bio_fd_config_t      listen_cfg;             //!< Config of `listen_bio`.  The bio keeps the pointer.
        fr_bio_t                *fd_bio;                //!< The fd bio of the connection being run.
        fr_bio_fd_config_t      fd_cfg;                 //!< Config of `fd_bio`.  The bio keeps the pointer.
        fr_bio_tls_t            *bio;                   //!< The TLS bio of the connection being run.
        fr_tls_connection_t     *conn;                  //!< The connection of `bio`.  The hooks of this
                                                        ///< program read this connection.
        request_t               *request;               //!< The request the connection runs under.
 
 
        unsigned int            count;                  //!< How many connections to run.
        bool                    alert;                  //!< Reject the peer with a TLS alert, see -A.
        bool                    invalid;                //!< Mark the session invalid mid-handshake, see -I.
        bool                    nonblock;               //!< Put the connection socket in non-blocking mode, see -B.
        bool                    client;                 //!< Act as the client and connect to a server,
                                                        ///< rather than accept a connection.  Copied into
                                                        ///< every connection this program allocates.
 
        bool                    app_data;               //!< Send one byte of application data once the
                                                        ///< handshake is done, see -P.
 
        bool                    hold;                   //!< Once connected, send nothing and stay
                                                        ///< connected, see -H.
 
        bool                    reject;                 //!< Reject the session once the handshake
                                                        ///< succeeds, see -R.
        bool                    network_fail;           //!< Fail the session with a network error once
                                                        ///< the handshake succeeds, see -N.
        bool                    abort_pending;          //!< Free the connection once the handshake
                                                        ///< succeeds, while `store session` is still
                                                        ///< queued, see -Q.
        unsigned int            connections;            //!< How many connections have been run so far.
        fr_ipaddr_t             server_ipaddr;          //!< Server named by -s.
        uint16_t                server_port;            //!< Port from -s, or from the configuration.
 
        int                     sockfd;                 //!< Listening socket.
        fr_event_fd_t           *accept_ef;             //!< Read event for sockfd, while waiting in
                                                        ///< tls_socket_accept().
        bool                    accepting;              //!< Waiting in tls_socket_accept().
 
        char const              *command;               //!< Command to run, see -e.
        pid_t                   command_pid;            //!< Command started by -e, or 0.
        fr_event_pid_t const    *command_ev;            //!< Waits for the command to exit.
        bool                    command_exited;         //!< The command has exited.
        bool                    command_waiting;        //!< Waiting in tls_command_wait().
 
        int                     fd;                     //!< Accepted or connected socket.
 
        uint8_t                 *first;                 //!< The datagram which named the peer, read from
                                                        ///< the listening socket before the connection's
                                                        ///< socket existed.  Handed to the connection once
                                                        ///< the connection is running.
        size_t                  first_len;              //!< Length of `first`.
        unsigned char           *alpn;                  //!< Protocol list built by -L, in the wire format
                                                        ///< fr_tls_conf_t expects.  NULL means no ALPN.
        bool                    alpn_required;          //!< Set by -l.
 
        bool                    connected;              //!< The `connected` callback has run.
        bool                    done;                   //!< Set once the connection has a result.
        int                     ret;                    //!< Exit status.
} unit_test_bio_t;
 
static void usage(main_config_t const *config, int status);
static void tls_request_failed(unit_test_bio_t *utt);
 
/*
 *      Interpreter callbacks.
 *
 *      The callbacks below mirror the set in
 *      src/lib/unlang/interpret_synchronous.c and src/lib/io/coord_pair.c.  The
 *      one difference is that a post-event handler drains the runnable heap,
 *      rather than a loop inside the caller, so the event loop decides when
 *      each request runs.
 */
 
/** Schedule a request, once
 *
 * A request reaches the heap from two directions: the interpreter creating it,
 * and the interpreter marking it runnable again.  Inserting a request which is
 * already on the heap puts it there twice, and popping it then returns a
 * request which the heap still holds, which the interpreter refuses to run.
 */
static void tls_runnable_insert(unit_test_bio_t *utt, request_t *request)
{
        if (fr_heap_entry_inserted(request->runnable)) return;
 
        fr_heap_insert(&utt->runnable, request);
}
 
/** An internal request created by the interpreter has to run on ours
 *
 * The subrequests created for the "verify certificate" section and for the
 * session cache sections reach this callback.
 *
 * fr_tls_call_push() pushes each of them as a detachable subrequest, which
 * the parent waits on rather than running inline, so the subrequest has to be
 * scheduled here or nothing ever runs it.
 */
static void _request_init_internal(request_t *request, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        RDEBUG3("Initialising internal request");
 
        unlang_interpret_set(request, utt->intp);
 
        /*
         *      interpret_child_init() calls this, and nothing else schedules
         *      the child, so a subrequest which is not put on the heap here
         *      never runs at all.
         */
        tls_runnable_insert(utt, request);
}
 
static void _request_done_external(request_t *request, UNUSED rlm_rcode_t rcode, UNUSED void *uctx)
{
        RDEBUG3("Done external request");
 
        /*
         *      main() allocated the request, and the request has to survive
         *      until the connection is done with, so this callback does not
         *      free the request.
         */
}
 
static void _request_done_internal(request_t *request, UNUSED rlm_rcode_t rcode, UNUSED void *uctx)
{
        RDEBUG3("Done internal request");
 
        /* The code which created the internal request frees the request */
}
 
static void _request_done_detached(request_t *request, UNUSED rlm_rcode_t rcode, UNUSED void *uctx)
{
        RDEBUG3("Done detached request");
 
        /*
         *      Nothing else can free a detached request, so this callback
         *      frees the detached request.
         */
        talloc_free(request);
}
 
static void _request_detach(request_t *request, UNUSED void *uctx)
{
        RDEBUG3("Request detached");
 
        if (request_detach(request) < 0) RPEDEBUG("Failed detaching request");
}
 
static void _request_yield(request_t *request, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        utt->yielded++;
 
        RDEBUG3("Request yielded");
}
 
static void _request_resume(request_t *request, UNUSED void *uctx)
{
        RDEBUG3("Request resumed");
}
 
static void _request_runnable(request_t *request, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        fr_assert(utt->yielded > 0);
        utt->yielded--;
 
        tls_runnable_insert(utt, request);
}
 
static bool _request_scheduled(request_t const *request, UNUSED void *uctx)
{
        return fr_heap_entry_inserted(request->runnable);
}
 
/** Stop the event loop, recording why
 *
 * The connection carries the result, so the exit status is decided here
 * rather than by the TLS bio.
 */
static void tls_done(unit_test_bio_t *utt)
{
        if (utt->done) return;
 
        utt->done = true;
        /*
         *      With -H the peer ends a connection which was already up, and the end is
         *      not a failure.
         */
        utt->ret = (utt->conn && utt->conn->failed && !(utt->hold && utt->connected)) ? EXIT_FAILURE : EXIT_SUCCESS;
 
        fr_event_loop_exit(utt->el, 1);
}
 
/** The TLS bio says the connection failed, at any point
 *
 */
static void tls_bio_failed(fr_bio_t *bio)
{
        unit_test_bio_t *utt = talloc_get_type_abort(bio->uctx, unit_test_bio_t);
 
        tls_done(utt);
}
 
/** Record a failure this program cannot recover from, and stop
 *
 * tls_done() reads the result from the connection, so a failure has to reach
 * the connection before the program stops.
 */
static void tls_request_failed(unit_test_bio_t *utt)
{
        if (utt->conn) utt->conn->failed = TLS_CONNECTION_FAIL_APPLICATION;
        tls_done(utt);
}
 
/** Something happened on a connection which -H holds open
 *
 * The TLS bio removed its fd events when the connection connected, so the
 * program watches the fd itself.  Reading the bio is how the program learns
 * that the peer has gone.
 */
static void _tls_hold_read(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
        uint8_t         buffer[256];
        ssize_t         slen;
 
        do {
                slen = fr_bio_read((fr_bio_t *) utt->bio, NULL, buffer, sizeof(buffer));
        } while (slen > 0);
 
        if (slen == fr_bio_error(IO_WOULD_BLOCK)) return;
 
        if ((slen < 0) || fr_bio_fd_info(utt->fd_bio)->eof) {
                DEBUG2("The peer ended the held connection");
                tls_done(utt);
        }
}
 
static void _tls_hold_error(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags,
                            UNUSED int fd_errno, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        DEBUG2("The held connection failed");
        tls_done(utt);
}
 
/** The connection is up, and can carry application data
 *
 * The TLS bio removed its fd events before calling this function.  A program
 * which had data to send would send it with fr_bio_write(), and close when it
 * was done.
 */
static void tls_bio_connected(fr_bio_t *bio)
{
        unit_test_bio_t *utt = talloc_get_type_abort(bio->uctx, unit_test_bio_t);
 
        DEBUG2("Connection is up and can carry application data");
 
        /*
         *      Send one byte of application data, which tells the peer that
         *      every session ticket we were going to send has already gone.
         *      The connection only reaches TLS_CONNECTION_CONNECTED when every
         *      ticket section has run.
         */
        if (utt->app_data && !utt->client) {
                uint8_t zero = 0x00;
 
                if (fr_bio_write(bio, NULL, &zero, sizeof(zero)) != (ssize_t) sizeof(zero)) {
                        PERROR("Failed sending the application data");
                        tls_request_failed(utt);
                        return;
                }
 
                DEBUG("Sent one byte of application data");
        }
 
        /*
         *      -H holds the connection open with nothing more to say.  A
         *      peer which is still owed a session ticket or a byte of
         *      application data then waits for something which never
         *      arrives, which is what the post-handshake timer is for.
         *
         *      The connection still ends: the peer gives up, closes, and
         *      the TLS bio fails the connection when it sees EOF.
         */
        utt->connected = true;
 
        if (utt->hold) {
                DEBUG("Holding the connection open, sending nothing");
 
                if (fr_event_fd_insert(utt, NULL, utt->el, utt->fd, _tls_hold_read, NULL, _tls_hold_error, utt) < 0) {
                        PERROR("Failed watching the held connection");
                        tls_request_failed(utt);
                }
                return;
        }
 
        tls_done(utt);
}
 
/** Drain the runnable heap once per pass of the event loop
 *
 * A handshake round yields whenever the round runs a virtual server section.
 * When that section finishes, unlang_interpret_mark_runnable() puts the
 * request on the runnable heap, and this drains the heap again.
 */
static void _tls_runnable(UNUSED fr_event_list_t *el, UNUSED fr_time_t now, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
        request_t       *request;
 
        /*
         *      Stand in for an application which rejects a peer outright.
         *
         *      `pending` says a record has arrived and the handshake has not
         *      read it yet.  This hook used to live in _tls_connection_read(),
         *      where its position said the same thing, and the comment there
         *      warned that raising the alert before a record arrives sends it
         *      into an empty handshake, where it is lost.  The test cannot
         *      tell: removing this test passes six suite runs out of six,
         *      because a server runs no handshake round until a record
         *      arrives.  A client runs one straight away, so keep the test.
         *
         *      Raising the alert later, with the other two hooks below, is
         *      too late.  Those run after the round, and the round which
         *      would have carried the alert has gone.
         */
        /*
         *      Stand in for a record which FreeRADIUS itself refuses.
         *
         *      fr_tls_session_msg_cb() marks such a session invalid and
         *      lets the round finish.  The round after that refuses to
         *      continue, records FR_ERROR_VALUE_SESSION_INVALID, and sends
         *      the peer a fatal alert.  Setting the flag here reaches that
         *      second round without having to feed the handshake a
         *      malformed record.
         *
         *      `pending` places this before a round, for the same reason
         *      the alert hook below is placed there.
         */
        if (utt->invalid && utt->conn->tls_session && utt->conn->pending &&
            (utt->connections == utt->count)) {
                utt->invalid = false;
                utt->conn->tls_session->invalid = true;
        }
 
        if (utt->alert && utt->conn->tls_session && utt->conn->pending &&
            (utt->connections == utt->count)) {
                utt->alert = false;
 
                if (fr_tls_session_alert(utt->conn->request, utt->conn->tls_session,
                                         SSL3_AL_FATAL, SSL_AD_ACCESS_DENIED) < 0) {
                        ERROR("Failed raising the TLS alert");
                        tls_request_failed(utt);
                        return;
                }
        }
 
        while (fr_heap_pop((void **)&request, &utt->runnable) == 0) {
                if (!request) break;
 
                (void) unlang_interpret(request, UNLANG_REQUEST_RESUME);
 
                /*
                 *      Only the connection's own request advances the
                 *      handshake.  A subrequest returns the subrequest's
                 *      result through the interpreter.
                 *
                 *      The connection's own IO is not done here any more.
                 *      tls_connection_frame_process() does it, inside
                 *      src/lib/tls, at the point the connection is about to
                 *      wait for the peer.  A real listener has no hook here,
                 *      so nothing which a real listener cannot do belongs
                 *      here either.
                 */
                if (request == utt->conn->request) {
                        /*
                         *      Stand in for an application which rejects a
                         *      session after the handshake succeeded.  The
                         *      handshake has finished, so OpenSSL has asked
                         *      for the session to be cached, and the
                         *      connection is about to run its cache
                         *      operations.  Failing it here makes those
                         *      operations a deny and a clear rather than a
                         *      store, which is what rlm_eap_tls does when
                         *      policy rejects.
                         */
                        if ((utt->reject || utt->network_fail) && (utt->connections == utt->count) &&
                            fr_tls_session_is_init_finished(utt->conn->tls_session)) {
                                INFO("%s the session after a successful handshake",
                                     utt->network_fail ? "Failing, with a network error," : "Rejecting");
 
                                /*
                                 *      Record the reason, and nothing else.
                                 *      The handshake has finished, so OpenSSL
                                 *      has asked for the session to be cached,
                                 *      and the connection frame is about to run
                                 *      that cache work.  The frame reads
                                 *      `failed` to decide whether the work is a
                                 *      store or a deny and a clear, which is
                                 *      what rlm_eap_tls does when policy
                                 *      rejects.
                                 *
                                 *      fr_tls_connection_failed() would instead
                                 *      report the connection finished here, and
                                 *      the queued cache work would never be
                                 *      drained.  src/lib/tls/session.c asserts
                                 *      on exactly that.
                                 */
                                utt->conn->failed = utt->network_fail ? TLS_CONNECTION_FAIL_SYSCALL :
                                                                        TLS_CONNECTION_FAIL_APPLICATION;
                        }
 
                        /*
                         *      Free the connection while `store session` is
                         *      still queued.  The handshake has finished, so
                         *      OpenSSL has asked for the session to be cached
                         *      and the connection is about to run that work,
                         *      but it has not run yet.  Closing now frees the
                         *      session with the operation still pending, which
                         *      is the path session.c used to assert on and now
                         *      discards.  This is deterministic: it does not
                         *      depend on when the peer closes.
                         */
                        if (utt->abort_pending && (utt->connections == utt->count) &&
                            fr_tls_session_is_init_finished(utt->conn->tls_session)) {
                                INFO("Aborting the connection with cache operations still queued");
                                tls_done(utt);
                                return;
                        }
                }
 
                if (utt->done) return;
        }
}
 
/** Open the listening socket described by the "unit_test_tls" section
 *
 * The listening socket is an fd bio for both transports.  fr_bio_fd_accept()
 * accepts a stream connection, or takes the first datagram of a peer as a
 * connection, see tls_socket_accept_one().
 */
static int tls_socket_open(unit_test_bio_t *utt)
{
        fr_ipaddr_t     ipaddr = utt->conf.ipaddr;
        uint16_t        port = utt->conf.port;
        bool            dgram = (utt->conf.socket_type == SOCK_DGRAM);
 
        /*
         *      The items are not marked as required, because a client has no
         *      listening socket, and so needs neither of them.
         */
        if ((ipaddr.af == AF_UNSPEC) || !port) {
                ERROR("Both 'ipaddr' and 'port' must be set in the 'unit_test_tls' section "
                      "when listening for a connection");
                return -1;
        }
 
        utt->listen_cfg = (fr_bio_fd_config_t) {
                .type = FR_BIO_FD_LISTEN,
                .socket_type = utt->conf.socket_type,
                .transport = dgram ? "udp" : "tcp",
                .transport_type = dgram ? FR_BIO_FD_TRANSPORT_UDP : FR_BIO_FD_TRANSPORT_TCP,
                .server = true,
                .src_ipaddr = ipaddr,
                .src_port = port,
                .backlog = 8,
                .backlog_is_set = true,
                .reuse_port = dgram,            /* the connection's socket shares the port */
                .async = true,                  /* so that accepting does not block */
        };
 
        utt->listen_bio = fr_bio_fd_alloc(utt, &utt->listen_cfg, 0);
        if (!utt->listen_bio) {
                PERROR("Failed opening %s socket", utt->conf.transport);
                return -1;
        }
 
        utt->sockfd = fr_bio_fd_info(utt->listen_bio)->socket.fd;
 
        INFO("Listening on %pV port %u using %s", fr_box_ipaddr(ipaddr), port, utt->conf.transport);
        return 0;
}
 
/** Accept a connection, if the listening socket has one queued
 *
 * @return
 *      - 1 if a connection was accepted.
 *      - 0 if no connection is queued.
 *      - -1 on error.
 */
static int tls_socket_accept_one(unit_test_bio_t *utt)
{
        int fd, rcode;
 
        /*
         *      A datagram socket is not listening, so there is nothing to
         *      accept.  The first ClientHello names the peer, and the
         *      connection runs on a second socket which is connect()ed to
         *      that peer: the kernel then delivers that peer's datagrams to
         *      the connected socket in preference to this one, and read()
         *      and write() work as they do on a stream.
         *
         *      The connection cannot run on this socket.  connect() is a
         *      property of the socket rather than of the descriptor, so
         *      connecting this one, or any descriptor duplicated from it,
         *      would leave the listening socket bound to one peer for the
         *      rest of the program.
         */
        if (utt->conf.socket_type == SOCK_DGRAM) {
                uint8_t         buf[FR_TLS_MAX_PACKET_SIZE];
                ssize_t         slen;
 
                /*
                 *      fr_bio_fd_accept() takes the first datagram of a peer as a connection: it opens
                 *      a socket which is connect()ed to that peer, and the kernel then delivers that
                 *      peer's datagrams to the connected socket in preference to the listening socket.
                 *      The datagram which named the peer is no longer in the socket, and the first read
                 *      of the new bio returns the datagram.  The program reads the datagram now,
                 *      because the datagram decides whether there is a connection at all.
                 *
                 *      It is given to the connection once the connection is running, see
                 *      _tls_connection_start().
                 */
                for (;;) {
                        int accepted = fr_bio_fd_accept(utt, &utt->fd_bio, utt->listen_bio);
 
                        if (accepted == 0) return 0;
 
                        if (accepted < 0) {
                                PERROR("Failed accepting the first datagram");
                                return -1;
                        }
 
                        slen = fr_bio_read(utt->fd_bio, NULL, buf, sizeof(buf));
                        if (slen < 0) {
                                PERROR("Failed reading the first datagram");
                                TALLOC_FREE(utt->fd_bio);
                                return -1;
                        }
 
                        /*
                         *      Filter input packets by ClientHello.
                         *
                         *      Even if we connect() sockets, the connected socket could go away.  Packets for
                         *      that (old) socket are then received by the original accept socket.  We don't
                         *      know what to do with them, as the DTLS session goes away when the socket goes
                         *      away.
                         *
                         *      The main accept socket doesn't read its FD while the DTLS session is
                         *      running, so packets might pile up here.  This is only a problem for
                         *      unit_test_bio, as a real server would keep reading the accept socket.
                         *
                         *      A server which takes one of those old datagrams as a new connection request
                         *      will try to start a connection to a peer which has already gone.  The real
                         *      peer's handshake stays queued here, and the handshake never completes.
                         *
                         *      The solution (hack) is to just discard anything that doesn't look like a
                         *      ClientHello.
                         *
                         *      A ClientHello is a handshake record in epoch 0 whose first message is a
                         *      client_hello.  RFC 6347 Section 4.1 gives the record header, which is
                         *      DTLS1_RT_HEADER_LENGTH octets of type, version, epoch, sequence number, and
                         *      length.  Section 4.3.2 gives the handshake message types.  A discarded
                         *      datagram looks to the peer like a lost datagram, and the peer retransmits, see
                         *      Section 4.2.4.
                         */
                        if ((slen > (ssize_t) DTLS1_RT_HEADER_LENGTH) &&
                            (buf[0] == SSL3_RT_HANDSHAKE) &&
                            (buf[3] == 0) && (buf[4] == 0) &&
                            (buf[DTLS1_RT_HEADER_LENGTH] == SSL3_MT_CLIENT_HELLO)) break;
 
                        DEBUG2("Discarding a %zd byte datagram which does not start a connection", slen);
                        TALLOC_FREE(utt->fd_bio);
                }
 
                MEM(utt->first = talloc_memdup(utt, buf, (size_t) slen));
                utt->first_len = (size_t) slen;
 
                utt->fd = fr_bio_fd_info(utt->fd_bio)->socket.fd;
 
                return 1;
        }
 
        rcode = fr_bio_fd_accept(utt, &utt->fd_bio, utt->listen_bio);
        if (rcode == 0) return 0;
 
        if (rcode < 0) {
                PERROR("Failed accepting connection");
                return -1;
        }
 
        fd = fr_bio_fd_info(utt->fd_bio)->socket.fd;
 
        /*
         *      Some systems give the accepted socket the O_NONBLOCK flag of
         *      the listening socket, and some don't.  Set the flag to what
         *      -B asks for.
         */
        if (utt->nonblock ? (fr_nonblock(fd) < 0) : (fr_blocking(fd) < 0)) {
                PERROR("Failed setting the connection socket mode");
                TALLOC_FREE(utt->fd_bio);
                return -1;
        }
 
        utt->fd = fd;
 
        return 1;
}
 
/** Accept the connection once the listening socket is readable
 *
 */
static void _tls_socket_accept(fr_event_list_t *el, UNUSED int fd, UNUSED int flags, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        if (tls_socket_accept_one(utt) == 0) return;
 
        fr_event_loop_exit(el, 1);
}
 
/** Stop waiting for a connection if the listening socket fails
 *
 */
static void _tls_socket_error(fr_event_list_t *el, UNUSED int fd, UNUSED int flags, int fd_errno, UNUSED void *uctx)
{
        ERROR("Listening socket failed: %s", fr_syserror(fd_errno));
 
        fr_event_loop_exit(el, 1);
}
 
/** Start waiting for a connection, from inside the event loop
 *
 * See tls_connection_run() for why this runs from inside the event loop.
 */
static void _tls_socket_accept_start(fr_event_list_t *el, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        /*
         *      The command exited before this connection, so the only
         *      connection which can arrive is one already queued.
         */
        if (utt->command_exited) {
                if (tls_socket_accept_one(utt) == 0) ERROR("The command exited without connecting");
 
                fr_event_loop_exit(el, 1);
                return;
        }
 
        if (fr_event_fd_insert(utt, &utt->accept_ef, el, utt->sockfd,
                               _tls_socket_accept, NULL, _tls_socket_error, utt) < 0) {
                PERROR("Failed adding the listening socket to the event loop");
                fr_event_loop_exit(el, 1);
        }
}
 
/** Wait for a connection, or for the command started by -e to exit without connecting
 *
 * @return
 *      - 0 with utt->fd set to the accepted connection.
 *      - -1 on failure.
 */
static int tls_socket_accept(unit_test_bio_t *utt)
{
        fr_event_user_t *ev = NULL;
 
        INFO("Waiting for a connection");
 
        if (fr_event_user_insert(utt, utt->el, &ev, true, _tls_socket_accept_start, utt) < 0) {
                PERROR("Failed scheduling the wait for a connection");
                return -1;
        }
 
        utt->accepting = true;
        (void) fr_event_loop(utt->el);
        utt->accepting = false;
 
        if (utt->accept_ef) {
                (void) fr_event_fd_delete(utt->el, utt->sockfd, FR_EVENT_FILTER_IO);
                utt->accept_ef = NULL;
        }
        TALLOC_FREE(ev);
 
        return utt->fd_bio ? 0 : -1;
}
 
/** Record that the command started by -e has exited
 *
 * If the server is waiting for a connection, a command which exits has either
 * connected already, and the connection is queued, or never will.
 */
static void _tls_command_exit(fr_event_list_t *el, pid_t pid, int status, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        utt->command_exited = true;
 
        if (WIFEXITED(status)) {
                INFO("Command (PID %ld) exited with status %d", (long)pid, WEXITSTATUS(status));
        } else if (WIFSIGNALED(status)) {
                INFO("Command (PID %ld) was killed by signal %d", (long)pid, WTERMSIG(status));
        }
 
        if (utt->accepting) {
                if (tls_socket_accept_one(utt) == 0) ERROR("The command exited without connecting");
 
                fr_event_loop_exit(el, 1);
                return;
        }
 
        if (utt->command_waiting) fr_event_loop_exit(el, 1);
}
 
/** Start the command named by -e
 *
 * A server starts the command once it is listening.  A command which connects
 * to the server connects to a socket which is already listening, so it can't
 * be refused, and the server sees the command exit, so it never waits for a
 * peer which has gone.
 *
 * A client starts the command once its first connection succeeds.
 */
static int tls_command_start(unit_test_bio_t *utt, char const *command)
{
        pid_t           pid;
        sigset_t        set;
 
        pid = fork();
        if (pid < 0) {
                ERROR("Failed forking the command: %s", fr_syserror(errno));
                return -1;
        }
 
        if (pid == 0) {
                /*
                 *      Only async-signal-safe calls between fork() and exec.
                 *      The command gets neither of our sockets, so the peer
                 *      sees the connection close when we close it, and it
                 *      gets an empty signal mask, not ours.
                 *
                 *      Only close() the fds.  Freeing the listen bio would
                 *      shutdown() the listening socket, which is shared
                 *      with the parent after fork().
                 */
                if (utt->sockfd >= 0) close(utt->sockfd);
                if (utt->fd >= 0) close(utt->fd);
                sigemptyset(&set);
                sigprocmask(SIG_SETMASK, &set, NULL);
                execl("/bin/sh", "sh", "-c", command, (char *)NULL);
                _exit(127);
        }
 
        INFO("Started command (PID %ld): %s", (long)pid, command);
 
        utt->command_pid = pid;
 
        if (fr_event_pid_wait(utt, utt->el, &utt->command_ev, pid, _tls_command_exit, utt) < 0) {
                PERROR("Failed waiting for the command to exit");
                return -1;
        }
 
        return 0;
}
 
/** Wait for the command started by -e to exit, so its output is complete
 *
 */
static void tls_command_wait(unit_test_bio_t *utt)
{
        if (!utt->command_pid || utt->command_exited) return;
 
        utt->command_waiting = true;
        (void) fr_event_loop(utt->el);
        utt->command_waiting = false;
}
 
/** Connect to the server named by -s
 *
 * With -B the fd bio connects without blocking, and the TLS bio waits for
 * the connect in the event loop.
 */
static int tls_socket_connect(unit_test_bio_t *utt)
{
        char    buffer[FR_IPADDR_STRLEN];
 
        fr_inet_ntop(buffer, sizeof(buffer), &utt->server_ipaddr);
 
        utt->fd_cfg = (fr_bio_fd_config_t) {
                .type = FR_BIO_FD_CONNECTED,
                .socket_type = utt->conf.socket_type,
                .transport = (utt->conf.socket_type == SOCK_DGRAM) ? "udp" : "tcp",
                .transport_type = (utt->conf.socket_type == SOCK_DGRAM) ?
                                        FR_BIO_FD_TRANSPORT_UDP : FR_BIO_FD_TRANSPORT_TCP,
                .dst_ipaddr = utt->server_ipaddr,
                .dst_port = utt->server_port,
                .async = utt->nonblock,
        };
 
        utt->fd_bio = fr_bio_fd_alloc(utt, &utt->fd_cfg, 0);
        if (!utt->fd_bio) {
                PERROR("Failed connecting to %s port %u", buffer, utt->server_port);
                return -1;
        }
 
        utt->fd = fr_bio_fd_info(utt->fd_bio)->socket.fd;
 
        INFO("Opened a connection to %s port %u on fd %d", buffer, utt->server_port, utt->fd);
 
        return 0;
}
 
/** Build an internal client.
 *
 * unit_test_tls accepts packets from anywhere (for now), and doesn't read "client" configuration sections.
 *
 * The client is built by allocating a CONF_SECTION rather than by filling in #fr_client_t manually, which
 * allows fields to be examined by `%request.client()`.
 *
 * "proto = tls" sets both the protocol and tls_required.  It also fixes the
 * secret at "radsec", so that is the secret set here.
 */
static fr_client_t *tls_client_alloc(TALLOC_CTX *ctx, fr_ipaddr_t const *ipaddr)
{
        CONF_SECTION    *cs;
        fr_client_t     *client;
        char            buffer[FR_IPADDR_STRLEN];
 
        /*
         *      Written without a prefix, the way a person would write it in
         *      a "client" section.  The "ipaddr" item is a COMBO_IP_PREFIX,
         *      so a bare host address parses as a /32 or a /128.
         */
        fr_inet_ntop(buffer, sizeof(buffer), ipaddr);
 
        MEM(cs = cf_section_alloc(ctx, NULL, "client", "unit_test_tls"));
        MEM(cf_pair_alloc(cs, "ipaddr", buffer, T_OP_EQ, T_BARE_WORD, T_BARE_WORD));
        MEM(cf_pair_alloc(cs, "proto", "tls", T_OP_EQ, T_BARE_WORD, T_BARE_WORD));
        MEM(cf_pair_alloc(cs, "secret", "radsec", T_OP_EQ, T_BARE_WORD, T_DOUBLE_QUOTED_STRING));
        MEM(cf_pair_alloc(cs, "shortname", "unit_test_tls", T_OP_EQ, T_BARE_WORD, T_DOUBLE_QUOTED_STRING));
        MEM(cf_pair_alloc(cs, "nas_type", "test", T_OP_EQ, T_BARE_WORD, T_DOUBLE_QUOTED_STRING));
 
        client = client_afrom_cs(ctx, cs, NULL, 0);
        if (!client) {
                PERROR("Failed creating the client for %s", buffer);
                talloc_free(cs);
                return NULL;
        }
 
        /*
         *      The client has to outlive the section it was built from,
         *      because %request.client() reads the section.
         */
        talloc_steal(client, cs);
 
        return client;
}
 
/** Build the request the handshake runs under
 *
 * The TLS code reads the control list for TLS-Session-Cert-File and
 * TLS-Session-Require-Client-Certificate, and writes the negotiated version
 * and cipher suite into the session-state list, so a real request is needed.
 */
static request_t *tls_request_alloc(TALLOC_CTX *ctx, fr_bio_t *fd_bio, int socket_type)
{
        fr_bio_fd_info_t const  *info = fr_bio_fd_info(fd_bio);
        int                     fd = info->socket.fd;
        request_t               *request;
        struct sockaddr_storage sa;
        socklen_t               salen;
 
        static uint64_t         number = 0;
 
        request = request_local_alloc_internal(ctx, NULL);
        if (!request) return NULL;
 
        if (!request->packet) request->packet = fr_packet_alloc(request, false);
        if (!request->reply) request->reply = fr_packet_alloc(request, false);
 
        request->packet->timestamp = fr_time();
 
        request->packet->socket.type = socket_type;
        request->packet->socket.fd = fd;
 
        /*
         *      A stream socket which is still connecting has no peer yet, so
         *      the fd bio gives the address which the socket is connecting to.
         */
        salen = sizeof(sa);
        if (getpeername(fd, (struct sockaddr *) &sa, &salen) == 0) {
                (void) fr_ipaddr_from_sockaddr(&request->packet->socket.inet.src_ipaddr,
                                               &request->packet->socket.inet.src_port, &sa, salen);
        } else {
                request->packet->socket.inet.src_ipaddr = info->socket.inet.dst_ipaddr;
                request->packet->socket.inet.src_port = info->socket.inet.dst_port;
        }
        request->packet->socket.af = request->packet->socket.inet.src_ipaddr.af;
 
        salen = sizeof(sa);
        if (getsockname(fd, (struct sockaddr *) &sa, &salen) == 0) {
                (void) fr_ipaddr_from_sockaddr(&request->packet->socket.inet.dst_ipaddr,
                                               &request->packet->socket.inet.dst_port, &sa, salen);
        }
 
        /*
         *      The client is the far end of the connection we just accepted.
         */
        request->client = tls_client_alloc(request, &request->packet->socket.inet.src_ipaddr);
        if (!request->client) {
                talloc_free(request);
                return NULL;
        }
 
        request->number = number++;
        request->name = talloc_typed_asprintf(request, "%" PRIu64, request->number);
        request->master_state = REQUEST_ACTIVE;
 
        request->log.dst = talloc_zero(request, log_dst_t);
        request->log.dst->func = vlog_request;
        request->log.dst->uctx = &default_log;
        request->log.dst->lvl = fr_debug_lvl;
 
        request->log.lvl = fr_debug_lvl;
        request->async = talloc_zero(request, fr_async_t);
        request->async->request = request;
 
        if (fr_packet_pairs_from_packet(request->request_ctx, &request->request_pairs, request->packet) < 0) {
                ERROR("Failed converting connection addresses to attributes");
                talloc_free(request);
                return NULL;
        }
 
        return request;
}
 
/** Start the TLS bio, from inside the event loop
 *
 * See tls_connection_run() for why this runs from inside the event loop.
 * The TLS bio adds the fd to the event loop, runs the handshake, and calls
 * tls_bio_connected() or tls_bio_failed().
 */
static void _tls_connection_start(UNUSED fr_event_list_t *el, void *uctx)
{
        unit_test_bio_t *utt = talloc_get_type_abort(uctx, unit_test_bio_t);
 
        if (fr_bio_tls_connect(utt->bio) < 0) {
                PERROR("Failed starting the TLS connection");
                tls_request_failed(utt);
                return;
        }
 
        /*
         *      A datagram connection starts with a datagram which was read
         *      from the listening socket, because that is what named the
         *      peer.  The connection's socket never saw it, so hand it over
         *      now that there is a connection to hand it to.
         */
        if (utt->first && !utt->done) {
                uint8_t *first = utt->first;
                size_t  first_len = utt->first_len;
 
                utt->first = NULL;
                utt->first_len = 0;
 
                DEBUG3("Handing the connection the %zu byte datagram which named the peer", first_len);
                fr_tls_connection_recv(utt->conn, first, first_len);
                talloc_free(first);
        }
}
 
/** Run one connection from the first byte to the last
 *
 * Everything which belongs to a single connection is allocated here and freed
 * again at the end, so that the next connection starts clean.  What survives
 * is what the cache needs: the interpreter, the modules, and so the sessions
 * a policy stored.
 *
 * The program opens the fd bio, allocates the request, and allocates the TLS
 * bio from the request.  The TLS bio does the rest.
 */
static int tls_connection_run(unit_test_bio_t *utt)
{
        int             ret = -1;
        fr_event_user_t *ev = NULL;
        request_t       *stale;
 
        utt->connections++;
 
        utt->done = false;
        utt->connected = false;
        utt->ret = EXIT_SUCCESS;
        utt->fd = -1;
 
        /*
         *      Get a connection, one way or the other.
         */
        if (utt->client) {
                if (tls_socket_connect(utt) < 0) return -1;
 
                if (utt->command && !utt->command_pid && (tls_command_start(utt, utt->command) < 0)) goto finish;
        } else {
                if (tls_socket_accept(utt) < 0) return -1;
        }
 
        utt->request = tls_request_alloc(utt, utt->fd_bio, utt->conf.socket_type);
        if (!utt->request) goto finish;
 
        unlang_interpret_set(utt->request, utt->intp);
 
        utt->bio = fr_bio_tls_alloc(utt->request, utt->fd_bio, utt->ssl_ctx, utt->client,
                                    utt->conf.require_client_certificate);
        if (!utt->bio) {
                PERROR("Failed creating the TLS bio");
                goto finish;
        }
 
        utt->conn = fr_bio_tls_conn(utt->bio);
 
        ((fr_bio_t *) utt->bio)->uctx = utt;
        fr_bio_cb_set((fr_bio_t *) utt->bio, &(fr_bio_cb_funcs_t) {
                        .connected = tls_bio_connected,
                        .failed = tls_bio_failed,
                      });
 
        /*
         *      Name the connection for the log.  Only the application knows
         *      what identifies a connection, which is why the library does
         *      not do this itself.
         */
        {
                fr_socket_t *socket = &utt->request->packet->socket;
 
                utt->conn->name = fr_asprintf(utt->conn, "%s from %pV:%u to %pV:%u",
                                              (socket->type == SOCK_DGRAM) ? "DTLS" : "TLS",
                                              fr_box_ipaddr(socket->inet.src_ipaddr), socket->inet.src_port,
                                              fr_box_ipaddr(socket->inet.dst_ipaddr), socket->inet.dst_port);
                if (!utt->conn->name) goto finish;
 
                DEBUG2("Connection is %s", utt->conn->name);
        }
 
        if (!utt->client) {
                INFO("Accepted connection from %pV on fd %d",
                     fr_box_ipaddr(utt->request->packet->socket.inet.src_ipaddr), utt->fd);
        }
 
        if (fr_event_post_insert(utt->el, _tls_runnable, utt) < 0) {
                PERROR("Failed adding the runnable handler to the event loop");
                goto finish;
        }
 
        /*
         *      The connection is started from inside the event loop rather
         *      than here.  Ending the previous connection left the loop
         *      flagged as exiting, and fr_event_fd_insert() refuses to add a
         *      socket to a loop in that state.  fr_event_loop() clears the
         *      flag as it starts, so a user event which fires immediately is
         *      the first point at which the TLS bio can add the socket.
         */
        if (fr_event_user_insert(utt, utt->el, &ev, true, _tls_connection_start, utt) < 0) {
                PERROR("Failed scheduling the start of the connection");
                goto finish;
        }
 
        (void) fr_event_loop(utt->el);
 
        ret = 0;
 
finish:
        (void) fr_event_post_delete(utt->el, _tls_runnable, utt);
        if (utt->fd >= 0) (void) fr_event_fd_delete(utt->el, utt->fd, FR_EVENT_FILTER_IO);
 
        /*
         *      The user event is allocated in utt, which outlives the event
         *      list.  The destructor of the user event removes it from the
         *      event list, so free it while the event list still exists.
         */
        TALLOC_FREE(ev);
 
        /*
         *      Freeing the TLS bio cancels the request, which unwinds the
         *      connection frame, and then frees the connection.  The fd bio
         *      closes the socket.
         */
        utt->conn = NULL;
        TALLOC_FREE(utt->bio);
        TALLOC_FREE(utt->fd_bio);
 
        /*
         *      Empty the heap before the requests on it are freed.  Popping
         *      clears each entry's index, so nothing is left pointing at
         *      memory the request pool is about to hand out again.
         */
        while (fr_heap_pop((void **)&stale, &utt->runnable) == 0) {
                if (!stale) break;
        }
        utt->yielded = 0;
 
        TALLOC_FREE(utt->request);
        TALLOC_FREE(utt->first);
        utt->fd = -1;
 
        return ret;
}
 
/** Turn a comma separated list of names into the wire format ALPN uses
 *
 * Each name becomes one length octet followed by the name.  There is no
 * terminator, so the caller takes the length from the array itself.
 *
 * @param[in] ctx       to allocate in.
 * @param[in] names     comma separated, in order of preference.
 * @return
 *      - the list, whose talloc array length is the length of the list.
 *      - NULL if a name is empty or longer than 255 octets.
 */
static unsigned char *tls_alpn_build(TALLOC_CTX *ctx, char const *names)
{
        unsigned char   *alpn, *p;
        char const      *q;
        size_t          len;
 
        /*
         *      One length octet per name, and the names themselves.  The
         *      separators become those length octets, and the first name has
         *      no separator before it, so one more octet than the string.
         */
        MEM(alpn = talloc_zero_array(ctx, unsigned char, strlen(names) + 1));
        p = alpn;
 
        for (q = names; *q != '\0'; q += len) {
                len = strcspn(q, ",");
                if ((len == 0) || (len > 255)) {
                        ERROR("Each ALPN protocol name must be between 1 and 255 characters");
                        talloc_free(alpn);
                        return NULL;
                }
 
                *p++ = (unsigned char) len;
                memcpy(p, q, len);
                p += len;
 
                if (q[len] == ',') len++;               /* step over the separator */
        }
 
        /*
         *      A trailing separator, or a repeated one, leaves the array
         *      longer than what was written into it.  Shrink it so the array
         *      length is the length of the list.
         */
        MEM(alpn = talloc_realloc(ctx, alpn, unsigned char, (size_t) (p - alpn)));
 
        return alpn;
}
 
int main(int argc, char *argv[])
{
        int                     ret = EXIT_SUCCESS;
        int                     c;
        char const              *receipt_file = NULL;
        char const              *command = NULL;
        char const              *server = NULL;
        unsigned int            count = 1;
        bool                    alert = false;
        bool                    invalid = false;
        bool                    nonblock = false;
        bool                    reject = false;
        bool                    network_fail = false;
        bool                    abort_pending = false;
        bool                    app_data = false;
        bool                    delay_tickets = false;
        bool                    hold = false;
        bool                    client = false;
        char const              *alpn_names = NULL;
        bool                    alpn_required = false;
        unsigned int            i;
 
        TALLOC_CTX              *autofree;
        TALLOC_CTX              *thread_ctx;
 
        char                    *p;
        main_config_t           *config;
 
        fr_dict_t               *dict = NULL;
        fr_dict_t const         *dict_check;
 
        virtual_server_t const  *vs;
        CONF_SECTION            *utt_cs;
 
        unit_test_bio_t         *utt = NULL;
        fr_tls_conf_t           *conf = NULL;
 
        /*
         *      Must be called first, so the handler is called last
         */
        fr_atexit_global_setup();
 
        autofree = talloc_autofree_context();
        thread_ctx = talloc_new(autofree);
 
        config = main_config_alloc(autofree);
        if (!config) {
                fr_perror("unit_test_bio");
                fr_exit_now(EXIT_FAILURE);
        }
 
        p = strrchr(argv[0], FR_DIR_SEP);
        if (!p) {
                main_config_name_set_default(config, argv[0], false);
        } else {
                main_config_name_set_default(config, p + 1, false);
        }
 
        fr_talloc_fault_setup();
 
        if (fr_fault_setup(autofree, getenv("PANIC_ACTION"), argv[0], PANIC_ACTION_SIGNALS) < 0) {
                fr_perror("%s", config->name);
                fr_exit_now(EXIT_FAILURE);
        }
#ifdef NDEBUG
        fr_disable_null_tracking_on_free(autofree);
#endif
 
        fr_debug_lvl = 0;
        fr_time_start();
 
        /*
         *      The tests should have only IPs, not host names.
         */
        fr_hostname_lookups = fr_reverse_lookups = false;
 
        /*
         *      We always log to stdout.
         */
        default_log.dst = L_DST_STDOUT;
        default_log.fd = STDOUT_FILENO;
        default_log.print_level = true;
 
        /*  Process the options.  */
        while ((c = getopt(argc, argv, "ABc:Cd:D:e:hHIlL:Mn:NPQr:Rs:TxX")) != -1) {
                switch (c) {
                        case 'A':
                                alert = true;
                                break;
 
                        case 'B':
                                nonblock = true;
                                break;
 
                        case 'N':
                                network_fail = true;
                                break;
 
                        case 'R':
                                reject = true;
                                break;
 
                        case 'Q':
                                abort_pending = true;
                                break;
 
                        case 'c':
                                count = (unsigned int) atoi(optarg);
                                if (!count) {
                                        fprintf(stderr, "Invalid value \"%s\" for -c\n", optarg);
                                        fr_exit_now(EXIT_FAILURE);
                                }
                                break;
 
                        case 'C':
                                check_config = true;
                                break;
 
                        case 'd':
                                main_config_confdir_set(config, optarg);
                                break;
 
                        case 'D':
                                main_config_dict_dir_set(config, optarg);
                                break;
 
                        case 'h':
                                usage(config, EXIT_SUCCESS);
                                break;
 
                        case 'I':
                                invalid = true;
                                break;
 
                        case 'l':
                                alpn_required = true;
                                break;
 
                        case 'L':
                                alpn_names = optarg;
                                break;
 
                        case 'M':
                                talloc_enable_leak_report();
                                break;
 
                        case 'n':
                                config->name = optarg;
                                break;
 
                        case 'H':
                                hold = true;
                                break;
 
                        case 'P':
                                app_data = true;
                                break;
 
                        case 'T':
                                delay_tickets = true;
                                break;
 
                        case 'e':
                                command = optarg;
                                break;
 
                        case 'r':
                                receipt_file = optarg;
                                break;
 
                        case 's':
                                server = optarg;
                                break;
 
                        case 'X':
                                fr_debug_lvl += 2;
                                default_log.print_level = true;
                                break;
 
                        case 'x':
                                fr_debug_lvl++;
                                if (fr_debug_lvl > 2) default_log.print_level = true;
                                break;
 
                        default:
                                usage(config, EXIT_FAILURE);
                                break;
                }
        }
 
        if (receipt_file && (fr_unlink(receipt_file) < 0)) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        /*
         *  A mismatch between the OpenSSL headers used at build time and the
         *  linked OpenSSL library makes this program exit now, rather than
         *  crash later.
         */
        if (fr_openssl_version_consistent() < 0) EXIT_WITH_FAILURE;
 
        /*
         *  fr_openssl_init() must be called before *ANY* OpenSSL functions are
         *  used, which is why
         *  fr_openssl_init() is called so early.
         */
        if (fr_openssl_init() < 0) EXIT_WITH_FAILURE;
 
        if (fr_debug_lvl) dependency_version_print();
 
        /*
         *      Mismatch between the binary and the libraries it links against
         */
        if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      Initialise the dynamic loader infrastructure, which the config
         *      file parser uses.
         */
        modules_init(config->lib_dir);
 
        if (!fr_dict_global_ctx_init(NULL, true, config->dict_dir)) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (fr_dict_internal_afrom_file(&dict, FR_DICTIONARY_INTERNAL_DIR, __FILE__) < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (fr_tls_dict_init() < 0) EXIT_WITH_FAILURE;
 
        /*
         *      Load the custom dictionary
         */
        if (fr_dict_read(dict, config->confdir, FR_DICTIONARY_FILE) == -1) {
                PERROR("Failed to initialize the dictionaries");
                EXIT_WITH_FAILURE;
        }
 
        if (fr_dict_autoload(unit_test_bio_dict) < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (request_global_init() < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      The triggers are run-time expansions, so the triggers need the
         *      main event loop.
         */
        if (main_loop_init() < 0) {
                PERROR("Failed initialising main event loop");
                EXIT_WITH_FAILURE;
        }
 
        if (unlang_global_init() < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (modules_rlm_init() < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (virtual_servers_init() < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (main_config_init(config) < 0) EXIT_WITH_FAILURE;
 
        /*
         *      The TLS bio writes a close_notify alert when the bio closes, and the peer may have closed the
         *      socket already.  The write must fail with an error, as it does in radiusd, and must not kill
         *      the process.
         */
#ifdef SIGPIPE
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
                fr_perror("%s: Failed ignoring SIGPIPE", config->name);
                EXIT_WITH_FAILURE;
        }
#endif
 
        MEM(utt = talloc_zero(autofree, unit_test_bio_t));
        utt->sockfd = utt->fd = -1;
        utt->ret = EXIT_SUCCESS;
        utt->count = count;
        utt->alert = alert;
        utt->invalid = invalid;
        utt->nonblock = nonblock;
        utt->app_data = app_data;
        utt->hold = hold;
        utt->reject = reject;
        utt->network_fail = network_fail;
        utt->abort_pending = abort_pending;
 
 
        /*
         *      Bootstrap and instantiate the virtual servers and the modules
         *      that the virtual servers use.  The TLS subsections name a
         *      virtual server, so server_init() has to run before
         *      cf_section_parse() reads the `unit_test_tls` section.
         */
        if (server_init(config->root_cs, config->confdir, dict) < 0) EXIT_WITH_FAILURE;
 
        vs = virtual_server_find("tls");
        if (!vs) {
                ERROR("Cannot find virtual server 'tls'");
                EXIT_WITH_FAILURE;
        }
 
        dict_check = virtual_server_dict_by_name("tls");
        if (!dict_check || !fr_dict_compatible(dict_check, dict_tls)) {
                ERROR("Virtual server 'tls' must have 'namespace = tls'");
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      Parse the settings that steer the test program, with the TLS
         *      configuration for each role as a subsection.  The TLS rows
         *      resolve the `virtual_server` item through
         *      virtual_server_cf_parse(), so server_init() had to run first.
         *      cf_section_parse_pass2() then resolves the expansions in the
         *      TLS subsections.
         */
        utt_cs = cf_section_find(config->root_cs, "unit_test_tls", NULL);
        if (!utt_cs) {
                ERROR("Cannot find a top-level 'unit_test_tls { ... }' section in %s.conf", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (cf_section_rules_push(utt_cs, unit_test_bio_config) < 0) EXIT_WITH_FAILURE;
 
        if ((cf_section_parse(utt, &utt->conf, utt_cs) < 0) ||
            (cf_section_parse_pass2(&utt->conf, utt_cs) < 0)) {
                cf_log_perr(utt_cs, "Failed parsing the 'unit_test_tls' section");
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      Resolve `transport` into the socket it names, and into the
         *      socket type which the TLS configuration below is given.
         */
        if (strcmp(utt->conf.transport, "tcp") == 0) {
                utt->conf.socket_type = SOCK_STREAM;
                utt->conf.ipaddr = utt->conf.tcp.ipaddr;
                utt->conf.port = utt->conf.tcp.port;
 
        } else if (strcmp(utt->conf.transport, "udp") == 0) {
                utt->conf.socket_type = SOCK_DGRAM;
                utt->conf.ipaddr = utt->conf.udp.ipaddr;
                utt->conf.port = utt->conf.udp.port;
 
        } else {
                cf_log_err(utt_cs, "Invalid transport name \"%s\", expected \"tcp\" or \"udp\"",
                           utt->conf.transport);
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      -s turns the program around: instead of listening for a
         *      connection, it makes one.
         */
        if (server) {
                utt->client = client = true;
 
                if (fr_inet_pton_port(&utt->server_ipaddr, &utt->server_port, server,
                                      -1, AF_UNSPEC, true, false) < 0) {
                        PERROR("Invalid value \"%s\" for -s", server);
                        EXIT_WITH_FAILURE;
                }
 
                /*
                 *      fr_inet_pton_port() clears the port before it starts,
                 *      so a missing port is zero here, and not the default.
                 */
                if (!utt->server_port) utt->server_port = utt->conf.port;
 
                if (!utt->server_port) {
                        ERROR("No port given in -s, and no 'port' in the 'unit_test_tls' section");
                        EXIT_WITH_FAILURE;
                }
        }
 
        if (utt->conf.drop_datagram) {
                cf_log_err(utt_cs, "'drop_datagram' is not supported by unit_test_bio, use unit_test_tls");
                EXIT_WITH_FAILURE;
        }
 
        conf = client ? utt->conf.client : utt->conf.server;
        if (!conf) {
                cf_log_err(utt_cs, "Cannot run as %s, the 'unit_test_tls' section has no '%s { ... }' subsection",
                           client ? "client" : "server", client ? "client" : "server");
                EXIT_WITH_FAILURE;
        }
 
        conf->delayed_tickets = delay_tickets;
 
        /*
         *      ALPN is not parsed from the configuration file.  The library
         *      leaves the protocol list to the application, so set it here,
         *      after the TLS configuration is parsed and before the context
         *      is built from it.  See src/lib/tls/alpn.c.
         */
        if (alpn_names) {
                utt->alpn = tls_alpn_build(utt, alpn_names);
                if (!utt->alpn) EXIT_WITH_FAILURE;
 
                conf->alpn = utt->alpn;
                conf->sizeof_alpn = talloc_array_length(utt->alpn);
        }
        conf->alpn_required = alpn_required;
 
        /*
         *      The transport is set by the application for the same reason
         *      the ALPN strings are: one `tls { ... }` section is parsed by
         *      the same rules everywhere, and only the application knows
         *      what it opened the socket as.
         */
        conf->socket_type = utt->conf.socket_type;
 
        utt->ssl_ctx = fr_tls_ctx_alloc(conf, client);
        if (!utt->ssl_ctx) {
                cf_log_perr(utt_cs, "Failed creating the TLS context");
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      The configuration parsed without error, so exit with success.
         */
        if (check_config) {
                DEBUG("Configuration appears to be OK");
                goto cleanup;
        }
 
        utt->el = main_loop_event_list();
        fr_assert(utt->el != NULL);
 
 
        fr_coords_create(autofree, utt->el);
 
        /*
         *      Simulate thread-specific instantiation
         */
        fr_schedule_worker_id_set(0);
        if (fr_thread_instantiate(thread_ctx, utt->el) < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (modules_rlm_coord_attach(utt->el) < 0) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        if (fr_coord_pre_event_insert(utt->el) < 0) {
                fr_strerror_const("Failed adding coordinator pre-check to event list");
                EXIT_WITH_FAILURE;
        }
 
        if (fr_coord_post_event_insert(utt->el) < 0) {
                fr_strerror_const("Failed adding coordinator post-check to event list");
                EXIT_WITH_FAILURE;
        }
 
        /*
         *  Set the panic action (if required)
         */
        {
                char const *panic_action = NULL;
 
                panic_action = getenv("PANIC_ACTION");
                if (!panic_action) panic_action = config->panic_action;
 
                if (panic_action && (fr_fault_setup(autofree, panic_action, argv[0], PANIC_ACTION_SIGNALS) < 0)) {
                        fr_perror("%s", config->name);
                        EXIT_WITH_FAILURE;
                }
        }
 
        setlinebuf(stdout); /* line buffered output */
 
        /*
         *      One interpreter, one runnable heap and one request for the
         *      whole connection.  The unit_test_bio_t documentation says why.
         */
        MEM(utt->runnable = fr_heap_talloc_alloc(utt, fr_pointer_cmp, request_t, runnable, 0));
 
        utt->intp = unlang_interpret_init(utt, utt->el,
                                          &(unlang_request_func_t){
                                                .init_internal  = _request_init_internal,
 
                                                .done_external  = _request_done_external,
                                                .done_internal  = _request_done_internal,
                                                .done_detached  = _request_done_detached,
 
                                                .detach         = _request_detach,
                                                .yield          = _request_yield,
                                                .resume         = _request_resume,
                                                .mark_runnable  = _request_runnable,
                                                .scheduled      = _request_scheduled,
                                          }, utt);
        if (!utt->intp) {
                fr_perror("%s", config->name);
                EXIT_WITH_FAILURE;
        }
 
        /*
         *      Subrequests created by the TLS code inherit the thread default,
         *      so the thread default has to point at the connection's
         *      interpreter.
         */
        unlang_interpret_set_thread_default(utt->intp);
 
        /*
         *      A server has one listening socket for every connection it
         *      accepts, so it is opened once, here.
         */
        if (!utt->client && (tls_socket_open(utt) < 0)) EXIT_WITH_FAILURE;
 
        /*
         *      A server starts the command once it is listening.  A client
         *      starts it once the first connection succeeds, see
         *      tls_connection_run().
         */
        utt->command = command;
        if (!utt->client && command && (tls_command_start(utt, command) < 0)) EXIT_WITH_FAILURE;
 
        for (i = 0; i < utt->count; i++) {
                if (tls_connection_run(utt) < 0) EXIT_WITH_FAILURE;
 
                if (utt->ret != EXIT_SUCCESS) break;
        }
 
        tls_command_wait(utt);
 
        ret = utt->ret;
 
cleanup:
        if (utt) {
                /*
                 *      tls_connection_run() cleans up everything which belongs
                 *      to one connection.  What is left here is what outlives
                 *      them.
                 */
                if (utt->ssl_ctx) SSL_CTX_free(utt->ssl_ctx);
 
                if (utt->sockfd >= 0) close(utt->sockfd);
 
                /*
                 *      A failure left the client running.  The reap below
                 *      signals it if it doesn't exit by itself.
                 */
                if (utt->command_pid && !utt->command_exited) {
                        talloc_free(UNCONST(fr_event_pid_t *, utt->command_ev));
                        (void) fr_event_pid_reap(utt->el, utt->command_pid, NULL, NULL);
                }
        }
 
        unlang_interpret_set_thread_default(NULL);
 
        /*
         *      Detach from coordinators.
         */
        if (utt && utt->el && (modules_rlm_coord_detach() > 0)) {
                if (unlikely(fr_coord_close_event_insert(utt->el) < 0)) {
                        ERROR("Failed setting up coordinator close events");
                }
                fr_event_loop(utt->el);
        }
 
        /*
         *      Free thread data
         */
        talloc_free(thread_ctx);
 
        fr_coords_destroy();
 
        fr_atexit_thread_trigger_all();
 
        if (utt && utt->el) fr_event_list_reap_signal(utt->el, fr_time_delta_from_sec(5), SIGKILL);
 
        main_loop_free();
 
        fr_atexit_thread_trigger_all();
 
        server_free();
 
        /*
         *      Virtual servers need to be freed before modules
         *      as state entries containing data with module-specific
         *      destructors may exist.
         */
        virtual_servers_free();
 
        modules_rlm_free();
 
        main_config_free(&config);
 
        fr_tls_dict_free();
 
        fr_dict_autofree(unit_test_bio_dict);
 
        if (fr_dict_free(&dict, __FILE__) < 0) {
                fr_perror("unit_test_bio - dict");
                ret = EXIT_FAILURE;
        }
 
        fr_openssl_free();
 
        if (receipt_file && (ret == EXIT_SUCCESS) && (fr_touch(NULL, receipt_file, 0644, true, 0755) <= 0)) {
                fr_perror("unit_test_bio");
                ret = EXIT_FAILURE;
        }
 
        if (talloc_free(autofree) < 0) {
                fr_perror("unit_test_bio - autofree");
                ret = EXIT_FAILURE;
        }
 
        /*
         *      Ensure our atexit handlers run before any other
         *      atexit handlers registered by third party libraries.
         */
        fr_atexit_global_trigger_all();
 
        return ret;
}
 
/*
 *  Display the syntax for starting this program.
 */
static NEVER_RETURNS void usage(main_config_t const *config, int status)
{
        FILE *output = status ? stderr : stdout;
 
        fprintf(output, "Usage: %s [options]\n", config->name);
        fprintf(output, "Options:\n");
        fprintf(output, "  -A                 Reject the peer with a fatal TLS alert on the last connection,\n");
        fprintf(output, "                     rather than completing the handshake.  With -c 2 the first\n");
        fprintf(output, "                     connection fills the session cache, so the alert then has a\n");
        fprintf(output, "                     session to clear.  Used to test the alert and clear paths.\n");
        fprintf(output, "  -B                 Put the connection socket in non-blocking mode, so that a read()\n");
        fprintf(output, "                     or a write() which would wait returns EAGAIN instead.  The event\n");
        fprintf(output, "                     loop already waits for the socket to be readable or writable, so\n");
        fprintf(output, "                     this exercises the EAGAIN paths rather than changing what runs.\n");
        fprintf(output, "  -I                 Mark the session invalid part way through the handshake on the\n");
        fprintf(output, "                     last connection, the way fr_tls_session_msg_cb() marks a record\n");
        fprintf(output, "                     FreeRADIUS refuses.  The next round then refuses to continue, and\n");
        fprintf(output, "                     sends the peer a fatal alert saying so.\n");
        fprintf(output, "  -R                 Reject the session once the handshake has succeeded on the last\n");
        fprintf(output, "                     connection, as policy would.  The cached session is then cleared\n");
        fprintf(output, "                     rather than stored.  With -c 2 the first connection fills the\n");
        fprintf(output, "                     cache and the second resumes from it before being rejected, so\n");
        fprintf(output, "                     the clear then has a loaded session to remove.\n");
        fprintf(output, "  -Q                 Free the connection on the last connection once the handshake\n");
        fprintf(output, "                     has succeeded, while `store session` is still queued, to\n");
        fprintf(output, "                     exercise the path that discards queued cache operations.\n");
        fprintf(output, "  -N                 Fail the session with a network error on the last connection,\n");
        fprintf(output, "                     once the handshake succeeds, to simulate the peer closing the\n");
        fprintf(output, "                     connection.  With -c 2 the second connection loads a session\n");
        fprintf(output, "                     from the cache.  A network error does not clear the loaded\n");
        fprintf(output, "                     session, and the session stays in the cache.\n");
        fprintf(output, "  -H                 Once the connection is up, send nothing and hold it open.\n");
        fprintf(output, "                     A peer which is still owed a session ticket or a byte of\n");
        fprintf(output, "                     application data then waits for something which never\n");
        fprintf(output, "                     arrives, which is what exercises the post-handshake timer.\n");
        fprintf(output, "  -c <count>         Run <count> connections, one after another.  Session resumption\n");
        fprintf(output, "                     needs two: one to fill the cache, one to resume from it.\n");
        fprintf(output, "  -C                 Check configuration and exit.\n");
        fprintf(output, "  -d <confdir>       Configuration file directory. (defaults to " CONFDIR ").\n");
        fprintf(output, "  -D <dict_dir>      Dictionary files are in \"dict_dir/*\".\n");
        fprintf(output, "  -e <command>       Run <command> in a shell.  A server runs it once it is\n");
        fprintf(output, "                     listening, so <command> can be what connects to the server,\n");
        fprintf(output, "                     such as openssl s_client.  If <command> exits without\n");
        fprintf(output, "                     connecting, the server fails instead of waiting.  With -s,\n");
        fprintf(output, "                     it runs once the first connection succeeds.  Either way,\n");
        fprintf(output, "                     unit_test_bio waits for <command> to exit before it exits.\n");
        fprintf(output, "  -h                 Print this help message.\n");
        fprintf(output, "  -M                 Enable talloc leak reporting.\n");
        fprintf(output, "  -n <name>          Read ${confdir}/name.conf instead of ${confdir}/unit_test_bio.conf.\n");
        fprintf(output, "  -P                 Server only.  Send one byte of application data, 0x00, once the\n");
        fprintf(output, "                     handshake is done.  A server sends every session ticket before\n");
        fprintf(output, "                     its first byte of application data, so this tells a client that\n");
        fprintf(output, "                     no ticket is still on its way.\n");
        fprintf(output, "  -T                 Delay stateless TLS 1.3 session tickets, as EAP does.  The server\n");
        fprintf(output, "                     sends none in the handshake.\n");
        fprintf(output, "  -r <receipt_file>  Create <receipt_file> when the program exits successfully.\n");
        fprintf(output, "  -s <server[:port]> Connect to <server> as a TLS client, instead of listening\n");
        fprintf(output, "                     for a connection.  Reads the 'tls client' section.  The port\n");
        fprintf(output, "                     defaults to 'port' from the 'unit_test_tls' section.\n");
        fprintf(output, "  -X                 Turn on full debugging.\n");
        fprintf(output, "  -x                 Turn on additional debugging. (-xx gives more debugging).\n");
 
        fr_exit_now(status);
}