Enable TcpMaxSeg setsockopt option for apple targets

[hulthe]

What does this PR do

Enables the TcpMaxSeg socket option for apple targets. I've tested this on MacOS, not sure about iOS but I imagine it would work just the same.

Here's some code I used to verify that it works:

use nix::sys::socket::{getsockopt, setsockopt, sockopt::TcpMaxSeg};
use std::{io::Write, net::TcpStream};

fn main() {
    // Open a socket to somewhere
    let mut socket = TcpStream::connect(("127.0.0.1", 1234)).unwrap();
    
    // Set the MSS
    setsockopt(&socket, TcpMaxSeg, &523).unwrap();
    
    // Read the MSS
    let maxseg = getsockopt(&socket, TcpMaxSeg).unwrap();
    println!("maxseg: {maxseg}");
    
    // Send a large amount of data and observe that the segments are not bigger than 523 bytes
    socket.write_all(&[0x77; 2000]).unwrap();
}

Checklist:

• I have read CONTRIBUTING.md
• I have written necessary tests and rustdoc comments
• A change log has been added if this PR modifies nix's API

[SteveLauC]

Actually, this socket option was available for macOS, but for getsockopt() only. This PR adds the setsockopt() part

[hulthe]

Ah, right you are. Fixed.

[SteveLauC]

Could you please give this test an update as well?

nix/test/sys/test_sockopt.rs

Lines 161 to 221 in 003bfe4

	#[test]
	fn test_so_tcp_maxseg() {
	use nix::sys::socket::{
	accept, bind, connect, getsockname, listen, Backlog, SockaddrIn,
	};
	use nix::unistd::write;
	use std::net::SocketAddrV4;
	use std::str::FromStr;
	let std_sa = SocketAddrV4::from_str("127.0.0.1:0").unwrap();
	let mut sock_addr = SockaddrIn::from(std_sa);
	let rsock = socket(
	AddressFamily::Inet,
	SockType::Stream,
	SockFlag::empty(),
	SockProtocol::Tcp,
	)
	.unwrap();
	bind(rsock.as_raw_fd(), &sock_addr).unwrap();
	sock_addr = getsockname(rsock.as_raw_fd()).unwrap();
	listen(&rsock, Backlog::new(10).unwrap()).unwrap();
	let initial = getsockopt(&rsock, sockopt::TcpMaxSeg).unwrap();
	// Initial MSS is expected to be 536 (https://tools.ietf.org/html/rfc879#section-1) but some
	// platforms keep it even lower. This might fail if you've tuned your initial MSS to be larger
	// than 700
	cfg_if! {
	if #[cfg(linux_android)] {
	let segsize: u32 = 873;
	assert!(initial < segsize);
	setsockopt(&rsock, sockopt::TcpMaxSeg, &segsize).unwrap();
	} else {
	assert!(initial < 700);
	}
	}
	// Connect and check the MSS that was advertised
	let ssock = socket(
	AddressFamily::Inet,
	SockType::Stream,
	SockFlag::empty(),
	SockProtocol::Tcp,
	)
	.unwrap();
	connect(ssock.as_raw_fd(), &sock_addr).unwrap();
	let rsess = accept(rsock.as_raw_fd()).unwrap();
	let rsess = unsafe { OwnedFd::from_raw_fd(rsess) };
	write(&rsess, b"hello").unwrap();
	let actual = getsockopt(&ssock, sockopt::TcpMaxSeg).unwrap();
	// Actual max segment size takes header lengths into account, max IPv4 options (60 bytes) + max
	// TCP options (40 bytes) are subtracted from the requested maximum as a lower boundary.
	cfg_if! {
	if #[cfg(linux_android)] {
	assert!((segsize - 100) <= actual);
	assert!(actual <= segsize);
	} else {
	assert!(initial < actual);
	assert!(536 < actual);
	}
	}
	}

[hulthe]

@SteveLauC I updated the test. Had to change it around a bit though since it seems MaxSeg works slightly differently on macos:

1. Can't set MSS on a non-connected socket.
2. Can't set the MSS on a connected socket and then read the same MSS using getsockopt on the other end.

Still I hope the test is good enough :)