diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile --- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 +++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 @@ -10,7 +10,7 @@ VERSION_MINOR := 5 VERSION_BUILD := $(shell date +"%s") VERSION_SUFFIX := .1 -SUBDIRS := tpmd tpmd_dev tddl +SUBDIRS := tpmd all: version all-recursive @@ -48,12 +48,12 @@ user_install: user modules_install: modules @$(MAKE) -C tpmd_dev install || exit -1 -DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd +DIRS := . tpm crypto tpmd DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) -DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd +DIRS := . tpmd DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) -DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in +DISTSRC += ./README ./AUTHORS ./ChangeLog DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) dist: $(DISTSRC) diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c --- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 +++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 @@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su case TPM_CAP_PROP_TIS_TIMEOUT: debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); - /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ - return TPM_FAIL; + /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ + UINT32 len = *respSize = 16; + BYTE *ptr = *resp = tpm_malloc(*respSize); + if (ptr == NULL || + tpm_marshal_UINT32(&ptr, &len, 200000) || + tpm_marshal_UINT32(&ptr, &len, 200000) || + tpm_marshal_UINT32(&ptr, &len, 200000) || + tpm_marshal_UINT32(&ptr, &len, 200000)) { + tpm_free(*resp); + return TPM_FAIL; + } + return TPM_SUCCESS; + case TPM_CAP_PROP_STARTUP_EFFECT: debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); @@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su case TPM_CAP_PROP_DURATION: debug("[TPM_CAP_PROP_DURATION]"); - /* TODO: TPM_CAP_PROP_DURATION */ - return TPM_FAIL; + /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ + BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; + *respSize = 16; + *resp = tpm_malloc(*respSize); + memcpy(*resp,dur,16); + case TPM_CAP_PROP_ACTIVE_COUNTER: debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile --- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 +++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 @@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a -Wwrite-strings -Wsign-compare -Wno-multichar #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing +CFLAGS += -I../../../../tools/vtpm_manager/manager LDFLAGS += -lgmp -BINDIR := /usr/sbin/ +BINDIR := /usr/bin/ TPMD := tpmd DIRS := ../tpm ../crypto @@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil OBJS := $(patsubst %.c, %.o, $(SRCS)) OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) +VTPM_BIN := vtpmd + vpath %.c $(strip $(DIRS)) all: $(TPMD) @@ -32,10 +35,8 @@ TPMD_GROUP ?= tss INSTALL ?= install install: $(TPMD) - $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm - $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) - $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) + $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) .PHONY: all clean install diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c --- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 +++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 @@ -32,6 +32,9 @@ #include #include "tpm_emulator_config.h" #include "tpm/tpm_emulator.h" +#include "tpm/tpm_structures.h" +#include "tpm/tpm_marshalling.h" +#include "vtpm_manager.h" #define TPM_DAEMON_NAME "tpmd" #define TPM_CMD_BUF_SIZE 4096 @@ -39,6 +42,24 @@ #define TPM_RANDOM_DEVICE "/dev/urandom" #undef TPM_MKDIRS +#ifdef VTPM_MULTI_VM + #define DEV_BE "/dev/vtpm" + #define DEV_FE "/dev/tpm" +#else + #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" + #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" + #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" + + #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" + #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" + + static char *vtpm_rx_name=NULL; +#endif + + static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; + +#define BUFFER_SIZE 2048 + static volatile int stopflag = 0; static int is_daemon = 0; static int opt_debug = 0; @@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ static uid_t opt_uid = 0; static gid_t opt_gid = 0; static int tpm_startup = 2; +static int vtpm_type = VTPM_TYPE_PVM; +int dmi_id = 0; static int rand_fh; void tpm_log(int priority, const char *fmt, ...) @@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) int tpm_write_to_file(uint8_t *data, size_t data_length) { - int fh; - ssize_t res; - fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); - if (fh < 0) return -1; - while (data_length > 0) { - res = write(fh, data, data_length); - if (res < 0) { - close(fh); - return -1; - } - data_length -= res; - data += res; + int res, out_data_size, in_header_size; + BYTE *ptr, *out_data, *in_header; + UINT32 result, len, in_rsp_size; + UINT16 tag = VTPM_TAG_REQ; + + printf("Saving NVM\n"); + if (vtpm_tx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_tx_fh = open(DEV_FE, O_RDWR); +#else + vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); +#endif + } + + if (vtpm_tx_fh < 0) { + return -1; + } + + // Send request to VTPM Manager to encrypt data +#ifdef VTPM_MUTLI_VM + out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; +#else + out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; +#endif + + out_data = ptr = (BYTE *) malloc(len); + + if (ptr == NULL +#ifndef VTPM_MUTLI_VM + || tpm_marshal_UINT32(&ptr, &len, dmi_id) +#endif + || tpm_marshal_UINT16(&ptr, &len, tag) +#ifdef VTPM_MUTLI_VM + || tpm_marshal_UINT32(&ptr, &len, out_data_size) +#else + || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) +#endif + || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) + || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { + free(out_data); + return -1; + } + + printf("\tSending SaveNVM Command.\n"); + res = write(vtpm_tx_fh, out_data, out_data_size); + free(out_data); + if (res != out_data_size) return -1; + + if (vtpm_rx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_rx_fh = vtpm_tx_fh +#else + if (vtpm_rx_name == NULL) { + vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); + sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); } - close(fh); - return 0; + vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); +#endif + } + + if (vtpm_rx_fh < 0) { + return -1; + } + + // Read Header of response so we can get the size & status +#ifdef VTPM_MUTLI_VM + in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; +#else + in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; +#endif + in_header = ptr = malloc(in_header_size); + + printf("\tReading SaveNVM header.\n"); + res = read(vtpm_rx_fh, in_header, in_header_size); + + if ( (res != in_header_size) +#ifndef VTPM_MUTLI_VM + || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) +#endif + || tpm_unmarshal_UINT16(&ptr, &len, &tag) + || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) + || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { + free(in_header); + return -1; + } + free(in_header); + + if (result != VTPM_SUCCESS) { + return -1; + } + +#ifdef VTPM_MUTLI_VM + close(vtpm_tx_fh); close(vtpm_rx_fh); +#endif + + printf("\tFinishing up SaveNVM\n"); + return (0); } int tpm_read_from_file(uint8_t **data, size_t *data_length) { - int fh; - ssize_t res; - size_t total_length; - fh = open(opt_storage_file, O_RDONLY); - if (fh < 0) return -1; - total_length = lseek(fh, 0, SEEK_END); - lseek(fh, 0, SEEK_SET); - *data = tpm_malloc(total_length); - if (*data == NULL) { - close(fh); - return -1; - } - *data_length = 0; - while (total_length > 0) { - res = read(fh, &(*data)[*data_length], total_length); - if (res < 0) { - close(fh); - tpm_free(*data); - return -1; - } - *data_length += res; - total_length -= res; + int res, out_data_size, in_header_size; + uint8_t *ptr, *out_data, *in_header; + UINT16 tag = VTPM_TAG_REQ; + UINT32 len, in_rsp_size, result; +#ifdef VTPM_MUTLI_VM + int vtpm_rx_fh, vtpm_tx_fh; +#endif + + printf("Loading NVM.\n"); + if (vtpm_tx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_tx_fh = open(DEV_FE, O_RDWR); +#else + vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); +#endif + } + + if (vtpm_tx_fh < 0) { + printf("Error in read_from_file:301\n"); + return -1; + } + + // Send request to VTPM Manager to encrypt data +#ifdef VTPM_MUTLI_VM + out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; +#else + out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; +#endif + out_data = ptr = (BYTE *) malloc(len); + + if (ptr == NULL +#ifndef VTPM_MUTLI_VM + || tpm_marshal_UINT32(&ptr, &len, dmi_id) +#endif + || tpm_marshal_UINT16(&ptr, &len, tag) +#ifdef VTPM_MUTLI_VM + || tpm_marshal_UINT32(&ptr, &len, out_data_size) +#else + || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) +#endif + || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { + free(out_data); + printf("Error in read_from_file:325\n"); + + return -1; + } + + printf("\tSending LoadNVM command\n"); + res = write(vtpm_tx_fh, out_data, out_data_size); + free(out_data); + if (res != out_data_size) + { + printf("Error in read_from_file:335\n"); + return -1; + } + + if (vtpm_rx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_rx_fh = vtpm_tx_fh; +#else + if (vtpm_rx_name == NULL) { + vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); + sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); } - close(fh); - return 0; + vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); +#endif + } + + if (vtpm_rx_fh < 0) { + printf("Error in read_from_file:352\n"); + return -1; + } + + // Read Header of response so we can get the size & status +#ifdef VTPM_MUTLI_VM + in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; +#else + in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; +#endif + in_header = ptr = malloc(in_header_size); + + printf("\tReading LoadNVM header\n"); + res = read(vtpm_rx_fh, in_header, in_header_size); + + if ( (res != in_header_size) +#ifndef VTPM_MUTLI_VM + || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) +#endif + || tpm_unmarshal_UINT16(&ptr, &len, &tag) + || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) + || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { + free(in_header); + printf("Error in read_from_file:375\n"); + return -1; + } + free(in_header); + + if (result != VTPM_SUCCESS) { + printf("Error in read_from_file:381\n"); + return -1; + } + + // Read Encrypted data from VTPM Manager + *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; + *data = (uint8_t *) malloc(*data_length); + + printf("\tReading clear data from LoadNVM.\n"); + res = read(vtpm_rx_fh, *data, *data_length); +#ifdef VTPM_MUTLI_VM + close(vtpm_rx_fh);close(vtpm_tx_fh); +#endif + + printf("\tReturing from loading NVM\n"); + if (res != (int)*data_length) { + free(*data); + printf("Error in read_from_file:398\n"); + return -1; + } else { + return 0; + } + + + } static void print_usage(char *name) { printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " - "[-o user name] [-g group name] [-h] [startup mode]\n", name); + "[-o user name] [-g group name] [-h]" +#ifdef VTPM_MULTI_VM + "clear|save|deactivated\n", name); +#else + "clear|save|deactivated pvm|hvm vtpmid\n", name); +#endif printf(" d : enable debug mode\n"); printf(" f : forces the application to run in the foreground\n"); printf(" s : storage file to use (default: %s)\n", opt_storage_file); @@ -205,7 +413,13 @@ static void parse_options(int argc, char exit(EXIT_SUCCESS); } } - if (optind < argc) { + /*Make sure we have all required options*/ +#ifdef VTPM_MULTI_VM +#define EXTRA_OPTS 0 +#else +#define EXTRA_OPTS 2 +#endif + if (optind < argc - EXTRA_OPTS ) { debug("startup mode = '%s'", argv[optind]); if (!strcmp(argv[optind], "clear")) { tpm_startup = 1; @@ -219,6 +433,25 @@ static void parse_options(int argc, char print_usage(argv[0]); exit(EXIT_SUCCESS); } +#ifndef VTPM_MULTI_VM + ++optind; + if(!strcmp(argv[optind], "pvm")) { + vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo + } else if (!strcmp(argv[optind], "hvm")) { + vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket + } else { + error("Invalid vm mode '%s'; must be 'pvm', " + "or 'hvm' ", argv[optind]); + print_usage(argv[0]); + exit(EXIT_SUCCESS); + } + ++optind; + dmi_id = atoi(argv[optind]); +#endif + } else { + error("Invalid number of arguments"); + print_usage(argv[0]); + exit(EXIT_SUCCESS); } } @@ -348,93 +581,180 @@ static int init_socket(const char *name) static void main_loop(void) { - int sock, fh, res; - int32_t in_len; + int32_t in_len, written; uint32_t out_len; - uint8_t in[TPM_CMD_BUF_SIZE], *out; + uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; + int guest_id=-1; + int i; + char *vtpm_rx_file=NULL; + int res; + +#ifndef VTPM_MULTI_VM + int sockfd = -1; struct sockaddr_un addr; - socklen_t addr_len; - fd_set rfds; - struct timeval tv; + struct sockaddr_un client_addr; + unsigned int client_length; +#endif + + int vtpm_tx_fh=-1, vtpm_rx_fh=-1; + +#ifndef VTPM_MULTI_VM + if (vtpm_type == VTPM_TYPE_PVM) { + vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); + sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); + } else { + vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); + sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); + + if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { + error("Unable to create socket. errno = %d\n", errno); + exit (-1); + } + + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + strcpy(addr.sun_path,vtpm_rx_file ); + unlink(addr.sun_path); + } +#endif info("staring main loop"); - /* open UNIX socket */ - sock = init_socket(opt_socket_name); - if (sock < 0) exit(EXIT_FAILURE); /* init tpm emulator */ - debug("initializing TPM emulator: %d", tpm_startup); +#ifdef VTPM_MULTI_VM + debug("initializing TPM emulator: state=%d", tpm_startup); +#else + debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); +#endif tpm_emulator_init(tpm_startup); /* start command processing */ while (!stopflag) { /* wait for incomming connections */ debug("waiting for connections..."); - FD_ZERO(&rfds); - FD_SET(sock, &rfds); - tv.tv_sec = 10; - tv.tv_usec = 0; - res = select(sock + 1, &rfds, NULL, NULL, &tv); - if (res < 0) { - error("select(sock) failed: %s", strerror(errno)); - break; - } else if (res == 0) { - continue; - } - addr_len = sizeof(addr); - fh = accept(sock, (struct sockaddr*)&addr, &addr_len); - if (fh < 0) { - error("accept() failed: %s", strerror(errno)); - continue; - } + if (vtpm_rx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_rx_fh = open(DEV_BE, O_RDWR); +#else + if (vtpm_type == VTPM_TYPE_PVM) + { + vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); + } else { + if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + error("Unable to bind(). errno = %d\n", errno); + exit (-1); + } + + if (listen(sockfd, 10) <0) { + error("Unable to listen(). errno = %d\n", errno); + exit (-1); + } + + memset(&client_addr, 0, sizeof(client_addr)); + client_length = sizeof(client_addr); + + vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); + } +#endif + } + + /*Error Checking*/ + if (vtpm_rx_fh < 0) { + error("Failed to open devices to listen to guest.\n"); + exit(-1); + } + /* receive and handle commands */ in_len = 0; do { debug("waiting for commands..."); - FD_ZERO(&rfds); - FD_SET(fh, &rfds); - tv.tv_sec = TPM_COMMAND_TIMEOUT; - tv.tv_usec = 0; - res = select(fh + 1, &rfds, NULL, NULL, &tv); - if (res < 0) { - error("select(fh) failed: %s", strerror(errno)); - close(fh); - break; - } else if (res == 0) { -#ifdef TPMD_DISCONNECT_IDLE_CLIENTS - info("connection closed due to inactivity"); - close(fh); - break; -#else - continue; -#endif - } - in_len = read(fh, in, sizeof(in)); - if (in_len > 0) { + + in_len = read(vtpm_rx_fh, in, sizeof(in)); + /*Magic size of minimum TPM command is 6*/ + //FIXME Magic size check may not be required anymore + if (in_len < 6) { + info("Recv incomplete command of %d bytes.", in_len); + if (in_len <= 0) { + close(vtpm_rx_fh); + vtpm_rx_fh = -1; + continue; + } + } else { + /*Debug Printouts*/ debug("received %d bytes", in_len); + debug_nostop("Recv[%d]: 0x", in_len); + for (i=0; i< in_len; i++) + debug_more("%x ", in[i]); + debug_more("\n"); + /*Multiple Guest check*/ + if (guest_id == -1) { + guest_id = *((int32_t *) in); + } else { + if (guest_id != *((int32_t *) in) ) { + error("WARNING: More than one guest attached\n"); + } + } + + /*Open tx handle now*/ + if (vtpm_tx_fh < 0) { +#ifdef VTPM_MUTLI_VM + vtpm_tx_fh = open(DEV_BE, O_RDWR); + vtpm_rx_fh = vtpm_tx_fh; +#else + if (vtpm_type == VTPM_TYPE_PVM) { + vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); + } // No need to open the other direction for HVM +#endif + } + if (vtpm_tx_fh < 0) { + error("Failed to open devices to respond to guest.\n"); + exit(-1); + } + + /*Handle the TPM command now*/ out = NULL; - res = tpm_handle_command(in, in_len, &out, &out_len); + res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); if (res < 0) { error("tpm_handle_command() failed"); } else { debug("sending %d bytes", out_len); + //FIXME this prepending may or may not be needed + /*Prepend the first 4 bytes of the in buffer.. why?*/ + addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); + *(uint32_t *) addressed_out = *(uint32_t *) in; + memcpy(addressed_out + sizeof(uint32_t), out, out_len); + out_len += sizeof(uint32_t); + /*End Prepend*/ + + /*Perform write operation now*/ while (out_len > 0) { - res = write(fh, out, out_len); + res = write(vtpm_tx_fh, addressed_out, out_len); + if (res < 0) { error("write(%d) failed: %s", out_len, strerror(errno)); break; - } + } else { + debug_nostop("Sent[%Zu]: ", out_len); + for (i=0; (unsigned int)i< out_len; i++) + debug_more("%x ", addressed_out[i]); + debug_more("\n"); + } out_len -= res; } tpm_free(out); + tpm_free(addressed_out); } } } while (in_len > 0); - close(fh); + //close(fh); } + /* shutdown tpm emulator */ tpm_emulator_shutdown(); - /* close socket */ - close(sock); - unlink(opt_socket_name); + /* Close handles */ + close(vtpm_tx_fh); +#ifndef VTPM_MULTI_VM + close(vtpm_rx_fh); + free(vtpm_rx_file); +#endif info("main loop stopped"); } @@ -450,12 +770,13 @@ int main(int argc, char **argv) /* open random device */ init_random(); /* init signal handlers */ - init_signal_handler(); + //init_signal_handler(); /* unless requested otherwiese, fork and daemonize process */ - if (!opt_foreground) daemonize(); + //if (!opt_foreground) daemonize(); /* start main processing loop */ main_loop(); info("stopping TPM Emulator daemon"); closelog(); return 0; } + diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h --- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 +++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 @@ -29,23 +29,28 @@ /* TPM emulator configuration */ -#undef TPM_STRONG_PERSISTENCE -#undef TPM_GENERATE_EK +#define TPM_STRONG_PERSISTENCE +#define TPM_GENERATE_EK #undef TPM_GENERATE_SEED_DAA #undef TPM_MEMORY_ALIGNMENT_MANDATORY +extern int dmi_id; + /* log macros */ void tpm_log(int priority, const char *fmt, ...); -#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ - __FILE__, __LINE__, ## __VA_ARGS__) -#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ - __FILE__, __LINE__, ## __VA_ARGS__) -#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ - __FILE__, __LINE__, ## __VA_ARGS__) -#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ - __FILE__, __LINE__, ## __VA_ARGS__) +#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ + dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) +#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ + dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) +#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ + dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) +#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ + dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) +#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ + dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) +#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) /* min/max macros that also do strict type-checking */