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, ReturnFlags, SendFlags};
17
18use crate::{PollFirst, 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    poll_first: bool,
87}
88
89/// Receive data from remote into vectored buffer.
90pub struct RecvVectored<T: IoVectoredBufMut, S> {
91    pub(crate) fd: S,
92    pub(crate) buffer: T,
93    pub(crate) flags: RecvFlags,
94    poll_first: bool,
95}
96
97pub(crate) struct RecvFromHeader<S> {
98    pub(crate) fd: S,
99    pub(crate) flags: RecvFlags,
100    pub(crate) addr: SockAddrStorage,
101    pub(crate) addr_len: socklen_t,
102    poll_first: bool,
103}
104
105/// Receive data and source address.
106pub struct RecvFrom<T: IoBufMut, S> {
107    pub(crate) header: RecvFromHeader<S>,
108    pub(crate) buffer: T,
109}
110
111/// Receive data and source address into vectored buffer.
112pub struct RecvFromVectored<T: IoVectoredBufMut, S> {
113    pub(crate) header: RecvFromHeader<S>,
114    pub(crate) buffer: T,
115}
116
117/// Receive data and source address with ancillary data into vectored
118/// buffer.
119pub struct RecvMsg<T: IoVectoredBufMut, C: IoBufMut, S> {
120    pub(crate) header: RecvFromHeader<S>,
121    pub(crate) buffer: T,
122    pub(crate) control: C,
123    pub(crate) control_len: usize,
124    pub(crate) return_flags: ReturnFlags,
125    poll_first: bool,
126}
127
128impl<S> Connect<S> {
129    /// Create [`Connect`]. `fd` should be bound.
130    pub fn new(fd: S, addr: SockAddr) -> Self {
131        Self { fd, addr }
132    }
133}
134
135impl CloseSocket {
136    /// Create [`CloseSocket`].
137    pub fn new(fd: OwnedFd) -> Self {
138        Self {
139            fd: ManuallyDrop::new(fd),
140        }
141    }
142}
143
144impl<T: IoBuf, S> Send<T, S> {
145    /// Create [`Send`].
146    pub fn new(fd: S, buffer: T, flags: SendFlags) -> Self {
147        Self { fd, buffer, flags }
148    }
149}
150
151impl<T: IoBuf, S> IntoInner for Send<T, S> {
152    type Inner = T;
153
154    fn into_inner(self) -> Self::Inner {
155        self.buffer
156    }
157}
158
159impl<T: IoVectoredBuf, S> SendVectored<T, S> {
160    /// Create [`SendVectored`].
161    pub fn new(fd: S, buffer: T, flags: SendFlags) -> Self {
162        Self { fd, buffer, flags }
163    }
164}
165
166impl<T: IoVectoredBuf, S> IntoInner for SendVectored<T, S> {
167    type Inner = T;
168
169    fn into_inner(self) -> Self::Inner {
170        self.buffer
171    }
172}
173
174impl<S> SendToHeader<S> {
175    pub fn new(fd: S, addr: SockAddr, flags: SendFlags) -> Self {
176        Self { fd, addr, flags }
177    }
178}
179
180impl<T: IoBuf, S> SendTo<T, S> {
181    /// Create [`SendTo`].
182    pub fn new(fd: S, buffer: T, addr: SockAddr, flags: SendFlags) -> Self {
183        Self {
184            header: SendToHeader::new(fd, addr, flags),
185            buffer,
186        }
187    }
188}
189
190impl<T: IoBuf, S> IntoInner for SendTo<T, S> {
191    type Inner = T;
192
193    fn into_inner(self) -> Self::Inner {
194        self.buffer
195    }
196}
197
198impl<T: IoVectoredBuf, S> SendToVectored<T, S> {
199    /// Create [`SendToVectored`].
200    pub fn new(fd: S, buffer: T, addr: SockAddr, flags: SendFlags) -> Self {
201        Self {
202            header: SendToHeader::new(fd, addr, flags),
203            buffer,
204        }
205    }
206}
207
208impl<T: IoVectoredBuf, S> IntoInner for SendToVectored<T, S> {
209    type Inner = T;
210
211    fn into_inner(self) -> Self::Inner {
212        self.buffer
213    }
214}
215
216impl<T: IoVectoredBuf, C: IoBuf, S> SendMsg<T, C, S> {
217    /// Create [`SendMsg`].
218    ///
219    /// # Panics
220    ///
221    /// This function will panic if the control message buffer is misaligned.
222    pub fn new(fd: S, buffer: T, control: C, addr: Option<SockAddr>, flags: SendFlags) -> Self {
223        assert!(
224            control.buf_len() == 0 || control.buf_ptr().cast::<CmsgHeader>().is_aligned(),
225            "misaligned control message buffer"
226        );
227        Self {
228            fd,
229            buffer,
230            control,
231            addr,
232            flags,
233        }
234    }
235}
236
237impl<T: IoVectoredBuf, C: IoBuf, S> IntoInner for SendMsg<T, C, S> {
238    type Inner = (T, C);
239
240    fn into_inner(self) -> Self::Inner {
241        (self.buffer, self.control)
242    }
243}
244
245impl<T: IoVectoredBufMut, C: IoBufMut, S> RecvMsg<T, C, S> {
246    /// Create [`RecvMsg`].
247    ///
248    /// # Panics
249    ///
250    /// This function will panic if the control message buffer is
251    /// misaligned.
252    pub fn new(fd: S, buffer: T, control: C, flags: RecvFlags) -> Self {
253        assert!(
254            control.buf_ptr().cast::<CmsgHeader>().is_aligned(),
255            "misaligned control message buffer"
256        );
257        Self {
258            header: RecvFromHeader::new(fd, flags),
259            buffer,
260            control,
261            control_len: 0,
262            return_flags: ReturnFlags::empty(),
263            poll_first: false,
264        }
265    }
266}
267
268impl<T: IoVectoredBufMut, C: IoBufMut, S> PollFirst for RecvMsg<T, C, S> {
269    fn poll_first(&mut self) {
270        self.poll_first = true;
271    }
272}
273
274impl<T: IoVectoredBufMut, C: IoBufMut, S> IntoInner for RecvMsg<T, C, S> {
275    type Inner = ((T, C), Option<SockAddr>, usize, ReturnFlags);
276
277    fn into_inner(self) -> Self::Inner {
278        (
279            (self.buffer, self.control),
280            self.header.into_addr(),
281            self.control_len,
282            self.return_flags,
283        )
284    }
285}
286
287impl<T: IoBufMut, S> Recv<T, S> {
288    /// Create [`Recv`].
289    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
290        Self {
291            fd,
292            buffer,
293            flags,
294            poll_first: false,
295        }
296    }
297}
298
299impl<T: IoBufMut, S> PollFirst for Recv<T, S> {
300    fn poll_first(&mut self) {
301        self.poll_first = true;
302    }
303}
304
305impl<T: IoBufMut, S> IntoInner for Recv<T, S> {
306    type Inner = T;
307
308    fn into_inner(self) -> Self::Inner {
309        self.buffer
310    }
311}
312
313impl<T: IoVectoredBufMut, S> RecvVectored<T, S> {
314    /// Create [`RecvVectored`].
315    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
316        Self {
317            fd,
318            buffer,
319            flags,
320            poll_first: false,
321        }
322    }
323}
324
325impl<T: IoVectoredBufMut, S> PollFirst for RecvVectored<T, S> {
326    fn poll_first(&mut self) {
327        self.poll_first = true;
328    }
329}
330
331impl<T: IoVectoredBufMut, S> IntoInner for RecvVectored<T, S> {
332    type Inner = T;
333
334    fn into_inner(self) -> Self::Inner {
335        self.buffer
336    }
337}
338
339impl<S> RecvFromHeader<S> {
340    pub fn new(fd: S, flags: RecvFlags) -> Self {
341        let addr = SockAddrStorage::zeroed();
342        let name_len = addr.size_of();
343        Self {
344            fd,
345            addr,
346            flags,
347            addr_len: name_len,
348            poll_first: false,
349        }
350    }
351
352    pub fn into_addr(self) -> Option<SockAddr> {
353        (self.addr_len > 0).then(|| unsafe { SockAddr::new(self.addr, self.addr_len) })
354    }
355}
356
357impl<T: IoVectoredBufMut, S> RecvFromVectored<T, S> {
358    /// Create [`RecvFromVectored`].
359    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
360        Self {
361            header: RecvFromHeader::new(fd, flags),
362            buffer,
363        }
364    }
365}
366
367impl<T: IoVectoredBufMut, S> PollFirst for RecvFromVectored<T, S> {
368    fn poll_first(&mut self) {
369        self.header.poll_first = true;
370    }
371}
372
373impl<T: IoVectoredBufMut, S: AsFd> IntoInner for RecvFromVectored<T, S> {
374    type Inner = (T, Option<SockAddr>);
375
376    fn into_inner(self) -> Self::Inner {
377        let addr = self.header.into_addr();
378        (self.buffer, addr)
379    }
380}
381
382impl<T: IoBufMut, S> RecvFrom<T, S> {
383    /// Create [`RecvFrom`].
384    pub fn new(fd: S, buffer: T, flags: RecvFlags) -> Self {
385        Self {
386            header: RecvFromHeader::new(fd, flags),
387            buffer,
388        }
389    }
390}
391
392impl<T: IoBufMut, S> PollFirst for RecvFrom<T, S> {
393    fn poll_first(&mut self) {
394        self.header.poll_first = true;
395    }
396}
397
398impl<T: IoBufMut, S> IntoInner for RecvFrom<T, S> {
399    type Inner = (T, Option<SockAddr>);
400
401    fn into_inner(self) -> Self::Inner {
402        (self.buffer, self.header.into_addr())
403    }
404}
compio_driver/sys/op/socket/mod.rs

compio_driver/sys/op/socket/
mod.rs
