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 //! uds
16 #![allow(missing_docs)]
17 #![allow(clippy::missing_safety_doc)]
18 use std::io::{self, ErrorKind, Result};
19 use std::mem;
20
21 use libc::bind;
22 use libc::c_void;
23 use libc::{accept4, close, connect};
24 use libc::{c_char, listen, poll, recv, socket, MSG_NOSIGNAL};
25 use libc::{c_int, sa_family_t, sockaddr, sockaddr_un, socklen_t, AF_UNIX};
26 use libc::{fcntl, pipe, read, send, socketpair, write, MSG_EOR};
27 use libc::{POLLERR, POLLHUP, POLLNVAL, POLLRDHUP};
28 use libc::{SOCK_CLOEXEC, SOCK_STREAM};
29
30 const LISTEN_BACKLOG: c_int = 10;
31 const MAX_CLIENT_FD_COUNT: usize = 256;
32
33 #[derive(PartialEq, Debug, Clone)]
34 pub struct PollNode {
35 pub fd: i32,
36 pub events: i16,
37 pub revents: i16,
38 pub ppid: u32,
39 pub pkg_name: String,
40 pub debug_or_release: bool,
41 }
42
43 impl PollNode {
new(fd: i32, ppid: u32, pkg_name: String, debug_or_release: bool) -> Self44 pub fn new(fd: i32, ppid: u32, pkg_name: String, debug_or_release: bool) -> Self {
45 Self {
46 fd,
47 events: POLLNVAL | POLLRDHUP | POLLHUP | POLLERR,
48 revents: 0,
49 ppid,
50 pkg_name,
51 debug_or_release,
52 }
53 }
54 }
55
name_index() -> socklen_t56 fn name_index() -> socklen_t {
57 unsafe {
58 let total_size = mem::size_of::<sockaddr_un>();
59 let name_size = mem::size_of_val(&mem::zeroed::<sockaddr_un>().sun_path);
60 (total_size - name_size) as socklen_t
61 }
62 }
63
64 // const fn as_u8(slice: &[c_char]) -> &[u8] {
65 // unsafe { &*(slice as *const [c_char] as *const [u8]) }
66 // }
67
as_char(slice: &[u8]) -> &[c_char]68 const fn as_char(slice: &[u8]) -> &[c_char] {
69 unsafe { &*(slice as *const [u8] as *const [c_char]) }
70 }
71
72 pub struct UdsAddr {
73 addr: sockaddr_un,
74 len: socklen_t,
75 }
76
77 impl Default for UdsAddr {
default() -> Self78 fn default() -> Self {
79 let mut addr: sockaddr_un = unsafe { mem::zeroed() };
80 addr.sun_family = AF_UNIX as sa_family_t;
81 Self {
82 len: name_index(),
83 addr,
84 }
85 }
86 }
87
88 impl UdsAddr {
parse_abstract(name: &[u8]) -> io::Result<Self>89 pub fn parse_abstract(name: &[u8]) -> io::Result<Self> {
90 let mut addr = UdsAddr::default();
91 addr.addr.sun_path[1..1 + name.len()].copy_from_slice(as_char(name));
92 addr.len = name_index() + 1 + name.len() as socklen_t;
93 Ok(addr)
94 }
95
as_raw_general(&self) -> (&sockaddr, socklen_t)96 pub fn as_raw_general(&self) -> (&sockaddr, socklen_t) {
97 (
98 unsafe { &*(&self.addr as *const sockaddr_un as *const sockaddr) },
99 self.len,
100 )
101 }
102
as_raw_mut_general(&mut self) -> (&mut sockaddr, &mut socklen_t)103 pub unsafe fn as_raw_mut_general(&mut self) -> (&mut sockaddr, &mut socklen_t) {
104 (
105 &mut *(&mut self.addr as *mut sockaddr_un as *mut sockaddr),
106 &mut self.len,
107 )
108 }
109 }
110
111 pub struct UdsServer {}
112
113 impl UdsServer {
wrap_socket(socket_type: c_int) -> i32114 pub fn wrap_socket(socket_type: c_int) -> i32 {
115 let flags = socket_type | SOCK_CLOEXEC;
116 unsafe { socket(AF_UNIX, flags, 0) }
117 }
118
wrap_bind(socket_fd: i32, addr: &UdsAddr) -> Result<()>119 pub fn wrap_bind(socket_fd: i32, addr: &UdsAddr) -> Result<()> {
120 unsafe {
121 let (addr_raw, len_raw) = addr.as_raw_general();
122 loop {
123 let ret = bind(socket_fd, addr_raw, len_raw);
124 println!("bind ret : {}", ret);
125 if ret != -1 {
126 break Ok(());
127 }
128 let err = io::Error::last_os_error();
129 if err.kind() != ErrorKind::Interrupted {
130 break Err(err);
131 }
132 }
133 }
134 }
135
wrap_listen(socket_fd: i32) -> c_int136 pub fn wrap_listen(socket_fd: i32) -> c_int {
137 unsafe { listen(socket_fd, LISTEN_BACKLOG) }
138 }
139
wrap_accept(socket_fd: i32) -> i32140 pub fn wrap_accept(socket_fd: i32) -> i32 {
141 let mut addr = UdsAddr::default();
142 let capacity = mem::size_of_val(&addr.addr) as socklen_t;
143 addr.len = capacity;
144 unsafe {
145 let (addr_ptr, len_ptr) = addr.as_raw_mut_general();
146 accept4(socket_fd, addr_ptr, len_ptr, SOCK_CLOEXEC)
147 }
148 }
149
wrap_recv(socket_fd: i32, buffer: &mut [u8]) -> isize150 pub fn wrap_recv(socket_fd: i32, buffer: &mut [u8]) -> isize {
151 let ptr = buffer.as_ptr() as *mut c_void;
152 unsafe { recv(socket_fd, ptr, buffer.len(), MSG_NOSIGNAL) }
153 }
154
wrap_read(socket_fd: i32, buffer: &mut [u8]) -> isize155 pub fn wrap_read(socket_fd: i32, buffer: &mut [u8]) -> isize {
156 let ptr = buffer.as_ptr() as *mut c_void;
157 unsafe { read(socket_fd, ptr, buffer.len()) }
158 }
159
wrap_write(socket_fd: i32, buffer: &[u8]) -> isize160 pub fn wrap_write(socket_fd: i32, buffer: &[u8]) -> isize {
161 let ptr = buffer.as_ptr() as *const c_void;
162 unsafe { write(socket_fd, ptr, buffer.len()) }
163 }
164
wrap_poll(fds: &mut [PollNode], size: u32, timeout: i32) -> i32165 pub fn wrap_poll(fds: &mut [PollNode], size: u32, timeout: i32) -> i32 {
166 let init_value = unsafe { mem::zeroed() };
167 let pollfds: &mut [libc::pollfd; MAX_CLIENT_FD_COUNT] =
168 &mut [init_value; MAX_CLIENT_FD_COUNT];
169 for (index, node) in fds.iter_mut().enumerate() {
170 pollfds[index].fd = node.fd;
171 pollfds[index].events = node.events;
172 pollfds[index].revents = node.revents;
173 }
174 unsafe {
175 let ret = poll(pollfds.as_mut_ptr(), size as libc::nfds_t, timeout);
176 if ret == -1 {
177 ret
178 } else {
179 for i in 0..size as usize {
180 fds[i].revents = pollfds[i].revents;
181 fds[i].events = pollfds[i].events;
182 }
183 0
184 }
185 }
186 }
187
188 #[allow(unused)]
wrap_send(socket_fd: i32, buffer: &[u8]) -> isize189 pub fn wrap_send(socket_fd: i32, buffer: &[u8]) -> isize {
190 let ptr = buffer.as_ptr() as *const c_void;
191 let flags = MSG_NOSIGNAL | MSG_EOR;
192 unsafe { send(socket_fd, ptr, buffer.len(), flags) }
193 }
194
195 #[allow(unused)]
wrap_close(socket_fd: i32)196 pub fn wrap_close(socket_fd: i32) {
197 unsafe { close(socket_fd) };
198 }
199
200 #[allow(unused)]
wrap_socketpair(socket_type: c_int) -> Result<(i32, i32)>201 pub fn wrap_socketpair(socket_type: c_int) -> Result<(i32, i32)> {
202 let flags = socket_type | SOCK_CLOEXEC;
203 let mut fd_buf = [-1; 2];
204 unsafe {
205 socketpair(AF_UNIX, flags, 0, fd_buf[..].as_mut_ptr());
206 fcntl(fd_buf[1], 100, 20);
207 }
208 Ok((fd_buf[0], fd_buf[1]))
209 }
210
211 #[allow(unused)]
wrap_pipe() -> Result<(i32, i32)>212 pub fn wrap_pipe() -> Result<(i32, i32)> {
213 let mut fd_buf = [-1; 2];
214 unsafe {
215 println!("pipe() begin...");
216 let ret = pipe(fd_buf[..].as_mut_ptr());
217 println!("pipe() ret:{}", ret);
218 if ret >= 0 {
219 fcntl(fd_buf[1], 100, 20);
220 }
221 }
222 Ok((fd_buf[0], fd_buf[1]))
223 }
224 }
225
226 pub struct UdsClient {}
227
228 impl UdsClient {
wrap_socket(af: i32) -> i32229 pub fn wrap_socket(af: i32) -> i32 {
230 let flags = SOCK_STREAM | SOCK_CLOEXEC;
231 unsafe { socket(af, flags, 0) }
232 }
233
wrap_bind(socket_fd: i32, addr: &UdsAddr) -> Result<()>234 pub fn wrap_bind(socket_fd: i32, addr: &UdsAddr) -> Result<()> {
235 unsafe {
236 let (addr_raw, len_raw) = addr.as_raw_general();
237 loop {
238 let ret = bind(socket_fd, addr_raw, len_raw);
239 println!("bind ret : {}", ret);
240 if ret != -1 {
241 break Ok(());
242 }
243 let err = io::Error::last_os_error();
244 if err.kind() != ErrorKind::Interrupted {
245 break Err(err);
246 }
247 }
248 }
249 }
250
wrap_listen(socket_fd: i32) -> c_int251 pub fn wrap_listen(socket_fd: i32) -> c_int {
252 unsafe { listen(socket_fd, LISTEN_BACKLOG) }
253 }
254
wrap_connect(socket_fd: i32, addr: &UdsAddr) -> Result<()>255 pub fn wrap_connect(socket_fd: i32, addr: &UdsAddr) -> Result<()> {
256 unsafe {
257 let (addr_raw, len_raw) = addr.as_raw_general();
258 println!("wrap_connect:len_raw: {:#?}", len_raw);
259 println!("wrap_connect:addr_raw: {:#?}", addr_raw.sa_data);
260 loop {
261 let ret = connect(socket_fd, addr_raw, len_raw);
262 println!("connect ret ++++++---->: {}", ret);
263 if ret != -1 {
264 break Ok(());
265 }
266 let err = io::Error::last_os_error();
267 if err.kind() != ErrorKind::Interrupted {
268 break Err(err);
269 }
270 }
271 }
272 }
273
wrap_recv(socket_fd: i32, buffer: &mut [u8]) -> isize274 pub fn wrap_recv(socket_fd: i32, buffer: &mut [u8]) -> isize {
275 let ptr = buffer.as_ptr() as *mut c_void;
276 unsafe { recv(socket_fd, ptr, buffer.len(), MSG_NOSIGNAL) }
277 }
278
wrap_read(socket_fd: i32, buffer: &mut [u8]) -> isize279 pub fn wrap_read(socket_fd: i32, buffer: &mut [u8]) -> isize {
280 let ptr = buffer.as_ptr() as *mut c_void;
281 unsafe { read(socket_fd, ptr, buffer.len()) }
282 }
283
wrap_write(socket_fd: i32, buffer: &[u8]) -> isize284 pub fn wrap_write(socket_fd: i32, buffer: &[u8]) -> isize {
285 let ptr = buffer.as_ptr() as *const c_void;
286 unsafe { write(socket_fd, ptr, buffer.len()) }
287 }
288
wrap_send(socket_fd: i32, buffer: &[u8]) -> isize289 pub fn wrap_send(socket_fd: i32, buffer: &[u8]) -> isize {
290 let ptr = buffer.as_ptr() as *const c_void;
291 let flags = MSG_NOSIGNAL | MSG_EOR;
292 unsafe { send(socket_fd, ptr, buffer.len(), flags) }
293 }
294 }
295