* Copyright (C) 2023 Huawei Device Co., Ltd.
* 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.
*/
#![allow(missing_docs)]
use crate::common::sendmsg::send_msg;
use crate::common::uds::{PollNode, UdsAddr, UdsServer};
use crate::config::ErrCode;
use crate::config::HdcCommand;
use crate::config::TaskMessage;
use crate::daemon_lib::sys_para::set_dev_item;
use crate::{transfer, utils};
use crate::utils::hdc_log::*;
use libc::{POLLERR, POLLHUP, POLLIN, POLLNVAL, POLLRDHUP, SOCK_STREAM};
use std::collections::HashMap;
use std::sync::{Arc, Once};
#[cfg(feature = "host")]
extern crate ylong_runtime_static as ylong_runtime;
use ylong_runtime::sync::waiter::Waiter;
use ylong_runtime::sync::Mutex;
const JPID_SOCKET_PATH: &str = "ohjpid-control";
const PATH_LEN: usize = JPID_SOCKET_PATH.as_bytes().len() + 1;
#[allow(unused)]
#[derive(Clone, Debug, PartialEq)]
pub enum DisplayType {
AllApp = 0,
DebugApp = 1,
ReleaseApp = 2,
AllAppWithType = 3,
}
type NodeMap = Arc<Mutex<HashMap<i32, PollNode>>>;
type SocketPairVec = Arc<Mutex<Vec<(i32, i32)>>>;
type SocketpairMap = Arc<Mutex<HashMap<u32, SocketPairVec>>>;
type Trackers = Arc<Mutex<Vec<(u32, u32, DisplayType)>>>;
pub trait JdwpBase: Send + Sync + 'static {}
pub struct Jdwp {
poll_node_map: NodeMap,
socketpair_map: SocketpairMap,
new_process_waiter: Arc<Waiter>,
trackers: Trackers,
await_fd: i32,
}
impl JdwpBase for Jdwp {}
type JdWpShare = Arc<Jdwp>;
impl Default for Jdwp {
fn default() -> Self {
Self::new()
}
}
impl Jdwp {
pub fn get_instance() -> JdWpShare {
static mut INSTANCE: Option<JdWpShare> = None;
unsafe {
INSTANCE
.get_or_insert_with(|| Arc::new(Jdwp::new()))
.clone()
}
}
pub fn new() -> Self {
Self {
poll_node_map: Arc::new(Mutex::new(HashMap::default())),
socketpair_map: Arc::new(Mutex::new(HashMap::default())),
new_process_waiter: Arc::new(Waiter::new()),
trackers: Arc::new(Mutex::new(Vec::new())),
await_fd: UdsServer::wrap_event_fd(),
}
}
}
impl Jdwp {
async fn put_socketpair(&self, target_pid: u32, fd: i32, fd2: i32) {
let socketpair_map = self.socketpair_map.clone();
let mut socketpair_map_lock = socketpair_map.lock().await;
if let Some(vec) = socketpair_map_lock.get(&target_pid) {
let mut lock = vec.lock().await;
lock.push((fd, fd2));
} else {
let vec = vec![(fd, fd2)];
socketpair_map_lock.insert(target_pid, Arc::new(Mutex::new(vec)));
}
}
pub async fn send_fd_to_target(&self, target_pid: u32, fd: i32, fd2: i32, parameter: &str) -> bool {
let map = self.poll_node_map.clone();
let map = map.lock().await;
let keys = map.keys();
for k in keys {
let v = map.get(k);
if let Some(node) = v {
if node.ppid == target_pid {
crate::info!("send_fd_to_target pid:{target_pid}, fd:({fd}, {fd2})");
self.put_socketpair(target_pid, fd, fd2).await;
let bytes = fd.to_be_bytes();
let fd_bytes = bytes.as_slice();
let param_bytes = parameter.as_bytes();
let param_bytes = [fd_bytes, param_bytes].concat();
let param_bytes = param_bytes.as_slice();
let ret = send_msg(node.fd, fd, param_bytes);
crate::info!("send_fd_to_target ret:{}", ret);
return ret > 0;
}
}
}
false
}
async fn send_process_list(trackers: Trackers, node_map: NodeMap) {
let trackers = trackers.lock().await;
for (channel_id2, session_id2, display) in trackers.iter() {
let message = Self::get_process_list_with_pkg_name(node_map.clone(), display.clone()).await;
let len = message.as_bytes().len();
let len_str = format!("{:04x}\n", len);
let mut header = len_str.as_bytes().to_vec();
let mut buffer = Vec::<u8>::new();
buffer.append(&mut header);
buffer.append(&mut message.as_str().as_bytes().to_vec());
let data = TaskMessage {
channel_id: *channel_id2,
command: HdcCommand::KernelEchoRaw,
payload: buffer.to_vec(),
};
transfer::put(*session_id2, data).await;
}
}
pub async fn add_tracker(&self, channel_id: u32, session_id: u32, display: DisplayType) {
let mut trackers_lock = self.trackers.lock().await;
trackers_lock.push((channel_id, session_id, display));
drop(trackers_lock);
let node_map = self.poll_node_map.clone();
Self::send_process_list(self.trackers.clone(), node_map).await;
}
pub async fn get_process_list(&self) -> String {
let mut result = String::from("");
let map = self.poll_node_map.clone();
let map = map.lock().await;
let keys = map.keys();
for key in keys {
let value = map.get(key);
if let Some(v) = value {
result.push_str((v.ppid.to_string() + "\n").as_str());
}
}
result
}
pub async fn get_process_list_with_pkg_name(map: NodeMap, display: DisplayType) -> String {
let mut result = String::from("");
let map = map.lock().await;
let keys = map.keys();
for key in keys {
let value = map.get(key);
if let Some(v) = value {
if display == DisplayType::AllApp {
result.push_str((v.ppid.to_string() + " " + v.pkg_name.as_str() + "\n").as_str());
} else if display == DisplayType::DebugApp {
if v.is_debug {
result.push_str((v.ppid.to_string() + " " + v.pkg_name.as_str() + "\n").as_str());
}
} else if display == DisplayType::AllAppWithType {
let mut apptype = String::from("release");
if v.is_debug {
apptype = String::from("debug");
}
result.push_str((
v.ppid.to_string() + " "
+ v.pkg_name.as_str() + " "
+ apptype.as_str() + "\n").as_str());
}
}
}
result
}
fn chang_item_once() {
static ONCE: Once = Once::new();
ONCE.call_once(|| {
let result = set_dev_item("persist.hdc.jdwp", "0");
crate::info!("set persist.hdc.jdwp to 0 result: {}", result);
}
);
}
pub async fn handle_client(fd: i32, waiter: Arc<Waiter>, node_map: NodeMap) {
crate::info!("handle_client start...");
let mut buffer: [u8; 1024] = [0; 1024];
let size = UdsServer::wrap_recv(fd, &mut buffer);
let u32_size = std::mem::size_of::<u32>();
if size > u32_size as isize {
let len = u32::from_le_bytes(buffer[0..u32_size].try_into().unwrap_or_default());
let pid = u32::from_le_bytes(buffer[u32_size..2 * u32_size].try_into().unwrap_or_default());
if pid == 0 || len == 0 {
crate::warn!("Data parsing exception. pid {pid}, len {len}");
return;
}
crate::info!("pid:{}", pid);
let is_debug = u32::from_le_bytes(buffer[u32_size * 2..3 * u32_size].try_into().unwrap_or_default()) == 1;
crate::info!("debug:{}", is_debug);
let pkg_name = String::from_utf8(buffer[u32_size * 3..len as usize].to_vec()).unwrap_or_default();
crate::info!("pkg name:{}", pkg_name);
Self::chang_item_once();
let node_map = node_map.clone();
let mut map = node_map.lock().await;
let node = PollNode::new(fd, pid, pkg_name.clone(), is_debug);
let mut key_ = -1;
for (key, value) in map.iter() {
if value.pkg_name == pkg_name {
key_ = *key;
UdsServer::wrap_close(value.fd);
break;
}
}
if key_ != -1 {
map.remove(&key_);
}
map.insert(fd, node);
drop(map);
waiter.wake_one();
} else if size <= u32_size as isize {
crate::info!("The data length is too short, size = {size}");
}
}
pub fn jdwp_listen(&self) -> bool {
let fd = UdsServer::wrap_socket(SOCK_STREAM);
let name = JPID_SOCKET_PATH.as_bytes();
let socket_name = &mut [0u8; PATH_LEN];
socket_name[0] = b'\0';
socket_name[1..].copy_from_slice(name);
let addr = UdsAddr::parse_abstract(&socket_name[1..]);
if let Ok(addr_obj) = &addr {
if let Err(ret) = UdsServer::wrap_bind(fd, addr_obj) {
crate::error!("bind fail. {ret:?}");
return false;
}
let ret = UdsServer::wrap_listen(fd);
if ret < 0 {
crate::error!("listen fail, ret = {ret}");
return false;
}
let node_map = self.poll_node_map.clone();
let waiter = self.new_process_waiter.clone();
ylong_runtime::spawn(async move {
loop {
let client_fd = UdsServer::wrap_accept(fd);
if client_fd == -1 {
crate::error!("wrap_accept failed");
break;
}
let map = node_map.clone();
let w = waiter.clone();
utils::spawn(Self::handle_client(client_fd, w, map));
}
});
true
} else {
crate::info!("parse addr fail ");
false
}
}
pub fn start_data_looper(&self) {
let node_map = self.poll_node_map.clone();
let socketpair_map = self.socketpair_map.clone();
let trackers = self.trackers.clone();
let await_fd = self.await_fd;
utils::spawn(async move {
loop {
let mut poll_nodes = Vec::<PollNode>::new();
let mut fd_node = PollNode::new(await_fd, 0, "".to_string(), false);
fd_node.revents = 0;
fd_node.events = POLLIN;
poll_nodes.push(fd_node);
let node_map_value = node_map.lock().await;
let keys = node_map_value.keys();
for k in keys {
if let Some(n) = node_map_value.get(k) {
poll_nodes.push(n.clone());
}
}
let size = poll_nodes.len();
drop(node_map_value);
UdsServer::wrap_poll(poll_nodes.as_mut_slice(), size.try_into().unwrap_or_default(), -1);
let mut node_map_value = node_map.lock().await;
for pnode in &poll_nodes {
if pnode.revents & (POLLNVAL | POLLRDHUP | POLLHUP | POLLERR) != 0 {
crate::info!("start_data_looper remove node:{}", pnode.pkg_name);
node_map_value.remove(&pnode.fd);
UdsServer::wrap_close(pnode.fd);
let pid = pnode.ppid;
let mut socketpair_map_lock = socketpair_map.lock().await;
if let Some(vec) = socketpair_map_lock.remove(&pid) {
let lock = vec.lock().await;
for (fd0, fd1) in lock.iter() {
crate::info!("start_data_looper close pid:{}, socketpair_fd:({},{})", pid, fd0, fd1);
}
}
} else if pnode.fd == await_fd && pnode.revents & POLLIN != 0 {
UdsServer::wrap_read_fd(await_fd);
}
}
drop(node_map_value);
let trackers = trackers.clone();
let node_map = node_map.clone();
Self::send_process_list(trackers, node_map).await;
}
});
}
pub async fn create_fd_event_poll(&self) {
loop {
let waiter = self.new_process_waiter.clone();
waiter.wait().await;
UdsServer::wrap_write_fd(self.await_fd);
}
}
pub async fn init(&self) -> ErrCode {
if !self.jdwp_listen() {
crate::info!("jdwp_listen failed");
return ErrCode::ModuleJdwpFailed;
}
self.start_data_looper();
set_dev_item("persist.hdc.jdwp", "0");
let result = set_dev_item("persist.hdc.jdwp", "1");
crate::info!("init set persist.hdc.jdwp to 1 result: {}", result);
self.create_fd_event_poll().await;
ErrCode::Success
}
}
pub async fn stop_session_task(session_id: u32) {
let jdwp = Jdwp::get_instance();
let mut trackers = jdwp.trackers.lock().await;
trackers.retain(|x| x.1 != session_id);
}
pub async fn stop_task(session_id: u32, channel_id: u32) {
let jdwp = Jdwp::get_instance();
let mut trackers = jdwp.trackers.lock().await;
trackers.retain(|x| x.1 != session_id || x.0 != channel_id);
}