automotive/remoteaccess/hal/default/src/RemoteAccessService.cpp

/*
 * Copyright (C) 2022 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 "RemoteAccessService.h"

#include <VehicleUtils.h>
#include <aidl/android/hardware/automotive/vehicle/VehicleProperty.h>
#include <android-base/parseint.h>
#include <android-base/stringprintf.h>
#include <android/binder_status.h>
#include <grpc++/grpc++.h>
#include <private/android_filesystem_config.h>
#include <sys/stat.h>
#include <utils/Log.h>
#include <chrono>
#include <fstream>
#include <iostream>
#include <thread>

namespace android {
namespace hardware {
namespace automotive {
namespace remoteaccess {

namespace {

using ::aidl::android::hardware::automotive::remoteaccess::ApState;
using ::aidl::android::hardware::automotive::remoteaccess::IRemoteTaskCallback;
using ::aidl::android::hardware::automotive::remoteaccess::ScheduleInfo;
using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
using ::android::base::Error;
using ::android::base::ParseInt;
using ::android::base::Result;
using ::android::base::ScopedLockAssertion;
using ::android::base::StringAppendF;
using ::android::base::StringPrintf;
using ::android::frameworks::automotive::vhal::IVhalClient;
using ::android::hardware::automotive::vehicle::toInt;
using ::grpc::ClientContext;
using ::grpc::ClientReaderInterface;
using ::grpc::Status;
using ::grpc::StatusCode;
using ::ndk::ScopedAStatus;

const std::string WAKEUP_SERVICE_NAME = "com.google.vehicle.wakeup";
const std::string PROCESSOR_ID = "application_processor";
constexpr char COMMAND_SET_AP_STATE[] = "--set-ap-state";
constexpr char COMMAND_START_DEBUG_CALLBACK[] = "--start-debug-callback";
constexpr char COMMAND_STOP_DEBUG_CALLBACK[] = "--stop-debug-callback";
constexpr char COMMAND_SHOW_TASK[] = "--show-task";
constexpr char COMMAND_GET_VEHICLE_ID[] = "--get-vehicle-id";
constexpr char COMMAND_INJECT_TASK[] = "--inject-task";
constexpr char COMMAND_INJECT_TASK_NEXT_REBOOT[] = "--inject-task-next-reboot";
constexpr char COMMAND_STATUS[] = "--status";

constexpr char DEBUG_TASK_FILE[] = "/data/vendor/remoteaccess/debugTask";

std::vector<uint8_t> stringToBytes(std::string_view s) {
    const char* data = s.data();
    return std::vector<uint8_t>(data, data + s.size());
}

ScopedAStatus rpcStatusToScopedAStatus(const Status& status, const std::string& errorMsg) {
    return ScopedAStatus::fromServiceSpecificErrorWithMessage(
            status.error_code(), (errorMsg + ", error: " + status.error_message()).c_str());
}

std::string printBytes(const std::vector<uint8_t>& bytes) {
    std::string s;
    for (size_t i = 0; i < bytes.size(); i++) {
        StringAppendF(&s, "%02x", bytes[i]);
    }
    return s;
}

bool checkBoolFlag(const char* flag) {
    return !strcmp(flag, "1") || !strcmp(flag, "0");
}

void dprintErrorStatus(int fd, const char* detail, const ScopedAStatus& status) {
    dprintf(fd, "%s, code: %d, error: %s\n", detail, status.getStatus(), status.getMessage());
}

std::string boolToString(bool x) {
    return x ? "true" : "false";
}

}  // namespace

RemoteAccessService::RemoteAccessService(WakeupClient::StubInterface* grpcStub)
    : mGrpcStub(grpcStub) {
    std::ifstream debugTaskFile;
    debugTaskFile.open(DEBUG_TASK_FILE, std::ios::in);
    if (!debugTaskFile.is_open()) {
        ALOGD("No debug task available");
        return;
    }

    char buffer[1024] = {};
    debugTaskFile.getline(buffer, sizeof(buffer));
    std::string clientId = std::string(buffer);
    debugTaskFile.getline(buffer, sizeof(buffer));
    std::string taskData = std::string(buffer);
    int latencyInSec;
    debugTaskFile >> latencyInSec;
    debugTaskFile.close();

    ALOGD("Task for client: %s, data: [%s], latency: %d\n", clientId.c_str(), taskData.c_str(),
          latencyInSec);

    mInjectDebugTaskThread = std::thread([this, clientId, taskData, latencyInSec] {
        std::this_thread::sleep_for(std::chrono::seconds(latencyInSec));
        if (auto result = deliverRemoteTaskThroughCallback(clientId, taskData); !result.ok()) {
            ALOGE("Failed to inject debug task, clientID: %s, taskData: %s, error: %s",
                  clientId.c_str(), taskData.c_str(), result.error().message().c_str());
            return;
        }
        ALOGD("Task for client: %s, data: [%s] successfully injected\n", clientId.c_str(),
              taskData.c_str());
    });
}

RemoteAccessService::~RemoteAccessService() {
    maybeStopTaskLoop();
    if (mInjectDebugTaskThread.joinable()) {
        mInjectDebugTaskThread.join();
    }
}

void RemoteAccessService::maybeStartTaskLoop() {
    std::lock_guard<std::mutex> lockGuard(mStartStopTaskLoopLock);
    if (mTaskLoopRunning) {
        return;
    }

    mThread = std::thread([this]() { runTaskLoop(); });

    mTaskLoopRunning = true;
}

void RemoteAccessService::maybeStopTaskLoop() {
    std::lock_guard<std::mutex> lockGuard(mStartStopTaskLoopLock);
    if (!mTaskLoopRunning) {
        return;
    }

    {
        std::lock_guard<std::mutex> lockGuard(mLock);
        // Try to stop the reading stream.
        if (mGetRemoteTasksContext) {
            mGetRemoteTasksContext->TryCancel();
            // Don't reset mGetRemoteTaskContext here since the read stream might still be affective
            // and might still be using it. This will cause reader->Read to return false and
            // mGetRemoteTasksContext will be cleared after reader->Finish() is called.
        }
        mTaskWaitStopped = true;
        mCv.notify_all();
    }
    if (mThread.joinable()) {
        mThread.join();
    }

    mTaskLoopRunning = false;
}

void RemoteAccessService::updateGrpcConnected(bool connected) {
    std::lock_guard<std::mutex> lockGuard(mLock);
    mGrpcConnected = connected;
}

Result<void> RemoteAccessService::deliverRemoteTaskThroughCallback(const std::string& clientId,
                                                                   std::string_view taskData) {
    std::shared_ptr<IRemoteTaskCallback> callback;
    {
        std::lock_guard<std::mutex> lockGuard(mLock);
        callback = mRemoteTaskCallback;
        mClientIdToTaskCount[clientId] += 1;
    }
    if (callback == nullptr) {
        return Error() << "No callback registered, task ignored";
    }
    ALOGD("Calling onRemoteTaskRequested callback for client ID: %s", clientId.c_str());
    ScopedAStatus callbackStatus =
            callback->onRemoteTaskRequested(clientId, stringToBytes(taskData));
    if (!callbackStatus.isOk()) {
        return Error() << "Failed to call onRemoteTaskRequested callback, status: "
                       << callbackStatus.getStatus()
                       << ", message: " << callbackStatus.getMessage();
    }
    return {};
}

void RemoteAccessService::runTaskLoop() {
    GetRemoteTasksRequest request = {};
    std::unique_ptr<ClientReaderInterface<GetRemoteTasksResponse>> reader;
    while (true) {
        {
            std::lock_guard<std::mutex> lockGuard(mLock);
            mGetRemoteTasksContext.reset(new ClientContext());
            reader = mGrpcStub->GetRemoteTasks(mGetRemoteTasksContext.get(), request);
        }
        updateGrpcConnected(true);
        GetRemoteTasksResponse response;
        while (reader->Read(&response)) {
            ALOGI("Receiving one task from remote task client");

            if (auto result =
                        deliverRemoteTaskThroughCallback(response.clientid(), response.data());
                !result.ok()) {
                ALOGE("%s", result.error().message().c_str());
                continue;
            }
        }
        updateGrpcConnected(false);
        Status status = reader->Finish();
        mGetRemoteTasksContext.reset();

        ALOGE("GetRemoteTasks stream breaks, code: %d, message: %s, sleeping for 10s and retry",
              status.error_code(), status.error_message().c_str());
        // The long lasting connection should not return. But if the server returns, retry after
        // 10s.
        {
            std::unique_lock lk(mLock);
            if (mCv.wait_for(lk, std::chrono::milliseconds(mRetryWaitInMs), [this] {
                    ScopedLockAssertion lockAssertion(mLock);
                    return mTaskWaitStopped;
                })) {
                // If the stopped flag is set, we are quitting, exit the loop.
                break;
            }
        }
    }
}

ScopedAStatus RemoteAccessService::getVehicleId(std::string* vehicleId) {
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    auto vhalClient = IVhalClient::tryCreate();
    if (vhalClient == nullptr) {
        ALOGE("Failed to connect to VHAL");
        return ScopedAStatus::fromServiceSpecificErrorWithMessage(
                /*errorCode=*/0, "Failed to connect to VHAL to get vehicle ID");
    }
    return getVehicleIdWithClient(*vhalClient.get(), vehicleId);
#else
    // Don't use VHAL client in fuzzing since IPC is not allowed.
    return ScopedAStatus::ok();
#endif
}

ScopedAStatus RemoteAccessService::getVehicleIdWithClient(IVhalClient& vhalClient,
                                                          std::string* vehicleId) {
    auto result = vhalClient.getValueSync(
            *vhalClient.createHalPropValue(toInt(VehicleProperty::INFO_VIN)));
    if (!result.ok()) {
        return ScopedAStatus::fromServiceSpecificErrorWithMessage(
                /*errorCode=*/0,
                ("failed to get INFO_VIN from VHAL: " + result.error().message()).c_str());
    }
    *vehicleId = (*result)->getStringValue();
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::getProcessorId(std::string* processorId) {
    *processorId = PROCESSOR_ID;
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::getWakeupServiceName(std::string* wakeupServiceName) {
    *wakeupServiceName = WAKEUP_SERVICE_NAME;
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::setRemoteTaskCallback(
        const std::shared_ptr<IRemoteTaskCallback>& callback) {
    std::lock_guard<std::mutex> lockGuard(mLock);
    mRemoteTaskCallback = callback;
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::clearRemoteTaskCallback() {
    std::lock_guard<std::mutex> lockGuard(mLock);
    mRemoteTaskCallback.reset();
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::notifyApStateChange(const ApState& newState) {
    ClientContext context;
    NotifyWakeupRequiredRequest request = {};
    request.set_iswakeuprequired(newState.isWakeupRequired);
    NotifyWakeupRequiredResponse response = {};
    Status status = mGrpcStub->NotifyWakeupRequired(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to notify isWakeupRequired");
    }

    if (newState.isReadyForRemoteTask) {
        maybeStartTaskLoop();
    } else {
        maybeStopTaskLoop();
    }
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::isTaskScheduleSupported(bool* out) {
    *out = true;
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::scheduleTask(const ScheduleInfo& scheduleInfo) {
    ClientContext context;
    ScheduleTaskRequest request = {};
    ScheduleTaskResponse response = {};
    request.mutable_scheduleinfo()->set_clientid(scheduleInfo.clientId);
    request.mutable_scheduleinfo()->set_scheduleid(scheduleInfo.scheduleId);
    request.mutable_scheduleinfo()->set_data(scheduleInfo.taskData.data(),
                                             scheduleInfo.taskData.size());
    request.mutable_scheduleinfo()->set_count(scheduleInfo.count);
    request.mutable_scheduleinfo()->set_starttimeinepochseconds(
            scheduleInfo.startTimeInEpochSeconds);
    request.mutable_scheduleinfo()->set_periodicinseconds(scheduleInfo.periodicInSeconds);
    Status status = mGrpcStub->ScheduleTask(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to call ScheduleTask");
    }
    int errorCode = response.errorcode();
    switch (errorCode) {
        case ErrorCode::OK:
            return ScopedAStatus::ok();
        case ErrorCode::INVALID_ARG:
            return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
        default:
            // Should not happen.
            return ScopedAStatus::fromServiceSpecificErrorWithMessage(
                    -1, ("Got unknown error code: " + ErrorCode_Name(errorCode) +
                         " from remote access HAL")
                                .c_str());
    }
}

ScopedAStatus RemoteAccessService::unscheduleTask(const std::string& clientId,
                                                  const std::string& scheduleId) {
    ClientContext context;
    UnscheduleTaskRequest request = {};
    UnscheduleTaskResponse response = {};
    request.set_clientid(clientId);
    request.set_scheduleid(scheduleId);
    Status status = mGrpcStub->UnscheduleTask(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to call UnscheduleTask");
    }
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::unscheduleAllTasks(const std::string& clientId) {
    ClientContext context;
    UnscheduleAllTasksRequest request = {};
    UnscheduleAllTasksResponse response = {};
    request.set_clientid(clientId);
    Status status = mGrpcStub->UnscheduleAllTasks(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to call UnscheduleAllTasks");
    }
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::isTaskScheduled(const std::string& clientId,
                                                   const std::string& scheduleId, bool* out) {
    ClientContext context;
    IsTaskScheduledRequest request = {};
    IsTaskScheduledResponse response = {};
    request.set_clientid(clientId);
    request.set_scheduleid(scheduleId);
    Status status = mGrpcStub->IsTaskScheduled(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to call isTaskScheduled");
    }
    *out = response.istaskscheduled();
    return ScopedAStatus::ok();
}

ScopedAStatus RemoteAccessService::getAllScheduledTasks(const std::string& clientId,
                                                        std::vector<ScheduleInfo>* out) {
    ClientContext context;
    GetAllScheduledTasksRequest request = {};
    GetAllScheduledTasksResponse response = {};
    request.set_clientid(clientId);
    Status status = mGrpcStub->GetAllScheduledTasks(&context, request, &response);
    if (!status.ok()) {
        return rpcStatusToScopedAStatus(status, "Failed to call isTaskScheduled");
    }
    out->clear();
    for (int i = 0; i < response.allscheduledtasks_size(); i++) {
        const GrpcScheduleInfo& rpcScheduleInfo = response.allscheduledtasks(i);
        ScheduleInfo scheduleInfo = {
                .clientId = rpcScheduleInfo.clientid(),
                .scheduleId = rpcScheduleInfo.scheduleid(),
                .taskData = stringToBytes(rpcScheduleInfo.data()),
                .count = rpcScheduleInfo.count(),
                .startTimeInEpochSeconds = rpcScheduleInfo.starttimeinepochseconds(),
                .periodicInSeconds = rpcScheduleInfo.periodicinseconds(),
        };
        out->push_back(std::move(scheduleInfo));
    }
    return ScopedAStatus::ok();
}

bool RemoteAccessService::checkDumpPermission() {
    uid_t uid = AIBinder_getCallingUid();
    return uid == AID_ROOT || uid == AID_SHELL || uid == AID_SYSTEM;
}

void RemoteAccessService::dumpHelp(int fd) {
    dprintf(fd,
            "RemoteAccess HAL debug interface, Usage: \n"
            "%s [0/1](isReadyForRemoteTask) [0/1](isWakeupRequired): Set the new AP state\n"
            "%s: Start a debug callback that will record the received tasks\n"
            "%s: Stop the debug callback\n"
            "%s: Show tasks received by debug callback\n"
            "%s: Get vehicle id\n"
            "%s [client_id] [task_data]: Inject a task\n"
            "%s [client_id] [task_data] [latencyInSec]: "
            "Inject a task on next reboot after latencyInSec seconds\n"
            "%s: Show status\n",
            COMMAND_SET_AP_STATE, COMMAND_START_DEBUG_CALLBACK, COMMAND_STOP_DEBUG_CALLBACK,
            COMMAND_SHOW_TASK, COMMAND_GET_VEHICLE_ID, COMMAND_INJECT_TASK,
            COMMAND_INJECT_TASK_NEXT_REBOOT, COMMAND_STATUS);
}

binder_status_t RemoteAccessService::dump(int fd, const char** args, uint32_t numArgs) {
    if (!checkDumpPermission()) {
        dprintf(fd, "Caller must be root, system or shell\n");
        return STATUS_PERMISSION_DENIED;
    }

    if (numArgs == 0) {
        dumpHelp(fd);
        printCurrentStatus(fd);
        return STATUS_OK;
    }

    if (!strcmp(args[0], COMMAND_SET_AP_STATE)) {
        if (numArgs < 3) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        ApState apState = {};
        const char* remoteTaskFlag = args[1];
        if (!strcmp(remoteTaskFlag, "1") && !strcmp(remoteTaskFlag, "0")) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        if (!checkBoolFlag(args[1])) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        if (!strcmp(args[1], "1")) {
            apState.isReadyForRemoteTask = true;
        }
        if (!checkBoolFlag(args[2])) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        if (!strcmp(args[2], "1")) {
            apState.isWakeupRequired = true;
        }
        auto status = notifyApStateChange(apState);
        if (!status.isOk()) {
            dprintErrorStatus(fd, "Failed to set AP state", status);
        } else {
            dprintf(fd, "successfully set the new AP state\n");
        }
    } else if (!strcmp(args[0], COMMAND_START_DEBUG_CALLBACK)) {
        mDebugCallback = ndk::SharedRefBase::make<DebugRemoteTaskCallback>();
        setRemoteTaskCallback(mDebugCallback);
        dprintf(fd, "Debug callback registered\n");
    } else if (!strcmp(args[0], COMMAND_STOP_DEBUG_CALLBACK)) {
        if (mDebugCallback) {
            mDebugCallback.reset();
        }
        clearRemoteTaskCallback();
        dprintf(fd, "Debug callback unregistered\n");
    } else if (!strcmp(args[0], COMMAND_SHOW_TASK)) {
        if (mDebugCallback) {
            dprintf(fd, "%s", mDebugCallback->printTasks().c_str());
        } else {
            dprintf(fd, "Debug callback is not currently used, use \"%s\" first.\n",
                    COMMAND_START_DEBUG_CALLBACK);
        }
    } else if (!strcmp(args[0], COMMAND_GET_VEHICLE_ID)) {
        std::string vehicleId;
        auto status = getVehicleId(&vehicleId);
        if (!status.isOk()) {
            dprintErrorStatus(fd, "Failed to get vehicle ID", status);
        } else {
            dprintf(fd, "Vehicle Id: %s\n", vehicleId.c_str());
        }
    } else if (!strcmp(args[0], COMMAND_INJECT_TASK)) {
        if (numArgs < 3) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        debugInjectTask(fd, args[1], args[2]);
    } else if (!strcmp(args[0], COMMAND_INJECT_TASK_NEXT_REBOOT)) {
        if (numArgs < 4) {
            dumpHelp(fd);
            return STATUS_OK;
        }
        debugInjectTaskNextReboot(fd, args[1], args[2], args[3]);
    } else if (!strcmp(args[0], COMMAND_STATUS)) {
        printCurrentStatus(fd);
    } else {
        dumpHelp(fd);
    }

    return STATUS_OK;
}

void RemoteAccessService::printCurrentStatus(int fd) {
    std::lock_guard<std::mutex> lockGuard(mLock);
    dprintf(fd,
            "\nRemoteAccess HAL status \n"
            "Remote task callback registered: %s\n"
            "Task receiving GRPC connection established: %s\n"
            "Received task count by clientId: \n%s\n",
            boolToString(mRemoteTaskCallback.get()).c_str(), boolToString(mGrpcConnected).c_str(),
            clientIdToTaskCountToStringLocked().c_str());
}

void RemoteAccessService::debugInjectTask(int fd, std::string_view clientId,
                                          std::string_view taskData) {
    std::string clientIdCopy = std::string(clientId);
    if (auto result = deliverRemoteTaskThroughCallback(clientIdCopy, taskData); !result.ok()) {
        dprintf(fd, "Failed to inject task: %s\n", result.error().message().c_str());
        return;
    }
    dprintf(fd, "Task for client: %s, data: [%s] successfully injected\n", clientId.data(),
            taskData.data());
}

void RemoteAccessService::debugInjectTaskNextReboot(int fd, std::string_view clientId,
                                                    std::string_view taskData,
                                                    const char* latencyInSecStr) {
    int latencyInSec;
    if (!ParseInt(latencyInSecStr, &latencyInSec)) {
        dprintf(fd, "The input latency in second is not a valid integer");
        return;
    }
    std::ofstream debugTaskFile;
    debugTaskFile.open(DEBUG_TASK_FILE, std::ios::out);
    if (!debugTaskFile.is_open()) {
        dprintf(fd,
                "Failed to open debug task file, please run the command: "
                "'adb shell touch %s' first\n",
                DEBUG_TASK_FILE);
        return;
    }
    if (taskData.find("\n") != std::string::npos) {
        dprintf(fd, "Task data must not contain newline\n");
        return;
    }
    debugTaskFile << clientId << "\n" << taskData << "\n" << latencyInSec;
    debugTaskFile.close();
    dprintf(fd,
            "Task with clientId: %s, task data: %s, latency: %d sec scheduled for next reboot\n",
            clientId.data(), taskData.data(), latencyInSec);
}

std::string RemoteAccessService::clientIdToTaskCountToStringLocked() {
    // Print the table header
    std::string output = "| ClientId | Count |\n";
    for (const auto& [clientId, taskCount] : mClientIdToTaskCount) {
        output += StringPrintf("  %-9s  %-6zu\n", clientId.c_str(), taskCount);
    }
    return output;
}

ScopedAStatus DebugRemoteTaskCallback::onRemoteTaskRequested(const std::string& clientId,
                                                             const std::vector<uint8_t>& data) {
    std::lock_guard<std::mutex> lockGuard(mLock);
    mTasks.push_back({
            .clientId = clientId,
            .data = data,
    });
    return ScopedAStatus::ok();
}

std::string DebugRemoteTaskCallback::printTasks() {
    std::lock_guard<std::mutex> lockGuard(mLock);
    std::string s = StringPrintf("Received %zu tasks in %f seconds", mTasks.size(),
                                 (android::uptimeMillis() - mStartTimeMillis) / 1000.);
    for (size_t i = 0; i < mTasks.size(); i++) {
        StringAppendF(&s, "Client Id: %s, Data: %s\n", mTasks[i].clientId.c_str(),
                      printBytes(mTasks[i].data).c_str());
    }
    return s;
}

}  // namespace remoteaccess
}  // namespace automotive
}  // namespace hardware
}  // namespace android