1 /* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #![allow(missing_docs)] 16 use crate::common::sendmsg::send_msg; 17 use crate::common::uds::{PollNode, UdsAddr, UdsServer}; 18 use crate::config::ErrCode; 19 use crate::config::HdcCommand; 20 use crate::config::TaskMessage; 21 use crate::daemon_lib::sys_para::set_dev_item; 22 use crate::{transfer, utils}; 23 use crate::utils::hdc_log::*; 24 use libc::{POLLERR, POLLHUP, POLLIN, POLLNVAL, POLLRDHUP, SOCK_STREAM}; 25 26 use std::collections::HashMap; 27 use std::sync::{Arc, Once}; 28 #[cfg(feature = "host")] 29 extern crate ylong_runtime_static as ylong_runtime; 30 use ylong_runtime::sync::waiter::Waiter; 31 use ylong_runtime::sync::Mutex; 32 33 const JPID_SOCKET_PATH: &str = "ohjpid-control"; 34 const PATH_LEN: usize = JPID_SOCKET_PATH.as_bytes().len() + 1; 35 36 #[allow(unused)] 37 #[derive(Clone, Debug, PartialEq)] 38 pub enum DisplayType { 39 AllApp = 0, 40 DebugApp = 1, 41 ReleaseApp = 2, 42 AllAppWithType = 3, 43 } 44 45 type NodeMap = Arc<Mutex<HashMap<i32, PollNode>>>; 46 type SocketPairVec = Arc<Mutex<Vec<(i32, i32)>>>; 47 type SocketpairMap = Arc<Mutex<HashMap<u32, SocketPairVec>>>; 48 type Trackers = Arc<Mutex<Vec<(u32, u32, DisplayType)>>>; 49 50 pub trait JdwpBase: Send + Sync + 'static {} 51 pub struct Jdwp { 52 poll_node_map: NodeMap, 53 socketpair_map: SocketpairMap, 54 new_process_waiter: Arc<Waiter>, 55 trackers: Trackers, 56 await_fd: i32, 57 } 58 59 impl JdwpBase for Jdwp {} 60 61 type JdWpShare = Arc<Jdwp>; 62 63 impl Default for Jdwp { defaultnull64 fn default() -> Self { 65 Self::new() 66 } 67 } 68 69 impl Jdwp { get_instancenull70 pub fn get_instance() -> JdWpShare { 71 static mut INSTANCE: Option<JdWpShare> = None; 72 unsafe { 73 INSTANCE 74 .get_or_insert_with(|| Arc::new(Jdwp::new())) 75 .clone() 76 } 77 } 78 newnull79 pub fn new() -> Self { 80 Self { 81 poll_node_map: Arc::new(Mutex::new(HashMap::default())), 82 socketpair_map: Arc::new(Mutex::new(HashMap::default())), 83 new_process_waiter: Arc::new(Waiter::new()), 84 trackers: Arc::new(Mutex::new(Vec::new())), 85 await_fd: UdsServer::wrap_event_fd(), 86 } 87 } 88 } 89 90 impl Jdwp { 91 async fn put_socketpair(&self, target_pid: u32, fd: i32, fd2: i32) { 92 let socketpair_map = self.socketpair_map.clone(); 93 let mut socketpair_map_lock = socketpair_map.lock().await; 94 if let Some(vec) = socketpair_map_lock.get(&target_pid) { 95 let mut lock = vec.lock().await; 96 lock.push((fd, fd2)); 97 } else { 98 let vec = vec![(fd, fd2)]; 99 socketpair_map_lock.insert(target_pid, Arc::new(Mutex::new(vec))); 100 } 101 } 102 103 pub async fn send_fd_to_target(&self, target_pid: u32, fd: i32, fd2: i32, parameter: &str) -> bool { 104 let map = self.poll_node_map.clone(); 105 let map = map.lock().await; 106 let keys = map.keys(); 107 for k in keys { 108 let v = map.get(k); 109 if let Some(node) = v { 110 if node.ppid == target_pid { 111 crate::info!("send_fd_to_target pid:{target_pid}, fd:({fd}, {fd2})"); 112 self.put_socketpair(target_pid, fd, fd2).await; 113 114 let bytes = fd.to_be_bytes(); 115 let fd_bytes = bytes.as_slice(); 116 let param_bytes = parameter.as_bytes(); 117 let param_bytes = [fd_bytes, param_bytes].concat(); 118 let param_bytes = param_bytes.as_slice(); 119 let ret = send_msg(node.fd, fd, param_bytes); 120 crate::info!("send_fd_to_target ret:{}", ret); 121 return ret > 0; 122 } 123 } 124 } 125 false 126 } 127 128 async fn send_process_list(trackers: Trackers, node_map: NodeMap) { 129 let trackers = trackers.lock().await; 130 for (channel_id2, session_id2, display) in trackers.iter() { 131 let message = Self::get_process_list_with_pkg_name(node_map.clone(), display.clone()).await; 132 let len = message.as_bytes().len(); 133 let len_str = format!("{:04x}\n", len); 134 let mut header = len_str.as_bytes().to_vec(); 135 let mut buffer = Vec::<u8>::new(); 136 buffer.append(&mut header); 137 buffer.append(&mut message.as_str().as_bytes().to_vec()); 138 139 let data = TaskMessage { 140 channel_id: *channel_id2, 141 command: HdcCommand::KernelEchoRaw, 142 payload: buffer.to_vec(), 143 }; 144 transfer::put(*session_id2, data).await; 145 } 146 } 147 148 pub async fn add_tracker(&self, channel_id: u32, session_id: u32, display: DisplayType) { 149 let mut trackers_lock = self.trackers.lock().await; 150 trackers_lock.push((channel_id, session_id, display)); 151 drop(trackers_lock); 152 153 let node_map = self.poll_node_map.clone(); 154 Self::send_process_list(self.trackers.clone(), node_map).await; 155 } 156 157 pub async fn get_process_list(&self) -> String { 158 let mut result = String::from(""); 159 let map = self.poll_node_map.clone(); 160 let map = map.lock().await; 161 let keys = map.keys(); 162 for key in keys { 163 let value = map.get(key); 164 if let Some(v) = value { 165 result.push_str((v.ppid.to_string() + "\n").as_str()); 166 } 167 } 168 result 169 } 170 171 pub async fn get_process_list_with_pkg_name(map: NodeMap, display: DisplayType) -> String { 172 let mut result = String::from(""); 173 let map = map.lock().await; 174 let keys = map.keys(); 175 for key in keys { 176 let value = map.get(key); 177 if let Some(v) = value { 178 if display == DisplayType::AllApp { 179 result.push_str((v.ppid.to_string() + " " + v.pkg_name.as_str() + "\n").as_str()); 180 } else if display == DisplayType::DebugApp { 181 if v.is_debug { 182 result.push_str((v.ppid.to_string() + " " + v.pkg_name.as_str() + "\n").as_str()); 183 } 184 } else if display == DisplayType::AllAppWithType { 185 let mut apptype = String::from("release"); 186 if v.is_debug { 187 apptype = String::from("debug"); 188 } 189 result.push_str(( 190 v.ppid.to_string() + " " 191 + v.pkg_name.as_str() + " " 192 + apptype.as_str() + "\n").as_str()); 193 } 194 } 195 } 196 result 197 } 198 chang_item_oncenull199 fn chang_item_once() { 200 static ONCE: Once = Once::new(); 201 ONCE.call_once(|| { 202 let result = set_dev_item("persist.hdc.jdwp", "0"); 203 crate::info!("set persist.hdc.jdwp to 0 result: {}", result); 204 } 205 ); 206 } 207 208 pub async fn handle_client(fd: i32, waiter: Arc<Waiter>, node_map: NodeMap) { 209 crate::info!("handle_client start..."); 210 let mut buffer: [u8; 1024] = [0; 1024]; 211 let size = UdsServer::wrap_recv(fd, &mut buffer); 212 let u32_size = std::mem::size_of::<u32>(); 213 if size > u32_size as isize { 214 let len = u32::from_le_bytes(buffer[0..u32_size].try_into().unwrap_or_default()); 215 let pid = u32::from_le_bytes(buffer[u32_size..2 * u32_size].try_into().unwrap_or_default()); 216 if pid == 0 || len == 0 { 217 crate::warn!("Data parsing exception. pid {pid}, len {len}"); 218 return; 219 } 220 crate::info!("pid:{}", pid); 221 let is_debug = u32::from_le_bytes(buffer[u32_size * 2..3 * u32_size].try_into().unwrap_or_default()) == 1; 222 crate::info!("debug:{}", is_debug); 223 let pkg_name = String::from_utf8(buffer[u32_size * 3..len as usize].to_vec()).unwrap_or_default(); 224 crate::info!("pkg name:{}", pkg_name); 225 Self::chang_item_once(); 226 227 let node_map = node_map.clone(); 228 let mut map = node_map.lock().await; 229 let node = PollNode::new(fd, pid, pkg_name.clone(), is_debug); 230 let mut key_ = -1; 231 for (key, value) in map.iter() { 232 if value.pkg_name == pkg_name { 233 key_ = *key; 234 UdsServer::wrap_close(value.fd); 235 break; 236 } 237 } 238 if key_ != -1 { 239 map.remove(&key_); 240 } 241 map.insert(fd, node); 242 drop(map); 243 244 waiter.wake_one(); 245 } else if size <= u32_size as isize { 246 crate::info!("The data length is too short, size = {size}"); 247 } 248 } 249 jdwp_listennull250 pub fn jdwp_listen(&self) -> bool { 251 let fd = UdsServer::wrap_socket(SOCK_STREAM); 252 let name = JPID_SOCKET_PATH.as_bytes(); 253 let socket_name = &mut [0u8; PATH_LEN]; 254 socket_name[0] = b'\0'; 255 socket_name[1..].copy_from_slice(name); 256 let addr = UdsAddr::parse_abstract(&socket_name[1..]); 257 if let Ok(addr_obj) = &addr { 258 if let Err(ret) = UdsServer::wrap_bind(fd, addr_obj) { 259 crate::error!("bind fail. {ret:?}"); 260 return false; 261 } 262 let ret = UdsServer::wrap_listen(fd); 263 if ret < 0 { 264 crate::error!("listen fail, ret = {ret}"); 265 return false; 266 } 267 let node_map = self.poll_node_map.clone(); 268 let waiter = self.new_process_waiter.clone(); 269 ylong_runtime::spawn(async move { 270 loop { 271 let client_fd = UdsServer::wrap_accept(fd); 272 if client_fd == -1 { 273 crate::error!("wrap_accept failed"); 274 break; 275 } 276 let map = node_map.clone(); 277 let w = waiter.clone(); 278 utils::spawn(Self::handle_client(client_fd, w, map)); 279 } 280 }); 281 true 282 } else { 283 crate::info!("parse addr fail "); 284 false 285 } 286 } 287 start_data_loopernull288 pub fn start_data_looper(&self) { 289 let node_map = self.poll_node_map.clone(); 290 let socketpair_map = self.socketpair_map.clone(); 291 let trackers = self.trackers.clone(); 292 let await_fd = self.await_fd; 293 utils::spawn(async move { 294 loop { 295 let mut poll_nodes = Vec::<PollNode>::new(); 296 let mut fd_node = PollNode::new(await_fd, 0, "".to_string(), false); 297 fd_node.revents = 0; 298 fd_node.events = POLLIN; 299 poll_nodes.push(fd_node); 300 301 let node_map_value = node_map.lock().await; 302 let keys = node_map_value.keys(); 303 for k in keys { 304 if let Some(n) = node_map_value.get(k) { 305 poll_nodes.push(n.clone()); 306 } 307 } 308 let size = poll_nodes.len(); 309 310 drop(node_map_value); 311 UdsServer::wrap_poll(poll_nodes.as_mut_slice(), size.try_into().unwrap_or_default(), -1); 312 let mut node_map_value = node_map.lock().await; 313 for pnode in &poll_nodes { 314 if pnode.revents & (POLLNVAL | POLLRDHUP | POLLHUP | POLLERR) != 0 { 315 crate::info!("start_data_looper remove node:{}", pnode.pkg_name); 316 node_map_value.remove(&pnode.fd); 317 UdsServer::wrap_close(pnode.fd); 318 319 let pid = pnode.ppid; 320 let mut socketpair_map_lock = socketpair_map.lock().await; 321 if let Some(vec) = socketpair_map_lock.remove(&pid) { 322 let lock = vec.lock().await; 323 for (fd0, fd1) in lock.iter() { 324 //此处close socketpair,会导致hdcd和aa之间的pipe异常，hdcd读取不到aa force-stop的返回结果 325 crate::info!("start_data_looper close pid:{}, socketpair_fd:({},{})", pid, fd0, fd1); 326 } 327 } 328 } else if pnode.fd == await_fd && pnode.revents & POLLIN != 0 { 329 UdsServer::wrap_read_fd(await_fd); 330 } 331 } 332 drop(node_map_value); 333 let trackers = trackers.clone(); 334 let node_map = node_map.clone(); 335 Self::send_process_list(trackers, node_map).await; 336 } 337 }); 338 } 339 340 pub async fn create_fd_event_poll(&self) { 341 loop { 342 let waiter = self.new_process_waiter.clone(); 343 waiter.wait().await; 344 345 UdsServer::wrap_write_fd(self.await_fd); 346 } 347 } 348 349 pub async fn init(&self) -> ErrCode { 350 if !self.jdwp_listen() { 351 crate::info!("jdwp_listen failed"); 352 return ErrCode::ModuleJdwpFailed; 353 } 354 355 self.start_data_looper(); 356 set_dev_item("persist.hdc.jdwp", "0"); 357 let result = set_dev_item("persist.hdc.jdwp", "1"); 358 crate::info!("init set persist.hdc.jdwp to 1 result: {}", result); 359 self.create_fd_event_poll().await; 360 ErrCode::Success 361 } 362 } 363 364 pub async fn stop_session_task(session_id: u32) { 365 let jdwp = Jdwp::get_instance(); 366 let mut trackers = jdwp.trackers.lock().await; 367 trackers.retain(|x| x.1 != session_id); 368 } 369 370 pub async fn stop_task(session_id: u32, channel_id: u32) { 371 let jdwp = Jdwp::get_instance(); 372 let mut trackers = jdwp.trackers.lock().await; 373 trackers.retain(|x| x.1 != session_id || x.0 != channel_id); 374 } 375