read database from partition

6 files changed, 104 insertions, 17 deletions

diff --git a/.idea/fsverify.iml b/.idea/fsverify.iml
index cf84ae4..11cef43 100644
--- a/.idea/fsverify.iml
+++ b/.idea/fsverify.iml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="EMPTY_MODULE" version="4">
+  <component name="Go" enabled="true" />
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
diff --git a/cmd/verify.go b/cmd/verify.go
index 3ceabbe..9c7947c 100644
--- a/cmd/verify.go
+++ b/cmd/verify.go
@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"fmt"
 	"github.com/axtloss/fsverify/core"
 	"github.com/spf13/cobra"
 )
@@ -17,16 +18,29 @@ func NewVerifyCommand() *cobra.Command {
 }
 
 func ValidateCommand(_ *cobra.Command, args []string) error {
-	node := core.Node{
-		BlockStart:  0,
-		BlockEnd:    4 * 1000,
-		BlockSum:    "test",
-		PrevNodeSum: "aaaa",
+
+	header, err := core.ReadHeader("./part.fsverify")
+	fmt.Println(header.MagicNumber)
+	fmt.Println(header.Signature)
+	fmt.Println(header.FilesystemSize)
+	fmt.Println(header.TableSize)
+	if err != nil {
+		return err
+	}
+	dbfile, err := core.ReadDB("./part.fsverify")
+	if err != nil {
+		return err
 	}
-	err := core.AddNode(node, nil)
+	fmt.Println("DBFILE: ", dbfile)
+	db, err := core.OpenDB(dbfile)
+	if err != nil {
+		return err
+	}
+
+	getnode, err := core.GetNode("aaaa", db)
 	if err != nil {
 		return err
 	}
-	_, err = core.ReadHeader("./test.part")
-	return err
+	fmt.Println(getnode)
+	return nil
 }
diff --git a/core/storage.go b/core/storage.go
index 8c76c52..ba4faf6 100644
--- a/core/storage.go
+++ b/core/storage.go
@@ -16,6 +16,7 @@ type Header struct {
 	Signature      string
 	FilesystemSize int
 	TableSize      int
+	TableUnit      int
 }
 
 type Node struct {
@@ -42,6 +43,7 @@ func ReadHeader(partition string) (Header, error) {
 	Signature := make([]byte, 302)
 	FileSystemSize := make([]byte, 4)
 	TableSize := make([]byte, 4)
+	TableUnit := make([]byte, 1)
 
 	_, err = reader.Read(MagicNumber)
 	MagicNum := binary.BigEndian.Uint16(MagicNumber)
@@ -62,19 +64,88 @@ func ReadHeader(partition string) (Header, error) {
 	if err != nil {
 		return Header{}, err
 	}
+	_, err = reader.Read(TableUnit)
+	if err != nil {
+		return Header{}, err
+	}
 
 	header.Signature = string(Signature)
 	header.FilesystemSize = int(binary.BigEndian.Uint16(FileSystemSize))
-	header.TableSize = int(binary.BigEndian.Uint16(TableSize))
+	header.TableSize = int(binary.BigEndian.Uint32(TableSize))
+	switch TableUnit[0] {
+	case 0:
+		header.TableUnit = 1
+	case 1:
+		header.TableUnit = 1000
+	case 2:
+		header.TableUnit = 1000000
+	case 3:
+		header.TableUnit = 1000000000
+	case 4:
+		header.TableUnit = 1000000000000
+	case 5:
+		header.TableUnit = 1000000000000000
+	default:
+		return Header{}, fmt.Errorf("Unknown TableUnit %d", TableUnit)
+	}
 	return header, nil
 }
 
-func OpenDB() (*bolt.DB, error) {
-	_, exist := os.Stat("my.db") // TODO: use configuration file for db path
+func ReadDB(partition string) (string, error) {
+	_, exist := os.Stat(partition)
+	if os.IsNotExist(exist) {
+		return "", fmt.Errorf("Cannot find partition %s", partition)
+	}
+	part, err := os.Open(partition)
+	if err != nil {
+		return "", err
+	}
+	defer part.Close()
+	reader := bufio.NewReader(part)
+
+	_, err = reader.Read(make([]byte, 313))
+	if err != nil {
+		fmt.Println(err)
+		return "", err
+	}
+
+	header, err := ReadHeader(partition)
+	if err != nil {
+		fmt.Println(err)
+		return "", err
+	}
+	fmt.Println("Header:")
+	fmt.Println(header.TableSize)
+	fmt.Println(header.TableUnit)
+	db := make([]byte, header.TableSize*header.TableUnit)
+	_, err = reader.Read(db)
+	if err != nil {
+		return "", err
+	}
+
+	temp, err := os.MkdirTemp("", "*-fsverify")
+	if err != nil {
+		return "", err
+	}
+
+	fmt.Println("DB Path:")
+	fmt.Println(temp)
+	fmt.Println()
+	err = os.WriteFile(temp+"/verify.db", db, 0777)
+	if err != nil {
+		return "", err
+	}
+
+	//defer os.RemoveAll(temp)
+	return temp + "/verify.db", err
+}
+
+func OpenDB(dbpath string) (*bolt.DB, error) {
+	_, exist := os.Stat(dbpath)
 	if os.IsNotExist(exist) {
-		os.Create("my.db")
+		os.Create(dbpath)
 	}
-	db, err := bolt.Open("my.db", 0777, nil)
+	db, err := bolt.Open(dbpath, 0777, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +156,7 @@ func AddNode(node Node, db *bolt.DB) error {
 	var err error
 	var deferDB bool
 	if db == nil {
-		db, err = OpenDB()
+		db, err = OpenDB("my.db")
 		if err != nil {
 			return err
 		}
@@ -114,7 +185,7 @@ func GetNode(checksum string, db *bolt.DB) (Node, error) {
 	var err error
 	var deferDB bool
 	if db == nil {
-		db, err = OpenDB()
+		db, err = OpenDB("my.db")
 		if err != nil {
 			return Node{}, err
 		}
diff --git a/fsverify-paper.md b/fsverify-paper.md
index 0686c07..82b9cf8 100644
--- a/fsverify-paper.md
+++ b/fsverify-paper.md
@@ -2,14 +2,15 @@
 The FsVerify partition contains a header with the necessary metadata for the filesystem verification, and a bbolt database containing all File and Directory nodes to be checked.
 
 ## Partition Header
-`<magic number> <signature> <filesystem size> <table size>`
+`<magic number> <signature> <filesystem size> <table size> <table unit>`
 
 Field|Size|Purpose|Value
 -----|----|-------|-----
 magic number|2 bytes|sanity check|0xACAB
 signature|302 bytes|minisign signature|
 filesystem size|4 bytes|size of the original filesystem in gb
-table size|4 bytes| size of the table in mb
+table size|4 bytes| size of the table in \<table unit\>
+table unit|1 byte|unit of the table size|0x0: bytes, 0x1: kilobytes, 0x2: megabytes, 0x3: gigabytes, 0x4: terabytes, 0x5: petabytes
 
 Due to the filesystem and table size field, which can go up to 0xFFFFFFFF (16777215), the maximum supported partition size and table size is 16777215gb (~16pb)
 
diff --git a/my.db b/my.db
new file mode 100644
index 0000000..b29529c
--- /dev/null
+++ b/my.db
diff --git a/part.fsverify b/part.fsverify
new file mode 100644
index 0000000..1890f21
--- /dev/null
+++ b/part.fsverify