4027

pending completion

Build # 4027

Build Type

Pull #732

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/stefanberger/swtpm/commit/<a class=hub.com/stefanberger/swtpm/commit/0ecd83dcbe351d5e6665266504786f105a1cfae3">0ecd83dcb<a href="https://github.com/stefanberger/swtpm/commit/0ecd83dcbe351d5e6665266504786f105a1cfae3">">Merge </a><a class="double-link" href="https://github.com/stefanberger/swtpm/commit/<a class="double-link" href="https://github.com/stefanberger/swtpm/commit/f9d74021a1d9a633b2eeaeef6bb51f53af8d0659">f9d74021a</a>">f9d74021a</a><a href="https://github.com/stefanberger/swtpm/commit/0ecd83dcbe351d5e6665266504786f105a1cfae3"> into 0ebe80466">0ebe80466</a>

Pull Request Pull Request #732: Release the lock on the storage backend when migrating with shared storage

Run Details

103 of 103 new or added lines in 9 files covered. (100.0%)

6283 of 8358 relevant lines covered (75.17%)

15487.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.52

/src/swtpm/swtpm_chardev.c

/********************************************************************************/
/*                                                                              */
/*                           TPM Main Program                                   */
/*                 Written by Ken Goldman, Stefan Berger                        */
/*                     IBM Thomas J. Watson Research Center                     */
/*                                                                              */
/* (c) Copyright IBM Corporation 2006, 2010, 2015, 2016, 2019                        */
/*                                                                                */
/* All rights reserved.                                                                */
/*                                                                                 */
/* Redistribution and use in source and binary forms, with or without                */
/* modification, are permitted provided that the following conditions are        */
/* met:                                                                                */
/*                                                                                 */
/* Redistributions of source code must retain the above copyright notice,        */
/* this list of conditions and the following disclaimer.                        */
/*                                                                                 */
/* Redistributions in binary form must reproduce the above copyright                */
/* notice, this list of conditions and the following disclaimer in the                */
/* documentation and/or other materials provided with the distribution.                */
/*                                                                                 */
/* Neither the names of the IBM Corporation nor the names of its                */
/* contributors may be used to endorse or promote products derived from                */
/* this software without specific prior written permission.                        */
/*                                                                                 */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS                */
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT                */
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR        */
/* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT                */
/* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,        */
/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT                */
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        */
/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY        */
/* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT                */
/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE        */
/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                */
/********************************************************************************/

#include <config.h>

#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <getopt.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/ioctl.h>

#include <libtpms/tpm_error.h>
#include <libtpms/tpm_library.h>
#include <libtpms/tpm_memory.h>

#include "main.h"
#include "swtpm_debug.h"
#include "swtpm_io.h"
#include "swtpm_nvstore.h"
#include "common.h"
#include "locality.h"
#include "logging.h"
#include "pidfile.h"
#include "tpmlib.h"
#include "utils.h"
#include "ctrlchannel.h"
#include "mainloop.h"
#ifdef WITH_VTPM_PROXY
#include "vtpm_proxy.h"
#endif
#include "tpmstate.h"
#include "daemonize.h"
#include "seccomp_profile.h"
#include "options.h"
#include "capabilities.h"

/* local variables */
static int notify_fd[2] = {-1, -1};

static struct libtpms_callbacks callbacks = {
    .sizeOfStruct            = sizeof(struct libtpms_callbacks),
    .tpm_nvram_init          = SWTPM_NVRAM_Init,
    .tpm_nvram_loaddata      = SWTPM_NVRAM_LoadData,
    .tpm_nvram_storedata     = SWTPM_NVRAM_StoreData,
    .tpm_nvram_deletename    = SWTPM_NVRAM_DeleteName,
    .tpm_io_init             = NULL,
    .tpm_io_getlocality      = mainloop_cb_get_locality,
};

static void sigterm_handler(int sig __attribute__((unused)))
{
    TPM_DEBUG("Terminating...\n");
    if (write(notify_fd[1], "T", 1) < 0) {
        logprintf(STDERR_FILENO, "Error: sigterm notification failed: %s\n",
                  strerror(errno));
    }
    mainloop_terminate = true;
}

#ifdef WITH_VTPM_PROXY
static int create_vtpm_proxy(struct vtpm_proxy_new_dev *vtpm_new_dev,
                             int *_errno)
{
    int fd, n, ret = 0;

    fd = open("/dev/vtpmx", O_RDWR);
    if (fd < 0) {
        logprintf(STDERR_FILENO, "Could not open /dev/vtpmx: %s\n",
                  strerror(errno));
        *_errno = errno;
        return -1;
    }

    n = ioctl(fd, VTPM_PROXY_IOC_NEW_DEV, vtpm_new_dev);
    if (n) {
        logprintf(STDERR_FILENO, "Ioctl to create vtpm proxy failed: %s\n",
                  strerror(errno));
        *_errno = errno;
        ret = -1;
    }
    close(fd);

    return ret;
}
#endif

static void usage(FILE *file, const char *prgname, const char *iface)
{
    fprintf(file,
    "Usage: %s %s [options]\n"
    "\n"
    "The following options are supported:\n"
    "\n"
    "-c|--chardev <device>\n"
    "                 : use the given character device\n"
    "-f|--fd <fd>     : use the given character device file descriptor\n"
    "-d|--daemon      : daemonize the TPM\n"
    "--ctrl type=[unixio|tcp][,path=<path>][,port=<port>[,bindaddr=address[,ifname=ifname]]][,fd=<filedescriptor|clientfd=<filedescriptor>][,mode=0...][,uid=uid][,gid=gid]\n"
    "                 : TPM control channel using either UnixIO or TCP sockets;\n"
    "                   the path is only valid for Unixio channels; the port must\n"
    "                   be given in case the type is TCP; the TCP socket is bound\n"
    "                   to 127.0.0.1 by default and other bind addresses can be\n"
    "                   given with the bindaddr parameter; if fd is provided,\n"
    "                   it will be treated as a server socket and used for \n"
    "                   accepting client connections; if clientfd is provided,\n"
    "                   it will be treaded as client connection;\n"
    "                   NOTE: fd and clientfd are mutually exclusive and \n"
    "                   clientfd is only valid for UnixIO channels\n"
    "                   mode allows a user to set the file mode bits of a Unixio socket;\n"
    "                   the value must be given in octal number format\n"
    "                   uid and gid set the ownership of the Unixio socket's file;\n"
    "--migration-key file=<path>|fd=<fd>[,mode=aes-cbc|aes-256-cbc][,format=hex|binary][,remove=[true|false]]\n"
    "                 : use an AES key for the encryption of the TPM's state\n"
    "                   when it is retrieved from the TPM via ioctls;\n"
    "                   Setting this key ensures that the TPM's state will always\n"
    "                   be encrypted when migrated\n"
    "--migration-key pwdfile=<path>|pwdfd=<fd>[,mode=aes-cbc|aes-256-cbc][,remove=[true|false]][,kdf=sha512|pbkdf2]\n"
    "                 : provide a passphrase in a file; the AES key will be\n"
    "                   derived from this passphrase; default kdf is PBKDF2\n"
    "--log file=<path>|fd=<filedescriptor>[,level=n][,prefix=<prefix>][,truncate]\n"
    "                 : write the TPM's log into the given file rather than\n"
    "                   to the console; provide '-' for path to avoid logging\n"
    "                   log level 5 and higher will enable libtpms logging;\n"
    "                   all logged output will be prefixed with prefix;\n"
    "                   the log file can be reset (truncate)\n"
    "--key file=<path>|fd=<fd>[,mode=aes-cbc|aes-256-cbc][,format=hex|binary][,remove=[true|false]]\n"
    "                 : use an AES key for the encryption of the TPM's state\n"
    "                   files; use the given mode for the block encryption;\n"
    "                   the key is to be provided as a hex string or in binary\n"
    "                   format; the keyfile can be automatically removed using\n"
    "                   the remove parameter\n"
    "--key pwdfile=<path>|pwdfd=<fd>[,mode=aes-cbc|aes-256-cbc][,remove=[true|false]][,kdf=sha512|pbkdf2]\n"
    "                 : provide a passphrase in a file; the AES key will be\n"
    "                   derived from this passphrase; default kdf is PBKDF2\n"
    "--pid file=<path>|fd=<filedescriptor>\n"
    "                 : write the process ID into the given file\n"
    "--tpmstate dir=<dir>[,mode=0...]|backend-uri=<uri>\n"
    "                 : set the directory or uri where the TPM's state will be written\n"
    "                   into; the TPM_PATH environment variable can be used\n"
    "                   instead of dir option;\n"
    "                   mode allows a user to set the file mode bits of the state files;\n"
    "                   the default mode is 0640;\n"
    "-r|--runas <user>: change to the given user\n"
#ifdef WITH_VTPM_PROXY
    "--vtpm-proxy     : spawn a Linux vTPM proxy driver device and read TPM\n"
#endif
    "                   command from its anonymous file descriptor\n"
    "--locality [reject-locality-4][,allow-set-locality]\n"
    "                 : reject-locality-4: reject any command in locality 4\n"
    "                   allow-set-locality: accept SetLocality command\n"
    "--flags [not-need-init][,startup-clear|startup-state|startup-deactivated|startup-none][,disable-auto-shutdown]\n"
    "                 : not-need-init: commands can be sent without needing to\n"
    "                   send an INIT via control channel; not needed when using\n"
    "                   --vtpm-proxy\n"
    "                   startup-...: send Startup command with this type;\n"
    "                   when --vtpm-proxy is used, startup-clear is used\n"
    "                   disable-auto-shutdown disables automatic sending of\n"
    "                   TPM2_Shutdown before TPM 2 reset or swtpm termination;\n"
    "--tpm2           : choose TPM2 functionality\n"
#ifdef WITH_SECCOMP
# ifndef SCMP_ACT_LOG
    "--seccomp action=none|kill\n"
# else
    "--seccomp action=none|kill|log\n"
# endif
    "                 : Choose the action of the seccomp profile when a\n"
    "                   blacklisted syscall is executed; default is kill\n"
#endif
    "--migration [incoming][,release-lock-outgoing]\n"
    "                 : Incoming migration will defer locking of NVRAM storage\n"
    "                   Release-lock-outgoing will release the NVRAM lock on\n"
    "                   outgoing migration\n"
    "--print-capabilites\n"
    "                 : print capabilities and terminate\n"
    "--print-states\n"
    "                 : print existing TPM states and terminate\n"
    "-h|--help        : display this help screen and terminate\n"
    "\n",
    prgname, iface);
}

static void swtpm_cleanup(struct ctrlchannel *cc)
{
    pidfile_remove();
    ctrlchannel_free(cc);
    log_global_free();
    tpmstate_global_free();
    SWTPM_NVRAM_Shutdown();
}

#ifdef WITH_VTPM_PROXY
static int swtpm_chardev_create_vtpm_proxy(struct mainLoopParams *mlp,
                                           bool *need_init_cmd) {
    struct vtpm_proxy_new_dev vtpm_new_dev = {
        .flags = 0,
    };
    int _errno;

    if (mlp->tpmversion == TPMLIB_TPM_VERSION_2)
        vtpm_new_dev.flags = VTPM_PROXY_FLAG_TPM2;

    /* Will be adjusted for TPM 2 */
    mlp->startupType = TPM_ST_CLEAR;
    *need_init_cmd = false;

    if (mlp->fd >= 0) {
        logprintf(STDERR_FILENO,
                  "Cannot use vTPM proxy with a provided device.\n");
        return -1;
    }

    if (create_vtpm_proxy(&vtpm_new_dev, &_errno))
        return -1;

    mlp->fd = vtpm_new_dev.fd;

    mlp->flags |= MAIN_LOOP_FLAG_TERMINATE | MAIN_LOOP_FLAG_USE_FD;
    SWTPM_IO_SetSocketFD(mlp->fd);

    fprintf(stdout, "New TPM device: /dev/tpm%u (major/minor = %u/%u)\n",
            vtpm_new_dev.tpm_num,
            vtpm_new_dev.major, vtpm_new_dev.minor);
    mlp->locality_flags |= LOCALITY_FLAG_ALLOW_SETLOCALITY;

    return 0;
}
#endif

int swtpm_chardev_main(int argc, char **argv, const char *prgname, const char *iface)
{
    TPM_RESULT rc = 0;
    int daemonize = FALSE;
    int opt, longindex, ret;
    struct stat statbuf;
    struct mainLoopParams mlp = {
        .cc = NULL,
        .fd = -1,
        .flags = 0,
        .locality_flags = 0,
        .tpmversion = TPMLIB_TPM_VERSION_1_2,
        .startupType = _TPM_ST_NONE,
        .lastCommand = TPM_ORDINAL_NONE,
        .disable_auto_shutdown = false,
        .incoming_migration = false,
        .nvram_locked = false,
    };
    unsigned long val;
    char *end_ptr;
    char *keydata = NULL;
    char *migkeydata = NULL;
    char *logdata = NULL;
    char *piddata = NULL;
    char *localitydata = NULL;
    char *tpmstatedata = NULL;
    char *ctrlchdata = NULL;
    char *flagsdata = NULL;
    char *seccompdata = NULL;
    char *migrationdata = NULL;
    char *runas = NULL;
#ifdef WITH_VTPM_PROXY
    bool use_vtpm_proxy = false;
#endif
#ifdef DEBUG
    time_t              start_time;
#endif
    bool need_init_cmd = true;
    unsigned int seccomp_action;
    bool printcapabilities = false;
    bool printstates = false;
    static struct option longopts[] = {
        {"daemon"    ,       no_argument, 0, 'd'},
        {"help"      ,       no_argument, 0, 'h'},
        {"chardev"   , required_argument, 0, 'c'},
        {"fd"        , required_argument, 0, 'f'},
        {"runas"     , required_argument, 0, 'r'},
        {"locality"  , required_argument, 0, 'L'},
        {"log"       , required_argument, 0, 'l'},
        {"key"       , required_argument, 0, 'k'},
        {"migration-key", required_argument, 0, 'K'},
        {"pid"       , required_argument, 0, 'P'},
        {"tpmstate"  , required_argument, 0, 's'},
        {"ctrl"      , required_argument, 0, 'C'},
        {"flags"     , required_argument, 0, 'F'},
#ifdef WITH_VTPM_PROXY
        {"vtpm-proxy",       no_argument, 0, 'v'},
#endif
        {"tpm2"      ,       no_argument, 0, '2'},
#ifdef WITH_SECCOMP
        {"seccomp"   , required_argument, 0, 'S'},
#endif
        {"migration" , required_argument, 0, 'i'},
        {"print-capabilities"
                     ,       no_argument, 0, 'a'},
        {"print-states",     no_argument, 0, 'e'},
        {NULL        , 0                , 0, 0  },
    };

    log_set_prefix("swtpm: ");

    while (TRUE) {
        opt = getopt_long(argc, argv, "dhc:f:r:", longopts, &longindex);

        if (opt == -1)
            break;

        switch (opt) {
        case 'd':
            daemonize = TRUE;
            if (daemonize_prep() == -1) {
                logprintf(STDERR_FILENO,
                          "Could not prepare to daemonize: %s\n", strerror(errno));
                exit(EXIT_FAILURE);
            }
            break;

        case 'c':
            if (mlp.fd >= 0)
                continue;

            mlp.fd = open(optarg, O_RDWR);
            if (mlp.fd < 0) {
                logprintf(STDERR_FILENO, "Cannot open %s: %s\n",
                          optarg, strerror(errno));
                exit(EXIT_FAILURE);
            }
            mlp.flags |= MAIN_LOOP_FLAG_TERMINATE | MAIN_LOOP_FLAG_USE_FD;
            SWTPM_IO_SetSocketFD(mlp.fd);
            break;

        case 'f':
            if (mlp.fd >= 0)
                continue;

            errno = 0;
            val = strtoul(optarg, &end_ptr, 10);
            if (val != (unsigned int)val || errno || end_ptr[0] != '\0') {
                logprintf(STDERR_FILENO,
                          "Cannot parse character device file descriptor.\n");
                exit(EXIT_FAILURE);
            }
            mlp.fd = val;
            if (fstat(mlp.fd, &statbuf) != 0) {
                logprintf(STDERR_FILENO, "Cannot stat file descriptor: %s\n",
                          strerror(errno));
                exit(EXIT_FAILURE);
            }
            /*
             * test for wrong file types; anonymous fd's do not seem to be any of the wrong
             * ones but are also not character devices
             */
            if (S_ISREG(statbuf.st_mode) || S_ISDIR(statbuf.st_mode) || S_ISBLK(statbuf.st_mode)
                || S_ISLNK(statbuf.st_mode)) {
                logprintf(STDERR_FILENO,
                          "Given file descriptor type is not supported.\n");
                exit(EXIT_FAILURE);
            }
            mlp.flags |= MAIN_LOOP_FLAG_TERMINATE | MAIN_LOOP_FLAG_USE_FD;
            SWTPM_IO_SetSocketFD(mlp.fd);

            break;

        case 'k':
            keydata = optarg;
            break;

        case 'K':
            migkeydata = optarg;
            break;

        case 'l':
            logdata = optarg;
            break;

        case 'P':
            piddata = optarg;
            break;

        case 's':
            tpmstatedata = optarg;
            break;

        case 'C':
            ctrlchdata = optarg;
            break;

        case 'L':
            localitydata = optarg;
            break;

        case 'F':
            flagsdata = optarg;
            break;

        case '2':
            mlp.tpmversion = TPMLIB_TPM_VERSION_2;
            break;

        case 'h':
            usage(stdout, prgname, iface);
            exit(EXIT_SUCCESS);

        case 'a':
            printcapabilities = true;
            break;

        case 'e':
            printstates = true;
            break;

        case 'r':
            runas = optarg;
            break;

#ifdef WITH_VTPM_PROXY
        case 'v':
            use_vtpm_proxy = true;
            break;
#endif

        case 'S':
            seccompdata = optarg;
            break;

        case 'i':
            migrationdata = optarg;
            break;

        default:
            usage(stderr, prgname, iface);
            exit(EXIT_FAILURE);
        }
    }

    if (optind < argc) {
        logprintf(STDERR_FILENO,
                  "Unknown parameter '%s'\n", argv[optind]);
        exit(EXIT_FAILURE);
    }

    /* change process ownership before accessing files */
    if (runas) {
        if (change_process_owner(runas) < 0)
            exit(EXIT_FAILURE);
    }

    if (handle_log_options(logdata) < 0)
        exit(EXIT_FAILURE);

    if (handle_locality_options(localitydata, &mlp.locality_flags) < 0)
        exit(EXIT_FAILURE);

#ifdef WITH_VTPM_PROXY
    if (use_vtpm_proxy) {
        if (swtpm_chardev_create_vtpm_proxy(&mlp, &need_init_cmd) < 0)
            exit(EXIT_FAILURE);
    }
#endif

    if (printcapabilities) {
        /*
         * Choose the TPM version so that getting/setting buffer size works.
         * Ignore failure, for backward compatibility when TPM 1.2 is disabled.
         */
        ret = capabilities_print_json(false, mlp.tpmversion);
        exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
    }

    if (tpmlib_choose_tpm_version(mlp.tpmversion) != TPM_SUCCESS)
        exit(EXIT_FAILURE);

    tpmstate_set_version(mlp.tpmversion);

    if (printstates) {
        if (handle_tpmstate_options(tpmstatedata) < 0)
            exit(EXIT_FAILURE);
        if (tpmstatedata == NULL) {
            logprintf(STDERR_FILENO,
                      "Error: --tpmstate option is required for --print-states\n");
            exit(EXIT_FAILURE);
        }
        ret = SWTPM_NVRAM_PrintJson();
        if (ret)
            goto exit_failure;
        else
            goto exit_success;
    }

    if (mlp.fd < 0) {
        logprintf(STDERR_FILENO,
                  "Error: Missing character device or file descriptor\n");
        exit(EXIT_FAILURE);
    } else if (mlp.fd < 3) {
        /* no std{in,out,err} */
        logprintf(STDERR_FILENO,
            "Error: Cannot accept file descriptors with values 0, 1, or 2\n");
        exit(EXIT_FAILURE);
    }

    if (handle_ctrlchannel_options(ctrlchdata, &mlp.cc) < 0) {
        goto exit_failure;
    }

    if (handle_key_options(keydata) < 0 ||
        handle_migration_key_options(migkeydata) < 0 ||
        handle_pid_options(piddata) < 0 ||
        handle_tpmstate_options(tpmstatedata) < 0 ||
        handle_seccomp_options(seccompdata, &seccomp_action) < 0 ||
        handle_flags_options(flagsdata, &need_init_cmd,
                             &mlp.startupType, &mlp.disable_auto_shutdown) < 0 ||
        handle_migration_options(migrationdata, &mlp.incoming_migration,
                                 &mlp.release_lock_outgoing) < 0) {
        goto exit_failure;
    }

    if (pidfile_write(getpid()) < 0) {
        goto exit_failure;
    }

    setvbuf(stdout, 0, _IONBF, 0);      /* output may be going through pipe */

#ifdef DEBUG
    /* initialization */
    start_time = time(NULL);
#endif

    TPM_DEBUG("main: Initializing TPM at %s", ctime(&start_time));

    tpmlib_debug_libtpms_parameters(mlp.tpmversion);

    if ((rc = tpmlib_register_callbacks(&callbacks)))
        goto error_no_tpm;

    if (!need_init_cmd) {
        mlp.nvram_locked = !mlp.incoming_migration;

        if ((rc = tpmlib_start(0, mlp.tpmversion, mlp.nvram_locked)))
            goto error_no_tpm;
        tpm_running = true;
    }

    if (install_sighandlers(notify_fd, sigterm_handler) < 0)
        goto error_no_sighandlers;

    if (create_seccomp_profile(false, seccomp_action) < 0)
        goto error_seccomp_profile;

    mlp.flags |= MAIN_LOOP_FLAG_USE_FD | MAIN_LOOP_FLAG_KEEP_CONNECTION | \
      MAIN_LOOP_FLAG_END_ON_HUP;

    if (daemonize) {
        daemonize_finish();
    }

    rc = mainLoop(&mlp, notify_fd[0]);

error_seccomp_profile:
    uninstall_sighandlers();

error_no_sighandlers:
    TPMLIB_Terminate();

error_no_tpm:
    close(notify_fd[0]);
    notify_fd[0] = -1;
    close(notify_fd[1]);
    notify_fd[1] = -1;

    swtpm_cleanup(mlp.cc);

    /* Fatal initialization errors cause the program to abort */
    if (rc == 0) {
        exit(EXIT_SUCCESS);
    }
    else {
        TPM_DEBUG("main: TPM initialization failure %08x, exiting\n", rc);
        exit(EXIT_FAILURE);
    }

exit_failure:
    swtpm_cleanup(mlp.cc);

    exit(EXIT_FAILURE);

exit_success:
    swtpm_cleanup(mlp.cc);

    exit(EXIT_SUCCESS);
}

1	/********************************************************************************/
2	/* */
3	/* TPM Main Program */
4	/* Written by Ken Goldman, Stefan Berger */
5	/* IBM Thomas J. Watson Research Center */
6	/* */
7	/* (c) Copyright IBM Corporation 2006, 2010, 2015, 2016, 2019 */
8	/* */
9	/* All rights reserved. */
10	/* */
11	/* Redistribution and use in source and binary forms, with or without */
12	/* modification, are permitted provided that the following conditions are */
13	/* met: */
14	/* */
15	/* Redistributions of source code must retain the above copyright notice, */
16	/* this list of conditions and the following disclaimer. */
17	/* */
18	/* Redistributions in binary form must reproduce the above copyright */
19	/* notice, this list of conditions and the following disclaimer in the */
20	/* documentation and/or other materials provided with the distribution. */
21	/* */
22	/* Neither the names of the IBM Corporation nor the names of its */
23	/* contributors may be used to endorse or promote products derived from */
24	/* this software without specific prior written permission. */
25	/* */
26	/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
27	/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
28	/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */
29	/* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
30	/* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
31	/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
32	/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */
33	/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */
34	/* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
35	/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */
36	/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
37	/********************************************************************************/
38
39	#include <config.h>
40
41	#include <stdlib.h>
42	#include <stdbool.h>
43	#include <stdio.h>
44	#include <string.h>
45	#include <time.h>
46	#include <getopt.h>
47	#include <errno.h>
48	#include <sys/stat.h>
49	#include <fcntl.h>
50	#include <sys/socket.h>
51	#include <sys/ioctl.h>
52
53	#include <libtpms/tpm_error.h>
54	#include <libtpms/tpm_library.h>
55	#include <libtpms/tpm_memory.h>
56
57	#include "main.h"
58	#include "swtpm_debug.h"
59	#include "swtpm_io.h"
60	#include "swtpm_nvstore.h"
61	#include "common.h"
62	#include "locality.h"
63	#include "logging.h"
64	#include "pidfile.h"
65	#include "tpmlib.h"
66	#include "utils.h"
67	#include "ctrlchannel.h"
68	#include "mainloop.h"
69	#ifdef WITH_VTPM_PROXY
70	#include "vtpm_proxy.h"
71	#endif
72	#include "tpmstate.h"
73	#include "daemonize.h"
74	#include "seccomp_profile.h"
75	#include "options.h"
76	#include "capabilities.h"
77
78	/* local variables */
79	static int notify_fd[2] = {-1, -1};
80
81	static struct libtpms_callbacks callbacks = {
82	.sizeOfStruct = sizeof(struct libtpms_callbacks),
83	.tpm_nvram_init = SWTPM_NVRAM_Init,
84	.tpm_nvram_loaddata = SWTPM_NVRAM_LoadData,
85	.tpm_nvram_storedata = SWTPM_NVRAM_StoreData,
86	.tpm_nvram_deletename = SWTPM_NVRAM_DeleteName,
87	.tpm_io_init = NULL,
88	.tpm_io_getlocality = mainloop_cb_get_locality,
89	};
90
91	static void sigterm_handler(int sig __attribute__((unused)))
92	{
93	TPM_DEBUG("Terminating...\n");
94	if (write(notify_fd[1], "T", 1) < 0) {	×
95	logprintf(STDERR_FILENO, "Error: sigterm notification failed: %s\n",	×
96	strerror(errno));	×
97	}
98	mainloop_terminate = true;	×
99	}
100
101	#ifdef WITH_VTPM_PROXY
102	static int create_vtpm_proxy(struct vtpm_proxy_new_dev *vtpm_new_dev,	2✔
103	int *_errno)
104	{
105	int fd, n, ret = 0;	2✔
106
107	fd = open("/dev/vtpmx", O_RDWR);	2✔
108	if (fd < 0) {	2✔
109	logprintf(STDERR_FILENO, "Could not open /dev/vtpmx: %s\n",	×
110	strerror(errno));	×
111	*_errno = errno;	×
112	return -1;	×
113	}
114
115	n = ioctl(fd, VTPM_PROXY_IOC_NEW_DEV, vtpm_new_dev);	2✔
116	if (n) {	2✔
117	logprintf(STDERR_FILENO, "Ioctl to create vtpm proxy failed: %s\n",	×
118	strerror(errno));	×
119	*_errno = errno;	×
120	ret = -1;	×
121	}
122	close(fd);	2✔
123
124	return ret;	2✔
125	}
126	#endif
127
128	static void usage(FILE file, const char prgname, const char *iface)
129	{
130	fprintf(file,	4✔
131	"Usage: %s %s [options]\n"
132	"\n"
133	"The following options are supported:\n"
134	"\n"
135	"-c\|--chardev <device>\n"
136	" : use the given character device\n"
137	"-f\|--fd <fd> : use the given character device file descriptor\n"
138	"-d\|--daemon : daemonize the TPM\n"
139	"--ctrl type=[unixio\|tcp][,path=<path>][,port=<port>[,bindaddr=address[,ifname=ifname]]][,fd=<filedescriptor\|clientfd=<filedescriptor>][,mode=0...][,uid=uid][,gid=gid]\n"
140	" : TPM control channel using either UnixIO or TCP sockets;\n"
141	" the path is only valid for Unixio channels; the port must\n"
142	" be given in case the type is TCP; the TCP socket is bound\n"
143	" to 127.0.0.1 by default and other bind addresses can be\n"
144	" given with the bindaddr parameter; if fd is provided,\n"
145	" it will be treated as a server socket and used for \n"
146	" accepting client connections; if clientfd is provided,\n"
147	" it will be treaded as client connection;\n"
148	" NOTE: fd and clientfd are mutually exclusive and \n"
149	" clientfd is only valid for UnixIO channels\n"
150	" mode allows a user to set the file mode bits of a Unixio socket;\n"
151	" the value must be given in octal number format\n"
152	" uid and gid set the ownership of the Unixio socket's file;\n"
153	"--migration-key file=<path>\|fd=<fd>[,mode=aes-cbc\|aes-256-cbc][,format=hex\|binary][,remove=[true\|false]]\n"
154	" : use an AES key for the encryption of the TPM's state\n"
155	" when it is retrieved from the TPM via ioctls;\n"
156	" Setting this key ensures that the TPM's state will always\n"
157	" be encrypted when migrated\n"
158	"--migration-key pwdfile=<path>\|pwdfd=<fd>[,mode=aes-cbc\|aes-256-cbc][,remove=[true\|false]][,kdf=sha512\|pbkdf2]\n"
159	" : provide a passphrase in a file; the AES key will be\n"
160	" derived from this passphrase; default kdf is PBKDF2\n"
161	"--log file=<path>\|fd=<filedescriptor>[,level=n][,prefix=<prefix>][,truncate]\n"
162	" : write the TPM's log into the given file rather than\n"
163	" to the console; provide '-' for path to avoid logging\n"
164	" log level 5 and higher will enable libtpms logging;\n"
165	" all logged output will be prefixed with prefix;\n"
166	" the log file can be reset (truncate)\n"
167	"--key file=<path>\|fd=<fd>[,mode=aes-cbc\|aes-256-cbc][,format=hex\|binary][,remove=[true\|false]]\n"
168	" : use an AES key for the encryption of the TPM's state\n"
169	" files; use the given mode for the block encryption;\n"
170	" the key is to be provided as a hex string or in binary\n"
171	" format; the keyfile can be automatically removed using\n"
172	" the remove parameter\n"
173	"--key pwdfile=<path>\|pwdfd=<fd>[,mode=aes-cbc\|aes-256-cbc][,remove=[true\|false]][,kdf=sha512\|pbkdf2]\n"
174	" : provide a passphrase in a file; the AES key will be\n"
175	" derived from this passphrase; default kdf is PBKDF2\n"
176	"--pid file=<path>\|fd=<filedescriptor>\n"
177	" : write the process ID into the given file\n"
178	"--tpmstate dir=<dir>[,mode=0...]\|backend-uri=<uri>\n"
179	" : set the directory or uri where the TPM's state will be written\n"
180	" into; the TPM_PATH environment variable can be used\n"
181	" instead of dir option;\n"
182	" mode allows a user to set the file mode bits of the state files;\n"
183	" the default mode is 0640;\n"
184	"-r\|--runas <user>: change to the given user\n"
185	#ifdef WITH_VTPM_PROXY
186	"--vtpm-proxy : spawn a Linux vTPM proxy driver device and read TPM\n"
187	#endif
188	" command from its anonymous file descriptor\n"
189	"--locality [reject-locality-4][,allow-set-locality]\n"
190	" : reject-locality-4: reject any command in locality 4\n"
191	" allow-set-locality: accept SetLocality command\n"
192	"--flags [not-need-init][,startup-clear\|startup-state\|startup-deactivated\|startup-none][,disable-auto-shutdown]\n"
193	" : not-need-init: commands can be sent without needing to\n"
194	" send an INIT via control channel; not needed when using\n"
195	" --vtpm-proxy\n"
196	" startup-...: send Startup command with this type;\n"
197	" when --vtpm-proxy is used, startup-clear is used\n"
198	" disable-auto-shutdown disables automatic sending of\n"
199	" TPM2_Shutdown before TPM 2 reset or swtpm termination;\n"
200	"--tpm2 : choose TPM2 functionality\n"
201	#ifdef WITH_SECCOMP
202	# ifndef SCMP_ACT_LOG
203	"--seccomp action=none\|kill\n"
204	# else
205	"--seccomp action=none\|kill\|log\n"
206	# endif
207	" : Choose the action of the seccomp profile when a\n"
208	" blacklisted syscall is executed; default is kill\n"
209	#endif
210	"--migration [incoming][,release-lock-outgoing]\n"
211	" : Incoming migration will defer locking of NVRAM storage\n"
212	" Release-lock-outgoing will release the NVRAM lock on\n"
213	" outgoing migration\n"
214	"--print-capabilites\n"
215	" : print capabilities and terminate\n"
216	"--print-states\n"
217	" : print existing TPM states and terminate\n"
218	"-h\|--help : display this help screen and terminate\n"
219	"\n",
220	prgname, iface);
221	}
222
223	static void swtpm_cleanup(struct ctrlchannel *cc)	7✔
224	{
225	pidfile_remove();	7✔
226	ctrlchannel_free(cc);	7✔
227	log_global_free();	7✔
228	tpmstate_global_free();	7✔
229	SWTPM_NVRAM_Shutdown();	7✔
230	}	7✔
231
232	#ifdef WITH_VTPM_PROXY
233	static int swtpm_chardev_create_vtpm_proxy(struct mainLoopParams *mlp,	2✔
234	bool *need_init_cmd) {
235	struct vtpm_proxy_new_dev vtpm_new_dev = {	2✔
236	.flags = 0,
237	};
238	int _errno;
239
240	if (mlp->tpmversion == TPMLIB_TPM_VERSION_2)	2✔
241	vtpm_new_dev.flags = VTPM_PROXY_FLAG_TPM2;	1✔
242
243	/* Will be adjusted for TPM 2 */
244	mlp->startupType = TPM_ST_CLEAR;	2✔
245	*need_init_cmd = false;	2✔
246
247	if (mlp->fd >= 0) {	2✔
248	logprintf(STDERR_FILENO,	×
249	"Cannot use vTPM proxy with a provided device.\n");
250	return -1;	×
251	}
252
253	if (create_vtpm_proxy(&vtpm_new_dev, &_errno))	2✔
254	return -1;
255
256	mlp->fd = vtpm_new_dev.fd;	2✔
257
258	mlp->flags \|= MAIN_LOOP_FLAG_TERMINATE \| MAIN_LOOP_FLAG_USE_FD;	2✔
259	SWTPM_IO_SetSocketFD(mlp->fd);	2✔
260
261	fprintf(stdout, "New TPM device: /dev/tpm%u (major/minor = %u/%u)\n",	4✔
262	vtpm_new_dev.tpm_num,
263	vtpm_new_dev.major, vtpm_new_dev.minor);
264	mlp->locality_flags \|= LOCALITY_FLAG_ALLOW_SETLOCALITY;	2✔
265
266	return 0;	2✔
267	}
268	#endif
269
270	int swtpm_chardev_main(int argc, char *argv, const char prgname, const char *iface)	12✔
271	{
272	TPM_RESULT rc = 0;	12✔
273	int daemonize = FALSE;	12✔
274	int opt, longindex, ret;
275	struct stat statbuf;
276	struct mainLoopParams mlp = {	12✔
277	.cc = NULL,
278	.fd = -1,
279	.flags = 0,
280	.locality_flags = 0,
281	.tpmversion = TPMLIB_TPM_VERSION_1_2,
282	.startupType = _TPM_ST_NONE,
283	.lastCommand = TPM_ORDINAL_NONE,
284	.disable_auto_shutdown = false,
285	.incoming_migration = false,
286	.nvram_locked = false,
287	};
288	unsigned long val;
289	char *end_ptr;
290	char *keydata = NULL;	12✔
291	char *migkeydata = NULL;	12✔
292	char *logdata = NULL;	12✔
293	char *piddata = NULL;	12✔
294	char *localitydata = NULL;	12✔
295	char *tpmstatedata = NULL;	12✔
296	char *ctrlchdata = NULL;	12✔
297	char *flagsdata = NULL;	12✔
298	char *seccompdata = NULL;	12✔
299	char *migrationdata = NULL;	12✔
300	char *runas = NULL;	12✔
301	#ifdef WITH_VTPM_PROXY
302	bool use_vtpm_proxy = false;	12✔
303	#endif
304	#ifdef DEBUG
305	time_t start_time;
306	#endif
307	bool need_init_cmd = true;	12✔
308	unsigned int seccomp_action;
309	bool printcapabilities = false;	12✔
310	bool printstates = false;	12✔
311	static struct option longopts[] = {
312	{"daemon" , no_argument, 0, 'd'},
313	{"help" , no_argument, 0, 'h'},
314	{"chardev" , required_argument, 0, 'c'},
315	{"fd" , required_argument, 0, 'f'},
316	{"runas" , required_argument, 0, 'r'},
317	{"locality" , required_argument, 0, 'L'},
318	{"log" , required_argument, 0, 'l'},
319	{"key" , required_argument, 0, 'k'},
320	{"migration-key", required_argument, 0, 'K'},
321	{"pid" , required_argument, 0, 'P'},
322	{"tpmstate" , required_argument, 0, 's'},
323	{"ctrl" , required_argument, 0, 'C'},
324	{"flags" , required_argument, 0, 'F'},
325	#ifdef WITH_VTPM_PROXY
326	{"vtpm-proxy", no_argument, 0, 'v'},
327	#endif
328	{"tpm2" , no_argument, 0, '2'},
329	#ifdef WITH_SECCOMP
330	{"seccomp" , required_argument, 0, 'S'},
331	#endif
332	{"migration" , required_argument, 0, 'i'},
333	{"print-capabilities"
334	, no_argument, 0, 'a'},
335	{"print-states", no_argument, 0, 'e'},
336	{NULL , 0 , 0, 0 },
337	};
338
339	log_set_prefix("swtpm: ");	12✔
340
341	while (TRUE) {
342	opt = getopt_long(argc, argv, "dhc:f:r:", longopts, &longindex);	44✔
343
344	if (opt == -1)	44✔
345	break;
346
347	switch (opt) {	36✔
348	case 'd':	1✔
349	daemonize = TRUE;	1✔
350	if (daemonize_prep() == -1) {	1✔
351	logprintf(STDERR_FILENO,	×
352	"Could not prepare to daemonize: %s\n", strerror(errno));	×
353	exit(EXIT_FAILURE);	×
354	}
355	break;
356
357	case 'c':	×
358	if (mlp.fd >= 0)	×
359	continue;	×
360
361	mlp.fd = open(optarg, O_RDWR);	×
362	if (mlp.fd < 0) {	×
363	logprintf(STDERR_FILENO, "Cannot open %s: %s\n",	×
364	optarg, strerror(errno));	×
365	exit(EXIT_FAILURE);	×
366	}
367	mlp.flags \|= MAIN_LOOP_FLAG_TERMINATE \| MAIN_LOOP_FLAG_USE_FD;	×
368	SWTPM_IO_SetSocketFD(mlp.fd);	×
369	break;	×
370
371	case 'f':	3✔
372	if (mlp.fd >= 0)	3✔
373	continue;	×
374
375	errno = 0;	3✔
376	val = strtoul(optarg, &end_ptr, 10);	3✔
377	if (val != (unsigned int)val \|\| errno \|\| end_ptr[0] != '\0') {	3✔
378	logprintf(STDERR_FILENO,	×
379	"Cannot parse character device file descriptor.\n");
380	exit(EXIT_FAILURE);	×
381	}
382	mlp.fd = val;	3✔
383	if (fstat(mlp.fd, &statbuf) != 0) {	6✔
384	logprintf(STDERR_FILENO, "Cannot stat file descriptor: %s\n",	×
385	strerror(errno));
386	exit(EXIT_FAILURE);	×
387	}
388	/*
389	* test for wrong file types; anonymous fd's do not seem to be any of the wrong
390	* ones but are also not character devices
391	*/
392	if (S_ISREG(statbuf.st_mode) \|\| S_ISDIR(statbuf.st_mode) \|\| S_ISBLK(statbuf.st_mode)	3✔
393	\|\| S_ISLNK(statbuf.st_mode)) {	3✔
394	logprintf(STDERR_FILENO,	×
395	"Given file descriptor type is not supported.\n");
396	exit(EXIT_FAILURE);	×
397	}
398	mlp.flags \|= MAIN_LOOP_FLAG_TERMINATE \| MAIN_LOOP_FLAG_USE_FD;	3✔
399	SWTPM_IO_SetSocketFD(mlp.fd);	3✔
400
401	break;	3✔
402
403	case 'k':	×
404	keydata = optarg;	×
405	break;	×
406
407	case 'K':	×
408	migkeydata = optarg;	×
409	break;	×
410
411	case 'l':	1✔
412	logdata = optarg;	1✔
413	break;	1✔
414
415	case 'P':	5✔
416	piddata = optarg;	5✔
417	break;	5✔
418
419	case 's':	7✔
420	tpmstatedata = optarg;	7✔
421	break;	7✔
422
423	case 'C':	5✔
424	ctrlchdata = optarg;	5✔
425	break;	5✔
426
427	case 'L':	×
428	localitydata = optarg;	×
429	break;	×
430
431	case 'F':	1✔
432	flagsdata = optarg;	1✔
433	break;	1✔
434
435	case '2':	4✔
436	mlp.tpmversion = TPMLIB_TPM_VERSION_2;	4✔
437	break;	4✔
438
439	case 'h':	4✔
440	usage(stdout, prgname, iface);	8✔
441	exit(EXIT_SUCCESS);	4✔
442
443	case 'a':
444	printcapabilities = true;
445	break;
446
447	case 'e':	2✔
448	printstates = true;	2✔
449	break;	2✔
450
451	case 'r':	×
452	runas = optarg;	×
453	break;	×
454
455	#ifdef WITH_VTPM_PROXY
456	case 'v':	2✔
457	use_vtpm_proxy = true;	2✔
458	break;	2✔
459	#endif
460
461	case 'S':	×
462	seccompdata = optarg;	×
463	break;	×
464
465	case 'i':	×
466	migrationdata = optarg;	×
467	break;	×
468
469	default:	×
470	usage(stderr, prgname, iface);	×
471	exit(EXIT_FAILURE);	×
472	}
473	}
474
475	if (optind < argc) {	8✔
476	logprintf(STDERR_FILENO,	×
477	"Unknown parameter '%s'\n", argv[optind]);	×
478	exit(EXIT_FAILURE);	×
479	}
480
481	/* change process ownership before accessing files */
482	if (runas) {	8✔
483	if (change_process_owner(runas) < 0)	×
484	exit(EXIT_FAILURE);	×
485	}
486
487	if (handle_log_options(logdata) < 0)	8✔
488	exit(EXIT_FAILURE);	×
489
490	if (handle_locality_options(localitydata, &mlp.locality_flags) < 0)	8✔
491	exit(EXIT_FAILURE);	×
492
493	#ifdef WITH_VTPM_PROXY
494	if (use_vtpm_proxy) {	8✔
495	if (swtpm_chardev_create_vtpm_proxy(&mlp, &need_init_cmd) < 0)	2✔
496	exit(EXIT_FAILURE);	×
497	}
498	#endif
499
500	if (printcapabilities) {	8✔
501	/*
502	* Choose the TPM version so that getting/setting buffer size works.
503	* Ignore failure, for backward compatibility when TPM 1.2 is disabled.
504	*/
505	ret = capabilities_print_json(false, mlp.tpmversion);	1✔
506	exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);	1✔
507	}
508
509	if (tpmlib_choose_tpm_version(mlp.tpmversion) != TPM_SUCCESS)	7✔
510	exit(EXIT_FAILURE);	×
511
512	tpmstate_set_version(mlp.tpmversion);	7✔
513
514	if (printstates) {	7✔
515	if (handle_tpmstate_options(tpmstatedata) < 0)	2✔
516	exit(EXIT_FAILURE);	×
517	if (tpmstatedata == NULL) {	2✔
518	logprintf(STDERR_FILENO,	×
519	"Error: --tpmstate option is required for --print-states\n");
520	exit(EXIT_FAILURE);	×
521	}
522	ret = SWTPM_NVRAM_PrintJson();	2✔
523	if (ret)	2✔
524	goto exit_failure;
525	else
526	goto exit_success;
527	}
528
529	if (mlp.fd < 0) {	5✔
530	logprintf(STDERR_FILENO,	×
531	"Error: Missing character device or file descriptor\n");
532	exit(EXIT_FAILURE);	×
533	} else if (mlp.fd < 3) {	5✔
534	/* no std{in,out,err} */
535	logprintf(STDERR_FILENO,	×
536	"Error: Cannot accept file descriptors with values 0, 1, or 2\n");
537	exit(EXIT_FAILURE);	×
538	}
539
540	if (handle_ctrlchannel_options(ctrlchdata, &mlp.cc) < 0) {	5✔
541	goto exit_failure;
542	}
543
544	if (handle_key_options(keydata) < 0 \|\|	10✔
545	handle_migration_key_options(migkeydata) < 0 \|\|	10✔
546	handle_pid_options(piddata) < 0 \|\|	10✔
547	handle_tpmstate_options(tpmstatedata) < 0 \|\|	10✔
548	handle_seccomp_options(seccompdata, &seccomp_action) < 0 \|\|	10✔
549	handle_flags_options(flagsdata, &need_init_cmd,	5✔
550	&mlp.startupType, &mlp.disable_auto_shutdown) < 0 \|\|	5✔
551	handle_migration_options(migrationdata, &mlp.incoming_migration,	5✔
552	&mlp.release_lock_outgoing) < 0) {
553	goto exit_failure;
554	}
555
556	if (pidfile_write(getpid()) < 0) {	5✔
557	goto exit_failure;
558	}
559
560	setvbuf(stdout, 0, _IONBF, 0); /* output may be going through pipe */	5✔
561
562	#ifdef DEBUG
563	/* initialization */
564	start_time = time(NULL);
565	#endif
566
567	TPM_DEBUG("main: Initializing TPM at %s", ctime(&start_time));
568
569	tpmlib_debug_libtpms_parameters(mlp.tpmversion);	5✔
570
571	if ((rc = tpmlib_register_callbacks(&callbacks)))	5✔
572	goto error_no_tpm;
573
574	if (!need_init_cmd) {	5✔
575	mlp.nvram_locked = !mlp.incoming_migration;	2✔
576
577	if ((rc = tpmlib_start(0, mlp.tpmversion, mlp.nvram_locked)))	2✔
578	goto error_no_tpm;
579	tpm_running = true;	2✔
580	}
581
582	if (install_sighandlers(notify_fd, sigterm_handler) < 0)	5✔
583	goto error_no_sighandlers;
584
585	if (create_seccomp_profile(false, seccomp_action) < 0)	5✔
586	goto error_seccomp_profile;
587
588	mlp.flags \|= MAIN_LOOP_FLAG_USE_FD \| MAIN_LOOP_FLAG_KEEP_CONNECTION \| \	5✔
589	MAIN_LOOP_FLAG_END_ON_HUP;
590
591	if (daemonize) {	5✔
592	daemonize_finish();	1✔
593	}
594
595	rc = mainLoop(&mlp, notify_fd[0]);	5✔
596
597	error_seccomp_profile:	5✔
598	uninstall_sighandlers();	5✔
599
600	error_no_sighandlers:	5✔
601	TPMLIB_Terminate();	5✔
602
603	error_no_tpm:	5✔
604	close(notify_fd[0]);	5✔
605	notify_fd[0] = -1;	5✔
606	close(notify_fd[1]);	5✔
607	notify_fd[1] = -1;	5✔
608
609	swtpm_cleanup(mlp.cc);	5✔
610
611	/* Fatal initialization errors cause the program to abort */
612	if (rc == 0) {	5✔
613	exit(EXIT_SUCCESS);	5✔
614	}
615	else {
616	TPM_DEBUG("main: TPM initialization failure %08x, exiting\n", rc);
617	exit(EXIT_FAILURE);	×
618	}
619
620	exit_failure:	×
621	swtpm_cleanup(mlp.cc);	×
622
623	exit(EXIT_FAILURE);	×
624
625	exit_success:	2✔
626	swtpm_cleanup(mlp.cc);	2✔
627
628	exit(EXIT_SUCCESS);	2✔
629	}

stefanberger / swtpm / 4027

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous