Added hex parser, and options struct

Author: Nemesis-AS

Cargo.toml

@@ -13,8 +13,7 @@ version = "0.1.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-# No Dependencies!
+hex = "0.4.3"
 
 [dev-dependencies]
 clap = { version = "4.0.7", features = ["derive"] }
-hex = "0.4.3"

examples/cli.rs

@@ -1,4 +1,4 @@
-use bencode_parser::BEncode;
+use bencode_parser::{BEncode, Options};
 use clap::Parser;
 use std::fs;
 use std::io::Write;
@@ -28,7 +28,8 @@ fn main() {
     let path: PathBuf = PathBuf::from(&args.input);
     let bytes = fs::read(path).expect("Couldn't Read File!");
 
-    let res: BEncode = BEncode::parse(bytes);
+    let options: Options = Options::default();
+    let res: BEncode = BEncode::parse(bytes, options);
 
     if let BEncode::Dictionary(_) = res {
         let file_path: PathBuf = PathBuf::from(args.output);

examples/info_hash_extractor.rs

@@ -1,4 +1,4 @@
-use bencode_parser::BEncode;
+use bencode_parser::{BEncode, Options};
 use clap::Parser;
 use std::fs;
 use std::path::PathBuf;
@@ -16,7 +16,12 @@ fn main() {
 
     let path: PathBuf = PathBuf::from(args.input);
     let bytes: Vec<u8> = fs::read(path).expect("Cannot read File!");
-    let res: BEncode = BEncode::parse(bytes);
+
+    let options: Options = Options::default();
+    let res: BEncode = BEncode::parse(bytes, options);
+
+    // The length is 20 in torrent files, but parsing 1 byte to hex returns 2 characters, so the length also has to be doubled
+    let hash_length: usize = 40;
 
     if let BEncode::Dictionary(obj) = res {
         let info: &BEncode = obj
@@ -25,17 +30,20 @@ fn main() {
 
         if let BEncode::Dictionary(info_obj) = info {
             let pieces: &BEncode = info_obj.get("pieces").expect("Cannot find Pieces!");
-            if let BEncode::BinaryStr(str) = pieces {
-                if str.len() % 20 != 0 {
-                    panic!("Pieces Hash not valid! (The length is not a multiple of 20)");
+            if let BEncode::String(str) = pieces {
+                if str.len() % hash_length != 0 {
+                    panic!(
+                        "Pieces Hash not valid! (The length is not a multiple of {})",
+                        hash_length
+                    );
                 }
                 let mut hashes: Vec<String> = Vec::new();
                 let mut start_idx: usize = 0;
 
-                while (start_idx + 20) <= str.len() {
-                    let hash: String = hex::encode(&str[start_idx..start_idx + 20]);
+                while (start_idx + hash_length) <= str.len() {
+                    let hash: String = str[start_idx..start_idx + hash_length].to_string();
                     hashes.push(hash);
-                    start_idx += 20;
+                    start_idx += hash_length;
                 }
 
                 println!("{:?}", hashes);

src/lib.rs

@@ -11,6 +11,9 @@
 //!
 //! ```
 
+mod options;
+
+pub use options::Options;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::fmt;
@@ -49,7 +52,7 @@ impl fmt::Debug for BEncode {
 impl BEncode {
     /// This function returns the parsed [`BEncode`] object, given a valid path to a file containing bencode.
     /// returns a `Bencode::Int(-1)` if the bencode cannot be parsed
-    pub fn parse(bytes: Vec<u8>) -> Self {
+    pub fn parse(bytes: Vec<u8>, options: Options) -> Self {
         // =====================STATE VARIABLES==========================
         let mut parents: Vec<BEncode> = Vec::new();
         let mut dict_keys: Vec<String> = Vec::new();
@@ -92,7 +95,7 @@ impl BEncode {
                 }
                 // String
                 c if c.chars().next().unwrap().is_numeric() => {
-                    let (new_idx, out_str) = Self::parse_str(&bytes, idx - 1);
+                    let (new_idx, out_str) = Self::parse_str(&bytes, idx - 1, options.parse_hex);
                     idx = new_idx;
                     // println!("Parsed String: {:?}", out_str);
                     if !parents.is_empty() {
@@ -220,7 +223,7 @@ impl BEncode {
     }
 
     /// Internal function to parse a bencode ByteString
-    fn parse_str(bytes: &[u8], mut idx: usize) -> (usize, BEncode) {
+    fn parse_str(bytes: &[u8], mut idx: usize, parse_hex: bool) -> (usize, BEncode) {
         let mut len_str: String = String::new();
 
         // This loop determines the length of the string
@@ -244,10 +247,9 @@ impl BEncode {
         let out_str = String::from_utf8(byte_slice.clone()).unwrap_or_else(|_e| "".to_string());
 
         if out_str.is_empty() {
-            // unsafe {
-            //     // let bin = String::from_utf8_unchecked(byte_slice);
-            //     return (idx + len, BEncode::BinaryStr(byte_slice.to_vec()));
-            // }
+            if parse_hex {
+                return (idx + len, BEncode::String(hex::encode(byte_slice)));
+            }
             return (idx + len, BEncode::BinaryStr(byte_slice.to_vec()));
         }
 

src/options.rs

@@ -0,0 +1,11 @@
+//! The `Options` struct contains the configurable options that the parser can take
+pub struct Options {
+    /// `parse_hex` tells the parser if the hex data from pieces should be parsed. Default value: `true`
+    pub parse_hex: bool,
+}
+
+impl Options {
+    pub fn default() -> Self {
+        Self { parse_hex: true }
+    }
+}