qiurui
/
asterinas
mirror of https://github.com/asterinas/asterinas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rustfmt socket option macros

This commit is contained in:
Ruihan Li 2025-12-03 13:12:48 +08:00 committed by Jianfeng Jiang
parent 34ebccb2e9
commit 2168b32d88
11 changed files with 204 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
kernel/src/net/socket/ip/datagram/mod.rs
View File

@ -10,13 +10,12 @@ use super::addr::UNSPECIFIED_LOCAL_ENDPOINT;
use crate::{
events::IoEvents,
fs::utils::Inode,
match_sock_option_mut,
net::{
iface::is_broadcast_endpoint,
socket::{
ip::options::{IpOptionSet, SetIpLevelOption},
new_pseudo_inode,
options::{Error as SocketError, SocketOption},
options::{macros::sock_option_mut, Error as SocketError, SocketOption},
private::SocketPrivate,
util::{
datagram_common::{select_remote_and_bind, Bound, Inner},
@ -241,13 +240,13 @@ impl Socket for DatagramSocket {
}
fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
socket_errors: SocketError => {
sock_option_mut!(match option {
socket_errors @ SocketError => {
// TODO: Support socket errors for UDP sockets
socket_errors.set(None);
return Ok(());
},
_ => ()
}
_ => (),
});
let inner = self.inner.read();

50
kernel/src/net/socket/ip/options.rs
View File

@ -5,8 +5,11 @@ use core::num::NonZeroU8;
use aster_bigtcp::socket::NeedIfacePoll;
use crate::{
impl_socket_options, match_sock_option_mut, match_sock_option_ref,
net::socket::options::SocketOption, prelude::*,
net::socket::options::{
macros::{impl_socket_options, sock_option_mut, sock_option_ref},
SocketOption,
},
prelude::*,
};
/// IP-level socket options.
@ -43,24 +46,24 @@ impl IpOptionSet {
}
pub(super) fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
ip_tos: Tos => {
sock_option_mut!(match option {
ip_tos @ Tos => {
let tos = self.tos();
ip_tos.set(tos as _);
},
ip_ttl: Ttl => {
}
ip_ttl @ Ttl => {
let ttl = self.ttl();
ip_ttl.set(ttl);
},
ip_hdrincl: Hdrincl => {
}
ip_hdrincl @ Hdrincl => {
let hdrincl = self.hdrincl();
ip_hdrincl.set(hdrincl);
},
ip_recverr: Recverr => {
}
ip_recverr @ Recverr => {
let recverr = self.recverr();
ip_recverr.set(recverr);
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option is unknown")
}
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option is unknown"),
});
Ok(())
@ -71,28 +74,31 @@ impl IpOptionSet {
option: &dyn SocketOption,
socket: &dyn SetIpLevelOption,
) -> Result<NeedIfacePoll> {
match_sock_option_ref!(option, {
ip_tos: Tos => {
sock_option_ref!(match option {
ip_tos @ Tos => {
let old_value = self.tos();
let mut val = *ip_tos.get().unwrap() as u8;
val &= !INET_ECN_MASK;
val |= old_value & INET_ECN_MASK;
self.set_tos(val);
},
ip_ttl: Ttl => {
}
ip_ttl @ Ttl => {
let ttl = ip_ttl.get().unwrap();
self.set_ttl(*ttl);
},
ip_hdrincl: Hdrincl => {
}
ip_hdrincl @ Hdrincl => {
let hdrincl = ip_hdrincl.get().unwrap();
socket.set_hdrincl(*hdrincl)?;
self.set_hdrincl(*hdrincl);
},
ip_recverr: Recverr => {
}
ip_recverr @ Recverr => {
let recverr = ip_recverr.get().unwrap();
self.set_recverr(*recverr);
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
}
_ => return_errno_with_message!(
Errno::ENOPROTOOPT,
"the socket option to be set is unknown"
),
});
Ok(NeedIfacePoll::FALSE)

107
kernel/src/net/socket/ip/stream/mod.rs
View File

@ -26,12 +26,14 @@ use super::{
use crate::{
events::IoEvents,
fs::{file_handle::FileLike, utils::Inode},
match_sock_option_mut, match_sock_option_ref,
net::{
iface::Iface,
socket::{
new_pseudo_inode,
options::{Error as SocketError, SocketOption},
options::{
macros::{sock_option_mut, sock_option_ref},
Error as SocketError, SocketOption,
},
private::SocketPrivate,
util::{
options::{GetSocketLevelOption, SetSocketLevelOption, SocketOptionSet},
@ -588,12 +590,12 @@ impl Socket for StreamSocket {
}
fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
socket_errors: SocketError => {
sock_option_mut!(match option {
socket_errors @ SocketError => {
socket_errors.set(self.test_and_clear_error());
return Ok(());
},
_ => ()
}
_ => (),
});
let state = self.read_updated_state();
@ -614,12 +616,12 @@ impl Socket for StreamSocket {
// Deal with TCP-level options
// FIXME: Here we only return the previously set values, without actually
// asking the underlying sockets for the real, effective values.
match_sock_option_mut!(option, {
tcp_no_delay: NoDelay => {
sock_option_mut!(match option {
tcp_no_delay @ NoDelay => {
let no_delay = options.tcp.no_delay();
tcp_no_delay.set(no_delay);
},
tcp_maxseg: MaxSegment => {
}
tcp_maxseg @ MaxSegment => {
const DEFAULT_MAX_SEGMEMT: u32 = 536;
// For an unconnected socket,
// older Linux versions (e.g., v6.0) return
@ -633,37 +635,40 @@ impl Socket for StreamSocket {
} else {
tcp_maxseg.set(maxseg);
}
},
tcp_keep_idle: KeepIdle => {
}
tcp_keep_idle @ KeepIdle => {
let keep_idle = options.tcp.keep_idle();
tcp_keep_idle.set(keep_idle);
},
tcp_syn_cnt: SynCnt => {
}
tcp_syn_cnt @ SynCnt => {
let syn_cnt = options.tcp.syn_cnt();
tcp_syn_cnt.set(syn_cnt);
},
tcp_defer_accept: DeferAccept => {
}
tcp_defer_accept @ DeferAccept => {
let defer_accept = options.tcp.defer_accept();
let seconds = defer_accept.to_secs();
tcp_defer_accept.set(seconds);
},
tcp_window_clamp: WindowClamp => {
}
tcp_window_clamp @ WindowClamp => {
let window_clamp = options.tcp.window_clamp();
tcp_window_clamp.set(window_clamp);
},
tcp_congestion: Congestion => {
}
tcp_congestion @ Congestion => {
let congestion = options.tcp.congestion();
tcp_congestion.set(congestion);
},
tcp_user_timeout: UserTimeout => {
}
tcp_user_timeout @ UserTimeout => {
let user_timeout = options.tcp.user_timeout();
tcp_user_timeout.set(user_timeout);
},
tcp_inq: Inq => {
}
tcp_inq @ Inq => {
let inq = options.tcp.receive_inq();
tcp_inq.set(inq);
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to get is unknown")
}
_ => return_errno_with_message!(
Errno::ENOPROTOOPT,
"the socket option to get is unknown"
),
});
Ok(())
@ -712,23 +717,28 @@ fn do_tcp_setsockopt(
options: &mut OptionSet,
state: &mut State,
) -> Result<NeedIfacePoll> {
match_sock_option_ref!(option, {
tcp_no_delay: NoDelay => {
sock_option_ref!(match option {
tcp_no_delay @ NoDelay => {
let no_delay = tcp_no_delay.get().unwrap();
options.tcp.set_no_delay(*no_delay);
state.set_raw_option(|raw_socket: &dyn RawTcpSetOption| raw_socket.set_nagle_enabled(!no_delay));
},
tcp_maxseg: MaxSegment => {
state.set_raw_option(|raw_socket: &dyn RawTcpSetOption| {
raw_socket.set_nagle_enabled(!no_delay)
});
}
tcp_maxseg @ MaxSegment => {
const MIN_MAXSEG: u32 = 536;
const MAX_MAXSEG: u32 = 65535;
let maxseg = tcp_maxseg.get().unwrap();
if *maxseg < MIN_MAXSEG || *maxseg > MAX_MAXSEG {
return_errno_with_message!(Errno::EINVAL, "the maximum segment size is out of bounds");
return_errno_with_message!(
Errno::EINVAL,
"the maximum segment size is out of bounds"
);
}
options.tcp.set_maxseg(*maxseg);
},
tcp_keep_idle: KeepIdle => {
}
tcp_keep_idle @ KeepIdle => {
const MIN_KEEP_IDLE: u32 = 1;
const MAX_KEEP_IDLE: u32 = 32767;
@ -739,8 +749,8 @@ fn do_tcp_setsockopt(
options.tcp.set_keep_idle(*keepidle);
// TODO: Track when the socket becomes idle to actually support keep idle.
},
tcp_syn_cnt: SynCnt => {
}
tcp_syn_cnt @ SynCnt => {
const MAX_TCP_SYN_CNT: u8 = 127;
let syncnt = tcp_syn_cnt.get().unwrap();
@ -748,16 +758,16 @@ fn do_tcp_setsockopt(
return_errno_with_message!(Errno::EINVAL, "the SYN count is out of bounds");
}
options.tcp.set_syn_cnt(*syncnt);
},
tcp_defer_accept: DeferAccept => {
}
tcp_defer_accept @ DeferAccept => {
let mut seconds = *(tcp_defer_accept.get().unwrap());
if (seconds as i32) < 0 {
seconds = 0;
}
let retrans = Retrans::from_secs(seconds);
options.tcp.set_defer_accept(retrans);
},
tcp_window_clamp: WindowClamp => {
}
tcp_window_clamp @ WindowClamp => {
let window_clamp = tcp_window_clamp.get().unwrap();
let half_recv_buf = options.socket.recv_buf() / 2;
if *window_clamp <= half_recv_buf {
@ -765,23 +775,24 @@ fn do_tcp_setsockopt(
} else {
options.tcp.set_window_clamp(*window_clamp);
}
},
tcp_congestion: Congestion => {
}
tcp_congestion @ Congestion => {
let congestion = tcp_congestion.get().unwrap();
options.tcp.set_congestion(*congestion);
},
tcp_user_timeout: UserTimeout => {
}
tcp_user_timeout @ UserTimeout => {
let user_timeout = tcp_user_timeout.get().unwrap();
if (*user_timeout as i32) < 0 {
return_errno_with_message!(Errno::EINVAL, "the user timeout cannot be negative");
}
options.tcp.set_user_timeout(*user_timeout);
},
tcp_inq: Inq => {
}
tcp_inq @ Inq => {
let inq = tcp_inq.get().unwrap();
options.tcp.set_receive_inq(*inq);
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
}
_ =>
return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown"),
});
Ok(NeedIfacePoll::FALSE)

2
kernel/src/net/socket/ip/stream/options.rs
View File

@ -1,6 +1,6 @@
// SPDX-License-Identifier: MPL-2.0
use crate::{impl_socket_options, prelude::*};
use crate::{net::socket::options::macros::impl_socket_options, prelude::*};
impl_socket_options!(
pub struct NoDelay(bool);

27
kernel/src/net/socket/netlink/common/mod.rs
View File

@ -9,11 +9,13 @@ use super::{GroupIdSet, NetlinkSocketAddr};
use crate::{
events::IoEvents,
fs::utils::Inode,
match_sock_option_mut, match_sock_option_ref,
net::socket::{
netlink::{table::SupportedNetlinkProtocol, AddMembership, DropMembership},
new_pseudo_inode,
options::{Error as SocketError, SocketOption},
options::{
macros::{sock_option_mut, sock_option_ref},
Error as SocketError, SocketOption,
},
private::SocketPrivate,
util::{
datagram_common::{select_remote_and_bind, Bound, Inner},
@ -186,13 +188,13 @@ where
}
fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
socket_errors: SocketError => {
sock_option_mut!(match option {
socket_errors @ SocketError => {
// TODO: Support socket errors for netlink sockets
socket_errors.set(None);
return Ok(());
},
_ => ()
}
_ => (),
});
let inner = self.inner.read();
@ -281,16 +283,17 @@ fn do_netlink_setsockopt<P: SupportedNetlinkProtocol>(
option: &dyn SocketOption,
inner: &mut Inner<UnboundNetlink<P>, BoundNetlink<P::Message>>,
) -> Result<()> {
match_sock_option_ref!(option, {
add_membership: AddMembership => {
sock_option_ref!(match option {
add_membership @ AddMembership => {
let groups = add_membership.get().unwrap();
inner.add_groups(GroupIdSet::new(*groups));
},
drop_membership: DropMembership => {
}
drop_membership @ DropMembership => {
let groups = drop_membership.get().unwrap();
inner.drop_groups(GroupIdSet::new(*groups));
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
}
_ =>
return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown"),
});
Ok(())

2
kernel/src/net/socket/netlink/options.rs
View File

@ -1,6 +1,6 @@
// SPDX-License-Identifier: MPL-2.0
use crate::impl_socket_options;
use crate::net::socket::options::macros::impl_socket_options;
impl_socket_options!(
pub struct AddMembership(u32);

22
kernel/src/net/socket/options/macros.rs
View File

@ -1,6 +1,5 @@
// SPDX-License-Identifier: MPL-2.0
#[macro_export]
macro_rules! impl_socket_options {
($(
$(#[$outer:meta])*
@ -43,13 +42,13 @@ macro_rules! impl_socket_options {
)*
};
}
pub(in crate::net) use impl_socket_options;
#[macro_export]
macro_rules! match_sock_option_ref {
macro_rules! sock_option_ref {
(
$option:expr, {
$( $bind: ident : $ty:ty => $arm:expr ),*,
_ => $default:expr
match $option:ident {
$( $bind:ident @ $ty:ty => $arm:block $(,)? )*
_ => $default:expr $(,)?
}
) => {{
let __option : &dyn SocketOption = $option;
@ -63,13 +62,13 @@ macro_rules! match_sock_option_ref {
}
}};
}
pub(in crate::net) use sock_option_ref;
#[macro_export]
macro_rules! match_sock_option_mut {
macro_rules! sock_option_mut {
(
$option:expr, {
$( $bind: ident : $ty:ty => $arm:expr ),*,
_ => $default:expr
match $option:ident {
$( $bind:ident @ $ty:ty => $arm:block $(,)? )*
_ => $default:expr $(,)?
}
) => {{
let __option : &mut dyn SocketOption = $option;
@ -83,3 +82,4 @@ macro_rules! match_sock_option_mut {
}
}};
}
pub(in crate::net) use sock_option_mut;

8
kernel/src/net/socket/options/mod.rs
View File

@ -1,9 +1,11 @@
// SPDX-License-Identifier: MPL-2.0
use super::util::LingerOption;
use crate::{impl_socket_options, net::socket::unix::CUserCred, prelude::*, process::Gid};
use macros::impl_socket_options;
mod macros;
use super::util::LingerOption;
use crate::{net::socket::unix::CUserCred, prelude::*, process::Gid};
pub(in crate::net) mod macros;
/// Socket options. This trait represents all options that can be set or got for a socket, including
/// socket level options and options for specific socket type like tcp socket.

11
kernel/src/net/socket/unix/datagram/socket.rs
View File

@ -6,10 +6,9 @@ use super::message::{MessageQueue, MessageReceiver};
use crate::{
events::IoEvents,
fs::utils::Inode,
match_sock_option_mut,
net::socket::{
new_pseudo_inode,
options::{Error as SocketError, SocketOption},
options::{macros::sock_option_mut, Error as SocketError, SocketOption},
private::SocketPrivate,
unix::{ctrl_msg::AuxiliaryData, UnixSocketAddr},
util::{
@ -200,13 +199,13 @@ impl Socket for UnixDatagramSocket {
}
fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
socket_errors: SocketError => {
sock_option_mut!(match option {
socket_errors @ SocketError => {
// TODO: Support socket errors for UNIX sockets
socket_errors.set(None);
return Ok(());
},
_ => ()
}
_ => (),
});
let options = self.options.read();

25
kernel/src/net/socket/unix/stream/socket.rs
View File

@ -16,10 +16,11 @@ use crate::{
file_handle::FileLike,
utils::{EndpointState, Inode},
},
match_sock_option_mut,
net::socket::{
new_pseudo_inode,
options::{Error as SocketError, PeerCred, PeerGroups, SocketOption},
options::{
macros::sock_option_mut, Error as SocketError, PeerCred, PeerGroups, SocketOption,
},
private::SocketPrivate,
unix::{cred::SocketCred, ctrl_msg::AuxiliaryData, CUserCred, UnixSocketAddr},
util::{
@ -387,13 +388,13 @@ impl Socket for UnixStreamSocket {
}
fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
match_sock_option_mut!(option, {
socket_errors: SocketError => {
sock_option_mut!(match option {
socket_errors @ SocketError => {
// TODO: Support socket errors for UNIX sockets
socket_errors.set(None);
return Ok(());
},
_ => ()
}
_ => (),
});
let state = self.state.read();
@ -496,19 +497,19 @@ impl Socket for UnixStreamSocket {
}
fn do_unix_getsockopt(option: &mut dyn SocketOption, state: &State) -> Result<()> {
match_sock_option_mut!(option, {
socket_peer_cred: PeerCred => {
sock_option_mut!(match option {
socket_peer_cred @ PeerCred => {
let peer_cred = state.peer_cred().unwrap_or_else(CUserCred::new_invalid);
socket_peer_cred.set(peer_cred);
},
socket_peer_groups: PeerGroups => {
}
socket_peer_groups @ PeerGroups => {
let groups = state.peer_groups()?;
socket_peer_groups.set(groups);
},
}
_ => return_errno_with_message!(
Errno::ENOPROTOOPT,
"the socket option to get is not UNIX-socket-specific"
)
),
});
Ok(())

116
kernel/src/net/socket/util/options.rs
View File

@ -8,10 +8,10 @@ use aster_bigtcp::socket::{
use super::LingerOption;
use crate::{
match_sock_option_mut, match_sock_option_ref,
net::socket::{
netlink::NETLINK_DEFAULT_BUF_SIZE,
options::{
macros::{sock_option_mut, sock_option_ref},
AcceptConn, Broadcast, KeepAlive, Linger, PassCred, PeerCred, PeerGroups, Priority,
RecvBuf, RecvBufForce, ReuseAddr, ReusePort, SendBuf, SendBufForce, SocketOption,
},
@ -107,67 +107,70 @@ impl SocketOptionSet {
option: &mut dyn SocketOption,
socket: &dyn GetSocketLevelOption,
) -> Result<()> {
match_sock_option_mut!(option, {
socket_reuse_addr: ReuseAddr => {
sock_option_mut!(match option {
socket_reuse_addr @ ReuseAddr => {
let reuse_addr = self.reuse_addr();
socket_reuse_addr.set(reuse_addr);
},
socket_broadcast: Broadcast => {
}
socket_broadcast @ Broadcast => {
let broadcast = self.broadcast();
socket_broadcast.set(broadcast);
},
socket_send_buf: SendBuf => {
}
socket_send_buf @ SendBuf => {
let send_buf = self.send_buf();
socket_send_buf.set(send_buf);
},
socket_recv_buf: RecvBuf => {
}
socket_recv_buf @ RecvBuf => {
let recv_buf = self.recv_buf();
socket_recv_buf.set(recv_buf);
},
socket_keepalive: KeepAlive => {
}
socket_keepalive @ KeepAlive => {
let keep_alive = self.keep_alive();
socket_keepalive.set(keep_alive);
},
socket_priority: Priority => {
}
socket_priority @ Priority => {
let priority = self.priority();
socket_priority.set(priority);
},
socket_linger: Linger => {
}
socket_linger @ Linger => {
let linger = self.linger();
socket_linger.set(linger);
},
socket_reuse_port: ReusePort => {
}
socket_reuse_port @ ReusePort => {
let reuse_port = self.reuse_port();
socket_reuse_port.set(reuse_port);
},
socket_pass_cred: PassCred => {
}
socket_pass_cred @ PassCred => {
// This option only affects UNIX sockets. However, it also works well with other
// sockets for setting and getting.
let pass_cred = self.pass_cred();
socket_pass_cred.set(pass_cred);
},
socket_peer_cred: PeerCred => {
}
socket_peer_cred @ PeerCred => {
let peer_cred = CUserCred::new_invalid();
socket_peer_cred.set(peer_cred);
},
socket_accept_conn: AcceptConn => {
}
socket_accept_conn @ AcceptConn => {
let is_listening = socket.is_listening();
socket_accept_conn.set(is_listening);
},
socket_sendbuf_force: SendBufForce => {
}
socket_sendbuf_force @ SendBufForce => {
check_current_privileged()?;
let send_buf = self.send_buf();
socket_sendbuf_force.set(send_buf);
},
socket_recvbuf_force: RecvBufForce => {
}
socket_recvbuf_force @ RecvBufForce => {
check_current_privileged()?;
let recv_buf = self.recv_buf();
socket_recvbuf_force.set(recv_buf);
},
_socket_peer_groups: PeerGroups => {
}
_socket_peer_groups @ PeerGroups => {
return_errno_with_message!(Errno::ENODATA, "the socket does not have peer groups");
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to get is unknown")
}
_ => return_errno_with_message!(
Errno::ENOPROTOOPT,
"the socket option to get is unknown"
),
});
Ok(())
}
@ -178,58 +181,58 @@ impl SocketOptionSet {
option: &dyn SocketOption,
socket: &dyn SetSocketLevelOption,
) -> Result<NeedIfacePoll> {
match_sock_option_ref!(option, {
socket_reuse_addr: ReuseAddr => {
sock_option_ref!(match option {
socket_reuse_addr @ ReuseAddr => {
let reuse_addr = socket_reuse_addr.get().unwrap();
self.set_reuse_addr(*reuse_addr);
socket.set_reuse_addr(*reuse_addr);
},
socket_broadcast: Broadcast => {
}
socket_broadcast @ Broadcast => {
let broadcast = socket_broadcast.get().unwrap();
self.set_broadcast(*broadcast);
},
socket_send_buf: SendBuf => {
}
socket_send_buf @ SendBuf => {
let send_buf = socket_send_buf.get().unwrap();
if *send_buf <= MIN_SENDBUF {
self.set_send_buf(MIN_SENDBUF);
} else {
self.set_send_buf(*send_buf);
}
},
socket_recv_buf: RecvBuf => {
}
socket_recv_buf @ RecvBuf => {
let recv_buf = socket_recv_buf.get().unwrap();
if *recv_buf <= MIN_RECVBUF {
self.set_recv_buf(MIN_RECVBUF);
} else {
self.set_recv_buf(*recv_buf);
}
},
socket_keepalive: KeepAlive => {
}
socket_keepalive @ KeepAlive => {
let keep_alive = socket_keepalive.get().unwrap();
self.set_keep_alive(*keep_alive);
return Ok(socket.set_keep_alive(*keep_alive));
},
socket_priority: Priority => {
}
socket_priority @ Priority => {
let priority = socket_priority.get().unwrap();
check_priority(*priority)?;
self.set_priority(*priority);
},
socket_linger: Linger => {
}
socket_linger @ Linger => {
let linger = socket_linger.get().unwrap();
self.set_linger(*linger);
},
socket_reuse_port: ReusePort => {
}
socket_reuse_port @ ReusePort => {
let reuse_port = socket_reuse_port.get().unwrap();
self.set_reuse_port(*reuse_port);
},
socket_pass_cred: PassCred => {
}
socket_pass_cred @ PassCred => {
// This option only affects UNIX sockets. However, it also works well with other
// sockets for setting and getting.
let pass_cred = socket_pass_cred.get().unwrap();
self.set_pass_cred(*pass_cred);
socket.set_pass_cred(*pass_cred);
},
socket_sendbuf_force: SendBufForce => {
}
socket_sendbuf_force @ SendBufForce => {
check_current_privileged()?;
let send_buf = socket_sendbuf_force.get().unwrap();
if *send_buf <= MIN_SENDBUF {
@ -237,8 +240,8 @@ impl SocketOptionSet {
} else {
self.set_send_buf(*send_buf);
}
},
socket_recvbuf_force: RecvBufForce => {
}
socket_recvbuf_force @ RecvBufForce => {
check_current_privileged()?;
let recv_buf = socket_recvbuf_force.get().unwrap();
if *recv_buf <= MIN_RECVBUF {
@ -246,8 +249,11 @@ impl SocketOptionSet {
} else {
self.set_recv_buf(*recv_buf);
}
},
_ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
}
_ => return_errno_with_message!(
Errno::ENOPROTOOPT,
"the socket option to be set is unknown"
),
});
Ok(NeedIfacePoll::FALSE)