fix: trace abort and color handling

Author: jogi1

examples/mvd_parser.rs

@@ -41,7 +41,7 @@ fn parse_file(filename: String) -> Result<bool, Box<dyn Error>> {
             },
             Err(e) => {
                 #[cfg(feature = "trace")]
-                print_message_trace(&mvd.message, false, 0, 2)?;
+                print_message_trace(&mvd.message, false, 0, 2, false)?;
                 return Err(Box::new(e));
             },
         };
@@ -62,7 +62,7 @@ fn parse_file(filename: String) -> Result<bool, Box<dyn Error>> {
         }
         #[cfg(feature = "trace")]
         if false { // if you want to print a trace of each read frame
-            print_message_trace(&mvd.message, false, 0, 2)?;
+            print_message_trace(&mvd.message, false, 0, 2, false)?;
         }
     }
     return Ok(true)

examples/trace.rs

@@ -1,5 +1,5 @@
 use quakeworld::protocol::message::{Message, MessageFlags, MessageType};
-use quakeworld::protocol::types::{ServerClient, Print, ServerMessage};
+use quakeworld::protocol::types::{ServerClient, ServerMessage};
 use quakeworld::utils::trace::print_message_trace;
 fn main() {
         let b: Vec<u8> = vec![8, 2, 0x68, 0x65, 0x6c, 0x6c, 0x6f,0x0];
@@ -26,5 +26,5 @@ fn main() {
             },
             _ => { panic!("its not print!");},
         }
-        print_message_trace(&message, false)?;
+        let _ = print_message_trace(&message, true, 0, 9, true);
     }

src/protocol/message/mod.rs

@@ -6,7 +6,7 @@ use serde::Serialize;
 use crate::utils::ascii_converter::AsciiConverter;
 
 use crate::protocol::types::*;
-use crate::protocol::message::trace::{trace_start, trace_stop, trace_annotate, trace_lock, trace_unlock, MessageTrace, TraceValue, ToTraceValue};
+use crate::protocol::message::trace::{trace_start, trace_stop, trace_annotate, trace_abort, trace_lock, trace_unlock, MessageTrace, TraceValue, ToTraceValue};
 
 pub mod errors;
 pub mod trace;
@@ -72,7 +72,13 @@ macro_rules! endian_read {
                 pub fn [< read_$ty >] (&mut self, readahead: bool) ->  Result<$ty, MessageError> {
                     const TYPE_SIZE:usize = std::mem::size_of::<$ty>();
                     trace_start!(self, readahead);
-                    self.check_read_size(TYPE_SIZE)?;
+                    match self.check_read_size(TYPE_SIZE) {
+                        Ok(()) => {},
+                        Err(e) => {
+                            trace_abort!(self);
+                            return Err(e);
+                        },
+                    }
                     let mut a: [u8; TYPE_SIZE] = [0; TYPE_SIZE];
                     for n in 0..TYPE_SIZE {
                         a[n] = self.buffer[self.start + self.position + n ];
@@ -297,7 +303,6 @@ impl Message {
             } else if b == 0 {
                 break
             }
-
             buf.push(b);
         }
         trace_unlock!(self);
@@ -497,16 +502,25 @@ impl Message {
                 Ok(t) => t,
                 Err(e) => {
                     match e {
-                        MessageError::ReadBeyondSize(_,_,_) => break,
-                        _ => return Err(e),
+                        MessageError::ReadBeyondSize(_,_,_) => {
+                            break
+                        },
+                        _ => {
+                            let p = Packet::Connected(Connected{
+                                sequence,
+                                sequence_ack,
+                                messages,
+                            });
+                            trace_stop!(self, p);
+                            return Err(e)
+                        },
                     }
                 },
             };
 
             let cmd = match ServerClient::try_from(t) {
                 Ok(cmd) => cmd,
                 Err(_) => {
-
                     let p = Packet::Connected(Connected{
                         sequence,
                         sequence_ack,
@@ -516,7 +530,19 @@ impl Message {
                     return Err(MessageError::UnknownType(t));
                 }
             };
-            let ret = cmd.read_message(self)?;
+
+            let ret = match cmd.read_message(self) {
+                Ok(ret) => ret,
+                Err(e) => {
+                    let p = Packet::Connected(Connected{
+                        sequence,
+                        sequence_ack,
+                        messages,
+                    });
+                    trace_stop!(self, p);
+                    return Err(e);
+                }
+            };
             messages.push(ret);
         }
         let p = Packet::Connected(Connected{
@@ -539,8 +565,7 @@ impl Message {
         trace_stop!(self, _packet_type, U8);
         match packet_type {
             CommandCode::S2cChallenge => {
-                let p = self.read_packet_s2c_challenge();
-                return p;
+                self.read_packet_s2c_challenge()
             }
             CommandCode::S2cConnection => {
                 Ok(Packet::ConnectionLessServerConnection)

src/protocol/message/trace.rs

@@ -12,6 +12,7 @@ pub struct ReadTrace {
     pub start: usize,
     pub stop: usize,
     pub readahead: bool,
+    pub aborted: bool,
     pub function: String,
     pub annotation: Option<String>,
     pub read: Vec<ReadTrace>,
@@ -90,10 +91,29 @@ impl Message {
             read: vec![],
             value: TraceValue::None,
             annotation,
+            aborted: false,
         };
         self.trace.stack.push(res)
     }
 
+    #[cfg(feature = "trace")]
+    pub fn read_trace_abort(&mut self) {
+        if !self.trace.enabled {
+            return;
+        }
+        if let Some(mut trace) = self.trace.stack.pop() {
+            trace.aborted = true;
+            trace.stop = self.position;
+
+            let len = self.trace.stack.len();
+            if len > 0 {
+                self.trace.stack[len-1].read.push(trace);
+            } else {
+                self.trace.read.push(trace);
+            }
+        }
+    }
+
     #[cfg(feature = "trace")]
     pub fn read_trace_stop(&mut self, value: TraceValue) {
         if !self.trace.enabled {
@@ -159,6 +179,21 @@ macro_rules! trace_stop{
 }
 pub(crate) use trace_stop;
 
+#[cfg(not(feature = "trace"))]
+macro_rules! trace_abort {
+}
+
+#[cfg(feature = "trace")]
+macro_rules! trace_abort {
+    ($self:expr) => {
+        if $self.trace.enabled && !$self.trace.locked {
+            $self.read_trace_abort();
+        }
+    }
+}
+
+pub(crate) use trace_abort;
+
 #[cfg(not(feature = "trace"))]
 macro_rules! trace_annotate {
 }

src/protocol/types.rs

@@ -1652,13 +1652,10 @@ pub struct Intermission {
     pub angle: AngleVector,
 }
 
-
 #[derive(Debug, PartialEq, Eq, PartialOrd, ParseMessage, Serialize, Clone)]
 pub struct Disconnect {
 }
 
-
-
 #[derive(Debug, Eq, PartialEq, PartialOrd, Ord, TryFromPrimitive, Display, Serialize, Clone)]
 #[repr(u8)]
 pub enum TempEntityType {