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 "
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