1 files changed, 95 insertions, 3 deletions

diff --git a/src/mft.rs b/src/mft.rs
index 6654f65..802f381 100644
--- a/src/mft.rs
+++ b/src/mft.rs
@@ -1,4 +1,6 @@
 use seek_bufread::BufReader;
+use enumerator::{PathEnumerator,PathMapping};
+use rwinstructs::reference::{MftReference};
 use errors::{MftError};
 use entry::{MftEntry};
 use std::fs::File;
@@ -9,6 +11,7 @@ use std::mem;
 
 pub struct MftHandler {
     filehandle: BufReader<File>,
+    path_enumerator: PathEnumerator,
     _entry_size: u32,
     _offset: u64,
     _size: u64
@@ -55,17 +58,40 @@ impl MftHandler{
         ).unwrap();
 
         let mut entry_buffer = vec![0; self._entry_size as usize];
-        self.filehandle.read_exact(&mut entry_buffer)?;
+        self.filehandle.read_exact(
+            &mut entry_buffer
+        )?;
 
-        let mft_entry = self.entry_from_buffer(
+        let mut mft_entry = self.entry_from_buffer(
             entry_buffer,
             entry
         )?;
 
+        // We need to set the path if dir
+        match mft_entry.get_pathmap() {
+            Some(mapping) => {
+                if mft_entry.is_dir() {
+                    &self.path_enumerator.set_mapping(
+                        mft_entry.header.entry_reference.clone().unwrap(),
+                        mapping.clone()
+                    );
+                }
+            },
+            None    => {},
+        }
+
+        mft_entry.set_fullnames(
+            self
+        );
+
         Ok(mft_entry)
     }
 
-    pub fn entry_from_buffer(&mut self, mut buffer: Vec<u8>, entry: u64) -> Result<MftEntry,MftError> {
+    pub fn print_mapping(&self){
+        self.path_enumerator.print_mapping();
+    }
+
+    pub fn entry_from_buffer(&mut self, buffer: Vec<u8>, entry: u64) -> Result<MftEntry,MftError> {
         let mft_entry = MftEntry::new(
             buffer,
             Some(entry)
@@ -73,4 +99,70 @@ impl MftHandler{
 
         Ok(mft_entry)
     }
+
+    pub fn get_fullpath(&mut self, reference: MftReference) -> String {
+        let mut path_stack = Vec::new();
+        self.enumerate_path_stack(
+            &mut path_stack,
+            reference
+        );
+        path_stack.join("/")
+    }
+
+    fn enumerate_path_stack(&mut self, name_stack: &mut Vec<String>, reference: MftReference) {
+        // 1407374883553285 (5-5)
+        if reference.0 == 1407374883553285 {
+
+        }
+        else {
+            match self.path_enumerator.get_mapping(reference){
+                Some(mapping) => {
+                    self.enumerate_path_stack(
+                        name_stack,
+                        mapping.parent.clone()
+                    );
+                    name_stack.push(
+                        mapping.name.clone()
+                    );
+                },
+                None => {
+                    // Mapping not exists
+                    // Get entry number for this reference that does not exist
+                    let entry = reference.get_entry_number();
+                    // Gat mapping for it
+                    match self.get_mapping_from_entry(entry) {
+                        Some(mapping) => {
+                            self.path_enumerator.set_mapping(
+                                reference,
+                                mapping.clone()
+                            );
+                            self.enumerate_path_stack(
+                                name_stack,
+                                reference
+                            );
+                        },
+                        None => {}
+                    }
+                }
+            }
+        }
+    }
+
+    fn get_mapping_from_entry(&mut self, entry: u64) -> Option<PathMapping>{
+        self.filehandle.seek(
+            SeekFrom::Start(entry * self._entry_size as u64)
+        );
+
+        let mut entry_buffer = vec![0; self._entry_size as usize];
+        self.filehandle.read_exact(
+            &mut entry_buffer
+        );
+
+        let mut mft_entry = self.entry_from_buffer(
+            entry_buffer,
+            entry
+        );
+
+        mft_entry.unwrap().get_pathmap()
+    }
 }