1 /* 2 * Copyright 2016 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 "AgentRequestHandler.h" 18 19 #include <errno.h> 20 21 #include <dirent.h> 22 #include <netdb.h> 23 #include <netinet/in.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <sys/socket.h> 28 #include <sys/stat.h> 29 #include <sys/types.h> 30 #include <unistd.h> 31 #include <utils/RefBase.h> 32 33 #include <fstream> 34 #include <iostream> 35 #include <sstream> 36 #include <string> 37 #include <vector> 38 39 #include "BinderClientToDriver.h" 40 #include "SocketClientToDriver.h" 41 #include "SocketServerForDriver.h" 42 #include "test/vts/proto/AndroidSystemControlMessage.pb.h" 43 #include "test/vts/proto/VtsDriverControlMessage.pb.h" 44 45 using namespace std; 46 using namespace google::protobuf; 47 48 namespace android { 49 namespace vts { 50 51 bool AgentRequestHandler::ListHals(const RepeatedPtrField<string>& base_paths) { 52 cout << "[runner->agent] command " << __FUNCTION__ << endl; 53 AndroidSystemControlResponseMessage response_msg; 54 ResponseCode result = FAIL; 55 56 for (const string& path : base_paths) { 57 cout << __FUNCTION__ << ": open a dir " << path << endl; 58 DIR* dp; 59 if (!(dp = opendir(path.c_str()))) { 60 cerr << "Error(" << errno << ") opening " << path << endl; 61 continue; 62 } 63 64 struct dirent* dirp; 65 int len; 66 while ((dirp = readdir(dp)) != NULL) { 67 len = strlen(dirp->d_name); 68 if (len > 3 && !strcmp(&dirp->d_name[len - 3], ".so")) { 69 string found_path = path + "/" + string(dirp->d_name); 70 cout << __FUNCTION__ << ": found " << found_path << endl; 71 response_msg.add_file_names(found_path); 72 result = SUCCESS; 73 } 74 } 75 closedir(dp); 76 } 77 response_msg.set_response_code(result); 78 return VtsSocketSendMessage(response_msg); 79 } 80 81 bool AgentRequestHandler::SetHostInfo(const int callback_port) { 82 cout << "[runner->agent] command " << __FUNCTION__ << endl; 83 callback_port_ = callback_port; 84 AndroidSystemControlResponseMessage response_msg; 85 response_msg.set_response_code(SUCCESS); 86 return VtsSocketSendMessage(response_msg); 87 } 88 89 bool AgentRequestHandler::CheckDriverService(const string& service_name, 90 bool* live) { 91 cout << "[runner->agent] command " << __FUNCTION__ << endl; 92 AndroidSystemControlResponseMessage response_msg; 93 94 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 95 if (IsDriverRunning(service_name, 10)) { 96 #else // binder 97 sp<IVtsFuzzer> binder = GetBinderClient(service_name); 98 if (binder.get()) { 99 #endif 100 if (live) *live = true; 101 response_msg.set_response_code(SUCCESS); 102 response_msg.set_reason("found the service"); 103 cout << "set service_name " << service_name << endl; 104 service_name_ = service_name; 105 } else { 106 if (live) *live = false; 107 response_msg.set_response_code(FAIL); 108 response_msg.set_reason("service not found"); 109 } 110 return VtsSocketSendMessage(response_msg); 111 } 112 113 static const char kUnixSocketNamePrefixForCallbackServer[] = 114 "/data/local/tmp/vts_agent_callback"; 115 116 bool AgentRequestHandler::LaunchDriverService( 117 const AndroidSystemControlCommandMessage& command_msg) { 118 int driver_type = command_msg.driver_type(); 119 const string& service_name = command_msg.service_name(); 120 const string& file_path = command_msg.file_path(); 121 int target_class = command_msg.target_class(); 122 int target_type = command_msg.target_type(); 123 float target_version = command_msg.target_version() / 100.0; 124 const string& target_package = command_msg.target_package(); 125 const string& target_component_name = command_msg.target_component_name(); 126 const string& module_name = command_msg.module_name(); 127 const string& hw_binder_service_name = command_msg.hw_binder_service_name(); 128 int bits = command_msg.bits(); 129 130 cout << "[runner->agent] command " << __FUNCTION__ << " (file_path=" 131 << file_path << ")" << endl; 132 ResponseCode result = FAIL; 133 134 // TODO: shall check whether there's a service with the same name and return 135 // success immediately if exists. 136 AndroidSystemControlResponseMessage response_msg; 137 138 // deletes the service file if exists before starting to launch a driver. 139 string socket_port_flie_path = GetSocketPortFilePath(service_name); 140 struct stat file_stat; 141 if (stat(socket_port_flie_path.c_str(), &file_stat) == 0 // file exists 142 && remove(socket_port_flie_path.c_str()) == -1) { 143 cerr << __func__ << " " << socket_port_flie_path << " delete error" << endl; 144 response_msg.set_reason("service file already exists."); 145 } else { 146 pid_t pid = fork(); 147 if (pid == 0) { // child 148 Close(); 149 150 string driver_binary_path; 151 char* cmd = NULL; 152 if (driver_type == VTS_DRIVER_TYPE_HAL_CONVENTIONAL || 153 driver_type == VTS_DRIVER_TYPE_HAL_LEGACY || 154 driver_type == VTS_DRIVER_TYPE_HAL_HIDL) { 155 // TODO: check whether the port is available and handle if fails. 156 static int port = 0; 157 string callback_socket_name(kUnixSocketNamePrefixForCallbackServer); 158 callback_socket_name += std::to_string(port++); 159 cout << "callback_socket_name: " << callback_socket_name << endl; 160 StartSocketServerForDriver(callback_socket_name, -1); 161 162 if (bits == 32) { 163 driver_binary_path = driver_hal_binary32_; 164 } else { 165 driver_binary_path = driver_hal_binary64_; 166 } 167 size_t offset = driver_binary_path.find_last_of("/"); 168 string ld_dir_path = driver_binary_path.substr(0, offset); 169 170 if (driver_hal_spec_dir_path_.length() < 1) { 171 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 172 asprintf(&cmd, 173 "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s " 174 "--server_socket_path=%s " 175 "--callback_socket_name=%s", 176 ld_dir_path.c_str(), driver_binary_path.c_str(), 177 socket_port_flie_path.c_str(), callback_socket_name.c_str()); 178 #else // binder 179 asprintf(&cmd, 180 "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s " 181 "--service_name=%s " 182 "--callback_socket_name=%s", 183 ld_dir_path.c_str(), driver_binary_path.c_str(), 184 service_name.c_str(), callback_socket_name.c_str()); 185 #endif 186 } else { 187 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 188 asprintf(&cmd, 189 "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s " 190 "--server_socket_path=%s " 191 "--spec_dir_path=%s --callback_socket_name=%s", 192 ld_dir_path.c_str(), driver_binary_path.c_str(), 193 socket_port_flie_path.c_str(), 194 driver_hal_spec_dir_path_.c_str(), 195 callback_socket_name.c_str()); 196 #else // binder 197 asprintf(&cmd, 198 "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s " 199 "--service_name=%s " 200 "--spec_dir_path=%s --callback_socket_name=%s", 201 ld_dir_path.c_str(), driver_binary_path.c_str(), 202 service_name.c_str(), driver_hal_spec_dir_path_.c_str(), 203 callback_socket_name.c_str()); 204 #endif 205 } 206 } else if (driver_type == VTS_DRIVER_TYPE_SHELL) { 207 if (bits == 32) { 208 driver_binary_path = driver_shell_binary32_; 209 } else { 210 driver_binary_path = driver_shell_binary64_; 211 } 212 size_t offset = driver_binary_path.find_last_of("/"); 213 string ld_dir_path = driver_binary_path.substr(0, offset); 214 215 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 216 asprintf( 217 &cmd, 218 "LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH %s --server_socket_path=%s", 219 ld_dir_path.c_str(), driver_binary_path.c_str(), 220 socket_port_flie_path.c_str()); 221 #else // binder 222 cerr << __func__ << " no binder implementation available." << endl; 223 exit(-1); 224 #endif 225 } else { 226 cerr << __func__ << " unsupported driver type." << endl; 227 } 228 229 if (cmd) { 230 cout << __func__ << "launch a driver - " << cmd << endl; 231 system(cmd); 232 cout << __func__ << "driver exits" << endl; 233 free(cmd); 234 } 235 exit(0); 236 } else if (pid > 0) { 237 for (int attempt = 0; attempt < 10; attempt++) { 238 sleep(1); 239 if (IsDriverRunning(service_name, 10)) { 240 result = SUCCESS; 241 break; 242 } 243 } 244 if (result) { 245 // TODO: use an attribute (client) of a newly defined class. 246 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 247 VtsDriverSocketClient* client = 248 android::vts::GetDriverSocketClient(service_name); 249 if (!client) { 250 #else // binder 251 android::sp<android::vts::IVtsFuzzer> client = 252 android::vts::GetBinderClient(service_name); 253 if (!client.get()) { 254 #endif 255 response_msg.set_response_code(FAIL); 256 response_msg.set_reason("Failed to start a driver."); 257 // TODO: kill the driver? 258 return VtsSocketSendMessage(response_msg); 259 } 260 261 if (driver_type == VTS_DRIVER_TYPE_HAL_CONVENTIONAL || 262 driver_type == VTS_DRIVER_TYPE_HAL_LEGACY || 263 driver_type == VTS_DRIVER_TYPE_HAL_HIDL) { 264 cout << "[agent->driver]: LoadHal " << module_name << endl; 265 int32_t driver_id = client->LoadHal( 266 file_path, target_class, target_type, target_version, 267 target_package, target_component_name, hw_binder_service_name, 268 module_name); 269 cout << "[driver->agent]: LoadHal returns " << driver_id << endl; 270 if (driver_id == -1) { 271 response_msg.set_response_code(FAIL); 272 response_msg.set_reason("Failed to load the selected HAL."); 273 } else { 274 response_msg.set_response_code(SUCCESS); 275 response_msg.set_result(std::to_string(driver_id)); 276 response_msg.set_reason("Loaded the selected HAL."); 277 cout << "set service_name " << service_name << endl; 278 service_name_ = service_name; 279 } 280 } else if (driver_type == VTS_DRIVER_TYPE_SHELL) { 281 response_msg.set_response_code(SUCCESS); 282 response_msg.set_reason("Loaded the shell driver."); 283 cout << "set service_name " << service_name << endl; 284 service_name_ = service_name; 285 } 286 287 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 288 driver_client_ = client; 289 #endif 290 return VtsSocketSendMessage(response_msg); 291 } 292 } 293 response_msg.set_reason( 294 "Failed to fork a child process to start a driver."); 295 } 296 response_msg.set_response_code(FAIL); 297 cerr << "can't fork a child process to run the vts_hal_driver." << endl; 298 return VtsSocketSendMessage(response_msg); 299 } 300 301 bool AgentRequestHandler::ReadSpecification( 302 const AndroidSystemControlCommandMessage& command_message) { 303 cout << "[runner->agent] command " << __FUNCTION__ << endl; 304 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 305 VtsDriverSocketClient* client = driver_client_; 306 if (!client) { 307 #else // binder 308 android::sp<android::vts::IVtsFuzzer> client = 309 android::vts::GetBinderClient(service_name_); 310 if (!client.get()) { 311 #endif 312 return false; 313 } 314 315 const string& result = client->ReadSpecification( 316 command_message.service_name(), command_message.target_class(), 317 command_message.target_type(), command_message.target_version() / 100.0f, 318 command_message.target_package()); 319 320 return SendApiResult("ReadSpecification", result); 321 } 322 323 bool AgentRequestHandler::ListApis() { 324 cout << "[runner->agent] command " << __FUNCTION__ << endl; 325 // TODO: use an attribute (client) of a newly defined class. 326 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 327 VtsDriverSocketClient* client = driver_client_; 328 if (!client) { 329 #else // binder 330 android::sp<android::vts::IVtsFuzzer> client = 331 android::vts::GetBinderClient(service_name_); 332 if (!client.get()) { 333 #endif 334 return false; 335 } 336 return SendApiResult("GetAttribute", "", client->GetFunctions()); 337 } 338 339 bool AgentRequestHandler::CallApi(const string& call_payload, 340 const string& uid) { 341 cout << "[runner->agent] command " << __FUNCTION__ << endl; 342 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 343 VtsDriverSocketClient* client = driver_client_; 344 if (!client) { 345 #else // binder 346 // TODO: use an attribute (client) of a newly defined class. 347 android::sp<android::vts::IVtsFuzzer> client = 348 android::vts::GetBinderClient(service_name_); 349 if (!client.get()) { 350 #endif 351 return false; 352 } 353 354 return SendApiResult("Call", client->Call(call_payload, uid)); 355 } 356 357 bool AgentRequestHandler::GetAttribute(const string& payload) { 358 cout << "[runner->agent] command " << __FUNCTION__ << endl; 359 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 360 VtsDriverSocketClient* client = driver_client_; 361 if (!client) { 362 #else // binder 363 // TODO: use an attribute (client) of a newly defined class. 364 android::sp<android::vts::IVtsFuzzer> client = 365 android::vts::GetBinderClient(service_name_); 366 if (!client.get()) { 367 #endif 368 return false; 369 } 370 371 return SendApiResult("GetAttribute", client->GetAttribute(payload)); 372 } 373 374 bool AgentRequestHandler::SendApiResult(const string& func_name, 375 const string& result, 376 const string& spec) { 377 AndroidSystemControlResponseMessage response_msg; 378 if (result.size() > 0 || spec.size() > 0) { 379 cout << "[agent] Call: success" << endl; 380 response_msg.set_response_code(SUCCESS); 381 if (result.size() > 0) { 382 response_msg.set_result(result); 383 } 384 if (spec.size() > 0) { 385 response_msg.set_spec(spec); 386 } 387 } else { 388 cout << "[agent] Call: fail" << endl; 389 response_msg.set_response_code(FAIL); 390 response_msg.set_reason("Failed to call api function: " + func_name); 391 } 392 return VtsSocketSendMessage(response_msg); 393 } 394 395 bool AgentRequestHandler::DefaultResponse() { 396 cout << "[agent] " << __FUNCTION__ << endl; 397 AndroidSystemControlResponseMessage response_msg; 398 response_msg.set_response_code(SUCCESS); 399 response_msg.set_reason("an example reason here"); 400 return VtsSocketSendMessage(response_msg); 401 } 402 403 bool AgentRequestHandler::ExecuteShellCommand( 404 const AndroidSystemControlCommandMessage& command_message) { 405 cout << "[runner->agent] command " << __FUNCTION__ << endl; 406 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 407 VtsDriverSocketClient* client = driver_client_; 408 if (!client) { 409 #else // binder 410 cerr << __func__ << " binder not supported." << endl; 411 { 412 #endif 413 return false; 414 } 415 416 auto result_message = 417 client->ExecuteShellCommand(command_message.shell_command()); 418 419 AndroidSystemControlResponseMessage response_msg; 420 421 if (result_message) { 422 CreateSystemControlResponseFromDriverControlResponse(*result_message, 423 &response_msg); 424 } else { 425 cout << "ExecuteShellCommand: failed to call the api" << endl; 426 response_msg.set_response_code(FAIL); 427 response_msg.set_reason("Failed to call the api."); 428 } 429 430 return VtsSocketSendMessage(response_msg); 431 } 432 433 void AgentRequestHandler::CreateSystemControlResponseFromDriverControlResponse( 434 const VtsDriverControlResponseMessage& driver_control_response_message, 435 AndroidSystemControlResponseMessage* system_control_response_message) { 436 437 if (driver_control_response_message.response_code() == 438 VTS_DRIVER_RESPONSE_SUCCESS) { 439 cout << "ExecuteShellCommand: shell driver reported success" << endl; 440 system_control_response_message->set_response_code(SUCCESS); 441 } else if (driver_control_response_message.response_code() == 442 VTS_DRIVER_RESPONSE_FAIL) { 443 cout << "ExecuteShellCommand: shell driver reported fail" << endl; 444 system_control_response_message->set_response_code(FAIL); 445 } else if (driver_control_response_message.response_code() == 446 UNKNOWN_VTS_DRIVER_RESPONSE_CODE) { 447 cout << "ExecuteShellCommand: shell driver reported unknown" << endl; 448 system_control_response_message->set_response_code(UNKNOWN_RESPONSE_CODE); 449 } 450 451 for (const auto& log_stdout : driver_control_response_message.stdout()) { 452 system_control_response_message->add_stdout(log_stdout); 453 } 454 455 for (const auto& log_stderr : driver_control_response_message.stderr()) { 456 system_control_response_message->add_stderr(log_stderr); 457 } 458 459 for (const auto& exit_code : driver_control_response_message.exit_code()) { 460 system_control_response_message->add_exit_code(exit_code); 461 } 462 } 463 464 bool AgentRequestHandler::ProcessOneCommand() { 465 AndroidSystemControlCommandMessage command_msg; 466 if (!VtsSocketRecvMessage(&command_msg)) return false; 467 468 cout << getpid() << " " << __func__ 469 << " command_type = " << command_msg.command_type() << endl; 470 switch (command_msg.command_type()) { 471 case LIST_HALS: 472 return ListHals(command_msg.paths()); 473 case SET_HOST_INFO: 474 return SetHostInfo(command_msg.callback_port()); 475 case CHECK_DRIVER_SERVICE: 476 return CheckDriverService(command_msg.service_name(), NULL); 477 case LAUNCH_DRIVER_SERVICE: 478 return LaunchDriverService(command_msg); 479 case VTS_AGENT_COMMAND_READ_SPECIFICATION: 480 return ReadSpecification(command_msg); 481 case LIST_APIS: 482 return ListApis(); 483 case CALL_API: 484 return CallApi(command_msg.arg(), command_msg.driver_caller_uid()); 485 case VTS_AGENT_COMMAND_GET_ATTRIBUTE: 486 return GetAttribute(command_msg.arg()); 487 // for shell driver 488 case VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND: 489 ExecuteShellCommand(command_msg); 490 return true; 491 default: 492 cerr << __func__ << " ERROR unknown command " 493 << command_msg.command_type() << endl; 494 return DefaultResponse(); 495 } 496 } 497 498 } // namespace vts 499 } // namespace android 500
