@@ -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