wasmer/lib/emscripten/src/syscalls/unix/select.rs

use wasmer_runtime_core::vm::Ctx;
use crate::varargs::VarArgs;
use std::collections::HashMap;
use std::slice;
use crate::syscalls::emscripten_vfs::{FileHandle, VirtualFd};
use std::ffi::c_void;
use crate::macros::emscripten_memory_ptr;

#[cfg(feature = "vfs")]
#[derive(Debug)]
struct FdPair {
    pub virtual_fd: i32,
    pub host_fd: i32,
}

#[cfg(feature = "vfs")]
fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs, nfds: i32, fds_set_offset: u32) -> (i32, HashMap<i32, i32>, Vec<FdPair>) {

    let set_ptr = emscripten_memory_ptr(ctx.memory(0), fds_set_offset) as *mut _; // e.g. libc::unix::bsd::fd_set
    let set_u8_ptr = set_ptr as *mut u8;

    let bit_array_size = if nfds >= 0 { (nfds + 7) / 8 } else { 0 } as usize;
    let end_offset = fds_set_offset as usize + bit_array_size;
    let set_view = &ctx.memory(0).view::<u8>()[(fds_set_offset as usize)..end_offset];
    use bit_field::BitArray;
//    let check = set_ptr.get_bit(1);

    let fds_slice = unsafe { slice::from_raw_parts(set_u8_ptr, bit_array_size) };

//    (0usize..nfds as usize).filter_map(|x| fds_slice.get_bit(x));
//    let ofds = (0..nfds).filter_map(|v| fd_slice.v)
    let original_fds: Vec<i32> = (0..nfds)
        .filter_map(|virtual_fd| {
            if fds_slice.get_bit(virtual_fd as usize) {
                Some(virtual_fd as i32)
            } else {
                None
            }
        }).collect::<Vec<_>>();

    let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();

    // virtual read and write file descriptors
    let file_descriptor_pairs = original_fds.iter()
        .filter(|vfd| {
            if let FileHandle::VirtualFile(handle) = vfs.fd_map.get(&VirtualFd(**vfd)).unwrap() {
                debug!("skipping virtual fd {} (vbox handle {}) because is a virtual file", *vfd, *handle);
                false
            }
            else {
                true
            }
        })
        .map(|vfd| {
            let vfd = VirtualFd(*vfd);
            let file_handle = vfs.fd_map.get(&vfd).unwrap();
            let host_fd = match file_handle {
                FileHandle::Socket(host_fd) => host_fd,
//                FileHandle::VirtualFile(handle) => handle,
                _ => panic!(),
            };
            let pair = FdPair {
                virtual_fd: vfd.0,
                host_fd: *host_fd,
            };
            // swap the read descriptors
            unsafe {
                libc::FD_CLR(pair.virtual_fd, set_ptr);
                libc::FD_SET(pair.host_fd, set_ptr);
            };
            pair
        })
        .collect::<Vec<_>>();

    let mut sz = 0;

    // helper look up tables
    let mut lookup = HashMap::new();
    for pair in file_descriptor_pairs.iter() {
//        if pair.virtual_fd > sz { sz = pair.host_fd }
        if pair.host_fd > sz { sz = pair.host_fd }
        lookup.insert(pair.host_fd, pair.virtual_fd);
    }

    let max_file_descriptor = sz;
    (max_file_descriptor, lookup, file_descriptor_pairs)
}


#[cfg(feature = "vfs")]
fn translate_to_virtual_file_descriptors(ctx: &mut Ctx, nfds: i32, fds_set_offset: u32, lookup: HashMap<i32, i32>) -> Vec<FdPair> {
    let set_ptr = emscripten_memory_pointer!(ctx.memory(0), fds_set_offset) as *mut _;
    let set_u8_ptr = set_ptr as *mut u8;
    let fds_slice = unsafe { slice::from_raw_parts_mut(set_u8_ptr, nfds as usize) };
    use bit_field::BitArray;

    let fds = (0..nfds)
        .filter_map(|virtual_fd| {
            if fds_slice.get_bit(virtual_fd as usize) {
                Some(virtual_fd as i32)
            } else {
                None
            }
        }).collect::<Vec<_>>();

    // swap descriptors back
    let pairs = fds.iter()
        .filter_map(|host_fd| {
            lookup.get(&host_fd).map(|virtual_fd| (*virtual_fd, host_fd))
        })
        .map(|(virtual_fd, host_fd)| {
            unsafe {
                libc::FD_CLR(*host_fd, set_ptr);
                libc::FD_SET(virtual_fd, set_ptr);
            }
            FdPair { virtual_fd, host_fd: *host_fd }
        }).collect::<Vec<_>>();
    pairs
}

/// select
#[cfg(feature = "vfs")]
#[allow(clippy::cast_ptr_alignment)]
pub fn ___syscall142(ctx: &mut Ctx, _which: libc::c_int, mut varargs: VarArgs) -> libc::c_int {
    debug!("emscripten::___syscall142 (newselect) {}", _which);
    let nfds: i32 = varargs.get(ctx);
    let readfds: u32 = varargs.get(ctx);
    let writefds: u32 = varargs.get(ctx);
    let _exceptfds: u32 = varargs.get(ctx);
    let timeout: i32 = varargs.get(ctx);
    assert!(nfds <= 64, "`nfds` must be less than or equal to 64");
    let readfds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as *mut _;
    let writefds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as *mut _;

//    debug!(" select read descriptors: {:?}", read_fds);
//
//    debug!("select write descriptors: {:?}", write_fds);

    let (read_max, read_lookup, read_pairs)
        = translate_to_host_file_descriptors(ctx, &mut varargs, nfds, readfds);
    let (write_max, write_lookup, write_pairs)
        = translate_to_host_file_descriptors(ctx, &mut varargs, nfds, writefds);

    let max = if read_max > write_max { read_max } else { write_max };

    let mut sz = max;

    debug!("set read descriptors BEFORE select: {:?}", read_pairs);
    debug!("set write descriptors BEFORE select: {:?}", write_pairs);

    // call `select`
    sz = sz + 1;
    let mut result = unsafe { libc::select(sz, readfds_set_ptr, writefds_set_ptr, 0 as _, 0 as _) };

    if result == -1 {
        panic!("result returned from select was -1. The errno code: {}", errno::errno());
    }

    let read_pairs = translate_to_virtual_file_descriptors(ctx, sz, readfds, read_lookup);
    debug!("select read descriptors after select completes: {:?}", read_pairs);

    let write_pairs = translate_to_virtual_file_descriptors(ctx, sz, writefds, write_lookup);
    debug!("select write descriptors after select completes: {:?}", write_pairs);

    debug!("select returns {}", result);
    result
}