1 //
2 // Copyright (C) 2015 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "tpm_manager/client/tpm_nvram_dbus_proxy.h"
18 
19 #include <brillo/bind_lambda.h>
20 #include <brillo/dbus/dbus_method_invoker.h>
21 
22 #include "tpm_manager/common/tpm_manager_constants.h"
23 #include "tpm_manager/common/tpm_nvram_dbus_interface.h"
24 
25 namespace {
26 
27 // Use a two minute timeout because TPM operations can take a long time.
28 const int kDBusTimeoutMS = 2 * 60 * 1000;
29 
30 }  // namespace
31 
32 namespace tpm_manager {
33 
34 TpmNvramDBusProxy::~TpmNvramDBusProxy() {
35   if (bus_) {
36     bus_->ShutdownAndBlock();
37   }
38 }
39 
40 bool TpmNvramDBusProxy::Initialize() {
41   dbus::Bus::Options options;
42   options.bus_type = dbus::Bus::SYSTEM;
43   bus_ = new dbus::Bus(options);
44   object_proxy_ = bus_->GetObjectProxy(
45       tpm_manager::kTpmManagerServiceName,
46       dbus::ObjectPath(tpm_manager::kTpmManagerServicePath));
47   return (object_proxy_ != nullptr);
48 }
49 
50 void TpmNvramDBusProxy::DefineSpace(const DefineSpaceRequest& request,
51                                     const DefineSpaceCallback& callback) {
52   CallMethod<DefineSpaceReply>(tpm_manager::kDefineSpace, request, callback);
53 }
54 
55 void TpmNvramDBusProxy::DestroySpace(const DestroySpaceRequest& request,
56                                      const DestroySpaceCallback& callback) {
57   CallMethod<DestroySpaceReply>(tpm_manager::kDestroySpace, request, callback);
58 }
59 
60 void TpmNvramDBusProxy::WriteSpace(const WriteSpaceRequest& request,
61                                    const WriteSpaceCallback& callback) {
62   CallMethod<WriteSpaceReply>(tpm_manager::kWriteSpace, request, callback);
63 }
64 
65 void TpmNvramDBusProxy::ReadSpace(const ReadSpaceRequest& request,
66                                   const ReadSpaceCallback& callback) {
67   CallMethod<ReadSpaceReply>(tpm_manager::kReadSpace, request, callback);
68 }
69 
70 void TpmNvramDBusProxy::LockSpace(const LockSpaceRequest& request,
71                                   const LockSpaceCallback& callback) {
72   CallMethod<LockSpaceReply>(tpm_manager::kLockSpace, request, callback);
73 }
74 
75 void TpmNvramDBusProxy::ListSpaces(const ListSpacesRequest& request,
76                                    const ListSpacesCallback& callback) {
77   CallMethod<ListSpacesReply>(tpm_manager::kListSpaces, request, callback);
78 }
79 
80 void TpmNvramDBusProxy::GetSpaceInfo(const GetSpaceInfoRequest& request,
81                                      const GetSpaceInfoCallback& callback) {
82   CallMethod<GetSpaceInfoReply>(tpm_manager::kGetSpaceInfo, request, callback);
83 }
84 
85 template <typename ReplyProtobufType,
86           typename RequestProtobufType,
87           typename CallbackType>
88 void TpmNvramDBusProxy::CallMethod(const std::string& method_name,
89                                    const RequestProtobufType& request,
90                                    const CallbackType& callback) {
91   auto on_error = [callback](brillo::Error* error) {
92     ReplyProtobufType reply;
93     reply.set_result(NVRAM_RESULT_IPC_ERROR);
94     callback.Run(reply);
95   };
96   brillo::dbus_utils::CallMethodWithTimeout(
97       kDBusTimeoutMS, object_proxy_, tpm_manager::kTpmNvramInterface,
98       method_name, callback, base::Bind(on_error), request);
99 }
100 
101 }  // namespace tpm_manager
102