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
ListHals(const RepeatedPtrField<string> & base_paths)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
SetHostInfo(const int callback_port)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
CheckDriverService(const string & service_name,bool * live)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