DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-18 08:06:32 +00:00
Code Issues Releases Wiki Activity

regulate naming to posix

Browse Source
This commit is contained in:
Samuka007
2024-10-17 06:28:53 +00:00
parent b9f27f44e4
commit ddad6b11a1
21 changed files with 108 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
kernel/src/net/socket/base.rs
View File

@ -60,7 +60,7 @@ pub trait Socket: Sync + Send + Debug + Any {
/// 对应于 Posix `getsockopt` ，获取socket选项
fn get_option(
&self,
level: OptionLevel,
level: PSOL,
name: usize,
value: &mut [u8],
) -> Result<usize, SystemError> {
@ -76,40 +76,40 @@ pub trait Socket: Sync + Send + Debug + Any {
// pselect
/// # `read`
fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
self.recv(buffer, MessageFlag::empty())
self.recv(buffer, PMSG::empty())
}
/// # `recv`
/// 接收数据，`read` = `recv` with flags = 0
fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
Err(ENOSYS)
}
/// # `recv_from`
fn recv_from(
&self,
buffer: &mut [u8],
flags: MessageFlag,
flags: PMSG,
address: Option<Endpoint>,
) -> Result<(usize, Endpoint), SystemError> {
Err(ENOSYS)
}
/// # `recv_msg`
fn recv_msg(&self, msg: &mut MsgHdr, flags: MessageFlag) -> Result<usize, SystemError> {
fn recv_msg(&self, msg: &mut MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
Err(ENOSYS)
}
// select
/// # `send`
fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
Err(ENOSYS)
}
/// # `send_msg`
fn send_msg(&self, msg: &MsgHdr, flags: MessageFlag) -> Result<usize, SystemError> {
fn send_msg(&self, msg: &MsgHdr, flags: PMSG) -> Result<usize, SystemError> {
Err(ENOSYS)
}
/// # `send_to`
fn send_to(
&self,
buffer: &[u8],
flags: MessageFlag,
flags: PMSG,
address: Endpoint,
) -> Result<usize, SystemError> {
Err(ENOSYS)
@ -122,7 +122,7 @@ pub trait Socket: Sync + Send + Debug + Any {
/// - value 选项的值
/// ## Reference
/// https://code.dragonos.org.cn/s?refs=sk_setsockopt&project=linux-6.6.21
fn set_option(&self, level: OptionLevel, name: usize, val: &[u8]) -> Result<(), SystemError> {
fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> {
log::warn!("setsockopt is not implemented");
Ok(())
}
@ -135,7 +135,7 @@ pub trait Socket: Sync + Send + Debug + Any {
// socketpair
/// # `write`
fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
self.send(buffer, MessageFlag::empty())
self.send(buffer, PMSG::empty())
}
// fn write_buffer(&self, _buf: &[u8]) -> Result<usize, SystemError> {
// todo!()

10
kernel/src/net/socket/definition/mod.rs
View File

@ -1,10 +0,0 @@
// socket definitions
mod msg_flag;
mod option;
mod option_level;
mod types;
pub use msg_flag::MessageFlag; // Socket message flags MSG_*
pub use option::Options; // Socket options SO_*
pub use option_level::OptionLevel; // Socket options level SOL_*
pub use types::Type; // Socket types SOCK_*

2
kernel/src/net/socket/family.rs
View File

@ -117,5 +117,5 @@ use crate::net::socket;
use alloc::sync::Arc;
pub trait Family {
fn socket(stype: socket::Type, protocol: u32) -> Result<Arc<socket::Inode>, SystemError>;
fn socket(stype: socket::PSOCK, protocol: u32) -> Result<Arc<socket::Inode>, SystemError>;
}

16
kernel/src/net/socket/inet/datagram/mod.rs
View File

@ -207,8 +207,8 @@ impl Socket for UdpSocket {
return Err(EAFNOSUPPORT);
}
fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
if flags.contains(MessageFlag::DONTWAIT) {
fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
if flags.contains(PMSG::DONTWAIT) {
log::warn!("Nonblock send is not implemented yet");
}
@ -218,10 +218,10 @@ impl Socket for UdpSocket {
fn send_to(
&self,
buffer: &[u8],
flags: MessageFlag,
flags: PMSG,
address: Endpoint,
) -> Result<usize, SystemError> {
if flags.contains(MessageFlag::DONTWAIT) {
if flags.contains(PMSG::DONTWAIT) {
log::warn!("Nonblock send is not implemented yet");
}
@ -232,10 +232,10 @@ impl Socket for UdpSocket {
return Err(EINVAL);
}
fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
use crate::sched::SchedMode;
return if self.is_nonblock() || flags.contains(MessageFlag::DONTWAIT) {
return if self.is_nonblock() || flags.contains(PMSG::DONTWAIT) {
self.try_recv(buffer)
} else {
loop {
@ -253,7 +253,7 @@ impl Socket for UdpSocket {
fn recv_from(
&self,
buffer: &mut [u8],
flags: MessageFlag,
flags: PMSG,
address: Option<Endpoint>,
) -> Result<(usize, Endpoint), SystemError> {
use crate::sched::SchedMode;
@ -262,7 +262,7 @@ impl Socket for UdpSocket {
self.connect(endpoint)?;
}
return if self.is_nonblock() || flags.contains(MessageFlag::DONTWAIT) {
return if self.is_nonblock() || flags.contains(PMSG::DONTWAIT) {
self.try_recv(buffer)
} else {
loop {

0
kernel/src/net/socket/inet/definition/option.rs → kernel/src/net/socket/inet/posix/option.rs
View File

0
kernel/src/net/socket/inet/definition/proto.rs → kernel/src/net/socket/inet/posix/proto.rs
View File

4
kernel/src/net/socket/inet/stream/mod.rs
View File

@ -278,11 +278,11 @@ impl Socket for TcpSocket {
.map(|(inner, endpoint)| (Inode::new(inner), Endpoint::Ip(endpoint)))
}
fn recv(&self, buffer: &mut [u8], _flags: MessageFlag) -> Result<usize, SystemError> {
fn recv(&self, buffer: &mut [u8], _flags: PMSG) -> Result<usize, SystemError> {
self.try_recv(buffer)
}
fn send(&self, buffer: &[u8], _flags: MessageFlag) -> Result<usize, SystemError> {
fn send(&self, buffer: &[u8], _flags: PMSG) -> Result<usize, SystemError> {
self.try_send(buffer)
}

11
kernel/src/net/socket/inet/syscall.rs
View File

@ -8,14 +8,13 @@ use inet::{TcpSocket, UdpSocket};
use crate::net::socket::*;
fn create_inet_socket(
socket_type: Type,
socket_type: PSOCK,
protocol: smoltcp::wire::IpProtocol,
) -> Result<Arc<dyn Socket>, SystemError> {
// log::debug!("type: {:?}, protocol: {:?}", socket_type, protocol);
use smoltcp::wire::IpProtocol::*;
use Type::*;
match socket_type {
Datagram => {
PSOCK::Datagram => {
match protocol {
HopByHop | Udp => {
return Ok(UdpSocket::new(false));
@ -29,7 +28,7 @@ fn create_inet_socket(
// }
// return Ok(UdpSocket::new(false));
}
Stream => match protocol {
PSOCK::Stream => match protocol {
HopByHop | Tcp => {
return Ok(TcpSocket::new(false));
}
@ -37,7 +36,7 @@ fn create_inet_socket(
return Err(EPROTONOSUPPORT);
}
},
Raw => {
PSOCK::Raw => {
todo!("raw")
}
_ => {
@ -48,7 +47,7 @@ fn create_inet_socket(
pub struct Inet;
impl family::Family for Inet {
fn socket(stype: Type, protocol: u32) -> Result<Arc<Inode>, SystemError> {
fn socket(stype: PSOCK, protocol: u32) -> Result<Arc<Inode>, SystemError> {
let socket = create_inet_socket(stype, smoltcp::wire::IpProtocol::from(protocol as u8))?;
Ok(Inode::new(socket))
}

12
kernel/src/net/socket/inode.rs
View File

@ -101,7 +101,7 @@ impl Inode {
pub fn set_option(
&self,
level: OptionLevel,
level: PSOL,
name: usize,
value: &[u8],
) -> Result<(), SystemError> {
@ -110,7 +110,7 @@ impl Inode {
pub fn get_option(
&self,
level: OptionLevel,
level: PSOL,
name: usize,
value: &mut [u8],
) -> Result<usize, SystemError> {
@ -125,16 +125,16 @@ impl Inode {
&self,
buffer: &[u8],
address: Endpoint,
flags: MessageFlag,
flags: PMSG,
) -> Result<usize, SystemError> {
self.inner.send_to(buffer, flags, address)
}
pub fn send(&self, buffer: &[u8], flags: MessageFlag) -> Result<usize, SystemError> {
pub fn send(&self, buffer: &[u8], flags: PMSG) -> Result<usize, SystemError> {
self.inner.send(buffer, flags)
}
pub fn recv(&self, buffer: &mut [u8], flags: MessageFlag) -> Result<usize, SystemError> {
pub fn recv(&self, buffer: &mut [u8], flags: PMSG) -> Result<usize, SystemError> {
self.inner.recv(buffer, flags)
}
@ -142,7 +142,7 @@ impl Inode {
pub fn recv_from(
&self,
buffer: &mut [u8],
flags: MessageFlag,
flags: PMSG,
address: Option<Endpoint>,
) -> Result<(usize, Endpoint), SystemError> {
self.inner.recv_from(buffer, flags, address)

4
kernel/src/net/socket/mod.rs
View File

@ -1,7 +1,7 @@
mod base;
mod buffer;
mod common;
mod definition;
mod posix;
mod endpoint;
mod family;
pub mod inet;
@ -17,7 +17,7 @@ pub use common::{
// poll_unit::{EPollItems, WaitQueue},
EPollItems,
};
pub use definition::*;
pub use posix::*;
pub use endpoint::*;
pub use family::{AddressFamily, Family};
pub use inode::Inode;

12
kernel/src/net/socket/posix/mod.rs Normal file
View File

@ -0,0 +1,12 @@
// posix socket and arguments definitions
// now all posix definitions are with P front like MSG -> PMSG,
// for better understanding and avoiding conflicts with other definitions
mod msg_flag;
mod option;
mod option_level;
mod types;
pub use msg_flag::MessageFlag as PMSG; // Socket message flags MSG_*
pub use option::Options as PSO; // Socket options SO_*
pub use option_level::OptionLevel as PSOL; // Socket options level SOL_*
pub use types::Type as PSOCK; // Socket types SOCK_*

0
kernel/src/net/socket/definition/msg_flag.rs → kernel/src/net/socket/posix/msg_flag.rs
View File

0
kernel/src/net/socket/definition/option.rs → kernel/src/net/socket/posix/option.rs
View File

0
kernel/src/net/socket/definition/option_level.rs → kernel/src/net/socket/posix/option_level.rs
View File

6
kernel/src/net/socket/definition/types.rs → kernel/src/net/socket/posix/types.rs
View File

@ -9,10 +9,10 @@ pub enum Type {
Packet = 10,
}
use crate::net::syscall_util::SysArgSocketType;
impl TryFrom<SysArgSocketType> for Type {
use crate::net::syscall_util::PosixArgsSocketType;
impl TryFrom<PosixArgsSocketType> for Type {
type Error = system_error::SystemError;
fn try_from(x: SysArgSocketType) -> Result<Self, Self::Error> {
fn try_from(x: PosixArgsSocketType) -> Result<Self, Self::Error> {
use num_traits::FromPrimitive;
return <Self as FromPrimitive>::from_u32(x.types().bits())
.ok_or(system_error::SystemError::EINVAL);

14
kernel/src/net/socket/unix/mod.rs
View File

@ -10,27 +10,27 @@ lazy_static! {
pub static ref INODE_MAP: RwLock<HashMap<InodeId, Endpoint>> = RwLock::new(HashMap::new());
}
fn create_unix_socket(sock_type: Type) -> Result<Arc<Inode>, SystemError> {
fn create_unix_socket(sock_type: PSOCK) -> Result<Arc<Inode>, SystemError> {
match sock_type {
Type::Stream | Type::Datagram => stream::StreamSocket::new_inode(),
Type::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_inode(),
PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_inode(false),
_ => Err(EPROTONOSUPPORT),
}
}
impl family::Family for Unix {
fn socket(stype: Type, _protocol: u32) -> Result<Arc<Inode>, SystemError> {
fn socket(stype: PSOCK, _protocol: u32) -> Result<Arc<Inode>, SystemError> {
let socket = create_unix_socket(stype)?;
Ok(socket)
}
}
impl Unix {
pub fn new_pairs(socket_type: Type) -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
pub fn new_pairs(socket_type: PSOCK) -> Result<(Arc<Inode>, Arc<Inode>), SystemError> {
// log::debug!("socket_type {:?}", socket_type);
match socket_type {
Type::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(),
Type::Stream | Type::Datagram => stream::StreamSocket::new_pairs(),
PSOCK::SeqPacket => seqpacket::SeqpacketSocket::new_pairs(),
PSOCK::Stream | PSOCK::Datagram => stream::StreamSocket::new_pairs(),
_ => todo!(),
}
}

30
kernel/src/net/socket/unix/seqpacket/mod.rs
View File

@ -244,7 +244,7 @@ impl Socket for SeqpacketSocket {
fn set_option(
&self,
_level: crate::net::socket::OptionLevel,
_level: crate::net::socket::PSOL,
_optname: usize,
_optval: &[u8],
) -> Result<(), SystemError> {
@ -294,7 +294,7 @@ impl Socket for SeqpacketSocket {
fn get_option(
&self,
_level: crate::net::socket::OptionLevel,
_level: crate::net::socket::PSOL,
_name: usize,
_value: &mut [u8],
) -> Result<usize, SystemError> {
@ -303,18 +303,18 @@ impl Socket for SeqpacketSocket {
}
fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
self.recv(buffer, crate::net::socket::MessageFlag::empty())
self.recv(buffer, crate::net::socket::PMSG::empty())
}
fn recv(
&self,
buffer: &mut [u8],
flags: crate::net::socket::MessageFlag,
flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> {
if flags.contains(MessageFlag::OOB) {
if flags.contains(PMSG::OOB) {
return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
}
if !flags.contains(MessageFlag::DONTWAIT) {
if !flags.contains(PMSG::DONTWAIT) {
loop {
wq_wait_event_interruptible!(
self.wait_queue,
@ -344,7 +344,7 @@ impl Socket for SeqpacketSocket {
fn recv_msg(
&self,
_msg: &mut crate::net::syscall::MsgHdr,
_flags: crate::net::socket::MessageFlag,
_flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS)
}
@ -352,15 +352,15 @@ impl Socket for SeqpacketSocket {
fn send(
&self,
buffer: &[u8],
flags: crate::net::socket::MessageFlag,
flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> {
if flags.contains(MessageFlag::OOB) {
if flags.contains(PMSG::OOB) {
return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
}
if self.is_peer_shutdown()? {
return Err(SystemError::EPIPE);
}
if !flags.contains(MessageFlag::DONTWAIT) {
if !flags.contains(PMSG::DONTWAIT) {
loop {
match &*self.inner.write() {
Inner::Connected(connected) => match connected.try_write(buffer) {
@ -384,26 +384,26 @@ impl Socket for SeqpacketSocket {
fn send_msg(
&self,
_msg: &crate::net::syscall::MsgHdr,
_flags: crate::net::socket::MessageFlag,
_flags: crate::net::socket::PMSG,
) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS)
}
fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
self.send(buffer, crate::net::socket::MessageFlag::empty())
self.send(buffer, crate::net::socket::PMSG::empty())
}
fn recv_from(
&self,
buffer: &mut [u8],
flags: MessageFlag,
flags: PMSG,
_address: Option<Endpoint>,
) -> Result<(usize, Endpoint), SystemError> {
// log::debug!("recvfrom flags {:?}", flags);
if flags.contains(MessageFlag::OOB) {
if flags.contains(PMSG::OOB) {
return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
}
if !flags.contains(MessageFlag::DONTWAIT) {
if !flags.contains(PMSG::DONTWAIT) {
loop {
wq_wait_event_interruptible!(
self.wait_queue,

28
kernel/src/net/socket/unix/stream/mod.rs
View File

@ -243,7 +243,7 @@ impl Socket for StreamSocket {
fn set_option(
&self,
_level: OptionLevel,
_level: PSOL,
_optname: usize,
_optval: &[u8],
) -> Result<(), SystemError> {
@ -329,7 +329,7 @@ impl Socket for StreamSocket {
fn get_option(
&self,
_level: OptionLevel,
_level: PSOL,
_name: usize,
_value: &mut [u8],
) -> Result<usize, SystemError> {
@ -338,11 +338,11 @@ impl Socket for StreamSocket {
}
fn read(&self, buffer: &mut [u8]) -> Result<usize, SystemError> {
self.recv(buffer, socket::MessageFlag::empty())
self.recv(buffer, socket::PMSG::empty())
}
fn recv(&self, buffer: &mut [u8], flags: socket::MessageFlag) -> Result<usize, SystemError> {
if !flags.contains(MessageFlag::DONTWAIT) {
fn recv(&self, buffer: &mut [u8], flags: socket::PMSG) -> Result<usize, SystemError> {
if !flags.contains(PMSG::DONTWAIT) {
loop {
log::debug!("socket try recv");
wq_wait_event_interruptible!(
@ -373,13 +373,13 @@ impl Socket for StreamSocket {
fn recv_from(
&self,
buffer: &mut [u8],
flags: socket::MessageFlag,
flags: socket::PMSG,
_address: Option<Endpoint>,
) -> Result<(usize, Endpoint), SystemError> {
if flags.contains(MessageFlag::OOB) {
if flags.contains(PMSG::OOB) {
return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
}
if !flags.contains(MessageFlag::DONTWAIT) {
if !flags.contains(PMSG::DONTWAIT) {
loop {
log::debug!("socket try recv from");
@ -413,16 +413,16 @@ impl Socket for StreamSocket {
fn recv_msg(
&self,
_msg: &mut crate::net::syscall::MsgHdr,
_flags: socket::MessageFlag,
_flags: socket::PMSG,
) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS)
}
fn send(&self, buffer: &[u8], flags: socket::MessageFlag) -> Result<usize, SystemError> {
fn send(&self, buffer: &[u8], flags: socket::PMSG) -> Result<usize, SystemError> {
if self.is_peer_shutdown()? {
return Err(SystemError::EPIPE);
}
if !flags.contains(MessageFlag::DONTWAIT) {
if !flags.contains(PMSG::DONTWAIT) {
loop {
match &*self.inner.write() {
Inner::Connected(connected) => match connected.try_send(buffer) {
@ -446,7 +446,7 @@ impl Socket for StreamSocket {
fn send_msg(
&self,
_msg: &crate::net::syscall::MsgHdr,
_flags: socket::MessageFlag,
_flags: socket::PMSG,
) -> Result<usize, SystemError> {
todo!()
}
@ -454,14 +454,14 @@ impl Socket for StreamSocket {
fn send_to(
&self,
_buffer: &[u8],
_flags: socket::MessageFlag,
_flags: socket::PMSG,
_address: Endpoint,
) -> Result<usize, SystemError> {
Err(SystemError::ENOSYS)
}
fn write(&self, buffer: &[u8]) -> Result<usize, SystemError> {
self.send(buffer, socket::MessageFlag::empty())
self.send(buffer, socket::PMSG::empty())
}
fn send_buffer_size(&self) -> usize {

2
kernel/src/net/socket/utils.rs
View File

@ -5,7 +5,7 @@ use system_error::SystemError;
pub fn create_socket(
family: socket::AddressFamily,
socket_type: socket::Type,
socket_type: socket::PSOCK,
protocol: u32,
is_nonblock: bool,
is_close_on_exec: bool,

32
kernel/src/net/syscall.rs
View File

@ -35,10 +35,10 @@ impl Syscall {
// protocol
// );
let address_family = socket::AddressFamily::try_from(address_family as u16)?;
let type_arg = SysArgSocketType::from_bits_truncate(socket_type as u32);
let type_arg = PosixArgsSocketType::from_bits_truncate(socket_type as u32);
let is_nonblock = type_arg.is_nonblock();
let is_close_on_exec = type_arg.is_cloexec();
let stype = socket::Type::try_from(type_arg)?;
let stype = socket::PSOCK::try_from(type_arg)?;
// log::debug!("type_arg {:?} stype {:?}", type_arg, stype);
let inode = socket::create_socket(
@ -73,8 +73,8 @@ impl Syscall {
fds: &mut [i32],
) -> Result<usize, SystemError> {
let address_family = AF::try_from(address_family as u16)?;
let socket_type = SysArgSocketType::from_bits_truncate(socket_type as u32);
let stype = socket::Type::try_from(socket_type)?;
let socket_type = PosixArgsSocketType::from_bits_truncate(socket_type as u32);
let stype = socket::PSOCK::try_from(socket_type)?;
let binding = ProcessManager::current_pcb().fd_table();
let mut fd_table_guard = binding.write();
@ -112,7 +112,7 @@ impl Syscall {
optname: usize,
optval: &[u8],
) -> Result<usize, SystemError> {
let sol = socket::OptionLevel::try_from(level as u32)?;
let sol = socket::PSOL::try_from(level as u32)?;
let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
.get_socket(fd as i32)
.ok_or(SystemError::EBADF)?;
@ -142,14 +142,14 @@ impl Syscall {
.get_socket(fd as i32)
.ok_or(EBADF)?;
let level = socket::OptionLevel::try_from(level as u32)?;
use socket::{PSOL, PSO};
use socket::OptionLevel as SOL;
use socket::Options as SO;
if matches!(level, SOL::SOCKET) {
let optname = SO::try_from(optname as u32).map_err(|_| ENOPROTOOPT)?;
let level = PSOL::try_from(level as u32)?;
if matches!(level, PSOL::SOCKET) {
let optname = PSO::try_from(optname as u32).map_err(|_| ENOPROTOOPT)?;
match optname {
SO::SNDBUF => {
PSO::SNDBUF => {
// 返回发送缓冲区大小
unsafe {
*optval = socket.send_buffer_size() as u32;
@ -157,7 +157,7 @@ impl Syscall {
}
return Ok(0);
}
SO::RCVBUF => {
PSO::RCVBUF => {
// 返回默认的接收缓冲区大小
unsafe {
*optval = socket.recv_buffer_size() as u32;
@ -178,7 +178,7 @@ impl Syscall {
// to be interpreted by the TCP protocol, level should be set to the
// protocol number of TCP.
if matches!(level, SOL::TCP) {
if matches!(level, PSOL::TCP) {
use socket::inet::stream::TcpOption;
let optname = TcpOption::try_from(optname as i32).map_err(|_| ENOPROTOOPT)?;
match optname {
@ -253,7 +253,7 @@ impl Syscall {
Some(SockAddr::to_endpoint(addr, addrlen)?)
};
let flags = socket::MessageFlag::from_bits_truncate(flags);
let flags = socket::PMSG::from_bits_truncate(flags);
let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
.get_socket(fd as i32)
@ -285,7 +285,7 @@ impl Syscall {
let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
.get_socket(fd as i32)
.ok_or(SystemError::EBADF)?;
let flags = socket::MessageFlag::from_bits_truncate(flags);
let flags = socket::PMSG::from_bits_truncate(flags);
if addr.is_null() {
let (n, _) = socket.recv_from(buf, flags, None)?;
@ -327,7 +327,7 @@ impl Syscall {
// .get_socket(fd as i32)
// .ok_or(SystemError::EBADF)?;
// let flags = socket::MessageFlag::from_bits_truncate(flags as u32);
// let flags = socket::PMSG::from_bits_truncate(flags as u32);
// let mut buf = iovs.new_buf(true);
// // 从socket中读取数据

12
kernel/src/net/syscall_util.rs
View File

@ -1,6 +1,6 @@
bitflags::bitflags! {
// #[derive(PartialEq, Eq, Debug, Clone, Copy)]
pub struct SysArgSocketType: u32 {
pub struct PosixArgsSocketType: u32 {
const DGRAM = 1; // 0b0000_0001
const STREAM = 2; // 0b0000_0010
const RAW = 3; // 0b0000_0011
@ -14,20 +14,20 @@ bitflags::bitflags! {
}
}
impl SysArgSocketType {
impl PosixArgsSocketType {
#[inline(always)]
pub fn types(&self) -> SysArgSocketType {
SysArgSocketType::from_bits(self.bits() & 0b_1111).unwrap()
pub fn types(&self) -> PosixArgsSocketType {
PosixArgsSocketType::from_bits(self.bits() & 0b_1111).unwrap()
}
#[inline(always)]
pub fn is_nonblock(&self) -> bool {
self.contains(SysArgSocketType::NONBLOCK)
self.contains(PosixArgsSocketType::NONBLOCK)
}
#[inline(always)]
pub fn is_cloexec(&self) -> bool {
self.contains(SysArgSocketType::CLOEXEC)
self.contains(PosixArgsSocketType::CLOEXEC)
}
}