WIP: Functions for accessing file data

create.sh

@@ -11,10 +11,14 @@ ed b_file
 B FILE
 .
 
+cat b_file
+
 ed c_file
 C FILE
 .
 
+cat c_file
+
 exit
 
 EOF

scheme/main.rs

@@ -123,7 +123,7 @@ impl FileScheme {
 }
 
 impl Scheme for FileScheme {
-    fn open(&mut self, url: &str, flags: usize, mode: usize) -> Result<usize> {
+    fn open(&mut self, url: &str, flags: usize, _mode: usize) -> Result<usize> {
         let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
 
         let mut nodes = Vec::new();
@@ -143,7 +143,11 @@ impl Scheme for FileScheme {
                     }
                 }
             } else {
-                data.extend_from_slice(&format!("{:#?}", node).as_bytes());
+                for i in 0..try!(self.fs.node_len(node.0)) {
+                    let mut sector = [0; 512];
+                    try!(self.fs.read_node(node.0, i as usize * 512, &mut sector));
+                    data.extend_from_slice(&sector);
+                }
             },
             Err(err) => if err.errno == ENOENT && flags & O_CREAT == O_CREAT {
                 let mut last_part = String::new();

src/filesystem.rs

@@ -322,7 +322,7 @@ impl FileSystem {
 
     pub fn read_node(&mut self, block: u64, offset: usize, buf: &mut [u8]) -> Result<usize> {
         let block_offset = offset / 512;
-        let byte_offset = offset % 512;
+        let mut byte_offset = offset % 512;
         let block_len = (buf.len() + byte_offset + 511)/512;
 
         let mut blocks = Vec::new();
@@ -330,9 +330,15 @@ impl FileSystem {
 
         let mut i = 0;
         for &block in blocks.iter() {
-            let mut sector = ['r' as u8; 512];
+            let mut sector = [0; 512];
             try!(self.disk.read_at(block, &mut sector));
-            i += 512;
+
+            for (s_b, mut b) in sector.iter().skip(byte_offset).zip((&mut buf[i..]).iter_mut()) {
+                *b = *s_b;
+                i += 1;
+            }
+
+            byte_offset = 0;
         }
 
         Ok(i)
@@ -340,7 +346,7 @@ impl FileSystem {
 
     pub fn write_node(&mut self, block: u64, offset: usize, buf: &[u8]) -> Result<usize> {
         let block_offset = offset / 512;
-        let byte_offset = offset % 512;
+        let mut byte_offset = offset % 512;
         let block_len = (buf.len() + byte_offset + 511)/512;
 
         try!(self.node_ensure_len(block, (block_offset + block_len) as u64));
@@ -350,11 +356,38 @@ impl FileSystem {
 
         let mut i = 0;
         for &block in blocks.iter() {
-            let sector = ['w' as u8; 512];
+            let mut sector = [0; 512];
+
+            for (mut s_b, b) in sector.iter_mut().skip(byte_offset).zip(buf[i..].iter()) {
+                *s_b = *b;
+                i += 1;
+            }
+
             try!(self.disk.write_at(block, &sector));
-            i += 512;
+
+            byte_offset = 0;
         }
 
         Ok(i)
     }
+
+    pub fn node_len(&mut self, block: u64) -> Result<u64> {
+        if block == 0 {
+            return Err(Error::new(ENOENT));
+        }
+
+        let mut size = 0;
+
+        let node = try!(self.node(block));
+        for extent in node.1.extents.iter() {
+            size += extent.length;
+        }
+
+        if node.1.next > 0 {
+            size += try!(self.node_len(node.1.next));
+            Ok(size)
+        } else {
+            Ok(size)
+        }
+    }
 }

utility/main.rs

@@ -7,6 +7,7 @@ extern crate system;
 use std::env;
 use std::io::{self, Write};
 use std::path::Path;
+use std::str;
 
 use redoxfs::{FileSystem, Node};
 
@@ -60,6 +61,24 @@ fn shell(mut fs: FileSystem){
                         Err(err) => println!("node: failed to read {}: {}", block, err)
                     }
                 },
+                "cat" => {
+                    if let Some(arg) = args.next() {
+                        match fs.find_node(arg, block) {
+                            Ok(node) => {
+                                println!("{}: {:#?}", node.0, node.1);
+
+                                let mut data = [0; 512];
+                                match fs.read_node(node.0, 0, &mut data) {
+                                    Ok(count) => println!("cat: read {} bytes\n{}", count, unsafe { str::from_utf8_unchecked(&data) }),
+                                    Err(err) => println!("cat: failed to read {}: {}", node.0, err)
+                                }
+                            }
+                            Err(err) => println!("cat: failed to create {}: {}", arg, err)
+                        }
+                    } else {
+                        println!("cat <path>");
+                    }
+                },
                 "cd" => {
                     if let Some(arg) = args.next() {
                         if arg == "." {
@@ -178,7 +197,7 @@ fn shell(mut fs: FileSystem){
                         println!("rmdir <dir>");
                     }
                 },
-                _ => println!("commands: exit header node root free find ls mk mkdir rm rmdir")
+                _ => println!("commands: exit header node root free cat ed find ls mk mkdir rm rmdir")
             }
         }
     }