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

compio_driver/sys/op/socket/
mod.rs
