Home | History | Annotate | Download | only in client 
      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::DefineNvram(const DefineNvramRequest& request,
     51                                     const DefineNvramCallback& callback) {
     52   CallMethod<DefineNvramReply>(tpm_manager::kDefineNvram, request, callback);
     53 }
     54 
     55 void TpmNvramDBusProxy::DestroyNvram(const DestroyNvramRequest& request,
     56                                      const DestroyNvramCallback& callback) {
     57   CallMethod<DestroyNvramReply>(tpm_manager::kDestroyNvram, request, callback);
     58 }
     59 
     60 void TpmNvramDBusProxy::WriteNvram(const WriteNvramRequest& request,
     61                                    const WriteNvramCallback& callback) {
     62   CallMethod<WriteNvramReply>(tpm_manager::kWriteNvram, request, callback);
     63 }
     64 
     65 void TpmNvramDBusProxy::ReadNvram(const ReadNvramRequest& request,
     66                                   const ReadNvramCallback& callback) {
     67   CallMethod<ReadNvramReply>(tpm_manager::kReadNvram, request, callback);
     68 }
     69 
     70 void TpmNvramDBusProxy::IsNvramDefined(const IsNvramDefinedRequest& request,
     71                                        const IsNvramDefinedCallback& callback) {
     72   CallMethod<IsNvramDefinedReply>(
     73       tpm_manager::kIsNvramDefined, request, callback);
     74 }
     75 
     76 void TpmNvramDBusProxy::IsNvramLocked(const IsNvramLockedRequest& request,
     77                                       const IsNvramLockedCallback& callback) {
     78   CallMethod<IsNvramLockedReply>(
     79       tpm_manager::kIsNvramLocked, request, callback);
     80 }
     81 
     82 void TpmNvramDBusProxy::GetNvramSize(const GetNvramSizeRequest& request,
     83                                      const GetNvramSizeCallback& callback) {
     84   CallMethod<GetNvramSizeReply>(tpm_manager::kGetNvramSize, request, callback);
     85 }
     86 
     87 template<typename ReplyProtobufType,
     88          typename RequestProtobufType,
     89          typename CallbackType>
     90 void TpmNvramDBusProxy::CallMethod(const std::string& method_name,
     91                                    const RequestProtobufType& request,
     92                                    const CallbackType& callback) {
     93   auto on_error = [callback](brillo::Error* error) {
     94     ReplyProtobufType reply;
     95     reply.set_status(STATUS_NOT_AVAILABLE);
     96     callback.Run(reply);
     97   };
     98   brillo::dbus_utils::CallMethodWithTimeout(
     99       kDBusTimeoutMS,
    100       object_proxy_,
    101       tpm_manager::kTpmNvramInterface,
    102       method_name,
    103       callback,
    104       base::Bind(on_error),
    105       request);
    106 }
    107 
    108 }  // namespace tpm_manager
    109