Implement fallback for sendmmsg and recvmmsg

Some Android phones use older 2.x kernels
and do not support `sendmmsg`
which is available only since Linux 3.0.

Similarly, `recvmmsg` is only available
since Linux 2.6.34.

quinn-udp/src/unix.rs

@@ -194,7 +194,9 @@ fn send(
     let num_transmits = transmits.len().min(BATCH_SIZE);
 
     loop {
-        let n = unsafe { libc::sendmmsg(io.as_raw_fd(), msgs.as_mut_ptr(), num_transmits as _, 0) };
+        let n = unsafe {
+            sendmmsg_with_fallback(io.as_raw_fd(), msgs.as_mut_ptr(), num_transmits as _)
+        };
         if n == -1 {
             let e = io::Error::last_os_error();
             match e.kind() {
@@ -289,6 +291,56 @@ fn send(
     Ok(sent)
 }
 
+/// Implementation of `sendmmsg` with a fallback
+/// to `sendmsg` if syscall is not available.
+///
+/// It uses [`libc::syscall`] instead of [`libc::sendmmsg`]
+/// to avoid linking error on systems where libc does not contain `sendmmsg`.
+#[cfg(not(any(target_os = "macos", target_os = "ios")))]
+unsafe fn sendmmsg_with_fallback(
+    sockfd: libc::c_int,
+    msgvec: *mut libc::mmsghdr,
+    vlen: libc::c_uint,
+) -> libc::c_int {
+    let flags = 0;
+    let ret = libc::syscall(libc::SYS_sendmmsg, sockfd, msgvec, vlen, flags) as libc::c_int;
+    if ret != -1 {
+        return ret;
+    }
+
+    let e = io::Error::last_os_error();
+    match e.raw_os_error() {
+        Some(libc::ENOSYS) => {
+            // Fallback to `sendmsg`.
+            sendmmsg_fallback(sockfd, msgvec, vlen)
+        }
+        _ => -1,
+    }
+}
+
+/// Fallback implementation of `sendmmsg` using `sendmsg`
+/// for systems which do not support `sendmmsg`
+/// such as Linux <3.0.
+#[cfg(not(any(target_os = "macos", target_os = "ios")))]
+unsafe fn sendmmsg_fallback(
+    sockfd: libc::c_int,
+    msgvec: *mut libc::mmsghdr,
+    vlen: libc::c_uint,
+) -> libc::c_int {
+    let flags = 0;
+    if vlen == 0 {
+        return 0;
+    }
+
+    let n = libc::sendmsg(sockfd, &(*msgvec).msg_hdr, flags);
+    if n == -1 {
+        -1
+    } else {
+        (*msgvec).msg_len = n as libc::c_uint;
+        1
+    }
+}
+
 #[cfg(not(any(target_os = "macos", target_os = "ios")))]
 fn recv(io: SockRef<'_>, bufs: &mut [IoSliceMut<'_>], meta: &mut [RecvMeta]) -> io::Result<usize> {
     let mut names = [MaybeUninit::<libc::sockaddr_storage>::uninit(); BATCH_SIZE];
@@ -305,12 +357,10 @@ fn recv(io: SockRef<'_>, bufs: &mut [IoSliceMut<'_>], meta: &mut [RecvMeta]) ->
     }
     let msg_count = loop {
         let n = unsafe {
-            libc::recvmmsg(
+            recvmmsg_with_fallback(
                 io.as_raw_fd(),
                 hdrs.as_mut_ptr(),
                 bufs.len().min(BATCH_SIZE) as _,
-                0,
-                ptr::null_mut(),
             )
         };
         if n == -1 {
@@ -352,6 +402,58 @@ fn recv(io: SockRef<'_>, bufs: &mut [IoSliceMut<'_>], meta: &mut [RecvMeta]) ->
     Ok(1)
 }
 
+/// Implementation of `recvmmsg` with a fallback
+/// to `recvmsg` if syscall is not available.
+///
+/// It uses [`libc::syscall`] instead of [`libc::recvmmsg`]
+/// to avoid linking error on systems where libc does not contain `recvmmsg`.
+#[cfg(not(any(target_os = "macos", target_os = "ios")))]
+unsafe fn recvmmsg_with_fallback(
+    sockfd: libc::c_int,
+    msgvec: *mut libc::mmsghdr,
+    vlen: libc::c_uint,
+) -> libc::c_int {
+    let flags = 0;
+    let timeout = ptr::null_mut::<libc::timespec>();
+    let ret =
+        libc::syscall(libc::SYS_recvmmsg, sockfd, msgvec, vlen, flags, timeout) as libc::c_int;
+    if ret != -1 {
+        return ret;
+    }
+
+    let e = io::Error::last_os_error();
+    match e.raw_os_error() {
+        Some(libc::ENOSYS) => {
+            // Fallback to `recvmsg`.
+            recvmmsg_fallback(sockfd, msgvec, vlen)
+        }
+        _ => -1,
+    }
+}
+
+/// Fallback implementation of `recvmmsg` using `recvmsg`
+/// for systems which do not support `recvmmsg`
+/// such as Linux <2.6.33.
+#[cfg(not(any(target_os = "macos", target_os = "ios")))]
+unsafe fn recvmmsg_fallback(
+    sockfd: libc::c_int,
+    msgvec: *mut libc::mmsghdr,
+    vlen: libc::c_uint,
+) -> libc::c_int {
+    let flags = 0;
+    if vlen == 0 {
+        return 0;
+    }
+
+    let n = libc::recvmsg(sockfd, &mut (*msgvec).msg_hdr, flags);
+    if n == -1 {
+        -1
+    } else {
+        (*msgvec).msg_len = n as libc::c_uint;
+        1
+    }
+}
+
 /// Returns the platforms UDP socket capabilities
 pub fn udp_state() -> UdpState {
     UdpState {