tpm_manager: Break up proxy interface
This CL breaks up the dbus_proxy interface to inherit from
TpmOwnershipInterface and TpmNvramInterface.
Bug: 24659038
TEST=compile and run on DUT.
Change-Id: I74c9a7fa3c1c0cbe76e60f08bbb4160d41a40744
diff --git a/client/dbus_proxy.cc b/client/dbus_proxy.cc
deleted file mode 100644
index 18c1190..0000000
--- a/client/dbus_proxy.cc
+++ /dev/null
@@ -1,120 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "tpm_manager/client/dbus_proxy.h"
-
-#include <brillo/bind_lambda.h>
-#include <brillo/dbus/dbus_method_invoker.h>
-
-#include "tpm_manager/common/dbus_interface.h"
-
-namespace {
-
-// Use a two minute timeout because TPM operations can take a long time.
-const int kDBusTimeoutMS = 2 * 60 * 1000;
-
-} // namespace
-
-namespace tpm_manager {
-
-DBusProxy::DBusProxy() {}
-
-DBusProxy::~DBusProxy() {
- if (bus_) {
- bus_->ShutdownAndBlock();
- }
-}
-
-bool DBusProxy::Initialize() {
- dbus::Bus::Options options;
- options.bus_type = dbus::Bus::SYSTEM;
- bus_ = new dbus::Bus(options);
- object_proxy_ = bus_->GetObjectProxy(
- tpm_manager::kTpmManagerServiceName,
- dbus::ObjectPath(tpm_manager::kTpmManagerServicePath));
- return (object_proxy_ != nullptr);
-}
-
-void DBusProxy::GetTpmStatus(const GetTpmStatusRequest& request,
- const GetTpmStatusCallback& callback) {
- CallMethod<GetTpmStatusReply>(tpm_manager::kGetTpmStatus, request, callback);
-}
-
-void DBusProxy::TakeOwnership(const TakeOwnershipRequest& request,
- const TakeOwnershipCallback& callback) {
- CallMethod<TakeOwnershipReply>(
- tpm_manager::kTakeOwnership, request, callback);
-}
-
-void DBusProxy::DefineNvram(const DefineNvramRequest& request,
- const DefineNvramCallback& callback) {
- CallMethod<DefineNvramReply>(tpm_manager::kDefineNvram, request, callback);
-}
-
-void DBusProxy::DestroyNvram(const DestroyNvramRequest& request,
- const DestroyNvramCallback& callback) {
- CallMethod<DestroyNvramReply>(tpm_manager::kDestroyNvram, request, callback);
-}
-
-void DBusProxy::WriteNvram(const WriteNvramRequest& request,
- const WriteNvramCallback& callback) {
- CallMethod<WriteNvramReply>(tpm_manager::kWriteNvram, request, callback);
-}
-
-void DBusProxy::ReadNvram(const ReadNvramRequest& request,
- const ReadNvramCallback& callback) {
- CallMethod<ReadNvramReply>(tpm_manager::kReadNvram, request, callback);
-}
-
-void DBusProxy::IsNvramDefined(const IsNvramDefinedRequest& request,
- const IsNvramDefinedCallback& callback) {
- CallMethod<IsNvramDefinedReply>(
- tpm_manager::kIsNvramDefined, request, callback);
-}
-
-void DBusProxy::IsNvramLocked(const IsNvramLockedRequest& request,
- const IsNvramLockedCallback& callback) {
- CallMethod<IsNvramLockedReply>(
- tpm_manager::kIsNvramLocked, request, callback);
-}
-
-void DBusProxy::GetNvramSize(const GetNvramSizeRequest& request,
- const GetNvramSizeCallback& callback) {
- CallMethod<GetNvramSizeReply>(tpm_manager::kGetNvramSize, request, callback);
-}
-
-template<typename ReplyProtobufType,
- typename RequestProtobufType,
- typename CallbackType>
-void DBusProxy::CallMethod(const std::string& method_name,
- const RequestProtobufType& request,
- const CallbackType& callback) {
- auto on_error = [callback](brillo::Error* error) {
- ReplyProtobufType reply;
- reply.set_status(STATUS_NOT_AVAILABLE);
- callback.Run(reply);
- };
- brillo::dbus_utils::CallMethodWithTimeout(
- kDBusTimeoutMS,
- object_proxy_,
- tpm_manager::kTpmManagerInterface,
- method_name,
- callback,
- base::Bind(on_error),
- request);
-}
-
-} // namespace tpm_manager
diff --git a/client/main.cc b/client/main.cc
index 771249c..a752c5c 100644
--- a/client/main.cc
+++ b/client/main.cc
@@ -28,7 +28,8 @@
#include <brillo/daemons/daemon.h>
#include <brillo/syslog_logging.h>
-#include "tpm_manager/client/dbus_proxy.h"
+#include "tpm_manager/client/tpm_nvram_dbus_proxy.h"
+#include "tpm_manager/client/tpm_ownership_dbus_proxy.h"
#include "tpm_manager/common/print_tpm_ownership_interface_proto.h"
#include "tpm_manager/common/print_tpm_nvram_interface_proto.h"
#include "tpm_manager/common/tpm_ownership_interface.pb.h"
@@ -93,11 +94,18 @@
LOG(ERROR) << "Error initializing tpm_manager_client.";
return exit_code;
}
- tpm_manager_.reset(new tpm_manager::DBusProxy());
- if (!tpm_manager_->Initialize()) {
- LOG(ERROR) << "Error initializing dbus proxy to tpm_managerd.";
+ TpmNvramDBusProxy* nvram_proxy = new TpmNvramDBusProxy();
+ if (!nvram_proxy->Initialize()) {
+ LOG(ERROR) << "Error initializing proxy to nvram interface.";
return EX_UNAVAILABLE;
}
+ TpmOwnershipDBusProxy* ownership_proxy = new TpmOwnershipDBusProxy();
+ if (!ownership_proxy->Initialize()) {
+ LOG(ERROR) << "Error initializing proxy to ownership interface.";
+ return EX_UNAVAILABLE;
+ }
+ tpm_nvram_.reset(nvram_proxy);
+ tpm_ownership_.reset(ownership_proxy);
exit_code = ScheduleCommand();
if (exit_code == EX_USAGE) {
printf("%s", kUsage);
@@ -106,7 +114,8 @@
}
void OnShutdown(int* exit_code) override {
- tpm_manager_.reset();
+ tpm_nvram_.reset();
+ tpm_ownership_.reset();
ClientLoopBase::OnShutdown(exit_code);
}
@@ -208,7 +217,7 @@
void HandleGetTpmStatus() {
GetTpmStatusRequest request;
- tpm_manager_->GetTpmStatus(
+ tpm_ownership_->GetTpmStatus(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<GetTpmStatusReply>,
weak_factory_.GetWeakPtr()));
@@ -216,7 +225,7 @@
void HandleTakeOwnership() {
TakeOwnershipRequest request;
- tpm_manager_->TakeOwnership(
+ tpm_ownership_->TakeOwnership(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<TakeOwnershipReply>,
weak_factory_.GetWeakPtr()));
@@ -226,7 +235,7 @@
DefineNvramRequest request;
request.set_index(index);
request.set_length(length);
- tpm_manager_->DefineNvram(
+ tpm_nvram_->DefineNvram(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<DefineNvramReply>,
weak_factory_.GetWeakPtr()));
@@ -235,7 +244,7 @@
void HandleDestroyNvram(uint32_t index) {
DestroyNvramRequest request;
request.set_index(index);
- tpm_manager_->DestroyNvram(
+ tpm_nvram_->DestroyNvram(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<DestroyNvramReply>,
weak_factory_.GetWeakPtr()));
@@ -245,7 +254,7 @@
WriteNvramRequest request;
request.set_index(index);
request.set_data(data);
- tpm_manager_->WriteNvram(
+ tpm_nvram_->WriteNvram(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<WriteNvramReply>,
weak_factory_.GetWeakPtr()));
@@ -254,7 +263,7 @@
void HandleReadNvram(uint32_t index) {
ReadNvramRequest request;
request.set_index(index);
- tpm_manager_->ReadNvram(
+ tpm_nvram_->ReadNvram(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<ReadNvramReply>,
weak_factory_.GetWeakPtr()));
@@ -263,7 +272,7 @@
void HandleIsNvramDefined(uint32_t index) {
IsNvramDefinedRequest request;
request.set_index(index);
- tpm_manager_->IsNvramDefined(
+ tpm_nvram_->IsNvramDefined(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<IsNvramDefinedReply>,
weak_factory_.GetWeakPtr()));
@@ -272,7 +281,7 @@
void HandleIsNvramLocked(uint32_t index) {
IsNvramLockedRequest request;
request.set_index(index);
- tpm_manager_->IsNvramLocked(
+ tpm_nvram_->IsNvramLocked(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<IsNvramLockedReply>,
weak_factory_.GetWeakPtr()));
@@ -281,14 +290,15 @@
void HandleGetNvramSize(uint32_t index) {
GetNvramSizeRequest request;
request.set_index(index);
- tpm_manager_->GetNvramSize(
+ tpm_nvram_->GetNvramSize(
request,
base::Bind(&ClientLoop::PrintReplyAndQuit<GetNvramSizeReply>,
weak_factory_.GetWeakPtr()));
}
// Pointer to a DBus proxy to tpm_managerd.
- std::unique_ptr<tpm_manager::TpmManagerInterface> tpm_manager_;
+ std::unique_ptr<tpm_manager::TpmNvramInterface> tpm_nvram_;
+ std::unique_ptr<tpm_manager::TpmOwnershipInterface> tpm_ownership_;
// Declared last so that weak pointers will be destroyed first.
base::WeakPtrFactory<ClientLoop> weak_factory_{this};
diff --git a/client/tpm_nvram_dbus_proxy.cc b/client/tpm_nvram_dbus_proxy.cc
new file mode 100644
index 0000000..fc0706e
--- /dev/null
+++ b/client/tpm_nvram_dbus_proxy.cc
@@ -0,0 +1,108 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "tpm_manager/client/tpm_nvram_dbus_proxy.h"
+
+#include <brillo/bind_lambda.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+
+#include "tpm_manager/common/tpm_manager_constants.h"
+#include "tpm_manager/common/tpm_nvram_dbus_interface.h"
+
+namespace {
+
+// Use a two minute timeout because TPM operations can take a long time.
+const int kDBusTimeoutMS = 2 * 60 * 1000;
+
+} // namespace
+
+namespace tpm_manager {
+
+TpmNvramDBusProxy::~TpmNvramDBusProxy() {
+ if (bus_) {
+ bus_->ShutdownAndBlock();
+ }
+}
+
+bool TpmNvramDBusProxy::Initialize() {
+ dbus::Bus::Options options;
+ options.bus_type = dbus::Bus::SYSTEM;
+ bus_ = new dbus::Bus(options);
+ object_proxy_ = bus_->GetObjectProxy(
+ tpm_manager::kTpmManagerServiceName,
+ dbus::ObjectPath(tpm_manager::kTpmManagerServicePath));
+ return (object_proxy_ != nullptr);
+}
+
+void TpmNvramDBusProxy::DefineNvram(const DefineNvramRequest& request,
+ const DefineNvramCallback& callback) {
+ CallMethod<DefineNvramReply>(tpm_manager::kDefineNvram, request, callback);
+}
+
+void TpmNvramDBusProxy::DestroyNvram(const DestroyNvramRequest& request,
+ const DestroyNvramCallback& callback) {
+ CallMethod<DestroyNvramReply>(tpm_manager::kDestroyNvram, request, callback);
+}
+
+void TpmNvramDBusProxy::WriteNvram(const WriteNvramRequest& request,
+ const WriteNvramCallback& callback) {
+ CallMethod<WriteNvramReply>(tpm_manager::kWriteNvram, request, callback);
+}
+
+void TpmNvramDBusProxy::ReadNvram(const ReadNvramRequest& request,
+ const ReadNvramCallback& callback) {
+ CallMethod<ReadNvramReply>(tpm_manager::kReadNvram, request, callback);
+}
+
+void TpmNvramDBusProxy::IsNvramDefined(const IsNvramDefinedRequest& request,
+ const IsNvramDefinedCallback& callback) {
+ CallMethod<IsNvramDefinedReply>(
+ tpm_manager::kIsNvramDefined, request, callback);
+}
+
+void TpmNvramDBusProxy::IsNvramLocked(const IsNvramLockedRequest& request,
+ const IsNvramLockedCallback& callback) {
+ CallMethod<IsNvramLockedReply>(
+ tpm_manager::kIsNvramLocked, request, callback);
+}
+
+void TpmNvramDBusProxy::GetNvramSize(const GetNvramSizeRequest& request,
+ const GetNvramSizeCallback& callback) {
+ CallMethod<GetNvramSizeReply>(tpm_manager::kGetNvramSize, request, callback);
+}
+
+template<typename ReplyProtobufType,
+ typename RequestProtobufType,
+ typename CallbackType>
+void TpmNvramDBusProxy::CallMethod(const std::string& method_name,
+ const RequestProtobufType& request,
+ const CallbackType& callback) {
+ auto on_error = [callback](brillo::Error* error) {
+ ReplyProtobufType reply;
+ reply.set_status(STATUS_NOT_AVAILABLE);
+ callback.Run(reply);
+ };
+ brillo::dbus_utils::CallMethodWithTimeout(
+ kDBusTimeoutMS,
+ object_proxy_,
+ tpm_manager::kTpmNvramInterface,
+ method_name,
+ callback,
+ base::Bind(on_error),
+ request);
+}
+
+} // namespace tpm_manager
diff --git a/client/dbus_proxy.h b/client/tpm_nvram_dbus_proxy.h
similarity index 73%
rename from client/dbus_proxy.h
rename to client/tpm_nvram_dbus_proxy.h
index d52c68c..4522311 100644
--- a/client/dbus_proxy.h
+++ b/client/tpm_nvram_dbus_proxy.h
@@ -14,13 +14,14 @@
// limitations under the License.
//
-#ifndef TPM_MANAGER_CLIENT_DBUS_PROXY_H_
-#define TPM_MANAGER_CLIENT_DBUS_PROXY_H_
+#ifndef TPM_MANAGER_CLIENT_TPM_NVRAM_DBUS_PROXY_H_
+#define TPM_MANAGER_CLIENT_TPM_NVRAM_DBUS_PROXY_H_
-#include "tpm_manager/common/tpm_manager_interface.h"
+#include "tpm_manager/common/tpm_nvram_interface.h"
#include <string>
+#include <base/macros.h>
#include <base/memory/ref_counted.h>
#include <dbus/bus.h>
#include <dbus/object_proxy.h>
@@ -29,22 +30,21 @@
namespace tpm_manager {
-// An implementation of TpmManagerInterface that forwards requests to
+// An implementation of TpmNvramInterface that forwards requests to
// tpm_managerd over D-Bus.
// Usage:
-// std::unique_ptr<TpmManagerInterface> tpm_manager = new DBusProxy();
-// tpm_manager->GetTpmStatus(...);
-class TPM_MANAGER_EXPORT DBusProxy : public TpmManagerInterface {
+// std::unique_ptr<TpmNvramInterface> tpm_manager = new TpmNvramDBusProxy();
+// tpm_manager->DefineNvram(...);
+class TPM_MANAGER_EXPORT TpmNvramDBusProxy : public TpmNvramInterface {
public:
- DBusProxy();
- virtual ~DBusProxy();
+ TpmNvramDBusProxy() = default;
+ virtual ~TpmNvramDBusProxy();
- // TpmManagerInterface methods.
- bool Initialize() override;
- void GetTpmStatus(const GetTpmStatusRequest& request,
- const GetTpmStatusCallback& callback) override;
- void TakeOwnership(const TakeOwnershipRequest& request,
- const TakeOwnershipCallback& callback) override;
+ // Performs initialization tasks. This method must be called before calling
+ // any other method in this class. Returns true on success.
+ bool Initialize();
+
+ // TpmNvramInterface methods.
void DefineNvram(const DefineNvramRequest& request,
const DefineNvramCallback& callback) override;
void DestroyNvram(const DestroyNvramRequest& request,
@@ -75,9 +75,9 @@
scoped_refptr<dbus::Bus> bus_;
dbus::ObjectProxy* object_proxy_;
- DISALLOW_COPY_AND_ASSIGN(DBusProxy);
+ DISALLOW_COPY_AND_ASSIGN(TpmNvramDBusProxy);
};
} // namespace tpm_manager
-#endif // TPM_MANAGER_CLIENT_DBUS_PROXY_H_
+#endif // TPM_MANAGER_CLIENT_TPM_NVRAM_DBUS_PROXY_H_
diff --git a/client/dbus_proxy_test.cc b/client/tpm_nvram_dbus_proxy_test.cc
similarity index 76%
rename from client/dbus_proxy_test.cc
rename to client/tpm_nvram_dbus_proxy_test.cc
index b299b41..b03237e 100644
--- a/client/dbus_proxy_test.cc
+++ b/client/tpm_nvram_dbus_proxy_test.cc
@@ -21,7 +21,7 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-#include "tpm_manager/client/dbus_proxy.h"
+#include "tpm_manager/client/tpm_nvram_dbus_proxy.h"
using testing::_;
using testing::Invoke;
@@ -30,9 +30,9 @@
namespace tpm_manager {
-class DBusProxyTest : public testing::Test {
+class TpmNvramDBusProxyTest : public testing::Test {
public:
- ~DBusProxyTest() override = default;
+ ~TpmNvramDBusProxyTest() override = default;
void SetUp() override {
mock_object_proxy_ = new StrictMock<dbus::MockObjectProxy>(
nullptr, "", dbus::ObjectPath(""));
@@ -41,84 +41,10 @@
protected:
scoped_refptr<StrictMock<dbus::MockObjectProxy>> mock_object_proxy_;
- DBusProxy proxy_;
+ TpmNvramDBusProxy proxy_;
};
-TEST_F(DBusProxyTest, GetTpmStatus) {
- auto fake_dbus_call = [](
- dbus::MethodCall* method_call,
- const dbus::MockObjectProxy::ResponseCallback& response_callback) {
- // Verify request protobuf.
- dbus::MessageReader reader(method_call);
- GetTpmStatusRequest request;
- EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
- // Create reply protobuf.
- auto response = dbus::Response::CreateEmpty();
- dbus::MessageWriter writer(response.get());
- GetTpmStatusReply reply;
- reply.set_status(STATUS_SUCCESS);
- reply.set_enabled(true);
- reply.set_owned(true);
- reply.mutable_local_data()->set_owned_by_this_install(true);
- reply.set_dictionary_attack_counter(3);
- reply.set_dictionary_attack_threshold(4);
- reply.set_dictionary_attack_lockout_in_effect(true);
- reply.set_dictionary_attack_lockout_seconds_remaining(5);
- writer.AppendProtoAsArrayOfBytes(reply);
- response_callback.Run(response.release());
- };
- EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
- .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
-
- // Set expectations on the outputs.
- int callback_count = 0;
- auto callback = [&callback_count](const GetTpmStatusReply& reply) {
- callback_count++;
- EXPECT_EQ(STATUS_SUCCESS, reply.status());
- EXPECT_TRUE(reply.enabled());
- EXPECT_TRUE(reply.owned());
- EXPECT_TRUE(reply.local_data().owned_by_this_install());
- EXPECT_EQ(3, reply.dictionary_attack_counter());
- EXPECT_EQ(4, reply.dictionary_attack_threshold());
- EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect());
- EXPECT_EQ(5, reply.dictionary_attack_lockout_seconds_remaining());
- };
- GetTpmStatusRequest request;
- proxy_.GetTpmStatus(request, base::Bind(callback));
- EXPECT_EQ(1, callback_count);
-}
-
-TEST_F(DBusProxyTest, TakeOwnership) {
- auto fake_dbus_call = [](
- dbus::MethodCall* method_call,
- const dbus::MockObjectProxy::ResponseCallback& response_callback) {
- // Verify request protobuf.
- dbus::MessageReader reader(method_call);
- TakeOwnershipRequest request;
- EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
- // Create reply protobuf.
- auto response = dbus::Response::CreateEmpty();
- dbus::MessageWriter writer(response.get());
- TakeOwnershipReply reply;
- reply.set_status(STATUS_SUCCESS);
- writer.AppendProtoAsArrayOfBytes(reply);
- response_callback.Run(response.release());
- };
- EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
- .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
-
- // Set expectations on the outputs.
- int callback_count = 0;
- auto callback = [&callback_count](const TakeOwnershipReply& reply) {
- callback_count++;
- EXPECT_EQ(STATUS_SUCCESS, reply.status());
- };
- TakeOwnershipRequest request;
- proxy_.TakeOwnership(request, base::Bind(callback));
- EXPECT_EQ(1, callback_count);
-}
-
-TEST_F(DBusProxyTest, DefineNvram) {
+TEST_F(TpmNvramDBusProxyTest, DefineNvram) {
uint32_t nvram_index = 5;
size_t nvram_length = 32;
auto fake_dbus_call = [nvram_index, nvram_length](
@@ -155,7 +81,7 @@
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, DestroyNvram) {
+TEST_F(TpmNvramDBusProxyTest, DestroyNvram) {
uint32_t nvram_index = 5;
auto fake_dbus_call = [nvram_index](
dbus::MethodCall* method_call,
@@ -187,7 +113,7 @@
proxy_.DestroyNvram(request, base::Bind(callback));
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, WriteNvram) {
+TEST_F(TpmNvramDBusProxyTest, WriteNvram) {
uint32_t nvram_index = 5;
std::string nvram_data("nvram_data");
auto fake_dbus_call = [nvram_index, nvram_data](
@@ -224,7 +150,7 @@
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, ReadNvram) {
+TEST_F(TpmNvramDBusProxyTest, ReadNvram) {
uint32_t nvram_index = 5;
std::string nvram_data("nvram_data");
auto fake_dbus_call = [nvram_index, nvram_data](
@@ -261,7 +187,7 @@
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, IsNvramDefined) {
+TEST_F(TpmNvramDBusProxyTest, IsNvramDefined) {
uint32_t nvram_index = 5;
bool nvram_defined = true;
auto fake_dbus_call = [nvram_index, nvram_defined](
@@ -299,7 +225,7 @@
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, IsNvramLocked) {
+TEST_F(TpmNvramDBusProxyTest, IsNvramLocked) {
uint32_t nvram_index = 5;
bool nvram_locked = true;
auto fake_dbus_call = [nvram_index, nvram_locked](
@@ -337,7 +263,7 @@
EXPECT_EQ(1, callback_count);
}
-TEST_F(DBusProxyTest, GetNvramSize) {
+TEST_F(TpmNvramDBusProxyTest, GetNvramSize) {
uint32_t nvram_index = 5;
size_t nvram_size = 32;
auto fake_dbus_call = [nvram_index, nvram_size](
diff --git a/client/tpm_ownership_dbus_proxy.cc b/client/tpm_ownership_dbus_proxy.cc
new file mode 100644
index 0000000..3282ca4
--- /dev/null
+++ b/client/tpm_ownership_dbus_proxy.cc
@@ -0,0 +1,84 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "tpm_manager/client/tpm_ownership_dbus_proxy.h"
+
+#include <brillo/bind_lambda.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+
+#include "tpm_manager/common/tpm_manager_constants.h"
+#include "tpm_manager/common/tpm_ownership_dbus_interface.h"
+
+namespace {
+
+// Use a two minute timeout because TPM operations can take a long time.
+const int kDBusTimeoutMS = 2 * 60 * 1000;
+
+} // namespace
+
+namespace tpm_manager {
+
+TpmOwnershipDBusProxy::~TpmOwnershipDBusProxy() {
+ if (bus_) {
+ bus_->ShutdownAndBlock();
+ }
+}
+
+bool TpmOwnershipDBusProxy::Initialize() {
+ dbus::Bus::Options options;
+ options.bus_type = dbus::Bus::SYSTEM;
+ bus_ = new dbus::Bus(options);
+ object_proxy_ = bus_->GetObjectProxy(
+ tpm_manager::kTpmManagerServiceName,
+ dbus::ObjectPath(tpm_manager::kTpmManagerServicePath));
+ return (object_proxy_ != nullptr);
+}
+
+void TpmOwnershipDBusProxy::GetTpmStatus(
+ const GetTpmStatusRequest& request,
+ const GetTpmStatusCallback& callback) {
+ CallMethod<GetTpmStatusReply>(tpm_manager::kGetTpmStatus, request, callback);
+}
+
+void TpmOwnershipDBusProxy::TakeOwnership(
+ const TakeOwnershipRequest& request,
+ const TakeOwnershipCallback& callback) {
+ CallMethod<TakeOwnershipReply>(
+ tpm_manager::kTakeOwnership, request, callback);
+}
+
+template<typename ReplyProtobufType,
+ typename RequestProtobufType,
+ typename CallbackType>
+void TpmOwnershipDBusProxy::CallMethod(const std::string& method_name,
+ const RequestProtobufType& request,
+ const CallbackType& callback) {
+ auto on_error = [callback](brillo::Error* error) {
+ ReplyProtobufType reply;
+ reply.set_status(STATUS_NOT_AVAILABLE);
+ callback.Run(reply);
+ };
+ brillo::dbus_utils::CallMethodWithTimeout(
+ kDBusTimeoutMS,
+ object_proxy_,
+ tpm_manager::kTpmOwnershipInterface,
+ method_name,
+ callback,
+ base::Bind(on_error),
+ request);
+}
+
+} // namespace tpm_manager
diff --git a/client/tpm_ownership_dbus_proxy.h b/client/tpm_ownership_dbus_proxy.h
new file mode 100644
index 0000000..34c1a49
--- /dev/null
+++ b/client/tpm_ownership_dbus_proxy.h
@@ -0,0 +1,73 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef TPM_MANAGER_CLIENT_TPM_OWNERSHIP_DBUS_PROXY_H_
+#define TPM_MANAGER_CLIENT_TPM_OWNERSHIP_DBUS_PROXY_H_
+
+#include "tpm_manager/common/tpm_ownership_interface.h"
+
+#include <string>
+
+#include <base/macros.h>
+#include <base/memory/ref_counted.h>
+#include <dbus/bus.h>
+#include <dbus/object_proxy.h>
+
+#include "tpm_manager/common/export.h"
+
+namespace tpm_manager {
+
+// An implementation of TpmOwnershipInterface that forwards requests to
+// tpm_managerd over D-Bus.
+// Usage:
+// std::unique_ptr<TpmOwnershipInterface> tpm_ = new TpmOwnershipDBusProxy();
+// tpm_->GetTpmStatus(...);
+class TPM_MANAGER_EXPORT TpmOwnershipDBusProxy : public TpmOwnershipInterface {
+ public:
+ TpmOwnershipDBusProxy() = default;
+ virtual ~TpmOwnershipDBusProxy();
+
+ // Performs initialization tasks. This method must be called before calling
+ // any other method in this class. Returns true on success.
+ bool Initialize();
+
+ // TpmOwnershipInterface methods.
+ void GetTpmStatus(const GetTpmStatusRequest& request,
+ const GetTpmStatusCallback& callback) override;
+ void TakeOwnership(const TakeOwnershipRequest& request,
+ const TakeOwnershipCallback& callback) override;
+
+ void set_object_proxy(dbus::ObjectProxy* object_proxy) {
+ object_proxy_ = object_proxy;
+ }
+
+ private:
+ // Template method to call a given |method_name| remotely via dbus.
+ template<typename ReplyProtobufType,
+ typename RequestProtobufType,
+ typename CallbackType>
+ void CallMethod(const std::string& method_name,
+ const RequestProtobufType& request,
+ const CallbackType& callback);
+
+ scoped_refptr<dbus::Bus> bus_;
+ dbus::ObjectProxy* object_proxy_;
+ DISALLOW_COPY_AND_ASSIGN(TpmOwnershipDBusProxy);
+};
+
+} // namespace tpm_manager
+
+#endif // TPM_MANAGER_CLIENT_TPM_OWNERSHIP_DBUS_PROXY_H_
diff --git a/client/tpm_ownership_dbus_proxy_test.cc b/client/tpm_ownership_dbus_proxy_test.cc
new file mode 100644
index 0000000..a22afe6
--- /dev/null
+++ b/client/tpm_ownership_dbus_proxy_test.cc
@@ -0,0 +1,121 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <string>
+
+#include <brillo/bind_lambda.h>
+#include <dbus/mock_object_proxy.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "tpm_manager/client/tpm_ownership_dbus_proxy.h"
+
+using testing::_;
+using testing::Invoke;
+using testing::StrictMock;
+using testing::WithArgs;
+
+namespace tpm_manager {
+
+class TpmOwnershipDBusProxyTest : public testing::Test {
+ public:
+ ~TpmOwnershipDBusProxyTest() override = default;
+ void SetUp() override {
+ mock_object_proxy_ = new StrictMock<dbus::MockObjectProxy>(
+ nullptr, "", dbus::ObjectPath(""));
+ proxy_.set_object_proxy(mock_object_proxy_.get());
+ }
+
+ protected:
+ scoped_refptr<StrictMock<dbus::MockObjectProxy>> mock_object_proxy_;
+ TpmOwnershipDBusProxy proxy_;
+};
+
+TEST_F(TpmOwnershipDBusProxyTest, GetTpmStatus) {
+ auto fake_dbus_call = [](
+ dbus::MethodCall* method_call,
+ const dbus::MockObjectProxy::ResponseCallback& response_callback) {
+ // Verify request protobuf.
+ dbus::MessageReader reader(method_call);
+ GetTpmStatusRequest request;
+ EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
+ // Create reply protobuf.
+ auto response = dbus::Response::CreateEmpty();
+ dbus::MessageWriter writer(response.get());
+ GetTpmStatusReply reply;
+ reply.set_status(STATUS_SUCCESS);
+ reply.set_enabled(true);
+ reply.set_owned(true);
+ reply.mutable_local_data()->set_owned_by_this_install(true);
+ reply.set_dictionary_attack_counter(3);
+ reply.set_dictionary_attack_threshold(4);
+ reply.set_dictionary_attack_lockout_in_effect(true);
+ reply.set_dictionary_attack_lockout_seconds_remaining(5);
+ writer.AppendProtoAsArrayOfBytes(reply);
+ response_callback.Run(response.release());
+ };
+ EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
+ .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
+
+ // Set expectations on the outputs.
+ int callback_count = 0;
+ auto callback = [&callback_count](const GetTpmStatusReply& reply) {
+ callback_count++;
+ EXPECT_EQ(STATUS_SUCCESS, reply.status());
+ EXPECT_TRUE(reply.enabled());
+ EXPECT_TRUE(reply.owned());
+ EXPECT_TRUE(reply.local_data().owned_by_this_install());
+ EXPECT_EQ(3, reply.dictionary_attack_counter());
+ EXPECT_EQ(4, reply.dictionary_attack_threshold());
+ EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect());
+ EXPECT_EQ(5, reply.dictionary_attack_lockout_seconds_remaining());
+ };
+ GetTpmStatusRequest request;
+ proxy_.GetTpmStatus(request, base::Bind(callback));
+ EXPECT_EQ(1, callback_count);
+}
+
+TEST_F(TpmOwnershipDBusProxyTest, TakeOwnership) {
+ auto fake_dbus_call = [](
+ dbus::MethodCall* method_call,
+ const dbus::MockObjectProxy::ResponseCallback& response_callback) {
+ // Verify request protobuf.
+ dbus::MessageReader reader(method_call);
+ TakeOwnershipRequest request;
+ EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
+ // Create reply protobuf.
+ auto response = dbus::Response::CreateEmpty();
+ dbus::MessageWriter writer(response.get());
+ TakeOwnershipReply reply;
+ reply.set_status(STATUS_SUCCESS);
+ writer.AppendProtoAsArrayOfBytes(reply);
+ response_callback.Run(response.release());
+ };
+ EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
+ .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
+
+ // Set expectations on the outputs.
+ int callback_count = 0;
+ auto callback = [&callback_count](const TakeOwnershipReply& reply) {
+ callback_count++;
+ EXPECT_EQ(STATUS_SUCCESS, reply.status());
+ };
+ TakeOwnershipRequest request;
+ proxy_.TakeOwnership(request, base::Bind(callback));
+ EXPECT_EQ(1, callback_count);
+}
+
+} // namespace tpm_manager
diff --git a/common/mock_tpm_manager_interface.h b/common/mock_tpm_manager_interface.h
deleted file mode 100644
index 8246754..0000000
--- a/common/mock_tpm_manager_interface.h
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef TPM_MANAGER_COMMON_MOCK_TPM_MANAGER_INTERFACE_H_
-#define TPM_MANAGER_COMMON_MOCK_TPM_MANAGER_INTERFACE_H_
-
-#include "tpm_manager/common/tpm_manager_interface.h"
-
-#include <gmock/gmock.h>
-
-namespace tpm_manager {
-
-class MockTpmManagerInterface : public TpmManagerInterface {
- public:
- MockTpmManagerInterface();
- ~MockTpmManagerInterface() override;
-
- MOCK_METHOD0(Initialize, bool());
- MOCK_METHOD2(GetTpmStatus,
- void(const GetTpmStatusRequest& request,
- const GetTpmStatusCallback& callback));
- MOCK_METHOD2(TakeOwnership,
- void(const TakeOwnershipRequest& request,
- const TakeOwnershipCallback& callback));
- MOCK_METHOD2(DefineNvram,
- void(const DefineNvramRequest& request,
- const DefineNvramCallback& callback));
- MOCK_METHOD2(DestroyNvram,
- void(const DestroyNvramRequest& request,
- const DestroyNvramCallback& callback));
- MOCK_METHOD2(WriteNvram,
- void(const WriteNvramRequest& request,
- const WriteNvramCallback& callback));
- MOCK_METHOD2(ReadNvram,
- void(const ReadNvramRequest& request,
- const ReadNvramCallback& callback));
- MOCK_METHOD2(IsNvramDefined,
- void(const IsNvramDefinedRequest& request,
- const IsNvramDefinedCallback& callback));
- MOCK_METHOD2(IsNvramLocked,
- void(const IsNvramLockedRequest& request,
- const IsNvramLockedCallback& callback));
- MOCK_METHOD2(GetNvramSize,
- void(const GetNvramSizeRequest& request,
- const GetNvramSizeCallback& callback));
-};
-
-} // namespace tpm_manager
-
-#endif // TPM_MANAGER_COMMON_MOCK_TPM_MANAGER_INTERFACE_H_
diff --git a/common/mock_tpm_manager_interface.cc b/common/mock_tpm_nvram_interface.cc
similarity index 79%
copy from common/mock_tpm_manager_interface.cc
copy to common/mock_tpm_nvram_interface.cc
index a585597..d0c12c1 100644
--- a/common/mock_tpm_manager_interface.cc
+++ b/common/mock_tpm_nvram_interface.cc
@@ -14,11 +14,11 @@
// limitations under the License.
//
-#include "tpm_manager/common/mock_tpm_manager_interface.h"
+#include "tpm_manager/common/mock_tpm_nvram_interface.h"
namespace tpm_manager {
-MockTpmManagerInterface::MockTpmManagerInterface() {}
-MockTpmManagerInterface::~MockTpmManagerInterface() {}
+MockTpmNvramInterface::MockTpmNvramInterface() {}
+MockTpmNvramInterface::~MockTpmNvramInterface() {}
} // namespace tpm_manager
diff --git a/common/mock_tpm_nvram_interface.h b/common/mock_tpm_nvram_interface.h
new file mode 100644
index 0000000..c7360e7
--- /dev/null
+++ b/common/mock_tpm_nvram_interface.h
@@ -0,0 +1,49 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef TPM_MANAGER_COMMON_MOCK_TPM_NVRAM_INTERFACE_H_
+#define TPM_MANAGER_COMMON_MOCK_TPM_NVRAM_INTERFACE_H_
+
+#include <gmock/gmock.h>
+
+#include "tpm_manager/common/tpm_nvram_interface.h"
+
+namespace tpm_manager {
+
+class MockTpmNvramInterface : public TpmNvramInterface {
+ public:
+ MockTpmNvramInterface();
+ ~MockTpmNvramInterface() override;
+
+ MOCK_METHOD2(DefineNvram, void(const DefineNvramRequest& request,
+ const DefineNvramCallback& callback));
+ MOCK_METHOD2(DestroyNvram, void(const DestroyNvramRequest& request,
+ const DestroyNvramCallback& callback));
+ MOCK_METHOD2(WriteNvram, void(const WriteNvramRequest& request,
+ const WriteNvramCallback& callback));
+ MOCK_METHOD2(ReadNvram, void(const ReadNvramRequest& request,
+ const ReadNvramCallback& callback));
+ MOCK_METHOD2(IsNvramDefined, void(const IsNvramDefinedRequest& request,
+ const IsNvramDefinedCallback& callback));
+ MOCK_METHOD2(IsNvramLocked, void(const IsNvramLockedRequest& request,
+ const IsNvramLockedCallback& callback));
+ MOCK_METHOD2(GetNvramSize, void(const GetNvramSizeRequest& request,
+ const GetNvramSizeCallback& callback));
+};
+
+} // namespace tpm_manager
+
+#endif // TPM_MANAGER_COMMON_MOCK_TPM_NVRAM_INTERFACE_H_
diff --git a/common/mock_tpm_manager_interface.cc b/common/mock_tpm_ownership_interface.cc
similarity index 79%
rename from common/mock_tpm_manager_interface.cc
rename to common/mock_tpm_ownership_interface.cc
index a585597..ebc3bd6 100644
--- a/common/mock_tpm_manager_interface.cc
+++ b/common/mock_tpm_ownership_interface.cc
@@ -14,11 +14,11 @@
// limitations under the License.
//
-#include "tpm_manager/common/mock_tpm_manager_interface.h"
+#include "tpm_manager/common/mock_tpm_ownership_interface.h"
namespace tpm_manager {
-MockTpmManagerInterface::MockTpmManagerInterface() {}
-MockTpmManagerInterface::~MockTpmManagerInterface() {}
+MockTpmOwnershipInterface::MockTpmOwnershipInterface() {}
+MockTpmOwnershipInterface::~MockTpmOwnershipInterface() {}
} // namespace tpm_manager
diff --git a/common/mock_tpm_ownership_interface.h b/common/mock_tpm_ownership_interface.h
new file mode 100644
index 0000000..5ae7ac6
--- /dev/null
+++ b/common/mock_tpm_ownership_interface.h
@@ -0,0 +1,39 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef TPM_MANAGER_COMMON_MOCK_TPM_OWNERSHIP_INTERFACE_H_
+#define TPM_MANAGER_COMMON_MOCK_TPM_OWNERSHIP_INTERFACE_H_
+
+#include <gmock/gmock.h>
+
+#include "tpm_manager/common/tpm_ownership_interface.h"
+
+namespace tpm_manager {
+
+class MockTpmOwnershipInterface : public TpmOwnershipInterface {
+ public:
+ MockTpmOwnershipInterface();
+ ~MockTpmOwnershipInterface() override;
+
+ MOCK_METHOD2(GetTpmStatus, void(const GetTpmStatusRequest& request,
+ const GetTpmStatusCallback& callback));
+ MOCK_METHOD2(TakeOwnership, void(const TakeOwnershipRequest& request,
+ const TakeOwnershipCallback& callback));
+};
+
+} // namespace tpm_manager
+
+#endif // TPM_MANAGER_COMMON_MOCK_TPM_OWNERSHIP_INTERFACE_H_
diff --git a/common/mock_tpm_manager_interface.cc b/common/tpm_manager_constants.h
similarity index 69%
copy from common/mock_tpm_manager_interface.cc
copy to common/tpm_manager_constants.h
index a585597..eabf378 100644
--- a/common/mock_tpm_manager_interface.cc
+++ b/common/tpm_manager_constants.h
@@ -14,11 +14,14 @@
// limitations under the License.
//
-#include "tpm_manager/common/mock_tpm_manager_interface.h"
+#ifndef TPM_MANAGER_COMMON_TPM_MANAGER_CONSTANTS_H_
+#define TPM_MANAGER_COMMON_TPM_MANAGER_CONSTANTS_H_
namespace tpm_manager {
-MockTpmManagerInterface::MockTpmManagerInterface() {}
-MockTpmManagerInterface::~MockTpmManagerInterface() {}
+constexpr char kTpmManagerServiceName[] = "org.chromium.TpmManager";
+constexpr char kTpmManagerServicePath[] = "/org/chromium/TpmManager";
} // namespace tpm_manager
+
+#endif // TPM_MANAGER_COMMON_TPM_MANAGER_CONSTANTS_H_
diff --git a/common/tpm_manager_interface.h b/common/tpm_manager_interface.h
deleted file mode 100644
index 531bdb9..0000000
--- a/common/tpm_manager_interface.h
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef TPM_MANAGER_COMMON_TPM_MANAGER_INTERFACE_H_
-#define TPM_MANAGER_COMMON_TPM_MANAGER_INTERFACE_H_
-
-#include <base/callback.h>
-
-#include "tpm_manager/common/export.h"
-#include "tpm_manager/common/tpm_nvram_interface.h"
-#include "tpm_manager/common/tpm_ownership_interface.h"
-
-namespace tpm_manager {
-
-// This is the main TpmManager interface that is implemented by the proxies
-// and services.
-// TODO(usanghi): Move this class into server/ since the client side will
-// implement each interface seperately.
-class TPM_MANAGER_EXPORT TpmManagerInterface : public TpmNvramInterface,
- public TpmOwnershipInterface {
- public:
- virtual ~TpmManagerInterface() = default;
-
- // Performs initialization tasks. This method must be called before calling
- // any other method on this interface.
- virtual bool Initialize() = 0;
-
- // TpmOwnershipInterface methods.
- virtual void GetTpmStatus(const GetTpmStatusRequest& request,
- const GetTpmStatusCallback& callback) = 0;
- virtual void TakeOwnership(const TakeOwnershipRequest& request,
- const TakeOwnershipCallback& callback) = 0;
-
- // TpmNvramInterface methods.
- virtual void DefineNvram(const DefineNvramRequest& request,
- const DefineNvramCallback& callback) = 0;
- virtual void DestroyNvram(const DestroyNvramRequest& request,
- const DestroyNvramCallback& callback) = 0;
- virtual void WriteNvram(const WriteNvramRequest& request,
- const WriteNvramCallback& callback) = 0;
- virtual void ReadNvram(const ReadNvramRequest& request,
- const ReadNvramCallback& callback) = 0;
- virtual void IsNvramDefined(const IsNvramDefinedRequest& request,
- const IsNvramDefinedCallback& callback) = 0;
- virtual void IsNvramLocked(const IsNvramLockedRequest& request,
- const IsNvramLockedCallback& callback) = 0;
- virtual void GetNvramSize(const GetNvramSizeRequest& request,
- const GetNvramSizeCallback& callback) = 0;
-};
-
-} // namespace tpm_manager
-
-#endif // TPM_MANAGER_COMMON_TPM_MANAGER_INTERFACE_H_
diff --git a/common/dbus_interface.h b/common/tpm_nvram_dbus_interface.h
similarity index 67%
rename from common/dbus_interface.h
rename to common/tpm_nvram_dbus_interface.h
index d8ebc24..cd70595 100644
--- a/common/dbus_interface.h
+++ b/common/tpm_nvram_dbus_interface.h
@@ -14,18 +14,14 @@
// limitations under the License.
//
-#ifndef TPM_MANAGER_COMMON_DBUS_INTERFACE_H_
-#define TPM_MANAGER_COMMON_DBUS_INTERFACE_H_
+#ifndef TPM_MANAGER_COMMON_TPM_NVRAM_DBUS_INTERFACE_H_
+#define TPM_MANAGER_COMMON_TPM_NVRAM_DBUS_INTERFACE_H_
namespace tpm_manager {
-constexpr char kTpmManagerInterface[] = "org.chromium.TpmManager";
-constexpr char kTpmManagerServicePath[] = "/org/chromium/TpmManager";
-constexpr char kTpmManagerServiceName[] = "org.chromium.TpmManager";
+constexpr char kTpmNvramInterface[] = "org.chromium.TpmNvram";
-// Methods exported by tpm_manager.
-constexpr char kGetTpmStatus[] = "GetTpmStatus";
-constexpr char kTakeOwnership[] = "TakeOwnership";
+// Methods exported by tpm_manager nvram D-Bus interface.
constexpr char kDefineNvram[] = "DefineNvram";
constexpr char kDestroyNvram[] = "DestroyNvram";
constexpr char kWriteNvram[] = "WriteNvram";
@@ -36,4 +32,4 @@
} // namespace tpm_manager
-#endif // TPM_MANAGER_COMMON_DBUS_INTERFACE_H_
+#endif // TPM_MANAGER_COMMON_TPM_NVRAM_DBUS_INTERFACE_H_
diff --git a/common/mock_tpm_manager_interface.cc b/common/tpm_ownership_dbus_interface.h
similarity index 61%
copy from common/mock_tpm_manager_interface.cc
copy to common/tpm_ownership_dbus_interface.h
index a585597..979b0ff 100644
--- a/common/mock_tpm_manager_interface.cc
+++ b/common/tpm_ownership_dbus_interface.h
@@ -14,11 +14,17 @@
// limitations under the License.
//
-#include "tpm_manager/common/mock_tpm_manager_interface.h"
+#ifndef TPM_MANAGER_COMMON_TPM_OWNERSHIP_DBUS_INTERFACE_H_
+#define TPM_MANAGER_COMMON_TPM_OWNERSHIP_DBUS_INTERFACE_H_
namespace tpm_manager {
-MockTpmManagerInterface::MockTpmManagerInterface() {}
-MockTpmManagerInterface::~MockTpmManagerInterface() {}
+constexpr char kTpmOwnershipInterface[] = "org.chromium.TpmOwnership";
+
+// Methods exported by tpm_manager ownership D-Bus interface.
+constexpr char kGetTpmStatus[] = "GetTpmStatus";
+constexpr char kTakeOwnership[] = "TakeOwnership";
} // namespace tpm_manager
+
+#endif // TPM_MANAGER_COMMON_TPM_OWNERSHIP_DBUS_INTERFACE_H_
diff --git a/server/dbus_service.cc b/server/dbus_service.cc
index 09c569f..2859ca9 100644
--- a/server/dbus_service.cc
+++ b/server/dbus_service.cc
@@ -23,90 +23,97 @@
#include <dbus/bus.h>
#include <dbus/object_path.h>
-#include "tpm_manager/common/dbus_interface.h"
+#include "tpm_manager/common/tpm_manager_constants.h"
+#include "tpm_manager/common/tpm_nvram_dbus_interface.h"
+#include "tpm_manager/common/tpm_ownership_dbus_interface.h"
namespace tpm_manager {
DBusService::DBusService(const scoped_refptr<dbus::Bus>& bus,
- TpmManagerInterface* service)
+ TpmNvramInterface* nvram_service,
+ TpmOwnershipInterface* ownership_service)
: dbus_object_(nullptr, bus, dbus::ObjectPath(kTpmManagerServicePath)),
- service_(service) {}
+ nvram_service_(nvram_service),
+ ownership_service_(ownership_service) {}
void DBusService::Register(const CompletionAction& callback) {
- brillo::dbus_utils::DBusInterface* dbus_interface =
- dbus_object_.AddOrGetInterface(kTpmManagerInterface);
+ brillo::dbus_utils::DBusInterface* ownership_dbus_interface =
+ dbus_object_.AddOrGetInterface(kTpmOwnershipInterface);
- dbus_interface->AddMethodHandler(
+ ownership_dbus_interface->AddMethodHandler(
kGetTpmStatus,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleOwnershipDBusMethod<
GetTpmStatusRequest,
GetTpmStatusReply,
- &TpmManagerInterface::GetTpmStatus>);
+ &TpmOwnershipInterface::GetTpmStatus>);
- dbus_interface->AddMethodHandler(
+ ownership_dbus_interface->AddMethodHandler(
kTakeOwnership,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleOwnershipDBusMethod<
TakeOwnershipRequest,
TakeOwnershipReply,
- &TpmManagerInterface::TakeOwnership>);
+ &TpmOwnershipInterface::TakeOwnership>);
- dbus_interface->AddMethodHandler(
+ brillo::dbus_utils::DBusInterface* nvram_dbus_interface =
+ dbus_object_.AddOrGetInterface(kTpmNvramInterface);
+
+ nvram_dbus_interface->AddMethodHandler(
kDefineNvram,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
DefineNvramRequest,
DefineNvramReply,
- &TpmManagerInterface::DefineNvram>);
+ &TpmNvramInterface::DefineNvram>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kDestroyNvram,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
DestroyNvramRequest,
DestroyNvramReply,
- &TpmManagerInterface::DestroyNvram>);
+ &TpmNvramInterface::DestroyNvram>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kWriteNvram,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
WriteNvramRequest,
WriteNvramReply,
- &TpmManagerInterface::WriteNvram>);
+ &TpmNvramInterface::WriteNvram>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kReadNvram,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
ReadNvramRequest,
ReadNvramReply,
- &TpmManagerInterface::ReadNvram>);
+ &TpmNvramInterface::ReadNvram>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kIsNvramDefined,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
IsNvramDefinedRequest,
IsNvramDefinedReply,
- &TpmManagerInterface::IsNvramDefined>);
+ &TpmNvramInterface::IsNvramDefined>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kIsNvramLocked,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
IsNvramLockedRequest,
IsNvramLockedReply,
- &TpmManagerInterface::IsNvramLocked>);
+ &TpmNvramInterface::IsNvramLocked>);
- dbus_interface->AddMethodHandler(
+ nvram_dbus_interface->AddMethodHandler(
kGetNvramSize,
base::Unretained(this),
- &DBusService::HandleDBusMethod<
+ &DBusService::HandleNvramDBusMethod<
GetNvramSizeRequest,
GetNvramSizeReply,
- &TpmManagerInterface::GetNvramSize>);
+ &TpmNvramInterface::GetNvramSize>);
dbus_object_.RegisterAsync(callback);
}
@@ -114,11 +121,12 @@
template<typename RequestProtobufType,
typename ReplyProtobufType,
DBusService::HandlerFunction<RequestProtobufType,
- ReplyProtobufType> func>
-void DBusService::HandleDBusMethod(
+ ReplyProtobufType,
+ TpmNvramInterface> func>
+void DBusService::HandleNvramDBusMethod(
std::unique_ptr<DBusMethodResponse<const ReplyProtobufType&>> response,
const RequestProtobufType& request) {
- // Convert |response| to a shared_ptr so |service_| can safely copy the
+ // Convert |response| to a shared_ptr so |nvram_service_| can safely copy the
// callback.
using SharedResponsePointer = std::shared_ptr<
DBusMethodResponse<const ReplyProtobufType&>>;
@@ -127,7 +135,29 @@
const ReplyProtobufType& reply) {
response->Return(reply);
};
- (service_->*func)(
+ (nvram_service_->*func)(
+ request,
+ base::Bind(callback, SharedResponsePointer(std::move(response))));
+}
+
+template<typename RequestProtobufType,
+ typename ReplyProtobufType,
+ DBusService::HandlerFunction<RequestProtobufType,
+ ReplyProtobufType,
+ TpmOwnershipInterface> func>
+void DBusService::HandleOwnershipDBusMethod(
+ std::unique_ptr<DBusMethodResponse<const ReplyProtobufType&>> response,
+ const RequestProtobufType& request) {
+ // Convert |response| to a shared_ptr so |ownership_service_| can safely
+ // copy the callback.
+ using SharedResponsePointer = std::shared_ptr<
+ DBusMethodResponse<const ReplyProtobufType&>>;
+ // A callback that sends off the reply protobuf.
+ auto callback = [](const SharedResponsePointer& response,
+ const ReplyProtobufType& reply) {
+ response->Return(reply);
+ };
+ (ownership_service_->*func)(
request,
base::Bind(callback, SharedResponsePointer(std::move(response))));
}
diff --git a/server/dbus_service.h b/server/dbus_service.h
index e5502c6..4746310 100644
--- a/server/dbus_service.h
+++ b/server/dbus_service.h
@@ -23,7 +23,8 @@
#include <brillo/dbus/dbus_object.h>
#include <dbus/bus.h>
-#include "tpm_manager/common/tpm_manager_interface.h"
+#include "tpm_manager/common/tpm_nvram_interface.h"
+#include "tpm_manager/common/tpm_ownership_interface.h"
namespace tpm_manager {
@@ -34,10 +35,12 @@
// Handles D-Bus communtion with the TpmManager daemon.
class DBusService {
public:
- // Does not take ownership of |service|. |service| must remain valid for the
+ // Does not take ownership of |nvram_service| or |ownership_service|. The
+ // services proviced must be initialized, and must remain valid for the
// lifetime of this instance.
DBusService(const scoped_refptr<dbus::Bus>& bus,
- TpmManagerInterface* service);
+ TpmNvramInterface* nvram_service,
+ TpmOwnershipInterface* ownership_service);
virtual ~DBusService() = default;
// Connects to D-Bus system bus and exports TpmManager methods.
@@ -47,22 +50,34 @@
friend class DBusServiceTest;
template<typename RequestProtobufType,
- typename ReplyProtobufType>
- using HandlerFunction = void(TpmManagerInterface::*)(
+ typename ReplyProtobufType,
+ typename TpmInterface>
+ using HandlerFunction = void(TpmInterface::*)(
const RequestProtobufType&,
const base::Callback<void(const ReplyProtobufType&)>&);
- // Template to handle D-Bus calls.
+ // Templates to handle D-Bus calls.
template<typename RequestProtobufType,
typename ReplyProtobufType,
DBusService::HandlerFunction<RequestProtobufType,
- ReplyProtobufType> func>
- void HandleDBusMethod(
+ ReplyProtobufType,
+ TpmNvramInterface> func>
+ void HandleNvramDBusMethod(
+ std::unique_ptr<DBusMethodResponse<const ReplyProtobufType&>> response,
+ const RequestProtobufType& request);
+
+ template<typename RequestProtobufType,
+ typename ReplyProtobufType,
+ DBusService::HandlerFunction<RequestProtobufType,
+ ReplyProtobufType,
+ TpmOwnershipInterface> func>
+ void HandleOwnershipDBusMethod(
std::unique_ptr<DBusMethodResponse<const ReplyProtobufType&>> response,
const RequestProtobufType& request);
brillo::dbus_utils::DBusObject dbus_object_;
- TpmManagerInterface* service_;
+ TpmNvramInterface* nvram_service_;
+ TpmOwnershipInterface* ownership_service_;
DISALLOW_COPY_AND_ASSIGN(DBusService);
};
diff --git a/server/dbus_service_test.cc b/server/dbus_service_test.cc
index 2e9230a..25c7bbe 100644
--- a/server/dbus_service_test.cc
+++ b/server/dbus_service_test.cc
@@ -23,8 +23,11 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-#include "tpm_manager/common/dbus_interface.h"
-#include "tpm_manager/common/mock_tpm_manager_interface.h"
+#include "tpm_manager/common/mock_tpm_nvram_interface.h"
+#include "tpm_manager/common/mock_tpm_ownership_interface.h"
+#include "tpm_manager/common/tpm_manager_constants.h"
+#include "tpm_manager/common/tpm_nvram_dbus_interface.h"
+#include "tpm_manager/common/tpm_ownership_dbus_interface.h"
#include "tpm_manager/server/dbus_service.h"
using testing::_;
@@ -47,7 +50,9 @@
mock_bus_.get(), path);
ON_CALL(*mock_bus_, GetExportedObject(path))
.WillByDefault(Return(mock_exported_object_.get()));
- dbus_service_.reset(new DBusService(mock_bus_, &mock_service_));
+ dbus_service_.reset(new DBusService(mock_bus_,
+ &mock_nvram_service_,
+ &mock_ownership_service_));
dbus_service_->Register(brillo::dbus_utils::AsyncEventSequencer::
GetDefaultCompletionAction());
}
@@ -55,39 +60,38 @@
template<typename RequestProtobufType, typename ReplyProtobufType>
void ExecuteMethod(const std::string& method_name,
const RequestProtobufType& request,
- ReplyProtobufType* reply) {
- std::unique_ptr<dbus::MethodCall> call = CreateMethodCall(method_name);
+ ReplyProtobufType* reply,
+ const std::string& interface) {
+ std::unique_ptr<dbus::MethodCall> call = CreateMethodCall(method_name,
+ interface);
dbus::MessageWriter writer(call.get());
writer.AppendProtoAsArrayOfBytes(request);
- auto response = CallMethod(call.get());
+ auto response = brillo::dbus_utils::testing::CallMethod(
+ dbus_service_->dbus_object_, method_call);
dbus::MessageReader reader(response.get());
EXPECT_TRUE(reader.PopArrayOfBytesAsProto(reply));
}
protected:
- std::unique_ptr<dbus::Response> CallMethod(dbus::MethodCall* method_call) {
- return brillo::dbus_utils::testing::CallMethod(
- dbus_service_->dbus_object_, method_call);
- }
-
std::unique_ptr<dbus::MethodCall> CreateMethodCall(
- const std::string& method_name) {
+ const std::string& method_name, const std::string& interface) {
std::unique_ptr<dbus::MethodCall> call(new dbus::MethodCall(
- kTpmManagerInterface, method_name));
+ interface, method_name));
call->SetSerial(1);
return call;
}
scoped_refptr<dbus::MockBus> mock_bus_;
scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
- StrictMock<MockTpmManagerInterface> mock_service_;
+ StrictMock<MockTpmNvramInterface> mock_nvram_service_;
+ StrictMock<MockTpmOwnershipInterface> mock_ownership_service_;
std::unique_ptr<DBusService> dbus_service_;
};
TEST_F(DBusServiceTest, CopyableCallback) {
- EXPECT_CALL(mock_service_, GetTpmStatus(_, _))
- .WillOnce(WithArgs<1>(
- Invoke([](const TpmManagerInterface::GetTpmStatusCallback& callback) {
+ EXPECT_CALL(mock_ownership_service_, GetTpmStatus(_, _))
+ .WillOnce(WithArgs<1>(Invoke([](
+ const TpmOwnershipInterface::GetTpmStatusCallback& callback) {
// Copy the callback, then call the original.
GetTpmStatusReply reply;
base::Closure copy = base::Bind(callback, reply);
@@ -95,15 +99,15 @@
})));
GetTpmStatusRequest request;
GetTpmStatusReply reply;
- ExecuteMethod(kGetTpmStatus, request, &reply);
+ ExecuteMethod(kGetTpmStatus, request, &reply, kTpmOwnershipInterface);
}
TEST_F(DBusServiceTest, GetTpmStatus) {
GetTpmStatusRequest request;
- EXPECT_CALL(mock_service_, GetTpmStatus(_, _))
+ EXPECT_CALL(mock_ownership_service_, GetTpmStatus(_, _))
.WillOnce(Invoke([](
const GetTpmStatusRequest& request,
- const TpmManagerInterface::GetTpmStatusCallback& callback) {
+ const TpmOwnershipInterface::GetTpmStatusCallback& callback) {
GetTpmStatusReply reply;
reply.set_status(STATUS_SUCCESS);
reply.set_enabled(true);
@@ -116,7 +120,7 @@
callback.Run(reply);
}));
GetTpmStatusReply reply;
- ExecuteMethod(kGetTpmStatus, request, &reply);
+ ExecuteMethod(kGetTpmStatus, request, &reply, kTpmOwnershipInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
EXPECT_TRUE(reply.enabled());
EXPECT_TRUE(reply.owned());
@@ -128,17 +132,17 @@
}
TEST_F(DBusServiceTest, TakeOwnership) {
- EXPECT_CALL(mock_service_, TakeOwnership(_, _))
+ EXPECT_CALL(mock_ownership_service_, TakeOwnership(_, _))
.WillOnce(Invoke([](
const TakeOwnershipRequest& request,
- const TpmManagerInterface::TakeOwnershipCallback& callback) {
+ const TpmOwnershipInterface::TakeOwnershipCallback& callback) {
TakeOwnershipReply reply;
reply.set_status(STATUS_SUCCESS);
callback.Run(reply);
}));
TakeOwnershipRequest request;
TakeOwnershipReply reply;
- ExecuteMethod(kTakeOwnership, request, &reply);
+ ExecuteMethod(kTakeOwnership, request, &reply, kTpmOwnershipInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
}
@@ -148,10 +152,10 @@
DefineNvramRequest request;
request.set_index(nvram_index);
request.set_length(nvram_length);
- EXPECT_CALL(mock_service_, DefineNvram(_, _))
+ EXPECT_CALL(mock_nvram_service_, DefineNvram(_, _))
.WillOnce(Invoke([nvram_index, nvram_length](
const DefineNvramRequest& request,
- const TpmManagerInterface::DefineNvramCallback& callback) {
+ const TpmNvramInterface::DefineNvramCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
EXPECT_TRUE(request.has_length());
@@ -161,7 +165,7 @@
callback.Run(reply);
}));
DefineNvramReply reply;
- ExecuteMethod(kDefineNvram, request, &reply);
+ ExecuteMethod(kDefineNvram, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
}
@@ -169,10 +173,10 @@
uint32_t nvram_index = 5;
DestroyNvramRequest request;
request.set_index(nvram_index);
- EXPECT_CALL(mock_service_, DestroyNvram(_, _))
+ EXPECT_CALL(mock_nvram_service_, DestroyNvram(_, _))
.WillOnce(Invoke([nvram_index](
const DestroyNvramRequest& request,
- const TpmManagerInterface::DestroyNvramCallback& callback) {
+ const TpmNvramInterface::DestroyNvramCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
DestroyNvramReply reply;
@@ -180,7 +184,7 @@
callback.Run(reply);
}));
DestroyNvramReply reply;
- ExecuteMethod(kDestroyNvram, request, &reply);
+ ExecuteMethod(kDestroyNvram, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
}
@@ -190,10 +194,10 @@
WriteNvramRequest request;
request.set_index(nvram_index);
request.set_data(nvram_data);
- EXPECT_CALL(mock_service_, WriteNvram(_, _))
+ EXPECT_CALL(mock_nvram_service_, WriteNvram(_, _))
.WillOnce(Invoke([nvram_index, nvram_data](
const WriteNvramRequest& request,
- const TpmManagerInterface::WriteNvramCallback& callback) {
+ const TpmNvramInterface::WriteNvramCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
EXPECT_TRUE(request.has_data());
@@ -203,7 +207,7 @@
callback.Run(reply);
}));
WriteNvramReply reply;
- ExecuteMethod(kWriteNvram, request, &reply);
+ ExecuteMethod(kWriteNvram, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
}
@@ -212,10 +216,10 @@
std::string nvram_data("nvram_data");
ReadNvramRequest request;
request.set_index(nvram_index);
- EXPECT_CALL(mock_service_, ReadNvram(_, _))
+ EXPECT_CALL(mock_nvram_service_, ReadNvram(_, _))
.WillOnce(Invoke([nvram_index, nvram_data](
const ReadNvramRequest& request,
- const TpmManagerInterface::ReadNvramCallback& callback) {
+ const TpmNvramInterface::ReadNvramCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
ReadNvramReply reply;
@@ -224,7 +228,7 @@
callback.Run(reply);
}));
ReadNvramReply reply;
- ExecuteMethod(kReadNvram, request, &reply);
+ ExecuteMethod(kReadNvram, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
EXPECT_TRUE(reply.has_data());
EXPECT_EQ(nvram_data, reply.data());
@@ -235,10 +239,10 @@
bool nvram_defined = true;
IsNvramDefinedRequest request;
request.set_index(nvram_index);
- EXPECT_CALL(mock_service_, IsNvramDefined(_, _))
+ EXPECT_CALL(mock_nvram_service_, IsNvramDefined(_, _))
.WillOnce(Invoke([nvram_index, nvram_defined](
const IsNvramDefinedRequest& request,
- const TpmManagerInterface::IsNvramDefinedCallback& callback) {
+ const TpmNvramInterface::IsNvramDefinedCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
IsNvramDefinedReply reply;
@@ -247,7 +251,7 @@
callback.Run(reply);
}));
IsNvramDefinedReply reply;
- ExecuteMethod(kIsNvramDefined, request, &reply);
+ ExecuteMethod(kIsNvramDefined, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
EXPECT_TRUE(reply.has_is_defined());
EXPECT_EQ(nvram_defined, reply.is_defined());
@@ -258,10 +262,10 @@
bool nvram_locked = true;
IsNvramLockedRequest request;
request.set_index(nvram_index);
- EXPECT_CALL(mock_service_, IsNvramLocked(_, _))
+ EXPECT_CALL(mock_nvram_service_, IsNvramLocked(_, _))
.WillOnce(Invoke([nvram_index, nvram_locked](
const IsNvramLockedRequest& request,
- const TpmManagerInterface::IsNvramLockedCallback& callback) {
+ const TpmNvramInterface::IsNvramLockedCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
IsNvramLockedReply reply;
@@ -270,7 +274,7 @@
callback.Run(reply);
}));
IsNvramLockedReply reply;
- ExecuteMethod(kIsNvramLocked, request, &reply);
+ ExecuteMethod(kIsNvramLocked, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
EXPECT_TRUE(reply.has_is_locked());
EXPECT_EQ(nvram_locked, reply.is_locked());
@@ -281,10 +285,10 @@
size_t nvram_size = 32;
GetNvramSizeRequest request;
request.set_index(nvram_index);
- EXPECT_CALL(mock_service_, GetNvramSize(_, _))
+ EXPECT_CALL(mock_nvram_service_, GetNvramSize(_, _))
.WillOnce(Invoke([nvram_index, nvram_size](
const GetNvramSizeRequest& request,
- const TpmManagerInterface::GetNvramSizeCallback& callback) {
+ const TpmNvramInterface::GetNvramSizeCallback& callback) {
EXPECT_TRUE(request.has_index());
EXPECT_EQ(nvram_index, request.index());
GetNvramSizeReply reply;
@@ -293,7 +297,7 @@
callback.Run(reply);
}));
GetNvramSizeReply reply;
- ExecuteMethod(kGetNvramSize, request, &reply);
+ ExecuteMethod(kGetNvramSize, request, &reply, kTpmNvramInterface);
EXPECT_EQ(STATUS_SUCCESS, reply.status());
EXPECT_TRUE(reply.has_size());
EXPECT_EQ(nvram_size, reply.size());
diff --git a/server/main.cc b/server/main.cc
index 307334f..8a4e74c 100644
--- a/server/main.cc
+++ b/server/main.cc
@@ -24,7 +24,7 @@
#include <brillo/syslog_logging.h>
#include <brillo/userdb_utils.h>
-#include "tpm_manager/common/dbus_interface.h"
+#include "tpm_manager/common/tpm_manager_constants.h"
#include "tpm_manager/server/dbus_service.h"
#include "tpm_manager/server/local_data_store_impl.h"
#include "tpm_manager/server/tpm_manager_service.h"
@@ -85,7 +85,7 @@
void RegisterDBusObjectsAsync(AsyncEventSequencer* sequencer) override {
dbus_service_.reset(new tpm_manager::DBusService(
- bus_, tpm_manager_service_.get()));
+ bus_, tpm_manager_service_.get(), tpm_manager_service_.get()));
dbus_service_->Register(sequencer->GetHandler("Register() failed.", true));
}
@@ -94,7 +94,7 @@
std::unique_ptr<tpm_manager::TpmStatus> tpm_status_;
std::unique_ptr<tpm_manager::TpmInitializer> tpm_initializer_;
std::unique_ptr<tpm_manager::TpmNvram> tpm_nvram_;
- std::unique_ptr<tpm_manager::TpmManagerInterface> tpm_manager_service_;
+ std::unique_ptr<tpm_manager::TpmManagerService> tpm_manager_service_;
std::unique_ptr<tpm_manager::DBusService> dbus_service_;
DISALLOW_COPY_AND_ASSIGN(TpmManagerDaemon);
diff --git a/server/tpm_manager_service.h b/server/tpm_manager_service.h
index 6fc7afa..64196d4 100644
--- a/server/tpm_manager_service.h
+++ b/server/tpm_manager_service.h
@@ -17,8 +17,6 @@
#ifndef TPM_MANAGER_SERVER_TPM_MANAGER_SERVICE_H_
#define TPM_MANAGER_SERVER_TPM_MANAGER_SERVICE_H_
-#include "tpm_manager/common/tpm_manager_interface.h"
-
#include <memory>
#include <base/callback.h>
@@ -27,6 +25,8 @@
#include <base/threading/thread.h>
#include <brillo/bind_lambda.h>
+#include "tpm_manager/common/tpm_nvram_interface.h"
+#include "tpm_manager/common/tpm_ownership_interface.h"
#include "tpm_manager/server/local_data_store.h"
#include "tpm_manager/server/tpm_initializer.h"
#include "tpm_manager/server/tpm_nvram.h"
@@ -37,7 +37,7 @@
// This class implements the core tpm_manager service. All Tpm access is
// asynchronous, except for the initial setup in Initialize().
// Usage:
-// std::unique_ptr<TpmManagerInterface> tpm_manager = new TpmManagerService();
+// std::unique_ptr<TpmManagerService> tpm_manager = new TpmManagerService();
// CHECK(tpm_manager->Initialize());
// tpm_manager->GetTpmStatus(...);
//
@@ -52,7 +52,8 @@
// safe because the thread is owned by this class (so it is guaranteed not to
// process a task after destruction). Weak pointers are used to post replies
// back to the main thread.
-class TpmManagerService : public TpmManagerInterface {
+class TpmManagerService : public TpmNvramInterface,
+ public TpmOwnershipInterface {
public:
// If |wait_for_ownership| is set, TPM initialization will be postponed until
// an explicit TakeOwnership request is received. Does not take ownership of
@@ -64,12 +65,17 @@
TpmNvram* tpm_nvram);
~TpmManagerService() override = default;
- // TpmManagerInterface methods.
- bool Initialize() override;
+ // Performs initialization tasks. This method must be called before calling
+ // any other method in this class. Returns true on success.
+ bool Initialize();
+
+ // TpmOwnershipInterface methods.
void GetTpmStatus(const GetTpmStatusRequest& request,
const GetTpmStatusCallback& callback) override;
void TakeOwnership(const TakeOwnershipRequest& request,
const TakeOwnershipCallback& callback) override;
+
+ // TpmNvramInterface methods.
void DefineNvram(const DefineNvramRequest& request,
const DefineNvramCallback& callback) override;
void DestroyNvram(const DestroyNvramRequest& request,
diff --git a/tpm_manager.gyp b/tpm_manager.gyp
index 8922ac9..8fd48cc 100644
--- a/tpm_manager.gyp
+++ b/tpm_manager.gyp
@@ -58,7 +58,8 @@
'target_name': 'libtpm_manager',
'type': 'shared_library',
'sources': [
- 'client/dbus_proxy.cc',
+ 'client/tpm_nvram_dbus_proxy.cc',
+ 'client/tpm_ownership_dbus_proxy.cc',
],
'dependencies': [
'proto_library',
@@ -149,8 +150,10 @@
],
},
'sources': [
- 'client/dbus_proxy_test.cc',
- 'common/mock_tpm_manager_interface.cc',
+ 'client/tpm_nvram_dbus_proxy_test.cc',
+ 'client/tpm_ownership_dbus_proxy_test.cc',
+ 'common/mock_tpm_nvram_interface.cc',
+ 'common/mock_tpm_ownership_interface.cc',
'server/dbus_service_test.cc',
'server/mock_local_data_store.cc',
'server/mock_openssl_crypto_util.cc',
