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 --server " 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 --server " 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 --server " 190 "--server_socket_path=%s " 191 "--spec_dir=%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 --server " 199 "--service_name=%s " 200 "--spec_dir=%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 int32_t result; 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 result = client->LoadHal(file_path, target_class, target_type, 266 target_version, target_package, 267 target_component_name, 268 hw_binder_service_name, module_name); 269 cout << "[driver->agent]: LoadHal returns " << result << endl; 270 if (result == VTS_DRIVER_RESPONSE_SUCCESS) { 271 response_msg.set_response_code(SUCCESS); 272 response_msg.set_reason("Loaded the selected HAL."); 273 cout << "set service_name " << service_name << endl; 274 service_name_ = service_name; 275 } else { 276 response_msg.set_response_code(FAIL); 277 response_msg.set_reason("Failed to load the selected HAL."); 278 } 279 } else if (driver_type == VTS_DRIVER_TYPE_SHELL) { 280 response_msg.set_response_code(SUCCESS); 281 response_msg.set_reason("Loaded the shell driver."); 282 cout << "set service_name " << service_name << endl; 283 service_name_ = service_name; 284 } 285 286 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 287 driver_client_ = client; 288 #endif 289 return VtsSocketSendMessage(response_msg); 290 } 291 } 292 response_msg.set_reason( 293 "Failed to fork a child process to start a driver."); 294 } 295 response_msg.set_response_code(FAIL); 296 cerr << "can't fork a child process to run the vts_hal_driver." << endl; 297 return VtsSocketSendMessage(response_msg); 298 } 299 300 bool AgentRequestHandler::ReadSpecification( 301 const AndroidSystemControlCommandMessage& command_message) { 302 cout << "[runner->agent] command " << __FUNCTION__ << endl; 303 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 304 VtsDriverSocketClient* client = driver_client_; 305 if (!client) { 306 #else // binder 307 android::sp<android::vts::IVtsFuzzer> client = 308 android::vts::GetBinderClient(service_name_); 309 if (!client.get()) { 310 #endif 311 return false; 312 } 313 314 const char* result = client->ReadSpecification( 315 command_message.service_name(), 316 command_message.target_class(), 317 command_message.target_type(), 318 command_message.target_version() / 100.0, 319 command_message.target_package()); 320 321 AndroidSystemControlResponseMessage response_msg; 322 if (result != NULL && strlen(result) > 0) { 323 cout << "[agent] Call: success" << endl; 324 response_msg.set_response_code(SUCCESS); 325 response_msg.set_result(result); 326 } else { 327 cout << "[agent] Call: fail" << endl; 328 response_msg.set_response_code(FAIL); 329 response_msg.set_reason("Failed to call the api."); 330 } 331 bool succ = VtsSocketSendMessage(response_msg); 332 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 333 free((void*)result); 334 #endif 335 return succ; 336 } 337 338 bool AgentRequestHandler::ListApis() { 339 cout << "[runner->agent] command " << __FUNCTION__ << endl; 340 // TODO: use an attribute (client) of a newly defined class. 341 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 342 VtsDriverSocketClient* client = driver_client_; 343 if (!client) { 344 #else // binder 345 android::sp<android::vts::IVtsFuzzer> client = 346 android::vts::GetBinderClient(service_name_); 347 if (!client.get()) { 348 #endif 349 return false; 350 } 351 const char* result = client->GetFunctions(); 352 if (result != NULL) { 353 cout << "GetFunctions: len " << strlen(result) << endl; 354 } 355 356 AndroidSystemControlResponseMessage response_msg; 357 if (result != NULL && strlen(result) > 0) { 358 response_msg.set_response_code(SUCCESS); 359 response_msg.set_spec(string(result)); 360 } else { 361 response_msg.set_response_code(FAIL); 362 response_msg.set_reason("Failed to get the functions."); 363 } 364 365 bool succ = VtsSocketSendMessage(response_msg); 366 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 367 free((void*)result); 368 #endif 369 return succ; 370 } 371 372 bool AgentRequestHandler::CallApi(const string& call_payload, 373 const string& uid) { 374 cout << "[runner->agent] command " << __FUNCTION__ << endl; 375 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 376 VtsDriverSocketClient* client = driver_client_; 377 if (!client) { 378 #else // binder 379 // TODO: use an attribute (client) of a newly defined class. 380 android::sp<android::vts::IVtsFuzzer> client = 381 android::vts::GetBinderClient(service_name_); 382 if (!client.get()) { 383 #endif 384 return false; 385 } 386 387 const char* result = client->Call(call_payload, uid); 388 389 AndroidSystemControlResponseMessage response_msg; 390 if (result != NULL && strlen(result) > 0) { 391 cout << "[agent] Call: success" << endl; 392 response_msg.set_response_code(SUCCESS); 393 response_msg.set_result(result); 394 } else { 395 cout << "[agent] Call: fail" << endl; 396 response_msg.set_response_code(FAIL); 397 response_msg.set_reason("Failed to call the api."); 398 } 399 bool succ = VtsSocketSendMessage(response_msg); 400 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 401 free((void*)result); 402 #endif 403 return succ; 404 } 405 406 bool AgentRequestHandler::GetAttribute(const string& payload) { 407 cout << "[runner->agent] command " << __FUNCTION__ << endl; 408 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 409 VtsDriverSocketClient* client = driver_client_; 410 if (!client) { 411 #else // binder 412 // TODO: use an attribute (client) of a newly defined class. 413 android::sp<android::vts::IVtsFuzzer> client = 414 android::vts::GetBinderClient(service_name_); 415 if (!client.get()) { 416 #endif 417 return false; 418 } 419 420 const char* result = client->GetAttribute(payload); 421 422 AndroidSystemControlResponseMessage response_msg; 423 if (result != NULL && strlen(result) > 0) { 424 cout << "[agent] Call: success" << endl; 425 response_msg.set_response_code(SUCCESS); 426 response_msg.set_result(result); 427 } else { 428 cout << "[agent] Call: fail" << endl; 429 response_msg.set_response_code(FAIL); 430 response_msg.set_reason("Failed to call the api."); 431 } 432 bool succ = VtsSocketSendMessage(response_msg); 433 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 434 free((void*)result); 435 #endif 436 return succ; 437 } 438 439 bool AgentRequestHandler::DefaultResponse() { 440 cout << "[agent] " << __FUNCTION__ << endl; 441 AndroidSystemControlResponseMessage response_msg; 442 response_msg.set_response_code(SUCCESS); 443 response_msg.set_reason("an example reason here"); 444 return VtsSocketSendMessage(response_msg); 445 } 446 447 bool AgentRequestHandler::ExecuteShellCommand( 448 const AndroidSystemControlCommandMessage& command_message) { 449 cout << "[runner->agent] command " << __FUNCTION__ << endl; 450 #ifndef VTS_AGENT_DRIVER_COMM_BINDER // socket 451 VtsDriverSocketClient* client = driver_client_; 452 if (!client) { 453 #else // binder 454 cerr << __func__ << " binder not supported." << endl; 455 { 456 #endif 457 return false; 458 } 459 460 VtsDriverControlResponseMessage* result_message = client->ExecuteShellCommand( 461 command_message.shell_command()); 462 463 AndroidSystemControlResponseMessage response_msg; 464 465 if (result_message == NULL) { 466 cout << "ExecuteShellCommand: failed to call the api" << endl; 467 response_msg.set_response_code(FAIL); 468 response_msg.set_reason("Failed to call the api."); 469 } else { 470 CreateSystemControlResponseFromDriverControlResponse( 471 *result_message, &response_msg); 472 delete(result_message); 473 } 474 475 bool succ = VtsSocketSendMessage(response_msg); 476 return succ; 477 } 478 479 void AgentRequestHandler::CreateSystemControlResponseFromDriverControlResponse( 480 const VtsDriverControlResponseMessage& driver_control_response_message, 481 AndroidSystemControlResponseMessage* system_control_response_message) { 482 483 if (driver_control_response_message.response_code() == 484 VTS_DRIVER_RESPONSE_SUCCESS) { 485 cout << "ExecuteShellCommand: shell driver reported success" << endl; 486 system_control_response_message->set_response_code(SUCCESS); 487 } else if (driver_control_response_message.response_code() == 488 VTS_DRIVER_RESPONSE_FAIL) { 489 cout << "ExecuteShellCommand: shell driver reported fail" << endl; 490 system_control_response_message->set_response_code(FAIL); 491 } else if (driver_control_response_message.response_code() == 492 UNKNOWN_VTS_DRIVER_RESPONSE_CODE) { 493 cout << "ExecuteShellCommand: shell driver reported unknown" << endl; 494 system_control_response_message->set_response_code(UNKNOWN_RESPONSE_CODE); 495 } 496 497 for (const auto& log_stdout : driver_control_response_message.stdout()) { 498 system_control_response_message->add_stdout(log_stdout); 499 } 500 501 for (const auto& log_stderr : driver_control_response_message.stderr()) { 502 system_control_response_message->add_stderr(log_stderr); 503 } 504 505 for (const auto& exit_code : driver_control_response_message.exit_code()) { 506 system_control_response_message->add_exit_code(exit_code); 507 } 508 } 509 510 bool AgentRequestHandler::ProcessOneCommand() { 511 AndroidSystemControlCommandMessage command_msg; 512 if (!VtsSocketRecvMessage(&command_msg)) return false; 513 514 cout << getpid() << " " << __func__ 515 << " command_type = " << command_msg.command_type() << endl; 516 switch (command_msg.command_type()) { 517 case LIST_HALS: 518 return ListHals(command_msg.paths()); 519 case SET_HOST_INFO: 520 return SetHostInfo(command_msg.callback_port()); 521 case CHECK_DRIVER_SERVICE: 522 return CheckDriverService(command_msg.service_name(), NULL); 523 case LAUNCH_DRIVER_SERVICE: 524 return LaunchDriverService(command_msg); 525 case VTS_AGENT_COMMAND_READ_SPECIFICATION: 526 return ReadSpecification(command_msg); 527 case LIST_APIS: 528 return ListApis(); 529 case CALL_API: 530 return CallApi(command_msg.arg(), command_msg.driver_caller_uid()); 531 case VTS_AGENT_COMMAND_GET_ATTRIBUTE: 532 return GetAttribute(command_msg.arg()); 533 // for shell driver 534 case VTS_AGENT_COMMAND_EXECUTE_SHELL_COMMAND: 535 ExecuteShellCommand(command_msg); 536 return true; 537 default: 538 cerr << __func__ << " ERROR unknown command " 539 << command_msg.command_type() << endl; 540 return DefaultResponse(); 541 } 542 } 543 544 } // namespace vts 545 } // namespace android 546
