/*
 * Copyright 2016 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.
 */
#define LOG_TAG "VtsAgentRequestHandler"

#include "AgentRequestHandler.h"

#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <string>

#include <android-base/logging.h>

#include "BinderClientToDriver.h"
#include "SocketClientToDriver.h"
#include "SocketServerForDriver.h"
#include "test/vts/proto/AndroidSystemControlMessage.pb.h"
#include "test/vts/proto/VtsDriverControlMessage.pb.h"
#include "test/vts/proto/VtsResourceControllerMessage.pb.h"

using namespace std;
using namespace google::protobuf;

namespace android {
namespace vts {

bool AgentRequestHandler::ListHals(const RepeatedPtrField<string>& base_paths) {
  AndroidSystemControlResponseMessage response_msg;
  ResponseCode result = FAIL;

  for (const string& path : base_paths) {
    LOG(DEBUG) << "open a dir " << path;
    DIR* dp;
    if (!(dp = opendir(path.c_str()))) {
      LOG(ERROR) << "Error(" << errno << ") opening " << path;
      continue;
    }

    struct dirent* dirp;
    int len;
    while ((dirp = readdir(dp)) != NULL) {
      len = strlen(dirp->d_name);
      if (len > 3 && !strcmp(&dirp->d_name[len - 3], ".so")) {
        string found_path = path + "/" + string(dirp->d_name);
        LOG(INFO) << "found " << found_path;
        response_msg.add_file_names(found_path);
        result = SUCCESS;
      }
    }
    closedir(dp);
  }
  response_msg.set_response_code(result);
  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::SetHostInfo(const int callback_port) {
  callback_port_ = callback_port;
  AndroidSystemControlResponseMessage response_msg;
  response_msg.set_response_code(SUCCESS);
  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::CheckDriverService(const string& service_name,
                                             bool* live) {
  AndroidSystemControlResponseMessage response_msg;

#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  if (IsDriverRunning(service_name, 10)) {
#else  // binder
  sp<IVtsFuzzer> binder = GetBinderClient(service_name);
  if (binder.get()) {
#endif
    if (live) *live = true;
    response_msg.set_response_code(SUCCESS);
    response_msg.set_reason("found the service");
    LOG(DEBUG) << "set service_name " << service_name;
    service_name_ = service_name;
  } else {
    if (live) *live = false;
    response_msg.set_response_code(FAIL);
    response_msg.set_reason("service not found");
  }
  return VtsSocketSendMessage(response_msg);
}

static const char kUnixSocketNamePrefixForCallbackServer[] =
    "/data/local/tmp/vts_agent_callback";

bool AgentRequestHandler::LaunchDriverService(
    const AndroidSystemControlCommandMessage& command_msg) {
  int driver_type = command_msg.driver_type();
  const string& service_name = command_msg.service_name();
  const string& file_path = command_msg.file_path();
  int target_class = command_msg.target_class();
  int target_type = command_msg.target_type();
  int target_version_major = command_msg.target_version_major();
  int target_version_minor = command_msg.target_version_minor();
  const string& target_package = command_msg.target_package();
  const string& target_component_name = command_msg.target_component_name();
  const string& module_name = command_msg.module_name();
  const string& hw_binder_service_name = command_msg.hw_binder_service_name();
  int bits = command_msg.bits();
  const string& test_hal_flag =
      command_msg.is_test_hal() ? "TREBLE_TESTING_OVERRIDE=true " : "";

  LOG(DEBUG) << "file_path=" << file_path;
  ResponseCode result = FAIL;

  // TODO: shall check whether there's a service with the same name and return
  // success immediately if exists.
  AndroidSystemControlResponseMessage response_msg;

  // deletes the service file if exists before starting to launch a driver.
  string socket_port_flie_path = GetSocketPortFilePath(service_name);
  struct stat file_stat;
  if (stat(socket_port_flie_path.c_str(), &file_stat) == 0  // file exists
      && remove(socket_port_flie_path.c_str()) == -1) {
    LOG(ERROR) << socket_port_flie_path << " delete error";
    response_msg.set_reason("service file already exists.");
  } else {
    pid_t pid = fork();
    if (pid == 0) {  // child
      Close();

      string driver_binary_path;
      char* cmd = NULL;
      if (driver_type == VTS_DRIVER_TYPE_HAL_CONVENTIONAL ||
          driver_type == VTS_DRIVER_TYPE_HAL_LEGACY ||
          driver_type == VTS_DRIVER_TYPE_HAL_HIDL) {
        // TODO: check whether the port is available and handle if fails.
        static int port = 0;
        string callback_socket_name(kUnixSocketNamePrefixForCallbackServer);
        callback_socket_name += to_string(port++);
        LOG(INFO) << "callback_socket_name: " << callback_socket_name;
        StartSocketServerForDriver(callback_socket_name, -1);

        if (bits == 32) {
          driver_binary_path = driver_hal_binary32_;
        } else {
          driver_binary_path = driver_hal_binary64_;
        }
        size_t offset = driver_binary_path.find_last_of("/");
        string ld_dir_path = driver_binary_path.substr(0, offset);

        if (driver_hal_spec_dir_path_.length() < 1) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
          asprintf(&cmd,
                   "%sLD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s "
                   "--server_socket_path=%s "
                   "--callback_socket_name=%s",
                   test_hal_flag.c_str(), ld_dir_path.c_str(),
                   driver_binary_path.c_str(), socket_port_flie_path.c_str(),
                   callback_socket_name.c_str());
#else  // binder
          asprintf(&cmd,
                   "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s "
                   "--service_name=%s "
                   "--callback_socket_name=%s",
                   ld_dir_path.c_str(), driver_binary_path.c_str(),
                   service_name.c_str(), callback_socket_name.c_str());
#endif
        } else {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
          asprintf(&cmd,
                   "%sLD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s "
                   "--server_socket_path=%s "
                   "--spec_dir_path=%s --callback_socket_name=%s",
                   test_hal_flag.c_str(), ld_dir_path.c_str(),
                   driver_binary_path.c_str(), socket_port_flie_path.c_str(),
                   driver_hal_spec_dir_path_.c_str(),
                   callback_socket_name.c_str());
#else  // binder
          asprintf(&cmd,
                   "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s "
                   "--service_name=%s "
                   "--spec_dir_path=%s --callback_socket_name=%s",
                   ld_dir_path.c_str(), driver_binary_path.c_str(),
                   service_name.c_str(), driver_hal_spec_dir_path_.c_str(),
                   callback_socket_name.c_str());
#endif
        }
      } else if (driver_type == VTS_DRIVER_TYPE_SHELL) {
        if (bits == 32) {
          driver_binary_path = driver_shell_binary32_;
        } else {
          driver_binary_path = driver_shell_binary64_;
        }
        size_t offset = driver_binary_path.find_last_of("/");
        string ld_dir_path = driver_binary_path.substr(0, offset);

#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
        asprintf(
            &cmd,
            "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s --server_socket_path=%s",
            ld_dir_path.c_str(), driver_binary_path.c_str(),
            socket_port_flie_path.c_str());
#else  // binder
        LOG(ERROR) << "No binder implementation available.";
        exit(-1);
#endif
      } else {
        LOG(ERROR) << "Unsupported driver type.";
      }

      if (cmd) {
        LOG(INFO) << "Launch a driver - " << cmd;
        system(cmd);
        LOG(INFO) << "driver exits";
        free(cmd);
      }
      exit(0);
    } else if (pid > 0) {
      for (int attempt = 0; attempt < 10; attempt++) {
        sleep(1);
        if (IsDriverRunning(service_name, 10)) {
          result = SUCCESS;
          break;
        }
      }
      if (result) {
// TODO: use an attribute (client) of a newly defined class.
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
        VtsDriverSocketClient* client =
            android::vts::GetDriverSocketClient(service_name);
        if (!client) {
#else  // binder
        android::sp<android::vts::IVtsFuzzer> client =
            android::vts::GetBinderClient(service_name);
        if (!client.get()) {
#endif
          response_msg.set_response_code(FAIL);
          response_msg.set_reason("Failed to start a driver.");
          // TODO: kill the driver?
          return VtsSocketSendMessage(response_msg);
        }

        if (driver_type == VTS_DRIVER_TYPE_HAL_CONVENTIONAL ||
            driver_type == VTS_DRIVER_TYPE_HAL_LEGACY ||
            driver_type == VTS_DRIVER_TYPE_HAL_HIDL) {
          LOG(DEBUG) << "LoadHal " << module_name;
          int32_t driver_id = client->LoadHal(
              file_path, target_class, target_type, target_version_major,
              target_version_minor, target_package, target_component_name,
              hw_binder_service_name, module_name);
          if (driver_id == -1) {
            response_msg.set_response_code(FAIL);
            response_msg.set_reason("Failed to load the selected HAL.");
          } else {
            response_msg.set_response_code(SUCCESS);
            response_msg.set_result(to_string(driver_id));
            response_msg.set_reason("Loaded the selected HAL.");
            LOG(DEBUG) << "set service_name " << service_name;
            service_name_ = service_name;
          }
        } else if (driver_type == VTS_DRIVER_TYPE_SHELL) {
          response_msg.set_response_code(SUCCESS);
          response_msg.set_reason("Loaded the shell driver.");
          LOG(DEBUG) << "set service_name " << service_name;
          service_name_ = service_name;
        }

#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
        driver_client_ = client;
#endif
        return VtsSocketSendMessage(response_msg);
      }
    }
    response_msg.set_reason(
        "Failed to fork a child process to start a driver.");
  }
  response_msg.set_response_code(FAIL);
  LOG(ERROR) << "Can't fork a child process to run the vts_hal_driver.";
  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::ReadSpecification(
    const AndroidSystemControlCommandMessage& command_message) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    return false;
  }

  const string& result = client->ReadSpecification(
      command_message.service_name(), command_message.target_class(),
      command_message.target_type(), command_message.target_version_major(),
      command_message.target_version_minor(), command_message.target_package());

  return SendApiResult("ReadSpecification", result);
}

bool AgentRequestHandler::ListApis() {
// TODO: use an attribute (client) of a newly defined class.
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    return false;
  }
  return SendApiResult("GetAttribute", "", client->GetFunctions());
}

bool AgentRequestHandler::CallApi(const string& call_payload,
                                  const string& uid) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  // TODO: use an attribute (client) of a newly defined class.
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    return false;
  }

  return SendApiResult("Call", client->Call(call_payload, uid));
}

bool AgentRequestHandler::GetAttribute(const string& payload) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  // TODO: use an attribute (client) of a newly defined class.
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    return false;
  }

  return SendApiResult("GetAttribute", client->GetAttribute(payload));
}

bool AgentRequestHandler::SendApiResult(const string& func_name,
                                        const string& result,
                                        const string& spec) {
  AndroidSystemControlResponseMessage response_msg;
  if (result.size() > 0 || spec.size() > 0) {
    LOG(DEBUG) << "Call: success";
    response_msg.set_response_code(SUCCESS);
    if (result.size() > 0) {
      response_msg.set_result(result);
    }
    if (spec.size() > 0) {
      response_msg.set_spec(spec);
    }
  } else {
    LOG(ERROR) << "Call: fail";
    response_msg.set_response_code(FAIL);
    response_msg.set_reason("Failed to call api function: " + func_name);
  }
  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::DefaultResponse() {
  AndroidSystemControlResponseMessage response_msg;
  response_msg.set_response_code(SUCCESS);
  response_msg.set_reason("an example reason here");
  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::ExecuteShellCommand(
    const AndroidSystemControlCommandMessage& command_message) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  LOG(ERROR) << " binder not supported.";
  {
#endif
    return false;
  }

  auto result_message =
      client->ExecuteShellCommand(command_message.shell_command());

  AndroidSystemControlResponseMessage response_msg;

  if (result_message) {
    CreateSystemControlResponseFromDriverControlResponse(*result_message,
                                                         &response_msg);
  } else {
    LOG(ERROR) << "ExecuteShellCommand: failed to call the api";
    response_msg.set_response_code(FAIL);
    response_msg.set_reason("Failed to call the api.");
  }

  return VtsSocketSendMessage(response_msg);
}

void AgentRequestHandler::CreateSystemControlResponseFromDriverControlResponse(
    const VtsDriverControlResponseMessage& driver_control_response_message,
    AndroidSystemControlResponseMessage* system_control_response_message) {

  if (driver_control_response_message.response_code() ==
      VTS_DRIVER_RESPONSE_SUCCESS) {
    LOG(DEBUG) << "ExecuteShellCommand: shell driver reported success";
    system_control_response_message->set_response_code(SUCCESS);
  } else if (driver_control_response_message.response_code() ==
      VTS_DRIVER_RESPONSE_FAIL) {
    LOG(ERROR) << "ExecuteShellCommand: shell driver reported fail";
    system_control_response_message->set_response_code(FAIL);
  } else if (driver_control_response_message.response_code() ==
      UNKNOWN_VTS_DRIVER_RESPONSE_CODE) {
    LOG(ERROR) << "ExecuteShellCommand: shell driver reported unknown";
    system_control_response_message->set_response_code(UNKNOWN_RESPONSE_CODE);
  }

  for (const auto& log_stdout : driver_control_response_message.stdout()) {
    system_control_response_message->add_stdout(log_stdout);
  }

  for (const auto& log_stderr : driver_control_response_message.stderr()) {
    system_control_response_message->add_stderr(log_stderr);
  }

  for (const auto& exit_code : driver_control_response_message.exit_code()) {
    system_control_response_message->add_exit_code(exit_code);
  }
}

bool AgentRequestHandler::ProcessFmqCommand(
    const AndroidSystemControlCommandMessage& command_msg) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    LOG(ERROR) << "Driver socket client is uninitialized.";
    return false;
  }

  AndroidSystemControlResponseMessage response_msg;
  FmqResponseMessage* fmq_response = response_msg.mutable_fmq_response();
  FmqRequestMessage fmq_request = command_msg.fmq_request();
  // send the request message
  bool success = client->ProcessFmqCommand(fmq_request, fmq_response);

  // prepare for response back to host
  if (success) {
    response_msg.set_response_code(SUCCESS);
  } else {
    response_msg.set_response_code(FAIL);
    response_msg.set_reason("Failed to call api to process FMQ command.");
  }

  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::ProcessHidlMemoryCommand(
    const AndroidSystemControlCommandMessage& command_msg) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    LOG(ERROR) << "Driver socket client is uninitialized.";
    return false;
  }

  AndroidSystemControlResponseMessage response_msg;
  HidlMemoryResponseMessage* hidl_memory_response =
      response_msg.mutable_hidl_memory_response();
  HidlMemoryRequestMessage hidl_memory_request =
      command_msg.hidl_memory_request();
  // send the request message
  bool success = client->ProcessHidlMemoryCommand(hidl_memory_request,
                                                  hidl_memory_response);

  // prepare for response back to host
  if (success) {
    response_msg.set_response_code(SUCCESS);
  } else {
    response_msg.set_response_code(FAIL);
    response_msg.set_reason(
        "Failed to call api to process hidl_memory command.");
  }

  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::ProcessHidlHandleCommand(
    const AndroidSystemControlCommandMessage& command_msg) {
#ifndef VTS_AGENT_DRIVER_COMM_BINDER  // socket
  VtsDriverSocketClient* client = driver_client_;
  if (!client) {
#else  // binder
  android::sp<android::vts::IVtsFuzzer> client =
      android::vts::GetBinderClient(service_name_);
  if (!client.get()) {
#endif
    LOG(ERROR) << "Driver socket client is uninitialized.";
    return false;
  }

  AndroidSystemControlResponseMessage response_msg;
  HidlHandleResponseMessage* hidl_handle_response =
      response_msg.mutable_hidl_handle_response();
  HidlHandleRequestMessage hidl_handle_request =
      command_msg.hidl_handle_request();
  // send the request message
  bool success = client->ProcessHidlHandleCommand(hidl_handle_request,
                                                  hidl_handle_response);

  // prepare for response back to host
  if (success) {
    response_msg.set_response_code(SUCCESS);
  } else {
    response_msg.set_response_code(FAIL);
    response_msg.set_reason(
        "Failed to call api to process hidl_handle command.");
  }

  return VtsSocketSendMessage(response_msg);
}

bool AgentRequestHandler::ProcessOneCommand() {
  AndroidSystemControlCommandMessage command_msg;
  if (!VtsSocketRecvMessage(&command_msg)) return false;

  LOG(DEBUG) << "command_type = " << command_msg.command_type();
  switch (command_msg.command_type()) {
    case LIST_HALS:
      return ListHals(command_msg.paths());
    case SET_HOST_INFO:
      return SetHostInfo(command_msg.callback_port());
    case CHECK_DRIVER_SERVICE:
      return CheckDriverService(command_msg.service_name(), NULL);
    case LAUNCH_DRIVER_SERVICE:
      return LaunchDriverService(command_msg);
    case VTS_AGENT_COMMAND_READ_SPECIFICATION:
      return ReadSpecification(command_msg);
    case LIST_APIS:
      return ListApis();
    case CALL_API:
      return CallApi(command_msg.arg(), command_msg.driver_caller_uid());
    case VTS_AGENT_COMMAND_GET_ATTRIBUTE:
      return GetAttribute(command_msg.arg());
    // for shell driver
    case VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND:
      ExecuteShellCommand(command_msg);
      return true;
    case VTS_FMQ_COMMAND:
      return ProcessFmqCommand(command_msg);
    case VTS_HIDL_MEMORY_COMMAND:
      return ProcessHidlMemoryCommand(command_msg);
    case VTS_HIDL_HANDLE_COMMAND:
      return ProcessHidlHandleCommand(command_msg);
    default:
      LOG(ERROR) << " ERROR unknown command " << command_msg.command_type();
      return DefaultResponse();
  }
}

}  // namespace vts
}  // namespace android