├── .gitignore
├── screenshots
    ├── inline.png
    └── structured.png
├── Cargo.toml
├── src
    ├── definition.rs
    ├── lib.rs
    ├── field
    │   ├── garbage.rs
    │   ├── padding.rs
    │   ├── unknown.rs
    │   ├── constant.rs
    │   ├── mod.rs
    │   └── named.rs
    └── formatter
    │   ├── mod.rs
    │   ├── inline.rs
    │   └── structured.rs
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | Cargo.lock
3 | 


--------------------------------------------------------------------------------
/screenshots/inline.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/meh/rorschach/HEAD/screenshots/inline.png


--------------------------------------------------------------------------------
/screenshots/structured.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/meh/rorschach/HEAD/screenshots/structured.png


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name    = "rorschach"
 3 | version = "0.1.3"
 4 | 
 5 | authors = ["meh. <meh@schizofreni.co>"]
 6 | license = "WTFPL"
 7 | exclude = ["screenshots/*"]
 8 | 
 9 | description = "Binary data definition and formatter."
10 | repository  = "https://github.com/meh/rorschach"
11 | keywords    = ["formatter", "binary", "hex"]
12 | 
13 | [dependencies]
14 | byteorder = "0.5"
15 | ansi_term = "0.8"
16 | 


--------------------------------------------------------------------------------
/src/definition.rs:
--------------------------------------------------------------------------------
 1 | use {Field};
 2 | 
 3 | /// A packet definition.
 4 | #[derive(Clone, PartialEq, Default, Debug)]
 5 | pub struct Definition {
 6 | 	fields: Vec<Field>,
 7 | }
 8 | 
 9 | impl Definition {
10 | 	/// The fields in the definition.
11 | 	pub fn fields(&self) -> &[Field] {
12 | 		self.fields.as_ref()
13 | 	}
14 | 
15 | 	/// Add a field.
16 | 	pub fn field<T: Into<Field>>(mut self, field: T) -> Self {
17 | 		self.fields.push(field.into());
18 | 		self
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | extern crate byteorder;
 2 | extern crate ansi_term;
 3 | 
 4 | /// Endianness for fields.
 5 | #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 6 | pub enum Endian {
 7 | 	Little,
 8 | 	Big,
 9 | }
10 | 
11 | impl Default for Endian {
12 | 	#[cfg(target_endian = "big")]
13 | 	fn default() -> Self {
14 | 		Endian::Big
15 | 	}
16 | 
17 | 	#[cfg(target_endian = "little")]
18 | 	fn default() -> Self {
19 | 		Endian::Little
20 | 	}
21 | }
22 | 
23 | pub use Endian::{Little as LittleEndian, Big as BigEndian};
24 | 
25 | mod definition;
26 | pub use definition::Definition;
27 | 
28 | pub mod field;
29 | pub use field::Field;
30 | 
31 | pub mod formatter;
32 | pub use formatter::Formatter;
33 | 


--------------------------------------------------------------------------------
/src/field/garbage.rs:
--------------------------------------------------------------------------------
 1 | use std::io::{self, Read};
 2 | use {Field};
 3 | 
 4 | #[derive(Clone, PartialEq, Eq, Debug)]
 5 | pub struct Garbage {
 6 | 	bits: usize,
 7 | }
 8 | 
 9 | impl Garbage {
10 | 	pub fn bits(&self) -> usize {
11 | 		self.bits
12 | 	}
13 | 
14 | 	pub fn read<R: Read>(&self, mut buffer: R) -> io::Result<Vec<u8>> {
15 | 		let mut data = vec![0u8; super::bytes(self.bits)];
16 | 		try!(buffer.read(&mut data));
17 | 
18 | 		Ok(data)
19 | 	}
20 | }
21 | 
22 | #[derive(Default)]
23 | pub struct Builder {
24 | 	bits: Option<usize>,
25 | }
26 | 
27 | impl Builder {
28 | 	pub fn bits(mut self, value: usize) -> Self {
29 | 		self.bits = Some(value);
30 | 		self
31 | 	}
32 | 
33 | 	pub fn bytes(self, value: usize) -> Self {
34 | 		self.bits(value * 8)
35 | 	}
36 | }
37 | 
38 | impl Into<Field> for Builder {
39 | 	fn into(self) -> Field {
40 | 		Field::Garbage(Garbage {
41 | 			bits: self.bits.expect("missing field size"),
42 | 		})
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/src/field/padding.rs:
--------------------------------------------------------------------------------
 1 | use std::io::{self, Read};
 2 | use {Field};
 3 | 
 4 | #[derive(Clone, PartialEq, Eq, Debug)]
 5 | pub struct Padding {
 6 | 	bits: usize,
 7 | }
 8 | 
 9 | impl Padding {
10 | 	pub fn bits(&self) -> usize {
11 | 		self.bits
12 | 	}
13 | 
14 | 	pub fn read<R: Read>(&self, mut buffer: R) -> io::Result<Vec<u8>> {
15 | 		let mut data = vec![0u8; super::bytes(self.bits)];
16 | 		try!(buffer.read(&mut data));
17 | 
18 | 		Ok(data)
19 | 	}
20 | }
21 | 
22 | #[derive(Default)]
23 | pub struct Builder {
24 | 	bits: Option<usize>,
25 | }
26 | 
27 | impl Builder {
28 | 	pub fn bits(mut self, value: usize) -> Self {
29 | 		self.bits = Some(value);
30 | 		self
31 | 	}
32 | 
33 | 	pub fn bytes(self, value: usize) -> Self {
34 | 		self.bits(value * 8)
35 | 	}
36 | }
37 | 
38 | impl Into<Field> for Builder {
39 | 	fn into(self) -> Field {
40 | 		Field::Padding(Padding {
41 | 			bits: self.bits.expect("missing field size"),
42 | 		})
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/src/formatter/mod.rs:
--------------------------------------------------------------------------------
 1 | use std::io::{self, Read, Write};
 2 | use ansi_term;
 3 | use {Definition};
 4 | 
 5 | /// Trait for formatters.
 6 | pub trait Formatter {
 7 | 	fn format<R: Read, W: Write>(&self, def: &Definition, input: R, output: W) -> io::Result<()>;
 8 | }
 9 | 
10 | /// Color for styling.
11 | pub use ansi_term::Colour as Color;
12 | 
13 | /// Styles for fields that do not have instance styling.
14 | #[derive(Clone, Copy, PartialEq, Debug)]
15 | pub struct Style {
16 | 	pub default:  ansi_term::Style,
17 | 	pub constant: (ansi_term::Style, ansi_term::Style),
18 | 	pub padding:  (ansi_term::Style, ansi_term::Style),
19 | 	pub garbage:  ansi_term::Style,
20 | 	pub unknown:  ansi_term::Style,
21 | }
22 | 
23 | impl Default for Style {
24 | 	fn default() -> Self {
25 | 		Style {
26 | 			default:  Color::White.normal(),
27 | 			constant: (Color::Fixed(237).normal(), Color::Fixed(255).on(Color::Red)),
28 | 			padding:  (Color::Fixed(237).normal(), Color::Fixed(255).on(Color::Red)),
29 | 			garbage:  Color::Fixed(237).normal(),
30 | 			unknown:  Color::Fixed(240).normal(),
31 | 		}
32 | 	}
33 | }
34 | 
35 | mod structured;
36 | pub use self::structured::Structured;
37 | 
38 | mod inline;
39 | pub use self::inline::Inline;
40 | 


--------------------------------------------------------------------------------
/src/field/unknown.rs:
--------------------------------------------------------------------------------
 1 | use std::io::{self, Read};
 2 | use {Field};
 3 | 
 4 | /// An unkown field, it means you're not sure whether the data is padding or
 5 | /// garbage.
 6 | #[derive(Clone, PartialEq, Eq, Debug)]
 7 | pub struct Unknown {
 8 | 	bits: usize,
 9 | }
10 | 
11 | impl Unknown {
12 | 	/// Get how many bits the field is.
13 | 	pub fn bits(&self) -> usize {
14 | 		self.bits
15 | 	}
16 | 
17 | 	/// Read the data from a `Read` for this field.
18 | 	pub fn read<R: Read>(&self, mut buffer: R) -> io::Result<Vec<u8>> {
19 | 		let mut data = vec![0u8; super::bytes(self.bits)];
20 | 		try!(buffer.read(&mut data));
21 | 
22 | 		Ok(data)
23 | 	}
24 | }
25 | 
26 | /// A builder for an unknown field.
27 | #[derive(Default)]
28 | pub struct Builder {
29 | 	bits: Option<usize>,
30 | }
31 | 
32 | impl Builder {
33 | 	/// Defines the size in bits.
34 | 	pub fn bits(mut self, value: usize) -> Self {
35 | 		self.bits = Some(value);
36 | 		self
37 | 	}
38 | 
39 | 	/// Defines the size in bytes.
40 | 	pub fn bytes(self, value: usize) -> Self {
41 | 		self.bits(value * 8)
42 | 	}
43 | }
44 | 
45 | impl Into<Field> for Builder {
46 | 	fn into(self) -> Field {
47 | 		Field::Unknown(Unknown {
48 | 			bits: self.bits.expect("missing field size"),
49 | 		})
50 | 	}
51 | }
52 | 


--------------------------------------------------------------------------------
/src/field/constant.rs:
--------------------------------------------------------------------------------
 1 | use std::slice;
 2 | use std::io::{self, Read};
 3 | use {Field};
 4 | 
 5 | #[derive(Clone, PartialEq, Eq, Debug)]
 6 | pub struct Constant {
 7 | 	bits: usize,
 8 | 
 9 | 	value: Vec<u8>,
10 | }
11 | 
12 | impl Constant {
13 | 	pub fn bits(&self) -> usize {
14 | 		self.bits
15 | 	}
16 | 
17 | 	pub fn value(&self) -> &[u8] {
18 | 		&self.value
19 | 	}
20 | 
21 | 	pub fn read<R: Read>(&self, mut buffer: R) -> io::Result<Vec<u8>> {
22 | 		let mut data = vec![0u8; super::bytes(self.bits)];
23 | 		try!(buffer.read(&mut data));
24 | 
25 | 		Ok(data)
26 | 	}
27 | }
28 | 
29 | #[derive(Default)]
30 | pub struct Builder {
31 | 	bits: Option<usize>,
32 | 
33 | 	value: Option<Vec<u8>>,
34 | }
35 | 
36 | impl Builder {
37 | 	pub fn bits(mut self, value: usize) -> Self {
38 | 		self.bits = Some(value);
39 | 		self
40 | 	}
41 | 
42 | 	pub fn bytes(self, value: usize) -> Self {
43 | 		self.bits(value * 8)
44 | 	}
45 | 
46 | 	pub fn value<T: 'static>(mut self, value: T) -> Self {
47 | 		self.value = Some(unsafe {
48 | 			slice::from_raw_parts(&value as *const _ as *const u8,
49 | 			                      super::bytes(self.bits.unwrap_or(0)))
50 | 		}.to_vec());
51 | 
52 | 		self
53 | 	}
54 | }
55 | 
56 | impl Into<Field> for Builder {
57 | 	fn into(self) -> Field {
58 | 		Field::Constant(Constant {
59 | 			bits:  self.bits.expect("missing field size"),
60 | 			value: self.value.expect("missing field value"),
61 | 		})
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/src/field/mod.rs:
--------------------------------------------------------------------------------
 1 | pub mod constant;
 2 | pub use self::constant::Constant;
 3 | 
 4 | pub mod garbage;
 5 | pub use self::garbage::Garbage;
 6 | 
 7 | pub mod unknown;
 8 | pub use self::unknown::Unknown;
 9 | 
10 | pub mod padding;
11 | pub use self::padding::Padding;
12 | 
13 | pub mod named;
14 | pub use self::named::Named;
15 | 
16 | /// Field types.
17 | #[derive(Clone, PartialEq, Debug)]
18 | pub enum Field {
19 | 	Constant(Constant),
20 | 	Garbage(Garbage),
21 | 	Unknown(Unknown),
22 | 	Padding(Padding),
23 | 	Named(Named),
24 | }
25 | 
26 | impl Field {
27 | 	/// Get how many bits the field is.
28 | 	pub fn bits(&self) -> usize {
29 | 		match self {
30 | 			&Field::Constant(ref v) => v.bits(),
31 | 			&Field::Garbage(ref v)  => v.bits(),
32 | 			&Field::Unknown(ref v)  => v.bits(),
33 | 			&Field::Padding(ref v)  => v.bits(),
34 | 			&Field::Named(ref v)    => v.bits(),
35 | 		}
36 | 	}
37 | 
38 | 	/// Create a `Constant` field.
39 | 	pub fn constant() -> constant::Builder {
40 | 		constant::Builder::default()
41 | 	}
42 | 
43 | 	/// Create a `Named` field.
44 | 	pub fn named<T: Into<String>>(name: T) -> named::Builder {
45 | 		named::Builder::default().name(name)
46 | 	}
47 | 
48 | 	/// Create a `Padding` field.
49 | 	pub fn padding() -> padding::Builder {
50 | 		padding::Builder::default()
51 | 	}
52 | 
53 | 	/// Create a `Garbage` field.
54 | 	pub fn garbage() -> garbage::Builder {
55 | 		garbage::Builder::default()
56 | 	}
57 | 
58 | 	/// Create an `Unknown` field.
59 | 	pub fn unknown() -> unknown::Builder {
60 | 		unknown::Builder::default()
61 | 	}
62 | }
63 | 
64 | #[doc(hidden)]
65 | pub fn bytes(bits: usize) -> usize {
66 | 	(bits as f32 / 8.0).ceil() as usize
67 | }
68 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Rorschach
 2 | =========
 3 | Pretty print binary blobs based on common layout definition.
 4 | 
 5 | Example
 6 | -------
 7 | ```rust
 8 | use rorschach::{Definition, Field, LittleEndian};
 9 | use rorschach::formatter::{self, Color};
10 | 
11 | let def = Definition::default()
12 |   .field(Field::named("sequence")
13 |   	.is::<u32>(LittleEndian)
14 |   	.style(Color::Fixed(255).normal()))
15 |   .field(Field::named("buttons")
16 |   	.bytes(3)
17 |   	.binary()
18 |   	.style(Color::Fixed(3).normal()))
19 |   .field(Field::named("trigger.left")
20 |   	.is::<u8>(LittleEndian)
21 |   	.style(Color::Fixed(255).on(Color::Fixed(63)).underline()))
22 |   .field(Field::named("trigger.right")
23 |   	.is::<u8>(LittleEndian)
24 |   	.style(Color::Fixed(255).on(Color::Fixed(63))))
25 |   .field(Field::padding()
26 |   	.bytes(3))
27 |   .field(Field::named("pad.left.x")
28 |   	.is::<i16>(LittleEndian)
29 |   	.style(Color::Fixed(255).on(Color::Fixed(27)).underline()))
30 |   .field(Field::named("pad.left.y")
31 |   	.is::<i16>(LittleEndian)
32 |   	.style(Color::Fixed(27).normal()))
33 |   .field(Field::named("pad.right.x")
34 |   	.is::<i16>(LittleEndian)
35 |   	.style(Color::Fixed(255).on(Color::Fixed(36)).underline()))
36 |   .field(Field::named("pad.right.y")
37 |   	.is::<i16>(LittleEndian)
38 |   	.style(Color::Fixed(36).normal()))
39 |   .field(Field::padding()
40 |   	.bytes(12))
41 |   .field(Field::named("acceleration.pitch")
42 |   	.is::<i16>(LittleEndian)
43 |   	.style(Color::Fixed(124).normal()))
44 |   .field(Field::named("acceleration.yaw")
45 |   	.is::<i16>(LittleEndian)
46 |   	.style(Color::Fixed(160).normal()))
47 |   .field(Field::named("acceleration.roll")
48 |   	.is::<i16>(LittleEndian)
49 |   	.style(Color::Fixed(196).normal()))
50 |   .field(Field::named("orientation.pitch")
51 |   	.is::<i16>(LittleEndian)
52 |   	.style(Color::Fixed(57).normal()))
53 |   .field(Field::named("orientation.yaw")
54 |   	.is::<i16>(LittleEndian)
55 |   	.style(Color::Fixed(93).normal()))
56 |   .field(Field::named("orientation.roll")
57 |   	.is::<i16>(LittleEndian)
58 |   	.style(Color::Fixed(129).normal()))
59 |   .field(Field::padding()
60 |   	.bytes(16));
61 | ```
62 | 
63 | Structured
64 | ----------
65 | The structured formatter takes inspiration from the ASCII art tables often used
66 | in network related RFCs.
67 | 
68 | ```rust
69 | formatter::Structured::default()
70 |   .header(true)
71 |   .style(Default::default())
72 |   .format(&def, buffer, io::stdout())
73 |   .unwrap()
74 | ```
75 | 
76 | ![Structured Screenshot](/screenshots/structured.png?raw=true)
77 | 
78 | Inline
79 | ------
80 | The inline formatter is the simplest formatter, it just prints the bytes as
81 | hexadecimal one after another, but it does support coloring which can help
82 | reversing formats.
83 | 
84 | ```rust
85 | formatter::Inline::default()
86 |   .newline(true)
87 |   .split(4)
88 |   .style(Default::default())
89 |   .format(&def, buffer, io::stdout())
90 |   .unwrap()
91 | ```
92 | 
93 | ![Inline Screenshot](/screenshots/inline.png?raw=true)
94 | 


--------------------------------------------------------------------------------
/src/field/named.rs:
--------------------------------------------------------------------------------
  1 | use std::{ptr, mem};
  2 | use std::io::{self, Read};
  3 | use std::any::{Any, TypeId};
  4 | use ansi_term::Style;
  5 | use {Field, Endian};
  6 | 
  7 | #[derive(Clone, PartialEq, Debug)]
  8 | pub struct Named {
  9 | 	bits: usize,
 10 | 
 11 | 	name:   String,
 12 | 	style:  Option<Style>,
 13 | 	binary: bool,
 14 | 
 15 | 	endian: Endian,
 16 | 	kind:   Option<TypeId>,
 17 | }
 18 | 
 19 | impl Named {
 20 | 	pub fn bits(&self) -> usize {
 21 | 		self.bits
 22 | 	}
 23 | 
 24 | 	pub fn name(&self) -> &str {
 25 | 		&self.name
 26 | 	}
 27 | 
 28 | 	pub fn style(&self) -> Option<Style> {
 29 | 		self.style
 30 | 	}
 31 | 
 32 | 	pub fn binary(&self) -> bool {
 33 | 		self.binary
 34 | 	}
 35 | 
 36 | 	pub fn endian(&self) -> Endian {
 37 | 		self.endian
 38 | 	}
 39 | 
 40 | 	pub fn kind(&self) -> Option<TypeId> {
 41 | 		self.kind
 42 | 	}
 43 | 
 44 | 	pub fn read<R: Read>(&self, mut buffer: R) -> io::Result<Vec<u8>> {
 45 | 		let mut data = vec![0u8; super::bytes(self.bits)];
 46 | 		try!(buffer.read(&mut data));
 47 | 
 48 | 		Ok(data)
 49 | 	}
 50 | 
 51 | 	pub fn decode<T: Any, R: Read>(&self, buffer: R) -> io::Result<T> {
 52 | 		if self.kind.is_none() || TypeId::of::<T>() != self.kind.unwrap() {
 53 | 			return Err(io::Error::new(io::ErrorKind::InvalidInput, "type mismatch"));
 54 | 		}
 55 | 
 56 | 		let mut data = try!(self.read(buffer));
 57 | 
 58 | 		if cfg!(target_endian = "big") && self.endian == Endian::Little ||
 59 | 		   cfg!(target_endian = "little") && self.endian == Endian::Big {
 60 | 			data.reverse();
 61 | 		}
 62 | 
 63 | 		Ok(unsafe {
 64 | 			ptr::read(data.as_ptr() as *const _ as *const T)
 65 | 		})
 66 | 	}
 67 | }
 68 | 
 69 | #[derive(Default)]
 70 | pub struct Builder {
 71 | 	bits: Option<usize>,
 72 | 
 73 | 	name:   Option<String>,
 74 | 	style:  Option<Style>,
 75 | 	binary: bool,
 76 | 
 77 | 	endian: Option<Endian>,
 78 | 	kind:   Option<TypeId>,
 79 | }
 80 | 
 81 | impl Builder {
 82 | 	pub fn bits(mut self, value: usize) -> Self {
 83 | 		self.bits = Some(value);
 84 | 		self
 85 | 	}
 86 | 
 87 | 	pub fn bytes(self, value: usize) -> Self {
 88 | 		self.bits(value * 8)
 89 | 	}
 90 | 
 91 | 	pub fn name<T: Into<String>>(mut self, name: T) -> Self {
 92 | 		self.name = Some(name.into());
 93 | 		self
 94 | 	}
 95 | 
 96 | 	pub fn style(mut self, value: Style) -> Self {
 97 | 		self.style = Some(value);
 98 | 		self
 99 | 	}
100 | 
101 | 	pub fn binary(mut self) -> Self {
102 | 		self.binary = true;
103 | 		self
104 | 	}
105 | 
106 | 	pub fn is<T: Any>(mut self, endian: Endian) -> Self {
107 | 		self.bits   = Some(mem::size_of::<T>() * 8);
108 | 		self.endian = Some(endian);
109 | 		self.kind   = Some(TypeId::of::<T>());
110 | 		self
111 | 	}
112 | }
113 | 
114 | impl Into<Field> for Builder {
115 | 	fn into(self) -> Field {
116 | 		Field::Named(Named {
117 | 			bits: self.bits.expect("missing field size"),
118 | 
119 | 			name:   self.name.expect("missing field name"),
120 | 			style:  self.style,
121 | 			binary: self.binary,
122 | 
123 | 			endian: self.endian.unwrap_or(Default::default()),
124 | 			kind:   self.kind,
125 | 		})
126 | 	}
127 | }
128 | 


--------------------------------------------------------------------------------
/src/formatter/inline.rs:
--------------------------------------------------------------------------------
  1 | use std::io::{self, Read, Write};
  2 | use ansi_term;
  3 | use {Formatter, Definition, Field};
  4 | use super::Style;
  5 | 
  6 | /// Inline formatter, just puts bytes one after another as hex.
  7 | #[derive(Clone, Copy, PartialEq, Debug)]
  8 | pub struct Inline {
  9 | 	split:   usize,
 10 | 	newline: bool,
 11 | 	style:   Option<Style>,
 12 | }
 13 | 
 14 | impl Default for Inline {
 15 | 	fn default() -> Self {
 16 | 		Inline {
 17 | 			split:   1,
 18 | 			newline: false,
 19 | 			style:   None,
 20 | 		}
 21 | 	}
 22 | }
 23 | 
 24 | impl Inline {
 25 | 	/// Adds a space every given bytes.
 26 | 	pub fn split(mut self, value: usize) -> Self {
 27 | 		self.split = value;
 28 | 		self
 29 | 	}
 30 | 
 31 | 	/// Whether to print a newline or not at the end.
 32 | 	pub fn newline(mut self, value: bool) -> Self {
 33 | 		self.newline = value;
 34 | 		self
 35 | 	}
 36 | 
 37 | 	/// The default colors, once set it will always color the output.
 38 | 	pub fn style(mut self, value: Style) -> Self {
 39 | 		self.style = Some(value);
 40 | 		self
 41 | 	}
 42 | }
 43 | 
 44 | impl Formatter for Inline {
 45 | 	fn format<R: Read, W: Write>(&self, def: &Definition, mut input: R, output: W) -> io::Result<()> {
 46 | 		let mut printer = Printer { newline: self.newline, split: self.split, printed: 0, output: output };
 47 | 
 48 | 		for field in def.fields() {
 49 | 			match field {
 50 | 				&Field::Named(ref field) => {
 51 | 					try!(printer.print(&try!(field.read(input.by_ref())),
 52 | 						self.style.and(field.style())));
 53 | 				}
 54 | 
 55 | 				&Field::Constant(ref field) => {
 56 | 					let data = try!(field.read(input.by_ref()));
 57 | 
 58 | 					try!(printer.print(&data,
 59 | 						self.style.map(|s| if data == field.value() {
 60 | 							s.constant.0
 61 | 						}
 62 | 						else {
 63 | 							s.constant.1
 64 | 						})));
 65 | 				}
 66 | 
 67 | 				&Field::Garbage(ref field) => {
 68 | 					try!(printer.print(&try!(field.read(input.by_ref())),
 69 | 						self.style.map(|s| s.garbage)));
 70 | 				}
 71 | 
 72 | 				&Field::Unknown(ref field) => {
 73 | 					try!(printer.print(&try!(field.read(input.by_ref())),
 74 | 						self.style.map(|s| s.unknown)));
 75 | 				}
 76 | 
 77 | 				&Field::Padding(ref field) => {
 78 | 					for byte in try!(field.read(input.by_ref())) {
 79 | 						try!(printer.print(&[byte][..],
 80 | 							self.style.map(|s| if byte != 0 {
 81 | 								s.padding.1
 82 | 							}
 83 | 							else {
 84 | 								s.padding.0
 85 | 							})));
 86 | 					}
 87 | 				}
 88 | 			}
 89 | 		}
 90 | 
 91 | 		printer.finish()
 92 | 	}
 93 | }
 94 | 
 95 | struct Printer<W: Write> {
 96 | 	split:   usize,
 97 | 	newline: bool,
 98 | 	printed: usize,
 99 | 	output:  W,
100 | }
101 | 
102 | impl<W: Write> Printer<W> {
103 | 	pub fn print(&mut self, input: &[u8], style: Option<ansi_term::Style>) -> io::Result<()> {
104 | 		for byte in input {
105 | 			let string = format!("{:02x}", byte);
106 | 
107 | 			if let Some(style) = style {
108 | 				try!(write!(self.output, "{}", style.paint(string)));
109 | 			}
110 | 			else {
111 | 				try!(write!(self.output, "{}", string));
112 | 			}
113 | 
114 | 			if self.split > 0 && (self.printed + 1) % self.split == 0 {
115 | 				try!(write!(self.output, " "));
116 | 			}
117 | 
118 | 			self.printed += 1;
119 | 		}
120 | 
121 | 		Ok(())
122 | 	}
123 | 
124 | 	pub fn finish(&mut self) -> io::Result<()> {
125 | 		if self.newline {
126 | 			try!(writeln!(self.output, ""));
127 | 		}
128 | 
129 | 		Ok(())
130 | 	}
131 | }
132 | 


--------------------------------------------------------------------------------
/src/formatter/structured.rs:
--------------------------------------------------------------------------------
  1 | use std::fmt;
  2 | use std::any::{TypeId};
  3 | use std::io::{self, Read, Write};
  4 | use ansi_term;
  5 | use {Formatter, Definition, Field};
  6 | use super::Style;
  7 | 
  8 | /// Structured formatter, like the ones seen in network RFCs.
  9 | #[derive(Clone, Copy, PartialEq, Default, Debug)]
 10 | pub struct Structured {
 11 | 	header: bool,
 12 | 	style:  Option<Style>,
 13 | }
 14 | 
 15 | impl Structured {
 16 | 	/// Whether to print the header or not.
 17 | 	pub fn header(mut self, value: bool) -> Self {
 18 | 		self.header = value;
 19 | 		self
 20 | 	}
 21 | 
 22 | 	/// The default colors, once set it will always color the output.
 23 | 	pub fn style(mut self, value: Style) -> Self {
 24 | 		self.style = Some(value);
 25 | 		self
 26 | 	}
 27 | }
 28 | 
 29 | impl Formatter for Structured {
 30 | 	fn format<R: Read, W: Write>(&self, def: &Definition, mut input: R, mut output: W) -> io::Result<()> {
 31 | 		if self.header {
 32 | 			try!(writeln!(output, " 0                   1                   2                   3"));
 33 | 			try!(writeln!(output, " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1"));
 34 | 			try!(writeln!(output, "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"));
 35 | 		}
 36 | 
 37 | 		let mut printer = Printer { consumed: 0, padding: 0, output: output.by_ref() };
 38 | 
 39 | 		for field in def.fields() {
 40 | 			match field {
 41 | 				&Field::Named(ref field) => {
 42 | 					let kind  = field.kind().unwrap_or(TypeId::of::<()>());
 43 | 					let style = self.style.and(field.style());
 44 | 
 45 | 					if kind == TypeId::of::<u8>() {
 46 | 						try!(printer.print(field.decode::<u8, _>(input.by_ref()).unwrap(),
 47 | 							field.bits(), style));
 48 | 					}
 49 | 					else if kind == TypeId::of::<u16>() {
 50 | 						try!(printer.print(field.decode::<u16, _>(input.by_ref()).unwrap(),
 51 | 							field.bits(), style));
 52 | 					}
 53 | 					else if kind == TypeId::of::<u32>() {
 54 | 						try!(printer.print(field.decode::<u32, _>(input.by_ref()).unwrap(),
 55 | 							field.bits(), style));
 56 | 					}
 57 | 					else if kind == TypeId::of::<i8>() {
 58 | 						try!(printer.print(field.decode::<i8, _>(input.by_ref()).unwrap(),
 59 | 							field.bits(), style));
 60 | 					}
 61 | 					else if kind == TypeId::of::<i16>() {
 62 | 						try!(printer.print(field.decode::<i16, _>(input.by_ref()).unwrap(),
 63 | 							field.bits(), style));
 64 | 					}
 65 | 					else if kind == TypeId::of::<i32>() {
 66 | 						try!(printer.print(field.decode::<i32, _>(input.by_ref()).unwrap(),
 67 | 							field.bits(), style));
 68 | 					}
 69 | 					else if field.binary() {
 70 | 						try!(printer.binary(&try!(field.read(input.by_ref())),
 71 | 							field.bits(), style));
 72 | 					}
 73 | 					else {
 74 | 						try!(printer.hex(&try!(field.read(input.by_ref())),
 75 | 							field.bits(), style));
 76 | 					}
 77 | 				}
 78 | 
 79 | 				&Field::Constant(ref field) => {
 80 | 					let data = try!(field.read(input.by_ref()));
 81 | 
 82 | 					if data == field.value() {
 83 | 						try!(printer.hex(&data,
 84 | 							field.bits(), self.style.map(|s| s.constant.0)));
 85 | 					}
 86 | 					else {
 87 | 						try!(printer.hex(&data,
 88 | 							field.bits(), self.style.map(|s| s.constant.1)));
 89 | 					}
 90 | 				}
 91 | 
 92 | 				&Field::Garbage(ref field) => {
 93 | 					try!(printer.hex(&try!(field.read(input.by_ref())),
 94 | 						field.bits(), self.style.map(|s| s.garbage)));
 95 | 				}
 96 | 
 97 | 				&Field::Unknown(ref field) => {
 98 | 					try!(printer.hex(&try!(field.read(input.by_ref())),
 99 | 						field.bits(), self.style.map(|s| s.unknown)));
100 | 				}
101 | 
102 | 				&Field::Padding(ref field) => {
103 | 					for byte in try!(field.read(input.by_ref())) {
104 | 						if byte != 0 {
105 | 							try!(printer.byte(byte, self.style.map(|s| s.padding.1)));
106 | 						}
107 | 						else {
108 | 							try!(printer.pad());
109 | 						}
110 | 					}
111 | 				}
112 | 			}
113 | 		}
114 | 
115 | 		printer.finish()
116 | 	}
117 | }
118 | 
119 | struct Printer<W: Write> {
120 | 	consumed: usize,
121 | 	padding:  usize,
122 | 	output:   W,
123 | }
124 | 
125 | impl<W: Write> Printer<W> {
126 | 	fn remaining(&self) -> usize {
127 | 		32 - (self.consumed % 32)
128 | 	}
129 | 
130 | 	fn space(string: &str, width: usize) -> (usize, usize) {
131 | 		let rem  = width - string.len();
132 | 		let half = if rem % 2 == 0 { rem / 2 } else { (rem - 1) / 2 };
133 | 
134 | 		if rem % 2 == 0 {
135 | 			(half, half)
136 | 		}
137 | 		else {
138 | 			(half + 1, half)
139 | 		}
140 | 	}
141 | 
142 | 	pub fn pad(&mut self) -> io::Result<()> {
143 | 		self.padding += 1;
144 | 
145 | 		if self.padding > 1 && self.consumed % 32 != 0 {
146 | 			try!(write!(self.output, " "));
147 | 		}
148 | 		else {
149 | 			try!(write!(self.output, "|"));
150 | 		}
151 | 
152 | 		try!(write!(self.output, "{: ^15}", ""));
153 | 
154 | 		self.done(8)
155 | 	}
156 | 
157 | 	pub fn byte(&mut self, data: u8, style: Option<ansi_term::Style>) -> io::Result<()> {
158 | 		self.hex(&[data][..], 8, style)
159 | 	}
160 | 
161 | 	pub fn binary(&mut self, data: &[u8], bits: usize, style: Option<ansi_term::Style>) -> io::Result<()> {
162 | 		self.print({
163 | 			let mut out = String::with_capacity(data.len() * 8);
164 | 
165 | 			for byte in data {
166 | 				out.push_str(&format!("{:08b}", byte));
167 | 			}
168 | 
169 | 			out.pop();
170 | 			out
171 | 		}, bits, style)
172 | 	}
173 | 
174 | 	pub fn hex(&mut self, mut data: &[u8], mut bits: usize, style: Option<ansi_term::Style>) -> io::Result<()> {
175 | 		let remaining = self.remaining();
176 | 
177 | 		if bits > remaining {
178 | 			try!(self.hex(&data[.. remaining / 8], remaining, style));
179 | 			data  = &data[remaining / 8 ..];
180 | 			bits -= remaining;
181 | 		}
182 | 
183 | 		if bits > 32 {
184 | 			for data in data.chunks(4) {
185 | 				try!(self.hex(data, data.len() * 8, style));
186 | 			}
187 | 
188 | 			return Ok(());
189 | 		}
190 | 
191 | 		self.print({
192 | 			let mut out = String::with_capacity(data.len() * 3);
193 | 
194 | 			for byte in data {
195 | 				out.push_str(&format!("{:02x} ", byte));
196 | 			}
197 | 
198 | 			out.pop();
199 | 			out
200 | 		}, bits, style)
201 | 	}
202 | 
203 | 	pub fn print<T: fmt::Display>(&mut self, data: T, bits: usize, style: Option<ansi_term::Style>) -> io::Result<()> {
204 | 		let remaining = self.remaining();
205 | 		let string    = data.to_string();
206 | 		let width;
207 | 
208 | 		if bits > remaining {
209 | 			if bits - remaining > remaining {
210 | 				for _ in 0 .. (remaining / 8) {
211 | 					try!(self.pad())
212 | 				}
213 | 
214 | 				width = (bits - remaining) * 2 - 1;
215 | 			}
216 | 			else {
217 | 				width = remaining * 2 - 1;
218 | 			}
219 | 		}
220 | 		else {
221 | 			width = bits * 2 - 1;
222 | 		}
223 | 
224 | 		let (left, right) = Self::space(&string, width);
225 | 
226 | 		try!(write!(self.output, "|"));
227 | 		try!(write!(self.output, "{: ^1$}", "", left));
228 | 
229 | 		if let Some(style) = style {
230 | 			try!(write!(self.output, "{}", style.paint(string)));
231 | 		}
232 | 		else {
233 | 			try!(write!(self.output, "{}", string));
234 | 		}
235 | 
236 | 		try!(write!(self.output, "{: ^1$}", "", right));
237 | 
238 | 		self.padding = 0;
239 | 
240 | 		if bits > remaining {
241 | 			if bits - remaining <= remaining {
242 | 				try!(self.done((width + 1) / 2));
243 | 
244 | 				for _ in 0 .. ((bits - remaining) / 8) {
245 | 					try!(self.pad());
246 | 				}
247 | 			}
248 | 			else {
249 | 				try!(self.done(bits));
250 | 			}
251 | 		}
252 | 		else {
253 | 			try!(self.done(bits));
254 | 		}
255 | 
256 | 		Ok(())
257 | 	}
258 | 
259 | 	pub fn finish(&mut self) -> io::Result<()> {
260 | 		if self.consumed % 32 == 0 {
261 | 			return Ok(());
262 | 		}
263 | 
264 | 		try!(writeln!(self.output, "|"));
265 | 
266 | 		for _ in 0 .. (self.consumed % 32) {
267 | 			try!(write!(self.output, "+-"));
268 | 		}
269 | 
270 | 		try!(writeln!(self.output, "+"));
271 | 
272 | 		Ok(())
273 | 	}
274 | 
275 | 	fn done(&mut self, bits: usize) -> io::Result<()> {
276 | 		self.consumed += bits;
277 | 
278 | 		if self.consumed % 32 == 0 {
279 | 			try!(writeln!(self.output, "|"));
280 | 			try!(writeln!(self.output, "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"));
281 | 		}
282 | 
283 | 		Ok(())
284 | 	}
285 | }
286 | 


--------------------------------------------------------------------------------