Function open

euralios_std/src/server.rs:64–148

Open a file or directory This will create files but not directories

(mut dir: Arc<RwLock<dyn DirLike + Sync + Send>>, path: &Path, flags: u64)

///
/// This will create files but not directories
fn open(mut dir: Arc<RwLock<dyn DirLike + Sync + Send>>, path: &Path, flags: u64) -> Result<CommHandle, syscalls::SyscallError> {
    println!("[std:open] Opening {:?}", path);

    let mut path_iter = path.iter().peekable();
    while let Some(component) = path_iter.next()  {
        // Convert to a string for indexing
        let key = component.to_str().unwrap();

        let result_subdir = dir.read().get_dir(key);
        if let Ok(subdir) = result_subdir {
            if path_iter.peek().is_none() {
                // No further path components => Opening an existing directory
                let readwrite = (flags & message::O_WRITE) == message::O_WRITE;
                println!("Starting handle_directory({}, rw:{})", key, readwrite);

                // Make a new communication handle pair
                let (handle, client_handle) = syscalls::new_rendezvous()?;

                // Start a thread
                thread::spawn(move || {
                    handle_directory(subdir, handle, readwrite, |message| {
                        println!("[std:handle subdir] Unexpected message {:?}", message);
                    });
                })?; // Might fail to start a thread

                // Return the other handle to the client
                return Ok(client_handle)
            } else {
                // Further components => Move to subdirectory
                dir = subdir;
            }
        } else {
            let result_file = dir.read().get_file(key);
            if let Ok(file) = result_file {
                if path_iter.peek().is_some() {
                    println!("Error opening path {:?}: {} is a file not a directory", path, key);
                    return Err(syscalls::SYSCALL_ERROR_NOT_DIR);
                }
                // No more components -> Opening an existing file

                if (flags & message::O_TRUNCATE) == message::O_TRUNCATE {
                    // Delete contents
                    file.write().clear()?;
                }

                // Make a new communication handle pair
                let (handle, client_handle) = syscalls::new_rendezvous()?;

                // Start a thread
                if (flags & message::O_WRITE) == message::O_WRITE {
                    thread::spawn(move || {
                        handle_file_readwrite(file, handle);
                    })?; // Might fail to start thread
                } else {
                    thread::spawn(move || {
                        handle_file_readonly(file, handle);
                    })?;
                }