Upgrade to tpm-emulator version 0.7.

tpmd_dev/linux/tpmd_dev.c

-/* Software-Based Trusted Platform Module (TPM) Emulator for Linux 
- * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
+/* Software-based Trusted Platform Module (TPM) Emulator
+ * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net>
  *
- * This module 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 module 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 module 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 
+ * This module 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_dev.c 426 2010-02-22 17:11:58Z mast $
  */
 
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/miscdevice.h>
 #include <linux/poll.h>
 
 #include <linux/socket.h>
 #include <linux/net.h>
 #include <linux/un.h>
 
+#include "config.h"
+
 #define TPM_DEVICE_MINOR  224
-#define TPM_DEVICE_NAME   "tpm"
+#define TPM_DEVICE_ID     "tpm"
 #define TPM_MODULE_NAME   "tpmd_dev"
 
-#define TPM_RESPONSE_SIZE 4096
 #define TPM_STATE_IS_OPEN 0
 
 #ifdef DEBUG
 #define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \
                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
 #else
 #define debug(fmt, ...)
 #endif
 #define info(fmt, ...)  printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \
                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
 #define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \
                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
 #define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \
                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Mario Strasser <mast@gmx.net>");
 MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator");
-MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME);
+MODULE_SUPPORTED_DEVICE(TPM_DEVICE_ID);
 
 /* module parameters */
-char *tpmd_socket_name = "/var/run/tpm/tpmd_socket:0";
+char *tpmd_socket_name = TPM_SOCKET_NAME;
 module_param(tpmd_socket_name, charp, 0444);
 MODULE_PARM_DESC(tpmd_socket_name, " Sets the name of the TPM daemon socket.");
 
 /* TPM lock */
 static struct semaphore tpm_mutex;
 
 /* TPM command response */
 static struct {
   uint8_t *data;
   uint32_t size;
@@ skipping 43 matching lines @@
   iov.iov_base = (void*)in;
   iov.iov_len = in_size;
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
   res = sock_sendmsg(tpmd_sock, &msg, in_size);
   if (res < 0) {
     error("sock_sendmsg() failed: %d\n", res);
     return res;
   }
   /* receive response from tpmd */
-  tpm_response.size = TPM_RESPONSE_SIZE;
+  tpm_response.size = TPM_CMD_BUF_SIZE;
   tpm_response.data = kmalloc(tpm_response.size, GFP_KERNEL);
   if (tpm_response.data == NULL) return -1;
   memset(&msg, 0, sizeof(msg));
   iov.iov_base = (void*)tpm_response.data;
   iov.iov_len = tpm_response.size;
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
   oldmm = get_fs();
   set_fs(KERNEL_DS);
   res = sock_recvmsg(tpmd_sock, &msg, tpm_response.size, 0);
@@ skipping 103 matching lines @@
   .owner   = THIS_MODULE,
   .open    = tpm_open,
   .release = tpm_release,
   .read    = tpm_read,
   .write   = tpm_write,
   .ioctl   = tpm_ioctl,
 };
 
 static struct miscdevice tpm_dev = {
   .minor      = TPM_DEVICE_MINOR, 
-  .name       = TPM_DEVICE_NAME, 
+  .name       = TPM_DEVICE_ID, 
   .fops       = &fops,
 };
 
 int __init init_tpm_module(void)
 {
   int res = misc_register(&tpm_dev);
   if (res != 0) {
     error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR);
     return res;
   }
   /* initialize variables */
   sema_init(&tpm_mutex, 1);
   module_state = 0;
   tpm_response.data = NULL;
   tpm_response.size = 0;
   tpmd_sock = NULL;
   return 0;
 }
 
 void __exit cleanup_tpm_module(void)
 {
   misc_deregister(&tpm_dev);
   tpmd_disconnect();
   if (tpm_response.data != NULL) kfree(tpm_response.data);
 }
 
 module_init(init_tpm_module);
 module_exit(cleanup_tpm_module);