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