587 lines
21 KiB
C++
587 lines
21 KiB
C++
/*
|
|
* 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
|