Skip to content

Commit 8409951

Browse files
Implement socket.socket.sendmsg (RustPython#5205)
* Implement socket.socket.sendmsg * debugger-friendly newlines * Fix control_buf error on macOS --------- Co-authored-by: Jeong YunWon <jeong@youknowone.org>
1 parent 3286e68 commit 8409951

3 files changed

Lines changed: 165 additions & 6 deletions

File tree

‎Cargo.lock‎

Lines changed: 3 additions & 3 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎stdlib/Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -94,7 +94,7 @@ termios = "0.3.3"
9494

9595
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
9696
gethostname = "0.2.3"
97-
socket2 = { version = "0.5.4", features = ["all"] }
97+
socket2 = { version = "0.5.6", features = ["all"] }
9898
dns-lookup = "2"
9999
openssl = { version = "0.10.62", optional = true }
100100
openssl-sys = { version = "0.9.80", optional = true }

‎stdlib/src/socket.rs‎

Lines changed: 161 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -822,7 +822,8 @@ mod _socket {
822822

823823
impl PySocket {
824824
pub fn sock_opt(&self) -> Option<PyMappedRwLockReadGuard<'_, Socket>> {
825-
PyRwLockReadGuard::try_map(self.sock.read(), |sock| sock.as_ref()).ok()
825+
let sock = PyRwLockReadGuard::try_map(self.sock.read(), |sock| sock.as_ref());
826+
sock.ok()
826827
}
827828

828829
pub fn sock(&self) -> io::Result<PyMappedRwLockReadGuard<'_, Socket>> {
@@ -869,7 +870,8 @@ mod _socket {
869870
where
870871
F: FnMut() -> io::Result<R>,
871872
{
872-
self.sock_op_timeout_err(vm, select, self.get_timeout().ok(), f)
873+
let timeout = self.get_timeout().ok();
874+
self.sock_op_timeout_err(vm, select, timeout, f)
873875
}
874876

875877
fn sock_op_timeout_err<F, R>(
@@ -1319,6 +1321,121 @@ mod _socket {
13191321
})
13201322
}
13211323

1324+
#[cfg(all(unix, not(target_os = "redox")))]
1325+
#[pymethod]
1326+
fn sendmsg(
1327+
&self,
1328+
buffers: Vec<ArgBytesLike>,
1329+
ancdata: OptionalArg,
1330+
flags: OptionalArg<i32>,
1331+
addr: OptionalOption,
1332+
vm: &VirtualMachine,
1333+
) -> PyResult<usize> {
1334+
let flags = flags.unwrap_or(0);
1335+
let mut msg = socket2::MsgHdr::new();
1336+
1337+
let sockaddr;
1338+
if let Some(addr) = addr.flatten() {
1339+
sockaddr = self
1340+
.extract_address(addr, "sendmsg", vm)
1341+
.map_err(|e| e.into_pyexception(vm))?;
1342+
msg = msg.with_addr(&sockaddr);
1343+
}
1344+
1345+
let buffers = buffers
1346+
.iter()
1347+
.map(|buf| buf.borrow_buf())
1348+
.collect::<Vec<_>>();
1349+
let buffers = buffers
1350+
.iter()
1351+
.map(|buf| io::IoSlice::new(buf))
1352+
.collect::<Vec<_>>();
1353+
msg = msg.with_buffers(&buffers);
1354+
1355+
let control_buf;
1356+
if let OptionalArg::Present(ancdata) = ancdata {
1357+
let cmsgs = vm.extract_elements_with(
1358+
&ancdata,
1359+
|obj| -> PyResult<(i32, i32, ArgBytesLike)> {
1360+
let seq: Vec<PyObjectRef> = obj.try_into_value(vm)?;
1361+
let [lvl, typ, data]: [PyObjectRef; 3] = seq.try_into().map_err(|_| {
1362+
vm.new_type_error("expected a sequence of length 3".to_owned())
1363+
})?;
1364+
Ok((
1365+
lvl.try_into_value(vm)?,
1366+
typ.try_into_value(vm)?,
1367+
data.try_into_value(vm)?,
1368+
))
1369+
},
1370+
)?;
1371+
control_buf = Self::pack_cmsgs_to_send(&cmsgs, vm)?;
1372+
if !control_buf.is_empty() {
1373+
msg = msg.with_control(&control_buf);
1374+
}
1375+
}
1376+
1377+
self.sock_op(vm, SelectKind::Write, || {
1378+
let sock = self.sock()?;
1379+
sock.sendmsg(&msg, flags)
1380+
})
1381+
.map_err(|e| e.into_pyexception(vm))
1382+
}
1383+
1384+
// based on nix's implementation
1385+
#[cfg(all(unix, not(target_os = "redox")))]
1386+
fn pack_cmsgs_to_send(
1387+
cmsgs: &[(i32, i32, ArgBytesLike)],
1388+
vm: &VirtualMachine,
1389+
) -> PyResult<Vec<u8>> {
1390+
use std::{mem, ptr};
1391+
1392+
if cmsgs.is_empty() {
1393+
return Ok(vec![]);
1394+
}
1395+
1396+
let capacity = cmsgs
1397+
.iter()
1398+
.map(|(_, _, buf)| buf.len())
1399+
.try_fold(0, |sum, len| {
1400+
let space = checked_cmsg_space(len).ok_or_else(|| {
1401+
vm.new_os_error("ancillary data item too large".to_owned())
1402+
})?;
1403+
usize::checked_add(sum, space)
1404+
.ok_or_else(|| vm.new_os_error("too much ancillary data".to_owned()))
1405+
})?;
1406+
1407+
let mut cmsg_buffer = vec![0u8; capacity];
1408+
1409+
// make a dummy msghdr so we can use the CMSG_* apis
1410+
let mut mhdr = unsafe { mem::zeroed::<libc::msghdr>() };
1411+
mhdr.msg_control = cmsg_buffer.as_mut_ptr().cast();
1412+
mhdr.msg_controllen = capacity as _;
1413+
1414+
let mut pmhdr: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(&mhdr) };
1415+
for (lvl, typ, buf) in cmsgs {
1416+
if pmhdr.is_null() {
1417+
return Err(vm.new_runtime_error(
1418+
"unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR".to_owned(),
1419+
));
1420+
}
1421+
let data = &*buf.borrow_buf();
1422+
assert_eq!(data.len(), buf.len());
1423+
// Safe because we know that pmhdr is valid, and we initialized it with
1424+
// sufficient space
1425+
unsafe {
1426+
(*pmhdr).cmsg_level = *lvl;
1427+
(*pmhdr).cmsg_type = *typ;
1428+
(*pmhdr).cmsg_len = data.len() as _;
1429+
ptr::copy_nonoverlapping(data.as_ptr(), libc::CMSG_DATA(pmhdr), data.len());
1430+
}
1431+
1432+
// Safe because mhdr is valid
1433+
pmhdr = unsafe { libc::CMSG_NXTHDR(&mhdr, pmhdr) };
1434+
}
1435+
1436+
Ok(cmsg_buffer)
1437+
}
1438+
13221439
#[pymethod]
13231440
fn close(&self) -> io::Result<()> {
13241441
let sock = self.detach();
@@ -2364,4 +2481,46 @@ mod _socket {
23642481
HError,
23652482
GaiError,
23662483
}
2484+
2485+
#[cfg(all(unix, not(target_os = "redox")))]
2486+
fn checked_cmsg_len(len: usize) -> Option<usize> {
2487+
// SAFETY: CMSG_LEN is always safe
2488+
let cmsg_len = |length| unsafe { libc::CMSG_LEN(length) };
2489+
if len as u64 > (i32::MAX as u64 - cmsg_len(0) as u64) {
2490+
return None;
2491+
}
2492+
let res = cmsg_len(len as _) as usize;
2493+
if res > i32::MAX as usize || res < len {
2494+
return None;
2495+
}
2496+
Some(res)
2497+
}
2498+
2499+
#[cfg(all(unix, not(target_os = "redox")))]
2500+
fn checked_cmsg_space(len: usize) -> Option<usize> {
2501+
// SAFETY: CMSG_SPACE is always safe
2502+
let cmsg_space = |length| unsafe { libc::CMSG_SPACE(length) };
2503+
if len as u64 > (i32::MAX as u64 - cmsg_space(1) as u64) {
2504+
return None;
2505+
}
2506+
let res = cmsg_space(len as _) as usize;
2507+
if res > i32::MAX as usize || res < len {
2508+
return None;
2509+
}
2510+
Some(res)
2511+
}
2512+
2513+
#[cfg(all(unix, not(target_os = "redox")))]
2514+
#[pyfunction(name = "CMSG_LEN")]
2515+
fn cmsg_len(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
2516+
checked_cmsg_len(length)
2517+
.ok_or_else(|| vm.new_overflow_error("CMSG_LEN() argument out of range".to_owned()))
2518+
}
2519+
2520+
#[cfg(all(unix, not(target_os = "redox")))]
2521+
#[pyfunction(name = "CMSG_SPACE")]
2522+
fn cmsg_space(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
2523+
checked_cmsg_space(length)
2524+
.ok_or_else(|| vm.new_overflow_error("CMSG_SPACE() argument out of range".to_owned()))
2525+
}
23672526
}

0 commit comments

Comments
 (0)