compio_driver/sys/op/socket/
mod.rs

1#[cfg(unix)]
2mod_use![unix];
3
4#[cfg(io_uring)]
5mod_use![iour];
6
7#[cfg(windows)]
8mod_use![iocp];
9
10#[cfg(polling)]
11mod_use![poll];
12
13#[cfg(stub)]
14mod_use![stub];
15
16use rustix::net::{RecvFlags, SendFlags};
17
18use crate::sys::prelude::*;
19
20/// Connect to a remote address.
21pub struct Connect<S> {
22    pub(crate) fd: S,
23    pub(crate) addr: SockAddr,
24}
25
26/// Close socket fd.
27pub struct CloseSocket {
28    pub(crate) fd: ManuallyDrop<OwnedFd>,
29}
30
31/// Send data to remote.
32///
33/// If you want to write to a pipe, use [`Write`].
34///
35/// [`Write`]: crate::op::Write
36pub struct Send<T: IoBuf, S> {
37    pub(crate) fd: S,
38    pub(crate) buffer: T,
39    pub(crate) flags: SendFlags,
40}
41
42/// Send data to remote from vectored buffer.
43pub struct SendVectored<T: IoVectoredBuf, S> {
44    pub(crate) fd: S,
45    pub(crate) buffer: T,
46    pub(crate) flags: SendFlags,
47}
48
49pub(crate) struct SendToHeader<S> {
50    pub(crate) fd: S,
51    pub(crate) addr: SockAddr,
52    pub(crate) flags: SendFlags,
53}
54
55/// Send data to specified address.
56pub struct SendTo<T: IoBuf, S> {
57    pub(crate) header: SendToHeader<S>,
58    pub(crate) buffer: T,
59}
60
61/// Send data to specified address from vectored buffer.
62pub struct SendToVectored<T: IoVectoredBuf, S> {
63    pub(crate) header: SendToHeader<S>,
64    pub(crate) buffer: T,
65}
66
67/// Send data to specified address accompanied by ancillary data from vectored
68/// buffer.
69pub struct SendMsg<T: IoVectoredBuf, C: IoBuf, S> {
70    pub(crate) fd: S,
71    pub(crate) buffer: T,
72    pub(crate) control: C,
73    pub(crate) addr: Option<SockAddr>,
74    pub(crate) flags: SendFlags,
75}
76
77/// Receive data from remote.
78///
79/// If you want to read from a pipe, use [`Read`].
80///
81/// [`Read`]: crate::op::Read
82pub struct Recv<T: IoBufMut, S> {
83    pub(crate) fd: S,
84    pub(crate) buffer: T,
85    pub(crate) flags: RecvFlags,
86}
87
88/// Receive data from remote into vectored buffer.
89pub struct RecvVectored<T: IoVectoredBufMut, S> {
90    pub(crate) fd: S,
91    pub(crate) buffer: T,
92    pub(crate) flags: RecvFlags,
93}
94
95pub(crate) struct RecvFromHeader<S> {
96    pub(crate) fd: S,
97    pub(crate) flags: RecvFlags,
98    pub(crate) addr: SockAddrStorage,
99    pub(crate) addr_len: socklen_t,
100}
101
102/// Receive data and source address.
103pub struct RecvFrom<T: IoBufMut, S> {
104    pub(crate) header: RecvFromHeader<S>,
105    pub(crate) buffer: T,
106}
107
108/// Receive data and source address into vectored buffer.
109pub struct RecvFromVectored<T: IoVectoredBufMut, S> {
110    pub(crate) header: RecvFromHeader<S>,
111    pub(crate) buffer: T,
112}
113
114/// Receive data and source address with ancillary data into vectored
115/// buffer.
116pub struct RecvMsg<T: IoVectoredBufMut, C: IoBufMut, S> {
117    pub(crate) header: RecvFromHeader<S>,
118    pub(crate) buffer: T,
119    pub(crate) control: C,
120    pub(crate) control_len: usize,
121}
122
123impl<S> Connect<S> {
124    /// Create [`Connect`]. `fd` should be bound.
125    pub fn new(fd: S, addr: SockAddr) -> Self {
126        Self { fd, addr }
127    }
128}
129
130impl CloseSocket {
131    /// Create [`CloseSocket`].
132    pub fn new(fd: OwnedFd) -> Self {
133        Self {
134            fd: ManuallyDrop::new(fd),
135        }
136    }
137}
138
139impl<T: IoBuf, S> Send<T, S> {
140    /// Create [`Send`].
141    pub fn new(fd: S, buffer: T, flags: SendFlags) -> Self {
142        Self { fd, buffer, flags }
143    }
144}
145
146impl<T: IoBuf, S> IntoInner for Send<T, S> {
147    type Inner = T;
148
149    fn into_inner(self) -> Self::Inner {
150        self.buffer
151    }
152}
153
154impl<T: IoVectoredBuf, S> SendVectored<T, S> {
155    /// Create [`SendVectored`].
156    pub fn new(fd: S, buffer: T, flags: SendFlags) -> Self {
157        Self { fd, buffer, flags }
158    }
159}
160
161impl<T: IoVectoredBuf, S> IntoInner for SendVectored<T, S> {
162    type Inner = T;
163
164    fn into_inner(self) -> Self::Inner {
165        self.buffer
166    }
167}
168
169impl<S> SendToHeader<S> {
170    pub fn new(fd: S, addr: SockAddr, flags: SendFlags) -> Self {
171        Self { fd, addr, flags }
172    }
173}
174
175impl<T: IoBuf, S> SendTo<T, S> {
176    /// Create [`SendTo`].
177    pub fn new(fd: S, buffer: T, addr: SockAddr, flags: SendFlags) -> Self {
178        Self {
179            header: SendToHeader::new(fd, addr, flags),
180            buffer,
181        }
182    }
183}
184
185impl<T: IoBuf, S> IntoInner for SendTo<T, S> {
186    type Inner = T;
187
188    fn into_inner(self) -> Self::Inner {
189        self.buffer
190    }
191}
192
193impl<T: IoVectoredBuf, S> SendToVectored<T, S> {
194    /// Create [`SendToVectored`].
195    pub fn new(fd: S, buffer: T, addr: SockAddr, flags: SendFlags) -> Self {
196        Self {
197            header: SendToHeader::new(fd, addr, flags),
198            buffer,
199        }
200    }
201}
202
203impl<T: IoVectoredBuf, S> IntoInner for SendToVectored<T, S> {
204    type Inner = T;
205
206    fn into_inner(self) -> Self::Inner {
207        self.buffer
208    }
209}
210
211impl<T: IoVectoredBuf, C: IoBuf, S> SendMsg<T, C, S> {
212    /// Create [`SendMsg`].
213    ///
214    /// # Panics
215    ///
216    /// This function will panic if the control message buffer is misaligned.
217    pub fn new(fd: S, buffer: T, control: C, addr: Option<SockAddr>, flags: SendFlags) -> Self {
218        assert!(
219            control.buf_len() == 0 || control.buf_ptr().cast::<CmsgHeader>().is_aligned(),
220            "misaligned control message buffer"
221        );
222        Self {
223            fd,
224            buffer,
225            control,
226            addr,
227            flags,
228        }
229    }
230}
231
232impl<T: IoVectoredBuf, C: IoBuf, S> IntoInner for SendMsg<T, C, S> {
233    type Inner = (T, C);
234
235    fn into_inner(self) -> Self::Inner {
236        (self.buffer, self.control)
237    }
238}
239
240impl<T: IoVectoredBufMut, C: IoBufMut, S> RecvMsg<T, C, S> {
241    /// Create [`RecvMsg`].
242    ///
243    /// # Panics
244    ///
245    /// This function will panic if the control message buffer is
246    /// misaligned.
247    pub fn new(fd: S, buffer: T, control: C, flags: RecvFlags) -> Self {
248        assert!(
249            control.buf_ptr().cast::<CmsgHeader>().is_aligned(),
250            "misaligned control message buffer"
251        );
252        Self {
253            header: RecvFromHeader::new(fd, flags),
254            buffer,
255            control,
256            control_len: 0,
257        }
258    }
259}
260
261impl<T: IoVectoredBufMut, C: IoBufMut, S> IntoInner for RecvMsg<T, C, S> {
262    type Inner = ((T, C), Option<SockAddr>, usize);
263
264    fn into_inner(self) -> Self::Inner {
265        (
266            (self.buffer, self.control),
267            self.header.into_addr(),
268            self.control_len,
269        )
270    }
271}
272
273impl<T: IoBufMut, S> Recv<T, S> {
274    /// Create [`Recv`].
275    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
276        Self { fd, buffer, flags }
277    }
278}
279
280impl<T: IoBufMut, S> IntoInner for Recv<T, S> {
281    type Inner = T;
282
283    fn into_inner(self) -> Self::Inner {
284        self.buffer
285    }
286}
287
288impl<T: IoVectoredBufMut, S> RecvVectored<T, S> {
289    /// Create [`RecvVectored`].
290    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
291        Self { fd, buffer, flags }
292    }
293}
294
295impl<T: IoVectoredBufMut, S> IntoInner for RecvVectored<T, S> {
296    type Inner = T;
297
298    fn into_inner(self) -> Self::Inner {
299        self.buffer
300    }
301}
302
303impl<S> RecvFromHeader<S> {
304    pub fn new(fd: S, flags: RecvFlags) -> Self {
305        let addr = SockAddrStorage::zeroed();
306        let name_len = addr.size_of();
307        Self {
308            fd,
309            addr,
310            flags,
311            addr_len: name_len,
312        }
313    }
314
315    pub fn into_addr(self) -> Option<SockAddr> {
316        (self.addr_len > 0).then(|| unsafe { SockAddr::new(self.addr, self.addr_len) })
317    }
318}
319
320impl<T: IoVectoredBufMut, S> RecvFromVectored<T, S> {
321    /// Create [`RecvFromVectored`].
322    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
323        Self {
324            header: RecvFromHeader::new(fd, flags),
325            buffer,
326        }
327    }
328}
329
330impl<T: IoVectoredBufMut, S: AsFd> IntoInner for RecvFromVectored<T, S> {
331    type Inner = (T, Option<SockAddr>);
332
333    fn into_inner(self) -> Self::Inner {
334        let addr = self.header.into_addr();
335        (self.buffer, addr)
336    }
337}
338
339impl<T: IoBufMut, S> RecvFrom<T, S> {
340    /// Create [`RecvFrom`].
341    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
342        Self {
343            header: RecvFromHeader::new(fd, flags),
344            buffer,
345        }
346    }
347}
348
349impl<T: IoBufMut, S> IntoInner for RecvFrom<T, S> {
350    type Inner = (T, Option<SockAddr>);
351
352    fn into_inner(self) -> Self::Inner {
353        (self.buffer, self.header.into_addr())
354    }
355}
compio_driver/sys/op/socket/mod.rs

compio_driver/sys/op/socket/
mod.rs
