1cde5492fSlogin use core::cmp::min; 2cde5492fSlogin 3cde5492fSlogin use alloc::{boxed::Box, sync::Arc}; 4cde5492fSlogin use num_traits::{FromPrimitive, ToPrimitive}; 5cde5492fSlogin use smoltcp::wire; 6cde5492fSlogin 7cde5492fSlogin use crate::{ 8cde5492fSlogin arch::asm::current::current_pcb, 9cde5492fSlogin filesystem::vfs::{ 10cde5492fSlogin file::{File, FileMode}, 11cde5492fSlogin syscall::{IoVec, IoVecs}, 12cde5492fSlogin }, 13*ab5c8ca4Slogin include::bindings::bindings::verify_area, 14*ab5c8ca4Slogin libs::spinlock::SpinLockGuard, 15cde5492fSlogin net::socket::{AddressFamily, SOL_SOCKET}, 16*ab5c8ca4Slogin syscall::{Syscall, SystemError}, 17cde5492fSlogin }; 18cde5492fSlogin 19cde5492fSlogin use super::{ 20cde5492fSlogin socket::{PosixSocketType, RawSocket, SocketInode, SocketOptions, TcpSocket, UdpSocket}, 21cde5492fSlogin Endpoint, Protocol, ShutdownType, Socket, 22cde5492fSlogin }; 23cde5492fSlogin 24*ab5c8ca4Slogin impl Syscall { 25cde5492fSlogin /// @brief sys_socket系统调用的实际执行函数 26cde5492fSlogin /// 27cde5492fSlogin /// @param address_family 地址族 28cde5492fSlogin /// @param socket_type socket类型 29cde5492fSlogin /// @param protocol 传输协议 30*ab5c8ca4Slogin pub fn socket( 31cde5492fSlogin address_family: usize, 32cde5492fSlogin socket_type: usize, 33cde5492fSlogin protocol: usize, 34*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 35cde5492fSlogin let address_family = AddressFamily::try_from(address_family as u16)?; 36cde5492fSlogin let socket_type = PosixSocketType::try_from((socket_type & 0xf) as u8)?; 37cde5492fSlogin // kdebug!("do_socket: address_family: {address_family:?}, socket_type: {socket_type:?}, protocol: {protocol}"); 38cde5492fSlogin // 根据地址族和socket类型创建socket 39cde5492fSlogin let socket: Box<dyn Socket> = match address_family { 40cde5492fSlogin AddressFamily::Unix | AddressFamily::INet => match socket_type { 41cde5492fSlogin PosixSocketType::Stream => Box::new(TcpSocket::new(SocketOptions::default())), 42cde5492fSlogin PosixSocketType::Datagram => Box::new(UdpSocket::new(SocketOptions::default())), 43cde5492fSlogin PosixSocketType::Raw => Box::new(RawSocket::new( 44cde5492fSlogin Protocol::from(protocol as u8), 45cde5492fSlogin SocketOptions::default(), 46cde5492fSlogin )), 47cde5492fSlogin _ => { 48cde5492fSlogin // kdebug!("do_socket: EINVAL"); 49cde5492fSlogin return Err(SystemError::EINVAL); 50cde5492fSlogin } 51cde5492fSlogin }, 52cde5492fSlogin _ => { 53cde5492fSlogin // kdebug!("do_socket: EAFNOSUPPORT"); 54cde5492fSlogin return Err(SystemError::EAFNOSUPPORT); 55cde5492fSlogin } 56cde5492fSlogin }; 57cde5492fSlogin // kdebug!("do_socket: socket: {socket:?}"); 58cde5492fSlogin let socketinode: Arc<SocketInode> = SocketInode::new(socket); 59cde5492fSlogin let f = File::new(socketinode, FileMode::O_RDWR)?; 60cde5492fSlogin // kdebug!("do_socket: f: {f:?}"); 61cde5492fSlogin // 把socket添加到当前进程的文件描述符表中 62*ab5c8ca4Slogin let fd = current_pcb().alloc_fd(f, None).map(|x| x as usize); 63cde5492fSlogin // kdebug!("do_socket: fd: {fd:?}"); 64cde5492fSlogin return fd; 65cde5492fSlogin } 66cde5492fSlogin 67cde5492fSlogin /// @brief sys_setsockopt系统调用的实际执行函数 68cde5492fSlogin /// 69cde5492fSlogin /// @param fd 文件描述符 70cde5492fSlogin /// @param level 选项级别 71cde5492fSlogin /// @param optname 选项名称 72cde5492fSlogin /// @param optval 选项值 73cde5492fSlogin /// @param optlen optval缓冲区长度 74*ab5c8ca4Slogin pub fn setsockopt( 75cde5492fSlogin fd: usize, 76cde5492fSlogin level: usize, 77cde5492fSlogin optname: usize, 78*ab5c8ca4Slogin optval: &[u8], 79*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 80cde5492fSlogin let socket_inode: Arc<SocketInode> = current_pcb() 81cde5492fSlogin .get_socket(fd as i32) 82cde5492fSlogin .ok_or(SystemError::EBADF)?; 83cde5492fSlogin // 获取内层的socket(真正的数据) 84*ab5c8ca4Slogin let socket: SpinLockGuard<Box<dyn Socket>> = socket_inode.inner(); 85*ab5c8ca4Slogin return socket.setsockopt(level, optname, optval).map(|_| 0); 86cde5492fSlogin } 87cde5492fSlogin 88cde5492fSlogin /// @brief sys_getsockopt系统调用的实际执行函数 89cde5492fSlogin /// 90cde5492fSlogin /// 参考:https://man7.org/linux/man-pages/man2/setsockopt.2.html 91cde5492fSlogin /// 92cde5492fSlogin /// @param fd 文件描述符 93cde5492fSlogin /// @param level 选项级别 94cde5492fSlogin /// @param optname 选项名称 95cde5492fSlogin /// @param optval 返回的选项值 96cde5492fSlogin /// @param optlen 返回的optval缓冲区长度 97*ab5c8ca4Slogin pub fn getsockopt( 98cde5492fSlogin fd: usize, 99cde5492fSlogin level: usize, 100cde5492fSlogin optname: usize, 101cde5492fSlogin optval: *mut u8, 102cde5492fSlogin optlen: *mut u32, 103*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 104cde5492fSlogin // 获取socket 105cde5492fSlogin let optval = optval as *mut u32; 106cde5492fSlogin let binding: Arc<SocketInode> = current_pcb() 107cde5492fSlogin .get_socket(fd as i32) 108cde5492fSlogin .ok_or(SystemError::EBADF)?; 109cde5492fSlogin let socket = binding.inner(); 110cde5492fSlogin 111cde5492fSlogin if level as u8 == SOL_SOCKET { 112*ab5c8ca4Slogin let optname = PosixSocketOption::try_from(optname as i32) 113*ab5c8ca4Slogin .map_err(|_| SystemError::ENOPROTOOPT)?; 114cde5492fSlogin match optname { 115cde5492fSlogin PosixSocketOption::SO_SNDBUF => { 116cde5492fSlogin // 返回发送缓冲区大小 117cde5492fSlogin unsafe { 118cde5492fSlogin *optval = socket.metadata()?.send_buf_size as u32; 119cde5492fSlogin *optlen = core::mem::size_of::<u32>() as u32; 120cde5492fSlogin } 121cde5492fSlogin return Ok(0); 122cde5492fSlogin } 123cde5492fSlogin PosixSocketOption::SO_RCVBUF => { 124cde5492fSlogin let optval = optval as *mut u32; 125cde5492fSlogin // 返回默认的接收缓冲区大小 126cde5492fSlogin unsafe { 127cde5492fSlogin *optval = socket.metadata()?.recv_buf_size as u32; 128cde5492fSlogin *optlen = core::mem::size_of::<u32>() as u32; 129cde5492fSlogin } 130cde5492fSlogin return Ok(0); 131cde5492fSlogin } 132cde5492fSlogin _ => { 133cde5492fSlogin return Err(SystemError::ENOPROTOOPT); 134cde5492fSlogin } 135cde5492fSlogin } 136cde5492fSlogin } 137cde5492fSlogin drop(socket); 138cde5492fSlogin 139cde5492fSlogin // To manipulate options at any other level the 140cde5492fSlogin // protocol number of the appropriate protocol controlling the 141cde5492fSlogin // option is supplied. For example, to indicate that an option is 142cde5492fSlogin // to be interpreted by the TCP protocol, level should be set to the 143cde5492fSlogin // protocol number of TCP. 144cde5492fSlogin 145cde5492fSlogin let posix_protocol = 146cde5492fSlogin PosixIpProtocol::try_from(level as u16).map_err(|_| SystemError::ENOPROTOOPT)?; 147cde5492fSlogin if posix_protocol == PosixIpProtocol::TCP { 148cde5492fSlogin let optname = PosixTcpSocketOptions::try_from(optname as i32) 149cde5492fSlogin .map_err(|_| SystemError::ENOPROTOOPT)?; 150cde5492fSlogin match optname { 151cde5492fSlogin PosixTcpSocketOptions::Congestion => return Ok(0), 152cde5492fSlogin _ => { 153cde5492fSlogin return Err(SystemError::ENOPROTOOPT); 154cde5492fSlogin } 155cde5492fSlogin } 156cde5492fSlogin } 157cde5492fSlogin return Err(SystemError::ENOPROTOOPT); 158cde5492fSlogin } 159cde5492fSlogin 160cde5492fSlogin /// @brief sys_connect系统调用的实际执行函数 161cde5492fSlogin /// 162cde5492fSlogin /// @param fd 文件描述符 163cde5492fSlogin /// @param addr SockAddr 164cde5492fSlogin /// @param addrlen 地址长度 165cde5492fSlogin /// 166cde5492fSlogin /// @return 成功返回0,失败返回错误码 167*ab5c8ca4Slogin pub fn connect(fd: usize, addr: *const SockAddr, addrlen: usize) -> Result<usize, SystemError> { 168cde5492fSlogin let endpoint: Endpoint = SockAddr::to_endpoint(addr, addrlen)?; 169cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 170cde5492fSlogin .get_socket(fd as i32) 171cde5492fSlogin .ok_or(SystemError::EBADF)?; 172cde5492fSlogin let mut socket = socket.inner(); 173cde5492fSlogin // kdebug!("connect to {:?}...", endpoint); 174cde5492fSlogin socket.connect(endpoint)?; 175cde5492fSlogin return Ok(0); 176cde5492fSlogin } 177cde5492fSlogin 178cde5492fSlogin /// @brief sys_bind系统调用的实际执行函数 179cde5492fSlogin /// 180cde5492fSlogin /// @param fd 文件描述符 181cde5492fSlogin /// @param addr SockAddr 182cde5492fSlogin /// @param addrlen 地址长度 183cde5492fSlogin /// 184cde5492fSlogin /// @return 成功返回0,失败返回错误码 185*ab5c8ca4Slogin pub fn bind(fd: usize, addr: *const SockAddr, addrlen: usize) -> Result<usize, SystemError> { 186cde5492fSlogin let endpoint: Endpoint = SockAddr::to_endpoint(addr, addrlen)?; 187cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 188cde5492fSlogin .get_socket(fd as i32) 189cde5492fSlogin .ok_or(SystemError::EBADF)?; 190cde5492fSlogin let mut socket = socket.inner(); 191cde5492fSlogin socket.bind(endpoint)?; 192cde5492fSlogin return Ok(0); 193cde5492fSlogin } 194cde5492fSlogin 195cde5492fSlogin /// @brief sys_sendto系统调用的实际执行函数 196cde5492fSlogin /// 197cde5492fSlogin /// @param fd 文件描述符 198cde5492fSlogin /// @param buf 发送缓冲区 199cde5492fSlogin /// @param flags 标志 200cde5492fSlogin /// @param addr SockAddr 201cde5492fSlogin /// @param addrlen 地址长度 202cde5492fSlogin /// 203cde5492fSlogin /// @return 成功返回发送的字节数,失败返回错误码 204*ab5c8ca4Slogin pub fn sendto( 205cde5492fSlogin fd: usize, 206*ab5c8ca4Slogin buf: &[u8], 207*ab5c8ca4Slogin _flags: u32, 208cde5492fSlogin addr: *const SockAddr, 209cde5492fSlogin addrlen: usize, 210*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 211cde5492fSlogin let endpoint = if addr.is_null() { 212cde5492fSlogin None 213cde5492fSlogin } else { 214cde5492fSlogin Some(SockAddr::to_endpoint(addr, addrlen)?) 215cde5492fSlogin }; 216cde5492fSlogin 217cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 218cde5492fSlogin .get_socket(fd as i32) 219cde5492fSlogin .ok_or(SystemError::EBADF)?; 220cde5492fSlogin let socket = socket.inner(); 221*ab5c8ca4Slogin return socket.write(buf, endpoint); 222cde5492fSlogin } 223cde5492fSlogin 224cde5492fSlogin /// @brief sys_recvfrom系统调用的实际执行函数 225cde5492fSlogin /// 226cde5492fSlogin /// @param fd 文件描述符 227cde5492fSlogin /// @param buf 接收缓冲区 228cde5492fSlogin /// @param flags 标志 229cde5492fSlogin /// @param addr SockAddr 230cde5492fSlogin /// @param addrlen 地址长度 231cde5492fSlogin /// 232cde5492fSlogin /// @return 成功返回接收的字节数,失败返回错误码 233*ab5c8ca4Slogin pub fn recvfrom( 234cde5492fSlogin fd: usize, 235*ab5c8ca4Slogin buf: &mut [u8], 236*ab5c8ca4Slogin _flags: u32, 237cde5492fSlogin addr: *mut SockAddr, 238cde5492fSlogin addrlen: *mut u32, 239*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 240cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 241cde5492fSlogin .get_socket(fd as i32) 242cde5492fSlogin .ok_or(SystemError::EBADF)?; 243cde5492fSlogin let socket = socket.inner(); 244cde5492fSlogin 245cde5492fSlogin let (n, endpoint) = socket.read(buf); 246cde5492fSlogin drop(socket); 247cde5492fSlogin 248cde5492fSlogin let n: usize = n?; 249cde5492fSlogin 250cde5492fSlogin // 如果有地址信息,将地址信息写入用户空间 251cde5492fSlogin if !addr.is_null() { 252cde5492fSlogin let sockaddr_in = SockAddr::from(endpoint); 253cde5492fSlogin unsafe { 254cde5492fSlogin sockaddr_in.write_to_user(addr, addrlen)?; 255cde5492fSlogin } 256cde5492fSlogin } 257*ab5c8ca4Slogin return Ok(n); 258cde5492fSlogin } 259cde5492fSlogin 260cde5492fSlogin /// @brief sys_recvmsg系统调用的实际执行函数 261cde5492fSlogin /// 262cde5492fSlogin /// @param fd 文件描述符 263cde5492fSlogin /// @param msg MsgHdr 264*ab5c8ca4Slogin /// @param flags 标志,暂时未使用 265cde5492fSlogin /// 266cde5492fSlogin /// @return 成功返回接收的字节数,失败返回错误码 267*ab5c8ca4Slogin pub fn recvmsg(fd: usize, msg: &mut MsgHdr, _flags: u32) -> Result<usize, SystemError> { 268cde5492fSlogin // 检查每个缓冲区地址是否合法,生成iovecs 269cde5492fSlogin let mut iovs = unsafe { IoVecs::from_user(msg.msg_iov, msg.msg_iovlen, true)? }; 270cde5492fSlogin 271cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 272cde5492fSlogin .get_socket(fd as i32) 273cde5492fSlogin .ok_or(SystemError::EBADF)?; 274cde5492fSlogin let socket = socket.inner(); 275cde5492fSlogin 276cde5492fSlogin let mut buf = iovs.new_buf(true); 277cde5492fSlogin // 从socket中读取数据 278cde5492fSlogin let (n, endpoint) = socket.read(&mut buf); 279cde5492fSlogin drop(socket); 280cde5492fSlogin 281cde5492fSlogin let n: usize = n?; 282cde5492fSlogin 283cde5492fSlogin // 将数据写入用户空间的iovecs 284cde5492fSlogin iovs.scatter(&buf[..n]); 285cde5492fSlogin 286cde5492fSlogin let sockaddr_in = SockAddr::from(endpoint); 287cde5492fSlogin unsafe { 288cde5492fSlogin sockaddr_in.write_to_user(msg.msg_name, &mut msg.msg_namelen)?; 289cde5492fSlogin } 290*ab5c8ca4Slogin return Ok(n); 291cde5492fSlogin } 292cde5492fSlogin 293cde5492fSlogin /// @brief sys_listen系统调用的实际执行函数 294cde5492fSlogin /// 295cde5492fSlogin /// @param fd 文件描述符 296*ab5c8ca4Slogin /// @param backlog 队列最大连接数 297cde5492fSlogin /// 298cde5492fSlogin /// @return 成功返回0,失败返回错误码 299*ab5c8ca4Slogin pub fn listen(fd: usize, backlog: usize) -> Result<usize, SystemError> { 300cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 301cde5492fSlogin .get_socket(fd as i32) 302cde5492fSlogin .ok_or(SystemError::EBADF)?; 303cde5492fSlogin let mut socket = socket.inner(); 304cde5492fSlogin socket.listen(backlog)?; 305cde5492fSlogin return Ok(0); 306cde5492fSlogin } 307cde5492fSlogin 308cde5492fSlogin /// @brief sys_shutdown系统调用的实际执行函数 309cde5492fSlogin /// 310cde5492fSlogin /// @param fd 文件描述符 311cde5492fSlogin /// @param how 关闭方式 312cde5492fSlogin /// 313cde5492fSlogin /// @return 成功返回0,失败返回错误码 314*ab5c8ca4Slogin pub fn shutdown(fd: usize, how: usize) -> Result<usize, SystemError> { 315cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 316cde5492fSlogin .get_socket(fd as i32) 317cde5492fSlogin .ok_or(SystemError::EBADF)?; 318cde5492fSlogin let socket = socket.inner(); 319cde5492fSlogin socket.shutdown(ShutdownType::try_from(how as i32)?)?; 320cde5492fSlogin return Ok(0); 321cde5492fSlogin } 322cde5492fSlogin 323cde5492fSlogin /// @brief sys_accept系统调用的实际执行函数 324cde5492fSlogin /// 325cde5492fSlogin /// @param fd 文件描述符 326cde5492fSlogin /// @param addr SockAddr 327cde5492fSlogin /// @param addrlen 地址长度 328cde5492fSlogin /// 329cde5492fSlogin /// @return 成功返回新的文件描述符,失败返回错误码 330*ab5c8ca4Slogin pub fn accept(fd: usize, addr: *mut SockAddr, addrlen: *mut u32) -> Result<usize, SystemError> { 331cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 332cde5492fSlogin .get_socket(fd as i32) 333cde5492fSlogin .ok_or(SystemError::EBADF)?; 334cde5492fSlogin // kdebug!("accept: socket={:?}", socket); 335cde5492fSlogin let mut socket = socket.inner(); 336cde5492fSlogin // 从socket中接收连接 337cde5492fSlogin let (new_socket, remote_endpoint) = socket.accept()?; 338cde5492fSlogin drop(socket); 339cde5492fSlogin 340cde5492fSlogin // kdebug!("accept: new_socket={:?}", new_socket); 341cde5492fSlogin // Insert the new socket into the file descriptor vector 342cde5492fSlogin let new_socket: Arc<SocketInode> = SocketInode::new(new_socket); 343cde5492fSlogin let new_fd = current_pcb().alloc_fd(File::new(new_socket, FileMode::O_RDWR)?, None)?; 344cde5492fSlogin // kdebug!("accept: new_fd={}", new_fd); 345cde5492fSlogin if !addr.is_null() { 346cde5492fSlogin // kdebug!("accept: write remote_endpoint to user"); 347cde5492fSlogin // 将对端地址写入用户空间 348cde5492fSlogin let sockaddr_in = SockAddr::from(remote_endpoint); 349cde5492fSlogin unsafe { 350cde5492fSlogin sockaddr_in.write_to_user(addr, addrlen)?; 351cde5492fSlogin } 352cde5492fSlogin } 353*ab5c8ca4Slogin return Ok(new_fd as usize); 354cde5492fSlogin } 355cde5492fSlogin 356cde5492fSlogin /// @brief sys_getsockname系统调用的实际执行函数 357cde5492fSlogin /// 358cde5492fSlogin /// Returns the current address to which the socket 359cde5492fSlogin /// sockfd is bound, in the buffer pointed to by addr. 360cde5492fSlogin /// 361cde5492fSlogin /// @param fd 文件描述符 362cde5492fSlogin /// @param addr SockAddr 363cde5492fSlogin /// @param addrlen 地址长度 364cde5492fSlogin /// 365cde5492fSlogin /// @return 成功返回0,失败返回错误码 366*ab5c8ca4Slogin pub fn getsockname( 367cde5492fSlogin fd: usize, 368cde5492fSlogin addr: *mut SockAddr, 369cde5492fSlogin addrlen: *mut u32, 370*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 371cde5492fSlogin if addr.is_null() { 372cde5492fSlogin return Err(SystemError::EINVAL); 373cde5492fSlogin } 374cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 375cde5492fSlogin .get_socket(fd as i32) 376cde5492fSlogin .ok_or(SystemError::EBADF)?; 377cde5492fSlogin let socket = socket.inner(); 378cde5492fSlogin let endpoint: Endpoint = socket.endpoint().ok_or(SystemError::EINVAL)?; 379cde5492fSlogin drop(socket); 380cde5492fSlogin 381cde5492fSlogin let sockaddr_in = SockAddr::from(endpoint); 382cde5492fSlogin unsafe { 383cde5492fSlogin sockaddr_in.write_to_user(addr, addrlen)?; 384cde5492fSlogin } 385cde5492fSlogin return Ok(0); 386cde5492fSlogin } 387cde5492fSlogin 388cde5492fSlogin /// @brief sys_getpeername系统调用的实际执行函数 389cde5492fSlogin /// 390cde5492fSlogin /// @param fd 文件描述符 391cde5492fSlogin /// @param addr SockAddr 392cde5492fSlogin /// @param addrlen 地址长度 393cde5492fSlogin /// 394cde5492fSlogin /// @return 成功返回0,失败返回错误码 395*ab5c8ca4Slogin pub fn getpeername( 396cde5492fSlogin fd: usize, 397cde5492fSlogin addr: *mut SockAddr, 398cde5492fSlogin addrlen: *mut u32, 399*ab5c8ca4Slogin ) -> Result<usize, SystemError> { 400cde5492fSlogin if addr.is_null() { 401cde5492fSlogin return Err(SystemError::EINVAL); 402cde5492fSlogin } 403cde5492fSlogin 404cde5492fSlogin let socket: Arc<SocketInode> = current_pcb() 405cde5492fSlogin .get_socket(fd as i32) 406cde5492fSlogin .ok_or(SystemError::EBADF)?; 407cde5492fSlogin let socket = socket.inner(); 408cde5492fSlogin let endpoint: Endpoint = socket.peer_endpoint().ok_or(SystemError::EINVAL)?; 409cde5492fSlogin drop(socket); 410cde5492fSlogin 411cde5492fSlogin let sockaddr_in = SockAddr::from(endpoint); 412cde5492fSlogin unsafe { 413cde5492fSlogin sockaddr_in.write_to_user(addr, addrlen)?; 414cde5492fSlogin } 415cde5492fSlogin return Ok(0); 416cde5492fSlogin } 417*ab5c8ca4Slogin } 418cde5492fSlogin 419cde5492fSlogin // 参考资料: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/netinet_in.h.html#tag_13_32 420cde5492fSlogin #[repr(C)] 421cde5492fSlogin #[derive(Debug, Clone, Copy)] 422cde5492fSlogin pub struct SockAddrIn { 423cde5492fSlogin pub sin_family: u16, 424cde5492fSlogin pub sin_port: u16, 425cde5492fSlogin pub sin_addr: u32, 426cde5492fSlogin pub sin_zero: [u8; 8], 427cde5492fSlogin } 428cde5492fSlogin 429cde5492fSlogin #[repr(C)] 430cde5492fSlogin #[derive(Debug, Clone, Copy)] 431cde5492fSlogin pub struct SockAddrUn { 432cde5492fSlogin pub sun_family: u16, 433cde5492fSlogin pub sun_path: [u8; 108], 434cde5492fSlogin } 435cde5492fSlogin 436cde5492fSlogin #[repr(C)] 437cde5492fSlogin #[derive(Debug, Clone, Copy)] 438cde5492fSlogin pub struct SockAddrLl { 439cde5492fSlogin pub sll_family: u16, 440cde5492fSlogin pub sll_protocol: u16, 441cde5492fSlogin pub sll_ifindex: u32, 442cde5492fSlogin pub sll_hatype: u16, 443cde5492fSlogin pub sll_pkttype: u8, 444cde5492fSlogin pub sll_halen: u8, 445cde5492fSlogin pub sll_addr: [u8; 8], 446cde5492fSlogin } 447cde5492fSlogin 448cde5492fSlogin #[repr(C)] 449cde5492fSlogin #[derive(Debug, Clone, Copy)] 450cde5492fSlogin pub struct SockAddrNl { 451cde5492fSlogin nl_family: u16, 452cde5492fSlogin nl_pad: u16, 453cde5492fSlogin nl_pid: u32, 454cde5492fSlogin nl_groups: u32, 455cde5492fSlogin } 456cde5492fSlogin 457cde5492fSlogin #[repr(C)] 458cde5492fSlogin #[derive(Debug, Clone, Copy)] 459cde5492fSlogin pub struct SockAddrPlaceholder { 460cde5492fSlogin pub family: u16, 461cde5492fSlogin pub data: [u8; 14], 462cde5492fSlogin } 463cde5492fSlogin 464cde5492fSlogin #[repr(C)] 465cde5492fSlogin #[derive(Clone, Copy)] 466cde5492fSlogin pub union SockAddr { 467cde5492fSlogin pub family: u16, 468cde5492fSlogin pub addr_in: SockAddrIn, 469cde5492fSlogin pub addr_un: SockAddrUn, 470cde5492fSlogin pub addr_ll: SockAddrLl, 471cde5492fSlogin pub addr_nl: SockAddrNl, 472cde5492fSlogin pub addr_ph: SockAddrPlaceholder, 473cde5492fSlogin } 474cde5492fSlogin 475cde5492fSlogin impl SockAddr { 476cde5492fSlogin /// @brief 把用户传入的SockAddr转换为Endpoint结构体 477cde5492fSlogin pub fn to_endpoint(addr: *const SockAddr, len: usize) -> Result<Endpoint, SystemError> { 478cde5492fSlogin if unsafe { 479cde5492fSlogin verify_area( 480cde5492fSlogin addr as usize as u64, 481cde5492fSlogin core::mem::size_of::<SockAddr>() as u64, 482cde5492fSlogin ) 483cde5492fSlogin } == false 484cde5492fSlogin { 485cde5492fSlogin return Err(SystemError::EFAULT); 486cde5492fSlogin } 487cde5492fSlogin 488cde5492fSlogin let addr = unsafe { addr.as_ref() }.ok_or(SystemError::EFAULT)?; 489cde5492fSlogin if len < addr.len()? { 490cde5492fSlogin return Err(SystemError::EINVAL); 491cde5492fSlogin } 492cde5492fSlogin unsafe { 493cde5492fSlogin match AddressFamily::try_from(addr.family)? { 494cde5492fSlogin AddressFamily::INet => { 495cde5492fSlogin let addr_in: SockAddrIn = addr.addr_in; 496cde5492fSlogin 497cde5492fSlogin let ip: wire::IpAddress = wire::IpAddress::from(wire::Ipv4Address::from_bytes( 498cde5492fSlogin &u32::from_be(addr_in.sin_addr).to_be_bytes()[..], 499cde5492fSlogin )); 500cde5492fSlogin let port = u16::from_be(addr_in.sin_port); 501cde5492fSlogin 502cde5492fSlogin return Ok(Endpoint::Ip(Some(wire::IpEndpoint::new(ip, port)))); 503cde5492fSlogin } 504cde5492fSlogin AddressFamily::Packet => { 505cde5492fSlogin // TODO: support packet socket 506cde5492fSlogin return Err(SystemError::EINVAL); 507cde5492fSlogin } 508cde5492fSlogin AddressFamily::Netlink => { 509cde5492fSlogin // TODO: support netlink socket 510cde5492fSlogin return Err(SystemError::EINVAL); 511cde5492fSlogin } 512cde5492fSlogin AddressFamily::Unix => { 513cde5492fSlogin return Err(SystemError::EINVAL); 514cde5492fSlogin } 515cde5492fSlogin _ => { 516cde5492fSlogin return Err(SystemError::EINVAL); 517cde5492fSlogin } 518cde5492fSlogin } 519cde5492fSlogin } 520cde5492fSlogin } 521cde5492fSlogin 522cde5492fSlogin /// @brief 获取地址长度 523cde5492fSlogin pub fn len(&self) -> Result<usize, SystemError> { 524cde5492fSlogin let ret = match AddressFamily::try_from(unsafe { self.family })? { 525cde5492fSlogin AddressFamily::INet => Ok(core::mem::size_of::<SockAddrIn>()), 526cde5492fSlogin AddressFamily::Packet => Ok(core::mem::size_of::<SockAddrLl>()), 527cde5492fSlogin AddressFamily::Netlink => Ok(core::mem::size_of::<SockAddrNl>()), 528cde5492fSlogin AddressFamily::Unix => Err(SystemError::EINVAL), 529cde5492fSlogin _ => Err(SystemError::EINVAL), 530cde5492fSlogin }; 531cde5492fSlogin 532cde5492fSlogin return ret; 533cde5492fSlogin } 534cde5492fSlogin 535cde5492fSlogin /// @brief 把SockAddr的数据写入用户空间 536cde5492fSlogin /// 537cde5492fSlogin /// @param addr 用户空间的SockAddr的地址 538cde5492fSlogin /// @param len 要写入的长度 539cde5492fSlogin /// 540cde5492fSlogin /// @return 成功返回写入的长度,失败返回错误码 541cde5492fSlogin pub unsafe fn write_to_user( 542cde5492fSlogin &self, 543cde5492fSlogin addr: *mut SockAddr, 544cde5492fSlogin addr_len: *mut u32, 545cde5492fSlogin ) -> Result<usize, SystemError> { 546cde5492fSlogin // 当用户传入的地址或者长度为空时,直接返回0 547cde5492fSlogin if addr.is_null() || addr_len.is_null() { 548cde5492fSlogin return Ok(0); 549cde5492fSlogin } 550cde5492fSlogin // 检查用户传入的地址是否合法 551cde5492fSlogin if !verify_area( 552cde5492fSlogin addr as usize as u64, 553cde5492fSlogin core::mem::size_of::<SockAddr>() as u64, 554cde5492fSlogin ) || !verify_area(addr_len as usize as u64, core::mem::size_of::<u32>() as u64) 555cde5492fSlogin { 556cde5492fSlogin return Err(SystemError::EFAULT); 557cde5492fSlogin } 558cde5492fSlogin 559cde5492fSlogin let to_write = min(self.len()?, *addr_len as usize); 560cde5492fSlogin if to_write > 0 { 561cde5492fSlogin let buf = core::slice::from_raw_parts_mut(addr as *mut u8, to_write); 562cde5492fSlogin buf.copy_from_slice(core::slice::from_raw_parts( 563cde5492fSlogin self as *const SockAddr as *const u8, 564cde5492fSlogin to_write, 565cde5492fSlogin )); 566cde5492fSlogin } 567cde5492fSlogin *addr_len = self.len()? as u32; 568cde5492fSlogin return Ok(to_write); 569cde5492fSlogin } 570cde5492fSlogin } 571cde5492fSlogin 572cde5492fSlogin impl From<Endpoint> for SockAddr { 573cde5492fSlogin fn from(value: Endpoint) -> Self { 574cde5492fSlogin match value { 575cde5492fSlogin Endpoint::Ip(ip_endpoint) => { 576cde5492fSlogin // 未指定地址 577cde5492fSlogin if let None = ip_endpoint { 578cde5492fSlogin return SockAddr { 579cde5492fSlogin addr_ph: SockAddrPlaceholder { 580cde5492fSlogin family: AddressFamily::Unspecified as u16, 581cde5492fSlogin data: [0; 14], 582cde5492fSlogin }, 583cde5492fSlogin }; 584cde5492fSlogin } 585cde5492fSlogin // 指定了地址 586cde5492fSlogin let ip_endpoint = ip_endpoint.unwrap(); 587cde5492fSlogin match ip_endpoint.addr { 588cde5492fSlogin wire::IpAddress::Ipv4(ipv4_addr) => { 589cde5492fSlogin let addr_in = SockAddrIn { 590cde5492fSlogin sin_family: AddressFamily::INet as u16, 591cde5492fSlogin sin_port: ip_endpoint.port.to_be(), 592cde5492fSlogin sin_addr: u32::from_be_bytes(ipv4_addr.0).to_be(), 593cde5492fSlogin sin_zero: [0; 8], 594cde5492fSlogin }; 595cde5492fSlogin 596cde5492fSlogin return SockAddr { addr_in }; 597cde5492fSlogin } 598cde5492fSlogin _ => { 599cde5492fSlogin unimplemented!("not support ipv6"); 600cde5492fSlogin } 601cde5492fSlogin } 602cde5492fSlogin } 603cde5492fSlogin 604cde5492fSlogin Endpoint::LinkLayer(link_endpoint) => { 605cde5492fSlogin let addr_ll = SockAddrLl { 606cde5492fSlogin sll_family: AddressFamily::Packet as u16, 607cde5492fSlogin sll_protocol: 0, 608cde5492fSlogin sll_ifindex: link_endpoint.interface as u32, 609cde5492fSlogin sll_hatype: 0, 610cde5492fSlogin sll_pkttype: 0, 611cde5492fSlogin sll_halen: 0, 612cde5492fSlogin sll_addr: [0; 8], 613cde5492fSlogin }; 614cde5492fSlogin 615cde5492fSlogin return SockAddr { addr_ll }; 616cde5492fSlogin } // _ => { 617cde5492fSlogin // // todo: support other endpoint, like Netlink... 618cde5492fSlogin // unimplemented!("not support {value:?}"); 619cde5492fSlogin // } 620cde5492fSlogin } 621cde5492fSlogin } 622cde5492fSlogin } 623cde5492fSlogin 624cde5492fSlogin #[repr(C)] 625cde5492fSlogin #[derive(Debug, Clone, Copy)] 626cde5492fSlogin pub struct MsgHdr { 627cde5492fSlogin /// 指向一个SockAddr结构体的指针 628cde5492fSlogin pub msg_name: *mut SockAddr, 629cde5492fSlogin /// SockAddr结构体的大小 630cde5492fSlogin pub msg_namelen: u32, 631cde5492fSlogin /// scatter/gather array 632cde5492fSlogin pub msg_iov: *mut IoVec, 633cde5492fSlogin /// elements in msg_iov 634cde5492fSlogin pub msg_iovlen: usize, 635cde5492fSlogin /// 辅助数据 636cde5492fSlogin pub msg_control: *mut u8, 637cde5492fSlogin /// 辅助数据长度 638cde5492fSlogin pub msg_controllen: usize, 639cde5492fSlogin /// 接收到的消息的标志 640cde5492fSlogin pub msg_flags: u32, 641cde5492fSlogin } 642cde5492fSlogin 643cde5492fSlogin #[derive(Debug, Clone, Copy, FromPrimitive, ToPrimitive, PartialEq, Eq)] 644cde5492fSlogin pub enum PosixIpProtocol { 645cde5492fSlogin /// Dummy protocol for TCP. 646cde5492fSlogin IP = 0, 647cde5492fSlogin /// Internet Control Message Protocol. 648cde5492fSlogin ICMP = 1, 649cde5492fSlogin /// Internet Group Management Protocol. 650cde5492fSlogin IGMP = 2, 651cde5492fSlogin /// IPIP tunnels (older KA9Q tunnels use 94). 652cde5492fSlogin IPIP = 4, 653cde5492fSlogin /// Transmission Control Protocol. 654cde5492fSlogin TCP = 6, 655cde5492fSlogin /// Exterior Gateway Protocol. 656cde5492fSlogin EGP = 8, 657cde5492fSlogin /// PUP protocol. 658cde5492fSlogin PUP = 12, 659cde5492fSlogin /// User Datagram Protocol. 660cde5492fSlogin UDP = 17, 661cde5492fSlogin /// XNS IDP protocol. 662cde5492fSlogin IDP = 22, 663cde5492fSlogin /// SO Transport Protocol Class 4. 664cde5492fSlogin TP = 29, 665cde5492fSlogin /// Datagram Congestion Control Protocol. 666cde5492fSlogin DCCP = 33, 667cde5492fSlogin /// IPv6-in-IPv4 tunnelling. 668cde5492fSlogin IPv6 = 41, 669cde5492fSlogin /// RSVP Protocol. 670cde5492fSlogin RSVP = 46, 671cde5492fSlogin /// Generic Routing Encapsulation. (Cisco GRE) (rfc 1701, 1702) 672cde5492fSlogin GRE = 47, 673cde5492fSlogin /// Encapsulation Security Payload protocol 674cde5492fSlogin ESP = 50, 675cde5492fSlogin /// Authentication Header protocol 676cde5492fSlogin AH = 51, 677cde5492fSlogin /// Multicast Transport Protocol. 678cde5492fSlogin MTP = 92, 679cde5492fSlogin /// IP option pseudo header for BEET 680cde5492fSlogin BEETPH = 94, 681cde5492fSlogin /// Encapsulation Header. 682cde5492fSlogin ENCAP = 98, 683cde5492fSlogin /// Protocol Independent Multicast. 684cde5492fSlogin PIM = 103, 685cde5492fSlogin /// Compression Header Protocol. 686cde5492fSlogin COMP = 108, 687cde5492fSlogin /// Stream Control Transport Protocol 688cde5492fSlogin SCTP = 132, 689cde5492fSlogin /// UDP-Lite protocol (RFC 3828) 690cde5492fSlogin UDPLITE = 136, 691cde5492fSlogin /// MPLS in IP (RFC 4023) 692cde5492fSlogin MPLSINIP = 137, 693cde5492fSlogin /// Ethernet-within-IPv6 Encapsulation 694cde5492fSlogin ETHERNET = 143, 695cde5492fSlogin /// Raw IP packets 696cde5492fSlogin RAW = 255, 697cde5492fSlogin /// Multipath TCP connection 698cde5492fSlogin MPTCP = 262, 699cde5492fSlogin } 700cde5492fSlogin 701cde5492fSlogin impl TryFrom<u16> for PosixIpProtocol { 702cde5492fSlogin type Error = SystemError; 703cde5492fSlogin 704cde5492fSlogin fn try_from(value: u16) -> Result<Self, Self::Error> { 705cde5492fSlogin match <Self as FromPrimitive>::from_u16(value) { 706cde5492fSlogin Some(p) => Ok(p), 707cde5492fSlogin None => Err(SystemError::EPROTONOSUPPORT), 708cde5492fSlogin } 709cde5492fSlogin } 710cde5492fSlogin } 711cde5492fSlogin 712cde5492fSlogin impl Into<u16> for PosixIpProtocol { 713cde5492fSlogin fn into(self) -> u16 { 714cde5492fSlogin <Self as ToPrimitive>::to_u16(&self).unwrap() 715cde5492fSlogin } 716cde5492fSlogin } 717cde5492fSlogin 718cde5492fSlogin #[allow(non_camel_case_types)] 719cde5492fSlogin #[derive(Debug, Clone, Copy, FromPrimitive, ToPrimitive, PartialEq, Eq)] 720cde5492fSlogin pub enum PosixSocketOption { 721cde5492fSlogin SO_DEBUG = 1, 722cde5492fSlogin SO_REUSEADDR = 2, 723cde5492fSlogin SO_TYPE = 3, 724cde5492fSlogin SO_ERROR = 4, 725cde5492fSlogin SO_DONTROUTE = 5, 726cde5492fSlogin SO_BROADCAST = 6, 727cde5492fSlogin SO_SNDBUF = 7, 728cde5492fSlogin SO_RCVBUF = 8, 729cde5492fSlogin SO_SNDBUFFORCE = 32, 730cde5492fSlogin SO_RCVBUFFORCE = 33, 731cde5492fSlogin SO_KEEPALIVE = 9, 732cde5492fSlogin SO_OOBINLINE = 10, 733cde5492fSlogin SO_NO_CHECK = 11, 734cde5492fSlogin SO_PRIORITY = 12, 735cde5492fSlogin SO_LINGER = 13, 736cde5492fSlogin SO_BSDCOMPAT = 14, 737cde5492fSlogin SO_REUSEPORT = 15, 738cde5492fSlogin SO_PASSCRED = 16, 739cde5492fSlogin SO_PEERCRED = 17, 740cde5492fSlogin SO_RCVLOWAT = 18, 741cde5492fSlogin SO_SNDLOWAT = 19, 742cde5492fSlogin SO_RCVTIMEO_OLD = 20, 743cde5492fSlogin SO_SNDTIMEO_OLD = 21, 744cde5492fSlogin 745cde5492fSlogin SO_SECURITY_AUTHENTICATION = 22, 746cde5492fSlogin SO_SECURITY_ENCRYPTION_TRANSPORT = 23, 747cde5492fSlogin SO_SECURITY_ENCRYPTION_NETWORK = 24, 748cde5492fSlogin 749cde5492fSlogin SO_BINDTODEVICE = 25, 750cde5492fSlogin 751cde5492fSlogin /// 与SO_GET_FILTER相同 752cde5492fSlogin SO_ATTACH_FILTER = 26, 753cde5492fSlogin SO_DETACH_FILTER = 27, 754cde5492fSlogin 755cde5492fSlogin SO_PEERNAME = 28, 756cde5492fSlogin 757cde5492fSlogin SO_ACCEPTCONN = 30, 758cde5492fSlogin 759cde5492fSlogin SO_PEERSEC = 31, 760cde5492fSlogin SO_PASSSEC = 34, 761cde5492fSlogin 762cde5492fSlogin SO_MARK = 36, 763cde5492fSlogin 764cde5492fSlogin SO_PROTOCOL = 38, 765cde5492fSlogin SO_DOMAIN = 39, 766cde5492fSlogin 767cde5492fSlogin SO_RXQ_OVFL = 40, 768cde5492fSlogin 769cde5492fSlogin /// 与SCM_WIFI_STATUS相同 770cde5492fSlogin SO_WIFI_STATUS = 41, 771cde5492fSlogin SO_PEEK_OFF = 42, 772cde5492fSlogin 773cde5492fSlogin /* Instruct lower device to use last 4-bytes of skb data as FCS */ 774cde5492fSlogin SO_NOFCS = 43, 775cde5492fSlogin 776cde5492fSlogin SO_LOCK_FILTER = 44, 777cde5492fSlogin SO_SELECT_ERR_QUEUE = 45, 778cde5492fSlogin SO_BUSY_POLL = 46, 779cde5492fSlogin SO_MAX_PACING_RATE = 47, 780cde5492fSlogin SO_BPF_EXTENSIONS = 48, 781cde5492fSlogin SO_INCOMING_CPU = 49, 782cde5492fSlogin SO_ATTACH_BPF = 50, 783cde5492fSlogin // SO_DETACH_BPF = SO_DETACH_FILTER, 784cde5492fSlogin SO_ATTACH_REUSEPORT_CBPF = 51, 785cde5492fSlogin SO_ATTACH_REUSEPORT_EBPF = 52, 786cde5492fSlogin 787cde5492fSlogin SO_CNX_ADVICE = 53, 788cde5492fSlogin SCM_TIMESTAMPING_OPT_STATS = 54, 789cde5492fSlogin SO_MEMINFO = 55, 790cde5492fSlogin SO_INCOMING_NAPI_ID = 56, 791cde5492fSlogin SO_COOKIE = 57, 792cde5492fSlogin SCM_TIMESTAMPING_PKTINFO = 58, 793cde5492fSlogin SO_PEERGROUPS = 59, 794cde5492fSlogin SO_ZEROCOPY = 60, 795cde5492fSlogin /// 与SCM_TXTIME相同 796cde5492fSlogin SO_TXTIME = 61, 797cde5492fSlogin 798cde5492fSlogin SO_BINDTOIFINDEX = 62, 799cde5492fSlogin 800cde5492fSlogin SO_TIMESTAMP_OLD = 29, 801cde5492fSlogin SO_TIMESTAMPNS_OLD = 35, 802cde5492fSlogin SO_TIMESTAMPING_OLD = 37, 803cde5492fSlogin SO_TIMESTAMP_NEW = 63, 804cde5492fSlogin SO_TIMESTAMPNS_NEW = 64, 805cde5492fSlogin SO_TIMESTAMPING_NEW = 65, 806cde5492fSlogin 807cde5492fSlogin SO_RCVTIMEO_NEW = 66, 808cde5492fSlogin SO_SNDTIMEO_NEW = 67, 809cde5492fSlogin 810cde5492fSlogin SO_DETACH_REUSEPORT_BPF = 68, 811cde5492fSlogin 812cde5492fSlogin SO_PREFER_BUSY_POLL = 69, 813cde5492fSlogin SO_BUSY_POLL_BUDGET = 70, 814cde5492fSlogin 815cde5492fSlogin SO_NETNS_COOKIE = 71, 816cde5492fSlogin SO_BUF_LOCK = 72, 817cde5492fSlogin SO_RESERVE_MEM = 73, 818cde5492fSlogin SO_TXREHASH = 74, 819cde5492fSlogin SO_RCVMARK = 75, 820cde5492fSlogin } 821cde5492fSlogin 822cde5492fSlogin impl TryFrom<i32> for PosixSocketOption { 823cde5492fSlogin type Error = SystemError; 824cde5492fSlogin 825cde5492fSlogin fn try_from(value: i32) -> Result<Self, Self::Error> { 826cde5492fSlogin match <Self as FromPrimitive>::from_i32(value) { 827cde5492fSlogin Some(p) => Ok(p), 828cde5492fSlogin None => Err(SystemError::EINVAL), 829cde5492fSlogin } 830cde5492fSlogin } 831cde5492fSlogin } 832cde5492fSlogin 833cde5492fSlogin impl Into<i32> for PosixSocketOption { 834cde5492fSlogin fn into(self) -> i32 { 835cde5492fSlogin <Self as ToPrimitive>::to_i32(&self).unwrap() 836cde5492fSlogin } 837cde5492fSlogin } 838cde5492fSlogin 839cde5492fSlogin #[derive(Debug, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive)] 840cde5492fSlogin pub enum PosixTcpSocketOptions { 841cde5492fSlogin /// Turn off Nagle's algorithm. 842cde5492fSlogin NoDelay = 1, 843cde5492fSlogin /// Limit MSS. 844cde5492fSlogin MaxSegment = 2, 845cde5492fSlogin /// Never send partially complete segments. 846cde5492fSlogin Cork = 3, 847cde5492fSlogin /// Start keeplives after this period. 848cde5492fSlogin KeepIdle = 4, 849cde5492fSlogin /// Interval between keepalives. 850cde5492fSlogin KeepIntvl = 5, 851cde5492fSlogin /// Number of keepalives before death. 852cde5492fSlogin KeepCnt = 6, 853cde5492fSlogin /// Number of SYN retransmits. 854cde5492fSlogin Syncnt = 7, 855cde5492fSlogin /// Lifetime for orphaned FIN-WAIT-2 state. 856cde5492fSlogin Linger2 = 8, 857cde5492fSlogin /// Wake up listener only when data arrive. 858cde5492fSlogin DeferAccept = 9, 859cde5492fSlogin /// Bound advertised window 860cde5492fSlogin WindowClamp = 10, 861cde5492fSlogin /// Information about this connection. 862cde5492fSlogin Info = 11, 863cde5492fSlogin /// Block/reenable quick acks. 864cde5492fSlogin QuickAck = 12, 865cde5492fSlogin /// Congestion control algorithm. 866cde5492fSlogin Congestion = 13, 867cde5492fSlogin /// TCP MD5 Signature (RFC2385). 868cde5492fSlogin Md5Sig = 14, 869cde5492fSlogin /// Use linear timeouts for thin streams 870cde5492fSlogin ThinLinearTimeouts = 16, 871cde5492fSlogin /// Fast retrans. after 1 dupack. 872cde5492fSlogin ThinDupack = 17, 873cde5492fSlogin /// How long for loss retry before timeout. 874cde5492fSlogin UserTimeout = 18, 875cde5492fSlogin /// TCP sock is under repair right now. 876cde5492fSlogin Repair = 19, 877cde5492fSlogin RepairQueue = 20, 878cde5492fSlogin QueueSeq = 21, 879cde5492fSlogin RepairOptions = 22, 880cde5492fSlogin /// Enable FastOpen on listeners 881cde5492fSlogin FastOpen = 23, 882cde5492fSlogin Timestamp = 24, 883cde5492fSlogin /// Limit number of unsent bytes in write queue. 884cde5492fSlogin NotSentLowat = 25, 885cde5492fSlogin /// Get Congestion Control (optional) info. 886cde5492fSlogin CCInfo = 26, 887cde5492fSlogin /// Record SYN headers for new connections. 888cde5492fSlogin SaveSyn = 27, 889cde5492fSlogin /// Get SYN headers recorded for connection. 890cde5492fSlogin SavedSyn = 28, 891cde5492fSlogin /// Get/set window parameters. 892cde5492fSlogin RepairWindow = 29, 893cde5492fSlogin /// Attempt FastOpen with connect. 894cde5492fSlogin FastOpenConnect = 30, 895cde5492fSlogin /// Attach a ULP to a TCP connection. 896cde5492fSlogin ULP = 31, 897cde5492fSlogin /// TCP MD5 Signature with extensions. 898cde5492fSlogin Md5SigExt = 32, 899cde5492fSlogin /// Set the key for Fast Open(cookie). 900cde5492fSlogin FastOpenKey = 33, 901cde5492fSlogin /// Enable TFO without a TFO cookie. 902cde5492fSlogin FastOpenNoCookie = 34, 903cde5492fSlogin ZeroCopyReceive = 35, 904cde5492fSlogin /// Notify bytes available to read as a cmsg on read. 905cde5492fSlogin /// 与TCP_CM_INQ相同 906cde5492fSlogin INQ = 36, 907cde5492fSlogin /// delay outgoing packets by XX usec 908cde5492fSlogin TxDelay = 37, 909cde5492fSlogin } 910cde5492fSlogin 911cde5492fSlogin impl TryFrom<i32> for PosixTcpSocketOptions { 912cde5492fSlogin type Error = SystemError; 913cde5492fSlogin 914cde5492fSlogin fn try_from(value: i32) -> Result<Self, Self::Error> { 915cde5492fSlogin match <Self as FromPrimitive>::from_i32(value) { 916cde5492fSlogin Some(p) => Ok(p), 917cde5492fSlogin None => Err(SystemError::EINVAL), 918cde5492fSlogin } 919cde5492fSlogin } 920cde5492fSlogin } 921cde5492fSlogin 922cde5492fSlogin impl Into<i32> for PosixTcpSocketOptions { 923cde5492fSlogin fn into(self) -> i32 { 924cde5492fSlogin <Self as ToPrimitive>::to_i32(&self).unwrap() 925cde5492fSlogin } 926cde5492fSlogin } 927