add new option to skip n bytes before searching

Author: LaBatata101

src/lib.rs

@@ -10,6 +10,11 @@ use utils::{file, search};
 use crate::utils::{print_hexdump_output, PatternType};
 
 pub fn setup_args<'a>() -> ArgMatches<'a> {
+    let integer_validator = |value: String| match value.parse::<usize>() {
+        Ok(_) => Ok(()),
+        Err(_) => Err(String::from("the value needs to be a valid integer")),
+    };
+
     App::new("grep_bin")
         .version(clap::crate_version!())
         .author(clap::crate_authors!())
@@ -45,23 +50,28 @@ All of these byte sequence are valid: f9b4ca, F9B4CA and f9B4Ca",
 Examples of input: jpg, mp3, exe",
                 ),
         )
-        .arg(Arg::with_name("context_bytes_size")
-             .short("c")
-             .default_value("16")
-             .validator(|value| {
-                 match value.parse::<usize>() {
-                     Ok(_) => Ok(()),
-                     Err(_) => Err(String::from("the value needs to be a valid integer")),
-                 }
-                })
-             .long_help("Defines the number of bytes that will be printed in each line.")
-             )
+        .arg(
+            Arg::with_name("context_bytes_size")
+                .short("c")
+                .default_value("16")
+                .validator(integer_validator)
+                .long_help("Defines the number of bytes that will be printed in each line."),
+        )
         .arg(
             Arg::with_name("print_only")
                 .short("p")
                 .long("print-only")
                 .help("Prints only the file name that contais the match."),
         )
+        .arg(
+            Arg::with_name("skip_bytes")
+                .short("s")
+                .long("skip-bytes")
+                .default_value("0")
+                .takes_value(true)
+                .validator(integer_validator)
+                .help("Skip n bytes before searching."),
+        )
         .settings(&[AppSettings::ArgRequiredElseHelp, AppSettings::ColoredHelp])
         .get_matches()
 }
@@ -90,6 +100,7 @@ pub fn run(args: ArgMatches) {
         .unwrap()
         .parse()
         .unwrap();
+    let skip_bytes: u64 = args.value_of("skip_bytes").unwrap().parse().unwrap();
 
     for filename in files {
         let mut searcher = search::Searcher::new(&pattern, context_bytes_size, skip_bytes);

src/utils/search.rs

@@ -1,5 +1,5 @@
 use std::fs::File;
-use std::io::{BufReader, Read};
+use std::io::{BufReader, Read, Seek, SeekFrom};
 use std::ops::Range;
 
 #[derive(Debug, Clone)]
@@ -95,25 +95,27 @@ pub struct Searcher<'a> {
     pattern: &'a [u8],
     matches: Matches,
     context_bytes_size: usize,
+    skip_bytes: u64,
 }
 
 impl<'a> Searcher<'a> {
     const BUFFER_SIZE: usize = 8192;
 
-    pub fn new(pattern: &'a [u8], context_bytes_size: usize) -> Self {
+    pub fn new(pattern: &'a [u8], context_bytes_size: usize, skip_bytes: u64) -> Self {
         Self {
             pattern,
             matches: Matches::new(pattern.len(), context_bytes_size),
             context_bytes_size,
+            skip_bytes,
         }
     }
 
     pub fn search_in_file(&mut self, filepath: &str) -> std::io::Result<()> {
-        let file = File::open(filepath)?;
+        let mut file = File::open(filepath)?;
         let file_size = file.metadata().unwrap().len() as usize;
 
+        let mut pos_in_file = file.seek(SeekFrom::Start(self.skip_bytes)).unwrap_or(0) as usize;
         let mut reader = BufReader::new(file);
-        let mut pos_in_file = 0;
 
         if file_size < self.context_bytes_size {
             self.context_bytes_size = file_size;