basic support for binary files via base64

Author: mgree

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+base64 = "0.13.0"
 clap = "2.0"
 fuser = "0.8"
 libc = "0.2.51"

Cargo.toml

@@ -13,6 +13,8 @@ pub struct Config {
     pub dirmode: u16,
     pub add_newlines: bool,
     pub pad_element_names: bool,
+    pub base64: base64::Config,
+    pub try_decode_base64: bool,
     pub read_only: bool,
     pub output: Output,
 }
@@ -41,7 +43,6 @@ impl Config {
             .replace("=", "equal")
             .replace(" ", "space")
     }
-    
 }
 
 impl Default for Config {
@@ -56,8 +57,10 @@ impl Default for Config {
             dirmode: 0o755,
             add_newlines: false,
             pad_element_names: true,
+            base64: base64::STANDARD,
+            try_decode_base64: false,
             read_only: false,
             output: Output::Stdout,
         }
     }
-}
+}

binary/twitter.ico

@@ -119,8 +119,10 @@ where
     /// Characterizes the outermost value. Drives the worklist algorithm.
     fn node(self, config: &Config) -> Node<Self>;
 
-    #[allow(clippy::ptr_arg)]
-    fn from_bytes(v: &Vec<u8>, config: &Config) -> Self;
+    fn from_bytes<T>(v: T, config: &Config) -> Self
+    where
+        T: AsRef<[u8]>;
+    fn from_string(v: String, config: &Config) -> Self;
     fn from_list_dir(files: Vec<Self>, config: &Config) -> Self;
     fn from_named_dir(files: HashMap<String, Self>, config: &Config) -> Self;
 }
@@ -238,7 +240,15 @@ where
     V: Nodelike,
 {
     match &fs.get(inum).unwrap().entry {
-        Entry::File(contents) => V::from_bytes(contents, &fs.config),
+        Entry::File(contents) => match String::from_utf8(contents.clone()) {
+            Ok(mut contents) => {
+                if fs.config.add_newlines && contents.ends_with('\n') {
+                    contents.truncate(contents.len() - 1);
+                }
+                V::from_string(contents, &fs.config)
+            }
+            Err(_) => V::from_bytes(contents, &fs.config),
+        },
         Entry::Directory(DirType::List, files) => {
             let mut entries = Vec::with_capacity(files.len());
 
@@ -294,25 +304,20 @@ mod json {
                 Value::Bool(b) => Node::Bytes(format!("{}{}", b, nl).into_bytes()),
                 Value::Number(n) => Node::Bytes(format!("{}{}", n, nl).into_bytes()),
                 Value::String(s) => {
-                    let contents = if s.ends_with('\n') { s } else { s + nl };
-                    Node::Bytes(contents.into_bytes())
+                    if config.try_decode_base64 {
+                        if let Ok(bytes) = base64::decode_config(&s, config.base64) {
+                            return Node::Bytes(bytes);
+                        }
+                    }
+
+                    Node::String(if s.ends_with('\n') { s } else { s + nl })
                 }
                 Value::Array(vs) => Node::List(vs),
                 Value::Object(fvs) => Node::Map(fvs.into_iter().collect()),
             }
         }
 
-        fn from_bytes(contents: &Vec<u8>, config: &Config) -> Self {
-            let contents = match String::from_utf8(contents.clone()) {
-                Ok(mut contents) => {
-                    if config.add_newlines && contents.ends_with('\n') {
-                        contents.truncate(contents.len() - 1);
-                    }
-                    contents
-                }
-                Err(_) => unimplemented!("binary data JSON serialization"),
-            };
-
+        fn from_string(contents: String, _config: &Config) -> Self {
             if contents.is_empty() {
                 Value::Null
             } else if contents == "true" {
@@ -326,6 +331,13 @@ mod json {
             }
         }
 
+        fn from_bytes<T>(contents: T, config: &Config) -> Self
+        where
+            T: AsRef<[u8]>,
+        {
+            Value::String(base64::encode_config(contents, config.base64))
+        }
+
         fn from_list_dir(files: Vec<Self>, _config: &Config) -> Self {
             Value::Array(files)
         }
@@ -340,7 +352,6 @@ mod toml {
     use super::*;
 
     use serde_toml::Value;
-
     #[derive(Debug)]
     pub enum Error<E> {
         Io(std::io::Error),
@@ -392,25 +403,20 @@ mod toml {
                 Value::Float(n) => Node::Bytes(format!("{}{}", n, nl).into_bytes()),
                 Value::Integer(n) => Node::Bytes(format!("{}{}", n, nl).into_bytes()),
                 Value::String(s) => {
-                    let contents = if s.ends_with('\n') { s } else { s + nl };
-                    Node::Bytes(contents.into_bytes())
+                    if config.try_decode_base64 {
+                        if let Ok(bytes) = base64::decode_config(&s, config.base64) {
+                            return Node::Bytes(bytes);
+                        }
+                    }
+
+                    Node::String(if s.ends_with('\n') { s } else { s + nl })
                 }
                 Value::Array(vs) => Node::List(vs),
                 Value::Table(fvs) => Node::Map(fvs.into_iter().collect()),
             }
         }
 
-        fn from_bytes(contents: &Vec<u8>, config: &Config) -> Self {
-            let contents = match String::from_utf8(contents.clone()) {
-                Ok(mut contents) => {
-                    if config.add_newlines && contents.ends_with('\n') {
-                        contents.truncate(contents.len() - 1);
-                    }
-                    contents
-                }
-                Err(_) => unimplemented!("binary data TOML serialization"),
-            };
-
+        fn from_string(contents: String, _config: &Config) -> Self {
             if contents == "true" {
                 Value::Boolean(true)
             } else if contents == "false" {
@@ -424,6 +430,13 @@ mod toml {
             }
         }
 
+        fn from_bytes<T>(contents: T, config: &Config) -> Self
+        where
+            T: AsRef<[u8]>,
+        {
+            Value::String(base64::encode_config(contents, config.base64))
+        }
+
         fn from_list_dir(files: Vec<Self>, _config: &Config) -> Self {
             Value::Array(files)
         }

src/config.rs

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+fail() {
+    echo FAILED: $1
+    if [ "$MNT" ]
+    then
+        cd
+        umount "$MNT"
+        rmdir "$MNT"
+        rm "$TGT"
+        rm "$TGT2"
+        rm "$ICO"
+    fi
+    exit 1
+}
+
+MNT=$(mktemp -d)
+TGT=$(mktemp)
+TGT2=$(mktemp)
+
+ffs "$MNT" ../json/object.json >"$TGT" &
+PID=$!
+sleep 2
+cp ../binary/twitter.ico "$MNT"/favicon
+umount "$MNT" || fail unmount1    
+sleep 1
+kill -0 $PID >/dev/null 2>&1 && fail process1
+
+# easiest to just test using ffs, but would be cool to get outside validation
+[ -f "$TGT" ] || fail output1
+[ -s "$TGT" ] || fail output2
+grep favicon "$TGT" >/dev/null 2>&1 || fail text
+ffs --no-output "$MNT" "$TGT" >"$TGT2" &
+PID=$!
+sleep 2
+
+ICO=$(mktemp)
+
+ls "$MNT" | grep favicon >/dev/null 2>&1 || fail field
+base64 -D -i "$MNT"/favicon -o "$ICO"
+diff ../binary/twitter.ico "$ICO" || fail diff
+
+umount "$MNT" || fail unmount2
+sleep 1
+kill -0 $PID >/dev/null 2>&1 && fail process2
+
+[ -f "$TGT2" ] || fail tgt2
+[ -s "$TGT2" ] && fail tgt2_nonempty
+
+rmdir "$MNT" || fail mount
+rm "$TGT"
+rm "$TGT2"
+rm "$ICO"