Upgrade to tpm-emulator version 0.7.

tpmd/unix/tpmd.c

-/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
- * Copyright (C) 2006 Mario Strasser <mast@gmx.net>,
- *                    Swiss Federal Institute of Technology (ETH) Zurich
+/* Software-based Trusted Platform Module (TPM) Emulator
+ * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net>
  *
  * 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.
  *
- * $Id$
+ * $Id: tpmd.c 405 2010-02-18 23:11:31Z mast $
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>
 #include <string.h>
 #include <errno.h>
 #include <syslog.h>
 #include <stdarg.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <pwd.h>
 #include <grp.h>
 #include "config.h"
 #include "tpm/tpm_emulator.h"
 
 #define TPM_COMMAND_TIMEOUT 30
 #define TPM_RANDOM_DEVICE   "/dev/urandom"
 
 static volatile int stopflag = 0;
 static int is_daemon = 0;
 static int opt_debug = 0;
 static int opt_foreground = 0;
 static const char *opt_socket_name = TPM_SOCKET_NAME;
 static const char *opt_storage_file = TPM_STORAGE_NAME;
-
 static uid_t opt_uid = 0;
 static gid_t opt_gid = 0;
 static int tpm_startup = 2;
+static uint32_t tpm_config = 0;
 static int rand_fh;
 
 void *tpm_malloc(size_t size)
 {
   return malloc(size);
 }
 
 void tpm_free(/*const*/ void *ptr)
 {
   if (ptr != NULL) free((void*)ptr);
 }
 
 void tpm_log(int priority, const char *fmt, ...)
 {
     va_list ap, bp;
     va_start(ap, fmt);
     va_copy(bp, ap);
-    vsyslog(priority, fmt, ap);
+    switch (priority) {
+      case TPM_LOG_DEBUG:
+        vsyslog(LOG_DEBUG, fmt, ap);
+        break;
+      case TPM_LOG_ERROR:
+        vsyslog(LOG_ERR, fmt, ap);
+        break;
+      case TPM_LOG_INFO:
+      default:
+        vsyslog(LOG_INFO, fmt, ap);
+        break;
+    }
     va_end(ap);
-    if (!is_daemon && (priority != LOG_DEBUG || opt_debug)) {
-         vprintf(fmt, bp);
+    if (!is_daemon && (priority != TPM_LOG_DEBUG || opt_debug)) {
+        vprintf(fmt, bp);
     }
     va_end(bp);
 }
 
 void tpm_get_extern_random_bytes(void *buf, size_t nbytes)
 {
     uint8_t *p = (uint8_t*)buf;
     ssize_t res;
     while (nbytes > 0) {
         res = read(rand_fh, p, nbytes);
@@ skipping 16 matching lines @@
 }
 
 int tpm_write_to_storage(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;
+        if (res < 0) {
+            close(fh);
+            return -1;
+        }
+        data_length -= res; 
+        data += res;
     }
     close(fh);
     return 0;
 }
 
 int tpm_read_from_storage(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;
-        }
+        if (res < 0) {
+            close(fh);
+            tpm_free(*data);
+            return -1;
+        }
+        if (res == 0) break;
         *data_length += res;
-        total_length -= res;
+        total_length -= res;
     }
     close(fh);
     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);
     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);
     printf("  u : unix socket name to use (default: %s)\n", opt_socket_name);
     printf("  o : effective user the application should run as\n");
     printf("  g : effective group the application should run as\n");
     printf("  h : print this help message\n");
     printf("  startup mode : must be 'clear', "
            "'save' (default) or 'deactivated\n");
 }
 
 static void parse_options(int argc, char **argv)
 {
     char c;
     struct passwd *pwd;
     struct group *grp;
     opt_uid = getuid();
     opt_gid = getgid();
     info("parsing options");
-    while ((c = getopt (argc, argv, "dfs:u:o:g:h")) != -1) {
+    while ((c = getopt (argc, argv, "dfs:u:o:g:c:h")) != -1) {
         debug("handling option '-%c'", c);
         switch (c) {
             case 'd':
                 opt_debug = 1;
                 setlogmask(setlogmask(0) | LOG_MASK(LOG_DEBUG));
                 debug("debug mode enabled");
                 break;
             case 'f':
                 debug("application is forced to run in foreground");
                 opt_foreground = 1;
@@ skipping 15 matching lines @@
                 opt_uid = pwd->pw_uid;
                 break;
             case 'g':
                 grp  = getgrnam(optarg);
                 if (grp == NULL) {
                     error("invalid group name '%s'\n", optarg);
                     exit(EXIT_FAILURE);
                 }
                 opt_gid = grp->gr_gid;
                 break;
+            case 'c':
+                tpm_config = strtol(optarg, NULL, 0);
+                break;
             case '?':
                 error("unknown option '-%c'", optopt);
                 print_usage(argv[0]);
                 exit(EXIT_FAILURE);
             case 'h':
             default:
                 print_usage(argv[0]);
                 exit(EXIT_SUCCESS);
         }
     }
@@ skipping 157 matching lines @@
     socklen_t addr_len;
     fd_set rfds;
     struct timeval tv;
 
     info("staring main loop");
     /* open UNIX socket */
     sock = init_socket(opt_socket_name);
     if (sock < 0) exit(EXIT_FAILURE);
     /* init tpm emulator */
     mkdirs(opt_storage_file);
-    debug("initializing TPM emulator: %d", tpm_startup);
-    tpm_emulator_init(tpm_startup);
+    debug("initializing TPM emulator");
+    tpm_emulator_init(tpm_startup, tpm_config);
     /* 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) {
@@ skipping 32 matching lines @@
             }
             in_len = read(fh, in, sizeof(in));
             if (in_len > 0) {
                 debug("received %d bytes", in_len);
                 out = NULL;
                 res = tpm_handle_command(in, in_len, &out, &out_len);
                 if (res < 0) {
                     error("tpm_handle_command() failed");
                 } else {
                     debug("sending %d bytes", out_len);
-                    while (out_len > 0) {
-                        res = write(fh, out, out_len);
+                    uint32_t len = 0;
+                    while (len < out_len) {
+                        res = write(fh, &out[len], out_len - len);
                         if (res < 0) {
-                            error("write(%d) failed: %s", out_len, strerror(errno));
+                            error("write(%d) failed: %s", 
+                                  out_len - len, strerror(errno));
                             break;
                         }
-                        out_len -= res;
+                        len += res;
                     }
                     tpm_free(out);
                 }
             }
         } while (in_len > 0);
         close(fh);
     }
     /* shutdown tpm emulator */
     tpm_emulator_shutdown();
     /* close socket */
     close(sock);
     unlink(opt_socket_name);
     info("main loop stopped");
 }
 
 int main(int argc, char **argv)
 {
     openlog(argv[0], 0, LOG_DAEMON);
     setlogmask(~LOG_MASK(LOG_DEBUG));
     syslog(LOG_INFO, "--- separator ---\n");
     info("starting TPM Emulator daemon (1.2.%d.%d-%d)",
          VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD);
     parse_options(argc, argv);
     /* switch uid/gid if required */
     switch_uid_gid();
-    /* open random device */
-    init_random();
     /* init signal handlers */
     init_signal_handler();
     /* unless requested otherwiese, fork and daemonize process */
     if (!opt_foreground) daemonize();
+    /* open random device */
+    init_random();
     /* start main processing loop */
     main_loop();
     info("stopping TPM Emulator daemon");
+    close(rand_fh);
     closelog();
-    return 0;
+    return EXIT_SUCCESS;
 }