Delete fastsearch-core

fastsearch-core/Cargo.toml

@@ -1,35 +0,0 @@
-[package]
-name = "fastsearch-core"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-windows = { version = "0.60", features = [
-    "Win32_Storage_FileSystem",
-    "Win32_Security",
-    "Win32_System_Ioctl",
-    "Win32_System_IO",
-    "Win32_Foundation",
-    "Win32_System_Threading",
-    "Win32_System_LibraryLoader",
-    "Win32_UI",
-    "Win32_Graphics_Gdi",
-    "Win32_Graphics_Dwm",
-    "Win32_UI_Input",
-    "Win32_UI_WindowsAndMessaging",
-    "Win32_UI_Shell",
-    "Win32_UI_Input_KeyboardAndMouse",
-    "Win32_System_Diagnostics_Debug",
-    "Win32_System_Pipes",
-] }
-rayon = "1.10"
-crossbeam-channel = "0.5"
-fuzzy-matcher = "0.3"
-once_cell = "1.19"
-parking_lot = "0.12"
-bincode = "1.3"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1.0"
-lz4_flex = "0.11"
-ctrlc = "3.5"
-memmap2 = "0.9"

fastsearch-core/src/index/mod.rs

@@ -1,2 +0,0 @@
-pub mod search;
-pub mod store;

fastsearch-core/src/index/search.rs

@@ -1,126 +0,0 @@
-use rayon::prelude::*;
-use crate::index::store::IndexStore;
-
-const APP_EXTENSIONS: &[&str] = &["exe", "lnk", "msi", "appx", "msix"];
-const APP_PATH_MARKERS: &[&str] = &[
-    "\\program files\\", "\\program files (x86)\\",
-    "\\start menu\\", "\\desktop\\", "\\appdata\\",
-];
-
-#[derive(Debug, Clone)]
-pub struct SearchResult {
-    pub full_path: std::path::PathBuf,
-    pub name: String,
-    pub rank: u8,
-    pub is_dir: bool,
-}
-
-pub fn search(
-    store: &IndexStore,
-    query: &str,
-    limit: usize,
-    case_sensitive: bool,
-    excluded_dirs: &[String],
-) -> Vec<SearchResult> {
-    if query.is_empty() {
-        return Vec::new();
-    }
-
-    let q = if case_sensitive { query.to_string() } else { query.to_lowercase() };
-
-    let entries = &store.entries;
-    let name_lower_arena = &store.name_lower_arena;
-    let name_arena = &store.name_arena;
-
-    let mut candidates: Vec<(u32, u8)> = entries
-        .par_iter()
-        .enumerate()
-        .filter_map(|(idx, entry)| {
-            let name_cmp = if case_sensitive {
-                unsafe { std::str::from_utf8_unchecked(&name_arena[entry.name_off as usize..(entry.name_off as usize + entry.name_len as usize)]) }
-            } else {
-                unsafe { std::str::from_utf8_unchecked(&name_lower_arena[entry.name_lower_off as usize..(entry.name_lower_off as usize + entry.name_lower_len as usize)]) }
-            };
-
-            let rank = if name_cmp == q { 1u8 }
-                else if name_cmp.starts_with(&q) { 2 }
-                else if name_cmp.contains(q.as_str()) { 3 }
-                else { return None; };
-
-            Some((idx as u32, rank))
-        })
-        .collect();
-
-    candidates.sort_unstable_by_key(|&(_, rank)| rank);
-    let overshoot = (limit * 5).max(1000);
-    candidates.truncate(overshoot);
-
-    let mut results: Vec<SearchResult> = Vec::with_capacity(limit);
-
-    for &(idx, base_rank) in &candidates {
-        let entry = &entries[idx as usize];
-        let full_path = build_path(entry.file_ref, store);
-
-        if !excluded_dirs.is_empty() {
-            let path_lower = full_path.to_string_lossy().to_lowercase();
-            if excluded_dirs.iter().any(|ex| path_lower.starts_with(ex.as_str())) {
-                continue;
-            }
-        }
-
-        let name_lower = store.name_lower(entry);
-        let rank = if base_rank <= 2 {
-            let ext_is_app = name_lower
-                .rsplit('.')
-                .next()
-                .map(|e| APP_EXTENSIONS.contains(&e))
-                .unwrap_or(false);
-            if ext_is_app {
-                let path_lower = full_path.to_string_lossy().to_lowercase();
-                if APP_PATH_MARKERS.iter().any(|m| path_lower.contains(m)) { 0 } else { base_rank }
-            } else {
-                base_rank
-            }
-        } else {
-            base_rank
-        };
-
-        results.push(SearchResult {
-            full_path,
-            name: store.name(entry).to_string(),
-            rank,
-            is_dir: entry.is_dir(),
-        });
-    }
-
-    results.sort_unstable_by_key(|r| r.rank);
-    results.truncate(limit);
-    results
-}
-
-/// Iterative path builder — walks parent chain via sorted ref_lookup.
-pub fn build_path(file_ref: u64, store: &IndexStore) -> std::path::PathBuf {
-    let mut components: Vec<&str> = Vec::with_capacity(16);
-    let mut current = file_ref;
-
-    for _ in 0..64 {
-        match store.lookup_idx(current) {
-            Some(idx) => {
-                let entry = &store.entries[idx as usize];
-                components.push(store.name(entry));
-                if entry.parent_ref == current {
-                    break;
-                }
-                current = entry.parent_ref;
-            }
-            None => break,
-        }
-    }
-
-    components.reverse();
-    let mut path = std::path::PathBuf::from(&store.drive_root);
-    for comp in components {
-        path.push(comp);
-    }
-    path
-}

fastsearch-core/src/index/store.rs

@@ -1,252 +0,0 @@
-#![allow(dead_code)]
-use serde::{Serialize, Deserialize};
-use crate::mft::types::{FileKind, FileRecord, JournalCheckpoint};
-use crate::mft::reader::ScanResult;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CachedEntry {
-    pub file_ref: u64,
-    pub parent_ref: u64,
-    pub name: String,
-    pub kind: FileKind,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct CacheData {
-    pub entries: Vec<CachedEntry>,
-    pub drive_root: String,
-    pub checkpoints: Vec<JournalCheckpoint>,
-}
-
-#[derive(Clone)]
-pub struct IndexEntry {
-    pub file_ref: u64,
-    pub parent_ref: u64,
-    pub name_off: u32,
-    pub name_lower_off: u32,
-    pub name_len: u16,
-    pub name_lower_len: u16,
-    pub flags: u8,
-}
-
-impl IndexEntry {
-    #[inline]
-    pub fn is_dir(&self) -> bool {
-        self.flags & 1 != 0
-    }
-
-    #[inline]
-    pub fn kind(&self) -> FileKind {
-        if self.is_dir() { FileKind::Directory } else { FileKind::File }
-    }
-}
-
-pub struct IndexStore {
-    pub entries: Vec<IndexEntry>,
-    pub name_arena: Vec<u8>,
-    pub name_lower_arena: Vec<u8>,
-    pub ref_lookup: Vec<(u64, u32)>,
-    pub drive_root: String,
-    pub checkpoints: Vec<JournalCheckpoint>,
-}
-
-impl IndexStore {
-    pub fn new() -> Self {
-        Self {
-            entries: Vec::new(),
-            name_arena: Vec::new(),
-            name_lower_arena: Vec::new(),
-            ref_lookup: Vec::new(),
-            drive_root: String::new(),
-            checkpoints: Vec::new(),
-        }
-    }
-
-    #[inline]
-    pub fn name(&self, e: &IndexEntry) -> &str {
-        unsafe {
-            std::str::from_utf8_unchecked(
-                &self.name_arena[e.name_off as usize..(e.name_off as usize + e.name_len as usize)]
-            )
-        }
-    }
-
-    #[inline]
-    pub fn name_lower(&self, e: &IndexEntry) -> &str {
-        unsafe {
-            std::str::from_utf8_unchecked(
-                &self.name_lower_arena[e.name_lower_off as usize..(e.name_lower_off as usize + e.name_lower_len as usize)]
-            )
-        }
-    }
-
-    pub fn lookup_idx(&self, file_ref: u64) -> Option<u32> {
-        self.ref_lookup
-            .binary_search_by_key(&file_ref, |&(r, _)| r)
-            .ok()
-            .map(|pos| self.ref_lookup[pos].1)
-    }
-
-    fn rebuild_ref_lookup(&mut self) {
-        self.ref_lookup.clear();
-        self.ref_lookup.reserve(self.entries.len());
-        for (i, e) in self.entries.iter().enumerate() {
-            self.ref_lookup.push((e.file_ref, i as u32));
-        }
-        self.ref_lookup.sort_unstable_by_key(|&(r, _)| r);
-    }
-
-    pub fn populate_from_scan(&mut self, scan: ScanResult, drive_root: &str) {
-        self.drive_root = drive_root.to_string();
-        let count = scan.records.len();
-        self.entries.reserve(count);
-        self.name_arena.reserve(count * 30);
-        self.name_lower_arena.reserve(count * 30);
-
-        for r in &scan.records {
-            let name_slice = &scan.name_data[r.name_off as usize..(r.name_off as usize + r.name_len as usize)];
-            let name = String::from_utf16_lossy(name_slice);
-            let name_lower = name.to_lowercase();
-
-            let n_off = self.name_arena.len() as u32;
-            let n_len = name.len() as u16;
-            self.name_arena.extend_from_slice(name.as_bytes());
-
-            let nl_off = self.name_lower_arena.len() as u32;
-            let nl_len = name_lower.len() as u16;
-            self.name_lower_arena.extend_from_slice(name_lower.as_bytes());
-
-            self.entries.push(IndexEntry {
-                file_ref: r.file_ref,
-                parent_ref: r.parent_ref,
-                name_off: n_off,
-                name_lower_off: nl_off,
-                name_len: n_len,
-                name_lower_len: nl_len,
-                flags: if r.is_dir { 1 } else { 0 },
-            });
-        }
-    }
-
-    pub fn finalize(&mut self) {
-        let store_ptr = self as *const IndexStore;
-        self.entries.sort_unstable_by(|a, b| {
-            let s = unsafe { &*store_ptr };
-            s.name_lower(a).cmp(s.name_lower(b))
-        });
-        self.rebuild_ref_lookup();
-        self.name_arena.shrink_to_fit();
-        self.name_lower_arena.shrink_to_fit();
-    }
-
-    pub fn to_cache(&self) -> CacheData {
-        CacheData {
-            entries: self.entries.iter().map(|e| CachedEntry {
-                file_ref: e.file_ref,
-                parent_ref: e.parent_ref,
-                name: self.name(e).to_string(),
-                kind: e.kind(),
-            }).collect(),
-            drive_root: self.drive_root.clone(),
-            checkpoints: self.checkpoints.clone(),
-        }
-    }
-
-    pub fn from_cache(cache: CacheData) -> Self {
-        let count = cache.entries.len();
-        let mut store = Self {
-            entries: Vec::with_capacity(count),
-            name_arena: Vec::with_capacity(count * 30),
-            name_lower_arena: Vec::with_capacity(count * 30),
-            ref_lookup: Vec::with_capacity(count),
-            drive_root: cache.drive_root,
-            checkpoints: cache.checkpoints,
-        };
-
-        for c in cache.entries {
-            let name_lower = c.name.to_lowercase();
-
-            let n_off = store.name_arena.len() as u32;
-            let n_len = c.name.len() as u16;
-            store.name_arena.extend_from_slice(c.name.as_bytes());
-
-            let nl_off = store.name_lower_arena.len() as u32;
-            let nl_len = name_lower.len() as u16;
-            store.name_lower_arena.extend_from_slice(name_lower.as_bytes());
-
-            let flags = match c.kind {
-                FileKind::Directory => 1u8,
-                FileKind::File => 0u8,
-            };
-
-            store.entries.push(IndexEntry {
-                file_ref: c.file_ref,
-                parent_ref: c.parent_ref,
-                name_off: n_off,
-                name_lower_off: nl_off,
-                name_len: n_len,
-                name_lower_len: nl_len,
-                flags,
-            });
-        }
-
-        store.rebuild_ref_lookup();
-        store.name_arena.shrink_to_fit();
-        store.name_lower_arena.shrink_to_fit();
-        store
-    }
-
-    pub fn insert(&mut self, record: FileRecord) {
-        let name_lower = record.name.to_lowercase();
-
-        let n_off = self.name_arena.len() as u32;
-        let n_len = record.name.len() as u16;
-        self.name_arena.extend_from_slice(record.name.as_bytes());
-
-        let nl_off = self.name_lower_arena.len() as u32;
-        let nl_len = name_lower.len() as u16;
-        self.name_lower_arena.extend_from_slice(name_lower.as_bytes());
-
-        let flags = match record.kind {
-            FileKind::Directory => 1u8,
-            FileKind::File => 0u8,
-        };
-
-        let entry = IndexEntry {
-            file_ref: record.file_ref,
-            parent_ref: record.parent_ref,
-            name_off: n_off,
-            name_lower_off: nl_off,
-            name_len: n_len,
-            name_lower_len: nl_len,
-            flags,
-        };
-
-        let store_ptr = self as *const IndexStore;
-        let pos = self.entries.partition_point(|e| {
-            let s = unsafe { &*store_ptr };
-            s.name_lower(e) < name_lower.as_str()
-        });
-        self.entries.insert(pos, entry);
-        self.rebuild_ref_lookup();
-    }
-
-    pub fn remove(&mut self, file_ref: u64) {
-        self.entries.retain(|e| e.file_ref != file_ref);
-        self.rebuild_ref_lookup();
-    }
-
-    pub fn rename(&mut self, old_ref: u64, new_record: FileRecord) {
-        self.remove(old_ref);
-        self.insert(new_record);
-    }
-
-    pub fn apply_move(&mut self, file_ref: u64, new_parent_ref: u64, name: String, kind: FileKind) {
-        self.remove(file_ref);
-        self.insert(FileRecord { file_ref, parent_ref: new_parent_ref, name, kind });
-    }
-
-    pub fn len(&self) -> usize {
-        self.entries.len()
-    }
-}

fastsearch-core/src/lib.rs

@@ -1,12 +0,0 @@
-#![allow(dead_code)]
-
-pub mod index;
-pub mod mft;
-pub mod utils;
-
-pub use index::search::{SearchResult, search, build_path};
-pub use index::store::{IndexStore, CacheData};
-pub use mft::types::*;
-pub use mft::reader::{MftReader, ScanResult};
-pub use mft::watcher::UsnWatcher;
-pub use utils::drives::get_ntfs_drives;

fastsearch-core/src/mft/mod.rs

@@ -1,3 +0,0 @@
-pub mod reader;
-pub mod types;
-pub mod watcher;

fastsearch-core/src/mft/reader.rs

@@ -1,387 +0,0 @@
-
-#![allow(dead_code)]
-
-use std::mem;
-use windows::{
-    core::PCWSTR,
-    Win32::Foundation::HANDLE,
-    Win32::Storage::FileSystem::{
-        CreateFileW, ReadFile, SetFilePointerEx,
-        FILE_BEGIN, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_SEQUENTIAL_SCAN,
-        FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
-    },
-    Win32::System::Ioctl::{
-        FSCTL_ENUM_USN_DATA, MFT_ENUM_DATA_V0, USN_RECORD_V2,
-    },
-    Win32::System::IO::DeviceIoControl,
-};
-
-use crate::mft::types::NtfsDrive;
-
-const FALLBACK_BUF: usize = 4 * 1024 * 1024;
-const DIRECT_BUF: usize = 4 * 1024 * 1024;
-
-pub struct CompactRecord {
-    pub file_ref: u64,
-    pub parent_ref: u64,
-    pub name_off: u32,
-    pub name_len: u16,
-    pub is_dir: bool,
-}
-
-pub struct ScanResult {
-    pub records: Vec<CompactRecord>,
-    pub name_data: Vec<u16>,
-}
-
-pub struct MftReader {
-    handle: HANDLE,
-    pub drive: NtfsDrive,
-}
-
-impl MftReader {
-    pub fn open(drive: &NtfsDrive) -> windows::core::Result<Self> {
-        let path: Vec<u16> = drive
-            .device_path
-            .encode_utf16()
-            .chain(Some(0))
-            .collect();
-
-        let handle = unsafe {
-            CreateFileW(
-                PCWSTR(path.as_ptr()),
-                0x80000000u32,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                None,
-                OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS,
-                None,
-            )?
-        };
-
-        Ok(Self {
-            handle,
-            drive: drive.clone(),
-        })
-    }
-
-    pub fn scan_direct(&self) -> Option<ScanResult> {
-        let record_size = self.read_mft_record_size()?;
-
-        let mft_path = format!("{}$MFT", self.drive.root);
-        let mft_wide: Vec<u16> = mft_path.encode_utf16().chain(Some(0)).collect();
-
-        let mft_handle = unsafe {
-            CreateFileW(
-                PCWSTR(mft_wide.as_ptr()),
-                0x80000000u32,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                None,
-                OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_SEQUENTIAL_SCAN,
-                None,
-            )
-            .ok()?
-        };
-
-        let mut records: Vec<CompactRecord> = Vec::with_capacity(3_000_000);
-        let mut name_data: Vec<u16> = Vec::with_capacity(40_000_000);
-        let mut buffer = vec![0u8; DIRECT_BUF];
-        let mut mft_index: u64 = 0;
-        let mut leftover = 0usize;
-
-        loop {
-            let mut bytes_read = 0u32;
-            let ok = unsafe {
-                ReadFile(
-                    mft_handle,
-                    Some(&mut buffer[leftover..]),
-                    Some(&mut bytes_read),
-                    None,
-                )
-            };
-            if ok.is_err() || bytes_read == 0 {
-                break;
-            }
-
-            let total = leftover + bytes_read as usize;
-            let mut offset = 0usize;
-
-            while offset + record_size <= total {
-                let applied =
-                    Self::apply_fixup(&mut buffer[offset..offset + record_size], record_size);
-            
-                if applied {
-                    Self::parse_file_record(
-                        &buffer[offset..offset + record_size],
-                        mft_index,
-                        &mut records,
-                        &mut name_data,
-                    );
-                }
-            
-                mft_index += 1;
-                offset += record_size;
-            }
-
-            offset = total - (total % record_size);
-
-            leftover = total - offset;
-            if leftover > 0 {
-                unsafe {
-                    std::ptr::copy(
-                        buffer.as_ptr().add(offset),
-                        buffer.as_mut_ptr(),
-                        leftover,
-                    );
-                }
-            }
-        }
-
-        unsafe {
-            windows::Win32::Foundation::CloseHandle(mft_handle).ok();
-        }
-
-        Some(ScanResult { records, name_data })
-    }
-
-    pub fn scan(&self) -> ScanResult {
-        let mut records: Vec<CompactRecord> = Vec::with_capacity(3_000_000);
-        let mut name_data: Vec<u16> = Vec::with_capacity(40_000_000);
-
-        let mut enum_data = MFT_ENUM_DATA_V0 {
-            StartFileReferenceNumber: 0,
-            LowUsn: 0,
-            HighUsn: i64::MAX,
-        };
-
-        let mut buffer = vec![0u8; FALLBACK_BUF];
-
-        loop {
-            let mut bytes_returned: u32 = 0;
-
-            let ok = unsafe {
-                DeviceIoControl(
-                    self.handle,
-                    FSCTL_ENUM_USN_DATA,
-                    Some(&enum_data as *const _ as *const _),
-                    mem::size_of::<MFT_ENUM_DATA_V0>() as u32,
-                    Some(buffer.as_mut_ptr() as *mut _),
-                    FALLBACK_BUF as u32,
-                    Some(&mut bytes_returned),
-                    None,
-                )
-            };
-
-            if let Err(e) = ok {
-                let code = e.code().0 as u32;
-                if code == 0x80070026 {
-                    break;
-                }
-                eprintln!("MFT error on {}: {:?}", self.drive.letter, e);
-                break;
-            }
-
-            if bytes_returned <= 8 {
-                break;
-            }
-
-            let next_ref = u64::from_ne_bytes(buffer[0..8].try_into().unwrap());
-            enum_data.StartFileReferenceNumber = next_ref;
-
-            let mut offset = 8usize;
-            while offset + mem::size_of::<USN_RECORD_V2>() <= bytes_returned as usize {
-                let record = unsafe {
-                    &*(buffer.as_ptr().add(offset) as *const USN_RECORD_V2)
-                };
-
-                let rec_len = record.RecordLength as usize;
-                if rec_len == 0 || offset + rec_len > bytes_returned as usize {
-                    break;
-                }
-
-                let name_offset = record.FileNameOffset as usize;
-                let name_len = record.FileNameLength as usize / 2;
-                let name_ptr = unsafe {
-                    buffer.as_ptr().add(offset + name_offset) as *const u16
-                };
-                let name_slice = unsafe { std::slice::from_raw_parts(name_ptr, name_len) };
-
-                let arena_off = name_data.len() as u32;
-                name_data.extend_from_slice(name_slice);
-
-                records.push(CompactRecord {
-                    file_ref: record.FileReferenceNumber as u64,
-                    parent_ref: record.ParentFileReferenceNumber as u64,
-                    name_off: arena_off,
-                    name_len: name_len as u16,
-                    is_dir: (record.FileAttributes & 0x10) != 0,
-                });
-
-                offset += rec_len;
-            }
-        }
-
-        ScanResult { records, name_data }
-    }
-
-    fn read_mft_record_size(&self) -> Option<usize> {
-        unsafe {
-            SetFilePointerEx(self.handle, 0, None, FILE_BEGIN).ok()?;
-        }
-        let mut boot = [0u8; 512];
-        let mut br = 0u32;
-        unsafe {
-            ReadFile(self.handle, Some(&mut boot), Some(&mut br), None).ok()?;
-        }
-        if br < 512 || &boot[3..7] != b"NTFS" {
-            return None;
-        }
-
-        let bytes_per_sector = u16::from_le_bytes([boot[0x0B], boot[0x0C]]) as usize;
-        let sectors_per_cluster = boot[0x0D] as usize;
-        let cluster_size = bytes_per_sector * sectors_per_cluster;
-
-        let raw = boot[0x40] as i8;
-        let record_size = if raw > 0 {
-            raw as usize * cluster_size
-        } else {
-            1usize << (-(raw as i32) as usize)
-        };
-
-        Some(record_size)
-    }
-
-    fn apply_fixup(record: &mut [u8], record_size: usize) -> bool {
-        if record.len() < 48 || &record[0..4] != b"FILE" {
-            return false;
-        }
-
-        let fixup_off = u16::from_le_bytes([record[4], record[5]]) as usize;
-        let fixup_cnt = u16::from_le_bytes([record[6], record[7]]) as usize;
-
-        if fixup_cnt < 2 || fixup_off + fixup_cnt * 2 > record_size {
-            return false;
-        }
-
-        let check = [record[fixup_off], record[fixup_off + 1]];
-
-        for i in 1..fixup_cnt {
-            let end = i * 512 - 2;
-            if end + 1 >= record_size {
-                break;
-            }
-            if record[end] != check[0] || record[end + 1] != check[1] {
-                return false;
-            }
-            record[end] = record[fixup_off + i * 2];
-            record[end + 1] = record[fixup_off + i * 2 + 1];
-        }
-
-        true
-    }
-
-    fn parse_file_record(
-        record: &[u8],
-        mft_index: u64,
-        records: &mut Vec<CompactRecord>,
-        name_data: &mut Vec<u16>,
-    ) {
-        let flags = u16::from_le_bytes([record[0x16], record[0x17]]);
-        if flags & 0x01 == 0 {
-            return;
-        }
-    
-        let is_dir = flags & 0x02 != 0;
-        let seq = u16::from_le_bytes([record[0x10], record[0x11]]) as u64;
-        let file_ref = mft_index | (seq << 48);
-    
-        let first_attr = u16::from_le_bytes([record[0x14], record[0x15]]) as usize;
-        let mut aoff = first_attr;
-    
-        let mut best_ns: u8 = 255;
-        let mut best_name: Option<(usize, usize, u64)> = None;
-    
-        while aoff + 8 <= record.len() {
-            let atype = u32::from_le_bytes(record[aoff..aoff + 4].try_into().unwrap());
-    
-            if atype == 0xFFFF_FFFF {
-                break;
-            }
-    
-            let alen =
-                u32::from_le_bytes(record[aoff + 4..aoff + 8].try_into().unwrap()) as usize;
-    
-            if alen == 0 || aoff + alen > record.len() {
-                break;
-            }
-    
-            if atype == 0x30 && record[aoff + 8] == 0 {
-                let vlen =
-                    u32::from_le_bytes(record[aoff + 16..aoff + 20].try_into().unwrap()) as usize;
-    
-                let voff =
-                    u16::from_le_bytes([record[aoff + 20], record[aoff + 21]]) as usize;
-    
-                let vs = aoff + voff;
-    
-                if vs + 66 <= record.len() && vlen >= 66 {
-                    let parent =
-                        u64::from_le_bytes(record[vs..vs + 8].try_into().unwrap());
-    
-                    let nlen = record[vs + 64] as usize;
-                    let ns = record[vs + 65];
-    
-                    if vs + 66 + nlen * 2 <= record.len() {
-                        if ns == 2 {
-                            continue;
-                        }
-    
-                        let priority = match ns {
-                            1 => 0,
-                            3 => 1,
-                            0 => 2,
-                            _ => 3,
-                        };
-    
-                        if priority < best_ns {
-                            best_ns = priority;
-                            best_name = Some((vs + 66, nlen, parent));
-                        
-                            if priority == 0 {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-    
-            aoff += alen;
-        }
-    
-        if let Some((name_pos, nlen, parent)) = best_name {
-            let arena_off = name_data.len() as u32;
-    
-            for i in 0..nlen {
-                let p = name_pos + i * 2;
-                name_data.push(u16::from_le_bytes([record[p], record[p + 1]]));
-            }
-    
-            records.push(CompactRecord {
-                file_ref,
-                parent_ref: parent,
-                name_off: arena_off,
-                name_len: nlen as u16,
-                is_dir,
-            });
-        }
-    }
-
-}
-
-
-impl Drop for MftReader {
-    fn drop(&mut self) {
-        unsafe { windows::Win32::Foundation::CloseHandle(self.handle).ok() };
-    }
-}

fastsearch-core/src/mft/types.rs

@@ -1,37 +0,0 @@
-use serde::{Serialize, Deserialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum FileKind {
-    File,
-    Directory,
-}
-
-#[derive(Debug, Clone)]
-pub struct FileRecord {
-    pub file_ref: u64,
-    pub parent_ref: u64,
-    pub name: String,
-    pub kind: FileKind,
-}
-
-#[derive(Debug, Clone)]
-pub struct NtfsDrive {
-    pub letter: char,
-    pub root: String,
-    pub device_path: String,
-}
-
-#[derive(Debug)]
-pub enum IndexEvent {
-    Created(FileRecord),
-    Deleted(u64),
-    Renamed { old_ref: u64, new_record: FileRecord },
-    Moved { file_ref: u64, new_parent_ref: u64, name: String, kind: FileKind },
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JournalCheckpoint {
-    pub next_usn: i64,
-    pub journal_id: u64,
-    pub drive_letter: char,
-}

fastsearch-core/src/mft/watcher.rs

@@ -1,232 +0,0 @@
-use std::mem;
-use std::time::Duration;
-use crossbeam_channel::Sender;
-use windows::{
-    core::PCWSTR,
-    Win32::Foundation::HANDLE,
-    Win32::Storage::FileSystem::{
-        CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_SHARE_DELETE,
-        FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
-    },
-    Win32::System::Ioctl::{
-        FSCTL_QUERY_USN_JOURNAL, FSCTL_READ_USN_JOURNAL,
-        READ_USN_JOURNAL_DATA_V0, USN_JOURNAL_DATA_V0, USN_RECORD_V2,
-        USN_REASON_FILE_CREATE, USN_REASON_FILE_DELETE,
-        USN_REASON_RENAME_NEW_NAME, USN_REASON_RENAME_OLD_NAME,
-    },
-    Win32::System::IO::DeviceIoControl,
-};
-use crate::mft::types::{FileKind, FileRecord, IndexEvent, JournalCheckpoint, NtfsDrive};
-
-const BUFFER_SIZE: usize = 64 * 1024;
-
-pub struct UsnWatcher {
-    handle: HANDLE,
-    drive: NtfsDrive,
-    sender: Sender<IndexEvent>,
-    pub next_usn: i64,
-    pub journal_id: u64,
-}
-
-impl UsnWatcher {
-    pub fn new(
-        drive: &NtfsDrive,
-        sender: Sender<IndexEvent>,
-    ) -> windows::core::Result<Self> {
-        Self::new_from(drive, sender, None)
-    }
-
-    pub fn new_from(
-        drive: &NtfsDrive,
-        sender: Sender<IndexEvent>,
-        checkpoint: Option<&JournalCheckpoint>,
-    ) -> windows::core::Result<Self> {
-        let path: Vec<u16> = drive.device_path.encode_utf16().chain(Some(0)).collect();
-
-        let handle = unsafe {
-            CreateFileW(
-                PCWSTR(path.as_ptr()),
-                0x0,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                None,
-                OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS,
-                None,
-            )?
-        };
-
-        let mut journal_data: USN_JOURNAL_DATA_V0 = unsafe { mem::zeroed() };
-        let mut bytes_returned = 0u32;
-
-        unsafe {
-            DeviceIoControl(
-                handle,
-                FSCTL_QUERY_USN_JOURNAL,
-                None, 0,
-                Some(&mut journal_data as *mut _ as *mut _),
-                mem::size_of::<USN_JOURNAL_DATA_V0>() as u32,
-                Some(&mut bytes_returned),
-                None,
-            )?;
-        }
-
-        let next_usn = if let Some(cp) = checkpoint {
-            if cp.journal_id != journal_data.UsnJournalID {
-                return Err(windows::core::Error::new(
-                    windows::Win32::Foundation::ERROR_JOURNAL_NOT_ACTIVE.into(),
-                    "Journal ID mismatch — rescan needed",
-                ));
-            }
-            if cp.next_usn < journal_data.FirstUsn || cp.next_usn > journal_data.NextUsn {
-                return Err(windows::core::Error::new(
-                    windows::Win32::Foundation::ERROR_JOURNAL_NOT_ACTIVE.into(),
-                    "Saved USN outside journal range — rescan needed",
-                ));
-            }
-            cp.next_usn
-        } else {
-            journal_data.NextUsn
-        };
-
-        Ok(Self {
-            handle,
-            drive: drive.clone(),
-            sender,
-            next_usn,
-            journal_id: journal_data.UsnJournalID,
-        })
-    }
-
-    pub fn checkpoint(&self) -> JournalCheckpoint {
-        JournalCheckpoint {
-            next_usn: self.next_usn,
-            journal_id: self.journal_id,
-            drive_letter: self.drive.letter,
-        }
-    }
-
-    pub fn run(&mut self) {
-        let mut buffer = vec![0u8; BUFFER_SIZE];
-        loop {
-            std::thread::sleep(Duration::from_millis(500));
-            self.poll(&mut buffer);
-        }
-    }
-
-    pub fn run_shared(&mut self, shared: std::sync::Arc<parking_lot::Mutex<Vec<JournalCheckpoint>>>) {
-        let mut buffer = vec![0u8; BUFFER_SIZE];
-        loop {
-            std::thread::sleep(Duration::from_millis(500));
-            self.poll(&mut buffer);
-            let mut cps = shared.lock();
-            cps.retain(|c| c.drive_letter != self.drive.letter);
-            cps.push(self.checkpoint());
-        }
-    }
-
-    pub fn drain(&mut self) -> usize {
-        let mut buffer = vec![0u8; BUFFER_SIZE];
-        let mut count = 0;
-        loop {
-            let before = self.next_usn;
-            self.poll(&mut buffer);
-            if self.next_usn == before {
-                break;
-            }
-            count += 1;
-        }
-        count
-    }
-
-    fn poll(&mut self, buffer: &mut Vec<u8>) {
-        let read_data = READ_USN_JOURNAL_DATA_V0 {
-            StartUsn: self.next_usn,
-            ReasonMask: USN_REASON_FILE_CREATE
-                | USN_REASON_FILE_DELETE
-                | USN_REASON_RENAME_NEW_NAME
-                | USN_REASON_RENAME_OLD_NAME,
-            ReturnOnlyOnClose: 0,
-            Timeout: 0,
-            BytesToWaitFor: 0,
-            UsnJournalID: self.journal_id,
-        };
-
-        let mut bytes_returned = 0u32;
-        let ok = unsafe {
-            DeviceIoControl(
-                self.handle,
-                FSCTL_READ_USN_JOURNAL,
-                Some(&read_data as *const _ as *const _),
-                mem::size_of::<READ_USN_JOURNAL_DATA_V0>() as u32,
-                Some(buffer.as_mut_ptr() as *mut _),
-                BUFFER_SIZE as u32,
-                Some(&mut bytes_returned),
-                None,
-            )
-        };
-
-        if ok.is_err() || bytes_returned <= 8 {
-            return;
-        }
-
-        self.next_usn = i64::from_ne_bytes(buffer[0..8].try_into().unwrap());
-
-        let mut offset = 8usize;
-        while offset + mem::size_of::<USN_RECORD_V2>() <= bytes_returned as usize {
-            let record = unsafe {
-                &*(buffer.as_ptr().add(offset) as *const USN_RECORD_V2)
-            };
-            if record.RecordLength == 0 { break; }
-            self.process_record(record, buffer, offset);
-            offset += record.RecordLength as usize;
-        }
-    }
-
-    fn process_record(&self, record: &USN_RECORD_V2, buffer: &[u8], offset: usize) {
-        let name_offset = record.FileNameOffset as usize;
-        let name_len = record.FileNameLength as usize / 2;
-        let name_ptr = unsafe {
-            buffer.as_ptr().add(offset + name_offset) as *const u16
-        };
-        let name_slice = unsafe { std::slice::from_raw_parts(name_ptr, name_len) };
-        let name = String::from_utf16_lossy(name_slice);
-
-        let is_dir = (record.FileAttributes & 0x10) != 0;
-        let file_ref = record.FileReferenceNumber as u64;
-        let parent_ref = record.ParentFileReferenceNumber as u64;
-        let reason = record.Reason;
-
-        if reason & USN_REASON_FILE_DELETE != 0 {
-            let _ = self.sender.send(IndexEvent::Deleted(file_ref));
-            return;
-        }
-
-        let kind = if is_dir { FileKind::Directory } else { FileKind::File };
-
-        if reason & USN_REASON_RENAME_NEW_NAME != 0 {
-            let _ = self.sender.send(IndexEvent::Moved {
-                file_ref,
-                new_parent_ref: parent_ref,
-                name: name.clone(),
-                kind: kind.clone(),
-            });
-            return;
-        }
-
-        if reason & USN_REASON_FILE_CREATE != 0 {
-            let new_record = FileRecord {
-                file_ref,
-                parent_ref,
-                name,
-                kind,
-            };
-            let _ = self.sender.send(IndexEvent::Created(new_record));
-        }
-    }
-}
-
-impl Drop for UsnWatcher {
-    fn drop(&mut self) {
-        unsafe { windows::Win32::Foundation::CloseHandle(self.handle).ok() };
-    }
-}

fastsearch-core/src/utils/drives.rs

@@ -1,59 +0,0 @@
-use crate::mft::types::NtfsDrive;
-use windows::{
-    Win32::Storage::FileSystem::{
-        GetLogicalDriveStringsW, GetVolumeInformationW,
-    },
-};
-
-/// Returns all NTFS drives on the system
-pub fn get_ntfs_drives() -> Vec<NtfsDrive> {
-    let mut drives = Vec::new();
-
-    let mut buf = vec![0u16; 256];
-    let len = unsafe { GetLogicalDriveStringsW(Some(&mut buf)) } as usize;
-    if len == 0 {
-        return drives;
-    }
-
-    let drive_strings: Vec<String> = buf[..len]
-        .split(|&c| c == 0)
-        .filter(|s| !s.is_empty())
-        .map(|s| String::from_utf16_lossy(s))
-        .collect();
-
-    for root in drive_strings {
-        if is_ntfs(&root) {
-            let letter = root.chars().next().unwrap();
-            drives.push(NtfsDrive {
-                letter,
-                root: root.clone(),
-                device_path: format!("\\\\.\\{}:", letter),
-            });
-        }
-    }
-
-    drives
-}
-
-fn is_ntfs(root: &str) -> bool {
-    let root_wide: Vec<u16> = root.encode_utf16().chain(Some(0)).collect();
-    let mut fs_name = vec![0u16; 32];
-
-    let ok = unsafe {
-        GetVolumeInformationW(
-            windows::core::PCWSTR(root_wide.as_ptr()),
-            None,
-            None,
-            None,
-            None,
-            Some(&mut fs_name),
-        )
-    };
-
-    if ok.is_err() {
-        return false;
-    }
-
-    let fs = String::from_utf16_lossy(&fs_name);
-    fs.starts_with("NTFS")
-}

fastsearch-core/src/utils/mod.rs

@@ -1 +0,0 @@
-pub mod drives;