// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "smbfs/authpolicy_client.h"

#include <memory>
#include <utility>

#include <base/bind.h>
#include <authpolicy/proto_bindings/active_directory_info.pb.h>
#include <dbus/authpolicy/dbus-constants.h>
#include <dbus/message.h>

namespace smbfs {
namespace {

authpolicy::ErrorType GetErrorFromReader(dbus::MessageReader* reader) {
  int32_t int_error;
  if (!reader->PopInt32(&int_error)) {
    DLOG(ERROR) << "AuthPolicyClient: Failed to get an error from the response";
    return authpolicy::ERROR_DBUS_FAILURE;
  }
  if (int_error < 0 || int_error >= authpolicy::ERROR_COUNT) {
    return authpolicy::ERROR_UNKNOWN;
  }
  return static_cast<authpolicy::ErrorType>(int_error);
}

authpolicy::ErrorType GetErrorAndProto(
    dbus::Response* response, google::protobuf::MessageLite* protobuf) {
  if (!response) {
    DLOG(ERROR) << "AuthPolicyClient: Failed to call to authpolicy";
    return authpolicy::ERROR_DBUS_FAILURE;
  }
  dbus::MessageReader reader(response);
  const authpolicy::ErrorType error = GetErrorFromReader(&reader);

  if (error != authpolicy::ERROR_NONE) {
    LOG(ERROR) << "AuthPolicyClient: Failed to get Kerberos files with error "
               << error;
    return error;
  }

  if (!reader.PopArrayOfBytesAsProto(protobuf)) {
    DLOG(ERROR) << "AuthPolicyClient: Failed to parse protobuf.";
    return authpolicy::ERROR_DBUS_FAILURE;
  }
  return authpolicy::ERROR_NONE;
}

}  // namespace

AuthPolicyClient::AuthPolicyClient(scoped_refptr<dbus::Bus> bus)
    : auth_policy_object_proxy_(bus->GetObjectProxy(
          authpolicy::kAuthPolicyServiceName,
          dbus::ObjectPath(authpolicy::kAuthPolicyServicePath))) {}

void AuthPolicyClient::GetUserKerberosFiles(
    const std::string& object_guid, GetUserKerberosFilesCallback callback) {
  dbus::MethodCall method_call(authpolicy::kAuthPolicyInterface,
                               authpolicy::kGetUserKerberosFilesMethod);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(object_guid);
  auth_policy_object_proxy_->CallMethod(
      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
      base::BindOnce(&AuthPolicyClient::HandleGetUserKeberosFiles,
                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}

void AuthPolicyClient::ConnectToKerberosFilesChangedSignal(
    dbus::ObjectProxy::SignalCallback signal_callback,
    dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
  auth_policy_object_proxy_->ConnectToSignal(
      authpolicy::kAuthPolicyInterface,
      authpolicy::kUserKerberosFilesChangedSignal, std::move(signal_callback),
      std::move(on_connected_callback));
}

void AuthPolicyClient::HandleGetUserKeberosFiles(
    GetUserKerberosFilesCallback callback, dbus::Response* response) {
  authpolicy::KerberosFiles files_proto;
  bool success =
      (GetErrorAndProto(response, &files_proto) == authpolicy::ERROR_NONE);
  if (success && (!files_proto.has_krb5cc() || !files_proto.has_krb5conf())) {
    LOG(ERROR) << "AuthPolicyClient: Kerberos files are empty.";
    success = false;
  }

  std::move(callback).Run(success, files_proto.krb5cc(),
                          files_proto.krb5conf());
}

}  // namespace smbfs